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

Applies the configured convolution operation.

Parameters

input

Input data

Returns

Transformed output

Extracts per-channel double spans, calls the corresponding Kinesis::Discrete::Convolution primitive on each channel, then reconstructs the typed output via OperationHelper.

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

Definition at line 76 of file ConvolutionTransformer.hpp.

    {
        switch (m_operation) {
 
        case ConvolutionOperation::DIRECT_CONVOLUTION: {
            const auto ir = get_parameter_or<std::vector<double>>(
                "impulse_response", std::vector<double> { 1.0 });
            return apply_per_channel(input, [&ir](std::span<const double> ch) {
                return D::convolve(ch, ir);
            });
        }
 
        case ConvolutionOperation::CROSS_CORRELATION: {
            const auto tmpl = get_parameter_or<std::vector<double>>(
                "template_signal", std::vector<double> { 1.0 });
            const auto norm = get_parameter_or<bool>("normalize", true);
            return apply_per_channel(input, [&tmpl, norm](std::span<const double> ch) {
                return D::cross_correlate(ch, tmpl, norm);
            });
        }
 
        case ConvolutionOperation::MATCHED_FILTER: {
            const auto ref = get_parameter_or<std::vector<double>>(
                "reference_signal", std::vector<double> { 1.0 });
            return apply_per_channel(input, [&ref](std::span<const double> ch) {
                return D::matched_filter(ch, ref);
            });
        }
 
        case ConvolutionOperation::DECONVOLUTION: {
            const auto ir = get_parameter_or<std::vector<double>>(
                "impulse_response", std::vector<double> { 1.0 });
            const auto reg = get_parameter_or<double>("regularization", 1e-6);
            return apply_per_channel(input, [&ir, reg](std::span<const double> ch) {
                return D::deconvolve(ch, ir, reg);
            });
        }
 
        case ConvolutionOperation::AUTO_CORRELATION: {
            const auto norm = get_parameter_or<bool>("normalize", true);
            return apply_per_channel(input, [norm](std::span<const double> ch) {
                return D::auto_correlate(ch, norm);
            });
        }
 
        default:
            return create_output(input);
        }
    }