vtkCurveGenerator.h

Go to the documentation of this file.

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

  Program: 3D Slicer

  Copyright (c) Kitware Inc.

  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.

  This file was originally developed by Thomas Vaughan, PerkLab, Queen's University.

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

#ifndef __vtkCurveGenerator_h
#define __vtkCurveGenerator_h

// vtk includes
#include <vtkParametricFunction.h>
#include <vtkPointLocator.h>
#include <vtkPolyData.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkSetGet.h>
#include <vtkSmartPointer.h>

class vtkSlicerDijkstraGraphGeodesicPath;
class vtkDoubleArray;
class vtkPoints;
class vtkSpline;

// export
#include "vtkSlicerMarkupsModuleMRMLExport.h"

class VTK_SLICER_MARKUPS_MODULE_MRML_EXPORT vtkCurveGenerator : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkCurveGenerator, vtkPolyDataAlgorithm);
  static vtkCurveGenerator* New();

  void PrintSelf(ostream& os, vtkIndent indent) override;

  vtkSetMacro(CurveIsClosed, bool);
  vtkGetMacro(CurveIsClosed, bool);
  vtkBooleanMacro(CurveIsClosed, bool);

  void SetCurveIsLoop(bool loop) { this->SetCurveIsClosed(loop); }
  void CurveIsLoopOn() { this->SetCurveIsClosed(true); }
  void CurveIsLoopOff() { this->SetCurveIsClosed(false); }
  bool GetCurveIsLoop() { return this->GetCurveIsClosed(); }

  enum
    {
    CURVE_TYPE_LINEAR_SPLINE = 0, // Curve interpolates between input points with straight lines
    CURVE_TYPE_CARDINAL_SPLINE, // Curve interpolates between input points smoothly
    CURVE_TYPE_KOCHANEK_SPLINE, // Curve interpolates between input points smoothly, generalized
    CURVE_TYPE_POLYNOMIAL, // Curve approximates the input points with a polynomial fit
    CURVE_TYPE_SHORTEST_DISTANCE_ON_SURFACE, // Curve finds the closest path along a the edges of a surface mesh
    CURVE_TYPE_LAST // Valid types go above this line
    };
  vtkGetMacro(CurveType, int);
  vtkSetMacro(CurveType, int);
  static const char* GetCurveTypeAsString(int id);
  static int GetCurveTypeFromString(const char* name);
  void SetCurveTypeToLinearSpline() { this->SetCurveType(CURVE_TYPE_LINEAR_SPLINE); }
  void SetCurveTypeToCardinalSpline() { this->SetCurveType(CURVE_TYPE_CARDINAL_SPLINE); }
  void SetCurveTypeToKochanekSpline() { this->SetCurveType(CURVE_TYPE_KOCHANEK_SPLINE); }
  void SetCurveTypeToPolynomial() { this->SetCurveType(CURVE_TYPE_POLYNOMIAL); }
  void SetCurveTypeToShortestDistanceOnSurface() { this->SetCurveType(CURVE_TYPE_SHORTEST_DISTANCE_ON_SURFACE); }

  virtual bool IsInterpolatingCurve();

  vtkSetMacro(NumberOfPointsPerInterpolatingSegment, int);
  vtkGetMacro(NumberOfPointsPerInterpolatingSegment, int);

  vtkGetMacro(KochanekBias, double);
  vtkSetMacro(KochanekBias, double);

  vtkGetMacro(KochanekContinuity, double);
  vtkSetMacro(KochanekContinuity, double);

  vtkGetMacro(KochanekTension, double);
  vtkSetMacro(KochanekTension, double);

  vtkGetMacro(KochanekEndsCopyNearestDerivatives, bool);
  vtkSetMacro(KochanekEndsCopyNearestDerivatives, bool);

  vtkGetMacro(PolynomialOrder, int);
  vtkSetMacro(PolynomialOrder, int);

  // Wednesday May 9, 2018 TODO
  // InputParameters is currently computed by this class depending on the
  // value of PolynomialPointSortingMethod, and is only supported for polynomials.
  // In the future this could be expanded to support splines, and to allow
  // the user to specify their own parameters (make a SetInputParameters function)
  // e.g. through functions below
  // Set the parameter values (e.g. point distances) that the curve should be based on
  //virtual void SetInputParameters( vtkDoubleArray* );
  //virtual vtkDoubleArray* GetInputParameters();

  enum
    {
    SORTING_METHOD_INDEX = 0,
    SORTING_METHOD_MINIMUM_SPANNING_TREE_POSITION,
    SORTING_METHOD_LAST // valid types should be written above this line
    };
  vtkGetMacro(PolynomialPointSortingMethod, int);
  vtkSetMacro(PolynomialPointSortingMethod, int);
  static const char* GetPolynomialPointSortingMethodAsString(int id);
  static int GetPolynomialPointSortingMethodFromString(const char* name);
  void SetPolynomialPointSortingMethodToIndex() { this->SetPolynomialPointSortingMethod(vtkCurveGenerator::SORTING_METHOD_INDEX); }
  void SetPolynomialPointSortingMethodToMinimumSpanningTreePosition()
    {
    this->SetPolynomialPointSortingMethod(vtkCurveGenerator::SORTING_METHOD_MINIMUM_SPANNING_TREE_POSITION);
    }

  enum
    {
    POLYNOMIAL_FIT_METHOD_GLOBAL_LEAST_SQUARES = 0,
    POLYNOMIAL_FIT_METHOD_MOVING_LEAST_SQUARES,
    POLYNOMIAL_FIT_METHOD_LAST // Valid types go above this line
    };
  vtkGetMacro(PolynomialFitMethod, double);
  vtkSetMacro(PolynomialFitMethod, double);
  static const char* GetPolynomialFitMethodAsString(int id);
  static int GetPolynomialFitMethodFromString(const char* name);
  void SetPolynomialFitMethodToGlobalLeastSquares() { this->SetPolynomialFitMethod(vtkCurveGenerator::POLYNOMIAL_FIT_METHOD_GLOBAL_LEAST_SQUARES); }
  void SetPolynomialFitMethodToMovingLeastSquares() { this->SetPolynomialFitMethod(vtkCurveGenerator::POLYNOMIAL_FIT_METHOD_MOVING_LEAST_SQUARES); }

  vtkGetMacro(PolynomialSampleWidth, double);
  vtkSetMacro(PolynomialSampleWidth, double);

  enum
    {
    POLYNOMIAL_WEIGHT_FUNCTION_RECTANGULAR = 0,
    POLYNOMIAL_WEIGHT_FUNCTION_TRIANGULAR,
    POLYNOMIAL_WEIGHT_FUNCTION_COSINE,
    POLYNOMIAL_WEIGHT_FUNCTION_GAUSSIAN,
    POLYNOMIAL_WEIGHT_FUNCTION_LAST // Valid types go above this line
    };
  vtkGetMacro(PolynomialWeightFunction, double);
  vtkSetMacro(PolynomialWeightFunction, double);
  static const char* GetPolynomialWeightFunctionAsString(int id);
  static int GetPolynomialWeightFunctionFromString(const char* name);
  void SetPolynomialWeightFunctionToRectangular() { this->SetPolynomialWeightFunction(vtkCurveGenerator::POLYNOMIAL_WEIGHT_FUNCTION_RECTANGULAR); }
  void SetPolynomialWeightFunctionToTriangular() { this->SetPolynomialWeightFunction(vtkCurveGenerator::POLYNOMIAL_WEIGHT_FUNCTION_TRIANGULAR); }
  void SetPolynomialWeightFunctionToCosine() { this->SetPolynomialWeightFunction(vtkCurveGenerator::POLYNOMIAL_WEIGHT_FUNCTION_COSINE); }
  void SetPolynomialWeightFunctionToGaussian() { this->SetPolynomialWeightFunction(vtkCurveGenerator::POLYNOMIAL_WEIGHT_FUNCTION_GAUSSIAN); }

  int GetSurfaceCostFunctionType();
  void SetSurfaceCostFunctionType(int surfaceCostFunctionType);

  vtkIdType GetControlPointIdFromInterpolatedPointId(vtkIdType interpolatedPointId);

  vtkIdList* GetSurfacePointIds();

  double GetOutputCurveLength();

  vtkParametricFunction* GetParametricFunction() { return this->ParametricFunction.GetPointer(); };

  void SetInputPoints(vtkPoints* points);

  vtkPoints* GetOutputPoints();

  static void SortByIndex(vtkPoints* inputPoints, vtkDoubleArray* outputParameters);

  static void SortByMinimumSpanningTreePosition(vtkPoints* inputPoints, vtkDoubleArray* outputParameters);

protected:
  // input parameters
  int NumberOfPointsPerInterpolatingSegment;
  int CurveType;
  bool CurveIsClosed;
  double KochanekBias;
  double KochanekContinuity;
  double KochanekTension;
  bool KochanekEndsCopyNearestDerivatives;
  int PolynomialOrder;
  int PolynomialPointSortingMethod;
  int PolynomialFitMethod;
  double PolynomialSampleWidth;
  int PolynomialWeightFunction;
  std::vector<vtkIdType> InterpolatedPointIdsForControlPoints;

  // internal storage
  vtkSmartPointer<vtkPointLocator> SurfacePointLocator;
  vtkSmartPointer<vtkSlicerDijkstraGraphGeodesicPath> SurfacePathFilter;
  vtkSmartPointer<vtkDoubleArray> InputParameters;
  vtkSmartPointer<vtkParametricFunction> ParametricFunction;

  // output
  double OutputCurveLength;

  // logic
  void SetParametricFunctionToSpline(vtkPoints* inputPoints, vtkSpline* xSpline, vtkSpline* ySpline, vtkSpline* zSpline);
  void SetParametricFunctionToLinearSpline(vtkPoints* inputPoints);
  void SetParametricFunctionToCardinalSpline(vtkPoints* inputPoints);
  void SetParametricFunctionToKochanekSpline(vtkPoints* inputPoints);
  void SetParametricFunctionToPolynomial(vtkPoints* inputPoints);
  int GeneratePoints(vtkPoints* inputPoints, vtkPolyData* inputSurface, vtkPolyData* outputPolyData);
  int GeneratePointsFromFunction(vtkPoints* inputPoints, vtkPoints* outputPoints, vtkDoubleArray* outputPedigreeIdArray);
  int GeneratePointsFromSurface(vtkPoints* inputPoints, vtkPolyData* inputSurface, vtkPoints* outputPoints, vtkDoubleArray* outputPedigreeIdArray);
  int GenerateLines(vtkPolyData* polyData);

  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector, vtkInformationVector* outputVector) override;

protected:
  vtkCurveGenerator();
  ~vtkCurveGenerator() override;
  vtkCurveGenerator(const vtkCurveGenerator&) = delete;
  void operator=(const vtkCurveGenerator&) = delete;
};

#endif