Slic3r::FillLightning::Node Class Reference

#include <src/libslic3r/Fill/Lightning/TreeNode.hpp>

Inheritance diagram for Slic3r::FillLightning::Node:

Collaboration diagram for Slic3r::FillLightning::Node:

Classes
struct	RectilinearJunction

Public Member Functions
const Point &	getLocation () const
void	setLocation (const Point &p)
NodeSPtr	addChild (const Point &p)
NodeSPtr	addChild (NodeSPtr &new_child)
void	propagateToNextLayer (std::vector< NodeSPtr > &next_trees, const Polygons &next_outlines, const EdgeGrid::Grid &outline_locator, coord_t prune_distance, coord_t smooth_magnitude, coord_t max_remove_colinear_dist) const
void	visitBranches (const std::function< void(const Point &, const Point &)> &visitor) const
void	visitNodes (const std::function< void(NodeSPtr)> &visitor)
coord_t	getWeightedDistance (const Point &unsupported_location, const coord_t &supporting_radius) const
bool	isRoot () const
void	reroot (const NodeSPtr &new_parent=nullptr)
NodeSPtr	closestNode (const Point &loc)
bool	hasOffspring (const NodeSPtr &to_be_checked) const
	Node ()=delete
void	convertToPolylines (Polylines &output, coord_t line_overlap) const
const std::optional< Point > &	getLastGroundingLocation () const

Static Public Member Functions
template<typename ... Arg>
static NodeSPtr	create (Arg &&...arg)

Protected Member Functions
	Node (const Point &p, const std::optional< Point > &last_grounding_location=std::nullopt)
NodeSPtr	deepCopy () const
bool	realign (const Polygons &outlines, const EdgeGrid::Grid &outline_locator, std::vector< NodeSPtr > &rerooted_parts)
void	straighten (coord_t magnitude, coord_t max_remove_colinear_dist)
RectilinearJunction	straighten (coord_t magnitude, const Point &junction_above, coord_t accumulated_dist, int64_t max_remove_colinear_dist2)
coord_t	prune (const coord_t &distance)
void	convertToPolylines (size_t long_line_idx, Polylines &output) const
void	removeJunctionOverlap (Polylines &polylines, coord_t line_overlap) const

Protected Attributes
bool	m_is_root
Point	m_p
std::weak_ptr< Node >	m_parent
std::vector< NodeSPtr >	m_children
std::optional< Point >	m_last_grounding_location

Friends
BoundingBox	get_extents (const NodeSPtr &root_node)
BoundingBox	get_extents (const std::vector< NodeSPtr > &tree_roots)

Detailed Description

A single vertex of a Lightning Tree, the structure that determines the paths to be printed to form Lightning Infill.

In essence these vertices are just a position linked to other positions in 2D. The nodes have a hierarchical structure of parents and children, forming a tree. The class also has some helper functions specific to Lightning Infill e.g. to straighten the paths around this node.

---

Class Documentation

Slic3r::FillLightning::Node::RectilinearJunction

struct Slic3r::FillLightning::Node::RectilinearJunction

Class Members
Point	junction_loc	junction location below
coord_t	total_recti_dist	rectilinear distance along the tree from the last junction above to the junction below

Constructor & Destructor Documentation

Node() [1/2]

Slic3r::FillLightning::Node::Node ( )

delete

Node() [2/2]

Slic3r::FillLightning::Node::Node ( const Point &  p, const std::optional< Point > &  last_grounding_location = std::nullopt  )

explicitprotected

Construct a new node, either for insertion in a tree or as root.

Parameters

p	The physical location in the 2D layer that this node represents. Connecting other nodes to this node indicates that a line segment should be drawn between those two physical positions.

                                                                              : 
    m_is_root(true), m_p(p), m_last_grounding_location(last_grounding_location)
{}

Member Function Documentation

addChild() [1/2]

NodeSPtr Slic3r::FillLightning::Node::addChild

(

const Point &

p

)

Construct a new Node instance and add it as a child of this node.

Parameters

p	The location of the new node.

Returns

A shared pointer to the new node.

{
    assert(m_p != child_loc);
    NodeSPtr child = Node::create(child_loc);
    return addChild(child);
}

References addChild(), create(), and m_p.

Referenced by addChild().

Here is the call graph for this function:

Here is the caller graph for this function:

addChild() [2/2]

NodeSPtr Slic3r::FillLightning::Node::addChild

(

NodeSPtr &

new_child

)

Add an existing Node as a child of this node.

Parameters

new_child

The node that must be added as a child.

Returns

Always returns new_child.

{
    assert(new_child != shared_from_this());
    //assert(p != new_child->p); // NOTE: No problem for now. Issue to solve later. Maybe even afetr final. Low prio.
    m_children.push_back(new_child);
    new_child->m_parent = shared_from_this();
    new_child->m_is_root = false;
    return new_child;
}

References m_children.

closestNode()

NodeSPtr Slic3r::FillLightning::Node::closestNode

(

const Point &

loc

)

Retrieves the closest node to the specified location.

Parameters

loc	The specified location.

Returns

The branch that starts at the position closest to the location within this tree.

{
    NodeSPtr result = shared_from_this();
    auto closest_dist2 = coord_t((m_p - loc).cast<double>().norm());
 
    for (const auto& child : m_children) {
        NodeSPtr candidate_node = child->closestNode(loc);
        const auto child_dist2 = coord_t((candidate_node->m_p - loc).cast<double>().norm());
        if (child_dist2 < closest_dist2) {
            closest_dist2 = child_dist2;
            result = candidate_node;
        }
    }
 
    return result;
}

References m_children, and m_p.

convertToPolylines() [1/2]

void Slic3r::FillLightning::Node::convertToPolylines	(	Polylines &	output,
		coord_t	line_overlap
	)		const

Convert the tree into polylines

At each junction one line is chosen at random to continue

The lines start at a leaf and end in a junction

Parameters

output

all branches in this tree connected into polylines

{
    Polylines result;
    result.emplace_back();
    convertToPolylines(0, result);
    removeJunctionOverlap(result, line_overlap);
    append(output, std::move(result));
}

References Slic3r::append().

Referenced by convertToPolylines().

Here is the call graph for this function:

Here is the caller graph for this function:

convertToPolylines() [2/2]

void Slic3r::FillLightning::Node::convertToPolylines ( size_t  long_line_idx, Polylines &  output  ) const

protected

Convert the tree into polylines

At each junction one line is chosen at random to continue

The lines start at a leaf and end in a junction

Parameters

long_line	a reference to a polyline in output which to continue building on in the recursion
output	all branches in this tree connected into polylines

{
    if (m_children.empty()) {
        output[long_line_idx].points.push_back(m_p);
        return;
    }
    size_t first_child_idx = rand() % m_children.size();
    m_children[first_child_idx]->convertToPolylines(long_line_idx, output);
    output[long_line_idx].points.push_back(m_p);
 
    for (size_t idx_offset = 1; idx_offset < m_children.size(); idx_offset++) {
        size_t child_idx = (first_child_idx + idx_offset) % m_children.size();
        const Node& child = *m_children[child_idx];
        output.emplace_back();
        size_t child_line_idx = output.size() - 1;
        child.convertToPolylines(child_line_idx, output);
        output[child_line_idx].points.emplace_back(m_p);
    }
}

References convertToPolylines().

Here is the call graph for this function:

create()

template<typename ... Arg>

static NodeSPtr Slic3r::FillLightning::Node::create ( Arg &&...  arg )

inlinestatic

    {
        struct EnableMakeShared : public Node
        {
            explicit EnableMakeShared(Arg&&...arg) : Node(std::forward<Arg>(arg)...) {}
        };
        return std::make_shared<EnableMakeShared>(std::forward<Arg>(arg)...);
    }

References arg().

Referenced by addChild(), and deepCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

deepCopy()

NodeSPtr Slic3r::FillLightning::Node::deepCopy ( ) const

protected

Copy this node and its entire sub-tree.

Returns

The equivalent of this node in the copy (the root of the new sub- tree).

{
    NodeSPtr local_root = Node::create(m_p);
    local_root->m_is_root = m_is_root;
    if (m_is_root)
    {
        local_root->m_last_grounding_location = m_last_grounding_location.value_or(m_p);
    }
    local_root->m_children.reserve(m_children.size());
    for (const auto& node : m_children)
    {
        NodeSPtr child = node->deepCopy();
        child->m_parent = local_root;
        local_root->m_children.push_back(child);
    }
    return local_root;
}

References create(), m_children, m_is_root, m_last_grounding_location, and m_p.

Referenced by propagateToNextLayer().

Here is the call graph for this function:

Here is the caller graph for this function:

getLastGroundingLocation()

const std::optional< Point > & Slic3r::FillLightning::Node::getLastGroundingLocation ( ) const

inline

If this was ever a direct child of the root, it'll have a previous grounding location.

This needs to be known when roots are reconnected, so that the last (higher) layer is supported by the next one.

{ return m_last_grounding_location; }

References m_last_grounding_location.

getLocation()

const Point & Slic3r::FillLightning::Node::getLocation ( ) const

inline

Get the position on this layer that this node represents, a vertex of the path to print.

Returns

The position that this node represents.

{ return m_p; }

References m_p.

Referenced by getWeightedDistance().

Here is the caller graph for this function:

getWeightedDistance()

coord_t Slic3r::FillLightning::Node::getWeightedDistance	(	const Point &	unsupported_location,
		const coord_t &	supporting_radius
	)		const

Get a weighted distance from an unsupported point to this node (given the current supporting radius).

When attaching a unsupported location to a node, not all nodes have the same priority. (Eucludian) closer nodes are prioritised, but that's not the whole story. For instance, we give some nodes a 'valence boost' depending on the nr. of branches.

Parameters

unsupported_location	The (unsuppported) location of which the weighted distance needs to be calculated.
supporting_radius	The maximum distance which can be bridged without (infill) supporting it.

Returns

The weighted distance.

{
    constexpr coord_t min_valence_for_boost = 0;
    constexpr coord_t max_valence_for_boost = 4;
    constexpr coord_t valence_boost_multiplier = 4;
 
    const size_t valence = (!m_is_root) + m_children.size();
    const coord_t valence_boost = (min_valence_for_boost < valence && valence < max_valence_for_boost) ? valence_boost_multiplier * supporting_radius : 0;
    const auto dist_here = coord_t((getLocation() - unsupported_location).cast<double>().norm());
    return dist_here - valence_boost;
}

References getLocation(), m_children, and m_is_root.

Here is the call graph for this function:

hasOffspring()

bool Slic3r::FillLightning::Node::hasOffspring

(

const NodeSPtr &

to_be_checked

)

const

Returns whether the given tree node is a descendant of this node.

If this node itself is given, it is also considered to be a descendant.

Parameters

to_be_checked

A node to find out whether it is a descendant of this node.

Returns

true if the given node is a descendant or this node itself, or false if it is not in the sub-tree.

{
    if (to_be_checked == shared_from_this())
        return true;
 
    for (auto& child_ptr : m_children)
        if (child_ptr->hasOffspring(to_be_checked)) 
            return true;
 
    return false;
}

References m_children.

isRoot()

bool Slic3r::FillLightning::Node::isRoot ( ) const

inline

Returns whether this node is the root of a lightning tree. It is the root if it has no parents.

Returns

true if this node is the root (no parents) or false if it is a child node of some other node.

{ return m_is_root; }

References m_is_root.

propagateToNextLayer()

void Slic3r::FillLightning::Node::propagateToNextLayer	(	std::vector< NodeSPtr > &	next_trees,
		const Polygons &	next_outlines,
		const EdgeGrid::Grid &	outline_locator,
		coord_t	prune_distance,
		coord_t	smooth_magnitude,
		coord_t	max_remove_colinear_dist
	)		const

Propagate this node's sub-tree to the next layer.

Creates a copy of this tree, realign it to the new layer boundaries next_outlines and reduce (i.e. prune and straighten) it. A copy of this node and all of its descendant nodes will be added to the next_trees vector.

Parameters

next_trees	A collection of tree nodes to use for the next layer.
next_outlines	The shape of the layer below, to make sure that the tree stays within the bounds of the infill area.
prune_distance	The maximum distance that a leaf node may be moved such that it still supports the current node.
smooth_magnitude	The maximum distance that a line may be shifted to straighten the tree's paths, such that it still supports the current paths.
max_remove_colinear_dist	The maximum distance of a line-segment from which straightening may remove a colinear point.

{
    auto tree_below = deepCopy();
    tree_below->prune(prune_distance);
    tree_below->straighten(smooth_magnitude, max_remove_colinear_dist);
    if (tree_below->realign(next_outlines, outline_locator, next_trees))
        next_trees.push_back(tree_below);
}

References deepCopy().

Here is the call graph for this function:

prune()

coord_t Slic3r::FillLightning::Node::prune ( const coord_t &  distance )

protected

Prune the tree from the extremeties (leaf-nodes) until the pruning distance is reached.

Returns

The distance that has been pruned. If less than distance, then the whole tree was puned away.

{
    if (pruning_distance <= 0)
        return 0;
 
    coord_t max_distance_pruned = 0;
    for (auto child_it = m_children.begin(); child_it != m_children.end(); ) {
        auto& child = *child_it;
        coord_t dist_pruned_child = child->prune(pruning_distance);
        if (dist_pruned_child >= pruning_distance)
        { // pruning is finished for child; dont modify further
            max_distance_pruned = std::max(max_distance_pruned, dist_pruned_child);
            ++child_it;
        } else {
            const Point a = getLocation();
            const Point b = child->getLocation();
            const Point ba = a - b;
            const auto ab_len = coord_t(ba.cast<double>().norm());
            if (dist_pruned_child + ab_len <= pruning_distance) { 
                // we're still in the process of pruning
                assert(child->m_children.empty() && "when pruning away a node all it's children must already have been pruned away");
                max_distance_pruned = std::max(max_distance_pruned, dist_pruned_child + ab_len);
                child_it = m_children.erase(child_it);
            } else {
                // pruning stops in between this node and the child
                const Point n = b + (ba.cast<double>().normalized() * (pruning_distance - dist_pruned_child)).cast<coord_t>();
                assert(std::abs((n - b).cast<double>().norm() + dist_pruned_child - pruning_distance) < 10 && "total pruned distance must be equal to the pruning_distance");
                max_distance_pruned = std::max(max_distance_pruned, pruning_distance);
                child->setLocation(n);
                ++child_it;
            }
        }
    }
 
    return max_distance_pruned;
}

realign()

bool Slic3r::FillLightning::Node::realign ( const Polygons &  outlines, const EdgeGrid::Grid &  outline_locator, std::vector< NodeSPtr > &  rerooted_parts  )

protected

Reconnect trees from the layer above to the new outlines of the lower layer.

Returns

Wether or not the root is kept (false is no, true is yes).

{
    if (outlines.empty())
        return false;
 
    if (contains(outlines, m_p)) {
        // Only keep children that have an unbroken connection to here, realign will put the rest in rerooted parts due to recursion:
        Point coll;
        bool reground_me = false;
        m_children.erase(std::remove_if(m_children.begin(), m_children.end(), [&](const NodeSPtr &child) {
            bool connect_branch = child->realign(outlines, outline_locator, rerooted_parts);
            // Find an intersection of the line segment from p to child->p, at maximum outline_locator.resolution() * 2 distance from p.
            if (connect_branch && lineSegmentPolygonsIntersection(child->m_p, m_p, outline_locator, coll, outline_locator.resolution() * 2)) {
                child->m_last_grounding_location.reset();
                child->m_parent.reset();
                child->m_is_root = true;
                rerooted_parts.push_back(child);
                reground_me = true;
                connect_branch = false;
            }
            return ! connect_branch;
        }), m_children.end());
        if (reground_me)
            m_last_grounding_location.reset();
        return true;
    }
 
    // 'Lift' any decendants out of this tree:
    for (auto& child : m_children)
        if (child->realign(outlines, outline_locator, rerooted_parts)) {
            child->m_last_grounding_location = m_p;
            child->m_parent.reset();
            child->m_is_root = true;
            rerooted_parts.push_back(child);
        }
 
    m_children.clear();
    return false;
}

References Slic3r::contains(), m_children, m_last_grounding_location, and m_p.

Here is the call graph for this function:

removeJunctionOverlap()

void Slic3r::FillLightning::Node::removeJunctionOverlap ( Polylines &  polylines, coord_t  line_overlap  ) const

protected

{
    const coord_t reduction    = line_overlap;
    size_t        res_line_idx = 0;
    while (res_line_idx < result_lines.size()) {
        Polyline &polyline = result_lines[res_line_idx];
        if (polyline.size() <= 1) {
            polyline = std::move(result_lines.back());
            result_lines.pop_back();
            continue;
        }
 
        coord_t to_be_reduced = reduction;
        Point a = polyline.back();
        for (int point_idx = int(polyline.size()) - 2; point_idx >= 0; point_idx--) {
            const Point b = polyline.points[point_idx];
            const Point ab = b - a;
            const auto ab_len = coord_t(ab.cast<double>().norm());
            if (ab_len >= to_be_reduced) {
                polyline.points.back() = a + (ab.cast<double>() * (double(to_be_reduced) / ab_len)).cast<coord_t>();
                break;
            } else {
                to_be_reduced -= ab_len;
                polyline.points.pop_back();
            }
            a = b;
        }
 
        if (polyline.size() <= 1) {
            polyline = std::move(result_lines.back());
            result_lines.pop_back();
        } else
            ++ res_line_idx;
    }
}

References Slic3r::MultiPoint::back(), Slic3r::MultiPoint::points, and Slic3r::MultiPoint::size().

Here is the call graph for this function:

reroot()

void Slic3r::FillLightning::Node::reroot

(

const NodeSPtr &

new_parent = nullptr

)

Reverse the parent-child relationship all the way to the root, from this node onward. This has the effect of 're-rooting' the tree at the current node if no immediate parent is given as argument. That is, the current node will become the root, it's (former) parent if any, will become one of it's children. This is then recursively bubbled up until it reaches the (former) root, which then will become a leaf.

Parameters

new_parent

The (new) parent-node of the root, useful for recursing or immediately attaching the node to another tree.

{
    if (! m_is_root) {
        auto old_parent = m_parent.lock();
        old_parent->reroot(shared_from_this());
        m_children.push_back(old_parent);
    }
 
    if (new_parent) {
        m_children.erase(std::remove(m_children.begin(), m_children.end(), new_parent), m_children.end());
        m_is_root = false;
        m_parent = new_parent;
    } else {
        m_is_root = true;
        m_parent.reset();
    }
}

References m_children, m_is_root, and m_parent.

setLocation()

void Slic3r::FillLightning::Node::setLocation ( const Point &  p )

inline

Change the position on this layer that the node represents.

Parameters

p	The position that the node needs to represent.

{ m_p = p; }

References m_p.

straighten() [1/2]

Node::RectilinearJunction Slic3r::FillLightning::Node::straighten ( coord_t  magnitude, const Point &  junction_above, coord_t  accumulated_dist, int64_t  max_remove_colinear_dist2  )

protected

Recursive part of straighten(.)

Parameters

junction_above	The last seen junction with multiple children above
accumulated_dist	The distance along the tree from the last seen junction to this node
max_remove_colinear_dist2	Maximum distance squared of the (compound) line-segment from which a co-linear point may be removed.

Returns

the total distance along the tree from the last junction above to the first next junction below and the location of the next junction below

{
    constexpr coord_t junction_magnitude_factor_numerator = 3;
    constexpr coord_t junction_magnitude_factor_denominator = 4;
 
    const coord_t junction_magnitude = magnitude * junction_magnitude_factor_numerator / junction_magnitude_factor_denominator;
    if (m_children.size() == 1)
    {
        auto child_p = m_children.front();
        auto child_dist = coord_t((m_p - child_p->m_p).cast<double>().norm());
        RectilinearJunction junction_below = child_p->straighten(magnitude, junction_above, accumulated_dist + child_dist, max_remove_colinear_dist2);
        coord_t total_dist_to_junction_below = junction_below.total_recti_dist;
        const Point& a = junction_above;
        Point        b = junction_below.junction_loc;
        if (a != b) // should always be true!
        {
            Point ab = b - a;
            Point destination = (a.cast<int64_t>() + ab.cast<int64_t>() * int64_t(accumulated_dist) / std::max(int64_t(1), int64_t(total_dist_to_junction_below))).cast<coord_t>();
            if ((destination - m_p).cast<int64_t>().squaredNorm() <= int64_t(magnitude) * int64_t(magnitude))
                m_p = destination;
            else
                m_p += ((destination - m_p).cast<double>().normalized() * magnitude).cast<coord_t>();
        }
        { // remove nodes on linear segments
            constexpr coord_t close_enough = 10;
 
            child_p = m_children.front(); //recursive call to straighten might have removed the child
            const NodeSPtr& parent_node = m_parent.lock();
            if (parent_node &&
                (child_p->m_p - parent_node->m_p).cast<int64_t>().squaredNorm() < max_remove_colinear_dist2 &&
                Line::distance_to_squared(m_p, parent_node->m_p, child_p->m_p) < close_enough * close_enough) {
                child_p->m_parent = m_parent;
                for (auto& sibling : parent_node->m_children)
                { // find this node among siblings
                    if (sibling == shared_from_this())
                    {
                        sibling = child_p; // replace this node by child
                        break;
                    }
                }
            }
        }
        return junction_below;
    }
    else
    {
        constexpr coord_t weight = 1000;
        Point junction_moving_dir = ((junction_above - m_p).cast<double>().normalized() * weight).cast<coord_t>();
        bool prevent_junction_moving = false;
        for (auto& child_p : m_children)
        {
            const auto child_dist = coord_t((m_p - child_p->m_p).cast<double>().norm());
            RectilinearJunction below = child_p->straighten(magnitude, m_p, child_dist, max_remove_colinear_dist2);
 
            junction_moving_dir += ((below.junction_loc - m_p).cast<double>().normalized() * weight).cast<coord_t>();
            if (below.total_recti_dist < magnitude) // TODO: make configurable?
            {
                prevent_junction_moving = true; // prevent flipflopping in branches due to straightening and junctoin moving clashing
            }
        }
        if (junction_moving_dir != Point(0, 0) && ! m_children.empty() && ! m_is_root && ! prevent_junction_moving)
        {
            auto junction_moving_dir_len = coord_t(junction_moving_dir.norm());
            if (junction_moving_dir_len > junction_magnitude)
            {
                junction_moving_dir = junction_moving_dir * junction_magnitude / junction_moving_dir_len;
            }
            m_p += junction_moving_dir;
        }
        return RectilinearJunction{ accumulated_dist, m_p };
    }
}

References Slic3r::Line::distance_to_squared(), Slic3r::FillLightning::Node::RectilinearJunction::junction_loc, and Slic3r::FillLightning::Node::RectilinearJunction::total_recti_dist.

Here is the call graph for this function:

straighten() [2/2]

void Slic3r::FillLightning::Node::straighten ( coord_t  magnitude, coord_t  max_remove_colinear_dist  )

protected

Smoothen the tree to make it a bit more printable, while still supporting the trees above.

Parameters

magnitude	The maximum allowed distance to move the node.
max_remove_colinear_dist	Maximum distance of the (compound) line-segment from which a co-linear point may be removed.

{
    straighten(magnitude, m_p, 0, int64_t(max_remove_colinear_dist) * int64_t(max_remove_colinear_dist));
}

visitBranches()

void Slic3r::FillLightning::Node::visitBranches

(

const std::function< void(const Point &, const Point &)> &

visitor

)

const

Executes a given function for every line segment in this node's sub-tree.

The function takes two Point arguments. These arguments will be filled in with the higher-order node (closer to the root) first, and the downtree node (closer to the leaves) as the second argument. The segment from this node's parent to this node itself is not included. The order in which the segments are visited is depth-first.

Parameters

visitor

A function to execute for every branch in the node's sub- tree.

{
    for (const auto& node : m_children) {
        assert(node->m_parent.lock() == shared_from_this());
        visitor(m_p, node->m_p);
        node->visitBranches(visitor);
    }
}

References m_children, and m_p.

visitNodes()

void Slic3r::FillLightning::Node::visitNodes

(

const std::function< void(NodeSPtr)> &

visitor

)

Execute a given function for every node in this node's sub-tree.

The visitor function takes a node as input. This node is not const, so this can be used to change the tree. Nodes are visited in depth-first order. This node itself is visited as well (pre-order).

Parameters

visitor

A function to execute for every node in this node's sub- tree.

{
    visitor(shared_from_this());
    for (const auto& node : m_children) {
        assert(node->m_parent.lock() == shared_from_this());
        node->visitNodes(visitor);
    }
}

References m_children.

Friends And Related Symbol Documentation

get_extents [1/2]

BoundingBox get_extents ( const NodeSPtr &  root_node )

friend

{
    BoundingBox bbox;
    for (const NodeSPtr &children : root_node->m_children)
        bbox.merge(get_extents(children));
    bbox.merge(root_node->getLocation());
    return bbox;
}

get_extents [2/2]

BoundingBox get_extents ( const std::vector< NodeSPtr > &  tree_roots )

friend

{
    BoundingBox bbox;
    for (const NodeSPtr &root_node : tree_roots)
        bbox.merge(get_extents(root_node));
    return bbox;
}

Member Data Documentation

m_children

std::vector<NodeSPtr> Slic3r::FillLightning::Node::m_children

protected

Referenced by addChild(), closestNode(), deepCopy(), getWeightedDistance(), hasOffspring(), realign(), reroot(), visitBranches(), and visitNodes().

m_is_root

bool Slic3r::FillLightning::Node::m_is_root

protected

Referenced by deepCopy(), getWeightedDistance(), isRoot(), and reroot().

m_last_grounding_location

std::optional<Point> Slic3r::FillLightning::Node::m_last_grounding_location

protected

Referenced by deepCopy(), getLastGroundingLocation(), and realign().

m_p

Point Slic3r::FillLightning::Node::m_p

protected

Referenced by addChild(), closestNode(), deepCopy(), getLocation(), realign(), setLocation(), and visitBranches().

m_parent

std::weak_ptr<Node> Slic3r::FillLightning::Node::m_parent

protected

Referenced by reroot().

---

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

• src/libslic3r/Fill/Lightning/TreeNode.hpp
• src/libslic3r/Fill/Lightning/TreeNode.cpp