NestingBLFNaive (Bottom-Left-Fill Naive) is a simple rectangle nesting algorithm that places items sequentially into a container by always positioning each new piece in the lowest possible position and then the leftmost available space. It does not perform complex optimization or backtracking; instead, it follows a straightforward greedy placement strategy.

origin

geometries

sheetWidth

sheetHeight

sheetsGap

Distance from the edges of the sheet to the curves/surfaces to be nested

edgeClearance

spacing

Nesting BLF Naive

Sheet boundary curves. Flat array of rectangular curves representing each sheet used in the nesting.

sheets

Nested geometries in their final positions. Flat array of all geometries in the order they appear across all sheets.

Translation vectors for each input geometry. Array aligned with input geometries showing movement from original position. Unplaced geometries have zero vectors.

moveVectors

Rotation angles in radians for each input geometry. Array aligned with input geometries showing rotation applied. Unplaced geometries have zero rotation.

rotationAngles

Sheet index for each input geometry. Array aligned with input geometries showing which sheet each geometry is placed on. Unplaced geometries have value -1.

sheetIds

Original input geometry indices. Flat array showing which input geometry corresponds to each nested geometry.

geometryIds

<p><strong>Nesting for the BeeGraphy Editor.</strong></p>

Rectangular Nesting

True Shape Nesting

Overlay

nesting-dark.png

nesting-light.png

Nesting

Nesting by naive guillotine best fit algorithm

Nesting by naive guillotine best fit algorithm.

distance from the edges of the sheet to the curves/surfaces to be nested

Nesting Guillotine Best Fit Naive

Nesting by naive guillotine best fit genetic algorithm

Nesting by naive guillotine best fit genetic algorithm.

Required to get always the same output with the same input

seed

The minimum allowable size for nested pieces to be considered usable

minUsableSize

Genetic Nesting Guillotine Best Fit Naive

NestingRowNaive is a simple row-based nesting algorithm used in 2D bin packing / cutting optimization. It places items sequentially in horizontal rows inside a container (sheet/material). Each new item is placed next to the previous one in the current row until the row width is filled; then a new row is started below.

Nesting Row Naive

NestingMaxRectsBestFit is a rectangle nesting algorithm used to place multiple rectangular shapes into a larger container while minimizing wasted space. It works by tracking the largest available free rectangles in the container and placing each new item in the position where it best fits according to a chosen heuristic (usually minimal leftover space).

Nesting MaxRects Best Fit

NestingCBLFNaive (Corner-Bottom-Left-Fill Naive) is a simple 2D nesting / bin-packing heuristic that places shapes or rectangles into a container by always selecting the lowest possible position and then the leftmost available corner. It follows a bottom-left placement strategy without complex optimization or backtracking.

Number of different orderings to try (more = slower but potentially better packing)

numCursors

Random seed for reproducible results when numCursors > 5

Nesting CBLF Naive

3-stage guillotine nesting: sheet is cut into horizontal strips, strips into vertical stacks, stacks into parts. Optimized for format-cutting machines.

Spacing between sheets in the output layout

Gap between parts (kerf / blade thickness)

Allow 90-degree rotation of parts for better fit

allowRotation

Number of sorting heuristics to try (higher = slower but potentially denser)

Nesting Guillotine 3-Stage

Sheet index per geometry (-1 if unplaced).

Original input indices of placed geometries.

True-shape polygon nesting using genetic algorithm with bitmap collision detection. Supports hole filling and multi-angle rotation.

List of geometries to be nested (curves or surfaces)

Spacing between sheets when laying them out

Distance from the edges of the sheet to the nested parts

Number of rotation increments to test (4 = 0/90/180/270, higher = finer angles)

rotationSteps

Precision for discretizing curves to polylines (mm)

curveTolerance

Nesting Polygon Genetic

Sheet boundary curves. Rectangular outlines for each sheet used.

Nested geometries transformed to their final positions on sheets.

Translation vectors for each input geometry. Unplaced geometries have zero vectors.

Rotation angles in radians for each input geometry. Unplaced geometries have zero rotation.

Sheet index for each input geometry. Unplaced geometries have value -1.

Original input geometry indices for each nested geometry.

BLF — fast greedy bottom-left | GA — genetic algorithm over order + rotation (best density, slow)

mode

When all parts are uniform-radius circles, place analytically into a hex grid (skips BLF/GA). Falls back silently for non-circle input.

hexStart

mm per pixel. Smaller = more accurate but slower + more memory. Auto-adapts upward for huge sheets (capped at 500px/side), so this only matters at face value for sheets ≤500mm/side.

resolution

Post-pass compaction iterations. 0 = disabled (default — benchmarked to add no density over the lowest-top placement while roughly doubling run time). Raise to trade speed for a possible tighter pack on hard inputs.

qlmPasses

PRNG seed for GA. Same seed + input = bit-exact same output.

popSize

GA maximum generations. Each generation re-runs the full placement popSize times, so keep it modest — the GA is seeded from the BLF result and only searches for improvements on top of it.

maxGens

Stop GA after this many generations with no improvement. Low by default so runs where BLF is already optimal (the GA seed) finish quickly instead of grinding stagnant generations.

stagCap

mutSwapRate

mutRotateRate

True-shape nesting via bitmap pixel-mask collision. Handles curved, concave, and holed shapes natively. Supports BLF (fast) and GA (dense) packing, per-part rotation, kerf-aware spacing, hex pre-pass for circle inputs, and QLM post-pass compaction.

List of geometries to be nested. Any shape — curves, concavity, holes handled natively.

Minimum clearance between parts (kerf). Dilates each part mask.

Discrete rotation poses per part. 1 = no rotation, 2 = fast and the best default, 4 and 8 sample finer. The arc they span is chosen per part: shapes that tile when flipped (wedges, triangles, L-brackets) get the full circle, shapes that nest by translation (arcs) get 0..π. More poses cost proportionally more time and rarely change the sheet count — raise only for strongly irregular parts.

Precision for discretizing curves to polylines (mm). Smaller = more samples per curve.

Nesting Bitmap Polygon

Fraction of usable sheet area covered by parts (0-1), per sheet. Edge clearance excluded.

utilization

Largest reusable empty rectangle per sheet (CAM remnant-stock detection).

remnants

One diagnostic string per unplaced part, or empty if all parts were placed.

unplacedReasons

Overlays one geometry onto another: moves it (Translation, if given), rotates it (Rotation, if given) about the base geometry's bbox center, then moves it again (Offset, if given, rotated to match). Copies the base geometry meta onto the result. Wire arrays into the ports and use the node's List Matching (right-click: Shortest List / Longest List / Cross Reference) to control how items pair up.

baseGeometry

Geometry to overlay onto the base geometry

overlayGeometry

translation

Rotation (radians) applied to the overlay geometry about the base geometry's bbox center

rotation

Additional move applied after Rotation and Translation, rotated by Rotation so it stays in the same relative direction

offset

When enabled, warns if the transformed overlay geometry extends beyond the base geometry's bounding box

checkBounds

Overlay Nested Geometry

Resulting geometry with the overlay applied

Nesting BLF Naive

Ports

Inputs

Outputs