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

---

mainBackground.cpp

Go to the documentation of this file.

#include "Basis/CmdOptions.h"
#include "Core/Array/Statistics.h"
#include "Core/Array/MakeFromData.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/GetRgbPixels.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/Stream/RgbDataSrcFactory.h"
#include "Visualization/AppControlSrc.h"
#include "Visualization/Window.h"

// since we are not using libraries:
#include "OglGui/OglLib.cpp"
#include "Link/ImpalaLib.cpp"

namespace Impala
{
namespace Application
{


using namespace Visualization;
using namespace Core::Array;
using namespace Core::Stream;

class WindowBackground : public Window, public AppControlSrc
{
public:

    WindowBackground(RgbDataSrc* src) :
        Window(0, 0, SuggestWndWidth(1, src->FrameWidth()),
               SuggestWndHeight(1, src->FrameHeight()) + 25, true),
        AppControlSrc(1)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        SetSrc(src); // tell AppControlSrc about src
        AppController::Instance().AddControl((AppControlSrc*) this, true);
        mViewScale = options.GetDouble("viewScale");
        mSigma = options.GetDouble("sigma");

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

        Reset();

        AppController::Instance().MainLoop();
    }

    void
    Reset()
    {
        mMinimumThres = 10.0;
        mCountdown = 25;
        mStat.Reset();
    }

    // specialization of base classes

    void
    HandleCycleSrc()
    {
        mOglWnd->updateScene = 1;
        std::string s = GetFpsString();
        if (mStat.IsDoingStat())
            s += std::string("      learning...");
        SetStatusStr((char*) s.c_str());
    }

    void
    HandleNewFrame()
    {
        int view = 0;
        bool startBackground = ! mStat.IsDoingStat();
        if (!startBackground)
            UpdateView(view++, GetSrc()->DataPtr(), GetSrc()->FrameWidth(),
                       GetSrc()->FrameHeight(), mViewScale);

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

        Array2dVec3UInt8* srcWrap = ArrayCreate<Array2dVec3UInt8>
            (GetSrc()->FrameWidth(), GetSrc()->FrameHeight(), 0, 0,
             GetSrc()->DataPtr(), true);
        Array2dVec3Real64* srcV3R64 = ArrayCreate<Array2dVec3Real64>
            (GetSrc()->FrameWidth(), GetSrc()->FrameHeight(), mBorderSize,
             mBorderSize);

        mCountdown--;
        if (mCountdown == 0)
            Set(mBackground, srcWrap);

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

        // RGB
        //MakeFromData2<Array2dVec3Real64,Array2dVec3UInt8>(srcV3R64,
        //                                                  GetSrc()->DataPtr());
        //RGB2Intensity(lum, srcV3R64);

        // Lab
        //ColorSpace(srcV3R64, srcV3R64, RGB, Lab);
        //ProjectRange(lum, srcV3R64, 1);

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

        RecGauss(lum, lum, mSigma, mSigma, 0, 0, 3);
        RecGauss(col, col, mSigma, mSigma, 0, 0, 3);

        //UpdateView(view++, lum, "Direct", mViewScale);

        Array2dScalarReal64* crit = col;
        mStat.DoArray(crit);

        Array2dScalarReal64* diff = 0;
        Sub(diff, mStat.GetMean(), crit);
        Abs(diff, diff);
        //UpdateView(view++, diff, "Stretch", mViewScale);

        Array2dScalarUInt8* binIm = 0;
        Array2dScalarReal64* thr = 0;
        MulVal(thr, mStat.GetStDev(), 3.0);
        MaximumVal(thr, thr, mMinimumThres);
        GreaterThan(binIm, diff, thr);
        //UpdateView(view++, binIm, "Binary", mViewScale);

        /*
        Array2dScalarReal64* ker = ArrayCreate<Array2dScalarReal64>(9, 9);
        Matrix::MatSet(ker, 0);
        Array2dScalarUInt8* binImClosed = 0;
        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);

        if (startBackground)
        {
            Array2dVec3UInt8* theBack = 0;
            Mul(theBack, mBackground, binIm);
            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
    KeyEvent(OglGui::Window* src, int c, int state)
    {
        AppControlSrc::KeyEvent(src, c, 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;
        } 
   }

    virtual void
    MouseFunc(INT msg, INT but, INT state, INT x, INT y)
    {
        Window::MouseFunc(msg, but, state, x, y);

        if ((msg == oglMouseDown) && (but == oglRightButton))
        {
            OGLMENU menu = oglSys.MenuCreate();
            oglSys.MenuAdd(menu, "fps reset", 0, 2);

            int choice = oglSys.MenuPopUp(mOglWnd, menu);

            switch (choice)
            {
            case 2:
                FpsReset();
                break;
            }

            oglSys.MenuDestroy(menu);
            oglSys.UpdateSceneFlag(mOglWnd, 1);
        }
    }

private:

    double mViewScale;
    double mMinimumThres;
    double mSigma;
    int    mBorderSize;
    int    mCountdown;
    Statistics<Array2dScalarReal64> mStat;
    Array2dVec3UInt8*               mBackground;

};

int
mainBackground(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, true);
    options.SetDefault("sigma", "3.0");
    std::string usageStr = "camera|filename\n\n";
    if (! options.ParseArgs(argc, argv, usageStr, 1))
        return 1;

    std::string srcName = options.GetArg(0);
    RgbDataSrcFactory& factory = RgbDataSrcFactory::Instance();
    RgbDataSrc* src = factory.Construct(srcName, options.GetString("src"));
    if (! src->Valid())
    {
        std::cout << "RgbDataSrc failed" << std::endl;
        return 0;
    }
    std::cout << src->FrameWidth() << " x " << src->FrameHeight() << std::endl;

    WindowBackground* oglWnd = new WindowBackground(src);
    if (! oglWnd->Valid())
    {
        std::cout << "WindowBackground failed" << std::endl;
        return 0;
    }
    return 1;
}

} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::mainBackground(argc, argv);
}

---