GLImg.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   : ICLQt/src/ICLQt/GLImg.h                                **
** Module : ICLQt                                                  **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** 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 <ICLCore/ImgBase.h>
#include <ICLUtils/Uncopyable.h>
#include <ICLMath/FixedVector.h>
#include <ICLUtils/Function.h>
#include <ICLUtils/Range.h>
#include <ICLQt/ImageStatistics.h>

namespace icl{
  namespace qt{

    class GLImg : public utils::Uncopyable{
      struct Data;  
      Data *m_data; 
      
      public:
      

      static void set_use_dirty_flag(bool useIt);
      
      static bool get_use_dirty_flag();
      

      GLImg(const core::ImgBase *src=0, core::scalemode sm=core::interpolateNN, int maxCellSize=4096);
      
      ~GLImg();
      

      void update(const core::ImgBase *src, int maxCellSize=4096);
      
      void setScaleMode(core::scalemode sm);
      
      bool isNull() const;
      

      void draw2D(const utils::Rect &r, const utils::Size &windowSize);
  

      void draw2D(const float a[2], const float b[2], const float c[2],const float e[2], const utils::Size &windowSize);
      

      void draw3D(const float a[3],const float b[3],const float c[3],const float d[3],
                  const float na[3]=0, const float nb[3]=0, const float nc[3]=0, const float nd[3]=0,
                  const utils::Point32f &texCoordsA=utils::Point32f(0,0),
                  const utils::Point32f &texCoordsB=utils::Point32f(1,0),
                  const utils::Point32f &texCoordsC=utils::Point32f(0,1),
                  const utils::Point32f &texCoordsD=utils::Point32f(1,1));     
  

      void draw3DGeneric(int numPoints,
                         const float *xs, const float *ys, const float *zs, int xyzStride,
                         const utils::Point32f *texCoords, const float *nxs=0, const float *nys=0,
                         const float *nzs=0, int nxyzStride=1);
  
      inline void draw3D(const float a[3],const float b[3],const float c[3]){
        const float d[3] = { b[0] + c[0] -a[0], b[1] + c[1] -a[1], b[2] + c[2] -a[2]  };
        draw3D(a,b,c,d);
      }
  
  

      void drawToGrid(int nx, int ny, const float *xs, const float *ys, const float *zs,
                      const float *nxs=0, const float *nys=0, const float *nzs=0,
                      const int stride = 1);
      
      typedef math::FixedColVector<float,3> Vec3;
      
      typedef utils::Function<Vec3,int,int> grid_function; 
      

      void drawToGrid(int nx, int ny, grid_function gridVertices, 
                      grid_function gridNormals = grid_function());
      
  
      static int getMaxTextureSize();
      
      utils::Size getCells() const;
      
      void bind(int xCell=0, int yCell=0);
  
      inline utils::Size getSize() const { return utils::Size(getWidth(), getHeight()); }
  
      int getWidth() const;
  
      int getHeight() const;
  
      int getChannels() const;
      
      core::depth getDepth() const;
      
      core::format getFormat() const;
      
      utils::Rect getROI() const;
  
      utils::Time getTime() const;
  

      void setBCI(int b=-1, int c=-1, int i=-1);
  
      std::vector<utils::Range64f> getMinMax() const;
      
      std::vector<icl64f> getColor(int x, int y)const;
  

      const core::ImgBase *extractImage() const;
  
      const ImageStatistics &getStats() const;
  
      void setDrawGrid(bool enabled, float *color=0);
  
      void setGridColor(float *color);
  
      const float *getGridColor() const;
      
      core::scalemode getScaleMode() const;
      
      void lock() const;
  
      void unlock() const;
  
      
    };
  } // namespace qt
}