Mesh Offset

Example of mesh offset

• C++

  #include <MRMesh/MRBox.h>
  #include <MRMesh/MRMesh.h>
  #include <MRMesh/MRMeshLoad.h>
  #include <MRMesh/MRMeshSave.h>
  #include <MRMesh/MRRegionBoundary.h>
  #include <MRVoxels/MROffset.h>
   
  int main()
  {
      // Load mesh
      MR::Mesh mesh = *MR::MeshLoad::fromAnySupportedFormat( "mesh.stl" );
   
      // Setup parameters
      MR::GeneralOffsetParameters params;
      params.voxelSize = mesh.computeBoundingBox().diagonal() * 5e-3f; // offset grid precision (algorithm is voxel based)
      if ( !MR::findRightBoundary( mesh.topology ).empty() )
          params.signDetectionMode = MR::SignDetectionMode::HoleWindingRule; // use if you have holes in mesh
   
      // Make offset mesh
      float offset = mesh.computeBoundingBox().diagonal() * 0.05f;
      auto meshRes = MR::generalOffsetMesh( mesh, offset, params );
      if ( !meshRes.has_value() )
      {
          // log meshRes.error()
          return 1;
      }
   
      // Save result
      MR::MeshSave::toAnySupportedFormat( *meshRes, "mesh_offset.stl" );
   
      return 0;
  }

• Python

  import meshlib.mrmeshpy as mrmeshpy
   
  # Load mesh
  mesh = mrmeshpy.loadMesh("mesh.stl")
   
  # Setup parameters
  params = mrmeshpy.OffsetParameters()
  params.voxelSize = mesh.computeBoundingBox().diagonal() * 5e-3  # offset grid precision (algorithm is voxel based)
  if mrmeshpy.findRightBoundary(mesh.topology).empty():
      params.signDetectionMode = mrmeshpy.SignDetectionMode.HoleWindingRule  # use if you have holes in mesh
   
  # Make offset mesh
  offset = mesh.computeBoundingBox().diagonal() * 0.05
  result_mesh = mrmeshpy.offsetMesh(mesh, offset, params)
   
  # Save result
  mrmeshpy.saveMesh(result_mesh, "offsetMesh.stl")

• C

  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MRMeshLoad.h>
  #include <MRMeshC/MRMeshSave.h>
  #include <MRMeshC/MROffset.h>
  #include <MRMeshC/MRString.h>
   
  #include <math.h>
  #include <stdio.h>
  #include <stdlib.h>
   
  #define APPROX_VOXEL_COUNT 10000000.f
   
  // 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 != 3 && argc != 4 )
      {
          fprintf( stderr, "Usage: %s OFFSET_VALUE INPUT [OUTPUT]", argv[0] );
          goto out;
      }
   
      float offsetValue = atof( argv[1] );
      if ( !isfinite( offsetValue ) )
      {
          fprintf( stderr, "Incorrect offset value: %s", argv[1] );
          goto out;
      }
   
      const char* input = argv[2];
      const char* output = ( argc == 3 ) ? argv[2] : argv[3];
   
      // error messages will be stored here
      MRString* errorString = NULL;
   
      MRMesh* inputMesh = mrMeshLoadFromAnySupportedFormat( input, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to load inputMesh: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out;
      }
   
      // offset functions can also be applied to separate mesh components rather than to the whole mesh
      // this is not our case, so the region is set to NULL
      MRMeshPart inputMeshPart = (MRMeshPart){
          .mesh = inputMesh,
          .region = NULL,
      };
   
      MROffsetParameters params = mrOffsetParametersNew();
      // calculate voxel size depending on desired accuracy and/or memory consumption
      params.voxelSize = mrSuggestVoxelSize( inputMeshPart, APPROX_VOXEL_COUNT );
      // set optional progress callback
      params.callBack = onProgress;
   
      MRMesh* outputMesh = mrOffsetMesh( inputMeshPart, offsetValue, &params, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to perform offset: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out_inputMesh;
      }
   
      mrMeshSaveToAnySupportedFormat( outputMesh, output, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to save inputMesh: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out_outputMesh;
      }
   
      rc = EXIT_SUCCESS;
  out_outputMesh:
      mrMeshFree( outputMesh );
  out_inputMesh:
      mrMeshFree( inputMesh );
  out:
      return rc;
  }

• C#

  using MR.DotNet;
  using System;
  using System.Globalization;
  using System.Reflection;
   
  class Program
  {
      static void Main(string[] args)
      {
          if (args.Length != 2 && args.Length != 3)
          {           
              Console.WriteLine("Usage: {0} OFFSET_VALUE INPUT [OUTPUT]", Assembly.GetExecutingAssembly().GetName().Name);
              return;
          }
   
          try
          {
              float offsetValue = float.Parse(args[0],
                        System.Globalization.NumberStyles.AllowThousands,
                        CultureInfo.InvariantCulture);
   
              string input = args[1];
              string output = args.Length == 3 ? args[2] : args[1];
   
              MeshPart mp = new MeshPart();
              mp.mesh = Mesh.FromAnySupportedFormat( args[1] );
   
              OffsetParameters op = new OffsetParameters();
              op.voxelSize = Offset.SuggestVoxelSize(mp, 1e6f);
   
              var result = Offset.OffsetMesh(mp, offsetValue, op);
   
              Mesh.ToAnySupportedFormat(result, output);
          }
          catch (Exception e)
          {
              Console.WriteLine("Error: {0}", e.Message);
          }
      }
  }