Signed Distance

Example of usage to get signed distance from mesh to mesh

Note

Please note that unlike findSignedDistances, this function return minimal distance between two meshes

• C++

  #include "MRMesh/MRMeshLoad.h"
  #include "MRMesh/MRMesh.h"
  #include "MRMesh/MRMeshMeshDistance.h"
  #include <iostream>
   
  int main()
  {
      auto mesh1Res = MR::MeshLoad::fromAnySupportedFormat( "mesh1.ctm" );
      if ( !mesh1Res.has_value() )
      {
          std::cerr << mesh1Res.error();
          return 1;
      }
      auto mesh2Res = MR::MeshLoad::fromAnySupportedFormat( "mesh2.ctm" );
      if ( !mesh2Res.has_value() )
      {
          std::cerr << mesh2Res.error();
          return 1;
      }
   
      auto dist = MR::findSignedDistance( *mesh1Res, *mesh2Res );
      std::cout << "Signed distance between meshes is " << dist.signedDist << "\n";
      return 0;
  }

• Python

  from meshlib import mrmeshpy
   
  mesh1 = mrmeshpy.loadMesh("mesh1.ctm")
  mesh2 = mrmeshpy.loadMesh("mesh2.ctm")
   
  a = mrmeshpy.findSignedDistance(mesh1, mesh2)
  print(f"Signed distance between meshes is {a.signedDist}")

• C

  #include <MRCMesh/MRMesh.h>
  #include <MRCMesh/MRMeshPart.h>
  #include <MRCMesh/MRMeshLoad.h>
  #include <MRCMesh/MRMeshMeshDistance.h>
  #include <MRCMisc/std_string.h>
  #include <MRCMisc/expected_MR_Mesh_std_string.h>
   
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  int main( void )
  {
      int rc = EXIT_FAILURE;
   
      // Load mesh.
      MR_expected_MR_Mesh_std_string* mesh1Res = MR_MeshLoad_fromAnySupportedFormat_2( "mesh1.ctm", NULL, NULL );
      MR_Mesh* mesh1 = MR_expected_MR_Mesh_std_string_value_mut( mesh1Res );
      if ( !mesh1 )
      {
          fprintf( stderr, "Failed to load mesh: %s\n", MR_std_string_data( MR_expected_MR_Mesh_std_string_error( mesh1Res ) ) );
          goto fail_load_1;
      }
   
      MR_expected_MR_Mesh_std_string* mesh2Res = MR_MeshLoad_fromAnySupportedFormat_2( "mesh2.ctm", NULL, NULL );
      MR_Mesh* mesh2 = MR_expected_MR_Mesh_std_string_value_mut( mesh2Res );
      if ( !mesh2 )
      {
          fprintf( stderr, "Failed to load mesh: %s\n", MR_std_string_data( MR_expected_MR_Mesh_std_string_error( mesh2Res ) ) );
          goto fail_load_2;
      }
   
      MR_MeshPart* mp1 = MR_MeshPart_Construct( mesh1, NULL );
      MR_MeshPart* mp2 = MR_MeshPart_Construct( mesh2, NULL );
   
      MR_MeshMeshSignedDistanceResult* res = MR_findSignedDistance_MR_MeshPart( mp1, mp2, NULL, NULL );
      const float* dist = MR_MeshMeshSignedDistanceResult_Get_signedDist( res );
   
      fprintf( stdout, "Signed distance between meshes is: %f\n", *dist );
   
      MR_MeshMeshSignedDistanceResult_Destroy( res );
      MR_MeshPart_Destroy( mp2 );
      MR_MeshPart_Destroy( mp1 );
   
      rc = EXIT_SUCCESS;
   
  fail_load_2:
      MR_expected_MR_Mesh_std_string_Destroy( mesh2Res );
  fail_load_1:
      MR_expected_MR_Mesh_std_string_Destroy( mesh1Res );
      return rc;
  }

• JavaScript

  import createMeshLib from '@meshinspector/meshlib';
   
  const ml = await createMeshLib();
   
  using mesh1 = ml.MeshLoad.fromAnySupportedFormat('mesh1.ply');
  using mesh2 = ml.MeshLoad.fromAnySupportedFormat('mesh2.ply');
   
  // unlike findSignedDistances, this returns the single minimal signed distance between two meshes
  const dist = ml.findSignedDistanceFromMesh(mesh1, mesh2);
  console.log(`Signed distance between meshes is ${dist.signedDist}`);