vtkGlyph3DMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGlyph3DMapper.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 vtkGlyph3DMapper_h
#define vtkGlyph3DMapper_h
 
#include "vtkGlyph3D.h" // for the constants (VTK_SCALE_BY_SCALAR, ...).
#include "vtkMapper.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkWeakPointer.h"         // needed for vtkWeakPointer.
 
class vtkCompositeDataDisplayAttributes;
class vtkDataObjectTree;
 
class VTKRENDERINGCORE_EXPORT vtkGlyph3DMapper : public vtkMapper
{
public:
  static vtkGlyph3DMapper* New();
  vtkTypeMacro(vtkGlyph3DMapper, vtkMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum ArrayIndexes
  {
    SCALE = 0,
    SOURCE_INDEX = 1,
    MASK = 2,
    ORIENTATION = 3,
    SELECTIONID = 4
  };
 
  void SetSourceConnection(int idx, vtkAlgorithmOutput* algOutput);
  void SetSourceConnection(vtkAlgorithmOutput* algOutput)
  {
    this->SetSourceConnection(0, algOutput);
  }
 
  void SetInputData(vtkDataObject*);
 
  void SetSourceData(int idx, vtkPolyData* pd);
 
  void SetSourceTableTree(vtkDataObjectTree* tree);
 
  void SetSourceData(vtkPolyData* pd);
 
  vtkPolyData* GetSource(int idx = 0);
 
  vtkDataObjectTree* GetSourceTableTree();
 
 
  vtkSetMacro(Scaling, bool);
  vtkBooleanMacro(Scaling, bool);
  vtkGetMacro(Scaling, bool);
 
 
  vtkSetMacro(ScaleMode, int);
  vtkGetMacro(ScaleMode, int);
 
 
  vtkSetMacro(ScaleFactor, double);
  vtkGetMacro(ScaleFactor, double);
 
  enum ScaleModes
  {
    NO_DATA_SCALING = 0,
    SCALE_BY_MAGNITUDE = 1,
    SCALE_BY_COMPONENTS = 2
  };
 
  void SetScaleModeToScaleByMagnitude() { this->SetScaleMode(SCALE_BY_MAGNITUDE); }
  void SetScaleModeToScaleByVectorComponents() { this->SetScaleMode(SCALE_BY_COMPONENTS); }
  void SetScaleModeToNoDataScaling() { this->SetScaleMode(NO_DATA_SCALING); }
  const char* GetScaleModeAsString();
 
 
  vtkSetVector2Macro(Range, double);
  vtkGetVectorMacro(Range, double, 2);
 
 
  vtkSetMacro(Orient, bool);
  vtkGetMacro(Orient, bool);
  vtkBooleanMacro(Orient, bool);
 
 
  vtkSetClampMacro(OrientationMode, int, DIRECTION, QUATERNION);
  vtkGetMacro(OrientationMode, int);
  void SetOrientationModeToDirection() { this->SetOrientationMode(vtkGlyph3DMapper::DIRECTION); }
  void SetOrientationModeToRotation() { this->SetOrientationMode(vtkGlyph3DMapper::ROTATION); }
  void SetOrientationModeToQuaternion() { this->SetOrientationMode(vtkGlyph3DMapper::QUATERNION); }
  const char* GetOrientationModeAsString();
 
  enum OrientationModes
  {
    DIRECTION = 0,
    ROTATION = 1,
    QUATERNION = 2
  };
 
 
  vtkSetMacro(Clamping, bool);
  vtkGetMacro(Clamping, bool);
  vtkBooleanMacro(Clamping, bool);
 
 
  vtkSetMacro(SourceIndexing, bool);
  vtkGetMacro(SourceIndexing, bool);
  vtkBooleanMacro(SourceIndexing, bool);
 
 
  vtkSetMacro(UseSourceTableTree, bool);
  vtkGetMacro(UseSourceTableTree, bool);
  vtkBooleanMacro(UseSourceTableTree, bool);
 
 
  vtkSetMacro(UseSelectionIds, bool);
  vtkBooleanMacro(UseSelectionIds, bool);
  vtkGetMacro(UseSelectionIds, bool);
 
  double* GetBounds() override;
 
  void GetBounds(double bounds[6]) override;
 
  void Render(vtkRenderer* ren, vtkActor* act) override;
 
 
  vtkSetMacro(Masking, bool);
  vtkGetMacro(Masking, bool);
  vtkBooleanMacro(Masking, bool);
 
  void SetMaskArray(const char* maskarrayname);
 
  void SetMaskArray(int fieldAttributeType);
 
  void SetOrientationArray(const char* orientationarrayname);
 
  void SetOrientationArray(int fieldAttributeType);
 
  void SetScaleArray(const char* scalarsarrayname);
 
  void SetScaleArray(int fieldAttributeType);
 
  void SetSourceIndexArray(const char* arrayname);
 
  void SetSourceIndexArray(int fieldAttributeType);
 
  void SetSelectionIdArray(const char* selectionIdArrayName);
 
  void SetSelectionIdArray(int fieldAttributeType);
 
 
  vtkSetMacro(SelectionColorId, unsigned int);
  vtkGetMacro(SelectionColorId, unsigned int);
 
 
  virtual void SetBlockAttributes(vtkCompositeDataDisplayAttributes* attr);
  vtkGetObjectMacro(BlockAttributes, vtkCompositeDataDisplayAttributes);
 
 
  vtkSetMacro(CullingAndLOD, bool);
  vtkGetMacro(CullingAndLOD, bool);
 
  virtual vtkIdType GetMaxNumberOfLOD();
 
  virtual void SetNumberOfLOD(vtkIdType vtkNotUsed(nb)) {}
 
  virtual void SetLODDistanceAndTargetReduction(
    vtkIdType vtkNotUsed(index), float vtkNotUsed(distance), float vtkNotUsed(targetReduction))
  {
  }
 
  vtkSetMacro(LODColoring, bool);
  vtkGetMacro(LODColoring, bool);
 
  bool GetSupportsSelection() override { return true; }
 
protected:
  vtkGlyph3DMapper();
  ~vtkGlyph3DMapper() override;
 
  virtual int RequestUpdateExtent(
    vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo);
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  vtkPolyData* GetSource(int idx, vtkInformationVector* sourceInfo);
  vtkPolyData* GetSourceTable(int idx, vtkInformationVector* sourceInfo);
 
 
  vtkDataArray* GetMaskArray(vtkDataSet* input);
  vtkDataArray* GetSourceIndexArray(vtkDataSet* input);
  vtkDataArray* GetOrientationArray(vtkDataSet* input);
  vtkDataArray* GetScaleArray(vtkDataSet* input);
  vtkDataArray* GetSelectionIdArray(vtkDataSet* input);
  vtkUnsignedCharArray* GetColors(vtkDataSet* input);
 
  vtkCompositeDataDisplayAttributes* BlockAttributes;
  bool Scaling;       // Determine whether scaling of geometry is performed
  double ScaleFactor; // Scale factor to use to scale geometry
  int ScaleMode;      // Scale by scalar value or vector magnitude
 
  double Range[2];      // Range to use to perform scalar scaling
  bool Orient;          // boolean controls whether to "orient" data
  bool Clamping;        // whether to clamp scale factor
  bool SourceIndexing;  // Enable/disable indexing into the glyph table
  bool UseSelectionIds; // Enable/disable custom pick ids
  bool Masking;         // Enable/disable masking.
  int OrientationMode;
 
  bool UseSourceTableTree; // Map DataObjectTree glyph source into table
 
  unsigned int SelectionColorId;
 
  bool CullingAndLOD = false; // Disable culling
  std::vector<std::pair<float, float> > LODs;
  bool LODColoring = false;
 
private:
  vtkGlyph3DMapper(const vtkGlyph3DMapper&) = delete;
  void operator=(const vtkGlyph3DMapper&) = delete;
 
  bool GetBoundsInternal(vtkDataSet* ds, double ds_bounds[6]);
};
 
#endif