u#
Summary: geometric mean over the objects of the ratio to the default
Default row shaded (tracked-fit, κ 1e2, M 24). Green: 2 % better, red: 2 % worse. Parts and
encode time summed over the objects; longest deg: the largest degree any part reached.
zno rows yet
a8
The two effects apart: the cut decision and the stored basis
scripts/split_2x2.py: tracked-fit's cut decision with the default or a high cap (fewer cuts), and the
stored height basis with the default or a high cap (higher degrees). Ratios to default / default (shaded).
u&
Why the elephant is cut so much
17 tracks, 27 parts: every extra part comes from one track, the body (layers 6-99), cut into 11 slabs. Three or
four of its cuts sit on real events (a step of 0.2-0.5 in the ring coefficients, a jump of the perimeter: legs at 13, the
leg tops at 26-30, the head at 50-51, the trunk at 91). The others (19, 36, 61, 70, 77, 85) sit on smooth stretches (steps
0.01-0.05). There the cut test, the fit's worst miss in coefficients, is 2.5-4 times the miss in shape
(nearest-point RMS between the fitted ring and the sliced ring): 14-26 0.029 against 0.0072, 31-50 0.0115 against 0.0038,
61-89 0.031 against 0.0096 (tolerance 0.01). The rest is the parametrization sliding along the ring (tangential drift of
the arc-length start), which moves no surface. Across the head (36-89) both are large (0.149 / 0.045): a real cut.
A higher degree removes some of these cuts only by following the drift too.
scripts/body_track.py elephant → report/elephant_body.txt (per layer: rings in the
slice, area, perimeter, coefficient step; then the coefficient and shape misses of the stretches).
zelephant_body.txta
Step 2: the fit test in shape, not in coefficients
scripts/shape_test.py: tracked-fit unchanged (tracking, cut search, step rule, tolerance 0.01,
default cap) except that a fit follows its part when every ring is within the tolerance in shape (nearest-point RMS
between the fitted and the sliced ring, both ways) instead of in coefficients. Green / red: shape better / worse than coef.
Renders: shape-fit images in each object's section.
u?
Step 2, result. (After a fix: the first run measured to the nearest sample of the other ring,
which leaves a floor of up to half a sample spacing, about the tolerance on a big ring, and cut more; now to the polyline.)
The shape test cuts less (124 parts against 134: elephant 27 → 23, shoe 22 → 17, dress 17 → 16, horse 18 → 17, bowl_gso
6 → 5) at the same Chamfer (× 0.997 / 1.000 / 1.001 at 256 / 1024 / 6144). Normals: better at 256 on the elephant and the
shoe, worse at 6144 (elephant, shoe, horse about +9 %; bowl_gso × 1.9). The bowl shows why: the foot (6-14) and the waist
(15-26) become one part, and its fit leaves horizontal ripples at the foot, still at 6144 atoms. Every ring is within 0.01
in shape, but 0.01 is 0.64 of a layer height (2 / 128): a miss that alternates from layer to layer at that size tilts the
surface by tens of degrees. A tolerance on distance alone allows it; the coefficient test caught it by being stricter for
another reason. Next: a slope test besides the distance (the change of the miss between neighbouring rings, against the
layer height).
Which parts fit their shape
scripts/fit_audit.py: per part, the worst shape distance over its layers between the sliced ring
and the ring given back at the layer centre, in layer heights (0.0172 canonical; the cut tolerance 0.01 is 0.58 of
one). Counts of parts by their worst miss. "full fit": all degrees of the part's height basis (what the cut test judges).
Images: per object and cut test, the four parts that miss most: equivalent radius sqrt(area / pi) along the part (sliced,
full fit, 6144, 1024 atoms) and the miss per layer.
What it shows. 6144 atoms give back the full fit (the budget is not what limits a part there); 1024
does not (elephant parts 0.5-2 layer heights off). Most parts fit to under a tenth of a layer. The waves are where a part
holds a corner or a step: the polynomial rings around it with a period of two or three layers across the whole part
(bowl_gso, shape test: the foot, layers 6-26, holds the bottom edge at layers 6-8, the radius 5 → 27 layer heights in two
layers, then a gentle flare; its miss alternates 0.1 / 0.28 up to layer 26 and peaks at 0.52 at the corner. The corner
cannot be cut off: it is two layers from the end and pieces are at least FIT_MIN = 4). With the coefficient test every part
of the ten stays within 0.38 of a layer (dino 0.38, dress 0.31, the rest 0.25 or less); the shape test at the same 0.01
lets elephant, bowl_gso and shoe parts go to 0.5 (a step at the head, the leg tops, the foot). The coefficient test is,
in shape, about three times stricter than its number: it cuts the corners and steps, and the smooth drifting stretches too.
So the knob is the tolerance in shape: a fraction of a layer.
u
The dino's body part: the height polynomial
scripts/part_profile.py dino 1e4 50 and dino 1e2 24: the largest part, the sliced rings at
the layer centres (dots) and the stored polynomial drawn continuously at 1024 and 6144 atoms (equivalent radius, five single
coefficients, the shape miss at the centres).
With the ground truth (grey: the mesh sectioned at 10 heights per layer, the part's ring; bottom panel,
lines: the polynomial against it at every height, dots: against the sliced rings at the centres).
Inside (41-65) the true section is smooth and the 6144 polynomial follows it to about 0.12 of a layer between the
centres too (0.05-0.08 at them); at 1024 it is 0.4-0.65 everywhere: the budget, not the partition.
The top end (66-70) is a real event: the true section jumps at 66.4 (radius 16.1 → 17.9 → 16.7, x centroid -5 → -9.5
→ -7.5) and again at 68.2 (16.5 → 17.6): something joins the body ring, twice, between layers. The part runs on through it
in both settings (a cut there would leave 2 layers, FIT_MIN = 4), and no polynomial follows a step: 1.5 layer heights off
between the centres at 6144, though 0.07 at them.
The bottom end (39-40) is smooth in truth; with KAPPA 1e4 the polynomial swings there anyway (more than 2 layers off
between the first centres; beyond the end centres up to 193 layer heights of radius): the ill-conditioning KAPPA 1e2
prevents. The default follows it.
Note: the SDF decode does not read the polynomial between the centres (it interpolates the rings' signed distance), so the
lines between the dots are the polynomial's behaviour, not the mesh's.
Why 1024 atoms is wavy, and a smaller dictionary
The cap on the atom count changes nothing below it: the selection is one projection and one sort, so
MAX_ATOMS = 2048 and decoding 1024 gives the dino's descriptor and mesh bit for bit as 6144 does. The waves at
1024 are the selection's: it keeps the atoms of largest energy (185 of 1021 values in the dino's body part, scattered over
degrees 0-16), so the error left is the sum of the dropped degree polynomials, an oscillation along the height
(0.4-0.6 of a layer). A smaller dictionary (scripts/nm_sweep.py; the cut test fits with the same M, so
a lower M also cuts more): lowering N loses the angular detail (8 / 8: Chamfer 1.07-1.17 times, normals 1.6-1.8 times at
1024 / 2048; the battery and the open box worst); the dino's body at N 8, M 8 is smooth along the height at 1024 (degrees up
to 4 kept) but 0.35-0.55 of a layer off the ground truth, and 0.25-0.5 still at 6144: 8 harmonics cannot draw its section
(the dots there are the N 8 rings, not the truth). Keeping N 16 and lowering M only: Chamfer within 0.4 % at every budget;
normals over 30° 8 % fewer at 256 (M 12 or 8), 4-10 % more at 1024 / 2048; elephant better (42.5 → 37.2 % at 1024, M 8),
dress worse. A lower degree trades the waves for more parts; at 1024 the error stays about the same size.
a<
Step 3: the fewest parts for a tolerance
scripts/dp_split.py: each track partitioned by dynamic programming into the fewest pieces (at
least FIT_MIN = 4 layers) whose full fit misses no ring by more than the tolerance; among those the least total squared miss
(cuts on the events). dp-coef: the package's measure and tolerance (coefficients, 0.01), so its difference from
greedy (the package) is the search alone; dp-shape-t: the miss in shape, the tolerance t layer
heights. Worst part miss: over all parts of all objects, the full fit's worst ring, in shape (layer heights). Ratios to
greedy. Renders at 1024 atoms below the tables (6144 in img/).
a
Step 4: cut where the shape jumps between neighbouring rings
scripts/ring_steps.py: along each track (before any cut), the shape change from one ring to the
next (each ring evaluated at 256 points from its Fourier series, the RMS distance of each one's points to the other's
polyline, both ways: no fit, and no dependence on where a ring starts), log scale, with the package's cuts (red).
scripts/spike_split.py: a cut where that step is at least 2.5 times the median of the steps within 4 layers
on either side and at least one layer height; pieces down to 2 layers. spike: nothing else;
spike+fit: then the package's cut search inside any piece whose fit still misses by more than 0.25 of a layer
in shape.
The events stand out as spikes over a slowly varying baseline (0.02-1.5 layer heights). The dino's long
track is cut by the package on its spikes already (11.5, 29.5, 38.5, 68.5; 66.5 not, as it would leave 2 layers). The
elephant's body has spikes at 8, 13, 26, 30, 50-51, 64, 89, 91, 96, and the package cuts on some (13, 51, 91), between 26 and
30, and on flat stretches at 19, 36, 61, 70, 77; 64, 89, 96 not. The bowl's wall is smooth from 9 to 114 (falling from 1 to
0.02 as it turns vertical); its spikes are the bottom edge (6-8, up to 15 layer heights) and the rim (115+), and the
package's cuts at 14.5 and 26.5 sit on the smooth stretch, fencing off the bottom edge that is too close to the end to cut.
First three objects: spikes alone leave the bowl's bottom edge inside (between the track's first two rings: a cut would
leave one ring; 14.8 layer heights off) and an elephant piece at 0.47; with the check: elephant 27 parts (0.21), bowl 5
(0.10, one fewer than the package), dino 28 (0.24 against the package's 25 at 0.38: the two-layer pieces at its joins).
spike_splitspikeuV
Step 5: cut only when coefficients AND shape miss
scripts/and_test.py: the package's cut search unchanged; a piece is cut only when its fit misses
a ring by more than 0.01 in coefficients (the points at the same t) and by more than t layer heights in shape (closest
points). Sliding along the ring (large in coefficients, small in shape) no longer cuts.
It changes little: 134 parts → 133 (t = 0.15, 0.2), 129 (0.25), 128 (0.3); Chamfer within 0.2 % at every
budget, normals within 1.5 %. Only a handful of the package's cuts come from sliding: the rest are misses of more than 0.3 of
a layer in shape, real changes the polynomial does not follow. With the cut test as the lever, there is little room to
make parts bigger at the same accuracy.
Why so little (scripts/and_scatter.py: every piece the package's cut search tests, its
fit's worst miss in coefficients and in shape). 144 pieces tested on the ten meshes, 60 cut. The shape miss is about half
the coefficient miss (median 0.48; 10-90 % 0.27-0.73), and the points sit close to that line: a piece that fails the
coefficient test (over 0.58 of a layer) is almost always over 0.3 of a layer in shape too. Of the 60 cuts, the shape miss
is under 0.15 for 1, under 0.25 for 5, under 0.3 for 6, under 0.4 for 9, under 0.58 (the same number as the coefficient
tolerance) for 12. AND spares only those; the rest are real shape misses.
and_testandu
The mug's handle: where coefficients and shape part ways
scripts/mug_handle.py mug: along the body track, the step between neighbouring rings in
coefficients (points at the same t: what the fit sees) and in shape (closest points), with the package's cuts; below, the
rings around the four largest steps (start point dotted; the slice's other rings, the handle, in grey).
Layers 28-38: the handle's root grows out of the body ring as a lobe; the coefficient step (about 3 layer
heights) is 2.7 times the shape step (1.1): the lobe adds length and every point slides. The package does not cut there:
the fit follows it, and the body part 6-38 holds the whole root. 38 → 39: the lobe pinches off and becomes its own ring (the
handle hole appears): the body ring loses a lobe of about 8 layer heights in one layer, shape step 7.8 (19 in
coefficients), and the package cuts exactly there. 94 → 95 and 101 → 102: the handle joins from above in one layer (4.3) and
pinches off again (5.6): cuts at 93 and 102. The rim (119 → 121): 47 in coefficients against 5 in shape (the start point
jumps), then a real jump of 31: cut at 113. The cuts are on real jumps of the outline, which both measures see; where only
the coefficients jump, the fit follows, or a real jump is next to it. To keep the handle region in the body's part, the part
would have to hold a lobe that vanishes within one layer: no height polynomial can, whatever the cut rule. The way out is
the tracking: the lobe as its own part from where it starts to grow (a ring split at its neck).
Step 6: rings split at their necks before tracking (prototype)
scripts/neck_split.py mug: every solid ring cut at its narrowest neck (the pair of points with the
least chord / shorter arc, under 0.3, chord inside, both pieces at least 3 % of the area), then the package's tracking,
Fourier and cut rule unchanged.
Mug: 4 tracks → 12, 8 parts → 16 (worst part miss 0.15 → 0.18 of a layer). The handle becomes three parts
(lower root 33-39, handle 40-95, upper root 96-100), but the body is still cut at 33 and 96: the neck forms only once the
lobe is longer than it is wide, so the body ring still holds the short bump at 28-32 and loses it at 33 (a smaller jump,
still cut). The rim's thin lip (120-121) is shredded into 7 parts. To work, a split found at one layer would have to be
carried down the track to the layers where the lobe is still a bump (two passes), and thin rings (rims, walls) kept whole.
Not run on the other objects.
Step 7: momentum, the body goes on and the lobe is peeled off (prototype, mug)
scripts/momentum.py mug: after tracking, a long solid track is fitted along the height on the layers
it follows; at the others the clean body is interpolated (PCHIP per coefficient) from the undisturbed layers on either side.
Where a ring is the clean ring plus a lobe (reaching 2 layer heights out, meeting the clean ring along at most 40 % of it),
the track keeps ring AND clean ring and the lobe (widened 1.5 layer heights into the body, so the parts overlap) goes to the
track it touches (the handle). Then the package's cut rule.
The body is one part from the base to layer 96, through the lower handle attachment (the package: 6-38,
39-92, 93-101); the lower root joins the handle's track (one cut left at 39, where the handle hole opens: a real ledge).
The upper attachment only partly (the body flares towards the rim there; the body cut at 97). 9 parts against 8, worst part
miss 0.14 against 0.15. Accuracy: Chamfer 0.296 / 0.228 / 0.223 against 0.282 / 0.225 / 0.220 at 256 / 1024 / 6144; normals
over 30° 13.8 / 2.8 / 1.9 % against 12.7 / 0.96 / 0.52 %. The overlap costs it: the decoder's signed distance at a layer is
to the nearest ring edge, the lobe's edges inside the body included, and near the junction those inner edges bend the field.
Parts that overlap are inside for the decoder, but its distance assumes rings that do not. Making this pay would take a
union distance in the decoder (each part's own distance, then the largest), on NumPy, numba and CUDA, bit for bit.
With the union distance in the decoder (worktree ../fcp_devel_union, branch union-sdf)
Decoder: the distance at a layer is measured only to segments on the region's boundary (a segment whose
midpoint the other rings put inside the region on both of its sides is left out; the parity unchanged); one host flag table,
the same on NumPy, numba and CUDA; disjoint or nested rings unchanged; all 281 tests pass. On the mug the flags work (the
buried segments at the lower root, 28-38) and the bad normals there are gone. What is left is the upper attachment
(95-101), right where the body flares towards the rim: the clean body predicted from below does not flare, so part of what
is peeled is a band around the rim, not the handle. Peeled patchily (95, 100, 101): 9 parts, normals over 30° 2.8 / 2.0 %
at 1024 / 6144 against 0.97 / 0.57; peeled whole (95-101): 8 parts with the body 6-102 one part, but Chamfer 0.75 against
0.22 (the band, drawn with 16 harmonics, wanders into the cavity). The lower attachment shows the idea works where the body
is predictable; near the rim it does not yet.
v6
The v6 work (the evaluation on meshes and clouds, the short-track filter, atoms="auto", lobe parts) has its own
report: fcp_2910_v6/report/index.html.
Per object
zl
Green / red: better / worse than the default row by 2 % (Chamfer) or 5 % (normals).
z