transform_convolve() [1/2]

template<OperationReadyData DataType>

DataType MayaFlux::Yantra::transform_convolve	(	DataType &	input,
		const std::vector< double > &	impulse_response
	)

Convolution transformation using existing infrastructure with C++20 ranges (IN-PLACE)

Template Parameters

DataType

OperationReadyData type

Parameters

input	Input data - WILL BE MODIFIED
impulse_response	Impulse response for convolution

Returns

Convolved data

Definition at line 138 of file ConvolutionHelper.hpp.

{
    if (impulse_response.size() == 1) {
        if (std::abs(impulse_response[0] - 1.0) < 1e-15) {
            return input;
        } else {
            auto [target_data, structure_info] = OperationHelper::extract_structured_double(input);
 
            std::vector<std::vector<double>> reconstructed_data(target_data.size());
 
            for (size_t i = 0; i < target_data.size(); ++i) {
                std::ranges::transform(target_data[i], reconstructed_data[i].begin(),
                    [gain = impulse_response[0]](double x) { return x * gain; });
            }
            return OperationHelper::reconstruct_from_double<DataType>(reconstructed_data, structure_info);
        }
    }
 
    auto [target_data, structure_info] = OperationHelper::extract_structured_double(input);
 
    auto convolution_op = [](const Eigen::VectorXcd& input_fft,
                              const Eigen::VectorXcd& kernel_fft,
                              Eigen::VectorXcd& result_fft) {
        std::ranges::transform(input_fft, kernel_fft, result_fft.begin(),
            [](const std::complex<double>& a, const std::complex<double>& b) {
                return a * b;
            });
    };
 
    for (auto& span : target_data) {
        auto result = fft_convolve_helper(span, std::span<const double>(impulse_response), convolution_op, false);
        std::copy(result.begin(), result.end(), span.begin());
    }
 
    auto reconstructed_data = target_data
        | std::views::transform([](const auto& span) {
              return std::vector<double>(span.begin(), span.end());
          })
        | std::ranges::to<std::vector>();
 
    return OperationHelper::reconstruct_from_double<DataType>(reconstructed_data, structure_info);
}

References MayaFlux::Yantra::OperationHelper::extract_structured_double(), and fft_convolve_helper().

Referenced by MayaFlux::Yantra::ConvolutionTransformer< InputType, OutputType >::transform_implementation().

Here is the call graph for this function:

Here is the caller graph for this function: