VTK
vtkOpenGLVolumeGradientOpacityTable.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkOpenGLVolumeGradientOpacityTable.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 vtkOpenGLVolumeGradientOpacityTable_h
17 #define vtkOpenGLVolumeGradientOpacityTable_h
18 
19 #include <vector>
20 
21 #include <vtkObjectFactory.h>
22 #include <vtkPiecewiseFunction.h>
23 #include <vtkTextureObject.h>
24 #include <vtkVolumeMapper.h>
25 #include <vtkMath.h>
26 #include <vtk_glew.h>
27 
28 
29 //----------------------------------------------------------------------------
31 {
32 public:
33 
35 
36  // activate texture.
37  //--------------------------------------------------------------------------
38  void Activate()
39  {
40  if (!this->TextureObject)
41  {
42  return;
43  }
44  this->TextureObject->Activate();
45  }
46 
47  void Deactivate()
48  {
49  if (!this->TextureObject)
50  {
51  return;
52  }
53  this->TextureObject->Deactivate();
54  }
55 
56  // Update opacity tranfer function texture.
57  //--------------------------------------------------------------------------
58  void Update(vtkPiecewiseFunction* gradientOpacity,
59  double sampleDistance,
60  double range[2],
61  double vtkNotUsed(unitDistance),
62  int filterValue,
63  vtkOpenGLRenderWindow* renWin)
64  {
65  bool needUpdate=false;
66 
67  if (!this->TextureObject)
68  {
70  }
71 
72  this->TextureObject->SetContext(renWin);
73 
74  if (this->LastRange[0] != range[0] ||
75  this->LastRange[1] != range[1])
76  {
77  this->LastRange[0] = range[0];
78  this->LastRange[1] = range[1];
79  needUpdate = true;
80  }
81 
82  if(gradientOpacity->GetMTime() > this->BuildTime ||
83  this->TextureObject->GetMTime() > this->BuildTime ||
84  this->LastSampleDistance != sampleDistance ||
85  needUpdate || !this->TextureObject->GetHandle())
86  {
87  int const idealW = gradientOpacity->EstimateMinNumberOfSamples(this->LastRange[0],
88  this->LastRange[1]);
89  int const newWidth = this->GetMaximumSupportedTextureWidth(renWin, idealW);
90 
91  if(this->Table == NULL || this->TextureWidth != newWidth)
92  {
93  this->TextureWidth = newWidth;
94  delete [] this->Table;
95  this->Table = new float[this->TextureWidth];
96  }
97 
98  gradientOpacity->GetTable(0,
99  (this->LastRange[1] - this->LastRange[0]) * 0.25,
100  this->TextureWidth, this->Table);
101 
102  this->TextureObject->Create2DFromRaw(this->TextureWidth, 1, 1,
103  VTK_FLOAT,
104  this->Table);
105 
107  this->TextureObject->SetMagnificationFilter(filterValue);
108  this->TextureObject->SetMinificationFilter(filterValue);
109  this->BuildTime.Modified();
110  }
111 
112  if(this->LastInterpolation != filterValue)
113  {
114  this->LastInterpolation = filterValue;
115  this->TextureObject->SetMagnificationFilter(filterValue);
116  this->TextureObject->SetMinificationFilter(filterValue);
117  }
118  }
119 
120  //--------------------------------------------------------------------------
122  int idealWidth)
123  {
124  if (!this->TextureObject)
125  {
126  vtkErrorMacro("vtkTextureObject not initialized!");
127  return -1;
128  }
129 
130  // Try to match the next power of two.
131  idealWidth = vtkMath::NearestPowerOfTwo(idealWidth);
132  int const maxWidth = this->TextureObject->GetMaximumTextureSize(renWin);
133  if (maxWidth < 0)
134  {
135  vtkErrorMacro("Failed to query max texture size! using default 1024.");
136  return 1024;
137  }
138 
139  if (maxWidth >= idealWidth)
140  {
141  idealWidth = vtkMath::Max(1024, idealWidth);
142  return idealWidth;
143  }
144 
145  vtkWarningMacro("This OpenGL implementation does not support the required "
146  "texture size of " << idealWidth << ", falling back to maximum allowed, "
147  << maxWidth << "." << "This may cause an incorrect color table mapping.");
148 
149  return maxWidth;
150  }
151 
152  // Get the texture unit
153  //--------------------------------------------------------------------------
154  int GetTextureUnit(void)
155  {
156  if (!this->TextureObject)
157  {
158  return -1;
159  }
160  return this->TextureObject->GetTextureUnit();
161  }
162 
163  //--------------------------------------------------------------------------
165  {
166  if (this->TextureObject)
167  {
169  this->TextureObject->Delete();
170  this->TextureObject = 0;
171  }
172  }
173 
174 protected:
175  //--------------------------------------------------------------------------
177  {
178  this->TextureObject = NULL;
179  this->TextureWidth = width;
180  this->LastSampleDistance = 1.0;
181  this->Table = NULL;
182  this->LastInterpolation = -1;
183  this->LastRange[0] = this->LastRange[1] = 0.0;
184  }
185 
186  //--------------------------------------------------------------------------
188  {
189  if (this->TextureObject)
190  {
191  this->TextureObject->Delete();
192  this->TextureObject = NULL;
193  }
194 
195  delete[] this->Table;
196  }
197 
200 
203  float* Table;
205  double LastRange[2];
206 
207 private:
209  VTK_DELETE_FUNCTION;
211  const vtkOpenGLVolumeGradientOpacityTable&) VTK_DELETE_FUNCTION;
212 };
213 
215 
216 
219 {
220 public:
221  //--------------------------------------------------------------------------
222  vtkOpenGLVolumeGradientOpacityTables(unsigned int numberOfTables)
223  {
224  this->Tables.reserve(static_cast<size_t>(numberOfTables));
225 
226  for (unsigned int i = 0; i < numberOfTables; i++)
227  {
230  this->Tables.push_back(table);
231  }
232  }
233 
234  //--------------------------------------------------------------------------
236  {
237  size_t const size = this->Tables.size();
238  for (size_t i = 0; i < size; i++)
239  {
240  this->Tables[i]->Delete();
241  }
242  }
243 
244  // Get opacity table at a given index.
245  //--------------------------------------------------------------------------
247  {
248  if (i >= this->Tables.size())
249  {
250  return NULL;
251  }
252  return this->Tables[i];
253  }
254 
255  // Get number of tables.
256  //--------------------------------------------------------------------------
258  {
259  return this->Tables.size();
260  }
261 
262  //--------------------------------------------------------------------------
264  {
265  size_t const size = this->Tables.size();
266  for (size_t i = 0; i < size; ++i)
267  {
268  this->Tables[i]->ReleaseGraphicsResources(window);
269  }
270  }
271 private:
272  std::vector<vtkOpenGLVolumeGradientOpacityTable*> Tables;
273 
274  vtkOpenGLVolumeGradientOpacityTables() VTK_DELETE_FUNCTION;
275 
277 
278  vtkOpenGLVolumeGradientOpacityTables &operator=(const vtkOpenGLVolumeGradientOpacityTables &other) VTK_DELETE_FUNCTION;
279 };
280 
281 #endif // vtkOpenGLVolumeGradientOpacityTable_h
282 // VTK-HeaderTest-Exclude: vtkOpenGLVolumeGradientOpacityTable.h
vtkPiecewiseFunction.h
vtkTextureObject::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *win)
Deactivate and UnBind the texture.
vtkOpenGLVolumeGradientOpacityTables::GetTable
vtkOpenGLVolumeGradientOpacityTable * GetTable(unsigned int i)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:246
vtkOpenGLVolumeGradientOpacityTable::vtkOpenGLVolumeGradientOpacityTable
vtkOpenGLVolumeGradientOpacityTable(int width=1024)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:176
vtkOpenGLVolumeGradientOpacityTables
Definition: vtkOpenGLVolumeGradientOpacityTable.h:219
vtkOpenGLVolumeGradientOpacityTable::Table
float * Table
Definition: vtkOpenGLVolumeGradientOpacityTable.h:203
vtkMath::NearestPowerOfTwo
static int NearestPowerOfTwo(int x)
Compute the nearest power of two that is not less than x.
Definition: vtkMath.h:1230
vtkTextureObject::SetMinificationFilter
virtual void SetMinificationFilter(int)
vtkMath.h
vtkOpenGLVolumeGradientOpacityTable::Deactivate
void Deactivate()
Definition: vtkOpenGLVolumeGradientOpacityTable.h:47
vtkOpenGLVolumeGradientOpacityTable::TextureObject
vtkTextureObject * TextureObject
Definition: vtkOpenGLVolumeGradientOpacityTable.h:198
vtkOpenGLVolumeGradientOpacityTables::GetNumberOfTables
size_t GetNumberOfTables()
Definition: vtkOpenGLVolumeGradientOpacityTable.h:257
vtkOpenGLVolumeGradientOpacityTable::BuildTime
vtkTimeStamp BuildTime
Definition: vtkOpenGLVolumeGradientOpacityTable.h:202
vtkMath::Max
static T Max(const T &a, const T &b)
Returns the maximum of the two arugments provided.
Definition: vtkMath.h:1268
vtkTextureObject::SetWrapS
virtual void SetWrapS(int)
vtkOpenGLVolumeGradientOpacityTable::Activate
void Activate()
Definition: vtkOpenGLVolumeGradientOpacityTable.h:38
vtkPiecewiseFunction::GetTable
void GetTable(double x1, double x2, int size, float *table, int stride=1)
Fills in an array of function values evaluated at regular intervals.
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
vtkOpenGLVolumeGradientOpacityTables::~vtkOpenGLVolumeGradientOpacityTables
~vtkOpenGLVolumeGradientOpacityTables()
Definition: vtkOpenGLVolumeGradientOpacityTable.h:235
vtkX3D::range
@ range
Definition: vtkX3D.h:238
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:60
vtkOpenGLVolumeGradientOpacityTable
Definition: vtkOpenGLVolumeGradientOpacityTable.h:31
vtkTextureObject::GetMaximumTextureSize
static int GetMaximumTextureSize(vtkOpenGLRenderWindow *context)
Query and return maximum texture size (dimension) supported by the OpenGL driver for a particular con...
vtkOpenGLVolumeGradientOpacityTable::LastInterpolation
int LastInterpolation
Definition: vtkOpenGLVolumeGradientOpacityTable.h:204
vtkObjectFactory.h
vtkObjectBase::Delete
virtual void Delete()
Delete a VTK object.
vtkTextureObject::Activate
void Activate(unsigned int texUnit)
Set the active tex unit and bind (using our bind).
vtkPiecewiseFunction::EstimateMinNumberOfSamples
int EstimateMinNumberOfSamples(double const &x1, double const &x2)
Estimates the minimum size of a table such that it would correctly sample this function.
vtkOpenGLVolumeGradientOpacityTable::New
static vtkOpenGLVolumeGradientOpacityTable * New()
vtkTextureObject::GetTextureUnit
int GetTextureUnit()
Return the texture unit used for this texture.
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:35
vtkDataObject::GetMTime
vtkMTimeType GetMTime() override
Data objects are composite objects and need to check each part for MTime.
vtkOpenGLVolumeGradientOpacityTable::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *window)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:164
vtkTimeStamp::Modified
void Modified()
Set this objects time to the current time.
vtkTextureObject::SetContext
void SetContext(vtkRenderWindow *)
Get/Set the context.
vtkVolumeMapper.h
vtkOpenGLVolumeGradientOpacityTable::LastSampleDistance
double LastSampleDistance
Definition: vtkOpenGLVolumeGradientOpacityTable.h:201
vtkOpenGLVolumeGradientOpacityTable::GetMaximumSupportedTextureWidth
int GetMaximumSupportedTextureWidth(vtkOpenGLRenderWindow *renWin, int idealWidth)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:121
vtkTextureObject
abstracts an OpenGL texture object.
Definition: vtkTextureObject.h:44
vtkTextureObject::New
static vtkTextureObject * New()
VTK_FLOAT
#define VTK_FLOAT
Definition: vtkType.h:58
vtkOpenGLVolumeGradientOpacityTable::Update
void Update(vtkPiecewiseFunction *gradientOpacity, double sampleDistance, double range[2], double vtkNotUsed(unitDistance), int filterValue, vtkOpenGLRenderWindow *renWin)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:58
vtkX3D::size
@ size
Definition: vtkX3D.h:253
vtkTextureObject::Deactivate
void Deactivate(unsigned int texUnit)
vtkTextureObject::SetMagnificationFilter
virtual void SetMagnificationFilter(int)
vtkPiecewiseFunction
Defines a 1D piecewise function.
Definition: vtkPiecewiseFunction.h:52
vtkTextureObject::ClampToEdge
@ ClampToEdge
Definition: vtkTextureObject.h:74
vtkOpenGLVolumeGradientOpacityTable::LastRange
double LastRange[2]
Definition: vtkOpenGLVolumeGradientOpacityTable.h:205
vtkOpenGLVolumeGradientOpacityTable::~vtkOpenGLVolumeGradientOpacityTable
~vtkOpenGLVolumeGradientOpacityTable()
Definition: vtkOpenGLVolumeGradientOpacityTable.h:187
vtkOpenGLVolumeGradientOpacityTable::TextureWidth
int TextureWidth
Definition: vtkOpenGLVolumeGradientOpacityTable.h:199
vtkOpenGLRenderWindow
OpenGL rendering window.
Definition: vtkOpenGLRenderWindow.h:42
vtkOpenGLVolumeGradientOpacityTables::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *window)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:263
vtkOpenGLVolumeGradientOpacityTables::vtkOpenGLVolumeGradientOpacityTables
vtkOpenGLVolumeGradientOpacityTables(unsigned int numberOfTables)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:222
vtkTextureObject::Create2DFromRaw
bool Create2DFromRaw(unsigned int width, unsigned int height, int numComps, int dataType, void *data)
Create a 2D texture from client memory numComps must be in [1-4].
vtkOpenGLVolumeGradientOpacityTable::GetTextureUnit
int GetTextureUnit(void)
Definition: vtkOpenGLVolumeGradientOpacityTable.h:154
vtkStandardNewMacro
vtkStandardNewMacro(vtkOpenGLVolumeGradientOpacityTable)