This file is indexed.

/usr/include/vtk-5.8/vtkTemporalInterpolator.h is in libvtk5-dev 5.8.0-5.

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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkTemporalInterpolator.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.

=========================================================================*/
// .NAME vtkTemporalInterpolator - interpolate datasets between time steps to produce a new dataset
// .SECTION Description
// vtkTemporalInterpolator interpolates between two time steps to
// produce new data for an arbitrary T.
// vtkTemporalInterpolator has three modes of operation. 
// The default mode is to produce a continuous range of time 
// values as output, which enables a filter downstream to request 
// any value of T within the range. 
// The second mode of operation is enabled by setting
// DiscreteTimeStepInterval to a non zero value. When this mode is
// activated, the filter will report a finite number of Time steps
// separated by deltaT between the original range of values.
// This mode is useful when a dataset of N time steps has one (or more)
// missing datasets for certain T values and you simply wish to smooth
// over the missing steps but otherwise use the original data.
// The third mode of operation is enabled by setting
// ResampleFactor to a non zero positive integer value. 
// When this mode is activated, the filter will report a finite number 
// of Time steps which contain the original steps, plus N new values between
// each original step 1/ResampleFactor time units apart.
// Note that if the input time steps are irregular, then using ResampleFactor
// will produce an irregular sequence of regular steps between 
// each of the original irregular steps (clear enough, yes?).
//
// @TODO
// Higher order interpolation schemes will require changes to the API
// as most calls assume only two timesteps are used.

// .SECTION Thanks
// Ken Martin (Kitware) and John Bidiscombe of 
// CSCS - Swiss National Supercomputing Centre
// for creating and contributing this class.
// For related material, please refer to : 
// John Biddiscombe, Berk Geveci, Ken Martin, Kenneth Moreland, David Thompson,
// "Time Dependent Processing in a Parallel Pipeline Architecture", 
// IEEE Visualization 2007. 

#ifndef __vtkTemporalInterpolator_h
#define __vtkTemporalInterpolator_h

#include "vtkTemporalDataSetAlgorithm.h"

class vtkDataSet;

class VTK_HYBRID_EXPORT vtkTemporalInterpolator : public vtkTemporalDataSetAlgorithm
{
public:
  static vtkTemporalInterpolator *New();
  vtkTypeMacro(vtkTemporalInterpolator, vtkTemporalDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);

  // Description:
  // If you require a discrete number of outputs steps, to be 
  // generated from an input source - for example, you required
  // N steps separated by T, then set DiscreteTimeStepInterval to T
  // and you will get TIME_RANGE/DiscreteTimeStepInterval steps
  // This is a useful option to use if you have a dataset with one
  // missing time step and wish to 'fill-in' the missing data
  // with an interpolated value from the steps either side
  vtkSetMacro(DiscreteTimeStepInterval, double);
  vtkGetMacro(DiscreteTimeStepInterval, double);

  // Description:
  // When ResampleFactor is a non zero positive integer, each pair
  // of input time steps will be interpolated between with the number
  // of steps specified. For example an input of 1,2,3,4,5 and a resample factor
  // of 10, will produce steps 0f 1.0, 1.1, 1.2.....1.9, 2.0 etc
  // NB. Irregular input steps will produce irregular output steps.
  // Resample factor wuill only be used if DiscreteTimeStepInterval is zero
  // otherwise the DiscreteTimeStepInterval takes precedence
  vtkSetMacro(ResampleFactor, int);
  vtkGetMacro(ResampleFactor, int);

protected:
  vtkTemporalInterpolator();
  ~vtkTemporalInterpolator();

  double DiscreteTimeStepInterval;
  int    ResampleFactor;
/*
  virtual int FillInputPortInformation(int port, vtkInformation* info);

  virtual int RequestDataObject(vtkInformation *,
                                vtkInformationVector **,
                                vtkInformationVector *);
*/
  virtual int RequestUpdateExtent(vtkInformation *,
                                  vtkInformationVector **,
                                  vtkInformationVector *);
  virtual int RequestInformation(vtkInformation *,
                                 vtkInformationVector **,
                                 vtkInformationVector *);
  
  virtual int RequestData(vtkInformation *,
                          vtkInformationVector **,
                          vtkInformationVector *);

  // Description:
  // General interpolation routine for any type on input data. This is
  // called recursively when heirarchical/multiblock data is encountered
  vtkDataObject *InterpolateDataObject(vtkDataObject *in1, 
                                       vtkDataObject *in2,
                                       double ratio);

  // Description:
  // Root level interpolation for a concrete dataset object.
  // Point/Cell data and points are interpolated.
  // Needs improving if connectivity is to be handled
  virtual vtkDataSet *InterpolateDataSet(vtkDataSet *in1, 
                                         vtkDataSet *in2,
                                         double ratio);

  // Description:
  // Interpolate a single vtkDataArray. Called from the Interpolation routine
  // on the points and pointdata/celldata
  virtual vtkDataArray *InterpolateDataArray(double ratio, 
                                             vtkDataArray **arrays, 
                                             vtkIdType N);

  // Description:
  // Called just before interpolation of each dataset to ensure 
  // each data array has the same number of tuples/components etc
  virtual bool VerifyArrays(vtkDataArray **arrays, int N);

  // internally used : Ratio is {0,1} between two time steps
  // DeltaT is time between current 2 steps.
  // These are only valid when 2 time steps are interpolated
  // Higher order schemes will require changes to the API
  double Ratio;
  double DeltaT;
  double Tfrac;

private:
  vtkTemporalInterpolator(const vtkTemporalInterpolator&);  // Not implemented.
  void operator=(const vtkTemporalInterpolator&);  // Not implemented.
};



#endif