extract_high_energy_data()

std::vector< std::vector< double > > MayaFlux::Yantra::extract_high_energy_data	(	const std::vector< std::span< const double > > &	data,
		double	energy_threshold = 0.1,
		uint32_t	window_size = 512,
		uint32_t	hop_size = 256
	)

Extract data from high-energy regions using EnergyAnalyzer.

Parameters

data	Input data span
energy_threshold	Minimum energy threshold for region selection
window_size	Analysis window size
hop_size	Hop size between windows

Returns

Vector containing actual data from high-energy regions

Definition at line 46 of file ExtractionHelper.cpp.

{
    std::vector<std::vector<double>> result;
    result.reserve(data.size());
 
    for (const auto& channel : data) {
        if (channel.empty()) {
            result.emplace_back();
            continue;
        }
 
        uint32_t effective_window_size = std::min(window_size, static_cast<uint32_t>(channel.size()));
        uint32_t effective_hop_size = std::min(hop_size, effective_window_size / 2);
        if (effective_hop_size == 0)
            effective_hop_size = 1;
 
        if (!validate_extraction_parameters(effective_window_size, effective_hop_size, channel.size())) {
            result.emplace_back();
            continue;
        }
 
        try {
            auto energy_analyzer = std::make_shared<EnergyAnalyzer<std::vector<Kakshya::DataVariant>, Eigen::VectorXd>>(
                effective_window_size, effective_hop_size);
            energy_analyzer->set_parameter("method", "rms");
 
            std::vector<Kakshya::DataVariant> data_variant { Kakshya::DataVariant { std::vector<double>(channel.begin(), channel.end()) } };
            EnergyAnalysis energy_result = energy_analyzer->analyze_energy(data_variant);
 
            if (energy_result.channels.empty() || energy_result.channels[0].energy_values.empty() || energy_result.channels[0].window_positions.empty()) {
                result.emplace_back();
                continue;
            }
 
            std::vector<std::pair<size_t, size_t>> qualifying_windows;
            const auto& ch_energy = energy_result.channels[0].energy_values;
            const auto& ch_windows = energy_result.channels[0].window_positions;
            for (size_t i = 0; i < ch_energy.size(); ++i) {
                if (ch_energy[i] > energy_threshold) {
                    auto [start_idx, end_idx] = ch_windows[i];
                    if (start_idx < channel.size() && end_idx <= channel.size() && start_idx < end_idx) {
                        qualifying_windows.emplace_back(start_idx, end_idx);
                    }
                }
            }
 
            auto merged_windows = merge_overlapping_windows(qualifying_windows);
 
            std::vector<double> extracted_data;
            for (const auto& [start_idx, end_idx] : merged_windows) {
                std::ranges::copy(channel.subspan(start_idx, end_idx - start_idx),
                    std::back_inserter(extracted_data));
            }
 
            result.push_back(std::move(extracted_data));
        } catch (const std::exception&) {
            result.emplace_back();
        }
    }
 
    return result;
}

References MayaFlux::Yantra::EnergyAnalysis::channels, and validate_extraction_parameters().

Referenced by MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::extract_implementation().

Here is the call graph for this function:

Here is the caller graph for this function: