Hermes/fluencyCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: Hermes/fluencyCAD:master
Branches Tags
Hermes/fluencyCAD:master Hermes/fluencyCAD:feature/occ-migration Hermes/fluencyCAD:single_window Hermes/fluencyCAD:structure
...
pull from: Hermes/fluencyCAD:feature/occ-migration
Branches Tags
Hermes/fluencyCAD:feature/occ-migration Hermes/fluencyCAD:single_window Hermes/fluencyCAD:master Hermes/fluencyCAD:structure

33 Commits
master ... feature/occ-migration

Author SHA1 Message Date
bklronin 742d06d242 - Render improvements, camera plane, update 2026-07-13 23:01:35 +02:00
bklronin c78d0af78c - added renderer 
- Added undo
 2026-07-13 06:54:21 +02:00
bklronin dda9db822b - added renderer 
- Added undo
 2026-07-12 23:25:59 +02:00
bklronin 9f1387fe68 - added renderer 
- Added undo
 2026-07-12 22:21:43 +02:00
bklronin 210e3cfb5d - added renderer 2026-07-12 22:21:20 +02:00
bklronin b8516fff91 - Working assembly multi :) 2026-07-11 21:42:08 +02:00
bklronin d7e5929a13 - Working assembly multi :) 2026-07-11 21:29:58 +02:00
bklronin 2b2afbc479 - Added save file foramt 
- Split main.py refactor
 2026-07-11 15:39:30 +02:00
bklronin b0aebdc04f - Added save file foramt 
- Split main.py refactor
 2026-07-11 09:34:38 +02:00
bklronin be22c44a3f - Added save file foramt 
- Split main.py refactor
 2026-07-07 22:40:40 +02:00
bklronin 80ba3cc70a - Added save file foramt 
- Split main.py refactor
 2026-07-07 21:51:27 +02:00
bklronin 5269c0897c - Added save file foramt 
- Split main.py refactor
 2026-07-05 22:16:08 +02:00
bklronin 3a169007f7 - assembly draft 2026-07-05 19:36:27 +02:00
bklronin b595b88e04 - assembly draft 2026-07-05 10:16:49 +02:00
bklronin 9f10a5c5e5 - UI refinement, button position ui file as source no dirty drafting anymore 2026-07-04 16:16:04 +02:00
bklronin 6ba742ddf5 - sketch enhacements 2026-07-04 12:10:58 +02:00
bklronin 01833e4af2 - sketch enhacements 2026-07-03 21:49:05 +02:00
bklronin f860ff3e77 - removed cadquery deoendency 2026-07-01 20:03:00 +02:00
bklronin 9938f4ddd4 - Basic operations 2026-06-29 23:30:02 +02:00
bklronin f6422e0847 - Tons of addtions 2026-06-28 22:51:52 +02:00
bklronin f8f16ea800 - Tons of addtions 2026-06-28 21:12:34 +02:00
bklronin 54ac2c098a - Improved sketching 2026-06-14 10:10:37 +02:00
bklronin ea34e7e29d - Improved sketching 2026-06-14 10:10:33 +02:00
bklronin 7091f530ee fix: use RenderWidget and add animation callback for camera controls 
- Change from RenderCanvas to RenderWidget for embedded Qt widget
- Add _animate() callback for canvas.request_draw()
- Update render() to use request_draw() for continuous rendering
- This enables OrbitController to work properly with mouse events
 2026-03-14 09:12:12 +01:00
bklronin 75d4820292 fix: register OrbitController events with renderer 
Use controller.register_events(renderer) instead of canvas to properly
enable camera rotation/pan/zoom controls in the 3D viewer.
 2026-03-14 09:09:32 +01:00
bklronin d52106a48a fix: update pygfx integration for current API 
- Use rendercanvas.qt.RenderCanvas instead of wgpu.gui.qt.WgpuCanvas
- Fix camera position API: use camera.local.position instead of camera.position.set()
- Fix light position API: use light.local.position
- Fix PygfxRenderObject to properly inherit from RenderObject
- Change add_mesh/add_wireframe/add_points/add_grid/add_axes to return string ID
- Update base Renderer class to return str instead of RenderObject
- Add custom compute_normals() function for mesh normals
 2026-03-14 09:06:38 +01:00
bklronin d7ebbf45d5 feat: add CLI logging for debugging 
- Add logging module with DEBUG level
- Log MainWindow initialization
- Log Viewer3DWidget initialization and mesh operations
- Log mouse events in Sketch2DWidget
- Log extrude operations with detailed steps
- Log component and sketch management
 2026-03-14 09:01:20 +01:00
bklronin daed79dac6 chore: update .gitignore and remove pycache from tracking 2026-03-14 08:59:25 +01:00
bklronin e13769840b fix: ensure renderer is initialized before operations 
- Add _ensure_initialized() method to Viewer3DWidget
- Queue pending meshes until widget is shown
- Add remove_mesh() method to PygfxRenderer
- Fix all viewer methods to check initialization
 2026-03-14 08:59:12 +01:00
bklronin 5371bf7c38 fix: implement custom compute_normals for pygfx 
pygfx doesn't have a compute_normals function, so we implement
our own vertex normal computation from positions and face indices.
 2026-03-14 08:57:52 +01:00
bklronin bf00310889 feat: implement full GUI with all features from old codebase 
- Main window with left/center/right panel layout
- 2D sketch widget with drawing tools (line, rectangle, circle)
- Constraint tools (coincident, horizontal, vertical, distance, midpoint)
- Snapping system (point, midpoint, horizontal, vertical, angle, grid)
- 3D viewer widget using pygfx
- Component timeline with buttons
- Sketch and body list management
- Operations (extrude, cut, combine, revolve)
- Workplane tools (origin, face, flip, move)
- Export functionality (STEP, IGES, STL)
- Import STEP/IGES files
- Code tab for CadQuery scripting
 2026-03-14 08:56:13 +01:00
bklronin 8c6a413137 fix: correct OCP API usage for mesh, bounding box, and volume 
- Fix BRep_Tool.Triangulation_s to use TopoDS.Face_s for face casting
- Fix BRepBndLib.AddClose_s import and usage
- Fix BRepGProp.VolumeProperties_s and SurfaceProperties_s imports
- Fix _get_shape to handle Workplane objects stored in shape attribute
- Fix OCCSketchEntity to properly inherit from SketchEntity
- Update pyproject.toml dependency versions
 2026-03-14 08:52:45 +01:00
bklronin fe23ca610c feat: Replace SDF kernel with OpenCASCADE, VTK with pygfx 
Major architecture migration:

- Remove SDF-based geometry kernel (sdf/)
- Remove VTK renderer (drawing_modules/)
- Remove old mesh modules (mesh_modules/)

New components:
- geometry/base.py: Abstract geometry kernel interface
- geometry_occ/kernel.py: OpenCASCADE implementation via CadQuery/OCP
- geometry_occ/sketch.py: 2D sketching with constraint solving
- rendering/base.py: Abstract renderer interface
- rendering/pygfx_renderer.py: WebGPU-based renderer
- models/data_model.py: Project, Component, Sketch, Body classes
- main.py: New Qt-based application

Features:
- STEP/IGES import/export
- Exact BRep geometry (vs approximate SDF mesh)
- Parametric sketching with constraints
- Boolean operations (union, difference, intersection)
- Fillet and chamfer operations
- Modern pygfx renderer (~30MB vs VTK ~200MB)

Dependencies:
- cadquery >= 2.4
- ocp >= 7.9.3
- pygfx >= 0.7.0
- wgpu >= 0.19.0
- PySide6 >= 6.9.0
 2026-03-14 08:45:07 +01:00
115 changed files with 25824 additions and 14694 deletions
Expand all files Collapse all files
.gitignore
+36 -1
View File
@@ -1,3 +1,38 @@
*.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
.idea/fluency.iml
Generated
-11
View File
@@ -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
Generated
+1 -1
View File
@@ -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
Generated
+224 -33
View File
@@ -4,11 +4,14 @@
<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="- added renderer&#10;- Added undo">
<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/rendering/mitsuba_backend.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/rendering/mitsuba_backend.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/rendering/render_backend.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/rendering/render_backend.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/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 +28,7 @@
<component name="Git.Settings">
<option name="RECENT_BRANCH_BY_REPOSITORY">
<map>
<entry key="$PROJECT_DIR$" value="structure" />
<entry key="$PROJECT_DIR$" value="single_window" />
</map>
</option>
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
@@ -45,30 +48,45 @@
<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.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.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.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/rendering&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,6 +94,8 @@
</component>
<component name="RecentsManager">
<key name="CopyFile.RECENT_KEYS">
<recent name="$PROJECT_DIR$/src/fluency/rendering" />
<recent name="$PROJECT_DIR$/src/fluency" />
<recent name="$PROJECT_DIR$" />
<recent name="$PROJECT_DIR$/drawing_modules" />
<recent name="$PROJECT_DIR$/modules" />
@@ -87,7 +107,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>
@@ -252,9 +272,172 @@
<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>
<option name="localTasksCounter" value="40" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="3" />
</component>
<component name="Vcs.Log.Tabs.Properties">
<option name="TAB_STATES">
<map>
@@ -270,8 +453,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" />
@@ -287,6 +468,16 @@
<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" />
<option name="LAST_COMMIT_MESSAGE" value="- added renderer&#10;- Added undo" />
</component>
</project>
README.md
+111
View File
@@ -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
__pycache__/Gui.cpython-311.pyc
BIN
View File
Binary file not shown.
__pycache__/Gui.cpython-312.pyc
BIN
View File
Binary file not shown.
__pycache__/main.cpython-311.pyc
BIN
View File
Binary file not shown.
__pycache__/main.cpython-312.pyc
BIN
View File
Binary file not shown.
agent.md
+219
View File
@@ -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
-849
View File
@@ -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
View File
@@ -1 +0,0 @@
pyside6-uic gui.ui > Gui.py -g python
doc/flow.md
-35
View File
@@ -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
-3
View File
@@ -1,3 +0,0 @@
## Compile ui file
pyside6-uic gui.ui > Gui.py -g python
docs/render_view_plan.md
+253
View File
@@ -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/.DS_Store
Vendored
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/draw_widget2d.cpython-311.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/draw_widget_solve.cpython-311.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/draw_widget_solve.cpython-312.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/gl_widget.cpython-311.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/improved_sketcher.cpython-312.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/vtk_widget.cpython-311.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/vtk_widget.cpython-312.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/vysta_widget.cpython-311.pyc
BIN
View File
Binary file not shown.
drawing_modules/__pycache__/vysta_widget.cpython-312.pyc
BIN
View File
Binary file not shown.
drawing_modules/case.stl
BIN
View File
Binary file not shown.
drawing_modules/draw_widget2d.py
-916
View File
@@ -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/draw_widget_solve.py
-1098
View File
File diff suppressed because it is too large Load Diff
drawing_modules/gl_widget.py
-504
View File
@@ -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/improved_sketcher.py
-1702
View File
File diff suppressed because it is too large Load Diff
drawing_modules/sketcher_integration_example.py
-201
View File
@@ -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
-35
View File
@@ -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
-861
View File
@@ -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
-337
View File
@@ -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
-111
View File
@@ -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
+843 -525
View File
File diff suppressed because it is too large Load Diff
Gui.py → gui_ui.py
+514 -335
View File
File diff suppressed because it is too large Load Diff
main.py
-1478
View File
File diff suppressed because it is too large Load Diff
main_backup.py
-851
View File
@@ -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()
memory.db
View File
mesh_modules/3d_placeholder_model.stl
BIN
View File
Binary file not shown.
mesh_modules/__pycache__/interactor_mesh.cpython-311.pyc
BIN
View File
Binary file not shown.
mesh_modules/__pycache__/interactor_mesh.cpython-312.pyc
BIN
View File
Binary file not shown.
mesh_modules/__pycache__/simple_mesh.cpython-311.pyc
BIN
View File
Binary file not shown.
mesh_modules/__pycache__/simple_mesh.cpython-312.pyc
BIN
View File
Binary file not shown.
mesh_modules/__pycache__/vesta_mesh.cpython-311.pyc
BIN
View File
Binary file not shown.
mesh_modules/__pycache__/vesta_mesh.cpython-312.pyc
BIN
View File
Binary file not shown.
mesh_modules/interactor_mesh.py
-43
View File
@@ -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
-213
View File
@@ -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
-119
View File
@@ -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
-5
View File
@@ -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
+72
View File
@@ -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
-61
View File
@@ -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
-26
View File
@@ -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/__pycache__/__init__.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/d2.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/d3.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/dn.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/ease.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/errors.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/mesh.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/progress.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/stl.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/text.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/units.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/__pycache__/util.cpython-312.pyc
BIN
View File
Binary file not shown.
sdf/d2.py
-390
View File
@@ -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/d3.py
-1666
View File
File diff suppressed because it is too large Load Diff
sdf/dn.py
-366
View File
@@ -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
-637
View File
@@ -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
-42
View File
@@ -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
-282
View File
@@ -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
-83
View File
@@ -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
-27
View File
@@ -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
-160
View File
@@ -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
-3
View File
@@ -1,3 +0,0 @@
import pint
units = pint.UnitRegistry()
sdf/util.py
-32
View File
@@ -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
+30
View File
@@ -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
+19
View File
@@ -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
+442
View File
@@ -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
+11
View File
@@ -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/kernel.py
+743
View File
@@ -0,0 +1,743 @@
"""
OpenCASCADE-based geometry kernel for Fluency CAD.
This module provides a concrete implementation of the geometry kernel
using OCP (OpenCASCADE Python bindings).
"""
from typing import List, Tuple, Optional, Any, Dict
import numpy as np
from fluency.geometry.base import (
GeometryKernel,
GeometryObject,
Point2D,
Point3D,
)
class OCCGeometryObject(GeometryObject):
"""Geometry object wrapper for OpenCASCADE shapes."""
def __init__(self, shape: Any = None, metadata: Optional[Dict] = None):
super().__init__(shape, metadata)
class OCGeometryKernel(GeometryKernel):
"""
OpenCASCADE-based geometry kernel implementation.
This kernel uses OCP (OpenCASCADE Python bindings) for all geometry
operations.
"""
def __init__(self) -> None:
self._tolerance: float = 0.001
self._mesh_tolerance: float = 0.1
def _get_shape(self, obj: GeometryObject) -> Any:
"""Extract the underlying OCC shape from a GeometryObject.
Returns *None* if the object carries no shape (e.g. an empty sketch) —
callers should check for None before using the result.
"""
if isinstance(obj, OCCGeometryObject):
if obj.shape is not None and hasattr(obj.shape, "wrapped"):
return obj.shape.wrapped
return obj.shape
# Non-OCCGeometryObject: return its shape if present, else None.
# (Use explicit identity/truth checks — some OCP TopoDS objects have a
# falsy __bool__, so ``obj.shape if obj.shape`` is unsafe.)
shape = getattr(obj, "shape", None)
return shape if shape is not None else None
def create_point(self, x: float, y: float) -> GeometryObject:
"""Create a 2D point."""
from OCP.gp import gp_Pnt
return OCCGeometryObject(gp_Pnt(x, y, 0))
def create_line(self, start: Point2D, end: Point2D) -> GeometryObject:
"""Create a 2D line segment."""
from OCP.gp import gp_Pnt
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeEdge
edge = BRepBuilderAPI_MakeEdge(
gp_Pnt(start.x, start.y, 0), gp_Pnt(end.x, end.y, 0)
).Edge()
return OCCGeometryObject(edge, {"type": "line"})
def create_circle(self, center: Point2D, radius: float) -> GeometryObject:
"""Create a 2D circle."""
from OCP.gp import gp_Pnt, gp_Dir, gp_Ax2, gp_Circ
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeEdge
circ = gp_Circ(
gp_Ax2(gp_Pnt(center.x, center.y, 0), gp_Dir(0, 0, 1)), radius
)
edge = BRepBuilderAPI_MakeEdge(circ).Edge()
return OCCGeometryObject(edge, {"type": "circle"})
def create_arc(
self, center: Point2D, radius: float, start_angle: float, end_angle: float
) -> GeometryObject:
"""Create a 2D arc."""
import math
from OCP.gp import gp_Pnt, gp_Dir, gp_Ax2, gp_Circ
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeEdge
start_rad = math.radians(start_angle)
end_rad = math.radians(end_angle)
circ = gp_Circ(
gp_Ax2(gp_Pnt(center.x, center.y, 0), gp_Dir(0, 0, 1)), radius
)
edge = BRepBuilderAPI_MakeEdge(circ, start_rad, end_rad).Edge()
return OCCGeometryObject(edge, {"type": "arc"})
def create_polygon(self, points: List[Point2D]) -> GeometryObject:
"""Create a closed polygon from points."""
from OCP.gp import gp_Pnt
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakePolygon
if len(points) < 3:
raise ValueError("Polygon requires at least 3 points")
mp = BRepBuilderAPI_MakePolygon()
for pt in points:
mp.Add(gp_Pnt(pt.x, pt.y, 0))
mp.Close()
return OCCGeometryObject(mp.Wire(), {"type": "polygon"})
def create_rectangle(
self, width: float, height: float, center: Optional[Point2D] = None
) -> GeometryObject:
"""Create a rectangle."""
from OCP.gp import gp_Pnt
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakePolygon
cx = center.x if center else 0
cy = center.y if center else 0
hw = width / 2.0
hh = height / 2.0
mp = BRepBuilderAPI_MakePolygon()
mp.Add(gp_Pnt(cx - hw, cy - hh, 0))
mp.Add(gp_Pnt(cx + hw, cy - hh, 0))
mp.Add(gp_Pnt(cx + hw, cy + hh, 0))
mp.Add(gp_Pnt(cx - hw, cy + hh, 0))
mp.Close()
return OCCGeometryObject(mp.Wire(), {"type": "rectangle"})
def extrude(
self,
sketch: GeometryObject,
height: float,
direction: Tuple[float, float, float] = (0, 0, 1),
symmetric: bool = False,
) -> GeometryObject:
"""Extrude a sketch face into a 3D solid along the sketch plane normal.
The sketch's plane normal is read from ``sketch.metadata["normal"]``
(set by ``OCCSketch.build_face_geometry``); it defaults to +Z for
legacy objects that don't carry one. *direction* is accepted for API
compatibility but ignored — the plane normal is authoritative. A
negative *height* extrudes against the normal.
"""
from OCP.gp import gp_Vec
from OCP.BRepPrimAPI import BRepPrimAPI_MakePrism
from OCP.BRepAlgoAPI import BRepAlgoAPI_Fuse
from OCP.TopoDS import TopoDS_Shape
# Defensive: figure out the actual shape from whatever the caller
# hands us, and surface a clear error if we can't get one.
if isinstance(sketch, OCCGeometryObject):
face = self._get_shape(sketch)
elif isinstance(sketch, TopoDS_Shape):
face = sketch
else:
face = self._get_shape(sketch)
if face is None:
raise ValueError(
"Cannot extrude: sketch has no geometry. "
"Draw a closed profile before extruding."
)
# If the wrapper class itself leaked through somehow, surface a
# clear error instead of letting BRepPrimAPI_MakePrism raise an
# opaque TypeError.
if isinstance(face, OCCGeometryObject):
raise ValueError(
"Cannot extrude: sketch geometry is a wrapper, not a shape. "
"This is a bug — please report it."
)
# ``face`` may be a TopoDS_Face (new path) or a compound/wire.
# If it's not already a face, build one.
face = self._ensure_face(face)
if face is None:
raise ValueError(
"Cannot extrude: sketch geometry is not a valid face. "
"Ensure the profile is closed (no open ends)."
)
normal = self._sketch_normal(sketch)
nx, ny, nz = normal
def _prism(h: float):
vec = gp_Vec(nx * h, ny * h, nz * h)
maker = BRepPrimAPI_MakePrism(face, vec, False, True)
maker.Build()
return maker.Shape()
if symmetric:
half = height / 2.0
pos = _prism(half)
neg = _prism(-half)
fuse = BRepAlgoAPI_Fuse(pos, neg)
fuse.Build()
solid = fuse.Shape()
else:
solid = _prism(height)
return OCCGeometryObject(solid, {"type": "extrusion", "normal": normal})
@staticmethod
def _sketch_normal(obj: GeometryObject) -> Tuple[float, float, float]:
"""Return the normal stored on a sketch-derived geometry object, else +Z."""
import numpy as np
meta = getattr(obj, "metadata", None) or {}
n = meta.get("normal")
if n is None:
return (0.0, 0.0, 1.0)
arr = np.asarray(n, dtype=float)
norm = float(np.linalg.norm(arr))
if norm < 1e-12:
return (0.0, 0.0, 1.0)
arr = arr / norm
return (float(arr[0]), float(arr[1]), float(arr[2]))
@staticmethod
def _ensure_face(shape: Any) -> Any:
"""Return a ``TopoDS_Face`` from *shape*, or *None* if impossible.
If *shape* is already a face, return it unchanged; otherwise try to
build a planar face from it (wire/edge/compound). Returns *None* for
empty/invalid input so callers can surface a clear error instead of
feeding a non-face to ``BRepPrimAPI_MakePrism``.
"""
from OCP.TopoDS import TopoDS_Face
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeFace
if shape is None:
return None
if isinstance(shape, TopoDS_Face):
return shape
try:
maker = BRepBuilderAPI_MakeFace(shape, True)
maker.Build()
if maker.IsDone():
return maker.Face()
except Exception:
pass
return None
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 sketch face around an axis."""
import math
# Get the OCC shape directly (a TopoDS_Face for new sketch geometry).
shape = self._get_shape(sketch)
face = self._ensure_face(shape)
from OCP.gp import gp_Ax1, gp_Pnt, gp_Dir
from OCP.BRepPrimAPI import BRepPrimAPI_MakeRevol
# Revolve the face around the axis
revolve_axis = gp_Ax1(gp_Pnt(*origin), gp_Dir(*axis))
angle_rad = math.radians(angle)
revolver = BRepPrimAPI_MakeRevol(face, revolve_axis, angle_rad)
revolver.Build()
solid_shape = revolver.Shape()
return OCCGeometryObject(solid_shape, {"type": "revolution"})
def loft(self, profiles: List[GeometryObject], ruled: bool = False) -> GeometryObject:
"""Create a loft between multiple profiles."""
from OCP.BRepOffsetAPI import BRepOffsetAPI_ThruSections
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_WIRE
from OCP.TopoDS import TopoDS
if len(profiles) < 2:
raise ValueError("Loft requires at least 2 profiles")
loft_maker = BRepOffsetAPI_ThruSections(True, ruled)
for profile in profiles:
shape = self._get_shape(profile)
explorer = TopExp_Explorer(shape, TopAbs_WIRE)
while explorer.More():
wire = TopoDS.Wire_s(explorer.Current())
loft_maker.AddWire(wire)
explorer.Next()
loft_maker.Build()
solid = loft_maker.Shape()
return OCCGeometryObject(solid, {"type": "loft"})
def sweep(
self, profile: GeometryObject, path: GeometryObject, is_frenet: bool = False
) -> GeometryObject:
"""Sweep a profile along a path."""
from OCP.BRepOffsetAPI import BRepOffsetAPI_MakePipeShell
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_WIRE
from OCP.TopoDS import TopoDS
profile_shape = self._get_shape(profile)
path_shape = self._get_shape(path)
def _first_wire(shape):
exp = TopExp_Explorer(shape, TopAbs_WIRE)
if exp.More():
return TopoDS.Wire_s(exp.Current())
raise ValueError("No wire found in shape for sweep")
profile_wire = _first_wire(profile_shape)
path_wire = _first_wire(path_shape)
pipe = BRepOffsetAPI_MakePipeShell(path_wire)
pipe.Add(profile_wire, False, False)
if is_frenet:
pipe.SetMode(True)
pipe.Build()
solid = pipe.Shape()
return OCCGeometryObject(solid, {"type": "sweep"})
def boolean_union(self, *bodies: GeometryObject) -> GeometryObject:
"""Union multiple bodies."""
if len(bodies) < 2:
return bodies[0] if bodies else OCCGeometryObject(None)
result = self._get_shape(bodies[0])
for body in bodies[1:]:
shape = self._get_shape(body)
from OCP.BRepAlgoAPI import BRepAlgoAPI_Fuse
fuse = BRepAlgoAPI_Fuse(result, shape)
fuse.Build()
result = fuse.Shape()
return OCCGeometryObject(result, {"type": "union"})
def boolean_difference(self, base: GeometryObject, tool: GeometryObject) -> GeometryObject:
"""Subtract tool from base."""
base_shape = self._get_shape(base)
tool_shape = self._get_shape(tool)
from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut
cut = BRepAlgoAPI_Cut(base_shape, tool_shape)
cut.Build()
return OCCGeometryObject(cut.Shape(), {"type": "difference"})
def boolean_intersection(self, body1: GeometryObject, body2: GeometryObject) -> GeometryObject:
"""Intersect two bodies."""
shape1 = self._get_shape(body1)
shape2 = self._get_shape(body2)
from OCP.BRepAlgoAPI import BRepAlgoAPI_Common
common = BRepAlgoAPI_Common(shape1, shape2)
common.Build()
return OCCGeometryObject(common.Shape(), {"type": "intersection"})
def fillet(
self, body: GeometryObject, radius: float, edges: Optional[List[Any]] = None
) -> GeometryObject:
"""Apply fillet to edges."""
shape = self._get_shape(body)
from OCP.BRepFilletAPI import BRepFilletAPI_MakeFillet
fillet = BRepFilletAPI_MakeFillet(shape)
if edges:
for edge in edges:
fillet.Add(radius, edge)
else:
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_EDGE
explorer = TopExp_Explorer(shape, TopAbs_EDGE)
while explorer.More():
fillet.Add(radius, explorer.Current())
explorer.Next()
fillet.Build()
return OCCGeometryObject(fillet.Shape(), {"type": "fillet"})
def chamfer(
self, body: GeometryObject, size: float, edges: Optional[List[Any]] = None
) -> GeometryObject:
"""Apply chamfer to edges."""
shape = self._get_shape(body)
from OCP.BRepFilletAPI import BRepFilletAPI_MakeChamfer
chamfer = BRepFilletAPI_MakeChamfer(shape)
if edges:
for edge in edges:
chamfer.Add(size, edge)
else:
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_EDGE
explorer = TopExp_Explorer(shape, TopAbs_EDGE)
while explorer.More():
chamfer.Add(size, explorer.Current())
explorer.Next()
chamfer.Build()
return OCCGeometryObject(chamfer.Shape(), {"type": "chamfer"})
def shell(
self, body: GeometryObject, thickness: float, faces_to_remove: Optional[List[Any]] = None
) -> GeometryObject:
"""Create a shell (hollow body)."""
shape = self._get_shape(body)
from OCP.BRepOffsetAPI import BRepOffsetAPI_MakeThickSolid
from OCP.TopTools import TopTools_ListOfShape
faces_list = TopTools_ListOfShape()
if faces_to_remove:
for face in faces_to_remove:
faces_list.Append(face)
shell_maker = BRepOffsetAPI_MakeThickSolid()
shell_maker.MakeThickSolidByJoin(shape, faces_list, thickness, 0.001)
shell_maker.Build()
return OCCGeometryObject(shell_maker.Shape(), {"type": "shell"})
def offset(self, face: GeometryObject, distance: float) -> GeometryObject:
"""Offset a face or surface."""
shape = self._get_shape(face)
from OCP.BRepOffsetAPI import BRepOffsetAPI_MakeOffset
offset_maker = BRepOffsetAPI_MakeOffset(shape, False)
offset_maker.Perform(distance)
return OCCGeometryObject(offset_maker.Shape(), {"type": "offset"})
def translate(self, body: GeometryObject, vector: Tuple[float, float, float]) -> GeometryObject:
"""Translate a body."""
shape = self._get_shape(body)
from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform
from OCP.gp import gp_Trsf, gp_Vec
transform = gp_Trsf()
transform.SetTranslation(gp_Vec(*vector))
transformer = BRepBuilderAPI_Transform(shape, transform)
return OCCGeometryObject(transformer.Shape(), {"type": "translated"})
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."""
import math
shape = self._get_shape(body)
from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform
from OCP.gp import gp_Trsf, gp_Ax1, gp_Pnt, gp_Dir
ax1 = gp_Ax1(gp_Pnt(*origin), gp_Dir(*axis))
transform = gp_Trsf()
transform.SetRotation(ax1, angle)
transformer = BRepBuilderAPI_Transform(shape, transform)
return OCCGeometryObject(transformer.Shape(), {"type": "rotated"})
def scale(self, body: GeometryObject, factor: float) -> GeometryObject:
"""Scale a body uniformly."""
shape = self._get_shape(body)
from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform
from OCP.gp import gp_Trsf
transform = gp_Trsf()
transform.SetScale(factor)
transformer = BRepBuilderAPI_Transform(shape, transform)
return OCCGeometryObject(transformer.Shape(), {"type": "scaled"})
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."""
shape = self._get_shape(body)
from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform
from OCP.gp import gp_Trsf, gp_Ax2, gp_Pnt, gp_Dir
ax2 = gp_Ax2(gp_Pnt(*plane_origin), gp_Dir(*plane_normal))
transform = gp_Trsf()
transform.SetMirror(ax2)
transformer = BRepBuilderAPI_Transform(shape, transform)
return OCCGeometryObject(transformer.Shape(), {"type": "mirrored"})
def export_step(self, body: GeometryObject, filepath: str, schema: str = "AP214") -> bool:
"""Export to STEP format."""
try:
shape = self._get_shape(body)
from OCP.STEPControl import STEPControl_Writer, STEPControl_AsIs
from OCP.Interface import Interface_Static
writer = STEPControl_Writer()
if schema == "AP214":
Interface_Static.SetCVal_s("write.step.schema", "AP214")
elif schema == "AP203":
Interface_Static.SetCVal_s("write.step.schema", "AP203")
writer.Transfer(shape, STEPControl_AsIs)
return writer.Write(filepath)
except Exception as e:
print(f"STEP export error: {e}")
return False
def export_iges(self, body: GeometryObject, filepath: str) -> bool:
"""Export to IGES format."""
try:
shape = self._get_shape(body)
from OCP.IGESControl import IGESControl_Writer
from OCP.Interface import Interface_Static
Interface_Static.SetCVal_s("write.iges.schema", "5.3")
writer = IGESControl_Writer()
writer.AddShape(shape)
return writer.Write(filepath)
except Exception as e:
print(f"IGES export error: {e}")
return False
def export_stl(
self, body: GeometryObject, filepath: str, tolerance: float = 0.1, ascii_mode: bool = False
) -> bool:
"""Export to STL format."""
try:
shape = self._get_shape(body)
from OCP.StlAPI import StlAPI_Writer
from OCP.BRepMesh import BRepMesh_IncrementalMesh
mesh = BRepMesh_IncrementalMesh(shape, tolerance)
mesh.Perform()
writer = StlAPI_Writer()
writer.ASCIIMode = ascii_mode
return writer.Write(shape, filepath)
except Exception as e:
print(f"STL export error: {e}")
return False
def import_step(self, filepath: str) -> GeometryObject:
"""Import from STEP format."""
from OCP.STEPControl import STEPControl_Reader
from OCP.IFSelect import IFSelect_RetDone
reader = STEPControl_Reader()
status = reader.ReadFile(filepath)
if status != IFSelect_RetDone:
raise ValueError(f"Failed to read STEP file: {filepath}")
reader.TransferRoots()
shape = reader.OneShape()
return OCCGeometryObject(shape, {"type": "imported_step"})
def import_iges(self, filepath: str) -> GeometryObject:
"""Import from IGES format."""
from OCP.IGESControl import IGESControl_Reader
from OCP.IFSelect import IFSelect_RetDone
reader = IGESControl_Reader()
status = reader.ReadFile(filepath)
if status != IFSelect_RetDone:
raise ValueError(f"Failed to read IGES file: {filepath}")
reader.TransferRoots()
shape = reader.OneShape()
return OCCGeometryObject(shape, {"type": "imported_iges"})
def get_mesh(
self, body: GeometryObject, tolerance: float = 0.1
) -> Tuple[np.ndarray, np.ndarray]:
"""Get triangulated mesh for rendering."""
shape = self._get_shape(body)
from OCP.BRepMesh import BRepMesh_IncrementalMesh
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_FACE
from OCP.BRep import BRep_Tool
from OCP.TopLoc import TopLoc_Location
# Use finer angular deflection (0.15 rad ≈ 24 segments/circle) so
# curved surfaces like cylinders render smoothly instead of faceted.
mesh = BRepMesh_IncrementalMesh(shape, tolerance, False, 0.15, True)
mesh.Perform()
vertices_list: List[List[float]] = []
faces_list: List[List[int]] = []
vertex_offset = 0
from OCP.TopoDS import TopoDS
from OCP.TopAbs import TopAbs_Orientation
explorer = TopExp_Explorer(shape, TopAbs_FACE)
while explorer.More():
face = TopoDS.Face_s(explorer.Current())
location = TopLoc_Location()
triangulation = BRep_Tool.Triangulation_s(face, location)
if triangulation is not None:
n_vertices = triangulation.NbNodes()
for i in range(1, n_vertices + 1):
p = triangulation.Node(i)
vertices_list.append([p.X(), p.Y(), p.Z()])
n_triangles = triangulation.NbTriangles()
# REVERSED faces store triangle winding in the natural (surface)
# orientation — we must flip it so the computed normals point
# outward (away from solid interior). TopAbs_REVERSED = 1.
reverse_winding = face.Orientation() == TopAbs_Orientation.TopAbs_REVERSED
for i in range(1, n_triangles + 1):
tri = triangulation.Triangle(i)
v0, v1, v2 = (
tri.Value(1) - 1 + vertex_offset,
tri.Value(2) - 1 + vertex_offset,
tri.Value(3) - 1 + vertex_offset,
)
if reverse_winding:
# Swap last two vertices to flip winding direction.
v1, v2 = v2, v1
faces_list.append([v0, v1, v2])
vertex_offset += n_vertices
explorer.Next()
return np.array(vertices_list, dtype=np.float32), np.array(faces_list, dtype=np.int32)
def get_edges(self, body: GeometryObject) -> Tuple[np.ndarray, np.ndarray]:
"""Get edge wireframe for rendering."""
shape = self._get_shape(body)
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_EDGE
from OCP.BRep import BRep_Tool
from OCP.TopLoc import TopLoc_Location
from OCP.BRepAdaptor import BRepAdaptor_Curve
from OCP.GeomAbs import GeomAbs_Line, GeomAbs_Circle, GeomAbs_Ellipse, GeomAbs_BSplineCurve
vertices_list: List[List[float]] = []
edges_list: List[List[int]] = []
vertex_offset = 0
def discretize_edge(edge: Any, num_points: int = 20) -> List[List[float]]:
curve = BRepAdaptor_Curve(edge)
curve_type = curve.GetType()
points = []
if curve_type == GeomAbs_Line:
first = curve.FirstParameter()
last = curve.LastParameter()
p1 = curve.Value(first)
p2 = curve.Value(last)
points = [[p1.X(), p1.Y(), p1.Z()], [p2.X(), p2.Y(), p2.Z()]]
else:
first = curve.FirstParameter()
last = curve.LastParameter()
for i in range(num_points + 1):
t = first + (last - first) * i / num_points
p = curve.Value(t)
points.append([p.X(), p.Y(), p.Z()])
return points
explorer = TopExp_Explorer(shape, TopAbs_EDGE)
while explorer.More():
from OCP.TopoDS import TopoDS
edge = TopoDS.Edge_s(explorer.Current())
edge_points = discretize_edge(edge)
for i, pt in enumerate(edge_points):
vertices_list.append(pt)
if i < len(edge_points) - 1:
edges_list.append([vertex_offset + i, vertex_offset + i + 1])
vertex_offset += len(edge_points)
explorer.Next()
return np.array(vertices_list, dtype=np.float32), np.array(edges_list, dtype=np.int32)
def get_bounding_box(self, body: GeometryObject) -> Tuple[Point3D, Point3D]:
"""Get the bounding box of a body."""
shape = self._get_shape(body)
from OCP.Bnd import Bnd_Box
from OCP.BRepBndLib import BRepBndLib
bbox = Bnd_Box()
BRepBndLib.AddClose_s(shape, bbox)
xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
return Point3D(xmin, ymin, zmin), Point3D(xmax, ymax, zmax)
def get_volume(self, body: GeometryObject) -> float:
"""Calculate the volume of a solid body."""
shape = self._get_shape(body)
from OCP.GProp import GProp_GProps
from OCP.BRepGProp import BRepGProp
props = GProp_GProps()
BRepGProp.VolumeProperties_s(shape, props)
return props.Mass()
def get_surface_area(self, body: GeometryObject) -> float:
"""Calculate the surface area of a body."""
shape = self._get_shape(body)
from OCP.GProp import GProp_GProps
from OCP.BRepGProp import BRepGProp
props = GProp_GProps()
BRepGProp.SurfaceProperties_s(shape, props)
return props.Mass()
def get_center_of_mass(self, body: GeometryObject) -> Point3D:
"""Calculate the center of mass of a solid body."""
shape = self._get_shape(body)
from OCP.GProp import GProp_GProps
from OCP.BRepGProp import BRepGProp
props = GProp_GProps()
BRepGProp.VolumeProperties_s(shape, props)
cg = props.CentreOfMass()
return Point3D(cg.X(), cg.Y(), cg.Z())
src/fluency/geometry_occ/sketch.py
+1903
View File
File diff suppressed because it is too large Load Diff
src/fluency/io/__init__.py
+5
View File
@@ -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/io/project_io.py
+734
View File
@@ -0,0 +1,734 @@
"""Project save/load — ``.fluency`` ZIP files.
The on-disk format is a single ZIP archive:
project.json # project tree: components, sketches, bodies,
# workplanes, assemblies, connectors, view state
bodies/<id>.step # one STEP file per Body (BRep geometry)
sketches/<id>/meta.json # sketch entities + constraints (kept separately
# so a single huge sketch doesn't bloat the
# main project.json)
sketches/<id>/solved.step # the sketch's solved face geometry
Sketch constraint solving and 3D body geometry are both preserved by using
OpenCASCADE's native STEP exporter (which is lossless for BRep). Everything
else is JSON.
The :func:`save_project` function is the entry point used by the File menu.
The :func:`load_project` function returns a fully populated
:class:`fluency.models.Project` (with a fresh ``OCGeometryKernel``) and an
optional view-state dict that the main window can hand back to the renderer
to restore the camera.
"""
from __future__ import annotations
import json
import logging
import os
import shutil
import tempfile
import zipfile
from dataclasses import asdict, is_dataclass
from datetime import datetime
from typing import Any, Callable, Dict, List, Optional, Tuple
import numpy as np
from fluency.models.data_model import (
Assembly,
AssemblyComponent,
AssemblyConnection,
Body,
Component,
Connector,
Project,
Sketch,
Workplane,
)
from fluency.geometry_occ.kernel import OCCGeometryObject, OCGeometryKernel
from fluency.geometry_occ.sketch import OCCSketch
logger = logging.getLogger(__name__)
# ── JSON-friendly type coercion ─────────────────────────────────────────────
def _json_default(obj: Any) -> Any:
"""Default JSON encoder for numpy / dataclass / datetime values."""
if isinstance(obj, np.ndarray):
return obj.tolist()
if isinstance(obj, (datetime,)):
return obj.isoformat()
if isinstance(obj, (set, frozenset)):
return sorted(obj)
if isinstance(obj, tuple):
return list(obj)
if is_dataclass(obj):
return asdict(obj)
raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
def _to_json(data: Any) -> str:
return json.dumps(data, default=_json_default, indent=2, sort_keys=False)
def _coerce_listlike(value: Any) -> List[Any]:
"""Cast arrays / tuples / numpy arrays to plain lists for JSON friendliness."""
if value is None:
return []
if isinstance(value, np.ndarray):
return value.tolist()
if isinstance(value, (list, tuple)):
return [v for v in value]
return list(value)
def _to_3tuple(value: Any) -> Tuple[float, float, float]:
"""Coerce a saved 3-vector to a tuple of floats (for OCC)."""
if value is None:
return (0.0, 0.0, 0.0)
if isinstance(value, np.ndarray):
seq = value.tolist()
else:
seq = list(value)
if len(seq) < 3:
seq = list(seq) + [0.0] * (3 - len(seq))
return (float(seq[0]), float(seq[1]), float(seq[2]))
def _to_3vec(value: Any) -> np.ndarray:
"""Coerce a saved 3-vector to a 3-element numpy array."""
if isinstance(value, np.ndarray):
return value.astype(float).reshape(3)
if value is None:
return np.zeros(3, dtype=float)
seq = list(value)
if len(seq) < 3:
seq = list(seq) + [0.0] * (3 - len(seq))
return np.array([float(seq[0]), float(seq[1]), float(seq[2])], dtype=float)
def _to_mat3(value: Any) -> np.ndarray:
"""Coerce a saved 3×3 matrix (flat 9-list or nested) to np.ndarray."""
if isinstance(value, np.ndarray):
arr = value.astype(float)
return arr.reshape(3, 3)
if value is None:
return np.eye(3, dtype=float)
flat = list(np.asarray(value, dtype=float).flatten())
if len(flat) < 9:
flat = flat + [0.0] * (9 - len(flat))
return np.array(flat[:9], dtype=float).reshape(3, 3)
def _parse_iso(value: Optional[str]) -> datetime:
"""Parse an ISO-8601 timestamp, falling back to ``now`` on failure."""
if not value:
return datetime.now()
try:
return datetime.fromisoformat(value)
except (TypeError, ValueError):
return datetime.now()
# ── Model serialization (to_dict) ──────────────────────────────────────────
def _workplane_to_dict(wp: Workplane) -> Dict[str, Any]:
return {
"id": wp.id,
"name": wp.name,
"origin": list(wp.origin),
"normal": list(wp.normal),
"x_dir": list(wp.x_dir),
"visible": bool(wp.visible),
"created_at": wp.created_at.isoformat() if wp.created_at else None,
"modified_at": wp.modified_at.isoformat() if wp.modified_at else None,
}
def _workplane_from_dict(data: Dict[str, Any]) -> Workplane:
wp = Workplane(
id=data.get("id") or None, # Workplane generates uuid if None
name=data.get("name", "Untitled Workplane"),
origin=tuple(data.get("origin", (0.0, 0.0, 0.0))),
normal=tuple(data.get("normal", (0.0, 0.0, 1.0))),
x_dir=tuple(data.get("x_dir", (1.0, 0.0, 0.0))),
visible=bool(data.get("visible", True)),
)
wp.created_at = _parse_iso(data.get("created_at"))
wp.modified_at = _parse_iso(data.get("modified_at"))
return wp
def _body_to_dict(body: Body) -> Dict[str, Any]:
"""Body serialization. ``geometry_ref`` is set later by the ZIP writer
once the STEP file is written."""
return {
"id": body.id,
"name": body.name,
"source_sketch_id": body.source_sketch.id if body.source_sketch else None,
"source_operation": body.source_operation,
"extrude_length": body.extrude_length,
"extrude_symmetric": body.extrude_symmetric,
"extrude_invert": body.extrude_invert,
"extrude_cut": body.extrude_cut,
"extrude_union": body.extrude_union,
"extrude_through_all": body.extrude_through_all,
"extrude_face_index": body.extrude_face_index,
"extrude_target_body_id": body.extrude_target_body_id,
"position": _coerce_listlike(body.position),
"rotation": _coerce_listlike(body.rotation),
"color": list(body.color) if body.color else [0.2, 0.4, 0.8],
"opacity": float(body.opacity),
"visible": bool(body.visible),
"has_geometry": body.geometry is not None,
"geometry_ref": None, # filled in by save_project
"created_at": body.created_at.isoformat() if body.created_at else None,
"modified_at": body.modified_at.isoformat() if body.modified_at else None,
}
def _body_from_dict(
data: Dict[str, Any],
geometry_loader: Optional[Callable[[str], Optional[OCCGeometryObject]]] = None,
source_sketch: Optional[Sketch] = None,
) -> Body:
geometry: Optional[OCCGeometryObject] = None
if geometry_loader is not None and data.get("geometry_ref"):
geometry = geometry_loader(data["geometry_ref"]) if data.get("has_geometry") else None
body = Body(
id=data.get("id") or None,
name=data.get("name", "Untitled Body"),
geometry=geometry,
source_sketch=source_sketch,
source_operation=data.get("source_operation", "extrude"),
extrude_length=data.get("extrude_length"),
extrude_symmetric=bool(data.get("extrude_symmetric", False)),
extrude_invert=bool(data.get("extrude_invert", False)),
extrude_cut=bool(data.get("extrude_cut", False)),
extrude_union=bool(data.get("extrude_union", False)),
extrude_through_all=bool(data.get("extrude_through_all", False)),
extrude_face_index=data.get("extrude_face_index"),
extrude_target_body_id=data.get("extrude_target_body_id"),
position=_to_3vec(data.get("position")),
rotation=_to_mat3(data.get("rotation")),
color=tuple(data.get("color", [0.2, 0.4, 0.8])),
opacity=float(data.get("opacity", 1.0)),
visible=bool(data.get("visible", True)),
)
body.created_at = _parse_iso(data.get("created_at"))
body.modified_at = _parse_iso(data.get("modified_at"))
return body
def _sketch_to_dict(sketch: Sketch) -> Dict[str, Any]:
occ_dict: Optional[Dict[str, Any]] = None
if sketch.occ_sketch is not None and isinstance(sketch.occ_sketch, OCCSketch):
try:
occ_dict = sketch.occ_sketch.to_dict()
except Exception as exc:
logger.warning("Sketch %s occ_sketch.to_dict() failed: %s", sketch.id, exc)
return {
"id": sketch.id,
"name": sketch.name,
"workplane_origin": _coerce_listlike(sketch.workplane_origin),
"workplane_normal": _coerce_listlike(sketch.workplane_normal),
"workplane_x_dir": _coerce_listlike(sketch.workplane_x_dir),
"is_solved": bool(sketch.is_solved),
"is_fully_constrained": bool(sketch.is_fully_constrained),
"occ_sketch": occ_dict,
"has_geometry": sketch.geometry is not None,
"geometry_ref": None, # filled in by save_project
"created_at": sketch.created_at.isoformat() if sketch.created_at else None,
"modified_at": sketch.modified_at.isoformat() if sketch.modified_at else None,
}
def _sketch_from_dict(
data: Dict[str, Any],
geometry_loader: Optional[Callable[[str], Optional[OCCGeometryObject]]] = None,
) -> Sketch:
occ_dict = data.get("occ_sketch")
occ_sketch: Optional[OCCSketch] = None
if occ_dict is not None:
try:
occ_sketch = OCCSketch.from_dict(occ_dict)
except Exception as exc:
logger.warning("Sketch %s OCCSketch.from_dict() failed: %s", data.get("id"), exc)
occ_sketch = OCCSketch()
else:
occ_sketch = OCCSketch()
# Re-apply the workplane (from_dict already does this internally, but be
# defensive in case the saved dict didn't carry the workplane fields).
occ_sketch.set_workplane(
tuple(data.get("workplane_origin", (0.0, 0.0, 0.0))),
tuple(data.get("workplane_normal", (0.0, 0.0, 1.0))),
tuple(data.get("workplane_x_dir", (1.0, 0.0, 0.0))),
)
geometry: Optional[OCCGeometryObject] = None
if geometry_loader is not None and data.get("geometry_ref"):
geometry = geometry_loader(data["geometry_ref"]) if data.get("has_geometry") else None
sk = Sketch(
id=data.get("id") or None,
name=data.get("name", "Untitled Sketch"),
occ_sketch=occ_sketch,
geometry=geometry,
is_solved=bool(data.get("is_solved", False)),
is_fully_constrained=bool(data.get("is_fully_constrained", False)),
)
sk.workplane_origin = _to_3vec(data.get("workplane_origin"))
sk.workplane_normal = _to_3vec(data.get("workplane_normal"))
sk.workplane_x_dir = _to_3vec(data.get("workplane_x_dir"))
sk.apply_workplane()
sk.created_at = _parse_iso(data.get("created_at"))
sk.modified_at = _parse_iso(data.get("modified_at"))
return sk
def _component_to_dict(comp: Component) -> Dict[str, Any]:
return {
"id": comp.id,
"name": comp.name,
"description": comp.description,
"active_sketch": comp.active_sketch,
"active_workplane": comp.active_workplane,
"sketches": {sid: _sketch_to_dict(s) for sid, s in comp.sketches.items()},
"bodies": {bid: _body_to_dict(b) for bid, b in comp.bodies.items()},
"workplanes": {wid: _workplane_to_dict(w) for wid, w in comp.workplanes.items()},
"created_at": comp.created_at.isoformat() if comp.created_at else None,
"modified_at": comp.modified_at.isoformat() if comp.modified_at else None,
}
def _component_from_dict(
data: Dict[str, Any],
body_geometry_loader: Optional[Callable[[str], Optional[OCCGeometryObject]]] = None,
sketch_geometry_loader: Optional[Callable[[str], Optional[OCCGeometryObject]]] = None,
) -> Component:
comp = Component(
id=data.get("id") or None,
name=data.get("name", "Untitled Component"),
description=data.get("description", ""),
active_sketch=data.get("active_sketch"),
active_workplane=data.get("active_workplane"),
)
comp.created_at = _parse_iso(data.get("created_at"))
comp.modified_at = _parse_iso(data.get("modified_at"))
for wid, wp_data in (data.get("workplanes") or {}).items():
comp.workplanes[wid] = _workplane_from_dict(wp_data)
# Sketches first so bodies can reference them.
for sid, sk_data in (data.get("sketches") or {}).items():
comp.sketches[sid] = _sketch_from_dict(sk_data, sketch_geometry_loader)
for bid, body_data in (data.get("bodies") or {}).items():
src_sketch = None
src_id = body_data.get("source_sketch_id")
if src_id and src_id in comp.sketches:
src_sketch = comp.sketches[src_id]
comp.bodies[bid] = _body_from_dict(body_data, body_geometry_loader, src_sketch)
return comp
def _connector_to_dict(conn: Connector) -> Dict[str, Any]:
return {
"id": conn.id,
"name": conn.name,
"position": list(conn.position),
"normal": list(conn.normal),
"x_dir": list(conn.x_dir),
"axis_rotation": float(conn.axis_rotation),
"offset": float(conn.offset),
"assembly_component_id": conn.assembly_component_id,
"source_obj_id": conn.source_obj_id,
"partner_ac_id": conn.partner_ac_id,
"partner_connector_id": conn.partner_connector_id,
"is_grounded": bool(conn.is_grounded),
"is_invalid": bool(conn.is_invalid),
"created_at": conn.created_at.isoformat() if conn.created_at else None,
"modified_at": conn.modified_at.isoformat() if conn.modified_at else None,
}
def _connector_from_dict(data: Dict[str, Any]) -> Connector:
conn = Connector(
id=data.get("id") or None,
name=data.get("name", "Untitled Connector"),
position=_to_3tuple(data.get("position")),
normal=_to_3tuple(data.get("normal")),
x_dir=_to_3tuple(data.get("x_dir")),
axis_rotation=float(data.get("axis_rotation", 0.0)),
offset=float(data.get("offset", 0.0)),
assembly_component_id=data.get("assembly_component_id", ""),
source_obj_id=data.get("source_obj_id", ""),
)
conn.partner_ac_id = data.get("partner_ac_id")
conn.partner_connector_id = data.get("partner_connector_id")
conn.is_grounded = bool(data.get("is_grounded", False))
conn.is_invalid = bool(data.get("is_invalid", False))
conn.created_at = _parse_iso(data.get("created_at"))
conn.modified_at = _parse_iso(data.get("modified_at"))
return conn
def _assembly_component_to_dict(ac: AssemblyComponent) -> Dict[str, Any]:
return {
"id": ac.id,
"component_id": ac.component_id,
"name": ac.name,
"position": _coerce_listlike(ac.position),
"rotation": _coerce_listlike(ac.rotation),
"connectors": {cid: _connector_to_dict(c) for cid, c in ac.connectors.items()},
"created_at": ac.created_at.isoformat() if ac.created_at else None,
"modified_at": ac.modified_at.isoformat() if ac.modified_at else None,
}
def _assembly_component_from_dict(data: Dict[str, Any]) -> AssemblyComponent:
ac = AssemblyComponent(
id=data.get("id") or None,
component_id=data.get("component_id", ""),
name=data.get("name", "Untitled Instance"),
position=_to_3vec(data.get("position")),
rotation=_to_mat3(data.get("rotation")),
)
ac.created_at = _parse_iso(data.get("created_at"))
ac.modified_at = _parse_iso(data.get("modified_at"))
for cid, c_data in (data.get("connectors") or {}).items():
ac.connectors[cid] = _connector_from_dict(c_data)
return ac
def _assembly_connection_to_dict(c: AssemblyConnection) -> Dict[str, Any]:
return {
"id": c.id,
"first_ac_id": c.first_ac_id,
"second_ac_id": c.second_ac_id,
"first_connector_id": c.first_connector_id,
"second_connector_id": c.second_connector_id,
"created_at": c.created_at.isoformat() if c.created_at else None,
}
def _assembly_connection_from_dict(data: Dict[str, Any]) -> AssemblyConnection:
conn = AssemblyConnection(
id=data.get("id") or None,
first_ac_id=data.get("first_ac_id", ""),
second_ac_id=data.get("second_ac_id", ""),
first_connector_id=data.get("first_connector_id"),
second_connector_id=data.get("second_connector_id"),
)
conn.created_at = _parse_iso(data.get("created_at"))
return conn
def _assembly_to_dict(asm: Assembly) -> Dict[str, Any]:
return {
"id": asm.id,
"name": asm.name,
"active_assembly_component": asm.active_assembly_component,
"components": {cid: _assembly_component_to_dict(ac) for cid, ac in asm.components.items()},
"connections": [_assembly_connection_to_dict(c) for c in asm.connections],
"created_at": asm.created_at.isoformat() if asm.created_at else None,
"modified_at": asm.modified_at.isoformat() if asm.modified_at else None,
}
def _assembly_from_dict(data: Dict[str, Any]) -> Assembly:
asm = Assembly(
id=data.get("id") or None,
name=data.get("name", "Untitled Assembly"),
active_assembly_component=data.get("active_assembly_component"),
)
asm.created_at = _parse_iso(data.get("created_at"))
asm.modified_at = _parse_iso(data.get("modified_at"))
for cid, ac_data in (data.get("components") or {}).items():
asm.components[cid] = _assembly_component_from_dict(ac_data)
for c_data in (data.get("connections") or []):
asm.connections.append(_assembly_connection_from_dict(c_data))
return asm
def _project_to_dict(
project: Project,
view_state: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
return {
"format_version": 1,
"name": project.name,
"description": project.description,
"active_component": project.active_component,
"active_assembly": project.active_assembly,
"components": {cid: _component_to_dict(c) for cid, c in project.components.items()},
"assemblies": {aid: _assembly_to_dict(a) for aid, a in project.assemblies.items()},
"created_at": project.created_at.isoformat() if project.created_at else None,
"modified_at": project.modified_at.isoformat() if project.modified_at else None,
"view_state": view_state or {},
}
# ── Geometry (STEP) write/read helpers ─────────────────────────────────────
def _write_step_for_body(
kernel: OCGeometryKernel,
geometry: OCCGeometryObject,
) -> Optional[bytes]:
"""Serialize a single body geometry to a STEP byte string.
Returns *None* if OCC reports the shape is empty (so the ZIP can omit
the file and the body is restored as geometry-less). The temporary
file is created and immediately deleted; we never touch the user's
filesystem outside of ``tempfile``.
"""
fd, tmp_path = tempfile.mkstemp(suffix=".step")
os.close(fd)
try:
ok = kernel.export_step(geometry, tmp_path)
if not ok:
return None
with open(tmp_path, "rb") as f:
return f.read()
finally:
try:
os.unlink(tmp_path)
except OSError:
pass
def _read_step_bytes(
kernel: OCGeometryKernel,
data: bytes,
) -> Optional[OCCGeometryObject]:
"""Parse a STEP byte string back into an OCCGeometryObject."""
fd, tmp_path = tempfile.mkstemp(suffix=".step")
os.close(fd)
try:
with open(tmp_path, "wb") as f:
f.write(data)
geom = kernel.import_step(tmp_path)
return geom
except Exception as exc:
logger.warning("Failed to read STEP: %s", exc)
return None
finally:
try:
os.unlink(tmp_path)
except OSError:
pass
# ── Save / Load entry points ───────────────────────────────────────────────
def project_zip_path(path: str) -> str:
"""Return *path* with the ``.fluency`` extension added if missing."""
base, ext = os.path.splitext(path)
if ext.lower() == ".fluency":
return path
return base + ".fluency"
def save_project(
project: Project,
filepath: str,
view_state: Optional[Dict[str, Any]] = None,
kernel: Optional[OCGeometryKernel] = None,
) -> str:
"""Save *project* to a ``.fluency`` ZIP at *filepath*.
*view_state* (optional) is a free-form dict that the main window uses to
record camera position, active tab, etc. It is stored verbatim inside
``project.json`` under the ``view_state`` key.
*kernel* is the OCGeometryKernel to use for STEP export. A new one is
created if not provided (slightly slower startup, but never holds stale
state). Pass the app's kernel to keep one canonical instance.
Returns the actual file path that was written.
"""
filepath = project_zip_path(filepath)
kernel = kernel or OCGeometryKernel()
# Build the manifest in two passes:
# pass 1: serialize all metadata + collect body/sketches that need
# STEP files written alongside. We track the in-zip path of
# each STEP file in the body/sketches' ``geometry_ref`` slot.
# pass 2: write the ZIP, streaming each body/sketches's STEP data
# into its own archive member.
manifest = _project_to_dict(project, view_state)
# Per-body STEP files. Skipped if the body has no geometry.
body_files: List[Tuple[str, bytes]] = []
for comp_id, comp in project.components.items():
for body_id, body in comp.bodies.items():
if body.geometry is None:
continue
step_bytes = _write_step_for_body(kernel, body.geometry)
if step_bytes is None:
continue
arcname = f"bodies/{body_id}.step"
body_files.append((arcname, step_bytes))
manifest["components"][comp_id]["bodies"][body_id]["geometry_ref"] = arcname
# Per-sketch STEP files (solved face geometry).
sketch_files: List[Tuple[str, bytes]] = []
sketch_meta_files: List[Tuple[str, bytes]] = []
for comp_id, comp in project.components.items():
for sketch_id, sketch in comp.sketches.items():
# Save the OCCSketch state to its own JSON file so the
# main project.json stays compact.
occ = sketch.occ_sketch.to_dict() if sketch.occ_sketch is not None else None
meta = {
"id": sketch.id,
"name": sketch.name,
"workplane_origin": _coerce_listlike(sketch.workplane_origin),
"workplane_normal": _coerce_listlike(sketch.workplane_normal),
"workplane_x_dir": _coerce_listlike(sketch.workplane_x_dir),
"is_solved": bool(sketch.is_solved),
"is_fully_constrained": bool(sketch.is_fully_constrained),
"occ_sketch": occ,
}
meta_arc = f"sketches/{sketch_id}/meta.json"
sketch_meta_files.append((meta_arc, _to_json(meta).encode("utf-8")))
# Drop the heavy occ_sketch payload from the main manifest so
# the file is smaller and edits are localised.
manifest["components"][comp_id]["sketches"][sketch_id]["occ_sketch"] = None
manifest["components"][comp_id]["sketches"][sketch_id]["occ_sketch_ref"] = meta_arc
if sketch.geometry is None:
continue
step_bytes = _write_step_for_body(kernel, sketch.geometry)
if step_bytes is None:
continue
arcname = f"sketches/{sketch_id}/solved.step"
sketch_files.append((arcname, step_bytes))
manifest["components"][comp_id]["sketches"][sketch_id]["geometry_ref"] = arcname
# Write the ZIP. Use a temp file + rename so a partial write can't
# clobber an existing good file.
tmp_fd, tmp_path = tempfile.mkstemp(suffix=".fluency")
os.close(tmp_fd)
try:
with zipfile.ZipFile(tmp_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
zf.writestr("project.json", _to_json(manifest))
for arcname, data in body_files + sketch_files + sketch_meta_files:
zf.writestr(arcname, data)
# Atomic-ish replace.
shutil.move(tmp_path, filepath)
except Exception:
try:
os.unlink(tmp_path)
except OSError:
pass
raise
return filepath
def load_project(filepath: str) -> Tuple[Project, Dict[str, Any]]:
"""Load a project from a ``.fluency`` ZIP.
Returns ``(project, view_state)``. The caller is responsible for
handing *view_state* to the renderer (camera, etc.) and for re-rendering
the scene with the freshly-loaded bodies.
"""
if not os.path.exists(filepath):
raise FileNotFoundError(filepath)
kernel = OCGeometryKernel()
body_cache: Dict[str, Optional[OCCGeometryObject]] = {}
# Body geometry can be reused across bodies if the same STEP appears
# under multiple names (rare, but cheap to handle). We cache by zip
# member name.
def body_geometry_loader(member_name: str) -> Optional[OCCGeometryObject]:
if member_name in body_cache:
return body_cache[member_name]
try:
data = zipf.read(member_name)
except KeyError:
logger.warning("Body STEP missing in archive: %s", member_name)
body_cache[member_name] = None
return None
geom = _read_step_bytes(kernel, data)
body_cache[member_name] = geom
return geom
# Sketch geometry loader shares the same byte path. Sketches that have
# solved faces point at sketches/<id>/solved.step.
def sketch_geometry_loader(member_name: str) -> Optional[OCCGeometryObject]:
return body_geometry_loader(member_name)
with zipfile.ZipFile(filepath, "r") as zipf:
manifest_raw = zipf.read("project.json")
manifest = json.loads(manifest_raw.decode("utf-8"))
view_state: Dict[str, Any] = manifest.get("view_state") or {}
# If a sketch's occ_sketch is referenced as a separate file, read
# it in now and patch the manifest so _sketch_from_dict sees it.
for comp_id, comp_data in (manifest.get("components") or {}).items():
for sk_id, sk_data in (comp_data.get("sketches") or {}).items():
ref = sk_data.get("occ_sketch_ref")
if not ref:
continue
try:
meta_bytes = zipf.read(ref)
except KeyError:
logger.warning("Sketch meta missing in archive: %s", ref)
continue
meta = json.loads(meta_bytes.decode("utf-8"))
sk_data["occ_sketch"] = meta.get("occ_sketch")
# Workplane fields on the sketch-level file override the
# embedded ones (source of truth lives in the sidecar).
for k in ("workplane_origin", "workplane_normal", "workplane_x_dir",
"is_solved", "is_fully_constrained"):
if k in meta:
sk_data[k] = meta[k]
project = Project(
name=manifest.get("name", "Untitled Project"),
description=manifest.get("description", ""),
active_component=manifest.get("active_component"),
active_assembly=manifest.get("active_assembly"),
kernel=kernel,
)
project.file_path = filepath
project.created_at = _parse_iso(manifest.get("created_at"))
project.modified_at = _parse_iso(manifest.get("modified_at"))
for cid, c_data in (manifest.get("components") or {}).items():
project.components[cid] = _component_from_dict(
c_data,
body_geometry_loader=body_geometry_loader,
sketch_geometry_loader=sketch_geometry_loader,
)
for aid, a_data in (manifest.get("assemblies") or {}).items():
project.assemblies[aid] = _assembly_from_dict(a_data)
# After all components are loaded, re-wire connector partner ids so
# they point to the freshly-loaded AssemblyComponents. (The dict
# round-trip preserves the raw strings; we just make sure the partner
# ids are still present in the project so the assembly-move handler
# can follow the rigid-group graph.)
for asm in project.assemblies.values():
for conn in asm.connections:
if conn.first_connector_id and conn.first_ac_id in asm.components:
first_ac = asm.components[conn.first_ac_id]
if conn.first_connector_id in first_ac.connectors:
first_ac.connectors[conn.first_connector_id].is_grounded = True
if conn.second_connector_id and conn.second_ac_id in asm.components:
pass # already set in the connector itself
return project, view_state
src/fluency/main.py
+61
View File
@@ -0,0 +1,61 @@
"""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,
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",
"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
+15
View File
@@ -0,0 +1,15 @@
"""Models module."""
from fluency.models.data_model import (
Project,
Component,
Sketch,
Body,
)
__all__ = [
"Project",
"Component",
"Sketch",
"Body",
]
src/fluency/models/data_model.py
+802
View File
@@ -0,0 +1,802 @@
"""
Data models for Fluency CAD.
This module defines the core data structures for the CAD application
including projects, components, sketches, and bodies.
"""
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Any, Tuple
from datetime import datetime
import uuid
import numpy as np
from fluency.geometry.base import (
Point2D,
Point3D,
GeometryObject,
SketchInterface,
)
from fluency.geometry_occ.kernel import OCGeometryKernel, OCCGeometryObject
from fluency.geometry_occ.sketch import OCCSketch
@dataclass
class Workplane:
"""
An independent working plane (datum plane) not tied to a face.
Workplanes can be created at any time and serve as the foundation for
sketching and subsequent 3D operations (extrude, cut, revolve, etc.).
They are visible in the 3D view as a semi-transparent reference grid.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
name: str = "Untitled Workplane"
origin: Tuple[float, float, float] = (0.0, 0.0, 0.0)
normal: Tuple[float, float, float] = (0.0, 0.0, 1.0)
x_dir: Tuple[float, float, float] = (1.0, 0.0, 0.0)
# OCC AIS shape (visual plane) object id in the renderer
render_object: Any = None
visible: bool = True
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
def __post_init__(self):
# Normalise normal and x_dir on construction.
import numpy as np
n = np.asarray(self.normal, dtype=float)
n = n / np.linalg.norm(n)
x = np.asarray(self.x_dir, dtype=float)
# Remove any component of x along n, then renormalise.
x = x - np.dot(x, n) * n
x_norm = np.linalg.norm(x)
if x_norm < 1e-9:
fallback = np.array([1.0, 0.0, 0.0]) if abs(n[0]) < 0.9 else np.array([0.0, 1.0, 0.0])
x = fallback - np.dot(fallback, n) * n
x_norm = np.linalg.norm(x)
x = x / x_norm
y = np.cross(n, x)
y = y / np.linalg.norm(y)
self.normal = tuple(float(v) for v in n)
self.x_dir = tuple(float(v) for v in x)
self._y_dir = tuple(float(v) for v in y)
@property
def y_dir(self) -> Tuple[float, float, float]:
"""Derived in-plane Y axis (normal × x_dir)."""
return self._y_dir
def uv_to_world(self, u: float, v: float) -> Tuple[float, float, float]:
"""Map a UV point to 3D world coordinates on this plane."""
ox, oy, oz = self.origin
xx, xy, xz = self.x_dir
yx, yy, yz = self._y_dir
return (
ox + u * xx + v * yx,
oy + u * xy + v * yy,
oz + u * xz + v * yz,
)
def world_to_uv(self, p: Tuple[float, float, float]) -> Tuple[float, float]:
"""Map a 3D world point to UV coordinates on this plane."""
import numpy as np
ox, oy, oz = self.origin
v = np.array([p[0] - ox, p[1] - oy, p[2] - oz])
xd = np.array(self.x_dir, dtype=float)
yd = np.array(self._y_dir, dtype=float)
return (float(np.dot(v, xd)), float(np.dot(v, yd)))
@dataclass
class Sketch:
"""
2D sketch with constraints.
A sketch contains 2D geometry on a workplane that can be
extruded or revolved to create 3D bodies.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
name: str = "Untitled Sketch"
workplane_origin: np.ndarray = field(default_factory=lambda: np.array([0.0, 0.0, 0.0]))
workplane_normal: np.ndarray = field(default_factory=lambda: np.array([0.0, 0.0, 1.0]))
workplane_x_dir: np.ndarray = field(default_factory=lambda: np.array([1.0, 0.0, 0.0]))
occ_sketch: Optional[OCCSketch] = field(default_factory=OCCSketch)
geometry: Optional[OCCGeometryObject] = None
is_solved: bool = False
is_fully_constrained: bool = False
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
def set_workplane(
self,
origin: Tuple[float, float, float],
normal: Tuple[float, float, float],
x_dir: Tuple[float, float, float],
) -> None:
"""Set this sketch's 3D workplane and sync it to the OCC sketch.
Call this when the sketch is placed on a face/datum plane. UV
coordinates are unchanged; only their world mapping moves.
"""
self.workplane_origin = np.asarray(origin, dtype=float)
self.workplane_normal = np.asarray(normal, dtype=float)
self.workplane_x_dir = np.asarray(x_dir, dtype=float)
self.apply_workplane()
self.modified_at = datetime.now()
def apply_workplane(self) -> None:
"""Push the stored workplane fields into the underlying OCCSketch."""
if self.occ_sketch is not None:
self.occ_sketch.set_workplane(
tuple(self.workplane_origin.tolist()),
tuple(self.workplane_normal.tolist()),
tuple(self.workplane_x_dir.tolist()),
)
def add_point(self, x: float, y: float) -> Any:
"""Add a point to the sketch."""
self.modified_at = datetime.now()
self.is_solved = False
if self.occ_sketch:
return self.occ_sketch.add_point(x, y)
return None
def add_line(self, start: Any, end: Any) -> Any:
"""Add a line to the sketch."""
self.modified_at = datetime.now()
self.is_solved = False
if self.occ_sketch:
return self.occ_sketch.add_line(start, end)
return None
def add_circle(self, center: Any, radius: float) -> Any:
"""Add a circle to the sketch."""
self.modified_at = datetime.now()
self.is_solved = False
if self.occ_sketch:
return self.occ_sketch.add_circle(center, radius)
return None
def add_rectangle(self, corner1: tuple, corner2: tuple) -> List[Any]:
"""Add a rectangle to the sketch."""
self.modified_at = datetime.now()
self.is_solved = False
if self.occ_sketch:
return self.occ_sketch.add_rectangle(corner1, corner2)
return []
def solve(self) -> bool:
"""Solve all constraints."""
if self.occ_sketch:
result = self.occ_sketch.solve()
self.is_solved = result
self.is_fully_constrained = self.occ_sketch.is_fully_constrained()
self.modified_at = datetime.now()
return result
return False
def get_geometry(self) -> Optional[GeometryObject]:
"""Get the solved geometry."""
if self.occ_sketch:
return self.occ_sketch.get_geometry()
return None
def get_polygon_points(self) -> List[Point2D]:
"""Get ordered polygon points."""
if self.occ_sketch:
return self.occ_sketch.get_polygon_points()
return []
def clear(self) -> None:
"""Clear all geometry."""
if self.occ_sketch:
self.occ_sketch.clear()
self.geometry = None
self.is_solved = False
self.is_fully_constrained = False
self.modified_at = datetime.now()
@dataclass
class Body:
"""
3D solid body.
A body is created from a sketch through operations like
extrude, revolve, loft, or sweep.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
name: str = "Untitled Body"
geometry: Optional[OCCGeometryObject] = None
source_sketch: Optional[Sketch] = None
source_operation: str = "extrude"
# Re-extrusion parameters — stored so the body can be rebuilt from
# its source sketch when the sketch is edited. None means the body
# was not created by an extrude-type operation and cannot be auto-
# rebuilt.
extrude_length: Optional[float] = None
extrude_symmetric: bool = False
extrude_invert: bool = False
extrude_cut: bool = False
extrude_union: bool = False
extrude_through_all: bool = False
extrude_face_index: Optional[int] = None # which sketch face was selected
extrude_target_body_id: Optional[str] = None # for cut/union: target body id
needs_update: bool = False # True when source sketch changed since last extrude
position: np.ndarray = field(default_factory=lambda: np.array([0.0, 0.0, 0.0]))
rotation: np.ndarray = field(default_factory=lambda: np.eye(3))
color: tuple = (0.2, 0.4, 0.8)
opacity: float = 1.0
visible: bool = True
render_object: Any = None
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
def get_mesh(self, kernel: OCGeometryKernel, tolerance: float = 0.1) -> tuple:
"""Get mesh for rendering."""
if self.geometry and kernel:
return kernel.get_mesh(self.geometry, tolerance)
return np.array([]), np.array([])
def get_edges(self, kernel: OCGeometryKernel) -> tuple:
"""Get edges for wireframe rendering."""
if self.geometry and kernel:
return kernel.get_edges(self.geometry)
return np.array([]), np.array([])
@dataclass
class Component:
"""
Component containing sketches and bodies.
A component is a logical grouping of geometry, similar to
a part in a CAD system.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
name: str = "Untitled Component"
description: str = ""
sketches: Dict[str, Sketch] = field(default_factory=dict)
bodies: Dict[str, Body] = field(default_factory=dict)
workplanes: Dict[str, Workplane] = field(default_factory=dict)
active_sketch: Optional[str] = None
active_workplane: Optional[str] = None
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
def add_workplane(self, workplane: Optional[Workplane] = None) -> Workplane:
"""Add an independent workplane to the component."""
if workplane is None:
workplane = Workplane(name=f"Workplane {len(self.workplanes) + 1}")
self.workplanes[workplane.id] = workplane
if self.active_workplane is None:
self.active_workplane = workplane.id
self.modified_at = datetime.now()
return workplane
def remove_workplane(self, wp_id: str) -> bool:
"""Remove a workplane from the component."""
if wp_id in self.workplanes:
del self.workplanes[wp_id]
if self.active_workplane == wp_id:
self.active_workplane = next(iter(self.workplanes.keys()), None)
self.modified_at = datetime.now()
return True
return False
def add_sketch(self, sketch: Optional[Sketch] = None) -> Sketch:
"""Add a sketch to the component."""
if sketch is None:
sketch = Sketch(name=f"Sketch {len(self.sketches) + 1}")
self.sketches[sketch.id] = sketch
self.modified_at = datetime.now()
return sketch
def add_body(self, body: Optional[Body] = None) -> Body:
"""Add a body to the component."""
if body is None:
body = Body(name=f"Body {len(self.bodies) + 1}")
self.bodies[body.id] = body
self.modified_at = datetime.now()
return body
def remove_sketch(self, sketch_id: str) -> bool:
"""Remove a sketch from the component."""
if sketch_id in self.sketches:
del self.sketches[sketch_id]
if self.active_sketch == sketch_id:
self.active_sketch = None
self.modified_at = datetime.now()
return True
return False
def remove_body(self, body_id: str) -> bool:
"""Remove a body from the component."""
if body_id in self.bodies:
del self.bodies[body_id]
self.modified_at = datetime.now()
return True
return False
def get_active_sketch(self) -> Optional[Sketch]:
"""Get the currently active sketch."""
if self.active_sketch and self.active_sketch in self.sketches:
return self.sketches[self.active_sketch]
return None
def set_active_sketch(self, sketch_id: Optional[str]) -> None:
"""Set the active sketch."""
self.active_sketch = sketch_id
self.modified_at = datetime.now()
@dataclass
class Connector:
"""
A connection point on an assembly component instance.
Stores the position and orientation of a connection point
(e.g. a hole center, face midpoint, or edge point) that will
later be used by the SolveSpace solver to mate components.
The *normal* defines the connection axis direction (e.g. the
hole axis for a screw connection).
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
name: str = "Untitled Connector"
# 3D position of the connection point (component-local coords).
# Transformed to world coords at render time using the parent
# AssemblyComponent's position/rotation, so connectors move with
# their component automatically.
position: Tuple[float, float, float] = (0.0, 0.0, 0.0)
# Normal direction of the connection (e.g. hole axis) in local coords.
normal: Tuple[float, float, float] = (0.0, 0.0, 1.0)
# In-plane X direction for defining the reference frame (local coords).
x_dir: Tuple[float, float, float] = (1.0, 0.0, 0.0)
# Rotation around the normal axis (degrees).
axis_rotation: float = 0.0
# Offset distance along the normal.
offset: float = 0.0
# Which AssemblyComponent this connector belongs to.
assembly_component_id: str = ""
# Which body/face this connector was placed on (renderer obj_id).
source_obj_id: str = ""
# --- Rigid-group pairing (set when two connectors are mated) ---
# The id of the partner AssemblyComponent this connector is mated to.
# The FIRST-picked component is the grounded reference of the pair;
# 'is_grounded' marks that side so the move handler knows which half
# is the fixed frame of the rigid group.
partner_ac_id: Optional[str] = None
# The id of the partner Connector on the partner component.
partner_connector_id: Optional[str] = None
# True on the first-picked (grounded) connector of a mated pair.
is_grounded: bool = False
# True when the source geometry this connector was placed on has
# changed or disappeared — the connector needs re-placement.
is_invalid: bool = False
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
@dataclass
class AssemblyComponent:
"""
An instance of a component within an assembly.
References a component in the project and stores its relative
position and rotation for placement within the assembly.
Holds connectors that define connection points for the
SolveSpace solver.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
component_id: str = ""
name: str = "Untitled Instance"
# Position and orientation relative to the assembly origin.
position: np.ndarray = field(default_factory=lambda: np.array([0.0, 0.0, 0.0]))
rotation: np.ndarray = field(default_factory=lambda: np.eye(3))
# Connectors defined on this component instance.
connectors: Dict[str, Connector] = field(default_factory=dict)
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
def add_connector(
self,
position: Tuple[float, float, float],
normal: Tuple[float, float, float],
x_dir: Tuple[float, float, float],
source_obj_id: str = "",
name: Optional[str] = None,
) -> Connector:
"""Add a connector to this component instance."""
conn = Connector(
name=name or f"Connector {len(self.connectors) + 1}",
position=position,
normal=normal,
x_dir=x_dir,
assembly_component_id=self.id,
source_obj_id=source_obj_id,
)
self.connectors[conn.id] = conn
self.modified_at = datetime.now()
return conn
def remove_connector(self, connector_id: str) -> bool:
"""Remove a connector from this component instance."""
if connector_id in self.connectors:
del self.connectors[connector_id]
self.modified_at = datetime.now()
return True
return False
@dataclass
class AssemblyConnection:
"""A mated connector pair linking two AssemblyComponents.
Records which component is the grounded reference (``first_ac_id``) and
which was solved against it (``second_ac_id``), plus the partner
connector ids so the linkage can be followed / removed symmetrically.
Used by the assembly-move handler to propagate translations across the
rigid group.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
first_ac_id: str = "" # grounded reference side
second_ac_id: str = "" # solved side
first_connector_id: Optional[str] = None
second_connector_id: Optional[str] = None
created_at: datetime = field(default_factory=datetime.now)
@dataclass
class Assembly:
"""
An assembly of multiple component instances.
An assembly groups component instances with relative positions,
ready for constraint solving and joint definition between them.
Components can be instanced multiple times, each at a different
position and rotation.
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
name: str = "Untitled Assembly"
components: Dict[str, AssemblyComponent] = field(default_factory=dict)
active_assembly_component: Optional[str] = None
# Mated connector pairs — each entry links two AssemblyComponents so the
# assembly-move handler can propagate rigid-group translations. The
# 'first_ac_id' side is the grounded reference of the pair.
connections: List["AssemblyConnection"] = field(default_factory=list)
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
def add_connection(self, first_ac_id: str, second_ac_id: str) -> "AssemblyConnection":
"""Record a mated connector pair between two component instances.
The first-picked component (``first_ac_id``) is treated as the
grounded reference of the pair. Guards against duplicate entries.
Returns the AssemblyConnection for further bookkeeping.
"""
# Guard: deduplicate — same pair in either order
for c in self.connections:
if (c.first_ac_id == first_ac_id and c.second_ac_id == second_ac_id) or \
(c.first_ac_id == second_ac_id and c.second_ac_id == first_ac_id):
return c
conn = AssemblyConnection(
first_ac_id=first_ac_id,
second_ac_id=second_ac_id,
)
self.connections.append(conn)
self.modified_at = datetime.now()
return conn
def remove_connections_for(self, ac_id: str) -> None:
"""Drop every connection that involves *ac_id* (e.g. on removal)."""
self.connections = [
c for c in self.connections
if c.first_ac_id != ac_id and c.second_ac_id != ac_id
]
def get_rigid_group(self, ac_id: str) -> List[str]:
"""Return ids of all components rigidly linked to *ac_id* (BFS).
Includes *ac_id* itself. Two components are linked when a mated
connector pair (in ``connections``) joins them; linkage is
transitive, so the whole connected subgraph forms one rigid group.
"""
if ac_id not in self.components:
return []
# Build adjacency from the connection list.
adj: Dict[str, List[str]] = {}
for c in self.connections:
adj.setdefault(c.first_ac_id, []).append(c.second_ac_id)
adj.setdefault(c.second_ac_id, []).append(c.first_ac_id)
seen: List[str] = []
queue: List[str] = [ac_id]
while queue:
cur = queue.pop(0)
if cur in seen:
continue
seen.append(cur)
for nb in adj.get(cur, []):
if nb not in seen:
queue.append(nb)
return seen
def is_grounded_reference(self, ac_id: str) -> bool:
"""True if *ac_id* is the grounded (first-picked) side of any pair."""
return any(c.first_ac_id == ac_id for c in self.connections)
def get_group_size(self, ac_id: str) -> int:
"""Number of components rigidly linked to *ac_id* (including itself)."""
return len(self.get_rigid_group(ac_id))
def add_component_instance(
self, component_id: str, name: Optional[str] = None
) -> AssemblyComponent:
"""Add a component instance to the assembly.
Returns the newly created AssemblyComponent. The same
component can be added multiple times (multiple instances).
"""
ac = AssemblyComponent(
component_id=component_id,
name=name or f"Instance {len(self.components) + 1}",
)
self.components[ac.id] = ac
if self.active_assembly_component is None:
self.active_assembly_component = ac.id
self.modified_at = datetime.now()
return ac
def remove_component_instance(self, assembly_component_id: str) -> bool:
"""Remove a component instance from the assembly."""
if assembly_component_id in self.components:
del self.components[assembly_component_id]
# Also drop any mated-connector links that referenced this
# instance — otherwise stale connection edges would remain in
# the rigid-group graph and point at a missing component.
self.remove_connections_for(assembly_component_id)
if self.active_assembly_component == assembly_component_id:
self.active_assembly_component = next(
iter(self.components.keys()), None
)
self.modified_at = datetime.now()
return True
return False
def get_active_instance(self) -> Optional[AssemblyComponent]:
"""Get the currently active assembly component instance."""
if (
self.active_assembly_component
and self.active_assembly_component in self.components
):
return self.components[self.active_assembly_component]
return None
@dataclass
class Project:
"""
Top-level project container.
A project contains components and provides access to the
geometry kernel for operations.
"""
name: str = "Untitled Project"
description: str = ""
components: Dict[str, Component] = field(default_factory=dict)
active_component: Optional[str] = None
assemblies: Dict[str, Assembly] = field(default_factory=dict)
active_assembly: Optional[str] = None
kernel: OCGeometryKernel = field(default_factory=OCGeometryKernel)
created_at: datetime = field(default_factory=datetime.now)
modified_at: datetime = field(default_factory=datetime.now)
file_path: Optional[str] = None
# ── Component helpers ──
def add_component(self, component: Optional[Component] = None) -> Component:
"""Add a component to the project."""
if component is None:
component = Component(name=f"Component {len(self.components) + 1}")
self.components[component.id] = component
if self.active_component is None:
self.active_component = component.id
self.modified_at = datetime.now()
return component
def remove_component(self, component_id: str) -> bool:
"""Remove a component from the project."""
if component_id in self.components:
del self.components[component_id]
if self.active_component == component_id:
self.active_component = next(iter(self.components.keys()), None)
self.modified_at = datetime.now()
return True
return False
def get_active_component(self) -> Optional[Component]:
"""Get the currently active component."""
if self.active_component and self.active_component in self.components:
return self.components[self.active_component]
return None
def set_active_component(self, component_id: Optional[str]) -> None:
"""Set the active component."""
self.active_component = component_id
self.modified_at = datetime.now()
# ── Assembly helpers ──
def add_assembly(self, assembly: Optional[Assembly] = None) -> Assembly:
"""Add an assembly to the project."""
if assembly is None:
assembly = Assembly(name=f"Assembly {len(self.assemblies) + 1}")
self.assemblies[assembly.id] = assembly
if self.active_assembly is None:
self.active_assembly = assembly.id
self.modified_at = datetime.now()
return assembly
def remove_assembly(self, assembly_id: str) -> bool:
"""Remove an assembly from the project."""
if assembly_id in self.assemblies:
del self.assemblies[assembly_id]
if self.active_assembly == assembly_id:
self.active_assembly = next(iter(self.assemblies.keys()), None)
self.modified_at = datetime.now()
return True
return False
def get_active_assembly(self) -> Optional[Assembly]:
"""Get the currently active assembly."""
if self.active_assembly and self.active_assembly in self.assemblies:
return self.assemblies[self.active_assembly]
return None
def set_active_assembly(self, assembly_id: Optional[str]) -> None:
"""Set the active assembly."""
self.active_assembly = assembly_id
self.modified_at = datetime.now()
def get_component_by_id(self, component_id: str) -> Optional[Component]:
"""Look up a component by id across all project components."""
return self.components.get(component_id)
def add_component(self, component: Optional[Component] = None) -> Component:
"""Add a component to the project."""
if component is None:
component = Component(name=f"Component {len(self.components) + 1}")
self.components[component.id] = component
if self.active_component is None:
self.active_component = component.id
self.modified_at = datetime.now()
return component
def remove_component(self, component_id: str) -> bool:
"""Remove a component from the project."""
if component_id in self.components:
del self.components[component_id]
if self.active_component == component_id:
self.active_component = next(iter(self.components.keys()), None)
self.modified_at = datetime.now()
return True
return False
def get_active_component(self) -> Optional[Component]:
"""Get the currently active component."""
if self.active_component and self.active_component in self.components:
return self.components[self.active_component]
return None
def set_active_component(self, component_id: Optional[str]) -> None:
"""Set the active component."""
self.active_component = component_id
self.modified_at = datetime.now()
def export_step(self, filepath: str) -> bool:
"""Export all visible bodies to STEP."""
all_bodies: List[OCCGeometryObject] = []
for comp in self.components.values():
for body in comp.bodies.values():
if body.visible and body.geometry:
all_bodies.append(body.geometry)
if not all_bodies:
return False
if len(all_bodies) == 1:
return self.kernel.export_step(all_bodies[0], filepath)
result = self.kernel.boolean_union(*all_bodies)
return self.kernel.export_step(result, filepath)
def export_iges(self, filepath: str) -> bool:
"""Export all visible bodies to IGES."""
all_bodies: List[OCCGeometryObject] = []
for comp in self.components.values():
for body in comp.bodies.values():
if body.visible and body.geometry:
all_bodies.append(body.geometry)
if not all_bodies:
return False
if len(all_bodies) == 1:
return self.kernel.export_iges(all_bodies[0], filepath)
result = self.kernel.boolean_union(*all_bodies)
return self.kernel.export_iges(result, filepath)
def export_stl(self, filepath: str, tolerance: float = 0.1) -> bool:
"""Export all visible bodies to STL."""
all_bodies: List[OCCGeometryObject] = []
for comp in self.components.values():
for body in comp.bodies.values():
if body.visible and body.geometry:
all_bodies.append(body.geometry)
if not all_bodies:
return False
if len(all_bodies) == 1:
return self.kernel.export_stl(all_bodies[0], filepath, tolerance)
result = self.kernel.boolean_union(*all_bodies)
return self.kernel.export_stl(result, filepath, tolerance)
def get_all_bodies(self) -> List[Body]:
"""Get all bodies from all components."""
bodies: List[Body] = []
for comp in self.components.values():
bodies.extend(comp.bodies.values())
return bodies
def get_all_sketches(self) -> List[Sketch]:
"""Get all sketches from all components."""
sketches: List[Sketch] = []
for comp in self.components.values():
sketches.extend(comp.sketches.values())
return sketches
src/fluency/rendering/__init__.py
+30
View File
@@ -0,0 +1,30 @@
"""Rendering module."""
# OCC/OpenGL viewport renderers
from fluency.rendering.base import (
Renderer,
RenderObject,
RenderColor,
)
from fluency.rendering.pygfx_renderer import PygfxRenderer, PygfxRenderObject
from fluency.rendering.occ_renderer import OCCRenderer, OCCRenderObject
# Photorealistic render backends
from fluency.rendering.render_backend import (
RenderBackend,
RenderMaterial,
RenderCamera,
RenderSettings,
)
__all__ = [
"Renderer",
"RenderObject",
"RenderColor",
"PygfxRenderer",
"PygfxRenderObject",
"RenderBackend",
"RenderMaterial",
"RenderCamera",
"RenderSettings",
]
src/fluency/rendering/base.py
+380
View File
@@ -0,0 +1,380 @@
"""
Rendering abstraction layer for Fluency CAD.
This module defines abstract interfaces for 3D rendering,
allowing different rendering backends to be used interchangeably.
"""
from abc import ABC, abstractmethod
from typing import List, Tuple, Optional, Callable, Any
from dataclasses import dataclass
import numpy as np
@dataclass
class RenderColor:
"""RGB color representation."""
r: float
g: float
b: float
a: float = 1.0
def to_tuple(self) -> Tuple[float, float, float, float]:
return (self.r, self.g, self.b, self.a)
def to_tuple_rgb(self) -> Tuple[float, float, float]:
return (self.r, self.g, self.b)
@classmethod
def from_hex(cls, hex_color: str) -> "RenderColor":
"""Create color from hex string (#RRGGBB or #RRGGBBAA)."""
hex_color = hex_color.lstrip("#")
if len(hex_color) == 6:
r = int(hex_color[0:2], 16) / 255.0
g = int(hex_color[2:4], 16) / 255.0
b = int(hex_color[4:6], 16) / 255.0
return cls(r, g, b)
elif len(hex_color) == 8:
r = int(hex_color[0:2], 16) / 255.0
g = int(hex_color[2:4], 16) / 255.0
b = int(hex_color[4:6], 16) / 255.0
a = int(hex_color[6:8], 16) / 255.0
return cls(r, g, b, a)
raise ValueError(f"Invalid hex color: {hex_color}")
class RenderObject:
"""Base class for renderable objects."""
def __init__(self, name: Optional[str] = None):
self.name = name
self.visible: bool = True
self.selected: bool = False
self.color: RenderColor = RenderColor(0.2, 0.4, 0.8)
self._scene_node: Any = None
def set_color(self, color: RenderColor) -> None:
self.color = color
def set_visible(self, visible: bool) -> None:
self.visible = visible
def set_selected(self, selected: bool) -> None:
self.selected = selected
class Renderer(ABC):
"""
Abstract base class for 3D renderers.
A renderer provides 3D visualization capabilities including
mesh display, camera control, and object selection.
"""
@abstractmethod
def initialize(self, parent_widget: Any) -> bool:
"""
Initialize the renderer with a parent widget.
Args:
parent_widget: Qt widget to embed the renderer in
Returns:
True if initialization succeeded
"""
pass
@abstractmethod
def shutdown(self) -> None:
"""Clean up renderer resources."""
pass
@abstractmethod
def add_mesh(
self,
vertices: np.ndarray,
faces: np.ndarray,
color: Tuple[float, float, float] = (0.2, 0.4, 0.8),
name: Optional[str] = None,
) -> str:
"""
Add a mesh to the scene.
Args:
vertices: Nx3 array of vertex positions
faces: Mx3 array of triangle indices
color: RGB color tuple
name: Optional name for the object
Returns:
String ID of the mesh
"""
pass
@abstractmethod
def add_wireframe(
self,
vertices: np.ndarray,
edges: np.ndarray,
color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
line_width: float = 1.0,
name: Optional[str] = None,
) -> str:
"""
Add a wireframe to the scene.
Args:
vertices: Nx3 array of vertex positions
edges: Mx2 array of edge vertex indices
color: RGB color tuple
line_width: Width of lines
name: Optional name for the object
Returns:
String ID of the wireframe
"""
pass
@abstractmethod
def add_points(
self,
points: np.ndarray,
color: Tuple[float, float, float] = (1.0, 0.0, 0.0),
size: float = 5.0,
name: Optional[str] = None,
) -> str:
"""
Add points to the scene.
Args:
points: Nx3 array of point positions
color: RGB color tuple
size: Point size
name: Optional name for the object
Returns:
String ID of the points
"""
pass
@abstractmethod
def add_lines(
self,
start_points: np.ndarray,
end_points: np.ndarray,
color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
line_width: float = 1.0,
name: Optional[str] = None,
) -> str:
"""
Add line segments to the scene.
Args:
start_points: Nx3 array of line start positions
end_points: Nx3 array of line end positions
color: RGB color tuple
line_width: Width of lines
name: Optional name for the object
Returns:
String ID of the lines
"""
pass
@abstractmethod
def remove_object(self, obj: RenderObject) -> bool:
"""
Remove an object from the scene.
Args:
obj: Object to remove
Returns:
True if removal succeeded
"""
pass
@abstractmethod
def clear_scene(self) -> None:
"""Remove all objects from the scene."""
pass
@abstractmethod
def update_mesh(self, obj: RenderObject, vertices: np.ndarray, faces: np.ndarray) -> bool:
"""
Update mesh geometry.
Args:
obj: Object to update
vertices: New Nx3 array of vertex positions
faces: New Mx3 array of triangle indices
Returns:
True if update succeeded
"""
pass
@abstractmethod
def set_object_color(self, obj: RenderObject, color: Tuple[float, float, float]) -> None:
"""Set the color of an object."""
pass
@abstractmethod
def set_object_visible(self, obj: RenderObject, visible: bool) -> None:
"""Set the visibility of an object."""
pass
@abstractmethod
def set_camera_position(
self,
position: Tuple[float, float, float],
target: Tuple[float, float, float] = (0, 0, 0),
up: Tuple[float, float, float] = (0, 0, 1),
) -> None:
"""
Set camera position and orientation.
Args:
position: Camera position
target: Point camera is looking at
up: Up vector
"""
pass
@abstractmethod
def get_camera_position(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
"""
Get camera position, target, and up vector.
Returns:
Tuple of (position, target, up) as numpy arrays
"""
pass
@abstractmethod
def fit_camera(self, padding: float = 1.1) -> None:
"""
Fit camera to show all objects.
Args:
padding: Padding factor (1.0 = exact fit)
"""
pass
@abstractmethod
def set_camera_perspective(
self, fov: float = 50.0, near: float = 0.1, far: float = 10000.0
) -> None:
"""Set camera perspective parameters."""
pass
@abstractmethod
def set_camera_orthographic(
self, width: float = 100.0, near: float = 0.1, far: float = 10000.0
) -> None:
"""Set camera orthographic parameters."""
pass
@abstractmethod
def render(self) -> None:
"""Trigger a render."""
pass
@abstractmethod
def on_pick(self, callback: Callable[[Any], None]) -> None:
"""
Register a callback for picking/selection.
Args:
callback: Function called with pick info when object is clicked
"""
pass
@abstractmethod
def on_camera_change(self, callback: Callable[[], None]) -> None:
"""
Register a callback for camera changes.
Args:
callback: Function called when camera moves
"""
pass
@abstractmethod
def set_background_color(self, color: Tuple[float, float, float]) -> None:
"""Set the background color."""
pass
@abstractmethod
def add_grid(
self,
size: float = 100.0,
divisions: int = 10,
color: Tuple[float, float, float] = (0.3, 0.3, 0.3),
) -> str:
"""Add a reference grid. Returns the grid ID."""
pass
@abstractmethod
def add_axes(self, size: float = 10.0, visible: bool = True) -> str:
"""Add coordinate axes. Returns the axes ID."""
pass
@abstractmethod
def get_screen_size(self) -> Tuple[int, int]:
"""Get the screen size in pixels."""
pass
@abstractmethod
def project_to_screen(self, point: Tuple[float, float, float]) -> Tuple[int, int]:
"""
Project a 3D point to screen coordinates.
Args:
point: 3D point to project
Returns:
Screen (x, y) coordinates
"""
pass
@abstractmethod
def unproject_from_screen(
self, screen_x: int, screen_y: int, depth: float = 0.0
) -> Tuple[float, float, float]:
"""
Unproject screen coordinates to 3D.
Args:
screen_x: Screen x coordinate
screen_y: Screen y coordinate
depth: Depth value (0=near, 1=far)
Returns:
3D point coordinates
"""
pass
@abstractmethod
def take_screenshot(self) -> np.ndarray:
"""
Take a screenshot of the current view.
Returns:
RGBA image as numpy array
"""
pass
@abstractmethod
def save_screenshot(self, filepath: str) -> bool:
"""
Save a screenshot to file.
Args:
filepath: Path to save screenshot
Returns:
True if save succeeded
"""
pass
src/fluency/rendering/material_presets.py
+156
View File
@@ -0,0 +1,156 @@
"""Material presets for the render backend.
Each preset is a RenderMaterial with physically-plausible values.
"""
from __future__ import annotations
from typing import Dict, List
from .render_backend import RenderMaterial
# ── Preset library ──────────────────────────────────────────────────────
# Note: Mitsuba pip installs don't include spectral metal data files,
# so metal_preset is not used. Instead, metals use material="none" with
# specular_reflectance set to the metal color.
PRESETS: Dict[str, RenderMaterial] = {
# ── Metals ──────────────────────────────────────────────────────
"Brushed Steel": RenderMaterial(
name="Brushed Steel",
color=(0.65, 0.67, 0.72),
metallic=0.9,
roughness=0.35,
bsdf_type="roughconductor",
),
"Polished Chrome": RenderMaterial(
name="Polished Chrome",
color=(0.8, 0.8, 0.8),
metallic=1.0,
roughness=0.05,
bsdf_type="roughconductor",
),
"Brushed Aluminum": RenderMaterial(
name="Brushed Aluminum",
color=(0.75, 0.75, 0.75),
metallic=0.85,
roughness=0.25,
bsdf_type="roughconductor",
),
"Copper": RenderMaterial(
name="Copper",
color=(0.95, 0.64, 0.54),
metallic=0.95,
roughness=0.15,
bsdf_type="roughconductor",
),
"Gold": RenderMaterial(
name="Gold",
color=(1.0, 0.76, 0.33),
metallic=1.0,
roughness=0.1,
bsdf_type="roughconductor",
),
"Blackened Steel": RenderMaterial(
name="Blackened Steel",
color=(0.15, 0.15, 0.17),
metallic=0.8,
roughness=0.4,
bsdf_type="roughconductor",
),
# ── Plastics ────────────────────────────────────────────────────
"Matte Plastic": RenderMaterial(
name="Matte Plastic",
color=(0.2, 0.5, 0.8),
metallic=0.0,
roughness=0.6,
bsdf_type="plastic",
int_ior=1.5,
),
"Glossy Plastic": RenderMaterial(
name="Glossy Plastic",
color=(0.2, 0.5, 0.8),
metallic=0.0,
roughness=0.1,
bsdf_type="plastic",
int_ior=1.5,
),
"White Nylon": RenderMaterial(
name="White Nylon",
color=(0.85, 0.85, 0.83),
metallic=0.0,
roughness=0.45,
bsdf_type="plastic",
int_ior=1.53,
),
"Black ABS": RenderMaterial(
name="Black ABS",
color=(0.05, 0.05, 0.05),
metallic=0.0,
roughness=0.35,
bsdf_type="plastic",
int_ior=1.54,
),
"Red PA12": RenderMaterial(
name="Red PA12",
color=(0.75, 0.08, 0.08),
metallic=0.0,
roughness=0.4,
bsdf_type="plastic",
int_ior=1.53,
),
# ── Other ───────────────────────────────────────────────────────
"Rubber": RenderMaterial(
name="Rubber",
color=(0.1, 0.1, 0.1),
metallic=0.0,
roughness=0.9,
bsdf_type="diffuse",
),
"Ceramic White": RenderMaterial(
name="Ceramic White",
color=(0.92, 0.91, 0.88),
metallic=0.0,
roughness=0.15,
bsdf_type="dielectric",
int_ior=1.55,
),
"Glass": RenderMaterial(
name="Glass",
color=(0.95, 0.95, 0.95),
metallic=0.0,
roughness=0.0,
bsdf_type="dielectric",
int_ior=1.52,
),
"Wood": RenderMaterial(
name="Wood",
color=(0.6, 0.4, 0.2),
metallic=0.0,
roughness=0.7,
bsdf_type="diffuse",
),
}
def get_preset(name: str) -> RenderMaterial:
"""Get a material preset by name. Falls back to default if not found."""
if name in PRESETS:
return PRESETS[name]
return default_material()
def default_material() -> RenderMaterial:
"""Return the default grey material."""
return RenderMaterial(
name="Default",
color=(0.7, 0.7, 0.7),
metallic=0.0,
roughness=0.5,
bsdf_type="diffuse",
)
def preset_names() -> List[str]:
"""Return sorted list of available preset names."""
return sorted(PRESETS.keys())
src/fluency/rendering/mitsuba_backend.py
+382
View File
@@ -0,0 +1,382 @@
"""Mitsuba 3 photorealistic render backend.
Requires: ``pip install mitsuba``
"""
from __future__ import annotations
import logging
import os
from typing import Callable, Optional
import numpy as np
from .render_backend import RenderBackend, RenderCamera, RenderMaterial, RenderSettings
logger = logging.getLogger(__name__)
class MitsubaBackend(RenderBackend):
"""Render backend using Mitsuba 3 path tracer."""
def name(self) -> str:
return "Mitsuba 3"
def is_available(self) -> bool:
import sys
import io
old_stderr = sys.stderr
sys.stderr = io.StringIO()
try:
import mitsuba # noqa: F401
return True
except ImportError:
return False
finally:
sys.stderr = old_stderr
# ── Scene construction ──────────────────────────────────────────
def _build_scene_dict(
self,
mesh_path: str,
material: RenderMaterial,
camera: RenderCamera,
settings: RenderSettings,
) -> dict:
"""Build a Mitsuba scene dictionary from our data classes.
Uses a 3-point lighting setup (key + fill + rim) plus an ambient
environment emitter for soft fill, giving well-balanced shading on
all faces of the model. Lighting intensities and colors come from
``settings.lighting``; ground plane comes from ``settings.ground_plane``.
"""
import mitsuba as mi
lighting = settings.lighting
ground = settings.ground_plane
# Map our BSDF types to Mitsuba BSDF dicts
bsdf = self._make_bsdf(material)
# Determine mesh file type from extension
ext = os.path.splitext(mesh_path)[1].lower()
shape_type = "ply" if ext == ".ply" else "obj"
# Build camera-to-world transform using the Python API
cam_to_world = mi.ScalarTransform4f.look_at(
origin=list(camera.origin),
target=list(camera.target),
up=list(camera.up),
)
scene = {
"type": "scene",
# Integrator
"integrator": {
"type": "path",
"max_depth": settings.max_depth,
},
# Camera
"sensor": {
"type": "perspective",
"fov": camera.fov,
"to_world": cam_to_world,
"film": {
"type": "hdrfilm",
"width": settings.width,
"height": settings.height,
"rfilter": {"type": "gaussian"},
},
"sampler": {
"type": "independent",
"sample_count": settings.spp,
},
},
# Ambient environment fill
"emitter": {
"type": "constant",
"radiance": {
"type": "rgb",
"value": [
lighting.ambient_intensity,
lighting.ambient_intensity * 0.97,
lighting.ambient_intensity * 0.94,
],
},
},
# Shape
"shape": {
"type": shape_type,
"filename": mesh_path,
"bsdf": bsdf,
},
}
# ── 3-point lighting (colors and intensities from config) ───
key_rgb = [c * lighting.key_intensity for c in lighting.key_color]
key_to_world = mi.ScalarTransform4f.look_at(
origin=[1.0, -0.8, 1.2],
target=[0.0, 0.0, 0.0],
up=[0.0, 0.0, 1.0],
)
scene["key_light"] = {
"type": "directional",
"to_world": key_to_world,
"irradiance": {"type": "rgb", "value": key_rgb},
}
fill_rgb = [c * lighting.fill_intensity for c in lighting.fill_color]
fill_to_world = mi.ScalarTransform4f.look_at(
origin=[-1.0, 0.6, 0.8],
target=[0.0, 0.0, 0.0],
up=[0.0, 0.0, 1.0],
)
scene["fill_light"] = {
"type": "directional",
"to_world": fill_to_world,
"irradiance": {"type": "rgb", "value": fill_rgb},
}
rim_rgb = [c * lighting.rim_intensity for c in lighting.rim_color]
rim_to_world = mi.ScalarTransform4f.look_at(
origin=[-0.3, 1.2, -0.8],
target=[0.0, 0.0, 0.0],
up=[0.0, 0.0, 1.0],
)
scene["rim_light"] = {
"type": "directional",
"to_world": rim_to_world,
"irradiance": {"type": "rgb", "value": rim_rgb},
}
# ── Ground plane / backdrop (optional) ─────────────────────
if ground.enabled:
try:
# Load mesh to compute bounds for ground/backdrop placement
mesh_shape = mi.load_dict({"type": shape_type, "filename": mesh_path})
bbox = mesh_shape.bbox()
bbox_min, bbox_max = bbox[0], bbox[1]
# Ground at model's lowest Z with 0.1% offset
model_height = bbox_max[2] - bbox_min[2]
ground_z = bbox_min[2] - 0.001 * model_height
dx = bbox_max[0] - bbox_min[0]
dy = bbox_max[1] - bbox_min[1]
dz = bbox_max[2] - bbox_min[2]
diag = float((dx * dx + dy * dy + dz * dz) ** 0.5)
except Exception:
# Fallback: place at origin with large default size
ground_z = -ground.distance_below
diag = 1000.0
bsdf_ground = {
"type": "diffuse",
"reflectance": {"type": "rgb", "value": list(ground.color)},
}
if ground.curved_backdrop:
# Photo booth style curved leinwand:
# - Flat floor section in front of the model
# - Curved cylinder behind that sweeps up and over
half_size = diag * 50.0 # huge floor
radius = diag * 3.0 # curvature radius
cyl_height = diag * 20.0 # width of the cylinder (along its axis)
scene["ground_floor"] = {
"type": "rectangle",
"to_world": mi.ScalarTransform4f.translate([0.0, 0.0, ground_z])
@ mi.ScalarTransform4f.scale([half_size, half_size, 1.0]),
"bsdf": bsdf_ground,
}
# Cylinder: axis along Y, positioned behind model, radius sweeps up
scene["ground_backdrop"] = {
"type": "cylinder",
"radius": radius,
"p0": [-cyl_height / 2, -radius, ground_z],
"p1": [cyl_height / 2, -radius, ground_z],
"to_world": mi.ScalarTransform4f.rotate([1, 0, 0], 90)
@ mi.ScalarTransform4f.translate([0.0, 0.0, -radius]),
"bsdf": bsdf_ground,
}
else:
# Simple flat ground plane — very large so edges aren't visible
half_size = diag * 50.0
scene["ground_plane"] = {
"type": "rectangle",
"to_world": mi.ScalarTransform4f.translate([0.0, 0.0, ground_z])
@ mi.ScalarTransform4f.scale([half_size, half_size, 1.0]),
"bsdf": bsdf_ground,
}
return scene
def _make_bsdf(self, material: RenderMaterial) -> dict:
"""Convert a RenderMaterial to a Mitsuba BSDF dict."""
mt = material.bsdf_type
if mt == "roughconductor":
# Use material="none" with specular_reflectance set to the
# metal color. The pip-installed Mitsuba doesn't include
# spectral metal data files (iron.spd, copper.spd, etc.).
return {
"type": "roughconductor",
"material": "none",
"alpha": max(material.roughness, 0.01),
"specular_reflectance": {
"type": "rgb",
"value": list(material.color),
},
}
if mt == "roughdielectric":
return {
"type": "roughdielectric",
"int_ior": material.int_ior,
"ext_ior": 1.0,
"alpha": max(material.roughness, 0.01),
}
if mt == "dielectric":
return {
"type": "dielectric",
"int_ior": material.int_ior,
"ext_ior": 1.0,
}
if mt == "plastic":
return {
"type": "plastic",
"diffuse_reflectance": {
"type": "rgb",
"value": list(material.color),
},
"int_ior": material.int_ior,
}
# Default: diffuse
return {
"type": "diffuse",
"reflectance": {
"type": "rgb",
"value": list(material.color),
},
}
# ── Rendering ───────────────────────────────────────────────────
def render(
self,
mesh_path: str,
material: RenderMaterial,
camera: RenderCamera,
settings: RenderSettings,
progress_callback: Optional[Callable[[float], None]] = None,
) -> np.ndarray:
"""Render a mesh file and return (H, W, 3) float32 RGB array."""
self._set_variant()
import mitsuba as mi
scene_dict = self._build_scene_dict(mesh_path, material, camera, settings)
scene = mi.load_dict(scene_dict)
logger.info(f"Rendering {settings.width}x{settings.height} @ {settings.spp} spp")
# Render
try:
image = mi.render(scene, spp=settings.spp, seed=int(settings.seed or 0)) # type: ignore[arg-type] # Mitsuba accepts int at runtime
except Exception as e:
logger.error(f"Mitsuba render failed: {e}")
raise
if progress_callback:
progress_callback(1.0)
# Convert to numpy (H, W, 3)
arr = np.array(image, dtype=np.float32)
# Apply approximate sRGB tonemapping
arr = np.clip(arr, 0.0, None)
arr = np.power(arr, 1.0 / 2.2) # gamma
arr = np.clip(arr, 0.0, 1.0)
return arr
def render_preview(
self,
mesh_path: str,
material: RenderMaterial,
camera: RenderCamera,
settings: RenderSettings,
) -> np.ndarray:
"""Quick low-quality preview (4x fewer spp)."""
preview_settings = RenderSettings(
width=settings.width // 2,
height=settings.height // 2,
spp=max(settings.spp // 4, 16),
max_depth=min(settings.max_depth, 4),
seed=settings.seed,
lighting=settings.lighting,
ground_plane=settings.ground_plane,
)
return self.render(mesh_path, material, camera, preview_settings)
# ── Export ──────────────────────────────────────────────────────
def export_image(self, image: np.ndarray, path: str) -> None:
"""Save a rendered image to PNG or EXR."""
from PIL import Image
ext = os.path.splitext(path)[1].lower()
if ext == ".exr":
# Save as EXR (HDR) — no tonemapping
try:
import OpenEXR # type: ignore[import-not-found]
import Imath # type: ignore[import-not-found]
h, w = image.shape[:2]
header = OpenEXR.Header(w, h)
header["channels"] = {
"R": Imath.PixelType(Imath.PixelType.FLOAT),
"G": Imath.PixelType(Imath.PixelType.FLOAT),
"B": Imath.PixelType(Imath.PixelType.FLOAT),
}
exr = OpenEXR.OutputFile(path, header)
exr.write(
{
"R": image[:, :, 0].tobytes(),
"G": image[:, :, 1].tobytes(),
"B": image[:, :, 2].tobytes(),
}
)
exr.close()
except ImportError:
# Fallback: save as 16-bit PNG
logger.warning("OpenEXR not available, saving as 16-bit PNG")
img = Image.fromarray((image * 65535).astype(np.uint16), "RGB")
img.save(path)
else:
# PNG / JPEG — already tonemapped
img = Image.fromarray((image * 255).astype(np.uint8), "RGB")
img.save(path)
logger.info(f"Exported render to {path}")
# ── Helpers ─────────────────────────────────────────────────────
def _set_variant(self) -> None:
"""Set the Mitsuba variant (called once)."""
import sys
import io
# Suppress the harmless "LLVM API initialization failed" warning
# that drjit emits on macOS ARM when scalar variant is used.
old_stderr = sys.stderr
sys.stderr = io.StringIO()
try:
import mitsuba as mi
mi.set_variant("scalar_rgb")
finally:
sys.stderr = old_stderr
src/fluency/rendering/occ_renderer.py
+2216
View File
File diff suppressed because it is too large Load Diff
src/fluency/rendering/occ_to_mesh.py
+252
View File
@@ -0,0 +1,252 @@
"""Convert OCC BRep shapes to mesh files for render backends.
Outputs PLY files (preferred by Mitsuba) or STL files.
"""
from __future__ import annotations
import logging
import os
import tempfile
from typing import List, Optional, Tuple
import numpy as np
logger = logging.getLogger(__name__)
def occ_shape_to_ply(
shape,
output_path: Optional[str] = None,
linear_deflection: float = 0.1,
angular_deflection: float = 0.15,
) -> str:
"""Tessellate an OCC TopoDS_Shape and write as PLY.
Returns the path to the written PLY file.
"""
from OCP.BRepMesh import BRepMesh_IncrementalMesh
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_FACE
from OCP.TopoDS import TopoDS
from OCP.BRep import BRep_Tool
from OCP.TopLoc import TopLoc_Location
# Tessellate
tess = BRepMesh_IncrementalMesh(
shape, linear_deflection, False, angular_deflection, True
)
tess.Perform()
# Extract triangulation from all faces
all_vertices: List[List[float]] = []
all_faces: List[List[int]] = []
vertex_offset = 0
from OCP.TopAbs import TopAbs_FORWARD
explorer = TopExp_Explorer(shape, TopAbs_FACE)
while explorer.More():
face = TopoDS.Face_s(explorer.Current())
location = TopLoc_Location()
triangulation = BRep_Tool.Triangulation_s(face, location)
if triangulation is None:
explorer.Next()
continue
# Transform
trsf = location.Transformation()
# Check face orientation: FORWARD means the surface normal points
# outward from the solid; REVERSED means it points inward.
is_forward = (face.Orientation() == TopAbs_FORWARD)
# Extract vertices (apply location transform to positions)
nb_nodes = triangulation.NbNodes()
for i in range(1, nb_nodes + 1):
node = triangulation.Node(i)
pnt = node.Transformed(trsf)
all_vertices.append([pnt.X(), pnt.Y(), pnt.Z()])
# Extract triangles
# For REVERSED faces, swap winding order (n1, n3, n2) so that
# the computed normal points outward consistently.
nb_triangles = triangulation.NbTriangles()
for i in range(1, nb_triangles + 1):
tri = triangulation.Triangle(i)
n1, n2, n3 = tri.Get()
if is_forward:
all_faces.append([
n1 - 1 + vertex_offset,
n2 - 1 + vertex_offset,
n3 - 1 + vertex_offset,
])
else:
# Swap winding for REVERSED faces
all_faces.append([
n1 - 1 + vertex_offset,
n3 - 1 + vertex_offset,
n2 - 1 + vertex_offset,
])
vertex_offset += nb_nodes
explorer.Next()
if not all_vertices:
raise ValueError("Tessellation produced no vertices")
vertices = np.array(all_vertices, dtype=np.float32)
faces = np.array(all_faces, dtype=np.uint32)
logger.info(
f"Tessellation: {len(vertices)} vertices, {len(faces)} triangles"
)
# Compute smooth vertex normals from face normals.
# Winding is already corrected during tessellation using OCC face orientation.
normals, corrected_faces = _compute_outward_normals(vertices, faces, shape)
# Write PLY with corrected faces and normals
if output_path is None:
fd, output_path = tempfile.mkstemp(suffix=".ply", prefix="fluency_render_")
os.close(fd)
_write_ply(output_path, vertices, corrected_faces, normals)
logger.info(f"Wrote PLY: {output_path}")
return output_path
def _compute_outward_normals(
vertices: np.ndarray,
faces: np.ndarray,
shape,
) -> Tuple[np.ndarray, np.ndarray]:
"""Compute outward-facing vertex normals and correct face winding.
The winding is already corrected during tessellation using OCC's face
orientation (TopAbs_FORWARD/REVERSED). This function computes smooth
vertex normals by averaging face normals at shared vertices.
Returns (normals, corrected_faces) for PLY export.
"""
n_verts = len(vertices)
v_normals = np.zeros((n_verts, 3), dtype=np.float64)
# Ensure faces is 2D (numpy creates (3,) for single-face meshes)
if faces.ndim == 1:
faces = faces.reshape(1, -1)
# Winding is already correct from tessellation (face orientation check).
# Just compute face normals and accumulate to vertices.
v0 = vertices[faces[:, 0]]
v1 = vertices[faces[:, 1]]
v2 = vertices[faces[:, 2]]
edge1 = v1 - v0
edge2 = v2 - v0
fn = np.cross(edge1, edge2)
# Normalize face normals
lengths = np.linalg.norm(fn, axis=1, keepdims=True)
lengths[lengths < 1e-10] = 1.0
fn /= lengths
# Accumulate to vertices
for i in range(len(faces)):
idx = faces[i]
v_normals[idx[0]] += fn[i]
v_normals[idx[1]] += fn[i]
v_normals[idx[2]] += fn[i]
# Normalize vertex normals
v_lengths = np.linalg.norm(v_normals, axis=1, keepdims=True)
v_lengths[v_lengths < 1e-10] = 1.0
v_normals /= v_lengths
return v_normals.astype(np.float32), faces.astype(np.uint32)
def occ_shape_to_stl(
shape,
output_path: Optional[str] = None,
linear_deflection: float = 0.1,
) -> str:
"""Tessellate an OCC TopoDS_Shape and write as binary STL.
Returns the path to the written STL file.
"""
from OCP.BRepMesh import BRepMesh_IncrementalMesh
from OCP.StlAPI import StlAPI_Writer
# Tessellate
tess = BRepMesh_IncrementalMesh(shape, linear_deflection, False, 0.5, True)
tess.Perform()
if output_path is None:
fd, output_path = tempfile.mkstemp(suffix=".stl", prefix="fluency_render_")
os.close(fd)
writer = StlAPI_Writer()
writer.SetASCIIMode(False)
writer.Write(shape, output_path)
logger.info(f"Wrote STL: {output_path}")
return output_path
def occ_shape_bounds(shape) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]:
"""Return (min_xyz, max_xyz) bounding box of an OCC shape."""
from OCP.Bnd import Bnd_Box
from OCP.BRepBndLib import BRepBndLib
bbox = Bnd_Box()
BRepBndLib.Add_s(shape, bbox)
xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
return (xmin, ymin, zmin), (xmax, ymax, zmax)
def _write_ply(
path: str,
vertices: np.ndarray,
faces: np.ndarray,
normals: Optional[np.ndarray] = None,
) -> None:
"""Write a binary PLY file (little-endian) with optional vertex normals."""
import struct
n_verts = len(vertices)
n_faces = len(faces)
has_normals = normals is not None and len(normals) == n_verts
with open(path, "wb") as f:
# Header
header_lines = [
"ply",
"format binary_little_endian 1.0",
f"element vertex {n_verts}",
"property float x",
"property float y",
"property float z",
]
if has_normals:
header_lines.extend([
"property float nx",
"property float ny",
"property float nz",
])
header_lines.append(f"element face {n_faces}")
header_lines.append("property list uchar int vertex_indices")
header_lines.append("end_header")
f.write(("\n".join(header_lines) + "\n").encode("ascii"))
# Vertex positions (+ normals if available)
for i in range(n_verts):
f.write(struct.pack("<fff", vertices[i, 0], vertices[i, 1], vertices[i, 2]))
if has_normals:
f.write(struct.pack("<fff", normals[i, 0], normals[i, 1], normals[i, 2]))
# Faces
for face in faces:
f.write(struct.pack("<B", 3))
f.write(struct.pack("<iii", int(face[0]), int(face[1]), int(face[2])))
src/fluency/rendering/pygfx_renderer.py
+479
View File
@@ -0,0 +1,479 @@
"""
pygfx-based renderer for Fluency CAD.
This module provides a modern WebGPU-based renderer using pygfx,
offering a smaller dependency footprint than VTK while providing
excellent 3D visualization capabilities.
"""
from typing import List, Tuple, Optional, Callable, Any
import numpy as np
from dataclasses import dataclass
from fluency.rendering.base import (
Renderer,
RenderObject,
RenderColor,
)
def compute_normals(vertices: np.ndarray, faces: np.ndarray) -> np.ndarray:
"""Compute vertex normals from positions and face indices."""
vertices = np.asarray(vertices, dtype=np.float32)
faces = np.asarray(faces, dtype=np.int32)
normals = np.zeros_like(vertices)
for face in faces:
v0, v1, v2 = vertices[face[0]], vertices[face[1]], vertices[face[2]]
edge1 = v1 - v0
edge2 = v2 - v0
face_normal = np.cross(edge1, edge2)
length = np.linalg.norm(face_normal)
if length > 1e-10:
face_normal = face_normal / length
normals[face[0]] += face_normal
normals[face[1]] += face_normal
normals[face[2]] += face_normal
lengths = np.linalg.norm(normals, axis=1, keepdims=True)
lengths = np.where(lengths > 1e-10, lengths, 1)
normals = normals / lengths
return normals.astype(np.float32)
@dataclass
class PygfxRenderObject(RenderObject):
"""pygfx render object wrapper."""
scene_node: Any = None
geometry: Any = None
material: Any = None
def __init__(
self,
scene_node: Any = None,
geometry: Any = None,
material: Any = None,
name: Optional[str] = None,
):
super().__init__(name=name)
self.scene_node = scene_node
self.geometry = geometry
self.material = material
class PygfxRenderer(Renderer):
"""
pygfx-based renderer implementation.
This renderer uses pygfx (WebGPU-based) for 3D visualization,
providing modern rendering with a small dependency footprint.
"""
def __init__(self) -> None:
self._canvas: Any = None
self._renderer: Any = None
self._scene: Any = None
self._camera: Any = None
self._controller: Any = None
self._objects: List[PygfxRenderObject] = []
self._pick_callback: Optional[Callable[[Any], None]] = None
self._camera_change_callback: Optional[Callable[[], None]] = None
self._background_color: Tuple[float, float, float] = (0.1, 0.1, 0.15)
self._initialized: bool = False
def initialize(self, parent_widget: Any) -> bool:
"""Initialize pygfx with Qt widget."""
try:
import pygfx as gfx
from rendercanvas.qt import RenderWidget
from PySide6.QtWidgets import QVBoxLayout
self._canvas = RenderWidget(parent=parent_widget)
self._renderer = gfx.renderers.WgpuRenderer(self._canvas)
self._scene = gfx.Scene()
self._camera = gfx.PerspectiveCamera(50, 16 / 9)
self._camera.local.position = (100, 100, 100)
self._controller = gfx.OrbitController(self._camera)
self._controller.register_events(self._renderer)
self._setup_lighting()
self._add_grid()
layout = QVBoxLayout(parent_widget)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self._canvas)
self._canvas.request_draw(self._animate)
self._setup_picking()
self._initialized = True
return True
except Exception as e:
print(f"Failed to initialize pygfx: {e}")
import traceback
traceback.print_exc()
return False
def _animate(self):
"""Animation callback for the canvas."""
if self._initialized:
self._renderer.render(self._scene, self._camera)
def _setup_lighting(self) -> None:
"""Setup scene lighting."""
import pygfx as gfx
ambient = gfx.AmbientLight(intensity=0.3)
self._scene.add(ambient)
directional = gfx.DirectionalLight(intensity=1.0)
directional.local.position = (100, 100, 100)
self._scene.add(directional)
fill = gfx.DirectionalLight(intensity=0.5)
fill.local.position = (-100, 50, 50)
self._scene.add(fill)
def _add_grid(self) -> None:
"""Add reference grid."""
import pygfx as gfx
grid = gfx.GridHelper(
size=200, divisions=20, color1=(0.3, 0.3, 0.3, 1), color2=(0.2, 0.2, 0.2, 1)
)
self._scene.add(grid)
def _setup_picking(self) -> None:
"""Setup mesh picking."""
pass
def shutdown(self) -> None:
"""Clean up renderer resources."""
self._objects.clear()
self._initialized = False
def add_mesh(
self,
vertices: np.ndarray,
faces: np.ndarray,
color: Tuple[float, float, float] = (0.2, 0.4, 0.8),
name: Optional[str] = None,
) -> str:
"""Add a mesh to the scene. Returns the mesh ID."""
import pygfx as gfx
import uuid
vertices = np.asarray(vertices, dtype=np.float32)
faces = np.asarray(faces, dtype=np.int32)
normals = compute_normals(vertices, faces)
geometry = gfx.Geometry(positions=vertices, indices=faces, normals=normals)
material = gfx.MeshPhongMaterial(color=color, flat_shading=False)
mesh = gfx.Mesh(geometry, material)
self._scene.add(mesh)
mesh_id = name or f"mesh_{uuid.uuid4().hex[:8]}"
obj = PygfxRenderObject(name=mesh_id, scene_node=mesh, geometry=geometry, material=material)
obj.color = RenderColor(*color)
self._objects.append(obj)
return mesh_id
def add_wireframe(
self,
vertices: np.ndarray,
edges: np.ndarray,
color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
line_width: float = 1.0,
name: Optional[str] = None,
) -> str:
"""Add a wireframe to the scene. Returns the wireframe ID."""
import pygfx as gfx
import uuid
positions: List[List[float]] = []
for edge in edges:
positions.append(vertices[edge[0]])
positions.append(vertices[edge[1]])
positions_arr = np.array(positions, dtype=np.float32)
geometry = gfx.Geometry(positions=positions_arr)
material = gfx.LineMaterial(color=color, thickness=line_width)
lines = gfx.Line(geometry, material)
self._scene.add(lines)
wireframe_id = name or f"wireframe_{uuid.uuid4().hex[:8]}"
obj = PygfxRenderObject(
name=wireframe_id, scene_node=lines, geometry=geometry, material=material
)
obj.color = RenderColor(*color)
self._objects.append(obj)
return wireframe_id
def add_points(
self,
points: np.ndarray,
color: Tuple[float, float, float] = (1.0, 0.0, 0.0),
size: float = 5.0,
name: Optional[str] = None,
) -> str:
"""Add points to the scene. Returns the points ID."""
import pygfx as gfx
import uuid
points_arr = np.asarray(points, dtype=np.float32)
geometry = gfx.Geometry(positions=points_arr)
material = gfx.PointsMaterial(color=color, size=size)
points_obj = gfx.Points(geometry, material)
self._scene.add(points_obj)
points_id = name or f"points_{uuid.uuid4().hex[:8]}"
obj = PygfxRenderObject(
name=points_id, scene_node=points_obj, geometry=geometry, material=material
)
obj.color = RenderColor(*color)
self._objects.append(obj)
return points_id
def add_lines(
self,
start_points: np.ndarray,
end_points: np.ndarray,
color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
line_width: float = 1.0,
name: Optional[str] = None,
) -> str:
"""Add line segments to the scene. Returns the lines ID."""
import pygfx as gfx
import uuid
positions = np.hstack([start_points, end_points]).flatten()
positions = positions.reshape(-1, 3).astype(np.float32)
geometry = gfx.Geometry(positions=positions)
material = gfx.LineMaterial(color=color, thickness=line_width)
lines = gfx.Line(geometry, material)
self._scene.add(lines)
lines_id = name or f"lines_{uuid.uuid4().hex[:8]}"
obj = PygfxRenderObject(
name=lines_id, scene_node=lines, geometry=geometry, material=material
)
obj.color = RenderColor(*color)
self._objects.append(obj)
return lines_id
def remove_object(self, obj: RenderObject) -> bool:
"""Remove an object from the scene."""
if isinstance(obj, PygfxRenderObject) and obj in self._objects:
if obj.scene_node is not None:
self._scene.remove(obj.scene_node)
self._objects.remove(obj)
return True
return False
def remove_mesh(self, mesh_id: str) -> bool:
"""Remove a mesh by its ID."""
for obj in self._objects:
if obj.name == mesh_id:
return self.remove_object(obj)
return False
def clear_scene(self) -> None:
"""Remove all objects from the scene."""
for obj in self._objects[:]:
if obj.scene_node is not None:
self._scene.remove(obj.scene_node)
self._objects.clear()
def update_mesh(self, obj: RenderObject, vertices: np.ndarray, faces: np.ndarray) -> bool:
"""Update mesh geometry."""
if not isinstance(obj, PygfxRenderObject):
return False
import pygfx as gfx
vertices = np.asarray(vertices, dtype=np.float32)
faces = np.asarray(faces, dtype=np.int32)
normals = compute_normals(vertices, faces)
geometry = gfx.Geometry(positions=vertices, indices=faces, normals=normals)
obj.geometry = geometry
if obj.scene_node is not None:
obj.scene_node.geometry = geometry
return True
def set_object_color(self, obj: RenderObject, color: Tuple[float, float, float]) -> None:
"""Set the color of an object."""
if isinstance(obj, PygfxRenderObject):
obj.color = RenderColor(*color)
if obj.material is not None:
obj.material.color = color
def set_object_visible(self, obj: RenderObject, visible: bool) -> None:
"""Set the visibility of an object."""
if isinstance(obj, PygfxRenderObject):
obj.visible = visible
if obj.scene_node is not None:
obj.scene_node.visible = visible
def set_camera_position(
self,
position: Tuple[float, float, float],
target: Tuple[float, float, float] = (0, 0, 0),
up: Tuple[float, float, float] = (0, 0, 1),
) -> None:
"""Set camera position and orientation."""
self._camera.local.position = position
self._camera.look_at(target)
def get_camera_position(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
"""Get camera position, target, and up vector."""
pos = np.array(self._camera.local.position)
target = np.array([0, 0, 0])
up = np.array(self._camera.local.up)
return pos, target, up
def fit_camera(self, padding: float = 1.1) -> None:
"""Fit camera to show all objects."""
if not self._objects:
return
all_positions: List[np.ndarray] = []
for obj in self._objects:
if obj.geometry is not None and hasattr(obj.geometry, "positions"):
positions = obj.geometry.positions.data
all_positions.append(positions)
if all_positions:
positions = np.vstack(all_positions)
min_pos = positions.min(axis=0)
max_pos = positions.max(axis=0)
center = (min_pos + max_pos) / 2
size = np.linalg.norm(max_pos - min_pos) * padding
self._camera.local.position = (center[0] + size, center[1] + size, center[2] + size)
self._camera.look_at(tuple(center))
def set_camera_perspective(
self, fov: float = 50.0, near: float = 0.1, far: float = 10000.0
) -> None:
"""Set camera perspective parameters."""
self._camera.fov = fov
self._camera.near = near
self._camera.far = far
def set_camera_orthographic(
self, width: float = 100.0, near: float = 0.1, far: float = 10000.0
) -> None:
"""Set camera orthographic parameters."""
import pygfx as gfx
self._camera = gfx.OrthographicCamera(width=width, near=near, far=far)
self._controller.camera = self._camera
def render(self) -> None:
"""Trigger a render."""
if self._initialized:
self._canvas.request_draw()
def on_pick(self, callback: Callable[[Any], None]) -> None:
"""Register a callback for picking/selection."""
self._pick_callback = callback
def on_camera_change(self, callback: Callable[[], None]) -> None:
"""Register a callback for camera changes."""
self._camera_change_callback = callback
def set_background_color(self, color: Tuple[float, float, float]) -> None:
"""Set the background color."""
self._background_color = color
self._scene.background = color
def add_grid(
self,
size: float = 100.0,
divisions: int = 10,
color: Tuple[float, float, float] = (0.3, 0.3, 0.3),
) -> str:
"""Add a reference grid. Returns the grid ID."""
import pygfx as gfx
grid = gfx.GridHelper(
size=size, divisions=divisions, color1=(*color, 1), color2=(*color, 0.5)
)
self._scene.add(grid)
obj = PygfxRenderObject(name="grid", scene_node=grid)
self._objects.append(obj)
return "grid"
def add_axes(self, size: float = 10.0, visible: bool = True) -> str:
"""Add coordinate axes. Returns the axes ID."""
import pygfx as gfx
axes = gfx.AxesHelper(size=size)
axes.visible = visible
self._scene.add(axes)
obj = PygfxRenderObject(name="axes", scene_node=axes)
self._objects.append(obj)
return "axes"
def get_screen_size(self) -> Tuple[int, int]:
"""Get the screen size in pixels."""
if self._canvas is not None:
return self._canvas.get_physical_size()
return (800, 600)
def project_to_screen(self, point: Tuple[float, float, float]) -> Tuple[int, int]:
"""Project a 3D point to screen coordinates."""
return (0, 0)
def unproject_from_screen(
self, screen_x: int, screen_y: int, depth: float = 0.0
) -> Tuple[float, float, float]:
"""Unproject screen coordinates to 3D."""
return (0.0, 0.0, 0.0)
def take_screenshot(self) -> np.ndarray:
"""Take a screenshot of the current view."""
return np.zeros((100, 100, 4), dtype=np.uint8)
def save_screenshot(self, filepath: str) -> bool:
"""Save a screenshot to file."""
try:
img = self.take_screenshot()
from PIL import Image
Image.fromarray(img).save(filepath)
return True
except Exception as e:
print(f"Screenshot error: {e}")
return False
src/fluency/rendering/render_backend.py
+142
View File
@@ -0,0 +1,142 @@
"""Abstract render backend interface.
Any photorealistic renderer (Mitsuba, Blender, Cycles, ...) implements
:class:`RenderBackend`. The UI only talks to this ABC so backends can be
swapped by changing one import.
"""
from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class RenderMaterial:
"""PBR material description for the render backend."""
name: str = "Default"
color: tuple[float, float, float] = (0.7, 0.7, 0.7)
metallic: float = 0.0 # 0.0 = dielectric, 1.0 = metal
roughness: float = 0.5 # 0.0 = mirror, 1.0 = fully rough
bsdf_type: str = "diffuse" # diffuse | roughconductor | roughdielectric | plastic
# Optional: named metal preset (copper, aluminium, gold, chrome, steel)
metal_preset: Optional[str] = None
# For dielectric / plastic
int_ior: float = 1.5
@dataclass
class RenderCamera:
"""Camera parameters for the render."""
origin: tuple[float, float, float] = (100.0, 100.0, 100.0)
target: tuple[float, float, float] = (0.0, 0.0, 0.0)
up: tuple[float, float, float] = (0.0, 0.0, 1.0)
fov: float = 60.0 # vertical field of view in degrees
@dataclass
class LightingConfig:
"""Lighting configuration for the render scene."""
ambient_intensity: float = 0.3 # constant environment fill [0..1]
key_color: tuple[float, float, float] = (1.0, 0.98, 0.95) # RGB key light color
key_intensity: float = 3.5 # key light irradiance multiplier
fill_color: tuple[float, float, float] = (0.92, 0.94, 1.0) # RGB fill light color
fill_intensity: float = 1.5 # fill light irradiance multiplier
rim_color: tuple[float, float, float] = (1.0, 0.98, 0.96) # RGB rim light color
rim_intensity: float = 1.2 # rim light irradiance multiplier
@dataclass
class GroundPlaneConfig:
"""Ground plane configuration for the render scene."""
enabled: bool = False
color: tuple[float, float, float] = (0.5, 0.5, 0.5) # RGB diffuse color
roughness: float = 0.8 # surface roughness [0..1]
distance_below: float = 0.0 # mm below origin (positive = below)
curved_backdrop: bool = False # photo booth style curved leinwand
@dataclass
class RenderSettings:
"""Quality / resolution settings."""
width: int = 1920
height: int = 1080
spp: int = 256 # samples per pixel
max_depth: int = 8 # max bounces for path tracer
seed: int = 0 # random seed (0 = auto)
lighting: LightingConfig = field(default_factory=LightingConfig)
ground_plane: GroundPlaneConfig = field(default_factory=GroundPlaneConfig)
class RenderBackend(ABC):
"""Abstract photorealistic renderer.
Implementations live in separate modules so backends can be swapped
without touching the UI. Typical call::
backend = MitsubaBackend()
image = backend.render(obj_path, material, camera, settings)
"""
@abstractmethod
def name(self) -> str:
"""Human-readable backend name (shown in UI)."""
@abstractmethod
def is_available(self) -> bool:
"""Return True if this backend's dependencies are installed."""
@abstractmethod
def render(
self,
mesh_path: str,
material: RenderMaterial,
camera: RenderCamera,
settings: RenderSettings,
progress_callback=None,
) -> "np.ndarray":
"""Render a mesh file and return an (H, W, 3) float32 RGB array.
*mesh_path* is an STL or OBJ file on disk.
*progress_callback(fraction)* is called with 0.0–1.0 progress.
"""
@abstractmethod
def render_preview(
self,
mesh_path: str,
material: RenderMaterial,
camera: RenderCamera,
settings: RenderSettings,
) -> "np.ndarray":
"""Quick low-quality preview (fewer spp)."""
@abstractmethod
def export_image(self, image: "np.ndarray", path: str) -> None:
"""Save a rendered image to PNG / EXR."""
def default_camera_from_bounds(
self, bounds_min: tuple[float, float, float], bounds_max: tuple[float, float, float]
) -> RenderCamera:
"""Compute a sensible default camera looking at the bbox centre."""
import numpy as np
mn = np.asarray(bounds_min, dtype=float)
mx = np.asarray(bounds_max, dtype=float)
centre = (mn + mx) / 2.0
diag = float(np.linalg.norm(mx - mn))
# Place camera at iso-ish position, far enough to see everything.
eye = centre + np.array([0.7, -0.7, 0.5]) * diag * 0.8
return RenderCamera(
origin=tuple(eye.tolist()),
target=tuple(centre.tolist()),
up=(0.0, 0.0, 1.0),
fov=45.0,
)
src/fluency/sketch_solver.py
+326
View File
@@ -0,0 +1,326 @@
"""
SolveSpace-based constraint solver for Fluency CAD.
Provides integration between python-solvespace (SolverSystem) and
the Fluency CAD sketch pipeline (OCCSketch). Drawing operations
add entities to BOTH the OCCSketch (for OCC->render pipeline) and
the SolverSketch (for constraint solving). After constraint solving,
solved positions are synced back to the OCCSketch.
"""
from __future__ import annotations
import math
import re
import uuid
import logging
from dataclasses import dataclass, field
from typing import List, Optional, Tuple, Any, Dict
from python_solvespace import SolverSystem, ResultFlag
logger = logging.getLogger(__name__)
# ── Data classes ──────────────────────────────────────────────────────────
@dataclass
class SolverPoint:
"""A 2D point tracked by the solver system."""
x: float
y: float
handle: Any = None
handle_nr: int = 0
entity_id: int = -1 # Corresponding OCCSketch entity id
is_helper: bool = False
id: str = field(default_factory=lambda: str(uuid.uuid4()))
def to_tuple(self) -> Tuple[float, float]:
return (self.x, self.y)
@dataclass
class SolverLine:
"""A line segment tracked by the solver system."""
start: SolverPoint
end: SolverPoint
handle: Any = None
handle_nr: int = 0
entity_ids: Tuple[int, int] = (-1, -1) # Corresponding OCCSketch entity ids
is_helper: bool = False
constraints: List[str] = field(default_factory=list)
id: str = field(default_factory=lambda: str(uuid.uuid4()))
@property
def length(self) -> float:
return math.sqrt(
(self.end.x - self.start.x) ** 2 + (self.end.y - self.start.y) ** 2
)
def midpoint(self) -> Tuple[float, float]:
return (
(self.start.x + self.end.x) / 2,
(self.start.y + self.end.y) / 2,
)
@dataclass
class SolverCircle:
"""A circle tracked by the solver system."""
center: SolverPoint
radius: float
handle: Any = None
handle_nr: int = 0
entity_id: int = -1 # Corresponding OCCSketch entity id
is_helper: bool = False
id: str = field(default_factory=lambda: str(uuid.uuid4()))
# ── Solver wrapper ────────────────────────────────────────────────────────
class SolverSketch(SolverSystem):
"""
Sketch that uses python-solvespace for parametric constraint solving.
Maintains its own lists of points, lines, and circles with solve-space
handles. Provides methods for creating geometry, applying constraints,
solving, and syncing solved positions back to an OCCSketch.
"""
def __init__(self) -> None:
super().__init__()
self.id = str(uuid.uuid4())
self.wp = self.create_2d_base()
self.points: List[SolverPoint] = []
self.lines: List[SolverLine] = []
self.circles: List[SolverCircle] = []
self._last_solve_result: int = 0
# ── Geometry creation ────────────────────────────────────────────────
def add_solver_point(self, x: float, y: float, is_helper: bool = False) -> SolverPoint:
"""Add a point to the solver system and return a SolverPoint."""
handle = self.add_point_2d(x, y, self.wp)
handle_nr = _extract_handle_nr(str(handle))
point = SolverPoint(
x=x, y=y, handle=handle, handle_nr=handle_nr,
is_helper=is_helper,
)
self.points.append(point)
return point
def add_solver_line(
self, start: SolverPoint, end: SolverPoint, is_helper: bool = False
) -> SolverLine:
"""Add a line to the solver system and return a SolverLine."""
handle = self.add_line_2d(start.handle, end.handle, self.wp)
handle_nr = _extract_handle_nr(str(handle))
line = SolverLine(
start=start, end=end, handle=handle, handle_nr=handle_nr,
is_helper=is_helper,
)
self.lines.append(line)
return line
def add_solver_circle(
self, center: SolverPoint, radius: float, is_helper: bool = False
) -> SolverCircle:
"""Add a circle to the solver system and return a SolverCircle.
Note: python-solvespace handles circles via diameter, so we
store radius but pass 2*radius to the solver if needed.
"""
# For now, circles are tracked for OCC output but the solver
# doesn't have a dedicated add_circle_2d in the standard API.
# We'll handle radius/diameter constraints through the points.
circle = SolverCircle(
center=center, radius=radius,
is_helper=is_helper,
)
self.circles.append(circle)
return circle
# ── Constraint methods ───────────────────────────────────────────────
def constrain_coincident(self, entity_a, entity_b) -> bool:
"""Make two entities coincident (point-point or point-line)."""
try:
if isinstance(entity_a, SolverPoint) and isinstance(entity_b, SolverPoint):
self.coincident(entity_a.handle, entity_b.handle, self.wp)
elif isinstance(entity_a, SolverPoint) and isinstance(entity_b, SolverLine):
self.coincident(entity_a.handle, entity_b.handle, self.wp)
elif isinstance(entity_a, SolverLine) and isinstance(entity_b, SolverPoint):
self.coincident(entity_b.handle, entity_a.handle, self.wp)
else:
logger.warning(f"coincident: unsupported types {type(entity_a)}, {type(entity_b)}")
return False
return True
except Exception as e:
logger.error(f"coincident constraint failed: {e}")
return False
def constrain_horizontal(self, line: SolverLine) -> bool:
"""Constrain a line to be horizontal."""
try:
self.horizontal(line.handle, self.wp)
return True
except Exception as e:
logger.error(f"horizontal constraint failed: {e}")
return False
def constrain_vertical(self, line: SolverLine) -> bool:
"""Constrain a line to be vertical."""
try:
self.vertical(line.handle, self.wp)
return True
except Exception as e:
logger.error(f"vertical constraint failed: {e}")
return False
def constrain_distance(
self, entity_a, entity_b, distance: float
) -> bool:
"""Constrain distance between point-point or point-line."""
try:
handle_a = entity_a.handle if isinstance(entity_a, SolverPoint) else entity_a.handle
handle_b = entity_b.handle if isinstance(entity_b, SolverPoint) else entity_b.handle
if isinstance(entity_a, SolverPoint) and isinstance(entity_b, SolverLine):
self.distance(handle_a, handle_b, distance, self.wp)
elif isinstance(entity_a, SolverLine) and isinstance(entity_b, SolverPoint):
self.distance(handle_b, handle_a, distance, self.wp)
elif isinstance(entity_a, SolverPoint) and isinstance(entity_b, SolverPoint):
self.distance(handle_a, handle_b, distance, self.wp)
elif isinstance(entity_a, SolverLine) and isinstance(entity_b, SolverLine):
self.distance(handle_a, handle_b, distance, self.wp)
else:
logger.warning(f"distance: unsupported types {type(entity_a)}, {type(entity_b)}")
return False
return True
except Exception as e:
logger.error(f"distance constraint failed: {e}")
return False
def constrain_midpoint(self, point: SolverPoint, line: SolverLine) -> bool:
"""Constrain a point to be at the midpoint of a line."""
try:
self.midpoint(point.handle, line.handle, self.wp)
return True
except Exception as e:
logger.error(f"midpoint constraint failed: {e}")
return False
def constrain_parallel(self, line_a: SolverLine, line_b: SolverLine) -> bool:
"""Constrain two lines to be parallel."""
try:
self.parallel(line_a.handle, line_b.handle, self.wp)
return True
except Exception as e:
logger.error(f"parallel constraint failed: {e}")
return False
def constrain_perpendicular(self, line_a: SolverLine, line_b: SolverLine) -> bool:
"""Constrain two lines to be perpendicular."""
try:
self.perpendicular(line_a.handle, line_b.handle, self.wp)
return True
except Exception as e:
logger.error(f"perpendicular constraint failed: {e}")
return False
def constrain_angle(self, line_a: SolverLine, line_b: SolverLine, angle_deg: float) -> bool:
"""Constrain angle between two lines in degrees."""
try:
angle_rad = math.radians(angle_deg)
self.angle(line_a.handle, line_b.handle, angle_rad, self.wp)
return True
except Exception as e:
logger.error(f"angle constraint failed: {e}")
return False
def constrain_equal_length(self, line_a: SolverLine, line_b: SolverLine) -> bool:
"""Constrain two lines to have equal length."""
try:
self.equal(line_a.handle, line_b.handle, self.wp)
return True
except Exception as e:
logger.error(f"equal length constraint failed: {e}")
return False
# ── Solving ──────────────────────────────────────────────────────────
def solve(self) -> int:
"""Solve all constraints. Returns ResultFlag as int."""
result = super().solve()
self._last_solve_result = result
if result == ResultFlag.OKAY:
# Update our stored point positions from solver params
self._sync_solved_positions()
return result
def _sync_solved_positions(self) -> None:
"""Update SolverPoint coordinates from solver's solved params."""
for point in self.points:
if point.handle and self.params(point.handle.params):
x, y = self.params(point.handle.params)
point.x = x
point.y = y
# ── Query ────────────────────────────────────────────────────────────
def get_solved_point_positions(self) -> Dict[int, Tuple[float, float]]:
"""Get map of entity_id -> (x, y) after solving."""
positions: Dict[int, Tuple[float, float]] = {}
for point in self.points:
if point.handle and self.params(point.handle.params):
x, y = self.params(point.handle.params)
positions[point.entity_id] = (x, y)
return positions
def is_point_on_line(
self, px: float, py: float, line: SolverLine, tolerance: float = 5.0
) -> bool:
"""Check if a point lies on a solver line (in world coords)."""
# Vector from start to point
ap_x = px - line.start.x
ap_y = py - line.start.y
# Vector from start to end
ab_x = line.end.x - line.start.x
ab_y = line.end.y - line.start.y
ab_len_sq = ab_x**2 + ab_y**2
if ab_len_sq == 0:
return False
# Project point onto line
t = (ap_x * ab_x + ap_y * ab_y) / ab_len_sq
t = max(0, min(1, t))
closest_x = line.start.x + t * ab_x
closest_y = line.start.y + t * ab_y
dist = math.sqrt((px - closest_x) ** 2 + (py - closest_y) ** 2)
return dist <= tolerance
# ── Clear / reset ────────────────────────────────────────────────────
def clear(self) -> None:
"""Clear all geometry from this solver sketch."""
self.points.clear()
self.lines.clear()
self.circles.clear()
self.wp = self.create_2d_base()
# ── Helpers ───────────────────────────────────────────────────────────────
def _extract_handle_nr(handle_str: str) -> int:
"""Extract numeric handle from string like 'Entity(handle=7, ...)'."""
match = re.search(r"handle=(\d+)", handle_str)
return int(match.group(1)) if match else 0
src/fluency/sketch_undo.py
+372
View File
@@ -0,0 +1,372 @@
"""
Undo/Redo manager for OCCSketch using snapshot-based approach.
python_solvespace has no per-entity delete API — the solver is rebuilt from
scratch after every modification. This makes snapshot-based undo natural:
we capture the complete sketch state (entities, geometry, constraints) and
restore it by rebuilding the solver from the snapshot data.
Each snapshot is ~10-50 KB depending on sketch complexity, and we cap the
stack at a configurable depth (default 50).
"""
from __future__ import annotations
import copy
import logging
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Set, Tuple
logger = logging.getLogger(__name__)
@dataclass
class SketchSnapshot:
"""Immutable snapshot of sketch state for undo/redo.
Captures everything needed to fully reconstruct an OCCSketch:
entities, points, lines, circles, arcs, counter, constraint log,
and the special entity id sets (centerlines, external/underlay).
"""
# Entity registry: id → (entity_type, geometry, is_construction, is_external, constraints_list)
entities: Dict[int, Tuple[str, Any, bool, bool, List[str]]] = field(default_factory=dict)
# Geometry sub-indices
points: Dict[int, Tuple[float, float]] = field(default_factory=dict)
lines: Dict[int, Tuple[int, int]] = field(default_factory=dict)
circles: Dict[int, Tuple[int, float]] = field(default_factory=dict)
arcs: Dict[int, Dict[str, Any]] = field(default_factory=dict)
# Counters and flags
entity_counter: int = 0
constraint_count: int = 0
first_point_id: Optional[int] = None
# Constraint replay log
constraint_log: List[Dict[str, Any]] = field(default_factory=list)
# Special entity sets
centerline_ids: Set[int] = field(default_factory=set)
external_entity_ids: Set[int] = field(default_factory=set)
# Workplane (so undo doesn't lose the placement plane)
wp_origin: Tuple[float, float, float] = (0.0, 0.0, 0.0)
wp_normal: Tuple[float, float, float] = (0.0, 0.0, 1.0)
wp_x_dir: Tuple[float, float, float] = (1.0, 0.0, 0.0)
wp_y_dir: Tuple[float, float, float] = (0.0, 1.0, 0.0)
class SketchUndoManager:
"""Manages undo/redo stacks of SketchSnapshot for an OCCSketch.
Usage::
undo_mgr = SketchUndoManager(sketch)
# Before any modification:
undo_mgr.save_state()
# ... perform modification ...
# Ctrl+Z:
undo_mgr.undo()
# Ctrl+Y / Ctrl+Shift+Z:
undo_mgr.redo()
"""
def __init__(self, sketch: Any, max_stack_size: int = 50) -> None:
from fluency.geometry_occ.sketch import OCCSketch
self._sketch: OCCSketch = sketch
self._max_stack_size = max_stack_size
self._undo_stack: List[SketchSnapshot] = []
self._redo_stack: List[SketchSnapshot] = []
# ─── Public API ────────────────────────────────────────────────────────
@property
def can_undo(self) -> bool:
"""True if there is a state to undo to."""
return len(self._undo_stack) > 0
@property
def can_redo(self) -> bool:
"""True if there is a state to redo to."""
return len(self._redo_stack) > 0
@property
def undo_depth(self) -> int:
"""Number of undo levels available."""
return len(self._undo_stack)
@property
def redo_depth(self) -> int:
"""Number of redo levels available."""
return len(self._redo_stack)
def save_state(self) -> None:
"""Capture the current sketch state and push it onto the undo stack.
Call this **before** any modifying operation (draw, delete, move,
constraint add/remove, construction toggle, etc.).
The redo stack is cleared whenever a new state is saved (i.e. when
the user makes a new change after undoing).
"""
snapshot = self._capture()
self._undo_stack.append(snapshot)
# Cap the stack size.
if len(self._undo_stack) > self._max_stack_size:
self._undo_stack.pop(0)
# New mutation invalidates the redo history.
self._redo_stack.clear()
logger.debug(
f"save_state: undo_depth={len(self._undo_stack)} "
f"entities={len(snapshot.entities)}"
)
def undo(self) -> bool:
"""Restore the previous sketch state.
Returns True if a state was restored, False if the undo stack is empty.
"""
if not self._undo_stack:
logger.debug("undo: stack empty")
return False
# Save current state to redo stack before restoring.
current_snapshot = self._capture()
self._redo_stack.append(current_snapshot)
# Pop and restore.
snapshot = self._undo_stack.pop()
self._restore(snapshot)
logger.debug(
f"undo: restored state with {len(snapshot.entities)} entities, "
f"undo_depth={len(self._undo_stack)} redo_depth={len(self._redo_stack)}"
)
return True
def redo(self) -> bool:
"""Re-apply the most recently undone state.
Returns True if a state was restored, False if the redo stack is empty.
"""
if not self._redo_stack:
logger.debug("redo: stack empty")
return False
# Save current state to undo stack before restoring.
current_snapshot = self._capture()
self._undo_stack.append(current_snapshot)
# Pop and restore.
snapshot = self._redo_stack.pop()
self._restore(snapshot)
logger.debug(
f"redo: restored state with {len(snapshot.entities)} entities, "
f"undo_depth={len(self._undo_stack)} redo_depth={len(self._redo_stack)}"
)
return True
def clear(self) -> None:
"""Clear both stacks (e.g. when loading a new sketch)."""
self._undo_stack.clear()
self._redo_stack.clear()
logger.debug("undo stacks cleared")
# ─── Snapshot Capture ──────────────────────────────────────────────────
def _capture(self) -> SketchSnapshot:
"""Capture the current sketch state into a snapshot."""
sketch = self._sketch
# Capture entities: id → (type, geometry, is_construction, is_external, constraints)
entities: Dict[int, Tuple[str, Any, bool, bool, List[str]]] = {}
for eid, ent in sketch._entities.items():
entities[eid] = (
ent.entity_type,
ent.geometry,
ent.is_construction,
ent.is_external,
list(ent.constraints), # copy the constraints list
)
# Deep copy the mutable dicts (points coords are tuples, so shallow is fine,
# but arcs contain dicts so we deep-copy those).
points = dict(sketch._points)
lines = dict(sketch._lines)
circles = dict(sketch._circles)
arcs = {k: copy.deepcopy(v) for k, v in sketch._arcs.items()}
# Constraint log entries contain tuples and sets — need careful copy.
constraint_log = []
for entry in sketch._constraint_log:
copied = {
"type": entry["type"],
"ids": tuple(entry["ids"]),
"params": tuple(entry["params"]) if entry.get("params") else (),
"labels": set(entry["labels"]) if entry.get("labels") else set(),
}
constraint_log.append(copied)
return SketchSnapshot(
entities=entities,
points=points,
lines=lines,
circles=circles,
arcs=arcs,
entity_counter=sketch._entity_counter,
constraint_count=sketch._constraint_count,
first_point_id=sketch._first_point_id,
constraint_log=constraint_log,
centerline_ids=set(sketch._centerline_ids),
external_entity_ids=set(sketch._external_entity_ids),
wp_origin=sketch._wp_origin,
wp_normal=sketch._wp_normal,
wp_x_dir=sketch._wp_x_dir,
wp_y_dir=sketch._wp_y_dir,
)
# ─── Snapshot Restore ──────────────────────────────────────────────────
def _restore(self, snapshot: SketchSnapshot) -> None:
"""Restore the sketch to a previously captured snapshot state."""
from fluency.geometry_occ.sketch import OCCSketch, OCCSketchEntity
sketch = self._sketch
# Clear the current solver and rebuild from scratch.
sketch._solver = sketch._solver.__class__() # SolverSystem()
sketch._wp = sketch._solver.create_2d_base()
sketch._first_point_id = None
# Restore counters and flags.
sketch._entity_counter = snapshot.entity_counter
sketch._constraint_count = snapshot.constraint_count
sketch._centerline_ids = set(snapshot.centerline_ids)
sketch._external_entity_ids = set(snapshot.external_entity_ids)
# Restore workplane.
sketch._wp_origin = snapshot.wp_origin
sketch._wp_normal = snapshot.wp_normal
sketch._wp_x_dir = snapshot.wp_x_dir
sketch._wp_y_dir = snapshot.wp_y_dir
# Rebuild entity objects from the snapshot.
sketch._entities.clear()
sketch._points.clear()
sketch._lines.clear()
sketch._circles.clear()
sketch._arcs.clear()
# First pass: re-add all points to the solver.
for eid in sorted(snapshot.entities.keys()):
etype, geometry, is_constr, is_ext, constraints = snapshot.entities[eid]
if etype == "point" and eid in snapshot.points:
x, y = snapshot.points[eid]
solver_handle = sketch._solver.add_point_2d(x, y, sketch._wp)
ent = OCCSketchEntity(
entity_id=eid,
entity_type="point",
geometry=(x, y),
handle=solver_handle,
)
ent.is_construction = is_constr
ent.is_external = is_ext
ent.constraints = list(constraints)
sketch._entities[eid] = ent
sketch._points[eid] = (x, y)
# Anchor the first point (or first external point) for solver stability.
if sketch._first_point_id is None and not is_ext:
sketch._first_point_id = eid
sketch._solver.dragged(solver_handle, sketch._wp)
elif sketch._first_point_id is None and is_ext:
sketch._first_point_id = eid
sketch._solver.dragged(solver_handle, sketch._wp)
# Second pass: re-add all lines.
for lid in sorted(snapshot.lines.keys()):
sid, eid2 = snapshot.lines[lid]
s_ent = sketch._entities.get(sid)
e_ent = sketch._entities.get(eid2)
if s_ent is None or e_ent is None or s_ent.handle is None or e_ent.handle is None:
continue
solver_handle = sketch._solver.add_line_2d(s_ent.handle, e_ent.handle, sketch._wp)
etype, geometry, is_constr, is_ext, constraints = snapshot.entities[lid]
ent = OCCSketchEntity(
entity_id=lid,
entity_type="line",
geometry=geometry,
handle=solver_handle,
)
ent.is_construction = is_constr
ent.is_external = is_ext
ent.constraints = list(constraints)
sketch._entities[lid] = ent
sketch._lines[lid] = (sid, eid2)
# Restore circles (not in solver, just tracked).
for cid, (center_id, radius) in snapshot.circles.items():
if cid in snapshot.entities:
etype, geometry, is_constr, is_ext, constraints = snapshot.entities[cid]
center_ent = sketch._entities.get(center_id)
ent = OCCSketchEntity(
entity_id=cid,
entity_type="circle",
geometry=geometry,
handle=None,
)
ent.is_construction = is_constr
ent.is_external = is_ext
ent.constraints = list(constraints)
sketch._entities[cid] = ent
sketch._circles[cid] = (center_id, radius)
# Restore arcs (not in solver, just tracked).
for aid, arc_data in snapshot.arcs.items():
if aid in snapshot.entities:
etype, geometry, is_constr, is_ext, constraints = snapshot.entities[aid]
ent = OCCSketchEntity(
entity_id=aid,
entity_type="arc",
geometry=geometry,
handle=None,
)
ent.is_construction = is_constr
ent.is_external = is_ext
ent.constraints = list(constraints)
sketch._entities[aid] = ent
sketch._arcs[aid] = copy.deepcopy(arc_data)
# Rebuild the constraint log (entries were deep-copied on capture).
sketch._constraint_log = []
for entry in snapshot.constraint_log:
sketch._constraint_log.append({
"type": entry["type"],
"ids": tuple(entry["ids"]),
"params": tuple(entry["params"]) if entry.get("params") else (),
"labels": set(entry["labels"]) if entry.get("labels") else set(),
})
# Re-apply all constraints to the solver.
for entry in sketch._constraint_log:
sketch._apply_constraint_log(entry)
# Solve to update geometry positions.
sketch.solve()
logger.debug(
f"Restored snapshot: {len(sketch._entities)} entities, "
f"{len(sketch._constraint_log)} constraints"
)
src/fluency/tests/test_project_io.py
+240
View File
@@ -0,0 +1,240 @@
"""Smoke test for project_io save/load round-trip.
Builds a small project (a Component with a sketch, an extrude body, a
workplane, plus an assembly with two instances and a connector) and
verifies that saving then loading it preserves the data.
"""
import os
import sys
import tempfile
import unittest
# Allow running this file directly: ``python tests/test_project_io.py``.
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir, "src"))
from fluency.io.project_io import save_project, load_project
from fluency.models.data_model import (
Project,
Component,
Body,
Workplane,
Assembly,
)
class TestProjectIO(unittest.TestCase):
"""Round-trip the same project through save/load and check equivalence."""
def _build_project(self) -> Project:
project = Project(name="Test Project", description="A tiny test")
project.file_path = None # simulate untitled
comp = project.add_component(Component(name="Part1"))
# Add a workplane.
wp = Workplane(
name="Top",
origin=(0.0, 0.0, 0.0),
normal=(0.0, 0.0, 1.0),
x_dir=(1.0, 0.0, 0.0),
)
comp.add_workplane(wp)
# Add a sketch with a square.
sk = comp.add_sketch()
sk.occ_sketch.add_rectangle((0.0, 0.0), (10.0, 10.0))
sk.solve()
# Build a face geometry for the sketch (needed for export / restore).
faces = sk.occ_sketch.detect_faces()
if faces:
sk.geometry = sk.occ_sketch.build_face_geometry(faces[0])
# Extrude into a body.
if sk.geometry:
kernel = project.kernel
body_shape = kernel.extrude(sk.geometry, height=20.0)
body = comp.add_body(
Body(
name="Block",
geometry=body_shape,
source_sketch=sk,
source_operation="extrude",
)
)
body.color = (0.4, 0.2, 0.8)
# Add an assembly with two instances and a mated connector pair.
asm = project.add_assembly(Assembly(name="Asm1"))
ac1 = asm.add_component_instance(comp.id, name="Inst1")
ac2 = asm.add_component_instance(comp.id, name="Inst2")
c1 = ac1.add_connector(
position=(5.0, 5.0, 0.0),
normal=(0.0, 0.0, 1.0),
x_dir=(1.0, 0.0, 0.0),
)
c2 = ac2.add_connector(
position=(10.0, 10.0, 5.0),
normal=(0.0, 0.0, -1.0),
x_dir=(1.0, 0.0, 0.0),
)
# Record a mated pair (UI normally does this on connector-pick).
conn = asm.add_connection(ac1.id, ac2.id)
conn.first_connector_id = c1.id
conn.second_connector_id = c2.id
c1.partner_ac_id = ac2.id
c1.partner_connector_id = c2.id
c2.partner_ac_id = ac1.id
c2.partner_connector_id = c1.id
c1.is_grounded = True
return project
def test_round_trip(self):
original = self._build_project()
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, "test.fluency")
saved_path = save_project(original, path)
self.assertTrue(os.path.exists(saved_path))
self.assertGreater(os.path.getsize(saved_path), 100)
loaded, view_state = load_project(saved_path)
# ── Project metadata ──
self.assertEqual(loaded.name, "Test Project")
self.assertEqual(loaded.description, "A tiny test")
self.assertEqual(len(loaded.components), 1)
self.assertEqual(len(loaded.assemblies), 1)
# ── Component / Workplane / Sketch / Body ──
comp = next(iter(loaded.components.values()))
self.assertEqual(comp.name, "Part1")
self.assertEqual(len(comp.workplanes), 1)
self.assertEqual(len(comp.sketches), 1)
self.assertEqual(len(comp.bodies), 1)
sk = next(iter(comp.sketches.values()))
self.assertIsNotNone(sk.occ_sketch)
# OCCSketch replayed the rectangle: 4 points + 4 lines + 1 implicit
# origin anchor (first-point-fix). We only check that the entities
# exist.
self.assertGreaterEqual(sk.occ_sketch.get_entity_count(), 4)
# Solved geometry should round-trip through STEP.
self.assertIsNotNone(sk.geometry)
body = next(iter(comp.bodies.values()))
self.assertIsNotNone(body.geometry)
self.assertEqual(body.name, "Block")
self.assertEqual(tuple(body.color), (0.4, 0.2, 0.8))
# BRep topology should still be valid.
self.assertGreater(body.get_mesh(loaded.kernel, 0.5)[0].size, 0)
# ── Assembly / connector / connection ──
asm = next(iter(loaded.assemblies.values()))
self.assertEqual(len(asm.components), 2)
self.assertEqual(len(asm.connections), 1)
ac1, ac2 = list(asm.components.values())
self.assertEqual(len(ac1.connectors), 1)
conn = next(iter(ac1.connectors.values()))
self.assertEqual(conn.position, (5.0, 5.0, 0.0))
# The grounded-reference flag was re-applied to the first connector.
self.assertTrue(conn.is_grounded)
# Rigid-group BFS should still link the two instances.
self.assertEqual(set(asm.get_rigid_group(ac1.id)), {ac1.id, ac2.id})
class TestProjectIOWithConstraints(unittest.TestCase):
"""Round-trip with parametric constraints on the sketch.
Builds a slightly more interesting sketch (rectangle with horizontal +
vertical constraints + a distance) so the constraint-log replay path
is exercised, not just the entity-construction path.
"""
def _build_project(self) -> Project:
project = Project(name="Constraints Project", description="")
comp = project.add_component(Component(name="Part1"))
# A square with a 25.4mm horizontal distance + a vertical distance,
# both anchored on a single fixed corner. This is the minimum
# number of constraints to fully define a square in 2D.
sk = comp.add_sketch()
sk.occ_sketch.set_workplane(
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
(1.0, 0.0, 0.0),
)
p1 = sk.occ_sketch.add_point(0.0, 0.0) # fixed anchor (auto)
p2 = sk.occ_sketch.add_point(25.4, 0.0)
p3 = sk.occ_sketch.add_point(25.4, 25.4)
p4 = sk.occ_sketch.add_point(0.0, 25.4)
sk.occ_sketch.add_line(p1, p2)
sk.occ_sketch.add_line(p2, p3)
sk.occ_sketch.add_line(p3, p4)
sk.occ_sketch.add_line(p4, p1)
# Constraint the right side to a known length (instead of relying
# on the construction positions, which would just be redundant).
sk.occ_sketch.constrain_distance(p2, p3, 25.4)
sk.solve()
sk.is_fully_constrained = sk.occ_sketch.is_fully_constrained()
faces = sk.occ_sketch.detect_faces()
if faces:
sk.geometry = sk.occ_sketch.build_face_geometry(faces[0])
# View state to persist.
view_state = {
"active_tab": 0,
"active_component_id": comp.id,
"active_sketch_id": sk.id,
"camera_eye": [50.0, 50.0, 50.0],
"camera_at": [0.0, 0.0, 0.0],
"camera_up": [0.0, 0.0, 1.0],
"panel_focus": "sketch",
"assembly_view_active": False,
}
self._view_state = view_state
return project
def test_round_trip_with_view_state(self):
original = self._build_project()
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, "constrained.fluency")
save_project(original, path, view_state=self._view_state)
loaded, view_state = load_project(path)
# View state must survive (modulo float-to-list round-tripping).
self.assertEqual(view_state.get("active_component_id"),
self._view_state["active_component_id"])
self.assertEqual(view_state.get("active_sketch_id"),
self._view_state["active_sketch_id"])
self.assertEqual(view_state.get("camera_eye"),
self._view_state["camera_eye"])
self.assertEqual(view_state.get("panel_focus"),
self._view_state["panel_focus"])
# Sketch must have replayed its constraints and remain solvable.
comp = next(iter(loaded.components.values()))
sk = next(iter(comp.sketches.values()))
# Re-solve on the loaded sketch to confirm the post-replay
# configuration is still consistent.
self.assertTrue(sk.occ_sketch.solve())
# The right edge of the square should still be 25.4mm tall.
import math
for lid, line in sk.occ_sketch._lines.items():
sid, eid = line
sx, sy = sk.occ_sketch._points[sid]
ex, ey = sk.occ_sketch._points[eid]
length = math.hypot(ex - sx, ey - sy)
if abs(length) > 1e-3:
self.assertAlmostEqual(
length, 25.4, places=3,
msg=f"Constraint replay broke: line {lid} = {length}",
)
break
if __name__ == "__main__":
unittest.main()
src/fluency/ui/__init__.py
+15
View File
@@ -0,0 +1,15 @@
"""Fluency CAD UI package.
Contains the Qt widgets, dialogs, and the main window:
ui/
dialogs.py – All 4 modal dialogs (Extrude, Revolve, Offset, WorkplaneOrientation)
sketch_widget.py – Sketch2DWidget (2D sketcher with constraint solver)
viewer_widget.py – Viewer3DWidget (3D viewer / OCC canvas)
main_window.py – MainWindow (application shell)
The public classes are re-exported from `fluency.main` so existing code that
does `from fluency.main import MainWindow` continues to work.
"""
__all__: list[str] = []

Some files were not shown because too many files have changed in this diff Show More