View2DTexture.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
 
 
#pragma once
 
#include "mlDataTypes.h"
#include "SoView2DSystem.h"
#include <mlPagedImage.h>
 
#include "mlOpenGL.h"
#include "mlGLResources.h"
 
#include "View2DLut.h"
 
class SoSFMLImage;
class View2DShader;
 
namespace ml {
  class PagedImage;
}
 
 
class SOVIEW2D_API View2DTexture
{
public:
  View2DTexture();
  virtual ~View2DTexture();
 
  void setLut(View2DLut* newLut);
 
  View2DLut* getLut();
 
  void setFilter(View2DTextureFilter filter);
 
  View2DTextureFilter getFilter() { return _filter; }
 
  void setData(void* data, MLssize_t sizeX, MLssize_t sizeY, MLDataType dtype = MLuint8Type, MLssize_t channels = 1, bool ownsData = true);
 
  MLDataType getImageDataType() { return _type; }
 
  void allocateData(MLssize_t sizeX, MLssize_t sizeY, MLDataType dtype = MLuint8Type, MLssize_t channels = 1);
 
  void* getData() { return _data; };
 
  bool hasData() { return _data!=nullptr; };
 
  void freeData();
 
  void forgetData();
 
  void setDataChanged() { _dataChanged = true; };
 
  bool isValidUserID(void* user, MLssize_t id);
 
  bool isValidUser(void* user) { return user==_user; };
 
  void setUserID(void* user, MLssize_t id);
 
  MLssize_t getChannels() const { return _channels; }
 
  bool isNPOT() { return _useNPOT; }
 
  double getDataShift() { return _dataShift; }
  double getDataScale() { return _dataScale; }
 
  void getSize(MLssize_t &x, MLssize_t &y) { x = _sizeX; y = _sizeY; };
 
  void loadSliceToTexture(SoSFMLImage* image, MLssize_t slice, MLssize_t timepoint, MLssize_t userIndex, bool useNPOT = false);
  void loadSliceToTexture(ml::PagedImage*  image, MLssize_t slice, MLssize_t timepoint, MLssize_t userIndex, bool useNPOT = false);
 
  void loadSliceToTexture(SoSFMLImage* image, const ml::SubImageBox& section, bool useNPOT = false);
  void loadSliceToTexture(ml::PagedImage*  image, const ml::SubImageBox& section, bool useNPOT = false);
 
  void bindTexture();
 
  void drawTexture(float dx1,float dy1, float dx2, float dy2);
  void drawTexture(float vp1[3],float vp2[3],float vp3[3]);
 
  void drawTextureRegion(float vp1[3], float vp2[3], float vp3[3], int startX, int startY, int endX, int endY);
 
  void drawTextureAsBorderImage(float dx1, float dy1, float dx2, float dy2, float borderWidth, float borderHeight);
 
  void restoreState();
 
  void freeTexture();
 
  bool needsImageData();
 
  void setShader(View2DShader* shader);
 
  void setForceShaderUsage(bool flag);
 
  View2DShader* getShader() { return _shader; }
 
  static MLssize_t getPowerOfTwo(MLssize_t size, bool& subflag);
 
  static MLssize_t getPowerOfTwo(MLssize_t size);
 
  void setCheckerInterval(size_t interval);
 
  size_t getCheckerInterval() const;
 
  void setCheckerTilesInverted(bool inverted);
 
  bool areCheckerTilesInverted() const;
 
  void internalBindFirstTexture();
 
  GLint internalGetFirstTexture();
 
  void createRenderToTextureTarget(int width, int height, int channels, GLenum format, GLenum internalFormat);
 
  MLuint64 getSizeInBytesOnGPU() const;
 
private:
  void createTextureIds();
 
  static MLuint32* convertToRGBA(void* data, MLssize_t size, MLssize_t channels, size_t dataTypeSize, View2DLut* lut);
 
  void transferTextureData(void* data, GLuint format, GLuint internalFormat, GLuint transferDataType);
 
  MLssize_t calcNumTextures(MLssize_t size);
 
  MLssize_t _sizeX;
  MLssize_t _sizeY;
 
  MLDataType _type;
  ml::GLTextures _textures;
  MLssize_t     _numTexturesX;
  MLssize_t     _numTexturesY;
 
  View2DLut* _lut;
 
  MLssize_t _channels;
 
  void*  _data;
  bool   _dataChanged;
  bool   _ownsData;
 
  View2DTextureFilter _filter;
 
  void* _user;
  MLssize_t _id;
 
  ml::LUTDataId _lastLutChangeID;
  MLssize_t      _lastLutSize;
 
  View2DShader* _shader;
  bool          _shaderChanged;
  bool          _forceShaderUsage;
  bool          _useNPOT;
 
  double        _dataScale;
  double        _dataShift;
 
  static MLssize_t _maxTextureSize;
 
  size_t _checkerInterval;
 
  bool _areCheckersInverted;
};