reworked method to use v1 style protos

test passing

Author: jacobrkerstetter

src/ansys/geometry/core/_grpc/_services/v0/bodies.py

@@ -173,31 +173,43 @@ def create_sweeping_chain(self, **kwargs) -> dict:  # noqa: D102
 
     @protect_grpc
     def sweep_with_guide(self, **kwargs):  # noqa: D102
-        from ansys.api.geometry.v0.bodies_pb2 import SweepWithGuideRequest
+        from ansys.api.dbu.v0.dbumodels_pb2 import EntityIdentifier
+        from ansys.api.geometry.v0.bodies_pb2 import (
+            SweepWithGuideRequest,
+            SweepWithGuideRequestData,
+        )
 
-        # Create the request - assumes all inputs are valid and of the proper type
+        # Create request object - assumes all inputs are valid and of the proper type
         request = SweepWithGuideRequest(
-            name=kwargs["name"],
-            parent=kwargs["parent_id"],
-            plane=from_plane_to_grpc_plane(kwargs["sketch"].plane),
-            geometries=from_sketch_shapes_to_grpc_geometries(
-                kwargs["sketch"].plane, kwargs["sketch"].edges, kwargs["sketch"].faces
-            ),
-            path=from_trimmed_curve_to_grpc_trimmed_curve(kwargs["path"]),
-            guide=from_trimmed_curve_to_grpc_trimmed_curve(kwargs["guide"]),
-            tight_tolerance= kwargs["tight_tolerance"],
+            request_data=[
+                SweepWithGuideRequestData(
+                    name=data.name,
+                    parent=EntityIdentifier(id=data.parent_id),
+                    plane=from_plane_to_grpc_plane(data.sketch.plane),
+                    geometries=from_sketch_shapes_to_grpc_geometries(
+                        data.sketch.plane, data.sketch.edges, data.sketch.faces
+                    ),
+                    path=from_trimmed_curve_to_grpc_trimmed_curve(data.path),
+                    guide=from_trimmed_curve_to_grpc_trimmed_curve(data.guide),
+                    tight_tolerance=data.tight_tolerance,
+                )
+                for data in kwargs["sweep_data"]
+            ],
         )
 
         # Call the gRPC service
         resp = self.stub.SweepWithGuide(request=request)
 
         # Return the response - formatted as a dictionary
         return {
-            "id": resp.id,
-            "name": resp.name,
-            "master_id": resp.master_id,
-            "is_surface": resp.is_surface,
-        }   
+            "bodies": [{
+                "id": body.id,
+                "name": body.name,
+                "master_id": body.master_id,
+                "is_surface": body.is_surface,
+            }]
+            for body in resp.bodies
+        }
 
     @protect_grpc
     def create_extruded_body_from_face_profile(self, **kwargs) -> dict:  # noqa: D102

src/ansys/geometry/core/designer/component.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 """Provides for managing components."""
 
+from dataclasses import dataclass
 from enum import Enum, unique
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, Optional, Union
@@ -134,6 +135,17 @@ def get_multiplier(self) -> int:
         """
         return 1 if self is ExtrusionDirection.POSITIVE else -1
 
+@dataclass
+class SweepWithGuideData:
+    """Data class for sweep with guide parameters."""
+
+    name: str
+    parent_id: str
+    sketch: Sketch
+    path: TrimmedCurve
+    guide: TrimmedCurve
+    tight_tolerance: bool = False
+
 
 class Component:
     """Provides for creating and managing a component.
@@ -710,51 +722,30 @@ def sweep_chain(
     @min_backend_version(26, 1, 0)
     @check_input_types
     @ensure_design_is_active
-    def sweep_with_guide(
-        self,
-        name: str,
-        sketch: Sketch,
-        path: TrimmedCurve,
-        guide: TrimmedCurve,
-        tight_tolerance: bool
-    ): 
+    def sweep_with_guide(self, sweep_data: list[SweepWithGuideData]) -> list[Body]:
         """Create a body by sweeping a sketch along a path with a guide curve.
 
         The newly created body is placed under this component within the design assembly.
 
         Parameters
         ----------
-        name : str
-            User-defined label for the new solid body.
-        sketch : Sketch
-            Two-dimensional sketch source for the sweep.
-        path : TrimmedCurve
-            The path to sweep the profile along.
-        guide : TrimmedCurve
-            The guide curve to control the sweep.
-        tight_tolerance : bool
-            Whether to use tight tolerance for the sweep.
+        sweep_data: SweepWithGuideData
+            Data for the sweep operation, including the sketch, path, and guide curve.
 
         Returns
         -------
-        Body
-            Created body from the given sketch.
+        list[Body]
+            Created bodies from the given sweep data.
 
         Warnings
         --------
         This method is only available starting on Ansys release 26R1.
         """
         self._grpc_client.log.debug(f"Sweeping the profile {self.id}. Creating body...")
         response = self._grpc_client.services.bodies.sweep_with_guide(
-            name=name,
-            parent_id=self.id,
-            sketch=sketch,
-            path=path,
-            guide=guide,
-            tight_tolerance=tight_tolerance,
-            backend_version=self._grpc_client.backend_version,
+            sweep_data=sweep_data
         )
-        return self.__build_body_from_response(response)
+        return [self.__build_body_from_response(body_data) for body_data in response.get("bodies")]
 
     @min_backend_version(24, 2, 0)
     @check_input_types

tests/integration/test_design.py

@@ -40,6 +40,7 @@
     SurfaceType,
 )
 from ansys.geometry.core.designer.body import CollisionType, FillStyle, MasterBody
+from ansys.geometry.core.designer.component import SweepWithGuideData
 from ansys.geometry.core.designer.face import FaceLoopType
 from ansys.geometry.core.designer.part import MasterComponent, Part
 from ansys.geometry.core.errors import GeometryExitedError, GeometryRuntimeError
@@ -56,6 +57,7 @@
     UnitVector3D,
     Vector3D,
 )
+from ansys.geometry.core.math.matrix import Matrix44
 from ansys.geometry.core.misc import DEFAULT_UNITS, UNITS, Accuracy, Angle, Distance, checks
 from ansys.geometry.core.misc.auxiliary import DEFAULT_COLOR
 from ansys.geometry.core.parameters.parameter import ParameterType, ParameterUpdateStatus
@@ -2813,90 +2815,49 @@ def test_sweep_with_guide(modeler: Modeler):
     """Test creating a body by sweeping a profile with a guide curve."""
     design = modeler.create_design("SweepWithGuide")
 
-    # Set up path points array
-    path_points = []
-    path_points.append(Point3D([0.0, 0.0, 0.15]))
-    path_points.append(Point3D([0.05, 0.0, 0.1]))
-    path_points.append(Point3D([0.1, 0.0, 0.05]))
-    path_points.append(Point3D([0.15, 0.0, 0.1]))
-    path_points.append(Point3D([0.2, 0.0, 0.15]))
-
-    npoints = len(path_points)
-    for i in range(2):
-        for j in range(1, npoints):
-            orgp = path_points[j]
-            p = Point3D([orgp[0] + (i + 1) * path_points[npoints - 1][0], orgp[1], orgp[2]])
-            path_points.append(p)
-
-    # Insert values at the beginning and end
-    start_point = [
-        Point3D(
-            [
-                path_points[npoints - 2][0] - path_points[npoints - 1][0],
-                path_points[npoints - 2][1],
-                path_points[npoints - 2][2],
-            ],
-        )
+    # Create path points for the sweep path
+    path_points = [
+        Point3D([0.0, 0.0, 0.15]),
+        Point3D([0.05, 0.0, 0.1]),
+        Point3D([0.1, 0.0, 0.05]),
+        Point3D([0.15, 0.0, 0.1]),
+        Point3D([0.2, 0.0, 0.15]),
     ]
-    path_points = start_point + path_points
-    end_point = Point3D(
-        [
-            path_points[2][0] + (1 + 2) * path_points[npoints][0],
-            path_points[2][1],
-            path_points[2][2],
-        ],
-    )
-    path_points.append(end_point)
-
-    # Create the NURBS curve through the points
-    nurbs_curve = NURBSCurve.fit_curve_from_points(path_points, 3)
+    nurbs_path = NURBSCurve.fit_curve_from_points(path_points, degree=3)
     n_l_points = len(path_points)
-    yarn_path = nurbs_curve.trim(
-        Interval(1.0 / (n_l_points - 1), (n_l_points - 2.0) / (n_l_points - 1))
-    )
-
-    # Create the lenticular profile sketch
-    yarn_path_eval = nurbs_curve.project_point(path_points[1])
-    p = yarn_path_eval.position
-    d = yarn_path_eval.first_derivative.normalize()
-
-    # Define Hughes-Moeller algorithm for finding orthonormal base
-    def hughes_moeller(axis_direction):
-        """Find the orthonornal base using hughes moeller algorithm."""
-        n = axis_direction
-        if np.abs(n[0]) > np.abs([n[2]]):
-            b2 = np.array(([-n[1], n[0], 0.0]))
-        else:
-            b2 = np.array((0.0, -n[2], n[1]))
-        b2 *= np.sqrt(np.dot(b2, b2))
-        b1 = np.cross(b2, n)
-        return b1, b2
-
-    a = 0.043134775028197354
-    aspect_ratio = 0.1
-    p1, p2 = hughes_moeller(np.array([d.x, d.y, d.z]))
-    plane = Plane(origin=p, direction_x=Vector3D(p1), direction_y=Vector3D(p2))
-    lenticular_profile = Sketch(plane)
-    radius = (a / aspect_ratio + a * aspect_ratio) / 2.0
-
-    c1 = Point2D([-radius + a * aspect_ratio, 0.0])
-    c2 = Point2D([radius - a * aspect_ratio, 0.0])
-    s1 = Point2D([0.0, a])
-    e1 = Point2D([0.0, -a])
-
-    lenticular_profile.arc(s1, e1, c1, True)
-    lenticular_profile.arc(e1, s1, c2, True)
-
-    # Sweep the sketch
-    sweep_body = design.sweep_with_guide(
-        name="Yarn",
-        sketch=lenticular_profile,
-        path=[yarn_path],
-        guide=None,
+    path_interval = Interval(1.0 / (n_l_points - 1), (n_l_points - 2.0) / (n_l_points - 1))
+    trimmed_path = nurbs_path.trim(path_interval)
+
+    # Create a simple circular profile sketch
+    profile_plane = Plane(origin=path_points[1])
+    profile_sketch = Sketch(profile_plane)
+    profile_sketch.circle(Point2D([0, 0]), 0.01)  # 0.01 radius
+
+    # Create guide curve points (offset from path)
+    guide_points = [Point3D([p.x.m, p.y.m + 0.01, p.z.m]) for p in path_points]
+    guide_curve = NURBSCurve.fit_curve_from_points(guide_points, degree=3)
+    guide_interval = Interval(1.0 / (n_l_points - 1), (n_l_points - 2.0) / (n_l_points - 1))
+    trimmed_guide = guide_curve.trim(guide_interval)
+
+    # Sweep the profile along the path with the guide curve
+    sweep_data = [SweepWithGuideData(
+        name="SweptBody",
+        parent_id=design.id,
+        sketch=profile_sketch,
+        path=trimmed_path,
+        guide=trimmed_guide,
         tight_tolerance=True,
-    )
+    )]
+    sweep_body = design.sweep_with_guide(sweep_data=sweep_data)[0]
+
+    design.export_to_scdocx("C:\\Users\\jkerstet\\Downloads\\sweep_body.scdocx")
 
-    sweep_body.plot(screenshot="C:\\Users\\jkerstet\\Downloads\\sweep_body.png")
+    assert sweep_body is not None
+    assert sweep_body.name == "SweptBody"
+    assert sweep_body.is_surface
+    assert len(sweep_body.faces) == 1
+    assert len(sweep_body.edges) == 2
+    assert len(sweep_body.vertices) == 0
 
 
 def test_create_body_from_loft_profile(modeler: Modeler):