KisFilteredRollingMean Class Reference

#include <KisFilteredRollingMean.h>

Public Member Functions
void	addValue (qreal value)
qreal	filteredMean () const
bool	isEmpty () const
	KisFilteredRollingMean (int windowSize, qreal effectivePortion)

Private Attributes
std::vector< qreal >	m_cutOffBuffer
qreal	m_effectivePortion
qreal	m_rollingSum
boost::circular_buffer< qreal >	m_values

Detailed Description

A special class that calculates a rolling mean of the values stream, but filtering out random extreme deviations.

On each step the algorithm sorts the entire sampling window and drops a small portion of the lowest and the highest values. The rest of the values are used to calculate the mean of the window.

Basically, it takes the median and a few surrounding values to calculate the mean.

PS: The actually implementation does a few optimizations. For example, it doesn't sort the entire range. But the idea is the same.

Definition at line 33 of file KisFilteredRollingMean.h.

Constructor & Destructor Documentation

KisFilteredRollingMean()

KisFilteredRollingMean::KisFilteredRollingMean	(	int	windowSize,
		qreal	effectivePortion )

Creates a mean accumulator

windowSize is the size of the samples window effectivePortion the portion of the samples window that is used for actual mean calculation. On each side of the sorted range (0.5 * (1.0 - effectivePortion) * windowSize) values are dropped and are not counted for the mean calculation.

Definition at line 16 of file KisFilteredRollingMean.cpp.

    : m_values(windowSize),
      m_rollingSum(0.0),
      m_effectivePortion(effectivePortion),
      m_cutOffBuffer(qCeil(0.5 * (qCeil(windowSize * (1.0 - effectivePortion)))))
{
}

Member Function Documentation

addValue()

void KisFilteredRollingMean::addValue

(

qreal

value

)

Adds a value for the rolling mean calculation. The complexity of the call is O(1).

Definition at line 24 of file KisFilteredRollingMean.cpp.

{
    if (m_values.full()) {
        m_rollingSum -= m_values.front();
    }
 
    m_values.push_back(value);
    m_rollingSum += value;
}

References m_rollingSum, m_values, and value().

filteredMean()

qreal KisFilteredRollingMean::filteredMean

(

)

const

Calculates the filtered mean value of the current range. The function is slow, its complexity is O(N) + O(N*log(M)), where N is the size of the rolling window, M is the number of elements dropped from the window (1.0 - effectivePortion) * windowSize).

Definition at line 34 of file KisFilteredRollingMean.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_values.empty(), 0.0);
 
    const int usefulElements = qMax(1, qRound(m_effectivePortion * m_values.size()));
 
    qreal sum = 0.0;
    int num = 0;
 
    const int cutOffTotal = m_values.size() - usefulElements;
 
    if (cutOffTotal > 0) {
        const std::vector<double>::size_type cutMin = qRound(0.5 * cutOffTotal);
        const std::vector<double>::size_type cutMax = cutOffTotal - cutMin;
 
        KIS_SAFE_ASSERT_RECOVER(cutMin <= m_cutOffBuffer.size()) {
            m_cutOffBuffer.resize(cutMin);
        }
        KIS_SAFE_ASSERT_RECOVER(cutMax <= m_cutOffBuffer.size()) {
            m_cutOffBuffer.resize(cutMax);
        }
 
        sum = m_rollingSum;
        num = usefulElements;
 
        std::partial_sort_copy(m_values.begin(),
                               m_values.end(),
                               m_cutOffBuffer.begin(),
                               m_cutOffBuffer.begin() + cutMin);
 
        sum -= std::accumulate(m_cutOffBuffer.begin(),
                               m_cutOffBuffer.begin() + cutMin,
                               0.0);
 
        std::partial_sort_copy(m_values.begin(),
                               m_values.end(),
                               m_cutOffBuffer.begin(),
                               m_cutOffBuffer.begin() + cutMax,
                               std::greater<qreal>());
 
        sum -= std::accumulate(m_cutOffBuffer.begin(),
                               m_cutOffBuffer.begin() + cutMax,
                               0.0);
    } else {
        sum = m_rollingSum;
        num = m_values.size();
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(num > 0, 0.0);
 
    return sum / num;
}

References KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_cutOffBuffer, m_effectivePortion, m_rollingSum, and m_values.

isEmpty()

bool KisFilteredRollingMean::isEmpty

(

)

const

Returns true if the accumulator has at least some value

Definition at line 87 of file KisFilteredRollingMean.cpp.

{
    return m_values.empty();
}

References m_values.

Member Data Documentation

m_cutOffBuffer

std::vector<qreal> KisFilteredRollingMean::m_cutOffBuffer

mutableprivate

Definition at line 72 of file KisFilteredRollingMean.h.

m_effectivePortion

qreal KisFilteredRollingMean::m_effectivePortion

private

Definition at line 71 of file KisFilteredRollingMean.h.

m_rollingSum

qreal KisFilteredRollingMean::m_rollingSum

private

Definition at line 70 of file KisFilteredRollingMean.h.

m_values

boost::circular_buffer<qreal> KisFilteredRollingMean::m_values

private

Definition at line 69 of file KisFilteredRollingMean.h.

---

The documentation for this class was generated from the following files:

• libs/global/KisFilteredRollingMean.h
• libs/global/KisFilteredRollingMean.cpp