VTK  9.3.1
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
53#ifndef vtkFixedPointVolumeRayCastMapper_h
54#define vtkFixedPointVolumeRayCastMapper_h
55
56#include "vtkRenderingVolumeModule.h" // For export macro
57#include "vtkThreads.h" // for VTK_THREAD_RETURN_TYPE
58#include "vtkVolumeMapper.h"
59
60#define VTKKW_FP_SHIFT 15
61#define VTKKW_FPMM_SHIFT 17
62#define VTKKW_FP_MASK 0x7fff
63#define VTKKW_FP_SCALE 32767.0
64
65VTK_ABI_NAMESPACE_BEGIN
66class vtkMatrix4x4;
69class vtkRenderer;
70class vtkTimerLog;
71class vtkVolume;
72class vtkTransform;
73class vtkRenderWindow;
87class vtkDataArray;
88
89// Forward declaration needed for use by friend declaration below.
90VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
91VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
92
93class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
94{
95public:
98 void PrintSelf(ostream& os, vtkIndent indent) override;
99
101
106 vtkSetMacro(SampleDistance, float);
107 vtkGetMacro(SampleDistance, float);
109
111
118 vtkSetMacro(InteractiveSampleDistance, float);
119 vtkGetMacro(InteractiveSampleDistance, float);
121
123
130 vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
131 vtkGetMacro(ImageSampleDistance, float);
133
135
139 vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
140 vtkGetMacro(MinimumImageSampleDistance, float);
142
144
148 vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
149 vtkGetMacro(MaximumImageSampleDistance, float);
151
153
162 vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
163 vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
164 vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);
166
168
176 vtkSetClampMacro(LockSampleDistanceToInputSpacing, vtkTypeBool, 0, 1);
177 vtkGetMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
178 vtkBooleanMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
180
182
187 void SetNumberOfThreads(int num);
190
192
196 vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
197 vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
198 vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);
200
202
209 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren);
210 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren, vtkVolume* vol);
212
217 void Render(vtkRenderer*, vtkVolume*) override;
218
219 unsigned int ToFixedPointPosition(float val);
220 void ToFixedPointPosition(float in[3], unsigned int out[3]);
221 unsigned int ToFixedPointDirection(float dir);
222 void ToFixedPointDirection(float in[3], unsigned int out[3]);
223 void FixedPointIncrement(unsigned int position[3], unsigned int increment[3]);
224 void GetFloatTripleFromPointer(float v[3], float* ptr);
225 void GetUIntTripleFromPointer(unsigned int v[3], unsigned int* ptr);
226 void ShiftVectorDown(unsigned int in[3], unsigned int out[3]);
227 int CheckMinMaxVolumeFlag(unsigned int pos[3], int c);
228 int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip);
229
230 void LookupColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
231 unsigned short index, unsigned char color[4]);
232 void LookupDependentColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
233 unsigned short index[4], int components, unsigned char color[4]);
234 void LookupAndCombineIndependentColorsUC(unsigned short* colorTable[4],
235 unsigned short* scalarOpacityTable[4], unsigned short index[4], float weights[4],
236 int components, unsigned char color[4]);
237 int CheckIfCropped(unsigned int pos[3]);
238
239 vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
240 vtkGetObjectMacro(MIPHelper, vtkFixedPointVolumeRayCastMIPHelper);
241 vtkGetObjectMacro(CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper);
242 vtkGetObjectMacro(CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper);
243 vtkGetObjectMacro(CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper);
244 vtkGetObjectMacro(CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper);
245 vtkGetVectorMacro(TableShift, float, 4);
246 vtkGetVectorMacro(TableScale, float, 4);
247 vtkGetMacro(ShadingRequired, int);
248 vtkGetMacro(GradientOpacityRequired, int);
249
250 vtkGetObjectMacro(CurrentScalars, vtkDataArray);
251 vtkGetObjectMacro(PreviousScalars, vtkDataArray);
252
253 int* GetRowBounds() { return this->RowBounds; }
254 unsigned short* GetColorTable(int c) { return this->ColorTable[c]; }
255 unsigned short* GetScalarOpacityTable(int c) { return this->ScalarOpacityTable[c]; }
256 unsigned short* GetGradientOpacityTable(int c) { return this->GradientOpacityTable[c]; }
257 vtkVolume* GetVolume() { return this->Volume; }
258 unsigned short** GetGradientNormal() { return this->GradientNormal; }
259 unsigned char** GetGradientMagnitude() { return this->GradientMagnitude; }
260 unsigned short* GetDiffuseShadingTable(int c) { return this->DiffuseShadingTable[c]; }
261 unsigned short* GetSpecularShadingTable(int c) { return this->SpecularShadingTable[c]; }
262
264 int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
265
267
269
271
277 vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
279
280 int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
286
287 void CreateCanonicalView(vtkVolume* volume, vtkImageData* image, int blend_mode,
288 double viewDirection[3], double viewUp[3]);
289
297 {
298 return this->RetrieveRenderTime(ren, vol);
299 }
300 float GetEstimatedRenderTime(vtkRenderer* ren) { return this->RetrieveRenderTime(ren); }
301
303
316 vtkSetMacro(FinalColorWindow, float);
317 vtkGetMacro(FinalColorWindow, float);
318 vtkSetMacro(FinalColorLevel, float);
319 vtkGetMacro(FinalColorLevel, float);
321
322 // Here to be used by the mapper to tell the helper
323 // to flip the MIP comparison in order to support
324 // minimum intensity blending
325 vtkGetMacro(FlipMIPComparison, int);
326
334
335protected:
338
339 // The helper class that displays the image
341
342 // The distance between sample points along the ray
345
346 // The distance between rays in the image
352
353 // Saved values used to restore
356
357 // Internal method for computing matrices needed during
358 // ray casting
359 void ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6],
360 vtkRenderer* ren, vtkVolume* vol);
361
362 int ComputeRowBounds(vtkRenderer* ren, int imageFlag, int rowBoundsFlag, int inputExtent[6]);
363
365
366 friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
367 friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
368
370
377
379
383
384 // This object encapsulated the image and all related information
386
389
395
396 void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
399
401
403
404 vtkColorTransferFunction* SavedRGBFunction[4];
405 vtkPiecewiseFunction* SavedGrayFunction[4];
406 vtkPiecewiseFunction* SavedScalarOpacityFunction[4];
407 vtkPiecewiseFunction* SavedGradientOpacityFunction[4];
408 int SavedColorChannels[4];
409 float SavedScalarOpacityDistance[4];
413
416
418
419 unsigned short ColorTable[4][32768 * 3];
420 unsigned short ScalarOpacityTable[4][32768];
421 unsigned short GradientOpacityTable[4][256];
422 int TableSize[4];
423 float TableScale[4];
424 float TableShift[4];
425
426 float GradientMagnitudeScale[4];
427 float GradientMagnitudeShift[4];
428
429 unsigned short** GradientNormal;
430 unsigned char** GradientMagnitude;
433
435
437
439
441
442 unsigned short DiffuseShadingTable[4][65536 * 3];
443 unsigned short SpecularShadingTable[4][65536 * 3];
444
447
450
453
455 double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
456
461
463
465 double rayStart[3], double rayEnd[3], int numClippingPlanes, float* clippingPlanes);
466
467 unsigned int FixedPointCroppingRegionPlanes[6];
468 unsigned int CroppingRegionMask[27];
469
470 // Get the ZBuffer value corresponding to location (x,y) where (x,y)
471 // are indexing into the ImageInUse image. This must be converted to
472 // the zbuffer image coordinates. Nearest neighbor value is returned.
473 float GetZBufferValue(int x, int y);
474
480
481 // Some variables used for ray computation
482 float ViewToVoxelsArray[16];
483 float WorldToVoxelsArray[16];
484 float VoxelsToWorldArray[16];
485
486 double CroppingBounds[6];
487
490
491 double SavedSpacing[3];
492
493 // Min Max structure used to do space leaping
494 unsigned short* MinMaxVolume;
495 int MinMaxVolumeSize[4];
499
501 void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
502
505
507
509
510private:
512 void operator=(const vtkFixedPointVolumeRayCastMapper&) = delete;
513
514 bool ThreadWarning;
515};
516
518{
519 return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
520}
521
522inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float in[3], unsigned int out[3])
523{
524 out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
525 out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
526 out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
527}
528
530{
531 return ((dir < 0.0) ? (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5))
532 : (0x80000000 + static_cast<unsigned int>(dir * VTKKW_FP_SCALE + 0.5)));
533}
534
536 float in[3], unsigned int out[3])
537{
538 out[0] = ((in[0] < 0.0) ? (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5))
539 : (0x80000000 + static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5)));
540 out[1] = ((in[1] < 0.0) ? (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5))
541 : (0x80000000 + static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5)));
542 out[2] = ((in[2] < 0.0) ? (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5))
543 : (0x80000000 + static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5)));
544}
545
547 unsigned int position[3], unsigned int increment[3])
548{
549 if (increment[0] & 0x80000000)
550 {
551 position[0] += (increment[0] & 0x7fffffff);
552 }
553 else
554 {
555 position[0] -= increment[0];
556 }
557 if (increment[1] & 0x80000000)
558 {
559 position[1] += (increment[1] & 0x7fffffff);
560 }
561 else
562 {
563 position[1] -= increment[1];
564 }
565 if (increment[2] & 0x80000000)
566 {
567 position[2] += (increment[2] & 0x7fffffff);
568 }
569 else
570 {
571 position[2] -= increment[2];
572 }
573}
574
576{
577 v[0] = *(ptr);
578 v[1] = *(ptr + 1);
579 v[2] = *(ptr + 2);
580}
581
583 unsigned int v[3], unsigned int* ptr)
584{
585 v[0] = *(ptr);
586 v[1] = *(ptr + 1);
587 v[2] = *(ptr + 2);
588}
589
591 unsigned int in[3], unsigned int out[3])
592{
593 out[0] = in[0] >> VTKKW_FP_SHIFT;
594 out[1] = in[1] >> VTKKW_FP_SHIFT;
595 out[2] = in[2] >> VTKKW_FP_SHIFT;
596}
597
598inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag(unsigned int mmpos[3], int c)
599{
600 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
601 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
602 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
603 static_cast<vtkIdType>(c);
604
605 return ((*(this->MinMaxVolume + 3 * offset + 2)) & 0x00ff);
606}
607
609 unsigned int mmpos[3], int c, unsigned short maxIdx, int flip)
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 if ((*(this->MinMaxVolume + 3 * offset + 2) & 0x00ff))
617 {
618 if (flip)
619 {
620 return (*(this->MinMaxVolume + 3 * offset) < maxIdx);
621 }
622 else
623 {
624 return (*(this->MinMaxVolume + 3 * offset + 1) > maxIdx);
625 }
626 }
627 else
628 {
629 return 0;
630 }
631}
632
633inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC(unsigned short* colorTable,
634 unsigned short* scalarOpacityTable, unsigned short index, unsigned char color[4])
635{
636 unsigned short alpha = scalarOpacityTable[index];
637 color[0] = static_cast<unsigned char>(
638 (colorTable[3 * index] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
639 color[1] = static_cast<unsigned char>(
640 (colorTable[3 * index + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
641 color[2] = static_cast<unsigned char>(
642 (colorTable[3 * index + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
643 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
644}
645
646inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC(unsigned short* colorTable,
647 unsigned short* scalarOpacityTable, unsigned short index[4], int components,
648 unsigned char color[4])
649{
650 unsigned short alpha;
651 switch (components)
652 {
653 case 2:
654 alpha = scalarOpacityTable[index[1]];
655 color[0] = static_cast<unsigned char>(
656 (colorTable[3 * index[0]] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
657 color[1] = static_cast<unsigned char>(
658 (colorTable[3 * index[0] + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
659 color[2] = static_cast<unsigned char>(
660 (colorTable[3 * index[0] + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
661 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
662 break;
663 case 4:
664 alpha = scalarOpacityTable[index[3]];
665 color[0] = static_cast<unsigned char>((index[0] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
666 color[1] = static_cast<unsigned char>((index[1] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
667 color[2] = static_cast<unsigned char>((index[2] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
668 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
669 break;
670 }
671}
672
674 unsigned short* colorTable[4], unsigned short* scalarOpacityTable[4], unsigned short index[4],
675 float weights[4], int components, unsigned char color[4])
676{
677 unsigned int tmp[4] = { 0, 0, 0, 0 };
678
679 for (int i = 0; i < components; i++)
680 {
681 unsigned short alpha =
682 static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]]) * weights[i]);
683 tmp[0] += static_cast<unsigned char>(
684 ((colorTable[i][3 * index[i]]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
685 tmp[1] += static_cast<unsigned char>(
686 ((colorTable[i][3 * index[i] + 1]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
687 tmp[2] += static_cast<unsigned char>(
688 ((colorTable[i][3 * index[i] + 2]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
689 tmp[3] += static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
690 }
691
692 color[0] = static_cast<unsigned char>((tmp[0] > 255) ? (255) : (tmp[0]));
693 color[1] = static_cast<unsigned char>((tmp[1] > 255) ? (255) : (tmp[1]));
694 color[2] = static_cast<unsigned char>((tmp[2] > 255) ? (255) : (tmp[2]));
695 color[3] = static_cast<unsigned char>((tmp[3] > 255) ? (255) : (tmp[3]));
696}
697
699{
700 int idx;
701
702 if (pos[2] < this->FixedPointCroppingRegionPlanes[4])
703 {
704 idx = 0;
705 }
706 else if (pos[2] > this->FixedPointCroppingRegionPlanes[5])
707 {
708 idx = 18;
709 }
710 else
711 {
712 idx = 9;
713 }
714
715 if (pos[1] >= this->FixedPointCroppingRegionPlanes[2])
716 {
717 if (pos[1] > this->FixedPointCroppingRegionPlanes[3])
718 {
719 idx += 6;
720 }
721 else
722 {
723 idx += 3;
724 }
725 }
726
727 if (pos[0] >= this->FixedPointCroppingRegionPlanes[0])
728 {
729 if (pos[0] > this->FixedPointCroppingRegionPlanes[1])
730 {
731 idx += 2;
732 }
733 else
734 {
735 idx += 1;
736 }
737 }
738
739 return !(static_cast<unsigned int>(this->CroppingRegionFlags) & this->CroppingRegionMask[idx]);
740}
741
742VTK_ABI_NAMESPACE_END
743#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:62
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:28
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