Slic3r::sla::SupportTreeBuilder Class Reference

#include <src/libslic3r/SLA/SupportTreeBuilder.hpp>

Collaboration diagram for Slic3r::sla::SupportTreeBuilder:

Public Member Functions
	SupportTreeBuilder (const JobController &ctl={})
	SupportTreeBuilder (SupportTreeBuilder &&o)
	SupportTreeBuilder (const SupportTreeBuilder &o)
SupportTreeBuilder &	operator= (SupportTreeBuilder &&o)
SupportTreeBuilder &	operator= (const SupportTreeBuilder &o)
const JobController &	ctl () const
template<class... Args>
Head &	add_head (unsigned id, Args &&... args)
long	add_pillar (long headid, double length)
void	add_pillar_base (long pid, double baseheight=3, double radius=2)
template<class... Args>
const Anchor &	add_anchor (Args &&...args)
void	increment_bridges (const Pillar &pillar)
void	increment_links (const Pillar &pillar)
unsigned	bridgecount (const Pillar &pillar) const
template<class... Args>
long	add_pillar (Args &&...args)
template<class... Args>
const Junction &	add_junction (Args &&... args)
const Bridge &	add_bridge (const Vec3d &s, const Vec3d &e, double r)
const Bridge &	add_bridge (long headid, const Vec3d &endp)
template<class... Args>
const Bridge &	add_crossbridge (Args &&... args)
template<class... Args>
const DiffBridge &	add_diffbridge (Args &&... args)
Head &	head (unsigned id)
size_t	pillarcount () const
const std::vector< Pillar > &	pillars () const
const std::vector< Head > &	heads () const
const std::vector< Bridge > &	bridges () const
const std::vector< Bridge > &	crossbridges () const
template<class T >
IntegerOnly< T, const Pillar & >	pillar (T id) const
template<class T >
IntegerOnly< T, Pillar & >	pillar (T id)
const indexed_triangle_set &	merged_mesh (size_t steps=45) const
const indexed_triangle_set &	merge_and_cleanup ()
const indexed_triangle_set &	retrieve_mesh (MeshType meshtype=MeshType::Support) const
void	retrieve_full_mesh (indexed_triangle_set &outmesh) const

Private Types
using	Mutex = tbb::spin_mutex

Private Member Functions
template<class BridgeT , class... Args>
const BridgeT &	_add_bridge (std::vector< BridgeT > &br, Args &&... args)

Private Attributes
std::vector< Head >	m_heads
std::vector< size_t >	m_head_indices
std::vector< Pillar >	m_pillars
std::vector< Junction >	m_junctions
std::vector< Bridge >	m_bridges
std::vector< Bridge >	m_crossbridges
std::vector< DiffBridge >	m_diffbridges
std::vector< Pedestal >	m_pedestals
std::vector< Anchor >	m_anchors
JobController	m_ctl
indexed_triangle_set	m_meshcache
Mutex	m_mutex
bool	m_meshcache_valid = false
double	m_model_height = 0

Detailed Description

Member Typedef Documentation

Mutex

using Slic3r::sla::SupportTreeBuilder::Mutex = tbb::spin_mutex

private

Constructor & Destructor Documentation

SupportTreeBuilder() [1/3]

Slic3r::sla::SupportTreeBuilder::SupportTreeBuilder ( const JobController &  ctl = {} )

inlineexplicit

{}) : m_ctl{ctl} {}

SupportTreeBuilder() [2/3]

Slic3r::sla::SupportTreeBuilder::SupportTreeBuilder

(

SupportTreeBuilder &&

o

)

    : m_heads(std::move(o.m_heads))
    , m_head_indices{std::move(o.m_head_indices)}
    , m_pillars{std::move(o.m_pillars)}
    , m_bridges{std::move(o.m_bridges)}
    , m_crossbridges{std::move(o.m_crossbridges)}
    , m_meshcache{std::move(o.m_meshcache)}
    , m_meshcache_valid{o.m_meshcache_valid}
    , m_model_height{o.m_model_height}
{}

SupportTreeBuilder() [3/3]

Slic3r::sla::SupportTreeBuilder::SupportTreeBuilder

(

const SupportTreeBuilder &

o

)

    : m_heads(o.m_heads)
    , m_head_indices{o.m_head_indices}
    , m_pillars{o.m_pillars}
    , m_bridges{o.m_bridges}
    , m_crossbridges{o.m_crossbridges}
    , m_meshcache{o.m_meshcache}
    , m_meshcache_valid{o.m_meshcache_valid}
    , m_model_height{o.m_model_height}
{}

Member Function Documentation

_add_bridge()

template<class BridgeT , class... Args>

const BridgeT & Slic3r::sla::SupportTreeBuilder::_add_bridge ( std::vector< BridgeT > &  br, Args &&...  args  )

inlineprivate

    {
        std::lock_guard<Mutex> lk(m_mutex);
        br.emplace_back(std::forward<Args>(args)...);
        br.back().id = long(br.size() - 1);
        m_meshcache_valid = false;
        return br.back();
    }

References long, m_meshcache_valid, and m_mutex.

Referenced by add_bridge(), add_crossbridge(), and add_diffbridge().

Here is the caller graph for this function:

add_anchor()

template<class... Args>

const Anchor & Slic3r::sla::SupportTreeBuilder::add_anchor ( Args &&...  args )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        m_anchors.emplace_back(std::forward<Args>(args)...);
        m_anchors.back().id = long(m_junctions.size() - 1);
        m_meshcache_valid = false;
        return m_anchors.back();
    }

References long, m_anchors, m_junctions, m_meshcache_valid, and m_mutex.

Referenced by Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge(), and Slic3r::sla::DefaultSupportTree::connect_to_model_body().

Here is the caller graph for this function:

add_bridge() [1/2]

const Bridge & Slic3r::sla::SupportTreeBuilder::add_bridge ( const Vec3d &  s, const Vec3d &  e, double  r  )

inline

    {
        return _add_bridge(m_bridges, s, e, r);
    }

References _add_bridge(), and m_bridges.

Referenced by Slic3r::sla::connect_to_ground(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), and Slic3r::sla::create_ground_pillar().

Here is the call graph for this function:

Here is the caller graph for this function:

add_bridge() [2/2]

const Bridge & Slic3r::sla::SupportTreeBuilder::add_bridge ( long  headid, const Vec3d &  endp  )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(headid >= 0 && size_t(headid) < m_head_indices.size());
        
        Head &h = m_heads[m_head_indices[size_t(headid)]];
        m_bridges.emplace_back(h.junction_point(), endp, h.r_back_mm);
        m_bridges.back().id = long(m_bridges.size() - 1);
        
        h.bridge_id = m_bridges.back().id;
        m_meshcache_valid = false;
        return m_bridges.back();
    }

References Slic3r::sla::Head::bridge_id, Slic3r::sla::Head::junction_point(), long, m_bridges, m_head_indices, m_heads, m_meshcache_valid, m_mutex, and Slic3r::sla::Head::r_back_mm.

Here is the call graph for this function:

add_crossbridge()

template<class... Args>

const Bridge & Slic3r::sla::SupportTreeBuilder::add_crossbridge ( Args &&...  args )

inline

    {
        return _add_bridge(m_crossbridges, std::forward<Args>(args)...);
    }

References _add_bridge(), and m_crossbridges.

Referenced by Slic3r::sla::DefaultSupportTree::interconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

add_diffbridge()

template<class... Args>

const DiffBridge & Slic3r::sla::SupportTreeBuilder::add_diffbridge ( Args &&...  args )

inline

    {
        return _add_bridge(m_diffbridges, std::forward<Args>(args)...);
    }

References _add_bridge(), and m_diffbridges.

Referenced by Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge(), Slic3r::sla::build_ground_connection(), Slic3r::sla::BranchingTreeBuilder::build_subtree(), and Slic3r::sla::create_ground_pillar().

Here is the call graph for this function:

Here is the caller graph for this function:

add_head()

template<class... Args>

Head & Slic3r::sla::SupportTreeBuilder::add_head ( unsigned  id, Args &&...  args  )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        m_heads.emplace_back(std::forward<Args>(args)...);
        m_heads.back().id = id;
        
        if (id >= m_head_indices.size()) m_head_indices.resize(id + 1);
        m_head_indices[id] = m_heads.size() - 1;
        
        m_meshcache_valid = false;
        return m_heads.back();
    }

References m_head_indices, m_heads, m_meshcache_valid, and m_mutex.

Referenced by Slic3r::sla::DefaultSupportTree::add_pinheads(), and Slic3r::sla::create_branching_tree().

Here is the caller graph for this function:

add_junction()

template<class... Args>

const Junction & Slic3r::sla::SupportTreeBuilder::add_junction ( Args &&...  args )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        m_junctions.emplace_back(std::forward<Args>(args)...);
        m_junctions.back().id = long(m_junctions.size() - 1);
        m_meshcache_valid = false;
        return m_junctions.back();
    }

References long, m_junctions, m_meshcache_valid, and m_mutex.

Referenced by Slic3r::sla::build_ground_connection(), Slic3r::sla::BranchingTreeBuilder::build_subtree(), Slic3r::sla::connect_to_ground(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), and Slic3r::sla::create_ground_pillar().

Here is the caller graph for this function:

add_pillar() [1/2]

template<class... Args>

long Slic3r::sla::SupportTreeBuilder::add_pillar ( Args &&...  args )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        if (m_pillars.capacity() < m_heads.size())
            m_pillars.reserve(m_heads.size() * 10);
        
        m_pillars.emplace_back(std::forward<Args>(args)...);
        Pillar& pillar = m_pillars.back();
        pillar.id = long(m_pillars.size() - 1);
        pillar.starts_from_head = false;
        m_meshcache_valid = false;
        return pillar.id;
    }

References long, m_heads, m_meshcache_valid, m_mutex, m_pillars, and pillar().

Here is the call graph for this function:

add_pillar() [2/2]

long Slic3r::sla::SupportTreeBuilder::add_pillar ( long  headid, double  length  )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        if (m_pillars.capacity() < m_heads.size())
            m_pillars.reserve(m_heads.size() * 10);
        
        assert(headid >= 0 && size_t(headid) < m_head_indices.size());
        Head &head = m_heads[m_head_indices[size_t(headid)]];
        
        Vec3d hjp = head.junction_point() - Vec3d{0, 0, length};
        m_pillars.emplace_back(hjp, length, head.r_back_mm);
 
        Pillar& pillar = m_pillars.back();
        pillar.id = long(m_pillars.size() - 1);
        head.pillar_id = pillar.id;
        pillar.start_junction_id = head.id;
        pillar.starts_from_head = true;
        
        m_meshcache_valid = false;
        return pillar.id;
    }

References head(), Slic3r::sla::SupportTreeNode::id, Slic3r::sla::Head::junction_point(), Slic3r::length(), long, m_head_indices, m_heads, m_meshcache_valid, m_mutex, m_pillars, pillar(), Slic3r::sla::Head::pillar_id, and Slic3r::sla::Head::r_back_mm.

Referenced by Slic3r::sla::build_ground_connection(), Slic3r::sla::DefaultSupportTree::connect_to_model_body(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), and Slic3r::sla::create_ground_pillar().

Here is the call graph for this function:

Here is the caller graph for this function:

add_pillar_base()

void Slic3r::sla::SupportTreeBuilder::add_pillar_base	(	long	pid,
		double	baseheight = 3,
		double	radius = 2
	)

{
    std::lock_guard<Mutex> lk(m_mutex);
    assert(pid >= 0 && size_t(pid) < m_pillars.size());
    Pillar& pll = m_pillars[size_t(pid)];
    m_pedestals.emplace_back(pll.endpt, std::min(baseheight, pll.height),
                             std::max(radius, pll.r_start), pll.r_start);
 
    m_pedestals.back().id = m_pedestals.size() - 1;
    m_meshcache_valid = false;
}

References Slic3r::sla::Pillar::endpt, Slic3r::sla::Pillar::height, m_meshcache_valid, m_mutex, m_pedestals, m_pillars, and Slic3r::sla::Pillar::r_start.

Referenced by Slic3r::sla::DefaultSupportTree::add_pillar_base(), Slic3r::sla::build_ground_connection(), and Slic3r::sla::create_ground_pillar().

Here is the caller graph for this function:

bridgecount()

unsigned Slic3r::sla::SupportTreeBuilder::bridgecount ( const Pillar &  pillar ) const

inline

                                                     {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(pillar.id >= 0 && size_t(pillar.id) < m_pillars.size());
        return pillar.bridges;
    }

References m_mutex, m_pillars, and pillar().

Referenced by Slic3r::sla::DefaultSupportTree::connect_to_nearpillar().

Here is the call graph for this function:

Here is the caller graph for this function:

bridges()

const std::vector< Bridge > & Slic3r::sla::SupportTreeBuilder::bridges ( ) const

inline

{ return m_bridges; }

References m_bridges.

crossbridges()

const std::vector< Bridge > & Slic3r::sla::SupportTreeBuilder::crossbridges ( ) const

inline

{ return m_crossbridges; }

References m_crossbridges.

ctl()

const JobController & Slic3r::sla::SupportTreeBuilder::ctl ( ) const

inline

{ return m_ctl; }

References m_ctl.

Referenced by Slic3r::sla::create_branching_tree(), Slic3r::sla::DefaultSupportTree::execute(), Slic3r::sla::Anchor::Head(), Slic3r::sla::BranchingTreeBuilder::is_valid(), and merged_mesh().

Here is the caller graph for this function:

head()

Head & Slic3r::sla::SupportTreeBuilder::head ( unsigned  id )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(id < m_head_indices.size());
        
        m_meshcache_valid = false;
        return m_heads[m_head_indices[id]];
    }

References m_head_indices, m_heads, m_meshcache_valid, and m_mutex.

Referenced by add_pillar(), Slic3r::sla::DefaultSupportTree::classify(), Slic3r::sla::create_branching_tree(), Slic3r::sla::create_ground_pillar(), merged_mesh(), and Slic3r::sla::DefaultSupportTree::routing_to_ground().

Here is the caller graph for this function:

heads()

const std::vector< Head > & Slic3r::sla::SupportTreeBuilder::heads ( ) const

inline

{ return m_heads; }

References m_heads.

increment_bridges()

void Slic3r::sla::SupportTreeBuilder::increment_bridges ( const Pillar &  pillar )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(pillar.id >= 0 && size_t(pillar.id) < m_pillars.size());
        
        if(pillar.id >= 0 && size_t(pillar.id) < m_pillars.size())
            m_pillars[size_t(pillar.id)].bridges++;
    }

References m_mutex, m_pillars, and pillar().

Referenced by Slic3r::sla::DefaultSupportTree::connect_to_nearpillar().

Here is the call graph for this function:

Here is the caller graph for this function:

increment_links()

void Slic3r::sla::SupportTreeBuilder::increment_links ( const Pillar &  pillar )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(pillar.id >= 0 && size_t(pillar.id) < m_pillars.size());
        
        if(pillar.id >= 0 && size_t(pillar.id) < m_pillars.size()) 
            m_pillars[size_t(pillar.id)].links++;
    }

References m_mutex, m_pillars, and pillar().

Here is the call graph for this function:

merge_and_cleanup()

const indexed_triangle_set & Slic3r::sla::SupportTreeBuilder::merge_and_cleanup

(

)

{
    // in case the mesh is not generated, it should be...
    auto &ret = merged_mesh(); 
    
    // Doing clear() does not garantee to release the memory.
    clear_and_shrink(m_heads);
    clear_and_shrink(m_head_indices);
    clear_and_shrink(m_pillars);
    clear_and_shrink(m_junctions);
    clear_and_shrink(m_bridges);
 
    return ret;
}

References Slic3r::clear_and_shrink(), m_bridges, m_head_indices, m_heads, m_junctions, m_pillars, and merged_mesh().

Here is the call graph for this function:

merged_mesh()

const indexed_triangle_set & Slic3r::sla::SupportTreeBuilder::merged_mesh

(

size_t

steps = 45

)

const

{
    if (m_meshcache_valid) return m_meshcache;
    
    indexed_triangle_set merged;
    
    for (auto &head : m_heads) {
        if (ctl().stopcondition()) break;
        if (head.is_valid()) its_merge(merged, get_mesh(head, steps));
    }
    
    for (auto &pill : m_pillars) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(pill, steps));
    }
 
    for (auto &pedest : m_pedestals) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(pedest, steps));
    }
    
    for (auto &j : m_junctions) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(j, steps));
    }
 
    for (auto &bs : m_bridges) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(bs, steps));
    }
    
    for (auto &bs : m_crossbridges) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(bs, steps));
    }
 
    for (auto &bs : m_diffbridges) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(bs, steps));
    }
 
    for (auto &anch : m_anchors) {
        if (ctl().stopcondition()) break;
        its_merge(merged, get_mesh(anch, steps));
    }
 
    if (ctl().stopcondition()) {
        // In case of failure we have to return an empty mesh
        m_meshcache = {};
        return m_meshcache;
    }
    
    m_meshcache = std::move(merged);
    
    // The mesh will be passed by const-pointer to TriangleMeshSlicer,
    // which will need this.
    its_merge_vertices(m_meshcache);
    
    BoundingBoxf3 bb = bounding_box(m_meshcache);
    m_model_height   = bb.max(Z) - bb.min(Z);
 
    m_meshcache_valid = true;
    return m_meshcache;
}

References ctl(), Slic3r::sla::get_mesh(), head(), Slic3r::sla::Head::is_valid(), Slic3r::its_merge(), m_heads, m_meshcache, m_meshcache_valid, and Slic3r::sla::JobController::stopcondition.

Referenced by merge_and_cleanup(), Slic3r::sla::DefaultSupportTree::merge_result(), and retrieve_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

SupportTreeBuilder & Slic3r::sla::SupportTreeBuilder::operator=

(

const SupportTreeBuilder &

o

)

{
    m_heads = o.m_heads;
    m_head_indices = o.m_head_indices;
    m_pillars = o.m_pillars;
    m_bridges = o.m_bridges;
    m_crossbridges = o.m_crossbridges;
    m_meshcache = o.m_meshcache;
    m_meshcache_valid = o.m_meshcache_valid;
    m_model_height = o.m_model_height;
    return *this;
}

References m_bridges, m_crossbridges, m_head_indices, m_heads, m_meshcache, m_meshcache_valid, m_model_height, and m_pillars.

operator=() [2/2]

SupportTreeBuilder & Slic3r::sla::SupportTreeBuilder::operator=

(

SupportTreeBuilder &&

o

)

{
    m_heads = std::move(o.m_heads);
    m_head_indices = std::move(o.m_head_indices);
    m_pillars = std::move(o.m_pillars);
    m_bridges = std::move(o.m_bridges);
    m_crossbridges = std::move(o.m_crossbridges);
    m_meshcache = std::move(o.m_meshcache);
    m_meshcache_valid = o.m_meshcache_valid;
    m_model_height = o.m_model_height;
    return *this;
}

References m_bridges, m_crossbridges, m_head_indices, m_heads, m_meshcache, m_meshcache_valid, m_model_height, and m_pillars.

pillar() [1/2]

template<class T >

IntegerOnly< T, Pillar & > Slic3r::sla::SupportTreeBuilder::pillar ( T  id )

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(id >= 0 && size_t(id) < m_pillars.size() &&
               size_t(id) < std::numeric_limits<size_t>::max());
        
        return m_pillars[size_t(id)];
    }

References m_mutex, and m_pillars.

pillar() [2/2]

template<class T >

IntegerOnly< T, const Pillar & > Slic3r::sla::SupportTreeBuilder::pillar ( T  id ) const

inline

    {
        std::lock_guard<Mutex> lk(m_mutex);
        assert(id >= 0 && size_t(id) < m_pillars.size() &&
               size_t(id) < std::numeric_limits<size_t>::max());
        
        return m_pillars[size_t(id)];
    }

References m_mutex, and m_pillars.

Referenced by add_pillar(), add_pillar(), bridgecount(), Slic3r::sla::DefaultSupportTree::connect_to_ground(), Slic3r::sla::DefaultSupportTree::connect_to_model_body(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), Slic3r::sla::DefaultSupportTree::create_ground_pillar(), increment_bridges(), increment_links(), and Slic3r::sla::DefaultSupportTree::search_pillar_and_connect().

Here is the caller graph for this function:

pillarcount()

size_t Slic3r::sla::SupportTreeBuilder::pillarcount ( ) const

inline

                                      {
        std::lock_guard<Mutex> lk(m_mutex);
        return m_pillars.size();
    }

References m_mutex, and m_pillars.

Referenced by Slic3r::sla::DefaultSupportTree::search_pillar_and_connect().

Here is the caller graph for this function:

pillars()

const std::vector< Pillar > & Slic3r::sla::SupportTreeBuilder::pillars ( ) const

inline

{ return m_pillars; }

References m_pillars.

retrieve_full_mesh()

void Slic3r::sla::SupportTreeBuilder::retrieve_full_mesh ( indexed_triangle_set &  outmesh ) const

inline

    {
        its_merge(outmesh, retrieve_mesh(MeshType::Support));
        its_merge(outmesh, retrieve_mesh(MeshType::Pad));
    }

References Slic3r::its_merge(), Slic3r::sla::Pad, retrieve_mesh(), and Slic3r::sla::Support.

Here is the call graph for this function:

retrieve_mesh()

const indexed_triangle_set & Slic3r::sla::SupportTreeBuilder::retrieve_mesh

(

MeshType

meshtype = MeshType::Support

)

const

{
    static const indexed_triangle_set EMPTY_MESH;
 
    switch(meshtype) {
    case MeshType::Support: return merged_mesh();
    case MeshType::Pad:     return EMPTY_MESH; //pad().tmesh;
    }
    
    return m_meshcache;
}

References m_meshcache, merged_mesh(), Slic3r::sla::Pad, and Slic3r::sla::Support.

Referenced by retrieve_full_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_anchors

std::vector<Anchor> Slic3r::sla::SupportTreeBuilder::m_anchors

private

Referenced by add_anchor().

m_bridges

std::vector<Bridge> Slic3r::sla::SupportTreeBuilder::m_bridges

private

Referenced by add_bridge(), add_bridge(), bridges(), merge_and_cleanup(), operator=(), and operator=().

m_crossbridges

std::vector<Bridge> Slic3r::sla::SupportTreeBuilder::m_crossbridges

private

Referenced by add_crossbridge(), crossbridges(), operator=(), and operator=().

m_ctl

JobController Slic3r::sla::SupportTreeBuilder::m_ctl

private

Referenced by ctl().

m_diffbridges

std::vector<DiffBridge> Slic3r::sla::SupportTreeBuilder::m_diffbridges

private

Referenced by add_diffbridge().

m_head_indices

std::vector<size_t> Slic3r::sla::SupportTreeBuilder::m_head_indices

private

Referenced by add_bridge(), add_head(), add_pillar(), head(), merge_and_cleanup(), operator=(), and operator=().

m_heads

std::vector<Head> Slic3r::sla::SupportTreeBuilder::m_heads

private

Referenced by add_bridge(), add_head(), add_pillar(), add_pillar(), head(), heads(), merge_and_cleanup(), merged_mesh(), operator=(), and operator=().

m_junctions

std::vector<Junction> Slic3r::sla::SupportTreeBuilder::m_junctions

private

Referenced by add_anchor(), add_junction(), and merge_and_cleanup().

m_meshcache

indexed_triangle_set Slic3r::sla::SupportTreeBuilder::m_meshcache

mutableprivate

Referenced by merged_mesh(), operator=(), operator=(), and retrieve_mesh().

m_meshcache_valid

bool Slic3r::sla::SupportTreeBuilder::m_meshcache_valid = false

mutableprivate

Referenced by _add_bridge(), add_anchor(), add_bridge(), add_head(), add_junction(), add_pillar(), add_pillar(), add_pillar_base(), head(), merged_mesh(), operator=(), and operator=().

m_model_height

double Slic3r::sla::SupportTreeBuilder::m_model_height = 0

mutableprivate

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

m_mutex

Mutex Slic3r::sla::SupportTreeBuilder::m_mutex

mutableprivate

Referenced by _add_bridge(), add_anchor(), add_bridge(), add_head(), add_junction(), add_pillar(), add_pillar(), add_pillar_base(), bridgecount(), head(), increment_bridges(), increment_links(), pillar(), pillar(), and pillarcount().

m_pedestals

std::vector<Pedestal> Slic3r::sla::SupportTreeBuilder::m_pedestals

private

Referenced by add_pillar_base().

m_pillars

std::vector<Pillar> Slic3r::sla::SupportTreeBuilder::m_pillars

private

Referenced by add_pillar(), add_pillar(), add_pillar_base(), bridgecount(), increment_bridges(), increment_links(), merge_and_cleanup(), operator=(), operator=(), pillar(), pillar(), pillarcount(), and pillars().

---

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

• src/libslic3r/SLA/SupportTreeBuilder.hpp
• src/libslic3r/SLA/SupportTreeBuilder.cpp