Slic3r::csg Namespace Reference

Namespaces
namespace	detail_cgal
namespace	detail_mcut
namespace	detail

Classes
struct	CSGPart

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

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 Cont>
bool	is_all_positive (const Cont &csgmesh)
template<class Cont>
indexed_triangle_set	csgmesh_merge_positive_parts (const Cont &csgmesh)
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>
bool	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 CSGPartT>
MeshBoolean::mcut::McutMeshPtr	get_mcutmesh (const CSGPartT &csgpart)
template<class It>
void	perform_csgmesh_booleans_cgal (MeshBoolean::cgal::CGALMeshPtr &cgalm, const Range< It > &csgrange)
template<class It>
void	perform_csgmesh_booleans_mcut (MeshBoolean::mcut::McutMeshPtr &mcutm, const Range< It > &csgrange)
template<class It, class Visitor>
std::tuple< BooleanFailReason, std::string, It >	check_csgmesh_booleans (const Range< It > &csgrange, Visitor &&vfn)
template<class It>
std::tuple< BooleanFailReason, std::string, It >	check_csgmesh_booleans (const Range< It > &csgrange, bool use_mcut=false)
template<class It>
MeshBoolean::cgal::CGALMeshPtr	perform_csgmesh_booleans (const Range< It > &csgparts)
template<class It>
MeshBoolean::mcut::McutMeshPtr	perform_csgmesh_booleans_mcut (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)

Enumeration Type Documentation

BooleanFailReason

enum class Slic3r::csg::BooleanFailReason

strong

Enumerator
OK
MeshEmpty
NotBoundAVolume
SelfIntersect
NoIntersection

{ OK, MeshEmpty, NotBoundAVolume, SelfIntersect, NoIntersection};

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>

std::tuple< BooleanFailReason, std::string, It > Slic3r::csg::check_csgmesh_booleans	(	const Range< It > &	csgrange,
		bool	use_mcut = false )

{
    if(!use_mcut)
        return check_csgmesh_booleans(csgrange, [](auto &) {});
    else {
        using namespace detail_mcut;
        BooleanFailReason fail_reason = BooleanFailReason::OK;
        std::string fail_part_name;
 
        std::vector<McutMeshPtr> McutMeshes(csgrange.size());
        auto check_part = [&csgrange, &McutMeshes,&fail_reason,&fail_part_name](size_t i) {
            auto it = csgrange.begin();
            std::advance(it, i);
            auto& csgpart = *it;
            auto m = get_mcutmesh(csgpart);
 
            // mesh can be nullptr if this is a stack push or pull
            if (!get_mesh(csgpart) && get_stack_operation(csgpart) != CSGStackOp::Continue) {
                McutMeshes[i] = MeshBoolean::mcut::triangle_mesh_to_mcut(indexed_triangle_set{});
                return;
            }
 
            try {
                if (!m || MeshBoolean::mcut::empty(*m)) {
                    fail_reason=BooleanFailReason::MeshEmpty;
                    fail_part_name = csgpart.name;
                    return;
                }
            }
            catch (...) { return; }
 
            McutMeshes[i] = std::move(m);
        };
        execution::for_each(ex_tbb, size_t(0), csgrange.size(), check_part);
        return { fail_reason,fail_part_name, csgrange.end() };
    }
}

References Slic3r::Range< It >::begin(), check_csgmesh_booleans(), Continue, Slic3r::MeshBoolean::mcut::empty(), Slic3r::Range< It >::end(), Slic3r::ex_tbb, Slic3r::execution::for_each(), get_mcutmesh(), get_mesh(), get_stack_operation(), MeshEmpty, OK, Slic3r::Range< It >::size(), and Slic3r::MeshBoolean::mcut::triangle_mesh_to_mcut().

Here is the call graph for this function:

check_csgmesh_booleans() [2/2]

template<class It, class Visitor>

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

{
    using namespace detail_cgal;
    BooleanFailReason fail_reason = BooleanFailReason::OK;
    std::string fail_part_name;
    std::vector<CGALMeshPtr> cgalmeshes(csgrange.size());
    auto check_part = [&csgrange, &cgalmeshes,&fail_reason,&fail_part_name](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)) {
                BOOST_LOG_TRIVIAL(info) << "check_csgmesh_booleans fails! mesh " << i << "/" << csgrange.size() << " is empty, cannot do boolean!";
                fail_reason= BooleanFailReason::MeshEmpty;
                fail_part_name = csgpart.name;
                return;
            }
 
            if (!MeshBoolean::cgal::does_bound_a_volume(*m)) {
                BOOST_LOG_TRIVIAL(info) << "check_csgmesh_booleans fails! mesh "<<i<<"/"<<csgrange.size()<<" does_bound_a_volume is false, cannot do boolean!";
                fail_reason= BooleanFailReason::NotBoundAVolume;
                fail_part_name = csgpart.name;
                return;
            }
 
            if (MeshBoolean::cgal::does_self_intersect(*m)) {
                BOOST_LOG_TRIVIAL(info) << "check_csgmesh_booleans fails! mesh " << i << "/" << csgrange.size() << " does_self_intersect is true, cannot do boolean!";
                fail_reason= BooleanFailReason::SelfIntersect;
                fail_part_name = csgpart.name;
                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 { fail_reason,fail_part_name, 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(), MeshEmpty, NotBoundAVolume, OK, SelfIntersect, Slic3r::Range< It >::size(), and Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal().

Referenced by check_csgmesh_booleans(), Slic3r::GUI::Plater::combine_mesh_fff(), and Slic3r::GUI::Plater::export_stl().

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(), get_transform(), Slic3r::csg::CSGPart::its_ptr, and Slic3r::csg::CSGPart::stack_operation.

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(), get_transform(), Slic3r::csg::CSGPart::its_ptr, and Slic3r::csg::CSGPart::stack_operation.

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

Here is the call graph for this function:

Here is the caller graph for this function:

csgmesh_merge_positive_parts()

template<class Cont>

indexed_triangle_set Slic3r::csg::csgmesh_merge_positive_parts

(

const Cont &

csgmesh

)

{
    indexed_triangle_set m;
    for (auto &csgpart : csgmesh) {
        auto op = csg::get_operation(csgpart);
        const indexed_triangle_set * pmesh = csg::get_mesh(csgpart);
        if (pmesh && op == csg::CSGType::Union) {
            indexed_triangle_set mcpy = *pmesh;
            its_transform(mcpy, csg::get_transform(csgpart), true);
            its_merge(m, mcpy);
        }
    }
 
    return m;
}

References get_mesh(), get_operation(), get_transform(), Slic3r::its_merge(), and Union.

Referenced by Slic3r::GUI::Plater::export_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cgalmesh()

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(), and Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal().

Referenced by check_csgmesh_booleans().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mcutmesh()

template<class CSGPartT>

MeshBoolean::mcut::McutMeshPtr Slic3r::csg::get_mcutmesh

(

const CSGPartT &

csgpart

)

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

References get_mesh(), get_transform(), and Slic3r::MeshBoolean::mcut::triangle_mesh_to_mcut().

Referenced by check_csgmesh_booleans().

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(), check_csgmesh_booleans(), copy_csgrange_deep(), copy_csgrange_shallow(), csgmesh_merge_positive_parts(), get_cgalmesh(), get_mcutmesh(), 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(), csgmesh_merge_positive_parts(), is_same(), perform_csgmesh_booleans_cgal(), and perform_csgmesh_booleans_mcut().

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(), check_csgmesh_booleans(), copy_csgrange_deep(), copy_csgrange_shallow(), is_same(), perform_csgmesh_booleans_cgal(), and perform_csgmesh_booleans_mcut().

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(), csgmesh_merge_positive_parts(), get_cgalmesh(), get_mcutmesh(), 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();
}

get_transform() [3/5]

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

inline

{
    return Transform3f::Identity();
}

get_transform() [4/5]

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

inline

{
    return Transform3f::Identity();
}

get_transform() [5/5]

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

inline

{
    return Transform3f::Identity();
}

is_all_positive()

template<class Cont>

bool Slic3r::csg::is_all_positive

(

const Cont &

csgmesh

)

{
    bool is_all_pos =
        std::all_of(csgmesh.begin(),
                    csgmesh.end(),
                    [](auto &part) {
                        return csg::get_operation(part) == csg::CSGType::Union;
                    });
 
    return is_all_pos;
}

Referenced by Slic3r::GUI::Plater::export_stl().

Here is the caller 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(), 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>

bool 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;
    bool has_splitable_volume = false;
 
    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;
                has_splitable_volume = true;
            } else {
                CSGPart part{&(vol->mesh().its),
                             vol->is_model_part() ? CSGType::Union : CSGType::Difference,
                             (trafo * vol->get_matrix()).cast<float>()};
                part.name = vol->name;
                *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;
    //    }
    //}
 
    return has_splitable_volume;
}

References Difference, Slic3r::ModelVolume::get_matrix(), Slic3r::ModelVolume::is_model_part(), Slic3r::ModelVolume::is_negative_volume(), Slic3r::TriangleMesh::its, Slic3r::its_is_splittable(), Slic3r::its_split(), Slic3r::ModelVolume::mesh(), Slic3r::ModelVolume::mesh_ptr(), mpartsDoSplits, mpartsDrillHoles, mpartsNegative, mpartsPositive, Slic3r::csg::CSGPart::name, Slic3r::ModelVolume::name, Pop, Push, Slic3r::csg::CSGPart::stack_operation, Union, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::Plater::combine_mesh_fff(), and Slic3r::GUI::Plater::export_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_csgmesh_booleans()

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_cgal(ret, csgparts);
    return ret;
}

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

Referenced by Slic3r::GUI::Plater::combine_mesh_fff(), and Slic3r::GUI::Plater::export_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_csgmesh_booleans_cgal()

template<class It>

void Slic3r::csg::perform_csgmesh_booleans_cgal	(	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, Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal(), and Union.

Referenced by perform_csgmesh_booleans().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_csgmesh_booleans_mcut() [1/2]

template<class It>

MeshBoolean::mcut::McutMeshPtr Slic3r::csg::perform_csgmesh_booleans_mcut

(

const Range< It > &

csgparts

)

{
    auto ret = MeshBoolean::mcut::triangle_mesh_to_mcut(indexed_triangle_set{});
    if (ret)
        perform_csgmesh_booleans_mcut(ret, csgparts);
    return ret;
}

References perform_csgmesh_booleans_mcut(), and Slic3r::MeshBoolean::mcut::triangle_mesh_to_mcut().

Here is the call graph for this function:

perform_csgmesh_booleans_mcut() [2/2]

template<class It>

void Slic3r::csg::perform_csgmesh_booleans_mcut	(	MeshBoolean::mcut::McutMeshPtr &	mcutm,
		const Range< It > &	csgrange )

{
    using MeshBoolean::mcut::McutMesh;
    using MeshBoolean::mcut::McutMeshPtr;
    using namespace detail_mcut;
 
    struct Frame {
        CSGType op; McutMeshPtr mcutptr;
        explicit Frame(CSGType csgop = CSGType::Union)
            : op{ csgop }
            , mcutptr{ MeshBoolean::mcut::triangle_mesh_to_mcut(indexed_triangle_set{}) }
        {}
    };
 
    std::stack opstack{ std::vector<Frame>{} };
 
    opstack.push(Frame{});
 
    std::vector<McutMeshPtr> McutMeshes = get_mcutptrs(ex_tbb, csgrange);
 
    size_t csgidx = 0;
    for (auto& csgpart : csgrange) {
 
        auto op = get_operation(csgpart);
        McutMeshPtr& mcutptr = McutMeshes[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->mcutptr, mcutptr);
 
        if (get_stack_operation(csgpart) == CSGStackOp::Pop) {
            McutMeshPtr src = std::move(top->mcutptr);
            auto popop = opstack.top().op;
            opstack.pop();
            McutMeshPtr& dst = opstack.top().mcutptr;
            perform_csg(popop, dst, src);
        }
    }
 
    mcutm = std::move(opstack.top().mcutptr);
    
}

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

Referenced by Slic3r::GUI::Plater::combine_mesh_fff(), and perform_csgmesh_booleans_mcut().

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: