dox/Rendering/vtkVolumeProperty.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkVolumeProperty.h,v $

  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 __vtkVolumeProperty_h
#define __vtkVolumeProperty_h

#include "vtkObject.h"

class vtkPiecewiseFunction;
class vtkTimeStamp;
class vtkColorTransferFunction;

class VTK_RENDERING_EXPORT vtkVolumeProperty : public vtkObject
{
public:
  static vtkVolumeProperty *New();
  vtkTypeRevisionMacro(vtkVolumeProperty,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
  void DeepCopy(vtkVolumeProperty *p);

  unsigned long GetMTime();
 

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


  vtkSetClampMacro( InterpolationType, int,
        VTK_NEAREST_INTERPOLATION, VTK_LINEAR_INTERPOLATION);
  vtkGetMacro(InterpolationType,int);
  void SetInterpolationTypeToNearest() 
        {this->SetInterpolationType(VTK_NEAREST_INTERPOLATION);};
  void SetInterpolationTypeToLinear() 
        {this->SetInterpolationType(VTK_LINEAR_INTERPOLATION);};
  const char *GetInterpolationTypeAsString(void);


  virtual void SetComponentWeight(int index, double value);
  virtual double GetComponentWeight(int index);


  void SetColor( int index, vtkPiecewiseFunction *function );
  void SetColor( vtkPiecewiseFunction *f ){this->SetColor(0,f);};
      

  void SetColor( int index, vtkColorTransferFunction *function );
  void SetColor( vtkColorTransferFunction *f ){this->SetColor(0,f);};
  

  int GetColorChannels( int index );
  int GetColorChannels(){return this->GetColorChannels(0);};
  

  vtkPiecewiseFunction *GetGrayTransferFunction( int index );
  vtkPiecewiseFunction *GetGrayTransferFunction()
    {return this->GetGrayTransferFunction(0);};
  

  vtkColorTransferFunction *GetRGBTransferFunction( int index );
  vtkColorTransferFunction *GetRGBTransferFunction()
    {return this->GetRGBTransferFunction(0);};
  

  void SetScalarOpacity( int index, vtkPiecewiseFunction *function );
  void SetScalarOpacity( vtkPiecewiseFunction *f )
    {this->SetScalarOpacity(0,f);};
  

  vtkPiecewiseFunction *GetScalarOpacity( int index );
  vtkPiecewiseFunction *GetScalarOpacity()
    {return this->GetScalarOpacity(0);};
      

  void SetScalarOpacityUnitDistance( int index, double distance );
  void SetScalarOpacityUnitDistance( double distance )
    {this->SetScalarOpacityUnitDistance( 0, distance );}
  double GetScalarOpacityUnitDistance( int index );
  double GetScalarOpacityUnitDistance()
    {return this->GetScalarOpacityUnitDistance(0);}
  
  

  void SetGradientOpacity( int index, vtkPiecewiseFunction *function );
  void SetGradientOpacity( vtkPiecewiseFunction *function )
    {this->SetGradientOpacity(0,function);}
  

  vtkPiecewiseFunction *GetGradientOpacity( int index );
  vtkPiecewiseFunction *GetGradientOpacity()
    {return this->GetGradientOpacity( 0 );}


  virtual void SetDisableGradientOpacity( int index, int value );
  virtual void SetDisableGradientOpacity( int value )
    { this->SetDisableGradientOpacity(0, value); }
  virtual void DisableGradientOpacityOn( int index )
    { this->SetDisableGradientOpacity(index, 1); }
  virtual void DisableGradientOpacityOn()
    { this->DisableGradientOpacityOn(0); }
  virtual void DisableGradientOpacityOff( int index )
    { this->SetDisableGradientOpacity(index, 0); }
  virtual void DisableGradientOpacityOff()
    { this->DisableGradientOpacityOff(0); }
  virtual int GetDisableGradientOpacity( int index );
  virtual int GetDisableGradientOpacity()
    { return this->GetDisableGradientOpacity(0); }
  vtkPiecewiseFunction *GetStoredGradientOpacity( int index );
  vtkPiecewiseFunction *GetStoredGradientOpacity()
    {return this->GetStoredGradientOpacity( 0 );}


  void SetShade( int index, int value );
  void SetShade( int value ) {this->SetShade(0,value);}
  int GetShade( int index );
  int GetShade() {return this->GetShade(0);}
  void ShadeOn( int index );
  void ShadeOn() {this->ShadeOn(0);}
  void ShadeOff( int index );
  void ShadeOff() {this->ShadeOff(0);}


  void SetAmbient( int index, double value );
  void SetAmbient( double value ) {this->SetAmbient( 0, value );}
  double GetAmbient( int index );
  double GetAmbient() {return this->GetAmbient(0);}


  void SetDiffuse( int index, double value );
  void SetDiffuse( double value ) {this->SetDiffuse( 0, value );}
  double GetDiffuse( int index );
  double GetDiffuse() {return this->GetDiffuse(0);}


  void SetSpecular( int index, double value );
  void SetSpecular( double value ) {this->SetSpecular( 0, value );}
  double GetSpecular( int index );
  double GetSpecular() {return this->GetSpecular(0);}


  void SetSpecularPower( int index, double value );
  void SetSpecularPower( double value ) {this->SetSpecularPower( 0, value );}
  double GetSpecularPower( int index );
  double GetSpecularPower() {return this->GetSpecularPower(0);}

  //BTX
  void UpdateMTimes(); 


  vtkTimeStamp GetGradientOpacityMTime( int index );
  vtkTimeStamp GetGradientOpacityMTime()
    { return this->GetGradientOpacityMTime(0); }  
      

  vtkTimeStamp GetScalarOpacityMTime( int index );
  vtkTimeStamp GetScalarOpacityMTime()
    { return this->GetScalarOpacityMTime(0); }  


  vtkTimeStamp GetRGBTransferFunctionMTime( int index );
  vtkTimeStamp GetRGBTransferFunctionMTime()
    { return this->GetRGBTransferFunctionMTime(0); }  


  vtkTimeStamp GetGrayTransferFunctionMTime( int index );
  vtkTimeStamp GetGrayTransferFunctionMTime()
    { return this->GetGrayTransferFunctionMTime(0); }  
  //ETX

protected:
  vtkVolumeProperty();
  ~vtkVolumeProperty();

  int                           IndependentComponents;
  double                        ComponentWeight[VTK_MAX_VRCOMP];

  int                           InterpolationType;

  int                           ColorChannels[VTK_MAX_VRCOMP];

  vtkPiecewiseFunction          *GrayTransferFunction[VTK_MAX_VRCOMP];
  vtkTimeStamp                  GrayTransferFunctionMTime[VTK_MAX_VRCOMP];

  vtkColorTransferFunction      *RGBTransferFunction[VTK_MAX_VRCOMP];
  vtkTimeStamp                  RGBTransferFunctionMTime[VTK_MAX_VRCOMP];

  vtkPiecewiseFunction          *ScalarOpacity[VTK_MAX_VRCOMP];
  vtkTimeStamp                  ScalarOpacityMTime[VTK_MAX_VRCOMP];
  double                        ScalarOpacityUnitDistance[VTK_MAX_VRCOMP];
  
  vtkPiecewiseFunction          *GradientOpacity[VTK_MAX_VRCOMP];
  vtkTimeStamp                  GradientOpacityMTime[VTK_MAX_VRCOMP];
  vtkPiecewiseFunction          *DefaultGradientOpacity[VTK_MAX_VRCOMP];
  int                           DisableGradientOpacity[VTK_MAX_VRCOMP];

  int                           Shade[VTK_MAX_VRCOMP];
  double                        Ambient[VTK_MAX_VRCOMP];
  double                        Diffuse[VTK_MAX_VRCOMP];
  double                        Specular[VTK_MAX_VRCOMP];
  double                        SpecularPower[VTK_MAX_VRCOMP];

  virtual void                  CreateDefaultGradientOpacity(int index);

private:
  vtkVolumeProperty(const vtkVolumeProperty&);  // Not implemented.
  void operator=(const vtkVolumeProperty&);  // Not implemented.
};

inline const char *vtkVolumeProperty::GetInterpolationTypeAsString(void)
{
  if( this->InterpolationType == VTK_NEAREST_INTERPOLATION )
    {
    return "Nearest Neighbor";
    }
  else if( this->InterpolationType == VTK_LINEAR_INTERPOLATION )
    {
    return "Linear";
    }
  else
    {
    return "Unknown";
    }
}

#endif

---