Slic3r::RasterizationImpl Namespace Reference

Typedefs
using	IndexPair = std::pair<int64_t, int64_t>
using	Grids = std::vector<IndexPair>

Functions
IndexPair	point_map_grid_index (const Point &pt, int64_t xdist, int64_t ydist)
bool	nearly_equal (const Point &p1, const Point &p2)
Grids	line_rasterization (const Line &line, int64_t xdist=scale_(1), int64_t ydist=scale_(1))

Typedef Documentation

Grids

using Slic3r::RasterizationImpl::Grids = std::vector<IndexPair>

IndexPair

using Slic3r::RasterizationImpl::IndexPair = std::pair<int64_t, int64_t>

Function Documentation

line_rasterization()

Grids Slic3r::RasterizationImpl::line_rasterization ( const Line & line, int64_t xdist = scale_(1), int64_t ydist = scale_(1) )

inline

{
    Grids     res;
    Point     rayStart     = line.a;
    Point     rayEnd       = line.b;
    IndexPair currentVoxel = point_map_grid_index(rayStart, xdist, ydist);
    IndexPair firstVoxel   = currentVoxel;
    IndexPair lastVoxel    = point_map_grid_index(rayEnd, xdist, ydist);
 
    Point ray = rayEnd - rayStart;
 
    double stepX = ray.x() >= 0 ? 1 : -1;
    double stepY = ray.y() >= 0 ? 1 : -1;
 
    double nextVoxelBoundaryX = (currentVoxel.first + stepX) * xdist;
    double nextVoxelBoundaryY = (currentVoxel.second + stepY) * ydist;
 
    if (stepX < 0) { nextVoxelBoundaryX += xdist; }
    if (stepY < 0) { nextVoxelBoundaryY += ydist; }
 
    double tMaxX = ray.x() != 0 ? (nextVoxelBoundaryX - rayStart.x()) / ray.x() : DBL_MAX;
    double tMaxY = ray.y() != 0 ? (nextVoxelBoundaryY - rayStart.y()) / ray.y() : DBL_MAX;
 
    double tDeltaX = ray.x() != 0 ? static_cast<double>(xdist) / ray.x() * stepX : DBL_MAX;
    double tDeltaY = ray.y() != 0 ? static_cast<double>(ydist) / ray.y() * stepY : DBL_MAX;
 
    res.push_back(currentVoxel);
 
    double tx = tMaxX;
    double ty = tMaxY;
 
    while (lastVoxel != currentVoxel) {
        if (lastVoxel.first == currentVoxel.first) {
            for (int64_t i = currentVoxel.second; i != lastVoxel.second; i += (int64_t) stepY) {
                currentVoxel.second += (int64_t) stepY;
                res.push_back(currentVoxel);
            }
            break;
        }
        if (lastVoxel.second == currentVoxel.second) {
            for (int64_t i = currentVoxel.first; i != lastVoxel.first; i += (int64_t) stepX) {
                currentVoxel.first += (int64_t) stepX;
                res.push_back(currentVoxel);
            }
            break;
        }
 
        if (tx < ty) {
            currentVoxel.first += (int64_t) stepX;
            tx += tDeltaX;
        } else {
            currentVoxel.second += (int64_t) stepY;
            ty += tDeltaY;
        }
        res.push_back(currentVoxel);
        if (res.size() >= 100000) { // bug
            assert(0);
        }
    }
 
    return res;
}

References Slic3r::Line::a, Slic3r::Line::b, and point_map_grid_index().

Here is the call graph for this function:

nearly_equal()

bool Slic3r::RasterizationImpl::nearly_equal ( const Point & p1, const Point & p2 )

inline

{ return std::abs(p1.x() - p2.x()) < SCALED_EPSILON && std::abs(p1.y() - p2.y()) < SCALED_EPSILON; }

References SCALED_EPSILON.

point_map_grid_index()

IndexPair Slic3r::RasterizationImpl::point_map_grid_index ( const Point & pt, int64_t xdist, int64_t ydist )

inline

{
    auto x = pt.x() / xdist;
    auto y = pt.y() / ydist;
    return std::make_pair(x, y);
}

Referenced by line_rasterization().

Here is the caller graph for this function: