VTK  9.2.6
vtkFixedPointVolumeRayCastMapper.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkFixedPointVolumeRayCastMapper.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 =========================================================================*/
65 #ifndef vtkFixedPointVolumeRayCastMapper_h
66 #define vtkFixedPointVolumeRayCastMapper_h
67 
68 #include "vtkRenderingVolumeModule.h" // For export macro
69 #include "vtkThreads.h" // for VTK_THREAD_RETURN_TYPE
70 #include "vtkVolumeMapper.h"
71 
72 #define VTKKW_FP_SHIFT 15
73 #define VTKKW_FPMM_SHIFT 17
74 #define VTKKW_FP_MASK 0x7fff
75 #define VTKKW_FP_SCALE 32767.0
76 
77 class vtkMatrix4x4;
78 class vtkMultiThreader;
79 class vtkPlaneCollection;
80 class vtkRenderer;
81 class vtkTimerLog;
82 class vtkVolume;
83 class vtkTransform;
84 class vtkRenderWindow;
98 class vtkDataArray;
99 
100 // Forward declaration needed for use by friend declaration below.
101 VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
102 VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
103 
104 class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
105 {
106 public:
109  void PrintSelf(ostream& os, vtkIndent indent) override;
110 
112 
117  vtkSetMacro(SampleDistance, float);
118  vtkGetMacro(SampleDistance, float);
120 
122 
129  vtkSetMacro(InteractiveSampleDistance, float);
130  vtkGetMacro(InteractiveSampleDistance, float);
132 
134 
141  vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
142  vtkGetMacro(ImageSampleDistance, float);
144 
146 
150  vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
151  vtkGetMacro(MinimumImageSampleDistance, float);
153 
155 
159  vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
160  vtkGetMacro(MaximumImageSampleDistance, float);
162 
164 
173  vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
174  vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
175  vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);
177 
179 
187  vtkSetClampMacro(LockSampleDistanceToInputSpacing, vtkTypeBool, 0, 1);
188  vtkGetMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
189  vtkBooleanMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
191 
193 
198  void SetNumberOfThreads(int num);
199  int GetNumberOfThreads();
201 
203 
207  vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
208  vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
209  vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);
211 
213 
220  float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren);
221  float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren, vtkVolume* vol);
223 
228  void Render(vtkRenderer*, vtkVolume*) override;
229 
230  unsigned int ToFixedPointPosition(float val);
231  void ToFixedPointPosition(float in[3], unsigned int out[3]);
232  unsigned int ToFixedPointDirection(float dir);
233  void ToFixedPointDirection(float in[3], unsigned int out[3]);
234  void FixedPointIncrement(unsigned int position[3], unsigned int increment[3]);
235  void GetFloatTripleFromPointer(float v[3], float* ptr);
236  void GetUIntTripleFromPointer(unsigned int v[3], unsigned int* ptr);
237  void ShiftVectorDown(unsigned int in[3], unsigned int out[3]);
238  int CheckMinMaxVolumeFlag(unsigned int pos[3], int c);
239  int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip);
240 
241  void LookupColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
242  unsigned short index, unsigned char color[4]);
243  void LookupDependentColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
244  unsigned short index[4], int components, unsigned char color[4]);
245  void LookupAndCombineIndependentColorsUC(unsigned short* colorTable[4],
246  unsigned short* scalarOpacityTable[4], unsigned short index[4], float weights[4],
247  int components, unsigned char color[4]);
248  int CheckIfCropped(unsigned int pos[3]);
249 
250  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
251  vtkGetObjectMacro(MIPHelper, vtkFixedPointVolumeRayCastMIPHelper);
252  vtkGetObjectMacro(CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper);
253  vtkGetObjectMacro(CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper);
254  vtkGetObjectMacro(CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper);
255  vtkGetObjectMacro(CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper);
256  vtkGetVectorMacro(TableShift, float, 4);
257  vtkGetVectorMacro(TableScale, float, 4);
258  vtkGetMacro(ShadingRequired, int);
259  vtkGetMacro(GradientOpacityRequired, int);
260 
261  vtkGetObjectMacro(CurrentScalars, vtkDataArray);
262  vtkGetObjectMacro(PreviousScalars, vtkDataArray);
263 
264  int* GetRowBounds() { return this->RowBounds; }
265  unsigned short* GetColorTable(int c) { return this->ColorTable[c]; }
266  unsigned short* GetScalarOpacityTable(int c) { return this->ScalarOpacityTable[c]; }
267  unsigned short* GetGradientOpacityTable(int c) { return this->GradientOpacityTable[c]; }
268  vtkVolume* GetVolume() { return this->Volume; }
269  unsigned short** GetGradientNormal() { return this->GradientNormal; }
270  unsigned char** GetGradientMagnitude() { return this->GradientMagnitude; }
271  unsigned short* GetDiffuseShadingTable(int c) { return this->DiffuseShadingTable[c]; }
272  unsigned short* GetSpecularShadingTable(int c) { return this->SpecularShadingTable[c]; }
273 
274  void ComputeRayInfo(
275  int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
276 
277  void InitializeRayInfo(vtkVolume* vol);
278 
279  int ShouldUseNearestNeighborInterpolation(vtkVolume* vol);
280 
282 
287  void SetRayCastImage(vtkFixedPointRayCastImage*);
288  vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
290 
291  int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
292  void PerVolumeInitialization(vtkRenderer*, vtkVolume*);
293  void PerSubVolumeInitialization(vtkRenderer*, vtkVolume*, int);
294  void RenderSubVolume();
295  void DisplayRenderedImage(vtkRenderer*, vtkVolume*);
296  void AbortRender();
297 
298  void CreateCanonicalView(vtkVolume* volume, vtkImageData* image, int blend_mode,
299  double viewDirection[3], double viewUp[3]);
300 
308  {
309  return this->RetrieveRenderTime(ren, vol);
310  }
311  float GetEstimatedRenderTime(vtkRenderer* ren) { return this->RetrieveRenderTime(ren); }
312 
314 
327  vtkSetMacro(FinalColorWindow, float);
328  vtkGetMacro(FinalColorWindow, float);
329  vtkSetMacro(FinalColorLevel, float);
330  vtkGetMacro(FinalColorLevel, float);
332 
333  // Here to be used by the mapper to tell the helper
334  // to flip the MIP comparison in order to support
335  // minimum intensity blending
336  vtkGetMacro(FlipMIPComparison, int);
337 
344  void ReleaseGraphicsResources(vtkWindow*) override;
345 
346 protected:
349 
350  // The helper class that displays the image
352 
353  // The distance between sample points along the ray
356 
357  // The distance between rays in the image
363 
364  // Saved values used to restore
367 
368  // Internal method for computing matrices needed during
369  // ray casting
370  void ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6],
371  vtkRenderer* ren, vtkVolume* vol);
372 
373  int ComputeRowBounds(vtkRenderer* ren, int imageFlag, int rowBoundsFlag, int inputExtent[6]);
374 
375  void CaptureZBuffer(vtkRenderer* ren);
376 
377  friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
378  friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
379 
381 
388 
390 
394 
395  // This object encapsulated the image and all related information
397 
398  int* RowBounds;
400 
406 
407  void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
408  float RetrieveRenderTime(vtkRenderer* ren, vtkVolume* vol);
409  float RetrieveRenderTime(vtkRenderer* ren);
410 
412 
414 
415  vtkColorTransferFunction* SavedRGBFunction[4];
416  vtkPiecewiseFunction* SavedGrayFunction[4];
417  vtkPiecewiseFunction* SavedScalarOpacityFunction[4];
418  vtkPiecewiseFunction* SavedGradientOpacityFunction[4];
419  int SavedColorChannels[4];
420  float SavedScalarOpacityDistance[4];
424 
427 
429 
430  unsigned short ColorTable[4][32768 * 3];
431  unsigned short ScalarOpacityTable[4][32768];
432  unsigned short GradientOpacityTable[4][256];
433  int TableSize[4];
434  float TableScale[4];
435  float TableShift[4];
436 
437  float GradientMagnitudeScale[4];
438  float GradientMagnitudeShift[4];
439 
440  unsigned short** GradientNormal;
441  unsigned char** GradientMagnitude;
442  unsigned short* ContiguousGradientNormal;
444 
446 
448 
450 
452 
453  unsigned short DiffuseShadingTable[4][65536 * 3];
454  unsigned short SpecularShadingTable[4][65536 * 3];
455 
458 
461 
464 
465  int ClipRayAgainstVolume(
466  double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
467 
468  int UpdateColorTable(vtkVolume* vol);
469  int UpdateGradients(vtkVolume* vol);
470  int UpdateShadingTable(vtkRenderer* ren, vtkVolume* vol);
471  void UpdateCroppingRegions();
472 
473  void ComputeGradients(vtkVolume* vol);
474 
475  int ClipRayAgainstClippingPlanes(
476  double rayStart[3], double rayEnd[3], int numClippingPlanes, float* clippingPlanes);
477 
478  unsigned int FixedPointCroppingRegionPlanes[6];
479  unsigned int CroppingRegionMask[27];
480 
481  // Get the ZBuffer value corresponding to location (x,y) where (x,y)
482  // are indexing into the ImageInUse image. This must be converted to
483  // the zbuffer image coordinates. Nearest neighbor value is returned.
484  float GetZBufferValue(int x, int y);
485 
491 
492  // Some variables used for ray computation
493  float ViewToVoxelsArray[16];
494  float WorldToVoxelsArray[16];
495  float VoxelsToWorldArray[16];
496 
497  double CroppingBounds[6];
498 
501 
502  double SavedSpacing[3];
503 
504  // Min Max structure used to do space leaping
505  unsigned short* MinMaxVolume;
506  int MinMaxVolumeSize[4];
510 
511  void UpdateMinMaxVolume(vtkVolume* vol);
512  void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
513 
516 
518 
519  void ApplyFinalColorWindowLevel();
520 
521 private:
523  void operator=(const vtkFixedPointVolumeRayCastMapper&) = delete;
524 
525  bool ThreadWarning;
526 };
527 
529 {
530  return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
531 }
532 
533 inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float in[3], unsigned int out[3])
534 {
535  out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
536  out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
537  out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
538 }
539 
541 {
542  return ((dir < 0.0) ? (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5))
543  : (0x80000000 + static_cast<unsigned int>(dir * VTKKW_FP_SCALE + 0.5)));
544 }
545 
547  float in[3], unsigned int out[3])
548 {
549  out[0] = ((in[0] < 0.0) ? (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5))
550  : (0x80000000 + static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5)));
551  out[1] = ((in[1] < 0.0) ? (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5))
552  : (0x80000000 + static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5)));
553  out[2] = ((in[2] < 0.0) ? (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5))
554  : (0x80000000 + static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5)));
555 }
556 
558  unsigned int position[3], unsigned int increment[3])
559 {
560  if (increment[0] & 0x80000000)
561  {
562  position[0] += (increment[0] & 0x7fffffff);
563  }
564  else
565  {
566  position[0] -= increment[0];
567  }
568  if (increment[1] & 0x80000000)
569  {
570  position[1] += (increment[1] & 0x7fffffff);
571  }
572  else
573  {
574  position[1] -= increment[1];
575  }
576  if (increment[2] & 0x80000000)
577  {
578  position[2] += (increment[2] & 0x7fffffff);
579  }
580  else
581  {
582  position[2] -= increment[2];
583  }
584 }
585 
587 {
588  v[0] = *(ptr);
589  v[1] = *(ptr + 1);
590  v[2] = *(ptr + 2);
591 }
592 
594  unsigned int v[3], unsigned int* ptr)
595 {
596  v[0] = *(ptr);
597  v[1] = *(ptr + 1);
598  v[2] = *(ptr + 2);
599 }
600 
602  unsigned int in[3], unsigned int out[3])
603 {
604  out[0] = in[0] >> VTKKW_FP_SHIFT;
605  out[1] = in[1] >> VTKKW_FP_SHIFT;
606  out[2] = in[2] >> VTKKW_FP_SHIFT;
607 }
608 
609 inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag(unsigned int mmpos[3], int c)
610 {
611  vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
612  (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
613  mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
614  static_cast<vtkIdType>(c);
615 
616  return ((*(this->MinMaxVolume + 3 * offset + 2)) & 0x00ff);
617 }
618 
620  unsigned int mmpos[3], int c, unsigned short maxIdx, int flip)
621 {
622  vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
623  (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
624  mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
625  static_cast<vtkIdType>(c);
626 
627  if ((*(this->MinMaxVolume + 3 * offset + 2) & 0x00ff))
628  {
629  if (flip)
630  {
631  return (*(this->MinMaxVolume + 3 * offset) < maxIdx);
632  }
633  else
634  {
635  return (*(this->MinMaxVolume + 3 * offset + 1) > maxIdx);
636  }
637  }
638  else
639  {
640  return 0;
641  }
642 }
643 
644 inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC(unsigned short* colorTable,
645  unsigned short* scalarOpacityTable, unsigned short index, unsigned char color[4])
646 {
647  unsigned short alpha = scalarOpacityTable[index];
648  color[0] = static_cast<unsigned char>(
649  (colorTable[3 * index] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
650  color[1] = static_cast<unsigned char>(
651  (colorTable[3 * index + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
652  color[2] = static_cast<unsigned char>(
653  (colorTable[3 * index + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
654  color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
655 }
656 
657 inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC(unsigned short* colorTable,
658  unsigned short* scalarOpacityTable, unsigned short index[4], int components,
659  unsigned char color[4])
660 {
661  unsigned short alpha;
662  switch (components)
663  {
664  case 2:
665  alpha = scalarOpacityTable[index[1]];
666  color[0] = static_cast<unsigned char>(
667  (colorTable[3 * index[0]] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
668  color[1] = static_cast<unsigned char>(
669  (colorTable[3 * index[0] + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
670  color[2] = static_cast<unsigned char>(
671  (colorTable[3 * index[0] + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
672  color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
673  break;
674  case 4:
675  alpha = scalarOpacityTable[index[3]];
676  color[0] = static_cast<unsigned char>((index[0] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
677  color[1] = static_cast<unsigned char>((index[1] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
678  color[2] = static_cast<unsigned char>((index[2] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
679  color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
680  break;
681  }
682 }
683 
685  unsigned short* colorTable[4], unsigned short* scalarOpacityTable[4], unsigned short index[4],
686  float weights[4], int components, unsigned char color[4])
687 {
688  unsigned int tmp[4] = { 0, 0, 0, 0 };
689 
690  for (int i = 0; i < components; i++)
691  {
692  unsigned short alpha =
693  static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]]) * weights[i]);
694  tmp[0] += static_cast<unsigned char>(
695  ((colorTable[i][3 * index[i]]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
696  tmp[1] += static_cast<unsigned char>(
697  ((colorTable[i][3 * index[i] + 1]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
698  tmp[2] += static_cast<unsigned char>(
699  ((colorTable[i][3 * index[i] + 2]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
700  tmp[3] += static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
701  }
702 
703  color[0] = static_cast<unsigned char>((tmp[0] > 255) ? (255) : (tmp[0]));
704  color[1] = static_cast<unsigned char>((tmp[1] > 255) ? (255) : (tmp[1]));
705  color[2] = static_cast<unsigned char>((tmp[2] > 255) ? (255) : (tmp[2]));
706  color[3] = static_cast<unsigned char>((tmp[3] > 255) ? (255) : (tmp[3]));
707 }
708 
710 {
711  int idx;
712 
713  if (pos[2] < this->FixedPointCroppingRegionPlanes[4])
714  {
715  idx = 0;
716  }
717  else if (pos[2] > this->FixedPointCroppingRegionPlanes[5])
718  {
719  idx = 18;
720  }
721  else
722  {
723  idx = 9;
724  }
725 
726  if (pos[1] >= this->FixedPointCroppingRegionPlanes[2])
727  {
728  if (pos[1] > this->FixedPointCroppingRegionPlanes[3])
729  {
730  idx += 6;
731  }
732  else
733  {
734  idx += 3;
735  }
736  }
737 
738  if (pos[0] >= this->FixedPointCroppingRegionPlanes[0])
739  {
740  if (pos[0] > this->FixedPointCroppingRegionPlanes[1])
741  {
742  idx += 2;
743  }
744  else
745  {
746  idx += 1;
747  }
748  }
749 
750  return !(static_cast<unsigned int>(this->CroppingRegionFlags) & this->CroppingRegionMask[idx]);
751 }
752 
753 #endif
int CroppingRegionFlags
Cropping variables, and a method for converting the world coordinate cropping region planes to voxel ...
void ShiftVectorDown(unsigned int in[3], unsigned int out[3])
vtkFixedPointVolumeRayCastMIPHelper * MIPHelper
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:50
vtkFixedPointVolumeRayCastCompositeShadeHelper * CompositeShadeHelper
vtkVolumeRayCastSpaceLeapingImageFilter * SpaceLeapFilter
Abstract class for a volume mapper.
encode a direction into a one or two byte value
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:41
A helper that generates composite images for the volume ray cast mapper.
void FixedPointIncrement(unsigned int position[3], unsigned int increment[3])
Use finite differences to estimate gradient.
Defines a 1D piecewise function.
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
A class for performing multithreaded execution.
record modification and/or execution time
Definition: vtkTimeStamp.h:35
maintain a list of planes
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
abstract specification for renderers
Definition: vtkRenderer.h:72
void GetUIntTripleFromPointer(unsigned int v[3], unsigned int *ptr)
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:60
int vtkIdType
Definition: vtkType.h:332
A helper that generates MIP images for the volume ray cast mapper.
helper class that draws the image to the screen
void Render(vtkRenderer *ren, vtkVolume *vol) override=0
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THIS METHOD OUTSIDE OF THE RENDERI...
#define VTKKW_FP_SCALE
int vtkTypeBool
Definition: vtkABI.h:69
Timer support and logging.
Definition: vtkTimerLog.h:95
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkFixedPointVolumeRayCastCompositeGOHelper * CompositeGOHelper
a simple class to control print indentation
Definition: vtkIndent.h:39
float GetEstimatedRenderTime(vtkRenderer *ren, vtkVolume *vol)
Get an estimate of the rendering time for a given volume / renderer.
topologically and geometrically regular array of data
Definition: vtkImageData.h:53
void LookupDependentColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index[4], int components, unsigned char color[4])
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
Compute shading tables for encoded normals.
int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip)
A helper that generates composite images for the volume ray cast mapper.
void ReleaseGraphicsResources(vtkWindow *) override
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being...
A helper that generates composite images for the volume ray cast mapper.
Defines a transfer function for mapping a property to an RGB color value.
create a window for renderers to draw into
vtkFixedPointVolumeRayCastCompositeHelper * CompositeHelper
A helper that generates composite images for the volume ray cast mapper.
void LookupAndCombineIndependentColorsUC(unsigned short *colorTable[4], unsigned short *scalarOpacityTable[4], unsigned short index[4], float weights[4], int components, unsigned char color[4])
int CheckMinMaxVolumeFlag(unsigned int pos[3], int c)
void LookupColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index, unsigned char color[4])
vtkFixedPointVolumeRayCastCompositeGOShadeHelper * CompositeGOShadeHelper
static vtkAlgorithm * New()
vtkRayCastImageDisplayHelper * ImageDisplayHelper
#define VTKKW_FP_SHIFT
vtkFiniteDifferenceGradientEstimator * GradientEstimator
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void GetFloatTripleFromPointer(float v[3], float *ptr)
helper class for a ray cast image