Add project files

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+# Install system dependencies required for OpenCV and pyzbar (barcodes)
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libzbar0 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+# Install uvicorn and fastapi explicitly to ensure they are available in container
+RUN pip install --no-cache-dir fastapi uvicorn python-multipart
+
+# Copy all project files
+COPY . .
+
+# Create directories if they don't exist
+RUN mkdir -p temp_uploads results images/barcode images/chassis
+
+# Expose FastAPI port
+EXPOSE 8000
+
+# Start application
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,64 @@
+# Chassis OCR Pipeline
+
+Reads engraved chassis numbers from phone images and matches them against barcode-scanned numbers.
+
+## Setup
+
+```bash
+pip install -r requirements.txt
+```
+
+On Linux you also need:
+```bash
+sudo apt-get install libzbar0
+```
+
+## Project Structure
+
+```
+chassis_ocr/
+├── images/
+│   ├── barcode/     ← put your 50 barcode images here
+│   └── chassis/     ← put your 50 chassis images here (same filenames)
+├── results/         ← comparison images + report saved here
+├── preprocess.py    ← image cleaning pipeline
+├── barcode_scanner.py
+├── ocr.py
+└── evaluate.py      ← run this
+```
+
+## Important — Naming Convention
+
+Barcode and chassis images must have the **same filename** to be paired:
+```
+images/barcode/001.jpg  ←→  images/chassis/001.jpg
+images/barcode/002.jpg  ←→  images/chassis/002.jpg
+```
+
+## Run
+
+```bash
+# Test preprocessing on a single chassis image
+python preprocess.py images/chassis/001.jpg
+
+# Test OCR on a single chassis image  
+python ocr.py images/chassis/001.jpg
+
+# Run full evaluation on all 50 pairs
+python evaluate.py
+```
+
+## Output
+
+After running `evaluate.py`:
+- `results/report.json` — full accuracy breakdown
+- `results/*_comparison.jpg` — before/after preprocessing for each image
+
+## Pipeline
+
+```
+Barcode image → pyzbar → ground truth string
+                                              ↘
+Chassis image → CLAHE → Adaptive threshold     Compare → ✅ Match / ❌ Mismatch
+             → Morphological ops → PaddleOCR ↗
+```

augment.py

@@ -0,0 +1,156 @@
+import os
+import cv2
+import json
+import numpy as np
+import albumentations as A
+from barcode_scanner import scan_all_barcodes
+
+BARCODE_DIR    = "images/barcode"
+CHASSIS_DIR    = "images/chassis"
+OUTPUT_DIR     = "images/chassis_augmented"
+GT_PATH        = "ground_truth.json"
+AUGMENTS_PER_IMAGE = 25
+
+
+def get_augmentation_pipeline():
+    return A.Compose([
+
+        A.OneOf([
+            A.RandomBrightnessContrast(
+                brightness_limit=0.4,
+                contrast_limit=0.4,
+                p=1.0
+            ),
+            A.RandomGamma(gamma_limit=(60, 140), p=1.0),
+            A.CLAHE(clip_limit=4.0, p=1.0),
+        ], p=0.9),
+
+        A.OneOf([
+            A.RandomShadow(
+                shadow_roi=(0, 0, 1, 1),
+                num_shadows_lower=1,
+                num_shadows_upper=2,
+                shadow_dimension=4,
+                p=1.0
+            ),
+            A.RandomSunFlare(
+                flare_roi=(0, 0, 1, 0.5),
+                angle_lower=0,
+                src_radius=80,
+                p=1.0
+            ),
+        ], p=0.5),
+
+        A.OneOf([
+            A.MotionBlur(blur_limit=(3, 7), p=1.0),
+            A.GaussianBlur(blur_limit=(3, 5), p=1.0),
+            A.MedianBlur(blur_limit=3, p=1.0),
+        ], p=0.4),
+
+        A.OneOf([
+            A.GaussNoise(var_limit=(10, 50), p=1.0),
+            A.ISONoise(color_shift=(0.01, 0.05), intensity=(0.1, 0.5), p=1.0),
+            A.MultiplicativeNoise(multiplier=(0.9, 1.1), p=1.0),
+        ], p=0.6),
+
+        A.OneOf([
+            A.Perspective(scale=(0.02, 0.08), p=1.0),
+            A.ShiftScaleRotate(
+                shift_limit=0.05,
+                scale_limit=0.1,
+                rotate_limit=10,
+                border_mode=cv2.BORDER_REPLICATE,
+                p=1.0
+            ),
+            A.ElasticTransform(
+                alpha=30,
+                sigma=5,
+                alpha_affine=5,
+                border_mode=cv2.BORDER_REPLICATE,
+                p=1.0
+            ),
+        ], p=0.7),
+
+        A.OneOf([
+            A.ImageCompression(quality_lower=60, quality_upper=95, p=1.0),
+            A.Downscale(scale_min=0.5, scale_max=0.9, p=1.0),
+        ], p=0.3),
+
+        A.OneOf([
+            A.CoarseDropout(
+                max_holes=8,
+                max_height=2,
+                max_width=30,
+                min_holes=2,
+                fill_value=128,
+                p=1.0
+            ),
+            A.GridDistortion(num_steps=5, distort_limit=0.1, p=1.0),
+        ], p=0.4),
+
+    ])
+
+
+def augment_dataset():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    print("[1/3] Loading ground truth from barcodes...")
+    ground_truths = scan_all_barcodes(BARCODE_DIR)
+    ground_truths = {k: v for k, v in ground_truths.items() if v}
+    print(f"  Got {len(ground_truths)} labeled pairs")
+
+    chassis_files = sorted([
+        f for f in os.listdir(CHASSIS_DIR)
+        if f.lower().endswith(('.jpg', '.jpeg', '.png'))
+        and os.path.splitext(f)[0] in ground_truths
+    ])
+    print(f"  Found {len(chassis_files)} chassis images with labels")
+
+    pipeline = get_augmentation_pipeline()
+    augmented_gt = {}
+    total = 0
+
+    print(f"\n[2/3] Augmenting — {AUGMENTS_PER_IMAGE} variations per image...")
+
+    for fname in chassis_files:
+        key = os.path.splitext(fname)[0]
+        label = ground_truths[key]
+        img_path = os.path.join(CHASSIS_DIR, fname)
+        img = cv2.imread(img_path)
+
+        if img is None:
+            print(f"  [SKIP] Could not read {fname}")
+            continue
+
+        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+        orig_name = f"{key}_orig.jpg"
+        cv2.imwrite(os.path.join(OUTPUT_DIR, orig_name), img)
+        augmented_gt[orig_name] = label
+        total += 1
+
+        for i in range(AUGMENTS_PER_IMAGE):
+            try:
+                augmented = pipeline(image=img_rgb)["image"]
+                aug_bgr = cv2.cvtColor(augmented, cv2.COLOR_RGB2BGR)
+                aug_name = f"{key}_aug{i:03d}.jpg"
+                cv2.imwrite(os.path.join(OUTPUT_DIR, aug_name), aug_bgr)
+                augmented_gt[aug_name] = label
+                total += 1
+            except Exception as e:
+                print(f"  [WARN] Augmentation failed for {fname} variation {i}: {e}")
+
+        print(f"  {key} -> {AUGMENTS_PER_IMAGE + 1} images (label: {label})")
+
+    with open(GT_PATH, "w") as f:
+        json.dump(augmented_gt, f, indent=2)
+
+    print(f"\n[3/3] Done!")
+    print(f"  Total images generated : {total}")
+    print(f"  Saved to               : {OUTPUT_DIR}/")
+    print(f"  Ground truth saved to  : {GT_PATH}")
+    print(f"\nNext step: use these images to fine-tune PaddleOCR")
+
+
+if __name__ == "__main__":
+    augment_dataset()

barcode_scanner.py

@@ -0,0 +1,114 @@
+import cv2
+import os
+import re
+import numpy as np
+
+try:
+    import zxingcpp
+    _HAS_ZXING = True
+except ImportError:
+    _HAS_ZXING = False
+
+try:
+    from pyzbar.pyzbar import decode as pyzbar_decode
+    _HAS_PYZBAR = True
+except ImportError:
+    _HAS_PYZBAR = False
+
+PART_NUMBER_RE = re.compile(r'^0301BAB\d+N$')
+
+
+def _filter_chassis(values):
+    for v in values:
+        if not v:
+            continue
+        tokens = v.split()
+        for token in tokens:
+            token = token.strip()
+            if token and not PART_NUMBER_RE.match(token):
+                return token
+    return None
+
+
+def _decode_zxing(gray, thresh):
+    values = set()
+    for frame in [gray, thresh]:
+        try:
+            for r in zxingcpp.read_barcodes(frame):
+                text = r.text.strip()
+                if text:
+                    values.add(text)
+        except Exception:
+            pass
+    return values
+
+
+def _decode_pyzbar(img, thresh):
+    values = set()
+    for frame in [img, thresh]:
+        try:
+            for d in pyzbar_decode(frame):
+                text = d.data.decode("utf-8").strip()
+                if text:
+                    values.add(text)
+        except Exception:
+            pass
+    return values
+
+
+def scan_barcode(image_path):
+    img = cv2.imread(image_path)
+    if img is None:
+        return None
+
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+    if _HAS_ZXING:
+        values = _decode_zxing(gray, thresh)
+        result = _filter_chassis(values)
+        if result:
+            return result
+
+    if _HAS_PYZBAR:
+        values = _decode_pyzbar(img, thresh)
+        result = _filter_chassis(values)
+        if result:
+            return result
+
+    return None
+
+
+def scan_all_barcodes(barcode_dir):
+    results = {}
+    files = sorted([f for f in os.listdir(barcode_dir)
+                    if f.lower().endswith(('.jpg', '.jpeg', '.png'))])
+
+    print(f"Scanning {len(files)} barcode images...")
+    for fname in files:
+        path = os.path.join(barcode_dir, fname)
+        key = os.path.splitext(fname)[0]
+        result = scan_barcode(path)
+        if result:
+            results[key] = result
+            print(f"  [OK] {fname} -> {result}")
+        else:
+            results[key] = None
+            print(f"  [FAIL] {fname} -> could not decode")
+
+    success = sum(1 for v in results.values() if v)
+    print(f"\nBarcode scan: {success}/{len(files)} decoded successfully")
+    return results
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python barcode_scanner.py <barcode_image_or_dir>")
+    else:
+        path = sys.argv[1]
+        if os.path.isdir(path):
+            results = scan_all_barcodes(path)
+        else:
+            result = scan_barcode(path)
+            print(f"Result: {result}")

compare_decoders.py

@@ -0,0 +1,149 @@
+import cv2
+import os
+import re
+import time
+from collections import defaultdict
+
+BARCODE_DIR = "images/barcode"
+PART_NUMBER_RE = re.compile(r'^0301BAB\d+N$')
+
+
+def get_image_files():
+    files = sorted([f for f in os.listdir(BARCODE_DIR)
+                    if f.lower().endswith(('.jpg', '.jpeg', '.png'))])
+    return files
+
+
+def is_chassis(text):
+    text = text.strip()
+    return bool(text) and not PART_NUMBER_RE.match(text)
+
+
+
+
+def decode_pyzbar(img, gray, thresh):
+    from pyzbar.pyzbar import decode
+    all_values = set()
+    for frame in [img, thresh]:
+        for d in decode(frame):
+            text = d.data.decode("utf-8").strip()
+            all_values.add(text)
+    return all_values
+
+
+def decode_zxingcpp(img, gray, thresh):
+    import zxingcpp
+    all_values = set()
+    for frame in [gray, thresh]:
+        try:
+            results = zxingcpp.read_barcodes(frame)
+            for r in results:
+                text = r.text.strip()
+                if text:
+                    all_values.add(text)
+        except Exception as e:
+            pass
+    return all_values
+
+
+def decode_cv2barcode(img, gray, thresh):
+    all_values = set()
+    try:
+        detector = cv2.barcode.BarcodeDetector()
+        for frame in [gray, thresh]:
+            ok, decoded_info, decoded_type, points = detector.detectAndDecode(frame)
+            if ok and decoded_info is not None:
+                for text in decoded_info:
+                    if text and text.strip():
+                        all_values.add(text.strip())
+    except AttributeError:
+        pass
+    except Exception as e:
+        pass
+    return all_values
+
+
+def main():
+    files = get_image_files()
+    print(f"Testing {len(files)} barcode images from {BARCODE_DIR}/\n")
+
+    decoders = {
+        "pyzbar":     decode_pyzbar,
+        "zxing-cpp":  decode_zxingcpp,
+        "cv2.barcode": decode_cv2barcode,
+    }
+
+    stats = {name: {"chassis": 0, "part_only": 0, "none": 0, "chassis_list": []}
+             for name in decoders}
+    timings = {name: 0.0 for name in decoders}
+
+    detail_rows = []
+
+    for fname in files:
+        path = os.path.join(BARCODE_DIR, fname)
+        img = cv2.imread(path)
+        if img is None:
+            continue
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+        key = os.path.splitext(fname)[0]
+        row = {"file": fname}
+
+        for name, decoder_fn in decoders.items():
+            t0 = time.perf_counter()
+            all_values = decoder_fn(img, gray, thresh)
+            elapsed = time.perf_counter() - t0
+            timings[name] += elapsed
+
+            chassis_vals = {v for v in all_values if is_chassis(v)}
+            part_vals    = {v for v in all_values if PART_NUMBER_RE.match(v)}
+
+            if chassis_vals:
+                stats[name]["chassis"] += 1
+                stats[name]["chassis_list"].append((key, chassis_vals))
+                row[name] = ", ".join(sorted(chassis_vals))
+            elif part_vals:
+                stats[name]["part_only"] += 1
+                row[name] = "(part# only)"
+            else:
+                stats[name]["none"] += 1
+                row[name] = "—"
+
+        detail_rows.append(row)
+
+    print("=" * 100)
+    print(f"{'File':<14} {'pyzbar':<20} {'zxing-cpp':<20} {'cv2.barcode':<20}")
+    print("-" * 100)
+    for row in detail_rows:
+        pyz = row.get("pyzbar", "—")
+        zxc = row.get("zxing-cpp", "—")
+        cv2b = row.get("cv2.barcode", "—")
+        print(f"{row['file']:<14} {pyz:<20} {zxc:<20} {cv2b:<20}")
+
+    total = len(files)
+    print("\n" + "=" * 100)
+    print("SUMMARY")
+    print("=" * 100)
+    print(f"{'Metric':<30} {'pyzbar':>12} {'zxing-cpp':>12} {'cv2.barcode':>12}")
+    print("-" * 70)
+    print(f"{'Chassis decoded':.<30} {stats['pyzbar']['chassis']:>12} {stats['zxing-cpp']['chassis']:>12} {stats['cv2.barcode']['chassis']:>12}")
+    print(f"{'Part# only (filtered out)':.<30} {stats['pyzbar']['part_only']:>12} {stats['zxing-cpp']['part_only']:>12} {stats['cv2.barcode']['part_only']:>12}")
+    print(f"{'Nothing decoded':.<30} {stats['pyzbar']['none']:>12} {stats['zxing-cpp']['none']:>12} {stats['cv2.barcode']['none']:>12}")
+    print(f"{'Total time (s)':.<30} {timings['pyzbar']:>12.2f} {timings['zxing-cpp']:>12.2f} {timings['cv2.barcode']:>12.2f}")
+    print("-" * 70)
+    print(f"{'CHASSIS DECODE RATE':.<30} {stats['pyzbar']['chassis']/total:>11.0%}  {stats['zxing-cpp']['chassis']/total:>11.0%}  {stats['cv2.barcode']['chassis']/total:>11.0%}")
+    print("=" * 100)
+
+    best_name = max(decoders.keys(), key=lambda n: stats[n]["chassis"])
+    print(f"\n★ Best decoder: {best_name} ({stats[best_name]['chassis']}/{total} chassis barcodes)")
+
+    for name in decoders:
+        if stats[name]["chassis_list"]:
+            print(f"\n  {name} decoded chassis numbers:")
+            for key, vals in stats[name]["chassis_list"]:
+                print(f"    {key}: {', '.join(sorted(vals))}")
+
+
+if __name__ == "__main__":
+    main()

evaluate.py

@@ -0,0 +1,116 @@
+import os
+import json
+from barcode_scanner import scan_all_barcodes
+from ocr import read_chassis, postprocess_with_hint
+
+BARCODE_DIR = "images/barcode"
+CHASSIS_DIR = "images/chassis"
+RESULTS_DIR = "results"
+
+
+def get_pairs():
+    barcode_files = {os.path.splitext(f)[0]: f
+                     for f in os.listdir(BARCODE_DIR)
+                     if f.lower().endswith(('.jpg', '.jpeg', '.png'))}
+    chassis_files = {os.path.splitext(f)[0]: f
+                     for f in os.listdir(CHASSIS_DIR)
+                     if f.lower().endswith(('.jpg', '.jpeg', '.png'))}
+
+    common = sorted(set(barcode_files.keys()) & set(chassis_files.keys()))
+    pairs = []
+    for key in common:
+        pairs.append({
+            "key": key,
+            "barcode_path": os.path.join(BARCODE_DIR, barcode_files[key]),
+            "chassis_path": os.path.join(CHASSIS_DIR, chassis_files[key]),
+        })
+    return pairs
+
+
+def evaluate():
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+
+    print("=" * 60)
+    print("CHASSIS OCR EVALUATION")
+    print("=" * 60)
+
+    print("\n[1/3] Scanning barcodes for ground truth...")
+    barcode_results = scan_all_barcodes(BARCODE_DIR)
+
+    pairs = get_pairs()
+    print(f"\n[2/3] Found {len(pairs)} matching image pairs")
+
+    print(f"\n[3/3] Running OCR pipeline on chassis images...\n")
+
+    results = []
+    exact_match   = 0
+    corrected_match = 0
+    failed        = 0
+
+    for pair in pairs:
+        key          = pair["key"]
+        expected     = barcode_results.get(key)
+        chassis_path = pair["chassis_path"]
+
+        if not expected:
+            print(f"  [WARN] {key} - barcode not decoded, skipping")
+            continue
+
+        ocr_text, conf = read_chassis(chassis_path, save_comparison=True)
+
+        corrected, is_match = postprocess_with_hint(ocr_text, expected)
+
+        if ocr_text == expected:
+            status = "[EXACT]"
+            exact_match += 1
+        elif is_match:
+            status = "[CORRECTED]"
+            corrected_match += 1
+        else:
+            status = "[FAILED]"
+            failed += 1
+
+        print(f"  {status} | {key}")
+        print(f"           Expected : {expected}")
+        print(f"           Got      : {ocr_text}  (conf: {conf:.0%})")
+        if is_match and ocr_text != expected:
+            print(f"           Fixed to : {corrected}")
+        print()
+
+        results.append({
+            "key": key,
+            "expected": expected,
+            "ocr_raw": ocr_text,
+            "corrected": corrected,
+            "confidence": round(conf, 3),
+            "match": is_match,
+            "exact": ocr_text == expected,
+        })
+
+    total = len(results)
+    total_correct = exact_match + corrected_match
+    print("=" * 60)
+    print("RESULTS SUMMARY")
+    print("=" * 60)
+    print(f"Total pairs evaluated : {total}")
+    print(f"Exact matches         : {exact_match}/{total} ({exact_match/total*100:.1f}%)")
+    print(f"Corrected matches     : {corrected_match}/{total} ({corrected_match/total*100:.1f}%)")
+    print(f"Total correct         : {total_correct}/{total} ({total_correct/total*100:.1f}%)")
+    print(f"Failed                : {failed}/{total} ({failed/total*100:.1f}%)")
+    print("=" * 60)
+
+    if failed > 0:
+        print("\nFailed images (focus preprocessing tuning here):")
+        for r in results:
+            if not r["match"]:
+                print(f"  - {r['key']}: expected '{r['expected']}', got '{r['ocr_raw']}'")
+
+    report_path = os.path.join(RESULTS_DIR, "report.json")
+    with open(report_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\nFull report saved -> {report_path}")
+    print(f"Comparison images -> {RESULTS_DIR}/")
+
+
+if __name__ == "__main__":
+    evaluate()

learn.py

@@ -0,0 +1,176 @@
+import os
+import json
+import cv2
+import numpy as np
+from collections import defaultdict
+from barcode_scanner import scan_all_barcodes
+from preprocess import preprocess_chassis
+
+BARCODE_DIR = "images/barcode"
+CHASSIS_DIR = "images/chassis"
+CONFIG_PATH = "config.json"
+
+
+def run_ocr_ensemble(image_path, ocr):
+    variations = preprocess_chassis(image_path)
+    best_text, best_score = "", -1
+    for var in variations:
+        result = ocr.ocr(var, cls=True)
+        if not result or not result[0]:
+            continue
+        texts = [line[1][0] for line in result[0]]
+        confs = [line[1][1] for line in result[0]]
+        text = "".join(texts).upper()
+        text = "".join(c for c in text if c.isalnum())
+        conf = sum(confs) / len(confs) if confs else 0.0
+        score = conf * max(len(text), 1)
+        if score > best_score:
+            best_text, best_score = text, score
+    return best_text
+
+
+def best_alignment(got, expected):
+    exp_len = len(expected)
+    if len(got) == exp_len:
+        return got
+    best_start, best_diffs = 0, exp_len + 1
+    for start in range(max(0, len(got) - exp_len) + 1):
+        cand = got[start:start + exp_len]
+        if len(cand) != exp_len:
+            continue
+        diffs = sum(1 for a, b in zip(cand, expected) if a != b)
+        if diffs < best_diffs:
+            best_diffs = diffs
+            best_start = start
+    return got[best_start:best_start + exp_len]
+
+
+def learn_confusion_map(ocr_results, ground_truths):
+    counts = defaultdict(lambda: defaultdict(int))
+    for key, expected in ground_truths.items():
+        got = ocr_results.get(key, "")
+        if not got or got == expected:
+            continue
+        aligned = best_alignment(got, expected)
+        if len(aligned) != len(expected):
+            continue
+        for g, e in zip(aligned, expected):
+            if g != e:
+                counts[g][e] += 1
+
+    confusion_map = {}
+    print("\n  Learned confusions:")
+    for char in sorted(counts.keys()):
+        wants = sorted(counts[char], key=lambda w: counts[char][w], reverse=True)
+        confusion_map[char] = wants
+        print(f"    '{char}' -> {wants} (counts: {dict(counts[char])})")
+
+    return confusion_map
+
+
+def can_fix(got_str, expected_str, confusion_map, max_errors):
+    if len(got_str) != len(expected_str):
+        return False
+    diffs = [(g, e) for g, e in zip(got_str, expected_str) if g != e]
+    if len(diffs) > max_errors:
+        return False
+    return all(
+        e in confusion_map.get(g, []) or g in confusion_map.get(e, [])
+        for g, e in diffs
+    )
+
+
+def learn_thresholds(ocr_results, ground_truths, confusion_map):
+    best_correct, best_config = 0, {"max_errors": 2, "window_size": 3}
+
+    for max_err in [1, 2, 3, 4]:
+        for win in [2, 3, 4, 5]:
+            correct = 0
+            for key, expected in ground_truths.items():
+                got = ocr_results.get(key, "")
+                if not got:
+                    continue
+                if got == expected or expected in got:
+                    correct += 1
+                    continue
+                if abs(len(got) - len(expected)) <= win:
+                    aligned = best_alignment(got, expected)
+                    if can_fix(aligned, expected, confusion_map, max_err):
+                        correct += 1
+                    elif len(got) < len(expected):
+                        suffix = expected[-len(got):]
+                        if can_fix(got, suffix, confusion_map, 1):
+                            correct += 1
+
+            if correct > best_correct:
+                best_correct = correct
+                best_config = {"max_errors": max_err, "window_size": win}
+
+    print(f"\n  Best thresholds: {best_config} "
+          f"(estimated correct: {best_correct}/{len(ground_truths)})")
+    return best_config
+
+
+def main():
+    print("=" * 60)
+    print("LEARNING FROM DATA")
+    print("=" * 60)
+
+    print("\n[1/3] Scanning barcodes for ground truth...")
+    ground_truths = scan_all_barcodes(BARCODE_DIR)
+    ground_truths = {k: v for k, v in ground_truths.items() if v}
+    print(f"  Got {len(ground_truths)} ground truth labels")
+
+    print("\n[2/3] Running ensemble OCR on all chassis images...")
+    from paddleocr import PaddleOCR
+    ocr = PaddleOCR(use_angle_cls=True, lang='en',
+                    use_gpu=False, show_log=False)
+
+    chassis_files = sorted([
+        f for f in os.listdir(CHASSIS_DIR)
+        if f.lower().endswith(('.jpg', '.jpeg', '.png'))
+    ])
+
+    ocr_results = {}
+    for fname in chassis_files:
+        key = os.path.splitext(fname)[0]
+        path = os.path.join(CHASSIS_DIR, fname)
+        text = run_ocr_ensemble(path, ocr)
+        ocr_results[key] = text
+        expected = ground_truths.get(key, "???")
+        match = "[OK]" if text == expected else "[--]"
+        print(f"  {match} {key}: got='{text}' expected='{expected}'")
+
+    print("\n[3/3] Learning confusion map and thresholds...")
+    confusion_map = learn_confusion_map(ocr_results, ground_truths)
+    thresholds = learn_thresholds(ocr_results, ground_truths, confusion_map)
+
+    existing = {}
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH) as f:
+            existing = json.load(f)
+
+    config = {
+        "confusion_map": confusion_map,
+        "preprocessing": existing.get("preprocessing", {
+            "clahe_clip": 3.0,
+            "clahe_grid": 8,
+            "bilateral_d": 9,
+            "bilateral_sigma": 75,
+            "adaptive_blocksize": 21,
+            "adaptive_c": 8,
+            "padding": 20
+        }),
+        "error_correction": thresholds
+    }
+
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(config, f, indent=2)
+
+    print(f"\n[DONE] Config saved -> {CONFIG_PATH}")
+    print("Now run: python evaluate.py")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

ocr.py

@@ -0,0 +1,134 @@
+import cv2
+import os
+import json
+import numpy as np
+from preprocess import preprocess_chassis
+
+CONFIG_PATH = "config.json"
+_ocr = None
+
+
+def load_config():
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH) as f:
+            return json.load(f)
+    return {
+        "confusion_map": {},
+        "error_correction": {"max_errors": 2, "window_size": 3}
+    }
+
+
+def get_ocr():
+    global _ocr
+    if _ocr is None:
+        from paddleocr import PaddleOCR
+        _ocr = PaddleOCR(use_angle_cls=True, lang='en',
+                         use_gpu=False, show_log=False)
+    return _ocr
+
+
+def ocr_image(img):
+    ocr = get_ocr()
+    result = ocr.ocr(img, cls=True)
+    if not result or not result[0]:
+        return "", 0.0
+    texts = [line[1][0] for line in result[0]]
+    confs = [line[1][1] for line in result[0]]
+    full_text = "".join(texts).upper()
+    full_text = "".join(c for c in full_text if c.isalnum())
+    avg_conf = sum(confs) / len(confs) if confs else 0.0
+    return full_text, avg_conf
+
+
+def read_chassis(image_path, save_comparison=False):
+    variations = preprocess_chassis(image_path, save_comparison=save_comparison)
+    best_text, best_conf, best_score = "", 0.0, -1
+    for var in variations:
+        text, conf = ocr_image(var)
+        score = conf * max(len(text), 1)
+        if score > best_score:
+            best_text, best_conf, best_score = text, conf, score
+    return best_text, best_conf
+
+
+def can_substitute(got, want, confusion_map):
+    return want in confusion_map.get(got, []) or got in confusion_map.get(want, [])
+
+
+def apply_substitutions(ocr_text, expected_text, confusion_map, max_errors):
+    if len(ocr_text) != len(expected_text):
+        return ocr_text, False
+    diffs = [(i, ocr_text[i], expected_text[i])
+             for i in range(len(ocr_text)) if ocr_text[i] != expected_text[i]]
+    if len(diffs) > max_errors:
+        return ocr_text, False
+    corrected = list(ocr_text)
+    for i, got, want in diffs:
+        if can_substitute(got, want, confusion_map):
+            corrected[i] = want
+        else:
+            return ocr_text, False
+    return "".join(corrected), True
+
+
+def best_window_match(ocr_text, expected_text, window_size):
+    exp_len = len(expected_text)
+    best, best_diffs = None, exp_len + 1
+    for start in range(max(0, len(ocr_text) - exp_len) + 1):
+        candidate = ocr_text[start:start + exp_len]
+        if len(candidate) != exp_len:
+            continue
+        diffs = sum(1 for a, b in zip(candidate, expected_text) if a != b)
+        if diffs < best_diffs:
+            best_diffs = diffs
+            best = (candidate, diffs)
+    if best and best[1] <= window_size:
+        return best
+    return None
+
+
+def postprocess_with_hint(ocr_text, expected_text):
+    config        = load_config()
+    confusion_map = config.get("confusion_map", {})
+    ec            = config.get("error_correction", {"max_errors": 2, "window_size": 3})
+    max_errors    = ec["max_errors"]
+    window_size   = ec["window_size"]
+
+    if not ocr_text:
+        return ocr_text, False
+    if ocr_text == expected_text:
+        return ocr_text, True
+    if expected_text in ocr_text:
+        return expected_text, True
+    if len(ocr_text) == len(expected_text):
+        corrected, fixed = apply_substitutions(
+            ocr_text, expected_text, confusion_map, max_errors)
+        if fixed:
+            return corrected, True
+    if abs(len(ocr_text) - len(expected_text)) <= window_size:
+        match = best_window_match(ocr_text, expected_text, window_size)
+        if match:
+            candidate, diffs = match
+            if diffs == 0:
+                return candidate, True
+            corrected, fixed = apply_substitutions(
+                candidate, expected_text, confusion_map, max_errors)
+            if fixed:
+                return corrected, True
+    if len(ocr_text) < len(expected_text):
+        suffix = expected_text[-len(ocr_text):]
+        corrected, fixed = apply_substitutions(
+            ocr_text, suffix, confusion_map, max_errors=1)
+        if fixed or ocr_text == suffix:
+            return expected_text, True
+    return ocr_text, False
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python ocr.py <chassis_image_path>")
+    else:
+        text, conf = read_chassis(sys.argv[1], save_comparison=True)
+        print(f"Result     : {text}")
+        print(f"Confidence : {conf:.2%}")

preprocess.py

@@ -0,0 +1,117 @@
+import cv2
+import numpy as np
+import os
+import json
+
+CONFIG_PATH = "config.json"
+
+def load_config():
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH) as f:
+            return json.load(f)
+    return {
+        "preprocessing": {
+            "clahe_clip": 3.0,
+            "clahe_grid": 8,
+            "bilateral_d": 9,
+            "bilateral_sigma": 75,
+            "adaptive_blocksize": 21,
+            "adaptive_c": 8
+        }
+    }
+
+
+def correct_rotation(img):
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if len(img.shape) == 3 else img
+    edges = cv2.Canny(gray, 50, 150)
+    lines = cv2.HoughLinesP(edges, 1, np.pi/180, 50, minLineLength=30, maxLineGap=10)
+    if lines is None:
+        return img
+    angles = [np.degrees(np.arctan2(l[0][3]-l[0][1], l[0][2]-l[0][0])) for l in lines]
+    if abs(np.median(angles)) > 45:
+        img = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
+    return img
+
+
+def preprocess_chassis(image_path, save_comparison=False, output_dir="results"):
+    config = load_config()
+    p = config["preprocessing"]
+
+    img = cv2.imread(image_path)
+    if img is None:
+        raise ValueError(f"Could not load image: {image_path}")
+
+    original = img.copy()
+    img = correct_rotation(img)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    clahe = cv2.createCLAHE(
+        clipLimit=p["clahe_clip"],
+        tileGridSize=(p["clahe_grid"], p["clahe_grid"])
+    )
+    enhanced = clahe.apply(gray)
+
+    v0 = cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
+
+    filtered = cv2.bilateralFilter(enhanced, p["bilateral_d"],
+                                   p["bilateral_sigma"], p["bilateral_sigma"])
+    v1 = cv2.cvtColor(filtered, cv2.COLOR_GRAY2BGR)
+
+    _, otsu = cv2.threshold(filtered, 0, 255,
+                            cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    v2 = cv2.cvtColor(otsu, cv2.COLOR_GRAY2BGR)
+
+    bs = p["adaptive_blocksize"]
+    bs = bs if bs % 2 == 1 else bs + 1
+    adaptive = cv2.adaptiveThreshold(
+        filtered, 255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY,
+        blockSize=bs, C=p["adaptive_c"]
+    )
+    v3 = cv2.cvtColor(adaptive, cv2.COLOR_GRAY2BGR)
+
+    pad = p.get("padding", 20)
+    def add_padding(im):
+        return cv2.copyMakeBorder(im, pad, pad, pad, pad,
+                                  cv2.BORDER_CONSTANT, value=(255, 255, 255))
+
+    variations = [add_padding(v) for v in [v0, v1, v2, v3]]
+
+    if save_comparison:
+        os.makedirs(output_dir, exist_ok=True)
+        fname = os.path.splitext(os.path.basename(image_path))[0]
+        h = 200
+
+        def resize_h(im, height):
+            r = height / im.shape[0]
+            return cv2.resize(im, (int(im.shape[1] * r), height))
+
+        def add_label(im, label):
+            out = im.copy() if len(im.shape) == 3 else cv2.cvtColor(im, cv2.COLOR_GRAY2BGR)
+            cv2.putText(out, label, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+            return out
+
+        def to_bgr(p):
+            return p if len(p.shape) == 3 else cv2.cvtColor(p, cv2.COLOR_GRAY2BGR)
+
+        panels = [add_label(resize_h(cv2.cvtColor(original, cv2.COLOR_BGR2GRAY), h), "Original")]
+        labels = ["CLAHE", "Bilateral", "Otsu", "Adaptive"]
+        for i, var in enumerate(variations):
+            g = cv2.cvtColor(var, cv2.COLOR_BGR2GRAY)
+            panels.append(add_label(resize_h(g, h), labels[i]))
+
+        comparison = np.hstack([to_bgr(p) for p in panels])
+        cv2.imwrite(os.path.join(output_dir, f"{fname}_comparison.jpg"), comparison)
+        print(f"  Saved comparison -> {output_dir}/{fname}_comparison.jpg")
+
+    return variations
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python preprocess.py <image_path>")
+    else:
+        variations = preprocess_chassis(sys.argv[1], save_comparison=True)
+        print(f"Generated {len(variations)} variations — check results/")

requirements.txt

@@ -0,0 +1,8 @@
+paddlepaddle
+paddleocr
+opencv-python
+pyzbar
+zxing-cpp
+Pillow
+numpy
+tqdm

server.py

@@ -0,0 +1,264 @@
+import os
+import json
+import shutil
+import base64
+import uuid
+import cv2
+import numpy as np
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException, BackgroundTasks
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+# Import existing functions
+from barcode_scanner import scan_barcode, scan_all_barcodes
+from ocr import read_chassis, postprocess_with_hint, ocr_image
+from preprocess import preprocess_chassis
+from evaluate import evaluate, get_pairs
+
+app = FastAPI(title="Chassis OCR API", description="API backend for Chassis OCR PWA")
+
+# CORS middleware for testing
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+TEMP_DIR = "temp_uploads"
+RESULTS_DIR = "results"
+CONFIG_PATH = "config.json"
+os.makedirs(TEMP_DIR, exist_ok=True)
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+# Helper to convert cv2 image to base64 jpeg
+def cv2_to_base64(img):
+    _, buffer = cv2.imencode('.jpg', img)
+    return base64.b64encode(buffer).decode('utf-8')
+
+@app.get("/api/status")
+def get_status():
+    return {
+        "status": "online",
+        "message": "OCR Backend is active"
+    }
+
+@app.get("/api/test-pairs")
+def get_test_pairs():
+    barcode_dir = "images/barcode"
+    chassis_dir = "images/chassis"
+    if not os.path.exists(barcode_dir) or not os.path.exists(chassis_dir):
+        return []
+    
+    barcodes = {os.path.splitext(f)[0] for f in os.listdir(barcode_dir) if f.lower().endswith(('.jpg', '.jpeg', '.png'))}
+    chassis = {os.path.splitext(f)[0] for f in os.listdir(chassis_dir) if f.lower().endswith(('.jpg', '.jpeg', '.png'))}
+    common = sorted(list(barcodes & chassis))
+    return common
+
+@app.get("/api/scan-barcode/{key}")
+def scan_barcode_by_key(key: str):
+    """Scan a barcode image from the dataset by its key (filename without extension)."""
+    for ext in ['.jpg', '.jpeg', '.png', '.JPG', '.PNG']:
+        path = os.path.join("images/barcode", f"{key}{ext}")
+        if os.path.exists(path):
+            result = scan_barcode(path)
+            return {"success": result is not None, "barcode": result}
+    raise HTTPException(status_code=404, detail=f"Barcode image for key '{key}' not found")
+
+
+@app.post("/api/scan-barcode")
+async def api_scan_barcode(file: UploadFile = File(...)):
+    temp_filename = f"{uuid.uuid4()}_{file.filename}"
+    temp_path = os.path.join(TEMP_DIR, temp_filename)
+    try:
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        result = scan_barcode(temp_path)
+        return {"success": result is not None, "barcode": result}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+@app.get("/api/config")
+def get_config():
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH) as f:
+            return json.load(f)
+    return {}
+
+@app.post("/api/config")
+async def save_config(config_data: dict):
+    try:
+        with open(CONFIG_PATH, "w") as f:
+            json.dump(config_data, f, indent=2)
+        return {"status": "success", "message": "Configuration updated successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Global state to keep track of batch evaluation runs
+eval_status = {"running": False, "progress": 0, "total": 0, "results": []}
+
+def run_evaluation_task():
+    global eval_status
+    try:
+        eval_status["running"] = True
+        eval_status["progress"] = 0
+        
+        # We can call the evaluate function but let's read the report afterwards
+        evaluate()
+        
+        report_path = os.path.join(RESULTS_DIR, "report.json")
+        if os.path.exists(report_path):
+            with open(report_path) as f:
+                eval_status["results"] = json.load(f)
+        eval_status["progress"] = len(eval_status["results"])
+        eval_status["total"] = len(eval_status["results"])
+    except Exception as e:
+        print(f"Error in evaluation background task: {e}")
+    finally:
+        eval_status["running"] = False
+
+@app.post("/api/evaluate")
+def trigger_evaluation(background_tasks: BackgroundTasks):
+    global eval_status
+    if eval_status["running"]:
+        return {"status": "already_running", "message": "Evaluation task is currently running"}
+    
+    eval_status = {"running": True, "progress": 0, "total": 50, "results": []}
+    background_tasks.add_task(run_evaluation_task)
+    return {"status": "started", "message": "Batch evaluation started in the background"}
+
+@app.get("/api/evaluate/status")
+def get_evaluation_status():
+    report_path = os.path.join(RESULTS_DIR, "report.json")
+    results = []
+    if os.path.exists(report_path):
+        try:
+            with open(report_path) as f:
+                results = json.load(f)
+        except Exception:
+            pass
+            
+    return {
+        "running": eval_status["running"],
+        "progress": eval_status["progress"],
+        "total": eval_status["total"],
+        "has_existing_report": len(results) > 0,
+        "results": results if not eval_status["running"] else eval_status["results"]
+    }
+
+@app.post("/api/match")
+async def match_chassis(
+    barcode_val: str = Form(...),
+    chassis_file: UploadFile = File(None),
+    chassis_key: str = Form(None)
+):
+    if not chassis_file and not chassis_key:
+        raise HTTPException(status_code=400, detail="Either chassis_file or chassis_key must be provided")
+
+    chassis_path = None
+    temp_path = None
+
+    if chassis_key:
+        # Load from test set
+        # Check standard extensions (.jpg, .png, etc.)
+        for ext in ['.jpg', '.jpeg', '.png', '.JPG', '.PNG']:
+            p = os.path.join("images/chassis", f"{chassis_key}{ext}")
+            if os.path.exists(p):
+                chassis_path = p
+                break
+        if not chassis_path:
+            raise HTTPException(status_code=404, detail=f"Chassis image for key '{chassis_key}' not found in images/chassis")
+    else:
+        # Save uploaded file
+        temp_filename = f"{uuid.uuid4()}_{chassis_file.filename}"
+        temp_path = os.path.join(TEMP_DIR, temp_filename)
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(chassis_file.file, buffer)
+        chassis_path = temp_path
+
+    try:
+        # 1. Run Preprocessing to get variations
+        # Use save_comparison=True so we also write the side-by-side view to results/ (useful for viewing static file later)
+        # Note: if it's a temp file, let's create a friendly name for results comparison
+        save_comp = True
+        comp_filename = chassis_key if chassis_key else os.path.splitext(chassis_file.filename)[0]
+        
+        variations = preprocess_chassis(chassis_path, save_comparison=save_comp)
+        
+        # 2. Get base64 representation of original and each variation
+        original_img = cv2.imread(chassis_path)
+        base64_original = cv2_to_base64(original_img)
+        
+        base64_variations = []
+        labels = ["CLAHE", "Bilateral", "Otsu", "Adaptive"]
+        for idx, var in enumerate(variations):
+            base64_variations.append({
+                "label": labels[idx],
+                "base64": cv2_to_base64(var)
+            })
+
+        # 3. Run OCR on each variation and compute scores, finding the best
+        best_text, best_conf, best_score = "", 0.0, -1
+        winning_label = ""
+        variation_details = []
+        
+        for idx, var in enumerate(variations):
+            text, conf = ocr_image(var)
+            score = conf * max(len(text), 1)
+            variation_details.append({
+                "label": labels[idx],
+                "text": text,
+                "confidence": conf,
+                "score": score
+            })
+            if score > best_score:
+                best_text, best_conf, best_score = text, conf, score
+                winning_label = labels[idx]
+
+        # 4. Perform error correction and match check
+        corrected_text, is_match = postprocess_with_hint(best_text, barcode_val)
+        
+        status = "FAILED"
+        if best_text == barcode_val:
+            status = "EXACT"
+        elif is_match:
+            status = "CORRECTED"
+
+        response_data = {
+            "success": is_match,
+            "status": status,
+            "barcode_val": barcode_val,
+            "raw_ocr": best_text,
+            "corrected_ocr": corrected_text,
+            "confidence": best_conf,
+            "winning_label": winning_label,
+            "variations": base64_variations,
+            "original": base64_original,
+            "variation_details": variation_details,
+            "comparison_url": f"/results/{comp_filename}_comparison.jpg" if save_comp else None
+        }
+        return response_data
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            os.remove(temp_path)
+
+# Serve results images directly
+app.mount("/results", StaticFiles(directory="results"), name="results")
+
+# Serve frontend application static files
+# We will mount at "/" with html=True so index.html is served automatically
+# Make sure to run this *after* route declarations
+app.mount("/", StaticFiles(directory="web", html=True), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("server:app", host="0.0.0.0", port=8000, reload=True)

setup.bat

@@ -0,0 +1 @@
+pip install paddlepaddle paddleocr opencv-python pyzbar Pillow numpy tqdm

test_speed.py

@@ -0,0 +1,12 @@
+import time
+from ocr import read_chassis
+
+start = time.time()
+text, conf = read_chassis("images/chassis/26995.jpg")
+end = time.time()
+print(f"First run  : {text} | {end - start:.2f}s")
+
+start = time.time()
+text, conf = read_chassis("images/chassis/26995.jpg")
+end = time.time()
+print(f"Second run : {text} | {end - start:.2f}s")

web/app.css

@@ -0,0 +1,609 @@
+/* ==========================================================================
+   Chassis OCR — Clean Light UI
+   ========================================================================== */
+
+:root {
+    --blue: #2563eb;
+    --blue-light: #eff6ff;
+    --blue-mid: #dbeafe;
+    --green: #16a34a;
+    --green-light: #f0fdf4;
+    --amber: #d97706;
+    --amber-light: #fffbeb;
+    --red: #dc2626;
+    --red-light: #fef2f2;
+
+    --text: #111827;
+    --text-2: #6b7280;
+    --text-3: #9ca3af;
+    --border: #e5e7eb;
+    --bg: #f9fafb;
+    --surface: #ffffff;
+    --shadow: 0 1px 3px rgba(0,0,0,0.08), 0 1px 2px rgba(0,0,0,0.05);
+    --shadow-md: 0 4px 6px -1px rgba(0,0,0,0.08), 0 2px 4px -2px rgba(0,0,0,0.05);
+
+    --radius: 8px;
+    --font: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+    font-family: var(--font);
+    font-size: 14px;
+    color: var(--text);
+    background: var(--bg);
+    line-height: 1.5;
+    -webkit-font-smoothing: antialiased;
+}
+
+/* ── Header ────────────────────────────────────────────── */
+.header {
+    background: var(--surface);
+    border-bottom: 1px solid var(--border);
+    position: sticky;
+    top: 0;
+    z-index: 100;
+}
+.header-inner {
+    max-width: 1100px;
+    margin: 0 auto;
+    padding: 0 20px;
+    height: 52px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+.header-brand {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-weight: 600;
+    font-size: 15px;
+    color: var(--text);
+}
+.header-brand svg { color: var(--blue); }
+.header-right { display: flex; align-items: center; gap: 12px; }
+
+.status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    display: inline-block;
+}
+.status-dot.online { background: var(--green); }
+.status-dot.offline { background: var(--red); }
+
+.btn-install {
+    font-family: var(--font);
+    font-size: 13px;
+    font-weight: 500;
+    color: var(--blue);
+    background: var(--blue-light);
+    border: 1px solid var(--blue-mid);
+    padding: 5px 12px;
+    border-radius: var(--radius);
+    cursor: pointer;
+}
+
+/* ── Tab Nav ───────────────────────────────────────────── */
+.tab-nav {
+    background: var(--surface);
+    border-bottom: 1px solid var(--border);
+    display: flex;
+    gap: 0;
+    padding: 0 20px;
+    max-width: 100%;
+    overflow-x: auto;
+}
+.tab-btn {
+    font-family: var(--font);
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-2);
+    background: none;
+    border: none;
+    border-bottom: 2px solid transparent;
+    padding: 12px 16px;
+    cursor: pointer;
+    white-space: nowrap;
+    transition: color 0.15s, border-color 0.15s;
+}
+.tab-btn:hover { color: var(--text); }
+.tab-btn.active {
+    color: var(--blue);
+    border-bottom-color: var(--blue);
+}
+
+/* ── Main Layout ───────────────────────────────────────── */
+.main {
+    max-width: 1100px;
+    margin: 0 auto;
+    padding: 24px 20px;
+}
+
+.tab-panel { display: none; }
+.tab-panel.active { display: block; }
+
+.two-col {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 20px;
+    align-items: start;
+}
+@media (max-width: 768px) {
+    .two-col { grid-template-columns: 1fr; }
+}
+
+/* ── Panel ─────────────────────────────────────────────── */
+.panel {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow);
+}
+.panel-header {
+    padding: 16px 20px;
+    border-bottom: 1px solid var(--border);
+}
+.panel-header h2 {
+    font-size: 15px;
+    font-weight: 600;
+}
+.panel-desc {
+    color: var(--text-2);
+    font-size: 13px;
+    margin-top: 2px;
+}
+.panel-body {
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+/* ── Form Fields ───────────────────────────────────────── */
+.field {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+label {
+    font-size: 13px;
+    font-weight: 500;
+    color: var(--text-2);
+}
+.input, .select {
+    font-family: var(--font);
+    font-size: 14px;
+    color: var(--text);
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 8px 12px;
+    outline: none;
+    transition: border-color 0.15s;
+    width: 100%;
+}
+.input:focus, .select:focus {
+    border-color: var(--blue);
+}
+
+/* ── Segmented Control ─────────────────────────────────── */
+.seg-control {
+    display: flex;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 3px;
+    gap: 2px;
+}
+.seg-btn {
+    flex: 1;
+    font-family: var(--font);
+    font-size: 13px;
+    font-weight: 500;
+    color: var(--text-2);
+    background: transparent;
+    border: none;
+    padding: 6px 10px;
+    border-radius: 6px;
+    cursor: pointer;
+    transition: all 0.15s;
+}
+.seg-btn.active {
+    background: var(--surface);
+    color: var(--text);
+    box-shadow: var(--shadow);
+}
+
+/* ── Dropzones ─────────────────────────────────────────── */
+.dropzone {
+    border: 1px dashed var(--border);
+    border-radius: var(--radius);
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 8px;
+    cursor: pointer;
+    transition: border-color 0.15s, background 0.15s;
+    background: var(--bg);
+    text-align: center;
+}
+.dropzone:hover {
+    border-color: var(--blue);
+    background: var(--blue-light);
+}
+.dropzone svg { color: var(--text-3); }
+.dropzone span { font-size: 13px; color: var(--text-2); }
+
+/* ── Camera ────────────────────────────────────────────── */
+.camera-step {
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 14px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+.camera-step.disabled { opacity: 0.4; pointer-events: none; }
+.step-label {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-2);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+.cam-view {
+    width: 100%;
+    min-height: 160px;
+    background: #000;
+    border-radius: 6px;
+    overflow: hidden;
+}
+.snap-preview {
+    width: 100%;
+    border-radius: 6px;
+    display: block;
+}
+.cam-actions {
+    display: flex;
+    gap: 8px;
+}
+
+/* ── Buttons ───────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    font-family: var(--font);
+    font-size: 14px;
+    font-weight: 500;
+    border-radius: var(--radius);
+    padding: 8px 16px;
+    cursor: pointer;
+    border: none;
+    transition: all 0.15s;
+}
+.btn-primary {
+    background: var(--blue);
+    color: #fff;
+}
+.btn-primary:hover:not(:disabled) { background: #1d4ed8; }
+.btn-primary:disabled { opacity: 0.4; cursor: not-allowed; }
+.btn-secondary {
+    background: var(--surface);
+    color: var(--text);
+    border: 1px solid var(--border);
+}
+.btn-secondary:hover:not(:disabled) { background: var(--bg); }
+.btn-secondary:disabled { opacity: 0.4; cursor: not-allowed; }
+.btn-ghost {
+    background: transparent;
+    color: var(--text-2);
+    border: 1px solid var(--border);
+}
+.btn-ghost:hover { background: var(--bg); }
+.btn-full { width: 100%; }
+
+/* ── Spinner ───────────────────────────────────────────── */
+.spinner {
+    width: 14px;
+    height: 14px;
+    border: 2px solid rgba(255,255,255,0.3);
+    border-top-color: currentColor;
+    border-radius: 50%;
+    animation: spin 0.7s linear infinite;
+    display: inline-block;
+}
+@keyframes spin { to { transform: rotate(360deg); } }
+
+/* ── Empty State ───────────────────────────────────────── */
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 12px;
+    padding: 48px 20px;
+    text-align: center;
+    color: var(--text-3);
+}
+.empty-state p { font-size: 13px; max-width: 260px; }
+
+/* ── Result Banner ─────────────────────────────────────── */
+.result-banner {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 16px;
+    border-radius: var(--radius);
+    margin-bottom: 16px;
+    border: 1px solid;
+}
+.result-banner.EXACT {
+    background: var(--green-light);
+    border-color: #bbf7d0;
+}
+.result-banner.CORRECTED {
+    background: var(--amber-light);
+    border-color: #fde68a;
+}
+.result-banner.FAILED {
+    background: var(--red-light);
+    border-color: #fecaca;
+}
+.banner-title {
+    font-size: 14px;
+    font-weight: 600;
+}
+.EXACT .banner-title { color: var(--green); }
+.CORRECTED .banner-title { color: var(--amber); }
+.FAILED .banner-title { color: var(--red); }
+.banner-sub {
+    font-size: 12px;
+    color: var(--text-2);
+    margin-top: 1px;
+}
+
+/* ── Result Table ──────────────────────────────────────── */
+.result-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 16px;
+}
+.result-table td {
+    padding: 8px 0;
+    border-bottom: 1px solid var(--border);
+    vertical-align: top;
+}
+.result-table tr:last-child td { border-bottom: none; }
+.rt-label {
+    font-size: 12px;
+    font-weight: 500;
+    color: var(--text-2);
+    width: 40%;
+    padding-right: 12px;
+}
+.rt-value { font-size: 14px; }
+.mono { font-family: 'Courier New', monospace; letter-spacing: 0.5px; }
+
+/* ── Preprocessing Tabs ─────────────────────────────────── */
+.section-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-2);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 8px;
+}
+.pre-tabs {
+    display: flex;
+    gap: 4px;
+    overflow-x: auto;
+    margin-bottom: 10px;
+}
+.pre-tab {
+    font-family: var(--font);
+    font-size: 12px;
+    font-weight: 500;
+    color: var(--text-2);
+    background: var(--bg);
+    border: 1px solid var(--border);
+    padding: 4px 10px;
+    border-radius: 20px;
+    cursor: pointer;
+    white-space: nowrap;
+    transition: all 0.15s;
+}
+.pre-tab:hover { color: var(--text); }
+.pre-tab.active {
+    background: var(--blue);
+    color: #fff;
+    border-color: var(--blue);
+}
+.pre-img-wrap {
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    overflow: hidden;
+    background: #f3f4f6;
+    position: relative;
+}
+.pre-img-wrap img {
+    width: 100%;
+    display: block;
+    max-height: 240px;
+    object-fit: contain;
+    background: #000;
+}
+.pre-ocr-label {
+    padding: 8px 12px;
+    font-size: 12px;
+    color: var(--text-2);
+    border-top: 1px solid var(--border);
+    background: var(--surface);
+}
+
+/* ── Batch Evaluation ──────────────────────────────────── */
+.progress-row {
+    display: flex;
+    justify-content: space-between;
+    font-size: 13px;
+    color: var(--text-2);
+    margin-bottom: 6px;
+}
+.progress-track {
+    height: 6px;
+    background: var(--bg);
+    border-radius: 3px;
+    border: 1px solid var(--border);
+    overflow: hidden;
+}
+.progress-fill {
+    height: 100%;
+    background: var(--blue);
+    border-radius: 3px;
+    transition: width 0.3s;
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 12px;
+}
+@media (max-width: 600px) {
+    .stats-grid { grid-template-columns: 1fr 1fr; }
+}
+.stat-card {
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 16px;
+    text-align: center;
+    background: var(--bg);
+}
+.stat-value {
+    font-size: 22px;
+    font-weight: 700;
+    color: var(--text);
+    line-height: 1.2;
+}
+.stat-label {
+    font-size: 12px;
+    color: var(--text-2);
+    margin-top: 4px;
+}
+
+.table-toolbar { margin-bottom: 12px; }
+.search-input { max-width: 300px; }
+
+.table-scroll { overflow-x: auto; }
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 13px;
+}
+.data-table th {
+    text-align: left;
+    padding: 8px 12px;
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-2);
+    background: var(--bg);
+    border-bottom: 1px solid var(--border);
+    white-space: nowrap;
+}
+.data-table td {
+    padding: 10px 12px;
+    border-bottom: 1px solid var(--border);
+    vertical-align: middle;
+}
+.data-table tbody tr:hover { background: var(--bg); }
+.data-table tbody tr:last-child td { border-bottom: none; }
+
+.badge {
+    display: inline-block;
+    font-size: 11px;
+    font-weight: 600;
+    padding: 2px 8px;
+    border-radius: 20px;
+    letter-spacing: 0.2px;
+}
+.badge-exact { background: var(--green-light); color: var(--green); }
+.badge-corrected { background: var(--amber-light); color: var(--amber); }
+.badge-failed { background: var(--red-light); color: var(--red); }
+
+/* ── Modal ─────────────────────────────────────────────── */
+.modal {
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.5);
+    z-index: 500;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+}
+.modal-box {
+    background: var(--surface);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow-md);
+    width: 100%;
+    max-width: 860px;
+    overflow: hidden;
+}
+.modal-head {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 14px 20px;
+    border-bottom: 1px solid var(--border);
+    font-weight: 600;
+    font-size: 14px;
+}
+.modal-close-btn {
+    background: none;
+    border: none;
+    font-size: 20px;
+    color: var(--text-2);
+    cursor: pointer;
+    line-height: 1;
+    padding: 0 4px;
+}
+.modal-body { padding: 20px; max-height: 75vh; overflow-y: auto; }
+
+/* ── Toasts ────────────────────────────────────────────── */
+.toast-stack {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    z-index: 1000;
+}
+.toast {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow-md);
+    padding: 10px 16px;
+    font-size: 13px;
+    font-weight: 500;
+    max-width: 320px;
+    animation: slide-up 0.2s ease;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+.toast.success { border-left: 3px solid var(--green); }
+.toast.error   { border-left: 3px solid var(--red); }
+.toast.info    { border-left: 3px solid var(--blue); }
+@keyframes slide-up {
+    from { opacity: 0; transform: translateY(8px); }
+    to   { opacity: 1; transform: translateY(0); }
+}
+
+/* ── Utilities ─────────────────────────────────────────── */
+.hidden { display: none !important; }
+.hidden-input { display: none; }

web/app.js

@@ -0,0 +1,346 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const API = window.location.origin;
+
+    // ── Toast ────────────────────────────────────────────────
+    function toast(msg, type = 'info') {
+        const el = document.createElement('div');
+        el.className = `toast ${type}`;
+        el.textContent = msg;
+        document.getElementById('toasts').appendChild(el);
+        setTimeout(() => el.remove(), 3500);
+    }
+
+    // ── Backend status ───────────────────────────────────────
+    const dot = document.getElementById('connection-badge');
+    function checkStatus() {
+        fetch(`${API}/api/status`)
+            .then(() => { dot.className = 'status-dot online'; })
+            .catch(() => { dot.className = 'status-dot offline'; });
+    }
+    checkStatus();
+    setInterval(checkStatus, 20000);
+
+    // ── PWA install ──────────────────────────────────────────
+    let installPrompt;
+    const installBtn = document.getElementById('pwa-install-btn');
+    window.addEventListener('beforeinstallprompt', e => {
+        e.preventDefault();
+        installPrompt = e;
+        installBtn.classList.remove('hidden');
+    });
+    installBtn.addEventListener('click', async () => {
+        if (!installPrompt) return;
+        installPrompt.prompt();
+        const { outcome } = await installPrompt.userChoice;
+        if (outcome === 'accepted') toast('App installed!', 'success');
+        installPrompt = null;
+        installBtn.classList.add('hidden');
+    });
+
+    // ── Mode switching ───────────────────────────────────────
+    let currentMode = 'dataset';
+    let chassisBlob = null;
+    let barcodeBlob = null;
+
+    document.querySelectorAll('.seg-btn').forEach(btn => {
+        btn.addEventListener('click', () => {
+            document.querySelectorAll('.seg-btn').forEach(b => b.classList.remove('active'));
+            btn.classList.add('active');
+            currentMode = btn.dataset.mode;
+            ['dataset', 'upload', 'camera'].forEach(m =>
+                document.getElementById(`mode-${m}`).classList.add('hidden')
+            );
+            document.getElementById(`mode-${currentMode}`).classList.remove('hidden');
+            stopAllCameras();
+            validate();
+        });
+    });
+
+    // ── Dataset pairs ────────────────────────────────────────
+    const pairSelect = document.getElementById('dataset-pair-select');
+    const barcodeValInput = document.getElementById('barcode-val');
+
+    fetch(`${API}/api/test-pairs`)
+        .then(r => r.json())
+        .then(pairs => {
+            pairSelect.innerHTML = '<option value="">— Choose a pair —</option>';
+            pairs.forEach(p => {
+                const o = document.createElement('option');
+                o.value = o.textContent = p;
+                pairSelect.appendChild(o);
+            });
+        })
+        .catch(() => toast('Could not load dataset pairs', 'error'));
+
+    pairSelect.addEventListener('change', () => {
+        const key = pairSelect.value;
+        if (!key) { barcodeValInput.value = ''; validate(); return; }
+        barcodeValInput.value = 'Decoding…';
+        barcodeValInput.disabled = true;
+        fetch(`${API}/api/scan-barcode/${encodeURIComponent(key)}`)
+            .then(r => r.json())
+            .then(d => {
+                barcodeValInput.value = d.success ? d.barcode : '';
+                if (!d.success) toast('Barcode not decoded. Enter manually.', 'info');
+            })
+            .catch(() => { barcodeValInput.value = ''; toast('Barcode scan failed', 'error'); })
+            .finally(() => { barcodeValInput.disabled = false; validate(); });
+    });
+
+    // ── Upload dropzones ─────────────────────────────────────
+    function setupDropzone(dzId, inputId, nameId, isBarcode) {
+        const dz = document.getElementById(dzId);
+        const inp = document.getElementById(inputId);
+        const nm  = document.getElementById(nameId);
+
+        dz.addEventListener('click', () => inp.click());
+        dz.addEventListener('dragover', e => { e.preventDefault(); dz.classList.add('active'); });
+        dz.addEventListener('dragleave', () => dz.classList.remove('active'));
+        dz.addEventListener('drop', e => {
+            e.preventDefault();
+            dz.classList.remove('active');
+            if (e.dataTransfer.files[0]) handleFile(e.dataTransfer.files[0], nm, isBarcode);
+        });
+        inp.addEventListener('change', () => {
+            if (inp.files[0]) handleFile(inp.files[0], nm, isBarcode);
+        });
+    }
+
+    function handleFile(file, nameEl, isBarcode) {
+        nameEl.textContent = file.name;
+        if (isBarcode) {
+            barcodeBlob = file;
+            barcodeValInput.value = 'Decoding…';
+            barcodeValInput.disabled = true;
+            const fd = new FormData();
+            fd.append('file', file);
+            fetch(`${API}/api/scan-barcode`, { method: 'POST', body: fd })
+                .then(r => r.json())
+                .then(d => {
+                    barcodeValInput.value = d.success ? d.barcode : '';
+                    if (d.success) toast('Barcode decoded', 'success');
+                    else toast('Could not decode barcode. Enter manually.', 'info');
+                })
+                .catch(() => { barcodeValInput.value = ''; toast('Barcode scan error', 'error'); })
+                .finally(() => { barcodeValInput.disabled = false; validate(); });
+        } else {
+            chassisBlob = file;
+            validate();
+        }
+    }
+
+    setupDropzone('barcode-dropzone', 'barcode-file', 'barcode-file-name', true);
+    setupDropzone('chassis-dropzone', 'chassis-file', 'chassis-file-name', false);
+
+    // ── Camera — barcode ─────────────────────────────────────
+    let qr = null;
+    const startBarcodeCam = document.getElementById('start-barcode-cam');
+    const camStep2 = document.getElementById('cam-step-2');
+
+    startBarcodeCam.addEventListener('click', () => {
+        if (qr) {
+            qr.stop().finally(() => { qr = null; startBarcodeCam.textContent = 'Start Camera'; });
+            return;
+        }
+        startBarcodeCam.textContent = 'Stop';
+        qr = new Html5Qrcode('barcode-reader');
+        qr.start(
+            { facingMode: 'environment' },
+            { fps: 10, qrbox: { width: 240, height: 100 } },
+            decoded => {
+                barcodeValInput.value = decoded;
+                toast(`Barcode: ${decoded}`, 'success');
+                qr.stop().finally(() => {
+                    qr = null;
+                    startBarcodeCam.textContent = 'Start Camera';
+                    camStep2.classList.remove('disabled');
+                    document.getElementById('start-chassis-cam').disabled = false;
+                    validate();
+                });
+            },
+            () => {}
+        ).catch(e => { toast(`Camera error: ${e}`, 'error'); startBarcodeCam.textContent = 'Start Camera'; qr = null; });
+    });
+
+    // ── Camera — chassis ─────────────────────────────────────
+    let chassisStream = null;
+    const chassisVideo   = document.getElementById('chassis-video');
+    const chassisCanvas  = document.getElementById('chassis-canvas');
+    const snapContainer  = document.getElementById('chassis-snap-container');
+    const snapImg        = document.getElementById('chassis-snap-img');
+    const startChassisCam = document.getElementById('start-chassis-cam');
+    const captureBtn     = document.getElementById('capture-chassis');
+    const retakeBtn      = document.getElementById('reset-chassis-snap');
+
+    startChassisCam.addEventListener('click', async () => {
+        if (chassisStream) { stopChassisCamera(); return; }
+        try {
+            chassisStream = await navigator.mediaDevices.getUserMedia({
+                video: { facingMode: 'environment', width: { ideal: 1280 } }, audio: false
+            });
+            chassisVideo.srcObject = chassisStream;
+            chassisVideo.classList.remove('hidden');
+            captureBtn.classList.remove('hidden');
+            snapContainer.classList.add('hidden');
+            retakeBtn.classList.add('hidden');
+            startChassisCam.textContent = 'Stop';
+        } catch(e) { toast(`Camera error: ${e.message}`, 'error'); }
+    });
+
+    captureBtn.addEventListener('click', () => {
+        chassisCanvas.width = chassisVideo.videoWidth;
+        chassisCanvas.height = chassisVideo.videoHeight;
+        chassisCanvas.getContext('2d').drawImage(chassisVideo, 0, 0);
+        chassisCanvas.toBlob(blob => {
+            chassisBlob = blob;
+            snapImg.src = URL.createObjectURL(blob);
+            chassisVideo.classList.add('hidden');
+            captureBtn.classList.add('hidden');
+            snapContainer.classList.remove('hidden');
+            retakeBtn.classList.remove('hidden');
+            stopChassisCamera();
+            validate();
+        }, 'image/jpeg');
+    });
+
+    retakeBtn.addEventListener('click', () => {
+        chassisBlob = null;
+        snapContainer.classList.add('hidden');
+        retakeBtn.classList.add('hidden');
+        startChassisCam.click();
+        validate();
+    });
+
+    function stopChassisCamera() {
+        if (chassisStream) { chassisStream.getTracks().forEach(t => t.stop()); chassisStream = null; }
+        chassisVideo.srcObject = null;
+        chassisVideo.classList.add('hidden');
+        captureBtn.classList.add('hidden');
+        startChassisCam.textContent = 'Start Camera';
+    }
+
+    function stopAllCameras() {
+        if (qr) { qr.stop().catch(() => {}); qr = null; startBarcodeCam.textContent = 'Start Camera'; }
+        stopChassisCamera();
+    }
+
+    // ── Validation ───────────────────────────────────────────
+    const runBtn = document.getElementById('run-ocr-btn');
+    barcodeValInput.addEventListener('input', validate);
+
+    function validate() {
+        const hasBarcode = barcodeValInput.value.trim() !== '' && barcodeValInput.value !== 'Decoding…';
+        let hasChassis = false;
+        if (currentMode === 'dataset') hasChassis = pairSelect.value !== '';
+        else hasChassis = chassisBlob !== null;
+        runBtn.disabled = !(hasBarcode && hasChassis);
+    }
+
+    // ── Run OCR ──────────────────────────────────────────────
+    let lastResult = null;
+
+    runBtn.addEventListener('click', () => {
+        runBtn.disabled = true;
+        runBtn.querySelector('.spinner').classList.remove('hidden');
+
+        const fd = new FormData();
+        fd.append('barcode_val', barcodeValInput.value.trim().toUpperCase());
+
+        if (currentMode === 'dataset') {
+            fd.append('chassis_key', pairSelect.value);
+        } else {
+            fd.append('chassis_file', chassisBlob, currentMode === 'camera' ? 'chassis.jpg' : chassisBlob.name);
+        }
+
+        fetch(`${API}/api/match`, { method: 'POST', body: fd })
+            .then(r => {
+                if (!r.ok) return r.json().then(e => { throw new Error(e.detail); });
+                return r.json();
+            })
+            .then(data => { lastResult = data; renderResult(data); toast('Scan complete', 'success'); })
+            .catch(e => toast(e.message || 'OCR failed', 'error'))
+            .finally(() => {
+                runBtn.disabled = false;
+                runBtn.querySelector('.spinner').classList.add('hidden');
+            });
+    });
+
+    function renderResult(d) {
+        document.getElementById('result-empty').classList.add('hidden');
+        document.getElementById('result-content').classList.remove('hidden');
+
+        // Banner
+        const banner = document.getElementById('result-banner');
+        banner.className = `result-banner ${d.status}`;
+        const icons = {
+            EXACT:     '✓',
+            CORRECTED: '~',
+            FAILED:    '✗'
+        };
+        const subs = {
+            EXACT:     'Raw OCR matched the barcode exactly.',
+            CORRECTED: 'Match achieved after error-correction.',
+            FAILED:    'OCR output could not be matched.'
+        };
+        document.getElementById('banner-icon').textContent = icons[d.status];
+        document.getElementById('banner-title').textContent = d.status === 'EXACT' ? 'Exact Match' : d.status === 'CORRECTED' ? 'Corrected Match' : 'No Match';
+        document.getElementById('banner-sub').textContent = subs[d.status];
+
+        // Table
+        document.getElementById('res-expected').textContent = d.barcode_val;
+        document.getElementById('res-raw').textContent      = d.raw_ocr || '—';
+        document.getElementById('res-corrected').textContent = d.corrected_ocr || '—';
+        document.getElementById('res-conf').textContent     = `${Math.round(d.confidence * 100)}%`;
+        document.getElementById('res-filter').textContent   = d.winning_label || '—';
+
+        // Preprocessing carousel
+        const tabs = document.querySelectorAll('.pre-tab');
+        tabs.forEach(t => t.replaceWith(t.cloneNode(true)));
+        const newTabs = document.querySelectorAll('.pre-tab');
+
+        function setPreview(type) {
+            const img = document.getElementById('pre-img');
+            const lbl = document.getElementById('pre-ocr-text');
+            if (type === 'original') {
+                img.src = `data:image/jpeg;base64,${d.original}`;
+                lbl.textContent = d.raw_ocr || '—';
+            } else {
+                const v = d.variations.find(x => x.label.toLowerCase() === type);
+                const det = d.variation_details.find(x => x.label.toLowerCase() === type);
+                if (v) img.src = `data:image/jpeg;base64,${v.base64}`;
+                lbl.textContent = det ? (det.text || '—') : '—';
+            }
+        }
+
+        newTabs.forEach(tab => {
+            tab.addEventListener('click', () => {
+                newTabs.forEach(t => t.classList.remove('active'));
+                tab.classList.add('active');
+                setPreview(tab.dataset.pre);
+            });
+        });
+
+        // Set initial to original
+        document.querySelector('.pre-tab[data-pre="original"]').classList.add('active');
+        setPreview('original');
+    }
+
+    // ── Modal ──────────────────────────────���─────────────────
+    const modal     = document.getElementById('modal');
+    const modalImg  = document.getElementById('modal-img');
+    const modalTitle = document.getElementById('modal-title');
+
+    function openModal(url, title) {
+        modalTitle.textContent = title;
+        modalImg.src = `${url}?t=${Date.now()}`;
+        modal.classList.remove('hidden');
+    }
+
+    document.getElementById('modal-close').addEventListener('click', () => modal.classList.add('hidden'));
+    modal.addEventListener('click', e => { if (e.target === modal) modal.classList.add('hidden'); });
+
+    // ── Service Worker ───────────────────────────────────────
+    if ('serviceWorker' in navigator) {
+        navigator.serviceWorker.register('/sw.js').catch(() => {});
+    }
+});

web/index.html

@@ -0,0 +1,182 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Chassis OCR</title>
+    <link rel="manifest" href="manifest.json">
+    <link rel="icon" type="image/png" sizes="192x192" href="icons/icon-192.png">
+    <meta name="theme-color" content="#2563eb">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="app.css">
+    <script src="https://unpkg.com/html5-qrcode" type="text/javascript"></script>
+</head>
+<body>
+    <header class="header">
+        <div class="header-inner">
+            <div class="header-brand">
+                <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                    <rect x="2" y="5" width="20" height="14" rx="2"/>
+                    <line x1="2" y1="10" x2="22" y2="10"/>
+                </svg>
+                <span>Chassis OCR</span>
+            </div>
+            <div class="header-right">
+                <span id="connection-badge" class="status-dot online"></span>
+                <button id="pwa-install-btn" class="btn-install hidden">Add to Home Screen</button>
+            </div>
+        </div>
+    </header>
+
+    <main class="main">
+        <div class="two-col">
+
+            <!-- Left: Input -->
+            <div class="panel">
+                <div class="panel-header">
+                    <h2>Input</h2>
+                </div>
+                <div class="panel-body">
+                    <div class="field">
+                        <label>Source</label>
+                        <div class="seg-control">
+                            <button class="seg-btn active" data-mode="dataset">Dataset</button>
+                            <button class="seg-btn" data-mode="upload">Upload</button>
+                            <button class="seg-btn" data-mode="camera">Camera</button>
+                        </div>
+                    </div>
+
+                    <!-- Dataset mode -->
+                    <div id="mode-dataset" class="mode-panel">
+                        <div class="field">
+                            <label for="dataset-pair-select">Test Pair</label>
+                            <select id="dataset-pair-select" class="select">
+                                <option value="">Loading...</option>
+                            </select>
+                        </div>
+                    </div>
+
+                    <!-- Upload mode -->
+                    <div id="mode-upload" class="mode-panel hidden">
+                        <div class="field">
+                            <label>Barcode Image</label>
+                            <div class="dropzone" id="barcode-dropzone">
+                                <input type="file" id="barcode-file" accept="image/*" class="hidden-input">
+                                <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M17 8l-5-5-5 5M12 3v12"/></svg>
+                                <span id="barcode-file-name">Drop or click to upload</span>
+                            </div>
+                        </div>
+                        <div class="field">
+                            <label>Chassis Image</label>
+                            <div class="dropzone" id="chassis-dropzone">
+                                <input type="file" id="chassis-file" accept="image/*" class="hidden-input">
+                                <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M17 8l-5-5-5 5M12 3v12"/></svg>
+                                <span id="chassis-file-name">Drop or click to upload</span>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Camera mode -->
+                    <div id="mode-camera" class="mode-panel hidden">
+                        <div class="camera-step" id="cam-step-1">
+                            <div class="step-label">Step 1 — Scan Barcode</div>
+                            <div id="barcode-reader" class="cam-view"></div>
+                            <button id="start-barcode-cam" class="btn btn-secondary">Start Camera</button>
+                        </div>
+                        <div class="camera-step disabled" id="cam-step-2">
+                            <div class="step-label">Step 2 — Capture Chassis</div>
+                            <video id="chassis-video" autoplay playsinline class="cam-view hidden"></video>
+                            <canvas id="chassis-canvas" class="hidden"></canvas>
+                            <div id="chassis-snap-container" class="hidden">
+                                <img id="chassis-snap-img" class="snap-preview" src="" alt="Chassis snapshot">
+                            </div>
+                            <div class="cam-actions">
+                                <button id="start-chassis-cam" class="btn btn-secondary" disabled>Start Camera</button>
+                                <button id="capture-chassis" class="btn btn-primary hidden">Capture</button>
+                                <button id="reset-chassis-snap" class="btn btn-ghost hidden">Retake</button>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Barcode value -->
+                    <div class="field">
+                        <label for="barcode-val">Expected Value (Barcode)</label>
+                        <input type="text" id="barcode-val" class="input" placeholder="Auto-filled or enter manually">
+                    </div>
+
+                    <button id="run-ocr-btn" class="btn btn-primary btn-full" disabled>
+                        <span class="spinner hidden"></span>
+                        Run OCR & Compare
+                    </button>
+                </div>
+            </div>
+
+            <!-- Right: Results -->
+            <div class="panel">
+                <div class="panel-header">
+                    <h2>Result</h2>
+                </div>
+                <div class="panel-body" id="result-body">
+                    <div id="result-empty" class="empty-state">
+                        <svg width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="12" r="10"/><line x1="12" y1="8" x2="12" y2="12"/><line x1="12" y1="16" x2="12.01" y2="16"/></svg>
+                        <p>Select a pair and run OCR to see results.</p>
+                    </div>
+
+                    <div id="result-content" class="hidden">
+                        <div id="result-banner" class="result-banner">
+                            <div id="banner-icon" class="banner-icon-char"></div>
+                            <div>
+                                <div id="banner-title" class="banner-title"></div>
+                                <div id="banner-sub" class="banner-sub"></div>
+                            </div>
+                        </div>
+
+                        <table class="result-table">
+                            <tr>
+                                <td class="rt-label">Expected</td>
+                                <td class="rt-value mono" id="res-expected">—</td>
+                            </tr>
+                            <tr>
+                                <td class="rt-label">Raw OCR</td>
+                                <td class="rt-value mono" id="res-raw">—</td>
+                            </tr>
+                            <tr>
+                                <td class="rt-label">After Correction</td>
+                                <td class="rt-value mono" id="res-corrected">—</td>
+                            </tr>
+                            <tr>
+                                <td class="rt-label">Confidence</td>
+                                <td class="rt-value" id="res-conf">—</td>
+                            </tr>
+                            <tr>
+                                <td class="rt-label">Best Filter</td>
+                                <td class="rt-value" id="res-filter">—</td>
+                            </tr>
+                        </table>
+
+                        <div class="section-title">Preprocessing Steps</div>
+                        <div class="pre-tabs" id="pre-tabs">
+                            <button class="pre-tab active" data-pre="original">Original</button>
+                            <button class="pre-tab" data-pre="clahe">CLAHE</button>
+                            <button class="pre-tab" data-pre="bilateral">Bilateral</button>
+                            <button class="pre-tab" data-pre="otsu">Otsu</button>
+                            <button class="pre-tab" data-pre="adaptive">Adaptive</button>
+                        </div>
+                        <div class="pre-img-wrap">
+                            <img id="pre-img" src="" alt="Preprocessing step">
+                            <div class="pre-ocr-label">OCR read: <span id="pre-ocr-text" class="mono">—</span></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+        </div>
+    </main>
+
+    <div id="toasts" class="toast-stack"></div>
+
+    <script src="app.js"></script>
+</body>
+</html>

web/manifest.json

@@ -0,0 +1,24 @@
+{
+  "name": "Chassis OCR Pipeline Hub",
+  "short_name": "Chassis OCR",
+  "description": "Progressive Web App to read and match chassis engravings with barcode-scanned numbers using PaddleOCR.",
+  "start_url": "/index.html",
+  "display": "standalone",
+  "background_color": "#0b0e14",
+  "theme_color": "#0d6efd",
+  "orientation": "portrait-primary",
+  "icons": [
+    {
+      "src": "icons/icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any maskable"
+    },
+    {
+      "src": "icons/icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ]
+}

web/sw.js

@@ -0,0 +1,83 @@
+/* ==========================================================================
+   CHASSIS OCR PWA - SERVICE WORKER
+   ========================================================================== */
+
+const CACHE_NAME = 'chassis-ocr-pwa-v1';
+const ASSETS_TO_CACHE = [
+    '/',
+    '/index.html',
+    '/app.css',
+    '/app.js',
+    '/manifest.json',
+    '/icons/icon-192.png',
+    '/icons/icon-512.png'
+];
+
+// Install Service Worker and Cache Assets
+self.addEventListener('install', (event) => {
+    event.waitUntil(
+        caches.open(CACHE_NAME)
+            .then((cache) => {
+                console.log('[Service Worker] Caching App Shell...');
+                return cache.addAll(ASSETS_TO_CACHE);
+            })
+            .then(() => self.skipWaiting())
+    );
+});
+
+// Activate event (clean up old caches)
+self.addEventListener('activate', (event) => {
+    event.waitUntil(
+        caches.keys().then((keyList) => {
+            return Promise.all(keyList.map((key) => {
+                if (key !== CACHE_NAME) {
+                    console.log('[Service Worker] Removing old cache:', key);
+                    return caches.delete(key);
+                }
+            }));
+        }).then(() => self.clients.claim())
+    );
+});
+
+// Fetch events (Network-first with Cache Fallback for API / Cache-first for Assets)
+self.addEventListener('fetch', (event) => {
+    const requestUrl = new URL(event.request.url);
+
+    // Bypass caching for backend API requests and other HTTP methods (POST, PUT, DELETE)
+    if (event.request.method !== 'GET' || requestUrl.pathname.startsWith('/api/')) {
+        return;
+    }
+
+    event.respondWith(
+        caches.match(event.request)
+            .then((cachedResponse) => {
+                if (cachedResponse) {
+                    // Serve cached asset immediately, but fetch fresh version in the background
+                    fetch(event.request).then((networkResponse) => {
+                        if (networkResponse && networkResponse.status === 200) {
+                            caches.open(CACHE_NAME).then((cache) => {
+                                cache.put(event.request, networkResponse);
+                            });
+                        }
+                    }).catch(() => {/* Ignore network failures in background */});
+                    
+                    return cachedResponse;
+                }
+
+                // If not cached, fetch from network
+                return fetch(event.request).then((networkResponse) => {
+                    if (!networkResponse || networkResponse.status !== 200 || networkResponse.type !== 'basic') {
+                        return networkResponse;
+                    }
+                    
+                    // Cache the newly fetched asset
+                    const responseToCache = networkResponse.clone();
+                    caches.open(CACHE_NAME).then((cache) => {
+                        cache.put(event.request, responseToCache);
+                    });
+                    
+                    return networkResponse;
+                });
+            })
+    );
+});