Datasets:

ppak10
/

Agentic-SLS-ASTM

	#!/usr/bin/env python3
	"""Build-plate modulus maps for the stacked Type IV prints (Batches Q-U).

	One figure per batch, two panels: the D638 Type IV specimens as they sat on
	the build plate, lower stack (samples 1-7, first ~70 layers) beside upper
	stack (samples 8-14, printed directly above in the same XY slots). Each
	specimen outline is a real cross-section of its numbered STL taken just
	below the top face, so the engraved "A n"/"B n" grip identifiers render as
	unfilled engravings — the same marks used to identify the physical parts.
	Fill color encodes the tensile chord modulus (0.05-0.25% strain, ISO
	527-style), computed from each specimen's stress-strain curve at plot time:
	the Q-U exports are curve-only, so the dataset deliberately carries no
	TestWorks modulus scalar for them (see CLAUDE.md), and the chord method
	reproduces TestWorks moduli within ~5% on batches that have both.

	The color scale is normalized PER MATERIAL FAMILY (PA11 Onyx: Q+R; PA12
	White/GF blend: S+T+U) so batches of the same powder compare directly
	without a cross-material scale washing out either family's contrast — the
	colorbar range on each figure states its family's span. Specimens with no
	curve draw with the layout intact: broken-after-print specimens (Batch Q's
	specimen 7) as gray hatched outlines; never-printed specimens (Batch S's
	upper stack — its build was soft-canceled as that level began) as faint
	dashed outlines. Axes bounds are exactly the 161x161 mm plate, so
	part-to-edge padding reads true.

	Geometry inputs live in source/objects/: the 14 numbered STLs and
	d638_type4_stacked_layout.json (per-part firmware MeshPrintTransform
	matrices + provenance for every print of this template job — all share the
	same XY placement; see the JSON's description for the Z-scale nuance).
	Transform convention is row-major V*M applied to the mesh recentered on its
	bounds center (firmware convention).

	Outputs: assets/batches/D638_{Q,R,S,T,U}_layout.png/.pdf
	"""
	import json

	import numpy as np
	import trimesh
	import matplotlib.pyplot as plt
	import matplotlib.colors as mcolors
	from matplotlib.cm import ScalarMappable
	from matplotlib.patches import PathPatch
	from matplotlib.path import Path as MplPath

	from _lib import DATA_DIR, OUT_DIR, ROOT, load_specimen, save_figure

	OBJECTS_DIR = ROOT / "source" / "objects"
	LAYOUT = json.loads((OBJECTS_DIR / "d638_type4_stacked_layout.json").read_text())
	# material families share a color normalization; batch order inside a family
	# only affects figure generation order
	FAMILIES = [
	("PA11 Onyx", ["Q", "R"]),
	("PA12 White/GF blend", ["S", "T", "U"]),
	]
	# samples that were never printed (build canceled before their stack) — drawn
	# as faint dashed outlines, distinct from broken-after-print (gray hatch)
	UNPRINTED = {"S": set(range(8, 15))}
	# Slice this far below each part's top face — deep enough to cut through the
	# engraved identifiers (so they render as holes), shallower than the engrave
	# depth everywhere else.
	SLICE_BELOW_TOP_MM = 0.3
	POWDER_BG = "#EFE7DD"
	BROKEN_FC, BROKEN_HATCH = "#C9C2B8", "///"
	UNPRINTED_EDGE = "#B9B1A4"

	# Sequential fill ramp: the batch color ramp's gold->deep-brown sweep (see
	# _lib.ORDERED_BATCHES notes), reused here as a continuous modulus scale so
	# the layout maps stay in the house palette.
	MODULUS_RAMP = mcolors.LinearSegmentedColormap.from_list(
	"modulus_ramp", ["#F7C948", "#F9931E", "#F97415", "#C7430C", "#6E2206"])


	def chord_modulus_mpa(spec: dict) -> float \| None:
	"""Tensile chord modulus between 0.05% and 0.25% strain (ISO 527 window),
	linearly interpolated on the analyzed stress-strain curve."""
	pairs = sorted(zip(spec["strain"], spec["stress_mpa"]))
	strain = [p[0] for p in pairs]
	stress = [p[1] for p in pairs]

	def at(x: float) -> float \| None:
	for i in range(1, len(strain)):
	if strain[i] >= x:
	s0, s1, t0, t1 = strain[i - 1], strain[i], stress[i - 1], stress[i]
	return t0 + (t1 - t0) * (x - s0) / (s1 - s0)
	return None

	lo, hi = at(0.0005), at(0.0025)
	if lo is None or hi is None:
	return None
	return (hi - lo) / 0.002


	def top_slice_polys(stl_path) -> list[tuple[np.ndarray, list[np.ndarray]]]:
	"""Cross-section polygons (exterior, holes) just below the mesh top face,
	in mesh coordinates recentered on the bounds center — the frame the
	firmware transform expects."""
	mesh = trimesh.load(stl_path)
	z_top = mesh.bounds[1][2]
	section = mesh.section(plane_origin=[0, 0, z_top - SLICE_BELOW_TOP_MM],
	plane_normal=[0, 0, 1])
	planar, to_3d = section.to_2D()
	center = (mesh.bounds[0] + mesh.bounds[1]) / 2.0

	def back(coords) -> np.ndarray:
	pts = np.array([[x, y, 0.0, 1.0] for x, y in coords]) @ to_3d.T
	return pts[:, :2] - center[:2]

	return [(back(p.exterior.coords), [back(h.coords) for h in p.interiors])
	for p in planar.polygons_full]


	def to_plate(pts2d: np.ndarray, transform: list) -> np.ndarray:
	"""Recentered mesh XY -> plate XY via the row-major V*M firmware matrix."""
	pts = np.hstack([pts2d, np.zeros((len(pts2d), 1)), np.ones((len(pts2d), 1))])
	return (pts @ np.array(transform))[:, :2]


	def specimen_patch(sample: int, transform: list, facecolor, hatch,
	edgecolor="black", linestyle="solid") -> PathPatch:
	verts: list[tuple[float, float]] = []
	codes: list[int] = []
	stl = OBJECTS_DIR / "d638_type_4_numbered" / f"d638_type4_{sample}.STL"
	for exterior, holes in top_slice_polys(stl):
	for ring in [exterior, *holes]:
	ring_pts = [tuple(p) for p in to_plate(ring, transform)]
	verts += ring_pts
	codes += [MplPath.MOVETO] + [MplPath.LINETO] * (len(ring_pts) - 2) + [MplPath.CLOSEPOLY]
	return PathPatch(MplPath(verts, codes), facecolor=facecolor, hatch=hatch,
	edgecolor=edgecolor, linewidth=0.6, linestyle=linestyle, zorder=2)


	def main() -> None:
	transforms = {p["sample"]: p["transform"] for p in LAYOUT["parts"]}
	plate_x, plate_y = LAYOUT["plate_mm"]["x"], LAYOUT["plate_mm"]["y"]

	for family, batches in FAMILIES:
	run_family(family, batches, transforms, plate_x, plate_y)


	def run_family(family: str, batches: list[str], transforms: dict,
	plate_x: float, plate_y: float) -> None:
	moduli: dict[tuple[str, int], float] = {}
	for batch in batches:
	for path in sorted((DATA_DIR / "D638").glob(f"{batch}*.jsonl")):
	spec = load_specimen(path)
	if spec is None:
	continue
	sample = int(path.stem.removeprefix(batch))
	mod = chord_modulus_mpa(spec)
	if mod is not None:
	moduli[(batch, sample)] = mod
	# One normalization across the family, so its batch figures share a color
	# scale and compare directly.
	norm = mcolors.Normalize(vmin=min(moduli.values()), vmax=max(moduli.values()))

	for batch in batches:
	fig, axes = plt.subplots(1, 2, figsize=(11.5, 5.6), layout="constrained")
	for ax, (lo, hi, label) in zip(axes, [(1, 7, "Samples 1–7 (lower stack)"),
	(8, 14, "Samples 8–14 (upper stack)")]):
	ax.set_facecolor(POWDER_BG)
	for sample in range(lo, hi + 1):
	mod = moduli.get((batch, sample))
	if mod is not None:
	patch = specimen_patch(sample, transforms[sample],
	MODULUS_RAMP(norm(mod)), None)
	elif sample in UNPRINTED.get(batch, set()):
	patch = specimen_patch(sample, transforms[sample], "none", None,
	edgecolor=UNPRINTED_EDGE, linestyle=(0, (4, 3)))
	else:
	patch = specimen_patch(sample, transforms[sample], BROKEN_FC, BROKEN_HATCH)
	ax.add_patch(patch)
	ax.set_xlim(0, plate_x)
	ax.set_ylim(0, plate_y)
	ax.set_aspect("equal")
	title = label
	if lo == 8 and batch in UNPRINTED:
	title += " — not printed"
	ax.set_title(title)
	ax.set_xlabel("X [mm]")
	ax.set_ylabel("Y [mm]")
	fig.colorbar(ScalarMappable(norm=norm, cmap=MODULUS_RAMP), ax=axes,
	shrink=0.8, label="Tensile chord modulus [MPa]")
	fig.suptitle(f"Batch {batch} — {family}, tensile modulus by build-plate position")
	png = save_figure(fig, OUT_DIR / "batches" / f"D638_{batch}_layout")
	plt.close(fig)
	print(f"wrote {png.relative_to(ROOT)} "
	f"({sum(1 for (b, _) in moduli if b == batch)} specimens colored)")


	if __name__ == "__main__":
	main()