qquick3dparticlesystemlogging.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dparticlesystemlogging_p.h"
#include <float.h> // FLT_MAX
 
QT_BEGIN_NAMESPACE
 
QQuick3DParticleSystemLogging::QQuick3DParticleSystemLogging(QObject *parent)
    : QObject(parent)
{
}
 
int QQuick3DParticleSystemLogging::loggingInterval() const
{
    return m_loggingInterval;
}
 
void QQuick3DParticleSystemLogging::setLoggingInterval(int interval)
{
    if (m_loggingInterval == interval)
        return;
 
    m_loggingInterval = interval;
    Q_EMIT loggingIntervalChanged();
}
 
int QQuick3DParticleSystemLogging::updates() const
{
    return m_updates;
}
 
int QQuick3DParticleSystemLogging::particlesMax() const
{
    return m_particlesMax;
}
 
int QQuick3DParticleSystemLogging::particlesUsed() const
{
    return m_particlesUsed;
}
 
float QQuick3DParticleSystemLogging::time() const
{
    return m_time;
}
 
float QQuick3DParticleSystemLogging::timeAverage() const
{
    return m_timeAverage;
}
 
float QQuick3DParticleSystemLogging::timeDeviation() const
{
    return m_timeDeviation;
}
 
void QQuick3DParticleSystemLogging::updateTimes(qint64 time)
{
    m_time = float(time / 1000000.0) / m_updates;
 
    m_totalTimesList.append(m_time);
 
    // Keep max amount of times stored and remove the oldest values
    const int MAX_TIMES = 100;
    if (m_totalTimesList.size() > MAX_TIMES)
        m_totalTimesList.removeFirst();
 
    auto sortedTimes = m_totalTimesList;
    std::sort(sortedTimes.begin(), sortedTimes.end());
 
    // Calculate average from stored times.
    // Only take into account the middle 50% of the values.
    // This gives us interquartile range (IQR) and the average time among IQR.
    if (sortedTimes.size() > 5) {
        // Skip 25%, count 50%, so maxItem at 75%
        const int skipAmount = roundf(0.25f * float(sortedTimes.size()));
        const int maxItem = sortedTimes.size() - skipAmount;
        int countAmount = 0;
        double totalTime = 0.0;
        float maxTime = 0.0f;
        float minTime = FLT_MAX;
        for (int i = skipAmount; i < maxItem; i++) {
            const float time = sortedTimes.at(i);
            totalTime += time;
            minTime = std::min(minTime, time);
            maxTime = std::max(maxTime, time);
            countAmount++;
        }
        m_timeAverage = float(totalTime / countAmount);
        m_timeDeviation = maxTime - minTime;
        Q_EMIT timeAverageChanged();
        Q_EMIT timeDeviationChanged();
    }
    Q_EMIT timeChanged();
}
 
void QQuick3DParticleSystemLogging::resetData()
{
    m_updates = 0;
    m_particlesMax = 0;
    m_particlesUsed = 0;
    m_time = 0.0f;
    m_timeAverage = 0.0f;
    m_timeDeviation = 0.0f;
    m_totalTimesList.clear();
    Q_EMIT updatesChanged();
    Q_EMIT particlesMaxChanged();
    Q_EMIT particlesUsedChanged();
    Q_EMIT timeChanged();
    Q_EMIT timeAverageChanged();
    Q_EMIT timeDeviationChanged();
}
 
QT_END_NAMESPACE