Mirror current local backend deployment

ai_providers.py

@@ -1,262 +0,0 @@
-"""
-AI Vision Provider Router
-==========================
-Reads API keys from .env and routes /api/analyze requests to whichever
-provider the caller requests (or the first available one by default).
-
-Supported providers
--------------------
-  anthropic  — Claude claude-sonnet-4-6         (pip install anthropic)
-  openai     — GPT-4o                    (pip install openai)
-  gemini     — Gemini 2.0 Flash           (pip install google-genai)
-  groq       — Llama 4 Scout (vision)    (pip install groq)
-
-Adding a new provider
----------------------
-1. Add its API key variable to .env / .env.example
-2. Add an entry to PROVIDERS below
-3. Implement a _call_<name>() function
-"""
-
-from __future__ import annotations
-import base64
-import json
-import logging
-import os
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-# ── Prompt sent to every provider ────────────────────────────────────────────
-_ANALYSIS_PROMPT = (
-    "You are an expert in architectural drawings and CAD digitisation.\n"
-    "Analyse this architectural drawing and respond ONLY with valid JSON "
-    "(no markdown fences) using exactly these fields:\n\n"
-    "{\n"
-    '  "drawing_type": "floor plan | elevation | section | detail | site plan | unknown",\n'
-    '  "scale": "e.g. 1:100, or null if not visible",\n'
-    '  "elements": ["list of detected architectural elements"],\n'
-    '  "rooms": ["list of room names if readable"],\n'
-    '  "quality_score": 1-10,\n'
-    '  "quality_notes": "brief assessment of drawing condition",\n'
-    '  "ocr_difficulty": "easy | moderate | hard | very hard",\n'
-    '  "digitisation_recommendations": ["actionable recommendations"]\n'
-    "}"
-)
-
-# ── Provider registry ─────────────────────────────────────────────────────────
-# Each entry: { env_key, display_name, model_id, sdk_package }
-PROVIDERS: dict[str, dict] = {
-    "anthropic": {
-        "env_key":     "ANTHROPIC_API_KEY",
-        "display_name": "Anthropic Claude",
-        "model_id":    "claude-sonnet-4-6",
-        "sdk_package": "anthropic",
-    },
-    "openai": {
-        "env_key":     "OPENAI_API_KEY",
-        "display_name": "OpenAI GPT-4o",
-        "model_id":    "gpt-4o",
-        "sdk_package": "openai",
-    },
-    "gemini": {
-        "env_key":     "GOOGLE_API_KEY",
-        "display_name": "Google Gemini 2.0 Flash",
-        "model_id":    "gemini-2.0-flash",
-        "sdk_package": "google.genai",
-    },
-    "groq": {
-        "env_key":     "GROQ_API_KEY",
-        "display_name": "Groq Llama 4 Scout",
-        "model_id":    "meta-llama/llama-4-scout-17b-16e-instruct",
-        "sdk_package": "groq",
-    },
-}
-
-# Priority order when no provider is specified
-_DEFAULT_PRIORITY = ["anthropic", "openai", "groq", "gemini"]
-
-
-# ── Public helpers ────────────────────────────────────────────────────────────
-
-def list_providers() -> list[dict]:
-    """Return status of every provider — used by /api/info."""
-    result = []
-    for name, cfg in PROVIDERS.items():
-        key = os.getenv(cfg["env_key"], "").strip()
-        result.append({
-            "name":         name,
-            "display_name": cfg["display_name"],
-            "model":        cfg["model_id"],
-            "configured":   bool(key),
-        })
-    return result
-
-
-def get_default_provider() -> Optional[str]:
-    """Return the name of the first provider that has a key set."""
-    for name in _DEFAULT_PRIORITY:
-        key = os.getenv(PROVIDERS[name]["env_key"], "").strip()
-        if key:
-            return name
-    return None
-
-
-def analyze(
-    image_bytes: bytes,
-    filename: str,
-    provider_name: Optional[str] = None,
-) -> dict:
-    """
-    Run vision analysis on the image using the specified provider.
-    Falls back to the first configured provider if none is specified.
-
-    Returns the parsed JSON analysis dict.
-    Raises ValueError if no provider is available.
-    Raises RuntimeError on API call failure.
-    """
-    name = provider_name or get_default_provider()
-    if name is None:
-        raise ValueError(
-            "No AI provider configured. Add at least one API key to backend/.env"
-        )
-    if name not in PROVIDERS:
-        available = ", ".join(PROVIDERS.keys())
-        raise ValueError(f"Unknown provider '{name}'. Choose from: {available}")
-
-    cfg = PROVIDERS[name]
-    api_key = os.getenv(cfg["env_key"], "").strip()
-    if not api_key:
-        raise ValueError(
-            f"Provider '{name}' has no API key set. "
-            f"Add {cfg['env_key']} to backend/.env"
-        )
-
-    media_type = _media_type(filename)
-    logger.info("AI analysis via %s (%s)", cfg["display_name"], cfg["model_id"])
-
-    if name == "anthropic":
-        raw = _call_anthropic(api_key, cfg["model_id"], image_bytes, media_type)
-    elif name == "openai":
-        raw = _call_openai(api_key, cfg["model_id"], image_bytes, media_type)
-    elif name == "gemini":
-        raw = _call_gemini(api_key, cfg["model_id"], image_bytes, media_type)
-    elif name == "groq":
-        raw = _call_groq(api_key, cfg["model_id"], image_bytes, media_type)
-    else:
-        raise ValueError(f"No call handler for provider '{name}'")
-
-    return _parse_response(raw, name)
-
-
-# ── Provider call implementations ─────────────────────────────────────────────
-
-def _call_anthropic(api_key: str, model: str, image_bytes: bytes, media_type: str) -> str:
-    import anthropic
-    client = anthropic.Anthropic(api_key=api_key)
-    b64 = base64.b64encode(image_bytes).decode()
-    msg = client.messages.create(
-        model=model,
-        max_tokens=1024,
-        messages=[{
-            "role": "user",
-            "content": [
-                {"type": "image", "source": {"type": "base64", "media_type": media_type, "data": b64}},
-                {"type": "text",  "text": _ANALYSIS_PROMPT},
-            ],
-        }],
-    )
-    return msg.content[0].text
-
-
-def _call_openai(api_key: str, model: str, image_bytes: bytes, media_type: str) -> str:
-    from openai import OpenAI
-    client = OpenAI(api_key=api_key)
-    b64 = base64.b64encode(image_bytes).decode()
-    data_url = f"data:{media_type};base64,{b64}"
-    resp = client.chat.completions.create(
-        model=model,
-        max_tokens=1024,
-        messages=[{
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_url}},
-                {"type": "text",      "text": _ANALYSIS_PROMPT},
-            ],
-        }],
-    )
-    return resp.choices[0].message.content
-
-
-def _call_gemini(api_key: str, model: str, image_bytes: bytes, media_type: str) -> str:
-    from google import genai
-    from google.genai import types
-
-    client = genai.Client(api_key=api_key)
-    img_part = types.Part.from_bytes(data=image_bytes, mime_type=media_type)
-    resp = client.models.generate_content(
-        model=model,
-        contents=[img_part, _ANALYSIS_PROMPT],
-        config=types.GenerateContentConfig(
-            safety_settings=[
-                types.SafetySetting(category="HARM_CATEGORY_HARASSMENT",        threshold="BLOCK_NONE"),
-                types.SafetySetting(category="HARM_CATEGORY_HATE_SPEECH",       threshold="BLOCK_NONE"),
-                types.SafetySetting(category="HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold="BLOCK_NONE"),
-                types.SafetySetting(category="HARM_CATEGORY_DANGEROUS_CONTENT", threshold="BLOCK_NONE"),
-            ]
-        ),
-    )
-    return resp.text
-
-
-def _call_groq(api_key: str, model: str, image_bytes: bytes, media_type: str) -> str:
-    import base64, warnings
-    import httpx
-    from groq import Groq
-
-    # Corporate proxy uses a self-signed cert — bypass SSL verification
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        http_client = httpx.Client(verify=False)  # noqa: S501
-        client = Groq(api_key=api_key, http_client=http_client)
-
-    b64 = base64.b64encode(image_bytes).decode()
-    data_url = f"data:{media_type};base64,{b64}"
-    resp = client.chat.completions.create(
-        model=model,
-        max_tokens=1024,
-        messages=[{
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_url}},
-                {"type": "text",      "text": _ANALYSIS_PROMPT},
-            ],
-        }],
-    )
-    return resp.choices[0].message.content
-
-
-# ── Helpers ───────────────────────────────────────────────────────────────────
-
-def _media_type(filename: str) -> str:
-    fname = (filename or "").lower()
-    if fname.endswith(".png"):
-        return "image/png"
-    if fname.endswith(".webp"):
-        return "image/webp"
-    return "image/jpeg"
-
-
-def _parse_response(raw: str, provider: str) -> dict:
-    text = raw.strip()
-    if text.startswith("```"):
-        parts = text.split("```")
-        text = parts[1]
-        if text.startswith("json"):
-            text = text[4:]
-        text = text.strip()
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError:
-        logger.warning("Provider %s returned non-JSON: %s", provider, text[:200])
-        return {"raw_response": text}

benchmark/ground_truth.example.json

@@ -1,32 +0,0 @@
-{
-  "_comment": "Copy this file to ground_truth.json and fill in values for your test images.",
-  "_format": {
-    "image_filename": {
-      "drawing_type":        "floor plan | elevation | section | detail | site plan",
-      "expected_text":       ["list", "of", "key", "labels", "that", "must", "be", "detected"],
-      "expected_dimensions": ["3640mm", "2730mm"],
-      "expected_room_names": ["Living Room", "Bedroom"],
-      "expected_line_count_min": 10,
-      "expected_line_count_max": 100,
-      "notes":               "Any context about this drawing"
-    }
-  },
-  "sample_floor_plan.jpg": {
-    "drawing_type":           "floor plan",
-    "expected_text":          ["Living Room", "Bedroom", "Kitchen", "3640", "1:100"],
-    "expected_dimensions":    [],
-    "expected_room_names":    ["Living Room", "Bedroom", "Kitchen"],
-    "expected_line_count_min": 20,
-    "expected_line_count_max": 150,
-    "notes":                  "Standard A3 floor plan, moderate yellowing"
-  },
-  "sample_elevation.jpg": {
-    "drawing_type":           "elevation",
-    "expected_text":          ["GL", "FL", "2F", "1F"],
-    "expected_dimensions":    [],
-    "expected_room_names":    [],
-    "expected_line_count_min": 15,
-    "expected_line_count_max": 80,
-    "notes":                  "South elevation, faded ink"
-  }
-}

benchmark/ground_truth.json

@@ -1,25 +0,0 @@
-{
-  "_comment": "Ground truth for benchmark/sample_images/*. See ground_truth.example.json for field meanings.",
-
-  "floor_plan_level1.jpg": {
-    "drawing_type":           "floor plan",
-    "expected_text":          ["Bedroom 1", "Bedroom 2", "Kitchen", "Bathroom", "Living Room",
-                                "3,640 x 3,640", "2,730 x 4,000", "1,820 x 3,000", "8,190 x 4,000",
-                                "SCALE", "1:100", "FLOOR PLAN", "LEVEL 1"],
-    "expected_dimensions":    ["3,640 x 3,640", "2,730 x 4,000", "1,820 x 3,000", "8,190 x 4,000"],
-    "expected_room_names":    ["Bedroom 1", "Bedroom 2", "Kitchen", "Bathroom", "Living Room"],
-    "expected_line_count_min": 15,
-    "expected_line_count_max": 40,
-    "notes":                  "4-room floor plan with door swings, dimension callouts, and a title block (SCALE / FLOOR PLAN — LEVEL 1). Line count reflects actual wall/curve segments (walls + 2 door-swing arcs, each arc approximated as several short polyline segments), not raw Hough fragments — see line_extractor.py's merge/curve-detection rewrite."
-  },
-
-  "synthetic_floor_plan.png": {
-    "drawing_type":           "floor plan",
-    "expected_text":          ["Bedroom", "Living Room", "3640mm", "1:100"],
-    "expected_dimensions":    ["3640mm"],
-    "expected_room_names":    ["Bedroom", "Living Room"],
-    "expected_line_count_min": 4,
-    "expected_line_count_max": 10,
-    "notes":                  "Simple 2-room synthetic floor plan with one dimension callout and a scale label."
-  }
-}

benchmark/metrics.py

@@ -1,122 +0,0 @@
-"""
-Accuracy metrics for the architectural drawing benchmark.
-
-All functions return float values in [0, 1] unless noted otherwise.
-"""
-
-from __future__ import annotations
-import re
-from typing import List
-
-
-# ---------------------------------------------------------------------------
-# OCR metrics
-# ---------------------------------------------------------------------------
-
-def _normalize(s: str) -> str:
-    """
-    Normalize OCR text for comparison so a correctly-read character isn't
-    scored as an error just because it differs in glyph from how the
-    ground truth happens to be transcribed — e.g. PaddleOCR reads the
-    drawing's actual '×' (U+00D7) multiplication sign for dimension
-    callouts like "2,730 × 4,000", while ground truth was transcribed with
-    a plain ASCII 'x'. Both represent the same text; only the codepoint
-    differs.
-    """
-    return s.strip().lower().replace("×", "x")
-
-
-def character_error_rate(predicted: str, ground_truth: str) -> float:
-    """
-    Character Error Rate (CER) — standard metric for OCR quality.
-
-    CER = edit_distance(predicted, ground_truth) / len(ground_truth)
-
-    Lower is better. 0.0 = perfect, 1.0 = completely wrong.
-    Returns 0.0 if ground_truth is empty.
-    """
-    if not ground_truth:
-        return 0.0
-    predicted, ground_truth = _normalize(predicted), _normalize(ground_truth)
-    dist = _levenshtein(predicted, ground_truth)
-    return min(dist / len(ground_truth), 1.0)
-
-
-def word_error_rate(predicted: str, ground_truth: str) -> float:
-    """
-    Word Error Rate (WER) — edit distance at word level.
-
-    WER = edit_distance(pred_words, gt_words) / len(gt_words)
-
-    Lower is better.
-    """
-    pred_words = _normalize(predicted).split()
-    gt_words   = _normalize(ground_truth).split()
-    if not gt_words:
-        return 0.0
-    dist = _levenshtein(pred_words, gt_words)
-    return min(dist / len(gt_words), 1.0)
-
-
-def token_recall(predicted_tokens: List[str], expected_tokens: List[str]) -> float:
-    """
-    Fraction of expected tokens found anywhere in the predicted token list.
-
-    Useful for checking that key labels (room names, dimensions) were detected
-    without penalising extra detections.
-    """
-    if not expected_tokens:
-        return 1.0
-    pred_set = {_normalize(t) for t in predicted_tokens}
-    hits = sum(1 for t in expected_tokens if _normalize(t) in pred_set)
-    return hits / len(expected_tokens)
-
-
-def token_precision(predicted_tokens: List[str], expected_tokens: List[str]) -> float:
-    """
-    Fraction of predicted tokens that appear in the expected list.
-    """
-    if not predicted_tokens:
-        return 1.0 if not expected_tokens else 0.0
-    exp_set = {_normalize(t) for t in expected_tokens}
-    hits = sum(1 for t in predicted_tokens if _normalize(t) in exp_set)
-    return hits / len(predicted_tokens)
-
-
-def f1(precision: float, recall: float) -> float:
-    if precision + recall == 0:
-        return 0.0
-    return 2 * precision * recall / (precision + recall)
-
-
-# ---------------------------------------------------------------------------
-# Line detection metrics
-# ---------------------------------------------------------------------------
-
-def line_count_accuracy(detected: int, expected_min: int, expected_max: int) -> float:
-    """
-    Returns 1.0 if detected count is within the expected range,
-    otherwise a linear penalty based on how far outside the range it falls.
-    """
-    if expected_min <= detected <= expected_max:
-        return 1.0
-    midpoint = (expected_min + expected_max) / 2
-    deviation = abs(detected - midpoint) / max(midpoint, 1)
-    return max(0.0, 1.0 - deviation)
-
-
-# ---------------------------------------------------------------------------
-# Internal helpers
-# ---------------------------------------------------------------------------
-
-def _levenshtein(a, b) -> int:
-    """Generic Levenshtein distance — works on strings or lists."""
-    m, n = len(a), len(b)
-    dp = list(range(n + 1))
-    for i in range(1, m + 1):
-        prev = dp[:]
-        dp[0] = i
-        for j in range(1, n + 1):
-            cost = 0 if a[i - 1] == b[j - 1] else 1
-            dp[j] = min(dp[j] + 1, dp[j - 1] + 1, prev[j - 1] + cost)
-    return dp[n]

benchmark/results/after_fix.json

@@ -1,160 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T11:17:46.470453",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "benchmark/results/after_fix.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.647
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.011,
-          "lines_detected": 243,
-          "horizontal": 223,
-          "vertical": 20,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 1.013,
-          "element_count": 17,
-          "full_text": "tum ttや5R5R5t5や5や5つOOつつつつつつべつべつべべ\nBedroom 1                                Kitchen             Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\nBedroom 2                                Living Room\n3,640 x 5,640                                     8,190 x 4,000\n— oo oo Hr rT HH\nSCALE  1:10 g00mm       FLOOR PLAN — LEVEL 1       6,400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 5,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "oo",
-              "rT",
-              "SCALE",
-              "g00mm",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.006,
-          "svg_size_bytes": 21209
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.677,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.8462,
-        "ocr_token_recall": 0.9231,
-        "ocr_token_precision": 0.7059,
-        "ocr_token_f1": 0.8,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.567
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.005,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.381,
-          "element_count": 3,
-          "full_text": "ーー      ーー\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2698
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.954,
-      "accuracy": {
-        "ocr_cer": 0.7812,
-        "ocr_wer": 0.8,
-        "ocr_token_recall": 0.75,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 0.8571,
-        "room_name_recall": 0.5,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.8906,
-    "min_ocr_cer": 0.7812,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.8231,
-    "min_ocr_wer": 0.8,
-    "max_ocr_wer": 0.8462,
-    "avg_ocr_token_recall": 0.8366,
-    "min_ocr_token_recall": 0.75,
-    "max_ocr_token_recall": 0.9231,
-    "avg_ocr_token_precision": 0.8529,
-    "min_ocr_token_precision": 0.7059,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.8286,
-    "min_ocr_token_f1": 0.8,
-    "max_ocr_token_f1": 0.8571,
-    "avg_room_name_recall": 0.75,
-    "min_room_name_recall": 0.5,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260629_114932.json

@@ -1,61 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-06-29T11:49:32.822180",
-    "image_count": 1,
-    "ground_truth": null,
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260629_114932.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.149
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.004,
-          "lines_detected": 20,
-          "horizontal": 14,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.247,
-          "element_count": 5,
-          "full_text": "_ _\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Living",
-              "Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "_",
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2307
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.401
-    }
-  ],
-  "aggregate": {}
-}

benchmark/results/benchmark_20260629_115100.json

@@ -1,92 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-06-29T11:51:01.173922",
-    "image_count": 1,
-    "ground_truth": "benchmark/ground_truth_test.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260629_115100.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.115
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.004,
-          "lines_detected": 20,
-          "horizontal": 14,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.255,
-          "element_count": 5,
-          "full_text": "_ _\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Living",
-              "Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "_",
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2307
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.375,
-      "accuracy": {
-        "ocr_cer": 0.75,
-        "ocr_wer": 1.0,
-        "ocr_token_recall": 0.5,
-        "ocr_token_precision": 0.4,
-        "ocr_token_f1": 0.4444,
-        "room_name_recall": 0.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.75,
-    "min_ocr_cer": 0.75,
-    "max_ocr_cer": 0.75,
-    "avg_ocr_wer": 1.0,
-    "min_ocr_wer": 1.0,
-    "max_ocr_wer": 1.0,
-    "avg_ocr_token_recall": 0.5,
-    "min_ocr_token_recall": 0.5,
-    "max_ocr_token_recall": 0.5,
-    "avg_ocr_token_precision": 0.4,
-    "min_ocr_token_precision": 0.4,
-    "max_ocr_token_precision": 0.4,
-    "avg_ocr_token_f1": 0.4444,
-    "min_ocr_token_f1": 0.4444,
-    "max_ocr_token_f1": 0.4444,
-    "avg_room_name_recall": 0.0,
-    "min_room_name_recall": 0.0,
-    "max_room_name_recall": 0.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_110502.json

@@ -1,139 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T11:05:05.449218",
-    "image_count": 2,
-    "ground_truth": null,
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_110502.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.627
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.011,
-          "lines_detected": 242,
-          "horizontal": 221,
-          "vertical": 21,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 1.064,
-          "element_count": 32,
-          "full_text": "a1 a\n\nBedroom 1                                Kitchen             Bathroom\n\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n\n3,640 x 5,640                                     8,190 x 4,000\nmm\nSCALE  11100600mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "6.400mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom",
-              "Living",
-              "Room",
-              "SCALE",
-              "FLOOR",
-              "PLAN",
-              "LEVEL"
-            ],
-            "numbers": [
-              "1",
-              "2",
-              "1"
-            ],
-            "labels": [
-              "a1",
-              "a",
-              "3,640",
-              "x",
-              "3,640",
-              "2,730",
-              "x",
-              "4,000",
-              "1,820",
-              "x",
-              "3,000",
-              "3,640",
-              "x",
-              "5,640",
-              "8,190",
-              "x",
-              "4,000",
-              "—"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.006,
-          "svg_size_bytes": 22576
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.708
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.542
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.006,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.38,
-          "element_count": 6,
-          "full_text": "ーー      ーー\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Living",
-              "Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "ーー",
-              "ーー",
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2982
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.929
-    }
-  ],
-  "aggregate": {}
-}

benchmark/results/benchmark_20260707_111530.json

@@ -1,121 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T11:15:32.885738",
-    "image_count": 2,
-    "ground_truth": null,
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_111530.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.635
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.01,
-          "lines_detected": 243,
-          "horizontal": 223,
-          "vertical": 20,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.982,
-          "element_count": 18,
-          "full_text": "tum ttや5R5R5t5や5や5つOOつつつつつつべつべつべべ\nBedroom 1                                Kitchen             Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\nBedroom 2                                Living Room\n3,640 x 5,640                                     8,190 x 4,000\n— oo oo Hr rT HH\nSCALE  1:10 g00mm       FLOOR PLAN — LEVEL 1       6,400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 5,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "5 つつ つつ べつ べつ",
-              "oo",
-              "rT",
-              "SCALE",
-              "g00mm",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.005,
-          "svg_size_bytes": 21209
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.632
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.553
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.005,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.379,
-          "element_count": 3,
-          "full_text": "ーー      ーー\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2698
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.938
-    }
-  ],
-  "aggregate": {}
-}

benchmark/results/benchmark_20260707_111703.json

@@ -1,120 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T11:17:05.935392",
-    "image_count": 2,
-    "ground_truth": null,
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_111703.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.635
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.01,
-          "lines_detected": 243,
-          "horizontal": 223,
-          "vertical": 20,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.973,
-          "element_count": 17,
-          "full_text": "tum ttや5R5R5t5や5や5つOOつつつつつつべつべつべべ\nBedroom 1                                Kitchen             Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\nBedroom 2                                Living Room\n3,640 x 5,640                                     8,190 x 4,000\n— oo oo Hr rT HH\nSCALE  1:10 g00mm       FLOOR PLAN — LEVEL 1       6,400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 5,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "oo",
-              "rT",
-              "SCALE",
-              "g00mm",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.005,
-          "svg_size_bytes": 21209
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.623
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.549
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.005,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.375,
-          "element_count": 3,
-          "full_text": "ーー      ーー\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2698
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.93
-    }
-  ],
-  "aggregate": {}
-}

benchmark/results/benchmark_20260707_111914.json

@@ -1,160 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T11:19:17.139313",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_111914.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.636
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.01,
-          "lines_detected": 243,
-          "horizontal": 223,
-          "vertical": 20,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.565,
-          "element_count": 17,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6.400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [
-              "7",
-              "1"
-            ],
-            "labels": [
-              "{",
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.006,
-          "svg_size_bytes": 21483
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.217,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.7059,
-        "ocr_token_f1": 0.7697,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.552
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.005,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.353,
-          "element_count": 3,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2699
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.911,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 0.75,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 0.8571,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.7981,
-    "min_ocr_token_recall": 0.75,
-    "max_ocr_token_recall": 0.8462,
-    "avg_ocr_token_precision": 0.8529,
-    "min_ocr_token_precision": 0.7059,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.8134,
-    "min_ocr_token_f1": 0.7697,
-    "max_ocr_token_f1": 0.8571,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_112107.json

@@ -1,163 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T11:21:10.382211",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_112107.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.627
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.01,
-          "lines_detected": 243,
-          "horizontal": 223,
-          "vertical": 20,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.843,
-          "element_count": 18,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6.400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [
-              "7",
-              "1"
-            ],
-            "labels": [
-              "{",
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1",
-              "a"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.005,
-          "svg_size_bytes": 21575
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.485,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.6667,
-        "ocr_token_f1": 0.7458,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.549
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.005,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.532,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 2796
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.087,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9231,
-    "min_ocr_token_recall": 0.8462,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.8334,
-    "min_ocr_token_precision": 0.6667,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.8729,
-    "min_ocr_token_f1": 0.7458,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_150812.json

@@ -1,163 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T15:08:17.169789",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_150812.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.979
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.013,
-          "lines_detected": 243,
-          "horizontal": 223,
-          "vertical": 20,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 2.075,
-          "element_count": 18,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6.400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [
-              "7",
-              "1"
-            ],
-            "labels": [
-              "{",
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1",
-              "a"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.007,
-          "svg_size_bytes": 21575
-        }
-      },
-      "errors": [],
-      "total_time_s": 3.074,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.6667,
-        "ocr_token_f1": 0.7458,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.626
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.006,
-          "lines_detected": 26,
-          "horizontal": 20,
-          "vertical": 6,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.596,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.003,
-          "svg_size_bytes": 2796
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.231,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9231,
-    "min_ocr_token_recall": 0.8462,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.8334,
-    "min_ocr_token_precision": 0.6667,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.8729,
-    "min_ocr_token_f1": 0.7458,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_163623.json

@@ -1,163 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T16:36:26.607603",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_163623.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.684
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.027,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.985,
-          "element_count": 18,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6.400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [
-              "7",
-              "1"
-            ],
-            "labels": [
-              "{",
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1",
-              "a"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.002,
-          "svg_size_bytes": 4265
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.698,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.6667,
-        "ocr_token_f1": 0.7458,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.57
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.024,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.582,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.177,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9231,
-    "min_ocr_token_recall": 0.8462,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.8334,
-    "min_ocr_token_precision": 0.6667,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.8729,
-    "min_ocr_token_f1": 0.7458,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_163851.json

@@ -1,158 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T16:38:54.291474",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_163851.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.637
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.026,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.849,
-          "element_count": 14,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6.400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 3900
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.513,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.8571,
-        "ocr_token_f1": 0.8516,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.564
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.023,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.585,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.173,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9231,
-    "min_ocr_token_recall": 0.8462,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.9285,
-    "min_ocr_token_precision": 0.8571,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.9258,
-    "min_ocr_token_f1": 0.8516,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_164015.json

@@ -1,158 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T16:40:18.370959",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_164015.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.642
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.026,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.852,
-          "element_count": 14,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 3900
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.521,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.8571,
-        "ocr_token_f1": 0.8516,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.56
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.024,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.558,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.143,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9231,
-    "min_ocr_token_recall": 0.8462,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.9285,
-    "min_ocr_token_precision": 0.8571,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.9258,
-    "min_ocr_token_f1": 0.8516,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_164018.json

@@ -1,158 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T16:40:21.307646",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_164018.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.631
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.026,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.879,
-          "element_count": 14,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "\"SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 3900
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.537,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.8462,
-        "ocr_token_precision": 0.8571,
-        "ocr_token_f1": 0.8516,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.581
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.024,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.553,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.0,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.158,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9231,
-    "min_ocr_token_recall": 0.8462,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.9285,
-    "min_ocr_token_precision": 0.8571,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.9258,
-    "min_ocr_token_f1": 0.8516,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_164213.json

@@ -1,158 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T16:42:16.087131",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_164213.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.644
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.027,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.925,
-          "element_count": 14,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 3899
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.597,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.9231,
-        "ocr_token_precision": 0.9286,
-        "ocr_token_f1": 0.9258,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.58
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.025,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.569,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.175,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9616,
-    "min_ocr_token_recall": 0.9231,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.9643,
-    "min_ocr_token_precision": 0.9286,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.9629,
-    "min_ocr_token_f1": 0.9258,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260707_181600.json

@@ -1,158 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-07T18:16:02.710676",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "/Users/aaronlee/Downloads/architectural-drawing-poc/backend/benchmark/results/benchmark_20260707_181600.json",
-    "pipeline_version": "1.0.0"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.628
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.025,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.861,
-          "element_count": 14,
-          "full_text": "7                                                 1Z,000mm                                                              |\n\nBedroom 1                                   Kitchen              Bathroom\n3,640 x 3,640                                     2,730 x 4,000           1,820 x 3,000\n\nBedroom 2                                Living Room\n3,640 x 3,640                                     8,190 x 4,000\n\n1                                   {\n\"SCALE 1:100690mm       FLOOR PLAN — LEVEL 1       6.400mm",
-          "classified": {
-            "dimensions": [
-              "3,640 x 3,640",
-              "2,730 x 4,000",
-              "1,820 x 3,000",
-              "3,640 x 3,640",
-              "8,190 x 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "SCALE",
-              "FLOOR PLAN",
-              "LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 3899
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.515,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 0.7308,
-        "ocr_token_recall": 0.9231,
-        "ocr_token_precision": 0.9286,
-        "ocr_token_f1": 0.9258,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.556
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.024,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.55,
-          "element_count": 4,
-          "full_text": "Bedroom\n\nLiving Room\n\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.0,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.13,
-      "accuracy": {
-        "ocr_cer": 0.3125,
-        "ocr_wer": 0.2,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.6562,
-    "min_ocr_cer": 0.3125,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 0.4654,
-    "min_ocr_wer": 0.2,
-    "max_ocr_wer": 0.7308,
-    "avg_ocr_token_recall": 0.9616,
-    "min_ocr_token_recall": 0.9231,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.9643,
-    "min_ocr_token_precision": 0.9286,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.9629,
-    "min_ocr_token_f1": 0.9258,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260708_034005.json

@@ -1,135 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-08T03:40:13.475146",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "C:\\Users\\drago\\Downloads\\architecture-poc\\backend\\benchmark\\results\\benchmark_20260708_034005.json",
-    "pipeline_version": "1.0.0",
-    "ocr_model": "paddleocr"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 1.21
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.069,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 5.352,
-          "element_count": 0,
-          "full_text": "",
-          "classified": {
-            "dimensions": [],
-            "room_names": [],
-            "numbers": [],
-            "labels": []
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.003,
-          "svg_size_bytes": 2463
-        }
-      },
-      "errors": [],
-      "total_time_s": 6.634,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 1.0,
-        "ocr_token_recall": 0.0,
-        "ocr_token_precision": 0.0,
-        "ocr_token_f1": 0.0,
-        "room_name_recall": 0.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.913
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.053,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.03,
-          "element_count": 0,
-          "full_text": "",
-          "classified": {
-            "dimensions": [],
-            "room_names": [],
-            "numbers": [],
-            "labels": []
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 784
-        }
-      },
-      "errors": [],
-      "total_time_s": 0.997,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 1.0,
-        "ocr_token_recall": 0.0,
-        "ocr_token_precision": 0.0,
-        "ocr_token_f1": 0.0,
-        "room_name_recall": 0.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 1.0,
-    "min_ocr_cer": 1.0,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 1.0,
-    "min_ocr_wer": 1.0,
-    "max_ocr_wer": 1.0,
-    "avg_ocr_token_recall": 0.0,
-    "min_ocr_token_recall": 0.0,
-    "max_ocr_token_recall": 0.0,
-    "avg_ocr_token_precision": 0.0,
-    "min_ocr_token_precision": 0.0,
-    "max_ocr_token_precision": 0.0,
-    "avg_ocr_token_f1": 0.0,
-    "min_ocr_token_f1": 0.0,
-    "max_ocr_token_f1": 0.0,
-    "avg_room_name_recall": 0.0,
-    "min_room_name_recall": 0.0,
-    "max_room_name_recall": 0.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260708_034317.json

@@ -1,159 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-08T03:43:54.440447",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "C:\\Users\\drago\\Downloads\\architecture-poc\\backend\\benchmark\\results\\benchmark_20260708_034317.json",
-    "pipeline_version": "1.0.0",
-    "ocr_model": "paddleocr"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 1.095
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.058,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 21.326,
-          "element_count": 14,
-          "full_text": "12,000mm\nBedroom 1\nKitchen\nBathroom\n2,730 � 4,000\n3,640 � 3,640\n1,820 � 3,000\nBedroom 2\nLiving Room\n3,640 � 3,640\n8,190 � 4,000\nSCALE 1:100,600mm\nFLOOR PLAN - LEVEL 1\n6,400mm",
-          "classified": {
-            "dimensions": [
-              "12,000mm",
-              "2,730 � 4,000",
-              "3,640 � 3,640",
-              "1,820 � 3,000",
-              "3,640 � 3,640",
-              "8,190 � 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "SCALE 1:100,600mm",
-              "FLOOR PLAN - LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.003,
-          "svg_size_bytes": 3925
-        }
-      },
-      "errors": [],
-      "total_time_s": 22.482,
-      "accuracy": {
-        "ocr_cer": 0.6,
-        "ocr_wer": 0.8077,
-        "ocr_token_recall": 0.3846,
-        "ocr_token_precision": 0.3571,
-        "ocr_token_f1": 0.3704,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 1.049
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.082,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 12.898,
-          "element_count": 4,
-          "full_text": "Bedroom\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 14.03,
-      "accuracy": {
-        "ocr_cer": 0.5,
-        "ocr_wer": 0.4,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.55,
-    "min_ocr_cer": 0.5,
-    "max_ocr_cer": 0.6,
-    "avg_ocr_wer": 0.6038,
-    "min_ocr_wer": 0.4,
-    "max_ocr_wer": 0.8077,
-    "avg_ocr_token_recall": 0.6923,
-    "min_ocr_token_recall": 0.3846,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.6785,
-    "min_ocr_token_precision": 0.3571,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.6852,
-    "min_ocr_token_f1": 0.3704,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260708_034854.json

@@ -1,159 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-08T03:49:28.572783",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "C:\\Users\\drago\\Downloads\\architecture-poc\\backend\\benchmark\\results\\benchmark_20260708_034854.json",
-    "pipeline_version": "1.0.0",
-    "ocr_model": "paddleocr"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 1.087
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.059,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 20.128,
-          "element_count": 14,
-          "full_text": "12,000mm\nBedroom 1\nKitchen\nBathroom\n2,730 × 4,000\n3,640 × 3,640\n1,820 × 3,000\nBedroom 2\nLiving Room\n3,640 × 3,640\n8,190 × 4,000\nSCALE 1:100,600mm\nFLOOR PLAN - LEVEL 1\n6,400mm",
-          "classified": {
-            "dimensions": [
-              "12,000mm",
-              "2,730 × 4,000",
-              "3,640 × 3,640",
-              "1,820 × 3,000",
-              "3,640 × 3,640",
-              "8,190 × 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "SCALE 1:100,600mm",
-              "FLOOR PLAN - LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.004,
-          "svg_size_bytes": 3925
-        }
-      },
-      "errors": [],
-      "total_time_s": 21.278,
-      "accuracy": {
-        "ocr_cer": 0.6,
-        "ocr_wer": 0.8077,
-        "ocr_token_recall": 0.3846,
-        "ocr_token_precision": 0.3571,
-        "ocr_token_f1": 0.3704,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.882
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.048,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 12.043,
-          "element_count": 4,
-          "full_text": "Bedroom\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 12.974,
-      "accuracy": {
-        "ocr_cer": 0.5,
-        "ocr_wer": 0.4,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.55,
-    "min_ocr_cer": 0.5,
-    "max_ocr_cer": 0.6,
-    "avg_ocr_wer": 0.6038,
-    "min_ocr_wer": 0.4,
-    "max_ocr_wer": 0.8077,
-    "avg_ocr_token_recall": 0.6923,
-    "min_ocr_token_recall": 0.3846,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.6785,
-    "min_ocr_token_precision": 0.3571,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.6852,
-    "min_ocr_token_f1": 0.3704,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260708_035238.json

@@ -1,159 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-08T03:53:16.189753",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "C:\\Users\\drago\\Downloads\\architecture-poc\\backend\\benchmark\\results\\benchmark_20260708_035238.json",
-    "pipeline_version": "1.0.0",
-    "ocr_model": "paddleocr"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 1.163
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.063,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 22.366,
-          "element_count": 14,
-          "full_text": "12,000mm\nBedroom 1\nKitchen\nBathroom\n2,730 × 4,000\n3,640 × 3,640\n1,820 × 3,000\nBedroom 2\nLiving Room\n3,640 × 3,640\n8,190 × 4,000\nSCALE 1:100,600mm\nFLOOR PLAN - LEVEL 1\n6,400mm",
-          "classified": {
-            "dimensions": [
-              "12,000mm",
-              "2,730 × 4,000",
-              "3,640 × 3,640",
-              "1,820 × 3,000",
-              "3,640 × 3,640",
-              "8,190 × 4,000",
-              "6,400mm"
-            ],
-            "room_names": [
-              "Bedroom 1",
-              "Kitchen",
-              "Bathroom",
-              "Bedroom 2",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "SCALE 1:100,600mm",
-              "FLOOR PLAN - LEVEL 1"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.003,
-          "svg_size_bytes": 3925
-        }
-      },
-      "errors": [],
-      "total_time_s": 23.595,
-      "accuracy": {
-        "ocr_cer": 0.5704,
-        "ocr_wer": 0.6538,
-        "ocr_token_recall": 0.6923,
-        "ocr_token_precision": 0.7143,
-        "ocr_token_f1": 0.7031,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.982
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.055,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 13.425,
-          "element_count": 4,
-          "full_text": "Bedroom\n3640mm\nLiving Room\n1:100",
-          "classified": {
-            "dimensions": [
-              "3640mm"
-            ],
-            "room_names": [
-              "Bedroom",
-              "Living Room"
-            ],
-            "numbers": [],
-            "labels": [
-              "1:100"
-            ]
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 1202
-        }
-      },
-      "errors": [],
-      "total_time_s": 14.463,
-      "accuracy": {
-        "ocr_cer": 0.5,
-        "ocr_wer": 0.4,
-        "ocr_token_recall": 1.0,
-        "ocr_token_precision": 1.0,
-        "ocr_token_f1": 1.0,
-        "room_name_recall": 1.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 0.5352,
-    "min_ocr_cer": 0.5,
-    "max_ocr_cer": 0.5704,
-    "avg_ocr_wer": 0.5269,
-    "min_ocr_wer": 0.4,
-    "max_ocr_wer": 0.6538,
-    "avg_ocr_token_recall": 0.8461,
-    "min_ocr_token_recall": 0.6923,
-    "max_ocr_token_recall": 1.0,
-    "avg_ocr_token_precision": 0.8572,
-    "min_ocr_token_precision": 0.7143,
-    "max_ocr_token_precision": 1.0,
-    "avg_ocr_token_f1": 0.8516,
-    "min_ocr_token_f1": 0.7031,
-    "max_ocr_token_f1": 1.0,
-    "avg_room_name_recall": 1.0,
-    "min_room_name_recall": 1.0,
-    "max_room_name_recall": 1.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/results/benchmark_20260708_035329.json

@@ -1,135 +0,0 @@
-{
-  "metadata": {
-    "timestamp": "2026-07-08T03:53:32.005797",
-    "image_count": 2,
-    "ground_truth": "benchmark/ground_truth.json",
-    "output_path": "C:\\Users\\drago\\Downloads\\architecture-poc\\backend\\benchmark\\results\\benchmark_20260708_035329.json",
-    "pipeline_version": "1.0.0",
-    "ocr_model": "tesseract"
-  },
-  "images": [
-    {
-      "filename": "floor_plan_level1.jpg",
-      "size_bytes": 233218,
-      "dimensions": {
-        "width": 1400,
-        "height": 1000
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 1.153
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.062,
-          "lines_detected": 27,
-          "horizontal": 8,
-          "vertical": 9,
-          "diagonal": 10
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.085,
-          "element_count": 0,
-          "full_text": "",
-          "classified": {
-            "dimensions": [],
-            "room_names": [],
-            "numbers": [],
-            "labels": []
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.002,
-          "svg_size_bytes": 2463
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.302,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 1.0,
-        "ocr_token_recall": 0.0,
-        "ocr_token_precision": 0.0,
-        "ocr_token_f1": 0.0,
-        "room_name_recall": 0.0,
-        "line_count_accuracy": 1.0
-      }
-    },
-    {
-      "filename": "synthetic_floor_plan.png",
-      "size_bytes": 12406,
-      "dimensions": {
-        "width": 1200,
-        "height": 900
-      },
-      "stages": {
-        "enhancement": {
-          "success": true,
-          "time_s": 0.987
-        },
-        "line_extraction": {
-          "success": true,
-          "time_s": 0.064,
-          "lines_detected": 6,
-          "horizontal": 3,
-          "vertical": 3,
-          "diagonal": 0
-        },
-        "ocr": {
-          "success": true,
-          "time_s": 0.054,
-          "element_count": 0,
-          "full_text": "",
-          "classified": {
-            "dimensions": [],
-            "room_names": [],
-            "numbers": [],
-            "labels": []
-          }
-        },
-        "svg": {
-          "success": true,
-          "time_s": 0.001,
-          "svg_size_bytes": 784
-        }
-      },
-      "errors": [],
-      "total_time_s": 1.106,
-      "accuracy": {
-        "ocr_cer": 1.0,
-        "ocr_wer": 1.0,
-        "ocr_token_recall": 0.0,
-        "ocr_token_precision": 0.0,
-        "ocr_token_f1": 0.0,
-        "room_name_recall": 0.0,
-        "line_count_accuracy": 1.0
-      }
-    }
-  ],
-  "aggregate": {
-    "avg_ocr_cer": 1.0,
-    "min_ocr_cer": 1.0,
-    "max_ocr_cer": 1.0,
-    "avg_ocr_wer": 1.0,
-    "min_ocr_wer": 1.0,
-    "max_ocr_wer": 1.0,
-    "avg_ocr_token_recall": 0.0,
-    "min_ocr_token_recall": 0.0,
-    "max_ocr_token_recall": 0.0,
-    "avg_ocr_token_precision": 0.0,
-    "min_ocr_token_precision": 0.0,
-    "max_ocr_token_precision": 0.0,
-    "avg_ocr_token_f1": 0.0,
-    "min_ocr_token_f1": 0.0,
-    "max_ocr_token_f1": 0.0,
-    "avg_room_name_recall": 0.0,
-    "min_room_name_recall": 0.0,
-    "max_room_name_recall": 0.0,
-    "avg_line_count_accuracy": 1.0,
-    "min_line_count_accuracy": 1.0,
-    "max_line_count_accuracy": 1.0
-  }
-}

benchmark/run_benchmark.py

@@ -1,432 +0,0 @@
-#!/usr/bin/env python3
-"""
-Architectural Drawing AI — Benchmark Runner
-============================================
-Runs every image in `sample_images/` through the full processing pipeline
-and measures accuracy against optional ground truth annotations.
-
-Usage
------
-    # Basic run (no ground truth — measures timing and detection counts only)
-    cd backend
-    ./venv/bin/python benchmark/run_benchmark.py
-
-    # With ground truth annotations
-    ./venv/bin/python benchmark/run_benchmark.py --gt benchmark/ground_truth.json
-
-    # Save results to a specific file
-    ./venv/bin/python benchmark/run_benchmark.py --gt benchmark/ground_truth.json \
-        --out benchmark/results/run_2026_06_29.json
-
-    # Verbose output (prints per-image detail)
-    ./venv/bin/python benchmark/run_benchmark.py -v
-
-Output
-------
-Prints a summary table to stdout and writes a full JSON report to
-benchmark/results/benchmark_<timestamp>.json (or --out path).
-
-The JSON report is structured for import into the feasibility report and for
-comparison across runs to track accuracy improvements over time.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-import cv2
-import numpy as np
-
-# Make sure backend root is on the path regardless of cwd
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT))
-
-from processors.image_enhancer import ImageEnhancer
-from processors.line_extractor  import LineExtractor
-from processors.ocr_processor   import OCRProcessor
-from processors.svg_generator   import SVGGenerator
-from utils.image_utils          import bytes_to_numpy, resize_for_processing
-from benchmark.metrics import (
-    character_error_rate,
-    word_error_rate,
-    token_recall,
-    token_precision,
-    f1,
-    line_count_accuracy,
-)
-
-logging.basicConfig(level=logging.WARNING)
-logger = logging.getLogger(__name__)
-
-SAMPLE_DIR  = ROOT / "benchmark" / "sample_images"
-RESULTS_DIR = ROOT / "benchmark" / "results"
-RESULTS_DIR.mkdir(parents=True, exist_ok=True)
-
-SUPPORTED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".tif", ".tiff", ".bmp", ".webp"}
-
-
-# ---------------------------------------------------------------------------
-# Processor singletons
-# ---------------------------------------------------------------------------
-_enhancer  = ImageEnhancer()
-_extractor = LineExtractor()
-_ocr       = OCRProcessor()
-_svg       = SVGGenerator()
-_paddleocr = None  # lazy — only imported/instantiated if --ocr-model paddleocr
-
-
-def _get_ocr_processor(ocr_model: Optional[str]):
-    """Mirrors main.py's _get_ocr_processor: falls back to Tesseract if
-    PaddleOCR is requested but unavailable."""
-    global _paddleocr
-    if ocr_model == "paddleocr":
-        if _paddleocr is None:
-            from processors.paddleocr_processor import PaddleOCRProcessor
-            _paddleocr = PaddleOCRProcessor()
-        if _paddleocr.is_available:
-            return _paddleocr
-        logger.warning(
-            "PaddleOCR requested but unavailable (%s) — falling back to Tesseract",
-            _paddleocr.unavailable_reason,
-        )
-    return _ocr
-
-
-# ---------------------------------------------------------------------------
-# Per-image processing
-# ---------------------------------------------------------------------------
-
-def process_image(image_path: Path, ocr_model: Optional[str] = None) -> Dict[str, Any]:
-    """
-    Run the full pipeline on one image.
-    Returns a dict with timings, counts, and all raw results.
-    """
-    raw = image_path.read_bytes()
-    image = bytes_to_numpy(raw)
-    if image is None:
-        return {"error": "Cannot decode image", "path": str(image_path)}
-
-    image = resize_for_processing(image, max_dimension=3000)
-    result: Dict[str, Any] = {
-        "filename":    image_path.name,
-        "size_bytes":  len(raw),
-        "dimensions":  {"width": image.shape[1], "height": image.shape[0]},
-        "stages":      {},
-        "errors":      [],
-    }
-
-    # Stage 1 — Enhancement
-    t0 = time.perf_counter()
-    try:
-        enhanced = _enhancer.enhance(image)
-        result["stages"]["enhancement"] = {
-            "success": True,
-            "time_s":  round(time.perf_counter() - t0, 3),
-        }
-    except Exception as exc:
-        enhanced = image
-        result["stages"]["enhancement"] = {"success": False, "error": str(exc)}
-        result["errors"].append(f"enhancement: {exc}")
-
-    # Stage 2 — Line extraction
-    t0 = time.perf_counter()
-    try:
-        _, lines = _extractor.extract(enhanced)
-        result["stages"]["line_extraction"] = {
-            "success":        True,
-            "time_s":         round(time.perf_counter() - t0, 3),
-            "lines_detected": len(lines),
-            "horizontal":     sum(1 for l in lines if abs(l["angle"]) <= 15 or abs(l["angle"]) >= 165),
-            "vertical":       sum(1 for l in lines if 75 <= abs(l["angle"]) <= 105),
-            "diagonal":       sum(1 for l in lines if not (abs(l["angle"]) <= 15 or abs(l["angle"]) >= 165 or 75 <= abs(l["angle"]) <= 105)),
-        }
-    except Exception as exc:
-        lines = []
-        result["stages"]["line_extraction"] = {"success": False, "error": str(exc)}
-        result["errors"].append(f"line_extraction: {exc}")
-
-    # Stage 3 — OCR
-    t0 = time.perf_counter()
-    try:
-        ocr_result = _get_ocr_processor(ocr_model).extract_text(enhanced)
-        result["stages"]["ocr"] = {
-            "success":       True,
-            "time_s":        round(time.perf_counter() - t0, 3),
-            "element_count": ocr_result["element_count"],
-            "full_text":     ocr_result["full_text"],
-            "classified": {
-                "dimensions": [e["text"] for e in ocr_result["classified"]["dimensions"]],
-                "room_names": [e["text"] for e in ocr_result["classified"]["room_names"]],
-                "numbers":    [e["text"] for e in ocr_result["classified"]["numbers"]],
-                "labels":     [e["text"] for e in ocr_result["classified"]["labels"]],
-            },
-        }
-    except Exception as exc:
-        ocr_result = None
-        result["stages"]["ocr"] = {"success": False, "error": str(exc)}
-        result["errors"].append(f"ocr: {exc}")
-
-    # Stage 4 — SVG (always run to verify generation)
-    t0 = time.perf_counter()
-    try:
-        svg = _svg.generate(lines, image.shape[1], image.shape[0], ocr_result)
-        result["stages"]["svg"] = {
-            "success":      True,
-            "time_s":       round(time.perf_counter() - t0, 3),
-            "svg_size_bytes": len(svg.encode()),
-        }
-    except Exception as exc:
-        result["stages"]["svg"] = {"success": False, "error": str(exc)}
-        result["errors"].append(f"svg: {exc}")
-
-    result["total_time_s"] = round(
-        sum(s.get("time_s", 0) for s in result["stages"].values()), 3
-    )
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Accuracy scoring against ground truth
-# ---------------------------------------------------------------------------
-
-def score_against_ground_truth(
-    image_result: Dict[str, Any],
-    gt: Dict[str, Any],
-) -> Dict[str, Any]:
-    """
-    Compares pipeline output against a ground truth entry.
-    Returns a dict of accuracy scores for this image.
-    """
-    scores: Dict[str, Any] = {}
-
-    ocr_stage = image_result["stages"].get("ocr", {})
-    line_stage = image_result["stages"].get("line_extraction", {})
-
-    # OCR — full text CER and WER
-    if ocr_stage.get("success") and "expected_text" in gt:
-        expected_str  = " ".join(gt["expected_text"])
-        predicted_str = ocr_stage.get("full_text", "")
-
-        scores["ocr_cer"] = round(character_error_rate(predicted_str, expected_str), 4)
-        scores["ocr_wer"] = round(word_error_rate(predicted_str, expected_str), 4)
-
-        # Token-level recall/precision for key labels
-        all_tokens = (
-            ocr_stage["classified"]["dimensions"]
-            + ocr_stage["classified"]["room_names"]
-            + ocr_stage["classified"]["numbers"]
-            + ocr_stage["classified"]["labels"]
-        )
-        rec  = token_recall(all_tokens, gt["expected_text"])
-        prec = token_precision(all_tokens, gt["expected_text"])
-        scores["ocr_token_recall"]    = round(rec, 4)
-        scores["ocr_token_precision"] = round(prec, 4)
-        scores["ocr_token_f1"]        = round(f1(prec, rec), 4)
-
-    # Room name recall
-    if ocr_stage.get("success") and "expected_room_names" in gt:
-        rooms = ocr_stage["classified"]["room_names"]
-        scores["room_name_recall"] = round(
-            token_recall(rooms, gt["expected_room_names"]), 4
-        )
-
-    # Line count accuracy
-    if line_stage.get("success") and "expected_line_count_min" in gt:
-        scores["line_count_accuracy"] = round(
-            line_count_accuracy(
-                line_stage["lines_detected"],
-                gt["expected_line_count_min"],
-                gt["expected_line_count_max"],
-            ),
-            4,
-        )
-
-    return scores
-
-
-# ---------------------------------------------------------------------------
-# Summary statistics
-# ---------------------------------------------------------------------------
-
-def aggregate(all_scores: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Average all numeric score fields across images."""
-    if not all_scores:
-        return {}
-    keys = [k for k in all_scores[0] if isinstance(all_scores[0][k], float)]
-    agg: Dict[str, Any] = {}
-    for k in keys:
-        vals = [s[k] for s in all_scores if k in s]
-        if vals:
-            agg[f"avg_{k}"] = round(sum(vals) / len(vals), 4)
-            agg[f"min_{k}"] = round(min(vals), 4)
-            agg[f"max_{k}"] = round(max(vals), 4)
-    return agg
-
-
-def print_summary(report: Dict[str, Any]) -> None:
-    """Print a human-readable table to stdout."""
-    images   = report["images"]
-    agg      = report.get("aggregate", {})
-    metadata = report["metadata"]
-
-    print("\n" + "=" * 70)
-    print(f"  Architectural Drawing AI — Benchmark Results")
-    print(f"  {metadata['timestamp']}  |  {metadata['image_count']} image(s)")
-    print("=" * 70)
-
-    col = "{:<28} {:>7} {:>7} {:>8} {:>8}"
-    print(col.format("Image", "Lines", "OCR", "Time(s)", "Errors"))
-    print("-" * 70)
-
-    for img in images:
-        line_s = img["stages"].get("line_extraction", {})
-        ocr_s  = img["stages"].get("ocr", {})
-        lines  = line_s.get("lines_detected", "-") if line_s.get("success") else "ERR"
-        tokens = ocr_s.get("element_count", "-") if ocr_s.get("success") else "ERR"
-        errors = len(img.get("errors", []))
-        print(col.format(
-            img["filename"][:27],
-            str(lines),
-            str(tokens),
-            str(img.get("total_time_s", "-")),
-            str(errors) if errors else "",
-        ))
-
-    if agg:
-        print("-" * 70)
-        print("\n  Accuracy (averaged across all images with ground truth):\n")
-        metric_labels = {
-            "avg_ocr_cer":             "OCR Character Error Rate  (lower=better)",
-            "avg_ocr_wer":             "OCR Word Error Rate       (lower=better)",
-            "avg_ocr_token_f1":        "OCR Token F1              (higher=better)",
-            "avg_ocr_token_recall":    "OCR Token Recall",
-            "avg_ocr_token_precision": "OCR Token Precision",
-            "avg_room_name_recall":    "Room Name Recall",
-            "avg_line_count_accuracy": "Line Count Accuracy",
-        }
-        for key, label in metric_labels.items():
-            if key in agg:
-                pct = f"{agg[key]*100:.1f}%"
-                print(f"    {label:<45} {pct:>7}")
-
-    print("\n  Results saved to:", report["metadata"].get("output_path", "—"))
-    print("=" * 70 + "\n")
-
-
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Benchmark the drawing pipeline")
-    parser.add_argument(
-        "--images", default=str(SAMPLE_DIR),
-        help="Directory of test images (default: benchmark/sample_images/)",
-    )
-    parser.add_argument(
-        "--gt", default=None,
-        help="Path to ground_truth.json for accuracy scoring",
-    )
-    parser.add_argument(
-        "--out", default=None,
-        help="Output JSON path (default: benchmark/results/benchmark_<ts>.json)",
-    )
-    parser.add_argument(
-        "-v", "--verbose", action="store_true",
-        help="Print per-image stage detail",
-    )
-    parser.add_argument(
-        "--ocr-model", default=None, choices=["tesseract", "paddleocr"],
-        help="OCR engine to benchmark (default: tesseract). Falls back to "
-             "tesseract if paddleocr is requested but unavailable.",
-    )
-    args = parser.parse_args()
-
-    images_dir = Path(args.images)
-    if not images_dir.exists():
-        print(f"ERROR: images directory not found: {images_dir}")
-        sys.exit(1)
-
-    image_paths = sorted(
-        p for p in images_dir.iterdir()
-        if p.suffix.lower() in SUPPORTED_EXTENSIONS
-    )
-
-    if not image_paths:
-        print(f"\nNo images found in {images_dir}")
-        print("Add JPEG/PNG architectural drawings to that directory and re-run.")
-        sys.exit(0)
-
-    ground_truth: Dict[str, Any] = {}
-    if args.gt:
-        gt_path = Path(args.gt)
-        if gt_path.exists():
-            with gt_path.open(encoding="utf-8") as f:
-                raw_gt = json.load(f)
-            # Strip comment keys
-            ground_truth = {k: v for k, v in raw_gt.items() if not k.startswith("_")}
-            print(f"Loaded ground truth for {len(ground_truth)} image(s).")
-        else:
-            print(f"WARNING: ground truth file not found: {gt_path}")
-
-    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-    out_path = Path(args.out) if args.out else RESULTS_DIR / f"benchmark_{ts}.json"
-
-    print(f"\nProcessing {len(image_paths)} image(s) from {images_dir} …\n")
-
-    image_results = []
-    all_scores    = []
-
-    for path in image_paths:
-        print(f"  [{image_paths.index(path)+1}/{len(image_paths)}] {path.name} …", end=" ", flush=True)
-        result = process_image(path, ocr_model=args.ocr_model)
-
-        if "error" in result:
-            print(f"FAILED — {result['error']}")
-        else:
-            print(f"OK  ({result['total_time_s']}s, "
-                  f"{result['stages'].get('line_extraction', {}).get('lines_detected', '?')} lines, "
-                  f"{result['stages'].get('ocr', {}).get('element_count', '?')} OCR tokens)")
-
-        if args.verbose:
-            for stage, data in result.get("stages", {}).items():
-                print(f"     {stage}: {data}")
-
-        gt_entry = ground_truth.get(path.name)
-        if gt_entry:
-            scores = score_against_ground_truth(result, gt_entry)
-            result["accuracy"] = scores
-            all_scores.append(scores)
-
-        image_results.append(result)
-
-    report = {
-        "metadata": {
-            "timestamp":    datetime.now().isoformat(),
-            "image_count":  len(image_results),
-            "ground_truth": args.gt,
-            "output_path":  str(out_path),
-            "pipeline_version": "1.0.0",
-            "ocr_model": args.ocr_model or "tesseract",
-        },
-        "images":    image_results,
-        "aggregate": aggregate(all_scores) if all_scores else {},
-    }
-
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    with out_path.open("w", encoding="utf-8") as f:
-        json.dump(report, f, indent=2, ensure_ascii=False)
-
-    print_summary(report)
-
-
-if __name__ == "__main__":
-    main()

processors/enhancement/__init__.py

@@ -1,12 +0,0 @@
-"""
-Enhancement provider package.
-Import `registry` for all provider access.
-"""
-from .registry import registry
-from .base import EnhancementProvider
-from .pipeline import build_preset_pipelines
-
-# Register composite pipelines after all individual providers are loaded
-build_preset_pipelines(registry)
-
-__all__ = ["registry", "EnhancementProvider"]

processors/enhancement/base.py

@@ -1,92 +0,0 @@
-"""
-Abstract base class for all image enhancement providers.
-
-Every provider must implement:
-  - name        : str   — unique slug used in the API (e.g. "classical", "real_esrgan")
-  - display_name: str   — human-readable name shown in /api/info
-  - is_available: bool  — False if required dependencies are not installed
-  - enhance(image) -> np.ndarray
-
-Optional overrides:
-  - description : str
-  - enhance_to_grayscale(image) -> np.ndarray  (for intermediate display)
-"""
-
-from __future__ import annotations
-from abc import ABC, abstractmethod
-from typing import Optional
-import numpy as np
-
-
-class EnhancementProvider(ABC):
-
-    # ------------------------------------------------------------------ #
-    # Identity — subclasses set these as class attributes                  #
-    # ------------------------------------------------------------------ #
-
-    name:         str = ""
-    display_name: str = ""
-    description:  str = ""
-
-    # ------------------------------------------------------------------ #
-    # Availability                                                          #
-    # ------------------------------------------------------------------ #
-
-    @property
-    @abstractmethod
-    def is_available(self) -> bool:
-        """
-        Return True only if all required packages are installed and any
-        required model weights are accessible. Called once at startup.
-        """
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        """Human-readable explanation shown in /api/info when unavailable."""
-        return None
-
-    # ------------------------------------------------------------------ #
-    # Core interface                                                        #
-    # ------------------------------------------------------------------ #
-
-    @abstractmethod
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        """
-        Enhance the image.
-
-        Parameters
-        ----------
-        image : np.ndarray
-            BGR or grayscale uint8 image as loaded by OpenCV.
-
-        Returns
-        -------
-        np.ndarray
-            Enhanced image — same dtype (uint8), same or different shape.
-            Must be suitable for direct input to LineExtractor and OCRProcessor.
-        """
-
-    def enhance_to_grayscale(self, image: np.ndarray) -> np.ndarray:
-        """
-        Return a grayscale (non-binary) enhanced image for display purposes.
-        Default: call enhance() and convert to grayscale if needed.
-        Override in subclasses if the provider has a natural grayscale output.
-        """
-        import cv2
-        result = self.enhance(image)
-        if len(result.shape) == 3:
-            return cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
-        return result
-
-    # ------------------------------------------------------------------ #
-    # Metadata for /api/info                                               #
-    # ------------------------------------------------------------------ #
-
-    def info(self) -> dict:
-        return {
-            "name":             self.name,
-            "display_name":     self.display_name,
-            "description":      self.description,
-            "available":        self.is_available,
-            "unavailable_reason": self.unavailable_reason if not self.is_available else None,
-        }

processors/enhancement/classical.py

@@ -1,35 +0,0 @@
-"""
-Classical OpenCV enhancement provider.
-Always available — no extra dependencies beyond the existing requirements.
-Wraps the existing ImageEnhancer pipeline.
-"""
-
-from __future__ import annotations
-import numpy as np
-
-from .base import EnhancementProvider
-from processors.image_enhancer import ImageEnhancer
-
-
-class ClassicalCVProvider(EnhancementProvider):
-
-    name         = "classical"
-    display_name = "Classical CV (OpenCV)"
-    description  = (
-        "6-stage OpenCV pipeline: grayscale → NLM denoise → background removal "
-        "→ CLAHE contrast → adaptive threshold → morphological cleanup. "
-        "Fast, no GPU required, works on any hardware."
-    )
-
-    def __init__(self) -> None:
-        self._enhancer = ImageEnhancer()
-
-    @property
-    def is_available(self) -> bool:
-        return True  # OpenCV is a hard dependency of the whole backend
-
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        return self._enhancer.enhance(image)
-
-    def enhance_to_grayscale(self, image: np.ndarray) -> np.ndarray:
-        return self._enhancer.enhance_grayscale(image)

processors/enhancement/groq_guided.py

@@ -1,288 +0,0 @@
-"""
-Groq AI-Guided Enhancement Provider
-=====================================
-Uses Groq's Llama 4 Scout vision model to assess the input drawing's
-quality, type, and degradation level, then runs the classical OpenCV
-pipeline with parameters tuned to that assessment.
-
-What Groq contributes
----------------------
-Groq is a text/vision inference API — it cannot modify pixel values.
-Its role here is PARAMETER SELECTION:
-
-  • quality_score  → how aggressively to denoise / boost contrast
-  • drawing_type   → e.g. "detail" drawings need sharper lines
-  • ocr_difficulty → drive CLAHE strength for text regions
-
-All actual image processing is performed by OpenCV via _TunableEnhancer,
-a subclass of ImageEnhancer that accepts the parameter dict from Groq's
-analysis instead of hardcoded constants.
-
-Fallback
---------
-If the Groq call fails for any reason (network error, rate limit, bad JSON),
-the provider silently falls back to default parameters — equivalent to the
-standard classical pipeline — so processing never fails.
-"""
-
-from __future__ import annotations
-
-import base64
-import json
-import logging
-import os
-import warnings
-from typing import Optional
-
-import cv2
-import numpy as np
-
-from .base import EnhancementProvider
-from processors.image_enhancer import ImageEnhancer
-
-logger = logging.getLogger(__name__)
-
-# ── Groq analysis prompt ──────────────────────────────────────────────────────
-# Short, specific — we only need the fields we can act on.
-_PARAM_PROMPT = (
-    "You are assessing a scanned architectural or engineering drawing for "
-    "automated image restoration.  Respond ONLY with valid JSON (no markdown "
-    "fences) using exactly these fields:\n"
-    "{\n"
-    '  "drawing_type": "floor plan | elevation | section | detail | '
-    'site plan | railway | electrical | mechanical | other",\n'
-    '  "quality_score": <integer 1-10>,\n'
-    '  "degradation": ["list from: faded, yellowed, stained, noisy, blurred, '
-    'folded, torn, foxing, compression artifacts"],\n'
-    '  "has_color_fills": <true or false>,\n'
-    '  "has_japanese_text": <true or false>,\n'
-    '  "ocr_difficulty": "easy | moderate | hard | very hard"\n'
-    "}"
-)
-
-
-# ── Parameter mapping ─────────────────────────────────────────────────────────
-
-def _default_params() -> dict:
-    """Matches the hardcoded defaults in ImageEnhancer — safe fallback."""
-    return {
-        "bilateral_sigma":  40,
-        "clahe_clip":       2.0,
-        "content_clip":     3.0,
-        "sharpen_strength": 0.30,
-        "bg_brightness":    235,
-        "vivify_factor":    1.30,
-    }
-
-
-def _params_from_analysis(analysis: dict) -> dict:
-    """
-    Convert Groq's quality analysis into a parameter dict.
-
-    Quality tier  → base settings
-    OCR difficulty → lifts CLAHE in content zones
-    Drawing type   → increases sharpening for detail/section drawings
-    """
-    params  = _default_params()
-    quality = int(analysis.get("quality_score") or 5)
-    ocr     = (analysis.get("ocr_difficulty") or "moderate").lower()
-    dtype   = (analysis.get("drawing_type") or "").lower()
-
-    # ── Quality tier ──
-    if quality <= 3:
-        # Severely degraded: maximum denoising + contrast
-        params.update(bilateral_sigma=55, clahe_clip=3.5,
-                      content_clip=4.5, sharpen_strength=0.45, bg_brightness=228)
-    elif quality <= 6:
-        # Moderately degraded: standard-plus settings
-        params.update(bilateral_sigma=40, clahe_clip=2.5,
-                      content_clip=3.5, sharpen_strength=0.35, bg_brightness=232)
-    elif quality <= 8:
-        # Good: default settings
-        params.update(bilateral_sigma=30, clahe_clip=2.0,
-                      content_clip=3.0, sharpen_strength=0.30, bg_brightness=236)
-    else:
-        # Excellent: minimal processing to avoid over-cooking
-        params.update(bilateral_sigma=22, clahe_clip=1.5,
-                      content_clip=2.5, sharpen_strength=0.20, bg_brightness=242)
-
-    # ── OCR difficulty modifier ──
-    if ocr in ("hard", "very hard"):
-        params["clahe_clip"]    = min(params["clahe_clip"] + 0.5, 5.0)
-        params["content_clip"]  = min(params["content_clip"] + 0.5, 6.0)
-    if ocr == "very hard":
-        params["bilateral_sigma"] = min(params["bilateral_sigma"] + 10, 65)
-
-    # ── Drawing type modifier ──
-    if any(t in dtype for t in ("detail", "section")):
-        # Precise linework drawings benefit from stronger sharpening
-        params["sharpen_strength"] = min(params["sharpen_strength"] + 0.10, 0.60)
-
-    logger.info(
-        "Groq-guided params — quality=%d  ocr=%s  type=%s  "
-        "σ=%d  clahe=%.1f  content_clahe=%.1f  sharpen=%.2f",
-        quality, ocr, dtype or "unknown",
-        params["bilateral_sigma"], params["clahe_clip"],
-        params["content_clip"], params["sharpen_strength"],
-    )
-    return params
-
-
-# ── Tunable pipeline ──────────────────────────────────────────────────────────
-
-class _TunableEnhancer(ImageEnhancer):
-    """
-    ImageEnhancer subclass where the four parametric stages read their
-    settings from a dict instead of hardcoded constants.
-
-    Non-parametric stages (crop, upscale, border, deskew, background
-    normalisation, speck removal) are inherited unchanged.
-    """
-
-    def __init__(self, params: dict) -> None:
-        self._p = params
-
-    def _bilateral_denoise(self, image: np.ndarray) -> np.ndarray:
-        s  = self._p["bilateral_sigma"]
-        d1 = cv2.bilateralFilter(image, d=9, sigmaColor=s,        sigmaSpace=15)
-        return cv2.bilateralFilter(d1,   d=9, sigmaColor=max(10, s // 2), sigmaSpace=10)
-
-    def _enhance_contrast(self, image: np.ndarray) -> np.ndarray:
-        clip = self._p["clahe_clip"]
-        if len(image.shape) == 2:
-            return cv2.createCLAHE(clipLimit=clip, tileGridSize=(8, 8)).apply(image)
-        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-        l, a, b = cv2.split(lab)
-        l = cv2.createCLAHE(clipLimit=clip, tileGridSize=(8, 8)).apply(l)
-        return cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
-
-    def _content_enhance(self, image: np.ndarray) -> np.ndarray:
-        clip = self._p["content_clip"]
-        gray = image if len(image.shape) == 2 else cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        content_px   = (gray < 200).astype(np.uint8)
-        kern         = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (21, 21))
-        content_zone = cv2.dilate(content_px, kern).astype(bool)
-        clahe        = cv2.createCLAHE(clipLimit=clip, tileGridSize=(8, 8))
-        if len(image.shape) == 2:
-            return np.where(content_zone, clahe.apply(image), image).astype(np.uint8)
-        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-        l, a, b = cv2.split(lab)
-        l_out = np.where(content_zone, clahe.apply(l), l).astype(np.uint8)
-        return cv2.cvtColor(cv2.merge([l_out, a, b]), cv2.COLOR_LAB2BGR)
-
-    def _sharpen_linework(self, image: np.ndarray) -> np.ndarray:
-        strength = self._p["sharpen_strength"]
-        gray = image if len(image.shape) == 2 else cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        gx   = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
-        gy   = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
-        grad = np.sqrt(gx ** 2 + gy ** 2)
-        edge = ((gray < 180) & (grad > 15)).astype(np.uint8)
-        kern = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-        zone = cv2.dilate(edge, kern).astype(bool)
-        blur      = cv2.GaussianBlur(image, (3, 3), sigmaX=0.8)
-        sharpened = cv2.addWeighted(image, 1.0 + strength, blur, -strength, 0)
-        if len(image.shape) == 3:
-            mask3 = np.stack([zone, zone, zone], axis=2)
-            return np.where(mask3, sharpened, image).astype(np.uint8)
-        return np.where(zone, sharpened, image).astype(np.uint8)
-
-    def _clean_background(self, image: np.ndarray) -> np.ndarray:
-        thresh = self._p["bg_brightness"]
-        gray   = image if len(image.shape) == 2 else cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        gray_f = gray.astype(np.float32)
-        variance = np.maximum(
-            cv2.blur(gray_f ** 2, (9, 9)) - cv2.blur(gray_f, (9, 9)) ** 2, 0.0
-        )
-        bg_mask = (gray > thresh) & (variance < 60)
-        result  = image.copy()
-        if len(image.shape) == 2:
-            result[bg_mask] = 255
-        else:
-            result[bg_mask] = (255, 255, 255)
-        logger.info("BG cleanup (thresh=%d): %d px → white", thresh, int(bg_mask.sum()))
-        return result
-
-
-# ── Provider class ────────────────────────────────────────────────────────────
-
-class GroqGuidedProvider(EnhancementProvider):
-    """
-    Enhancement provider that uses Groq's vision model to assess the
-    drawing and then runs a parameter-tuned classical CV pipeline.
-    """
-
-    name         = "groq_guided"
-    display_name = "Groq AI-Guided (Llama 4 Scout + OpenCV)"
-    description  = (
-        "Groq Llama 4 Scout vision assesses drawing quality, type, and "
-        "degradation — then a tuned OpenCV pipeline applies the right "
-        "enhancement strength.  Requires GROQ_API_KEY in backend/.env."
-    )
-
-    @property
-    def is_available(self) -> bool:
-        return bool(os.getenv("GROQ_API_KEY", "").strip())
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        return None if self.is_available else "GROQ_API_KEY not set in backend/.env"
-
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        analysis = self._analyze(image)
-        params   = _params_from_analysis(analysis)
-        return _TunableEnhancer(params).enhance(image)
-
-    # ── Groq call ──────────────────────────────────────────────────────────
-
-    def _analyze(self, image: np.ndarray) -> dict:
-        """
-        Send an 800 px thumbnail to Groq for quality assessment.
-        Returns empty dict (→ default params) on any failure.
-        """
-        thumb = self._thumbnail(image, 800)
-        _, jpeg = cv2.imencode(".jpg", thumb, [cv2.IMWRITE_JPEG_QUALITY, 85])
-        b64 = base64.b64encode(jpeg.tobytes()).decode()
-
-        try:
-            raw  = self._call_groq(b64)
-            text = raw.strip()
-            if text.startswith("```"):
-                text = text.split("```")[1].lstrip("json").strip()
-            result = json.loads(text)
-            logger.info("Groq analysis: %s", result)
-            return result
-        except Exception as exc:
-            logger.warning("Groq analysis failed (%s) — using default params", exc)
-            return {}
-
-    def _call_groq(self, b64: str) -> str:
-        import httpx
-        from groq import Groq
-
-        api_key = os.getenv("GROQ_API_KEY", "").strip()
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            client = Groq(api_key=api_key, http_client=httpx.Client(verify=False))  # noqa: S501  # NOSONAR
-
-        resp = client.chat.completions.create(
-            model="meta-llama/llama-4-scout-17b-16e-instruct",
-            max_tokens=256,
-            messages=[{
-                "role": "user",
-                "content": [
-                    {"type": "image_url",
-                     "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
-                    {"type": "text", "text": _PARAM_PROMPT},
-                ],
-            }],
-        )
-        return resp.choices[0].message.content
-
-    @staticmethod
-    def _thumbnail(image: np.ndarray, max_side: int) -> np.ndarray:
-        h, w = image.shape[:2]
-        if max(h, w) <= max_side:
-            return image
-        scale = max_side / max(h, w)
-        return cv2.resize(image, (int(w * scale), int(h * scale)),
-                          interpolation=cv2.INTER_AREA)

processors/enhancement/huggingface.py

@@ -1,130 +0,0 @@
-"""
-HuggingFace enhancement provider.
-===================================
-Loads any image-to-image model from HuggingFace Hub and applies it as an
-enhancement step before classical binarisation.
-
-Recommended models for architectural drawing restoration:
-  - "microsoft/swin2SR-compressed-SR-x2-64"  (lightweight super-resolution)
-  - "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr" (real-world degradation)
-  - "eugenesiow/srcnn-scale2"                (fast, minimal memory)
-
-Installation
-------------
-    pip install transformers Pillow torch
-
-Usage (via API)
----------------
-    POST /api/process
-    {
-      "enhancement_model": "huggingface",
-      "hf_model_id": "microsoft/swin2SR-compressed-SR-x2-64"
-    }
-
-    Or set a default via env var:
-      HF_ENHANCEMENT_MODEL=microsoft/swin2SR-compressed-SR-x2-64
-"""
-
-from __future__ import annotations
-import logging
-import os
-from typing import Optional
-
-import numpy as np
-
-from .base import EnhancementProvider
-
-logger = logging.getLogger(__name__)
-
-_HF_AVAILABLE = False
-_HF_ERROR: Optional[str] = None
-
-try:
-    from transformers import pipeline as hf_pipeline   # noqa: F401
-    from PIL import Image                               # noqa: F401
-    _HF_AVAILABLE = True
-except ImportError as _e:
-    _HF_ERROR = f"transformers / Pillow not installed: {_e}"
-
-_DEFAULT_HF_MODEL = os.environ.get(
-    "HF_ENHANCEMENT_MODEL",
-    "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr",
-)
-
-
-class HuggingFaceProvider(EnhancementProvider):
-
-    name         = "huggingface"
-    display_name = "HuggingFace (configurable model)"
-    description  = (
-        "Applies any image-to-image HuggingFace model as a pre-processing step. "
-        "Pass 'hf_model_id' in the request to select a model, or set the "
-        "HF_ENHANCEMENT_MODEL env var. Falls back to classical binarisation after "
-        "the model runs. Install: pip install transformers Pillow torch"
-    )
-
-    def __init__(self, model_id: Optional[str] = None) -> None:
-        self._model_id   = model_id or _DEFAULT_HF_MODEL
-        self._pipe       = None  # lazy-loaded
-
-    @property
-    def is_available(self) -> bool:
-        return _HF_AVAILABLE
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        return _HF_ERROR
-
-    def with_model(self, model_id: str) -> "HuggingFaceProvider":
-        """Return a new provider instance using the specified model."""
-        return HuggingFaceProvider(model_id=model_id)
-
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        import cv2
-        from PIL import Image as PILImage
-        from processors.image_enhancer import ImageEnhancer
-
-        pipe = self._get_pipeline()
-
-        # Convert to PIL RGB for the transformer pipeline
-        if len(image.shape) == 2:
-            pil_img = PILImage.fromarray(image).convert("RGB")
-        else:
-            rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-            pil_img = PILImage.fromarray(rgb)
-
-        logger.info("HuggingFace enhancing with model: %s", self._model_id)
-        result = pipe(pil_img)
-
-        # Pipeline output varies by model — handle both PIL and list-of-dict
-        if isinstance(result, list):
-            out_pil = result[0].get("image", pil_img) if isinstance(result[0], dict) else result[0]
-        elif hasattr(result, "images"):
-            out_pil = result.images[0]
-        else:
-            out_pil = result
-
-        out_np = np.array(out_pil.convert("L"))  # grayscale uint8
-
-        # Finish with classical binarisation so output is compatible
-        # with downstream LineExtractor + OCR processors
-        enh      = ImageEnhancer()
-        contrast = enh._enhance_contrast(out_np)
-        binary   = enh._binarize(contrast)
-        return enh._morphological_cleanup(binary)
-
-    def _get_pipeline(self):
-        if self._pipe is not None:
-            return self._pipe
-        from transformers import pipeline as hf_pipeline
-        logger.info("Loading HuggingFace pipeline: %s", self._model_id)
-        self._pipe = hf_pipeline(
-            "image-to-image",
-            model=self._model_id,
-        )
-        return self._pipe
-
-    def info(self) -> dict:
-        base = super().info()
-        base["active_model"] = self._model_id
-        return base

processors/enhancement/huggingface_api.py

@@ -1,140 +0,0 @@
-"""
-HuggingFace Serverless Inference API — Cloud Enhancement Provider
-==================================================================
-Sends the image to a HuggingFace-hosted super-resolution model via their
-free Serverless Inference API.
-
-Setup (free)
-------------
-1. Create a free account at https://huggingface.co
-2. Go to https://huggingface.co/settings/tokens → Create new token
-3. Under "User Permissions" enable "Make calls to Inference Providers"
-4. Add to backend/.env:
-       HF_API_TOKEN=hf_...
-
-Optional — override the default model:
-       HF_API_MODEL=eugenesiow/srcnn-scale2
-
-Default model
--------------
-caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr
-  4x super-resolution trained on real-world degraded images.
-  Works well on scanned/photocopied documents.
-
-Limitations of the free tier
------------------------------
-  ~10 requests/minute on shared infrastructure
-  Max image size: ~4 MB — provider auto-resizes before sending
-  SSL verification is disabled to work through corporate proxies
-"""
-
-from __future__ import annotations
-import io
-import logging
-import os
-import warnings
-from typing import Optional
-
-import numpy as np
-
-from .base import EnhancementProvider
-
-logger = logging.getLogger(__name__)
-
-_DEFAULT_MODEL = os.environ.get(
-    "HF_API_MODEL",
-    "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr",
-)
-
-# New HuggingFace Inference API endpoint (replaces api-inference.huggingface.co)
-_HF_ROUTER_BASE = "https://router.huggingface.co/hf-inference/models"
-
-
-class HuggingFaceAPIProvider(EnhancementProvider):
-
-    name         = "huggingface_api"
-    display_name = "HuggingFace Cloud API (free)"
-    description  = (
-        "Cloud super-resolution via HuggingFace Serverless Inference API. "
-        "Free account required — add HF_API_TOKEN to backend/.env with "
-        "'Make calls to Inference Providers' permission enabled."
-    )
-
-    def __init__(self, model_id: Optional[str] = None) -> None:
-        self._model_id = model_id or _DEFAULT_MODEL
-
-    @property
-    def is_available(self) -> bool:
-        return bool(os.environ.get("HF_API_TOKEN", "").strip())
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        if not self.is_available:
-            return (
-                "HF_API_TOKEN not set. "
-                "Get a free token at https://huggingface.co/settings/tokens "
-                "(enable 'Make calls to Inference Providers') "
-                "and add it to backend/.env"
-            )
-        return None
-
-    def with_model(self, model_id: str) -> "HuggingFaceAPIProvider":
-        return HuggingFaceAPIProvider(model_id=model_id)
-
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        import cv2
-        import requests
-        from PIL import Image as PILImage
-        from processors.image_enhancer import ImageEnhancer
-
-        token = os.environ.get("HF_API_TOKEN", "").strip()
-        url   = f"{_HF_ROUTER_BASE}/{self._model_id}"
-
-        # Convert to BGR then resize for free-tier payload limit (~4 MB)
-        bgr = image if len(image.shape) == 3 else cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
-        h, w = bgr.shape[:2]
-        if max(h, w) > 1500:
-            scale = 1500 / max(h, w)
-            bgr   = cv2.resize(bgr, (int(w * scale), int(h * scale)),
-                               interpolation=cv2.INTER_AREA)
-
-        _, enc = cv2.imencode(".jpg", bgr, [cv2.IMWRITE_JPEG_QUALITY, 85])
-        img_bytes = enc.tobytes()
-
-        logger.info("HF API request: model=%s  input=%dx%d  size=%.1f KB",
-                    self._model_id, bgr.shape[1], bgr.shape[0], len(img_bytes) / 1024)
-
-        # verify=False to work through corporate proxies with self-signed certs
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            resp = requests.post(
-                url,
-                headers={
-                    "Authorization": f"Bearer {token}",
-                    "Content-Type":  "image/jpeg",
-                },
-                data=img_bytes,
-                verify=False,  # noqa: S501 — intentional: corporate proxy uses self-signed cert
-                timeout=120,
-            )
-
-        if resp.status_code != 200:
-            raise RuntimeError(
-                f"HuggingFace API {resp.status_code}: {resp.text[:400]}"
-            )
-
-        out_pil = PILImage.open(io.BytesIO(resp.content)).convert("RGB")
-        out_bgr = cv2.cvtColor(np.array(out_pil), cv2.COLOR_RGB2BGR)
-        logger.info("HF API response: %dx%d", out_bgr.shape[1], out_bgr.shape[0])
-
-        # Binarise so output is compatible with LineExtractor + OCRProcessor
-        enh      = ImageEnhancer()
-        gray     = cv2.cvtColor(out_bgr, cv2.COLOR_BGR2GRAY)
-        contrast = enh._enhance_contrast(gray)
-        binary   = enh._binarize(contrast)
-        return enh._morphological_cleanup(binary)
-
-    def info(self) -> dict:
-        base = super().info()
-        base["active_model"] = self._model_id
-        return base

processors/enhancement/pipeline.py

@@ -1,124 +0,0 @@
-"""
-Enhancement Pipeline
-====================
-Chains multiple providers in sequence. The output of each provider becomes
-the input of the next. Useful for combining AI super-resolution with
-classical binarisation, or for running experimental multi-stage workflows.
-
-Example chains defined here:
-  "ai_then_classical" — Real-ESRGAN upscale → classical binarise
-  "hf_then_classical" — HuggingFace model → classical binarise
-
-Custom chains can be built at runtime:
-    from processors.enhancement.pipeline import EnhancementPipeline
-    from processors.enhancement.registry import registry
-
-    pipe = EnhancementPipeline([
-        registry.get("real_esrgan"),
-        registry.get("classical"),
-    ])
-    result = pipe.enhance(image)
-"""
-
-from __future__ import annotations
-import logging
-from typing import List, Optional
-
-import numpy as np
-
-from .base import EnhancementProvider
-
-logger = logging.getLogger(__name__)
-
-
-class EnhancementPipeline(EnhancementProvider):
-    """
-    Meta-provider that runs a list of providers in sequence.
-    Reports as available only if ALL constituent providers are available.
-    """
-
-    def __init__(
-        self,
-        providers: List[EnhancementProvider],
-        name: str = "pipeline",
-        display_name: str = "Custom Pipeline",
-        description: str = "",
-    ) -> None:
-        if not providers:
-            raise ValueError("EnhancementPipeline requires at least one provider")
-        self._providers   = providers
-        self.name         = name
-        self.display_name = display_name
-        self.description  = description or " → ".join(p.display_name for p in providers)
-
-    @property
-    def is_available(self) -> bool:
-        return all(p.is_available for p in self._providers)
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        reasons = [
-            f"{p.name}: {p.unavailable_reason}"
-            for p in self._providers
-            if not p.is_available
-        ]
-        return "; ".join(reasons) if reasons else None
-
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        result = image
-        for provider in self._providers:
-            logger.info("Pipeline stage: %s", provider.name)
-            result = provider.enhance(result)
-        return result
-
-    def info(self) -> dict:
-        base = super().info()
-        base["stages"] = [p.name for p in self._providers]
-        return base
-
-
-# ---------------------------------------------------------------------------
-# Pre-built named chains registered via the registry
-# ---------------------------------------------------------------------------
-
-def build_preset_pipelines(registry) -> None:
-    """
-    Register composite pipeline presets into an existing registry.
-    Called once after the registry has loaded all individual providers.
-
-    This is intentionally separated so the registry doesn't need to
-    import pipeline — avoiding circular imports.
-    """
-    try:
-        esrgan    = registry._providers.get("real_esrgan")
-        hf        = registry._providers.get("huggingface")
-        classical = registry._providers.get("classical")
-
-        if esrgan and classical:
-            pipe = EnhancementPipeline(
-                providers=[esrgan, classical],
-                name="ai_then_classical",
-                display_name="AI Super-Resolution + Classical Binarise",
-                description=(
-                    "Real-ESRGAN 4× upscale and denoise, followed by classical "
-                    "adaptive threshold binarisation. Best for degraded photographic scans."
-                ),
-            )
-            registry._providers[pipe.name] = pipe
-            logger.info("Pipeline registered: %s", pipe.name)
-
-        if hf and classical:
-            pipe = EnhancementPipeline(
-                providers=[hf, classical],
-                name="hf_then_classical",
-                display_name="HuggingFace Model + Classical Binarise",
-                description=(
-                    "Configurable HuggingFace image model followed by classical "
-                    "binarisation. Set HF_ENHANCEMENT_MODEL env var to choose model."
-                ),
-            )
-            registry._providers[pipe.name] = pipe
-            logger.info("Pipeline registered: %s", pipe.name)
-
-    except Exception as exc:
-        logger.warning("Failed to build preset pipelines: %s", exc)

processors/enhancement/real_esrgan.py

@@ -1,153 +0,0 @@
-"""
-Real-ESRGAN enhancement provider.
-=================================
-Uses Real-ESRGAN (https://github.com/xinntao/Real-ESRGAN) to upscale and
-denoise scanned documents before applying classical binarisation.
-
-This is the recommended provider for degraded photographic scans where
-classical CV loses thin lines and text detail.
-
-Installation
-------------
-    pip install basicsr realesrgan torch torchvision
-
-The model weights (~64 MB) are downloaded automatically on first use to
-~/.cache/realesrgan/.
-
-Why this model
---------------
-Real-ESRGAN was trained on degraded images including scan noise, JPEG
-compression, and blurring. It produces 4× upscaled output with clean edges —
-ideal as a pre-processing step before adaptive thresholding.
-"""
-
-from __future__ import annotations
-import logging
-import os
-from typing import Optional
-
-import numpy as np
-
-from .base import EnhancementProvider
-
-logger = logging.getLogger(__name__)
-
-_REALESRGAN_AVAILABLE = False
-_REALESRGAN_ERROR: Optional[str] = None
-
-try:
-    from basicsr.archs.rrdbnet_arch import RRDBNet                    # noqa: F401
-    from realesrgan import RealESRGANer                                # noqa: F401
-    _REALESRGAN_AVAILABLE = True
-except ImportError as _e:
-    _REALESRGAN_ERROR = f"realesrgan / basicsr not installed: {_e}"
-except Exception as _e:
-    _REALESRGAN_ERROR = f"Unexpected import error: {_e}"
-
-
-class RealESRGANProvider(EnhancementProvider):
-
-    name         = "real_esrgan"
-    display_name = "Real-ESRGAN (AI Super-Resolution)"
-    description  = (
-        "4× AI upscaling + denoising using Real-ESRGAN. Recovers thin lines "
-        "and legible text from heavily degraded photographic scans. "
-        "Requires PyTorch (GPU recommended, CPU supported). "
-        "Install: pip install basicsr realesrgan torch torchvision"
-    )
-
-    # Model variant — x4plus is the best general-purpose option.
-    # Alternatives: RealESRGAN_x4plus_anime_6B (smaller), RealESRGAN_x2plus
-    _MODEL_NAME = "RealESRGAN_x4plus"
-    _SCALE      = 4
-
-    def __init__(self) -> None:
-        self._upsampler = None  # lazy-loaded on first enhance() call
-
-    @property
-    def is_available(self) -> bool:
-        return _REALESRGAN_AVAILABLE
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        return _REALESRGAN_ERROR
-
-    # Deliver at 2× the original rather than 4× — downstream OCR and line
-    # detection run 4× faster with no perceptible quality loss on the binary.
-    _OUTPUT_SCALE = 2
-
-    def enhance(self, image: np.ndarray) -> np.ndarray:
-        import cv2
-        upsampler = self._get_upsampler()
-
-        # Real-ESRGAN expects BGR uint8
-        if len(image.shape) == 2:
-            bgr = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
-        else:
-            bgr = image.copy()
-
-        # 4× AI super-resolution
-        output, _ = upsampler.enhance(bgr, outscale=self._SCALE)
-
-        # Downscale to _OUTPUT_SCALE× to keep OCR/line detection manageable
-        if self._OUTPUT_SCALE < self._SCALE:
-            factor = self._OUTPUT_SCALE / self._SCALE
-            h4, w4 = output.shape[:2]
-            output = cv2.resize(
-                output,
-                (int(w4 * factor), int(h4 * factor)),
-                interpolation=cv2.INTER_AREA,
-            )
-
-        logger.info("Post-AI output: %dx%d", output.shape[1], output.shape[0])
-
-        # Grayscale → contrast → binarise → cleanup
-        # (skip NL-means denoising and background removal — AI output is already clean)
-        from processors.image_enhancer import ImageEnhancer
-        gray = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY)
-        enh  = ImageEnhancer()
-        contrast = enh._enhance_contrast(gray)
-        binary   = enh._binarize(contrast)
-        return enh._morphological_cleanup(binary)
-
-    def _get_upsampler(self):
-        """Lazy-load the model weights on first call."""
-        if self._upsampler is not None:
-            return self._upsampler
-
-        import torch
-        from basicsr.archs.rrdbnet_arch import RRDBNet
-        from realesrgan import RealESRGANer
-
-        model = RRDBNet(
-            num_in_ch=3, num_out_ch=3,
-            num_feat=64, num_block=23, num_grow_ch=32, scale=self._SCALE,
-        )
-        # Weights are downloaded automatically by RealESRGANer on first use
-        weights_url = (
-            "https://github.com/xinntao/Real-ESRGAN/releases/download/"
-            "v0.1.0/RealESRGAN_x4plus.pth"
-        )
-        cache_dir = os.path.expanduser("~/.cache/realesrgan")
-        os.makedirs(cache_dir, exist_ok=True)
-        weights_path = os.path.join(cache_dir, f"{self._MODEL_NAME}.pth")
-
-        if torch.cuda.is_available():
-            device = torch.device("cuda")
-        elif torch.backends.mps.is_available():
-            device = torch.device("mps")
-        else:
-            device = torch.device("cpu")
-        logger.info("Real-ESRGAN loading on %s", device)
-
-        self._upsampler = RealESRGANer(
-            scale=self._SCALE,
-            model_path=weights_path if os.path.exists(weights_path) else weights_url,
-            model=model,
-            tile=512,        # tile processing avoids OOM on large images
-            tile_pad=10,
-            pre_pad=0,
-            half=False,  # fp16 unstable on MPS/CPU; keep fp32
-            device=device,
-        )
-        return self._upsampler

processors/enhancement/registry.py

@@ -1,133 +0,0 @@
-"""
-Enhancement Provider Registry
-==============================
-Auto-discovers all EnhancementProvider subclasses in this package and
-exposes them by name. Handles unavailable providers gracefully.
-
-Usage
------
-    from processors.enhancement.registry import registry
-
-    provider = registry.get("real_esrgan")   # raises if not found/unavailable
-    provider = registry.get_or_default("real_esrgan")  # falls back to classical
-
-    registry.list_all()   # all providers (available + unavailable)
-    registry.list_available()  # only available providers
-"""
-
-from __future__ import annotations
-import importlib
-import logging
-from typing import Dict, List, Optional
-
-from .base import EnhancementProvider
-
-logger = logging.getLogger(__name__)
-
-# Explicit list of provider modules in this package.
-# Add a new module name here when adding a new provider.
-_PROVIDER_MODULES = [
-    "processors.enhancement.classical",
-    "processors.enhancement.groq_guided",        # cloud — needs GROQ_API_KEY
-    "processors.enhancement.huggingface_api",    # cloud — free HF token
-    "processors.enhancement.real_esrgan",        # local — needs GPU + torch
-    "processors.enhancement.huggingface",        # local — needs torch
-]
-
-_DEFAULT_PROVIDER = "classical"
-
-
-class EnhancementRegistry:
-    """Singleton registry of all enhancement providers."""
-
-    def __init__(self) -> None:
-        self._providers: Dict[str, EnhancementProvider] = {}
-        self._load_all()
-
-    def _load_all(self) -> None:
-        for module_path in _PROVIDER_MODULES:
-            mod = self._import_module(module_path)
-            if mod is not None:
-                self._register_providers_from(mod)
-
-    def _import_module(self, module_path: str):
-        try:
-            return importlib.import_module(module_path)
-        except ImportError as exc:
-            logger.debug("Skipping provider module %s: %s", module_path, exc)
-            return None
-
-    def _register_providers_from(self, mod) -> None:
-        for attr_name in dir(mod):
-            cls = getattr(mod, attr_name)
-            if self._is_provider_class(cls):
-                self._instantiate_and_register(cls, attr_name)
-
-    @staticmethod
-    def _is_provider_class(obj) -> bool:
-        return (
-            isinstance(obj, type)
-            and issubclass(obj, EnhancementProvider)
-            and obj is not EnhancementProvider
-            and bool(obj.name)
-        )
-
-    def _instantiate_and_register(self, cls, attr_name: str) -> None:
-        try:
-            instance = cls()
-            self._providers[instance.name] = instance
-            status = "available" if instance.is_available else "unavailable"
-            logger.info("Enhancement provider loaded: %s (%s)", instance.name, status)
-        except Exception as exc:
-            logger.warning("Failed to instantiate provider %s: %s", attr_name, exc)
-
-    # ------------------------------------------------------------------ #
-    # Public API                                                            #
-    # ------------------------------------------------------------------ #
-
-    def get(self, name: str) -> EnhancementProvider:
-        """
-        Return the provider for `name`.
-        Raises ValueError if unknown or unavailable.
-        """
-        provider = self._providers.get(name)
-        if provider is None:
-            available = ", ".join(self._providers.keys())
-            raise ValueError(
-                f"Unknown enhancement model '{name}'. "
-                f"Available: {available}"
-            )
-        if not provider.is_available:
-            raise ValueError(
-                f"Enhancement model '{name}' is not available: "
-                f"{provider.unavailable_reason}"
-            )
-        return provider
-
-    def get_or_default(self, name: Optional[str]) -> EnhancementProvider:
-        """
-        Return the provider for `name`, falling back to the default classical
-        provider if `name` is None, unknown, or unavailable.
-        """
-        if name is None:
-            return self.get(_DEFAULT_PROVIDER)
-        try:
-            return self.get(name)
-        except ValueError as exc:
-            logger.warning("%s — falling back to classical provider", exc)
-            return self.get(_DEFAULT_PROVIDER)
-
-    def list_all(self) -> List[dict]:
-        """Return info dicts for every registered provider."""
-        return [p.info() for p in self._providers.values()]
-
-    def list_available(self) -> List[dict]:
-        """Return info dicts for available providers only."""
-        return [p.info() for p in self._providers.values() if p.is_available]
-
-    def names(self) -> List[str]:
-        return list(self._providers.keys())
-
-
-# Module-level singleton — import this everywhere
-registry = EnhancementRegistry()

processors/ocr_classification.py

@@ -1,82 +0,0 @@
-"""
-OCR Classification
-===================
-Shared text-classification rules used by every OCR provider (Tesseract,
-PaddleOCR, ...) so a phrase like "3,640 x 3,640" or "SCALE" is bucketed the
-same way regardless of which engine recognised it.
-
-Classification buckets:
-  - dimensions  : numeric strings WITH a recognised unit suffix (mm/cm/m/ft/in/'/")
-                  or a "WIDTH x HEIGHT" pair (with or without a unit suffix)
-  - room_names  : multi-character capitalised phrases (title-block keywords excluded)
-  - numbers     : bare numeric tokens (no unit suffix)
-  - labels      : everything else with sufficient confidence
-"""
-
-import re
-from typing import Any, Dict, List
-
-# Patterns for classification.
-# Digits may use comma thousands-separators (e.g. "3,640"), common in
-# architectural dimension callouts.
-_NUM         = r"\d+(?:,\d{3})*(?:\.\d+)?"
-_DIM_RE      = re.compile(rf"^{_NUM}\s*(mm|cm|m|ft|in|'|\")$", re.IGNORECASE)
-_DIM_PAIR_RE = re.compile(
-    rf"^{_NUM}\s*[x×]\s*{_NUM}\s*(mm|cm|m|ft|in|'|\")?$", re.IGNORECASE
-)
-_NUM_RE      = re.compile(rf"^{_NUM}$")
-
-# Title-block / drawing-metadata words that are capitalised (and would
-# otherwise pass the room-name heuristic) but are not room names.
-_TITLE_BLOCK_WORDS = {
-    "scale", "floor", "plan", "level", "section", "elevation", "detail",
-    "site", "drawn", "checked", "approved", "date", "rev", "revision",
-    "sheet", "north", "title", "project", "drawing", "no", "nts", "n.t.s",
-    "scale:", "client", "architect", "job",
-}
-
-
-def classify(elements: List[Dict[str, Any]]) -> Dict[str, List]:
-    classified: Dict[str, List] = {
-        "dimensions": [],
-        "room_names": [],
-        "numbers":    [],
-        "labels":     [],
-    }
-
-    for elem in elements:
-        text = elem["text"]
-
-        if _DIM_PAIR_RE.match(text) or _DIM_RE.match(text):
-            classified["dimensions"].append(elem)
-        elif _NUM_RE.match(text):
-            classified["numbers"].append(elem)
-        elif is_title_block(text):
-            classified["labels"].append(elem)
-        elif len(text) > 2 and text[0].isupper():
-            classified["room_names"].append(elem)
-        else:
-            classified["labels"].append(elem)
-
-    return classified
-
-
-def is_title_block(text: str) -> bool:
-    """True if any word in the phrase is a drawing-metadata keyword."""
-    words = re.findall(r"[A-Za-z.:]+", text.lower())
-    return any(w in _TITLE_BLOCK_WORDS for w in words)
-
-
-def empty_result(reason: str) -> Dict[str, Any]:
-    return {
-        "full_text":     "",
-        "element_count": 0,
-        "elements":      [],
-        "classified":    {
-            "dimensions": [],
-            "room_names": [],
-            "numbers":    [],
-            "labels":     [],
-        },
-        "error": reason,
-    }

processors/paddleocr_processor.py

@@ -1,157 +0,0 @@
-"""
-PaddleOCR Processor
-===================
-Alternative to Tesseract (see ocr_processor.py) backed by PaddleOCR
-(Apache 2.0, https://github.com/PaddlePaddle/PaddleOCR).
-
-Why this is a separate, simpler class rather than another Tesseract config:
-PaddleOCR's detector locates text at the phrase/line level directly, so none
-of ocr_processor.py's word->phrase grouping, gap-splitting, or tick-mark
-height filtering is needed here — those all exist specifically to work
-around Tesseract returning individual words with no semantic grouping.
-Classification (dimensions/room_names/numbers/labels) is shared via
-ocr_classification.py so both engines bucket text identically.
-
-Status: NOT YET BENCHMARKED. Model weights could not be downloaded in the
-sandboxed dev environment this was written in — see CLAUDE.md for why
-(corporate TLS-inspecting proxy whose root CA isn't in Python's default
-trust store). The API calls below are verified against the installed
-paddleocr==3.7.0 / paddlex package source directly (constructor params,
-and the exact result schema: `rec_texts`/`rec_scores`/`rec_boxes`, with
-`rec_boxes[i] == [left, top, right, bottom]` — see
-venv/lib/python3.12/site-packages/paddlex/inference/pipelines/ocr/pipeline.py
-and .../components/common/convert_points_and_boxes.py), but real accuracy
-on this project's sample images has not been measured. Run
-`benchmark/run_benchmark.py` before relying on this over Tesseract.
-"""
-
-from __future__ import annotations
-import logging
-import os
-from typing import Any, Dict, List, Optional
-
-import numpy as np
-
-from .ocr_classification import classify, empty_result
-
-logger = logging.getLogger(__name__)
-
-# PP-OCRv6's detection/recognition models crash under paddlex's default CPU
-# MKLDNN/PIR execution path on this Windows/CPU combo:
-#   NotImplementedError: (Unimplemented) ConvertPirAttribute2RuntimeAttribute
-#   not support [pir::ArrayAttribute<pir::DoubleAttribute>]
-# Neither model is in paddlex's MKLDNN_BLOCKLIST (an upstream gap), so the
-# workaround is disabling MKLDNN-by-default before paddlex's flags module
-# is imported. Must happen before `import paddleocr`, not after.
-os.environ.setdefault("PADDLE_PDX_ENABLE_MKLDNN_BYDEFAULT", "False")
-
-try:
-    from paddleocr import PaddleOCR as _PaddleOCREngine
-    _PADDLEOCR_AVAILABLE = True
-    _PADDLEOCR_ERROR: Optional[str] = None
-except ImportError as _e:
-    _PADDLEOCR_AVAILABLE = False
-    _PADDLEOCR_ERROR = f"paddleocr / paddlepaddle not installed: {_e}"
-
-
-class PaddleOCRProcessor:
-    """
-    Drop-in alternative to OCRProcessor — same extract_text() contract
-    (full_text / element_count / elements / classified), so main.py can
-    swap between engines without any other code changing.
-    """
-
-    def __init__(self, lang: str = "en") -> None:
-        # PaddleOCR loads one recognition model per language (unlike
-        # Tesseract's combined "jpn+eng"); "en" covers this project's
-        # sample images, pass lang="japan" for Japanese-only drawings.
-        self._lang = lang
-        self._engine = None  # lazy-loaded on first use — downloads weights
-
-    @property
-    def is_available(self) -> bool:
-        return _PADDLEOCR_AVAILABLE
-
-    @property
-    def unavailable_reason(self) -> Optional[str]:
-        return _PADDLEOCR_ERROR
-
-    def extract_text(self, image: np.ndarray) -> Dict[str, Any]:
-        """
-        Parameters
-        ----------
-        image : enhanced binary or grayscale (or BGR) image
-
-        Returns
-        -------
-        Same schema as OCRProcessor.extract_text() — see that module's
-        docstring.
-        """
-        if not _PADDLEOCR_AVAILABLE:
-            logger.warning("paddleocr not installed – OCR skipped")
-            return empty_result("paddleocr not installed")
-
-        try:
-            engine = self._get_engine()
-            results = engine.predict(image)
-        except Exception as exc:
-            logger.exception("PaddleOCR error")
-            return empty_result(str(exc))
-
-        if not results:
-            return empty_result("no text regions detected")
-
-        result = results[0]
-        elements = self._to_elements(
-            result.get("rec_texts", []),
-            result.get("rec_scores", []),
-            result.get("rec_boxes", []),
-        )
-        classified = classify(elements)
-
-        return {
-            "full_text":     "\n".join(e["text"] for e in elements),
-            "element_count": len(elements),
-            "elements":      elements,
-            "classified":    classified,
-        }
-
-    # ------------------------------------------------------------------ #
-    # Private helpers                                                       #
-    # ------------------------------------------------------------------ #
-
-    def _get_engine(self):
-        if self._engine is not None:
-            return self._engine
-        logger.info("Loading PaddleOCR engine (lang=%s) — downloads weights on first use", self._lang)
-        self._engine = _PaddleOCREngine(
-            lang=self._lang,
-            # Our own enhancement pipeline already deskews/upscales the
-            # image, so skip PaddleOCR's own document-orientation
-            # classification and unwarping sub-pipelines — one less model
-            # to download and one less inference pass per image.
-            use_doc_orientation_classify=False,
-            use_doc_unwarping=False,
-            use_textline_orientation=False,
-        )
-        return self._engine
-
-    @staticmethod
-    def _to_elements(
-        texts: List[str], scores: List[float], boxes: Any
-    ) -> List[Dict[str, Any]]:
-        elements: List[Dict[str, Any]] = []
-        for text, score, box in zip(texts, scores, boxes):
-            text = str(text).strip()
-            if not text:
-                continue
-            x1, y1, x2, y2 = (float(v) for v in box)
-            elements.append({
-                "text":       text,
-                "confidence": round(float(score) * 100),  # match Tesseract's 0-100 scale
-                "x":          int(round(x1)),
-                "y":          int(round(y1)),
-                "width":      int(round(x2 - x1)),
-                "height":     int(round(y2 - y1)),
-            })
-        return elements

requirements.cloud.txt

@@ -1,19 +0,0 @@
-# Cloud deployment — excludes torch/Real-ESRGAN (too large for serverless)
-# Real-ESRGAN is available when running locally only.
-fastapi==0.115.0
-uvicorn[standard]==0.30.6
-python-multipart==0.0.9
-opencv-python-headless==4.10.0.84
-numpy>=1.26.4
-Pillow==10.4.0
-pytesseract==0.3.13
-anthropic==0.34.2
-openai>=1.0.0
-google-genai>=1.0.0
-groq>=0.9.0
-python-dotenv==1.0.1
-svgwrite==1.4.3
-scipy==1.13.1
-huggingface_hub>=1.21.0
-requests>=2.31.0
-scikit-image>=0.21.0

tests/conftest.py

@@ -1,53 +0,0 @@
-"""
-Shared pytest fixtures for backend tests.
-"""
-
-import io
-import sys
-import os
-
-import cv2
-import numpy as np
-import pytest
-
-# Make sure the backend package is importable
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-
-@pytest.fixture
-def synthetic_drawing() -> np.ndarray:
-    """800×600 grayscale floor plan with walls, interior lines and text."""
-    img = np.ones((600, 800), dtype=np.uint8) * 240
-    cv2.rectangle(img, (50, 50), (750, 550), 0, 3)
-    cv2.line(img, (400, 50), (400, 350), 0, 2)
-    cv2.line(img, (50, 300), (400, 300), 0, 2)
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    cv2.putText(img, "3640", (180, 285), font, 1.2, 0, 2)
-    cv2.putText(img, "Living Room", (100, 430), font, 1.0, 0, 2)
-    cv2.putText(img, "Bedroom", (470, 220), font, 1.0, 0, 2)
-    return img
-
-
-@pytest.fixture
-def synthetic_drawing_bgr(synthetic_drawing) -> np.ndarray:
-    return cv2.cvtColor(synthetic_drawing, cv2.COLOR_GRAY2BGR)
-
-
-@pytest.fixture
-def drawing_bytes(synthetic_drawing) -> bytes:
-    """PNG-encoded bytes of the synthetic drawing."""
-    _, buf = cv2.imencode(".png", synthetic_drawing)
-    return buf.tobytes()
-
-
-@pytest.fixture
-def drawing_file(drawing_bytes):
-    """File-like object for use with FastAPI TestClient."""
-    return ("drawing.png", io.BytesIO(drawing_bytes), "image/png")
-
-
-@pytest.fixture
-def client():
-    from fastapi.testclient import TestClient
-    from main import app
-    return TestClient(app)

tests/test_api.py

@@ -1,122 +0,0 @@
-"""
-Integration tests for the FastAPI endpoints using TestClient.
-"""
-
-import io
-import pytest
-from fastapi.testclient import TestClient
-
-
-class TestHealthEndpoint:
-    def test_returns_200(self, client):
-        resp = client.get("/health")
-        assert resp.status_code == 200
-
-    def test_status_is_healthy(self, client):
-        data = client.get("/health").json()
-        assert data["status"] == "healthy"
-
-    def test_all_processors_listed(self, client):
-        data = client.get("/health").json()
-        processors = data["processors"]
-        for name in ("image_enhancer", "line_extractor", "ocr_processor", "svg_generator"):
-            assert name in processors
-
-
-class TestInfoEndpoint:
-    def test_returns_200(self, client):
-        assert client.get("/api/info").status_code == 200
-
-    def test_returns_processing_options(self, client):
-        data = client.get("/api/info").json()
-        assert "processing_options" in data
-
-    def test_all_options_listed(self, client):
-        opts = client.get("/api/info").json()["processing_options"]
-        for key in ("enhance", "extract_lines", "run_ocr", "generate_svg", "run_ai"):
-            assert key in opts
-
-
-class TestProcessEndpoint:
-    def test_returns_200_with_valid_image(self, client, drawing_file):
-        resp = client.post("/api/process", files={"file": drawing_file})
-        assert resp.status_code == 200
-
-    def test_response_has_required_fields(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        for field in ("filename", "original_size", "processing_steps", "processing_time_s"):
-            assert field in data
-
-    def test_enhance_step_runs_by_default(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        assert "image_enhancement" in data["processing_steps"]
-        assert "enhanced_image" in data
-
-    def test_line_extraction_step_runs_by_default(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        assert "line_extraction" in data["processing_steps"]
-        assert "detected_lines" in data
-
-    def test_ocr_step_runs_by_default(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        assert "ocr" in data["processing_steps"]
-        assert "ocr_results" in data
-
-    def test_svg_not_generated_by_default(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        assert "svg_generation" not in data["processing_steps"]
-
-    def test_svg_generated_when_requested(self, client, drawing_file):
-        resp = client.post(
-            "/api/process",
-            files={"file": drawing_file},
-            data={"generate_svg": "true"},
-        )
-        data = resp.json()
-        assert "svg_generation" in data["processing_steps"]
-        assert "svg_output" in data
-
-    def test_enhance_only_skips_other_steps(self, client, drawing_file):
-        resp = client.post(
-            "/api/process",
-            files={"file": drawing_file},
-            data={"enhance": "true", "extract_lines": "false", "run_ocr": "false"},
-        )
-        data = resp.json()
-        assert "image_enhancement" in data["processing_steps"]
-        assert "line_extraction" not in data["processing_steps"]
-        assert "ocr" not in data["processing_steps"]
-
-    def test_detected_lines_is_integer(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        assert isinstance(data.get("detected_lines"), int)
-
-    def test_processing_time_is_float(self, client, drawing_file):
-        data = client.post("/api/process", files={"file": drawing_file}).json()
-        assert isinstance(data["processing_time_s"], float)
-        assert data["processing_time_s"] > 0
-
-    def test_invalid_file_returns_400(self, client):
-        fake_file = ("bad.png", io.BytesIO(b"not an image"), "image/png")
-        resp = client.post("/api/process", files={"file": fake_file})
-        assert resp.status_code == 400
-
-    def test_original_size_matches_image(self, client, drawing_bytes):
-        # Our synthetic image is 800×600
-        file = ("drawing.png", io.BytesIO(drawing_bytes), "image/png")
-        data = client.post("/api/process", files={"file": file}).json()
-        size = data["original_size"]
-        assert size["width"] == 800
-        assert size["height"] == 600
-
-
-class TestAnalyzeEndpoint:
-    def test_returns_501_without_api_key(self, client, drawing_file, monkeypatch):
-        monkeypatch.setenv("ANTHROPIC_API_KEY", "")
-        resp = client.post("/api/analyze", files={"file": drawing_file})
-        assert resp.status_code == 501
-
-    def test_error_message_mentions_api_key(self, client, drawing_file, monkeypatch):
-        monkeypatch.setenv("ANTHROPIC_API_KEY", "")
-        data = client.post("/api/analyze", files={"file": drawing_file}).json()
-        assert "ANTHROPIC_API_KEY" in data["detail"]

tests/test_image_enhancer.py

@@ -1,52 +0,0 @@
-"""
-Unit tests for ImageEnhancer.
-"""
-
-import cv2
-import numpy as np
-import pytest
-
-from processors.image_enhancer import ImageEnhancer
-
-
-@pytest.fixture
-def enhancer():
-    return ImageEnhancer()
-
-
-class TestEnhance:
-    def test_output_same_spatial_size(self, enhancer, synthetic_drawing):
-        result = enhancer.enhance(synthetic_drawing)
-        assert result.shape[:2] == synthetic_drawing.shape[:2]
-
-    def test_output_is_binary(self, enhancer, synthetic_drawing):
-        result = enhancer.enhance(synthetic_drawing)
-        unique = set(np.unique(result).tolist())
-        assert unique.issubset({0, 255}), f"Expected only 0/255, got {unique}"
-
-    def test_accepts_grayscale_input(self, enhancer, synthetic_drawing):
-        assert len(synthetic_drawing.shape) == 2
-        result = enhancer.enhance(synthetic_drawing)
-        assert result is not None
-
-    def test_accepts_bgr_input(self, enhancer, synthetic_drawing_bgr):
-        assert synthetic_drawing_bgr.shape[2] == 3
-        result = enhancer.enhance(synthetic_drawing_bgr)
-        assert result is not None
-        assert len(result.shape) == 2  # always returns grayscale
-
-    def test_output_dtype_is_uint8(self, enhancer, synthetic_drawing):
-        result = enhancer.enhance(synthetic_drawing)
-        assert result.dtype == np.uint8
-
-    def test_enhancer_reduces_noise(self, enhancer):
-        noisy = np.random.randint(0, 256, (200, 200), dtype=np.uint8)
-        result = enhancer.enhance(noisy)
-        # Binary output should have far fewer unique grey levels than random noise
-        assert len(np.unique(result)) <= 2
-
-    def test_enhance_grayscale_method_not_binary(self, enhancer, synthetic_drawing):
-        result = enhancer.enhance_grayscale(synthetic_drawing)
-        unique_values = np.unique(result)
-        # Grayscale output should have more than 2 grey levels
-        assert len(unique_values) > 2

tests/test_line_extractor.py

@@ -1,81 +0,0 @@
-"""
-Unit tests for LineExtractor.
-"""
-
-import cv2
-import numpy as np
-import pytest
-
-from processors.line_extractor import LineExtractor
-
-
-@pytest.fixture
-def extractor():
-    return LineExtractor()
-
-
-@pytest.fixture
-def clear_line_drawing():
-    """White canvas with a few crisp black lines — guaranteed to be detected."""
-    img = np.ones((400, 600), dtype=np.uint8) * 255
-    cv2.line(img, (50, 200), (550, 200), 0, 3)   # horizontal
-    cv2.line(img, (300, 50), (300, 350), 0, 3)   # vertical
-    cv2.line(img, (50, 50), (550, 350), 0, 3)    # diagonal
-    return img
-
-
-class TestExtract:
-    def test_returns_tuple(self, extractor, synthetic_drawing):
-        result = extractor.extract(synthetic_drawing)
-        assert isinstance(result, tuple) and len(result) == 2
-
-    def test_visualisation_is_bgr(self, extractor, clear_line_drawing):
-        vis, _ = extractor.extract(clear_line_drawing)
-        assert len(vis.shape) == 3 and vis.shape[2] == 3
-
-    def test_visualisation_same_size(self, extractor, synthetic_drawing):
-        vis, _ = extractor.extract(synthetic_drawing)
-        assert vis.shape[:2] == synthetic_drawing.shape[:2]
-
-    def test_detects_lines_in_drawing(self, extractor, clear_line_drawing):
-        _, lines = extractor.extract(clear_line_drawing, hough_threshold=30)
-        assert len(lines) >= 3, f"Expected ≥3 lines, got {len(lines)}"
-
-    def test_blank_image_returns_no_lines(self, extractor):
-        blank = np.ones((300, 400), dtype=np.uint8) * 255
-        _, lines = extractor.extract(blank)
-        assert lines == []
-
-    def test_line_dict_has_required_keys(self, extractor, clear_line_drawing):
-        _, lines = extractor.extract(clear_line_drawing, hough_threshold=30)
-        assert lines, "No lines detected — cannot check keys"
-        for line in lines:
-            for key in ("x1", "y1", "x2", "y2", "angle", "length"):
-                assert key in line, f"Missing key '{key}' in line dict"
-
-    def test_line_length_is_positive(self, extractor, clear_line_drawing):
-        _, lines = extractor.extract(clear_line_drawing, hough_threshold=30)
-        for line in lines:
-            assert line["length"] > 0
-
-    def test_accepts_bgr_input(self, extractor, synthetic_drawing_bgr):
-        vis, lines = extractor.extract(synthetic_drawing_bgr)
-        assert vis is not None
-
-
-class TestClassifyAngle:
-    def test_horizontal(self, extractor):
-        assert extractor._classify_angle(0) == "horizontal"
-        assert extractor._classify_angle(10) == "horizontal"
-        assert extractor._classify_angle(-10) == "horizontal"
-        assert extractor._classify_angle(170) == "horizontal"
-
-    def test_vertical(self, extractor):
-        assert extractor._classify_angle(90) == "vertical"
-        assert extractor._classify_angle(80) == "vertical"
-        assert extractor._classify_angle(100) == "vertical"
-
-    def test_diagonal(self, extractor):
-        assert extractor._classify_angle(45) == "diagonal"
-        assert extractor._classify_angle(-45) == "diagonal"
-        assert extractor._classify_angle(135) == "diagonal"

tests/test_ocr_processor.py

@@ -1,106 +0,0 @@
-"""
-Unit tests for OCRProcessor.
-"""
-
-import cv2
-import numpy as np
-import pytest
-
-from processors.ocr_processor import OCRProcessor
-
-
-@pytest.fixture
-def processor():
-    return OCRProcessor()
-
-
-@pytest.fixture
-def text_drawing():
-    """Large, clear image with well-spaced text for reliable OCR."""
-    img = np.ones((900, 1200), dtype=np.uint8) * 255
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    cv2.putText(img, "Living Room", (100, 200), font, 2.0, 0, 4)
-    cv2.putText(img, "3640",        (100, 450), font, 2.0, 0, 4)
-    cv2.putText(img, "Bedroom",     (100, 700), font, 2.0, 0, 4)
-    return img
-
-
-class TestExtractText:
-    def test_returns_dict_with_expected_keys(self, processor, synthetic_drawing):
-        result = processor.extract_text(synthetic_drawing)
-        for key in ("full_text", "element_count", "elements", "classified"):
-            assert key in result, f"Missing key: {key}"
-
-    def test_classified_has_correct_categories(self, processor, synthetic_drawing):
-        result = processor.extract_text(synthetic_drawing)
-        for cat in ("dimensions", "room_names", "numbers", "labels"):
-            assert cat in result["classified"]
-
-    def test_element_count_matches_elements_list(self, processor, text_drawing):
-        result = processor.extract_text(text_drawing)
-        assert result["element_count"] == len(result["elements"])
-
-    def test_each_element_has_required_fields(self, processor, text_drawing):
-        result = processor.extract_text(text_drawing)
-        for el in result["elements"]:
-            for field in ("text", "confidence", "x", "y", "width", "height"):
-                assert field in el, f"Missing field '{field}' in element"
-
-    def test_confidence_values_in_range(self, processor, text_drawing):
-        result = processor.extract_text(text_drawing)
-        for el in result["elements"]:
-            assert 0 <= el["confidence"] <= 100
-
-    def test_detects_dimension_number(self, processor, text_drawing):
-        result = processor.extract_text(text_drawing)
-        all_texts = [el["text"] for el in result["elements"]]
-        assert any("3640" in t for t in all_texts), \
-            f"Expected '3640' in OCR output, got: {all_texts}"
-
-    def test_classifies_bare_number_as_number(self, processor, text_drawing):
-        result = processor.extract_text(text_drawing)
-        num_texts = [el["text"] for el in result["classified"]["numbers"]]
-        assert "3640" in num_texts, \
-            f"'3640' (no unit) should be in numbers, got: {num_texts}"
-
-    def test_blank_image_returns_empty(self, processor):
-        blank = np.ones((400, 600), dtype=np.uint8) * 255
-        result = processor.extract_text(blank)
-        assert result["element_count"] == 0
-        assert result["elements"] == []
-
-    def test_full_text_is_string(self, processor, synthetic_drawing):
-        result = processor.extract_text(synthetic_drawing)
-        assert isinstance(result["full_text"], str)
-
-
-class TestClassify:
-    def test_dimension_pattern(self, processor):
-        elements = [{"text": "3640mm", "confidence": 90, "x": 0, "y": 0, "width": 50, "height": 20}]
-        classified = processor._classify(elements)
-        assert any(e["text"] == "3640mm" for e in classified["dimensions"])
-
-    def test_room_name_pattern(self, processor):
-        elements = [{"text": "Kitchen", "confidence": 90, "x": 0, "y": 0, "width": 80, "height": 20}]
-        classified = processor._classify(elements)
-        assert any(e["text"] == "Kitchen" for e in classified["room_names"])
-
-    def test_number_pattern(self, processor):
-        elements = [{"text": "42", "confidence": 90, "x": 0, "y": 0, "width": 30, "height": 20}]
-        classified = processor._classify(elements)
-        assert any(e["text"] == "42" for e in classified["numbers"])
-
-    def test_dimension_with_unit(self, processor):
-        elements = [{"text": "3640mm", "confidence": 90, "x": 0, "y": 0, "width": 60, "height": 20}]
-        classified = processor._classify(elements)
-        assert any(e["text"] == "3640mm" for e in classified["dimensions"])
-
-    def test_bare_number_not_in_dimensions(self, processor):
-        elements = [{"text": "100", "confidence": 90, "x": 0, "y": 0, "width": 40, "height": 20}]
-        classified = processor._classify(elements)
-        assert not any(e["text"] == "100" for e in classified["dimensions"])
-
-    def test_label_catchall(self, processor):
-        elements = [{"text": "note", "confidence": 90, "x": 0, "y": 0, "width": 40, "height": 20}]
-        classified = processor._classify(elements)
-        assert any(e["text"] == "note" for e in classified["labels"])

tests/test_svg_generator.py

@@ -1,75 +0,0 @@
-"""
-Unit tests for SVGGenerator.
-"""
-
-import pytest
-
-from processors.svg_generator import SVGGenerator
-
-
-@pytest.fixture
-def generator():
-    return SVGGenerator()
-
-
-@pytest.fixture
-def sample_lines():
-    return [
-        {"x1": 10, "y1": 10, "x2": 200, "y2": 10,  "angle": 0.0,  "length": 190.0},
-        {"x1": 10, "y1": 10, "x2": 10,  "y2": 200, "angle": 90.0, "length": 190.0},
-        {"x1": 10, "y1": 10, "x2": 200, "y2": 200, "angle": 45.0, "length": 268.7},
-    ]
-
-
-@pytest.fixture
-def sample_ocr():
-    return {
-        "elements": [
-            {"text": "Living Room", "confidence": 85, "x": 50, "y": 100, "width": 120, "height": 20},
-            {"text": "3640",        "confidence": 90, "x": 50, "y": 150, "width":  60, "height": 20},
-        ]
-    }
-
-
-class TestGenerate:
-    def test_returns_string(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert isinstance(result, str)
-
-    def test_output_is_valid_svg(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert result.strip().startswith("<svg") or "<svg" in result
-
-    def test_svg_contains_correct_dimensions(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert "800" in result
-        assert "600" in result
-
-    def test_svg_contains_line_elements(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert "<line" in result
-
-    def test_wall_lines_group_present(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert "wall-lines" in result
-
-    def test_detail_lines_group_present(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert "detail-lines" in result
-
-    def test_svg_includes_ocr_text(self, generator, sample_lines, sample_ocr):
-        result = generator.generate(sample_lines, 800, 600, ocr_results=sample_ocr)
-        assert "Living Room" in result
-        assert "text-labels" in result
-
-    def test_svg_without_ocr_has_no_text_labels(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600, ocr_results=None)
-        assert "text-labels" not in result
-
-    def test_empty_lines_produces_svg(self, generator):
-        result = generator.generate([], 400, 300)
-        assert "<svg" in result
-
-    def test_white_background_rect_present(self, generator, sample_lines):
-        result = generator.generate(sample_lines, 800, 600)
-        assert 'fill="white"' in result