extract_above_mean_data()

std::vector< std::vector< double > > MayaFlux::Yantra::extract_above_mean_data	(	const std::vector< std::span< const double > > &	data,
		double	mean_multiplier = 1.5,
		uint32_t	window_size = 512,
		uint32_t	hop_size = 256
	)

Extract data from regions with values above statistical mean.

Parameters

data	Input data span
mean_multiplier	Multiplier for mean threshold (e.g., 1.5 = 1.5x mean)
window_size	Analysis window size
hop_size	Hop size between windows

Returns

Vector containing actual data from above-mean regions

Definition at line 318 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 stat_analyzer = std::make_shared<StatisticalAnalyzer<std::vector<Kakshya::DataVariant>, Eigen::VectorXd>>(
                effective_window_size, effective_hop_size);
            stat_analyzer->set_parameter("method", "mean");
 
            std::vector<Kakshya::DataVariant> data_variant { Kakshya::DataVariant { std::vector<double>(channel.begin(), channel.end()) } };
            ChannelStatistics stat_result = stat_analyzer->analyze_statistics(data_variant).channel_statistics[0];
 
            if (stat_result.statistical_values.empty() || stat_result.window_positions.empty()) {
                result.emplace_back();
                continue;
            }
 
            const double threshold = stat_result.mean_stat * mean_multiplier;
 
            std::vector<std::pair<size_t, size_t>> qualifying_windows;
            for (size_t i = 0; i < stat_result.statistical_values.size(); ++i) {
                if (stat_result.statistical_values[i] > threshold) {
                    auto [start_idx, end_idx] = stat_result.window_positions[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::ChannelStatistics::mean_stat, MayaFlux::Yantra::ChannelStatistics::statistical_values, validate_extraction_parameters(), and MayaFlux::Yantra::ChannelStatistics::window_positions.

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: