feat: Replace SDF kernel with OpenCASCADE, VTK with pygfx

Major architecture migration: - Remove SDF-based geometry kernel (sdf/) - Remove VTK renderer (drawing_modules/) - Remove old mesh modules (mesh_modules/) New components: - geometry/base.py: Abstract geometry kernel interface - geometry_occ/kernel.py: OpenCASCADE implementation via CadQuery/OCP - geometry_occ/sketch.py: 2D sketching with constraint solving - rendering/base.py: Abstract renderer interface - rendering/pygfx_renderer.py: WebGPU-based renderer - models/data_model.py: Project, Component, Sketch, Body classes - main.py: New Qt-based application Features: - STEP/IGES import/export - Exact BRep geometry (vs approximate SDF mesh) - Parametric sketching with constraints - Boolean operations (union, difference, intersection) - Fillet and chamfer operations - Modern pygfx renderer (~30MB vs VTK ~200MB) Dependencies: - cadquery >= 2.4 - ocp >= 7.9.3 - pygfx >= 0.7.0 - wgpu >= 0.19.0 - PySide6 >= 6.9.0
2026-03-14 08:45:07 +01:00
parent d6044e551a
commit fe23ca610c
90 changed files with 3737 additions and 14523 deletions
@@ -0,0 +1,553 @@
+"""
+Fluency CAD - Main Application
+
+A parametric CAD application built on OpenCASCADE Technology (OCCT)
+with a modern pygfx-based 3D renderer.
+"""
+
+import sys
+from typing import Optional, List
+from PySide6.QtWidgets import (
+    QApplication,
+    QMainWindow,
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QToolBar,
+    QStatusBar,
+    QFileDialog,
+    QMessageBox,
+    QDockWidget,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QLabel,
+    QDoubleSpinBox,
+    QComboBox,
+    QPushButton,
+    QGroupBox,
+)
+from PySide6.QtCore import Qt, Signal, Slot
+from PySide6.QtGui import QAction, QIcon, QKeySequence
+
+from fluency.geometry_occ.kernel import OCGeometryKernel
+from fluency.geometry_occ.sketch import OCCSketch
+from fluency.rendering.pygfx_renderer import PygfxRenderer
+from fluency.models.data_model import Project, Component, Sketch, Body
+
+
+class SketchWidget(QWidget):
+    """2D sketching widget."""
+
+    sketch_changed = Signal()
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self._sketch: Optional[OCCSketch] = None
+        self._mode: str = "select"
+        self._points: List = []
+        self._setup_ui()
+
+    def _setup_ui(self) -> None:
+        layout = QVBoxLayout(self)
+
+        toolbar = QToolBar()
+        toolbar.addAction("Select", lambda: self._set_mode("select"))
+        toolbar.addAction("Line", lambda: self._set_mode("line"))
+        toolbar.addAction("Rectangle", lambda: self._set_mode("rectangle"))
+        toolbar.addAction("Circle", lambda: self._set_mode("circle"))
+        toolbar.addSeparator()
+        toolbar.addAction("Coincident", self._add_coincident_constraint)
+        toolbar.addAction("Horizontal", self._add_horizontal_constraint)
+        toolbar.addAction("Vertical", self._add_vertical_constraint)
+        toolbar.addAction("Distance", self._add_distance_constraint)
+
+        layout.addWidget(toolbar)
+
+        self._canvas = QLabel("Sketch Canvas (Click to draw)")
+        self._canvas.setMinimumSize(400, 300)
+        self._canvas.setStyleSheet("background-color: #1a1a2e; color: white;")
+        self._canvas.setAlignment(Qt.AlignCenter)
+
+        layout.addWidget(self._canvas)
+
+    def _set_mode(self, mode: str) -> None:
+        self._mode = mode
+        self._canvas.setText(f"Mode: {mode.upper()}")
+
+    def _add_coincident_constraint(self) -> None:
+        pass
+
+    def _add_horizontal_constraint(self) -> None:
+        pass
+
+    def _add_vertical_constraint(self) -> None:
+        pass
+
+    def _add_distance_constraint(self) -> None:
+        pass
+
+    def set_sketch(self, sketch: Optional[OCCSketch]) -> None:
+        self._sketch = sketch
+
+    def get_sketch(self) -> Optional[OCCSketch]:
+        return self._sketch
+
+
+class PropertiesWidget(QWidget):
+    """Properties panel widget."""
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self._setup_ui()
+
+    def _setup_ui(self) -> None:
+        layout = QVBoxLayout(self)
+
+        extrude_group = QGroupBox("Extrude")
+        extrude_layout = QVBoxLayout(extrude_group)
+
+        height_layout = QHBoxLayout()
+        height_layout.addWidget(QLabel("Height:"))
+        self._height_spin = QDoubleSpinBox()
+        self._height_spin.setRange(-10000, 10000)
+        self._height_spin.setValue(10)
+        height_layout.addWidget(self._height_spin)
+        extrude_layout.addLayout(height_layout)
+
+        self._extrude_btn = QPushButton("Extrude")
+        extrude_layout.addWidget(self._extrude_btn)
+
+        layout.addWidget(extrude_group)
+
+        fillet_group = QGroupBox("Fillet")
+        fillet_layout = QVBoxLayout(fillet_group)
+
+        radius_layout = QHBoxLayout()
+        radius_layout.addWidget(QLabel("Radius:"))
+        self._fillet_spin = QDoubleSpinBox()
+        self._fillet_spin.setRange(0.01, 1000)
+        self._fillet_spin.setValue(1)
+        radius_layout.addWidget(self._fillet_spin)
+        fillet_layout.addLayout(radius_layout)
+
+        self._fillet_btn = QPushButton("Apply Fillet")
+        fillet_layout.addWidget(self._fillet_btn)
+
+        layout.addWidget(fillet_group)
+
+        layout.addStretch()
+
+    def get_extrude_height(self) -> float:
+        return self._height_spin.value()
+
+    def get_fillet_radius(self) -> float:
+        return self._fillet_spin.value()
+
+
+class BrowserWidget(QWidget):
+    """Feature browser tree widget."""
+
+    item_selected = Signal(str, str)
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self._setup_ui()
+
+    def _setup_ui(self) -> None:
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self._tree = QTreeWidget()
+        self._tree.setHeaderLabel("Features")
+        self._tree.itemClicked.connect(self._on_item_clicked)
+
+        layout.addWidget(self._tree)
+
+    def _on_item_clicked(self, item: QTreeWidgetItem, column: int) -> None:
+        data = item.data(0, Qt.UserRole)
+        if data:
+            item_type, item_id = data.split(":")
+            self.item_selected.emit(item_type, item_id)
+
+    def update_from_project(self, project: Project) -> None:
+        self._tree.clear()
+
+        for comp_id, comp in project.components.items():
+            comp_item = QTreeWidgetItem([comp.name])
+            comp_item.setData(0, Qt.UserRole, f"component:{comp_id}")
+            self._tree.addTopLevelItem(comp_item)
+
+            sketches_item = QTreeWidgetItem(["Sketches"])
+            comp_item.addChild(sketches_item)
+
+            for sketch_id, sketch in comp.sketches.items():
+                sketch_item = QTreeWidgetItem([sketch.name])
+                sketch_item.setData(0, Qt.UserRole, f"sketch:{sketch_id}")
+                sketches_item.addChild(sketch_item)
+
+            bodies_item = QTreeWidgetItem(["Bodies"])
+            comp_item.addChild(bodies_item)
+
+            for body_id, body in comp.bodies.items():
+                body_item = QTreeWidgetItem([body.name])
+                body_item.setData(0, Qt.UserRole, f"body:{body_id}")
+                bodies_item.addChild(body_item)
+
+            comp_item.setExpanded(True)
+
+
+class MainWindow(QMainWindow):
+    """Main application window."""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._project = Project()
+        self._kernel = OCGeometryKernel()
+        self._renderer = PygfxRenderer()
+
+        self._current_sketch: Optional[Sketch] = None
+        self._selected_body: Optional[Body] = None
+
+        self._setup_ui()
+        self._setup_connections()
+        self._create_initial_component()
+
+    def _setup_ui(self) -> None:
+        self.setWindowTitle("Fluency CAD 2.0")
+        self.setMinimumSize(1200, 800)
+
+        self._create_menus()
+        self._create_toolbars()
+        self._create_dock_widgets()
+        self._create_central_widget()
+
+        self.statusBar().showMessage("Ready")
+
+    def _create_menus(self) -> None:
+        menubar = self.menuBar()
+
+        file_menu = menubar.addMenu("&File")
+
+        new_action = QAction("&New Project", self)
+        new_action.setShortcut(QKeySequence.New)
+        new_action.triggered.connect(self._new_project)
+        file_menu.addAction(new_action)
+
+        open_action = QAction("&Open...", self)
+        open_action.setShortcut(QKeySequence.Open)
+        open_action.triggered.connect(self._open_project)
+        file_menu.addAction(open_action)
+
+        file_menu.addSeparator()
+
+        export_step = QAction("Export &STEP...", self)
+        export_step.triggered.connect(self._export_step)
+        file_menu.addAction(export_step)
+
+        export_iges = QAction("Export &IGES...", self)
+        export_iges.triggered.connect(self._export_iges)
+        file_menu.addAction(export_iges)
+
+        export_stl = QAction("Export S&TL...", self)
+        export_stl.triggered.connect(self._export_stl)
+        file_menu.addAction(export_stl)
+
+        file_menu.addSeparator()
+
+        exit_action = QAction("E&xit", self)
+        exit_action.setShortcut(QKeySequence.Quit)
+        exit_action.triggered.connect(self.close)
+        file_menu.addAction(exit_action)
+
+        edit_menu = menubar.addMenu("&Edit")
+        edit_menu.addAction("Undo")
+        edit_menu.addAction("Redo")
+        edit_menu.addSeparator()
+        edit_menu.addAction("Delete")
+
+        view_menu = menubar.addMenu("&View")
+        view_menu.addAction("Fit All", self._fit_view)
+        view_menu.addAction("Reset View", self._reset_view)
+        view_menu.addSeparator()
+
+        iso_view = QAction("Isometric", self)
+        iso_view.triggered.connect(lambda: self._set_view("iso"))
+        view_menu.addAction(iso_view)
+
+        top_view = QAction("Top", self)
+        top_view.triggered.connect(lambda: self._set_view("top"))
+        view_menu.addAction(top_view)
+
+        front_view = QAction("Front", self)
+        front_view.triggered.connect(lambda: self._set_view("front"))
+        view_menu.addAction(front_view)
+
+        right_view = QAction("Right", self)
+        right_view.triggered.connect(lambda: self._set_view("right"))
+        view_menu.addAction(right_view)
+
+        help_menu = menubar.addMenu("&Help")
+        help_menu.addAction("About", self._show_about)
+
+    def _create_toolbars(self) -> None:
+        toolbar = self.addToolBar("Main")
+        toolbar.addAction("New Sketch", self._new_sketch)
+        toolbar.addSeparator()
+        toolbar.addAction("Extrude", self._extrude_sketch)
+        toolbar.addAction("Revolve", self._revolve_sketch)
+        toolbar.addSeparator()
+        toolbar.addAction("Union", self._boolean_union)
+        toolbar.addAction("Subtract", self._boolean_subtract)
+        toolbar.addAction("Intersect", self._boolean_intersect)
+        toolbar.addSeparator()
+        toolbar.addAction("Fillet", self._apply_fillet)
+        toolbar.addAction("Chamfer", self._apply_chamfer)
+
+    def _create_dock_widgets(self) -> None:
+        browser_dock = QDockWidget("Browser", self)
+        self._browser = BrowserWidget()
+        browser_dock.setWidget(self._browser)
+        self.addDockWidget(Qt.LeftDockWidgetArea, browser_dock)
+
+        properties_dock = QDockWidget("Properties", self)
+        self._properties = PropertiesWidget()
+        properties_dock.setWidget(self._properties)
+        self.addDockWidget(Qt.RightDockWidgetArea, properties_dock)
+
+    def _create_central_widget(self) -> None:
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self._view_container = QWidget()
+        self._renderer.initialize(self._view_container)
+        layout.addWidget(self._view_container)
+
+        self.setCentralWidget(central)
+
+    def _setup_connections(self) -> None:
+        self._properties._extrude_btn.clicked.connect(self._extrude_sketch)
+        self._properties._fillet_btn.clicked.connect(self._apply_fillet)
+        self._browser.item_selected.connect(self._on_item_selected)
+
+    def _create_initial_component(self) -> None:
+        comp = self._project.add_component()
+        self._browser.update_from_project(self._project)
+
+    def _new_project(self) -> None:
+        self._project = Project()
+        self._create_initial_component()
+        self._renderer.clear_scene()
+        self._renderer.render()
+        self.statusBar().showMessage("New project created")
+
+    def _open_project(self) -> None:
+        filepath, _ = QFileDialog.getOpenFileName(
+            self, "Open Project", "", "STEP Files (*.step *.stp)"
+        )
+        if filepath:
+            try:
+                geometry = self._kernel.import_step(filepath)
+                comp = self._project.add_component()
+                body = comp.add_body(Body(name="Imported", geometry=geometry))
+                self._render_body(body)
+                self._browser.update_from_project(self._project)
+                self.statusBar().showMessage(f"Opened: {filepath}")
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Failed to open file: {e}")
+
+    def _export_step(self) -> None:
+        filepath, _ = QFileDialog.getSaveFileName(
+            self, "Export STEP", "", "STEP Files (*.step *.stp)"
+        )
+        if filepath:
+            if self._project.export_step(filepath):
+                self.statusBar().showMessage(f"Exported: {filepath}")
+            else:
+                QMessageBox.warning(self, "Export Failed", "No bodies to export")
+
+    def _export_iges(self) -> None:
+        filepath, _ = QFileDialog.getSaveFileName(
+            self, "Export IGES", "", "IGES Files (*.iges *.igs)"
+        )
+        if filepath:
+            if self._project.export_iges(filepath):
+                self.statusBar().showMessage(f"Exported: {filepath}")
+            else:
+                QMessageBox.warning(self, "Export Failed", "No bodies to export")
+
+    def _export_stl(self) -> None:
+        filepath, _ = QFileDialog.getSaveFileName(self, "Export STL", "", "STL Files (*.stl)")
+        if filepath:
+            if self._project.export_stl(filepath):
+                self.statusBar().showMessage(f"Exported: {filepath}")
+            else:
+                QMessageBox.warning(self, "Export Failed", "No bodies to export")
+
+    def _new_sketch(self) -> None:
+        comp = self._project.get_active_component()
+        if comp:
+            sketch = comp.add_sketch()
+            self._current_sketch = sketch
+            self._browser.update_from_project(self._project)
+            self.statusBar().showMessage(f"Created: {sketch.name}")
+
+    def _extrude_sketch(self) -> None:
+        comp = self._project.get_active_component()
+        if not comp:
+            return
+
+        sketch = comp.get_active_sketch()
+        if not sketch:
+            sketch = self._current_sketch
+
+        if not sketch or not sketch.occ_sketch:
+            QMessageBox.warning(self, "No Sketch", "Please create a sketch first")
+            return
+
+        sketch.solve()
+        geometry = sketch.get_geometry()
+
+        if not geometry:
+            QMessageBox.warning(self, "No Geometry", "Sketch has no valid geometry")
+            return
+
+        height = self._properties.get_extrude_height()
+
+        try:
+            body_geometry = self._kernel.extrude(geometry, height)
+
+            body = comp.add_body(
+                Body(
+                    name=f"Extrusion {len(comp.bodies) + 1}",
+                    geometry=body_geometry,
+                    source_sketch=sketch,
+                    source_operation="extrude",
+                )
+            )
+
+            self._render_body(body)
+            self._browser.update_from_project(self._project)
+            self.statusBar().showMessage(f"Extruded: {body.name}")
+
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Extrude failed: {e}")
+
+    def _revolve_sketch(self) -> None:
+        self.statusBar().showMessage("Revolve not yet implemented")
+
+    def _boolean_union(self) -> None:
+        self.statusBar().showMessage("Boolean union not yet implemented")
+
+    def _boolean_subtract(self) -> None:
+        self.statusBar().showMessage("Boolean subtract not yet implemented")
+
+    def _boolean_intersect(self) -> None:
+        self.statusBar().showMessage("Boolean intersect not yet implemented")
+
+    def _apply_fillet(self) -> None:
+        if not self._selected_body:
+            QMessageBox.warning(self, "No Selection", "Please select a body")
+            return
+
+        radius = self._properties.get_fillet_radius()
+
+        try:
+            self._selected_body.geometry = self._kernel.fillet(self._selected_body.geometry, radius)
+            self._render_body(self._selected_body)
+            self.statusBar().showMessage(f"Applied fillet: {radius}")
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Fillet failed: {e}")
+
+    def _apply_chamfer(self) -> None:
+        if not self._selected_body:
+            QMessageBox.warning(self, "No Selection", "Please select a body")
+            return
+
+        size = self._properties.get_fillet_radius()
+
+        try:
+            self._selected_body.geometry = self._kernel.chamfer(self._selected_body.geometry, size)
+            self._render_body(self._selected_body)
+            self.statusBar().showMessage(f"Applied chamfer: {size}")
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Chamfer failed: {e}")
+
+    def _render_body(self, body: Body) -> None:
+        if not body.geometry:
+            return
+
+        vertices, faces = body.get_mesh(self._kernel)
+
+        if body.render_object:
+            self._renderer.update_mesh(body.render_object, vertices, faces)
+        else:
+            body.render_object = self._renderer.add_mesh(vertices, faces, body.color, body.name)
+
+        self._renderer.fit_camera()
+        self._renderer.render()
+
+    def _fit_view(self) -> None:
+        self._renderer.fit_camera()
+        self._renderer.render()
+
+    def _reset_view(self) -> None:
+        self._renderer.set_camera_position((100, 100, 100), (0, 0, 0))
+        self._renderer.render()
+
+    def _set_view(self, view: str) -> None:
+        positions = {
+            "iso": ((100, 100, 100), (0, 0, 0)),
+            "top": ((0, 0, 200), (0, 0, 0)),
+            "front": ((0, -200, 0), (0, 0, 0)),
+            "right": ((200, 0, 0), (0, 0, 0)),
+        }
+        if view in positions:
+            pos, target = positions[view]
+            self._renderer.set_camera_position(pos, target)
+            self._renderer.render()
+
+    def _on_item_selected(self, item_type: str, item_id: str) -> None:
+        if item_type == "body":
+            comp = self._project.get_active_component()
+            if comp and item_id in comp.bodies:
+                self._selected_body = comp.bodies[item_id]
+                self.statusBar().showMessage(f"Selected: {self._selected_body.name}")
+        elif item_type == "sketch":
+            comp = self._project.get_active_component()
+            if comp and item_id in comp.sketches:
+                self._current_sketch = comp.sketches[item_id]
+                comp.set_active_sketch(item_id)
+                self.statusBar().showMessage(f"Selected: {self._current_sketch.name}")
+
+    def _show_about(self) -> None:
+        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",
+        )
+
+
+def main() -> int:
+    """Application entry point."""
+    app = QApplication(sys.argv)
+    app.setStyle("Fusion")
+
+    window = MainWindow()
+    window.show()
+
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())