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
}