Boolean operation problem after mesh was decimated

[gecpgecp]

Thank you to the meshlib team for their outstanding work and help.

I have a mesh (meshA) extracted from CT voxels using the marchingcube algorithm. After performing the MR::decimateMesh operation on this data, I performed the MR::BooleanOperation::Intersection operation on a conic data set (meshCone). I found that without decimateMesh, the boolean operation always succeeds, but after decimateMesh, it sometimes succeeds and sometimes fails. The success or failure is related to the setting value of decimSetting.maxError. This relationship has no fixed pattern. For example, setting maxError to 0.01 will cause it to fail, while setting it to 0.1 or 0.001 may both succeed.

the fail message is :

Cannot separate mesh B to inside and outside parts, probably contours on mesh B are not closed or are not consistent.

the code as follow:

#include "MRMesh/MRTorus.h"
#include "MRMesh/MRMesh.h"
#include "MRMesh/MRParallelFor.h"
#include "myWeightedPointsShell.h"
#include "MRVoxels/MROffset.h"
#include "MRMesh/MRMeshSave.h"
#include "MRMesh/MRMeshLoad.h"
#include "MRMesh/MRMakeSphereMesh.h"
#include <iostream>
#include <MRMesh/MRMeshDecimate.h>
#include <MRMesh/MRBuffer.h>
#include <MRMesh/MRMeshBuilder.h>
#include <MRMesh/MRFixSelfIntersections.h>
#include <MRMesh/MRMeshBoolean.h>
#include <MRMesh/MRMeshDecimate.h>
#include <MRMesh/MRMeshFillHole.h>
using namespace MR;
using namespace MR::WeightedShell;

int main()
{
   
    // Create some mesh
    MeshLoadSettings loadSetting;
    loadSetting.callback = [](float pro)->bool {
        std::cout << "load pro:" << pro * 100 << std::endl;
        return true;
        };
    auto meshARes = MR::MeshLoad::fromAnySupportedFormat("d:/2.stl",loadSetting);
    Mesh& meshA = *meshARes;

    MR::DecimateSettings decimSetting;
    decimSetting.maxError = 0.05;
    MR::decimateMesh(meshA, decimSetting);

 
    std::cout << "A colosed:" << meshA.topology.isClosed() << std::endl;
    auto meshReadResCone = MR::MeshLoad::fromAnySupportedFormat("d:/cone.ply");
    Mesh& meshCone = *meshReadResCone;

    BooleanParameters boolParam;
    boolParam.cb  = [](float pro)->bool {
        std::cout << "bool pro:" << pro * 100 << std::endl;
        return true;
        };
    MR::BooleanResult result = MR::boolean(meshA, meshCone, MR::BooleanOperation::Intersection,boolParam);
    if (!result.valid()) {
        std::cerr << result.errorString << std::endl;
        system("pause");
    }
      
    MR::Mesh &resultMesh = *result;
    MR::MeshSave::toAnySupportedFormat(resultMesh, "d:/r.ply");
    std::cout << "is bool result closed:" << resultMesh.topology.isClosed() << std::endl;

    system("pause");
    return 0;
}

[Grantim]

Hello!

"Cannot separate mesh B to inside and outside parts, probably contours on mesh B are not closed or are not consistent." this error could mean that either mesh A is open or it is not solid (it has inconsistent components orientation).

But it is hard to find the reason without input data, could you please provide the meshes?

[gecpgecp]

My original mesh, meshA, is a 200MB file, which I cannot upload. When I tried to generate smaller data points by reducing the resolution of the original voxel data and sent it to you for testing, I found that the smaller data points did not have this problem. Both the original mesh and the mesh after decimateMesh could perform boolean calculations normally.

meshA is a mesh from voxel by marchingcube method and meshCone is a standard cylinder mesh, the all are closed mesh.

[Grantim]

Could you share it using cloud storage? (If you don't want to share data publicly you can send the link to our email support@meshinspector.com)

[gecpgecp]

Thank you very much for your prompt reply. I have compressed and uploaded the data to Google Drive.
the mesh data link as follow: https://drive.google.com/file/d/19c485h9ltM_ikxIb9NhgY-V4SMDaahpk/view?usp=sharing

the code as follow:
If I set decimSetting.maxError to 0.2 or 0.005, the boolean operation succeeds; if I set decimSetting.maxError to 0.01, the boolean operation fails. Is there a good way to ensure that the decimate operation always succeeds?

#include "MRMesh/MRTorus.h"
#include "MRMesh/MRMesh.h"
#include "MRMesh/MRParallelFor.h"
#include "myWeightedPointsShell.h"
#include "MRVoxels/MROffset.h"
#include "MRMesh/MRMeshSave.h"
#include "MRMesh/MRMeshLoad.h"
#include "MRMesh/MRMakeSphereMesh.h"
#include <iostream>
#include <MRMesh/MRMeshDecimate.h>
#include <MRMesh/MRBuffer.h>
#include <MRMesh/MRMeshBuilder.h>
#include <MRMesh/MRFixSelfIntersections.h>
#include <MRMesh/MRMeshBoolean.h>
#include <MRMesh/MRMeshDecimate.h>
#include <MRMesh/MRMeshFillHole.h>
using namespace MR;
using namespace MR::WeightedShell;

int main()
{
   
    // Create some mesh
    MeshLoadSettings loadSetting;
    loadSetting.callback = [](float pro)->bool {
        std::cout << "load pro:" << pro * 100 << std::endl;
        return true;
        };
    auto meshARes = MR::MeshLoad::fromAnySupportedFormat("d:/meshA.ply",loadSetting);
    Mesh& meshA = *meshARes;
    
    MR::DecimateSettings decimSetting;
    decimSetting.progressCallback = [](float pro)->bool {
        std::cout << "decim pro:" << pro * 100 << std::endl;
        return true;
        };
    decimSetting.maxError = 0.01;
    MR::decimateMesh(meshA, decimSetting);

    MR::MeshSave::toAnySupportedFormat(meshA, "d:/meshA_dicim.ply");

 
    std::cout << "A colosed:" << meshA.topology.isClosed() << std::endl;
    auto meshReadResCone = MR::MeshLoad::fromAnySupportedFormat("d:/cone.ply");
    Mesh& meshCone = *meshReadResCone;

    BooleanParameters boolParam;
    boolParam.cb  = [](float pro)->bool {
        std::cout << "bool pro:" << pro * 100 << std::endl;
        return true;
        };
    MR::BooleanResult result = MR::boolean(meshA, meshCone, MR::BooleanOperation::Intersection,boolParam);
    if (!result.valid()) {
        std::cerr << result.errorString << std::endl;
        system("pause");
    }
      
    MR::Mesh &resultMesh = *result;
    MR::MeshSave::toAnySupportedFormat(resultMesh, "d:/r.ply");
    std::cout << "is bool result closed:" << resultMesh.topology.isClosed() << std::endl;

    system("pause");
    return 0;
}

[Grantim]

Thanks for the data, now it's clear that the issue is related to small degenerated components that stayed after decimation. They could appear in intersection area and spoil boolean result.

I suggest that you can call something like this before or after decimation to prevent this issue:

    meshA.deleteFaces( mesh.topology.getValidFaces() - MeshComponents::getLargeByAreaComponents( meshA, meshA.area() * 0.002f, nullptr ) );

it will remove small components, so the issue should not appear.

---

Please also note, that while meshA has quite complex shape with close surfaces - self-intersections might appear after decimation, and if they will appear in the area of boolean intersection they also might lead to boolean fails.
While initial mesh is result of marching cubes algorithm it is guaranteed to be clean, so I suggest that more robust way of processing is to perform boolean first and than decimate.

[gecpgecp]

Thank you for your answer. So far, your suggestion to delete connected components with smaller areas seems to be effective for my data.