gitcad-mech 0.7.7__tar.gz

gitcad_mech-0.7.7/.gitignore

@@ -0,0 +1,38 @@
+# Generated geometry is a build artifact, NOT source (ADR-0004). Never commit it.
+*.brep
+*.step
+*.stp
+*.stl
+*.gltf
+*.glb
+*.iges
+*.igs
+# Drawings are generated from the model too.
+/build-artifacts/
+*.dxf
+# PDFs generated from drawings (keep hand-authored docs elsewhere if needed).
+/out/
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+
+# Editors / OS
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db

gitcad_mech-0.7.7/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: gitcad-mech
+Version: 0.7.7
+Summary: gitcad mechanical: document model, exact B-rep kernel, sketches, drawings, mech importers
+Project-URL: Homepage, https://gitcad.xyz
+Project-URL: Repository, https://github.com/gitcad-xyz/gitcad
+Project-URL: Issues, https://github.com/gitcad-xyz/gitcad/issues
+Project-URL: Kernel (forgekernel), https://github.com/gitcad-xyz/forge
+Author-email: Dan Willis <danielcwillis@gmail.com>
+License-Expression: Apache-2.0
+Keywords: brep,cad,exact-arithmetic,kernel,nurbs,occt,sheet-metal,step
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: forgekernel-rs>=0.1.0; platform_machine in 'x86_64 AMD64 aarch64 arm64'
+Requires-Dist: forgekernel>=0.1.0
+Requires-Dist: gitcad-core==0.7.7
+Provides-Extra: occt
+Requires-Dist: cadquery-ocp>=7.7; extra == 'occt'
+Description-Content-Type: text/markdown
+
+# gitcad-mech
+
+Mechanical domain for [**gitcad**](https://gitcad.xyz) — the parametric document
+model and geometry kernels.
+
+- **Document model** — feature tree with stable identity; builds to a solid and a
+  reviewable report.
+- **Exact kernel by default** — ships [`forgekernel`](https://pypi.org/project/forgekernel/),
+  a from-scratch B-rep kernel whose topological decisions are made in exact
+  rational arithmetic (ℚ), never by floating-point epsilon. OCCT
+  (`cadquery-ocp`) is available as an independent oracle / fallback.
+- **Sketches, extrude/revolve, loft, sweep, fillet/chamfer, shell, patterns,
+  sheet metal, weldments, holes with thread specs.**
+- **Associative drawings** — HLR views, section/detail views, dimensions, GD&T,
+  weld & surface-finish symbols → SVG/PDF/DXF.
+- **Importers** — STEP, FCStd (parametric tree), with verified feature recovery.
+
+```bash
+pip install gitcad-mech          # exact kernel + native accelerator (default where a wheel exists)
+pip install gitcad-mech[occt]    # + OCCT oracle/fallback (cadquery-ocp)
+```
+
+Apache-2.0 · https://github.com/gitcad-xyz/gitcad

gitcad_mech-0.7.7/README.md

@@ -0,0 +1,23 @@
+# gitcad-mech
+
+Mechanical domain for [**gitcad**](https://gitcad.xyz) — the parametric document
+model and geometry kernels.
+
+- **Document model** — feature tree with stable identity; builds to a solid and a
+  reviewable report.
+- **Exact kernel by default** — ships [`forgekernel`](https://pypi.org/project/forgekernel/),
+  a from-scratch B-rep kernel whose topological decisions are made in exact
+  rational arithmetic (ℚ), never by floating-point epsilon. OCCT
+  (`cadquery-ocp`) is available as an independent oracle / fallback.
+- **Sketches, extrude/revolve, loft, sweep, fillet/chamfer, shell, patterns,
+  sheet metal, weldments, holes with thread specs.**
+- **Associative drawings** — HLR views, section/detail views, dimensions, GD&T,
+  weld & surface-finish symbols → SVG/PDF/DXF.
+- **Importers** — STEP, FCStd (parametric tree), with verified feature recovery.
+
+```bash
+pip install gitcad-mech          # exact kernel + native accelerator (default where a wheel exists)
+pip install gitcad-mech[occt]    # + OCCT oracle/fallback (cadquery-ocp)
+```
+
+Apache-2.0 · https://github.com/gitcad-xyz/gitcad

gitcad_mech-0.7.7/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gitcad-mech"
+version = "0.7.7"
+description = "gitcad mechanical: document model, exact B-rep kernel, sketches, drawings, mech importers"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+authors = [{name = "Dan Willis", email = "danielcwillis@gmail.com"}]
+keywords = ["cad", "brep", "kernel", "nurbs", "exact-arithmetic", "sheet-metal", "step", "occt"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Manufacturing",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Multimedia :: Graphics :: 3D Modeling",
+]
+# The exact forge kernel is the default backend. forgekernel (pure Python) is
+# the always-present floor; the native forgekernel_rs accelerator installs BY
+# DEFAULT on mainstream architectures (identical results, faster hot paths) and
+# is skipped only on exotic arches with no wheel — where forge auto-falls-back
+# to pure Python at runtime, so nothing breaks.
+dependencies = [
+    "gitcad-core==0.7.7",
+    "forgekernel>=0.1.0",
+    "forgekernel_rs>=0.1.0; platform_machine in 'x86_64 AMD64 aarch64 arm64'",
+]
+
+[project.optional-dependencies]
+# OCCT independent oracle / fallback kernel.
+occt = ["cadquery-ocp>=7.7"]
+
+[project.urls]
+Homepage = "https://gitcad.xyz"
+Repository = "https://github.com/gitcad-xyz/gitcad"
+Issues = "https://github.com/gitcad-xyz/gitcad/issues"
+"Kernel (forgekernel)" = "https://github.com/gitcad-xyz/forge"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gitcad"]

gitcad_mech-0.7.7/src/gitcad/analysis.py

@@ -0,0 +1,181 @@
+"""Mechanical analysis: exact inertia through the seam + DFM checks.
+
+`inertia` surfaces the exact rational inertia tensor forge computes for
+its solid classes (planar and freeform, via the divergence-theorem flux)
+and falls back to OCCT's float `MatrixOfInertia` for OCCT shapes.
+`draft_analysis` is a moldability check: faces whose draft angle to a
+pull direction is below a minimum can't release from the tool.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+
+def inertia(kernel, shape) -> dict[str, Any]:
+    """Volume, centroid, and inertia tensor (about the centroid) + the
+    three principal moments. Exact rationals when forge built the shape;
+    floats via OCCT otherwise. Returns floats for a uniform interface,
+    with ``exact=True`` when the underlying tensor is rational."""
+    exact = False
+    try:
+        from forgekernel.bsolid import (PatchSolid, mass_properties,
+                                        polyhedron_mass_properties)
+        from forgekernel.brep import Solid as _Solid
+
+        if isinstance(shape, _Solid):
+            mp = polyhedron_mass_properties(shape)
+            exact = True
+        elif isinstance(shape, PatchSolid):
+            mp = mass_properties(shape)
+            exact = True
+        else:
+            mp = None
+    except ImportError:
+        mp = None
+
+    if mp is not None:
+        V = float(mp["volume"])
+        c = tuple(float(x) for x in mp["centroid"])
+        I = [[float(mp["inertia"][i][j]) for j in range(3)] for i in range(3)]
+    else:
+        # any kernel's mass_props returns the tensor about the centroid;
+        # route through the seam (no direct OCP import — ADR-0002).
+        m = kernel.mass_props(shape)
+        V = float(m["volume"])
+        c = (m["cx"], m["cy"], m["cz"])
+        I = [[m["ixx"], m["ixy"], m["ixz"]],
+             [m["ixy"], m["iyy"], m["iyz"]],
+             [m["ixz"], m["iyz"], m["izz"]]]
+
+    principal = sorted(_sym_eigs_3x3(I))
+    return {"volume": V, "centroid": c, "inertia": I,
+            "principal_moments": principal, "exact": exact}
+
+
+def _sym_eigs_3x3(A):
+    """Eigenvalues of a symmetric 3×3 matrix (closed form; analysis only)."""
+    p1 = A[0][1] ** 2 + A[0][2] ** 2 + A[1][2] ** 2
+    q = (A[0][0] + A[1][1] + A[2][2]) / 3
+    p2 = ((A[0][0] - q) ** 2 + (A[1][1] - q) ** 2 + (A[2][2] - q) ** 2
+          + 2 * p1)
+    if p2 == 0:
+        return [A[0][0], A[1][1], A[2][2]]
+    p = math.sqrt(p2 / 6)
+    B = [[(A[i][j] - (q if i == j else 0)) / p for j in range(3)]
+         for i in range(3)]
+    detB = (B[0][0] * (B[1][1] * B[2][2] - B[1][2] * B[2][1])
+            - B[0][1] * (B[1][0] * B[2][2] - B[1][2] * B[2][0])
+            + B[0][2] * (B[1][0] * B[2][1] - B[1][1] * B[2][0]))
+    r = max(-1.0, min(1.0, detB / 2))
+    phi = math.acos(r) / 3
+    e1 = q + 2 * p * math.cos(phi)
+    e3 = q + 2 * p * math.cos(phi + 2 * math.pi / 3)
+    e2 = 3 * q - e1 - e3
+    return [e1, e2, e3]
+
+
+def draft_analysis(kernel, shape, pull=(0, 0, 1),
+                   min_angle_deg: float = 1.0) -> dict[str, Any]:
+    """Moldability: for a pull (ejection) direction, report planar faces
+    whose draft angle — 90° minus the angle between the face normal and
+    the pull — is below ``min_angle_deg``. Zero-draft walls (parallel to
+    the pull) fail hardest; floors/ceilings (perpendicular) pass."""
+    if math.sqrt(sum(float(c) ** 2 for c in pull)) < 1e-12:
+        raise ValueError("draft_analysis: pull direction must be non-zero")
+    d = _unit(pull)
+    faces = kernel.entities(shape, "face")
+    violations = []
+    for i, f in enumerate(faces):
+        n = f.get("plane")
+        if n is None:                       # curved face: skip (report as such)
+            continue
+        n = _unit(n)
+        dot = abs(sum(n[c] * d[c] for c in range(3)))
+        theta = math.degrees(math.acos(max(-1.0, min(1.0, dot))))
+        draft = 90.0 - theta
+        if draft < min_angle_deg:
+            violations.append({"face": i, "draft_deg": round(draft, 4),
+                               "normal": [round(x, 6) for x in n]})
+    return {"pull": list(d), "min_angle_deg": min_angle_deg,
+            "faces_checked": len(faces), "violations": violations,
+            "ok": not violations}
+
+
+def _unit(v):
+    m = math.sqrt(sum(float(c) ** 2 for c in v)) or 1.0
+    return tuple(float(c) / m for c in v)
+
+
+def thickness_analysis(kernel, shape, min_wall: float = 1.0) -> dict[str, Any]:
+    """Min-wall (moldability/printability) estimate for a planar forge
+    solid: the smallest separation between an anti-parallel pair of faces
+    whose projections overlap. Exact for prismatic parts (a box reports
+    min(dx,dy,dz)); a first-order estimate elsewhere (not a full medial
+    axis). Raises for non-forge shapes."""
+    try:
+        from forgekernel.brep import Solid as _Solid
+    except ImportError:                      # pragma: no cover
+        _Solid = ()
+    if not isinstance(shape, _Solid):
+        raise NotImplementedError(
+            "thickness_analysis: planar forge solids only")
+    # group polygons by (unit normal, plane offset)
+    faces = []
+    for poly in shape.polys:
+        n = _unit(poly.plane.n)
+        # a point on the plane → signed offset d = n·p
+        v0 = poly.verts[0]
+        d = sum(n[c] * float(v0[c]) for c in range(3))
+        pts = [tuple(float(x) for x in v) for v in poly.verts]
+        faces.append((n, d, pts))
+    thin = []
+    min_t = float("inf")
+    for i in range(len(faces)):
+        ni, di, pi = faces[i]
+        for j in range(i + 1, len(faces)):
+            nj, dj, pj = faces[j]
+            # anti-parallel?
+            if abs(ni[0] + nj[0]) > 1e-9 or abs(ni[1] + nj[1]) > 1e-9 \
+                    or abs(ni[2] + nj[2]) > 1e-9:
+                continue
+            # projected-bbox overlap onto the plane's two in-plane axes
+            if not _proj_overlap(ni, pi, pj):
+                continue
+            # nj = −ni. In the nᵢ coordinate face i sits at di and face j at
+            # −dj; SOLID lies between them only when di + dj > 0 (that IS the
+            # wall thickness). di + dj < 0 is an EMPTY slot/pocket — not a
+            # wall — so the sign must NOT be discarded with abs() (that
+            # flagged open slots as thin material, a false DFM failure).
+            t = di + dj
+            if t <= 1e-12:
+                continue
+            if t < min_t:
+                min_t = t
+            if t < min_wall:
+                thin.append({"faces": [i, j], "thickness": round(t, 6)})
+    return {"min_wall_target": min_wall,
+            "min_thickness": None if min_t == float("inf") else round(min_t, 6),
+            "thin_regions": thin, "ok": min_t >= min_wall}
+
+
+def _proj_overlap(n, pa, pb) -> bool:
+    """Do two planar point-sets overlap when projected onto the plane ⟂ n?"""
+    # two in-plane basis vectors
+    ref = (1.0, 0.0, 0.0) if abs(n[0]) < 0.9 else (0.0, 1.0, 0.0)
+    dot = sum(ref[c] * n[c] for c in range(3))
+    u = tuple(ref[c] - dot * n[c] for c in range(3))
+    um = math.sqrt(sum(c * c for c in u)) or 1.0
+    u = tuple(c / um for c in u)
+    w = (n[1] * u[2] - n[2] * u[1], n[2] * u[0] - n[0] * u[2],
+         n[0] * u[1] - n[1] * u[0])
+
+    def box(pts):
+        us = [sum(p[c] * u[c] for c in range(3)) for p in pts]
+        ws = [sum(p[c] * w[c] for c in range(3)) for p in pts]
+        return min(us), max(us), min(ws), max(ws)
+
+    au0, au1, aw0, aw1 = box(pa)
+    bu0, bu1, bw0, bw1 = box(pb)
+    return au0 <= bu1 and bu0 <= au1 and aw0 <= bw1 and bw0 <= aw1

gitcad_mech-0.7.7/src/gitcad/derive.py

@@ -0,0 +1,60 @@
+"""Deriving part interfaces from real domain data (ADR-0008 domain wiring).
+
+The board side lives on :meth:`gitcad.ecad.board.Board.to_part`. This module
+covers the mechanical side: build a Document against a kernel and derive the
+envelope from actual geometry. Ports/frames remain *declared* for mech in v1 —
+a solid doesn't announce which faces are mounting bosses; that semantic tag is
+design intent (a follow-up will attach ports to stable entity ids so they
+re-derive positions from geometry too).
+"""
+
+from __future__ import annotations
+
+from gitcad.document import Document
+from gitcad.part.interface import Frame, Interface, Port
+from gitcad.part.manifest import PartManifest
+from gitcad.seams import Kernel
+
+
+def model_to_part(
+    doc: Document,
+    kernel: Kernel,
+    *,
+    part_id: str,
+    name: str,
+    version: str = "0.1.0",
+    frames: dict[str, Frame] | None = None,
+    ports: dict[str, Port] | None = None,
+    properties: dict | None = None,
+) -> PartManifest:
+    """Build ``doc`` and derive its ``part.json``: envelope from the built
+    geometry's bounding box; declared frames/ports carried through."""
+    if not len(doc):
+        raise ValueError("document has no features")
+    final = doc.build(kernel).final(doc)
+    (minx, miny, minz), (maxx, maxy, maxz) = kernel.bbox(final)
+    # Round to fixed precision: a derived envelope feeds interface-semver
+    # (ADR-0009), so float noise between rebuilds must never register as an
+    # interface change. 1e-6 mm is far below manufacturing relevance.
+    minx, miny, minz, maxx, maxy, maxz = (round(v, 6) for v in
+                                          (minx, miny, minz, maxx, maxy, maxz))
+
+    iface_frames = {"origin": Frame()}
+    iface_frames.update(frames or {})
+    props = {"kernel": kernel.name}
+    props.update(properties or {})
+    measures = kernel.measure(final)
+    if "volume" in measures:
+        props["volume_mm3"] = round(measures["volume"], 3)
+
+    return PartManifest(
+        id=part_id, name=name, domain="mech", version=version,
+        interface=Interface(
+            envelope={"origin": [minx, miny, minz],
+                      "dx": maxx - minx, "dy": maxy - miny, "dz": maxz - minz},
+            frames=iface_frames,
+            ports=dict(ports or {}),
+            properties=props,
+        ),
+        body={"model": f"{name}.model"},
+    )