feat: NURBS and TrimmedCurve enhancements (#1994)

Co-authored-by: Jacob Kerstetter <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: pyansys-ci-bot <[email protected]>
Co-authored-by: Roberto Pastor Muela <[email protected]>

Author: 4 people

doc/changelog.d/1994.added.md

@@ -0,0 +1 @@
+Nurbs and trimmedcurve enhancements

src/ansys/geometry/core/math/vector.py

@@ -159,7 +159,7 @@ def transform(self, matrix: "Matrix44") -> "Vector3D":
         transformation matrix and return a new ``Vector3D`` object representing the
         transformed vector.
         """
-        vector_4x1 = np.append(self, 1)
+        vector_4x1 = np.append(self, 0)
         result_4x1 = matrix * vector_4x1
         result_vector = Vector3D(result_4x1[0:3])
         return result_vector

src/ansys/geometry/core/shapes/curves/circle.py

@@ -163,6 +163,7 @@ def transformed_copy(self, matrix: Matrix44) -> "Circle":
         new_point = self.origin.transform(matrix)
         new_reference = self._reference.transform(matrix)
         new_axis = self._axis.transform(matrix)
+
         return Circle(
             new_point,
             self.radius,

src/ansys/geometry/core/shapes/curves/nurbs.py

@@ -25,6 +25,7 @@
 from typing import TYPE_CHECKING, Optional
 
 from beartype import beartype as check_input_types
+import numpy as np
 
 from ansys.geometry.core.math import Matrix44, Point3D
 from ansys.geometry.core.math.vector import Vector3D
@@ -141,6 +142,54 @@ def from_control_points(
 
         return curve
 
+    @classmethod
+    @check_input_types
+    def fit_curve_from_points(
+        cls,
+        points: list[Point3D],
+        degree: int,
+    ) -> "NURBSCurve":
+        """Fit a NURBS curve to a set of points.
+
+        Parameters
+        ----------
+        points : list[Point3D]
+            Points to fit the curve to.
+        degree : int
+            Degree of the curve.
+
+        Returns
+        -------
+        NURBSCurve
+            Fitted NURBS curve.
+
+        """
+        from geomdl import fitting
+
+        # Convert points to a format suitable for the fitting function
+        converted_points = []
+        for pt in points:
+            pt_raw = [*pt]
+            converted_points.append(pt_raw)
+
+        # Fit the curve to the points
+        curve = fitting.interpolate_curve(converted_points, degree)
+
+        # Construct the NURBSCurve object
+        nurbs_curve = cls()
+        nurbs_curve._nurbs_curve.degree = curve.degree
+        nurbs_curve._nurbs_curve.ctrlpts = [Point3D(entry) for entry in curve.ctrlpts]
+        nurbs_curve._nurbs_curve.knotvector = curve.knotvector
+        nurbs_curve._nurbs_curve.weights = curve.weights
+
+        # Verify the curve is valid
+        try:
+            nurbs_curve._nurbs_curve._check_variables()
+        except ValueError as e:
+            raise ValueError(f"Invalid NURBS curve: {e}")
+
+        return nurbs_curve
+
     def __eq__(self, other: "NURBSCurve") -> bool:
         """Determine if two curves are equal."""
         if not isinstance(other, NURBSCurve):
@@ -164,8 +213,8 @@ def parameterization(self) -> Parameterization:
             Information about how the NURBS curve is parameterized.
         """
         return Parameterization(
-            ParamType.OTHER,
             ParamForm.OTHER,
+            ParamType.OTHER,
             Interval(start=self._nurbs_curve.domain[0], end=self._nurbs_curve.domain[1]),
         )
 
@@ -182,7 +231,12 @@ def transformed_copy(self, matrix: Matrix44) -> "NURBSCurve":
         NURBSCurve
             Transformed copy of the curve.
         """
-        control_points = [matrix @ point for point in self._nurbs_curve.ctrlpts]
+        control_points = []
+        for point in self._nurbs_curve.ctrlpts:
+            # Transform the control point using the transformation matrix
+            transformed_point = matrix @ np.array([*point, 1])
+            control_points.append(Point3D(transformed_point[:3]))
+
         return NURBSCurve.from_control_points(
             control_points,
             self._nurbs_curve.degree,

src/ansys/geometry/core/shapes/curves/trimmed_curve.py

@@ -27,8 +27,10 @@
 from ansys.api.geometry.v0.commands_pb2_grpc import CommandsStub
 from ansys.geometry.core.connection.client import GrpcClient
 from ansys.geometry.core.connection.conversions import trimmed_curve_to_grpc_trimmed_curve
+from ansys.geometry.core.math.matrix import Matrix44
 from ansys.geometry.core.math.point import Point3D
-from ansys.geometry.core.misc.measurements import DEFAULT_UNITS
+from ansys.geometry.core.math.vector import UnitVector3D, Vector3D
+from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Angle, Distance
 from ansys.geometry.core.shapes.curves.curve import Curve
 from ansys.geometry.core.shapes.curves.curve_evaluation import CurveEvaluation
 from ansys.geometry.core.shapes.parameterization import Interval
@@ -151,6 +153,90 @@ def intersect_curve(self, other: "TrimmedCurve") -> list[Point3D]:
             for point in res.points
         ]
 
+    def transformed_copy(self, matrix: Matrix44) -> "TrimmedCurve":
+        """Return a copy of the trimmed curve transformed by the given matrix.
+
+        Parameters
+        ----------
+        matrix : Matrix44
+            Transformation matrix to apply to the curve.
+
+        Returns
+        -------
+        TrimmedCurve
+            A new trimmed curve with the transformation applied.
+        """
+        transformed_geometry = self.geometry.transformed_copy(matrix)
+        transformed_start = self.start.transform(matrix)
+        transformed_end = self.end.transform(matrix)
+
+        return TrimmedCurve(
+            transformed_geometry,
+            transformed_start,
+            transformed_end,
+            self.interval,
+            self.length,
+        )
+
+    def translate(self, direction: UnitVector3D, distance: Real | Quantity | Distance) -> None:
+        """Translate the trimmed curve by a given vector and distance.
+
+        Parameters
+        ----------
+        direction : UnitVector3D
+            Direction of translation.
+        distance : Real | Quantity | Distance
+            Distance to translate.
+        """
+        distance = distance if isinstance(distance, Distance) else Distance(distance)
+        translation_matrix = Matrix44.create_translation(direction * distance.value.m)
+
+        translated_copy = self.transformed_copy(translation_matrix)
+
+        # Update the current instance with the translated copy
+        self._geometry = translated_copy.geometry
+        self._start = translated_copy.start
+        self._end = translated_copy.end
+        self._length = translated_copy.length
+        self._interval = translated_copy.interval
+
+    def rotate(self, origin: Point3D, axis: UnitVector3D, angle: Real | Quantity | Angle) -> None:
+        """Rotate the trimmed curve around a given axis centered at a given point.
+
+        Parameters
+        ----------
+        origin : Point3D
+            Origin point of the rotation.
+        axis : UnitVector3D
+            Axis of rotation.
+        angle : Real | Quantity | Angle
+            Angle to rotate in radians.
+        """
+        angle = angle if isinstance(angle, Angle) else Angle(angle)
+
+        # Translate the curve to the origin
+        translate_to_origin_matrix = Matrix44.create_translation(
+            Vector3D([-origin.x.m, -origin.y.m, -origin.z.m])
+        )
+        translated_copy = self.transformed_copy(translate_to_origin_matrix)
+
+        # Rotate the curve around the axis
+        rotation_matrix = Matrix44.create_matrix_from_rotation_about_axis(axis, angle.value.m)
+        rotated_copy = translated_copy.transformed_copy(rotation_matrix)
+
+        # Translate the curve back to its original position
+        translate_back_matrix = Matrix44.create_translation(
+            Vector3D([origin.x.m, origin.y.m, origin.z.m])
+        )
+        translated_back_copy = rotated_copy.transformed_copy(translate_back_matrix)
+
+        # Update the current instance with the rotated copy
+        self._geometry = translated_back_copy.geometry
+        self._start = translated_back_copy.start
+        self._end = translated_back_copy.end
+        self._length = translated_back_copy.length
+        self._interval = translated_back_copy.interval
+
     def __repr__(self) -> str:
         """Represent the trimmed curve as a string."""
         return (

tests/integration/test_trimmed_geometry.py

@@ -41,19 +41,16 @@
 )
 from ansys.geometry.core.sketch.sketch import Sketch
 
-"""A helper function to create a sketch line given two points and a design."""
-
 
 def create_sketch_line(design: Design, p1: Point3D, p2: Point3D):
+    """A helper function to create a sketch line given two points and a design."""
     point1 = point3d_to_grpc_point(p1)
     point2 = point3d_to_grpc_point(p2)
     design._commands_stub.CreateSketchLine(CreateSketchLineRequest(point1=point1, point2=point2))
 
 
-"""A helper function that creates the Hedgehog model."""
-
-
 def create_hedgehog(modeler: Modeler):
+    """A helper function that creates the Hedgehog model."""
     design = modeler.create_design("Hedgehog")
     sketch = Sketch().arc_from_three_points(
         Point2D([0.01, 0.01]), Point2D([0, -0.005]), Point2D([-0.01, 0.01])
@@ -97,19 +94,15 @@ def create_hedgehog(modeler: Modeler):
     return design
 
 
-"""A fixture of the hedgehog design to test the surface and curve properties individually."""
-
-
 @pytest.fixture
 def hedgehog_design(modeler: Modeler):
+    """A fixture of the hedgehog design to test the surface and curve properties individually."""
     h = create_hedgehog(modeler)
     yield h
 
 
-"""Tests the surface properties for the hedgehog design."""
-
-
 def test_trimmed_surface_properties(hedgehog_design):
+    """Tests the surface properties for the hedgehog design."""
     hedgehog_body = hedgehog_design.bodies[0]
     faces = hedgehog_body.faces
 
@@ -161,10 +154,8 @@ def test_trimmed_surface_properties(hedgehog_design):
         assert faces[i].shape.box_uv.interval_v == Interval(start=interval_v[0], end=interval_v[1])
 
 
-"""Tests the normal vectors for the hedgehog design using the BoxUV coordinates."""
-
-
 def test_trimmed_surface_normals(hedgehog_design):
+    """Tests the normal vectors for the hedgehog design using the BoxUV coordinates."""
     hedgehog_body = hedgehog_design.bodies[0]
     faces = hedgehog_body.faces
     # corners to consider
@@ -219,10 +210,8 @@ def test_trimmed_surface_normals(hedgehog_design):
         assert np.allclose(faces[i].shape.normal(corner_param.u, corner_param.v), bottom_right)
 
 
-"""Tests the curve properties for the hedgehog design."""
-
-
 def test_trimmed_curve_properties(hedgehog_design):
+    """Tests the curve properties for the hedgehog design."""
     hedgehog_body = hedgehog_design.bodies[0]
     edges = hedgehog_body.edges
 
@@ -245,3 +234,73 @@ def test_trimmed_curve_properties(hedgehog_design):
         assert isinstance(edges[i].shape.geometry, geometry_type)
         assert np.allclose(edges[i].shape.start, Point3D(start))
         assert np.allclose(edges[i].shape.end, Point3D(end))
+
+
+def test_trimmed_curve_line_translate(hedgehog_design):
+    """Tests the translation of a trimmed curve with line geometry."""
+    hedgehog_body = hedgehog_design.bodies[0]
+    edges = hedgehog_body.edges
+    edge = edges[1]
+    trimmed_curve = edge.shape
+
+    assert isinstance(trimmed_curve, TrimmedCurve)
+    assert trimmed_curve.start == Point3D([0.01, 0.01, 0.0])
+    assert trimmed_curve.end == Point3D([0.01, 0.01, 0.02])
+
+    trimmed_curve.translate(UnitVector3D([1, 0, 0]), 0.01)
+
+    assert trimmed_curve.start == Point3D([0.02, 0.01, 0.0])
+    assert trimmed_curve.end == Point3D([0.02, 0.01, 0.02])
+
+
+def test_trimmed_curve_line_rotate(hedgehog_design):
+    """Tests the rotation of a trimmed curve with line geometry."""
+    hedgehog_body = hedgehog_design.bodies[0]
+    edges = hedgehog_body.edges
+    edge = edges[1]
+    trimmed_curve = edge.shape
+
+    assert isinstance(trimmed_curve, TrimmedCurve)
+    assert trimmed_curve.start == Point3D([0.01, 0.01, 0.0])
+    assert trimmed_curve.end == Point3D([0.01, 0.01, 0.02])
+
+    # Rotate the curve in the x-direction by 90 degrees about the point (0.01, 0.01, 0.0)
+    trimmed_curve.rotate(Point3D([0.01, 0.01, 0.0]), UnitVector3D([1, 0, 0]), np.pi / 2)
+
+    assert np.allclose(trimmed_curve.start, Point3D([0.01, 0.01, 0.0]))
+    assert np.allclose(trimmed_curve.end, Point3D([0.01, -0.01, 0.0]))
+
+
+def test_trimmed_curve_circle_translate(hedgehog_design):
+    """Tests the rotation of a trimmed curve with circle geometry."""
+    hedgehog_body = hedgehog_design.bodies[0]
+    edges = hedgehog_body.edges
+    edge = edges[0]
+    trimmed_curve = edge.shape
+
+    assert isinstance(trimmed_curve, TrimmedCurve)
+    assert np.allclose(trimmed_curve.start, Point3D([0.01, 0.01, 0.02]))
+    assert np.allclose(trimmed_curve.end, Point3D([-0.01, 0.01, 0.02]))
+
+    trimmed_curve.translate(UnitVector3D([1, 0, 0]), 0.01)
+
+    assert np.allclose(trimmed_curve.start, Point3D([0.02, 0.01, 0.02]))
+    assert np.allclose(trimmed_curve.end, Point3D([0.0, 0.01, 0.02]))
+
+
+def test_trimmed_curve_circle_rotate(hedgehog_design):
+    """Tests the rotation of a trimmed curve with circle geometry."""
+    hedgehog_body = hedgehog_design.bodies[0]
+    edges = hedgehog_body.edges
+    edge = edges[0]
+    trimmed_curve = edge.shape
+
+    assert isinstance(trimmed_curve, TrimmedCurve)
+    assert np.allclose(trimmed_curve.start, Point3D([0.01, 0.01, 0.02]))
+    assert np.allclose(trimmed_curve.end, Point3D([-0.01, 0.01, 0.02]))
+
+    # Rotate the curve in the x-direction by 90 degrees about the point (0.01, 0.01, 0.02)
+    trimmed_curve.rotate(Point3D([0.01, 0.01, 0.02]), UnitVector3D([0, 1, 0]), np.pi / 2)
+
+    assert np.allclose(trimmed_curve.start, Point3D([0.01, 0.01, 0.02]))
+    assert np.allclose(trimmed_curve.end, Point3D([0.01, 0.01, 0.04]))

tests/test_primitives.py

@@ -961,6 +961,33 @@ def test_nurbs_curve_from_control_points():
     assert nurbs_curve != nurbs_curve_weights
 
 
+def test_nurbs_curve_fitting():
+    """Test ``NURBSCurve`` fitting."""
+    points = [
+        Point3D([0, 0, 0]),
+        Point3D([1, 1, 0]),
+        Point3D([2, 0, 0]),
+        Point3D([5, 2, 0]),
+    ]
+    degree = 3
+    nurbs_curve = NURBSCurve.fit_curve_from_points(points=points, degree=degree)
+
+    # Verify degree, knots, and control points
+    assert nurbs_curve.degree == degree
+
+    assert len(nurbs_curve.knots) == 8
+
+    assert len(nurbs_curve.control_points) == 4
+    assert np.allclose(nurbs_curve.control_points[0], Point3D([0, 0, 0]))
+    assert np.allclose(
+        nurbs_curve.control_points[1], Point3D([1.54969033497753, 4.03483016710592, 0])
+    )
+    assert np.allclose(
+        nurbs_curve.control_points[2], Point3D([2.87290323505786, -5.66639579939497, 0])
+    )
+    assert np.allclose(nurbs_curve.control_points[3], Point3D([5, 2, 0]))
+
+
 def test_nurbs_curve_evaluation():
     """Test ``NURBSCurve`` evaluation."""
     control_points = [