Slic3r::Voronoi::debug Namespace Reference

Functions
bool	verify_twin_halfedges_successive (const VD &vd, const Lines &lines)
bool	verify_inside_outside_annotations (const VD &vd)
bool	verify_vertices_on_contour (const VD &vd, const Lines &lines)
bool	verify_signed_distances (const VD &vd, const Lines &lines, const std::vector< double > &signed_distances)
bool	verify_offset_intersection_points (const VD &vd, const Lines &lines, const double offset_distance, const std::vector< Vec2d > &offset_intersection_points)

Function Documentation

verify_inside_outside_annotations()

bool Slic3r::Voronoi::debug::verify_inside_outside_annotations

(

const VD &

vd

)

    {
        // Verify that "Colors" are set at all Voronoi entities.
        for (const VD::vertex_type &v : vd.vertices()) {
            assert(! v.is_degenerate());
            assert(vertex_category(v) != VertexCategory::Unknown);
        }
        for (const VD::edge_type &e : vd.edges())
            assert(edge_category(e) != EdgeCategory::Unknown);
        for (const VD::cell_type &c : vd.cells()) {
            // Unfortunately denegerate cells could be created, which reference a null edge.
            // https://github.com/boostorg/polygon/issues/47
            assert(c.is_degenerate() || cell_category(c) != CellCategory::Unknown);
        }
 
        // Verify consistency between markings of Voronoi cells, edges and verticies.
        for (const VD::cell_type &cell : vd.cells()) {
            if (cell.is_degenerate()) {
                // Unfortunately denegerate cells could be created, which reference a null edge.
                // https://github.com/boostorg/polygon/issues/47
                continue;
            }
            const VD::edge_type *first_edge = cell.incident_edge();
            const VD::edge_type *edge       = first_edge;
            CellCategory         cc         = cell_category(cell);
            size_t               num_vertices_on_contour    = 0;
            size_t               num_vertices_inside        = 0;
            size_t               num_vertices_outside       = 0;
            size_t               num_edges_point_to_contour = 0;
            size_t               num_edges_point_inside     = 0;
            size_t               num_edges_point_outside    = 0;
            do {
                {
                    EdgeCategory ec = edge_category(edge);
                    switch (ec) {
                    case EdgeCategory::PointsInside:
                        assert(edge->vertex0() != nullptr && edge->vertex1() != nullptr);
                        ++ num_edges_point_inside; break;
                    case EdgeCategory::PointsOutside:
//                        assert(edge->vertex0() != nullptr);
                        ++ num_edges_point_outside; break;
                    case EdgeCategory::PointsToContour:
                        assert(edge->vertex1() != nullptr);
                        ++ num_edges_point_to_contour; break;
                    default:
                        assert(false);
                    }
                }
                {
                    VertexCategory vc = (edge->vertex1() == nullptr) ? VertexCategory::Outside : vertex_category(edge->vertex1());
                    switch (vc) {
                    case VertexCategory::Inside:
                        ++ num_vertices_inside; break;
                    case VertexCategory::Outside:
                        ++ num_vertices_outside; break;
                    case VertexCategory::OnContour:
                        ++ num_vertices_on_contour; break;
                    default:
                        assert(false);
                    }
                }
                {
                    const VD::cell_type *cell_other = edge->twin()->cell();
                    const CellCategory   cc_other   = cell_category(cell_other);
                    assert(cc_other != CellCategory::Unknown);
                    switch (cc) {
                    case CellCategory::Boundary:
                        assert(cc_other != CellCategory::Boundary || cell_other->contains_segment());
                        break;
                    case CellCategory::Inside:
                        assert(cc_other == CellCategory::Inside || cc_other ==CellCategory::Boundary);
                        break;
                    case CellCategory::Outside:
                        assert(cc_other == CellCategory::Outside || cc_other == CellCategory::Boundary);
                        break;
                    default:
                        assert(false);
                        break;
                    }
                }
                edge = edge->next();
            } while (edge != first_edge);
 
            switch (cc) {
            case CellCategory::Boundary:
                assert(cell.contains_segment());
                assert(num_edges_point_to_contour == 2);
                assert(num_vertices_on_contour == 2);
                assert(num_vertices_inside > 0);
                assert(num_vertices_outside > 0);
                assert(num_edges_point_inside > 0);
                assert(num_edges_point_outside > 0);
                break;
            case CellCategory::Inside:
                assert(num_vertices_on_contour <= 1);
                assert(num_edges_point_to_contour <= 1);
                assert(num_vertices_inside > 0);
                assert(num_vertices_outside == 0);
                assert(num_edges_point_inside > 0);
                assert(num_edges_point_outside == 0);
                break;
            case CellCategory::Outside:
                assert(num_vertices_on_contour <= 1);
                assert(num_edges_point_to_contour <= 1);
                assert(num_vertices_inside == 0);
                assert(num_vertices_outside > 0);
                assert(num_edges_point_inside == 0);
                assert(num_edges_point_outside > 0);
                break;
            default:
                assert(false);
                break;
            }
        }
 
        return true;
    }

References Slic3r::Voronoi::Boundary, Slic3r::Voronoi::cell_category(), Slic3r::Voronoi::edge_category(), Slic3r::Voronoi::Inside, Slic3r::Voronoi::OnContour, Slic3r::Voronoi::Outside, Slic3r::Voronoi::PointsInside, Slic3r::Voronoi::PointsOutside, Slic3r::Voronoi::PointsToContour, Slic3r::Voronoi::Unknown, and Slic3r::Voronoi::vertex_category().

Referenced by Slic3r::Voronoi::annotate_inside_outside(), Slic3r::Voronoi::edge_offset_contour_intersections(), Slic3r::Voronoi::signed_vertex_distances(), and Slic3r::Voronoi::skeleton_edges_rough().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_offset_intersection_points()

bool Slic3r::Voronoi::debug::verify_offset_intersection_points	(	const VD &	vd,
		const Lines &	lines,
		const double	offset_distance,
		const std::vector< Vec2d > &	offset_intersection_points
	)

    {
        const VD::edge_type *front_edge = &vd.edges().front();
        const double d = std::abs(offset_distance);
        for (const VD::edge_type &edge : vd.edges()) {
            const Vec2d &p = offset_intersection_points[&edge - front_edge];
            if (edge_offset_has_intersection(p)) {
                double err  = std::abs(detail::dist_to_site(lines, *edge.cell(), p) - d);
                double err2 = std::abs(detail::dist_to_site(lines, *edge.twin()->cell(), p) - d);
                assert(err < SCALED_EPSILON);
                assert(err2 < SCALED_EPSILON);
            }
        }
        return true;
    }

References Slic3r::Voronoi::detail::dist_to_site(), Slic3r::Voronoi::edge_offset_has_intersection(), and SCALED_EPSILON.

Referenced by Slic3r::Voronoi::edge_offset_contour_intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_signed_distances()

bool Slic3r::Voronoi::debug::verify_signed_distances	(	const VD &	vd,
		const Lines &	lines,
		const std::vector< double > &	signed_distances
	)

    {
        for (const VD::edge_type &edge : vd.edges()) {
            const VD::vertex_type *v = edge.vertex0();
            double d = (v == nullptr) ? std::numeric_limits<double>::max() : signed_distances[v - &vd.vertices().front()];
            if (v == nullptr || vertex_category(v) == VertexCategory::Outside)
                assert(d > 0.);
            else if (vertex_category(v) == VertexCategory::OnContour)
                assert(d == 0.);
            else
                assert(d < 0.);
            if (v != nullptr) {
                double err  = std::abs(detail::dist_to_site(lines, *edge.cell(), vertex_point(v)) - std::abs(d));
                double err2 = std::abs(detail::dist_to_site(lines, *edge.twin()->cell(), vertex_point(v)) - std::abs(d));
                assert(err < SCALED_EPSILON);
                assert(err2 < SCALED_EPSILON);
            }
        }
        return true;
    }

References Slic3r::Voronoi::detail::dist_to_site(), Slic3r::Voronoi::OnContour, Slic3r::Voronoi::Outside, SCALED_EPSILON, Slic3r::Voronoi::vertex_category(), and Slic3r::Voronoi::vertex_point().

Referenced by Slic3r::Voronoi::signed_vertex_distances().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_twin_halfedges_successive()

bool Slic3r::Voronoi::debug::verify_twin_halfedges_successive	(	const VD &	vd,
		const Lines &	lines
	)

    {
        for (size_t i = 0; i < vd.num_edges(); i += 2) {
            const VD::edge_type &e  = vd.edges()[i];
            const VD::edge_type &e2 = vd.edges()[i + 1];
            assert(e.twin() == &e2);
            assert(e2.twin() == &e);
            assert(e.is_secondary() == e2.is_secondary());
            if (e.is_secondary()) {
                assert(e.cell()->contains_point() != e2.cell()->contains_point());
                const VD::edge_type &ex = (e.cell()->contains_point() ? e : e2);
                // Verify that the Point defining the cell left of ex is an end point of a segment
                // defining the cell right of ex.
                const Line  &line0 = lines[ex.cell()->source_index()];
                const Line  &line1 = lines[ex.twin()->cell()->source_index()];
                const Point &pt    = (ex.cell()->source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_START_POINT) ? line0.a : line0.b;
                assert(pt == line1.a || pt == line1.b);
            }
        }
        return true;
    }

References Slic3r::Line::a, and Slic3r::Line::b.

Referenced by Slic3r::Voronoi::annotate_inside_outside().

Here is the caller graph for this function:

verify_vertices_on_contour()

bool Slic3r::Voronoi::debug::verify_vertices_on_contour	(	const VD &	vd,
		const Lines &	lines
	)

    {
        for (const VD::edge_type &edge : vd.edges()) {
            const VD::vertex_type *v = edge.vertex0();
            if (v != nullptr) {
                bool on_contour = vertex_category(v) == VertexCategory::OnContour;
                assert(detail::on_site(lines, *edge.cell(), vertex_point(v)) == on_contour);
                assert(detail::on_site(lines, *edge.twin()->cell(), vertex_point(v)) == on_contour);
            }
        }
        return true;
    }

References Slic3r::Voronoi::detail::on_site(), Slic3r::Voronoi::OnContour, Slic3r::Voronoi::vertex_category(), and Slic3r::Voronoi::vertex_point().

Referenced by Slic3r::Voronoi::annotate_inside_outside().

Here is the call graph for this function:

Here is the caller graph for this function: