VTK  9.2.6
vtkFixedPointVolumeRayCastMapper.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkFixedPointVolumeRayCastMapper.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
58
59#ifndef vtkFixedPointVolumeRayCastMapper_h
60#define vtkFixedPointVolumeRayCastMapper_h
61
62#include "vtkRenderingVolumeModule.h" // For export macro
63#include "vtkThreads.h" // for VTK_THREAD_RETURN_TYPE
64#include "vtkVolumeMapper.h"
65
66#define VTKKW_FP_SHIFT 15
67#define VTKKW_FPMM_SHIFT 17
68#define VTKKW_FP_MASK 0x7fff
69#define VTKKW_FP_SCALE 32767.0
70
71class vtkMatrix4x4;
74class vtkRenderer;
75class vtkTimerLog;
76class vtkVolume;
77class vtkTransform;
78class vtkRenderWindow;
92class vtkDataArray;
93
94// Forward declaration needed for use by friend declaration below.
95VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
96VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
97
98class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
99{
100public:
103 void PrintSelf(ostream& os, vtkIndent indent) override;
104
106
111 vtkSetMacro(SampleDistance, float);
112 vtkGetMacro(SampleDistance, float);
114
116
123 vtkSetMacro(InteractiveSampleDistance, float);
124 vtkGetMacro(InteractiveSampleDistance, float);
126
128
135 vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
136 vtkGetMacro(ImageSampleDistance, float);
138
140
144 vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
145 vtkGetMacro(MinimumImageSampleDistance, float);
147
149
153 vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
154 vtkGetMacro(MaximumImageSampleDistance, float);
156
158
167 vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
171
173
185
187
192 void SetNumberOfThreads(int num);
195
197
205
207
214 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren);
215 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren, vtkVolume* vol);
217
222 void Render(vtkRenderer*, vtkVolume*) override;
223
224 unsigned int ToFixedPointPosition(float val);
225 void ToFixedPointPosition(float in[3], unsigned int out[3]);
226 unsigned int ToFixedPointDirection(float dir);
227 void ToFixedPointDirection(float in[3], unsigned int out[3]);
228 void FixedPointIncrement(unsigned int position[3], unsigned int increment[3]);
229 void GetFloatTripleFromPointer(float v[3], float* ptr);
230 void GetUIntTripleFromPointer(unsigned int v[3], unsigned int* ptr);
231 void ShiftVectorDown(unsigned int in[3], unsigned int out[3]);
232 int CheckMinMaxVolumeFlag(unsigned int pos[3], int c);
233 int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip);
234
235 void LookupColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
236 unsigned short index, unsigned char color[4]);
237 void LookupDependentColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
238 unsigned short index[4], int components, unsigned char color[4]);
239 void LookupAndCombineIndependentColorsUC(unsigned short* colorTable[4],
240 unsigned short* scalarOpacityTable[4], unsigned short index[4], float weights[4],
241 int components, unsigned char color[4]);
242 int CheckIfCropped(unsigned int pos[3]);
243
244 vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
250 vtkGetVectorMacro(TableShift, float, 4);
251 vtkGetVectorMacro(TableScale, float, 4);
252 vtkGetMacro(ShadingRequired, int);
253 vtkGetMacro(GradientOpacityRequired, int);
254
255 vtkGetObjectMacro(CurrentScalars, vtkDataArray);
256 vtkGetObjectMacro(PreviousScalars, vtkDataArray);
257
258 int* GetRowBounds() { return this->RowBounds; }
259 unsigned short* GetColorTable(int c) { return this->ColorTable[c]; }
260 unsigned short* GetScalarOpacityTable(int c) { return this->ScalarOpacityTable[c]; }
261 unsigned short* GetGradientOpacityTable(int c) { return this->GradientOpacityTable[c]; }
262 vtkVolume* GetVolume() { return this->Volume; }
263 unsigned short** GetGradientNormal() { return this->GradientNormal; }
264 unsigned char** GetGradientMagnitude() { return this->GradientMagnitude; }
265 unsigned short* GetDiffuseShadingTable(int c) { return this->DiffuseShadingTable[c]; }
266 unsigned short* GetSpecularShadingTable(int c) { return this->SpecularShadingTable[c]; }
267
269 int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
270
272
274
276
284
285 int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
291
292 void CreateCanonicalView(vtkVolume* volume, vtkImageData* image, int blend_mode,
293 double viewDirection[3], double viewUp[3]);
294
302 {
303 return this->RetrieveRenderTime(ren, vol);
304 }
305 float GetEstimatedRenderTime(vtkRenderer* ren) { return this->RetrieveRenderTime(ren); }
306
308
321 vtkSetMacro(FinalColorWindow, float);
322 vtkGetMacro(FinalColorWindow, float);
323 vtkSetMacro(FinalColorLevel, float);
324 vtkGetMacro(FinalColorLevel, float);
326
327 // Here to be used by the mapper to tell the helper
328 // to flip the MIP comparison in order to support
329 // minimum intensity blending
330 vtkGetMacro(FlipMIPComparison, int);
331
339
340protected:
343
344 // The helper class that displays the image
346
347 // The distance between sample points along the ray
350
351 // The distance between rays in the image
357
358 // Saved values used to restore
361
362 // Internal method for computing matrices needed during
363 // ray casting
364 void ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6],
365 vtkRenderer* ren, vtkVolume* vol);
366
367 int ComputeRowBounds(vtkRenderer* ren, int imageFlag, int rowBoundsFlag, int inputExtent[6]);
368
370
371 friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
372 friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
373
375
382
384
388
389 // This object encapsulated the image and all related information
391
394
400
401 void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
404
406
408
418
421
423
424 unsigned short ColorTable[4][32768 * 3];
425 unsigned short ScalarOpacityTable[4][32768];
426 unsigned short GradientOpacityTable[4][256];
427 int TableSize[4];
428 float TableScale[4];
429 float TableShift[4];
430
433
434 unsigned short** GradientNormal;
435 unsigned char** GradientMagnitude;
438
440
442
444
446
447 unsigned short DiffuseShadingTable[4][65536 * 3];
448 unsigned short SpecularShadingTable[4][65536 * 3];
449
452
455
458
460 double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
461
466
468
470 double rayStart[3], double rayEnd[3], int numClippingPlanes, float* clippingPlanes);
471
473 unsigned int CroppingRegionMask[27];
474
475 // Get the ZBuffer value corresponding to location (x,y) where (x,y)
476 // are indexing into the ImageInUse image. This must be converted to
477 // the zbuffer image coordinates. Nearest neighbor value is returned.
478 float GetZBufferValue(int x, int y);
479
485
486 // Some variables used for ray computation
490
491 double CroppingBounds[6];
492
495
496 double SavedSpacing[3];
497
498 // Min Max structure used to do space leaping
499 unsigned short* MinMaxVolume;
504
506 void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
507
510
512
514
515private:
517 void operator=(const vtkFixedPointVolumeRayCastMapper&) = delete;
518
519 bool ThreadWarning;
520};
521
523{
524 return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
525}
526
527inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float in[3], unsigned int out[3])
528{
529 out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
530 out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
531 out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
532}
533
535{
536 return ((dir < 0.0) ? (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5))
537 : (0x80000000 + static_cast<unsigned int>(dir * VTKKW_FP_SCALE + 0.5)));
538}
539
541 float in[3], unsigned int out[3])
542{
543 out[0] = ((in[0] < 0.0) ? (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5))
544 : (0x80000000 + static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5)));
545 out[1] = ((in[1] < 0.0) ? (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5))
546 : (0x80000000 + static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5)));
547 out[2] = ((in[2] < 0.0) ? (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5))
548 : (0x80000000 + static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5)));
549}
550
552 unsigned int position[3], unsigned int increment[3])
553{
554 if (increment[0] & 0x80000000)
555 {
556 position[0] += (increment[0] & 0x7fffffff);
557 }
558 else
559 {
560 position[0] -= increment[0];
561 }
562 if (increment[1] & 0x80000000)
563 {
564 position[1] += (increment[1] & 0x7fffffff);
565 }
566 else
567 {
568 position[1] -= increment[1];
569 }
570 if (increment[2] & 0x80000000)
571 {
572 position[2] += (increment[2] & 0x7fffffff);
573 }
574 else
575 {
576 position[2] -= increment[2];
577 }
578}
579
581{
582 v[0] = *(ptr);
583 v[1] = *(ptr + 1);
584 v[2] = *(ptr + 2);
585}
586
588 unsigned int v[3], unsigned int* ptr)
589{
590 v[0] = *(ptr);
591 v[1] = *(ptr + 1);
592 v[2] = *(ptr + 2);
593}
594
596 unsigned int in[3], unsigned int out[3])
597{
598 out[0] = in[0] >> VTKKW_FP_SHIFT;
599 out[1] = in[1] >> VTKKW_FP_SHIFT;
600 out[2] = in[2] >> VTKKW_FP_SHIFT;
601}
602
603inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag(unsigned int mmpos[3], int c)
604{
605 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
606 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
607 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
608 static_cast<vtkIdType>(c);
609
610 return ((*(this->MinMaxVolume + 3 * offset + 2)) & 0x00ff);
611}
612
614 unsigned int mmpos[3], int c, unsigned short maxIdx, int flip)
615{
616 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
617 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
618 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
619 static_cast<vtkIdType>(c);
620
621 if ((*(this->MinMaxVolume + 3 * offset + 2) & 0x00ff))
622 {
623 if (flip)
624 {
625 return (*(this->MinMaxVolume + 3 * offset) < maxIdx);
626 }
627 else
628 {
629 return (*(this->MinMaxVolume + 3 * offset + 1) > maxIdx);
630 }
631 }
632 else
633 {
634 return 0;
635 }
636}
637
638inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC(unsigned short* colorTable,
639 unsigned short* scalarOpacityTable, unsigned short index, unsigned char color[4])
640{
641 unsigned short alpha = scalarOpacityTable[index];
642 color[0] = static_cast<unsigned char>(
643 (colorTable[3 * index] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
644 color[1] = static_cast<unsigned char>(
645 (colorTable[3 * index + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
646 color[2] = static_cast<unsigned char>(
647 (colorTable[3 * index + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
648 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
649}
650
651inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC(unsigned short* colorTable,
652 unsigned short* scalarOpacityTable, unsigned short index[4], int components,
653 unsigned char color[4])
654{
655 unsigned short alpha;
656 switch (components)
657 {
658 case 2:
659 alpha = scalarOpacityTable[index[1]];
660 color[0] = static_cast<unsigned char>(
661 (colorTable[3 * index[0]] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
662 color[1] = static_cast<unsigned char>(
663 (colorTable[3 * index[0] + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
664 color[2] = static_cast<unsigned char>(
665 (colorTable[3 * index[0] + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
666 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
667 break;
668 case 4:
669 alpha = scalarOpacityTable[index[3]];
670 color[0] = static_cast<unsigned char>((index[0] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
671 color[1] = static_cast<unsigned char>((index[1] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
672 color[2] = static_cast<unsigned char>((index[2] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
673 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
674 break;
675 }
676}
677
679 unsigned short* colorTable[4], unsigned short* scalarOpacityTable[4], unsigned short index[4],
680 float weights[4], int components, unsigned char color[4])
681{
682 unsigned int tmp[4] = { 0, 0, 0, 0 };
683
684 for (int i = 0; i < components; i++)
685 {
686 unsigned short alpha =
687 static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]]) * weights[i]);
688 tmp[0] += static_cast<unsigned char>(
689 ((colorTable[i][3 * index[i]]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
690 tmp[1] += static_cast<unsigned char>(
691 ((colorTable[i][3 * index[i] + 1]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
692 tmp[2] += static_cast<unsigned char>(
693 ((colorTable[i][3 * index[i] + 2]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
694 tmp[3] += static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
695 }
696
697 color[0] = static_cast<unsigned char>((tmp[0] > 255) ? (255) : (tmp[0]));
698 color[1] = static_cast<unsigned char>((tmp[1] > 255) ? (255) : (tmp[1]));
699 color[2] = static_cast<unsigned char>((tmp[2] > 255) ? (255) : (tmp[2]));
700 color[3] = static_cast<unsigned char>((tmp[3] > 255) ? (255) : (tmp[3]));
701}
702
704{
705 int idx;
706
707 if (pos[2] < this->FixedPointCroppingRegionPlanes[4])
708 {
709 idx = 0;
710 }
711 else if (pos[2] > this->FixedPointCroppingRegionPlanes[5])
712 {
713 idx = 18;
714 }
715 else
716 {
717 idx = 9;
718 }
719
720 if (pos[1] >= this->FixedPointCroppingRegionPlanes[2])
721 {
722 if (pos[1] > this->FixedPointCroppingRegionPlanes[3])
723 {
724 idx += 6;
725 }
726 else
727 {
728 idx += 3;
729 }
730 }
731
732 if (pos[0] >= this->FixedPointCroppingRegionPlanes[0])
733 {
734 if (pos[0] > this->FixedPointCroppingRegionPlanes[1])
735 {
736 idx += 2;
737 }
738 else
739 {
740 idx += 1;
741 }
742 }
743
744 return !(static_cast<unsigned int>(this->CroppingRegionFlags) & this->CroppingRegionMask[idx]);
745}
746
747#endif
Defines a transfer function for mapping a property to an RGB color value.
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?
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?
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
a simple class to control print indentation
Definition vtkIndent.h:34
represent and manipulate 4x4 transformation matrices
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:67
record modification and/or execution time
Timer support and logging.
Definition vtkTimerLog.h:90
describes linear transformations via a 4x4 matrix
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:45
window superclass for vtkRenderWindow
Definition vtkWindow.h:39
int vtkTypeBool
Definition vtkABI.h:69
#define vtkDataArray
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
int vtkIdType
Definition vtkType.h:332