mesh boolean difference - works until it does not

[petrasvestartas]

Issues with multiple times applying in invalid meshes. I know you did some new developments in cgal. Can you suggest any solutions? These issues remains for many years with our compas cgal binding.

It would be really nice that the mesh booleans would be more robust for more than a few boolean difference runs due to triangulations.

Issue Details

The issue is that the more booleans I do the more detailed mesh becomes and at one point it just crashes.
In "real life" I am trying to cut out drilled screws from a piece of block.

Source Code

std::tuple<compas::RowMatrixXd, compas::RowMatrixXi>
pmp_boolean_difference(
    Eigen::Ref<const compas::RowMatrixXd> vertices_a,
    Eigen::Ref<const compas::RowMatrixXi> faces_a,
    Eigen::Ref<const compas::RowMatrixXd> vertices_b,
    Eigen::Ref<const compas::RowMatrixXi> faces_b)
{
    compas::Mesh mesh_a = compas::mesh_from_vertices_and_faces(vertices_a, faces_a);
    compas::Mesh mesh_b = compas::mesh_from_vertices_and_faces(vertices_b, faces_b);
    compas::Mesh mesh_out;

    CGAL::Polygon_mesh_processing::corefine_and_compute_difference(mesh_a, mesh_b, mesh_out);

    std::tuple<compas::RowMatrixXd, compas::RowMatrixXi> result = compas::mesh_to_vertices_and_faces(mesh_out);
    return result;
};

Environment

Ubuntu, mac and windows

This booleand difference fails.

mesh.zip

[MaelRL]

One of the CC is not triangulated, maybe it creates some issue in your pipeline?

Otherwise after extracting each CC and triangulating the screw and running:

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Surface_mesh.h>

#include <CGAL/Polygon_mesh_processing/corefinement.h>
#include <CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h>

#include <iostream>
#include <string>

typedef CGAL::Exact_predicates_inexact_constructions_kernel   K;
typedef CGAL::Surface_mesh<K::Point_3>                        Mesh;

namespace PMP = CGAL::Polygon_mesh_processing;

int main(int argc, char* argv[])
{
  const std::string filename1 = (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/blobby.off");
  const std::string filename2 = (argc > 2) ? argv[2] : CGAL::data_file_path("meshes/eight.off");

  Mesh mesh1, mesh2;
  if(!PMP::IO::read_polygon_mesh(filename1, mesh1) || !PMP::IO::read_polygon_mesh(filename2, mesh2))
  {
    std::cerr << "Invalid input." << std::endl;
    return 1;
  }

  Mesh out;
  bool valid_diff = PMP::corefine_and_compute_difference(mesh1,mesh2, out);

  if(valid_diff)
  {
    std::cout << "Diff was successfully computed\n";
    CGAL::IO::write_polygon_mesh("diff.off", out, CGAL::parameters::stream_precision(17));
    return 0;
  }

  std::cout << "Difference could not be computed\n";

  return 1;
}

I get the expect result:

Could you give a bit more code to try and reproduce?