extract_zero_crossing_data()

std::vector< std::vector< double > > MayaFlux::Yantra::extract_zero_crossing_data	(	const std::vector< std::span< const double > > &	data,
		double	threshold = 0.0,
		double	min_distance = 1.0,
		uint32_t	region_size = 1
	)

Extract data at zero crossing points using existing EnergyAnalyzer.

Parameters

data	Input data span
threshold	Zero crossing threshold (default: 0.0)
min_distance	Minimum distance between crossings
region_size	Size of region around each crossing to extract

Returns

Vector containing actual data from zero crossing regions

Definition at line 477 of file ExtractionHelper.cpp.

{
    std::vector<std::vector<double>> result;
    result.reserve(data.size());
 
    for (const auto& channel : data) {
        if (channel.empty() || region_size == 0) {
            result.emplace_back();
            continue;
        }
 
        try {
            auto analyzer = std::make_shared<EnergyAnalyzer<std::vector<Kakshya::DataVariant>, Eigen::VectorXd>>(
                region_size * 2, static_cast<uint32_t>(min_distance));
            analyzer->set_parameter("method", "zero_crossing");
 
            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& crossing_positions = energy_result.channels[0].event_positions;
 
            if (crossing_positions.empty()) {
                result.emplace_back();
                continue;
            }
 
            std::vector<size_t> filtered_positions;
            size_t last_position = 0;
 
            for (size_t pos : crossing_positions) {
                if (filtered_positions.empty() || (pos - last_position) >= static_cast<size_t>(min_distance)) {
                    filtered_positions.push_back(pos);
                    last_position = pos;
                }
            }
 
            std::vector<size_t> qualified_positions;
            for (size_t pos : filtered_positions) {
                if (pos < channel.size() && std::abs(channel[pos]) >= threshold) {
                    qualified_positions.push_back(pos);
                }
            }
 
            std::vector<double> extracted_data;
            for (size_t pos : qualified_positions) {
                const size_t half_region = region_size / 2;
                const size_t region_start = (pos >= half_region) ? pos - half_region : 0;
                const size_t region_end = std::min(pos + half_region, channel.size());
 
                if (region_start < region_end) {
                    auto region = channel.subspan(region_start, region_end - region_start);
                    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.

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

Here is the caller graph for this function: