feat: add 4 new RCE feature modules — Laplacian, Gradient Orientation, Gabor, LBP

pages/3_Feature_Lab.py

@@ -32,11 +32,14 @@ with col_rce:
     st.header("🧬 RCE: Modular Physics Engine")
     st.subheader("Select Active Modules")
 
-    # Dynamically build checkboxes from the registry
-    m_cols = st.columns(len(REGISTRY))
+    # Dynamically build checkboxes from the registry (rows of 4)
     active = {}
-    for i, (key, meta) in enumerate(REGISTRY.items()):
-        active[key] = m_cols[i].checkbox(meta["label"], value=True)
+    items = list(REGISTRY.items())
+    for row_start in range(0, len(items), 4):
+        row_items = items[row_start:row_start + 4]
+        m_cols = st.columns(4)
+        for col, (key, meta) in zip(m_cols, row_items):
+            active[key] = col.checkbox(meta["label"], value=(key in ("intensity", "sobel", "spectral")))
 
     # Build vector + collect visualizations by calling registry functions
     final_vector = []
@@ -47,12 +50,14 @@ with col_rce:
             final_vector.extend(vec)
             viz_images.append((meta["viz_title"], viz))
 
-    # Visualizations
+    # Visualizations (rows of 3)
     st.divider()
     if viz_images:
-        v_cols = st.columns(len(viz_images))
-        for idx, (title, img) in enumerate(viz_images):
-            v_cols[idx].image(img, caption=title, use_container_width=True)
+        for row_start in range(0, len(viz_images), 3):
+            row = viz_images[row_start:row_start + 3]
+            v_cols = st.columns(3)
+            for col, (title, img) in zip(v_cols, row):
+                col.image(img, caption=title, use_container_width=True)
     else:
         st.warning("No modules selected — vector is empty.")
 

src/detectors/rce/features.py

@@ -53,6 +53,69 @@ def compute_spectral(gray: np.ndarray):
     return hist.astype(np.float32), viz
 
 
+# ---------------------------------------------------------------------------
+# Module 3 — Laplacian (2nd-order, curvature / blobs)
+# ---------------------------------------------------------------------------
+def compute_laplacian(gray: np.ndarray):
+    """10-bin histogram of absolute Laplacian response (blob / corner energy)."""
+    lap = cv2.Laplacian(gray, cv2.CV_64F, ksize=3)
+    mag = np.abs(lap)
+    hist, _ = np.histogram(mag, bins=10, range=(0, 255))
+    viz = (mag / (mag.max() + 1e-5)).astype(np.float32)
+    return hist.astype(np.float32), viz
+
+
+# ---------------------------------------------------------------------------
+# Module 4 — Gradient Orientation (1st-order direction)
+# ---------------------------------------------------------------------------
+def compute_grad_orient(gray: np.ndarray):
+    """10-bin histogram of gradient orientations (0-360°), weighted by magnitude."""
+    sx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    sy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+    mag = np.sqrt(sx ** 2 + sy ** 2)
+    angle = np.degrees(np.arctan2(sy, sx)) % 360
+    hist, _ = np.histogram(angle, bins=10, range=(0, 360), weights=mag)
+    viz = (angle / 360.0).astype(np.float32)
+    return hist.astype(np.float32), viz
+
+
+# ---------------------------------------------------------------------------
+# Module 5 — Gabor (oriented texture / frequency)
+# ---------------------------------------------------------------------------
+def compute_gabor(gray: np.ndarray):
+    """10-bin histogram of mean Gabor filter responses across 4 orientations."""
+    ksize = 15
+    sigma, lambd, gamma, psi = 4.0, 10.0, 0.5, 0.0
+    responses = np.zeros_like(gray, dtype=np.float64)
+    for theta in [0, np.pi / 4, np.pi / 2, 3 * np.pi / 4]:
+        kernel = cv2.getGaborKernel(
+            (ksize, ksize), sigma, theta, lambd, gamma, psi, ktype=cv2.CV_64F
+        )
+        responses += np.abs(cv2.filter2D(gray, cv2.CV_64F, kernel))
+    responses /= 4.0
+    hist, _ = np.histogram(responses, bins=10, range=(0, responses.max() + 1e-5))
+    viz = (responses / (responses.max() + 1e-5)).astype(np.float32)
+    return hist.astype(np.float32), viz
+
+
+# ---------------------------------------------------------------------------
+# Module 6 — LBP (Local Binary Pattern, texture micro-structure)
+# ---------------------------------------------------------------------------
+def compute_lbp(gray: np.ndarray):
+    """10-bin histogram of simplified 8-neighbour LBP codes."""
+    padded = cv2.copyMakeBorder(gray, 1, 1, 1, 1, cv2.BORDER_REFLECT)
+    h, w = gray.shape
+    lbp = np.zeros((h, w), dtype=np.uint8)
+    offsets = [(-1, -1), (-1, 0), (-1, 1),
+               (0, 1), (1, 1), (1, 0), (1, -1), (0, -1)]
+    for bit, (dy, dx) in enumerate(offsets):
+        neighbour = padded[1 + dy: 1 + dy + h, 1 + dx: 1 + dx + w]
+        lbp |= ((neighbour >= gray).astype(np.uint8) << bit)
+    hist = cv2.calcHist([lbp], [0], None, [10], [0, 256]).flatten().astype(np.float32)
+    viz = lbp.astype(np.float32) / 255.0
+    return hist, viz
+
+
 # ---------------------------------------------------------------------------
 # Registry — defines the order and display labels seen by the UI
 # Add new modules here; the Feature Lab page iterates this dict.
@@ -73,10 +136,24 @@ REGISTRY: dict = {
         "fn": compute_spectral,
         "viz_title": "Frequency Domain (FFT)",
     },
-    # --- ADD NEW MODULES BELOW ---
-    # "lbp": {
-    #     "label": "LBP (Local Texture)",
-    #     "fn": compute_lbp,
-    #     "viz_title": "LBP Pattern",
-    # },
+    "laplacian": {
+        "label": "2-Order (Laplacian)",
+        "fn": compute_laplacian,
+        "viz_title": "Curvature / Blobs (Laplacian)",
+    },
+    "grad_orient": {
+        "label": "Gradient Orient.",
+        "fn": compute_grad_orient,
+        "viz_title": "Edge Directions",
+    },
+    "gabor": {
+        "label": "Gabor (Texture)",
+        "fn": compute_gabor,
+        "viz_title": "Oriented Texture (Gabor)",
+    },
+    "lbp": {
+        "label": "LBP (Local Texture)",
+        "fn": compute_lbp,
+        "viz_title": "Local Binary Pattern",
+    },
 }