update: move and fix the bezier handle to avoid weird meshing behavior

Author: skim0119

src/bsr/geometry/primitives/pipe.py

@@ -15,6 +15,7 @@
 import bpy
 import numpy as np
 from numpy.typing import NDArray
+from scipy.interpolate import interp1d
 
 from bsr.geometry.protocol import BlenderMeshInterfaceProtocol, SplineDataType
 from bsr.tools.keyframe_mixin import KeyFrameControlMixin
@@ -35,16 +36,7 @@ class BezierSplinePipe(KeyFrameControlMixin):
     positions : NDArray
         The position of the spline control points. Shape: (3, n)
     radii : NDArray
-        The radius at each control point. Shape: (n,)
-    handle_type : str, optional
-        Handle type for Bezier points. Options: "AUTO", "VECTOR", "SMOOTH"
-        Default: "AUTO" (recommended for smooth pipes without tip distortion)
-
-    Notes
-    -----
-    - "AUTO" handles provide the smoothest pipe appearance
-    - "VECTOR" handles can cause tip distortion and bevel compression at corners
-    - "SMOOTH" handles provide manual control but require more setup
+        The radius at each control point. Shape: (n-1,)
     """
 
     input_states = {"positions", "radii"}
@@ -54,7 +46,6 @@ def __init__(
         self,
         positions: NDArray,
         radii: NDArray,
-        handle_type: str = "AUTO",
         downsample_num_element: int | None = None,
         **kwargs: Any,
     ) -> None:
@@ -67,9 +58,6 @@ def __init__(
             The position of the spline object. (3, n)
         radii : NDArray
             The radius of the spline object. (n,)
-        handle_type : str, optional
-            The handle type for Bezier points. Options: "AUTO", "VECTOR", "SMOOTH"
-            Default is "AUTO" for smoother pipe appearance.
         downsample_num_element : int | None, optional
             If provided, downsample the positions and radii to this number of elements.
             Default is None (no downsampling).
@@ -78,7 +66,7 @@ def __init__(
             downsample_num_element is None or downsample_num_element >= 2
         ), "downsample_num_element must be at least 2 to include both endpoints"
         self.downsample_num_element = downsample_num_element
-        self._obj = self._create_bezier_spline(radii.size, handle_type)
+        self._obj = self._create_bezier_spline(min(positions.shape[1], downsample_num_element))
         self._obj.name = self.name
         self.update_states(positions, radii)
 
@@ -91,7 +79,6 @@ def __init__(
     def create(
         cls,
         states: SplineDataType,
-        handle_type: str = "AUTO",
         downsample_num_element: int | None = None,
     ) -> "BezierSplinePipe":
         """
@@ -101,9 +88,6 @@ def create(
         ----------
         states : SplineDataType
             Dictionary containing 'positions', 'radii'
-        handle_type : str, optional
-            The handle type for Bezier points. Options: "AUTO", "VECTOR", "SMOOTH"
-            Default is "AUTO" for smoother pipe appearance.
         downsample_num_element : int | None, optional
             If provided, downsample the positions and radii to this number of elements.
             Default is None (no downsampling).
@@ -118,7 +102,6 @@ def create(
         return cls(
             states["positions"],
             states["radii"],
-            handle_type,
             downsample_num_element,
         )
 
@@ -182,60 +165,34 @@ def update_states(
             If the shape of the position or radius is incorrect, or if the data is NaN.
         """
 
-        # Apply downsampling if configured
-        if self.downsample_num_element is not None:
-            positions, radii = self._downsample_data(positions, radii)
-
         spline = self.object.data.splines[0]
         if positions is not None:
             _validate_position(positions)
+            positions = self._downsample_data(positions, self.downsample_num_element)
             for i, point in enumerate(spline.bezier_points):
                 x, y, z = positions[:, i]
                 point.co = (x, y, z)
         if radii is not None:
             _validate_radii(radii)
+            _radii = np.concatenate([radii, [0]])
+            _radii[1:] += radii
+            _radii[1:-1] /= 2.0
+            radii = self._downsample_data(_radii, self.downsample_num_element)
             for i, point in enumerate(spline.bezier_points):
                 point.radius = radii[i]
 
     def _downsample_data(
-        self, positions: NDArray, radii: NDArray
-    ) -> tuple[NDArray, NDArray]:
-        """
-        Downsamples the positions and radii arrays to the specified number of elements.
-        Always includes both endpoints (first and last points).
-
-        Parameters
-        ----------
-        positions : NDArray
-            The position array to downsample. Shape: (3, n)
-        radii : NDArray
-            The radius array to downsample. Shape: (n,)
-        num_elements : int
-            The target number of elements after downsampling.
-
-        Returns
-        -------
-        tuple[NDArray, NDArray]
-            Downsampled positions and radii arrays.
-        """
-        num_elements = self.downsample_num_element
-        if positions.shape[1] <= num_elements:
-            # No downsampling needed
-            # TODO: should we just raise error, or interpolate the positions and radii?
-            return positions, radii
+        self, vector: NDArray, num_elements: int
+        ) -> NDArray:
+        if vector.shape[-1] <= num_elements:
+            return vector
 
         t = np.linspace(0, 1, num_elements)
-        t_old = np.linspace(0, 1, positions.shape[1])
-        new_positions = np.empty((3, num_elements))
-        new_positions[0, :] = np.interp(t, t_old, positions[0, :])
-        new_positions[1, :] = np.interp(t, t_old, positions[1, :])
-        new_positions[2, :] = np.interp(t, t_old, positions[2, :])
-        new_radii = np.interp(t, t_old, radii)
-
-        return new_positions, new_radii
+        t_old = np.linspace(0, 1, vector.shape[-1])
+        return interp1d(t_old, vector, axis=-1)(t)
 
     def _create_bezier_spline(
-        self, number_of_points: int, handle_type: str = "AUTO"
+        self, number_of_points: int,
     ) -> bpy.types.Object:
         """
         Creates a new pipe object.
@@ -244,9 +201,6 @@ def _create_bezier_spline(
         ----------
         number_of_points : int
             The number of points in the pipe.
-        handle_type : str, optional
-            The handle type for Bezier points. Options: "AUTO", "VECTOR", "SMOOTH"
-            Default is "AUTO" for smoother pipe appearance.
         """
         # Create a new curve
         curve_data = bpy.data.curves.new(name="spline_curve", type="CURVE")
@@ -260,12 +214,12 @@ def _create_bezier_spline(
         # Set the spline points and radii
         for i in range(number_of_points):
             point = spline.bezier_points[i]
-            point.handle_left_type = point.handle_right_type = handle_type
+            point.handle_left_type = point.handle_right_type = "FREE"
 
         # Create a new object with the curve data
         curve_object = bpy.data.objects.new("spline_curve_object", curve_data)
         curve_object.data.resolution_u = 1
-        curve_object.data.render_resolution_u = 1
+        # curve_object.data.render_resolution_u = 1
         bpy.context.collection.objects.link(curve_object)
 
         # Create a bevel object for the pipe profile
@@ -279,7 +233,7 @@ def _create_bezier_spline(
         bevel_circle = bpy.context.object
         bevel_circle.name = "bevel_circle"
         # Set resolution for smoother bevel profile
-        bevel_circle.data.resolution_u = 1
+        bevel_circle.data.resolution_u = 8
         # Hide the bevel circle object in the viewport and render
         bevel_circle.hide_viewport = True
         bevel_circle.hide_render = True
@@ -300,8 +254,14 @@ def update_keyframe(self, keyframe: int) -> None:
         keyframe : int
         """
         spline = self.object.data.splines[0]
+
         for i, point in enumerate(spline.bezier_points):
-            point.keyframe_insert(data_path="co", frame=keyframe)
+            # This is to reset the left/right handle for each bezier curve points
+            point.handle_left_type = "AUTO"
+            point.handle_right_type = "AUTO"
+            point.keyframe_insert(data_path="handle_left", frame=keyframe)
+            point.keyframe_insert(data_path="handle_right", frame=keyframe)
+            point.keyframe_insert(data_path="co", frame=keyframe)  # Coordinate
             point.keyframe_insert(data_path="radius", frame=keyframe)
         self.material.keyframe_insert(data_path="diffuse_color", frame=keyframe)