FrameLoop.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 FRAMELOOP_H_
#define FRAMELOOP_H_

#include <vector>
#include <map>
#include <iostream>

#include <mhexcptn.h>
#include <DynamicsHelpers.h>
#include <GCString.h>

#if HAVE_ICE
# include <IceComm/ActCvImpl.h>
#endif

#include <Threads/Condition.h>
#include <Threads/Mutex.h>

#include <vision/FrameSource.h>
#include <vision/FrameObserver.h>

#include <oflow/OpticalFlow.h>

#include <cv.h>
#include <highgui.h>

#include "Matcher.h"

#include <tcpclient/TcpClient.h>

extern "C" {
#include "server/ACT-CV.i"
}

#include "server/ResultHolder.h"


class FrameLoop : virtual public ReferenceCount, public FrameObsSupport {
protected:
public:
    virtual void Loop(FrameSource *frameSource) =0;
    virtual void LoopUntilKeyPress(FrameSource *frameSource) =0;
    virtual void LoopNFrames(FrameSource *frameSource, int nFrames) =0;
    virtual void SingleFrame(FrameSource *frameSource) =0;

    virtual void WaitForFirstFrame() =0;
    virtual void WaitForNextFrame() =0;
};

class FrameLoopImpl : public FrameLoop {
    mhthreads::Condition newFrame;
    std::vector<RegionInfo> regions;
#define WAIT_TIME 10    
public:
    void Loop(FrameSource *frameSource){
        for (;;) {
            MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
            IplImage *img = frameSource->GetNextFrame();
            FireFrameNotification(img,frameSource->GetFrameNr());
            if (img==nullptr) break;
            cvWaitKey(WAIT_TIME);
            newFrame.Signal();
        }        
    }
    void LoopUntilKeyPress(FrameSource *frameSource) {
        for (;;) {
            IplImage *img = frameSource->GetNextFrame();
            FireFrameNotification(img,frameSource->GetFrameNr());
            std::vector<RegionInfo> curRegions;
            curRegions.reserve(frameSource->GetNumInfos());
            for(size_t u=0; u<frameSource->GetNumInfos(); ++u) {
                curRegions.push_back(frameSource->GetInfo(u));
            }
            std::sort(curRegions.begin(), curRegions.end());
            if(curRegions != regions) {
                regions = curRegions;
                FireRegionNotification(regions);
            }
            if (img==nullptr) break;
            if (cvWaitKey(WAIT_TIME) >= 0) break;
            newFrame.Signal();
        }        
    }
    void LoopNFrames(FrameSource *frameSource, int nFrames) {
        for (int i=0;i<nFrames;i++) {
            IplImage *img = frameSource->GetNextFrame();
            FireFrameNotification(img,frameSource->GetFrameNr());
            if (img==nullptr) break;
            cvWaitKey(WAIT_TIME);
            newFrame.Signal();
        }        
    }
    void SingleFrame(FrameSource *frameSource) {
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        IplImage *img = frameSource->GetNextFrame();
        MHDBGMSG_P(__FILE__,__LINE__,"NextFrame",img);
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        FireFrameNotification(img,frameSource->GetFrameNr());
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        std::vector<RegionInfo> curRegions;
        curRegions.reserve(frameSource->GetNumInfos());
        for(size_t u=0; u<frameSource->GetNumInfos(); ++u) {
            curRegions.push_back(frameSource->GetInfo(u));
        }
        std::sort(curRegions.begin(), curRegions.end());
        if(curRegions != regions) {
            regions = curRegions;
            FireRegionNotification(regions);
        }
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        cvWaitKey(5);
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        newFrame.Signal();
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    }
    void WaitForFirstFrame() {
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        newFrame.TimedWait(5*60,0);
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    }
    void WaitForNextFrame() {
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        
        int res=newFrame.TimedWait(30,0);
        //int res=newFrame.Wait();
        if (res!=0) {
            // no new frame! 110 = ETIMEDOUT
            MHDBGMSG_I(__FILE__,__LINE__,"Error code:",res);
            throw std::runtime_error("no new frame");
        }
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    }
};


#endif /*FRAMELOOP_H_*/