Find self-intersecting triangles of single mesh

Following code presents example of finding self-intersecting triangles of single mesh

• C++

  #include "MRMesh/MRTorus.h"
  #include "MRMesh/MRMesh.h"
  #include "MRMesh/MRMatrix3.h"
  #include "MRMesh/MRAffineXf.h"
  #include "MRMesh/MRMeshCollide.h"
  #include <iostream>
   
  int main()
  {
      auto mesh = MR::makeTorusWithSelfIntersections(); // make torus with self-intersections
   
      auto selfCollidingParis = MR::findSelfCollidingTriangles( mesh ); // find self-intersecting faces pairs
      if ( !selfCollidingParis.has_value() )
      {
          // check error
          std::cerr << selfCollidingParis.error();
          return 1;
      }
      for ( auto [fl, fr] : *selfCollidingParis )
          std::cout << int( fl ) << " " << int( fr ) << "\n"; // print each pair
   
      auto selfCollidingBitSet = MR::findSelfCollidingTrianglesBS( mesh ); // find bitset of self-intersecting faces
      if ( !selfCollidingBitSet.has_value() )
      {
          // check error
          std::cerr << selfCollidingBitSet.error();
          return 1;
      }
      std::cout << selfCollidingBitSet->count() << "\n"; // print number of self-intersecting faces
   
      auto isSelfColliding = MR::findSelfCollidingTriangles( mesh, nullptr ); // fast check if mesh has self-intersections
      if ( !isSelfColliding.has_value() )
      {
          // check error
          std::cerr << isSelfColliding.error();
          return 1;
      }
      std::cout << *isSelfColliding << "\n";
      return 0;
  }

• Python

  from meshlib import mrmeshpy as mm
   
  mesh = mm.makeTorusWithSelfIntersections() # make torus with self-intersections
   
  selfCollidingParis = mm.findSelfCollidingTriangles(mesh) # find self-intersecting faces pairs
  for fp in selfCollidingParis:
      print(fp.aFace,fp.bFace) # print each pair
   
  selfCollidingBitSet = mm.findSelfCollidingTrianglesBS(mesh) # find bitset of self-intersecting faces
  print(selfCollidingBitSet.count()) # print number of self-intersecting faces
   
  isSelfColliding = mm.findSelfCollidingTriangles(mesh,None) # fast check if mesh has self-intersections
  print(isSelfColliding)

• C

  #include "MRCMesh/MRTorus.h"
  #include "MRCMesh/MRMesh.h"
  #include "MRCMesh/MRMeshPart.h"
  #include "MRCMesh/MRMeshCollide.h"
  #include "MRCMesh/MRBitSet.h"
  #include "MRCMesh/MRFaceFace.h"
  #include <MRCMisc/std_string.h>
  #include <MRCMisc/expected_std_vector_MR_FaceFace_std_string.h>
  #include <MRCMisc/expected_MR_FaceBitSet_std_string.h>
  #include <MRCMisc/expected_bool_std_string.h>
  #include <MRCMisc/std_vector_MR_FaceFace.h>
   
  #include <inttypes.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  int main( void )
  {
      int rc = EXIT_FAILURE;
   
      // make torus with self-intersections
      MR_Mesh* mesh = MR_makeTorusWithSelfIntersections( NULL, NULL, NULL, NULL, NULL );
      MR_MeshPart* mp = MR_MeshPart_Construct( mesh, NULL );
   
      // find self-intersecting faces pairs
      MR_expected_std_vector_MR_FaceFace_std_string* selfCollidingPairsRes = MR_findSelfCollidingTriangles_4( mp, MR_PassBy_DefaultArgument, NULL, NULL, NULL );
      MR_std_vector_MR_FaceFace* selfCollidingPairs = MR_expected_std_vector_MR_FaceFace_std_string_value_mut( selfCollidingPairsRes );
      if ( !selfCollidingPairs )
      {
          // check error
          fprintf( stderr, "%s\n", MR_std_string_data( MR_expected_std_vector_MR_FaceFace_std_string_error( selfCollidingPairsRes ) ) );
          goto fail_self_collision_pairs;
      }
   
      for ( MR_uint64_t i = 0; i < MR_std_vector_MR_FaceFace_size( selfCollidingPairs ); ++i )
      {
          const MR_FaceFace* ff = MR_std_vector_MR_FaceFace_at( selfCollidingPairs, i );
          // print each pair
          fprintf( stdout, "%d %d\n", MR_FaceFace_Get_aFace( ff )->id_, MR_FaceFace_Get_bFace( ff )->id_ );
      }
   
      // find bitset of self-intersecting faces
      MR_expected_MR_FaceBitSet_std_string* selfCollidingBitSetRes = MR_findSelfCollidingTrianglesBS( mp, MR_PassBy_DefaultArgument, NULL, NULL, NULL );
      MR_FaceBitSet* selfCollidingBitSet = MR_expected_MR_FaceBitSet_std_string_value_mut( selfCollidingBitSetRes );
      if ( !selfCollidingBitSet )
      {
          // check error
          fprintf( stderr, "%s\n", MR_std_string_data( MR_expected_MR_FaceBitSet_std_string_error( selfCollidingBitSetRes ) ) );
          goto fail_self_collision_bs;
      }
      // print number of self-intersecting faces
      fprintf( stdout, "%" PRIu64 "\n", MR_BitSet_count( MR_FaceBitSet_UpcastTo_MR_BitSet( selfCollidingBitSet ) ) );
   
      // fast check if mesh has self-intersections
      MR_expected_bool_std_string* isSelfCollidingRes = MR_findSelfCollidingTriangles_5( mp, NULL, MR_PassBy_DefaultArgument, NULL, NULL, NULL );
      bool* isSelfColliding = MR_expected_bool_std_string_value_mut( isSelfCollidingRes );
      if ( !isSelfColliding )
      {
          // check error
          fprintf( stderr, "%s\n", MR_std_string_data( MR_expected_bool_std_string_error( isSelfCollidingRes ) ) );
          goto fail_self_collision_fast;
      }
      // print number of self-intersecting faces
      fprintf( stdout, "%d\n", *isSelfColliding );
   
      rc = EXIT_SUCCESS;
  fail_self_collision_fast:
      MR_expected_bool_std_string_Destroy( isSelfCollidingRes );
  fail_self_collision_bs:
      MR_expected_MR_FaceBitSet_std_string_Destroy( selfCollidingBitSetRes );
  fail_self_collision_pairs:
      MR_expected_std_vector_MR_FaceFace_std_string_Destroy( selfCollidingPairsRes );
      MR_MeshPart_Destroy( mp );
      MR_Mesh_Destroy( mesh );
      return rc;
  }

• C#

  using static MR;
   
  public class CollisionSelf
  {
      public static void Run(string[] args)
      {
          var mesh = new MeshPart(MR.makeTorusWithSelfIntersections());
   
          Console.WriteLine(" --- Beginning Colliding Self Test! --- ");
          // find self-intersecting faces pairs
          var selfCollidingPairs = findSelfCollidingTriangles(mesh);
   
          FaceFace pair; // more efficient to declare outside loop
          for (ulong i = 0; i < selfCollidingPairs.size(); i++)
          {
              pair = selfCollidingPairs[i];
              Console.WriteLine($"FaceA: {pair.aFace.id} FaceB: {pair.bFace.id}"); // print each pair
          }
   
          // find bitset of self-intersecting faces
          var selfCollidingBitSet = MR.findSelfCollidingTrianglesBS(mesh);
          Console.WriteLine($"{selfCollidingBitSet.count()} faces self-intersecting");
   
          // fast check if mesh has self-intersections
          var isSelfColliding = MR.findSelfCollidingTriangles(mesh, outCollidingPairs: null);
          Console.WriteLine($"Is self colliding: {isSelfColliding}");
      }
   
  }