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 
65 VTK_ABI_NAMESPACE_BEGIN
66 class vtkMatrix4x4;
67 class vtkMultiThreader;
68 class vtkPlaneCollection;
69 class vtkRenderer;
70 class vtkTimerLog;
71 class vtkVolume;
72 class vtkTransform;
73 class vtkRenderWindow;
87 class vtkDataArray;
88 
89 // Forward declaration needed for use by friend declaration below.
90 VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
91 VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
92 
93 class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
94 {
95 public:
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);
188  int GetNumberOfThreads();
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 
263  void ComputeRayInfo(
264  int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
265 
266  void InitializeRayInfo(vtkVolume* vol);
267 
268  int ShouldUseNearestNeighborInterpolation(vtkVolume* vol);
269 
271 
276  void SetRayCastImage(vtkFixedPointRayCastImage*);
277  vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
279 
280  int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
281  void PerVolumeInitialization(vtkRenderer*, vtkVolume*);
282  void PerSubVolumeInitialization(vtkRenderer*, vtkVolume*, int);
283  void RenderSubVolume();
284  void DisplayRenderedImage(vtkRenderer*, vtkVolume*);
285  void AbortRender();
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 
333  void ReleaseGraphicsResources(vtkWindow*) override;
334 
335 protected:
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 
364  void CaptureZBuffer(vtkRenderer* ren);
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 
387  int* RowBounds;
389 
395 
396  void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
397  float RetrieveRenderTime(vtkRenderer* ren, vtkVolume* vol);
398  float RetrieveRenderTime(vtkRenderer* ren);
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;
431  unsigned short* ContiguousGradientNormal;
433 
435 
437 
439 
441 
442  unsigned short DiffuseShadingTable[4][65536 * 3];
443  unsigned short SpecularShadingTable[4][65536 * 3];
444 
447 
450 
453 
454  int ClipRayAgainstVolume(
455  double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
456 
457  int UpdateColorTable(vtkVolume* vol);
458  int UpdateGradients(vtkVolume* vol);
459  int UpdateShadingTable(vtkRenderer* ren, vtkVolume* vol);
460  void UpdateCroppingRegions();
461 
462  void ComputeGradients(vtkVolume* vol);
463 
464  int ClipRayAgainstClippingPlanes(
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 
500  void UpdateMinMaxVolume(vtkVolume* vol);
501  void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
502 
505 
507 
508  void ApplyFinalColorWindowLevel();
509 
510 private:
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 
522 inline 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 
598 inline 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 
633 inline 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 
646 inline 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 
742 VTK_ABI_NAMESPACE_END
743 #endif
int CroppingRegionFlags
Cropping variables, and a method for converting the world coordinate cropping region planes to voxel ...
void ShiftVectorDown(unsigned int in[3], unsigned int out[3])
vtkFixedPointVolumeRayCastMIPHelper * MIPHelper
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:39
vtkFixedPointVolumeRayCastCompositeShadeHelper * CompositeShadeHelper
vtkVolumeRayCastSpaceLeapingImageFilter * SpaceLeapFilter
Abstract class for a volume mapper.
encode a direction into a one or two byte value
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:30
A helper that generates composite images for the volume ray cast mapper.
void FixedPointIncrement(unsigned int position[3], unsigned int increment[3])
Use finite differences to estimate gradient.
Defines a 1D piecewise function.
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void *arg)
A class for performing multithreaded execution.
record modification and/or execution time
Definition: vtkTimeStamp.h:24
maintain a list of planes
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void *arg)
abstract specification for renderers
Definition: vtkRenderer.h:61
void GetUIntTripleFromPointer(unsigned int v[3], unsigned int *ptr)
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:49
int vtkIdType
Definition: vtkType.h:315
A helper that generates MIP images for the volume ray cast mapper.
helper class that draws the image to the screen
void Render(vtkRenderer *ren, vtkVolume *vol) override=0
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THIS METHOD OUTSIDE OF THE RENDERI...
#define VTKKW_FP_SCALE
int vtkTypeBool
Definition: vtkABI.h:64
Timer support and logging.
Definition: vtkTimerLog.h:84
window superclass for vtkRenderWindow
Definition: vtkWindow.h:27
vtkFixedPointVolumeRayCastCompositeGOHelper * CompositeGOHelper
a simple class to control print indentation
Definition: vtkIndent.h:28
float GetEstimatedRenderTime(vtkRenderer *ren, vtkVolume *vol)
Get an estimate of the rendering time for a given volume / renderer.
topologically and geometrically regular array of data
Definition: vtkImageData.h:42
void LookupDependentColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index[4], int components, unsigned char color[4])
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:44
Compute shading tables for encoded normals.
int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip)
A helper that generates composite images for the volume ray cast mapper.
void ReleaseGraphicsResources(vtkWindow *) override
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being...
A helper that generates composite images for the volume ray cast mapper.
A fixed point mapper for volumes.
Defines a transfer function for mapping a property to an RGB color value.
create a window for renderers to draw into
vtkFixedPointVolumeRayCastCompositeHelper * CompositeHelper
A helper that generates composite images for the volume ray cast mapper.
void LookupAndCombineIndependentColorsUC(unsigned short *colorTable[4], unsigned short *scalarOpacityTable[4], unsigned short index[4], float weights[4], int components, unsigned char color[4])
int CheckMinMaxVolumeFlag(unsigned int pos[3], int c)
void LookupColorUC(unsigned short *colorTable, unsigned short *scalarOpacityTable, unsigned short index, unsigned char color[4])
vtkFixedPointVolumeRayCastCompositeGOShadeHelper * CompositeGOShadeHelper
static vtkAlgorithm * New()
vtkRayCastImageDisplayHelper * ImageDisplayHelper
#define VTKKW_FP_SHIFT
vtkFiniteDifferenceGradientEstimator * GradientEstimator
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void GetFloatTripleFromPointer(float v[3], float *ptr)
helper class for a ray cast image