ventforge 0.1.0__tar.gz → 0.2.0__tar.gz

ventforge-0.2.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: ventforge
+Version: 0.2.0
+Summary: Parametric vent pattern designer with native GUI and MCP server
+License-Expression: GPL-3.0-or-later
+Keywords: vent,pattern,3d-printing,cnc,cad,mcp,parametric
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Manufacturing
+Classifier: Topic :: Multimedia :: Graphics :: Editors :: Vector-Based
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: shapely>=2
+Requires-Dist: ezdxf
+Requires-Dist: pillow
+Requires-Dist: mcp<3,>=2
+Provides-Extra: gui
+Requires-Dist: PySide6-Essentials>=6.5; extra == "gui"
+Provides-Extra: cad
+Requires-Dist: cadquery-ocp-novtk<8.1,>=8.0; extra == "cad"
+Provides-Extra: all
+Requires-Dist: ventforge[cad,gui]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: ventforge[all]; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# VentForge
+
+Design vent and perforation patterns for 3D printing, laser cutting and CNC, then export them as ready-to-use
+files. Use the desktop editor, or let an AI assistant such as Claude do the designing through the built-in
+MCP server. Both work on the same design file.
+
+## Features
+
+- **10 layouts:** grid (square, diamond, hexagon), random, path, spiral, concentric, fibonacci, crosslines,
+  voronoi stone cracks, flow lines, and custom points.
+- **Hole shapes:** circle, rounded rectangle, hexagon, polygon, star, or your own outline.
+- **Gradients:** vary size, spacing, angle or shape across the plate. Drive them with points, lines or
+  curves, with noise, or with a grayscale image.
+- **Boundary:** none, circle, rounded rectangle, or a drawn outline, with margin and clipping.
+- **Fan grilles:** one click for a 40–140 mm fan: holes only over the blades, 4 screw holes, and the
+  share of the fan opening left open (airflow).
+- **Keep-outs:** circles or rectangles that stay free of holes (bosses, logos, screws), optionally cut as holes.
+  Draw them on the canvas with the Keep-out tool (K; Shift for a circle, right-click to remove).
+- **Machining:** CNC tool radius (rounds inside corners, drops holes the cutter cannot reach) and laser
+  kerf compensation for SVG/DXF. Set a minimum feature (about 2× nozzle for 3D printing) to flag holes
+  that would close up.
+- **Export:** PNG, SVG, DXF, STEP, STL. You can also wrap the pattern onto a tube or cut it into an
+  existing STEP part.
+- **Checks:** hole count, open area, the thinnest wall in mm (marked on the canvas), and warnings where walls
+  get thinner than your minimum.
+- **Airflow estimate:** pressure loss of the grille (Idelchik thin perforated plate) at 2 m/s, so two designs
+  can be compared by airflow. A rough figure, not a flow simulation.
+- Undo/redo, presets, and a personal library (also from the AI assistant: `save_to_library`).
+
+## Install
+
+You need Python 3.11 or newer. Install the full app with [uv](https://docs.astral.sh/uv/) (recommended)
+or pipx:
+
+```bash
+uv tool install "ventforge[all]"
+```
+
+```bash
+pipx install "ventforge[all]"
+```
+
+Pick a smaller install if you don't need everything:
+
+| You want                                                  | Install                       |
+|-----------------------------------------------------------|-------------------------------|
+| Everything                                                | `ventforge[all]`              |
+| Desktop editor                                            | `ventforge[gui]`              |
+| STEP/STL export, tube wrap, cut into part (OpenCascade)   | `ventforge[cad]`              |
+| Only the MCP server with SVG, DXF and PNG export          | `ventforge`                   |
+
+## Use the desktop editor
+
+```bash
+ventforge
+```
+
+To open a saved design, pass its file: `ventforge my_vent.vent.json`.
+
+1. Pick a preset or a layout mode in the side panel.
+2. Drag the sliders. The preview updates as you go.
+3. Pick a file type from the **Export** menu.
+
+**Canvas controls**
+
+| Action            | How                                                           |
+|-------------------|---------------------------------------------------------------|
+| Zoom              | Mouse wheel, or `+` / `-`                                     |
+| Pan               | Drag empty space, middle-drag, or hold `Space` and drag       |
+| Zoom to fit       | `Z`, or double-click empty space                              |
+| Measure           | `R` (ruler)                                                   |
+| Draw an outline   | `B`, click the points, `Enter` to finish, `Esc` to cancel     |
+| Undo / redo       | `Ctrl+Z` / `Ctrl+Y`                                           |
+
+Your design saves itself shortly after each change.
+
+## Use it with an AI assistant (MCP)
+
+You don't need to install anything first, because uv downloads VentForge on demand.
+
+**Claude Code:**
+
+```bash
+claude mcp add ventforge -- uvx --from "ventforge[all]" ventforge --mcp
+```
+
+**Claude Desktop:** add this to `claude_desktop_config.json`, then restart the app:
+
+```json
+{
+  "mcpServers": {
+    "ventforge": {
+      "command": "uvx",
+      "args": ["--from", "ventforge[all]", "ventforge", "--mcp"]
+    }
+  }
+}
+```
+
+Then ask, for example: *"Make a 120 × 80 mm hexagon vent with 4 mm holes that get smaller toward the
+edges, and export it as STEP."*
+
+The assistant works on `~/Documents/VentForge/current.vent.json`. If you open that file in the editor
+(or ask the assistant to "open it in the GUI"), you can watch the design change live.
+
+**Tools the server offers:** `new_design`, `open_design`, `list_presets`, `save_to_library`, `get_design`,
+`describe_parameters`, `set_params`, `add_control`, `clear_controls`, `fan_grille`,
+`fit_open_area` (solve a parameter for a target open area), `preview`, `export`,
+`wrap_cylinder`, `cut_into_part`, `open_in_gui`.
+
+## Project layout
+
+```
+ventforge/
+├── model.py         design file format: every parameter and its default
+├── pattern.py       geometry: places and shapes the holes
+├── export.py        PNG, SVG, DXF, STEP and STL output, tube wrap, cut into part
+├── gui.py           desktop editor
+├── mcp_server.py    MCP tools for AI assistants
+├── __main__.py      `ventforge` command (editor, or MCP server with --mcp)
+└── presets/         example designs shipped with the package
+tests/               pytest suite, including a real MCP client/server run
+.github/workflows/   CI on Windows, macOS and Linux; publishes to PyPI on version tags
+```
+
+## Licence
+
+GPL-3.0-or-later, see [LICENSE](LICENSE). You may use, change and sell VentForge. Versions you distribute
+must stay open source under the same licence.

ventforge-0.2.0/README.md

@@ -0,0 +1,129 @@
+# VentForge
+
+Design vent and perforation patterns for 3D printing, laser cutting and CNC, then export them as ready-to-use
+files. Use the desktop editor, or let an AI assistant such as Claude do the designing through the built-in
+MCP server. Both work on the same design file.
+
+## Features
+
+- **10 layouts:** grid (square, diamond, hexagon), random, path, spiral, concentric, fibonacci, crosslines,
+  voronoi stone cracks, flow lines, and custom points.
+- **Hole shapes:** circle, rounded rectangle, hexagon, polygon, star, or your own outline.
+- **Gradients:** vary size, spacing, angle or shape across the plate. Drive them with points, lines or
+  curves, with noise, or with a grayscale image.
+- **Boundary:** none, circle, rounded rectangle, or a drawn outline, with margin and clipping.
+- **Fan grilles:** one click for a 40–140 mm fan: holes only over the blades, 4 screw holes, and the
+  share of the fan opening left open (airflow).
+- **Keep-outs:** circles or rectangles that stay free of holes (bosses, logos, screws), optionally cut as holes.
+  Draw them on the canvas with the Keep-out tool (K; Shift for a circle, right-click to remove).
+- **Machining:** CNC tool radius (rounds inside corners, drops holes the cutter cannot reach) and laser
+  kerf compensation for SVG/DXF. Set a minimum feature (about 2× nozzle for 3D printing) to flag holes
+  that would close up.
+- **Export:** PNG, SVG, DXF, STEP, STL. You can also wrap the pattern onto a tube or cut it into an
+  existing STEP part.
+- **Checks:** hole count, open area, the thinnest wall in mm (marked on the canvas), and warnings where walls
+  get thinner than your minimum.
+- **Airflow estimate:** pressure loss of the grille (Idelchik thin perforated plate) at 2 m/s, so two designs
+  can be compared by airflow. A rough figure, not a flow simulation.
+- Undo/redo, presets, and a personal library (also from the AI assistant: `save_to_library`).
+
+## Install
+
+You need Python 3.11 or newer. Install the full app with [uv](https://docs.astral.sh/uv/) (recommended)
+or pipx:
+
+```bash
+uv tool install "ventforge[all]"
+```
+
+```bash
+pipx install "ventforge[all]"
+```
+
+Pick a smaller install if you don't need everything:
+
+| You want                                                  | Install                       |
+|-----------------------------------------------------------|-------------------------------|
+| Everything                                                | `ventforge[all]`              |
+| Desktop editor                                            | `ventforge[gui]`              |
+| STEP/STL export, tube wrap, cut into part (OpenCascade)   | `ventforge[cad]`              |
+| Only the MCP server with SVG, DXF and PNG export          | `ventforge`                   |
+
+## Use the desktop editor
+
+```bash
+ventforge
+```
+
+To open a saved design, pass its file: `ventforge my_vent.vent.json`.
+
+1. Pick a preset or a layout mode in the side panel.
+2. Drag the sliders. The preview updates as you go.
+3. Pick a file type from the **Export** menu.
+
+**Canvas controls**
+
+| Action            | How                                                           |
+|-------------------|---------------------------------------------------------------|
+| Zoom              | Mouse wheel, or `+` / `-`                                     |
+| Pan               | Drag empty space, middle-drag, or hold `Space` and drag       |
+| Zoom to fit       | `Z`, or double-click empty space                              |
+| Measure           | `R` (ruler)                                                   |
+| Draw an outline   | `B`, click the points, `Enter` to finish, `Esc` to cancel     |
+| Undo / redo       | `Ctrl+Z` / `Ctrl+Y`                                           |
+
+Your design saves itself shortly after each change.
+
+## Use it with an AI assistant (MCP)
+
+You don't need to install anything first, because uv downloads VentForge on demand.
+
+**Claude Code:**
+
+```bash
+claude mcp add ventforge -- uvx --from "ventforge[all]" ventforge --mcp
+```
+
+**Claude Desktop:** add this to `claude_desktop_config.json`, then restart the app:
+
+```json
+{
+  "mcpServers": {
+    "ventforge": {
+      "command": "uvx",
+      "args": ["--from", "ventforge[all]", "ventforge", "--mcp"]
+    }
+  }
+}
+```
+
+Then ask, for example: *"Make a 120 × 80 mm hexagon vent with 4 mm holes that get smaller toward the
+edges, and export it as STEP."*
+
+The assistant works on `~/Documents/VentForge/current.vent.json`. If you open that file in the editor
+(or ask the assistant to "open it in the GUI"), you can watch the design change live.
+
+**Tools the server offers:** `new_design`, `open_design`, `list_presets`, `save_to_library`, `get_design`,
+`describe_parameters`, `set_params`, `add_control`, `clear_controls`, `fan_grille`,
+`fit_open_area` (solve a parameter for a target open area), `preview`, `export`,
+`wrap_cylinder`, `cut_into_part`, `open_in_gui`.
+
+## Project layout
+
+```
+ventforge/
+├── model.py         design file format: every parameter and its default
+├── pattern.py       geometry: places and shapes the holes
+├── export.py        PNG, SVG, DXF, STEP and STL output, tube wrap, cut into part
+├── gui.py           desktop editor
+├── mcp_server.py    MCP tools for AI assistants
+├── __main__.py      `ventforge` command (editor, or MCP server with --mcp)
+└── presets/         example designs shipped with the package
+tests/               pytest suite, including a real MCP client/server run
+.github/workflows/   CI on Windows, macOS and Linux; publishes to PyPI on version tags
+```
+
+## Licence
+
+GPL-3.0-or-later, see [LICENSE](LICENSE). You may use, change and sell VentForge. Versions you distribute
+must stay open source under the same licence.

{ventforge-0.1.0 → ventforge-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ventforge"
-version = "0.1.0"
+version = "0.2.0"
 description = "Parametric vent pattern designer with native GUI and MCP server"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{ventforge-0.1.0 → ventforge-0.2.0}/tests/test_export.py

@@ -97,6 +97,8 @@ def test_step_roundtrip_volume(tmp, make, t):
     assert len(sols) == 1
     ex._check(shape, "reimport")  # full BRepCheck when small, else volume/solid checks
     assert ex.volume(shape) == pytest.approx(expected_volume(res, t), rel=0.005)
+    # body named after the file (OCC appends a per-process counter)
+    assert f"PRODUCT('{make.__name__} " in p.read_text(errors="ignore")
 
 
 def test_step_multipart(tmp):
@@ -168,7 +170,10 @@ def _box_step(path, lx, ly, lz):
     ex._write(BRepPrimAPI_MakeBox(gp_Pnt(-lx / 2, -ly / 2, 0), lx, ly, lz).Shape(), path)
 
 
-def test_cut_into_part(tmp):
+@pytest.mark.parametrize("tiled", [False, True])
+def test_cut_into_part(tmp, monkeypatch, tiled):
+    if tiled:  # force the split-cut-merge path that big vents (> UNTILED_MAX holes) take
+        monkeypatch.setattr(ex, "UNTILED_MAX", 0)
     _box_step(tmp / "box.step", 120, 120, 10)
     pts = _grid(10, 8.0)
     res = _result([Point(x, y).buffer(2, 64) for x, y in pts] + [_hex(0, 0, 3)],

ventforge-0.2.0/tests/test_mcp.py

@@ -0,0 +1,94 @@
+import pytest
+"""Runs the MCP server over real stdio, the way Claude talks to it."""
+import asyncio
+
+from mcp_e2e import main
+
+
+def test_mcp_server_end_to_end(tmp_path):
+    asyncio.run(main(tmp_path))
+    assert (tmp_path / "e2e_preview.png").stat().st_size > 0
+    for ext in ("svg", "dxf", "step", "stl"):
+        assert (tmp_path / f"e2e.{ext}").stat().st_size > 0
+    assert (tmp_path / "e2e_tube.step").stat().st_size > 0
+
+
+def test_bad_patch_leaves_file_untouched(tmp_path):
+    import pytest
+    from ventforge import mcp_server as m
+    p = tmp_path / "d.vent.json"
+    m.new_design(path=str(p))
+    before = p.read_bytes()
+    with pytest.raises(ValueError):
+        m.set_params({"dot": {"shape": "blob"}})
+    assert p.read_bytes() == before
+
+
+def test_set_params_keeps_an_edit_saved_meanwhile(tmp_path, monkeypatch):
+    """The editor saving while set_params generates must not be overwritten."""
+    import os
+    from ventforge import mcp_server as m
+    from ventforge.model import Design
+    p = tmp_path / "d.vent.json"
+    m.new_design(path=str(p))
+    real, calls = m._generate, []
+
+    def generate_while_editor_saves(d):
+        if not calls:
+            e = Design.load(p)
+            e.dot.diameter = 2.5
+            e.save(p)
+            os.utime(p, ns=(p.stat().st_atime_ns, p.stat().st_mtime_ns + 10**9))  # coarse clocks
+        calls.append(1)
+        return real(d)
+
+    monkeypatch.setattr(m, "_generate", generate_while_editor_saves)
+    m.set_params({"canvas": {"width": 140}})
+    d = Design.load(p)
+    assert d.dot.diameter == 2.5 and d.canvas.width == 140
+
+
+def test_fit_open_area_hits_target(tmp_path):
+    from ventforge import mcp_server as m
+    m.new_design(path=str(tmp_path / "f.vent.json"))
+    out = m.fit_open_area(0.3)
+    assert abs(out["stats"]["open_area_ratio"] - 0.3) < 0.01
+    assert m.get_design()["design"]["dot"]["diameter"] == out["dot.diameter"]
+
+
+def test_fit_open_area_refuses_unreachable_target(tmp_path):
+    from ventforge import mcp_server as m
+    m.new_design(path=str(tmp_path / "f.vent.json"))
+    before = (tmp_path / "f.vent.json").read_text()
+    with pytest.raises(ValueError, match="outside"):
+        m.fit_open_area(0.3, low=0.5, high=0.6)
+    with pytest.raises(ValueError, match="ratio"):
+        m.fit_open_area(30)
+    with pytest.raises(ValueError, match="unknown parameter"):
+        m.fit_open_area(0.3, param="dot.nope")
+    assert (tmp_path / "f.vent.json").read_text() == before
+
+
+def test_fan_grille_tool_saves_and_reports_airflow(tmp_path):
+    from ventforge import mcp_server as m
+    m.new_design(path=str(tmp_path / "f.vent.json"))
+    out = m.fan_grille(80)
+    d = m.get_design()["design"]
+    assert d["canvas"]["width"] == 80 and len(d["keepouts"]) == 4
+    assert 0 < out["stats"]["fan_open_ratio"] < 1
+    fit = m.fit_open_area(0.5)  # targets the fan opening now
+    assert abs(fit["stats"]["fan_open_ratio"] - 0.5) < 0.01
+
+
+def test_library_round_trip(tmp_path, monkeypatch):
+    from ventforge import mcp_server as m
+    monkeypatch.setattr(m, "HOME", tmp_path)
+    m.new_design(path=str(tmp_path / "work.vent.json"))
+    m.fan_grille(92)
+    m.save_to_library("92mm case X")
+    assert "92mm case X" in m.list_presets()["library"]
+    m.new_design(path=str(tmp_path / "other.vent.json"), preset="92mm case X")
+    assert len(m.get_design()["design"]["keepouts"]) == 4
+    for bad in ("../evil", "a/b", ""):
+        with pytest.raises(ValueError):
+            m.save_to_library(bad)

{ventforge-0.1.0 → ventforge-0.2.0}/tests/test_pattern.py

@@ -1,3 +1,4 @@
+import math
 import time
 from pathlib import Path
 
@@ -288,6 +289,40 @@ def test_image_paths_resolve_against_design_file(tmp_path, monkeypatch):
     assert loaded.gradients.size.image == str((tmp_path / "fade.png").resolve())
     assert loaded.background.image == loaded.gradients.size.image
     assert generate(loaded).holes
+    loaded.save(tmp_path / "x.vent.json")  # saving again keeps the path relative (folder stays movable)
+    assert '"image": "fade.png"' in (tmp_path / "x.vent.json").read_text()
+
+
+def test_missing_image_is_a_clear_error(tmp_path):
+    d = Design().patched({"gradients": {"size": {"enabled": True, "image": str(tmp_path / "gone.png")}}})
+    with pytest.raises(FileNotFoundError, match="gone.png"):
+        generate(d)
+
+
+def test_unknown_choice_rejected():
+    with pytest.raises(ValueError, match="dot.shape"):
+        Design().patched({"dot": {"shape": "hexgon"}})
+    with pytest.raises(ValueError, match="rotate_by"):
+        Design().patched({"pattern": {"crosslines": {"rotate_by": "row"}}})
+
+
+def test_old_file_with_bad_choice_still_loads(tmp_path):
+    # 0.1.0 advertised row/col for crosslines; such files must open, falling back to the default
+    p = tmp_path / "old.vent.json"
+    p.write_text('{"pattern": {"mode": "crosslines", "crosslines": {"rotate_by": "row"}}}')
+    d = Design.load(p)
+    assert d.pattern.crosslines.rotate_by == "both" and d.pattern.mode == "crosslines"
+
+
+def test_fibonacci_even_density_with_hole():
+    d = Design().patched({"canvas": {"width": 200, "height": 200}, "dot": {"diameter": 1},
+                          "pattern": {"mode": "fibonacci", "fibonacci": {
+                              "count": 1500, "spread": 2.0, "inner_radius": 30}}})
+    r = np.hypot(*np.array([h.centroid.coords[0] for h in generate(d).holes]).T)
+    assert r.min() >= 29
+    inner = ((r >= 30) & (r < 45)).sum() / (np.pi * (45 ** 2 - 30 ** 2))
+    outer = ((r >= 60) & (r < 75)).sum() / (np.pi * (75 ** 2 - 60 ** 2))
+    assert inner == pytest.approx(outer, rel=0.15)
 
 
 def test_huge_concentric_radius_and_path_layers_stay_fast():
@@ -298,3 +333,97 @@ def test_huge_concentric_radius_and_path_layers_stay_fast():
         t = time.perf_counter()
         assert generate(Design().patched(patch)).holes
         assert time.perf_counter() - t < 4, patch  # was out-of-memory / 5 s
+
+
+@pytest.mark.parametrize("patch", [
+    {"canvas": {"width": 2000, "height": 2000}, "pattern": {"grid": {"spacing_x": 1, "spacing_y": 1}}},
+    {"canvas": {"width": 3000, "height": 3000}, "pattern": {"mode": "voronoi", "voronoi": {"cell_size": 1}}},
+    {"canvas": {"width": 3000, "height": 3000}, "pattern": {"mode": "concentric"}},
+])
+def test_huge_layouts_refused_fast(patch):
+    t = time.perf_counter()
+    with pytest.raises(ValueError, match="points"):
+        generate(Design().patched(patch))
+    assert time.perf_counter() - t < 2  # was minutes and gigabytes
+
+
+def test_bad_types_rejected():
+    with pytest.raises(ValueError, match="boundary.clip"):
+        Design().patched({"boundary": {"clip": "false"}})  # bool("false") would switch clipping on
+    with pytest.raises(ValueError, match="dot must be an object"):
+        Design().patched({"dot": 5})
+
+
+def test_fan_grille_holes_over_blades_and_screw_holes():
+    from ventforge.model import FANS, fan_grille
+    d = fan_grille(Design(), 120)
+    r = generate(d)
+    pitch, screw = FANS[120]
+    screws = {(round(c[0], 2), round(c[1], 2)) for c in r.circles if c and abs(c[2] - screw / 2) < 1e-9}
+    assert screws == {(sx * pitch / 2, sy * pitch / 2) for sx in (-1, 1) for sy in (-1, 1)}
+    opening = shapely.Point(0, 0).buffer(d.boundary.vent_diameter / 2 + 1e-6)
+    assert sum(opening.contains(h) for h in r.holes) == len(r.holes) - 4
+    assert 0.2 < r.stats["fan_open_ratio"] < 0.8
+    with pytest.raises(ValueError, match="fan size"):
+        fan_grille(Design(), 77)
+
+
+def test_keepout_stays_free():
+    d = Design().patched({"keepouts": [{"shape": "rectangle", "x": 10, "y": -5, "width": 30, "height": 12,
+                                        "clearance": 2}]})
+    zone = shapely.box(10 - 17, -5 - 8, 10 + 17, -5 + 8).buffer(-1e-6)  # touching the edge is fine
+    holes = generate(d).holes
+    assert holes and not any(zone.intersects(h) for h in holes)
+
+
+def test_tool_radius_rounds_corners_and_drops_too_small():
+    d = Design().patched({"dot": {"shape": "rounded_rectangle", "corner_radius": 0, "diameter": 4}})
+    sharp = generate(d)
+    d.machining.tool_radius = 1.0
+    r = generate(d)
+    assert len(r.holes) == len(sharp.holes)
+    assert r.holes[0].area == pytest.approx(16 - (4 - math.pi) * 1.0, rel=0.02)  # 4 corners lose (1 - pi/4) r^2
+    d.machining.tool_radius = 2.5  # wider than the 4 mm holes
+    assert generate(d).stats["dropped_by_tool"] == len(sharp.holes)
+
+
+def test_kerf_offsets_cut_paths():
+    from ventforge.export import cut_paths
+    d = Design()
+    d.machining.kerf = 0.2
+    r = generate(d)
+    c = cut_paths(r, d)
+    assert c.circles[0][2] == pytest.approx(r.circles[0][2] - 0.1)
+    assert c.outline.area > r.outline.area
+
+
+def test_keepout_hole_is_cut_with_free_clearance_around_it():
+    d = Design().patched({"keepouts": [{"shape": "rectangle", "x": 0, "y": 0, "width": 10, "height": 6,
+                                        "hole": True}]})
+    r = generate(d)
+    assert any(h.equals_exact(shapely.box(-5, -3, 5, 3), 1e-6) or abs(h.area - 60) < 1e-6 for h in r.holes)
+    assert not any(h.intersects(shapely.box(-6.4, -4.4, 6.4, 4.4)) for h in r.holes if abs(h.area - 60) > 1e-6)
+
+
+def test_thinnest_wall_found_and_located():
+    d = Design().patched({"pattern": {"mode": "custom_points", "custom_points": {"points": [[0, 0], [5, 0], [30, 30]]}},
+                          "dot": {"diameter": 4}})
+    s = generate(d).stats
+    assert s["thinnest_wall"] == pytest.approx(1.0, abs=0.01)  # centres 5 apart, radius 2 each
+    assert s["thinnest_wall_at"] == pytest.approx([2.5, 0], abs=0.05)
+
+
+def test_airflow_loss_drops_as_open_area_grows():
+    small = generate(Design().patched({"dot": {"diameter": 2}})).stats
+    big = generate(Design().patched({"dot": {"diameter": 4}})).stats
+    assert big["open_area_ratio"] > small["open_area_ratio"]
+    assert 0 < big["pressure_drop_pa"] < small["pressure_drop_pa"]
+    assert big["pressure_drop_pa"] == pytest.approx(big["loss_coefficient"] * 1.2 * 4 / 2)
+
+
+def test_min_feature_flags_narrow_holes():
+    d = Design().patched({"dot": {"diameter": 3}})
+    assert "below_min_feature" not in generate(d).stats
+    d.machining.min_feature = 3.5
+    s = generate(d).stats
+    assert s["below_min_feature"] == s["count"]

{ventforge-0.1.0 → ventforge-0.2.0}/ventforge/export.py

@@ -12,7 +12,7 @@ import time
 from pathlib import Path
 
 import shapely
-from shapely.geometry import MultiPolygon, Polygon
+from shapely.geometry import Polygon
 from shapely.geometry.polygon import orient
 from shapely.strtree import STRtree
 
@@ -280,8 +280,10 @@ def _write(shape, path, tolerance: float = 0.05):
         from OCP.Interface import Interface_Static
         from OCP.STEPControl import STEPControl_AsIs, STEPControl_Writer
 
+        w = STEPControl_Writer()  # registers the write.step.* statics, so set them after this
         Interface_Static.SetCVal_s("write.step.unit", "MM")
-        w = STEPControl_Writer()
+        # body name in CAD; OCC's default is "Open CASCADE STEP translator 8.0 1"
+        Interface_Static.SetCVal_s("write.step.product.name", path.stem)
         w.Transfer(shape, STEPControl_AsIs)
         if w.Write(str(path)) != IFSelect_RetDone:
             raise RuntimeError(f"STEP write failed: {path}")
@@ -480,10 +482,13 @@ def _cut(base, tools, what: str, planes=()):
 
 
 TOOLS_PER_CELL = 50
+UNTILED_MAX = 600  # up to this many holes one cut is as fast as tiling, and leaves no seams on the part
 
 
 def _grid_planes(n_tools, u_range, v_range, plane_u, plane_v):
     """k-1 cut planes along each axis, k chosen for ~TOOLS_PER_CELL tools per cell."""
+    if n_tools <= UNTILED_MAX:
+        return []
     k = math.ceil(math.sqrt(n_tools / TOOLS_PER_CELL))
     out = []
     for i in range(1, k):
@@ -613,14 +618,35 @@ def cut_into_part(result: Result, design: Design, part_path, out_path, origin=(0
 
 
 # --------------------------------------------------------------------------- dispatch
+def cut_paths(result: Result, design: Design) -> Result:
+    """Laser/waterjet kerf: the beam centre runs kerf/2 inside each hole and outside the outline, so the cut
+    part has the designed size. Holes narrower than the kerf are dropped."""
+    k = design.machining.kerf / 2
+    if k <= 0:
+        return result
+    holes, circles = [], []
+    for i, h in enumerate(result.holes):
+        c = _circle(result, i)
+        if c:
+            if c[2] > k:
+                holes.append(h)
+                circles.append((c[0], c[1], c[2] - k))
+            continue
+        for p in _parts(h.buffer(-k, join_style="mitre")):
+            holes.append(p)
+            circles.append(None)
+    return Result(holes=holes, outline=result.outline.buffer(k, join_style="mitre"), stats=result.stats,
+                  circles=circles)
+
+
 def export(result: Result, design: Design, path) -> None:
     ext = Path(path).suffix.lower()
     if ext == ".svg":
-        to_svg(result, design, path)
+        to_svg(cut_paths(result, design), design, path)
     elif ext == ".png":
         to_png(result, design, path)
     elif ext == ".dxf":
-        to_dxf(result, path)
+        to_dxf(cut_paths(result, design), path)
     elif ext in (".step", ".stp"):
         to_step(result, design, path)
     elif ext == ".stl":