Slic3r::sla::SupportTreeBuilder Class Reference

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

Inheritance diagram for Slic3r::sla::SupportTreeBuilder:

Collaboration diagram for Slic3r::sla::SupportTreeBuilder:

Public Types
using	UPtr = std::unique_ptr<SupportTree>

Public Member Functions
	SupportTreeBuilder ()=default
	SupportTreeBuilder (SupportTreeBuilder &&o)
	SupportTreeBuilder (const SupportTreeBuilder &o)
SupportTreeBuilder &	operator= (SupportTreeBuilder &&o)
SupportTreeBuilder &	operator= (const SupportTreeBuilder &o)
template<class... Args>
Head &	add_head (unsigned id, Args &&... args)
template<class... 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 Pad &	pad () const
const indexed_triangle_set &	merged_mesh (size_t steps=45) const
double	full_height () const
double	mesh_height () const
const indexed_triangle_set &	merge_and_cleanup ()
const indexed_triangle_set &	add_pad (const ExPolygons &modelbase, const PadConfig &pcfg) override
	Adding the "pad" under the supports. modelbase will be used according to the embed_object flag in PoolConfig. If set, the plate will be interpreted as the model's intrinsic pad. Otherwise, the modelbase will be unified with the base plate calculated from the supports.
void	remove_pad () override
virtual const indexed_triangle_set &	retrieve_mesh (MeshType meshtype=MeshType::Support) const override
std::vector< ExPolygons >	slice (const std::vector< float > &, float closing_radius) const
void	retrieve_full_mesh (indexed_triangle_set &outmesh) const
const JobController &	ctl () const

Static Public Member Functions
static UPtr	create (const SupportableMesh &input, const JobController &ctl={})

Public Attributes
double	ground_level = 0

Private Types
using	Mutex = ccr::SpinningMutex

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
Pad	m_pad
indexed_triangle_set	m_meshcache
Mutex	m_mutex
bool	m_meshcache_valid = false
double	m_model_height = 0
JobController	m_ctl

Detailed Description

Member Typedef Documentation

Mutex

using Slic3r::sla::SupportTreeBuilder::Mutex = ccr::SpinningMutex

private

UPtr

using Slic3r::sla::SupportTree::UPtr = std::unique_ptr<SupportTree>

inherited

Constructor & Destructor Documentation

SupportTreeBuilder() [1/3]

Slic3r::sla::SupportTreeBuilder::SupportTreeBuilder ( )

default

References SupportTreeBuilder().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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_pad{std::move(o.m_pad)}
    , m_meshcache{std::move(o.m_meshcache)}
    , m_meshcache_valid{o.m_meshcache_valid}
    , m_model_height{o.m_model_height}
    , ground_level{o.ground_level}
{}

References SupportTreeBuilder(), ground_level, m_bridges, m_crossbridges, m_head_indices, m_heads, m_meshcache, m_meshcache_valid, m_model_height, m_pad, and m_pillars.

Here is the call graph for this function:

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_pad{o.m_pad}
    , m_meshcache{o.m_meshcache}
    , m_meshcache_valid{o.m_meshcache_valid}
    , m_model_height{o.m_model_height}
    , ground_level{o.ground_level}
{}

References SupportTreeBuilder(), m_bridges, m_crossbridges, m_head_indices, m_heads, m_meshcache, m_pad, and m_pillars.

Here is the call graph for this function:

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 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 m_anchors, m_junctions, m_meshcache_valid, and m_mutex.

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.

Here is the call 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(), 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.

Here is the call 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.

Here is the call 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.

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 m_junctions, m_meshcache_valid, and m_mutex.

add_pad()

const indexed_triangle_set & Slic3r::sla::SupportTreeBuilder::add_pad ( const ExPolygons & modelbase, const PadConfig & pcfg )

overridevirtual

Adding the "pad" under the supports. modelbase will be used according to the embed_object flag in PoolConfig. If set, the plate will be interpreted as the model's intrinsic pad. Otherwise, the modelbase will be unified with the base plate calculated from the supports.

Implements Slic3r::sla::SupportTree.

{
    m_pad = Pad{merged_mesh(), modelbase, ground_level, cfg, ctl().cancelfn};
    return m_pad.tmesh;
}

References Slic3r::sla::JobController::cancelfn, Slic3r::sla::SupportTree::ctl(), ground_level, m_pad, and merged_mesh().

Here is the call 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 m_heads, m_meshcache_valid, m_mutex, m_pillars, and pillar().

Here is the call graph for this function:

add_pillar() [2/2]

template<class... Args>

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::length(), m_head_indices, m_heads, m_meshcache_valid, m_mutex, m_pillars, and pillar().

Here is the call 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), pll.r);
 
    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.

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().

Here is the call graph for this function:

bridges()

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

inline

{ return m_bridges; }

References m_bridges.

create()

SupportTree::UPtr Slic3r::sla::SupportTree::create ( const SupportableMesh & input, const JobController & ctl = {} )

staticinherited

{
    auto builder = make_unique<SupportTreeBuilder>();
    builder->m_ctl = ctl;
    
    if (sm.cfg.enabled) {
        // Execute takes care about the ground_level
        SupportTreeBuildsteps::execute(*builder, sm);
        builder->merge_and_cleanup();   // clean metadata, leave only the meshes.
    } else {
        // If a pad gets added later, it will be in the right Z level
        builder->ground_level = sm.emesh.ground_level();
    }
    
    return std::move(builder);
}

References Slic3r::sla::SupportableMesh::cfg, ctl(), Slic3r::sla::SupportableMesh::emesh, Slic3r::sla::SupportTreeConfig::enabled, Slic3r::sla::SupportTreeBuildsteps::execute(), Slic3r::sla::IndexedMesh::ground_level(), and Slic3r::make_unique().

Referenced by Slic3r::SLAPrintObject::SupportData::create_support_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

crossbridges()

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

inline

{ return m_crossbridges; }

References m_crossbridges.

ctl()

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

inlineinherited

{ return m_ctl; }

References m_ctl.

Referenced by Slic3r::sla::SupportTreeBuilder::add_pad(), create(), Slic3r::sla::SupportTreeBuildsteps::execute(), Slic3r::sla::SupportTreeBuilder::merged_mesh(), and slice().

Here is the caller graph for this function:

full_height()

double Slic3r::sla::SupportTreeBuilder::full_height

(

)

const

{
    if (merged_mesh().indices.empty() && !pad().empty())
        return pad().cfg.full_height();
    
    double h = mesh_height();
    if (!pad().empty()) h += pad().cfg.required_elevation();
    return h;
}

References Slic3r::sla::Pad::cfg, Slic3r::empty(), Slic3r::sla::PadConfig::full_height(), merged_mesh(), mesh_height(), pad(), and Slic3r::sla::PadConfig::required_elevation().

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

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().

Here is the call 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.
    m_heads = {};
    m_head_indices = {};
    m_pillars = {};
    m_junctions = {};
    m_bridges = {};
    
    return ret;
}

References 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 = 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 Slic3r::bounding_box(), Slic3r::sla::SupportTree::ctl(), Slic3r::sla::get_mesh(), head(), Slic3r::its_merge(), Slic3r::its_merge_vertices(), m_anchors, m_bridges, m_crossbridges, m_diffbridges, m_heads, m_junctions, m_meshcache, m_meshcache_valid, m_model_height, m_pedestals, m_pillars, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and Slic3r::sla::Z.

Referenced by add_pad(), full_height(), merge_and_cleanup(), mesh_height(), and retrieve_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_height()

double Slic3r::sla::SupportTreeBuilder::mesh_height ( ) const

inline

    {
        if (!m_meshcache_valid) merged_mesh();
        return m_model_height;
    }

References m_meshcache_valid, m_model_height, and merged_mesh().

Referenced by full_height().

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_pad = o.m_pad;
    m_meshcache = o.m_meshcache;
    m_meshcache_valid = o.m_meshcache_valid;
    m_model_height = o.m_model_height;
    ground_level = o.ground_level;
    return *this;
}

References SupportTreeBuilder(), ground_level, m_bridges, m_crossbridges, m_head_indices, m_heads, m_meshcache, m_meshcache_valid, m_model_height, m_pad, and m_pillars.

Here is the call graph for this function:

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_pad = std::move(o.m_pad);
    m_meshcache = std::move(o.m_meshcache);
    m_meshcache_valid = o.m_meshcache_valid;
    m_model_height = o.m_model_height;
    ground_level = o.ground_level;
    return *this;
}

References SupportTreeBuilder(), ground_level, m_bridges, m_crossbridges, m_head_indices, m_heads, m_meshcache, m_meshcache_valid, m_model_height, m_pad, and m_pillars.

Here is the call graph for this function:

pad()

const Pad & Slic3r::sla::SupportTreeBuilder::pad ( ) const

inline

{ return m_pad; }

References m_pad.

Referenced by full_height(), and retrieve_mesh().

Here is the caller graph for this function:

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

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.

pillars()

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

inline

{ return m_pillars; }

References m_pillars.

remove_pad()

void Slic3r::sla::SupportTreeBuilder::remove_pad ( )

inlineoverridevirtual

Implements Slic3r::sla::SupportTree.

{ m_pad = Pad(); }

References m_pad, and Slic3r::sla::Pad.

retrieve_full_mesh()

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

inherited

                                                                        {
    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

overridevirtual

Implements Slic3r::sla::SupportTree.

{
    switch(meshtype) {
    case MeshType::Support: return merged_mesh();
    case MeshType::Pad:     return pad().tmesh;
    }
    
    return m_meshcache;
}

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

Here is the call graph for this function:

slice()

std::vector< ExPolygons > Slic3r::sla::SupportTree::slice ( const std::vector< float > & grid, float closing_radius ) const

inherited

{
    const indexed_triangle_set &sup_mesh = retrieve_mesh(MeshType::Support);
    const indexed_triangle_set &pad_mesh = retrieve_mesh(MeshType::Pad);
 
    using Slices = std::vector<ExPolygons>;
    auto slices = reserve_vector<Slices>(2);
 
    if (!sup_mesh.empty()) {
        slices.emplace_back();
        slices.back() = slice_mesh_ex(sup_mesh, grid, cr, ctl().cancelfn);
    }
 
    if (!pad_mesh.empty()) {
        slices.emplace_back();
 
        auto bb = bounding_box(pad_mesh);
        auto maxzit = std::upper_bound(grid.begin(), grid.end(), bb.max.z());
        
        auto cap = grid.end() - maxzit;
        auto padgrid = reserve_vector<float>(size_t(cap > 0 ? cap : 0));
        std::copy(grid.begin(), maxzit, std::back_inserter(padgrid));
 
        slices.back() = slice_mesh_ex(pad_mesh, padgrid, cr, ctl().cancelfn);
    }
 
    size_t len = grid.size();
    for (const Slices &slv : slices) { len = std::min(len, slv.size()); }
 
    // Either the support or the pad or both has to be non empty
    if (slices.empty()) return {};
 
    Slices &mrg = slices.front();
 
    for (auto it = std::next(slices.begin()); it != slices.end(); ++it) {
        for (size_t i = 0; i < len; ++i) {
            Slices &slv = *it;
            std::copy(slv[i].begin(), slv[i].end(), std::back_inserter(mrg[i]));
            slv[i] = {}; // clear and delete
        }
    }
 
    return mrg;
}

References Slic3r::bounding_box(), ctl(), Slic3r::grid(), Slic3r::sla::Pad, Slic3r::reserve_vector(), retrieve_mesh(), Slic3r::slice_mesh_ex(), and Slic3r::sla::Support.

Here is the call graph for this function:

Member Data Documentation

ground_level

double Slic3r::sla::SupportTreeBuilder::ground_level = 0

Referenced by SupportTreeBuilder(), add_pad(), Slic3r::sla::SupportTreeBuildsteps::execute(), operator=(), and operator=().

m_anchors

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

private

Referenced by add_anchor(), and merged_mesh().

m_bridges

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

private

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

m_crossbridges

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

private

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

m_ctl

JobController Slic3r::sla::SupportTree::m_ctl

privateinherited

Referenced by ctl().

m_diffbridges

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

private

Referenced by add_diffbridge(), and merged_mesh().

m_head_indices

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

private

Referenced by SupportTreeBuilder(), SupportTreeBuilder(), 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 SupportTreeBuilder(), SupportTreeBuilder(), 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(), merge_and_cleanup(), and merged_mesh().

m_meshcache

indexed_triangle_set Slic3r::sla::SupportTreeBuilder::m_meshcache

mutableprivate

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

m_meshcache_valid

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

mutableprivate

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

m_model_height

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

mutableprivate

Referenced by SupportTreeBuilder(), merged_mesh(), mesh_height(), 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_pad

Pad Slic3r::sla::SupportTreeBuilder::m_pad

private

Referenced by SupportTreeBuilder(), SupportTreeBuilder(), add_pad(), operator=(), operator=(), pad(), and remove_pad().

m_pedestals

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

private

Referenced by add_pillar_base(), and merged_mesh().

m_pillars

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

private

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

---

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

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