"""Main application window — application shell, menus, panels, operations."""
from __future__ import annotations
import math
import logging
import os
import sys
import tempfile
import uuid
from datetime import datetime
from typing import Any, Dict, List, Optional, Tuple
from PySide6.QtCore import Qt, Signal, Slot, QPoint, QPointF, QSize, QRect, QSettings
from PySide6.QtGui import (
QAction,
QColor,
QFont,
QIcon,
QKeySequence,
QPainter,
QPainterPath,
QPen,
)
MAX_RECENT_PROJECTS = 10
from PySide6.QtWidgets import (
QApplication,
QButtonGroup,
QCheckBox,
QComboBox,
QDialog,
QDialogButtonBox,
QDockWidget,
QDoubleSpinBox,
QFileDialog,
QFrame,
QGridLayout,
QGroupBox,
QHBoxLayout,
QInputDialog,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QMainWindow,
QMenu,
QMenuBar,
QMessageBox,
QPushButton,
QRadioButton,
QSizePolicy,
QSplitter,
QSpinBox,
QStatusBar,
QTabWidget,
QTextEdit,
QToolBar,
QTreeWidget,
QTreeWidgetItem,
QVBoxLayout,
QWidget,
)
from fluency.geometry_occ.kernel import OCGeometryKernel, OCCGeometryObject
from fluency.geometry_occ.sketch import OCCSketch
from fluency.geometry.base import Point2D, Point3D
from fluency.io.project_io import load_project, project_zip_path, save_project
from fluency.models.data_model import Project, Component, Sketch, Body, Workplane
from fluency.rendering.occ_renderer import OCCRenderer
from fluency.ui.dialogs import (
ExtrudeDialog,
OffsetDialog,
RevolveDialog,
WorkplaneOrientationDialog,
)
from fluency.ui.sketch_widget import Sketch2DWidget
from fluency.ui.viewer_widget import Viewer3DWidget
from gui_ui import Ui_fluencyCAD # auto-generated Qt form (project root on sys.path)
logger = logging.getLogger(__name__)
def _project_body_to_workplane(
body_shape: Any,
workplane: Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]],
) -> List[List[Tuple[float, float]]]:
"""Project ALL edges of a 3D body onto a workplane, returning UV polylines.
*workplane* is (origin, normal, x_dir). Every edge (linear and curved)
of every face of *body_shape* is projected onto the workplane by mapping
each sample point from 3D \u2192 UV (orthographic projection along the
workplane normal). The result is a list of polylines, each a list of
(u, v) points, suitable as underlay construction lines in the 2D sketch.
This lets the user see the body's silhouette from the workplane's
perspective and draw sketches precisely aligned to the body's features.
"""
import numpy as np
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_EDGE, TopAbs_FACE, TopAbs_WIRE
from OCP.TopoDS import TopoDS
from OCP.BRepAdaptor import BRepAdaptor_Curve, BRepAdaptor_Surface
from OCP.GeomAbs import GeomAbs_Line
from OCP.gp import gp_Pnt
origin = np.asarray(workplane[0], dtype=float)
normal = np.asarray(workplane[1], dtype=float)
x_dir = np.asarray(workplane[2], dtype=float)
x_dir = x_dir / np.linalg.norm(x_dir)
normal = normal / np.linalg.norm(normal)
y_dir = np.cross(normal, x_dir)
y_dir = y_dir / np.linalg.norm(y_dir)
def world_to_uv(p: gp_Pnt) -> Tuple[float, float]:
v = np.array([p.X() - origin[0], p.Y() - origin[1], p.Z() - origin[2]])
return (float(np.dot(v, x_dir)), float(np.dot(v, y_dir)))
polylines: List[List[Tuple[float, float]]] = []
# Iterate every face of the body, then each wire/edge within.
face_expl = TopExp_Explorer(body_shape, TopAbs_FACE)
while face_expl.More():
face = face_expl.Current()
wire_expl = TopExp_Explorer(face, TopAbs_WIRE)
while wire_expl.More():
wire = wire_expl.Current()
edge_expl = TopExp_Explorer(wire, TopAbs_EDGE)
while edge_expl.More():
edge = TopoDS.Edge_s(edge_expl.Current())
try:
crv = BRepAdaptor_Curve(edge)
f = crv.FirstParameter()
l = crv.LastParameter()
is_line = crv.GetType() == GeomAbs_Line
if is_line:
pts = [crv.Value(f), crv.Value(l)]
else:
# Sample 24 segments \u2014 enough for smooth curves.
pts = [crv.Value(f + (l - f) * i / 24.0) for i in range(25)]
poly = [world_to_uv(p) for p in pts]
polylines.append(poly)
except Exception:
pass
edge_expl.Next()
wire_expl.Next()
face_expl.Next()
return polylines
def _offset_polygon(points: List[Tuple[float, float]], distance: float) -> List[Tuple[float, float]]:
"""Offset a closed polygon by *distance* (positive = outward).
Uses the edge-normal method: each edge is offset along its outward
normal, then adjacent offset edges are intersected to find the new
vertex positions. Handles convex polygons well; concave (reflex)
corners may produce self-intersecting results for large offsets.
Returns the offset polygon as a list of (x, y) tuples (same length
as *points*, closed).
"""
import math
n = len(points)
if n < 3:
return list(points)
# Determine polygon orientation (signed area).
area = 0.0
for i in range(n):
j = (i + 1) % n
area += points[i][0] * points[j][1] - points[j][0] * points[i][1]
is_ccw = area > 0.0
# Compute edge directions and left normals.
edges: List[Tuple[float, float]] = []
normals: List[Tuple[float, float]] = []
for i in range(n):
j = (i + 1) % n
dx = points[j][0] - points[i][0]
dy = points[j][1] - points[i][1]
length = math.hypot(dx, dy)
if length < 1e-9:
edges.append((0.0, 0.0))
normals.append((0.0, 0.0))
else:
ux = dx / length
uy = dy / length
edges.append((ux, uy))
# Left normal: (-uy, ux)
normals.append((-uy, ux))
# For CCW polygons the left normal points *inward*; flip for outward.
if is_ccw:
normals = [(-nx, -ny) for (nx, ny) in normals]
result: List[Tuple[float, float]] = []
for i in range(n):
prev_i = (i - 1 + n) % n
n_prev = normals[prev_i] # outward normal of edge (prev, i)
n_curr = normals[i] # outward normal of edge (i, next)
# Intersect the two offset edge lines to find the new vertex.
# Line 1: through points[prev_i] + d*n_prev, direction = edges[prev_i]
# Line 2: through points[i] + d*n_curr, direction = edges[i]
p1x = points[prev_i][0] + distance * n_prev[0]
p1y = points[prev_i][1] + distance * n_prev[1]
d1x, d1y = edges[prev_i]
p2x = points[i][0] + distance * n_curr[0]
p2y = points[i][1] + distance * n_curr[1]
d2x, d2y = edges[i]
det = d1x * d2y - d1y * d2x
if abs(det) < 1e-9:
# Parallel edges — fall back to normal offset.
result.append((points[i][0] + distance * n_curr[0],
points[i][1] + distance * n_curr[1]))
else:
diff_x = p2x - p1x
diff_y = p2y - p1y
t1 = (diff_x * d2y - diff_y * d2x) / det
result.append((p1x + t1 * d1x, p1y + t1 * d1y))
return result
class MainWindow(QMainWindow):
"""Main application window."""
def __init__(self):
super().__init__()
logger.info("Initializing MainWindow")
self._project = Project()
self._kernel = OCGeometryKernel()
logger.info("Created Project and OCGeometryKernel")
self._current_component: Optional[Component] = None
self._current_sketch: Optional[Sketch] = None
self._selected_body: Optional[Body] = None
self._component_buttons: List[QPushButton] = []
self._component_group: Optional[QButtonGroup] = None
# Assembly state
self._assembly_component_buttons: List[QPushButton] = []
self._assembly_component_group: Optional[QButtonGroup] = None
self._assembly_view_active: bool = False
self._selected_assembly_component_id: Optional[str] = None
# Connector two-click state
self._connector_first_pick: Optional[Dict[str, Any]] = None
self._connector_second_ac_id: Optional[str] = None
self._connector_align_pos: Any = None
# Drag-move state for assembly components
self._asm_move_ac_id: Optional[str] = None
self._asm_move_start_pos: Any = None
# Rigid-group drag state: maps every component id in the dragged
# rigid group to its start position, so the whole group translates
# together and connected partners keep their solved relative
# transforms. Keyed by AssemblyComponent.id.
self._asm_move_group_start: Dict[str, Any] = {}
# Cached rigid-group membership for the current drag (avoids recomputing
# the BFS graph on every mouse-move event).
self._asm_move_group_ids: List[str] = []
# Cache of render object IDs per assembly component, so drag updates
# can replace only the moved component's shapes without clearing the
# entire scene (avoids camera flicker).
self._asm_render_objects: Dict[str, List[str]] = {}
# ── Project file state ──
# The path the project was loaded from / last saved to. None means
# the project is unsaved (the title bar will show "Untitled").
# ``_dirty`` is set on any edit; cleared after a successful save.
self._project_path: Optional[str] = None
self._dirty: bool = False
# Suppresses ``_mark_dirty`` while we're setting up the default
# project (init / new / open), so a freshly-created empty project
# doesn't immediately show as "modified" in the title bar.
self._suspend_dirty: bool = True
# ── Settings (persistent preferences) ──
self._settings = QSettings("FluencyCAD", "FluencyCAD")
self._setup_ui()
self._setup_connections()
self._create_initial_component()
self._create_initial_assembly()
self._setup_recent_projects()
self._suspend_dirty = False
self._update_window_title()
logger.info("MainWindow initialization complete")
def _setup_ui(self):
self.setWindowTitle("Fluency CAD 2.0")
self.setMinimumSize(1400, 900)
# Central widget first so ``self._ui`` is populated when we wire
# the File menu actions to their handlers.
self._create_central_widget()
self._create_menus()
self._create_dock_widgets()
self._setup_ui_aliases()
logger.info("Ready")
def _create_menus(self):
"""Wire up the File menu actions defined in the .ui file.
The File menu and its QActions (``actionNew_Project``,
``actionOpen_Project``, ``actionSave_Project``, etc.) are all
declared in ``gui.ui`` so they integrate cleanly with the macOS
system menubar. This method only connects the actions to their
handlers and adds the runtime-only View / Help menus.
"""
# ── File menu actions (defined in gui.ui) ──
self._ui.actionNew_Project.triggered.connect(self._new_project)
self._ui.actionOpen_Project.triggered.connect(self._open_project)
self._ui.actionSave_Project.triggered.connect(self._save_project)
self._ui.actionSave_Project_As.triggered.connect(self._save_project_as)
self._ui.actionImport_File.triggered.connect(self._import_file)
self._ui.actionExport_Step.triggered.connect(self._export_step)
self._ui.actionExport_Iges.triggered.connect(self._export_iges)
self._ui.actionExport_Stl.triggered.connect(self._export_stl)
self._ui.actionExit.triggered.connect(self.close)
# ── Recent Projects submenu (runtime-only) ──
file_menu = self._ui.menuFile
self._recent_projects_menu = QMenu("Recent Projects", self)
file_menu.addMenu(self._recent_projects_menu)
self._update_recent_menu()
# ── Load Last Project on Startup toggle ──
file_menu.addSeparator()
self._action_load_last = QAction("Load Last Project on Startup", self)
self._action_load_last.setCheckable(True)
self._action_load_last.setChecked(self._settings.value("load_last_on_startup", False, type=bool))
self._action_load_last.toggled.connect(self._toggle_load_last_project)
file_menu.addAction(self._action_load_last)
# ── View menu (runtime-only, not in the .ui) ──
view_menu = self.menuBar().addMenu("&View")
view_menu.addAction("Fit All", self._fit_view)
view_menu.addAction("Reset View", self._reset_view)
view_menu.addSeparator()
for view_name in ["Isometric", "Top", "Front", "Right", "Back", "Left", "Bottom"]:
action = QAction(view_name, self)
action.triggered.connect(
lambda checked, v=view_name.lower(): self._viewer_3d.set_view(v)
)
view_menu.addAction(action)
# ── Help menu (runtime-only, not in the .ui) ──
help_menu = self.menuBar().addMenu("&Help")
help_menu.addAction("About", self._show_about)
def _create_central_widget(self):
"""Load the compiled UI file and add programmatic custom widgets."""
self._ui = Ui_fluencyCAD()
self._ui.setupUi(self)
# Keep a reference to the grid for panel-focus management.
self._grid = self._ui.gridLayout
# -- Add programmatic custom widgets to their placeholder locations --
# Sketch2DWidget goes in the sketch tab’s QVBoxLayout.
self._sketch_widget = Sketch2DWidget()
self._ui.sketch_tab.layout().addWidget(self._sketch_widget)
# Viewer3DWidget goes in the gl_box QHBoxLayout.
self._viewer_3d = Viewer3DWidget()
self._ui.gl_box.layout().addWidget(self._viewer_3d)
# Code editor — use the UI’s textEdit with our custom font.
self._code_edit = self._ui.textEdit
self._code_edit.setFont(QFont("Monaco", 10))
self._code_edit.setPlaceholderText("# Enter Python code here...")
# Component buttons (dynamically generated per component, not in UI).
self._component_box = QWidget()
self._component_box_layout = QHBoxLayout(self._component_box)
self._component_box_layout.setAlignment(Qt.AlignLeft)
self._component_group = QButtonGroup(self)
self._component_group.setExclusive(True)
# Add to the Components group box from the UI.
compo_layout = self._ui.compo_box.layout()
if compo_layout is None:
compo_layout = QHBoxLayout(self._ui.compo_box)
compo_layout.setContentsMargins(0, 0, 0, 0)
compo_layout.addWidget(self._component_box)
compo_layout.addStretch()
# ── Assembly box (dynamic buttons like component box) ──
self._assembly_box = QWidget()
self._assembly_box_layout = QHBoxLayout(self._assembly_box)
self._assembly_box_layout.setAlignment(Qt.AlignLeft)
self._assembly_component_group = QButtonGroup(self)
self._assembly_component_group.setExclusive(True)
# Add to the Assembly group box from the UI.
asm_layout = self._ui.assembly_box.layout()
if asm_layout is None:
asm_layout = QHBoxLayout(self._ui.assembly_box)
asm_layout.setContentsMargins(0, 0, 0, 0)
asm_layout.addWidget(self._assembly_box)
asm_layout.addStretch()
# ── Assembly Move button (programmatic, in assembly_tools) ──
self._btn_asm_move = QPushButton("Pos")
self._btn_asm_move.setCheckable(True)
self._btn_asm_move.setMinimumSize(QSize(50, 50))
self._btn_asm_move.setMaximumSize(QSize(50, 50))
self._btn_asm_move.setToolTip("Toggle: click a body in 3D and drag to move the assembly component")
asm_tools_layout = self._ui.assembly_tools.layout()
if asm_tools_layout is not None:
asm_tools_layout.addWidget(self._btn_asm_move, 0, 2, 1, 1)
# Panel-focus mode (equal | sketch | viewer).
self._panel_focus: str = "equal"
def _setup_ui_aliases(self):
"""Create _btn_* aliases pointing to the UI-loaded widgets.
The rest of the application references widgets via ``self._btn_*``
names. This method maps those to the ``pb_*`` / ``pushButton_*``
names created by the compiled UI file so existing signal connections
and mode-switching code continues to work unchanged.
"""
ui = self._ui
# ── Workplanes ──
self._btn_wp_origin = ui.pb_origin_wp
self._btn_wp_face = ui.pb_origin_face
self._btn_wp_flip = ui.pb_flip_face
self._btn_wp_new = ui.pb_wp_new
self._btn_underlay = ui.pb_underlay
self._btn_clr_face = ui.pb_clr_face
self._btn_to_sketch = ui.pb_to_sketch
# ── Drawing ──
self._btn_line = ui.pb_linetool
self._btn_rect = ui.pb_rectool
self._btn_circle = ui.pb_circtool
self._btn_slot = ui.pb_slotool
self._btn_arc = ui.pb_arc_tool
self._btn_construct = ui.pb_enable_construct
self._btn_snap = ui.pb_enable_snap
self._btn_offset = ui.pb_offset_tool
# ── Constrain ──
self._btn_con_ptpt = ui.pb_con_ptpt
self._btn_con_ptline = ui.pb_con_line
self._btn_con_mid = ui.pb_con_mid
self._btn_con_perp = ui.pb_con_perp
self._btn_con_horiz = ui.pb_con_horiz
self._btn_con_vert = ui.pb_con_vert
self._btn_con_dist = ui.pb_con_dist
self._btn_con_sym = ui.pb_con_sym
# ── Snaps ──
self._btn_snap_point = ui.pushButton_8
self._btn_snap_mid = ui.pb_snap_midp
self._btn_snap_horiz = ui.pb_snap_horiz
self._btn_snap_vert = ui.pb_snap_vert
self._btn_snap_angle = ui.pb_snap_angle
self._btn_snap_grid = ui.pushButton_7
self._spin_snap_dist = ui.spinbox_snap_distance
self._spin_angle = ui.spinbox_angle_steps
# ── Modify ──
self._btn_extrude = ui.pb_extrdop
self._btn_cut = ui.pb_cutop
self._btn_combine = ui.pb_combop
self._btn_move = ui.pb_moveop
self._btn_revolve = ui.pb_revop
self._btn_array = ui.pb_arrayop
# ── Export ──
self._btn_export_stl = ui.pushButton_2
self._btn_export_step = ui.pb_export_step
self._btn_export_iges = ui.pb_export_iges
# ── Sketch list tools ──
self._btn_add_sketch = ui.pb_nw_sktch
self._btn_edit_sketch = ui.pb_edt_sktch
self._btn_del_sketch = ui.pb_del_sketch
# ── Body tools ──
self._btn_update_body = ui.pb_update_body
self._btn_edit_sketch_3 = ui.pb_edt_sktch_3
self._btn_del_body = ui.pb_del_body
# ── Component tools ──
self._btn_new_compo = ui.pb_new_compo
self._btn_del_compo = ui.pb_del_compo
# ── Assembly / Connector ──
self._btn_compo_to_assembly = ui.pb_compo_to_assembly
self._btn_remove_compo_from_assembly = ui.pb_remove_compo_from_assembly
self._btn_add_connector = ui.pb_add_connector
self._btn_add_connector.setCheckable(True)
self._btn_del_connector = ui.pb_remove_connector
# ── Code tab ──
self._btn_apply_code = ui.pb_apply_code
self._btn_load_code = ui.pushButton_5
self._btn_save_code = ui.pushButton_4
self._btn_del_code = ui.pushButton
# ── List views & tabs ──
self._sketch_list = ui.sketch_list
self._body_list = ui.body_list
self._input_tabs = ui.InputTab
def _toggle_panel_focus(self):
"""Cycle the sketch/viewer split: equal → sketch → viewer → equal.
Driven by Spacebar and the Layout button (§_setup_connections).
"""
order = ["equal", "sketch", "viewer"]
try:
nxt = order[(order.index(self._panel_focus) + 1) % len(order)]
except (AttributeError, ValueError):
nxt = "equal"
self._set_panel_focus(nxt)
def _set_panel_focus(self, panel: str):
"""Set the sketch/viewer column stretches based on the focus mode."""
if not hasattr(self, "_grid"):
self._panel_focus = panel
return
self._panel_focus = panel
if panel == "viewer":
# Viewer 2/3, sketch 1/3 — more room for 3D work, sketch stays visible.
self._grid.setColumnStretch(1, 1)
self._grid.setColumnStretch(2, 2)
elif panel == "sketch":
# Sketch 2/3, viewer 1/3 — comfortable sketching, 3D stays visible.
self._grid.setColumnStretch(1, 2)
self._grid.setColumnStretch(2, 1)
else: # equal
self._grid.setColumnStretch(1, 1)
self._grid.setColumnStretch(2, 1)
logger.info(f"Panel focus -> {self._panel_focus}")
def keyPressEvent(self, event):
# Spacebar cycles the sketch/viewer split so you can grow the side you're
# working in without leaving the keyboard.
if event.key() == Qt.Key_Space:
self._toggle_panel_focus()
event.accept()
return
super().keyPressEvent(event)
def _create_dock_widgets(self):
pass
def _setup_connections(self):
self._btn_line.clicked.connect(lambda: self._set_sketch_mode("line"))
self._btn_rect.clicked.connect(lambda: self._set_sketch_mode("rectangle"))
self._btn_circle.clicked.connect(lambda: self._set_sketch_mode("circle"))
self._btn_arc.clicked.connect(lambda: self._set_sketch_mode("arc"))
self._btn_slot.clicked.connect(lambda: self._set_sketch_mode("slot"))
self._btn_construct.clicked.connect(self._on_construct_change)
self._btn_con_ptpt.clicked.connect(lambda: self._set_sketch_mode("constrain_coincident"))
self._btn_con_ptline.clicked.connect(lambda: self._set_sketch_mode("constrain_ptline"))
self._btn_con_horiz.clicked.connect(lambda: self._set_sketch_mode("constrain_horizontal"))
self._btn_con_vert.clicked.connect(lambda: self._set_sketch_mode("constrain_vertical"))
self._btn_con_mid.clicked.connect(lambda: self._set_sketch_mode("constrain_midpoint"))
self._btn_con_perp.clicked.connect(lambda: self._set_sketch_mode("constrain_perpendicular"))
self._btn_con_dist.clicked.connect(lambda: self._set_sketch_mode("constrain_distance"))
self._btn_con_sym.clicked.connect(lambda: self._set_sketch_mode("constrain_symmetric"))
self._btn_snap_point.clicked.connect(
lambda c: self._sketch_widget.set_snap_mode("point", c)
)
self._btn_snap_mid.clicked.connect(lambda c: self._sketch_widget.set_snap_mode("mpoint", c))
self._btn_snap_horiz.clicked.connect(
lambda c: self._sketch_widget.set_snap_mode("horiz", c)
)
self._btn_snap_vert.clicked.connect(lambda c: self._sketch_widget.set_snap_mode("vert", c))
self._btn_snap_angle.clicked.connect(
lambda c: self._sketch_widget.set_snap_mode("angle", c)
)
self._btn_snap_grid.clicked.connect(lambda c: self._sketch_widget.set_snap_mode("grid", c))
self._spin_snap_dist.valueChanged.connect(self._sketch_widget.set_snap_distance)
self._spin_angle.valueChanged.connect(self._sketch_widget.set_angle_steps)
self._btn_extrude.clicked.connect(self._extrude_sketch)
self._btn_cut.clicked.connect(self._boolean_cut)
self._btn_combine.clicked.connect(self._boolean_union)
self._btn_revolve.clicked.connect(self._revolve_sketch)
self._btn_add_sketch.clicked.connect(self._add_sketch_to_component)
self._btn_edit_sketch.clicked.connect(self._edit_sketch)
self._btn_del_sketch.clicked.connect(self._delete_sketch)
self._btn_wp_face.toggled.connect(self._on_face_sketch_toggled)
self._viewer_3d.facePicked.connect(self._on_face_picked)
self._viewer_3d.pickFaceCancelled.connect(
lambda: self._btn_wp_face.setChecked(False)
)
self._btn_new_compo.clicked.connect(self._new_component)
self._btn_del_compo.clicked.connect(self._delete_component)
self._btn_compo_to_assembly.clicked.connect(self._add_component_to_assembly)
self._btn_remove_compo_from_assembly.clicked.connect(self._remove_component_from_assembly)
self._btn_asm_move.toggled.connect(self._on_assembly_move_toggled)
self._btn_add_connector.clicked.connect(self._on_start_connector_placement)
self._btn_del_connector.clicked.connect(self._on_delete_connector)
self._viewer_3d.connectorPicked.connect(self._on_connector_picked)
self._viewer_3d.connectorHover.connect(self._on_connector_hover)
self._viewer_3d.connectorPickCancelled.connect(
lambda: self._btn_add_connector.setChecked(False)
)
self._viewer_3d.assemblyComponentActivated.connect(
self._on_assembly_move_activated
)
self._viewer_3d.assemblyComponentDragged.connect(
self._on_assembly_move_dragged
)
self._viewer_3d.assemblyMoveFinished.connect(
self._on_assembly_move_finished
)
self._btn_update_body.clicked.connect(self._redraw_bodies)
self._btn_del_body.clicked.connect(self._delete_body)
self._btn_export_stl.clicked.connect(self._export_stl)
self._btn_export_step.clicked.connect(self._export_step)
self._btn_export_iges.clicked.connect(self._export_iges)
self._sketch_widget.constrain_done.connect(self._on_constrain_done)
self._sketch_widget.sketch_updated.connect(self._on_sketch_updated)
self._sketch_list.currentItemChanged.connect(self._on_sketch_selected)
self._body_list.currentItemChanged.connect(self._on_body_list_changed)
# Per-body visibility toggle: the user clicks the checkbox next
# to a body name in the right-hand list. We update the body's
# ``visible`` flag and ask the viewer to show/hide the mesh.
# (itemChanged also fires for selection changes; the handler
# filters on the check-state role.)
self._body_list.itemChanged.connect(self._on_body_visibility_changed)
self._btn_wp_origin.clicked.connect(self._new_sketch_origin)
self._btn_wp_new.clicked.connect(self._new_workplane)
self._btn_wp_flip.clicked.connect(self._flip_workplane)
# Underlay show/hide, ClrFace, and ToSketch — all stay in sync
# with the source face state managed by set_source_face /
# clear_source_face / _project_body_to_active_wp.
self._btn_underlay.toggled.connect(self._on_underlay_toggled)
self._btn_clr_face.clicked.connect(self._on_clear_source_face)
self._btn_to_sketch.clicked.connect(self._on_convert_underlay_to_sketch)
# Generic buttons
self._btn_move.clicked.connect(self._translate_body)
self._btn_array.clicked.connect(self._pattern_array)
self._btn_offset.clicked.connect(self._offset_sketch)
self._btn_edit_sketch_3.clicked.connect(self._edit_sketch)
# Snap toggle
self._btn_snap.clicked.connect(lambda c: self._sketch_widget.set_snap_mode("point", c))
def _create_initial_component(self):
self._new_component()
def _create_initial_assembly(self):
"""Create the initial assembly in the project."""
self._project.add_assembly()
logger.info("Created initial assembly")
def _set_sketch_mode(self, mode: str):
self._sketch_widget.set_mode(mode)
for btn in [
self._btn_line,
self._btn_rect,
self._btn_circle,
self._btn_arc,
self._btn_slot,
self._btn_con_ptpt,
self._btn_con_ptline,
self._btn_con_horiz,
self._btn_con_vert,
self._btn_con_mid,
self._btn_con_perp,
self._btn_con_dist,
self._btn_con_sym,
]:
btn.setChecked(False)
if mode in ["line", "rectangle", "circle", "arc", "slot"]:
if mode == "line":
self._btn_line.setChecked(True)
elif mode == "rectangle":
self._btn_rect.setChecked(True)
elif mode == "circle":
self._btn_circle.setChecked(True)
elif mode == "arc":
self._btn_arc.setChecked(True)
elif mode == "slot":
self._btn_slot.setChecked(True)
elif mode.startswith("constrain_"):
if mode == "constrain_coincident":
self._btn_con_ptpt.setChecked(True)
elif mode == "constrain_horizontal":
self._btn_con_horiz.setChecked(True)
elif mode == "constrain_vertical":
self._btn_con_vert.setChecked(True)
def _on_construct_change(self, checked):
self._sketch_widget.set_construct_mode(checked)
def _on_constrain_done(self):
for btn in [
self._btn_line,
self._btn_rect,
self._btn_circle,
self._btn_arc,
self._btn_slot,
self._btn_con_ptpt,
self._btn_con_ptline,
self._btn_con_horiz,
self._btn_con_vert,
self._btn_con_mid,
self._btn_con_perp,
self._btn_con_dist,
self._btn_con_sym,
]:
btn.setChecked(False)
self._sketch_widget.set_mode(None)
def _on_sketch_updated(self):
pass
def _get_active_component_index(self) -> int:
for i, btn in enumerate(self._component_buttons):
if btn.isChecked():
return i
return 0
def _new_component(self):
logger.info("=== NEW COMPONENT ===")
comp = self._project.add_component()
self._current_component = comp
self._mark_dirty()
logger.info(f"Created component: {comp.name}")
btn = QPushButton(str(len(self._project.components)))
btn.setCheckable(True)
btn.setFixedSize(QSize(40, 40))
btn.clicked.connect(self._on_component_button_clicked)
btn.setChecked(True)
for b in self._component_buttons:
b.setChecked(False)
self._component_buttons.append(btn)
self._component_group.addButton(btn)
self._component_box_layout.addWidget(btn)
self._refresh_lists()
logger.info(f"Created component: {comp.name}")
def _delete_component(self):
idx = self._get_active_component_index()
comp_ids = list(self._project.components.keys())
if idx < len(comp_ids):
comp_id = comp_ids[idx]
del self._project.components[comp_id]
if self._component_buttons:
btn = self._component_buttons.pop(idx)
self._component_group.removeButton(btn)
btn.deleteLater()
if self._component_buttons:
self._component_buttons[0].setChecked(True)
self._refresh_lists()
logger.info(f"Deleted component")
def _on_component_button_clicked(self):
idx = self._get_active_component_index()
comp_ids = list(self._project.components.keys())
if idx < len(comp_ids):
self._current_component = self._project.components[comp_ids[idx]]
self._assembly_view_active = False
self._refresh_lists()
self._redraw_bodies()
def _refresh_lists(self):
self._sketch_list.clear()
self._body_list.clear()
if self._current_component:
for sketch_id, sketch in self._current_component.sketches.items():
self._sketch_list.addItem(sketch.name)
for body_id, body in self._current_component.bodies.items():
# QListWidgetItem with a checkbox so the user can toggle
# each body's visibility in the 3D viewer. The item's
# data role stores the body id so the toggle handler can
# look up the right body without relying on display text.
item = QListWidgetItem(body.name)
item.setData(Qt.UserRole, body_id)
# Qt.Checked = visible, Qt.Unchecked = hidden. Default
# is whatever the body model says.
item.setCheckState(
Qt.Checked if body.visible else Qt.Unchecked
)
# Greying out a hidden body's name is a nice UX touch.
if not body.visible:
item.setForeground(QColor("#6c7086"))
self._body_list.addItem(item)
def _redraw_bodies(self):
self._viewer_3d.clear_scene()
if self._current_component:
for body_id, body in self._current_component.bodies.items():
if body.geometry:
logger.debug(f"Redrawing body: {body.name}")
shape = self._kernel._get_shape(body.geometry)
body.render_object = self._viewer_3d.show_shape(shape, body.color, body.name)
logger.info(f"Redraw render object: {body.render_object}")
# Re-add workplane visuals after the clear.
for wp_id, wp in self._current_component.workplanes.items():
if wp.visible:
wp.render_object = self._viewer_3d.show_workplane(
origin=wp.origin,
normal=wp.normal,
x_dir=wp.x_dir,
size=250.0,
name=f"workplane_{wp.id}",
)
self._viewer_3d.fit_camera()
# ────────────────────────────────────────────────────────────────────
# Assembly methods
# ────────────────────────────────────────────────────────────────────
def _get_assembly(self) -> Optional[Any]:
"""Get the active assembly from the project."""
assembly = self._project.get_active_assembly()
if assembly is None:
assembly = self._project.add_assembly()
return assembly
def _add_component_to_assembly(self):
"""Add the currently selected component to the assembly.
Creates a new button in the assembly box and stores the
component instance in the assembly model.
"""
if self._current_component is None:
logger.warning("No active component to add to assembly")
return
assembly = self._get_assembly()
# Create an instance of the current component in the assembly.
ac = assembly.add_component_instance(
component_id=self._current_component.id,
name=f"{self._current_component.name}",
)
logger.info(
f"Added component '{self._current_component.name}' "
f"to assembly '{assembly.name}' (instance={ac.id})"
)
# Create a button for this assembly component.
instance_num = len(assembly.components)
label = f"{instance_num}"
btn = QPushButton(label)
btn.setCheckable(True)
btn.setFixedSize(QSize(40, 40))
btn.setToolTip(f"{ac.name} (instance {list(assembly.components.keys()).index(ac.id) + 1})")
# Store the assembly component id in the button.
btn._assembly_component_id = ac.id
btn.clicked.connect(self._on_assembly_component_clicked)
# Uncheck all other assembly buttons, check this one.
for b in self._assembly_component_buttons:
b.setChecked(False)
btn.setChecked(True)
self._assembly_component_buttons.append(btn)
self._assembly_component_group.addButton(btn)
self._assembly_box_layout.addWidget(btn)
# Store the selected id and activate assembly view.
self._selected_assembly_component_id = ac.id
self._assembly_view_active = True
self._mark_dirty()
# Show the assembly in the viewer, framing all components.
self._show_assembly_in_viewer(fit=True)
def _remove_component_from_assembly(self):
"""Remove the currently selected assembly component."""
assembly = self._get_assembly()
if not assembly or not assembly.components:
logger.warning("Assembly is empty, nothing to remove")
return
# Find the active assembly component id from the checked button.
active_id = self._get_active_assembly_component_id()
if active_id is None:
logger.warning("No assembly component selected to remove")
return
# Find the button index for this assembly component.
idx = -1
for i, btn in enumerate(self._assembly_component_buttons):
if getattr(btn, '_assembly_component_id', None) == active_id:
idx = i
break
if idx >= 0:
assembly.remove_component_instance(active_id)
btn = self._assembly_component_buttons.pop(idx)
self._assembly_component_group.removeButton(btn)
btn.deleteLater()
# Select the first remaining button if any.
if self._assembly_component_buttons:
self._assembly_component_buttons[0].setChecked(True)
first_id = getattr(self._assembly_component_buttons[0], '_assembly_component_id', None)
self._selected_assembly_component_id = first_id
self._assembly_view_active = True
else:
self._selected_assembly_component_id = None
self._assembly_view_active = False
# Fall back to normal component view.
self._redraw_bodies()
return
logger.info(f"Removed assembly component instance {active_id}")
self._mark_dirty()
self._show_assembly_in_viewer(fit=True)
def _get_active_assembly_component_id(self) -> Optional[str]:
"""Get the assembly component id of the currently checked button."""
for btn in self._assembly_component_buttons:
if btn.isChecked():
return getattr(btn, '_assembly_component_id', None)
return None
def _on_assembly_component_clicked(self):
"""Handle an assembly component button click.
Shows all components from the assembly in the 3D viewer,
with the clicked component highlighted/selected.
"""
# Find which assembly component id was clicked.
active_id = self._get_active_assembly_component_id()
if active_id is None:
return
self._selected_assembly_component_id = active_id
self._assembly_view_active = True
self._show_assembly_in_viewer(fit=True)
def _apply_transform(self, shape: Any, position, rotation) -> Any:
"""Apply a position translation and rotation matrix to a shape.
Returns a new transformed TopoDS_Shape. If position is zero and
rotation is identity the original shape is returned unchanged.
"""
import numpy as np
from OCP.gp import gp_Trsf
from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform
pos = np.asarray(position, dtype=float)
rot = np.asarray(rotation, dtype=float)
# Skip if identity.
if np.allclose(pos, 0.0) and np.allclose(rot, np.eye(3)):
return shape
# Use SetValues for a combined rotation + translation transform.
# gp_Trsf.SetValues takes 12 values forming a 3x4 matrix:
# [R11 R12 R13 Tx]
# [R21 R22 R23 Ty]
# [R31 R32 R33 Tz]
trsf = gp_Trsf()
trsf.SetValues(
float(rot[0, 0]), float(rot[0, 1]), float(rot[0, 2]), float(pos[0]),
float(rot[1, 0]), float(rot[1, 1]), float(rot[1, 2]), float(pos[1]),
float(rot[2, 0]), float(rot[2, 1]), float(rot[2, 2]), float(pos[2]),
)
transformer = BRepBuilderAPI_Transform(shape, trsf, False)
transformer.Build()
return transformer.Shape()
def _make_connector_marker(self, position: Tuple[float, float, float],
color: Tuple[float, float, float] = (1.0, 0.3, 0.0)) -> Optional[Any]:
"""Create a sphere marker for a connector at *position*.
Returns the TopoDS_Shape of a sphere, or None on failure.
"""
try:
from OCP.gp import gp_Pnt
from OCP.BRepPrimAPI import BRepPrimAPI_MakeSphere
sphere = BRepPrimAPI_MakeSphere(gp_Pnt(*position), 4.0).Shape()
return sphere
except Exception as exc:
logger.debug(f"Failed to create connector marker: {exc}")
return None
def _show_assembly_in_viewer(self, fit: bool = False):
"""Show all components from the assembly in the 3D viewer.
All bodies from all assembly component instances are displayed
together with their position/rotation transforms applied.
The component whose button is checked gets a highlight color;
the rest are shown in a neutral/dimmed color.
Connector markers (small orange spheres) are also shown.
Pass *fit=True* to also frame all visible components with the
camera (use when switching to assembly view via button clicks;
omit during drag to avoid camera flicker).
"""
assembly = self._get_assembly()
if not assembly or not assembly.components:
self._viewer_3d.clear_scene()
return
self._viewer_3d.clear_scene()
# Reset the render-object cache; it will be rebuilt below.
self._asm_render_objects.clear()
highlight_color = (0.2, 0.6, 1.0) # Bright blue for selected
dim_color = (0.5, 0.5, 0.5) # Grey for non-selected
shown_any = False
for ac_id, ac in assembly.components.items():
comp = self._project.get_component_by_id(ac.component_id)
if comp is None:
logger.debug(f"Assembly component {ac_id} references missing component {ac.component_id}")
continue
is_selected = (ac_id == self._selected_assembly_component_id)
color = highlight_color if is_selected else dim_color
render_ids: List[str] = []
for body_id, body in comp.bodies.items():
if body.geometry:
try:
shape = self._kernel._get_shape(body.geometry)
# Apply component instance transform.
transformed = self._apply_transform(
shape, ac.position, ac.rotation
)
obj_id = f"asm_{ac_id}_{body_id}"
render_obj = self._viewer_3d.show_shape(
transformed,
color=color,
name=obj_id,
)
render_ids.append(obj_id)
shown_any = True
except Exception as exc:
logger.debug(f"Failed to show body {body_id} in assembly: {exc}")
self._asm_render_objects[ac_id] = render_ids
# Show connector markers for this instance.
# Connector positions are stored in component-local coords;
# transform to world coords for rendering.
for conn_id, conn in ac.connectors.items():
try:
local_pos = np.array(conn.position, dtype=float)
world_pos = ac.position + ac.rotation @ local_pos
sphere_shape = self._make_connector_marker(tuple(world_pos))
if sphere_shape is not None:
self._viewer_3d.show_shape(
sphere_shape,
color=(1.0, 0.3, 0.0), # Orange
name=f"conn_{ac_id}_{conn_id}",
)
except Exception as exc:
logger.debug(f"Failed to show connector {conn_id}: {exc}")
if shown_any and fit:
self._viewer_3d.fit_camera()
def _update_assembly_component_in_viewer(self, ac_id: str):
"""Replace only the shapes of a single assembly component in-place.
Removes the existing render objects for *ac_id* from the viewer
and recreates them at the component's current position/rotation.
Connector markers are also updated to follow the component.
Other components are left untouched — no scene clear, so the
camera stays perfectly still.
"""
assembly = self._get_assembly()
ac = assembly.components.get(ac_id) if assembly else None
if ac is None:
return
comp = self._project.get_component_by_id(ac.component_id)
if comp is None:
return
# Remove old render objects for this component.
old_ids = self._asm_render_objects.pop(ac_id, [])
for oid in old_ids:
try:
self._viewer_3d.remove_mesh(oid)
except Exception:
pass
# Remove old connector markers for this component.
for conn_id in list(ac.connectors.keys()):
try:
self._viewer_3d.remove_mesh(f"conn_{ac_id}_{conn_id}")
except Exception:
pass
is_selected = (ac_id == self._selected_assembly_component_id)
color = (0.2, 0.6, 1.0) if is_selected else (0.5, 0.5, 0.5)
new_ids: List[str] = []
for body_id, body in comp.bodies.items():
if body.geometry:
try:
shape = self._kernel._get_shape(body.geometry)
transformed = self._apply_transform(
shape, ac.position, ac.rotation
)
obj_id = f"asm_{ac_id}_{body_id}"
self._viewer_3d.show_shape(
transformed,
color=color,
name=obj_id,
)
new_ids.append(obj_id)
except Exception as exc:
logger.debug(f"Failed to update body {body_id}: {exc}")
# Re-add connector markers at updated world positions.
import numpy as np
for conn_id, conn in ac.connectors.items():
try:
local_pos = np.array(conn.position, dtype=float)
world_pos = ac.position + ac.rotation @ local_pos
sphere_shape = self._make_connector_marker(tuple(world_pos))
if sphere_shape is not None:
self._viewer_3d.show_shape(
sphere_shape,
color=(1.0, 0.3, 0.0), # Orange
name=f"conn_{ac_id}_{conn_id}",
)
new_ids.append(f"conn_{ac_id}_{conn_id}")
except Exception as exc:
logger.debug(f"Failed to update connector {conn_id}: {exc}")
self._asm_render_objects[ac_id] = new_ids
# ────────────────────────────────────────────────────────────────────
# Assembly 3D drag-move
# ────────────────────────────────────────────────────────────────────
def _on_assembly_move_toggled(self, checked: bool):
"""Toggle 3D drag-to-move mode in the viewer.
When active, clicking a body in the assembly view and dragging
moves its assembly component in real-time. Shift+drag moves in Z.
"""
if checked and not self._assembly_view_active:
self._btn_asm_move.setChecked(False)
QMessageBox.warning(self, "Assembly View",
"Switch to assembly view first by clicking an assembly component button.")
return
self._viewer_3d.set_assembly_move_mode(checked)
if checked:
self._viewer_3d.setFocus()
self._viewer_3d.activateWindow()
self.setStatusTip("Drag a body to move it; Shift+drag for Z depth")
else:
self.setStatusTip("")
def _on_assembly_move_activated(self, owner_obj_id: str):
"""Called when the user clicks a body in move mode.
Parse the assembly component id, compute the rigid group it belongs
to (transitively via mated connectors), and snapshot EVERY member's
start position so the whole group can translate together during the
drag. The first-picked component of each mated pair stays as the
grounded reference frame for the solver; for a pure-translation
drag that just means we preserve all current relative transforms.
"""
import numpy as np
ac_id = self._parse_ac_id(owner_obj_id)
if ac_id is None:
return
assembly = self._get_assembly()
ac = assembly.components.get(ac_id)
if ac is None:
return
self._asm_move_ac_id = ac_id
# Rigid group membership (BFS over mated-connector connections).
group_ids = assembly.get_rigid_group(ac_id)
self._asm_move_group_ids = group_ids
self._asm_move_group_start = {}
for gid in group_ids:
g_ac = assembly.components.get(gid)
if g_ac is not None:
self._asm_move_group_start[gid] = np.array(g_ac.position, dtype=float)
# Keep the legacy single-component start for backwards compatibility.
self._asm_move_start_pos = np.array(ac.position, dtype=float)
def _on_assembly_move_dragged(self, owner_obj_id: str, dx: float, dy: float, dz: float):
"""Propagate a drag move across the entire rigid group, in-place.
Every component in the dragged rigid group receives the SAME world
translation delta (relative to its own start position), so the mated
relative transforms are preserved exactly and SolveSpace's solved
alignment stays valid throughout the drag. Each member is updated
in-place via ``_update_assembly_component_in_viewer`` so the camera
never flickers.
"""
if self._asm_move_ac_id is None or self._asm_move_start_pos is None:
return
ac_id = self._asm_move_ac_id
assembly = self._get_assembly()
ac = assembly.components.get(ac_id)
if ac is None:
return
import numpy as np
delta = np.array([dx, dy, dz], dtype=float)
# Propagate the same delta to every rigid-group member.
group_ids = self._asm_move_group_ids or [ac_id]
for gid in group_ids:
start = self._asm_move_group_start.get(gid)
if start is None:
continue
g_ac = assembly.components.get(gid)
if g_ac is None:
continue
g_ac.position = start + delta
# Update only this component's shapes — no scene clear.
self._update_assembly_component_in_viewer(gid)
def _on_assembly_move_finished(self, owner_obj_id: str):
"""Finalize the drag move."""
if self._asm_move_ac_id is not None:
members = len(self._asm_move_group_ids) if self._asm_move_group_ids else 1
logger.info(
f"Moved assembly rigid group led by {self._asm_move_ac_id} "
f"({members} member(s)) to final position"
)
self._mark_dirty()
self._asm_move_ac_id = None
self._asm_move_start_pos = None
self._asm_move_group_start = {}
self._asm_move_group_ids = []
# ────────────────────────────────────────────────────────────────────
# Connector methods — two-click selection + preview dialog
# ────────────────────────────────────────────────────────────────────
@staticmethod
def _parse_ac_id(owner_obj_id: str) -> Optional[str]:
"""Extract the assembly component id from a renderer owner_obj_id.
Format: asm_{ac_id}_{body_id}
"""
if not owner_obj_id or not owner_obj_id.startswith("asm_"):
return None
parts = owner_obj_id.split("_")
if len(parts) >= 3:
return parts[1]
return owner_obj_id[4:]
def _on_start_connector_placement(self, checked: bool):
"""Toggle connector pick mode.
First click selects the first component's connection entity.
Second click selects the second component and triggers SolveSpace alignment.
"""
if not self._assembly_view_active:
self._btn_add_connector.setChecked(False)
QMessageBox.warning(self, "Assembly View",
"Switch to assembly view first by clicking an assembly component button.")
return
# Reset any in-progress two-click state.
self._connector_first_pick = None
self._connector_second_ac_id = None
self._connector_align_pos = None
self._viewer_3d.set_connector_pick_mode(checked)
if checked:
self._viewer_3d.setFocus()
self._viewer_3d.activateWindow()
self.setStatusTip("Click on the first component's connection point/face/edge/hole")
else:
self.setStatusTip("")
def _on_connector_hover(self, info) -> None:
"""Show entity-type feedback in the status bar during connector pick.
The gizmo itself is drawn by the viewer; this just reports what
entity is under the cursor so the user knows what they will snap to.
"""
if info is None:
self.statusBar().showMessage("Move over a face / edge / hole / vertex to snap")
return
entity_type = info.get("type", "")
feature_type = info.get("feature_type", "")
suggestion = info.get("suggestion", "")
names = {
"planar_face": "Face",
"cylindrical_face": "Hole",
"edge": "Edge",
"vertex": "Vertex",
}
name = names.get(entity_type, names.get(feature_type, "Entity"))
ac_id = self._parse_ac_id(info.get("owner_obj_id", ""))
comp_name = ""
if ac_id is not None:
assembly = self._get_assembly()
ac = assembly.components.get(ac_id) if assembly else None
if ac is not None:
comp_name = f" on {ac.name}"
# Show suggestion if available, otherwise generic message.
if suggestion:
self.statusBar().showMessage(f"{name}{comp_name}: {suggestion} — click to pick")
else:
self.statusBar().showMessage(f"Snap target: {name}{comp_name} — click to pick")
def _on_connector_picked(self, origin, normal, x_dir, entity_type, raw_shape, owner_obj_id):
"""Handle a connector entity pick — first or second click.
Snaps to faces, cylindrical holes, edges, or vertices.
Stores connector in component-local coordinates so it stays
valid when the component is moved by the solver.
"""
import numpy as np
ac_id = self._parse_ac_id(owner_obj_id)
if ac_id is None:
QMessageBox.warning(self, "Pick Error",
"Could not identify which assembly component was clicked.")
return
assembly = self._get_assembly()
ac = assembly.components.get(ac_id)
if ac is None:
QMessageBox.warning(self, "Pick Error",
"The clicked component was not found in the assembly.")
return
# Convert world-space connector to component-local coordinates.
# p_local = R^T @ (p_world - P)
pos_world = np.array(origin, dtype=float)
rot = ac.rotation
pos_local = rot.T @ (pos_world - ac.position)
n_world = np.array(normal, dtype=float)
n_local = rot.T @ n_world
n_local = n_local / max(np.linalg.norm(n_local), 1e-12)
x_world = np.array(x_dir, dtype=float) if x_dir else np.array([1.0, 0.0, 0.0])
x_local = rot.T @ x_world
x_local = x_local / max(np.linalg.norm(x_local), 1e-12)
# ── First pick ──
if self._connector_first_pick is None:
self._connector_first_pick = {
"ac_id": ac_id,
"origin_local": tuple(pos_local),
"normal_local": tuple(n_local),
"x_dir_local": tuple(x_local),
"origin_world": tuple(origin),
"normal_world": tuple(normal),
"entity_type": entity_type,
"owner_obj_id": owner_obj_id,
}
# Highlight the first face if planar.
if entity_type in ("planar_face", "cylindrical_face"):
self._viewer_3d.highlight_face(raw_shape)
self.setStatusTip("Now click on the second component's connection point/face/edge/hole")
logger.info(f"Connector first pick: {ac.name} at {origin} ({entity_type})")
return
# ── Second pick ──
first = self._connector_first_pick
# Don't allow picking the same component twice.
if ac_id == first["ac_id"]:
QMessageBox.warning(self, "Same Component",
"Pick a different component for the second connection point.")
return
self._connector_second_ac_id = ac_id
self._viewer_3d.clear_face_highlight()
# Keep gizmo visible until next hover so user sees what was picked.
self._viewer_3d.set_connector_pick_mode(False, clear_gizmo=False)
self._btn_add_connector.setChecked(False)
self.setStatusTip("")
logger.info(f"Connector second pick: {ac.name} at {origin} ({entity_type})")
# Build connector records (local coords).
second_pick = {
"ac_id": ac_id,
"origin_local": tuple(pos_local),
"normal_local": tuple(n_local),
"x_dir_local": tuple(x_local),
"origin_world": tuple(origin),
"normal_world": tuple(normal),
"entity_type": entity_type,
"owner_obj_id": owner_obj_id,
}
# SolveSpace alignment: move appropriate component so its connector
# coincides with the anchor's connector. The chronologically first
# component added to the assembly is the global anchor — it stays
# locked in world space. All solving keeps it fixed.
first_ac = assembly.components.get(first["ac_id"])
second_ac = ac
anchor_ac_id = next(iter(assembly.components.keys()))
# Compute the world target normal (from the anchor's connector).
anchor_pick_source = first if anchor_ac_id == first["ac_id"] else second_pick
target_pos = np.array(anchor_pick_source["origin_world"], dtype=float)
target_normal = np.array(anchor_pick_source["normal_world"], dtype=float)
target_normal = target_normal / max(np.linalg.norm(target_normal), 1e-12)
solved = self._solve_assembly_alignment(
first_ac=first_ac,
second_ac=second_ac,
first_pick=first,
second_pick=second_pick,
anchor_component_id=anchor_ac_id,
)
if solved is None:
QMessageBox.warning(self, "Solver Error",
"SolveSpace could not align the components.")
self._connector_first_pick = None
self._connector_second_ac_id = None
self._show_assembly_in_viewer(fit=True)
return
# Apply solved transform to the component the solver actually moved.
moved_ac_id = solved["moved_ac_id"]
moved_ac = assembly.components.get(moved_ac_id)
if moved_ac is not None:
moved_ac.position = solved["position"]
moved_ac.rotation = solved["rotation"]
# Chain auto-offset: if the anchor already has a rigid group (>1
# member), auto-offset the moved component along the connector
# normal so it doesn't stack at the same point.
if assembly.get_group_size(anchor_ac_id) > 1 and moved_ac is not None:
auto_offset = 50.0
moved_ac.position = moved_ac.position + target_normal * auto_offset
# Show dialog with live preview (rotation offset along normal).
moved_comp_before_dialog = assembly.components.get(moved_ac_id)
rotation, offset, flip = self._show_connector_dialog_with_preview(
first_ac=first_ac,
second_ac=second_ac,
first_pick=first,
second_pick=second_pick,
solved=solved,
mover_ac=moved_ac,
)
if rotation is None:
# User cancelled — restore original position.
if moved_comp_before_dialog is not None:
moved_comp_before_dialog.position = np.array(solved["original_position"], dtype=float)
moved_comp_before_dialog.rotation = np.array(solved["original_rotation"], dtype=float)
self._connector_first_pick = None
self._connector_second_ac_id = None
self._show_assembly_in_viewer(fit=True)
return
# Apply dialog adjustments (rotation + offset + flip).
import numpy as np
# Build rotation matrix: rotate second connector normal around
# the target normal axis by rotation degrees.
angle_rad = np.radians(rotation)
# Rodrigues' rotation formula around target_normal.
k = target_normal
K = np.array([[0, -k[2], k[1]], [k[2], 0, -k[0]], [-k[1], k[0], 0]])
R_axis = np.eye(3) + np.sin(angle_rad) * K + (1 - np.cos(angle_rad)) * (K @ K)
# Apply dialog adjustments to the MOVED component.
if moved_ac is not None:
moved_ac.rotation = R_axis @ moved_ac.rotation
flip_sign = -1.0 if flip else 1.0
moved_ac.position = moved_ac.position + flip_sign * target_normal * offset
# Determine which pick is the anchor and which is the mover.
anchor_pick = first if anchor_ac_id == first["ac_id"] else second_pick
mover_pick = second_pick if anchor_ac_id == first["ac_id"] else first
anchor_comp = assembly.components.get(anchor_ac_id)
mover_comp = assembly.components.get(mover_pick["ac_id"])
# Create connectors on both sides and link them as a mated pair.
conn_a = None
conn_m = None
if anchor_comp:
conn_a = anchor_comp.add_connector(
position=anchor_pick["origin_local"],
normal=anchor_pick["normal_local"],
x_dir=anchor_pick["x_dir_local"],
source_obj_id=anchor_pick["owner_obj_id"],
name=f"Conn {anchor_pick['entity_type']} anchor",
)
conn_a.axis_rotation = rotation
conn_a.offset = offset
conn_a.is_grounded = True
if mover_comp:
conn_m = mover_comp.add_connector(
position=mover_pick["origin_local"],
normal=mover_pick["normal_local"],
x_dir=mover_pick["x_dir_local"],
source_obj_id=mover_pick["owner_obj_id"],
name=f"Conn {mover_pick['entity_type']} mover",
)
conn_m.axis_rotation = rotation
conn_m.offset = offset
# Cross-link the partners and register the pair on the assembly graph.
if conn_a is not None and conn_m is not None:
conn_a.partner_ac_id = mover_comp.id if mover_comp else ""
conn_a.partner_connector_id = conn_m.id
conn_m.partner_ac_id = anchor_comp.id if anchor_comp else ""
conn_m.partner_connector_id = conn_a.id
assembly.add_connection(anchor_ac_id, moved_ac_id)
logger.info(f"Connected: anchor={anchor_ac_id} ↔ moved={moved_ac_id}, "
f"rotation={rotation}°, offset={offset}mm, flip={flip}")
self._connector_first_pick = None
self._connector_second_ac_id = None
self._mark_dirty()
self._show_assembly_in_viewer(fit=True)
@staticmethod
def _rotation_between_vectors(a, b):
"""Return a 3×3 rotation that maps vector *a* onto vector *b*.
Handles the two degenerate cases that plain Rodrigues' formula gets
wrong when the cross-product axis collapses to zero:
* ``a ≈ b`` → identity (no rotation needed).
* ``a ≈ -b`` → a 180° rotation about any axis orthogonal to *a*
(picked by a stable reference-vector projection).
Vectors are internally normalized so callers may pass non-unit input.
"""
import numpy as _np
import math as _math
a = _np.asarray(a, dtype=float)
b = _np.asarray(b, dtype=float)
an = _np.linalg.norm(a); bn = _np.linalg.norm(b)
if an < 1e-12 or bn < 1e-12:
return _np.eye(3)
a = a / an; b = b / bn
dot = float(_np.dot(a, b))
cross = _np.cross(a, b)
cross_norm = _np.linalg.norm(cross)
if cross_norm < 1e-9:
if dot > 0.0:
# Already aligned.
return _np.eye(3)
# Anti-parallel: 180° about an axis orthogonal to *a*.
ref = _np.array([1.0, 0.0, 0.0]) if abs(a[0]) < 0.9 else _np.array([0.0, 1.0, 0.0])
axis = ref - a * _np.dot(ref, a)
axis = axis / max(_np.linalg.norm(axis), 1e-12)
K = _np.array([[0, -axis[2], axis[1]], [axis[2], 0, -axis[0]], [-axis[1], axis[0], 0]])
# sin(180°)=0, 1-cos(180°)=2 → R = I + 2 (K @ K)
return _np.eye(3) + 2.0 * (K @ K)
axis = cross / cross_norm
angle = _math.acos(max(-1.0, min(1.0, dot)))
K = _np.array([[0, -axis[2], axis[1]], [axis[2], 0, -axis[0]], [-axis[1], axis[0], 0]])
return _np.eye(3) + _np.sin(angle) * K + (1.0 - _np.cos(angle)) * (K @ K)
def _solve_assembly_alignment(
self,
first_ac: Any,
second_ac: Any,
first_pick: Dict[str, Any],
second_pick: Dict[str, Any],
anchor_component_id: Optional[str] = None,
) -> Optional[Dict[str, Any]]:
"""Use SolveSpace to align the second component to the first.
The anchor component (either ``anchor_component_id`` or, failing that,
the ``first_ac``) is treated as fixed (grounded). The solver moves
the *other* component so its connector coincides with the anchor's
connector (position + normal alignment).
Returns a dict with:
* ``position`` — new world position for the moved component.
* ``rotation`` — new 3×3 rotation matrix for the moved component.
* ``moved_ac_id`` — which component was moved.
* ``original_position`` / ``original_rotation`` — for cancellation.
"""
import numpy as np
try:
from python_solvespace import SolverSystem, ResultFlag, Entity
except ImportError:
logger.warning("python_solvespace not available, falling back to direct alignment")
return self._align_direct(first_ac, second_ac, first_pick, second_pick,
anchor_component_id=anchor_component_id)
# ── Determine anchor and mover ──
# The anchor component stays locked. Prefer anchor_component_id
# (the first-added component); fall back to first_ac (the first click).
assembly = self._get_assembly()
if anchor_component_id:
anchor_ac = assembly.components.get(anchor_component_id) if assembly else None
else:
anchor_ac = first_ac
if anchor_ac is None:
anchor_ac = first_ac
# The mover is whichever of first_ac / second_ac is NOT the anchor.
if second_ac.id == anchor_ac.id:
mover_ac = first_ac
mover_pick = first_pick
anchor_pick = second_pick
else:
mover_ac = second_ac
mover_pick = second_pick
anchor_pick = first_pick
# Save original transform for cancellation.
orig_pos = np.array(mover_ac.position, dtype=float)
orig_rot = np.array(mover_ac.rotation, dtype=float)
# World positions of anchor connector (grounded).
a_world = np.array(anchor_pick["origin_world"], dtype=float)
n_anchor = np.array(anchor_pick["normal_world"], dtype=float)
n_anchor = n_anchor / max(np.linalg.norm(n_anchor), 1e-12)
# Local positions of mover connector (solved).
m_local = np.array(mover_pick["origin_local"], dtype=float)
n_local = np.array(mover_pick["normal_local"], dtype=float)
n_local = n_local / max(np.linalg.norm(n_local), 1e-12)
# Build solver.
#
# IMPORTANT: SolveSpace's SLVS_C_PARALLEL and SLVS_C_SAME_ORIENTATION
# both generate multi-equation residuals that trigger a hard C-level
# assertion in this python_solvespace build's Newton iterator
# ("Expected constraint to generate a single equation"), aborting the
# whole process. We therefore avoid line-parallel / orientation
# constraints entirely and instead drive BOTH translation AND axis
# alignment with a pair of coincident point constraints:
#
# * coincident(pt_anchor, pt_mover) — forces the connector points
# together (3 trans DOF)
# * coincident(pt_anchor_tip, tip_mover) — pins the mover's axis
# tip onto the anchor's
# normal line (2 rot DOF)
#
# That's 6 single-equation-coincident residuals against 6 free point
# parameters — a well-posed 0-DOF system — so it converges cleanly.
# The remaining free rotation around the axis is left for the
# rotation_spinner in the dialog.
sys = SolverSystem()
# Anchor (grounded) reference frame.
pt_anchor = sys.add_point_3d(float(a_world[0]), float(a_world[1]), float(a_world[2]))
sys.dragged(pt_anchor, Entity.FREE_IN_3D)
pt_anchor_tip = sys.add_point_3d(
float(a_world[0] + n_anchor[0]),
float(a_world[1] + n_anchor[1]),
float(a_world[2] + n_anchor[2]),
)
sys.dragged(pt_anchor_tip, Entity.FREE_IN_3D)
# Mover (free) points, seeded near its current world connector.
m_world_current = orig_pos + orig_rot @ m_local
pt_mover = sys.add_point_3d(
float(m_world_current[0]), float(m_world_current[1]), float(m_world_current[2])
)
n_world_current = orig_rot @ n_local
tip_mover = sys.add_point_3d(
float(m_world_current[0] + n_world_current[0]),
float(m_world_current[1] + n_world_current[1]),
float(m_world_current[2] + n_world_current[2]),
)
# Constraints: pivot coincidence + axis-tip coincidence.
sys.coincident(pt_anchor, pt_mover, Entity.FREE_IN_3D)
sys.coincident(pt_anchor_tip, tip_mover, Entity.FREE_IN_3D)
# Solve.
result = sys.solve()
if result != ResultFlag.OKAY:
logger.warning(f"SolveSpace solve failed: {result}")
return self._align_direct(first_ac, second_ac, first_pick, second_pick,
anchor_component_id=anchor_component_id)
# Extract solved positions.
p_solved = np.array(sys.params(pt_mover.params), dtype=float)
tip_solved = np.array(sys.params(tip_mover.params), dtype=float)
n_solved = tip_solved - p_solved
n_solved = n_solved / max(np.linalg.norm(n_solved), 1e-12)
# Compute the new component transform.
R_align = self._rotation_between_vectors(n_local, n_solved)
new_rot = R_align @ orig_rot
new_pos = p_solved - new_rot @ m_local
return {
"position": new_pos,
"rotation": new_rot,
"moved_ac_id": mover_ac.id,
"original_position": orig_pos,
"original_rotation": orig_rot,
}
def _align_direct(
self,
first_ac: Any,
second_ac: Any,
first_pick: Dict[str, Any],
second_pick: Dict[str, Any],
anchor_component_id: Optional[str] = None,
) -> Optional[Dict[str, Any]]:
"""Direct geometric alignment (fallback when SolveSpace unavailable).
Moves the non-anchor component so its connector coincides with the
anchor's connector.
"""
import numpy as np
# ── Determine anchor and mover ──
assembly = self._get_assembly()
if anchor_component_id:
anchor_ac = assembly.components.get(anchor_component_id) if assembly else None
else:
anchor_ac = first_ac
if anchor_ac is None:
anchor_ac = first_ac
if second_ac.id == anchor_ac.id:
mover_ac = first_ac
mover_pick = first_pick
anchor_pick = second_pick
else:
mover_ac = second_ac
mover_pick = second_pick
anchor_pick = first_pick
orig_pos = np.array(mover_ac.position, dtype=float)
orig_rot = np.array(mover_ac.rotation, dtype=float)
# World position of the anchor connector (locked target).
a_world = np.array(anchor_pick["origin_world"], dtype=float)
n_anchor = np.array(anchor_pick["normal_world"], dtype=float)
n_anchor = n_anchor / max(np.linalg.norm(n_anchor), 1e-12)
# Mover's connector in local coords.
m_local = np.array(mover_pick["origin_local"], dtype=float)
n_local = np.array(mover_pick["normal_local"], dtype=float)
n_local = n_local / max(np.linalg.norm(n_local), 1e-12)
# Align mover's normal to anchor's normal.
R_align = self._rotation_between_vectors(n_local, n_anchor)
new_rot = R_align @ orig_rot
new_pos = a_world - new_rot @ m_local
return {
"position": new_pos,
"rotation": new_rot,
"moved_ac_id": mover_ac.id,
"original_position": orig_pos,
"original_rotation": orig_rot,
}
def _show_connector_dialog_with_preview(
self,
first_ac: Any,
second_ac: Any,
first_pick: Dict[str, Any],
second_pick: Dict[str, Any],
solved: Dict[str, Any],
mover_ac: Any = None,
) -> Tuple[Optional[float], Optional[float], bool]:
"""Show connector dialog with live 3D preview of the alignment.
Returns (rotation_degrees, offset_mm, flip) or (None, None, False) if cancelled.
"""
from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout,
QLabel, QDoubleSpinBox, QPushButton,
QFrame, QCheckBox)
if second_ac is None:
return (None, None, False)
# The component to preview adjustments on — defaults to second_ac
# but can be overridden via mover_ac (for anchor-aware solving).
preview_target = mover_ac if mover_ac is not None else second_ac
dialog = QDialog(self)
dialog.setWindowTitle("Connector — Connection Properties")
dialog.setMinimumWidth(340)
layout = QVBoxLayout(dialog)
entity_names = {
"planar_face": "Face",
"cylindrical_face": "Hole",
"edge": "Edge",
"vertex": "Vertex",
}
t1 = entity_names.get(first_pick.get("entity_type", ""), "Entity")
t2 = entity_names.get(second_pick.get("entity_type", ""), "Entity")
layout.addWidget(QLabel(f"{t1} on {first_ac.name} → {t2} on {second_ac.name}"))
layout.addWidget(QLabel("Adjust the connection:"))
# Rotation around normal axis.
rot_layout = QHBoxLayout()
rot_layout.addWidget(QLabel("Rotation around axis (°):"))
rotation_spin = QDoubleSpinBox()
rotation_spin.setDecimals(1)
rotation_spin.setRange(-360, 360)
rotation_spin.setValue(0.0)
rotation_spin.setSuffix("°")
rot_layout.addWidget(rotation_spin)
layout.addLayout(rot_layout)
# Offset along normal.
off_layout = QHBoxLayout()
off_layout.addWidget(QLabel("Offset along normal (mm):"))
offset_spin = QDoubleSpinBox()
offset_spin.setDecimals(2)
offset_spin.setRange(-10000, 10000)
offset_spin.setValue(0.0)
off_layout.addWidget(offset_spin)
layout.addLayout(off_layout)
# Flip alignment direction.
flip_check = QCheckBox("Flip connection direction (normals opposed)")
flip_check.setChecked(False)
layout.addWidget(flip_check)
line = QFrame()
line.setFrameShape(QFrame.HLine)
layout.addWidget(line)
btn_layout = QHBoxLayout()
ok_btn = QPushButton("Connect")
cancel_btn = QPushButton("Cancel")
btn_layout.addWidget(ok_btn)
btn_layout.addWidget(cancel_btn)
layout.addLayout(btn_layout)
import numpy as np
target_normal = np.array(first_pick["normal_world"], dtype=float)
target_normal = target_normal / max(np.linalg.norm(target_normal), 1e-12)
# ── Live preview callback ──
def _update_preview(*args):
rot_deg = rotation_spin.value()
off = offset_spin.value()
flip = flip_check.isChecked()
# Start from solved transform.
base_pos = np.array(solved["position"], dtype=float)
base_rot = np.array(solved["rotation"], dtype=float)
# Apply axis rotation around target_normal.
angle_rad = np.radians(rot_deg)
k = target_normal
K = np.array([[0, -k[2], k[1]], [k[2], 0, -k[0]], [-k[1], k[0], 0]])
R_axis = np.eye(3) + np.sin(angle_rad) * K + (1 - np.cos(angle_rad)) * (K @ K)
preview_rot = R_axis @ base_rot
# Apply offset (with flip).
flip_sign = -1.0 if flip else 1.0
preview_pos = base_pos + flip_sign * target_normal * off
preview_target.position = preview_pos
preview_target.rotation = preview_rot
self._show_assembly_in_viewer() # no fit — keep camera steady
rotation_spin.valueChanged.connect(_update_preview)
offset_spin.valueChanged.connect(_update_preview)
flip_check.toggled.connect(_update_preview)
# Initial preview.
_update_preview()
ok_btn.clicked.connect(dialog.accept)
cancel_btn.clicked.connect(dialog.reject)
if dialog.exec():
return (rotation_spin.value(), offset_spin.value(), flip_check.isChecked())
return (None, None, False)
def _on_delete_connector(self):
"""Delete the connector nearest to the selected assembly component."""
active_id = self._get_active_assembly_component_id()
if active_id is None:
QMessageBox.warning(self, "No Selection",
"Select an assembly component first")
return
assembly = self._get_assembly()
ac = assembly.components.get(active_id)
if ac is None or not ac.connectors:
QMessageBox.information(self, "No Connectors",
"This component has no connectors to remove.")
return
# List connectors in a simple choice dialog.
conn_names = list(ac.connectors.keys())
conn_labels = [f"{c.name} at {c.position}" for c in ac.connectors.values()]
from PySide6.QtWidgets import QInputDialog
label, ok = QInputDialog.getItem(
self, "Remove Connector", "Select connector:", conn_labels, 0, False
)
if ok and label:
idx = conn_labels.index(label)
conn_id = conn_names[idx]
conn = ac.connectors.get(conn_id)
# Un-partner the mate and drop the rigid-group edge so stale
# connections don't linger in the BFS graph.
if conn is not None:
partner_ac_id = conn.partner_ac_id
partner_conn_id = conn.partner_connector_id
if partner_ac_id is not None and partner_conn_id is not None:
partner_ac = assembly.components.get(partner_ac_id)
if partner_ac is not None and partner_conn_id in partner_ac.connectors:
pc = partner_ac.connectors[partner_conn_id]
pc.partner_ac_id = None
pc.partner_connector_id = None
pc.is_grounded = False
# Remove the connection edge either side references this pair.
assembly.connections = [
c for c in assembly.connections
if not (
(c.first_ac_id == active_id and c.second_ac_id == partner_ac_id)
or (c.first_ac_id == partner_ac_id and c.second_ac_id == active_id)
)
] if partner_ac_id is not None else assembly.connections
ac.remove_connector(conn_id)
logger.info(f"Removed connector {conn_id}")
self._show_assembly_in_viewer(fit=True)
def _new_workplane(self):
"""Open the orientation dialog and create a new independent workplane.
The workplane is shown as a semi-transparent plane in the 3D view
(with live preview as the user adjusts options in the dialog).
A fresh sketch is created on it ready for drawing, and body outlines
are projected as underlay construction lines for precise alignment.
"""
dialog = WorkplaneOrientationDialog(self)
origin = (0.0, 0.0, 0.0)
_preview_obj_id: Optional[str] = None
def _preview_callback(orientation):
"""Live-preview the workplane orientation in the 3D viewer."""
nonlocal _preview_obj_id
if orientation is None:
# Dialog closing — clear the preview.
if _preview_obj_id is not None:
self._viewer_3d.remove_workplane(_preview_obj_id)
_preview_obj_id = None
return
normal, x_dir = orientation
# Replace the previous preview (same ID = update in place).
if _preview_obj_id is not None:
self._viewer_3d.remove_workplane(_preview_obj_id)
_preview_obj_id = self._viewer_3d.show_workplane(
origin=origin,
normal=normal,
x_dir=x_dir,
size=250.0,
name="__wp_preview__",
)
dialog.set_preview_callback(_preview_callback)
if not dialog.exec():
# Preview already cleared by dialog.hideEvent → callback(None).
return
normal, x_dir, wp_name = dialog.get_orientation()
if not self._current_component:
self._current_component = self._project.add_component()
# Create the Workplane model.
from fluency.models.data_model import Workplane
wp = self._current_component.add_workplane(
Workplane(
name=wp_name,
origin=origin,
normal=normal,
x_dir=x_dir, )
)
# The preview visual becomes the permanent workplane; just update
# its name so it can be found later for removal.
if _preview_obj_id is not None:
# Store the render object ID in the workplane model.
wp.render_object = _preview_obj_id
# The show_workplane_plane method replaced the preview already,
# so the visual is showing the final orientation.
else:
# Fallback: create a new visual (shouldn't happen).
wp.render_object = self._viewer_3d.show_workplane(
origin=origin,
normal=normal,
x_dir=x_dir,
size=250.0,
name=f"workplane_{wp.id}",
)
self._mark_dirty()
# Create a sketch on this workplane and set up the 2D widget.
sketch = self._current_component.add_sketch()
self._mark_dirty()
sketch.name = f"Sketch on {wp.name}"
sketch.set_workplane(origin, normal, x_dir)
sketch._source_workplane_id = wp.id
# Prepare the OCC sketch in the widget.
if sketch.occ_sketch is None or sketch.occ_sketch.get_entity_count() > 0:
sketch.occ_sketch = self._sketch_widget.create_sketch()
sketch.apply_workplane()
self._sketch_widget.set_sketch(sketch.occ_sketch)
self._current_sketch = sketch
# Project body outlines onto the workplane for alignment.
self._project_body_to_active_wp()
self._sketch_widget.set_mode("line")
self._btn_line.setChecked(True)
self._refresh_lists()
self._set_panel_focus("sketch")
self.statusBar().showMessage(
f"Workplane '{wp.name}' created — sketch on it to draw. "
f"Body outlines projected as underlay.",
6000,
)
logger.info(f"New workplane '{wp.name}' with orientation n={normal} x={x_dir}")
def _project_body_to_active_wp(self) -> None:
"""Project all body outlines in the current component onto the active
sketch's workplane as underlay construction lines.
This lets the user see the 3D body's silhouette from the workplane's
perspective and position their 2D sketch precisely relative to the
existing geometry. Uses the same external-entity mechanism as
face-projected underlay (``set_source_face``).
"""
if not self._current_component or not self._current_sketch:
return
occ_sketch = self._current_sketch.occ_sketch
if occ_sketch is None:
return
wp = occ_sketch.get_workplane()
if not wp:
return
origin = wp[0] # (ox, oy, oz)
normal = wp[1] # (nx, ny, nz)
x_dir = wp[2] # (xx, xy, xz)
# Collect all body shapes from the current component.
body_shapes = []
kernel = self._kernel
for body in self._current_component.bodies.values():
if body.geometry is not None:
shape = kernel._get_shape(body.geometry)
if shape is not None:
body_shapes.append(shape)
if not body_shapes:
self._sketch_widget.clear_source_face()
self._btn_underlay.setEnabled(False)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(False)
self._btn_to_sketch.setEnabled(False)
return
# Project edges of all bodies onto the workplane.
workplane_data = (origin, normal, x_dir)
all_polylines: List[List[Tuple[float, float]]] = []
for shape in body_shapes:
try:
polys = _project_body_to_workplane(shape, workplane_data)
all_polylines.extend(polys)
except Exception as exc:
logger.debug("body projection failed for a shape: %s", exc)
if not all_polylines:
return
# Import the polylines as external/underlay entities in the sketch.
# First clear any existing external entities, then add the new ones.
occ_sketch.remove_external_entities()
imported_count = 0
for poly in all_polylines:
if len(poly) < 2:
continue
try:
_, lines = occ_sketch.add_external_polyline(
[(float(u), float(v)) for (u, v) in poly]
)
imported_count += len(lines)
except Exception as exc:
logger.debug("workplane underlay polyline import failed: %s", exc)
if imported_count > 0:
logger.info(
"Imported %d construction-line segments from body outlines",
imported_count,
)
# Refresh the 2D widget's entity tracking. We do NOT set
# _source_underlay_uv here because body projections produce
# many disjoint polylines — the fill paintEvent draws from
# _source_underlay_uv[0] would look wrong. The external
# entities themselves (orange dashed lines) provide the
# visual underlay.
self._sketch_widget._rebuild_from_sketch()
self._sketch_widget._source_workplane = workplane_data
self._sketch_widget._source_underlay_uv = []
self._sketch_widget._underlay_visible = True
self._sketch_widget.update()
# Enable the underlay toggle so the user can hide lines.
self._btn_underlay.setEnabled(True)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(True)
self._btn_to_sketch.setEnabled(True)
def _new_sketch_origin(self):
self._sketch_widget.create_sketch()
self._sketch_widget.set_mode("line")
self._btn_line.setChecked(True)
logger.info("New sketch at origin")
def _flip_workplane(self):
logger.info("Flip workplane (not implemented)")
def _move_workplane(self):
logger.info("Move workplane: use middle-click pan in 3D view")
def _translate_body(self):
if not self._selected_body or not self._selected_body.geometry:
QMessageBox.warning(self, "No Body", "Select a body first")
return
dx, ok1 = QInputDialog.getDouble(self, "Translate", "DX (mm):", 0, -10000, 10000, 2)
if not ok1:
return
dy, ok2 = QInputDialog.getDouble(self, "Translate", "DY (mm):", 0, -10000, 10000, 2)
if not ok2:
return
dz, ok3 = QInputDialog.getDouble(self, "Translate", "DZ (mm):", 0, -10000, 10000, 2)
if not ok3:
return
try:
new_geom = self._kernel.translate(self._selected_body.geometry, (dx, dy, dz))
self._selected_body.geometry = new_geom
self._redraw_bodies()
logger.info(f"Translated body by ({dx}, {dy}, {dz})")
except Exception as e:
QMessageBox.critical(self, "Error", f"Translation failed: {e}")
def _pattern_array(self):
logger.info("Pattern array not yet implemented")
# ─── Offset sketch ─────────────────────────────────────────────────────
@staticmethod
def _find_parent_point_entities(
sketch: OCCSketch,
positions: List[Tuple[float, float]],
tolerance: float = 0.01,
) -> List[Optional[OCCSketchEntity]]:
"""Match position tuples to the corresponding point entities in the sketch.
Searches ``sketch._entities`` for point entities whose geometry
matches each entry in *positions* within *tolerance*. Returns a
list parallel to *positions*; unmatched entries are *None*.
Skips external / centerline / construction entities so we only
pick up user-drawn boundary points.
"""
matches: List[Optional[OCCSketchEntity]] = []
for (tx, ty) in positions:
found: Optional[OCCSketchEntity] = None
for eid, entity in sketch._entities.items():
if entity.entity_type != "point":
continue
if entity.is_external or entity.is_construction:
continue
if entity.id in sketch._centerline_ids:
continue
if entity.geometry is not None:
ex, ey = entity.geometry
if abs(ex - tx) < tolerance and abs(ey - ty) < tolerance:
found = entity
break
matches.append(found)
return matches
def _offset_sketch(self) -> None:
"""Open the offset dialog and apply an offset to the selected sketch face.
The user must first select a closed face (region) in the 2D sketch.
When the Offset button is pressed:
1. The selected face's outer boundary is read.
2. An OffsetDialog appears with a number spinner.
3. Live preview shows the offset result in the 2D view.
4. On OK, new point & line entities are created in the sketch
at the offset position, duplicating the original boundary.
5. Distance constraints auto-connect each offset point to its
parent so the offset stays parametric.
6. The region between the original and offset boundaries forms
a selectable wall face (e.g. for extrusion into a thin wall).
"""
# Ensure we have a sketch and a selected face.
sketch = self._sketch_widget.get_sketch()
if sketch is None:
QMessageBox.warning(self, "No Sketch", "Please create and select a sketch first.")
return
selected_face = self._sketch_widget._selected_face
if selected_face is None:
QMessageBox.warning(
self, "No Face Selected",
"Click inside a closed face (region) in the sketch to select it, "
"then press Offset."
)
return
outer = selected_face.get("outer")
if outer is None:
QMessageBox.warning(self, "No Outer Boundary", "Selected face has no outer boundary.")
return
# ── Extract boundary points ──
if outer["type"] == "circle":
cx, cy = outer["center"]
radius = outer["radius"]
is_circle = True
elif outer["type"] == "polygon":
pts = list(outer["points"])
if len(pts) < 3:
QMessageBox.warning(self, "Invalid Polygon", "Face boundary has fewer than 3 points.")
return
# Remove closing duplicate (last == first) if present.
if len(pts) > 1 and pts[-1] == pts[0]:
pts.pop()
is_circle = False
else:
QMessageBox.warning(self, "Unsupported Face", f"Face type '{outer.get('type')}' not supported.")
return
# ── Find the ORIGINAL point entities so we can constrain to them ──
if is_circle:
parent_center = self._find_parent_point_entities(sketch, [(cx, cy)], tolerance=0.01)
parent_center_entity = parent_center[0] if parent_center else None
else:
parent_entities = self._find_parent_point_entities(sketch, pts, tolerance=0.01)
# ── Open dialog with live preview ──
dialog = OffsetDialog(self)
def _compute_offset_preview(distance: float, inward: bool) -> Optional[List[Tuple[float, float]]]:
"""Return offset polygon points, or None for circles."""
d = -distance if inward else distance
if is_circle:
return None # circles not drawn as polygon preview
try:
return _offset_polygon(pts, d)
except Exception as exc:
logger.debug("offset preview compute failed: %s", exc)
return None
def _preview_callback(values):
if values is None:
self._sketch_widget.clear_offset_preview()
return
distance, inward = values
preview_pts = _compute_offset_preview(distance, inward)
self._sketch_widget.set_offset_preview(preview_pts)
dialog.set_preview_callback(_preview_callback)
if not dialog.exec():
# Preview already cleared by hideEvent.
self._sketch_widget.clear_offset_preview()
return
self._sketch_widget.clear_offset_preview()
distance, inward = dialog.get_values()
d = -distance if inward else distance
logger.info(f"Offset distance: {abs(d):.2f} mm {'inward' if inward else 'outward'}")
try:
# ── Apply offset: create new entities in the sketch ──
if is_circle:
self._apply_circle_offset(
sketch, cx, cy, radius, d, selected_face,
parent_center_entity=parent_center_entity,
offset_distance=abs(d),
)
else:
self._apply_polygon_offset(
sketch, pts, d, selected_face,
parent_entities=parent_entities,
offset_distance=abs(d),
)
self._sketch_widget._rebuild_from_sketch()
self._sketch_widget._solve_and_sync()
self._sketch_widget.sketch_updated.emit()
self._sketch_widget.update()
self.statusBar().showMessage(
f"Offset sketch by {abs(d):.2f} mm {'inward' if inward else 'outward'}", 4000
)
logger.info("Offset complete")
except Exception as e:
logger.exception(f"Offset failed: {e}")
QMessageBox.critical(self, "Error", f"Offset failed: {e}")
def _apply_polygon_offset(
self, sketch: OCCSketch,
pts: List[Tuple[float, float]],
distance: float,
face: Dict[str, Any],
parent_entities: Optional[List[Optional[OCCSketchEntity]]] = None,
offset_distance: float = 0.0,
) -> None:
"""Duplicate a polygon boundary at *distance* offset and add to the sketch.
Creates new point + line entities for the offset boundary and
re-applies any holes from the original face (offset by the same
distance, clipped if they collapse). The region between the
original boundary and the offset boundary becomes a selectable
face (e.g. a thin wall for extrusion). When *parent_entities*
is provided, a distance constraint is added between each parent
point and the corresponding offset point with the
*offset_distance* value.
"""
offset_pts = _offset_polygon(pts, distance)
# Create new point entities at the offset positions.
new_points = []
for (x, y) in offset_pts:
pt = sketch.add_point(float(x), float(y))
new_points.append(pt)
# Create line entities connecting the new points.
new_lines = []
for i in range(len(new_points)):
j = (i + 1) % len(new_points)
line = sketch.add_line(new_points[i], new_points[j])
new_lines.append(line)
# ── Auto-constrain: distance constraint between each parent
# point and its corresponding offset point ──
if parent_entities and offset_distance > 0:
constrained = 0
for parent_ent, new_pt in zip(parent_entities, new_points):
if parent_ent is not None:
try:
sketch.constrain_distance(parent_ent, new_pt, offset_distance)
constrained += 1
except Exception as exc:
logger.debug(
"distance constraint failed for parent id=%s: %s",
parent_ent.id, exc,
)
if constrained:
logger.info("Added %d distance constraints to offset polygon", constrained)
# ── Offset holes ──
holes = face.get("holes", [])
for hole in holes:
if hole["type"] != "polygon":
continue
hole_pts = list(hole["points"])
if len(hole_pts) < 3:
continue
if len(hole_pts) > 1 and hole_pts[-1] == hole_pts[0]:
hole_pts.pop()
# Holes are offset in the OPPOSITE direction (a positive outer
# offset should make holes smaller, not larger).
offset_hole = _offset_polygon(hole_pts, -distance)
if len(offset_hole) < 3:
logger.debug("Hole offset collapsed — skipping")
continue
hole_points = []
for (x, y) in offset_hole:
pt = sketch.add_point(float(x), float(y))
hole_points.append(pt)
for i in range(len(hole_points)):
j = (i + 1) % len(hole_points)
sketch.add_line(hole_points[i], hole_points[j])
logger.info(
"Created %d offset points and %d offset lines for polygon boundary + %d holes",
len(offset_pts), len(offset_pts),
len([h for h in holes if h.get("type") == "polygon"]),
)
def _apply_circle_offset(
self, sketch: OCCSketch,
cx: float, cy: float, radius: float,
distance: float,
face: Dict[str, Any],
parent_center_entity: Optional[OCCSketchEntity] = None,
offset_distance: float = 0.0,
) -> None:
"""Duplicate a circle at *distance* offset and add to the sketch.
For circles the offset is simply a new circle with (radius ± distance).
A new center point is created so the original is not disturbed.
The region between the original and offset circles becomes a
selectable face (annular wall for extrusion). When
*parent_center_entity* is provided a distance constraint links
it to the new center.
"""
new_radius = radius + distance
if new_radius <= 0:
logger.warning("Offset radius would be non-positive — skipping")
return
# Create a new center point (slightly nudged so it's distinct).
new_cx = cx + 0.001 if abs(distance) < 0.01 else cx
new_cy = cy + 0.001 if abs(distance) < 0.01 else cy
center_pt = sketch.add_point(float(new_cx), float(new_cy))
sketch.add_circle(center_pt, float(new_radius))
# ── Auto-constrain: distance from parent center to new center ──
if parent_center_entity is not None and offset_distance > 0:
try:
sketch.constrain_distance(parent_center_entity, center_pt, offset_distance)
logger.info("Added distance constraint to offset circle center")
except Exception as exc:
logger.debug("circle distance constraint failed: %s", exc)
# Also offset any holes.
holes = face.get("holes", [])
for hole in holes:
if hole["type"] != "circle":
continue
h_cx, h_cy = hole["center"]
h_r = hole["radius"]
new_h_r = h_r - distance # holes shrink when outer grows
if new_h_r <= 0:
logger.debug("Hole circle offset collapsed — skipping")
continue
h_center = sketch.add_point(float(h_cx), float(h_cy))
sketch.add_circle(h_center, float(new_h_r))
logger.info(
"Created offset circle: center=(%.2f, %.2f), radius=%.2f",
new_cx, new_cy, new_radius,
)
# ─── Sketch-on-surface (face pick) ────────────────────────────────────
def _on_face_sketch_toggled(self, checked: bool) -> None:
"""Toggle the 3D viewer's face-pick mode (WP Face button)."""
self._viewer_3d.set_pick_face_mode(checked)
if checked:
# Clear any previous face-selection tint before picking a new one.
self._viewer_3d.clear_face_highlight()
# Make sure the 3D viewer has focus so it receives the click.
self._viewer_3d.setFocus()
self._viewer_3d.activateWindow()
self.statusBar().showMessage(
"Pick a planar face in the 3D viewer to sketch on (Esc to cancel)",
8000,
)
def _on_face_picked(self, origin, normal, x_dir, face_shape) -> None:
"""Create a new sketch on the picked planar face and switch to 2D.
Also records *which body* the picked face belonged to on the sketch
(``sketch._source_body_id``) so a later "Perform Cut" / "Combine"
extrude operation auto-targets that body instead of the first body
in the dict. Auto-selects the new sketch in the left-hand list so
the user can immediately Extrude/Cut without hunting for the row.
"""
# ``facePicked`` carries the face shape PLUS the owning obj_id from
# ``pick_planar_face`` (the renderer matches DetectedInteractive
# against tracked AIS objects). We extract that owner so the cut
# can target the right body.
source_body = None
logger.info(
f"Face picked: origin={origin}, normal={normal}, x_dir={x_dir}"
)
# Pull the owning obj_id the renderer stashed on this pick pass.
owner_obj_id = getattr(self._viewer_3d, "_last_pick_owner_obj_id", None)
if owner_obj_id and self._current_component is not None:
for bid, body in self._current_component.bodies.items():
if body.render_object == owner_obj_id:
source_body = body
logger.info(f"Sketch source body: {body.name}")
break
# Tint the picked face light-blue so the selection is visible in 3D.
self._viewer_3d.highlight_face(face_shape)
# Leave pick mode (the button stays toggled until we uncheck it).
self._btn_wp_face.setChecked(False)
self._viewer_3d.set_pick_face_mode(False)
if not self._current_component:
self._current_component = self._project.add_component()
sketch = self._current_component.add_sketch()
self._mark_dirty()
sketch.name = f"Sketch on face {len(self._current_component.sketches)}"
# Place the sketch on the picked plane (sets fields + syncs occ_sketch).
sketch.set_workplane(origin, normal, x_dir)
# Keep the face reference for the projection underlay (Phase 3).
sketch._source_face = face_shape
# Remember which body the sketch lives on so a later cut / combine
# extrude auto-targets it. ``source_body`` may be None if the
# pick landed on an untracked shape (e.g. an imported STEP that
# wasn't registered as a component body — robust fallback then).
sketch._source_body_id = source_body.id if source_body else None
# Hand the sketch to the 2D widget and focus the sketch panel.
# Always build a clean OCC sketch carrying the face workplane so the
# widget draws on the picked plane.
if sketch.occ_sketch is None or sketch.occ_sketch.get_entity_count() > 0:
sketch.occ_sketch = self._sketch_widget.create_sketch()
sketch.apply_workplane()
self._sketch_widget.set_sketch(sketch.occ_sketch)
self._sketch_widget.set_source_face(face_shape, origin, normal, x_dir)
self._current_sketch = sketch
self._sketch_widget.set_mode("line")
self._btn_line.setChecked(True)
self._refresh_lists()
# Auto-select the freshly created sketch in the left-hand list so a
# 3D op (Extrude/Cut) operates on it without the user hunting for
# the row. _on_sketch_selected loads it into the widget for editing.
for row in range(self._sketch_list.count()):
item = self._sketch_list.item(row)
if item is not None and item.text() == sketch.name:
self._sketch_list.setCurrentRow(row)
break
# Switch focus to the sketch panel so the user can draw immediately.
self._set_panel_focus("sketch")
self.statusBar().showMessage(
f"Sketch placed on face — drawing in 2D on that plane", 6000
)
# The face is now the source for the underlay construction lines:
# enable the show/hide toggle, ClrFace, and ToSketch buttons.
self._btn_underlay.setEnabled(True)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(True)
self._btn_to_sketch.setEnabled(True)
def _on_underlay_toggled(self, checked: bool) -> None:
"""Show or hide the underlay construction lines in the 2D view.
Toggling this button does NOT remove the external entities from the
sketch solver — they stay there so existing constraints that
reference them keep working. The entities are just hidden from
paint + hover + hit-test while the toggle is off.
"""
self._sketch_widget.set_underlay_visible(checked)
self.statusBar().showMessage(
f"Underlay {'visible' if checked else 'hidden'}", 2000
)
def _on_clear_source_face(self) -> None:
"""Forget the source face: remove underlay entities, keep the workplane.
After this, the sketch remains on the same plane but the face
reference and its projected construction lines are gone. The user
keeps whatever user-drawn geometry they already added (and any
constraints they already applied, since they were pinned to entity
ids that are now removed along with the underlay).
"""
self._sketch_widget.clear_source_face()
self._btn_underlay.setEnabled(False)
self._btn_underlay.setChecked(False)
self._btn_clr_face.setEnabled(False)
self._btn_to_sketch.setEnabled(False)
if self._current_sketch is not None:
# Drop the saved reference on the model so re-editing the
# sketch later doesn't re-create the underlay.
self._current_sketch._source_face = None
self.statusBar().showMessage(
"Source face cleared — underlay construction lines removed", 3000
)
def _on_convert_underlay_to_sketch(self) -> None:
"""Convert the underlay/projected construction lines into real sketch geometry.
Delegates to the widget's ``_convert_underlay_to_sketch`` which
creates regular (non-construction, non-external) point and line
entities at every underlay position. The underlay reference stays
intact so the user can still toggle it on/off.
"""
self._sketch_widget._convert_underlay_to_sketch()
# Sync the main window's underlay toggle to match the widget
# (the conversion auto-hides the underlay).
self._btn_underlay.setChecked(False)
self.statusBar().showMessage(
"Underlay converted to sketch geometry — now you can select faces, offset, and extrude",
5000,
)
def _pattern_array_placeholder(self):
pass
def _add_sketch_to_component(self):
logger.info("=== ADD SKETCH TO COMPONENT ===")
if not self._current_component:
logger.info("No current component, creating new one")
self._current_component = self._project.add_component()
sketch = self._current_component.add_sketch()
self._mark_dirty()
logger.debug(f"Created sketch: {sketch.name}")
sketch_widget_sketch = self._sketch_widget.get_sketch()
logger.debug(f"Sketch from widget: {sketch_widget_sketch}")
sketch.occ_sketch = sketch_widget_sketch
if not sketch.occ_sketch:
logger.info("Creating new sketch in widget")
sketch.occ_sketch = self._sketch_widget.create_sketch()
# Adopt the widget sketch's existing 3D workplane (e.g. set by a
# face-pick) instead of clobbering it with this Sketch's default XY
# fields — otherwise a sketch drawn on a picked face would jump back
# to the world origin plane on the next extrude.
if sketch.occ_sketch is not None and hasattr(sketch.occ_sketch, "get_workplane"):
wp = sketch.occ_sketch.get_workplane()
import numpy as _np
sketch.workplane_origin = _np.asarray(wp[0], dtype=float)
sketch.workplane_normal = _np.asarray(wp[1], dtype=float)
sketch.workplane_x_dir = _np.asarray(wp[2], dtype=float)
# Sync the sketch's workplane (origin/normal/x_dir) into the OCC sketch
# so geometry is built on the right plane.
sketch.apply_workplane()
self._current_sketch = sketch
self._refresh_lists()
self._sketch_widget.set_mode(None)
logger.info(f"Added sketch: {sketch.name}")
logger.info(f"=== SKETCH ADDED: {sketch.name} ===")
def _edit_sketch(self):
selected = self._sketch_list.currentItem()
if not selected:
return
name = selected.text()
for sketch_id, sketch in self._current_component.sketches.items():
if sketch.name == name:
self._current_sketch = sketch
if sketch.occ_sketch:
sketch.apply_workplane()
self._sketch_widget.set_sketch(sketch.occ_sketch)
# If the sketch carries a saved source face (sketch-on-
# surface), re-bind it so the underlay construction lines
# come back. set_source_face rebuilds the external
# entities and re-orients the 2D view.
if getattr(sketch, "_source_face", None) is not None and sketch.occ_sketch is not None:
wp = sketch.occ_sketch.get_workplane()
origin, normal, x_dir = wp[0], wp[1], wp[2]
self._sketch_widget.set_source_face(
sketch._source_face, origin, normal, x_dir
)
self._btn_underlay.setEnabled(True)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(True)
self._btn_to_sketch.setEnabled(True)
elif getattr(sketch, "_source_workplane_id", None) is not None:
# Sketch on an independent workplane: project body outlines.
self._project_body_to_active_wp()
self._btn_underlay.setEnabled(True)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(True)
self._btn_to_sketch.setEnabled(True)
else:
# No saved face: make sure the underlay buttons
# reflect that the widget has no source face bound.
self._btn_underlay.setEnabled(False)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(False)
self._btn_to_sketch.setEnabled(False)
self._sketch_widget.set_mode("line")
self._btn_line.setChecked(True)
logger.info(f"Editing sketch: {name}")
break
def _on_sketch_selected(self, current, previous):
"""When sketch is selected in list, load it for editing."""
if current and self._current_component:
name = current.text()
for sketch_id, sketch in self._current_component.sketches.items():
if sketch.name == name:
self._current_sketch = sketch
if sketch.occ_sketch and hasattr(sketch.occ_sketch, 'get_entity_count') and sketch.occ_sketch.get_entity_count() > 0:
self._sketch_widget.set_sketch(sketch.occ_sketch)
break
def _delete_sketch(self):
selected = self._sketch_list.currentItem()
if not selected or not self._current_component:
return
name = selected.text()
to_delete = None
for sketch_id, sketch in self._current_component.sketches.items():
if sketch.name == name:
to_delete = sketch_id
break
if to_delete:
del self._current_component.sketches[to_delete]
self._mark_dirty()
self._refresh_lists()
logger.info(f"Deleted sketch: {name}")
def _on_sketch_list_changed(self, current, previous):
if current and self._current_component:
name = current.text()
for sketch_id, sketch in self._current_component.sketches.items():
if sketch.name == name:
self._current_sketch = sketch
break
def _on_body_list_changed(self, current, previous):
if current and self._current_component:
name = current.text()
for body_id, body in self._current_component.bodies.items():
if body.name == name:
self._selected_body = body
logger.info(f"Selected: {name}")
break
def _on_body_visibility_changed(self, item: QListWidgetItem) -> None:
"""Toggle a body's 3D visibility when the user flips its checkbox.
itemChanged also fires for selection (not just check-state) changes,
so we filter on the check state being the changed role. The body
is looked up via the UserRole data we set in _refresh_lists.
"""
if self._current_component is None:
return
body_id = item.data(Qt.UserRole)
if body_id is None:
return
body = self._current_component.bodies.get(body_id)
if body is None:
return
new_visible = item.checkState() == Qt.Checked
if body.visible == new_visible:
return # no change
body.visible = new_visible
# Greying out hidden bodies gives a quick visual hint in the list.
item.setForeground(QColor("#1e1e2e") if new_visible else QColor("#6c7086"))
# Apply to the 3D viewer: if the body has a rendered object, hide
# or show it. Bodies without a render_object (e.g. just-created,
# not yet displayed) don't need viewer updates; they'll pick up
# the visibility at the next redraw.
if body.render_object is not None:
ok = self._viewer_3d.set_visibility(body.render_object, new_visible)
if not ok:
logger.debug(
"set_visibility failed for body %s (render_object=%r)",
body.name, body.render_object,
)
logger.info(
f"{'Visible' if new_visible else 'Hidden'}: {body.name}"
)
# ─── Extrude / cut helpers (shared by live preview + apply) ────────
def _resolve_extrude_target(
self, sketch: Sketch, exclude_body: Optional[Body] = None
) -> Optional[Body]:
"""Choose the body a cut / union should target.
Preference order:
1. the body the sketch was projected onto (``sketch._source_body_id``)
2. the first body in the component that isn't the *exclude_body*
(the freshly-extruded tool itself, which we don't want to cut
*itself*).
Returns *None* if there is no candidate (e.g. the sketch wasn't
on a face and the component has no other bodies).
"""
if self._current_component is None:
return None
bodies = self._current_component.bodies
src_id = getattr(sketch, "_source_body_id", None)
if src_id is not None and src_id in bodies:
cand = bodies[src_id]
if cand is not exclude_body:
return cand
for body in bodies.values():
if body is exclude_body:
continue
return body
return None
def _through_all_length(self, target: Body, sketch: Sketch) -> float:
"""Height (mm) for ``kernel.extrude(..., symmetric=True)`` to pass
*through* the target body.
Computes the target body's bounding-box extent along the sketch's
workplane normal direction ("extent" = how far the body reaches on
either side of the face). With ``symmetric=True`` the kernel
extrudes ``± height/2``, so to clear the full ``extent`` on each
side we need ``height = 2 × (extent + buffer)``. The 5 mm buffer
on each side guarantees the tool pokes out past the body so the
boolean reliably removes the through volume.
"""
import numpy as _np
try:
p_min, p_max = self._kernel.get_bounding_box(target.geometry)
except Exception:
logger.debug("through-all bbox failed", exc_info=True)
return 2000.0 # generous fallback if bbox fails for any reason
origin = _np.asarray(sketch.workplane_origin, dtype=float)
normal = _np.asarray(sketch.workplane_normal, dtype=float)
normal = normal / max(_np.linalg.norm(normal), 1e-12)
corners = []
for xs in (p_min.x, p_max.x):
for ys in (p_min.y, p_max.y):
for zs in (p_min.z, p_max.z):
corners.append(_np.array([xs, ys, zs]))
ds = [_np.dot(c - origin, normal) for c in corners]
extent = max(abs(min(ds)), abs(max(ds)))
# Symmetric through: cover ±(extent + 5 mm) on each side of the
# face plane, which means a total height of 2×(extent + 5).
return 2.0 * float(extent) + 10.0
def _compute_extrude_result(
self,
sketch: Sketch,
face_geom: Any,
length: float,
symmetric: bool,
invert: bool,
cut: bool,
union: bool,
through_all: bool,
) -> Optional[Dict[str, Any]]:
"""Compute the *previewable* result of an extrude/cut/union.
Returns a dict with:
- "result_shape": final TopoDS_Shape (the thing to show / commit)
- "target_body": the Body being modified (None for plain extrude)
- "tool_geom": the extruded profile geometry (the boolean tool)
- "tool_shape": same, as a TopoDS_Shape (for show/remove)
Or *None* if the geometry can't be built (e.g. empty sketch).
Mutates nothing on the project — safe to call repeatedly for the
live preview. The apply path (:meth:`_extrude_sketch`) commits
the returned shape onto ``target_body`` (or creates a new body
for plain extrudes).
"""
if face_geom is None:
return None
# Resolve target (only meaningful for cut / union).
target = self._resolve_extrude_target(sketch) if (cut or union) else None
# Determine the extrude length and direction.
if through_all and target is not None:
# Pass-through: symmetric extrude large enough to clear the body
# on both sides of the face plane (direction-agnostic).
extrude_length = self._through_all_length(target, sketch)
symmetric = True
invert = False
else:
# Cut targeting a body must go *into* the body — the picked face's
# outward normal points AWAY from the body, so a non-inverted
# extrude would build a boss ABOVE the face and the boolean cut
# would remove nothing. Force the tool into the body so
# "Perform Cut" always carves a real pocket.
if cut and target is not None:
invert = True
extrude_length = -length if invert else length
try:
tool_geom = self._kernel.extrude(
face_geom, extrude_length, symmetric=symmetric
)
except Exception as exc:
logger.debug("preview extrude failed: %s", exc)
return None
if tool_geom is None:
return None
tool_shape = self._kernel._get_shape(tool_geom)
if target is not None:
try:
if cut:
result_geom = self._kernel.boolean_difference(
target.geometry, tool_geom
)
else: # union
result_geom = self._kernel.boolean_union(
target.geometry, tool_geom
)
except Exception as exc:
logger.debug("preview boolean failed: %s", exc)
return None
result_shape = self._kernel._get_shape(result_geom)
return {
"result_shape": result_shape,
"result_geom": result_geom,
"target_body": target,
"tool_geom": tool_geom,
"tool_shape": tool_shape,
}
# Plain extrude: the tool IS the result.
return {
"result_shape": tool_shape,
"result_geom": tool_geom,
"target_body": None,
"tool_geom": tool_geom,
"tool_shape": tool_shape,
}
def _start_extrude_preview(self, dialog: ExtrudeDialog, sketch: Sketch, face_geom: Any) -> None:
"""Install a live-preview callback on *dialog* for *sketch*.
The host dims the body the cut/union will target (if any) so the
previewed result reads clearly on top of it. The dimming is
reverted on dialog close (see hideEvent → callback(None)).
"""
# Track which bodies we dimmed so we can restore their transparency
# exactly (they might have had a non-zero transparency to start, in
# which case we leave them alone).
state = {"dimmed": []}
def _apply_dim(target: Optional[Body]):
# Undo any prior dim, then dim the new target.
for bid, tval in state["dimmed"]:
body = self._current_component.bodies.get(bid) if self._current_component else None
if body is not None and body.render_object is not None:
self._viewer_3d.set_transparency(body.render_object, 0.0)
state["dimmed"].clear()
if target is not None and target.render_object is not None:
ok = self._viewer_3d.set_transparency(target.render_object, 0.6)
if ok:
state["dimmed"].append((target.id, 0.6))
def _clear():
self._viewer_3d.clear_preview()
for bid, _tval in state["dimmed"]:
body = self._current_component.bodies.get(bid) if self._current_component else None
if body is not None and body.render_object is not None:
self._viewer_3d.set_transparency(body.render_object, 0.0)
state["dimmed"].clear()
def _callback(values):
if values is None:
_clear()
return
length, symmetric, invert, cut, union, through_all, _rounded = values
result = self._compute_extrude_result(
sketch, face_geom,
length, symmetric, invert, bool(cut), bool(union),
bool(through_all),
)
if result is None or result["result_shape"] is None:
self._viewer_3d.clear_preview()
_apply_dim(None)
return
self._viewer_3d.show_preview(result["result_shape"])
_apply_dim(result["target_body"])
dialog.set_preview_callback(_callback)
def _extrude_sketch(self):
logger.info("=== EXTRUDE SKETCH ===")
if not self._current_component:
logger.warning("No current component")
return
sketch = self._current_sketch
logger.debug(f"Current sketch: {sketch}")
if not sketch or not sketch.occ_sketch:
sketch_entity = self._sketch_widget.get_sketch()
logger.debug(f"Sketch from widget: {sketch_entity}")
if not sketch_entity:
logger.warning("No sketch entity found")
QMessageBox.warning(self, "No Sketch", "Please create a sketch first")
return
sketch.occ_sketch = sketch_entity
# Resolve the profile geometry *before* opening the dialog so the
# live preview can use it. Prefer the selected face (which can
# include holes) over the full sketch.
face_geom = self._sketch_widget.get_selected_face_geometry()
if face_geom is not None:
logger.info("Using selected face geometry (with holes)")
else:
face_geom = sketch.occ_sketch.get_geometry()
logger.debug(f"Geometry: {face_geom}")
if not face_geom:
logger.error("No geometry from sketch")
QMessageBox.warning(self, "No Geometry", "Sketch has no valid geometry")
return
dialog = ExtrudeDialog(self)
# Wire up the live preview: every spinbox/checkbox change rebuilds
# the result via the shared helper and shows it transparent.
self._start_extrude_preview(dialog, sketch, face_geom)
accepted = dialog.exec()
# The dialog's hideEvent already fired the callback with *None* to
# clear the preview and un-dim any body — but be defensive in case
# a subclass swallows the event.
self._viewer_3d.clear_preview()
if not accepted:
logger.info("Extrude dialog cancelled")
return
length, symmetric, invert, cut, union, through_all, rounded = dialog.get_values()
logger.info(
f"Extrude params: length={length}, symmetric={symmetric}, "
f"invert={invert}, cut={cut}, union={union}, through_all={through_all}"
)
try:
result = self._compute_extrude_result(
sketch, face_geom,
length, symmetric, invert, bool(cut), bool(union),
bool(through_all),
)
if result is None or result["result_geom"] is None:
logger.warning("Extrude produced no geometry")
QMessageBox.warning(self, "No Geometry", "Extrude produced no geometry")
return
target = result["target_body"]
if target is not None:
# Cut / union: commit the result onto the *target* body in
# place (don't create a separate tool body — the previous
# implementation did, and that was the user-perceived
# "added without cut" bug once the spurious body was
# deleted).
target.geometry = result["result_geom"]
if target.render_object is not None:
self._viewer_3d.remove_mesh(target.render_object)
shape = self._kernel._get_shape(target.geometry)
target.render_object = self._viewer_3d.show_shape(
shape, target.color, target.name
)
op = "cut" if cut else "union"
logger.info(
f"{op.capitalize()} applied: {target.name} now holds the result"
)
body_name = target.name
else:
# Plain extrude: create a new body for the extrusion.
body = self._current_component.add_body(
Body(
name=f"Extrusion_{len(self._current_component.bodies) + 1}",
geometry=result["result_geom"],
source_sketch=sketch,
source_operation="extrude",
)
)
self._mark_dirty()
logger.info(f"Created body: {body.name}")
logger.debug("Adding shape to OCC viewer")
shape = self._kernel._get_shape(body.geometry)
body.render_object = self._viewer_3d.show_shape(
shape, body.color, body.name
)
logger.info(f"Render object: {body.render_object}")
body_name = body.name
self._refresh_lists()
self._viewer_3d.fit_camera()
logger.info(f"Extruded: {body_name}")
logger.info("=== EXTRUDE COMPLETE ===")
except Exception as e:
logger.exception(f"Extrude failed: {e}")
QMessageBox.critical(self, "Error", f"Extrude failed: {e}")
def _revolve_sketch(self):
logger.info("=== REVOLVE SKETCH ===")
if not self._current_component:
logger.warning("No current component")
return
sketch = self._current_sketch
if not sketch or not sketch.occ_sketch:
sketch_entity = self._sketch_widget.get_sketch()
if not sketch_entity:
QMessageBox.warning(self, "No Sketch", "Please create a sketch first")
return
sketch.occ_sketch = sketch_entity
dialog = RevolveDialog(self)
if not dialog.exec():
logger.info("Revolve dialog cancelled")
return
angle = dialog.angle_input.value()
try:
face_geom = self._sketch_widget.get_selected_face_geometry()
if face_geom is not None:
geometry = face_geom
else:
geometry = sketch.occ_sketch.get_geometry()
if not geometry:
QMessageBox.warning(self, "No Geometry", "Sketch has no valid geometry")
return
body_geometry = self._kernel.revolve(geometry, angle)
body = self._current_component.add_body(
Body(
name=f"Revolution_{len(self._current_component.bodies) + 1}",
geometry=body_geometry,
source_sketch=sketch,
source_operation="revolve",
)
)
self._mark_dirty()
logger.debug("Adding shape to OCC viewer")
shape = self._kernel._get_shape(body_geometry)
body.render_object = self._viewer_3d.show_shape(shape, body.color, body.name)
logger.info(f"Render object: {body.render_object}")
self._refresh_lists()
self._viewer_3d.fit_camera()
logger.info(f"Revolved: {body.name}")
except Exception as e:
logger.exception(f"Revolve failed: {e}")
QMessageBox.critical(self, "Error", f"Revolve failed: {e}")
def _boolean_cut(self):
logger.info("=== BOOLEAN CUT ===")
if not self._current_component or len(self._current_component.bodies) < 2:
QMessageBox.warning(self, "Need Bodies", "Need at least 2 bodies to perform cut.\nCreate multiple bodies first.")
return
# Use the first body in the list as base, last as tool
body_ids = list(self._current_component.bodies.keys())
if len(body_ids) < 2:
return
# Let user pick which body to use as tool
body_names = [self._current_component.bodies[bid].name for bid in body_ids]
tool_name, ok = QInputDialog.getItem(
self, "Select Tool Body", "Body to subtract (tool):", body_names, len(body_names) - 1, False
)
if not ok:
return
tool_id = None
base_id = None
for bid in body_ids:
if self._current_component.bodies[bid].name == tool_name:
tool_id = bid
else:
base_id = bid
if tool_id is None or base_id is None:
return
base_body = self._current_component.bodies[base_id]
tool_body = self._current_component.bodies[tool_id]
if not base_body.geometry or not tool_body.geometry:
QMessageBox.warning(self, "No Geometry", "One of the bodies has no geometry")
return
try:
result_geom = self._kernel.boolean_difference(base_body.geometry, tool_body.geometry)
new_body = self._current_component.add_body(
Body(
name=f"Cut_{len(self._current_component.bodies) + 1}",
geometry=result_geom,
source_operation="boolean_cut",
)
)
self._mark_dirty()
logger.debug("Adding shape to OCC viewer")
shape = self._kernel._get_shape(result_geom)
new_body.render_object = self._viewer_3d.show_shape(shape, new_body.color, new_body.name)
logger.info(f"Render object: {new_body.render_object}")
self._refresh_lists()
self._viewer_3d.fit_camera()
logger.info(f"Cut complete: {new_body.name}")
except Exception as e:
logger.exception(f"Boolean cut failed: {e}")
QMessageBox.critical(self, "Error", f"Boolean cut failed: {e}")
def _boolean_union(self):
logger.info("=== BOOLEAN UNION ===")
if not self._current_component or len(self._current_component.bodies) < 2:
QMessageBox.warning(self, "Need Bodies", "Need at least 2 bodies to perform union.")
return
bodies = list(self._current_component.bodies.values())
geometries = [b.geometry for b in bodies if b.geometry]
if len(geometries) < 2:
QMessageBox.warning(self, "Need Bodies", "Not enough bodies with valid geometry.")
return
try:
result_geom = self._kernel.boolean_union(*geometries)
new_body = self._current_component.add_body(
Body(
name=f"Union_{len(self._current_component.bodies) + 1}",
geometry=result_geom,
source_operation="boolean_union",
)
)
self._mark_dirty()
logger.debug("Adding shape to OCC viewer")
shape = self._kernel._get_shape(result_geom)
new_body.render_object = self._viewer_3d.show_shape(shape, new_body.color, new_body.name)
logger.info(f"Render object: {new_body.render_object}")
self._refresh_lists()
self._viewer_3d.fit_camera()
logger.info(f"Union complete: {new_body.name}")
except Exception as e:
logger.exception(f"Boolean union failed: {e}")
QMessageBox.critical(self, "Error", f"Boolean union failed: {e}")
def _delete_body(self):
selected = self._body_list.currentItem()
if not selected or not self._current_component:
return
name = selected.text()
to_delete = None
for body_id, body in self._current_component.bodies.items():
if body.name == name:
to_delete = body_id
if body.render_object:
self._viewer_3d.remove_mesh(body.render_object)
break
if to_delete:
del self._current_component.bodies[to_delete]
self._mark_dirty()
self._refresh_lists()
logger.info(f"Deleted body: {name}")
# ── Recent Projects ──────────────────────────────────────────────
def _setup_recent_projects(self) -> None:
"""Restore the recent projects menu from settings on startup."""
self._update_recent_menu()
# Auto-load last project if the preference is enabled.
if self._settings.value("load_last_on_startup", False, type=bool):
recent = self._settings.value("recent_projects", [], type=list)
if recent and os.path.isfile(recent[0]):
self._suspend_dirty = True
try:
self._open_project_file(recent[0])
except Exception as exc:
logger.warning("Failed to auto-load last project: %s", exc)
finally:
self._suspend_dirty = False
def _get_recent_projects(self) -> List[str]:
"""Return the list of recent project paths from QSettings."""
return self._settings.value("recent_projects", [], type=list)
def _add_recent_project(self, path: str) -> None:
"""Add *path* to the top of the recent-projects list."""
recent = self._get_recent_projects()
# Normalize and deduplicate.
path = os.path.abspath(path)
if path in recent:
recent.remove(path)
recent.insert(0, path)
# Trim to max.
recent = recent[:MAX_RECENT_PROJECTS]
self._settings.setValue("recent_projects", recent)
self._update_recent_menu()
def _update_recent_menu(self) -> None:
"""Rebuild the Recent Projects submenu from the stored list."""
self._recent_projects_menu.clear()
recent = self._get_recent_projects()
if not recent:
action = self._recent_projects_menu.addAction("(Empty)")
action.setEnabled(False)
return
for path in recent:
name = os.path.basename(path)
action = self._recent_projects_menu.addAction(f"{name} — {path}")
# Use the full path as data so we can open it.
action.setData(path)
action.triggered.connect(self._open_recent_project)
self._recent_projects_menu.addSeparator()
clear_action = self._recent_projects_menu.addAction("Clear Recent Projects")
clear_action.triggered.connect(self._clear_recent_projects)
@Slot()
def _open_recent_project(self) -> None:
"""Open the project whose action was clicked."""
action = self.sender()
if action is None:
return
path = action.data()
if path and os.path.isfile(path):
self._open_project_file(path)
else:
QMessageBox.warning(self, "File Not Found", f"Project not found:\n{path}")
@Slot(bool)
def _toggle_load_last_project(self, checked: bool) -> None:
"""Persist the "Load last project on startup" preference."""
self._settings.setValue("load_last_on_startup", checked)
@Slot()
def _clear_recent_projects(self) -> None:
"""Empty the recent projects list."""
self._settings.setValue("recent_projects", [])
self._update_recent_menu()
# ── Project save / load ─────────────────────────────────────────
def _new_project(self):
if not self._confirm_discard_changes():
return
# Suppress dirty while we reset the scene; the new project starts
# as a fresh empty one and shouldn't show as "modified".
self._suspend_dirty = True
try:
self._project = Project()
self._current_component = None
self._current_sketch = None
self._selected_body = None
for btn in self._component_buttons:
btn.deleteLater()
self._component_buttons.clear()
# set_sketch(None) clears the underlay entities via the new
# set_sketch guard, but we also need to drop the saved source face
# and reset the workplane buttons to their disabled state.
self._sketch_widget.clear_source_face()
self._sketch_widget.set_sketch(None)
self._viewer_3d.clear_scene()
self._refresh_lists()
self._btn_underlay.setEnabled(False)
self._btn_underlay.setChecked(True)
self._btn_clr_face.setEnabled(False)
self._btn_to_sketch.setEnabled(False)
self._create_initial_component()
finally:
self._suspend_dirty = False
self._project_path = None
self._dirty = False
self._update_window_title()
logger.info("New project created")
# ────────────────────────────────────────────────────────────────────
# Project save / load
# ────────────────────────────────────────────────────────────────────
def _mark_dirty(self) -> None:
"""Mark the project as having unsaved changes.
Called from any UI path that mutates the model (adding components,
sketches, bodies, etc.). The setter is intentionally a no-op if the
project is already dirty to keep the title-bar updates cheap — the
title flips from "Untitled" / "name.fluency" to "Untitled*" /
"name.fluency*" on the first edit and stays there until :meth:`_save_project`
clears it.
When :attr:`_suspend_dirty` is set (during programmatic init or a
``_new_project`` reset) the call is a no-op so the freshly-created
default project doesn't immediately appear as "modified" in the
title bar.
"""
if self._dirty or self._suspend_dirty:
return
self._dirty = True
self._update_window_title()
def _update_window_title(self) -> None:
"""Refresh the title bar to reflect current file + dirty state."""
if self._project_path:
name = os.path.basename(self._project_path)
else:
name = "Untitled"
suffix = " *" if self._dirty else ""
self.setWindowTitle(f"Fluency CAD 2.0 — {name}{suffix}")
def _collect_view_state(self) -> Dict[str, Any]:
"""Snapshot the camera + active-tab state for the saved view_state."""
try:
eye, at_, up = self._viewer_3d.get_camera_position()
except Exception:
eye = [1.0, 1.0, 1.0]
at_ = [0.0, 0.0, 0.0]
up = [0.0, 0.0, 1.0]
# eye / at / up may be tuples, lists, or numpy arrays depending on
# the renderer — coerce to plain 3-lists.
def _flat3(v):
if v is None:
return [0.0, 0.0, 0.0]
if hasattr(v, "tolist"):
v = v.tolist()
seq = list(v)
if len(seq) < 3:
seq = seq + [0.0] * (3 - len(seq))
return [float(seq[0]), float(seq[1]), float(seq[2])]
return {
"active_tab": self._input_tabs.currentIndex() if hasattr(self, "_input_tabs") else 0,
"active_component_id": self._current_component.id if self._current_component else None,
"active_sketch_id": self._current_sketch.id if self._current_sketch else None,
"selected_body_id": self._selected_body.id if self._selected_body else None,
"camera_eye": _flat3(eye),
"camera_at": _flat3(at_),
"camera_up": _flat3(up),
"panel_focus": getattr(self, "_panel_focus", "equal"),
"assembly_view_active": bool(self._assembly_view_active),
"selected_assembly_component_id": self._selected_assembly_component_id,
}
def _restore_view_state(self, view_state: Dict[str, Any]) -> None:
"""Apply a saved view_state dict to the camera + UI selection."""
if not view_state:
return
try:
eye = view_state.get("camera_eye")
at_ = view_state.get("camera_at")
up = view_state.get("camera_up")
if eye and at_ and up:
self._viewer_3d.set_camera_position(
(float(eye[0]), float(eye[1]), float(eye[2])),
(float(at_[0]), float(at_[1]), float(at_[2])),
up=(float(up[0]), float(up[1]), float(up[2])),
)
except Exception as exc:
logger.debug("Failed to restore camera: %s", exc)
# Active tab.
try:
tab_idx = int(view_state.get("active_tab", 0))
if hasattr(self, "_input_tabs"):
self._input_tabs.setCurrentIndex(max(0, tab_idx))
except Exception:
pass
# Panel focus.
try:
focus = view_state.get("panel_focus")
if focus in ("equal", "sketch", "viewer"):
self._set_panel_focus(focus)
except Exception:
pass
def _confirm_discard_changes(self) -> bool:
"""Return True if it's safe to discard the current project.
Pops a Save / Discard / Cancel dialog when the project is dirty.
Returns True (= proceed with discard) for the Save and Discard
choices; False for Cancel. When the project is clean, returns
True immediately so the call site doesn't have to special-case it.
"""
if not self._dirty:
return True
box = QMessageBox(self)
box.setIcon(QMessageBox.Warning)
box.setWindowTitle("Unsaved Changes")
box.setText("This project has unsaved changes.")
box.setInformativeText("Save before continuing?")
box.setStandardButtons(
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
)
box.setDefaultButton(QMessageBox.Save)
choice = box.exec()
if choice == QMessageBox.Cancel:
return False
if choice == QMessageBox.Save:
return self._save_project()
return True # Discard
def _save_project(self) -> bool:
"""Save the current project. Returns True on success."""
if not self._project_path:
return self._save_project_as()
return self._write_project_to_disk(self._project_path)
def _save_project_as(self) -> bool:
"""Prompt for a path and save. Returns True on success."""
# Default to the current file name so Save-As is one click away
# from a normal Save.
default = self._project_path or os.path.join(
os.path.expanduser("~"), "untitled.fluency"
)
path, _ = QFileDialog.getSaveFileName(
self,
"Save Project",
default,
"Fluency Project (*.fluency)",
)
if not path:
return False
path = project_zip_path(path)
return self._write_project_to_disk(path)
def _write_project_to_disk(self, path: str) -> bool:
"""Write the project to *path* and update internal state on success."""
try:
view_state = self._collect_view_state()
save_project(
self._project,
path,
view_state=view_state,
kernel=self._kernel,
)
self._project_path = path
self._project.file_path = path
self._dirty = False
self._update_window_title()
self._add_recent_project(path)
self.statusBar().showMessage(f"Saved: {os.path.basename(path)}", 5000)
logger.info("Saved project: %s", path)
return True
except Exception as exc:
QMessageBox.critical(
self, "Save Failed", f"Could not save the project:\n{exc}"
)
return False
def _open_project(self) -> bool:
"""Prompt for and open a ``.fluency`` file. Returns True on success."""
if not self._confirm_discard_changes():
return False
path, _ = QFileDialog.getOpenFileName(
self,
"Open Project",
os.path.expanduser("~"),
"Fluency Project (*.fluency);;All files (*)",
)
if not path:
return False
return self._open_project_file(path)
def _open_project_file(self, path: str) -> bool:
"""Load *path* into the running app. Returns True on success."""
try:
project, view_state = load_project(path)
except Exception as exc:
QMessageBox.critical(
self, "Open Failed", f"Could not open the project:\n{exc}"
)
return False
# Suppress dirty tracking while we replace the in-memory project
# and rebuild the UI. The loaded project starts clean until the
# user touches it again.
self._suspend_dirty = True
try:
# Replace the in-memory project + UI state. This is the same path
# that New Project would take, but populated with the loaded data.
self._project = project
# Reuse the running kernel so we keep the same OCC viewer context.
# The loaded body's STEP data has already been parsed by the new
# kernel inside load_project; we copy those bodies' references in
# via the dict already, but we still want the live ``_kernel`` in
# this window to match for new operations.
self._kernel = project.kernel
# Reset all UI state.
for btn in self._component_buttons:
btn.deleteLater()
self._component_buttons.clear()
for btn in self._assembly_component_buttons:
btn.deleteLater()
self._assembly_component_buttons.clear()
self._current_component = None
self._current_sketch = None
self._selected_body = None
self._selected_assembly_component_id = None
self._assembly_view_active = False
self._sketch_widget.clear_source_face()
self._sketch_widget.set_sketch(None)
self._viewer_3d.clear_scene()
self._refresh_lists()
# Rebuild component buttons (one per component, numbered).
for idx, comp in enumerate(self._project.components.values(), start=1):
btn = QPushButton(str(idx))
btn.setCheckable(True)
btn.setFixedSize(QSize(40, 40))
btn.clicked.connect(self._on_component_button_clicked)
self._component_buttons.append(btn)
self._component_group.addButton(btn)
self._component_box_layout.addWidget(btn)
# Pick which component to activate: explicit saved selection,
# falling back to the project's active_component, then the first.
target_comp_id: Optional[str] = None
if view_state.get("active_component_id") in self._project.components:
target_comp_id = view_state["active_component_id"]
elif self._project.active_component in self._project.components:
target_comp_id = self._project.active_component
elif self._project.components:
target_comp_id = next(iter(self._project.components.keys()))
if target_comp_id is not None:
self._current_component = self._project.components[target_comp_id]
idx = list(self._project.components.keys()).index(target_comp_id)
if 0 <= idx < len(self._component_buttons):
for b in self._component_buttons:
b.setChecked(False)
self._component_buttons[idx].setChecked(True)
# Rebuild assembly component buttons (one per assembly instance).
for assembly in self._project.assemblies.values():
for ac_id, ac in assembly.components.items():
instance_num = len(self._assembly_component_buttons) + 1
btn = QPushButton(str(instance_num))
btn.setCheckable(True)
btn.setFixedSize(QSize(40, 40))
btn.setToolTip(f"{ac.name} (instance {instance_num})")
btn._assembly_component_id = ac.id
btn.clicked.connect(self._on_assembly_component_clicked)
self._assembly_component_buttons.append(btn)
self._assembly_component_group.addButton(btn)
self._assembly_box_layout.addWidget(btn)
# Restore the active assembly component selection.
if assembly.active_assembly_component and assembly.active_assembly_component in assembly.components:
for b in self._assembly_component_buttons:
if getattr(b, '_assembly_component_id', None) == assembly.active_assembly_component:
b.setChecked(True)
self._selected_assembly_component_id = assembly.active_assembly_component
break
# If the saved view says we're in assembly view, switch over.
if view_state.get("assembly_view_active") and self._project.assemblies:
self._assembly_view_active = True
self._show_assembly_in_viewer(fit=True)
else:
self._assembly_view_active = False
self._redraw_bodies()
# Restore camera + active tab.
self._restore_view_state(view_state)
self._refresh_lists()
# Try to activate the saved sketch (without re-rendering the
# underlay from a now-stale source face — we don't persist those).
target_sk_id = view_state.get("active_sketch_id")
if (
target_sk_id
and self._current_component
and target_sk_id in self._current_component.sketches
):
sk = self._current_component.sketches[target_sk_id]
if sk.occ_sketch is not None:
self._sketch_widget.set_sketch(sk.occ_sketch)
self._current_sketch = sk
finally:
self._suspend_dirty = False
# Clear dirty + update title.
self._project_path = path
self._dirty = False
self._update_window_title()
self._add_recent_project(path)
self.statusBar().showMessage(f"Opened: {os.path.basename(path)}", 5000)
logger.info("Opened project: %s", path)
return True
def closeEvent(self, event) -> None:
"""Prompt to save on window close if there are unsaved changes."""
if not self._confirm_discard_changes():
event.ignore()
return
event.accept()
def _import_file(self):
filepath, _ = QFileDialog.getOpenFileName(
self, "Import File", "", "STEP Files (*.step *.stp);;IGES Files (*.iges *.igs)"
)
if filepath:
try:
if filepath.lower().endswith((".step", ".stp")):
geometry = self._kernel.import_step(filepath)
else:
geometry = self._kernel.import_iges(filepath)
if not self._current_component:
self._current_component = self._project.add_component()
body = self._current_component.add_body(
Body(name="Imported", geometry=geometry, source_operation="import")
)
self._mark_dirty()
vertices, faces = body.get_mesh(self._kernel)
body.render_object = self._viewer_3d.add_mesh(
vertices, faces, body.color, body.name
)
self._refresh_lists()
self._viewer_3d.fit_camera()
logger.info(f"Imported: {filepath}")
except Exception as e:
QMessageBox.critical(self, "Error", f"Failed to import: {e}")
def _export_step(self):
if not self._selected_body:
QMessageBox.warning(self, "No Selection", "Please select a body")
return
filepath, _ = QFileDialog.getSaveFileName(
self, "Export STEP", "", "STEP Files (*.step *.stp)"
)
if filepath:
if self._kernel.export_step(self._selected_body.geometry, filepath):
logger.info(f"Exported: {filepath}")
else:
QMessageBox.warning(self, "Export Failed", "Failed to export STEP")
def _export_iges(self):
if not self._selected_body:
QMessageBox.warning(self, "No Selection", "Please select a body")
return
filepath, _ = QFileDialog.getSaveFileName(
self, "Export IGES", "", "IGES Files (*.iges *.igs)"
)
if filepath:
if self._kernel.export_iges(self._selected_body.geometry, filepath):
logger.info(f"Exported: {filepath}")
else:
QMessageBox.warning(self, "Export Failed", "Failed to export IGES")
def _export_stl(self):
if not self._selected_body:
QMessageBox.warning(self, "No Selection", "Please select a body")
return
filepath, _ = QFileDialog.getSaveFileName(self, "Export STL", "", "STL Files (*.stl)")
if filepath:
if self._kernel.export_stl(self._selected_body.geometry, filepath):
logger.info(f"Exported: {filepath}")
else:
QMessageBox.warning(self, "Export Failed", "Failed to export STL")
def _fit_view(self):
self._viewer_3d.fit_camera()
def _reset_view(self):
self._viewer_3d.set_camera_position((100, 100, 100), (0, 0, 0))
def _show_about(self):
QMessageBox.about(
self,
"About Fluency CAD",
"Fluency CAD 2.0\n\n"
"A parametric CAD application built on:\n"
"- OpenCASCADE Technology (OCCT)\n"
"- CadQuery Python bindings\n"
"- pygfx WebGPU renderer\n\n"
"Features:\n"
"- STEP/IGES import/export\n"
"- Parametric sketching\n"
"- Boolean operations\n"
"- Fillets and chamfers\n"
"- Component timeline",
)