interpolate_cubic() [2/2]

template<OperationReadyData DataType>

DataType MayaFlux::Yantra::interpolate_cubic	(	DataType &	input,
		size_t	target_size,
		std::vector< std::vector< double > > &	working_buffer
	)

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

Template Parameters

DataType

OperationReadyData type

Parameters

input	Input data - will NOT be modified
target_size	Target size after interpolation
working_buffer	Buffer for operations (will be resized if needed)

Returns

Interpolated data

Definition at line 745 of file MathematicalHelper.hpp.

{
    auto [target_data, structure_info] = OperationHelper::setup_operation_buffer(input, working_buffer);
 
    bool needs_resize = false;
    for (const auto& span : target_data) {
        if (target_size != span.size()) {
            needs_resize = true;
            break;
        }
    }
 
    if (!needs_resize) {
        return OperationHelper::reconstruct_from_double<DataType>(working_buffer, structure_info);
    }
 
    for (size_t ch = 0; ch < target_data.size(); ++ch) {
        const auto& data_span = target_data[ch];
        working_buffer[ch].resize(target_size);
 
        if (target_size <= 1 || data_span.size() <= 1) {
            std::fill(working_buffer[ch].begin(), working_buffer[ch].end(),
                data_span.empty() ? 0.0 : data_span[0]);
            continue;
        }
 
        auto indices = std::views::iota(size_t { 0 }, target_size);
        std::ranges::transform(indices, working_buffer[ch].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>(working_buffer, structure_info);
}

References interpolate_cubic().

Here is the call graph for this function: