Collaboration diagram for marchsq::AdaptiveTpmsField:

Public Member Functions
	AdaptiveTpmsField (const AdaptiveTpms &tpms, const AdaptiveInfillField &radial_field, const BoundingBox &bbox, coordf_t z, float angle)
float	get_scalar (const Coord &p) const
coord_t	to_coord (long x) const
long	to_coordr (coord_t x) const
Point	to_Point (const Coord &p) const

Public Attributes
const coord_t	rsize = scaled(rsizef)
const long	gsize = std::lround(gsizef / rsizef)
const AdaptiveTpms &	tpms
const AdaptiveInfillField &	radial_field
RadialScale	scale
DensityLevels	levels
Point	size
Point	offs
double	z
double	cos_angle
double	sin_angle

Static Public Attributes
static constexpr float	gsizef = 0.40f
static constexpr float	rsizef = 0.004f

Detailed Description

Constructor & Destructor Documentation

◆ AdaptiveTpmsField()

marchsq::AdaptiveTpmsField::AdaptiveTpmsField	(	const AdaptiveTpms &	tpms,
		const AdaptiveInfillField &	radial_field,
		const BoundingBox &	bbox,
		coordf_t	z,
		float	angle )

inline

        : tpms(tpms), radial_field(radial_field), scale(tpms, radial_field.axis() < 0 ? 3 : 2)
        , levels(std::max(tpms.interior_frequency / tpms.surface_frequency, 1e-3), BlendRatio, tpms.gradient)
        , size(bbox.size()), offs(bbox.min), z(z)
        , cos_angle(std::cos(angle)), sin_angle(std::sin(angle))
    {}

References Slic3r::angle(), cos_angle, levels, offs, radial_field, scale, sin_angle, size, tpms, and z.

Here is the call graph for this function:

Member Function Documentation

◆ get_scalar()

float marchsq::AdaptiveTpmsField::get_scalar ( const Coord & p ) const

inline

    {
        const Point                            pt = to_Point(p);
        const double                           x  = unscaled(pt.x());
        const double                           y  = unscaled(pt.y());
        const Vec3d                            obj(cos_angle * x - sin_angle * y, sin_angle * x + cos_angle * y, z);
        if (radial_field.mode() == AdaptiveInfillMode::SmoothBlend) {
            // The regular patterns of the two levels around the target of the depth, blended by a smoothstep.
            auto lattice = [this, x, y](int level) {
                const double frequency = tpms.surface_frequency * levels.scale(level);
                return tpms.equation(float(frequency * x), float(frequency * y), float(frequency * z));
            };
            if (levels.count == 0)
                return lattice(0);
            const double c = std::clamp(levels.level(radial_field.depth(obj)), 0., double(levels.count));
            const int    k = std::min(int(c), levels.count - 1);
            const double u = c - k;
            const double w = u * u * (3. - 2. * u);
            return float((w < 1. ? (1. - w) * lattice(k) : 0.) + (w > 0. ? w * lattice(k + 1) : 0.));
        }
        const int                              axis = radial_field.axis();
        AdaptiveInfillField::Radials               radials;
        const size_t                           count = radial_field.radial(obj, radials);
        float                                  value = 0.f;
        for (size_t i = 0; i < count; ++i) {
            const auto &[center, t, weight] = radials[i];
            Vec3d q                         = tpms.surface_frequency * scale(t) * (obj - center);
            if (axis >= 0)
                q[axis] = tpms.interior_frequency * obj[axis];
            value += weight * tpms.equation(float(cos_angle * q.x() + sin_angle * q.y()), float(cos_angle * q.y() - sin_angle * q.x()), float(q.z()));
        }
        return value;
    }