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

---

Background.h

Go to the documentation of this file.

#ifndef Impala_Visualization_Background_h
#define Impala_Visualization_Background_h

#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/MulVal.h"
#include "Core/Array/MaximumVal.h"
#include "Core/Array/Dilation.h"
#include "Core/Array/GreaterThan.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/ColorSpace.h"
#include "Core/Array/Rgb2Ooo.h"
#include "Core/Array/ProjectRange.h"
#include "Core/Matrix/MatSet.h"
#include "Core/VideoSet/VxsDocument.h"
#include "Core/Database/DataDocumentListener.h"
#include "Visualization/Window.h"
#include "Core/Array/Statistics.h"

namespace Impala
{
namespace Visualization
{


class Background : public Core::Database::DataDocumentListener
{
public:
    typedef Core::Array::Array2dScalarReal64 Array2dScalarReal64;
    typedef Core::Array::Array2dVec3Real64 Array2dVec3Real64;
    typedef Core::Array::Array2dScalarUInt8 Array2dScalarUInt8;
    typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;


    Background(Core::Database::DataDocument* dataDoc, Window* wnd,
               double viewScale)
    {
        mDataDoc = dataDoc;
        mViewScale = viewScale;
        mWnd = wnd;

        mStat = new Core::Array::Statistics<Array2dScalarReal64>(25, false);

        mSigma = 3.0;
        Array2dScalarReal64* g = 0;
        g = Core::Array::MakeGaussIIR1d(mSigma, 0, 3.0);
        mBorderSize = g->CW();
        delete g;

        Reset();
    }

    virtual void
    HandleNewFile()
    {
        HandleNewFrame();
    }

    virtual void
    HandleNewFrame()
    {
        int view = 0;

        Core::Array::ArraySystem& aSys = Core::Array::ArraySystem::Instance();
        aSys.MarkMemoryUsage(false);

        Core::Array::Array2dVec3UInt8* srcWrap = mDataDoc->VisualAtCursor(false);
        if (!srcWrap)
            return;
        Array2dVec3Real64* srcV3R64 = Core::Array::ArrayCreate<Array2dVec3Real64>
            (srcWrap->CW(), srcWrap->CH(), mBorderSize, mBorderSize);

        Array2dScalarReal64* lum = 0;
        Array2dScalarReal64* col = 0;
        Array2dScalarReal64* tmp = 0;

        Core::Array::Rgb2Ooo(srcV3R64, srcWrap);
        //Core::Array::ProjectRange(lum, srcV3R64, 1);
        Core::Array::ProjectRange(col, srcV3R64, 2);
        Core::Array::ProjectRange(tmp, srcV3R64, 3);
        Core::Array::Add(col, col, tmp);

        //Core::Array::RecGauss(lum, lum, mSigma, mSigma, 0, 0, 3);
        Core::Array::RecGauss(col, col, mSigma, mSigma, 0, 0, 3);

        Array2dScalarReal64* crit = col;
        //UpdateView(view++, crit, "Direct", mViewScale);

        mStat->DoArray(crit);

        Array2dScalarReal64* diff = 0;
        Core::Array::Sub(diff, mStat->GetMean(), crit);
        Core::Array::Abs(diff, diff);
        mWnd->UpdateView(view++, diff, "Stretch", mViewScale);

        Array2dScalarUInt8* binIm = 0;
        Array2dScalarReal64* thr = 0;
        Core::Array::MulVal(thr, mStat->GetStDev(), 1.0);
        Core::Array::MaximumVal(thr, thr, mMinimumThres);
        Core::Array::GreaterThan(binIm, diff, thr);
        mWnd->UpdateView(view++, binIm, "Binary", mViewScale);

        /*
        Array2dScalarReal64* ker =
            Core::Array::ArrayCreate<Array2dScalarReal64>(9, 9);
        Core::Matrix::MatSet(ker, 0);
        Array2dScalarUInt8* binImClosed = 0;
        Core::Array::Dilation(binImClosed, binIm, ker);
        delete ker;
        UpdateView(view++, binImClosed, "Binary", mViewScale);
        */

        //UpdateView(view++, mStat->GetMinimum(), "Stretch", mViewScale);
        //UpdateView(view++, mStat->GetMaximum(), "Stretch", mViewScale);
        //UpdateView(view++, mStat->GetMean(), "Direct", mViewScale);
        //UpdateView(view++, mStat->GetStDev(), "Stretch", mViewScale);

        Array2dVec3UInt8* theBack = 0;
        Core::Array::Mul(theBack, srcWrap, binIm);
        mWnd->UpdateView(view++, theBack, "Direct", mViewScale);
        delete theBack;

        delete diff;
        delete thr;
        delete binIm;
        //delete binImClosed;
        delete lum;
        delete col;
        delete tmp;
        delete srcV3R64;
        aSys.CheckMemoryUsageSinceMark(false);
    }

    virtual void
    HandleNewKey(int c, int state)
    {
        if (c == 'r')
            Reset();
        if (c == 't')
        {
            mMinimumThres += 1;
            std::cout << "Minimum threshold at " << mMinimumThres << std::endl;
        } 
        if (c == 'T')
        {
            mMinimumThres -= 1;
            std::cout << "Minimum threshold at " << mMinimumThres << std::endl;
        } 
    }

private:

    void
    Reset()
    {
        mMinimumThres = 5.0;
        mStat->Reset();
    }

    Core::Database::DataDocument* mDataDoc;
    Window* mWnd;
    double  mViewScale;

    double mMinimumThres;
    double mSigma;
    int    mBorderSize;
    Core::Array::Statistics<Array2dScalarReal64>* mStat;

};

} // namespace Visualization
} // namespace Impala

#endif

---