VTK
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 =========================================================================*/
67 #ifndef vtkFixedPointVolumeRayCastMapper_h
68 #define vtkFixedPointVolumeRayCastMapper_h
69 
70 #include "vtkRenderingVolumeModule.h" // For export macro
71 #include "vtkVolumeMapper.h"
72 
73 #define VTKKW_FP_SHIFT 15
74 #define VTKKW_FPMM_SHIFT 17
75 #define VTKKW_FP_MASK 0x7fff
76 #define VTKKW_FP_SCALE 32767.0
77 
78 class vtkMatrix4x4;
79 class vtkMultiThreader;
80 class vtkPlaneCollection;
81 class vtkRenderer;
82 class vtkTimerLog;
83 class vtkVolume;
84 class vtkTransform;
85 class vtkRenderWindow;
99 class vtkDataArray;
100 
101 // Forward declaration needed for use by friend declaration below.
104 
105 class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
106 {
107 public:
110  void PrintSelf( ostream& os, vtkIndent indent );
111 
113 
118  vtkSetMacro( SampleDistance, float );
119  vtkGetMacro( SampleDistance, float );
121 
123 
130  vtkSetMacro( InteractiveSampleDistance, float );
131  vtkGetMacro( InteractiveSampleDistance, float );
133 
135 
142  vtkSetClampMacro( ImageSampleDistance, float, 0.1f, 100.0f );
143  vtkGetMacro( ImageSampleDistance, float );
145 
147 
151  vtkSetClampMacro( MinimumImageSampleDistance, float, 0.1f, 100.0f );
152  vtkGetMacro( MinimumImageSampleDistance, float );
154 
156 
160  vtkSetClampMacro( MaximumImageSampleDistance, float, 0.1f, 100.0f );
161  vtkGetMacro( MaximumImageSampleDistance, float );
163 
165 
174  vtkSetClampMacro( AutoAdjustSampleDistances, int, 0, 1 );
175  vtkGetMacro( AutoAdjustSampleDistances, int );
176  vtkBooleanMacro( AutoAdjustSampleDistances, int );
178 
180 
188  vtkSetClampMacro( LockSampleDistanceToInputSpacing, int, 0, 1 );
189  vtkGetMacro( LockSampleDistanceToInputSpacing, int );
190  vtkBooleanMacro( LockSampleDistanceToInputSpacing, int );
192 
194 
199  void SetNumberOfThreads( int num );
202 
204 
208  vtkSetClampMacro( IntermixIntersectingGeometry, int, 0, 1 );
209  vtkGetMacro( IntermixIntersectingGeometry, int );
210  vtkBooleanMacro( IntermixIntersectingGeometry, int );
212 
214 
221  float ComputeRequiredImageSampleDistance( float desiredTime,
222  vtkRenderer *ren );
223  float ComputeRequiredImageSampleDistance( float desiredTime,
224  vtkRenderer *ren,
225  vtkVolume *vol );
227 
233 
234  unsigned int ToFixedPointPosition( float val );
235  void ToFixedPointPosition( float in[3], unsigned int out[3] );
236  unsigned int ToFixedPointDirection( float dir );
237  void ToFixedPointDirection( float in[3], unsigned int out[3] );
238  void FixedPointIncrement( unsigned int position[3], unsigned int increment[3] );
239  void GetFloatTripleFromPointer( float v[3], float *ptr );
240  void GetUIntTripleFromPointer( unsigned int v[3], unsigned int *ptr );
241  void ShiftVectorDown( unsigned int in[3], unsigned int out[3] );
242  int CheckMinMaxVolumeFlag( unsigned int pos[3], int c );
243  int CheckMIPMinMaxVolumeFlag( unsigned int pos[3], int c, unsigned short maxIdx, int flip );
244 
245  void LookupColorUC( unsigned short *colorTable,
246  unsigned short *scalarOpacityTable,
247  unsigned short index,
248  unsigned char color[4] );
249  void LookupDependentColorUC( unsigned short *colorTable,
250  unsigned short *scalarOpacityTable,
251  unsigned short index[4],
252  int components,
253  unsigned char color[4] );
254  void LookupAndCombineIndependentColorsUC(
255  unsigned short *colorTable[4],
256  unsigned short *scalarOpacityTable[4],
257  unsigned short index[4],
258  float weights[4],
259  int components,
260  unsigned char color[4] );
261  int CheckIfCropped( unsigned int pos[3] );
262 
263  vtkGetObjectMacro( RenderWindow, vtkRenderWindow );
264  vtkGetObjectMacro( MIPHelper, vtkFixedPointVolumeRayCastMIPHelper );
265  vtkGetObjectMacro( CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper );
266  vtkGetObjectMacro( CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper );
267  vtkGetObjectMacro( CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper );
268  vtkGetObjectMacro( CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper );
269  vtkGetVectorMacro( TableShift, float, 4 );
270  vtkGetVectorMacro( TableScale, float, 4 );
271  vtkGetMacro( ShadingRequired, int );
272  vtkGetMacro( GradientOpacityRequired, int );
273 
274  vtkGetObjectMacro( CurrentScalars, vtkDataArray );
275  vtkGetObjectMacro( PreviousScalars, vtkDataArray );
276 
277 
278  int *GetRowBounds() {return this->RowBounds;}
279  unsigned short *GetColorTable(int c) {return this->ColorTable[c];}
280  unsigned short *GetScalarOpacityTable(int c) {return this->ScalarOpacityTable[c];}
281  unsigned short *GetGradientOpacityTable(int c) {return this->GradientOpacityTable[c];}
282  vtkVolume *GetVolume() {return this->Volume;}
283  unsigned short **GetGradientNormal() {return this->GradientNormal;}
284  unsigned char **GetGradientMagnitude() {return this->GradientMagnitude;}
285  unsigned short *GetDiffuseShadingTable(int c) {return this->DiffuseShadingTable[c];}
286  unsigned short *GetSpecularShadingTable(int c) {return this->SpecularShadingTable[c];}
287 
288  void ComputeRayInfo( int x, int y,
289  unsigned int pos[3],
290  unsigned int dir[3],
291  unsigned int *numSteps );
292 
294 
296 
298 
304  vtkGetObjectMacro( RayCastImage, vtkFixedPointRayCastImage );
306 
308  double *, double *, int * );
313  void AbortRender();
314 
317  int blend_mode,
318  double viewDirection[3],
319  double viewUp[3] );
320 
328  vtkVolume *vol )
329  { return this->RetrieveRenderTime( ren, vol ); }
331  { return this->RetrieveRenderTime( ren ); }
332 
333 
335 
348  vtkSetMacro( FinalColorWindow, float );
349  vtkGetMacro( FinalColorWindow, float );
350  vtkSetMacro( FinalColorLevel, float );
351  vtkGetMacro( FinalColorLevel, float );
353 
354 
355  // Here to be used by the mapper to tell the helper
356  // to flip the MIP comparison in order to support
357  // minimum intensity blending
358  vtkGetMacro( FlipMIPComparison, int );
359 
367 
368 protected:
371 
372  // The helper class that displays the image
374 
375  // The distance between sample points along the ray
378 
379  // The distance between rays in the image
385 
386  // Saved values used to restore
389 
390  // Internal method for computing matrices needed during
391  // ray casting
392  void ComputeMatrices( double volumeOrigin[3],
393  double volumeSpacing[3],
394  int volumeExtent[6],
395  vtkRenderer *ren,
396  vtkVolume *vol );
397 
399  int imageFlag, int rowBoundsFlag,
400  int volumeExtent[6]);
401 
403 
406 
408 
415 
417 
421 
422  // This object encapsulated the image and all related information
424 
425  int *RowBounds;
427 
433 
434  void StoreRenderTime( vtkRenderer *ren, vtkVolume *vol, float t );
437 
439 
441 
442  vtkColorTransferFunction *SavedRGBFunction[4];
443  vtkPiecewiseFunction *SavedGrayFunction[4];
444  vtkPiecewiseFunction *SavedScalarOpacityFunction[4];
445  vtkPiecewiseFunction *SavedGradientOpacityFunction[4];
446  int SavedColorChannels[4];
447  float SavedScalarOpacityDistance[4];
451 
454 
456 
457 
458  unsigned short ColorTable[4][32768*3];
459  unsigned short ScalarOpacityTable[4][32768];
460  unsigned short GradientOpacityTable[4][256];
461  int TableSize[4];
462  float TableScale[4];
463  float TableShift[4];
464 
465  float GradientMagnitudeScale[4];
466  float GradientMagnitudeShift[4];
467 
468  unsigned short **GradientNormal;
469  unsigned char **GradientMagnitude;
470  unsigned short *ContiguousGradientNormal;
472 
474 
476 
478 
480 
481  unsigned short DiffuseShadingTable [4][65536*3];
482  unsigned short SpecularShadingTable[4][65536*3];
483 
486 
489 
492 
493  int ClipRayAgainstVolume( float rayStart[3],
494  float rayEnd[3],
495  float rayDirection[3],
496  double bounds[6] );
497 
501  vtkVolume *vol );
503 
505 
506  int ClipRayAgainstClippingPlanes( float rayStart[3],
507  float rayEnd[3],
508  int numClippingPlanes,
509  float *clippingPlanes );
510 
511  unsigned int FixedPointCroppingRegionPlanes[6];
512  unsigned int CroppingRegionMask[27];
513 
514  // Get the ZBuffer value corresponding to location (x,y) where (x,y)
515  // are indexing into the ImageInUse image. This must be converted to
516  // the zbuffer image coordinates. Nearest neighbor value is returned.
517  float GetZBufferValue( int x, int y );
518 
524 
525  // Some variables used for ray computation
526  float ViewToVoxelsArray[16];
527  float WorldToVoxelsArray[16];
528  float VoxelsToWorldArray[16];
529 
530  double CroppingBounds[6];
531 
534 
535  double SavedSpacing[3];
536 
537 
538  // Min Max structure used to do space leaping
539  unsigned short *MinMaxVolume;
540  int MinMaxVolumeSize[4];
544 
546  void FillInMaxGradientMagnitudes( int fullDim[3],
547  int smallDim[3] );
548 
551 
553 
555 
556 private:
558  void operator=(const vtkFixedPointVolumeRayCastMapper&) VTK_DELETE_FUNCTION;
559 
560  bool ThreadWarning;
561 };
562 
563 
565 {
566  return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
567 }
568 
569 inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition( float in[3], unsigned int out[3] )
570 {
571  out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
572  out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
573  out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
574 }
575 
577 {
578  return ((dir<0.0)?
579  (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5)):
580  (0x80000000+static_cast<unsigned int>(dir*VTKKW_FP_SCALE + 0.5)));
581 }
582 
583 inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointDirection( float in[3], unsigned int out[3] )
584 {
585  out[0] = ((in[0]<0.0)?
586  (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5)):
587  (0x80000000+
588  static_cast<unsigned int>(in[0]*VTKKW_FP_SCALE + 0.5)));
589  out[1] = ((in[1]<0.0)?
590  (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5)):
591  (0x80000000+
592  static_cast<unsigned int>(in[1]*VTKKW_FP_SCALE + 0.5)));
593  out[2] = ((in[2]<0.0)?
594  (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5)):
595  (0x80000000+
596  static_cast<unsigned int>(in[2]*VTKKW_FP_SCALE + 0.5)));
597 }
598 
599 inline void vtkFixedPointVolumeRayCastMapper::FixedPointIncrement( unsigned int position[3], unsigned int increment[3] )
600 {
601  if ( increment[0]&0x80000000 )
602  {
603  position[0] += (increment[0]&0x7fffffff);
604  }
605  else
606  {
607  position[0] -= increment[0];
608  }
609  if ( increment[1]&0x80000000 )
610  {
611  position[1] += (increment[1]&0x7fffffff);
612  }
613  else
614  {
615  position[1] -= increment[1];
616  }
617  if ( increment[2]&0x80000000 )
618  {
619  position[2] += (increment[2]&0x7fffffff);
620  }
621  else
622  {
623  position[2] -= increment[2];
624  }
625 }
626 
627 
629 {
630  v[0] = *(ptr);
631  v[1] = *(ptr+1);
632  v[2] = *(ptr+2);
633 }
634 
635 inline void vtkFixedPointVolumeRayCastMapper::GetUIntTripleFromPointer( unsigned int v[3], unsigned int *ptr )
636 {
637  v[0] = *(ptr);
638  v[1] = *(ptr+1);
639  v[2] = *(ptr+2);
640 }
641 
643  unsigned int out[3] )
644 {
645  out[0] = in[0] >> VTKKW_FP_SHIFT;
646  out[1] = in[1] >> VTKKW_FP_SHIFT;
647  out[2] = in[2] >> VTKKW_FP_SHIFT;
648 }
649 
650 inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag( unsigned int mmpos[3], int c )
651 {
652  vtkIdType offset =
653  static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
654  ( mmpos[2]*static_cast<vtkIdType>(
655  this->MinMaxVolumeSize[0]*this->MinMaxVolumeSize[1]) +
656  mmpos[1]*static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) +
657  mmpos[0] ) + static_cast<vtkIdType>(c);
658 
659  return ((*(this->MinMaxVolume + 3*offset + 2))&0x00ff);
660 }
661 
662 inline int vtkFixedPointVolumeRayCastMapper::CheckMIPMinMaxVolumeFlag( unsigned int mmpos[3], int c,
663  unsigned short maxIdx, int flip )
664 {
665  vtkIdType offset =
666  static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
667  ( mmpos[2]*static_cast<vtkIdType>(
668  this->MinMaxVolumeSize[0]*this->MinMaxVolumeSize[1]) +
669  mmpos[1]*static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) +
670  mmpos[0] ) + static_cast<vtkIdType>(c);
671 
672  if ( (*(this->MinMaxVolume + 3*offset + 2)&0x00ff) )
673  {
674  if (flip)
675  {
676  return ( *(this->MinMaxVolume + 3*offset) < maxIdx );
677  }
678  else
679  {
680  return ( *(this->MinMaxVolume + 3*offset + 1) > maxIdx );
681  }
682  }
683  else
684  {
685  return 0;
686  }
687 }
688 
689 inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC( unsigned short *colorTable,
690  unsigned short *scalarOpacityTable,
691  unsigned short index,
692  unsigned char color[4] )
693 {
694  unsigned short alpha = scalarOpacityTable[index];
695  color[0] = static_cast<unsigned char>
696  ((colorTable[3*index ]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
697  color[1] = static_cast<unsigned char>
698  ((colorTable[3*index+1]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
699  color[2] = static_cast<unsigned char>
700  ((colorTable[3*index+2]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
701  color[3] = static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
702 }
703 
704 inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC( unsigned short *colorTable,
705  unsigned short *scalarOpacityTable,
706  unsigned short index[4],
707  int components,
708  unsigned char color[4] )
709 {
710  unsigned short alpha;
711  switch ( components )
712  {
713  case 2:
714  alpha = scalarOpacityTable[index[1]];
715  color[0] = static_cast<unsigned char>
716  ((colorTable[3*index[0] ]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
717  color[1] = static_cast<unsigned char>
718  ((colorTable[3*index[0]+1]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
719  color[2] = static_cast<unsigned char>
720  ((colorTable[3*index[0]+2]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
721  color[3] = static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
722  break;
723  case 4:
724  alpha = scalarOpacityTable[index[3]];
725  color[0] = static_cast<unsigned char>((index[0]*alpha + 0x7fff)>>VTKKW_FP_SHIFT );
726  color[1] = static_cast<unsigned char>((index[1]*alpha + 0x7fff)>>VTKKW_FP_SHIFT );
727  color[2] = static_cast<unsigned char>((index[2]*alpha + 0x7fff)>>VTKKW_FP_SHIFT );
728  color[3] = static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
729  break;
730  }
731 }
732 
733 
735  unsigned short *scalarOpacityTable[4],
736  unsigned short index[4],
737  float weights[4],
738  int components,
739  unsigned char color[4] )
740 {
741  unsigned int tmp[4] = {0,0,0,0};
742 
743  for ( int i = 0; i < components; i++ )
744  {
745  unsigned short alpha = static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]])*weights[i]);
746  tmp[0] += static_cast<unsigned char>(((colorTable[i][3*index[i] ])*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
747  tmp[1] += static_cast<unsigned char>(((colorTable[i][3*index[i]+1])*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
748  tmp[2] += static_cast<unsigned char>(((colorTable[i][3*index[i]+2])*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
749  tmp[3] += static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
750  }
751 
752  color[0] = static_cast<unsigned char>((tmp[0]>255)?(255):(tmp[0]));
753  color[1] = static_cast<unsigned char>((tmp[1]>255)?(255):(tmp[1]));
754  color[2] = static_cast<unsigned char>((tmp[2]>255)?(255):(tmp[2]));
755  color[3] = static_cast<unsigned char>((tmp[3]>255)?(255):(tmp[3]));
756 
757 }
758 
759 inline int vtkFixedPointVolumeRayCastMapper::CheckIfCropped( unsigned int pos[3] )
760 {
761  int idx;
762 
763  if ( pos[2] < this->FixedPointCroppingRegionPlanes[4] )
764  {
765  idx = 0;
766  }
767  else if ( pos[2] > this->FixedPointCroppingRegionPlanes[5] )
768  {
769  idx = 18;
770  }
771  else
772  {
773  idx = 9;
774  }
775 
776  if ( pos[1] >= this->FixedPointCroppingRegionPlanes[2] )
777  {
778  if ( pos[1] > this->FixedPointCroppingRegionPlanes[3] )
779  {
780  idx += 6;
781  }
782  else
783  {
784  idx += 3;
785  }
786  }
787 
788  if ( pos[0] >= this->FixedPointCroppingRegionPlanes[0] )
789  {
790  if ( pos[0] > this->FixedPointCroppingRegionPlanes[1] )
791  {
792  idx += 2;
793  }
794  else
795  {
796  idx += 1;
797  }
798  }
799 
800  return !(static_cast<unsigned int>(this->CroppingRegionFlags)
801  &this->CroppingRegionMask[idx]);
802 }
803 
804 #endif
vtkFixedPointVolumeRayCastMapper::GetSpecularShadingTable
unsigned short * GetSpecularShadingTable(int c)
Definition: vtkFixedPointVolumeRayCastMapper.h:286
vtkFixedPointVolumeRayCastMapper::ContiguousGradientNormal
unsigned short * ContiguousGradientNormal
Definition: vtkFixedPointVolumeRayCastMapper.h:470
vtkFixedPointVolumeRayCastMapper::RenderRendererTable
vtkRenderer ** RenderRendererTable
Definition: vtkFixedPointVolumeRayCastMapper.h:430
vtkFixedPointVolumeRayCastMapper::GetGradientMagnitude
unsigned char ** GetGradientMagnitude()
Definition: vtkFixedPointVolumeRayCastMapper.h:284
vtkVolumeMapper
Abstract class for a volume mapper.
Definition: vtkVolumeMapper.h:50
vtkFixedPointVolumeRayCastMapper::GetGradientNormal
unsigned short ** GetGradientNormal()
Definition: vtkFixedPointVolumeRayCastMapper.h:283
vtkFixedPointVolumeRayCastMapper::ComputeMatrices
void ComputeMatrices(double volumeOrigin[3], double volumeSpacing[3], int volumeExtent[6], vtkRenderer *ren, vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::OldRowBounds
int * OldRowBounds
Definition: vtkFixedPointVolumeRayCastMapper.h:426
vtkFixedPointVolumeRayCastMapper::Threader
vtkMultiThreader * Threader
Definition: vtkFixedPointVolumeRayCastMapper.h:407
vtkX3D::alpha
@ alpha
Definition: vtkX3D.h:250
vtkVolume
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:51
vtkFixedPointVolumeRayCastMapper::UpdateGradients
int UpdateGradients(vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::SavedMinMaxInput
vtkImageData * SavedMinMaxInput
Definition: vtkFixedPointVolumeRayCastMapper.h:541
vtkFixedPointRayCastImage
helper class for a ray cast image
Definition: vtkFixedPointRayCastImage.h:40
vtkRayCastImageDisplayHelper
helper class that draws the image to the screen
Definition: vtkRayCastImageDisplayHelper.h:40
vtkFixedPointVolumeRayCastMapper::RenderSubVolume
void RenderSubVolume()
vtkFixedPointVolumeRayCastMapper::MIPHelper
vtkFixedPointVolumeRayCastMIPHelper * MIPHelper
Definition: vtkFixedPointVolumeRayCastMapper.h:519
vtkIdType
int vtkIdType
Definition: vtkType.h:287
vtkFixedPointVolumeRayCastMapper
A fixed point mapper for volumes.
Definition: vtkFixedPointVolumeRayCastMapper.h:106
vtkFixedPointVolumeRayCastMapper::GetGradientOpacityTable
unsigned short * GetGradientOpacityTable(int c)
Definition: vtkFixedPointVolumeRayCastMapper.h:281
vtkFixedPointVolumeRayCastMapper::RowBounds
int * RowBounds
Definition: vtkFixedPointVolumeRayCastMapper.h:425
FixedPointVolumeRayCastMapper_CastRays
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
vtkFixedPointVolumeRayCastMapper::MinMaxVolumeSize
int MinMaxVolumeSize[4]
Definition: vtkFixedPointVolumeRayCastMapper.h:540
vtkFixedPointVolumeRayCastMapper::SetNumberOfThreads
void SetNumberOfThreads(int num)
Set/Get the number of threads to use.
vtkFixedPointVolumeRayCastMapper::UpdateShadingTable
int UpdateShadingTable(vtkRenderer *ren, vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::RenderTimeTable
float * RenderTimeTable
Definition: vtkFixedPointVolumeRayCastMapper.h:428
vtkFixedPointVolumeRayCastMapper::ComputeRequiredImageSampleDistance
float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer *ren, vtkVolume *vol)
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
vtkX3D::image
@ image
Definition: vtkX3D.h:374
vtkFixedPointVolumeRayCastMapper::GradientOpacityRequired
int GradientOpacityRequired
Definition: vtkFixedPointVolumeRayCastMapper.h:485
vtkFixedPointVolumeRayCastMapper::RenderVolumeTable
vtkVolume ** RenderVolumeTable
Definition: vtkFixedPointVolumeRayCastMapper.h:429
vtkFixedPointVolumeRayCastMapper::RayCastImage
vtkFixedPointRayCastImage * RayCastImage
Definition: vtkFixedPointVolumeRayCastMapper.h:423
vtkFixedPointVolumeRayCastMapper::ReleaseGraphicsResources
virtual void ReleaseGraphicsResources(vtkWindow *)
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being...
vtkFixedPointVolumeRayCastMapper::ComputeRayInfo
void ComputeRayInfo(int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int *numSteps)
vtkFixedPointVolumeRayCastMapper::ApplyFinalColorWindowLevel
void ApplyFinalColorWindowLevel()
vtkFixedPointVolumeRayCastMapper::GetDiffuseShadingTable
unsigned short * GetDiffuseShadingTable(int c)
Definition: vtkFixedPointVolumeRayCastMapper.h:285
vtkFixedPointVolumeRayCastMapper::ShiftVectorDown
void ShiftVectorDown(unsigned int in[3], unsigned int out[3])
Definition: vtkFixedPointVolumeRayCastMapper.h:642
vtkFixedPointVolumeRayCastMIPHelper
A helper that generates MIP images for the volume ray cast mapper.
Definition: vtkFixedPointVolumeRayCastMIPHelper.h:38
vtkFixedPointVolumeRayCastMapper::LookupAndCombineIndependentColorsUC
void LookupAndCombineIndependentColorsUC(unsigned short *colorTable[4], unsigned short *scalarOpacityTable[4], unsigned short index[4], float weights[4], int components, unsigned char color[4])
Definition: vtkFixedPointVolumeRayCastMapper.h:734
vtkX3D::dir
@ dir
Definition: vtkX3D.h:324
vtkFixedPointVolumeRayCastMapper::FixedPointCroppingRegionPlanes
unsigned int FixedPointCroppingRegionPlanes[6]
Definition: vtkFixedPointVolumeRayCastMapper.h:511
vtkFixedPointVolumeRayCastMapper::Volume
vtkVolume * Volume
Definition: vtkFixedPointVolumeRayCastMapper.h:491
vtkFixedPointVolumeRayCastMapper::CompositeShadeHelper
vtkFixedPointVolumeRayCastCompositeShadeHelper * CompositeShadeHelper
Definition: vtkFixedPointVolumeRayCastMapper.h:522
vtkFixedPointVolumeRayCastMapper::ClipRayAgainstVolume
int ClipRayAgainstVolume(float rayStart[3], float rayEnd[3], float rayDirection[3], double bounds[6])
vtkFixedPointVolumeRayCastMapper::MinimumImageSampleDistance
float MinimumImageSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:381
vtkFixedPointVolumeRayCastMapper::FixedPointIncrement
void FixedPointIncrement(unsigned int position[3], unsigned int increment[3])
Definition: vtkFixedPointVolumeRayCastMapper.h:599
vtkFixedPointVolumeRayCastMapper::~vtkFixedPointVolumeRayCastMapper
~vtkFixedPointVolumeRayCastMapper()
vtkFiniteDifferenceGradientEstimator
Use finite differences to estimate gradient.
Definition: vtkFiniteDifferenceGradientEstimator.h:49
vtkFixedPointVolumeRayCastMapper::ImageSampleDistance
float ImageSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:380
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkFixedPointVolumeRayCastMapper::ViewToWorldMatrix
vtkMatrix4x4 * ViewToWorldMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:410
vtkFixedPointVolumeRayCastMapper::CaptureZBuffer
void CaptureZBuffer(vtkRenderer *ren)
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:61
vtkFixedPointVolumeRayCastMapper::UpdateMinMaxVolume
void UpdateMinMaxVolume(vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::TransformedClippingPlanes
float * TransformedClippingPlanes
Definition: vtkFixedPointVolumeRayCastMapper.h:533
vtkColorTransferFunction
Defines a transfer function for mapping a property to an RGB color value.
Definition: vtkColorTransferFunction.h:59
VTKKW_FP_SCALE
#define VTKKW_FP_SCALE
Definition: vtkFixedPointVolumeRayCastMapper.h:76
vtkFixedPointVolumeRayCastMapper::SavedGradientsInput
vtkImageData * SavedGradientsInput
Definition: vtkFixedPointVolumeRayCastMapper.h:452
vtkFixedPointVolumeRayCastCompositeGOShadeHelper
A helper that generates composite images for the volume ray cast mapper.
Definition: vtkFixedPointVolumeRayCastCompositeGOShadeHelper.h:40
vtkFixedPointVolumeRayCastMapper::GetRowBounds
int * GetRowBounds()
Definition: vtkFixedPointVolumeRayCastMapper.h:278
vtkFixedPointVolumeRayCastMapper::OldImageSampleDistance
float OldImageSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:388
vtkFixedPointVolumeRayCastMapper::RetrieveRenderTime
float RetrieveRenderTime(vtkRenderer *ren)
vtkFixedPointVolumeRayCastMapper::DirectionEncoder
vtkDirectionEncoder * DirectionEncoder
Definition: vtkFixedPointVolumeRayCastMapper.h:475
vtkFixedPointVolumeRayCastMapper::MaximumImageSampleDistance
float MaximumImageSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:382
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:35
vtkFixedPointVolumeRayCastMapper::NumberOfGradientSlices
int NumberOfGradientSlices
Definition: vtkFixedPointVolumeRayCastMapper.h:473
vtkFixedPointVolumeRayCastMapper::VoxelsToViewMatrix
vtkMatrix4x4 * VoxelsToViewMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:412
vtkFixedPointVolumeRayCastMapper::PerspectiveMatrix
vtkMatrix4x4 * PerspectiveMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:409
vtkFixedPointVolumeRayCastMapper::SavedParametersInput
vtkImageData * SavedParametersInput
Definition: vtkFixedPointVolumeRayCastMapper.h:449
vtkFixedPointVolumeRayCastMapper::LockSampleDistanceToInputSpacing
int LockSampleDistanceToInputSpacing
Definition: vtkFixedPointVolumeRayCastMapper.h:384
vtkFixedPointVolumeRayCastMapper::UpdateCroppingRegions
void UpdateCroppingRegions()
vtkFixedPointVolumeRayCastMapper::UpdateColorTable
int UpdateColorTable(vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::NumTransformedClippingPlanes
int NumTransformedClippingPlanes
Definition: vtkFixedPointVolumeRayCastMapper.h:532
vtkFixedPointVolumeRayCastMapper::GetFloatTripleFromPointer
void GetFloatTripleFromPointer(float v[3], float *ptr)
Definition: vtkFixedPointVolumeRayCastMapper.h:628
vtkFixedPointVolumeRayCastMapper::VoxelsToWorldMatrix
vtkMatrix4x4 * VoxelsToWorldMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:414
vtkMultiThreader
A class for performing multithreaded execution.
Definition: vtkMultiThreader.h:97
vtkX3D::position
@ position
Definition: vtkX3D.h:261
vtkX3D::color
@ color
Definition: vtkX3D.h:221
vtkFixedPointVolumeRayCastMapper::ViewToVoxelsMatrix
vtkMatrix4x4 * ViewToVoxelsMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:411
vtkFixedPointVolumeRayCastMapper::PerVolumeInitialization
void PerVolumeInitialization(vtkRenderer *, vtkVolume *)
vtkFixedPointVolumeRayCastMapper::vtkFixedPointVolumeRayCastMapper
vtkFixedPointVolumeRayCastMapper()
vtkFixedPointVolumeRayCastMapper::CroppingRegionMask
unsigned int CroppingRegionMask[27]
Definition: vtkFixedPointVolumeRayCastMapper.h:512
vtkEncodedGradientShader
Compute shading tables for encoded normals.
Definition: vtkEncodedGradientShader.h:46
vtkX3D::offset
@ offset
Definition: vtkX3D.h:438
vtkFixedPointVolumeRayCastMapper::InteractiveSampleDistance
float InteractiveSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:377
vtkFixedPointVolumeRayCastMapper::ToFixedPointDirection
unsigned int ToFixedPointDirection(float dir)
Definition: vtkFixedPointVolumeRayCastMapper.h:576
vtkFixedPointVolumeRayCastMapper::ClipRayAgainstClippingPlanes
int ClipRayAgainstClippingPlanes(float rayStart[3], float rayEnd[3], int numClippingPlanes, float *clippingPlanes)
vtkFixedPointVolumeRayCastMapper::MinMaxVolumeCache
vtkImageData * MinMaxVolumeCache
Definition: vtkFixedPointVolumeRayCastMapper.h:542
vtkFixedPointVolumeRayCastMapper::FinalColorWindow
float FinalColorWindow
Definition: vtkFixedPointVolumeRayCastMapper.h:549
vtkFixedPointVolumeRayCastMapper::FinalColorLevel
float FinalColorLevel
Definition: vtkFixedPointVolumeRayCastMapper.h:550
vtkFixedPointVolumeRayCastMapper::RenderTableSize
int RenderTableSize
Definition: vtkFixedPointVolumeRayCastMapper.h:431
vtkFixedPointVolumeRayCastMapper::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent)
Methods invoked by print to print information about the object including superclasses.
vtkFixedPointVolumeRayCastMapper::WorldToVoxelsMatrix
vtkMatrix4x4 * WorldToVoxelsMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:413
vtkFixedPointVolumeRayCastMapper::CheckMIPMinMaxVolumeFlag
int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip)
Definition: vtkFixedPointVolumeRayCastMapper.h:662
vtkFixedPointVolumeRayCastMapper::OldSampleDistance
float OldSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:387
vtkVolumeMapper.h
vtkFixedPointVolumeRayCastMapper::PerSubVolumeInitialization
void PerSubVolumeInitialization(vtkRenderer *, vtkVolume *, int)
VTKKW_FP_SHIFT
#define VTKKW_FP_SHIFT
Definition: vtkFixedPointVolumeRayCastMapper.h:73
vtkFixedPointVolumeRayCastMapper::ComputeRowBounds
int ComputeRowBounds(vtkRenderer *ren, int imageFlag, int rowBoundsFlag, int volumeExtent[6])
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:46
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:40
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
vtkFixedPointVolumeRayCastMapper::ComputeRequiredImageSampleDistance
float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer *ren)
What is the image sample distance required to achieve the desired time? A version of this method is p...
vtkVolumeRayCastSpaceLeapingImageFilter
Builds the space leaping data structure.
Definition: vtkVolumeRayCastSpaceLeapingImageFilter.h:41
vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag
int CheckMinMaxVolumeFlag(unsigned int pos[3], int c)
Definition: vtkFixedPointVolumeRayCastMapper.h:650
vtkFixedPointVolumeRayCastMapper::VoxelsTransform
vtkTransform * VoxelsTransform
Definition: vtkFixedPointVolumeRayCastMapper.h:419
vtkFixedPointVolumeRayCastMapper::vtkFPVRCMSwitchOnDataType
friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
vtkFixedPointVolumeRayCastMapper::GetNumberOfThreads
int GetNumberOfThreads()
vtkFixedPointVolumeRayCastMapper::PerImageInitialization
int PerImageInitialization(vtkRenderer *, vtkVolume *, int, double *, double *, int *)
vtkFixedPointVolumeRayCastMapper::SavedGradientsMTime
vtkTimeStamp SavedGradientsMTime
Definition: vtkFixedPointVolumeRayCastMapper.h:453
vtkFixedPointVolumeRayCastMapper::RetrieveRenderTime
float RetrieveRenderTime(vtkRenderer *ren, vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::GradientShader
vtkEncodedGradientShader * GradientShader
Definition: vtkFixedPointVolumeRayCastMapper.h:477
vtkFixedPointVolumeRayCastMapper::RenderWindow
vtkRenderWindow * RenderWindow
Definition: vtkFixedPointVolumeRayCastMapper.h:490
vtkFixedPointVolumeRayCastMapper::ContiguousGradientMagnitude
unsigned char * ContiguousGradientMagnitude
Definition: vtkFixedPointVolumeRayCastMapper.h:471
vtkFixedPointVolumeRayCastMapper::DisplayRenderedImage
void DisplayRenderedImage(vtkRenderer *, vtkVolume *)
vtkFixedPointVolumeRayCastMapper::VoxelsToViewTransform
vtkTransform * VoxelsToViewTransform
Definition: vtkFixedPointVolumeRayCastMapper.h:420
vtkFixedPointVolumeRayCastMapper::CompositeGOHelper
vtkFixedPointVolumeRayCastCompositeGOHelper * CompositeGOHelper
Definition: vtkFixedPointVolumeRayCastMapper.h:521
vtkFixedPointVolumeRayCastMapper::GetScalarOpacityTable
unsigned short * GetScalarOpacityTable(int c)
Definition: vtkFixedPointVolumeRayCastMapper.h:280
vtkFixedPointVolumeRayCastMapper::AutoAdjustSampleDistances
int AutoAdjustSampleDistances
Definition: vtkFixedPointVolumeRayCastMapper.h:383
vtkFixedPointVolumeRayCastMapper::LookupColorUC
void LookupColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index, unsigned char color[4])
Definition: vtkFixedPointVolumeRayCastMapper.h:689
vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC
void LookupDependentColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index[4], int components, unsigned char color[4])
Definition: vtkFixedPointVolumeRayCastMapper.h:704
vtkFPVRCMSwitchOnDataType
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
vtkFixedPointVolumeRayCastMapper::PerspectiveTransform
vtkTransform * PerspectiveTransform
Definition: vtkFixedPointVolumeRayCastMapper.h:418
vtkFixedPointVolumeRayCastMapper::SetRayCastImage
void SetRayCastImage(vtkFixedPointRayCastImage *)
Set / Get the underlying image object.
VTK_THREAD_RETURN_TYPE
#define VTK_THREAD_RETURN_TYPE
Definition: vtkSystemIncludes.h:136
vtkFixedPointVolumeRayCastMapper::CheckIfCropped
int CheckIfCropped(unsigned int pos[3])
Definition: vtkFixedPointVolumeRayCastMapper.h:759
vtkPiecewiseFunction
Defines a 1D piecewise function.
Definition: vtkPiecewiseFunction.h:52
vtkFixedPointVolumeRayCastMapper::CurrentScalars
vtkDataArray * CurrentScalars
Definition: vtkFixedPointVolumeRayCastMapper.h:487
vtkBooleanMacro
vtkBooleanMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkFixedPointVolumeRayCastMapper::GetUIntTripleFromPointer
void GetUIntTripleFromPointer(unsigned int v[3], unsigned int *ptr)
Definition: vtkFixedPointVolumeRayCastMapper.h:635
vtkSetMacro
vtkSetMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkFixedPointVolumeRayCastMapper::FlipMIPComparison
int FlipMIPComparison
Definition: vtkFixedPointVolumeRayCastMapper.h:552
vtkTimerLog
Timer support and logging.
Definition: vtkTimerLog.h:81
vtkFixedPointVolumeRayCastMapper::ShadingRequired
int ShadingRequired
Definition: vtkFixedPointVolumeRayCastMapper.h:484
vtkFixedPointVolumeRayCastMapper::MinimumViewDistance
float MinimumViewDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:440
vtkFixedPointVolumeRayCastMapper::ImageDisplayHelper
vtkRayCastImageDisplayHelper * ImageDisplayHelper
Definition: vtkFixedPointVolumeRayCastMapper.h:373
vtkFixedPointVolumeRayCastMapper::SpaceLeapFilter
vtkVolumeRayCastSpaceLeapingImageFilter * SpaceLeapFilter
Definition: vtkFixedPointVolumeRayCastMapper.h:543
vtkFixedPointVolumeRayCastMapper::ComputeGradients
void ComputeGradients(vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::GetEstimatedRenderTime
float GetEstimatedRenderTime(vtkRenderer *ren, vtkVolume *vol)
Get an estimate of the rendering time for a given volume / renderer.
Definition: vtkFixedPointVolumeRayCastMapper.h:327
vtkFixedPointVolumeRayCastMapper::GetColorTable
unsigned short * GetColorTable(int c)
Definition: vtkFixedPointVolumeRayCastMapper.h:279
vtkFixedPointVolumeRayCastMapper::Render
void Render(vtkRenderer *, vtkVolume *)
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Initialize rendering for this volume.
vtkFixedPointVolumeRayCastMapper::StoreRenderTime
void StoreRenderTime(vtkRenderer *ren, vtkVolume *vol, float t)
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:64
vtkFixedPointVolumeRayCastMapper::RenderTableEntries
int RenderTableEntries
Definition: vtkFixedPointVolumeRayCastMapper.h:432
vtkDirectionEncoder
encode a direction into a one or two byte value
Definition: vtkDirectionEncoder.h:40
vtkFixedPointVolumeRayCastMapper::PreviousScalars
vtkDataArray * PreviousScalars
Definition: vtkFixedPointVolumeRayCastMapper.h:488
vtkFixedPointVolumeRayCastMapper::GradientEstimator
vtkFiniteDifferenceGradientEstimator * GradientEstimator
Definition: vtkFixedPointVolumeRayCastMapper.h:479
vtkFixedPointVolumeRayCastMapper::GradientNormal
unsigned short ** GradientNormal
Definition: vtkFixedPointVolumeRayCastMapper.h:468
vtkFixedPointVolumeRayCastMapper::ShouldUseNearestNeighborInterpolation
int ShouldUseNearestNeighborInterpolation(vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::New
static vtkFixedPointVolumeRayCastMapper * New()
vtkVolumeMapper::CroppingRegionFlags
int CroppingRegionFlags
Definition: vtkVolumeMapper.h:267
vtkFixedPointVolumeRayCastCompositeHelper
A helper that generates composite images for the volume ray cast mapper.
Definition: vtkFixedPointVolumeRayCastCompositeHelper.h:40
vtkFixedPointVolumeRayCastMapper::GetZBufferValue
float GetZBufferValue(int x, int y)
vtkFixedPointVolumeRayCastMapper::GetVolume
vtkVolume * GetVolume()
Definition: vtkFixedPointVolumeRayCastMapper.h:282
vtkPlaneCollection
maintain a list of planes
Definition: vtkPlaneCollection.h:37
vtkRenderWindow
create a window for renderers to draw into
Definition: vtkRenderWindow.h:87
vtkFixedPointVolumeRayCastCompositeGOHelper
A helper that generates composite images for the volume ray cast mapper.
Definition: vtkFixedPointVolumeRayCastCompositeGOHelper.h:40
vtkFixedPointVolumeRayCastMapper::InitializeRayInfo
void InitializeRayInfo(vtkVolume *vol)
vtkFixedPointVolumeRayCastMapper::VolumeMatrix
vtkMatrix4x4 * VolumeMatrix
Definition: vtkFixedPointVolumeRayCastMapper.h:416
vtkFixedPointVolumeRayCastMapper::CreateCanonicalView
void CreateCanonicalView(vtkVolume *volume, vtkImageData *image, int blend_mode, double viewDirection[3], double viewUp[3])
vtkFixedPointVolumeRayCastMapper::FixedPointVolumeRayCastMapper_CastRays
friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition
unsigned int ToFixedPointPosition(float val)
Definition: vtkFixedPointVolumeRayCastMapper.h:564
vtkFixedPointVolumeRayCastMapper::AbortRender
void AbortRender()
vtkFixedPointVolumeRayCastMapper::FillInMaxGradientMagnitudes
void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3])
vtkX3D::index
@ index
Definition: vtkX3D.h:246
vtkFixedPointVolumeRayCastMapper::SampleDistance
float SampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:376
vtkFixedPointVolumeRayCastCompositeShadeHelper
A helper that generates composite images for the volume ray cast mapper.
Definition: vtkFixedPointVolumeRayCastCompositeShadeHelper.h:40
vtkFixedPointVolumeRayCastMapper::CompositeGOShadeHelper
vtkFixedPointVolumeRayCastCompositeGOShadeHelper * CompositeGOShadeHelper
Definition: vtkFixedPointVolumeRayCastMapper.h:523
vtkFixedPointVolumeRayCastMapper::CompositeHelper
vtkFixedPointVolumeRayCastCompositeHelper * CompositeHelper
Definition: vtkFixedPointVolumeRayCastMapper.h:520
vtkFixedPointVolumeRayCastMapper::GetEstimatedRenderTime
float GetEstimatedRenderTime(vtkRenderer *ren)
Definition: vtkFixedPointVolumeRayCastMapper.h:330
vtkFixedPointVolumeRayCastMapper::MinMaxVolume
unsigned short * MinMaxVolume
Definition: vtkFixedPointVolumeRayCastMapper.h:539
vtkFixedPointVolumeRayCastMapper::SavedBlendMode
int SavedBlendMode
Definition: vtkFixedPointVolumeRayCastMapper.h:448
vtkFixedPointVolumeRayCastMapper::IntermixIntersectingGeometry
int IntermixIntersectingGeometry
Definition: vtkFixedPointVolumeRayCastMapper.h:438
vtkFixedPointVolumeRayCastMapper::SavedSampleDistance
float SavedSampleDistance
Definition: vtkFixedPointVolumeRayCastMapper.h:455
vtkFixedPointVolumeRayCastMapper::GradientMagnitude
unsigned char ** GradientMagnitude
Definition: vtkFixedPointVolumeRayCastMapper.h:469
vtkFixedPointVolumeRayCastMapper::SavedParametersMTime
vtkTimeStamp SavedParametersMTime
Definition: vtkFixedPointVolumeRayCastMapper.h:450