Non-Manifold Meshes: Understanding Why Booleans Fail On Non-Watertight Models

Non-manifold geometry refers to meshes that contain irregularities that violate the mathematical definition of a 2-manifold. A 2-manifold mesh surface has well-defined inside and outside volumes with consistent face normals. Non-manifold meshes contain defects such as unmerged vertices, edges, disconnected surfaces and inconsistent face normals that cause problems for modeling operations like booleans.

What is Non-Manifold Geometry?

Manifold geometry follows two key mathematical rules:

The local neighborhood of any point on the surface resembles a flat 2D disc topologically. There are no irregularities or non 2-manifold features like holes or self intersections around any point.
The mesh encloses a volume with a defined inside and outside. All face normals point coherently outwards or inwards.

Models that violate these principles contain non-manifold geometry. The main non-manifold features are:

Table of Contents

Unmerged vertices – Two or more disconnected vertices in the same spatial location.
Unmerged edges – Vertex connected edges that should be a single edge.
Disconnected surfaces – Surfaces that do not share merged edges.
Inconsistent normals – Face normals that point incoherently instead of pointing uniformly inwards or outwards.

These defects produce meshes with irregular topology that modeling tools like booleans cannot interpret robustly. Fixing non-manifolds requires diagnosing the specific problems and merging elements or correcting normals until manifold topology is restored.

Causes of Non-Manifold Geometry

Non-manifold geometry arises from flaws in modeling process such as:

Unmerged Vertices

Unmerged vertices occur when vertex points occupy the same spatial location but remain disconnected in the mesh description. This can happen by:

Duplicating geometry in the same location without merging.
Boolean operations that fail to merge nearby vertices.
File import/export that loses connections between elements.
Modeling errors that accidentally disconnect elements.

Unmerged Edges

Unmerged edges arise when open vertex paths should logically be a single edge but remain disconnected, for example:

Boolean operations that fail to bridge nearby open edge paths.
Duplicated open paths that should be merged into one edge.
Disconnected edges from inserting cuts or holes.
File import/export errors that break logical connections.

Disconnected Faces

Disconnected surfaces occur when nearby surfaces fail to share merged edge connections. For example:

Boolean operations that leave fragmented surface pieces disconnected.
Inserted holes, cuts or extrusions that detach nearby surfaces.
File import errors that lose logical connections between surfaces.

Faces With Inconsistent Normals

Irregular face normals arise from flaws such as:

Boolean operations duplicating and flipping some normals.
Merging misaligned surface pieces into one mesh.
Mesh editing operations like extrudes, cuts, deletions etc. that distort normals.
Importing meshes with scrambled normals.

The Boolean Tool’s Requirement for Manifold Meshes

The boolean mesh operation relies on manifold input geometry to function correctly. It computes a topological intersection between meshes by considering face intersections. With non-manifold inputs containing irregular topology, the underlying intersection algorithms get confused and fail to robustly merge the models.

Typical failure cases include:

Self intersecting results with interior holes and gaps.
Fragmented disconnected surface pieces.
Unmerged duplicate vertices stacked together.
Flipped inconsistent normals mismatching surface directions.
Partial boolean results showing missing merged regions.

Diagnosing exactly why a boolean failed requires checking for non-manifold conditions. Each type of defect causes characteristic failure symptoms reflecting the underlying topology problem. A advanced repair approach targets the specific non-manifolds by merging elements and correcting normals until manifold topology is restored.

Fixing Non-Manifold Meshes

Producing a manifold mesh to enable robust booleans involves:

Finding non-manifold defects.
Fixing unmerged vertices.
Fixing unmerged edges.
Connecting disconnected surfaces.
Flipping inconsistent normals.

Specialized non-manifold diagnosing tools both identify defects and guide merges and corrections.

Finding Non-Manifolds

The first stage detects any non-manifolds at vertices, edges or faces. Pseudo-code for a sample diagnose procedure is:

Function diagnose_nonmanifolds(mesh):
    
    for each vertex v in mesh:
       
        if v connectivity > 2-manifold 
            -> Flag as non-manifold
                
        if v position matches other vertices 
            -> Flag as unmerged
             
    for each edge e in mesh:  
         
        if e vertex order flips 
            -> Flag as non-manifold
             
        if e overlaps unmerged with another edge 
            -> Flag as unmerged
         
    for each face f in mesh:
       
        if f normal != neighbor normals 
            -> Flag as non-manifold  
           
        if f shares no edges with a neighbor 
           -> Flag as disconnected
           
    return all non-manifold flagged elements

This isolates all vertices, edges and faces with non-manifold conditions to target fixes.

Merging Vertices

Unmerged vertices stacked in the same spatial location need welding into one vertex. This consolidates connectivity and converts all associated edges and faces to share the new unified vertex.

  
Function merge_vertices(unmerged_verts):
    
    // Create new vertex at average position 
    v_new = Vertex(average_position(unmerged_verts))
    
    // Update all topology elements... 
    for each vertex v in unmerged_verts: 
        
        for each edge e connected to v:
            replace v with v_new in e
             
        for each face f connected to v: 
            replace v with v_new in f
            
        remove v
        
    remove original unmerged vertices
    
    return mesh_with_merged_verts

This merges vertices while preserving surrounding mesh topology via connectivity updates.

Merging Edges

Unmerged open edge paths need consolidation into single logical edges. This stitches together endpoints and removes redundant edge segments.

  
Function merge_edges(unmerged_edges):
    
    for each edge pair (e1, e2) in unmerged_edges:
        
        // Merge endpoints  
        v_start = start_vert(e1) 
        v_end = end_vert(e2)
        
        new_edge = Edge(v_start, v_end)
        
        // Update connectivity
        for each face connected to e1 or e2:
            replace edge with new_edge
            
        remove e1
        remove e2
        
    return mesh

Updated connections extend the new path while deleting original segments until the mesh contains only merged edges.

Connecting Faces

Disconnected surfaces need connecting by bridging shared edge paths between neighboring boundary loops. This stitches surface pieces together by merging the edges between them.

Function connect_faces(disconnected_faces):
    
    for each face pair (f1, f2) in disconnected_faces: 
        
        e1 = get_shared_edge(f1)
        e2 = get_shared_edge(f2)
        
        new_edge = Edge(e1, e2)
        
        // Update connectivity
        replace e1 and e2 with new_edge
        
        // Merge faces  
        new_face = MergeFaces(f1, f2, new_edge)
        
    return mesh_with_merged_faces

Adding edges between nearby open boundary paths and merging into consolidated faces integrates disjointed surfaces into a continuous mesh.

Flipping Normals

Inconsistent face normal orientations need uniform coherent alignment. Detecting direction mismatches between neighboring faces indicates incorrect normals to flip.

Function orient_normals(mesh):
    
    // Compare norms between faces 
    for each face f in mesh:
        fn = get_norm(f)  
        for neighbor n of f:
           if fn != get_norm(n):
                f_flipnorms.add(f)
               
    // Align inconsistent normals            
    for each face f in f_flipnorms:
         
        reverse_normal(f)
         
    return mesh_with_fixed_normals

Flipping flipped normals makes all normals point coherently as the final step toward manifold topology.

Preventing Non-Manifold Geometry

A proactive modeling approach avoids introducing non-manifolds defects:

Modeling Best Practices

Analyze meshes after each modeling step
Stitch surfaces instead of leaving gaps
Merge elements instead of disconnecting
Orient normals during extrudes, cuts etc.
Minimize boolean use due to fragility

Applying careful mesh operations prevents most defects.

Using Mesh Analysis Tools

Interactive tools like:

Real-time validation – Color codes irregular elements during modeling.
AutomaticELEMENT merges – Snaps nearby elements into position.
Element selection and mass merge – Allows manually fixing flagged defects.
Normal orientation override – Specifies coherent directions.

Greatly simplify creating and maintaining good topology.

Conclusion – Creating Manifold Models for Successful Booleans

Non-manifold geometry disrupts the logical consistency and mathematical principles required for robust mesh booleans and other modeling operations. Straying outside the well defined rules of 2-manifold topology with unmerged elements, disconnected surfaces and irregular normals confuses intersection computations. Restoring proper merges and orientations fixes problematic models.

Learning to recognize, diagnose and resolve non-manifold defects empowers creating high quality models. Mastering both corrective troubleshooting and proactive prevention techniques leads to efficient workflows and reliable results.