extract_silence_data()

std::vector< std::vector< double > > MayaFlux::Yantra::extract_silence_data	(	const std::vector< std::span< const double > > &	data,
		double	silence_threshold = 0.01,
		uint32_t	min_duration = 1024,
		uint32_t	window_size = 512,
		uint32_t	hop_size = 256
	)

Extract data from silent regions using existing EnergyAnalyzer.

Parameters

data	Input data span
silence_threshold	Energy threshold below which regions are considered silent
min_duration	Minimum duration for silence regions
window_size	Analysis window size
hop_size	Hop size between windows

Returns

Vector containing actual data from silent regions

Definition at line 552 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 = std::min(window_size, static_cast<uint32_t>(channel.size()));
        uint32_t effective_hop = std::max(1U, std::min(hop_size, window_size / 2));
 
        try {
            auto analyzer = std::make_shared<EnergyAnalyzer<std::vector<Kakshya::DataVariant>, Eigen::VectorXd>>(
                effective_window, effective_hop);
            analyzer->set_parameter("method", "rms");
            analyzer->set_energy_thresholds(0.0, silence_threshold, silence_threshold * 2.0, silence_threshold * 5.0);
            analyzer->enable_classification(true);
 
            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() || energy_result.channels[0].energy_values.empty() || energy_result.channels[0].window_positions.empty() || energy_result.channels[0].classifications.empty()) {
                result.emplace_back();
                continue;
            }
 
            const auto& classifications = energy_result.channels[0].classifications;
            const auto& window_positions = energy_result.channels[0].window_positions;
 
            std::vector<std::pair<size_t, size_t>> regions;
            for (size_t idx = 0; idx < classifications.size(); ++idx) {
                if (classifications[idx] == EnergyLevel::SILENT) {
                    auto [start_idx, end_idx] = window_positions[idx];
                    if (end_idx > start_idx && (end_idx - start_idx) >= min_duration) {
                        regions.emplace_back(start_idx, end_idx);
                    }
                }
            }
 
            auto merged_regions = merge_overlapping_windows(regions);
 
            std::vector<double> extracted_data;
            for (const auto& [start_idx, end_idx] : merged_regions) {
                if (start_idx < channel.size() && end_idx <= channel.size() && start_idx < end_idx) {
                    auto region = channel.subspan(start_idx, end_idx - start_idx);
                    std::ranges::copy(region, 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 SILENT.

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

Here is the caller graph for this function: