MeshLib Documentation
Loading...
Searching...
No Matches
Precise detect collisions of two meshes

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

▶ See it live in the browser

  • C++
    #include "MRMesh/MRMesh.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;
    }
    int main()
    Definition LaplacianDeformation.cpp:4
    CoordinateConverters getVectorConverters(const MeshPart &a)
    PreciseCollisionResult findCollidingEdgeTrisPrecise(const MeshPart &a, const MeshPart &b, ConvertToIntVector conv, const AffineXf3f *rigidB2A=nullptr, bool anyIntersection=false)
    Mesh makeUVSphere(float radius=1.0, int horisontalResolution=16, int verticalResolution=16)
  • 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())
    const std::vector< T > & get() const
  • 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 "MRCMesh/MRVector.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( 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( mpA, mpB, NULL );
    // find each intersecting edge/triangle pair
    MR_Vector_MR_VarEdgeTri* collidingFaceEdges = MR_findCollidingEdgeTrisPrecise(
    mpA, mpB, MR_CoordinateConverters_Get_toInt( converters ), NULL, NULL );
    // print pairs of edges triangles
    for ( size_t i = 0; i < MR_Vector_MR_VarEdgeTri_size( collidingFaceEdges ); ++i )
    {
    MR_VarEdgeTri* edgeTri = MR_Vector_MR_VarEdgeTri_index_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_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;
    }
    Vector3f shift() const
  • C#
    public static class CollisionPreciseExample
    {
    public static void Main(string[] args)
    {
    var meshA = MR.makeUVSphere(); // make mesh A
    var meshB = MR.makeUVSphere(); // make mesh B
    meshB.transform(MR.AffineXf3f.translation(new MR.Vector3f(0.1f, 0.1f, 0.1f))); // shift mesh B for better demonstration
    var converters = MR.getVectorConverters(meshA, meshB); // create converters to integer field (needed for absolute precision predicates)
    var collidingFaceEdges = MR.findCollidingEdgeTrisPrecise(meshA, meshB, converters.toInt); // find each intersecting edge/triangle pair
    // print pairs of edges triangles
    for (nuint i = 0; i < collidingFaceEdges.size(); ++i)
    {
    var vet = collidingFaceEdges[i];
    if (vet.isEdgeATriB())
    Console.WriteLine("edgeA: {0}, triB: {1}", vet.edge.id, vet.tri().id);
    else
    Console.WriteLine("triA: {0}, edgeB: {1}", vet.tri().id, vet.edge.id);
    }
    }
    }
  • JavaScript
    import createMeshLib from '@meshinspector/meshlib';
    const ml = await createMeshLib();
    using meshA = ml.makeUVSphere(1.0, 16, 16); // make mesh A
    using meshB = ml.makeUVSphere(1.0, 16, 16); // make mesh B
    // shift mesh B for better demonstration
    using shift = ml.AffineXf3f.translation({ x: 0.1, y: 0.1, z: 0.1 });
    meshB.transform(shift);
    // create converters to integer field (needed for absolute precision predicates)
    using converters = ml.getVectorConverters(meshA, meshB);
    // find each intersecting edge/triangle pair
    using collidingFaceEdges = ml.findCollidingEdgeTrisPrecise(meshA, meshB, converters);
    for (let i = 0; i < collidingFaceEdges.size(); ++i) {
    using vet = collidingFaceEdges.get(i);
    if (vet.isEdgeATriB())
    console.log(`edgeA: ${vet.edge}, triB: ${vet.tri()}`);
    else
    console.log(`triA: ${vet.tri()}, edgeB: ${vet.edge}`);
    }
    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::{AffineXf3f, MeshPart, Vector3f};
    fn main()
    {
    let mesh_a = meshlib::make_uv_sphere(None, None, None); // make mesh A
    let mut mesh_b = meshlib::make_uv_sphere(None, None, None); // make mesh B
    mesh_b.transform(&AffineXf3f::translation(&Vector3f {x: 0.1, y: 0.1, z: 0.1}), None); // shift mesh B for better demonstration
    let part_a = MeshPart::construct(&mesh_a, None);
    let part_b = MeshPart::construct(&mesh_b, None);
    let converters = meshlib::get_vector_converters(&part_a, &part_b, None); // create converters to integer field (needed for absolute precision predicates)
    let colliding_face_edges = meshlib::find_colliding_edge_tris_precise(&part_a, &part_b, converters.to_int(), None, None); // find each intersecting edge/triangle pair
    // print pairs of edges triangles
    for i in 0..colliding_face_edges.size()
    {
    let vet = colliding_face_edges.index(i);
    if vet.is_edge_a_tri_b()
    {
    println!("edgeA: {}, triB: {}", vet.edge().id_, vet.tri().id_);
    }
    else
    {
    println!("triA: {}, edgeB: {}", vet.tri().id_, vet.edge().id_);
    }
    }
    }
  • Java
    import meshlib.AffineXf3f;
    import meshlib.CoordinateConverters;
    import meshlib.Functions;
    import meshlib.Mesh;
    import meshlib.MeshPart;
    import meshlib.VarEdgeTri;
    import meshlib.Vector3f;
    import meshlib.Vector_MR_VarEdgeTri;
    // The class isn't public because of the `.dox.java` file name, the launcher doesn't mind.
    class CollisionPrecise
    {
    public static void main(String[] args)
    {
    Mesh meshA = Functions.makeUVSphere(null, null, null); // make mesh A
    Mesh meshB = Functions.makeUVSphere(null, null, null); // make mesh B
    meshB.transform(AffineXf3f.translation(new Vector3f(0.1f, 0.1f, 0.1f)), null); // shift mesh B for better demonstration
    MeshPart partA = new MeshPart(meshA, null);
    MeshPart partB = new MeshPart(meshB, null);
    CoordinateConverters converters = Functions.getVectorConverters(partA, partB, null); // create converters to integer field (needed for absolute precision predicates)
    Vector_MR_VarEdgeTri collidingFaceEdges = Functions.findCollidingEdgeTrisPrecise(partA, partB, converters.toInt(), null, null); // find each intersecting edge/triangle pair
    // print pairs of edges triangles
    for (long i = 0; i < collidingFaceEdges.size(); i++)
    {
    VarEdgeTri vet = collidingFaceEdges.index(i);
    if (vet.isEdgeATriB())
    System.out.println("edgeA: " + vet.edge().id_() + ", triB: " + vet.tri().id_());
    else
    System.out.println("triA: " + vet.tri().id_() + ", edgeB: " + vet.edge().id_());
    }
    }
    }