Slic3r::sla::BranchingTreeBuilder Class Reference

Inheritance diagram for Slic3r::sla::BranchingTreeBuilder:

Collaboration diagram for Slic3r::sla::BranchingTreeBuilder:

Public Member Functions
	BranchingTreeBuilder (SupportTreeBuilder &builder, const SupportableMesh &sm, const branchingtree::PointCloud &cloud)
bool	add_bridge (const branchingtree::Node &from, const branchingtree::Node &to) override
bool	add_merger (const branchingtree::Node &node, const branchingtree::Node &closest, const branchingtree::Node &merge_node) override
bool	add_ground_bridge (const branchingtree::Node &from, const branchingtree::Node &) override
bool	add_mesh_bridge (const branchingtree::Node &from, const branchingtree::Node &to) override
std::optional< Vec3f >	suggest_avoidance (const branchingtree::Node &from, float max_bridge_len) const override
void	report_unroutable (const branchingtree::Node &j) override
const std::vector< size_t > &	unroutable_pinheads () const
bool	is_valid () const override
const std::vector< branchingtree::Node > &	pillars () const
const GroundConnection *	ground_conn (size_t pillar) const

Private Member Functions
double	get_radius (const branchingtree::Node &j) const
void	build_subtree (size_t root)
void	discard_subtree (size_t root)
void	discard_subtree_rescure (size_t root)

Private Attributes
SupportTreeBuilder &	m_builder
const SupportableMesh &	m_sm
const branchingtree::PointCloud &	m_cloud
std::vector< branchingtree::Node >	m_pillars
std::map< int, GroundConnection >	m_gnd_connections
execution::SpinningMutex< ExecutionTBB >	m_gnd_connections_mtx
std::vector< size_t >	m_unroutable_pinheads

Static Private Attributes
static constexpr double	WIDENING_SCALE = 0.05

Detailed Description

Constructor & Destructor Documentation

BranchingTreeBuilder()

Slic3r::sla::BranchingTreeBuilder::BranchingTreeBuilder ( SupportTreeBuilder &  builder, const SupportableMesh &  sm, const branchingtree::PointCloud &  cloud  )

inline

        : m_builder{builder}, m_sm{sm}, m_cloud{cloud}
    {}

Member Function Documentation

add_bridge()

bool Slic3r::sla::BranchingTreeBuilder::add_bridge ( const branchingtree::Node &  from, const branchingtree::Node &  to  )

overridevirtual

Implements Slic3r::branchingtree::Builder.

{
    Vec3d fromd = from.pos.cast<double>(), tod = to.pos.cast<double>();
    double fromR = get_radius(from), toR = get_radius(to);
    Beam beam{Ball{fromd, fromR}, Ball{tod, toR}};
    auto   hit = beam_mesh_hit(beam_ex_policy , m_sm.emesh, beam,
                               m_sm.cfg.safety_distance_mm);
 
    bool ret = hit.distance() > (tod - fromd).norm();
 
    return ret;
}

References Slic3r::sla::beam_ex_policy, Slic3r::sla::beam_mesh_hit(), Slic3r::sla::SupportableMesh::cfg, Slic3r::sla::SupportableMesh::emesh, get_radius(), m_sm, Slic3r::branchingtree::Node::pos, and Slic3r::sla::SupportTreeConfig::safety_distance_mm.

Here is the call graph for this function:

add_ground_bridge()

bool Slic3r::sla::BranchingTreeBuilder::add_ground_bridge ( const branchingtree::Node &  from, const branchingtree::Node &  to  )

overridevirtual

Implements Slic3r::branchingtree::Builder.

{
    bool ret = false;
 
    namespace bgi = boost::geometry::index;
 
    auto it = m_gnd_connections.find(from.id);
    const GroundConnection *connptr = nullptr;
 
    if (it == m_gnd_connections.end()) {
        sla::Junction j{from.pos.cast<double>(), get_radius(from)};
        Vec3d init_dir = (to.pos - from.pos).cast<double>().normalized();
 
        auto conn = deepsearch_ground_connection(beam_ex_policy , m_sm, j,
                                                 get_radius(to), init_dir);
 
        // Remember that this node was tested if can go to ground, don't
        // test it with any other destination ground point because
        // it is unlikely that search_ground_route would find a better solution
        connptr = &(m_gnd_connections[from.id] = conn);
    } else {
        connptr = &(it->second);
    }
 
    if (connptr && *connptr) {
        m_pillars.emplace_back(from);
        ret = true;
        build_subtree(from.id);
    }
 
    return ret;
}

References Slic3r::sla::beam_ex_policy, build_subtree(), Slic3r::sla::deepsearch_ground_connection(), get_radius(), Slic3r::branchingtree::Node::id, m_gnd_connections, m_pillars, m_sm, and Slic3r::branchingtree::Node::pos.

Referenced by discard_subtree_rescure(), and report_unroutable().

Here is the call graph for this function:

Here is the caller graph for this function:

add_merger()

bool Slic3r::sla::BranchingTreeBuilder::add_merger ( const branchingtree::Node &  node, const branchingtree::Node &  closest, const branchingtree::Node &  merge_node  )

overridevirtual

Implements Slic3r::branchingtree::Builder.

{
    Vec3d from1d = node.pos.cast<double>(),
          from2d = closest.pos.cast<double>(),
          tod    = merge_node.pos.cast<double>();
 
    double mergeR   = get_radius(merge_node);
    double nodeR    = get_radius(node);
    double closestR = get_radius(closest);
    Beam beam1{Ball{from1d, nodeR}, Ball{tod, mergeR}};
    Beam beam2{Ball{from2d, closestR}, Ball{tod, mergeR}};
 
    auto sd = m_sm.cfg.safety_distance_mm ;
    auto hit1 = beam_mesh_hit(beam_ex_policy , m_sm.emesh, beam1, sd);
    auto hit2 = beam_mesh_hit(beam_ex_policy , m_sm.emesh, beam2, sd);
 
    bool ret = hit1.distance() > (tod - from1d).norm() &&
               hit2.distance() > (tod - from2d).norm();
 
    return ret;
}

References Slic3r::sla::beam_ex_policy, Slic3r::sla::beam_mesh_hit(), Slic3r::sla::SupportableMesh::cfg, Slic3r::sla::SupportableMesh::emesh, get_radius(), m_sm, Slic3r::branchingtree::Node::pos, and Slic3r::sla::SupportTreeConfig::safety_distance_mm.

Here is the call graph for this function:

add_mesh_bridge()

bool Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge ( const branchingtree::Node &  from, const branchingtree::Node &  to  )

overridevirtual

Implements Slic3r::branchingtree::Builder.

{
    if (from.weight > m_sm.cfg.max_weight_on_model_support)
        return false;
 
    sla::Junction fromj = {from.pos.cast<double>(), get_radius(from)};
 
    auto anchor = m_sm.cfg.ground_facing_only ?
                      std::optional<Anchor>{} : // If no mesh connections are allowed
                      calculate_anchor_placement(beam_ex_policy , m_sm, fromj,
                                                 to.pos.cast<double>());
 
    if (anchor) {
        sla::Junction toj = {anchor->junction_point(), anchor->r_back_mm};
 
        auto hit = beam_mesh_hit(beam_ex_policy , m_sm.emesh,
                                 Beam{{fromj.pos, fromj.r}, {toj.pos, toj.r}}, 0.);
 
        if (hit.distance() > distance(fromj.pos, toj.pos)) {
            m_builder.add_diffbridge(fromj.pos, toj.pos, fromj.r, toj.r);
            m_builder.add_anchor(*anchor);
 
            build_subtree(from.id);
        } else {
            anchor.reset();
        }
    }
 
    return bool(anchor);
}

References Slic3r::sla::SupportTreeBuilder::add_anchor(), Slic3r::sla::SupportTreeBuilder::add_diffbridge(), Slic3r::sla::beam_ex_policy, Slic3r::sla::beam_mesh_hit(), build_subtree(), Slic3r::sla::calculate_anchor_placement(), Slic3r::sla::SupportableMesh::cfg, Slic3r::sla::distance(), Slic3r::sla::SupportableMesh::emesh, get_radius(), Slic3r::sla::SupportTreeConfig::ground_facing_only, Slic3r::branchingtree::Node::id, m_builder, m_sm, Slic3r::sla::SupportTreeConfig::max_weight_on_model_support, Slic3r::branchingtree::Node::pos, Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, and Slic3r::branchingtree::Node::weight.

Here is the call graph for this function:

build_subtree()

void Slic3r::sla::BranchingTreeBuilder::build_subtree ( size_t  root )

inlineprivate

    {
        traverse(m_cloud, root, [this](const branchingtree::Node &node) {
            if (node.left >= 0 && node.right >= 0) {
                auto nparent = m_cloud.get(node.id);
                auto nleft = m_cloud.get(node.left);
                auto nright = m_cloud.get(node.right);
                Vec3d from1d = nleft.pos.cast<double>();
                Vec3d from2d = nright.pos.cast<double>();
                Vec3d tod    = nparent.pos.cast<double>();
                double mergeR = get_radius(nparent);
                double leftR  = get_radius(nleft);
                double rightR = get_radius(nright);
 
                m_builder.add_diffbridge(from1d, tod, leftR, mergeR);
                m_builder.add_diffbridge(from2d, tod, rightR, mergeR);
                m_builder.add_junction(tod, mergeR);
            } else if (int child = node.left + node.right + 1; child >= 0) {
                auto from = m_cloud.get(child);
                auto to   = m_cloud.get(node.id);
                auto tod  = to.pos.cast<double>();
                double toR = get_radius(to);
                m_builder.add_diffbridge(from.pos.cast<double>(),
                                         tod,
                                         get_radius(from),
                                         toR);
                m_builder.add_junction(tod, toR);
            }
        });
    }

References Slic3r::sla::SupportTreeBuilder::add_diffbridge(), Slic3r::sla::SupportTreeBuilder::add_junction(), Slic3r::branchingtree::PointCloud::get(), get_radius(), Slic3r::branchingtree::Node::id, if(), Slic3r::branchingtree::Node::left, m_builder, m_cloud, Slic3r::branchingtree::Node::pos, and Slic3r::branchingtree::Node::right.

Referenced by add_ground_bridge(), and add_mesh_bridge().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_subtree()

void Slic3r::sla::BranchingTreeBuilder::discard_subtree ( size_t  root )

inlineprivate

    {
        // Discard all the support points connecting to this branch.
        traverse(m_cloud, root, [this](const branchingtree::Node &node) {
            int suppid_parent = m_cloud.get_leaf_id(node.id);
            int suppid_left   = m_cloud.get_leaf_id(node.left);
            int suppid_right  = m_cloud.get_leaf_id(node.right);
            if (suppid_parent >= 0)
                m_unroutable_pinheads.emplace_back(suppid_parent);
            if (suppid_left >= 0)
                m_unroutable_pinheads.emplace_back(suppid_left);
            if (suppid_right >= 0)
                m_unroutable_pinheads.emplace_back(suppid_right);
        });
    }

References Slic3r::branchingtree::PointCloud::get_leaf_id(), Slic3r::branchingtree::Node::id, Slic3r::branchingtree::Node::left, m_cloud, m_unroutable_pinheads, and Slic3r::branchingtree::Node::right.

Here is the call graph for this function:

discard_subtree_rescure()

void Slic3r::sla::BranchingTreeBuilder::discard_subtree_rescure ( size_t  root )

inlineprivate

    {
        // Discard all the support points connecting to this branch.
        // As a last resort, try to route child nodes to ground and stop
        // traversing if any child branch succeeds.
        traverse(m_cloud, root, [this](const branchingtree::Node &node) {
            branchingtree::TraverseReturnT ret{true, true};
 
            int suppid_parent = m_cloud.get_leaf_id(node.id);
            int suppid_left   = branchingtree::Node::ID_NONE;
            int suppid_right  = branchingtree::Node::ID_NONE;
 
            double glvl = ground_level(m_sm);
            branchingtree::Node dst = node;
            dst.pos.z() = glvl;
            dst.weight += node.pos.z() - glvl;
 
            if (node.left >= 0 && add_ground_bridge(m_cloud.get(node.left), dst))
                ret.to_left = false;
            else
                suppid_left = m_cloud.get_leaf_id(node.left);
 
            if (node.right >= 0 && add_ground_bridge(m_cloud.get(node.right), dst))
                ret.to_right = false;
            else
                suppid_right = m_cloud.get_leaf_id(node.right);
 
            if (suppid_parent >= 0)
                m_unroutable_pinheads.emplace_back(suppid_parent);
            if (suppid_left >= 0)
                m_unroutable_pinheads.emplace_back(suppid_left);
            if (suppid_right >= 0)
                m_unroutable_pinheads.emplace_back(suppid_right);
 
            return ret;
        });
    }

References add_ground_bridge(), Slic3r::branchingtree::PointCloud::get(), Slic3r::branchingtree::PointCloud::get_leaf_id(), Slic3r::sla::ground_level(), Slic3r::branchingtree::Node::id, Slic3r::branchingtree::Node::ID_NONE, Slic3r::branchingtree::Node::left, m_cloud, m_sm, m_unroutable_pinheads, Slic3r::branchingtree::Node::pos, Slic3r::branchingtree::Node::right, and Slic3r::branchingtree::Node::weight.

Referenced by report_unroutable().

Here is the call graph for this function:

Here is the caller graph for this function:

get_radius()

double Slic3r::sla::BranchingTreeBuilder::get_radius ( const branchingtree::Node &  j ) const

inlineprivate

    {
        double w = WIDENING_SCALE * m_sm.cfg.pillar_widening_factor * j.weight;
 
        return double(j.Rmin) + w;
    }

References Slic3r::sla::SupportableMesh::cfg, m_sm, Slic3r::sla::SupportTreeConfig::pillar_widening_factor, Slic3r::branchingtree::Node::Rmin, Slic3r::branchingtree::Node::weight, and WIDENING_SCALE.

Referenced by add_bridge(), add_ground_bridge(), add_merger(), add_mesh_bridge(), and build_subtree().

Here is the caller graph for this function:

ground_conn()

const GroundConnection * Slic3r::sla::BranchingTreeBuilder::ground_conn ( size_t  pillar ) const

inline

    {
        const GroundConnection *ret = nullptr;
 
        auto it = m_gnd_connections.find(m_pillars[pillar].id);
        if (it != m_gnd_connections.end())
            ret = &it->second;
 
        return ret;
    }

References m_gnd_connections, and m_pillars.

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

Here is the caller graph for this function:

is_valid()

bool Slic3r::sla::BranchingTreeBuilder::is_valid ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::branchingtree::Builder.

{ return !m_builder.ctl().stopcondition(); }

References Slic3r::sla::SupportTreeBuilder::ctl(), m_builder, and Slic3r::sla::JobController::stopcondition.

Here is the call graph for this function:

pillars()

const std::vector< branchingtree::Node > & Slic3r::sla::BranchingTreeBuilder::pillars ( ) const

inline

{ return m_pillars; }

References m_pillars.

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

Here is the caller graph for this function:

report_unroutable()

void Slic3r::sla::BranchingTreeBuilder::report_unroutable ( const branchingtree::Node &  j )

inlineoverridevirtual

Implements Slic3r::branchingtree::Builder.

    {
        double glvl = ground_level(m_sm);
        branchingtree::Node dst = j;
        dst.pos.z() = glvl;
        dst.weight += j.pos.z() - glvl;
        if (add_ground_bridge(j, dst))
            return;
 
        BOOST_LOG_TRIVIAL(warning) << "Cannot route junction at " << j.pos.x()
                                   << " " << j.pos.y() << " " << j.pos.z();
 
        // Discard all the support points connecting to this branch.
        discard_subtree_rescure(j.id);
//        discard_subtree(j.id);
    }

References add_ground_bridge(), discard_subtree_rescure(), Slic3r::sla::ground_level(), Slic3r::branchingtree::Node::id, m_sm, Slic3r::branchingtree::Node::pos, and Slic3r::branchingtree::Node::weight.

Here is the call graph for this function:

suggest_avoidance()

std::optional< Vec3f > Slic3r::sla::BranchingTreeBuilder::suggest_avoidance ( const branchingtree::Node &  from, float  max_bridge_len  ) const

overridevirtual

Reimplemented from Slic3r::branchingtree::Builder.

{
    std::optional<Vec3f> ret;
 
    double glvl = ground_level(m_sm);
    branchingtree::Node dst = from;
    dst.pos.z() = glvl;
    dst.weight += from.pos.z() - glvl;
    sla::Junction j{from.pos.cast<double>(), get_radius(from)};
 
    auto found_it = m_gnd_connections.end();
    {
        std::lock_guard lk{m_gnd_connections_mtx};
        found_it = m_gnd_connections.find(from.id);
    }
 
    if (found_it != m_gnd_connections.end()) {
        ret = get_avoidance(found_it->second, max_bridge_len);
    } else {
        auto conn = deepsearch_ground_connection(
            beam_ex_policy , m_sm, j, get_radius(dst), sla::DOWN);
 
        {
            std::lock_guard lk{m_gnd_connections_mtx};
            m_gnd_connections[from.id] = conn;
        }
 
        ret = get_avoidance(conn, max_bridge_len);
    }
 
    return ret;
}

References Slic3r::sla::beam_ex_policy, Slic3r::sla::deepsearch_ground_connection(), Slic3r::sla::DOWN, Slic3r::sla::get_avoidance(), Slic3r::sla::ground_level(), Slic3r::branchingtree::Node::id, Slic3r::branchingtree::Node::pos, and Slic3r::branchingtree::Node::weight.

Here is the call graph for this function:

unroutable_pinheads()

const std::vector< size_t > & Slic3r::sla::BranchingTreeBuilder::unroutable_pinheads ( ) const

inline

    {
        return m_unroutable_pinheads;
    }

References m_unroutable_pinheads.

Member Data Documentation

m_builder

SupportTreeBuilder& Slic3r::sla::BranchingTreeBuilder::m_builder

private

Referenced by add_mesh_bridge(), build_subtree(), and is_valid().

m_cloud

const branchingtree::PointCloud& Slic3r::sla::BranchingTreeBuilder::m_cloud

private

Referenced by build_subtree(), discard_subtree(), and discard_subtree_rescure().

m_gnd_connections

std::map<int, GroundConnection> Slic3r::sla::BranchingTreeBuilder::m_gnd_connections

mutableprivate

Referenced by add_ground_bridge(), and ground_conn().

m_gnd_connections_mtx

execution::SpinningMutex<ExecutionTBB> Slic3r::sla::BranchingTreeBuilder::m_gnd_connections_mtx

mutableprivate

m_pillars

std::vector<branchingtree::Node> Slic3r::sla::BranchingTreeBuilder::m_pillars

private

Referenced by add_ground_bridge(), ground_conn(), and pillars().

m_sm

const SupportableMesh& Slic3r::sla::BranchingTreeBuilder::m_sm

private

Referenced by add_bridge(), add_ground_bridge(), add_merger(), add_mesh_bridge(), discard_subtree_rescure(), get_radius(), and report_unroutable().

m_unroutable_pinheads

std::vector<size_t> Slic3r::sla::BranchingTreeBuilder::m_unroutable_pinheads

private

Referenced by discard_subtree(), discard_subtree_rescure(), and unroutable_pinheads().

WIDENING_SCALE

constexpr double Slic3r::sla::BranchingTreeBuilder::WIDENING_SCALE = 0.05

staticconstexprprivate

Referenced by get_radius().

---

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

• src/libslic3r/SLA/BranchingTreeSLA.cpp