Detect white background on images using python

Question

Is there a way to tell whether an image as a white background using python and what could be a good strategy to get a "percentage of confidence" about this question? Seems like the literature on internet doesn't cover exactly this case and I can't find anything strictly related.

The images I want to analyze are typical e-commerce website product pictures, so they should have a single focused object in the middle and white background only at the borders.

Another information that could be available is the max percentage of image space the object should occupy.

Answer 1

This question may be years ago but I just had a similar task recently. Sharing my answer here might help others that will encounter the same task too and I might also improve my answer by having the community look at it.

import cv2 as cv
import numpy as np

THRESHOLD_INTENSITY = 230

def has_white_background(img):
    # Read image into org_img variable
    org_img = cv.imread(img, cv.IMREAD_GRAYSCALE)
    # cv.imshow('Original Image', org_img)

    # Create a black blank image for the mask
    mask = np.zeros_like(org_img)

    # Create a thresholded image, I set my threshold to 200 as this is the value 
    # I found most effective in identifying light colored object
    _, thres_img = cv.threshold(org_img, 200, 255, cv.THRESH_BINARY_INV)

    # Find the most significant contours
    contours, hierarchy = cv.findContours(thres_img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)
    # Get the outermost contours
    outer_contours_img = max(contours, key=cv.contourArea)

    # Get the bounding rectangle of the contours
    x,y,w,h = cv.boundingRect(outer_contours_img)
    # Draw a rectangle base on the bounding rectangle of the contours to our mask
    cv.rectangle(mask,(x,y),(x+w,y+h),(255,255,255),-1)
    # Invert the mask so that we create a hole for the detected object in our mask
    mask = cv.bitwise_not(mask)

    # Apply mask to the original image to subtract it and retain only the bg
    img_bg = cv.bitwise_and(org_img, org_img, mask=mask)

    # If the size of the mask is similar to the size of the image then the bg is not white
    if h == org_img.shape[0] and w == org_img.shape[1]:
        return False

    # Create a np array of the 
    np_array = np.array(img_bg)

    # Remove the zeroes from the "remaining bg image" so that we dont consider the black part,
    # and find the average intensity of the remaining pixels
    ave_intensity = np_array[np.nonzero(np_array)].mean()

    if ave_intensity > THRESHOLD_INTENSITY:
        return True
    else:
        return False

These are the images of the steps from the code above:

Here is the Original Image. No copyright infringement intended. (Cant find the url of the actual imagem from unsplash)

First step is to convert the image to grayscale.

Apply thresholding to the image.

Get the contours of the "thresholded" image and get the contours. Drawing the contours is optional only.

From the contours, get the values of the outer contour and find its bounding rectangle. Optionally draw the rectangle to the image so that you'll see if your assumed thresholding value fits the object in the rectangle.

Create a mask out of the bounding rectangle.

Lastly, subtract the mask to the greyscale image. What will remain is the background image minus the mask.

To Finally identify if the background is white, find the average intensity values of the background image excluding the 0 values of the image array. And base on a certain threshold value, categorize it if its white or not.

Hope this helps. If you think it can still be improve, or if there are flaws with my solution pls comment below.

Answer 2

I would go with something like this.

1. Reduce the contrast of the image by making the brightest, whitest pixel something like 240 instead of 255 so that the whites generally found within the image and within parts of the product are no longer pure white.

2. Put a 1 pixel wide white border around your image - that will allow the floodfill in the next step to "flow" all the way around the edge (even if the "product" touches the edges of the frame) and "seep" into the image from all borders/edges.

3. Floofdill your image starting at the top-left corner (which is necessarily pure white after step 2) and allow a tolerance of 10-20% when matching the white in case the background is off-white or slightly shadowed, and the white will flow into your image all around the edges until it reaches the product in the centre.

4. See how many pure white pixels you have now - these are the background ones. The percentage of pure white pixels will give you an indicator of confidence in the image being a product on a whitish background.

I would use ImageMagick from the command line like this:

convert product.jpg +level 5% -bordercolor white -border 1 \
  -fill white -fuzz 25% -draw "color 0,0 floodfill" result.jpg

I will put a red border around the following 2 pictures just so you can see the edges on StackOverflow's white background, and show you the before and after images - look at the amount of white in the resulting images (there is none in the second one because it didn't have a white background) and also at the shadow under the router to see the effect of the -fuzz.

Before

After

If you want that as a percentage, you can make all non-white pixels black and then calculate the percentage of white pixels like this:

convert product.jpg -level 5%                                      \
   -bordercolor white -border 1                                    \
   -fill white -fuzz 25% -draw "color 0,0 floodfill" -shave 1      \
   -fuzz 0 -fill black +opaque white -format "%[fx:int(mean*100)]" info:
62

Before

After

ImageMagick has Python bindings so you could do the above in Python - or you could use OpenCV and Python to implement the same algorithm.

Answer 3

The most popular image format is .png. PNG image can have a transparent color (alpha). Often match with the white background page. With pillow is easy to find out which pixels are transparent.

A good starting point:

from PIL import Image

img = Image.open('image.png')
img = img.convert("RGBA")

pixdata = img.load()

for y in xrange(img.size[1]):
    for x in xrange(img.size[0]):
        pixel = pixdata[x, y]
        if pixel[3] == 255:
           # tranparent....

Or maybe it's enough if you check if top-left pixel it's white:

pixel = pixdata[0, 0]
if item[0] == 255 and item[1] == 255 and item[2] == 255:
   # it's white