Better card detection

app.py

@@ -58,53 +58,108 @@ def extract_flip7_value(card_img):
 
 
 def detect_cards_and_sum(image, game):
+    """
+    Returns: (num_cards, total, error_msg, annotated_rgb_image)
+    """
     try:
         if image is None:
             return 0, 0, "No image provided.", None
 
+        # --- helpers ---
+        def order_points(pts):
+            pts = np.array(pts, dtype="float32")
+            s = pts.sum(axis=1)
+            diff = np.diff(pts, axis=1)
+            tl = pts[np.argmin(s)]
+            br = pts[np.argmax(s)]
+            tr = pts[np.argmin(diff)]
+            bl = pts[np.argmax(diff)]
+            return np.array([tl, tr, br, bl], dtype="float32")
+
+        # accept both PIL and np image
         if not isinstance(image, np.ndarray):
             image = np.array(image.convert("RGB"))
-        img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-        display_img = img.copy()
+        img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        annotated = img_bgr.copy()
 
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        blur = cv2.GaussianBlur(gray, (5,5), 0)
-        thresh = cv2.threshold(blur, 120, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]
+        H, W = annotated.shape[:2]
+        img_area = float(H * W)
 
-        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        # --- robust edge map for rectangles ---
+        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+        gray = cv2.GaussianBlur(gray, (5, 5), 0)
+        edges = cv2.Canny(gray, 60, 160)
+        edges = cv2.dilate(edges, np.ones((3, 3), np.uint8), iterations=1)
 
-        total = 0
-        detected_values = []
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        values = []
+        drawn_boxes = 0
 
         for cnt in contours:
-            peri = cv2.arcLength(cnt, True)
-            approx = cv2.approxPolyDP(cnt, 0.02 * peri, True)
-
-            if len(approx) == 4:  # rectangle → card
-                pts = np.float32(approx.reshape(4, 2))
-                dst = np.array([[0,0],[200,0],[200,300],[0,300]], dtype="float32")
-                M = cv2.getPerspectiveTransform(pts, dst)
-                warp = cv2.warpPerspective(img, M, (200,300))
-
-                if game == "Skyjo":
-                    value = extract_skyjo_value(warp)
-                else:
-                    value = extract_flip7_value(warp)
-
-                if value is not None:
-                    detected_values.append(value)
-                    total += value
-
-                    # Draw bounding box + label
-                    cv2.polylines(display_img, [approx], True, (0,255,0), 3)
-                    x, y = approx[0][0]
-                    cv2.putText(display_img, str(value), (int(x), int(y)-10),
-                                cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0,0,255), 3)
-
-        if not detected_values:
-            return 0, 0, "No valid card values detected.", cv2.cvtColor(display_img, cv2.COLOR_BGR2RGB)
-
-        return len(detected_values), total, None, cv2.cvtColor(display_img, cv2.COLOR_BGR2RGB)
+            # geometric filtering
+            rect = cv2.minAreaRect(cnt)              # (center, (w, h), angle)
+            (cx, cy), (rw, rh), _ = rect
+            if rw == 0 or rh == 0:
+                continue
+
+            box = cv2.boxPoints(rect)                # 4 points, unordered
+            box = np.int32(box)
+
+            # use bounding area (more stable with edges than contour area)
+            box_area = rw * rh
+            if box_area < 0.01 * img_area or box_area > 0.8 * img_area:
+                continue  # too small or too big to be a card
+
+            # aspect ratio (card ~ 1.4–1.8 between long/short edges)
+            long_side = max(rw, rh)
+            short_side = min(rw, rh)
+            ratio = long_side / short_side
+            if ratio < 1.2 or ratio > 1.9:
+                continue
+
+            # rectangularity: contour area close to its minAreaRect area
+            cnt_area = cv2.contourArea(cnt)
+            if cnt_area / box_area < 0.65:
+                continue
+
+            # perspective warp to a canonical card size (2:3 ratio)
+            dst_w, dst_h = 300, 450
+            M = cv2.getPerspectiveTransform(order_points(box), 
+                                            np.array([[0, 0],
+                                                      [dst_w-1, 0],
+                                                      [dst_w-1, dst_h-1],
+                                                      [0, dst_h-1]], dtype="float32"))
+            card = cv2.warpPerspective(img_bgr, M, (dst_w, dst_h))
+
+            # read value (center crop OCR handled in your extract_* funcs)
+            if game == "Skyjo":
+                val = extract_skyjo_value(card)
+            else:
+                val = extract_flip7_value(card)
+
+            if val is None:
+                continue
+
+            values.append(val)
+
+            # draw box + label at centroid (safer than vertex 0)
+            cv2.polylines(annotated, [box], True, (0, 255, 0), 3)
+            moments = cv2.moments(box)
+            if moments["m00"] != 0:
+                tx = int(moments["m10"] / moments["m00"])
+                ty = int(moments["m01"] / moments["m00"])
+            else:
+                tx, ty = int(cx), int(cy)
+            cv2.putText(annotated, str(val), (tx - 10, ty - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3)
+            drawn_boxes += 1
+
+        if not values:
+            # return the annotated image anyway so you can see what was (not) detected
+            return 0, 0, "No valid card values detected.", cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+
+        return len(values), int(sum(values)), None, cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
 
     except Exception as e:
         return 0, 0, f"Error: {str(e)}", None