This file is indexed.

/usr/include/InsightToolkit/Review/itkWarpHarmonicEnergyCalculator.h is in libinsighttoolkit3-dev 3.20.1-1.

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
165
/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkWarpHarmonicEnergyCalculator.h
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/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 notices for more information.

=========================================================================*/

#ifndef __itkWarpHarmonicEnergyCalculator_h
#define __itkWarpHarmonicEnergyCalculator_h

#include "itkObject.h"
#include "itkObjectFactory.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkImage.h"
#include "itkVector.h"

namespace itk
{

/** \class WarpHarmonicEnergyCalculator
 *
 * \brief Compute the harmonic energy of a deformation field
 *
 * This class computes the harmonic energy of a deformation
 * field which is a measure inversely related to the smoothness
 * of the deformation field
 *
 * \author Tom Vercauteren, INRIA & Mauna Kea Technologies
 *
 * This implementation was taken from the Insight Journal paper:
 * http://hdl.handle.net/1926/510
 *
 * \ingroup Operators
 */
template <class TInputImage>
class ITK_EXPORT WarpHarmonicEnergyCalculator : public Object
{
public:
  /** Standard class typedefs. */
  typedef WarpHarmonicEnergyCalculator          Self;
  typedef Object                                Superclass;
  typedef SmartPointer<Self>                    Pointer;
  typedef SmartPointer<const Self>              ConstPointer;

  /** Method for creation through the object factory. */
  itkNewMacro(Self);

  /** Run-time type information (and related methods). */
  itkTypeMacro(WarpHarmonicEnergyCalculator, Object);

  /** Type definition for the input image. */
  typedef TInputImage                           ImageType;

  /** Pointer type for the image. */
  typedef typename TInputImage::Pointer         ImagePointer;

  /** Const Pointer type for the image. */
  typedef typename TInputImage::ConstPointer    ImageConstPointer;

  /** Type definition for the input image pixel type. */
  typedef typename TInputImage::PixelType PixelType;

  /** Type definition for the input image index type. */
  typedef typename TInputImage::IndexType IndexType;

  /** Type definition for the input image region type. */
  typedef typename TInputImage::RegionType RegionType;

  /** The dimensionality of the input image. */
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  /** Length of the vector pixel type of the input image. */
  itkStaticConstMacro(VectorDimension, unsigned int,
                      PixelType::Dimension);

  /** Type of the iterator that will be used to move through the image.  Also
      the type which will be passed to the evaluate function */
  typedef ConstNeighborhoodIterator<ImageType> ConstNeighborhoodIteratorType;
  typedef typename ConstNeighborhoodIteratorType::RadiusType RadiusType;

  /** Set the derivative weights according to the spacing of the input image
   *  (1/spacing). Use this option if you want to calculate the Jacobian
   *  determinant in the space in which the data was acquired. */
  void SetUseImageSpacingOn()
    {
    this->SetUseImageSpacing(true);
    }

  /** Reset the derivative weights to ignore image spacing.  Use this option if
   *  you want to calculate the Jacobian determinant in the image space.
   *  Default is ImageSpacingOn. */
  void SetUseImageSpacingOff()
    {
    this->SetUseImageSpacing(false);
    }

  /** Set/Get whether or not the filter will use the spacing of the input
   *  image in its calculations */
  void SetUseImageSpacing(bool);
  itkGetConstMacro(UseImageSpacing, bool);

  /** Directly Set/Get the array of weights used in the gradient calculations.
   *  Note that calling UseImageSpacingOn will clobber these values. */
  void SetDerivativeWeights(double data[]);
  itkGetVectorMacro(DerivativeWeights, const double, ::itk::GetImageDimension<TInputImage>::ImageDimension);

  /** Set the input image. */
  itkSetConstObjectMacro(Image,ImageType);

  /** Compute the minimum and maximum values of intensity of the input image. */
  void Compute(void);

  /** Return the smoothness value. */
  itkGetConstMacro(HarmonicEnergy,double);

  /** Set the region over which the values will be computed */
  void SetRegion( const RegionType & region );

protected:
  WarpHarmonicEnergyCalculator();
  virtual ~WarpHarmonicEnergyCalculator() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  /** Get/Set the neighborhood radius used for gradient computation */
  itkGetConstReferenceMacro( NeighborhoodRadius, RadiusType );
  itkSetMacro( NeighborhoodRadius, RadiusType );

  double EvaluateAtNeighborhood( ConstNeighborhoodIteratorType &it ) const;

private:
  WarpHarmonicEnergyCalculator(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  double               m_HarmonicEnergy;
  ImageConstPointer    m_Image;

  RegionType           m_Region;
  bool                 m_RegionSetByUser;

  bool m_UseImageSpacing;

  /** The weights used to scale partial derivatives during processing */
  double m_DerivativeWeights[::itk::GetImageDimension<TInputImage>::ImageDimension];

  RadiusType    m_NeighborhoodRadius;
};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkWarpHarmonicEnergyCalculator.txx"
#endif

#endif /* __itkWarpHarmonicEnergyCalculator_h */