CamInterface.h

Go to the documentation of this file.

/*
 *
 * German Research Center for Artificial Intelligence
 * DFKI-Lab Bremen 2010
 *
 * File:   CamInterface.h
 * Author: Alexander Duda (Alexander.Duda@dfki.de)
 *
 */

#ifndef _CAMINTERFACE_H
#define _CAMINTERFACE_H

#include "CamTypes.h"                   //definition of camera specific types
#include <base/samples/Frame.hpp>         //definition of a general image frame
#include <vector>
#include <stdexcept>

namespace camera
{

    class CamInterface
    {
    protected:
        base::samples::frame::frame_size_t image_size_;  //size of the returned image frame
        base::samples::frame::frame_mode_t image_mode_;  //color mode of the returned image frame
                                                  //See CameraFrame.h for all possible modes
        uint8_t image_color_depth_;               //color depth in bytes of the returned image
                                                  //frame
        GrabMode act_grab_mode_;                  //actual grab mode
    public:
        CamInterface();
        virtual ~CamInterface();

    private:
        CamInterface(const CamInterface &other){}; //only one handle per
                                                   //camera is allowed

    // ------------------------------------------------------------------------
    // CONTROL FUNCTIONS-------------------------------------------------------
    // ------------------------------------------------------------------------

    public:

        virtual int listCameras(std::vector<CamInfo> &cam_infos)const 
        {throw std::runtime_error("listCameras is not yet implemented for the camera interface!");return 0;};


        virtual bool findCamera(const CamInfo &pattern,CamInfo &cam )const;


        virtual int countCameras()const;



        virtual bool open(const CamInfo &cam,const AccessMode mode=Master)
        {throw std::runtime_error("open is not yet implemented for the camera interface!");return 0;};


        virtual bool open2(const std::string &display_name,const AccessMode mode=Master);
        

        virtual bool open2(unsigned long &unique_camera_id,const AccessMode mode=Master);


        virtual bool open2(const CamInfo &pattern,const AccessMode mode=Master);
        

        virtual bool isOpen()const
        {throw std::runtime_error("isOpen is not yet implemented for the camera interface!");return 0;};
        

        virtual const CamInfo *getCameraInfo()const
        {
           throw std::runtime_error("This camerea interface does not support getCameraInfo.");
           return NULL;
        };


        virtual bool close()
        {throw std::runtime_error("close is not yet implemented for the camera interface!");return 0;};


        virtual bool grab(const GrabMode mode = SingleFrame,
                          const int buffer_len=1)
        {throw std::runtime_error("grab is not yet implemented for the camera interface!");return 0;};                  


        virtual bool retrieveFrame(base::samples::frame::Frame &frame,const int timeout=1000)
        {throw std::runtime_error("retrieveFrame is not yet implemented for the camera interface!");return 0;};


        virtual bool isFrameAvailable()
        {throw std::runtime_error("isFrameAvailable is not yet implemented for the camera interface!");return 0;};


        virtual int skipFrames()
        {throw std::runtime_error("skipFrames is not yet implemented for the camera interface!");return 0;};


        virtual bool setIpSettings(const CamInfo &cam,
                    const IPSettings &ip_settings)const
        {throw std::runtime_error("setIpSettings is not yet implemented for the camera interface!");return 0;};


        virtual bool setAttrib(const int_attrib::CamAttrib attrib,const int value)
        {throw std::runtime_error("setAttrib int_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool setAttrib(const double_attrib::CamAttrib attrib,
                                const double value)
        {throw std::runtime_error("setAttrib double_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool setAttrib(const str_attrib::CamAttrib attrib,const std::string value)
        {throw std::runtime_error("setAttrib str_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool setAttrib(const enum_attrib::CamAttrib attrib)
        {throw std::runtime_error("setAttrib enum_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool isAttribAvail(const int_attrib::CamAttrib attrib)
        {throw std::runtime_error("isAttribAvail int_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool isAttribAvail(const double_attrib::CamAttrib attrib)
        {throw std::runtime_error("isAttribAvail double_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool isAttribAvail(const str_attrib::CamAttrib attrib)
        {throw std::runtime_error("isAttribAvail str_attrib is not yet implemented for the camera interface!");return 0;};
                            

        virtual bool isAttribAvail(const enum_attrib::CamAttrib attrib)
        {throw std::runtime_error("isAttribAvail enum_attrib is not yet implemented for the camera interface!");return 0;};


        virtual int getAttrib(const int_attrib::CamAttrib attrib)
        {throw std::runtime_error("getAttrib int_attrib is not yet implemented for the camera interface!");return 0;};


        virtual double getAttrib(const double_attrib::CamAttrib attrib)
        {throw std::runtime_error("getAttrib double_attrib is not yet implemented for the camera interface!");return 0;};


        virtual std::string getAttrib(const str_attrib::CamAttrib attrib)
        {throw std::runtime_error("getAttrib str_attrib is not yet implemented for the camera interface!");return 0;};


        virtual bool isAttribSet(const enum_attrib::CamAttrib attrib)
        {throw std::runtime_error("isAttribSet is not yet implemented for the camera interface!");return 0;};


        virtual CamInterface& operator>>(base::samples::frame::Frame &frame);


        virtual bool setFrameSettings(const base::samples::frame::frame_size_t size,
                                      const base::samples::frame::frame_mode_t mode,
                                      const uint8_t color_depth,
                                      const bool resize_frames = true);
    


        virtual bool setFrameSettings(const base::samples::frame::Frame &frame,
                                    const bool resize_frames = true);


        virtual bool getFrameSettings(base::samples::frame::frame_size_t &size,
                                        base::samples::frame::frame_mode_t &mode,
                                        uint8_t &color_depth)
        {throw std::runtime_error("getFrameSettings is not yet implemented for the camera interface!");return 0;};


        virtual bool triggerFrame()
        {throw std::runtime_error("triggerFrame is not yet implemented for the camera interface!");return 0;};


        virtual bool setToDefault()
        {throw std::runtime_error("setToDefault is not yet implemented for the camera interface!");return 0;};


        virtual bool setFrameToCameraFrameSettings(base::samples::frame::Frame &frame);
        

        virtual bool setCallbackFcn(void (*pcallback_function)(const void* p),void *p)
        {
          throw std::runtime_error("This camerea does not support callback functions. "
                                   "Use is isFrameAvailable() instead.");
        };
        

        virtual void synchronizeWithSystemTime(uint32_t time_interval)
        {
          throw std::runtime_error("This camerea does not support synchronizeWithSystemTime. "
                                   "The timestamp of the camera frame will be invalid.");
        };
        

        virtual void saveConfiguration(uint8_t index)
        {
          throw std::runtime_error("This camerea does not support saveConfiguration.");
        };
        

        virtual void loadConfiguration(uint8_t index)
        {
          throw std::runtime_error("This camerea does not support loadConfiguration.");
        };
        

        virtual void getRange(const double_attrib::CamAttrib attrib,double &dmin,double &dmax)
        {
          throw std::runtime_error("This camerea does not support getRange for double_attrib.");
        };
        

        virtual void getRange(const int_attrib::CamAttrib attrib,int &imin,int &imax)
        {
          throw std::runtime_error("This camerea does not support getRange for int_attrib.");
        };
    

    virtual int getFileDescriptor() const
    {
      throw std::runtime_error("This camerea does not provide a file descriptor.");
    };
        

        virtual std::string doDiagnose();
    };
}
#endif  /* _CAMINTERFACE_H */