Mesh Boolean

Example of boolean operation

• C++

  #include <MRMesh/MRMesh.h>
  #include <MRMesh/MRMeshBoolean.h>
  #include <MRMesh/MRMeshSave.h>
  #include <MRMesh/MRUVSphere.h>
   
  #include <iostream>
   
  int main()
  {
      // create first sphere with radius of 1 unit
      MR::Mesh sphere1 = MR::makeUVSphere( 1.0f, 64, 64 );
   
      // create second sphere by cloning the first sphere and moving it in X direction
      MR::Mesh sphere2 = sphere1;
      MR::AffineXf3f xf = MR::AffineXf3f::translation( MR::Vector3f( 0.7f, 0.0f, 0.0f ) );
      sphere2.transform( xf );
   
      // perform boolean operation
      MR::BooleanResult result = MR::boolean( sphere1, sphere2, MR::BooleanOperation::Intersection );
      MR::Mesh resultMesh = *result;
      if ( !result.valid() )
          std::cerr << result.errorString << std::endl;
   
      // save result to STL file
      MR::MeshSave::toAnySupportedFormat( resultMesh, "out_boolean.stl" );
   
      return 0;
  }

• Python

  import meshlib.mrmeshpy as mrmeshpy
   
  # create first sphere with radius of 1 unit
  sphere1 = mrmeshpy.makeUVSphere(1.0, 64, 64)
   
  # create second sphere by cloning the first sphere and moving it in X direction
  sphere2 = mrmeshpy.copyMesh(sphere1)
  xf = mrmeshpy.AffineXf3f.translation(mrmeshpy.Vector3f(0.7, 0.0, 0.0))
  sphere2.transform(xf)
   
  # perform boolean operation
  result = mrmeshpy.boolean(sphere1, sphere2, mrmeshpy.BooleanOperation.Intersection)
  result_mesh = result.mesh
  if not result.valid():
      print(result.errorString)
   
  # save result to STL file
  mrmeshpy.saveMesh(result_mesh, "out_boolean.stl")

• C

  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MRMeshBoolean.h>
  #include <MRMeshC/MRMeshLoad.h>
  #include <MRMeshC/MRMeshSave.h>
  #include <MRMeshC/MRString.h>
   
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.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 != 5 )
      {
          fprintf( stderr, "Usage: %s { unite | intersect } INPUT1 INPUT2 OUTPUT", argv[0] );
          goto out;
      }
   
      MRBooleanOperation op;
      if ( strcmp( argv[1], "unite" ) == 0 )
          op = MRBooleanOperationUnion;
      else if ( strcmp( argv[1], "intersect" ) == 0 )
          op = MRBooleanOperationIntersection;
      else
      {
          fprintf( stderr, "Incorrect operation: %s", argv[1] );
          goto out;
      }
   
      const char* input1 = argv[2];
      const char* input2 = argv[3];
      const char* output = argv[4];
   
      // error messages will be stored here
      MRString* errorString = NULL;
   
      MRMesh* mesh1 = mrMeshLoadFromAnySupportedFormat( input1, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to load mesh 1: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out;
      }
   
      MRMesh* mesh2 = mrMeshLoadFromAnySupportedFormat( input2, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to load mesh 2: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out_mesh1;
      }
   
      // you can set some parameters for boolean, e.g. progress callback
      MRBooleanParameters params = mrBooleanParametersNew();
      params.cb = onProgress;
      // perform the boolean operation
      MRBooleanResult result = mrBoolean( mesh1, mesh2, op, &params );
      if ( result.errorString )
      {
          fprintf( stderr, "Failed to perform boolean: %s", mrStringData( result.errorString ) );
          mrStringFree( errorString );
          goto out_mesh2;
      }
   
      mrMeshSaveToAnySupportedFormat( result.mesh, output, &errorString );
      if ( errorString )
      {
          fprintf( stderr, "Failed to save result: %s", mrStringData( errorString ) );
          mrStringFree( errorString );
          goto out_result;
      }
   
      rc = EXIT_SUCCESS;
  out_result:
      mrMeshFree( result.mesh );
  out_mesh2:
      mrMeshFree( mesh2 );
  out_mesh1:
      mrMeshFree( mesh1 );
  out:
      return rc;
  }

• C#

  using MR.DotNet;
  using System;
  using System.Reflection;
   
  class Program
  {
      static void Main(string[] args)
      {
          if (args.Length != 4)
              Console.WriteLine( "Usage: {0}  {{unite | intersect}}  INPUT1 INPUT2 OUTPUT", Assembly.GetExecutingAssembly().GetName().Name );
   
          BooleanOperation op;
          switch (args[0])
          {
              case "unite":
                  op = BooleanOperation.Union;
                  break;
              case "intersect":
                  op = BooleanOperation.Intersection;
                  break;
              default:
                  Console.WriteLine( "Unknown operation: {0}", args[0] );
                  return;
          }
   
          try
          {
              Mesh meshA = Mesh.FromAnySupportedFormat(args[1]);
              Mesh meshB = Mesh.FromAnySupportedFormat(args[2]);
              var res = MeshBoolean.Boolean(meshA, meshB, op);
              Mesh.ToAnySupportedFormat(res.mesh, args[3]);
          }
          catch (Exception e)
          {
              Console.WriteLine( "Error: {0}", e.Message );
          }
      }
  }