vtkMRMLMarkupsCurveNode.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 __vtkMRMLMarkupsCurveNode_h
#define __vtkMRMLMarkupsCurveNode_h

// MRML includes
#include "vtkMRMLDisplayableNode.h"
#include "vtkMRMLModelNode.h"

// Markups includes
#include "vtkSlicerMarkupsModuleMRMLExport.h"
#include "vtkMRMLMarkupsDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"

// VTK includes
#include <vtkStringArray.h>

// std includes
#include <vector>

class vtkArrayCalculator;
class vtkAssignAttribute;
class vtkCallbackCommand;
class vtkCleanPolyData;
class vtkCurveMeasurementsCalculator;
class vtkPassThroughFilter;
class vtkPlane;
class vtkTransformPolyDataFilter;
class vtkTriangleFilter;

class  VTK_SLICER_MARKUPS_MODULE_MRML_EXPORT vtkMRMLMarkupsCurveNode : public vtkMRMLMarkupsNode
{
public:
  static vtkMRMLMarkupsCurveNode *New();
  vtkTypeMacro(vtkMRMLMarkupsCurveNode,vtkMRMLMarkupsNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  const char* GetIcon() override {return ":/Icons/MarkupsCurveMouseModePlace.png";}

  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------

  vtkMRMLNode* CreateNodeInstance() override;
  const char* GetNodeTagName() override {return "MarkupsCurve";}

  void ReadXMLAttributes( const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsCurveNode);

  vtkPoints* GetCurvePointsWorld();

  double GetCurveLengthWorld(vtkIdType startCurvePointIndex=0, vtkIdType numberOfCurvePoints=-1);

  static double GetCurveLength(vtkPoints* curvePoints, bool closedCurve, vtkIdType startCurvePointIndex=0, vtkIdType numberOfCurvePoints=-1);

  double GetCurveLengthBetweenStartEndPointsWorld(vtkIdType startCurvePointIndex, vtkIdType endCurvePointIndex);

  bool SetControlPointLabels(vtkStringArray* labels, vtkPoints* points);

  bool ResampleCurveSurface(double controlPointDistance, vtkMRMLModelNode* node, double maximumSearchRadius=.25);

  static bool ConstrainPointsToSurface(vtkPoints* originalPoints, vtkPoints* normalVectors, vtkPolyData* surfacePolydata,
    vtkPoints* surfacePoints, double maximumSearchRadius=.25);

  void ResampleCurveWorld(double controlPointDistance);

  static bool ResamplePoints(vtkPoints* originalPoints, vtkPoints* interpolatedPoints, double samplingDistance, bool closedCurve);

  bool GetSampledCurvePointsBetweenStartEndPointsWorld(vtkPoints* sampledPoints,
    double samplingDistance, vtkIdType startCurvePointIndex, vtkIdType endCurvePointIndex);

  vtkIdType GetClosestCurvePointIndexToPositionWorld(const double posWorld[3]);

  vtkIdType GetClosestPointPositionAlongCurveWorld(const double posWorld[3], double closestPosWorld[3]);

  vtkIdType GetFarthestCurvePointIndexToPositionWorld(const double posWorld[3]);

  vtkIdType GetCurvePointIndexFromControlPointIndex(int controlPointIndex);

  static bool GetPositionAndClosestPointIndexAlongCurve(double foundCurvePosition[3], vtkIdType& foundClosestPointIndex,
    vtkIdType startCurvePointId, double distanceFromStartPoint, vtkPoints* curvePoints, bool closedCurve);

  vtkIdType GetCurvePointIndexAlongCurveWorld(vtkIdType startCurvePointId, double distanceFromStartPoint);

  bool GetPositionAlongCurveWorld(double foundCurvePosition[3], vtkIdType startCurvePointId, double distanceFromStartPoint);

  bool GetCurveDirectionAtPointIndexWorld(vtkIdType curvePointIndex, double directionVectorWorld[3]);

  bool GetCurvePointToWorldTransformAtPointIndex(vtkIdType curvePointIndex, vtkMatrix4x4* curvePointToWorld);

  bool GetPointsOnPlaneWorld(vtkPlane* plane, vtkPoints* intersectionPoints);

  int GetCurveType();
  void SetCurveType(int type);
  const char* GetCurveTypeAsString(int id);
  int GetCurveTypeFromString(const char* name);
  void SetCurveTypeToLinear();
  void SetCurveTypeToCardinalSpline();
  void SetCurveTypeToKochanekSpline();
  void SetCurveTypeToPolynomial();
  void SetCurveTypeToShortestDistanceOnSurface(vtkMRMLModelNode* modelNode=nullptr);

  const char* GetShortestDistanceSurfaceNodeReferenceRole() { return "shortestDistanceSurface"; };
  const char* GetShortestDistanceSurfaceNodeReferenceMRMLAttributeName() { return "shortestDistanceSurfaceRef"; };

  void SetAndObserveShortestDistanceSurfaceNode(vtkMRMLModelNode* modelNode);
  vtkMRMLModelNode* GetShortestDistanceSurfaceNode();

  int GetSurfaceCostFunctionType();
  void SetSurfaceCostFunctionType(int surfaceCostFunctionType);
  static const char* GetSurfaceCostFunctionTypeAsString(int surfaceCostFunctionType);
  static int GetSurfaceCostFunctionTypeFromString(const char* name);

  const char* GetSurfaceDistanceWeightingFunction();
  void SetSurfaceDistanceWeightingFunction(const char* function);

  int GetNumberOfPointsPerInterpolatingSegment();
  void SetNumberOfPointsPerInterpolatingSegment(int pointsPerSegment);

  virtual void UpdateAssignedAttribute() override;

protected:
  vtkSmartPointer<vtkCleanPolyData> CleanFilter;
  vtkSmartPointer<vtkTriangleFilter> TriangleFilter;
  vtkSmartPointer<vtkTransformPolyDataFilter> SurfaceToLocalTransformer;
  vtkSmartPointer<vtkArrayCalculator> SurfaceScalarCalculator;
  vtkSmartPointer<vtkPassThroughFilter> SurfaceScalarPassThroughFilter;
  vtkSmartPointer<vtkCurveMeasurementsCalculator> CurveMeasurementsCalculator;
  const char* ShortestDistanceSurfaceActiveScalar;

  vtkSmartPointer<vtkAssignAttribute> ScalarDisplayAssignAttribute;

  vtkCallbackCommand* CurvatureMeasurementModifiedCallbackCommand;

protected:
  void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData) override;
  void OnNodeReferenceAdded(vtkMRMLNodeReference* reference) override;
  void OnNodeReferenceModified(vtkMRMLNodeReference* reference) override;
  void OnNodeReferenceRemoved(vtkMRMLNodeReference* reference) override;

  virtual void UpdateSurfaceScalarVariables();
  virtual void OnSurfaceModelNodeChanged();
  virtual void OnSurfaceModelTransformChanged();

  vtkMRMLMarkupsCurveNode();
  ~vtkMRMLMarkupsCurveNode() override;
  vtkMRMLMarkupsCurveNode(const vtkMRMLMarkupsCurveNode&);
  void operator=(const vtkMRMLMarkupsCurveNode&);

  void UpdateMeasurementsInternal() override;

  static void OnCurvatureMeasurementModified(vtkObject* caller, unsigned long eid, void* clientData, void* callData);
};

#endif