extract_peak_data()

std::vector< std::vector< double > > MayaFlux::Yantra::extract_peak_data	(	const std::vector< std::span< const double > > &	data,
		double	threshold = 0.1,
		double	min_distance = 10.0,
		uint32_t	region_size = 256
	)

Extract data from peak regions using peak detection.

Parameters

data	Input data span
threshold	Peak detection threshold
min_distance	Minimum distance between peaks
region_size	Size of region around each peak to extract

Returns

Vector containing actual data from peak regions

Definition at line 113 of file ExtractionHelper.cpp.

{
    std::vector<std::vector<double>> result;
    result.reserve(data.size());
 
    for (const auto& channel : data) {
        if (channel.size() < 3) {
            result.emplace_back();
            continue;
        }
 
        try {
            auto analyzer = std::make_shared<EnergyAnalyzer<std::vector<Kakshya::DataVariant>, Eigen::VectorXd>>(
                512, 256);
            analyzer->set_parameter("method", "peak");
            analyzer->set_parameter("threshold", threshold);
 
            std::vector<Kakshya::DataVariant> data_variant {
                Kakshya::DataVariant { std::vector<double>(channel.begin(), channel.end()) }
            };
            EnergyAnalysis energy_result = analyzer->analyze_energy(data_variant);
 
            if (energy_result.channels.empty()) {
                result.emplace_back();
                continue;
            }
 
            const auto& peak_positions = energy_result.channels[0].event_positions;
 
            if (peak_positions.empty()) {
                result.emplace_back();
                continue;
            }
 
            std::vector<size_t> filtered_positions;
            size_t last_position = 0;
 
            for (size_t pos : peak_positions) {
                if (filtered_positions.empty() || (pos - last_position) >= static_cast<size_t>(min_distance)) {
                    filtered_positions.push_back(pos);
                    last_position = pos;
                }
            }
 
            std::vector<double> extracted_data;
            for (size_t peak_pos : filtered_positions) {
                const size_t half_region = region_size / 2;
                const size_t start_idx = (peak_pos >= half_region) ? peak_pos - half_region : 0;
                const size_t end_idx = std::min(peak_pos + half_region, channel.size());
 
                if (start_idx < channel.size() && end_idx <= channel.size() && start_idx < end_idx) {
                    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.

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

Here is the caller graph for this function: