Slic3r::tex2color::cgalutils Namespace Reference

Typedefs
using	Kernel = CGAL::Exact_predicates_inexact_constructions_kernel
using	CGALMesh = CGAL::Surface_mesh<Kernel::Point_3>

Functions
CGALMesh	trimesh_to_cgal (const TriMesh &mesh)
TriMesh	cgal_to_trimesh (const CGALMesh &cm)
bool	is_mesh_halfedge_compatible (const TriMesh &mesh)
bool	convert_trimesh_to_cgal (const TriMesh &mesh, CGALMesh &cgal_mesh)
bool	convert_trimesh_to_cgal (const TriMesh &mesh, const std::vector< Vec2f > &vertex_uvs, CGALMesh &cgal_mesh, std::vector< Vec2f > &cgal_vertex_uvs)

Typedef Documentation

CGALMesh

using Slic3r::tex2color::cgalutils::CGALMesh = CGAL::Surface_mesh<Kernel::Point_3>

Kernel

using Slic3r::tex2color::cgalutils::Kernel = CGAL::Exact_predicates_inexact_constructions_kernel

Function Documentation

cgal_to_trimesh()

TriMesh Slic3r::tex2color::cgalutils::cgal_to_trimesh ( const CGALMesh & cm )

inline

                                                   {
    TriMesh mesh;
    std::map<CGALMesh::Vertex_index, size_t> vmap;
    size_t idx = 0;
    for (auto v : cm.vertices()) {
        if (!cm.is_valid(v) || cm.is_removed(v)) continue;
        auto p = cm.point(v);
        mesh.vertices.push_back(Vec3f((float)p.x(), (float)p.y(), (float)p.z()));
        vmap[v] = idx++;
    }
    for (auto f : cm.faces()) {
        if (!cm.is_valid(f) || cm.is_removed(f)) continue;
        auto h = cm.halfedge(f);
        auto v0 = cm.target(h);
        auto v1 = cm.target(cm.next(h));
        auto v2 = cm.target(cm.next(cm.next(h)));
        mesh.indices.push_back(Vec3i32((int)vmap[v0], (int)vmap[v1], (int)vmap[v2]));
    }
    return mesh;
}

References Slic3r::f().

Referenced by Slic3r::tex2color::color_utils::smooth_region_labels().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_trimesh_to_cgal() [1/2]

bool Slic3r::tex2color::cgalutils::convert_trimesh_to_cgal ( const TriMesh & mesh, CGALMesh & cgal_mesh )

inline

                                                                              {
    cgal_mesh = trimesh_to_cgal(mesh);
    return cgal_mesh.number_of_faces() > 0 || mesh.indices.empty();
}

References trimesh_to_cgal().

Referenced by Slic3r::tex2color::color_utils::get_components(), Slic3r::tex2color::color_utils::is_closed(), Slic3r::tex2color::color_utils::mesh_cluster(), Slic3r::tex2color::color_utils::remesh_mesh(), and Slic3r::tex2color::color_utils::smooth_region_labels().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_trimesh_to_cgal() [2/2]

bool Slic3r::tex2color::cgalutils::convert_trimesh_to_cgal ( const TriMesh & mesh, const std::vector< Vec2f > & vertex_uvs, CGALMesh & cgal_mesh, std::vector< Vec2f > & cgal_vertex_uvs )

inline

{
    cgal_mesh.clear();
    std::vector<CGALMesh::Vertex_index> vmap(mesh.vertices.size());
    cgal_vertex_uvs.clear();
 
    for (size_t i = 0; i < mesh.vertices.size(); ++i) {
        vmap[i] = cgal_mesh.add_vertex(Kernel::Point_3(
            mesh.vertices[i].x(), mesh.vertices[i].y(), mesh.vertices[i].z()));
    }
 
    cgal_vertex_uvs.resize(cgal_mesh.num_vertices());
    for (size_t i = 0; i < mesh.vertices.size(); ++i) {
        if (i < vertex_uvs.size())
            cgal_vertex_uvs[vmap[i]] = vertex_uvs[i];
        else
            cgal_vertex_uvs[vmap[i]] = Vec2f(0.f, 0.f);
    }
 
    for (const auto& f : mesh.indices)
        cgal_mesh.add_face(vmap[f[0]], vmap[f[1]], vmap[f[2]]);
 
    return true;
}

References Slic3r::f().

Here is the call graph for this function:

is_mesh_halfedge_compatible()

bool Slic3r::tex2color::cgalutils::is_mesh_halfedge_compatible ( const TriMesh & mesh )

inline

                                                             {
    std::vector<std::unordered_set<std::size_t>> vtx_to_adj_faces(mesh.vertices.size());
    std::size_t edge_id = 0;
    std::vector<std::unordered_set<std::size_t>> edge_to_faces;
    std::vector<std::unordered_set<std::size_t>> vtx_to_prev_vtxs(mesh.vertices.size());
    std::vector<std::unordered_set<std::size_t>> vtx_to_next_vtxs(mesh.vertices.size());
    std::vector<std::unordered_map<std::size_t, std::size_t>> vtx_vtx_to_edge(mesh.vertices.size());
 
    for (std::size_t fid = 0; fid < mesh.indices.size(); ++fid) {
        const TriFace& face = mesh.indices[fid];
        if (face[0] == face[1] || face[1] == face[2] || face[2] == face[0]) {
            return false;
        }
        for (std::size_t i = 0; i < 3; ++i) {
            if (static_cast<std::size_t>(face[i]) >= mesh.vertices.size()) {
                return false;
            }
            vtx_to_adj_faces[face[i]].insert(fid);
 
            std::size_t prev_vtx = face[(i + 2) % 3];
            std::size_t next_vtx = face[(i + 1) % 3];
 
            if (vtx_to_prev_vtxs[face[i]].count(prev_vtx)) {
                return false;
            }
            vtx_to_prev_vtxs[face[i]].insert(prev_vtx);
 
            if (vtx_to_next_vtxs[face[i]].count(next_vtx)) {
                return false;
            }
            vtx_to_next_vtxs[face[i]].insert(next_vtx);
        }
 
        for (std::size_t i = 0; i < 3; ++i) {
            std::size_t va = face[i];
            std::size_t vb = face[(i + 1) % 3];
            if (!vtx_vtx_to_edge[va].count(vb)) {
                vtx_vtx_to_edge[va][vb] = edge_id;
                vtx_vtx_to_edge[vb][va] = edge_id;
                ++edge_id;
                edge_to_faces.emplace_back(std::unordered_set<std::size_t>());
            }
            edge_to_faces[vtx_vtx_to_edge[va][vb]].insert(fid);
        }
    }
 
    for (std::size_t vid = 0; vid < mesh.vertices.size(); ++vid) {
        if (vtx_to_adj_faces[vid].empty()) {
            continue;
        }
        std::unordered_set<std::size_t> visited_faces;
        std::queue<std::size_t> face_queue;
        face_queue.push(*(vtx_to_adj_faces[vid].begin()));
        visited_faces.insert(*(vtx_to_adj_faces[vid].begin()));
        while (!face_queue.empty()) {
            std::size_t fid = face_queue.front();
            face_queue.pop();
            const TriFace& face = mesh.indices[fid];
            for (std::size_t i = 0; i < 3; ++i) {
                if (static_cast<std::size_t>(face[i]) != vid) {
                    continue;
                }
                std::size_t v_next = face[(i + 1) % 3];
                std::size_t v_prev = face[(i + 2) % 3];
                for (std::size_t nbr : {v_next, v_prev}) {
                    std::size_t eid = vtx_vtx_to_edge[vid][nbr];
                    for (std::size_t adj_fid : edge_to_faces[eid]) {
                        if (!visited_faces.count(adj_fid) && vtx_to_adj_faces[vid].count(adj_fid)) {
                            visited_faces.insert(adj_fid);
                            face_queue.push(adj_fid);
                        }
                    }
                }
                break;
            }
        }
 
        for (std::size_t fid : vtx_to_adj_faces[vid]) {
            if (!visited_faces.count(fid)) {
                return false;
            }
        }
    }
 
    return true;
}

References count, and Slic3r::empty().

Here is the call graph for this function:

trimesh_to_cgal()

CGALMesh Slic3r::tex2color::cgalutils::trimesh_to_cgal ( const TriMesh & mesh )

inline

                                                     {
    CGALMesh cm;
    std::vector<CGALMesh::Vertex_index> vmap(mesh.vertices.size());
    for (size_t i = 0; i < mesh.vertices.size(); ++i)
        vmap[i] = cm.add_vertex(Kernel::Point_3(mesh.vertices[i].x(), mesh.vertices[i].y(), mesh.vertices[i].z()));
    for (const auto& f : mesh.indices) {
        cm.add_face(vmap[f[0]], vmap[f[1]], vmap[f[2]]);
    }
    return cm;
}

References Slic3r::f().

Referenced by convert_trimesh_to_cgal().

Here is the call graph for this function:

Here is the caller graph for this function: