A small application for converting STEP files (demo_CAS_converter.cpp)

Tutorial that teaches how to use the CASCADE module to import, convert and visualize STEP models.

// =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Alessandro Tasora, Dario Fusai
// =============================================================================
//
// A small interactive editor to test the convex decomposition settings 
// and the STEP conversion features of OpenCASCADE library.
//
// =============================================================================
 
#include "chrono/core/ChRealtimeStep.h"
#include "chrono/core/ChRandom.h"
#include "chrono/collision/ChConvexDecomposition.h"
#include "chrono/physics/ChSystemNSC.h"
#include "chrono_irrlicht/ChVisualSystemIrrlicht.h"
 
#include "chrono_cascade/ChCascadeDoc.h"
#include "chrono_cascade/ChCascadeMeshTools.h"
#include "chrono_cascade/ChCascadeIrrMeshTools.h"
 
// Use the namespace of Chrono
using namespace chrono;
using namespace chrono::irrlicht;
using namespace chrono::cascade;
 
// Use the main namespace of Irrlicht
using namespace irr;
 
// Utility global variables
std::shared_ptr<ChTriangleMeshConnected> model_mesh = nullptr;
std::shared_ptr<ChBody> original_body = nullptr;
std::shared_ptr<ChBody> decomposition_body = nullptr;
ChConvexDecompositionHACDv2 decompositionHACDv2;
int hacd_maxhullcount;
int hacd_maxhullmerge;
int hacd_maxhullvertexes;
double hacd_concavity;
double hacd_smallclusterthreshold;
double hacd_fusetolerance;
 
// Load a triangle mesh using Irrlicht importer
void LoadModel(ChVisualSystemIrrlicht* vis, const char* filename) {
    model_mesh = ChTriangleMeshConnected::CreateFromWavefrontFile(filename);
 
    auto model_visshape = chrono_types::make_shared<ChVisualShapeTriangleMesh>(model_mesh, false);
    original_body->AddVisualShape(model_visshape);
    vis->BindItem(original_body);
}
 
// Load STEP model using OpenCASCADE
void LoadStepModel(ChVisualSystemIrrlicht* vis, const char* filename) {
    std::cout << "Loading the .STEP model..." << std::endl;
 
    ChCascadeDoc cas_doc;
    bool load_ok = cas_doc.LoadSTEP(filename);
 
    if (load_ok) {
        // Print hierarchy on screen
        cas_doc.Dump(std::cout);
 
        // Find all shapes and get as a single compound
        TopoDS_Shape shape;
        cas_doc.GetRootShape(shape);
 
        if (!shape.IsNull()) {
            model_mesh = chrono_types::make_shared<ChTriangleMeshConnected>();
            ChCascadeMeshTools::FillTriangleMeshFromCascade(*model_mesh, shape, ChCascadeTriangulate());
 
            auto model_visshape = chrono_types::make_shared<ChVisualShapeTriangleMesh>(model_mesh, false);
            original_body->AddVisualShape(model_visshape);
            vis->BindItem(original_body);
 
            std::cout << " ...done" << std::endl;
        }
 
    } else {
        std::cerr << "Error: unable to load .STEP file\n";
    }
}
 
// Perform convex decomposition using HACDv2
void DecomposeModel(ChVisualSystemIrrlicht* vis) {
    if (!model_mesh)
        return;
 
    // Perform the convex decomposition using the desired parameters.
    decompositionHACDv2.Reset();
    decompositionHACDv2.AddTriangleMesh(*model_mesh);
 
    decompositionHACDv2.SetParameters(hacd_maxhullcount, hacd_maxhullmerge, hacd_maxhullvertexes, (float)hacd_concavity,
                                      (float)hacd_smallclusterthreshold, (float)hacd_fusetolerance);
    decompositionHACDv2.ComputeConvexDecomposition();
    std::cout << "Convex decomposition completed\n";
    std::cout << "Number of decomposed convex hulls: " << decompositionHACDv2.GetHullCount() << "\n";
 
    // Visualize the resulting convex decomposition by creating many colored meshes, each per convex hull.
    decomposition_body = chrono_types::make_shared<ChBody>();
    for (unsigned int j = 0; j < decompositionHACDv2.GetHullCount(); j++) {
        auto chmesh_hull = chrono_types::make_shared<ChTriangleMeshSoup>();
        decompositionHACDv2.GetConvexHullResult(j, *chmesh_hull);
 
        auto trimesh_connected = chrono_types::make_shared<ChTriangleMeshConnected>();
        for (const auto& tri : chmesh_hull->GetTriangles()) {
            trimesh_connected->AddTriangle(tri);
        }
 
        auto decomposition_visshape = chrono_types::make_shared<ChVisualShapeTriangleMesh>(trimesh_connected, false);
        ChColor col(0.1 + 0.5 * ChRandom::Get(), 0.3 + 0.2 * ChRandom::Get(), 0.5 * ChRandom::Get());
        decomposition_visshape->SetColor(col);
        decomposition_body->AddVisualShape(decomposition_visshape);
    }
 
    vis->BindItem(decomposition_body);
    vis->UnbindItem(original_body);
}
 
// Save the convex decomposition as Wavefront .obj to a file
void SaveHullsWavefront(ChVisualSystemIrrlicht* vis, const std::string& filename) {
    try {
        std::ofstream decomposed_objfile(filename);
        decompositionHACDv2.WriteConvexHullsAsWavefrontObj(decomposed_objfile);
        std::cout << "Saved Wavefront file: " << filename << "\n";
    } catch (...) {
        vis->GetGUIEnvironment()->addMessageBox(L"Save file error", L"Impossible to write into file.");
    }
}
 
// Save the convex decomposition as chulls list to an .obj file
void SaveHullsChulls(ChVisualSystemIrrlicht* vis, const std::string& filename) {
    try {
        std::ofstream decomposed_objfile(filename);
        decompositionHACDv2.WriteConvexHullsAsChullsFile(decomposed_objfile);
        std::cout << "Saved chulls file: " << filename << "\n";
    } catch (...) {
        vis->GetGUIEnvironment()->addMessageBox(L"Save file error", L"Impossible to write into file.");
    }
}
 
// Define an Irrlicht event receiver class which will be used to manage input from the GUI
class MyEventReceiver : public IEventReceiver {
  public:
    MyEventReceiver(ChVisualSystemIrrlicht* vsys) : vis(vsys) {
        vis->GetDevice()->setEventReceiver(this);
 
        // create menu
        menu = vis->GetGUIEnvironment()->addMenu();
        menu->addItem(L"File", -1, true, true);
        menu->addItem(L"View", -1, true, true);
 
        gui::IGUIContextMenu* submenu;
        submenu = menu->getSubMenu(0);
        submenu->addItem(L"Load OBJ mesh...", 90);
        submenu->addItem(L"Load STEP model...", 95);
        submenu->addItem(L"Save convex hulls (.obj)", 91);
        submenu->addItem(L"Save convex hulls (.chulls)", 96);
        submenu->addSeparator();
        submenu->addItem(L"Quit", 92);
        submenu = menu->getSubMenu(1);
        submenu->addItem(L"View model", 93);
        submenu->addItem(L"View decomposition", 94);
 
        text_algo_type =
            vis->GetGUIEnvironment()->addStaticText(L"HACDv2 algorithm", core::rect<s32>(510, 35, 650, 50), false);
 
        // ..add a GUI
        edit_hacd_maxhullcount = vis->GetGUIEnvironment()->addEditBox(
            irr::core::stringw((int)hacd_maxhullcount).c_str(), core::rect<s32>(510, 60, 650, 75), true, 0, 121);
        text_hacd_maxhullcount =
            vis->GetGUIEnvironment()->addStaticText(L"Max. hull count ", core::rect<s32>(650, 60, 750, 75), false);
 
        // ..add a GUI
        edit_hacd_maxhullmerge = vis->GetGUIEnvironment()->addEditBox(
            irr::core::stringw((int)hacd_maxhullmerge).c_str(), core::rect<s32>(510, 85, 650, 100), true, 0, 122);
        text_hacd_maxhullmerge =
            vis->GetGUIEnvironment()->addStaticText(L"Max. hull merge ", core::rect<s32>(650, 85, 750, 100), false);
 
        // ..add a GUI
        edit_hacd_maxhullvertexes = vis->GetGUIEnvironment()->addEditBox(
            irr::core::stringw((int)hacd_maxhullvertexes).c_str(), core::rect<s32>(510, 110, 650, 125), true, 0, 123);
        text_hacd_maxhullvertexes = vis->GetGUIEnvironment()->addStaticText(L"Max. vertices per hull",
                                                                            core::rect<s32>(650, 110, 750, 125), false);
 
        // ..add a GUI
        edit_hacd_concavity = vis->GetGUIEnvironment()->addEditBox(irr::core::stringw(hacd_concavity).c_str(),
                                                                   core::rect<s32>(510, 135, 650, 150), true, 0, 124);
        text_hacd_concavity = vis->GetGUIEnvironment()->addStaticText(L"Max. concavity (0..1)",
                                                                      core::rect<s32>(650, 135, 750, 150), false);
 
        // ..add a GUI
        edit_hacd_smallclusterthreshold = vis->GetGUIEnvironment()->addEditBox(
            irr::core::stringw(hacd_smallclusterthreshold).c_str(), core::rect<s32>(510, 160, 650, 175), true, 0, 125);
        text_hacd_smallclusterthreshold = vis->GetGUIEnvironment()->addStaticText(
            L"Small cluster threshold", core::rect<s32>(650, 160, 750, 175), false);
 
        // ..add a GUI
        edit_hacd_fusetolerance = vis->GetGUIEnvironment()->addEditBox(
            irr::core::stringw(hacd_fusetolerance).c_str(), core::rect<s32>(510, 185, 650, 200), true, 0, 126);
        text_hacd_fusetolerance = vis->GetGUIEnvironment()->addStaticText(L"Vertex fuse tolerance",
                                                                          core::rect<s32>(650, 185, 750, 200), false);
 
        // .. add buttons..
        button_decompose = vis->GetGUIEnvironment()->addButton(core::rect<s32>(510, 210, 650, 225), 0, 106,
                                                               L"Decompose", L"Perform convex decomposition");
 
        text_hacd_maxhullcount->setVisible(true);
        edit_hacd_maxhullcount->setVisible(true);
        text_hacd_maxhullmerge->setVisible(true);
        edit_hacd_maxhullmerge->setVisible(true);
        text_hacd_maxhullvertexes->setVisible(true);
        edit_hacd_maxhullvertexes->setVisible(true);
        text_hacd_concavity->setVisible(true);
        edit_hacd_concavity->setVisible(true);
        text_hacd_smallclusterthreshold->setVisible(true);
        edit_hacd_smallclusterthreshold->setVisible(true);
        text_hacd_fusetolerance->setVisible(true);
        edit_hacd_fusetolerance->setVisible(true);
    }
 
    bool OnEvent(const SEvent& event) {
        // check if user moved the sliders with mouse..
        if (event.EventType == EET_GUI_EVENT) {
            s32 id = event.GUIEvent.Caller->getID();
            auto env = vis->GetGUIEnvironment();
 
            switch (event.GUIEvent.EventType) {
                case gui::EGET_MENU_ITEM_SELECTED: {
                    // a menu item was clicked
 
                    menu = (gui::IGUIContextMenu*)event.GUIEvent.Caller;
                    id = menu->getItemCommandId(menu->getSelectedItem());
 
                    switch (id) {
                        case 90:
                            env->addFileOpenDialog(L"Load a mesh file, in .OBJ/.X/.MAX format", true, 0, 80);
                            break;
                        case 95:
                            env->addFileOpenDialog(L"Load a 3D CAD model, in STEP format", true, 0, 85);
                            break;
                        case 91:
                            env->addFileOpenDialog(L"Save decomposed convex hulls in .obj 3D format", true, 0, 81);
                            break;
                        case 96:
                            env->addFileOpenDialog(L"Save decomposed convex hulls in .chulls 3D format", true, 0, 86);
                            break;
                        case 92:  // File -> Quit
                            vis->GetDevice()->closeDevice();
                            break;
                        case 93:  // view model
                            vis->BindItem(original_body);
                            vis->UnbindItem(decomposition_body);
                            break;
                        case 94:  // view decomposition
                            vis->BindItem(decomposition_body);
                            vis->UnbindItem(original_body);
                            break;
                    }
                    break;
                }
 
                case gui::EGET_FILE_SELECTED: {
                    // load the model file, selected in the file open dialog
                    gui::IGUIFileOpenDialog* dialog = (gui::IGUIFileOpenDialog*)event.GUIEvent.Caller;
 
                    switch (id) {
                        case 80:
                            LoadModel(vis, core::stringc(dialog->getFileName()).c_str());
                            break;
                        case 85:
                            LoadStepModel(vis, core::stringc(dialog->getFileName()).c_str());
                            break;
                        case 81:
                            SaveHullsWavefront(vis, core::stringc(dialog->getFileName()).c_str());
                            break;
                        case 86:
                            SaveHullsChulls(vis, core::stringc(dialog->getFileName()).c_str());
                            break;
                    }
                } break;
 
                case gui::EGET_EDITBOX_ENTER: {
                    // load the model file, selected in the file open dialog
                    gui::IGUIEditBox* medit = (gui::IGUIEditBox*)event.GUIEvent.Caller;
 
                    switch (id) {
                        case 122:
                            hacd_maxhullmerge = std::atoi(irr::core::stringc(medit->getText()).c_str());
                            medit->setText(irr::core::stringw(hacd_maxhullmerge).c_str());
                            break;
                        case 123:
                            hacd_maxhullvertexes = std::atoi(irr::core::stringc(medit->getText()).c_str());
                            medit->setText(irr::core::stringw(hacd_maxhullvertexes).c_str());
                            break;
                        case 124:
                            hacd_concavity = std::atof(irr::core::stringc(medit->getText()).c_str());
                            medit->setText(irr::core::stringw(hacd_concavity).c_str());
                            break;
                        case 125:
                            hacd_smallclusterthreshold = std::atof(irr::core::stringc(medit->getText()).c_str());
                            medit->setText(irr::core::stringw(hacd_smallclusterthreshold).c_str());
                            break;
                        case 126:
                            hacd_fusetolerance = std::atof(irr::core::stringc(medit->getText()).c_str());
                            medit->setText(irr::core::stringw(hacd_fusetolerance).c_str());
                            break;
                    }
                } break;
 
                case gui::EGET_BUTTON_CLICKED: {
                    switch (id) {
                        case 106:
                            DecomposeModel(vis);
                            return true;
                        default:
                            return false;
                    }
                    break;
                }
 
                default:
                    break;
            }
        }
 
        return false;
    }
 
  private:
    ChVisualSystemIrrlicht* vis;
 
    gui::IGUIContextMenu* menu;
    gui::IGUIButton* button_decompose;
    gui::IGUIStaticText* text_algo_type;
    gui::IGUIStaticText* text_hacd_maxhullcount;
    gui::IGUIEditBox* edit_hacd_maxhullcount;
    gui::IGUIStaticText* text_hacd_maxhullmerge;
    gui::IGUIEditBox* edit_hacd_maxhullmerge;
    gui::IGUIStaticText* text_hacd_maxhullvertexes;
    gui::IGUIEditBox* edit_hacd_maxhullvertexes;
    gui::IGUIStaticText* text_hacd_concavity;
    gui::IGUIEditBox* edit_hacd_concavity;
    gui::IGUIStaticText* text_hacd_smallclusterthreshold;
    gui::IGUIEditBox* edit_hacd_smallclusterthreshold;
    gui::IGUIStaticText* text_hacd_fusetolerance;
    gui::IGUIEditBox* edit_hacd_fusetolerance;
};
 
// Main program
int main(int argc, char* argv[]) {
    std::cout << "Copyright (c) 2017 projectchrono.org\nChrono version: " << CHRONO_VERSION << std::endl;
 
    // Create Chrono physical system
    ChSystemNSC sys;
    sys.SetGravitationalAcceleration({0, 0, 0});
 
    original_body = chrono_types::make_shared<ChBody>();
    original_body->SetFixed(true);
    sys.Add(original_body);
 
    decomposition_body = chrono_types::make_shared<ChBody>();
    decomposition_body->SetFixed(true);
    sys.Add(decomposition_body);
 
    // Default settings
    hacd_maxhullcount = 512;
    hacd_maxhullmerge = 256;
    hacd_maxhullvertexes = 64;
    hacd_concavity = 0.2;
    hacd_smallclusterthreshold = 0.0;
    hacd_fusetolerance = 1e-9;
 
    // Create the Irrlicht visualization system
    auto vis = chrono_types::make_shared<ChVisualSystemIrrlicht>();
    vis->AttachSystem(&sys);
    vis->SetWindowSize(800, 600);
    vis->SetWindowTitle("Convex decomposition of a mesh");
    vis->Initialize();
    vis->AddLogo();
    vis->AddSkyBox();
    vis->AddCamera(ChVector3d(0, 1.5, -2));
    vis->AddLight(ChVector3d(30, 100, 30), 200, ChColor(0.7f, 0.7f, 0.7f));
    vis->AddLight(ChVector3d(30, -80, -30), 130, ChColor(0.7f, 0.8f, 0.8f));
 
    // Create a custom event receiver for a GUI
    MyEventReceiver receiver(vis.get());
    vis->AddUserEventReceiver(&receiver);
 
    // Rendering loop
    while (vis->Run()) {
        vis->BeginScene();
        vis->Render();
        vis->EndScene();
    }
 
    return 0;
}