Slic3r::PaintedLineVisitor Struct Reference

Collaboration diagram for Slic3r::PaintedLineVisitor:

Public Member Functions
	PaintedLineVisitor (const EdgeGrid::Grid &grid, std::vector< PaintedLine > &painted_lines, std::mutex &painted_lines_mutex, size_t reserve)
void	reset ()
bool	operator() (coord_t iy, coord_t ix)

Public Attributes
const EdgeGrid::Grid &	grid
std::vector< PaintedLine > &	painted_lines
std::mutex &	painted_lines_mutex
Line	line_to_test
std::unordered_set< std::pair< size_t, size_t >, boost::hash< std::pair< size_t, size_t > > >	painted_lines_set
int	color = -1

Static Public Attributes
static const double	cos_threshold2 = Slic3r::sqr(cos(M_PI * 30. / 180.))
static const double	append_threshold = 50 * SCALED_EPSILON
static const double	append_threshold2 = Slic3r::sqr(append_threshold)

Detailed Description

Constructor & Destructor Documentation

PaintedLineVisitor()

Slic3r::PaintedLineVisitor::PaintedLineVisitor ( const EdgeGrid::Grid &  grid, std::vector< PaintedLine > &  painted_lines, std::mutex &  painted_lines_mutex, size_t  reserve  )

inline

                                                                                                                                       : grid(grid), painted_lines(painted_lines), painted_lines_mutex(painted_lines_mutex)
    {
        painted_lines_set.reserve(reserve);
    }

References painted_lines_set.

Member Function Documentation

operator()()

bool Slic3r::PaintedLineVisitor::operator() ( coord_t  iy, coord_t  ix  )

inline

    {
        // Called with a row and column of the grid cell, which is intersected by a line.
        auto         cell_data_range        = grid.cell_data_range(iy, ix);
        const Vec2d  v1                     = line_to_test.vector().cast<double>();
        const double v1_sqr_norm            = v1.squaredNorm();
        const double heuristic_thr_part     = line_to_test.length() + append_threshold;
        for (auto it_contour_and_segment = cell_data_range.first; it_contour_and_segment != cell_data_range.second; ++it_contour_and_segment) {
            Line        grid_line         = grid.line(*it_contour_and_segment);
            const Vec2d v2                = grid_line.vector().cast<double>();
            double      heuristic_thr_sqr = Slic3r::sqr(heuristic_thr_part + grid_line.length());
 
            // An inexpensive heuristic to test whether line_to_test and grid_line can be somewhere close enough to each other.
            // This helps filter out cases when the following expensive calculations are useless.
            if ((grid_line.a - line_to_test.a).cast<double>().squaredNorm() > heuristic_thr_sqr ||
                (grid_line.b - line_to_test.a).cast<double>().squaredNorm() > heuristic_thr_sqr ||
                (grid_line.a - line_to_test.b).cast<double>().squaredNorm() > heuristic_thr_sqr ||
                (grid_line.b - line_to_test.b).cast<double>().squaredNorm() > heuristic_thr_sqr)
                continue;
 
            // When lines have too different length, it is necessary to normalize them
            if (Slic3r::sqr(v1.dot(v2)) > cos_threshold2 * v1_sqr_norm * v2.squaredNorm()) {
                // The two vectors are nearly collinear (their mutual angle is lower than 30 degrees)
                if (painted_lines_set.find(*it_contour_and_segment) == painted_lines_set.end()) {
                    if (grid_line.distance_to_squared(line_to_test.a) < append_threshold2 ||
                        grid_line.distance_to_squared(line_to_test.b) < append_threshold2 ||
                        line_to_test.distance_to_squared(grid_line.a) < append_threshold2 ||
                        line_to_test.distance_to_squared(grid_line.b) < append_threshold2) {
                        Line line_to_test_projected;
                        project_line_on_line(grid_line, line_to_test, &line_to_test_projected);
 
                        if ((line_to_test_projected.a - grid_line.a).cast<double>().squaredNorm() > (line_to_test_projected.b - grid_line.a).cast<double>().squaredNorm())
                            line_to_test_projected.reverse();
 
                        painted_lines_set.insert(*it_contour_and_segment);
                        {
                            boost::lock_guard<std::mutex> lock(painted_lines_mutex);
                            painted_lines.push_back({it_contour_and_segment->first, it_contour_and_segment->second, line_to_test_projected, this->color});
                        }
                    }
                }
            }
        }
        // Continue traversing the grid along the edge.
        return true;
    }

References Slic3r::Line::a, append_threshold, append_threshold2, Slic3r::Line::b, Slic3r::EdgeGrid::Grid::cell_data_range(), color, cos_threshold2, Slic3r::Line::distance_to_squared(), grid, Slic3r::Line::length(), Slic3r::EdgeGrid::Grid::line(), line_to_test, painted_lines, painted_lines_mutex, painted_lines_set, Slic3r::project_line_on_line(), Slic3r::Line::reverse(), Slic3r::sqr(), and Slic3r::Line::vector().

Here is the call graph for this function:

reset()

void Slic3r::PaintedLineVisitor::reset ( )

inline

{ painted_lines_set.clear(); }

References painted_lines_set.

Member Data Documentation

append_threshold

const double Slic3r::PaintedLineVisitor::append_threshold = 50 * SCALED_EPSILON

inlinestatic

Referenced by operator()().

append_threshold2

const double Slic3r::PaintedLineVisitor::append_threshold2 = Slic3r::sqr(append_threshold)

inlinestatic

Referenced by operator()().

color

int Slic3r::PaintedLineVisitor::color = -1

Referenced by operator()().

cos_threshold2

const double Slic3r::PaintedLineVisitor::cos_threshold2 = Slic3r::sqr(cos(M_PI * 30. / 180.))

inlinestatic

Referenced by operator()().

grid

const EdgeGrid::Grid& Slic3r::PaintedLineVisitor::grid

Referenced by operator()().

line_to_test

Line Slic3r::PaintedLineVisitor::line_to_test

Referenced by operator()().

painted_lines

std::vector<PaintedLine>& Slic3r::PaintedLineVisitor::painted_lines

Referenced by operator()().

painted_lines_mutex

std::mutex& Slic3r::PaintedLineVisitor::painted_lines_mutex

Referenced by operator()().

painted_lines_set

std::unordered_set<std::pair<size_t, size_t>, boost::hash<std::pair<size_t, size_t> > > Slic3r::PaintedLineVisitor::painted_lines_set

Referenced by PaintedLineVisitor(), operator()(), and reset().

---

The documentation for this struct was generated from the following file:

• src/libslic3r/MultiMaterialSegmentation.cpp