vtkEncodedGradientEstimator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkEncodedGradientEstimator.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 vtkEncodedGradientEstimator_h
#define vtkEncodedGradientEstimator_h
 
#include "vtkRenderingVolumeModule.h" // For export macro
#include "vtkObject.h"
 
class vtkImageData;
class vtkDirectionEncoder;
class vtkMultiThreader;
 
class VTKRENDERINGVOLUME_EXPORT vtkEncodedGradientEstimator : public vtkObject
{
public:
  vtkTypeMacro(vtkEncodedGradientEstimator,vtkObject);
  void PrintSelf( ostream& os, vtkIndent indent );
 
 
  virtual void SetInputData(vtkImageData*);
  vtkGetObjectMacro( InputData, vtkImageData );
 
 
  vtkSetMacro( GradientMagnitudeScale, float );
  vtkGetMacro( GradientMagnitudeScale, float );
  vtkSetMacro( GradientMagnitudeBias, float );
  vtkGetMacro( GradientMagnitudeBias, float );
 
 
  vtkSetClampMacro( BoundsClip, int, 0, 1 );
  vtkGetMacro( BoundsClip, int );
  vtkBooleanMacro( BoundsClip, int );
 
 
  vtkSetVector6Macro( Bounds, int );
  vtkGetVectorMacro(  Bounds, int, 6 );
 
  void  Update( void );
 
  unsigned short  *GetEncodedNormals( void );
 
 
  int   GetEncodedNormalIndex( vtkIdType xyz_index );
  int   GetEncodedNormalIndex( int x_index, int y_index, int z_index );
 
  unsigned char *GetGradientMagnitudes(void);
 
 
  vtkSetClampMacro( NumberOfThreads, int, 1, VTK_MAX_THREADS );
  vtkGetMacro( NumberOfThreads, int );
 
 
  void SetDirectionEncoder( vtkDirectionEncoder *direnc );
  vtkGetObjectMacro( DirectionEncoder, vtkDirectionEncoder );
 
 
  vtkSetMacro( ComputeGradientMagnitudes, int );
  vtkGetMacro( ComputeGradientMagnitudes, int );
  vtkBooleanMacro( ComputeGradientMagnitudes, int );
 
 
  vtkSetMacro( CylinderClip, int );
  vtkGetMacro( CylinderClip, int );
  vtkBooleanMacro( CylinderClip, int );
 
 
  vtkGetMacro( LastUpdateTimeInSeconds, float );
  vtkGetMacro( LastUpdateTimeInCPUSeconds, float );
 
  vtkGetMacro( UseCylinderClip, int );
  int *GetCircleLimits() { return this->CircleLimits; };
 
 
  void SetZeroNormalThreshold( float v );
  vtkGetMacro( ZeroNormalThreshold, float );
 
 
  vtkSetClampMacro( ZeroPad, int, 0, 1 );
  vtkGetMacro( ZeroPad, int );
  vtkBooleanMacro( ZeroPad, int );
 
 
  // These variables should be protected but are being
  // made public to be accessible to the templated function.
  // We used to have the templated function as a friend, but
  // this does not work with all compilers
 
  // The input scalar data on which the normals are computed
  vtkImageData         *InputData;
 
  // The encoded normals (2 bytes) and the size of the encoded normals
  unsigned short        *EncodedNormals;
  int                   EncodedNormalsSize[3];
 
  // The magnitude of the gradient array and the size of this array
  unsigned char         *GradientMagnitudes;
 
  // The time at which the normals were last built
  vtkTimeStamp          BuildTime;
 
//BTX
  vtkGetVectorMacro( InputSize, int, 3 );
  vtkGetVectorMacro( InputAspect, float, 3 );
//ETX
 
protected:
  vtkEncodedGradientEstimator();
  ~vtkEncodedGradientEstimator();
 
  virtual void ReportReferences(vtkGarbageCollector*);
 
  // The number of threads to use when encoding normals
  int                        NumberOfThreads;
 
  vtkMultiThreader           *Threader;
 
  vtkDirectionEncoder        *DirectionEncoder;
 
  virtual void               UpdateNormals( void ) = 0;
 
  float                      GradientMagnitudeScale;
  float                      GradientMagnitudeBias;
 
  float                      LastUpdateTimeInSeconds;
  float                      LastUpdateTimeInCPUSeconds;
 
  float                      ZeroNormalThreshold;
 
  int                        CylinderClip;
  int                        *CircleLimits;
  int                        CircleLimitsSize;
  int                        UseCylinderClip;
  void                       ComputeCircleLimits( int size );
 
  int                        BoundsClip;
  int                        Bounds[6];
 
  int                        InputSize[3];
  float                      InputAspect[3];
 
  int                        ComputeGradientMagnitudes;
 
  int                        ZeroPad;
 
private:
  vtkEncodedGradientEstimator(const vtkEncodedGradientEstimator&);  // Not implemented.
  void operator=(const vtkEncodedGradientEstimator&);  // Not implemented.
};
 
 
#endif