toolwake 0.1.0__tar.gz

toolwake-0.1.0/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project are documented here. Format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
+[Semantic Versioning](https://semver.org/).
+
+## [0.1.0] — 2026-09-14
+
+First release.
+
+### Added
+- `Toolpath` — load from G-code (`M82`/`M83` aware, so print and travel moves
+  are told apart correctly) or from `(N, 6)` pose files; `helix` and
+  `conical_helix` fixtures.
+- `Needle` / `ToolProfile` — tools as a coaxial stack of sections, the way CAM
+  describes one. `Needle.luer()` models a luer-lock dispensing tip whose hub is
+  roughly 50x the cannula diameter.
+- `Deposit` — accumulating wake with a spatial hash for broad phase and exact
+  capsule/box distance for narrow phase, plus a trailing-window rule so the
+  tool never collides with the bead it is currently extruding.
+- `simulate` — per-row clearance against everything laid earlier, naming which
+  section of the tool was closest.
+- `animate` — mp4/gif of the tool and its wake (needs matplotlib).
+- `to_html` / `to_html_str` — a self-contained interactive viewer with no
+  external requests; step between collisions, deep-link any frame.
+- `ToolwakeSession` / `asgi_routes` — serve the viewer for embedding in another
+  GUI, with a version poll so an iframe follows new results.
+- `toolwake` CLI; exits 2 on a collision so it drops into a pre-flight gate.

toolwake-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zane Bates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

toolwake-0.1.0/MANIFEST.in

@@ -0,0 +1,10 @@
+include LICENSE
+include README.md
+include CHANGELOG.md
+recursive-include tests *.py
+recursive-include examples *.py
+# Rendered output is regenerated by examples/demo.py; shipping it would bloat
+# the sdist by several MB for no benefit.
+prune examples/*.mp4
+prune examples/*.html
+global-exclude __pycache__ *.py[cod]

toolwake-0.1.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: toolwake
+Version: 0.1.0
+Summary: Simulate a depositing tool travelling a toolpath, accumulate the material it leaves in its wake, and check the tool against it.
+Author-email: Zane Bates <zanetbates1@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/zbates1/toolwake
+Project-URL: Issues, https://github.com/zbates1/toolwake/issues
+Project-URL: Changelog, https://github.com/zbates1/toolwake/blob/main/CHANGELOG.md
+Keywords: 3d-printing,non-planar,bioprinting,collision,toolpath,robotics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Provides-Extra: render
+Requires-Dist: matplotlib>=3.5; extra == "render"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: matplotlib>=3.5; extra == "dev"
+Dynamic: license-file
+
+# toolwake
+
+Simulate a depositing tool travelling a toolpath, accumulate the material it
+leaves in its wake, and check the tool against that wake.
+
+Built for non-planar bioprinting, where a tall part and a wide end effector can
+collide with material the printer laid down minutes earlier — a failure that
+ordinary slicer previews and robot self-collision checks both miss.
+
+The video and the numbers come from the same model, so the picture cannot
+disagree with the report.
+
+```python
+from toolwake import Toolpath, Needle, simulate, animate
+
+path   = Toolpath.helix(radius=0.018, pitch=0.0035, turns=7)
+needle = Needle(inner_d=90e-6, outer_d=0.4e-3, length=12.7e-3,
+                housing=(0.130, 0.075, 0.072))
+
+res = simulate(path, needle, lag=10)
+print(res.report())
+# {'status': 'ok', 'rows': 770, 'min_clearance_mm': 3.2626, ...}
+
+animate(res, "wake.mp4")        # video
+to_html(res, "wake.html")       # interactive, self-contained
+```
+
+The HTML viewer is one file with no external requests — drag to rotate, scrub
+the timeline, and step between collisions. `wake.html#worst` opens on the
+deepest penetration, and every frame is linkable as `#f=<row>`, so "look at the
+collision around row 506" becomes something you can send.
+
+Or from the shell:
+
+```bash
+toolwake helix -o wake.mp4
+toolwake part.gcode --housing 0.130 0.075 0.072 --report clearance.json
+toolwake part.gcode --html check.html --no-video
+```
+
+The CLI exits `2` on a collision, so it drops straight into a pre-flight gate.
+
+## Install
+
+```bash
+pip install toolwake            # core: numpy only
+pip install toolwake[render]    # + matplotlib for video
+                                # the HTML viewer needs neither
+```
+
+`.mp4` output needs ffmpeg on PATH. `.gif` does not.
+
+## Why it is built this way
+
+**The tool is a profile, the way CAM describes one.** A dispensing needle is
+not a single cylinder: a luer-lock tip is a thin cannula stepping up to a hub
+roughly 50x its diameter, then a locking collar. Sections stack from the tip
+upward, each a cylinder or a taper, so the model has the same holder / shank /
+flute structure a CAM simulation draws.
+
+```python
+Needle.luer(inner_d=90e-6)
+# ToolProfile(4 sections: cannula, taper, hub, luer collar;
+#             len=32.7 mm, r_max=5.50 mm)
+```
+
+Reports name the section that was closest, because "hub" and "cannula" call for
+different fixes.
+
+**Primitives, not meshes.** Each section is a capsule and the end effector is an
+oriented box, so the distance functions are exact and there is no mesh
+dependency. Tapers become capsules at their LARGEST radius — deliberately
+conservative, since a false stop costs a reprint and a missed collision costs
+the part. Pass `slices=` to follow a taper more tightly.
+
+**Model the housing, not just the tip.** The nozzle crossing an earlier bead is
+the failure people picture and the rarer one. On a tall part the housing is down
+inside the structure while the tip is somewhere harmless. `test_housing_catches_
+what_the_needle_misses` is that case in one test: a thin needle reports clear,
+a 130 mm body reports a collision, on the same path.
+
+**Non-planar is orientation, not just Z.** A 6-DOF path carries a rotation
+vector per row, read the way a UR reports pose, so rows move between the robot
+and here unchanged. `conical_helix` leans the tool to the wall's own slope;
+`with_tool_axis` turns any set of surface normals into orientations.
+
+Orientation only changes the answer when the closest approach is somewhere
+other than the tip — lean the tool and the tip has not moved, but the hub has
+swung several millimetres. That is the whole reason the body is modelled.
+
+**Deposit after measuring.** Each row is checked against the wake *before* its
+own material is added, and `lag` extends that immunity a few rows back —
+otherwise the tool always collides with the bead it is extruding right now.
+
+**Only print moves leave a wake.** Travel moves deposit nothing. Treating them
+as material fills the part with phantom obstacles and every later move reports a
+false collision. `Toolpath.from_gcode` handles both `M82` and `M83`, because
+whether a row extrudes depends on it and slicers disagree — Cura emits `M82`,
+PrusaSlicer `M83`.
+
+**Two-phase queries.** A uniform spatial hash narrows the candidate beads, then
+exact capsule/box distance measures against those only. A plain occupancy grid
+would give a binary answer quantised to the voxel size; this reports a real
+distance. The grid is sized to the *query* radius rather than the bead — getting
+that wrong made an early version 16x slower for identical results.
+
+## Embedding in another GUI
+
+`ToolwakeSession` holds the latest result and hands it out as HTML, so a host
+application can iframe it and let it follow new checks on its own.
+
+```python
+from toolwake import ToolwakeSession, Needle
+
+session = ToolwakeSession(needle=Needle.luer(inner_d=90e-6), lag=10)
+url = session.serve(port=7100)        # -> http://127.0.0.1:7100
+...
+session.run(toolpath)                 # the iframe reloads itself
+```
+
+The page polls a version endpoint, so re-checking a toolpath updates the view
+without the host telling it anything.
+
+If the host already runs a web framework, skip the extra port and mount the
+routes — same bytes, no second socket, no cross-origin handling:
+
+```python
+from fastapi import Response
+from toolwake.serve import asgi_routes
+
+for path, fn in asgi_routes(session):
+    def make(fn=fn):
+        def endpoint():
+            body, ctype = fn()
+            return Response(body, media_type=ctype)
+        return endpoint
+    app.get("/api/toolwake" + path)(make())
+```
+
+Then point an iframe at `/api/toolwake/view`. Routes are `/view`, `/version`
+and `/report.json`.
+
+> On some Windows machines a local security product stalls large responses over
+> loopback — measured here as 1 KB instant and 83 KB failing under a bare
+> stdlib handler with no toolwake code in the path. If `serve()` hangs, mount
+> the routes instead.
+
+## API
+
+| | |
+|---|---|
+| `Toolpath.from_gcode(path)` | parse G0/G1, infer print vs travel from E |
+| `Toolpath.from_arrays(xyz, kinds, rotvec)` | bring your own, 3-DOF or 6-DOF |
+| `Toolpath.from_poses(path)` | (N, 6) `x y z rx ry rz` pose file |
+| `Toolpath.with_tool_axis(axes)` | set orientation from per-row tool directions |
+| `Toolpath.helix(...)` | vertical-tool helix fixture |
+| `Toolpath.conical_helix(...)` | flaring wall; tool leans to stay normal |
+| `Needle(inner_d, outer_d, length, housing)` | plain cannula |
+| `Needle.luer(inner_d, ...)` | full luer tip: cannula, taper, hub, collar |
+| `ToolProfile([Section(...), ...])` | build any coaxial tool |
+| `simulate(path, needle, lag, threshold)` | → `Result` |
+| `Result.report()` | JSON-ready clearance summary |
+| `animate(result, "out.mp4")` | video of the tool and its wake |
+| `to_html(result, "out.html")` | interactive viewer, jumps between collisions |
+| `ToolwakeSession(...)` | re-checkable session, serves HTML for embedding |
+| `asgi_routes(session)` | route table to mount into an existing app |
+| `Deposit`, `Capsule`, `Box` | the pieces, usable directly |
+
+Distances are **metres** throughout; the report converts to mm.
+
+`Result.status` is `ok` / `warn` / `collision`, matching the usual clearance
+banding: penetration is a collision, anything inside `threshold` is a warning.
+
+## Limits
+
+- **Per-row sampling, not swept volumes.** A thin tool moving fast past a thin
+  wall can pass between sampled rows. Densify the path or add continuous
+  collision detection if that matters for your geometry.
+- **Beads are straight segments** between consecutive rows, with a constant
+  radius. Die swell, sag and variable extrusion width are not modelled.
+- **No process physics** — nothing here knows about cure, flow or adhesion.
+- **Preset hub dimensions are nominal.** `luer_taper_tip` defaults approximate a
+  34G half-inch tip; hubs vary between manufacturers. Measure the tip you run
+  and pass the real numbers.
+- `search` bounds how far a query looks. Beads beyond it are not measured and
+  the clearance returns `inf`. Raise it for a large housing.
+
+## Development
+
+```bash
+pip install -e .[dev]
+pytest
+```
+
+## Licence
+
+MIT

toolwake-0.1.0/README.md

@@ -0,0 +1,197 @@
+# toolwake
+
+Simulate a depositing tool travelling a toolpath, accumulate the material it
+leaves in its wake, and check the tool against that wake.
+
+Built for non-planar bioprinting, where a tall part and a wide end effector can
+collide with material the printer laid down minutes earlier — a failure that
+ordinary slicer previews and robot self-collision checks both miss.
+
+The video and the numbers come from the same model, so the picture cannot
+disagree with the report.
+
+```python
+from toolwake import Toolpath, Needle, simulate, animate
+
+path   = Toolpath.helix(radius=0.018, pitch=0.0035, turns=7)
+needle = Needle(inner_d=90e-6, outer_d=0.4e-3, length=12.7e-3,
+                housing=(0.130, 0.075, 0.072))
+
+res = simulate(path, needle, lag=10)
+print(res.report())
+# {'status': 'ok', 'rows': 770, 'min_clearance_mm': 3.2626, ...}
+
+animate(res, "wake.mp4")        # video
+to_html(res, "wake.html")       # interactive, self-contained
+```
+
+The HTML viewer is one file with no external requests — drag to rotate, scrub
+the timeline, and step between collisions. `wake.html#worst` opens on the
+deepest penetration, and every frame is linkable as `#f=<row>`, so "look at the
+collision around row 506" becomes something you can send.
+
+Or from the shell:
+
+```bash
+toolwake helix -o wake.mp4
+toolwake part.gcode --housing 0.130 0.075 0.072 --report clearance.json
+toolwake part.gcode --html check.html --no-video
+```
+
+The CLI exits `2` on a collision, so it drops straight into a pre-flight gate.
+
+## Install
+
+```bash
+pip install toolwake            # core: numpy only
+pip install toolwake[render]    # + matplotlib for video
+                                # the HTML viewer needs neither
+```
+
+`.mp4` output needs ffmpeg on PATH. `.gif` does not.
+
+## Why it is built this way
+
+**The tool is a profile, the way CAM describes one.** A dispensing needle is
+not a single cylinder: a luer-lock tip is a thin cannula stepping up to a hub
+roughly 50x its diameter, then a locking collar. Sections stack from the tip
+upward, each a cylinder or a taper, so the model has the same holder / shank /
+flute structure a CAM simulation draws.
+
+```python
+Needle.luer(inner_d=90e-6)
+# ToolProfile(4 sections: cannula, taper, hub, luer collar;
+#             len=32.7 mm, r_max=5.50 mm)
+```
+
+Reports name the section that was closest, because "hub" and "cannula" call for
+different fixes.
+
+**Primitives, not meshes.** Each section is a capsule and the end effector is an
+oriented box, so the distance functions are exact and there is no mesh
+dependency. Tapers become capsules at their LARGEST radius — deliberately
+conservative, since a false stop costs a reprint and a missed collision costs
+the part. Pass `slices=` to follow a taper more tightly.
+
+**Model the housing, not just the tip.** The nozzle crossing an earlier bead is
+the failure people picture and the rarer one. On a tall part the housing is down
+inside the structure while the tip is somewhere harmless. `test_housing_catches_
+what_the_needle_misses` is that case in one test: a thin needle reports clear,
+a 130 mm body reports a collision, on the same path.
+
+**Non-planar is orientation, not just Z.** A 6-DOF path carries a rotation
+vector per row, read the way a UR reports pose, so rows move between the robot
+and here unchanged. `conical_helix` leans the tool to the wall's own slope;
+`with_tool_axis` turns any set of surface normals into orientations.
+
+Orientation only changes the answer when the closest approach is somewhere
+other than the tip — lean the tool and the tip has not moved, but the hub has
+swung several millimetres. That is the whole reason the body is modelled.
+
+**Deposit after measuring.** Each row is checked against the wake *before* its
+own material is added, and `lag` extends that immunity a few rows back —
+otherwise the tool always collides with the bead it is extruding right now.
+
+**Only print moves leave a wake.** Travel moves deposit nothing. Treating them
+as material fills the part with phantom obstacles and every later move reports a
+false collision. `Toolpath.from_gcode` handles both `M82` and `M83`, because
+whether a row extrudes depends on it and slicers disagree — Cura emits `M82`,
+PrusaSlicer `M83`.
+
+**Two-phase queries.** A uniform spatial hash narrows the candidate beads, then
+exact capsule/box distance measures against those only. A plain occupancy grid
+would give a binary answer quantised to the voxel size; this reports a real
+distance. The grid is sized to the *query* radius rather than the bead — getting
+that wrong made an early version 16x slower for identical results.
+
+## Embedding in another GUI
+
+`ToolwakeSession` holds the latest result and hands it out as HTML, so a host
+application can iframe it and let it follow new checks on its own.
+
+```python
+from toolwake import ToolwakeSession, Needle
+
+session = ToolwakeSession(needle=Needle.luer(inner_d=90e-6), lag=10)
+url = session.serve(port=7100)        # -> http://127.0.0.1:7100
+...
+session.run(toolpath)                 # the iframe reloads itself
+```
+
+The page polls a version endpoint, so re-checking a toolpath updates the view
+without the host telling it anything.
+
+If the host already runs a web framework, skip the extra port and mount the
+routes — same bytes, no second socket, no cross-origin handling:
+
+```python
+from fastapi import Response
+from toolwake.serve import asgi_routes
+
+for path, fn in asgi_routes(session):
+    def make(fn=fn):
+        def endpoint():
+            body, ctype = fn()
+            return Response(body, media_type=ctype)
+        return endpoint
+    app.get("/api/toolwake" + path)(make())
+```
+
+Then point an iframe at `/api/toolwake/view`. Routes are `/view`, `/version`
+and `/report.json`.
+
+> On some Windows machines a local security product stalls large responses over
+> loopback — measured here as 1 KB instant and 83 KB failing under a bare
+> stdlib handler with no toolwake code in the path. If `serve()` hangs, mount
+> the routes instead.
+
+## API
+
+| | |
+|---|---|
+| `Toolpath.from_gcode(path)` | parse G0/G1, infer print vs travel from E |
+| `Toolpath.from_arrays(xyz, kinds, rotvec)` | bring your own, 3-DOF or 6-DOF |
+| `Toolpath.from_poses(path)` | (N, 6) `x y z rx ry rz` pose file |
+| `Toolpath.with_tool_axis(axes)` | set orientation from per-row tool directions |
+| `Toolpath.helix(...)` | vertical-tool helix fixture |
+| `Toolpath.conical_helix(...)` | flaring wall; tool leans to stay normal |
+| `Needle(inner_d, outer_d, length, housing)` | plain cannula |
+| `Needle.luer(inner_d, ...)` | full luer tip: cannula, taper, hub, collar |
+| `ToolProfile([Section(...), ...])` | build any coaxial tool |
+| `simulate(path, needle, lag, threshold)` | → `Result` |
+| `Result.report()` | JSON-ready clearance summary |
+| `animate(result, "out.mp4")` | video of the tool and its wake |
+| `to_html(result, "out.html")` | interactive viewer, jumps between collisions |
+| `ToolwakeSession(...)` | re-checkable session, serves HTML for embedding |
+| `asgi_routes(session)` | route table to mount into an existing app |
+| `Deposit`, `Capsule`, `Box` | the pieces, usable directly |
+
+Distances are **metres** throughout; the report converts to mm.
+
+`Result.status` is `ok` / `warn` / `collision`, matching the usual clearance
+banding: penetration is a collision, anything inside `threshold` is a warning.
+
+## Limits
+
+- **Per-row sampling, not swept volumes.** A thin tool moving fast past a thin
+  wall can pass between sampled rows. Densify the path or add continuous
+  collision detection if that matters for your geometry.
+- **Beads are straight segments** between consecutive rows, with a constant
+  radius. Die swell, sag and variable extrusion width are not modelled.
+- **No process physics** — nothing here knows about cure, flow or adhesion.
+- **Preset hub dimensions are nominal.** `luer_taper_tip` defaults approximate a
+  34G half-inch tip; hubs vary between manufacturers. Measure the tip you run
+  and pass the real numbers.
+- `search` bounds how far a query looks. Beads beyond it are not measured and
+  the clearance returns `inf`. Raise it for a large housing.
+
+## Development
+
+```bash
+pip install -e .[dev]
+pytest
+```
+
+## Licence
+
+MIT

toolwake-0.1.0/examples/demo.py

@@ -0,0 +1,82 @@
+"""Two runs: one that clears, one that does not.
+
+The second is the interesting one — it is the case a needle-tip-only check
+passes and a housing-aware check catches.
+"""
+import numpy as np
+
+from toolwake import Needle, Toolpath, animate, simulate
+from toolwake.toolpath import PRINT, TRAVEL
+
+
+def clean():
+    """A helix with enough pitch that the tool never revisits earlier material."""
+    path = Toolpath.helix(radius=0.018, pitch=0.0035, turns=7, per_turn=110)
+    needle = Needle(inner_d=90e-6, outer_d=0.4e-3, length=12.7e-3)
+    return path, needle
+
+
+def housing_collision():
+    """Print a tall wall, then travel back down beside it.
+
+    25 mm away: a 0.4 mm needle is comfortably clear, a 130 mm housing is not.
+    """
+    n = 150
+    wall = np.column_stack([np.zeros(n), np.zeros(n), np.linspace(0, 0.06, n)])
+    m = 60
+    aside = np.column_stack([np.full(m, 0.025), np.zeros(m),
+                             np.linspace(0.06, 0.0, m)])
+    path = Toolpath(np.vstack([wall, aside]),
+                    kinds=[PRINT] * n + [TRAVEL] * m)
+    needle = Needle(inner_d=90e-6, outer_d=0.4e-3, length=12.7e-3,
+                    housing=(0.130, 0.075, 0.072))
+    return path, needle
+
+
+if __name__ == "__main__":
+    for name, build in (("helix_wake", clean),
+                        ("housing_collision", housing_collision)):
+        path, needle = build()
+        res = simulate(path, needle, lag=10)
+        print(f"{name}: {res!r}")
+        print(f"  {res.report()}")
+        animate(res, f"examples/{name}.mp4", fps=30, max_frames=300)
+
+
+def nonplanar_two_walls():
+    """Two concentric walls; the second is printed with the tool tilted outward.
+
+    This is the realistic non-planar failure. A single vase wall rarely traps
+    its own tool — the body leans over empty space. Put a second feature beside
+    it and the leaning body sweeps straight through the one printed first.
+
+    Outer wall at r = 20 mm goes down first. The inner wall at r = 10 mm is
+    then printed with a 30 deg outward lean, which throws the hub about
+    20*sin(30) = 10 mm outward — exactly onto the outer wall.
+    """
+    import numpy as np
+    from toolwake import Needle, Toolpath
+    from toolwake.geometry import rotvec_from_axis
+    from toolwake.toolpath import PRINT, TRAVEL
+
+    def ring(radius, z0, z1, turns, per_turn, lean):
+        n = int(turns * per_turn)
+        t = np.linspace(0.0, turns * 2 * np.pi, n)
+        xyz = np.column_stack([radius * np.cos(t), radius * np.sin(t),
+                               np.linspace(z0, z1, n)])
+        axes = np.column_stack([np.sin(lean) * np.cos(t),
+                                np.sin(lean) * np.sin(t),
+                                np.full(n, np.cos(lean))])
+        return xyz, np.array([rotvec_from_axis(u) for u in axes])
+
+    outer_xyz, outer_rv = ring(0.020, 0.0, 0.030, 5, 80, 0.0)
+    inner_xyz, inner_rv = ring(0.010, 0.0, 0.030, 5, 80, np.radians(30.0))
+
+    # One travel hop between the two walls, which deposits nothing.
+    hop_xyz = np.array([inner_xyz[0]])
+    hop_rv = np.array([inner_rv[0]])
+
+    path = Toolpath(np.vstack([outer_xyz, hop_xyz, inner_xyz]),
+                    kinds=[PRINT] * len(outer_xyz) + [TRAVEL] + [PRINT] * len(inner_xyz),
+                    rotvec=np.vstack([outer_rv, hop_rv, inner_rv]))
+    return path, Needle.luer(inner_d=90e-6)

toolwake-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "toolwake"
+version = "0.1.0"
+description = "Simulate a depositing tool travelling a toolpath, accumulate the material it leaves in its wake, and check the tool against it."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Zane Bates", email = "zanetbates1@gmail.com" }]
+keywords = ["3d-printing", "non-planar", "bioprinting", "collision", "toolpath", "robotics"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Visualization",
+]
+dependencies = ["numpy>=1.21"]
+
+[project.optional-dependencies]
+render = ["matplotlib>=3.5"]
+dev = ["pytest>=7", "matplotlib>=3.5"]
+
+[project.scripts]
+toolwake = "toolwake.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/zbates1/toolwake"
+Issues = "https://github.com/zbates1/toolwake/issues"
+Changelog = "https://github.com/zbates1/toolwake/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

toolwake-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

toolwake-0.1.0/src/toolwake/__init__.py

@@ -0,0 +1,51 @@
+"""toolwake — simulate a depositing tool, accumulate its wake, check against it.
+
+    from toolwake import Toolpath, Needle, simulate, animate
+
+    path = Toolpath.helix(radius=0.02, pitch=0.004, turns=6)
+    res  = simulate(path, Needle(inner_d=90e-6, housing=(0.130, 0.075, 0.072)))
+    print(res.report())
+    animate(res, "wake.mp4")
+
+The wake the video draws and the wake the clearance numbers are measured
+against are the same object, so the picture cannot disagree with the report.
+"""
+from .deposit import Deposit
+from .geometry import (Box, Capsule, rotation_from_rotvec,
+                       rotvec_from_axis)
+from .simulate import Result, simulate
+from .viewer import to_html_str
+from .profile import Section, ToolProfile, blunt_cannula, luer_taper_tip
+from .tool import Needle, ToolPose
+from .toolpath import PRINT, TRAVEL, Toolpath
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Toolpath", "PRINT", "TRAVEL",
+    "Needle", "ToolPose",
+    "Section", "ToolProfile", "blunt_cannula", "luer_taper_tip",
+    "Deposit",
+    "Capsule", "Box", "rotation_from_rotvec", "rotvec_from_axis",
+    "simulate", "Result",
+    "animate", "to_html", "to_html_str", "ToolwakeSession",
+    "__version__",
+]
+
+
+def animate(*args, **kwargs):
+    """Render a Result to video. Imported lazily so matplotlib stays optional."""
+    from .render import animate as _animate
+    return _animate(*args, **kwargs)
+
+
+def ToolwakeSession(*args, **kwargs):
+    """A re-checkable simulation served as HTML, for embedding in another GUI."""
+    from .serve import ToolwakeSession as _S
+    return _S(*args, **kwargs)
+
+
+def to_html(*args, **kwargs):
+    """Write a standalone interactive viewer. No dependencies beyond numpy."""
+    from .viewer import to_html as _to_html
+    return _to_html(*args, **kwargs)