Skip to content

Image Pipeline Playground

feat(backend/nodes): add blob detect analysis node

Mohammad Rajaei116134151be1
diff --git a/backend/app/nodes/__init__.py b/backend/app/nodes/__init__.py
index e11870e..aadf5fd 100644
--- a/backend/app/nodes/__init__.py
+++ b/backend/app/nodes/__init__.py
@@ -30,6 +30,7 @@ from app.nodes.io import LoadImageNode, PreviewNode, SaveImageNode
from app.nodes.morphology import DilateNode, ErodeNode, MorphologyExNode
from app.nodes.stochastic import GaussianNoiseNode, RandomBrightnessContrastNode
from app.nodes.structure import (
+ BlobDetectNode,
ConnectedComponentsNode,
ConvexHullNode,
FindContoursNode,
@@ -69,6 +70,7 @@ def register_builtin_nodes() -> None:
ConvexHullNode(),
ImageMomentsNode(),
ConnectedComponentsNode(),
+ BlobDetectNode(),
ErodeNode(),
DilateNode(),
MorphologyExNode(),
diff --git a/backend/app/nodes/structure.py b/backend/app/nodes/structure.py
index 1f40569..01c70fe 100644
--- a/backend/app/nodes/structure.py
+++ b/backend/app/nodes/structure.py
@@ -8,7 +8,14 @@ import cv2
import numpy as np
from app.engine.registry import BaseNode
-from app.nodes.common import image_in, image_out, int_param, require_image, select_param
+from app.nodes.common import (
+ image_in,
+ image_out,
+ int_param,
+ number_param,
+ require_image,
+ select_param,
+)
def _as_gray(image: np.ndarray) -> np.ndarray:
@@ -382,3 +389,114 @@ class ConnectedComponentsNode(BaseNode):
" _w = int(_st[_i, cv2.CC_STAT_WIDTH]); _h = int(_st[_i, cv2.CC_STAT_HEIGHT])",
f" cv2.rectangle({dst}, (_x, _y), (_x+_w-1, _y+_h-1), (0, 255, 120), 2)",
]
+
+
+class BlobDetectNode(BaseNode):
+ type = "blob_detect"
+ label = "Blob Detect"
+ category = "analysis"
+ description = "Detect blob keypoints with OpenCV SimpleBlobDetector."
+ ports = [image_in(), image_out()]
+ params = [
+ number_param("min_area", "Min Area", 20.0, minimum=1.0, maximum=100000.0),
+ number_param("max_area", "Max Area", 5000.0, minimum=1.0, maximum=1000000.0),
+ number_param(
+ "min_circularity",
+ "Min Circularity",
+ 0.1,
+ minimum=0.0,
+ maximum=1.0,
+ step=0.05,
+ ),
+ number_param(
+ "min_convexity",
+ "Min Convexity",
+ 0.5,
+ minimum=0.0,
+ maximum=1.0,
+ step=0.05,
+ ),
+ number_param(
+ "min_inertia",
+ "Min Inertia",
+ 0.1,
+ minimum=0.0,
+ maximum=1.0,
+ step=0.05,
+ ),
+ select_param("overlay", "Overlay", "on_input", ["on_input", "blank"]),
+ ]
+
+ def execute(
+ self,
+ inputs: dict[str, np.ndarray | list[np.ndarray] | None],
+ params: dict[str, Any],
+ seed: int = 0,
+ ) -> dict[str, np.ndarray | list[np.ndarray]]:
+ image = require_image(inputs)
+ gray = _as_gray(image)
+ blob_params = cv2.SimpleBlobDetector_Params()
+ blob_params.filterByArea = True
+ blob_params.minArea = float(params["min_area"])
+ blob_params.maxArea = float(params["max_area"])
+ blob_params.filterByCircularity = True
+ blob_params.minCircularity = float(params["min_circularity"])
+ blob_params.filterByConvexity = True
+ blob_params.minConvexity = float(params["min_convexity"])
+ blob_params.filterByInertia = True
+ blob_params.minInertiaRatio = float(params["min_inertia"])
+ blob_params.filterByColor = False
+ detector = cv2.SimpleBlobDetector_create(blob_params)
+ keypoints = detector.detect(gray)
+ if str(params["overlay"]) == "blank":
+ canvas = np.zeros_like(_as_bgr(image))
+ else:
+ canvas = _as_bgr(image)
+ return {
+ "image": cv2.drawKeypoints(
+ canvas,
+ keypoints,
+ np.array([]),
+ (0, 140, 255),
+ cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
+ )
+ }
+
+ def emit_python(
+ self,
+ node_id: str,
+ params: dict[str, Any],
+ input_vars: dict[str, str],
+ output_vars: dict[str, str],
+ ) -> list[str]:
+ src = input_vars["image"]
+ dst = output_vars["image"]
+ blank = str(params["overlay"]) == "blank"
+ return [
+ f"_gray = {src} if len({src}.shape) == 2 else cv2.cvtColor({src}, cv2.COLOR_BGR2GRAY)",
+ "_bp = cv2.SimpleBlobDetector_Params()",
+ "_bp.filterByArea = True",
+ f"_bp.minArea = {float(params['min_area'])}",
+ f"_bp.maxArea = {float(params['max_area'])}",
+ "_bp.filterByCircularity = True",
+ f"_bp.minCircularity = {float(params['min_circularity'])}",
+ "_bp.filterByConvexity = True",
+ f"_bp.minConvexity = {float(params['min_convexity'])}",
+ "_bp.filterByInertia = True",
+ f"_bp.minInertiaRatio = {float(params['min_inertia'])}",
+ "_bp.filterByColor = False",
+ "_det = cv2.SimpleBlobDetector_create(_bp)",
+ "_kps = _det.detect(_gray)",
+ (
+ "_base = np.zeros((_gray.shape[0], _gray.shape[1], 3), dtype='uint8')"
+ if blank
+ else (
+ f"_base = {src}.copy() if len({src}.shape) == 3 else "
+ f"cv2.cvtColor({src}, cv2.COLOR_GRAY2BGR)"
+ )
+ ),
+ (
+ f"{dst} = cv2.drawKeypoints(_base, _kps, np.array([]), (0, 140, 255), "
+ "cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)"
+ ),
+ ]
diff --git a/backend/tests/test_nodes.py b/backend/tests/test_nodes.py
index de3d3f5..d23b210 100644
--- a/backend/tests/test_nodes.py
+++ b/backend/tests/test_nodes.py
@@ -36,6 +36,7 @@ def test_builtin_nodes_registered() -> None:
"convex_hull",
"moments",
"connected_components",
+ "blob_detect",
"erode",
"dilate",
"morphology_ex",
diff --git a/backend/tests/test_structure_blob.py b/backend/tests/test_structure_blob.py
new file mode 100644
index 0000000..be4f0a3
--- /dev/null
+++ b/backend/tests/test_structure_blob.py
@@ -0,0 +1,37 @@
+"""Tests for blob-detect structure node."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from app.engine.registry import registry
+from app.nodes import register_builtin_nodes
+
+
+def test_blob_detect_registered() -> None:
+ register_builtin_nodes()
+ assert "blob_detect" in {meta.type for meta in registry.list_metadata()}
+
+
+def test_blob_detect_finds_circular_blob() -> None:
+ register_builtin_nodes()
+ image = np.zeros((120, 120), dtype=np.uint8)
+ # SimpleBlobDetector often prefers dark blobs on light background.
+ image[:] = 255
+ yy, xx = np.ogrid[:120, :120]
+ mask = (xx - 60) ** 2 + (yy - 60) ** 2 <= 18**2
+ image[mask] = 0
+ result = registry.get("blob_detect").execute(
+ {"image": image},
+ {
+ "min_area": 50.0,
+ "max_area": 5000.0,
+ "min_circularity": 0.5,
+ "min_convexity": 0.5,
+ "min_inertia": 0.2,
+ "overlay": "blank",
+ },
+ seed=0,
+ )["image"]
+ assert result.ndim == 3
+ assert int(result.sum()) > 0