Geometric Shell-Generation Problem

[netemadi9]

Hey all,

I’m working on a geometric shell-generation problem and would appreciate advice on the appropriate formulation and MeshLib operations.

The input consists of:

• An open, curved reference surface F.
• An optional narrow boundary band C, extending from F at a specified width and angle.
• The outer boundary R of that band.

I need to generate an exterior surface E that joins R exactly and gradually reaches a requested clearance from F.

The desired behavior is:

• Preserve the boundary’s position and shape, including tight bends.
• Follow the underlying reference surface’s broader curvature.
• Allow reduced clearance near the boundary, transitioning smoothly to full clearance farther away.
• Adapt that transition naturally when the boundary band’s width or angle changes.
• Avoid self-intersections, inward folds and unwanted handles.
• Generate within a few seconds.

The clearance requirement applies to F. The boundary band is part of the shell’s existing geometry, so requiring clearance from the entire F+C surface would be incorrect: E must touch C at their shared boundary.

Our most promising experiment uses MeshLib’s WeightedShell.pointsShell to construct a union of spheres sampled on F. We exclude spheres that would engulf R, unite the result with a temporarily closed solid beneath F+C, then extract the exterior and conform its boundary to R.

This produces a coherent surface with a clean boundary connection in several cases. However, the departure near R is often too steep. It does not sufficiently follow the reference surface before reaching full clearance. There is also a limitation when the boundary band is wider than the requested clearance: spheres centred on F may not reach the boundary region at all.

Other experiments have exposed different problems:

• Direct normal offsets and shrinkwrap can develop local folds.
• Dilation/erosion improves the main body but does not determine the desired boundary transition.
• Smoothing a separately constructed transition can produce pinching or an obvious change of shape.
• Offset guides derived from a closed solid can inherit curvature from its artificial closure near the open boundary.

We are testing with MeshLib 3.1.4.297.

Is there a MeshLib operation, or a recommended combination of operations, for generating one smooth exterior with fixed boundary conditions and a gradually enforced clearance constraint?

Would you approach this as a constrained distance field, a rolling-ball construction with a rounding radius independent of clearance, an obstacle-constrained surface deformation, or something else?

In particular, how would you formulate the boundary transition so that it emerges from the reference geometry rather than requiring a prescribed profile?

Here are a couple of illustrations for reference.

Thank you!!

[Fedr]

Your union-of-spheres experiment is the right formulation. MeshLib has it built in, in a more complete form, and a few changes remove the problems you listed.

1. Use the mesh version, not point samples. WeightedShell::meshShell( mesh, vertWeights, params ) (ParametersMetric). Weights are interpolated linearly inside triangles, so the result is the boundary of the union of balls centred at every point of the input surface with radius params.offset + w(p). There are no sampling gaps, and since the band C is simply part of the input mesh, "spheres centred on F do not reach the boundary" cannot happen: the shell reaches R because you put weight there, however wide the band is.

2. Use the one-sided distance. params.dist.bidirectionalMode = false. The field becomes signed distance minus weight, and the iso-surface exists only on the normal side of the input. No inner sheet, no need to close the solid underneath, and nothing from an artificial closure can leak into the result.

3. Put both the boundary condition and the transition into the weights.
params.offset = clearance; w = -clearance on R (ball radius 0, so the surface passes exactly through R); w = 0 far from R (full clearance); a ramp in between, as a function of geodesic distance from R along the surface (computeSurfaceDistances( mesh, rVerts )).

The transition is then the envelope of balls of smoothly growing radius rolling over the reference surface, so it inherits F's curvature and is fold-free by construction (an iso-surface of a continuous field cannot fold, and one-sided mode has no handles to create). The only thing you prescribe is the 1-D radius function ρ(s) = clearance + w(s):

• its slope is the departure angle: the surface leaves the carrier at asin(ρ'); e.g. ρ(s) = c·(1 − (1 − s/T)²) leaves R at asin(2c/T) and lands tangentially on the full-clearance offset at s = T;
• keep ρ' < 1 everywhere and tell the search about it (params.dist.maxWeightGrad), plus minWeight = -clearance, maxWeight = 0;
• "too steep near R" is just a shorter ramp than you want: lengthen T.

4. Round the F/C crease of the carrier first. E runs on the inner side of the crease where the band meets F, and the inward offset of a crease is again a crease, however smooth ρ is. So build the shell not on F+C itself but on a copy with the crease rounded: positionVertsSmoothly( carrier, vertsWithinRoundingRadiusOfTheJunction ), rounding radius about twice the clearance (keep R itself fixed). The clearance is still checked against the original F; the rounding only moves the carrier towards E, so it never reduces the real clearance. With this the transition has no visible angle: in my test the largest dihedral angle per edge in the transition zone went from 55° (crease) to 10° with a 2c rounding, against 4° on the plain offset part of the same shell.

5. Cut the flap. Marching cubes continues the surface past R (the signed field jumps across the tangent extension of C beyond R), so: project the vertices of R onto the shell (findProjection), convertMeshTriPointsToMeshContour + cutMesh, keep one side with fillContourLeft, snap the new boundary onto R (findProjectionOnPolyline), and relax a few rings next to the seam with positionVertsSmoothly keeping the seam fixed. That gives an exact boundary connection.

Attached is the whole pipeline as one Python script, shell_from_ply.py (in the zip, with the synthetic input FC.ply and its result E.ply); it takes any F+C mesh whose only boundary loop is R, and the five constants at the top are the clearance, the band width, the transition length, the rounding half-width and the voxel size:

python shell_from_ply.py FC.ply E.ply

Numbers on that 17k-vertex synthetic F+C (band 5 mm wide, tilted 60°, clearance 3 mm, transition 12 mm): shell in 3.3 s at 0.8 mm voxels, 12 s at 0.5 mm; distance to F is 3.000 median with 5e-3 max deviation outside the transition, reduced smoothly to 2.7 next to R; the only self-intersections are a few sliver triangles at the cut seam, which a proper stitch removes. The first picture shows plane sections of the input, the rounded carrier and the two shells (built on F+C and on the rounded carrier); the second zooms on the transition for two rounding radii.

shell6885_prototype.zip

On the other formulations you mention: an obstacle-constrained smooth surface (fix R, positionVertsSmoothly everything else, push vertices that violate the clearance onto the offset of F and iterate) does produce a transition with no ramp at all, but the naive active-set version tears the triangulation where F is steep; it would need soft constraints (positionVertsSmoothlySharpBd with vertStabilizers) to be robust. I would start with the weighted shell.

[netemadi9]

Thank you Fedr - I will give this a go!