vtkConvexHull2D.h

Go to the documentation of this file.

/*=========================================================================
 
 Program:   Visualization Toolkit
 Module:    vtkConvexHull2D.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 vtkConvexHull2D_h
#define vtkConvexHull2D_h
 
#include "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkSmartPointer.h" // needed for ivars
 
class vtkCoordinate;
class vtkPoints;
class vtkPolygon;
class vtkPolyLine;
class vtkRenderer;
class vtkTransform;
class vtkTransformPolyDataFilter;
 
class VTKRENDERINGANNOTATION_EXPORT vtkConvexHull2D: public vtkPolyDataAlgorithm
{
public:
  static vtkConvexHull2D *New();
  vtkTypeMacro(vtkConvexHull2D, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  vtkGetMacro(ScaleFactor, double);
  vtkSetMacro(ScaleFactor, double);
 
 
  vtkGetMacro(Outline, bool);
  vtkSetMacro(Outline, bool);
  vtkBooleanMacro(Outline, bool);
 
  enum HullShapes {
    BoundingRectangle = 0,
    ConvexHull
  };
 
 
  vtkGetMacro(HullShape, int);
  vtkSetClampMacro(HullShape, int, 0, 1);
 
 
  vtkSetClampMacro(MinHullSizeInWorld, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(MinHullSizeInWorld, double);
 
 
 
  vtkSetClampMacro(MinHullSizeInDisplay, int, 0, VTK_INT_MAX);
  vtkGetMacro(MinHullSizeInDisplay, int);
 
 
  void SetRenderer(vtkRenderer* renderer);
  vtkRenderer* GetRenderer();
 
  virtual unsigned long GetMTime();
 
 
  static void CalculateBoundingRectangle(vtkPoints* inPoints,
    vtkPoints* outPoints, double minimumHullSize=1.0);
  static void CalculateConvexHull(vtkPoints* inPoints, vtkPoints* outPoints,
    double minimumHullSize=1.0);
 
protected:
  vtkConvexHull2D();
  ~vtkConvexHull2D();
 
 
  int RequestData(vtkInformation *, vtkInformationVector **,
    vtkInformationVector *);
 
private:
  vtkConvexHull2D(const vtkConvexHull2D&); // Not implemented.
  void operator=(const vtkConvexHull2D&); // Not implemented.
 
  void ResizeHullToMinimumInDisplay(vtkPolyData* hullPolyData);
 
  double ScaleFactor;
  bool Outline;
  int HullShape;
  int MinHullSizeInDisplay;
  double MinHullSizeInWorld;
  vtkRenderer* Renderer;
 
  vtkSmartPointer<vtkCoordinate> Coordinate;
  vtkSmartPointer<vtkTransform> Transform;
  vtkSmartPointer<vtkTransform> OutputTransform;
  vtkSmartPointer<vtkTransformPolyDataFilter> OutputTransformFilter;
  vtkSmartPointer<vtkPolyLine> OutlineSource;
  vtkSmartPointer<vtkPolygon> HullSource;
};
 
#endif // vtkConvexHull2D_h