Merge branch 'blitz' into feat/run-script-core-service

RobPasMue · web-flow · commit 314801beb954 · 2025-03-12T10:14:47.000-05:00
diff --git a/.github/workflows/ci_cd.yml b/.github/workflows/ci_cd.yml
diff --git a/doc/changelog.d/1806.added.md b/doc/changelog.d/1806.added.md
@@ -0,0 +1 @@
+matrix helper methods
diff --git a/doc/changelog.d/1808.fixed.md b/doc/changelog.d/1808.fixed.md
@@ -0,0 +1 @@
+translating sketch issues when using a custom default unit
diff --git a/doc/changelog.d/1816.fixed.md b/doc/changelog.d/1816.fixed.md
@@ -0,0 +1 @@
+edge start and end were not being mapped correctly
diff --git a/src/ansys/geometry/core/designer/edge.py b/src/ansys/geometry/core/designer/edge.py
@@ -128,8 +128,13 @@ def shape(self) -> TrimmedCurve:
             geometry = grpc_curve_to_curve(response)
 
             response = self._edges_stub.GetStartAndEndPoints(self._grpc_id)
-            start = Point3D([response.start.x, response.start.y, response.start.z])
-            end = Point3D([response.end.x, response.end.y, response.end.z])
+            start = Point3D(
+                [response.start.x, response.start.y, response.start.z],
+                unit=DEFAULT_UNITS.SERVER_LENGTH,
+            )
+            end = Point3D(
+                [response.end.x, response.end.y, response.end.z], unit=DEFAULT_UNITS.SERVER_LENGTH
+            )
 
             response = self._edges_stub.GetLength(self._grpc_id)
             length = Quantity(response.length, DEFAULT_UNITS.SERVER_LENGTH)
@@ -193,7 +198,10 @@ def start(self) -> Point3D:
             # Only for versions earlier than 24.2.0 (before the introduction of the shape property)
             self._grpc_client.log.debug("Requesting edge start point from server.")
             response = self._edges_stub.GetStartAndEndPoints(self._grpc_id)
-            return Point3D([response.start.x, response.start.y, response.start.z])
+            return Point3D(
+                [response.start.x, response.start.y, response.start.z],
+                unit=DEFAULT_UNITS.SERVER_LENGTH,
+            )
 
     @property
     @protect_grpc
diff --git a/src/ansys/geometry/core/designer/face.py b/src/ansys/geometry/core/designer/face.py
@@ -554,8 +554,8 @@ def create_isoparametric_curves(
         trimmed_curves = []
         for c in curves:
             geometry = grpc_curve_to_curve(c.curve)
-            start = Point3D([c.start.x, c.start.y, c.start.z])
-            end = Point3D([c.end.x, c.end.y, c.end.z])
+            start = Point3D([c.start.x, c.start.y, c.start.z], unit=DEFAULT_UNITS.SERVER_LENGTH)
+            end = Point3D([c.end.x, c.end.y, c.end.z], unit=DEFAULT_UNITS.SERVER_LENGTH)
             interval = Interval(c.interval_start, c.interval_end)
             length = Quantity(c.length, DEFAULT_UNITS.SERVER_LENGTH)
 
diff --git a/src/ansys/geometry/core/math/matrix.py b/src/ansys/geometry/core/math/matrix.py
@@ -30,6 +30,7 @@
 from ansys.geometry.core.typing import Real, RealSequence
 
 if TYPE_CHECKING:
+    from ansys.geometry.core.math.frame import Frame
     from ansys.geometry.core.math.vector import Vector3D  # For type hints
 
 DEFAULT_MATRIX33 = np.identity(3)
@@ -308,3 +309,61 @@ def create_rotation(
             ]
         )
         return matrix
+
+    @classmethod
+    def create_matrix_from_rotation_about_axis(cls, axis: "Vector3D", angle: float) -> "Matrix44":
+        """
+        Create a matrix representing a rotation about a given axis.
+
+        Parameters
+        ----------
+        axis : Vector3D
+            The axis of rotation.
+        angle : float
+            The angle of rotation in radians.
+
+        Returns
+        -------
+        Matrix44
+            A 4x4 matrix representing the rotation.
+        """
+        axis_dir = axis.normalize()
+        x, y, z = axis_dir[0], axis_dir[1], axis_dir[2]
+
+        k = np.array([[0, -z, y], [z, 0, -x], [-y, x, 0]])
+
+        identity = np.eye(3)
+        cos_theta = np.cos(angle)
+        sin_theta = np.sin(angle)
+
+        # Rodrigues' rotation formula
+        rotation_3x3 = identity + sin_theta * k + (1 - cos_theta) * (k @ k)
+
+        # Convert to a 4x4 homogeneous matrix
+        rotation_matrix = np.eye(4)
+        rotation_matrix[:3, :3] = rotation_3x3
+
+        return cls(rotation_matrix)
+
+    @classmethod
+    def create_matrix_from_mapping(cls, frame: "Frame") -> "Matrix44":
+        """
+        Create a matrix representing the specified mapping.
+
+        Parameters
+        ----------
+        frame : Frame
+            The frame containing the origin and direction vectors.
+
+        Returns
+        -------
+        Matrix44
+            A 4x4 matrix representing the translation and rotation defined by the frame.
+        """
+        from ansys.geometry.core.math.vector import Vector3D
+
+        translation_matrix = Matrix44.create_translation(
+            Vector3D([frame.origin[0], frame.origin[1], frame.origin[2]])
+        )
+        rotation_matrix = Matrix44.create_rotation(frame.direction_x, frame.direction_y)
+        return translation_matrix * rotation_matrix
diff --git a/src/ansys/geometry/core/math/vector.py b/src/ansys/geometry/core/math/vector.py
@@ -32,6 +32,7 @@
 from ansys.geometry.core.math.point import Point2D, Point3D
 from ansys.geometry.core.misc.accuracy import Accuracy
 from ansys.geometry.core.misc.checks import check_ndarray_is_float_int
+from ansys.geometry.core.misc.measurements import Angle
 from ansys.geometry.core.misc.units import UNITS
 from ansys.geometry.core.typing import Real, RealSequence
 
@@ -163,6 +164,22 @@ def transform(self, matrix: "Matrix44") -> "Vector3D":
         result_vector = Vector3D(result_4x1[0:3])
         return result_vector
 
+    @check_input_types
+    def rotate_vector(self, vector: "Vector3D", angle: Real | Quantity | Angle) -> "Vector3D":
+        """Rotate a vector around a given axis by a specified angle."""
+        if self.is_zero:
+            raise Exception("Invalid vector operation: rotation axis cannot be zero.")
+
+        # Convert angle to Angle object and get its value in radians
+        angle = angle if isinstance(angle, Angle) else Angle(angle)
+        angle_m = angle.value.m_as(UNITS.radian)
+
+        axis = self.normalize()
+        parallel = axis * (vector.dot(axis))
+        perpendicular1 = vector - parallel
+        perpendicular2 = axis.cross(perpendicular1)
+        return parallel + perpendicular1 * np.cos(angle_m) + perpendicular2 * np.sin(angle_m)
+
     @check_input_types
     def get_angle_between(self, v: "Vector3D") -> Quantity:
         """Get the angle between this 3D vector and another 3D vector.
diff --git a/src/ansys/geometry/core/shapes/curves/trimmed_curve.py b/src/ansys/geometry/core/shapes/curves/trimmed_curve.py
@@ -29,6 +29,7 @@
 from ansys.geometry.core.connection.conversions import trimmed_curve_to_grpc_trimmed_curve
 from ansys.geometry.core.errors import protect_grpc
 from ansys.geometry.core.math.point import Point3D
+from ansys.geometry.core.misc.measurements import DEFAULT_UNITS
 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
@@ -148,7 +149,10 @@ def intersect_curve(self, other: "TrimmedCurve") -> list[Point3D]:
         )
         if res.intersect is False:
             return []
-        return [Point3D([point.x, point.y, point.z]) for point in res.points]
+        return [
+            Point3D([point.x, point.y, point.z], unit=DEFAULT_UNITS.SERVER_LENGTH)
+            for point in res.points
+        ]
 
     def __repr__(self) -> str:
         """Represent the trimmed curve as a string."""
diff --git a/src/ansys/geometry/core/sketch/sketch.py b/src/ansys/geometry/core/sketch/sketch.py
@@ -28,7 +28,7 @@
 
 from ansys.geometry.core.math.constants import ZERO_POINT2D
 from ansys.geometry.core.math.plane import Plane
-from ansys.geometry.core.math.point import Point2D
+from ansys.geometry.core.math.point import Point2D, Point3D
 from ansys.geometry.core.math.vector import UnitVector3D, Vector2D, Vector3D
 from ansys.geometry.core.misc.checks import graphics_required
 from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Angle, Distance
@@ -121,16 +121,24 @@ def translate_sketch_plane(self, translation: Vector3D) -> "Sketch":
         Parameters
         ----------
         translation : Vector3D
-            Vector defining the translation. Meters is the expected unit.
+            Vector defining the translation. Default units are the expected
+            units, otherwise it will be inconsistent.
 
         Returns
         -------
         Sketch
             Revised sketch state ready for further sketch actions.
         """
-        self.plane = Plane(
-            self.plane.origin + translation, self.plane.direction_x, self.plane.direction_y
+        new_origin = Point3D(
+            [
+                self.plane.origin.x.m_as(DEFAULT_UNITS.LENGTH) + translation.x,
+                self.plane.origin.y.m_as(DEFAULT_UNITS.LENGTH) + translation.y,
+                self.plane.origin.z.m_as(DEFAULT_UNITS.LENGTH) + translation.z,
+            ]
         )
+        # Set the same unit system as the plane origin
+        new_origin.unit = self.plane.origin.unit
+        self.plane = Plane(new_origin, self.plane.direction_x, self.plane.direction_y)
         return self
 
     @check_input_types
diff --git a/tests/integration/test_issues.py b/tests/integration/test_issues.py
@@ -33,6 +33,7 @@
     Point2D,
     Point3D,
 )
+from ansys.geometry.core.math.vector import UnitVector3D
 from ansys.geometry.core.misc import DEFAULT_UNITS, UNITS, Angle, Distance
 from ansys.geometry.core.modeler import Modeler
 from ansys.geometry.core.sketch import Sketch
@@ -260,3 +261,67 @@ def test_issue_1724_intersect_failures(modeler: Modeler):
 
     # Verify that the volume of the cylinder is the same (the intersect is the same as the cylinder)
     assert np.isclose(design.bodies[0].volume.m, np.pi * radius**2 * (wz - 0.1))
+
+
+def test_issue_1807_translate_sketch_non_default_units():
+    """Test that translating a sketch with non-default units is handled properly.
+
+    For more info see
+    https://github.com/ansys/pyansys-geometry/issues/1807
+    """
+    try:
+        # Set the default units to mm
+        DEFAULT_UNITS.LENGTH = UNITS.mm
+
+        # Draw a box sketch
+        sketch = Sketch()
+        sketch.box(Point2D([0, 0]), 10, 10)
+
+        # Verify the sketch plane origin
+        assert sketch.plane.origin == Point3D([0, 0, 0])
+
+        # Translate the sketch
+        sketch.translate_sketch_plane_by_distance(UnitVector3D([0, 0, 1]), Distance(10, UNITS.mm))
+
+        # Verify the new sketch plane origin
+        assert sketch.plane.origin == Point3D([0, 0, 10], unit=UNITS.mm)
+
+    finally:
+        # Reset the default units to meters
+        DEFAULT_UNITS.LENGTH = UNITS.meter
+
+
+def test_issue_1813_edge_start_end_non_default_units(modeler: Modeler):
+    """Test that creating an edge with non-default units is handled properly.
+
+    Notes
+    -----
+    Apparently there are some issues on the start and end locations when
+    using non-default units. This test is to verify that the issue has been
+    resolved.
+
+    For more info see
+    https://github.com/ansys/pyansys-geometry/issues/1813
+    """
+    try:
+        # Create initial design and set default units to millimeters
+        design = modeler.create_design("MillimetersEdgeIssue")
+        DEFAULT_UNITS.LENGTH = UNITS.mm
+
+        # Sketch and extrude box
+        box = design.extrude_sketch("box", Sketch().box(Point2D([0.5, 0.5]), 1, 1), 1)
+
+        # Perform some assertions like...
+        # 1) The edge lengths should be 1 mm
+        for face in box.faces:
+            for edge in face.edges:
+                assert np.isclose(edge.length, 1 * UNITS.mm)
+                length_vec = edge.start - edge.end
+                assert np.isclose(np.linalg.norm(length_vec) * length_vec.base_unit, 1 * UNITS.mm)
+
+        # 2) Verify the box volume
+        assert np.isclose(box.volume, 1 * UNITS.mm * UNITS.mm * UNITS.mm)
+
+    finally:
+        # Reset the default units to meters
+        DEFAULT_UNITS.LENGTH = UNITS.meter
diff --git a/tests/test_math.py b/tests/test_math.py
@@ -24,6 +24,7 @@
 
 from beartype.roar import BeartypeCallHintParamViolation
 import numpy as np
+from pint import Quantity
 import pytest
 
 from ansys.geometry.core.math import (
@@ -628,6 +629,24 @@ def test_vector2d_errors():
         v1.get_angle_between(v2)
 
 
+def test_rotate_vector():
+    """Test the rotate_vector method."""
+    # Define the vectors and angle
+    axis = Vector3D([0.0, 0.0, 1.0])
+    vector = Vector3D([1.0, 0.0, 0.0])
+
+    angle = Quantity(np.pi / 2)  # 90 degrees
+
+    # Expected result after rotating vector around axis by 90 degrees
+    expected_vector = Vector3D([0.0, 1.0, 0.0])
+
+    # Call the method under test
+    result_vector = axis.rotate_vector(vector, angle)
+
+    # Assert that the result matches the expected vector
+    assert np.allclose(result_vector, expected_vector)
+
+
 def test_matrix():
     """Simple test to create a ``Matrix``."""
     # Create two matrix objects
@@ -828,6 +847,82 @@ def test_create_rotation_matrix():
     assert np.array_equal(expected_matrix, rotation_matrix)
 
 
+def test_create_matrix_from_rotation_about_axis_x():
+    """Test the create_matrix_from_rotation_about_axis method for rotation about the x-axis."""
+    axis = Vector3D([1.0, 0.0, 0.0])
+    angle = np.pi / 2  # 90 degrees
+    expected_matrix = Matrix44([[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
+
+    result_matrix = Matrix44.create_matrix_from_rotation_about_axis(axis, angle)
+
+    print(result_matrix)
+    assert np.allclose(result_matrix, expected_matrix)
+
+
+def test_create_matrix_from_rotation_about_axis_y():
+    """Test the create_matrix_from_rotation_about_axis method for rotation about the y-axis."""
+    axis = Vector3D([0.0, 1.0, 0.0])
+    angle = np.pi / 2  # 90 degrees
+    expected_matrix = Matrix44([[0, 0, 1, 0], [0, 1, 0, 0], [-1, 0, 0, 0], [0, 0, 0, 1]])
+
+    result_matrix = Matrix44.create_matrix_from_rotation_about_axis(axis, angle)
+    assert np.allclose(result_matrix, expected_matrix)
+
+
+def test_create_matrix_from_rotation_about_axis_z():
+    """Test the create_matrix_from_rotation_about_axis method for rotation about the z-axis."""
+    axis = Vector3D([0.0, 0.0, 1.0])
+    angle = np.pi / 2  # 90 degrees
+    expected_matrix = Matrix44([[0, -1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+
+    result_matrix = Matrix44.create_matrix_from_rotation_about_axis(axis, angle)
+    assert np.allclose(result_matrix, expected_matrix)
+
+
+def test_create_matrix_from_rotation_about_arbitrary_axis():
+    """Test the create_matrix_from_rotation_about_axis method for
+    rotation about an arbitrary axis.
+    """
+    axis = Vector3D([1.0, 1.0, 1.0]).normalize()
+    angle = np.pi / 3  # 60 degrees
+    # Expected matrix calculated using external tools or libraries
+    expected_matrix = Matrix44(
+        [
+            [0.66666667, -0.33333333, 0.66666667, 0],
+            [0.66666667, 0.66666667, -0.33333333, 0],
+            [-0.33333333, 0.66666667, 0.66666667, 0],
+            [0, 0, 0, 1],
+        ]
+    )
+
+    result_matrix = Matrix44.create_matrix_from_rotation_about_axis(axis, angle)
+    assert np.allclose(result_matrix, expected_matrix)
+
+
+def test_create_matrix_from_mapping():
+    """Test the create_matrix_from_mapping method."""
+    # Define the frame with origin and direction vectors
+    origin = Vector3D([1.0, 2.0, 3.0])
+    direction_x = Vector3D([1.0, 0.0, 0.0])
+    direction_y = Vector3D([0.0, 1.0, 0.0])
+    frame = Frame(origin, direction_x, direction_y)
+
+    # Create the expected translation matrix
+    expected_translation_matrix = Matrix44.create_translation(origin)
+
+    # Create the expected rotation matrix
+    expected_rotation_matrix = Matrix44.create_rotation(direction_x, direction_y)
+
+    # Create the expected result by multiplying the translation and rotation matrices
+    expected_matrix = expected_translation_matrix * expected_rotation_matrix
+
+    # Call the method under test
+    result_matrix = Matrix44.create_matrix_from_mapping(frame)
+
+    # Assert that the result matches the expected matrix
+    assert np.allclose(result_matrix, expected_matrix)
+
+
 def test_frame():
     """``Frame`` construction and equivalency."""
     origin = Point3D([42, 99, 13])

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+translating sketch issues when using a custom default unit`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+edge start and end were not being mapped correctly`