Slic3r::anonymous_namespace{AdaptiveInfillField.cpp} Namespace Reference

Classes
struct	DensityLevels
class	RadialScale

Functions
void	distance_transform_line (const float *f, float *d, int n, int *v, double *s)
void	distance_transform_axis (std::vector< float > &grid, const Vec3i32 &size, int axis, const std::function< void()> &throw_if_canceled)
void	rasterize (const ExPolygons &expolygons, const Vec2d &origin, double cell, int nx, int ny, float *nodes)
double	target_scale (double ratio, AdaptiveInfillGradient gradient, double depth)

Variables
constexpr double	MaxNodes = double(1 << 20)
constexpr double	MinCellSize = 0.5
constexpr double	NeckRatio = 0.8
constexpr double	MinLobeRatio = 0.3
constexpr double	LobeReach = 2.
constexpr double	LobeMorph = 0.1
constexpr double	ShellRatio = 1.5
constexpr double	BlendRatio = 2.5
constexpr int	Samples = 32
constexpr float	InfF = std::numeric_limits<float>::infinity()
constexpr double	InfD = std::numeric_limits<double>::infinity()

Function Documentation

distance_transform_axis()

void Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::distance_transform_axis	(	std::vector< float > &	grid,
		const Vec3i32 &	size,
		int	axis,
		const std::function< void()> &	throw_if_canceled )

{
    const int    n      = size[axis];
    const int    a1     = (axis + 1) % 3;
    const int    a2     = (axis + 2) % 3;
    const size_t stride = axis == 0 ? 1 : axis == 1 ? size_t(size.x()) : size_t(size.x()) * size.y();
    tbb::parallel_for(tbb::blocked_range<size_t>(0, size_t(size[a1]) * size[a2]), [&](const tbb::blocked_range<size_t> &range) {
        std::vector<float>  f(n), d(n);
        std::vector<int>    v(n);
        std::vector<double> s(n + 1);
        for (size_t line = range.begin(); line < range.end(); ++line) {
            Vec3i32 idx;
            idx[axis]          = 0;
            idx[a1]            = int(line % size[a1]);
            idx[a2]            = int(line / size[a1]);
            const size_t first = (size_t(idx.z()) * size.y() + idx.y()) * size.x() + idx.x();
            for (int i = 0; i < n; ++i)
                f[i] = grid[first + i * stride];
            distance_transform_line(f.data(), d.data(), n, v.data(), s.data());
            for (int i = 0; i < n; ++i)
                grid[first + i * stride] = d[i];
        }
        throw_if_canceled();
    });
}

References distance_transform_axis(), distance_transform_line(), Slic3r::f(), Slic3r::grid(), and Slic3r::range().

Referenced by distance_transform_axis().

Here is the call graph for this function:

Here is the caller graph for this function:

distance_transform_line()

void Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::distance_transform_line	(	const float *	f,
		float *	d,
		int	n,
		int *	v,
		double *	s )

{
    int k = -1;
    for (int q = 0; q < n; ++q) {
        if (f[q] == InfF)
            continue;
        double x = -InfD;
        while (k >= 0) {
            x = (f[q] + double(q) * q - f[v[k]] - double(v[k]) * v[k]) / (2. * (q - v[k]));
            if (x > s[k])
                break;
            --k;
        }
        if (k < 0)
            x = -InfD;
        v[++k]   = q;
        s[k]     = x;
        s[k + 1] = InfD;
    }
    if (k < 0) {
        std::fill(d, d + n, InfF);
        return;
    }
    for (int q = 0, j = 0; q < n; ++q) {
        while (s[j + 1] < q)
            ++j;
        d[q] = float(sqr(double(q - v[j])) + f[v[j]]);
    }
}

References distance_transform_line(), Slic3r::f(), InfD, InfF, and Slic3r::sqr().

Referenced by distance_transform_axis(), and distance_transform_line().

Here is the call graph for this function:

Here is the caller graph for this function:

rasterize()

void Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::rasterize	(	const ExPolygons &	expolygons,
		const Vec2d &	origin,
		double	cell,
		int	nx,
		int	ny,
		float *	nodes )

{
    std::vector<std::vector<double>> crossings(ny);
    auto add_crossings = [&](const Polygon &polygon) {
        const Points &pts = polygon.points;
        for (size_t i = 0; i < pts.size(); ++i) {
            const Vec2d a = unscaled(pts[i]);
            const Vec2d b = unscaled(pts[i + 1 == pts.size() ? 0 : i + 1]);
            if (a.y() == b.y())
                continue;
            const auto [lo, hi] = std::minmax(a.y(), b.y());
            const int j0        = std::max(0, int(std::ceil((lo - origin.y()) / cell)));
            const int j1        = std::min(ny, int(std::ceil((hi - origin.y()) / cell)));
            for (int j = j0; j < j1; ++j) {
                const double y = origin.y() + j * cell;
                crossings[j].push_back(a.x() + (b.x() - a.x()) * (y - a.y()) / (b.y() - a.y()));
            }
        }
    };
    for (const ExPolygon &expolygon : expolygons) {
        add_crossings(expolygon.contour);
        for (const Polygon &hole : expolygon.holes)
            add_crossings(hole);
    }
    for (int j = 0; j < ny; ++j) {
        std::vector<double> &xs = crossings[j];
        std::sort(xs.begin(), xs.end());
        for (size_t k = 0; k + 1 < xs.size(); k += 2) {
            const int i0 = std::max(0, int(std::ceil((xs[k] - origin.x()) / cell)));
            const int i1 = std::min(nx, int(std::ceil((xs[k + 1] - origin.x()) / cell)));
            std::fill(nodes + size_t(j) * nx + std::min(i0, i1), nodes + size_t(j) * nx + i1, InfF);
        }
    }
}

References InfF, rasterize(), and Slic3r::unscaled().

Referenced by rasterize().

Here is the call graph for this function:

Here is the caller graph for this function:

target_scale()

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::target_scale	(	double	ratio,
		AdaptiveInfillGradient	gradient,
		double	depth )

{
    switch (gradient) {
    case AdaptiveInfillGradient::Quadratic: return 1. + (ratio - 1.) * depth * depth;
    case AdaptiveInfillGradient::Exponential: return std::pow(ratio, depth);
    default: return 1. + (ratio - 1.) * depth;
    }
}

References Slic3r::Exponential, Slic3r::Quadratic, and target_scale().

Referenced by Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::RadialScale::RadialScale(), Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::DensityLevels::level(), and target_scale().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

BlendRatio

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::BlendRatio = 2.5

constexpr

InfD

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::InfD = std::numeric_limits<double>::infinity()

constexpr

Referenced by distance_transform_line().

InfF

float Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::InfF = std::numeric_limits<float>::infinity()

constexpr

Referenced by distance_transform_line(), and rasterize().

LobeMorph

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::LobeMorph = 0.1

constexpr

LobeReach

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::LobeReach = 2.

constexpr

MaxNodes

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::MaxNodes = double(1 << 20)

constexpr

MinCellSize

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::MinCellSize = 0.5

constexpr

MinLobeRatio

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::MinLobeRatio = 0.3

constexpr

NeckRatio

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::NeckRatio = 0.8

constexpr

Samples

int Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::Samples = 32

constexpr

ShellRatio

double Slic3r::anonymous_namespace{AdaptiveInfillField.cpp}::ShellRatio = 1.5

constexpr