vtkParametricFunction.h 7.88 KB
Newer Older
1 2 3 4 5
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkParametricFunction.h

6
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 8 9
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

10 11
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 13 14
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
/**
 * @class   vtkParametricFunction
 * @brief   abstract interface for parametric functions
 *
 * vtkParametricFunction is an abstract interface for functions
 * defined by parametric mapping i.e. f(u,v,w)->(x,y,z) where
 * u_min <= u < u_max, v_min <= v < v_max, w_min <= w < w_max. (For
 * notational convenience, we will write f(u)->x and assume that
 * u means (u,v,w) and x means (x,y,z).)
 *
 * The interface contains the pure virtual function, Evaluate(), that
 * generates a point and the derivatives at that point which are then used to
 * construct the surface. A second pure virtual function, EvaluateScalar(),
 * can be used to generate a scalar for the surface. Finally, the
 * GetDimension() virtual function is used to differentiate 1D, 2D, and 3D
 * parametric functions. Since this abstract class defines a pure virtual
 * API, its subclasses must implement the pure virtual functions
 * GetDimension(), Evaluate() and EvaluateScalar().
 *
 * This class has also methods for defining a range of parametric values (u,v,w).
 *
 * @par Thanks:
 * Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
 * class.
 *
 * @sa
 * vtkParametricFunctionSource - tessellates a parametric function
 *
 * @sa
 * Implementations of derived classes implementing non-orentable surfaces:
 * vtkParametricBoy vtkParametricCrossCap vtkParametricFigure8Klein
 * vtkParametricKlein vtkParametricMobius vtkParametricRoman
 *
 * @sa
 * Implementations of derived classes implementing orientable surfaces:
 * vtkParametricConicSpiral vtkParametricDini vtkParametricEllipsoid
 * vtkParametricEnneper vtkParametricRandomHills vtkParametricSuperEllipsoid
 * vtkParametricSuperToroid vtkParametricTorus
 *
*/

56 57
#ifndef vtkParametricFunction_h
#define vtkParametricFunction_h
58

59
#include "vtkCommonComputationalGeometryModule.h" // For export macro
60 61
#include "vtkObject.h"

62
class VTKCOMMONCOMPUTATIONALGEOMETRY_EXPORT vtkParametricFunction : public vtkObject
63 64
{
public:
65
  vtkTypeMacro(vtkParametricFunction, vtkObject);
66
  void PrintSelf(ostream& os, vtkIndent indent) override;
67

68 69 70 71 72 73 74 75
  /**
   * Return the dimension of parametric space. Depending on the dimension,
   * then the (u,v,w) parameters and associated information (e.g., derivates)
   * have meaning. For example, if the dimension of the function is one, then
   * u[0] and Duvw[0...2] have meaning.
   * This is a pure virtual function that must be instantiated in
   * a derived class.
   */
76 77
  virtual int GetDimension() = 0;

78 79 80 81 82 83 84 85 86 87 88 89
  /**
   * Performs the mapping \$f(uvw)->(Pt,Duvw)\$f.
   * This is a pure virtual function that must be instantiated in
   * a derived class.

   * uvw are the parameters, with u corresponding to uvw[0],
   * v to uvw[1] and w to uvw[2] respectively. Pt is the returned Cartesian point,
   * Duvw are the derivatives of this point with respect to u, v and w.
   * Note that the first three values in Duvw are Du, the next three are Dv,
   * and the final three are Dw. Du Dv Dw are the partial derivatives of the
   * function at the point Pt with respect to u, v and w respectively.
   */
90
  virtual void Evaluate(double uvw[3], double Pt[3], double Duvw[9]) = 0;
91

92 93 94 95 96
  /**
   * Calculate a user defined scalar using one or all of uvw, Pt, Duvw.
   * This is a pure virtual function that must be instantiated in
   * a derived class.

luz.paz's avatar
luz.paz committed
97
   * uvw are the parameters with Pt being the cartesian point,
98 99 100
   * Duvw are the derivatives of this point with respect to u, v, and w.
   * Pt, Duvw are obtained from Evaluate().
   */
101
  virtual double EvaluateScalar(double uvw[3], double Pt[3], double Duvw[9]) = 0;
102

103 104 105 106
  //@{
  /**
   * Set/Get the minimum u-value.
   */
107 108
  vtkSetMacro(MinimumU,double);
  vtkGetMacro(MinimumU,double);
109
  //@}
110

111 112 113 114
  //@{
  /**
   * Set/Get the maximum u-value.
   */
115 116
  vtkSetMacro(MaximumU,double);
  vtkGetMacro(MaximumU,double);
117
  //@}
118

119 120 121 122
  //@{
  /**
   * Set/Get the minimum v-value.
   */
123 124
  vtkSetMacro(MinimumV,double);
  vtkGetMacro(MinimumV,double);
125
  //@}
126

127 128 129 130
  //@{
  /**
   * Set/Get the maximum v-value.
   */
131 132
  vtkSetMacro(MaximumV,double);
  vtkGetMacro(MaximumV,double);
133
  //@}
134

135 136 137 138
  //@{
  /**
   * Set/Get the minimum w-value.
   */
139 140
  vtkSetMacro(MinimumW,double);
  vtkGetMacro(MinimumW,double);
141
  //@}
142

143 144 145 146
  //@{
  /**
   * Set/Get the maximum w-value.
   */
147 148
  vtkSetMacro(MaximumW,double);
  vtkGetMacro(MaximumW,double);
149
  //@}
150

151 152 153 154
  //@{
  /**
   * Set/Get the flag which joins the first triangle strip to the last one.
   */
155 156 157
  vtkSetClampMacro(JoinU,vtkTypeBool,0,1);
  vtkGetMacro(JoinU,vtkTypeBool);
  vtkBooleanMacro(JoinU,vtkTypeBool);
158
  //@}
159

160 161
  //@{
  /**
luz.paz's avatar
luz.paz committed
162
   * Set/Get the flag which joins the ends of the triangle strips.
163
   */
164 165 166
  vtkSetClampMacro(JoinV, vtkTypeBool, 0, 1);
  vtkGetMacro(JoinV, vtkTypeBool);
  vtkBooleanMacro(JoinV, vtkTypeBool);
167
  //@}
168

169 170
  //@{
  /**
luz.paz's avatar
luz.paz committed
171
   * Set/Get the flag which joins the ends of the triangle strips.
172
   */
173 174 175
  vtkSetClampMacro(JoinW, vtkTypeBool, 0, 1);
  vtkGetMacro(JoinW, vtkTypeBool);
  vtkBooleanMacro(JoinW, vtkTypeBool);
176 177 178 179 180 181 182 183 184
  //@}

  //@{
  /**
   * Set/Get the flag which joins the first triangle strip to
   * the last one with a twist.
   * JoinU must also be set if this is set.
   * Used when building some non-orientable surfaces.
   */
185 186 187
  vtkSetClampMacro(TwistU,vtkTypeBool,0,1);
  vtkGetMacro(TwistU,vtkTypeBool);
  vtkBooleanMacro(TwistU,vtkTypeBool);
188 189 190 191 192 193 194 195 196
  //@}

  //@{
  /**
   * Set/Get the flag which joins the ends of the
   * triangle strips with a twist.
   * JoinV must also be set if this is set.
   * Used when building some non-orientable surfaces.
   */
197 198 199
  vtkSetClampMacro(TwistV, vtkTypeBool, 0, 1);
  vtkGetMacro(TwistV, vtkTypeBool);
  vtkBooleanMacro(TwistV, vtkTypeBool);
200 201 202 203 204 205 206 207 208
  //@}

  //@{
  /**
   * Set/Get the flag which joins the ends of the
   * triangle strips with a twist.
   * JoinW must also be set if this is set.
   * Used when building some non-orientable surfaces.
   */
209 210 211
  vtkSetClampMacro(TwistW, vtkTypeBool, 0, 1);
  vtkGetMacro(TwistW, vtkTypeBool);
  vtkBooleanMacro(TwistW, vtkTypeBool);
212 213 214 215
  //@}

  //@{
  /**
luz.paz's avatar
luz.paz committed
216
   * Set/Get the flag which determines the ordering of the
217 218 219 220 221 222 223
   * vertices forming the triangle strips. The ordering of the
   * points being inserted into the triangle strip is important
   * because it determines the direction of the normals for the
   * lighting. If set, the ordering is clockwise, otherwise the
   * ordering is anti-clockwise. Default is true (i.e. clockwise
   * ordering).
   */
224 225 226
  vtkSetClampMacro(ClockwiseOrdering,vtkTypeBool,0,1);
  vtkGetMacro(ClockwiseOrdering,vtkTypeBool);
  vtkBooleanMacro(ClockwiseOrdering,vtkTypeBool);
227 228 229 230 231 232 233 234
  //@}

  //@{
  /**
   * Set/Get the flag which determines whether derivatives are available
   * from the parametric function (i.e., whether the Evaluate() method
   * returns valid derivatives).
   */
235 236 237
  vtkSetClampMacro(DerivativesAvailable,vtkTypeBool,0,1);
  vtkGetMacro(DerivativesAvailable,vtkTypeBool);
  vtkBooleanMacro(DerivativesAvailable,vtkTypeBool);
238
  //@}
239 240 241

protected:
  vtkParametricFunction();
242
  ~vtkParametricFunction() override;
243 244 245 246 247 248 249 250 251

  // Variables
  double MinimumU;
  double MaximumU;
  double MinimumV;
  double MaximumV;
  double MinimumW;
  double MaximumW;

252 253 254
  vtkTypeBool JoinU;
  vtkTypeBool JoinV;
  vtkTypeBool JoinW;
255

256 257 258
  vtkTypeBool TwistU;
  vtkTypeBool TwistV;
  vtkTypeBool TwistW;
259

260
  vtkTypeBool ClockwiseOrdering;
261

262
  vtkTypeBool DerivativesAvailable;
263 264

private:
265 266
  vtkParametricFunction(const vtkParametricFunction&) = delete;
  void operator=(const vtkParametricFunction&) = delete;
267 268 269 270

};

#endif