onset_positions()

std::vector< size_t > MayaFlux::Kinesis::Discrete::onset_positions	(	std::span< const double >	data,
		uint32_t	window_size,
		uint32_t	hop_size,
		double	threshold = 0.1
	)

Sample indices of onsets detected via spectral flux.

Onset positions are local maxima of the half-wave-rectified spectral flux curve that exceed the normalised threshold. Sequential processing is required — this function is not parallelisable.

Note

Eigen::FFT dependency. Produces sparse output. Not suitable for compute shader contexts.

Parameters

data	Input span
window_size	FFT window size in samples
hop_size	Hop size between successive FFT frames
threshold	Normalised flux threshold in [0, 1] (default: 0.1)

Returns

Sorted sample indices of detected onsets

Definition at line 670 of file Analysis.cpp.

{
    const size_t nw = num_windows(data.size(), window_size, hop_size);
    if (nw < 2)
        return {};
 
    const Eigen::VectorXd hw = hann_window(window_size);
    std::vector<double> flux(nw - 1, 0.0);
    Eigen::VectorXcd prev_spec;
 
    for (size_t i = 0; i < nw; ++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);
 
        if (i > 0) {
            double f = 0.0;
            for (Eigen::Index j = 0; j < spec.size(); ++j) {
                const double diff = std::abs(spec(j)) - std::abs(prev_spec(j));
                if (diff > 0.0)
                    f += diff;
            }
            flux[i - 1] = f;
        }
        prev_spec = spec;
    }
 
    const double mx = *std::ranges::max_element(flux);
    if (mx > 0.0) {
        for (double& f : flux) {
            f /= mx;
        }
    }
 
    std::vector<size_t> pos;
    for (size_t i = 1; i + 1 < flux.size(); ++i) {
        if (flux[i] > threshold && flux[i] > flux[i - 1] && flux[i] >= flux[i + 1])
            pos.push_back((i + 1) * hop_size);
    }
 
    return pos;
}

References num_windows(), and onset_positions().

Referenced by MayaFlux::detect_onsets(), MayaFlux::detect_onsets(), MayaFlux::detect_onsets_per_channel(), MayaFlux::Yantra::extract_onsets(), and onset_positions().

Here is the call graph for this function:

Here is the caller graph for this function: