Issue: localFixSelfIntersections does not fully resolve self-intersections and alters geometry

[JEELGANDHI21]

Description

When using mrmeshpy.localFixSelfIntersections() with CutAndFill method, the function does not completely resolve all self-intersections. Additionally, it modifies the mesh geometry (face count changes and residual artifacts remain), which is undesirable for precision-sensitive workflows like 3D printing.

Steps to Reproduce

Load an STL mesh
Run:
findSelfCollidingTrianglesBS
localFixSelfIntersections with CutAndFill
Re-run self-intersection detection and compare mesh statistics

settings = mrmeshpy.SelfIntersections.Settings()
settings.method = mrmeshpy.SelfIntersections.Settings.Method.CutAndFill
settings.maxExpand = 1
settings.touchIsIntersection = False
mrmeshpy.localFixSelfIntersections(mesh, settings)

Observed Behavior
Self-intersections are only partially resolved:
Before: 389
After: 74 remaining
Geometry is modified:
Faces reduced from 79276 → 79216
Zero-area faces still remain (51 → 44)

Mesh still has:
Multiple connected components (12)
Residual degeneracies

Original File

After Repairing Self Intersection

Also tried to repair using Python Script available in Repository
There is a visible geometry change.

Possible Improvement Suggestions

• Provide a stricter mode for full self-intersection resolution
• Add controls to limit geometry deviation
• Improve handling of dense/self-overlapping regions
• Provide diagnostics on why some intersections remain

[Grantim]

Hi, thanks for the detailed report.

A few notes:

Local repair has inherent limits. localFixSelfIntersections (including CutAndFill) targets self-intersections region-by-region, and different types of intersections have very different complexity — isolated pairs are easy, but densely tangled or stacked overlaps often can't all be resolved locally without global topology changes. That's why you're seeing residual intersections and some collateral effects on face count / zero-area faces / component count. We don't currently guarantee that a single pass eliminates every intersection, and tightening maxExpand / touchIsIntersection only goes so far before the local changes start conflicting with each other.

Try the rebuild (voxel remesh) pipeline for a guaranteed clean output. If your downstream use requires zero self-intersections, the most reliable route in MeshLib is rebuildMesh, which voxelizes the mesh and reconstructs an iso-surface. It's effectively guaranteed to produce a watertight, self-intersection-free result. The tradeoff is that voxelization smooths sharp edges and thin features depending on the voxel size you choose — so it's a quality/robustness knob you can tune.

Worth noting for your 3D-printing use case: the `voxelSize` parameter can reasonably be matched to your printer's resolution. Any detail finer than what the printer can physically reproduce will be lost in printing anyway, so choosing `voxelSize` near the printer's effective resolution often gives you a clean, manifold mesh without sacrificing anything the final print would have preserved.

A ready-to-use wrapper is here:
https://github.com/MeshInspector/MeshLib/blob/master/python_scripts/mesh_rebuild.py

It calls `mrmeshpy.rebuildMesh` with `RebuildMeshSettings` (voxel size, optional CUDA `FastWindingNumber`, optional decimation).

Could you share the mesh? If you can attach the input that produced this result, we'd like to look at it. Concrete cases help us (a) see whether the local-repair algorithm can be improved for your kind of geometry, and (b) recommend a tuned pipeline (e.g. rebuild + targeted decimation, or a hybrid) that preserves fidelity where it matters for your workflow.

Thanks!

[JEELGANDHI21]

Hello, thanks for looking into this issue.

As requested, I’ve attached the input file. I also tried using RebuildMesh, but my geometry is quite densely tangled. I’m working with other files as well, including models with human body structures and ornaments. Rebuilding the mesh tends to overly smooth the geometry, which is not acceptable for my next steps.

To address self-intersections, I experimented with the following approach that dynamically expands rings:

def fix_self_intersections(mesh: mrmeshpy.Mesh,
                            max_iterations: int = 20) -> bool:
    expand_rings  = 1
    prev_si_count = None
    stuck_count   = 0

    for iteration in range(max_iterations):
        mp       = mrmeshpy.MeshPart(mesh)
        si_bs    = mrmeshpy.findSelfCollidingTrianglesBS(mp, touchIsIntersection=False)
        si_count = si_bs.count()

        if si_count == 0:
            if iteration == 0:
                print("  No self-intersections found.")
            else:
                print(f"  Converged after {iteration} iteration(s). SI=0.")
            return True

        # Stuck detection: SI not going down
        if prev_si_count is not None and si_count >= prev_si_count:
            stuck_count += 1
            if stuck_count >= 2:
                expand_rings = min(expand_rings + 1, 6)
                stuck_count  = 0
                print(f"  Stuck at SI={si_count}, widening to {expand_rings} rings")
        else:
            stuck_count = 0
        prev_si_count = si_count

        # Delete SI region + N rings
        region = si_bs
        for _ in range(expand_rings):
            region = mrmeshpy.expandFaces(mesh.topology, region)
        mesh.deleteFaces(region)

        # Fill with escalating metric
        for e in mesh.topology.findHoleRepresentiveEdges():
            params          = mrmeshpy.FillHoleParams()
            params.smoothBd = True
            if expand_rings <= 2:
                params.metric = mrmeshpy.getUniversalMetric(mesh)
            elif expand_rings <= 4:
                params.metric = mrmeshpy.getComplexFillMetric(mesh, e)
            else:
                params.metric = mrmeshpy.getPlaneFillMetric(mesh, e)
            mrmeshpy.fillHole(mesh, e, params)

        mp2       = mrmeshpy.MeshPart(mesh)
        remaining = mrmeshpy.findSelfCollidingTrianglesBS(
            mp2, touchIsIntersection=False).count()
        print(f"  Iter {iteration + 1} (expand={expand_rings} rings): "
              f"{si_count} SI -> {remaining} remaining")

    mp_f  = mrmeshpy.MeshPart(mesh)
    final = mrmeshpy.findSelfCollidingTrianglesBS(mp_f, touchIsIntersection=False).count()
    if final > 0:
        print(f"  Max iterations ({max_iterations}) reached. {final} SI remain.")
    return final == 0

Same for the remove Degenerate Faces using degen = mrmeshpy.findDegenerateFaces(mp, 1e6) and delete that faces using mesh.deleteFaces(degen) and to fill used escalating metrics mentioned below:

for e in mesh.topology.findHoleRepresentiveEdges():
            params          = mrmeshpy.FillHoleParams()
            params.smoothBd = True
            if metrics_tried == 0:
                # Best quality: balances curvature + triangle quality
                params.metric = mrmeshpy.getUniversalMetric(mesh)
            else:
                # Fallback: minimizes circumcircle radii -> fewer needle triangles
                params.metric = mrmeshpy.getCircumscribedMetric(mesh)
            mrmeshpy.fillHole(mesh, e, params)

For hole fixing, I’m currently using mesh.topology.findHoleRepresentiveEdges() and iterating over those edges to fill holes with:

params = mrmeshpy.FillHoleParams()
params.metric = mrmeshpy.getUniversalMetric(mesh)
params.smoothBd = True
mrmeshpy.fillHole(mesh, e, params)

However, this approach hasn’t fully resolved the issue in my case. I’d appreciate any suggestions or recommended workflows for handling such dense and detailed geometries without losing important features.

STL.zip

[Grantim]

Thanks for providing the data. Unfortunately, I could not find any reliable pattern to fix self-intersections locally.
It seems that the only robust way in this case is to rebuild, have you tried lowering voxel size? Smaller voxel size will preserve more details but will take more time to compute.

I've managed to get such mesh with 0.1 voxel size
Main.zip