deploy: backend bundle from 27fd3a957d41862b7f48c17d609eb808d9c5c3f2

.gitattributes

@@ -10,3 +10,10 @@
 Code/Frontend/public/icon-32.png -filter -diff -merge -text
 Code/Frontend/public/icon-192.png -filter -diff -merge -text
 Code/Frontend/public/logo-128.png -filter -diff -merge -text
+
+# Exclude model weight files from LFS (tracked via .gitignore instead)
+*.pth -filter -diff -merge -text
+*.pt -filter -diff -merge -text
+
+# Exclude sample/test images from LFS (small files used for testing)
+Datasets/Samples/** -filter -diff -merge -text

Code/Backend/api_server.py

@@ -191,7 +191,7 @@ import time
 
 from src.dl.prediction_pipeline import create_dl_pipeline
 from src.preprocessing.image_utils import check_image_quality
-from src.preprocessing.card_detector import detect_card_boundary_strict
+from src.preprocessing.card_detector import detect_card_boundary_strict, detect_card_boundary_with_hand
 
 # Import validators
 import sys
@@ -754,7 +754,7 @@ async def authenticate_card(request: AuthenticateRequest):
         # Layer 1: Stricter geometric validation for Pokemon cards
         # Strategy: Reject cards with incorrect aspect ratio or low saturation
         # Pokemon cards have aspect ratio ~0.716 (63mm x 88mm)
-        front_corners = detect_card_boundary_strict(
+        front_corners = detect_card_boundary_with_hand(
             front_img,
             min_area_ratio=0.001,  # Very low - card can be small in frame
             max_area_ratio=0.999,  # Almost entire image is OK for webcam shots
@@ -762,7 +762,7 @@ async def authenticate_card(request: AuthenticateRequest):
             solidity_threshold=0.60,  # Lower solidity for cards with background
             fill_ratio_threshold=0.40  # Lower fill ratio to be more permissive
         )
-        back_corners = detect_card_boundary_strict(
+        back_corners = detect_card_boundary_with_hand(
             back_img,
             min_area_ratio=0.001,
             max_area_ratio=0.999,  # Almost entire image is OK for webcam shots

Code/Model/src/dl/prediction_pipeline.py

@@ -20,6 +20,7 @@ from .model import CardAuthModel
 from .transforms import get_eval_transforms
 from ..preprocessing import (
     detect_card_boundary_strict,
+    detect_card_boundary_with_hand,
     crop_to_card,
     resize_image,
     check_image_quality,

Code/Model/src/preprocessing/__init__.py

@@ -2,7 +2,14 @@
 Preprocessing module for card image processing
 """
 
-from .card_detector import detect_card_boundary, detect_card_boundary_strict, crop_to_card, validate_card_detection
+from .card_detector import (
+    detect_card_boundary,
+    detect_card_boundary_strict,
+    detect_skin_mask,
+    detect_card_boundary_with_hand,
+    crop_to_card,
+    validate_card_detection,
+)
 from .image_utils import (
     resize_image,
     normalize_pixels,
@@ -31,6 +38,8 @@ __all__ = [
     # Card detection
     "detect_card_boundary",
     "detect_card_boundary_strict",
+    "detect_skin_mask",
+    "detect_card_boundary_with_hand",
     "crop_to_card",
     "validate_card_detection",
     # Image utilities

Code/Model/src/preprocessing/card_detector.py

@@ -160,6 +160,65 @@ def detect_card_boundary_strict(
     return best_corners
 
 
+def detect_skin_mask(image: np.ndarray) -> np.ndarray:
+    """Return a dilated binary mask of skin-coloured pixels using YCrCb thresholding."""
+    ycrcb = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb)
+    mask = cv2.inRange(ycrcb,
+                       np.array([0,   133,  77]),
+                       np.array([255, 173, 127]))
+    kernel = np.ones((15, 15), np.uint8)
+    return cv2.dilate(mask, kernel, iterations=2)
+
+
+def detect_card_boundary_with_hand(image: np.ndarray, **kwargs) -> Optional[np.ndarray]:
+    """Strict detection first; if that fails, retry with skin pixels neutralised to grey.
+
+    For hand-held cards the fingers/skin tones (and warm-background surfaces that share
+    YCrCb values with skin) confuse Canny edge detection.  Three-tier strategy:
+
+    Tier 1 — normal strict path (flat card on table: always succeeds here).
+    Tier 2 — skin removal + same strict params.
+    Tier 3 — skin removal + relaxed params (hand distorts the bounding contour AR).
+
+    Tiers 2-3 are only entered when a non-zero skin mask is found, so flat-card
+    images where no skin is present always exit at Tier 1 or return None.
+
+    Args:
+        image: Input image (BGR format).
+        **kwargs: Forwarded to :func:`detect_card_boundary_strict` for Tiers 1 & 2.
+                  Tier 3 overrides aspect_ratio_range, solidity_threshold, and
+                  fill_ratio_threshold with hand-tolerant values.
+
+    Returns:
+        Array of 4 corner points or None if no card found after all tiers.
+    """
+    # Tier 1: normal strict path
+    corners = detect_card_boundary_strict(image, **kwargs)
+    if corners is not None:
+        return corners  # Flat-card path unchanged
+
+    skin_mask = detect_skin_mask(image)
+    if skin_mask.sum() == 0:
+        return None  # No skin present; detection simply failed
+
+    masked = image.copy()
+    masked[skin_mask > 0] = [128, 128, 128]  # Neutral grey removes skin/background edges
+
+    # Tier 2: skin removal + caller's strict params
+    corners = detect_card_boundary_strict(masked, **kwargs)
+    if corners is not None:
+        return corners
+
+    # Tier 3: skin removal + relaxed params
+    # Holding the card in hand makes the detected bounding contour wider/shorter than
+    # the bare card, pushing AR below 0.65.  Relax all three geometry thresholds.
+    relaxed = dict(kwargs)
+    relaxed['aspect_ratio_range'] = (0.40, 0.95)
+    relaxed['solidity_threshold'] = 0.40
+    relaxed['fill_ratio_threshold'] = 0.20
+    return detect_card_boundary_strict(masked, **relaxed)
+
+
 def detect_card_boundary(
     image: np.ndarray,
     debug: bool = False,