MeshLib Documentation
Loading...
Searching...
No Matches
Fusion Example

Example of Fusion.

  • C++
    #include "MRMesh/MRBox.h"
    #include <MRMesh/MRMesh.h>
    #include <iostream>
    int main()
    {
    // CTM, JPEG and other formats beyond the basic ones come with the MRIOExtras library
    // load points
    auto loadRes = MR::PointsLoad::fromAnySupportedFormat( "Points.ply" );
    if ( !loadRes.has_value() )
    {
    std::cerr << loadRes.error() << "\n";
    return 1; // error while loading file
    }
    params.voxelSize = loadRes->computeBoundingBox().diagonal() * 1e-2f;
    params.sigma = std::max( params.voxelSize, MR::findAvgPointsRadius( *loadRes, 50 ) );
    params.minWeight = 1.0f;
    auto fusionRes = MR::pointsToMeshFusion( *loadRes, params );
    if ( !fusionRes.has_value() )
    {
    std::cerr << fusionRes.error() << "\n";
    return 1; // error while building the mesh
    }
    auto saveRes = MR::MeshSave::toAnySupportedFormat( *fusionRes, "Mesh.ctm" );
    if ( !saveRes.has_value() )
    {
    std::cerr << saveRes.error() << "\n";
    return 1; // error while saving file
    }
    return 0;
    }
    int main()
    Definition LaplacianDeformation.cpp:4
    Expected< Mesh > pointsToMeshFusion(const PointCloud &cloud, const PointsToMeshParameters &params)
    void loadIOExtras()
    Expected< PointCloud > fromAnySupportedFormat(const std::filesystem::path &file, const PointsLoadSettings &settings={})
    Expected< void > toAnySupportedFormat(const Mesh &mesh, const std::filesystem::path &file, const SaveSettings &settings={})
    float findAvgPointsRadius(const PointCloud &pointCloud, int avgPoints, int samples=1024)
  • Python
    from meshlib import mrmeshpy as mm
    points = mm.loadPoints("Points.ply")
    params = mm.PointsToMeshParameters()
    params.voxelSize = points.computeBoundingBox().diagonal()*1e-2
    params.sigma = max(params.voxelSize,mm.findAvgPointsRadius(points,50))
    params.minWeight = 1
    mesh = mm.pointsToMeshFusion(points,params)
    mm.saveMesh(mesh,"Mesh.ctm")
    static constexpr SymMatrix2 diagonal(T diagVal) noexcept
  • C
    #include <MRCMesh/MRPointsLoad.h>
    #include <MRCMesh/MRMeshSave.h>
    #include <MRCMesh/MRPointCloudRadius.h>
    #include <MRCMesh/MRPointCloud.h>
    #include <MRCMesh/MRBox.h>
    #include <MRCVoxels/MRPointsToMeshFusion.h>
    #include <MRCMisc/expected_MR_Mesh_std_string.h>
    #include <MRCMisc/expected_MR_PointCloud_std_string.h>
    #include <MRCMisc/expected_void_std_string.h>
    #include <MRCMisc/std_string.h>
    #include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main( void )
    {
    int rc = EXIT_FAILURE;
    // load points
    MR_expected_MR_PointCloud_std_string* loadRes = MR_PointsLoad_fromAnySupportedFormat( "Points.ply", NULL, NULL );
    MR_PointCloud* pc = MR_expected_MR_PointCloud_std_string_value_mut( loadRes );
    if ( !pc )
    {
    fprintf( stderr, "Failed to load points: %s\n", MR_std_string_data( MR_expected_MR_PointCloud_std_string_error( loadRes ) ) );
    goto fail_load;
    }
    MR_PointsToMeshParameters* params = MR_PointsToMeshParameters_DefaultConstruct();
    MR_Box3f box = MR_PointCloud_computeBoundingBox( pc, NULL );
    float voxelSize = MR_Box3f_diagonal( &box ) * 1e-2f;
    MR_PointsToMeshParameters_Set_voxelSize( params, voxelSize );
    MR_PointsToMeshParameters_Set_sigma( params, fmaxf( voxelSize, MR_findAvgPointsRadius( pc, 50, NULL ) ) );
    MR_PointsToMeshParameters_Set_minWeight( params, 1.0f );
    MR_expected_MR_Mesh_std_string* fusionRes = MR_pointsToMeshFusion( pc, params );
    MR_Mesh* mesh = MR_expected_MR_Mesh_std_string_value_mut( fusionRes );
    if ( !mesh )
    {
    fprintf( stderr, "Failed to fuse points: %s\n", MR_std_string_data( MR_expected_MR_Mesh_std_string_error( fusionRes ) ) );
    goto fail_fuse;
    }
    MR_expected_void_std_string* saveEx = MR_MeshSave_toAnySupportedFormat( mesh, "Mesh.ctm", NULL, NULL );
    if ( MR_expected_void_std_string_error( saveEx ) )
    {
    fprintf( stderr, "Failed to save mesh: %s\n", MR_std_string_data( MR_expected_void_std_string_error( saveEx ) ) );
    goto fail_save; // error while saving file
    }
    rc = EXIT_SUCCESS;
    fail_save:
    MR_expected_void_std_string_Destroy( saveEx );
    fail_fuse:
    MR_expected_MR_Mesh_std_string_Destroy( fusionRes );
    MR_PointsToMeshParameters_Destroy( params );
    fail_load:
    MR_expected_MR_PointCloud_std_string_Destroy( loadRes );
    return rc;
    }
    const Vector3f & voxelSize() const
    const BoxT & box(NodeId n) const
    const std::shared_ptr< const Mesh > & mesh() const
  • C#
    public static class FusionExample
    {
    public static void Main(string[] args)
    {
    // load points
    var pc = MR.PointsLoad.fromAnySupportedFormat("Points.ply");
    MR.PointsToMeshParameters parameters = new();
    parameters.voxelSize = pc.computeBoundingBox().diagonal() * 1e-2f;
    parameters.sigma = MathF.Max(parameters.voxelSize, MR.findAvgPointsRadius(pc, 50));
    parameters.minWeight = 1.0f;
    var mesh = MR.pointsToMeshFusion(pc, parameters);
    MR.MeshSave.toAnySupportedFormat(mesh, "Mesh.ctm");
    }
    }
  • JavaScript
    import createMeshLib from '@meshinspector/meshlib';
    const ml = await createMeshLib();
    using pointCloud = ml.PointsLoad.fromAnySupportedFormat('Points.ply');
    using bbox = pointCloud.computeBoundingBox();
    using params = new ml.PointsToMeshParameters();
    params.voxelSize = bbox.diagonal() * 0.01;
    params.sigma = Math.max(params.voxelSize, ml.findAvgPointsRadius(pointCloud, 50));
    params.minWeight = 1;
    using mesh = ml.pointsToMeshFusion(pointCloud, params);
    ml.MeshSave.toAnySupportedFormat(mesh, 'Mesh.ply');
    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
    fn main() -> Result<(), String>
    {
    // load points
    let points = meshlib::points_load::from_any_supported_format("Points.ply", None).into_result()?;
    let mut params = meshlib::PointsToMeshParameters::new();
    let voxel_size = points.compute_bounding_box(None).diagonal() * 1e-2;
    params.set_voxel_size(voxel_size);
    params.set_sigma(voxel_size.max(meshlib::find_avg_points_radius(&points, 50, None)));
    params.set_min_weight(1.0);
    let mesh = meshlib::points_to_mesh_fusion(&points, &params).into_result()?;
    meshlib::mesh_save::to_any_supported_format(&mesh, "Mesh.ctm", None).into_result()?;
    Ok(())
    }
  • Java
    import meshlib.Functions;
    import meshlib.Mesh;
    import meshlib.PointCloud;
    import meshlib.PointsToMeshParameters;
    // The class isn't public because of the `.dox.java` file name, the launcher doesn't mind.
    class Fusion
    {
    public static void main(String[] args)
    {
    // load points. An error is thrown as `UnexpectedResultException`.
    PointCloud pointCloud = meshlib.pointsload.Functions.fromAnySupportedFormat("Points.ply", null);
    PointsToMeshParameters params = new PointsToMeshParameters();
    params.setVoxelSize(pointCloud.computeBoundingBox(null).diagonal() * 1e-2f);
    params.setSigma(Math.max(params.voxelSize(), Functions.findAvgPointsRadius(pointCloud, 50, null)));
    params.setMinWeight(1.0f);
    Mesh mesh = Functions.pointsToMeshFusion(pointCloud, params);
    meshlib.meshsave.Functions.toAnySupportedFormat(mesh, "Mesh.ctm", null);
    }
    }
    const std::shared_ptr< const PointCloud > & pointCloud() const