interpolate_cubic()

void MayaFlux::Kinesis::Discrete::interpolate_cubic ( std::span< const double >  src, std::span< double >  dst  )

noexcept

Catmull-Rom cubic interpolation from src into dst (caller sizes dst) Branchless boundary clamping; Horner evaluation form.

Parameters

src	Source span (read-only, at least 2 samples)
dst	Destination span (written in-place)

Definition at line 183 of file Transform.cpp.

{
    const size_t dst_n = dst.size();
    const size_t src_n = src.size();
 
    if (dst_n == 0 || src_n == 0)
        return;
 
    if (dst_n == 1 || src_n == 1) {
        std::ranges::fill(dst, src[0]);
        return;
    }
 
    const double step = static_cast<double>(src_n - 1) / static_cast<double>(dst_n - 1);
    const size_t last = src_n - 1;
 
    Parallel::for_each(Parallel::par_unseq,
        std::views::iota(size_t { 0 }, dst_n).begin(),
        std::views::iota(size_t { 0 }, dst_n).end(),
        [&src, &dst, step, last](size_t i) {
            const double pos = static_cast<double>(i) * step;
            const auto idx = static_cast<size_t>(pos);
            const double f = pos - static_cast<double>(idx);
 
            const size_t i0 = idx > 0 ? idx - 1 : 0;
            const size_t i1 = idx;
            const size_t i2 = std::min(idx + 1, last);
            const size_t i3 = std::min(idx + 2, last);
 
            const double y0 = src[i0], y1 = src[i1], y2 = src[i2], y3 = src[i3];
            const double a = -0.5 * y0 + 1.5 * y1 - 1.5 * y2 + 0.5 * y3;
            const double b = y0 - 2.5 * y1 + 2.0 * y2 - 0.5 * y3;
            const double c = -0.5 * y0 + 0.5 * y2;
            dst[i] = ((a * f + b) * f + c) * f + y1;
        });
}

References a, and b.