vtkGenericGlyph3DFilter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGenericGlyph3DFilter.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 vtkGenericGlyph3DFilter_h
#define vtkGenericGlyph3DFilter_h
 
#include "vtkFiltersGenericModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
#define VTK_SCALE_BY_SCALAR 0
#define VTK_SCALE_BY_VECTOR 1
#define VTK_SCALE_BY_VECTORCOMPONENTS 2
#define VTK_DATA_SCALING_OFF 3
 
#define VTK_COLOR_BY_SCALE  0
#define VTK_COLOR_BY_SCALAR 1
#define VTK_COLOR_BY_VECTOR 2
 
#define VTK_USE_VECTOR 0
#define VTK_USE_NORMAL 1
#define VTK_VECTOR_ROTATION_OFF 2
 
#define VTK_INDEXING_OFF 0
#define VTK_INDEXING_BY_SCALAR 1
#define VTK_INDEXING_BY_VECTOR 2
 
class VTKFILTERSGENERIC_EXPORT vtkGenericGlyph3DFilter : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkGenericGlyph3DFilter,vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  static vtkGenericGlyph3DFilter *New();
 
  void SetSourceData(vtkPolyData *pd) {this->SetSourceData(0,pd);};
 
  void SetSourceData(int id, vtkPolyData *pd);
 
  vtkPolyData *GetSource(int id=0);
 
 
  vtkSetMacro(Scaling,int);
  vtkBooleanMacro(Scaling,int);
  vtkGetMacro(Scaling,int);
 
 
  vtkSetMacro(ScaleMode,int);
  vtkGetMacro(ScaleMode,int);
  void SetScaleModeToScaleByScalar()
    {this->SetScaleMode(VTK_SCALE_BY_SCALAR);};
  void SetScaleModeToScaleByVector()
    {this->SetScaleMode(VTK_SCALE_BY_VECTOR);};
  void SetScaleModeToScaleByVectorComponents()
    {this->SetScaleMode(VTK_SCALE_BY_VECTORCOMPONENTS);};
  void SetScaleModeToDataScalingOff()
    {this->SetScaleMode(VTK_DATA_SCALING_OFF);};
  const char *GetScaleModeAsString();
 
 
  vtkSetMacro(ColorMode,int);
  vtkGetMacro(ColorMode,int);
  void SetColorModeToColorByScale()
    {this->SetColorMode(VTK_COLOR_BY_SCALE);};
  void SetColorModeToColorByScalar()
    {this->SetColorMode(VTK_COLOR_BY_SCALAR);};
  void SetColorModeToColorByVector()
    {this->SetColorMode(VTK_COLOR_BY_VECTOR);};
  const char *GetColorModeAsString();
 
 
  vtkSetMacro(ScaleFactor,double);
  vtkGetMacro(ScaleFactor,double);
 
 
  vtkSetVector2Macro(Range,double);
  vtkGetVectorMacro(Range,double,2);
 
 
  vtkSetMacro(Orient,int);
  vtkBooleanMacro(Orient,int);
  vtkGetMacro(Orient,int);
 
 
  vtkSetMacro(Clamping,int);
  vtkBooleanMacro(Clamping,int);
  vtkGetMacro(Clamping,int);
 
 
  vtkSetMacro(VectorMode,int);
  vtkGetMacro(VectorMode,int);
  void SetVectorModeToUseVector() {this->SetVectorMode(VTK_USE_VECTOR);};
  void SetVectorModeToUseNormal() {this->SetVectorMode(VTK_USE_NORMAL);};
  void SetVectorModeToVectorRotationOff()
    {this->SetVectorMode(VTK_VECTOR_ROTATION_OFF);};
  const char *GetVectorModeAsString();
 
 
  vtkSetMacro(IndexMode,int);
  vtkGetMacro(IndexMode,int);
  void SetIndexModeToScalar() {this->SetIndexMode(VTK_INDEXING_BY_SCALAR);};
  void SetIndexModeToVector() {this->SetIndexMode(VTK_INDEXING_BY_VECTOR);};
  void SetIndexModeToOff() {this->SetIndexMode(VTK_INDEXING_OFF);};
  const char *GetIndexModeAsString();
 
 
  vtkSetMacro(GeneratePointIds,int);
  vtkGetMacro(GeneratePointIds,int);
  vtkBooleanMacro(GeneratePointIds,int);
 
 
  vtkSetStringMacro(PointIdsName);
  vtkGetStringMacro(PointIdsName);
 
 
  vtkGetStringMacro(InputScalarsSelection);
  void SelectInputScalars(const char *fieldName)
    {this->SetInputScalarsSelection(fieldName);}
 
 
  vtkGetStringMacro(InputVectorsSelection);
  void SelectInputVectors(const char *fieldName)
    {this->SetInputVectorsSelection(fieldName);}
 
 
  vtkGetStringMacro(InputNormalsSelection);
  void SelectInputNormals(const char *fieldName)
    {this->SetInputNormalsSelection(fieldName);}
 
protected:
  vtkGenericGlyph3DFilter();
  ~vtkGenericGlyph3DFilter();
 
  int FillInputPortInformation(int, vtkInformation*);
 
  int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
  int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
  int RequestUpdateExtent(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
  vtkPolyData **Source; // Geometry to copy to each point
  int Scaling; // Determine whether scaling of geometry is performed
  int ScaleMode; // Scale by scalar value or vector magnitude
  int ColorMode; // new scalars based on scale, scalar or vector
  double ScaleFactor; // Scale factor to use to scale geometry
  double Range[2]; // Range to use to perform scalar scaling
  int Orient; // boolean controls whether to "orient" data
  int VectorMode; // Orient/scale via normal or via vector data
  int Clamping; // whether to clamp scale factor
  int IndexMode; // what to use to index into glyph table
  int GeneratePointIds; // produce input points ids for each output point
  char *PointIdsName;
 
  char *InputScalarsSelection;
  char *InputVectorsSelection;
  char *InputNormalsSelection;
  vtkSetStringMacro(InputScalarsSelection);
  vtkSetStringMacro(InputVectorsSelection);
  vtkSetStringMacro(InputNormalsSelection);
 
private:
  vtkGenericGlyph3DFilter(const vtkGenericGlyph3DFilter&);  // Not implemented.
  void operator=(const vtkGenericGlyph3DFilter&);  // Not implemented.
};
 
 
inline const char *vtkGenericGlyph3DFilter::GetScaleModeAsString()
{
  if ( this->ScaleMode == VTK_SCALE_BY_SCALAR )
    {
    return "ScaleByScalar";
    }
  else if ( this->ScaleMode == VTK_SCALE_BY_VECTOR )
    {
    return "ScaleByVector";
    }
  else
    {
    return "DataScalingOff";
    }
}
 
 
inline const char *vtkGenericGlyph3DFilter::GetColorModeAsString()
{
  if ( this->ColorMode == VTK_COLOR_BY_SCALAR )
    {
    return "ColorByScalar";
    }
  else if ( this->ColorMode == VTK_COLOR_BY_VECTOR )
    {
    return "ColorByVector";
    }
  else
    {
    return "ColorByScale";
    }
}
 
 
inline const char *vtkGenericGlyph3DFilter::GetVectorModeAsString()
{
  if ( this->VectorMode == VTK_USE_VECTOR)
    {
    return "UseVector";
    }
  else if ( this->VectorMode == VTK_USE_NORMAL)
    {
    return "UseNormal";
    }
  else
    {
    return "VectorRotationOff";
    }
}
 
 
inline const char *vtkGenericGlyph3DFilter::GetIndexModeAsString()
{
  if ( this->IndexMode == VTK_INDEXING_OFF)
    {
    return "IndexingOff";
    }
  else if ( this->IndexMode == VTK_INDEXING_BY_SCALAR)
    {
    return "IndexingByScalar";
    }
  else
    {
    return "IndexingByVector";
    }
}
 
#endif