vtkFixedPointRayCastImage.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkFixedPointRayCastImage.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef vtkFixedPointRayCastImage_h
#define vtkFixedPointRayCastImage_h
 
#include "vtkObject.h"
#include "vtkRenderingVolumeModule.h" // For export macro
 
class VTKRENDERINGVOLUME_EXPORT vtkFixedPointRayCastImage : public vtkObject
{
public:
  static vtkFixedPointRayCastImage* New();
  vtkTypeMacro(vtkFixedPointRayCastImage, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  unsigned short* GetImage() { return this->Image; }
 
 
  vtkSetVector2Macro(ImageViewportSize, int);
  vtkGetVectorMacro(ImageViewportSize, int, 2);
 
 
  vtkSetVector2Macro(ImageMemorySize, int);
  vtkGetVectorMacro(ImageMemorySize, int, 2);
 
 
  vtkSetVector2Macro(ImageInUseSize, int);
  vtkGetVectorMacro(ImageInUseSize, int, 2);
 
 
  vtkSetVector2Macro(ImageOrigin, int);
  vtkGetVectorMacro(ImageOrigin, int, 2);
 
 
  vtkSetMacro(ImageSampleDistance, float);
  vtkGetMacro(ImageSampleDistance, float);
 
  void AllocateImage();
 
  void ClearImage();
 
 
  vtkSetVector2Macro(ZBufferSize, int);
  vtkGetVectorMacro(ZBufferSize, int, 2);
 
 
  vtkSetVector2Macro(ZBufferOrigin, int);
  vtkGetVectorMacro(ZBufferOrigin, int, 2);
 
 
  vtkSetClampMacro(UseZBuffer, vtkTypeBool, 0, 1);
  vtkGetMacro(UseZBuffer, vtkTypeBool);
  vtkBooleanMacro(UseZBuffer, vtkTypeBool);
 
  float GetZBufferValue(int x, int y);
 
  float* GetZBuffer() { return this->ZBuffer; }
 
  // Descipriotn:
  // Allocate the space for the ZBuffer according to the size.
  void AllocateZBuffer();
 
protected:
  vtkFixedPointRayCastImage();
  ~vtkFixedPointRayCastImage() override;
 
  // 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 a copy of the ImageSampleDistance from the mapper - copied here
  // in order to share among all mappers contributing to this image
  float ImageSampleDistance;
 
  // This is the allocated image
  unsigned short* Image;
 
  // This is the size of the zbuffer in pixels
  int ZBufferSize[2];
 
  // This is the size of the memory for the zbuffer - this can be
  // bigger than the size of the zbuffer since we will allocate enough
  // space for the whole viewport to avoid re-allocating over and over
  int ZBufferMemorySize;
 
  // This is the distance from the lower left corner of the viewport
  // where the ZBuffer starts
  int ZBufferOrigin[2];
 
  // This is the flag that indicate whether the ZBuffer is in use
  vtkTypeBool UseZBuffer;
 
  // This is the actual ZBuffer data in floats
  float* ZBuffer;
 
private:
  vtkFixedPointRayCastImage(const vtkFixedPointRayCastImage&) = delete;
  void operator=(const vtkFixedPointRayCastImage&) = delete;
};
 
#endif