Source code for pyvcad_rendering.mesh_selection_ui

"""Standalone VTK/wx auxiliary tool for authoring reusable mesh triangle selections."""

# STD
from pathlib import Path

# VTK
from vtkmodules.vtkCommonCore import vtkPoints
from vtkmodules.vtkCommonDataModel import vtkCellArray, vtkPolyData
from vtkmodules.vtkFiltersCore import vtkPolyDataNormals
from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
from vtkmodules.vtkRenderingCore import vtkActor, vtkCellPicker, vtkPolyDataMapper, vtkRenderer
import vtkmodules.vtkRenderingOpenGL2  # noqa: F401 - registers the OpenGL backend

# GUI
import wx

# OpenVCAD
import pyvcad as pv

from .dpi_aware_interactor import DPIAwareVTKInteractor
from .mesh_selection import (
    mesh_selection_recipe,
    resolve_selection_mesh,
    save_mesh_selection,
)


METHOD_LABELS = (
    "Manual triangles",
    "Select linked",
    "Linked by face angle",
    "Geodesic radius",
)
METHOD_IDS = ("manual", "linked", "linked_by_face_angle", "geodesic_radius")
ACTION_LABELS = ("Replace", "Add", "Remove")
ACTION_IDS = ("replace", "add", "remove")


def _polydata(vertices, triangles, triangle_ids=None):
    points = vtkPoints()
    points.SetNumberOfPoints(len(vertices))
    for index, vertex in enumerate(vertices):
        points.SetPoint(index, float(vertex.x), float(vertex.y), float(vertex.z))

    cells = vtkCellArray()
    ids = range(len(triangles)) if triangle_ids is None else triangle_ids
    for triangle_id in ids:
        triangle = triangles[triangle_id]
        cells.InsertNextCell(3)
        cells.InsertCellPoint(int(triangle[0]))
        cells.InsertCellPoint(int(triangle[1]))
        cells.InsertCellPoint(int(triangle[2]))

    data = vtkPolyData()
    data.SetPoints(points)
    data.SetPolys(cells)
    return data


def _actor_for_polydata(polydata, color, opacity=1.0, edges=False, offset=False):
    normals = vtkPolyDataNormals()
    normals.SetInputData(polydata)
    normals.ComputePointNormalsOff()
    normals.ComputeCellNormalsOn()
    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(normals.GetOutputPort())
    mapper.ScalarVisibilityOff()
    if offset:
        mapper.SetResolveCoincidentTopologyToPolygonOffset()
        mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(-4.0, -4.0)
    actor = vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(*color)
    actor.GetProperty().SetOpacity(opacity)
    actor.GetProperty().SetEdgeVisibility(bool(edges))
    actor.GetProperty().SetEdgeColor(0.15, 0.17, 0.20)
    actor.GetProperty().SetLineWidth(1.0)
    return actor, mapper


def _line_polydata(vertices, edges):
    points = vtkPoints()
    points.SetNumberOfPoints(len(vertices))
    for index, vertex in enumerate(vertices):
        points.SetPoint(index, float(vertex.x), float(vertex.y), float(vertex.z))
    lines = vtkCellArray()
    for first, second in edges:
        lines.InsertNextCell(2)
        lines.InsertCellPoint(int(first))
        lines.InsertCellPoint(int(second))
    data = vtkPolyData()
    data.SetPoints(points)
    data.SetLines(lines)
    return data


[docs] class MeshSelectionFrame(wx.Frame): """Purpose-built mesh picker kept separate from the normal OpenVCAD renderer.""" def __init__(self, mesh, voxel_size=None, initial_selection=None, parent=None): super().__init__(parent, title="OpenVCAD Mesh Selection") if not isinstance(mesh, pv.SurfaceMesh): raise TypeError("mesh must be a pyvcad.SurfaceMesh") if initial_selection is not None: if not isinstance(initial_selection, pv.MeshSelection): raise TypeError("initial_selection must be a pyvcad.MeshSelection") if initial_selection.source_fingerprint != mesh.fingerprint: raise ValueError("initial_selection belongs to different source geometry") self.mesh = mesh self.voxel_size = voxel_size self.result = None self._accepted = False self._vertices = mesh.vertices self._triangles = mesh.triangles self._selected_ids = set(initial_selection.triangle_ids if initial_selection else []) self._recipe = {"method": "manual"} self._preview = None self._painting = False self._paint_base = set() self._painted_ids = set() self._paint_action = "replace" self.SetSize(self.FromDIP(wx.Size(1180, 760))) self.SetMinSize(self.FromDIP(wx.Size(920, 620))) self._build_ui() self._build_scene() self._bind_events() self._refresh_selection(render=False) self.Centre() self.Show() # Reapply native Choice defaults after the macOS controls are realized. Some wx builds # transiently advance a newly created popup by one item during window realization. self.method_choice.SetStringSelection("Linked by face angle") self.action_choice.SetStringSelection("Replace") self.angle_control.Enable(True) self.angle_label.Enable(True) def _build_ui(self): content = wx.Panel(self) layout = wx.BoxSizer(wx.HORIZONTAL) self.vtk_widget = DPIAwareVTKInteractor(content, -1) self.vtk_widget.Enable(1) layout.Add(self.vtk_widget, 1, wx.EXPAND) controls = wx.Panel(content) controls.SetMinSize(self.FromDIP(wx.Size(310, -1))) control_layout = wx.BoxSizer(wx.VERTICAL) title = wx.StaticText(controls, label="Mesh patch selection") font = title.GetFont() font.SetPointSize(font.GetPointSize() + 3) font.SetWeight(wx.FONTWEIGHT_BOLD) title.SetFont(font) control_layout.Add(title, 0, wx.LEFT | wx.RIGHT | wx.TOP, 16) help_text = wx.StaticText( controls, label="Choose a method, then click the mesh. Switch to Navigate to orbit the camera.", ) help_text.Wrap(self.FromDIP(275)) control_layout.Add(help_text, 0, wx.ALL, 16) control_layout.Add(wx.StaticText(controls, label="Interaction"), 0, wx.LEFT | wx.RIGHT, 16) self.interaction_choice = wx.Choice(controls, choices=("Select triangles", "Navigate camera")) self.interaction_choice.SetSelection(0) control_layout.Add(self.interaction_choice, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) control_layout.Add(wx.StaticText(controls, label="Selection method"), 0, wx.LEFT | wx.RIGHT, 16) self.method_choice = wx.Choice(controls, choices=METHOD_LABELS) self.method_choice.SetSelection(2) control_layout.Add(self.method_choice, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) self.angle_label = wx.StaticText(controls, label="Maximum local face angle") control_layout.Add(self.angle_label, 0, wx.LEFT | wx.RIGHT, 16) self.angle_control = wx.SpinCtrlDouble(controls, min=0.0, max=180.0, initial=30.0, inc=1.0) self.angle_control.SetDigits(1) control_layout.Add(self.angle_control, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) self.radius_label = wx.StaticText(controls, label="Geodesic radius (mm)") control_layout.Add(self.radius_label, 0, wx.LEFT | wx.RIGHT, 16) self.radius_control = wx.SpinCtrlDouble( controls, min=0.0, max=1000000.0, initial=10.0, inc=1.0 ) self.radius_control.SetDigits(2) self.radius_label.Enable(False) self.radius_control.Enable(False) control_layout.Add(self.radius_control, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) control_layout.Add(wx.StaticText(controls, label="Edit action"), 0, wx.LEFT | wx.RIGHT, 16) self.action_choice = wx.Choice(controls, choices=ACTION_LABELS) self.action_choice.SetSelection(0) control_layout.Add(self.action_choice, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) quick_buttons = wx.BoxSizer(wx.HORIZONTAL) self.clear_button = wx.Button(controls, label="Clear") self.invert_button = wx.Button(controls, label="Invert") quick_buttons.Add(self.clear_button, 1, wx.RIGHT, 6) quick_buttons.Add(self.invert_button, 1) control_layout.Add(quick_buttons, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) ring_buttons = wx.BoxSizer(wx.HORIZONTAL) self.grow_button = wx.Button(controls, label="Grow one ring") self.shrink_button = wx.Button(controls, label="Shrink one ring") ring_buttons.Add(self.grow_button, 1, wx.RIGHT, 6) ring_buttons.Add(self.shrink_button, 1) control_layout.Add(ring_buttons, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) self.summary_label = wx.StaticText(controls, label="") control_layout.Add(self.summary_label, 0, wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) self.validation_label = wx.StaticText( controls, label="Conformal validation has not been run." ) self.validation_label.Wrap(self.FromDIP(275)) control_layout.Add(self.validation_label, 0, wx.LEFT | wx.RIGHT | wx.BOTTOM, 12) self.validate_button = wx.Button(controls, label="Validate conformal patch") control_layout.Add(self.validate_button, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) control_layout.AddStretchSpacer(1) output_buttons = wx.BoxSizer(wx.HORIZONTAL) self.copy_button = wx.Button(controls, label="Copy IDs") self.save_button = wx.Button(controls, label="Save JSON…") output_buttons.Add(self.copy_button, 1, wx.RIGHT, 6) output_buttons.Add(self.save_button, 1) control_layout.Add(output_buttons, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 16) finish_buttons = wx.StdDialogButtonSizer() self.cancel_button = wx.Button(controls, wx.ID_CANCEL) self.accept_button = wx.Button(controls, wx.ID_OK, label="Use Selection") self.accept_button.SetDefault() finish_buttons.AddButton(self.cancel_button) finish_buttons.AddButton(self.accept_button) finish_buttons.Realize() control_layout.Add(finish_buttons, 0, wx.EXPAND | wx.ALL, 16) controls.SetSizer(control_layout) layout.Add(controls, 0, wx.EXPAND) content.SetSizer(layout) frame_layout = wx.BoxSizer(wx.VERTICAL) frame_layout.Add(content, 1, wx.EXPAND) self.SetSizer(frame_layout) self.CreateStatusBar().SetStatusText("Click a mesh face to begin.") def _build_scene(self): self.renderer = vtkRenderer() self.renderer.SetBackground(0.96, 0.97, 0.98) self.render_window = self.vtk_widget.GetRenderWindow() self.render_window.AddRenderer(self.renderer) interactor = self.render_window.GetInteractor() interactor.SetInteractorStyle(vtkInteractorStyleTrackballCamera()) self.base_polydata = _polydata(self._vertices, self._triangles) self.base_actor, self.base_mapper = _actor_for_polydata( self.base_polydata, (0.70, 0.73, 0.78), opacity=1.0, edges=True ) self.selection_actor, self.selection_mapper = _actor_for_polydata( _polydata(self._vertices, self._triangles, []), (1.0, 0.35, 0.05), opacity=1.0, edges=True, offset=True, ) self.boundary_mapper = vtkPolyDataMapper() self.boundary_mapper.SetInputData(_line_polydata(self._vertices, [])) self.boundary_actor = vtkActor() self.boundary_actor.SetMapper(self.boundary_mapper) self.boundary_actor.GetProperty().SetColor(0.05, 0.15, 0.25) self.boundary_actor.GetProperty().SetLineWidth(4.0) self.renderer.AddActor(self.base_actor) self.renderer.AddActor(self.selection_actor) self.renderer.AddActor(self.boundary_actor) self.renderer.ResetCamera() self.picker = vtkCellPicker() self.picker.SetTolerance(0.002) self.picker.InitializePickList() self.picker.AddPickList(self.base_actor) self.picker.PickFromListOn() self._left_press_tag = interactor.AddObserver( "LeftButtonPressEvent", self._on_left_button_press, 10.0 ) interactor.AddObserver("MouseMoveEvent", self._on_mouse_move, 10.0) interactor.AddObserver("LeftButtonReleaseEvent", self._on_left_button_release, 10.0) def _bind_events(self): self.Bind(wx.EVT_CLOSE, self._on_close) self.method_choice.Bind(wx.EVT_CHOICE, self._on_method_change) self.angle_control.Bind(wx.EVT_SPINCTRLDOUBLE, self._on_angle_change) self.angle_control.Bind(wx.EVT_TEXT, self._on_angle_change) self.radius_control.Bind(wx.EVT_SPINCTRLDOUBLE, self._on_radius_change) self.radius_control.Bind(wx.EVT_TEXT, self._on_radius_change) self.clear_button.Bind(wx.EVT_BUTTON, self._on_clear) self.invert_button.Bind(wx.EVT_BUTTON, self._on_invert) self.grow_button.Bind(wx.EVT_BUTTON, self._on_grow) self.shrink_button.Bind(wx.EVT_BUTTON, self._on_shrink) self.validate_button.Bind(wx.EVT_BUTTON, self._on_validate) self.copy_button.Bind(wx.EVT_BUTTON, self._on_copy) self.save_button.Bind(wx.EVT_BUTTON, self._on_save) self.accept_button.Bind(wx.EVT_BUTTON, self._on_accept) self.cancel_button.Bind(wx.EVT_BUTTON, self._on_cancel) def _on_left_button_press(self, caller, _event): if self.interaction_choice.GetSelection() != 0: return interactor = self.render_window.GetInteractor() x, y = interactor.GetEventPosition() if not self.picker.Pick(x, y, 0, self.renderer): return triangle_id = int(self.picker.GetCellId()) if triangle_id < 0: return point = tuple(float(value) for value in self.picker.GetPickPosition()) method = METHOD_IDS[self.method_choice.GetSelection()] if method == "manual": self._start_paint(triangle_id) else: self._begin_selection(triangle_id, point) command = caller.GetCommand(self._left_press_tag) if command is not None: command.SetAbortFlag(1) def _start_paint(self, triangle_id): self._painting = True self._paint_base = set(self._selected_ids) self._painted_ids = set() self._paint_action = ACTION_IDS[self.action_choice.GetSelection()] self._paint_triangle(triangle_id) def _paint_triangle(self, triangle_id): if triangle_id in self._painted_ids: return self._painted_ids.add(triangle_id) if self._paint_action == "replace": self._selected_ids = set(self._painted_ids) elif self._paint_action == "add": self._selected_ids = self._paint_base | self._painted_ids else: self._selected_ids = self._paint_base - self._painted_ids self._recipe = {"method": "manual"} self._preview = None self._refresh_selection() def _on_mouse_move(self, _caller, _event): if not self._painting or self.interaction_choice.GetSelection() != 0: return interactor = self.render_window.GetInteractor() x, y = interactor.GetEventPosition() if self.picker.Pick(x, y, 0, self.renderer): triangle_id = int(self.picker.GetCellId()) if triangle_id >= 0: self._paint_triangle(triangle_id) def _on_left_button_release(self, _caller, _event): self._painting = False def _begin_selection(self, triangle_id, point): method = METHOD_IDS[self.method_choice.GetSelection()] action = ACTION_IDS[self.action_choice.GetSelection()] self._preview = { "base": set(self._selected_ids), "triangle_id": triangle_id, "point": point, "method": method, "action": action, } self._apply_preview() def _apply_preview(self): if self._preview is None: return method = self._preview["method"] triangle_id = self._preview["triangle_id"] if method == "manual": candidate = self.mesh.select_triangles([triangle_id]) recipe = {"method": "manual"} elif method == "linked": candidate = self.mesh.select_linked(triangle_id) recipe = mesh_selection_recipe("linked", point=self._preview["point"]) elif method == "linked_by_face_angle": angle = self.angle_control.GetValue() candidate = self.mesh.select_linked_by_face_angle(triangle_id, angle) recipe = mesh_selection_recipe( "linked_by_face_angle", point=self._preview["point"], max_angle_degrees=angle ) else: radius = self.radius_control.GetValue() seed_vertex = self.mesh.nearest_vertex(pv.Vec3(self._preview["point"])) candidate = self.mesh.select_by_geodesic_radius(seed_vertex, radius) recipe = mesh_selection_recipe( "geodesic_radius", point=self._preview["point"], radius=radius ) candidate_ids = set(candidate.triangle_ids) base = self._preview["base"] action = self._preview["action"] if action == "replace": self._selected_ids = candidate_ids self._recipe = recipe elif action == "add": self._selected_ids = base | candidate_ids self._recipe = recipe if not base else {"method": "manual"} else: self._selected_ids = base - candidate_ids self._recipe = {"method": "manual"} self._refresh_selection() def _refresh_selection(self, render=True): selected = sorted(self._selected_ids) self.selection_mapper.SetInputData(_polydata(self._vertices, self._triangles, selected)) self.selection_mapper.Update() if selected: selection = self.mesh.select_triangles(selected) area = selection.area boundary_edges = selection.boundary_edges() else: area = 0.0 boundary_edges = [] self.boundary_mapper.SetInputData(_line_polydata(self._vertices, boundary_edges)) self.boundary_mapper.Update() self.summary_label.SetLabel( "{} of {} triangles\nSelected area: {:.3f} mm²".format( len(selected), len(self._triangles), area ) ) self.validation_label.SetLabel("Conformal validation has not been run.") self.accept_button.Enable(bool(selected)) self.copy_button.Enable(bool(selected)) self.save_button.Enable(bool(selected)) self.validate_button.Enable(bool(selected)) if render: self.render_window.Render() def _on_method_change(self, _event): method = METHOD_IDS[self.method_choice.GetSelection()] is_angle = method == "linked_by_face_angle" is_radius = method == "geodesic_radius" self.angle_control.Enable(is_angle) self.angle_label.Enable(is_angle) self.radius_control.Enable(is_radius) self.radius_label.Enable(is_radius) self._preview = None def _on_angle_change(self, _event): if self._preview is not None and self._preview["method"] == "linked_by_face_angle": self._apply_preview() def _on_radius_change(self, _event): if self._preview is not None and self._preview["method"] == "geodesic_radius": self._apply_preview() def _on_clear(self, _event): self._selected_ids.clear() self._recipe = {"method": "manual"} self._preview = None self._refresh_selection() def _on_invert(self, _event): self._selected_ids = set(range(len(self._triangles))) - self._selected_ids self._recipe = {"method": "manual"} self._preview = None self._refresh_selection() def _on_grow(self, _event): if not self._selected_ids: return selection = self.mesh.select_triangles(sorted(self._selected_ids)).grown() self._selected_ids = set(selection.triangle_ids) self._recipe = {"method": "manual"} self._preview = None self._refresh_selection() def _on_shrink(self, _event): if not self._selected_ids: return selection = self.mesh.select_triangles(sorted(self._selected_ids)).shrunk() self._selected_ids = set(selection.triangle_ids) self._recipe = {"method": "manual"} self._preview = None self._refresh_selection() def _on_validate(self, _event): try: surface = self.mesh.select_triangles( sorted(self._selected_ids) ).to_triangle_mesh_surface() self.validation_label.SetLabel( "Conformal patch ready: one connected open disk, {} triangles.".format( surface.triangle_count ) ) except RuntimeError as error: self.validation_label.SetLabel("Not a conformal disk: {}".format(error)) self.validation_label.Wrap(self.FromDIP(275)) self.Layout() def _on_copy(self, _event): text = repr(sorted(self._selected_ids)) if wx.TheClipboard.Open(): wx.TheClipboard.SetData(wx.TextDataObject(text)) wx.TheClipboard.Close() self.SetStatusText("Copied {} triangle IDs.".format(len(self._selected_ids))) def _on_save(self, _event): dialog = wx.FileDialog( self, message="Save mesh selection", wildcard="OpenVCAD mesh selection (*.selection.json)|*.selection.json|JSON (*.json)|*.json", style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT, ) if dialog.ShowModal() != wx.ID_OK: dialog.Destroy() return path = Path(dialog.GetPath()) dialog.Destroy() if not path.name.endswith(".json"): path = path.with_name(path.name + ".selection.json") try: save_mesh_selection( self.mesh.select_triangles(sorted(self._selected_ids)), path, recipe=self._recipe, voxel_size=self.voxel_size, ) self.SetStatusText("Saved selection to {}".format(path)) except (OSError, RuntimeError, ValueError) as error: wx.MessageBox(str(error), "Unable to save selection", wx.OK | wx.ICON_ERROR, self) def _on_accept(self, _event): if not self._selected_ids: return self.result = self.mesh.select_triangles(sorted(self._selected_ids)) self._accepted = True self.Close() def _on_cancel(self, _event): self.result = None self.Close() def _on_close(self, event): if not self._accepted: self.result = None event.Skip()
[docs] def select_mesh_patch(source, voxel_size=None, initial_selection=None): """Open the auxiliary picker and return a ``pyvcad.MeshSelection`` or ``None``. ``source`` may be an existing ``SurfaceMesh`` or an OpenVCAD ``Node``. Tree inputs require an explicit voxel size because the selected triangle IDs are resolution-specific. Arguments: source (SurfaceMesh | Node): The mesh, or the tree to mesh. voxel_size (float, optional): Meshing voxel size in mm. Required for a ``Node``. initial_selection (MeshSelection, optional): Triangles to show as selected when the picker opens. Returns: MeshSelection | None: The accepted selection, or None if the picker was closed without one. Raises: RuntimeError: If called while a wx event loop is already running. """ if wx.App.Get() is not None: raise RuntimeError("select_mesh_patch must be launched outside an existing wx event loop") mesh = resolve_selection_mesh(source, voxel_size=voxel_size) with wx.LogNull(): app = wx.App(False) app.frame = MeshSelectionFrame( mesh, voxel_size=voxel_size, initial_selection=initial_selection ) app.MainLoop() return app.frame.result
[docs] def Select_Mesh_Patch(source, voxel_size=None, initial_selection=None): """Alias for :func:`select_mesh_patch`.""" return select_mesh_patch(source, voxel_size=voxel_size, initial_selection=initial_selection)
__all__ = ["MeshSelectionFrame", "Select_Mesh_Patch", "select_mesh_patch"]