- Assembly instaiated operations

- assembly forward proagation

.gitignore

@@ -1,3 +1,76 @@
 *.xml
 *.iml
-.idea
+.idea
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Lock files
+uv.lock
+
+# IDE
+.vscode/
+*.swp
+*.swo
+/src/fluency/Tesfiles/bordo_adapter3.fluency
+/CONSTRAINT_STATUS_FINAL.md
+/CONSTRAINT_STATUS_IMPLEMENTATION.md
+/src/fluency/rendering/first.png
+/littlebrother.md
+/src/fluency/Tesfiles/multiboidy.fluency
+/src/fluency/rendering/nromal_test.png
+/package.json
+/package-lock.json
+/src/fluency/Screenshot 2026-06-28 at 17.57.52.png
+/src/fluency/rendering/Screenshot 2026-07-12 at 16.54.14.png
+/src/fluency/Screenshot 2026-07-26 at 20.23.42.png
+/Screenshot 2026-08-05 at 10.14.15.png
+/Screenshot 2026-08-05 at 11.15.33.png
+/Screenshot 2026-08-05 at 11.22.42.png
+/SURFACE_MODIFIER_PLAN.md
+/test.step
+/src/fluency/test333.step
+/src/fluency/tests/test_arc_attached_to_rectangle.py
+/src/fluency/tests/test_array_pattern.py
+/src/fluency/tests/test_chamfer.py
+/src/fluency/tests/test_circle_diameter_constraint.py
+/tests/test_distance_constraint_picking.py
+/tests/test_extrude_geometry.py
+/src/fluency/tests/test_feature_replay.py
+/src/fluency/tests/test_fillet.py
+/tests/test_mirror.py
+/test_modifier.py
+/src/fluency/tests/test_projection_constraints.py
+/tests/test_re_extrude.py
+/scripts/test_render_zoom.py
+/test_thread.py
+/test_thread_hole.step
+/test_thread_m3.step
+/test_thread_m5_hole.step
+/test_thread_shaft.step
+/test_thread_tilted.step
+/src/fluency/testpart.step

.idea/fluency.iml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/sdfcad" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/.venv" />
-    </content>
-    <orderEntry type="jdk" jdkName="Python 3.12 (fluency)" jdkType="Python SDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/fluency.iml" filepath="$PROJECT_DIR$/.idea/fluency.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/fluency-cad.iml" filepath="$PROJECT_DIR$/.idea/fluency-cad.iml" />
     </modules>
   </component>
 </project>

.idea/workspace.xml

@@ -4,11 +4,17 @@
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="8f0bafd6-58a0-4b20-aa2b-ddc3ba278873" name="Changes" comment="- added sdf folder ( doesnt work via pip or git=)">
+    <list default="true" id="8f0bafd6-58a0-4b20-aa2b-ddc3ba278873" name="Changes" comment="Fiexed highlighting of operations">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/drawing_modules/draw_widget_solve.py" beforeDir="false" afterPath="$PROJECT_DIR$/drawing_modules/draw_widget_solve.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/main.py" beforeDir="false" afterPath="$PROJECT_DIR$/main.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/mesh_modules/interactor_mesh.py" beforeDir="false" afterPath="$PROJECT_DIR$/mesh_modules/interactor_mesh.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/geometry_occ/sketch.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/geometry_occ/sketch.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/io/project_io.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/io/project_io.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/models/data_model.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/models/data_model.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/rendering/occ_renderer.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/rendering/occ_renderer.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/ui/main_window.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/ui/main_window.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/ui/render_window.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/ui/render_window.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/ui/sketch_widget.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/ui/sketch_widget.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/ui/technical_drawing_widget.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/ui/technical_drawing_widget.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/ui/viewer_widget.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/ui/viewer_widget.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -25,7 +31,7 @@
   <component name="Git.Settings">
     <option name="RECENT_BRANCH_BY_REPOSITORY">
       <map>
-        <entry key="$PROJECT_DIR$" value="structure" />
+        <entry key="$PROJECT_DIR$" value="feature/surface-modifier-pyramid-patterns" />
       </map>
     </option>
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
@@ -45,30 +51,48 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "Python.2dtest.executor": "Run",
-    "Python.3d_windows.executor": "Run",
-    "Python.Unnamed.executor": "Run",
-    "Python.draw_widget2d.executor": "Run",
-    "Python.draw_widget_solve.executor": "Run",
-    "Python.fluency.executor": "Run",
-    "Python.fluencyb.executor": "Run",
-    "Python.gl_widget.executor": "Run",
-    "Python.main.executor": "Run",
-    "Python.meshtest.executor": "Run",
-    "Python.side_fluency.executor": "Run",
-    "Python.simple_mesh.executor": "Run",
-    "Python.vtk_widget.executor": "Run",
-    "Python.vulkan.executor": "Run",
-    "RunOnceActivity.OpenProjectViewOnStart": "true",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "RunOnceActivity.git.unshallow": "true",
-    "git-widget-placeholder": "master",
-    "last_opened_file_path": "/Volumes/Data_drive/Programming/fluency",
-    "settings.editor.selected.configurable": "project.propVCSSupport.DirectoryMappings"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;Python.2dtest.executor&quot;: &quot;Run&quot;,
+    &quot;Python.3d_windows.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Unnamed.executor&quot;: &quot;Run&quot;,
+    &quot;Python.base.executor&quot;: &quot;Run&quot;,
+    &quot;Python.data_model.executor&quot;: &quot;Run&quot;,
+    &quot;Python.debug_dragging.executor&quot;: &quot;Run&quot;,
+    &quot;Python.draw_widget2d.executor&quot;: &quot;Run&quot;,
+    &quot;Python.draw_widget_solve.executor&quot;: &quot;Run&quot;,
+    &quot;Python.fluency.executor&quot;: &quot;Run&quot;,
+    &quot;Python.fluencyb.executor&quot;: &quot;Run&quot;,
+    &quot;Python.gl_widget.executor&quot;: &quot;Run&quot;,
+    &quot;Python.gui_ui.executor&quot;: &quot;Run&quot;,
+    &quot;Python.kernel.executor&quot;: &quot;Run&quot;,
+    &quot;Python.main.executor&quot;: &quot;Run&quot;,
+    &quot;Python.main_window.executor&quot;: &quot;Run&quot;,
+    &quot;Python.meshtest.executor&quot;: &quot;Run&quot;,
+    &quot;Python.occ_renderer.executor&quot;: &quot;Run&quot;,
+    &quot;Python.occ_to_mesh.executor&quot;: &quot;Run&quot;,
+    &quot;Python.render_backend.executor&quot;: &quot;Run&quot;,
+    &quot;Python.side_fluency.executor&quot;: &quot;Run&quot;,
+    &quot;Python.simple_mesh.executor&quot;: &quot;Run&quot;,
+    &quot;Python.sketch.executor&quot;: &quot;Run&quot;,
+    &quot;Python.technical_drawing_widget.executor&quot;: &quot;Run&quot;,
+    &quot;Python.vtk_widget.executor&quot;: &quot;Run&quot;,
+    &quot;Python.vulkan.executor&quot;: &quot;Run&quot;,
+    &quot;RunOnceActivity.OpenProjectViewOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.TerminalTabsStorage.copyFrom.TerminalArrangementManager.252&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.typescript.service.memoryLimit.init&quot;: &quot;true&quot;,
+    &quot;codeWithMe.voiceChat.enabledByDefault&quot;: &quot;false&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;feature/occ-migration&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/Volumes/Data_drive/Programming/fluency/src/fluency&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;project.propVCSSupport.DirectoryMappings&quot;
   }
-}]]></component>
+}</component>
   <component name="QodanaReportsService">
     <option name="descriptions">
       <ReportDescription localRun="true" path="/private/var/folders/kg/zm48w_r96yb68mlbzvb9gtq40000gn/T/qodana_output/qodana.sarif.json" reportGuid="5f5b823c-c594-48c5-ae1f-062e30303918" reportId="fluency/qodana/2024-02-04" />
@@ -76,9 +100,11 @@
   </component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/fluency" />
       <recent name="$PROJECT_DIR$" />
+      <recent name="$PROJECT_DIR$/src/fluency/Tesfiles" />
+      <recent name="$PROJECT_DIR$/src/fluency/rendering" />
       <recent name="$PROJECT_DIR$/drawing_modules" />
-      <recent name="$PROJECT_DIR$/modules" />
     </key>
     <key name="MoveFile.RECENT_KEYS">
       <recent name="$PROJECT_DIR$" />
@@ -87,7 +113,7 @@
   <component name="SharedIndexes">
     <attachedChunks>
       <set>
-        <option value="bundled-python-sdk-4c141bd692a7-e2d783800521-com.jetbrains.pycharm.community.sharedIndexes.bundled-PC-251.26927.90" />
+        <option value="bundled-python-sdk-c59985aa861c-c2ffad84badb-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-261.24374.152" />
       </set>
     </attachedChunks>
   </component>
@@ -100,54 +126,6 @@
       <option name="presentableId" value="Default" />
       <updated>1703867682707</updated>
     </task>
-    <task id="LOCAL-00001" summary="init">
-      <option name="closed" value="true" />
-      <created>1703951701948</created>
-      <option name="number" value="00001" />
-      <option name="presentableId" value="LOCAL-00001" />
-      <option name="project" value="LOCAL" />
-      <updated>1703951701948</updated>
-    </task>
-    <task id="LOCAL-00002" summary="- Basic oop sketch widget implement">
-      <option name="closed" value="true" />
-      <created>1729958532384</created>
-      <option name="number" value="00002" />
-      <option name="presentableId" value="LOCAL-00002" />
-      <option name="project" value="LOCAL" />
-      <updated>1729958532384</updated>
-    </task>
-    <task id="LOCAL-00003" summary="- Sketch projection partly works again :)">
-      <option name="closed" value="true" />
-      <created>1735563255455</created>
-      <option name="number" value="00003" />
-      <option name="presentableId" value="LOCAL-00003" />
-      <option name="project" value="LOCAL" />
-      <updated>1735563255455</updated>
-    </task>
-    <task id="LOCAL-00004" summary="- Sketch projection partly works again :)">
-      <option name="closed" value="true" />
-      <created>1735585968733</created>
-      <option name="number" value="00004" />
-      <option name="presentableId" value="LOCAL-00004" />
-      <option name="project" value="LOCAL" />
-      <updated>1735585968733</updated>
-    </task>
-    <task id="LOCAL-00005" summary="- Added new componnt controls">
-      <option name="closed" value="true" />
-      <created>1735601610504</created>
-      <option name="number" value="00005" />
-      <option name="presentableId" value="LOCAL-00005" />
-      <option name="project" value="LOCAL" />
-      <updated>1735601610504</updated>
-    </task>
-    <task id="LOCAL-00006" summary="- Added new componnt controls">
-      <option name="closed" value="true" />
-      <created>1735601786207</created>
-      <option name="number" value="00006" />
-      <option name="presentableId" value="LOCAL-00006" />
-      <option name="project" value="LOCAL" />
-      <updated>1735601786207</updated>
-    </task>
     <task id="LOCAL-00007" summary="- changing compos for sketches works">
       <option name="closed" value="true" />
       <created>1735652081552</created>
@@ -252,9 +230,300 @@
       <option name="project" value="LOCAL" />
       <updated>1755369224187</updated>
     </task>
-    <option name="localTasksCounter" value="20" />
+    <task id="LOCAL-00020" summary="- Tons of addtions">
+      <option name="closed" value="true" />
+      <created>1782673954850</created>
+      <option name="number" value="00020" />
+      <option name="presentableId" value="LOCAL-00020" />
+      <option name="project" value="LOCAL" />
+      <updated>1782673954850</updated>
+    </task>
+    <task id="LOCAL-00021" summary="- Tons of addtions">
+      <option name="closed" value="true" />
+      <created>1782679912834</created>
+      <option name="number" value="00021" />
+      <option name="presentableId" value="LOCAL-00021" />
+      <option name="project" value="LOCAL" />
+      <updated>1782679912834</updated>
+    </task>
+    <task id="LOCAL-00022" summary="- Basic operations">
+      <option name="closed" value="true" />
+      <created>1782768610475</created>
+      <option name="number" value="00022" />
+      <option name="presentableId" value="LOCAL-00022" />
+      <option name="project" value="LOCAL" />
+      <updated>1782768610475</updated>
+    </task>
+    <task id="LOCAL-00023" summary="- removed cadquery deoendency">
+      <option name="closed" value="true" />
+      <created>1782928990792</created>
+      <option name="number" value="00023" />
+      <option name="presentableId" value="LOCAL-00023" />
+      <option name="project" value="LOCAL" />
+      <updated>1782928990792</updated>
+    </task>
+    <task id="LOCAL-00024" summary="- sketch enhacements">
+      <option name="closed" value="true" />
+      <created>1783108151675</created>
+      <option name="number" value="00024" />
+      <option name="presentableId" value="LOCAL-00024" />
+      <option name="project" value="LOCAL" />
+      <updated>1783108151676</updated>
+    </task>
+    <task id="LOCAL-00025" summary="- sketch enhacements">
+      <option name="closed" value="true" />
+      <created>1783159860774</created>
+      <option name="number" value="00025" />
+      <option name="presentableId" value="LOCAL-00025" />
+      <option name="project" value="LOCAL" />
+      <updated>1783159860774</updated>
+    </task>
+    <task id="LOCAL-00026" summary="- UI refinement, button position ui file as source no dirty drafting anymore">
+      <option name="closed" value="true" />
+      <created>1783174566362</created>
+      <option name="number" value="00026" />
+      <option name="presentableId" value="LOCAL-00026" />
+      <option name="project" value="LOCAL" />
+      <updated>1783174566362</updated>
+    </task>
+    <task id="LOCAL-00027" summary="- assembly draft">
+      <option name="closed" value="true" />
+      <created>1783239410744</created>
+      <option name="number" value="00027" />
+      <option name="presentableId" value="LOCAL-00027" />
+      <option name="project" value="LOCAL" />
+      <updated>1783239410744</updated>
+    </task>
+    <task id="LOCAL-00028" summary="- assembly draft">
+      <option name="closed" value="true" />
+      <created>1783272988957</created>
+      <option name="number" value="00028" />
+      <option name="presentableId" value="LOCAL-00028" />
+      <option name="project" value="LOCAL" />
+      <updated>1783272988957</updated>
+    </task>
+    <task id="LOCAL-00029" summary="- Added save file foramt&#10;- Split main.py refactor">
+      <option name="closed" value="true" />
+      <created>1783282570014</created>
+      <option name="number" value="00029" />
+      <option name="presentableId" value="LOCAL-00029" />
+      <option name="project" value="LOCAL" />
+      <updated>1783282570014</updated>
+    </task>
+    <task id="LOCAL-00030" summary="- Added save file foramt&#10;- Split main.py refactor">
+      <option name="closed" value="true" />
+      <created>1783453889199</created>
+      <option name="number" value="00030" />
+      <option name="presentableId" value="LOCAL-00030" />
+      <option name="project" value="LOCAL" />
+      <updated>1783453889199</updated>
+    </task>
+    <task id="LOCAL-00031" summary="- Added save file foramt&#10;- Split main.py refactor">
+      <option name="closed" value="true" />
+      <created>1783456842297</created>
+      <option name="number" value="00031" />
+      <option name="presentableId" value="LOCAL-00031" />
+      <option name="project" value="LOCAL" />
+      <updated>1783456842297</updated>
+    </task>
+    <task id="LOCAL-00032" summary="- Added save file foramt&#10;- Split main.py refactor">
+      <option name="closed" value="true" />
+      <created>1783755278516</created>
+      <option name="number" value="00032" />
+      <option name="presentableId" value="LOCAL-00032" />
+      <option name="project" value="LOCAL" />
+      <updated>1783755278516</updated>
+    </task>
+    <task id="LOCAL-00033" summary="- Added save file foramt&#10;- Split main.py refactor">
+      <option name="closed" value="true" />
+      <created>1783777171864</created>
+      <option name="number" value="00033" />
+      <option name="presentableId" value="LOCAL-00033" />
+      <option name="project" value="LOCAL" />
+      <updated>1783777171864</updated>
+    </task>
+    <task id="LOCAL-00034" summary="- Working assembly multi :)">
+      <option name="closed" value="true" />
+      <created>1783798201133</created>
+      <option name="number" value="00034" />
+      <option name="presentableId" value="LOCAL-00034" />
+      <option name="project" value="LOCAL" />
+      <updated>1783798201133</updated>
+    </task>
+    <task id="LOCAL-00035" summary="- Working assembly multi :)">
+      <option name="closed" value="true" />
+      <created>1783798929531</created>
+      <option name="number" value="00035" />
+      <option name="presentableId" value="LOCAL-00035" />
+      <option name="project" value="LOCAL" />
+      <updated>1783798929531</updated>
+    </task>
+    <task id="LOCAL-00036" summary="-  added renderer">
+      <option name="closed" value="true" />
+      <created>1783887682052</created>
+      <option name="number" value="00036" />
+      <option name="presentableId" value="LOCAL-00036" />
+      <option name="project" value="LOCAL" />
+      <updated>1783887682052</updated>
+    </task>
+    <task id="LOCAL-00037" summary="-  added renderer&#10;- Added undo">
+      <option name="closed" value="true" />
+      <created>1783887704766</created>
+      <option name="number" value="00037" />
+      <option name="presentableId" value="LOCAL-00037" />
+      <option name="project" value="LOCAL" />
+      <updated>1783887704766</updated>
+    </task>
+    <task id="LOCAL-00038" summary="-  added renderer&#10;- Added undo">
+      <option name="closed" value="true" />
+      <created>1783891561116</created>
+      <option name="number" value="00038" />
+      <option name="presentableId" value="LOCAL-00038" />
+      <option name="project" value="LOCAL" />
+      <updated>1783891561116</updated>
+    </task>
+    <task id="LOCAL-00039" summary="-  added renderer&#10;- Added undo">
+      <option name="closed" value="true" />
+      <created>1783918463034</created>
+      <option name="number" value="00039" />
+      <option name="presentableId" value="LOCAL-00039" />
+      <option name="project" value="LOCAL" />
+      <updated>1783918463034</updated>
+    </task>
+    <task id="LOCAL-00040" summary="- Render improvements, camera plane, update">
+      <option name="closed" value="true" />
+      <created>1783976498520</created>
+      <option name="number" value="00040" />
+      <option name="presentableId" value="LOCAL-00040" />
+      <option name="project" value="LOCAL" />
+      <updated>1783976498520</updated>
+    </task>
+    <task id="LOCAL-00041" summary="- added &quot;measurement lines&quot;">
+      <option name="closed" value="true" />
+      <created>1785094789247</created>
+      <option name="number" value="00041" />
+      <option name="presentableId" value="LOCAL-00041" />
+      <option name="project" value="LOCAL" />
+      <updated>1785094789248</updated>
+    </task>
+    <task id="LOCAL-00042" summary="- added &quot;measurement lines&quot;">
+      <option name="closed" value="true" />
+      <created>1785697123545</created>
+      <option name="number" value="00042" />
+      <option name="presentableId" value="LOCAL-00042" />
+      <option name="project" value="LOCAL" />
+      <updated>1785697123545</updated>
+    </task>
+    <task id="LOCAL-00043" summary="- arc improvements, fillets, operations, bodys">
+      <option name="closed" value="true" />
+      <created>1785701099363</created>
+      <option name="number" value="00043" />
+      <option name="presentableId" value="LOCAL-00043" />
+      <option name="project" value="LOCAL" />
+      <updated>1785701099363</updated>
+    </task>
+    <task id="LOCAL-00044" summary="- arc improvements, fillets, operations, bodys">
+      <option name="closed" value="true" />
+      <created>1785915859137</created>
+      <option name="number" value="00044" />
+      <option name="presentableId" value="LOCAL-00044" />
+      <option name="project" value="LOCAL" />
+      <updated>1785915859137</updated>
+    </task>
+    <task id="LOCAL-00045" summary="- arc improvements, fillets, operations, bodys">
+      <option name="closed" value="true" />
+      <created>1785941246695</created>
+      <option name="number" value="00045" />
+      <option name="presentableId" value="LOCAL-00045" />
+      <option name="project" value="LOCAL" />
+      <updated>1785941246695</updated>
+    </task>
+    <task id="LOCAL-00046" summary="- arc improvements, fillets, operations, bodys">
+      <option name="closed" value="true" />
+      <created>1785948828454</created>
+      <option name="number" value="00046" />
+      <option name="presentableId" value="LOCAL-00046" />
+      <option name="project" value="LOCAL" />
+      <updated>1785948828454</updated>
+    </task>
+    <task id="LOCAL-00047" summary="- arc improvements, fillets, operations, bodys">
+      <option name="closed" value="true" />
+      <created>1786110295218</created>
+      <option name="number" value="00047" />
+      <option name="presentableId" value="LOCAL-00047" />
+      <option name="project" value="LOCAL" />
+      <updated>1786110295218</updated>
+    </task>
+    <task id="LOCAL-00048" summary="- arc improvements, fillets, operations, bodys">
+      <option name="closed" value="true" />
+      <created>1786125317688</created>
+      <option name="number" value="00048" />
+      <option name="presentableId" value="LOCAL-00048" />
+      <option name="project" value="LOCAL" />
+      <updated>1786125317688</updated>
+    </task>
+    <task id="LOCAL-00049" summary="- Operation highlighting, body highlighting">
+      <option name="closed" value="true" />
+      <created>1786180549405</created>
+      <option name="number" value="00049" />
+      <option name="presentableId" value="LOCAL-00049" />
+      <option name="project" value="LOCAL" />
+      <updated>1786180549405</updated>
+    </task>
+    <task id="LOCAL-00050" summary="- tech draw draft">
+      <option name="closed" value="true" />
+      <created>1786888483687</created>
+      <option name="number" value="00050" />
+      <option name="presentableId" value="LOCAL-00050" />
+      <option name="project" value="LOCAL" />
+      <updated>1786888483688</updated>
+    </task>
+    <task id="LOCAL-00051" summary="- tech draw draft v2">
+      <option name="closed" value="true" />
+      <created>1786910497589</created>
+      <option name="number" value="00051" />
+      <option name="presentableId" value="LOCAL-00051" />
+      <option name="project" value="LOCAL" />
+      <updated>1786910497589</updated>
+    </task>
+    <task id="LOCAL-00052" summary="- tech draw draft v2">
+      <option name="closed" value="true" />
+      <created>1786984519780</created>
+      <option name="number" value="00052" />
+      <option name="presentableId" value="LOCAL-00052" />
+      <option name="project" value="LOCAL" />
+      <updated>1786984519781</updated>
+    </task>
+    <task id="LOCAL-00053" summary="- tech draw draft v2">
+      <option name="closed" value="true" />
+      <created>1786995561375</created>
+      <option name="number" value="00053" />
+      <option name="presentableId" value="LOCAL-00053" />
+      <option name="project" value="LOCAL" />
+      <updated>1786995561376</updated>
+    </task>
+    <task id="LOCAL-00054" summary="- tech drawing and render improv">
+      <option name="closed" value="true" />
+      <created>1787058413911</created>
+      <option name="number" value="00054" />
+      <option name="presentableId" value="LOCAL-00054" />
+      <option name="project" value="LOCAL" />
+      <updated>1787058413911</updated>
+    </task>
+    <task id="LOCAL-00055" summary="Fiexed highlighting of operations">
+      <option name="closed" value="true" />
+      <created>1787091089061</created>
+      <option name="number" value="00055" />
+      <option name="presentableId" value="LOCAL-00055" />
+      <option name="project" value="LOCAL" />
+      <updated>1787091089061</updated>
+    </task>
+    <option name="localTasksCounter" value="56" />
     <servers />
   </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
   <component name="Vcs.Log.Tabs.Properties">
     <option name="TAB_STATES">
       <map>
@@ -270,16 +539,6 @@
     <ignored-roots>
       <path value="$PROJECT_DIR$/pythonProject" />
     </ignored-roots>
-    <MESSAGE value="init" />
-    <MESSAGE value="- Basic oop sketch widget implement" />
-    <MESSAGE value="- Renabled extrusion with new object system" />
-    <MESSAGE value="- Sketch projection partly works again :)" />
-    <MESSAGE value="- Added new componnt controls" />
-    <MESSAGE value="- changing compos for sketches works" />
-    <MESSAGE value="- changing compos including sketches and bodies" />
-    <MESSAGE value="- Drawing bodys depending on the selected compo&#10;- Cut working&#10;- Edit sketch working" />
-    <MESSAGE value="- delete sketch working&#10;- added mid point snap&#10;- added hovering line with distance" />
-    <MESSAGE value="- Added new buttons and settings" />
     <MESSAGE value="- Added construction lines switching&#10;- Moved callbacks into sketchwidget from main.&#10;- Changed reset on right click" />
     <MESSAGE value="- Added contrain displayed next to line&#10;- Slight change to point check from solver." />
     <MESSAGE value="- Added enabling of midpsnap and prepared others&#10;- Show dimesnion on hover" />
@@ -287,6 +546,24 @@
     <MESSAGE value="- added MIT license" />
     <MESSAGE value="- added screenshot" />
     <MESSAGE value="- added sdf folder ( doesnt work via pip or git=)" />
-    <option name="LAST_COMMIT_MESSAGE" value="- added sdf folder ( doesnt work via pip or git=)" />
+    <MESSAGE value="- Tons of addtions" />
+    <MESSAGE value="- Basic operations" />
+    <MESSAGE value="- removed cadquery deoendency" />
+    <MESSAGE value="- sketch enhacements" />
+    <MESSAGE value="- UI refinement, button position ui file as source no dirty drafting anymore" />
+    <MESSAGE value="- assembly draft" />
+    <MESSAGE value="- Added save file foramt&#10;- Split main.py refactor" />
+    <MESSAGE value="- Working assembly multi :)" />
+    <MESSAGE value="-  added renderer" />
+    <MESSAGE value="-  added renderer&#10;- Added undo" />
+    <MESSAGE value="- Render improvements, camera plane, update" />
+    <MESSAGE value="- added &quot;measurement lines&quot;" />
+    <MESSAGE value="- arc improvements, fillets, operations, bodys" />
+    <MESSAGE value="- Operation highlighting, body highlighting" />
+    <MESSAGE value="- tech draw draft" />
+    <MESSAGE value="- tech draw draft v2" />
+    <MESSAGE value="- tech drawing and render improv" />
+    <MESSAGE value="Fiexed highlighting of operations" />
+    <option name="LAST_COMMIT_MESSAGE" value="Fiexed highlighting of operations" />
   </component>
 </project>

.layout_new.py

@@ -0,0 +1,376 @@
+# ── Sheet layout regions ────────────────────────────────────────────────────
+
+_LAYOUT_MARGIN_MM = 10.0
+_VIEW_GAP_MM = 12.0
+
+# Title block box (see _title_block_primitives): 180 × 52 at the bottom-right
+# corner with a 5 mm sheet margin.  Views must clear it (plus clearance).
+_TB_LEFT_MM = _A3_WIDTH_MM - 180.0 - 5.0
+_TB_TOP_MM = 5.0 + 52.0
+_TB_CLEARANCE_MM = 5.0
+
+# Sheet interior (border margin) as (x0, y0, x1, y1) in sheet mm.
+_SHEET_INNER = (
+    _LAYOUT_MARGIN_MM,
+    _LAYOUT_MARGIN_MM,
+    _A3_WIDTH_MM - _LAYOUT_MARGIN_MM,
+    _A3_HEIGHT_MM - _LAYOUT_MARGIN_MM,
+)
+
+# Regions the orthographic layout may occupy, as (x0, y0, w, h):
+#  - UPPER: full sheet width above the title block
+#  - LEFT:  full sheet height in the left strip beside the title block
+_REGION_UPPER = (
+    _LAYOUT_MARGIN_MM,
+    _TB_TOP_MM + _TB_CLEARANCE_MM,
+    _A3_WIDTH_MM - 2 * _LAYOUT_MARGIN_MM,
+    _A3_HEIGHT_MM - _LAYOUT_MARGIN_MM - (_TB_TOP_MM + _TB_CLEARANCE_MM),
+)
+_REGION_LEFT = (
+    _LAYOUT_MARGIN_MM,
+    _LAYOUT_MARGIN_MM,
+    _TB_LEFT_MM - _TB_CLEARANCE_MM - _LAYOUT_MARGIN_MM,
+    _A3_HEIGHT_MM - 2 * _LAYOUT_MARGIN_MM,
+)
+
+_MID_ORDER = ("left", "front", "right", "back")
+_COL_ORDER = ("top", "front", "bottom")  # sheet top → bottom
+_GRID_ORDER = ("front", "right", "back", "top", "left", "bottom")
+
+_RectList = List[Tuple[str, float, float, float, float]]
+
+
+def _place_cross(
+    dims: Dict[str, Tuple[float, float]], gap: float
+) -> _RectList:
+    """Classic third-angle cross: mid views run left→right (left, front,
+    right, back), col views stack top→bottom (top, front, bottom), with the
+    anchor view (front, or the first present one) at the intersection.
+
+    *dims* maps view id → ``(w, h)`` in sheet units.  Returns local
+    ``(vid, x, y, w, h)`` rects (origin arbitrary — the caller centres the
+    union on the sheet).
+    """
+    mid = [k for k in _MID_ORDER if k in dims]
+    col = [k for k in _COL_ORDER if k in dims]
+    if not mid and not col:
+        return []
+    rects: Dict[str, Tuple[float, float, float, float]] = {}
+
+    if col:
+        # Stack bottom → top.
+        y = 0.0
+        for k in reversed(col):
+            w, h = dims[k]
+            rects[k] = (0.0, y, w, h)
+            y += h + gap
+        col_h = y - gap
+        cx = max(dims[k][0] for k in col) / 2.0
+        for k in col:
+            _x, yy, w, h = rects[k]
+            rects[k] = (cx - w / 2.0, yy, w, h)
+    else:
+        col_h = 0.0
+        cx = 0.0
+
+    anchor = "front" if "front" in dims else (mid[0] if mid else col[0])
+    if anchor in rects:
+        ax, ay, aw, _ah = rects[anchor]
+        anchor_cy = ay + _ah / 2.0
+    else:
+        aw, ah = dims[anchor]
+        ax = cx - aw / 2.0
+        ay = col_h / 2.0 - ah / 2.0
+        rects[anchor] = (ax, ay, aw, ah)
+        anchor_cy = col_h / 2.0
+
+    ia = mid.index(anchor) if anchor in mid else -1
+    x = ax
+    for k in reversed(mid[:ia]):
+        w, h = dims[k]
+        x -= w + gap
+        rects[k] = (x, anchor_cy - h / 2.0, w, h)
+    x = ax + aw
+    for k in mid[ia + 1 :]:
+        w, h = dims[k]
+        x += gap
+        rects[k] = (x, anchor_cy - h / 2.0, w, h)
+        x += w
+    return [(k, *r) for k, r in rects.items()]
+
+
+def _place_swapped(dims: Dict[str, Tuple[float, float]], gap: float) -> _RectList:
+    """Cross with the view families swapped: the mid views stack vertically
+    (left, front, right, back from the top) and the col views run
+    horizontally (bottom, front, top from the left) — the classic cross
+    turned a quarter turn, for sheets where that orientation fits more.
+    """
+    mid = [k for k in _MID_ORDER if k in dims]
+    col = [k for k in _COL_ORDER if k in dims]
+    if not mid or not col:
+        return []
+    rects: Dict[str, Tuple[float, float, float, float]] = {}
+    cx = max(dims[k][0] for k in mid) / 2.0
+    y = 0.0
+    for k in mid:  # top → bottom
+        w, h = dims[k]
+        rects[k] = (cx - w / 2.0, y, w, h)
+        y += h + gap
+    anchor = "front" if "front" in dims else mid[0]
+    anchor_cy = rects[anchor][1] + dims[anchor][1] / 2.0
+
+    row: Dict[str, Tuple[float, float, float, float]] = {}
+    x = 0.0
+    x_anchor = 0.0
+    for k in reversed(col):  # bottom, front, top → left to right
+        w, h = dims[k]
+        if k == anchor:
+            x_anchor = x
+        row[k] = (x, anchor_cy - h / 2.0, w, h)
+        x += w + gap
+    shift = rects[anchor][0] - x_anchor
+    for k, r in row.items():
+        if k == anchor:
+            continue
+        x0, y0, w, h = r
+        rects[k] = (x0 + shift, y0, w, h)
+    return [(k, *r) for k, r in rects.items()]
+
+
+def _place_grid(
+    dims: Dict[str, Tuple[float, float]], gap: float, rows: int
+) -> _RectList:
+    """Wrap the present standard views into a grid of *rows* rows, filled
+    bottom→top and left→right (so the primary views sit near the bottom,
+    like in the cross)."""
+    order = [k for k in _GRID_ORDER if k in dims]
+    if not order:
+        return []
+    cols = max(1, -(-len(order) // rows))
+    rects: _RectList = []
+    y = 0.0
+    for r in range(rows):
+        chunk = order[r * cols : (r + 1) * cols]
+        if not chunk:
+            break
+        x = 0.0
+        row_h = 0.0
+        for k in chunk:
+            w, h = dims[k]
+            rects.append((k, x, y, w, h))
+            x += w + gap
+            row_h = max(row_h, h)
+        y += row_h + gap
+    return rects
+
+
+def _fit_scale(
+    place: Callable[
+        [Dict[str, Tuple[float, float]], float], _RectList
+    ],
+    dims_m: Dict[str, Tuple[float, float]],
+    region: Tuple[float, float, float, float],
+) -> float:
+    """Largest shared scale at which *dims_m* (model units) laid out by
+    *place* fits the ``(x0, y0, w, h)`` *region* of the sheet.
+
+    The union size grows monotonically with the scale, so a bisection
+    converges to the tight fit.
+    """
+    _rx0, _ry0, rw, rh = region
+
+    def fits(s: float) -> bool:
+        rects = place(
+            {k: (w * s, h * s) for k, (w, h) in dims_m.items()}, _VIEW_GAP_MM
+        )
+        if not rects:
+            return True
+        minx = min(r[1] for r in rects)
+        miny = min(r[2] for r in rects)
+        maxx = max(r[1] + r[3] for r in rects)
+        maxy = max(r[2] + r[4] for r in rects)
+        return (maxx - minx) <= rw + 1e-9 and (maxy - miny) <= rh + 1e-9
+
+    s_lo, s_hi = 0.0, 1.0
+    if fits(s_hi):
+        s_lo = s_hi
+        while s_hi < 1.0e6 and fits(s_hi * 2.0):
+            s_hi *= 2.0
+    for _ in range(60):
+        mid = 0.5 * (s_lo + s_hi)
+        if fits(mid):
+            s_lo = mid
+        else:
+            s_hi = mid
+    return s_lo
+
+
+def _free_rects(
+    used_rects: Sequence[Tuple[float, float, float, float]]
+) -> List[Tuple[float, float, float, float]]:
+    """Axis-aligned free rects ``(x0, y0, w, h)`` around *used_rects*,
+    clearing the sheet border and the title block zone."""
+    ix0, iy0, ix1, iy1 = _SHEET_INNER
+    if used_rects:
+        ux0 = min(r[0] for r in used_rects)
+        uy0 = min(r[1] for r in used_rects)
+        ux1 = max(r[0] + r[2] for r in used_rects)
+        uy1 = max(r[1] + r[3] for r in used_rects)
+        cands = [
+            (ux1 + _VIEW_GAP_MM, iy0, ix1, iy1),  # right of the used block
+            (ix0, iy0, ux0 - _VIEW_GAP_MM, iy1),  # left
+            (ix0, uy1 + _VIEW_GAP_MM, ix1, iy1),  # above
+            (ix0, iy0, ix1, uy0 - _VIEW_GAP_MM),  # below
+        ]
+    else:
+        cands = [(ix0, iy0, ix1, iy1)]
+    tb = (
+        _TB_LEFT_MM - _TB_CLEARANCE_MM,
+        0.0,
+        _A3_WIDTH_MM - (_TB_LEFT_MM - _TB_CLEARANCE_MM),
+        _TB_TOP_MM + _TB_CLEARANCE_MM,
+    )
+    out: List[Tuple[float, float, float, float]] = []
+    for x0, y0, x1, y1 in cands:
+        x0, y0 = max(x0, ix0), max(y0, iy0)
+        x1, y1 = min(x1, ix1), min(y1, iy1)
+        if x1 - x0 < 1.0 or y1 - y0 < 1.0:
+            continue
+        if not (x1 <= tb[0] or tb[2] <= x0 or y1 <= tb[1] or tb[3] <= y0):
+            # Overlaps the title block zone — keep the parts above/left of it.
+            subs = [
+                (x0, max(y0, tb[3]), x1, y1),
+                (x0, y0, min(x1, tb[0]), y1),
+            ]
+        else:
+            subs = [(x0, y0, x1, y1)]
+        for sx0, sy0, sx1, sy1 in subs:
+            if sx1 - sx0 > 1.0 and sy1 - sy0 > 1.0:
+                out.append((sx0, sy0, sx1 - sx0, sy1 - sy0))
+    return out
+
+
+def _layout_views_on_sheet(
+    views: Sequence[DrawingView],
+    bboxes: Dict[str, Tuple[float, float, float, float]],
+) -> Tuple[
+    Dict[str, Tuple[float, float, float, float]],
+    Optional[float],
+    Dict[str, float],
+]:
+    """Compute a slot rectangle and sheet rotation for each view.
+
+    *bboxes* maps view_id → ``(min_x, min_y, max_x, max_y)`` in model
+    units (from :func:`_edges_bounds`).  Returns ``(slots, common_scale,
+    rotations)``: slots are ``(left, bottom, width, height)`` in sheet mm
+    (origin at the sheet's bottom-left corner, +y up), common_scale is the
+    shared model→sheet scale of the standard orthographic views, and
+    rotations maps view_id → sheet rotation in degrees (0 or 90).
+
+    The sheet is filled, not just used: every candidate arrangement
+    (classic third-angle cross, the cross with the view families swapped,
+    and 1/2/3-row grids) is combined with every per-view 90° rotation
+    assignment, and the candidate giving the largest shared scale is used.
+    Candidates within 0.5% of the best scale prefer the one with fewer
+    rotated views, then the more conventional arrangement, so layouts stay
+    stable and standard whenever they are already the best fit.  All
+    orthographic views share one scale so the projections stay mutually
+    consistent.  Isometric and custom views take the largest remaining
+    free rect (clearing the title block).
+    """
+    slots: Dict[str, Tuple[float, float, float, float]] = {}
+    rotations: Dict[str, float] = {}
+    common_scale: Optional[float] = None
+
+    ortho = [
+        v for v in views if v.kind in _STANDARD_VIEWS and v.kind != "isometric"
+    ]
+
+    used_rects: List[Tuple[float, float, float, float]] = []
+    if ortho:
+        dims0: Dict[str, Tuple[float, float]] = {}
+        for v in ortho:
+            b = bboxes.get(v.kind)
+            vs = max(v.scale, 1e-9)
+            if b is None:
+                dims0[v.kind] = (1.0 * vs, 1.0 * vs)
+            else:
+                dims0[v.kind] = (
+                    max(b[2] - b[0], 1e-6) * vs,
+                    max(b[3] - b[1], 1e-6) * vs,
+                )
+        keys = list(dims0)
+        arrangements: Tuple[
+            Tuple[str, int, Callable[[Dict[str, Tuple[float, float]], float], _RectList]]
+        ] = (
+            ("cross", 0, _place_cross),
+            ("swapped", 1, _place_swapped),
+            ("grid1", 2, lambda d, g: _place_grid(d, g, 1)),
+            ("grid2", 3, lambda d, g: _place_grid(d, g, 2)),
+            ("grid3", 4, lambda d, g: _place_grid(d, g, 3)),
+        )
+        cands: List[
+            Tuple[float, int, int, Tuple[float, float, float, float],
+                  Dict[str, Tuple[float, float]],
+                  Callable[[Dict[str, Tuple[float, float]], float], _RectList],
+                  List[bool]]
+        ] = []
+        for mask in range(1 << len(keys)):
+            rotated = [bool(mask & (1 << i)) for i in range(len(keys))]
+            dims_m = {
+                k: (
+                    dims0[k][1] if rotated[i] else dims0[k][0],
+                    dims0[k][0] if rotated[i] else dims0[k][1],
+                )
+                for i, k in enumerate(keys)
+            }
+            for _name, rank, place in arrangements:
+                s_up = _fit_scale(place, dims_m, _REGION_UPPER)
+                s_left = _fit_scale(place, dims_m, _REGION_LEFT)
+                if s_up >= s_left:
+                    s, region = s_up, _REGION_UPPER
+                else:
+                    s, region = s_left, _REGION_LEFT
+                if s <= 0.0:
+                    continue
+                cands.append((s, sum(rotated), rank, region, dims_m, place, rotated))
+        if cands:
+            best_s = max(c[0] for c in cands)
+            s, _nrot, _rank, region, dims_m, place, rotated = min(
+                (c for c in cands if c[0] >= best_s * 0.995),
+                key=lambda c: (c[1], c[2], -c[0]),
+            )
+            rx0, _ry0, rw, rh = region
+            ds = {k: (w * s, h * s) for k, (w, h) in dims_m.items()}
+            rects = place(ds, _VIEW_GAP_MM)
+            minx = min(r[1] for r in rects)
+            miny = min(r[2] for r in rects)
+            maxx = max(r[1] + r[3] for r in rects)
+            maxy = max(r[2] + r[4] for r in rects)
+            ox = rx0 + (rw - (maxx - minx)) / 2.0
+            oy = _ry0 + (rh - (maxy - miny)) / 2.0
+            for vid, x, y, w, h in rects:
+                slots[vid] = (x - minx + ox, y - miny + oy, w, h)
+                rotations[vid] = 90.0 if rotated[keys.index(vid)] else 0.0
+            common_scale = s
+            used_rects = [(ox, oy, maxx - minx, maxy - miny)]
+
+    # Isometric and custom views: the largest remaining free rect each,
+    # clearing the title block.
+    extra = [
+        v for v in views
+        if v.kind == "isometric" or v.kind not in _STANDARD_VIEWS
+    ]
+    assigned = list(used_rects)
+    for i, v in enumerate(extra):
+        vid = v.kind if v.kind in _STANDARD_VIEWS else (v.name or v.id)
+        free = _free_rects(assigned)
+        if free:
+            slot = max(free, key=lambda r: r[2] * r[3])
+        else:
+            # No free rect left — park in the bottom-left corner stack.
+            slot = (_LAYOUT_MARGIN_MM, _LAYOUT_MARGIN_MM + i * 60.0, 120.0, 50.0)
+        slots[vid] = slot
+        assigned.append(slot)
+
+    return slots, common_scale, rotations

.render_check.py

@@ -0,0 +1,50 @@
+import os, sys
+os.environ["QT_QPA_PLATFORM"] = "offscreen"
+sys.path.insert(0, "/Volumes/Data_drive/Programming/fluency/src")
+
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QPixmap, QPainter, QColor
+from PySide6.QtCore import QRectF
+import math
+
+app = QApplication.instance() or QApplication([])
+
+from fluency.geometry.base import Point2D
+from fluency.geometry_occ.kernel import OCGeometryKernel
+from fluency.models.data_model import Body, Component, Project, DrawingView, TechnicalDrawing
+from fluency.technical_drawing import generate_drawing, render_drawing, _A3_WIDTH_MM, _A3_HEIGHT_MM
+
+kernel = OCGeometryKernel()
+# Long thin bar: 120 x 25 x 30 (matches the "wide bar" screenshot case).
+points = [Point2D(0, 0), Point2D(120, 0), Point2D(120, 25), Point2D(0, 25)]
+box = kernel.extrude(kernel.create_polygon(points), 30.0)
+body = Body(name="Bar", geometry=box)
+comp = Component(name="BarComp")
+comp.bodies[body.id] = body
+project = Project()
+project.components[comp.id] = comp
+project.active_component = comp.id
+
+W = 2400
+H = int(W * _A3_HEIGHT_MM / _A3_WIDTH_MM)
+pm = QPixmap(W, H)
+pm.fill(QColor(255, 255, 255))
+
+for name, kinds in [
+    ("four", ["front", "top", "right", "back"]),
+    ("six", ["front", "top", "right", "left", "back", "bottom"]),
+    ("sixiso", ["front", "top", "right", "left", "back", "bottom", "isometric"]),
+]:
+    drawing = TechnicalDrawing(
+        source_kind="component", source_id=comp.id,
+        views=[DrawingView(kind=k) for k in kinds],
+        auto_dimensions=True, title=name,
+    )
+    result = generate_drawing(drawing, project, kernel)
+    p = QPainter(pm)
+    render_drawing(p, result, QRectF(0, 0, W, H))
+    p.end()
+    out = f"/tmp/drawing_{name}.png"
+    pm.save(out)
+    print(name, "saved", out, "prims", len(result.primitives), "scale",
+          round(result.view_transforms.get("front", (None,))[0] or 0, 3))

.smoke_layout.py

@@ -0,0 +1,159 @@
+"""Smoke test: layout optimizer fills the page, no overlaps, title block clear."""
+import math
+import os
+import sys
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, "/Volumes/Data_drive/Programming/fluency/src")
+
+from fluency.models.data_model import DrawingView
+from fluency.technical_drawing import (
+    _layout_views_on_sheet,
+    build_manual_candidates,
+)
+
+A3W, A3H = 420.0, 297.0
+TB = (235.0, 0.0, 420.0, 62.0)  # title block zone incl. clearance
+
+
+def b(x, y, w, h):
+    return (x, y, x + w, y + h)
+
+
+def overlaps(r1, r2, clear=0.0):
+    x0, y0, w, h = r1
+    x1, y1, w2, h2 = r2
+    return not (x0 + w <= x1 + clear or x1 + w2 <= x0 + clear
+                or y0 + h <= y1 + clear or y1 + h2 <= y0 + clear)
+
+
+def tb_overlap(r, clear=5.0):
+    x0, y0, w, h = r
+    x1, y1, w2, h2 = TB
+    return not (x0 + w <= x1 + clear or x1 + w2 <= x0 + clear
+                or y0 + h <= y1 + clear or y1 + h2 <= y0 + clear)
+
+
+def union_rect(rects):
+    x0 = min(r[0] for r in rects)
+    y0 = min(r[1] for r in rects)
+    x1 = max(r[0] + r[2] for r in rects)
+    y1 = max(r[1] + r[3] for r in rects)
+    return (x0, y0, x1 - x0, y1 - y0)
+
+
+def check(name, kinds, boxes, expect_rot=None):
+    views = [DrawingView(kind=k) for k in kinds]
+    bboxes = {k: boxes[k] for k in kinds}
+    slots, scale, rots = _layout_views_on_sheet(views, bboxes)
+    print(f"--- {name}: scale={scale:.4f} rots={rots}")
+    # all slots within sheet
+    for k, s in slots.items():
+        assert 10 - 1e-6 <= s[0] and 10 - 1e-6 <= s[1], f"{k} outside sheet {s}"
+        assert s[0] + s[2] <= A3W - 10 + 1e-6, f"{k} beyond right {s}"
+        assert s[1] + s[3] <= A3H - 10 + 1e-6, f"{k} beyond top {s}"
+    # no overlaps between slots
+    ks = list(slots)
+    for i in range(len(ks)):
+        for j in range(i + 1, len(ks)):
+            assert not overlaps(slots[ks[i]], slots[ks[j]], 11.9), \
+                f"{ks[i]} overlaps {ks[j]}: {slots[ks[i]]} / {slots[ks[j]]}"
+    # title block clear
+    for k, s in slots.items():
+        assert not tb_overlap(s), f"{k} intrudes title block {s}"
+    # fill report
+    u = union_rect(list(slots.values()))
+    area = u[2] * u[3]
+    print(f"    union: x0={u[0]:.1f} y0={u[1]:.1f} w={u[2]:.1f} h={u[3]:.1f} "
+          f"area={area:.0f}mm^2 ({100*area/(A3W*A3H):.0f}% of sheet)")
+    for k in ks:
+        print(f"    {k}: {tuple(round(v,1) for v in slots[k])}")
+    if expect_rot is not None:
+        assert rots == expect_rot, f"expected {expect_rot}, got {rots}"
+    return slots, scale, rots
+
+
+# 1. Two square views (front+top): should fill the page, no rotation.
+check("two square", ["front", "top"],
+      {"front": b(0, 0, 40, 40), "top": b(0, 0, 40, 20)})
+
+# 2. Wide bar, 4 views (old screenshot case): front+back wide, top+right.
+check("wide bar 4", ["front", "top", "right", "back"],
+      {"front": b(0, 0, 120, 25), "top": b(0, 0, 25, 40),
+       "right": b(0, 0, 25, 40), "back": b(0, 0, 120, 25)})
+
+# 3. Six views of a long thin part: rotation should kick in.
+check("thin part 6", ["front", "top", "right", "left", "back", "bottom"],
+      {"front": b(0, 0, 200, 30), "top": b(0, 0, 30, 50),
+       "right": b(0, 0, 50, 30), "left": b(0, 0, 50, 30),
+       "back": b(0, 0, 200, 30), "bottom": b(0, 0, 30, 50)})
+
+# 4. Single front view: fills the whole page.
+check("single", ["front"], {"front": b(0, 0, 10, 20)})
+
+# 5. All 6 + isometric + custom.
+check("everything",
+      ["front", "top", "right", "left", "back", "bottom", "isometric"],
+      {"front": b(0, 0, 80, 40), "top": b(0, 0, 80, 30),
+       "right": b(0, 0, 30, 40), "left": b(0, 0, 30, 40),
+       "back": b(0, 0, 80, 40), "bottom": b(0, 0, 80, 30),
+       "isometric": b(0, 0, 60, 60)})
+
+# ── Inverse-transform roundtrip ─────────────────────────────────────────
+# A 90°-rotated view: forward via _assemble_view's recorded 6-tuple,
+# inverse via the widget's formula.
+t = (2.0, 150.0, 80.0, 90.0, 10.0, 5.0)  # s, o_x, o_y, deg, cx, cy
+scale, ox, oy, deg, cx, cy = t
+th = math.radians(deg)
+cos_t, sin_t = math.cos(th), math.sin(th)
+
+
+def fwd(p):
+    dx, dy = p[0] - cx, p[1] - cy
+    return ((dx * cos_t - dy * sin_t) * scale + ox,
+            (dx * sin_t + dy * cos_t) * scale + oy)
+
+
+def inv(p):
+    sx, sy = (p[0] - ox) / scale, (p[1] - oy) / scale
+    return (sx * cos_t + sy * sin_t + cx, -sx * sin_t + sy * cos_t + cy)
+
+
+for p in [(0, 0), (10, 5), (3, -7), (42.5, 11.25)]:
+    rt = inv(fwd(p))
+    assert abs(rt[0] - p[0]) < 1e-9 and abs(rt[1] - p[1]) < 1e-9, (p, rt)
+print("inverse roundtrip OK")
+
+# Legacy 3-tuple still works through build_manual_candidates.
+from fluency.models.data_model import DrawingAnnotation, TechnicalDrawing
+d = TechnicalDrawing(source_kind="component", source_id="c")
+ann = DrawingAnnotation(kind="dimension", dimension_kind="length",
+                        view_id="front", anchors=[(0.0, 0.0), (0.0, 12.5)],
+                        direction=(0.0, 1.0))
+d.annotations.append(ann)
+cands, res, unres = build_manual_candidates(d, {"front": (2.0, 10.0, 20.0)})
+assert unres == [] and cands[0].anchor_points[1] == (10.0, 45.0)
+print("legacy 3-tuple OK")
+
+# 6-tuple manual: rotated length direction must rotate too.
+ann2 = DrawingAnnotation(kind="dimension", dimension_kind="length",
+                         view_id="front",
+                         anchors=[(0.0, 0.0), (0.0, 10.0)],
+                         direction=(0.0, 1.0))
+d2 = TechnicalDrawing(source_kind="component", source_id="c")
+d2.annotations.append(ann2)
+# 90° rotation about centre c=(5,5), scale 2, o=(100,80)
+cands, res, unres = build_manual_candidates(
+    d2, {"front": (2.0, 100.0, 80.0, 90.0, 5.0, 5.0)}
+)
+c = cands[0]
+# anchors: (0,0)->rot90 about (5,5) = (5-(0-5)*0 - ... compute: dx=-5,dy=-5
+# fwd: (dx*cos - dy*sin)*2+100 = (0 - (-5))*2+100 = 110 ; (dx*sin+dy*cos)*2+80 = (-5)*2+80=70
+# (0,10): dx=-5, dy=5 -> (0-5)*2+100=90 ; (−5*1+0)*2+80=70
+assert c.anchor_points[0] == (110.0, 70.0), c.anchor_points
+assert c.anchor_points[1] == (90.0, 70.0), c.anchor_points
+# direction (0,1) rotated 90° CCW -> (-1, 0)
+assert c.direction[0] == -1.0 and abs(c.direction[1]) < 1e-9, c.direction
+print("6-tuple manual (rotated) OK")
+
+print("ALL SMOKE CHECKS PASSED")

.test_connector_relocate.py

@@ -0,0 +1,238 @@
+"""Headless test: connectors follow moved features across ALL assemblies.
+
+Simulates the test-file scenario: a plate with a hole, mated hole-to-face
+in two different assemblies.  The hole is moved (rebuilt geometry) and the
+body-update connector recalculation must:
+  1. re-locate the hole connector on every instance of the component
+     (both the active and a non-active assembly),
+  2. re-solve each mated pair so the partner parts follow,
+  3. never snap a planar connector onto the cylindrical hole (type match),
+  4. mark a connector invalid when its feature disappears.
+  5. auto-follow a FAR move when the candidate is unambiguous (single
+     feature of its class) — the demo case,
+  6. NOT auto-apply an ambiguous far candidate (another same-class feature
+     is nearer) — that needs a manual pick, simulated here.
+  7. backfill legacy connectors' entity_type from their auto-generated name.
+"""
+
+import os
+import sys
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+import numpy as np
+
+from OCP.gp import gp_Pnt, gp_Dir, gp_Ax2
+from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox, BRepPrimAPI_MakeCylinder
+from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut
+
+from PySide6.QtWidgets import QApplication
+
+from fluency.ui.main_window import MainWindow
+from fluency.models.data_model import Assembly, Body
+from fluency.geometry_occ.kernel import OCCGeometryObject
+
+app = QApplication.instance() or QApplication([])
+w = MainWindow()
+
+comp = w._current_component
+
+
+def make_plate(hole_xy):
+    box = BRepPrimAPI_MakeBox(60.0, 40.0, 5.0).Shape()
+    ax = gp_Ax2(gp_Pnt(float(hole_xy[0]), float(hole_xy[1]), 0.0), gp_Dir(0, 0, 1))
+    cyl = BRepPrimAPI_MakeCylinder(ax, 3.0, 6.0).Shape()
+    return BRepAlgoAPI_Cut(box, cyl).Shape()
+
+
+body = Body(name="plate")
+comp.bodies[body.id] = body
+body.geometry = OCCGeometryObject(make_plate((10.0, 5.0)))
+
+partner = w._project.add_component()
+pbody = Body(name="partner")
+partner.bodies[pbody.id] = pbody
+pbody.geometry = OCCGeometryObject(BRepPrimAPI_MakeBox(30.0, 30.0, 10.0).Shape())
+
+
+def make_pair(asm):
+    ac1 = asm.add_component_instance(comp.id, name="A")
+    ac2 = asm.add_component_instance(partner.id, name="B")
+    ac1.position = np.zeros(3)
+    ac1.rotation = np.eye(3)
+    ac2.position = np.array([0.0, 0.0, 15.0])
+    ac2.rotation = np.eye(3)
+    ac1.geom_cache[body.id] = body.geometry
+
+    c1 = ac1.add_connector(
+        position=(10.0, 5.0, 2.5),
+        normal=(0.0, 0.0, 1.0),
+        x_dir=(1.0, 0.0, 0.0),
+        source_obj_id=f"asm_{ac1.id}_{body.id}",
+        name="Conn hole A",
+        entity_type="cylindrical_face",
+    )
+    c2 = ac2.add_connector(
+        position=(15.0, 15.0, 0.0),
+        normal=(0.0, 0.0, -1.0),
+        x_dir=(1.0, 0.0, 0.0),
+        source_obj_id=f"asm_{ac2.id}_{pbody.id}",
+        name="Conn face B",
+        entity_type="planar_face",
+    )
+    c1.is_grounded = True
+    c1.partner_ac_id = ac2.id
+    c1.partner_connector_id = c2.id
+    c2.partner_ac_id = ac1.id
+    c2.partner_connector_id = c1.id
+    aconn = asm.add_connection(ac1.id, ac2.id)
+    aconn.first_connector_id = c1.id
+    aconn.second_connector_id = c2.id
+    return ac1, ac2, c1, c2, aconn
+
+
+asm1 = w._project.get_active_assembly()
+asm2 = w._project.add_assembly(Assembly(name="second"))
+pair1 = make_pair(asm1)
+pair2 = make_pair(asm2)
+assert w._project.active_assembly == asm1.id  # asm2 is the NON-active one
+
+# ── Move the hole: rebuild the plate with the hole at (25, 12) ──────────
+new_geom = OCCGeometryObject(make_plate((25.0, 12.0)))
+body.geometry = new_geom
+for asm in (asm1, asm2):
+    for ac in asm.components.values():
+        if ac.component_id == comp.id:
+            ac.geom_cache[body.id] = new_geom
+
+# ── The body-update auto path ───────────────────────────────────────────
+w._recalculate_connectors()
+
+for (ac1, ac2, c1, c2, aconn), label in ((pair1, "asm1"), (pair2, "asm2")):
+    # The hole connector followed the hole on every instance.
+    assert np.allclose(c1.position, (25.0, 12.0, 2.5), atol=1e-6), (label, c1.position)
+    # The mated pair re-aligned: both world connectors coincide.
+    w1 = ac1.position + ac1.rotation @ np.asarray(c1.position)
+    w2 = ac2.position + ac2.rotation @ np.asarray(c2.position)
+    assert np.allclose(w1, w2, atol=1e-6), (label, w1, w2)
+    print(f"{label}: connector at {np.round(c1.position, 3)}, "
+          f"partner moved to {np.round(ac2.position, 3)}")
+
+# ── The 'Upd' button path: move the hole again, re-run the handler ─────
+w._refresh_connection_list()
+w._connection_list.setCurrentRow(0)  # active assembly = asm1
+geom3 = OCCGeometryObject(make_plate((35.0, 20.0)))
+body.geometry = geom3
+for ac in asm1.components.values():
+    if ac.component_id == comp.id:
+        ac.geom_cache[body.id] = geom3
+w._on_update_connection_from_list()
+ac1, ac2, c1, c2, aconn = pair1
+assert np.allclose(c1.position, (35.0, 20.0, 2.5), atol=1e-6), c1.position
+w1 = ac1.position + ac1.rotation @ np.asarray(c1.position)
+w2 = ac2.position + ac2.rotation @ np.asarray(c2.position)
+assert np.allclose(w1, w2, atol=1e-6), (w1, w2)
+print("Upd button: connector at", np.round(c1.position, 3),
+      "partner at", np.round(ac2.position, 3))
+
+# ── Type matching: a planar connector must not snap onto the hole ───────
+ac1 = pair1[0]
+c3 = ac1.add_connector(
+    position=(30.0, 20.0, 5.0),
+    normal=(0.0, 0.0, 1.0),
+    x_dir=(1.0, 0.0, 0.0),
+    source_obj_id=f"asm_{ac1.id}_{body.id}",
+    name="Conn face",
+    entity_type="planar_face",
+)
+res = w._redetect_connector_on_geometry(c3, ac1, comp)
+assert res is not None, "planar connector candidate missing"
+assert not c3.is_invalid, "pure relocator must not mutate the connector"
+assert np.allclose(c3.position, (30.0, 20.0, 5.0), atol=1e-6), c3.position
+assert np.allclose(res[1], (30.0, 20.0, 5.0), atol=1e-6), res[1]
+print("planar connector stayed on the face:", np.round(res[1], 3))
+
+# ── Feature removed: relocator finds nothing; auto path marks invalid ──
+plain = OCCGeometryObject(BRepPrimAPI_MakeBox(60.0, 40.0, 5.0).Shape())
+body.geometry = plain
+ac1.geom_cache[body.id] = plain
+res = w._redetect_connector_on_geometry(pair1[2], ac1, comp)
+assert res is None, "hole connector should find no candidate on a plain box"
+w._recalculate_connectors()
+assert pair1[2].is_invalid, "auto path must mark the connector invalid"
+print("removed feature -> connector marked invalid")
+
+# ── Far move with a decoy: ambiguous candidate is NOT auto-applied ─────
+# The real hole moved to (25, 12) — ~12.8mm from the stored (35, 20) — but
+# a SECOND hole now sits at (28, 16), only ~8mm away.  The nearest
+# candidate is ambiguous (different feature), so the auto path must leave
+# the connector alone and queue it for a manual pick.
+def make_plate2(holes):
+    box = BRepPrimAPI_MakeBox(60.0, 40.0, 5.0).Shape()
+    for hx, hy in holes:
+        ax = gp_Ax2(gp_Pnt(hx, hy, 0.0), gp_Dir(0, 0, 1))
+        box = BRepAlgoAPI_Cut(box, BRepPrimAPI_MakeCylinder(ax, 3.0, 6.0).Shape()).Shape()
+    return box
+# ── Stage 1: the user's demo — a SINGLE hole moved far away ─────────────
+# 12.8mm from the stored position, but the only cylindrical face on the
+# body → unambiguous → must be auto-applied (and the mate re-solved).
+geom4 = OCCGeometryObject(make_plate2([(25.0, 12.0)]))
+body.geometry = geom4
+for asm in (asm1, asm2):
+    for ac in asm.components.values():
+        if ac.component_id == comp.id:
+            ac.geom_cache[body.id] = geom4
+w._recalculate_connectors()
+assert np.allclose(pair1[2].position, (25.0, 12.0, 2.5), atol=1e-6), \
+    "unique far candidate must be auto-applied (the demo case)"
+assert not pair1[2].is_invalid
+w1 = ac1.position + ac1.rotation @ np.asarray(pair1[2].position)
+w2 = pair1[1].position + pair1[1].rotation @ np.asarray(pair1[3].position)
+assert np.allclose(w1, w2, atol=1e-6), (w1, w2)
+print("single far hole: auto-followed to", np.round(pair1[2].position, 3))
+
+# ── Stage 2: far move with a decoy — ambiguous, NOT auto-applied ───────
+# The real hole now sits at (32, 20) — 10.6mm from the stored (25, 12) —
+# while a decoy hole at (21, 7) is only 6.4mm away.  The nearest
+# candidate is likely a DIFFERENT feature, so the auto path must leave
+# the connector alone and queue it for a manual pick.
+geom5 = OCCGeometryObject(make_plate2([(32.0, 20.0), (21.0, 7.0)]))
+body.geometry = geom5
+for asm in (asm1, asm2):
+    for ac in asm.components.values():
+        if ac.component_id == comp.id:
+            ac.geom_cache[body.id] = geom5
+w._recalculate_connectors()
+assert np.allclose(pair1[2].position, (25.0, 12.0, 2.5), atol=1e-6), \
+    "ambiguous far candidate must not be auto-applied"
+assert not pair1[2].is_invalid, "ambiguous candidate is not a missing feature"
+
+# Simulate the user clicking the REAL hole in the relocate pick flow:
+w._relocate_pending = [(asm1, ac1, pair1[2])]
+w._on_relocate_picked(
+    (32.0, 20.0, 2.5), (0.0, 0.0, 1.0), (1.0, 0.0, 0.0),
+    "cylindrical_face", f"asm_{ac1.id}_{body.id}",
+)
+assert np.allclose(pair1[2].position, (32.0, 20.0, 2.5), atol=1e-6), pair1[2].position
+assert not pair1[2].is_invalid, "manual pick must re-validate the connector"
+assert w._relocate_pending is None, "pending queue must drain after the pick"
+w1 = ac1.position + ac1.rotation @ np.asarray(pair1[2].position)
+w2 = pair1[1].position + pair1[1].rotation @ np.asarray(pair1[3].position)
+assert np.allclose(w1, w2, atol=1e-6), (w1, w2)
+print("far move: manual pick re-homed connector at", np.round(pair1[2].position, 3),
+      "partner at", np.round(pair1[1].position, 3))
+
+# ── Legacy backfill: empty entity_type recovered from the auto name ────
+from fluency.models.data_model import Connector
+legacy = Connector(
+    name="Conn cylindrical_face anchor",
+    position=(32.0, 20.0, 2.5),
+    source_obj_id=f"asm_{ac1.id}_{body.id}",
+)
+assert legacy.entity_type == "cylindrical_face", legacy.entity_type
+res = w._redetect_connector_on_geometry(legacy, ac1, comp)
+assert res is not None and res[0] < 1e-3, res
+print("legacy name backfill: entity_type =", legacy.entity_type)
+
+print("CONNECTOR_RELOCATE_OK")

.test_demo_repro.py

@@ -0,0 +1,158 @@
+"""Headless repro: load assemblytest.fluency, compare sketch circle centers
+vs. saved body hole axes vs. connector positions, then run the real
+body-update path and check where connectors land.
+"""
+
+import os
+import sys
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+import numpy as np
+
+from OCP.BRepAdaptor import BRepAdaptor_Surface
+from OCP.GeomAbs import GeomAbs_Cylinder
+from OCP.TopAbs import TopAbs_FACE
+from OCP.TopExp import TopExp_Explorer
+from OCP.TopoDS import TopoDS
+
+from PySide6.QtWidgets import QApplication
+
+from fluency.ui.main_window import MainWindow
+
+def etype(e):
+    if isinstance(e, dict):
+        return e.get("type")
+    return getattr(e, "entity_type", None) or getattr(e, "type", None)
+
+def egeom(e):
+    if isinstance(e, dict):
+        return e.get("geometry")
+    return getattr(e, "geometry", None)
+
+app = QApplication.instance() or QApplication([])
+w = MainWindow()
+
+path = os.path.join(os.path.dirname(__file__), "assemblytest.fluency")
+ok = w._open_project_file(path)
+assert ok, "failed to open demo file"
+
+proj = w._project
+
+for comp in proj.components.values():
+    print(f"=== {comp.name} ({comp.id})")
+    for sk in comp.sketches.values():
+        occ = sk.occ_sketch
+        if occ is None:
+            print("  sketch with no occ_sketch:", sk.id)
+            continue
+        for e in occ._entities.values():
+            t = etype(e)
+            if t == "circle":
+                g = egeom(e)
+                cid = e.get("id") if isinstance(e, dict) else e.id
+                print(f"  circle id={cid} center=({g[0][0]!r}, {g[0][1]!r}) r={g[1]!r}")
+    for body in comp.bodies.values():
+        if not body.geometry:
+            print(f"  body {body.name}: no geometry")
+            continue
+        shape = w._kernel._get_shape(body.geometry)
+        print(f"  body {body.name}: extrude len={body.extrude_length}")
+        expl = TopExp_Explorer(shape, TopAbs_FACE)
+        while expl.More():
+            face = TopoDS.Face_s(expl.Current())
+            try:
+                adaptor = BRepAdaptor_Surface(face)
+                if adaptor.GetType() == GeomAbs_Cylinder:
+                    cyl = adaptor.Cylinder()
+                    loc = cyl.Location()
+                    d = cyl.Axis().Direction()
+                    print(
+                        f"    cyl axis at ({loc.X()!r}, {loc.Y()!r}) "
+                        f"dir=({d.X():.4f},{d.Y():.4f},{d.Z():.4f})"
+                    )
+            except Exception:
+                pass
+            expl.Next()
+
+asm = proj.get_active_assembly()
+print("=== active assembly:", asm.name)
+for ac in asm.components.values():
+    comp = proj.get_component_by_id(ac.component_id)
+    print(f"  instance '{ac.name}' -> {comp.name}, pos={np.round(ac.position, 4)}")
+    for conn in ac.connectors.values():
+        print(
+            f"    conn '{conn.name}' pos={np.round(conn.position, 6)} "
+            f"normal={np.round(conn.normal, 3)} et={conn.entity_type!r} "
+            f"invalid={conn.is_invalid}"
+        )
+
+# ── Run the real update path: rebuild bodies from sketch, recalc connectors ──
+# Activate the component with the holes (Component 1).
+comp1 = None
+for comp in proj.components.values():
+    if any(
+        etype(e) == "circle"
+        for sk in comp.sketches.values()
+        for e in (sk.occ_sketch._entities.values() if sk.occ_sketch else [])
+    ):
+        comp1 = comp
+        break
+assert comp1 is not None
+w._current_component = comp1
+print("=== running _update_bodies_from_sketch()")
+w._update_bodies_from_sketch()
+print("=== running _recalculate_connectors()")
+w._recalculate_connectors()
+
+print("=== after update")
+for comp in proj.components.values():
+    for body in comp.bodies.values():
+        if not body.geometry:
+            continue
+        shape = w._kernel._get_shape(body.geometry)
+        expl = TopExp_Explorer(shape, TopAbs_FACE)
+        axes = []
+        while expl.More():
+            face = TopoDS.Face_s(expl.Current())
+            try:
+                adaptor = BRepAdaptor_Surface(face)
+                if adaptor.GetType() == GeomAbs_Cylinder:
+                    loc = adaptor.Cylinder().Location()
+                    axes.append((round(loc.X(), 9), round(loc.Y(), 9)))
+            except Exception:
+                pass
+            expl.Next()
+        print(f"  {comp.name} body axes: {axes}")
+    for sk in comp.sketches.values():
+        for e in sk.occ_sketch._entities.values():
+            t = etype(e)
+            if t == "circle":
+                g = egeom(e)
+                print(f"  {comp.name} circle: ({g[0][0]!r}, {g[0][1]!r})")
+
+asm = proj.get_active_assembly()
+for ac in asm.components.values():
+    for conn in ac.connectors.values():
+        print(
+            f"    conn '{conn.name}' pos={np.round(conn.position, 6)} "
+            f"invalid={conn.is_invalid}"
+        )
+
+# Partner alignment check: for each connection, world positions of the pair.
+for aconn in asm.connections:
+    a1 = asm.components.get(aconn.first_ac_id)
+    a2 = asm.components.get(aconn.second_ac_id)
+    c1 = a1.connectors.get(aconn.first_connector_id)
+    c2 = a2.connectors.get(aconn.second_connector_id)
+    if c1 is None or c2 is None:
+        continue
+    w1 = a1.position + a1.rotation @ np.asarray(c1.position, dtype=float)
+    w2 = a2.position + a2.rotation @ np.asarray(c2.position, dtype=float)
+    print(
+        f"  conn {aconn.id[:8]}: w1={np.round(w1, 6)} w2={np.round(w2, 6)} "
+        f"gap={float(np.linalg.norm(w1 - w2))!r}"
+    )
+
+print("DEMO_REPRO_DONE")

.test_instance_ops.py

@@ -0,0 +1,89 @@
+"""Round-trip smoke test: instance-local sketches + modifiers survive save/load.
+
+Builds a minimal project (component with a body, assembly with two instances,
+one carrying an instance sketch + cut modifier + fillet modifier), saves to a
+temp .fluency, reloads, and asserts:
+  1. the shared component is untouched by instance work,
+  2. the instance sketch + modifiers round-trip with sketch refs intact,
+  3. the plain instance has none.
+"""
+import os
+import tempfile
+
+import numpy as np
+
+from fluency.models.data_model import (
+    Project, Component, Body, Sketch, Feature, Assembly, AssemblyComponent,
+)
+from fluency.io.project_io import save_project, load_project
+
+
+def main():
+    project = Project(name="inst test")
+    comp = project.add_component()
+    comp.name = "BasePart"
+    body = comp.add_body(Body(name="MainBody"))
+    base_sketch = comp.add_sketch(Sketch(name="BaseSketch"))
+    body.features.append(
+        Feature(operation="extrude", sketch=base_sketch, length=10.0)
+    )
+
+    asm = project.add_assembly(Assembly(name="TestAsm"))
+    ac1 = asm.add_component_instance(comp.id, name="Instance A")
+    ac1.position = np.array([0.0, 0.0, 0.0])
+    ac2 = asm.add_component_instance(comp.id, name="Instance B")
+    ac2.position = np.array([50.0, 0.0, 0.0])
+
+    # Instance A: local sketch + cut modifier referencing it + fillet.
+    inst_sketch = ac1.add_instance_sketch()
+    inst_sketch.name = "InstCutSketch"
+    ac1.add_modifier(body.id, Feature(operation="cut", sketch=inst_sketch,
+                                      length=5.0, through_all=True))
+    ac1.add_modifier(body.id, Feature(operation="fillet", radius=1.0))
+
+    # ---- save / load ----
+    fd, path = tempfile.mkstemp(suffix=".fluency")
+    os.close(fd)
+    try:
+        save_project(project, path)
+        loaded, _view = load_project(path)
+
+        lcomp = loaded.components[comp.id]
+        lac1 = None
+        lac2 = None
+        for lasm in loaded.assemblies.values():
+            for ac in lasm.components.values():
+                if ac.name == "Instance A":
+                    lac1 = ac
+                elif ac.name == "Instance B":
+                    lac2 = ac
+        assert lac1 is not None and lac2 is not None, "instances missing"
+
+        # 1. component untouched
+        assert len(lcomp.sketches) == 1, "component sketch count changed"
+        assert len(lcomp.bodies[body.id].features) == 1, "feature chain changed"
+        assert not getattr(lcomp.bodies[body.id], "modifiers", None)
+
+        # 2. instance A round-trip
+        assert len(lac1.sketches) == 1, "instance sketch missing"
+        lsk_id, lsk = next(iter(lac1.sketches.items()))
+        assert lsk.name == "InstCutSketch"
+        mods = lac1.modifiers
+        lbody_id = next(iter(lcomp.bodies))
+        assert len(mods.get(lbody_id, [])) == 2, f"modifiers missing: {mods}"
+        cut, fil = mods[lbody_id][0], mods[lbody_id][1]
+        assert cut.operation == "cut" and fil.operation == "fillet"
+        assert cut.sketch is not None and cut.sketch.id == lsk_id, \
+            "cut sketch ref did not resolve to instance sketch"
+        assert cut.length == 5.0 and cut.through_all
+
+        # 3. plain instance clean
+        assert not lac2.sketches and not lac2.modifiers
+
+        print("ROUND_TRIP_OK")
+    finally:
+        os.unlink(path)
+
+
+if __name__ == "__main__":
+    main()

.test_relocate_fallback.py

@@ -0,0 +1,83 @@
+"""Headless smoke: the manual re-pick fallback path (prompt -> frame -> pick mode)."""
+
+import os
+import sys
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+import numpy as np
+
+from OCP.gp import gp_Pnt, gp_Dir, gp_Ax2
+from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox, BRepPrimAPI_MakeCylinder
+from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut
+
+from PySide6.QtWidgets import QApplication, QMessageBox
+
+from fluency.ui.main_window import MainWindow
+from fluency.models.data_model import Body
+from fluency.geometry_occ.kernel import OCCGeometryObject
+
+app = QApplication.instance() or QApplication([])
+w = MainWindow()
+
+comp = w._current_component
+body = Body(name="plate")
+comp.bodies[body.id] = body
+box = BRepPrimAPI_MakeBox(60.0, 40.0, 5.0).Shape()
+ax = gp_Ax2(gp_Pnt(10.0, 5.0, 0.0), gp_Dir(0, 0, 1))
+box = BRepAlgoAPI_Cut(box, BRepPrimAPI_MakeCylinder(ax, 3.0, 6.0).Shape()).Shape()
+body.geometry = OCCGeometryObject(box)
+
+partner = w._project.add_component()
+pbody = Body(name="partner")
+partner.bodies[pbody.id] = pbody
+pbody.geometry = OCCGeometryObject(BRepPrimAPI_MakeBox(30.0, 30.0, 10.0).Shape())
+
+asm = w._project.get_active_assembly()
+ac1 = asm.add_component_instance(comp.id, name="A")
+ac2 = asm.add_component_instance(partner.id, name="B")
+ac1.geom_cache[body.id] = body.geometry
+c1 = ac1.add_connector(
+    position=(10.0, 5.0, 2.5), normal=(0, 0, 1), x_dir=(1, 0, 0),
+    source_obj_id=f"asm_{ac1.id}_{body.id}",
+    name="Conn hole", entity_type="cylindrical_face",
+)
+c1.partner_ac_id = ac2.id
+
+# Activate the assembly view so the prompt path is taken.
+w._assembly_view_active = True
+w._selected_assembly_component_id = ac1.id
+
+# Force a Yes from the question dialog, and record that it actually fired.
+asked = {}
+def fake_question(parent, title, text, buttons, default):
+    asked["title"] = title
+    return QMessageBox.StandardButton.Yes
+QMessageBox.question = staticmethod(fake_question)
+def fake_warning(*a, **k):
+    return QMessageBox.StandardButton.Ok
+QMessageBox.warning = staticmethod(fake_warning)
+
+w._prompt_relocate_unresolved([(asm, ac1, c1)])
+assert asked.get("title") == "Connector Position Needed", asked
+assert w._relocate_pending == [(asm, ac1, c1)], w._relocate_pending
+assert w._viewer_3d._connector_pick_mode, "pick mode must be active"
+
+# A wrong-part click must not consume the pending entry.
+w._on_relocate_picked((0, 0, 0), (0, 0, 1), (1, 0, 0), "planar_face", f"asm_{ac2.id}_{pbody.id}")
+assert w._relocate_pending == [(asm, ac1, c1)], "wrong part must not consume the pick"
+
+# The right click re-homes and drains.
+w._on_relocate_picked((40.0, 30.0, 2.5), (0, 0, 1), (1, 0, 0), "cylindrical_face", f"asm_{ac1.id}_{body.id}")
+assert w._relocate_pending is None
+assert np.allclose(c1.position, (40.0, 30.0, 2.5)), c1.position
+assert not w._viewer_3d._connector_pick_mode, "pick mode must be off after completion"
+
+# Esc cancel mid-flight clears the state.
+w._relocate_pending = [(asm, ac1, c1)]
+w._start_relocate_pick_next()
+w._on_connector_pick_cancelled()
+assert w._relocate_pending is None
+assert not w._viewer_3d._connector_pick_mode
+print("RELOCATE_PICK_FALLBACK_OK")

.test_underlay_curves.py

@@ -0,0 +1,149 @@
+"""Headless test: update_external_entities handles circle/arc dict entries.
+
+Reproduces the crash where a re-projected face contains a circular edge
+(e.g. an instance cut hole): _project_face_to_uv returns a mixed list of
+polylines + curve dicts, and update_external_entities used to unpack the
+dict entries as (u, v) tuples.
+
+Covers:
+  1. mixed projection (polylines + circle dict) -> rebuild + rebind path,
+     no crash, no duplicate/orphan curve entities, user geometry re-anchored.
+  2. repeated update with the same mixed projection -> stable (idempotent).
+  3. polylines-only same-topology projection -> in-place path still works
+     (external ids preserved).
+"""
+import math
+
+from fluency.geometry_occ.sketch import OCCSketch
+
+RECT = [
+    [(0.0, 0.0), (10.0, 0.0)],
+    [(10.0, 0.0), (10.0, 10.0)],
+    [(10.0, 10.0), (0.0, 10.0)],
+    [(0.0, 10.0), (0.0, 0.0)],
+]
+
+
+def _counts(sk):
+    ents = list(sk._entities.values())
+    return {
+        "ext_points": sum(
+            1
+            for e in ents
+            if e.entity_type == "point" and getattr(e, "is_external", False)
+        ),
+        "ext_lines": sum(
+            1
+            for e in ents
+            if e.entity_type == "line" and getattr(e, "is_external", False)
+        ),
+        "circles": sum(1 for e in ents if e.entity_type == "circle"),
+        "arcs": sum(1 for e in ents if e.entity_type == "arc"),
+        "user_points": sum(
+            1
+            for e in ents
+            if e.entity_type == "point" and not getattr(e, "is_external", False)
+        ),
+    }
+
+
+def test_mixed_projection_rebuild():
+    sk = OCCSketch()
+    sk.add_external_polylines([list(p) for p in RECT])
+    center = sk.add_external_point(5.0, 5.0)
+    sk.add_circle(center, 2.0)
+    user = sk.add_point(5.0, 5.0)
+    assert sk.constrain_coincident(user, center)
+    assert sk.solve()
+
+    # Re-projection: same rectangle, circle moved + resized -> mixed list.
+    new_proj = [
+        list(p) for p in RECT
+    ] + [
+        {"type": "circle", "center": [6.0, 6.0], "radius": 1.5},
+    ]
+    old_ext_ids = set(sk._external_entity_ids)
+    assert sk.update_external_entities(new_proj), "rebuild + rebind solve failed"
+
+    c = _counts(sk)
+    assert c["circles"] == 1, f"duplicate circle entities: {c}"
+    assert c["ext_points"] == 5, f"ext point count wrong (expect 4 corners + 1 centre): {c}"
+    assert c["ext_lines"] == 4, f"ext line count wrong (expect 4): {c}"
+    assert c["user_points"] == 1
+    # The coincident rebind must anchor the user point to the NEW centre.
+    ux, uy = user.geometry
+    assert math.hypot(ux - 6.0, uy - 6.0) < 1e-6, f"user point at {(ux, uy)}"
+    # Rebuild path: fresh external ids.
+    assert not (old_ext_ids & sk._external_entity_ids)
+
+    # Idempotent second pass with the same projection.
+    assert sk.update_external_entities(list(new_proj)), "second pass failed"
+    c2 = _counts(sk)
+    assert c2 == c, f"counts changed on second pass: {c} -> {c2}"
+    ux, uy = user.geometry
+    assert math.hypot(ux - 6.0, uy - 6.0) < 1e-6
+    print("test_mixed_projection_rebuild OK")
+
+
+def test_polylines_only_inplace():
+    sk = OCCSketch()
+    sk.add_external_polylines([list(p) for p in RECT])
+    corner = None
+    for eid in sk._external_entity_ids:
+        ent = sk._entities[eid]
+        if ent.entity_type == "point" and ent.geometry == (0.0, 0.0):
+            corner = ent
+            break
+    assert corner is not None
+    user = sk.add_point(0.0, 0.0)
+    assert sk.constrain_coincident(user, corner)
+    assert sk.solve()
+
+    # Same topology, slightly shifted rectangle -> in-place move.
+    moved = [[(u + 1.0, v + 2.0) for (u, v) in poly] for poly in RECT]
+    old_ext_ids = set(sk._external_entity_ids)
+    assert sk.update_external_entities(moved), "in-place solve failed"
+    assert sk._external_entity_ids == old_ext_ids, "in-place path must keep ids"
+    ux, uy = user.geometry
+    assert math.hypot(ux - 1.0, uy - 2.0) < 1e-6, f"user point at {(ux, uy)}"
+    print("test_polylines_only_inplace OK")
+
+
+def test_arc_import_shares_corners():
+    """_import_external_curves must merge arc endpoints with existing
+    polyline corner points (no floating duplicate endpoints)."""
+    sk = OCCSketch()
+    # Rectangle with the top-right corner filleted: the arc endpoints must
+    # land on the truncated-edge corner points, not create new ones.
+    r = 2.0
+    sk.add_external_polylines([
+        [(0.0, 0.0), (10.0, 0.0)],
+        [(10.0, 0.0), (10.0, 10.0 - r)],
+        [(10.0 - r, 10.0), (0.0, 10.0)],
+        [(0.0, 10.0), (0.0, 0.0)],
+    ])
+    sk._import_external_curves(
+        [],
+        [
+            {
+                "type": "arc",
+                "center": [10.0 - r, 10.0 - r],
+                "start": [10.0, 10.0 - r],
+                "end": [10.0 - r, 10.0],
+                "radius": r,
+            },
+        ],
+    )
+    c = _counts(sk)
+    # 5 corners + 1 arc centre, NO extra endpoint entities.
+    assert c["ext_points"] == 6, f"expected 6 ext points, got {c}"
+    assert c["arcs"] == 1, f"expected 1 arc, got {c}"
+    assert sk.solve()
+    print("test_arc_import_shares_corners OK")
+
+
+if __name__ == "__main__":
+    test_mixed_projection_rebuild()
+    test_polylines_only_inplace()
+    test_arc_import_shares_corners()
+    print("UNDERLAY_CURVES_OK")

README.md

@@ -0,0 +1,111 @@
+# Fluency CAD 2.0
+
+A parametric CAD application built on OpenCASCADE Technology (OCCT) with a modern pygfx-based 3D renderer.
+
+## Features
+
+- **OpenCASCADE Geometry Kernel**: Industry-standard BRep geometry with exact precision
+- **STEP/IGES Import/Export**: Full support for industry-standard CAD file formats
+- **Parametric Sketching**: 2D sketching with constraint solving using SolveSpace
+- **Boolean Operations**: Union, difference, and intersection
+- **Fillet & Chamfer**: Apply edge treatments to solid bodies
+- **Modern Renderer**: WebGPU-based rendering with pygfx (smaller footprint than VTK)
+
+## Architecture
+
+```
+fluency/
+├── src/fluency/
+│   ├── geometry/           # Geometry abstraction layer
+│   │   └── base.py         # Abstract interfaces
+│   ├── geometry_occ/       # OpenCASCADE implementation
+│   │   ├── kernel.py       # OCGeometryKernel
+│   │   └── sketch.py       # OCCSketch with constraints
+│   ├── rendering/          # Rendering abstraction
+│   │   ├── base.py         # Abstract renderer
+│   │   └── pygfx_renderer.py
+│   ├── models/             # Data models
+│   │   └── data_model.py   # Project, Component, Sketch, Body
+│   └── main.py             # Application entry point
+├── tests/
+│   └── test_geometry.py
+└── pyproject.toml
+```
+
+## Installation
+
+```bash
+# Create virtual environment
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install dependencies
+pip install -e ".[dev]"
+```
+
+## Dependencies
+
+| Package | Purpose |
+|---------|---------|
+| cadquery-ocp | OpenCASCADE Python bindings (OCP) |
+| pygfx | WebGPU-based 3D renderer |
+| wgpu | WebGPU Python bindings |
+| PySide6 | Qt GUI framework |
+| numpy | Numerical computing |
+| scipy | Scientific computing |
+
+## Usage
+
+```bash
+# Run the application
+fluency-cad
+
+# Or directly
+python -m fluency.main
+```
+
+## API Example
+
+```python
+from fluency.geometry_occ.kernel import OCGeometryKernel
+from fluency.geometry.base import Point2D
+
+# Create kernel
+kernel = OCGeometryKernel()
+
+# Create a sketch
+points = [
+    Point2D(0, 0),
+    Point2D(10, 0),
+    Point2D(10, 10),
+    Point2D(0, 10),
+]
+polygon = kernel.create_polygon(points)
+
+# Extrude to 3D
+body = kernel.extrude(polygon, height=20.0)
+
+# Apply fillet
+body = kernel.fillet(body, radius=2.0)
+
+# Export to STEP
+kernel.export_step(body, "part.step")
+
+# Export to STL
+kernel.export_stl(body, "part.stl")
+```
+
+## Comparison: Before vs After
+
+| Aspect | Before (SDF + VTK) | After (OCC + pygfx) |
+|--------|-------------------|---------------------|
+| Geometry Precision | Approximate (mesh) | Exact (BRep) |
+| Export Formats | STL only | STEP, IGES, STL, BREP |
+| File Size | Large (mesh) | Small (BRep) |
+| Fillet/Chamfer | Approximate | Exact |
+| Dependency Size | ~200MB (VTK) | ~30MB (pygfx) |
+| Constraint Solver | SolveSpace (separate) | SolveSpace (integrated) |
+
+## License
+
+MIT License

WARP.md

@@ -1,147 +0,0 @@
-# WARP.md
-
-This file provides guidance to WARP (warp.dev) when working with code in this repository.
-
-## Project Overview
-Fluency is a CAD (Computer Aided Design) application built with Python/PySide6 that provides parametric 3D modeling through a timeline-based project system. The application combines 2D sketching with constraint solving, 3D visualization using VTK, and SDF (Signed Distance Function) based mesh generation.
-
-## Common Commands
-
-### Development Environment Setup
-```bash
-# Activate virtual environment (if exists)
-source .venv/bin/activate
-
-# Install dependencies
-pip install -r requirements.txt
-```
-
-### Running the Application
-```bash
-# Run the main application
-python main.py
-
-# Run with debugging
-python -u main.py
-```
-
-### UI Development
-```bash
-# Convert Qt Designer UI file to Python code
-pyside6-uic gui.ui > Gui.py -g python
-```
-
-### Building Executable
-The project uses Nuitka for compilation (configured in `main.py` header):
-```bash
-# Build standalone executable
-nuitka --standalone --plugin-enable=pyside6 --plugin-enable=numpy --macos-create-app-bundle main.py
-```
-
-### Testing
-```bash
-# Run mesh generation test
-python meshtest.py
-```
-
-## Architecture Overview
-
-### Core Components
-
-#### Main Application (`main.py`)
-- **MainWindow**: Central UI controller that manages all widgets and user interactions
-- **Project System**: Hierarchical structure: `Project → Timeline → Component → Sketch/Body`
-- **Signal-based Communication**: Qt signals coordinate between 2D sketching and 3D rendering
-
-#### Project Hierarchy
-```
-Project
-├── Timeline (list of Components)
-└── Component
-    ├── Sketches (dict)
-    ├── Bodies (dict) 
-    └── Connectors (for assembly)
-```
-
-#### Drawing Modules (`drawing_modules/`)
-- **SketchWidget** (`draw_widget_solve.py`): 2D parametric sketching with SolverSpace constraint solving
-- **VTKWidget** (`vtk_widget.py`): 3D visualization and mesh interaction using VTK
-- **PyVistaWidget** (`vysta_widget.py`): Alternative 3D rendering backend
-
-#### Mesh Generation (`mesh_modules/`)
-- **VESTA** (`vesta_mesh.py`): Multi-threaded SDF-to-mesh conversion using marching cubes
-- **Interactor Mesh** (`interactor_mesh.py`): Simplified edge-based meshes for 3D selection
-- **Simple Mesh** (`simple_mesh.py`): Basic mesh utilities
-
-### Data Flow Architecture
-
-#### 2D to 3D Pipeline
-1. **2D Sketching**: User draws in SketchWidget using Qt coordinate system
-2. **Constraint Solving**: SolverSpace resolves geometric constraints
-3. **SDF Generation**: Sketch converted to Signed Distance Functions for 3D operations
-4. **Mesh Generation**: VESTA generates triangle meshes from SDF using marching cubes
-5. **3D Rendering**: VTK displays both solid meshes and interactive edges
-
-#### Signal Flow (from `doc/flow.md`)
-- 2D QPoint → cartesian space → SolverSpace dict → constraint solving → display
-- 3D mesh selection → projection to 2D → sketch widget integration
-
-### Key Classes
-
-#### Core Data Structures
-- **Sketch**: 2D geometric data with origin, normal, points, and constraints
-- **Body**: 3D mesh representation containing SDF objects and interactor meshes  
-- **Component**: Container grouping related sketches and bodies
-- **Interactor**: Simplified edge-based mesh for 3D manipulation
-
-#### Constraint Solving
-The application uses `python_solvespace` for parametric constraint solving:
-- Point-to-point constraints
-- Distance constraints
-- Horizontal/vertical line constraints
-- Point-to-line constraints
-
-### Technology Stack
-- **GUI**: PySide6 (Qt for Python)
-- **3D Graphics**: VTK for rendering, PyVista as alternative
-- **Constraint Solving**: SolverSpace for parametric geometry
-- **Mesh Generation**: SDF library with custom VESTA marching cubes implementation
-- **Scientific Computing**: NumPy for mathematical operations
-
-## Development Workflow
-
-### Adding New Sketch Tools
-1. Add UI button in `gui.ui`
-2. Convert UI: `pyside6-uic gui.ui > Gui.py -g python`  
-3. Connect signal in `MainWindow.__init__()`
-4. Implement tool logic in `SketchWidget`
-
-### Adding New 3D Operations
-1. Extend operation buttons in the Modify group
-2. Implement operation logic using SDF functions
-3. Update Body creation and timeline management
-4. Handle interactor mesh generation for selection
-
-### Debugging Tips
-- Monitor solver results through `SolverSystem` status
-- Use VTK's built-in debugging for rendering issues
-- Check coordinate transformations between 2D sketch and 3D space
-- Verify SDF function outputs before mesh generation
-
-### File Structure
-- `main.py`: Application entry point and main window
-- `Gui.py`: Auto-generated UI code (do not edit directly)
-- `gui.ui`: Qt Designer UI definition file
-- `drawing_modules/`: 2D and 3D rendering widgets
-- `mesh_modules/`: Mesh generation and processing
-- `doc/`: Architecture and command documentation
-
-## Dependencies
-Primary external libraries:
-- `PySide6`: Qt GUI framework
-- `vtk`: 3D visualization toolkit
-- `python-solvespace`: Constraint solving
-- `sdf`: Signed Distance Function operations
-- `numpy`: Numerical computations
-- `scikit-image`: Marching cubes algorithm
-- `names`: Random name generation for sketches

agent.md

@@ -0,0 +1,219 @@
+# Fluency CAD — Agent Guide
+
+## Project Overview
+
+**Fluency CAD 2.0** is a parametric CAD application built on **OpenCASCADE Technology (OCCT)** with a modern **pygfx-based 3D renderer**. It provides 2D sketching with SolveSpace constraint solving, boolean operations, STEP/IGES/STL import/export, and exact BRep geometry.
+
+- Language: **Python 3.10+**
+- GUI: **PySide6** (Qt6)
+- Geometry Kernel: **OCP** (cadquery-ocp — OpenCASCADE Python bindings)
+- Constraint Solver: **python_solvespace**
+- Renderer: **pygfx** (WebGPU) + **OCCRenderer** (native OCC AIS display)
+
+---
+
+## Architecture
+
+```
+src/fluency/
+├── __init__.py              # Package entry (version, imports)
+├── main.py                  # Application entry point, MainWindow, Sketch2DWidget (~5000 lines)
+├── sketch_solver.py         # SolveSpace constraint solver wrapper (legacy)
+├── geometry/
+│   └── base.py              # Abstract interfaces: GeometryKernel, SketchInterface, data classes
+├── geometry_occ/
+│   ├── kernel.py            # OCGeometryKernel (extrude, boolean, fillet, import/export, mesh)
+│   └── sketch.py            # OCCSketch with SolveSpace integration (face detection, constraints)
+├── models/
+│   └── data_model.py        # Project, Component, Sketch, Body dataclasses
+├── rendering/
+│   ├── base.py              # Abstract Renderer interface
+│   ├── occ_renderer.py      # OCC AIS renderer (preferred — smooth BRep display)
+│   └── pygfx_renderer.py    # Legacy pygfx renderer
+├── utils/                   # Utility modules
+└── widgets/                 # Custom widgets
+tests/
+└── test_geometry.py         # Comprehensive test suite (52+ tests)
+```
+
+### Key Classes & Responsibilities
+
+| Class | File | Purpose |
+|-------|------|---------|
+| `OCGeometryKernel` | `kernel.py` | OCC shape ops: extrude, boolean, fillet, mesh, import/export |
+| `OCCSketch` | `sketch.py` | 2D sketch with SolveSpace solver, face detection, workplane |
+| `OCCSketchEntity` | `sketch.py` | Entity (point/line/circle/arc) with solver handle, is_construction, is_external |
+| `Sketch2DWidget` | `main.py` | Qt widget for interactive 2D sketching (draw, snap, constrain) |
+| `MainWindow` | `main.py` | Main application window, toolbars, 3D viewer, operations |
+| `OCCRenderer` | `occ_renderer.py` | Native OCC AIS display (shaded + edges, face pick) |
+| `Sketch` | `data_model.py` | Data model: workplane, occ_sketch ref, source_body_id |
+| `Body` | `data_model.py` | 3D solid with geometry, visibility, render object |
+| `Component` | `data_model.py` | Container for sketches and bodies |
+| `Project` | `data_model.py` | Top-level container with kernel |
+
+### Data Flow
+
+```
+User draws in Sketch2DWidget
+  → OCCSketch entities created in solver
+  → Constraint solving (python_solvespace)
+  → OCCSketch.get_geometry() → detect_faces() → build_face_geometry()
+  → OCGeometryKernel.extrude() → BRepPrimAPI_MakePrism
+  → Boolean operations → Body added to Component
+  → OCCRenderer.add_shape() → AIS display
+```
+
+---
+
+## Development Commands
+
+```bash
+# Install editable
+pip install -e ".[dev]"
+
+# Run app
+python -m fluency.main
+
+# Run tests (52 tests)
+python -m pytest tests/test_geometry.py -v
+
+# Run single test
+python -m pytest tests/test_geometry.py::TestOCCSketch::test_workplane_extrude_with_hole -xvs
+
+# Quck geometry test (raw OCC, no Qt)
+python -c "from fluency.geometry_occ.sketch import OCCSketch; ..."
+```
+
+---
+
+## Code Conventions
+
+### General
+- Line length: **100 chars** (black/ruff config)
+- Target Python: **3.10+** (uses `from __future__ import annotations`, walrus, pattern matching)
+- Docstrings: Google/NumPy style preferred
+- Logging: `logger = logging.getLogger(__name__)` with `logging.DEBUG` level
+
+### OCC / OCP
+- Always use `is not None` for OCP objects — `TopoDS_Shape.__bool__` can be falsy even for valid shapes
+- `BRepBuilderAPI_MakeFace.Add(wire)` expects a `TopoDS_Wire`. `wire.Reversed()` returns `TopoDS_Shape` → cast via `_TopoDS.Wire_s(wire.Reversed())`
+- Face normal direction: check `face.Orientation()` vs `TopAbs_REVERSED` — a REVERSED face's outward normal is the NEGATION of the surface axis
+- `TopoDS_Wire_s(shape)`, `TopoDS_Face_s(shape)` — use `_s` suffix from OCP for downcasts
+- Mesh: `BRepMesh_IncrementalMesh(shape, tol, False, 0.15, True)` — default deflection 0.15 rad for smooth curves
+
+### Extrude / Cut Workflow
+- Snapshot `list(self._current_component.bodies.items())` **BEFORE** `add_body()` — the new body must not be in the target set
+- Cut targets the **source body** (`sketch._source_body_id` from face pick), not `bodies[0]`
+- The fix: apply boolean to **target** geometry, then remove tool body
+- Plain extrude with holes: inner wires must have **OPPOSITE** geometric winding to the outer wire (see `build_face_geometry` and `_loop_signed_area`)
+
+### Sketch / Solvers
+- `python_solvespace` has NO remove API for entities/constraints. Deleting requires: drop from `_points`/`_lines`, prune `_constraint_log`, `_rebuild_solver()` (recreates entire system), `_rebuild_labels()`, re-solve
+- `_constraint_log`: each entry is `{"type": str, "ids": tuple[int,...], "params": tuple, "labels": set[str]}`
+- Constraint labels: stored on **point** entities for paintEvent rendering; rebuilt via `_rebuild_labels()`
+- Line constraints (`horizontal`/`vertical`/`parallel`/`perpendicular`) need the **line's** solver handle, not a point's. Use `_find_line_sketch_entity()` to get the correct handle
+- External entities (underlay): `is_external=True`, `is_construction=True`, fixed in solver (always `dragged`). Stored in `_external_entity_ids`, excluded from `_line_segments()`, `get_polygon_points()`, `get_closed_loops()`, `detect_faces()`, `get_geometry()`
+
+### Face Detection
+- `get_closed_loops()`: uses snapped-coordinate graph (`_SNAP_TOL = 1e-4`) from line endpoint adjacency. Only accepts simple cycles (all nodes degree 2)
+- `detect_faces()`: even-odd nesting rule via `_loop_contains`. Even depth = outer boundary, odd = hole
+- `_loop_rep_point`: midpoint between centroid and first vertex. **Fragile** — can land inside a nested shape for certain geometries (e.g., a small hole near the centroid's direction from the first vertex)
+- `_loop_signed_area`: shoelace formula for polygons, `πr²` (positive = CCW) for circles
+
+### Rendering
+- **OCCRenderer** is the main renderer (not pygfx). Uses `AIS_Shape`, `V3d_Viewer`, `AIS_InteractiveContext`
+- Face pick: `pick_planar_face(x, y)` → `MoveTo` → `DetectedShape` → `TopoDS_Face_s` → `BRepAdaptor_Surface` plane check
+- Highlight: `highlight_face(face)` creates a transparent AIS overlay; `clear_face_highlight()` removes it
+- Preview: `preview_shape(shape)` for live transparent extrude preview
+- Navigation: Left=orbit, Middle=pan, Wheel=zoom. **Right is RESERVED** — check user before reassigning
+
+### Paint-Event Safety
+- Every constraint-tag rendering loop wraps each entry in `try/except` so a bad entry (dangling id, corrupted geometry) doesn't crash the entire paint event
+- `_point_world()` and `_entity_anchor()` return `None` (not raise) for malformed input
+
+---
+
+## Known Bugs & Fix Patterns
+
+### 1. Hole Orientation in Extrusion (FIXED 2026-07-03)
+**Symptom**: Inner shapes (circle/triangle/slot) inside a rectangle become solid islands instead of holes when extruding, depending on drag direction.
+
+**Root Cause**: `wire_loop` in `build_face_geometry` unconditionally reversed hole wires (`w.Reversed()`). When the outer polygon was CW-winding (e.g., dragging from top-left to bottom-right), the reversed inner had the SAME effective direction as the outer, making OCC treat it as solid.
+
+**Fix**: Added `_loop_signed_area()` to compute geometric winding. Hole wires are only reversed when their natural winding matches the outer's (ensuring opposite winding for holes).
+
+**Relevant code**: `sketch.py`, `build_face_geometry()` and `_loop_signed_area()`
+
+### 2. _loop_rep_point Fragility (KNOWN)
+**Symptom**: Face detection fails when a nested shape contains the outer loop's representative point (midpoint between centroid and first vertex).
+
+**Would-be fix**: Use a guaranteed-interior point (maximum inscribed circle center or perturbed centroid) instead of the centroid-first-vertex midpoint.
+
+### 3. Extrude Cut / Target Selection (FIXED 2026-06-29)
+**Symptom**: Cut created a separate "cavity-shaped" body next to the original instead of modifying the target.
+
+**Fix**: Boolean result stored on TARGET body geometry; tool body removed from component. Auto-target via `sketch._source_body_id`.
+
+### 4. Workplane Preservation (FIXED 2026-06-29)
+**Symptom**: Sketch placed on a face lost its workplane after being added to component.
+
+**Fix**: Copy `occ_sketch` workplane fields into `Sketch` dataclass BEFORE `apply_workplane()`.
+
+---
+
+## API Quirks
+
+- **`QPoint(0,0)`**: falsy via `isNull()` in PySide6 → always use `is not None` for `Optional[QPoint]`
+- **`QMouseEvent`/`QPainterPath`**: live in `PySide6.QtGui` (NOT `QtCore`)
+- **`BRepBuilderAPI_MakeFace.Add()`**: needs `TopoDS_Wire`. `wire.Reversed()` returns `TopoDS_Shape` — cast via `TopoDS_Wire_s()`
+- **python_solvespace**: NO entity/constraint remove API — workaround via `_rebuild_solver()`. Parameters read via `solver.params(handle.params)` → returns `(x, y)` tuple
+- **OCGeometryKernel.extrude**: unwraps `OCCGeometryObject`, raw `TopoDS_Shape`, or cadquery `Workplane`. Always use `is not None` for the shape (not truthiness)
+- **Sketch._source_body_id**: dynamic attribute set on `Sketch` dataclass, set during face-pick flow
+- **`_get_shape(obj)`**: returns `obj.shape.wrapped` for `OCCGeometryObject`, `obj.shape` for raw shapes, `None` for empty. Use `is not None` guards everywhere
+
+---
+
+## Memory / Agent Context
+
+This project has extensive Pi memory (hermes-memory) for:
+- `project="fluency"` with `target="failure"`: bugs, fixes, corrections, insights
+- `project="fluency"` with `target="memory"`: conventions, decisions, workflow patterns
+- Available skills: `fix-cad-app-pipeline`, `refactor-from-cadquery-to-ocp`
+
+Key memory queries for debugging:
+- "hole orientation" → `_loop_signed_area` / `build_face_geometry` fix
+- "extrude cut auto-target" → cut/target body fix
+- "workplane preservation" → _add_sketch_to_component fix
+- "_loop_rep_point" → face detection fragility
+- "paint-event safety" → try/except per entry pattern
+- "solver rebuild" → delete workflow via _rebuild_solver
+- "face pick origin" → pick_planar_face face bbox centre
+
+---
+
+## Testing Patterns
+
+```python
+# Direct OCC test (no Qt)
+from OCP.BRepBuilderAPI import BRepBuilderAPI_MakePolygon, BRepBuilderAPI_MakeFace
+from OCP.gp import gp_Pnt
+from OCP.BRepPrimAPI import BRepPrimAPI_MakePrism
+from OCP.GProp import GProp_GProps; from OCP.BRepGProp import BRepGProp
+
+# Build test shape, extrude, verify volume
+mp = BRepBuilderAPI_MakePolygon(); ...
+g = GProp_GProps(); BRepGProp.VolumeProperties_s(shape, g)
+assert abs(g.Mass() - expected) < 0.1
+```
+
+```python
+# Sketch-based test
+from fluency.geometry_occ.sketch import OCCSketch
+from fluency.geometry_occ.kernel import OCGeometryKernel
+
+sk = OCCSketch()
+# ... add points, lines, circles ...
+sk.solve()
+geom = sk.get_geometry()
+solid = OCGeometryKernel().extrude(geom, 10.0)
+```

doc/SKETCHER_TECHNICAL_DOCUMENTATION.md

@@ -1,849 +0,0 @@
-# Fluency CAD - Improved Sketcher Technical Documentation
-
-## Table of Contents
-1. [Overview](#overview)
-2. [Architecture](#architecture)
-3. [Core Components](#core-components)
-4. [Geometry System](#geometry-system)
-5. [Constraint Solving](#constraint-solving)
-6. [Coordinate Systems](#coordinate-systems)
-7. [Interaction System](#interaction-system)
-8. [Rendering System](#rendering-system)
-9. [Snapping System](#snapping-system)
-10. [Working Plane Integration](#working-plane-integration)
-11. [API Reference](#api-reference)
-12. [Performance Considerations](#performance-considerations)
-13. [Troubleshooting](#troubleshooting)
-
-## Overview
-
-The ImprovedSketchWidget is a parametric 2D sketching system built for Fluency CAD. It provides constraint-based geometric modeling with real-time solving, integrated snapping, and seamless integration with 3D working planes. The system is built on top of the SolverSpace constraint solver and PySide6 for the user interface.
-
-### Key Features
-- **Parametric Geometry**: All geometry is constraint-driven and automatically updates
-- **Real-time Solving**: Constraints are solved dynamically as geometry is modified
-- **Advanced Snapping**: Multi-mode snapping system (points, midpoints, grid, angles)
-- **Construction Geometry**: Support for helper/construction geometry
-- **Working Plane Integration**: Seamless 2D/3D workflow with projected geometry
-- **Interactive Dragging**: Smooth point dragging with constraint preservation
-- **Multiple Drawing Modes**: Lines, rectangles, circles, arcs, and points
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────┐
-│                ImprovedSketchWidget                     │
-│  ┌─────────────────┐  ┌─────────────────────────────┐   │
-│  │   User Interface │  │      Rendering System      │   │
-│  │   - Mouse Events │  │   - Coordinate Transform    │   │
-│  │   - Keyboard     │  │   - Geometry Drawing       │   │
-│  │   - Mode Control │  │   - UI Overlays            │   │
-│  └─────────────────┘  └─────────────────────────────┘   │
-│           │                         │                   │
-│           └─────────┬───────────────┘                   │
-│                     │                                   │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │            Interaction System               │   │
-│  │  - Snapping Engine                             │   │
-│  │  - Dragging Logic                              │   │
-│  │  - Selection Management                        │   │
-│  └─────────────────────────────────────────────────┘   │
-│                     │                                   │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │              Geometry System                   │   │
-│  │  ┌─────────────┐  ┌─────────────────────────┐   │   │
-│  │  │ Point2D     │  │      Line2D             │   │   │
-│  │  │ Circle2D    │  │      Arc2D (future)     │   │   │
-│  │  └─────────────┘  └─────────────────────────┘   │   │
-│  └─────────────────────────────────────────────────┘   │
-│                     │                                   │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │            ImprovedSketch                      │   │
-│  │  (Enhanced SolverSystem)                       │   │
-│  │  - Constraint Management                       │   │
-│  │  - Solver Integration                          │   │
-│  │  - Geometry Storage                            │   │
-│  └─────────────────────────────────────────────────┘   │
-│                     │                                   │
-│  ┌─────────────────────────────────────────────────┐   │
-│  │          SolverSpace Library                   │   │
-│  │  - Constraint Solving Engine                   │   │
-│  │  - Geometric Relationships                     │   │
-│  └─────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────┘
-```
-
-## Core Components
-
-### 1. ImprovedSketchWidget
-The main widget class that handles user interaction and rendering.
-
-**Key Responsibilities:**
-- Mouse and keyboard event handling
-- Mode management (line, circle, constraint modes, etc.)
-- Coordinate system transformations
-- Rendering pipeline orchestration
-- Integration with external systems (working planes)
-
-### 2. ImprovedSketch
-Enhanced wrapper around SolverSpace's SolverSystem.
-
-**Key Responsibilities:**
-- Geometry storage and management
-- Constraint system integration
-- Solver result processing
-- Handle management for solver objects
-
-### 3. Geometry Classes
-Type-safe geometry representations with validation.
-
-**Classes:**
-- `Point2D`: 2D points with solver integration
-- `Line2D`: 2D lines with constraint tracking
-- `Circle2D`: 2D circles with radius constraints
-
-## Geometry System
-
-### Point2D Class
-```python
-class Point2D:
-    def __init__(self, x: float, y: float, is_construction: bool = False):
-        self.id = uuid.uuid4()           # Unique identifier
-        self.x = float(x)                # X coordinate
-        self.y = float(y)                # Y coordinate
-        self.ui_point = QPoint(int(x), int(y))  # Qt UI point
-        self.handle = None               # SolverSpace handle
-        self.handle_nr = None            # Handle number
-        self.is_helper = is_construction # Construction geometry flag
-```
-
-**Key Features:**
-- Automatic coordinate validation
-- SolverSpace handle integration
-- Construction/normal geometry support
-- Distance calculations and equality testing
-
-### Line2D Class
-```python
-class Line2D:
-    def __init__(self, start_point: Point2D, end_point: Point2D, is_construction: bool = False):
-        self.id = uuid.uuid4()
-        self.start = start_point         # Start point reference
-        self.end = end_point            # End point reference
-        self.handle = None              # SolverSpace handle
-        self.constraints = []           # Applied constraints list
-        self.is_helper = is_construction
-```
-
-**Key Features:**
-- Automatic degenerate line detection
-- Length, midpoint, and angle calculations
-- Point-on-line testing with tolerance
-- Constraint tracking and annotation
-
-### Circle2D Class
-```python
-class Circle2D:
-    def __init__(self, center: Point2D, radius: float, is_construction: bool = False):
-        self.id = uuid.uuid4()
-        self.center = center            # Center point reference
-        self.radius = float(radius)     # Radius value
-        self.handle = None              # SolverSpace handle
-        self.constraints = []           # Applied constraints
-        self.is_helper = is_construction
-```
-
-## Constraint Solving
-
-### SolverSpace Integration
-
-The system uses the `python-solvespace` library for constraint solving. The `ImprovedSketch` class wraps the SolverSpace API and provides:
-
-1. **Automatic Handle Management**: Each geometry object gets a unique handle
-2. **Error Handling**: Robust error handling for solver failures
-3. **Position Updates**: Automatic geometry position updates after solving
-
-### Constraint Types
-
-#### Geometric Constraints
-- **Coincident**: Point-to-point or point-to-line coincidence
-- **Horizontal**: Forces lines to be horizontal
-- **Vertical**: Forces lines to be vertical
-- **Distance**: Fixes distance between points or line length
-- **Parallel**: Makes lines parallel (future implementation)
-- **Perpendicular**: Makes lines perpendicular (future implementation)
-
-#### Constraint Application Workflow
-```python
-def _handle_distance_constraint(self, pos: QPoint):
-    line = self.sketch.get_line_near(pos)
-    if line and line.handle:
-        # Get user input for distance
-        distance, ok = QInputDialog.getDouble(...)
-        if ok:
-            # Apply constraint to solver
-            self.sketch.distance(line.start.handle, line.end.handle, distance, self.sketch.wp)
-            # Solve system
-            result = self.sketch.solve_system()
-            if result == ResultFlag.OKAY:
-                line.constraints.append(f"L={distance:.2f}")
-```
-
-### Solver Workflow
-
-1. **Constraint Addition**: Constraints are added to the solver system
-2. **System Solving**: The solver attempts to find a valid solution
-3. **Result Processing**: If successful, geometry positions are updated
-4. **UI Updates**: The display is refreshed to show new positions
-
-## Coordinate Systems
-
-The sketcher uses multiple coordinate systems that must be properly transformed between:
-
-### 1. Sketch Coordinates (Local)
-- Origin at sketch center
-- Y-axis points up (mathematical convention)
-- Units in millimeters
-- Range: typically -1000 to +1000
-
-### 2. Viewport Coordinates (Screen)
-- Origin at top-left of widget
-- Y-axis points down (computer graphics convention)
-- Units in pixels
-- Range: 0 to widget dimensions
-
-### 3. Working Plane Coordinates (3D)
-- 3D coordinates projected onto 2D working plane
-- Transformation handled by external VTK system
-- Converted to sketch coordinates for display
-
-### Coordinate Transformations
-
-#### Viewport to Local (Mouse Input)
-```python
-def _viewport_to_local(self, viewport_pos: QPoint) -> QPoint:
-    # Step 1: Subtract widget center
-    center_x = self.width() / 2
-    center_y = self.height() / 2
-    
-    # Step 2: Apply pan offset
-    viewport_x = viewport_pos.x() - center_x - (self.pan_offset.x() * self.zoom_factor)
-    viewport_y = viewport_pos.y() - center_y - (self.pan_offset.y() * self.zoom_factor)
-    
-    # Step 3: Apply inverse zoom and Y-flip
-    local_x = viewport_x / self.zoom_factor
-    local_y = -viewport_y / self.zoom_factor
-    
-    return QPoint(int(local_x), int(local_y))
-```
-
-#### Rendering Transform Setup
-```python
-def _setup_coordinate_system(self, painter: QPainter):
-    transform = QTransform()
-    
-    # Translate to center and apply pan
-    center = QPointF(self.width() / 2, self.height() / 2)
-    transform.translate(center.x() + self.pan_offset.x() * self.zoom_factor, 
-                      center.y() + self.pan_offset.y() * self.zoom_factor)
-    
-    # Apply zoom and flip Y-axis
-    transform.scale(self.zoom_factor, -self.zoom_factor)
-    
-    painter.setTransform(transform)
-```
-
-## Interaction System
-
-### Mode-Based Interaction
-
-The sketcher supports multiple interaction modes with robust mode management:
-
-#### Drawing Modes
-- `SketchMode.LINE`: Two-point line creation
-- `SketchMode.RECTANGLE`: Two-corner rectangle creation
-- `SketchMode.CIRCLE`: Center-radius circle creation
-- `SketchMode.POINT`: Single point creation
-
-#### Constraint Modes
-- `SketchMode.COINCIDENT_PT_PT`: Point-to-point coincidence
-- `SketchMode.HORIZONTAL`: Horizontal line constraint
-- `SketchMode.VERTICAL`: Vertical line constraint
-- `SketchMode.DISTANCE`: Distance/length constraint
-
-#### Selection Mode
-- `SketchMode.NONE`: Selection and manipulation mode (enables point dragging)
-
-### Selection and Deletion System
-
-The sketcher now includes a comprehensive selection and deletion system that allows users to select and remove elements from the sketch.
-
-#### Selection Methods
-
-1. **Single Element Selection**: Click on individual points or lines to select/deselect them
-2. **Rectangle Selection**: Click and drag to create a selection rectangle for multiple elements
-3. **Visual Feedback**: Selected elements are highlighted in yellow with increased size
-
-#### Deletion Methods
-
-1. **Keyboard Deletion**: Press Delete or Backspace to remove selected elements
-2. **Proper Cleanup**: Elements are removed from both the sketch and constraint solver
-3. **Dependency Handling**: Lines are deleted before points to maintain geometric integrity
-
-#### Implementation Details
-
-The selection system is implemented through the following components:
-
-- **Selection Tracking**: `selected_elements` list tracks currently selected elements
-- **Rectangle Selection**: `selection_rect_start` and `selection_rect_end` track rectangle selection bounds
-- **Visual Feedback**: Modified drawing methods highlight selected elements in yellow
-- **Keyboard Support**: `keyPressEvent` handles Delete/Backspace keys
-- **Deletion Method**: `delete_selected_elements` handles removal of elements from sketch and solver
-
-#### Selection Workflow
-
-1. **Default Selection Mode**: The sketcher defaults to selection mode when no drawing tool is active
-2. **Element Selection**:
-   - Click on points or lines to select/deselect them (they turn yellow)
-   - Click and drag to create a rectangle selection for multiple elements
-3. **Element Deletion**:
-   - Press Delete or Backspace to remove all selected elements
-   - Elements are removed from both the sketch and constraint solver
-4. **Visual Feedback**:
-   - Selected elements are highlighted in yellow
-   - Rectangle selection is shown with a yellow dashed border
-
-#### Constraints Handling
-
-When elements are deleted:
-- Lines are removed first to avoid issues with points being used by lines
-- Points are only removed if they are not used by any remaining lines
-- The constraint solver is re-run after deletion to update remaining constraints
-- Proper error handling ensures the UI remains responsive even if solver operations fail
-
-### Mode Management System
-
-The mode system has been enhanced to provide intuitive selection and deletion functionality:
-
-#### Mode Compatibility
-- Python `None` is automatically converted to `SketchMode.NONE` for backward compatibility
-- The `set_mode()` method ensures the mode is always a valid `SketchMode` enum value
-- Mode changes reset all interaction buffers and state
-
-#### Default Selection Behavior
-- `SketchMode.NONE` now serves as the default selection mode
-- When no drawing tool is active, the sketcher is in selection mode by default
-- Users can click on elements to select/deselect them (they turn yellow)
-- Users can click and drag to create rectangle selections
-- Pressing Delete or Backspace removes all selected elements
-
-#### Right-Click Behavior
-- Right-clicking **always** exits any active mode and returns to `SketchMode.NONE`
-- This enables point dragging and prevents unintended geometry creation
-- The mode reset happens directly in the sketcher, not through main app signals
-
-#### Point Dragging Safety
-- Point dragging is **only** enabled when in `SketchMode.NONE` mode
-- Left-clicks in `NONE` mode check for draggable points first
-- If no point is found, the click is processed as a selection operation
-
-### Mouse Event Handling
-
-#### Click Processing Flow
-```python
-def mousePressEvent(self, event):
-    local_pos = self._viewport_to_local(event.pos())
-    
-    if event.button() == Qt.LeftButton:
-        self._handle_left_click(local_pos)
-    elif event.button() == Qt.RightButton:
-        self._handle_right_click(local_pos)
-    elif event.button() == Qt.MiddleButton:
-        self._start_panning(event.pos())
-```
-
-#### Enhanced Left-Click Handler
-```python
-def _handle_left_click(self, pos: QPoint):
-    # Safety check for NONE mode (dragging enabled)
-    if self.current_mode == SketchMode.NONE or self.current_mode is None:
-        point = self.sketch.get_point_near(pos, self.snap_settings.snap_distance)
-        if point:
-            self._start_point_drag(point, pos)
-            return
-        else:
-            # No point found - ignore click to prevent unintended drawing
-            return
-    
-    # Handle active drawing/constraint modes
-    if self.current_mode == SketchMode.LINE:
-        self._handle_line_creation(pos)
-    elif self.current_mode == SketchMode.HORIZONTAL:
-        self._handle_horizontal_constraint(pos)
-    # ... other modes
-```
-
-#### Right-Click Mode Reset
-```python
-def _handle_right_click(self, pos: QPoint):
-    # Reset interaction state
-    self._reset_interaction_state()
-    
-    # Force mode to NONE to enable dragging
-    self.current_mode = SketchMode.NONE
-    
-    # Emit signal to inform main app
-    self.constraint_applied.emit()
-```
-
-### Point Dragging System
-
-The point dragging system is optimized for performance and maintains constraint consistency:
-
-#### Drag Phases
-
-1. **Drag Start** (`_start_point_drag`):
-   - Identifies dragged point
-   - Stores initial position
-   - Sets dragging state
-
-2. **Drag Update** (`_handle_point_drag`):
-   - Updates point visual position only
-   - Applies snapping
-   - No solver execution (for performance)
-
-3. **Drag End** (`_end_point_drag`):
-   - Updates solver parameters with final position
-   - Runs constraint solver
-   - Updates all connected geometry
-   - Resets drag state
-
-```python
-def _end_point_drag(self):
-    if not self.dragging_point:
-        return
-    
-    # Update solver parameters with final position
-    if self.dragging_point.handle:
-        new_x = self.dragging_point.x
-        new_y = self.dragging_point.y
-        self.sketch.set_params(self.dragging_point.handle.params, [new_x, new_y])
-    
-    # Run solver to update all connected geometry
-    result = self.sketch.solve_system()
-    if result == ResultFlag.OKAY:
-        self.sketch_modified.emit()
-```
-
-## Rendering System
-
-### Rendering Pipeline
-
-The rendering system uses Qt's QPainter with a multi-layer approach:
-
-1. **Coordinate System Setup**: Apply zoom, pan, and Y-flip transforms
-2. **Background Rendering**: Grid, axes, and origin marker
-3. **Geometry Rendering**: Points, lines, circles with proper styling
-4. **Dynamic Elements**: Preview geometry during creation
-5. **UI Overlays**: Mode indicators, measurements, snap highlights
-
-### Rendering Layers
-
-#### Layer 1: Background
-- Coordinate axes (dashed gray lines)
-- Grid (if enabled)
-- Origin marker (red circle)
-
-#### Layer 2: Geometry
-- Construction geometry (green, dotted)
-- Normal geometry (gray, solid)
-- Constraint annotations
-
-#### Layer 3: Interactive Elements
-- Hover highlights (red)
-- Dynamic previews (gray, dashed)
-- Measurements during creation
-
-#### Layer 4: UI Overlays
-- Snap point indicators
-- Mode and zoom information
-- Status messages
-
-### Styling System
-
-Rendering appearance is controlled by the `RenderSettings` class:
-
-```python
-@dataclass
-class RenderSettings:
-    normal_pen_width: float = 2.0
-    construction_pen_width: float = 1.0
-    highlight_pen_width: float = 3.0
-    
-    normal_color = QColor(128, 128, 128)      # Gray
-    construction_color = QColor(0, 255, 0)    # Green
-    highlight_color = QColor(255, 0, 0)       # Red
-    solver_color = QColor(0, 255, 0)          # Green
-    dynamic_color = QColor(128, 128, 128)     # Gray
-    text_color = QColor(255, 255, 255)        # White
-```
-
-### Dynamic Previews
-
-During geometry creation, dynamic previews show:
-- **Line Creation**: Dashed line from start to cursor with length annotation
-- **Rectangle Creation**: Dashed rectangle outline
-- **Circle Creation**: Dashed circle with radius line and annotation
-
-## Snapping System
-
-### Snap Modes
-
-The snapping system supports multiple simultaneous snap modes:
-
-#### SnapMode.POINT
-- Snaps to existing geometry points
-- Priority: Highest
-- Visual: Red circle highlight
-
-#### SnapMode.MIDPOINT
-- Snaps to line midpoints
-- Priority: Medium
-- Visual: Red diamond highlight
-
-#### SnapMode.GRID
-- Snaps to grid intersections
-- Priority: Lowest
-- Visual: Green cross highlight
-
-#### SnapMode.HORIZONTAL/VERTICAL
-- Angular snapping (future implementation)
-- Constrains to horizontal/vertical directions
-
-#### SnapMode.INTERSECTION
-- Snaps to line intersections (future implementation)
-
-### Snap Algorithm
-
-```python
-def _get_snapped_position(self, pos: QPoint) -> QPoint:
-    min_distance = float('inf')
-    snapped_pos = pos
-    snap_threshold = self.snap_settings.snap_distance
-    
-    # Point snapping (highest priority)
-    if SnapMode.POINT in self.snap_settings.enabled_modes:
-        for point in self.sketch.points:
-            distance = math.sqrt((pos.x() - point.x)**2 + (pos.y() - point.y)**2)
-            if distance < snap_threshold and distance < min_distance:
-                snapped_pos = QPoint(int(point.x), int(point.y))
-                min_distance = distance
-    
-    # Midpoint snapping (medium priority)
-    if SnapMode.MIDPOINT in self.snap_settings.enabled_modes and min_distance > snap_threshold:
-        for line in self.sketch.lines:
-            midpoint = line.midpoint
-            distance = math.sqrt((pos.x() - midpoint.x)**2 + (pos.y() - midpoint.y)**2)
-            if distance < snap_threshold and distance < min_distance:
-                snapped_pos = QPoint(int(midpoint.x), int(midpoint.y))
-                min_distance = distance
-    
-    return snapped_pos
-```
-
-### Snap Settings
-
-```python
-@dataclass
-class SnapSettings:
-    snap_distance: float = 20.0      # Snap threshold in pixels
-    angle_increment: float = 15.0    # Angular snap increment
-    grid_spacing: float = 50.0       # Grid spacing
-    enabled_modes: Set[SnapMode]     # Active snap modes
-```
-
-## Working Plane Integration
-
-### Projected Geometry Workflow
-
-The sketcher integrates with 3D working planes through projected geometry:
-
-1. **3D Geometry Selection**: User selects 3D lines/points in VTK widget
-2. **Plane Definition**: System computes working plane from selections
-3. **Geometry Projection**: 3D geometry is projected onto 2D working plane
-4. **Sketch Import**: Projected geometry is imported as construction geometry
-
-### Projection Import Methods
-
-#### `convert_proj_points(proj_points)`
-Imports projected 3D points as 2D construction points:
-```python
-def convert_proj_points(self, proj_points):
-    for point_data in proj_points:
-        if hasattr(point_data, 'x') and hasattr(point_data, 'y'):
-            point = Point2D(point_data.x, point_data.y, True)  # Construction
-            self.sketch.add_point(point)
-```
-
-#### `convert_proj_lines(proj_lines)`
-Imports projected 3D lines as 2D construction lines:
-```python
-def convert_proj_lines(self, proj_lines):
-    for line_data in proj_lines:
-        # Handle object format
-        if hasattr(line_data, 'start') and hasattr(line_data, 'end'):
-            x1, y1 = line_data.start.x, line_data.start.y
-            x2, y2 = line_data.end.x, line_data.end.y
-            
-            # Skip degenerate lines
-            if abs(x1 - x2) < 1e-6 and abs(y1 - y2) < 1e-6:
-                continue
-            
-            start = Point2D(x1, y1, True)
-            end = Point2D(x2, y2, True)
-            self.sketch.add_point(start)
-            self.sketch.add_point(end)
-            line = Line2D(start, end, True)
-            self.sketch.add_line(line)
-```
-
-### Construction vs Normal Geometry
-
-- **Construction Geometry**: 
-  - Rendered in green with dotted lines
-  - Used for reference and alignment
-  - Created from projected 3D geometry
-  - Flag: `is_construction=True`
-
-- **Normal Geometry**: 
-  - Rendered in gray with solid lines
-  - Part of the actual sketch design
-  - Created by user drawing actions
-  - Flag: `is_construction=False`
-
-## API Reference
-
-### Main Widget Class
-
-#### ImprovedSketchWidget
-
-**Initialization:**
-```python
-widget = ImprovedSketchWidget()
-widget.show()
-```
-
-**Mode Control:**
-```python
-# Set drawing modes
-widget.set_mode(SketchMode.LINE)
-widget.set_mode(SketchMode.NONE)  # Enable selection/dragging
-widget.set_mode(None)  # Also converted to SketchMode.NONE
-
-# Construction geometry
-widget.set_construction_mode(True)
-```
-
-**Snapping Control:**
-```python
-widget.set_snap_mode(SnapMode.POINT, True)
-widget.toggle_snap_mode(SnapMode.MIDPOINT, enabled)
-```
-
-**View Control:**
-```python
-widget.zoom_to_fit()
-```
-
-**Sketch Access:**
-```python
-sketch = widget.get_sketch()
-widget.set_sketch(imported_sketch)
-```
-
-### Sketch Management
-
-#### ImprovedSketch
-
-**Geometry Addition:**
-```python
-sketch = ImprovedSketch()
-point = Point2D(10, 20)
-line = Line2D(start_point, end_point)
-circle = Circle2D(center_point, radius)
-
-sketch.add_point(point)
-sketch.add_line(line)
-sketch.add_circle(circle)
-```
-
-**Constraint Application:**
-```python
-# Distance constraint
-sketch.distance(point1.handle, point2.handle, 50.0, sketch.wp)
-
-# Coincident constraint
-sketch.coincident(point1.handle, point2.handle, sketch.wp)
-
-# Line constraints
-sketch.horizontal(line.handle, sketch.wp)
-sketch.vertical(line.handle, sketch.wp)
-
-# Solve system
-result = sketch.solve_system()
-```
-
-### Signals
-
-The widget emits several signals for integration:
-
-```python
-# Emitted when constraint is successfully applied
-widget.constraint_applied.connect(callback)
-
-# Emitted when new geometry is created
-widget.geometry_created.connect(callback)  # Parameter: geometry type string
-
-# Emitted when sketch is modified
-widget.sketch_modified.connect(callback)
-```
-
-## Performance Considerations
-
-### Optimization Strategies
-
-1. **Lazy Solving**: Solver only runs when necessary (after constraints or drag end)
-2. **Efficient Rendering**: Uses Qt's optimized drawing primitives
-3. **Smart Updates**: Only redraws affected regions when possible
-4. **Handle Caching**: SolverSpace handles are cached to avoid recreation
-
-### Memory Management
-
-- Geometry objects use weak references where possible
-- SolverSpace handles are properly cleaned up
-- Qt objects follow parent-child hierarchy for automatic cleanup
-
-### Scalability Limits
-
-- Recommended maximum: ~1000 geometric entities
-- Solver performance degrades with complex constraint networks
-- Rendering remains smooth up to ~10,000 entities
-
-## Troubleshooting
-
-### Common Issues
-
-#### Mode Handling Problems
-**Symptoms**: Unintended line creation when dragging, tools not deactivating properly
-**Causes**: Mode not properly reset to NONE, Python None vs SketchMode.NONE confusion
-**Solutions**:
-- Always right-click to exit active modes
-- Ensure `set_mode(None)` is converted to `SketchMode.NONE`
-- Verify mode state after tool deactivation in main app
-
-#### Point Dragging Issues  
-**Symptoms**: Cannot drag points, dragging creates unwanted lines
-**Causes**: Mode not set to NONE, safety checks preventing drag detection
-**Solutions**:
-- Verify current mode is `SketchMode.NONE` before attempting to drag
-- Right-click to ensure proper mode exit from drawing tools
-- Check that point detection threshold is appropriate
-
-#### Solver Failures
-**Symptoms**: Constraints not applied, geometry not updating
-**Causes**: Over-constrained systems, conflicting constraints
-**Solutions**: 
-- Check constraint compatibility
-- Verify geometry validity
-- Use `ResultFlag` inspection for error details
-
-#### Coordinate Transform Issues
-**Symptoms**: Mouse clicks don't match visual geometry
-**Causes**: Incorrect transform calculations, zoom/pan state corruption
-**Solutions**:
-- Verify `_viewport_to_local` and `_setup_coordinate_system` consistency
-- Reset view with `zoom_to_fit()`
-
-#### Performance Problems
-**Symptoms**: Slow dragging, UI lag
-**Causes**: Solver running during drag, excessive redraws
-**Solutions**:
-- Ensure solver only runs in `_end_point_drag`
-- Check render loop efficiency
-- Profile with Qt performance tools
-
-#### Snap Behavior Issues
-**Symptoms**: Inconsistent snapping, incorrect snap points
-**Causes**: Priority conflicts, threshold settings, coordinate errors
-**Solutions**:
-- Adjust snap threshold in `SnapSettings`
-- Verify snap priority order
-- Check coordinate conversion in snap calculations
-
-### Debug Logging
-
-Enable detailed logging for troubleshooting:
-```python
-import logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger('improved_sketcher')
-```
-
-Key log messages include:
-- Geometry addition/removal
-- Constraint application results
-- Solver execution status
-- Coordinate transformations
-- Snap calculations
-
-### Testing Guidelines
-
-#### Unit Testing
-- Test geometry classes with edge cases
-- Verify coordinate transformations
-- Test constraint application logic
-
-#### Integration Testing
-- Test with various sketch sizes
-- Verify working plane integration
-- Test complex constraint networks
-
-#### Performance Testing
-- Measure solver execution time
-- Profile rendering performance
-- Test with large geometry sets
-
----
-
-## Recent Improvements (2025-08-16)
-
-### Mode Handling Enhancements
-
-Significant improvements have been made to the mode management system:
-
-#### Fixed Issues
-1. **Unintended Line Creation**: Resolved issue where dragging with line tool deactivated would still create lines
-2. **Mode Reset Reliability**: Right-click now reliably exits any active mode and returns to NONE
-3. **Backward Compatibility**: Python `None` mode values are automatically converted to `SketchMode.NONE`
-4. **Safety Checks**: Added comprehensive checks to prevent drawing operations in NONE mode
-
-#### Implementation Details
-- Enhanced `_handle_right_click()` to directly set mode to NONE
-- Added safety checks in `_handle_left_click()` for NONE mode behavior
-- Improved `set_mode()` method to handle None input gracefully
-- Added comprehensive debug logging for mode transitions
-
-#### Integration Improvements
-- Fixed main app integration where constraint modes were prematurely reset
-- Ensured persistent constraint behavior until explicit user cancellation
-- Maintained UI button state consistency with actual sketcher mode
-
-These improvements ensure reliable mode transitions and prevent common user frustrations with unintended geometry creation.
-
-## Conclusion
-
-The ImprovedSketchWidget provides a robust, extensible foundation for 2D parametric sketching in Fluency CAD. Its architecture separates concerns effectively, uses proven libraries (SolverSpace, PySide6), and provides rich interaction capabilities while maintaining good performance characteristics.
-
-The system is designed for extensibility - new geometry types, constraint types, and interaction modes can be added following the established patterns. The comprehensive API allows for both direct use and integration with larger CAD systems.
-
-With the recent mode handling improvements, the sketcher now provides a more reliable and intuitive user experience, with proper separation between drawing modes and selection/manipulation operations.

doc/commands.md

@@ -1 +0,0 @@
- pyside6-uic gui.ui > Gui.py -g python

doc/flow.md

@@ -1,35 +0,0 @@
-# Signal Flow
-## 2D SketchWidget
-
-- 2D QPoint form custom Qpainter widget in linear space
-- 2D QPoint ot cartesian space
-- 2D tuple into slvspace dict system and solvespace 
-- get calced position from Solvespace solver
-- add to internal reference dict 
-- Transform to linear QPainter space for display to show
-
-## 3D custom Widget
-
-- Take Tuple points form solvespace main dict
-- Draw Interactor and sdfCAD model
-
-### Select and Project
-
-- Project cartesian flattened mesh into 2D 
-- Transform to 2D xy
-- Transform to linear space for 2D widget to draw.
-- Result into 2D cartesian for body interaction extrude etc
-
-### Elements
-
-So far these are the elements: 
-
-- Project: Main File 
-- Timeline : Used to track the steps
-- Assembly: Uses Components and Connectors to from Assemblies
-- Component: Container for multiple smaller elements "part"
-- Connector: Preserves connections between parts even if the part in between is deleted
-- Code: A special type that directly builds bodys from sdfCAD code.
-- Body: The 3D meshed result from sdfCAD
-- Sketch: The base to draw new entities.
-- Interactor (edges): A special component mesh that is used to manipulate the bodys in 3d view.

doc/helper_commands.md

@@ -1,3 +0,0 @@
-## Compile ui file
-pyside6-uic gui.ui > Gui.py -g python
-

docs/render_view_plan.md

@@ -0,0 +1,253 @@
+# Realistic Render View — Implementation Plan
+
+## Context
+
+Add a **"Render"** feature to Fluency CAD that opens a separate window for photorealistic rendering of the selected component or assembly (like KeyShot/Cacles).
+
+**Constraints:**
+- Open in a **new window** — don't clutter the workspace
+- **Keep existing OCCRenderer** for the interactive 3D viewport — untouched
+- Render backend must be a **separate, swappable module** so we can change the renderer later
+- Use **Mitsuba 3** as the initial backend (`pip install mitsuba`, ~50MB)
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Main Fluency Window (existing OCCRenderer — untouched) │
+│                                                         │
+│  [Select body/assembly] → [Click "Render"]              │
+│              │                                          │
+│              ▼                                          │
+│  ┌─────────────────────────────────────┐                │
+│  │  RenderWindow (separate QMainWindow)│                │
+│  │                                     │                │
+│  │  ┌───────────────────────────────┐  │                │
+│  │  │  RenderBackend (ABC)          │  │                │
+│  │  │  ├─ MitsubaBackend  ← current │  │                │
+│  │  │  ├─ (future: BlenderBackend)  │  │                │
+│  │  │  └─ (future: CyclesBackend)   │  │                │
+│  │  └───────────────────────────────┘  │                │
+│  │                                     │                │\n│  │  [Image preview]  [Progress bar]  │                │
+│  │  [Material ▾] [Quality ▾] [Render]  │                │
+│  │                     [Export PNG]    │                │
+│  └─────────────────────────────────────┘                │
+└─────────────────────────────────────────────────────────┘
+```
+
+### Swappable Backend Interface
+
+```python
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+import numpy as np
+
+@dataclass
+class RenderMaterial:
+    name: str
+    color: tuple[float, float, float] = (0.7, 0.7, 0.7)
+    metallic: float = 0.0        # 0.0–1.0
+    roughness: float = 0.5       # 0.0–1.0
+    bsdf_type: str = "diffuse"   # diffuse | roughconductor | roughdielectric | plastic
+
+@dataclass
+class RenderCamera:
+    origin: tuple[float, float, float] = (100, 100, 100)
+    target: tuple[float, float, float] = (0, 0, 0)
+    up: tuple[float, float, float] = (0, 0, 1)
+    fov: float = 45.0
+
+@dataclass
+class RenderSettings:
+    width: int = 1920
+    height: int = 1080
+    spp: int = 256            # samples per pixel
+    max_depth: int = 8        # path tracer bounces
+
+class RenderBackend(ABC):
+    """Swap this to change the rendering engine."""
+    @abstractmethod
+    def render(self, obj_path: str, material: RenderMaterial,
+               camera: RenderCamera, settings: RenderSettings) -> np.ndarray: ...
+    @abstractmethod
+    def render_preview(self, obj_path: str, material: RenderMaterial,
+                       camera: RenderCamera, settings: RenderSettings) -> np.ndarray: ...
+    @abstractmethod
+    def name(self) -> str: ...
+```
+
+Switching backends later = write a new class implementing `RenderBackend`. One import change.
+
+---
+
+## Mitsuba 3 Backend
+
+### Why Mitsuba
+
+| Feature | Status |
+|---------|--------|
+| `pip install mitsuba` | Single install, no system deps |
+| True path tracing | GI, caustics, spectral rendering |
+| PBR materials | `roughconductor`, `roughdielectric`, `diffuse`, `plastic` |
+| Python dict API | Build scenes programmatically, no XML |
+| CPU + GPU backends | `scalar_rgb` (CPU), `cuda_rgb` (NVIDIA) |
+| Output formats | PNG, EXR (HDR) with tonemapping |
+
+### OCC → OBJ Conversion Path
+
+```python
+from OCP.BRepMesh import BRepMesh_IncrementalMesh
+from OCP.StlAPI import StlAPI_Writer
+from OCP.BRep import BRep_Builder
+import tempfile, os
+
+def occ_shape_to_obj(shape, obj_path: str, linear_deflection: float = 0.1):
+    """Tessellate OCC shape and write as OBJ for Mitsuba."""
+    tess = BRepMesh_IncrementalMesh(shape, linear_deflection, False, 0.5, True)
+    tess.Perform()
+    # Write STL (reliable), then convert to OBJ via trimesh or direct
+    writer = StlAPI_Writer()
+    writer.SetASCIIMode(False)
+    stl_path = obj_path.replace(".obj", ".stl")
+    writer.Write(shape, stl_path)
+    # Mitsuba can read STL directly, or we convert to OBJ
+    return stl_path
+```
+
+### Mitsuba Scene Construction
+
+```python
+import mitsuba as mi
+mi.set_variant("scalar_rgb")
+
+def build_scene(mesh_path: str, material: RenderMaterial,
+                camera: RenderCamera, settings: RenderSettings) -> mi.Scene:
+    # Map our material to Mitsuba BSDF
+    bsdf_map = {
+        "diffuse": {"type": "diffuse", "reflectance": {"type": "rgb", "value": material.color}},
+        "roughconductor": {
+            "type": "roughconductor",
+            "material": "copper",  # or铝, 钢, etc.
+            "alpha": material.roughness,
+        },
+        "roughdielectric": {
+            "type": "roughdielectric",
+            "int_ior": 1.5,
+            "alpha": material.roughness,
+        },
+        "plastic": {
+            "type": "plastic",
+            "diffuse_reflectance": {"type": "rgb", "value": material.color},
+            "int_ior": 1.5,
+        },
+    }
+
+    return mi.load_dict({
+        "type": "scene",
+        "integrator": {"type": "path", "max_depth": settings.max_depth},
+        "sensor": {
+            "type": "perspective",
+            "fov": camera.fov,
+            "to_world": mi.ScalarTransform4f.look_at(
+                origin=camera.origin, target=camera.target, up=camera.up
+            ),
+            "film": {"type": "hdrfilm", "width": settings.width, "height": settings.height},
+            "sampler": {"type": "independent", "sample_count": settings.spp},
+        },
+        "emitter": {"type": "constant"},
+        "shape": {
+            "type": "stl",  # or "obj"
+            "filename": mesh_path,
+            "bsdf": bsdf_map.get(material.bsdf_type, bsdf_map["diffuse"]),
+        },
+    })
+```
+
+---
+
+## Files to Create/Modify
+
+| File | Action | Description |
+|------|--------|-------------|
+| `src/fluency/rendering/render_backend.py` | **NEW** | Abstract `RenderBackend`, `RenderMaterial`, `RenderCamera`, `RenderSettings` |
+| `src/fluency/rendering/mitsuba_backend.py` | **NEW** | `MitsubaBackend(RenderBackend)` implementation |
+| `src/fluency/rendering/occ_to_mesh.py` | **NEW** | OCC `TopoDS_Shape` → STL/OBJ tessellation |
+| `src/fluency/rendering/material_presets.py` | **NEW** | Preset library: Steel, Aluminum, Brass, Chrome, Plastic, Rubber, Wood |
+| `src/fluency/ui/render_window.py` | **NEW** | `RenderWindow(QMainWindow)` — image preview, material/quality controls, render/export |
+| `src/fluency/ui/main_window.py` | MODIFY | Add "Render" button → get selected shapes → open `RenderWindow` |
+
+---
+
+## UI: RenderWindow
+
+```
+┌──────────────────────────────────────────┐
+│  Render — [Part Name]              [─][□][×] │
+├──────────────────────────────────────────┤
+│                                          │
+│  ┌──────────────────────────────────┐    │
+│  │                                  │    │
+│  │      Rendered Image Preview      │    │
+│  │      (QLabel with QPixmap)       │    │
+│  │                                  │    │
+│  └──────────────────────────────────┘    │
+│                                          │
+│  Material: [Steel ▾]                     │
+│  Quality:  [256 SPP ▾]                   │
+│  Resolution: [1920×1080 ▾]               │
+│                                          │
+│  [▶ Render]  [⏹ Cancel]  [💾 Export PNG] │
+│                                          │
+│  ████████████████░░░░░░  65%  (23s left) │
+└──────────────────────────────────────────┘
+```
+
+- **Preview**: progressive refinement (low SPP first, then ramp)
+- **Cancel**: kill Mitsuba render thread
+- **Export**: save to PNG/EXR
+
+---
+
+## Material Presets
+
+| Preset | Color | Metallic | Roughness | BSDF |
+|--------|-------|----------|-----------|------|
+| Brushed Steel | (0.65, 0.67, 0.72) | 0.9 | 0.35 | roughconductor |
+| Polished Chrome | (0.8, 0.8, 0.8) | 1.0 | 0.05 | roughconductor |
+| Brushed Aluminum | (0.75, 0.75, 0.75) | 0.85 | 0.25 | roughconductor |
+| Copper | (0.95, 0.64, 0.54) | 0.95 | 0.15 | roughconductor |
+| Gold | (1.0, 0.76, 0.33) | 1.0 | 0.1 | roughconductor |
+| Blackened Steel | (0.15, 0.15, 0.17) | 0.8 | 0.4 | roughconductor |
+| Matte Plastic | (0.2, 0.5, 0.8) | 0.0 | 0.6 | plastic |
+| Glossy Plastic | (0.2, 0.5, 0.8) | 0.0 | 0.1 | plastic |
+| White Nylon | (0.85, 0.85, 0.83) | 0.0 | 0.45 | plastic |
+| Black ABS | (0.05, 0.05, 0.05) | 0.0 | 0.35 | plastic |
+| Red PA12 | (0.75, 0.08, 0.08) | 0.0 | 0.4 | plastic |
+| Rubber | (0.1, 0.1, 0.1) | 0.0 | 0.9 | diffuse |
+| Ceramic White | (0.92, 0.91, 0.88) | 0.0 | 0.15 | dielectric |
+| Glass | (0.95, 0.95, 0.95) | 0.0 | 0.0 | dielectric |
+| Wood | (0.6, 0.4, 0.2) | 0.0 | 0.7 | diffuse |
+
+**Note:** Mitsuba pip installs don't include spectral metal data files (iron.spd, copper.spd, etc.), so metal presets use `material="none"` with `specular_reflectance` set to the metal color instead.
+
+---
+
+## Risks & Mitigations
+
+| Risk | Mitigation |
+|------|-----------|
+| Mitsuba not installed | Graceful error: "pip install mitsuba" shown in UI |
+| Slow CPU rendering | Default to low SPP (64) for preview; offer GPU variant if CUDA available |
+| Large meshes slow to tessellate | Progress indicator; optional mesh decimation |
+| Mitsuba STL/OCC compatibility | Test tessellation quality; tune `linear_deflection` |
+
+---
+
+## Estimated Effort
+
+- **Phase 1** (abstract backend + OCC→mesh + Mitsuba impl): ~4-6 hours
+- **Phase 2** (render window UI + material presets): ~3-4 hours
+- **Phase 3** (polish, export, swap test): ~2-3 hours
+- **Total**: ~9-13 hours

drawing_modules/draw_widget2d.py

@@ -1,916 +0,0 @@
-import math
-import re
-from copy import copy
-from typing import Optional
-
-import numpy as np
-from PySide6.QtWidgets import QApplication, QWidget, QMessageBox, QInputDialog
-from PySide6.QtGui import QPainter, QPen, QColor, QTransform
-from PySide6.QtCore import Qt, QPoint, QPointF, Signal, QLine
-from python_solvespace import SolverSystem, ResultFlag
-
-
-class SketchWidget(QWidget):
-    constrain_done = Signal()
-
-    def __init__(self):
-        super().__init__()
-
-        self.line_draw_buffer = [None, None]
-        self.drag_buffer = [None, None]
-        self.main_buffer = [None, None]
-
-        self.hovered_point = None
-        self.selected_line = None
-
-        self.snapping_range = 20  # Range in pixels for snapping
-        self.zoom = 1
-
-        self.setMouseTracking(True)
-        self.mouse_mode = False
-        self.solv = SolverSystem()
-
-        self.sketch = None
-
-    def set_sketch(self, sketch) -> None:
-        print(sketch)
-        self.sketch = sketch
-        self.create_workplane()
-
-    def get_sketch(self):
-        return self.sketch
-
-    def reset_buffers(self):
-        self.line_draw_buffer = [None, None]
-        self.drag_buffer = [None, None]
-        self.main_buffer = [None, None]
-
-    def set_points(self, points: list):
-        self.points = points
-        #self.update()
-
-    def create_workplane(self):
-        self.sketch.working_plane = self.solv.create_2d_base()
-
-    def create_workplane_projected(self):
-        self.sketch.working_plane = self.solv.create_2d_base()
-
-    def convert_proj_points(self):
-        out_points = []
-        for point in self.sketch.proj_points:
-            x, y = point
-            coord = QPoint(x, y)
-            out_points.append(coord)
-
-        self.sketch.proj_points = out_points
-
-    def convert_proj_lines(self):
-        out_lines = []
-        for line in self.sketch.proj_lines:
-            start = QPoint(line[0][0], line[0][1])
-            end = QPoint(line[1][0], line[1][1])
-            coord = QLine(start, end)
-            out_lines.append(coord)
-        self.sketch.proj_lines = out_lines
-
-    def find_duplicate_points_2d(self, edges):
-        points = []
-        seen = set()
-        duplicates = []
-
-        for edge in edges:
-            for point in edge:
-                # Extract only x and y coordinates
-                point_2d = (point[0], point[1])
-                if point_2d in seen:
-                    if point_2d not in duplicates:
-                        duplicates.append(point_2d)
-                else:
-                    seen.add(point_2d)
-                points.append(point_2d)
-
-        return duplicates
-
-    def normal_to_quaternion(self, normal):
-        normal = np.array(normal)
-        #normal = normal / np.linalg.norm(normal)
-
-        axis = np.cross([0, 0, 1], normal)
-        if np.allclose(axis, 0):
-            axis = np.array([1, 0, 0])
-        else:
-            axis = axis / np.linalg.norm(axis)  # Normalize the axis
-
-        angle = np.arccos(np.dot([0, 0, 1], normal))
-
-        qw = np.cos(angle / 2)
-        sin_half_angle = np.sin(angle / 2)
-        qx, qy, qz = axis * sin_half_angle  # This will now work correctly
-
-        return qw, qx, qy, qz
-
-    def create_workplane_space(self, points, normal):
-        print("edges", points)
-        origin = self.find_duplicate_points_2d(points)
-        print(origin)
-        x, y = origin[0]
-        origin = QPoint(x, y)
-
-        origin_handle = self.get_handle_from_ui_point(origin)
-        qw, qx, qy, qz = self.normal_to_quaternion(normal)
-
-        slv_normal = self.solv.add_normal_3d(qw, qx, qy, qz)
-        self.sketch.working_plane = self.solv.add_work_plane(origin_handle, slv_normal)
-        print(self.sketch.working_plane)
-
-    def get_handle_nr(self, input_str: str) -> int:
-        # Define the regex pattern to extract the handle number
-        pattern = r"handle=(\d+)"
-
-        # Use re.search to find the handle number in the string
-        match = re.search(pattern, input_str)
-
-        if match:
-            handle_number = int(match.group(1))
-            print(f"Handle number: {handle_number}")
-            return int(handle_number)
-
-        else:
-            print("Handle number not found.")
-            return 0
-
-    def get_keys(self, d: dict, target: QPoint) -> list:
-        result = []
-        path = []
-        print(d)
-        print(target)
-        for k, v in d.items():
-            path.append(k)
-            if isinstance(v, dict):
-                self.get_keys(v, target)
-            if v == target:
-                result.append(copy(path))
-            path.pop()
-
-        return result
-
-    def get_handle_from_ui_point(self, ui_point: QPoint):
-        """Input QPoint and you shall reveive a slvs entity handle!"""
-        for point in self.sketch.slv_points:
-            if ui_point == point['ui_point']:
-                slv_handle = point['solv_handle']
-
-                return slv_handle
-
-    def get_line_handle_from_ui_point(self, ui_point: QPoint):
-        """Input Qpoint that is on a line and you shall receive the handle of the line!"""
-        for target_line_con in self.sketch.slv_lines:
-            if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
-                slv_handle = target_line_con['solv_handle']
-
-                return slv_handle
-
-    def get_point_line_handles_from_ui_point(self, ui_point: QPoint) -> tuple:
-        """Input Qpoint that is on a line and you shall receive the handles of the points of the line!"""
-        for target_line_con in self.sketch.slv_lines:
-            if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
-                lines_to_cons = target_line_con['solv_entity_points']
-
-                return lines_to_cons
-
-    def distance(self, p1, p2):
-        return math.sqrt((p1.x() - p2.x())**2 + (p1.y() - p2.y())**2)
-
-    def calculate_midpoint(self, point1, point2):
-        mx = (point1.x() + point2.x()) // 2
-        my = (point1.y() + point2.y()) // 2
-        return QPoint(mx, my)
-
-    def is_point_on_line(self, p, p1, p2, tolerance=5):
-        # Calculate the lengths of the sides of the triangle
-        a = self.distance(p, p1)
-        b = self.distance(p, p2)
-        c = self.distance(p1, p2)
-
-        # Calculate the semi-perimeter
-        s = (a + b + c) / 2
-
-        # Calculate the area using Heron's formula
-        area = math.sqrt(s * (s - a) * (s - b) * (s - c))
-
-        # Calculate the height (perpendicular distance from the point to the line)
-        if c > 0:
-            height = (2 * area) / c
-            # Check if the height is within the tolerance distance to the line
-            if height > tolerance:
-                return False
-
-            # Check if the projection of the point onto the line is within the line segment
-            dot_product = ((p.x() - p1.x()) * (p2.x() - p1.x()) + (p.y() - p1.y()) * (p2.y() - p1.y())) / (c ** 2)
-
-            return 0 <= dot_product <= 1
-        else:
-            return None
-
-    def viewport_to_local_coord(self, qt_pos : QPoint) -> QPoint:
-        return QPoint(self.to_quadrant_coords(qt_pos))
-
-    def check_all_points(self,) -> list:
-        old_points_ui = []
-        new_points_ui = []
-
-        for old_point_ui in self.sketch.slv_points:
-            old_points_ui.append(old_point_ui['ui_point'])
-
-        for i in range(self.solv.entity_len()):
-            # Iterate though full length because mixed list from SS
-            entity = self.solv.entity(i)
-            if entity.is_point_2d() and self.solv.params(entity.params):
-                x_tbu, y_tbu = self.solv.params(entity.params)
-                point_solved = QPoint(x_tbu, y_tbu)
-                new_points_ui.append(point_solved)
-
-        # Now we have old_points_ui and new_points_ui, let's compare them
-        differences = []
-
-        if len(old_points_ui) != len(new_points_ui):
-            print(f"Length mismatch {len(old_points_ui)} - {len(new_points_ui)}")
-
-        for index, (old_point, new_point) in enumerate(zip(old_points_ui, new_points_ui)):
-            if old_point != new_point:
-                differences.append((index, old_point, new_point))
-
-        return differences
-
-    def update_ui_points(self, point_list: list):
-        # Print initial state of slv_points_main
-        # print("Initial slv_points_main:", self.slv_points_main)
-        print("Change list:", point_list)
-
-        if len(point_list) > 0:
-            for tbu_points_idx in point_list:
-                # Each tbu_points_idx is a tuple: (index, old_point, new_point)
-                index, old_point, new_point = tbu_points_idx
-
-                # Update the point in slv_points_main
-                self.sketch.slv_points[index]['ui_point'] = new_point
-            # Print updated state
-            # print("Updated slv_points_main:", self.slv_points_main)
-
-    def check_all_lines_and_update(self,changed_points: list):
-        for tbu_points_idx in changed_points:
-            index, old_point, new_point = tbu_points_idx
-            for line_needs_update in self.sketch.slv_lines:
-                if old_point == line_needs_update['ui_points'][0]:
-                    line_needs_update['ui_points'][0] = new_point
-                elif old_point == line_needs_update['ui_points'][1]:
-                    line_needs_update['ui_points'][1] = new_point
-
-    def mouseReleaseEvent(self, event):
-        local_event_pos = self.viewport_to_local_coord(event.pos())
-
-        if event.button() == Qt.LeftButton and not self.mouse_mode:
-            self.drag_buffer[1] = local_event_pos
-
-            print("Le main buffer", self.drag_buffer)
-
-            if len(self.main_buffer) == 2:
-                entry = self.drag_buffer[0]
-                new_params = self.drag_buffer[1].x(), self.drag_buffer[1].y()
-                self.solv.set_params(entry.params, new_params)
-
-                self.solv.solve()
-
-                points_need_update = self.check_all_points()
-                self.update_ui_points(points_need_update)
-                self.check_all_lines_and_update(points_need_update)
-
-                self.update()
-                self.drag_buffer = [None, None]
-
-    def mousePressEvent(self, event):
-        local_event_pos = self.viewport_to_local_coord(event.pos())
-
-        relation_point = {
-            'handle_nr': None,
-            'solv_handle': None,
-            'ui_point': None,
-            'part_of_entity': None
-        }
-
-        relation_line = {
-            'handle_nr': None,
-            'solv_handle': None,
-            'solv_entity_points': None,
-            'ui_points': None
-        }
-
-        if event.button() == Qt.LeftButton and not self.mouse_mode:
-            self.drag_buffer[0] = self.get_handle_from_ui_point(self.hovered_point)
-
-        if event.button() == Qt.RightButton and self.mouse_mode:
-            self.reset_buffers()
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "line":
-            if self.hovered_point:
-                clicked_pos = self.hovered_point
-            else:
-                clicked_pos = local_event_pos
-
-            if not self.line_draw_buffer[0]:
-                self.line_draw_buffer[0] = clicked_pos
-                u = clicked_pos.x()
-                v = clicked_pos.y()
-
-                point = self.solv.add_point_2d(u, v, self.sketch.working_plane)
-
-                relation_point = {}  # Reinitialize the dictionary
-                handle_nr = self.get_handle_nr(str(point))
-                relation_point['handle_nr'] = handle_nr
-                relation_point['solv_handle'] = point
-                relation_point['ui_point'] = clicked_pos
-
-                self.sketch.slv_points.append(relation_point)
-
-                print("points", self.sketch.slv_points)
-                print("lines", self.sketch.slv_lines)
-
-            elif self.line_draw_buffer[0]:
-                self.line_draw_buffer[1] = clicked_pos
-                u = clicked_pos.x()
-                v = clicked_pos.y()
-
-                point2 = self.solv.add_point_2d(u, v, self.sketch.working_plane)
-
-                relation_point = {}  # Reinitialize the dictionary
-                handle_nr = self.get_handle_nr(str(point2))
-                relation_point['handle_nr'] = handle_nr
-                relation_point['solv_handle'] = point2
-                relation_point['ui_point'] = clicked_pos
-
-                self.sketch.slv_points.append(relation_point)
-
-                print("points", self.sketch.slv_points)
-                print("lines", self.sketch.slv_lines)
-
-            print("Buffer state", self.line_draw_buffer)
-
-            if self.line_draw_buffer[0] and self.line_draw_buffer[1]:
-
-                point_slv1 = self.get_handle_from_ui_point(self.line_draw_buffer[0])
-                point_slv2 = self.get_handle_from_ui_point(self.line_draw_buffer[1])
-                print(point_slv1)
-                print(point_slv2)
-
-                line = self.solv.add_line_2d(point_slv1, point_slv2, self.sketch.working_plane)
-
-                relation_line = {}  # Reinitialize the dictionary
-                handle_nr_line = self.get_handle_nr(str(line))
-                relation_line['handle_nr'] = handle_nr_line
-                relation_line['solv_handle'] = line
-                relation_line['solv_entity_points'] = (point_slv1, point_slv2)
-                relation_line['ui_points'] = [self.line_draw_buffer[0], self.line_draw_buffer[1]]
-
-                # Track relationship of point in line
-                relation_point['part_of_entity'] = handle_nr_line
-
-                self.sketch.slv_lines.append(relation_line)
-
-                # Reset the buffer for the next line segment
-                self.line_draw_buffer[0] = self.line_draw_buffer[1]
-                self.line_draw_buffer[1] = None
-
-            # Track Relationship
-            # Points
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "pt_pt":
-            if self.hovered_point and not self.main_buffer[0]:
-                self.main_buffer[0] = self.get_handle_from_ui_point(self.hovered_point)
-
-            elif self.main_buffer[0]:
-                self.main_buffer[1] = self.get_handle_from_ui_point(self.hovered_point)
-
-            if self.main_buffer[0] and self.main_buffer[1]:
-                print("buf", self.main_buffer)
-
-                self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
-
-                if self.solv.solve() == ResultFlag.OKAY:
-                    print("Fuck yeah")
-
-                elif self.solv.solve() == ResultFlag.DIDNT_CONVERGE:
-                    print("Solve_failed - Converge")
-
-                elif self.solv.solve() == ResultFlag.TOO_MANY_UNKNOWNS:
-                    print("Solve_failed - Unknowns")
-
-                elif self.solv.solve() == ResultFlag.INCONSISTENT:
-                    print("Solve_failed - Incons")
-                self.constrain_done.emit()
-                self.main_buffer = [None, None]
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "pt_line":
-            print("ptline")
-            line_selected = None
-
-            if self.hovered_point and not self.main_buffer[1]:
-                self.main_buffer[0] = self.get_handle_from_ui_point(self.hovered_point)
-
-            elif self.main_buffer[0]:
-                self.main_buffer[1] = self.get_line_handle_from_ui_point(local_event_pos)
-
-                # Contrain point to line
-                if self.main_buffer[1]:
-                    self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
-
-                    if self.solv.solve() == ResultFlag.OKAY:
-                        print("Fuck yeah")
-                        self.constrain_done.emit()
-
-                    elif self.solv.solve() == ResultFlag.DIDNT_CONVERGE:
-                        print("Solve_failed - Converge")
-
-                    elif self.solv.solve() == ResultFlag.TOO_MANY_UNKNOWNS:
-                        print("Solve_failed - Unknowns")
-
-                    elif self.solv.solve() == ResultFlag.INCONSISTENT:
-                        print("Solve_failed - Incons")
-
-                    self.constrain_done.emit()
-                    # Clear saved_points after solve attempt
-                    self.main_buffer = [None, None]
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "pb_con_mid":
-            print("ptline")
-            line_selected = None
-
-            if self.hovered_point and not self.main_buffer[1]:
-                self.main_buffer[0] = self.get_handle_from_ui_point(self.hovered_point)
-
-            elif self.main_buffer[0]:
-                self.main_buffer[1] = self.get_line_handle_from_ui_point(local_event_pos)
-
-                # Contrain point to line
-                if self.main_buffer[1]:
-                    self.solv.midpoint(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
-
-                    if self.solv.solve() == ResultFlag.OKAY:
-                        print("Fuck yeah")
-
-                    elif self.solv.solve() == ResultFlag.DIDNT_CONVERGE:
-                        print("Solve_failed - Converge")
-
-                    elif self.solv.solve() == ResultFlag.TOO_MANY_UNKNOWNS:
-                        print("Solve_failed - Unknowns")
-
-                    elif self.solv.solve() == ResultFlag.INCONSISTENT:
-                        print("Solve_failed - Incons")
-                    self.constrain_done.emit()
-
-                    self.main_buffer = [None, None]
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "horiz":
-
-            line_selected = self.get_line_handle_from_ui_point(local_event_pos)
-
-            if line_selected:
-                self.solv.horizontal(line_selected, self.sketch.working_plane)
-
-            if self.solv.solve() == ResultFlag.OKAY:
-                print("Fuck yeah")
-
-            elif self.solv.solve() == ResultFlag.DIDNT_CONVERGE:
-                print("Solve_failed - Converge")
-
-            elif self.solv.solve() == ResultFlag.TOO_MANY_UNKNOWNS:
-                print("Solve_failed - Unknowns")
-
-            elif self.solv.solve() == ResultFlag.INCONSISTENT:
-                print("Solve_failed - Incons")
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "vert":
-            line_selected = self.get_line_handle_from_ui_point(local_event_pos)
-
-            if line_selected:
-                self.solv.vertical(line_selected, self.sketch.working_plane)
-
-                if self.solv.solve() == ResultFlag.OKAY:
-                    print("Fuck yeah")
-
-                elif self.solv.solve() == ResultFlag.DIDNT_CONVERGE:
-                    print("Solve_failed - Converge")
-
-                elif self.solv.solve() == ResultFlag.TOO_MANY_UNKNOWNS:
-                    print("Solve_failed - Unknowns")
-
-                elif self.solv.solve() == ResultFlag.INCONSISTENT:
-                    print("Solve_failed - Incons")
-
-        if event.button() == Qt.LeftButton and self.mouse_mode == "distance":
-            # Depending on selected elemnts either point line or line distance
-            #print("distance")
-            e1 = None
-            e2 = None
-
-            if self.hovered_point:
-                print("buf point")
-                # Get the point as UI point as buffer
-                self.main_buffer[0] = self.hovered_point
-
-            elif self.selected_line:
-                # Get the point as UI point as buffer
-                self.main_buffer[1] = local_event_pos
-
-            if self.main_buffer[0] and self.main_buffer[1]:
-                # Define point line combination
-                e1 = self.get_handle_from_ui_point(self.main_buffer[0])
-                e2 = self.get_line_handle_from_ui_point(self.main_buffer[1])
-
-            elif not self.main_buffer[0]:
-                # Define only line selection
-                e1, e2 = self.get_point_line_handles_from_ui_point(local_event_pos)
-
-            if e1 and e2:
-                # Ask fo the dimension and solve if both elements are present
-                length, ok = QInputDialog.getDouble(self, 'Distance', 'Enter a mm value:', value=100, decimals=2)
-                self.solv.distance(e1, e2, length, self.sketch.working_plane)
-
-                if self.solv.solve() == ResultFlag.OKAY:
-                    print("Fuck yeah")
-
-                elif self.solv.solve() == ResultFlag.DIDNT_CONVERGE:
-                    print("Solve_failed - Converge")
-
-                elif self.solv.solve() == ResultFlag.TOO_MANY_UNKNOWNS:
-                    print("Solve_failed - Unknowns")
-
-                elif self.solv.solve() == ResultFlag.INCONSISTENT:
-                    print("Solve_failed - Incons")
-
-                self.constrain_done.emit()
-                self.main_buffer = [None, None]
-
-        # Update the main point list with the new elements and draw them
-        points_need_update = self.check_all_points()
-        self.update_ui_points(points_need_update)
-        self.check_all_lines_and_update(points_need_update)
-
-        self.update()
-
-    def mouseMoveEvent(self, event):
-        local_event_pos = self.viewport_to_local_coord(event.pos())
-
-        closest_point = None
-        min_distance = float('inf')
-        threshold = 10  # Distance threshold for highlighting
-
-        if self.sketch:
-
-            for point in self.sketch.slv_points:
-                distance = (local_event_pos - point['ui_point']).manhattanLength()
-                if distance < threshold and distance < min_distance:
-                    closest_point = point['ui_point']
-                    min_distance = distance
-
-            for point in self.sketch.proj_points:
-                distance = (local_event_pos - point).manhattanLength()
-                if distance < threshold and distance < min_distance:
-                    closest_point = point
-                    min_distance = distance
-
-            if closest_point != self.hovered_point:
-                self.hovered_point = closest_point
-                print(self.hovered_point)
-
-            for dic in self.sketch.slv_lines:
-                p1 = dic['ui_points'][0]
-                p2 = dic['ui_points'][1]
-
-                if self.is_point_on_line(local_event_pos, p1, p2):
-                    self.selected_line = p1, p2
-                    break
-                else:
-                    self.selected_line = None
-
-            self.update()
-
-    def mouseDoubleClickEvent(self, event):
-        pass
-
-    def drawBackgroundGrid(self, painter):
-        """Draw a background grid."""
-        grid_spacing = 50
-        pen = QPen(QColor(200, 200, 200), 1, Qt.SolidLine)
-        painter.setPen(pen)
-
-        # Draw vertical grid lines
-        for x in range(-self.width() // 2, self.width() // 2, grid_spacing):
-            painter.drawLine(x, -self.height() // 2, x, self.height() // 2)
-
-        # Draw horizontal grid lines
-        for y in range(-self.height() // 2, self.height() // 2, grid_spacing):
-            painter.drawLine(-self.width() // 2, y, self.width() // 2, y)
-
-    def drawAxes(self, painter):
-        painter.setRenderHint(QPainter.Antialiasing)
-
-        # Set up pen for dashed lines
-        pen = QPen(Qt.gray, 1, Qt.DashLine)
-        painter.setPen(pen)
-
-        middle_x = self.width() // 2
-        middle_y = self.height() // 2
-
-        # Draw X axis as dashed line
-        painter.drawLine(0, middle_y, self.width(), middle_y)
-
-        # Draw Y axis as dashed line
-        painter.drawLine(middle_x, 0, middle_x, self.height())
-
-        # Draw tick marks
-        tick_length = int(10  * self.zoom)
-        tick_spacing = int(50 * self.zoom)
-
-        pen = QPen(Qt.gray, 1, Qt.SolidLine)
-        painter.setPen(pen)
-
-        # Draw tick marks on the X axis to the right and left from the middle point
-        for x in range(0, self.width() // 2, tick_spacing):
-            painter.drawLine(middle_x + x, middle_y - tick_length // 2, middle_x + x, middle_y + tick_length // 2)
-            painter.drawLine(middle_x - x, middle_y - tick_length // 2, middle_x - x, middle_y + tick_length // 2)
-
-        # Draw tick marks on the Y axis upwards and downwards from the middle point
-        for y in range(0, self.height() // 2, tick_spacing):
-            painter.drawLine(middle_x - tick_length // 2, middle_y + y, middle_x + tick_length // 2, middle_y + y)
-            painter.drawLine(middle_x - tick_length // 2, middle_y - y, middle_x + tick_length // 2, middle_y - y)
-
-        # Draw the origin point in red
-        painter.setPen(QPen(Qt.red, 4))
-        painter.drawPoint(middle_x, middle_y)
-
-    def draw_cross(self, painter, pos: QPoint, size=10):
-        # Set up the pen
-        pen = QPen(QColor('green'))  # You can change the color as needed
-        pen.setWidth(int(2 / self.zoom))  # Set the line widt)h
-        painter.setPen(pen)
-        x = pos.x()
-        y = pos.y()
-
-        # Calculate the endpoints of the cross
-        half_size = size // 2
-
-        # Draw the horizontal line
-        painter.drawLine(x - half_size, y, x + half_size, y)
-
-        # Draw the vertical line
-        painter.drawLine(x, y - half_size, x, y + half_size)
-
-    def to_quadrant_coords(self, point):
-        """Translate linear coordinates to quadrant coordinates."""
-        center_x = self.width() // 2
-        center_y = self.height() // 2
-        quadrant_x = point.x() - center_x
-        quadrant_y = center_y - point.y()  # Note the change here
-        return QPoint(quadrant_x, quadrant_y) / self.zoom
-
-    def from_quadrant_coords(self, point: QPoint):
-        """Translate quadrant coordinates to linear coordinates."""
-        center_x = self.width() // 2
-        center_y = self.height() // 2
-        widget_x = center_x + point.x() * self.zoom
-        widget_y = center_y - point.y() * self.zoom  # Note the subtraction here
-        
-        return QPoint(int(widget_x), int(widget_y))
-
-    def from_quadrant_coords_no_center(self, point):
-        """Invert Y Coordinate for mesh"""
-        center_x = 0
-        center_y = 0
-        widget_x = point.x()
-        widget_y = -point.y()
-        return QPoint(int(widget_x), int(widget_y))
-
-    def paintEvent(self, event):
-        painter = QPainter(self)
-        painter.setRenderHint(QPainter.Antialiasing)
-
-        self.drawAxes(painter)
-
-        # Create a QTransform object
-        transform = QTransform()
-
-        # Translate the origin to the center of the widget
-        center = QPointF(self.width() / 2, self.height() / 2)
-        transform.translate(center.x(), center.y())
-
-        # Apply the zoom factor
-        transform.scale(self.zoom, -self.zoom)  # Negative y-scale to invert y-axis
-
-        # Set the transform to the painter
-        painter.setTransform(transform)
-
-        pen = QPen(Qt.gray)
-        pen.setWidthF(2 / self.zoom)
-        painter.setPen(pen)
-
-        # Draw points
-        if self.sketch:
-            for point in self.sketch.slv_points:
-                painter.drawEllipse(point['ui_point'], 3 / self.zoom, 3 / self.zoom)
-
-            for dic in self.sketch.slv_lines:
-                p1 = dic['ui_points'][0]
-                p2 = dic['ui_points'][1]
-                painter.drawLine(p1, p2)
-
-                dis = self.distance(p1, p2)
-                mid = self.calculate_midpoint(p1, p2)
-                painter.drawText(mid, str(round(dis, 2)))
-
-            pen = QPen(Qt.green)
-            pen.setWidthF(2 / self.zoom)
-            painter.setPen(pen)
-
-            if self.solv.entity_len():
-                for i in range(self.solv.entity_len()):
-                    entity = self.solv.entity(i)
-                    if entity.is_point_2d() and self.solv.params(entity.params):
-                        x, y = self.solv.params(entity.params)
-                        point = QPointF(x, y)
-                        painter.drawEllipse(point, 6 / self.zoom, 6 / self.zoom)
-
-            # Highlight point hovered
-            if self.hovered_point:
-                highlight_pen = QPen(QColor(255, 0, 0))
-                highlight_pen.setWidthF(2 / self.zoom)
-                painter.setPen(highlight_pen)
-                painter.drawEllipse(self.hovered_point, 5 / self.zoom, 5 / self.zoom)
-
-            # Highlight line hovered
-            if self.selected_line and not self.hovered_point:
-                p1, p2 = self.selected_line
-                painter.setPen(QPen(Qt.red, 2 / self.zoom))
-                painter.drawLine(p1, p2)
-
-            for cross in self.sketch.proj_points:
-                self.draw_cross(painter, cross, 10 / self.zoom)
-
-            for selected in self.sketch.proj_lines:
-                pen = QPen(Qt.white, 1, Qt.DashLine)
-                painter.setPen(pen)
-                painter.drawLine(selected)
-
-        painter.end()
-
-    def wheelEvent(self, event):
-        delta = event.angleDelta().y()
-        self.zoom += (delta / 200) * 0.1
-        self.update()
-    
-    def aspect_ratio(self):
-        return self.width() / self.height() * (1.0 / abs(self.zoom))
-
-
-class Point2D:
-    """Improved oop aaproach?"""
-    def __init__(self):
-        self.ui_point = None
-        self.solve_handle_nr = None
-        self.solve_handle = None
-        self.part_of_entity = None
-
-    def to_quadrant_coords(self, point):
-        """Translate linear coordinates to quadrant coordinates."""
-        center_x = self.width() // 2
-        center_y = self.height() // 2
-        quadrant_x = point.x() - center_x
-        quadrant_y = center_y - point.y()  # Note the change here
-
-        return QPoint(quadrant_x, quadrant_y) / self.zoom
-
-    def from_quadrant_coords(self, point: QPoint):
-        """Translate quadrant coordinates to linear coordinates."""
-        center_x = self.width() // 2
-        center_y = self.height() // 2
-        widget_x = center_x + point.x() * self.zoom
-        widget_y = center_y - point.y() * self.zoom  # Note the subtraction here
-
-        return QPoint(int(widget_x), int(widget_y))
-
-    def from_quadrant_coords_no_center(self, point):
-        """Invert Y Coordinate for mesh"""
-        center_x = 0
-        center_y = 0
-        widget_x = point.x()
-        widget_y = -point.y()
-
-        return QPoint(int(widget_x), int(widget_y))
-
-    def get_handle_nr(self, input_str: str) -> int:
-        # Define the regex pattern to extract the handle number
-        pattern = r"handle=(\d+)"
-
-        # Use re.search to find the handle number in the string
-        match = re.search(pattern, input_str)
-
-        if match:
-            handle_number = int(match.group(1))
-            print(f"Handle number: {handle_number}")
-            return int(handle_number)
-
-        else:
-            print("Handle number not found.")
-            return 0
-
-    def get_keys(self, d: dict, target: QPoint) -> list:
-        result = []
-        path = []
-        print(d)
-        print(target)
-        for k, v in d.items():
-            path.append(k)
-            if isinstance(v, dict):
-                self.get_keys(v, target)
-            if v == target:
-                result.append(copy(path))
-            path.pop()
-
-        return result
-
-    def get_handle_from_ui_point(self, ui_point: QPoint):
-        """Input QPoint and you shall reveive a slvs entity handle!"""
-        for point in self.sketch.slv_points:
-            if ui_point == point['ui_point']:
-                slv_handle = point['solv_handle']
-
-                return slv_handle
-
-    def get_line_handle_from_ui_point(self, ui_point: QPoint):
-        """Input Qpoint that is on a line and you shall receive the handle of the line!"""
-        for target_line_con in self.sketch.slv_lines:
-            if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
-                slv_handle = target_line_con['solv_handle']
-
-                return slv_handle
-
-    def get_point_line_handles_from_ui_point(self, ui_point: QPoint) -> tuple:
-        """Input Qpoint that is on a line and you shall receive the handles of the points of the line!"""
-        for target_line_con in self.sketch.slv_lines:
-            if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
-                lines_to_cons = target_line_con['solv_entity_points']
-
-                return lines_to_cons
-
-    def distance(self, p1, p2):
-        return math.sqrt((p1.x() - p2.x())**2 + (p1.y() - p2.y())**2)
-
-    def calculate_midpoint(self, point1, point2):
-        mx = (point1.x() + point2.x()) // 2
-        my = (point1.y() + point2.y()) // 2
-        return QPoint(mx, my)
-
-    def is_point_on_line(self, p, p1, p2, tolerance=5):
-        # Calculate the lengths of the sides of the triangle
-        a = self.distance(p, p1)
-        b = self.distance(p, p2)
-        c = self.distance(p1, p2)
-
-        # Calculate the semi-perimeter
-        s = (a + b + c) / 2
-
-        # Calculate the area using Heron's formula
-        area = math.sqrt(s * (s - a) * (s - b) * (s - c))
-
-        # Calculate the height (perpendicular distance from the point to the line)
-        if c > 0:
-            height = (2 * area) / c
-            # Check if the height is within the tolerance distance to the line
-            if height > tolerance:
-                return False
-
-            # Check if the projection of the point onto the line is within the line segment
-            dot_product = ((p.x() - p1.x()) * (p2.x() - p1.x()) + (p.y() - p1.y()) * (p2.y() - p1.y())) / (c ** 2)
-
-            return 0 <= dot_product <= 1
-        else:
-            return None
-
-    def viewport_to_local_coord(self, qt_pos : QPoint) -> QPoint:
-        return QPoint(self.to_quadrant_coords(qt_pos))
-
-
-class Line2D:
-    pass
-
-class Sketch2d(SolverSystem):
-    
-
-if __name__ == "__main__":
-    import sys
-
-    app = QApplication(sys.argv)
-    window = SketchWidget()
-    window.setWindowTitle("Snap Line Widget")
-    window.resize(800, 600)
-    window.show()
-    sys.exit(app.exec())

drawing_modules/gl_widget.py

@@ -1,504 +0,0 @@
-import sys
-import numpy as np
-from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
-from PySide6.QtOpenGLWidgets import QOpenGLWidget
-from PySide6.QtCore import Qt, QPoint
-from OpenGL.GL import *
-from OpenGL.GLU import *
-
-##testing
-
-def create_cube(scale=1):
-    vertices = np.array([
-        [0, 0, 0],
-        [2, 0, 0],
-        [2, 2, 0],
-        [0, 2, 0],
-        [0, 0, 2],
-        [2, 0, 2],
-        [2, 2, 2],
-        [0, 2, 2]
-    ]) * scale
-
-    faces = np.array([
-        [0, 1, 2],
-        [2, 3, 0],
-        [4, 5, 6],
-        [6, 7, 4],
-        [0, 1, 5],
-        [5, 4, 0],
-        [2, 3, 7],
-        [7, 6, 2],
-        [0, 3, 7],
-        [7, 4, 0],
-        [1, 2, 6],
-        [6, 5, 1]
-    ])
-
-    return vertices, faces
-
-
-class MainWindow(QMainWindow):
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("OpenGL Cube Viewer")
-        self.setGeometry(100, 100, 800, 600)
-
-        self.opengl_widget = OpenGLWidget()
-
-        central_widget = QWidget()
-        layout = QVBoxLayout()
-        layout.addWidget(self.opengl_widget)
-        central_widget.setLayout(layout)
-        self.setCentralWidget(central_widget)
-
-        # Load cube data
-        vertices, faces = create_cube()
-        self.opengl_widget.load_interactor_mesh((vertices, faces))
-
-
-class OpenGLWidget(QOpenGLWidget):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.vertices = None
-        self.faces = None
-        self.selected_face = -1
-        self.scale_factor = 1
-        self.mesh_loaded = None
-        self.interactor_loaded = None
-        self.centroid = None
-        self.stl_file = "out.stl"  # Replace with your STL file path
-        self.lastPos = QPoint()
-        self.startPos = None
-        self.endPos = None
-        self.xRot = 180
-        self.yRot = 0
-        self.zoom = -2
-        self.sketch = []
-        self.gl_width = self.width()
-        self.gl_height = self.height()
-
-    def map_value_to_range(self, value, value_min=0, value_max=1920, range_min=-1, range_max=1):
-        value = max(value_min, min(value_max, value))
-        mapped_value = ((value - value_min) / (value_max - value_min)) * (range_max - range_min) + range_min
-
-        return mapped_value
-
-    def load_stl(self, filename: str) -> object:
-        try:
-            stl_mesh = mesh.Mesh.from_file(filename)
-
-            # Extract vertices
-            vertices = np.concatenate([stl_mesh.v0, stl_mesh.v1, stl_mesh.v2])
-
-            # Calculate bounding box
-            min_x, min_y, min_z = vertices.min(axis=0)
-            max_x, max_y, max_z = vertices.max(axis=0)
-
-            # Calculate centroid
-            centroid_x = (min_x + max_x) / 2.0
-            centroid_y = (min_y + max_y) / 2.0
-            centroid_z = (min_z + max_z) / 2.0
-
-            self.mesh_loaded = stl_mesh.vectors
-            self.centroid = (centroid_x, centroid_y, centroid_z)
-
-        except FileNotFoundError:
-            print(f"Error: File {filename} not found.")
-        except Exception as e:
-            print(f"Error loading {filename}: {e}")
-
-        return None, (0, 0, 0)
-
-    def load_interactor_mesh(self, simp_mesh):
-        self.interactor_loaded = simp_mesh
-        # Calculate centroid based on the average position of vertices
-        centroid = np.mean(simp_mesh[0], axis=0)
-
-        self.centroid = tuple(centroid)
-        print(f"Centroid: {self.centroid}")
-
-        self.update()
-
-    def load_mesh_direct(self, mesh):
-        try:
-            stl_mesh = mesh
-
-            # Extract vertices
-            vertices = np.array(stl_mesh)
-
-            # Calculate centroid based on the average position of vertices
-            centroid = np.mean(vertices, axis=0)
-
-            self.mesh_loaded = vertices
-            self.centroid = tuple(centroid)
-            print(f"Centroid: {self.centroid}")
-            self.update()
-        except Exception as e:
-            print(e)
-
-    def clear_mesh(self):
-        self.mesh_loaded = None
-
-    def initializeGL(self):
-        glClearColor(0, 0, 0, 1)
-        glEnable(GL_DEPTH_TEST)
-
-    def resizeGL(self, width, height):
-        glViewport(0, 0, width, height)
-        glMatrixMode(GL_PROJECTION)
-        glLoadIdentity()
-
-        aspect = width / float(height)
-
-        self.gl_width = self.width()
-        self.gl_height = self.height()
-
-        gluPerspective(45.0, aspect, 0.01, 1000.0)
-        glMatrixMode(GL_MODELVIEW)
-
-    def unproject(self, x, y, z, modelview, projection, viewport):
-        mvp = np.dot(projection, modelview)
-        mvp_inv = np.linalg.inv(mvp)
-
-        ndc = np.array([(x - viewport[0]) / viewport[2] * 2 - 1,
-                        (y - viewport[1]) / viewport[3] * 2 - 1,
-                        2 * z - 1,
-                        1])
-
-        world = np.dot(mvp_inv, ndc)
-        print("world undproj", world)
-        return world[:3] / world[3]
-
-    def draw_ray(self, ray_start, ray_end):
-        glColor3f(1.0, 0.0, 0.0)  # Set the color of the ray (red)
-        glBegin(GL_LINES)
-        glVertex3f(*ray_start)
-        glVertex3f(*ray_end)
-        glEnd()
-
-    def mousePressEvent(self, event):
-        if event.buttons() & Qt.RightButton:
-            self.select_face(event)
-
-    def select_face(self, event):
-        x = event.position().x()
-        y = event.position().y()
-
-        modelview = glGetDoublev(GL_MODELVIEW_MATRIX)
-        projection = glGetDoublev(GL_PROJECTION_MATRIX)
-        viewport = glGetIntegerv(GL_VIEWPORT)
-
-        # Unproject near and far points in world space
-        ray_start = gluUnProject(x, y, 0.0, modelview, projection, viewport)
-        ray_end = gluUnProject(x, y, 1.0, modelview, projection, viewport)
-
-        ray_start = np.array(ray_start)
-        ray_end = np.array(ray_end)
-        ray_direction = ray_end - ray_start
-        ray_direction /= np.linalg.norm(ray_direction)
-
-        print(f"Ray start: {ray_start}")
-        print(f"Ray end: {ray_end}")
-        print(f"Ray direction: {ray_direction}")
-
-        self.selected_face = self.check_intersection(ray_start, ray_end)
-        print(f"Selected face: {self.selected_face}")
-
-        self.update()
-
-    def ray_box_intersection(self, ray_origin, ray_direction, box_min, box_max):
-        inv_direction = 1 / (ray_direction + 1e-7)  # Add small value to avoid division by zero
-        t1 = (box_min - ray_origin) * inv_direction
-        t2 = (box_max - ray_origin) * inv_direction
-
-        t_min = np.max(np.minimum(t1, t2))
-        t_max = np.min(np.maximum(t1, t2))
-
-        print(f"min: {t_min}, max: {t_max}" )
-
-        return t_max >= t_min and t_max > 0
-
-    def check_intersection(self, ray_start, ray_end):
-        # Get the current modelview matrix
-        modelview = glGetDoublev(GL_MODELVIEW_MATRIX)
-
-        # Transform vertices to camera space
-        vertices_cam = [np.dot(modelview, np.append(v, 1))[:3] for v in self.interactor_loaded[0]]
-
-        ray_direction = ray_end - ray_start
-        ray_direction /= np.linalg.norm(ray_direction)
-
-        print(f"Checking intersection with {len(self.interactor_loaded[1])} faces")
-        for face_idx, face in enumerate(self.interactor_loaded[1]):
-            v0, v1, v2 = [vertices_cam[i] for i in face]
-            intersection = self.moller_trumbore(ray_start, ray_direction, v0, v1, v2)
-            if intersection is not None:
-                print(f"Intersection found with face {face_idx}")
-                return face_idx
-
-        print("No intersection found")
-        return None
-
-    def moller_trumbore(self, ray_origin, ray_direction, v0, v1, v2):
-        epsilon = 1e-6
-        # Find vectors for two edges sharing v0
-        edge1 = v1 - v0
-        edge2 = v2 - v0
-        pvec = np.cross(ray_direction, edge2)
-
-        det = np.dot(edge1, pvec)
-        print(det)
-
-        """if det < epsilon:
-            return None"""
-
-        inv_det = 1.0 / det
-        tvec = ray_origin - v0
-        u = np.dot(tvec, pvec) * inv_det
-
-        print("u", u )
-
-        if u < 0.0 or u > 1.0:
-            return None
-
-        qvec = np.cross(tvec, edge1)
-
-        # Calculate v parameter and test bounds
-        v = np.dot(ray_direction, qvec) * inv_det
-        print("v", v)
-
-        if v < 0.0 or u + v > 1.0:
-            return None
-
-        # Calculate t, ray intersects triangle
-        t = np.dot(edge2, qvec) * inv_det
-        print("t",t)
-
-        if t > epsilon:
-            return ray_origin + t * ray_direction
-
-        return None
-
-    def ray_triangle_intersection(self, ray_origin, ray_direction, v0, v1, v2):
-        epsilon = 1e-5
-        edge1 = v1 - v0
-        edge2 = v2 - v0
-        h = np.cross(ray_direction, edge2)
-        a = np.dot(edge1, h)
-
-        print(f"Triangle vertices: {v0}, {v1}, {v2}")
-        print(f"a: {a}")
-
-        if abs(a) < epsilon:
-            print("Ray is parallel to the triangle")
-            return None  # Ray is parallel to the triangle
-
-        f = 1.0 / a
-        s = ray_origin - v0
-        u = f * np.dot(s, h)
-
-        print(f"u: {u}")
-
-        if u < 0.0 or u > 1.0:
-            print("u is out of range")
-            return None
-
-        q = np.cross(s, edge1)
-        v = f * np.dot(ray_direction, q)
-
-        print(f"v: {v}")
-
-        if v < 0.0 or u + v > 1.0:
-            print("v is out of range")
-            return None
-
-        t = f * np.dot(edge2, q)
-
-        print(f"t: {t}")
-
-        if t > epsilon:
-            intersection_point = ray_origin + t * ray_direction
-            print(f"Intersection point: {intersection_point}")
-            return intersection_point
-
-        print("t is too small")
-        return None
-    def paintGL(self):
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
-        glMatrixMode(GL_MODELVIEW)
-        glLoadIdentity()
-
-        # Apply camera transformation
-        glTranslatef(0, 0, self.zoom)
-        glRotatef(self.xRot, 1.0, 0.0, 0.0)
-        glRotatef(self.yRot, 0.0, 1.0, 0.0)
-
-        """# Apply model transformation
-        glTranslatef(self.tx, self.ty, self.tz)
-        glScalef(self.scale, self.scale, self.scale)
-        glRotatef(self.model_xRot, 1.0, 0.0, 0.0)
-        glRotatef(self.model_yRot, 0.0, 1.0, 0.0)
-        glRotatef(self.model_zRot, 0.0, 0.0, 1.0)"""
-
-        glColor3f(0.9, 0.8, 0.8)
-        self.draw_area()
-
-        if self.mesh_loaded is not None:
-            # Adjust the camera for the STL mesh
-            if self.centroid:
-                glPushMatrix()  # Save current transformation matrix
-                glScalef(self.scale_factor, self.scale_factor, self.scale_factor)  # Apply scaling
-
-                cx, cy, cz = self.centroid
-                gluLookAt(cx, cy, cz + 100, cx, cy, cz, 0, 1, 0)
-
-                self.draw_mesh_direct(self.mesh_loaded)
-                glPopMatrix()  # Restore transformation matrix
-
-        if self.interactor_loaded is not None:
-            # Draw interactor mesh
-            glPushMatrix()  # Save current transformation matrix
-            glScalef(self.scale_factor, self.scale_factor, self.scale_factor)  # Apply scaling
-
-            self.draw_interactor(self.interactor_loaded)
-            glPopMatrix()  # Restore transformation matrix
-
-        if self.selected_face is not None:
-            glColor3f(0.0, 1.0, 0.0)  # Red color for selected face
-            glBegin(GL_TRIANGLES)
-            for vertex_idx in self.interactor_loaded[1][self.selected_face]:
-                glVertex3fv(self.interactor_loaded[0][vertex_idx])
-            glEnd()
-
-            # Flush the OpenGL pipeline and swap buffers
-
-
-        if hasattr(self, 'ray_start') and hasattr(self, 'ray_end'):
-            self.draw_ray(self.ray_start, self.ray_end)
-
-        glFlush()
-
-    def draw_stl(self, vertices):
-        glEnable(GL_LIGHTING)
-        glEnable(GL_LIGHT0)
-        glEnable(GL_DEPTH_TEST)
-        glEnable(GL_COLOR_MATERIAL)
-        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
-
-        glLightfv(GL_LIGHT0, GL_POSITION, (0, 1, 1, 0))
-        glLightfv(GL_LIGHT0, GL_DIFFUSE, (0.6, 0.6, 0.6, 1.0))
-
-        glBegin(GL_TRIANGLES)
-        for triangle in vertices:
-            for vertex in triangle:
-                glVertex3fv(vertex)
-        glEnd()
-        self.update()
-
-    def draw_interactor(self, simp_mesh: tuple):
-        vertices, faces = simp_mesh
-
-        glEnable(GL_LIGHTING)
-        glEnable(GL_LIGHT0)
-        glEnable(GL_DEPTH_TEST)
-        glEnable(GL_COLOR_MATERIAL)
-        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
-
-        glLightfv(GL_LIGHT0, GL_POSITION, (0, 0.6, 0.6, 0))
-        glLightfv(GL_LIGHT0, GL_DIFFUSE, (0.4, 0.4, 0.4, 0.6))
-
-        # Draw the faces
-        glDisable(GL_LIGHTING)
-        glColor3f(0.2, 0.0, 0.0)  # Set face color to red (or any color you prefer)
-
-        glBegin(GL_TRIANGLES)
-        for face in faces:
-            for vertex_index in face:
-                glVertex3fv(vertices[vertex_index])
-        glEnd()
-
-        # Draw the lines (edges of the triangles)
-        glColor3f(0.0, 1.0, 0.0)  # Set line color to green (or any color you prefer)
-
-        glBegin(GL_LINES)
-        for face in faces:
-            for i in range(len(face)):
-                glVertex3fv(vertices[face[i]])
-                glVertex3fv(vertices[face[(i + 1) % len(face)]])
-        glEnd()
-
-        glEnable(GL_LIGHTING)  # Re-enable lighting if further drawing requires it
-
-    def draw_mesh_direct(self, points):
-        glEnable(GL_LIGHTING)
-        glEnable(GL_LIGHT0)
-        glEnable(GL_DEPTH_TEST)
-        glEnable(GL_COLOR_MATERIAL)
-        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
-
-        glLightfv(GL_LIGHT0, GL_POSITION, (0, 0.6, 0.6, 0))
-        glLightfv(GL_LIGHT0, GL_DIFFUSE, (0.4, 0.4, 0.4, 0.6))
-
-        glDisable(GL_LIGHTING)
-        glBegin(GL_TRIANGLES)
-        for vertex in points:
-            glVertex3fv(vertex)
-        glEnd()
-
-        # Draw the lines (edges of the triangles)
-        #glDisable(GL_LIGHTING)  # Disable lighting to avoid affecting the line color
-        glColor3f(0.0, 0.0, 0.0)  # Set line color to black (or any color you prefer)
-
-        glBegin(GL_LINES)
-        for i in range(0, len(points), 3):
-            glVertex3fv(points[i])
-            glVertex3fv(points[i + 1])
-
-            glVertex3fv(points[i + 1])
-            glVertex3fv(points[i + 2])
-
-            glVertex3fv(points[i + 2])
-            glVertex3fv(points[i])
-        glEnd()
-
-        glEnable(GL_LIGHTING)  # Re-enable lighting if further drawing requires it
-
-    def draw_area(self):
-        glColor3f(0.5, 0.5, 0.5)  # Gray color
-
-        glBegin(GL_LINES)
-        for x in range(0, self.width(), 1):
-            x_ndc = self.map_value_to_range(x, 0, value_max=self.width(), range_min=-self.gl_width, range_max=self.gl_width)
-            glVertex2f(x_ndc, -self.gl_height)  # Start from y = -1
-            glVertex2f(x_ndc, self.gl_height)   # End at y = 1
-
-        for y in range(0, self.height(), 1):
-            y_ndc = self.map_value_to_range(y, 0, value_max=self.height(), range_min=-self.gl_height, range_max=self.gl_height)
-            glVertex2f(-self.gl_width, y_ndc)  # Start from x = -1
-            glVertex2f(self.gl_width, y_ndc)   # End at x = 1
-        glEnd()
-
-    def mouseMoveEvent(self, event):
-        dx = event.x() - self.lastPos.x()
-        dy = event.y() - self.lastPos.y()
-
-        if event.buttons() & Qt.MouseButton.LeftButton :
-            self.xRot += 0.5 * dy
-            self.yRot += 0.5 * dx
-            self.lastPos = event.pos()
-        self.update()
-
-    def wheelEvent(self, event):
-        delta = event.angleDelta().y()
-        self.zoom += delta / 200
-        self.update()
-
-    def aspect_ratio(self):
-        return self.width() / self.height() * (1.0 / abs(self.zoom))
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    window = MainWindow()
-    window.show()
-    sys.exit(app.exec())

drawing_modules/sketcher_integration_example.py

@@ -1,201 +0,0 @@
-"""
-Example integration of the improved sketcher with the main Fluency application
-This shows how to replace the existing sketcher with the improved version
-"""
-
-from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QPushButton, QButtonGroup
-from PySide6.QtCore import Qt
-
-from improved_sketcher import ImprovedSketchWidget, SketchMode, SnapMode
-
-
-class SketcherIntegrationDemo(QMainWindow):
-    """Demo showing how to integrate the improved sketcher with UI controls"""
-    
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Improved Sketcher Integration Demo")
-        self.resize(1200, 800)
-        
-        # Create central widget
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-        
-        # Create layout
-        main_layout = QHBoxLayout(central_widget)
-        
-        # Create toolbar
-        self.create_toolbar(main_layout)
-        
-        # Create sketcher widget
-        self.sketcher = ImprovedSketchWidget()
-        main_layout.addWidget(self.sketcher, stretch=1)
-        
-        # Connect sketcher signals
-        self.connect_sketcher_signals()
-        
-        # Set initial mode
-        self.sketcher.set_mode(SketchMode.LINE)
-        
-    def create_toolbar(self, parent_layout):
-        """Create toolbar with sketching tools"""
-        toolbar_widget = QWidget()
-        toolbar_widget.setFixedWidth(200)
-        toolbar_layout = QVBoxLayout(toolbar_widget)
-        
-        # Drawing tools group
-        drawing_group = QWidget()
-        drawing_layout = QVBoxLayout(drawing_group)
-        drawing_layout.addWidget(self.create_label("Drawing Tools"))
-        
-        # Create drawing mode buttons
-        self.drawing_buttons = QButtonGroup(self)
-        self.drawing_buttons.setExclusive(True)
-        
-        drawing_modes = [
-            ("Line", SketchMode.LINE),
-            ("Rectangle", SketchMode.RECTANGLE),
-            ("Circle", SketchMode.CIRCLE),
-            ("Point", SketchMode.POINT),
-        ]
-        
-        for name, mode in drawing_modes:
-            button = QPushButton(name)
-            button.setCheckable(True)
-            button.clicked.connect(lambda checked, m=mode: self.set_drawing_mode(m))
-            self.drawing_buttons.addButton(button)
-            drawing_layout.addWidget(button)
-        
-        # Set line as default
-        self.drawing_buttons.buttons()[0].setChecked(True)
-        
-        # Constraint tools group
-        constraint_group = QWidget()
-        constraint_layout = QVBoxLayout(constraint_group)
-        constraint_layout.addWidget(self.create_label("Constraints"))
-        
-        # Create constraint buttons
-        constraint_modes = [
-            ("Coincident", SketchMode.COINCIDENT_PT_PT),
-            ("Horizontal", SketchMode.HORIZONTAL),
-            ("Vertical", SketchMode.VERTICAL),
-            ("Distance", SketchMode.DISTANCE),
-        ]
-        
-        for name, mode in constraint_modes:
-            button = QPushButton(name)
-            button.clicked.connect(lambda checked, m=mode: self.set_constraint_mode(m))
-            constraint_layout.addWidget(button)
-        
-        # Settings group
-        settings_group = QWidget()
-        settings_layout = QVBoxLayout(settings_group)
-        settings_layout.addWidget(self.create_label("Settings"))
-        
-        # Construction mode toggle
-        self.construction_button = QPushButton("Construction Mode")
-        self.construction_button.setCheckable(True)
-        self.construction_button.toggled.connect(self.toggle_construction_mode)
-        settings_layout.addWidget(self.construction_button)
-        
-        # Snap settings
-        snap_buttons = [
-            ("Point Snap", SnapMode.POINT),
-            ("Grid Snap", SnapMode.GRID),
-            ("Midpoint Snap", SnapMode.MIDPOINT),
-        ]
-        
-        for name, snap_mode in snap_buttons:
-            button = QPushButton(name)
-            button.setCheckable(True)
-            button.toggled.connect(lambda checked, sm=snap_mode: self.toggle_snap_mode(sm, checked))
-            settings_layout.addWidget(button)
-        
-        # Set default snaps
-        settings_layout.itemAt(1).widget().setChecked(True)  # Point snap on by default
-        
-        # View controls
-        view_group = QWidget()
-        view_layout = QVBoxLayout(view_group)
-        view_layout.addWidget(self.create_label("View"))
-        
-        zoom_fit_button = QPushButton("Zoom to Fit")
-        zoom_fit_button.clicked.connect(self.sketcher.zoom_to_fit)
-        view_layout.addWidget(zoom_fit_button)
-        
-        # Add groups to toolbar
-        toolbar_layout.addWidget(drawing_group)
-        toolbar_layout.addWidget(constraint_group)
-        toolbar_layout.addWidget(settings_group)
-        toolbar_layout.addWidget(view_group)
-        toolbar_layout.addStretch()
-        
-        parent_layout.addWidget(toolbar_widget)
-    
-    def create_label(self, text):
-        """Create a section label"""
-        from PySide6.QtWidgets import QLabel
-        from PySide6.QtCore import Qt
-        
-        label = QLabel(text)
-        label.setAlignment(Qt.AlignCenter)
-        label.setStyleSheet("font-weight: bold; padding: 5px; background-color: #333; color: white;")
-        return label
-    
-    def set_drawing_mode(self, mode):
-        """Set the sketcher to drawing mode"""
-        self.sketcher.set_mode(mode)
-        print(f"Drawing mode set to: {mode.name}")
-    
-    def set_constraint_mode(self, mode):
-        """Set the sketcher to constraint mode"""
-        self.sketcher.set_mode(mode)
-        # Uncheck all drawing buttons when in constraint mode
-        for button in self.drawing_buttons.buttons():
-            button.setChecked(False)
-        print(f"Constraint mode set to: {mode.name}")
-    
-    def toggle_construction_mode(self, checked):
-        """Toggle construction geometry mode"""
-        self.sketcher.set_construction_mode(checked)
-        print(f"Construction mode: {'enabled' if checked else 'disabled'}")
-    
-    def toggle_snap_mode(self, snap_mode, enabled):
-        """Toggle snap mode"""
-        self.sketcher.toggle_snap_mode(snap_mode, enabled)
-        print(f"Snap mode {snap_mode.name}: {'enabled' if enabled else 'disabled'}")
-    
-    def connect_sketcher_signals(self):
-        """Connect to sketcher signals for feedback"""
-        self.sketcher.geometry_created.connect(self.on_geometry_created)
-        self.sketcher.constraint_applied.connect(self.on_constraint_applied)
-        self.sketcher.sketch_modified.connect(self.on_sketch_modified)
-    
-    def on_geometry_created(self, geometry_type):
-        """Handle geometry creation"""
-        print(f"Created: {geometry_type}")
-        # Update status or trigger other actions
-    
-    def on_constraint_applied(self):
-        """Handle constraint application"""
-        print("Constraint applied successfully")
-        # Return to line drawing mode after constraint
-        self.sketcher.set_mode(SketchMode.LINE)
-        self.drawing_buttons.buttons()[0].setChecked(True)
-    
-    def on_sketch_modified(self):
-        """Handle sketch modifications"""
-        print("Sketch modified")
-        # Could trigger auto-save or update displays
-
-
-def replace_sketcher_in_main_app():
-    """
-    Example of how to replace the existing sketcher in main.py
-    
-    In main.py, replace this code:
-    
-    ```python\n    from drawing_modules.draw_widget_solve import SketchWidget\n    self.sketchWidget = SketchWidget()\n    ```\n    \n    With:\n    \n    ```python\n    from drawing_modules.improved_sketcher import ImprovedSketchWidget, SketchMode\n    self.sketchWidget = ImprovedSketchWidget()\n    \n    # Connect to existing signals (adapt as needed)\n    self.sketchWidget.constraint_applied.connect(self.draw_op_complete)\n    self.sketchWidget.sketch_modified.connect(self.on_sketch_changed)\n    \n    # Connect toolbar buttons to new sketcher modes\n    self.ui.pb_linetool.clicked.connect(lambda: self.sketchWidget.set_mode(SketchMode.LINE))\n    self.ui.pb_rectool.clicked.connect(lambda: self.sketchWidget.set_mode(SketchMode.RECTANGLE))\n    # ... etc for other buttons\n    ```\n    \n    The improved sketcher provides these advantages:\n    \n    1. **Better Architecture**: Clean separation of concerns, proper error handling\n    2. **Enhanced Features**: Rectangle and circle tools, improved constraints\n    3. **Better Performance**: Optimized rendering and interaction handling\n    4. **Extensibility**: Easy to add new tools and constraints\n    5. **Type Safety**: Proper type hints and validation\n    6. **Logging**: Built-in logging for debugging\n    7. **Settings**: Configurable snap and render settings\n    \n    Key differences to adapt:\n    \n    - Use SketchMode enum instead of string modes\n    - Connect to new signal names (constraint_applied, geometry_created, sketch_modified)\n    - Use set_mode() instead of individual mode methods\n    - Access sketch data through self.sketch property\n    - Use new geometry classes (Point2D, Line2D, Circle2D)\n    """\n    pass
-
-
-if __name__ == "__main__":\n    import sys\n    \n    app = QApplication(sys.argv)\n    \n    # Create and show the integration demo\n    demo = SketcherIntegrationDemo()\n    demo.show()\n    \n    print("Improved Sketcher Integration Demo")\n    print("==================================")\n    print("Features:")\n    print("- Line, Rectangle, Circle, Point drawing")\n    print("- Coincident, Horizontal, Vertical, Distance constraints")\n    print("- Construction geometry mode")\n    print("- Point, Grid, Midpoint snapping")\n    print("- Zoom to fit")\n    print("- Mouse wheel zoom")\n    print("- Right-click to cancel operations")\n    print("")\n    print("Usage:")\n    print("- Select a drawing tool and click in the viewport")\n    print("- Right-click to finish multi-point operations")\n    print("- Use constraint tools to add relationships")\n    print("- Toggle construction mode for helper geometry")\n    \n    sys.exit(app.exec())

drawing_modules/solvespace_example.py

@@ -1,35 +0,0 @@
-from python_solvespace import SolverSystem, ResultFlag
-
-def solve_constraint():
-    solv = SolverSystem()
-    wp = solv.create_2d_base()  # Workplane (Entity)
-    p0 = solv.add_point_2d(0, 0, wp)  # Entity
-    p1 = solv.add_point_2d(10, 10, wp)  # Entity
-    p2 = solv.add_point_2d(0, 10, wp)  # Entity
-    solv.dragged(p0, wp)  # Make a constraint with the entity
-
-    line0 = solv.add_line_2d(p0, p1, wp)  # Create entity with others
-    line1 = solv.add_line_2d(p0, p2, wp)
-    #solv.angle(line0, line1, 45, wp)  # Constrain two entities
-    solv.coincident(p0, p1, wp)
-    solv.add_constraint(100006, wp, 0, p1,p2, line0, line1)
-
-    line1 = solv.entity(-1)  # Entity handle can be re-generated and negatively indexed
-    solv.
-    if solv.solve() == ResultFlag.OKAY:
-        # Get the result (unpack from the entity or parameters)
-        # x and y are actually float type
-        dof = solv.dof()
-        x, y = solv.params(p1.params)
-        print(dof)
-        print(x)
-        print(y)
-
-    else:
-        # Error!
-        # Get the list of all constraints
-        failures = solv.failures()
-        print(failures)
-        ...
-
-solve_constraint()

drawing_modules/vtk_widget.py

@@ -1,861 +0,0 @@
-import sys
-
-import numpy as np
-import vtk
-from PySide6 import QtCore, QtWidgets
-from PySide6.QtCore import Signal
-from vtkmodules.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
-from vtkmodules.util.numpy_support import vtk_to_numpy, numpy_to_vtk
-
-
-class VTKWidget(QtWidgets.QWidget):
-    face_data = Signal(dict)
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.selected_vtk_line = []
-        self.access_selected_points = []
-        self.selected_normal = None
-        self.centroid = None
-        self.selected_edges = []
-        self.cell_normals = None
-
-        self.local_matrix = None
-
-        self.project_tosketch_points = []
-        self.project_tosketch_lines = []
-
-        self.vtk_widget = QVTKRenderWindowInteractor(self)
-
-        self.picked_edge_actors = []
-        self.displayed_normal_actors = []
-        self.body_actors_orig = []
-        self.projected_mesh_actors = []
-        self.interactor_actors = []
-
-        self.flip_toggle = False
-
-        # Create layout and add VTK widget
-        layout = QtWidgets.QVBoxLayout()
-        layout.addWidget(self.vtk_widget)
-        self.setLayout(layout)
-
-        # Create VTK pipeline
-        self.renderer = vtk.vtkRenderer()
-        self.renderer_projections = vtk.vtkRenderer()
-        self.renderer_indicators = vtk.vtkRenderer()
-
-        self.renderer.SetViewport(0, 0, 1, 1)  # Full viewport
-        self.renderer_projections.SetViewport(0, 0, 1, 1)  # Full viewport, overlays the first
-        self.renderer_indicators.SetViewport(0, 0, 1, 1)  # Full viewport, overlays the first
-
-        self.renderer.SetLayer(0)
-        self.renderer_projections.SetLayer(1)
-        self.renderer_indicators.SetLayer(2)  # This will be on top
-
-        # Preserve color and depth buffers for non-zero layers
-        self.renderer_projections.SetPreserveColorBuffer(True)
-        self.renderer_projections.SetPreserveDepthBuffer(True)
-        self.renderer_indicators.SetPreserveColorBuffer(True)
-        self.renderer_indicators.SetPreserveDepthBuffer(True)
-
-        # Add renderers to the render window
-        render_window = self.vtk_widget.GetRenderWindow()
-        render_window.SetNumberOfLayers(3)
-        render_window.AddRenderer(self.renderer)
-        render_window.AddRenderer(self.renderer_projections)
-        render_window.AddRenderer(self.renderer_indicators)
-
-        self.camera = vtk.vtkCamera()
-        self.camera.SetPosition(5, 5, 1000)
-        self.camera.SetFocalPoint(0, 0, 0)
-        self.camera.SetClippingRange(1, 10000)  # Adjusted clipping range
-
-        self.renderer.SetActiveCamera(self.camera)
-        self.renderer_projections.SetActiveCamera(self.camera)
-        self.renderer_indicators.SetActiveCamera(self.camera)
-
-        self.interactor = self.vtk_widget.GetRenderWindow().GetInteractor()
-
-        # Light Setup
-        def add_light(renderer, position, color=(1, 1, 1), intensity=1.0):
-            light = vtk.vtkLight()
-            light.SetPosition(position)
-            light.SetColor(color)
-            light.SetIntensity(intensity)
-            renderer.AddLight(light)
-
-        # Add lights from multiple directions
-        add_light(self.renderer, (1000, 0, 0), intensity=1.5)
-        add_light(self.renderer, (-1000, 0, 0), intensity=1.5)
-        add_light(self.renderer, (0, 1000, 0), intensity=1.5)
-        add_light(self.renderer, (0, -1000, 0), intensity=1.5)
-        add_light(self.renderer, (0, 0, 1000), intensity=1.5)
-        add_light(self.renderer, (0, 0, -1000), intensity=1.5)
-
-        # Set up picking
-        self.picker = vtk.vtkCellPicker()
-        self.picker.SetTolerance(0.005)
-
-        # Create a mapper and actor for picked cells
-        self.picked_mapper = vtk.vtkDataSetMapper()
-        self.picked_actor = vtk.vtkActor()
-        self.picked_actor.SetMapper(self.picked_mapper)
-        self.picked_actor.GetProperty().SetColor(1.0, 0.0, 0.0)  # Red color for picked faces
-        self.picked_actor.VisibilityOff()  # Initially hide the actor
-        self.renderer.AddActor(self.picked_actor)
-
-        # Create an extract selection filter
-        self.extract_selection = vtk.vtkExtractSelection()
-
-        # Set up interactor style
-        self.style = vtk.vtkInteractorStyleTrackballCamera()
-        self.interactor.SetInteractorStyle(self.style)
-
-        # Add observer for mouse clicks
-        self.interactor.AddObserver("RightButtonPressEvent", self.on_click)
-
-        # Add axis gizmo (smaller size)
-        self.axes = vtk.vtkAxesActor()
-        self.axes.SetTotalLength(0.5, 0.5, 0.5)  # Reduced size
-        self.axes.SetShaftType(0)
-        self.axes.SetAxisLabels(1)
-
-        # Create an orientation marker
-        self.axes_widget = vtk.vtkOrientationMarkerWidget()
-        self.axes_widget.SetOrientationMarker(self.axes)
-        self.axes_widget.SetInteractor(self.interactor)
-        self.axes_widget.SetViewport(0.0, 0.0, 0.2, 0.2)  # Set position and size
-        self.axes_widget.EnabledOn()
-        self.axes_widget.InteractiveOff()
-
-        # Start the interactor
-        self.interactor.Initialize()
-        self.interactor.Start()
-
-        # Create the grid
-        grid = self.create_grid(size=100, spacing=10)
-
-        # Setup actor and mapper
-        mapper = vtk.vtkPolyDataMapper()
-        mapper.SetInputData(grid)
-
-        actor = vtk.vtkActor()
-        actor.SetPickable(False)
-        actor.SetMapper(mapper)
-        actor.GetProperty().SetColor(0.5, 0.5, 0.5)  # Set grid color to gray
-
-        self.renderer.AddActor(actor)
-
-    def reset_camera(self):
-        self.renderer.ResetCamera()
-        self.camera.SetClippingRange(1, 100000)  # Set your desired range
-        self.vtk_widget.GetRenderWindow().Render()
-
-    def update_render(self):
-        self.renderer.ResetCameraClippingRange()
-        self.renderer_projections.ResetCameraClippingRange()
-        self.renderer_indicators.ResetCameraClippingRange()
-        self.camera.SetClippingRange(1, 100000)
-        self.vtk_widget.GetRenderWindow().Render()
-
-    def create_grid(self, size=100, spacing=10):
-        # Create a vtkPoints object and store the points in it
-        points = vtk.vtkPoints()
-
-        # Create lines
-        lines = vtk.vtkCellArray()
-
-        # Create the grid
-        for i in range(-size, size + 1, spacing):
-            # X-direction line
-            points.InsertNextPoint(i, -size, 0)
-            points.InsertNextPoint(i, size, 0)
-            line = vtk.vtkLine()
-            line.GetPointIds().SetId(0, points.GetNumberOfPoints() - 2)
-            line.GetPointIds().SetId(1, points.GetNumberOfPoints() - 1)
-            lines.InsertNextCell(line)
-
-            # Y-direction line
-            points.InsertNextPoint(-size, i, 0)
-            points.InsertNextPoint(size, i, 0)
-            line = vtk.vtkLine()
-            line.GetPointIds().SetId(0, points.GetNumberOfPoints() - 2)
-            line.GetPointIds().SetId(1, points.GetNumberOfPoints() - 1)
-            lines.InsertNextCell(line)
-
-        # Create a polydata to store everything in
-        grid = vtk.vtkPolyData()
-
-        # Add the points to the dataset
-        grid.SetPoints(points)
-
-        # Add the lines to the dataset
-        grid.SetLines(lines)
-
-        return grid
-
-    def on_receive_command(self, command):
-        """Calls the individual commands pressed in main"""
-        print("Receive command: ", command)
-        if command == "flip":
-            self.clear_actors_projection()
-            self.flip_toggle = not self.flip_toggle  # Toggle the flag
-            self.on_invert_normal()
-
-    @staticmethod
-    def compute_normal_from_lines(line1, line2):
-        vec1 = line1[1] - line1[0]
-        vec2 = line2[1] - line2[0]
-        normal = np.cross(vec1, vec2)
-        print(normal)
-        normal = normal / np.linalg.norm(normal)
-        return normal
-
-    def load_interactor_mesh(self, edges, off_vector):
-        # Create vtkPoints to store all points
-        points = vtk.vtkPoints()
-
-        # Create vtkCellArray to store the lines
-        lines = vtk.vtkCellArray()
-
-        for edge in edges:
-            # Add points for this edge
-            point_id1 = points.InsertNextPoint(edge[0])
-            point_id2 = points.InsertNextPoint(edge[1])
-
-            # Create a line using the point IDs
-            line = vtk.vtkLine()
-            line.GetPointIds().SetId(0, point_id1)
-            line.GetPointIds().SetId(1, point_id2)
-
-            # Add the line to the cell array
-            lines.InsertNextCell(line)
-
-        # Create vtkPolyData to store the geometry
-        polydata = vtk.vtkPolyData()
-        polydata.SetPoints(points)
-        polydata.SetLines(lines)
-
-        # Create a transform for mirroring across the y-axis
-        matrix_transform = vtk.vtkTransform()
-
-        if self.local_matrix:
-            print(self.local_matrix)
-            matrix = vtk.vtkMatrix4x4()
-            matrix.DeepCopy(self.local_matrix)
-            matrix.Invert()
-            matrix_transform.SetMatrix(matrix)
-            #matrix_transform.Scale(1, 1, 1)  # This mirrors across the y-axis
-
-        # Apply the matrix transform
-        transformFilter = vtk.vtkTransformPolyDataFilter()
-        transformFilter.SetInputData(polydata)
-        transformFilter.SetTransform(matrix_transform)
-        transformFilter.Update()
-
-        # Create and apply the offset transform
-        offset_transform = vtk.vtkTransform()
-        offset_transform.Translate(off_vector[0], off_vector[1], off_vector[2])
-
-        offsetFilter = vtk.vtkTransformPolyDataFilter()
-        offsetFilter.SetInputConnection(transformFilter.GetOutputPort())
-        offsetFilter.SetTransform(offset_transform)
-        offsetFilter.Update()
-
-        # Create a mapper and actor
-        mapper = vtk.vtkPolyDataMapper()
-        mapper.SetInputConnection(offsetFilter.GetOutputPort())
-
-        actor = vtk.vtkActor()
-        actor.SetMapper(mapper)
-        actor.GetProperty().SetColor(1.0, 1.0, 1.0)
-        actor.GetProperty().SetLineWidth(4)  # Set line width
-
-        # Add the actor to the scene
-        self.renderer.AddActor(actor)
-        self.interactor_actors.append(actor)
-
-        mapper.Update()
-        self.vtk_widget.GetRenderWindow().Render()
-
-    def render_from_points_direct_with_faces(self, vertices, faces, color=(0.1, 0.2, 0.8), line_width=2, point_size=5):
-        """Sketch Widget has inverted Y axiis therefore we invert y via scale here until fix"""
-
-        # Handle empty vertices or faces
-        if len(vertices) == 0 or len(faces) == 0:
-            print("Warning: No vertices or faces to render")
-            return
-
-        points = vtk.vtkPoints()
-
-        # Validate vertices shape
-        if vertices.ndim != 2 or vertices.shape[1] != 3:
-            print(f"Warning: Invalid vertex shape {vertices.shape}. Expected Nx3.")
-            return
-
-        # Validate faces shape
-        if faces.ndim != 2 or faces.shape[1] != 3:
-            print(f"Warning: Invalid face shape {faces.shape}. Expected Nx3.")
-            return
-
-        # Use SetData with numpy array - ensure vertices are float32
-        try:
-            vertices_float = np.asarray(vertices, dtype=np.float32)
-            vtk_array = numpy_to_vtk(vertices_float, deep=True)
-            points.SetData(vtk_array)
-        except Exception as e:
-            print(f"Error converting vertices to VTK array: {e}")
-            # Fallback: manually insert points
-            for vertex in vertices:
-                points.InsertNextPoint(vertex[0], vertex[1], vertex[2])
-
-        # Create a vtkCellArray to store the triangles
-        triangles = vtk.vtkCellArray()
-        num_vertices = len(vertices)
-        
-        for i, face in enumerate(faces):
-            # Validate face indices
-            if (face[0] >= num_vertices or face[0] < 0 or 
-                face[1] >= num_vertices or face[1] < 0 or 
-                face[2] >= num_vertices or face[2] < 0):
-                print(f"Warning: Invalid face indices {face} at index {i}. Skipping face.")
-                continue
-                
-            triangle = vtk.vtkTriangle()
-            triangle.GetPointIds().SetId(0, int(face[0]))
-            triangle.GetPointIds().SetId(1, int(face[1]))
-            triangle.GetPointIds().SetId(2, int(face[2]))
-            triangles.InsertNextCell(triangle)
-
-        # Check if we have any valid triangles
-        if triangles.GetNumberOfCells() == 0:
-            print("Warning: No valid triangles to render")
-            return
-
-        # Create a polydata object
-        polydata = vtk.vtkPolyData()
-        polydata.SetPoints(points)
-        polydata.SetPolys(triangles)
-
-        # Calculate normals
-        normalGenerator = vtk.vtkPolyDataNormals()
-        normalGenerator.SetInputData(polydata)
-        normalGenerator.ComputePointNormalsOn()
-        normalGenerator.ComputeCellNormalsOn()
-        normalGenerator.Update()
-
-        # Safely get cell normals, with fallback if they're not available
-        cell_normals = normalGenerator.GetOutput().GetCellData().GetNormals()
-        if cell_normals:
-            try:
-                self.cell_normals = vtk_to_numpy(cell_normals)
-            except Exception as e:
-                print(f"Warning: Could not convert cell normals to numpy array: {e}")
-                self.cell_normals = None
-        else:
-            print("Warning: No cell normals available")
-            self.cell_normals = None
-
-        # Create a mapper and actor
-        mapper = vtk.vtkPolyDataMapper()
-        mapper.SetInputData(polydata)
-
-        actor = vtk.vtkActor()
-        actor.SetMapper(mapper)
-        actor.GetProperty().SetColor(color)
-        actor.GetProperty().EdgeVisibilityOff()
-        actor.GetProperty().SetLineWidth(line_width)
-        actor.GetProperty().SetMetallic(1)
-        actor.GetProperty().SetOpacity(0.8)
-        actor.SetPickable(False)
-
-        self.renderer.AddActor(actor)
-        self.body_actors_orig.append(actor)
-        self.vtk_widget.GetRenderWindow().Render()
-
-    def clear_body_actors(self):
-        for actor in self.body_actors_orig:
-            self.renderer.RemoveActor(actor)
-
-    def visualize_matrix(self, matrix):
-        points = vtk.vtkPoints()
-        for i in range(4):
-            for j in range(4):
-                points.InsertNextPoint(matrix.GetElement(0, j),
-                                       matrix.GetElement(1, j),
-                                       matrix.GetElement(2, j))
-
-        polydata = vtk.vtkPolyData()
-        polydata.SetPoints(points)
-
-        mapper = vtk.vtkPolyDataMapper()
-        mapper.SetInputData(polydata)
-
-        actor = vtk.vtkActor()
-        actor.SetMapper(mapper)
-        actor.GetProperty().SetPointSize(5)
-
-        self.renderer.AddActor(actor)
-
-    def numpy_to_vtk(self, array, deep=True):
-        """Convert a numpy array to a vtk array."""
-        vtk_array = vtk.vtkDoubleArray()
-        vtk_array.SetNumberOfComponents(array.shape[1])
-        vtk_array.SetNumberOfTuples(array.shape[0])
-
-        for i in range(array.shape[0]):
-            for j in range(array.shape[1]):
-                vtk_array.SetComponent(i, j, array[i, j])
-
-        return vtk_array
-
-    def get_points_and_edges_from_polydata(self, polydata) -> list:
-        # Extract points
-        points = {}
-        vtk_points = polydata.GetPoints()
-        for i in range(vtk_points.GetNumberOfPoints()):
-            point = vtk_points.GetPoint(i)
-            points[i] = np.array(point)
-
-        # Extract edges
-        edges = []
-        for i in range(polydata.GetNumberOfCells()):
-            cell = polydata.GetCell(i)
-            if cell.GetCellType() == vtk.VTK_LINE:
-                point_ids = cell.GetPointIds()
-                edge = (point_ids.GetId(0), point_ids.GetId(1))
-                edges.append(edge)
-
-        return points, edges
-
-    def project_mesh_to_plane(self, input_mesh, normal, origin):
-        # Create the projector
-        projector = vtk.vtkProjectPointsToPlane()
-        projector.SetInputData(input_mesh)
-        projector.SetProjectionTypeToSpecifiedPlane()
-
-        # Set the normal and origin of the plane
-        projector.SetNormal(normal)
-        projector.SetOrigin(origin)
-
-        # Execute the projection
-        projector.Update()
-
-        # Get the projected mesh
-        projected_mesh = projector.GetOutput()
-        return projected_mesh
-
-    def compute_2d_coordinates(self, projected_mesh, normal):
-        # Normalize the normal vector
-        normal = np.array(normal)
-        normal = normal / np.linalg.norm(normal)
-
-        # Create a vtkTransform
-        transform = vtk.vtkTransform()
-        transform.PostMultiply()  # This ensures transforms are applied in the order we specify
-
-        # Rotate so that the normal aligns with the Z-axis
-        rotation_axis = np.cross(normal, [0, 0, 1])
-        angle = np.arccos(np.dot(normal, [0, 0, 1])) * 180 / np.pi  # Convert to degrees
-
-        if np.linalg.norm(rotation_axis) > 1e-6:  # Check if rotation is needed
-            transform.RotateWXYZ(angle, rotation_axis[0], rotation_axis[1], rotation_axis[2])
-
-        # Get the transformation matrix
-        matrix = transform.GetMatrix()
-        self.local_matrix = [matrix.GetElement(i, j) for i in range(4) for j in range(4)]
-
-        # Apply the transform to the polydata
-        transformFilter = vtk.vtkTransformPolyDataFilter()
-        transformFilter.SetInputData(projected_mesh)
-        transformFilter.SetTransform(transform)
-        transformFilter.Update()
-
-        # Get the transformed points
-        transformed_polydata = transformFilter.GetOutput()
-        points = transformed_polydata.GetPoints()
-
-        # Extract 2D coordinates
-        xy_coordinates = []
-        for i in range(points.GetNumberOfPoints()):
-            point = points.GetPoint(i)
-            xy_coordinates.append((point[0], point[1]))
-
-        return xy_coordinates
-
-    def compute_2d_coordinates_line(self, projected_mesh, normal):
-        # Normalize the normal vector
-        normal = np.array(normal)
-        normal = normal / np.linalg.norm(normal)
-
-        # Create a vtkTransform
-        transform = vtk.vtkTransform()
-        transform.PostMultiply()  # This ensures transforms are applied in the order we specify
-
-        # Rotate so that the normal aligns with the Z-axis
-        rotation_axis = np.cross(normal, [0, 0, 1])
-        angle = np.arccos(np.dot(normal, [0, 0, 1])) * 180 / np.pi  # Convert to degrees
-
-        if np.linalg.norm(rotation_axis) > 1e-6:  # Check if rotation is needed
-            transform.RotateWXYZ(angle, rotation_axis[0], rotation_axis[1], rotation_axis[2])
-
-        # Get the transformation matrix
-        matrix = transform.GetMatrix()
-        self.local_matrix = [matrix.GetElement(i, j) for i in range(4) for j in range(4)]
-
-        # Apply the transform to the polydata
-        transformFilter = vtk.vtkTransformPolyDataFilter()
-        transformFilter.SetInputData(projected_mesh)
-        transformFilter.SetTransform(transform)
-        transformFilter.Update()
-
-        # Get the transformed points
-        transformed_polydata = transformFilter.GetOutput()
-        points = transformed_polydata.GetPoints()
-        lines = transformed_polydata.GetLines()
-
-        # Extract 2D coordinates
-        xy_coordinates = []
-
-        if points and lines:
-            points_data = points.GetData()
-            line_ids = vtk.vtkIdList()
-
-            # Loop through all the lines in the vtkCellArray
-            lines.InitTraversal()
-            while lines.GetNextCell(line_ids):
-                line_coordinates = []
-                for j in range(line_ids.GetNumberOfIds()):
-                    point_id = line_ids.GetId(j)
-                    point = points.GetPoint(point_id)
-                    line_coordinates.append((point[0], point[1]))  # Only take x, y
-                xy_coordinates.append(line_coordinates)
-
-        return xy_coordinates
-
-
-    def compute_2d_coordinates_line_bak(self, line_source, normal):
-        # Ensure the input is a vtkLineSource
-        print("line", line_source)
-        if not isinstance(line_source, vtk.vtkLineSource):
-            raise ValueError("Input must be a vtkLineSource")
-
-        # Normalize the normal vector
-        normal = np.array(normal)
-        normal = normal / np.linalg.norm(normal)
-
-        # Create a vtkTransform
-        transform = vtk.vtkTransform()
-        transform.PostMultiply()  # This ensures transforms are applied in the order we specify
-
-        # Rotate so that the normal aligns with the Z-axis
-        rotation_axis = np.cross(normal, [0, 0, 1])
-        angle = np.arccos(np.dot(normal, [0, 0, 1])) * 180 / np.pi  # Convert to degrees
-
-        if np.linalg.norm(rotation_axis) > 1e-6:  # Check if rotation is needed
-            transform.RotateWXYZ(angle, rotation_axis[0], rotation_axis[1], rotation_axis[2])
-
-        # Get the transformation matrix
-        matrix = transform.GetMatrix()
-        local_matrix = [matrix.GetElement(i, j) for i in range(4) for j in range(4)]
-
-        # Get the polydata from the line source
-        line_source.Update()
-        polydata = line_source.GetOutput()
-
-        # Apply the transform to the polydata
-        transform_filter = vtk.vtkTransformPolyDataFilter()
-        transform_filter.SetInputData(polydata)
-        transform_filter.SetTransform(transform)
-        transform_filter.Update()
-
-        # Get the transformed points
-        transformed_polydata = transform_filter.GetOutput()
-        transformed_points = transformed_polydata.GetPoints()
-
-        # Extract 2D coordinates
-        xy_coordinates = []
-        for i in range(transformed_points.GetNumberOfPoints()):
-            point = transformed_points.GetPoint(i)
-            xy_coordinates.append((point[0], point[1]))
-
-        return xy_coordinates
-
-    def project_2d_to_3d(self, xy_coordinates, normal):
-        # Normalize the normal vector
-        normal = np.array(normal)
-        normal = normal / np.linalg.norm(normal)
-
-        # Create a vtkTransform for the reverse transformation
-        reverse_transform = vtk.vtkTransform()
-        reverse_transform.PostMultiply()  # This ensures transforms are applied in the order we specify
-
-        # Compute the rotation axis and angle (same as in compute_2d_coordinates)
-        rotation_axis = np.cross(normal, [0, 0, 1])
-        angle = np.arccos(np.dot(normal, [0, 0, 1])) * 180 / np.pi  # Convert to degrees
-
-        if np.linalg.norm(rotation_axis) > 1e-6:  # Check if rotation is needed
-            # Apply the inverse rotation
-            reverse_transform.RotateWXYZ(-angle, rotation_axis[0], rotation_axis[1], rotation_axis[2])
-
-        # Create vtkPoints to store the 2D points
-        points_2d = vtk.vtkPoints()
-        for x, y in xy_coordinates:
-            points_2d.InsertNextPoint(x, y, 0)  # Z-coordinate is 0 for 2D points
-
-        # Create a polydata with the 2D points
-        polydata_2d = vtk.vtkPolyData()
-        polydata_2d.SetPoints(points_2d)
-
-        # Apply the reverse transform to the polydata
-        transform_filter = vtk.vtkTransformPolyDataFilter()
-        transform_filter.SetInputData(polydata_2d)
-        transform_filter.SetTransform(reverse_transform)
-        transform_filter.Update()
-
-        # Get the transformed points (now in 3D)
-        transformed_polydata = transform_filter.GetOutput()
-        transformed_points = transformed_polydata.GetPoints()
-
-        # Extract 3D coordinates
-        xyz_coordinates = []
-        for i in range(transformed_points.GetNumberOfPoints()):
-            point = transformed_points.GetPoint(i)
-            xyz_coordinates.append((point[0], point[1], point[2]))
-
-        return xyz_coordinates
-
-    def add_normal_line(self, origin, normal, length=10.0, color=(1, 0, 0)):
-        # Normalize the normal vector
-        normal = np.array(normal)
-        normal = normal / np.linalg.norm(normal)
-
-        # Calculate the end point
-        end_point = origin + normal * length
-
-        # Create vtkPoints
-        points = vtk.vtkPoints()
-        points.InsertNextPoint(origin)
-        points.InsertNextPoint(end_point)
-
-        # Create a line
-        line = vtk.vtkLine()
-        line.GetPointIds().SetId(0, 0)
-        line.GetPointIds().SetId(1, 1)
-
-        # Create a cell array to store the line
-        lines = vtk.vtkCellArray()
-        lines.InsertNextCell(line)
-
-        # Create a polydata to store everything in
-        polyData = vtk.vtkPolyData()
-        polyData.SetPoints(points)
-        polyData.SetLines(lines)
-
-        # Create mapper and actor
-        mapper = vtk.vtkPolyDataMapper()
-        mapper.SetInputData(polyData)
-
-        actor = vtk.vtkActor()
-        actor.SetMapper(mapper)
-        actor.GetProperty().SetColor(color)
-        actor.GetProperty().SetLineWidth(2)  # Adjust line width as needed
-
-        # Add to renderer
-        self.renderer.AddActor(actor)
-        self.vtk_widget.GetRenderWindow().Render()
-
-        return actor  # Return the actor in case you need to remove or modify it later
-
-    def on_invert_normal(self):
-        # Kippstufe für Normal flip
-        if self.selected_normal is not None:
-            self.clear_actors_normals()
-            self.compute_projection(self.flip_toggle)
-
-    def on_click(self, obj, event):
-        click_pos = self.interactor.GetEventPosition()
-
-        # Perform pick
-        self.picker.Pick(click_pos[0], click_pos[1], 0, self.renderer)
-
-        # Get picked cell ID
-        cell_id = self.picker.GetCellId()
-
-        if cell_id != -1:
-            print(f"Picked cell ID: {cell_id}")
-
-            # Get the polydata and the picked cell
-            polydata = self.picker.GetActor().GetMapper().GetInput()
-            cell = polydata.GetCell(cell_id)
-
-            # Ensure it's a line
-            if cell.GetCellType() == vtk.VTK_LINE:
-
-                # Get the two points of the line
-                point_id1 = cell.GetPointId(0)
-                point_id2 = cell.GetPointId(1)
-
-                proj_point1 = polydata.GetPoint(point_id1)
-                proj_point2 = polydata.GetPoint(point_id2)
-
-                self.access_selected_points.append((proj_point1, proj_point2))
-
-                point1 = np.array(proj_point1)
-                point2 = np.array(proj_point2)
-
-                #print(f"Line starts at: {point1}")
-                #print(f"Line ends at: {point2}")
-
-                # Store this line for later use if needed
-                self.selected_edges.append((point1, point2))
-
-                # Create a new vtkLineSource for the picked edge
-                line_source = vtk.vtkLineSource()
-                line_source.SetPoint1(point1)
-                line_source.SetPoint2(point2)
-
-                self.selected_vtk_line.append(line_source)
-
-                # Create a mapper and actor for the picked edge
-                edge_mapper = vtk.vtkPolyDataMapper()
-                edge_mapper.SetInputConnection(line_source.GetOutputPort())
-
-                edge_actor = vtk.vtkActor()
-                edge_actor.SetMapper(edge_mapper)
-                edge_actor.GetProperty().SetColor(1.0, 0.0, 0.0)  # Red color for picked edges
-                edge_actor.GetProperty().SetLineWidth(5)  # Make the line thicker
-
-                # Add the actor to the renderer and store it
-                self.renderer_indicators.AddActor(edge_actor)
-                self.picked_edge_actors.append(edge_actor)
-
-                if len(self.selected_edges) == 2:
-                    self.compute_projection(False)
-
-                if len(self.selected_edges) > 2:
-                    # Clear lists for selection
-                    self.selected_vtk_line.clear()
-                    self.selected_edges.clear()
-                    self.clear_edge_select()
-
-                    # Clear Actors from view
-                    self.clear_actors_projection()
-                    self.clear_actors_sel_edges()
-                    self.clear_actors_normals()
-
-
-    def find_origin_vertex(self, edge1, edge2):
-        if edge1[0] == edge2[0]or edge1[0] == edge2[1]:
-            return edge1[0]
-        elif edge1[1] == edge2[0] or edge1[1] == edge2[1]:
-            return edge1[1]
-        else:
-            return None  # The edges don't share a vertex
-
-    def clear_edge_select(self ):
-        # Clear selection after projection was succesful
-        self.selected_edges = []
-        self.selected_normal = []
-
-    def clear_actors_projection(self):
-        """Removes all actors that were used for projection"""
-        for flat_mesh in self.projected_mesh_actors:
-            self.renderer_projections.RemoveActor(flat_mesh)
-
-    def clear_actors_normals(self):
-        for normals in self.displayed_normal_actors:
-            self.renderer_indicators.RemoveActor(normals)
-
-    def clear_actors_sel_edges(self):
-        for edge_line in self.picked_edge_actors:
-            self.renderer_indicators.RemoveActor(edge_line)
-
-    def clear_actors_interactor(self):
-        ### Clear the outline of the mesh
-        for interactor in self.interactor_actors:
-            self.renderer.RemoveActor(interactor)
-
-    def compute_projection(self, direction_invert: bool = False):
-
-        # Compute the normal from the two selected edges        )
-        edge1 = self.selected_edges[0][1] - self.selected_edges[0][0]
-        edge2 = self.selected_edges[1][1] - self.selected_edges[1][0]
-        selected_normal = np.cross(edge1, edge2)
-        selected_normal = selected_normal / np.linalg.norm(selected_normal)
-        #print("Computed normal:", self.selected_normal)
-
-        # Invert the normal in local z if direction_invert is True
-        if direction_invert:
-            self.selected_normal = -selected_normal
-        else:
-            self.selected_normal = selected_normal
-
-        self.centroid = np.mean([point for edge in self.selected_edges for point in edge], axis=0)
-        #self.centroid = self.find_origin_vertex(edge1, edge2)
-
-        # Draw the normal line
-        normal_length = 50  # Adjust this value to change the length of the normal line
-        normal_actor = self.add_normal_line(self.centroid, self.selected_normal, length=normal_length,
-                                            color=(1, 0, 0))
-
-        polydata = self.picker.GetActor().GetMapper().GetInput()
-
-        projected_polydata = self.project_mesh_to_plane(polydata, self.selected_normal, self.centroid)
-
-        # Extract 2D coordinates
-        self.project_tosketch_points = self.compute_2d_coordinates(projected_polydata, self.selected_normal)
-
-        # Green indicator mesh needs to be translated to xy point paris start end.
-        self.project_tosketch_lines = self.compute_2d_coordinates_line(projected_polydata, self.selected_normal)
-
-        print("result", self.project_tosketch_lines)
-        """# Seperately rotate selected edges for drawing
-        self.project_tosketch_lines.clear()
-        for vtk_line in self.selected_vtk_line:
-            proj_vtk_line = self.compute_2d_coordinates_line(vtk_line, self.selected_normal)
-            self.project_tosketch_lines.append(proj_vtk_line)
-            print("outgoing lines", self.project_tosketch_lines)"""
-
-        # Create a mapper and actor for the projected data
-        mapper = vtk.vtkPolyDataMapper()
-        mapper.SetInputData(projected_polydata)
-
-        # Projected mesh in green
-        actor = vtk.vtkActor()
-        actor.SetMapper(mapper)
-        #actor.GetProperty().SetRenderLinesAsTubes(True)
-        actor.GetProperty().SetColor(0.0, 1.0, 0.0)  # Set color to green
-        actor.GetProperty().SetLineWidth(4)  # Set line width
-
-        self.renderer_indicators.AddActor(normal_actor)
-        self.displayed_normal_actors.append(normal_actor)
-
-        self.renderer_projections.AddActor(actor)
-        self.projected_mesh_actors.append(actor)
-
-        # Render the scene
-        self.update_render()
-        self.vtk_widget.GetRenderWindow().Render()
-
-    def start(self):
-        self.interactor.Initialize()
-        self.interactor.Start()
-
-
-class MainWindow(QtWidgets.QMainWindow):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.vtk_widget = VTKWidget()
-        self.setCentralWidget(self.vtk_widget)
-        self.setWindowTitle("VTK Mesh Viewer")
-        self.vtk_widget.create_cube_mesh()
-        self.show()
-        self.vtk_widget.start()
-
-
-if __name__ == "__main__":
-    app = QtWidgets.QApplication(sys.argv)
-    window = MainWindow()
-    sys.exit(app.exec())

drawing_modules/vtk_widget_alt_methods.py

@@ -1,337 +0,0 @@
-def are_coplanar(self, normal1, normal2, point1, point2, tolerance=1e-6):
-    # Check if normals are parallel
-    if np.abs(np.dot(normal1, normal2)) < 1 - tolerance:
-        return False
-
-    # Check if points lie on the same plane
-    diff = point2 - point1
-    return np.abs(np.dot(diff, normal1)) < tolerance
-
-
-def merge_coplanar_triangles(self, polydata):
-    # Compute normals
-    normalGenerator = vtk.vtkPolyDataNormals()
-    normalGenerator.SetInputData(polydata)
-    normalGenerator.ComputePointNormalsOff()
-    normalGenerator.ComputeCellNormalsOn()
-    normalGenerator.Update()
-
-    mesh = normalGenerator.GetOutput()
-    n_cells = mesh.GetNumberOfCells()
-
-    # Create a map to store merged triangles
-    merged = {}
-
-    for i in range(n_cells):
-        if i in merged:
-            continue
-
-        cell = mesh.GetCell(i)
-        normal = np.array(mesh.GetCellData().GetNormals().GetTuple(i))
-        point = np.array(cell.GetPoints().GetPoint(0))
-
-        merged[i] = [i]
-
-        for j in range(i + 1, n_cells):
-            if j in merged:
-                continue
-
-            cell_j = mesh.GetCell(j)
-            normal_j = np.array(mesh.GetCellData().GetNormals().GetTuple(j))
-            point_j = np.array(cell_j.GetPoints().GetPoint(0))
-
-            if self.are_coplanar(normal, normal_j, point, point_j):
-                merged[i].append(j)
-
-    # Create new polygons
-    new_polygons = vtk.vtkCellArray()
-    for group in merged.values():
-        if len(group) > 1:
-            polygon = vtk.vtkPolygon()
-            points = set()
-            for idx in group:
-                cell = mesh.GetCell(idx)
-                for j in range(3):
-                    point_id = cell.GetPointId(j)
-                    points.add(point_id)
-            polygon.GetPointIds().SetNumberOfIds(len(points))
-            for j, point_id in enumerate(points):
-                polygon.GetPointIds().SetId(j, point_id)
-            new_polygons.InsertNextCell(polygon)
-        else:
-            new_polygons.InsertNextCell(mesh.GetCell(group[0]))
-
-    # Create new polydata
-    new_polydata = vtk.vtkPolyData()
-    new_polydata.SetPoints(mesh.GetPoints())
-    new_polydata.SetPolys(new_polygons)
-
-    return new_polydata
-
-
-def create_cube_mesh(self):
-    # cube_source = vtk.vtkSuperquadricSource()
-
-    reader = vtk.vtkSTLReader()
-    reader.SetFileName("case.stl")  # Replace with your mesh file path
-    reader.Update()
-
-    featureEdges = vtk.vtkFeatureEdges()
-    featureEdges.SetInputConnection(reader.GetOutputPort())
-    featureEdges.BoundaryEdgesOn()
-    featureEdges.FeatureEdgesOn()
-    featureEdges.ManifoldEdgesOff()
-    featureEdges.NonManifoldEdgesOff()
-    featureEdges.Update()
-
-    # print(cube_source)
-    mapper = vtk.vtkPolyDataMapper()
-    mapper.SetInputConnection(reader.GetOutputPort())
-    actor = vtk.vtkActor()
-    actor.SetMapper(mapper)
-    self.renderer.AddActor(actor)
-
-    mapper_edge = vtk.vtkPolyDataMapper()
-    mapper_edge.SetInputConnection(featureEdges.GetOutputPort())
-    actor = vtk.vtkActor()
-    actor.SetMapper(mapper_edge)
-    self.renderer.AddActor(actor)
-
-
-def simplify_mesh(self, input_mesh, target_reduction):
-    # Create the quadric decimation filter
-    decimate = vtk.vtkDecimatePro()
-    decimate.SetInputData(input_mesh)
-
-    # Set the reduction factor (0 to 1, where 1 means maximum reduction)
-    decimate.SetTargetReduction(target_reduction)
-
-    # Optional: Preserve topology (if needed)
-    decimate.PreserveTopologyOn()
-
-    # Perform the decimation
-    decimate.Update()
-
-    return decimate.GetOutput()
-
-
-def combine_coplanar_faces(self, input_polydata, tolerance=0.001):
-    # Clean the polydata to merge duplicate points
-    clean = vtk.vtkCleanPolyData()
-    clean.SetInputData(input_polydata)
-    clean.SetTolerance(tolerance)
-    clean.Update()
-
-    # Generate normals and merge coplanar polygons
-    normals = vtk.vtkPolyDataNormals()
-    normals.SetInputConnection(clean.GetOutputPort())
-    normals.SplittingOff()  # Disable splitting of sharp edges
-    normals.ConsistencyOn()  # Ensure consistent polygon ordering
-    normals.AutoOrientNormalsOn()  # Automatically orient normals
-    normals.ComputePointNormalsOff()  # We only need face normals
-    normals.ComputeCellNormalsOn()  # Compute cell normals
-    normals.Update()
-
-    return normals.GetOutput()
-
-
-def poisson_reconstruction(self, points):
-    # Create a polydata object from points
-    point_polydata = vtk.vtkPolyData()
-    point_polydata.SetPoints(points)
-
-    # Create a surface reconstruction filter
-    surf = vtk.vtkSurfaceReconstructionFilter()
-    surf.SetInputData(point_polydata)
-    surf.Update()
-
-    # Create a contour filter to extract the surface
-    cf = vtk.vtkContourFilter()
-    cf.SetInputConnection(surf.GetOutputPort())
-    cf.SetValue(0, 0.0)
-    cf.Update()
-
-    # Reverse normals
-    reverse = vtk.vtkReverseSense()
-    reverse.SetInputConnection(cf.GetOutputPort())
-    reverse.ReverseCellsOn()
-    reverse.ReverseNormalsOn()
-    reverse.Update()
-
-    return reverse.GetOutput()
-
-
-def create_simplified_outline(self, polydata):
-    featureEdges = vtk.vtkFeatureEdges()
-    featureEdges.SetInputData(polydata)
-    featureEdges.BoundaryEdgesOn()
-    featureEdges.FeatureEdgesOn()
-    featureEdges.ManifoldEdgesOff()
-    featureEdges.NonManifoldEdgesOff()
-    featureEdges.Update()
-
-    """# 3. Clean the edges to merge duplicate points
-    cleaner = vtk.vtkCleanPolyData()
-    cleaner.SetInputConnection(feature_edges.GetOutputPort())
-    cleaner.Update()
-
-    # 4. Optional: Smooth the outline
-    smooth = vtk.vtkSmoothPolyDataFilter()
-    smooth.SetInputConnection(cleaner.GetOutputPort())
-    smooth.SetNumberOfIterations(15)
-    smooth.SetRelaxationFactor(0.1)
-    smooth.FeatureEdgeSmoothingOff()
-    smooth.BoundarySmoothingOn()
-    smooth.Update()"""
-
-    return featureEdges
-
-
-def render_from_points_direct_with_faces(self, vertices, faces):
-    points = vtk.vtkPoints()
-    for i in range(vertices.shape[0]):
-        points.InsertNextPoint(vertices[i])
-
-    # Create a vtkCellArray to store the triangles
-    triangles = vtk.vtkCellArray()
-    for i in range(faces.shape[0]):
-        triangle = vtk.vtkTriangle()
-        triangle.GetPointIds().SetId(0, faces[i, 0])
-        triangle.GetPointIds().SetId(1, faces[i, 1])
-        triangle.GetPointIds().SetId(2, faces[i, 2])
-        triangles.InsertNextCell(triangle)
-
-    """vtk_points = vtk.vtkPoints()
-    for point in points:
-        vtk_points.InsertNextPoint(point)
-
-    # Create a vtkCellArray to store the triangles
-    triangles = vtk.vtkCellArray()
-
-    # Assuming points are organized as triplets forming triangles
-    for i in range(0, len(points), 3):
-        triangle = vtk.vtkTriangle()
-        triangle.GetPointIds().SetId(0, i)
-        triangle.GetPointIds().SetId(1, i + 1)
-        triangle.GetPointIds().SetId(2, i + 2)
-        triangles.InsertNextCell(triangle)"""
-
-    # Create a polydata object
-    polydata = vtk.vtkPolyData()
-    polydata.SetPoints(points)
-    polydata.SetPolys(triangles)
-
-    # Calculate normals
-    normalGenerator = vtk.vtkPolyDataNormals()
-    normalGenerator.SetInputData(polydata)
-    normalGenerator.ComputePointNormalsOn()
-    normalGenerator.ComputeCellNormalsOn()
-    normalGenerator.Update()
-
-    self.cell_normals = vtk_to_numpy(normalGenerator.GetOutput().GetCellData().GetNormals())
-
-    # merged_polydata = self.merge_coplanar_triangles(polydata)
-
-    # Create a mapper and actor
-    mapper = vtk.vtkPolyDataMapper()
-    mapper.SetInputData(polydata)
-
-    actor = vtk.vtkActor()
-    actor.SetMapper(mapper)
-    actor.GetProperty().SetColor(1, 1, 1)  # Set color (white in this case)
-    actor.GetProperty().EdgeVisibilityOn()  # Show edges
-    actor.GetProperty().SetLineWidth(2)  # Set line width
-
-    feature_edges = self.create_simplified_outline(polydata)
-
-    # Create a mapper for the feature edges
-    edge_mapper = vtk.vtkPolyDataMapper()
-    # Already wiht output
-    edge_mapper.SetInputConnection(feature_edges.GetOutputPort())
-
-    # Create an actor for the feature edges
-    edge_actor = vtk.vtkActor()
-    edge_actor.SetMapper(edge_mapper)
-
-    # Set the properties of the edge actor
-    edge_actor.GetProperty().SetColor(1, 0, 0)  # Set color (red in this case)
-    edge_actor.GetProperty().SetLineWidth(2)  # Set line width
-
-    # Optionally, if you want to keep the original mesh visible:
-    # (assuming you have the original mesh mapper and actor set up)
-    self.renderer.AddActor(actor)  # Add the original mesh actor
-    # Add the edge actor to the renderer
-    self.renderer.AddActor(edge_actor)
-
-    # Force an update of the pipeline
-    mapper.Update()
-    self.vtk_widget.GetRenderWindow().Render()
-
-    """# Print statistics
-    print(f"Original points: {len(points)}")
-    print(f"Number of triangles: {triangles.GetNumberOfCells()}")
-    print(f"Final number of points: {normals.GetOutput().GetNumberOfPoints()}")
-    print(f"Final number of cells: {normals.GetOutput().GetNumberOfCells()}")"""
-
-
-def render_from_points_direct(self, points):
-    ### Rendermethod for SDF mesh (output)
-    # Create a vtkPoints object and store the points in it
-    vtk_points = vtk.vtkPoints()
-    for point in points:
-        vtk_points.InsertNextPoint(point)
-
-    # Create a polydata object
-    point_polydata = vtk.vtkPolyData()
-    point_polydata.SetPoints(vtk_points)
-
-    # Surface reconstruction
-    surf = vtk.vtkSurfaceReconstructionFilter()
-    surf.SetInputData(point_polydata)
-    surf.Update()
-
-    # Create a contour filter to extract the surface
-    cf = vtk.vtkContourFilter()
-    cf.SetInputConnection(surf.GetOutputPort())
-    cf.SetValue(0, 0.0)
-    cf.Update()
-
-    # Reverse the normals
-    reverse = vtk.vtkReverseSense()
-    reverse.SetInputConnection(cf.GetOutputPort())
-    reverse.ReverseCellsOn()
-    reverse.ReverseNormalsOn()
-    reverse.Update()
-
-    # Get the reconstructed mesh
-    reconstructed_mesh = reverse.GetOutput()
-
-    """# Simplify the mesh
-    target_reduction = 1  # Adjust this value as needed
-    simplified_mesh = self.simplify_mesh(reconstructed_mesh, target_reduction)
-
-    combinded_faces = self.combine_coplanar_faces(simplified_mesh, 0.001)"""
-
-    # Create a mapper and actor for the simplified mesh
-    mapper = vtk.vtkPolyDataMapper()
-    mapper.SetInputData(reconstructed_mesh)
-
-    actor = vtk.vtkActor()
-    actor.SetMapper(mapper)
-    actor.GetProperty().SetColor(1, 1, 1)  # Set color (white in this case)
-    actor.GetProperty().EdgeVisibilityOn()  # Show edges
-    actor.GetProperty().SetLineWidth(2)  # Set line width
-
-    # Add the actor to the renderer
-    self.renderer.AddActor(actor)
-
-    # Force an update of the pipeline
-    # mapper.Update()
-    self.vtk_widget.GetRenderWindow().Render()
-
-    # Print statistics
-    print(f"Original points: {len(points)}")
-    print(
-        f"Reconstructed mesh: {reconstructed_mesh.GetNumberOfPoints()} points, {reconstructed_mesh.GetNumberOfCells()} cells")
-    """print(
-        f"Simplified mesh: {simplified_mesh.GetNumberOfPoints()} points, {simplified_mesh.GetNumberOfCells()} cells")"""

drawing_modules/vysta_widget.py

@@ -1,111 +0,0 @@
-import sys
-
-import numpy as np
-import pyvista as pv
-from pyvista.plotting.opts import ElementType
-from pyvistaqt import QtInteractor
-from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
-
-
-class PyVistaWidget(QWidget):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        # Create the PyVista plotter
-        self.plotter = QtInteractor(self)
-        self.plotter.background_color = "darkgray"
-
-        # Create a layout and add the PyVista widget
-        layout = QVBoxLayout()
-        layout.addWidget(self.plotter.interactor)
-        self.setLayout(layout)
-
-        # Set up the picker
-        #self.plotter.enable_cell_picking(callback=self.on_cell_pick, show=True)
-        self.plotter.enable_element_picking(callback=self.on_cell_pick, show=True, mode="face", left_clicking=True)
-
-    def on_cell_pick(self, element):
-        if element is not None:
-            mesh = self.plotter.mesh  # Get the current mesh
-            print(mesh)
-            print(element)
-
-            """# Get the face data
-            face = mesh.extract_cells(element)
-
-            # Compute face normal
-            face.compute_normals(cell_normals=True, inplace=True)
-            normal = face.cell_data['Normals'][0]
-
-            # Get the points of the face
-            points = face.points
-
-            print(f"Picked face ID: {face_id}")
-            print(f"Face normal: {normal}")
-            print("Face points:")
-            for point in points:
-                print(point)"""
-        else:
-            print("No face was picked or the picked element is not a face.")
-    def create_simplified_outline(self, mesh, camera):
-        # Project 3D to 2D
-        points_2d = self.plotter.map_to_2d(mesh.points)
-
-        # Detect silhouette edges (simplified approach)
-        edges = mesh.extract_feature_edges(feature_angle=90, boundary_edges=False, non_manifold_edges=False)
-
-        # Project edges to 2D
-        edge_points_2d = self.plotter.map_to_2d(edges.points)
-
-        # Create 2D outline
-        self.plotter.add_lines(edge_points_2d, color='black', width=2)
-        self.plotter.render()
-
-    def mesh_from_points(self, points):
-        # Convert points to numpy array if not already
-        points = np.array(points)
-
-        # Create faces array
-        num_triangles = len(points) // 3
-        faces = np.arange(len(points)).reshape(num_triangles, 3)
-        faces = np.column_stack((np.full(num_triangles, 3), faces))  # Add 3 as first column
-
-        # Create PyVista PolyData
-        mesh = pv.PolyData(points, faces)
-
-        # Optional: Merge duplicate points
-        mesh = mesh.clean()
-
-        # Optional: Compute normals
-        mesh = mesh.compute_normals(point_normals=False, cell_normals=True, consistent_normals=True)
-        edges = mesh.extract_feature_edges(30, non_manifold_edges=False)
-
-        # Clear any existing meshes
-        self.plotter.clear()
-
-        # Add the mesh to the plotter
-        self.plotter.add_mesh(mesh, pickable=True, color='white', show_edges=True, line_width=2, pbr=True, metallic=0.8, roughness=0.1, diffuse=1)
-        self.plotter.add_mesh(edges, color="red", line_width=10)
-
-        # Reset the camera to fit the new mesh
-        self.plotter.reset_camera()
-
-        # Update the render window
-        self.plotter.update()
-
-        # Print statistics
-        print(f"Original points: {len(points)}")
-        print(f"Number of triangles: {num_triangles}")
-        print(f"Final number of points: {mesh.n_points}")
-        print(f"Final number of cells: {mesh.n_cells}")
-
-
-class MainWindow(QMainWindow):
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("PyVista in PySide6")
-        self.setGeometry(100, 100, 800, 600)
-
-
-
-

gui_ui.py

@@ -0,0 +1,948 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'gui.ui'
+##
+## Created by: Qt User Interface Compiler version 6.10.2
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QAction, QBrush, QColor, QConicalGradient,
+    QCursor, QFont, QFontDatabase, QGradient,
+    QIcon, QImage, QKeySequence, QLinearGradient,
+    QPainter, QPalette, QPixmap, QRadialGradient,
+    QTransform)
+from PySide6.QtWidgets import (QApplication, QFrame, QGridLayout, QGroupBox,
+    QHBoxLayout, QLabel, QListWidget, QListWidgetItem,
+    QMainWindow, QMenu, QMenuBar, QPushButton,
+    QSizePolicy, QSpinBox, QStatusBar, QTabWidget,
+    QTextEdit, QVBoxLayout, QWidget)
+
+class Ui_fluencyCAD(object):
+    def setupUi(self, fluencyCAD):
+        if not fluencyCAD.objectName():
+            fluencyCAD.setObjectName(u"fluencyCAD")
+        fluencyCAD.resize(2551, 1265)
+        sizePolicy = QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(fluencyCAD.sizePolicy().hasHeightForWidth())
+        fluencyCAD.setSizePolicy(sizePolicy)
+        self.actionNew_Project = QAction(fluencyCAD)
+        self.actionNew_Project.setObjectName(u"actionNew_Project")
+        self.actionOpen_Project = QAction(fluencyCAD)
+        self.actionOpen_Project.setObjectName(u"actionOpen_Project")
+        self.actionSave_Project = QAction(fluencyCAD)
+        self.actionSave_Project.setObjectName(u"actionSave_Project")
+        self.actionSave_Project_As = QAction(fluencyCAD)
+        self.actionSave_Project_As.setObjectName(u"actionSave_Project_As")
+        self.actionImport_File = QAction(fluencyCAD)
+        self.actionImport_File.setObjectName(u"actionImport_File")
+        self.actionExport_Step = QAction(fluencyCAD)
+        self.actionExport_Step.setObjectName(u"actionExport_Step")
+        self.actionExport_Iges = QAction(fluencyCAD)
+        self.actionExport_Iges.setObjectName(u"actionExport_Iges")
+        self.actionExport_Stl = QAction(fluencyCAD)
+        self.actionExport_Stl.setObjectName(u"actionExport_Stl")
+        self.actionExit = QAction(fluencyCAD)
+        self.actionExit.setObjectName(u"actionExit")
+        self.centralwidget = QWidget(fluencyCAD)
+        self.centralwidget.setObjectName(u"centralwidget")
+        self.gridLayout = QGridLayout(self.centralwidget)
+        self.gridLayout.setObjectName(u"gridLayout")
+        self.groupBox_5 = QGroupBox(self.centralwidget)
+        self.groupBox_5.setObjectName(u"groupBox_5")
+        sizePolicy.setHeightForWidth(self.groupBox_5.sizePolicy().hasHeightForWidth())
+        self.groupBox_5.setSizePolicy(sizePolicy)
+        self.gridLayout_11 = QGridLayout(self.groupBox_5)
+        self.gridLayout_11.setObjectName(u"gridLayout_11")
+        self.gridLayout_11.setContentsMargins(12, 12, 12, 12)
+        self.label = QLabel(self.groupBox_5)
+        self.label.setObjectName(u"label")
+
+        self.gridLayout_11.addWidget(self.label, 5, 0, 1, 1)
+
+        self.pb_snap_vert = QPushButton(self.groupBox_5)
+        self.pb_snap_vert.setObjectName(u"pb_snap_vert")
+        self.pb_snap_vert.setCheckable(True)
+        self.pb_snap_vert.setAutoExclusive(False)
+
+        self.gridLayout_11.addWidget(self.pb_snap_vert, 2, 1, 1, 1)
+
+        self.line_2 = QFrame(self.groupBox_5)
+        self.line_2.setObjectName(u"line_2")
+        self.line_2.setFrameShape(QFrame.Shape.HLine)
+        self.line_2.setFrameShadow(QFrame.Shadow.Sunken)
+
+        self.gridLayout_11.addWidget(self.line_2, 4, 0, 1, 2)
+
+        self.label_2 = QLabel(self.groupBox_5)
+        self.label_2.setObjectName(u"label_2")
+
+        self.gridLayout_11.addWidget(self.label_2, 5, 1, 1, 1)
+
+        self.spinbox_snap_distance = QSpinBox(self.groupBox_5)
+        self.spinbox_snap_distance.setObjectName(u"spinbox_snap_distance")
+        self.spinbox_snap_distance.setMaximum(30)
+        self.spinbox_snap_distance.setValue(10)
+
+        self.gridLayout_11.addWidget(self.spinbox_snap_distance, 6, 0, 1, 1)
+
+        self.pushButton_7 = QPushButton(self.groupBox_5)
+        self.pushButton_7.setObjectName(u"pushButton_7")
+        self.pushButton_7.setCheckable(True)
+        self.pushButton_7.setAutoExclusive(False)
+
+        self.gridLayout_11.addWidget(self.pushButton_7, 3, 0, 1, 1)
+
+        self.pb_snap_horiz = QPushButton(self.groupBox_5)
+        self.pb_snap_horiz.setObjectName(u"pb_snap_horiz")
+        self.pb_snap_horiz.setCheckable(True)
+        self.pb_snap_horiz.setAutoExclusive(False)
+
+        self.gridLayout_11.addWidget(self.pb_snap_horiz, 2, 0, 1, 1)
+
+        self.spinbox_angle_steps = QSpinBox(self.groupBox_5)
+        self.spinbox_angle_steps.setObjectName(u"spinbox_angle_steps")
+        self.spinbox_angle_steps.setMaximum(180)
+        self.spinbox_angle_steps.setValue(15)
+
+        self.gridLayout_11.addWidget(self.spinbox_angle_steps, 6, 1, 1, 1)
+
+        self.pushButton_8 = QPushButton(self.groupBox_5)
+        self.pushButton_8.setObjectName(u"pushButton_8")
+        self.pushButton_8.setCheckable(True)
+        self.pushButton_8.setAutoExclusive(False)
+
+        self.gridLayout_11.addWidget(self.pushButton_8, 0, 0, 1, 1)
+
+        self.pb_snap_midp = QPushButton(self.groupBox_5)
+        self.pb_snap_midp.setObjectName(u"pb_snap_midp")
+        self.pb_snap_midp.setCheckable(True)
+        self.pb_snap_midp.setAutoExclusive(False)
+
+        self.gridLayout_11.addWidget(self.pb_snap_midp, 0, 1, 1, 1)
+
+        self.pb_snap_angle = QPushButton(self.groupBox_5)
+        self.pb_snap_angle.setObjectName(u"pb_snap_angle")
+        self.pb_snap_angle.setCheckable(True)
+        self.pb_snap_angle.setAutoExclusive(False)
+
+        self.gridLayout_11.addWidget(self.pb_snap_angle, 3, 1, 1, 1)
+
+
+        self.gridLayout.addWidget(self.groupBox_5, 3, 0, 1, 1)
+
+        self.groupBox_4 = QGroupBox(self.centralwidget)
+        self.groupBox_4.setObjectName(u"groupBox_4")
+        self.groupBox_4.setMaximumSize(QSize(200, 16777215))
+        self.gridLayout_9 = QGridLayout(self.groupBox_4)
+        self.gridLayout_9.setObjectName(u"gridLayout_9")
+        self.pushButton_2 = QPushButton(self.groupBox_4)
+        self.pushButton_2.setObjectName(u"pushButton_2")
+
+        self.gridLayout_9.addWidget(self.pushButton_2, 0, 0, 1, 1)
+
+        self.pb_export_iges = QPushButton(self.groupBox_4)
+        self.pb_export_iges.setObjectName(u"pb_export_iges")
+
+        self.gridLayout_9.addWidget(self.pb_export_iges, 2, 0, 1, 1)
+
+        self.pb_export_step = QPushButton(self.groupBox_4)
+        self.pb_export_step.setObjectName(u"pb_export_step")
+
+        self.gridLayout_9.addWidget(self.pb_export_step, 0, 1, 1, 1)
+
+
+        self.gridLayout.addWidget(self.groupBox_4, 1, 3, 1, 1)
+
+        self.InputTab = QTabWidget(self.centralwidget)
+        self.InputTab.setObjectName(u"InputTab")
+        sizePolicy.setHeightForWidth(self.InputTab.sizePolicy().hasHeightForWidth())
+        self.InputTab.setSizePolicy(sizePolicy)
+        self.sketch_tab = QWidget()
+        self.sketch_tab.setObjectName(u"sketch_tab")
+        self.verticalLayout_4 = QVBoxLayout(self.sketch_tab)
+        self.verticalLayout_4.setObjectName(u"verticalLayout_4")
+        self.InputTab.addTab(self.sketch_tab, "")
+        self.code_tab = QWidget()
+        self.code_tab.setObjectName(u"code_tab")
+        self.verticalLayout = QVBoxLayout(self.code_tab)
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.textEdit = QTextEdit(self.code_tab)
+        self.textEdit.setObjectName(u"textEdit")
+
+        self.verticalLayout.addWidget(self.textEdit)
+
+        self.groupBox_7 = QGroupBox(self.code_tab)
+        self.groupBox_7.setObjectName(u"groupBox_7")
+        self.gridLayout_5 = QGridLayout(self.groupBox_7)
+        self.gridLayout_5.setObjectName(u"gridLayout_5")
+        self.pushButton_5 = QPushButton(self.groupBox_7)
+        self.pushButton_5.setObjectName(u"pushButton_5")
+
+        self.gridLayout_5.addWidget(self.pushButton_5, 2, 0, 1, 1)
+
+        self.pushButton_4 = QPushButton(self.groupBox_7)
+        self.pushButton_4.setObjectName(u"pushButton_4")
+
+        self.gridLayout_5.addWidget(self.pushButton_4, 2, 1, 1, 1)
+
+        self.pb_apply_code = QPushButton(self.groupBox_7)
+        self.pb_apply_code.setObjectName(u"pb_apply_code")
+
+        self.gridLayout_5.addWidget(self.pb_apply_code, 1, 0, 1, 1)
+
+        self.pushButton = QPushButton(self.groupBox_7)
+        self.pushButton.setObjectName(u"pushButton")
+
+        self.gridLayout_5.addWidget(self.pushButton, 1, 1, 1, 1)
+
+
+        self.verticalLayout.addWidget(self.groupBox_7)
+
+        self.InputTab.addTab(self.code_tab, "")
+
+        self.gridLayout.addWidget(self.InputTab, 0, 1, 5, 1)
+
+        self.compo_tool_box = QGroupBox(self.centralwidget)
+        self.compo_tool_box.setObjectName(u"compo_tool_box")
+        sizePolicy1 = QSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Preferred)
+        sizePolicy1.setHorizontalStretch(0)
+        sizePolicy1.setVerticalStretch(0)
+        sizePolicy1.setHeightForWidth(self.compo_tool_box.sizePolicy().hasHeightForWidth())
+        self.compo_tool_box.setSizePolicy(sizePolicy1)
+        self.compo_tool_box.setMinimumSize(QSize(0, 50))
+        self.horizontalLayout = QHBoxLayout(self.compo_tool_box)
+        self.horizontalLayout.setObjectName(u"horizontalLayout")
+        self.pb_new_compo = QPushButton(self.compo_tool_box)
+        self.pb_new_compo.setObjectName(u"pb_new_compo")
+        self.pb_new_compo.setMinimumSize(QSize(50, 50))
+        self.pb_new_compo.setMaximumSize(QSize(50, 50))
+
+        self.horizontalLayout.addWidget(self.pb_new_compo)
+
+        self.pb_del_compo = QPushButton(self.compo_tool_box)
+        self.pb_del_compo.setObjectName(u"pb_del_compo")
+        self.pb_del_compo.setEnabled(True)
+        sizePolicy.setHeightForWidth(self.pb_del_compo.sizePolicy().hasHeightForWidth())
+        self.pb_del_compo.setSizePolicy(sizePolicy)
+        self.pb_del_compo.setMinimumSize(QSize(50, 50))
+        self.pb_del_compo.setMaximumSize(QSize(50, 50))
+        self.pb_del_compo.setLayoutDirection(Qt.LeftToRight)
+
+        self.horizontalLayout.addWidget(self.pb_del_compo)
+
+
+        self.gridLayout.addWidget(self.compo_tool_box, 7, 0, 1, 1)
+
+        self.groupBox_3 = QGroupBox(self.centralwidget)
+        self.groupBox_3.setObjectName(u"groupBox_3")
+        sizePolicy.setHeightForWidth(self.groupBox_3.sizePolicy().hasHeightForWidth())
+        self.groupBox_3.setSizePolicy(sizePolicy)
+        self.groupBox_3.setMaximumSize(QSize(200, 16777213))
+        self.gridLayout_4 = QGridLayout(self.groupBox_3)
+        self.gridLayout_4.setObjectName(u"gridLayout_4")
+        self.pb_con_ptpt = QPushButton(self.groupBox_3)
+        self.pb_con_ptpt.setObjectName(u"pb_con_ptpt")
+        icon = QIcon()
+        icon.addFile(u"icons/pt_pt.png", QSize(), QIcon.Mode.Normal, QIcon.State.Off)
+        self.pb_con_ptpt.setIcon(icon)
+        self.pb_con_ptpt.setCheckable(True)
+        self.pb_con_ptpt.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_ptpt, 1, 0, 1, 1)
+
+        self.pb_con_vert = QPushButton(self.groupBox_3)
+        self.pb_con_vert.setObjectName(u"pb_con_vert")
+        self.pb_con_vert.setCheckable(True)
+        self.pb_con_vert.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_vert, 3, 1, 1, 1)
+
+        self.pb_con_sym = QPushButton(self.groupBox_3)
+        self.pb_con_sym.setObjectName(u"pb_con_sym")
+        self.pb_con_sym.setCheckable(True)
+        self.pb_con_sym.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_sym, 4, 1, 1, 1)
+
+        self.pb_con_mid = QPushButton(self.groupBox_3)
+        self.pb_con_mid.setObjectName(u"pb_con_mid")
+        self.pb_con_mid.setCheckable(True)
+        self.pb_con_mid.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_mid, 2, 0, 1, 1)
+
+        self.pb_con_line = QPushButton(self.groupBox_3)
+        self.pb_con_line.setObjectName(u"pb_con_line")
+        self.pb_con_line.setCheckable(True)
+        self.pb_con_line.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_line, 1, 1, 1, 1)
+
+        self.pb_con_horiz = QPushButton(self.groupBox_3)
+        self.pb_con_horiz.setObjectName(u"pb_con_horiz")
+        self.pb_con_horiz.setCheckable(True)
+        self.pb_con_horiz.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_horiz, 3, 0, 1, 1)
+
+        self.pb_con_dist = QPushButton(self.groupBox_3)
+        self.pb_con_dist.setObjectName(u"pb_con_dist")
+        self.pb_con_dist.setCheckable(True)
+        self.pb_con_dist.setAutoExclusive(False)
+        self.pb_con_dist.setAutoRepeatDelay(297)
+
+        self.gridLayout_4.addWidget(self.pb_con_dist, 4, 0, 1, 1)
+
+        self.pb_con_perp = QPushButton(self.groupBox_3)
+        self.pb_con_perp.setObjectName(u"pb_con_perp")
+        self.pb_con_perp.setCheckable(True)
+        self.pb_con_perp.setAutoExclusive(False)
+
+        self.gridLayout_4.addWidget(self.pb_con_perp, 2, 1, 1, 1)
+
+        self.pb_con_diameter = QPushButton(self.groupBox_3)
+        self.pb_con_diameter.setObjectName(u"pb_con_diameter")
+
+        self.gridLayout_4.addWidget(self.pb_con_diameter, 5, 0, 1, 1)
+
+
+        self.gridLayout.addWidget(self.groupBox_3, 2, 0, 1, 1)
+
+        self.assembly_tools = QGroupBox(self.centralwidget)
+        self.assembly_tools.setObjectName(u"assembly_tools")
+        sizePolicy1.setHeightForWidth(self.assembly_tools.sizePolicy().hasHeightForWidth())
+        self.assembly_tools.setSizePolicy(sizePolicy1)
+        self.assembly_tools.setMinimumSize(QSize(113, 50))
+        self.horizontalLayout_2 = QHBoxLayout(self.assembly_tools)
+        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
+        self.pb_compo_to_assembly = QPushButton(self.assembly_tools)
+        self.pb_compo_to_assembly.setObjectName(u"pb_compo_to_assembly")
+        self.pb_compo_to_assembly.setMinimumSize(QSize(50, 50))
+        self.pb_compo_to_assembly.setMaximumSize(QSize(50, 50))
+
+        self.horizontalLayout_2.addWidget(self.pb_compo_to_assembly)
+
+        self.pb_remove_compo_from_assembly = QPushButton(self.assembly_tools)
+        self.pb_remove_compo_from_assembly.setObjectName(u"pb_remove_compo_from_assembly")
+        self.pb_remove_compo_from_assembly.setEnabled(True)
+        sizePolicy.setHeightForWidth(self.pb_remove_compo_from_assembly.sizePolicy().hasHeightForWidth())
+        self.pb_remove_compo_from_assembly.setSizePolicy(sizePolicy)
+        self.pb_remove_compo_from_assembly.setMinimumSize(QSize(50, 50))
+        self.pb_remove_compo_from_assembly.setMaximumSize(QSize(50, 50))
+        self.pb_remove_compo_from_assembly.setLayoutDirection(Qt.LeftToRight)
+
+        self.horizontalLayout_2.addWidget(self.pb_remove_compo_from_assembly)
+
+
+        self.gridLayout.addWidget(self.assembly_tools, 8, 0, 1, 1)
+
+        self.groupBox_9 = QGroupBox(self.centralwidget)
+        self.groupBox_9.setObjectName(u"groupBox_9")
+        self.groupBox_9.setMaximumSize(QSize(200, 16777215))
+        self.gridLayout_7 = QGridLayout(self.groupBox_9)
+        self.gridLayout_7.setObjectName(u"gridLayout_7")
+        self.pb_origin_wp = QPushButton(self.groupBox_9)
+        self.pb_origin_wp.setObjectName(u"pb_origin_wp")
+
+        self.gridLayout_7.addWidget(self.pb_origin_wp, 0, 0, 1, 1)
+
+        self.pb_origin_face = QPushButton(self.groupBox_9)
+        self.pb_origin_face.setObjectName(u"pb_origin_face")
+        self.pb_origin_face.setCheckable(True)
+
+        self.gridLayout_7.addWidget(self.pb_origin_face, 0, 1, 1, 1)
+
+        self.pb_flip_face = QPushButton(self.groupBox_9)
+        self.pb_flip_face.setObjectName(u"pb_flip_face")
+
+        self.gridLayout_7.addWidget(self.pb_flip_face, 1, 0, 1, 1)
+
+        self.pb_underlay = QPushButton(self.groupBox_9)
+        self.pb_underlay.setObjectName(u"pb_underlay")
+        self.pb_underlay.setEnabled(False)
+        self.pb_underlay.setCheckable(True)
+        self.pb_underlay.setChecked(True)
+
+        self.gridLayout_7.addWidget(self.pb_underlay, 3, 0, 1, 1)
+
+        self.pb_clr_face = QPushButton(self.groupBox_9)
+        self.pb_clr_face.setObjectName(u"pb_clr_face")
+        self.pb_clr_face.setEnabled(False)
+
+        self.gridLayout_7.addWidget(self.pb_clr_face, 3, 1, 1, 1)
+
+        self.pb_to_sketch = QPushButton(self.groupBox_9)
+        self.pb_to_sketch.setObjectName(u"pb_to_sketch")
+        self.pb_to_sketch.setEnabled(False)
+
+        self.gridLayout_7.addWidget(self.pb_to_sketch, 4, 0, 1, 2)
+
+        self.pb_wp_new = QPushButton(self.groupBox_9)
+        self.pb_wp_new.setObjectName(u"pb_wp_new")
+
+        self.gridLayout_7.addWidget(self.pb_wp_new, 1, 1, 1, 1)
+
+
+        self.gridLayout.addWidget(self.groupBox_9, 0, 0, 1, 1)
+
+        self.groupBox_12 = QGroupBox(self.centralwidget)
+        self.groupBox_12.setObjectName(u"groupBox_12")
+        sizePolicy2 = QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Expanding)
+        sizePolicy2.setHorizontalStretch(0)
+        sizePolicy2.setVerticalStretch(0)
+        sizePolicy2.setHeightForWidth(self.groupBox_12.sizePolicy().hasHeightForWidth())
+        self.groupBox_12.setSizePolicy(sizePolicy2)
+        self.groupBox_12.setMaximumSize(QSize(200, 16777215))
+        self.verticalLayout_8 = QVBoxLayout(self.groupBox_12)
+        self.verticalLayout_8.setObjectName(u"verticalLayout_8")
+        self.verticalLayout_8.setContentsMargins(5, 5, 5, 5)
+        self.connection_list = QListWidget(self.groupBox_12)
+        self.connection_list.setObjectName(u"connection_list")
+        self.connection_list.setSelectionRectVisible(True)
+
+        self.verticalLayout_8.addWidget(self.connection_list)
+
+        self.groupBox_13 = QGroupBox(self.groupBox_12)
+        self.groupBox_13.setObjectName(u"groupBox_13")
+        sizePolicy.setHeightForWidth(self.groupBox_13.sizePolicy().hasHeightForWidth())
+        self.groupBox_13.setSizePolicy(sizePolicy)
+        self.groupBox_13.setMaximumSize(QSize(200, 16777215))
+        self.gridLayout_13 = QGridLayout(self.groupBox_13)
+        self.gridLayout_13.setObjectName(u"gridLayout_13")
+        self.gridLayout_13.setContentsMargins(2, 2, 2, 2)
+        self.pb_del_connection = QPushButton(self.groupBox_13)
+        self.pb_del_connection.setObjectName(u"pb_del_connection")
+
+        self.gridLayout_13.addWidget(self.pb_del_connection, 0, 2, 1, 1)
+
+        self.pb_update_connection = QPushButton(self.groupBox_13)
+        self.pb_update_connection.setObjectName(u"pb_update_connection")
+
+        self.gridLayout_13.addWidget(self.pb_update_connection, 0, 0, 1, 1)
+
+        self.pb_edt_sktch_4 = QPushButton(self.groupBox_13)
+        self.pb_edt_sktch_4.setObjectName(u"pb_edt_sktch_4")
+
+        self.gridLayout_13.addWidget(self.pb_edt_sktch_4, 0, 1, 1, 1)
+
+
+        self.verticalLayout_8.addWidget(self.groupBox_13)
+
+
+        self.gridLayout.addWidget(self.groupBox_12, 4, 3, 1, 1)
+
+        self.joint_tools = QGroupBox(self.centralwidget)
+        self.joint_tools.setObjectName(u"joint_tools")
+        self.joint_tools.setMinimumSize(QSize(0, 50))
+        self.gridLayout_10 = QGridLayout(self.joint_tools)
+        self.gridLayout_10.setObjectName(u"gridLayout_10")
+        self.pb_add_connector = QPushButton(self.joint_tools)
+        self.pb_add_connector.setObjectName(u"pb_add_connector")
+        self.pb_add_connector.setMinimumSize(QSize(50, 50))
+        self.pb_add_connector.setMaximumSize(QSize(50, 50))
+
+        self.gridLayout_10.addWidget(self.pb_add_connector, 0, 0, 1, 1)
+
+        self.pb_remove_connector = QPushButton(self.joint_tools)
+        self.pb_remove_connector.setObjectName(u"pb_remove_connector")
+        self.pb_remove_connector.setMinimumSize(QSize(50, 50))
+        self.pb_remove_connector.setMaximumSize(QSize(50, 50))
+
+        self.gridLayout_10.addWidget(self.pb_remove_connector, 0, 1, 1, 1)
+
+        self.pb_add_connector_3 = QPushButton(self.joint_tools)
+        self.pb_add_connector_3.setObjectName(u"pb_add_connector_3")
+        self.pb_add_connector_3.setMinimumSize(QSize(50, 50))
+        self.pb_add_connector_3.setMaximumSize(QSize(50, 50))
+
+        self.gridLayout_10.addWidget(self.pb_add_connector_3, 1, 1, 1, 1)
+
+        self.pb_add_connector_2 = QPushButton(self.joint_tools)
+        self.pb_add_connector_2.setObjectName(u"pb_add_connector_2")
+        self.pb_add_connector_2.setMinimumSize(QSize(50, 50))
+        self.pb_add_connector_2.setMaximumSize(QSize(50, 50))
+
+        self.gridLayout_10.addWidget(self.pb_add_connector_2, 1, 0, 1, 1)
+
+
+        self.gridLayout.addWidget(self.joint_tools, 7, 3, 2, 1)
+
+        self.gl_box = QGroupBox(self.centralwidget)
+        self.gl_box.setObjectName(u"gl_box")
+        sizePolicy3 = QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred)
+        sizePolicy3.setHorizontalStretch(0)
+        sizePolicy3.setVerticalStretch(4)
+        sizePolicy3.setHeightForWidth(self.gl_box.sizePolicy().hasHeightForWidth())
+        self.gl_box.setSizePolicy(sizePolicy3)
+        font = QFont()
+        font.setPointSize(12)
+        self.gl_box.setFont(font)
+        self.horizontalLayout_4 = QHBoxLayout(self.gl_box)
+#ifndef Q_OS_MAC
+        self.horizontalLayout_4.setSpacing(-1)
+#endif
+        self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
+        self.horizontalLayout_4.setContentsMargins(12, -1, -1, -1)
+
+        self.gridLayout.addWidget(self.gl_box, 0, 2, 5, 1)
+
+        self.compo_box = QGroupBox(self.centralwidget)
+        self.compo_box.setObjectName(u"compo_box")
+        self.compo_box.setMinimumSize(QSize(0, 120))
+
+        self.gridLayout.addWidget(self.compo_box, 7, 1, 1, 2)
+
+        self.groupBox_11 = QGroupBox(self.centralwidget)
+        self.groupBox_11.setObjectName(u"groupBox_11")
+        sizePolicy2.setHeightForWidth(self.groupBox_11.sizePolicy().hasHeightForWidth())
+        self.groupBox_11.setSizePolicy(sizePolicy2)
+        self.groupBox_11.setMaximumSize(QSize(200, 16777215))
+        self.verticalLayout_7 = QVBoxLayout(self.groupBox_11)
+        self.verticalLayout_7.setObjectName(u"verticalLayout_7")
+        self.verticalLayout_7.setContentsMargins(5, 5, 5, 5)
+        self.sketch_list = QListWidget(self.groupBox_11)
+        self.sketch_list.setObjectName(u"sketch_list")
+        sizePolicy4 = QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        sizePolicy4.setHorizontalStretch(0)
+        sizePolicy4.setVerticalStretch(0)
+        sizePolicy4.setHeightForWidth(self.sketch_list.sizePolicy().hasHeightForWidth())
+        self.sketch_list.setSizePolicy(sizePolicy4)
+        self.sketch_list.setSelectionRectVisible(True)
+
+        self.verticalLayout_7.addWidget(self.sketch_list)
+
+        self.groupBox_6 = QGroupBox(self.groupBox_11)
+        self.groupBox_6.setObjectName(u"groupBox_6")
+        sizePolicy.setHeightForWidth(self.groupBox_6.sizePolicy().hasHeightForWidth())
+        self.groupBox_6.setSizePolicy(sizePolicy)
+        self.gridLayout_6 = QGridLayout(self.groupBox_6)
+        self.gridLayout_6.setObjectName(u"gridLayout_6")
+        self.gridLayout_6.setContentsMargins(2, 2, 2, 2)
+        self.pb_edt_sktch = QPushButton(self.groupBox_6)
+        self.pb_edt_sktch.setObjectName(u"pb_edt_sktch")
+
+        self.gridLayout_6.addWidget(self.pb_edt_sktch, 1, 1, 1, 1)
+
+        self.pb_nw_sktch = QPushButton(self.groupBox_6)
+        self.pb_nw_sktch.setObjectName(u"pb_nw_sktch")
+
+        self.gridLayout_6.addWidget(self.pb_nw_sktch, 1, 0, 1, 1)
+
+        self.pb_del_sketch = QPushButton(self.groupBox_6)
+        self.pb_del_sketch.setObjectName(u"pb_del_sketch")
+
+        self.gridLayout_6.addWidget(self.pb_del_sketch, 1, 2, 1, 1)
+
+
+        self.verticalLayout_7.addWidget(self.groupBox_6)
+
+
+        self.gridLayout.addWidget(self.groupBox_11, 4, 0, 1, 1)
+
+        self.groupBox_2 = QGroupBox(self.centralwidget)
+        self.groupBox_2.setObjectName(u"groupBox_2")
+        sizePolicy.setHeightForWidth(self.groupBox_2.sizePolicy().hasHeightForWidth())
+        self.groupBox_2.setSizePolicy(sizePolicy)
+        self.groupBox_2.setMaximumSize(QSize(200, 16777215))
+        self.gridLayout_2 = QGridLayout(self.groupBox_2)
+        self.gridLayout_2.setObjectName(u"gridLayout_2")
+        self.gridLayout_2.setContentsMargins(10, -1, -1, -1)
+        self.pb_arc_tool = QPushButton(self.groupBox_2)
+        self.pb_arc_tool.setObjectName(u"pb_arc_tool")
+        self.pb_arc_tool.setCheckable(True)
+
+        self.gridLayout_2.addWidget(self.pb_arc_tool, 2, 0, 1, 1)
+
+        self.pb_rectool = QPushButton(self.groupBox_2)
+        self.pb_rectool.setObjectName(u"pb_rectool")
+        self.pb_rectool.setCheckable(True)
+        self.pb_rectool.setAutoExclusive(False)
+
+        self.gridLayout_2.addWidget(self.pb_rectool, 0, 1, 1, 1)
+
+        self.pb_circtool = QPushButton(self.groupBox_2)
+        self.pb_circtool.setObjectName(u"pb_circtool")
+        self.pb_circtool.setCheckable(True)
+        self.pb_circtool.setAutoExclusive(False)
+
+        self.gridLayout_2.addWidget(self.pb_circtool, 1, 0, 1, 1)
+
+        self.pb_enable_construct = QPushButton(self.groupBox_2)
+        self.pb_enable_construct.setObjectName(u"pb_enable_construct")
+        self.pb_enable_construct.setCheckable(True)
+
+        self.gridLayout_2.addWidget(self.pb_enable_construct, 4, 0, 1, 1)
+
+        self.pb_enable_snap = QPushButton(self.groupBox_2)
+        self.pb_enable_snap.setObjectName(u"pb_enable_snap")
+        self.pb_enable_snap.setIconSize(QSize(13, 16))
+        self.pb_enable_snap.setCheckable(True)
+        self.pb_enable_snap.setChecked(True)
+
+        self.gridLayout_2.addWidget(self.pb_enable_snap, 4, 1, 1, 1)
+
+        self.pb_linetool = QPushButton(self.groupBox_2)
+        self.pb_linetool.setObjectName(u"pb_linetool")
+        self.pb_linetool.setCheckable(True)
+        self.pb_linetool.setAutoExclusive(False)
+
+        self.gridLayout_2.addWidget(self.pb_linetool, 0, 0, 1, 1)
+
+        self.pb_slotool = QPushButton(self.groupBox_2)
+        self.pb_slotool.setObjectName(u"pb_slotool")
+        self.pb_slotool.setCheckable(True)
+        self.pb_slotool.setAutoExclusive(False)
+
+        self.gridLayout_2.addWidget(self.pb_slotool, 1, 1, 1, 1)
+
+        self.line = QFrame(self.groupBox_2)
+        self.line.setObjectName(u"line")
+        self.line.setFrameShape(QFrame.Shape.HLine)
+        self.line.setFrameShadow(QFrame.Shadow.Sunken)
+
+        self.gridLayout_2.addWidget(self.line, 3, 0, 1, 2)
+
+        self.pb_offset_tool = QPushButton(self.groupBox_2)
+        self.pb_offset_tool.setObjectName(u"pb_offset_tool")
+
+        self.gridLayout_2.addWidget(self.pb_offset_tool, 2, 1, 1, 1)
+
+
+        self.gridLayout.addWidget(self.groupBox_2, 1, 0, 1, 1)
+
+        self.assembly_box = QGroupBox(self.centralwidget)
+        self.assembly_box.setObjectName(u"assembly_box")
+        self.assembly_box.setMinimumSize(QSize(0, 120))
+
+        self.gridLayout.addWidget(self.assembly_box, 8, 1, 1, 2)
+
+        self.groupBox = QGroupBox(self.centralwidget)
+        self.groupBox.setObjectName(u"groupBox")
+        self.groupBox.setMaximumSize(QSize(200, 16777215))
+        self.gridLayout_3 = QGridLayout(self.groupBox)
+        self.gridLayout_3.setObjectName(u"gridLayout_3")
+        self.pb_chamfer_op = QPushButton(self.groupBox)
+        self.pb_chamfer_op.setObjectName(u"pb_chamfer_op")
+
+        self.gridLayout_3.addWidget(self.pb_chamfer_op, 2, 1, 1, 1)
+
+        self.pb_fillet_op = QPushButton(self.groupBox)
+        self.pb_fillet_op.setObjectName(u"pb_fillet_op")
+
+        self.gridLayout_3.addWidget(self.pb_fillet_op, 2, 0, 1, 1)
+
+        self.pb_thread = QPushButton(self.groupBox)
+        self.pb_thread.setObjectName(u"pb_thread")
+
+        self.gridLayout_3.addWidget(self.pb_thread, 6, 0, 1, 1)
+
+        self.pb_extrdop = QPushButton(self.groupBox)
+        self.pb_extrdop.setObjectName(u"pb_extrdop")
+
+        self.gridLayout_3.addWidget(self.pb_extrdop, 0, 0, 1, 1)
+
+        self.pb_revop = QPushButton(self.groupBox)
+        self.pb_revop.setObjectName(u"pb_revop")
+
+        self.gridLayout_3.addWidget(self.pb_revop, 4, 1, 1, 1)
+
+        self.pb_cutop = QPushButton(self.groupBox)
+        self.pb_cutop.setObjectName(u"pb_cutop")
+
+        self.gridLayout_3.addWidget(self.pb_cutop, 0, 1, 1, 1)
+
+        self.pb_arrayop = QPushButton(self.groupBox)
+        self.pb_arrayop.setObjectName(u"pb_arrayop")
+
+        self.gridLayout_3.addWidget(self.pb_arrayop, 4, 0, 1, 1)
+
+        self.pb_combop = QPushButton(self.groupBox)
+        self.pb_combop.setObjectName(u"pb_combop")
+
+        self.gridLayout_3.addWidget(self.pb_combop, 1, 0, 1, 1)
+
+        self.pb_moveop = QPushButton(self.groupBox)
+        self.pb_moveop.setObjectName(u"pb_moveop")
+
+        self.gridLayout_3.addWidget(self.pb_moveop, 1, 1, 1, 1)
+
+        self.pb_mirror_op = QPushButton(self.groupBox)
+        self.pb_mirror_op.setObjectName(u"pb_mirror_op")
+
+        self.gridLayout_3.addWidget(self.pb_mirror_op, 6, 1, 1, 1)
+
+
+        self.gridLayout.addWidget(self.groupBox, 0, 3, 1, 1)
+
+        self.line_3 = QFrame(self.centralwidget)
+        self.line_3.setObjectName(u"line_3")
+        self.line_3.setFrameShape(QFrame.Shape.HLine)
+        self.line_3.setFrameShadow(QFrame.Shadow.Sunken)
+
+        self.gridLayout.addWidget(self.line_3, 5, 0, 1, 4)
+
+        self.groupBox_10 = QGroupBox(self.centralwidget)
+        self.groupBox_10.setObjectName(u"groupBox_10")
+        sizePolicy2.setHeightForWidth(self.groupBox_10.sizePolicy().hasHeightForWidth())
+        self.groupBox_10.setSizePolicy(sizePolicy2)
+        self.groupBox_10.setMaximumSize(QSize(200, 16777215))
+        self.verticalLayout_6 = QVBoxLayout(self.groupBox_10)
+        self.verticalLayout_6.setObjectName(u"verticalLayout_6")
+        self.verticalLayout_6.setContentsMargins(5, 5, 5, 5)
+        self.body_list = QListWidget(self.groupBox_10)
+        self.body_list.setObjectName(u"body_list")
+        self.body_list.setSelectionRectVisible(True)
+
+        self.verticalLayout_6.addWidget(self.body_list)
+
+        self.groupBox_8 = QGroupBox(self.groupBox_10)
+        self.groupBox_8.setObjectName(u"groupBox_8")
+        sizePolicy.setHeightForWidth(self.groupBox_8.sizePolicy().hasHeightForWidth())
+        self.groupBox_8.setSizePolicy(sizePolicy)
+        self.groupBox_8.setMaximumSize(QSize(200, 16777215))
+        self.gridLayout_8 = QGridLayout(self.groupBox_8)
+        self.gridLayout_8.setObjectName(u"gridLayout_8")
+        self.gridLayout_8.setContentsMargins(2, 2, 2, 2)
+        self.pb_body_hide = QPushButton(self.groupBox_8)
+        self.pb_body_hide.setObjectName(u"pb_body_hide")
+
+        self.gridLayout_8.addWidget(self.pb_body_hide, 0, 1, 1, 1)
+
+        self.pb_update_body = QPushButton(self.groupBox_8)
+        self.pb_update_body.setObjectName(u"pb_update_body")
+
+        self.gridLayout_8.addWidget(self.pb_update_body, 0, 0, 1, 1)
+
+        self.pb_del_body = QPushButton(self.groupBox_8)
+        self.pb_del_body.setObjectName(u"pb_del_body")
+
+        self.gridLayout_8.addWidget(self.pb_del_body, 0, 2, 1, 1)
+
+
+        self.verticalLayout_6.addWidget(self.groupBox_8)
+
+
+        self.gridLayout.addWidget(self.groupBox_10, 2, 3, 2, 1)
+
+        fluencyCAD.setCentralWidget(self.centralwidget)
+        self.menubar = QMenuBar(fluencyCAD)
+        self.menubar.setObjectName(u"menubar")
+        self.menubar.setGeometry(QRect(0, 0, 2551, 24))
+        self.menuFile = QMenu(self.menubar)
+        self.menuFile.setObjectName(u"menuFile")
+        self.menuSettings = QMenu(self.menubar)
+        self.menuSettings.setObjectName(u"menuSettings")
+        fluencyCAD.setMenuBar(self.menubar)
+        self.statusbar = QStatusBar(fluencyCAD)
+        self.statusbar.setObjectName(u"statusbar")
+        fluencyCAD.setStatusBar(self.statusbar)
+
+        self.menubar.addAction(self.menuFile.menuAction())
+        self.menubar.addAction(self.menuSettings.menuAction())
+        self.menuFile.addAction(self.actionNew_Project)
+        self.menuFile.addAction(self.actionOpen_Project)
+        self.menuFile.addAction(self.actionSave_Project)
+        self.menuFile.addAction(self.actionSave_Project_As)
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.actionImport_File)
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.actionExport_Step)
+        self.menuFile.addAction(self.actionExport_Iges)
+        self.menuFile.addAction(self.actionExport_Stl)
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.actionExit)
+
+        self.retranslateUi(fluencyCAD)
+
+        self.InputTab.setCurrentIndex(0)
+
+
+        QMetaObject.connectSlotsByName(fluencyCAD)
+    # setupUi
+
+    def retranslateUi(self, fluencyCAD):
+        fluencyCAD.setWindowTitle(QCoreApplication.translate("fluencyCAD", u"fluencyCAD", None))
+        self.actionNew_Project.setText(QCoreApplication.translate("fluencyCAD", u"New Project", None))
+#if QT_CONFIG(shortcut)
+        self.actionNew_Project.setShortcut(QCoreApplication.translate("fluencyCAD", u"Ctrl+N", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionOpen_Project.setText(QCoreApplication.translate("fluencyCAD", u"Open Project...", None))
+#if QT_CONFIG(shortcut)
+        self.actionOpen_Project.setShortcut(QCoreApplication.translate("fluencyCAD", u"Ctrl+O", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionSave_Project.setText(QCoreApplication.translate("fluencyCAD", u"Save Project", None))
+#if QT_CONFIG(shortcut)
+        self.actionSave_Project.setShortcut(QCoreApplication.translate("fluencyCAD", u"Ctrl+S", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionSave_Project_As.setText(QCoreApplication.translate("fluencyCAD", u"Save Project As...", None))
+#if QT_CONFIG(shortcut)
+        self.actionSave_Project_As.setShortcut(QCoreApplication.translate("fluencyCAD", u"Ctrl+Shift+S", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionImport_File.setText(QCoreApplication.translate("fluencyCAD", u"Import STEP/IGES...", None))
+        self.actionExport_Step.setText(QCoreApplication.translate("fluencyCAD", u"Export STEP...", None))
+        self.actionExport_Iges.setText(QCoreApplication.translate("fluencyCAD", u"Export IGES...", None))
+        self.actionExport_Stl.setText(QCoreApplication.translate("fluencyCAD", u"Export STL...", None))
+        self.actionExit.setText(QCoreApplication.translate("fluencyCAD", u"Exit", None))
+#if QT_CONFIG(shortcut)
+        self.actionExit.setShortcut(QCoreApplication.translate("fluencyCAD", u"Ctrl+Q", None))
+#endif // QT_CONFIG(shortcut)
+        self.groupBox_5.setTitle(QCoreApplication.translate("fluencyCAD", u"Snapping Points", None))
+        self.label.setText(QCoreApplication.translate("fluencyCAD", u"Snp Dst", None))
+        self.pb_snap_vert.setText(QCoreApplication.translate("fluencyCAD", u"Vert", None))
+        self.label_2.setText(QCoreApplication.translate("fluencyCAD", u"Angl Stps", None))
+        self.spinbox_snap_distance.setSuffix(QCoreApplication.translate("fluencyCAD", u"mm", None))
+        self.pushButton_7.setText(QCoreApplication.translate("fluencyCAD", u"Grid", None))
+        self.pb_snap_horiz.setText(QCoreApplication.translate("fluencyCAD", u"Horiz", None))
+        self.spinbox_angle_steps.setSuffix(QCoreApplication.translate("fluencyCAD", u"\u00b0", None))
+        self.pushButton_8.setText(QCoreApplication.translate("fluencyCAD", u"Pnt", None))
+        self.pb_snap_midp.setText(QCoreApplication.translate("fluencyCAD", u"MidP", None))
+        self.pb_snap_angle.setText(QCoreApplication.translate("fluencyCAD", u"Angles", None))
+        self.groupBox_4.setTitle(QCoreApplication.translate("fluencyCAD", u"Export", None))
+        self.pushButton_2.setText(QCoreApplication.translate("fluencyCAD", u"STL", None))
+        self.pb_export_iges.setText(QCoreApplication.translate("fluencyCAD", u"IGES", None))
+        self.pb_export_step.setText(QCoreApplication.translate("fluencyCAD", u"STEP", None))
+        self.InputTab.setTabText(self.InputTab.indexOf(self.sketch_tab), QCoreApplication.translate("fluencyCAD", u"Sketch", None))
+        self.groupBox_7.setTitle(QCoreApplication.translate("fluencyCAD", u"Executive", None))
+        self.pushButton_5.setText(QCoreApplication.translate("fluencyCAD", u"Load Code", None))
+        self.pushButton_4.setText(QCoreApplication.translate("fluencyCAD", u"Save code", None))
+        self.pb_apply_code.setText(QCoreApplication.translate("fluencyCAD", u"Apply Code", None))
+        self.pushButton.setText(QCoreApplication.translate("fluencyCAD", u"Delete Code", None))
+        self.InputTab.setTabText(self.InputTab.indexOf(self.code_tab), QCoreApplication.translate("fluencyCAD", u"Code", None))
+        self.compo_tool_box.setTitle(QCoreApplication.translate("fluencyCAD", u"Component Tools", None))
+        self.pb_new_compo.setText(QCoreApplication.translate("fluencyCAD", u"New", None))
+        self.pb_del_compo.setText(QCoreApplication.translate("fluencyCAD", u"Del", None))
+        self.groupBox_3.setTitle(QCoreApplication.translate("fluencyCAD", u"Constrain", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_ptpt.setToolTip(QCoreApplication.translate("fluencyCAD", u"Poin to Point Constrain", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_ptpt.setText(QCoreApplication.translate("fluencyCAD", u"Pt_Pt", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_vert.setToolTip(QCoreApplication.translate("fluencyCAD", u"Vertical Constrain", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_vert.setText(QCoreApplication.translate("fluencyCAD", u"Vert", None))
+        self.pb_con_sym.setText(QCoreApplication.translate("fluencyCAD", u"Symetrc", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_mid.setToolTip(QCoreApplication.translate("fluencyCAD", u"Point to Middle Point Constrain", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_mid.setText(QCoreApplication.translate("fluencyCAD", u"Pt_Mid_L", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_line.setToolTip(QCoreApplication.translate("fluencyCAD", u"Point to Line Constrain", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_line.setText(QCoreApplication.translate("fluencyCAD", u"Pt_Lne", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_horiz.setToolTip(QCoreApplication.translate("fluencyCAD", u"Horizontal Constrain ", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_horiz.setText(QCoreApplication.translate("fluencyCAD", u"Horiz", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_dist.setToolTip(QCoreApplication.translate("fluencyCAD", u"Dimension of Line of Distance from Point to Line", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_dist.setText(QCoreApplication.translate("fluencyCAD", u"Distnce", None))
+#if QT_CONFIG(tooltip)
+        self.pb_con_perp.setToolTip(QCoreApplication.translate("fluencyCAD", u"Constrain Line perpendicular to another line.", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_con_perp.setText(QCoreApplication.translate("fluencyCAD", u"Perp_Lne", None))
+        self.pb_con_diameter.setText(QCoreApplication.translate("fluencyCAD", u"Diameter", None))
+        self.assembly_tools.setTitle(QCoreApplication.translate("fluencyCAD", u"Assembly Tools", None))
+        self.pb_compo_to_assembly.setText(QCoreApplication.translate("fluencyCAD", u"Add", None))
+        self.pb_remove_compo_from_assembly.setText(QCoreApplication.translate("fluencyCAD", u"Rem", None))
+        self.groupBox_9.setTitle(QCoreApplication.translate("fluencyCAD", u"Workplanes", None))
+#if QT_CONFIG(tooltip)
+        self.pb_origin_wp.setToolTip(QCoreApplication.translate("fluencyCAD", u"<W>orking Plane at 0, 0, 0", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_origin_wp.setText(QCoreApplication.translate("fluencyCAD", u"WP Origin", None))
+#if QT_CONFIG(shortcut)
+        self.pb_origin_wp.setShortcut(QCoreApplication.translate("fluencyCAD", u"W", None))
+#endif // QT_CONFIG(shortcut)
+#if QT_CONFIG(tooltip)
+        self.pb_origin_face.setToolTip(QCoreApplication.translate("fluencyCAD", u"Working Plane >P<rojection at selected edges face", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_origin_face.setText(QCoreApplication.translate("fluencyCAD", u" WP Face", None))
+#if QT_CONFIG(shortcut)
+        self.pb_origin_face.setShortcut(QCoreApplication.translate("fluencyCAD", u"P", None))
+#endif // QT_CONFIG(shortcut)
+#if QT_CONFIG(tooltip)
+        self.pb_flip_face.setToolTip(QCoreApplication.translate("fluencyCAD", u"Flip >N<ormal of projected mesh.", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_flip_face.setText(QCoreApplication.translate("fluencyCAD", u"WP Flip", None))
+#if QT_CONFIG(shortcut)
+        self.pb_flip_face.setShortcut(QCoreApplication.translate("fluencyCAD", u"N", None))
+#endif // QT_CONFIG(shortcut)
+#if QT_CONFIG(tooltip)
+        self.pb_underlay.setToolTip(QCoreApplication.translate("fluencyCAD", u"Show / hide the construction lines projected from the source face", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_underlay.setText(QCoreApplication.translate("fluencyCAD", u"Underlay", None))
+#if QT_CONFIG(tooltip)
+        self.pb_clr_face.setToolTip(QCoreApplication.translate("fluencyCAD", u"Forget the picked source face (keep the workplane)", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_clr_face.setText(QCoreApplication.translate("fluencyCAD", u"ClrFace", None))
+#if QT_CONFIG(tooltip)
+        self.pb_to_sketch.setToolTip(QCoreApplication.translate("fluencyCAD", u"Convert projected construction lines into real sketch geometry", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_to_sketch.setText(QCoreApplication.translate("fluencyCAD", u"ToSketch", None))
+#if QT_CONFIG(tooltip)
+        self.pb_wp_new.setToolTip(QCoreApplication.translate("fluencyCAD", u"Create a new independent workplane (datum plane)", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_wp_new.setText(QCoreApplication.translate("fluencyCAD", u"WP New", None))
+#if QT_CONFIG(shortcut)
+        self.pb_wp_new.setShortcut(QCoreApplication.translate("fluencyCAD", u"Shift+W", None))
+#endif // QT_CONFIG(shortcut)
+        self.groupBox_12.setTitle(QCoreApplication.translate("fluencyCAD", u"Component Connections", None))
+        self.groupBox_13.setTitle(QCoreApplication.translate("fluencyCAD", u"Tools", None))
+        self.pb_del_connection.setText(QCoreApplication.translate("fluencyCAD", u"Del", None))
+        self.pb_update_connection.setText(QCoreApplication.translate("fluencyCAD", u"Upd", None))
+        self.pb_edt_sktch_4.setText(QCoreApplication.translate("fluencyCAD", u"Nothing", None))
+        self.joint_tools.setTitle(QCoreApplication.translate("fluencyCAD", u"Joint Tools", None))
+        self.pb_add_connector.setText(QCoreApplication.translate("fluencyCAD", u"+ Cnct", None))
+        self.pb_remove_connector.setText(QCoreApplication.translate("fluencyCAD", u"- Cnct", None))
+        self.pb_add_connector_3.setText(QCoreApplication.translate("fluencyCAD", u"-Jnt", None))
+        self.pb_add_connector_2.setText(QCoreApplication.translate("fluencyCAD", u"+Jnt", None))
+        self.gl_box.setTitle(QCoreApplication.translate("fluencyCAD", u"Model Viewer", None))
+        self.compo_box.setTitle(QCoreApplication.translate("fluencyCAD", u"Components", None))
+        self.groupBox_11.setTitle(QCoreApplication.translate("fluencyCAD", u"Sketch", None))
+        self.groupBox_6.setTitle(QCoreApplication.translate("fluencyCAD", u"Tools", None))
+        self.pb_edt_sktch.setText(QCoreApplication.translate("fluencyCAD", u"Edt", None))
+        self.pb_nw_sktch.setText(QCoreApplication.translate("fluencyCAD", u"Add", None))
+        self.pb_del_sketch.setText(QCoreApplication.translate("fluencyCAD", u"Del", None))
+        self.groupBox_2.setTitle(QCoreApplication.translate("fluencyCAD", u"Drawing", None))
+        self.pb_arc_tool.setText(QCoreApplication.translate("fluencyCAD", u"Arc", None))
+        self.pb_rectool.setText(QCoreApplication.translate("fluencyCAD", u"Rctgl", None))
+        self.pb_circtool.setText(QCoreApplication.translate("fluencyCAD", u"Circle", None))
+        self.pb_enable_construct.setText(QCoreApplication.translate("fluencyCAD", u"Cstrct", None))
+        self.pb_enable_snap.setText(QCoreApplication.translate("fluencyCAD", u"Snap", None))
+        self.pb_linetool.setText(QCoreApplication.translate("fluencyCAD", u"Line", None))
+#if QT_CONFIG(shortcut)
+        self.pb_linetool.setShortcut(QCoreApplication.translate("fluencyCAD", u"S", None))
+#endif // QT_CONFIG(shortcut)
+        self.pb_slotool.setText(QCoreApplication.translate("fluencyCAD", u"Slot", None))
+#if QT_CONFIG(tooltip)
+        self.pb_offset_tool.setToolTip(QCoreApplication.translate("fluencyCAD", u"Offset selected sketch face (duplicate + offset boundary)", None))
+#endif // QT_CONFIG(tooltip)
+        self.pb_offset_tool.setText(QCoreApplication.translate("fluencyCAD", u"Offst", None))
+        self.assembly_box.setTitle(QCoreApplication.translate("fluencyCAD", u"Assembly", None))
+        self.groupBox.setTitle(QCoreApplication.translate("fluencyCAD", u"Modify", None))
+        self.pb_chamfer_op.setText(QCoreApplication.translate("fluencyCAD", u"Chamfer", None))
+        self.pb_fillet_op.setText(QCoreApplication.translate("fluencyCAD", u"Fillet", None))
+        self.pb_thread.setText(QCoreApplication.translate("fluencyCAD", u"Thread", None))
+        self.pb_extrdop.setText(QCoreApplication.translate("fluencyCAD", u"Extrd", None))
+        self.pb_revop.setText(QCoreApplication.translate("fluencyCAD", u"Rev", None))
+        self.pb_cutop.setText(QCoreApplication.translate("fluencyCAD", u"Cut", None))
+        self.pb_arrayop.setText(QCoreApplication.translate("fluencyCAD", u"Arry", None))
+        self.pb_combop.setText(QCoreApplication.translate("fluencyCAD", u"Comb", None))
+        self.pb_moveop.setText(QCoreApplication.translate("fluencyCAD", u"Mve", None))
+        self.pb_mirror_op.setText(QCoreApplication.translate("fluencyCAD", u"Mirror", None))
+        self.groupBox_10.setTitle(QCoreApplication.translate("fluencyCAD", u"Bodys / Operations", None))
+        self.groupBox_8.setTitle(QCoreApplication.translate("fluencyCAD", u"Tools", None))
+        self.pb_body_hide.setText(QCoreApplication.translate("fluencyCAD", u"Hide", None))
+        self.pb_update_body.setText(QCoreApplication.translate("fluencyCAD", u"Upd", None))
+        self.pb_del_body.setText(QCoreApplication.translate("fluencyCAD", u"Del", None))
+        self.menuFile.setTitle(QCoreApplication.translate("fluencyCAD", u"File", None))
+        self.menuSettings.setTitle(QCoreApplication.translate("fluencyCAD", u"Settings", None))
+    # retranslateUi
+

main_backup.py

@@ -1,851 +0,0 @@
-# nuitka-project: --plugin-enable=pyside6
-# nuitka-project: --plugin-enable=numpy
-# nuitka-project: --standalone
-# nuitka-project: --macos-create-app-bundle
-
-import uuid
-import names
-from PySide6.QtCore import Qt, QPoint, Signal, QSize
-from PySide6.QtWidgets import QApplication, QMainWindow, QSizePolicy, QInputDialog, QDialog, QVBoxLayout, QHBoxLayout, QLabel, QDoubleSpinBox, QCheckBox, QPushButton, QButtonGroup
-from Gui import Ui_fluencyCAD  # Import the generated GUI module
-from drawing_modules.vtk_widget import VTKWidget
-import numpy as np
-
-from drawing_modules.draw_widget_solve import SketchWidget
-from sdf import *
-from python_solvespace import SolverSystem, ResultFlag
-from mesh_modules import simple_mesh, vesta_mesh, interactor_mesh
-from dataclasses import dataclass, field
-
-# main, draw_widget, gl_widget
-
-class ExtrudeDialog(QDialog):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle('Extrude Options')
-
-        def create_hline():
-            line = QLabel()
-            line.setStyleSheet("border-top: 1px solid #cccccc;")  # Light grey line
-            line.setFixedHeight(1)
-            return line
-
-        layout = QVBoxLayout()
-
-        # Length input
-        length_layout = QHBoxLayout()
-        length_label = QLabel('Extrude Length (mm):')
-        self.length_input = QDoubleSpinBox()
-        self.length_input.setDecimals(2)
-        self.length_input.setRange(0, 1000)  # Adjust range as needed
-        length_layout.addWidget(length_label)
-        length_layout.addWidget(self.length_input)
-
-        # Symmetric checkbox
-        self.symmetric_checkbox = QCheckBox('Symmetric Extrude')
-        self.invert_checkbox = QCheckBox('Invert Extrusion')
-        self.cut_checkbox = QCheckBox('Perform Cut')
-        self.union_checkbox = QCheckBox('Combine')
-        self.rounded_checkbox = QCheckBox('Round Edges')
-        self.seperator = create_hline()
-
-        # OK and Cancel buttons
-        button_layout = QHBoxLayout()
-        ok_button = QPushButton('OK')
-        cancel_button = QPushButton('Cancel')
-        ok_button.clicked.connect(self.accept)
-        cancel_button.clicked.connect(self.reject)
-        button_layout.addWidget(ok_button)
-        button_layout.addWidget(cancel_button)
-
-        # Add all widgets to main layout
-        layout.addLayout(length_layout)
-        layout.addWidget(self.seperator)
-        layout.addWidget(self.cut_checkbox)
-        layout.addWidget(self.union_checkbox)
-        layout.addWidget(self.seperator)
-        layout.addWidget(self.symmetric_checkbox)
-        layout.addWidget(self.invert_checkbox)
-        layout.addWidget(self.seperator)
-        layout.addWidget(self.rounded_checkbox)
-
-        layout.addLayout(button_layout)
-
-        self.setLayout(layout)
-
-    def get_values(self):
-        return self.length_input.value(), self.symmetric_checkbox.isChecked() ,self.invert_checkbox.isChecked(), self.cut_checkbox.isChecked(), self.union_checkbox.isChecked(), self.rounded_checkbox.isChecked()
-
-
-class MainWindow(QMainWindow):
-    send_command = Signal(str)
-
-    def __init__(self):
-        super().__init__()
-
-        # Set up the UI from the generated GUI module
-        self.ui = Ui_fluencyCAD()
-        self.ui.setupUi(self)
-
-        self.custom_3D_Widget = VTKWidget()
-        layout = self.ui.gl_box.layout()
-        layout.addWidget(self.custom_3D_Widget)
-        size_policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        #self.custom_3D_Widget.setSizePolicy(size_policy)
-
-        self.sketchWidget = SketchWidget()
-        layout2 = self.ui.sketch_tab.layout()  # Get the layout of self.ui.gl_canvas
-        layout2.addWidget(self.sketchWidget)
-        size_policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        self.sketchWidget.setSizePolicy(size_policy)
-
-        ### Main Model -OLD ?
-        """self.model = {
-            'sketches': {},
-            'operation': {},
-        }"""
-        self.list_selected = []
-
-        #self.ui.pb_apply_code.pressed.connect(self.check_current_tab)
-        self.ui.sketch_list.currentItemChanged.connect(self.on_item_changed)
-        self.ui.sketch_list.itemChanged.connect(self.draw_mesh)
-
-        ### Sketches
-        self.ui.pb_origin_wp.pressed.connect(self.add_new_sketch_origin)
-        self.ui.pb_origin_face.pressed.connect(self.add_new_sketch_wp)
-
-        self.ui.pb_nw_sktch.pressed.connect(self.add_sketch_to_compo)
-        self.ui.pb_del_sketch.pressed.connect(self.del_sketch)
-        self.ui.pb_edt_sktch.pressed.connect(self.edit_sketch)
-
-        self.ui.pb_flip_face.pressed.connect(self.on_flip_face)
-
-        ###Modes
-        self.ui.pb_linetool.clicked.connect(self.sketchWidget.act_line_mode)
-        self.ui.pb_con_ptpt.clicked.connect(self.sketchWidget.act_constrain_pt_pt_mode)
-        self.ui.pb_con_line.clicked.connect(self.sketchWidget.act_constrain_pt_line_mode)
-        self.ui.pb_con_horiz.clicked.connect(self.sketchWidget.act_constrain_horiz_line_mode)
-        self.ui.pb_con_vert.clicked.connect(self.sketchWidget.act_constrain_vert_line_mode)
-        self.ui.pb_con_dist.clicked.connect(self.sketchWidget.act_constrain_distance_mode)
-        self.ui.pb_con_mid.clicked.connect(self.sketchWidget.act_constrain_mid_point_mode)
-
-        ### Operations
-        self.ui.pb_extrdop.pressed.connect(self.send_extrude)
-        self.ui.pb_cutop.pressed.connect(self.send_cut)
-        self.ui.pb_del_body.pressed.connect(self.del_body)
-
-        self.sketchWidget.constrain_done.connect(self.draw_op_complete)
-        self.setFocusPolicy(Qt.StrongFocus)
-
-        self.send_command.connect(self.custom_3D_Widget.on_receive_command)
-        self.ui.actionNew_Project.triggered.connect(self.new_project)
-        self.ui.pb_enable_construct.clicked.connect(self.sketchWidget.on_construct_change)
-        self.project = Project()
-        self.new_project()
-
-        ### SNAPS
-
-        self.ui.pb_snap_midp.toggled.connect(lambda checked: self.sketchWidget.on_snap_mode_change("mpoint", checked))
-        self.ui.pb_snap_horiz.toggled.connect(lambda checked: self.sketchWidget.on_snap_mode_change("horiz", checked))
-        self.ui.pb_snap_vert.toggled.connect(lambda checked: self.sketchWidget.on_snap_mode_change("vert", checked))
-        self.ui.pb_snap_angle.toggled.connect(lambda checked: self.sketchWidget.on_snap_mode_change("angle", checked))
-        self.ui.pb_enable_snap.toggled.connect(lambda checked: self.sketchWidget.on_snap_mode_change("point", checked))
-        ### COMPOS
-        ### COMPOS
-
-        self.ui.new_compo.pressed.connect(self.new_component)
-
-        """Project -> (Timeline) -> Component -> Sketch -> Body / Interactor -> Connector -> Assembly -> PB Render"""
-
-    def new_project(self):
-        print("New project")
-        timeline = []
-        self.project.timeline = timeline
-        self.new_component()
-
-    def new_component(self):
-        print("Creating a new component...")
-
-        # Lazily initialize self.compo_layout if it doesn't exist
-        if not hasattr(self, 'compo_layout'):
-            print("Initializing compo_layout...")
-            self.compo_layout = QHBoxLayout()
-
-            # Create a button group
-            self.compo_group = QButtonGroup(self)
-            self.compo_group.setExclusive(True)  # Ensure exclusivity
-
-            # Ensure the QGroupBox has a layout
-            if not self.ui.compo_box.layout():
-                self.ui.compo_box.setLayout(QVBoxLayout())  # Set a default layout for QGroupBox
-
-            # Add the horizontal layout to the QGroupBox's layout
-            self.ui.compo_box.layout().addLayout(self.compo_layout)
-
-            # Align the layout to the left
-            self.compo_layout.setAlignment(Qt.AlignLeft)
-
-        # Create and initialize a new Component
-        compo = Component()
-        compo.id = f"Component {len(self.project.timeline)}"
-        compo.descript = "Initial Component"
-        compo.sketches = {}
-        compo.bodies = {}
-        self.project.timeline.append(compo)
-
-        # Create a button for the new component
-        button = QPushButton()
-        button.setToolTip(compo.id)
-        button.setText(str(len(self.project.timeline)))
-        button.setFixedSize(QSize(40, 40))  # Set button size
-        button.setCheckable(True)
-        #button.setAutoExclusive(True)
-        button.released.connect(self.on_compo_change)
-        button.setChecked(True)
-
-        # Add button to the group
-        self.compo_group.addButton(button)
-
-        # Add the button to the layout
-        self.compo_layout.addWidget(button)
-
-        # We automatically switch to the new compo hence, refresh
-        self.on_compo_change()
-
-        print(f"Added component {compo.id} to the layout.")
-
-    def get_activated_compo(self):
-        # Iterate through all items in the layout
-        total_elements = self.compo_layout.count()
-        #print(total_elements)
-        for i in range(total_elements):
-            widget = self.compo_layout.itemAt(i).widget()  # Get the widget at the index
-            if widget:  # Check if the widget is not None
-                if isinstance(widget, QPushButton) and widget.isCheckable():
-                    state = widget.isChecked()  # Get the checked state
-                    print(f"{widget.text()} is {'checked' if state else 'unchecked'}.")
-                    if state:
-                        return i
-
-    def add_new_sketch_origin(self):
-        name = f"sketches-{str(names.get_first_name())}"
-        sketch = Sketch()
-        sketch.id = name
-        sketch.origin = [0,0,0]
-
-        self.sketchWidget.reset_buffers()
-        self.sketchWidget.create_sketch(sketch)
-
-    def add_new_sketch_wp(self):
-        ## Sketch projected from 3d view into 2d
-        name = f"sketches-{str(names.get_first_name())}"
-        sketch = Sketch()
-        sketch.id = name
-        sketch.origin = self.custom_3D_Widget.centroid
-        sketch.normal = self.custom_3D_Widget.selected_normal
-        sketch.slv_points = []
-        sketch.slv_lines = []
-        sketch.proj_points = self.custom_3D_Widget.project_tosketch_points
-        sketch.proj_lines = self.custom_3D_Widget.project_tosketch_lines
-
-        self.sketchWidget.reset_buffers()
-        self.sketchWidget.create_sketch(sketch)
-        self.sketchWidget.create_workplane_projected()
-
-        if not sketch.proj_lines:
-            self.sketchWidget.convert_proj_points(sketch.proj_points)
-
-        self.sketchWidget.convert_proj_lines(sketch.proj_lines)
-        self.sketchWidget.update()
-
-        # CLear all selections after it has been projected
-        self.custom_3D_Widget.project_tosketch_points.clear()
-        self.custom_3D_Widget.project_tosketch_lines.clear()
-        self.custom_3D_Widget.clear_actors_projection()
-        self.custom_3D_Widget.clear_actors_normals()
-
-    def add_sketch_to_compo(self):
-        """
-        Add sketch to component
-        :return:
-        """
-        sketch = Sketch()
-        sketch_from_widget = self.sketchWidget.get_sketch()
-
-        #Save original for editing later
-        sketch.original_sketch = sketch_from_widget
-
-        #Get parameters
-        points = [point for point in sketch_from_widget.points if hasattr(point, 'is_helper') and not point.is_helper]
-
-        sketch.convert_points_for_sdf(points)
-        sketch.id = sketch_from_widget.id
-
-        sketch.filter_lines_for_interactor(sketch_from_widget.lines)
-
-        # Register sketch to timeline
-        ### Add selection compo here
-        compo_id = self.get_activated_compo()
-        #print("newsketch_name", sketch.id)
-        self.project.timeline[compo_id].sketches[sketch.id] = sketch
-
-        # Add Item to slection menu
-        self.ui.sketch_list.addItem(sketch.id)
-
-        # Deactivate drawing
-        self.ui.pb_linetool.setChecked(False)
-        self.sketchWidget.line_mode = False
-
-        items = self.ui.sketch_list.findItems(sketch.id, Qt.MatchExactly)[0]
-        self.ui.sketch_list.setCurrentItem(items)
-
-    def on_compo_change(self):
-        '''This function redraws the sdf and helper mesh from available bodies and adds the names back to the list entries'''
-        self.custom_3D_Widget.clear_body_actors()
-        self.custom_3D_Widget.clear_actors_interactor()
-        self.custom_3D_Widget.clear_actors_projection()
-
-        compo_id = self.get_activated_compo()
-        if compo_id is not None:
-            self.ui.sketch_list.clear()
-            self.ui.body_list.clear()
-
-            #print("id", compo_id)
-            #print("sketch_registry", self.project.timeline[compo_id].sketches)
-
-            for sketch in self.project.timeline[compo_id].sketches:
-                #print(sketch)
-                self.ui.sketch_list.addItem(sketch)
-
-            for body in self.project.timeline[compo_id].bodies:
-                self.ui.body_list.addItem(body)
-
-                if self.project.timeline[compo_id].bodies:
-                    item = self.ui.body_list.findItems(body , Qt.MatchExactly)[0]
-                    self.ui.body_list.setCurrentItem(item)
-                    self.draw_mesh()
-
-                    selected = self.ui.body_list.currentItem()
-                    name = selected.text()
-
-                    edges = self.project.timeline[compo_id].bodies[name].interactor.edges
-                    offset_vec = self.project.timeline[compo_id].bodies[name].interactor.offset_vector
-                    self.custom_3D_Widget.load_interactor_mesh(edges, offset_vec)
-
-    def edit_sketch(self):
-        selected = self.ui.sketch_list.currentItem()
-        name = selected.text()
-        sel_compo = self.project.timeline[self.get_activated_compo()]
-        sketch = sel_compo.sketches[name].original_sketch
-
-        self.sketchWidget.set_sketch(sketch)
-
-        self.sketchWidget.update()
-
-    def del_sketch(self):
-        selected = self.ui.sketch_list.currentItem()
-        name = selected.text()
-        sel_compo = self.project.timeline[self.get_activated_compo()]
-        sketch = sel_compo.sketches[name]
-
-        if sketch is not None:
-            sel_compo.sketches.pop(name)
-            row = self.ui.sketch_list.row(selected)  # Get the row of the current item
-            self.ui.sketch_list.takeItem(row)  # Remove the item from the list widget
-            self.sketchWidget.sketch = None
-            print(sketch)
-        else:
-            print("No item selected.")
-
-    def on_flip_face(self):
-        self.send_command.emit("flip")
-
-    def draw_op_complete(self):
-        # safely disable the line modes
-        self.ui.pb_linetool.setChecked(False)
-        self.ui.pb_con_ptpt.setChecked(False)
-        self.ui.pb_con_line.setChecked(False)
-        self.ui.pb_con_dist.setChecked(False)
-        self.ui.pb_con_mid.setChecked(False)
-        self.ui.pb_con_perp.setChecked(False)
-
-        self.sketchWidget.mouse_mode = None
-        self.sketchWidget.reset_buffers()
-
-    def draw_mesh(self):
-
-        name = self.ui.body_list.currentItem().text()
-        print("selected_for disp", name)
-
-        compo_id = self.get_activated_compo()
-        model = self.project.timeline[compo_id].bodies[name].sdf_body
-
-        vesta = vesta_mesh
-        model_data = vesta.generate_mesh_from_sdf(model, resolution=64, threshold=0)
-
-        vertices, faces = model_data
-        #vesta.save_mesh_as_stl(vertices, faces, 'test.stl')
-        self.custom_3D_Widget.render_from_points_direct_with_faces(vertices, faces)
-
-    def on_item_changed(self, current_item, previous_item):
-        if current_item:
-            name = current_item.text()
-            #self.view_update()
-            print(f"Selected item: {name}")
-
-    def update_body(self):
-        pass
-
-    def del_body(self):
-        print("Deleting")
-        name = self.ui.body_list.currentItem()  # Get the current item
-
-        if name is not None:
-            item_name = name.text()
-            print("obj_name", item_name)
-            # Check if the 'operation' key exists in the model dictionary
-
-            if 'operation' in self.model and item_name in self.model['operation']:
-                if self.model['operation'][item_name]['id'] == item_name:
-                    row = self.ui.body_list.row(name)  # Get the row of the current item
-                    self.ui.body_list.takeItem(row)  # Remove the item from the list widget
-                    self.model['operation'].pop(item_name)  # Remove the item from the operation dictionary
-                    print(f"Removed operation: {item_name}")
-                    self.custom_3D_Widget.clear_mesh()
-
-    def send_extrude(self):
-        # Dialog input
-        is_symmetric = None
-        length = None
-        invert = None
-
-        selected = self.ui.sketch_list.currentItem()
-        name = selected.text()
-
-        sel_compo = self.project.timeline[self.get_activated_compo()]
-        #print(sel_compo)
-        sketch = sel_compo.sketches[name]
-        #print(sketch)
-        points = sketch.sdf_points
-
-        # detect loop that causes problems in mesh generation
-        if points[-1] == points[0]:
-            print("overlap")
-            del points[-1]
-
-        dialog = ExtrudeDialog(self)
-        if dialog.exec():
-            length, is_symmetric, invert, cut, union_with, rounded = dialog.get_values()
-            #print(f"Extrude length: {length}, Symmetric: {is_symmetric} Invert: {invert}")
-        else:
-            length = 0
-            #print("Extrude cancelled")
-
-        normal = self.custom_3D_Widget.selected_normal
-        #print("Normie enter", normal)
-        if normal is None:
-            normal = [0, 0, 1]
-
-        centroid = self.custom_3D_Widget.centroid
-        if centroid is None:
-            centroid = [0, 0, 0]
-        """else:
-            centroid = list(centroid)"""
-        #print("This centroid ", centroid)
-
-        sketch.origin = centroid
-        sketch.normal = normal
-
-        f = sketch.extrude(length, is_symmetric, invert, 0)
-
-        # Create body element and assign known stuff
-        name_op = f"extrd-{name}"
-
-        body = Body()
-        body.sketch = sketch #we add the sketches for reference here
-        body.id = name_op
-        body.sdf_body = f
-
-        ### Interactor
-        interactor = Interactor()
-        interactor.add_lines_for_interactor(sketch.interactor_lines)
-        interactor.invert = invert
-
-        if not invert:
-            edges = interactor_mesh.generate_mesh(interactor.lines, 0, length)
-        else:
-            edges = interactor_mesh.generate_mesh(interactor.lines, 0, -length)
-
-        sel_compo.bodies[name_op] = body
-
-        offset_vector = interactor.vector_to_centroid(None, centroid, normal)
-        #print("off_ved", offset_vector)
-        if len(offset_vector) == 0 :
-            offset_vector = [0, 0, 0]
-
-        interactor.edges = edges
-        interactor.offset_vector = offset_vector
-        body.interactor = interactor
-
-        self.custom_3D_Widget.load_interactor_mesh(edges, offset_vector)
-
-        self.ui.body_list.addItem(name_op)
-        items = self.ui.body_list.findItems(name_op, Qt.MatchExactly)[0]
-        self.ui.body_list.setCurrentItem(items)
-
-        self.draw_mesh()
-
-    def send_cut(self):
-        """name = self.ui.body_list.currentItem().text()
-        points = self.model['operation'][name]['sdf_object']
-        sel_compo = self.project.timeline[self.get_activated_compo()]
-        points = sel_compo.bodies[].
-        self.list_selected.append(points)"""
-
-        selected = self.ui.body_list.currentItem()
-        name = selected.text()
-
-        sel_compo = self.project.timeline[self.get_activated_compo()]
-        # print(sel_compo)
-        body = sel_compo.bodies[name]
-        # print(sketch)
-        self.list_selected.append(body.sdf_body)
-
-        if len(self.list_selected) == 2:
-            f = difference(self.list_selected[0], self.list_selected[1])  # equivalent
-
-            element = {
-                'id': name,
-                'type': 'cut',
-                'sdf_object': f,
-            }
-
-            # Create body element and assign known stuff
-            name_op = f"cut-{name}"
-
-            body = Body()
-            body.id = name_op
-            body.sdf_body = f
-
-            ## Add to component
-            sel_compo.bodies[name_op] = body
-
-            self.ui.body_list.addItem(name_op)
-            items = self.ui.body_list.findItems(name_op, Qt.MatchExactly)
-            self.ui.body_list.setCurrentItem(items[-1])
-            self.custom_3D_Widget.clear_body_actors()
-            self.draw_mesh()
-
-        elif len(self.list_selected) > 2:
-            self.list_selected.clear()
-        else:
-            print("mindestens 2!")
-
-    def load_and_render(self, file):
-        self.custom_3D_Widget.load_stl(file)
-        self.custom_3D_Widget.update()
-
-@dataclass
-class Timeline:
-    """Timeline """
-    ### Collection of the Components
-    timeline: list = None
-
-    """add to time, 
-    remove from time, """
-
-class Assembly:
-    """Connecting Components in 3D space based on slvs solver"""
-
-@dataclass
-class Component:
-    """The base container combining all related elements
-    id : The unique ID
-    sketches : the base sketches, bodys can contain additonal sketches for features
-    interactor : A smiplified model used as interactor
-    body : The body class that contains the actual 3d information
-    connector : Vector and Nomral information for assembly
-    descript : a basic description
-    materil : Speicfy a material for pbr rendering
-    """
-    id = None
-    sketches: dict = None
-    bodies: dict = None
-    connector = None
-
-    # Description
-    descript = None
-
-    # PBR
-    material = None
-
-
-class Connector:
-    """An Element that contains vectors and or normals as connection points.
-    These connection points can exist independently of bodies and other elements"""
-    id = None
-    vector = None
-    normal = None
-
-
-class Code:
-    """A class that holds all information from the code based approach"""
-    command_list = None
-
-    def generate_mesh_from_code(self, code_text: str):
-        local_vars = {}
-
-        try:
-            print(code_text)
-            exec(code_text, globals(), local_vars)
-            # Retrieve the result from the captured local variables
-            result = local_vars.get('result')
-            print("Result:", result)
-
-        except Exception as e:
-            print("Error executing code:", e)
-
-
-@dataclass
-class Sketch:
-    """All of the 2D Information of a sketches"""
-
-    # Save the incomng sketch from the 2D widget for late redit
-    original_sketch = None
-
-    id = None
-
-    # Space Information
-    origin = None
-    slv_plane = None
-    normal = None
-
-    # Points in UI form the sketches widget
-    ui_points: list = None
-    ui_lines: list = None
-
-    # Points cartesian coming as result of the solver
-    slv_points: list = None
-    slv_lines: list = None
-
-    sdf_points: list = None
-
-    interactor_lines: list = None
-
-    # Points coming back from the 3D-Widget as projection to draw on
-    proj_points: list = None
-    proj_lines: list = None
-
-    # Workingplane
-    working_plane = None
-
-    def translate_points_tup(self, point: QPoint):
-        """QPoints from Display to mesh data
-        input: Qpoints
-        output: Tuple X,Y
-        """
-        if isinstance(point, QPoint):
-            return point.x(), point.y()
-
-    def vector_to_centroid(self, shape_center, centroid, normal):
-
-        if not shape_center:
-            # Calculate the current center of the shape
-            shape_center = [0, 0, 0]
-
-        # Calculate the vector from the shape's center to the centroid
-        center_to_centroid = np.array(centroid) - np.array(shape_center)
-
-        # Project this vector onto the normal to get the required translation along the normal
-        translation_along_normal = np.dot(center_to_centroid, normal) * normal
-
-        return translation_along_normal
-
-    def angle_between_normals(self, normal1, normal2):
-        # Ensure the vectors are normalized
-        n1 = normal1 / np.linalg.norm(normal1)
-        n2 = normal2 / np.linalg.norm(normal2)
-
-        # Compute the dot product
-        dot_product = np.dot(n1, n2)
-
-        # Clip the dot product to the valid range [-1, 1]
-        dot_product = np.clip(dot_product, -1.0, 1.0)
-
-        # Compute the angle in radians
-        angle_rad = np.arccos(dot_product)
-
-        # Convert to degrees if needed
-        angle_deg = np.degrees(angle_rad)
-        print("Angle deg", angle_deg)
-
-        return angle_rad
-
-    def offset_syn(self, f, length):
-        f = f.translate((0,0, length / 2))
-        return f
-
-    def distance(self, p1, p2):
-        """Calculate the distance between two points."""
-        print("p1", p1)
-        print("p2", p2)
-        return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
-
-    def convert_points_for_sdf(self, points):
-        points_for_sdf = []
-        for point in points:
-            if point.is_helper is False:
-                print("point", point)
-                points_for_sdf.append(self.translate_points_tup(point.ui_point))
-
-        self.sdf_points = points_for_sdf
-
-    def filter_lines_for_interactor(self, lines):
-        ### Filter lines that are not meant to be drawn for the interactor like contruction lines
-        filtered_lines = []
-        for line in lines:
-            if not line.is_helper:
-                filtered_lines.append(line)
-
-        self.interactor_lines = filtered_lines
-
-    def extrude(self, height: float, symet: bool = True, invert: bool = False, offset_length: float = None):
-        """
-        Extrude a 2D shape into 3D, orient it along the normal, and position it relative to the centroid.
-        """
-
-        # Normalize the normal vector
-        normal = np.array(self.normal)
-        normal = normal / np.linalg.norm(self.normal)
-
-        # Create the 2D shape
-        f = polygon(self.sdf_points)
-
-        # Extrude the shape along the Z-axis
-        f = f.extrude(height)
-
-        # Center the shape along its extrusion axis
-        f = f.translate((0, 0, height / 2))
-
-        # Orient the shape along the normal vector
-        f = f.orient(normal)
-
-        offset_vector = self.vector_to_centroid(None, self.origin, normal)
-        # Adjust the offset vector by subtracting the inset distance along the normal direction
-        adjusted_offset = offset_vector - (normal * height)
-        if invert:
-            # Translate the shape along the adjusted offset vector
-            f = f.translate(adjusted_offset)
-        else:
-            f = f.translate(offset_vector)
-
-        # If offset_length is provided, adjust the offset_vector
-        if offset_length is not None:
-            # Check if offset_vector is not a zero vector
-            offset_vector_magnitude = np.linalg.norm(offset_vector)
-            if offset_vector_magnitude > 1e-10:  # Use a small threshold to avoid floating-point issues
-                # Normalize the offset vector
-                offset_vector_norm = offset_vector / offset_vector_magnitude
-                # Scale the normalized vector by the desired length
-                offset_vector = offset_vector_norm * offset_length
-                f = f.translate(offset_vector)
-            else:
-                print("Warning: Offset vector has zero magnitude. Using original vector.")
-
-        # Translate the shape along the adjusted offset vector
-
-        return f
-
-@dataclass
-class Interactor:
-    """Helper mesh consisting of edges for selection"""
-    lines = None
-    faces = None
-    body = None
-    offset_vector = None
-    edges = None
-
-    def translate_points_tup(self, point: QPoint):
-        """QPoints from Display to mesh data
-        input: Qpoints
-        output: Tuple X,Y
-        """
-        if isinstance(point, QPoint):
-            return point.x(), point.y()
-
-    def vector_to_centroid(self, shape_center, centroid, normal):
-
-        if not shape_center:
-            # Calculate the current center of the shape
-            shape_center = [0, 0, 0]
-
-        # Calculate the vector from the shape's center to the centroid
-        center_to_centroid = np.array(centroid) - np.array(shape_center)
-
-        # Project this vector onto the normal to get the required translation along the normal
-        translation_along_normal = np.dot(center_to_centroid, normal) * normal
-
-        return translation_along_normal
-
-    def add_lines_for_interactor(self, input_lines: list):
-        """Takes Line2D objects from the sketch widget and preparesit for interactor mesh.
-        Translates coordinates."""
-
-        points_for_interact = []
-        for point_to_poly in input_lines:
-            from_coord_start = window.sketchWidget.from_quadrant_coords_no_center(point_to_poly.crd1.ui_point)
-            from_coord_end = window.sketchWidget.from_quadrant_coords_no_center(point_to_poly.crd2.ui_point)
-            start_draw = self.translate_points_tup(from_coord_start)
-            end_draw = self.translate_points_tup(from_coord_end)
-            line = start_draw, end_draw
-            points_for_interact.append(line)
-
-        print("packed_lines", points_for_interact)
-
-        self.lines = points_for_interact
-
-@dataclass
-class Body:
-    """The actual body as sdf3 object"""
-    id = None
-    sketch = None
-    height = None
-    interactor = None
-    sdf_body = None
-
-    def mirror_body(self, sdf_object3d):
-        f = sdf_object3d.rotate(pi)
-
-        return f
-
-class Output:
-    def export_mesh(self, sdf_object):
-        """FINAL EXPORT"""
-        result_points = sdf_object.generate()
-        write_binary_stl('out.stl', result_points)
-
-    def generate_mesh_from_code(self, code_text: str):
-        local_vars = {}
-
-        try:
-            print(code_text)
-            exec(code_text, globals(), local_vars)
-            # Retrieve the result from the captured local variables
-            result = local_vars.get('result')
-            print("Result:", result)
-
-        except Exception as e:
-            print("Error executing code:", e)
-
-class Project:
-    """Project -> Timeline -> Component -> Sketch -> Body / Interactor -> Connector -> Assembly -> PB Render"""
-    timeline: Timeline = None
-    assembly: Assembly = None
-
-if __name__ == "__main__":
-    app = QApplication()
-    window = MainWindow()
-    window.show()
-    app.exec()
-
-

mesh_modules/interactor_mesh.py

@@ -1,43 +0,0 @@
-# Draw simple boundary based on the lines and depth
-
-def generate_mesh(lines: list, z_origin: float, depth: float, invert: bool = False):
-
-    origin = create_3D(lines, z_origin)
-
-    if invert :
-        extruded = create_3D(lines, z_origin - depth)
-    else:
-        extruded = create_3D(lines, z_origin + depth)
-
-    vert_lines = create_vert_lines(origin, extruded)
-
-    print(f"Result = {origin} / {extruded}  / {vert_lines}")
-
-    return origin + vert_lines + extruded
-
-
-def create_vert_lines(origin, extruded):
-    vert_lines = []
-    for d3_point_o, d3point_e in zip(origin, extruded):
-        for sp3d_1, sp3d_2 in zip(d3_point_o, d3point_e):
-            new_line = sp3d_1, sp3d_2
-            vert_lines.append(new_line)
-    return vert_lines
-
-
-def create_3D(lines, z_pos):
-    line_loop = []
-    for coordinate2d in lines:
-        start, end = coordinate2d
-
-        xs, ys = start
-        coordinate3d_start_orig = xs, ys, z_pos
-
-        xe, ye = end
-        coordinate3d_end_orig = xe, ye, z_pos
-
-        line3d_orig = coordinate3d_start_orig, coordinate3d_end_orig
-
-        line_loop.append(line3d_orig)
-
-    return line_loop

mesh_modules/simple_mesh.py

@@ -1,213 +0,0 @@
-import numpy as np
-from scipy.spatial import Delaunay, ConvexHull
-#from shapely.geometry import Polygon, Point
-
-
-def alpha_shape(points, alpha):
-    """
-    Compute the alpha shape (concave hull) of a set of points.
-    """
-
-    def add_edge(edges, edge_points, points, i, j):
-        """Add a line between the i-th and j-th points if not in the list already"""
-        if (i, j) in edges or (j, i) in edges:
-            return
-        edges.add((i, j))
-        edge_points.append(points[[i, j]])
-
-    tri = Delaunay(points)
-    edges = set()
-    edge_points = []
-
-    # Loop over triangles:
-    for ia, ib, ic in tri.simplices:
-        pa = points[ia]
-        pb = points[ib]
-        pc = points[ic]
-        # Lengths of sides of triangle
-        a = np.sqrt((pa[0] - pb[0]) ** 2 + (pa[1] - pb[1]) ** 2)
-        b = np.sqrt((pb[0] - pc[0]) ** 2 + (pb[1] - pc[1]) ** 2)
-        c = np.sqrt((pc[0] - pa[0]) ** 2 + (pc[1] - pa[1]) ** 2)
-        # Semiperimeter of triangle
-        s = (a + b + c) / 2.0
-        # Area of triangle by Heron's formula
-        area = np.sqrt(s * (s - a) * (s - b) * (s - c))
-        circum_r = a * b * c / (4.0 * area)
-        # Here's the radius filter.
-        if circum_r < 1.0 / alpha:
-            add_edge(edges, edge_points, points, ia, ib)
-            add_edge(edges, edge_points, points, ib, ic)
-            add_edge(edges, edge_points, points, ic, ia)
-
-    m = np.array(edge_points)
-    return m
-
-
-def generate_mesh(points, depth, alpha=0.1):
-    """
-    Generate a mesh by extruding a 2D shape along the Z-axis, automatically detecting holes.
-
-    :param points: List of (x, y) tuples representing all points of the 2D shape, including potential holes.
-    :param depth: Extrusion depth along the Z-axis.
-    :param alpha: Alpha value for the alpha shape algorithm (controls the "tightness" of the boundary).
-    :return: Tuple of vertices and faces.
-    """
-    # Convert points to a numpy array
-    points_2d = np.array(points)
-
-    # Compute the alpha shape (outer boundary)
-    boundary_edges = alpha_shape(points_2d, alpha)
-
-    # Create a Polygon from the boundary
-    boundary_polygon = Polygon(boundary_edges)
-
-    # Separate points into boundary and interior
-    boundary_points = []
-    interior_points = []
-    for point in points:
-        if Point(point).touches(boundary_polygon) or Point(point).within(boundary_polygon):
-            if Point(point).touches(boundary_polygon):
-                boundary_points.append(point)
-            else:
-                interior_points.append(point)
-
-    # Perform Delaunay triangulation on all points
-    tri = Delaunay(points_2d)
-
-    # Generate the top and bottom faces
-    bottom_face = np.hstack((tri.points, np.zeros((tri.points.shape[0], 1))))
-    top_face = np.hstack((tri.points, np.ones((tri.points.shape[0], 1)) * depth))
-
-    # Combine top and bottom vertices
-    vertices_array = np.vstack((bottom_face, top_face))
-
-    # Create faces
-    faces = []
-
-    # Bottom face triangulation
-    for simplex in tri.simplices:
-        faces.append(simplex.tolist())
-
-    # Top face triangulation (with an offset)
-    top_offset = len(tri.points)
-    for simplex in tri.simplices:
-        faces.append([i + top_offset for i in simplex])
-
-    # Side faces for the outer boundary
-    for i in range(len(boundary_points)):
-        next_i = (i + 1) % len(boundary_points)
-        current = points.index(boundary_points[i])
-        next_point = points.index(boundary_points[next_i])
-        faces.append([current, top_offset + current, top_offset + next_point])
-        faces.append([current, top_offset + next_point, next_point])
-
-    # Convert vertices to the desired format: list of tuples
-    vertices = [tuple(vertex) for vertex in vertices_array]
-
-    return vertices, faces
-
-def generate_mesh_wholes(points, holes, depth):
-    """
-    Generate a mesh by extruding a 2D shape along the Z-axis, including holes.
-
-    :param points: List of (x, y) tuples representing the outer boundary of the 2D shape.
-    :param holes: List of lists, where each inner list contains (x, y) tuples representing a hole.
-    :param depth: Extrusion depth along the Z-axis.
-    :return: Tuple of vertices and faces.
-    """
-    # Convert points to a numpy array
-    points_2d = np.array(points)
-
-    # Prepare points for triangulation
-    triangulation_points = points_2d.tolist()
-    for hole in holes:
-        triangulation_points.extend(hole)
-
-    # Perform Delaunay triangulation
-    tri = Delaunay(np.array(triangulation_points))
-
-    # Generate the top and bottom faces
-    bottom_face = np.hstack((tri.points, np.zeros((tri.points.shape[0], 1))))
-    top_face = np.hstack((tri.points, np.ones((tri.points.shape[0], 1)) * depth))
-
-    # Combine top and bottom vertices
-    vertices_array = np.vstack((bottom_face, top_face))
-
-    # Create faces
-    faces = []
-
-    # Bottom face triangulation
-    for simplex in tri.simplices:
-        faces.append(simplex.tolist())
-
-    # Top face triangulation (with an offset)
-    top_offset = len(tri.points)
-    for simplex in tri.simplices:
-        faces.append([i + top_offset for i in simplex])
-
-    # Side faces
-    for i in range(len(points)):
-        next_i = (i + 1) % len(points)
-        faces.append([i, top_offset + i, top_offset + next_i])
-        faces.append([i, top_offset + next_i, next_i])
-
-    # Side faces for holes
-    start_index = len(points)
-    for hole in holes:
-        for i in range(len(hole)):
-            current = start_index + i
-            next_i = start_index + (i + 1) % len(hole)
-            faces.append([current, top_offset + next_i, top_offset + current])
-            faces.append([current, next_i, top_offset + next_i])
-        start_index += len(hole)
-
-    # Convert vertices to the desired format: list of tuples
-    vertices = [tuple(vertex) for vertex in vertices_array]
-
-    return vertices, faces
-
-def generate_mesh_simple(points, depth):
-    """
-    Generate a mesh by extruding a 2D shape along the Z-axis.
-
-    :param points: List of (x, y) tuples representing the 2D shape.
-    :param depth: Extrusion depth along the Z-axis.
-    :return: Tuple of vertices and faces.
-    """
-    # Convert points to a numpy array
-    points_2d = np.array(points)
-
-    # Get the convex hull of the points to ensure they form a proper polygon
-    hull = ConvexHull(points_2d)
-    hull_points = points_2d[hull.vertices]
-
-    # Generate the top and bottom faces
-    bottom_face = np.hstack((hull_points, np.zeros((hull_points.shape[0], 1))))
-    top_face = np.hstack((hull_points, np.ones((hull_points.shape[0], 1)) * depth))
-
-    # Combine top and bottom vertices
-    vertices_array = np.vstack((bottom_face, top_face))
-
-    # Create faces
-    faces = []
-
-    # Bottom face triangulation (counter-clockwise)
-    for i in range(len(hull_points) - 2):
-        faces.append([0, i + 2, i + 1])
-
-    # Top face triangulation (counter-clockwise, with an offset)
-    top_offset = len(hull_points)
-    for i in range(len(hull_points) - 2):
-        faces.append([top_offset, top_offset + i + 1, top_offset + i + 2])
-
-    # Side faces (ensure counter-clockwise order)
-    for i in range(len(hull_points)):
-        next_i = (i + 1) % len(hull_points)
-        faces.append([i, top_offset + i, top_offset + next_i])
-        faces.append([i, top_offset + next_i, next_i])
-
-    # Convert vertices to the desired format: list of tuples
-    vertices = [tuple(vertex) for vertex in vertices_array]
-
-    return vertices, faces
-

mesh_modules/vesta_mesh.py

@@ -1,119 +0,0 @@
-import numpy as np
-from skimage import measure
-import multiprocessing
-from functools import partial
-from multiprocessing.pool import ThreadPool
-import itertools
-import time
-
-
-def _cartesian_product(*arrays):
-    la = len(arrays)
-    dtype = np.result_type(*arrays)
-    arr = np.empty([len(a) for a in arrays] + [la], dtype=dtype)
-    for i, a in enumerate(np.ix_(*arrays)):
-        arr[..., i] = a
-    return arr.reshape(-1, la)
-
-
-class VESTA:
-    def __init__(self, sdf, bounds=None, resolution=64, threshold=0.0, workers=None):
-        self.sdf = sdf
-        self.bounds = bounds
-        self.resolution = resolution
-        self.threshold = threshold
-        self.workers = workers or multiprocessing.cpu_count()
-
-    def _estimate_bounds(self):
-        s = 16
-        x0 = y0 = z0 = -1e9
-        x1 = y1 = z1 = 1e9
-        prev = None
-        for i in range(32):
-            X = np.linspace(x0, x1, s)
-            Y = np.linspace(y0, y1, s)
-            Z = np.linspace(z0, z1, s)
-            d = np.array([X[1] - X[0], Y[1] - Y[0], Z[1] - Z[0]])
-            threshold = np.linalg.norm(d) / 2
-            if threshold == prev:
-                break
-            prev = threshold
-            P = _cartesian_product(X, Y, Z)
-            volume = self.sdf(P).reshape((len(X), len(Y), len(Z)))
-            where = np.argwhere(np.abs(volume) <= threshold)
-            if where.size == 0:
-                continue
-            x1, y1, z1 = (x0, y0, z0) + where.max(axis=0) * d + d / 2
-            x0, y0, z0 = (x0, y0, z0) + where.min(axis=0) * d - d / 2
-        if prev is None:
-            raise ValueError("Failed to estimate bounds. No points found within any threshold.")
-        return ((x0, y0, z0), (x1, y1, z1))
-
-    def _vesta_worker(self, chunk):
-        x0, x1, y0, y1, z0, z1 = chunk
-        X = np.linspace(x0, x1, self.resolution)
-        Y = np.linspace(y0, y1, self.resolution)
-        Z = np.linspace(z0, z1, self.resolution)
-        P = _cartesian_product(X, Y, Z)
-        V = self.sdf(P).reshape((self.resolution, self.resolution, self.resolution))
-
-        try:
-            verts, faces, _, _ = measure.marching_cubes(V, self.threshold)
-        except RuntimeError:
-            # Return empty arrays if marching_cubes fails
-            return np.array([]), np.array([])
-
-        # Scale and translate vertices to match the chunk's bounds
-        verts = verts / (self.resolution - 1)
-        verts[:, 0] = verts[:, 0] * (x1 - x0) + x0
-        verts[:, 1] = verts[:, 1] * (y1 - y0) + y0
-        verts[:, 2] = verts[:, 2] * (z1 - z0) + z0
-
-        return verts, faces
-
-    def _merge_meshes(self, results):
-        all_verts = []
-        all_faces = []
-        offset = 0
-        for verts, faces in results:
-            if len(verts) > 0 and len(faces) > 0:
-                all_verts.append(verts)
-                all_faces.append(faces + offset)
-                offset += len(verts)
-        if not all_verts or not all_faces:
-            return np.array([]), np.array([])
-        return np.vstack(all_verts), np.vstack(all_faces)
-
-    def generate_mesh(self):
-        if self.bounds is None:
-            self.bounds = self._estimate_bounds()
-
-        (x0, y0, z0), (x1, y1, z1) = self.bounds
-        chunks = [
-            (x0, x1, y0, y1, z0, z1)
-        ]
-
-        with ThreadPool(self.workers) as pool:
-            results = pool.map(self._vesta_worker, chunks)
-
-        verts, faces = self._merge_meshes(results)
-        return verts, faces
-
-
-def generate_mesh_from_sdf(sdf, bounds=None, resolution=64, threshold=0.0, workers=None):
-    vesta = VESTA(sdf, bounds, resolution, threshold, workers)
-    return vesta.generate_mesh()
-
-
-# Helper function to save the mesh as an STL file
-def save_mesh_as_stl(vertices, faces, filename):
-    from stl import mesh
-
-    # Create the mesh
-    cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
-    for i, f in enumerate(faces):
-        for j in range(3):
-            cube.vectors[i][j] = vertices[f[j], :]
-
-    # Write the mesh to file
-    cube.save(filename)

meshtest.py

@@ -1,5 +0,0 @@
-from sdf import *
-f = box(1).translate((1,1,-0.2))
-c = hexagon(1).extrude(1).orient([0,0,-1])
-c = f & c
-f.save("out.stl")

pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fluency-cad"
+version = "2.0.0"
+description = "Parametric CAD application with OpenCASCADE geometry kernel"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "Fluency CAD Team"}
+]
+keywords = ["cad", "parametric", "opencascade", "3d-modeling"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: CAD",
+]
+
+dependencies = [
+    "pygfx>=0.1.0",
+    "wgpu>=0.1.0",
+    "PySide6>=6.4.0",
+    "numpy>=1.24.0",
+    "scipy>=1.10.0",
+    "pillow>=10.0.0",
+    "python_solvespace>=3.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "black>=24.0",
+    "mypy>=1.8",
+    "ruff>=0.4.0",
+]
+
+[project.scripts]
+fluency-cad = "fluency.main:main"
+
+[project.urls]
+Homepage = "https://github.com/fluency-cad/fluency"
+Documentation = "https://github.com/fluency-cad/fluency#readme"
+Repository = "https://github.com/fluency-cad/fluency"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+fluency = ["py.typed", "*.pyi"]
+
+[tool.black]
+line-length = 100
+target-version = ["py310", "py311", "py312"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true

requirements.txt

@@ -1,61 +0,0 @@
-asttokens==3.0.0
-attrs==25.3.0
-black==24.10.0
-click==8.2.1
-contourpy==1.3.2
-cycler==0.12.1
-decorator==5.2.1
-executing==2.2.0
-flexcache==0.3
-flexparser==0.4
-fonttools==4.58.1
-h5py==3.13.0
-imageio==2.37.0
-ipython==9.3.0
-ipython_pygments_lexers==1.1.1
-jedi==0.19.2
-kiwisolver==1.4.8
-lazy_loader==0.4
-markdown-it-py==3.0.0
-matplotlib==3.10.3
-matplotlib-inline==0.1.7
-mdurl==0.1.2
-meshio==5.3.5
-mypy_extensions==1.1.0
-names==0.3.0
-networkx==3.5
-Nuitka==2.7.10
-numpy==2.2.6
-ordered-set==4.1.0
-packaging==25.0
-parso==0.8.4
-pathspec==0.12.1
-pexpect==4.9.0
-pillow==11.2.1
-Pint==0.24.4
-platformdirs==4.3.8
-prompt_toolkit==3.0.51
-ptyprocess==0.7.0
-pure_eval==0.2.3
-Pygments==2.19.1
-pyparsing==3.2.3
-PySide6==6.9.0
-PySide6_Addons==6.9.0
-PySide6_Essentials==6.9.0
-python-dateutil==2.9.0.post0
-python_solvespace==3.0.8
-rich==13.9.4
-scikit-image==0.25.2
-scipy==1.15.3
-sdfcad @ git+https://gitlab.com/nobodyinperson/sdfCAD@42505b5181c88dda2fd66ac9d387533fbe4145f3
-shiboken6==6.9.0
-six==1.17.0
-stack-data==0.6.3
-tifffile==2025.5.26
-tokenize_rt==6.2.0
-traitlets==5.14.3
-typing_extensions==4.13.2
-vtk==9.4.2
-wcwidth==0.2.13
-xlrd==2.0.2
-zstandard==0.23.0

sdf/__init__.py

@@ -1,26 +0,0 @@
-from . import d2, d3, ease
-
-from .util import *
-from .units import units
-
-from .d2 import *
-
-from .d3 import *
-
-from .text import (
-    measure_image,
-    measure_text,
-    image,
-    text,
-)
-
-from .mesh import (
-    generate,
-    save,
-    sample_slice,
-    show_slice,
-)
-
-from .stl import (
-    write_binary_stl,
-)

sdf/d2.py

@@ -1,390 +0,0 @@
-import functools
-import numpy as np
-import operator
-import copy
-
-from . import dn, d3, ease
-
-# Constants
-
-ORIGIN = np.array((0, 0))
-
-X = np.array((1, 0))
-Y = np.array((0, 1))
-
-UP = Y
-
-# SDF Class
-
-_ops = {}
-
-
-class SDF2:
-    def __init__(self, f):
-        self.f = f
-
-    def __call__(self, p):
-        return self.f(p).reshape((-1, 1))
-
-    def __getattr__(self, name):
-        if name in _ops:
-            f = _ops[name]
-            return functools.partial(f, self)
-        raise AttributeError
-
-    def __or__(self, other):
-        return union(self, other)
-
-    def __and__(self, other):
-        return intersection(self, other)
-
-    def __sub__(self, other):
-        return difference(self, other)
-
-    def fillet(self, r):
-        newSelf = copy.deepcopy(self)
-        newSelf._r = r
-        return newSelf
-
-    def radius(self, *args, **kwargs):
-        return self.fillet(*args, **kwargs)
-
-    def k(self, *args, **kwargs):
-        return self.fillet(*args, **kwargs)
-
-    def r(self, *args, **kwargs):
-        return self.fillet(*args, **kwargs)
-
-    def chamfer(self, c):
-        newSelf = copy.deepcopy(self)
-        newSelf._c = c
-        return newSelf
-
-    def c(self, *args, **kwargs):
-        return self.chamfer(*args, **kwargs)
-
-
-def sdf2(f):
-    @functools.wraps(f)
-    def wrapper(*args, **kwargs):
-        return SDF2(f(*args, **kwargs))
-
-    return wrapper
-
-
-def op2(f):
-    @functools.wraps(f)
-    def wrapper(*args, **kwargs):
-        return SDF2(f(*args, **kwargs))
-
-    _ops[f.__name__] = wrapper
-    return wrapper
-
-
-def op23(f):
-    @functools.wraps(f)
-    def wrapper(*args, **kwargs):
-        return d3.SDF3(f(*args, **kwargs))
-
-    _ops[f.__name__] = wrapper
-    return wrapper
-
-
-# Helpers
-
-
-def _length(a):
-    return np.linalg.norm(a, axis=1)
-
-
-def _normalize(a):
-    return a / np.linalg.norm(a)
-
-
-def _dot(a, b):
-    return np.sum(a * b, axis=1)
-
-
-def _vec(*arrs):
-    return np.stack(arrs, axis=-1)
-
-
-_min = np.minimum
-_max = np.maximum
-
-# Primitives
-
-
-@sdf2
-def circle(radius=None, diameter=None, center=ORIGIN):
-    if (radius is not None) == (diameter is not None):
-        raise ValueError(f"Specify either radius or diameter")
-    if radius is None:
-        radius = diameter / 2
-
-    def f(p):
-        return _length(p - center) - radius
-
-    return f
-
-
-@sdf2
-def line(normal=UP, point=ORIGIN):
-    normal = _normalize(normal)
-
-    def f(p):
-        return np.dot(point - p, normal)
-
-    return f
-
-
-@sdf2
-def slab(x0=None, y0=None, x1=None, y1=None, r=None):
-    fs = []
-    if x0 is not None:
-        fs.append(line(X, (x0, 0)))
-    if x1 is not None:
-        fs.append(line(-X, (x1, 0)))
-    if y0 is not None:
-        fs.append(line(Y, (0, y0)))
-    if y1 is not None:
-        fs.append(line(-Y, (0, y1)))
-    return intersection(*fs, r=r)
-
-
-@sdf2
-def rectangle(size=1, center=ORIGIN, a=None, b=None):
-    if a is not None and b is not None:
-        a = np.array(a)
-        b = np.array(b)
-        size = b - a
-        center = a + size / 2
-        return rectangle(size, center)
-    size = np.array(size)
-
-    def f(p):
-        q = np.abs(p - center) - size / 2
-        return _length(_max(q, 0)) + _min(np.amax(q, axis=1), 0)
-
-    return f
-
-
-@sdf2
-def rounded_rectangle(size, radius, center=ORIGIN):
-    try:
-        r0, r1, r2, r3 = radius
-    except TypeError:
-        r0 = r1 = r2 = r3 = radius
-
-    def f(p):
-        x = p[:, 0]
-        y = p[:, 1]
-        r = np.zeros(len(p)).reshape((-1, 1))
-        r[np.logical_and(x > 0, y > 0)] = r0
-        r[np.logical_and(x > 0, y <= 0)] = r1
-        r[np.logical_and(x <= 0, y <= 0)] = r2
-        r[np.logical_and(x <= 0, y > 0)] = r3
-        q = np.abs(p) - size / 2 + r
-        return (
-            _min(_max(q[:, 0], q[:, 1]), 0).reshape((-1, 1))
-            + _length(_max(q, 0)).reshape((-1, 1))
-            - r
-        )
-
-    return f
-
-
-@sdf2
-def equilateral_triangle():
-    def f(p):
-        k = 3**0.5
-        p = _vec(np.abs(p[:, 0]) - 1, p[:, 1] + 1 / k)
-        w = p[:, 0] + k * p[:, 1] > 0
-        q = _vec(p[:, 0] - k * p[:, 1], -k * p[:, 0] - p[:, 1]) / 2
-        p = np.where(w.reshape((-1, 1)), q, p)
-        p = _vec(p[:, 0] - np.clip(p[:, 0], -2, 0), p[:, 1])
-        return -_length(p) * np.sign(p[:, 1])
-
-    return f
-
-
-@sdf2
-def hexagon(radius=None, diameter=None):
-    if (radius is not None) == (diameter is not None):
-        raise ValueError(f"Specify either radius or diameter")
-    if radius is None:
-        radius = diameter / 2
-    radius *= 3**0.5 / 2
-
-    def f(p):
-        k = np.array((3**0.5 / -2, 0.5, np.tan(np.pi / 6)))
-        p = np.abs(p)
-        p -= 2 * k[:2] * _min(_dot(k[:2], p), 0).reshape((-1, 1))
-        p -= _vec(
-            np.clip(p[:, 0], -k[2] * radius, k[2] * radius), np.zeros(len(p)) + radius
-        )
-        return _length(p) * np.sign(p[:, 1])
-
-    return f
-
-
-@sdf2
-def rounded_x(w, r):
-    def f(p):
-        p = np.abs(p)
-        q = (_min(p[:, 0] + p[:, 1], w) * 0.5).reshape((-1, 1))
-        return _length(p - q) - r
-
-    return f
-
-
-def RegularPolygon(n, r=1):
-    ri = r * np.cos(np.pi / n)
-    return intersection(
-        *[slab(y0=-ri).rotate(a) for a in np.arange(0, 2 * np.pi, 2 * np.pi / n)]
-    )
-
-
-@sdf2
-def polygon(points):
-    points = [np.array(p) for p in points]
-
-    def f(p):
-        n = len(points)
-        d = _dot(p - points[0], p - points[0])
-        s = np.ones(len(p))
-        for i in range(n):
-            j = (i + n - 1) % n
-            vi = points[i]
-            vj = points[j]
-            e = vj - vi
-            w = p - vi
-            b = w - e * np.clip(np.dot(w, e) / np.dot(e, e), 0, 1).reshape((-1, 1))
-            d = _min(d, _dot(b, b))
-            c1 = p[:, 1] >= vi[1]
-            c2 = p[:, 1] < vj[1]
-            c3 = e[0] * w[:, 1] > e[1] * w[:, 0]
-            c = _vec(c1, c2, c3)
-            s = np.where(np.all(c, axis=1) | np.all(~c, axis=1), -s, s)
-        return s * np.sqrt(d)
-
-    return f
-
-
-# Positioning
-
-
-@op2
-def translate(other, offset):
-    def f(p):
-        return other(p - offset)
-
-    return f
-
-
-@op2
-def scale(other, factor):
-    try:
-        x, y = factor
-    except TypeError:
-        x = y = factor
-    s = (x, y)
-    m = min(x, y)
-
-    def f(p):
-        return other(p / s) * m
-
-    return f
-
-
-@op2
-def rotate(other, angle):
-    s = np.sin(angle)
-    c = np.cos(angle)
-    m = 1 - c
-    matrix = np.array(
-        [
-            [c, -s],
-            [s, c],
-        ]
-    ).T
-
-    def f(p):
-        return other(np.dot(p, matrix))
-
-    return f
-
-
-@op2
-def circular_array(other, count):
-    angles = [i / count * 2 * np.pi for i in range(count)]
-    return union(*[other.rotate(a) for a in angles])
-
-
-# Alterations
-
-
-@op2
-def elongate(other, size):
-    def f(p):
-        q = np.abs(p) - size
-        x = q[:, 0].reshape((-1, 1))
-        y = q[:, 1].reshape((-1, 1))
-        w = _min(_max(x, y), 0)
-        return other(_max(q, 0)) + w
-
-    return f
-
-
-# 2D => 3D Operations
-
-
-@op23
-def extrude(other, h=np.inf):
-    def f(p):
-        d = other(p[:, [0, 1]])
-        w = _vec(d.reshape(-1), np.abs(p[:, 2]) - h / 2)
-        return _min(_max(w[:, 0], w[:, 1]), 0) + _length(_max(w, 0))
-
-    return f
-
-
-@op23
-def extrude_to(a, b, h, e=ease.linear):
-    def f(p):
-        d1 = a(p[:, [0, 1]])
-        d2 = b(p[:, [0, 1]])
-        t = e(np.clip(p[:, 2] / h, -0.5, 0.5) + 0.5)
-        d = d1 + (d2 - d1) * t.reshape((-1, 1))
-        w = _vec(d.reshape(-1), np.abs(p[:, 2]) - h / 2)
-        return _min(_max(w[:, 0], w[:, 1]), 0) + _length(_max(w, 0))
-
-    return f
-
-
-@op23
-def revolve(other, offset=0):
-    def f(p):
-        xy = p[:, [0, 1]]
-        # use horizontal distance to Z axis as X coordinate in 2D shape
-        # use Z coordinate as Y coordinate in 2D shape
-        q = _vec(_length(xy) - offset, p[:, 2])
-        return other(q)
-
-    return f
-
-
-# Common
-
-union = op2(dn.union)
-difference = op2(dn.difference)
-intersection = op2(dn.intersection)
-blend = op2(dn.blend)
-negate = op2(dn.negate)
-dilate = op2(dn.dilate)
-erode = op2(dn.erode)
-shell = op2(dn.shell)
-repeat = op2(dn.repeat)
-mirror = op2(dn.mirror)
-modulate_between = op2(dn.modulate_between)
-stretch = op2(dn.stretch)

sdf/dn.py

@@ -1,366 +0,0 @@
-import itertools
-from functools import reduce, partial
-import warnings
-
-from . import ease
-
-import numpy as np
-
-_min = np.minimum
-_max = np.maximum
-
-
-def distance_to_plane(p, origin, normal):
-    """
-    Calculate the distance of a point ``p`` to the plane around ``origin`` with
-    normal ``normal``. This is dimension-independent, so e.g. the z-coordinate
-    can be omitted.
-
-    Args:
-        p (array): either [x,y,z] or [[x,y,z],[x,y,z],...]
-        origin (vector): a point on the plane
-        normal (vector): normal vector of the plane
-
-    Returns:
-        int: distance to plane
-    """
-    normal = normal / np.linalg.norm(normal)
-    return abs((p - origin) @ normal)
-
-
-def minimum(a, b, r=0):
-    if r:
-        Δ = b - a
-        h = np.clip(0.5 + 0.5 * Δ / r, 0, 1)
-        return b - Δ * h - r * h * (1 - h)
-    else:
-        return np.minimum(a, b)
-
-
-def maximum(a, b, r=0):
-    if r:
-        Δ = b - a
-        h = np.clip(0.5 - 0.5 * Δ / r, 0, 1)
-        return b - Δ * h + r * h * (1 - h)
-    else:
-        return np.maximum(a, b)
-
-
-def union(*sdfs, chamfer=0, c=0, radius=0, r=0, fillet=0, f=0):
-    c = max(chamfer, c)
-    r = max(radius, r, fillet, f)
-    sqrt05 = np.sqrt(0.5)
-
-    def f(p):
-        sdfs_ = iter(sdfs)
-        d1 = next(sdfs_)(p)
-        for sdf in sdfs_:
-            d2 = sdf(p)
-            R = r or getattr(sdf, "_r", 0)
-            C = c or getattr(sdf, "_c", 0)
-            parts = (d1, d2)
-            if C:
-                parts = (minimum(d1, d2), (d1 + d2 - C) * sqrt05)
-            d1 = minimum(*parts, R)
-
-        return d1
-
-    return f
-
-
-def intersection(*sdfs, chamfer=0, c=0, radius=0, r=0, fillet=0, f=0):
-    c = max(chamfer, c)
-    r = max(radius, r, fillet, f)
-    sqrt05 = np.sqrt(0.5)
-
-    def f(p):
-        sdfs_ = iter(sdfs)
-        d1 = next(sdfs_)(p)
-        for sdf in sdfs_:
-            d2 = sdf(p)
-            R = r or getattr(sdf, "_r", 0)
-            C = c or getattr(sdf, "_c", 0)
-            parts = (d1, d2)
-            if C:
-                parts = (maximum(d1, d2), (d1 + d2 + C) * sqrt05)
-            d1 = maximum(*parts, R)
-
-        return d1
-
-    return f
-
-
-def difference(*sdfs, chamfer=0, c=0, radius=0, r=0, fillet=0, f=0):
-    c = max(chamfer, c)
-    r = max(radius, r, fillet, f)
-    sqrt05 = np.sqrt(0.5)
-
-    def f(p):
-        sdfs_ = iter(sdfs)
-        d1 = next(sdfs_)(p)
-        for sdf in sdfs_:
-            d2 = sdf(p)
-            R = r or getattr(sdf, "_r", 0)
-            C = c or getattr(sdf, "_c", 0)
-            parts = (d1, -d2)
-            if C:
-                parts = (maximum(d1, -d2), (d1 - d2 + C) * sqrt05)
-            d1 = maximum(*parts, R)
-
-        return d1
-
-    return f
-
-
-def union_legacy(a, *bs, r=None):
-    def f(p):
-        d1 = a(p)
-        for b in bs:
-            d2 = b(p)
-            K = k or getattr(b, "_r", None)
-            if K is None:
-                d1 = _min(d1, d2)
-            else:
-                h = np.clip(0.5 + 0.5 * (d2 - d1) / K, 0, 1)
-                m = d2 + (d1 - d2) * h
-                d1 = m - K * h * (1 - h)
-        return d1
-
-    return f
-
-
-def difference_legacy(a, *bs, r=None):
-    def f(p):
-        d1 = a(p)
-        for b in bs:
-            d2 = b(p)
-            K = k or getattr(b, "_r", None)
-            if K is None:
-                d1 = _max(d1, -d2)
-            else:
-                h = np.clip(0.5 - 0.5 * (d2 + d1) / K, 0, 1)
-                m = d1 + (-d2 - d1) * h
-                d1 = m + K * h * (1 - h)
-        return d1
-
-    return f
-
-
-def intersection_legacy(a, *bs, r=None):
-    def f(p):
-        d1 = a(p)
-        for b in bs:
-            d2 = b(p)
-            K = k or getattr(b, "_r", None)
-            if K is None:
-                d1 = _max(d1, d2)
-            else:
-                h = np.clip(0.5 - 0.5 * (d2 - d1) / K, 0, 1)
-                m = d2 + (d1 - d2) * h
-                d1 = m + K * h * (1 - h)
-        return d1
-
-    return f
-
-
-def blend(a, *bs, r=0.5):
-    def f(p):
-        d1 = a(p)
-        for b in bs:
-            d2 = b(p)
-            K = k or getattr(b, "_r", None)
-            d1 = K * d2 + (1 - K) * d1
-        return d1
-
-    return f
-
-
-def negate(other):
-    def f(p):
-        return -other(p)
-
-    return f
-
-
-def dilate(other, r):
-    def f(p):
-        return other(p) - r
-
-    return f
-
-
-def erode(other, r):
-    def f(p):
-        return other(p) + r
-
-    return f
-
-
-def shell(other, thickness=1, type="center"):
-    """
-    Keep only a margin of a given thickness around the object's boundary.
-
-    Args:
-        thickness (float): the resulting thickness
-        type (str): what kind of shell to generate.
-
-            ``"center"`` (default)
-                shell is spaced symmetrically around boundary
-            ``"outer"``
-                the resulting shell will be ``thickness`` larger than before
-            ``"inner"``
-                the resulting shell will be as large as before
-    """
-    return dict(
-        center=lambda p: np.abs(other(p)) - thickness / 2,
-        inner=other - other.erode(thickness),
-        outer=other.dilate(thickness) - other,
-    )[type]
-
-
-def modulate_between(sdf, a, b, e=ease.in_out_cubic):
-    """
-    Apply a distance offset transition between two control points
-    (e.g. make a rod thicker or thinner at some point or add a bump)
-
-    Args:
-        a, b (vectors): the two control points
-        e (scalar function): the distance offset function, will be called with
-            values between 0 (at control point ``a``) and 1 (at control point
-            ``b``).  Its result will be subtracted from the given SDF, thus
-            enlarging the object by that value.
-    """
-
-    # unit vector from control point a to b
-    ab = (ab := b - a) / (L := np.linalg.norm(ab))
-
-    def f(p):
-        # project current point onto control direction, clip and apply easing
-        offset = e(np.clip((p - a) @ ab / L, 0, 1))
-        return (dist := sdf(p)) - offset.reshape(dist.shape)
-
-    return f
-
-
-def stretch(sdf, a, b, symmetric=False, e=ease.linear):
-    """
-    Grab the object at point ``a`` and stretch the entire plane to ``b``.
-
-    Args:
-        a, b (point vectors): the control points
-        symmetric (bool): also stretch the same into the other direction.
-        e (Easing): easing to apply
-
-    Examples
-    ========
-
-    .. code-block:: python
-
-        # make a capsule
-        sphere(5).stretch(ORIGIN, 10*Z).save() # same as capsule(ORIGIN, 10*Z, 5)
-        # make an egg
-        sphere(5).stretch(ORIGIN, 10*Z, e=ease.smoothstep[:0.44]).save()
-    """
-    ab = (ab := b - a) / (L := np.linalg.norm(ab))
-
-    def f(p):
-        # s = ”how far are we between a and b as fraction?”
-        # if symmetric=True this also goes into the negative direction
-        s = np.clip((p - a) @ ab / L, -1 if symmetric else 0, 1)
-        # we return the sdf at a point 'behind' (p minus ...)
-        # the current point, but we go only as far back as the stretch distance
-        # at max
-        return sdf(p - (np.sign(s) * e(abs(s)) * L * ab[:, np.newaxis]).T)
-
-    return f
-
-
-def shear(sdf, fix, grab, move, e=ease.linear):
-    """
-    Grab the object at point ``grab`` and shear the entire plane in direction
-    ``move``, keeping point ``fix`` in place. If ``move`` is orthogonal to the
-    direction ``fix``->``grab``, then this operation is a shear.
-
-    Args:
-        fix, grab (point vectors): the control points
-        move (point vector): direction to shear to
-        e (Easing): easing to apply
-
-    Examples
-    ========
-
-    .. code-block:: python
-
-        # make a capsule
-        box([20,10,50]).shear(fix=-15*Z, grab=15*Z, move=-5*X, e=ease.smoothstep)
-    """
-    ab = (ab := grab - fix) / (L := np.linalg.norm(ab))
-
-    def f(p):
-        # s = ”how far are we between a and b as fraction?”
-        s = (p - fix) @ ab / L
-        return sdf(p - move * np.expand_dims(e(np.clip(s, 0, 1)), axis=1))
-
-    return f
-
-
-def mirror(other, direction, at=0):
-    """
-    Mirror around a given plane defined by ``origin`` reference point and
-    ``direction``.
-
-    Args:
-        direction (vector): direction to mirror to (e.g. :any:`X` to mirror along X axis)
-        at (3D vector): point to mirror at. Default is the origin.
-    """
-    direction = direction / np.linalg.norm(direction)
-
-    def f(p):
-        projdir = np.expand_dims((p - at) @ direction, axis=1) * direction
-        # mirrored point:
-        # - project 'p' onto 'direction' (result goes into 'projdir' direction)
-        # - projected point is at   'at + projdir'
-        # - remember direction from projected point to the original point (p - (at + projdir))
-        # - from origin 'at' go backwards the projected direction (at - projdir)
-        # - from that target, move along the remembered direction (p - (at + projdir))
-        # - pmirr = at - projdir + (p - (at + projdir))
-        # - the 'at' cancels out, the projdir is subtracted twice from the point
-        return other(p - 2 * projdir)
-
-    return f
-
-
-def repeat(other, spacing, count=None, padding=0):
-    count = np.array(count) if count is not None else None
-    spacing = np.array(spacing)
-
-    def neighbors(dim, padding, spacing):
-        try:
-            padding = [padding[i] for i in range(dim)]
-        except Exception:
-            padding = [padding] * dim
-        try:
-            spacing = [spacing[i] for i in range(dim)]
-        except Exception:
-            spacing = [spacing] * dim
-        for i, s in enumerate(spacing):
-            if s == 0:
-                padding[i] = 0
-        axes = [list(range(-p, p + 1)) for p in padding]
-        return list(itertools.product(*axes))
-
-    def f(p):
-        q = np.divide(p, spacing, out=np.zeros_like(p), where=spacing != 0)
-        if count is None:
-            index = np.round(q)
-        else:
-            index = np.clip(np.round(q), -count, count)
-
-        indexes = [index + n for n in neighbors(p.shape[-1], padding, spacing)]
-        A = [other(p - spacing * i) for i in indexes]
-        a = A[0]
-        for b in A[1:]:
-            a = _min(a, b)
-        return a
-
-    return f

sdf/ease.py

@@ -1,637 +0,0 @@
-# system modules
-from dataclasses import dataclass
-from typing import Callable
-import itertools
-import functools
-import warnings
-
-# external modules
-import numpy as np
-import scipy.optimize
-
-
-@dataclass
-@functools.total_ordering
-class Extremum:
-    """
-    Container for min and max in Easing
-    """
-
-    pos: float
-    value: float
-
-    def __eq__(self, other):
-        return self.value == other.value
-
-    def __lt__(self, other):
-        return self.value < other.value
-
-
-@dataclass
-@functools.total_ordering
-class Easing:
-    """
-    A function defined on the interval [0;1]
-    """
-
-    f: Callable[float, float]
-    name: str
-
-    def modifier(decorated_fun):
-        @functools.wraps(decorated_fun)
-        def wrapper(self, *args, **kwargs):
-            newfun = decorated_fun(self, *args, **kwargs)
-            arglist = ",".join(
-                itertools.chain(map(str, args), (f"{k}={v}" for k, v in kwargs.items()))
-            )
-            newfun.__name__ = f"{self.f.__name__}.{decorated_fun.__name__}({arglist})"
-            return type(self)(f=newfun, name=newfun.__name__)
-
-        return wrapper
-
-    def __repr__(self):
-        return self.name
-
-    def __str__(self):
-        return self.name
-
-    @functools.cached_property
-    def is_ascending(self):
-        return np.all(np.diff(self.f(np.linspace(0, 1, 100))) >= 0)
-
-    @functools.cached_property
-    def is_symmetric(self):
-        t = np.linspace(0, 0.5, 100)
-        return np.allclose(self.f(t), self.f(1 - t))
-
-    @property
-    @modifier
-    def reverse(self):
-        """
-        Revert the function so it goes the other way round (starts at the end)
-        """
-        return lambda t: self.f(1 - t)
-
-    @property
-    @modifier
-    def symmetric(self):
-        """
-        Mirror and squash function to make it symmetric
-        """
-        return lambda t: self.f(-2 * (np.abs(t - 0.5) - 0.5))
-
-    @modifier
-    def mirror(self, x=None, y=None, copy=False):
-        """
-        Mirror function around an x and/or y value.
-
-        Args:
-            x (float): x value to mirror around
-            y (float): y value to mirror around
-            copy (bool): when mirroring around x, do copy-mirror
-        """
-        if (x, y) == (None, None):
-            x = 0.5
-
-        def mirrored(t):
-            if x is not None:
-                t = 2 * x - t
-            if copy:
-                t = np.abs(-t)
-            if y is None:
-                return self.f(t)
-            else:
-                return y - self.f(t)
-
-        return mirrored
-
-    @modifier
-    def clip(self, min=None, max=None):
-        """
-        Clip function at low and/or high values
-        """
-        if min is None and max is None:
-            min = 0
-            max = 1
-        return lambda t: np.clip(self.f(t), min, max)
-
-    @modifier
-    def clip_input(self, min=None, max=None):
-        """
-        Clip input parameter, i.e. extrapolate constantly outside the interval.
-        """
-        if min is None and max is None:
-            min = 0
-            max = 1
-        return lambda t: self.f(np.clip(t, min, max))
-
-    @property
-    @modifier
-    def clipped(self):
-        """
-        Clipped parameter and result to [0;1]
-        """
-        return lambda t: np.clip(self(np.clip(t, 0, 1)), 0, 1)
-
-    @modifier
-    def append(self, other, e=None):
-        """
-        Append another easing function and squish both into the [0;1] interval
-        """
-        if e is None:
-            e = in_out_square
-
-        def f(t):
-            mix = e(t)
-            return self.f(t * 2) * (1 - mix) + other((t - 0.5) * 2) * mix
-
-        return f
-
-    @modifier
-    def prepend(self, other, e=None):
-        """
-        Prepend another easing function and squish both into the [0;1] interval
-        """
-        if e is None:
-            e = in_out_square
-
-        def f(t):
-            mix = e(t)
-            return other(t * 2) * (1 - mix) + self.f((t - 0.5) * 2) * mix
-
-        return f
-
-    @modifier
-    def shift(self, offset):
-        """
-        Shift function on x-axis into positive direction by ``offset``.
-        """
-        return lambda t: self.f(t - offset)
-
-    @modifier
-    def repeat(self, n=2):
-        """
-        Repeat the function a total of n times in the interval [0;1].
-        """
-        return lambda t: self.f(t % (1 / n) * n)
-
-    @modifier
-    def multiply(self, factor):
-        """
-        Scale function by ``factor``
-        """
-        if isinstance(factor, Easing):
-            return lambda t: self(t) * factor(t)
-        else:
-            return lambda t: factor * self.f(t)
-
-    @modifier
-    def add(self, offset):
-        """
-        Add ``offset`` to function
-        """
-        if isinstance(offset, Easing):
-            return lambda t: self(t) + offset(t)
-        else:
-            return lambda t: self.f(t) + offset
-
-    def __add__(self, offset):
-        return self.add(offset)
-
-    def __radd__(self, offset):
-        return self.add(offset)
-
-    def __sub__(self, offset):
-        return self.add(-offset)
-
-    def __rsub__(self, offset):
-        return self.add(-offset)
-
-    def __mul__(self, factor):
-        return self.multiply(factor)
-
-    def __rmul__(self, factor):
-        return self.multiply(factor)
-
-    def __neg__(self):
-        return self.multiply(-1)
-
-    def __truediv__(self, factor):
-        return self.multiply(1 / factor)
-
-    def __or__(self, other):
-        return self.transition(other)
-
-    def __rshift__(self, offset):
-        return self.shift(offset)
-
-    def __lshift__(self, offset):
-        return self.shift(-offset)
-
-    def __getitem__(self, index):
-        if isinstance(index, Easing):
-            return self.chain(index)
-        if isinstance(index, slice):
-            return self.zoom(
-                0 if index.start is None else index.start,
-                1 if index.stop is None else index.stop,
-            )
-        else:
-            raise ValueError(
-                f"{index = } has to be slice of floats or an easing function"
-            )
-
-    @modifier
-    def chain(self, f=None):
-        """
-        Feed parameter through the given function before evaluating this function.
-        """
-        if f is None:
-            f = self.f
-        return lambda t: self.f(f(t))
-
-    @modifier
-    def zoom(self, left, right=None):
-        """
-        Arrange so that the interval [left;right] is moved into [0;1]
-        If only one argument is given, zoom in/out by moving edges that far.
-        """
-        if left is not None and right is None:
-            if left >= 0.5:
-                raise ValueError(
-                    f"{left = } is > 0.5 which doesn't make sense (bounds would cross)"
-                )
-            left = left
-            right = 1 - left
-        if left >= right:
-            raise ValueError(f"{right = } bound must be greater than {left = }")
-        return self.chain(linear.between(left, right)).f
-
-    @modifier
-    def between(self, left=0, right=1, e=None):
-        """
-        Arrange so ``f(0)==a`` and ``f(1)==b``.
-        """
-        f0, f1 = self.f(np.array([0, 1]))
-        la = f0 - left
-        lb = f1 - right
-        if e is None:  # linear is defined later
-            e = (
-                self  # use ourself as transition when we're ascending within [0;1]
-                if (self.is_ascending and np.allclose(self.f(np.array([0, 1])), [0, 1]))
-                else linear
-            )
-
-        def f(t):
-            t_ = e(t)
-            return self.f(t_) - (la * (1 - t_)) - lb * t_
-
-        return f
-
-    @modifier
-    def transition(self, other, e=None):
-        """
-        Transiton from one easing to another
-        """
-        if e is None:
-            e = linear
-
-        def f(t):
-            t_ = e(t)
-            return self.f(t) * (1 - t_) + other(t) * t_
-
-        return f
-
-    @classmethod
-    def function(cls, decorated_fun):
-        return cls(f=decorated_fun, name=decorated_fun.__name__)
-
-    def plot(self, *others, xlim=(0, 1), ax=None):
-        import matplotlib.pyplot as plt  # lazy import for speed
-        from cycler import cycler
-
-        if ax is None:
-            fig, ax_ = plt.subplots()
-        else:
-            ax_ = ax
-
-        try:
-            ax_.set_prop_cycle(
-                cycler(linestyle=["solid", "dashed", "dotted"], linewidth=[1, 1, 2])
-                * plt.rcParams["axes.prop_cycle"]
-            )
-        except ValueError as e:
-            pass
-
-        t = np.linspace(*xlim, 1000)
-        funs = list(others or [])
-        if isinstance(self, Easing):
-            funs.insert(0, self)
-        for f in funs:
-            ax_.plot(t, f(t), label=getattr(f, "name", getattr(f, "__name__", str(f))))
-        ax_.legend(ncol=int(np.ceil(len(ax_.get_lines()) / 10)))
-        if ax is None:
-            plt.show()
-        return ax_
-
-    @functools.cached_property
-    def min(self):
-        v = self.f(t := np.linspace(0, 1, 1000))
-        approxmin = Extremum(pos=t[i := np.argmin(v)], value=v[i])
-        opt = scipy.optimize.minimize(self, x0=[approxmin.pos], bounds=[(0, 1)])
-        optmin = Extremum(pos=opt.x[0], value=opt.fun)
-        return min(approxmin, optmin)
-
-    @functools.cached_property
-    def max(self):
-        """
-        Determine the maximum value
-        """
-        v = self.f(t := np.linspace(0, 1, 1000))
-        approxmax = Extremum(pos=t[i := np.argmax(v)], value=v[i])
-        opt = scipy.optimize.minimize(-self, x0=[approxmax.pos], bounds=[(0, 1)])
-        optmax = Extremum(pos=opt.x[0], value=-opt.fun)
-        return max(approxmax, optmax)
-
-    @functools.cached_property
-    def mean(self):
-        return np.mean(self.f(np.linspace(0, 1, 1000)))
-
-    def __lt__(self, e):
-        return np.all(self.f(t := np.linspace(0, 1, 50)) < e.f(t))
-
-    def __eq__(self, e):
-        return np.allclose(self.f(t := np.linspace(0, 1, 50)), e.f(t))
-
-    def __call__(self, t):
-        return self.f(t)
-
-
-@Easing.function
-def linear(t):
-    return t
-
-
-@Easing.function
-def in_quad(t):
-    return t * t
-
-
-@Easing.function
-def out_quad(t):
-    return -t * (t - 2)
-
-
-@Easing.function
-def in_out_quad(t):
-    u = 2 * t - 1
-    a = 2 * t * t
-    b = -0.5 * (u * (u - 2) - 1)
-    return np.where(t < 0.5, a, b)
-
-
-@Easing.function
-def in_cubic(t):
-    return t * t * t
-
-
-@Easing.function
-def out_cubic(t):
-    u = t - 1
-    return u * u * u + 1
-
-
-@Easing.function
-def in_out_cubic(t):
-    u = t * 2
-    v = u - 2
-    a = 0.5 * u * u * u
-    b = 0.5 * (v * v * v + 2)
-    return np.where(u < 1, a, b)
-
-
-@Easing.function
-def in_quart(t):
-    return t * t * t * t
-
-
-@Easing.function
-def out_quart(t):
-    u = t - 1
-    return -(u * u * u * u - 1)
-
-
-@Easing.function
-def in_out_quart(t):
-    u = t * 2
-    v = u - 2
-    a = 0.5 * u * u * u * u
-    b = -0.5 * (v * v * v * v - 2)
-    return np.where(u < 1, a, b)
-
-
-@Easing.function
-def in_quint(t):
-    return t * t * t * t * t
-
-
-@Easing.function
-def out_quint(t):
-    u = t - 1
-    return u * u * u * u * u + 1
-
-
-@Easing.function
-def in_out_quint(t):
-    u = t * 2
-    v = u - 2
-    a = 0.5 * u * u * u * u * u
-    b = 0.5 * (v * v * v * v * v + 2)
-    return np.where(u < 1, a, b)
-
-
-@Easing.function
-def in_sine(t):
-    return -np.cos(t * np.pi / 2) + 1
-
-
-@Easing.function
-def out_sine(t):
-    return np.sin(t * np.pi / 2)
-
-
-@Easing.function
-def in_out_sine(t):
-    return -0.5 * (np.cos(np.pi * t) - 1)
-
-
-@Easing.function
-def in_expo(t):
-    a = np.zeros(len(t))
-    b = 2 ** (10 * (t - 1))
-    return np.where(t == 0, a, b)
-
-
-@Easing.function
-def out_expo(t):
-    a = np.zeros(len(t)) + 1
-    b = 1 - 2 ** (-10 * t)
-    return np.where(t == 1, a, b)
-
-
-@Easing.function
-def in_out_expo(t):
-    zero = np.zeros(len(t))
-    one = zero + 1
-    a = 0.5 * 2 ** (20 * t - 10)
-    b = 1 - 0.5 * 2 ** (-20 * t + 10)
-    return np.where(t == 0, zero, np.where(t == 1, one, np.where(t < 0.5, a, b)))
-
-
-@Easing.function
-def in_circ(t):
-    return -1 * (np.sqrt(1 - t * t) - 1)
-
-
-@Easing.function
-def out_circ(t):
-    u = t - 1
-    return np.sqrt(1 - u * u)
-
-
-@Easing.function
-def in_out_circ(t):
-    u = t * 2
-    v = u - 2
-    a = -0.5 * (np.sqrt(1 - u * u) - 1)
-    b = 0.5 * (np.sqrt(1 - v * v) + 1)
-    return np.where(u < 1, a, b)
-
-
-@Easing.function
-def in_elastic(t, k=0.5):
-    u = t - 1
-    return -1 * (2 ** (10.0 * u) * np.sin((u - k / 4) * (2 * np.pi) / k))
-
-
-@Easing.function
-def out_elastic(t, k=0.5):
-    return 2 ** (-10.0 * t) * np.sin((t - k / 4) * (2 * np.pi / k)) + 1
-
-
-@Easing.function
-def in_out_elastic(t, k=0.5):
-    u = t * 2
-    v = u - 1
-    a = -0.5 * (2 ** (10 * v) * np.sin((v - k / 4) * 2 * np.pi / k))
-    b = 2 ** (-10 * v) * np.sin((v - k / 4) * 2 * np.pi / k) * 0.5 + 1
-    return np.where(u < 1, a, b)
-
-
-@Easing.function
-def in_back(t):
-    k = 1.70158
-    return t * t * ((k + 1) * t - k)
-
-
-@Easing.function
-def out_back(t):
-    k = 1.70158
-    u = t - 1
-    return u * u * ((k + 1) * u + k) + 1
-
-
-@Easing.function
-def in_out_back(t):
-    k = 1.70158 * 1.525
-    u = t * 2
-    v = u - 2
-    a = 0.5 * (u * u * ((k + 1) * u - k))
-    b = 0.5 * (v * v * ((k + 1) * v + k) + 2)
-    return np.where(u < 1, a, b)
-
-
-@Easing.function
-def in_bounce(t):
-    return 1 - out_bounce(1 - t)
-
-
-@Easing.function
-def out_bounce(t):
-    a = (121 * t * t) / 16
-    b = (363 / 40 * t * t) - (99 / 10 * t) + 17 / 5
-    c = (4356 / 361 * t * t) - (35442 / 1805 * t) + 16061 / 1805
-    d = (54 / 5 * t * t) - (513 / 25 * t) + 268 / 25
-    return np.where(t < 4 / 11, a, np.where(t < 8 / 11, b, np.where(t < 9 / 10, c, d)))
-
-
-@Easing.function
-def in_out_bounce(t):
-    a = in_bounce(2 * t) * 0.5
-    b = out_bounce(2 * t - 1) * 0.5 + 0.5
-    return np.where(t < 0.5, a, b)
-
-
-@Easing.function
-def in_square(t):
-    return np.heaviside(t - 1, 0)
-
-
-@Easing.function
-def out_square(t):
-    return np.heaviside(t + 1, 0)
-
-
-@Easing.function
-def in_out_square(t):
-    return np.heaviside(t - 0.5, 0)
-
-
-def constant(x):
-    return Easing(f=lambda t: np.full_like(t, x), name=f"constant({x})")
-
-
-zero = constant(0)
-one = constant(1)
-
-
-@Easing.function
-def smoothstep(t):
-    t = np.clip(t, 0, 1)
-    return 3 * t * t - 2 * t * t * t
-
-
-def _main():
-    import matplotlib.pyplot as plt
-    from cycler import cycler
-
-    plt.rcParams["axes.prop_cycle"] *= cycler(
-        linestyle=["solid", "dashed", "dotted"], linewidth=[1, 2, 3]
-    )
-    plt.rcParams["figure.autolayout"] = True
-    plt.rcParams["axes.grid"] = True
-    plt.rcParams["axes.axisbelow"] = True
-    plt.rcParams["legend.fontsize"] = "small"
-    LOCALS = globals()
-    print(f"{LOCALS = }")
-    fig, axes = plt.subplots(nrows=2)
-    Easing.plot(
-        *sorted((obj for n, obj in LOCALS.items() if isinstance(obj, Easing)), key=str),
-        ax=axes[0],
-    )
-    Easing.plot(
-        in_sine.symmetric,
-        in_out_sine.symmetric.multiply(-0.6),
-        linear.symmetric.multiply(-0.7),
-        in_out_sine.multiply(-0.6).symmetric,
-        out_sine.multiply(-0.6).reverse.symmetric.multiply(2),
-        out_bounce.add(-0.5),
-        ax=axes[1],
-    )
-    axes[0].set_title("Standard")
-    axes[1].set_title("Derived")
-    plt.show()
-
-
-if __name__ == "__main__":
-    _main()

sdf/errors.py

@@ -1,42 +0,0 @@
-import warnings
-import functools
-
-
-class SDFCADError(Exception):
-    pass
-
-
-class SDFCADInfiniteObjectError(Exception):
-    """
-    Error raised when an infinite object is encountered where not suitable.
-    """
-
-    pass
-
-
-class SDFCADWarning(Warning):
-    pass
-
-
-class SDFCADAlphaQualityWarning(SDFCADWarning):
-    show = True
-
-
-def alpha_quality(decorated_fun):
-    @functools.wraps(decorated_fun)
-    def wrapper(*args, **kwargs):
-        if SDFCADAlphaQualityWarning.show:
-            warnings.warn(
-                f"{decorated_fun.__name__}() is alpha quality "
-                f"and might give wrong results. Use with care. "
-                f"Hide this warning by setting sdf.errors.SDFCADAlphaQualityWarning.show=False.",
-                SDFCADAlphaQualityWarning,
-            )
-            with warnings.catch_warnings():
-                # Don't reissue nested alpha quality warnings
-                warnings.simplefilter("ignore", SDFCADAlphaQualityWarning)
-                return decorated_fun(*args, **kwargs)
-        else:
-            return decorated_fun(*args, **kwargs)
-
-    return wrapper

sdf/mesh.py

@@ -1,282 +0,0 @@
-from functools import partial
-from multiprocessing.pool import ThreadPool
-from skimage import measure
-
-import multiprocessing
-import itertools
-import numpy as np
-import time
-
-from . import progress, stl
-
-WORKERS = multiprocessing.cpu_count()
-SAMPLES = 2**18
-BATCH_SIZE = 32
-
-
-def _marching_cubes(volume, level=0):
-    verts, faces, _, _ = measure.marching_cubes(volume, level)
-    return verts[faces].reshape((-1, 3))
-
-
-def _cartesian_product(*arrays):
-    la = len(arrays)
-    dtype = np.result_type(*arrays)
-    arr = np.empty([len(a) for a in arrays] + [la], dtype=dtype)
-    for i, a in enumerate(np.ix_(*arrays)):
-        arr[..., i] = a
-    return arr.reshape(-1, la)
-
-
-def _skip(sdf, job):
-    X, Y, Z = job
-    x0, x1 = X[0], X[-1]
-    y0, y1 = Y[0], Y[-1]
-    z0, z1 = Z[0], Z[-1]
-    x = (x0 + x1) / 2
-    y = (y0 + y1) / 2
-    z = (z0 + z1) / 2
-    r = abs(sdf(np.array([(x, y, z)])).reshape(-1)[0])
-    d = np.linalg.norm(np.array((x - x0, y - y0, z - z0)))
-    if r <= d:
-        return False
-    corners = np.array(list(itertools.product((x0, x1), (y0, y1), (z0, z1))))
-    values = sdf(corners).reshape(-1)
-    same = np.all(values > 0) if values[0] > 0 else np.all(values < 0)
-    return same
-
-
-def _worker(sdf, job, sparse):
-    X, Y, Z = job
-    if sparse and _skip(sdf, job):
-        return None
-        # return _debug_triangles(X, Y, Z)
-    P = _cartesian_product(X, Y, Z)
-    volume = sdf(P).reshape((len(X), len(Y), len(Z)))
-    try:
-        points = _marching_cubes(volume)
-    except Exception:
-        return []
-        # return _debug_triangles(X, Y, Z)
-    scale = np.array([X[1] - X[0], Y[1] - Y[0], Z[1] - Z[0]])
-    offset = np.array([X[0], Y[0], Z[0]])
-    return points * scale + offset
-
-
-def _estimate_bounds(sdf):
-    # TODO: raise exception if bound estimation fails
-    s = 16
-    x0 = y0 = z0 = -1e9
-    x1 = y1 = z1 = 1e9
-    prev = None
-    for i in range(32):
-        X = np.linspace(x0, x1, s)
-        Y = np.linspace(y0, y1, s)
-        Z = np.linspace(z0, z1, s)
-        d = np.array([X[1] - X[0], Y[1] - Y[0], Z[1] - Z[0]])
-        threshold = np.linalg.norm(d) / 2
-        if threshold == prev:
-            break
-        prev = threshold
-        P = _cartesian_product(X, Y, Z)
-        volume = sdf(P).reshape((len(X), len(Y), len(Z)))
-        where = np.argwhere(np.abs(volume) <= threshold)
-        x1, y1, z1 = (x0, y0, z0) + where.max(axis=0) * d + d / 2
-        x0, y0, z0 = (x0, y0, z0) + where.min(axis=0) * d - d / 2
-    return ((x0, y0, z0), (x1, y1, z1))
-
-
-def generate(
-    sdf,
-    step=None,
-    bounds=None,
-    samples=SAMPLES,
-    workers=WORKERS,
-    batch_size=BATCH_SIZE,
-    verbose=True,
-    sparse=True,
-):
-    start = time.time()
-
-    if bounds is None:
-        bounds = _estimate_bounds(sdf)
-    (x0, y0, z0), (x1, y1, z1) = bounds
-
-    if step is None and samples is not None:
-        volume = (x1 - x0) * (y1 - y0) * (z1 - z0)
-        step = (volume / samples) ** (1 / 3)
-
-    try:
-        dx, dy, dz = step
-    except TypeError:
-        dx = dy = dz = step
-
-    if verbose:
-        print("min %g, %g, %g" % (x0, y0, z0))
-        print("max %g, %g, %g" % (x1, y1, z1))
-        print("step %g, %g, %g" % (dx, dy, dz))
-
-    X = np.arange(x0, x1, dx)
-    Y = np.arange(y0, y1, dy)
-    Z = np.arange(z0, z1, dz)
-
-    s = batch_size
-    Xs = [X[i : i + s + 1] for i in range(0, len(X), s)]
-    Ys = [Y[i : i + s + 1] for i in range(0, len(Y), s)]
-    Zs = [Z[i : i + s + 1] for i in range(0, len(Z), s)]
-
-    batches = list(itertools.product(Xs, Ys, Zs))
-    num_batches = len(batches)
-    num_samples = sum(len(xs) * len(ys) * len(zs) for xs, ys, zs in batches)
-
-    if verbose:
-        print(
-            "%d samples in %d batches with %d workers"
-            % (num_samples, num_batches, workers)
-        )
-
-    points = []
-    skipped = empty = nonempty = 0
-    bar = progress.Bar(num_batches, enabled=verbose)
-    f = partial(_worker, sdf, sparse=sparse)
-    with ThreadPool(workers) as pool:
-        for result in pool.imap(f, batches):
-            bar.increment(1)
-            if result is None:
-                skipped += 1
-            elif len(result) == 0:
-                empty += 1
-            else:
-                nonempty += 1
-                points.extend(result)
-    bar.done()
-
-    if verbose:
-        print("%d skipped, %d empty, %d nonempty" % (skipped, empty, nonempty))
-        triangles = len(points) // 3
-        seconds = time.time() - start
-        print("%d triangles in %g seconds" % (triangles, seconds))
-
-    return points
-
-
-def save(path, *args, **kwargs):
-    points = generate(*args, **kwargs)
-    if str(path).lower().endswith(".stl"):
-        stl.write_binary_stl(path, points)
-    else:
-        mesh = _mesh(points)
-        mesh.write(path)
-
-
-def _mesh(points):
-    import meshio
-
-    points, cells = np.unique(points, axis=0, return_inverse=True)
-    cells = [("triangle", cells.reshape((-1, 3)))]
-    return meshio.Mesh(points, cells)
-
-
-def _debug_triangles(X, Y, Z):
-    x0, x1 = X[0], X[-1]
-    y0, y1 = Y[0], Y[-1]
-    z0, z1 = Z[0], Z[-1]
-
-    p = 0.25
-    x0, x1 = x0 + (x1 - x0) * p, x1 - (x1 - x0) * p
-    y0, y1 = y0 + (y1 - y0) * p, y1 - (y1 - y0) * p
-    z0, z1 = z0 + (z1 - z0) * p, z1 - (z1 - z0) * p
-
-    v = [
-        (x0, y0, z0),
-        (x0, y0, z1),
-        (x0, y1, z0),
-        (x0, y1, z1),
-        (x1, y0, z0),
-        (x1, y0, z1),
-        (x1, y1, z0),
-        (x1, y1, z1),
-    ]
-
-    return [
-        v[3],
-        v[5],
-        v[7],
-        v[5],
-        v[3],
-        v[1],
-        v[0],
-        v[6],
-        v[4],
-        v[6],
-        v[0],
-        v[2],
-        v[0],
-        v[5],
-        v[1],
-        v[5],
-        v[0],
-        v[4],
-        v[5],
-        v[6],
-        v[7],
-        v[6],
-        v[5],
-        v[4],
-        v[6],
-        v[3],
-        v[7],
-        v[3],
-        v[6],
-        v[2],
-        v[0],
-        v[3],
-        v[2],
-        v[3],
-        v[0],
-        v[1],
-    ]
-
-
-def sample_slice(sdf, w=1024, h=1024, x=None, y=None, z=None, bounds=None):
-    if bounds is None:
-        bounds = _estimate_bounds(sdf)
-    (x0, y0, z0), (x1, y1, z1) = bounds
-
-    if x is not None:
-        X = np.array([x])
-        Y = np.linspace(y0, y1, w)
-        Z = np.linspace(z0, z1, h)
-        extent = (Z[0], Z[-1], Y[0], Y[-1])
-        axes = "ZY"
-    elif y is not None:
-        Y = np.array([y])
-        X = np.linspace(x0, x1, w)
-        Z = np.linspace(z0, z1, h)
-        extent = (Z[0], Z[-1], X[0], X[-1])
-        axes = "ZX"
-    elif z is not None:
-        Z = np.array([z])
-        X = np.linspace(x0, x1, w)
-        Y = np.linspace(y0, y1, h)
-        extent = (Y[0], Y[-1], X[0], X[-1])
-        axes = "YX"
-    else:
-        raise Exception("x, y, or z position must be specified")
-
-    P = _cartesian_product(X, Y, Z)
-    return sdf(P).reshape((w, h)), extent, axes
-
-
-def show_slice(*args, **kwargs):
-    import matplotlib.pyplot as plt
-
-    show_abs = kwargs.pop("abs", False)
-    a, extent, axes = sample_slice(*args, **kwargs)
-    if show_abs:
-        a = np.abs(a)
-    im = plt.imshow(a, extent=extent, origin="lower")
-    plt.xlabel(axes[0])
-    plt.ylabel(axes[1])
-    plt.colorbar(im)
-    plt.show()

sdf/progress.py

@@ -1,83 +0,0 @@
-import sys
-import time
-
-
-def pretty_time(seconds):
-    seconds = int(round(seconds))
-    s = seconds % 60
-    m = (seconds // 60) % 60
-    h = seconds // 3600
-    return "%d:%02d:%02d" % (h, m, s)
-
-
-class Bar(object):
-    def __init__(self, max_value=100, min_value=0, enabled=True):
-        self.min_value = min_value
-        self.max_value = max_value
-        self.value = min_value
-        self.start_time = time.time()
-        self.enabled = enabled
-
-    @property
-    def percent_complete(self):
-        t = (self.value - self.min_value) / (self.max_value - self.min_value)
-        return t * 100
-
-    @property
-    def elapsed_time(self):
-        return time.time() - self.start_time
-
-    @property
-    def eta(self):
-        t = self.percent_complete / 100
-        if t == 0:
-            return 0
-        return (1 - t) * self.elapsed_time / t
-
-    def increment(self, delta):
-        self.update(self.value + delta)
-
-    def update(self, value):
-        self.value = value
-        if self.enabled:
-            sys.stdout.write("  %s    \r" % self.render())
-            sys.stdout.flush()
-
-    def done(self):
-        self.update(self.max_value)
-        self.stop()
-
-    def stop(self):
-        if self.enabled:
-            sys.stdout.write("\n")
-            sys.stdout.flush()
-
-    def render(self):
-        items = [
-            self.render_percent_complete(),
-            self.render_value(),
-            self.render_bar(),
-            self.render_elapsed_time(),
-            self.render_eta(),
-        ]
-        return " ".join(items)
-
-    def render_percent_complete(self):
-        return "%3.0f%%" % self.percent_complete
-
-    def render_value(self):
-        if self.min_value == 0:
-            return "(%g of %g)" % (self.value, self.max_value)
-        else:
-            return "(%g)" % (self.value)
-
-    def render_bar(self, size=30):
-        a = int(round(self.percent_complete / 100.0 * size))
-        b = size - a
-        return "[" + "#" * a + "-" * b + "]"
-
-    def render_elapsed_time(self):
-        return pretty_time(self.elapsed_time)
-
-    def render_eta(self):
-        return pretty_time(self.eta)

sdf/stl.py

@@ -1,27 +0,0 @@
-import numpy as np
-import struct
-
-
-def write_binary_stl(path, points):
-    n = len(points) // 3
-
-    points = np.array(points, dtype="float32").reshape((-1, 3, 3))
-    normals = np.cross(points[:, 1] - points[:, 0], points[:, 2] - points[:, 0])
-    normals /= np.linalg.norm(normals, axis=1).reshape((-1, 1))
-
-    dtype = np.dtype(
-        [
-            ("normal", ("<f", 3)),
-            ("points", ("<f", (3, 3))),
-            ("attr", "<H"),
-        ]
-    )
-
-    a = np.zeros(n, dtype=dtype)
-    a["points"] = points
-    a["normal"] = normals
-
-    with open(path, "wb") as fp:
-        fp.write(b"\x00" * 80)
-        fp.write(struct.pack("<I", n))
-        fp.write(a.tobytes())

sdf/text.py

@@ -1,160 +0,0 @@
-from PIL import Image, ImageFont, ImageDraw
-import scipy.ndimage as nd
-import numpy as np
-
-from . import d2
-
-# TODO: add support for newlines?
-
-PIXELS = 2**22
-
-
-def _load_image(thing):
-    if isinstance(thing, str):
-        return Image.open(thing)
-    elif isinstance(thing, (np.ndarray, np.generic)):
-        return Image.fromarray(thing)
-    return Image.fromarray(np.array(thing))
-
-
-def measure_text(name, text, width=None, height=None):
-    font = ImageFont.truetype(name, 96)
-    x0, y0, x1, y1 = font.getbbox(text)
-    aspect = (x1 - x0) / (y1 - y0)
-    if width is None and height is None:
-        height = 1
-    if width is None:
-        width = height * aspect
-    if height is None:
-        height = width / aspect
-    return (width, height)
-
-
-def measure_image(thing, width=None, height=None):
-    im = _load_image(thing)
-    w, h = im.size
-    aspect = w / h
-    if width is None and height is None:
-        height = 1
-    if width is None:
-        width = height * aspect
-    if height is None:
-        height = width / aspect
-    return (width, height)
-
-
-@d2.sdf2
-def text(font_name, text, width=None, height=None, pixels=PIXELS, points=512):
-    # load font file
-    font = ImageFont.truetype(font_name, points)
-
-    # compute texture bounds
-    p = 0.2
-    x0, y0, x1, y1 = font.getbbox(text)
-    px = int((x1 - x0) * p)
-    py = int((y1 - y0) * p)
-    tw = x1 - x0 + 1 + px * 2
-    th = y1 - y0 + 1 + py * 2
-
-    # render text to image
-    im = Image.new("L", (tw, th))
-    draw = ImageDraw.Draw(im)
-    draw.text((px - x0, py - y0), text, font=font, fill=255)
-
-    return _sdf(width, height, pixels, px, py, im)
-
-
-@d2.sdf2
-def image(thing, width=None, height=None, pixels=PIXELS):
-    im = _load_image(thing).convert("L")
-    return _sdf(width, height, pixels, 0, 0, im)
-
-
-def _sdf(width, height, pixels, px, py, im):
-    tw, th = im.size
-
-    # downscale image if necessary
-    factor = (pixels / (tw * th)) ** 0.5
-    if factor < 1:
-        tw, th = int(round(tw * factor)), int(round(th * factor))
-        px, py = int(round(px * factor)), int(round(py * factor))
-        im = im.resize((tw, th))
-
-    # convert to numpy array and apply distance transform
-    im = im.convert("1")
-    a = np.array(im)
-    inside = -nd.distance_transform_edt(a)
-    outside = nd.distance_transform_edt(~a)
-    texture = np.zeros(a.shape)
-    texture[a] = inside[a]
-    texture[~a] = outside[~a]
-
-    # save debug image
-    # a = np.abs(texture)
-    # lo, hi = a.min(), a.max()
-    # a = (a - lo) / (hi - lo) * 255
-    # im = Image.fromarray(a.astype('uint8'))
-    # im.save('debug.png')
-
-    # compute world bounds
-    pw = tw - px * 2
-    ph = th - py * 2
-    aspect = pw / ph
-    if width is None and height is None:
-        height = 1
-    if width is None:
-        width = height * aspect
-    if height is None:
-        height = width / aspect
-    x0 = -width / 2
-    y0 = -height / 2
-    x1 = width / 2
-    y1 = height / 2
-
-    # scale texture distances
-    scale = width / tw
-    texture *= scale
-
-    # prepare fallback rectangle
-    # TODO: reduce size based on mesh resolution instead of dividing by 2
-    rectangle = d2.rectangle((width / 2, height / 2))
-
-    def f(p):
-        x = p[:, 0]
-        y = p[:, 1]
-        u = (x - x0) / (x1 - x0)
-        v = (y - y0) / (y1 - y0)
-        v = 1 - v
-        i = u * pw + px
-        j = v * ph + py
-        d = _bilinear_interpolate(texture, i, j)
-        q = rectangle(p).reshape(-1)
-        outside = (i < 0) | (i >= tw - 1) | (j < 0) | (j >= th - 1)
-        d[outside] = q[outside]
-        return d
-
-    return f
-
-
-def _bilinear_interpolate(a, x, y):
-    x0 = np.floor(x).astype(int)
-    x1 = x0 + 1
-    y0 = np.floor(y).astype(int)
-    y1 = y0 + 1
-
-    x0 = np.clip(x0, 0, a.shape[1] - 1)
-    x1 = np.clip(x1, 0, a.shape[1] - 1)
-    y0 = np.clip(y0, 0, a.shape[0] - 1)
-    y1 = np.clip(y1, 0, a.shape[0] - 1)
-
-    pa = a[y0, x0]
-    pb = a[y1, x0]
-    pc = a[y0, x1]
-    pd = a[y1, x1]
-
-    wa = (x1 - x) * (y1 - y)
-    wb = (x1 - x) * (y - y0)
-    wc = (x - x0) * (y1 - y)
-    wd = (x - x0) * (y - y0)
-
-    return wa * pa + wb * pb + wc * pc + wd * pd

sdf/units.py

@@ -1,3 +0,0 @@
-import pint
-
-units = pint.UnitRegistry()

sdf/util.py

@@ -1,32 +0,0 @@
-import math
-import functools
-import inspect
-import numpy as np
-
-pi = math.pi
-
-degrees = math.degrees
-radians = math.radians
-
-
-def n_trailing_ascending_positive(d):
-    """
-    Determine how many elements in a given sequence are positive and ascending.
-
-    Args:
-        d (sequence of numbers): the sequence to check
-
-    Returns:
-        int : the amount of trailing ascending positive elements
-    """
-    d = np.array(d).flatten()
-    # is the next element larger than previous and positive?
-    order = (d[1:] > d[:-1]) & (d[:-1] > 0)
-    # TODO: Not happy at all with this if/else mess. Is there no easier way to find the
-    #       index in a numpy array after which the values are only ascending? 🤔
-    if np.all(order):  # all ascending
-        return d.size
-    elif np.all(~order):  # none ascending
-        return 0
-    else:  # count from end how many are ascending
-        return np.argmin(order[::-1]) + 1

src/fluency/__init__.py

@@ -0,0 +1,30 @@
+"""
+Fluency CAD - Parametric CAD Application
+
+A modern parametric CAD application built on OpenCASCADE Technology (OCCT)
+with a clean Python API using OCP (OpenCASCADE Python bindings).
+"""
+
+__version__ = "2.0.0"
+__author__ = "Fluency CAD Team"
+
+from fluency.geometry.base import (
+    Point2D,
+    Point3D,
+    GeometryObject,
+    GeometryKernel,
+    SketchInterface,
+)
+
+from fluency.geometry_occ.kernel import OCGeometryKernel
+from fluency.geometry_occ.sketch import OCCSketch
+
+__all__ = [
+    "Point2D",
+    "Point3D",
+    "GeometryObject",
+    "GeometryKernel",
+    "SketchInterface",
+    "OCGeometryKernel",
+    "OCCSketch",
+]

src/fluency/geometry/__init__.py

@@ -0,0 +1,19 @@
+"""Geometry abstraction layer for Fluency CAD."""
+
+from fluency.geometry.base import (
+    Point2D,
+    Point3D,
+    GeometryObject,
+    GeometryKernel,
+    SketchInterface,
+    SketchEntity,
+)
+
+__all__ = [
+    "Point2D",
+    "Point3D",
+    "GeometryObject",
+    "GeometryKernel",
+    "SketchInterface",
+    "SketchEntity",
+]

src/fluency/geometry/base.py

@@ -0,0 +1,442 @@
+"""
+Geometry abstraction layer for Fluency CAD.
+
+This module defines abstract interfaces for geometry operations,
+allowing different geometry kernels to be used interchangeably.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Tuple, Optional, Any, Dict
+import numpy as np
+
+
+@dataclass
+class Point2D:
+    """2D point representation."""
+
+    x: float
+    y: float
+
+    def to_tuple(self) -> Tuple[float, float]:
+        return (self.x, self.y)
+
+    def to_array(self) -> np.ndarray:
+        return np.array([self.x, self.y])
+
+    def distance_to(self, other: "Point2D") -> float:
+        return np.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Point2D):
+            return False
+        return abs(self.x - other.x) < 1e-6 and abs(self.y - other.y) < 1e-6
+
+
+@dataclass
+class Point3D:
+    """3D point representation."""
+
+    x: float
+    y: float
+    z: float
+
+    def to_tuple(self) -> Tuple[float, float, float]:
+        return (self.x, self.y, self.z)
+
+    def to_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
+    def distance_to(self, other: "Point3D") -> float:
+        return np.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2 + (self.z - other.z) ** 2)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Point3D):
+            return False
+        return (
+            abs(self.x - other.x) < 1e-6
+            and abs(self.y - other.y) < 1e-6
+            and abs(self.z - other.z) < 1e-6
+        )
+
+
+class GeometryObject:
+    """Base class for geometry objects."""
+
+    def __init__(self, shape: Any = None, metadata: Optional[Dict] = None):
+        self.shape = shape
+        self.metadata = metadata or {}
+        self._mesh_cache: Optional[Tuple[np.ndarray, np.ndarray]] = None
+
+    def invalidate_cache(self) -> None:
+        """Invalidate any cached data."""
+        self._mesh_cache = None
+
+
+class SketchEntity:
+    """Base class for sketch entities (points, lines, circles)."""
+
+    def __init__(self, entity_id: int, entity_type: str):
+        self.id = entity_id
+        self.entity_type = entity_type
+        self.constraints: List[str] = []
+        self.is_construction: bool = False
+
+    def add_constraint(self, constraint_type: str) -> None:
+        self.constraints.append(constraint_type)
+
+
+class GeometryKernel(ABC):
+    """
+    Abstract base class for geometry kernels.
+
+    A geometry kernel provides primitives, operations, and export capabilities
+    for CAD geometry.
+    """
+
+    @abstractmethod
+    def create_point(self, x: float, y: float) -> GeometryObject:
+        """Create a 2D point."""
+        pass
+
+    @abstractmethod
+    def create_line(self, start: Point2D, end: Point2D) -> GeometryObject:
+        """Create a 2D line segment."""
+        pass
+
+    @abstractmethod
+    def create_circle(self, center: Point2D, radius: float) -> GeometryObject:
+        """Create a 2D circle."""
+        pass
+
+    @abstractmethod
+    def create_arc(
+        self, center: Point2D, radius: float, start_angle: float, end_angle: float
+    ) -> GeometryObject:
+        """Create a 2D arc."""
+        pass
+
+    @abstractmethod
+    def create_polygon(self, points: List[Point2D]) -> GeometryObject:
+        """Create a closed polygon from points."""
+        pass
+
+    @abstractmethod
+    def create_rectangle(
+        self, width: float, height: float, center: Optional[Point2D] = None
+    ) -> GeometryObject:
+        """Create a rectangle."""
+        pass
+
+    @abstractmethod
+    def extrude(
+        self,
+        sketch: GeometryObject,
+        height: float,
+        direction: Tuple[float, float, float] = (0, 0, 1),
+        symmetric: bool = False,
+    ) -> GeometryObject:
+        """Extrude a 2D sketch into a 3D solid."""
+        pass
+
+    @abstractmethod
+    def revolve(
+        self,
+        sketch: GeometryObject,
+        angle: float = 360.0,
+        axis: Tuple[float, float, float] = (0, 0, 1),
+        origin: Tuple[float, float, float] = (0, 0, 0),
+    ) -> GeometryObject:
+        """Revolve a 2D sketch around an axis."""
+        pass
+
+    @abstractmethod
+    def loft(self, profiles: List[GeometryObject], ruled: bool = False) -> GeometryObject:
+        """Create a loft between multiple profiles."""
+        pass
+
+    @abstractmethod
+    def sweep(
+        self, profile: GeometryObject, path: GeometryObject, is_frenet: bool = False
+    ) -> GeometryObject:
+        """Sweep a profile along a path."""
+        pass
+
+    @abstractmethod
+    def boolean_union(self, *bodies: GeometryObject) -> GeometryObject:
+        """Union multiple bodies."""
+        pass
+
+    @abstractmethod
+    def boolean_difference(self, base: GeometryObject, tool: GeometryObject) -> GeometryObject:
+        """Subtract tool from base."""
+        pass
+
+    @abstractmethod
+    def boolean_intersection(self, body1: GeometryObject, body2: GeometryObject) -> GeometryObject:
+        """Intersect two bodies."""
+        pass
+
+    @abstractmethod
+    def fillet(
+        self, body: GeometryObject, radius: float, edges: Optional[List[Any]] = None
+    ) -> GeometryObject:
+        """Apply fillet to edges."""
+        pass
+
+    @abstractmethod
+    def chamfer(
+        self, body: GeometryObject, size: float, edges: Optional[List[Any]] = None
+    ) -> GeometryObject:
+        """Apply chamfer to edges."""
+        pass
+
+    @abstractmethod
+    def shell(
+        self, body: GeometryObject, thickness: float, faces_to_remove: Optional[List[Any]] = None
+    ) -> GeometryObject:
+        """Create a shell (hollow body)."""
+        pass
+
+    @abstractmethod
+    def offset(self, face: GeometryObject, distance: float) -> GeometryObject:
+        """Offset a face or surface."""
+        pass
+
+    @abstractmethod
+    def translate(self, body: GeometryObject, vector: Tuple[float, float, float]) -> GeometryObject:
+        """Translate a body."""
+        pass
+
+    @abstractmethod
+    def rotate(
+        self,
+        body: GeometryObject,
+        axis: Tuple[float, float, float],
+        angle: float,
+        origin: Tuple[float, float, float] = (0, 0, 0),
+    ) -> GeometryObject:
+        """Rotate a body around an axis."""
+        pass
+
+    @abstractmethod
+    def scale(self, body: GeometryObject, factor: float) -> GeometryObject:
+        """Scale a body uniformly."""
+        pass
+
+    @abstractmethod
+    def mirror(
+        self,
+        body: GeometryObject,
+        plane_normal: Tuple[float, float, float],
+        plane_origin: Tuple[float, float, float] = (0, 0, 0),
+    ) -> GeometryObject:
+        """Mirror a body across a plane."""
+        pass
+
+    @abstractmethod
+    def export_step(self, body: GeometryObject, filepath: str, schema: str = "AP214") -> bool:
+        """Export to STEP format."""
+        pass
+
+    @abstractmethod
+    def export_iges(self, body: GeometryObject, filepath: str) -> bool:
+        """Export to IGES format."""
+        pass
+
+    @abstractmethod
+    def export_stl(
+        self, body: GeometryObject, filepath: str, tolerance: float = 0.1, ascii_mode: bool = False
+    ) -> bool:
+        """Export to STL format."""
+        pass
+
+    @abstractmethod
+    def import_step(self, filepath: str) -> GeometryObject:
+        """Import from STEP format."""
+        pass
+
+    @abstractmethod
+    def import_iges(self, filepath: str) -> GeometryObject:
+        """Import from IGES format."""
+        pass
+
+    @abstractmethod
+    def get_mesh(
+        self, body: GeometryObject, tolerance: float = 0.1
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Get triangulated mesh for rendering.
+
+        Returns:
+            Tuple of (vertices, faces) where:
+            - vertices: Nx3 numpy array of vertex positions
+            - faces: Mx3 numpy array of triangle indices
+        """
+        pass
+
+    @abstractmethod
+    def get_edges(self, body: GeometryObject) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Get edge wireframe for rendering.
+
+        Returns:
+            Tuple of (vertices, edges) where:
+            - vertices: Nx3 numpy array of vertex positions
+            - edges: Mx2 numpy array of edge vertex indices
+        """
+        pass
+
+    @abstractmethod
+    def get_bounding_box(self, body: GeometryObject) -> Tuple[Point3D, Point3D]:
+        """Get the bounding box of a body."""
+        pass
+
+    @abstractmethod
+    def get_volume(self, body: GeometryObject) -> float:
+        """Calculate the volume of a solid body."""
+        pass
+
+    @abstractmethod
+    def get_surface_area(self, body: GeometryObject) -> float:
+        """Calculate the surface area of a body."""
+        pass
+
+    @abstractmethod
+    def get_center_of_mass(self, body: GeometryObject) -> Point3D:
+        """Calculate the center of mass of a solid body."""
+        pass
+
+
+class SketchInterface(ABC):
+    """
+    Abstract interface for 2D sketching with constraints.
+
+    A sketch provides 2D geometry creation and constraint solving
+    capabilities for parametric CAD.
+    """
+
+    @abstractmethod
+    def add_point(self, x: float, y: float) -> SketchEntity:
+        """Add a point to the sketch."""
+        pass
+
+    @abstractmethod
+    def add_line(self, start: SketchEntity, end: SketchEntity) -> SketchEntity:
+        """Add a line between two points."""
+        pass
+
+    @abstractmethod
+    def add_circle(self, center: SketchEntity, radius: float) -> SketchEntity:
+        """Add a circle."""
+        pass
+
+    @abstractmethod
+    def add_arc(
+        self,
+        center: SketchEntity,
+        radius: float,
+        start_point: SketchEntity,
+        end_point: SketchEntity,
+    ) -> SketchEntity:
+        """Add an arc."""
+        pass
+
+    @abstractmethod
+    def add_rectangle(
+        self, corner1: Tuple[float, float], corner2: Tuple[float, float]
+    ) -> List[SketchEntity]:
+        """Add a rectangle, returning the created entities."""
+        pass
+
+    @abstractmethod
+    def constrain_coincident(self, *entities: SketchEntity) -> bool:
+        """Make entities coincident."""
+        pass
+
+    @abstractmethod
+    def constrain_horizontal(self, line: SketchEntity) -> bool:
+        """Constrain a line to be horizontal."""
+        pass
+
+    @abstractmethod
+    def constrain_vertical(self, line: SketchEntity) -> bool:
+        """Constrain a line to be vertical."""
+        pass
+
+    @abstractmethod
+    def constrain_distance(
+        self, entity1: SketchEntity, entity2: SketchEntity, distance: float
+    ) -> bool:
+        """Constrain distance between two entities."""
+        pass
+
+    @abstractmethod
+    def constrain_angle(self, line1: SketchEntity, line2: SketchEntity, angle: float) -> bool:
+        """Constrain angle between two lines."""
+        pass
+
+    @abstractmethod
+    def constrain_parallel(self, line1: SketchEntity, line2: SketchEntity) -> bool:
+        """Constrain two lines to be parallel."""
+        pass
+
+    @abstractmethod
+    def constrain_perpendicular(self, line1: SketchEntity, line2: SketchEntity) -> bool:
+        """Constrain two lines to be perpendicular."""
+        pass
+
+    @abstractmethod
+    def constrain_midpoint(self, point: SketchEntity, line: SketchEntity) -> bool:
+        """Constrain a point to be at the midpoint of a line."""
+        pass
+
+    @abstractmethod
+    def constrain_tangent(self, entity1: SketchEntity, entity2: SketchEntity) -> bool:
+        """Constrain two entities to be tangent."""
+        pass
+
+    @abstractmethod
+    def constrain_equal_length(self, line1: SketchEntity, line2: SketchEntity) -> bool:
+        """Constrain two lines to have equal length."""
+        pass
+
+    @abstractmethod
+    def constrain_equal_radius(self, circle1: SketchEntity, circle2: SketchEntity) -> bool:
+        """Constrain two circles to have equal radius."""
+        pass
+
+    @abstractmethod
+    def constrain_diameter(self, circle: SketchEntity, diameter: float) -> bool:
+        """Set the diameter of a circle."""
+        pass
+
+    @abstractmethod
+    def constrain_fixed(self, entity: SketchEntity) -> bool:
+        """Fix an entity in place."""
+        pass
+
+    @abstractmethod
+    def solve(self) -> bool:
+        """Solve all constraints."""
+        pass
+
+    @abstractmethod
+    def get_geometry(self) -> GeometryObject:
+        """Get the solved geometry for operations."""
+        pass
+
+    @abstractmethod
+    def get_points(self) -> List[Point2D]:
+        """Get all point positions."""
+        pass
+
+    @abstractmethod
+    def clear(self) -> None:
+        """Clear all geometry and constraints."""
+        pass
+
+    @abstractmethod
+    def delete_entity(self, entity: SketchEntity) -> bool:
+        """Delete an entity and its constraints."""
+        pass

src/fluency/geometry_occ/__init__.py

@@ -0,0 +1,11 @@
+"""OpenCASCADE geometry module."""
+
+from fluency.geometry_occ.kernel import OCGeometryKernel, OCCGeometryObject
+from fluency.geometry_occ.sketch import OCCSketch, OCCSketchEntity
+
+__all__ = [
+    "OCGeometryKernel",
+    "OCCGeometryObject",
+    "OCCSketch",
+    "OCCSketchEntity",
+]

src/fluency/geometry_occ/surface_modifier.py

@@ -0,0 +1,385 @@
+"""Surface modifier for OpenCASCADE geometry.
+
+Applies geometric patterns (pyramids, bumps, grooves) to 3D surfaces using boolean operations.
+This enables grip-enhancing textures and visual surface modifications on CAD models.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from typing import Any, Optional, Tuple
+
+# OCC imports at module level for common types
+
+
+logger = logging.getLogger(__name__)
+
+
+class SurfaceModifier:
+    """Applies geometric patterns to 3D surfaces using OCC boolean operations."""
+
+    def __init__(self):
+        self._patterns_applied = []
+
+    def apply_pyramid_pattern(
+        self,
+        face_shape,
+        pyramid_height: float = 1.0,
+        base_radius: float = 2.0,
+        spacing: float = 5.0,
+        num_rings: Optional[int] = None,
+        direction: Tuple[float, float, float] = (0, 0, 1),
+    ) -> Optional[Any]:
+        """Apply a pyramid pattern to a face surface.
+
+        Args:
+            face_shape: OCC TopoDS_Shape representing the face or solid
+            pyramid_height: Height of each pyramid
+            base_radius: Radius of pyramid base
+            spacing: Distance between pyramids
+            num_rings: Number of concentric rings (auto-calculated if None)
+            direction: Normal direction for pyramids
+
+        Returns:
+            Modified shape on success, None on failure
+        """
+        try:
+            from OCP.TopAbs import TopAbs_FACE
+            from OCP.TopoDS import TopoDS_Face, TopoDS_Shape
+            from OCP.BRepAlgoAPI import BRepAlgoAPI_Fuse
+            from OCP.TopExp import TopExp_Explorer
+            from OCP.BRepAdaptor import BRepAdaptor_Surface
+
+            # Validate face shape
+            if not isinstance(face_shape, (TopoDS_Shape, TopoDS_Face)):
+                logger.error("Invalid face shape type")
+                return None
+
+            # Extract the first face for surface parameterization
+            if isinstance(face_shape, TopoDS_Shape):
+                explorer = TopExp_Explorer(face_shape, TopAbs_FACE)
+                if not explorer.More():
+                    logger.error("No faces found in shape")
+                    return None
+                from OCP import TopoDS
+                face = TopoDS.TopoDS.Face_s(explorer.Current())
+            else:
+                face = face_shape
+
+            # Get face surface for UV parameterization
+            surf = BRepAdaptor_Surface(face)
+
+            u_min, u_max = surf.FirstUParameter(), surf.LastUParameter()
+            v_min, v_max = surf.FirstVParameter(), surf.LastVParameter()
+
+            # Calculate number of rings if not specified
+            if num_rings is None:
+                # Estimate based on face area and spacing
+                u_range = u_max - u_min
+                v_range = v_max - v_min
+                avg_dim = (u_range + v_range) / 2.0
+                num_rings = max(1, min(int(avg_dim / spacing), 5))
+
+            logger.info(
+                f"Applying pyramid pattern: {num_rings} rings, "
+                f"{base_radius:.2f} radius, {pyramid_height:.2f} height"
+            )
+
+            # Create pyramids distributed across the face UV space
+            result_shape = face_shape
+            pyramid_count = 0
+
+            for ring_idx in range(num_rings):
+                # Distribute rings evenly across UV parameter space
+                u_fraction = (ring_idx + 1) / (num_rings + 1)
+                v_fraction = 0.5  # Center vertically
+
+                # Map to actual UV coordinates on the face
+                u_pos = u_min + u_fraction * (u_max - u_min)
+                v_pos = v_min + v_fraction * (v_max - v_min)
+
+                # Get 3D position and tangent vectors at this UV point
+                from OCP.gp import gp_Pnt, gp_Vec
+
+                center_pt = gp_Pnt()
+                d1u = gp_Vec()
+                d1v = gp_Vec()
+                surf.D1(u_pos, v_pos, center_pt, d1u, d1v)
+                # Normal is cross product of tangent vectors
+                normal = d1u.Crossed(d1v)
+                normal.Normalize()
+
+                # Calculate number of pyramids in this ring based on spacing
+                if ring_idx == 0:
+                    num_pyramids = 1  # Center pyramid
+                else:
+                    circumference = 2.0 * math.pi * (ring_idx * spacing)
+                    num_pyramids = max(3, int(circumference / spacing))
+
+                for i in range(num_pyramids):
+                    if ring_idx == 0:
+                        # Center pyramid - place at face center
+                        place_u = u_pos
+                        place_v = v_pos
+                    else:
+                        angle = (2.0 * math.pi * i) / num_pyramids
+                        # Offset in UV space based on ring radius
+                        offset_u = (ring_idx * spacing / (u_max - u_min)) * math.cos(angle)
+                        offset_v = (ring_idx * spacing / (v_max - v_min)) * math.sin(angle)
+                        place_u = max(u_min, min(u_max, u_pos + offset_u))
+                        place_v = max(v_min, min(v_max, v_pos + offset_v))
+
+                    try:
+                        # Get 3D position and normal for this pyramid
+                        pyramid_pt = gp_Pnt()
+                        pd1u = gp_Vec()
+                        pd1v = gp_Vec()
+                        surf.D1(place_u, place_v, pyramid_pt, pd1u, pd1v)
+                        pyramid_normal = pd1u.Crossed(pd1v)
+                        pyramid_normal.Normalize()
+
+                        # Create solid pyramid at this position
+                        pyramid_shape = self._create_solid_pyramid(
+                            pyramid_pt,
+                            pyramid_normal,
+                            pyramid_height,
+                            base_radius,
+                        )
+
+                        if pyramid_shape is not None:
+                            # Fuse with existing geometry
+                            fuse = BRepAlgoAPI_Fuse(result_shape, pyramid_shape)
+                            fuse.Build()
+
+                            if fuse.IsDone():
+                                result_shape = fuse.Shape()
+                                pyramid_count += 1
+                            else:
+                                logger.warning(
+                                    f"Failed to fuse pyramid at ({place_u:.2f}, {place_v:.2f})"
+                                )
+                    except Exception as e:
+                        logger.debug(
+                            f"Error creating pyramid at ring {ring_idx}, pyramid {i}: {e}"
+                        )
+
+            self._patterns_applied.append(
+                {
+                    "type": "pyramid",
+                    "parameters": {
+                        "height": pyramid_height,
+                        "base_radius": base_radius,
+                        "spacing": spacing,
+                        "num_rings": num_rings,
+                        "direction": direction,
+                    },
+                }
+            )
+
+            logger.info(f"Successfully applied {pyramid_count} pyramids")
+
+            return result_shape
+
+        except Exception as e:
+            logger.error(f"Error applying pyramid pattern: {e}", exc_info=True)
+            return None
+
+    def _create_solid_pyramid(
+        self,
+        base_point,  # gp_Pnt - position on the face
+        normal_vec,  # gp_Dir or gp_Vec - surface normal direction
+        height: float,
+        base_radius: float,
+    ) -> Optional[Any]:
+        """Create a solid pyramid at the specified position and orientation.
+
+        Uses BRepPrimAPI_MakePrism to extrude a square base into a solid pyramid.
+
+        Args:
+            base_point: 3D point where pyramid base is centered
+            normal_vec: Direction vector for pyramid growth (surface normal)
+            height: Height of the pyramid from base to apex
+            base_radius: Half-width of the square base
+
+        Returns:
+            OCC solid shape for the pyramid, or None on failure
+        """
+        try:
+            from OCP.gp import gp_Dir, gp_Ax2, gp_Vec
+            from OCP.BRepBuilderAPI import (
+                BRepBuilderAPI_MakeEdge,
+                BRepBuilderAPI_MakeWire,
+            )
+            from OCP.BRepPrimAPI import BRepPrimAPI_MakePrism
+
+            half = base_radius / 2.0
+
+            # Build orthonormal basis from normal vector
+            if isinstance(normal_vec, gp_Vec):
+                n_dir = gp_Dir(normal_vec.XYZ())
+            else:
+                n_dir = normal_vec
+
+            # Create a local coordinate system at the base point
+            local_ax2 = gp_Ax2(base_point, n_dir)
+
+            # Get X and Y axes from the local coordinate system
+            x_dir = local_ax2.XDirection()
+            y_dir = local_ax2.YDirection()
+
+            # Create 4 corners of the square base in the local plane
+            corner_points = [
+                base_point + gp_Vec(x_dir).Multiplied(half) + gp_Vec(y_dir).Multiplied(half),
+                base_point + gp_Vec(x_dir).Multiplied(-half) + gp_Vec(y_dir).Multiplied(half),
+                base_point + gp_Vec(x_dir).Multiplied(-half) + gp_Vec(y_dir).Multiplied(-half),
+                base_point + gp_Vec(x_dir).Multiplied(half) + gp_Vec(y_dir).Multiplied(-half),
+            ]
+
+            # Create edges connecting the corners
+            wire_maker = BRepBuilderAPI_MakeWire()
+            for idx in range(4):
+                next_idx = (idx + 1) % 4
+                edge = BRepBuilderAPI_MakeEdge(
+                    corner_points[idx], corner_points[next_idx]
+                ).Edge()
+                wire_maker.Add(edge)
+
+            if not wire_maker.IsDone():
+                logger.warning("Failed to create pyramid base wire")
+                return None
+
+            # Extrude the base wire in the normal direction by height to form a prism
+            extrusion_vec = gp_Vec(n_dir).Multiplied(height)
+            prism_maker = BRepPrimAPI_MakePrism(
+                wire_maker.Wire(), extrusion_vec, False  # no check intersection
+            )
+            prism_maker.Build()
+
+            if not prism_maker.IsDone():
+                logger.warning("Failed to create pyramid prism")
+                return None
+
+            return prism_maker.Shape()
+
+        except Exception as e:
+            logger.debug(f"Error creating solid pyramid: {e}")
+            return None
+
+    def apply_bump_pattern(
+        self,
+        face_shape,
+        bump_height: float = 1.0,
+        bump_radius: float = 2.0,
+        spacing: float = 5.0,
+        num_rings: Optional[int] = None,
+    ) -> Optional[Any]:
+        """Apply a simple bump pattern to a face surface.
+
+        Args:
+            face_shape: OCC TopoDS_Shape representing the face
+            bump_height: Height of each bump
+            bump_radius: Radius of each bump base
+            spacing: Distance between bumps
+            num_rings: Number of concentric rings
+
+        Returns:
+            Modified shape on success, None on failure
+        """
+        return self.apply_pyramid_pattern(
+            face_shape,
+            pyramid_height=bump_height,
+            base_radius=bump_radius,
+            spacing=spacing,
+            num_rings=num_rings,
+        )
+
+
+def apply_surface_modifier_to_body(
+    body_geometry, modifier_type: str = "pyramid", **parameters
+) -> Optional[Any]:
+    """Apply a surface modifier to a body geometry.
+
+    Args:
+        body_geometry: OCCGeometryObject or similar geometry object
+        modifier_type: Type of modifier ('pyramid', 'bump')
+        **parameters: Modifier-specific parameters
+
+    Returns:
+        Modified shape, or None on failure
+    """
+    from fluency.geometry_occ.kernel import OCGeometryKernel
+
+    kernel = OCGeometryKernel()
+    shape = kernel._get_shape(body_geometry)
+
+    if shape is None:
+        logger.error("No geometry found in body")
+        return None
+
+    modifier = SurfaceModifier()
+
+    try:
+        if modifier_type == "pyramid":
+            success = modifier.apply_pyramid_pattern(shape, **parameters)
+        elif modifier_type == "bump":
+            success = modifier.apply_bump_pattern(shape, **parameters)
+        else:
+            logger.error(f"Unknown modifier type: {modifier_type}")
+            return None
+
+        if not success:
+            logger.error("Surface modifier application failed")
+            return None
+
+        # Return the modified shape wrapped in OCCGeometryObject
+        from fluency.geometry_occ.kernel import OCCGeometryObject
+
+        return OCCGeometryObject(shape)
+
+    except Exception as e:
+        logger.error(f"Error applying surface modifier: {e}", exc_info=True)
+        return None
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Create a simple test case
+    from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox
+
+    # Create a box to modify
+    box_maker = BRepPrimAPI_MakeBox(50, 50, 10)
+    box_maker.Build()
+
+    if box_maker.IsDone():
+        print("Created test box")
+
+        # Apply pyramid pattern to top face (Z direction)
+        modifier = SurfaceModifier()
+        success = modifier.apply_pyramid_pattern(
+            box_maker.Shape(),
+            pyramid_height=2.0,
+            base_radius=3.0,
+            spacing=8.0,
+            num_rings=2,
+            direction=(0, 0, 1),
+        )
+
+        if success:
+            print("Successfully applied pyramid pattern")
+
+            # Export modified shape
+            from OCP.StlAPI import StlAPI_Writer
+            from OCP.BRepMesh import BRepMesh_IncrementalMesh
+
+            tess = BRepMesh_IncrementalMesh(box_maker.Shape(), 0.1)
+            tess.Perform()
+
+            writer = StlAPI_Writer()
+            writer.SetASCIIMode(False)
+            writer.Write(box_maker.Shape(), "/tmp/test_pyramid_pattern.stl")
+            print("Exported modified shape to STL")
+        else:
+            print("Failed to apply pyramid pattern")
+    else:
+        print("Failed to create test box")

src/fluency/io/__init__.py

@@ -0,0 +1,5 @@
+"""I/O module: project save/load."""
+
+from fluency.io.project_io import save_project, load_project, project_zip_path
+
+__all__ = ["save_project", "load_project", "project_zip_path"]

src/fluency/main.py

@@ -0,0 +1,63 @@
+"""Fluency CAD - Main entry point.
+
+This module is intentionally thin. The actual UI lives in the
+``fluency.ui`` package:
+
+    ui.dialogs           – 4 modal dialogs (Extrude, Revolve, Offset, WorkplaneOrientation)
+    ui.viewer_widget     – Viewer3DWidget (3D canvas)
+    ui.sketch_widget     – Sketch2DWidget (2D sketcher + constraint solver)
+    ui.main_window       – MainWindow (application shell)
+
+The public classes are re-exported here so that existing call sites
+that do ``from fluency.main import MainWindow`` (notably
+``tests/test_geometry.py``) keep working.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from fluency.ui.dialogs import (
+    ExtrudeDialog,
+    OffsetDialog,
+    RevolveDialog,
+    ThreadDialog,
+    WorkplaneOrientationDialog,
+)
+from fluency.ui.main_window import MainWindow
+from fluency.ui.sketch_widget import Sketch2DWidget
+from fluency.ui.viewer_widget import Viewer3DWidget
+
+__all__ = [
+    "MainWindow",
+    "Sketch2DWidget",
+    "Viewer3DWidget",
+    "ExtrudeDialog",
+    "RevolveDialog",
+    "OffsetDialog",
+    "ThreadDialog",
+    "WorkplaneOrientationDialog",
+    "main",
+]
+
+
+def main() -> int:
+    """Launch the Fluency CAD application.
+
+    Returns the ``QApplication.exec()`` exit code so that the console-script
+    entry point declared in ``pyproject.toml`` can forward it.
+    """
+    app = QApplication(sys.argv)
+    app.setStyle("Fusion")
+
+    window = MainWindow()
+    window.show()
+
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/fluency/models/__init__.py

@@ -0,0 +1,15 @@
+"""Models module."""
+
+from fluency.models.data_model import (
+    Project,
+    Component,
+    Sketch,
+    Body,
+)
+
+__all__ = [
+    "Project",
+    "Component",
+    "Sketch",
+    "Body",
+]