Slic3r::Voronoi::Internal Namespace Reference

Typedefs
using	VD = Geometry::VoronoiDiagram
typedef double	coordinate_type
typedef boost::polygon::point_data< coordinate_type >	point_type
typedef boost::polygon::segment_data< coordinate_type >	segment_type
typedef boost::polygon::rectangle_data< coordinate_type >	rect_type
typedef VD::cell_type	cell_type
typedef VD::cell_type::source_index_type	source_index_type
typedef VD::cell_type::source_category_type	source_category_type
typedef VD::edge_type	edge_type
typedef VD::cell_container_type	cell_container_type
typedef VD::cell_container_type	vertex_container_type
typedef VD::edge_container_type	edge_container_type
typedef VD::const_cell_iterator	const_cell_iterator
typedef VD::const_vertex_iterator	const_vertex_iterator
typedef VD::const_edge_iterator	const_edge_iterator

Functions
void	color_exterior (const VD::edge_type *edge)
point_type	retrieve_point (const Points &points, const std::vector< segment_type > &segments, const cell_type &cell)
void	clip_infinite_edge (const Points &points, const std::vector< segment_type > &segments, const edge_type &edge, coordinate_type bbox_max_size, std::vector< point_type > *clipped_edge)
void	sample_curved_edge (const Points &points, const std::vector< segment_type > &segments, const edge_type &edge, std::vector< point_type > &sampled_edge, coordinate_type max_dist)

Variables
static const std::size_t	EXTERNAL_COLOR = 1

Typedef Documentation

cell_container_type

typedef VD::cell_container_type Slic3r::Voronoi::Internal::cell_container_type

cell_type

typedef VD::cell_type Slic3r::Voronoi::Internal::cell_type

const_cell_iterator

typedef VD::const_cell_iterator Slic3r::Voronoi::Internal::const_cell_iterator

const_edge_iterator

typedef VD::const_edge_iterator Slic3r::Voronoi::Internal::const_edge_iterator

const_vertex_iterator

typedef VD::const_vertex_iterator Slic3r::Voronoi::Internal::const_vertex_iterator

coordinate_type

typedef double Slic3r::Voronoi::Internal::coordinate_type

edge_container_type

typedef VD::edge_container_type Slic3r::Voronoi::Internal::edge_container_type

edge_type

typedef VD::edge_type Slic3r::Voronoi::Internal::edge_type

point_type

typedef boost::polygon::point_data<coordinate_type> Slic3r::Voronoi::Internal::point_type

rect_type

typedef boost::polygon::rectangle_data<coordinate_type> Slic3r::Voronoi::Internal::rect_type

segment_type

typedef boost::polygon::segment_data<coordinate_type> Slic3r::Voronoi::Internal::segment_type

source_category_type

typedef VD::cell_type::source_category_type Slic3r::Voronoi::Internal::source_category_type

source_index_type

typedef VD::cell_type::source_index_type Slic3r::Voronoi::Internal::source_index_type

VD

using Slic3r::Voronoi::Internal::VD = typedef Geometry::VoronoiDiagram

vertex_container_type

typedef VD::cell_container_type Slic3r::Voronoi::Internal::vertex_container_type

Function Documentation

clip_infinite_edge()

void Slic3r::Voronoi::Internal::clip_infinite_edge ( const Points &  points, const std::vector< segment_type > &  segments, const edge_type &  edge, coordinate_type  bbox_max_size, std::vector< point_type > *  clipped_edge  )

inline

    {
        assert(edge.is_infinite());
        assert((edge.vertex0() == nullptr) != (edge.vertex1() == nullptr));
 
        const cell_type& cell1 = *edge.cell();
        const cell_type& cell2 = *edge.twin()->cell();
        // Infinite edges could not be created by two segment sites.
        assert(cell1.contains_point() || cell2.contains_point());
        if (! cell1.contains_point() && ! cell2.contains_point()) {
            printf("Error! clip_infinite_edge - infinite edge separates two segment cells\n");
            return;
        }
        point_type direction;
        if (cell1.contains_point() && cell2.contains_point()) {
            assert(! edge.is_secondary());
            point_type p1 = retrieve_point(points, segments, cell1);
            point_type p2 = retrieve_point(points, segments, cell2);
            if (edge.vertex0() == nullptr)
                std::swap(p1, p2);
            direction.x(p1.y() - p2.y());
            direction.y(p2.x() - p1.x());
        } else {
            assert(edge.is_secondary());
            segment_type segment = cell1.contains_segment() ? segments[cell1.source_index()] : segments[cell2.source_index()];
            direction.x(high(segment).y() - low(segment).y());
            direction.y(low(segment).x() - high(segment).x());
        }
        coordinate_type koef = bbox_max_size / (std::max)(fabs(direction.x()), fabs(direction.y()));
        if (edge.vertex0() == nullptr) {
            clipped_edge->push_back(point_type(edge.vertex1()->x() + direction.x() * koef, edge.vertex1()->y() + direction.y() * koef));
            clipped_edge->push_back(point_type(edge.vertex1()->x(), edge.vertex1()->y()));
        } else {
            clipped_edge->push_back(point_type(edge.vertex0()->x(), edge.vertex0()->y()));
            clipped_edge->push_back(point_type(edge.vertex0()->x() + direction.x() * koef, edge.vertex0()->y() + direction.y() * koef));
        }
    }

References retrieve_point(), and segment().

Referenced by Slic3r::dump_voronoi_to_svg().

Here is the call graph for this function:

Here is the caller graph for this function:

color_exterior()

void Slic3r::Voronoi::Internal::color_exterior ( const VD::edge_type *  edge )

inline

    {
        if (edge->color() == EXTERNAL_COLOR)
            return;
        edge->color(EXTERNAL_COLOR);
        edge->twin()->color(EXTERNAL_COLOR);
        const VD::vertex_type* v = edge->vertex1();
        if (v == NULL || !edge->is_primary())
            return;
        v->color(EXTERNAL_COLOR);
        const VD::edge_type* e = v->incident_edge();
        do {
            color_exterior(e);
            e = e->rot_next();
        } while (e != v->incident_edge());
    }

References color_exterior(), and EXTERNAL_COLOR.

Referenced by color_exterior(), and Slic3r::dump_voronoi_to_svg().

Here is the call graph for this function:

Here is the caller graph for this function:

retrieve_point()

point_type Slic3r::Voronoi::Internal::retrieve_point ( const Points &  points, const std::vector< segment_type > &  segments, const cell_type &  cell  )

inline

    {
        assert(cell.source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_START_POINT || cell.source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_END_POINT ||
               cell.source_category() == boost::polygon::SOURCE_CATEGORY_SINGLE_POINT);
        return cell.source_category() == boost::polygon::SOURCE_CATEGORY_SINGLE_POINT ?
                    Voronoi::Internal::point_type(double(points[cell.source_index()].x()), double(points[cell.source_index()].y())) :
                    (cell.source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_START_POINT) ?
                        low(segments[cell.source_index()]) : high(segments[cell.source_index()]);
    }

Referenced by clip_infinite_edge(), and sample_curved_edge().

Here is the caller graph for this function:

sample_curved_edge()

void Slic3r::Voronoi::Internal::sample_curved_edge ( const Points &  points, const std::vector< segment_type > &  segments, const edge_type &  edge, std::vector< point_type > &  sampled_edge, coordinate_type  max_dist  )

inline

    {
        point_type point = edge.cell()->contains_point() ?
            retrieve_point(points, segments, *edge.cell()) :
            retrieve_point(points, segments, *edge.twin()->cell());
        segment_type segment = edge.cell()->contains_point() ?
            segments[edge.twin()->cell()->source_index()] :
            segments[edge.cell()->source_index()];
        ::boost::polygon::voronoi_visual_utils<coordinate_type>::discretize(point, segment, max_dist, &sampled_edge);
    }

References boost::polygon::voronoi_visual_utils< CT >::discretize(), retrieve_point(), and segment().

Referenced by Slic3r::dump_voronoi_to_svg().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

EXTERNAL_COLOR

const std::size_t Slic3r::Voronoi::Internal::EXTERNAL_COLOR = 1

static

Referenced by color_exterior(), and Slic3r::dump_voronoi_to_svg().