Deploy Set Solver web app

.dockerignore

@@ -0,0 +1,18 @@
+.venv/
+.git/
+__pycache__/
+*.pyc
+data/
+training_images/
+docs/
+scripts/
+*.ipynb
+.DS_Store
+showcase.html
+
+# Training artifacts in weights/detector (keep only weights/*.pt)
+weights/detector/*.png
+weights/detector/*.jpg
+weights/detector/*.csv
+weights/detector/weights/last.pt
+weights/detector/weights/best.onnx

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system deps for opencv
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python deps (CPU-only torch)
+COPY requirements-web.txt .
+RUN pip install --no-cache-dir -r requirements-web.txt
+
+# Copy application code and weights
+COPY src/ src/
+COPY weights/ weights/
+
+# Hugging Face Spaces uses port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "src.web.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,15 @@
 ---
 title: Set Solver
-emoji: 📉
-colorFrom: purple
-colorTo: purple
+emoji: 🃏
+colorFrom: green
+colorTo: blue
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Set Solver
+
+Vision-based solver for the [Set card game](https://www.setgame.com/).
+
+Point your camera at Set cards → Get all valid Sets highlighted in real time.

requirements-web.txt

@@ -0,0 +1,11 @@
+# Web deployment only (CPU inference)
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch
+torchvision
+ultralytics>=8.0
+pillow>=10.0
+numpy>=1.24
+opencv-python-headless>=4.8
+fastapi
+uvicorn[standard]
+python-multipart

src/__init__.py

@@ -0,0 +1 @@
+# Set Solver

src/inference/__init__.py

@@ -0,0 +1 @@
+# Inference scripts

src/inference/classify.py

@@ -0,0 +1,103 @@
+"""
+Inference script for classifying a single card image.
+"""
+
+import torch
+from torchvision import transforms
+from PIL import Image
+from pathlib import Path
+
+# Import from training module
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+from src.train.classifier import (
+    SetCardClassifier,
+    NUMBER_NAMES, COLOR_NAMES, SHAPE_NAMES, FILL_NAMES
+)
+
+WEIGHTS_DIR = Path(__file__).parent.parent.parent / "weights"
+
+
+def load_model(weights_path: Path = None, device: str = None):
+    """Load trained classifier."""
+    if weights_path is None:
+        weights_path = WEIGHTS_DIR / "classifier_best.pt"
+    
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+    
+    model = SetCardClassifier(pretrained=False)
+    checkpoint = torch.load(weights_path, map_location=device)
+    model.load_state_dict(checkpoint["model_state_dict"])
+    model.to(device)
+    model.eval()
+    
+    return model, device
+
+
+def classify_card(image: Image.Image, model, device) -> dict:
+    """
+    Classify a card image.
+    
+    Returns dict with predicted attributes and confidences.
+    """
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    
+    img_tensor = transform(image).unsqueeze(0).to(device)
+    
+    with torch.no_grad():
+        outputs = model(img_tensor)
+    
+    # Get predictions and confidences
+    result = {}
+    for key, names in [
+        ("number", NUMBER_NAMES),
+        ("color", COLOR_NAMES),
+        ("shape", SHAPE_NAMES),
+        ("fill", FILL_NAMES),
+    ]:
+        probs = torch.softmax(outputs[key], dim=1)[0]
+        pred_idx = probs.argmax().item()
+        result[key] = {
+            "value": names[pred_idx],
+            "confidence": probs[pred_idx].item(),
+            "all_probs": {name: probs[i].item() for i, name in enumerate(names)},
+        }
+    
+    return result
+
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Classify a Set card image")
+    parser.add_argument("image", type=str, help="Path to card image")
+    args = parser.parse_args()
+    
+    print("Loading model...")
+    model, device = load_model()
+    
+    print(f"Classifying {args.image}...")
+    image = Image.open(args.image).convert("RGB")
+    result = classify_card(image, model, device)
+    
+    print("\nPrediction:")
+    print(f"  Number: {result['number']['value']} ({result['number']['confidence']:.1%})")
+    print(f"  Color:  {result['color']['value']} ({result['color']['confidence']:.1%})")
+    print(f"  Shape:  {result['shape']['value']} ({result['shape']['confidence']:.1%})")
+    print(f"  Fill:   {result['fill']['value']} ({result['fill']['confidence']:.1%})")
+    
+    # Human-readable card name
+    n = result['number']['value']
+    c = result['color']['value']
+    s = result['shape']['value']
+    f = result['fill']['value']
+    print(f"\nCard: {n} {f} {c} {s}(s)")
+
+
+if __name__ == "__main__":
+    main()

src/inference/solve.py

@@ -0,0 +1,424 @@
+"""
+End-to-end Set solver pipeline.
+
+Photo → Detect cards → Classify each → Find Sets → Visualize
+"""
+
+import sys
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+import torch
+from PIL import Image, ImageDraw, ImageFont
+from ultralytics import YOLO
+import numpy as np
+
+# Add parent to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from src.train.classifier import (
+    SetCardClassifier,
+    NUMBER_NAMES, COLOR_NAMES, SHAPE_NAMES, FILL_NAMES,
+)
+from src.solver.set_finder import Card, Shape, Color, Number, Fill, find_all_sets
+
+
+WEIGHTS_DIR = Path(__file__).parent.parent.parent / "weights"
+DATA_WEIGHTS_DIR = Path.home() / "data" / "set-solver" / "weights"
+
+# Chinese shorthand names: {1,2,3}-{实，空，线}-{红，绿，紫}-{菱，圆，弯}
+CHINESE_NUMBER = {"one": "1", "two": "2", "three": "3"}
+CHINESE_FILL = {"full": "实", "empty": "空", "partial": "线"}
+CHINESE_COLOR = {"red": "红", "green": "绿", "blue": "紫"}
+CHINESE_SHAPE = {"diamond": "菱", "oval": "圆", "squiggle": "弯"}
+
+
+def card_to_chinese(attrs: dict) -> str:
+    """Convert card attributes to Chinese shorthand like '2实红菱'."""
+    num = CHINESE_NUMBER.get(attrs['number'], attrs['number'])
+    fill = CHINESE_FILL.get(attrs['fill'], attrs['fill'])
+    color = CHINESE_COLOR.get(attrs['color'], attrs['color'])
+    shape = CHINESE_SHAPE.get(attrs['shape'], attrs['shape'])
+    return f"{num}{fill}{color}{shape}"
+
+# Colors for highlighting Sets (RGB)
+SET_COLORS = [
+    (255, 0, 0),      # Red
+    (0, 255, 0),      # Green
+    (0, 0, 255),      # Blue
+    (255, 255, 0),    # Yellow
+    (255, 0, 255),    # Magenta
+    (0, 255, 255),    # Cyan
+    (255, 128, 0),    # Orange
+    (128, 0, 255),    # Purple
+]
+
+
+class SetSolver:
+    """End-to-end Set solver."""
+    
+    def __init__(
+        self,
+        detector_path: Optional[Path] = None,
+        classifier_path: Optional[Path] = None,
+        device: Optional[str] = None,
+    ):
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+        self.device = device
+        
+        # Load detector
+        if detector_path is None:
+            # Check ~/data first, then repo weights
+            data_path = DATA_WEIGHTS_DIR / "detector" / "weights" / "best.pt"
+            repo_path = WEIGHTS_DIR / "detector" / "weights" / "best.pt"
+            detector_path = data_path if data_path.exists() else repo_path
+        print(f"Loading detector from {detector_path}")
+        self.detector = YOLO(str(detector_path))
+        
+        # Load classifier
+        if classifier_path is None:
+            classifier_path = WEIGHTS_DIR / "classifier_best.pt"
+        print(f"Loading classifier from {classifier_path}")
+        self.classifier = SetCardClassifier(pretrained=False)
+        checkpoint = torch.load(classifier_path, map_location=device)
+        self.classifier.load_state_dict(checkpoint["model_state_dict"])
+        self.classifier.to(device)
+        self.classifier.eval()
+        
+        # Classifier transform
+        from torchvision import transforms
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ])
+    
+    def detect_cards(self, image: Image.Image, conf: float = 0.5) -> List[dict]:
+        """
+        Detect cards in image.
+
+        Returns list of detections with bounding boxes.
+        Filters out oversized detections that likely merged two cards.
+        """
+        results = self.detector(image, conf=conf, verbose=False)
+
+        detections = []
+        for result in results:
+            boxes = result.boxes
+            for box in boxes:
+                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                c = box.conf[0].cpu().item()
+                w, h = x2 - x1, y2 - y1
+                detections.append({
+                    "bbox": (int(x1), int(y1), int(x2), int(y2)),
+                    "confidence": c,
+                    "area": w * h,
+                })
+
+        # Filter out merged detections: if a box is >2x the median area,
+        # it's likely covering two cards
+        if len(detections) >= 3:
+            areas = sorted(d["area"] for d in detections)
+            median_area = areas[len(areas) // 2]
+            detections = [d for d in detections if d["area"] <= median_area * 2.2]
+
+        return detections
+    
+    def classify_card(self, card_image: Image.Image) -> dict:
+        """Classify a cropped card image."""
+        img_tensor = self.transform(card_image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            outputs = self.classifier(img_tensor)
+        
+        result = {}
+        for key, names in [
+            ("number", NUMBER_NAMES),
+            ("color", COLOR_NAMES),
+            ("shape", SHAPE_NAMES),
+            ("fill", FILL_NAMES),
+        ]:
+            probs = torch.softmax(outputs[key], dim=1)[0]
+            pred_idx = probs.argmax().item()
+            result[key] = names[pred_idx]
+            result[f"{key}_conf"] = probs[pred_idx].item()
+        
+        return result
+    
+    def detection_to_card(self, attrs: dict, bbox: Tuple[int, int, int, int]) -> Card:
+        """Convert classification result to Card object."""
+        # Map classifier output to solver enums
+        # Training data uses "blue" but standard Set calls it "purple"
+        color_map = {"red": "RED", "green": "GREEN", "blue": "PURPLE"}
+        # Training data uses "partial" for striped, "full" for solid
+        fill_map = {"empty": "EMPTY", "full": "SOLID", "partial": "STRIPED"}
+        
+        return Card(
+            shape=Shape[attrs["shape"].upper()],
+            color=Color[color_map[attrs["color"]]],
+            number=Number[attrs["number"].upper()],
+            fill=Fill[fill_map[attrs["fill"]]],
+            bbox=bbox,
+        )
+    
+    def solve_from_image(
+        self,
+        image: Image.Image,
+        conf: float = 0.5,
+    ) -> dict:
+        """
+        Solve a Set game from a PIL Image directly.
+
+        Args:
+            image: PIL Image (RGB)
+            conf: Detection confidence threshold
+
+        Returns:
+            Dict with detected cards, found Sets, and annotated result image
+        """
+        image = image.convert("RGB")
+
+        detections = self.detect_cards(image, conf=conf)
+
+        cards = []
+        for det in detections:
+            x1, y1, x2, y2 = det["bbox"]
+            card_crop = image.crop((x1, y1, x2, y2))
+            attrs = self.classify_card(card_crop)
+            card = self.detection_to_card(attrs, det["bbox"])
+            cards.append({
+                "card": card,
+                "attrs": attrs,
+                "detection": det,
+            })
+
+        card_objects = [c["card"] for c in cards]
+        sets = find_all_sets(card_objects)
+
+        # Generate one annotated image per set (each highlighting only that set)
+        result_images = []
+        if sets:
+            for i in range(len(sets)):
+                result_images.append(self._draw_results(image, cards, sets, highlight_idx=i))
+        else:
+            result_images.append(self._draw_results(image, cards, sets))
+
+        return {
+            "num_cards": len(cards),
+            "cards": [
+                {
+                    "attrs": c["attrs"],
+                    "chinese": card_to_chinese(c["attrs"]),
+                    "bbox": c["detection"]["bbox"],
+                    "confidence": c["detection"]["confidence"],
+                }
+                for c in cards
+            ],
+            "num_sets": len(sets),
+            "sets": [
+                [str(card) for card in s]
+                for s in sets
+            ],
+            "sets_chinese": [
+                [card_to_chinese(next(c["attrs"] for c in cards if c["card"] is card)) for card in s]
+                for s in sets
+            ],
+            "sets_bboxes": [
+                [card.bbox for card in s]
+                for s in sets
+            ],
+            "result_images": result_images,
+        }
+
+    def solve(
+        self,
+        image_path: str,
+        conf: float = 0.5,
+        output_path: Optional[str] = None,
+        show: bool = False,
+    ) -> dict:
+        """
+        Solve a Set game from image.
+        
+        Args:
+            image_path: Path to input image
+            conf: Detection confidence threshold
+            output_path: Path to save annotated output image
+            show: Whether to display the result
+        
+        Returns:
+            Dict with detected cards and found Sets
+        """
+        # Load image
+        image = Image.open(image_path).convert("RGB")
+        print(f"Loaded image: {image.size}")
+        
+        # Detect cards
+        print("Detecting cards...")
+        detections = self.detect_cards(image, conf=conf)
+        print(f"Found {len(detections)} cards")
+        
+        # Classify each card
+        print("Classifying cards...")
+        cards = []
+        for det in detections:
+            x1, y1, x2, y2 = det["bbox"]
+            card_crop = image.crop((x1, y1, x2, y2))
+            attrs = self.classify_card(card_crop)
+            card = self.detection_to_card(attrs, det["bbox"])
+            cards.append({
+                "card": card,
+                "attrs": attrs,
+                "detection": det,
+            })
+        
+        # Find Sets
+        print("Finding Sets...")
+        card_objects = [c["card"] for c in cards]
+        sets = find_all_sets(card_objects)
+        print(f"Found {len(sets)} valid Set(s)")
+        
+        # Draw results
+        result_image = self._draw_results(image, cards, sets)
+        
+        if output_path:
+            result_image.save(output_path)
+            print(f"Saved result to {output_path}")
+        
+        if show:
+            result_image.show()
+        
+        return {
+            "num_cards": len(cards),
+            "cards": [
+                {
+                    "attrs": c["attrs"],
+                    "chinese": card_to_chinese(c["attrs"]),
+                    "bbox": c["detection"]["bbox"],
+                    "confidence": c["detection"]["confidence"],
+                }
+                for c in cards
+            ],
+            "num_sets": len(sets),
+            "sets": [
+                [str(card) for card in s]
+                for s in sets
+            ],
+            "sets_chinese": [
+                [card_to_chinese(next(c["attrs"] for c in cards if c["card"] is card)) for card in s]
+                for s in sets
+            ],
+            "result_image": result_image,
+        }
+    
+    def _draw_results(
+        self,
+        image: Image.Image,
+        cards: List[dict],
+        sets: List[Tuple[Card, Card, Card]],
+        highlight_idx: Optional[int] = None,
+    ) -> Image.Image:
+        """Draw bounding boxes and Set highlights on image.
+
+        Args:
+            highlight_idx: If set, only highlight this one set (0-based).
+                           If None, highlight all sets.
+        """
+        result = image.copy()
+        draw = ImageDraw.Draw(result)
+
+        # Try to load a Chinese-compatible font
+        font = None
+        font_paths = [
+            "/System/Library/Fonts/PingFang.ttc",  # macOS
+            "/System/Library/Fonts/STHeiti Light.ttc",  # macOS
+            "/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf",  # Linux
+            "C:\\Windows\\Fonts\\msyh.ttc",  # Windows
+        ]
+        for font_path in font_paths:
+            try:
+                font = ImageFont.truetype(font_path, 18)
+                break
+            except:
+                continue
+        if font is None:
+            font = ImageFont.load_default()
+
+        # Determine which set(s) to highlight
+        if highlight_idx is not None and 0 <= highlight_idx < len(sets):
+            highlighted_sets = [(highlight_idx, sets[highlight_idx])]
+        else:
+            highlighted_sets = list(enumerate(sets))
+
+        # Build set of highlighted card ids
+        highlighted_card_ids = set()
+        for _, card_set in highlighted_sets:
+            for card in card_set:
+                highlighted_card_ids.add(id(card))
+
+        # Draw only highlighted cards
+        for c in cards:
+            card = c["card"]
+            if id(card) not in highlighted_card_ids:
+                continue
+            attrs = c["attrs"]
+            x1, y1, x2, y2 = card.bbox
+
+            color_idx = highlighted_sets[0][0] if len(highlighted_sets) == 1 else 0
+            for si, card_set in highlighted_sets:
+                if card in card_set:
+                    color_idx = si
+                    break
+            color = SET_COLORS[color_idx % len(SET_COLORS)]
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
+
+            label = card_to_chinese(attrs)
+            draw.text((x1, y1 - 20), label, fill=color, font=font)
+
+        # Draw Set info
+        if highlight_idx is not None:
+            draw.text((10, 10), f"Set {highlight_idx + 1} / {len(sets)}", fill=(255, 255, 255), font=font)
+        else:
+            draw.text((10, 10), f"Found {len(sets)} Set(s)", fill=(255, 255, 255), font=font)
+        
+        return result
+
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Solve Set game from image")
+    parser.add_argument("image", type=str, help="Path to input image")
+    parser.add_argument("--output", "-o", type=str, help="Path to save output image")
+    parser.add_argument("--conf", type=float, default=0.25, help="Detection confidence")
+    parser.add_argument("--show", action="store_true", help="Display result")
+    args = parser.parse_args()
+    
+    solver = SetSolver()
+    result = solver.solve(
+        args.image,
+        conf=args.conf,
+        output_path=args.output,
+        show=args.show,
+    )
+    
+    print("\n" + "="*50)
+    print("结果 RESULTS")
+    print("="*50)
+    print(f"检测到卡牌: {result['num_cards']}")
+    print(f"找到Set: {result['num_sets']}")
+    
+    if result['cards']:
+        print("\n卡牌:")
+        for c in result['cards']:
+            print(f"  {c['chinese']}")
+    
+    if result['sets_chinese']:
+        print("\nSets:")
+        for i, s in enumerate(result['sets_chinese'], 1):
+            print(f"  Set {i}: {' + '.join(s)}")
+
+
+if __name__ == "__main__":
+    main()

src/solver/__init__.py

@@ -0,0 +1,11 @@
+from .set_finder import (
+    Card, Shape, Color, Number, Fill,
+    is_valid_set, find_all_sets, find_first_set,
+    generate_all_cards, card_to_index, index_to_card
+)
+
+__all__ = [
+    'Card', 'Shape', 'Color', 'Number', 'Fill',
+    'is_valid_set', 'find_all_sets', 'find_first_set',
+    'generate_all_cards', 'card_to_index', 'index_to_card'
+]

src/solver/set_finder.py

@@ -0,0 +1,173 @@
+"""
+Set-finding algorithm.
+
+A valid Set consists of 3 cards where, for each attribute,
+the values are either ALL THE SAME or ALL DIFFERENT.
+"""
+
+from dataclasses import dataclass
+from enum import IntEnum
+from itertools import combinations
+from typing import List, Tuple
+
+
+class Shape(IntEnum):
+    DIAMOND = 0
+    OVAL = 1
+    SQUIGGLE = 2
+
+
+class Color(IntEnum):
+    RED = 0
+    GREEN = 1
+    PURPLE = 2
+
+
+class Number(IntEnum):
+    ONE = 0
+    TWO = 1
+    THREE = 2
+
+
+class Fill(IntEnum):
+    SOLID = 0
+    STRIPED = 1
+    EMPTY = 2
+
+
+@dataclass
+class Card:
+    """A Set card with 4 attributes."""
+    shape: Shape
+    color: Color
+    number: Number
+    fill: Fill
+    
+    # Optional: position in image (for visualization)
+    bbox: Tuple[float, float, float, float] = None  # x, y, w, h
+    
+    def __hash__(self):
+        return hash((self.shape, self.color, self.number, self.fill))
+    
+    def __eq__(self, other):
+        if not isinstance(other, Card):
+            return False
+        return (self.shape == other.shape and 
+                self.color == other.color and
+                self.number == other.number and 
+                self.fill == other.fill)
+    
+    def to_tuple(self) -> Tuple[int, int, int, int]:
+        """Return attributes as tuple of ints."""
+        return (self.shape, self.color, self.number, self.fill)
+    
+    @classmethod
+    def from_tuple(cls, attrs: Tuple[int, int, int, int], bbox=None) -> "Card":
+        """Create card from tuple of attribute indices."""
+        return cls(
+            shape=Shape(attrs[0]),
+            color=Color(attrs[1]),
+            number=Number(attrs[2]),
+            fill=Fill(attrs[3]),
+            bbox=bbox
+        )
+    
+    def __repr__(self):
+        n = ["one", "two", "three"][self.number]
+        return f"{n} {self.fill.name.lower()} {self.color.name.lower()} {self.shape.name.lower()}(s)"
+
+
+def is_valid_set(card1: Card, card2: Card, card3: Card) -> bool:
+    """
+    Check if three cards form a valid Set.
+    
+    For each attribute, the three values must be either:
+    - All the same (e.g., all red)
+    - All different (e.g., red, green, purple)
+    """
+    for attr in ['shape', 'color', 'number', 'fill']:
+        values = [getattr(card1, attr), getattr(card2, attr), getattr(card3, attr)]
+        unique = len(set(values))
+        # Valid: all same (1 unique) or all different (3 unique)
+        # Invalid: exactly 2 unique
+        if unique == 2:
+            return False
+    return True
+
+
+def find_all_sets(cards: List[Card]) -> List[Tuple[Card, Card, Card]]:
+    """
+    Find all valid Sets among the given cards.
+    
+    Uses brute force: check all C(n,3) combinations.
+    For 12 cards: C(12,3) = 220 combinations - very fast.
+    For 21 cards (max in real game): C(21,3) = 1330 combinations - still fast.
+    """
+    valid_sets = []
+    for combo in combinations(cards, 3):
+        if is_valid_set(*combo):
+            valid_sets.append(combo)
+    return valid_sets
+
+
+def find_first_set(cards: List[Card]) -> Tuple[Card, Card, Card] | None:
+    """Find the first valid Set, or None if no Set exists."""
+    for combo in combinations(cards, 3):
+        if is_valid_set(*combo):
+            return combo
+    return None
+
+
+# --- Utilities ---
+
+def generate_all_cards() -> List[Card]:
+    """Generate all 81 unique Set cards."""
+    cards = []
+    for s in Shape:
+        for c in Color:
+            for n in Number:
+                for f in Fill:
+                    cards.append(Card(shape=s, color=c, number=n, fill=f))
+    return cards
+
+
+def card_to_index(card: Card) -> int:
+    """Convert card to unique index (0-80)."""
+    return (card.shape * 27 + card.color * 9 + card.number * 3 + card.fill)
+
+
+def index_to_card(idx: int) -> Card:
+    """Convert index (0-80) to card."""
+    fill = idx % 3
+    idx //= 3
+    number = idx % 3
+    idx //= 3
+    color = idx % 3
+    idx //= 3
+    shape = idx
+    return Card(Shape(shape), Color(color), Number(number), Fill(fill))
+
+
+# --- Demo ---
+
+if __name__ == "__main__":
+    # Example: find sets in a random deal
+    import random
+    
+    all_cards = generate_all_cards()
+    print(f"Total cards in deck: {len(all_cards)}")
+    
+    # Deal 12 cards
+    deal = random.sample(all_cards, 12)
+    print(f"\nDealt {len(deal)} cards:")
+    for i, card in enumerate(deal):
+        print(f"  {i+1}. {card}")
+    
+    # Find all sets
+    sets = find_all_sets(deal)
+    print(f"\nFound {len(sets)} valid Set(s):")
+    for i, (c1, c2, c3) in enumerate(sets):
+        print(f"\n  Set {i+1}:")
+        print(f"    - {c1}")
+        print(f"    - {c2}")
+        print(f"    - {c3}")

src/train/__init__.py

@@ -0,0 +1 @@
+# Training scripts

src/train/classifier.py

@@ -0,0 +1,361 @@
+"""
+Train a card attribute classifier on the existing labeled images.
+
+Uses MobileNetV3-Small for iPhone compatibility.
+Multi-head output: predicts all 4 attributes simultaneously.
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Tuple, Dict, List
+
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, random_split
+from torchvision import transforms, models
+from torchvision.io import read_image, ImageReadMode
+from PIL import Image
+import numpy as np
+from tqdm import tqdm
+
+# === Config ===
+
+DATA_DIR = Path(__file__).parent.parent.parent / "training_images"
+SYNTHETIC_DATA_DIR = Path(__file__).parent.parent.parent / "training_images_synthetic"
+WEIGHTS_DIR = Path(__file__).parent.parent.parent / "weights"
+WEIGHTS_DIR.mkdir(exist_ok=True)
+
+# Attribute mappings (folder names → indices)
+NUMBER_MAP = {"one": 0, "two": 1, "three": 2}
+COLOR_MAP = {"red": 0, "green": 1, "blue": 2}  # blue = purple in standard Set
+SHAPE_MAP = {"diamond": 0, "oval": 1, "squiggle": 2}
+FILL_MAP = {"empty": 0, "full": 1, "partial": 2}  # partial = striped
+
+# Reverse mappings for inference
+NUMBER_NAMES = ["one", "two", "three"]
+COLOR_NAMES = ["red", "green", "blue"]
+SHAPE_NAMES = ["diamond", "oval", "squiggle"]
+FILL_NAMES = ["empty", "full", "partial"]
+
+
+# === Dataset ===
+
+class SetCardDataset(Dataset):
+    """Dataset of labeled Set card images."""
+
+    def __init__(self, data_dirs, transform=None):
+        if isinstance(data_dirs, Path):
+            data_dirs = [data_dirs]
+        self.transform = transform
+        self.samples: List[Tuple[Path, Dict[str, int]]] = []
+
+        # Walk the directory structure to find all images
+        for data_dir in data_dirs:
+            if not data_dir.exists():
+                continue
+            count_before = len(self.samples)
+            for number in NUMBER_MAP:
+                for color in COLOR_MAP:
+                    for shape in SHAPE_MAP:
+                        for fill in FILL_MAP:
+                            folder = data_dir / number / color / shape / fill
+                            if folder.exists():
+                                for img_path in folder.glob("*.png"):
+                                    labels = {
+                                        "number": NUMBER_MAP[number],
+                                        "color": COLOR_MAP[color],
+                                        "shape": SHAPE_MAP[shape],
+                                        "fill": FILL_MAP[fill],
+                                    }
+                                    self.samples.append((img_path, labels))
+            print(f"Loaded {len(self.samples) - count_before} samples from {data_dir}")
+
+        print(f"Total: {len(self.samples)} samples")
+    
+    def __len__(self):
+        return len(self.samples)
+    
+    def __getitem__(self, idx):
+        img_path, labels = self.samples[idx]
+        
+        # Load image
+        image = Image.open(img_path).convert("RGB")
+        
+        if self.transform:
+            image = self.transform(image)
+        
+        # Stack labels into tensor
+        label_tensor = torch.tensor([
+            labels["number"],
+            labels["color"],
+            labels["shape"],
+            labels["fill"],
+        ], dtype=torch.long)
+        
+        return image, label_tensor
+    
+    def get_raw(self, idx):
+        """Get raw PIL image and labels (no transform)."""
+        img_path, labels = self.samples[idx]
+        image = Image.open(img_path).convert("RGB")
+        label_tensor = torch.tensor([
+            labels["number"],
+            labels["color"],
+            labels["shape"],
+            labels["fill"],
+        ], dtype=torch.long)
+        return image, label_tensor
+
+
+# === Model ===
+
+class SetCardClassifier(nn.Module):
+    """
+    Multi-head classifier for Set card attributes.
+    
+    Uses MobileNetV3-Small backbone (good for mobile deployment).
+    Four output heads, one per attribute.
+    """
+    
+    def __init__(self, pretrained: bool = True):
+        super().__init__()
+        
+        # Load pretrained MobileNetV3-Small
+        weights = models.MobileNet_V3_Small_Weights.DEFAULT if pretrained else None
+        self.backbone = models.mobilenet_v3_small(weights=weights)
+        
+        # Get the feature dimension from the classifier
+        in_features = self.backbone.classifier[0].in_features
+        
+        # Remove the original classifier
+        self.backbone.classifier = nn.Identity()
+        
+        # Add our multi-head classifier
+        self.heads = nn.ModuleDict({
+            "number": nn.Linear(in_features, 3),
+            "color": nn.Linear(in_features, 3),
+            "shape": nn.Linear(in_features, 3),
+            "fill": nn.Linear(in_features, 3),
+        })
+    
+    def forward(self, x):
+        features = self.backbone(x)
+        return {
+            "number": self.heads["number"](features),
+            "color": self.heads["color"](features),
+            "shape": self.heads["shape"](features),
+            "fill": self.heads["fill"](features),
+        }
+
+
+# === Training ===
+
+def train_epoch(model, loader, optimizer, criterion, device):
+    model.train()
+    total_loss = 0
+    correct = {k: 0 for k in ["number", "color", "shape", "fill"]}
+    total = 0
+    
+    for images, labels in tqdm(loader, desc="Training", leave=False):
+        images = images.to(device)
+        labels = labels.to(device)
+        
+        optimizer.zero_grad()
+        outputs = model(images)
+        
+        # Compute loss for each head (2x weight on fill to penalize fill mistakes)
+        loss = 0
+        fill_weight = 2.0
+        for i, key in enumerate(["number", "color", "shape", "fill"]):
+            head_loss = criterion(outputs[key], labels[:, i])
+            loss += fill_weight * head_loss if key == "fill" else head_loss
+            preds = outputs[key].argmax(dim=1)
+            correct[key] += (preds == labels[:, i]).sum().item()
+        
+        loss.backward()
+        optimizer.step()
+        
+        total_loss += loss.item()
+        total += labels.size(0)
+    
+    avg_loss = total_loss / len(loader)
+    accuracies = {k: v / total for k, v in correct.items()}
+    return avg_loss, accuracies
+
+
+def evaluate(model, loader, criterion, device):
+    model.eval()
+    total_loss = 0
+    correct = {k: 0 for k in ["number", "color", "shape", "fill"]}
+    total = 0
+    
+    with torch.no_grad():
+        for images, labels in tqdm(loader, desc="Evaluating", leave=False):
+            images = images.to(device)
+            labels = labels.to(device)
+            
+            outputs = model(images)
+            
+            loss = 0
+            for i, key in enumerate(["number", "color", "shape", "fill"]):
+                loss += criterion(outputs[key], labels[:, i])
+                preds = outputs[key].argmax(dim=1)
+                correct[key] += (preds == labels[:, i]).sum().item()
+            
+            total_loss += loss.item()
+            total += labels.size(0)
+    
+    avg_loss = total_loss / len(loader)
+    accuracies = {k: v / total for k, v in correct.items()}
+    return avg_loss, accuracies
+
+
+def main():
+    # === Hyperparameters ===
+    BATCH_SIZE = 32
+    EPOCHS = 50
+    LR = 1e-3
+    VAL_SPLIT = 0.15
+    TEST_SPLIT = 0.10
+    IMG_SIZE = 224
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu")
+    print(f"Using device: {device}")
+    
+    # === Data transforms ===
+    train_transform = transforms.Compose([
+        transforms.RandomResizedCrop(IMG_SIZE, scale=(0.7, 1.0)),  # Simulate imperfect detector crops
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomVerticalFlip(),
+        transforms.RandomRotation(180),  # Cards can be any orientation
+        transforms.RandomPerspective(distortion_scale=0.15, p=0.5),  # Perspective warp from detection
+        transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.05),
+        transforms.RandomGrayscale(p=0.05),  # Force model to not rely solely on color for fill
+        transforms.GaussianBlur(kernel_size=5, sigma=(0.1, 2.0)),  # ~30% effective via random sigma
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    
+    val_transform = transforms.Compose([
+        transforms.Resize((IMG_SIZE, IMG_SIZE)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    
+    # === Load dataset (clean + synthetic crops) ===
+    data_dirs = [DATA_DIR]
+    if SYNTHETIC_DATA_DIR.exists():
+        data_dirs.append(SYNTHETIC_DATA_DIR)
+    full_dataset = SetCardDataset(data_dirs, transform=None)  # No transform yet
+    
+    # Split into train/val/test
+    total = len(full_dataset)
+    test_size = int(total * TEST_SPLIT)
+    val_size = int(total * VAL_SPLIT)
+    train_size = total - val_size - test_size
+    
+    train_dataset, val_dataset, test_dataset = random_split(
+        full_dataset, [train_size, val_size, test_size],
+        generator=torch.Generator().manual_seed(42)
+    )
+    
+    print(f"Train: {len(train_dataset)}, Val: {len(val_dataset)}, Test: {len(test_dataset)}")
+    
+    # Wrap with transform (can't change transform on Subset, so we wrap)
+    class TransformDataset(torch.utils.data.Dataset):
+        def __init__(self, subset, transform):
+            self.subset = subset
+            self.transform = transform
+        def __len__(self):
+            return len(self.subset)
+        def __getitem__(self, idx):
+            image, label = self.subset[idx]
+            if self.transform:
+                image = self.transform(image)
+            return image, label
+    
+    train_dataset = TransformDataset(train_dataset, train_transform)
+    val_dataset = TransformDataset(val_dataset, val_transform)
+    test_dataset = TransformDataset(test_dataset, val_transform)
+    
+    # Use num_workers=0 on macOS to avoid shared memory issues
+    import platform
+    num_workers = 0 if platform.system() == "Darwin" else 4
+    
+    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=num_workers)
+    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=num_workers)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=num_workers)
+    
+    # === Model ===
+    model = SetCardClassifier(pretrained=True).to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=LR)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
+    
+    # === Training loop ===
+    best_val_acc = 0
+    
+    for epoch in range(EPOCHS):
+        train_loss, train_acc = train_epoch(model, train_loader, optimizer, criterion, device)
+        val_loss, val_acc = evaluate(model, val_loader, criterion, device)
+        scheduler.step()
+        
+        # Average accuracy across all heads
+        avg_train_acc = sum(train_acc.values()) / 4
+        avg_val_acc = sum(val_acc.values()) / 4
+        
+        print(f"Epoch {epoch+1}/{EPOCHS}")
+        print(f"  Train Loss: {train_loss:.4f}, Acc: {avg_train_acc:.4f}")
+        print(f"  Val Loss: {val_loss:.4f}, Acc: {avg_val_acc:.4f}")
+        print(f"  Val per-head: num={val_acc['number']:.3f} col={val_acc['color']:.3f} "
+              f"shp={val_acc['shape']:.3f} fil={val_acc['fill']:.3f}")
+        
+        # Save best model
+        if avg_val_acc > best_val_acc:
+            best_val_acc = avg_val_acc
+            torch.save({
+                "epoch": epoch,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "val_acc": val_acc,
+            }, WEIGHTS_DIR / "classifier_best.pt")
+            print(f"  Saved new best model (val_acc={avg_val_acc:.4f})")
+    
+    # === Final evaluation on test set ===
+    print("\n" + "="*50)
+    print("Final Test Evaluation")
+    print("="*50)
+    
+    # Load best model
+    checkpoint = torch.load(WEIGHTS_DIR / "classifier_best.pt")
+    model.load_state_dict(checkpoint["model_state_dict"])
+    
+    test_loss, test_acc = evaluate(model, test_loader, criterion, device)
+    avg_test_acc = sum(test_acc.values()) / 4
+    
+    print(f"Test Loss: {test_loss:.4f}")
+    print(f"Test Accuracy (avg): {avg_test_acc:.4f}")
+    print(f"  Number: {test_acc['number']:.4f}")
+    print(f"  Color:  {test_acc['color']:.4f}")
+    print(f"  Shape:  {test_acc['shape']:.4f}")
+    print(f"  Fill:   {test_acc['fill']:.4f}")
+    
+    # Save final results
+    results = {
+        "test_loss": test_loss,
+        "test_accuracy": test_acc,
+        "avg_test_accuracy": avg_test_acc,
+        "train_size": train_size,
+        "val_size": val_size,
+        "test_size": test_size,
+    }
+    with open(WEIGHTS_DIR / "training_results.json", "w") as f:
+        json.dump(results, f, indent=2)
+    
+    print(f"\nModel saved to {WEIGHTS_DIR / 'classifier_best.pt'}")
+    print(f"Results saved to {WEIGHTS_DIR / 'training_results.json'}")
+
+
+if __name__ == "__main__":
+    main()

src/web/app.py

@@ -0,0 +1,113 @@
+"""
+Web-based real-time Set solver.
+
+FastAPI backend serving a single HTML page with live camera feed.
+Processes frames via the SetSolver pipeline and returns annotated results.
+"""
+
+import base64
+import io
+import sys
+from pathlib import Path
+
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import HTMLResponse
+from PIL import Image
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from src.inference.solve import SetSolver
+
+app = FastAPI(title="Set Solver")
+
+# Global solver instance (loaded once at startup)
+solver: SetSolver = None
+
+
+@app.on_event("startup")
+def load_solver():
+    global solver
+    print("Loading Set Solver pipeline...")
+    solver = SetSolver()
+    print("Solver ready!")
+
+
+@app.get("/", response_class=HTMLResponse)
+def index():
+    html_path = Path(__file__).parent / "templates" / "index.html"
+    return html_path.read_text()
+
+
+@app.post("/api/solve")
+async def solve_frame(file: UploadFile = File(...)):
+    """Accept a JPEG frame, run solver, return results."""
+    contents = await file.read()
+    image = Image.open(io.BytesIO(contents)).convert("RGB")
+
+    result = solver.solve_from_image(image, conf=0.25)
+
+    # Encode per-set annotated images as base64 JPEG
+    result_images_b64 = []
+    for img in result.pop("result_images"):
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=85)
+        result_images_b64.append(base64.b64encode(buf.getvalue()).decode("utf-8"))
+    result["result_images_b64"] = result_images_b64
+
+    # Crop cards per set for trophy display
+    per_set_cards_b64 = []
+    for bboxes in result.get("sets_bboxes", []):
+        crops = []
+        for bbox in bboxes:
+            x1, y1, x2, y2 = bbox
+            crop = image.crop((x1, y1, x2, y2))
+            cbuf = io.BytesIO()
+            crop.save(cbuf, format="JPEG", quality=90)
+            crops.append(base64.b64encode(cbuf.getvalue()).decode("utf-8"))
+        per_set_cards_b64.append(crops)
+    result["per_set_cards_b64"] = per_set_cards_b64
+
+    return result
+
+
+if __name__ == "__main__":
+    import argparse
+    import subprocess
+    import tempfile
+    import uvicorn
+
+    parser = argparse.ArgumentParser(description="Set Solver web server")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--no-ssl", action="store_true", help="Disable auto-generated SSL (camera requires HTTPS on non-localhost)")
+    args = parser.parse_args()
+
+    ssl_kwargs = {}
+    if not args.no_ssl:
+        # Generate a self-signed cert so mobile browsers allow camera access
+        cert_dir = Path(tempfile.mkdtemp())
+        cert_file = cert_dir / "cert.pem"
+        key_file = cert_dir / "key.pem"
+        subprocess.run([
+            "openssl", "req", "-x509", "-newkey", "rsa:2048",
+            "-keyout", str(key_file), "-out", str(cert_file),
+            "-days", "1", "-nodes",
+            "-subj", "/CN=set-solver",
+        ], check=True, capture_output=True)
+        ssl_kwargs = {"ssl_certfile": str(cert_file), "ssl_keyfile": str(key_file)}
+        proto = "https"
+    else:
+        proto = "http"
+
+    # Show access URLs
+    import socket
+    hostname = socket.gethostname()
+    try:
+        local_ip = socket.gethostbyname(hostname)
+    except socket.gaierror:
+        local_ip = "127.0.0.1"
+    print(f"\n  Set Solver running at:")
+    print(f"    Local:   {proto}://localhost:{args.port}")
+    print(f"    Network: {proto}://{local_ip}:{args.port}\n")
+
+    uvicorn.run("src.web.app:app", host="0.0.0.0", port=args.port, reload=False, **ssl_kwargs)

src/web/templates/index.html

@@ -0,0 +1,383 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+<title>Set Solver</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    background: #000;
+    color: #fff;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    overflow: hidden;
+    height: 100dvh;
+    width: 100vw;
+    display: flex;
+    flex-direction: column;
+  }
+  #trophy {
+    display: none;
+    flex-direction: row;
+    justify-content: center;
+    align-items: center;
+    gap: 6px;
+    padding: 6px;
+    background: #111;
+    flex-shrink: 0;
+  }
+  #trophy.active { display: flex; }
+  #trophy img {
+    height: 60px;
+    max-width: 30vw;
+    border-radius: 4px;
+    border: 2px solid #4f4;
+    object-fit: contain;
+  }
+  #camera-container {
+    position: relative;
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    overflow: hidden;
+  }
+  video, #result-img {
+    max-width: 100%;
+    max-height: 100%;
+    object-fit: contain;
+  }
+  #result-img { display: none; }
+  #bottom-bar {
+    position: absolute;
+    bottom: 0; left: 0; right: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding-bottom: 16px;
+    z-index: 15;
+    pointer-events: none;
+  }
+  #set-nav {
+    display: none;
+    align-items: center;
+    gap: 12px;
+    margin-bottom: 10px;
+    pointer-events: auto;
+  }
+  #set-nav.active { display: flex; }
+  #set-nav .nav-arrow {
+    background: rgba(255,255,255,0.2);
+    border: none;
+    color: #fff;
+    font-size: 22px;
+    width: 40px; height: 40px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+  #set-nav .nav-arrow:active { background: rgba(255,255,255,0.4); }
+  #set-label {
+    font-size: 14px;
+    color: #ccc;
+    min-width: 100px;
+    text-align: center;
+  }
+  #scan-btn {
+    border: none;
+    border-radius: 28px;
+    padding: 14px 48px;
+    font-size: 18px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background 0.2s;
+    pointer-events: auto;
+  }
+  #scan-btn.start {
+    background: #4f4;
+    color: #000;
+  }
+  #scan-btn.stop {
+    background: #f44;
+    color: #fff;
+  }
+  #scan-btn.restart {
+    background: #ff0;
+    color: #000;
+  }
+  #scan-btn:active { opacity: 0.7; }
+  #status-bar {
+    position: absolute;
+    top: 8px; left: 8px;
+    background: rgba(0,0,0,0.6);
+    border-radius: 8px;
+    padding: 4px 10px;
+    font-size: 13px;
+    z-index: 5;
+  }
+  #status-bar .dot {
+    display: inline-block;
+    width: 8px; height: 8px;
+    border-radius: 50%;
+    margin-right: 6px;
+    vertical-align: middle;
+  }
+  .dot.active { background: #4f4; }
+  .dot.inactive { background: #f44; }
+  .dot.processing { background: #ff4; }
+  .dot.idle { background: #888; }
+</style>
+</head>
+<body>
+  <div id="trophy"></div>
+  <div id="camera-container">
+    <video id="video" autoplay playsinline muted></video>
+    <img id="result-img" alt="Result">
+    <div id="status-bar">
+      <span class="dot inactive" id="status-dot"></span>
+      <span id="status-text">Starting camera...</span>
+    </div>
+    <div id="bottom-bar">
+      <div id="set-nav">
+        <button class="nav-arrow" id="prev-btn">&larr;</button>
+        <span id="set-label"></span>
+        <button class="nav-arrow" id="next-btn">&rarr;</button>
+      </div>
+      <button id="scan-btn" class="start">Start</button>
+    </div>
+  </div>
+
+  <canvas id="capture-canvas" style="display:none;"></canvas>
+
+<script>
+const video = document.getElementById('video');
+const resultImg = document.getElementById('result-img');
+const trophy = document.getElementById('trophy');
+const setNav = document.getElementById('set-nav');
+const setLabel = document.getElementById('set-label');
+const prevBtn = document.getElementById('prev-btn');
+const nextBtn = document.getElementById('next-btn');
+const scanBtn = document.getElementById('scan-btn');
+const statusDot = document.getElementById('status-dot');
+const statusText = document.getElementById('status-text');
+const canvas = document.getElementById('capture-canvas');
+
+let stream = null;
+let scanning = false;
+let processing = false;
+let frozen = false;  // true when showing results
+let loopTimer = null;
+
+// Result state for cycling through sets
+let resultData = null;
+let currentSetIdx = 0;
+
+async function startCamera() {
+  if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+    statusDot.className = 'dot inactive';
+    statusText.textContent = 'Camera API unavailable — use https://';
+    console.error('mediaDevices not available. Page must be served over HTTPS (or localhost).');
+    return;
+  }
+  try {
+    stream = await navigator.mediaDevices.getUserMedia({
+      video: { facingMode: 'environment', width: { ideal: 1280 }, height: { ideal: 720 } },
+      audio: false,
+    });
+    for (const track of stream.getVideoTracks()) {
+      const caps = track.getCapabilities?.() || {};
+      const settings = {};
+      if ('backgroundBlur' in caps) settings.backgroundBlur = false;
+      if ('faceFraming' in caps) settings.faceFraming = false;
+      if ('pan' in caps) settings.pan = track.getSettings().pan;
+      if ('tilt' in caps) settings.tilt = track.getSettings().tilt;
+      if ('zoom' in caps) settings.zoom = track.getSettings().zoom;
+      if (Object.keys(settings).length > 0) {
+        try { await track.applyConstraints({ advanced: [settings] }); } catch (e) { /* ignore */ }
+      }
+    }
+    video.srcObject = stream;
+    await video.play();
+    statusDot.className = 'dot idle';
+    statusText.textContent = 'Ready — press Start';
+  } catch (err) {
+    statusDot.className = 'dot inactive';
+    statusText.textContent = 'Camera access denied — check browser permissions';
+    console.error('Camera error:', err);
+  }
+}
+
+function restart() {
+  // Go from frozen results back to live camera (not scanning yet)
+  frozen = false;
+  scanning = false;
+  resultData = null;
+  currentSetIdx = 0;
+  trophy.classList.remove('active');
+  trophy.innerHTML = '';
+  setNav.classList.remove('active');
+  resultImg.style.display = 'none';
+  video.style.display = 'block';
+
+  scanBtn.textContent = 'Start';
+  scanBtn.className = 'start';
+  statusDot.className = 'dot idle';
+  statusText.textContent = 'Ready — press Start';
+}
+
+function startScanning() {
+  scanning = true;
+  scanBtn.textContent = 'Stop';
+  scanBtn.className = 'stop';
+  statusDot.className = 'dot active';
+  statusText.textContent = 'Scanning...';
+
+  if (loopTimer) clearInterval(loopTimer);
+  loopTimer = setInterval(() => {
+    if (scanning && !processing) captureAndSolve();
+  }, 333);
+}
+
+function stopScanning() {
+  scanning = false;
+  if (loopTimer) { clearInterval(loopTimer); loopTimer = null; }
+  scanBtn.textContent = 'Start';
+  scanBtn.className = 'start';
+  statusDot.className = 'dot idle';
+  statusText.textContent = 'Stopped';
+}
+
+async function captureAndSolve() {
+  if (!scanning || processing) return;
+  processing = true;
+  statusDot.className = 'dot processing';
+
+  try {
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(video, 0, 0);
+
+    const blob = await new Promise(resolve => canvas.toBlob(resolve, 'image/jpeg', 0.8));
+    const formData = new FormData();
+    formData.append('file', blob, 'frame.jpg');
+
+    const resp = await fetch('/api/solve', { method: 'POST', body: formData });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const data = await resp.json();
+
+    if (!scanning) return;
+
+    statusText.textContent = `${data.num_cards} cards`;
+    statusDot.className = 'dot active';
+
+    if (data.num_sets > 0) {
+      showResult(data);
+    }
+  } catch (err) {
+    console.error('Solve error:', err);
+    if (scanning) statusDot.className = 'dot active';
+  } finally {
+    processing = false;
+  }
+}
+
+function showResult(data) {
+  scanning = false;
+  frozen = true;
+  if (loopTimer) { clearInterval(loopTimer); loopTimer = null; }
+
+  resultData = data;
+  currentSetIdx = 0;
+
+  video.style.display = 'none';
+  resultImg.style.display = 'block';
+
+  // Show nav if multiple sets
+  if (data.num_sets > 1) {
+    setNav.classList.add('active');
+  }
+
+  showCurrentSet();
+
+  scanBtn.textContent = 'Restart';
+  scanBtn.className = 'restart';
+  statusDot.className = 'dot active';
+  statusText.textContent = `Found ${data.num_sets} Set${data.num_sets > 1 ? 's' : ''}!`;
+
+  speak('Set!');
+}
+
+function showCurrentSet() {
+  if (!resultData) return;
+  const data = resultData;
+  const i = currentSetIdx;
+
+  // Show annotated image for this set
+  resultImg.src = 'data:image/jpeg;base64,' + data.result_images_b64[i];
+
+  // Show trophy cards for this set
+  const cards = data.per_set_cards_b64[i];
+  if (cards && cards.length === 3) {
+    trophy.innerHTML = cards
+      .map(b64 => `<img src="data:image/jpeg;base64,${b64}">`)
+      .join('');
+    trophy.classList.add('active');
+  }
+
+  // Update nav label
+  setLabel.textContent = `Set ${i + 1} / ${data.num_sets}`;
+}
+
+function prevSet() {
+  if (!resultData || resultData.num_sets <= 1) return;
+  currentSetIdx = (currentSetIdx - 1 + resultData.num_sets) % resultData.num_sets;
+  showCurrentSet();
+}
+
+function nextSet() {
+  if (!resultData || resultData.num_sets <= 1) return;
+  currentSetIdx = (currentSetIdx + 1) % resultData.num_sets;
+  showCurrentSet();
+}
+
+function speak(text) {
+  if ('speechSynthesis' in window) {
+    const utter = new SpeechSynthesisUtterance(text);
+    utter.rate = 1.2;
+    utter.pitch = 1.1;
+    speechSynthesis.speak(utter);
+  }
+}
+
+scanBtn.addEventListener('click', () => {
+  if (frozen) {
+    restart();
+  } else if (scanning) {
+    stopScanning();
+  } else {
+    startScanning();
+  }
+});
+prevBtn.addEventListener('click', prevSet);
+nextBtn.addEventListener('click', nextSet);
+
+document.addEventListener('keydown', e => {
+  if (e.key === ' ') {
+    e.preventDefault();
+    if (frozen) restart();
+    else if (scanning) stopScanning();
+    else startScanning();
+  } else if (e.key === 'ArrowLeft') {
+    prevSet();
+  } else if (e.key === 'ArrowRight') {
+    nextSet();
+  }
+});
+
+startCamera();
+</script>
+</body>
+</html>

weights/classifier_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0c464367eccfcfd6599377c9af35f72cd23c524b01eda7e9a11ccb1e3ba3f6d
+size 11465795

weights/detector/weights/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d65deae13124271df8739b700d2f893bca1eb7a7bc8ac870702e714b787ceee7
+size 5453594