Merge pull request #8 from LIHPC-Computational-Geometry/chore/use-model-class

Chore/use model class

Author: Ludofr3

bot/core/curve.py

@@ -1,4 +1,4 @@
-import nurbslib
+import ferrispline as ferr
 import numpy as np
 
 
@@ -10,7 +10,7 @@ class BezierCurve:
     def __init__(self, tag: str, control_points: list[list[float]], degree: int):
         self.tag = tag
         cp_array = np.array(control_points, dtype=np.float64)
-        self._engine = nurbslib.PyBezierCurve(degree, cp_array, None)
+        self._engine = ferr.PyBezierCurve(degree, cp_array, None)
 
     @staticmethod
     def _default_control_points(coords_a, coords_b, degree=3):
@@ -51,7 +51,7 @@ def get_degree(self):
     def set_control_points(self, control_points: list[list[float]]):
         """Replace the internal curve engine with updated control points."""
         cp_array = np.array(control_points, dtype=np.float64)
-        self._engine = nurbslib.PyBezierCurve(self.get_degree(), cp_array, None)
+        self._engine = ferr.PyBezierCurve(self.get_degree(), cp_array, None)
 
     def get_render_data(self) -> dict:
         curve_pts = self._engine.evaluate(100, False)

bot/core/spline.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import ferrispline
+import numpy as np
+
+
+class SplineModel:
+    """
+    Public curve wrapper backed by ferrispline.PyModel.
+
+    The public methods intentionally mirror the old BezierCurve contract to keep
+    existing model/viewer behavior unchanged during migration.
+    """
+
+    def __init__(self, tag: str, control_points: list[list[float]], degree: int):
+        super().__init__()
+        self.tag = str(tag)
+        self._degree = int(degree)
+        self._model = ferrispline.PyModel()
+        self._curve_id: str | None = None
+        self._control_points_cache: list[list[float]] = []
+        self.set_control_points(control_points)
+
+    @staticmethod
+    def _default_control_points(coords_a, coords_b, degree=3):
+        points = []
+
+        if degree == 0:
+            return [coords_a]
+
+        num_points = degree + 1
+        for i in range(num_points):
+            t = i / degree
+            current_point = [a + (b - a) * t for a, b in zip(coords_a, coords_b)]
+            points.append(current_point)
+
+        return points
+
+    def get_tag(self):
+        return self.tag
+
+    def get_control_points(self):
+        return [list(pt) for pt in self._control_points_cache]
+
+    def get_degree(self):
+        return self._degree
+
+    def set_control_points(self, control_points: list[list[float]]):
+        cp_array = np.array(control_points, dtype=np.float64)
+        self._control_points_cache = cp_array.tolist()
+        self._curve_id = self._model.create_bezier(self._degree, cp_array, None)
+
+    def _evaluate(self, sample: int):
+        if self._curve_id is None:
+            return np.empty((0, 3), dtype=np.float64)
+        curve_pts = self._model.evaluate(self._curve_id, int(sample))
+        if (
+            len(curve_pts.shape) == 2
+            and curve_pts.shape[0] in (2, 3)
+            and curve_pts.shape[1] > 3
+        ):
+            curve_pts = curve_pts.T
+        return curve_pts
+
+    def get_render_data(self) -> dict:
+        curve_pts = self._evaluate(100)
+        return {
+            "tag": self.tag,
+            "control_points": self.get_control_points(),
+            "degree": self.get_degree(),
+            "curve": curve_pts.tolist(),
+        }

bot/view/curve_app.py

@@ -13,8 +13,8 @@
     LineSegs,
     NodePath,
 )
-import nurbslib
 import numpy as np
+from bot.core.spline import SplineModel
 
 MASK_CURVE_PICK = BitMask32.bit(1)
 MASK_CP_PICK = BitMask32.bit(2)
@@ -251,10 +251,8 @@ def preview_control_point(self, cp_index: int, new_pos: List[float]):
         self.control_points[cp_index] = [new_pos[0], new_pos[1], new_pos[2]]
 
         if self.type == "bezier" and self.degree is not None:
-            cp_array = np.array(self.control_points, dtype=np.float64)
-            engine = nurbslib.PyBezierCurve(int(self.degree), cp_array, None)
-
-            pts = engine.evaluate(100, False)
+            engine = SplineModel(str(self.tag), self.control_points, int(self.degree))
+            pts = np.array(engine.get_render_data()["curve"], dtype=np.float64)
             if len(pts.shape) == 2 and pts.shape[0] in (2, 3) and pts.shape[1] > 3:
                 pts = pts.T
 

bot/viewer/viewer.py

@@ -12,7 +12,7 @@
 import threading
 from typing import Any, Callable, Optional, TYPE_CHECKING
 
-from bot.core.curve import BezierCurve
+from bot.core.spline import SplineModel
 
 if TYPE_CHECKING:
     from bot.core.cad import Model
@@ -333,10 +333,10 @@ def bezier_conversion(self, degree: int):
             tag = int(self._default_last_hovered)
             if self.model is not None:
                 coords_a, coords_b = self.model.get_end_points_coords(int(tag))
-                control_points = BezierCurve._default_control_points(
+                control_points = SplineModel._default_control_points(
                     coords_a, coords_b, degree
                 )
-                curve = BezierCurve(tag, control_points, degree)
+                curve = SplineModel(tag, control_points, degree)
                 self.model.set_curve(tag, curve)
             else:
                 self.set_hud_text("Impossible to convert: no model loaded")

ferrispline

@@ -8,15 +8,15 @@ requires-python = ">=3.14"
 dependencies = [
     "gmsh>=4.15.0",
     "ipython>=9.10.0",
-    "nurbslib",
+    "ferrispline",
     "panda3d>=1.10.16",
 ]
 
 [tool.uv]
 package = true
 
 [tool.uv.sources]
-nurbslib = { path = "ferrispline/nurbslib" }
+ferrispline = { path = "ferrispline/python" }
 
 [build-system]
 requires = ["hatchling"]

pyproject.toml

@@ -1,43 +1,43 @@
 """
-Unit tests for bot.core.curve.BezierCurve.
+Unit tests for bot.core.curve.SplineModel.
 
-The external Rust dependency (nurbslib) is mocked to allow testing the
+The external Rust dependency (ferrispline) is mocked to allow testing the
 Python bridge and logic without requiring the compiled engine.
 """
 
 import unittest
 from unittest.mock import MagicMock, patch
 import numpy as np
 
-from bot.core.curve import BezierCurve
+from bot.core.spline import SplineModel
 
 
-class TestBezierCurve(unittest.TestCase):
-    @patch("bot.core.curve.nurbslib")
+class TestSplineModel(unittest.TestCase):
+    @patch("bot.core.spline.ferrispline")
     def test_initialization_and_attributes(self, mock_nurbslib):
         """Tests the initialization of the curve and access to its basic attributes."""
         # 1. Data preparation
         tag = "curve_1"
         control_points = [[0.0, 0.0, 0.0], [5.0, 5.0, 0.0], [10.0, 0.0, 0.0]]
         degree = 2
 
-        # 2. Mock configuration to simulate the nurbslib engine
-        mock_engine_instance = MagicMock()
-        mock_engine_instance.get_control_points.return_value = np.array(control_points)
-        mock_engine_instance.get_degree.return_value = degree
-        mock_nurbslib.PyBezierCurve.return_value = mock_engine_instance
+        # 2. Mock configuration to simulate the ferrispline engine
+        mock_model_instance = MagicMock()
+        mock_model_instance.create_bezier.return_value = "curve-1"
+        mock_model_instance.evaluate.return_value = np.array(control_points)
+        mock_nurbslib.PyModel.return_value = mock_model_instance
 
         # 3. Object creation
-        curve = BezierCurve(tag, control_points, degree)
+        curve = SplineModel(tag, control_points, degree)
 
         # 4. Verifications (Assertions)
         self.assertEqual(curve.get_tag(), "curve_1")
         self.assertEqual(curve.get_control_points(), control_points)
         self.assertEqual(curve.get_degree(), degree)
 
-        # Ensure the Rust engine was called with the correct arguments
-        mock_nurbslib.PyBezierCurve.assert_called_once()
-        args, kwargs = mock_nurbslib.PyBezierCurve.call_args
+        # Ensure the Rust model was called with the correct arguments
+        mock_nurbslib.PyModel.assert_called_once()
+        args, kwargs = mock_model_instance.create_bezier.call_args
         self.assertEqual(args[0], degree)
         np.testing.assert_array_equal(args[1], np.array(control_points))
         self.assertIsNone(args[2])
@@ -48,7 +48,7 @@ def test_default_control_points_default_degree(self):
         coords_b = [30.0, 0.0, 0.0]
 
         # Call WITHOUT specifying the degree
-        pts = BezierCurve._default_control_points(coords_a, coords_b)
+        pts = SplineModel._default_control_points(coords_a, coords_b)
 
         # Since the default degree is 3, we expect 3 + 1 = 4 points
         expected_pts = [
@@ -67,7 +67,7 @@ def test_default_control_points_distribution(self):
         degree = 2
 
         # Execute static method
-        pts = BezierCurve._default_control_points(coords_a, coords_b, degree)
+        pts = SplineModel._default_control_points(coords_a, coords_b, degree)
 
         # We expect 3 points: point A, middle point, and point B
         expected_pts = [[0.0, 0.0, 0.0], [5.0, 0.0, 0.0], [10.0, 0.0, 0.0]]
@@ -80,21 +80,21 @@ def test_default_control_points_count(self):
 
         # We check for several different degrees
         for degree in [1, 3, 5, 10]:
-            pts = BezierCurve._default_control_points(coords_a, coords_b, degree)
+            pts = SplineModel._default_control_points(coords_a, coords_b, degree)
             self.assertEqual(len(pts), degree + 1)
 
     def test_default_control_points_degree_zero(self):
         """Tests the edge case where the curve degree is 0."""
         coords_a = [1.0, 2.0, 3.0]
         coords_b = [4.0, 5.0, 6.0]
 
-        pts = BezierCurve._default_control_points(coords_a, coords_b, degree=0)
+        pts = SplineModel._default_control_points(coords_a, coords_b, degree=0)
 
         # For degree 0, there must be only one point (point A)
         self.assertEqual(len(pts), 1)
         self.assertEqual(pts[0], coords_a)
 
-    @patch("bot.core.curve.nurbslib")
+    @patch("bot.core.spline.ferrispline")
     def test_get_render_data(self, mock_nurbslib):
         """Tests the structure and content of the render dictionary (used by the viewer)."""
         tag = "42"
@@ -105,14 +105,13 @@ def test_get_render_data(self, mock_nurbslib):
         mock_curve_eval = [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [1.0, 1.0, 1.0]]
 
         # Mock configuration
-        mock_engine_instance = MagicMock()
-        mock_engine_instance.get_control_points.return_value = np.array(control_points)
-        mock_engine_instance.get_degree.return_value = degree
-        mock_engine_instance.evaluate.return_value = np.array(mock_curve_eval)
-        mock_nurbslib.PyBezierCurve.return_value = mock_engine_instance
+        mock_model_instance = MagicMock()
+        mock_model_instance.create_bezier.return_value = "curve-42"
+        mock_model_instance.evaluate.return_value = np.array(mock_curve_eval)
+        mock_nurbslib.PyModel.return_value = mock_model_instance
 
         # Object creation and data retrieval
-        curve = BezierCurve(tag, control_points, degree)
+        curve = SplineModel(tag, control_points, degree)
         data = curve.get_render_data()
 
         # Verification of the presence of all required keys
@@ -128,7 +127,7 @@ def test_get_render_data(self, mock_nurbslib):
         self.assertEqual(data["curve"], mock_curve_eval)
 
         # Ensure the engine was called to generate 100 points
-        mock_engine_instance.evaluate.assert_called_once_with(100, False)
+        mock_model_instance.evaluate.assert_called_once_with("curve-42", 100)
 
 
 if __name__ == "__main__":

tests/unit/test_curve/test_bezier-curve.py

@@ -249,8 +249,8 @@ def _make_viewer_with_mocks(self):
 
         return viewer
 
-    @patch("bot.viewer.viewer.BezierCurve")
-    def test_bezier_conversion_success(self, MockBezierCurve):
+    @patch("bot.viewer.viewer.SplineModel")
+    def test_bezier_conversion_success(self, MockSplineModel):
         """Verifies the conversion of a classic curve into a Bezier curve."""
         viewer = self._make_viewer_with_mocks()
 
@@ -262,27 +262,27 @@ def test_bezier_conversion_success(self, MockBezierCurve):
         viewer.model.get_end_points_coords.return_value = [coords_a, coords_b]
 
         # Mock configuration for the static method _default_control_points
-        MockBezierCurve._default_control_points.return_value = [
+        MockSplineModel._default_control_points.return_value = [
             coords_a,
             [3.3, 0, 0],
             [6.6, 0, 0],
             coords_b,
         ]
 
-        # Configuration of the mocked instance returned by BezierCurve(...)
+        # Configuration of the mocked instance returned by SplineModel(...)
         mock_curve_instance = MagicMock()
-        MockBezierCurve.return_value = mock_curve_instance
+        MockSplineModel.return_value = mock_curve_instance
 
         # Method call
         viewer.bezier_conversion(degree)
 
         # Assertions
         viewer.model.get_end_points_coords.assert_called_once_with(42)
-        MockBezierCurve._default_control_points.assert_called_once_with(
+        MockSplineModel._default_control_points.assert_called_once_with(
             coords_a, coords_b, degree
         )
-        MockBezierCurve.assert_called_once_with(
-            42, MockBezierCurve._default_control_points.return_value, degree
+        MockSplineModel.assert_called_once_with(
+            42, MockSplineModel._default_control_points.return_value, degree
         )
         viewer.model.set_curve.assert_called_once_with(42, mock_curve_instance)