Slic3r::SurfaceMesh Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SurfaceMesh.hpp>

Collaboration diagram for Slic3r::SurfaceMesh:

Public Member Functions
	SurfaceMesh (const indexed_triangle_set &its)
	SurfaceMesh (const SurfaceMesh &)=delete
SurfaceMesh &	operator= (const SurfaceMesh &)=delete
Vertex_index	source (Halfedge_index h) const
Vertex_index	target (Halfedge_index h) const
Face_index	face (Halfedge_index h) const
Halfedge_index	next (Halfedge_index h) const
Halfedge_index	prev (Halfedge_index h) const
Halfedge_index	halfedge (Vertex_index v) const
Halfedge_index	halfedge (Face_index f) const
Halfedge_index	opposite (Halfedge_index h) const
Halfedge_index	next_around_target (Halfedge_index h) const
Halfedge_index	prev_around_target (Halfedge_index h) const
Halfedge_index	next_around_source (Halfedge_index h) const
Halfedge_index	prev_around_source (Halfedge_index h) const
Halfedge_index	halfedge (Vertex_index source, Vertex_index target) const
const stl_vertex &	point (Vertex_index v) const
size_t	degree (Vertex_index v) const
size_t	degree (Face_index f) const
bool	is_border (Halfedge_index h) const
bool	is_same_vertex (const Vertex_index &a, const Vertex_index &b) const
Vec3i32	get_face_neighbors (Face_index face_id) const

Private Attributes
const std::vector< Vec3i32 >	m_face_neighbors
const indexed_triangle_set &	m_its

Detailed Description

Constructor & Destructor Documentation

SurfaceMesh() [1/2]

Slic3r::SurfaceMesh::SurfaceMesh ( const indexed_triangle_set & its )

inlineexplicit

    : m_its(its),
      m_face_neighbors(its_face_neighbors_par(its))
    {}

References Slic3r::its_face_neighbors_par(), m_face_neighbors, and m_its.

Referenced by SurfaceMesh(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

SurfaceMesh() [2/2]

Slic3r::SurfaceMesh::SurfaceMesh ( const SurfaceMesh & )

delete

References SurfaceMesh().

Here is the call graph for this function:

Member Function Documentation

degree() [1/2]

size_t Slic3r::SurfaceMesh::degree ( Face_index f ) const

inline

                                      {
        size_t total = 0;
        for (unsigned char i=0; i<3; ++i) {
            size_t d = degree(Vertex_index(f, i));
            if (d == 0)
                return 0;
            total += d;
        }
        assert(total - 6 >= 0);
        return total - 6; // we counted 3 halfedges from f, and one more for each neighbor
    }

References degree(), and Slic3r::f().

Here is the call graph for this function:

degree() [2/2]

size_t Slic3r::SurfaceMesh::degree ( Vertex_index v ) const

inline

    {
        // In case the mesh is broken badly, the loop might end up to be infinite,
        // never getting back to the first halfedge. Remember list of all half-edges
        // and trip if any is encountered for the second time.
        Halfedge_index h_first = halfedge(v);
        boost::container::small_vector<Halfedge_index, 10> he_visited;
        Halfedge_index h = next_around_target(h_first);
        size_t degree = 2;
        while (! h.is_invalid() && h != h_first) {
            he_visited.emplace_back(h);
            h = next_around_target(h);
            if (std::find(he_visited.begin(), he_visited.end(), h) == he_visited.end())
                return 0;
            ++degree;
        }
        return h.is_invalid() ? 0 : degree - 1;
    }

References degree(), halfedge(), Slic3r::Halfedge_index::is_invalid(), and next_around_target().

Referenced by degree(), and degree().

Here is the call graph for this function:

Here is the caller graph for this function:

face()

Face_index Slic3r::SurfaceMesh::face ( Halfedge_index h ) const

inline

{ assert(! h.is_invalid()); return h.m_face; }

References Slic3r::Halfedge_index::is_invalid(), and Slic3r::Halfedge_index::m_face.

Here is the call graph for this function:

get_face_neighbors()

Vec3i32 Slic3r::SurfaceMesh::get_face_neighbors ( Face_index face_id ) const

inline

{ assert(int(face_id) < int(m_face_neighbors.size())); return m_face_neighbors[face_id]; }

References m_face_neighbors.

halfedge() [1/3]

Halfedge_index Slic3r::SurfaceMesh::halfedge ( Face_index f ) const

inline

{ return Halfedge_index(f, 0); }  

References Slic3r::f().

Here is the call graph for this function:

halfedge() [2/3]

Halfedge_index Slic3r::SurfaceMesh::halfedge ( Vertex_index source, Vertex_index target ) const

inline

    {
        Halfedge_index hi(source.m_face, source.m_vertex_idx);
        assert(! hi.is_invalid());
 
        const Vertex_index orig_target = this->target(hi);
        Vertex_index current_target = orig_target;
 
        while (! is_same_vertex(current_target, target)) {
            hi = next_around_source(hi);
            if (hi.is_invalid())
                break;
            current_target = this->target(hi);
            if (is_same_vertex(current_target, orig_target))
                return Halfedge_index(); // invalid
        }
 
        return hi;
    }

References Slic3r::Halfedge_index::is_invalid(), is_same_vertex(), next_around_source(), source(), and target().

Here is the call graph for this function:

halfedge() [3/3]

Halfedge_index Slic3r::SurfaceMesh::halfedge ( Vertex_index v ) const

inline

{ return Halfedge_index(v.m_face, (v.m_vertex_idx == 0 ? 2 : v.m_vertex_idx - 1)); }  

References Slic3r::Vertex_index::m_face, and Slic3r::Vertex_index::m_vertex_idx.

Referenced by degree(), and opposite().

Here is the caller graph for this function:

is_border()

bool Slic3r::SurfaceMesh::is_border ( Halfedge_index h ) const

inline

{ return m_face_neighbors[h.m_face][h.m_side] == -1; }

References Slic3r::Halfedge_index::m_face, m_face_neighbors, and Slic3r::Halfedge_index::m_side.

is_same_vertex()

bool Slic3r::SurfaceMesh::is_same_vertex ( const Vertex_index & a, const Vertex_index & b ) const

inline

{ return m_its.indices[a.m_face][a.m_vertex_idx] == m_its.indices[b.m_face][b.m_vertex_idx]; }

References Slic3r::Vertex_index::m_face, m_its, and Slic3r::Vertex_index::m_vertex_idx.

Referenced by halfedge(), and opposite().

Here is the caller graph for this function:

next()

Halfedge_index Slic3r::SurfaceMesh::next ( Halfedge_index h ) const

inline

{ assert(! h.is_invalid()); h.m_side = (h.m_side + 1) % 3; return h; }

References Slic3r::Halfedge_index::is_invalid(), and Slic3r::Halfedge_index::m_side.

Referenced by next_around_source(), next_around_target(), and opposite().

Here is the call graph for this function:

Here is the caller graph for this function:

next_around_source()

Halfedge_index Slic3r::SurfaceMesh::next_around_source ( Halfedge_index h ) const

inline

{ Halfedge_index op = opposite(h); return (op.is_invalid() ? Halfedge_index() : next(op)); }

References Slic3r::Halfedge_index::is_invalid(), next(), and opposite().

Referenced by halfedge().

Here is the call graph for this function:

Here is the caller graph for this function:

next_around_target()

Halfedge_index Slic3r::SurfaceMesh::next_around_target ( Halfedge_index h ) const

inline

{ return opposite(next(h)); }

References next(), and opposite().

Referenced by degree().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

SurfaceMesh & Slic3r::SurfaceMesh::operator= ( const SurfaceMesh & )

delete

References SurfaceMesh().

Here is the call graph for this function:

opposite()

Halfedge_index Slic3r::SurfaceMesh::opposite ( Halfedge_index h ) const

inline

                                                    {
        if (h.is_invalid())
            return h;
 
        int face_idx = m_face_neighbors[h.m_face][h.m_side];
        Halfedge_index h_candidate = halfedge(Face_index(face_idx));
 
        if (h_candidate.is_invalid())
            return Halfedge_index(); // invalid
 
        for (int i=0; i<3; ++i) {
            if (is_same_vertex(source(h_candidate), target(h))) {
                // Meshes in PrusaSlicer should be fixed enough for the following not to happen.
                assert(is_same_vertex(target(h_candidate), source(h)));
                return h_candidate;
            }
            h_candidate = next(h_candidate);
        }
        return Halfedge_index(); // invalid
    }

References halfedge(), Slic3r::Halfedge_index::is_invalid(), is_same_vertex(), Slic3r::Halfedge_index::m_face, m_face_neighbors, Slic3r::Halfedge_index::m_side, next(), source(), and target().

Referenced by next_around_source(), next_around_target(), prev_around_source(), and prev_around_target().

Here is the call graph for this function:

Here is the caller graph for this function:

point()

const stl_vertex & Slic3r::SurfaceMesh::point ( Vertex_index v ) const

inline

{ return m_its.vertices[m_its.indices[v.m_face][v.m_vertex_idx]]; }

References Slic3r::Vertex_index::m_face, m_its, and Slic3r::Vertex_index::m_vertex_idx.

prev()

Halfedge_index Slic3r::SurfaceMesh::prev ( Halfedge_index h ) const

inline

{ assert(! h.is_invalid()); h.m_side = (h.m_side == 0 ? 2 : h.m_side - 1); return h; }

References Slic3r::Halfedge_index::is_invalid(), and Slic3r::Halfedge_index::m_side.

Referenced by prev_around_source(), and prev_around_target().

Here is the call graph for this function:

Here is the caller graph for this function:

prev_around_source()

Halfedge_index Slic3r::SurfaceMesh::prev_around_source ( Halfedge_index h ) const

inline

{ return opposite(prev(h)); }

References opposite(), and prev().

Here is the call graph for this function:

prev_around_target()

Halfedge_index Slic3r::SurfaceMesh::prev_around_target ( Halfedge_index h ) const

inline

{ Halfedge_index op = opposite(h); return (op.is_invalid() ? Halfedge_index() : prev(op)); }

References Slic3r::Halfedge_index::is_invalid(), opposite(), and prev().

Here is the call graph for this function:

source()

Vertex_index Slic3r::SurfaceMesh::source ( Halfedge_index h ) const

inline

{ assert(! h.is_invalid()); return Vertex_index(h.m_face, h.m_side); }

References Slic3r::Halfedge_index::is_invalid(), Slic3r::Halfedge_index::m_face, and Slic3r::Halfedge_index::m_side.

Referenced by halfedge(), and opposite().

Here is the call graph for this function:

Here is the caller graph for this function:

target()

Vertex_index Slic3r::SurfaceMesh::target ( Halfedge_index h ) const

inline

{ assert(! h.is_invalid()); return Vertex_index(h.m_face, h.m_side == 2 ? 0 : h.m_side + 1); }

References Slic3r::Halfedge_index::is_invalid(), Slic3r::Halfedge_index::m_face, and Slic3r::Halfedge_index::m_side.

Referenced by halfedge(), and opposite().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_face_neighbors

const std::vector<Vec3i32> Slic3r::SurfaceMesh::m_face_neighbors

private

Referenced by SurfaceMesh(), get_face_neighbors(), is_border(), and opposite().

m_its

const indexed_triangle_set& Slic3r::SurfaceMesh::m_its

private

Referenced by SurfaceMesh(), is_same_vertex(), and point().

---

The documentation for this class was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SurfaceMesh.hpp