dl_adapters from dexined and superpoint

README.md

@@ -21,7 +21,7 @@ FeatureLab now exposes a production-friendly layout: FastAPI serves the detector
 ```
 FastAPI (/v1/detect/*)  <-- shared numpy/CV runtime -->  Gradio UI (/)
 ```
-- **Classical path**: Canny, Harris, Probabilistic Hough, contour-based ellipse fitting.
+- **Classical path**: Canny, Harris, Probabilistic Hough, Line Segment Detector (LSD), contour-based ellipse fitting.
 - **Deep path**: ONNX models (HED, SuperPoint, SOLD2, etc.) auto-loaded from `./models`.
 - **Responses**: base64 PNG overlays, rich feature metadata, timings, model info.
 
@@ -38,7 +38,12 @@ python app.py  # FastAPI + Gradio on http://localhost:7860
   ```json
   {
     "image": "<base64 png/jpeg>",
-    "params": { "canny_low": 50, "canny_high": 150, "...": "..." },
+    "params": {
+      "canny_low": 50,
+      "canny_high": 150,
+      "line_detector": "lsd",
+      "...": "..."
+    },
     "mode": "classical|dl|both",
     "compare": false,
     "dl_model": "hed.onnx"
@@ -56,6 +61,7 @@ python app.py  # FastAPI + Gradio on http://localhost:7860
     "models": { "classical": {...}, "dl": {...} }
   }
   ```
+- Classical line detector toggle: set `params.line_detector` to `"lsd"` to run OpenCV's Line Segment Detector instead of Probabilistic Hough.
 - Multipart uploads: `POST /v1/detect/<detector>/upload` with `file`, optional `params` (JSON string), `mode`, `compare`, `dl_model`.
 
 ## WebSocket API

backend/py/app/api/v1/detect.py

@@ -15,7 +15,7 @@ router = APIRouter(prefix="/v1/detect", tags=["detection"])
 DETECTOR_KEYS: Dict[str, str] = {
     "edges": "Edges (Canny)",
     "corners": "Corners (Harris)",
-    "lines": "Lines (Hough)",
+    "lines": "Lines (Hough/LSD)",
     "ellipses": "Ellipses (Contours + fitEllipse)",
 }
 
@@ -259,4 +259,3 @@ async def detection_stream(websocket: WebSocket):
             await websocket.send_json(_format_result(result, runtime_mode).dict())
     except WebSocketDisconnect:
         return
-

backend/py/app/gradio_demo/ui.py

@@ -13,10 +13,17 @@ DESC = (
 )
 
 
+LINE_METHOD_LABELS = {
+    "Hough (Probabilistic)": "hough",
+    "LSD (Line Segment Detector)": "lsd",
+}
+
+
 def _gradio_runtime(
     image: Optional[np.ndarray],
     detector: str,
     compare: bool,
+    line_method: str,
     dl_choice: str,
     canny_low: int,
     canny_high: int,
@@ -45,6 +52,8 @@ def _gradio_runtime(
         "max_ellipses": int(max_ellipses),
     }
 
+    params["line_detector"] = LINE_METHOD_LABELS.get(line_method, "hough")
+
     mode = "both" if compare else "classical"
     dl_model = dl_choice.strip() or None
     result = run_detection(image, detector, params=params, mode=mode, dl_choice=dl_model)
@@ -62,6 +71,11 @@ def _gradio_runtime(
 
 def build_demo() -> gr.Blocks:
     defaults = dict(DEFAULT_PARAMS)
+    line_default_key = defaults.get("line_detector", "hough")
+    line_default_label = next(
+        (label for label, key in LINE_METHOD_LABELS.items() if key == line_default_key),
+        "Hough (Probabilistic)",
+    )
 
     with gr.Blocks(title=TITLE) as demo:
         gr.Markdown(f"# {TITLE}\n{DESC}")
@@ -77,7 +91,7 @@ def build_demo() -> gr.Blocks:
                     [
                         "Edges (Canny)",
                         "Corners (Harris)",
-                        "Lines (Hough)",
+                        "Lines (Hough/LSD)",
                         "Ellipses (Contours + fitEllipse)",
                     ],
                     value="Edges (Canny)",
@@ -88,6 +102,12 @@ def build_demo() -> gr.Blocks:
                 dl_choice = gr.Textbox(value="", label="DL model filename (optional, in ./models)")
 
                 with gr.Accordion("Parameters", open=False):
+                    line_method = gr.Radio(
+                        choices=list(LINE_METHOD_LABELS.keys()),
+                        value=line_default_label,
+                        label="Line detector (classical)",
+                        info="Choose LSD to enable OpenCV's Line Segment Detector instead of Probabilistic Hough.",
+                    )
                     canny_low = gr.Slider(0, 255, value=defaults["canny_low"], step=1, label="Canny low threshold")
                     canny_high = gr.Slider(0, 255, value=defaults["canny_high"], step=1, label="Canny high threshold")
                     harris_k = gr.Slider(0.02, 0.15, value=defaults["harris_k"], step=0.005, label="Harris k")
@@ -128,6 +148,7 @@ def build_demo() -> gr.Blocks:
                 in_img,
                 detector,
                 compare,
+                line_method,
                 dl_choice,
                 canny_low,
                 canny_high,
@@ -150,6 +171,7 @@ def build_demo() -> gr.Blocks:
                 in_img,
                 detector,
                 compare,
+                line_method,
                 dl_choice,
                 canny_low,
                 canny_high,

backend/py/app/inference/classical.py

@@ -19,6 +19,7 @@ def detect_classical(
     hough_max_gap: int,
     ellipse_min_area: int,
     max_ellipses: int,
+    line_detector: str = "hough",
 ) -> Tuple[np.ndarray, Dict[str, Any]]:
     bgr = to_bgr(image)
     gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
@@ -41,17 +42,42 @@ def detect_classical(
             cv2.circle(overlay, (int(x), int(y)), 2, (0, 255, 255), -1)
         meta["num_corners"] = int(len(corners))
 
-    elif detector == "Lines (Hough)":
-        edges = cv2.Canny(gray, canny_low, canny_high, L2gradient=True)
-        lines = cv2.HoughLinesP(edges, rho=1, theta=np.pi / 180, threshold=hough_thresh,
-                                minLineLength=hough_min_len, maxLineGap=hough_max_gap)
-        n = 0
-        if lines is not None:
-            for l in lines:
-                x1, y1, x2, y2 = l[0]
-                cv2.line(overlay, (x1, y1), (x2, y2), (255, 128, 0), 2)
-            n = len(lines)
-        meta["num_lines"] = int(n)
+    elif detector == "Lines (Hough/LSD)":
+        method = (line_detector or "hough").lower()
+        if method not in {"hough", "lsd"}:
+            method = "hough"
+        meta["line_detector"] = method
+
+        if method == "lsd":
+            if not hasattr(cv2, "createLineSegmentDetector"):
+                meta["error"] = "OpenCV build lacks Line Segment Detector (LSD) support."
+                return to_rgb(overlay), meta
+            lsd = cv2.createLineSegmentDetector(refine=cv2.LSD_REFINE_ADV)
+            lines = lsd.detect(gray)[0]
+            n = 0
+            if lines is not None:
+                for seg in lines:
+                    x1, y1, x2, y2 = map(int, np.round(seg[0]))
+                    cv2.line(overlay, (x1, y1), (x2, y2), (0, 255, 255), 2)
+                n = len(lines)
+            meta["num_lines"] = int(n)
+        else:
+            edges = cv2.Canny(gray, canny_low, canny_high, L2gradient=True)
+            lines = cv2.HoughLinesP(
+                edges,
+                rho=1,
+                theta=np.pi / 180,
+                threshold=hough_thresh,
+                minLineLength=hough_min_len,
+                maxLineGap=hough_max_gap,
+            )
+            n = 0
+            if lines is not None:
+                for l in lines:
+                    x1, y1, x2, y2 = l[0]
+                    cv2.line(overlay, (x1, y1), (x2, y2), (255, 128, 0), 2)
+                n = len(lines)
+            meta["num_lines"] = int(n)
 
     elif detector == "Ellipses (Contours + fitEllipse)":
         edges = cv2.Canny(gray, canny_low, canny_high, L2gradient=True)
@@ -84,4 +110,3 @@ def detect_classical(
         meta["error"] = f"Unknown detector: {detector}"
 
     return to_rgb(overlay), meta
-

backend/py/app/inference/dl.py

@@ -1,10 +1,12 @@
 import os
+import sys
 from typing import Any, Dict, Optional, Tuple
 
 import cv2
 import numpy as np
 
 from .common import to_bgr, to_rgb
+from .dl_adapters import get_adapter
 
 try:
     import onnxruntime as ort  # type: ignore
@@ -17,7 +19,7 @@ MODEL_DIR = os.path.join(os.getcwd(), "models")
 DL_MODELS = {
     "Edges (Canny)": ["hed.onnx", "dexined.onnx"],
     "Corners (Harris)": ["superpoint.onnx"],
-    "Lines (Hough)": ["sold2.onnx", "hawp.onnx"],
+    "Lines (Hough/LSD)": ["sold2.onnx", "hawp.onnx"],
     "Ellipses (Contours + fitEllipse)": ["ellipse_head.onnx"],
 }
 
@@ -36,7 +38,7 @@ def _find_model(detector: str, choice_name: Optional[str]) -> Optional[str]:
 def _load_session(path: str):
     if ort is None:
         raise RuntimeError("onnxruntime not installed. `pip install onnxruntime`.")
-    providers = ["CoreMLExecutionProvider", "CPUExecutionProvider"] if "darwin" in os.sys.platform else ["CPUExecutionProvider"]
+    providers = ["CoreMLExecutionProvider", "CPUExecutionProvider"] if "darwin" in sys.platform else ["CPUExecutionProvider"]
     try:
         return ort.InferenceSession(path, providers=providers)
     except Exception as e:
@@ -50,7 +52,6 @@ def detect_dl(
 ) -> Tuple[np.ndarray, Dict[str, Any]]:
     bgr = to_bgr(image)
     rgb = to_rgb(bgr)
-    h, w = rgb.shape[:2]
     meta: Dict[str, Any] = {"path": "dl"}
 
     model_path = _find_model(detector, model_choice)
@@ -69,103 +70,25 @@ def detect_dl(
         meta["error"] = str(e)
         return rgb, meta
 
-    input_name = sess.get_inputs()[0].name
-    in_shape = sess.get_inputs()[0].shape  # e.g., [1,3,H,W] or dynamic
-    target_h, target_w = None, None
-    if len(in_shape) == 4:
-        target_h = in_shape[2] if isinstance(in_shape[2], int) and in_shape[2] > 0 else 512
-        target_w = in_shape[3] if isinstance(in_shape[3], int) and in_shape[3] > 0 else 512
-    else:
-        target_h, target_w = 512, 512
-
-    img_resized = cv2.resize(rgb, (target_w, target_h), interpolation=cv2.INTER_AREA)
-    x = img_resized.astype(np.float32) / 255.0
-    if x.ndim == 2:
-        x = np.expand_dims(x, axis=-1)
-    if x.shape[2] == 1:
-        x = np.repeat(x, 3, axis=2)
-    x = np.transpose(x, (2, 0, 1))[None, ...]  # NCHW
+    # Dispatch to model-specific adapter
+    adapter = get_adapter(model_path, detector)
+    try:
+        feed, ctx = adapter.preprocess(rgb, sess)
+    except Exception as e:
+        meta["error"] = f"Preprocess failed: {e}"
+        return rgb, meta
 
     try:
-        outputs = sess.run(None, {input_name: x})
+        outputs = sess.run(None, feed)
     except Exception as e:
         meta["error"] = f"ONNX inference failed: {e}"
         return rgb, meta
 
-    overlay = rgb.copy()
-    if detector == "Edges (Canny)":
-        pred = outputs[0]
-        if pred.ndim == 4:
-            prob = pred[0, 0]
-            prob = (prob - prob.min()) / (prob.max() - prob.min() + 1e-8)
-            edges = (prob > 0.5).astype(np.uint8) * 255
-            edges = cv2.resize(edges, (w, h), interpolation=cv2.INTER_NEAREST)
-            bgr2 = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
-            bgr2[edges > 0] = (0, 255, 0)
-            overlay = cv2.cvtColor(bgr2, cv2.COLOR_BGR2RGB)
-            meta["edge_prob_mean"] = float(prob.mean())
-        else:
-            meta["warning"] = "Unexpected model output shape for edges."
-
-    elif detector == "Corners (Harris)":
-        pred = outputs[0]
-        if pred.ndim == 4:
-            heat = pred[0, 0]
-            heat = (heat - heat.min()) / (heat.max() - heat.min() + 1e-8)
-            heat = cv2.resize(heat, (w, h), interpolation=cv2.INTER_CUBIC)
-            ys, xs = np.where(heat > 0.5)
-            overlay = rgb.copy()
-            for (y, x_) in zip(ys.tolist(), xs.tolist()):
-                cv2.circle(overlay, (int(x_), int(y)), 2, (0, 255, 255), -1)
-            meta["num_corners"] = int(len(xs))
-        else:
-            meta["warning"] = "Unexpected model output shape for corners."
-
-    elif detector == "Lines (Hough)":
-        pred = outputs[0]
-        if pred.ndim == 4:
-            heat = pred[0, 0]
-            heat = (heat - heat.min()) / (heat.max() - heat.min() + 1e-8)
-            mask = (heat > 0.5).astype(np.uint8) * 255
-            mask = cv2.resize(mask, (w, h), interpolation=cv2.INTER_NEAREST)
-            lines = cv2.HoughLinesP(mask, 1, np.pi/180, 50, minLineLength=30, maxLineGap=5)
-            overlay = rgb.copy()
-            n = 0
-            if lines is not None:
-                for l in lines:
-                    x1, y1, x2, y2 = l[0]
-                    cv2.line(overlay, (x1, y1), (x2, y2), (255, 128, 0), 2)
-                n = len(lines)
-            meta["num_lines"] = int(n)
-        else:
-            meta["warning"] = "Unexpected model output for lines."
-
-    elif detector == "Ellipses (Contours + fitEllipse)":
-        pred = outputs[0]
-        if pred.ndim == 4:
-            heat = pred[0, 0]
-            heat = (heat - heat.min()) / (heat.max() - heat.min() + 1e-8)
-            mask = (heat > 0.5).astype(np.uint8) * 255
-            mask = cv2.resize(mask, (w, h), interpolation=cv2.INTER_NEAREST)
-            contours, _ = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
-            count = 0
-            for cnt in contours:
-                if len(cnt) < 5:
-                    continue
-                try:
-                    (cx, cy), (MA, ma), angle = cv2.fitEllipse(cnt)
-                    area = float(np.pi * (MA / 2) * (ma / 2))
-                    if area >= 300:
-                        cv2.ellipse(overlay, ((int(cx), int(cy)), (int(MA), int(ma)), float(angle)), (0, 200, 255), 2)
-                        count += 1
-                except cv2.error:
-                    continue
-            meta["num_ellipses"] = int(count)
-        else:
-            meta["warning"] = "Unexpected model output for ellipses."
-
-    else:
-        meta["error"] = f"Unknown detector: {detector}"
+    try:
+        overlay, post_meta = adapter.postprocess(outputs, rgb, ctx, detector)
+        meta.update(post_meta)
+    except Exception as e:
+        meta["error"] = f"Postprocess failed: {e}"
+        return rgb, meta
 
     return overlay, meta
-

backend/py/app/inference/dl_adapters.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+import cv2
+import numpy as np
+
+
+@dataclass
+class AdapterContext:
+    input_name: str
+    in_size: Tuple[int, int]
+    orig_size: Tuple[int, int]
+    resize_size: Tuple[int, int]
+    extra: Dict[str, Any]
+
+
+class DLAdapter:
+    def preprocess(self, rgb: np.ndarray, sess) -> Tuple[Dict[str, np.ndarray], AdapterContext]:  # pragma: no cover - runtime dependent
+        raise NotImplementedError
+
+    def postprocess(
+        self, outputs: List[np.ndarray], rgb: np.ndarray, ctx: AdapterContext, detector: str
+    ) -> Tuple[np.ndarray, Dict[str, Any]]:  # pragma: no cover - runtime dependent
+        raise NotImplementedError
+
+
+def _first_input(sess) -> Tuple[str, Tuple[int, int]]:
+    inp = sess.get_inputs()[0]
+    name = inp.name
+    shape = inp.shape
+    if len(shape) == 4:
+        h = shape[2] if isinstance(shape[2], int) and shape[2] > 0 else None
+        w = shape[3] if isinstance(shape[3], int) and shape[3] > 0 else None
+        if h is None or w is None:
+            return name, (None, None)  # type: ignore
+        return name, (int(h), int(w))
+    return name, (None, None)  # type: ignore
+
+
+def _ensure_3ch(x: np.ndarray) -> np.ndarray:
+    if x.ndim == 2:
+        x = np.expand_dims(x, -1)
+    if x.shape[2] == 1:
+        x = np.repeat(x, 3, axis=2)
+    return x
+
+
+class EdgesAdapter(DLAdapter):
+    """Generic single-channel edge detector (DexiNed/HED-style).
+
+    - Input: RGB float32 in [0,1], NCHW 1x3xHxW
+    - Output: take first (or only) output, expect N x 1 x H x W (or compatible)
+    """
+
+    def preprocess(self, rgb: np.ndarray, sess) -> Tuple[Dict[str, np.ndarray], AdapterContext]:
+        input_name, in_wh = _first_input(sess)
+        H, W = rgb.shape[:2]
+        th, tw = in_wh
+        if th is None or tw is None:
+            # Default to 512x512 if model is dynamic and does not specify
+            th, tw = 512, 512
+        resized = cv2.resize(rgb, (tw, th), interpolation=cv2.INTER_AREA)
+        x = _ensure_3ch(resized.astype(np.float32) / 255.0)
+        x = np.transpose(x, (2, 0, 1))[None, ...]
+        ctx = AdapterContext(input_name=input_name, in_size=(th, tw), orig_size=(H, W), resize_size=(th, tw), extra={})
+        return {input_name: x}, ctx
+
+    def _extract_edge_prob(self, outputs: List[np.ndarray]) -> np.ndarray:
+        pred = outputs[0]
+        if pred.ndim == 4:
+            # N x C x H x W
+            cdim = pred.shape[1]
+            prob = pred[0, 0] if cdim >= 1 else pred[0, 0]
+        elif pred.ndim == 3:
+            # C x H x W or N x H x W
+            if pred.shape[0] in (1, 3):
+                prob = pred[0]
+            else:
+                prob = pred[0]
+        elif pred.ndim == 2:
+            prob = pred
+        else:
+            # Fallback: flatten and fail-safe normalize
+            prob = pred.reshape(-1)
+            prob = prob - prob.min()
+            prob = prob / (prob.max() + 1e-8)
+            prob = prob.reshape(int(np.sqrt(prob.size)), -1)
+        # Normalize to [0,1]
+        pmin, pmax = float(np.min(prob)), float(np.max(prob))
+        if pmax > pmin:
+            prob = (prob - pmin) / (pmax - pmin)
+        else:
+            prob = np.zeros_like(prob)
+        return prob.astype(np.float32)
+
+    def postprocess(
+        self, outputs: List[np.ndarray], rgb: np.ndarray, ctx: AdapterContext, detector: str
+    ) -> Tuple[np.ndarray, Dict[str, Any]]:
+        H, W = ctx.orig_size
+        prob = self._extract_edge_prob(outputs)
+        mask = (prob > 0.5).astype(np.uint8) * 255
+        mask = cv2.resize(mask, (W, H), interpolation=cv2.INTER_NEAREST)
+        bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+        bgr[mask > 0] = (0, 255, 0)
+        overlay = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+        meta: Dict[str, Any] = {
+            "edge_prob_mean": float(np.mean(prob)),
+            "resize": {"h": ctx.in_size[0], "w": ctx.in_size[1]},
+        }
+        return overlay, meta
+
+
+class SuperPointAdapter(DLAdapter):
+    """SuperPoint-style keypoint detector.
+
+    - Input: grayscale float32 [0,1], NCHW 1x1xHxW, H and W divisible by 8.
+    - Outputs: semi (1x65xhxw), desc (1x256xhxw). Extract keypoints from semi.
+    """
+
+    def _make_hw_div8(self, H: int, W: int) -> Tuple[int, int]:
+        H8 = max(8, (H // 8) * 8)
+        W8 = max(8, (W // 8) * 8)
+        return H8, W8
+
+    def preprocess(self, rgb: np.ndarray, sess) -> Tuple[Dict[str, np.ndarray], AdapterContext]:
+        input_name, in_wh = _first_input(sess)
+        H, W = rgb.shape[:2]
+        th, tw = in_wh
+        if th is None or tw is None:
+            th, tw = self._make_hw_div8(H, W)
+        else:
+            th, tw = self._make_hw_div8(th, tw)
+        gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+        gray_r = cv2.resize(gray, (tw, th), interpolation=cv2.INTER_AREA).astype(np.float32) / 255.0
+        x = gray_r[None, None, ...]
+        ctx = AdapterContext(input_name=input_name, in_size=(th, tw), orig_size=(H, W), resize_size=(th, tw), extra={})
+        return {input_name: x}, ctx
+
+    def _pick_outputs(self, outputs: List[np.ndarray]) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+        semi = None
+        desc = None
+        for o in outputs:
+            if o.ndim == 4 and o.shape[1] == 65:
+                semi = o
+            elif o.ndim == 4 and o.shape[1] == 256:
+                desc = o
+        if semi is None:
+            # fallback: first output
+            semi = outputs[0]
+        return semi, desc
+
+    def _softmax_channel(self, x: np.ndarray, axis: int = 1) -> np.ndarray:
+        x = x - np.max(x, axis=axis, keepdims=True)
+        e = np.exp(x)
+        return e / np.sum(e, axis=axis, keepdims=True)
+
+    def _semi_to_heat(self, semi: np.ndarray) -> np.ndarray:
+        # semi: 1 x 65 x h x w -> heat: (h*8) x (w*8)
+        if semi.ndim != 4:
+            semi = semi.reshape(1, semi.shape[0], semi.shape[1], semi.shape[2])
+        semi = self._softmax_channel(semi, axis=1)
+        semi = semi[0]
+        if semi.shape[0] == 65:
+            semi = semi[:-1, ...]  # drop dustbin
+        Hc, Wc = semi.shape[1], semi.shape[2]
+        semi = semi.transpose(1, 2, 0)  # h x w x 64
+        semi = semi.reshape(Hc, Wc, 8, 8)
+        semi = semi.transpose(0, 2, 1, 3)
+        heat = semi.reshape(Hc * 8, Wc * 8)
+        return heat
+
+    def _nms_points(self, heat: np.ndarray, thresh: float = 0.015, nms_size: int = 3, max_kp: int = 1000) -> Tuple[np.ndarray, np.ndarray]:
+        H, W = heat.shape
+        dil = cv2.dilate(heat, np.ones((nms_size, nms_size), np.float32))
+        maxima = (heat == dil) & (heat > thresh)
+        ys, xs = np.where(maxima)
+        if len(xs) > max_kp:
+            # keep strongest
+            vals = heat[ys, xs]
+            idx = np.argsort(vals)[-max_kp:]
+            ys, xs = ys[idx], xs[idx]
+        return ys, xs
+
+    def postprocess(
+        self, outputs: List[np.ndarray], rgb: np.ndarray, ctx: AdapterContext, detector: str
+    ) -> Tuple[np.ndarray, Dict[str, Any]]:
+        semi, desc = self._pick_outputs(outputs)
+        heat_r = self._semi_to_heat(semi)
+        # Resize heatmap back to original size
+        H0, W0 = ctx.orig_size
+        heat = cv2.resize(heat_r, (W0, H0), interpolation=cv2.INTER_CUBIC)
+        ys, xs = self._nms_points(heat)
+
+        overlay = rgb.copy()
+        for y, x in zip(ys.tolist(), xs.tolist()):
+            cv2.circle(overlay, (int(x), int(y)), 2, (255, 255, 0), -1)
+
+        meta: Dict[str, Any] = {
+            "num_corners": int(len(xs)),
+            "heat_mean": float(np.mean(heat)),
+        }
+        if desc is not None:
+            meta["descriptors_shape"] = list(desc.shape)
+        return overlay, meta
+
+
+def get_adapter(model_path: str, detector: str) -> DLAdapter:
+    name = os.path.basename(model_path).lower()
+    if "superpoint" in name or (detector.startswith("Corners") and "super" in name):
+        return SuperPointAdapter()
+    if any(k in name for k in ("dexined", "hed")) or detector.startswith("Edges"):
+        return EdgesAdapter()
+    # Default fallback: treat like edges
+    return EdgesAdapter()
+
+
+__all__ = [
+    "DLAdapter",
+    "AdapterContext",
+    "EdgesAdapter",
+    "SuperPointAdapter",
+    "get_adapter",
+]
+

backend/py/app/models/schemas.py

@@ -14,6 +14,10 @@ class DetectionParams(BaseModel):
     hough_max_gap: Optional[int] = Field(None, ge=0, le=200)
     ellipse_min_area: Optional[int] = Field(None, ge=10, le=100000)
     max_ellipses: Optional[int] = Field(None, ge=1, le=100)
+    line_detector: Optional[Literal["hough", "lsd"]] = Field(
+        None,
+        description="Classical line detector variant to use: 'hough' (default) or 'lsd'.",
+    )
 
 
 class DetectionRequest(BaseModel):
@@ -34,4 +38,3 @@ class DetectionResponse(BaseModel):
     fps_estimate: Optional[float] = None
     model: Dict[str, Any]
     models: Dict[str, Dict[str, Any]]
-

backend/py/app/services/runtime_adapter.py

@@ -21,6 +21,7 @@ DEFAULT_PARAMS: Dict[str, Any] = {
     "hough_max_gap": 5,
     "ellipse_min_area": 300,
     "max_ellipses": 5,
+    "line_detector": "hough",
 }
 
 PARAM_TYPES: Dict[str, Any] = {
@@ -34,6 +35,7 @@ PARAM_TYPES: Dict[str, Any] = {
     "hough_max_gap": int,
     "ellipse_min_area": int,
     "max_ellipses": int,
+    "line_detector": lambda x: str(x).lower(),
 }
 
 CLASSICAL_MODEL_INFO = {"name": "opencv-classical", "version": cv2.__version__}
@@ -105,6 +107,7 @@ def run_detection(
             merged["hough_max_gap"],
             merged["ellipse_min_area"],
             merged["max_ellipses"],
+            merged["line_detector"],
         )
         t_ms = (time.perf_counter() - t0) * 1000.0
         overlays["classical"] = classical_img
@@ -145,4 +148,3 @@ __all__ = [
     "merge_params",
     "run_detection",
 ]
-