main.cpp

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
*/

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>

#include <config.h>

#if HAVE_ICE
# include "IceComm/ActCvImpl.h"
#endif

#include <color/RGBtoHSV.h>
#include <highgui.h>

#include <mhexcptn.h>
#include <garbagecoll.h>
#include <GCString.h>
#include <statistiken.h>

#include "Robot.h"
#include "oflow/OpticalFlow.h"

#include "tests/TestFrameSource.h"

#include "vision/RobotFrameSource.h"
#include "vision/OpenCVFrameSource.h"
#include "vision/ImageFrameSource.h"
#include "vision/QtFrameSource.h"

#include "tcpserver/tcpserver.h"

#include "FrameLoop.h"
#include "Options.h"
#include "config.h"

#include <DynamicsHelpers.h>

#include <stdlib.h>
#include <time.h>

using namespace std;

ostream& operator << (ostream &o, const struct HSV &hsv) {
    o << hsv.h << " "
        << static_cast<int>(hsv.s) << " "
        << static_cast<int>(hsv.v);
    return o;
}

void PrintImageInfo(const IplImage *img) {
    cout << "size: " << img->width << "x" << img->height << endl;
    cout << "channels: " << img->nChannels << endl;
    cout << "depth: " << img->depth << endl;
}

vector<CvPoint> GetBigCorrPoints(const IplImage *img, double threshold=.999) {
    vector<CvPoint> result;

    for (int x=0;x<img->width;x++) {
        for (int y=0;y<img->height;y++) {
            if (cvGetReal2D(img, y, x)>threshold) {
                result.push_back(cvPoint(x,y));
            }
        }
    }
    return result;
}

CvPoint GetRandomTarget(const IplImage *img) {
    vector<CvPoint> points = GetBigCorrPoints(img);
    if (points.size()==0) return cvPoint(0,0);
    
    return points[rand()%points.size()];    
}



void PrintBigCorrs(const IplImage *img) {
    vector<CvPoint> points = GetBigCorrPoints(img);
    for (unsigned int i=0;i<points.size();i++) {
        cout << points[i] << endl;
    }
}


#define MAX_FRAME_COUNT -1


void Usage(Options *options) {
    cout << PACKAGE_STRING << endl
         << "Usage: " << endl;

    for (unsigned int i=0;i<options->size();i++) {
        options->at(i)->Describe(cout);   
    }
}

struct BMFontInfo {
    int code;
    int bmId;
    int pos[2];
    int size[2];
};

istream& operator >> (istream &in, BMFontInfo &bmfi) {
    in >> bmfi.code
       >> bmfi.bmId
       >> bmfi.pos[0] >> bmfi.pos[1] 
       >> bmfi.size[0] >> bmfi.size[1];
    return in;
}

int main(int argc, char** argv) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    srand((unsigned) time(nullptr));
    
    cout << "number of threads: " << cvGetNumThreads() << endl;

    bool showWnd = true;

    SourceOption srcOpt;
    AlgOption algOpt;
    FpsOption fpsOpt;
    ServerOption servOpt;
    
    Options options;
    options.push_back(&srcOpt);
    options.push_back(&algOpt);
    options.push_back(&fpsOpt);
    options.push_back(&servOpt);

    for (int i=1; i<argc; i++) {
        options.Parse(argv[i]);
    }

    ActCvObserver *visionObserver=0;
    
    if (servOpt.useServer) {
#if HAVE_ICE
        IceServer* iceServer = IceServer::GetInstance();
        cout << "IceServer started" << endl;
        visionObserver = IceServer::GetInstance()->GetVisionObserver();
        for (;;) {
            // nothing
        }
#else
        cerr << "IceServer is not available. Please recompile" << endl;
        return 1;
#endif
    }

    if (srcOpt.source == SourceOption::s_none) {
        Usage(&options);
        return -1;
    }
     
    GCPointer<FrameLoop> frameLoop = new FrameLoopImpl();
    switch (algOpt.algorithm) {
    case a_match:
        //frameLoop->AddObserver(new MatchObs("imgs/objects.txt"));
        frameLoop->AddObserver(new MatchContourObs());
        frameLoop->AddObserver(new FrameObsWindow("input video"));
        break;
    case a_oflow:
        {
            GCPointer<OFlowObs> flow = new OFlowObs();
            frameLoop->AddObserver(&*flow);
            if (visionObserver) flow->AddObserver(visionObserver);
        }
        break;
    case a_lines:
        frameLoop->AddObserver(new LineObs());
        break;
    case a_text:
        frameLoop->AddObserver(new TextObs());
        break;
    case a_color:
        //frameLoop->AddObserver(new ColorObs("hand.png"));
        frameLoop->AddObserver(new DiffObs());
        break;
    default:
#if 0
        break;
#else
        Usage(&options);
        return -1;
#endif
    }    
    
    if (fpsOpt.calcFps) {    
        frameLoop->AddObserver(new FpsFrameObs());
    }
    
    cout << "Press any key to exit" << endl;
    
    switch (srcOpt.source) {
    case SourceOption::s_robot:
    {
#if 1
        GCPointer<FrameSource> qtFS
            = QtFrameSource::QtSourceFactory(nullptr);
        frameLoop->LoopUntilKeyPress(&*qtFS);
#else
        Robot robot;
        RobotFrameSource robotFS(&robot);
        robotFS.SetSize(0,50,
                        robot.GetScreenWidth()/2-1,robot.GetScreenHeight()/2-1);
        frameLoop->LoopUntilKeyPress(&robotFS);
#endif
        break;
    }
    case SourceOption::s_qtwebkit:
    {
        // assume last option is the url
        GCPointer<FrameSource> qtFS
            = QtFrameSource::QtSourceFactory(argv[argc-1]);
        frameLoop->LoopUntilKeyPress(&*qtFS);
        break;
    }
    case SourceOption::s_cam:
    {
        GCPointer<OpenCVFrameSource> camFS
            = OpenCVFrameSource::CameraSourceFactory(0);
        frameLoop->LoopUntilKeyPress(&*camFS);
        break;
    }   
    case SourceOption::s_file:
    {
        // assume last option is the file name 
        GCPointer<OpenCVFrameSource> fileFS
            = OpenCVFrameSource::FileSourceFactory(argv[argc-1]);
        frameLoop->LoopUntilKeyPress(&*fileFS);
        break;
    }
    case SourceOption::s_singleImage:
    {
        // assume last option is the file name
        GCPointer<ImageFrameSource> fileFS
            = ImageFrameSource::ImageSourceFactory(argv[argc-1]);
        frameLoop->LoopUntilKeyPress(&*fileFS);
        break;
    }
    case SourceOption::s_test:
    {
        TestFrameSource testFS(cvSize(400,300));
        frameLoop->LoopUntilKeyPress(&testFS);
        break;
    }
    case SourceOption::s_testline:
    {
        //TestLineFrameSource testFS(cvSize(400,200));
        TestLineFSStaticErr testFS(cvSize(400,200));
        frameLoop->LoopUntilKeyPress(&testFS);
        break;
    }
    }
       

    MHDBGMSG(__FILE__,__LINE__,"Success - Bye");
    return 0;
}