ventforge 0.1.1__tar.gz → 0.2.0__tar.gz

{ventforge-0.1.1 → ventforge-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventforge
-Version: 0.1.1
+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
@@ -43,10 +43,20 @@ MCP server. Both work on the same design file.
 - **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, and warnings where walls get thinner than your minimum.
-- Undo/redo, presets, and a personal library.
+- **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
 
@@ -124,8 +134,9 @@ 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`, `get_design`,
-`describe_parameters`, `set_params`, `add_control`, `clear_controls`, `preview`, `export`,
+**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-0.1.1 → ventforge-0.2.0}/README.md

@@ -12,10 +12,20 @@ MCP server. Both work on the same design file.
 - **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, and warnings where walls get thinner than your minimum.
-- Undo/redo, presets, and a personal library.
+- **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
 
@@ -93,8 +103,9 @@ 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`, `get_design`,
-`describe_parameters`, `set_params`, `add_control`, `clear_controls`, `preview`, `export`,
+**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-0.1.1 → ventforge-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ventforge"
-version = "0.1.1"
+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.1 → ventforge-0.2.0}/tests/test_export.py

@@ -170,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.1 → ventforge-0.2.0}/tests/test_pattern.py

@@ -1,3 +1,4 @@
+import math
 import time
 from pathlib import Path
 
@@ -305,6 +306,14 @@ def test_unknown_choice_rejected():
         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": {
@@ -324,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.1 → 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
 
@@ -618,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":

{ventforge-0.1.1 → ventforge-0.2.0}/ventforge/gui.py

@@ -12,21 +12,21 @@ from dataclasses import fields, is_dataclass
 from pathlib import Path
 from typing import get_type_hints
 
-from PySide6.QtCore import QPointF, QRectF, QSettings, QSize, Qt, QThread, QTimer, QFileSystemWatcher, Signal
+from PySide6.QtCore import QPointF, QRectF, QSettings, QSize, QSizeF, Qt, QThread, QTimer, QFileSystemWatcher, Signal
 from PySide6.QtGui import (QAction, QBrush, QColor, QIcon, QKeySequence, QPainter, QPainterPath,
                            QPainterPathStroker, QPalette, QPen, QPixmap, QPolygonF, QTransform)
 from PySide6.QtWidgets import (QAbstractSpinBox, QApplication, QButtonGroup, QCheckBox, QColorDialog, QComboBox,
                                QDialog, QDialogButtonBox, QDockWidget, QDoubleSpinBox, QFileDialog, QFormLayout,
                                QGraphicsEllipseItem, QGraphicsItem, QGraphicsPixmapItem, QGraphicsScene,
-                               QGraphicsView, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QListWidget,
+                               QGraphicsView, QGridLayout, QHBoxLayout, QInputDialog, QLabel, QLineEdit, QListWidget,
                                QListWidgetItem, QMainWindow, QMessageBox, QProgressBar, QPushButton, QScrollArea,
                                QSizePolicy, QSlider, QSpinBox, QStackedWidget, QStyle, QTabWidget, QToolButton,
                                QVBoxLayout, QWidget)
 
-from .model import (CHOICES, MODES, SHAPES, Control, Design, DotStyle, Gradient, Pattern)
+from .model import (CHOICES, FANS, GRADS, MODES, SHAPES, Control, Design, DotStyle, Gradient, Keepout,
+                    Machining, Pattern, fan_grille)
 
 PRESETS = Path(__file__).resolve().parent / "presets"
-GRADS = ("size", "spacing", "angle", "shape")
 
 
 def pattern():  # imported lazily so the GUI module loads even while pattern.py is missing
@@ -45,6 +45,7 @@ META = {  # name: (min, max, step, suffix)
     "opacity": (0, 1, 0.05, ""), "offset_x": (-500, 500, 0.5, " mm"), "offset_y": (-500, 500, 0.5, " mm"),
     "turns": (0.1, 200, 0.5, ""), "spread": (0.1, 50, 0.1, ""), "width": (1, 5000, 1, " mm"),
     "height": (1, 5000, 1, " mm"), "thickness": (0.1, 100, 0.1, " mm"), "diameter": (0.1, 500, 0.1, " mm"),
+    "kerf": (0, 2, 0.01, " mm"), "tool_radius": (0, 20, 0.05, " mm"), "min_feature": (0, 20, 0.05, " mm"),
 }
 MM_WORDS = ("spacing", "radius", "diameter", "distance", "width", "margin", "size", "amplitude",
             "wavelength", "scale", "min_wall")
@@ -73,7 +74,8 @@ SOFT_PATH = {
     "pattern.concentric.inner_radius": (0, 60), "pattern.concentric.outer_radius": (0, 70),
     "pattern.fibonacci.count": (10, 700), "pattern.fibonacci.spread": (1, 10),
     "pattern.fibonacci.inner_radius": (0, 40), "pattern.crosslines.rotation": (-90, 90),
-    "pattern.voronoi.corner_radius": (0, 5), "pattern.flowlines.line_spacing": (2, 30),
+    "pattern.voronoi.corner_radius": (0, 5), "boundary.vent_diameter": (0, 300),
+    "machining.kerf": (0, 0.5), "machining.tool_radius": (0, 3), "machining.min_feature": (0, 3), "pattern.flowlines.line_spacing": (2, 30),
 }
 SOFT = {"diameter": (0.3, 20), "thickness": (0.5, 10), "margin": (0, 20), "corner_radius": (0, 20),
         "aspect": (0.2, 5), "sides": (3, 12), "star_points": (3, 12), "star_inner": (0.1, 0.9),
@@ -196,6 +198,13 @@ def _add_geom(path, g):
             path.closeSubpath()
 
 
+def add_keepout_path(path, k):
+    if k.shape == "rectangle":
+        path.addRect(QRectF(S(k.x - k.width / 2, k.y + k.height / 2), QSizeF(k.width, k.height)))
+    else:
+        path.addEllipse(S(k.x, k.y), k.width / 2, k.width / 2)
+
+
 def result_paths(r):
     holes = QPainterPath()
     holes.setFillRule(Qt.OddEvenFill)
@@ -540,6 +549,12 @@ class Canvas(QGraphicsView):
         self.decor.setZValue(3)
         self.draft = sc.addPath(QPainterPath(), QPen(QColor(255, 120, 120), 0))
         self.draft.setZValue(4)
+        self.keep = sc.addPath(QPainterPath(), QPen(QColor(255, 170, 60), 0, Qt.DashLine))
+        self.keep.setZValue(3)
+        self.weak = sc.addEllipse(-7, -7, 14, 14, QPen(QColor(255, 80, 80), 2))  # thinnest wall marker, in px
+        self.weak.setFlag(QGraphicsItem.ItemIgnoresTransformations)
+        self.weak.setZValue(6)
+        self.weak.setVisible(False)
         self.ruler = sc.addLine(0, 0, 0, 0, QPen(QColor(255, 255, 255), 0))
         self.ruler.setZValue(5)
         self.ruler_txt = sc.addSimpleText("")
@@ -574,6 +589,16 @@ class Canvas(QGraphicsView):
         self.holes.setBrush(QColor(color))
         self.plate.setPath(outline)
 
+    def set_overlays(self, keepouts, weak, bad):
+        path = QPainterPath()
+        for k in keepouts:
+            add_keepout_path(path, k)
+        self.keep.setPath(path)
+        self.weak.setVisible(weak is not None)
+        if weak is not None:
+            self.weak.setPos(S(*weak))
+            self.weak.setPen(QPen(QColor(255, 80, 80) if bad else QColor(240, 210, 90), 2))
+
     def set_background(self, pm, w, h, opacity):
         self.bg.setVisible(pm is not None)
         if pm is not None:
@@ -692,6 +717,11 @@ class Canvas(QGraphicsView):
         if self.tool == "ruler" and e.button() == Qt.LeftButton:
             self.ruler_start = pos
             self._ruler(pos)
+        elif self.tool == "keepout":
+            if e.button() == Qt.RightButton:
+                self.win.remove_keepout(pos.x(), -pos.y())
+            elif e.button() == Qt.LeftButton:
+                self.ruler_start = pos
         elif self.tool == "draw":
             if e.button() == Qt.RightButton:
                 self.finish_draw()
@@ -715,6 +745,12 @@ class Canvas(QGraphicsView):
             self._ruler(pos)
         elif self.tool == "draw" and self.draft_pts:
             self._draft(pos)
+        elif self.tool == "keepout" and self.ruler_start is not None:
+            path = QPainterPath()
+            if k := self._keepout(pos, e.modifiers()):
+                self.win.statusBar().showMessage(f"{k.shape} {k.width:.1f} × {k.height:.1f} mm at ({k.x:.1f}, {k.y:.1f})")
+                add_keepout_path(path, k)
+            self.draft.setPath(path)
         else:
             super().mouseMoveEvent(e)
 
@@ -723,6 +759,13 @@ class Canvas(QGraphicsView):
             self.pan_pos = None
             self.viewport().setCursor(Qt.CrossCursor if self.tool else Qt.OpenHandCursor)
             return
+        if self.tool == "keepout" and self.ruler_start is not None and e.button() == Qt.LeftButton:
+            k = self._keepout(self.mapToScene(e.position().toPoint()), e.modifiers())
+            self.ruler_start = None
+            self.draft.setPath(QPainterPath())
+            if k:
+                self.win.add_keepout(k)
+            return
         super().mouseReleaseEvent(e)
         if self.tool is None:
             self.win.commit()  # end of a handle drag
@@ -761,6 +804,18 @@ class Canvas(QGraphicsView):
         self.ruler_txt.setPos(pos + QPointF(2 / self.transform().m11(), 0))
         self.win.statusBar().showMessage(f"Distance {d:.2f} mm, dx {pos.x() - a.x():.2f}, dy {a.y() - pos.y():.2f}")
 
+    def _keepout(self, pos, mods):
+        """Drag corner to corner for a rectangle; with Shift, from the centre for a circle."""
+        a = self.ruler_start
+        if mods & Qt.ShiftModifier:
+            r = math.hypot(pos.x() - a.x(), pos.y() - a.y())
+            return Keepout("circle", round(a.x(), 2), round(-a.y(), 2), round(2 * r, 2), round(2 * r, 2)) if r > .25 else None
+        w, h = abs(pos.x() - a.x()), abs(pos.y() - a.y())
+        if min(w, h) < .5:
+            return None
+        return Keepout("rectangle", round((a.x() + pos.x()) / 2, 2), round(-(a.y() + pos.y()) / 2, 2),
+                       round(w, 2), round(h, 2))
+
     def _draft(self, cursor):
         path = QPainterPath(self.draft_pts[0])
         for q in self.draft_pts[1:] + [cursor]:
@@ -841,7 +896,9 @@ class MainWindow(QMainWindow):
         tb.addSeparator()
         self.ruler_act = act("Ruler", lambda on: self.set_tool("ruler" if on else None), "R", True)
         self.draw_act = act("Draw outline", lambda on: self.set_tool("draw" if on else None), "B", True)
+        self.keep_act = act("Keep-out", lambda on: self.set_tool("keepout" if on else None), "K", True)
         act("Zoom to fit", self.canvas.zoom_fit, "Z")
+        act("Fan grille…", self.fan_dialog).setToolTip("Plate for a standard fan: blade opening and 4 screw holes")
         tb.addSeparator()
         menu_btn = QToolButton(text="  Export  ", popupMode=QToolButton.InstantPopup)
         menu_btn.setObjectName("export")
@@ -964,6 +1021,10 @@ class MainWindow(QMainWindow):
         bf.addRow(row(button("Draw outline", lambda: self.draw_act.trigger(),
                              "Click points on the canvas; double-click, Enter or right-click to finish"),
                       button("Clear outline", lambda: self.set_param("boundary.points", []))))
+        bf.addRow("Keep-outs", self.field_widget("keepouts", "keepouts", list))
+        bf.addRow(row(button("Clear keep-outs", lambda: self.set_param("keepouts", []),
+                             "Screw holes and hole-free areas (set by Fan grille or the MCP server)")))
+        mcw, _, _ = self.form("machining", Machining)
         # background
         gw = QWidget()
         gf = QFormLayout(gw)
@@ -974,7 +1035,7 @@ class MainWindow(QMainWindow):
         gf.addRow(row(button("Load image…", self.load_background),
                       button("Clear", lambda: self.set_param("background.image", ""))))
         self._dock("Design", [Section("Library", lib), Section("Canvas", cw), Section("Boundary", bw),
-                              Section("Background image", gw, False)], Qt.LeftDockWidgetArea)
+                              Section("Machining", mcw, False), Section("Background image", gw, False)], Qt.LeftDockWidgetArea)
 
     def _right_dock(self):
         self.grad_tabs = QTabWidget()
@@ -1049,7 +1110,9 @@ class MainWindow(QMainWindow):
             elif isinstance(w, QLineEdit):
                 w.setText(str(v))
             elif isinstance(w, QLabel):
-                w.setText(f"{len(v)} point(s) — edit via file / MCP" if v else "none (default)")
+                w.setText(f"{len(v)} {'keep-out' if path == 'keepouts' else 'point'}(s)" + (" — draw with K, right-click to remove"
+                          if path == 'keepouts' else " — edit via file / MCP")
+                          if v else "none (default)")
             w.blockSignals(False)
         for w in self.findChildren(SliderField):  # canvas-relative slider ranges
             if getattr(w, "path", None) in SCALE:
@@ -1275,11 +1338,39 @@ class MainWindow(QMainWindow):
     def set_tool(self, tool):
         self.ruler_act.setChecked(tool == "ruler")
         self.draw_act.setChecked(tool == "draw")
+        self.keep_act.setChecked(tool == "keepout")
         self.canvas.set_tool(tool)
+        if tool == "keepout":
+            self.statusBar().showMessage("Drag a hole-free rectangle (Shift: circle from its centre); right-click one to"
+                                         " remove it, Esc to finish")
         if tool == "draw":
             self.statusBar().showMessage("Click to add outline points; double-click / Enter / right-click to finish,"
                                          " Esc to cancel")
 
+    def fan_dialog(self):
+        sizes = [f"{s} mm" for s in FANS]
+        s, ok = QInputDialog.getItem(self, "Fan grille", "Fan size (the hole pattern stays):", sizes, sizes.index("120 mm"),
+                                     False)
+        if ok:
+            self.need_fit = True
+            self.set_design(fan_grille(clone(self.design), int(s.split()[0])))
+            self.dirty = True
+            self.autosave()
+
+    def add_keepout(self, k):
+        self.design.keepouts.append(k)
+        self.changed(sync=True)
+        self.commit()
+
+    def remove_keepout(self, x, y):
+        from .pattern import _keepout_geom
+        from shapely import Point
+        hit = [i for i, k in enumerate(self.design.keepouts) if _keepout_geom(k).buffer(1).contains(Point(x, y))]
+        if hit:
+            del self.design.keepouts[hit[-1]]  # the topmost (last drawn)
+            self.changed(sync=True)
+            self.commit()
+
     def set_custom_boundary(self, pts):
         self.design.boundary.points = pts
         self.design.boundary.type = "custom"
@@ -1322,9 +1413,17 @@ class MainWindow(QMainWindow):
         self.canvas.set_result(holes, outline, self.design.dot.color)
         s = r.stats
         self.st["count"].setText(f"{s.get('count', len(r.holes))} dots")
-        self.st["open"].setText(f"open {100 * s.get('open_area_ratio', 0):.1f} %")
+        self.st["open"].setText(f"open {100 * s.get('open_area_ratio', 0):.1f} %"
+                                + (f"  ·  fan {100 * s['fan_open_ratio']:.0f} % open" if "fan_open_ratio" in s else "")
+                                + (f"  ·  {s['dropped_by_tool']} too small for the tool" if s.get("dropped_by_tool") else ""))
         v = s.get("min_wall_violations", 0)
-        self.st["viol"].setText(f"min-wall violations {v}")
+        tw = s.get("thinnest_wall")
+        self.st["viol"].setText(f"min-wall violations {v}" + (f"  ·  thinnest wall {tw:.2f} mm" if tw else "")
+                                + (f"  ·  {s['below_min_feature']} holes below min feature"
+                                   if s.get("below_min_feature") else "")
+                                + (f"  ·  airflow loss {s['pressure_drop_pa']:.0f} Pa @2 m/s"
+                                   if "pressure_drop_pa" in s else ""))
+        self.canvas.set_overlays(self.design.keepouts, s.get("thinnest_wall_at"), tw is not None and tw < self.design.min_wall)
         self.st["viol"].setStyleSheet("color:#ff7070" if v else "")
         self.st["time"].setText(f"{dt * 1000:.0f} ms")
         warn = f"   ⚠ {v} walls thinner than {self.design.min_wall:g} mm" if v else ""