OpticalFlow.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

This program 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 program 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.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef OPTICALFLOW_H_
#define OPTICALFLOW_H_

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <cv.h>
#include <garbagecoll.h>
#include <Pos.h>
#include <linien/linien.h>
#include <DynamicsHelpers.h>

#include <general/OpenCVKalman.h>
#include <general/OpenCVHelpers.h>

class FocusObserver : virtual public ReferenceCount {
public:
    virtual ~FocusObserver() {}
    virtual void FocusNotify(const CvPoint &p) = 0;
};

class FocusObsSupport {
    std::vector<FocusObserver*> observers;    
protected:
    void FireFocusNotification(const CvPoint &p) {
        for (unsigned int i=0; i<observers.size(); i++) {
            observers[i]->FocusNotify(p);
        }
    }
public:
    void AddObserver(FocusObserver *obs) {
        observers.push_back(obs);
    }
};

class OpticalFlow : public FocusObserver {
protected:

    RingBuf<GCPointer<ImageHolder>, 2>  imgBuf;
    
    RingBuf<GCPointer<ImageHolder>, 2>  pyrBuf;

    int numFeatures;
    CvPoint2D32f *prevFeatures;
    CvPoint2D32f *curFeatures;
    char* featStatus;
    void FreeStatusData();
    
    class Particle : public ReferenceCount {
    public:
        Pos<2,double> pos;
        Pos<2,double> vec;
        int numFound;
        
        Particle() : numFound(0) {}
        explicit Particle(const CvPoint2D32f &p)
            : pos(p.x,p.y), numFound(0) {}

        bool Found(const CvPoint2D32f &p);

        bool ToTheOutside(const CvPoint &focus) const {
            return ScalProd(
                Pos<2,double>(pos[0]-focus.x, pos[1]-focus.y),
                vec) > 0.0;
        }
    };
    std::vector<GCPointer<Particle> > particles;
    ExpGlaett<Pos<2,double> > focusOfExpansion;
    
    KalmanFilter<2> kalmanFOE;
    float kalmanState[4];
    
    CvSize imgSize;
    CvPoint focus;
    
    int numCalls;
    
    GCPointer<ImageHolder> eigenBuf; 
    GCPointer<ImageHolder> tempBuf; 
    CvMat* mask; 
    virtual int GetXMin();
    virtual int GetXMax();
    virtual int GetYMin();
    virtual int GetYMax();

    void MaskUseFullArea();
    void MaskUseGridCell(int x, int y,  int lenX, int lenY);
    void SelectFeatures();
public:
    OpticalFlow();
    virtual ~OpticalFlow();
    
    void SetSize(const CvSize &size);

    void SetFocus(const CvPoint &focus);
    void FocusNotify(const CvPoint &p) {
        SetFocus(p);
    }

    void AddImage(IplImage *img) {
        imgBuf.Add(new ImageHolder(img));
    }
    
    void Calc();
    void PrintInfo();
    double GetWinkel();
    void PrintFlowField(IplImage *img);
    void PrintFocus(IplImage *img);
};

#endif /*OPTICALFLOW_H_*/