loadpath 0.1.1__py3-none-any.whl

loadpath/printcheck.py

@@ -0,0 +1,263 @@
+"""
+Can it be printed as it stands, in this orientation, without supports?
+
+verify._overhang counts down-facing surface by its normal. That is the right
+first number, but it calls every flat ceiling a defect, and FDM prints many
+of them fine: a ceiling whose every point is held at both ends by walls
+already printed is a bridge, and a slicer strings filament across it. It
+also says nothing about the first layer, which is where most failed prints
+fail. This module slices the part along the build direction and reads each
+layer the way a slicer would:
+
+  support   - cells of a layer with nothing under them within 45 degrees
+              (Langelaar's stencil, the same one am.AMFilter designs to),
+              grouped into regions per layer. A region is a bridge when a
+              straight span through every one of its cells, in one common
+              direction, lands on supported material at both ends and is no
+              longer than `bridge_span`; otherwise it needs support. Short
+              ledges (`ledge` mm, a few extrusion widths) print as overhang.
+  islands   - regions with no printed material beside them at all: a new
+              start in mid-air, which no slicer can print unsupported.
+  bed       - the first layer: contact area, how many separate pieces touch
+              the bed and the smallest, whether the centre of mass sits over
+              the contact's hull (and by how much), and how tall the part
+              stands over its narrowest base width. A part that tips, or a
+              2 mm^2 foot, fails before anything else matters.
+  support volume - what a slicer would add, column by column from every
+              unbridged cell down to the part or the bed: a cost to compare
+              orientations by, not a slicer's exact number.
+
+The part is voxelized at `pitch` (the layer here is a cell, not the printer's
+layer height: 45-degree geometry is scale-free, bridges and ledges are
+measured in mm). Results carry the pitch they are good to.
+"""
+from __future__ import annotations
+
+import numpy as np
+from scipy import ndimage
+
+__all__ = ["check_print", "rotation_to_z", "BRIDGE_SPAN"]
+
+# Unsupported spans a slicer bridges reliably, mm: PLA/PETG with part
+# cooling manage 10-20 mm cleanly and sag past ~25-50. Conservative default.
+# Powder-bed metal barely bridges: a flat span past ~2 mm warps or drosses.
+# Resin holds short spans between supports; past ~5 mm the slicer adds more.
+BRIDGE_SPAN = {"fdm": 15.0, "lpbf": 2.0, "sla": 5.0, "dlp": 5.0}
+# A ledge this deep prints as an overhang off the wall below it.
+_LEDGE = 1.0
+# Bed pieces smaller than this lift: a foot under ~3x3 mm rarely holds.
+_MIN_FOOT = 9.0
+_CROSS = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]], bool)
+_EIGHT = np.ones((3, 3), bool)
+
+
+def rotation_to_z(direction) -> np.ndarray:
+    """Rotation matrix taking the build direction to +z (proper, det +1)."""
+    from .am import build_vector
+
+    u = build_vector(direction)
+    z = np.array([0.0, 0.0, 1.0])
+    c = float(u @ z)
+    if c > 1 - 1e-12:
+        return np.eye(3)
+    if c < -1 + 1e-12:
+        return np.diag([1.0, -1.0, -1.0])
+    v = np.cross(u, z)
+    s = np.linalg.norm(v)
+    k = np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]]) / s
+    ang = np.arctan2(s, c)
+    return np.eye(3) + np.sin(ang) * k + (1 - np.cos(ang)) * (k @ k)
+
+
+def _spans(region, anchor, pitch, max_steps):
+    """For each direction (0..165 deg), the chord through every cell of a
+    layer region and whether both ends land on anchor cells. Returns the
+    best direction's (fraction of cells spanned, longest chord in mm)."""
+    cells = np.argwhere(region)
+    shape = np.array(region.shape)
+    best = (0.0, np.inf)
+    for th in np.radians(np.arange(0, 180, 15)):
+        d = np.array([np.cos(th), np.sin(th)])
+        ok = np.ones(len(cells), bool)
+        length = np.zeros(len(cells))
+        for sgn in (1.0, -1.0):
+            done = np.zeros(len(cells), bool)
+            hit = np.zeros(len(cells), bool)
+            for step in range(1, max_steps + 1):
+                q = np.rint(cells + sgn * step * d).astype(int)
+                inside = np.all((q >= 0) & (q < shape), axis=1)
+                qc = np.clip(q, 0, shape - 1)
+                in_reg = inside & region[qc[:, 0], qc[:, 1]]
+                on_anchor = inside & anchor[qc[:, 0], qc[:, 1]]
+                newly = ~done & ~in_reg
+                hit |= newly & on_anchor
+                length += np.where(~done & in_reg, 1.0, 0.0)
+                done |= newly
+                if done.all():
+                    break
+            ok &= done & hit
+        frac = float(ok.mean())
+        span = float((length[ok].max() + 1.0) * pitch) if ok.any() else np.inf
+        if frac > best[0] + 1e-9 or (abs(frac - best[0]) < 1e-9 and span < best[1]):
+            best = (frac, span)
+    return best
+
+
+def _hull_margin(pts2, com2):
+    """Signed distance from the centre of mass to the contact's convex hull
+    edge (positive inside)."""
+    from scipy.spatial import ConvexHull, QhullError
+
+    if len(pts2) < 3:
+        return -float(np.min(np.linalg.norm(pts2 - com2, axis=1))) if len(pts2) else -np.inf
+    try:
+        hull = ConvexHull(pts2)
+    except QhullError:
+        return 0.0
+    # hull.equations: n.x + d <= 0 inside
+    return float(-(hull.equations[:, :2] @ com2 + hull.equations[:, 2]).max())
+
+
+def check_print(mesh, direction, process: str = "fdm", pitch: float | None = None,
+                bridge_span: float | None = None, ledge: float = _LEDGE, material=None,
+                max_cells: int = 1_500_000) -> dict:
+    """Slice `mesh` (trimesh, mm) along the build `direction` ((axis, sign)
+    or a vector, the way layers stack) and report support, bridges, islands
+    and bed contact. Nothing here passes or fails a part: the numbers are
+    costs and risks an orientation choice weighs (orient.py)."""
+    import trimesh
+
+    from .verify import voxelize
+
+    rot = rotation_to_z(direction)
+    m = mesh.copy()
+    m.apply_transform(np.block([[rot, np.zeros((3, 1))], [np.zeros((1, 3)), np.ones((1, 1))]]))
+    m.apply_translation([0.0, 0.0, -m.bounds[0, 2]])
+    ext = m.extents
+    vol = float(abs(m.volume))
+    if pitch is None:
+        pitch = max(0.4, float((np.prod(ext) / max_cells) ** (1.0 / 3.0)))
+    span_mm = float(bridge_span if bridge_span is not None else BRIDGE_SPAN.get(process, 15.0))
+    # whole cells from the bed up, so no cell centre sits on the bottom face
+    lo = m.bounds[0]
+    n_cells = np.maximum(np.ceil((m.extents - 1e-6) / pitch), 1)
+    solid, origin = voxelize(m, pitch, box=(lo, lo + n_cells * pitch))
+    # first layer at the bed: drop empty layers the grid padding left below
+    zs = np.nonzero(solid.any(axis=(0, 1)))[0]
+    solid = solid[:, :, zs[0]:zs[-1] + 1]
+    nx, ny, nz = solid.shape
+    a_cell = pitch * pitch
+    out = {"pitch": pitch, "height": float(ext[2]), "volume": vol,
+           "buildDirection": [float(c) for c in rot.T @ np.array([0.0, 0.0, 1.0])]}
+
+    max_steps = int(np.ceil(span_mm / pitch)) + 2
+    ledge_cells = ledge / pitch
+    need = np.zeros_like(solid)          # unbridged, unsupported cells
+    bridges, n_islands, island_area = [], 0, 0.0
+    bridged_area = 0.0
+    for k in range(1, nz):
+        below = ndimage.binary_dilation(solid[:, :, k - 1], _CROSS)
+        free = solid[:, :, k] & ~below
+        if not free.any():
+            continue
+        anchor = solid[:, :, k] & ~free
+        lbl, n = ndimage.label(free, _EIGHT)
+        for r in range(1, n + 1):
+            reg = lbl == r
+            ring = ndimage.binary_dilation(reg, _EIGHT) & ~reg
+            if not (ring & anchor).any():
+                n_islands += 1
+                island_area += reg.sum() * a_cell
+                need[:, :, k] |= reg
+                continue
+            # depth of the region from its nearest anchor: a narrow ledge
+            # off a wall prints as overhang, no bridge needed
+            depth = ndimage.distance_transform_edt(~anchor)[reg]
+            if depth.max() <= ledge_cells + 1.0:
+                continue
+            frac, span = _spans(reg, anchor, pitch, max_steps)
+            if frac >= 0.97 and span <= span_mm:
+                bridges.append({"z": float((k + 0.5) * pitch), "span": span, "area": float(reg.sum() * a_cell)})
+                bridged_area += reg.sum() * a_cell
+            else:
+                need[:, :, k] |= reg
+    # support columns: from each unbridged cell straight down to the part or the bed
+    sup_cells = 0
+    run = np.zeros((nx, ny), bool)
+    for k in range(nz - 1, 0, -1):
+        run = (run | need[:, :, k]) & ~solid[:, :, k - 1]
+        sup_cells += int(run.sum())
+    out["supportArea"] = float(need.sum() * a_cell)
+    out["supportVolume"] = float(sup_cells * a_cell * pitch)
+    out["islands"] = n_islands
+    out["islandArea"] = float(island_area)
+    out["bridges"] = len(bridges)
+    out["bridgedArea"] = float(bridged_area)
+    out["maxBridgeSpan"] = max((b["span"] for b in bridges), default=0.0)
+    out["bridgeList"] = sorted(bridges, key=lambda b: -b["span"])[:8]
+    out["supportFree"] = bool(out["supportArea"] == 0.0)
+    # support inside a sealed cavity can never come out: the cells that
+    # need support over a void that does not reach the outside (the grid's
+    # faces, or the open top above the part)
+    void = ~solid
+    lbl_v, _ = ndimage.label(void)
+    border = np.unique(np.concatenate([lbl_v[0].ravel(), lbl_v[-1].ravel(), lbl_v[:, 0].ravel(),
+                                       lbl_v[:, -1].ravel(), lbl_v[:, :, 0].ravel(), lbl_v[:, :, -1].ravel()]))
+    sealed = void & ~np.isin(lbl_v, border)
+    under = np.zeros_like(need)
+    under[:, :, 1:] = sealed[:, :, :-1]
+    trapped = need & under
+    out["trappedSupportArea"] = float(trapped.sum() * a_cell)
+    out["sealedVoidVolume"] = float(sealed.sum() * a_cell * pitch)
+
+    first = solid[:, :, 0]
+    lbl, n = ndimage.label(first, _EIGHT)
+    feet = np.bincount(lbl.ravel())[1:] * a_cell if n else np.zeros(0)
+    xy = (np.argwhere(first) + 0.5) * pitch + origin[:2]
+    try:
+        com = m.center_mass if m.is_volume else m.centroid
+    except Exception:  # noqa: BLE001 - a bad mass property is not worth failing a check
+        com = m.centroid
+    margin = _hull_margin(xy, np.asarray(com[:2])) if len(xy) else -np.inf
+    if len(xy) >= 3:
+        # narrowest width of the contact (minimum over directions of its extent)
+        th = np.radians(np.arange(0, 180, 5))
+        widths = [np.ptp(xy @ np.array([np.cos(t), np.sin(t)])) + pitch for t in th]
+        base_w = float(min(widths))
+    else:
+        base_w = pitch
+    out["bed"] = {
+        "contactArea": float(first.sum() * a_cell),
+        "contactFraction": float(first.sum() * a_cell / max(vol ** (2 / 3), 1e-9)),
+        "feet": int(n),
+        "smallestFoot": float(feet.min()) if n else 0.0,
+        "comMargin": margin,
+        "baseWidth": base_w,
+        "aspect": float(ext[2] / base_w) if base_w > 0 else np.inf,
+        "footprint": [float(ext[0]), float(ext[1])],
+    }
+    warnings = []
+    bed = out["bed"]
+    if bed["comMargin"] < 0:
+        warnings.append(f"the centre of mass is {-bed['comMargin']:.1f} mm outside the bed contact: it tips over "
+                        "unless supports or a brim hold it")
+    if n and bed["smallestFoot"] < _MIN_FOOT:
+        warnings.append(f"a {bed['smallestFoot']:.1f} mm^2 foot on the bed will likely lift: add a brim or "
+                        "pick a face with more contact")
+    if bed["aspect"] > 4.0:
+        warnings.append(f"stands {bed['aspect']:.1f}x taller than its narrowest base: it will wobble late in the "
+                        "print; a brim or a lower orientation helps")
+    if out["supportArea"] > 0 and not n_islands and process not in ("sls", "mjf", "binder", "lpbf"):
+        # (powder holds a polymer part up; LPBF counts supports by its own rules)
+        warnings.append(f"needs build supports under {out['supportArea']:.0f} mm^2 of downward faces "
+                        f"({out['supportVolume']:.0f} mm^3 of support; spans over {span_mm:g} mm count as "
+                        "unbridgeable, set process.bridgeSpan for your printer): reorient, chamfer the "
+                        "overhangs, or accept the supports")
+    if n_islands:
+        warnings.append(f"{n_islands} region(s) start in mid-air ({island_area:.0f} mm^2): they need support")
+    mat = getattr(material, "name", material)
+    if mat in ("abs", "asa", "pa-cf", "pa12") and max(ext[0], ext[1]) > 120 and process == "fdm":
+        warnings.append(f"{max(ext[0], ext[1]):.0f} mm across the bed in {mat}: warp risk; use an enclosure "
+                        "and a brim")
+    out["warnings"] = warnings
+    return out

loadpath/printsetup.py

@@ -0,0 +1,207 @@
+"""
+Pick the print setup for a finished FDM part: build orientation, material,
+bed temperature and brim, each candidate checked for strength (verify_part
+with that material and layer direction) and for warp (buildsim, on the bed
+at the end of the print, along the build). The search is on the delivered
+shape: it does not re-optimize the part for each setup, so a material or
+orientation that wins here may do better still once the part is
+re-optimized for it (search_print_setup reports what to set; run the study
+again with it).
+
+Why: on a bed-printed part the warp is set by the material, the height on
+the bed and how the bed holds it far more than by the topology (on the
+120 mm PA12 beam of bench/buildsim_fdm_warp_limit.py every design lifted
+2.5-3.7 mm), so these are the levers a warp limit needs.
+
+Stage 1 runs every (material, orientation) at the material's usual bed
+temperature without a brim; stage 2 sweeps bed temperature and brim on the
+best few that meet the safety factor. Ranking: meets the goal and the warp
+limit first, then lightest, then least warp, then no brim.
+"""
+from __future__ import annotations
+
+import dataclasses
+import time
+
+import numpy as np
+
+AXES = ("+z", "-z", "+x", "-x", "+y", "-y")
+BED_MAX = 110.0       # most hobby beds top out near here
+BED_STEP = 10.0
+TALL = 4.0            # height over narrowest base past which a print needs a brim to stand
+TALL_MAX = 10.0       # and past which not even a brim keeps it steady
+ROOM = 0.8            # a lift above this share of the limit counts as tight
+
+
+def _bed_candidates(material, setup, max_bed):
+    from .buildsim import BuildSetup, _fdm_params
+    p = _fdm_params(dataclasses.replace(setup, material=material))
+    base = p["bed"]
+    # above Tg an amorphous first layer sags (elephant's foot), so stop
+    # short of it; semi-crystalline (Tc far above) stop at the bed's limit
+    top = min(max_bed, p["tg"] - 5.0)
+    out = sorted({float(b) for b in (base - 2 * BED_STEP, base - BED_STEP, base, base + BED_STEP) if 40.0 <= b <= top})
+    return out or [min(base, top)]
+
+
+def _warp(mesh, setup, build, cells):
+    from .buildsim import simulate_part
+    r = simulate_part(mesh, dataclasses.replace(setup, release="none"), build=build, cells=cells)
+    m = r.mesh
+    on = np.zeros(m.n_nodes, bool)
+    on[m.enode[r.part].ravel()] = True
+    lift = float(np.abs(r.u_built[on, 2]).max())
+    return {"lift": lift, "peel": (r.report.get("peel") or {}).get("meanPeelStress"),
+            "bedFailed": bool(r.report.get("peel", {}).get("bedFailed", False))}
+
+
+def _strength(study, mesh, material, build, max_cells):
+    from .am import parse_build_direction
+    from .materials import material_from_spec
+    from .verify import verify_part
+    from .study import _margin
+    mat = material_from_spec(material)
+    b = parse_build_direction(build)
+    proc = dataclasses.replace(study.process, build=b) if study.process is not None else None
+    st = dataclasses.replace(study, material=mat, materials=[mat], process=proc,
+                             print_direction=b if study.print_direction is not None else None)
+    rep = verify_part(st, mesh, max_cells=max_cells)
+    # the goal's margin without the warp limits (those are checked here)
+    goal = _margin(st, {k: v for k, v in rep.items() if k != "warp"})
+    return {"mass": rep.get("mass"), "safetyFactor": rep.get("safetyFactor"), "margin": goal,
+            "supportVolume": (rep.get("print") or {}).get("supportVolume"),
+            "aspect": ((rep.get("print") or {}).get("bed") or {}).get("aspect"),
+            "comMargin": ((rep.get("print") or {}).get("bed") or {}).get("comMargin")}
+
+
+def search_print_setup(study, mesh, materials=None, builds=None, beds=None, brims=(0.0, 5.0), max_bed=BED_MAX,
+                       limit=None, cells=4000, verify_cells=30_000, top=2, progress=None, reoptimize=True) -> dict:
+    """Rank FDM print setups for the delivered part `mesh` (trimesh, study
+    frame). materials: names (default the study's); builds: build
+    directions (default the six grid axes); beds: bed temperatures (default
+    a few around each material's usual one, below its Tg); brims: brim
+    widths, mm; limit: maxDistortion, mm (default buildSim.maxDistortion).
+    Returns {"best": row, "rows": [...], "seconds", "notes"}; each row has
+    material, build, bed, brim, lift (mm), mass, safetyFactor, margin, and
+    passes (goal and warp limit)."""
+    t0 = time.time()
+    bs = study.build_sim or {}
+    from .buildsim import BuildSetup
+    setup = bs.get("setup") or BuildSetup(process="fdm", material=study.material.name)
+    del reoptimize  # used by the study runner (study._print_setup_rescue)
+    if setup.process.lower() != "fdm":
+        raise ValueError("search_print_setup is for FDM parts (buildSim with process fdm)")
+    if limit is None:
+        limit = bs.get("maxDistortion")
+    mats = list(materials or [m.name for m in (study.materials or [study.material])])
+    builds = list(builds or AXES)
+
+    def note(**kw):
+        if progress is not None:
+            progress(kw)
+
+    strength = {}
+    for mat in mats:
+        for b in builds:
+            note(stage="strength", material=mat, build=b)
+            try:
+                strength[(mat, b)] = _strength(study, mesh, mat, b, verify_cells)
+            except (RuntimeError, ValueError) as exc:
+                strength[(mat, b)] = {"error": str(exc), "margin": 0.0}
+
+    rows = []
+
+    def run(mat, b, bed, brim):
+        st = dataclasses.replace(setup, material=mat, bed=bed, brim=brim)
+        note(stage="warp", material=mat, build=b, bed=bed, brim=brim)
+        w = _warp(mesh, st, b, cells)
+        s = strength[(mat, b)]
+        ok_goal = s.get("margin") is None or s["margin"] >= 1.0
+        ok_warp = limit is None or w["lift"] <= limit
+        # a part standing over 4x taller than its narrowest base wobbles
+        # late in the print (printcheck), and one whose centre of mass is
+        # off its contact tips: both need a brim to stand
+        asp = s.get("aspect") or 0.0
+        tall = asp > TALL or (s.get("comMargin") or 0.0) < 0
+        ok_stand = asp <= TALL_MAX and (not tall or brim > 0)
+        row = {"material": mat, "build": b, "bed": bed, "brim": brim, **w,
+               **{k: s.get(k) for k in ("mass", "safetyFactor", "margin", "supportVolume", "aspect")},
+               "meetsGoal": bool(ok_goal), "meetsWarp": bool(ok_warp), "stands": bool(ok_stand),
+               "passes": bool(ok_goal and ok_warp and ok_stand)}
+        rows.append(row)
+        return row
+
+    from .buildsim import _fdm_params
+    first = []
+    for mat in mats:
+        base = _fdm_params(dataclasses.replace(setup, material=mat))["bed"]
+        for b in builds:
+            first.append(run(mat, b, base, 0.0))
+    # stage 2: bed and brim on the best few that hold the load
+    # (per material, so a lighter material is not crowded out by a flatter one)
+    can = [r for r in first if (r.get("aspect") or 0.0) <= TALL_MAX]
+    strong = []
+    for mat in mats:
+        mine = [r for r in can if r["material"] == mat]
+        mine = [r for r in mine if r["meetsGoal"]] or mine
+        strong += sorted(mine, key=lambda r: (r["lift"], r["mass"] or 0))[:top]
+    for r in strong:
+        for bed in (beds or _bed_candidates(r["material"], setup, max_bed)):
+            for brim in brims:
+                if bed == r["bed"] and brim == r["brim"]:
+                    continue
+                run(r["material"], r["build"], float(bed), float(brim))
+
+    def rank(r):
+        # among equals: room under the warp limit first (the FDM warp model
+        # is good to tens of percent), then less support, no brim, less lift
+        tight = limit is not None and r["lift"] > ROOM * limit
+        return (not r["passes"], not r["meetsGoal"], round(r["mass"] or 0.0, 2) if r["passes"] else 0.0,
+                tight, round(r["supportVolume"] or 0.0, -1), r["brim"], r["lift"], abs(r["bed"]))
+
+    rows.sort(key=rank)
+    best = rows[0] if rows else None
+    cur = next((r for r in rows if r["material"] == study.material.name and r["brim"] == 0.0
+                and r["build"] == _build_name(study)), None)
+    return {"best": best, "current": cur, "rerun": rerun_candidate(rows, limit), "rows": rows, "limit": limit, "seconds": round(time.time() - t0, 1),
+            "notes": ["the delivered shape is re-checked, not re-optimized, for each setup: re-run the study with "
+                      "the best setup to let the shape follow it",
+                      "brim is an estimate (more bed hold under the footprint's edge), not validated; bed "
+                      "temperature and material are in the validated FDM model"]}
+
+
+def _build_name(study):
+    b = study.process.build if study.process is not None else None
+    if isinstance(b, tuple) and len(b) == 2 and isinstance(b[0], (int, np.integer)):
+        return ("+" if b[1] > 0 else "-") + "xyz"[b[0]]
+    return "+z"
+
+
+def rerun_candidate(rows, limit, room=ROOM):
+    """The setup to re-optimize the part for when none passes as it is:
+    among the setups whose lift leaves room under the limit (room x limit,
+    else any under it), the most safety factor per gram (a re-optimized
+    part trades the two), then no brim, then the least lift."""
+    if limit is None:
+        return None
+    ok = [r for r in rows if r["lift"] <= room * limit] or [r for r in rows if r["lift"] <= limit]
+    ok = [r for r in ok if r.get("margin") is not None and r.get("mass") and r.get("stands", True)]
+    if not ok:
+        return None
+    return min(ok, key=lambda r: (-round(r["margin"] / r["mass"], 4), r["brim"], r["lift"]))
+
+
+def study_for(study, row):
+    """The study set up to print as `row` says: material, build direction
+    and the build sim's bed temperature and brim (printSetup off, so a
+    re-run does not search again)."""
+    from .am import parse_build_direction
+    from .materials import material_from_spec
+    mat = material_from_spec(row["material"])
+    b = parse_build_direction(row["build"])
+    proc = dataclasses.replace(study.process, build=b)
+    bs = dict(study.build_sim)
+    bs["setup"] = dataclasses.replace(bs["setup"], material=mat.name, bed=row["bed"], brim=row["brim"])
+    bs["printSetup"] = None
+    pd = b if study.print_direction is not None else None
+    return dataclasses.replace(study, material=mat, materials=[mat], process=proc, build_sim=bs, print_direction=pd)