How can I crop an image to remove white space using Python and OpenCV?

Approach:

1. threshold -> obtain mask
2. use boundingRect() on the mask
3. crop

PYTHONCopied
im = cv.imread("Cb768fyr.jpg")
gray = cv.cvtColor(im, cv.COLOR_BGR2GRAY)

th = 240 # 255 won't do, the image's background isn't perfectly white
(th, mask) = cv.threshold(gray, th, 255, cv.THRESH_BINARY_INV)

(x, y, w, h) = cv.boundingRect(mask)

pad = 0 # increase to give it some border
cropped = im[y-pad:y+h+pad, x-pad:x+w+pad]

Why threshold at all? Because cv.boundingRect() would otherwise treat all non-zero pixels as "true", i.e. the background would be considered foreground.

Why threshold with something other than 255? The background isn't perfectly white, due to the source image having been compressed lossily. If you did, that would be the result:

---

If you wanted to replace cv.boundingRect(), you can do it like this:

1. max-reduce mask along each axis in turn
2. find first and last index of positive values

PYTHONCopied
xproj = np.max(mask, axis=1) # collapse X, have Y
ymin = np.argmax(xproj)
ymax = len(xproj) - np.argmax(xproj[::-1])
print(f"{ymin=}, {ymax=}")

yproj = np.max(mask, axis=0)
xmin = np.argmax(yproj)
xmax = len(yproj) - np.argmax(yproj[::-1])
print(f"{xmin=}, {xmax=}")

cropped = im[ymin-pad:ymax+pad, xmin-pad:xmax+pad]

This could also use np.argwhere(). I won't bother comparing these two approaches since cv.boundingRect() does the job already.

---

The findContours approach will pick any connected component, not all of them. This means it could sometimes pick the triad (bottom left) or text (top left), and entirely discard most of the image.

You could fix that by slapping a convex hull on all the contours, but you'd still have to call boundingRect() anyway. So, all the contour stuff is wasted effort.

Assuming you want to also get rid of the small structures in the upper left and lower left corners, you can do the following:

• Use cv2.connectedComponentsWithStats() to find all connected components, together with their statistics (area, bounding box, center; see this answer for and explanation of the returned results).
• Get mask and rectangle of component with largest area (ignoring the background component at index 0).
• Fill everything that does not belong to the component's mask with white.
• Crop with component's rectangle.

Code:

PYTHONCopied
import cv2

in_path = "stackoverflow/car.jpg"  # TODO: Adjust as necessary
out_path = "stackoverflow/cropped.png"  # TODO: Adjust as necessary

image = cv2.imread(in_path)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
_, mask = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)

# Following https://stackoverflow.com/a/35854198/7395592
_, labels, stats, _ = cv2.connectedComponentsWithStats(mask)
# Ignore label 0, which is the background
stats = stats[1:]
# Get mask and rectangle (columns 0–3) for region with largest area (column 4)
row_idx_largest = stats[:, -1].argmax()
mask_largest = (labels == row_idx_largest + 1)  # +1: we cropped background row
x, y, w, h, _ = stats[row_idx_largest]

# Fill everything outside the largest region with white, then crop
image[~mask_largest] = 255
cropped_image = image[y:y+h, x:x+w]
cv2.imwrite(out_path, cropped_image)

Resulting image:

You can solve the problem by doing sort of "raycasting". To find the top edge you would measure where the topmost non-white pixel is in the first column. Then repeat for the second column and third etc.

The smallest of these values (i.e. the topmost) defines the top edge. You then repeat the process for the other sides.

Below is sample code demonstrating the idea.

PYTHONCopied
import cv2
import numpy as np

def crop_empty_spaces(image_path):
    # Load the image
    image = cv2.imread(image_path)
    
    # Convert to grayscale
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Apply a binary threshold to identify non-empty (non-white) areas
    _, thresh = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)
    
    # Find contours
    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # Get the bounding box of the largest contour
    if contours:
        x, y, w, h = cv2.boundingRect(contours[0])
        cropped_image = image[y:y+h, x:x+w]
        return cropped_image
    else:
        return image  # Return original if no contours found

# Example usage
image_path = '/mnt/data/Untitled.png'  # Update with your file path
cropped_image = crop_empty_spaces(image_path)
cv2.imwrite('/mnt/data/cropped_output.png', cropped_image)