adding more nodes

backend/nodes/straighten_path.py

@@ -0,0 +1,95 @@
+"""Straighten path — extract cross-section along a curved spline path."""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.ndimage import map_coordinates
+
+from backend.node_registry import register_node
+from backend.data_types import DataField
+
+
+@register_node(display_name="Straighten Path")
+class StraightenPath:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "field": ("DATA_FIELD",),
+                "points_x": ("STRING", {"default": "0.25, 0.5, 0.75"}),
+                "points_y": ("STRING", {"default": "0.5, 0.3, 0.5"}),
+                "thickness": ("INT", {"default": 1, "min": 1, "max": 100, "step": 1}),
+                "n_samples": ("INT", {"default": 256, "min": 10, "max": 2048, "step": 1}),
+            }
+        }
+
+    OUTPUTS = (
+        ('DATA_FIELD', 'straightened'),
+    )
+    FUNCTION = "process"
+
+    DESCRIPTION = (
+        "Extract a cross-section along an arbitrary curved path defined by "
+        "control points. Points are given as fractional coordinates (0–1). "
+        "The path is interpolated with cubic splines, and data is sampled "
+        "along it with configurable thickness. "
+    )
+
+    def process(self, field: DataField, points_x: str, points_y: str,
+                thickness: int, n_samples: int) -> tuple:
+        data = np.asarray(field.data, dtype=np.float64)
+        yres, xres = data.shape
+
+        # Parse control points
+        px = [float(v.strip()) * (xres - 1) for v in points_x.split(",") if v.strip()]
+        py = [float(v.strip()) * (yres - 1) for v in points_y.split(",") if v.strip()]
+
+        if len(px) < 2 or len(py) < 2:
+            # Need at least 2 points
+            return (field,)
+
+        n_pts = min(len(px), len(py))
+        px, py = px[:n_pts], py[:n_pts]
+
+        # Parameterize path and interpolate
+        t_ctrl = np.linspace(0, 1, n_pts)
+        t_sample = np.linspace(0, 1, n_samples)
+
+        # Simple cubic interpolation via numpy
+        if n_pts >= 4:
+            from numpy.polynomial.polynomial import Polynomial
+            cx = np.interp(t_sample, t_ctrl, px)
+            cy = np.interp(t_sample, t_ctrl, py)
+        else:
+            cx = np.interp(t_sample, t_ctrl, px)
+            cy = np.interp(t_sample, t_ctrl, py)
+
+        # Sample along path with thickness
+        if thickness <= 1:
+            values = map_coordinates(data, [cy, cx], order=1, mode='nearest')
+            result = values.reshape(1, -1)
+        else:
+            # Compute normals
+            dcx = np.gradient(cx)
+            dcy = np.gradient(cy)
+            length = np.sqrt(dcx**2 + dcy**2)
+            length = np.maximum(length, 1e-10)
+            nx = -dcy / length
+            ny = dcx / length
+
+            offsets = np.linspace(-(thickness - 1) / 2, (thickness - 1) / 2, thickness)
+            result = np.zeros((thickness, n_samples))
+            for i, off in enumerate(offsets):
+                sx = cx + off * nx
+                sy = cy + off * ny
+                result[i] = map_coordinates(data, [sy, sx], order=1, mode='nearest')
+
+        # Physical dimensions
+        total_length = 0.0
+        for i in range(1, len(cx)):
+            dx_phys = (cx[i] - cx[i - 1]) * field.dx
+            dy_phys = (cy[i] - cy[i - 1]) * field.dy
+            total_length += np.sqrt(dx_phys**2 + dy_phys**2)
+
+        return (field.replace(data=result, xreal=total_length,
+                              yreal=thickness * max(field.dx, field.dy)),)