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
78class vtkMatrix4x4;
81class vtkRenderer;
82class vtkTimerLog;
83class vtkVolume;
84class vtkTransform;
85class vtkRenderWindow;
99class vtkDataArray;
100
101// Forward declaration needed for use by friend declaration below.
104
105class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
106{
107public:
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 * );
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
368protected:
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
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;
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
556private:
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
569inline 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
583inline 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
599inline 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
635inline 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
650inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag( unsigned int mmpos[3], int c )
651{
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
662inline int vtkFixedPointVolumeRayCastMapper::CheckMIPMinMaxVolumeFlag( unsigned int mmpos[3], int c,
663 unsigned short maxIdx, int flip )
664{
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
689inline 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
704inline 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
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
Defines a transfer function for mapping a property to an RGB color value.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
encode a direction into a one or two byte value
Compute shading tables for encoded normals.
Use finite differences to estimate gradient.
helper class for a ray cast image
A helper that generates composite images for the volume ray cast mapper.
A helper that generates composite images for the volume ray cast mapper.
A helper that generates composite images for the volume ray cast mapper.
A helper that generates composite images for the volume ray cast mapper.
A helper that generates MIP images for the volume ray cast mapper.
void SetRayCastImage(vtkFixedPointRayCastImage *)
Set / Get the underlying image object.
vtkRayCastImageDisplayHelper * ImageDisplayHelper
int ClipRayAgainstVolume(float rayStart[3], float rayEnd[3], float rayDirection[3], double bounds[6])
vtkFixedPointVolumeRayCastMIPHelper * MIPHelper
vtkFixedPointVolumeRayCastCompositeGOHelper * CompositeGOHelper
int ShouldUseNearestNeighborInterpolation(vtkVolume *vol)
float RetrieveRenderTime(vtkRenderer *ren)
int ClipRayAgainstClippingPlanes(float rayStart[3], float rayEnd[3], int numClippingPlanes, float *clippingPlanes)
void GetFloatTripleFromPointer(float v[3], float *ptr)
void Render(vtkRenderer *, vtkVolume *)
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Initialize rendering for this volume.
void CaptureZBuffer(vtkRenderer *ren)
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...
void ComputeRayInfo(int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int *numSteps)
vtkFixedPointVolumeRayCastCompositeShadeHelper * CompositeShadeHelper
virtual void ReleaseGraphicsResources(vtkWindow *)
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being...
void StoreRenderTime(vtkRenderer *ren, vtkVolume *vol, float t)
vtkFiniteDifferenceGradientEstimator * GradientEstimator
vtkFixedPointVolumeRayCastCompositeGOShadeHelper * CompositeGOShadeHelper
float GetZBufferValue(int x, int y)
void DisplayRenderedImage(vtkRenderer *, vtkVolume *)
void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3])
void InitializeRayInfo(vtkVolume *vol)
void SetNumberOfThreads(int num)
Set/Get the number of threads to use.
void ComputeGradients(vtkVolume *vol)
void PrintSelf(ostream &os, vtkIndent indent)
Methods invoked by print to print information about the object including superclasses.
int UpdateShadingTable(vtkRenderer *ren, vtkVolume *vol)
void GetUIntTripleFromPointer(unsigned int v[3], unsigned int *ptr)
float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer *ren, vtkVolume *vol)
static vtkFixedPointVolumeRayCastMapper * New()
float GetEstimatedRenderTime(vtkRenderer *ren, vtkVolume *vol)
Get an estimate of the rendering time for a given volume / renderer.
float RetrieveRenderTime(vtkRenderer *ren, vtkVolume *vol)
int CheckMinMaxVolumeFlag(unsigned int pos[3], int c)
vtkFixedPointVolumeRayCastCompositeHelper * CompositeHelper
int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip)
friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
void PerSubVolumeInitialization(vtkRenderer *, vtkVolume *, int)
void LookupColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index, unsigned char color[4])
int ComputeRowBounds(vtkRenderer *ren, int imageFlag, int rowBoundsFlag, int volumeExtent[6])
void FixedPointIncrement(unsigned int position[3], unsigned int increment[3])
void LookupAndCombineIndependentColorsUC(unsigned short *colorTable[4], unsigned short *scalarOpacityTable[4], unsigned short index[4], float weights[4], int components, unsigned char color[4])
vtkVolumeRayCastSpaceLeapingImageFilter * SpaceLeapFilter
void PerVolumeInitialization(vtkRenderer *, vtkVolume *)
void CreateCanonicalView(vtkVolume *volume, vtkImageData *image, int blend_mode, double viewDirection[3], double viewUp[3])
int PerImageInitialization(vtkRenderer *, vtkVolume *, int, double *, double *, int *)
void UpdateMinMaxVolume(vtkVolume *vol)
friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
void ComputeMatrices(double volumeOrigin[3], double volumeSpacing[3], int volumeExtent[6], vtkRenderer *ren, vtkVolume *vol)
void ShiftVectorDown(unsigned int in[3], unsigned int out[3])
int UpdateColorTable(vtkVolume *vol)
int UpdateGradients(vtkVolume *vol)
void LookupDependentColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index[4], int components, unsigned char color[4])
topologically and geometrically regular array of data
Definition: vtkImageData.h:46
a simple class to control print indentation
Definition: vtkIndent.h:40
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
A class for performing multithreaded execution.
Defines a 1D piecewise function.
maintain a list of planes
helper class that draws the image to the screen
create a window for renderers to draw into
abstract specification for renderers
Definition: vtkRenderer.h:64
record modification and/or execution time
Definition: vtkTimeStamp.h:36
Timer support and logging.
Definition: vtkTimerLog.h:81
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:61
Abstract class for a volume mapper.
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:51
window superclass for vtkRenderWindow
Definition: vtkWindow.h:35
@ dir
Definition: vtkX3D.h:324
@ alpha
Definition: vtkX3D.h:250
@ color
Definition: vtkX3D.h:221
@ image
Definition: vtkX3D.h:374
@ position
Definition: vtkX3D.h:261
@ index
Definition: vtkX3D.h:246
@ offset
Definition: vtkX3D.h:438
#define VTKKW_FP_SCALE
#define VTKKW_FP_SHIFT
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
vtkSetMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkBooleanMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
#define VTK_THREAD_RETURN_TYPE
int vtkIdType
Definition: vtkType.h:287