vtkUnstructuredGridVolumeRayCastMapper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause

 
#ifndef vtkUnstructuredGridVolumeRayCastMapper_h
#define vtkUnstructuredGridVolumeRayCastMapper_h
 
#include "vtkRenderingVolumeModule.h" // For export macro
#include "vtkUnstructuredGridVolumeMapper.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDoubleArray;
class vtkIdList;
class vtkMultiThreader;
class vtkRayCastImageDisplayHelper;
class vtkRenderer;
class vtkTimerLog;
class vtkUnstructuredGridVolumeRayCastFunction;
class vtkUnstructuredGridVolumeRayCastIterator;
class vtkUnstructuredGridVolumeRayIntegrator;
class vtkVolume;
 
class VTKRENDERINGVOLUME_EXPORT vtkUnstructuredGridVolumeRayCastMapper
  : public vtkUnstructuredGridVolumeMapper
{
public:
  static vtkUnstructuredGridVolumeRayCastMapper* New();
  vtkTypeMacro(vtkUnstructuredGridVolumeRayCastMapper, vtkUnstructuredGridVolumeMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
  vtkGetMacro(ImageSampleDistance, float);


  vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
  vtkGetMacro(MinimumImageSampleDistance, float);


  vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
  vtkGetMacro(MaximumImageSampleDistance, float);


  vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
  vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
  vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);


  vtkSetMacro(NumberOfThreads, int);
  vtkGetMacro(NumberOfThreads, int);


  vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
  vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
  vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);


  virtual void SetRayCastFunction(vtkUnstructuredGridVolumeRayCastFunction* f);
  vtkGetObjectMacro(RayCastFunction, vtkUnstructuredGridVolumeRayCastFunction);


  virtual void SetRayIntegrator(vtkUnstructuredGridVolumeRayIntegrator* ri);
  vtkGetObjectMacro(RayIntegrator, vtkUnstructuredGridVolumeRayIntegrator);

  void Render(vtkRenderer*, vtkVolume*) override;

  void ReleaseGraphicsResources(vtkWindow*) override;
 
  vtkGetVectorMacro(ImageInUseSize, int, 2);
  vtkGetVectorMacro(ImageOrigin, int, 2);
  vtkGetVectorMacro(ImageViewportSize, int, 2);
 
  void CastRays(int threadID, int threadCount);
 
protected:
  vtkUnstructuredGridVolumeRayCastMapper();
  ~vtkUnstructuredGridVolumeRayCastMapper() override;
 
  float ImageSampleDistance;
  float MinimumImageSampleDistance;
  float MaximumImageSampleDistance;
  vtkTypeBool AutoAdjustSampleDistances;
 
  vtkMultiThreader* Threader;
  int NumberOfThreads;
 
  vtkRayCastImageDisplayHelper* ImageDisplayHelper;
 
  // This is how big the image would be if it covered the entire viewport
  int ImageViewportSize[2];
 
  // This is how big the allocated memory for image is. This may be bigger
  // or smaller than ImageFullSize - it will be bigger if necessary to
  // ensure a power of 2, it will be smaller if the volume only covers a
  // small region of the viewport
  int ImageMemorySize[2];
 
  // This is the size of subregion in ImageSize image that we are using for
  // the current image. Since ImageSize is a power of 2, there is likely
  // wasted space in it. This number will be used for things such as clearing
  // the image if necessary.
  int ImageInUseSize[2];
 
  // This is the location in ImageFullSize image where our ImageSize image
  // is located.
  int ImageOrigin[2];
 
  // This is the allocated image
  unsigned char* Image;
 
  float* RenderTimeTable;
  vtkVolume** RenderVolumeTable;
  vtkRenderer** RenderRendererTable;
  int RenderTableSize;
  int RenderTableEntries;
 
  void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
  float RetrieveRenderTime(vtkRenderer* ren, vtkVolume* vol);
 
  vtkTypeBool IntermixIntersectingGeometry;
 
  float* ZBuffer;
  int ZBufferSize[2];
  int ZBufferOrigin[2];
 
  // Get the ZBuffer value corresponding to location (x,y) where (x,y)
  // are indexing into the ImageInUse image. This must be converted to
  // the zbuffer image coordinates. Nearest neighbor value is returned.
  double GetZBufferValue(int x, int y);
 
  double GetMinimumBoundsDepth(vtkRenderer* ren, vtkVolume* vol);
 
  vtkUnstructuredGridVolumeRayCastFunction* RayCastFunction;
  vtkUnstructuredGridVolumeRayCastIterator** RayCastIterators;
  vtkUnstructuredGridVolumeRayIntegrator* RayIntegrator;
  vtkUnstructuredGridVolumeRayIntegrator* RealRayIntegrator;
 
  vtkIdList** IntersectedCellsBuffer;
  vtkDoubleArray** IntersectionLengthsBuffer;
  vtkDataArray** NearIntersectionsBuffer;
  vtkDataArray** FarIntersectionsBuffer;
 
  vtkVolume* CurrentVolume;
  vtkRenderer* CurrentRenderer;
 
  vtkDataArray* Scalars;
  int CellScalars;
 
private:
  vtkUnstructuredGridVolumeRayCastMapper(const vtkUnstructuredGridVolumeRayCastMapper&) = delete;
  void operator=(const vtkUnstructuredGridVolumeRayCastMapper&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif