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.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/Uncopyable.h>
#include <ICLUtils/Function.h>
#include <ICLUtils/Range.h>
#include <ICLMath/FixedVector.h>
#include <ICLCore/ImgBase.h>
#include <ICLQt/ImageStatistics.h>

namespace icl{
  namespace qt{

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

      public:

      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, bool invertNormals=false);

      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, bool invertNormals=false);

      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, int textureUnit=0) const;

      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
}