Slic3r::sla::IndexedMesh Class Reference

An index-triangle structure for libIGL functions. Also serves as an alternative (raw) input format for the SLASupportTree. More...

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

Collaboration diagram for Slic3r::sla::IndexedMesh:

Classes
class	hit_result
class	AABBImpl

Public Member Functions
	IndexedMesh (const indexed_triangle_set &tmesh, bool calculate_epsilon=false)
	IndexedMesh (const TriangleMesh &mesh, bool calculate_epsilon=false)
	IndexedMesh (const IndexedMesh &other)
IndexedMesh &	operator= (const IndexedMesh &)
	IndexedMesh (IndexedMesh &&other)
IndexedMesh &	operator= (IndexedMesh &&other)
	~IndexedMesh ()
double	ground_level () const
void	ground_level_offset (double o)
double	ground_level_offset () const
const std::vector< Vec3f > &	vertices () const
const std::vector< Vec3i32 > &	indices () const
const Vec3f &	vertices (size_t idx) const
const Vec3i32 &	indices (size_t idx) const
hit_result	query_ray_hit (const Vec3d &s, const Vec3d &dir) const
std::vector< hit_result >	query_ray_hits (const Vec3d &s, const Vec3d &dir) const
double	squared_distance (const Vec3d &p, int &i, Vec3d &c) const
double	squared_distance (const Vec3d &p) const
Vec3d	normal_by_face_id (int face_id) const
const indexed_triangle_set *	get_triangle_mesh () const

Private Member Functions
template<class M>
void	init (const M &mesh, bool calculate_epsilon)

Private Attributes
const indexed_triangle_set *	m_tm
double	m_ground_level = 0
double	m_gnd_offset = 0
std::unique_ptr< AABBImpl >	m_aabb

Detailed Description

An index-triangle structure for libIGL functions. Also serves as an alternative (raw) input format for the SLASupportTree.

Constructor & Destructor Documentation

IndexedMesh() [1/4]

Slic3r::sla::IndexedMesh::IndexedMesh ( const indexed_triangle_set & tmesh, bool calculate_epsilon = false )

explicit

    : m_aabb(new AABBImpl()), m_tm(&tmesh)
{
    init(tmesh, calculate_epsilon);
}

References init(), m_aabb, and m_tm.

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

Here is the call graph for this function:

Here is the caller graph for this function:

IndexedMesh() [2/4]

Slic3r::sla::IndexedMesh::IndexedMesh ( const TriangleMesh & mesh, bool calculate_epsilon = false )

explicit

    : m_aabb(new AABBImpl()), m_tm(&mesh.its)
{
    init(mesh, calculate_epsilon);
}

References init(), m_aabb, and m_tm.

Here is the call graph for this function:

IndexedMesh() [3/4]

Slic3r::sla::IndexedMesh::IndexedMesh

(

const IndexedMesh &

other

)

                                                :
    m_tm(other.m_tm), m_ground_level(other.m_ground_level),
    m_aabb( new AABBImpl(*other.m_aabb) ) {}

References IndexedMesh(), m_aabb, m_ground_level, and m_tm.

Here is the call graph for this function:

IndexedMesh() [4/4]

Slic3r::sla::IndexedMesh::IndexedMesh ( IndexedMesh && other )

default

References IndexedMesh().

Here is the call graph for this function:

~IndexedMesh()

Slic3r::sla::IndexedMesh::~IndexedMesh

(

)

{}

Member Function Documentation

get_triangle_mesh()

const indexed_triangle_set * Slic3r::sla::IndexedMesh::get_triangle_mesh ( ) const

inline

{ return m_tm; }

References m_tm.

ground_level()

double Slic3r::sla::IndexedMesh::ground_level ( ) const

inline

{ return m_ground_level + m_gnd_offset; }

References m_gnd_offset, and m_ground_level.

Referenced by Slic3r::contour_extrusion_path(), Slic3r::sla::SupportTree::create(), and Slic3r::sla::SupportTreeBuildsteps::execute().

Here is the caller graph for this function:

ground_level_offset() [1/2]

double Slic3r::sla::IndexedMesh::ground_level_offset ( ) const

inline

{ return m_gnd_offset; }

References m_gnd_offset.

ground_level_offset() [2/2]

void Slic3r::sla::IndexedMesh::ground_level_offset ( double o )

inline

{ m_gnd_offset = o; }

References m_gnd_offset.

Referenced by Slic3r::PrintObject::contour_z().

Here is the caller graph for this function:

indices() [1/2]

const std::vector< Vec3i32 > & Slic3r::sla::IndexedMesh::indices

(

)

const

{
    return m_tm->indices;
}

References m_tm.

Referenced by Slic3r::sla::normals().

Here is the caller graph for this function:

indices() [2/2]

const Vec3i32 & Slic3r::sla::IndexedMesh::indices

(

size_t

idx

)

const

{
    return m_tm->indices[idx];
}

References m_tm.

init()

template<class M>

void Slic3r::sla::IndexedMesh::init ( const M & mesh, bool calculate_epsilon )

private

{
    BoundingBoxf3 bb = bounding_box(mesh);
    m_ground_level += bb.min(Z);
 
    // Build the AABB accelaration tree
    m_aabb->init(*m_tm, calculate_epsilon);
}

References Slic3r::bounding_box(), m_aabb, m_ground_level, m_tm, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and Slic3r::sla::Z.

Referenced by IndexedMesh(), and IndexedMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

normal_by_face_id()

Vec3d Slic3r::sla::IndexedMesh::normal_by_face_id

(

int

face_id

)

const

                                                      {
 
    return its_unnormalized_normal(*m_tm, face_id).cast<double>().normalized();
}

References Slic3r::its_unnormalized_normal(), and m_tm.

Referenced by Slic3r::sla::normals(), query_ray_hit(), and query_ray_hits().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

IndexedMesh & Slic3r::sla::IndexedMesh::operator=

(

const IndexedMesh &

other

)

{
    m_tm = other.m_tm;
    m_ground_level = other.m_ground_level;
    m_aabb.reset(new AABBImpl(*other.m_aabb)); return *this;
}

References IndexedMesh(), m_aabb, m_ground_level, and m_tm.

Here is the call graph for this function:

operator=() [2/2]

IndexedMesh & Slic3r::sla::IndexedMesh::operator= ( IndexedMesh && other )

default

References IndexedMesh().

Here is the call graph for this function:

query_ray_hit()

IndexedMesh::hit_result Slic3r::sla::IndexedMesh::query_ray_hit	(	const Vec3d &	s,
		const Vec3d &	dir ) const

{
    assert(is_approx(dir.norm(), 1.));
    igl::Hit<float> hit{-1, -1, 0.f, 0.f, 0.f};
    hit.t = std::numeric_limits<float>::infinity();
 
#ifdef SLIC3R_HOLE_RAYCASTER
    if (! m_holes.empty()) {
 
        // If there are holes, the hit_results will be made by
        // query_ray_hits (object) and filter_hits (holes):
        return filter_hits(query_ray_hits(s, dir));
    }
#endif
 
    m_aabb->intersect_ray(*m_tm, s, dir, hit);
    hit_result ret(*this);
    ret.m_t = double(hit.t);
    ret.m_dir = dir;
    ret.m_source = s;
    if(!std::isinf(hit.t) && !std::isnan(hit.t)) {
        ret.m_normal = this->normal_by_face_id(hit.id);
        ret.m_face_id = hit.id;
    }
 
    return ret;
}

References Slic3r::is_approx(), m_aabb, Slic3r::sla::IndexedMesh::hit_result::m_dir, Slic3r::sla::IndexedMesh::hit_result::m_face_id, Slic3r::sla::IndexedMesh::hit_result::m_normal, Slic3r::sla::IndexedMesh::hit_result::m_source, Slic3r::sla::IndexedMesh::hit_result::m_t, m_tm, normal_by_face_id(), and query_ray_hits().

Referenced by Slic3r::contour_extrusion_path(), and Slic3r::FaceDetector::detect_exterior_face().

Here is the call graph for this function:

Here is the caller graph for this function:

query_ray_hits()

std::vector< IndexedMesh::hit_result > Slic3r::sla::IndexedMesh::query_ray_hits	(	const Vec3d &	s,
		const Vec3d &	dir ) const

{
    std::vector<IndexedMesh::hit_result> outs;
    std::vector<igl::Hit<float>> hits;
    m_aabb->intersect_ray(*m_tm, s, dir, hits);
 
    // The sort is necessary, the hits are not always sorted.
    std::sort(hits.begin(), hits.end(),
              [](const igl::Hit<float>& a, const igl::Hit<float>& b) { return a.t < b.t; });
 
    // Remove duplicates. They sometimes appear, for example when the ray is cast
    // along an axis of a cube due to floating-point approximations in igl (?)
    // BBS: STUDIO-2591 A mesh with overlapping faces cannot be painted
    //hits.erase(std::unique(hits.begin(), hits.end(),
    //                       [](const igl::Hit<float>& a, const igl::Hit<float>& b)
    //                       { return a.t == b.t; }),
    //           hits.end());
 
    //  Convert the igl::Hit<float> into hit_result
    outs.reserve(hits.size());
    for (const igl::Hit<float>& hit : hits) {
        outs.emplace_back(IndexedMesh::hit_result(*this));
        outs.back().m_t = double(hit.t);
        outs.back().m_dir = dir;
        outs.back().m_source = s;
        if(!std::isinf(hit.t) && !std::isnan(hit.t)) {
            outs.back().m_normal = this->normal_by_face_id(hit.id);
            outs.back().m_face_id = hit.id;
        }
    }
 
    return outs;
}

References m_aabb, m_tm, and normal_by_face_id().

Referenced by query_ray_hit().

Here is the call graph for this function:

Here is the caller graph for this function:

squared_distance() [1/2]

double Slic3r::sla::IndexedMesh::squared_distance ( const Vec3d & p ) const

inline

    {
        int   i;
        Vec3d c;
        return squared_distance(p, i, c);
    }

References squared_distance().

Here is the call graph for this function:

squared_distance() [2/2]

double Slic3r::sla::IndexedMesh::squared_distance	(	const Vec3d &	p,
		int &	i,
		Vec3d &	c ) const

                                                                           {
    double sqdst = 0;
    Eigen::Matrix<double, 1, 3> pp = p;
    Eigen::Matrix<double, 1, 3> cc;
    sqdst = m_aabb->squared_distance(*m_tm, pp, i, cc);
    c = cc;
    return sqdst;
}

References m_aabb, and m_tm.

Referenced by squared_distance().

Here is the caller graph for this function:

vertices() [1/2]

const std::vector< Vec3f > & Slic3r::sla::IndexedMesh::vertices

(

)

const

{
    return m_tm->vertices;
}

References m_tm.

Referenced by Slic3r::sla::normals().

Here is the caller graph for this function:

vertices() [2/2]

const Vec3f & Slic3r::sla::IndexedMesh::vertices

(

size_t

idx

)

const

{
    return m_tm->vertices[idx];
}

References m_tm.

Member Data Documentation

m_aabb

std::unique_ptr<AABBImpl> Slic3r::sla::IndexedMesh::m_aabb

private

Referenced by IndexedMesh(), IndexedMesh(), IndexedMesh(), init(), operator=(), query_ray_hit(), query_ray_hits(), and squared_distance().

m_gnd_offset

double Slic3r::sla::IndexedMesh::m_gnd_offset = 0

private

Referenced by ground_level(), ground_level_offset(), and ground_level_offset().

m_ground_level

double Slic3r::sla::IndexedMesh::m_ground_level = 0

private

Referenced by IndexedMesh(), ground_level(), init(), and operator=().

m_tm

const indexed_triangle_set* Slic3r::sla::IndexedMesh::m_tm

private

Referenced by IndexedMesh(), IndexedMesh(), IndexedMesh(), get_triangle_mesh(), indices(), indices(), init(), normal_by_face_id(), operator=(), query_ray_hit(), query_ray_hits(), squared_distance(), vertices(), and vertices().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLA/IndexedMesh.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLA/IndexedMesh.cpp