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 =========================================================================*/
61 #ifndef vtkFixedPointVolumeRayCastMapper_h
62 #define vtkFixedPointVolumeRayCastMapper_h
63 
64 #include "vtkRenderingVolumeModule.h" // For export macro
65 #include "vtkVolumeMapper.h"
66 
67 #define VTKKW_FP_SHIFT 15
68 #define VTKKW_FPMM_SHIFT 17
69 #define VTKKW_FP_MASK 0x7fff
70 #define VTKKW_FP_SCALE 32767.0
71 
72 class vtkMatrix4x4;
73 class vtkMultiThreader;
74 class vtkPlaneCollection;
75 class vtkRenderer;
76 class vtkTimerLog;
77 class vtkVolume;
78 class vtkTransform;
79 class vtkRenderWindow;
93 class vtkDataArray;
94 
95 // Forward declaration needed for use by friend declaration below.
98 
99 class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
100 {
101 public:
104  void PrintSelf( ostream& os, vtkIndent indent ) VTK_OVERRIDE;
105 
107 
112  vtkSetMacro( SampleDistance, float );
113  vtkGetMacro( SampleDistance, float );
115 
117 
124  vtkSetMacro( InteractiveSampleDistance, float );
125  vtkGetMacro( InteractiveSampleDistance, float );
127 
129 
136  vtkSetClampMacro( ImageSampleDistance, float, 0.1f, 100.0f );
137  vtkGetMacro( ImageSampleDistance, float );
139 
141 
145  vtkSetClampMacro( MinimumImageSampleDistance, float, 0.1f, 100.0f );
146  vtkGetMacro( MinimumImageSampleDistance, float );
148 
150 
154  vtkSetClampMacro( MaximumImageSampleDistance, float, 0.1f, 100.0f );
155  vtkGetMacro( MaximumImageSampleDistance, float );
157 
159 
168  vtkSetClampMacro( AutoAdjustSampleDistances, int, 0, 1 );
169  vtkGetMacro( AutoAdjustSampleDistances, int );
170  vtkBooleanMacro( AutoAdjustSampleDistances, int );
172 
174 
182  vtkSetClampMacro( LockSampleDistanceToInputSpacing, int, 0, 1 );
183  vtkGetMacro( LockSampleDistanceToInputSpacing, int );
184  vtkBooleanMacro( LockSampleDistanceToInputSpacing, int );
186 
188 
193  void SetNumberOfThreads( int num );
194  int GetNumberOfThreads();
196 
198 
202  vtkSetClampMacro( IntermixIntersectingGeometry, int, 0, 1 );
203  vtkGetMacro( IntermixIntersectingGeometry, int );
204  vtkBooleanMacro( IntermixIntersectingGeometry, int );
206 
208 
215  float ComputeRequiredImageSampleDistance( float desiredTime,
216  vtkRenderer *ren );
217  float ComputeRequiredImageSampleDistance( float desiredTime,
218  vtkRenderer *ren,
219  vtkVolume *vol );
221 
226  void Render( vtkRenderer *, vtkVolume * ) VTK_OVERRIDE;
227 
228  unsigned int ToFixedPointPosition( float val );
229  void ToFixedPointPosition( float in[3], unsigned int out[3] );
230  unsigned int ToFixedPointDirection( float dir );
231  void ToFixedPointDirection( float in[3], unsigned int out[3] );
232  void FixedPointIncrement( unsigned int position[3], unsigned int increment[3] );
233  void GetFloatTripleFromPointer( float v[3], float *ptr );
234  void GetUIntTripleFromPointer( unsigned int v[3], unsigned int *ptr );
235  void ShiftVectorDown( unsigned int in[3], unsigned int out[3] );
236  int CheckMinMaxVolumeFlag( unsigned int pos[3], int c );
237  int CheckMIPMinMaxVolumeFlag( unsigned int pos[3], int c, unsigned short maxIdx, int flip );
238 
239  void LookupColorUC( unsigned short *colorTable,
240  unsigned short *scalarOpacityTable,
241  unsigned short index,
242  unsigned char color[4] );
243  void LookupDependentColorUC( unsigned short *colorTable,
244  unsigned short *scalarOpacityTable,
245  unsigned short index[4],
246  int components,
247  unsigned char color[4] );
248  void LookupAndCombineIndependentColorsUC(
249  unsigned short *colorTable[4],
250  unsigned short *scalarOpacityTable[4],
251  unsigned short index[4],
252  float weights[4],
253  int components,
254  unsigned char color[4] );
255  int CheckIfCropped( unsigned int pos[3] );
256 
257  vtkGetObjectMacro( RenderWindow, vtkRenderWindow );
258  vtkGetObjectMacro( MIPHelper, vtkFixedPointVolumeRayCastMIPHelper );
259  vtkGetObjectMacro( CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper );
260  vtkGetObjectMacro( CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper );
261  vtkGetObjectMacro( CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper );
262  vtkGetObjectMacro( CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper );
263  vtkGetVectorMacro( TableShift, float, 4 );
264  vtkGetVectorMacro( TableScale, float, 4 );
265  vtkGetMacro( ShadingRequired, int );
266  vtkGetMacro( GradientOpacityRequired, int );
267 
268  vtkGetObjectMacro( CurrentScalars, vtkDataArray );
269  vtkGetObjectMacro( PreviousScalars, vtkDataArray );
270 
271 
272  int *GetRowBounds() {return this->RowBounds;}
273  unsigned short *GetColorTable(int c) {return this->ColorTable[c];}
274  unsigned short *GetScalarOpacityTable(int c) {return this->ScalarOpacityTable[c];}
275  unsigned short *GetGradientOpacityTable(int c) {return this->GradientOpacityTable[c];}
276  vtkVolume *GetVolume() {return this->Volume;}
277  unsigned short **GetGradientNormal() {return this->GradientNormal;}
278  unsigned char **GetGradientMagnitude() {return this->GradientMagnitude;}
279  unsigned short *GetDiffuseShadingTable(int c) {return this->DiffuseShadingTable[c];}
280  unsigned short *GetSpecularShadingTable(int c) {return this->SpecularShadingTable[c];}
281 
282  void ComputeRayInfo( int x, int y,
283  unsigned int pos[3],
284  unsigned int dir[3],
285  unsigned int *numSteps );
286 
287  void InitializeRayInfo( vtkVolume *vol );
288 
289  int ShouldUseNearestNeighborInterpolation( vtkVolume *vol );
290 
292 
297  void SetRayCastImage( vtkFixedPointRayCastImage * );
298  vtkGetObjectMacro( RayCastImage, vtkFixedPointRayCastImage );
300 
301  int PerImageInitialization( vtkRenderer *, vtkVolume *, int,
302  double *, double *, int * );
303  void PerVolumeInitialization( vtkRenderer *, vtkVolume * );
304  void PerSubVolumeInitialization( vtkRenderer *, vtkVolume *, int );
305  void RenderSubVolume();
306  void DisplayRenderedImage( vtkRenderer *, vtkVolume * );
307  void AbortRender();
308 
309  void CreateCanonicalView( vtkVolume *volume,
311  int blend_mode,
312  double viewDirection[3],
313  double viewUp[3] );
314 
322  vtkVolume *vol )
323  { return this->RetrieveRenderTime( ren, vol ); }
325  { return this->RetrieveRenderTime( ren ); }
326 
327 
329 
342  vtkSetMacro( FinalColorWindow, float );
343  vtkGetMacro( FinalColorWindow, float );
344  vtkSetMacro( FinalColorLevel, float );
345  vtkGetMacro( FinalColorLevel, float );
347 
348 
349  // Here to be used by the mapper to tell the helper
350  // to flip the MIP comparison in order to support
351  // minimum intensity blending
352  vtkGetMacro( FlipMIPComparison, int );
353 
360  void ReleaseGraphicsResources(vtkWindow *) VTK_OVERRIDE;
361 
362 protected:
364  ~vtkFixedPointVolumeRayCastMapper() VTK_OVERRIDE;
365 
366  // The helper class that displays the image
368 
369  // The distance between sample points along the ray
372 
373  // The distance between rays in the image
379 
380  // Saved values used to restore
383 
384  // Internal method for computing matrices needed during
385  // ray casting
386  void ComputeMatrices( double volumeOrigin[3],
387  double volumeSpacing[3],
388  int volumeExtent[6],
389  vtkRenderer *ren,
390  vtkVolume *vol );
391 
392  int ComputeRowBounds( vtkRenderer *ren,
393  int imageFlag, int rowBoundsFlag,
394  int volumeExtent[6]);
395 
396  void CaptureZBuffer( vtkRenderer *ren );
397 
400 
402 
409 
411 
415 
416  // This object encapsulated the image and all related information
418 
419  int *RowBounds;
421 
427 
428  void StoreRenderTime( vtkRenderer *ren, vtkVolume *vol, float t );
429  float RetrieveRenderTime( vtkRenderer *ren, vtkVolume *vol );
430  float RetrieveRenderTime( vtkRenderer *ren );
431 
433 
435 
436  vtkColorTransferFunction *SavedRGBFunction[4];
437  vtkPiecewiseFunction *SavedGrayFunction[4];
438  vtkPiecewiseFunction *SavedScalarOpacityFunction[4];
439  vtkPiecewiseFunction *SavedGradientOpacityFunction[4];
440  int SavedColorChannels[4];
441  float SavedScalarOpacityDistance[4];
445 
448 
450 
451 
452  unsigned short ColorTable[4][32768*3];
453  unsigned short ScalarOpacityTable[4][32768];
454  unsigned short GradientOpacityTable[4][256];
455  int TableSize[4];
456  float TableScale[4];
457  float TableShift[4];
458 
459  float GradientMagnitudeScale[4];
460  float GradientMagnitudeShift[4];
461 
462  unsigned short **GradientNormal;
463  unsigned char **GradientMagnitude;
464  unsigned short *ContiguousGradientNormal;
466 
468 
470 
472 
474 
475  unsigned short DiffuseShadingTable [4][65536*3];
476  unsigned short SpecularShadingTable[4][65536*3];
477 
480 
483 
486 
487  int ClipRayAgainstVolume( float rayStart[3],
488  float rayEnd[3],
489  float rayDirection[3],
490  double bounds[6] );
491 
492  int UpdateColorTable( vtkVolume *vol );
493  int UpdateGradients( vtkVolume *vol );
494  int UpdateShadingTable( vtkRenderer *ren,
495  vtkVolume *vol );
496  void UpdateCroppingRegions();
497 
498  void ComputeGradients( vtkVolume *vol );
499 
500  int ClipRayAgainstClippingPlanes( float rayStart[3],
501  float rayEnd[3],
502  int numClippingPlanes,
503  float *clippingPlanes );
504 
505  unsigned int FixedPointCroppingRegionPlanes[6];
506  unsigned int CroppingRegionMask[27];
507 
508  // Get the ZBuffer value corresponding to location (x,y) where (x,y)
509  // are indexing into the ImageInUse image. This must be converted to
510  // the zbuffer image coordinates. Nearest neighbor value is returned.
511  float GetZBufferValue( int x, int y );
512 
518 
519  // Some variables used for ray computation
520  float ViewToVoxelsArray[16];
521  float WorldToVoxelsArray[16];
522  float VoxelsToWorldArray[16];
523 
524  double CroppingBounds[6];
525 
528 
529  double SavedSpacing[3];
530 
531 
532  // Min Max structure used to do space leaping
533  unsigned short *MinMaxVolume;
534  int MinMaxVolumeSize[4];
538 
539  void UpdateMinMaxVolume( vtkVolume *vol );
540  void FillInMaxGradientMagnitudes( int fullDim[3],
541  int smallDim[3] );
542 
545 
547 
548  void ApplyFinalColorWindowLevel();
549 
550 private:
552  void operator=(const vtkFixedPointVolumeRayCastMapper&) VTK_DELETE_FUNCTION;
553 
554  bool ThreadWarning;
555 };
556 
557 
559 {
560  return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
561 }
562 
563 inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition( float in[3], unsigned int out[3] )
564 {
565  out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
566  out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
567  out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
568 }
569 
571 {
572  return ((dir<0.0)?
573  (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5)):
574  (0x80000000+static_cast<unsigned int>(dir*VTKKW_FP_SCALE + 0.5)));
575 }
576 
577 inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointDirection( float in[3], unsigned int out[3] )
578 {
579  out[0] = ((in[0]<0.0)?
580  (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5)):
581  (0x80000000+
582  static_cast<unsigned int>(in[0]*VTKKW_FP_SCALE + 0.5)));
583  out[1] = ((in[1]<0.0)?
584  (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5)):
585  (0x80000000+
586  static_cast<unsigned int>(in[1]*VTKKW_FP_SCALE + 0.5)));
587  out[2] = ((in[2]<0.0)?
588  (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5)):
589  (0x80000000+
590  static_cast<unsigned int>(in[2]*VTKKW_FP_SCALE + 0.5)));
591 }
592 
593 inline void vtkFixedPointVolumeRayCastMapper::FixedPointIncrement( unsigned int position[3], unsigned int increment[3] )
594 {
595  if ( increment[0]&0x80000000 )
596  {
597  position[0] += (increment[0]&0x7fffffff);
598  }
599  else
600  {
601  position[0] -= increment[0];
602  }
603  if ( increment[1]&0x80000000 )
604  {
605  position[1] += (increment[1]&0x7fffffff);
606  }
607  else
608  {
609  position[1] -= increment[1];
610  }
611  if ( increment[2]&0x80000000 )
612  {
613  position[2] += (increment[2]&0x7fffffff);
614  }
615  else
616  {
617  position[2] -= increment[2];
618  }
619 }
620 
621 
623 {
624  v[0] = *(ptr);
625  v[1] = *(ptr+1);
626  v[2] = *(ptr+2);
627 }
628 
629 inline void vtkFixedPointVolumeRayCastMapper::GetUIntTripleFromPointer( unsigned int v[3], unsigned int *ptr )
630 {
631  v[0] = *(ptr);
632  v[1] = *(ptr+1);
633  v[2] = *(ptr+2);
634 }
635 
637  unsigned int out[3] )
638 {
639  out[0] = in[0] >> VTKKW_FP_SHIFT;
640  out[1] = in[1] >> VTKKW_FP_SHIFT;
641  out[2] = in[2] >> VTKKW_FP_SHIFT;
642 }
643 
644 inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag( unsigned int mmpos[3], int c )
645 {
646  vtkIdType offset =
647  static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
648  ( mmpos[2]*static_cast<vtkIdType>(
649  this->MinMaxVolumeSize[0]*this->MinMaxVolumeSize[1]) +
650  mmpos[1]*static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) +
651  mmpos[0] ) + static_cast<vtkIdType>(c);
652 
653  return ((*(this->MinMaxVolume + 3*offset + 2))&0x00ff);
654 }
655 
656 inline int vtkFixedPointVolumeRayCastMapper::CheckMIPMinMaxVolumeFlag( unsigned int mmpos[3], int c,
657  unsigned short maxIdx, int flip )
658 {
659  vtkIdType offset =
660  static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
661  ( mmpos[2]*static_cast<vtkIdType>(
662  this->MinMaxVolumeSize[0]*this->MinMaxVolumeSize[1]) +
663  mmpos[1]*static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) +
664  mmpos[0] ) + static_cast<vtkIdType>(c);
665 
666  if ( (*(this->MinMaxVolume + 3*offset + 2)&0x00ff) )
667  {
668  if (flip)
669  {
670  return ( *(this->MinMaxVolume + 3*offset) < maxIdx );
671  }
672  else
673  {
674  return ( *(this->MinMaxVolume + 3*offset + 1) > maxIdx );
675  }
676  }
677  else
678  {
679  return 0;
680  }
681 }
682 
683 inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC( unsigned short *colorTable,
684  unsigned short *scalarOpacityTable,
685  unsigned short index,
686  unsigned char color[4] )
687 {
688  unsigned short alpha = scalarOpacityTable[index];
689  color[0] = static_cast<unsigned char>
690  ((colorTable[3*index ]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
691  color[1] = static_cast<unsigned char>
692  ((colorTable[3*index+1]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
693  color[2] = static_cast<unsigned char>
694  ((colorTable[3*index+2]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
695  color[3] = static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
696 }
697 
698 inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC( unsigned short *colorTable,
699  unsigned short *scalarOpacityTable,
700  unsigned short index[4],
701  int components,
702  unsigned char color[4] )
703 {
704  unsigned short alpha;
705  switch ( components )
706  {
707  case 2:
708  alpha = scalarOpacityTable[index[1]];
709  color[0] = static_cast<unsigned char>
710  ((colorTable[3*index[0] ]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
711  color[1] = static_cast<unsigned char>
712  ((colorTable[3*index[0]+1]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
713  color[2] = static_cast<unsigned char>
714  ((colorTable[3*index[0]+2]*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
715  color[3] = static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
716  break;
717  case 4:
718  alpha = scalarOpacityTable[index[3]];
719  color[0] = static_cast<unsigned char>((index[0]*alpha + 0x7fff)>>VTKKW_FP_SHIFT );
720  color[1] = static_cast<unsigned char>((index[1]*alpha + 0x7fff)>>VTKKW_FP_SHIFT );
721  color[2] = static_cast<unsigned char>((index[2]*alpha + 0x7fff)>>VTKKW_FP_SHIFT );
722  color[3] = static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
723  break;
724  }
725 }
726 
727 
729  unsigned short *scalarOpacityTable[4],
730  unsigned short index[4],
731  float weights[4],
732  int components,
733  unsigned char color[4] )
734 {
735  unsigned int tmp[4] = {0,0,0,0};
736 
737  for ( int i = 0; i < components; i++ )
738  {
739  unsigned short alpha = static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]])*weights[i]);
740  tmp[0] += static_cast<unsigned char>(((colorTable[i][3*index[i] ])*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
741  tmp[1] += static_cast<unsigned char>(((colorTable[i][3*index[i]+1])*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
742  tmp[2] += static_cast<unsigned char>(((colorTable[i][3*index[i]+2])*alpha + 0x7fff)>>(2*VTKKW_FP_SHIFT - 8));
743  tmp[3] += static_cast<unsigned char>(alpha>>(VTKKW_FP_SHIFT - 8));
744  }
745 
746  color[0] = static_cast<unsigned char>((tmp[0]>255)?(255):(tmp[0]));
747  color[1] = static_cast<unsigned char>((tmp[1]>255)?(255):(tmp[1]));
748  color[2] = static_cast<unsigned char>((tmp[2]>255)?(255):(tmp[2]));
749  color[3] = static_cast<unsigned char>((tmp[3]>255)?(255):(tmp[3]));
750 
751 }
752 
753 inline int vtkFixedPointVolumeRayCastMapper::CheckIfCropped( unsigned int pos[3] )
754 {
755  int idx;
756 
757  if ( pos[2] < this->FixedPointCroppingRegionPlanes[4] )
758  {
759  idx = 0;
760  }
761  else if ( pos[2] > this->FixedPointCroppingRegionPlanes[5] )
762  {
763  idx = 18;
764  }
765  else
766  {
767  idx = 9;
768  }
769 
770  if ( pos[1] >= this->FixedPointCroppingRegionPlanes[2] )
771  {
772  if ( pos[1] > this->FixedPointCroppingRegionPlanes[3] )
773  {
774  idx += 6;
775  }
776  else
777  {
778  idx += 3;
779  }
780  }
781 
782  if ( pos[0] >= this->FixedPointCroppingRegionPlanes[0] )
783  {
784  if ( pos[0] > this->FixedPointCroppingRegionPlanes[1] )
785  {
786  idx += 2;
787  }
788  else
789  {
790  idx += 1;
791  }
792  }
793 
794  return !(static_cast<unsigned int>(this->CroppingRegionFlags)
795  &this->CroppingRegionMask[idx]);
796 }
797 
798 #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:44
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:35
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:32
maintain a list of planes
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
abstract specification for renderers
Definition: vtkRenderer.h:57
void GetUIntTripleFromPointer(unsigned int v[3], unsigned int *ptr)
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
int vtkIdType
Definition: vtkType.h:345
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
Timer support and logging.
Definition: vtkTimerLog.h:85
window superclass for vtkRenderWindow
Definition: vtkWindow.h:34
vtkFixedPointVolumeRayCastCompositeGOHelper * CompositeGOHelper
a simple class to control print indentation
Definition: vtkIndent.h:33
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:39
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:48
Compute shading tables for encoded normals.
int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip)
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
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.
A fixed point mapper for volumes.
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.
#define VTK_THREAD_RETURN_TYPE
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
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
#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