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

---

IdentificationPane.h

Go to the documentation of this file.

/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/
#ifndef Impala_Application_SDash_IdentificationPane_h
#define Impala_Application_SDash_IdentificationPane_h

#include "Visualization/RgbOglImage.h"
#include "Visualization/Video.h"

#include "OglGui/GroupBox.h"
#include "OglGui/ViewStrip.h"
#include "OglGui/Button.h"
#include "OglGui/DirectionButton.h"
#include "OglGui/ImagesListener.h"
#include "OglGui/InfoViewer.h"

#include "Application/sdash/RoiInfo.h"
#include "Application/sdash/RegionsOfInterestInfo.h"
#include "Application/sdash/RegionsOfInterestCorrelation.h"
#include "Application/sdash/RoiLoader.h"
#include "Application/sdash/GuiEventListener.h"

namespace Impala {
namespace Application {
namespace SDash {

class IdentificationPane : 
    public OglGui::GroupBox, 
    public OglGui::ButtonListener,
    public OglGui::ImagesListener,
    public OglGui::WindowListener
{

public:

    RegionsOfInterestInfo* mRoiInfo;
    RegionsOfInterestCorrelation* mRoiCorrelations;

    IdentificationPane(
        const std::vector<Visualization::Video>& videos, 
        const std::string& roiPath, 
        Window* parent, int x, int y, int w, int h, strconst label,
        int borderType=BEV_ETCHED
        )
             : OglGui::GroupBox(parent, x, y, w, h, label, borderType)
             , mVideos(videos)
             , mRoiLoader(RoiLoader(roiPath))
    {
        mSimilarLoadingId = 0;
        StaticText* sText;
        sText = new StaticText(this, 4, h-22, w-8, 20, "Similars");
        sText->SetAlign(oglLeftAlign, oglCenterAlign);

        Button* infoBtn = new Button(this, w/2-22, h-23, 44, 20, "info",
                                     BEV_ETCHED,true);
        infoBtn->SetButtonListener(this,0);

        mClearSimilars = new Button(this, w-50, h-23, 46, 20, "clear",
                                    BEV_ETCHED,true);
        mClearSimilars->SetButtonListener(this,1);

        OGLWND* oglWnd;
        mSimilarsViewStrip = new ViewStrip(this,4,h/2,w-8,h/2-24);
        mSimilarsViewStrip->AspectRatio(0.5f);
        mSimilarsViewStrip->SetMargin(6);
        mSimilarsViewStrip->Spacing(6);
        mSimilarsViewStrip->SetViewTags((FlexViewTags) & ~movableTag);
        mSimilarsViewStrip->LayoutViews();
        oglWnd = mSimilarsViewStrip->GetOGLWND();
        oglSys.AllowPicking(oglWnd, 1,1);
        oglSys.AllowDeleteView(oglWnd, 1);
        oglSys.SetAllMouseMotion(oglWnd,1);
        
        mSimilarsViewStrip->SetImagesListener(this);
        mSimilarsViewStrip->SetWindowListener(this, 1);

        sText = new StaticText(this, 4, h/2-20, w/2, 20, "Positives");
        sText->SetAlign(oglLeftAlign, oglCenterAlign);
        mPositivesViewStrip = new ViewStrip(this,4,4,w-8,h/2-24);
        mPositivesViewStrip->AspectRatio(0.5);
        mPositivesViewStrip->SetMargin(6);
        mPositivesViewStrip->Spacing(6);
        mPositivesViewStrip->LayoutViews();
        oglWnd = mPositivesViewStrip->GetOGLWND();
        oglSys.AllowPicking(oglWnd, 1,1);
        oglSys.SetAllMouseMotion(oglWnd,1);
        mPositivesViewStrip->ScaleTo(this);
        mPositivesViewStrip->SetImagesListener(this);
        mPositivesViewStrip->SetWindowListener(this, 2);

        mClearPositives = new Button(this, w-50, h/2-20, 46, 20, "clear",
                                     BEV_ETCHED,true);
        mClearPositives->SetButtonListener(this,2);

        mSelectedToPositives =
            new DirectionButton(this,w/2-10,h/2-20,20,20,3,BEV_ETCHED);
        mSelectedToPositives->SetDirectionFeedback(true);
        mSelectedToPositives->SetButtonListener(this,3);

        mViewInfoText = new StaticText(this,100,h-22,200,20,"");
        mViewInfoText->SetForeground(0xff808080);


        ScaleChildren();
    }

    virtual ~IdentificationPane()
    {
    }

    void SetGuiEventListener(GuiEventListener* listener)
    {
        mGuiEventListener = listener;
    }

    ViewStrip* Similars()
    {
        return mSimilarsViewStrip;
    }
    ViewStrip* Positives()
    {
        return mPositivesViewStrip;
    }

    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        if (userData==0) // Info
            new InfoViewer(this, W()/2-300,H()/2-150,600,300,
                           "Info on Similar and Positives Image Strips",
                           "ViewStripsInfo.txt");
        if (userData==(void*)1)
            ClearSimilars();
        if (userData==(void*)2)
            ClearPositives();
        if (userData==(void*)3)
            SelectedToPositives();
    }

    void OglViewSetRoiInfo(OGLVIEW* oglView, RoiInfo* roiInfo)
    {
        oglView->UserData1 = (void*) roiInfo->videoId;
        oglView->UserData2 = (void*) roiInfo->frameNr;
        oglView->UserData3 = (void*) roiInfo->roiNr;
    }

    RoiInfo OglViewGetRoiInfo(OGLVIEW* oglView)
    {
        RoiInfo roiInfo;
        roiInfo.videoId = (int) oglView->UserData1;
        roiInfo.frameNr = (int) oglView->UserData2;
        roiInfo.roiNr   = (int) oglView->UserData3;
        return roiInfo;
    }

    virtual void DisplayFunc()
    {
        char    buf[10];
        int     cnt = 0;
        for ( ; mSimilarLoadingId < mRoisOfSimilars.size(); mSimilarLoadingId++)
        {
            int subjectVideoId = mRoisOfSimilars[0].videoId;
            RoiInfo& similRoi = mRoisOfSimilars[mSimilarLoadingId];
            OGLIMAGE* image = mRoiLoader.Load(similRoi.videoId, similRoi.frameNr, similRoi.roiNr);
            View* view = mSimilarsViewStrip->AddImage(image);
            OGLVIEW* oglView = view->GetOGLVIEW2D();
            sprintf(buf, "#%d", similRoi.videoId+1);
            viewSys.SetStr(oglView, OGL_TEXT, buf);
            ULONG   col = (similRoi.videoId != subjectVideoId) ? 0xffffff00 : oglGREEN;
            viewSys.SetColor(oglView, OGL_TEXT,col);
            oglSys.ReleaseOglImage(image);
            OglViewSetRoiInfo(view->GetOGLVIEW2D(), &similRoi);
            if (++cnt > 4)
            {
                mSimilarLoadingId++;
                break;
            }
        }
        if (mSimilarLoadingId == mRoisOfSimilars.size())
        {
            mSimilarLoadingId = 0;
            mRoisOfSimilars.clear();
        }
        GroupBox::DisplayFunc();
    }

    void SearchSimilars(RoiInfo subjRoi, int maxFrameNr)
    {
        int absRoiNr = mRoiInfo->GetAbsRoiNr(subjRoi.videoId, subjRoi.frameNr, subjRoi.roiNr);
        const unsigned short* similarsP = mRoiCorrelations->GetAllCorrelated(absRoiNr);

        ClearSimilars();

        for (int i = 0; i < CORRELATED_PER_ROI; i++)
        {
            RoiInfo similRoi = mRoiInfo->GetRoiInfo(*similarsP);
            //if (similRoi.videoId >= 0 && similRoi.videoId < mNrOfVideosStreet)
            if (similRoi.videoId >= 0 && similRoi.videoId < mVideos.size())
            {
                if (similRoi.frameNr <= maxFrameNr)
                {
                    if (!mVideos[similRoi.videoId].IsMovementFrame(similRoi.frameNr))
                    {
                        mRoisOfSimilars.push_back(similRoi);
                    }
                    //else
                    //{
                    //    printf("roi %i of movement frame %i of video %i skipped as similar\n", similRoi.roiNr, similRoi.frameNr, similRoi.videoId);
                    //}
                }
            }

            similarsP++;
        }
    }

    void SelectedToPositives()
    {
        int i = 0;
        while(OGLVIEW* oglView = mSimilarsViewStrip->FindIndexView(i))
        {
            if (viewSys.HasTags(oglView, selectedTag))
                AddPositive(oglView);
            i++;
        }
    }

    virtual void
    WindowKeyboardEvent(Window *src, int c, int state, void* userData)
    {
        if (userData==(void*)1) // SimilarsViewStrip
        {
            if (c==oglDELETE) // OGL has already deleted them since we allowed it.
                mSimilarsViewStrip->LayoutViews();
            if (c=='s')
                SelectedToPositives();
        }

        if (userData==(void*)2 && c==oglDELETE) // PositivesViewStrip
        {
            int i = mPositivesViewStrip->Size();
            if (i==0)
                return;
            while (OGLVIEW* oglView=mPositivesViewStrip->FindIndexView(i-1))
            {
                if (viewSys.HasTags(oglView, selectedTag))
                {
                    mRoisOfPositives.erase(mRoisOfPositives.begin()+i-1);
                    viewSys.DeleteView(oglView);
                }
                i--;
            }
            mPositivesViewStrip->LayoutViews();
        }
    }

    virtual void WindowInitDisplayEvent(Window *src, void* userData)
    {
        OGLWND* oglWnd;
        bool    hasObjects;
        int     state;
        if (userData == (void*) 1)
        {
            oglWnd = mSimilarsViewStrip->GetOGLWND();
            hasObjects = oglWnd->objectList != 0;
            state = mClearSimilars->GetState();
            mClearSimilars->SetState(hasObjects ? (state?state:1) : 0);

            int n = viewSys.TagTagged(oglWnd,selectedTag,1,selectedTag,1);
            state = mSelectedToPositives->GetState();
            mSelectedToPositives->SetState(n ? (state?state:1) : 0);
        }
        else if (userData == (void*) 2)
        {
            oglWnd = mPositivesViewStrip->GetOGLWND();
            hasObjects = oglWnd->objectList != 0;
            state = mClearPositives->GetState();
            mClearPositives->SetState(hasObjects ? (state?state:1) : 0);
        }
    }

    virtual void
    WindowMouseEvent(Window *src, int msg, int but, int state,
                     int x, int y, void* userData )
    {
        if (msg == oglMouseLeave)
            mViewInfoText->SetText("");
        if (msg == oglMouseMove && !state)
        {
            OGLVIEW* oglView = viewSys.FindView(src->GetOGLWND(), x, y);
            mViewInfoText->SetText("");
            if (oglView)
            {
                int videoId = (int)(long long) oglView->UserData1;
                int frameNr = (int)(long long) oglView->UserData2;
                //int secs = 14*3600 + 14*60 + 40 + frameNr * mTimesPerFrame[videoId];
                int secs = 14*3600 + 14*60 + 40 + frameNr * mVideos[videoId].GetTimePerFrame();
                int h, m, s;
                char buf[100];

                OglGui::AlertTimeLine::GetTimeUnits(secs,h,m,s);
                sprintf(buf, "Cam: %d Time: %02d:%02d:%02d", videoId+1, h, m, s);
                mViewInfoText->SetText(buf);
            }
        }
    }

    virtual void
    ImageSelectionEvent(Window* src, int imIndex, int msg, int btn, int state, void* userData)
    {
        ViewStrip* vsP = (ViewStrip*) src;
        OGLVIEW* oglView = vsP->FindIndexView(imIndex);
        RoiInfo roiInfo = OglViewGetRoiInfo(oglView);

        if (btn==oglRightButton || msg == oglMouseDblClick)
        {
            if (vsP == mSimilarsViewStrip)
                AddPositive(oglView);
        }
        else if (!(state&oglControl))
            // RvB: GuiEvent is geen goede naam. Zegt niks over het event.
            mGuiEventListener->GuiEvent(this, (void*) &roiInfo);
    }

    // RvB !!!! Needs to be looked into as OGLIMAGES are refCounted
    // RefCount beheer wordt duidelijker en makkelijker als de ontvanger
    // weet dat hij om OGLIMAGE's vraagt die dus een refCount verhoogd hebben.
    // Wanneer de caller de OGLIMAGE's niet meer nodig heeft, bijvoorbeeld
    // omdat hij ze in een ViewStrip stopt die de refCount weer verhoogd,
    // dan is caller verantwoordelijk om de OGLIMAGES te releasen.
    // Status: Done. No more app crashes
    std::vector<OGLIMAGE*> GetPositives(bool doClear = false)
    {
        LIST*    obj;
        OGLVIEW* oglView;
        OGLWND*  oglWnd = mPositivesViewStrip->GetOGLWND();
        std::vector<OGLIMAGE*> result;
        ForAllElements(obj, oglWnd->objectList)
        {
            oglView = (OGLVIEW*) obj->info;
            // result.push_back(oglView->im);
            // RvB: OGLIMAGES are refCounted. Replaced line above
            // with next two lines. GetImage increases refCount
            OGLIMAGE* im = viewSys.GetImage(oglView);
            result.push_back(im);
        }

        if (doClear)
            ClearPositives();
        return result;
    }

    void ClearSimilars()
    {
        viewSys.DeleteViews(mSimilarsViewStrip->GetOGLWND());
        mSimilarsViewStrip->LayoutViews();
        mSimilarsViewStrip->GetScrollBar()->SetNewPos(0);
        mRoisOfSimilars.clear();
        mSimilarLoadingId = 0;
    }

    void ClearPositives()
    {
        mRoisOfPositives.clear();

        viewSys.DeleteViews(mPositivesViewStrip->GetOGLWND());
        mPositivesViewStrip->LayoutViews();
    }

    //std::vector<int> SuggestTrack()
    //{
    //    std::vector<int> track;
    //    if (!mRoisOfPositives.empty())
    //    {
    //        track.push_back(mRoisOfPositives[0].videoId);
    //        for (int r = 1; r < mRoisOfPositives.size(); r++)
    //            if (mRoisOfPositives[r].videoId != mRoisOfPositives[r-1].videoId)
    //                track.push_back(mRoisOfPositives[r].videoId);
    //    }
    //    return track;
    //}

    void SuggestTrack(std::vector<int>& videoIds, std::vector<int>& frameNrs)
    {
        if (!mRoisOfPositives.empty())
        {
            int prevVideoId = -1;
            // walk reversely to obtain most recent frames while at same video
            for (int r = mRoisOfPositives.size() - 1; r >= 0 ; r--)
                if (mRoisOfPositives[r].videoId != prevVideoId)
                {
                    videoIds.insert(videoIds.begin(), mRoisOfPositives[r].videoId);
                    frameNrs.insert(frameNrs.begin(), mRoisOfPositives[r].frameNr);
                    prevVideoId = mRoisOfPositives[r].videoId;
                }
        }
    }

    //void TimesPerFrame(const float* timesPerFrame)
    //{
    //    mTimesPerFrame = timesPerFrame;
    //}


private:

    ViewStrip* mSimilarsViewStrip;
    ViewStrip* mPositivesViewStrip;
    RoiInfo mSubjectRoiInfo;
    RoiLoader mRoiLoader;
    //int mNrOfVideosStreet;
    GuiEventListener* mGuiEventListener;
    const std::vector<Visualization::Video>& mVideos;
    std::vector<RoiInfo> mRoisOfPositives;
    std::vector<RoiInfo> mRoisOfSimilars;
    int                  mSimilarLoadingId;

    StaticText*         mViewInfoText;
    Button*             mClearSimilars;
    Button*             mClearPositives;
    DirectionButton*    mSelectedToPositives;
    //const float* mTimesPerFrame;

    void AddPositive(OGLVIEW* oglView)
    {
        // determine insert position and insert new roi
        //RoiInfo newRoi = *((RoiInfo*) oglView->UserData1);
        RoiInfo newRoi = OglViewGetRoiInfo(oglView);
        float frameTimeNewRoi = newRoi.frameNr * mVideos[newRoi.videoId].GetTimePerFrame();
        std::vector<RoiInfo>::iterator iter = mRoisOfPositives.begin();
        int insertAt = 0;
        while (iter != mRoisOfPositives.end())
        {
            RoiInfo roi = *iter;
            float frameTimeRoi = roi.frameNr * mVideos[roi.videoId].GetTimePerFrame();
            //if (roi.frameNr > newRoi.frameNr) // assumes time order by frame order
            if (frameTimeRoi > frameTimeNewRoi)
                break;
            else if (roi.frameNr == newRoi.frameNr)
                if (roi.videoId == newRoi.videoId && roi.roiNr == newRoi.roiNr)
                    return; // don't add duplicates
            iter++;
            insertAt++;
        }
        mRoisOfPositives.insert(iter, newRoi);

        // refill the strip and insert new image 
        std::vector<OGLIMAGE*> currentPositives = GetPositives();
        // RvB: Als GetPositives de refCount verhoogd heeft kan volgende line geen kwaad.
        viewSys.DeleteViews(mPositivesViewStrip->GetOGLWND());
        mPositivesViewStrip->LayoutViews();
        View* view;
        for (int i = 0; i <= currentPositives.size(); i++)
        {
            if (i < insertAt)
                view = mPositivesViewStrip->AddImage(currentPositives[i]);
            else if (i == insertAt)
                view = mPositivesViewStrip->AddImage(oglView->im);
            else
                view = mPositivesViewStrip->AddImage(currentPositives[i-1]);

            // RvB: Geen texturing omdat ROIs niet deelbaar door 4 zijn.
            // het maken van textures kost ook tijd omdat dan de beelden
            // door CPU geschaald moeten worden naar een 2 macht.
            // view->GetOGLVIEW2D()->texturing = 1;
            RoiInfo roiInfo = mRoisOfPositives[i];
            //view->GetOGLVIEW2D()->UserData1 = new RoiInfo(roiInfo);
            OglViewSetRoiInfo(view->GetOGLVIEW2D(), &roiInfo);
        }
        // RvB: Als GetPositives de refCount v/d OGLIMAGES netjes verhoogd heeft
        // moeten ze hier gereleased worden (de viewstrip heeft nu nl een hold op ze).
         for (int i=0; i<currentPositives.size(); i++)
            oglSys.ReleaseOglImage(currentPositives[i]);

    }

}; // class

} // namespace SDash
} // namespace Application
} // namespace Impala

#endif

---