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

---

mainDemoCamera2d.cpp

Go to the documentation of this file.

#include "Basis/CmdOptions.h"
#include "Basis/Timer.h"
#include "Core/Array/MakeFromData.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/PixMin.h"
#include "Core/Array/PixMax.h"
#include "Core/Array/GetRgbPixels.h"
#include "Core/Array/GaussDerivative.h"
#include "Core/Array/Mul.h"
#include "Core/Array/Add.h"
#include "Core/Array/ColorSpace.h"
#include "Core/Array/ProjectRange.h"
#include "Core/Array/Sub.h"
#include "Core/Array/Norm2Sqr.h"
#include "Core/Array/InvLvvLw2.h"
#include "Core/Array/InvEw.h"
#include "Core/Array/InvWw.h"
#include "Core/Array/InvCw.h"
#include "Core/Array/InvNw.h"
#include "Core/Array/InvHw.h"
#include "Core/Array/InvRGBw.h"
#include "Core/Array/InvANGw.h"
#include "Core/Array/InvANG2w.h"
#include "Core/Array/InvJOSAw.h"
#include "Core/Array/InvOBw.h"
#include "Core/Array/InvHUEw.h"
#include "Core/Array/InvCompDer.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Stream/RgbDataSrcFactory.h"
#include "Visualization/Window.h"
#include "Visualization/AppControlSrc.h"

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

namespace Impala
{
namespace Application
{
namespace DemoCamera2d
{


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

Impala::Visualization::Window* oglWnd = 0;

// command line parameters
int verbose = 0;
Real64 sigma = 2.0;
Real64 precision = 3.0;
std::string demo[10] = {"source", "njet", "e", "einv", "rgb", "rgbinv", "compinv"};
int nrDemo = 7;
int curDemo = 0;
std::string disp0Mode("Stretch"); // "normal" scalar values
std::string disp1Mode("Stretch"); // values may be positive as well as negative
std::string disp2Mode("LogMagnitude"); // values are positive (gradient magnitude)
Real64 logScale = 32.0;

// buffers for processing done in DoProcessing
Array2dVec3Real64* srcV;
std::vector<Array2dScalarReal64*> lList;
std::vector<Array2dScalarReal64*> eList;
std::vector<Array2dScalarReal64*> rgbList;
Array2dScalarReal64* funcRes;


// L based

void
DoLw2()
{
    if (verbose == 1) 
        std::cout << "DoLw2 " << std::endl;
    //Lx2+Ly2
    funcRes = 0;
    Norm2Sqr(funcRes, lList[1], lList[2]);
}

void
DoLvvLw2()
{
    if (verbose == 1) 
        std::cout << "DoLvvLw2 " << std::endl;
    funcRes = 0;
    InvLvvLw2<Array2dScalarReal64>(funcRes, lList);
}

// E based

void
DoEw()
{
    if (verbose == 1) 
        std::cout << "DoEw " << std::endl;
    funcRes = 0;
    InvEw<Array2dScalarReal64>(funcRes, eList);
}

void
DoWw()
{
    if (verbose == 1) 
        std::cout << "DoWw " << std::endl;
    funcRes = 0;
    InvWw<Array2dScalarReal64>(funcRes, eList, sigma);
}

void
DoCw()
{
    if (verbose == 1) 
        std::cout << "DoCw " << std::endl;
    funcRes = 0;
    InvCw<Array2dScalarReal64>(funcRes, eList, sigma);
}

void
DoNw()
{
    if (verbose == 1) 
        std::cout << "DoNw " << std::endl;
    funcRes = 0;
    InvNw<Array2dScalarReal64>(funcRes, eList, sigma);
}

void
DoHw()
{
    if (verbose == 1) 
        std::cout << "DoHw " << std::endl;
    funcRes = 0;
    InvHw<Array2dScalarReal64>(funcRes, eList, sigma);
}

void
DoCw_log()
{
    if (verbose == 1) 
        std::cout << "DoCw_log " << std::endl;
    funcRes = 0;
    InvCw_log<Array2dScalarReal64>(funcRes, eList, sigma);
}

void
DoNw_log()
{
    if (verbose == 1) 
        std::cout << "DoNw_log " << std::endl;
    funcRes = 0;
    InvNw_log<Array2dScalarReal64>(funcRes, eList, sigma);
}

void
DoHw_log()
{
    if (verbose == 1) 
        std::cout << "DoHw_log " << std::endl;
    funcRes = 0;
    InvHw_log<Array2dScalarReal64>(funcRes, eList, sigma);
}

// RGB based

void
DoRGBw()
{
    if (verbose == 1) 
        std::cout << "DoRGBw " << std::endl;
    funcRes = 0;
    InvRGBw<Array2dScalarReal64>(funcRes, rgbList);
}

void
DoANGw()
{
    if (verbose == 1) 
        std::cout << "DoANGw " << std::endl;
    funcRes = 0;
    InvANGw<Array2dScalarReal64>(funcRes, rgbList);
}

void
DoANG2w()
{
    if (verbose == 1) 
        std::cout << "DoANG2w " << std::endl;
    funcRes = 0;
    InvANG2w<Array2dScalarReal64>(funcRes, rgbList);
}

void
DoJOSAw()
{
    if (verbose == 1) 
        std::cout << "DoJOSAw " << std::endl;
    funcRes = 0;
    InvJOSAw<Array2dScalarReal64>(funcRes, rgbList);
}

void
DoOBw()
{
    if (verbose == 1) 
        std::cout << "DoOBw " << std::endl;
    funcRes = 0;
    InvOBw<Array2dScalarReal64>(funcRes, rgbList);
}

void
DoHUEw()
{
    if (verbose == 1) 
        std::cout << "DoHUEw " << std::endl;
    funcRes = 0;
    InvHUEw<Array2dScalarReal64>(funcRes, rgbList);
}


typedef void (*PINVF)();

// Structure for information on demo functions.
class InvInfo
{
public:
    InvInfo()
    {
        mActive = false;
    }

    InvInfo(std::string name, int imIdx, bool reqL, bool reqE, bool reqRGB,
            PINVF func, std::string displayMode)
    {
        mName = name;
        mImIdx = imIdx;
        mReqL = reqL;
        mReqE = reqE;
        mReqRGB = reqRGB;
        mFunc = func;
        mDisplayMode = displayMode;
        mActive = true;
    }

    bool        mActive;
    std::string mName;
    int         mImIdx;
    bool        mReqL;
    bool        mReqE;
    bool        mReqRGB;
    PINVF       mFunc;
    std::string mDisplayMode;
};

// The basic demo functions

InvInfo basicInvs[] = {
    InvInfo("Source", 0, false, false, false, 0, ""),
    InvInfo("L", 0, true, false, false, 0, "DirectNC"),
    InvInfo("Lx", 1, true, false, false, 0, disp1Mode),
    InvInfo("Ly", 2, true, false, false, 0, disp1Mode),
    InvInfo("Lxx", 3, true, false, false, 0, disp1Mode),
    InvInfo("Lxy", 4, true, false, false, 0, disp1Mode),
    InvInfo("Lyy", 5, true, false, false, 0, disp1Mode),
    InvInfo("E", 0, false, true, false, 0, disp0Mode),
    InvInfo("El", 3, false, true, false, 0, disp0Mode),
    InvInfo("Ell", 6, false, true, false, 0, disp0Mode),
    InvInfo("Ex", 1, false, true, false, 0, disp1Mode),
    InvInfo("Elx", 4, false, true, false, 0, disp1Mode),
    InvInfo("Ellx", 7, false, true, false, 0, disp1Mode),
    InvInfo("Ey", 2, false, true, false, 0, disp1Mode),
    InvInfo("Ely", 5, false, true, false, 0, disp1Mode),
    InvInfo("Elly", 8, false, true, false, 0, disp1Mode),
    InvInfo("R", 0, false, false, true, 0, disp0Mode),
    InvInfo("G", 3, false, false, true, 0, disp0Mode),
    InvInfo("B", 6, false, false, true, 0, disp0Mode),
    InvInfo("Rx", 1, false, false, true, 0, disp1Mode),
    InvInfo("Gx", 4, false, false, true, 0, disp1Mode),
    InvInfo("Bx", 7, false, false, true, 0, disp1Mode),
    InvInfo("Ry", 2, false, false, true, 0, disp1Mode),
    InvInfo("Gy", 5, false, false, true, 0, disp1Mode),
    InvInfo("By", 8, false, false, true, 0, disp1Mode)
};
int nrBasicInvs = 25;

// Compound demo functions
InvInfo compoundInvs[] = {
    InvInfo("Lw2", -1, true, false, false, DoLw2, disp2Mode),
    InvInfo("LvvLw2", -1, true, false, false, DoLvvLw2, disp1Mode),
    InvInfo("Ew", -1, false, true, false, DoEw, disp2Mode),
    InvInfo("Ww", -1, false, true, false, DoWw, disp2Mode),
    InvInfo("Cw", -1, false, true, false, DoCw, disp2Mode),
    InvInfo("Nw", -1, false, true, false, DoNw, disp2Mode),
    InvInfo("Hw", -1, false, true, false, DoHw, disp2Mode),
    InvInfo("Cw_log", -1, false, true, false, DoCw_log, disp2Mode),
    InvInfo("Nw_log", -1, false, true, false, DoNw_log, disp2Mode),
    InvInfo("Hw_log", -1, false, true, false, DoHw_log, disp2Mode),
    InvInfo("RGBw", -1, false, false, true, DoRGBw, disp2Mode),
    InvInfo("ANGw", -1, false, false, true, DoANGw, disp2Mode),
    InvInfo("ANG2w", -1, false, false, true, DoANG2w, disp2Mode),
    InvInfo("JOSAw", -1, false, false, true, DoJOSAw, disp2Mode),
    InvInfo("OBw", -1, false, false, true, DoOBw, disp2Mode),
    InvInfo("HUEw", -1, false, false, true, DoHUEw, disp2Mode)
};
int nrCompoundInvs = 16;

// The current demo setup

std::vector<InvInfo> curInvList;

// demo presets

void
DemoSource()
{
    // empty list
}

void
DemoCompInv()
{
    curInvList.push_back(basicInvs[1]); // L
    curInvList.push_back(compoundInvs[0]); // Lw2
    curInvList.push_back(compoundInvs[2]); // Ew
    curInvList.push_back(compoundInvs[3]); // Ww
    curInvList.push_back(compoundInvs[4]); // Cw
    curInvList.push_back(compoundInvs[12]); // ANG2w
    curInvList.push_back(compoundInvs[11]); // ANGw
    curInvList.push_back(compoundInvs[14]); // OBw
}

void
DemoNJet()
{
    curInvList.push_back(basicInvs[0]); // Source
    curInvList.push_back(basicInvs[1]); // L
    curInvList.push_back(basicInvs[2]); // Lx
    curInvList.push_back(basicInvs[3]); // Ly
    curInvList.push_back(basicInvs[4]); // Lxx
    curInvList.push_back(basicInvs[5]); // Lxy
    curInvList.push_back(basicInvs[6]); // Lyy

    curInvList.push_back(compoundInvs[0]); // Lw2
    curInvList.push_back(compoundInvs[1]); // LvvLw2
}

void
DemoE()
{
    curInvList.push_back(basicInvs[7]); // E
    curInvList.push_back(basicInvs[8]); // El
    curInvList.push_back(basicInvs[9]); // Ell
    curInvList.push_back(basicInvs[10]); // Ex
    curInvList.push_back(basicInvs[11]); // Elx
    curInvList.push_back(basicInvs[12]); // Ellx
    curInvList.push_back(basicInvs[13]); // Ey
    curInvList.push_back(basicInvs[14]); // Ely
    curInvList.push_back(basicInvs[15]); // Elly
}

void
DemoEinv()
{
    curInvList.push_back(basicInvs[0]); // Source
    curInvList.push_back(compoundInvs[2]); // Ew
    curInvList.push_back(compoundInvs[3]); // Ww
    curInvList.push_back(compoundInvs[4]); // Cw
    curInvList.push_back(compoundInvs[5]); // Nw
    curInvList.push_back(compoundInvs[6]); // Hw
    curInvList.push_back(compoundInvs[7]); // Cw_log
    curInvList.push_back(compoundInvs[8]); // Nw_log
    curInvList.push_back(compoundInvs[9]); // Hw_log
}

void
DemoRGB()
{
    curInvList.push_back(basicInvs[16]); // R
    curInvList.push_back(basicInvs[17]); // G
    curInvList.push_back(basicInvs[18]); // B
    curInvList.push_back(basicInvs[19]); // Rx
    curInvList.push_back(basicInvs[20]); // Gx
    curInvList.push_back(basicInvs[21]); // Bx
    curInvList.push_back(basicInvs[22]); // Ry
    curInvList.push_back(basicInvs[23]); // Gy
    curInvList.push_back(basicInvs[24]); // By
}

void
DemoRGBinv()
{
    curInvList.push_back(basicInvs[0]); // Source
    curInvList.push_back(compoundInvs[10]); // RGBw
    curInvList.push_back(compoundInvs[11]); // ANGw
    curInvList.push_back(compoundInvs[12]); // ANG2w
    curInvList.push_back(compoundInvs[13]); // JOSAw
    curInvList.push_back(compoundInvs[14]); // OBw
    curInvList.push_back(compoundInvs[15]); // HUEw
    curInvList.push_back(basicInvs[0]); // Source
    curInvList.push_back(basicInvs[0]); // Source
}

void
SetCurDemo(std::string d)
{
    curInvList.clear();
    if (oglWnd)
        oglWnd->DeleteViewers();

    for (int i=0 ; i<nrDemo ; i++)
        if (demo[i] == d)
            curDemo = i;

    switch (curDemo) {
    case 0: DemoSource(); break;
    case 1: DemoNJet(); break;
    case 2: DemoE(); break;
    case 3: DemoEinv(); break;
    case 4: DemoRGB(); break;
    case 5: DemoRGBinv(); break;
    case 6: DemoCompInv(); break;
    default: DemoCompInv(); break;
    }
}


class WindowCamera2d : public Window, public AppControlSrc
{
public:

    WindowCamera2d(RgbDataSrc* src) :
        Window(0, 0, SuggestWndWidth(3, src->FrameWidth()),
               SuggestWndHeight(3, 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");
        AppController::Instance().MainLoop();
    }


    template<class ArrayT>
    void
    DisplayIm(ArrayT* im, std::string displayMode, std::string viewName)
    {
        UpdateView(mCurView, im, displayMode, mViewScale);
        SetViewText(mCurView, viewName);
        mCurView++;
    }

    void
    HandleNewFrame()
    {
        UpdateView(0, GetSrc()->DataPtr(), GetSrc()->FrameWidth(),
                   GetSrc()->FrameHeight(), mViewScale);

        ArraySystem& aSys = ArraySystem::Instance();
        aSys.MarkMemoryUsage(verbose > 0);

        MakeFromData2<Array2dVec3Real64,Array2dVec3UInt8>(srcV, GetSrc()->DataPtr());

        bool oneReqL = false;
        bool oneReqE = false;
        bool oneReqRGB = false;
        int i;
        for (i=0 ; i<curInvList.size() ; i++)
        {
            if (curInvList[i].mReqL)
                oneReqL = true;
            if (curInvList[i].mReqE)
                oneReqE = true;
            if (curInvList[i].mReqRGB)
                oneReqRGB = true;
        }
        if (oneReqL)
        {
            Array2dScalarReal64* l = 0;
            RGB2Intensity(l, srcV);
            lList = InvCompDer(l, sigma, precision, false);
            delete l;
        }
        if (oneReqE)
        {
            Array2dVec3Real64* ooo = 0;
            ColorSpace(ooo, srcV, Element::RGB, Element::OOO);
            eList = InvCompDer(ooo, sigma, precision, false);
            delete ooo;
        }
        if (oneReqRGB)
            rgbList = InvCompDer(srcV, sigma, precision, false);
        mCurView = 1;
        for (i=0 ; i<curInvList.size() ; i++)
        {
            InvInfo cI = curInvList[i];
            if (cI.mFunc)
                cI.mFunc();
            if (verbose == 1)
                std::cout << "Displaying " << i << " = " << cI.mName << std::endl;
            if (cI.mFunc)
            {
                DisplayIm(funcRes, cI.mDisplayMode, cI.mName);
                delete funcRes;
            }
            else
            {
                if (cI.mReqL)
                    DisplayIm(lList[cI.mImIdx], cI.mDisplayMode, cI.mName);
                if (cI.mReqE)
                    DisplayIm(eList[cI.mImIdx], cI.mDisplayMode, cI.mName);
                if (cI.mReqRGB)
                    DisplayIm(rgbList[cI.mImIdx], cI.mDisplayMode, cI.mName);
            }
        }
        ArrayListDelete(&lList);
        ArrayListDelete(&eList);
        ArrayListDelete(&rgbList);

        aSys.CheckMemoryUsageSinceMark(verbose > 0);
    }

    void
    HandleCycleSrc()
    {
        mOglWnd->updateScene = 1;
        SetStatusStr((char*) GetFpsString().c_str());
    }

    // specialization of base classes

    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, subMenu1, subMenu2, subMenu3;
            int     choice, i;
            menu = oglSys.MenuCreate();
            subMenu1 = oglSys.MenuCreate();
            oglSys.MenuAdd(menu, "demo preset", subMenu1, 0);
            for (i=0 ; i<nrDemo ; i++)
            {
                oglSys.MenuAdd(subMenu1, (char *) demo[i].c_str(), 0, 1000+i);
                if (curDemo == i)
                    oglSys.MenuCheck(menu, 1000+i, 1);
            }
            subMenu2 = oglSys.MenuCreate();
            oglSys.MenuAdd(menu, "add basic", subMenu2, 0);
            for (i=0 ; i<nrBasicInvs ; i++)
            {
                oglSys.MenuAdd(subMenu2, (char *) basicInvs[i].mName.c_str(), 0,
                               2000+i);
            }
            subMenu3 = oglSys.MenuCreate();
            oglSys.MenuAdd(menu, "add compound", subMenu3, 0);
            for (i=0 ; i<nrCompoundInvs ; i++)
            {
                oglSys.MenuAdd(subMenu3, (char *) compoundInvs[i].mName.c_str(), 0,
                               3000+i);
            }
            oglSys.MenuAdd(menu, NULL, 0, 0); // separator
            oglSys.MenuAdd(menu, "fps reset", 0, 2);

            choice = oglSys.MenuPopUp(mOglWnd, menu);

            if (choice >= 3000)
            {
                int cInv = choice - 3000;
                curInvList.push_back(compoundInvs[cInv]);
            }
            else if (choice >= 2000)
            {
                int bInv = choice - 2000;
                curInvList.push_back(basicInvs[bInv]);
            }
            else if (choice >= 1000)
            {
                curDemo = choice - 1000;
                SetCurDemo(demo[curDemo]);
            }
            else
            {
                switch (choice)
                {
                case 2: 
                    FpsReset();
                    break;
                }
            }
            //SetDoReprocess(true);

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

private:

    double        mViewScale;
    int           mCurView;

};

int
mainDemoCamera2d(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, true);
    std::string demoAlt("");
    for (int i=0 ; i<nrDemo ; i++)
    {
        demoAlt += demo[i];
        if (i != nrDemo-1)
            demoAlt += "|";
    }
    options.AddOption(0, "demo", "name", "compinv", (char*) demoAlt.c_str());
    options.AddOption(0, "file", "name", "camera");

    if (! options.ParseArgs(argc, argv, "", 0))
        return 1;

    SetCurDemo(options.GetString("demo"));
    verbose = options.GetInt("verb");
    sigma = options.GetDouble("sigma");
    precision = options.GetDouble("precision");
    logScale = options.GetDouble("logScale");
    std::string srcName = options.GetString("file");

    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->LastFrame()+1 << " frames of " << src->FrameWidth() 
              << " x " << src->FrameHeight() << std::endl;

    std::cout << "demo = " << demo[curDemo] << std::endl;
    std::cout << "sigma = " << sigma << ", precision = " << precision << std::endl;
    std::cout << "logScale = " << logScale << std::endl;

    Array2dScalarReal64* g = 0;
    g = MakeGaussian1d(sigma, 2, precision, 100);
    int borderSize = g->CW();
    delete g;

    srcV = ArrayCreate<Array2dVec3Real64>(src->FrameWidth(), src->FrameHeight(),
                                          borderSize, borderSize);

    //WindowCamera2d* oglWnd = new WindowCamera2d(srcName, src, &options);
    oglWnd = new WindowCamera2d(src);
    if (! oglWnd->Valid())
    {
        std::cout << "WindowCamera2d failed" << std::endl;
        return 0;
    }
    return 1;
}

} // namespace DemoCamera2d
} // namespace Application
} // namespace Impala

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

---