vtkMarkupsGlyphSource2D.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
==============================================================================*/

//
 
#ifndef __vtkMarkupsGlyphSource2D_h
#define __vtkMarkupsGlyphSource2D_h
 
#include "vtkSlicerMarkupsModuleVTKWidgetsExport.h"
 
#include "vtkSlicerBaseLogic.h"
 
// VTK includes
#include "vtkGlyphSource2D.h"
#include "vtkPolyDataAlgorithm.h"
 
class vtkPoints;
class vtkUnsignedCharArray;
class vtkCellArray;
 
class VTK_SLICER_MARKUPS_MODULE_VTKWIDGETS_EXPORT vtkMarkupsGlyphSource2D : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkMarkupsGlyphSource2D, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkMarkupsGlyphSource2D* New();

  vtkSetVector3Macro(Center, double);
  vtkGetVectorMacro(Center, double, 3);

  vtkSetClampMacro(Scale, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(Scale, double);

  vtkSetClampMacro(Scale2, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(Scale2, double);

  vtkSetVector3Macro(Color, double);
  vtkGetVectorMacro(Color, double, 3);

  vtkSetMacro(Filled, int);
  vtkGetMacro(Filled, int);
  vtkBooleanMacro(Filled, int);

  vtkSetMacro(Dash, int);
  vtkGetMacro(Dash, int);
  vtkBooleanMacro(Dash, int);

  vtkSetMacro(Cross, int);
  vtkGetMacro(Cross, int);
  vtkBooleanMacro(Cross, int);

  vtkSetMacro(RotationAngle, double);
  vtkGetMacro(RotationAngle, double);

  vtkSetClampMacro(GlyphType, int, GlyphNone, GlyphType_Last - 1);
  vtkGetMacro(GlyphType, int);
  void SetGlyphTypeToNone() { this->SetGlyphType(GlyphNone); }
  void SetGlyphTypeToStarBurst() { this->SetGlyphType(GlyphStarBurst); }
  void SetGlyphTypeToCross() { this->SetGlyphType(GlyphCross); }
  void SetGlyphTypeToCrossDot() { this->SetGlyphType(GlyphCrossDot); }
  void SetGlyphTypeToThickCross() { this->SetGlyphType(GlyphThickCross); }
  void SetGlyphTypeToVertex() { this->SetGlyphType(GlyphVertex); }
  void SetGlyphTypeToDash() { this->SetGlyphType(GlyphDash); }
  void SetGlyphTypeToTriangle() { this->SetGlyphType(GlyphTriangle); }
  void SetGlyphTypeToSquare() { this->SetGlyphType(GlyphSquare); }
  void SetGlyphTypeToCircle() { this->SetGlyphType(GlyphCircle); }
  void SetGlyphTypeToDiamond() { this->SetGlyphType(GlyphDiamond); }
  void SetGlyphTypeToArrow() { this->SetGlyphType(GlyphArrow); }
  void SetGlyphTypeToThickArrow() { this->SetGlyphType(GlyphThickArrow); }
  void SetGlyphTypeToHookedArrow() { this->SetGlyphType(GlyphHookedArrow); }
  void SetGlyphTypeToCircledCross() { this->SetGlyphType(GlyphCircledCross); }
  void SetGlyphTypeToCircledPoint() { this->SetGlyphType(GlyphCircledPoint); }
 
  void SetNextGlyphType();
 
  enum GlyphTypes
  {
    GlyphNone = 0,
    GlyphStarBurst,
    GlyphCross,
    GlyphCrossDot,
    GlyphThickCross,
    GlyphVertex,
    GlyphDash,
    GlyphTriangle,
    GlyphSquare,
    GlyphCircle,
    GlyphDiamond,
    GlyphArrow,
    GlyphThickArrow,
    GlyphHookedArrow,
    GlyphCircledCross,
    GlyphCircledPoint,
    GlyphType_Last // insert new types above this line
  };
 
protected:
  vtkMarkupsGlyphSource2D();
  ~vtkMarkupsGlyphSource2D() override = default;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  double Center[3];
  double Scale;
  double Scale2;
  double Color[3];
  int Filled;
  int Dash;
  int Cross;
  int GlyphType;
  double RotationAngle;
 
  void TransformGlyph(vtkPoints* pts);
  void ConvertColor();
  unsigned char RGB[3];
 
  void CreateVertex(vtkPoints* pts, vtkCellArray* verts, vtkUnsignedCharArray* colors);
  void CreateDash(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors, double scale = 1.0);
  void CreateCross(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors, double scale = 1.0, bool dot = false);
  void CreateThickCross(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateTriangle(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateSquare(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateCircle(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateDiamond(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateArrow(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateThickArrow(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateHookedArrow(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateCircledCross(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateCircledPoint(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
  void CreateStarBurst(vtkPoints* pts, vtkCellArray* lines, vtkCellArray* polys, vtkUnsignedCharArray* colors);
 
private:
  vtkMarkupsGlyphSource2D(const vtkMarkupsGlyphSource2D&) = delete;
  void operator=(const vtkMarkupsGlyphSource2D&) = delete;
};
 
#endif