/usr/include/vtk-7.1/vtkInterpolationKernel.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 135 136 137 138 139 140 | /*=========================================================================
Program: Visualization Toolkit
Module: vtkInterpolationKernel.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 vtkInterpolationKernel
* @brief base class for interpolation kernels
*
*
* vtkInterpolationKernel specifies an abstract interface for interpolation
* kernels. An interpolation kernel is used to produce an interpolated data
* value at a point X from the points + data in a local neighborhood
* surounding X. For example, given the N nearest points surrounding X, the
* interpolation kernel provides N weights, which when combined with the N
* data values associated with these nearest points, produces an interpolated
* data value at point X.
*
* Note that various kernel initialization methods are provided. The basic
* method requires providing a point locator to accelerate neigborhood
* queries. Some kernels may refer back to the original dataset, or the point
* attribute data associated with the dataset. The initialization method
* enables different styles of initialization and is kernel-dependent.
*
* Typically the kernels are invoked in two parts: first, the basis is
* computed using the supplied point locator and dataset. This basis is a
* local footprint of point surrounding a poitnX. In this footprint are the
* neighboring points used to compute the interpolation weights. Then, the
* weights are computed from points forming the basis. However, advanced
* users can develop their own basis, skipping the ComputeBasis() method, and
* then invoke ComputeWeights() directly.
*
* @warning
* The ComputeBasis() and ComputeWeights() methods must be thread safe as they
* are used in threaded algorithms.
*
* @sa
* vtkPointInterpolator vtkPointInterpolator2D vtkGeneralizedKernel
* vtkGaussianKernel vtkSPHKernel vtkShepardKernel vtkVoronoiKernel
*/
#ifndef vtkInterpolationKernel_h
#define vtkInterpolationKernel_h
#include "vtkFiltersPointsModule.h" // For export macro
#include "vtkObject.h"
class vtkAbstractPointLocator;
class vtkIdList;
class vtkDoubleArray;
class vtkDataSet;
class vtkPointData;
class VTKFILTERSPOINTS_EXPORT vtkInterpolationKernel : public vtkObject
{
public:
//@{
/**
* Standard method for type and printing.
*/
vtkAbstractTypeMacro(vtkInterpolationKernel, vtkObject);
void PrintSelf(ostream& os, vtkIndent indent);
//@}
/**
* Initialize the kernel. Pass information into the kernel that is
* necessary to subsequently perform evaluation. The locator refers to the
* points that are to be interpolated from; these points (ds) and the
* associated point data (pd) are provided as well. Note that some kernels
* may require manual setup / initialization, in which case set
* RequiresInitialization to false, do not call Initialize(), and of course
* manually initialize the kernel.
*/
virtual void Initialize(vtkAbstractPointLocator *loc, vtkDataSet *ds,
vtkPointData *pd);
//@{
/**
* Indicate whether the kernel needs initialization. By default this data
* member is true, and using classes will invoke Initialize() on the
* kernel. However, if the user takes over initialization manually, then
* set RequiresInitialization to false (0).
*/
vtkSetMacro(RequiresInitialization, bool);
vtkGetMacro(RequiresInitialization, bool);
vtkBooleanMacro(RequiresInitialization, bool);
//@}
/**
* Given a point x (and optional associated point id), determine the points
* around x which form an interpolation basis. The user must provide the
* vtkIdList pIds, which will be dynamically resized as necessary. The
* method returns the number of points in the basis. Typically this method
* is called before ComputeWeights(). Note that ptId is optional in most
* cases, although in some kernels it is used to facilitate basis
* computation.
*/
virtual vtkIdType ComputeBasis(double x[3], vtkIdList *pIds, vtkIdType ptId=0) = 0;
/**
* Given a point x, and a list of basis points pIds, compute interpolation
* weights associated with these basis points. Note that both the nearby
* basis points list pIds and the weights array are provided by the caller
* of the method, and may be dynamically resized as necessary. The method
* returns the number of weights (pIds may be resized in some
* cases). Typically this method is called after ComputeBasis(), although
* advanced users can invoke ComputeWeights() and provide the interpolation
* basis points pIds directly.
*/
virtual vtkIdType ComputeWeights(double x[3], vtkIdList *pIds,
vtkDoubleArray *weights) = 0;
protected:
vtkInterpolationKernel();
~vtkInterpolationKernel();
bool RequiresInitialization;
vtkAbstractPointLocator *Locator;
vtkDataSet *DataSet;
vtkPointData *PointData;
// Just clear out the data. Can be overloaded by subclasses as necessary.
virtual void FreeStructures();
private:
vtkInterpolationKernel(const vtkInterpolationKernel&) VTK_DELETE_FUNCTION;
void operator=(const vtkInterpolationKernel&) VTK_DELETE_FUNCTION;
};
#endif
|