transform_implementation()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>

output_type MayaFlux::Yantra::ConvolutionTransformer< InputType, OutputType >::transform_implementation ( input_type &  input )

inlineoverrideprotectedvirtual

Core transformation implementation for convolution operations.

Parameters

input

Input data to transform using convolution methods

Returns

Transformed output data

Performs the convolution operation specified by m_operation on the input data. Operations include direct convolution, cross-correlation, matched filtering, deconvolution, and auto-correlation. These operations are fundamental for signal processing tasks such as filtering, pattern matching, and system identification. Supports both in-place and out-of-place transformations.

Implements MayaFlux::Yantra::UniversalTransformer< InputType, OutputType >.

Definition at line 76 of file ConvolutionTransformer.hpp.

    {
        switch (m_operation) {
        case ConvolutionOperation::DIRECT_CONVOLUTION: {
            auto impulse_response = get_parameter_or<std::vector<double>>("impulse_response", std::vector<double> { 1.0 });
 
            if (this->is_in_place()) {
                return create_output(transform_convolve(input, impulse_response));
            }
            return create_output(transform_convolve(input, impulse_response, m_working_buffer));
        }
 
        case ConvolutionOperation::CROSS_CORRELATION: {
            auto template_signal = get_parameter_or<std::vector<double>>("template_signal", std::vector<double> { 1.0 });
            auto normalize = get_parameter_or<bool>("normalize", true);
 
            if (this->is_in_place()) {
                return create_output(transform_cross_correlate(input, template_signal, normalize));
            }
            return create_output(transform_cross_correlate(input, template_signal, normalize, m_working_buffer));
        }
 
        case ConvolutionOperation::MATCHED_FILTER: {
            auto reference_signal = get_parameter_or<std::vector<double>>("reference_signal", std::vector<double> { 1.0 });
 
            if (this->is_in_place()) {
                return create_output(transform_matched_filter(input, reference_signal));
            }
            return create_output(transform_matched_filter(input, reference_signal, m_working_buffer));
        }
 
        case ConvolutionOperation::DECONVOLUTION: {
            auto impulse_response = get_parameter_or<std::vector<double>>("impulse_response", std::vector<double> { 1.0 });
            auto regularization = get_parameter_or<double>("regularization", 1e-6);
 
            if (this->is_in_place()) {
                return create_output(transform_deconvolve(input, impulse_response, regularization));
            }
            return create_output(transform_deconvolve(input, impulse_response, regularization, m_working_buffer));
        }
 
        case ConvolutionOperation::AUTO_CORRELATION: {
            auto normalize = get_parameter_or<bool>("normalize", true);
 
            if (this->is_in_place()) {
                return create_output(transform_auto_correlate_fft(input, normalize));
            }
            return create_output(transform_auto_correlate_fft(input, m_working_buffer, normalize));
        }
 
        default:
            return create_output(input);
        }
    }

References MayaFlux::normalize(), MayaFlux::Yantra::transform_auto_correlate_fft(), MayaFlux::Yantra::transform_convolve(), MayaFlux::Yantra::transform_cross_correlate(), MayaFlux::Yantra::transform_deconvolve(), and MayaFlux::Yantra::transform_matched_filter().

Here is the call graph for this function: