Slic3r::Step Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/STEP.hpp>

Collaboration diagram for Slic3r::Step:

Public Types
enum class	Step_Status {   LOAD_SUCCESS , LOAD_ERROR , CANCEL , MESH_SUCCESS ,   MESH_ERROR }

Public Member Functions
	Step (boost::filesystem::path path, ImportStepProgressFn stepFn=nullptr, StepIsUtf8Fn isUtf8Fn=nullptr)
	Step (std::string path, ImportStepProgressFn stepFn=nullptr, StepIsUtf8Fn isUtf8Fn=nullptr)
	~Step ()
Step_Status	load ()
unsigned int	get_triangle_num (double linear_deflection, double angle_deflection)
unsigned int	get_triangle_num_tbb (double linear_deflection, double angle_deflection)
void	clean_mesh_data ()
Step_Status	mesh (Model *model, bool &is_cancel, bool isSplitCompound, double linear_deflection=0.003, double angle_deflection=0.5)
void	update_process (int load_stage, int current, int total, bool &cancel)

Public Attributes
std::atomic< bool >	m_stop_mesh {false}

Private Member Functions
	Handle (XCAFApp_Application) m_app
	Handle (TDocStd_Document) m_doc
	Handle (XCAFDoc_ShapeTool) m_shape_tool

Private Attributes
std::string	m_path
ImportStepProgressFn	m_stepFn
StepIsUtf8Fn	m_utf8Fn
std::vector< NamedSolid >	m_name_solids

Detailed Description

Member Enumeration Documentation

Step_Status

enum class Slic3r::Step::Step_Status

strong

Enumerator
LOAD_SUCCESS
LOAD_ERROR
CANCEL
MESH_SUCCESS
MESH_ERROR

                           {
        LOAD_SUCCESS,
        LOAD_ERROR,
        CANCEL,
        MESH_SUCCESS,
        MESH_ERROR
    };

Constructor & Destructor Documentation

Step() [1/2]

Slic3r::Step::Step	(	boost::filesystem::path	path,
		ImportStepProgressFn	stepFn = nullptr,
		StepIsUtf8Fn	isUtf8Fn = nullptr )

Referenced by Step().

Here is the caller graph for this function:

Step() [2/2]

Slic3r::Step::Step	(	std::string	path,
		ImportStepProgressFn	stepFn = nullptr,
		StepIsUtf8Fn	isUtf8Fn = nullptr )

                                                                             :
    m_path(path),
    m_stepFn(stepFn),
    m_utf8Fn(isUtf8Fn)
{
    m_app->NewDocument(TCollection_ExtendedString("BinXCAF"), m_doc);
}

References Step(), m_path, m_stepFn, and m_utf8Fn.

Here is the call graph for this function:

~Step()

Slic3r::Step::~Step

(

)

{
    m_app->Close(m_doc);
}

Member Function Documentation

clean_mesh_data()

void Slic3r::Step::clean_mesh_data

(

)

{
    for (const auto& name_solid : m_name_solids) {
        BRepTools::Clean(name_solid.solid);
    }
}

References clean_mesh_data(), and m_name_solids.

Referenced by clean_mesh_data(), get_triangle_num(), and get_triangle_num_tbb().

Here is the call graph for this function:

Here is the caller graph for this function:

get_triangle_num()

unsigned int Slic3r::Step::get_triangle_num	(	double	linear_deflection,
		double	angle_deflection )

{
    unsigned int tri_num = 0;
    try {
        Handle(StepProgressIncdicator) progress = new StepProgressIncdicator(m_stop_mesh);
        clean_mesh_data();
        IMeshTools_Parameters param;
        param.Deflection = linear_deflection;
        param.Angle = angle_deflection;
        param.InParallel = true;
        for (int i = 0; i < m_name_solids.size(); ++i) {
            BRepMesh_IncrementalMesh mesh(m_name_solids[i].solid, param, progress->Start());
            for (TopExp_Explorer anExpSF(m_name_solids[i].solid, TopAbs_FACE); anExpSF.More(); anExpSF.Next()) {
                TopLoc_Location aLoc;
                Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(TopoDS::Face(anExpSF.Current()), aLoc);
                if (!aTriangulation.IsNull()) {
                    tri_num += aTriangulation->NbTriangles();
                }
            }
            if (m_stop_mesh.load()) {
                return 0;
            }
        }
    } catch(const Exception &) {
        return 0;
    }
    
    return tri_num;
}

References clean_mesh_data(), get_triangle_num(), Handle(), m_name_solids, m_stop_mesh, and mesh().

Referenced by get_triangle_num().

Here is the call graph for this function:

Here is the caller graph for this function:

get_triangle_num_tbb()

unsigned int Slic3r::Step::get_triangle_num_tbb	(	double	linear_deflection,
		double	angle_deflection )

{
    unsigned int tri_num = 0;
    clean_mesh_data();
    tbb::parallel_for(tbb::blocked_range<size_t>(0, m_name_solids.size()),
    [&](const tbb::blocked_range<size_t>& range) {
        for (size_t i = range.begin(); i < range.end(); i++) {
            unsigned int solids_tri_num = 0;
            BRepMesh_IncrementalMesh mesh(m_name_solids[i].solid, linear_deflection, false, angle_deflection, true);
            for (TopExp_Explorer anExpSF(m_name_solids[i].solid, TopAbs_FACE); anExpSF.More(); anExpSF.Next()) {
                TopLoc_Location aLoc;
                Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(TopoDS::Face(anExpSF.Current()), aLoc);
                if (!aTriangulation.IsNull()) {
                    solids_tri_num += aTriangulation->NbTriangles();
                }
            }
            m_name_solids[i].tri_face_cout = solids_tri_num;
        }
 
    });
    for (int i = 0; i < m_name_solids.size(); ++i) {
        tri_num += m_name_solids[i].tri_face_cout;
    }
    return tri_num;
}

References clean_mesh_data(), get_triangle_num_tbb(), m_name_solids, and Slic3r::range().

Referenced by get_triangle_num_tbb().

Here is the call graph for this function:

Here is the caller graph for this function:

Handle() [1/3]

Slic3r::Step::Handle ( TDocStd_Document )

private

Handle() [2/3]

Slic3r::Step::Handle ( XCAFApp_Application )

private

Referenced by get_triangle_num(), and load().

Here is the caller graph for this function:

Handle() [3/3]

Slic3r::Step::Handle ( XCAFDoc_ShapeTool )

private

load()

Step::Step_Status Slic3r::Step::load

(

)

{
    if (!StepPreProcessor::isUtf8File(m_path.c_str()) && m_utf8Fn) {
        m_utf8Fn(false);
        return Step_Status::LOAD_ERROR;
    }
    std::atomic<bool> stop_load_flag = false;
    Handle(StepProgressIncdicator) incdicator = new StepProgressIncdicator(stop_load_flag);
    bool task_result = false;
    bool cb_cancel = false;
    int progress = 0;
    bool load_result = false;
    auto task = new boost::thread(Slic3r::create_thread([&]() -> void {
 
        STEPCAFControl_Reader reader;
        reader.SetNameMode(true);
        IFSelect_ReturnStatus stat = reader.ReadFile(m_path.c_str());
        if (cb_cancel) return;
        progress = 3;
        if (stat != IFSelect_RetDone || !reader.Transfer(m_doc, incdicator->Start())) {
            load_result = false;
            task_result = true;
            return;
        }
        if (cb_cancel) return;
        progress = 6;
        m_shape_tool = XCAFDoc_DocumentTool::ShapeTool(m_doc->Main());
        NCollection_Sequence<TDF_Label> topLevelShapes;
        m_shape_tool->GetFreeShapes(topLevelShapes);
        unsigned int id{ 1 };
        int topShapeLength = topLevelShapes.Length() + 1;
        for (int iLabel = 1; iLabel < topShapeLength; ++iLabel) {
            if (cb_cancel) return;
            getNamedSolids(TopLoc_Location{}, "", id, m_shape_tool, topLevelShapes.Value(iLabel), m_name_solids);
        }
        progress = 10;
        load_result = true;
        task_result = true;
    }));
    while (!task_result) {
        boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
        update_process(LOAD_STEP_STAGE_READ_FILE, progress, 10, cb_cancel);
        if (cb_cancel) {
            stop_load_flag.store(true);
            if (task) {
                if (task->joinable()) {
                    task->join();
                    delete task;
                }
            }
            return Step_Status::CANCEL;
        }
    }
    if (task){
        if (task->joinable()) {
            task->join();
            delete task;
        }
    }
    if (load_result) {
        return Step_Status::LOAD_SUCCESS;
    }else {
        return Step_Status::LOAD_ERROR;
    }
    
}

References CANCEL, Slic3r::create_thread(), Slic3r::getNamedSolids(), Handle(), Slic3r::StepPreProcessor::isUtf8File(), LOAD_ERROR, Slic3r::LOAD_STEP_STAGE_READ_FILE, LOAD_SUCCESS, m_name_solids, m_path, m_utf8Fn, and update_process().

Referenced by Slic3r::Model::read_from_step().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh()

Step::Step_Status Slic3r::Step::mesh	(	Model *	model,
		bool &	is_cancel,
		bool	isSplitCompound,
		double	linear_deflection = 0.003,
		double	angle_deflection = 0.5 )

{
    bool task_result = false;
    bool cb_cancel = false;
    float progress = .0;
    std::atomic<int> meshed_solid_num = 0;
    std::vector<NamedSolid> namedSolids;
    float progress_2 = .0;
    ModelObject* new_object = model->add_object();
    const char* last_slash = strrchr(m_path.c_str(), DIR_SEPARATOR);
    new_object->name.assign((last_slash == nullptr) ? m_path.c_str() : last_slash + 1);
    new_object->input_file = m_path.c_str();
 
    auto task = new boost::thread(Slic3r::create_thread([&]() -> void {
        NCollection_Sequence<TDF_Label> topLevelShapes;
        m_shape_tool->GetFreeShapes(topLevelShapes);
        unsigned int id{ 1 };
        int topShapeLength = topLevelShapes.Length() + 1;
        
        for (int iLabel = 1; iLabel < topShapeLength; ++iLabel) {
            progress = static_cast<double>(iLabel) / (topShapeLength-1);
            if (cb_cancel) {
                return;
            }
            getNamedSolids(TopLoc_Location{}, "", id, m_shape_tool, topLevelShapes.Value(iLabel), namedSolids, isSplitCompound);
        }
 
        std::vector<stl_file> stl;
        stl.resize(namedSolids.size());
        tbb::parallel_for(tbb::blocked_range<size_t>(0, namedSolids.size()), [&](const tbb::blocked_range<size_t>& range) {
            for (size_t i = range.begin(); i < range.end(); i++) {
                BRepMesh_IncrementalMesh mesh(namedSolids[i].solid, linear_deflection, false, angle_deflection, true);
                // BBS: calculate total number of the nodes and triangles
                int aNbNodes = 0;
                int aNbTriangles = 0;
                for (TopExp_Explorer anExpSF(namedSolids[i].solid, TopAbs_FACE); anExpSF.More(); anExpSF.Next()) {
                    TopLoc_Location aLoc;
                    Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(TopoDS::Face(anExpSF.Current()), aLoc);
                    if (!aTriangulation.IsNull()) {
                        aNbNodes += aTriangulation->NbNodes();
                        aNbTriangles += aTriangulation->NbTriangles();
                    }
                }
 
                if (aNbTriangles == 0 || aNbNodes == 0)
                    // BBS: No triangulation on the shape.
                    continue;
 
                stl[i].stats.type = inmemory;
                stl[i].stats.number_of_facets = (uint32_t)aNbTriangles;
                stl[i].stats.original_num_facets = stl[i].stats.number_of_facets;
                stl_allocate(&stl[i]);
 
                std::vector<Vec3f> points;
                points.reserve(aNbNodes);
                // BBS: count faces missing triangulation
                int aNbFacesNoTri = 0;
                // BBS: fill temporary triangulation
                int aNodeOffset = 0;
                int aTriangleOffet = 0;
                for (TopExp_Explorer anExpSF(namedSolids[i].solid, TopAbs_FACE); anExpSF.More(); anExpSF.Next()) {
                    const TopoDS_Shape& aFace = anExpSF.Current();
                    TopLoc_Location     aLoc;
                    Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(TopoDS::Face(aFace), aLoc);
                    if (aTriangulation.IsNull()) {
                        ++aNbFacesNoTri;
                        continue;
                    }
                    // BBS: copy nodes
                    gp_Trsf aTrsf = aLoc.Transformation();
                    for (int aNodeIter = 1; aNodeIter <= aTriangulation->NbNodes(); ++aNodeIter) {
                        gp_Pnt aPnt = aTriangulation->Node(aNodeIter);
                        aPnt.Transform(aTrsf);
                        points.emplace_back(Vec3f(aPnt.X(), aPnt.Y(), aPnt.Z()));
                    }
                    // BBS: copy triangles
                    const TopAbs_Orientation anOrientation = anExpSF.Current().Orientation();
                    int anId[3] = {};
                    for (int aTriIter = 1; aTriIter <= aTriangulation->NbTriangles(); ++aTriIter) {
                        Poly_Triangle aTri = aTriangulation->Triangle(aTriIter);
 
                        aTri.Get(anId[0], anId[1], anId[2]);
                        if (anOrientation == TopAbs_REVERSED)
                            std::swap(anId[1], anId[2]);
                        // BBS: save triangles facets
                        stl_facet facet;
                        facet.vertex[0] = points[anId[0] + aNodeOffset - 1].cast<float>();
                        facet.vertex[1] = points[anId[1] + aNodeOffset - 1].cast<float>();
                        facet.vertex[2] = points[anId[2] + aNodeOffset - 1].cast<float>();
                        facet.extra[0] = 0;
                        facet.extra[1] = 0;
                        stl_normal normal;
                        stl_calculate_normal(normal, &facet);
                        stl_normalize_vector(normal);
                        facet.normal = normal;
                        stl[i].facet_start[aTriangleOffet + aTriIter - 1] = facet;
                    }
 
                    aNodeOffset += aTriangulation->NbNodes();
                    aTriangleOffet += aTriangulation->NbTriangles();
                }
                meshed_solid_num.fetch_add(1, std::memory_order_relaxed);
            }
        });
 
 
        for (size_t i = 0; i < stl.size(); i++) {
            progress_2 = static_cast<float>(i) / stl.size();
            if (cb_cancel)
                return;
 
            //BBS: maybe mesh is empty from step file. Don't add
            if (stl[i].stats.number_of_facets > 0) {
                TriangleMesh triangle_mesh;
                triangle_mesh.from_stl(stl[i]);
                ModelVolume* new_volume = new_object->add_volume(std::move(triangle_mesh));
                new_volume->name = namedSolids[i].name;
                new_volume->source.input_file = m_path.c_str();
                new_volume->source.object_idx = (int)model->objects.size() - 1;
                new_volume->source.volume_idx = (int)new_object->volumes.size() - 1;
            }
        }
        task_result = true;
    }));
 
    while (!task_result) {
        boost::this_thread::sleep_for(boost::chrono::milliseconds(300));
        if (progress_2 > 0) {
            // third progress
            update_process(LOAD_STEP_STAGE_GET_MESH, static_cast<int>(progress_2 * 100), 100, cb_cancel);
        }else {
            if (meshed_solid_num.load()) {
                // second progress
                int meshed_solid = meshed_solid_num.load();
                update_process(LOAD_STEP_STAGE_GET_SOLID, static_cast<int>((float)meshed_solid / namedSolids.size() * 10) + 10, 20, cb_cancel);
            } else {
                if (progress > 0) {
                    // first progress
                    update_process(LOAD_STEP_STAGE_GET_SOLID, static_cast<int>(progress * 10), 20, cb_cancel);
                }
            }
        }
        
        
        if (cb_cancel) {
            if (task) {
                if (task->joinable()) {
                    task->join();
                    delete task;
                }
            }
            return Step_Status::CANCEL;
        }
    }
    if (task) {
        if (task->joinable()) {
            task->join();
            delete task;
        }
    }
 
    //BBS: no valid shape from the step, delete the new object as well
    if (new_object->volumes.size() == 0) {
        model->delete_object(new_object);
        return Step_Status::MESH_ERROR;
    }
    return Step_Status::MESH_SUCCESS;
}

References Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::create_thread(), DIR_SEPARATOR, Slic3r::TriangleMesh::from_stl(), Slic3r::getNamedSolids(), Slic3r::ModelObject::input_file, Slic3r::ModelVolume::Source::input_file, m_path, Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::ModelVolume::Source::object_idx, Slic3r::Model::objects, Slic3r::range(), Slic3r::ModelVolume::source, Slic3r::ModelVolume::Source::volume_idx, and Slic3r::ModelObject::volumes.

Referenced by get_triangle_num(), and Slic3r::Model::read_from_step().

Here is the call graph for this function:

Here is the caller graph for this function:

update_process()

void Slic3r::Step::update_process	(	int	load_stage,
		int	current,
		int	total,
		bool &	cancel )

{
    if (m_stepFn) {
        m_stepFn(load_stage, current, total, cancel);
    }
}

References m_stepFn.

Referenced by load().

Here is the caller graph for this function:

Member Data Documentation

m_name_solids

std::vector<NamedSolid> Slic3r::Step::m_name_solids

private

Referenced by clean_mesh_data(), get_triangle_num(), get_triangle_num_tbb(), and load().

m_path

std::string Slic3r::Step::m_path

private

Referenced by Step(), load(), and mesh().

m_stepFn

ImportStepProgressFn Slic3r::Step::m_stepFn

private

Referenced by Step(), and update_process().

m_stop_mesh

std::atomic<bool> Slic3r::Step::m_stop_mesh {false}

{false};

Referenced by get_triangle_num().

m_utf8Fn

StepIsUtf8Fn Slic3r::Step::m_utf8Fn

private

Referenced by Step(), and load().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/STEP.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/STEP.cpp