Precise detect collisions of two meshes

Following code presents example of finding preceise collision triangles and edges of two meshes

• C++

  #include "MRMesh/MRMakeSphereMesh.h"
  #include "MRMesh/MRMesh.h"
  #include "MRMesh/MRMatrix3.h"
  #include "MRMesh/MRAffineXf.h"
  #include "MRMesh/MRMeshCollidePrecise.h"
  #include <iostream>
   
  int main()
  {
      auto meshA = MR::makeUVSphere(); // make mesh A
      auto meshB = MR::makeUVSphere(); // make mesh B
      meshB.transform( MR::AffineXf3f::translation( MR::Vector3f( 0.1f, 0.1f, 0.1f ) ) ); // shift mesh B for better demonstration
   
      auto converters = MR::getVectorConverters( meshA, meshB ); // create converters to integer field (needed for absolute precision predicates)
      auto collidingFaceEdges = MR::findCollidingEdgeTrisPrecise( meshA, meshB, converters.toInt ); // find each intersecting edge/triangle pair 
      // print pairs of edges triangles
      for ( const auto& vet : collidingFaceEdges )
      {
          if ( vet.isEdgeATriB() )
              std::cout << "edgeA: " << int( vet.edge ) << ", triB: " << vet.tri().get() << "\n";
          else
              std::cout << "triA: " << vet.tri().get() << ", edgeB: " << int( vet.edge ) << "\n";
      }
      return 0;
  }

• Python

  from meshlib import mrmeshpy as mm
   
  meshA = mm.makeUVSphere() # make mesh A
  meshB = mm.makeUVSphere() # make mesh B
  meshB.transform(mm.AffineXf3f.translation(mm.Vector3f(0.1,0.1,0.1))) # shift mesh B for better demonstration
   
  converters = mm.getVectorConverters(meshA,meshB) # create converters to integer field (needed for absolute precision predicates)
  collidingFaceEdges = mm.findCollidingEdgeTrisPrecise(meshA,meshB,converters.toInt) # find each intersecting edge/triangle pair 
  # print pairs of edges tirangles
  for vet in collidingFaceEdges:
      if vet.isEdgeATriB():
          print("edgeA:",vet.edge.get(),"triB:",vet.tri().get())
      else:
          print("triA:",vet.tri().get(),"edgeB:",vet.edge.get())

• C

  #include "MRCMesh/MRMakeSphereMesh.h"
  #include "MRCMesh/MRAffineXf.h"
  #include "MRCMesh/MRMesh.h"
  #include "MRCMesh/MRMeshPart.h"
  #include "MRCMesh/MRMeshCollidePrecise.h"
  #include "MRCMesh/MRPrecisePredicates3.h"
  #include "MRCMesh/MRBitSet.h"
  #include <MRCMisc/std_vector_MR_VarEdgeTri.h>
  #include <MRCMisc/std_string.h>
   
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  int main( void )
  {
      int rc = EXIT_FAILURE;
   
      MR_Mesh* meshA = MR_makeUVSphere( NULL, NULL, NULL ); // make mesh A
      MR_Mesh* meshB = MR_makeUVSphere( NULL, NULL, NULL ); // make mesh B
      MR_Vector3f shift = MR_Vector3f_Construct_3( 0.1f, 0.1f, 0.1f );
      MR_AffineXf3f xf = MR_AffineXf3f_translation( &shift );
      MR_Mesh_transform( meshB, &xf, NULL ); // shift mesh B for better demonstration
   
      MR_MeshPart* mpA = MR_MeshPart_Construct( meshA, NULL );
      MR_MeshPart* mpB = MR_MeshPart_Construct( meshB, NULL );
   
      // create converters to integer field (needed for absolute precision predicates)
      MR_CoordinateConverters* converters = MR_getVectorConverters_3( mpA, mpB, NULL );
      // find each intersecting edge/triangle pair
      MR_std_vector_MR_VarEdgeTri* collidingFaceEdges = MR_findCollidingEdgeTrisPrecise_5(
          mpA, mpB, MR_PassBy_Copy, MR_CoordinateConverters_GetMutable_toInt( converters ), NULL, NULL );
   
      // print pairs of edges triangles
      for ( MR_uint64_t i = 0; i < MR_std_vector_MR_VarEdgeTri_size( collidingFaceEdges ); ++i )
      {
          MR_VarEdgeTri* edgeTri = MR_std_vector_MR_VarEdgeTri_at_mut( collidingFaceEdges, i );
          bool edgeATriB = MR_VarEdgeTri_isEdgeATriB( edgeTri );
          MR_FaceId tri = MR_VarEdgeTri_tri( edgeTri );
          if ( edgeATriB )
              fprintf( stdout, "edgeA: %d, triB: %d\n", *MR_EdgeId_get( MR_VarEdgeTri_GetMutable_edge( edgeTri ) ), *MR_FaceId_get( &tri ) );
          else
              fprintf( stdout, "triA: %d, edgeB: %d\n", *MR_FaceId_get( &tri ), *MR_EdgeId_get( MR_VarEdgeTri_GetMutable_edge( edgeTri ) ) );
      }
   
      MR_std_vector_MR_VarEdgeTri_Destroy( collidingFaceEdges );
      MR_CoordinateConverters_Destroy( converters );
   
      MR_MeshPart_Destroy( mpB );
      MR_MeshPart_Destroy( mpA );
   
      MR_Mesh_Destroy( meshB );
      MR_Mesh_Destroy( meshA );
   
      rc = EXIT_SUCCESS;
      return rc;
  }

• C#

  using static MR;
   
  public class CollisionPrecise {
   
      public static void Run(string[] args) {
          var meshA = MR.makeUVSphere();
          var meshB = MR.makeUVSphere();
   
          meshB.transform(MR.AffineXf3f.translation(new MR.Vector3f(0.1f, 0.1f, 0.1f)));
   
          var meshPartA = new MeshPart(meshA);
          var meshPartB = new MeshPart(meshB);
   
          Console.WriteLine(" --- Beginning Colliding Precise Test! --- ");
          var converters = MR.getVectorConverters(meshPartA, meshPartB).toInt;
          var collidingFaceEdges = MR.findCollidingEdgeTrisPrecise(meshPartA, meshPartB, converters);
   
          for (ulong i = 0; i < collidingFaceEdges.size(); i++) {
              var vet = collidingFaceEdges[i];
              var text = vet.isEdgeATriB()
                  ? $"edgeA: {vet.edge.id}, triB: {vet.tri().id}"
                  : $"triA: {vet.tri().id}, edgeB: {vet.edge.id}";
   
              Console.WriteLine(text);
          }
   
          var collidingFaceBitSet = MR.findCollidingTriangleBitsets(meshPartA, meshPartB);
          var bitSet = collidingFaceBitSet.first();
          Console.WriteLine($"Colliding faces on MeshA: {bitSet.count()}");
          bitSet = collidingFaceBitSet.second();
          Console.WriteLine($"Colliding faces on MeshB: {bitSet.count()}");
   
          var isColliding = !MR.findCollidingTriangles(meshPartA, meshPartB, null, true).empty();
          Console.WriteLine($"Is Colliding: {isColliding}\n");
   
      }
   
  }