图像中虚线识别技术咨询：现有傅里叶变换方案失效，寻求改进建议与替代方法

Great question—detecting those subtle Excel selection dashed lines can be tricky, especially when dealing with variable filter sizes or inconsistent periodic signals. Let's break down why your current Fourier transform approach might be falling short, then walk through actionable improvements and alternative techniques that should work better.

Why Your Current Approach Might Not Be Working #

• Weak Preprocessing: The Laplacian filter alone might not be enough to isolate the dashed line edges from the rest of the image. The signal going into the FFT could be too noisy or low-contrast, making it hard to pick out the periodic peak.
• Ignoring DC Component: The FFT's largest power peak is often the DC component (zero frequency, corresponding to the average brightness of the window). You're currently picking this peak sometimes, which throws off your frequency detection.
• Window/Stride Tuning: A fixed 30-pixel window might not align well with the dashed line's period, reducing the FFT's frequency resolution. Your stride could also be skipping over small segments of the line.

Improved Fourier Transform Approach #

Let's tweak your code to address these issues:

1. Better Preprocessing: Use Canny edge detection instead of just Laplacian to isolate the dashed line edges clearly.
2. Exclude DC Component: Skip the zero-frequency bin when looking for the dominant periodic signal.
3. Post-Processing: Add a morphological close operation to clean up the mask and fill small gaps.

Here's the revised code:

import cv2
import numpy as np

img = cv2.imread('test.png')
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow('Original Gray', imgGray)

# Step 1: Use Canny edge detection to highlight dashed line edges
edges = cv2.Canny(imgGray, 50, 150)
cv2.imshow('Canny Edges', edges)

rows, cols = edges.shape
maskImage = np.full((rows, cols), 0, dtype=np.uint8)

dashLineSearchInterval = 30
fminPixel = 7  # Smallest dashed line period (higher frequency)
fmaxPixel = 9  # Largest dashed line period (lower frequency)
stride = 2

# Process horizontal dashed lines (row-wise)
for y in range(0, rows - dashLineSearchInterval, stride):
    for x in range(0, cols - dashLineSearchInterval, stride):
        kX = edges[y, x:x+dashLineSearchInterval].copy()
        kX = kX - np.mean(kX)  # Remove DC offset
        
        N = dashLineSearchInterval
        freq = np.fft.fftfreq(N)
        ft = np.fft.fft(kX)
        power = ft.real**2 + ft.imag**2
        
        # Skip DC component to focus on periodic signals
        non_zero_freq_idx = np.where(freq != 0)[0]
        if len(non_zero_freq_idx) == 0:
            continue
        
        # Find the dominant frequency among non-DC components
        maxPowerIdx = non_zero_freq_idx[np.argmax(power[non_zero_freq_idx])]
        domFreq = abs(freq[maxPowerIdx])
        
        # Check if frequency falls within our target range
        if (1/fmaxPixel) <= domFreq <= (1/fminPixel):
            maskImage[y, x:x+dashLineSearchInterval] = 255

# Process vertical dashed lines (column-wise)
for x in range(0, cols - dashLineSearchInterval, stride):
    for y in range(0, rows - dashLineSearchInterval, stride):
        kY = edges[y:y+dashLineSearchInterval, x].copy()
        kY = kY - np.mean(kY)
        
        N = dashLineSearchInterval
        freq = np.fft.fftfreq(N)
        ft = np.fft.fft(kY)
        power = ft.real**2 + ft.imag**2
        
        non_zero_freq_idx = np.where(freq != 0)[0]
        if len(non_zero_freq_idx) == 0:
            continue
        
        maxPowerIdx = non_zero_freq_idx[np.argmax(power[non_zero_freq_idx])]
        domFreq = abs(freq[maxPowerIdx])
        
        if (1/fmaxPixel) <= domFreq <= (1/fminPixel):
            maskImage[y:y+dashLineSearchInterval, x] = 255

# Clean up the mask with morphological closing
kernel = np.ones((3,3), np.uint8)
maskImage = cv2.morphologyEx(maskImage, cv2.MORPH_CLOSE, kernel)
cv2.imshow('Final Mask', maskImage)
cv2.waitKey(0)
cv2.destroyAllWindows()

Alternative Technique: Template Matching #

Since Excel's selection dashed lines have a consistent pattern (short segments separated by gaps), template matching can be a simpler, more reliable approach. You create a template that matches the dashed line's period, then search the image for matches.

import cv2
import numpy as np

# Create templates matching Excel's dashed line pattern (adjust segment/gap lengths if needed)
# Horizontal template: 16-pixel window with two 3-pixel bright segments (period ~8 pixels)
template_h = np.zeros((1, 16), dtype=np.uint8)
template_h[0, 0:3] = 255
template_h[0, 8:11] = 255

# Vertical template: same pattern, rotated
template_v = np.zeros((16, 1), dtype=np.uint8)
template_v[0:3, 0] = 255
template_v[8:11, 0] = 255

img = cv2.imread('test.png')
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(imgGray, 50, 150)

# Match horizontal template
res_h = cv2.matchTemplate(edges, template_h, cv2.TM_CCOEFF_NORMED)
threshold = 0.7  # Adjust based on your image contrast
loc_h = np.where(res_h >= threshold)

# Match vertical template
res_v = cv2.matchTemplate(edges, template_v, cv2.TM_CCOEFF_NORMED)
loc_v = np.where(res_v >= threshold)

# Build the mask
mask = np.zeros_like(imgGray)
# Mark horizontal matches
for pt in zip(*loc_h[::-1]):
    cv2.rectangle(mask, pt, (pt[0] + 16, pt[1] + 1), 255, -1)
# Mark vertical matches
for pt in zip(*loc_v[::-1]):
    cv2.rectangle(mask, pt, (pt[0] + 1, pt[1] + 16), 255, -1)

cv2.imshow('Template Match Mask', mask)
cv2.waitKey(0)
cv2.destroyAllWindows()

Bonus Tips #

• Adjust Thresholds: For Canny edge detection and template matching, tweak the threshold values to fit your specific image's brightness/contrast.
• Resize Images: If your image is very large, downscale it slightly to speed up processing without losing the dashed line pattern.
• Hough Transform: For longer dashed lines, you could use the Hough Line Transform to detect line segments, then analyze their spacing to identify dashed patterns.

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