VTK  9.3.0
vtkFixedPointVolumeRayCastMapper.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2// SPDX-License-Identifier: BSD-3-Clause
50#ifndef vtkFixedPointVolumeRayCastMapper_h
51#define vtkFixedPointVolumeRayCastMapper_h
52
53#include "vtkRenderingVolumeModule.h" // For export macro
54#include "vtkThreads.h" // for VTK_THREAD_RETURN_TYPE
55#include "vtkVolumeMapper.h"
56
57#define VTKKW_FP_SHIFT 15
58#define VTKKW_FPMM_SHIFT 17
59#define VTKKW_FP_MASK 0x7fff
60#define VTKKW_FP_SCALE 32767.0
61
62VTK_ABI_NAMESPACE_BEGIN
63class vtkMatrix4x4;
66class vtkRenderer;
67class vtkTimerLog;
68class vtkVolume;
69class vtkTransform;
70class vtkRenderWindow;
84class vtkDataArray;
85
86// Forward declaration needed for use by friend declaration below.
87VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
88VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
89
90class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
91{
92public:
95 void PrintSelf(ostream& os, vtkIndent indent) override;
96
98
103 vtkSetMacro(SampleDistance, float);
104 vtkGetMacro(SampleDistance, float);
106
108
115 vtkSetMacro(InteractiveSampleDistance, float);
116 vtkGetMacro(InteractiveSampleDistance, float);
118
120
127 vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
128 vtkGetMacro(ImageSampleDistance, float);
130
132
136 vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
137 vtkGetMacro(MinimumImageSampleDistance, float);
139
141
145 vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
146 vtkGetMacro(MaximumImageSampleDistance, float);
148
150
159 vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
160 vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
161 vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);
163
165
173 vtkSetClampMacro(LockSampleDistanceToInputSpacing, vtkTypeBool, 0, 1);
174 vtkGetMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
175 vtkBooleanMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
177
179
184 void SetNumberOfThreads(int num);
187
189
193 vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
194 vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
195 vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);
197
199
206 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren);
207 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren, vtkVolume* vol);
209
214 void Render(vtkRenderer*, vtkVolume*) override;
215
216 unsigned int ToFixedPointPosition(float val);
217 void ToFixedPointPosition(float in[3], unsigned int out[3]);
218 unsigned int ToFixedPointDirection(float dir);
219 void ToFixedPointDirection(float in[3], unsigned int out[3]);
220 void FixedPointIncrement(unsigned int position[3], unsigned int increment[3]);
221 void GetFloatTripleFromPointer(float v[3], float* ptr);
222 void GetUIntTripleFromPointer(unsigned int v[3], unsigned int* ptr);
223 void ShiftVectorDown(unsigned int in[3], unsigned int out[3]);
224 int CheckMinMaxVolumeFlag(unsigned int pos[3], int c);
225 int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip);
226
227 void LookupColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
228 unsigned short index, unsigned char color[4]);
229 void LookupDependentColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
230 unsigned short index[4], int components, unsigned char color[4]);
231 void LookupAndCombineIndependentColorsUC(unsigned short* colorTable[4],
232 unsigned short* scalarOpacityTable[4], unsigned short index[4], float weights[4],
233 int components, unsigned char color[4]);
234 int CheckIfCropped(unsigned int pos[3]);
235
236 vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
237 vtkGetObjectMacro(MIPHelper, vtkFixedPointVolumeRayCastMIPHelper);
238 vtkGetObjectMacro(CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper);
239 vtkGetObjectMacro(CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper);
240 vtkGetObjectMacro(CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper);
241 vtkGetObjectMacro(CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper);
242 vtkGetVectorMacro(TableShift, float, 4);
243 vtkGetVectorMacro(TableScale, float, 4);
244 vtkGetMacro(ShadingRequired, int);
245 vtkGetMacro(GradientOpacityRequired, int);
246
247 vtkGetObjectMacro(CurrentScalars, vtkDataArray);
248 vtkGetObjectMacro(PreviousScalars, vtkDataArray);
249
250 int* GetRowBounds() { return this->RowBounds; }
251 unsigned short* GetColorTable(int c) { return this->ColorTable[c]; }
252 unsigned short* GetScalarOpacityTable(int c) { return this->ScalarOpacityTable[c]; }
253 unsigned short* GetGradientOpacityTable(int c) { return this->GradientOpacityTable[c]; }
254 vtkVolume* GetVolume() { return this->Volume; }
255 unsigned short** GetGradientNormal() { return this->GradientNormal; }
256 unsigned char** GetGradientMagnitude() { return this->GradientMagnitude; }
257 unsigned short* GetDiffuseShadingTable(int c) { return this->DiffuseShadingTable[c]; }
258 unsigned short* GetSpecularShadingTable(int c) { return this->SpecularShadingTable[c]; }
259
261 int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
262
264
266
268
274 vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
276
277 int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
283
284 void CreateCanonicalView(vtkVolume* volume, vtkImageData* image, int blend_mode,
285 double viewDirection[3], double viewUp[3]);
286
294 {
295 return this->RetrieveRenderTime(ren, vol);
296 }
297 float GetEstimatedRenderTime(vtkRenderer* ren) { return this->RetrieveRenderTime(ren); }
298
300
313 vtkSetMacro(FinalColorWindow, float);
314 vtkGetMacro(FinalColorWindow, float);
315 vtkSetMacro(FinalColorLevel, float);
316 vtkGetMacro(FinalColorLevel, float);
318
319 // Here to be used by the mapper to tell the helper
320 // to flip the MIP comparison in order to support
321 // minimum intensity blending
322 vtkGetMacro(FlipMIPComparison, int);
323
331
332protected:
335
336 // The helper class that displays the image
338
339 // The distance between sample points along the ray
342
343 // The distance between rays in the image
349
350 // Saved values used to restore
353
354 // Internal method for computing matrices needed during
355 // ray casting
356 void ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6],
357 vtkRenderer* ren, vtkVolume* vol);
358
359 int ComputeRowBounds(vtkRenderer* ren, int imageFlag, int rowBoundsFlag, int inputExtent[6]);
360
362
363 friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
364 friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
365
367
374
376
380
381 // This object encapsulated the image and all related information
383
386
392
393 void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
396
398
400
401 vtkColorTransferFunction* SavedRGBFunction[4];
402 vtkPiecewiseFunction* SavedGrayFunction[4];
403 vtkPiecewiseFunction* SavedScalarOpacityFunction[4];
404 vtkPiecewiseFunction* SavedGradientOpacityFunction[4];
405 int SavedColorChannels[4];
406 float SavedScalarOpacityDistance[4];
410
413
415
416 unsigned short ColorTable[4][32768 * 3];
417 unsigned short ScalarOpacityTable[4][32768];
418 unsigned short GradientOpacityTable[4][256];
419 int TableSize[4];
420 float TableScale[4];
421 float TableShift[4];
422
423 float GradientMagnitudeScale[4];
424 float GradientMagnitudeShift[4];
425
426 unsigned short** GradientNormal;
427 unsigned char** GradientMagnitude;
430
432
434
436
438
439 unsigned short DiffuseShadingTable[4][65536 * 3];
440 unsigned short SpecularShadingTable[4][65536 * 3];
441
444
447
450
452 double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
453
458
460
462 double rayStart[3], double rayEnd[3], int numClippingPlanes, float* clippingPlanes);
463
464 unsigned int FixedPointCroppingRegionPlanes[6];
465 unsigned int CroppingRegionMask[27];
466
467 // Get the ZBuffer value corresponding to location (x,y) where (x,y)
468 // are indexing into the ImageInUse image. This must be converted to
469 // the zbuffer image coordinates. Nearest neighbor value is returned.
470 float GetZBufferValue(int x, int y);
471
477
478 // Some variables used for ray computation
479 float ViewToVoxelsArray[16];
480 float WorldToVoxelsArray[16];
481 float VoxelsToWorldArray[16];
482
483 double CroppingBounds[6];
484
487
488 double SavedSpacing[3];
489
490 // Min Max structure used to do space leaping
491 unsigned short* MinMaxVolume;
492 int MinMaxVolumeSize[4];
496
498 void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
499
502
504
506
507private:
509 void operator=(const vtkFixedPointVolumeRayCastMapper&) = delete;
510
511 bool ThreadWarning;
512};
513
515{
516 return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
517}
518
519inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float in[3], unsigned int out[3])
520{
521 out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
522 out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
523 out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
524}
525
527{
528 return ((dir < 0.0) ? (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5))
529 : (0x80000000 + static_cast<unsigned int>(dir * VTKKW_FP_SCALE + 0.5)));
530}
531
533 float in[3], unsigned int out[3])
534{
535 out[0] = ((in[0] < 0.0) ? (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5))
536 : (0x80000000 + static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5)));
537 out[1] = ((in[1] < 0.0) ? (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5))
538 : (0x80000000 + static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5)));
539 out[2] = ((in[2] < 0.0) ? (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5))
540 : (0x80000000 + static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5)));
541}
542
544 unsigned int position[3], unsigned int increment[3])
545{
546 if (increment[0] & 0x80000000)
547 {
548 position[0] += (increment[0] & 0x7fffffff);
549 }
550 else
551 {
552 position[0] -= increment[0];
553 }
554 if (increment[1] & 0x80000000)
555 {
556 position[1] += (increment[1] & 0x7fffffff);
557 }
558 else
559 {
560 position[1] -= increment[1];
561 }
562 if (increment[2] & 0x80000000)
563 {
564 position[2] += (increment[2] & 0x7fffffff);
565 }
566 else
567 {
568 position[2] -= increment[2];
569 }
570}
571
573{
574 v[0] = *(ptr);
575 v[1] = *(ptr + 1);
576 v[2] = *(ptr + 2);
577}
578
580 unsigned int v[3], unsigned int* ptr)
581{
582 v[0] = *(ptr);
583 v[1] = *(ptr + 1);
584 v[2] = *(ptr + 2);
585}
586
588 unsigned int in[3], unsigned int out[3])
589{
590 out[0] = in[0] >> VTKKW_FP_SHIFT;
591 out[1] = in[1] >> VTKKW_FP_SHIFT;
592 out[2] = in[2] >> VTKKW_FP_SHIFT;
593}
594
595inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag(unsigned int mmpos[3], int c)
596{
597 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
598 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
599 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
600 static_cast<vtkIdType>(c);
601
602 return ((*(this->MinMaxVolume + 3 * offset + 2)) & 0x00ff);
603}
604
606 unsigned int mmpos[3], int c, unsigned short maxIdx, int flip)
607{
608 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
609 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
610 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
611 static_cast<vtkIdType>(c);
612
613 if ((*(this->MinMaxVolume + 3 * offset + 2) & 0x00ff))
614 {
615 if (flip)
616 {
617 return (*(this->MinMaxVolume + 3 * offset) < maxIdx);
618 }
619 else
620 {
621 return (*(this->MinMaxVolume + 3 * offset + 1) > maxIdx);
622 }
623 }
624 else
625 {
626 return 0;
627 }
628}
629
630inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC(unsigned short* colorTable,
631 unsigned short* scalarOpacityTable, unsigned short index, unsigned char color[4])
632{
633 unsigned short alpha = scalarOpacityTable[index];
634 color[0] = static_cast<unsigned char>(
635 (colorTable[3 * index] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
636 color[1] = static_cast<unsigned char>(
637 (colorTable[3 * index + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
638 color[2] = static_cast<unsigned char>(
639 (colorTable[3 * index + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
640 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
641}
642
643inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC(unsigned short* colorTable,
644 unsigned short* scalarOpacityTable, unsigned short index[4], int components,
645 unsigned char color[4])
646{
647 unsigned short alpha;
648 switch (components)
649 {
650 case 2:
651 alpha = scalarOpacityTable[index[1]];
652 color[0] = static_cast<unsigned char>(
653 (colorTable[3 * index[0]] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
654 color[1] = static_cast<unsigned char>(
655 (colorTable[3 * index[0] + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
656 color[2] = static_cast<unsigned char>(
657 (colorTable[3 * index[0] + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
658 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
659 break;
660 case 4:
661 alpha = scalarOpacityTable[index[3]];
662 color[0] = static_cast<unsigned char>((index[0] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
663 color[1] = static_cast<unsigned char>((index[1] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
664 color[2] = static_cast<unsigned char>((index[2] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
665 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
666 break;
667 }
668}
669
671 unsigned short* colorTable[4], unsigned short* scalarOpacityTable[4], unsigned short index[4],
672 float weights[4], int components, unsigned char color[4])
673{
674 unsigned int tmp[4] = { 0, 0, 0, 0 };
675
676 for (int i = 0; i < components; i++)
677 {
678 unsigned short alpha =
679 static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]]) * weights[i]);
680 tmp[0] += static_cast<unsigned char>(
681 ((colorTable[i][3 * index[i]]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
682 tmp[1] += static_cast<unsigned char>(
683 ((colorTable[i][3 * index[i] + 1]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
684 tmp[2] += static_cast<unsigned char>(
685 ((colorTable[i][3 * index[i] + 2]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
686 tmp[3] += static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
687 }
688
689 color[0] = static_cast<unsigned char>((tmp[0] > 255) ? (255) : (tmp[0]));
690 color[1] = static_cast<unsigned char>((tmp[1] > 255) ? (255) : (tmp[1]));
691 color[2] = static_cast<unsigned char>((tmp[2] > 255) ? (255) : (tmp[2]));
692 color[3] = static_cast<unsigned char>((tmp[3] > 255) ? (255) : (tmp[3]));
693}
694
696{
697 int idx;
698
699 if (pos[2] < this->FixedPointCroppingRegionPlanes[4])
700 {
701 idx = 0;
702 }
703 else if (pos[2] > this->FixedPointCroppingRegionPlanes[5])
704 {
705 idx = 18;
706 }
707 else
708 {
709 idx = 9;
710 }
711
712 if (pos[1] >= this->FixedPointCroppingRegionPlanes[2])
713 {
714 if (pos[1] > this->FixedPointCroppingRegionPlanes[3])
715 {
716 idx += 6;
717 }
718 else
719 {
720 idx += 3;
721 }
722 }
723
724 if (pos[0] >= this->FixedPointCroppingRegionPlanes[0])
725 {
726 if (pos[0] > this->FixedPointCroppingRegionPlanes[1])
727 {
728 idx += 2;
729 }
730 else
731 {
732 idx += 1;
733 }
734 }
735
736 return !(static_cast<unsigned int>(this->CroppingRegionFlags) & this->CroppingRegionMask[idx]);
737}
738
739VTK_ABI_NAMESPACE_END
740#endif
Defines a transfer function for mapping a property to an RGB color value.
abstract superclass for arrays of numeric data
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
a simple class to control print indentation
Definition vtkIndent.h:29
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:59
record modification and/or execution time
Timer support and logging.
Definition vtkTimerLog.h:85
describes linear transformations via a 4x4 matrix
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:40
window superclass for vtkRenderWindow
Definition vtkWindow.h:25
int vtkTypeBool
Definition vtkABI.h:64
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
int vtkIdType
Definition vtkType.h:315