MeshLib Documentation
Loading...
Searching...
No Matches
Signed Distance

Example of usage to get signed distance from mesh to mesh

▶ See it live in the browser

Note
Please note that unlike findSignedDistances, this function return minimal distance between two meshes
  • C++
    #include "MRMesh/MRMesh.h"
    #include <iostream>
    int main()
    {
    // CTM, JPEG and other formats beyond the basic ones come with the MRIOExtras library
    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;
    }
    int main()
    Definition LaplacianDeformation.cpp:4
    MeshMeshSignedDistanceResult findSignedDistance(const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr, float upDistLimitSq=FLT_MAX)
    float dist() const
    void loadIOExtras()
    Expected< Mesh > fromAnySupportedFormat(const std::filesystem::path &file, const MeshLoadSettings &settings={})
  • 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( "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( "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;
    }
  • C#
    public static class SignedDistanceExample
    {
    public static void Main(string[] args)
    {
    var mesh1 = MR.MeshLoad.fromAnySupportedFormat("mesh1.ctm");
    var mesh2 = MR.MeshLoad.fromAnySupportedFormat("mesh2.ctm");
    var dist = MR.findSignedDistance(mesh1, mesh2);
    Console.WriteLine("Signed distance between meshes is {0}", dist.signedDist);
    }
    }
  • 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}`);
    Note
    The using declaration requires Node.js 24+ or a modern browser. On older runtimes, call .delete() on each object instead (see Memory Management in the JavaScript Setup Guide).
  • Rust
    use meshlib::MeshPart;
    fn main() -> Result<(), String>
    {
    let mesh1 = meshlib::mesh_load::from_any_supported_format("mesh1.ctm", None).into_result()?;
    let mesh2 = meshlib::mesh_load::from_any_supported_format("mesh2.ctm", None).into_result()?;
    let dist = meshlib::find_signed_distance_mr_mesh_part(&MeshPart::construct(&mesh1, None), &MeshPart::construct(&mesh2, None), None, None);
    println!("Signed distance between meshes is {}", dist.signed_dist());
    Ok(())
    }
  • Java
    import meshlib.Functions;
    import meshlib.Mesh;
    import meshlib.MeshMeshSignedDistanceResult;
    import meshlib.MeshPart;
    // The class isn't public because of the `.dox.java` file name, the launcher doesn't mind.
    class SignedDistance
    {
    public static void main(String[] args)
    {
    // An error is thrown as `UnexpectedResultException`.
    Mesh mesh1 = meshlib.meshload.Functions.fromAnySupportedFormat("mesh1.ctm", null);
    Mesh mesh2 = meshlib.meshload.Functions.fromAnySupportedFormat("mesh2.ctm", null);
    MeshMeshSignedDistanceResult dist = Functions.findSignedDistance(new MeshPart(mesh1, null), new MeshPart(mesh2, null), null, null);
    System.out.println("Signed distance between meshes is " + dist.signedDist());
    }
    }