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

---

RgbDataSrcWindow.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_RgbDataSrcWindow_h
#define Impala_Core_Stream_RgbDataSrcWindow_h

#include "Core/Stream/RgbDataSrc.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/MakeFromData.h"
#include "Core/Array/Set.h"
#include "Core/Array/Rgb2Ooo.h"
#include "Core/Array/GaussDerivative.h"

namespace Impala
{
namespace Core
{
namespace Stream
{


//
class WindowPrepCopyToVec3Real64
{
public:
    
    typedef Array::Array2dVec3Real64 ArrayType;

    void
    DoIt(Array::Array2dVec3Real64*& dst, Array::Array2dVec3UInt8* src)
    {
        Set(dst, src);
    }

};

//
class WindowPrepRgb2Ooo
{
public:
    
    typedef Array::Array2dVec3Real64 ArrayType;

    void
    DoIt(Array::Array2dVec3Real64*& dst, Array::Array2dVec3UInt8* src)
    {
        Rgb2Ooo(dst, src);
    }

};

//
class WindowPrepGaussDerivative
{
public:
    
    typedef Array::Array2dVec3Real64 ArrayType;

    WindowPrepGaussDerivative(double sigma, int orderDerivx, int orderDerivy,
                              double truncation)
    {
        mSigma = sigma;
        mOrderDerivx = orderDerivx;
        mOrderDerivy = orderDerivy;
        mTruncation = truncation;
    }

    void
    DoIt(Array::Array2dVec3Real64*& dst, Array::Array2dVec3UInt8* src)
    {
        Array::Array2dVec3Real64* srcV = 0;
        Set(srcV, src);
        GaussDerivativeVec3(dst, srcV, mSigma, mOrderDerivx, mOrderDerivy,
                            mTruncation);
        delete srcV;
    }

private:

    double mSigma;
    int    mOrderDerivx;
    int    mOrderDerivy;
    double mTruncation;

};


// A window on top of a RgbDataSrc, buffering frames in the "sequence dimension".
// Prep determines whether the window contains pre-processed frames in addition
// to the original rgb data
// ControlSrc determines whether the window controles the src and thus actually
// becomes a RgbDataSrc or whether the window only "follows" the src.
// In the first case, the current frame of src is kept at "one past the window"
// and centre indicates whether the current frame is at the centre or at the end.
// In the latter case, the window contains only frames that are already visited
// by the src and thus centre has no meaning.

// NEW : "hacked" the Window to be a specialization of RgbDataSrc
// TODO: decide whether to keep it this way or use a generic/template approach
// to be able to mix Window and Src.
// If the latter case we should maintain the same names for the member functions
// but in the former case this is rather obscure as the functions are not virtual

template<class PrepT>
class RgbDataSrcWindow : public RgbDataSrc
{
public:

    typedef typename PrepT::ArrayType ArrayT;
    typedef Array::Array2dVec3UInt8 Array2dVec3UInt8;

    RgbDataSrcWindow(RgbDataSrc* src, int windowSize, PrepT* prep = 0,
                     bool controlSrc = false, bool centre = false)
        : RgbDataSrc(src->GetType(), src->GetName())
    {
        // init base class
        mFrameWidth = src->FrameWidth();
        mFrameHeight = src->FrameHeight();
        mLastFrame = src->LastFrame();

        // init this class
        mSrc = src;
        mWindowSize = windowSize;
        mControlSrc = controlSrc;
        mCentre = centre;
        ILOG_DEBUG("window size " << mWindowSize << ", centre " << mCentre);
        mPrep = prep;
        mWindowStart = -1;
        mRgbBufSize = src->FrameWidth() * src->FrameHeight() * 3;
        mWindow = new unsigned char*[windowSize];
        mWindowAr = new ArrayT*[windowSize];
        for (int i=0 ; i<windowSize ; i++)
        {
            mWindow[i] = new unsigned char[mRgbBufSize];
            mWindowAr[i] = 0;
            if (mPrep)
                mWindowAr[i] = Array::ArrayCreate<ArrayT>(src->FrameWidth(),
                                                          src->FrameHeight());
        }
    }

    virtual
    ~RgbDataSrcWindow()
    {
        for (int i=0 ; i<mWindowSize ; i++)
        {
            if (mWindow[i])
                delete mWindow[i];
            if (mWindowAr[i])
                delete mWindowAr[i];
        }
        delete [] mWindow;
        delete [] mWindowAr;
        if (mControlSrc)
            delete mSrc;
    }

    int
    WindowSize()
    {
        return mWindowSize;
    }

    int
    FrameWidth()
    {
        return mSrc->FrameWidth();
    }

    int
    FrameHeight()
    {
        return mSrc->FrameHeight();
    }

    // the "central" frame
    int
    FrameNr()
    {
        if (mCentre)
            return mWindowStart + mWindowSize/2;
        return mWindowStart + mWindowSize - 1;
    }

    int
    LastFrame()
    {
        if (mCentre)
            return mSrc->LastFrame() - mWindowSize/2;
        return mSrc->LastFrame();
    }

    RgbDataSrc*
    Src()
    {
        return mSrc;
    }

    // the "central" frame
    unsigned char*
    DataPtr()
    {
        if (mCentre)
            return mWindow[mWindowSize/2];
        return mWindow[mWindowSize-1];
    }

    // the "central" frame
    ArrayT*
    DataArray()
    {
        if (mCentre)
            return mWindowAr[mWindowSize/2];
        return mWindowAr[mWindowSize-1];
    }

    // dataPtr's for each frame in the window, 0 <= idx < windowSize
    unsigned char*
    DataPtrWindow(int idx)
    {
        return mWindow[idx];
    }

    // Array's for each frame in the window, 0 <= idx < windowSize
    ArrayT*
    DataArrayWindow(int idx)
    {
        return mWindowAr[idx];
    }

    virtual bool
    Valid() const
    {
        return (mSrc != 0) && mSrc->Valid();
    }

    bool
    NextFrame(int inc = 1)
    {
        if ((inc == 1) && (mWindowStart != -1))
            return Advance();
        else
            return GotoFrame(FrameNr() + inc);
    }

    bool 
    GotoFrame(int frameNr)
    {
        ILOG_DEBUG("  window goto frame " << frameNr);

        if (mSrc->TheEnd())
            return true;

        if (mCentre)
        {
            if (frameNr < mWindowSize/2)
                frameNr = mWindowSize/2;
            if (frameNr >= mSrc->LastFrame() - mWindowSize/2)
                frameNr = mSrc->LastFrame() - mWindowSize/2;
        }
        else
        {
            if (frameNr < mWindowSize - 1)
                frameNr = mWindowSize - 1;
            if (frameNr >= mSrc->LastFrame() - 1)
                frameNr = mSrc->LastFrame() - 1;
        }

        if (mCentre)
            return JumpStart(frameNr - mWindowSize/2);
        else
            return JumpStart(frameNr - (mWindowSize - 1));
    }

    bool
    TheEnd()
    {
        return mSrc->TheEnd();
    }

    bool
    FollowSrc()
    {
        return Advance();
    }

protected:

    // specialization of base class
    bool
    ReadFrameData()
    {
        const int frameNr = RgbDataSrc::FrameNr();
        ILOG_DEBUG("  reading frame data for " << frameNr);
        bool rc = false;
        if (frameNr == RgbDataSrcWindow::FrameNr() + 1)
            rc = Advance();
        else
            rc = GotoFrame(frameNr);
        mData = RgbDataSrcWindow::DataPtr();
        return rc;
    }

private:

    bool
    JumpStart(int start)
    {
        ILOG_DEBUG("  jumpstart " << start);

        mWindowStart = start;
        if (start == -1)
            return true;

        if (mSrc->FrameNr() != mWindowStart)
        {
            ILOG_DEBUG("  telling slave to goto " << mWindowStart);
            if (!mSrc->GotoFrame(mWindowStart))
                return false;
            ILOG_DEBUG("  slave went to " << mSrc->FrameNr());
        }

        for (int i=0 ; i<mWindowSize ; i++)
        {
            memcpy(mWindow[i], mSrc->DataPtr(), mRgbBufSize);
            if (mPrep)
            {
                Array2dVec3UInt8* srcWrap = Array::ArrayCreate<Array2dVec3UInt8>
                    (mSrc->FrameWidth(), mSrc->FrameHeight(), 0, 0,
                     mSrc->DataPtr(), true);
                mPrep->DoIt(mWindowAr[i], srcWrap);
                delete srcWrap;
            }
            if (!mSrc->NextFrame())
                return false;
        }
        return true;
    }

    bool
    Advance()
    {
        mWindowStart++;
        ILOG_DEBUG("  advance to window start " << mWindowStart);
        unsigned char* tmp = mWindow[0];
        ArrayT* tmpAr = mWindowAr[0];
        for (int i=0 ; i<mWindowSize-1 ; i++)
        {
            mWindow[i] = mWindow[i+1];
            mWindowAr[i] = mWindowAr[i+1];
        }
        mWindow[mWindowSize-1] = tmp;
        mWindowAr[mWindowSize-1] = tmpAr;

        memcpy(mWindow[mWindowSize-1], mSrc->DataPtr(), mRgbBufSize);
        if (mPrep)
        {
            Array2dVec3UInt8* srcWrap = Array::ArrayCreate<Array2dVec3UInt8>
                (mSrc->FrameWidth(), mSrc->FrameHeight(), 0, 0, mSrc->DataPtr(),
                 true);
            mPrep->DoIt(mWindowAr[mWindowSize-1], srcWrap);
            delete srcWrap;
        }

        bool rc = true;
        if (mControlSrc)
        {
            ILOG_DEBUG("  advancing slave src");
            rc = mSrc->NextFrame();
        }
        return rc;
    }

    RgbDataSrc*     mSrc;
    bool            mControlSrc;
    bool            mCentre;
    int             mRgbBufSize;
    int             mWindowSize;
    int             mWindowStart;
    unsigned char** mWindow;
    ArrayT**        mWindowAr;
    PrepT*          mPrep;

    ILOG_VAR_DECL;

};

ILOG_VAR_INIT_TEMPL_1(RgbDataSrcWindow, PrepT, Impala.Core.Stream);

} // namespace Stream
} // namespace Core
} // namespace Impala

#endif

---