doxygen/html/vtkGraphMapper_8h_source.html

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


  Program:   Visualization Toolkit

  Module:    vtkGraphMapper.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.


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

/*-------------------------------------------------------------------------

  Copyright 2008 Sandia Corporation.

  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,

  the U.S. Government retains certain rights in this software.

-------------------------------------------------------------------------*/

#ifndef vtkGraphMapper_h

#define vtkGraphMapper_h


#include "vtkMapper.h"

#include "vtkRenderingCoreModule.h" // For export macro


#include "vtkSmartPointer.h" // Required for smart pointer internal ivars.


class vtkActor2D;

class vtkMapArrayValues;

class vtkCamera;

class vtkFollower;

class vtkGraph;

class vtkGlyph3D;

class vtkGraphToPolyData;

class vtkIconGlyphFilter;

class vtkCellCenters;

class vtkPolyData;

class vtkPolyDataMapper;

class vtkPolyDataMapper2D;

class vtkLookupTable;

class vtkTransformCoordinateSystems;

class vtkTexture;

class vtkTexturedActor2D;

class vtkVertexGlyphFilter;


class VTKRENDERINGCORE_EXPORT vtkGraphMapper : public vtkMapper

{

public:

  static vtkGraphMapper* New();

  vtkTypeMacro(vtkGraphMapper, vtkMapper);

  void PrintSelf(ostream& os, vtkIndent indent) override;

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


  void SetVertexColorArrayName(const char* name);

  const char* GetVertexColorArrayName();


  void SetColorVertices(bool vis);

  bool GetColorVertices();

  void ColorVerticesOn();

  void ColorVerticesOff();


  void SetScaledGlyphs(bool arg);

  vtkGetMacro(ScaledGlyphs, bool);

  vtkBooleanMacro(ScaledGlyphs, bool);


  vtkSetStringMacro(ScalingArrayName);

  vtkGetStringMacro(ScalingArrayName);


  void SetEdgeVisibility(bool vis);

  bool GetEdgeVisibility();

  vtkBooleanMacro(EdgeVisibility, bool);


  void SetEdgeColorArrayName(const char* name);

  const char* GetEdgeColorArrayName();


  void SetColorEdges(bool vis);

  bool GetColorEdges();

  void ColorEdgesOn();

  void ColorEdgesOff();


  vtkSetStringMacro(EnabledEdgesArrayName);

  vtkGetStringMacro(EnabledEdgesArrayName);


  vtkSetMacro(EnableEdgesByArray, vtkTypeBool);

  vtkGetMacro(EnableEdgesByArray, vtkTypeBool);

  vtkBooleanMacro(EnableEdgesByArray, vtkTypeBool);


  vtkSetStringMacro(EnabledVerticesArrayName);

  vtkGetStringMacro(EnabledVerticesArrayName);


  vtkSetMacro(EnableVerticesByArray, vtkTypeBool);

  vtkGetMacro(EnableVerticesByArray, vtkTypeBool);

  vtkBooleanMacro(EnableVerticesByArray, vtkTypeBool);


  void SetIconArrayName(const char* name);

  const char* GetIconArrayName();


  void AddIconType(const char* type, int index);


  void ClearIconTypes();


  void SetIconSize(int* size);

  int* GetIconSize();


  void SetIconAlignment(int alignment);


  vtkTexture* GetIconTexture();

  void SetIconTexture(vtkTexture* texture);


  void SetIconVisibility(bool vis);

  bool GetIconVisibility();

  vtkBooleanMacro(IconVisibility, bool);


  vtkGetMacro(VertexPointSize, float);

  void SetVertexPointSize(float size);


  vtkGetMacro(EdgeLineWidth, float);

  void SetEdgeLineWidth(float width);


  void ReleaseGraphicsResources(vtkWindow*) override;


  vtkMTimeType GetMTime() override;


  void SetInputData(vtkGraph* input);

  vtkGraph* GetInput();


  double* GetBounds() VTK_SIZEHINT(6) override;

  void GetBounds(double* bounds) override { Superclass::GetBounds(bounds); }


  vtkGetObjectMacro(EdgeLookupTable, vtkLookupTable);

  vtkGetObjectMacro(VertexLookupTable, vtkLookupTable);


protected:

  vtkGraphMapper();

  ~vtkGraphMapper() override;


  vtkGetStringMacro(VertexColorArrayNameInternal);

  vtkSetStringMacro(VertexColorArrayNameInternal);

  vtkGetStringMacro(EdgeColorArrayNameInternal);

  vtkSetStringMacro(EdgeColorArrayNameInternal);

  char* VertexColorArrayNameInternal;

  char* EdgeColorArrayNameInternal;


  char* EnabledEdgesArrayName;

  char* EnabledVerticesArrayName;

  vtkTypeBool EnableEdgesByArray;

  vtkTypeBool EnableVerticesByArray;


  vtkGetStringMacro(IconArrayNameInternal);

  vtkSetStringMacro(IconArrayNameInternal);

  char* IconArrayNameInternal;


  vtkSmartPointer<vtkGlyph3D> CircleGlyph;

  vtkSmartPointer<vtkGlyph3D> CircleOutlineGlyph;


  vtkSmartPointer<vtkGraphToPolyData> GraphToPoly;

  vtkSmartPointer<vtkVertexGlyphFilter> VertexGlyph;

  vtkSmartPointer<vtkIconGlyphFilter> IconGlyph;

  vtkSmartPointer<vtkMapArrayValues> IconTypeToIndex;

  vtkSmartPointer<vtkTransformCoordinateSystems> IconTransform;


  vtkSmartPointer<vtkPolyDataMapper> EdgeMapper;

  vtkSmartPointer<vtkPolyDataMapper> VertexMapper;

  vtkSmartPointer<vtkPolyDataMapper> OutlineMapper;

  vtkSmartPointer<vtkPolyDataMapper2D> IconMapper;


  vtkSmartPointer<vtkActor> EdgeActor;

  vtkSmartPointer<vtkActor> VertexActor;

  vtkSmartPointer<vtkActor> OutlineActor;

  vtkSmartPointer<vtkTexturedActor2D> IconActor;


  // Color maps

  vtkLookupTable* EdgeLookupTable;

  vtkLookupTable* VertexLookupTable;


  void ReportReferences(vtkGarbageCollector*) override;


  // see algorithm for more info

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


private:

  vtkGraphMapper(const vtkGraphMapper&) = delete;

  void operator=(const vtkGraphMapper&) = delete;


  // Helper function

  vtkPolyData* CreateCircle(bool filled);


  float VertexPointSize;

  float EdgeLineWidth;

  bool ScaledGlyphs;

  char* ScalingArrayName;

};


#endif