/home/fwph/code/wurde/modules/visionModule/visionModule.H

Go to the documentation of this file.

#ifndef _VISION_MODULE_H
#define _VISION_MODULE_H

#include <Capability.H>
#include <opencv/cv.h>
#include <vector>
#include <map>
#include <WURDECam.H>
#include <string>
#include <Logger.H>
#include <ImageSource.H>
#include <dlfcn.h>

namespace WURDEVision {

       //       typedef std::pair<IplImage *,WURDE::Time> WURDEImage;

       typedef struct CameraConfig_t {
               std::string name;
               std::map<std::string,std::string> options;
       } CameraConfig;

       std::vector<CameraConfig> parseCameraFile(std::string config);

       typedef struct {
              std::string name;
              std::string type;
              std::multimap<std::string,std::string> options;
              std::vector<CameraConfig> cameras;
       } OperatorConfig;

       typedef struct {
              std::vector<CameraConfig> cameras;
              std::vector<OperatorConfig> operators;
              std::vector<std::string> plugins;
       } VisionModuleConfig;

       class VisionOperator {
       public:
              VisionOperator(std::string name){m_name=name;};
              ~VisionOperator(){}
              
              virtual void initOperator()=0;

              virtual void runOperator(WURDE::WURDEImage image)=0;
              
              virtual void runOperator(WURDE::WURDEImage image1, WURDE::WURDEImage image2)=0;
              
              virtual void quitOperator()=0;
              
              std::list<WURDE::Capability *> *getSuppliers(){WURDE::g_debug("returning supppliers"); return &m_supplierList;}

              std::list<WURDE::Capability *> *getConsumers(){return &m_consumerList;}

              WURDE::RunState getState(){return m_state;}

              bool isStereoModule(){return m_stereo;}

              std::string getName(){return m_name;}

              void setName(std::string name){m_name=name;}
              
              void setFormat(WURDE::ImageFormat format){ m_format=format;}

              WURDE::ImageFormat getFormat(){return m_format;}
              
              void setCameras(std::vector<WURDEVision::CameraConfig> cams){m_cameras=cams;}

              std::string getCamera0(){return m_cameras[0].name;}

              std::string getCamera1(){if(m_cameras.size()>1){return m_cameras[1].name;}else{return "Null";}}
       protected:
              WURDE::RunState m_state;
              void registerSupplier(WURDE::Capability *someObject){m_supplierList.push_back(someObject);}

              void registerConsumer(WURDE::Capability *someObject){m_consumerList.push_back(someObject);}
              std::string m_name;

              bool m_stereo;

              WURDE::ImageFormat m_format;

       private:
              std::vector<WURDEVision::CameraConfig> m_cameras;
              std::list<WURDE::Capability *> m_supplierList;
              std::list<WURDE::Capability *> m_consumerList;
       };

        VisionModuleConfig parseVisionFile(std::string config, std::string modName, std::vector<CameraConfig> &cameras);
        //fakeit indicates that we're not really starting up, just registering.
        void loadOperators(VisionModuleConfig &theConfig,std::list<VisionOperator *> &theOperators,bool fakeit);
        void loadCameras(VisionModuleConfig &theConfig, std::vector<WURDECamera *> &cameras);
              
       void loadOperatorMap(std::vector<std::string> operatorLibs);
}

typedef WURDEVision::VisionOperator *voperatorloader_ptr(std::string name);

extern "C" {
        extern std::map<std::string, voperatorloader_ptr *, std::less<std::string> > operatorFactory;
}

#endif 

---