Loading and saving mesh files

Following code presents example of loading and saving mesh file

• C++

  #include <MRMesh/MRMesh.h>
  #include <MRMesh/MRMeshLoad.h>
  #include <MRMesh/MRMeshSave.h>
  #include <MRIOExtras/MRCtm.h>
   
  #include <iostream>
   
  int main()
  {
      // Load mesh
      std::filesystem::path inFilePath = "mesh.stl";
      auto loadRes = MR::MeshLoad::fromAnySupportedFormat( inFilePath );
      if ( !loadRes.has_value() )
      {
          std::cerr << loadRes.error() << std::endl;
          return 1;
      }
   
      // Save mesh
      std::filesystem::path outFilePath = "mesh.ply";
      auto saveRes = MR::MeshSave::toAnySupportedFormat( loadRes.value(), outFilePath );
      if ( !saveRes.has_value() )
      {
          std::cerr << saveRes.error() << std::endl;
          return 1;
      }
   
      // More mesh formats are available in the MRIOExtras library
      std::filesystem::path outCtmFilePath = "mesh.ctm";
      saveRes = MR::MeshSave::toCtm( loadRes.value(), outCtmFilePath );
      if ( !saveRes.has_value() )
      {
          std::cerr << saveRes.error() << std::endl;
          return 1;
      }
      
      return 0;
  }

  Further examples won't check return values for sake of clarity

  See also

  MR::MeshLoad

  MR::MeshSave

• Python

  import meshlib.mrmeshpy as mrmeshpy
  import os
  import sys
   
  # This example needs an input mesh; create one if you do not have it already
  if not os.path.exists("mesh.stl"):
      mrmeshpy.saveMesh(mrmeshpy.makeCube(), "mesh.stl")
   
  # Load mesh
  try:
      mesh = mrmeshpy.loadMesh("mesh.stl")
  except RuntimeError as e:
      print(f"Failed to load mesh: {e}")
      sys.exit(1)
   
  print(f"Loaded {mesh.topology.numValidVerts()} vertices, "
        f"{mesh.topology.numValidFaces()} faces")
   
  # Save mesh
  try:
      mrmeshpy.saveMesh(mesh, "mesh.ply")
  except RuntimeError as e:
      print(f"Failed to save mesh: {e}")
      sys.exit(1)
   
  print("Saved mesh.ply")

• C

  #include <MRCMesh/MRMesh.h>
  #include <MRCMesh/MRMeshLoad.h>
  #include <MRCMesh/MRMeshSave.h>
  #include <MRCMesh/MRMeshTopology.h>
  #include <MRCMesh/MRString.h>
  #include <MRCMisc/expected_MR_Mesh_std_string.h>
  #include <MRCMisc/expected_void_std_string.h>
  #include <MRCMisc/std_string.h>
   
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  int main( int argc, char** argv )
  {
      int rc = EXIT_FAILURE;
   
      const char* inputPath = argc > 1 ? argv[1] : "mesh.stl";
      const char* outputPath = argc > 2 ? argv[2] : "mesh.ply";
   
      // Load mesh.
      MR_expected_MR_Mesh_std_string* meshEx = MR_MeshLoad_fromAnySupportedFormat_2( inputPath, NULL, NULL );
      MR_Mesh* mesh = MR_expected_MR_Mesh_std_string_value_mut( meshEx );
   
      if ( !mesh )
      {
          fprintf( stderr, "Failed to load mesh: %s\n", MR_std_string_data( MR_expected_MR_Mesh_std_string_error( meshEx ) ) );
          if ( argc <= 1 )
              fprintf( stderr, "Usage: MeshLoadSave [input mesh] [output mesh]\n" );
          goto fail_load;
      }
   
      // Save mesh.
      MR_expected_void_std_string* saveEx = MR_MeshSave_toAnySupportedFormat_3( mesh, outputPath, 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;
      }
   
      rc = EXIT_SUCCESS;
  fail_save:
      MR_expected_void_std_string_Destroy( saveEx );
  fail_load:
      MR_expected_MR_Mesh_std_string_Destroy( meshEx );
      return rc;
  }

• C#

  public class MeshLoadSaveExample
  {
      public static void Main(string[] args)
      {
          try
          {
              // This example needs an input mesh; create one if you do not have it already
              if (!File.Exists("mesh.stl"))
                  MR.MeshSave.toAnySupportedFormat(MR.makeCube(), "mesh.stl");
   
              // Load mesh
              var mesh = MR.MeshLoad.fromAnySupportedFormat("mesh.stl");
   
              // Save it in another format
              MR.MeshSave.toAnySupportedFormat(mesh, "mesh.ply");
          }
          catch (Exception e)
          {
              Console.WriteLine("Error: {0}", e.Message);
          }
      }
  }

• JavaScript

  import createMeshLib from '@meshinspector/meshlib';
   
  const ml = await createMeshLib();
   
  // Load mesh
  using mesh = ml.MeshLoad.fromAnySupportedFormat('mesh.stl');
   
  // Save mesh (the format is chosen from the file extension)
  ml.MeshSave.toAnySupportedFormat(mesh, 'mesh.ply');

  Note

  The using declaration requires Node.js 24+ or a modern browser. On older runtimes, call .delete() on each object instead (see Memory Management in the JavaScript Setup Guide).