Fix fundamental frequency detection.

home/xword.py

     return cv2.warpPerspective(img, m, (int(longest), int(longest)))
 
 
-def get_fundamental_frequency(ffts):
-    all_peak_indexes = []
-    max_peak_count = None
-    f_est = None
-    for fft in ffts:
-        # Use the upper half of the fft array, since this seems to always exclude the DC component.
-        peak_indexes = peakutils.indexes(np.flip(abs(fft[len(fft) // 2:])), thres=0.3)
-        peak_count = len(peak_indexes)
-        if peak_count < 1:
-            return None
-        if (max_peak_count is None) or (peak_count > max_peak_count):
-            max_peak_count = peak_count
-            f_est = round(peak_indexes[peak_count - 1] / peak_count)
-        all_peak_indexes.append(peak_indexes)
-
-    if f_est < 2:
-        return None
-
-    min_err = None
-    f = None
-    for delta in range(-2, 3):
-        err = 0
-        f_current = f_est + delta
-        for peak_indexes in all_peak_indexes:
-            for i, peak_index in enumerate(peak_indexes):
-                err += (peak_index - f_current * (i + 1)) ** 2
-        if (min_err is None) or (err < min_err):
-            min_err = err
-            f = f_current
-
-    return int(f)
+def get_fundamental_frequency(fft):
+    mag = abs(fft[0:len(fft) // 2])
+    mag[0] = 0
+    return int(np.argmax(mag))
 
 
 def get_threshold_from_quantile(img, quantile):
     gaussian_blur_size=11,
     adaptive_threshold_block_size=11,
     adaptive_threshold_mean_adjustment=2,
-    not_square=False,
+    square=True,
     num_dilations=1,
     contour_erosion_kernel_size=5,
     contour_erosion_iterations=5,
     grid_square_size=64,
     grid_border_size=20,
 ):
+    warnings = []
+
     original = cv2.imread(file_name, cv2.IMREAD_GRAYSCALE)
     if original is None:
         raise RuntimeError("Failed to load image")
     row_fft = np.fft.fft(np.sum(horiz_lines, axis=1))
     col_fft = np.fft.fft(np.sum(vert_lines, axis=0))
 
-    if not_square:
-        num_rows = get_fundamental_frequency([row_fft])
-        num_cols = get_fundamental_frequency([col_fft])
-    else:
-        num_rows = num_cols = get_fundamental_frequency([row_fft, col_fft])
+    num_rows = get_fundamental_frequency(row_fft)
+    num_cols = get_fundamental_frequency(col_fft)
+    if square and (num_rows != num_cols):
+        warnings.append("Crossword is not square")
 
     block_img = extract_square(original, top_left, top_right, bottom_right, bottom_left)
 
 
     grid_colours = extract_grid_colours(block_img, num_rows, num_cols, sampling_block_size_ratio)
     warning, grid = grid_colours_to_blocks(grid_colours, num_rows, num_cols, sampling_threshold)
+    if warning:
+        warnings.append("Some blocks may be the wrong colour")
 
     step = grid_square_size + grid_line_thickness
     grid_height = num_rows * step + grid_line_thickness
                 cv2.rectangle(output, (x, y), (x + grid_square_size - 1, y + grid_square_size - 1), 255, -1)
 
     _, png = cv2.imencode('.png', output)
-    return png.tobytes(), warning
+    return png.tobytes(), warnings

requirements.in

 chaussette
 django
 opencv-python
-peakutils
 pip-tools

requirements.txt

 chaussette==1.3.0
 click==7.0                # via pip-tools
 django==3.0.2
-numpy==1.18.1             # via opencv-python, peakutils, scipy
+numpy==1.18.1             # via opencv-python
 opencv-python==4.1.2.30
-peakutils==1.3.3
 pip-tools==4.4.0
 pytz==2019.3              # via django
-scipy==1.4.1              # via peakutils
 six==1.14.0               # via chaussette, pip-tools
 sqlparse==0.3.0           # via django