SlopEnvelopeOnsetdetection.cpp

Go to the documentation of this file.

namespace krotos
{
    EnvelopeFollowerSPD::EnvelopeFollowerSPD(float sampleRate)
    {
        jassert(sampleRate > 0.0f);
 
        m_sampleRate = sampleRate;
        setupEnvFol(2.0f, 250.0f);
    }
 
    void EnvelopeFollowerSPD::setupEnvFol(float attackTimeMs, float releaseTimeMs)
    {
        jassert(attackTimeMs > 0 && releaseTimeMs > 0);
 
        m_attackTimeSec = attackTimeMs * powf(10.0f, -3.0f);
        m_releaseTimeSec = releaseTimeMs * powf(10.0f, -3.0f);
 
        m_gAtt = 1.0f - expf(-1.0f / (m_attackTimeSec * m_sampleRate));
        m_gRel = 1.0f - expf(-1.0f / (m_releaseTimeSec * m_sampleRate));
    }
 
    void EnvelopeFollowerSPD::setAttackMs(float attackTimeMs)
    {
        jassert(attackTimeMs > 0);
        setupEnvFol(attackTimeMs, m_releaseTimeSec);
    }
 
    void EnvelopeFollowerSPD::setReleaseMs(float releaseTimeMs)
    {
        jassert(releaseTimeMs > 0);
        setupEnvFol(m_attackTimeSec, releaseTimeMs);
    }
 
    std::vector<float> EnvelopeFollowerSPD::filterVector(std::vector<float> inputMonoVector)
    {
        int numSamples = static_cast<int>(inputMonoVector.size());
        std::vector<float> envelope(numSamples, 0.0f);
 
        for (int i = 1; i < numSamples; i++)
        {
            float inputSample = fabsf(inputMonoVector.at(i));
 
            // We are in the attack Phase
            if (inputSample > fabsf(inputMonoVector.at(i - 1)))
            {
                envelope.at(i) = envelope.at(i - 1) * (1.0f - m_gAtt) + (m_gAtt * inputSample);
            }
            else // We are in release phase
            {
                envelope.at(i) = envelope.at(i - 1) * (1.0f - m_gRel) + (m_gRel * inputSample);
            }
        }
 
        return envelope;
    }
 
    std::vector<float> EnvelopeFollowerSPD::normaliseEnvelope(std::vector<float> envelope)
    {
        float min = *min_element(envelope.begin(), envelope.end());
        float max = *max_element(envelope.begin(), envelope.end());
 
        // Normalize envelope Array
        for (int i = 0; i < envelope.size(); i++)
        {
            envelope.at(i) = (jmap(envelope.at(i), min, max, 0.0f, 1.0f));
        }
 
        // if it hits something went wrong in the normalisation process
        jassert(*max_element(envelope.begin(), envelope.end()) <= 1.0f);
        jassert(*min_element(envelope.begin(), envelope.end()) >= 0.0f);
 
        return envelope;
    }
 
    //-----------------------------------------------------------------------------------------------------------------------------
    std::vector<float> SlopeGenerator::createSlopeVectorFromEnvelope(std::vector<float> envelopeArray)
    {
        int numSamples = static_cast<int>(envelopeArray.size());
 
        jassert(numSamples > 4);
        jassert(m_numRegressionPoints > 0);
 
        // number of linear Regression frames
        int numRegFrames = numSamples - m_numRegressionPoints + 1;
 
        std::vector<float> slopeArray(numRegFrames, 0.0f);
 
        float numer{0.0f};
        float denom{0.0f};
        float tMean{0.0f};
        float envMean{0.0f};
 
        std::vector<float> timeLocal(4);
 
        for (int i = 0; i < numRegFrames; i++)
        {
            // local time frame vector
            iota(timeLocal.begin(), timeLocal.end(), static_cast<float>(i + 1));
            // calculate moving  time frame mean
            tMean = accumulate(timeLocal.begin(), timeLocal.end(), 0.0f) / m_numRegressionPoints;
            jassert(tMean != 0);
 
            // local envelope frame vector
            std::vector<float>::const_iterator envFirst = envelopeArray.begin() + i;
            std::vector<float>::const_iterator envLast = envelopeArray.begin() + i + 4;
            std::vector<float> envLocal(envFirst, envLast);
            // calculate moving envelope frame mean
            envMean = accumulate(envLocal.begin(), envLocal.end(), 0.0f) / m_numRegressionPoints;
 
            // Apply least squares error criterion
            // ΤΟDO: Localise to C++, starting from 0 - m_numRegressionPoints
            for (int n = 1; n < m_numRegressionPoints + 1; n++)
            {
                numer += (timeLocal.at(n - 1) - tMean) * (envLocal.at(n - 1) - envMean);
                denom += powf(timeLocal.at(n - 1) - tMean, 2.0f) + 1e-10f;
                jassert(denom != 0.0f);
            }
 
            // Store value in slope Array
            slopeArray.at(i) = (numer / denom);
 
            numer = 0.0f;
            denom = 0.0f;
        }
 
        return slopeArray;
    }
 
    //-----------------------------------------------------------------------------------------------------------------------------
    OnsetDetector::OnsetDetector(float sampleRate) { m_sampleRate = sampleRate; }
 
    void OnsetDetector::setThresholdPercentage(float thresholdPercentage) { m_threshold = thresholdPercentage; }
 
    void OnsetDetector::setOnsetMiliSeconds(float onsetMiliSec)
    {
        jassert(m_sampleRate > 0);
        m_onset = static_cast<int>(onsetMiliSec * m_sampleRate);
    }
 
    void OnsetDetector::setDecayLengthMiliSeconds(float decayLengthMiliSec)
    {
        jassert(m_sampleRate > 0);
        m_decayLength = static_cast<int>(decayLengthMiliSec * m_sampleRate);
    }
 
    std::vector<int> OnsetDetector::calculateOnsetsGlobal(std::vector<float> slopeVector,
                                                          std::vector<float> normalisedEnvelopeVector)
    {
        // You have not set the parameters if this hits, call setters before calling
        // this function !!
        jassert(m_threshold != 0.f);
        jassert(m_decayLength != 0);
        jassert(m_onset != 0);
 
        // Calculate maximum Value of SlopeArray to set onset detection threshold
        float maxSlope = *max_element(slopeVector.begin(), slopeVector.end());
 
        float thresholdValue = m_threshold * maxSlope;
 
        int finishPosition = 0;
        int startPosition = 0;
        std::vector<int> attackPositions;
 
        while (finishPosition < slopeVector.size())
        {
            startPosition = finishPosition + 1;
 
            // local slope array vector
            std::vector<float>::const_iterator slopeFirst = slopeVector.begin() + startPosition;
            std::vector<float>::const_iterator slopeLast = slopeVector.end();
            std::vector<float> slopeLocal(slopeFirst, slopeLast);
 
            // local normalised envelope array vector
            std::vector<float>::const_iterator envNormFirst = normalisedEnvelopeVector.begin() + startPosition;
            std::vector<float>::const_iterator envNormLast = normalisedEnvelopeVector.end();
            std::vector<float> envNormLocal(envNormFirst, envNormLast);
 
            // Call function
            std::pair<int, int> attackFinishPair = detectAttackSegment(slopeLocal, envNormLocal, thresholdValue);
 
            if (m_finishFlag == true)
            {
                break;
            }
 
            attackPositions.push_back(attackFinishPair.first + finishPosition);
 
            finishPosition += attackFinishPair.second;
        }
 
        return attackPositions;
    }
 
    std::pair<int, int> OnsetDetector::detectAttackSegment(const std::vector<float>& slopeFrame,
                                                           const std::vector<float>& normalisedEnvelopeFrame,
                                                           float thresholdValue)
    {
        std::pair<int, int> attackFinishPair;
 
        // Find first Attack position in the local Slope array vector
        auto iter =
                find_if(slopeFrame.begin(), slopeFrame.end(), [=](float x) { return (fabsf(x) >= thresholdValue); });
        auto firstAttackPosition = static_cast<int>((distance(slopeFrame.begin(), iter)));
 
        attackFinishPair.first = firstAttackPosition;
 
        // We did not find any attacks, terminate
        if (firstAttackPosition == slopeFrame.size())
        {
            m_finishFlag = true;
            return attackFinishPair;
        }
        else
        {
            // Skip ahead by OnsetSamples and search for local maximum
            int localMaxPosition = -1;
            for (int i = firstAttackPosition + m_onset + 2; i < slopeFrame.size(); i++)
            {
                // check for local max
                if (slopeFrame.at(i - 1) > m_epsilon && slopeFrame.at(i) < -m_epsilon)
                {
                    localMaxPosition = i - 1;
                    break;
                }
            }
 
            // No local maximum, return attackPosition and terminate
            if (localMaxPosition == -1)
            {
                m_finishFlag = true;
                return attackFinishPair;
            }
 
            // Progress through data from local max to check if moving average power
            // hits noise floor
            bool rest = false;
 
            // number of frames to check
            int numRestFrames = static_cast<int>(
                    floorf(static_cast<float>(normalisedEnvelopeFrame.size() - localMaxPosition) / m_decayLength));
            // counter for while loop
            int n = 0;
            int start = 0;
            int finish = 0;
 
            while (n < (numRestFrames - 1) && rest == false)
            {
                start = localMaxPosition + (n * m_decayLength);
                finish = start + m_decayLength - 1;
 
                std::vector<float>::const_iterator envSegmentFirst = normalisedEnvelopeFrame.begin() + start;
                std::vector<float>::const_iterator envSegmentLast = normalisedEnvelopeFrame.begin() + finish;
                std::vector<float> decayRegionEnv(envSegmentFirst, envSegmentLast);
 
                // calculate average power of signal in that region
                transform(decayRegionEnv.begin(), decayRegionEnv.end(), decayRegionEnv.begin(),
                          [](float x) -> float { return x * x; });
                float movAvgPow = (accumulate(decayRegionEnv.begin(), decayRegionEnv.end(), 0.0f)) / m_decayLength;
 
                // if we find new rest segment return last position and attackposition and
                // terminate
                if (movAvgPow < 0.01f * normalisedEnvelopeFrame.at(localMaxPosition))
                {
                    rest = true;
                }
 
                n += 1;
            }
 
            attackFinishPair.second = finish;
 
            return attackFinishPair;
        }
    }
 
} // namespace krotos