/usr/include/vtk-7.1/vtkImplicitFunction.h is in libvtk7-dev 7.1.1+dfsg1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 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 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | /*=========================================================================
Program: Visualization Toolkit
Module: vtkImplicitFunction.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
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.
=========================================================================*/
/**
* @class vtkImplicitFunction
* @brief abstract interface for implicit functions
*
* vtkImplicitFunction specifies an abstract interface for implicit
* functions. Implicit functions are real valued functions defined in 3D
* space, w = F(x,y,z). Two primitive operations are required: the ability to
* evaluate the function, and the function gradient at a given point. The
* implicit function divides space into three regions: on the surface
* (F(x,y,z)=w), outside of the surface (F(x,y,z)>c), and inside the
* surface (F(x,y,z)<c). (When c is zero, positive values are outside,
* negative values are inside, and zero is on the surface. Note also
* that the function gradient points from inside to outside.)
*
* Implicit functions are very powerful. It is possible to represent almost
* any type of geometry with the level sets w = const, especially if you use
* boolean combinations of implicit functions (see vtkImplicitBoolean).
*
* vtkImplicitFunction provides a mechanism to transform the implicit
* function(s) via a vtkAbstractTransform. This capability can be used to
* translate, orient, scale, or warp implicit functions. For example,
* a sphere implicit function can be transformed into an oriented ellipse.
*
* @warning
* The transformation transforms a point into the space of the implicit
* function (i.e., the model space). Typically we want to transform the
* implicit model into world coordinates. In this case the inverse of the
* transformation is required.
*
* @sa
* vtkAbstractTransform vtkSphere vtkCylinder vtkImplicitBoolean vtkPlane
* vtkPlanes vtkQuadric vtkImplicitVolume vtkSampleFunction vtkCutter
* vtkClipPolyData
*/
#ifndef vtkImplicitFunction_h
#define vtkImplicitFunction_h
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
class vtkAbstractTransform;
class VTKCOMMONDATAMODEL_EXPORT vtkImplicitFunction : public vtkObject
{
public:
vtkTypeMacro(vtkImplicitFunction,vtkObject);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
/**
* Overload standard modified time function. If Transform is modified,
* then this object is modified as well.
*/
vtkMTimeType GetMTime() VTK_OVERRIDE;
//@{
/**
* Evaluate function at position x-y-z and return value. Point x[3] is
* transformed through transform (if provided).
*/
double FunctionValue(const double x[3]);
double FunctionValue(double x, double y, double z) {
double xyz[3] = {x, y, z}; return this->FunctionValue(xyz); };
//@}
//@{
/**
* Evaluate function gradient at position x-y-z and pass back vector. Point
* x[3] is transformed through transform (if provided).
*/
void FunctionGradient(const double x[3], double g[3]);
double *FunctionGradient(const double x[3]) {
this->FunctionGradient(x,this->ReturnValue);
return this->ReturnValue; };
double *FunctionGradient(double x, double y, double z) {
double xyz[3] = {x, y, z}; return this->FunctionGradient(xyz); };
//@}
//@{
/**
* Set/Get a transformation to apply to input points before
* executing the implicit function.
*/
virtual void SetTransform(vtkAbstractTransform*);
virtual void SetTransform(const double elements[16]);
vtkGetObjectMacro(Transform,vtkAbstractTransform);
//@}
//@{
/**
* Evaluate function at position x-y-z and return value. You should
* generally not call this method directly, you should use
* FunctionValue() instead. This method must be implemented by
* any derived class.
*/
virtual double EvaluateFunction(double x[3]) = 0;
double EvaluateFunction(double x, double y, double z) {
double xyz[3] = {x, y, z}; return this->EvaluateFunction(xyz); };
//@}
/**
* Evaluate function gradient at position x-y-z and pass back vector.
* You should generally not call this method directly, you should use
* FunctionGradient() instead. This method must be implemented by
* any derived class.
*/
virtual void EvaluateGradient(double x[3], double g[3]) = 0;
protected:
vtkImplicitFunction();
~vtkImplicitFunction() VTK_OVERRIDE;
vtkAbstractTransform *Transform;
double ReturnValue[3];
private:
vtkImplicitFunction(const vtkImplicitFunction&) VTK_DELETE_FUNCTION;
void operator=(const vtkImplicitFunction&) VTK_DELETE_FUNCTION;
};
#endif
|