vtkContourRepresentation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkContourRepresentation_h
#define vtkContourRepresentation_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkWidgetRepresentation.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
#include <vector>             // STL Header; Required for vector
 
VTK_ABI_NAMESPACE_BEGIN
class vtkContourLineInterpolator;
class vtkIncrementalOctreePointLocator;
class vtkPointPlacer;
class vtkPolyData;
class vtkIdList;
 
//----------------------------------------------------------------------
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();
  }
};
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkContourRepresentation
  : public vtkWidgetRepresentation
{
  friend class vtkContourWidget;
 
public:
 
  vtkTypeMacro(vtkContourRepresentation, vtkWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  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);
 
  // Description:
  // 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]);
 
  virtual vtkContourRepresentationNode* GetNthNode(int n);
 
  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]);
 
  // Description:
  // 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);
 
  // Used to communicate about the state of the representation
  enum
  {
    Outside = 0,
    Nearby
  };
 
  enum
  {
    Inactive = 0,
    Translate,
    Shift,
    Scale
  };
 
 
  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); }
 
  // Description:
  // 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);
 
 
  void BuildRepresentation() override = 0;
  int ComputeInteractionState(int X, int Y, int modified = 0) override = 0;
  void StartWidgetInteraction(double e[2]) override = 0;
  void WidgetInteraction(double e[2]) override = 0;
 
 
  void ReleaseGraphicsResources(vtkWindow* w) override = 0;
  int RenderOverlay(vtkViewport* viewport) override = 0;
  int RenderOpaqueGeometry(vtkViewport* viewport) override = 0;
  int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override = 0;
  vtkTypeBool HasTranslucentPolygonalGeometry() override = 0;
 
 
  void SetClosedLoop(vtkTypeBool val);
  vtkGetMacro(ClosedLoop, vtkTypeBool);
  vtkBooleanMacro(ClosedLoop, vtkTypeBool);
 
 
  virtual void SetShowSelectedNodes(vtkTypeBool);
  vtkGetMacro(ShowSelectedNodes, vtkTypeBool);
  vtkBooleanMacro(ShowSelectedNodes, vtkTypeBool);
 
  virtual vtkPolyData* GetContourRepresentationAsPolyData() = 0;
 
  void GetNodePolyData(vtkPolyData* poly);
 
  vtkSetMacro(RebuildLocator, bool);
 
protected:
  vtkContourRepresentation();
  ~vtkContourRepresentation() override;
 
  // Selection tolerance for the handles
  int PixelTolerance;
  double WorldTolerance;
 
  vtkPointPlacer* PointPlacer;
  vtkContourLineInterpolator* LineInterpolator;
 
  int ActiveNode;
 
  int CurrentOperation;
  vtkTypeBool ClosedLoop;
 
  // A flag to indicate whether to show the Selected nodes
  vtkTypeBool 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 updated, and all lines to be regenerated.
  // It 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&) = delete;
  void operator=(const vtkContourRepresentation&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif