SuperFluxOnsetDetection.cpp

Go to the documentation of this file.

namespace krotos
{
    SuperFluxOnsetDetection::SuperFluxOnsetDetection(std::vector<std::vector<float>>& logSpectrum, float sampleRate,
                                                     int hopSize)
    {
        m_sampleRate = sampleRate;
        m_hopSize = hopSize;
        m_inputLogSpectrum = logSpectrum;
        setParametersMS(30e-3f, 30e-3f, 100e-3f, 70e-3f, 30e-3f);
    }
 
    void SuperFluxOnsetDetection::setParametersMS(float preMax, float postMax, float preAvg, float postAvg,
                                                  float combWidth)
    {
        jassert(m_sampleRate > 0 && m_hopSize > 0);
 
        // Convert to number of samples from milisec
        m_preMaxFrames = std::lround(preMax * m_sampleRate / static_cast<float>(m_hopSize));
        m_postMaxFrames = std::lround(postMax * m_sampleRate / static_cast<float>(m_hopSize));
        m_preAvgFrames = std::lround(preAvg * m_sampleRate / static_cast<float>(m_hopSize));
        m_postAvgFrames = std::lround(postAvg * m_sampleRate / static_cast<float>(m_hopSize));
        m_combWidthFrames = std::lround(combWidth * m_sampleRate / static_cast<float>(m_hopSize));
    }
 
    void SuperFluxOnsetDetection::setDeltaPercentage(float deltaPrcnt) { m_deltaPrcnt = deltaPrcnt; }
 
    std::vector<float> SuperFluxOnsetDetection::trajectoryTracking(std::vector<std::vector<float>> logSpectrum)
    {
        // Apply maximum Filter of length 3
        m_numBands = static_cast<int>(logSpectrum.size());
        m_numFrames = static_cast<int>(logSpectrum[0].size());
 
        // Widen the spectro in freq dimension by reflecting beginning and end
        // beginning
        logSpectrum.insert(std::begin(logSpectrum), logSpectrum.at(1));
        // end
        logSpectrum.insert(std::end(logSpectrum), std::end(logSpectrum)[-2]);
 
        // Maximum Filtered Spectrogram
        std::vector<float> maxLogSpectrum(m_numBands * m_numFrames);
 
        for (int j = 0; j < m_numFrames; j++)
        {
            for (int i = 0; i < m_numBands; i++)
            {
                std::vector<float> subVec = {logSpectrum[i][j], logSpectrum[i + 1][j], logSpectrum[i + 2][j]};
                // Apply max filter
                float max = *std::max_element(std::begin(subVec), std::end(subVec));
                maxLogSpectrum[i * m_numFrames + j] = max;
            }
        }
 
        return maxLogSpectrum;
    }
 
    std::vector<float> SuperFluxOnsetDetection::calculateDetectionFunction(
            const std::vector<std::vector<float>>& logSpectrum, const std::vector<float>& maxLogSpectum)
    {
        float diffFlat = 0.0f;
        // Detection function Vector
        std::vector<float> detectionFunctionFlat(m_numFrames);
        // Calculate difference for each band per frame
        for (int j = mi; j < m_numFrames; j++)
        {
            for (int i = 0; i < m_numBands; i++)
            {
                diffFlat += halfWaveRect(logSpectrum[i][j] - maxLogSpectum[i * m_numFrames + (j - mi)]);
            }
 
            detectionFunctionFlat[j] = diffFlat;
            diffFlat = 0.0f;
        }
 
        return detectionFunctionFlat;
    }
 
    std::vector<int> SuperFluxOnsetDetection::peakPicking(std::vector<float> detectionFunction)
    {
        size_t detectionSize = detectionFunction.size();
 
        // Moving maximum vector calculation
        auto movingMaxVec = movingMax(detectionFunction);
 
        // Moving average vector calculation
        auto movingMeanVec = movingMean(detectionFunction);
 
        // if this hits something went wrong, probably weird parameters!!!
        jassert(movingMaxVec.size() == detectionSize && movingMeanVec.size() == detectionSize);
 
        // Set delta
        float maxDetect = *std::max_element(std::begin(detectionFunction), std::end(detectionFunction));
        float minDetect = *std::min_element(std::begin(detectionFunction), std::end(detectionFunction));
        float delta = m_deltaPrcnt * ((maxDetect - minDetect) / 2.0f);
 
        // Find positions of max > mean + delta
        std::vector<int> allOnsets;
        for (int i = 0; i < detectionSize; i++)
        {
            // peak picking condition
            if (movingMaxVec[i] >= movingMeanVec[i] + delta)
            {
                allOnsets.push_back(i);
            }
        }
 
        // Caclulate differences in positions between all onset frames
        std::vector<int> onsetPositions;
        //       adjacent_difference(allOnsets.std::begin(), allOnsets.std::end(),
        //       differences.std::begin());
 
        for (int i = 1; i < allOnsets.size(); i++)
        {
            // Keep only positions that are distanced more than combWidth
            if (allOnsets[i] - allOnsets[i - 1] > m_combWidthFrames)
            {
                onsetPositions.push_back(allOnsets[i] * m_hopSize);
            }
        }
 
        // Add 1st onsetFrame
        onsetPositions.insert(std::begin(onsetPositions), allOnsets[1] * m_hopSize);
        // Add 1st sample
        onsetPositions.insert(std::begin(onsetPositions), 0);
 
        return onsetPositions;
    }
 
    std::vector<float> SuperFluxOnsetDetection::movingMax(std::vector<float> detectionFunction)
    {
        size_t length = detectionFunction.size();
        // Extend the detection function by reflecting beginning and end
 
        // extract beginning subVector
        std::vector<float>::const_iterator first = std::begin(detectionFunction) + 1;
        std::vector<float>::const_iterator last = first + m_preMaxFrames;
        std::vector<float> subVecStart(first, last);
        // reverse it
        std::reverse(std::begin(subVecStart), std::end(subVecStart));
        // concatenate at beginning
        detectionFunction.insert(std::begin(detectionFunction), std::begin(subVecStart), std::end(subVecStart));
 
        // extract end subVector
        first = std::end(detectionFunction) - 1 - m_postMaxFrames;
        last = std::end(detectionFunction) - 1;
        std::vector<float> subVecEnd(first, last);
        // reverse it
        std::reverse(std::begin(subVecEnd), std::end(subVecEnd));
        // concatenate at end
        detectionFunction.insert(std::end(detectionFunction), std::begin(subVecEnd), std::end(subVecEnd));
 
        std::vector<float> movMax(length);
 
        // Iterate through the detect function,calculate the moving max
        for (int i = m_preMaxFrames; i < detectionFunction.size() - m_postMaxFrames; i++)
        {
            // extract subVector
            std::vector<float>::const_iterator start = std::begin(detectionFunction) + i - m_preMaxFrames;
            std::vector<float>::const_iterator finish = start + m_postMaxFrames;
            std::vector<float> subVec(start, finish);
            // maximum
            movMax.at(i - m_preMaxFrames) = *std::max_element(std::begin(subVec), std::end(subVec));
        }
 
        return movMax;
    }
 
    std::vector<float> SuperFluxOnsetDetection::movingMean(std::vector<float> detectionFunction)
    {
        size_t length = detectionFunction.size();
 
        // Extend the detection function by reflecting beginning and end
        // extract beginning subVector
        std::vector<float>::const_iterator first = std::begin(detectionFunction) + 1;
        std::vector<float>::const_iterator last = first + m_preAvgFrames;
        std::vector<float> subVecStart(first, last);
        // reverse it
        std::reverse(std::begin(subVecStart), std::begin(subVecStart));
        // concatenate at beginning
        detectionFunction.insert(std::begin(detectionFunction), std::begin(subVecStart), std::end(subVecStart));
 
        // extract end subVector
        first = std::end(detectionFunction) - 1 - m_postAvgFrames;
        last = std::end(detectionFunction) - 1;
        std::vector<float> subVecEnd(first, last);
        // reverse it
        std::reverse(std::begin(subVecEnd), std::end(subVecEnd));
        // concatenate at end
        detectionFunction.insert(std::end(detectionFunction), std::begin(subVecEnd), std::end(subVecEnd));
 
        std::vector<float> movMean(length);
        float count = static_cast<float>(m_preAvgFrames + m_postAvgFrames + 1);
        // Iterate through the detect function,calculate the moving max
        for (int i = m_preAvgFrames; i < detectionFunction.size() - m_postAvgFrames; i++)
        {
            // extract subVector
            std::vector<float>::const_iterator start = std::begin(detectionFunction) + i - m_preAvgFrames;
            std::vector<float>::const_iterator finish = start + m_postAvgFrames;
            std::vector<float> subVec(start, finish);
            // mean
            movMean.at(i - m_preAvgFrames) = std::accumulate(std::begin(subVec), std::end(subVec), 0.0f) / count;
        }
 
        return movMean;
    }
 
    std::vector<int> SuperFluxOnsetDetection::findOnsetsInSamples()
    {
        auto maxLogSpectrum = trajectoryTracking(m_inputLogSpectrum);
        auto detectionFunction = calculateDetectionFunction(m_inputLogSpectrum, maxLogSpectrum);
        std::vector<int> onsetPositions = peakPicking(detectionFunction);
 
        return onsetPositions;
    }
 
} // namespace krotos