low_frequency_energy()

std::vector< double > MayaFlux::Kinesis::Discrete::low_frequency_energy	(	std::span< const double >	data,
		size_t	n_windows,
		uint32_t	hop_size,
		uint32_t	window_size,
		double	low_bin_fraction = 0.125
	)

Low-frequency spectral energy per window.

Computes energy in the lowest (low_bin_fraction * N/2) bins of the magnitude spectrum. Defaults to the bottom eighth of the spectrum.

Note

Eigen::FFT dependency — not portable to compute shader contexts.

Parameters

data	Input span
n_windows	Pre-computed window count from num_windows()
hop_size	Samples between window starts
window_size	Samples per window
low_bin_fraction	Fraction of positive-frequency bins to include (default: 0.125)

Returns

Per-window low-frequency energy values

Definition at line 164 of file Analysis.cpp.

{
    std::vector<double> out(n_windows);
    std::vector<size_t> idx(n_windows);
    std::iota(idx.begin(), idx.end(), 0);
 
    const Eigen::VectorXd hw = hann_window(window_size);
    const int low_bins = std::max(1, static_cast<int>(static_cast<double>((double)window_size / 2) * low_bin_fraction));
 
    Parallel::for_each(Parallel::par_unseq, idx.begin(), idx.end(),
        [&](size_t i) {
            const size_t start = i * hop_size;
            auto w = data.subspan(start, std::min<size_t>(window_size, data.size() - start));
 
            Eigen::VectorXd buf = Eigen::VectorXd::Zero(window_size);
            for (size_t j = 0; j < w.size(); ++j)
                buf(static_cast<Eigen::Index>(j)) = w[j] * hw(static_cast<Eigen::Index>(j));
 
            Eigen::FFT<double> fft;
            Eigen::VectorXcd spec;
            fft.fwd(spec, buf);
 
            double e = 0.0;
            for (int j = 1; j < low_bins; ++j)
                e += std::norm(spec(j));
 
            out[i] = e / static_cast<double>(low_bins);
        });
 
    return out;
}

References low_frequency_energy().

Referenced by low_frequency_energy().

Here is the call graph for this function:

Here is the caller graph for this function: