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 78 of file MathematicalTransformer.hpp.

    {
        switch (m_operation) {
        case MathematicalOperation::GAIN: {
            auto gain_factor = get_parameter_or<double>("gain_factor", 1.0);
            if (this->is_in_place()) {
                return create_output(transform_linear(input, gain_factor, 0.0));
            }
            return create_output(transform_linear(input, gain_factor, 0.0, m_working_buffer));
        }
 
        case MathematicalOperation::OFFSET: {
            auto offset_value = get_parameter_or<double>("offset_value", 0.0);
            if (this->is_in_place()) {
                return create_output(transform_linear(input, 1.0, offset_value));
            }
            return create_output(transform_linear(input, 1.0, offset_value, m_working_buffer));
        }
 
        case MathematicalOperation::POWER: {
            auto exponent = get_parameter_or<double>("exponent", 2.0);
 
            if (this->is_in_place()) {
                return create_output(transform_power(input, exponent));
            }
            return create_output(transform_power(input, exponent, m_working_buffer));
        }
 
        case MathematicalOperation::LOGARITHMIC: {
            auto scale = get_parameter_or<double>("scale", 1.0);
            auto input_scale = get_parameter_or<double>("input_scale", 1.0);
            auto offset = get_parameter_or<double>("offset", 1.0);
            auto base = get_parameter_or<double>("base", std::numbers::e);
 
            if (this->is_in_place()) {
                return create_output(transform_logarithmic(input, scale, input_scale, offset, base));
            }
            return create_output(transform_logarithmic(input, scale, input_scale, offset, m_working_buffer, base));
        }
 
        case MathematicalOperation::EXPONENTIAL: {
            auto scale = get_parameter_or<double>("scale", 1.0);
            auto rate = get_parameter_or<double>("rate", 1.0);
            auto base = get_parameter_or<double>("base", std::numbers::e);
 
            if (this->is_in_place()) {
                return create_output(transform_exponential(input, scale, rate, base));
            }
            return create_output(transform_exponential(input, scale, rate, m_working_buffer, base));
        }
 
        case MathematicalOperation::TRIGONOMETRIC: {
            auto trig_function = get_parameter_or<std::string>("trig_function", "sin");
            auto frequency = get_parameter_or<double>("frequency", 1.0);
            auto amplitude = get_parameter_or<double>("amplitude", 1.0);
            auto phase = get_parameter_or<double>("phase", 0.0);
 
            if (trig_function == "sin") {
                if (this->is_in_place()) {
                    return create_output(transform_trigonometric(input, [](double x) { return std::sin(x); }, frequency, amplitude, phase));
                }
                return create_output(transform_trigonometric(input, [](double x) { return std::sin(x); }, frequency, amplitude, phase, m_working_buffer));
            }
            if (trig_function == "cos") {
                if (this->is_in_place()) {
                    return create_output(transform_trigonometric(input, [](double x) { return std::cos(x); }, frequency, amplitude, phase));
                }
                return create_output(transform_trigonometric(input, [](double x) { return std::cos(x); }, frequency, amplitude, phase, m_working_buffer));
            }
            if (trig_function == "tan") {
                if (this->is_in_place()) {
                    return create_output(transform_trigonometric(input, [](double x) { return std::tan(x); }, frequency, amplitude, phase));
                }
                return create_output(transform_trigonometric(input, [](double x) { return std::tan(x); }, frequency, amplitude, phase, m_working_buffer));
            }
            return create_output(input);
        }
 
        case MathematicalOperation::QUANTIZE: {
            auto bits = get_parameter_or<uint8_t>("bits", 16);
            if (this->is_in_place()) {
                return create_output(transform_quantize(input, bits));
            }
            return create_output(transform_quantize(input, bits, m_working_buffer));
        }
 
        case MathematicalOperation::NORMALIZE: {
            auto target_peak = get_parameter_or<double>("target_peak", 1.0);
            std::pair<double, double> target_range = { -target_peak, target_peak };
            if (this->is_in_place()) {
                return create_output(transform_normalize(input, target_range));
            }
            return create_output(transform_normalize(input, target_range, m_working_buffer));
        }
 
        case MathematicalOperation::POLYNOMIAL: {
            auto coefficients = get_parameter_or<std::vector<double>>("coefficients", std::vector<double> { 0.0, 1.0 });
            if (this->is_in_place()) {
                return create_output(transform_polynomial(input, coefficients));
            }
            return create_output(transform_polynomial(input, coefficients, m_working_buffer));
        }
 
        default:
            return create_output(input);
        }
    }

References MayaFlux::Yantra::transform_exponential(), MayaFlux::Yantra::transform_linear(), MayaFlux::Yantra::transform_logarithmic(), MayaFlux::Yantra::transform_normalize(), MayaFlux::Yantra::transform_polynomial(), MayaFlux::Yantra::transform_power(), MayaFlux::Yantra::transform_quantize(), and MayaFlux::Yantra::transform_trigonometric().

Here is the call graph for this function: