GenericGrabber.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/GenericGrabber.h                       **
** Module : ICLIO                                                  **
** Authors: Christof Elbrechter, 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 <ICLIO/Grabber.h>
#include <string>
#include <ICLUtils/Macros.h>
#include <ICLUtils/Exception.h>
#include <ICLUtils/Lockable.h>
#include <ICLUtils/ProgArg.h>
#include <ICLUtils/ConfigurableProxy.h>

namespace icl {
  namespace io{


    class GenericGrabber: public utils::Uncopyable, public utils::ConfigurableProxy{

        Grabber *m_poGrabber; 

        GrabberDeviceDescription m_poDesc; 

        mutable utils::Mutex m_mutex; 

      public:


        GenericGrabber(const utils::ProgArg &pa) throw (utils::ICLException):m_poGrabber(0){
          init(pa);
        }


        GenericGrabber(const std::string &devicePriorityList,
                       const std::string &params,
                       bool notifyErrors = true) throw (utils::ICLException):m_poGrabber(0){
          init(devicePriorityList,params,notifyErrors);
        }



        GenericGrabber():m_poGrabber(0){}


        void init(const std::string &devicePriorityList,
                  const std::string &params,
                  bool notifyErrors = true) throw (utils::ICLException);

        void init(const utils::ProgArg &pa) throw (utils::ICLException);

        static void resetBus(const std::string &deviceList="dc", bool verbose=false);

        std::string getType() const {
          utils::Mutex::Locker __lock(m_mutex);
          return m_poDesc.type;
        }

        Grabber *getGrabber() const {
          utils::Mutex::Locker __lock(m_mutex);
          return m_poGrabber;
        }

        virtual ~GenericGrabber();


        const core::ImgBase *grab(core::ImgBase **dst=0){
          utils::Mutex::Locker __lock(m_mutex);
          ICLASSERT_RETURN_VAL(!isNull(),0);
          return m_poGrabber->grab(dst);
        }

        bool isNull() const { return m_poGrabber == 0; }

        operator bool() const { return !isNull(); }


        void setDesiredFormatInternal(core::format fmt){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->setDesiredFormatInternal(fmt);
        }

        void setDesiredSizeInternal(const utils::Size &size){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->setDesiredSizeInternal(size);
        }

        void setDesiredDepthInternal(core::depth d){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->setDesiredDepthInternal(d);
        }

        core::format getDesiredFormatInternal() const{
          ICLASSERT_RETURN_VAL(!isNull(),(core::format)-1);
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->getDesiredFormatInternal();
        }

        core::depth getDesiredDepthInternal() const{
          ICLASSERT_RETURN_VAL(!isNull(),(core::depth)-1);
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->getDesiredDepthInternal();
        }

        utils::Size getDesiredSizeInternal() const{
          ICLASSERT_RETURN_VAL(!isNull(),utils::Size::null);
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->getDesiredSizeInternal();
        }

        void registerCallback(Grabber::callback cb){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->registerCallback(cb);
        }

        void removeAllCallbacks(){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->removeAllCallbacks();
        }


        template<class T>
        bool desiredUsed() const{
          ICLASSERT_RETURN_VAL(!isNull(),false);
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->desiredUsed<T>();
        }

        template<class T>
        void useDesired(const T &t){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->useDesired<T>(t);
        }

        void useDesired(core::depth d, const utils::Size &size, core::format fmt){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->useDesired(d, size, fmt);
        }


        template<class T>
        void ignoreDesired() {
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->ignoreDesired<T>();
        }

        void ignoreDesired(){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->ignoreDesired();
        }


        template<class T>
        T getDesired() const {
          ICLASSERT_RETURN_VAL(!isNull(), T());
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->getDesired<T>();
        }

        void enableUndistortion(const std::string &filename){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->enableUndistortion(filename);
        }

        void enableUndistortion(const ImageUndistortion &udist){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->enableUndistortion(udist);
        }


        void enableUndistortion(const utils::ProgArg &pa){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->enableUndistortion(pa);
        }

        void enableUndistortion(const core::Img32f &warpMap){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->enableUndistortion(warpMap);
        }


        void setUndistortionInterpolationMode(core::scalemode mode){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->setUndistortionInterpolationMode(mode);
        }

        void disableUndistortion(){
          ICLASSERT_RETURN(!isNull());
          utils::Mutex::Locker l(m_mutex);
          m_poGrabber->disableUndistortion();
        }

        bool isUndistortionEnabled() const{
          ICLASSERT_RETURN_VAL(!isNull(),false);
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->isUndistortionEnabled();
        }

        const core::Img32f *getUndistortionWarpMap() const{
          ICLASSERT_RETURN_VAL(!isNull(),0);
          utils::Mutex::Locker l(m_mutex);
          return m_poGrabber->getUndistortionWarpMap();
        }


        static const std::vector<GrabberDeviceDescription> &getDeviceList(const std::string &filter, bool rescan=true);


        inline void init(const GrabberDeviceDescription &dev){
          init(dev.type,dev.type+"="+dev.id,false);
        }
    };

  } // namespace io
}