Slic3r::MeshBoolean::cgal Namespace Reference

Classes
struct	CGALMesh
struct	CGALMeshDeleter

Typedefs
using	EpecKernel = CGAL::Exact_predicates_exact_constructions_kernel
using	EpicKernel = CGAL::Exact_predicates_inexact_constructions_kernel
using	_EpicMesh = CGAL::Surface_mesh< EpicKernel::Point_3 >
using	_EpecMesh = CGAL::Surface_mesh< EpecKernel::Point_3 >
using	CGALMeshPtr = std::unique_ptr< CGALMesh, CGALMeshDeleter >

Functions
template<class _Mesh >
void	triangle_mesh_to_cgal (const std::vector< stl_vertex > &V, const std::vector< stl_triangle_vertex_indices > &F, _Mesh &out)
Vec3f	to_vec3f (const _EpicMesh::Point &v)
Vec3f	to_vec3f (const _EpecMesh::Point &v)
template<class _Mesh >
indexed_triangle_set	cgal_to_indexed_triangle_set (const _Mesh &cgalmesh)
std::unique_ptr< CGALMesh, CGALMeshDeleter >	triangle_mesh_to_cgal (const std::vector< stl_vertex > &V, const std::vector< stl_triangle_vertex_indices > &F)
TriangleMesh	cgal_to_triangle_mesh (const CGALMesh &cgalmesh)
indexed_triangle_set	cgal_to_indexed_triangle_set (const CGALMesh &cgalmesh)
static bool	_cgal_diff (CGALMesh &A, CGALMesh &B, CGALMesh &R)
static bool	_cgal_union (CGALMesh &A, CGALMesh &B, CGALMesh &R)
static bool	_cgal_intersection (CGALMesh &A, CGALMesh &B, CGALMesh &R)
template<class Op >
void	_cgal_do (Op &&op, CGALMesh &A, CGALMesh &B)
void	minus (CGALMesh &A, CGALMesh &B)
void	plus (CGALMesh &A, CGALMesh &B)
void	intersect (CGALMesh &A, CGALMesh &B)
bool	does_self_intersect (const CGALMesh &mesh)
template<class Op >
void	_mesh_boolean_do (Op &&op, indexed_triangle_set &A, const indexed_triangle_set &B)
template<class Op >
void	_mesh_boolean_do (Op &&op, TriangleMesh &A, const TriangleMesh &B)
void	minus (TriangleMesh &A, const TriangleMesh &B)
void	plus (TriangleMesh &A, const TriangleMesh &B)
void	intersect (TriangleMesh &A, const TriangleMesh &B)
void	minus (indexed_triangle_set &A, const indexed_triangle_set &B)
void	plus (indexed_triangle_set &A, const indexed_triangle_set &B)
void	intersect (indexed_triangle_set &A, const indexed_triangle_set &B)
bool	does_self_intersect (const TriangleMesh &mesh)
bool	does_bound_a_volume (const CGALMesh &mesh)
bool	empty (const CGALMesh &mesh)
CGALMeshPtr	clone (const CGALMesh &m)
CGALMeshPtr	triangle_mesh_to_cgal (const indexed_triangle_set &M)
CGALMeshPtr	triangle_mesh_to_cgal (const TriangleMesh &M)

---

Class Documentation

Slic3r::MeshBoolean::cgal::CGALMesh

struct Slic3r::MeshBoolean::cgal::CGALMesh

Class Members
_EpicMesh	m

Typedef Documentation

_EpecMesh

using Slic3r::MeshBoolean::cgal::_EpecMesh = typedef CGAL::Surface_mesh<EpecKernel::Point_3>

_EpicMesh

using Slic3r::MeshBoolean::cgal::_EpicMesh = typedef CGAL::Surface_mesh<EpicKernel::Point_3>

CGALMeshPtr

using Slic3r::MeshBoolean::cgal::CGALMeshPtr = typedef std::unique_ptr<CGALMesh, CGALMeshDeleter>

EpecKernel

using Slic3r::MeshBoolean::cgal::EpecKernel = typedef CGAL::Exact_predicates_exact_constructions_kernel

EpicKernel

using Slic3r::MeshBoolean::cgal::EpicKernel = typedef CGAL::Exact_predicates_inexact_constructions_kernel

Function Documentation

_cgal_diff()

static bool Slic3r::MeshBoolean::cgal::_cgal_diff ( CGALMesh &  A, CGALMesh &  B, CGALMesh &  R  )

static

{
    const auto &p = CGALParams::throw_on_self_intersection(true);
    return CGALProc::corefine_and_compute_difference(A.m, B.m, R.m, p, p);
}

References _cgal_diff(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by _cgal_diff(), minus(), minus(), and minus().

Here is the call graph for this function:

Here is the caller graph for this function:

_cgal_do()

template<class Op >

void Slic3r::MeshBoolean::cgal::_cgal_do	(	Op &&	op,
		CGALMesh &	A,
		CGALMesh &	B
	)

{
    bool success = false;
    bool hw_fail = false;
    try {
        CGALMesh result;
        try_catch_signal({SIGSEGV, SIGFPE}, [&success, &A, &B, &result, &op] {
            success = op(A, B, result);
        }, [&] { hw_fail = true; });
        A = std::move(result);      // In-place operation does not work
    } catch (...) {
        success = false;
    }
 
    if (hw_fail)
        throw Slic3r::HardCrash("CGAL mesh boolean operation crashed.");
 
    if (! success)
        throw Slic3r::RuntimeError("CGAL mesh boolean operation failed.");
}

References _cgal_do(), and Slic3r::try_catch_signal().

Referenced by _cgal_do(), _mesh_boolean_do(), _mesh_boolean_do(), intersect(), minus(), and plus().

Here is the call graph for this function:

Here is the caller graph for this function:

_cgal_intersection()

static bool Slic3r::MeshBoolean::cgal::_cgal_intersection ( CGALMesh &  A, CGALMesh &  B, CGALMesh &  R  )

static

{
    const auto &p = CGALParams::throw_on_self_intersection(true);
    return CGALProc::corefine_and_compute_intersection(A.m, B.m, R.m, p, p);
}

References _cgal_intersection(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by _cgal_intersection(), intersect(), intersect(), and intersect().

Here is the call graph for this function:

Here is the caller graph for this function:

_cgal_union()

static bool Slic3r::MeshBoolean::cgal::_cgal_union ( CGALMesh &  A, CGALMesh &  B, CGALMesh &  R  )

static

{
    const auto &p = CGALParams::throw_on_self_intersection(true);
    return CGALProc::corefine_and_compute_union(A.m, B.m, R.m, p, p);
}

References _cgal_union(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by _cgal_union(), plus(), plus(), and plus().

Here is the call graph for this function:

Here is the caller graph for this function:

_mesh_boolean_do() [1/2]

template<class Op >

void Slic3r::MeshBoolean::cgal::_mesh_boolean_do	(	Op &&	op,
		indexed_triangle_set &	A,
		const indexed_triangle_set &	B
	)

{
    CGALMesh meshA;
    CGALMesh meshB;
    triangle_mesh_to_cgal(A.vertices, A.indices, meshA.m);
    triangle_mesh_to_cgal(B.vertices, B.indices, meshB.m);
    
    _cgal_do(op, meshA, meshB);
    
    A = cgal_to_indexed_triangle_set(meshA.m);
}

References _cgal_do(), _mesh_boolean_do(), cgal_to_indexed_triangle_set(), indexed_triangle_set::indices, Slic3r::MeshBoolean::cgal::CGALMesh::m, triangle_mesh_to_cgal(), and indexed_triangle_set::vertices.

Referenced by _mesh_boolean_do(), _mesh_boolean_do(), intersect(), intersect(), minus(), minus(), plus(), and plus().

Here is the call graph for this function:

Here is the caller graph for this function:

_mesh_boolean_do() [2/2]

template<class Op >

void Slic3r::MeshBoolean::cgal::_mesh_boolean_do	(	Op &&	op,
		TriangleMesh &	A,
		const TriangleMesh &	B
	)

{
    CGALMesh meshA;
    CGALMesh meshB;
    triangle_mesh_to_cgal(A.its.vertices, A.its.indices, meshA.m);
    triangle_mesh_to_cgal(B.its.vertices, B.its.indices, meshB.m);
 
    _cgal_do(op, meshA, meshB);
 
    A = cgal_to_triangle_mesh(meshA);
}

References _cgal_do(), _mesh_boolean_do(), cgal_to_triangle_mesh(), indexed_triangle_set::indices, Slic3r::TriangleMesh::its, Slic3r::MeshBoolean::cgal::CGALMesh::m, triangle_mesh_to_cgal(), and indexed_triangle_set::vertices.

Here is the call graph for this function:

cgal_to_indexed_triangle_set() [1/2]

template<class _Mesh >

indexed_triangle_set Slic3r::MeshBoolean::cgal::cgal_to_indexed_triangle_set

(

const _Mesh &

cgalmesh

)

{
    indexed_triangle_set its;
    its.vertices.reserve(cgalmesh.num_vertices());
    its.indices.reserve(cgalmesh.num_faces());
    
    const auto &faces = cgalmesh.faces();
    const auto &vertices = cgalmesh.vertices();
    int vsize = int(vertices.size());
 
    for (auto &vi : vertices) {
        auto &v = cgalmesh.point(vi); // Don't ask...
        its.vertices.emplace_back(to_vec3f(v));
    }
 
    for (auto &face : faces) {
        auto vtc = cgalmesh.vertices_around_face(cgalmesh.halfedge(face));
 
        int i = 0;
        Vec3i facet;
        for (auto v : vtc) {
            int iv = v;
            if (i > 2 || iv < 0 || iv >= vsize) { i = 0; break; }
            facet(i++) = iv;
        }
 
        if (i == 3)
            its.indices.emplace_back(facet);
    }
    
    return its;
}

References cgal_to_indexed_triangle_set(), indexed_triangle_set::indices, Slic3r::to_vec3f(), and indexed_triangle_set::vertices.

Referenced by _mesh_boolean_do(), cgal_to_indexed_triangle_set(), cgal_to_indexed_triangle_set(), cgal_to_triangle_mesh(), and Slic3r::SLAPrint::Steps::generate_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

cgal_to_indexed_triangle_set() [2/2]

indexed_triangle_set Slic3r::MeshBoolean::cgal::cgal_to_indexed_triangle_set

(

const CGALMesh &

cgalmesh

)

{
    return cgal_to_indexed_triangle_set(cgalmesh.m);
}

References cgal_to_indexed_triangle_set(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Here is the call graph for this function:

cgal_to_triangle_mesh()

TriangleMesh Slic3r::MeshBoolean::cgal::cgal_to_triangle_mesh

(

const CGALMesh &

cgalmesh

)

{
    return TriangleMesh{cgal_to_indexed_triangle_set(cgalmesh.m)};
}

References cgal_to_indexed_triangle_set(), cgal_to_triangle_mesh(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by _mesh_boolean_do(), cgal_to_triangle_mesh(), and Slic3r::GUI::Plater::export_stl_obj().

Here is the call graph for this function:

Here is the caller graph for this function:

clone()

CGALMeshPtr Slic3r::MeshBoolean::cgal::clone

(

const CGALMesh &

m

)

{
    return CGALMeshPtr{new CGALMesh{m}};
}

does_bound_a_volume()

bool Slic3r::MeshBoolean::cgal::does_bound_a_volume

(

const CGALMesh &

mesh

)

{
    return CGAL::is_closed(mesh.m) && CGALProc::does_bound_a_volume(mesh.m);
}

References does_bound_a_volume(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by Slic3r::csg::check_csgmesh_booleans(), and does_bound_a_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

does_self_intersect() [1/2]

bool Slic3r::MeshBoolean::cgal::does_self_intersect

(

const CGALMesh &

mesh

)

{ return CGALProc::does_self_intersect(mesh.m); }

References does_self_intersect(), and Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by Slic3r::csg::check_csgmesh_booleans(), does_self_intersect(), and does_self_intersect().

Here is the call graph for this function:

Here is the caller graph for this function:

does_self_intersect() [2/2]

bool Slic3r::MeshBoolean::cgal::does_self_intersect

(

const TriangleMesh &

mesh

)

{
    CGALMesh cgalm;
    triangle_mesh_to_cgal(mesh.its.vertices, mesh.its.indices, cgalm.m);
    return CGALProc::does_self_intersect(cgalm.m);
}

References does_self_intersect(), indexed_triangle_set::indices, Slic3r::TriangleMesh::its, Slic3r::MeshBoolean::cgal::CGALMesh::m, triangle_mesh_to_cgal(), and indexed_triangle_set::vertices.

Here is the call graph for this function:

empty()

bool Slic3r::MeshBoolean::cgal::empty

(

const CGALMesh &

mesh

)

{
    return mesh.m.is_empty();
}

References Slic3r::MeshBoolean::cgal::CGALMesh::m.

Referenced by Slic3r::csg::check_csgmesh_booleans().

Here is the caller graph for this function:

intersect() [1/3]

void Slic3r::MeshBoolean::cgal::intersect	(	CGALMesh &	A,
		CGALMesh &	B
	)

{ _cgal_do(_cgal_intersection, A, B); }

References _cgal_do(), and _cgal_intersection().

Referenced by Slic3r::csg::detail_cgal::perform_csg().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect() [2/3]

void Slic3r::MeshBoolean::cgal::intersect	(	indexed_triangle_set &	A,
		const indexed_triangle_set &	B
	)

{
    _mesh_boolean_do(_cgal_intersection, A, B);
}

References _cgal_intersection(), and _mesh_boolean_do().

Here is the call graph for this function:

intersect() [3/3]

void Slic3r::MeshBoolean::cgal::intersect	(	TriangleMesh &	A,
		const TriangleMesh &	B
	)

{
    _mesh_boolean_do(_cgal_intersection, A, B);
}

References _cgal_intersection(), and _mesh_boolean_do().

Here is the call graph for this function:

minus() [1/3]

void Slic3r::MeshBoolean::cgal::minus	(	CGALMesh &	A,
		CGALMesh &	B
	)

{ _cgal_do(_cgal_diff, A, B); }

References _cgal_diff(), and _cgal_do().

Referenced by Slic3r::csg::detail_cgal::perform_csg().

Here is the call graph for this function:

Here is the caller graph for this function:

minus() [2/3]

void Slic3r::MeshBoolean::cgal::minus	(	indexed_triangle_set &	A,
		const indexed_triangle_set &	B
	)

{
    _mesh_boolean_do(_cgal_diff, A, B);
}

References _cgal_diff(), and _mesh_boolean_do().

Here is the call graph for this function:

minus() [3/3]

void Slic3r::MeshBoolean::cgal::minus	(	TriangleMesh &	A,
		const TriangleMesh &	B
	)

{
    _mesh_boolean_do(_cgal_diff, A, B);
}

References _cgal_diff(), and _mesh_boolean_do().

Here is the call graph for this function:

plus() [1/3]

void Slic3r::MeshBoolean::cgal::plus	(	CGALMesh &	A,
		CGALMesh &	B
	)

{ _cgal_do(_cgal_union, A, B); }

References _cgal_do(), _cgal_union(), and plus().

Referenced by Slic3r::csg::detail_cgal::perform_csg(), plus(), plus(), and plus().

Here is the call graph for this function:

Here is the caller graph for this function:

plus() [2/3]

void Slic3r::MeshBoolean::cgal::plus	(	indexed_triangle_set &	A,
		const indexed_triangle_set &	B
	)

{
    _mesh_boolean_do(_cgal_union, A, B);
}

References _cgal_union(), _mesh_boolean_do(), and plus().

Here is the call graph for this function:

plus() [3/3]

void Slic3r::MeshBoolean::cgal::plus	(	TriangleMesh &	A,
		const TriangleMesh &	B
	)

{
    _mesh_boolean_do(_cgal_union, A, B);
}

References _cgal_union(), _mesh_boolean_do(), and plus().

Here is the call graph for this function:

to_vec3f() [1/2]

Vec3f Slic3r::MeshBoolean::cgal::to_vec3f ( const _EpecMesh::Point &  v )

inline

{
    CGAL::Cartesian_converter<EpecKernel, EpicKernel> cvt;
    auto iv = cvt(v);
    return { float(iv.x()), float(iv.y()), float(iv.z()) };
}

to_vec3f() [2/2]

Vec3f Slic3r::MeshBoolean::cgal::to_vec3f ( const _EpicMesh::Point &  v )

inline

{
    return { float(v.x()), float(v.y()), float(v.z()) };
}

triangle_mesh_to_cgal() [1/4]

CGALMeshPtr Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal ( const indexed_triangle_set &  M )

inline

{
    return triangle_mesh_to_cgal(M.vertices, M.indices);
}

References indexed_triangle_set::indices, triangle_mesh_to_cgal(), and indexed_triangle_set::vertices.

Here is the call graph for this function:

triangle_mesh_to_cgal() [2/4]

CGALMeshPtr Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal	(	const std::vector< stl_vertex > &	V,
		const std::vector< stl_triangle_vertex_indices > &	F
	)

{
    std::unique_ptr<CGALMesh, CGALMeshDeleter> out(new CGALMesh{});
    triangle_mesh_to_cgal(V, F, out->m);
    return out;
}

References Slic3r::F, and triangle_mesh_to_cgal().

Here is the call graph for this function:

triangle_mesh_to_cgal() [3/4]

template<class _Mesh >

void Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal	(	const std::vector< stl_vertex > &	V,
		const std::vector< stl_triangle_vertex_indices > &	F,
		_Mesh &	out
	)

{
    if (F.empty()) return;
 
    size_t vertices_count = V.size();
    size_t edges_count    = (F.size()* 3) / 2;
    size_t faces_count    = F.size();
    out.reserve(vertices_count, edges_count, faces_count);
 
    for (auto &v : V)
        out.add_vertex(typename _Mesh::Point{v.x(), v.y(), v.z()});
 
    using VI = typename _Mesh::Vertex_index;
    for (auto &f : F)
        out.add_face(VI(f(0)), VI(f(1)), VI(f(2)));
}

References Slic3r::F.

Referenced by _mesh_boolean_do(), _mesh_boolean_do(), Slic3r::csg::check_csgmesh_booleans(), does_self_intersect(), Slic3r::csg::get_cgalmesh(), Slic3r::csg::perform_csgmesh_booleans(), triangle_mesh_to_cgal(), triangle_mesh_to_cgal(), and triangle_mesh_to_cgal().

Here is the caller graph for this function:

triangle_mesh_to_cgal() [4/4]

CGALMeshPtr Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal ( const TriangleMesh &  M )

inline

{
    return triangle_mesh_to_cgal(M.its);
}

References Slic3r::TriangleMesh::its, and triangle_mesh_to_cgal().

Here is the call graph for this function: