Python/OpenCV：如何从条形码图像数据推断最优结构元素？

Got it, let's walk through a practical, step-by-step solution to reconstruct the original computer-generated barcode pixel array from those degraded photos. Your plan to use spatial frequency for pixel size inference and optimal structuring elements is spot-on for handling blur, distortion, and corrosion issues.

1. Preprocess the Image to Fix Lighting & Contrast #

First, we need to clean up the input image to reduce the impact of lighting gradients and poor contrast. Start by converting to grayscale, then use adaptive thresholding or CLAHE to normalize brightness:

import cv2
import numpy as np

# Load and convert to grayscale
img = cv2.imread("degraded_barcode.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Fix lighting gradients with CLAHE
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
clahe_gray = clahe.apply(gray)

# Adaptive thresholding to get a binary image
binary = cv2.adaptiveThreshold(
    clahe_gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2
)

This step flattens uneven lighting and makes the barcode's black/white transitions clearer—critical for accurate frequency analysis later.

2. Infer Single Pixel Size Using Spatial Frequency #

Barcodes have periodic black/white patterns, so we can use Fourier Transform to find the dominant spatial frequency, then calculate the corresponding pixel size in the input image.

# Compute 1D Fourier Transform (focus on horizontal axis, since barcodes are vertical)
fourier = np.fft.fft(binary.mean(axis=0))  # Average vertical pixels to get horizontal profile
freqs = np.fft.fftfreq(len(fourier))

# Find the dominant frequency (ignore DC component at index 0)
magnitudes = np.abs(fourier)
dominant_freq_idx = np.argmax(magnitudes[1:]) + 1
dominant_freq = abs(freqs[dominant_freq_idx])

# Calculate single barcode pixel size in input image pixels
# Dominant frequency = 1 / (barcode pixel width * 2) (each bar+space is a cycle)
barcode_pixel_size = int(round(1 / (2 * dominant_freq)))
print(f"Inferred single barcode pixel size: {barcode_pixel_size} input pixels")

The barcode's repeating bar-space pairs create a strong peak in the frequency spectrum. We convert that peak to the physical width of one barcode pixel in the input image.

3. Determine Optimal Structuring Element for Morphological Restoration #

Now that we know how many input pixels correspond to one barcode pixel, we can create a structuring element that matches this size. This fixes blur and corrosion without over-smoothing the barcode structure:

# Create structuring element: square matching the inferred barcode pixel size
struct_element = cv2.getStructuringElement(cv2.MORPH_RECT, (barcode_pixel_size, barcode_pixel_size))

# Use closing to fill corrosion gaps, then opening to remove small noise/blur artifacts
restored_binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, struct_element)
restored_binary = cv2.morphologyEx(restored_binary, cv2.MORPH_OPEN, struct_element)

• Closing (dilation followed by erosion) fills in small holes/corroded areas in barcode bars.
• Opening (erosion followed by dilation) removes tiny noise specks and smooths blurry edges.

4. Correct Distortion (Optional but Critical) #

If your images have perspective distortion, warp the image to a flat rectangle first. Here's how to detect the barcode's contour and apply perspective correction:

# Find contours to locate the barcode
contours, _ = cv2.findContours(restored_binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
barcode_contour = max(contours, key=cv2.contourArea)

# Approximate the contour to a quadrilateral
peri = cv2.arcLength(barcode_contour, True)
approx = cv2.approxPolyDP(barcode_contour, 0.02 * peri, True)

# Define source and destination points for perspective warp
src_pts = np.float32(approx)
# Sort points to get top-left, top-right, bottom-right, bottom-left
src_pts = src_pts[np.argsort(src_pts[:, 0, 0])]
if src_pts[0,0,1] > src_pts[1,0,1]:
    src_pts[0], src_pts[1] = src_pts[1], src_pts[0]
if src_pts[2,0,1] < src_pts[3,0,1]:
    src_pts[2], src_pts[3] = src_pts[3], src_pts[2]

# Destination points: flat rectangle aligned with inferred pixel size
barcode_width = int(round(cv2.norm(src_pts[0] - src_pts[1]) / barcode_pixel_size)) * barcode_pixel_size
barcode_height = int(round(cv2.norm(src_pts[1] - src_pts[2]) / barcode_pixel_size)) * barcode_pixel_size
dst_pts = np.float32([[0,0], [barcode_width,0], [barcode_width,barcode_height], [0,barcode_height]])

# Apply perspective warp
matrix = cv2.getPerspectiveTransform(src_pts, dst_pts)
corrected_img = cv2.warpPerspective(restored_binary, matrix, (barcode_width, barcode_height))

5. Reconstruct the Original Barcode Pixel Array #

Finally, resize the corrected image to the actual barcode dimensions (based on the inferred pixel size) to get the raw black/white pixel array:

# Calculate original barcode dimensions
original_width = barcode_width // barcode_pixel_size
original_height = barcode_height // barcode_pixel_size

# Resize to get the original pixel array (nearest neighbor preserves sharp edges)
original_barcode = cv2.resize(corrected_img, (original_width, original_height), interpolation=cv2.INTER_NEAREST)

# Convert to 0/1 pixel array (0 = black, 1 = white)
barcode_array = (original_barcode == 255).astype(int)
print(f"Reconstructed barcode array shape: {barcode_array.shape}")

This array matches the original computer-generated barcode's pixel structure, ready for decoding or further processing.

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