Slic3r::FillLightning Namespace Reference

Classes
struct	GeneratorDeleter
class	Filler
class	DistanceField
class	Generator
struct	GroundingLocation
class	Layer
class	Node

Typedefs
using	GeneratorPtr = std::unique_ptr<Generator, GeneratorDeleter>
using	NodeSPtr = std::shared_ptr<Node>
using	SparseNodeGrid = std::unordered_multimap<Point, std::weak_ptr<Node>, PointHash>

Functions
GeneratorPtr	build_generator (const PrintObject &print_object, const std::function< void()> &throw_on_cancel_callback)
static Point	to_grid_point (const Point &point, const BoundingBox &bbox)
static bool	polygonCollidesWithLineSegment (const Point &from, const Point &to, const EdgeGrid::Grid &loc_to_line)
bool	inside (const Polygons &polygons, const Point &p)
bool	lineSegmentPolygonsIntersection (const Point &a, const Point &b, const EdgeGrid::Grid &outline_locator, Point &result, const coord_t within_max_dist)
coord_t	locator_cell_size ()
BoundingBox	get_extents (const NodeSPtr &root_node)
BoundingBox	get_extents (const std::vector< NodeSPtr > &tree_roots)

Variables
constexpr coord_t	radius_per_cell_size = 6

Typedef Documentation

GeneratorPtr

typedef std::unique_ptr< Generator, GeneratorDeleter > Slic3r::FillLightning::GeneratorPtr = std::unique_ptr<Generator, GeneratorDeleter>

NodeSPtr

typedef std::shared_ptr< Node > Slic3r::FillLightning::NodeSPtr = std::shared_ptr<Node>

SparseNodeGrid

using Slic3r::FillLightning::SparseNodeGrid = std::unordered_multimap<Point, std::weak_ptr<Node>, PointHash>

Function Documentation

build_generator()

GeneratorPtr Slic3r::FillLightning::build_generator	(	const PrintObject &	print_object,
		const std::function< void()> &	throw_on_cancel_callback )

{
    return GeneratorPtr(new Generator(print_object, throw_on_cancel_callback));
}

Referenced by Slic3r::PrintObject::prepare_lightning_infill_data().

Here is the caller graph for this function:

get_extents() [1/2]

BoundingBox Slic3r::FillLightning::get_extents ( const NodeSPtr & root_node )

inline

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

Referenced by Slic3r::FillLightning::DistanceField::DistanceField(), Slic3r::FillLightning::Generator::generateTrees(), Slic3r::FillLightning::Generator::generateTreesforSupport(), Slic3r::FillLightning::Node::get_extents, and Slic3r::FillLightning::Node::get_extents.

Here is the caller graph for this function:

get_extents() [2/2]

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

inline

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

inside()

bool Slic3r::FillLightning::inside	(	const Polygons &	polygons,
		const Point &	p )

{
    return contains(polygons, p, true);
}

References Slic3r::Geometry::contains().

Referenced by Slic3r::FillLightning::Node::realign().

Here is the call graph for this function:

Here is the caller graph for this function:

lineSegmentPolygonsIntersection()

bool Slic3r::FillLightning::lineSegmentPolygonsIntersection	(	const Point &	a,
		const Point &	b,
		const EdgeGrid::Grid &	outline_locator,
		Point &	result,
		const coord_t	within_max_dist )

{
    struct Visitor {
        bool operator()(coord_t iy, coord_t ix) {
            // Called with a row and colum of the grid cell, which is intersected by a line.
            auto cell_data_range = grid.cell_data_range(iy, ix);
            for (auto it_contour_and_segment = cell_data_range.first; it_contour_and_segment != cell_data_range.second; ++it_contour_and_segment) {
                // End points of the line segment and their vector.
                auto segment = grid.segment(*it_contour_and_segment);
                if (Vec2d ip; Geometry::segment_segment_intersection(segment.first.cast<double>(), segment.second.cast<double>(), this->line_a, this->line_b, ip))
                    if (double d = (this->intersection_pt - this->line_b).squaredNorm(); d < d2min) {
                        this->d2min = d;
                        this->intersection_pt = ip;
                    }
            }
            // Continue traversing the grid along the edge.
            return true;
        }
 
        const EdgeGrid::Grid& grid;
        Vec2d                 line_a;
        Vec2d                 line_b;
        Vec2d                 intersection_pt;
        double                d2min { std::numeric_limits<double>::max() };
    } visitor { outline_locator, a.cast<double>(), b.cast<double>() };
 
    outline_locator.visit_cells_intersecting_line(a, b, visitor);
    if (visitor.d2min < double(within_max_dist) * double(within_max_dist)) {
        result = Point(visitor.intersection_pt);
        return true;
    }
    return false;
}

References Slic3r::grid(), Slic3r::Geometry::segment_segment_intersection(), and Slic3r::EdgeGrid::Grid::visit_cells_intersecting_line().

Referenced by Slic3r::FillLightning::Layer::reconnectRoots().

Here is the call graph for this function:

Here is the caller graph for this function:

locator_cell_size()

coord_t Slic3r::FillLightning::locator_cell_size ( )

inline

{ return scaled<coord_t>(4.); }

References Slic3r::scaled().

Referenced by Slic3r::FillLightning::Generator::generateTrees(), Slic3r::FillLightning::Generator::generateTreesforSupport(), Slic3r::FillLightning::Layer::getBestGroundingLocation(), and to_grid_point().

Here is the call graph for this function:

Here is the caller graph for this function:

polygonCollidesWithLineSegment()

bool Slic3r::FillLightning::polygonCollidesWithLineSegment ( const Point & from, const Point & to, const EdgeGrid::Grid & loc_to_line )

static

{
    struct Visitor {
        explicit Visitor(const EdgeGrid::Grid &grid, const Line &line) : grid(grid), line(line) {}
 
        bool operator()(coord_t iy, coord_t ix) {
            // Called with a row and colum of the grid cell, which is intersected by a line.
            auto cell_data_range = grid.cell_data_range(iy, ix);
            for (auto it_contour_and_segment = cell_data_range.first; it_contour_and_segment != cell_data_range.second; ++ it_contour_and_segment) {
                // End points of the line segment and their vector.
                auto segment = grid.segment(*it_contour_and_segment);
                if (Geometry::segments_intersect(segment.first, segment.second, line.a, line.b)) {
                    this->intersect = true;
                    return false;
                }
            }
            // Continue traversing the grid along the edge.
            return true;
        }
 
        const EdgeGrid::Grid& grid;
        Line                  line;
        bool                  intersect = false;
    } visitor(loc_to_line, {from, to});
 
    loc_to_line.visit_cells_intersecting_line(from, to, visitor);
    return visitor.intersect;
}

References Slic3r::Line::a, Slic3r::Line::b, Slic3r::grid(), Slic3r::Geometry::segments_intersect(), and Slic3r::EdgeGrid::Grid::visit_cells_intersecting_line().

Here is the call graph for this function:

to_grid_point()

Point Slic3r::FillLightning::to_grid_point ( const Point & point, const BoundingBox & bbox )

inlinestatic

{
    return (point - bbox.min) / locator_cell_size();
}

References locator_cell_size(), and Slic3r::BoundingBoxBase< PointType, APointsType >::min.

Referenced by Slic3r::FillLightning::Layer::fillLocator(), Slic3r::FillLightning::Layer::generateNewTrees(), Slic3r::FillLightning::Layer::getBestGroundingLocation(), and Slic3r::FillLightning::Layer::reconnectRoots().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

radius_per_cell_size

coord_t Slic3r::FillLightning::radius_per_cell_size = 6

constexpr

Referenced by Slic3r::FillLightning::DistanceField::DistanceField().