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 257 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>> channels;
            channels.reserve(numeric_data.size());
            for (auto& s : numeric_data)
                channels.emplace_back(s.data(), s.size());
 
            std::vector<std::vector<double>> extracted_data;
 
            switch (m_method) {
 
            case ExtractionMethod::HIGH_ENERGY_DATA:
                extracted_data = extract_high_energy(channels,
                    this->template get_parameter_or_default<double>("energy_threshold", 0.1),
                    m_window_size, m_hop_size);
                break;
 
            case ExtractionMethod::PEAK_DATA:
                extracted_data = extract_peaks(channels,
                    this->template get_parameter_or_default<double>("threshold", 0.1),
                    this->template get_parameter_or_default<double>("min_distance", 10.0),
                    this->template get_parameter_or_default<uint32_t>("region_size", 256));
                break;
 
            case ExtractionMethod::OUTLIER_DATA:
                extracted_data = extract_outliers(channels,
                    this->template get_parameter_or_default<double>("std_dev_threshold", 2.0),
                    m_window_size, m_hop_size);
                break;
 
            case ExtractionMethod::HIGH_SPECTRAL_DATA:
                extracted_data = extract_high_spectral(channels,
                    this->template get_parameter_or_default<double>("spectral_threshold", 0.1),
                    m_window_size, m_hop_size);
                break;
 
            case ExtractionMethod::ABOVE_MEAN_DATA:
                extracted_data = extract_above_mean(channels,
                    this->template get_parameter_or_default<double>("mean_multiplier", 1.5),
                    m_window_size, m_hop_size);
                break;
 
            case ExtractionMethod::OVERLAPPING_WINDOWS:
                extracted_data = extract_overlapping_windows(channels,
                    m_window_size,
                    this->template get_parameter_or_default<double>("overlap", 0.5));
                break;
 
            case ExtractionMethod::ZERO_CROSSING_DATA:
                extracted_data = extract_zero_crossings(channels,
                    this->template get_parameter_or_default<double>("threshold", 0.0),
                    this->template get_parameter_or_default<double>("min_distance", 1.0),
                    this->template get_parameter_or_default<uint32_t>("region_size", 1));
                break;
 
            case ExtractionMethod::SILENCE_DATA:
                extracted_data = extract_silence(channels,
                    this->template get_parameter_or_default<double>("silence_threshold", 0.01),
                    this->template get_parameter_or_default<uint32_t>("min_duration", 1024),
                    m_window_size, m_hop_size);
                break;
 
            case ExtractionMethod::ONSET_DATA:
                extracted_data = extract_onsets(channels,
                    this->template get_parameter_or_default<double>("threshold", 0.3),
                    this->template get_parameter_or_default<uint32_t>("region_size", 512),
                    this->template get_parameter_or_default<uint32_t>("fft_window_size", 1024),
                    m_hop_size);
                break;
 
            default:
                error<std::invalid_argument>(Journal::Component::Yantra, Journal::Context::ComputeMatrix, std::source_location::current(), "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());
 
            return output;
 
        } catch (const std::exception& e) {
            MF_ERROR(Journal::Component::Yantra, Journal::Context::ComputeMatrix, "Feature extraction failed: {}", e.what());
            return output_type {};
        }
    }

References MayaFlux::Yantra::ABOVE_MEAN_DATA, channels, MayaFlux::Journal::ComputeMatrix, MayaFlux::Yantra::extract_above_mean(), MayaFlux::Yantra::extract_high_energy(), MayaFlux::Yantra::extract_high_spectral(), MayaFlux::Yantra::extract_onsets(), MayaFlux::Yantra::extract_outliers(), MayaFlux::Yantra::extract_overlapping_windows(), MayaFlux::Kinesis::Vision::extract_peaks(), MayaFlux::Yantra::extract_silence(), MayaFlux::Yantra::OperationHelper::extract_structured_double(), MayaFlux::Yantra::extract_zero_crossings(), MayaFlux::Yantra::HIGH_ENERGY_DATA, MayaFlux::Yantra::HIGH_SPECTRAL_DATA, input, MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::m_hop_size, MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::m_method, MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::m_window_size, MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::method_to_string(), MF_ERROR, MayaFlux::Yantra::ONSET_DATA, MayaFlux::Yantra::OUTLIER_DATA, MayaFlux::Yantra::OVERLAPPING_WINDOWS, MayaFlux::Yantra::PEAK_DATA, MayaFlux::Yantra::SILENCE_DATA, MayaFlux::Journal::Yantra, and MayaFlux::Yantra::ZERO_CROSSING_DATA.

Here is the call graph for this function: