"""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"]