vtkUnstructuredGridVolumeZSweepMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkUnstructuredGridVolumeZSweepMapper.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 vtkUnstructuredGridVolumeZSweepMapper_h
#define vtkUnstructuredGridVolumeZSweepMapper_h
 
#include "vtkRenderingVolumeModule.h" // For export macro
#include "vtkUnstructuredGridVolumeMapper.h"
 
class vtkRenderer;
class vtkVolume;
class vtkRayCastImageDisplayHelper;
class vtkCell;
class vtkGenericCell;
class vtkIdList;
class vtkPriorityQueue;
class vtkTransform;
class vtkMatrix4x4;
class vtkVolumeProperty;
class vtkDoubleArray;
class vtkUnstructuredGridVolumeRayIntegrator;
class vtkRenderWindow;
 
// Internal classes
namespace vtkUnstructuredGridVolumeZSweepMapperNamespace
{
class vtkScreenEdge;
class vtkSpan;
class vtkPixelListFrame;
class vtkUseSet;
class vtkVertices;
class vtkSimpleScreenEdge;
class vtkDoubleScreenEdge;
class vtkVertexEntry;
class vtkPixelListEntryMemory;
};
 
class VTKRENDERINGVOLUME_EXPORT vtkUnstructuredGridVolumeZSweepMapper
  : public vtkUnstructuredGridVolumeMapper
{
public:
  vtkTypeMacro(vtkUnstructuredGridVolumeZSweepMapper, vtkUnstructuredGridVolumeMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkUnstructuredGridVolumeZSweepMapper* New();
 
 
  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);
 
 
  vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
  vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
  vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);
 
  int GetMaxPixelListSize();
 
  void SetMaxPixelListSize(int size);
 
 
  virtual void SetRayIntegrator(vtkUnstructuredGridVolumeRayIntegrator* ri);
  vtkGetObjectMacro(RayIntegrator, vtkUnstructuredGridVolumeRayIntegrator);
 
  void Render(vtkRenderer* ren, vtkVolume* vol) override;
 
  vtkGetVectorMacro(ImageInUseSize, int, 2);
  vtkGetVectorMacro(ImageOrigin, int, 2);
  vtkGetVectorMacro(ImageViewportSize, int, 2);
 
protected:
  vtkUnstructuredGridVolumeZSweepMapper();
  ~vtkUnstructuredGridVolumeZSweepMapper() override;
 
  void BuildUseSets();
 
  int ReorderTriangle(vtkIdType v[3], vtkIdType w[3]);
 
  void ProjectAndSortVertices(vtkRenderer* ren, vtkVolume* vol);
 
  void CreateAndCleanPixelList();
 
  void MainLoop(vtkRenderWindow* renWin);
 
  void CompositeFunction(double zTarget);
 
  unsigned char ColorComponentRealToByte(float color);
 
  void RasterizeFace(vtkIdType faceIds[3], int externalSide);
 
  void RasterizeTriangle(vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkVertexEntry* ve0,
    vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkVertexEntry* ve1,
    vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkVertexEntry* ve2, bool externalFace);
 
  void RasterizeSpan(int y, vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkScreenEdge* left,
    vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkScreenEdge* right, bool exitFace);
 
  void RasterizeLine(vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkVertexEntry* v0,
    vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkVertexEntry* v1, bool exitFace);
 
  void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
 
  float RetrieveRenderTime(vtkRenderer* ren, vtkVolume* vol);
 
  double GetZBufferValue(int x, int y);
 
  double GetMinimumBoundsDepth(vtkRenderer* ren, vtkVolume* vol);
 
  void AllocateUseSet(vtkIdType size);
 
  void AllocateVertices(vtkIdType size);
 
  void SavePixelListFrame();
 
  int MaxPixelListSize;
 
  float ImageSampleDistance;
  float MinimumImageSampleDistance;
  float MaximumImageSampleDistance;
  vtkTypeBool AutoAdjustSampleDistances;
 
  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;
 
  // This is the accumulating double RGBA image
  float* RealRGBAImage;
 
  float* RenderTimeTable;
  vtkVolume** RenderVolumeTable;
  vtkRenderer** RenderRendererTable;
  int RenderTableSize;
  int RenderTableEntries;
 
  vtkTypeBool IntermixIntersectingGeometry;
 
  float* ZBuffer;
  int ZBufferSize[2];
  int ZBufferOrigin[2];
 
  vtkDataArray* Scalars;
  int CellScalars;
 
  // if use CellScalars, we need to keep track of the
  // values on each side of the face and figure out
  // if the face is used by two cells (twosided) or one cell.
  double FaceScalars[2];
  int FaceSide;
 
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkSpan* Span;
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkPixelListFrame* PixelListFrame;
 
  // Used by BuildUseSets().
  vtkGenericCell* Cell;
 
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkUseSet* UseSet;
 
  vtkPriorityQueue* EventList;
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkVertices* Vertices;
 
  vtkTransform* PerspectiveTransform;
  vtkMatrix4x4* PerspectiveMatrix;
 
  // Used by the main loop
  int MaxPixelListSizeReached;
  int XBounds[2];
  int YBounds[2];
 
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkSimpleScreenEdge* SimpleEdge;
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkDoubleScreenEdge* DoubleEdge;
 
  vtkUnstructuredGridVolumeRayIntegrator* RayIntegrator;
  vtkUnstructuredGridVolumeRayIntegrator* RealRayIntegrator;
 
  vtkTimeStamp SavedTriangleListMTime;
 
  // Used during compositing
  vtkDoubleArray* IntersectionLengths;
  vtkDoubleArray* NearIntersections;
  vtkDoubleArray* FarIntersections;
 
  // Benchmark
  vtkIdType MaxRecordedPixelListSize;
 
  vtkUnstructuredGridVolumeZSweepMapperNamespace::vtkPixelListEntryMemory* MemoryManager;
 
private:
  vtkUnstructuredGridVolumeZSweepMapper(const vtkUnstructuredGridVolumeZSweepMapper&) = delete;
  void operator=(const vtkUnstructuredGridVolumeZSweepMapper&) = delete;
};
 
#endif