Grabber.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLIO/src/ICLIO/Grabber.h                              **
** Module : ICLIO                                                  **
** Authors: Christof Elbrechter, Michael Goetting, Robert          **
**          Haschke, Viktor Richter                                **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <string>
#include <vector>
#include <set>

#include <ICLCore/ImgBase.h>
#include <ICLUtils/SteppingRange.h>
#include <ICLUtils/Function.h>
#include <ICLUtils/Uncopyable.h>
#include <ICLUtils/Configurable.h>
#include <ICLUtils/ProgArg.h>
#include <ICLIO/GrabberDeviceDescription.h>
#include <ICLIO/ImageUndistortion.h>
#include <ICLUtils/Uncopyable.h>

namespace icl {
  namespace io{

    namespace{
      template <class T> inline T grabber_get_null(){ return 0; }
      template <> inline core::format grabber_get_null<core::format>(){ return (core::format)-1; }
      template <> inline core::depth grabber_get_null<core::depth>(){ return (core::depth)-1; }
      template <> inline icl::utils::Size grabber_get_null<icl::utils::Size>(){ return icl::utils::Size::null; }

      struct grabber_get_xxx_dummy{
          grabber_get_xxx_dummy(){
            grabber_get_null<core::format>();
            grabber_get_null<core::depth>();
            grabber_get_null<icl::utils::Size>();
          }
      };
    }
    template <class T> class GrabberHandle;
    class GenericGrabber;


    class Grabber : public utils::Uncopyable, public utils::Configurable{
        struct Data;

        Data *data;

      protected:
        virtual void setDesiredFormatInternal(core::format fmt);

        virtual void setDesiredSizeInternal(const utils::Size &size);

        virtual void setDesiredDepthInternal(core::depth d);

        virtual core::format getDesiredFormatInternal() const;

        virtual core::depth getDesiredDepthInternal() const;

        virtual utils::Size getDesiredSizeInternal() const;

      public:

        template<class X> friend class GrabberHandle;

        friend class GenericGrabber;

        Grabber();

        virtual ~Grabber();


        const core::ImgBase *grab(core::ImgBase **dst=0);


        template<class T>
        bool desiredUsed() const{ return false; }

        template<class T>
        void useDesired(const T &t){ (void)t;}

        void useDesired(core::depth d, const utils::Size &size, core::format fmt);


        template<class T>
        void ignoreDesired() {
          useDesired<T>(grabber_get_null<T>());
        }

        void ignoreDesired();


        template<class T>
        T getDesired() const { return T(); }


        static std::string translateSteppingRange(const utils::SteppingRange<double>& range);

        static utils::SteppingRange<double> translateSteppingRange(const std::string &rangeStr);

        static std::string translateDoubleVec(const std::vector<double> &doubleVec);

        static std::vector<double> translateDoubleVec(const std::string &doubleVecStr);

        static std::string translateStringVec(const std::vector<std::string> &stringVec);

        static std::vector<std::string> translateStringVec(const std::string &stringVecStr);



        void enableUndistortion(const std::string &filename);

        void enableUndistortion(const ImageUndistortion &udist);


        void enableUndistortion(const utils::ProgArg &pa);

        void enableUndistortion(const core::Img32f &warpMap);


        void setUndistortionInterpolationMode(core::scalemode mode);

        void disableUndistortion();

        bool isUndistortionEnabled() const;

        const core::Img32f *getUndistortionWarpMap() const;

        typedef utils::Function<void,const core::ImgBase*> callback;


        virtual void registerCallback(callback cb);

        virtual void removeAllCallbacks();


        virtual void notifyNewImageAvailable(const core::ImgBase *image);

      protected:



        virtual const core::ImgBase *acquireImage(){ return NULL; }


        const core::ImgBase *adaptGrabResult(const core::ImgBase *src, core::ImgBase **dst);

      private:
        void processPropertyChange(const utils::Configurable::Property &prop);

    };
    
    template<> inline void Grabber::useDesired<core::format>(const core::format &t) { setDesiredFormatInternal(t); }
    template<> inline void Grabber::useDesired<core::depth>(const core::depth &t) { setDesiredDepthInternal(t); }
    template<> inline void Grabber::useDesired<utils::Size>(const utils::Size &t) { setDesiredSizeInternal(t); }

    template<> inline core::depth Grabber::getDesired<core::depth>() const { return getDesiredDepthInternal(); }
    template<> inline utils::Size Grabber::getDesired<utils::Size>() const { return getDesiredSizeInternal(); }
    template<> inline core::format Grabber::getDesired<core::format>() const { return getDesiredFormatInternal(); }

    template<> inline bool Grabber::desiredUsed<core::format>() const{ return (int)getDesired<core::format>() != -1; }
    template<> inline bool Grabber::desiredUsed<core::depth>() const{ return (int)getDesired<core::depth>() != -1; }
    template<> inline bool Grabber::desiredUsed<utils::Size>() const{ return getDesired<utils::Size>() != utils::Size::null; }

    class GrabberRegister : utils::Uncopyable {
      private:
        utils::Mutex mutex;

        struct GrabberFunctions{
          utils::Function<Grabber*,const std::string&> init;
          utils::Function<const std::vector<GrabberDeviceDescription> &,std::string,bool> list;
        };

        // grabber functions map
        typedef std::map<std::string, GrabberFunctions> GFM;
        GFM gfm;

        // grabber bus reset functions map
        typedef std::map<std::string, utils::Function<void,bool> > GBRM;
        GBRM gbrm;

        // grabber device descriptions map
        typedef std::set<std::string> GDS;
        GDS gds;

        // private constructor
        GrabberRegister(){}

      public:
        static GrabberRegister* getInstance();

        void registerGrabberType(const std::string &grabberid,
                                   utils::Function<Grabber *, const std::string &> creator,
                                   utils::Function<const std::vector<GrabberDeviceDescription> &,std::string,bool> device_list)
        throw (utils::ICLException);

        void registerGrabberBusReset(const std::string &grabberid,
                                   utils::Function<void, bool> reset_function)
        throw (utils::ICLException);

        void addGrabberDescription(const std::string &grabber_description)
        throw (utils::ICLException);

        Grabber* createGrabber(const std::string &grabberid, const std::string &param) throw (utils::ICLException);

        std::vector<std::string> getRegisteredGrabbers();

        std::vector<std::string> getGrabberInfos();

        const std::vector<GrabberDeviceDescription>& getDeviceList(std::string id, std::string hint="", bool rescan=true);

        void resetGrabberBus(const std::string &id, bool verbose);
    };



    #define REGISTER_GRABBER(NAME,CREATE_FUNC,DEVICE_LIST_FUNC,DESCRIPTION)                                        \
    struct StaticGrabberRegistrationFor_##NAME{                                                                    \
      StaticGrabberRegistrationFor_##NAME(){                                                                       \
        icl::io::GrabberRegister::getInstance() -> registerGrabberType(#NAME, CREATE_FUNC, DEVICE_LIST_FUNC);      \
        icl::io::GrabberRegister::getInstance() -> addGrabberDescription(DESCRIPTION);                             \
      }                                                                                                            \
    } staticGrabberRegistrationFor_##NAME;

    #define REGISTER_GRABBER_BUS_RESET_FUNCTION(NAME,BUS_RESET_FUNC)                                               \
    struct StaticGrabberBusResetRegistrationFor_##NAME{                                                            \
      StaticGrabberBusResetRegistrationFor_##NAME(){                                                               \
        icl::io::GrabberRegister::getInstance() -> registerGrabberBusReset(#NAME, BUS_RESET_FUNC);                 \
      }                                                                                                            \
    } staticGrabberBusResetRegistrationFor_##NAME;

  } // namespace io
} // namespace icl