Slic3r::AdaptiveInfillField Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Fill/AdaptiveInfillField.hpp>

Collaboration diagram for Slic3r::AdaptiveInfillField:

Classes
struct	Slice
struct	Radial
struct	Lobe
struct	Body

Public Types
using	Radials = std::array<Radial, 2 * MaxMorph>

Public Member Functions
	AdaptiveInfillField (const std::vector< Slice > &slices, const BoundingBox &bbox, AdaptiveInfillMode mode, const std::function< void()> &throw_if_canceled)
bool	empty () const
size_t	radial (const Vec3d &pt, Radials &out) const
int	axis () const
AdaptiveInfillMode	mode () const
double	depth (const Vec3d &pt) const

Static Public Attributes
static constexpr size_t	MaxMorph = 4

Private Member Functions
double	radial (const Lobe &lobe, const Vec3d &pt) const
size_t	body_radial (size_t node, const Vec3d &pt, float weight, Radial *out) const
Vec3d	offset (const Vec3d &pt, const Vec3d &center) const
int	directions () const

Private Attributes
AdaptiveInfillMode	m_mode
int	m_axis
Vec3d	m_origin
double	m_cell
Vec3i32	m_size
std::vector< int >	m_body
std::vector< Body >	m_bodies
std::vector< Lobe >	m_lobes
std::vector< int >	m_section
std::vector< float >	m_depth

Static Private Attributes
static constexpr int	Polar = 24
static constexpr int	Azimuth = 48

Detailed Description

---

Class Documentation

Slic3r::AdaptiveInfillField::Slice

struct Slic3r::AdaptiveInfillField::Slice

Collaboration diagram for Slic3r::AdaptiveInfillField::Slice:

Class Members
coordf_t	bottom_z
const ExPolygons *	expolygons
coordf_t	top_z

Slic3r::AdaptiveInfillField::Radial

struct Slic3r::AdaptiveInfillField::Radial

Class Members
Vec3d	center
double	t
float	weight

Slic3r::AdaptiveInfillField::Lobe

struct Slic3r::AdaptiveInfillField::Lobe

Collaboration diagram for Slic3r::AdaptiveInfillField::Lobe:

Class Members
Vec3d	center
double	depth
vector< float >	mean_depth
vector< float >	reach

Slic3r::AdaptiveInfillField::Body

struct Slic3r::AdaptiveInfillField::Body

Class Members
double	depth
size_t	first_lobe
size_t	lobes

Member Typedef Documentation

Radials

using Slic3r::AdaptiveInfillField::Radials = std::array<Radial, 2 * MaxMorph>

Constructor & Destructor Documentation

AdaptiveInfillField()

Slic3r::AdaptiveInfillField::AdaptiveInfillField	(	const std::vector< Slice > &	slices,
		const BoundingBox &	bbox,
		AdaptiveInfillMode	mode,
		const std::function< void()> &	throw_if_canceled )

    : m_mode(mode)
    , m_axis(mode == AdaptiveInfillMode::NormalX ? 0 : mode == AdaptiveInfillMode::NormalY ? 1 : mode == AdaptiveInfillMode::NormalZ ? 2 : -1)
{
    assert(!slices.empty() && mode != AdaptiveInfillMode::Disabled);
    const Vec3d min(unscaled(bbox.min.x()), unscaled(bbox.min.y()), slices.front().bottom_z);
    const Vec3d extent = Vec3d(unscaled(bbox.max.x()), unscaled(bbox.max.y()), slices.back().top_z) - min;
 
    // Padded by a node on each side, so that the border of the grid is outside.
    m_cell     = std::max(MinCellSize, std::cbrt(extent.prod() / MaxNodes));
    auto nodes = [this](double length) { return int(std::ceil(length / m_cell)) + 3; };
    while (double(nodes(extent.x())) * nodes(extent.y()) * nodes(extent.z()) > MaxNodes)
        m_cell *= 1.1;
    m_size   = Vec3i32(nodes(extent.x()), nodes(extent.y()), nodes(extent.z()));
    m_origin = min - Vec3d::Constant(m_cell);
 
    const size_t       sy = size_t(m_size.x());
    const size_t       sz = sy * m_size.y();
    std::vector<float> depth(sz * m_size.z(), 0.f);
    tbb::parallel_for(tbb::blocked_range<int>(0, m_size.z()), [&](const tbb::blocked_range<int> &range) {
        for (int k = range.begin(); k < range.end(); ++k) {
            const double z  = m_origin.z() + k * m_cell;
            auto         it = std::lower_bound(slices.begin(), slices.end(), z, [](const Slice &s, double z) { return s.top_z < z; });
            if (it != slices.end() && z > it->bottom_z)
                rasterize(*it->expolygons, m_origin.head<2>(), m_cell, m_size.x(), m_size.y(), depth.data() + k * sz);
        }
        throw_if_canceled();
    });
    for (int axis = 0; axis < 3; ++axis)
        if (axis != m_axis)
            distance_transform_axis(depth, m_size, axis, throw_if_canceled);
 
    auto position = [this, sy, sz](size_t i) {
        return Vec3d(m_origin + m_cell * Vec3d(double(i % sy), double(i / sy % m_size.y()), double(i / sz)));
    };
    const std::array<std::ptrdiff_t, 6> steps{1, -1, std::ptrdiff_t(sy), -std::ptrdiff_t(sy), std::ptrdiff_t(sz), -std::ptrdiff_t(sz)};
 
    auto node_of = [this, sy, sz](const Vec3d &pt) -> std::ptrdiff_t {
        const Vec3d f = (pt - m_origin) / m_cell;
        const long  x = std::lround(f.x()), y = std::lround(f.y()), z = std::lround(f.z());
        if (x < 0 || y < 0 || z < 0 || x >= m_size.x() || y >= m_size.y() || z >= m_size.z())
            return -1;
        return std::ptrdiff_t(size_t(z) * sz + size_t(y) * sy + size_t(x));
    };
    // In the 2D modes, the steps within a section.
    auto in_section = [this](size_t step) { return int(step / 2) != m_axis; };
    std::vector<std::ptrdiff_t> neighbours;
    for (int dz = -1; dz <= 1; ++dz)
        for (int dy = -1; dy <= 1; ++dy)
            for (int dx = -1; dx <= 1; ++dx)
                if ((dx != 0 || dy != 0 || dz != 0) && (m_axis < 0 || Vec3i32(dx, dy, dz)[m_axis] == 0))
                    neighbours.push_back(std::ptrdiff_t(dz) * std::ptrdiff_t(sz) + std::ptrdiff_t(dy) * std::ptrdiff_t(sy) + dx);
 
    // Bodies are the connected inside nodes, none of which is on the border. The deepest nodes of a body are the
    // centers of its lobes, unless the depth between them stays above NeckRatio; where the depth ties, the center
    // is the node nearest to the middle of the tied nodes.
    const bool lobes = m_mode != AdaptiveInfillMode::SteppedShells && m_mode != AdaptiveInfillMode::SmoothBlend;
    m_body.assign(depth.size(), -1);
    std::vector<size_t> body_nodes;
    for (size_t seed = 0; seed < depth.size(); ++seed) {
        if (depth[seed] == 0.f || m_body[seed] >= 0)
            continue;
        const int id = int(m_bodies.size());
        body_nodes.assign(1, seed);
        m_body[seed]    = id;
        float max_depth = 0.f;
        for (size_t k = 0; k < body_nodes.size(); ++k) {
            max_depth = std::max(max_depth, depth[body_nodes[k]]);
            for (size_t s = 0; s < steps.size(); ++s)
                if (const size_t j = body_nodes[k] + steps[s]; in_section(s) && depth[j] > 0.f && m_body[j] < 0) {
                    m_body[j] = id;
                    body_nodes.push_back(j);
                }
        }
        m_bodies.push_back({m_lobes.size(), 0, (std::sqrt(double(max_depth)) - 0.5) * m_cell});
        if (!lobes)
            continue;
 
        std::vector<size_t> peaks;
        for (size_t i : body_nodes)
            if (depth[i] >= sqr(MinLobeRatio) * max_depth &&
                std::all_of(neighbours.begin(), neighbours.end(), [&](std::ptrdiff_t n) { return depth[i + n] <= depth[i]; }))
                peaks.push_back(i);
        std::sort(peaks.begin(), peaks.end(), [&depth](size_t a, size_t b) { return depth[a] > depth[b] || (depth[a] == depth[b] && a < b); });
        auto necked = [&](size_t a, size_t b) {
            const Vec3d  pa = position(a), pb = position(b);
            const double limit = sqr(NeckRatio) * std::min(depth[a], depth[b]);
            const int    samples = int(std::ceil((pb - pa).norm() / (0.5 * m_cell)));
            for (int s = 1; s < samples; ++s)
                if (depth[node_of(pa + (pb - pa) * (double(s) / samples))] < limit)
                    return true;
            return false;
        };
        // A peak joins the first lobe it sees without a neck, if it is as deep. The lobes are made one at a time,
        // from the first remaining peak, testing the others in parallel.
        std::vector<std::vector<size_t>> ties;
        while (!peaks.empty()) {
            const size_t      front = peaks.front();
            std::vector<char> joins(peaks.size(), 0);
            tbb::parallel_for(tbb::blocked_range<size_t>(1, peaks.size()), [&](const tbb::blocked_range<size_t> &range) {
                for (size_t k = range.begin(); k < range.end(); ++k)
                    if (!necked(front, peaks[k]))
                        joins[k] = std::sqrt(depth[peaks[k]]) >= std::sqrt(depth[front]) - 1.f ? 1 : 2;
            });
            std::vector<size_t> &tied = ties.emplace_back(1, front);
            std::vector<size_t>  remaining;
            for (size_t k = 1; k < peaks.size(); ++k)
                if (joins[k] == 0)
                    remaining.push_back(peaks[k]);
                else if (joins[k] == 1)
                    tied.push_back(peaks[k]);
            peaks = std::move(remaining);
        }
        m_bodies.back().lobes = ties.size();
        for (const std::vector<size_t> &tied : ties) {
            Vec3d middle(0., 0., 0.);
            for (size_t i : tied)
                middle += position(i);
            middle /= double(tied.size());
            Vec3d center = position(tied.front());
            for (size_t i : tied)
                if ((position(i) - middle).squaredNorm() < (center - middle).squaredNorm())
                    center = position(i);
            m_lobes.push_back({center, (std::sqrt(double(depth[tied.front()])) - 0.5) * m_cell, {}});
        }
    }
    throw_if_canceled();
 
    if (m_mode == AdaptiveInfillMode::SteppedShells || m_mode == AdaptiveInfillMode::SmoothBlend || m_mode == AdaptiveInfillMode::DistanceWarp) {
        m_depth.assign(depth.size(), 0.f);
        for (size_t i = 0; i < depth.size(); ++i)
            if (m_body[i] >= 0)
                m_depth[i] = float(std::min(1., std::max(0., std::sqrt(double(depth[i])) - 0.5) * m_cell / m_bodies[m_body[i]].depth));
    }
 
    // The reach of a lobe is the first exit along each direction from its center, smoothed over the directions.
    // It is shortened towards a neighbouring lobe, from where the point is nearer to the other lobe relative to their depths.
    std::vector<int> lobe_body(m_lobes.size());
    for (size_t id = 0; id < m_bodies.size(); ++id)
        std::fill_n(lobe_body.begin() + m_bodies[id].first_lobe, m_bodies[id].lobes, int(id));
    const int rows      = this->directions() / Azimuth;
    auto      direction = [this](int i, int j) {
        const double azimuth = j * 2. * PI / Azimuth;
        Vec3d        dir     = Vec3d::Zero();
        if (m_axis < 0) {
            const double polar = (i + 0.5) * PI / Polar;
            dir = Vec3d(std::sin(polar) * std::cos(azimuth), std::sin(polar) * std::sin(azimuth), std::cos(polar));
        } else {
            dir[(m_axis + 1) % 3] = std::cos(azimuth);
            dir[(m_axis + 2) % 3] = std::sin(azimuth);
        }
        return dir;
    };
    // Two passes of a box filter over the neighbouring directions, for each of the values of a direction.
    auto smooth = [rows](std::vector<double> &values, size_t count) {
        for (int pass = 0; pass < 2; ++pass) {
            std::vector<double> smoothed(values.size(), 0.);
            for (int i = 0; i < rows; ++i)
                for (int j = 0; j < Azimuth; ++j)
                    for (size_t k = 0; k < count; ++k) {
                        double &sum = smoothed[size_t(i * Azimuth + j) * count + k];
                        for (int di = -1; di <= 1; ++di)
                            for (int dj = -1; dj <= 1; ++dj)
                                sum += values[size_t(std::clamp(i + di, 0, rows - 1) * Azimuth + (j + dj + Azimuth) % Azimuth) * count + k];
                        sum /= 9.;
                    }
            values = std::move(smoothed);
        }
    };
    tbb::parallel_for(tbb::blocked_range<size_t>(0, m_lobes.size()), [&](const tbb::blocked_range<size_t> &range) {
        for (size_t l = range.begin(); l < range.end(); ++l) {
            const int   id   = lobe_body[l];
            const Body &body = m_bodies[id];
            Lobe       &lobe = m_lobes[l];
            // The other lobes of the body, by the distance from the center beyond which they may be nearer.
            std::vector<std::pair<double, size_t>> others;
            for (size_t k = body.first_lobe; k < body.first_lobe + body.lobes; ++k)
                if (k != l)
                    others.emplace_back((m_lobes[k].center - lobe.center).norm() / (1. + m_lobes[k].depth / lobe.depth), k);
            std::sort(others.begin(), others.end());
            auto nearer_lobe = [&](const Vec3d &pt, double r) {
                for (auto it = others.begin(); it != others.end() && it->first < r; ++it)
                    if ((pt - m_lobes[it->second].center).norm() / m_lobes[it->second].depth < r / lobe.depth)
                        return true;
                return false;
            };
            const double        step = 0.5 * m_cell;
            std::vector<double> log_reach(this->directions());
            for (int i = 0; i < rows; ++i)
                for (int j = 0; j < Azimuth; ++j) {
                    const Vec3d dir   = direction(i, j);
                    double      r     = 0.;
                    double      limit = InfD;
                    for (;;) {
                        const Vec3d          pt = lobe.center + (r + step) * dir;
                        const std::ptrdiff_t n  = node_of(pt);
                        if (n < 0 || depth[n] == 0.f || m_body[n] != id || r + step >= limit)
                            break;
                        if (limit == InfD && nearer_lobe(pt, r + step))
                            limit = LobeReach * (r + step);
                        r += step;
                    }
                    log_reach[i * Azimuth + j] = std::log(std::min(r + 0.5 * step, limit));
                }
            smooth(log_reach, 1);
            lobe.reach.resize(log_reach.size());
            std::transform(log_reach.begin(), log_reach.end(), lobe.reach.begin(), [](double v) { return float(std::exp(v)); });
 
            if (m_mode == AdaptiveInfillMode::DistanceWarp) {
                std::vector<double> mean(log_reach.size() * (Samples + 1));
                for (size_t d = 0; d < log_reach.size(); ++d) {
                    const Vec3d dir         = direction(int(d) / Azimuth, int(d) % Azimuth);
                    double      integral    = 0.;
                    double      previous    = this->depth(lobe.center);
                    mean[d * (Samples + 1)] = previous;
                    for (int k = 1; k <= Samples; ++k) {
                        // Exact for a depth linear between the samples, a + b * tau, weighted by tau^2.
                        const double t0 = double(k - 1) / Samples;
                        const double t1 = double(k) / Samples;
                        const double d1 = this->depth(lobe.center + t1 * lobe.reach[d] * dir);
                        const double b  = (d1 - previous) * Samples;
                        const double a  = previous - b * t0;
                        integral += a * (std::pow(t1, 3) - std::pow(t0, 3)) / 3. + b * (std::pow(t1, 4) - std::pow(t0, 4)) / 4.;
                        previous                    = d1;
                        mean[d * (Samples + 1) + k] = 3. * integral / std::pow(t1, 3);
                    }
                }
                // Smoothed like the reach: sharper profiles shear the pattern across the layer, adding lines.
                smooth(mean, Samples + 1);
                lobe.mean_depth.assign(mean.begin(), mean.end());
            }
        }
        throw_if_canceled();
    });
 
    // Every other node belongs to its nearest body, within its section in the 2D modes.
    if (m_axis >= 0) {
        std::vector<bool> has_body(m_size[m_axis], false);
        for (size_t i = 0; i < m_body.size(); ++i)
            if (m_body[i] >= 0)
                has_body[m_axis == 0 ? i % sy : m_axis == 1 ? i / sy % m_size.y() : i / sz] = true;
        m_section.assign(m_size[m_axis], -1);
        for (int k = 0; k < m_size[m_axis]; ++k)
            for (int d = 0; d < m_size[m_axis] && m_section[k] < 0; ++d)
                if (k - d >= 0 && has_body[k - d])
                    m_section[k] = k - d;
                else if (k + d < m_size[m_axis] && has_body[k + d])
                    m_section[k] = k + d;
    }
    // Stepped shells and Smooth blend only look up the depth.
    if (!lobes) {
        m_body = {};
        return;
    }
    if (m_bodies.size() == 1) {
        std::fill(m_body.begin(), m_body.end(), 0);
        return;
    }
    std::deque<size_t> queue;
    for (size_t i = 0; i < m_body.size(); ++i)
        if (m_body[i] >= 0)
            queue.push_back(i);
    while (!queue.empty()) {
        const size_t i = queue.front();
        queue.pop_front();
        const size_t              x = i % sy, y = i / sy % m_size.y(), z = i / sz;
        const std::array<bool, 6> valid{x + 1 < sy, x > 0, y + 1 < size_t(m_size.y()), y > 0, z + 1 < size_t(m_size.z()), z > 0};
        for (size_t k = 0; k < steps.size(); ++k)
            if (valid[k] && in_section(k) && m_body[i + steps[k]] < 0) {
                m_body[i + steps[k]] = m_body[i];
                queue.push_back(i + steps[k]);
            }
    }
}

References depth(), Slic3r::Disabled, Slic3r::length(), m_axis, m_cell, m_mode, m_origin, m_size, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, mode(), Slic3r::range(), and Slic3r::unscaled().

Here is the call graph for this function:

Member Function Documentation

axis()

int Slic3r::AdaptiveInfillField::axis ( ) const

inline

{ return m_axis; }

References m_axis.

Referenced by radial().

Here is the caller graph for this function:

body_radial()

size_t Slic3r::AdaptiveInfillField::body_radial ( size_t node, const Vec3d & pt, float weight, Radial * out ) const

private

{
    const Body &body = m_bodies[m_body[node]];
    if (body.lobes == 1) {
        const Lobe &lobe = m_lobes[body.first_lobe];
        out[0]           = {lobe.center, radial(lobe, pt), weight};
        return 1;
    }
 
    // The lobes nearest relative to their depth; they morph into each other near the sides where they are as near.
    std::array<std::pair<double, size_t>, MaxMorph> nearest;
    size_t                                          count = 0;
    for (size_t l = body.first_lobe; l < body.first_lobe + body.lobes; ++l) {
        const double d = this->offset(pt, m_lobes[l].center).norm() / m_lobes[l].depth;
        if (count < MaxMorph)
            nearest[count++] = {d, l};
        else if (d < nearest.back().first)
            nearest.back() = {d, l};
        else
            continue;
        for (size_t k = count - 1; k > 0 && nearest[k].first < nearest[k - 1].first; --k)
            std::swap(nearest[k], nearest[k - 1]);
    }
    std::array<double, MaxMorph> blend;
    double                       total  = 0.;
    size_t                       morphs = 0;
    for (; morphs < count; ++morphs) {
        const double u = 0.5 - (nearest[morphs].first - nearest[0].first) / LobeMorph;
        if (u <= 0.)
            break;
        blend[morphs] = u * u * (3. - 2. * u);
        total += blend[morphs];
    }
    for (size_t k = 0; k < morphs; ++k) {
        const Lobe &lobe = m_lobes[nearest[k].second];
        out[k]           = {lobe.center, radial(lobe, pt), float(weight * blend[k] / total)};
    }
    return morphs;
}

References body_radial(), Slic3r::AdaptiveInfillField::Lobe::center, Slic3r::center(), count, Slic3r::AdaptiveInfillField::Body::first_lobe, Slic3r::AdaptiveInfillField::Body::lobes, m_bodies, m_body, m_lobes, MaxMorph, offset(), and radial().

Referenced by body_radial(), and radial().

Here is the call graph for this function:

Here is the caller graph for this function:

depth()

double Slic3r::AdaptiveInfillField::depth

(

const Vec3d &

pt

)

const

{
    assert(!m_depth.empty());
    const Vec3d           f = (pt - m_origin) / m_cell;
    std::array<int, 3>    n0;
    std::array<double, 3> w;
    for (int a = 0; a < 3; ++a) {
        n0[a] = std::clamp(int(std::floor(f[a])), 0, m_size[a] - 2);
        w[a]  = std::clamp(f[a] - n0[a], 0., 1.);
    }
    const size_t sy    = size_t(m_size.x());
    const size_t sz    = sy * size_t(m_size.y());
    double       value = 0.;
    for (int c = 0; c < 8; ++c) {
        const size_t n = size_t(n0[2] + (c >> 2)) * sz + size_t(n0[1] + (c >> 1 & 1)) * sy + size_t(n0[0] + (c & 1));
        value += (c & 1 ? w[0] : 1. - w[0]) * (c >> 1 & 1 ? w[1] : 1. - w[1]) * (c >> 2 ? w[2] : 1. - w[2]) * m_depth[n];
    }
    return value;
}

References depth(), Slic3r::f(), m_cell, m_depth, m_origin, and m_size.

Referenced by AdaptiveInfillField(), and depth().

Here is the call graph for this function:

Here is the caller graph for this function:

directions()

int Slic3r::AdaptiveInfillField::directions ( ) const

inlineprivate

{ return m_axis < 0 ? Polar * Azimuth : Azimuth; }

References Azimuth, m_axis, and Polar.

empty()

bool Slic3r::AdaptiveInfillField::empty ( ) const

inline

{ return m_bodies.empty(); }

References m_bodies.

Referenced by radial().

Here is the caller graph for this function:

mode()

AdaptiveInfillMode Slic3r::AdaptiveInfillField::mode ( ) const

inline

{ return m_mode; }

References m_mode.

Referenced by AdaptiveInfillField().

Here is the caller graph for this function:

offset()

Vec3d Slic3r::AdaptiveInfillField::offset ( const Vec3d & pt, const Vec3d & center ) const

private

{
    Vec3d d = pt - center;
    if (m_axis >= 0)
        d[m_axis] = 0.;
    return d;
}

References Slic3r::center(), m_axis, and offset().

Referenced by body_radial(), offset(), and radial().

Here is the call graph for this function:

Here is the caller graph for this function:

radial() [1/2]

double Slic3r::AdaptiveInfillField::radial ( const Lobe & lobe, const Vec3d & pt ) const

private

{
    const Vec3d  d = this->offset(pt, lobe.center);
    const double r = d.norm();
    // Distance warp: the radial coordinate of the linear profile with the same mean depth, which is 1 - 3/4 of it.
    auto warp = [](double mean_depth) { return std::max(0., 4. / 3. * (1. - mean_depth)); };
    if (r < EPSILON)
        return lobe.mean_depth.empty() ? 0. : warp(lobe.mean_depth.front());
    int    i  = 0;
    double fi = 0.;
    double azimuth;
    if (m_axis < 0) {
        const double polar = std::clamp(std::acos(std::clamp(d.z() / r, -1., 1.)) / PI * Polar - 0.5, 0., double(Polar - 1));
        i       = std::min(int(polar), Polar - 2);
        fi      = polar - i;
        azimuth = std::atan2(d.y(), d.x());
    } else
        azimuth = std::atan2(d[(m_axis + 2) % 3], d[(m_axis + 1) % 3]);
    azimuth *= Azimuth / (2. * PI);
    if (azimuth < 0.)
        azimuth += Azimuth;
    const int    j0    = int(azimuth) % Azimuth;
    const int    j1    = (j0 + 1) % Azimuth;
    const double fj    = azimuth - std::floor(azimuth);
    auto         at    = [&lobe](int i, int j) { return double(lobe.reach[i * Azimuth + j]); };
    double       reach = at(i, j0) * (1. - fj) + at(i, j1) * fj;
    if (fi > 0.)
        reach = reach * (1. - fi) + (at(i + 1, j0) * (1. - fj) + at(i + 1, j1) * fj) * fi;
    const double tau = r / reach;
    if (lobe.mean_depth.empty())
        return tau;
    // Beyond the surface, the depth is zero.
    auto mean_at = [&lobe, tau](int i, int j) {
        const float *mean = lobe.mean_depth.data() + size_t(i * Azimuth + j) * (Samples + 1);
        if (tau >= 1.)
            return double(mean[Samples]) / (tau * tau * tau);
        const double x = tau * Samples;
        const int    k = std::min(int(x), Samples - 1);
        return mean[k] + (mean[k + 1] - mean[k]) * (x - k);
    };
    double mean = mean_at(i, j0) * (1. - fj) + mean_at(i, j1) * fj;
    if (fi > 0.)
        mean = mean * (1. - fi) + (mean_at(i + 1, j0) * (1. - fj) + mean_at(i + 1, j1) * fj) * fi;
    return warp(mean);
}

References Azimuth, Slic3r::AdaptiveInfillField::Lobe::center, EPSILON, m_axis, Slic3r::AdaptiveInfillField::Lobe::mean_depth, offset(), PI, Polar, radial(), and Slic3r::AdaptiveInfillField::Lobe::reach.

Here is the call graph for this function:

radial() [2/2]

size_t Slic3r::AdaptiveInfillField::radial	(	const Vec3d &	pt,
		Radials &	out ) const

{
    assert(!this->empty());
    Vec3i32 idx;
    for (int axis = 0; axis < 3; ++axis)
        idx[axis] = std::clamp<int>(int(std::lround((pt[axis] - m_origin[axis]) / m_cell)), 0, m_size[axis] - 1);
    auto node = [this](const Vec3i32 &idx) { return (size_t(idx.z()) * m_size.y() + idx.y()) * m_size.x() + idx.x(); };
    if (m_axis < 0)
        return this->body_radial(node(idx), pt, 1.f, out.data());
 
    // The sections around pt, or the nearest ones with a body.
    const double f     = std::clamp((pt[m_axis] - m_origin[m_axis]) / m_cell, 0., double(m_size[m_axis] - 1));
    const int    k     = std::min(int(f), m_size[m_axis] - 2);
    const float  w     = float(f - k);
    size_t       count = 0;
    if (w < 1.f) {
        idx[m_axis] = m_section[k];
        count += this->body_radial(node(idx), pt, 1.f - w, out.data());
    }
    if (w > 0.f) {
        idx[m_axis] = m_section[k + 1];
        count += this->body_radial(node(idx), pt, w, out.data() + count);
    }
    return count;
}

References axis(), body_radial(), count, empty(), Slic3r::f(), m_axis, m_cell, m_origin, m_section, m_size, and radial().

Referenced by body_radial(), radial(), and radial().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Azimuth

int Slic3r::AdaptiveInfillField::Azimuth = 48

staticconstexprprivate

Referenced by directions(), and radial().

m_axis

int Slic3r::AdaptiveInfillField::m_axis

private

Referenced by AdaptiveInfillField(), axis(), directions(), offset(), radial(), and radial().

m_bodies

std::vector<Body> Slic3r::AdaptiveInfillField::m_bodies

private

Referenced by body_radial(), and empty().

m_body

std::vector<int> Slic3r::AdaptiveInfillField::m_body

private

Referenced by body_radial().

m_cell

double Slic3r::AdaptiveInfillField::m_cell

private

Referenced by AdaptiveInfillField(), depth(), and radial().

m_depth

std::vector<float> Slic3r::AdaptiveInfillField::m_depth

private

Referenced by depth().

m_lobes

std::vector<Lobe> Slic3r::AdaptiveInfillField::m_lobes

private

Referenced by body_radial().

m_mode

AdaptiveInfillMode Slic3r::AdaptiveInfillField::m_mode

private

Referenced by AdaptiveInfillField(), and mode().

m_origin

Vec3d Slic3r::AdaptiveInfillField::m_origin

private

Referenced by AdaptiveInfillField(), depth(), and radial().

m_section

std::vector<int> Slic3r::AdaptiveInfillField::m_section

private

Referenced by radial().

m_size

Vec3i32 Slic3r::AdaptiveInfillField::m_size

private

Referenced by AdaptiveInfillField(), depth(), and radial().

MaxMorph

size_t Slic3r::AdaptiveInfillField::MaxMorph = 4

staticconstexpr

Referenced by body_radial().

Polar

int Slic3r::AdaptiveInfillField::Polar = 24

staticconstexprprivate

Referenced by directions(), and radial().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Fill/AdaptiveInfillField.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Fill/AdaptiveInfillField.cpp