Skip to content

Image Pipeline Playground

feat(backend/nodes): add morphology erode dilate and morph-ex

Mohammad Rajaeidd684d68312f
diff --git a/backend/app/nodes/__init__.py b/backend/app/nodes/__init__.py
index 79da70c..c1ea3d3 100644
--- a/backend/app/nodes/__init__.py
+++ b/backend/app/nodes/__init__.py
@@ -5,6 +5,7 @@ from app.nodes.color import MergeChannelsNode, SplitChannelsNode, ToGrayNode, To
from app.nodes.filters import CannyNode, GaussianBlurNode, MedianBlurNode, ThresholdNode
from app.nodes.geometry import CropNode, FlipNode, ResizeNode, RotateNode
from app.nodes.io import LoadImageNode, PreviewNode, SaveImageNode
+from app.nodes.morphology import DilateNode, ErodeNode, MorphologyExNode
from app.nodes.stochastic import GaussianNoiseNode, RandomBrightnessContrastNode
_REGISTERED = False
@@ -26,6 +27,9 @@ def register_builtin_nodes() -> None:
MedianBlurNode(),
CannyNode(),
ThresholdNode(),
+ ErodeNode(),
+ DilateNode(),
+ MorphologyExNode(),
ResizeNode(),
RotateNode(),
CropNode(),
diff --git a/backend/app/nodes/morphology.py b/backend/app/nodes/morphology.py
new file mode 100644
index 0000000..9828ade
--- /dev/null
+++ b/backend/app/nodes/morphology.py
@@ -0,0 +1,177 @@
+"""Morphological operations for binary / grayscale research pipelines."""
+
+from __future__ import annotations
+
+from typing import Any
+
+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
+
+
+def _odd(value: int) -> int:
+ value = max(1, int(value))
+ return value if value % 2 == 1 else value + 1
+
+
+def _kernel(ksize: int, shape: str) -> np.ndarray:
+ size = _odd(ksize)
+ morph_shape = {
+ "rect": cv2.MORPH_RECT,
+ "ellipse": cv2.MORPH_ELLIPSE,
+ "cross": cv2.MORPH_CROSS,
+ }.get(shape, cv2.MORPH_RECT)
+ return cv2.getStructuringElement(morph_shape, (size, size))
+
+
+class ErodeNode(BaseNode):
+ type = "erode"
+ label = "Erode"
+ category = "morphology"
+ description = "Morphological erosion — shrink bright regions / clean speckles."
+ ports = [image_in(), image_out()]
+ params = [
+ int_param("ksize", "Kernel Size", 3, minimum=1, maximum=31),
+ int_param("iterations", "Iterations", 1, minimum=1, maximum=20),
+ select_param("shape", "Kernel Shape", "rect", ["rect", "ellipse", "cross"]),
+ ]
+
+ 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)
+ kernel = _kernel(int(params["ksize"]), str(params["shape"]))
+ return {
+ "image": cv2.erode(image, kernel, iterations=int(params["iterations"])),
+ }
+
+ def emit_python(
+ self,
+ node_id: str,
+ params: dict[str, Any],
+ input_vars: dict[str, str],
+ output_vars: dict[str, str],
+ ) -> list[str]:
+ size = _odd(int(params["ksize"]))
+ shape = {
+ "rect": "cv2.MORPH_RECT",
+ "ellipse": "cv2.MORPH_ELLIPSE",
+ "cross": "cv2.MORPH_CROSS",
+ }.get(str(params["shape"]), "cv2.MORPH_RECT")
+ return [
+ f"_k = cv2.getStructuringElement({shape}, ({size}, {size}))",
+ (
+ f"{output_vars['image']} = cv2.erode("
+ f"{input_vars['image']}, _k, iterations={int(params['iterations'])})"
+ ),
+ ]
+
+
+class DilateNode(BaseNode):
+ type = "dilate"
+ label = "Dilate"
+ category = "morphology"
+ description = "Morphological dilation — expand bright regions / fill gaps."
+ ports = [image_in(), image_out()]
+ params = [
+ int_param("ksize", "Kernel Size", 3, minimum=1, maximum=31),
+ int_param("iterations", "Iterations", 1, minimum=1, maximum=20),
+ select_param("shape", "Kernel Shape", "rect", ["rect", "ellipse", "cross"]),
+ ]
+
+ 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)
+ kernel = _kernel(int(params["ksize"]), str(params["shape"]))
+ return {
+ "image": cv2.dilate(image, kernel, iterations=int(params["iterations"])),
+ }
+
+ def emit_python(
+ self,
+ node_id: str,
+ params: dict[str, Any],
+ input_vars: dict[str, str],
+ output_vars: dict[str, str],
+ ) -> list[str]:
+ size = _odd(int(params["ksize"]))
+ shape = {
+ "rect": "cv2.MORPH_RECT",
+ "ellipse": "cv2.MORPH_ELLIPSE",
+ "cross": "cv2.MORPH_CROSS",
+ }.get(str(params["shape"]), "cv2.MORPH_RECT")
+ return [
+ f"_k = cv2.getStructuringElement({shape}, ({size}, {size}))",
+ (
+ f"{output_vars['image']} = cv2.dilate("
+ f"{input_vars['image']}, _k, iterations={int(params['iterations'])})"
+ ),
+ ]
+
+
+class MorphologyExNode(BaseNode):
+ type = "morphology_ex"
+ label = "Morphology Ex"
+ category = "morphology"
+ description = "Open, close, gradient, tophat, or blackhat morphology."
+ ports = [image_in(), image_out()]
+ params = [
+ select_param(
+ "op",
+ "Operation",
+ "open",
+ ["open", "close", "gradient", "tophat", "blackhat"],
+ ),
+ int_param("ksize", "Kernel Size", 5, minimum=1, maximum=31),
+ select_param("shape", "Kernel Shape", "ellipse", ["rect", "ellipse", "cross"]),
+ ]
+
+ 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]]:
+ op = {
+ "open": cv2.MORPH_OPEN,
+ "close": cv2.MORPH_CLOSE,
+ "gradient": cv2.MORPH_GRADIENT,
+ "tophat": cv2.MORPH_TOPHAT,
+ "blackhat": cv2.MORPH_BLACKHAT,
+ }.get(str(params["op"]), cv2.MORPH_OPEN)
+ kernel = _kernel(int(params["ksize"]), str(params["shape"]))
+ return {"image": cv2.morphologyEx(require_image(inputs), op, kernel)}
+
+ def emit_python(
+ self,
+ node_id: str,
+ params: dict[str, Any],
+ input_vars: dict[str, str],
+ output_vars: dict[str, str],
+ ) -> list[str]:
+ size = _odd(int(params["ksize"]))
+ shape = {
+ "rect": "cv2.MORPH_RECT",
+ "ellipse": "cv2.MORPH_ELLIPSE",
+ "cross": "cv2.MORPH_CROSS",
+ }.get(str(params["shape"]), "cv2.MORPH_ELLIPSE")
+ op = {
+ "open": "cv2.MORPH_OPEN",
+ "close": "cv2.MORPH_CLOSE",
+ "gradient": "cv2.MORPH_GRADIENT",
+ "tophat": "cv2.MORPH_TOPHAT",
+ "blackhat": "cv2.MORPH_BLACKHAT",
+ }.get(str(params["op"]), "cv2.MORPH_OPEN")
+ return [
+ f"_k = cv2.getStructuringElement({shape}, ({size}, {size}))",
+ f"{output_vars['image']} = cv2.morphologyEx({input_vars['image']}, {op}, _k)",
+ ]
diff --git a/backend/tests/test_morphology.py b/backend/tests/test_morphology.py
new file mode 100644
index 0000000..58013e4
--- /dev/null
+++ b/backend/tests/test_morphology.py
@@ -0,0 +1,41 @@
+"""Tests for morphological nodes."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from app.engine.registry import registry
+from app.nodes import register_builtin_nodes
+
+
+def test_morphology_nodes_registered() -> None:
+ register_builtin_nodes()
+ types = {meta.type for meta in registry.list_metadata()}
+ assert {"erode", "dilate", "morphology_ex"}.issubset(types)
+
+
+def test_erode_shrinks_bright_blob() -> None:
+ register_builtin_nodes()
+ image = np.zeros((32, 32), dtype=np.uint8)
+ image[10:22, 10:22] = 255
+ eroded = registry.get("erode").execute(
+ {"image": image},
+ {"ksize": 3, "iterations": 1, "shape": "rect"},
+ seed=0,
+ )["image"]
+ assert isinstance(eroded, np.ndarray)
+ assert int(eroded.sum()) < int(image.sum())
+
+
+def test_morphology_open_removes_speckle() -> None:
+ register_builtin_nodes()
+ image = np.zeros((40, 40), dtype=np.uint8)
+ image[15:25, 15:25] = 255
+ image[2, 2] = 255
+ opened = registry.get("morphology_ex").execute(
+ {"image": image},
+ {"op": "open", "ksize": 3, "shape": "rect"},
+ seed=0,
+ )["image"]
+ assert opened[2, 2] == 0
+ assert opened[20, 20] == 255
diff --git a/backend/tests/test_nodes.py b/backend/tests/test_nodes.py
index 8012256..3880b78 100644
--- a/backend/tests/test_nodes.py
+++ b/backend/tests/test_nodes.py
@@ -22,6 +22,9 @@ def test_builtin_nodes_registered() -> None:
"median_blur",
"canny",
"threshold",
+ "erode",
+ "dilate",
+ "morphology_ex",
"resize",
"rotate",
"crop",