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 vtkProjectMarkupsCurvePointsFilter;
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/MarkupsOpenCurve.png";}
  const char* GetAddIcon() override {return ":/Icons/MarkupsCurveMouseModePlace.png";}
  const char* GetPlaceAddIcon() override {return ":/Icons/MarkupsCurveMouseModePlaceAdd.png";}

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

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

  const char* GetMarkupType() override {return "Curve";};

  // Get markup type GUI display name
  const char* GetTypeDisplayName() override {return "Curve";};

  const char* GetDefaultNodeNamePrefix() override {return "OC";};

  void ReadXMLAttributes( const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsCurveNode);

  vtkPoints* GetCurvePointsWorld() override;
  vtkPolyData* GetCurveWorld() override;
  vtkAlgorithmOutput* GetCurveWorldConnection() override;

  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);

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

  void ResampleCurveWorld(double controlPointDistance);

  // If pedigreeIdsArray is specified then the method returns the fractional point index of the original point for each new point.
  // Fractional point index is a value between the point indices of the two original points it was between, the fractional part
  // specifies the distance from those two points. It can be used for interpolating point data.
  static bool ResamplePoints(vtkPoints* originalPoints, vtkPoints* interpolatedPoints,
    double samplingDistance, bool closedCurve, vtkDoubleArray* pedigreeIdsArray=nullptr);

  static bool ResampleStaticControlPointMeasurements(vtkCollection* measurements, vtkDoubleArray* curvePointsPedigreeIdsArray, int curvePointsPerControlPoint);

  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 this->GetSurfaceConstraintNodeReferenceRole(); }
  const char* GetShortestDistanceSurfaceNodeReferenceMRMLAttributeName() { return this->GetSurfaceConstraintNodeReferenceMRMLAttributeName(); }

  const char* GetSurfaceConstraintNodeReferenceRole() { return "shortestDistanceSurface"; }
  const char* GetSurfaceConstraintNodeReferenceMRMLAttributeName() { return "shortestDistanceSurfaceRef"; };

  void SetAndObserveShortestDistanceSurfaceNode(vtkMRMLModelNode* modelNode) { this->SetAndObserveSurfaceConstraintNode(modelNode); }
  vtkMRMLModelNode* GetShortestDistanceSurfaceNode() { return this->GetSurfaceConstraintNode(); }

  void SetAndObserveSurfaceConstraintNode(vtkMRMLModelNode* modelNode);
  vtkMRMLModelNode* GetSurfaceConstraintNode();

  void SetSurfaceConstraintMaximumSearchRadiusTolerance(double tolerance);
  double GetSurfaceConstraintMaximumSearchRadiusTolerance() const;

  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;
  vtkSmartPointer<vtkPassThroughFilter> WorldOutput;
  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);

private:
  vtkSmartPointer<vtkProjectMarkupsCurvePointsFilter> ProjectPointsFilter;
};

#endif