transform_implementation()

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

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

inlineoverrideprotectedvirtual

Core transformation implementation.

Parameters

input

Input data to transform

Returns

Transformed output data

Performs the mathematical operation specified by m_operation on the input data. Supports both in-place and out-of-place transformations based on transformer settings.

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

Definition at line 80 of file MathematicalTransformer.hpp.

    {
        switch (m_operation) {
 
        case MathematicalOperation::GAIN: {
            const auto a = get_parameter_or<double>("gain_factor", 1.0);
            return apply_per_channel(input, [a](std::span<double> ch) {
                D::linear(ch, a, 0.0);
            });
        }
 
        case MathematicalOperation::OFFSET: {
            const auto b = get_parameter_or<double>("offset_value", 0.0);
            return apply_per_channel(input, [b](std::span<double> ch) {
                D::linear(ch, 1.0, b);
            });
        }
 
        case MathematicalOperation::POWER: {
            const auto exp = get_parameter_or<double>("exponent", 2.0);
            return apply_per_channel(input, [exp](std::span<double> ch) {
                D::power(ch, exp);
            });
        }
 
        case MathematicalOperation::LOGARITHMIC: {
            const auto a = get_parameter_or<double>("scale", 1.0);
            const auto b = get_parameter_or<double>("input_scale", 1.0);
            const auto c = get_parameter_or<double>("offset", 1.0);
            const auto base = get_parameter_or<double>("base", std::numbers::e);
            return apply_per_channel(input, [a, b, c, base](std::span<double> ch) {
                D::logarithmic(ch, a, b, c, base);
            });
        }
 
        case MathematicalOperation::EXPONENTIAL: {
            const auto a = get_parameter_or<double>("scale", 1.0);
            const auto b = get_parameter_or<double>("rate", 1.0);
            const auto base = get_parameter_or<double>("base", std::numbers::e);
            return apply_per_channel(input, [a, b, base](std::span<double> ch) {
                D::exponential(ch, a, b, base);
            });
        }
 
        case MathematicalOperation::TRIGONOMETRIC: {
            const auto fn = get_parameter_or<std::string>("trig_function", "sin");
            const auto freq = get_parameter_or<double>("frequency", 1.0);
            const auto amp = get_parameter_or<double>("amplitude", 1.0);
            const auto ph = get_parameter_or<double>("phase", 0.0);
            if (fn == "cos")
                return apply_per_channel(input, [freq, amp, ph](std::span<double> ch) {
                    D::apply_trig(ch, [](double x) { return std::cos(x); }, freq, amp, ph);
                });
            if (fn == "tan")
                return apply_per_channel(input, [freq, amp, ph](std::span<double> ch) {
                    D::apply_trig(ch, [](double x) { return std::tan(x); }, freq, amp, ph);
                });
            return apply_per_channel(input, [freq, amp, ph](std::span<double> ch) {
                D::apply_trig(ch, [](double x) { return std::sin(x); }, freq, amp, ph);
            });
        }
 
        case MathematicalOperation::QUANTIZE: {
            const auto bits = get_parameter_or<uint8_t>("bits", 16);
            return apply_per_channel(input, [bits](std::span<double> ch) {
                D::quantize(ch, bits);
            });
        }
 
        case MathematicalOperation::NORMALIZE: {
            const auto peak = get_parameter_or<double>("target_peak", 1.0);
            return apply_per_channel(input, [peak](std::span<double> ch) {
                D::normalize(ch, -peak, peak);
            });
        }
 
        case MathematicalOperation::POLYNOMIAL: {
            const auto coeffs = get_parameter_or<std::vector<double>>(
                "coefficients", std::vector<double> { 0.0, 1.0 });
            auto poly = std::make_shared<Nodes::Generator::Polynomial>(coeffs);
            return apply_per_channel(input, [&poly](std::span<double> ch) {
                std::ranges::transform(ch, ch.begin(),
                    [&poly](double x) { return poly->process_sample(x); });
            });
        }
 
        default:
            return create_output(input);
        }
    }

References a, b, and MayaFlux::peak().

Here is the call graph for this function: