GWN point slicer: inside / outside from the winding number

2026-10-28 13:01 · fcp v5.2 (CUDA), package untouched, prototype in scripts/gwn.py · the same 10 objects, 180 clouds, metric and references as fcp_2710_tests' synthesis (its eps and local prototypes are run again here for the normals) · tables from report/bench2.csv by scripts/make_page.py

Findings

• Clean, against the mesh route's 134 parts: 10k: gwn 136, with closing 128 (package 209, eps 185, local 180), error 0.80× the package's, normal median 7.2° (8.6°). 2048: 171, with closing 143 (273 / 237 / 222), error 0.68×, normals 18.2° (28.4°). 50k: 126 parts against 134 (package 145), error 2.80 against 2.79, normals 6.9° against 6.8°.
• Variable density (the open item of the synthesis): gradient 10k: 200 parts (package 887, local 248), error 0.51×, normals 10.4° (48°); stripes 10k: 243 with closing (1323, local 607), error 0.39×. The area weights make the winding number blind to density.
• Point noise, σ given: 0.6 % 10k: 284 parts (eps 349, local 364), error 0.52× (eps 0.78×, local 0.73×), normals 22° (eps 30°). 1.2 % 10k: 188 (median 0.69 of the mesh's: thin limbs go under the tolerance), error 0.66× (eps 0.71×), normals 34° (eps 29°, the one cloud where eps is better). 2048: 211 / 157 parts, error 0.78× / 0.99× (eps 1.04× / 1.26×).
• Mesh noise (clean samples of a bumpy surface, σ = 0): lowest error and best normals on all six; parts 0.66–0.91 of the noisy mesh's (bumps under half a spacing are smoothed).
• Thin walls are what is left: the open box (mesh 2 parts) gives 15 parts at 10k with closing (package 34) and 35 at 2048 (60); the synthetic open boxes show every slicer failing at walls of a spacing or less.
• Cost: 0.3 s at 2048, 1.6–3.5 s at 10k on a GTX 1650 (package 0.2 s), 11–54 s at 50k: a direct sum over all points per pixel; the main thing to fix before the package.

The pieces that matter, from the ablation: the local iso-value (thin parts survive), the tangent splats (walls of a spacing stay closed: clean 10k parts 262 → 176 with the loaf pan), the patch flips (density: the striped battery's normals 44 % inverted → 2.5 %), off when σ is given (1.2 % 10k error 14.8 → 9.2), and the 2D closing (fewer parts at zero noise, below).

All clouds: package, eps, local, gwn

Parts against the mesh route's on the mesh the cloud came from (the noisy mesh for mesh noise, else the clean mesh). Error: mean symmetric nearest-point distance to the clean mesh / diagonal (geometric mean over objects; ratio to the package per object, geometric mean). Normals: the descriptor's SDF normal (Shape.normal(method="sdf")) at 3000 points of the clean mesh against the outward face normal, oriented. 1024 atoms, 128 layers, up +z. sigma (the per-point noise) is given to eps, local and gwn on the point-noise clouds, 0 elsewhere. Green: best per cloud (parts ratio nearest 1).

Per object

clean · 10000

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

clean · 2048

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

point noise 0.6 % · 10000

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

point noise 1.2 % · 10000

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

point noise 1.2 % · 2048

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

density stripes · 10000

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

density gradient · 10000

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh's, lowest error.

Dense clean clouds (50 000 points): the exact end

The exact end: with 50 000 clean points (σ = 0, no closing) gwn gives 126 parts against the mesh route's 134 (package 145): within two on every object but the elephant (22 against 27); mean error 2.80 against 2.79 (package 2.87), normal median 6.9° against 6.8°. The open box: mesh 2, gwn 4, package 6.

parts · error ×10⁻³ (geometric mean on the last row) · normal median · encode seconds.

Fewer parts at zero noise

Goal: at zero noise, as few parts as the mesh route gives on the same clean mesh (the reference, per object; the elephant left out, its mesh-route encode is poor). The extra parts came from walls of about a spacing that open at single layers (open-box study). The fix in the slicer: a morphological closing of each layer's inside region by 0.75 spacings; the pixels it adds (gaps under 1.5 spacings) become just inside, the rest of the field is kept, so the contour keeps its sub-pixel position. Nine objects, mesh 107 parts: 10k 109 parts, sum |parts − mesh| 24 (gwn 117 / 32, package 177 / 74), error 3.01 (2.91 / 3.70); 2048 134 / 73 (159 / 92, package 252 / 167). On every cloud type it gives fewer parts at about the same error (main table, "gwn + closing").

A 3D closing (all layers on one grid, the layer step as the third spacing; 1 spacing, with the 2D one) gets 2048 to 105 parts (|Δ| 58) but fills concave steps (the battery's ledge at 2048: 4 → 2 parts, error ×2.4): not recommended. No better: larger splats (1.75, 2.5 spacings), a larger mollifier (0.75 spacings), larger 2D closings.

256 layers do not help. The mesh route goes from 107 to 139 parts and the clouds fall further behind (10k with closing 158, |Δ| 55; 2048 189, |Δ| 108): thin and flat-walled objects get twice the layers to break on while the cut tolerance stays one spacing; the organic ones stay at or under the mesh's count.

parts · error ×10⁻³; bold: parts nearest the mesh route's on the clean mesh (same layers); last row: total parts, sum of |parts − mesh parts| over the objects, geometric-mean error.

128 layers · 10000 points

128 layers · 2048 points

parts · error ×10⁻³; bold: parts nearest the mesh route's on the clean mesh (same layers); last row: total parts, sum of |parts − mesh parts| over the objects, geometric-mean error.

256 layers · 10000 points

256 layers · 2048 points

Thin walls: open boxes

Is the loaf pan's part count the mesh or the wall? Open boxes written by hand (exact, watertight, no lid), walls and floor of t point spacings at 10k points (scripts/openbox.py): a cube and a box of the loaf pan's proportions. The loaf pan's own wall is 1.45 % of the diagonal (median, by ray casting): 1.2 spacings at 10k, 0.5 at 2048, 2.6 at 50k (where gwn gives its 7 parts).

• It is the wall, not the mesh. At t ≥ 2 spacings gwn is near the mesh route's 2 parts (cube 4 / 3, pan 8) with the mesh's error and a few degrees of normal; the package needs 10 / 5 / 13. At t ≤ 1 spacing every slicer fails at 10k: gwn 16–70 parts, the others 46–123.
• Where the parts come from (cube, t = 1 spacing, 10k; gwn 16, package 54): the wall breaks at single layers where a sampling gap opens it (gwn: three long wall parts, layers 12–40 / 41–53 / 54–118), and the last 3–6 layers under the open rim fragment (gwn 9 parts, package 10). The floor gives none with gwn (package 5). At mid-height both slicers give the mesh's 2 rings.
• The normal medians of 60–90° at t ≤ 1 spacing are partly the measure: a decoded wall shifted by more than half its thickness puts the true point on the other side, and the oriented normal flips.
• Next on the encoder side, not the slicer: bridge one-layer gaps in tracking (a track ending at L and one starting at L + 1 / L + 2 with the same footprint), and fold short sliver parts under an open rim into the part below.

parts · error ×10⁻³ · normal median; bold: parts nearest the mesh route's, lowest error.

Decoding a prefix (95 / 99 / 99.5 % of the atom energy)

Does decoding fewer atoms (the shortest prefix holding 95 / 99 / 99.5 / 99.9 % of the descriptor's atom energy, the sum of squared atom values) give a better surface or normals? No, from 6144 atoms (the most a descriptor holds) as from 1024: on all ten objects and every cloud, clean or noisy (0.12 / 0.6 % with σ given), the full descriptor has the best normals and, but for one tie, the lowest error. From 6144: 99.9 % (300–800 atoms) costs 1.1–1.45× the error and 2.6–5.7° of normal median; 99 % 1.3–3.2×. The one tie is 0.6 % noise at 2048 points, where the error is flat from 99.9 % (and the first 1024 atoms are 3 % better, 4 objects of 10) while the normals still want every atom (+6° at 1024). The energy sits in ring means and low harmonics; detail and normals need the small atoms. And 6144 atoms beat 1024 on normals everywhere (1–6° of median) and on error everywhere but 0.6 % noise at 2048 (6–12 % lower) (clean 10k 7.2° → 5.5°, 0.6 % 10k 22.5° → 16.2°). The rest of this page encodes 1024 atoms, the package default, as fcp_2710_tests' ablation. scripts/energy_prefix.py (FCP_ATOMS=6144).

From 6144 atoms

From 1024 atoms (the bench's encodes)

Renders

Decoded at 96 cells per axis for the picture (the scores from the decode at the layers), coloured by part.

clean_10000

clean_2048

pn0p6_10000

The knee of the atom energy

Your knee (docs/noisy_clouds.md §3 in fcp_devel): with the noise in the atoms (a noisy mesh, exact slices), |v| in selection order stays high, drops, then decays as T⁻¹: the tail is the noise. Here on point clouds, 6144 atoms, gwn + closing, the knee by Kneedle (the atom farthest below the chord of log |v|, running median 64, against log T; the last 5 % left out), scripts/knee.py.

• With σ given there is no noise tail: the noisy descriptors decay like the clean mesh's (tail slope −1.7 against −1.55); the slicer's tolerance has already smoothed the noise, the Chamfer falls to a plateau and stays there, and the full descriptor is best.
• With σ = 0 (the slicer keeps the noise) the T⁻¹ tail appears (slope −1.1 to −1.2), as in your experiment. Truncating at the knee then denoises the normals where the knee is found: battery 1.2 % 28° → 9°, horse 44° → 38°, dino 47° → 40°, dress 53° → 47°; the Chamfer is worse at the knee on every object (it is flat past the knee, as you found).
• The knee is not found on fragmented descriptors (bowls, mug, shoe, open box under σ = 0: 60–190 parts): Kneedle picks the first 64 atoms (mug, shoe: flat discs) or the end. A stopping rule needs more than the curve's shape there.
• σ given beats σ = 0 + knee: at 1.2 % the normal median is 24° (σ given, full) against 46° (σ = 0 at its knee), Chamfer 8.8 against 13.7: smoothing in the slicer is the better denoiser for point clouds; the knee is the tool when the noise is already in the atoms.

σ = 0 per object

knee atoms (energy): Chamfer knee / full · normal median knee / full.

Chamfer against the energy not yet decoded

Renders: pn0p6_10000

Renders: pn1p2_10000

The tolerance knob: eps = max(0.5 local spacing, C sigma)

C sets how far the tolerance reaches once σ is given: larger C gives fewer parts and smoother surfaces, and loses detail under C σ (the horse's legs at 1.2 % noise). gwn uses C = 3.

What each piece does

Each row adds one piece (σ given on the point-noise clouds from row 6). Tried and dropped, numbers in report/bench.csv: per-point flips by the jump of w (they flip thin walls); a thin-sheet band from a normalized point density, flagged by cancelling normals or by low winding contrast (more parts and error everywhere, 3x the error under noise: noisy normals cancel like a thin wall); a noise estimate from w itself (reads 1/3 of σ on thin-walled objects, overlaps clean and noisy at 2048: report/sigma_gwn_v*.txt); the cut tolerance following σ (no change); the point-test cut rule (about 10 % fewer parts, slightly more error).

Method

One global field replaces the per-layer flood. For the oriented, area-weighted points the mollified generalized winding number

w(x) = 1/(4π) Σi ai ni·(pi − x) / (|pi − x|² + εi²)3/2

is about 1 inside and 0 outside, and each layer's rings are its iso-contour on that layer's raster (surf's own marching squares and loop chaining). The steps, each with the literature it comes from:

1. Area weights a_i = π r₁₆²/15 (the package's pose weights): the field does not depend on the density (fast winding numbers for point clouds, Barill et al. 2018). This is what fixes the variable-density clouds.
2. Directions and orientation: surf's robust directions and leak-proof flood, then patch flips: patches of the k-NN graph along one sheet are flipped greedily to make w two-valued on probes off the surface (a double well w²(1−w)², and w = 0 beyond the cloud's box), plus one global check (the jump of w across the points must be positive). This is the GCNO objective (Xu et al. 2023) on patches, a discrete version of the linear orientation of Gotsman & Hormann 2024. Used only when σ = 0 (measured: under noise they hurt).
3. Tangent splats: each dipole is spread over a disc in its tangent plane (centre + hexagon of radius 1.25 local spacings, a/7 each) with a small mollifier (0.25 local spacings): wide along the surface, so the gaps between samples close; sharp across it, so a wall of about one spacing keeps its two faces apart (surfel / disc winding numbers).
4. Local iso-value: the contour is w = τ(x), τ the Shepard average of w at the points (weights a/(d²+ε²)²), clamped to [0.05, 0.95]. The contour passes through the points, as an interpolating implicit (VIPSS, Huang et al. 2019); a global median of w at the points (DWG's iso-value, Liu et al. 2025) loses thin parts.
5. One scale ε_i = max(0.5 local spacing_i, C σ), C = 3: the mollifier, the splats' mollifier, the Shepard width and the minimum loop (2 max(s, ε)²) all follow it. σ = 0 is the exact end, σ > 0 the tolerant one.

Everything after the slicer is the package's (tracking, tracked-fit cuts with fit_tol="auto", atoms). The field is a direct O(points × pixels) sum on the GPU (CuPy kernels in gwn.py).

Open items

1. Speed. The field sums every splat at every pixel (O(7 n × pixels)). Barnes-Hut / fast winding numbers (Barill 2018: exact near, cluster dipoles far) and evaluating the far pixels on a coarse grid (the contour lies within a few ε of the points) should bring 50k to about a second. Then a numba twin for the CPU, as surf has.
2. σ is a parameter. The estimate from w itself (each point's offset through the flat-sheet profile, gradient normals) separates clean from noisy at 10k but reads about a third of σ on thin-walled objects and overlaps clean and noisy at 2048 (sigma_gwn_v2.txt).
3. Thin walls under heavy noise. When σ is far above the wall's thickness the two faces' dipoles cancel whatever their orientation (mug, bowls at 1.2 %: 30–50 parts against 6–8). Both thin-sheet bands tried failed (noisy normals cancel like thin walls).
4. Thin features under the tolerance go (the horse's legs at 1.2 % with C = 3): C = 2.5 keeps more (knob table), at more parts.
5. The package change is a decision for api/DECISIONS.md: a new slicer (and encoder version), noise= (σ) as the encoder's tolerance parameter.

Slices

Points within half a layer (grey), the mesh's section (black), the package's rings (blue), the GWN variants' rings (orange), at the layers with the most GWN rings. bowl_gso 2048: the rim wall is far thinner than the spacing, the earliest GWN breaks it into beads; mug, point noise 1.2 %: with σ and the first orientation the outside read as inside (the raster border is a contour), fixed by the outside probes and the global check; loaf pan 10k: a wall of about a spacing, fragmented before the splats.

slices_bowl_gso_2048_thin

slices_bowl_gso_2048_v1

slices_loaf_pan_10000

slices_loaf_pan_10000_close

slices_mug_pn1p2_10000

Gallery: decoded meshes coloured by part

Rendered before the open box replaced the loaf pan, and without the closing.

clean_10000

clean_2048

dstripe_10000

pn0p6_10000

pn1p2_10000