vtkCurvatures.h 5.19 KB
Newer Older
1 2 3 4 5
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkCurvatures.h

6
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 8 9 10 11 12 13 14
  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.

=========================================================================*/
15 16 17 18 19 20 21 22 23
/**
 * @class   vtkCurvatures
 * @brief   compute curvatures (Gauss and mean) of a Polydata object
 *
 * vtkCurvatures takes a polydata input and computes the curvature of the
 * mesh at each point. Four possible methods of computation are available :
 *
 * Gauss Curvature
 * discrete Gauss curvature (K) computation,
24 25 26
 * \f$K(\text{vertex v}) = 2*\pi - \sum_{\text{facet neighbs f of v}} (\text{angle_f at v})\f$.
 * The contribution of every facet is for the moment weighted by \f$Area(facet)/3\f$.
 * The units of Gaussian Curvature are \f$[1/m^2]\f$.
27 28
 *
 * Mean Curvature
29 30 31
 * \f$H(vertex v) = \text{average over edges neighbs e of H(e)}\f$,
 * \f$H(edge e) = length(e) * dihedral\_angle(e)\f$.
 *
32 33
 * NB: dihedral_angle is the ORIENTED angle between -PI and PI,
 * this means that the surface is assumed to be orientable
34 35
 * the computation creates the orientation.
 * The units of Mean Curvature are [1/m].
36
 *
37 38 39 40 41 42 43 44
 * Maximum (\f$k_\max\f$) and Minimum (\f$k_\min\f$) Principal Curvatures
 * \f$k_\max = H + \sqrt{H^2 - K}\f$,
 * \f$k_\min = H - \sqrt{H^2 - K}\f$
 * Excepting spherical and planar surfaces which have equal principal
 * curvatures, the curvature at a point on a surface varies with the direction
 * one "sets off" from the point. For all directions, the curvature will pass
 * through two extrema: a minimum (\f$k_\min\f$) and a maximum (\f$k_\max\f$)
 * which occur at mutually orthogonal directions to each other.
45
 *
46 47 48 49
 * NB. The sign of the Gauss curvature is a geometric invariant, it should be
 * positive when the surface looks like a sphere, negative when it looks like a
 * saddle, however the sign of the Mean curvature is not, it depends on the
 * convention for normals. This code assumes that normals point outwards (i.e.
50 51 52 53 54 55 56 57 58 59 60 61 62
 * from the surface of a sphere outwards). If a given mesh produces curvatures
 * of opposite senses then the flag InvertMeanCurvature can be set and the
 * Curvature reported by the Mean calculation will be inverted.
 *
 * @par Thanks:
 * Philip Batchelor philipp.batchelor@kcl.ac.uk for creating and contributing
 * the class and Andrew Maclean a.maclean@acfr.usyd.edu.au for cleanups and
 * fixes. Thanks also to Goodwin Lawlor for contributing patch to calculate
 * principal curvatures
 *
 *
 *
*/
63

64 65
#ifndef vtkCurvatures_h
#define vtkCurvatures_h
66

67
#include "vtkFiltersGeneralModule.h" // For export macro
68
#include "vtkPolyDataAlgorithm.h"
69 70 71

#define VTK_CURVATURE_GAUSS 0
#define VTK_CURVATURE_MEAN  1
72 73
#define VTK_CURVATURE_MAXIMUM 2
#define VTK_CURVATURE_MINIMUM 3
74

75
class VTKFILTERSGENERAL_EXPORT vtkCurvatures : public vtkPolyDataAlgorithm
76 77
{
public:
78
  vtkTypeMacro(vtkCurvatures,vtkPolyDataAlgorithm);
79
  void PrintSelf(ostream& os, vtkIndent indent) override;
80

81 82 83
  /**
   * Construct with curvature type set to Gauss
   */
84 85
  static vtkCurvatures *New();

86 87 88 89 90 91 92 93
  //@{
  /**
   * Set/Get Curvature type
   * VTK_CURVATURE_GAUSS: Gaussian curvature, stored as
   * DataArray "Gauss_Curvature"
   * VTK_CURVATURE_MEAN : Mean curvature, stored as
   * DataArray "Mean_Curvature"
   */
94 95 96 97 98 99
  vtkSetMacro(CurvatureType,int);
  vtkGetMacro(CurvatureType,int);
  void SetCurvatureTypeToGaussian()
  { this->SetCurvatureType(VTK_CURVATURE_GAUSS); }
  void SetCurvatureTypeToMean()
  { this->SetCurvatureType(VTK_CURVATURE_MEAN); }
100 101 102 103
  void SetCurvatureTypeToMaximum()
  { this->SetCurvatureType(VTK_CURVATURE_MAXIMUM); }
  void SetCurvatureTypeToMinimum()
  { this->SetCurvatureType(VTK_CURVATURE_MINIMUM); }
104
  //@}
105

106 107 108 109 110
  //@{
  /**
   * Set/Get the flag which inverts the mean curvature calculation for
   * meshes with inward pointing normals (default false)
   */
111 112 113
  vtkSetMacro(InvertMeanCurvature,vtkTypeBool);
  vtkGetMacro(InvertMeanCurvature,vtkTypeBool);
  vtkBooleanMacro(InvertMeanCurvature,vtkTypeBool);
114 115
  //@}

116 117 118 119
protected:
  vtkCurvatures();

  // Usual data generation method
120
  int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override;
121

122 123 124 125
  /**
   * discrete Gauss curvature (K) computation,
   * cf http://www-ipg.umds.ac.uk/p.batchelor/curvatures/curvatures.html
   */
126
  void GetGaussCurvature(vtkPolyData *output);
127 128 129

  // discrete Mean curvature (H) computation,
  // cf http://www-ipg.umds.ac.uk/p.batchelor/curvatures/curvatures.html
130
  void GetMeanCurvature(vtkPolyData *output);
131

132 133 134
  /**
   * Maximum principal curvature \f$k_max = H + sqrt(H^2 -K)\f$
   */
135
  void GetMaximumCurvature(vtkPolyData *input, vtkPolyData *output);
136

137 138 139
  /**
   * Minimum principal curvature \f$k_min = H - sqrt(H^2 -K)\f$
   */
140
  void GetMinimumCurvature(vtkPolyData *input, vtkPolyData *output);
141

142 143 144

  // Vars
  int CurvatureType;
145
  vtkTypeBool InvertMeanCurvature;
146 147

private:
148 149
  vtkCurvatures(const vtkCurvatures&) = delete;
  void operator=(const vtkCurvatures&) = delete;
150 151 152 153 154 155

};

#endif