Mesh Decimation

Example of mesh decimation

• C++

  #include <MRMesh/MRMeshFwd.h>
  #include <MRMesh/MRMeshLoad.h>
  #include <MRMesh/MRMeshSave.h>
  #include <MRMesh/MRMesh.h>
  #include <MRMesh/MRMeshDecimate.h>
  #include <MRMesh/MRBuffer.h>
   
  int main()
  {
      // Load mesh
      MR::Mesh mesh = *MR::MeshLoad::fromAnySupportedFormat( "mesh.stl" );
   
      // Repack mesh optimally.
      // It's not necessary but highly recommended to achieve the best performance in parallel processing
      mesh.packOptimally();
   
   
      // Setup decimate parameters
      MR::DecimateSettings settings;
   
      // Decimation stop thresholds, you may specify one or both
      settings.maxDeletedFaces = 1000; // Number of faces to be deleted
      settings.maxError = 0.05f; // Maximum error when decimation stops
   
      // Number of parts to simultaneous processing, greatly improves performance by cost of minor quality loss.
      // Recommended to set to the number of available CPU cores or more for the best performance
      settings.subdivideParts = 64;
   
      // Decimate mesh
      MR::decimateMesh( mesh, settings );
   
      // Save result
      MR::MeshSave::toAnySupportedFormat( mesh, "decimatedMesh.stl" );
  }

• Python

  import meshlib.mrmeshpy as mrmeshpy
   
  # Load mesh
  mesh = mrmeshpy.loadMesh("mesh.stl")
   
  # Repack mesh optimally.
  # It's not necessary but highly recommended to achieve the best performance in parallel processing
  mesh.packOptimally()
   
  # Setup decimate parameters
  settings = mrmeshpy.DecimateSettings()
  # Decimation stop thresholds, you may specify one or both
  settings.maxDeletedFaces = 1000 # Number of faces to be deleted
  settings.maxError = 0.05 # Maximum error when decimation stops
   
  # Number of parts to simultaneous processing, greatly improves performance by cost of minor quality loss.
  # Recommended to set to number of CPU cores or more available for the best performance
  settings.subdivideParts = 64
   
  # Decimate mesh
  mrmeshpy.decimateMesh(mesh, settings)
   
  # Save result
  mrmeshpy.saveMesh(mesh, "decimatedMesh.stl")

• C

  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MRMeshDecimate.h>
  #include <MRMeshC/MRMeshLoad.h>
  #include <MRMeshC/MRMeshSave.h>
  #include <MRMeshC/MRString.h>
   
  #include <stdio.h>
  #include <stdlib.h>
   
  // print progress every 10%
  int gProgress = -1;
  bool onProgress( float v )
  {
      int progress = (int)( 10.f * v );
      if ( progress != gProgress )
      {
          gProgress = progress;
          printf( "%d%%...\n", progress * 10 );
      }
      return true;
  }
   
  int main( int argc, char* argv[] )
  {
      int rc = EXIT_FAILURE;
      if ( argc != 2 && argc != 3 )
      {
          fprintf( stderr, "Usage: %s INPUT [OUTPUT]", argv[0] );
          goto out;
      }
   
      const char* input = argv[1];
      const char* output = ( argc == 2 ) ? argv[1] : argv[2];
   
      // error messages will be stored here
      MRString* errorString = NULL;
   
      MRMesh* mesh = mrMeshLoadFromAnySupportedFormat( input, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to load mesh: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out;
      }
   
      // you can set various parameters for the mesh decimation; see the documentation for more info
      MRDecimateSettings params = mrDecimateSettingsNew();
      params.strategy = MRDecimateStrategyMinimizeError;
      // maximum permitted deviation
      const MRBox3f bbox = mrMeshComputeBoundingBox( mesh, NULL );
      params.maxError = 1e-5f * mrBox3fDiagonal( &bbox );
      // maximum length of edges to be collapsed
      params.tinyEdgeLength = 1e-3f;
      // pack mesh after decimation
      params.packMesh = true;
      // set progress callback
      params.progressCallback = onProgress;
   
      MRDecimateResult result = mrDecimateMesh( mesh, &params );
      if ( !result.cancelled )
          printf( "Removed %d vertices, %d faces", result.vertsDeleted, result.facesDeleted );
      else
      {
          fprintf( stderr, "Cancelled" );
          goto out_mesh;
      }
   
      mrMeshSaveToAnySupportedFormat( mesh, output, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to save mesh: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out_mesh;
      }
   
      rc = EXIT_SUCCESS;
  out_mesh:
      mrMeshFree( mesh );
  out:
      return rc;
  }

• C#

  using MR.DotNet;
  using System;
  using System.Reflection;
   
  class Program
  {
      static void Main(string[] args)
      {
          if (args.Length != 1 && args.Length != 2)
          {           
              Console.WriteLine("Usage: {0} INPUT [OUTPUT]", Assembly.GetExecutingAssembly().GetName().Name);
              return;
          }
   
          try
          {
              string input = args[0];
              string output = args.Length == 2 ? args[1] : args[0];
   
              var mesh = Mesh.FromAnySupportedFormat( input );
   
              DecimateParameters dp = new DecimateParameters();
              dp.strategy = DecimateStrategy.MinimizeError;
              dp.maxError = 1e-5f * mesh.BoundingBox.Diagonal();
              dp.tinyEdgeLength = 1e-3f;
              dp.packMesh = true;
   
              var result = MeshDecimate.Decimate(mesh, dp);
              Mesh.ToAnySupportedFormat(mesh, output);
          }
          catch (Exception e)
          {
              Console.WriteLine("Error: {0}", e.Message);
          }
      }
  }