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 "vtkRenderingVolumeModule.h" // For export macro
#include "vtkObject.h"
 
class VTKRENDERINGVOLUME_EXPORT vtkFixedPointRayCastImage : public vtkObject
{
public:
  static vtkFixedPointRayCastImage *New();
  vtkTypeMacro(vtkFixedPointRayCastImage,vtkObject);
  virtual void PrintSelf(ostream& os, vtkIndent indent);
 
  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, int, 0, 1 );
  vtkGetMacro( UseZBuffer, int );
  vtkBooleanMacro( UseZBuffer, int );
 
  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();
 
  // 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
  int             UseZBuffer;
 
  // This is the actual ZBuffer data in floats
  float          *ZBuffer;
 
 
private:
  vtkFixedPointRayCastImage(const vtkFixedPointRayCastImage&);  // Not implemented.
  void operator=(const vtkFixedPointRayCastImage&);  // Not implemented.
};
 
#endif