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 "vtkRenderingCoreModule.h" // For export macro
#include "vtkMapper.h"
#include "vtkGlyph3D.h" // for the constants (VTK_SCALE_BY_SCALAR, ...).
#include "vtkWeakPointer.h" // needed for vtkWeakPointer.

class VTKRENDERINGCORE_EXPORT vtkGlyph3DMapper : public vtkMapper
{
public:
  static vtkGlyph3DMapper* New();
  vtkTypeMacro(vtkGlyph3DMapper, vtkMapper);
  void PrintSelf(ostream& os, vtkIndent indent);
  //BTX
  enum ArrayIndexes
    {
    SCALE = 0,
    SOURCE_INDEX = 1,
    MASK = 2,
    ORIENTATION = 3,
    SELECTIONID = 4
    };
  //ETX


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

  void SetInputData(vtkDataObject *);

  void SetSourceData(int idx, vtkPolyData *pd);

  void SetSourceData(vtkPolyData *pd);

  vtkPolyData *GetSource(int idx=0);


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


  vtkSetMacro(ScaleMode, int);
  vtkGetMacro(ScaleMode, int);


  vtkSetMacro(ScaleFactor,double);
  vtkGetMacro(ScaleFactor,double);

  //BTX
  enum ScaleModes
    {
    NO_DATA_SCALING = 0,
    SCALE_BY_MAGNITUDE = 1,
    SCALE_BY_COMPONENTS = 2
    };
  //ETX
  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, ROTATION);
  vtkGetMacro(OrientationMode, int);
  void SetOrientationModeToDirection()
    { this->SetOrientationMode(vtkGlyph3DMapper::DIRECTION); }
  void SetOrientationModeToRotation()
    { this->SetOrientationMode(vtkGlyph3DMapper::ROTATION); }
  const char* GetOrientationModeAsString();
  //BTX
  enum OrientationModes
    {
    DIRECTION=0,
    ROTATION=1
    };
  //ETX


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


  vtkSetMacro(SourceIndexing, bool);
  vtkGetMacro(SourceIndexing, bool);
  vtkBooleanMacro(SourceIndexing, bool);


  vtkSetMacro(UseSelectionIds, bool);
  vtkBooleanMacro(UseSelectionIds, bool);
  vtkGetMacro(UseSelectionIds, bool);

  virtual double *GetBounds();

  virtual void GetBounds(double bounds[6]);

  virtual void Render(vtkRenderer *ren, vtkActor *act);


  vtkSetMacro(NestedDisplayLists, bool);
  vtkGetMacro(NestedDisplayLists, bool);
  vtkBooleanMacro(NestedDisplayLists, bool);


  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);


  vtkSetMacro(SelectMode, int);


  virtual bool GetSupportsSelection()
    { return true; }
  //BTX
protected:
  vtkGlyph3DMapper();
  ~vtkGlyph3DMapper();

  virtual int RequestUpdateExtent(vtkInformation *request,
    vtkInformationVector **inInfo,
    vtkInformationVector *outInfo);

  virtual int FillInputPortInformation(int port,
    vtkInformation *info);

  vtkPolyData *GetSource(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);

  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 NestedDisplayLists; // boolean

  unsigned int SelectionColorId;
  int SelectMode;

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


  bool GetBoundsInternal(vtkDataSet* ds, double ds_bounds[6]);
  //ETX
};

#endif