Slic3r::VoxelUtils Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Feature/Interlocking/VoxelUtils.hpp>

Public Types
using	grid_coord_t = coord_t

Public Member Functions
	VoxelUtils (Vec3crd cell_size)
bool	walkLine (Vec3crd start, Vec3crd end, const std::function< bool(GridPoint3)> &process_cell_func) const
bool	walkPolygons (const ExPolygon &polys, coord_t z, const std::function< bool(GridPoint3)> &process_cell_func) const
bool	walkDilatedPolygons (const ExPolygon &polys, coord_t z, const DilationKernel &kernel, const std::function< bool(GridPoint3)> &process_cell_func) const
bool	walkDilatedPolygons (const ExPolygons &polys, coord_t z, const DilationKernel &kernel, const std::function< bool(GridPoint3)> &process_cell_func) const
bool	walkAreas (const ExPolygon &polys, coord_t z, const std::function< bool(GridPoint3)> &process_cell_func) const
bool	walkDilatedAreas (const ExPolygon &polys, coord_t z, const DilationKernel &kernel, const std::function< bool(GridPoint3)> &process_cell_func) const
bool	walkDilatedAreas (const ExPolygons &polys, coord_t z, const DilationKernel &kernel, const std::function< bool(GridPoint3)> &process_cell_func) const
std::function< bool(GridPoint3)>	dilate (const DilationKernel &kernel, const std::function< bool(GridPoint3)> &process_cell_func) const
GridPoint3	toGridPoint (const Vec3crd &point) const
grid_coord_t	toGridCoord (const coord_t &coord, const size_t dim) const
Vec3crd	toLowerCorner (const GridPoint3 &location) const
coord_t	toLowerCoord (const grid_coord_t &grid_coord, const size_t dim) const
Polygon	toPolygon (const GridPoint3 p) const

Public Attributes
Vec3crd	cell_size_

Private Member Functions
bool	_walkAreas (const ExPolygon &polys, coord_t z, const std::function< bool(GridPoint3)> &process_cell_func) const

Detailed Description

Utility class for walking over a 3D voxel grid.

Contains the math for intersecting voxels with lines, polgons, areas, etc.

Member Typedef Documentation

grid_coord_t

using Slic3r::VoxelUtils::grid_coord_t = coord_t

Constructor & Destructor Documentation

VoxelUtils()

Slic3r::VoxelUtils::VoxelUtils ( Vec3crd cell_size )

inline

        : cell_size_(cell_size)
    {
    }

References cell_size_.

Member Function Documentation

_walkAreas()

bool Slic3r::VoxelUtils::_walkAreas ( const ExPolygon & polys, coord_t z, const std::function< bool(GridPoint3)> & process_cell_func ) const

private

Warning

the polys is assumed to be translated by half the cell_size in xy already

{
    Points skin_points = spreadDotsArea(polys, Point(cell_size_.x(), cell_size_.y()));
    for (Point p : skin_points)
    {
        bool continue_ = process_cell_func(toGridPoint(Vec3crd(p.x() + cell_size_.x() / 2, p.y() + cell_size_.y() / 2, z)));
        if (! continue_)
        {
            return false;
        }
    }
    return true;
}

References _walkAreas(), cell_size_, Slic3r::spreadDotsArea(), and toGridPoint().

Referenced by _walkAreas(), walkAreas(), and walkDilatedAreas().

Here is the call graph for this function:

Here is the caller graph for this function:

dilate()

std::function< bool(GridPoint3)> Slic3r::VoxelUtils::dilate	(	const DilationKernel &	kernel,
		const std::function< bool(GridPoint3)> &	process_cell_func ) const

Dilate with a kernel.

Extends the process_cell_func, so that for each cell we process nearby cells as well.

Apply this function to a process_cell_func to create a new process_cell_func which applies the effect to nearby voxels as well.

Parameters

kernel	The offset positions relative to the input of process_cell_func
process_cell_func	Function to perform on each voxel cell

{
    return [&process_cell_func, &kernel](GridPoint3 loc)
    {
        for (const GridPoint3& rel : kernel.relative_cells_)
        {
            bool continue_ = process_cell_func(loc + rel);
            if (! continue_)
                return false;
        }
        return true;
    };
}

References dilate(), and Slic3r::DilationKernel::relative_cells_.

Referenced by dilate(), walkDilatedAreas(), and walkDilatedPolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

toGridCoord()

grid_coord_t Slic3r::VoxelUtils::toGridCoord ( const coord_t & coord, const size_t dim ) const

inline

    {
        assert(dim < 3);
        return coord / cell_size_[dim] - (coord < 0);
    }

References cell_size_.

Referenced by toGridPoint().

Here is the caller graph for this function:

toGridPoint()

GridPoint3 Slic3r::VoxelUtils::toGridPoint ( const Vec3crd & point ) const

inline

    {
        return GridPoint3(toGridCoord(point.x(), 0), toGridCoord(point.y(), 1), toGridCoord(point.z(), 2));
    }

References toGridCoord().

Referenced by _walkAreas(), and walkLine().

Here is the call graph for this function:

Here is the caller graph for this function:

toLowerCoord()

coord_t Slic3r::VoxelUtils::toLowerCoord ( const grid_coord_t & grid_coord, const size_t dim ) const

inline

    {
        assert(dim < 3);
        return grid_coord * cell_size_[dim];
    }

References cell_size_.

Referenced by toLowerCorner(), and walkLine().

Here is the caller graph for this function:

toLowerCorner()

Vec3crd Slic3r::VoxelUtils::toLowerCorner ( const GridPoint3 & location ) const

inline

    {
        return Vec3crd(toLowerCoord(location.x(), 0), toLowerCoord(location.y(), 1), toLowerCoord(location.z(), 2));
    }

References toLowerCoord().

Referenced by toPolygon().

Here is the call graph for this function:

Here is the caller graph for this function:

toPolygon()

Polygon Slic3r::VoxelUtils::toPolygon ( const GridPoint3 p ) const

inline

Returns a rectangular polygon equal to the cross section of a voxel cell at coordinate p

    {
        Polygon ret;
        Vec3crd c = toLowerCorner(p);
        ret.append({c.x(), c.y()});
        ret.append({c.x() + cell_size_.x(), c.y()});
        ret.append({c.x() + cell_size_.x(), c.y() + cell_size_.y()});
        ret.append({c.x(), c.y() + cell_size_.y()});
        return ret;
    }

References Slic3r::MultiPoint::append(), cell_size_, and toLowerCorner().

Here is the call graph for this function:

walkAreas()

bool Slic3r::VoxelUtils::walkAreas	(	const ExPolygon &	polys,
		coord_t	z,
		const std::function< bool(GridPoint3)> &	process_cell_func ) const

Process all voxels inside the area of a polygons object.

Warning

The voxels along the area are not processed. Thin areas might not process any voxels at all.

Parameters

polys	The area to fill
z	The height at which the polygons occur
process_cell_func	Function to perform on each voxel cell

Returns

Whether executing was stopped short as indicated by the cell_processing_function

{
    ExPolygon translated = polys;
    const Vec3crd translation = -cell_size_ / 2; // offset half a cell so that the dots of spreadDotsArea are centered on the middle of the cell isntead of the lower corners.
    if (translation.x() && translation.y())
    {
        translated.translate(Point(translation.x(), translation.y()));
    }
    return _walkAreas(translated, z, process_cell_func);
}

References _walkAreas(), cell_size_, Slic3r::ExPolygon::translate(), and walkAreas().

Referenced by walkAreas().

Here is the call graph for this function:

Here is the caller graph for this function:

walkDilatedAreas() [1/2]

bool Slic3r::VoxelUtils::walkDilatedAreas	(	const ExPolygon &	polys,
		coord_t	z,
		const DilationKernel &	kernel,
		const std::function< bool(GridPoint3)> &	process_cell_func ) const

Process all voxels inside the area of a polygons object. For each voxel inside the polygon we process each of the offset voxels according to the kernel.

Warning

The voxels along the area are not processed. Thin areas might not process any voxels at all.

Parameters

polys	The area to fill
z	The height at which the polygons occur
process_cell_func	Function to perform on each voxel cell

Returns

Whether executing was stopped short as indicated by the cell_processing_function

{
    ExPolygon translated = polys;
    GridPoint3 k = kernel.kernel_size_;
    k.x() %= 2;
    k.y() %= 2;
    k.z() %= 2;
    const Vec3crd translation = (Vec3crd(1, 1, 1) - k).array() * cell_size_.array() / 2 // offset half a cell when using an even kernel
                               - cell_size_.array() / 2; // offset half a cell so that the dots of spreadDotsArea are centered on the middle of the cell isntead of the lower corners.
    if (translation.x() && translation.y())
    {
        translated.translate(Point(translation.x(), translation.y()));
    }
    return _walkAreas(translated, z + translation.z(), dilate(kernel, process_cell_func));
}

References _walkAreas(), cell_size_, dilate(), Slic3r::DilationKernel::kernel_size_, Slic3r::ExPolygon::translate(), and walkDilatedAreas().

Referenced by walkDilatedAreas(), and walkDilatedAreas().

Here is the call graph for this function:

Here is the caller graph for this function:

walkDilatedAreas() [2/2]

bool Slic3r::VoxelUtils::walkDilatedAreas ( const ExPolygons & polys, coord_t z, const DilationKernel & kernel, const std::function< bool(GridPoint3)> & process_cell_func ) const

inline

    {
        for (const auto & poly : polys) {
            if (!walkDilatedAreas(poly, z, kernel, process_cell_func)) {
                return false;
            }
        }
 
        return true;
    }

References walkDilatedAreas().

Here is the call graph for this function:

walkDilatedPolygons() [1/2]

bool Slic3r::VoxelUtils::walkDilatedPolygons	(	const ExPolygon &	polys,
		coord_t	z,
		const DilationKernel &	kernel,
		const std::function< bool(GridPoint3)> &	process_cell_func ) const

Process voxels near the line segments of a polygon. For each voxel the polygon crosses we process each of the offset voxels according to the kernel.

Warning

Voxels may be processed multiple times!

Parameters

polys	The polygons to walk
z	The height at which the polygons occur
process_cell_func	Function to perform on each voxel cell

Returns

Whether executing was stopped short as indicated by the cell_processing_function

{
    ExPolygon translated = polys;
    GridPoint3 k = kernel.kernel_size_;
    k.x() %= 2;
    k.y() %= 2;
    k.z() %= 2;
    const Vec3crd translation = (Vec3crd(1, 1, 1) - k).array() * cell_size_.array() / 2;
    if (translation.x() && translation.y())
    {
        translated.translate(Point(translation.x(), translation.y()));
    }
    return walkPolygons(translated, z + translation.z(), dilate(kernel, process_cell_func));
}

References cell_size_, dilate(), Slic3r::DilationKernel::kernel_size_, Slic3r::ExPolygon::translate(), walkDilatedPolygons(), and walkPolygons().

Referenced by walkDilatedPolygons(), and walkDilatedPolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

walkDilatedPolygons() [2/2]

bool Slic3r::VoxelUtils::walkDilatedPolygons ( const ExPolygons & polys, coord_t z, const DilationKernel & kernel, const std::function< bool(GridPoint3)> & process_cell_func ) const

inline

    {
        for (const auto & poly : polys) {
            if (!walkDilatedPolygons(poly, z, kernel, process_cell_func)) {
                return false;
            }
        }
 
        return true;
    }

References walkDilatedPolygons().

Here is the call graph for this function:

walkLine()

bool Slic3r::VoxelUtils::walkLine	(	Vec3crd	start,
		Vec3crd	end,
		const std::function< bool(GridPoint3)> &	process_cell_func ) const

Process voxels which a line segment crosses.

Parameters

start	Start point of the line
end	End point of the line
process_cell_func	Function to perform on each cell the line crosses

Returns

Whether executing was stopped short as indicated by the cell_processing_function

{
    Vec3crd diff = end - start;
 
    const GridPoint3 start_cell = toGridPoint(start);
    const GridPoint3 end_cell = toGridPoint(end);
    if (start_cell == end_cell)
    {
        return process_cell_func(start_cell);
    }
 
    Vec3crd current_cell = start_cell;
    while (true)
    {
        bool continue_ = process_cell_func(current_cell);
 
        if (! continue_)
        {
            return false;
        }
 
        int stepping_dim = -1; // dimension in which the line next exits the current cell
        double percentage_along_line = std::numeric_limits<double>::max();
        for (int dim = 0; dim < 3; dim++)
        {
            if (diff[dim] == 0)
            {
                continue;
            }
            coord_t crossing_boundary = toLowerCoord(current_cell[dim], dim) + (diff[dim] > 0) * cell_size_[dim];
            double percentage_along_line_here = (crossing_boundary - start[dim]) / static_cast<double>(diff[dim]);
            if (percentage_along_line_here < percentage_along_line)
            {
                percentage_along_line = percentage_along_line_here;
                stepping_dim = dim;
            }
        }
        assert(stepping_dim != -1);
        if (percentage_along_line > 1.0)
        {
            // next cell is beyond the end
            return true;
        }
        current_cell[stepping_dim] += (diff[stepping_dim] > 0) ? 1 : -1;
    }
    return true;
}

References cell_size_, Slic3r::diff(), toGridPoint(), toLowerCoord(), and walkLine().

Referenced by walkLine(), and walkPolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

walkPolygons()

bool Slic3r::VoxelUtils::walkPolygons	(	const ExPolygon &	polys,
		coord_t	z,
		const std::function< bool(GridPoint3)> &	process_cell_func ) const

Process voxels which the line segments of a polygon crosses.

Warning

Voxels may be processed multiple times!

Parameters

polys	The polygons to walk
z	The height at which the polygons occur
process_cell_func	Function to perform on each voxel cell

Returns

Whether executing was stopped short as indicated by the cell_processing_function

{
    for (const Polygon& poly : to_polygons(polys))
    {
        Point last = poly.back();
        for (Point p : poly)
        {
            bool continue_ = walkLine(Vec3crd(last.x(), last.y(), z), Vec3crd(p.x(), p.y(), z), process_cell_func);
            if (! continue_)
            {
                return false;
            }
            last = p;
        }
    }
    return true;
}

References Slic3r::to_polygons(), walkLine(), and walkPolygons().

Referenced by walkDilatedPolygons(), and walkPolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cell_size_

Vec3crd Slic3r::VoxelUtils::cell_size_

Referenced by VoxelUtils(), _walkAreas(), toGridCoord(), toLowerCoord(), toPolygon(), walkAreas(), walkDilatedAreas(), walkDilatedPolygons(), and walkLine().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Feature/Interlocking/VoxelUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Feature/Interlocking/VoxelUtils.cpp