Slic3r::branchingtree::PointCloud Class Reference

#include <src/libslic3r/BranchingTree/PointCloud.hpp>

Collaboration diagram for Slic3r::branchingtree::PointCloud:

Classes
struct	CoordFn
struct	ZCompareFn

Public Member Functions
bool	is_outside_support_cone (const Vec3f &supp, const Vec3f &pt) const
	PointCloud (const indexed_triangle_set &M, std::vector< Node > support_leafs, const Properties &props)
	PointCloud (std::vector< Node > meshpts, std::vector< Node > bedpts, std::vector< Node > support_leafs, const Properties &props)
PtType	get_type (size_t node_id) const
const Node &	get (size_t node_id) const
Node &	get (size_t node_id)
const Node *	find (size_t node_id) const
Node *	find (size_t node_id)
int	get_leaf_id (size_t node_id) const
size_t	get_queue_idx (size_t node_id) const
float	get_distance (const Vec3f &p, size_t node) const
size_t	next_junction_id () const
size_t	insert_junction (const Node &p)
const std::vector< Node > &	get_junctions () const noexcept
const std::vector< Node > &	get_bedpoints () const noexcept
const std::vector< Node > &	get_meshpoints () const noexcept
const std::vector< Node > &	get_leafs () const noexcept
const Properties &	properties () const noexcept
void	mark_unreachable (size_t node_id)
size_t	reachable_count () const
template<class Fn >
void	foreach_reachable (const Vec3f &pos, Fn &&visitor, size_t k, double min_dist=0.)
auto	start_queue ()

Static Public Attributes
static constexpr auto	Unqueued = size_t(-1)

Private Types
using	PointIndexEl = std::pair< Vec3f, unsigned >

Static Private Member Functions
template<class PC >
static auto *	get_node (PC &&pc, size_t id)

Private Attributes
std::vector< Node >	m_leafs
std::vector< Node >	m_junctions
std::vector< Node >	m_meshpoints
std::vector< Node >	m_bedpoints
const branchingtree::Properties &	m_props
const double	cos2bridge_slope
const size_t	MESHPTS_BEGIN
const size_t	LEAFS_BEGIN
const size_t	JUNCTIONS_BEGIN
std::vector< bool >	m_searchable_indices
std::vector< size_t >	m_queue_indices
size_t	m_reachable_cnt
boost::geometry::index::rtree< PointIndexEl, boost::geometry::index::rstar< 16, 4 > >	m_ktree

Detailed Description

Member Typedef Documentation

PointIndexEl

using Slic3r::branchingtree::PointCloud::PointIndexEl = std::pair<Vec3f, unsigned>

private

Constructor & Destructor Documentation

PointCloud() [1/2]

Slic3r::branchingtree::PointCloud::PointCloud	(	const indexed_triangle_set &	M,
		std::vector< Node >	support_leafs,
		const Properties &	props
	)

    : PointCloud{sample_mesh(M, props.sampling_radius()),
                 sample_bed(props.bed_shape(),
                            props.ground_level(),
                            props.sampling_radius()),
                 std::move(support_leafs), props}
{}

PointCloud() [2/2]

Slic3r::branchingtree::PointCloud::PointCloud	(	std::vector< Node >	meshpts,
		std::vector< Node >	bedpts,
		std::vector< Node >	support_leafs,
		const Properties &	props
	)

    : m_leafs{std::move(support_leafs)}
    , m_meshpoints{std::move(meshpts)}
    , m_bedpoints{std::move(bedpts)}
    , m_props{props}
    , cos2bridge_slope{std::cos(props.max_slope()) *
                       std::abs(std::cos(props.max_slope()))}
    , MESHPTS_BEGIN{m_bedpoints.size()}
    , LEAFS_BEGIN{MESHPTS_BEGIN + m_meshpoints.size()}
    , JUNCTIONS_BEGIN{LEAFS_BEGIN + m_leafs.size()}
    , m_searchable_indices(JUNCTIONS_BEGIN + m_junctions.size(), true)
    , m_queue_indices(JUNCTIONS_BEGIN + m_junctions.size(), Unqueued)
    , m_reachable_cnt{JUNCTIONS_BEGIN + m_junctions.size()}
{
    for (size_t i = 0; i < m_bedpoints.size(); ++i) {
        m_bedpoints[i].id = int(i);
        m_ktree.insert({m_bedpoints[i].pos, i});
    }
    
    for (size_t i = 0; i < m_meshpoints.size(); ++i) {
        Node &n = m_meshpoints[i];
        n.id = int(MESHPTS_BEGIN + i);
        m_ktree.insert({n.pos, n.id});
    }
    
    for (size_t i = 0; i < m_leafs.size(); ++i) {
        Node &n = m_leafs[i];
        n.id    = int(LEAFS_BEGIN + i);
        n.left  = Node::ID_NONE;
        n.right = Node::ID_NONE;
 
        m_ktree.insert({n.pos, n.id});
    }
}

References Slic3r::branchingtree::Node::id, Slic3r::branchingtree::Node::ID_NONE, LEAFS_BEGIN, Slic3r::branchingtree::Node::left, m_bedpoints, m_ktree, m_leafs, m_meshpoints, MESHPTS_BEGIN, Slic3r::branchingtree::Node::pos, and Slic3r::branchingtree::Node::right.

Member Function Documentation

find() [1/2]

Node * Slic3r::branchingtree::PointCloud::find ( size_t  node_id )

inline

{ return get_node(*this, node_id); }

References get_node().

Here is the call graph for this function:

find() [2/2]

const Node * Slic3r::branchingtree::PointCloud::find ( size_t  node_id ) const

inline

{ return get_node(*this, node_id); }

References get_node().

Here is the call graph for this function:

foreach_reachable()

template<class Fn >

void Slic3r::branchingtree::PointCloud::foreach_reachable ( const Vec3f &  pos, Fn &&  visitor, size_t  k, double  min_dist = 0.  )

inline

    {
        // Fake output iterator
        struct Output {
            const PointCloud *self;
            Vec3f p;
            Fn &visitorfn;
 
            Output& operator *() { return *this; }
            void operator=(const PointIndexEl &el) {
                visitorfn(el.second, self->get_distance(p, el.second),
                             (p - el.first).squaredNorm());
            }
            Output& operator++() { return *this; }
        };
 
        namespace bgi = boost::geometry::index;
        float brln = 2 * m_props.max_branch_length();
        BoundingBox3Base<Vec3f> bb{{pos.x() - brln, pos.y() - brln,
                                    float(m_props.ground_level() - EPSILON)},
                                   {pos.x() + brln, pos.y() + brln,
                                    m_ktree.bounds().max_corner().get<Z>()}};
 
        // Extend upwards to find mergable junctions and support points
        bb.max.z() = m_ktree.bounds().max_corner().get<Z>();
 
        auto filter = bgi::satisfies(
                          [this, &pos, min_dist](const PointIndexEl &e) {
                              double D_branching = get_distance(pos, e.second);
                              double D_euql      = (pos - e.first).squaredNorm() ;
                              return m_searchable_indices[e.second] &&
                                     !std::isinf(D_branching) && D_euql > min_dist;
                          });
 
        m_ktree.query(bgi::intersects(bb) && filter && bgi::nearest(pos, k),
                      Output{this, pos, visitor});
    }

References EPSILON, get_distance(), Slic3r::branchingtree::Properties::ground_level(), m_ktree, m_props, m_searchable_indices, Slic3r::branchingtree::Properties::max_branch_length(), and Slic3r::Z.

Referenced by Slic3r::branchingtree::build_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

get() [1/2]

Node & Slic3r::branchingtree::PointCloud::get ( size_t  node_id )

inline

    {
        return *get_node(*this, node_id);
    }

References get_node().

Here is the call graph for this function:

get() [2/2]

const Node & Slic3r::branchingtree::PointCloud::get ( size_t  node_id ) const

inline

    {
        return *get_node(*this, node_id);
    }

References get_node().

Referenced by Slic3r::sla::BranchingTreeBuilder::build_subtree(), Slic3r::branchingtree::build_tree(), Slic3r::sla::BranchingTreeBuilder::discard_subtree_rescure(), get_distance(), Slic3r::branchingtree::PointCloud::ZCompareFn::operator()(), and Slic3r::branchingtree::PointCloud::CoordFn::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bedpoints()

const std::vector< Node > & Slic3r::branchingtree::PointCloud::get_bedpoints ( ) const

inlinenoexcept

{ return m_bedpoints; }

References m_bedpoints.

get_distance()

float Slic3r::branchingtree::PointCloud::get_distance	(	const Vec3f &	p,
		size_t	node
	)		const

{
    auto t = get_type(node_id);
    auto ret = std::numeric_limits<float>::infinity();
    const auto &node = get(node_id);
    
    switch (t) {
    case MESH:
    case BED: {
        // Points of mesh or bed which are outside of the support cone of
        // 'pos' must be discarded.
        if (is_outside_support_cone(p, node.pos))
            ret = std::numeric_limits<float>::infinity();
        else
            ret  = (node.pos - p).norm();
        
        break;
    }
    case LEAF:
    case JUNCTION:{
        auto mergept = find_merge_pt(p, node.pos, m_props.max_slope());
        double maxL2 = m_props.max_branch_length() * m_props.max_branch_length();
 
        if (!mergept || mergept->z() < (m_props.ground_level() + 2 * node.Rmin))
            ret = std::numeric_limits<float>::infinity();
        else if (double a = (node.pos - *mergept).squaredNorm(),
                 b        = (p - *mergept).squaredNorm();
                 a < maxL2 && b < maxL2)
            ret = std::sqrt(b);
 
        break;
    }
    case NONE:
        ;
    }
    
    // Setting the ret val to infinity will effectively discard this
    // connection of nodes. max_branch_length property is used here
    // to discard node=>node and node=>mesh connections longer than this
    // property.
    if (t != BED && ret > m_props.max_branch_length())
        ret = std::numeric_limits<float>::infinity();
    
    return ret;
}

References Slic3r::branchingtree::BED, Slic3r::branchingtree::find_merge_pt(), get(), get_type(), Slic3r::branchingtree::Properties::ground_level(), is_outside_support_cone(), Slic3r::branchingtree::JUNCTION, Slic3r::branchingtree::LEAF, m_props, Slic3r::branchingtree::Properties::max_branch_length(), Slic3r::branchingtree::Properties::max_slope(), Slic3r::branchingtree::MESH, and Slic3r::branchingtree::NONE.

Referenced by foreach_reachable().

Here is the call graph for this function:

Here is the caller graph for this function:

get_junctions()

const std::vector< Node > & Slic3r::branchingtree::PointCloud::get_junctions ( ) const

inlinenoexcept

{ return m_junctions; }

References m_junctions.

get_leaf_id()

int Slic3r::branchingtree::PointCloud::get_leaf_id ( size_t  node_id ) const

inline

    {
        return node_id >= LEAFS_BEGIN && node_id < JUNCTIONS_BEGIN ?
                   node_id - LEAFS_BEGIN :
                   Node::ID_NONE;
    }

References Slic3r::branchingtree::Node::ID_NONE, JUNCTIONS_BEGIN, and LEAFS_BEGIN.

Referenced by Slic3r::sla::BranchingTreeBuilder::discard_subtree(), and Slic3r::sla::BranchingTreeBuilder::discard_subtree_rescure().

Here is the caller graph for this function:

get_leafs()

const std::vector< Node > & Slic3r::branchingtree::PointCloud::get_leafs ( ) const

inlinenoexcept

{ return m_leafs; }

References m_leafs.

get_meshpoints()

const std::vector< Node > & Slic3r::branchingtree::PointCloud::get_meshpoints ( ) const

inlinenoexcept

{ return m_meshpoints; }

References m_meshpoints.

get_node()

template<class PC >

static auto * Slic3r::branchingtree::PointCloud::get_node ( PC &&  pc, size_t  id  )

inlinestaticprivate

    {
        auto *ret = decltype(pc.m_bedpoints.data())(nullptr);
 
        switch(pc.get_type(id)) {
        case BED: ret = &pc.m_bedpoints[id]; break;
        case MESH: ret = &pc.m_meshpoints[id - pc.MESHPTS_BEGIN]; break;
        case LEAF: ret = &pc.m_leafs [id - pc.LEAFS_BEGIN]; break;
        case JUNCTION: ret = &pc.m_junctions[id - pc.JUNCTIONS_BEGIN]; break;
        case NONE: assert(false);
        }
 
        return ret;
    }

References Slic3r::branchingtree::BED, Slic3r::branchingtree::JUNCTION, Slic3r::branchingtree::LEAF, Slic3r::branchingtree::MESH, and Slic3r::branchingtree::NONE.

Referenced by find(), find(), get(), and get().

Here is the caller graph for this function:

get_queue_idx()

size_t Slic3r::branchingtree::PointCloud::get_queue_idx ( size_t  node_id ) const

inline

{ return m_queue_indices[node_id]; }

References m_queue_indices.

Referenced by Slic3r::branchingtree::build_tree().

Here is the caller graph for this function:

get_type()

PtType Slic3r::branchingtree::PointCloud::get_type ( size_t  node_id ) const

inline

    {
        PtType ret = NONE;
 
        if (node_id < MESHPTS_BEGIN && !m_bedpoints.empty()) ret = BED;
        else if (node_id < LEAFS_BEGIN && !m_meshpoints.empty()) ret = MESH;
        else if (node_id < JUNCTIONS_BEGIN && !m_leafs.empty()) ret = LEAF;
        else if (node_id >= JUNCTIONS_BEGIN && !m_junctions.empty()) ret = JUNCTION;
 
        return ret;
    }

References Slic3r::branchingtree::BED, Slic3r::branchingtree::JUNCTION, JUNCTIONS_BEGIN, Slic3r::branchingtree::LEAF, LEAFS_BEGIN, m_bedpoints, m_junctions, m_leafs, m_meshpoints, Slic3r::branchingtree::MESH, MESHPTS_BEGIN, and Slic3r::branchingtree::NONE.

Referenced by Slic3r::branchingtree::build_tree(), and get_distance().

Here is the caller graph for this function:

insert_junction()

size_t Slic3r::branchingtree::PointCloud::insert_junction ( const Node &  p )

inline

    {
        size_t new_id = next_junction_id();
        m_junctions.emplace_back(p);
        m_junctions.back().id = int(new_id);
        m_ktree.insert({m_junctions.back().pos, new_id});
        m_searchable_indices.emplace_back(true);
        m_queue_indices.emplace_back(Unqueued);
        ++m_reachable_cnt;
 
        return new_id;
    }

References m_junctions, m_ktree, m_queue_indices, m_reachable_cnt, m_searchable_indices, next_junction_id(), and Unqueued.

Referenced by Slic3r::branchingtree::build_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

is_outside_support_cone()

bool Slic3r::branchingtree::PointCloud::is_outside_support_cone ( const Vec3f &  supp, const Vec3f &  pt  ) const

inline

    {
        Vec3d D = (pt - supp).cast<double>();
        double dot_sq = -D.z() * std::abs(-D.z());
 
        return dot_sq < D.squaredNorm() * cos2bridge_slope;
    }

References cos2bridge_slope.

Referenced by get_distance().

Here is the caller graph for this function:

mark_unreachable()

void Slic3r::branchingtree::PointCloud::mark_unreachable ( size_t  node_id )

inline

    {
        assert(node_id < m_searchable_indices.size());
 
        m_searchable_indices[node_id] = false;
        m_queue_indices[node_id] = Unqueued;
        --m_reachable_cnt;
    }

References m_queue_indices, m_reachable_cnt, m_searchable_indices, and Unqueued.

Referenced by Slic3r::branchingtree::build_tree().

Here is the caller graph for this function:

next_junction_id()

size_t Slic3r::branchingtree::PointCloud::next_junction_id ( ) const

inline

    {
        return JUNCTIONS_BEGIN + m_junctions.size();
    }

References JUNCTIONS_BEGIN, and m_junctions.

Referenced by Slic3r::branchingtree::build_tree(), and insert_junction().

Here is the caller graph for this function:

properties()

const Properties & Slic3r::branchingtree::PointCloud::properties ( ) const

inlinenoexcept

{ return m_props; }

References m_props.

Referenced by Slic3r::branchingtree::build_tree().

Here is the caller graph for this function:

reachable_count()

size_t Slic3r::branchingtree::PointCloud::reachable_count ( ) const

inline

{ return m_reachable_cnt; }

References m_reachable_cnt.

start_queue()

auto Slic3r::branchingtree::PointCloud::start_queue ( )

inline

    {
        auto ptsqueue = make_mutable_priority_queue<size_t, true>(
            [this](size_t el, size_t idx) { m_queue_indices[el] = idx; },
            ZCompareFn{this});
 
        ptsqueue.reserve(m_leafs.size());
        size_t iend = LEAFS_BEGIN + m_leafs.size();
        for (size_t i = LEAFS_BEGIN; i < iend; ++i)
            ptsqueue.push(i);
 
        return ptsqueue;
    }

References LEAFS_BEGIN, m_leafs, and m_queue_indices.

Referenced by Slic3r::branchingtree::build_tree().

Here is the caller graph for this function:

Member Data Documentation

cos2bridge_slope

const double Slic3r::branchingtree::PointCloud::cos2bridge_slope

private

Referenced by is_outside_support_cone().

JUNCTIONS_BEGIN

const size_t Slic3r::branchingtree::PointCloud::JUNCTIONS_BEGIN

private

Referenced by get_leaf_id(), get_type(), and next_junction_id().

LEAFS_BEGIN

const size_t Slic3r::branchingtree::PointCloud::LEAFS_BEGIN

private

Referenced by PointCloud(), get_leaf_id(), get_type(), and start_queue().

m_bedpoints

std::vector<Node> Slic3r::branchingtree::PointCloud::m_bedpoints

private

Referenced by PointCloud(), get_bedpoints(), and get_type().

m_junctions

std::vector<Node> Slic3r::branchingtree::PointCloud::m_junctions

private

Referenced by get_junctions(), get_type(), insert_junction(), and next_junction_id().

m_ktree

boost::geometry::index:: rtree<PointIndexEl, boost::geometry::index::rstar<16, 4> > Slic3r::branchingtree::PointCloud::m_ktree

private

Referenced by PointCloud(), foreach_reachable(), and insert_junction().

m_leafs

std::vector<Node> Slic3r::branchingtree::PointCloud::m_leafs

private

Referenced by PointCloud(), get_leafs(), get_type(), and start_queue().

m_meshpoints

std::vector<Node> Slic3r::branchingtree::PointCloud::m_meshpoints

private

Referenced by PointCloud(), get_meshpoints(), and get_type().

m_props

const branchingtree::Properties& Slic3r::branchingtree::PointCloud::m_props

private

Referenced by foreach_reachable(), get_distance(), and properties().

m_queue_indices

std::vector<size_t> Slic3r::branchingtree::PointCloud::m_queue_indices

private

Referenced by get_queue_idx(), insert_junction(), mark_unreachable(), and start_queue().

m_reachable_cnt

size_t Slic3r::branchingtree::PointCloud::m_reachable_cnt

private

Referenced by insert_junction(), mark_unreachable(), and reachable_count().

m_searchable_indices

std::vector<bool> Slic3r::branchingtree::PointCloud::m_searchable_indices

private

Referenced by foreach_reachable(), insert_junction(), and mark_unreachable().

MESHPTS_BEGIN

const size_t Slic3r::branchingtree::PointCloud::MESHPTS_BEGIN

private

Referenced by PointCloud(), and get_type().

Unqueued

constexpr auto Slic3r::branchingtree::PointCloud::Unqueued = size_t(-1)

staticconstexpr

Referenced by Slic3r::branchingtree::build_tree(), insert_junction(), and mark_unreachable().

---

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

• src/libslic3r/BranchingTree/PointCloud.hpp
• src/libslic3r/BranchingTree/PointCloud.cpp