ActCvImpl.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 ACTCVIMPL_H_
#define ACTCVIMPL_H_

#if HAVE_ICE

#include <string>
#include <map>
#include <sstream>
#include <Ice/Ice.h>
#include <IceUtil/IceUtil.h>

#include <garbagecoll.h>
#include <GCString.h>
#include <Threads/Mutex.h>

#include <Robot.h>
#include <vision/ActCvSource.h>

#include "ActCV.h"


class ActCvImpl : public ActCV::Vision, public ActCvObserver {
    mhthreads::Mutex mutex;
    
    std::string combinedData;
    
    std::map<std::string, std::string> data;

    void ComputeCombinedData() {
        std::ostringstream ostr;
        ostr << "(";
        for (std::map<std::string, std::string>::iterator i=data.begin();
            i!=data.end();i++) {
            ostr << "("
                << i->first << " "
                << i->second << ")";
        }
        ostr << ")";
        combinedData=ostr.str();
    }
public:
    ActCvImpl() : combinedData("()") {
    }
    std::string GetCurrent(const Ice::Current&) {
        mutex.Enter();
        std::string result = combinedData;
        mutex.Leave();
        return result;
    }
    
    void NewVisionNotification(const ActCvSource &src) {
        mutex.Enter();
        data[src.GetTypeName()]=src.GetResult();
        ComputeCombinedData();
        mutex.Leave();
    }
    
    const char* GetName() const {
        return "vision";
    }
};

class KeyboardImpl : public ActCV::Keyboard {
    Robot robot;
    bool isAttached;
public:
    KeyboardImpl() : isAttached(false) {
        robot.SetAutoDelay(50);
    }
    ~KeyboardImpl() {}
    void PressKey(int keyCode, const Ice::Current&) {
        std::cout << "received key " << keyCode << std::endl;
        if (!isAttached) {
            robot.AttachCurrentThread();
            isAttached=true;
        }
        robot.KeyPress(keyCode);
        robot.KeyRelease(keyCode);
    }    

    const char* GetName() const {
        return "keyboard";
    }
};

class IceServer {
    friend struct IceServerAutoStop;
    static IceServer *singleInstance;
    IceServer() : adapterName("ActCV") {
        Start();
    }

    void Start() {
        try {
            communicator = Ice::initialize();
            adapter = 
                communicator->createObjectAdapterWithEndpoints(adapterName, "tcp -p 34985");
            adapter->add(&visionImpl, communicator->stringToIdentity(visionImpl.GetName()));
            adapter->add(&keyboardImpl, communicator->stringToIdentity(keyboardImpl.GetName()));
            adapter->activate();
        } catch(const Ice::Exception& ex) {
            std::cerr << ex << std::endl;
        }
    }

    Ice::CommunicatorPtr communicator;
    Ice::ObjectAdapterPtr adapter;
    
    std::string adapterName;
    
    ActCvImpl visionImpl;
    KeyboardImpl keyboardImpl;

public:

    static IceServer* GetInstance() {
        if (singleInstance==NULL) {
            singleInstance=new IceServer();
        }
        return singleInstance;
    }

    void Stop() {
        communicator->destroy();
        //communicator->waitForShutdown();
    }
    
    ActCvObserver* GetVisionObserver() {
        return &visionImpl;
    }
};

class IceClient {
    Ice::CommunicatorPtr communicator;
    ActCV::KeyboardPrx keyboard;
public:
    IceClient() : keyboard(0), communicator(0) {}
    void ConnectTo(const char* name, int port); 
    void SendKey(int keyCode);     
};

#endif // HAVE_ICE

#endif /*ACTCVIMPL_H_*/