Adding pickable nodes (#1123)

* First implementation of the API

* Improving implementation

* added unit tests

* Updated API. Adding KP support.

* Increasing coverage by covering the errors.

* Fixing failure test

* Fixing code static analyser issues.

* Fixing code static analyser issues.

* Fixing code static analyser issues.

* fix get_ansys_bin for linux

* add in trivial ksel test

* Apply suggestions from code review

Co-authored-by: Alex Kaszynski <[email protected]>

* Fixing unit tests

* Fixing unit tests

* Adding ``plot_function`` for generalize more the ``allow_pickable_points``.
Now non-selection will return an empty list.

* Fixing unit tests

* Adding "current selection" to the window text

* Adding highlighting of selected points

* Fixing code static analyser

* Removing unnecessary prints because now it is more visual.

* Allowing unselecting.
Adding more info to text.
Make title disappear.

* Adding test for the mouse unselecting/selecting

* fix test; fix point picking behavior

* revert change to use mesh points

* fix issue with latest picker

Co-authored-by: Alex Kaszynski <[email protected]>

Author: germa89

examples/00-mapdl-examples/lathe_cutter.py

@@ -161,7 +161,12 @@
 mapdl.csys(1)
 mapdl.view(1, -1, 1, 1)
 mapdl.psymb("CS", 1)
-mapdl.vplot(color_areas=True, show_lines=True, cpos=[-1, 1, 1], smooth_shading=True)
+mapdl.vplot(
+    color_areas=True,
+    show_lines=True,
+    cpos=[-1, 1, 1],
+    smooth_shading=True,
+)
 
 ###############################################################################
 #
@@ -385,11 +390,18 @@
 
 ###############################################################################
 # Generate a single horizontal slice along the XY plane.
+#
+# .. note::
+#    We're using ``eye_dome_lighting`` here to enhance the plots of our slices.
+#    Read more about it at `Eye Dome Lighting
+#    <https://docs.pyvista.org/examples/02-plot/edl.html>`_
+
 single_slice = grid.slice(normal=[0, 0, 1], origin=[0, 0, 0])
 single_slice.plot(
     scalars="p1",
     background="white",
     lighting=False,
+    eye_dome_lighting=True,
     show_edges=False,
     cmap="jet",
     n_colors=9,
@@ -403,6 +415,7 @@
     scalars="p1",
     background="white",
     lighting=False,
+    eye_dome_lighting=True,
     show_edges=False,
     cmap="jet",
     n_colors=9,
@@ -416,13 +429,14 @@
 slices.plot(
     scalars="p1",
     background="white",
-    lighting=False,
     show_edges=False,
+    lighting=False,
+    eye_dome_lighting=True,
     cmap="jet",
     n_colors=9,
     scalar_bar_args=sbar_kwargs,
 )
 
 ###############################################################################
-# Exit MAPDL.
+# Finally, exit MAPDL.
 mapdl.exit()

src/ansys/mapdl/core/mapdl.py

@@ -32,11 +32,13 @@
 from ansys.mapdl.core.inline_functions import Query
 from ansys.mapdl.core.misc import (
     Information,
+    allow_pickable_points,
     last_created,
     load_file,
     random_string,
     run_as_prep7,
     supress_logging,
+    wrap_point_SEL,
 )
 from ansys.mapdl.core.plotting import general_plotter
 from ansys.mapdl.core.post import PostProcessing
@@ -3276,3 +3278,207 @@ def dim(
         return super().dim(
             par, type_, imax, jmax, kmax, var1, var2, var3, csysid, **kwargs
         )
+
+    def _get_selected_(self, entity):  # pragma: no cover
+        """Get list of selected entities."""
+        allowed_values = ["NODE", "ELEM", "KP", "LINE", "AREA", "VOLU"]
+        if entity.upper() not in allowed_values:
+            raise ValueError(
+                f"The value '{entity}' is not allowed."
+                f"Only {allowed_values} are allowed"
+            )
+
+        entity = entity.upper()
+
+        if entity == "NODE":
+            return self.mesh.nnum.copy()
+        elif entity == "ELEM":
+            return self.mesh.enum.copy()
+        elif entity == "KP":
+            return self.geometry.knum
+        elif entity == "LINE":
+            return self.geometry.lnum
+        elif entity == "AREA":
+            return self.geometry.anum
+        elif entity == "VOLU":
+            return self.geometry.vnum
+
+    def _pick_points(self, entity, pl, type_, previous_picked_points, **kwargs):
+        """Show a plot and get the selected points."""
+        _debug = kwargs.pop("_debug", False)  # for testing purposes
+        previous_picked_points = set(previous_picked_points)
+
+        q = self.queries
+        picked_points = []
+        picked_ids = []
+
+        selector = getattr(q, entity.lower())
+
+        # adding selection inversor
+        pl._inver_mouse_click_selection = False
+
+        selection_text = {
+            "S": "New selection",
+            "A": "Adding to selection",
+            "R": "Reselecting from the selection",
+            "U": "Unselecting",
+        }
+
+        def gen_text(picked_points=None):
+            """Generate helpful text for the render window."""
+            sel_ = "Unselecting" if pl._inver_mouse_click_selection else "Selecting"
+            type_text = selection_text[type_]
+            text = (
+                f"Please use the left mouse button to pick the {entity}s.\n"
+                f"Press the key 'u' to change between mouse selecting and unselecting.\n"
+                f"Type: {type_} - {type_text}\n"
+                f"Mouse selection: {sel_}\n"
+            )
+
+            picked_points_str = ""
+            if picked_points:
+                # reverse picked point order, exclude the brackets, and limit
+                # to 40 characters
+                picked_points_str = str(picked_points[::-1])[1:-1]
+                if len(picked_points_str) > 40:
+                    picked_points_str = picked_points_str[:40]
+                    idx = picked_points_str.rfind(",") + 2
+                    picked_points_str = picked_points_str[:idx] + "..."
+
+            return text + f"Current {entity} selection: {picked_points_str}"
+
+        def callback_(mesh, id_):
+            point = mesh.points[id_]
+            node_id = selector(
+                point[0], point[1], point[2]
+            )  # This will only return one node. Fine for now.
+
+            if not pl._inver_mouse_click_selection:
+                # Updating MAPDL points mapping
+                if node_id not in picked_points:
+                    picked_points.append(node_id)
+                # Updating pyvista points mapping
+                if id_ not in picked_ids:
+                    picked_ids.append(id_)
+            else:
+                # Updating MAPDL points mapping
+                if node_id in picked_points:
+                    picked_points.remove(node_id)
+                # Updating pyvista points mapping
+                if id_ in picked_ids:
+                    picked_ids.remove(id_)
+
+            # remov etitle and update text
+            pl.remove_actor("title")
+            pl._picking_text = pl.add_text(
+                gen_text(picked_points),
+                font_size=10,
+                name="_point_picking_message",
+            )
+            if picked_ids:
+                pl.add_mesh(
+                    mesh.points[picked_ids],
+                    color="red",
+                    point_size=10,
+                    name="_picked_points",
+                    pickable=False,
+                    reset_camera=False,
+                )
+            else:
+                pl.remove_actor("_picked_points")
+
+        pl.enable_point_picking(
+            callback=callback_,
+            use_mesh=True,
+            show_message=gen_text(),
+            show_point=True,
+            left_clicking=True,
+            font_size=10,
+            tolerance=kwargs.get("tolerance", 0.025),
+        )
+
+        def callback_u():
+            # inverting bool
+            pl._inver_mouse_click_selection = not pl._inver_mouse_click_selection
+            pl._picking_text = pl.add_text(
+                gen_text(picked_points),
+                font_size=10,
+                name="_point_picking_message",
+            )
+
+        pl.add_key_event("u", callback_u)
+
+        if not _debug:  # pragma: no cover
+            pl.show()
+        else:
+            _debug(pl)
+
+        picked_points = set(
+            picked_points
+        )  # removing duplicates (although there should be none)
+
+        if type_ == "S":
+            pass
+        elif type_ == "R":
+            picked_points = previous_picked_points.intersection(picked_points)
+        elif type_ == "A":
+            picked_points = previous_picked_points.union(picked_points)
+        elif type_ == "U":
+            picked_points = previous_picked_points.difference(picked_points)
+
+        return list(picked_points)
+
+    def _perform_entity_list_selection(
+        self, entity, selection_function, type_, item, comp, vmin, kabs
+    ):
+        """Select entities using CM, and the supplied selection function."""
+        self.cm(f"__temp_{entity}s__", f"{entity}")  # Saving previous selection
+
+        # Getting new selection
+        for id_, each_ in enumerate(vmin):
+            selection_function(
+                self, "S" if id_ == 0 else "A", item, comp, each_, "", "", kabs
+            )
+
+        self.cm(f"__temp_{entity}s_1__", f"{entity}")
+
+        self.cmsel("S", f"__temp_{entity}s__")
+        self.cmsel(type_, f"__temp_{entity}s_1__")
+
+        # Cleaning
+        self.cmdele(f"__temp_{entity}s__")
+        self.cmdele(f"__temp_{entity}s_1__")
+
+    @wraps(Commands.nsel)
+    def nsel(self, *args, **kwargs):
+        """Wraps previons NSEL to allow to use a list/tuple/array for vmin.
+
+        It will raise an error in case vmax or vinc are used too.
+        """
+        sel_func = (
+            super().nsel
+        )  # using super() inside the wrapped function confuses the references
+
+        @allow_pickable_points()
+        @wrap_point_SEL(entity="node")
+        def wrapped(self, *args, **kwargs):
+            return sel_func(*args, **kwargs)
+
+        return wrapped(self, *args, **kwargs)
+
+    @wraps(Commands.ksel)
+    def ksel(self, *args, **kwargs):
+        """Wraps superclassed KSEL to allow to use a list/tuple/array for vmin.
+
+        It will raise an error in case vmax or vinc are used too.
+        """
+        sel_func = (
+            super().ksel
+        )  # using super() inside the wrapped function confuses the references
+
+        @allow_pickable_points(entity="kp", plot_function="kplot")
+        @wrap_point_SEL(entity="kp")
+        def wrapped(self, *args, **kwargs):
+            return sel_func(*args, **kwargs)
+
+        return wrapped(self, *args, **kwargs)