extract_implementation()

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

output_type MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::extract_implementation ( const input_type &  input )

inlineoverrideprotected

Core extraction implementation - delegates to ExtractionHelper.

Parameters

input

Input data with metadata

Returns

Extracted data with metadata

Definition at line 221 of file FeatureExtractor.hpp.

    {
        try {
            auto [numeric_data, info] = OperationHelper::extract_structured_double(const_cast<input_type&>(input));
            DataStructureInfo structure_info = info;
 
            std::vector<std::span<const double>> data_span;
            data_span.reserve(numeric_data.size());
 
            for (auto& span : numeric_data) {
                data_span.emplace_back(span.data(), span.size());
            }
 
            std::vector<std::vector<double>> extracted_data;
 
            switch (m_method) {
            case ExtractionMethod::HIGH_ENERGY_DATA: {
                double energy_threshold = this->template get_parameter_or_default<double>("energy_threshold", 0.1);
                extracted_data = extract_high_energy_data(data_span, energy_threshold, m_window_size, m_hop_size);
                break;
            }
            case ExtractionMethod::PEAK_DATA: {
                double threshold = this->template get_parameter_or_default<double>("threshold", 0.1);
                double min_distance = this->template get_parameter_or_default<double>("min_distance", 10.0);
                uint32_t region_size = this->template get_parameter_or_default<uint32_t>("region_size", 256);
                extracted_data = extract_peak_data(data_span, threshold, min_distance, region_size);
                break;
            }
            case ExtractionMethod::OUTLIER_DATA: {
                double std_dev_threshold = this->template get_parameter_or_default<double>("std_dev_threshold", 2.0);
                extracted_data = extract_outlier_data(data_span, std_dev_threshold, m_window_size, m_hop_size);
                break;
            }
            case ExtractionMethod::HIGH_SPECTRAL_DATA: {
                double spectral_threshold = this->template get_parameter_or_default<double>("spectral_threshold", 0.1);
                extracted_data = extract_high_spectral_data(data_span, spectral_threshold, m_window_size, m_hop_size);
                break;
            }
            case ExtractionMethod::ABOVE_MEAN_DATA: {
                double mean_multiplier = this->template get_parameter_or_default<double>("mean_multiplier", 1.5);
                extracted_data = extract_above_mean_data(data_span, mean_multiplier, m_window_size, m_hop_size);
                break;
            }
            case ExtractionMethod::OVERLAPPING_WINDOWS: {
                double overlap = this->template get_parameter_or_default<double>("overlap", 0.5);
                extracted_data = extract_overlapping_windows(data_span, m_window_size, overlap);
                break;
            }
            case ExtractionMethod::ZERO_CROSSING_DATA: {
                double threshold = this->template get_parameter_or_default<double>("threshold", 0.0);
                double min_distance = this->template get_parameter_or_default<double>("min_distance", 1.0);
                uint32_t region_size = this->template get_parameter_or_default<uint32_t>("region_size", 1);
                extracted_data = extract_zero_crossing_data(data_span, threshold, min_distance, region_size);
                break;
            }
            case ExtractionMethod::SILENCE_DATA: {
                double silence_threshold = this->template get_parameter_or_default<double>("silence_threshold", 0.01);
                uint32_t min_duration = this->template get_parameter_or_default<uint32_t>("min_duration", 1024);
                extracted_data = extract_silence_data(data_span, silence_threshold, min_duration, m_window_size, m_hop_size);
                break;
            }
            case ExtractionMethod::ONSET_DATA: {
                double threshold = this->template get_parameter_or_default<double>("threshold", 0.3);
                uint32_t region_size = this->template get_parameter_or_default<uint32_t>("region_size", 512);
                uint32_t fft_window = this->template get_parameter_or_default<uint32_t>("fft_window_size", 1024);
                extracted_data = extract_onset_data(data_span, threshold, region_size, fft_window, m_hop_size);
                break;
            }
            default:
                throw std::invalid_argument("Unknown extraction method");
            }
 
            output_type output = this->convert_result(extracted_data, structure_info);
 
            output.template set_metadata<std::string>("extractor_type", "FeatureExtractor");
            output.template set_metadata<std::string>("extraction_method", method_to_string(m_method));
            output.template set_metadata<uint32_t>("window_size", static_cast<uint32_t>(m_window_size));
            output.template set_metadata<uint32_t>("hop_size", static_cast<uint32_t>(m_hop_size));
            output.template set_metadata<size_t>("extracted_samples", extracted_data.size());
            output.template set_metadata<size_t>("original_samples", data_span.size());
 
            return output;
 
        } catch (const std::exception& e) {
            throw std::runtime_error(std::string("FeatureExtractor failed: ") + e.what());
        }
    }

References MayaFlux::Yantra::extract_above_mean_data(), MayaFlux::Yantra::extract_high_energy_data(), MayaFlux::Yantra::extract_high_spectral_data(), MayaFlux::Yantra::extract_onset_data(), MayaFlux::Yantra::extract_outlier_data(), MayaFlux::Yantra::extract_overlapping_windows(), MayaFlux::Yantra::extract_peak_data(), MayaFlux::Yantra::extract_silence_data(), and MayaFlux::Yantra::extract_zero_crossing_data().

Here is the call graph for this function: