Fusion Example

Example of Fusion.

• C++

  #include <MRMesh/MRPointsLoad.h>
  #include <MRMesh/MRPointCloud.h>
  #include "MRMesh/MRBox.h"
  #include "MRMesh/MRPointCloudRadius.h"
  #include "MRVoxels/MRPointsToMeshFusion.h"
  #include <MRMesh/MRMeshSave.h>
  #include <MRMesh/MRMesh.h>
  #include <iostream>
   
  int main()
  {
      // load points
      auto loadRes = MR::PointsLoad::fromAnySupportedFormat( "Points.ply" );
      if ( !loadRes.has_value() )
      {
          std::cerr << loadRes.error() << "\n";
          return 1; // error while loading file
      }
   
      MR::PointsToMeshParameters params;
      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 saving file
      }
   
      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;
  }

• 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")

• 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 <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  #ifdef max
  #undef max
  #endif
  #define max(a,b) a > b ? a : b
   
  int main( void )
  {
      int rc = EXIT_FAILURE;
   
      // load points
      MR_expected_MR_PointCloud_std_string* loadRes = MR_PointsLoad_fromAnySupportedFormat_2( "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_1( pc, NULL );
      float voxelSize = MR_Box3f_diagonal( &box ) * 1e-2f;
      MR_PointsToMeshParameters_Set_voxelSize( params, voxelSize );
      float avgRadius = MR_findAvgPointsRadius( pc, 50, NULL );
      float sigma = max( voxelSize, avgRadius );
      MR_PointsToMeshParameters_Set_sigma( params, sigma );
      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_3( 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;
  }