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

---

SimilarityPlotNeedleImage.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Author: Richard van Balen
#ifndef Impala_Visualization_SimilarityPlotNeedleImage_h
#define Impala_Visualization_SimilarityPlotNeedleImage_h

#include "Core/VideoSet/SegmentationDocument.h"
#include "OglGui/StringSelector.h"
#include "OglGui/StringListener.h"
#include "OglGui/StaticText.h"
#include "OglGui/Slider.h"
#include "Visualization/ImagesWindow.h"
#include "Visualization/AppControlDoc.h"
#include "Visualization/Plot/Plot.h"
#include "Visualization/Plot/Points.h"
#include "Visualization/Plot/PlotNeedle.h"

namespace Impala {
namespace Visualization {

class SimilarityPlotNeedleImage : public Window,
                                  public AppControlDoc,
                                  public Core::Database::DataDocumentListener,
                                  public ImagesListener,
                                  public OglGui::StringListener,
                                  //public OglGui::SliderListener,
                                  public Visualization::Plot::PlotNeedleListener
{
public:
    typedef Core::VideoSet::SegmentationDocument    SegmentationDocument;
    typedef Core::Table::SimilarityTableSet         SimilarityTableSet;
    typedef SimilarityTableSet::RankTableType       RankTableType;
    typedef SimilarityTableSet::SimTableType        SimTableType;
    typedef Visualization::Plot::PlotNeedle         PlotNeedle;
    typedef OglGui::StringSelector                  StringSelector;
    typedef OglGui::StaticText                      StaticText;
    //typedef OglGui::Slider                          Slider;

    SimilarityPlotNeedleImage(OglGui::Window* parent,
                              int wndWidth, int wndHeight,
                              int thumbWidth, int thumbHeight,
                              SegmentationDocument* segDoc,
                              SimilarityTableSet* simSet, int controlId) :
        Window(parent, wndWidth, wndHeight, true),
        AppControlDoc(controlId, segDoc)
    {
        mSegDoc = segDoc;
        mSimSet = simSet;
        mCurKeyframe = -1;
        mCurFile = -1;
        mCurConcept = -1;
        mShowMaxSim = 1.0;
        mPointSize = 1;
        mKeyframes = mSegDoc->GetKeyframes();
        mKeyframeSet = mSegDoc->GetImSetKeyframes(true);
        AddDocListener(this);

        mStringSelector = new StringSelector(this, wndWidth, 120);
        std::vector<std::string> names = mSimSet->GetNames();
        for (int i=0 ; i<names.size() ; i++)
        {
            mStringSelector->AddString(names[i]);
            mSegDoc->AddConcept(names[i]);
        }
        mStringSelector->SetStringListener(this, 0);

        mPlotPoints = new Plot::Plot(this, wndWidth-10, 490);
        mPlotPoints->SetDrawAxes(true);

        mPlotNeedle = new PlotNeedle(0,100,0,5,-5);
        mPlotNeedle->SetRoundOffset(0.5); // To find frame nearest to needle
        mPlotNeedle->SetPlotNeedleListener(this, 0);
        mPlotPoints->Add(mPlotNeedle);

        mPoints = new Visualization::Plot::Points();
        mPlotPoints->Add(mPoints);

        mImageWnd = new ImagesWindow(this, thumbWidth, thumbHeight);
        mImageWnd->ActivateInfoBox(false);
        mImageWnd->SetImagesListener(this, 0);

        mInfoText = new StaticText(this, 200, 20, "");
        mInfoText->SetAlign(oglLeftAlign, oglCenterAlign);

        /*
        mMaxSimSlider = new Slider(this,400,50,0,1000,1000);
        mMaxSimSlider->SetShowValPerc(true);
        mMaxSimSlider->SetPrecisionIdx(3);
        mMaxSimSlider->SetSliderListener(this, 0);
        new StaticText(this, 100, 20, "Max sim to show", false);
        */
        mSegDoc->SetConcept(0);
    }

    void FillPoints()
    {
        double minY = 1000, maxY=-1000;
        mPoints->Clear();
        for (int i=0; i<mNrOfKeys; i++)
        {
            //double y = mSimTable->Get1(mStartKey+i);
            Quid quid = mKeyframes->GetQuidFrame(mStartKey+i);
            int rank = mSimSet->FindQuid(quid);
            double y = mSimTable->Get1(rank);
            if (y<minY) minY = y;
            if (y>maxY) maxY = y;
            if (y<=mShowMaxSim)
                mPoints->AddPoint(i+1, y, 0, 0, 1, 0, mPointSize, false);
        }
        mPoints->SetDimensionsX(1, mNrOfKeys);
        mPoints->SetDimensionsY(minY, maxY);

        mPlotPoints->SetRange(mNrOfKeys,2*fabs(maxY-minY),0);
        mPlotPoints->SetCenter(mNrOfKeys/2,minY,0.5);

        mPlotNeedle->SetMinMaxX(1, mNrOfKeys);

        //mMaxSimSlider->SetMinMax(minY*1000,maxY*1000);
        //mMaxSimSlider->SetTickInterval(fabs(maxY-minY)*100);
    }

    virtual void
    HandleNewFile()
    {
        if (!(mSegDoc->HasCursor() && mKeyframes && mKeyframeSet))
        {
            mCurKeyframe = mCurFile = -1;
            mImageWnd->RemoveImages();
            return;
        }

        int fileId  = mSegDoc->CurFileId();
        int concept = mSegDoc->GetConceptIdx();

        if (concept != mStringSelector->GetCurrentStringIdx())
            mStringSelector->SetCurrentString(concept, true);

        mSimTable = mSimSet->GetSimTable(concept);
        mStartKey = mKeyframes->GetFirstKeyframeVideo(fileId);
        mNrOfKeys = mKeyframes->GetNrKeyframesVideo(fileId);
        mCurKeyframe = mStartKey;

        if (!(fileId == mCurFile && concept == mCurConcept))
        {
            FillPoints();
            mPlotPoints->SetUserPan(0,0);
            mPlotPoints->SetUserZoom(0.9,0.9);
        }

        mCurFile = fileId;
        mCurConcept = concept;

        mCurKeyframe = mSegDoc->CurKeyfr() - mStartKey;
        mPlotNeedle->MoveTo(mCurKeyframe+1);
        //int minV, maxV;
        //mMaxSimSlider->GetMinMax(minV, maxV);
        //mMaxSimSlider->SetValue(maxV);
        UpdateImage();
    }


    void UpdateImage()
    {
        if (mCurKeyframe == -1 || !mKeyframeSet)
            return;

        mImageWnd->RemoveImages();
        mImageWnd->AddImage(mCurKeyframe, mKeyframeSet);

        //double sim = mSimTable->Get1(mCurKeyframe);
        Quid quid = mKeyframes->GetQuidFrame(mCurKeyframe);
        int rank = mSimSet->FindQuid(quid);
        double sim = mSimTable->Get1(rank);
        mInfoText->SetText("sim = "+ MakeString(sim));

        UpdatePointPlot();
//mSegDoc->GotoKeyfr(mCurKeyframe);
//AllHandleNewCursor(Core::Database::LEVEL_FRAME, false);
    }

    virtual void
    StringSelectionEvent(StringSelector* src, int strIndex, void* listenerData)
    {
        mSegDoc->SetConcept(strIndex);
        HandleNewFile();
    }

    /*
    virtual void SliderChangedEvent(Slider *src, int userData)
    {
        mShowMaxSim = src->GetValue()/1000.0f;
        FillPoints();
    }
    */

    virtual void
    ImageSelectionEvent(ImagesWindow* src, int imIndex, void* listenerData)
    {
        /*
        RankTableType* rank = mSimSet->GetRankTable(mCurConcept);
        bool rankIsKeyframe = rank->Size() == mKeyframes->GetNrKeyframes();
        int rankId = rank->Get1(mCurKeyframe);
        int keyfr = (rankIsKeyframe) ? rankId : mKeyframes->GetShotRKF(rankId);
        int shot = mKeyframes->GetShotId(keyfr);
        mSegDoc->GotoKeyfr(keyfr);
        SimTableType* simTable = mSimSet->GetSimTable(mCurConcept);
        std::string truth;
        mInfoText->SetText("rank = " + MakeString(rankId) +
                           ", sim = " + MakeString(simTable->Get1(rankId))
                          );
        AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
        */
    }

    virtual void
    KeyEvent(OglGui::Window* src, int c, int state)
    {
        int oldKeyFr = mCurKeyframe;

        if (c=='p' || c=='P') {
            if ((mPointSize += (c=='P' ? 1 : -1)) < 1)
                mPointSize = 1;
            FillPoints();
        }
        if (c==oglLEFT && --mCurKeyframe < 0)
            mCurKeyframe = 0;
        if (c==oglRIGHT && ++mCurKeyframe > mKeyframes->GetNrKeyframes())
            mCurKeyframe = mKeyframes->GetNrKeyframes()-1;
        if (oldKeyFr != mCurKeyframe)
            UpdateImage();
    }

    virtual void PlotNeedleChanged(PlotNeedle* src, double nX, void* userData)
    {
        if (mCurKeyframe == (int) (mStartKey+nX-1))
        {
            UpdatePointPlot();
            return;
        }
        mCurKeyframe = mStartKey + nX-1;
        if (mCurKeyframe < mStartKey)
            mCurKeyframe = mStartKey;
        if (mCurKeyframe > mStartKey+mNrOfKeys)
            mCurKeyframe = mStartKey+mNrOfKeys;
        UpdateImage();
    }


private:
    void
    UpdatePointPlot()
    {
        if (!mPlotPoints)
            return;

        double nPos = mCurKeyframe-mStartKey+1;
        mPlotNeedle->MoveTo(nPos);

        // Lines below pan the plot to keep the needle in sight
        double panX, panY;
        double l,t,r,b;
        mPlotPoints->GetUserPan(panX, panY);
        mPlotPoints->GetRange(l,t,r,b);
        if (nPos > r || nPos < l)
            mPlotPoints->SetUserPan(panX - (nPos - (nPos>r ? r:l)), panY);
    }

    SegmentationDocument*         mSegDoc;
    SimilarityTableSet*           mSimSet;
    SimTableType*                 mSimTable;
    int                           mCurConcept;
    int                           mCurFile;
    int                           mStartKey;
    int                           mNrOfKeys;
    int                           mCurKeyframe;
    int                           mPointSize;

    double                        mShowMaxSim;

    Core::VideoSet::Keyframes*    mKeyframes;
    Core::ImageSet::ImageSet*     mKeyframeSet;

    StringSelector*               mStringSelector;
    StaticText*                   mInfoText;
    ImagesWindow*                 mImageWnd;
    //Slider*                       mMaxSimSlider;

    Visualization::Plot::Plot*    mPlotPoints;
    Visualization::Plot::Points*  mPoints;
    PlotNeedle*                   mPlotNeedle;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SimilarityPlotNeedleImage, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---