vtkGlyph3D.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkGlyph3D.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 vtkGlyph3D_h
#define vtkGlyph3D_h

#include "vtkFiltersCoreModule.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_FOLLOW_CAMERA_DIRECTION 3

#define VTK_INDEXING_OFF 0
#define VTK_INDEXING_BY_SCALAR 1
#define VTK_INDEXING_BY_VECTOR 2

class vtkTransform;

class VTKFILTERSCORE_EXPORT vtkGlyph3D : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkGlyph3D, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkGlyph3D* New();

  void SetSourceData(vtkPolyData* pd) { this->SetSourceData(0, pd); }

  void SetSourceData(int id, vtkPolyData* pd);


  void SetSourceConnection(int id, vtkAlgorithmOutput* algOutput);
  void SetSourceConnection(vtkAlgorithmOutput* algOutput)
  {
    this->SetSourceConnection(0, algOutput);
  }

  vtkPolyData* GetSource(int id = 0);


  vtkSetMacro(Scaling, vtkTypeBool);
  vtkBooleanMacro(Scaling, vtkTypeBool);
  vtkGetMacro(Scaling, vtkTypeBool);


  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, vtkTypeBool);
  vtkBooleanMacro(Orient, vtkTypeBool);
  vtkGetMacro(Orient, vtkTypeBool);


  vtkSetMacro(Clamping, vtkTypeBool);
  vtkBooleanMacro(Clamping, vtkTypeBool);
  vtkGetMacro(Clamping, vtkTypeBool);


  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); }
  void SetVectorModeToFollowCameraDirection() { this->SetVectorMode(VTK_FOLLOW_CAMERA_DIRECTION); };
  const char* GetVectorModeAsString();

  vtkSetVectorMacro(FollowedCameraPosition, double, 3);
  vtkGetVectorMacro(FollowedCameraPosition, double, 3);

  vtkSetVectorMacro(FollowedCameraViewUp, double, 3);
  vtkGetVectorMacro(FollowedCameraViewUp, double, 3);


  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, vtkTypeBool);
  vtkGetMacro(GeneratePointIds, vtkTypeBool);
  vtkBooleanMacro(GeneratePointIds, vtkTypeBool);


  vtkSetStringMacro(PointIdsName);
  vtkGetStringMacro(PointIdsName);


  vtkSetMacro(FillCellData, vtkTypeBool);
  vtkGetMacro(FillCellData, vtkTypeBool);
  vtkBooleanMacro(FillCellData, vtkTypeBool);

  virtual int IsPointVisible(vtkDataSet*, vtkIdType) { return 1; }


  void SetSourceTransform(vtkTransform*);
  vtkGetObjectMacro(SourceTransform, vtkTransform);

  vtkMTimeType GetMTime() override;


  vtkSetMacro(OutputPointsPrecision, int);
  vtkGetMacro(OutputPointsPrecision, int);

protected:
  vtkGlyph3D();
  ~vtkGlyph3D() override;

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int, vtkInformation*) override;

  vtkPolyData* GetSource(int idx, vtkInformationVector* sourceInfo);


  virtual bool Execute(vtkDataSet* input, vtkInformationVector* sourceVector, vtkPolyData* output);
  virtual bool Execute(vtkDataSet* input, vtkInformationVector* sourceVector, vtkPolyData* output,
    vtkDataArray* inSScalars, vtkDataArray* inVectors);

  vtkPolyData** Source; // Geometry to copy to each point
  vtkTypeBool 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
  double
    FollowedCameraPosition[3]; // glyphs face towards this point in VTK_FOLLOW_CAMERA_DIRECTION mode
  double FollowedCameraViewUp[3]; // glyph up direction in VTK_FOLLOW_CAMERA_DIRECTION mode
  vtkTypeBool Clamping;           // whether to clamp scale factor
  int IndexMode;                  // what to use to index into glyph table
  vtkTypeBool GeneratePointIds;   // produce input points ids for each output point
  vtkTypeBool FillCellData;       // whether to fill output cell data
  char* PointIdsName;
  vtkTransform* SourceTransform;
  int OutputPointsPrecision;

private:
  vtkGlyph3D(const vtkGlyph3D&) = delete;
  void operator=(const vtkGlyph3D&) = delete;
};


inline const char* vtkGlyph3D::GetScaleModeAsString(void)
{
  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* vtkGlyph3D::GetColorModeAsString(void)
{
  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* vtkGlyph3D::GetVectorModeAsString(void)
{
  if (this->VectorMode == VTK_USE_VECTOR)
  {
    return "UseVector";
  }
  else if (this->VectorMode == VTK_USE_NORMAL)
  {
    return "UseNormal";
  }
  else if (this->VectorMode == VTK_FOLLOW_CAMERA_DIRECTION)
  {
    return "FollowCameraDirection";
  }
  else
  {
    return "VectorRotationOff";
  }
}


inline const char* vtkGlyph3D::GetIndexModeAsString(void)
{
  if (this->IndexMode == VTK_INDEXING_OFF)
  {
    return "IndexingOff";
  }
  else if (this->IndexMode == VTK_INDEXING_BY_SCALAR)
  {
    return "IndexingByScalar";
  }
  else
  {
    return "IndexingByVector";
  }
}

#endif