Schematic Construction

If Schematic Overlay is the one-stop "annotated product shot" look, Schematic Construction is the heavy sibling: it lays a full projective-geometry plate over the photo - two convergent ray pencils, concentric spheres, computed intersections, a graduated scale, a running data column - the whole Kepler-era diagram apparatus. This is the node you reach for when you want a render to read as a measured drawing, something that looks like it was produced by an astronomer with a pencil and a very long ruler, rather than a sticker sheet.

The through-line is that everything on the plate is computed, not drawn. Every label sits on a point the geometry actually produced. If Overlay is decoration, Construction is argument - and the seed doesn't just shuffle content, it chooses among valid layouts.

How it works

The pipeline starts with the same detection engine as Overlay: the image is scored on a block_size grid, points above threshold become the anchors, and two foci shoot rays at them. The primary focus (focus_a_x / focus_a_y) carries a convergent ray pencil (rays_a), and the secondary focus (focus_b_enabled, rays_b) is what produces the interesting intersections - the tooltip's point: the second pencil creates the non-trivial quadratic intersections where B's rays cut A's spheres. focus_clear keeps the focus itself untangled by starting rays a fixed fraction out from it.

Concentric spheres (sphere_count, sphere_inner, sphere_outer, sphere_span) sit about the primary focus, and the annotation engine computes every ray-meets-sphere intersection. marker_every thins the markers, label_every thins the labels, and a label collision resolver silently drops any label it can't place cleanly - so annotation thins out exactly where the geometry is densest. That's a feature, not a bug; without it the plate would be unreadable mush.

Then the micrographic dressing: a hatched lune (lune_density), a graduated scale on the outer sphere (scale_ticks), frame-exit labels giving each ray its index and true bearing (exit_labels_every), leader callouts (callout_count), and the running IDX / ANG / REF data column (data_column_rows). Three weight classes - datum, construct, fine - keep the hierarchy readable, and line_weight scales them together.

The inputs that matter

• image - the photograph. Its own tooltip is the whole philosophy: "It is never altered outside a pixelate zone."
• seed - the big one. It picks focus positions within their legal bands, which detected points the rays aim through, sphere radii, which gap carries the lune, and which intersections become pixelate zones. Same seed, same plate - deterministic across a batch.
• focus_a_x / focus_a_y, focus_b_enabled - where the geometry converges. Everything resolves to focus A, so nudging it re-aims the whole plate.
• rays_a / rays_b / sphere_count - density of the two pencils and the spheres. This is where you control how busy the plate is.
• palette - only three options here: whiteOnDark, blackOnLight, or custom (with bg_color / stroke_color). The tooltip's advice is spot on: use blackOnLight on a light photograph, because polarity is how this node stays legible rather than shadowing every stroke.
• elements (optional) - the addressable-elements override string. One per line, e.g. rays_b: off or spheres: +0.02,-0.01, with offsets as normalised canvas fractions so they survive a resolution change. Every group also has its own off_*_x / off_*_y offset widgets.
• pixel_size - mosaic tile size; 1 disables pixelation. The sample zones land on computed intersections, so every patch sits on an event the construction produced.

Outputs and where they wire

Same three image outputs as Overlay - image (full composite), overlay_only (the plate without the photo, for compositing elsewhere), overlay_alpha (a 0-to-1 mask of everywhere a vector element was drawn) - plus a fourth:

• element_table - a STRING listing the resolved element table. The README's trick: paste any line back into elements and edit it - that's how you nudge individual elements without hunting for widgets.

Install and getting comfortable

Same install as the whole pack - ComfyUI Manager (search "ComfyUI Schematic") or:

cd ComfyUI/custom_nodes
git clone https://github.com/jeremieLouvaert/ComfyUI-Schematic

Restart, and it appears under AKURATE/Schematic alongside Overlay and Voronoi. Only dependency is Pillow (already in ComfyUI), no models. If the annotation looks too small, that's type_scale (it scales all annotation, and the tooltip notes the type stays a fixed fraction of canvas - it's texture, not content, so it won't hold up to heavy upscaling). If the plate is too dense, raise marker_every and label_every rather than dropping the whole thing. And if you're overwhelmed by the ~45 inputs, ignore almost all of them at first: set image, pick a palette, nudge focus_a_x / focus_a_y, and let seed do the layout roulette. It's a fiddly node - that's the point - and it's the only one I've seen that ships a derivation document for why each line is where it is.