vtkContourRepresentation.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkContourRepresentation.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 vtkContourRepresentation_h
#define vtkContourRepresentation_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkWidgetRepresentation.h"
#include <vector> // STL Header; Required for vector
 
class vtkContourLineInterpolator;
class vtkIncrementalOctreePointLocator;
class vtkPointPlacer;
class vtkPolyData;
class vtkIdList;
 
//----------------------------------------------------------------------
//BTX
class vtkContourRepresentationPoint
{
public:
  double        WorldPosition[3];
  double        NormalizedDisplayPosition[2];
 
  // The point id. This is blank except in the case of
  // vtkPolygonalSurfaceContourLineInterpolator
  vtkIdType     PointId;
};
 
class vtkContourRepresentationNode
{
public:
  double        WorldPosition[3];
  double        WorldOrientation[9];
  double        NormalizedDisplayPosition[2];
  int           Selected;
  std::vector<vtkContourRepresentationPoint*> Points;
 
  // The point id. This is blank except in the case of
  // vtkPolygonalSurfaceContourLineInterpolator
  vtkIdType     PointId;
};
 
class vtkContourRepresentationInternals
{
public:
  std::vector<vtkContourRepresentationNode*> Nodes;
  void ClearNodes()
  {
    for(unsigned int i=0;i<this->Nodes.size();i++)
      {
      for (unsigned int j=0;j<this->Nodes[i]->Points.size();j++)
        {
        delete this->Nodes[i]->Points[j];
        }
      this->Nodes[i]->Points.clear();
      delete this->Nodes[i];
      }
    this->Nodes.clear();
  }
};
//ETX
 
class VTKINTERACTIONWIDGETS_EXPORT vtkContourRepresentation : public vtkWidgetRepresentation
{
  //BTX
  friend class vtkContourWidget;
  //ETX
public:
 
  vtkTypeMacro(vtkContourRepresentation,vtkWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  virtual int AddNodeAtWorldPosition( double x, double y, double z);
  virtual int AddNodeAtWorldPosition( double worldPos[3] );
  virtual int AddNodeAtWorldPosition( double worldPos[3],
                                      double worldOrient[9] );
 
 
  virtual int AddNodeAtDisplayPosition( double displayPos[2] );
  virtual int AddNodeAtDisplayPosition( int displayPos[2] );
  virtual int AddNodeAtDisplayPosition( int X, int Y );
 
 
  virtual int ActivateNode( double displayPos[2] );
  virtual int ActivateNode( int displayPos[2] );
  virtual int ActivateNode( int X, int Y );
 
  // Descirption:
  // Move the active node to a specified world position.
  // Will return 0 if there is no active node or the node
  // could not be moved to that position. 1 will be returned
  // on success.
  virtual int SetActiveNodeToWorldPosition( double pos[3] );
  virtual int SetActiveNodeToWorldPosition( double pos[3],
                                            double orient[9] );
 
 
  virtual int SetActiveNodeToDisplayPosition( double pos[2] );
  virtual int SetActiveNodeToDisplayPosition( int pos[2] );
  virtual int SetActiveNodeToDisplayPosition( int X, int Y );
 
 
  virtual int ToggleActiveNodeSelected();
  virtual int GetActiveNodeSelected();
  virtual int GetNthNodeSelected(int);
  virtual int SetNthNodeSelected(int);
 
  virtual int GetActiveNodeWorldPosition( double pos[3] );
 
  virtual int GetActiveNodeWorldOrientation( double orient[9] );
 
  virtual int GetActiveNodeDisplayPosition( double pos[2] );
 
  virtual int GetNumberOfNodes();
 
  virtual int GetNthNodeDisplayPosition( int n, double pos[2] );
 
  virtual int GetNthNodeWorldPosition( int n, double pos[3] );
 
  //BTX
 
  virtual vtkContourRepresentationNode *GetNthNode(int n);
  //ETX
 
  virtual int GetNthNodeWorldOrientation( int n, double orient[9] );
 
 
  virtual int SetNthNodeDisplayPosition( int n, int X, int Y );
  virtual int SetNthNodeDisplayPosition( int n, int pos[2] );
  virtual int SetNthNodeDisplayPosition( int n, double pos[2] );
 
 
  virtual int SetNthNodeWorldPosition( int n, double pos[3] );
  virtual int SetNthNodeWorldPosition( int n, double pos[3],
                                       double orient[9] );
 
  virtual int  GetNthNodeSlope( int idx, double slope[3] );
 
  // Descirption:
  // For a given node n, get the number of intermediate
  // points between this node and the node at
  // (n+1). If n is the last node and the loop is
  // closed, this is the number of intermediate points
  // between node n and node 0. 0 is returned if n is
  // out of range.
  virtual int GetNumberOfIntermediatePoints( int n );
 
 
  virtual int GetIntermediatePointWorldPosition( int n,
                                                 int idx, double point[3] );
 
 
  virtual int AddIntermediatePointWorldPosition( int n,
                                                 double point[3] );
 
 
  virtual int AddIntermediatePointWorldPosition( int n,
                               double point[3], vtkIdType ptId );
 
  virtual int DeleteLastNode();
 
  virtual int DeleteActiveNode();
 
  virtual int DeleteNthNode( int n );
 
  virtual void ClearAllNodes();
 
  virtual int AddNodeOnContour( int X, int Y );
 
 
  vtkSetClampMacro(PixelTolerance,int,1,100);
  vtkGetMacro(PixelTolerance,int);
 
 
  vtkSetClampMacro(WorldTolerance, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(WorldTolerance, double);
 
//BTX -- used to communicate about the state of the representation
  enum {
    Outside=0,
    Nearby
  };
 
  enum {
    Inactive = 0,
    Translate,
    Shift,
    Scale
  };
//ETX
 
 
  vtkGetMacro( CurrentOperation, int );
  vtkSetClampMacro( CurrentOperation, int,
                    vtkContourRepresentation::Inactive,
                    vtkContourRepresentation::Scale );
  void SetCurrentOperationToInactive()
    { this->SetCurrentOperation( vtkContourRepresentation::Inactive ); }
  void SetCurrentOperationToTranslate()
    { this->SetCurrentOperation( vtkContourRepresentation::Translate ); }
  void SetCurrentOperationToShift()
    {this->SetCurrentOperation( vtkContourRepresentation::Shift ); }
  void SetCurrentOperationToScale()
    {this->SetCurrentOperation( vtkContourRepresentation::Scale ); }
 
  // Descirption:
  // Set / get the Point Placer. The point placer is
  // responsible for converting display coordinates into
  // world coordinates according to some constraints, and
  // for validating world positions.
  void SetPointPlacer( vtkPointPlacer * );
  vtkGetObjectMacro( PointPlacer, vtkPointPlacer );
 
 
  void SetLineInterpolator( vtkContourLineInterpolator *);
  vtkGetObjectMacro( LineInterpolator, vtkContourLineInterpolator );
 
 
  virtual void BuildRepresentation()=0;
  virtual int ComputeInteractionState(int X, int Y, int modified=0)=0;
  virtual void StartWidgetInteraction(double e[2])=0;
  virtual void WidgetInteraction(double e[2])=0;
 
 
  virtual void ReleaseGraphicsResources(vtkWindow *w)=0;
  virtual int RenderOverlay(vtkViewport *viewport)=0;
  virtual int RenderOpaqueGeometry(vtkViewport *viewport)=0;
  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *viewport)=0;
  virtual int HasTranslucentPolygonalGeometry()=0;
 
 
  void SetClosedLoop( int val );
  vtkGetMacro( ClosedLoop, int );
  vtkBooleanMacro( ClosedLoop, int );
 
 
  virtual void SetShowSelectedNodes(int);
  vtkGetMacro( ShowSelectedNodes, int );
  vtkBooleanMacro( ShowSelectedNodes, int );
 
//BTX
 
  virtual vtkPolyData* GetContourRepresentationAsPolyData() = 0;
//ETX
 
  void GetNodePolyData( vtkPolyData* poly );
 
  vtkSetMacro(RebuildLocator,bool);
 
protected:
  vtkContourRepresentation();
  ~vtkContourRepresentation();
 
  // Selection tolerance for the handles
  int    PixelTolerance;
  double WorldTolerance;
 
  vtkPointPlacer             *PointPlacer;
  vtkContourLineInterpolator *LineInterpolator;
 
  int ActiveNode;
 
  int CurrentOperation;
  int ClosedLoop;
 
  // A flag to indicate whether to show the Selected nodes
  int                   ShowSelectedNodes;
 
  vtkContourRepresentationInternals *Internal;
 
  void AddNodeAtPositionInternal( double worldPos[3],
                                  double worldOrient[9], int displayPos[2] );
  void AddNodeAtPositionInternal( double worldPos[3],
                                  double worldOrient[9], double displayPos[2] );
  void SetNthNodeWorldPositionInternal( int n, double worldPos[3],
                                        double worldOrient[9] );
 
 
  void GetRendererComputedDisplayPositionFromWorldPosition( double worldPos[3],
                                    double worldOrient[9], int displayPos[2] );
  void GetRendererComputedDisplayPositionFromWorldPosition( double worldPos[3],
                                    double worldOrient[9], double displayPos[2] );
 
  virtual void UpdateLines( int index );
  void UpdateLine( int idx1, int idx2 );
 
  virtual int FindClosestPointOnContour( int X, int Y,
                                 double worldPos[3],
                                 int *idx );
 
  virtual void BuildLines()=0;
 
  // This method is called when something changes in the point
  // placer. It will cause all points to
  // be updates, and all lines to be regenerated.
  // Should be extended to detect changes in the line interpolator
  // too.
  virtual int  UpdateContour();
  vtkTimeStamp ContourBuildTime;
 
  void ComputeMidpoint( double p1[3], double p2[3], double mid[3] )
    {
      mid[0] = (p1[0] + p2[0])/2;
      mid[1] = (p1[1] + p2[1])/2;
      mid[2] = (p1[2] + p2[2])/2;
    }
 
  virtual void Initialize( vtkPolyData *, vtkIdList *);
 
  virtual void Initialize( vtkPolyData *);
 
  virtual void InitializeContour( vtkPolyData *, vtkIdList * );
 
  vtkIncrementalOctreePointLocator *Locator;
 
  void ResetLocator();
 
  void BuildLocator();
 
  bool RebuildLocator;
 
 
private:
  vtkContourRepresentation(const vtkContourRepresentation&);  //Not implemented
  void operator=(const vtkContourRepresentation&);  //Not implemented
};
 
#endif