moFilterManager.h

Go to the documentation of this file.

/*******************************************************************************

                                moFilterManager.h

  ****************************************************************************
  *                                                                          *
  *   This source is free software; you can redistribute it and/or modify    *
  *   it under the terms of the GNU General Public License as published by   *
  *   the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                          *
  *   This code is distributed in the hope that it will be useful, but       *
  *   WITHOUT ANY WARRANTY; without even the implied warranty of             *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
  *   General Public License for more details.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa

*******************************************************************************/

#ifndef __MOFILTERMANAGER_H
#define __MOFILTERMANAGER_H

#include "moTypes.h"
#include "moAbstract.h"
#include "moText.h"
#include "moVideoGraph.h"
#include "moResourceManager.h"
#include "moBuckets.h"
#include "moParam.h"
#include "moMathVector.h"


#define MO_TRACKER_TRACKED 0
#define MO_TRACKER_NOT_FOUND -1
#define MO_TRACKER_SMALL_DET -2
#define MO_TRACKER_MAX_ITERATIONS -3
#define MO_TRACKER_OOB -4
#define MO_TRACKER_LARGE_RESIDUE -5


#undef USE_TUIO
#ifdef USE_TUIO

using namespace TUIO;

//these includes TuioPoint.h TuioTime.h and TuioContainer.h
#include <TUIO/TuioObject.h>
#include <TUIO/TuioCursor.h>

moDeclareExportedDynamicArray( TuioCursor*, moTuioCursorArray );
moDeclareExportedDynamicArray( TuioObject*, moTuioObjectArray );



class LIBMOLDEO_API moTUIOSystemData {

    public:

        moTUIOSystemData();
        virtual ~moTUIOSystemData();
        virtual moVideoFormat& SetVideoFormat( moVideoFormat p_videoformat) { m_VideoFormat = p_videoformat; }
        virtual moVideoFormat& GetVideoFormat() { return m_VideoFormat; }


        virtual int GetCursorCount() { return m_Cursors.Count(); }
        virtual int GetObjectCount()  { return m_Objects.Count(); }

        virtual TuioCursor* GetCursor(int i) { return m_Cursors[i]; }
        virtual moTuioCursorArray& GetCursors()  { return m_Cursors; }

        virtual TuioObject* GetObject(int i)  { return m_Objects[i]; }
        virtual moTuioObjectArray& GetObjects()  { return m_Objects; }


        TuioCursor* addTuioCursor(float xp, float yp);

        void updateTuioCursor(TuioCursor *tcur, float xp, float yp);

        void removeTuioCursor(TuioCursor *tcur);

        void addExternalTuioCursor(TuioCursor *tcur);

        void updateExternalTuioCursor(TuioCursor *tcur);

        void removeExternalTuioCursor(TuioCursor *tcur);





        virtual TuioObject* addTuioObject(int sym, float xp, float yp, float a);

        virtual void updateTuioObject(TuioObject *tobj, float xp, float yp, float a);

        virtual void removeTuioObject(TuioObject *tobj);



        void addExternalTuioObject(TuioObject *tobj);

        void updateExternalTuioObject(TuioObject *tobj);

        void removeExternalTuioObject(TuioObject *tobj);



        virtual void initFrame(TuioTime ttime);

        virtual void commitFrame();


        //virtual void commitFrame();

        virtual long getSessionID();

        virtual long getFrameID();

        virtual TuioTime getFrameTime();

        std::list<TuioObject*> getUntouchedObjects();

        std::list<TuioCursor*> getUntouchedCursors();

        void stopUntouchedMovingObjects();

        void stopUntouchedMovingCursors();

        void removeUntouchedStoppedObjects();

        void removeUntouchedStoppedCursors();

        std::list<TuioObject*> getTuioObjects();


        std::list<TuioCursor*> getTuioCursors();

        TuioObject* getTuioObject(long s_id);

        TuioCursor* getTuioCursor(long s_id);

        TuioObject* getClosestTuioObject(float xp, float yp);

        TuioCursor* getClosestTuioCursor(float xp, float yp);


    private:

        moVideoFormat   m_VideoFormat;

        moTuioCursorArray m_Cursors;
        moTuioObjectArray m_Objects;
        std::list<TuioObject*> objectList;
        std::list<TuioCursor*> cursorList;

        int maxCursorID;
        //moTuioCursorArray m_freeCursorList;
        //moTuioObjectArray m_freeCursorBuffer;
        std::list<TuioCursor*> freeCursorList;
        std::list<TuioCursor*> freeCursorBuffer;

        bool full_update;
        int update_interval;
        bool periodic_update;

        long currentFrame;
        TuioTime currentFrameTime;
        bool updateObject, updateCursor;
        long lastCursorUpdate, lastObjectUpdate;

        long sessionID;
        bool verbose;

};
#endif

class moTrackerFeature;

moDeclareExportedDynamicArray( moTrackerFeature*, moTrackerFeatureArray );


class LIBMOLDEO_API moTrackerFeature { //de GpuKLT_Feature

    public:

    bool                    is_object;              
    bool                    is_parent;              
    bool                    is_cursor;              
    long                    stime;              
    long                    sframe;              
    long                    utime;              
    long                    uframe;              

    moTrackerFeatureArray   FeaturesCaptured;
    moTrackerFeature*       Parent;

    float                   x,y;                     
    float                   normx, normy;            
    float                   tr_x, tr_y;              
    float                   v_x, v_y;                
    float                   vp_x, vp_y;              
    float                   a_x, a_y;                
    float                   ap_x, ap_y;                
    float         t_x, t_y;                 
    bool                    valid;                   
    int                     val;                     
    moVector2fpArray         track;                  

    moTrackerFeature();

    moTrackerFeature & operator = (const moTrackerFeature &src);

    virtual ~moTrackerFeature();

    void print();

    void printTracks();

    int updatePos(float kltConvergeThreshold, float kltSSDthresh, int kltborder, float delta, float res, float d1, float d2, float w, float h);
};


class LIBMOLDEO_API moTrackerInstanceRecord {

  public:
    moTrackerInstanceRecord();
    virtual ~moTrackerInstanceRecord() {}
    moTrackerInstanceRecord & operator = (const moTrackerInstanceRecord &src);

    long            m_Tick;


        moVector2f      m_Barycenter;
        moVector2f      m_BarycenterMotion;
        moVector2f      m_BarycenterAcceleration;

        moVector2f      m_Variance;
        moVector2f      m_SpeedVariance;
        moVector2f      m_AccelerationVariance;
        moVector4f      m_BoundingRectangle;

    double          m_AbsoluteSpeedAverage;
    double          m_AbsoluteAccelerationAverage;
    double          m_AbsoluteTorqueAverage; 
    double          m_BoundingRectangleAngle;
    int             m_BlobCandidates;
        double          m_SurfaceCovered;

        int             m_ValidFeatures;
        int             m_DeltaValidFeatures;
        int             m_nFeatures;

        moVector2f      m_Max;
        moVector2f      m_Min;

};

moDeclareExportedDynamicArray( moTrackerInstanceRecord, moTrackerInstanceRecords );

#include "moTimeManager.h"

class LIBMOLDEO_API moTrackerSystemHistory : public moAbstract {
    public:
      moTrackerSystemHistory();
      virtual ~moTrackerSystemHistory();



      void  StartRecording( long maxtime = 60000, long granularity = 30 );
      bool  IsRecording() {return m_Timer.Started(); }
      void  Record( moTrackerInstanceRecord& p_InstanceRecord, long p_Tick = -1 );
      void  PauseRecording();
      void  ContinueRecording();
      void  StopRecording();
      void  Reset();
      long  CountRecords();
      bool  SaveToFile( moText filename );
      bool  SaveToXML( moText filename );
      moTrackerInstanceRecord& Get( int index );

    public:

      long        m_MaxTime;
      long        m_Granularity;
      long        m_nRecorded;
      double      m_RecordFactor;

      moTimer                     m_Timer;
      moTrackerInstanceRecords    m_History;
};


class LIBMOLDEO_API moTrackerSystemData {
    public:

    moTrackerSystemData();
    moTrackerSystemData( int ZoneW, int ZoneH );
    moTrackerSystemData( int ZoneW, int ZoneH, int ZoneCW, int ZoneCH );
    virtual ~moTrackerSystemData();

        virtual int GetFeaturesCount();

    virtual int GetValidFeatures();
    virtual int GetDeltaValidFeatures();

        virtual moVector2f GetBarycenter();

        virtual moVector2f GetBarycenterMotion();

        virtual moVector2f GetBarycenterAcceleration();

        virtual moVector2f GetVariance();

        virtual moVector2f GetSpeedVariance();

        virtual moVector2f GetAccelerationVariance();

        virtual moVector4f GetBoundingRectangle();

        virtual moVector2f GetMax();
        virtual moVector2f GetMin();
        virtual void SetMax( float x, float y );
        virtual void SetMin( float x, float y );


        virtual moTrackerFeature* GetFeature(int i);
        virtual moTrackerFeatureArray& GetFeatures();

        virtual moVideoFormat& GetVideoFormat() { return m_VideoFormat; }

        virtual void SetBarycenter( float b_x, float b_y) { m_ActualRecord.m_Barycenter = moVector2f(b_x,b_y); }
        virtual void SetBarycenterMotion( float b_x, float b_y) { m_ActualRecord.m_BarycenterMotion = moVector2f(b_x,b_y); }
        virtual void SetBarycenterAcceleration( float b_x, float b_y) { m_ActualRecord.m_BarycenterAcceleration = moVector2f(b_x,b_y); }

        virtual void SetVariance( float v_x, float v_y) { m_ActualRecord.m_Variance = moVector2f(v_x,v_y); }
        virtual void SetSpeedVariance( float v_x, float v_y) { m_ActualRecord.m_SpeedVariance = moVector2f(v_x,v_y); }
        virtual void SetAccelerationVariance( float v_x, float v_y) { m_ActualRecord.m_AccelerationVariance = moVector2f(v_x,v_y); }
        virtual void SetBoundingRectangle( float r_x, float r_y, float s_x, float s_y ) { m_ActualRecord.m_BoundingRectangle = moVector4f(r_x,r_y,s_x,s_y); }

        virtual void SetValidFeatures( int validfeatures) { m_ActualRecord.m_ValidFeatures = validfeatures; }
        virtual void SetDeltaValidFeatures( int deltavalidfeatures) { m_ActualRecord.m_DeltaValidFeatures = deltavalidfeatures; }

        virtual void SetAbsoluteSpeedAverage( float speedaverage ) { m_ActualRecord.m_AbsoluteSpeedAverage = speedaverage; }
        virtual void SetAbsoluteAccelerationAverage( float accaverage ) { m_ActualRecord.m_AbsoluteAccelerationAverage = accaverage; }
        virtual void SetAbsoluteTorqueAverage( float toraverage ) { m_ActualRecord.m_AbsoluteTorqueAverage = toraverage; }


    virtual int PositionToZone( float x, float y );

    virtual moVector2f ZoneToPosition( int zone );


    virtual int PositionToZoneC( float x, float y );

    virtual moVector2f ZoneToPositionC( int zone );

    virtual void SetPositionMatrix( float x, float y, int nfeatures );
    virtual void SetPositionMatrix( moVector2f pos, int nfeatures );
    virtual int GetPositionMatrix( float x, float y );
    virtual int GetPositionMatrix( moVector2f pos );

    virtual void SetMotionMatrix( float x, float y, int nfeatures );
    virtual void SetMotionMatrix( moVector2f pos,  int nfeatures );
    virtual int GetMotionMatrix( float x, float y );
    virtual int GetMotionMatrix( moVector2f pos );

    virtual void SetAccelerationMatrix( float x, float y, int nfeatures );
    virtual void SetAccelerationMatrix( moVector2f pos,  int nfeatures );
    virtual int GetAccelerationMatrix( float x, float y );
    virtual int GetAccelerationMatrix( moVector2f pos );

    virtual void SetPositionMatrixC( float x, float y, int nfeatures );
    virtual int GetPositionMatrixC( float x, float y );
    virtual int GetPositionMatrixC( moVector2f pos );
    virtual int GetPositionMatrixC( int zone );

    virtual void SetMotionMatrixC( float x, float y, int nfeatures );
    virtual int GetMotionMatrixC( float x, float y );
    virtual int GetMotionMatrixC( moVector2f pos );
    virtual int GetMotionMatrixC( int zone );

    virtual void ResetMatrix();
    virtual void DrawFeatures( float w, float h, float offsetx, float offsety );

    virtual void SetMaxFeatures( int p_nFeatures ) { m_ActualRecord.m_nFeatures = p_nFeatures; }
    virtual int GetMaxFeatures() { return m_ActualRecord.m_nFeatures; }

    void        Record();
    moTrackerSystemHistory&   GetHistory() { return m_History; }

    int             m_ZoneW;
    int             m_ZoneH;
    int             m_ZoneCW;
    int             m_ZoneCH;
    int             m_Zones;
    int             m_ZonesC;
    float**         m_Distancias;
    int**           m_Pares;
    int             nPares;

    protected:

    float           _zonewf;
    float           _zonehf;
    float           _zonecwf;
    float           _zonechf;

    moVideoFormat   m_VideoFormat;

    moTrackerFeatureArray m_Features;

    moTrackerInstanceRecord m_ActualRecord;

    moTrackerSystemHistory  m_History;
        int             *m_PositionMatrix; 
        int             *m_MotionMatrix; 
        int             *m_AccelerationMatrix; 

        int             *m_CircularPositionMatrix; 
        int             *m_CircularMotionMatrix; 

};


class LIBMOLDEO_API moFilterManager : public moResource
{
    public:

        moFilterManager();
        virtual ~moFilterManager();

        virtual MOboolean Init();
        virtual MOboolean Finish();

    protected:


};


#endif