Slic3r::FillLightning Namespace Reference

Classes
class	DistanceField
class	Filler
class	Generator
struct	GeneratorDeleter
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 coordf_t fill_density, 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	lineSegmentPolygonsIntersection (const Point &a, const Point &b, const EdgeGrid::Grid &outline_locator, Point &result, const coord_t within_max_dist)
bool	inside (const Polygons &polygons, const Point &p)
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
constexpr auto	locator_cell_size = scaled<coord_t>(4.)

Typedef Documentation

GeneratorPtr

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

NodeSPtr

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

SparseNodeGrid

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

Function Documentation

build_generator()

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

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

References Slic3r::fill_density().

Here is the call 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(), and Slic3r::FillLightning::Generator::generateTrees().

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
	)

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 segment(), 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:

polygonCollidesWithLineSegment()

static 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, segment(), and Slic3r::EdgeGrid::Grid::visit_cells_intersecting_line().

Here is the call graph for this function:

to_grid_point()

static 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 caller graph for this function:

Variable Documentation

locator_cell_size

constexpr auto Slic3r::FillLightning::locator_cell_size = scaled<coord_t>(4.)

constexpr

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

radius_per_cell_size

constexpr coord_t Slic3r::FillLightning::radius_per_cell_size = 6

constexpr