ImgParams.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   : ICLCore/src/ICLCore/ImgParams.h                        **
** Module : ICLCore                                                **
** Authors: Christof Elbrechter, Robert Haschke                    **
**                                                                 **
**                                                                 **
** 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.LGPL **
** 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 <ICLUtils/CompatMacros.h>
#include <ICLUtils/Point.h>
#include <ICLUtils/Size.h>
#include <ICLUtils/Rect.h>
#include <ICLCore/Types.h>
#include <ICLUtils/Exception.h>
#include <ICLUtils/Macros.h>


namespace icl{
  namespace core{

    class ICLCore_API ImgParams{
      public:
      static const ImgParams null;



      ImgParams() :
        m_oSize(null.m_oSize), m_iChannels(null.m_iChannels),
        m_eFormat(null.m_eFormat), m_oROI(null.m_oROI){}


      ImgParams(const ImgParams &params):
      m_oSize(params.m_oSize),m_iChannels(params.m_iChannels),
      m_eFormat(params.m_eFormat),m_oROI(params.m_oROI){}


      ImgParams(const utils::Size &size, int channels, const utils::Rect &roi = utils::Rect::null)
        { setup(size,formatMatrix,channels,roi); }


      ImgParams(const utils::Size &size, format fmt, const utils::Rect &roi = utils::Rect::null);


      ImgParams(const utils::Size &size, int channels, format fmt, const utils::Rect& roi = utils::Rect::null)
         { setup(size,fmt,channels,roi); }


      ImgParams(int width, int height, format fmt,
                int roiX=0, int roiY=0, int roiWidth = 0, int roiHeight = 0);


      ImgParams(int width, int height, int channels,
                int roiX=0, int roiY=0, int roiWidth = 0, int roiHeight = 0);



      ImgParams(int width, int height, int channels, format fmt,
                int roiX=0, int roiY=0, int roiWidth=0, int roiHeight=0);

      bool isNull() const { return (*this)==null; }

      bool operator!=(const ImgParams &other) const{ return !((*this)==other); }

      bool operator==(const ImgParams &other) const;

      void setSize(const utils::Size &size);

      void setFormat(format fmt);

      void setChannels(int channels);


      void setROIOffset(const utils::Point &offset);


      void setROISize(const utils::Size &roisize);


      void setROI(const utils::Point &offset, const utils::Size &roisize);

      void setROI(const utils::Rect &roi) { setROI (roi.ul(),roi.getSize()); }

      void setROIOffsetAdaptive(const utils::Point &offset);

      void setROISizeAdaptive(const utils::Size &size);


      void setROIAdaptive(const utils::Rect &r);


      utils::Rect& adaptROI(utils::Rect &roi) const;

      bool hasFullROI() const { return m_oROI.getSize() == m_oSize;}

      void setFullROI(){ setROI(utils::Point::null, getSize()); }

      const utils::Size& getSize() const { return m_oSize;  }

      int getChannels() const { return m_iChannels; }

      format getFormat() const { return m_eFormat; }

      const utils::Rect& getROI() const { return m_oROI; }

      void getROI(utils::Point &offset, utils::Size &size) const {
         offset=getROIOffset(); size = getROISize();
      }

      const utils::Point getROIOffset() const { return m_oROI.ul(); }

      const utils::Size getROISize() const{ return m_oROI.getSize(); }

      int getWidth() const { return m_oSize.width; }

      int getHeight() const{ return m_oSize.height; }

      int getPixelOffset() const { return m_oROI.x+m_oROI.y*getWidth(); }

      int getROIWidth() const{ return m_oROI.width; }

      int getROIHeight() const{ return m_oROI.height; }

      int getROIXOffset() const{ return m_oROI.x; }

      int getROIYOffset() const { return m_oROI.y; }

      int getDim() const { return getSize().getDim(); }

      int getROIDim() const { return getROISize().getDim(); }

      private:

      void setup(const utils::Size &size, format fmt, int channels, const utils::Rect &roi);


      utils::Size m_oSize;

      int m_iChannels;

      format m_eFormat;

      utils::Rect m_oROI;

    };

    ICLCore_API std::ostream &operator<<(std::ostream &os, const ImgParams &p);

    ICLCore_API std::istream &operator>>(std::istream &is, ImgParams &p);

  } // namespace core
}