Mesh ICP

Example of mesh ICP (finding transformation to match objects)

• C++

  #include <MRMesh/MRBox.h>
  #include <MRMesh/MRICP.h>
  #include <MRMesh/MRMesh.h>
  #include <MRMesh/MRMeshLoad.h>
  #include <MRMesh/MRMeshSave.h>
   
  #include <iostream>
   
  int main()
  {
      // Load meshes
      MR::Mesh meshFloating = *MR::MeshLoad::fromAnySupportedFormat( "meshA.stl" );
      MR::Mesh meshFixed = *MR::MeshLoad::fromAnySupportedFormat( "meshB.stl" );
   
      // Prepare ICP parameters
      float diagonal = meshFixed.getBoundingBox().diagonal();
      float icpSamplingVoxelSize = diagonal * 0.01f; // To sample points from object
      MR::ICPProperties icpParams;
      icpParams.distThresholdSq = MR::sqr( diagonal * 0.1f ); // Use points pairs with maximum distance specified
      icpParams.exitVal = diagonal * 0.003f; // Stop when distance reached
   
      // Calculate transformation
      MR::ICP icp(
          MR::MeshOrPoints{ MR::MeshPart{ meshFloating } },
          MR::MeshOrPoints{ MR::MeshPart{ meshFixed } },
          MR::AffineXf3f(), MR::AffineXf3f(),
          icpSamplingVoxelSize );
      icp.setParams( icpParams );
      MR::AffineXf3f xf = icp.calculateTransformation();
   
      // Transform floating mesh
      meshFloating.transform( xf );
   
      // Output information string
      std::string info = icp.getStatusInfo();
      std::cerr << info << std::endl;
   
      // Save result
      MR::MeshSave::toAnySupportedFormat( meshFloating, "meshA_icp.stl" );
  }

• Python

  import meshlib.mrmeshpy as mrmeshpy
   
  # Load meshes
  meshFloating = mrmeshpy.loadMesh("meshA.stl")
  meshFixed = mrmeshpy.loadMesh("meshB.stl")
   
  # Prepare ICP parameters
  diagonal = meshFixed.getBoundingBox().diagonal()
  icp_sampling_voxel_size = diagonal * 0.01  # To sample points from object
  icp_params = mrmeshpy.ICPProperties()
  icp_params.distThresholdSq = (diagonal * 0.1) ** 2  # Use points pairs with maximum distance specified
  icp_params.exitVal = diagonal * 0.003  # Stop when this distance reached
   
  # Calculate transformation
  icp = mrmeshpy.ICP(meshFloating, meshFixed,
                     mrmeshpy.AffineXf3f(), mrmeshpy.AffineXf3f(),
                     icp_sampling_voxel_size)
  icp.setParams(icp_params)
  xf = icp.calculateTransformation()
   
  # Transform floating mesh
  meshFloating.transform(xf)
   
  # Output information string
  print(icp.getLastICPInfo())
   
  # Save result
  mrmeshpy.saveMesh(meshFloating, "meshA_icp.stl")

• C

  #include <MRMeshC/MRICP.h>
  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MRMeshLoad.h>
  #include <MRMeshC/MRMeshSave.h>
  #include <MRMeshC/MRString.h>
   
  #include <stdio.h>
  #include <stdlib.h>
   
  int main( int argc, char* argv[] )
  {
      // Load meshes
      MRMesh* meshFloating = mrMeshLoadFromAnySupportedFormat( "meshA.stl", NULL );
      MRMesh* meshFixed = mrMeshLoadFromAnySupportedFormat( "meshB.stl", NULL );
   
      // Prepare ICP parameters
      MRBox3f bbox = mrMeshComputeBoundingBox( meshFixed, NULL );
      float diagonal = mrBox3fDiagonal( &bbox );
      float icpSamplingVoxelSize = diagonal * 0.01f; // To sample points from object
      MRICPProperties icpParams = mrICPPropertiesNew();
      icpParams.distThresholdSq = diagonal * diagonal * 0.01f; // Use points pairs with maximum distance specified
      icpParams.exitVal = diagonal * 0.003f; // Stop when distance reached
   
      // Calculate transformation
      MRMeshOrPointsXf* flt = mrMeshOrPointsXfFromMesh( meshFloating, NULL );
      MRMeshOrPointsXf* ref = mrMeshOrPointsXfFromMesh( meshFixed, NULL );
      MRICP* icp = mrICPNew( flt, ref, icpSamplingVoxelSize );
      mrICPSetParams( icp, &icpParams );
      MRAffineXf3f xf = mrICPCalculateTransformation( icp );
   
      // Transform floating mesh
      mrMeshTransform( meshFloating, &xf, NULL );
   
      // Output information string
      MRString* info = mrICPGetStatusInfo( icp );
      printf( "%s\n", mrStringData( info ) );
   
      // Save result
      mrMeshSaveToAnySupportedFormat( meshFloating, "meshA_icp.stl", NULL, NULL );
   
      mrStringFree( info );
      mrICPFree( icp );
      mrMeshOrPointsXfFree( flt );
      mrMeshOrPointsXfFree( ref );
      mrMeshFree( meshFixed );
      mrMeshFree( meshFloating );
      return EXIT_SUCCESS;
  }

• C#

  using System.Reflection;
  using static MR.DotNet;
   
  public class MeshICPExample
  {
      public static void Run()
      {
          try
          {
              // Load meshes
   
              Mesh meshFloating = MeshLoad.FromAnySupportedFormat("meshA.stl");
              MeshOrPointsXf meshXfFloating = new MeshOrPointsXf(meshFloating, new AffineXf3f());
              MeshOrPointsXf meshXfFixed = new MeshOrPointsXf(MeshLoad.FromAnySupportedFormat("meshB.stl"), new AffineXf3f());
   
              // Prepare ICP parameters
              float diagonal = meshXfFixed.obj.BoundingBox.Diagonal();
              float icpSamplingVoxelSize = diagonal * 0.01f; // To sample points from object
              ICPProperties icpParams = new ICPProperties();
              icpParams.distThresholdSq = diagonal * diagonal * 0.01f; // Use points pairs with maximum distance specified
              icpParams.exitVal = diagonal * 0.003f; // Stop when distance reached
   
              // Calculate transformation
              ICP icp = new ICP(meshXfFloating, meshXfFixed, icpSamplingVoxelSize);
              icp.SetParams( icpParams );
              AffineXf3f xf = icp.CalculateTransformation();
   
              // Transform floating mesh
              meshFloating.Transform(xf);
   
              // Output information string
              Console.WriteLine("info {0}", icp.GetStatusInfo());
   
              // Save result
              MeshSave.ToAnySupportedFormat( meshFloating, "meshA_icp.stl");
          }
          catch (Exception e)
          {
              Console.WriteLine("Error: {0}", e.Message);
          }
      }
  }