Refactor line detection with better fallback

detectors.py

@@ -60,6 +60,9 @@ from detection_schema import (
 from skimage.morphology import skeletonize
 from skimage.measure import label
 
+# At the top with other imports
+from line_detectors import OpenCVLineDetector, DeepLSDDetector, DEEPLSD_AVAILABLE
+
 class Detector(ABC):
     """Base class for all detectors"""
     
@@ -133,24 +136,16 @@ class LineDetector(Detector):
     
     def __init__(self, config, model_path=None, model_config=None, device='cpu', debug_handler=None):
         super().__init__(config, debug_handler)
-        self.model_path = model_path
-        self.model_config = model_config or {}
-        self.device = device
-        self.use_deeplsd = DEEPLSD_AVAILABLE
-        
-    def detect(self, image: np.ndarray) -> Dict:
-        """Detect lines using DeepLSD or fallback to basic methods"""
-        if self.use_deeplsd:
-            # Use DeepLSD
-            return self._detect_with_deeplsd(image)
+        # Try to use DeepLSD if available, otherwise fall back to OpenCV
+        if DEEPLSD_AVAILABLE and model_path:
+            self.detector = DeepLSDDetector(model_path)
+            logger.info("Using DeepLSD for line detection")
         else:
-            # Fallback to basic line detection
-            return self._detect_basic(image)
+            self.detector = OpenCVLineDetector()
+            logger.info("Using OpenCV for line detection")
             
-    def _detect_basic(self, image: np.ndarray) -> Dict:
-        """Basic line detection using OpenCV"""
-        # Basic implementation
-        return {'detections': []}
+    def detect(self, image: np.ndarray) -> Dict:
+        return self.detector.detect(image)
 
 
 class PointDetector(Detector):

line_detectors.py

@@ -0,0 +1,51 @@
+import logging
+import cv2
+import numpy as np
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+class BaseLineDetector:
+    """Base class for line detection methods"""
+    def detect(self, image: np.ndarray) -> Dict:
+        raise NotImplementedError
+
+class OpenCVLineDetector(BaseLineDetector):
+    """Basic line detection using OpenCV"""
+    def detect(self, image: np.ndarray) -> Dict:
+        # Convert to grayscale if needed
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image
+            
+        # Basic line detection using HoughLinesP
+        edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, 100, minLineLength=100, maxLineGap=10)
+        
+        detections = []
+        if lines is not None:
+            for line in lines:
+                x1, y1, x2, y2 = line[0]
+                detections.append({
+                    'start': [float(x1), float(y1)],
+                    'end': [float(x2), float(y2)]
+                })
+                
+        return {'detections': detections}
+
+# Try to import DeepLSD, but don't fail if not available
+try:
+    from deeplsd.models.deeplsd_inference import DeepLSD
+    class DeepLSDDetector(BaseLineDetector):
+        def __init__(self, model_path: Optional[str] = None):
+            self.model = DeepLSD(model_path) if model_path else None
+            
+        def detect(self, image: np.ndarray) -> Dict:
+            # DeepLSD implementation
+            return {'detections': []}
+    DEEPLSD_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"DeepLSD not available: {e}")
+    DEEPLSD_AVAILABLE = False
+    DeepLSDDetector = None