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
void	save_CGALMesh (const std::string &fname, const CGALMesh &cgal_mesh)
template<class _Mesh>
void	triangle_mesh_to_cgal (const TriangleMesh &M, _Mesh &out)
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)
template<class _Mesh>
TriangleMesh	cgal_to_triangle_mesh (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)
indexed_triangle_set	remesh_isotropic (const indexed_triangle_set &mesh, double target_edge_length, unsigned n_iterations, double sharp_angle_deg, unsigned n_relaxation_steps)
std::optional< std::vector< Vec2f > >	parameterize_lscm (const indexed_triangle_set &mesh)
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)
void	segment (CGALMesh &src, std::vector< CGALMesh > &dst, double smoothing_alpha=0.5, int segment_number=5)
std::vector< TriangleMesh >	segment (const TriangleMesh &src, double smoothing_alpha, int segment_number)
void	merge (std::vector< _EpicMesh > &srcs, _EpicMesh &dst)
TriangleMesh	merge (std::vector< TriangleMesh > meshes)
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)

Typedef Documentation

_EpecMesh

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

_EpicMesh

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

CGALMeshPtr

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

EpecKernel

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

EpicKernel

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

Function Documentation

_cgal_diff()

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 Slic3r::MeshBoolean::cgal::CGALMesh::m.

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

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 Slic3r::try_catch_signal().

Referenced by _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()

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 Slic3r::MeshBoolean::cgal::CGALMesh::m.

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

Here is the caller graph for this function:

_cgal_union()

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 Slic3r::MeshBoolean::cgal::CGALMesh::m.

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

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

Referenced by 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(), cgal_to_triangle_mesh(), Slic3r::TriangleMesh::its, Slic3r::MeshBoolean::cgal::CGALMesh::m, and triangle_mesh_to_cgal().

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 (const auto &vi : vertices) {
        auto &v = cgalmesh.point(vi); // Don't ask...
        its.vertices.emplace_back(to_vec3f(v));
    }
 
    for (const auto &face : faces) {
        auto vtc = cgalmesh.vertices_around_face(cgalmesh.halfedge(face));
 
        int i = 0;
        Vec3i32 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 to_vec3f().

Referenced by _mesh_boolean_do(), cgal_to_indexed_triangle_set(), cgal_to_triangle_mesh(), cgal_to_triangle_mesh(), and remesh_isotropic().

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() [1/2]

template<class _Mesh>

TriangleMesh Slic3r::MeshBoolean::cgal::cgal_to_triangle_mesh

(

const _Mesh &

cgalmesh

)

{
    indexed_triangle_set its = cgal_to_indexed_triangle_set(cgalmesh);
    return TriangleMesh(std::move(its));
}

References cgal_to_indexed_triangle_set().

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

Here is the call graph for this function:

Here is the caller graph for this function:

cgal_to_triangle_mesh() [2/2]

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

Here is the call 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 Slic3r::MeshBoolean::cgal::CGALMesh::m.

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

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 Slic3r::MeshBoolean::cgal::CGALMesh::m.

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

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

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:

merge() [1/2]

void Slic3r::MeshBoolean::cgal::merge	(	std::vector< _EpicMesh > &	srcs,
		_EpicMesh &	dst )

{
    _EpicMesh mesh_merged;
    for (size_t i = 0; i < srcs.size(); i++)
    {
        mesh_merged.join(srcs[i]);
    }
    if (mesh_merged.is_empty() == false) {
        CGAL::Polygon_mesh_processing::stitch_borders(mesh_merged);
        dst = std::move(mesh_merged);
    }
}

Referenced by merge(), and Slic3r::ModelObject::merge_volumes().

Here is the caller graph for this function:

merge() [2/2]

TriangleMesh Slic3r::MeshBoolean::cgal::merge

(

std::vector< TriangleMesh >

meshes

)

{
    std::vector<_EpicMesh> srcs(meshes.size());
    for (size_t i = 0; i < meshes.size(); i++)
    {
        MeshBoolean::cgal::triangle_mesh_to_cgal(meshes[i], srcs[i]);
    }
    _EpicMesh dst;
    merge(srcs, dst);
    return cgal_to_triangle_mesh(dst);
}

References cgal_to_triangle_mesh(), merge(), and triangle_mesh_to_cgal().

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:

parameterize_lscm()

std::optional< std::vector< Vec2f > > Slic3r::MeshBoolean::cgal::parameterize_lscm

(

const indexed_triangle_set &

mesh

)

{
    namespace SMP = CGAL::Surface_mesh_parameterization;
 
    if (mesh.indices.empty())
        return std::nullopt;
 
    _EpicMesh cgal_mesh;
    triangle_mesh_to_cgal(mesh.vertices, mesh.indices, cgal_mesh);
 
    using vertex_descriptor   = boost::graph_traits<_EpicMesh>::vertex_descriptor;
    using halfedge_descriptor = boost::graph_traits<_EpicMesh>::halfedge_descriptor;
 
    // LSCM assumes a single topological disk: one connected component, one boundary loop. A patch
    // with several disconnected painted islands, or with a hole in it, doesn't qualify -- bail out
    // rather than silently parameterizing just one arbitrary piece of it.
    {
        std::vector<std::size_t> component_id(num_faces(cgal_mesh));
        const std::size_t        num_components = CGAL::Polygon_mesh_processing::connected_components(
            cgal_mesh, CGAL::make_property_map(component_id));
        if (num_components != 1)
            return std::nullopt;
    }
 
    const halfedge_descriptor border = CGAL::Polygon_mesh_processing::longest_border(cgal_mesh).first;
    if (border == halfedge_descriptor())
        return std::nullopt; // no boundary at all -- a closed patch, which isn't a disk either
 
    // ...and exactly one boundary loop. One connected component is not enough on its own: a patch with
    // a hole in it (paint a ring, or erase the middle of a stroke) is a single component with two
    // loops, and LSCM will happily "parameterize" it into an overlapping, folded-over chart rather
    // than fail. Walk the border halfedges and check every one of them belongs to the longest loop.
    {
        std::size_t border_halfedges = 0;
        for (halfedge_descriptor h : halfedges(cgal_mesh))
            if (is_border(h, cgal_mesh))
                ++border_halfedges;
        std::size_t loop_length = 0;
        halfedge_descriptor h = border;
        do {
            ++loop_length;
            h = next(h, cgal_mesh);
        } while (h != border && loop_length <= border_halfedges);
        if (loop_length != border_halfedges)
            return std::nullopt; // more than one boundary loop -- not a topological disk
    }
 
    using Point_2 = EpicKernel::Point_2;
    using UV_pmap = _EpicMesh::Property_map<vertex_descriptor, Point_2>;
    UV_pmap uv_map = cgal_mesh.add_property_map<vertex_descriptor, Point_2>("h:uv", Point_2(0, 0)).first;
 
    using Parameterizer = SMP::LSCM_parameterizer_3<_EpicMesh>;
    const SMP::Error_code err = SMP::parameterize(cgal_mesh, Parameterizer(), border, uv_map);
    if (err != SMP::OK)
        return std::nullopt;
 
    // triangle_mesh_to_cgal() adds vertices in the exact same order as mesh.vertices (see above),
    // and Surface_mesh assigns indices sequentially on insertion into a fresh mesh, so a
    // vertex_descriptor's index here is guaranteed to match the original input vertex index --
    // the same assumption cgal_to_indexed_triangle_set() above already relies on.
    std::vector<Vec2f> result(mesh.vertices.size(), Vec2f::Zero());
    for (vertex_descriptor vd : vertices(cgal_mesh)) {
        const std::size_t idx = std::size_t(vd);
        if (idx < result.size()) {
            const Point_2 &uv = uv_map[vd];
            result[idx]        = Vec2f(float(uv.x()), float(uv.y()));
        }
    }
    return result;
}

References triangle_mesh_to_cgal().

Referenced by Slic3r::compute_patch_unwrap().

Here is the call graph for this function:

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

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

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(), and _mesh_boolean_do().

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(), and _mesh_boolean_do().

Here is the call graph for this function:

remesh_isotropic()

indexed_triangle_set Slic3r::MeshBoolean::cgal::remesh_isotropic	(	const indexed_triangle_set &	mesh,
		double	target_edge_length,
		unsigned	n_iterations,
		double	sharp_angle_deg,
		unsigned	n_relaxation_steps )

{
    if (mesh.indices.empty() || target_edge_length <= 0.0)
        return mesh;
 
    _EpicMesh cgal_mesh;
    triangle_mesh_to_cgal(mesh.vertices, mesh.indices, cgal_mesh);
    if (cgal_mesh.is_empty() || cgal_mesh.number_of_faces() == 0)
        return mesh;
 
    // Surface_mesh::add_face() refuses any face that would make the mesh non-manifold and returns a
    // null descriptor instead. Remeshing a mesh that silently lost faces that way produces holes in
    // the output, so bail out and let the caller report it rather than hand back a punctured model.
    if (cgal_mesh.number_of_faces() != mesh.indices.size())
        return mesh;
 
    using edge_descriptor = boost::graph_traits<_EpicMesh>::edge_descriptor;
    try {
        // Sharp edges and open borders are pinned before remeshing. Without that, the tangential
        // relaxation pass slides vertices along the surface and rounds every hard feature off - a
        // cube comes back with wobbly, eroded edges, which is the most visible way "remeshing does
        // not work properly". protect_constraints() forbids splitting or collapsing them, but it
        // requires each constrained edge to already be shorter than 4/3 * target, hence the split
        // first (passing the map so the halves inherit the constraint). This mirrors CGAL's own
        // isotropic_remeshing example.
        auto ecm = cgal_mesh.add_property_map<edge_descriptor, bool>("e:is_constrained", false).first;
        if (sharp_angle_deg > 0.0)
            CGALProc::detect_sharp_edges(cgal_mesh, sharp_angle_deg, ecm);
        for (edge_descriptor e : edges(cgal_mesh)) {
            const auto h = halfedge(e, cgal_mesh);
            if (is_border(h, cgal_mesh) || is_border(opposite(h, cgal_mesh), cgal_mesh))
                put(ecm, e, true);
        }
 
        std::vector<edge_descriptor> constrained;
        for (edge_descriptor e : edges(cgal_mesh))
            if (get(ecm, e))
                constrained.push_back(e);
        if (!constrained.empty())
            CGALProc::split_long_edges(constrained, target_edge_length, cgal_mesh,
                                       CGALParams::edge_is_constrained_map(ecm));
 
        CGALProc::isotropic_remeshing(faces(cgal_mesh), target_edge_length, cgal_mesh,
                                      CGALParams::number_of_iterations(n_iterations)
                                          .number_of_relaxation_steps(n_relaxation_steps)
                                          .edge_is_constrained_map(ecm)
                                          .protect_constraints(true));
    } catch (const std::exception &) {
        return mesh; // CGAL throws on some non-manifold / degenerate inputs; leave the mesh untouched
    }
    if (cgal_mesh.number_of_faces() == 0)
        return mesh;
 
    // isotropic_remeshing edits in place, and its edge collapses only *mark* vertices and faces as
    // removed - the underlying arrays keep the holes until the garbage is collected. That matters
    // because cgal_to_indexed_triangle_set() numbers its output vertices by iteration order (which
    // skips removed slots) while reading each face's corner as the raw integer value of the vertex
    // descriptor (which does not). Past the first collapse the two disagree, so every triangle
    // points at the wrong vertices, and any descriptor beyond the live vertex count is dropped
    // together with its triangle. Compacting first makes descriptor == iteration order again.
    cgal_mesh.collect_garbage();
    return cgal_to_indexed_triangle_set(cgal_mesh);
}

References cgal_to_indexed_triangle_set(), Slic3r::opposite(), and triangle_mesh_to_cgal().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::plan_remesh().

Here is the call graph for this function:

Here is the caller graph for this function:

save_CGALMesh()

void Slic3r::MeshBoolean::cgal::save_CGALMesh	(	const std::string &	fname,
		const CGALMesh &	cgal_mesh )

                                                                      {
    std::ofstream os(fname);
    os << cgal_mesh.m;
    os.close();
}

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

segment() [1/2]

void Slic3r::MeshBoolean::cgal::segment	(	CGALMesh &	src,
		std::vector< CGALMesh > &	dst,
		double	smoothing_alpha = 0.5,
		int	segment_number = 5 )

{
    typedef boost::graph_traits<_EpicMesh>::face_descriptor face_descriptor;
    typedef _EpicMesh::Property_map<face_descriptor, double> Facet_double_map;
    typedef CGAL::Face_filtered_graph<_EpicMesh> Filtered_graph;
 
    _EpicMesh mesh = src.m;
    Facet_double_map sdf_property_map;
 
    sdf_property_map = mesh.add_property_map<face_descriptor, double>("f:sdf").first;
 
    CGAL::sdf_values(mesh, sdf_property_map);
 
    // create a property-map for segment-ids
    typedef _EpicMesh::Property_map<face_descriptor, std::size_t> Facet_int_map;
    Facet_int_map segment_property_map = mesh.add_property_map<face_descriptor, std::size_t>("f:sid").first;;
    // segment the mesh using default parameters for number of levels, and smoothing lambda
    // Any other scalar values can be used instead of using SDF values computed using the CGAL function
    std::size_t number_of_segments = CGAL::segmentation_from_sdf_values(mesh, sdf_property_map, segment_property_map, segment_number, smoothing_alpha);
    //print area of each segment and then put it in a Mesh and print it in an OFF file
    Filtered_graph segment_mesh(mesh);
    _EpicMesh mesh_merged;
    for (std::size_t id = 0; id < number_of_segments; ++id)
    {
        segment_mesh.set_selected_faces(id, segment_property_map);
        //std::cout << "Segment " << id << "'s area is : " << CGAL::Polygon_mesh_processing::area(segment_mesh) << std::endl;
        _EpicMesh out;
        CGAL::copy_face_graph(segment_mesh, out);
 
        // save_CGALMesh("out.off", out);
 
        // fill holes
        typedef boost::graph_traits<_EpicMesh>::halfedge_descriptor      halfedge_descriptor;
        typedef boost::graph_traits<_EpicMesh>::vertex_descriptor        vertex_descriptor;
        std::vector<halfedge_descriptor> border_cycles;
        CGAL::extract_boundary_cycles(out, std::back_inserter(border_cycles));
        for (halfedge_descriptor h : border_cycles)
        {
            std::vector<face_descriptor>  patch_facets;
#if 0
            std::vector<vertex_descriptor> patch_vertices;
            CGAL::Polygon_mesh_processing::triangulate_and_refine_hole(out, h, std::back_inserter(patch_facets),
                std::back_inserter(patch_vertices));
            std::cout << "* Number of facets in constructed patch: " << patch_facets.size() << std::endl;
            std::cout << "  Number of vertices in constructed patch: " << patch_vertices.size() << std::endl;
#else
            CGAL::Polygon_mesh_processing::triangulate_hole(out, h, CGAL::parameters::default_values().face_output_iterator(std::back_inserter(patch_facets)));
#endif
        }
 
        //if (id > 2) {
        //    mesh_merged.join(out);
        //}
        //else
        {
            dst.emplace_back(CGALMesh(out));
        }
    }
    //if (mesh_merged.is_empty() == false) {
    //    CGAL::Polygon_mesh_processing::stitch_borders(mesh_merged);
    //    dst.emplace_back(std::move(CGALMesh(mesh_merged)));
    //}
}

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

Referenced by segment().

Here is the caller graph for this function:

segment() [2/2]

std::vector< TriangleMesh > Slic3r::MeshBoolean::cgal::segment	(	const TriangleMesh &	src,
		double	smoothing_alpha,
		int	segment_number )

{
    CGALMesh in_cgal_mesh;
    MeshBoolean::cgal::triangle_mesh_to_cgal(src, in_cgal_mesh.m);
    std::vector<CGALMesh> out_cgal_meshes;
    segment(in_cgal_mesh, out_cgal_meshes, smoothing_alpha, segment_number);
 
    std::vector<TriangleMesh> out_meshes;
    for (auto& outf_cgal_mesh: out_cgal_meshes)
    {
        out_meshes.emplace_back(cgal_to_triangle_mesh(outf_cgal_mesh.m));
    }
 
    return out_meshes;
}

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

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()) };
}

Referenced by cgal_to_indexed_triangle_set().

Here is the caller graph for this function:

triangle_mesh_to_cgal() [1/5]

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

inline

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

References triangle_mesh_to_cgal().

Here is the call graph for this function:

triangle_mesh_to_cgal() [2/5]

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/5]

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, and Slic3r::f().

Here is the call graph for this function:

triangle_mesh_to_cgal() [4/5]

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:

triangle_mesh_to_cgal() [5/5]

template<class _Mesh>

void Slic3r::MeshBoolean::cgal::triangle_mesh_to_cgal	(	const TriangleMesh &	M,
		_Mesh &	out )

{
    using Index3 = std::array<size_t, 3>;
 
    if (M.empty()) return;
 
    std::vector<typename _Mesh::Point> points;
    std::vector<Index3> indices;
    points.reserve(M.its.vertices.size());
    indices.reserve(M.its.indices.size());
    for (auto& v : M.its.vertices) points.emplace_back(v.x(), v.y(), v.z());
    for (auto& _f : M.its.indices) {
        auto f = _f.cast<size_t>();
        indices.emplace_back(Index3{ f(0), f(1), f(2) });
    }
 
    CGALProc::orient_polygon_soup(points, indices);
    CGALProc::polygon_soup_to_polygon_mesh(points, indices, out);
 
    // Number the faces because 'orient_to_bound_a_volume' needs a face <--> index map
    unsigned index = 0;
    for (auto face : out.faces()) face = CGAL::SM_Face_index(index++);
 
    if (CGAL::is_closed(out))
        CGALProc::orient_to_bound_a_volume(out);
    else
        throw Slic3r::RuntimeError("Mesh not watertight");
}

References Slic3r::TriangleMesh::empty(), Slic3r::f(), and Slic3r::TriangleMesh::its.

Referenced by _mesh_boolean_do(), _mesh_boolean_do(), Slic3r::csg::check_csgmesh_booleans(), does_self_intersect(), Slic3r::csg::get_cgalmesh(), merge(), parameterize_lscm(), Slic3r::csg::perform_csgmesh_booleans(), Slic3r::csg::perform_csgmesh_booleans_cgal(), remesh_isotropic(), segment(), triangle_mesh_to_cgal(), triangle_mesh_to_cgal(), and triangle_mesh_to_cgal().

Here is the call graph for this function:

Here is the caller graph for this function: