如何基于OpenCV实现堆叠纸箱计数算法？阈值不可硬编码

Hey there! Let's tackle this carton counting problem you're working on. It sounds like the main headache right now is filtering out those text edges while keeping the carton boundaries intact—totally relatable, since tiny text edges can mess up line detection big time. Here are some targeted preprocessing techniques to fix this, tailored to your existing workflow:

1. Targeted Morphological Operations (Better Than Generic Dilation/Erosion) #

Text edges are usually thinner and shorter than the thick, long horizontal edges of stacked cartons. Instead of using square kernels that blur everything, use a horizontal-structured kernel to selectively reinforce carton edges and suppress text:

# Create a horizontal kernel (long and narrow) to target horizontal carton edges
horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 1))
# Apply closing operation (dilate then erode) to fill gaps in horizontal edges, ignoring small vertical text edges
img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, horizontal_kernel, iterations=1)

This will strengthen the horizontal lines of the cartons while leaving most text edges untouched (or weakened enough to be ignored later).

2. Filter Short Edges Before Hough Line Detection #

After running Canny, text edges will show up as tiny, disconnected contours. You can filter these out by keeping only contours above a minimum length:

# Get contours from the Canny edge map
contours, _ = cv2.findContours(canny, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# Create a blank mask to keep only long edges
filtered_edges = np.zeros_like(canny)
for cnt in contours:
    # Adjust the threshold (50) based on your image size; make it larger to filter more small edges
    if cv2.arcLength(cnt, False) > 50:
        cv2.drawContours(filtered_edges, [cnt], 0, 255, 1)
# Use this filtered edge map for Hough Line detection instead of the raw Canny output
lines = cv2.HoughLinesP(filtered_edges, 1, np.pi / 200, 90, minLineLength=20, maxLineGap=10)

This step eliminates most text edges before they even reach your line extraction code, reducing noise drastically.

3. Gradient Direction Filtering (Focus on Horizontal Edges) #

Carton edges are mostly horizontal, so their gradient direction (perpendicular to the edge) will be vertical. Text edges have chaotic gradient directions, so we can filter for only vertical gradients:

# Calculate x and y gradients using Sobel
sobel_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3)
# Compute gradient magnitude and direction
magnitude = np.sqrt(sobel_x**2 + sobel_y**2)
direction = np.arctan2(np.abs(sobel_y), np.abs(sobel_x)) * 180 / np.pi
# Keep only gradients with direction close to 90° (vertical gradients = horizontal edges)
# Adjust the range (80-100) if needed for your images
mask = (direction >= 80) & (direction <= 100)
filtered_magnitude = np.zeros_like(magnitude)
filtered_magnitude[mask] = magnitude[mask]
# Normalize to 0-255 for Canny
filtered_magnitude = cv2.normalize(filtered_magnitude, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
# Run Canny on the filtered gradient map
canny = cv2.Canny(filtered_magnitude, 30, 120)

This method directly targets the edges you care about (horizontal carton lines) and discards everything else.

4. Color Channel Tweaking (Leverage HSV Space) #

Even though you can't hardcode color thresholds, text often has different saturation than the carton surface. Using the saturation channel from HSV can help suppress text:

# Convert your original color image to HSV
hsv = cv2.cvtColor(original_img, cv2.COLOR_BGR2HSV)
s_channel = hsv[:,:,1]  # Saturation channel
# Blur the saturation channel to soften text edges
s_blur = cv2.GaussianBlur(s_channel, (5,5), 0)
# Use this blurred saturation channel as your input for subsequent steps (instead of grayscale)
img = s_blur

Text edges tend to be high-contrast in saturation, so blurring this channel will reduce their prominence while keeping carton edges sharp.

Final Tip: Combine Techniques #

For best results, stack a few of these methods:

1. Start with the HSV saturation blur to weaken text.
2. Apply the horizontal kernel closing to reinforce carton edges.
3. Run Canny, then filter short contours.
4. Proceed with your existing Hough Line extraction and K-means clustering.

This should give you clean horizontal lines that accurately represent each carton layer, making your counting algorithm reliable.

内容的提问来源于stack exchange，提问作者PaKheng Chan