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

---

SimilarityTimeLine.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Show impala concept similarities on a WindowTimeLine.
//
// NOTE: - Assumed that similarities are within range [0..1]
//       - Based on fix 25 fps -> 1 frame 40 ms
// NOTE: Only 13 colors properly chosen, and only 20 colors defined
//       When using more than 20 concepts use AddSimColor
// Author: Richard van Balen

#ifndef Impala_Visualization_SimilarityTimeLine_h
#define Impala_Visualization_SimilarityTimeLine_h

#include "Visualization/TimeLineViewStrip.h"
#include "Visualization/SimilarityTimeLineListener.h"
#include "Core/Table/SimilarityTableSet.h"

static char*
sColorNamesSTL[] = {
    "red",
    "green",
    "blue",
    "magenta",
    "cyan",
    "yellow",
    "orange",
    "teal",
    "brown",
    "tomato",
    "DarkMagenta",
    "SoftBlue",
    "YellowGreen", // below this line colors not chosen optimally
    "PeachPuff", 
    "SaddleBrown",
    "SeaGreen",
    "SkyBlue",
    "Silver",
    "SlateBlue",
    "Violet",
    ""
};


namespace Impala {
namespace Visualization {

class  SimilarityTimeLine :  public TimeLineViewStrip
{
public:
    typedef Core::Table::SimilarityTableSet     SimilarityTableSet;
    typedef SimilarityTableSet::SimTableType    SimTableType;
    typedef std::vector<float>                  FloatVector;
    typedef std::vector<FloatVector*>           Averages;


    SimilarityTimeLine(int x, int y, int w, int h, int nViews) :
        TimeLineViewStrip(x,y,w,h,nViews)
    {
        Init(w,h);
    }

    SimilarityTimeLine(OglGui::Window* parent, int w, int h, int nViews) :
        TimeLineViewStrip(parent,w,h,nViews)
    {
        Init(w,h);
    }

    SimilarityTimeLine(OglGui::Window* parent, int x, int y, int w, int h,
                       int nViews) :
        TimeLineViewStrip(parent,x,y,w,h,nViews)
    {
        Init(w,h);
    }

    void
    SetListener(SimilarityTimeLineListener* listener, void* listenerData = 0)
    {
        mListener = listener;
        mListenerData = listenerData;
    }

    virtual void PublishCurrentChanged()
    {
        if (!mListener)
            return;
        mListener->CurrentChanged(this, mCurrent, mListenerData);
    }

    void SetSimilarityTableSet(SimilarityTableSet* simSet)
    {
        if (mSimSet)
            mVisibleConcepts.clear();
        if ((mSimSet = simSet) == 0)
            return;
        for (int i=0; i<mSimSet->NrTables(); i++)
            mVisibleConcepts.push_back(true);
    }

    void SetAverages(Averages* averages, FloatVector* maxima, FloatVector* means)
    {
        mAverages = averages;
        mMeans = means;
        mMaxima = maxima;
    }

    void AddSimColor(ULONG col)
    {
        mSimColors.push_back(col);
    }

    void SetSimColor(int id, ULONG col)
    {
        if (id > ((int)mSimColors.size())-1)
            return;
        mSimColors[id] = col;
    }

    ULONG GetSimColor(int id)
    {
        if (id > ((int)mSimColors.size())-1)
            return oglBLACK;
        return mSimColors[id];
    }

    int NrColors()
    {
        return mSimColors.size();
    }

    void SetShowSim(int id, bool show)
    {
        if (id<0 || id > ((int)mVisibleConcepts.size())-1)
            return;
        mVisibleConcepts[id] = show;
    }

    bool GetShowSim(int id)
    {
        if (id<0 || id > ((int)mVisibleConcepts.size())-1)
            return false;
        return mVisibleConcepts[id];
    }

    void NeedleOverConcepts()
    {
        OglGui::ZoomShiftRuler::DrawNeedle();
    }

    void PercMaxVal(float perc)       { mPercMax = perc; }
    void PercMaxMeanVal(float perc)   { mPercMaxMean = perc; }
    void ShowClassify(bool mode=true) { mShowClassify = mode; }

    bool PassTest(float sim, float maxim, float mean)
    {
        return (sim > mPercMax*maxim || (sim>mean+(maxim-mean)*mPercMaxMean));
    }

    void DrawHelpLines(int lineMax, int hRange)
    {
        OGC myOGC;
            OGCSave( &myOGC );

        ULONG col = oglGREY;
        SetSolidLineColor(col);
        SetStipple((short)oglDot);
        for (int i=0; i<4; i++)
        {
            int y = lineMax-i*hRange/4;
            DrawLine(24,y,W(),y);
            oglSys.PosColPrintf(mOglWnd,0,y-6,col,"%.2f",1.0f-i*0.25f);
        }
        SetStipple((short)oglSolid);
        if (mHelpLineActive)
        {
            if (mHelpLineY <= lineMax && mHelpLineY >= mAxisY)
            {
                DrawLine(20,mHelpLineY,W()-20,mHelpLineY);
                float val = (mHelpLineY-mAxisY)/(float)hRange;
                int offY = (mHelpLineY - mAxisY > 16) ? -16 : 4;
                oglSys.ShadowPrintf(mOglWnd,mHelpLineX+14,mHelpLineY+offY,
                                    oglDARKGREY,oglWHITE,"%0.2f",val);
            }
        }
        SetStipple((short)oglSolid);
    }

    void DrawAverages(int idx, int startFrame, int endFrame, int inc,
                      bool test, bool norm, int opaq, int hRange, int lineW)
    {
        if (!mAverages || (*mMaxima)[idx] < 0.20 || !mShowClassify)
            return;

        FloatVector*  avgVector = (*mAverages)[idx];
        float         maxim     = (*mMaxima)[idx];
        float         means     = (*mMeans)[idx];
        float         lineY     = H()-(idx+1)*5;

        if (startFrame > (*avgVector).size()-1)
            startFrame = (*avgVector).size()-1;

        if (endFrame > (*avgVector).size()-1)
            endFrame = (*avgVector).size()-1;

        int bInfo[3];
        oglSys.StartBlend(bInfo);

        ULONG col = mSimColors[idx%mSimColors.size()];
        UCHAR r,g,b;
        COLOR2RGB(col,r,g,b);
        UCHAR aR = r, aG = g, aB = b, aA = 0;

        glLineWidth(lineW);
        glBegin(GL_LINE_STRIP);
        for (float i=startFrame; i<endFrame; i+=inc)
        {
            double sim = (*avgVector)[(int)(i+mFrameError)];
            aA = test ? 0 : opaq;
            if (test && PassTest(sim,maxim,means))
            {
                if (norm)
                {
                    float normSim = sim/maxim;
                    aR = normSim * r;
                    aG = normSim * g;
                    aB = normSim * b;
                }
                aA = opaq;
            }
            glColor4ub(aR,aG,aB,aA);
            float x = (float) Unit2Pixel(i*40);
            if (hRange)
                lineY = (mAxisY + 2 + sim * hRange);
            glVertex2f(x,lineY);
        }
        glEnd();
        oglSys.EndBlend(bInfo);
        glLineWidth(1);
    }

    virtual void DisplayFunc()
    {
        OGC myOGC;
            OGCSave( &myOGC );

        TimeLineViewStrip::DisplayFunc();

        if (!mSimSet)
            return;

        int startFrame = FirstVisibleFrame();
        int endFrame   = LastVisibleFrame();

        if (endFrame > mSimSet->TableSize()-mFrameError-1)
            endFrame = mSimSet->TableSize()-mFrameError-1;

        int     range   = endFrame - startFrame;
        int     lineMax = H() - 4 - ((mAverages&&mShowClassify)?65:0);
        int     hRange  = lineMax - mAxisY;
        int     inc     = 1;

        if (range >= cMaxVisPerConcept)
            inc = (int) ((range / (double)cMaxVisPerConcept)+0.5);

        // Experiment to minimize flutter when sampling
        while(startFrame%inc)
            startFrame--;

        float bigW = 5;
        for (int j=0; j<mSimSet->NrTables(); j++)
        {
            DrawAverages(j,startFrame,endFrame,inc,true,true,200,0,bigW);
            DrawAverages(j,startFrame,endFrame,inc,true,false,255,0,1);

            if (!mVisibleConcepts[j])
                continue;

            DrawAverages(j,startFrame,endFrame,inc,false,false,255,hRange,1);
            DrawAverages(j,startFrame,endFrame,inc,true,false,128,hRange,bigW);

            ULONG col = mSimColors[j%mSimColors.size()];
            UCHAR r,g,b;
            COLOR2RGB(col,r,g,b);
            glColor3ub(r,g,b);
            SimTableType* simTable = mSimSet->GetSimTable(j);
            glPointSize(range < 300 ? (range<100?5:3) : 2);
            glBegin(GL_POINTS);
            for (float i=startFrame; i<=endFrame; i+=inc)
            {
                double sim = simTable->Get1(i+mFrameError);
                float  x   = (float) Unit2Pixel(i*40);
                float  y   = (float) (mAxisY + 2 + sim * hRange);
                glVertex2f(x,y);
            }
            glEnd();

        }
        glPointSize(1);
        glLineWidth(1);

        DrawHelpLines(lineMax,hRange);

        NeedleOverConcepts();

        OGCRestore(&myOGC);
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        TimeLineViewStrip::MouseFunc(msg,btn,state,x,y);
        mHelpLineActive = (state==oglLeftButton);
        mHelpLineX = x;
        mHelpLineY = y;
    }

private:

    void Init(int w, int h)
    {
        mListener = 0;
        mSimSet = 0;
        SetStart(0);
        SetSpan(60000);
        mCurrentConcept = 0;
        mShowClassify = true;
        ShowNeedle(false); // We handle the needle ourselves
        SetNeedleColor(oglBLACK);
        SetNeedleUpDownHeight(1000,4);
        mNrColors = 0;
        while( sColorNamesSTL[mNrColors][0] != 0 )
            mSimColors.push_back(OglColorStr(sColorNamesSTL[mNrColors++]));
        mAverages = 0;
        mPercMax = 0.66f;
        mPercMaxMean = 0.25f;
        mHelpLineActive = false;
    }

    static const int            cMaxVisPerConcept = 10000;

    SimilarityTimeLineListener* mListener;
    void*                       mListenerData;

    SimilarityTableSet*         mSimSet;
    std::vector<ULONG>          mSimColors;
    std::vector<bool>           mVisibleConcepts;

Averages* mAverages;
FloatVector* mMaxima;
FloatVector* mMeans;
float       mPercMax;
float       mPercMaxMean;
bool        mShowClassify;
bool        mHelpLineActive;
int         mHelpLineY;
int         mHelpLineX;

    int                         mCurrentConcept;
    int                         mNrColors;
};
} // namespace Visualization
} // namespace Impala
#endif

---