One design in. Sixty production files out, or none at all.
A WPC door design has to exist in every size a customer might order, in four different file formats, each named exactly the way the CNC operator expects. Done by hand it is an afternoon of exacting, error-prone work per design — and a single mistyped size reaches the router as scrapped material.
A manufacturing pipeline that runs on an operator’s machine and writes production bundles to disk. There is no hosted surface — the evidence is the source, the generated bundles and the run manifest.
orchestrator.py — 1,261 lines
Drives the run: size matrix expansion, staged delivery, bundle verification, idempotency checks and legacy artifact migration.
vector_compiler.py — 869 lines
Converts the source image into closed-contour toolpath geometry and generates the spot-UV varnish mask via HSV band segmentation.
catalog_pdf.py — 316 lines
Renders the per-size catalogue PDF that ships inside each bundle.
outputs/ — 7 production bundles
Seven completed `*_Production_Bundle.zip` archives plus `latest_run_manifest.json`, which records the naming contract and the full 15-entry size matrix in millimetres.
SheetFlow_ComplexJali_914x2134mm_Toolpath.svg
A compiled sample: 250 closed contours at 914.4 × 2133.6 mm, ready for the router.
dashboard.html — 1.4 MB
A generated single-file production gallery titled “Sheetflow WPC Production Gallery”, embedding the compiled previews inline so it opens with no server and no asset directory.
section handoff
The problem
What the build had to solve.
01
Every design must ship in 15 sizes — three widths by five heights — and each size needs four different production roles.
02
CNC operators consume files by filename, so an inconsistent name is a production error rather than a cosmetic one.
03
Runs get interrupted, and a half-written bundle that looks complete is worse than an obviously missing one.
section handoff
Architecture
How the work moves through it.
Ingest
Compile
Emit
Deliver
1
Ingest
A single source design image enters the pipeline with a per-design configuration describing how its varnish bands should be segmented.
Source image
Per-design config
Change detection
2
Compile
The image is vectorised into closed-contour geometry and scaled across the size matrix at one uniform factor on both axes, so proportions never drift between sizes.
Contour extraction
15-size matrix
Uniform scaling
3
Emit roles
Each size produces four artifacts under a documented naming contract: the CNC toolpath, the print file, the spot-UV varnish mask and the catalogue page.
Toolpath.svg
Print.jpg
Varnish.png
Catalog.pdf
4
Deliver atomically
The bundle is staged to a partial file, verified, and only then renamed into place — so an interrupted run can never replace a good production pack with a truncated one.
.partial staging
verify_bundle()
Atomic rename
Run manifest
section handoff
The build
What it is made of.
Every row was read off the source, not from a project brief. Line counts, versions and limits are the ones in the files listed above.
Language
Python — 2,446 lines across three modules
Size matrix
15 sizes: 30/32/36 in widths × 72–84 in heights, recorded in millimetres
CNC target
VCarve / ArtCAM, 6 mm tool at 3 mm cut depth
Varnish masking
Spot-UV masks via a multiband HSV segmentation engine, configured per design
Naming contract
{CleanDesignName}_{CleanSize}_{Role}{ext} — ASCII letters and digits only, no spaces in any path segment
Safety
Idempotent re-runs, `preview_only` dry-run on every destructive path, atomic staged delivery
section handoff
Engineering decisions
The choices, and why they went that way.
A bundle is renamed into place only after it verifies
Production packs are overwritten on every re-run, and a run can die halfway — a lost connection, a full disk, an operator closing the terminal. Writing directly to the destination means a truncated archive silently replaces a good one, and nobody finds out until the router does. Staging to a partial file and renaming only after verification makes an interrupted run leave the previous good bundle untouched.
Verify: Bundles are written to a `.partial` path and renamed only after `verify_bundle()` passes; the seven archives in `outputs/` are all complete.
The filename is treated as a machine interface
The CNC operator finds files by name, and tooling downstream parses them. That makes the filename an interface, not a label — so it is specified as a contract with a fixed field order, a fixed separator and an ASCII-only charset, and written into the run manifest rather than living in someone’s head.
Verify: `latest_run_manifest.json` carries the naming contract explicitly: pattern, field separator, the four role suffixes, archive layout and charset.
Every destructive path has a dry run
The pipeline deletes and overwrites production output. A dry-run flag threaded through every such path means an operator can see exactly what a run would do before it does it, which is the difference between a tool people trust with a full rebuild and one they only ever run on a copy.
Verify: Destructive operations take a `preview_only` parameter throughout the orchestrator.
Unchanged designs are skipped, not recompiled
Compiling 15 sizes × 4 roles is expensive, and most runs re-process a catalogue where one design changed. Change detection means a re-run costs roughly what the change costs, which is what makes running it routinely practical.
Verify: The orchestrator gates work behind `is_new_or_changed()` and `bundle_covers()` checks.
section handoff
Business outcome
What we can prove, and what we cannot.
Not publicly disclosed.
No business outcome has been measured against a stated method and confirmed with this client, so no figure is published. We would rather show you the system and let you judge it than print a number nobody verified.
section handoff
Questions
About this project.
What is WPC Design Automation?
A SheetFlow internal build: a Python pipeline that takes one WPC door design image and compiles it into a 15-size production matrix, emitting a CNC toolpath, a print file, a spot-UV varnish mask and a catalogue PDF for every size, packaged as verified production bundles. It is a manufacturing tool with no public deployment.
Was WPC Design Automation built for a client?
No. It is SheetFlow’s own capability, built to demonstrate what design automation can do for WPC manufacturing. No client commissioned it and no engagement is claimed. It is published here as an example of the engineering, not as delivered client work.
What business results has WPC Design Automation produced?
Not publicly disclosed. There is no client engagement behind it and no measured production outcome has been confirmed, so no figure is claimed.
