create_analysis_result()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = Eigen::VectorXd>

EnergyAnalysis MayaFlux::Yantra::EnergyAnalyzer< InputType, OutputType >::create_analysis_result ( const std::vector< std::vector< double > > &  energy_values, std::vector< std::span< const double > >  original_data, const DataStructureInfo &    ) const

inlineprivate

Create comprehensive analysis result from energy computation.

Definition at line 423 of file EnergyAnalyzer.hpp.

    {
        EnergyAnalysis result;
        result.method_used = m_method;
        result.window_size = m_window_size;
        result.hop_size = m_hop_size;
 
        if (energy_values.empty()) {
            return result;
        }
 
        result.channels.resize(energy_values.size());
 
        for (size_t ch = 0; ch < energy_values.size(); ch++) {
 
            auto& channel_result = result.channels[ch];
            const auto& ch_energy = energy_values[ch];
 
            channel_result.energy_values = ch_energy;
 
            if (!ch_energy.empty()) {
                auto [min_it, max_it] = std::ranges::minmax_element(ch_energy);
                channel_result.min_energy = *min_it;
                channel_result.max_energy = *max_it;
 
                const double sum = std::accumulate(ch_energy.begin(), ch_energy.end(), 0.0);
                channel_result.mean_energy = sum / static_cast<double>(ch_energy.size());
 
                const double mean = channel_result.mean_energy;
                const double var_sum = std::transform_reduce(
                    ch_energy.begin(), ch_energy.end(), 0.0, std::plus {},
                    [mean](double val) { return (val - mean) * (val - mean); });
                channel_result.variance = var_sum / static_cast<double>(ch_energy.size());
            }
 
            const size_t data_size = (ch < original_data.size()) ? original_data[ch].size() : 0;
            channel_result.window_positions.reserve(ch_energy.size());
 
            for (size_t i = 0; i < ch_energy.size(); ++i) {
                const size_t start = i * m_hop_size;
                const size_t end = std::min(start + m_window_size, data_size);
                channel_result.window_positions.emplace_back(start, end);
            }
 
            if (ch < original_data.size()) {
                switch (m_method) {
                case EnergyMethod::ZERO_CROSSING:
                    channel_result.event_positions = Kinesis::Discrete::zero_crossing_positions(
                        original_data[ch], 0.0);
                    break;
 
                case EnergyMethod::PEAK: {
                    double peak_threshold = m_classification_enabled ? m_quiet_threshold : 0.01;
                    channel_result.event_positions = Kinesis::Discrete::peak_positions(
                        original_data[ch], peak_threshold, m_hop_size / 4);
                    break;
                }
 
                case EnergyMethod::RMS:
                case EnergyMethod::POWER:
                case EnergyMethod::SPECTRAL:
                case EnergyMethod::HARMONIC:
                case EnergyMethod::DYNAMIC_RANGE:
                default:
                    // event_positions remains empty
                    break;
                }
            }
 
            if (m_classification_enabled) {
                channel_result.classifications.reserve(ch_energy.size());
                channel_result.level_counts.fill(0);
 
                for (double energy : ch_energy) {
                    EnergyLevel level = classify_energy_level(energy);
                    channel_result.classifications.push_back(level);
                    channel_result.level_counts[static_cast<size_t>(level)]++;
                }
            }
        }
 
        return result;
    }

References MayaFlux::Yantra::EnergyAnalysis::channels, MayaFlux::Yantra::EnergyAnalysis::hop_size, MayaFlux::mean(), MayaFlux::Yantra::EnergyAnalysis::method_used, and MayaFlux::Yantra::EnergyAnalysis::window_size.

Here is the call graph for this function: