v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  Program:   Visualization Toolkit

  Module:    vtkImageTracerWidget.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 vtkImageTracerWidget_h

#define vtkImageTracerWidget_h


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

#include "vtk3DWidget.h"


class vtkAbstractPropPicker;

class vtkActor;

class vtkCellArray;

class vtkCellPicker;

class vtkFloatArray;

class vtkGlyphSource2D;

class vtkPoints;

class vtkPolyData;

class vtkProp;

class vtkProperty;

class vtkPropPicker;

class vtkTransform;

class vtkTransformPolyDataFilter;


#define VTK_ITW_PROJECTION_YZ 0

#define VTK_ITW_PROJECTION_XZ 1

#define VTK_ITW_PROJECTION_XY 2

#define VTK_ITW_SNAP_CELLS    0

#define VTK_ITW_SNAP_POINTS   1


class VTKINTERACTIONWIDGETS_EXPORT vtkImageTracerWidget : public vtk3DWidget

{

public:

  static vtkImageTracerWidget *New();


  vtkTypeMacro(vtkImageTracerWidget,vtk3DWidget);

  void PrintSelf(ostream& os, vtkIndent indent);


  virtual void SetEnabled(int);

  virtual void PlaceWidget(double bounds[6]);

  void PlaceWidget()

    {this->Superclass::PlaceWidget();}

  void PlaceWidget(double xmin, double xmax, double ymin, double ymax,

                   double zmin, double zmax)

    {this->Superclass::PlaceWidget(xmin,xmax,ymin,ymax,zmin,zmax);}


  virtual void SetHandleProperty(vtkProperty*);

  vtkGetObjectMacro(HandleProperty, vtkProperty);

  virtual void SetSelectedHandleProperty(vtkProperty*);

  vtkGetObjectMacro(SelectedHandleProperty, vtkProperty);


  virtual void SetLineProperty(vtkProperty*);

  vtkGetObjectMacro(LineProperty, vtkProperty);

  virtual void SetSelectedLineProperty(vtkProperty*);

  vtkGetObjectMacro(SelectedLineProperty, vtkProperty);


  void SetViewProp(vtkProp* prop);


  vtkSetMacro(ProjectToPlane,int);

  vtkGetMacro(ProjectToPlane,int);

  vtkBooleanMacro(ProjectToPlane,int);


  vtkSetClampMacro(ProjectionNormal,int,VTK_ITW_PROJECTION_YZ,VTK_ITW_PROJECTION_XY);

  vtkGetMacro(ProjectionNormal,int);

  void SetProjectionNormalToXAxes()

    { this->SetProjectionNormal(0); }

  void SetProjectionNormalToYAxes()

    { this->SetProjectionNormal(1); }

  void SetProjectionNormalToZAxes()

    { this->SetProjectionNormal(2); }


  void SetProjectionPosition(double position);

  vtkGetMacro(ProjectionPosition,double);


  void SetSnapToImage(int snap);

  vtkGetMacro(SnapToImage,int);

  vtkBooleanMacro(SnapToImage,int);


  vtkSetMacro(AutoClose,int);

  vtkGetMacro(AutoClose,int);

  vtkBooleanMacro(AutoClose,int);


  vtkSetMacro(CaptureRadius,double);

  vtkGetMacro(CaptureRadius,double);


  void GetPath(vtkPolyData *pd);


  vtkGlyphSource2D* GetGlyphSource() { return this->HandleGenerator; }


  vtkSetClampMacro(ImageSnapType,int,VTK_ITW_SNAP_CELLS,VTK_ITW_SNAP_POINTS);

  vtkGetMacro(ImageSnapType,int);


  void SetHandlePosition(int handle, double xyz[3]);

  void SetHandlePosition(int handle, double x, double y, double z);

  void GetHandlePosition(int handle, double xyz[3]);

  double* GetHandlePosition(int handle);


  vtkGetMacro(NumberOfHandles,int);


  void SetInteraction(int interact);

  vtkGetMacro(Interaction,int);

  vtkBooleanMacro(Interaction,int);


  void InitializeHandles(vtkPoints*);


  int IsClosed();


  vtkSetMacro(HandleLeftMouseButton,int);

  vtkGetMacro(HandleLeftMouseButton,int);

  vtkBooleanMacro(HandleLeftMouseButton,int);

  vtkSetMacro(HandleMiddleMouseButton,int);

  vtkGetMacro(HandleMiddleMouseButton,int);

  vtkBooleanMacro(HandleMiddleMouseButton,int);

  vtkSetMacro(HandleRightMouseButton,int);

  vtkGetMacro(HandleRightMouseButton,int);

  vtkBooleanMacro(HandleRightMouseButton,int);


#ifdef VTK_WORKAROUND_WINDOWS_MANGLE

# define SetPropA SetProp

# define SetPropW SetProp

#endif


#ifdef VTK_WORKAROUND_WINDOWS_MANGLE

# undef SetPropA

# undef SetPropW

#endif


protected:

  vtkImageTracerWidget();

  ~vtkImageTracerWidget();


//BTX - manage the state of the widget

  int State;

  enum WidgetState

  {

    Start=0,

    Tracing,

    Snapping,

    Erasing,

    Inserting,

    Moving,

    Translating,

    Outside

  };

//ETX


  //handles the events

  static void ProcessEvents(vtkObject* object,

                            unsigned long event,

                            void* clientdata,

                            void* calldata);


  // ProcessEvents() dispatches to these methods.

  void OnLeftButtonDown();

  void OnLeftButtonUp();

  void OnMiddleButtonDown();

  void OnMiddleButtonUp();

  void OnRightButtonDown();

  void OnRightButtonUp();

  void OnMouseMove();


  void AddObservers();


  // Controlling ivars

  int    Interaction;

  int    ProjectionNormal;

  double ProjectionPosition;

  int    ProjectToPlane;

  int    ImageSnapType;

  int    SnapToImage;

  double CaptureRadius; // tolerance for auto path close

  int    AutoClose;

  int    IsSnapping;

  int    LastX;

  int    LastY;


  void  Trace(int , int );

  void  Snap(double* );

  void  MovePoint(const double* , const double* );

  void  Translate(const double* , const double* );

  void  ClosePath();


  // 2D glyphs representing hot spots (e.g., handles)

  vtkActor          **Handle;

  vtkPolyData       **HandleGeometry;

  vtkGlyphSource2D   *HandleGenerator;


  // Transforms required as 2D glyphs are generated in the x-y plane

  vtkTransformPolyDataFilter *TransformFilter;

  vtkTransform               *Transform;

  vtkFloatArray              *TemporaryHandlePoints;


  void AppendHandles(double*);

  void ResetHandles();

  void AllocateHandles(const int& );

  void AdjustHandlePosition(const int& , double*);

  int  HighlightHandle(vtkProp* ); // returns handle index or -1 on fail

  void EraseHandle(const int& );

  virtual void SizeHandles();

  void InsertHandleOnLine(double* );


  int NumberOfHandles;

  vtkActor *CurrentHandle;

  int CurrentHandleIndex;


  vtkProp       *ViewProp;    // the prop we want to pick on

  vtkPropPicker *PropPicker;  // the prop's picker


  // Representation of the line

  vtkPoints         *LinePoints;

  vtkCellArray      *LineCells;

  vtkActor          *LineActor;

  vtkPolyData       *LineData;

  vtkIdType          CurrentPoints[2];


  void HighlightLine(const int& );

  void BuildLinesFromHandles();

  void ResetLine(double* );

  void AppendLine(double* );

  int  PickCount;


  // Do the picking of the handles and the lines

  vtkCellPicker *HandlePicker;

  vtkCellPicker *LinePicker;

  vtkAbstractPropPicker* CurrentPicker;


  // Register internal Pickers within PickingManager

  virtual void RegisterPickers();


  // Properties used to control the appearance of selected objects and

  // the manipulator in general.

  vtkProperty *HandleProperty;

  vtkProperty *SelectedHandleProperty;

  vtkProperty *LineProperty;

  vtkProperty *SelectedLineProperty;

  void CreateDefaultProperties();


  // Enable/Disable mouse button events

  int HandleLeftMouseButton;

  int HandleMiddleMouseButton;

  int HandleRightMouseButton;


private:

  vtkImageTracerWidget(const vtkImageTracerWidget&);  //Not implemented

  void operator=(const vtkImageTracerWidget&);  //Not implemented

};


#endif