transform_implementation()

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

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

inlineoverrideprotectedvirtual

Core transformation implementation for temporal operations.

Parameters

input

Input data to transform in the time domain

Returns

Transformed output data

Performs the temporal operation specified by m_operation on the input data. Operations modify the temporal characteristics of the data including timing, duration, ordering, and envelope shaping. Supports both in-place and out-of-place transformations based on transformer settings.

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

Definition at line 79 of file TemporalTransformer.hpp.

    {
        switch (m_operation) {
 
        case TemporalOperation::TIME_REVERSE:
            return apply_per_channel(input, [](std::span<double> ch) {
                D::reverse(ch);
            });
 
        case TemporalOperation::FADE_IN_OUT: {
            const auto fi = get_parameter_or<double>("fade_in_ratio", 0.1);
            const auto fo = get_parameter_or<double>("fade_out_ratio", 0.1);
            return apply_per_channel(input, [fi, fo](std::span<double> ch) {
                D::fade(ch, fi, fo);
            });
        }
 
        case TemporalOperation::TIME_STRETCH: {
            const auto factor = get_parameter_or<double>("stretch_factor", 1.0);
            return apply_per_channel(input, [factor](std::span<const double> ch) {
                return D::time_stretch(ch, factor);
            });
        }
 
        case TemporalOperation::DELAY: {
            const auto samples = get_parameter_or<uint32_t>("delay_samples", 1000);
            const auto fill = get_parameter_or<double>("fill_value", 0.0);
            return apply_per_channel(input, [samples, fill](std::span<const double> ch) {
                return D::delay(ch, samples, fill);
            });
        }
 
        case TemporalOperation::SLICE: {
            const auto start = get_parameter_or<double>("start_ratio", 0.0);
            const auto end = get_parameter_or<double>("end_ratio", 1.0);
            return apply_per_channel(input, [start, end](std::span<const double> ch) {
                return D::slice(ch, start, end);
            });
        }
 
        case TemporalOperation::INTERPOLATE: {
            const auto target = get_parameter_or<size_t>("target_size", size_t { 0 });
            const auto cubic = get_parameter_or<bool>("use_cubic", false);
            if (target == 0)
                return create_output(input);
            return apply_per_channel(input, [target, cubic](std::span<const double> ch) {
                std::vector<double> out(target);
                if (cubic)
                    D::interpolate_cubic(ch, out);
                else
                    D::interpolate_linear(ch, out);
                return out;
            });
        }
 
        default:
            return create_output(input);
        }
    }