/usr/include/ITK-4.5/itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod.h is in libinsighttoolkit4-dev 4.5.0-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 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | /*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef __itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod_h
#define __itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod_h
#include "itkImageRegistrationMethodv4.h"
#include "itkBSplineScatteredDataPointSetToImageFilter.h"
#include "itkImageMaskSpatialObject.h"
#include "itkTimeVaryingBSplineVelocityFieldTransform.h"
namespace itk
{
//Forward-declare these because of module dependency conflict.
//They will soon be moved to a different module, at which
// time this can be removed.
template <unsigned int VDimension, typename TDataHolder>
class ImageToData;
template <typename TDataHolder>
class Array1DToData;
/** \class TimeVaryingBSplineVelocityFieldImageRegistrationMethod
* \brief Interface method for the current registration framework
* using the time varying velocity field transform.
*
*
* Output: The output is the updated transform which has been added to the
* composite transform.
*
* This derived class from the SimpleImageRegistrationMethod class
* is specialized to handle time-varying velocity field transforms
* of which there are currently 3:
*
* -# TimeVaryingDisplacementFieldTransform
* -# GaussianSmoothingOnUpdateTimeVaryingDisplacementFieldTransform
* -# BSplineSmoothingOnUpdateTimeVaryingDisplacementFieldTransform
*
* The latter is derived from the former and performs an optional
* spatial and temporal smoothing on the update and total velocity
* fields. Integration of the velocity field is performed using
* 4th order Runge Kutta and is performed using the class
* itkTimeVaryingBSplineVelocityFieldIntegrationImageFilter.
*
* Optimization occurs in an iterative fashion where for each
* sample time point, t, in the velocity field, we integrate
* the velocity field in the range [0, t] to yield the
* displacement field which warps fixed image to time point
* t. Simultaneously, we integrate the velocity field in
* the range [t, 1] to yield the displacement field transform
* which warps the moving image to time point t. The metric
* derivative for each time point of the velocity field
* calculated in this way produces the normalized update field
* (or gradient) of the velocity field to be added to the total
* field at each iteration after being multiplied by the
* learning rate and optionally smoothed. Mathematically,
* this can be described as
*
* \f[
* v_{total} = B_1( v_{total} + \lambda * B_2( v_{update} ) )
* \f]
* where
* \f$ B_1 = \f$ bspline smoothing on the total field
* \f$ B_2 = \f$ bspline smoothing on the update field
* \f$ \lambda = \f$ learning rate
* \f$ v_{update} = \f$ the normalized velocity field where we
* normalize the velocity field at each time point
* separately by the max norm of the field at that time
* point. This is done due to a weakly necessary
* (but not sufficient) condition being that the velocity
* field have a constant norm for all time points.
*
* \author Nick Tustison
* \author Brian Avants
*
* \ingroup ITKRegistrationMethodsv4
*/
template<typename TFixedImage, typename TMovingImage, typename TOutputTransform =
TimeVaryingBSplineVelocityFieldTransform<double, TFixedImage::ImageDimension> >
class TimeVaryingBSplineVelocityFieldImageRegistrationMethod
: public ImageRegistrationMethodv4<TFixedImage, TMovingImage, TOutputTransform>
{
public:
/** Standard class typedefs. */
typedef TimeVaryingBSplineVelocityFieldImageRegistrationMethod Self;
typedef ImageRegistrationMethodv4<TFixedImage, TMovingImage, TOutputTransform> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro( Self );
/** ImageDimension constants */
itkStaticConstMacro( ImageDimension, unsigned int, TFixedImage::ImageDimension );
/** Run-time type information (and related methods). */
itkTypeMacro( TimeVaryingBSplineVelocityFieldImageRegistrationMethod, SimpleImageRegistrationMethod );
/** Input typedefs for the images and transforms. */
typedef TFixedImage FixedImageType;
typedef typename FixedImageType::Pointer FixedImagePointer;
typedef TMovingImage MovingImageType;
typedef typename MovingImageType::Pointer MovingImagePointer;
/** Metric and transform typedefs */
typedef typename Superclass::ImageMetricType ImageMetricType;
typedef typename ImageMetricType::Pointer ImageMetricPointer;
typedef typename ImageMetricType::VirtualImageType VirtualImageType;
typedef typename ImageMetricType::MeasureType MeasureType;
typedef typename Superclass::MultiMetricType MultiMetricType;
typedef typename ImageMetricType::FixedImageMaskType FixedImageMaskType;
typedef typename ImageMetricType::MovingImageMaskType MovingImageMaskType;
typedef ImageMaskSpatialObject<ImageDimension> ImageMaskSpatialObjectType;
typedef typename ImageMaskSpatialObjectType::ImageType MaskImageType;
typedef TOutputTransform OutputTransformType;
typedef typename OutputTransformType::Pointer OutputTransformPointer;
typedef typename OutputTransformType::ScalarType RealType;
typedef typename OutputTransformType::DerivativeType DerivativeType;
typedef typename DerivativeType::ValueType DerivativeValueType;
typedef typename OutputTransformType::DisplacementFieldType DisplacementFieldType;
typedef typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticeType TimeVaryingVelocityFieldControlPointLatticeType;
typedef typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticePointer TimeVaryingVelocityFieldControlPointLatticePointer;
typedef typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticeType TimeVaryingVelocityFieldType;
typedef typename OutputTransformType::TimeVaryingVelocityFieldControlPointLatticePointer TimeVaryingVelocityFieldPointer;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::PixelType DisplacementVectorType;
typedef typename Superclass::CompositeTransformType CompositeTransformType;
typedef typename Superclass::DecoratedOutputTransformType DecoratedOutputTransformType;
typedef typename DecoratedOutputTransformType::Pointer DecoratedOutputTransformPointer;
typedef Array<SizeValueType> NumberOfIterationsArrayType;
typedef PointSet<DisplacementVectorType, ImageDimension + 1> PointSetType;
typedef BSplineScatteredDataPointSetToImageFilter<PointSetType, TimeVaryingVelocityFieldType> BSplineFilterType;
typedef typename BSplineFilterType::WeightsContainerType WeightsContainerType;
typedef typename WeightsContainerType::Element WeightsElementType;
typedef Image<WeightsElementType, ImageDimension> WeightedMaskImageType;
typedef Image<WeightsElementType, ImageDimension + 1> TimeVaryingWeightedMaskImageType;
/** Set/Get the learning rate. */
itkSetMacro( LearningRate, RealType );
itkGetConstMacro( LearningRate, RealType );
/** Set/Get the number of iterations per level. */
itkSetMacro( NumberOfIterationsPerLevel, NumberOfIterationsArrayType );
itkGetConstMacro( NumberOfIterationsPerLevel, NumberOfIterationsArrayType );
/** Set/Get the convergence threshold */
itkSetMacro( ConvergenceThreshold, RealType );
itkGetConstMacro( ConvergenceThreshold, RealType );
/** Set/Get the convergence window size */
itkSetMacro( ConvergenceWindowSize, unsigned int );
itkGetConstMacro( ConvergenceWindowSize, unsigned int );
/** Set/Get the number of time point samples. */
itkSetMacro( NumberOfTimePointSamples, SizeValueType );
itkGetConstMacro( NumberOfTimePointSamples, SizeValueType );
protected:
TimeVaryingBSplineVelocityFieldImageRegistrationMethod();
virtual ~TimeVaryingBSplineVelocityFieldImageRegistrationMethod();
virtual void PrintSelf( std::ostream & os, Indent indent ) const;
/** Perform the registration. */
virtual void GenerateData();
/** Handle optimization internally */
virtual void StartOptimization();
private:
TimeVaryingBSplineVelocityFieldImageRegistrationMethod( const Self & ); //purposely not
// implemented
void operator=( const Self & ); //purposely not
RealType m_LearningRate;
RealType m_ConvergenceThreshold;
unsigned int m_ConvergenceWindowSize;
NumberOfIterationsArrayType m_NumberOfIterationsPerLevel;
SizeValueType m_NumberOfTimePointSamples;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTimeVaryingBSplineVelocityFieldImageRegistrationMethod.hxx"
#endif
#endif
|