|| || || || || || || ||

---

Classifier.h

Go to the documentation of this file.

#ifndef Impala_Core_Tracking_Classifier_h
#define Impala_Core_Tracking_Classifier_h

#include "Core/Array/Arrays.h"
#include "Core/Matrix/MatCovariance.h"
#include "Core/Matrix/MatInverse.h"
#include "Core/Matrix/MatMul.h"
#include "Core/Array/MulVal.h"
#include "Core/Array/Sub.h"
#include "Core/Array/Add.h"

namespace Impala
{
namespace Core
{
namespace Tracking
{

double Trace(const Array::Array2dScalarReal64* matrix)
{
    // compute trace;
    const double* src = matrix->CPB();
    double trace = 0;
    int i;
    for(i=0 ; i<matrix->CW()*matrix->CH() ; i++)
    {
        trace += src[i];
    }
    return trace;
}

/**************************************************************
 * WARNING: this class assumes that all vectors have the same *
 *          dimensionality as declared in the constructor.    *
 **************************************************************/
class Classifier
{
public:
    Classifier(int size, int dimensionslity)
        :mDimensionality(dimensionslity)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mSize = size;
        mGamma = options.GetDouble("fore_back.classifier.gamma", 0.05);
        mLambdaFactor = options.GetDouble("fore_back.classifier.lambdafactor", 0.004);
        mObjectVectors = new Array::Array2dScalarReal64(mDimensionality, size, 0, 0);
        mClassifiers = new Array::Array2dScalarReal64(mDimensionality, size, 0, 0);
        mBackgroundMean = new Array::Array2dScalarReal64(mDimensionality, 1, 0, 0);
        mMatCovariance = new Array::Array2dScalarReal64(mDimensionality, mDimensionality, 0, 0);
    }

    virtual ~Classifier()
    {
        delete mObjectVectors;
        delete mClassifiers;
        delete mBackgroundMean;
        delete mMatCovariance;
    }
    
    void SetVec(const Array::Array2dScalarReal64& v, int index)
    {
        if(index >= mSize)
            std::cout << "[Classifier::SetVec] Classifier out of bounds" << std::endl;
        const double* vp = v.CPB(0,0);
        double* op = mObjectVectors->CPB(0,index);
        memcpy(op, vp, mDimensionality*sizeof(double));
    }

    void UpdateVec(const Array::Array2dScalarReal64& v, int index)
    {
        if(index >= mSize)
            std::cout << "[Classifier::UpdateVec] Classifier out of bounds" << std::endl;
        const double* vp = v.CPB(0,0);
        double* op = mObjectVectors->CPB(0,index);
        for(int i=0 ; i<mDimensionality ; i++)
        {
            op[i] = op[i] * (1.0-mGamma) + vp[i] * mGamma;
        }
    }

    void GetVector(int index, Array::Array2dScalarReal64& v)
    {
        double* vp = v.CPB(0, 0);
        double* op = mObjectVectors->CPB(0, index);
        memcpy(vp, op, mDimensionality*sizeof(double));
    }

    void GetClassifiers(int index, Array::Array2dScalarReal64& v)
    {
        double* vp = v.CPB(0, 0);
        double* op = mClassifiers->CPB(0, index);
        memcpy(vp, op, mDimensionality*sizeof(double));
    }

    void SetBackground(Array::Array2dScalarReal64& background)
    {
        delete mMatCovariance;
        mMatCovariance = Matrix::MatCovarianceExact(&background);
        MeanFromSamples(mBackgroundMean, &background);
        UpdateClassifiers();
    }

    void Update(Array::Array2dScalarReal64& background)
    {
        UpdateBackGroundModel(background);
        UpdateClassifiers();
    }

    void WriteSimpleDebug(std::ostream& stream)
    {
        stream << "[Classifier::WriteDebug]\n  background";
        for(int i=0 ; i<mBackgroundMean->CW() ; i++)
            stream << " " << mBackgroundMean->Val(i,0);
        stream << "\n  object vectors";
        for(int i=0 ; i<mObjectVectors->CH() ; i++)
        {
            stream << "\n  ";
            for(int j=0 ; j<mObjectVectors->CW() ; j++)
                stream << " " << mObjectVectors->Val(i,j);
        }
    }

    void WriteDebug(std::ostream& stream)
    {
        WriteSimpleDebug(stream);
        stream << "\n  covariance matrix";
        for(int i=0 ; i<mMatCovariance->CH() ; i++)
        {
            stream << "\n  ";
            for(int j=0 ; j<mMatCovariance->CW() ; j++)
                stream << " " << mMatCovariance->Val(i,j);
        }
        stream << std::endl;
    }


private:
    double mGamma;
    double mLambdaFactor;
    int mSize;
    int mDimensionality;

    Array::Array2dScalarReal64* mMatCovariance;
    Array::Array2dScalarReal64* mBackgroundMean;
    Array::Array2dScalarReal64* mObjectVectors;
    Array::Array2dScalarReal64* mClassifiers;

    void UpdateBackGroundModel(Array::Array2dScalarReal64& background)
    {
        // update covariance matrix (eq.19)
        Array::Array2dScalarReal64* temp = new Array::Array2dScalarReal64(mDimensionality, mDimensionality, 0, 0);
        MulVal(mMatCovariance, mMatCovariance, 1.-mGamma);
        MultiplyWithTranspose(temp, mBackgroundMean);
        AddMatrixWeighted(mMatCovariance, temp, 1.-mGamma);
        // update average fb (eq.18)
        MulVal(mBackgroundMean, mBackgroundMean, 1.-mGamma);
        Array::Array2dScalarReal64* mean = new Array::Array2dScalarReal64(mDimensionality, 1, 0, 0);
        MeanFromSamples(mean, &background);
        AddMatrixWeighted(mBackgroundMean, mean, mGamma);
        delete mean;
        // continue eq.19
        MultiplyWithTranspose(temp, mBackgroundMean);
        Sub(mMatCovariance, mMatCovariance, temp);
        SommateTransposeMultiplications(temp, &background);
        AddMatrixWeighted(mMatCovariance, temp, mGamma);
        delete temp;
    }

    void UpdateClassifiers()
    {
        // update classifiers (eq.13)
        // first compute [lambda*I + B]^-1
        Array::Array2dScalarReal64* temp = new Array::Array2dScalarReal64(mDimensionality, mDimensionality, 0, 0);
        AddLambdaDiagonal(temp, mMatCovariance);
        Array::Array2dScalarReal64* Binverse = Matrix::MatInverse(temp);
        if(Binverse)
        {
            for(int i=0 ; i<mObjectVectors->CH() ; i++)
            {
                // the term [f_o_i - f_b_avrg] occures multiple times we'll call it vector
                Array::Array2dScalarReal64* vector = new Array::Array2dScalarReal64(1, mDimensionality, 0, 0);
                GetNormalisedObjectVector(vector,i);
                // the term [lambda*I + B]^-1 * [f_o_i - f_b_avrg] also reoccures, we'll call it correlatedVector
                Array::Array2dScalarReal64* correlatedVector = Matrix::MatMul(Binverse, vector);
                double k_i = CrossProduct(vector, correlatedVector);
                k_i = 2. / (2.+k_i);
                SetClassifier(i, k_i, correlatedVector);
                delete correlatedVector;
                delete vector;
            }
            delete Binverse;
        }
        delete temp;
    }


    void MultiplyWithTranspose(Array::Array2dScalarReal64*& matrix, const Array::Array2dScalarReal64* vector)
    {
        const double* vec = vector->CPB();
        MultiplyWithTranspose(matrix, vec);
    }

    void MultiplyWithTranspose(Array::Array2dScalarReal64*& matrix, const double* vec)
    {
        for(int i=0 ; i<matrix->CH() ; i++)
        {
            double* dst = matrix->CPB(0, i);
            for(int j=0 ; j<matrix->CW() ; j++)
                dst[j] = vec[i]*vec[j];
        }
    }

    void AddMatrixWeighted(Array::Array2dScalarReal64*& matrix, const Array::Array2dScalarReal64* addmatrix, double weight)
    {
        double* dst = matrix->CPB();
        const double* src = addmatrix->CPB();
        for(int i=0 ; i<matrix->CW()*matrix->CH() ; i++)
        {
            dst[i] += src[i]*weight;
        }
    }

    void MeanFromSamples(Array::Array2dScalarReal64*& mean, const Array::Array2dScalarReal64* samples)
    {
        double* dst = mean->CPB();
        int i;
        for(i=0 ; i<samples->CW() ; i++)
            dst[i] = 0;
        for(i=0 ; i<samples->CH() ; i++)
        {
            const double* src = samples->CPB(0, i);
            for(int j=0 ; j<samples->CW() ; j++)
                dst[j] += src[j];
        }
        for(i=0 ; i<samples->CW() ; i++)
            dst[i] /= samples->CH();
    }

    void SommateTransposeMultiplications(Array::Array2dScalarReal64*& matrix, const Array::Array2dScalarReal64* samples)
    {
        double* dst = matrix->CPB();
        int i;
        for(i=0 ; i<matrix->CW()*matrix->CH() ; i++)
            dst[i] = 0;

        Array::Array2dScalarReal64* temp = new Array::Array2dScalarReal64(mDimensionality, mDimensionality, 0, 0);
        for(i=0 ; i<samples->CH() ; i++)
        {
            const double* sample = samples->CPB(0,i);
            MultiplyWithTranspose(temp, sample);
            Array::Add(matrix, matrix, temp);
        }
        delete temp;
        for(i=0 ; i<matrix->CH()*matrix->CH() ; i++)
            dst[i] /= (double)samples->CH();
    }

    void AddLambdaDiagonal(Array::Array2dScalarReal64*& matrixDst, const Array::Array2dScalarReal64* matrixSrc)
    {
        // add portion of trace
        double trace = Trace(matrixSrc) * mLambdaFactor;
        int i;
        for(i=0 ; i<matrixDst->CH() ; i++)
        {
            double* dst = matrixDst->CPB(0, i);
            const double* src = matrixSrc->CPB(0, i);
            for(int j=0 ; j<matrixDst->CW() ; j++)
            {
                dst[j] = src[j];
                if(i==j)
                    dst[j] += trace;
            }
        }
    }

    void GetNormalisedObjectVector(Array::Array2dScalarReal64*& vector, int index)
    {
        const double* object = mObjectVectors->CPB(0, index);
        const double* backMean = mBackgroundMean->CPB();
        double* dst = vector->CPB();
        for(int i=0 ; i<mDimensionality ; i++)
        {
            dst[i] = object[i] - backMean[i];
        }
    }

    double CrossProduct(const Array::Array2dScalarReal64* vector1, const Array::Array2dScalarReal64* vector2)
    {
        const double* src1 = vector1->CPB();
        const double* src2 = vector1->CPB();
        double dst = 0;
        for(int i=0 ; i<mDimensionality ; i++)
        {
            dst += src1[i] * src2[i];
        }
        return dst;
    }

    void SetClassifier(int index, double k_i, const Array::Array2dScalarReal64* correlatedVector)
    {
        const double* src = correlatedVector->CPB();
        double* dst = mClassifiers->CPB(0,index);
        for(int i=0 ; i<mDimensionality ; i++)
        {
            dst[i] = src[i] * k_i;
        }
    }

};

} // namespace Tracking
} // namespace Core
} // namespace Impala

#endif //Impala_Core_Tracking_Classifier_h

---