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

---

mainSrc.cpp

Go to the documentation of this file.

#include "Core/Geometry/PointZList.h"
#include "Core/Stream/RgbDataSrcFactory.h"
#include "Core/Stream/RgbDataSrcWindow.h"
#include "Core/Stream/SeqConvKernel.h"
#include "Core/Array/ColorSegmentation.h"
#include "Core/Array/Percentile.h"
#include "Core/Array/GreaterThanVal.h"
#include "Core/Array/Abs.h"
#include "Core/Array/WritePgm.h"
#include "Core/Array/WritePng.h"
#include "Core/Array/WriteJpg.h"
#include "Core/Array/Rotate.h"
#include "Core/Array/MakeFromData.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/GetRgbPixels.h"
#include "Core/Array/Set.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/ReadRaw.h"
#include "Core/Array/Erosion.h"
#include "Core/Array/Dilation.h"
#include "Core/Array/Threshold.h"
#include "Core/Array/Label.h"
#include "Core/Array/Watershed.h"
#include "Core/Array/GeodesicDistanceTransform.h"
#include "Core/Array/SKIZ.h"
#include "Core/Array/ProjectRange.h"
#include "Core/Array/GaussDerivative.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/Trait/BpoEqual.h"
#include "Core/Array/Harris.h"
#include "Core/Array/InvCompDer.h"
#include "Core/Array/KeypointsLowe.h"

#include "Visualization/Window.h"
#include "Visualization/AppControlSrc.h"
#include "Visualization/ViewListenerWithCircles.h"
#include "Visualization/ViewListenerWithArrows.h"

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

namespace Impala
{
namespace Application
{
namespace Src
{


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

// command line parameters
String gCmd;
int    gVerbose = 0;
Real64 gSigma = 1.0;
Real64 gPrecision = 3.0;
Real64 gLogScale = 32.0;
String gDispMode("LogMagnitude");
Real64 gSigmaA = 3.0;
Real64 gK = 0.00; // 0.04 ?
bool   gUseRecGauss = false;
int    gBorderSize = 19;

class BpoSwiss
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;

    typedef Pattern::TagCallValue CallCategory;

    BpoSwiss(Real64 theMax, int dimension)
    {
        mTheMax = theMax;
        mDimension = dimension;
    }

    Element::Vec3Real64
    DoIt(const Element::Vec3Real64& v, const Real64& s)
    {
        Real64 f = (s > 0) ? (s / mTheMax) * 255 : 0;
        if (f < 32)
            return v;
        /* blend
        if (mDimension == 1)
            return Element::Vec3Real64(f, v.y(), v.z());
        else if (mDimension == 2)
            return Element::Vec3Real64(v.x(), f, v.z());
        return Element::Vec3Real64(v.x(), v.y(), f);
        */

        // saturate
        if (mDimension == 1)
            return Element::Vec3Real64(255, v.Y(), v.Z());
        else if (mDimension == 2)
            return Element::Vec3Real64(v.X(), 255, v.Z());
        return Element::Vec3Real64(v.X(), v.Y(), 255);

        /* force
        if (mDimension == 1)
            return Element::Vec3Real64(f, 0, 0);
        else if (mDimension == 2)
            return Element::Vec3Real64(0, f, 0);
        return Element::Vec3Real64(0, 0, f);
        */
    }

private:
    Real64 mTheMax;
    int    mDimension;
};

class ExportPoints
{
public:
    typedef Pattern::TagPixOpOut       DirectionCategory;
    typedef Pattern::TagTransVar       TransVarianceCategory;
    typedef Pattern::Tag1Phase         PhaseCategory;

    ExportPoints(Real64 theMax, PointZListBI pListBI) :
        mPListBI(pListBI), mTheMax(theMax)
    {
    }

    void
    DoIt(const Real64& s, int x, int y)
    {
        Real64 f = (s > 0) ? (s / mTheMax) * 255 : 0;
        if (f < 32)
            return;
        *mPListBI++ = PointZ(x, y);
    }

private:

    Real64 mTheMax;
    PointZListBI mPListBI;
};

// finds max points and stores result in dst as well as pList
void
DoMaxPoints(Array2dVec3Real64* dst, Array2dScalarReal64* src, int dimension,
            PointZListBI pListBI)
{
    int cw = 2*gSigmaA + 1;
    int ch = 2*gSigmaA + 1;
    Array2dScalarReal64* ker = ArrayCreate<Array2dScalarReal64>(cw, ch);
    Core::Matrix::MatSet(ker, 0);

    Array2dScalarReal64* tmp1 = 0;
    Dilation(tmp1, src, ker);
    Trait::BpoEqual<Array2dScalarReal64, Array2dScalarReal64,
                    Array2dScalarReal64> bpo(0.0000000000000001);
    Pattern::PatBinaryPixOp(tmp1, tmp1, src, bpo); // src == dilated implies local max
    Mul(tmp1, tmp1, src); // obtain orignal values for local max from src
    Real64 theMax = PixMax(tmp1);
    //std::cout << "theMax : " << theMax << std::endl;

    ExportPoints expPoints(theMax, pListBI); // obtain coordinates
    Pattern::PatInOutOp(tmp1, expPoints);

    Array2dScalarReal64* tmp2 = 0;
    Dilation(tmp2, tmp1, ker); // "blow up" points for visibility
    delete ker;

    BpoSwiss bpoSwiss(theMax, dimension); // insert colored points in original
    Pattern::PatBinaryPixOp(dst, dst, tmp2, bpoSwiss);
    delete tmp1;
    delete tmp2;
}



class WindowSrc : public Window, public AppControlSrc
{
public:

    WindowSrc(RgbDataSrc* src) :
        Window(0, 0, SuggestWndWidth(3, src->FrameWidth()),
               SuggestWndHeight(2, 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");
        mCircleView1 = 0;
        mCircleView2 = 0;
        mCircleView4 = 0;
        mCircleView5 = 0;
        mArrowView = 0;
        if (gCmd == "tgauss")
        {
            mTGauss = MakeGaussian1d(gSigma, 1, gPrecision, 100);
            //WindowPrepCopyToVec3Real64* tmp = new WindowPrepCopyToVec3Real64();
            //mSrcWindow = new RgbDataSrcWindow<WindowPrepCopyToVec3Real64>
            WindowPrepGaussDerivative* tmp = new WindowPrepGaussDerivative
                (3.0, 1, 0, 3.0);
            mSrcWindow = new RgbDataSrcWindow<WindowPrepGaussDerivative>
                (GetSrc(), mTGauss->CW(), tmp);
        }

#ifdef OGL_USING_GLUT
//        SetAlwaysDraw(); // UpdateScene() doesn't work.
#endif
        AppController::Instance().MainLoop();
    }

    // specialization of base classes

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

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

        Util::Database* db = &Util::Database::GetInstance();
        ArraySystem& aSys = ArraySystem::Instance();
        aSys.MarkMemoryUsage(gVerbose > 0);

        Array2dVec3UInt8* srcWrap = ArrayCreate<Array2dVec3UInt8>
            (GetSrc()->FrameWidth(), GetSrc()->FrameHeight(), 0, 0,
             GetSrc()->DataPtr(), true);
        Array2dVec3Real64* srcV3R64 = ArrayCreate<Array2dVec3Real64>
            (GetSrc()->FrameWidth(), GetSrc()->FrameHeight(), gBorderSize,
             gBorderSize);
        MakeFromData2<Array2dVec3Real64,Array2dVec3UInt8>(srcV3R64,
                                                          GetSrc()->DataPtr());
        Array2dScalarReal64* srcSR64 = 0;
        RGB2Intensity(srcSR64, srcV3R64);


        if (gCmd == "keypoints")
        {
            if (gVerbose > 0)
                std::cout << "doing keypoints" << std::endl;
            mAList.clear();
            Array2dScalarReal64* points = 0;
            Array2dScalarUInt8* featVecs = 0;
            KeypointsLowe(points, featVecs, srcWrap, false);
            for (int r=0 ; r<points->CH() ; r++)
            {
                Real64* pointPtr = points->CPB(0, r);
                ArrowR a;
                a.mPX = *pointPtr++;
                a.mPY = *pointPtr++;
                //a.mLen = 6 * *pointPtr++; // produces proper length?
                a.mLen = *pointPtr++;
                a.mDir = *pointPtr++;
                mAList.push_back(a);
            }
            delete points;
            delete featVecs;
            if (mArrowView == 0)
                mArrowView = new ViewListenerWithArrows(&mAList, oglRED);
            UpdateView(1, srcSR64, "Stretch", mViewScale, mArrowView);
        }

        if (gCmd == "tgauss")
        {
            if (gVerbose > 0)
                std::cout << "doing tgauss" << std::endl;
            mSrcWindow->FollowSrc();
            Array2dVec3Real64* res = 0;
            SeqConvKernel(res, mSrcWindow, mTGauss);
            int v = 1;
            UpdateView(v++, res, "Stretch", mViewScale);
            for (int d=1 ; d<=3 ; d++)
            {
                Array2dScalarReal64* p = 0;
                ProjectRange(p, res, d);
                UpdateView(v++, p, "Stretch", mViewScale);
                delete p;
            }
            delete res;
            for (int i=0 ; i<mSrcWindow->WindowSize() ; i++)
                UpdateView(v++, mSrcWindow->DataArrayWindow(i), "Direct",
                           mViewScale);
        }

        if (gCmd == "segment")
        {
            if (gVerbose > 0)
                std::cout << "doing segment" << std::endl;
            ColorSegmentationAlgorithm segAlg = TextureAddZero;
            ColorSegmentationInvariant invariantType = C;
            //ColorSegmentationAlgorithm segAlg = Texture;
            //ColorSegmentationInvariant invariantType = E;
            //double minRegionFraction = 0.05;
            double minRegionFraction = 0.01;
            //double threshold = 7.5;
            double threshold = 6.0;
            bool gUseGauss = false;
            std::cout << "segAlg = " << MakeString(segAlg) << ", invariantType = "
                    << MakeString(invariantType) << std::endl;
            std::cout << "minRegionFraction = " << minRegionFraction
                    << ", threshold = " << threshold << std::endl;
            Array2dVec3UInt8* dst = 0;
            std::vector<Array2dVec3UInt8*> dispList;
            ColorSegmentation(dst, srcV3R64, segAlg, invariantType,
                              minRegionFraction, threshold, gUseGauss,
                              &dispList);
            UpdateView(1, dst, "Direct", mViewScale);
            for (int i=0 ; i<dispList.size() ; i++)
                UpdateView(2+i, dispList[i], "Direct", mViewScale);
            delete dst;
            ArrayListDelete(&dispList);
        }

        if (gCmd == "inv")
        {
            if (gVerbose > 0)
                std::cout << "doing inv" << std::endl;
            Array2dVec3Real64* srcCopy = 0;
            Set(srcCopy, srcV3R64);

            std::vector<Array2dScalarReal64*> rgbList;
            rgbList = InvCompDer(srcV3R64, gSigma, gPrecision, gUseRecGauss);
            Array2dScalarReal64* im = 0;

            HarrisObj<Array2dScalarReal64>(im, rgbList, gSigmaA, gK,
                                               gUseRecGauss);
            mPList1.clear();
            DoMaxPoints(srcV3R64, im, 1, std::back_inserter(mPList1));
            if (mCircleView1 == 0)
                mCircleView1 = new ViewListenerWithCircles(&mPList1, 5,
                                                               oglRED);
            UpdateView(1, im, gDispMode, mViewScale, mCircleView1);

            HarrisSperical<Array2dScalarReal64>(im, rgbList, gSigmaA, gK,
                                                    gUseRecGauss);
            mPList2.clear();
            DoMaxPoints(srcV3R64, im, 2, std::back_inserter(mPList2));
            if (mCircleView2 == 0)
                mCircleView2 = new ViewListenerWithCircles(&mPList2, 5,
                                                               oglGREEN);
            UpdateView(2, im, gDispMode, mViewScale, mCircleView2);

            UpdateView(0, srcV3R64, "Direct", mViewScale);
            UpdateView(3, srcCopy, "Direct", mViewScale); // dummy to init viewer

            HarrisRGB<Array2dScalarReal64>(im, rgbList, gSigmaA, gK,
                                               gUseRecGauss);
            mPList4.clear();
            DoMaxPoints(srcCopy, im, 2, std::back_inserter(mPList4));
            if (mCircleView4 == 0)
                mCircleView4 = new ViewListenerWithCircles(&mPList4, 5,
                                                               oglGREEN);
            UpdateView(4, im, gDispMode, mViewScale, mCircleView4);

            HarrisOpponent<Array2dScalarReal64>(im, rgbList, gSigmaA, gK,
                                                    gUseRecGauss);
            mPList5.clear();
            DoMaxPoints(srcCopy, im, 1, std::back_inserter(mPList5));
            if (mCircleView5 == 0)
                mCircleView5 = new ViewListenerWithCircles(&mPList5, 5,
                                                               oglRED);
            UpdateView(5, im, gDispMode, mViewScale, mCircleView5);

            UpdateView(3, srcCopy, "Direct", mViewScale);

            delete srcCopy;
            delete im;
            ArrayListDelete(&rgbList);
        }

        if (gCmd == "write")
        {
            if (gVerbose > 0)
                std::cout << "doing write" << std::endl;
            bool binary = true;
            WriteRaw(srcV3R64, "v3r64.raw", db, binary);
            WriteRaw(srcSR64, "sr64.raw", db, binary);
            UpdateView(1, srcSR64, "Stretch", mViewScale);
        }

        if (gCmd == "erosion")
        {
            if (gVerbose > 0)
                std::cout << "doing erosion" << std::endl;
            int cw = 5;
            int ch = 9;
            Array2dScalarReal64* ker = ArrayCreate<Array2dScalarReal64>(cw, ch);
            Core::Matrix::MatSet(ker, 0);
            Array2dScalarReal64* res = 0;
            Erosion(res, srcSR64, ker);
            //Percentile(res, srcSR64, 5, 0.95);
            UpdateView(1, res, "Stretch", mViewScale);
            delete ker;
            delete res;
        }

        if (gCmd == "dilation")
        {
            if (gVerbose > 0)
                std::cout << "doing dilation" << std::endl;
            int cw = 5;
            int ch = 9;
            Array2dScalarReal64* ker = ArrayCreate<Array2dScalarReal64>(cw, ch);
            Core::Matrix::MatSet(ker, 0);
            Array2dScalarReal64* res = 0;
            Dilation(res, srcSR64, ker);
            UpdateView(1, res, "Stretch", mViewScale);
            delete ker;
            delete res;
        }

        if (gCmd == "threshold")
        {
            if (gVerbose > 0)
                std::cout << "doing threshold" << std::endl;
            Array2dScalarUInt8* binIm = 0;
            Threshold(binIm, srcSR64, 128);
            UpdateView(1, binIm, "Binary", mViewScale);
            delete binIm;
        }

        if (gCmd == "label")
        {
            if (gVerbose > 0)
                std::cout << "doing label" << std::endl;
            Array2dScalarUInt8* binIm = 0;
            Threshold(binIm, srcSR64, 128);
            UpdateView(1, binIm, "Binary", mViewScale);
            Array2dScalarInt32* labIm = ArrayClone<Array2dScalarInt32>(binIm);
Timer tim(1);
        Label(labIm, binIm, 8);
std::cout << "time: " << tim.SplitTime() << std::endl;
            UpdateView(2, labIm, "Label", mViewScale);
            delete binIm;
            delete labIm;
        }

        if (gCmd == "watershed")
        {
            if (gVerbose > 0)
                std::cout << "doing watershed" << std::endl;
            Array2dScalarInt32* srcIm = 0;
            Set(srcIm, srcSR64);
            Array2dScalarInt32* dstIm = 0;
            Watershed(dstIm, srcIm, 8);
            UpdateView(1, dstIm, "Stretch", mViewScale);
            delete srcIm;
            delete dstIm;
        }

        if (gCmd == "geodesic")
        {
            if (gVerbose > 0)
                std::cout << "doing geodesic" << std::endl;
            Array2dScalarInt32* srcIm = 0;
            Set(srcIm, srcSR64);
            Array2dScalarInt32* dstIm = 0;
            GeodesicDistanceTransform(dstIm, srcIm, 8);
            UpdateView(1, dstIm, "Stretch", mViewScale);
            delete srcIm;
            delete dstIm;
        }

        if (gCmd == "skiz")
        {
            if (gVerbose > 0)
                std::cout << "doing skiz" << std::endl;
            Array2dScalarInt32* srcIm = 0;
            Set(srcIm, srcSR64);
            Array2dScalarInt32* dstIm = 0;
            SKIZ(dstIm, srcIm, 8);
            UpdateView(1, dstIm, "Stretch", mViewScale);
            delete srcIm;
            delete dstIm;
        }

        if (gCmd == "rotate")
        {
            if (gVerbose > 0)
                std::cout << "doing rotate" << std::endl;
            Array2dScalarReal64* res = 0;
            Rotate(res, srcSR64, 45.0, NEAREST, false, 0);
            UpdateView(1, res, "Stretch", mViewScale);
            delete res;
        }

        if (gCmd == "jpg")
        {
            if (gVerbose > 0)
                std::cout << "doing jpg" << std::endl;
            Array2dVec3UInt8* buf = ArrayCreate<Array2dVec3UInt8>
                (GetSrc()->FrameWidth(), GetSrc()->FrameHeight());
            GetRgbPixels(srcV3R64, buf->CPB(), "Direct");
            char fileName[50];
            sprintf(fileName, "frame_%06d.jpg", GetSrc()->FrameNr());
            WriteJpg(buf, String(fileName), db);
            delete buf;
        }

        if (gCmd == "png")
        {
            if (gVerbose > 0)
                std::cout << "doing png" << std::endl;
            Array2dVec3UInt8* buf = ArrayCreate<Array2dVec3UInt8>
                (GetSrc()->FrameWidth(), GetSrc()->FrameHeight());
            GetRgbPixels(srcV3R64, buf->CPB(), "Direct");
            char fileName[50];
            sprintf(fileName, "frame_%06d.png", GetSrc()->FrameNr());
            WritePng(buf, String(fileName), db);
            delete buf;
        }

        if (gCmd == "pgm")
        {
            if (gVerbose > 0)
                std::cout << "doing pgm" << std::endl;
            Array2dVec3UInt8* buf = ArrayCreate<Array2dVec3UInt8>
                (GetSrc()->FrameWidth(), GetSrc()->FrameHeight());
            GetRgbPixels(srcSR64, buf->CPB(), "Direct");
            char fileName[50];
            sprintf(fileName, "frame_%06d.pgm", GetSrc()->FrameNr());
            WritePgm(buf, String(fileName));
            delete buf;
        }

        if (gCmd == "stretch")
        {
            if (gVerbose > 0)
                std::cout << "doing stretch" << std::endl;
            UpdateView(1, srcSR64, "Stretch", mViewScale);
        }

        delete srcV3R64;
        delete srcSR64;
        delete srcWrap;
        aSys.CheckMemoryUsageSinceMark(gVerbose > 0);
    }

    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);
        }
    }

#ifdef APP_CONTROLLER_ALT
    // RvB: Test PP-Def APP_CONTROLLER_ALT
    virtual void DisplayFunc()
    {
        SetAlwaysDraw(GetDoContinuous());
        AppControlSrc::ComputeCycle(0.04);
        // RvB: Next does not work as getAllDone is private
        //if (AppController::Instance().GetAllDone())
        //  exit(0);
        if (AppControlSrc::Done())
            exit(0);
        Window::DisplayFunc();
    }
#endif

private:

    double        mViewScale;

    PointZList mPList1;
    PointZList mPList2;
    PointZList mPList4;
    PointZList mPList5;

    ViewListenerWithCircles* mCircleView1;
    ViewListenerWithCircles* mCircleView2;
    ViewListenerWithCircles* mCircleView4;
    ViewListenerWithCircles* mCircleView5;
    ArrowRList                 mAList;
    ViewListenerWithArrows*  mArrowView;

    // for tgauss
    //RgbDataSrcWindow<WindowPrepCopyToVec3Real64>* mSrcWindow;
    RgbDataSrcWindow<WindowPrepGaussDerivative>* mSrcWindow;
    Array2dScalarReal64*                         mTGauss;

};

int
mainSrc(int argc, char* argv[])
{
    OglInit(&argc, &argv[0]);
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, true);
    String usageStr = "cmd camera|filename\n\n";
    usageStr += "  cmd = stretch|pgm|png|jpg|rotate|skiz|geodesic|watershed|\n";
    usageStr += "        label|threshold|dilation|erosion|write|inv|segment|\n";
    usageStr += "        tgauss|keypoints\n";
    if (! options.ParseArgs(argc, argv, usageStr, 2))
        return 1;

    gCmd = options.GetArg(0);
    String srcName = options.GetArg(1);

    gVerbose = options.GetInt("verb");
    gSigma = options.GetDouble("sigma");
    gPrecision = options.GetDouble("precision");
    gUseRecGauss = options.GetBool("recGauss");
    gDispMode = options.GetString("disp");
    gLogScale = options.GetDouble("logScale");

    Array2dScalarReal64* g = 0;
    if (gUseRecGauss)
        g = MakeGaussIIR1d(Max(gSigma,gSigmaA), 1, gPrecision);
    else
        g = MakeGaussian1d(Max(gSigma,gSigmaA), 1, gPrecision, 100);
    int gw = g->CW();
    if (gw > gBorderSize)
    {
        std::cout << "Adjusting bordersize to " << gw << std::endl;
        gBorderSize = gw;
    }
    delete g;

    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;

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

    return 1;
}

} // namespace Src
} // namespace Application
} // namespace Impala

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

---