Slic3r::csg Namespace Reference

Namespaces
namespace	detail
namespace	detail_cgal

Classes
struct	CSGPart

Typedefs
using	VoxelizeParams = MeshToGridParams

Enumerations
enum class	CSGType { Union , Difference , Intersection }
enum class	CSGStackOp { Push , Continue , Pop }
enum	ModelParts { mpartsPositive = 1 , mpartsNegative = 2 , mpartsDrillHoles = 4 , mpartsDoSplits = 8 }

Functions
template<class CSGPartT >
CSGType	get_operation (const CSGPartT &part)
template<class CSGPartT >
CSGStackOp	get_stack_operation (const CSGPartT &part)
template<class CSGPartT >
const indexed_triangle_set *	get_mesh (const CSGPartT &part)
template<class CSGPartT >
Transform3f	get_transform (const CSGPartT &part)
template<class It , class OutIt >
void	copy_csgrange_shallow (const Range< It > &csgrange, OutIt out)
template<class It , class OutIt >
void	copy_csgrange_deep (const Range< It > &csgrange, OutIt out)
template<class ItA , class ItB >
bool	is_same (const Range< ItA > &A, const Range< ItB > &B)
template<class OutIt >
void	model_to_csgmesh (const ModelObject &mo, const Transform3d &trafo, OutIt out, int parts_to_include=mpartsPositive)
template<class CSGPartT >
MeshBoolean::cgal::CGALMeshPtr	get_cgalmesh (const CSGPartT &csgpart)
template<class It >
void	perform_csgmesh_booleans (MeshBoolean::cgal::CGALMeshPtr &cgalm, const Range< It > &csgrange)
template<class It , class Visitor >
It	check_csgmesh_booleans (const Range< It > &csgrange, Visitor &&vfn)
template<class It >
It	check_csgmesh_booleans (const Range< It > &csgrange)
template<class It >
MeshBoolean::cgal::CGALMeshPtr	perform_csgmesh_booleans (const Range< It > &csgparts)
template<class ItCSG >
std::vector< ExPolygons >	slice_csgmesh_ex (const Range< ItCSG > &csgrange, const std::vector< float > &slicegrid, const MeshSlicingParamsEx &params, const std::function< void()> &throw_on_cancel=[] {})
CSGType	get_operation (const indexed_triangle_set &part)
CSGStackOp	get_stack_operation (const indexed_triangle_set &part)
const indexed_triangle_set *	get_mesh (const indexed_triangle_set &part)
Transform3f	get_transform (const indexed_triangle_set &part)
CSGType	get_operation (const indexed_triangle_set *const part)
CSGStackOp	get_stack_operation (const indexed_triangle_set *const part)
const indexed_triangle_set *	get_mesh (const indexed_triangle_set *const part)
Transform3f	get_transform (const indexed_triangle_set *const part)
CSGType	get_operation (const TriangleMesh &part)
CSGStackOp	get_stack_operation (const TriangleMesh &part)
const indexed_triangle_set *	get_mesh (const TriangleMesh &part)
Transform3f	get_transform (const TriangleMesh &part)
CSGType	get_operation (const TriangleMesh *const part)
CSGStackOp	get_stack_operation (const TriangleMesh *const part)
const indexed_triangle_set *	get_mesh (const TriangleMesh *const part)
Transform3f	get_transform (const TriangleMesh *const part)
template<class CSGPartT >
VoxelGridPtr	get_voxelgrid (const CSGPartT &csgpart, VoxelizeParams params)
template<class It >
VoxelGridPtr	voxelize_csgmesh (const Range< It > &csgrange, const VoxelizeParams &params={})
MeshBoolean::cgal::CGALMeshPtr	get_cgalmesh (const CSGPartForStep &part)

Typedef Documentation

VoxelizeParams

using Slic3r::csg::VoxelizeParams = typedef MeshToGridParams

Enumeration Type Documentation

CSGStackOp

enum class Slic3r::csg::CSGStackOp

strong

Enumerator
Push
Continue
Pop

{ Push, Continue, Pop };

CSGType

enum class Slic3r::csg::CSGType

strong

Enumerator
Union
Difference
Intersection

{ Union, Difference, Intersection };

ModelParts

enum Slic3r::csg::ModelParts

Enumerator
mpartsPositive
mpartsNegative
mpartsDrillHoles
mpartsDoSplits

                {
    mpartsPositive = 1,   // Include positive parts
    mpartsNegative = 2,   // Include negative parts
    mpartsDrillHoles = 4, // Include drill holes
    mpartsDoSplits = 8,   // Split each splitable mesh and export as a union of csg parts
};

Function Documentation

check_csgmesh_booleans() [1/2]

template<class It >

It Slic3r::csg::check_csgmesh_booleans

(

const Range< It > &

csgrange

)

{
    return check_csgmesh_booleans(csgrange, [](auto &) {});
}

References check_csgmesh_booleans().

Here is the call graph for this function:

check_csgmesh_booleans() [2/2]

template<class It , class Visitor >

It Slic3r::csg::check_csgmesh_booleans	(	const Range< It > &	csgrange,
		Visitor &&	vfn
	)

{
    using namespace detail_cgal;
 
    std::vector<CGALMeshPtr> cgalmeshes(csgrange.size());
    auto check_part = [&csgrange, &cgalmeshes](size_t i)
    {
        auto it = csgrange.begin();
        std::advance(it, i);
        auto &csgpart = *it;
        auto m = get_cgalmesh(csgpart);
 
        // mesh can be nullptr if this is a stack push or pull
        if (!get_mesh(csgpart) && get_stack_operation(csgpart) != CSGStackOp::Continue) {
            cgalmeshes[i] = MeshBoolean::cgal::triangle_mesh_to_cgal(indexed_triangle_set{});
            return;
        }
 
        try {
            if (!m || MeshBoolean::cgal::empty(*m))
                return;
 
            if (!MeshBoolean::cgal::does_bound_a_volume(*m))
                return;
 
            if (MeshBoolean::cgal::does_self_intersect(*m))
                return;
        }
        catch (...) { return; }
 
        cgalmeshes[i] = std::move(m);
    };
    execution::for_each(ex_tbb, size_t(0), csgrange.size(), check_part);
 
    It ret = csgrange.end();
    for (size_t i = 0; i < csgrange.size(); ++i) {
        if (!cgalmeshes[i]) {
            auto it = csgrange.begin();
            std::advance(it, i);
            vfn(it);
 
            if (ret == csgrange.end())
                ret = it;
        }
    }
 
    return ret;
}

References Slic3r::Range< It >::begin(), Continue, Slic3r::MeshBoolean::cgal::does_bound_a_volume(), Slic3r::MeshBoolean::cgal::does_self_intersect(), Slic3r::MeshBoolean::cgal::empty(), Slic3r::Range< It >::end(), Slic3r::ex_tbb, Slic3r::execution::for_each(), get_cgalmesh(), get_mesh(), get_stack_operation(), Slic3r::Range< It >::size(), and Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal().

Referenced by check_csgmesh_booleans(), Slic3r::GUI::Plater::export_stl_obj(), and Slic3r::SLAPrint::Steps::generate_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_csgrange_deep()

template<class It , class OutIt >

void Slic3r::csg::copy_csgrange_deep	(	const Range< It > &	csgrange,
		OutIt	out
	)

{
    for (const auto &part : csgrange) {
 
        CSGPart cpy{{}, get_operation(part), get_transform(part)};
 
        if (auto meshptr = get_mesh(part)) {
            cpy.its_ptr = std::make_unique<const indexed_triangle_set>(*meshptr);
        }
 
        cpy.stack_operation = get_stack_operation(part);
 
        *out = std::move(cpy);
        ++out;
    }
}

References get_mesh(), get_operation(), get_stack_operation(), and get_transform().

Referenced by Slic3r::GUI::MeshClipper::set_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_csgrange_shallow()

template<class It , class OutIt >

void Slic3r::csg::copy_csgrange_shallow	(	const Range< It > &	csgrange,
		OutIt	out
	)

{
    for (const auto &part : csgrange) {
        CSGPart cpy{{},
                    get_operation(part),
                    get_transform(part)};
 
        cpy.stack_operation = get_stack_operation(part);
 
        if constexpr (std::is_convertible_v<decltype(part), const CSGPart&>) {
            if (auto shptr = part.its_ptr.get_shared_cpy()) {
                cpy.its_ptr = shptr;
            }
        }
 
        if (!cpy.its_ptr)
            cpy.its_ptr = AnyPtr<const indexed_triangle_set>{get_mesh(part)};
 
        *out = std::move(cpy);
        ++out;
    }
}

References get_mesh(), get_operation(), get_stack_operation(), and get_transform().

Referenced by Slic3r::SLAPrintObject::get_parts_to_slice(), and Slic3r::GUI::MeshClipper::set_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cgalmesh() [1/2]

MeshBoolean::cgal::CGALMeshPtr Slic3r::csg::get_cgalmesh

(

const CSGPartForStep &

part

)

{
    if (!part.cgalcache && csg::get_mesh(part)) {
        part.cgalcache = csg::get_cgalmesh(static_cast<const csg::CSGPart&>(part));
    }
 
    return part.cgalcache? clone(*part.cgalcache) : nullptr;
}

References Slic3r::CSGPartForStep::cgalcache, and get_cgalmesh().

Here is the call graph for this function:

get_cgalmesh() [2/2]

template<class CSGPartT >

MeshBoolean::cgal::CGALMeshPtr Slic3r::csg::get_cgalmesh

(

const CSGPartT &

csgpart

)

{
    const indexed_triangle_set *its = csg::get_mesh(csgpart);
    indexed_triangle_set dummy;
 
    if (!its)
        its = &dummy;
 
    MeshBoolean::cgal::CGALMeshPtr ret;
 
    indexed_triangle_set m = *its;
    its_transform(m, get_transform(csgpart), true);
 
    try {
        ret = MeshBoolean::cgal::triangle_mesh_to_cgal(m);
    } catch (...) {
        // errors are ignored, simply return null
        ret = nullptr;
    }
 
    return ret;
}

References get_mesh(), get_transform(), its_transform(), and Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal().

Referenced by check_csgmesh_booleans(), and get_cgalmesh().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh() [1/5]

template<class CSGPartT >

const indexed_triangle_set * Slic3r::csg::get_mesh

(

const CSGPartT &

part

)

{
    return part.its_ptr.get();
}

Referenced by check_csgmesh_booleans(), copy_csgrange_deep(), copy_csgrange_shallow(), Slic3r::csgmesh_merge_positive_parts(), Slic3r::csgmesh_positive_bb(), Slic3r::sla::csgmesh_positive_maxvolume(), get_cgalmesh(), get_voxelgrid(), and is_same().

Here is the caller graph for this function:

get_mesh() [2/5]

const indexed_triangle_set * Slic3r::csg::get_mesh ( const indexed_triangle_set &  part )

inline

{
    return ∂
}

get_mesh() [3/5]

const indexed_triangle_set * Slic3r::csg::get_mesh ( const indexed_triangle_set *const  part )

inline

{
    return part;
}

get_mesh() [4/5]

const indexed_triangle_set * Slic3r::csg::get_mesh ( const TriangleMesh &  part )

inline

{
    return &part.its;
}

References Slic3r::TriangleMesh::its.

get_mesh() [5/5]

const indexed_triangle_set * Slic3r::csg::get_mesh ( const TriangleMesh *const  part )

inline

{
    return &part->its;
}

References Slic3r::TriangleMesh::its.

get_operation() [1/5]

template<class CSGPartT >

CSGType Slic3r::csg::get_operation

(

const CSGPartT &

part

)

{
    return part.operation;
}

Referenced by copy_csgrange_deep(), copy_csgrange_shallow(), Slic3r::csgmesh_merge_positive_parts(), Slic3r::csgmesh_positive_bb(), Slic3r::sla::csgmesh_positive_maxvolume(), is_same(), perform_csgmesh_booleans(), and Slic3r::SLAPrint::Steps::slice_model().

Here is the caller graph for this function:

get_operation() [2/5]

CSGType Slic3r::csg::get_operation ( const indexed_triangle_set &  part )

inline

{
    return CSGType::Union;
}

References Union.

get_operation() [3/5]

CSGType Slic3r::csg::get_operation ( const indexed_triangle_set *const  part )

inline

{
    return CSGType::Union;
}

References Union.

get_operation() [4/5]

CSGType Slic3r::csg::get_operation ( const TriangleMesh &  part )

inline

{
    return CSGType::Union;
}

References Union.

get_operation() [5/5]

CSGType Slic3r::csg::get_operation ( const TriangleMesh *const  part )

inline

{
    return CSGType::Union;
}

References Union.

get_stack_operation() [1/5]

template<class CSGPartT >

CSGStackOp Slic3r::csg::get_stack_operation

(

const CSGPartT &

part

)

{
    return part.stack_operation;
}

Referenced by check_csgmesh_booleans(), copy_csgrange_deep(), copy_csgrange_shallow(), Slic3r::csgmesh_positive_bb(), Slic3r::sla::csgmesh_positive_maxvolume(), is_same(), and perform_csgmesh_booleans().

Here is the caller graph for this function:

get_stack_operation() [2/5]

CSGStackOp Slic3r::csg::get_stack_operation ( const indexed_triangle_set &  part )

inline

{
    return CSGStackOp::Continue;
}

References Continue.

get_stack_operation() [3/5]

CSGStackOp Slic3r::csg::get_stack_operation ( const indexed_triangle_set *const  part )

inline

{
    return CSGStackOp::Continue;
}

References Continue.

get_stack_operation() [4/5]

CSGStackOp Slic3r::csg::get_stack_operation ( const TriangleMesh &  part )

inline

{
    return CSGStackOp::Continue;
}

References Continue.

get_stack_operation() [5/5]

CSGStackOp Slic3r::csg::get_stack_operation ( const TriangleMesh *const  part )

inline

{
    return CSGStackOp::Continue;
}

References Continue.

get_transform() [1/5]

template<class CSGPartT >

Transform3f Slic3r::csg::get_transform

(

const CSGPartT &

part

)

{
    return part.trafo;
}

Referenced by copy_csgrange_deep(), copy_csgrange_shallow(), Slic3r::csgmesh_merge_positive_parts(), Slic3r::csgmesh_positive_bb(), get_cgalmesh(), get_voxelgrid(), and is_same().

Here is the caller graph for this function:

get_transform() [2/5]

Transform3f Slic3r::csg::get_transform ( const indexed_triangle_set &  part )

inline

{
    return Transform3f::Identity();
}

References Eigen::Transform< float, 3, Eigen::Affine, Eigen::DontAlign >::Identity().

Here is the call graph for this function:

get_transform() [3/5]

Transform3f Slic3r::csg::get_transform ( const indexed_triangle_set *const  part )

inline

{
    return Transform3f::Identity();
}

References Eigen::Transform< float, 3, Eigen::Affine, Eigen::DontAlign >::Identity().

Here is the call graph for this function:

get_transform() [4/5]

Transform3f Slic3r::csg::get_transform ( const TriangleMesh &  part )

inline

{
    return Transform3f::Identity();
}

References Eigen::Transform< float, 3, Eigen::Affine, Eigen::DontAlign >::Identity().

Here is the call graph for this function:

get_transform() [5/5]

Transform3f Slic3r::csg::get_transform ( const TriangleMesh *const  part )

inline

{
    return Transform3f::Identity();
}

References Eigen::Transform< float, 3, Eigen::Affine, Eigen::DontAlign >::Identity().

Here is the call graph for this function:

get_voxelgrid()

template<class CSGPartT >

VoxelGridPtr Slic3r::csg::get_voxelgrid	(	const CSGPartT &	csgpart,
		VoxelizeParams	params
	)

{
    const indexed_triangle_set *its = csg::get_mesh(csgpart);
    VoxelGridPtr ret;
 
    params.trafo(params.trafo() * csg::get_transform(csgpart));
 
    if (its)
        ret = mesh_to_grid(*its, params);
 
    return ret;
}

References get_mesh(), get_transform(), Slic3r::mesh_to_grid(), and Slic3r::MeshToGridParams::trafo().

Here is the call graph for this function:

is_same()

template<class ItA , class ItB >

bool Slic3r::csg::is_same	(	const Range< ItA > &	A,
		const Range< ItB > &	B
	)

{
    bool ret = true;
 
    size_t s = A.size();
 
    if (B.size() != s)
        ret = false;
 
    size_t i = 0;
    auto itA = A.begin();
    auto itB = B.begin();
    for (; ret && i < s; ++itA, ++itB, ++i) {
        ret = ret &&
              get_mesh(*itA) == get_mesh(*itB) &&
              get_operation(*itA) == get_operation(*itB) &&
              get_stack_operation(*itA) == get_stack_operation(*itB) &&
              get_transform(*itA).isApprox(get_transform(*itB));
    }
 
    return ret;
}

References Slic3r::Range< It >::begin(), get_mesh(), get_operation(), get_stack_operation(), get_transform(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::isApprox(), and Slic3r::Range< It >::size().

Referenced by Slic3r::GUI::MeshClipper::set_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

model_to_csgmesh()

template<class OutIt >

void Slic3r::csg::model_to_csgmesh	(	const ModelObject &	mo,
		const Transform3d &	trafo,
		OutIt	out,
		int	parts_to_include = mpartsPositive
	)

{
    bool do_positives  = parts_to_include & mpartsPositive;
    bool do_negatives  = parts_to_include & mpartsNegative;
    bool do_drillholes = parts_to_include & mpartsDrillHoles;
    bool do_splits     = parts_to_include & mpartsDoSplits;
 
    for (const ModelVolume *vol : mo.volumes) {
        if (vol && vol->mesh_ptr() &&
            ((do_positives && vol->is_model_part()) ||
             (do_negatives && vol->is_negative_volume()))) {
 
            if (do_splits && its_is_splittable(vol->mesh().its)) {
                CSGPart part_begin{{}, vol->is_model_part() ? CSGType::Union : CSGType::Difference};
                part_begin.stack_operation = CSGStackOp::Push;
                *out = std::move(part_begin);
                ++out;
 
                its_split(vol->mesh().its, SplitOutputFn{[&out, &vol, &trafo](indexed_triangle_set &&its) {
                              if (its.empty())
                                  return;
 
                              CSGPart part{std::make_unique<indexed_triangle_set>(std::move(its)),
                                       CSGType::Union,
                                       (trafo * vol->get_matrix()).cast<float>()};
 
                              *out = std::move(part);
                              ++out;
                          }});
 
                CSGPart part_end{{}};
                part_end.stack_operation = CSGStackOp::Pop;
                *out = std::move(part_end);
                ++out;
            } else {
                CSGPart part{&(vol->mesh().its),
                             vol->is_model_part() ? CSGType::Union : CSGType::Difference,
                             (trafo * vol->get_matrix()).cast<float>()};
 
                *out = std::move(part);
                ++out;
            }
        }
    }
 
    if (do_drillholes) {
        sla::DrainHoles drainholes = sla::transformed_drainhole_points(mo, trafo);
 
        for (const sla::DrainHole &dhole : drainholes) {
            CSGPart part{std::make_unique<const indexed_triangle_set>(
                             dhole.to_mesh()),
                         CSGType::Difference};
 
            *out = std::move(part);
            ++out;
        }
    }
}

References Difference, Slic3r::its_is_splittable(), Slic3r::its_split(), mpartsDoSplits, mpartsDrillHoles, mpartsNegative, mpartsPositive, Pop, Push, Slic3r::csg::CSGPart::stack_operation, Union, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::GUI::Plater::export_stl_obj(), and Slic3r::SLAPrint::Steps::mesh_assembly().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_csgmesh_booleans() [1/2]

template<class It >

MeshBoolean::cgal::CGALMeshPtr Slic3r::csg::perform_csgmesh_booleans

(

const Range< It > &

csgparts

)

{
    auto ret = MeshBoolean::cgal::triangle_mesh_to_cgal(indexed_triangle_set{});
    if (ret)
        perform_csgmesh_booleans(ret, csgparts);
 
    return ret;
}

References perform_csgmesh_booleans(), and Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal().

Here is the call graph for this function:

perform_csgmesh_booleans() [2/2]

template<class It >

void Slic3r::csg::perform_csgmesh_booleans	(	MeshBoolean::cgal::CGALMeshPtr &	cgalm,
		const Range< It > &	csgrange
	)

{
    using MeshBoolean::cgal::CGALMesh;
    using MeshBoolean::cgal::CGALMeshPtr;
    using namespace detail_cgal;
 
    struct Frame {
        CSGType op; CGALMeshPtr cgalptr;
        explicit Frame(CSGType csgop = CSGType::Union)
            : op{csgop}
            , cgalptr{MeshBoolean::cgal::triangle_mesh_to_cgal(indexed_triangle_set{})}
        {}
    };
 
    std::stack opstack{std::vector<Frame>{}};
 
    opstack.push(Frame{});
 
    std::vector<CGALMeshPtr> cgalmeshes = get_cgalptrs(ex_tbb, csgrange);
 
    size_t csgidx = 0;
    for (auto &csgpart : csgrange) {
 
        auto op = get_operation(csgpart);
        CGALMeshPtr &cgalptr = cgalmeshes[csgidx++];
 
        if (get_stack_operation(csgpart) == CSGStackOp::Push) {
            opstack.push(Frame{op});
            op = CSGType::Union;
        }
 
        Frame *top = &opstack.top();
 
        perform_csg(get_operation(csgpart), top->cgalptr, cgalptr);
 
        if (get_stack_operation(csgpart) == CSGStackOp::Pop) {
            CGALMeshPtr src = std::move(top->cgalptr);
            auto popop = opstack.top().op;
            opstack.pop();
            CGALMeshPtr &dst = opstack.top().cgalptr;
            perform_csg(popop, dst, src);
        }
    }
 
    cgalm = std::move(opstack.top().cgalptr);
}

References Slic3r::ex_tbb, get_operation(), get_stack_operation(), Pop, Push, and Union.

Referenced by Slic3r::GUI::Plater::export_stl_obj(), Slic3r::SLAPrint::Steps::generate_preview(), and perform_csgmesh_booleans().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_csgmesh_ex()

template<class ItCSG >

std::vector< ExPolygons > Slic3r::csg::slice_csgmesh_ex	(	const Range< ItCSG > &	csgrange,
		const std::vector< float > &	slicegrid,
		const MeshSlicingParamsEx &	params,
		const std::function< void()> &	throw_on_cancel = [] {}
	)

                                                    {})
{
    using namespace detail;
 
    struct Frame { CSGType op; std::vector<ExPolygons> slices; };
 
    std::stack opstack{std::vector<Frame>{}};
 
    MeshSlicingParamsEx params_cpy = params;
    auto trafo = params.trafo;
    auto nonempty_indices = reserve_vector<size_t>(slicegrid.size());
 
    opstack.push({CSGType::Union, std::vector<ExPolygons>(slicegrid.size())});
 
    for (const auto &csgpart : csgrange) {
        const indexed_triangle_set *its = csg::get_mesh(csgpart);
 
        auto op = get_operation(csgpart);
 
        if (get_stack_operation(csgpart) == CSGStackOp::Push) {
            opstack.push({op, std::vector<ExPolygons>(slicegrid.size())});
            op = CSGType::Union;
        }
 
        Frame *top = &opstack.top();
 
        if (its) {
            params_cpy.trafo = trafo * csg::get_transform(csgpart).template cast<double>();
            std::vector<ExPolygons> slices = slice_mesh_ex(*its,
                                                           slicegrid, params_cpy,
                                                           throw_on_cancel);
 
            assert(slices.size() == slicegrid.size());
 
            collect_nonempty_indices(op, slicegrid, slices, nonempty_indices);
 
            execution::for_each(
                ex_tbb, nonempty_indices.begin(), nonempty_indices.end(),
                [op, &slices, &top](size_t i) {
                    merge_slices(op, i, top->slices, slices);
                }, execution::max_concurrency(ex_tbb));
        }
 
        if (get_stack_operation(csgpart) == CSGStackOp::Pop) {
            std::vector<ExPolygons> popslices = std::move(top->slices);
            auto popop = opstack.top().op;
            opstack.pop();
            std::vector<ExPolygons> &prev_slices = opstack.top().slices;
 
            collect_nonempty_indices(popop, slicegrid, popslices, nonempty_indices);
 
            execution::for_each(
                ex_tbb, nonempty_indices.begin(), nonempty_indices.end(),
                [&popslices, &prev_slices, popop](size_t i) {
                    merge_slices(popop, i, prev_slices, popslices);
                }, execution::max_concurrency(ex_tbb));
        }
    }
 
    std::vector<ExPolygons> ret = std::move(opstack.top().slices);
 
    // TODO: verify if this part can be omitted or not.
    execution::for_each(ex_tbb, ret.begin(), ret.end(), [](ExPolygons &slice) {
        auto it = std::remove_if(slice.begin(), slice.end(), [](const ExPolygon &p){
            return p.area() < double(SCALED_EPSILON) * double(SCALED_EPSILON);
        });
 
        // Hopefully, ExPolygons are moved, not copied to new positions
        // and that is cheap for expolygons
        slice.erase(it, slice.end());
        slice = union_ex(slice);
    }, execution::max_concurrency(ex_tbb));
 
    return ret;
}

Referenced by Slic3r::GUI::MeshClipper::recalculate_triangles().

Here is the caller graph for this function:

voxelize_csgmesh()

template<class It >

VoxelGridPtr Slic3r::csg::voxelize_csgmesh	(	const Range< It > &	csgrange,
		const VoxelizeParams &	params = {}
	)

                                                             {})
{
    using namespace detail;
 
    VoxelGridPtr ret;
 
    std::vector<VoxelGridPtr> grids (csgrange.size());
 
    execution::for_each(ex_tbb, size_t(0), csgrange.size(), [&](size_t csgidx) {
        if (params.statusfn() && params.statusfn()(-1))
            return;
 
        auto it = csgrange.begin();
        std::advance(it, csgidx);
        auto &csgpart = *it;
        grids[csgidx] = get_voxelgrid(csgpart, params);
    }, execution::max_concurrency(ex_tbb));
 
    size_t csgidx = 0;
    struct Frame { CSGType op = CSGType::Union; VoxelGridPtr grid; };
    std::stack opstack{std::vector<Frame>{}};
 
    opstack.push({CSGType::Union, mesh_to_grid({}, params)});
 
    for (auto &csgpart : csgrange) {
        if (params.statusfn() && params.statusfn()(-1))
            break;
 
        auto &partgrid = grids[csgidx++];
 
        auto op = get_operation(csgpart);
 
        if (get_stack_operation(csgpart) == CSGStackOp::Push) {
            opstack.push({op, mesh_to_grid({}, params)});
            op = CSGType::Union;
        }
 
        Frame *top = &opstack.top();
 
        perform_csg(get_operation(csgpart), top->grid, partgrid);
 
        if (get_stack_operation(csgpart) == CSGStackOp::Pop) {
            VoxelGridPtr popgrid = std::move(top->grid);
            auto popop = opstack.top().op;
            opstack.pop();
            VoxelGridPtr &grid = opstack.top().grid;
            perform_csg(popop, grid, popgrid);
        }
    }
 
    ret = std::move(opstack.top().grid);
 
    return ret;
}

Referenced by Slic3r::SLAPrint::Steps::generate_preview_vdb().

Here is the caller graph for this function: