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

---

mainPlay.cpp

Go to the documentation of this file.

// RvB: This App works best with APP_CONTROLLER_ALT set
#define APP_CONTROLLER_ALT

#include "Visualization/VideoNav.h"
#include "Visualization/AppControlSrc.h"
#include "Core/Stream/RgbDataSrcFactory.h" // dies as first include with VC8??
#include "Link/DiskImage/DiskImageFuncs.h"

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

namespace Impala {
namespace Application {

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

class WindowPlay : public Window, public AppControlSrc,
                   public VideoNavListener, public OglGui::ViewListener
{
public:

    WindowPlay(int x, int y, bool doZoom, bool mainIs2d, bool vpIs2d,
               RgbDataSrc* src) :
        Window(x, y, SuggestWndWidth(1, src->FrameWidth()) + (doZoom ? 270 : 0),
               SuggestWndHeight(1, src->FrameHeight()) + 25 + 25, mainIs2d),
        AppControlSrc(1)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        SetSrc(src); // tell AppControlSrc about src
        AppController::Instance().AddControl((AppControlSrc*) this, true);

        mViewScale = options.GetDouble("viewScale");
        mVideoNav = new VideoNav(this, src);
        mVideoNav->SetVideoNavListener(this);
        mRoiWidth = 32;
        mRoiHeight = 32;
        mZoomFac = 5;
        int zWidth = mRoiWidth * mZoomFac;
        int zHeight = mRoiHeight * mZoomFac;
        mZoomedIm = 
            (doZoom) ? ArrayCreate<Array2dVec3UInt8>(zWidth, zHeight) : 0;
        mVp =
            (doZoom) ? MakeViewport(zWidth+40, zHeight+40, vpIs2d) : 0;

#if defined(OGL_USING_GLUT) && !defined(APP_CONTROLLER_ALT)
        SetAlwaysDraw(); // UpdateScene() doesn't work.
#endif
        MapKeysTo(mVideoNav);
        AppController::Instance().MainLoop();
    }

    void Zoom()
    {
        View* srcView = mVideoNav->GetView(0);
        if (!srcView)
            return;
        if ((mZoomedIm == 0) || (srcView->GetPointerX() < 0))
            return;
        Array2dVec3UInt8* dispIm = srcView->GetDispImage();
        if (!dispIm)
            return;

        unsigned char* dataPtr = dispIm->CPB(0, 0);
        int srcSX = srcView->GetPointerX() - mRoiWidth/2;
        if (srcSX < 0)
            srcSX = 0;
        if (srcSX > dispIm->CW()-1-mRoiWidth)
            srcSX = dispIm->CW()-1-mRoiWidth;
        int srcSY = srcView->GetPointerY() - mRoiHeight/2;
        if (srcSY < 0)
            srcSY = 0;
        if (srcSY > dispIm->CH()-1-mRoiHeight)
            srcSY = dispIm->CH()-1-mRoiHeight;
        for (int y=0 ; y<mRoiHeight ; y++)
        {
            unsigned char* src = dispIm->CPB(srcSX, srcSY + y);
            for (int x=0 ; x<mRoiWidth ; x++)
            {
                for (int zY=0 ; zY<mZoomFac ; zY++)
                {
                    unsigned char* dst = mZoomedIm->CPB(x*mZoomFac,
                                                        y*mZoomFac + zY);
                    for (int zX=0 ; zX<mZoomFac ; zX++)
                    {
                        for (int i=0 ; i<3 ; i++) {
                            *dst++ = src[i];
                        }
                    }
                }
                src += 3;
            }
        }
        mVp->UpdateView(0, mZoomedIm, "Direct", mViewScale, 0);
        mVideoNav->SetRect(Core::Geometry::Rectangle(srcSX, srcSY,
                                                 srcSX + mRoiWidth,
                                                 srcSY + mRoiHeight));
    }

    void HandleCycleSrc()
    {
// RvB: Should not be necessary and causes alwaysdraw behaviour
//        UpdateScene();
        SetStatusStr((char*) GetFpsString().c_str());
    }

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

    // specialization of base classes

    void NavFrameEvent(VideoNav* src, int requestedFrame, void* listenerData)
    {
        Jump(requestedFrame);
    }

    virtual void OnViewMouse(OglGui::View* view, int msg, int btn, int state,
                             float x, float y)
    {
        Zoom();
    }

#ifdef APP_CONTROLLER_ALT
    // RvB: Test PP-Def APP_CONTROLLER_ALT
    virtual void DisplayFunc()
    {
        SetAlwaysDraw(GetDoContinuous());
        AppControlSrc::ComputeCycle(0.04);
        if (AppControlSrc::Done())
            exit(0);
        Window::DisplayFunc();
    }
#endif

private:

    double        mViewScale;
    int           mRoiWidth; // size of roi, before zooming
    int           mRoiHeight;
    int           mZoomFac;

    Array2dVec3UInt8* mZoomedIm;
    Window*           mVp;
    VideoNav*         mVideoNav;

}; // class

int
mainPlay(int argc, char* argv[])
{
    OglInit(&argc, &argv[0]);
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, false, true);
    options.AddOption(0, "noZoom", "", "0");
    options.AddOption(0, "3d", "", "0");

    if (Link::DiskImage::DiskImageUsed())
        options.AddOption(0, "javacp", "classpath", "");

    if (! options.ParseArgs(argc, argv, "camera|filename", 1))
        return 1;

    ILOG_VAR(Application.mainPlay);

    String srcName = options.GetArg(0);
    bool doZoom = ! options.GetBool("noZoom");
    bool is2d = ! options.GetBool("3d");

    RgbDataSrcFactory& factory = RgbDataSrcFactory::Instance();
    Persistency::RgbDataSrcLocator loc("dot", srcName, options);
    RgbDataSrc* src = factory.Construct(loc, options.GetString("src"));
    if (! src->Valid())
    {
        ILOG_ERROR("RgbDataSrc failed");
        return 0;
    }
    ILOG_INFO(src->LastFrame()+1 << " frames of " << src->FrameWidth() 
              << " x " << src->FrameHeight());
    ILOG_INFO("length " << src->LastFrameAsTime());

    src->DumpInfo();

    WindowPlay* oglWnd = new WindowPlay(0, 0, doZoom, true, is2d, src);
    if (! oglWnd->Valid())
    {
        ILOG_ERROR("WindowPlay failed");
        return 0;
    }
    return 1;
}

} // namespace Application
} // namespace Impala

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

---