server-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 <map>
#include <thread>

// MH 20110313 TODO check OS X compability
#ifdef _WINDOWS
#define DLLFUNC __declspec(dllexport)
#else
#define DLLFUNC
#endif

#include <vision/FrameSource.h>
#include <vision/QtFrameSource.h>
#include <vision/RobotFrameSource.h>
#include <vision/OpenCVFrameSource.h>
#include <vision/ImageFrameSource.h>
#include <Robot.h>

#include <Threads/Condition.h>
#include <Threads/ThreadSafeQueue.h>
 
#include <tests/TestFrameSource.h>

#include <FrameLoop.h>

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

#include "ResultHolder.h"

using namespace std;
using namespace mhthreads;

// --------------------------------------------------------------------
// globals

GCPointer<FrameSource> frameSource = nullptr;
Robot *robot = nullptr;
QtFrameSource *qt = nullptr;


GCPointer<GCString> frameSourceFileName;

GCPointer<FrameLoop> frameLoop;

GCPointer<LineObs> lineObs;
GCPointer<ResultHolder<Line> > lineResult;


GCPointer<GCString> matchDefFileName;
GCPointer<MatchObs> matchObs;
GCPointer<ResultHolder<ObjectPosition> > matchResult;


GCPointer<TextObs> textObs;
GCPointer<ResultHolder<ObjectPosition> > textResult;


GCPointer<AttendedLocObs> attLocObs;

bool exitFlag=false;
std::mutex threadMutex;

thread *bgThread = nullptr;

struct Job {
    void (*nullary_fn)();
    void (*unary_fn)(int);
    int val;

    mhthreads::Condition *completed;

    Job() : nullary_fn(0), unary_fn(0), val(0), completed(0) {}
    Job(void (*nfn)()) : nullary_fn(nfn), unary_fn(0), val(0), completed(0) {}
    Job(void (*ufn)(int), int v) : nullary_fn(0), unary_fn(ufn), val(v), completed(0) {}
    Job(void (*nfn)(),mhthreads::Condition *c) 
        : nullary_fn(nfn), unary_fn(0), val(0), completed(c) {}
    Job(void (*ufn)(int), int v, mhthreads::Condition *c) 
        : nullary_fn(0), unary_fn(ufn), val(v), completed(c) {}
};
ThreadSafeQueue<Job> jobs;

void SetUpLoopInternal() {
    lock_guard<mutex> lock(threadMutex);
    frameLoop = new FrameLoopImpl();
    attLocObs = new AttendedLocObs();
    frameLoop->AddObserver(&*attLocObs);
}

void TearDownLoopInternal() {
    lock_guard<mutex> lock(threadMutex);
    frameLoop = nullptr;
    attLocObs = nullptr;
    lineObs = nullptr;
    matchObs = nullptr;
    textObs = nullptr;
}

void SelectSourceInternal(int vidSource) {
    lock_guard<mutex> lock(threadMutex);

    video_source vs = static_cast<video_source>(vidSource);

    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    switch(vs) {
    case s_robot:
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
#if 1
        frameSource = QtFrameSource::QtSourceFactory(nullptr);
#else
        if (robot==nullptr) {
#if 1
            robot = new Robot();
            RobotFrameSource *robotFS = new RobotFrameSource(robot);
            robotFS->SetSize(0,50,
                robot->GetScreenWidth()/2-1,
                robot->GetScreenHeight()/2-1);
            frameSource=robotFS;
#else
            // test code
            JVM *jvm = new JVM();
            delete jvm; 
            frameSource = new TestFrameSource(cvSize(400,300));
#endif            
        }
#endif
        break;
    case s_cam:
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        frameSource = OpenCVFrameSource::CameraSourceFactory(0);
        break;
    case s_file:
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        frameSource = OpenCVFrameSource::FileSourceFactory(frameSourceFileName->GetString());
        break;
    case s_web:
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        frameSource = QtFrameSource::QtSourceFactory(frameSourceFileName->GetString());
        qt = static_cast<QtFrameSource*>(&*frameSource);
        break;
    case s_singleImage:
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        frameSource = ImageFrameSource::ImageSourceFactory(frameSourceFileName->GetString());
        break;
    case s_test:
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        frameSource = new TestFrameSource(cvSize(400,300));
        break;
    }
    
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}

extern "C" DLLFUNC
void SelectSource(video_source vs) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
#if 0
    SelectSourceInternal(vs);
#else
    mhthreads::Condition waitForCompletion;
    jobs.push(Job(&SelectSourceInternal, vs, &waitForCompletion));
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    waitForCompletion.Wait(); // Race Condition here :(
#endif
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}

extern "C" DLLFUNC
void SelectFileBasedSource(const char *filename, video_source vs)
{
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    // copy name to static variable
    frameSourceFileName = new GCString(filename);
    mhthreads::Condition waitForCompletion;
    jobs.push(Job(&SelectSourceInternal, vs, &waitForCompletion));
    waitForCompletion.Wait(); // Race Condition here :(

    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}


void ReleaseSourceInternal() {
    lock_guard<mutex> lock(threadMutex);

    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    if(&*frameSource == qt) {
        qt = nullptr;
    }
    frameSource = nullptr;
#if 0
    frameLoop = nullptr;
    lineObs = nullptr;
    attLocObs = nullptr;
    // Problem: AttachCurrentThread aufgerufen!
    if (robot) {
        delete robot;
        robot=nullptr;
    }
#endif    
    // highgui ein wenig laufen lassen
    cvWaitKey(50);
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}

extern "C" DLLFUNC
void ReleaseSource() {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    mhthreads::Condition waitForCompletion;
    jobs.push(Job(&ReleaseSourceInternal, &waitForCompletion));
    waitForCompletion.Wait(); // Race Condition here :(
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}


static void BGFunc() {

    SetUpLoopInternal();

    for (;;) {

        {
            lock_guard<mutex> lock(threadMutex);
            if (exitFlag) {
                break;
            }
        }

        while (!jobs.empty()) {
            Job job=jobs.pop();
            if (job.nullary_fn) (* job.nullary_fn)();
            if (job.unary_fn) (* job.unary_fn)(job.val);

            if (job.completed) job.completed->Signal();
        }


        if(frameSource && (lineObs || textObs || matchObs)) {
            lock_guard<mutex> lock(threadMutex);
            if (frameSource) frameLoop->SingleFrame(&*frameSource);
        }
    }    

    TearDownLoopInternal();
}

extern "C" DLLFUNC
void ActCvInit() {
    lock_guard<mutex> lock(threadMutex);

    if(bgThread != nullptr) {
        MHDBGMSG(__FILE__,__LINE__,"background thread is already running");
        return;
    }

    exitFlag=false;
    bgThread = new thread(BGFunc);
}

extern "C" DLLFUNC
void WaitForNextFrame() {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);

    try {
        frameLoop->WaitForNextFrame();
    } catch (...) {
        // no new frame
    }
}

extern "C" DLLFUNC
void ActCvDeInit() {

    {
        lock_guard<mutex> lock(threadMutex);
        if(bgThread == nullptr || !bgThread->joinable()) {
            return;
        }
        exitFlag=true;
    }

    bgThread->join();
    delete bgThread;

    bgThread = nullptr;
}

void AddRecognitionInternal(int cvAlgo) {
    cv_algorithm a = static_cast<cv_algorithm>(cvAlgo);

    lock_guard<mutex> lock(threadMutex);

    switch (a) {
    case a_match:
        if (&*matchDefFileName == 0) throw runtime_error("Match definition filename not set");
        if (&*matchObs==nullptr) matchObs = new MatchObs(matchDefFileName->GetString());
        frameLoop->AddObserver(&*matchObs);
        frameLoop->AddObserver(new FrameObsWindow("input video"));
        break;
    case a_text:
        if (&*textObs==nullptr) textObs = new TextObs();
        frameLoop->AddObserver(&*textObs);
        break;
    case a_oflow:
        frameLoop->AddObserver(new OFlowObs());
        break;
    case a_lines:
        if (&*lineObs==nullptr) lineObs = new LineObs();
        frameLoop->AddObserver(&*lineObs);
        //lineObs = &*(frameLoop->FindObserver(lineObs->GetName()));
        break;
    }   
}

extern "C" DLLFUNC
void AddRecognition(cv_algorithm a) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
#if 0
    AddRecognitionInternal(a);
#else
    mhthreads::Condition waitForCompletion;
    jobs.push(Job(&AddRecognitionInternal, a, &waitForCompletion));
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    waitForCompletion.Wait(); // Race Condition here :(
#endif
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}

extern "C" DLLFUNC
void SetMatchDefFile(const char *s) {
    matchDefFileName = new GCString(s);
}


extern "C" DLLFUNC
void RemoveRecognition(cv_algorithm a) {
}

extern "C" DLLFUNC
void UpdateAttendedLoc(int x, int y) {
#if 1
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    attLocObs->UpdateAttendedLoc(x,y);
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
#endif    
}


extern "C" DLLFUNC
void MoveMouseTo(int x, int y) {
    if(qt) {
        qt->SetMousePos(x,y);
    }
    attLocObs->UpdateMousePos(x,y);
}


extern "C" DLLFUNC
void MouseClick(int button) {
    if(qt) {
        qt->DoClick(button);
    }
}

extern "C" DLLFUNC
void PressKey(int key) {
    if(qt) {
        qt->DoPressKey(key);
    }
}

// - line grabbing --------------------------------------------------
extern "C" DLLFUNC
int FindFirstLine() {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    if (&*lineObs == nullptr) {
        MHDBGMSG(__FILE__,__LINE__,"no line observer");
        return 0;
    }
    if (&*lineResult == nullptr) {
        lineResult = new ResultHolder<Line>(&*lineObs);
    }
    
    return lineResult->FindFirst();
}

extern "C" DLLFUNC
int FindNextLine(int handle, struct Line *line) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    return lineResult->FindNext(handle, line);
}

extern "C" DLLFUNC
void LineFindFinish(int handle) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    lineResult->FindFinish(handle);
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}

 // - matching ------------------------------------------------------

extern "C" DLLFUNC
int FindFirstMatch() {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    if (&*matchObs == nullptr) return 0;
    if (&*matchResult == nullptr) {
        matchResult = new ResultHolder<ObjectPosition>(&*matchObs);
    }
    
    return matchResult->FindFirst();
}

extern "C" DLLFUNC
int FindNextMatch(int handle, struct ObjectPosition *pos) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    return matchResult->FindNext(handle, pos);
}

extern "C" DLLFUNC
void MatchFindFinish(int handle) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    matchResult->FindFinish(handle);
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}


// - textual features ------------------------------------------------------

extern "C" DLLFUNC
int FindFirstText() {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    if (&*textObs == nullptr) return 0;
    if (&*textResult == nullptr) {
        textResult = new ResultHolder<ObjectPosition>(&*textObs);
    }
    
    return textResult->FindFirst();
}

extern "C" DLLFUNC
int FindNextText(int handle, struct ObjectPosition *pos) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    return textResult->FindNext(handle, pos);
}

extern "C" DLLFUNC
void TextFindFinish(int handle) {
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    textResult->FindFinish(handle);
    MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
}
    
// usw.