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;
  }

  Source meshes
  
  Boolean intersection
  
• 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")

  Source meshes
  
  Boolean intersection
  
• C

  #include <MRMeshC/MRMesh.h>
  #include <MRMeshC/MRMakeSphereMesh.h>
  #include <MRMeshC/MRVector3.h>
  #include <MRMeshC/MRAffineXf.h>
  #include <MRMeshC/MRMeshBoolean.h>
  #include <MRMeshC/MRMeshSave.h>
  #include <MRMeshC/MRString.h>
   
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  int main( int argc, char* argv[] )
  {
      int rc = EXIT_FAILURE;
   
      // error messages will be stored here
      MRString* errorString = NULL;
   
      // create first sphere with radius of 1 unit
      MRMakeUVSphereParameters makeParams = mrMakeUvSphereParametersNew();
      makeParams.radius = 1.f;
      makeParams.horizontalResolution = 64;
      makeParams.verticalResolution = 64;
      MRMesh* sphere1 = mrMakeUVSphere( &makeParams );
   
      // create second sphere by cloning the first sphere and moving it in X direction
      MRMesh* sphere2 = mrMeshCopy( sphere1 );
      MRVector3f xfTranslation = mrVector3fDiagonal( 0.f );
      xfTranslation.x = 0.7f;
      MRAffineXf3f xf = mrAffineXf3fTranslation( &xfTranslation );
      mrMeshTransform( sphere2, &xf, NULL );
   
      // perform the boolean operation
      MRBooleanParameters params = mrBooleanParametersNew();
      MRBooleanResult result = mrBoolean( sphere1, sphere2, MRBooleanOperationIntersection, &params );
      if ( result.errorString )
      {
          fprintf( stderr, "Failed to perform boolean: %s", mrStringData( result.errorString ) );
          mrStringFree( errorString );
          goto out;
      }
   
      // save result to STL file
      MRSaveSettings saveSettings = mrSaveSettingsNew();
      mrMeshSaveToAnySupportedFormat( result.mesh, "out_boolean.stl", &saveSettings, &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:
      mrMeshFree( sphere2 );
      mrMeshFree( sphere1 );
      return rc;
  }

  Source meshes
  
  Boolean intersection
  
• C#

  using System.Reflection;
  using static MR.DotNet;
   
  public class MeshBooleanExample
  {
      public static void Run(string[] args)
      {
          if (args.Length != 3)
          {
              Console.WriteLine("Usage: {0} MeshBooleanExample INPUT1 INPUT2", Assembly.GetExecutingAssembly().GetName().Name);
              return;
          }
   
          try
          {
              // load mesh
              Mesh meshA = MeshLoad.FromAnySupportedFormat(args[1]);
              Mesh meshB = MeshLoad.FromAnySupportedFormat(args[2]);
   
              // perform boolean operation
              var res = Boolean(meshA, meshB, BooleanOperation.Intersection);
   
              // save result to STL file
              MeshSave.ToAnySupportedFormat(res.mesh, "out_boolean.stl");
          }
          catch (Exception e)
          {
              Console.WriteLine("Error: {0}", e.Message);
          }
      }
  }

  Source meshes
  
  Boolean intersection