Fixing Mesh Degeneracies

Example of fixing degenerated faces

• C++

  #include <MRMesh/MRMesh.h>
  #include <MRMesh/MRMeshLoad.h>
   
  #include <iostream>
  #include <MRMesh/MRBox.h>
  #include <MRMesh/MRMeshFixer.h>
   
  int main()
  {
      auto mesh = MR::MeshLoad::fromAnySupportedFormat( "mesh.stl" );
      if ( !mesh )
      {
          std::cerr << mesh.error() << std::endl;
          return 1;
      }
   
      // you can set various parameters for the resolving process; see the documentation for more info
      MR::fixMeshDegeneracies( *mesh, {
          .maxDeviation = 1e-5f * mesh->computeBoundingBox().diagonal(),
          .tinyEdgeLength = 1e-3f,
      } );
   
      return 0;
  }

• Python

  import sys
   
  import meshlib.mrmeshpy as mrmeshpy
   
  # Load mesh
  mesh = mrmeshpy.loadMesh("mesh.stl")
   
  # you can set various parameters for the resolving process; see the documentation for more info
  params = mrmeshpy.FixMeshDegeneraciesParams()
  params.maxDeviation = 1e-5 * mesh.computeBoundingBox().diagonal()
  params.tinyEdgeLength = 1e-3
   
  mrmeshpy.fixMeshDegeneracies(mesh, params)
   
  mrmeshpy.saveMesh(mesh, "fixed_mesh.stl")

• C

  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MRMeshFixer.h>
  #include <MRMeshC/MRMeshLoad.h>
  #include <MRMeshC/MRMeshSave.h>
  #include <MRMeshC/MRString.h>
   
  #include <stdio.h>
  #include <stdlib.h>
   
  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 resolving process; see the documentation for more info
      MRFixMeshDegeneraciesParams params = mrFixMeshDegeneraciesParamsNew();
      // maximum permitted deviation
      const MRBox3f bbox = mrMeshComputeBoundingBox( mesh, NULL );
      params.maxDeviation = 1e-5f * mrBox3fDiagonal( &bbox );
      // maximum length of edges to be collapsed
      params.tinyEdgeLength = 1e-3f;
   
      mrFixMeshDegeneracies( mesh, &params, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to fix mesh degeneracies: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out_mesh;
      }
   
      MRSaveSettings saveSettings = mrSaveSettingsNew();
      mrMeshSaveToAnySupportedFormat( mesh, output, &saveSettings, &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 System.Reflection;
  using static MR.DotNet;
   
  public static class MeshFixDegeneraciesExample
  {
      public static void Run(string[] args)
      {
          try
          {
              if (args.Length != 2 && args.Length != 3)
              {
                  Console.WriteLine("Usage: {0} MeshFixDegeneraciesExample INPUT [OUTPUT]", Assembly.GetExecutingAssembly().GetName().Name);
                  return;
              }
   
              string inputFile = args[1];
              string outputFile = args.Length == 3 ? args[2] : inputFile;
   
              var mesh = MeshLoad.FromAnySupportedFormat(inputFile);
              var parameters = new FixMeshDegeneraciesParams();
              parameters.maxDeviation = mesh.BoundingBox.Diagonal() * 1e-5f;
              parameters.tinyEdgeLength = 1e-3f;
   
              FixMeshDegeneracies(ref mesh, parameters);
              MeshSave.ToAnySupportedFormat(mesh, outputFile);
          }
          catch (Exception e)
          {
              Console.WriteLine("Error: {0}", e.Message);
          }
      }
  }