feat: named selection functionality

doc/changelog.d/1768.added.md

@@ -0,0 +1 @@
+named selection functionality

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

@@ -59,6 +59,7 @@
 from ansys.geometry.core.connection.conversions import (
     grpc_frame_to_frame,
     grpc_matrix_to_matrix,
+    grpc_point_to_point3d,
     plane_to_grpc_plane,
     point3d_to_grpc_point,
 )
@@ -78,6 +79,11 @@
 from ansys.geometry.core.math.plane import Plane
 from ansys.geometry.core.math.point import Point3D
 from ansys.geometry.core.math.vector import UnitVector3D, Vector3D
+from ansys.geometry.core.misc.auxiliary import (
+    get_bodies_from_ids,
+    get_edges_from_ids,
+    get_faces_from_ids,
+)
 from ansys.geometry.core.misc.checks import ensure_design_is_active, min_backend_version
 from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Distance
 from ansys.geometry.core.misc.options import ImportOptions
@@ -677,8 +683,8 @@ def create_named_selection(
             beams=beams,
             design_points=design_points,
         )
-        self._named_selections[named_selection.name] = named_selection
 
+        self._named_selections[named_selection.name] = named_selection
         self._grpc_client.log.debug(
             f"Named selection {named_selection.name} is successfully created."
         )
@@ -1141,7 +1147,29 @@ def __read_existing_design(self) -> None:
 
         # Create NamedSelections
         for ns in response.named_selections:
-            new_ns = NamedSelection(ns.name, self._grpc_client, preexisting_id=ns.id)
+            result = self._named_selections_stub.Get(EntityIdentifier(id=ns.id))
+
+            # This works but is slow -- can use improvement for designs with many named selections
+            bodies = get_bodies_from_ids(self, [body.id for body in result.bodies])
+            faces = get_faces_from_ids(self, [face.id for face in result.faces])
+            edges = get_edges_from_ids(self, [edge.id for edge in result.edges])
+
+            design_points = []
+            for dp in result.design_points:
+                design_points.append(
+                    DesignPoint(dp.id, "dp: " + dp.id, grpc_point_to_point3d(dp.points[0]), self)
+                )
+
+            new_ns = NamedSelection(
+                ns.name,
+                self._grpc_client,
+                preexisting_id=ns.id,
+                bodies=bodies,
+                faces=faces,
+                edges=edges,
+                beams=[],  # BEAM IMPORT NOT SUPPORTED FOR NAMED SELECTIONS
+                design_points=design_points,
+            )
             self._named_selections[new_ns.name] = new_ns
 
         # Create CoordinateSystems

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

@@ -24,6 +24,10 @@
 from enum import Enum, unique
 from typing import TYPE_CHECKING, Union
 
+from beartype import beartype as check_input_types
+from pint import Quantity
+
+from ansys.api.dbu.v0.dbumodels_pb2 import EntityIdentifier
 from ansys.api.geometry.v0.commands_pb2 import (
     ChamferRequest,
     CreateCircularPatternRequest,
@@ -37,6 +41,8 @@
     FullFilletRequest,
     ModifyCircularPatternRequest,
     ModifyLinearPatternRequest,
+    MoveRotateRequest,
+    MoveTranslateRequest,
     OffsetFacesSetRadiusRequest,
     PatternRequest,
     RenameObjectRequest,
@@ -55,6 +61,7 @@
     point3d_to_grpc_point,
     unit_vector_to_grpc_direction,
 )
+from ansys.geometry.core.designer.selection import NamedSelection
 from ansys.geometry.core.errors import protect_grpc
 from ansys.geometry.core.math.plane import Plane
 from ansys.geometry.core.math.point import Point3D
@@ -71,6 +78,7 @@
     check_type_all_elements_in_iterable,
     min_backend_version,
 )
+from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Angle, Distance
 from ansys.geometry.core.shapes.curves.line import Line
 from ansys.geometry.core.typing import Real
 
@@ -1215,11 +1223,95 @@ def get_round_info(self, face: "Face") -> tuple[bool, Real]:
         return (result.along_u, result.radius)
 
     @protect_grpc
+    @check_input_types
+    @min_backend_version(25, 2, 0)
+    def move_translate(
+        self,
+        selection: NamedSelection,
+        direction: UnitVector3D,
+        distance: Distance | Quantity | Real,
+    ) -> bool:
+        """Move a selection by a distance in a direction.
+
+        Parameters
+        ----------
+        selection : NamedSelection
+            Named selection to move.
+        direction : UnitVector3D
+            Direction to move in.
+        distance : Distance | Quantity | Real
+            Distance to move. Default units are meters.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+        """
+        distance = distance if isinstance(distance, Distance) else Distance(distance)
+        translation_magnitude = distance.value.m_as(DEFAULT_UNITS.SERVER_LENGTH)
+
+        result = self._commands_stub.MoveTranslate(
+            MoveTranslateRequest(
+                selection=[EntityIdentifier(id=selection.id)],
+                direction=unit_vector_to_grpc_direction(direction),
+                distance=translation_magnitude,
+            )
+        )
+
+        return result.success
+
+    @protect_grpc
+    @check_input_types
+    @min_backend_version(25, 2, 0)
+    def move_rotate(
+        self,
+        selection: NamedSelection,
+        axis: Line,
+        angle: Angle | Quantity | Real,
+    ) -> dict[str, Union[bool, Real]]:
+        """Rotate a selection by an angle about a given axis.
+
+        Parameters
+        ----------
+        selection : NamedSelection
+            Named selection to move.
+        axis : Line
+            Direction to move in.
+        Angle : Angle | Quantity | Real
+            Angle to rotate by. Default units are radians.
+
+        Returns
+        -------
+        dict[str, Union[bool, Real]]
+            Dictionary containing the useful output from the command result.
+            Keys are success, modified_bodies, modified_faces, modified_edges.
+        """
+        angle = angle if isinstance(angle, Angle) else Angle(angle)
+        rotation_angle = angle.value.m_as(DEFAULT_UNITS.SERVER_ANGLE)
+
+        response = self._commands_stub.MoveRotate(
+            MoveRotateRequest(
+                selection=[EntityIdentifier(id=selection.id)],
+                axis=line_to_grpc_line(axis),
+                angle=rotation_angle,
+            )
+        )
+
+        result = {}
+        result["success"] = response.success
+        result["modified_bodies"] = response.modified_bodies
+        result["modified_faces"] = response.modified_faces
+        result["modified_edges"] = response.modified_edges
+
+        return result
+
+    @protect_grpc
+    @check_input_types
     @min_backend_version(25, 2, 0)
     def offset_faces_set_radius(
         self,
         faces: Union["Face", list["Face"]],
-        radius: Real,
+        radius: Distance | Quantity | Real,
         copy: bool = False,
         offset_mode: OffsetMode = OffsetMode.IGNORE_RELATIONSHIPS,
         extrude_type: ExtrudeType = ExtrudeType.FORCE_INDEPENDENT,
@@ -1230,7 +1322,7 @@ def offset_faces_set_radius(
         ----------
         faces : Face | list[Face]
             Faces to offset.
-        radius : Real
+        radius : Distance | Quantity | Real
             Radius of the offset.
         copy : bool, default: False
             Copy the face and move it instead of offsetting the original face if ``True``.
@@ -1247,17 +1339,18 @@ def offset_faces_set_radius(
         from ansys.geometry.core.designer.face import Face
 
         faces: list[Face] = faces if isinstance(faces, list) else [faces]
-
         check_type_all_elements_in_iterable(faces, Face)
-        check_is_float_int(radius, "radius")
 
         for face in faces:
             face.body._reset_tessellation_cache()
 
+        radius = radius if isinstance(radius, Distance) else Distance(radius)
+        radius_magnitude = radius.value.m_as(DEFAULT_UNITS.SERVER_LENGTH)
+
         result = self._commands_stub.OffsetFacesSetRadius(
             OffsetFacesSetRadiusRequest(
                 faces=[face._grpc_id for face in faces],
-                radius=radius,
+                radius=radius_magnitude,
                 copy=copy,
                 offset_mode=offset_mode.value,
                 extrude_type=extrude_type.value,

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

@@ -74,17 +74,11 @@ def __init__(
         preexisting_id: str | None = None,
     ):
         """Initialize the ``NamedSelection`` class."""
+        self._name = name
         self._grpc_client = grpc_client
-        self._named_selections_stub = NamedSelectionsStub(grpc_client.channel)
-
-        if preexisting_id:
-            self._id = preexisting_id
-            self._name = name
-            return
-
-        # All ids should be unique - no duplicated values
-        ids = set()
+        self._named_selections_stub = NamedSelectionsStub(self._grpc_client.channel)
 
+        # Create empty arrays if there are none of a type
         if bodies is None:
             bodies = []
         if faces is None:
@@ -96,6 +90,20 @@ def __init__(
         if design_points is None:
             design_points = []
 
+        # Instantiate
+        self._bodies = bodies
+        self._faces = faces
+        self._edges = edges
+        self._beams = beams
+        self._design_points = design_points
+
+        if preexisting_id:
+            self._id = preexisting_id
+            return
+
+        # All ids should be unique - no duplicated values
+        ids = set()
+
         # Loop over bodies, faces and edges
         [ids.add(body.id) for body in bodies]
         [ids.add(face.id) for face in faces]
@@ -107,7 +115,6 @@ def __init__(
         self._grpc_client.log.debug("Requesting creation of named selection.")
         new_named_selection = self._named_selections_stub.Create(named_selection_request)
         self._id = new_named_selection.id
-        self._name = new_named_selection.name
 
     @property
     def id(self) -> str:
@@ -118,3 +125,40 @@ def id(self) -> str:
     def name(self) -> str:
         """Name of the named selection."""
         return self._name
+
+    @property
+    def bodies(self) -> list[Body]:
+        """All bodies in the named selection."""
+        return self._bodies
+
+    @property
+    def faces(self) -> list[Face]:
+        """All faces in the named selection."""
+        return self._faces
+
+    @property
+    def edges(self) -> list[Edge]:
+        """All edges in the named selection."""
+        return self._edges
+
+    @property
+    def beams(self) -> list[Beam]:
+        """All beams in the named selection."""
+        return self._beams
+
+    @property
+    def design_points(self) -> list[DesignPoint]:
+        """All design points in the named selection."""
+        return self._design_points
+
+    def __repr__(self) -> str:
+        """Represent the ``NamedSelection`` as a string."""
+        lines = [f"ansys.geometry.core.designer.selection.NamedSelection {hex(id(self))}"]
+        lines.append(f"  Name                 : {self._name}")
+        lines.append(f"  Id                   : {self._id}")
+        lines.append(f"  N Bodies             : {len(self.bodies)}")
+        lines.append(f"  N Faces              : {len(self.faces)}")
+        lines.append(f"  N Edges              : {len(self.edges)}")
+        lines.append(f"  N Beams              : {len(self.beams)}")
+        lines.append(f"  N Design Points      : {len(self.design_points)}")
+        return "\n".join(lines)

tests/integration/test_design.py

@@ -455,6 +455,37 @@ def test_named_selections(modeler: Modeler):
     assert len(design.named_selections) == 3
 
 
+def test_named_selection_contents(modeler: Modeler):
+    """Test for verifying the correct contents of a ``NamedSelection``."""
+    # Create your design on the server side
+    design = modeler.create_design("NamedSelection_Test")
+
+    # Create objects to add to the named selection
+    box = design.extrude_sketch("box", Sketch().box(Point2D([0, 0]), 1, 1), 1)
+    box_2 = design.extrude_sketch("box_2", Sketch().box(Point2D([0, 0]), 5, 5), 5)
+    face = box_2.faces[2]
+    edge = box_2.edges[0]
+
+    # Create the NamedSelection
+    ns = design.create_named_selection(
+        "MyNamedSelection", bodies=[box, box_2], faces=[face], edges=[edge]
+    )
+
+    print(ns.bodies)
+    # Check that the named selection has everything
+    assert len(ns.bodies) == 2
+    assert np.isin([box.id, box_2.id], [body.id for body in ns.bodies]).all()
+
+    assert len(ns.faces) == 1
+    assert ns.faces[0].id == face.id
+
+    assert len(ns.edges) == 1
+    assert ns.edges[0].id == edge.id
+
+    assert len(ns.beams) == 0
+    assert len(ns.design_points) == 0
+
+
 def test_add_component_with_instance_name(modeler: Modeler):
     design = modeler.create_design("DesignHierarchyExample")
     circle_sketch = Sketch()
@@ -1519,7 +1550,7 @@ def test_named_selections_design_points(modeler: Modeler):
     design points.
     """
     # Create your design on the server side
-    design = modeler.create_design("NamedSelectionBeams_Test")
+    design = modeler.create_design("NamedSelectionDesignPoints_Test")
 
     # Test creating a named selection out of design_points
     point_set_1 = Point3D([10, 10, 0], UNITS.m)