VTK  9.2.5
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
77class vtkMatrix4x4;
80class vtkRenderer;
81class vtkTimerLog;
82class vtkVolume;
83class vtkTransform;
84class vtkRenderWindow;
98class vtkDataArray;
99
100// Forward declaration needed for use by friend declaration below.
101VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
102VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
103
104class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
105{
106public:
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);
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
275 int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
276
278
280
282
288 vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
290
291 int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
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
345
346protected:
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
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
400
406
407 void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
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;
444
446
448
450
452
453 unsigned short DiffuseShadingTable[4][65536 * 3];
454 unsigned short SpecularShadingTable[4][65536 * 3];
455
458
461
464
466 double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
467
472
474
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
512 void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
513
516
518
520
521private:
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
533inline 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
609inline 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
644inline 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
657inline 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
Defines a transfer function for mapping a property to an RGB color value.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:56
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
vtkFixedPointVolumeRayCastMIPHelper * MIPHelper
vtkFixedPointVolumeRayCastCompositeGOHelper * CompositeGOHelper
int ShouldUseNearestNeighborInterpolation(vtkVolume *vol)
void ReleaseGraphicsResources(vtkWindow *) override
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being...
float RetrieveRenderTime(vtkRenderer *ren)
void GetFloatTripleFromPointer(float v[3], float *ptr)
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
void StoreRenderTime(vtkRenderer *ren, vtkVolume *vol, float t)
vtkFiniteDifferenceGradientEstimator * GradientEstimator
vtkFixedPointVolumeRayCastCompositeGOShadeHelper * CompositeGOShadeHelper
int ComputeRowBounds(vtkRenderer *ren, int imageFlag, int rowBoundsFlag, int inputExtent[6])
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 Render(vtkRenderer *, vtkVolume *) override
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Initialize rendering for this volume.
void ComputeGradients(vtkVolume *vol)
int UpdateShadingTable(vtkRenderer *ren, vtkVolume *vol)
void GetUIntTripleFromPointer(unsigned int v[3], unsigned int *ptr)
float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer *ren, vtkVolume *vol)
What is the image sample distance required to achieve the desired time? A version of this method is p...
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 ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6], vtkRenderer *ren, vtkVolume *vol)
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void LookupColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index, unsigned char color[4])
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 *)
int ClipRayAgainstVolume(double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6])
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 ShiftVectorDown(unsigned int in[3], unsigned int out[3])
int UpdateColorTable(vtkVolume *vol)
int ClipRayAgainstClippingPlanes(double rayStart[3], double rayEnd[3], int numClippingPlanes, float *clippingPlanes)
int GetNumberOfThreads()
Set/Get the number of threads to use.
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:54
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:73
record modification and/or execution time
Definition: vtkTimeStamp.h:36
Timer support and logging.
Definition: vtkTimerLog.h:96
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:61
Abstract class for a volume mapper.
int CroppingRegionFlags
Cropping variables, and a method for converting the world coordinate cropping region planes to voxel ...
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:51
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39
int vtkTypeBool
Definition: vtkABI.h:69
#define VTKKW_FP_SCALE
#define VTKKW_FP_SHIFT
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
int vtkIdType
Definition: vtkType.h:332