Upload 10 files

llr.py

@@ -1,7 +1,4 @@
-# Code taken from
-# https://github.com/maciejczyzewski/neural-chessboard/
-
-from deps.laps import laps_intersections, laps_cluster
+from laps import laps_intersections, laps_cluster
 from slid import slid_tendency
 import scipy
 import cv2
@@ -44,11 +41,10 @@ def llr_unique(a):
 
 
 def llr_polysort(pts):
-    """sort points clockwise"""
     mlat = sum(x[0] for x in pts) / len(pts)
     mlng = sum(x[1] for x in pts) / len(pts)
 
-    def __sort(x):  # main math --> found on MIT site
+    def __sort(x):
         return (math.atan2(x[0]-mlat, x[1]-mlng) +
                 2*math.pi) % (2*math.pi)
     pts.sort(key=__sort)
@@ -70,7 +66,7 @@ def llr_polyscore(cnt, pts, cen, alfa=5, beta=2):
 
     pco = pyclipper.PyclipperOffset()
     pco.AddPath(cnt, pyclipper.JT_MITER, pyclipper.ET_CLOSEDPOLYGON)
-    pcnt = matplotlib.path.Path(pco.Execute(gamma)[0])  # FIXME: alfa/1.5
+    pcnt = matplotlib.path.Path(pco.Execute(gamma)[0])
     wtfs = pcnt.contains_points(pts)
     pts_in = min(np.count_nonzero(wtfs), 49)
     t1 = pts_in < min(len(pts), 49) - 2 * beta - 1
@@ -105,15 +101,6 @@ def llr_polyscore(cnt, pts, cen, alfa=5, beta=2):
 
     G = np.linalg.norm(na(cen)-na(cen2))
 
-    """
-	cnt_in = __convex_approx(na(pcnt_in))
-	S = cv2.contourArea(na(cnt_in))
-	if S < B: E += abs(S - B)
-	cnt_in = __convex_approx(na(list(cnt_in)+list(cnt)))
-	S = cv2.contourArea(na(cnt_in))
-	if S > B: E += abs(S - B)
-	"""
-
     a = [cnt[0], cnt[1]]
     b = [cnt[1], cnt[2]]
     c = [cnt[2], cnt[3]]
@@ -135,21 +122,14 @@ def llr_polyscore(cnt, pts, cen, alfa=5, beta=2):
     if B == 0 or A == 0:
         return 0
 
-    # See Eq.11 and Sec.3.4 in the paper
-
     C = 1+(E/A)**(1/3)
     D = 1+(G/A)**(1/5)
     R = (A**4)/((B**2) * C * D)
 
-    # print(R*(10**12), A, "|", B, C, D, "|", E, G)
-
     return R
 
 ################################################################################
 
-# LAPS, SLID
-
-
 def LLR(img, points, lines):
     old = points
 
@@ -207,8 +187,6 @@ def LLR(img, points, lines):
     centroid = (sum(x) / len(points),
                 sum(y) / len(points))
 
-    # print(alfa, beta, centroid)
-
     def __v(l):
         y_0, x_0 = l[0][0], l[0][1]
         y_1, x_1 = l[1][0], l[1][1]
@@ -269,8 +247,6 @@ def LLR(img, points, lines):
     pregroup[0] = llr_unique(pregroup[0])
     pregroup[1] = llr_unique(pregroup[1])
 
-    # print("---------------------")
-    # print(pregroup)
     for v in itertools.combinations(pregroup[0], 2):
         for h in itertools.combinations(pregroup[1], 2):
             poly = laps_intersections([v[0], v[1], h[0], h[1]])
@@ -280,20 +256,13 @@ def LLR(img, points, lines):
             poly = na(llr_polysort(llr_normalize(poly)))
             if not cv2.isContourConvex(poly):
                 continue
-            # print("Poly:", -llr_polyscore(poly, points, centroid,
-            #                               beta=beta, alfa=alfa/2))
             S[-llr_polyscore(poly, points, centroid,
                              beta=beta, alfa=alfa/2)] = poly
 
-    # print(bool(S))
     S = collections.OrderedDict(sorted(S.items()))
     K = next(iter(S))
-    # print("key --", K)
     four_points = llr_normalize(S[K])
 
-    # print("POINTS:", len(points))
-    # print("LINES:", len(lines))
-
     return four_points
 
 
@@ -303,5 +272,4 @@ def llr_pad(four_points, img):
 
     padded = pco.Execute(60)[0]
 
-    # 60,70/75 is best (with buffer/for debug purpose)
     return pco.Execute(60)[0]

requirements.txt

@@ -1,9 +1,13 @@
-gradio
-tensorflow
-opencv-python
-numpy
-pillow
-python-chess
-matplotlib
-scikit-learn
-pyclipper
+gradio>=4.0.0
+keras>=2.0.0
+matplotlib>=3.0.0
+numpy>=1.20.0
+opencv-contrib-python>=4.5.0
+scipy>=1.7.0
+tensorflow>=2.0.0
+pyclipper>=1.2.0
+scikit-learn>=1.0.0
+
+
+
+

rescale.py

@@ -6,13 +6,11 @@ arr = np.array
 
 
 def image_scale(pts, scale):
-    """scale to original image size"""
     def __loop(x, y): return [x[0] * y, x[1] * y]
     return list(map(functools.partial(__loop, y=1/scale), pts))
 
 
 def image_resize(img, height=500):
-    """resize image to same normalized area (height**2)"""
     pixels = height * height
     shape = list(np.shape(img))
     scale = math.sqrt(float(pixels)/float(shape[0]*shape[1]))
@@ -24,7 +22,6 @@ def image_resize(img, height=500):
 
 
 def image_transform(img, points, square_length=150):
-    """crop original image using perspective warp"""
     board_length = square_length * 8
     def __dis(a, b): return np.linalg.norm(arr(a)-arr(b))
     def __shi(seq, n=0): return seq[-(n % len(seq)):] + seq[:-(n % len(seq))]
@@ -42,7 +39,6 @@ def image_transform(img, points, square_length=150):
 
 
 def crop(img, pts, scale):
-    """crop using 4 points transform"""
     pts_orig = image_scale(pts, scale)
     img_crop = image_transform(img, pts_orig)
     return img_crop

slid.py

@@ -1,15 +1,8 @@
-# My implementation of the SLID module from
-# https://github.com/maciejczyzewski/neural-chessboard/
-
-from typing import Tuple
 import numpy as np
 import cv2
 
 
 arr = np.array
-# Four parameters are taken from the original code and
-# correspond to four possible cases that need correction:
-# low light, overexposure, underexposure, and blur
 CLAHE_PARAMS = [[3,   (2, 6),    5],  # @1
                 [3,   (6, 2),    5],  # @2
                 [5,   (3, 3),    5],  # @3
@@ -17,7 +10,6 @@ CLAHE_PARAMS = [[3,   (2, 6),    5],  # @1
 
 
 def slid_clahe(img, limit=2, grid=(3, 3), iters=5):
-    """repair using CLAHE algorithm (adaptive histogram equalization)"""
     img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     for i in range(iters):
         img = cv2.createCLAHE(clipLimit=limit,
@@ -29,7 +21,6 @@ def slid_clahe(img, limit=2, grid=(3, 3), iters=5):
 
 
 def slid_detector(img, alfa=150, beta=2):
-    """detect lines using Hough algorithm"""
     __lines, lines = [], cv2.HoughLinesP(img, rho=1, theta=np.pi/360*beta,
                                          threshold=40, minLineLength=50, maxLineGap=15)  # [40, 40, 10]
     if lines is None:
@@ -41,7 +32,6 @@ def slid_detector(img, alfa=150, beta=2):
 
 
 def slid_canny(img, sigma=0.25):
-    """apply Canny edge detector (automatic thresh)"""
     v = np.median(img)
     img = cv2.medianBlur(img, 5)
     img = cv2.GaussianBlur(img, (7, 7), 2)
@@ -51,7 +41,6 @@ def slid_canny(img, sigma=0.25):
 
 
 def pSLID(img, thresh=150):
-    """find all lines using different settings"""
     segments = []
     i = 0
     for key, arr in enumerate(CLAHE_PARAMS):
@@ -59,7 +48,6 @@ def pSLID(img, thresh=150):
         curr_segments = list(slid_detector(slid_canny(tmp), thresh))
         segments += curr_segments
         i += 1
-        # print("FILTER: {} {} : {}".format(i, arr, len(curr_segments)))
     return segments
 
 
@@ -97,12 +85,9 @@ def SLID(img, segments):
 
     def height(line, pt):
         v = np.cross(arr(line[1])-arr(line[0]), arr(pt)-arr(line[0]))
-        # Using dist() to speed up distance look-up since the 2-norm
-        # is used many times
         return np.linalg.norm(v)/dist(line[1], line[0])
 
     def are_similar(l1, l2):
-        '''See Sec.3.2.2 in Czyzewski et al.'''
         a = dist(l1[0], l1[1])
         b = dist(l2[0], l2[1])
 
@@ -114,10 +99,7 @@ def SLID(img, segments):
         if x1 < 1e-8 and x2 < 1e-8 and y1 < 1e-8 and y2 < 1e-8:
             return True
 
-        # print("l1: %s, l2: %s" % (str(l1), str(l2)))
-        # print("x1: %f, x2: %f, y1: %f, y2: %f" % (x1, x2, y1, y2))
         gamma = 0.25 * (x1+x2+y1+y2)
-        # print("gamma:", gamma)
 
         img_width = 500
         img_height = 282
@@ -126,7 +108,6 @@ def SLID(img, segments):
         w = np.pi/2 / np.sqrt(np.sqrt(A))
         t_delta = p*w
         t_delta = 0.0625
-        # t_delta = 0.05
 
         delta = (a+b) * t_delta
 
@@ -153,7 +134,6 @@ def SLID(img, segments):
 
     for l in segments:
         h = hash(str(l))
-        # Initialize the line
         hashmap[h] = l
         group[h] = set([h])
         parents[h] = h
@@ -161,8 +141,6 @@ def SLID(img, segments):
         wid = l[0][0] - l[1][0]
         hei = l[0][1] - l[1][1]
 
-        # Divide lines into more horizontal vs more vertical
-        # to speed up comparison later
         if abs(wid) < abs(hei):
             pregroup[0].append(l)
         else:
@@ -172,7 +150,6 @@ def SLID(img, segments):
         for i in range(len(lines)):
             l1 = lines[i]
             h1 = hash(str(l1))
-            # We're looking for the root line of each disjoint set
             if parents[h1] != h1:
                 continue
             for j in range(i+1, len(lines)):
@@ -181,7 +158,6 @@ def SLID(img, segments):
                 if parents[h2] != h2:
                     continue
                 if are_similar(l1, l2):
-                    # Merge lines into a single disjoint set
                     union(h1, h2)
 
     for h in group:

train.py

@@ -1,3 +1,9 @@
+# This module trains the CNN based on the labels provided in ./data/CNN
+# Note that data must be first split into train, validation, and test data
+# by running split_data.py.
+# Reference:
+# https://towardsdatascience.com/a-single-function-to-streamline-image-classification-with-keras-bd04f5cfe6df
+
 from matplotlib import pyplot as plt
 from tensorflow.keras.preprocessing.image import ImageDataGenerator
 from tensorflow.keras.models import Sequential