Simple triangulation

Simple triangulation

• C++

  #include <MRMesh/MRPointCloud.h>
  #include <MRMesh/MRPointCloudTriangulation.h>
  #include <MRMesh/MRUniformSampling.h>
  #include <MRVoxels/MROffset.h>
   
  int main()
  {
      // Generate point cloud
      MR::PointCloud pc;
      pc.points.reserve( 10000 );
      for ( auto i = 0; i < 100; ++i )
      {
          const auto u = MR::PI2_F * float( i ) / ( 100.f - 1.f );
          for ( auto j = 0; j < 100; ++j )
          {
              const auto v = MR::PI_F * float( j ) / ( 100.f - 1.f );
   
              pc.points.emplace_back(
                  std::cos( u ) * std::sin( v ),
                  std::sin( u ) * std::sin( v ),
                  std::cos( v )
              );
          }
      }
      // Remove duplicate points
      auto vs = MR::pointUniformSampling( pc, {
          .distance = 1e-3f,
      } );
      assert( vs );
      pc.validPoints = std::move( *vs );
      pc.invalidateCaches();
   
      // Triangulate it
      auto triangulated = MR::triangulatePointCloud( pc );
      assert( triangulated );
   
      // Fix possible issues
      auto mesh = MR::offsetMesh( *triangulated, 0.f, { {
          .voxelSize = MR::suggestVoxelSize( *triangulated, 5e+6f ),
      } } );
  }

• Python API v2

  from meshlib import mrmeshpy as mm
  from meshlib import mrmeshnumpy as mn
  import numpy as np
   
  u, v = np.mgrid[0:2 * np.pi:100j, 0:np.pi:100j]
  x = np.cos(u) * np.sin(v)
  y = np.sin(u) * np.sin(v)
  z = np.cos(v)
   
  # Prepare for MeshLib PointCloud
  verts = np.stack((x.flatten(), y.flatten(), z.flatten()), axis=-1).reshape(-1, 3)
  # Create MeshLib PointCloud from np ndarray
  pc = mn.pointCloudFromPoints(verts)
  # Remove duplicate points
  pc.validPoints = mm.pointUniformSampling(pc, 1e-3)
  pc.invalidateCaches()
   
  # Triangulate it
  triangulated_pc = mm.triangulatePointCloud(pc)
   
  # Fix possible issues
  triangulated_pc = mm.offsetMesh(triangulated_pc, 0.0)

• Python API v3

  Note

  Python API version 3 and later

  from meshlib import mrmeshpy as mm
  from meshlib import mrmeshnumpy as mn
  import numpy as np
   
  u, v = np.mgrid[0:2 * np.pi:100j, 0:np.pi:100j]
  x = np.cos(u) * np.sin(v)
  y = np.sin(u) * np.sin(v)
  z = np.cos(v)
   
  # Prepare for MeshLib PointCloud
  verts = np.stack((x.flatten(), y.flatten(), z.flatten()), axis=-1).reshape(-1, 3)
  # Create MeshLib PointCloud from np ndarray
  pc = mn.pointCloudFromPoints(verts)
  # Remove duplicate points
  samplingSettings = mm.UniformSamplingSettings()
  samplingSettings.distance = 1e-3
  pc.validPoints = mm.pointUniformSampling(pc, samplingSettings)
  pc.invalidateCaches()
   
  # Triangulate it
  triangulated_pc = mm.triangulatePointCloud(pc)
   
  # Fix possible issues
  offsetParams = mm.OffsetParameters()
  offsetParams.voxelSize = mm.suggestVoxelSize( triangulated_pc, 5e6 )
  triangulated_pc = mm.offsetMesh(triangulated_pc, 0.0, params=offsetParams)

• C

  #include <MRMeshC/MRBitSet.h>
  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MROffset.h>
  #include <MRMeshC/MRPointCloud.h>
  #include <MRMeshC/MRPointCloudTriangulation.h>
  #include <MRMeshC/MRUniformSampling.h>
   
  #include <math.h>
   
  int main( int argc, char* argv[] )
  {
      // Generate point cloud
      MRVector3f points[10000];
      for ( int i = 0; i < 100; ++i )
      {
          float u = M_PI_2 * (float)i / ( 100.f - 1.f );
          for ( int j = 0; j < 100; ++j )
          {
              float v = M_PI * (float)j / ( 100.f - 1.f );
   
              points[i * 100 + j] = (MRVector3f){
                  cos( u ) * sin( v ),
                  sin( u ) * sin( v ),
                  cos( v )
              };
          }
      }
      MRPointCloud* pc = mrPointCloudFromPoints( points, 10000 );
      // Remove duplicate points
      MRUniformSamplingSettings samplingSettings = mrUniformSamplingSettingsNew();
      samplingSettings.distance = 1e-3f;
      MRVertBitSet* vs = mrPointUniformSampling( pc, &samplingSettings );
      mrPointCloudSetValidPoints( pc, vs );
      mrPointCloudInvalidateCaches( pc );
   
      // Triangulate it
      MRMesh* triangulated = mrTriangulatePointCloud( pc, NULL );
   
      // Fix possible issues
      MROffsetParameters offsetParams = mrOffsetParametersNew();
      offsetParams.voxelSize = mrSuggestVoxelSize( (MRMeshPart){ triangulated, NULL }, 5e+6f );
      MRMesh* mesh = mrOffsetMesh( (MRMeshPart){ triangulated, NULL }, 0.f, &offsetParams, NULL );
   
      mrMeshFree( mesh );
      mrMeshFree( triangulated );
      mrVertBitSetFree( vs );
      mrPointCloudFree( pc );
  }