/usr/include/OTB-5.8/otbGenericInterpolateImageFunction.h is in libotb-dev 5.8.0+dfsg-3.
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 155 156 157 158 159 160 161 162 163 164 | /*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt 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 notices for more information.
=========================================================================*/
#ifndef otbGenericInterpolateImageFunction_h
#define otbGenericInterpolateImageFunction_h
#include "itkInterpolateImageFunction.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkConstantBoundaryCondition.h"
namespace otb
{
/** \class GenericInterpolateImageFunction
* \brief Generic interpolation of an otb::Image.
*
* GenericInterpolateImageFunction interpolates image intensity according to a
* resampling profil.
*
* The Initialize() method need to be call to create the filter.
*
* \ingroup ImageFunctions ImageInterpolators
*
* \ingroup OTBInterpolation
*/
template <class TInputImage, class TFunction, class TBoundaryCondition = itk::ZeroFluxNeumannBoundaryCondition<TInputImage>,
class TCoordRep = double>
class ITK_EXPORT GenericInterpolateImageFunction :
public itk::InterpolateImageFunction<TInputImage, TCoordRep>
{
public:
/** Standard class typedefs. */
typedef GenericInterpolateImageFunction Self;
typedef itk::InterpolateImageFunction<TInputImage, TCoordRep> Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Run-time type information (and related methods). */
itkTypeMacro(GenericInterpolateImageFunction, itk::InterpolateImageFunction);
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Input and output images typedef definition. */
typedef typename Superclass::OutputType OutputType;
typedef typename Superclass::InputImageType InputImageType;
/** Dimension underlying input image. */
//itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension);
/** Index and typedef support. */
typedef typename Superclass::IndexType IndexType;
typedef typename InputImageType::SizeType SizeType;
typedef typename Superclass::RealType RealType;
typedef TFunction FunctionType;
typedef itk::ConstNeighborhoodIterator<InputImageType, TBoundaryCondition> IteratorType;
/** ContinuousIndex typedef support. */
typedef typename Superclass::ContinuousIndexType ContinuousIndexType;
/** Dimension underlying input image. */
itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension);
/** Evaluate the function at a ContinuousIndex position
*
* Returns the interpolated image intensity at a
* specified point position. No bounds checking is done.
* The point is assume to lie within the image buffer.
*
* ImageFunction::IsInsideBuffer() can be used to check bounds before
* calling the method. */
OutputType EvaluateAtContinuousIndex(const ContinuousIndexType& index) const ITK_OVERRIDE;
/** Set/Get the window radius*/
virtual void SetRadius(unsigned int rad);
virtual unsigned int GetRadius() const
{
return m_Function.GetRadius();
}
//unsigned int GetRadius() { return this->GetFunction().GetRadius(); };
/** Set/Get the window radius*/
// Don't have to be used here, just declared for the inheritance classes.
//virtual void SetWindowSize(unsigned int win){ m_WindowSize = win; };
/** Get the functor list */
virtual FunctionType& GetFunction(void)
{
return m_Function;
}
/** Initialize tables: need to be call explicitly */
virtual void Initialize();
/** Weights normalization accessors*/
itkSetMacro(NormalizeWeight, bool);
itkGetMacro(NormalizeWeight, bool);
protected:
GenericInterpolateImageFunction();
~GenericInterpolateImageFunction() ITK_OVERRIDE;
void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE;
/** Call the superclass implementation and set the TablesHaveBeenGenerated
* flag to false */
void Modified(void) const ITK_OVERRIDE;
/** Delete tables.*/
virtual void ResetOffsetTable();
/** Initialize used tables*/
virtual void InitializeTables();
/** Fill the weight offset table*/
virtual void FillWeightOffsetTable();
private:
GenericInterpolateImageFunction(const Self &); //purposely not implemented
void operator =(const Self&); //purposely not implemented
/** Store the window radius. */
//unsigned int m_Radius;
// Constant to store twice the radius
unsigned int m_WindowSize;
/** Used function */
FunctionType m_Function;
/** Store the image dimension.*/
unsigned int m_ImageDimension;
/** These members are declared mutable so that they can be
regenerated seamlessly inside the EvaluateAtContinuousIndex method if
they need to */
/** Size of the offset table */
mutable unsigned int m_OffsetTableSize;
/** The offset array, used to keep a list of relevant
* offsets in the neihborhoodIterator */
mutable unsigned int *m_OffsetTable;
/** Index into the weights array for each offset */
mutable unsigned int **m_WeightOffsetTable;
/** True if internal statistics have been generated */
mutable bool m_TablesHaveBeenGenerated;
/** Weights normalization */
bool m_NormalizeWeight;
};
} // end namespace itk
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbGenericInterpolateImageFunction.txx"
#endif
#endif
|