interpolate_cubic() [1/2]

template<OperationReadyData DataType>

DataType MayaFlux::Yantra::interpolate_cubic	(	DataType &	input,
		size_t	target_size
	)

Cubic interpolation between data points using C++20 ranges (IN-PLACE)

Template Parameters

DataType

OperationReadyData type

Parameters

input	Input data - WILL BE MODIFIED/RESIZED
target_size	Target size after interpolation

Returns

Interpolated data

Definition at line 679 of file MathematicalHelper.hpp.

{
    auto [target_data, structure_info] = OperationHelper::extract_structured_double(input);
 
    bool needs_resize = false;
    for (const auto& span : target_data) {
        if (target_size != span.size()) {
            needs_resize = true;
            break;
        }
    }
 
    if (!needs_resize) {
        return input;
    }
 
    std::vector<std::vector<double>> result(target_data.size());
 
    for (size_t ch = 0; ch < target_data.size(); ++ch) {
        const auto& data_span = target_data[ch];
        auto& interpolated = result[ch];
        interpolated.resize(target_size);
 
        if (target_size <= 1 || data_span.size() <= 1) {
            std::fill(interpolated.begin(), interpolated.end(),
                data_span.empty() ? 0.0 : data_span[0]);
            continue;
        }
 
        auto indices = std::views::iota(size_t { 0 }, target_size);
        std::ranges::transform(indices, interpolated.begin(),
            [&data_span, target_size](size_t i) {
                double pos = static_cast<double>(i) * (data_span.size() - 1) / (target_size - 1);
                int idx = static_cast<int>(pos);
                double frac = pos - idx;
 
                auto get_sample = [&data_span](int i) {
                    return data_span[std::clamp(i, 0, static_cast<int>(data_span.size() - 1))];
                };
 
                double y0 = get_sample(idx - 1);
                double y1 = get_sample(idx);
                double y2 = get_sample(idx + 1);
                double y3 = get_sample(idx + 2);
 
                double a = -0.5 * y0 + 1.5 * y1 - 1.5 * y2 + 0.5 * y3;
                double b = y0 - 2.5 * y1 + 2.0 * y2 - 0.5 * y3;
                double c = -0.5 * y0 + 0.5 * y2;
                double d = y1;
 
                return ((a * frac + b) * frac + c) * frac + d;
            });
    }
 
    return OperationHelper::reconstruct_from_double<DataType>(result, structure_info);
}

References interpolate_cubic().

Referenced by interpolate_cubic(), interpolate_cubic(), and MayaFlux::Yantra::TemporalTransformer< InputType, OutputType >::transform_implementation().

Here is the call graph for this function:

Here is the caller graph for this function: