Rendering/vtkVolumeMapper.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkVolumeMapper.h,v $
  Language:  C++

  Copyright (c) 1993-2002 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 __vtkVolumeMapper_h
#define __vtkVolumeMapper_h

#include "vtkAbstractMapper3D.h"

class vtkRenderer;
class vtkVolume;
class vtkImageData;

#define VTK_CROP_SUBVOLUME              0x0002000
#define VTK_CROP_FENCE                  0x2ebfeba
#define VTK_CROP_INVERTED_FENCE         0x5140145
#define VTK_CROP_CROSS                  0x0417410
#define VTK_CROP_INVERTED_CROSS         0x7be8bef

class vtkWindow;
class vtkImageClip;

class VTK_RENDERING_EXPORT vtkVolumeMapper : public vtkAbstractMapper3D
{
public:
  vtkTypeRevisionMacro(vtkVolumeMapper,vtkAbstractMapper3D);
  void PrintSelf( ostream& os, vtkIndent indent );

  virtual void Update();


  virtual void SetInput( vtkImageData * );
  vtkImageData *GetInput();


  vtkSetClampMacro( IndependentComponents, int, 0, 1 );
  vtkGetMacro( IndependentComponents, int );
  vtkBooleanMacro( IndependentComponents, int );


  vtkSetClampMacro( ComponentBlendMode, int, 
                    vtkVolumeMapper::ComponentBlendAdd,
                    vtkVolumeMapper::ComponentBlendMaxOpacity );
  vtkGetMacro( ComponentBlendMode, int );
  void SetComponentBlendModeToAdd() 
    {this->SetComponentBlendMode(vtkVolumeMapper::ComponentBlendAdd);};
  void SetComponentBlendModeToMaxOpacity() 
    {this->SetComponentBlendMode(vtkVolumeMapper::ComponentBlendMaxOpacity);};
  
      
  

  vtkSetClampMacro(Cropping,int,0,1);
  vtkGetMacro(Cropping,int);
  vtkBooleanMacro(Cropping,int);


  vtkSetVector6Macro( CroppingRegionPlanes, float );
  vtkGetVectorMacro(  CroppingRegionPlanes, float, 6 );


  vtkGetVectorMacro( VoxelCroppingRegionPlanes, float, 6 );
  

  vtkSetClampMacro( CroppingRegionFlags, int, 0x0, 0x7ffffff );
  vtkGetMacro( CroppingRegionFlags, int );
  void SetCroppingRegionFlagsToSubVolume() 
    {this->SetCroppingRegionFlags( VTK_CROP_SUBVOLUME );};
  void SetCroppingRegionFlagsToFence() 
    {this->SetCroppingRegionFlags( VTK_CROP_FENCE );};
  void SetCroppingRegionFlagsToInvertedFence() 
    {this->SetCroppingRegionFlags( VTK_CROP_INVERTED_FENCE );};
  void SetCroppingRegionFlagsToCross() 
    {this->SetCroppingRegionFlags( VTK_CROP_CROSS );};
  void SetCroppingRegionFlagsToInvertedCross() 
    {this->SetCroppingRegionFlags( VTK_CROP_INVERTED_CROSS );};


  virtual float *GetBounds();
  virtual void GetBounds(float bounds[6])
    { this->vtkAbstractMapper3D::GetBounds(bounds); };


//BTX

  virtual float GetGradientMagnitudeScale() {return 1.0;};
  virtual float GetGradientMagnitudeBias()  {return 0.0;};
  virtual float GetGradientMagnitudeScale(int) {return 1.0;};
  virtual float GetGradientMagnitudeBias(int)  {return 0.0;};
  

  virtual void Render(vtkRenderer *ren, vtkVolume *vol)=0;

  virtual void ReleaseGraphicsResources(vtkWindow *) {};
  
  enum ComponentBlendModes {
    ComponentBlendAdd = 0,
    ComponentBlendMaxOpacity
  };
  
//ETX


  virtual void SetUseImageClipper(int);
  vtkGetMacro(UseImageClipper, int );
  vtkBooleanMacro(UseImageClipper, int );
  
protected:
  vtkVolumeMapper();
  ~vtkVolumeMapper();

  // Cropping variables, and a method for converting the world
  // coordinate cropping region planes to voxel coordinates
  int                  Cropping;
  float                CroppingRegionPlanes[6];
  float                VoxelCroppingRegionPlanes[6];
  int                  CroppingRegionFlags;
  void ConvertCroppingRegionPlanesToVoxels();
  
  // Flag for independent or dependent components
  int                  IndependentComponents;
  
  // How should we combine the components
  int                  ComponentBlendMode;
  
  vtkTimeStamp         BuildTime;

  // Clipper used on input to ensure it is the right size
  int UseImageClipper;
  vtkImageClip        *ImageClipper;
  
  
private:
  vtkVolumeMapper(const vtkVolumeMapper&);  // Not implemented.
  void operator=(const vtkVolumeMapper&);  // Not implemented.
};


#endif

Generated on Thu Jan 22 15:46:59 2004 for VTK by Doxygen 1.3.4