transform_implementation()

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

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

inlineoverrideprotectedvirtual

Core transformation implementation for spectral operations.

Parameters

input

Input data to transform in the frequency domain

Returns

Transformed output data

Performs the spectral operation specified by m_operation on the input data. Operations are performed using FFT/IFFT transforms with windowing for overlap-add processing. Supports both in-place and out-of-place transformations.

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

Definition at line 74 of file SpectralTransformer.hpp.

    {
        switch (m_operation) {
        case SpectralOperation::FREQUENCY_SHIFT: {
            auto shift_hz = get_parameter_or<double>("shift_hz", 0.0);
            auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
            auto sample_rate = get_parameter_or<double>("sample_rate", 48000.0);
 
            auto low_freq = std::max(0.0, shift_hz);
            auto high_freq = sample_rate / 2.0 + shift_hz;
 
            if (this->is_in_place()) {
                return create_output(transform_spectral_filter(input, low_freq, high_freq, sample_rate, window_size, hop_size));
            }
            return create_output(transform_spectral_filter(input, low_freq, high_freq, sample_rate, window_size, hop_size, m_working_buffer));
        }
 
        case SpectralOperation::PITCH_SHIFT: {
            auto pitch_ratio = get_parameter_or<double>("pitch_ratio", 1.0);
            auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
 
            double semitones = 12.0 * std::log2(pitch_ratio);
 
            if (this->is_in_place()) {
                return create_output(transform_pitch_shift(input, semitones, window_size, hop_size));
            }
            return create_output(transform_pitch_shift(input, semitones, window_size, hop_size, m_working_buffer));
        }
 
        case SpectralOperation::SPECTRAL_FILTER: {
            auto low_freq = get_parameter_or<double>("low_freq", 20.0);
            auto high_freq = get_parameter_or<double>("high_freq", 20000.0);
            auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
            auto sample_rate = get_parameter_or<double>("sample_rate", 48000.0);
 
            if (this->is_in_place()) {
                return create_output(transform_spectral_filter(input, low_freq, high_freq, sample_rate, window_size, hop_size));
            }
            return create_output(transform_spectral_filter(input, low_freq, high_freq, sample_rate, window_size, hop_size, m_working_buffer));
        }
 
        case SpectralOperation::HARMONIC_ENHANCE: {
            auto enhancement_factor = get_parameter_or<double>("enhancement_factor", 2.0);
            auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
 
            if (this->is_in_place()) {
                auto [data_span, structure_info] = OperationHelper::extract_structured_double(input);
 
                auto processor = [enhancement_factor](Eigen::VectorXcd& spectrum, size_t) {
                    for (int i = 1; i < spectrum.size() / 2; ++i) {
                        double freq_factor = 1.0 + (enhancement_factor - 1.0) * (double(i) / (spectrum.size() / 2));
                        spectrum[i] *= freq_factor;
                        spectrum[spectrum.size() - i] *= freq_factor;
                    }
                };
 
                for (auto& span : data_span) {
                    auto result = process_spectral_windows(span, window_size, hop_size, processor);
                    std::ranges::copy(result, span.begin());
                }
 
                auto reconstructed_data = data_span
                    | std::views::transform([](const auto& span) {
                          return std::vector<double>(span.begin(), span.end());
                      })
                    | std::ranges::to<std::vector>();
 
                return create_output(OperationHelper::reconstruct_from_double<InputType>(reconstructed_data, structure_info));
            }
 
            auto [target_data, structure_info] = OperationHelper::setup_operation_buffer(input, m_working_buffer);
            auto processor = [enhancement_factor](Eigen::VectorXcd& spectrum, size_t) {
                for (int i = 1; i < spectrum.size() / 2; ++i) {
                    double freq_factor = 1.0 + (enhancement_factor - 1.0) * (double(i) / (spectrum.size() / 2));
                    spectrum[i] *= freq_factor;
                    spectrum[spectrum.size() - i] *= freq_factor;
                }
            };
 
            for (size_t i = 0; i < target_data.size(); ++i) {
                auto result = process_spectral_windows(target_data[i], window_size, hop_size, processor);
                m_working_buffer[i] = std::move(result);
            }
 
            return create_output(OperationHelper::reconstruct_from_double<InputType>(m_working_buffer, structure_info));
        }
 
        case SpectralOperation::SPECTRAL_GATE: {
            auto threshold = get_parameter_or<double>("threshold", -40.0);
            auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
 
            double linear_threshold = std::pow(10.0, threshold / 20.0);
 
            if (this->is_in_place()) {
                auto [data_span, structure_info] = OperationHelper::extract_structured_double(input);
 
                auto processor = [linear_threshold](Eigen::VectorXcd& spectrum, size_t) {
                    std::ranges::transform(spectrum, spectrum.begin(), [linear_threshold](const std::complex<double>& bin) {
                        return (std::abs(bin) > linear_threshold) ? bin : std::complex<double>(0.0, 0.0);
                    });
                };
 
                for (auto& span : data_span) {
                    auto result = process_spectral_windows(span, window_size, hop_size, processor);
                    std::ranges::copy(result, span.begin());
                }
 
                auto reconstructed_data = data_span
                    | std::views::transform([](const auto& span) {
                          return std::vector<double>(span.begin(), span.end());
                      })
                    | std::ranges::to<std::vector>();
 
                return create_output(OperationHelper::reconstruct_from_double<InputType>(reconstructed_data, structure_info));
            }
 
            auto [target_data, structure_info] = OperationHelper::setup_operation_buffer(input, m_working_buffer);
            auto processor = [linear_threshold](Eigen::VectorXcd& spectrum, size_t) {
                std::ranges::transform(spectrum, spectrum.begin(), [linear_threshold](const std::complex<double>& bin) {
                    return (std::abs(bin) > linear_threshold) ? bin : std::complex<double>(0.0, 0.0);
                });
            };
 
            for (size_t i = 0; i < target_data.size(); ++i) {
                auto result = process_spectral_windows(target_data[i], window_size, hop_size, processor);
                m_working_buffer[i] = std::move(result);
            }
 
            return create_output(OperationHelper::reconstruct_from_double<InputType>(m_working_buffer, structure_info));
        }
 
        default:
            return create_output(input);
        }
    }

References MayaFlux::Yantra::process_spectral_windows(), MayaFlux::Yantra::transform_pitch_shift(), and MayaFlux::Yantra::transform_spectral_filter().

Here is the call graph for this function: