VTK
vtkVolumeMask.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkVolumeMask.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
16 #ifndef vtkVolumeMask_h
17 #define vtkVolumeMask_h
18 
19 #include <vtkDataArray.h>
20 #include <vtkImageData.h>
21 #include <vtkOpenGLRenderWindow.h>
22 #include <vtkRenderer.h>
23 #include <vtkRenderWindow.h>
24 #include <vtkTextureObject.h>
25 
26 #include <map> // STL required
27 
28 //----------------------------------------------------------------------------
30 {
31 public:
32  //--------------------------------------------------------------------------
34  {
35  this->Texture = nullptr;
36  this->Loaded = false;
37  this->LoadedExtent[0] = VTK_INT_MAX;
38  this->LoadedExtent[1] = VTK_INT_MIN;
39  this->LoadedExtent[2] = VTK_INT_MAX;
40  this->LoadedExtent[3] = VTK_INT_MIN;
41  this->LoadedExtent[4] = VTK_INT_MAX;
42  this->LoadedExtent[5] = VTK_INT_MIN;
43  }
44 
45  //--------------------------------------------------------------------------
47  {
48  if (this->Texture)
49  {
50  this->Texture->Delete();
51  this->Texture = nullptr;
52  }
53  }
54 
55  //--------------------------------------------------------------------------
57  {
58  return this->BuildTime;
59  }
60 
61  //--------------------------------------------------------------------------
62  void Activate()
63  {
64  this->Texture->Activate();
65  }
66 
67  //--------------------------------------------------------------------------
68  void Deactivate()
69  {
70  this->Texture->Deactivate();
71  }
72 
73  //--------------------------------------------------------------------------
74  void Update(vtkRenderer* ren,
75  vtkImageData *input,
76  int cellFlag,
77  int textureExtent[6],
78  int scalarMode,
79  int arrayAccessMode,
80  int arrayId,
81  const char* arrayName,
82  vtkIdType maxMemoryInBytes)
83  {
84  bool needUpdate = false;
85  bool modified = false;
86 
87  if (!this->Texture)
88  {
90  needUpdate = true;
91  }
92 
94  ren->GetRenderWindow()));
95 
96  if (!this->Texture->GetHandle())
97  {
98  needUpdate = true;
99  }
100 
101  int obsolete = needUpdate || !this->Loaded ||
102  input->GetMTime()>this->BuildTime;
103  if(!obsolete)
104  {
105  obsolete = cellFlag != this->LoadedCellFlag;
106  int i = 0;
107  while(!obsolete && i<6)
108  {
109  obsolete = obsolete || this->LoadedExtent[i]>textureExtent[i];
110  ++i;
111  obsolete = obsolete || this->LoadedExtent[i]<textureExtent[i];
112  ++i;
113  }
114  }
115 
116  if(obsolete)
117  {
118  this->Loaded = false;
119  int dim[3];
120  input->GetDimensions(dim);
121 
122  vtkDataArray *scalars =
123  vtkAbstractMapper::GetScalars(input,scalarMode,arrayAccessMode,
124  arrayId,arrayName,
125  this->LoadedCellFlag);
126 
127  // DON'T USE GetScalarType() or GetNumberOfScalarComponents() on
128  // ImageData as it deals only with point data...
129  int scalarType = scalars->GetDataType();
130  if(scalarType != VTK_UNSIGNED_CHAR)
131  {
132  cout <<"Mask should be VTK_UNSIGNED_CHAR." << endl;
133  }
134  if(scalars->GetNumberOfComponents()!=1)
135  {
136  cout << "Mask should be a one-component scalar field." << endl;
137  }
138 
139  GLint internalFormat = GL_R8;
140  GLenum format = GL_RED;
141  GLenum type = GL_UNSIGNED_BYTE;
142 
143  // Enough memory?
144  int textureSize[3];
145  int i = 0;
146  while(i < 3)
147  {
148  textureSize[i] = textureExtent[2*i+1] - textureExtent[2*i] + 1;
149  ++i;
150  }
151 
152  GLint width;
153  glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &width);
154  this->Loaded = textureSize[0] <= width && textureSize[1] <= width &&
155  textureSize[2] <= width;
156  if(this->Loaded)
157  {
158  // so far, so good but some cards don't report allocation error
159  this->Loaded = textureSize[0] * textureSize[1]*
160  textureSize[2] *
162  scalars->GetNumberOfComponents() <=
163  maxMemoryInBytes;
164  if(this->Loaded)
165  {
166  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
167 
168  if(!(textureExtent[1]-textureExtent[0]+cellFlag==dim[0]))
169  {
170  glPixelStorei(GL_UNPACK_ROW_LENGTH,dim[0]-cellFlag);
171  }
172  if(!(textureExtent[3]-textureExtent[2]+cellFlag==dim[1]))
173  {
174  glPixelStorei(GL_UNPACK_IMAGE_HEIGHT,
175  dim[1]-cellFlag);
176  }
177  void* dataPtr = scalars->GetVoidPointer(
178  ((textureExtent[4]*(dim[1]-cellFlag)+textureExtent[2]) *
179  (dim[0]-cellFlag)+textureExtent[0]) *
180  scalars->GetNumberOfComponents());
181 
182  this->Texture->SetDataType(type);
183  this->Texture->SetFormat(format);
184  this->Texture->SetInternalFormat(internalFormat);
185  this->Texture->Create3DFromRaw(
186  textureSize[0], textureSize[1], textureSize[2],
187  1, scalarType, dataPtr);
193  this->Texture->SetBorderColor(0.0f, 0.0f, 0.0f, 0.0f);
194 
195  // Restore the default values.
196  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
197  glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
198 
199  this->LoadedCellFlag = cellFlag;
200  i = 0;
201  while(i < 6)
202  {
203  this->LoadedExtent[i] = textureExtent[i];
204  ++i;
205  }
206 
207  double spacing[3];
208  double origin[3];
209  input->GetSpacing(spacing);
210  input->GetOrigin(origin);
211  int swapBounds[3];
212  swapBounds[0] = (spacing[0] < 0);
213  swapBounds[1] = (spacing[1] < 0);
214  swapBounds[2] = (spacing[2] < 0);
215 
216  if(!this->LoadedCellFlag) // loaded extents represent points
217  {
218  // slabsPoints[i]=(slabsDataSet[i] - origin[i/2]) / spacing[i/2];
219  // in general, x=o+i*spacing.
220  // if spacing is positive min extent match the min of the
221  // bounding box
222  // and the max extent match the max of the bounding box
223  // if spacing is negative min extent match the max of the
224  // bounding box
225  // and the max extent match the min of the bounding box
226 
227  // if spacing is negative, we may have to rethink the equation
228  // between real point and texture coordinate...
229  this->LoadedBounds[0]=origin[0]+
230  static_cast<double>(this->LoadedExtent[0+swapBounds[0]])*spacing[0];
231  this->LoadedBounds[2]=origin[1]+
232  static_cast<double>(this->LoadedExtent[2+swapBounds[1]])*spacing[1];
233  this->LoadedBounds[4]=origin[2]+
234  static_cast<double>(this->LoadedExtent[4+swapBounds[2]])*spacing[2];
235  this->LoadedBounds[1]=origin[0]+
236  static_cast<double>(this->LoadedExtent[1-swapBounds[0]])*spacing[0];
237  this->LoadedBounds[3]=origin[1]+
238  static_cast<double>(this->LoadedExtent[3-swapBounds[1]])*spacing[1];
239  this->LoadedBounds[5]=origin[2]+
240  static_cast<double>(this->LoadedExtent[5-swapBounds[2]])*spacing[2];
241 
242  }
243  else // loaded extents represent cells
244  {
245  int wholeTextureExtent[6];
246  input->GetExtent(wholeTextureExtent);
247  i=1;
248  while(i<6)
249  {
250  wholeTextureExtent[i]--;
251  i+=2;
252  }
253 
254  i=0;
255  while(i<3)
256  {
257  if(this->LoadedExtent[2*i]==wholeTextureExtent[2*i])
258  {
259  this->LoadedBounds[2*i+swapBounds[i]]=origin[i];
260  }
261  else
262  {
263  this->LoadedBounds[2*i+swapBounds[i]]=origin[i]+
264  (static_cast<double>(this->LoadedExtent[2*i])+0.5)*spacing[i];
265  }
266 
267  if(this->LoadedExtent[2*i+1]==wholeTextureExtent[2*i+1])
268  {
269  this->LoadedBounds[2*i+1-swapBounds[i]]=origin[i]+
270  (static_cast<double>(this->LoadedExtent[2*i+1])+1.0)*spacing[i];
271  }
272  else
273  {
274  this->LoadedBounds[2*i+1-swapBounds[i]]=origin[i]+
275  (static_cast<double>(this->LoadedExtent[2*i+1])+0.5)*spacing[i];
276  }
277  ++i;
278  }
279  }
280  modified = true;
281  }
282  }
283  }
284 
285  if(modified)
286  {
287  this->BuildTime.Modified();
288  }
289  }
290 
291  //--------------------------------------------------------------------------
292  double* GetLoadedBounds()
293  {
294  return this->LoadedBounds;
295  }
296 
297  //--------------------------------------------------------------------------
299  {
300  return this->LoadedExtent;
301  }
302 
303  //--------------------------------------------------------------------------
305  {
306  return this->LoadedCellFlag;
307  }
308 
309  //--------------------------------------------------------------------------
310  bool IsLoaded()
311  {
312  return this->Loaded;
313  }
314 
315  // Get the texture unit
316  //--------------------------------------------------------------------------
317  int GetTextureUnit(void)
318  {
319  if (!this->Texture)
320  {
321  return -1;
322  }
323  return this->Texture->GetTextureUnit();
324  }
325 
326  //--------------------------------------------------------------------------
328  {
329  if (this->Texture)
330  {
331  this->Texture->ReleaseGraphicsResources(window);
332  this->Texture->Delete();
333  this->Texture = nullptr;
334  }
335  }
336 
337 
338 protected:
341 
342  double LoadedBounds[6];
344 
346  bool Loaded;
347 };
348 
349 //----------------------------------------------------------------------------
351 {
352 public:
353  std::map<vtkImageData *,vtkVolumeMask*> Map;
355  {
356  }
357 private:
359  vtkMapMaskTextureId &operator=(const vtkMapMaskTextureId &other);
360 };
361 
362 #endif // vtkVolumeMask_h
363 // VTK-HeaderTest-Exclude: vtkVolumeMask.h
vtkVolumeMask::~vtkVolumeMask
~vtkVolumeMask()
Definition: vtkVolumeMask.h:46
vtkImageData.h
vtkVolumeMask::GetLoadedCellFlag
int GetLoadedCellFlag()
Definition: vtkVolumeMask.h:304
vtkTextureObject::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *win)
Deactivate and UnBind the texture.
vtkVolumeMask::vtkVolumeMask
vtkVolumeMask()
Definition: vtkVolumeMask.h:33
VTK_INT_MIN
#define VTK_INT_MIN
Definition: vtkType.h:158
vtkTextureObject::SetBorderColor
virtual void SetBorderColor(float, float, float, float)
Border Color (RGBA).
vtkVolumeMask::Texture
vtkTextureObject * Texture
Definition: vtkVolumeMask.h:339
VTK_INT_MAX
#define VTK_INT_MAX
Definition: vtkType.h:159
vtkMapMaskTextureId::vtkMapMaskTextureId
vtkMapMaskTextureId()
Definition: vtkVolumeMask.h:354
vtkAbstractArray::GetNumberOfComponents
int GetNumberOfComponents()
Definition: vtkAbstractArray.h:130
vtkVolumeMask::Activate
void Activate()
Definition: vtkVolumeMask.h:62
vtkAbstractMapper::GetScalars
static vtkDataArray * GetScalars(vtkDataSet *input, int scalarMode, int arrayAccessMode, int arrayId, const char *arrayName, int &cellFlag)
Internal helper function for getting the active scalars.
vtkTextureObject::Create3DFromRaw
bool Create3DFromRaw(unsigned int width, unsigned int height, unsigned int depth, int numComps, int dataType, void *data)
Create a 3D texture from client memory numComps must be in [1-4].
vtkMapMaskTextureId
Definition: vtkVolumeMask.h:350
vtkTextureObject::SetMinificationFilter
virtual void SetMinificationFilter(int)
vtkVolumeMask::Loaded
bool Loaded
Definition: vtkVolumeMask.h:346
vtkX3D::type
Definition: vtkX3D.h:516
vtkIdType
int vtkIdType
Definition: vtkType.h:347
vtkTextureObject::SetWrapS
virtual void SetWrapS(int)
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:35
vtkTextureObject::SetFormat
void SetFormat(unsigned int glFormat)
vtkRenderWindow.h
vtkTextureObject::SetContext
void SetContext(vtkOpenGLRenderWindow *)
Get/Set the context.
vtkRenderer.h
vtkTextureObject::SetInternalFormat
void SetInternalFormat(unsigned int glInternalFormat)
vtkObjectBase::Delete
virtual void Delete()
Delete a VTK object.
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
vtkTextureObject::Nearest
Definition: vtkTextureObject.h:86
vtkImageData::GetDimensions
virtual int * GetDimensions()
Get dimensions of this structured points dataset.
vtkTextureObject::GetTextureUnit
int GetTextureUnit()
Return the texture unit used for this texture.
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:37
vtkAbstractArray::GetVoidPointer
virtual void * GetVoidPointer(vtkIdType valueIdx)=0
Return a void pointer.
vtkImageData::GetExtent
virtual int * GetExtent()
vtkTextureObject::SetWrapT
virtual void SetWrapT(int)
vtkTimeStamp::Modified
void Modified()
Set this objects time to the current time.
vtkOpenGLRenderWindow::SafeDownCast
static vtkOpenGLRenderWindow * SafeDownCast(vtkObjectBase *o)
vtkVolumeMask::LoadedExtent
vtkIdType LoadedExtent[6]
Definition: vtkVolumeMask.h:343
vtkDataSet::GetMTime
vtkMTimeType GetMTime() override
Datasets are composite objects and need to check each part for MTime THIS METHOD IS THREAD SAFE.
vtkVolumeMask::GetLoadedExtent
vtkIdType * GetLoadedExtent()
Definition: vtkVolumeMask.h:298
vtkTextureObject::Deactivate
void Deactivate()
Deactivate and UnBind the texture.
vtkAbstractArray::GetDataTypeSize
virtual int GetDataTypeSize()=0
Return the size of the underlying data type.
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:45
vtkTextureObject
abstracts an OpenGL texture object.
Definition: vtkTextureObject.h:44
vtkAbstractArray::GetDataType
virtual int GetDataType()=0
Return the underlying data type.
vtkTextureObject.h
vtkTextureObject::New
static vtkTextureObject * New()
VTK_UNSIGNED_CHAR
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:51
vtkVolumeMask::GetLoadedBounds
double * GetLoadedBounds()
Definition: vtkVolumeMask.h:292
vtkVolumeMask::BuildTime
vtkTimeStamp BuildTime
Definition: vtkVolumeMask.h:340
vtkTextureObject::SetMagnificationFilter
virtual void SetMagnificationFilter(int)
vtkTextureObject::SetDataType
void SetDataType(unsigned int glType)
vtkX3D::spacing
Definition: vtkX3D.h:481
vtkVolumeMask
Definition: vtkVolumeMask.h:29
vtkImageData::GetOrigin
virtual double * GetOrigin()
vtkDataArray.h
vtkVolumeMask::GetTextureUnit
int GetTextureUnit(void)
Definition: vtkVolumeMask.h:317
vtkTextureObject::SetWrapR
virtual void SetWrapR(int)
vtkTextureObject::GetHandle
virtual unsigned int GetHandle()
Returns the OpenGL handle.
vtkImageData::GetSpacing
virtual double * GetSpacing()
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:63
vtkMapMaskTextureId::Map
std::map< vtkImageData *, vtkVolumeMask * > Map
Definition: vtkVolumeMask.h:353
vtkTextureObject::ClampToEdge
Definition: vtkTextureObject.h:67
vtkVolumeMask::GetBuildTime
vtkTimeStamp GetBuildTime()
Definition: vtkVolumeMask.h:56
vtkVolumeMask::LoadedBounds
double LoadedBounds[6]
Definition: vtkVolumeMask.h:342
vtkVolumeMask::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *window)
Definition: vtkVolumeMask.h:327
vtkRenderer::GetRenderWindow
vtkRenderWindow * GetRenderWindow()
Definition: vtkRenderer.h:420
vtkVolumeMask::LoadedCellFlag
int LoadedCellFlag
Definition: vtkVolumeMask.h:345
vtkVolumeMask::Deactivate
void Deactivate()
Definition: vtkVolumeMask.h:68
vtkVolumeMask::IsLoaded
bool IsLoaded()
Definition: vtkVolumeMask.h:310
vtkVolumeMask::Update
void Update(vtkRenderer *ren, vtkImageData *input, int cellFlag, int textureExtent[6], int scalarMode, int arrayAccessMode, int arrayId, const char *arrayName, vtkIdType maxMemoryInBytes)
Definition: vtkVolumeMask.h:74
vtkTextureObject::Activate
void Activate()
Activate and Bind the texture.
vtkOpenGLRenderWindow.h