Using Boolean Operations to Part a Mesh into Two

[nsmela]

Hi there,

I'm experiencing issues with the boolean operations and wanted some opinions on what I'm doing wrong.

The goal is to split a mesh (labeled "mould") into two meshes using a parting mesh (labeled "cutting mesh"). The process is:

• boolean subtract cutting from mould
• seperate the two resulting meshes and keep the largest one
• boolean subtract the largest mesh from the original mould
• result should be the smaller of the two

It's done this way because the cutting mesh has to be thick (2-3.0 mm) to properly generate resulting in a lot of lost volume.
The first step appears to be correct and it appears we can get the largest mesh, but the smallest mesh is a defective mesh.

Media:

Files:
cutting_mesh.zip
mould_mesh.zip

Mould Mesh:

Cutting Mesh:

Results of first boolean subtraction:

Results of Mould - Largest

Code: using C Sharp MR.DotNet

public static Result<CuttingMeshResults> PartModel(CuttingMeshResults results) {
        Mesh cutting = results.CuttingMesh;
        Mesh mould = results.Mould;

        try {
            BooleanResult split_meshes = Boolean(mould, cutting, BooleanOperation.DifferenceAB);
            MeshPart part = new MeshPart(split_meshes.mesh);

            var map = MeshComponents.GetAllComponentsMap(part, MeshComponents.FaceIncidence.PerEdge);

            if (map.NumComponents < 2) {
                return new MeshError($"Part Model failed: Cutting mesh did not generate two meshes.");
            }

            int numSmallerComponents;
            var largest_ids = GetLargestComponent(part, FaceIncidence.PerEdge, 0.1f, out numSmallerComponents);
            MeshPart largest = new MeshPart(split_meshes.mesh, largest_ids);

            BooleanResult smallest = Boolean(mould, largest.mesh, BooleanOperation.DifferenceAB);

            results.PositivePullMesh = new MeshModel(largest.mesh);
            results.NegativePullMesh = new MeshModel(smallest.mesh);
            
        }
        catch (Exception e) {
            return new MeshError($"Part Model failed: {e.Message}");
        }

        return results;
    }

[Grantim]

Hello @nsmela

The result mesh you are getting is actually expected for such pipeline, here is why:
in our boolean algorithm we use Simulation of Simplicity based on this paper which in general allows to resolve any kind of coplanar input by virtually shifting vertices. So when you for example subtract equivalent meshes you get valid zero volume mesh like this (one of the meshes gets virtual shift, so it has non-zero virtual volume, but real result does not have this shift):

Note that result mesh is closed and have zero volume.

This is exactly what you are facing when doing second subtraction.

It is highly recommended to avoid such operations (with equivalent/coincident surfaces), and eventually in most cases they are excessive and not needed.

---

As for your case: it seems like you do offset initial cutting mesh to make it thick, but instead you can just shift it in Y direction on on the offset value, and do only one boolean operation to get desired mesh.

If you still want to perform such kind of operation you can do it this way:

# (intersection)
Inter = Mould & Cutting
Smalls = (Mould - Cutting).keepAllButLargest()
# (union)
Result = Smalls + Inter

this way will produce visually correct result
-

but in transparent view you will still see SoS artifacts

---

Here I kept only one side of cutter, and performed intersection operation to obtain valid result
- -

You can see that in this case there no artifacts at all

[nsmela]

Thank you for the detailed answer!

As for your case: it seems like you do offset initial cutting mesh to make it thick, but instead you can just shift it in Y direction on on the offset value, and do only one boolean operation to get desired mesh.

Agreed, this would be easier. How would I do this?

[Grantim]

In my example I've removed all faces with normals looking away from Y direction, but it will be easier to use shifted cutter before offset.
Could you please provide details of cutter generation pipeline so we suggest reasonable way to prepare it.

For example you can use boolean rigidB2A parameter to provide shift of cutter directly into boolean operation like this:
BooleanParameters.rigidB2A = new AffineXf3f( new Vector3f(0.0f,shift,0.0f) )

[nsmela]

Absolutely. We start with the original mesh and an int[] array of vertices ids that represent the path going around that mesh. Each id is used to make a Vertex object, which stores the Vertex Id, 3d position, 3d normal, and 3d direction from the previous point in the path. For the normal, we set y = 0 and normalize.

To generate the outer path contour, we add the normal * distance to the position. After all points are repositioned, we check if the direction from the previous position had flipped (moved too far and is now defective). If so, we remove that point.

The two paths are then stitched together. We have a super-simple stitching algorythm that stitches based on the smallest angle triangle it can make at each step. This generates a shell that we then extrude out and then offset to clean up the mesh defects.

This is all done in geometry3sharp as we're more familiar with the library. We've been wanting to switch to MeshLib, but we're not as familiar with the terminology or best-practices for it yet.

EDIT:

This is what we've tried:

    internal static Result<MeshModel[]> BooleanSplit(Mesh body, Mesh tool, float gap_distance) {
        try {
            BooleanParameters parameters = new() {
                rigidB2A = new AffineXf3f(new MR.DotNet.Vector3f(0, gap_distance, 0))
            };

            var result = Boolean(body, tool, BooleanOperation.DifferenceAB, parameters);
            MeshModel[] meshes = [new MeshModel((Mesh)result.mesh)];
            return meshes;
}

MeshModel is a wrapper class, meant to convert from MeshGeometry3D, DMesh3 (Geometry3Sharp), and MR.Dotnet.Mesh.

Cutting Mesh is essetially now a fan of triangles:

Placement compared to mould:

Result:

This is great, but we need the second part as well. Did I do something wrong?

[Grantim]

Looks like it worked, for other part you can do one more boolean with inital mesh:

    internal static Result<MeshModel[]> BooleanSplit(Mesh body, Mesh tool, float gap_distance) {
        try {
            BooleanParameters parameters = new() {
                rigidB2A = new AffineXf3f(new MR.DotNet.Vector3f(0, gap_distance, 0))
            };

            var resultA = Boolean(body, tool, BooleanOperation.DifferenceAB, parameters);

            parameters.rigidB2A = new AffineXf3f(new MR.DotNet.Vector3f(0, -gap_distance, 0)); // shift in opposite direction if needed
            var resultB = Boolean(body, tool, BooleanOperation.Intersection, parameters);
            MeshModel[] meshes = [new MeshModel((Mesh)resultA.mesh), new MeshModel((Mesh)resultB.mesh)];
            return meshes;
}

[nsmela]

Correct, exactly what we were looking for:

Thank you!

[Grantim]

We've been wanting to switch to MeshLib, but we're not as familiar with the terminology or best-practices for it yet.

I see, unfortunately c# bindings does not have full meshlib functionality yet, but in c++ such triangle fan could be done like this:

Mesh mesh;
mesh.addSeparateContours( {initContour} ); // add edge loop in mesh representing initial ring
auto newLoop = makeDegenerateBandAroundHole(mesh, EdgeId(0)); // create degenerate triangle fan around initial ring
for ( int i=0; i < newLoop.size(); ++i )
    mesh.points[mesh.topology.org(newLoop[i])] = initContour[i] + initContourNormal[i] * extensionAmount; // extend degenerated fan to desired size

[nsmela]

Good to hear. When my current project dies down, I'll see if I can help expose a few more of the functions including this one.

[nsmela]

To follow up, we're expanding this function to split meshes with a 'tunnel' inside them (like a torus or donut mesh). We're encountering boolean operation errors again and not sure what is the culprit.

The original mesh before offsetting to create the mould.

Parting mesh and mould (mould = original.Offset() - original)

Parting mesh alone

After the boolean operations mentioned above, the internal areas seem to have their normals inverted.

This might work, but we want to perform this on boxy moulds, not a simple offset mesh.

When using the proper mould shape:

Ensured the cutting mesh entirely covers the mould. Pretty sure the cutting mesh has no holes (aside from the borders).

This shows the mesh can fold back onto itself in the y direction, which is what I suspect is the issue:

Is that what be causing it? I'm not familiar with the rigidB2A parameter and what it does.