Booleans are precision sensitive

[zalo]

@elalish 's request here: #669 (comment)

The results of Boolean Ops can differ depending on small differences in precision.

Here's a simple test with two cube manifolds unioned together by "exactly" touching faces:

cube      = Manifold.cube ([0.0999, 0.0999, 0.0999])
near_cube = cube.translate([0.0999 *  1, 0.0, 0.0]) + cube.translate([0.0999 *  2, 0.0, 0.0])
far_cube  = cube.translate([0.0999 * 50, 0.0, 0.0]) + cube.translate([0.0999 * 51, 0.0, 0.0]) # Should be the same, but further away
print("Near Cube Genus:", near_cube.genus(), ", Far Cube Genus:", far_cube.genus())

Near Cube Genus: 0, Far Cube Genus: -1

These problems exacerbate as faces rotate, extrude, dilate, etc. as seen in the Offset PRs and related BatchBoolean-based modelling.

I believe this is separate from the order-dependency/non-determinism bug...

[elalish]

This is working as intended - I don't think 0.0999 * 51 is exactly representable in binary floating point, so you are creating rounding errors that cause the first to have identical verts and the second to not quite, so there's nothing our symbolic perturbation can do. We can only fix these marginal cases when the input verts are actually identical.

What I was asking for is simplified cases that return shard manifolds when the verts are identical (hence my use of Warp), and especially cases that generate overlapping polygons, which the triangulator then chokes on.

[zalo]

Given that the Minkowski Sums are formed from Hulls (which lose all the symbolic perturbation information?), is there some way to synthetically reintroduce that back into the system?

Hrm, I suppose there shouldn’t be non-identical verts with that, but I have a suspicion that Hull moves the points around a bit… I’ll investigate that a bit later…

[elalish]

It would be interesting if Hull moves the verts at all. Symbolic perturbation isn't really information to be lost - it just means that when verts have floating-point equal X, Y, or Z values, we break the tie by looking at the direction of the normals of one of the two input objects to decide which one is one which side of the other. The Boolean op itself uses the input float coordinates as though they are exact and doesn't use our precision at all, hence its robustness.