nurbs surfaces working and tested

Author: jacobrkerstetter

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

@@ -237,32 +237,45 @@ def __eq__(self, other: "NURBSSurface") -> bool:
             and self._nurbs_surface.weights == other._nurbs_surface.weights
         )
 
-    def parameterization(self) -> Parameterization:
+    def parameterization(self) -> tuple[Parameterization, Parameterization]:
         """Get the parametrization of the NURBS surface.
 
         The parameter is defined in the interval [0, 1] by default. Information
         is provided about the parameter type and form.
 
         Returns
         -------
-        Parameterization
-            Information about how the NURBS surface is parameterized.
+        tuple[Parameterization, Parameterization]
+            Parameterization in the U and V directions respectively.
         """
-        return Parameterization(
-            ParamForm.OTHER,
-            ParamType.OTHER,
-            Interval(start=self._nurbs_surface.domain[0], end=self._nurbs_surface.domain[1]),
+        return (
+            Parameterization(
+                ParamForm.OTHER,
+                ParamType.OTHER,
+                Interval(
+                    start=self._nurbs_surface.domain[0][0],
+                    end=self._nurbs_surface.domain[0][1]
+                ),
+            ),
+            Parameterization(
+                ParamForm.OTHER,
+                ParamType.OTHER,
+                Interval(
+                    start=self._nurbs_surface.domain[1][0],
+                    end=self._nurbs_surface.domain[1][1],
+                ),
+            ),
         )
 
     def transformed_copy(self, matrix: Matrix44) -> "NURBSSurface":  # noqa: D102
         raise NotImplementedError("transformed_copy() is not implemented.")
 
-    def evaluate(self, parameter: Real) -> SurfaceEvaluation:
+    def evaluate(self, parameter: ParamUV) -> SurfaceEvaluation:
         """Evaluate the surface at the given parameter.
 
         Parameters
         ----------
-        parameter : Real
+        parameter : ParamUV
             Parameter to evaluate the surface at.
 
         Returns
@@ -272,7 +285,7 @@ def evaluate(self, parameter: Real) -> SurfaceEvaluation:
         """
         return NURBSSurfaceEvaluation(self, parameter)
 
-    def contains_param(self, param: Real) -> bool:  # noqa: D102
+    def contains_param(self, param: ParamUV) -> bool:  # noqa: D102
         raise NotImplementedError("contains_param() is not implemented.")
 
     def contains_point(self, point: Point3D) -> bool:  # noqa: D102
@@ -297,15 +310,26 @@ def __init__(self, nurbs_surface: NURBSSurface, parameter: ParamUV) -> None:
         """Initialize the ``NURBSsurfaceEvaluation`` class."""
         self._surface = nurbs_surface
         self._parameter = parameter
-        self._derivatives = nurbs_surface.geomdl_nurbs_surface.derivatives(parameter.u, parameter.v, 2)
+
+        u, v = parameter.u, parameter.v
+        domain = nurbs_surface._nurbs_surface.domain
+        u_start, u_end = domain[0][0], domain[0][1]
+        v_start, v_end = domain[1][0], domain[1][1]
+        
+        if not (u_start <= u <= u_end and v_start <= v <= v_end):
+            raise ValueError(
+                f"Parameter [u={u}, v={v}] is outside the surface domain: "
+                f"U[{u_start}, {u_end}], V[{v_start}, {v_end}]"
+            )
+        self._derivatives = nurbs_surface.geomdl_nurbs_surface.derivatives(u, v, 2)
 
     @property
     def surface(self) -> "NURBSSurface":
         """Surface being evaluated."""
         return self._surface
 
     @property
-    def parameter_u(self) -> ParamUV:
+    def parameter(self) -> ParamUV:
         """Parameter the evaluation is based upon."""
         return self._parameter
 
@@ -330,9 +354,10 @@ def normal(self) -> UnitVector3D:
             Normal to the surface at this evaluation.
         """
         from geomdl.operations import normal
-        return UnitVector3D(
-            normal(self._surface.geomdl_nurbs_surface, [self._parameter.u, self._parameter.v])
-        )
+        uv = [float(self._parameter.u), float(self._parameter.v)]
+        result = normal(self._surface.geomdl_nurbs_surface, uv)
+
+        return UnitVector3D(result[1])
 
     @cached_property
     def u_derivative(self) -> Vector3D:
@@ -407,4 +432,5 @@ def max_curvature(self) -> Real:
     @cached_property
     def max_curvature_direction(self) -> UnitVector3D:
         """Maximum curvature direction."""
-        raise NotImplementedError("max_curvature_direction() is not implemented.")
+        raise NotImplementedError("max_curvature_direction() is not implemented.")
+    

tests/test_primitives.py

@@ -22,7 +22,6 @@
 
 from beartype.roar import BeartypeCallHintParamViolation
 import geomdl
-from geomdl.visualization import VisMPL
 import numpy as np
 from pint import Quantity
 import pytest
@@ -53,7 +52,7 @@
     ParamForm,
     ParamType,
 )
-from ansys.geometry.core.shapes.surfaces.nurbs import NURBSSurface
+from ansys.geometry.core.shapes.surfaces.nurbs import NURBSSurface, NURBSSurfaceEvaluation
 from ansys.geometry.core.shapes.surfaces.sphere import SphereEvaluation
 
 
@@ -1664,3 +1663,143 @@ def test_nurbs_surface_fitting():
     assert len(surface.knotvector_u) == 6
     assert len(surface.knotvector_v) == 6
     assert len(surface.control_points) == 9
+
+
+def test_nurbs_surface_equality():
+    """Test if two NURBSSurface instances are equal."""
+    points = [
+        Point3D([0, 0, 0]),
+        Point3D([0, 1, 1]),
+        Point3D([0, 2, 0]),
+        Point3D([1, 0, 1]),
+        Point3D([1, 1, 2]),
+        Point3D([1, 2, 1]),
+        Point3D([2, 0, 0]),
+        Point3D([2, 1, 1]),
+        Point3D([2, 2, 0]),
+    ]
+    degree_u = 2
+    degree_v = 2
+
+    surface = NURBSSurface.fit_surface_from_points(
+        points=points, size_u = 3, size_v = 3, degree_u=degree_u, degree_v=degree_v
+    )
+    other_surface = NURBSSurface.fit_surface_from_points(
+        points=points, size_u = 3, size_v = 3, degree_u=degree_u, degree_v=degree_v
+    )
+
+    assert surface == other_surface
+
+    # Test with a different, non-equivalent, surface
+    different_points = [
+        Point3D([0, 0, 0]),
+        Point3D([0, 1, 1]),
+        Point3D([0, 2, 0]),
+        Point3D([2, 0, 1]),
+        Point3D([2, 1, 2]),
+        Point3D([2, 2, 1]),
+        Point3D([4, 0, 0]),
+        Point3D([4, 1, 1]),
+        Point3D([4, 2, 0]),
+    ]
+    different_surface = NURBSSurface.fit_surface_from_points(
+        points=different_points, size_u=3, size_v=3, degree_u=degree_u, degree_v=degree_v
+    )
+
+    assert surface != different_surface
+    
+    # Test comparison with a non-NURBSSurface object
+    non_nurbs_object = "Not a NURBSSurface"
+    assert surface != non_nurbs_object
+
+
+def test_nurbs_surface_parameterization():
+    """Test the parameterization method of the NURBSSurface class."""
+    # Define valid inputs for the NURBS surface
+    degree_u = 2
+    degree_v = 2
+    knots_u = [0, 0, 0, 1, 1, 1]
+    knots_v = [0, 0, 0, 1, 1, 1]
+    control_points = [
+        Point3D([0, 0, 0]),
+        Point3D([0, 1, 1]),
+        Point3D([0, 2, 0]),
+        Point3D([1, 0, 1]),
+        Point3D([1, 1, 2]),
+        Point3D([1, 2, 1]),
+        Point3D([2, 0, 0]),
+        Point3D([2, 1, 1]),
+        Point3D([2, 2, 0]),
+    ]
+
+    # Create a NURBS surface instance
+    nurbs_surface = NURBSSurface.from_control_points(
+        degree_u=degree_u,
+        degree_v=degree_v,
+        knots_u=knots_u,
+        knots_v=knots_v,
+        control_points=control_points,
+    )
+
+    # Call the parameterization method
+    u_param, v_param = nurbs_surface.parameterization()
+
+    # Validate the u parameterization
+    assert isinstance(u_param, Parameterization)
+    assert u_param.form == ParamForm.OTHER
+    assert u_param.type == ParamType.OTHER
+    assert u_param.interval.start == nurbs_surface._nurbs_surface.domain[0][0]
+    assert u_param.interval.end == nurbs_surface._nurbs_surface.domain[0][1]
+
+    # Validate the v parameterization
+    assert isinstance(v_param, Parameterization)
+    assert v_param.form == ParamForm.OTHER
+    assert v_param.type == ParamType.OTHER
+    assert v_param.interval.start == nurbs_surface._nurbs_surface.domain[1][0]
+    assert v_param.interval.end == nurbs_surface._nurbs_surface.domain[1][1]
+
+
+def test_nurbs_surface_simple_evaluation():
+    """Test NURBSSurface evaluation."""
+    degree_u = 2
+    degree_v = 2
+    knots_u = [0, 0, 0, 1, 1, 1]
+    knots_v = [0, 0, 0, 1, 1, 1]
+    control_points = [
+        Point3D([0, 0, 0]),
+        Point3D([0, 1, 1]),
+        Point3D([0, 2, 0]),
+        Point3D([1, 0, 1]),
+        Point3D([1, 1, 2]),
+        Point3D([1, 2, 1]),
+        Point3D([2, 0, 0]),
+        Point3D([2, 1, 1]),
+        Point3D([2, 2, 0]),
+    ]
+
+    nurbs_surface = NURBSSurface.from_control_points(
+        degree_u=degree_u,
+        degree_v=degree_v,
+        knots_u=knots_u,
+        knots_v=knots_v,
+        control_points=control_points,
+    )
+
+    # Test invalid evaluation at (-1,0)
+    with pytest.raises(ValueError):
+        _ = nurbs_surface.evaluate(ParamUV(-1, 0))
+
+    # Test evaluation at (0,0)
+    eval = nurbs_surface.evaluate(ParamUV(0.5, 0.5))
+
+    assert isinstance(eval, NURBSSurfaceEvaluation)
+    assert eval.parameter.u == 0.5
+    assert eval.parameter.v == 0.5
+    assert eval.position == Point3D([1, 1, 1])
+    assert isinstance(eval.u_derivative, Vector3D)
+    assert isinstance(eval.v_derivative, Vector3D)
+    assert isinstance(eval.uu_derivative, Vector3D)
+    assert isinstance(eval.uv_derivative, Vector3D)
+    assert isinstance(eval.vv_derivative, Vector3D)
+    assert isinstance(eval.normal, UnitVector3D)
+    assert isinstance(eval.surface, NURBSSurface)