VTK  9.5.20250806
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
102#ifndef vtkFixedPointVolumeRayCastMapper_h
103#define vtkFixedPointVolumeRayCastMapper_h
104
105#include "vtkRenderingVolumeModule.h" // For export macro
106#include "vtkThreads.h" // for VTK_THREAD_RETURN_TYPE
107#include "vtkVolumeMapper.h"
108#include "vtkWrappingHints.h"
109
110#define VTKKW_FP_SHIFT 15
111#define VTKKW_FPMM_SHIFT 17
112#define VTKKW_FP_MASK 0x7fff
113#define VTKKW_FP_SCALE 32767.0
114
115VTK_ABI_NAMESPACE_BEGIN
116class vtkMatrix4x4;
117class vtkMultiThreader;
119class vtkRenderer;
120class vtkTimerLog;
121class vtkVolume;
122class vtkTransform;
123class vtkRenderWindow;
137class vtkDataArray;
138
139// Forward declaration needed for use by friend declaration below.
140VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
141VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
142
144 : public vtkVolumeMapper
145{
146public:
149 void PrintSelf(ostream& os, vtkIndent indent) override;
150
152
157 vtkSetMacro(SampleDistance, float);
158 vtkGetMacro(SampleDistance, float);
160
162
169 vtkSetMacro(InteractiveSampleDistance, float);
170 vtkGetMacro(InteractiveSampleDistance, float);
172
174
181 vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
182 vtkGetMacro(ImageSampleDistance, float);
184
186
190 vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
191 vtkGetMacro(MinimumImageSampleDistance, float);
193
195
199 vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
200 vtkGetMacro(MaximumImageSampleDistance, float);
202
204
213 vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
214 vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
215 vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);
217
219
227 vtkSetClampMacro(LockSampleDistanceToInputSpacing, vtkTypeBool, 0, 1);
228 vtkGetMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
229 vtkBooleanMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
231
233
238 void SetNumberOfThreads(int num);
241
243
247 vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
248 vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
249 vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);
251
253
260 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren);
261 float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren, vtkVolume* vol);
263
268 void Render(vtkRenderer*, vtkVolume*) override;
269
270 unsigned int ToFixedPointPosition(float val);
271 void ToFixedPointPosition(float in[3], unsigned int out[3]);
272 unsigned int ToFixedPointDirection(float dir);
273 void ToFixedPointDirection(float in[3], unsigned int out[3]);
274 void FixedPointIncrement(unsigned int position[3], unsigned int increment[3]);
275 void GetFloatTripleFromPointer(float v[3], float* ptr);
276 void GetUIntTripleFromPointer(unsigned int v[3], unsigned int* ptr);
277 void ShiftVectorDown(unsigned int in[3], unsigned int out[3]);
278 int CheckMinMaxVolumeFlag(unsigned int pos[3], int c);
279 int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip);
280
281 void LookupColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
282 unsigned short index, unsigned char color[4]);
283 void LookupDependentColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
284 unsigned short index[4], int components, unsigned char color[4]);
285 void LookupAndCombineIndependentColorsUC(unsigned short* colorTable[4],
286 unsigned short* scalarOpacityTable[4], unsigned short index[4], float weights[4],
287 int components, unsigned char color[4]);
288 int CheckIfCropped(unsigned int pos[3]);
289
290 vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
291 vtkGetObjectMacro(MIPHelper, vtkFixedPointVolumeRayCastMIPHelper);
292 vtkGetObjectMacro(CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper);
293 vtkGetObjectMacro(CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper);
294 vtkGetObjectMacro(CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper);
295 vtkGetObjectMacro(CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper);
296 vtkGetVectorMacro(TableShift, float, 4);
297 vtkGetVectorMacro(TableScale, float, 4);
298 vtkGetMacro(ShadingRequired, int);
299 vtkGetMacro(GradientOpacityRequired, int);
300
301 vtkGetObjectMacro(CurrentScalars, vtkDataArray);
302 vtkGetObjectMacro(PreviousScalars, vtkDataArray);
303
304 int* GetRowBounds() { return this->RowBounds; }
305 unsigned short* GetColorTable(int c) { return this->ColorTable[c]; }
306 unsigned short* GetScalarOpacityTable(int c) { return this->ScalarOpacityTable[c]; }
307 unsigned short* GetGradientOpacityTable(int c) { return this->GradientOpacityTable[c]; }
308 vtkVolume* GetVolume() { return this->Volume; }
309 unsigned short** GetGradientNormal() { return this->GradientNormal; }
310 unsigned char** GetGradientMagnitude() { return this->GradientMagnitude; }
311 unsigned short* GetDiffuseShadingTable(int c) { return this->DiffuseShadingTable[c]; }
312 unsigned short* GetSpecularShadingTable(int c) { return this->SpecularShadingTable[c]; }
313
315 int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
316
318
320
322
328 void SetRayCastImage(vtkFixedPointRayCastImage*);
330 vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
332
333 int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
334 void PerVolumeInitialization(vtkRenderer*, vtkVolume*);
335 void PerSubVolumeInitialization(vtkRenderer*, vtkVolume*, int);
336 void RenderSubVolume();
337 void DisplayRenderedImage(vtkRenderer*, vtkVolume*);
338 void AbortRender();
339
340 void CreateCanonicalView(vtkVolume* volume, vtkImageData* image, int blend_mode,
341 double viewDirection[3], double viewUp[3]);
342
349 float GetEstimatedRenderTime(vtkRenderer* ren, vtkVolume* vol)
350 {
351 return this->RetrieveRenderTime(ren, vol);
352 }
353 float GetEstimatedRenderTime(vtkRenderer* ren) { return this->RetrieveRenderTime(ren); }
354
356
369 vtkSetMacro(FinalColorWindow, float);
370 vtkGetMacro(FinalColorWindow, float);
371 vtkSetMacro(FinalColorLevel, float);
372 vtkGetMacro(FinalColorLevel, float);
374
375 // Here to be used by the mapper to tell the helper
376 // to flip the MIP comparison in order to support
377 // minimum intensity blending
378 vtkGetMacro(FlipMIPComparison, int);
379
387
388protected:
391
392 // The helper class that displays the image
394
395 // The distance between sample points along the ray
398
399 // The distance between rays in the image
405
406 // Saved values used to restore
409
410 // Internal method for computing matrices needed during
411 // ray casting
412 void ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6],
413 vtkRenderer* ren, vtkVolume* vol);
414
415 int ComputeRowBounds(vtkRenderer* ren, int imageFlag, int rowBoundsFlag, int inputExtent[6]);
416
418
419 friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
420 friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
421
423
430
432
436
437 // This object encapsulated the image and all related information
439
442
448
449 void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
452
454
456
457 vtkColorTransferFunction* SavedRGBFunction[4];
458 vtkPiecewiseFunction* SavedGrayFunction[4];
459 vtkPiecewiseFunction* SavedScalarOpacityFunction[4];
460 vtkPiecewiseFunction* SavedGradientOpacityFunction[4];
461 int SavedColorChannels[4];
462 float SavedScalarOpacityDistance[4];
466
469
471
472 unsigned short ColorTable[4][32768 * 3];
473 unsigned short ScalarOpacityTable[4][32768];
474 unsigned short GradientOpacityTable[4][256];
475 int TableSize[4];
476 float TableScale[4];
477 float TableShift[4];
478
479 float GradientMagnitudeScale[4];
480 float GradientMagnitudeShift[4];
481
482 unsigned short** GradientNormal;
483 unsigned char** GradientMagnitude;
486
488
490
492
494
495 unsigned short DiffuseShadingTable[4][65536 * 3];
496 unsigned short SpecularShadingTable[4][65536 * 3];
497
500
503
506
508 double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
509
514
516
518 double rayStart[3], double rayEnd[3], int numClippingPlanes, float* clippingPlanes);
519
520 unsigned int FixedPointCroppingRegionPlanes[6];
521 unsigned int CroppingRegionMask[27];
522
523 // Get the ZBuffer value corresponding to location (x,y) where (x,y)
524 // are indexing into the ImageInUse image. This must be converted to
525 // the zbuffer image coordinates. Nearest neighbor value is returned.
526 float GetZBufferValue(int x, int y);
527
533
534 // Some variables used for ray computation
535 float ViewToVoxelsArray[16];
536 float WorldToVoxelsArray[16];
537 float VoxelsToWorldArray[16];
538
539 double CroppingBounds[6];
540
543
544 double SavedSpacing[3];
545
546 // Min Max structure used to do space leaping
547 unsigned short* MinMaxVolume;
548 int MinMaxVolumeSize[4];
552
554 void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
555
558
560
562
563private:
565 void operator=(const vtkFixedPointVolumeRayCastMapper&) = delete;
566
567 bool ThreadWarning;
568};
569
571{
572 return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
573}
574
575inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float in[3], unsigned int out[3])
576{
577 out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
578 out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
579 out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
580}
581
583{
584 return ((dir < 0.0) ? (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5))
585 : (0x80000000 + static_cast<unsigned int>(dir * VTKKW_FP_SCALE + 0.5)));
586}
587
589 float in[3], unsigned int out[3])
590{
591 out[0] = ((in[0] < 0.0) ? (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5))
592 : (0x80000000 + static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5)));
593 out[1] = ((in[1] < 0.0) ? (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5))
594 : (0x80000000 + static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5)));
595 out[2] = ((in[2] < 0.0) ? (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5))
596 : (0x80000000 + static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5)));
597}
598
600 unsigned int position[3], unsigned int increment[3])
601{
602 if (increment[0] & 0x80000000)
603 {
604 position[0] += (increment[0] & 0x7fffffff);
605 }
606 else
607 {
608 position[0] -= increment[0];
609 }
610 if (increment[1] & 0x80000000)
611 {
612 position[1] += (increment[1] & 0x7fffffff);
613 }
614 else
615 {
616 position[1] -= increment[1];
617 }
618 if (increment[2] & 0x80000000)
619 {
620 position[2] += (increment[2] & 0x7fffffff);
621 }
622 else
623 {
624 position[2] -= increment[2];
625 }
626}
627
629{
630 v[0] = *(ptr);
631 v[1] = *(ptr + 1);
632 v[2] = *(ptr + 2);
633}
634
636 unsigned int v[3], unsigned int* ptr)
637{
638 v[0] = *(ptr);
639 v[1] = *(ptr + 1);
640 v[2] = *(ptr + 2);
641}
642
644 unsigned int in[3], unsigned int out[3])
645{
646 out[0] = in[0] >> VTKKW_FP_SHIFT;
647 out[1] = in[1] >> VTKKW_FP_SHIFT;
648 out[2] = in[2] >> VTKKW_FP_SHIFT;
649}
650
651inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag(unsigned int mmpos[3], int c)
652{
653 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
654 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
655 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
656 static_cast<vtkIdType>(c);
657
658 return ((*(this->MinMaxVolume + 3 * offset + 2)) & 0x00ff);
659}
660
662 unsigned int mmpos[3], int c, unsigned short maxIdx, int flip)
663{
664 vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
665 (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
666 mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
667 static_cast<vtkIdType>(c);
668
669 if ((*(this->MinMaxVolume + 3 * offset + 2) & 0x00ff))
670 {
671 if (flip)
672 {
673 return (*(this->MinMaxVolume + 3 * offset) < maxIdx);
674 }
675 else
676 {
677 return (*(this->MinMaxVolume + 3 * offset + 1) > maxIdx);
678 }
679 }
680 else
681 {
682 return 0;
683 }
684}
685
686inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC(unsigned short* colorTable,
687 unsigned short* scalarOpacityTable, unsigned short index, unsigned char color[4])
688{
689 unsigned short alpha = scalarOpacityTable[index];
690 color[0] = static_cast<unsigned char>(
691 (colorTable[3 * index] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
692 color[1] = static_cast<unsigned char>(
693 (colorTable[3 * index + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
694 color[2] = static_cast<unsigned char>(
695 (colorTable[3 * index + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
696 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
697}
698
699inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC(unsigned short* colorTable,
700 unsigned short* scalarOpacityTable, unsigned short index[4], int components,
701 unsigned char color[4])
702{
703 unsigned short alpha;
704 switch (components)
705 {
706 case 2:
707 alpha = scalarOpacityTable[index[1]];
708 color[0] = static_cast<unsigned char>(
709 (colorTable[3 * index[0]] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
710 color[1] = static_cast<unsigned char>(
711 (colorTable[3 * index[0] + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
712 color[2] = static_cast<unsigned char>(
713 (colorTable[3 * index[0] + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
714 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
715 break;
716 case 4:
717 alpha = scalarOpacityTable[index[3]];
718 color[0] = static_cast<unsigned char>((index[0] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
719 color[1] = static_cast<unsigned char>((index[1] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
720 color[2] = static_cast<unsigned char>((index[2] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
721 color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
722 break;
723 }
724}
725
727 unsigned short* colorTable[4], unsigned short* scalarOpacityTable[4], unsigned short index[4],
728 float weights[4], int components, unsigned char color[4])
729{
730 unsigned int tmp[4] = { 0, 0, 0, 0 };
731
732 for (int i = 0; i < components; i++)
733 {
734 unsigned short alpha =
735 static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]]) * weights[i]);
736 tmp[0] += static_cast<unsigned char>(
737 ((colorTable[i][3 * index[i]]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
738 tmp[1] += static_cast<unsigned char>(
739 ((colorTable[i][3 * index[i] + 1]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
740 tmp[2] += static_cast<unsigned char>(
741 ((colorTable[i][3 * index[i] + 2]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
742 tmp[3] += static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
743 }
744
745 color[0] = static_cast<unsigned char>((tmp[0] > 255) ? (255) : (tmp[0]));
746 color[1] = static_cast<unsigned char>((tmp[1] > 255) ? (255) : (tmp[1]));
747 color[2] = static_cast<unsigned char>((tmp[2] > 255) ? (255) : (tmp[2]));
748 color[3] = static_cast<unsigned char>((tmp[3] > 255) ? (255) : (tmp[3]));
749}
750
752{
753 int idx;
754
755 if (pos[2] < this->FixedPointCroppingRegionPlanes[4])
756 {
757 idx = 0;
758 }
759 else if (pos[2] > this->FixedPointCroppingRegionPlanes[5])
760 {
761 idx = 18;
762 }
763 else
764 {
765 idx = 9;
766 }
767
768 if (pos[1] >= this->FixedPointCroppingRegionPlanes[2])
769 {
770 if (pos[1] > this->FixedPointCroppingRegionPlanes[3])
771 {
772 idx += 6;
773 }
774 else
775 {
776 idx += 3;
777 }
778 }
779
780 if (pos[0] >= this->FixedPointCroppingRegionPlanes[0])
781 {
782 if (pos[0] > this->FixedPointCroppingRegionPlanes[1])
783 {
784 idx += 2;
785 }
786 else
787 {
788 idx += 1;
789 }
790 }
791
792 return !(static_cast<unsigned int>(this->CroppingRegionFlags) & this->CroppingRegionMask[idx]);
793}
794
795VTK_ABI_NAMESPACE_END
796#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.
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 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 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 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
int ClipRayAgainstVolume(double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6])
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:108
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
record modification and/or execution time
Timer support and logging.
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:130
window superclass for vtkRenderWindow
Definition vtkWindow.h:48
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:332
#define VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL
#define VTK_MARSHALAUTO
#define VTK_MARSHALEXCLUDE(reason)