00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040 #ifndef _itkFEMFiniteDifferenceFunctionLoad_h_
00041 #define _itkFEMFiniteDifferenceFunctionLoad_h_
00042
00043 #include "itkFEMLoadElementBase.h"
00044
00045 #include "itkImage.h"
00046 #include "itkTranslationTransform.h"
00047
00048 #include "itkImageRegionIteratorWithIndex.h"
00049 #include "itkNeighborhoodIterator.h"
00050 #include "itkNeighborhoodIterator.h"
00051 #include "itkNeighborhoodInnerProduct.h"
00052 #include "itkDerivativeOperator.h"
00053 #include "itkForwardDifferenceOperator.h"
00054 #include "itkLinearInterpolateImageFunction.h"
00055 #include "vnl/vnl_math.h"
00056
00057 #include "itkDemonsRegistrationFunction.h"
00058 #include "itkMeanSquareRegistrationFunction.h"
00059 #include "itkNCCRegistrationFunction.h"
00060 #include "itkMIRegistrationFunction.h"
00061
00062 namespace itk
00063 {
00064 namespace fem
00065 {
00066
00086 template<class TMoving,class TFixed>
00087 class FiniteDifferenceFunctionLoad : public LoadElement
00088 {
00089 FEM_CLASS(FiniteDifferenceFunctionLoad,LoadElement)
00090 public:
00091
00092
00093 typedef typename LoadElement::Float Float;
00094
00095 typedef TMoving MovingImageType;
00096 typedef typename MovingImageType::ConstPointer MovingConstPointer;
00097 typedef MovingImageType* MovingPointer;
00098 typedef TFixed FixedImageType;
00099 typedef FixedImageType* FixedPointer;
00100 typedef typename FixedImageType::ConstPointer FixedConstPointer;
00101
00103 itkStaticConstMacro(ImageDimension, unsigned int,
00104 MovingImageType::ImageDimension);
00105
00106 typedef ImageRegionIteratorWithIndex<MovingImageType> MovingRegionIteratorType;
00107 typedef ImageRegionIteratorWithIndex<FixedImageType> FixedRegionIteratorType;
00108
00109
00110 typedef NeighborhoodIterator<MovingImageType>
00111 MovingNeighborhoodIteratorType;
00112 typedef typename MovingNeighborhoodIteratorType::IndexType
00113 MovingNeighborhoodIndexType;
00114 typedef typename MovingNeighborhoodIteratorType::RadiusType
00115 MovingRadiusType;
00116 typedef typename MovingNeighborhoodIteratorType::RadiusType
00117 RadiusType;
00118 typedef NeighborhoodIterator<FixedImageType>
00119 FixedNeighborhoodIteratorType;
00120 typedef typename FixedNeighborhoodIteratorType::IndexType
00121 FixedNeighborhoodIndexType;
00122 typedef typename FixedNeighborhoodIteratorType::RadiusType
00123 FixedRadiusType;
00124
00125
00126
00127 typedef typename MovingImageType::PixelType MovingPixelType;
00128 typedef typename FixedImageType::PixelType FixedPixelType;
00129 typedef Float PixelType;
00130 typedef Float ComputationType;
00131 typedef Image< PixelType, itkGetStaticConstMacro(ImageDimension) > ImageType;
00132 typedef itk::Vector<float,itkGetStaticConstMacro(ImageDimension)> VectorType;
00133 typedef vnl_vector<Float> FEMVectorType;
00134 typedef Image< VectorType, itkGetStaticConstMacro(ImageDimension) > DeformationFieldType;
00135 typedef typename DeformationFieldType::Pointer DeformationFieldTypePointer;
00136
00137
00138 typedef NeighborhoodIterator<DeformationFieldType>
00139 FieldIteratorType;
00140
00141
00142
00144 typedef PDEDeformableRegistrationFunction<FixedImageType,MovingImageType,
00145 DeformationFieldType> FiniteDifferenceFunctionType;
00146 typedef typename FiniteDifferenceFunctionType::Pointer FiniteDifferenceFunctionTypePointer;
00147 typedef typename FiniteDifferenceFunctionType::TimeStepType TimeStepType;
00148
00149 typedef MeanSquareRegistrationFunction<FixedImageType,MovingImageType,
00150 DeformationFieldType> MeanSquareRegistrationFunctionType;
00151
00152 typedef DemonsRegistrationFunction<FixedImageType,MovingImageType,
00153 DeformationFieldType> DemonsRegistrationFunctionType;
00154
00155 typedef NCCRegistrationFunction<FixedImageType,MovingImageType,
00156 DeformationFieldType> NCCRegistrationFunctionType;
00157
00158 typedef MIRegistrationFunction<FixedImageType,MovingImageType,
00159 DeformationFieldType> MIRegistrationFunctionType;
00160
00161
00162
00163
00164
00165
00166 void SetDifferenceFunction( FiniteDifferenceFunctionTypePointer drfp)
00167 {
00168 drfp->SetFixedImage(m_FixedImage);
00169 drfp->SetMovingImage(m_MovingImage);
00170 drfp->SetRadius(m_MetricRadius);
00171 drfp->SetDeformationField(m_DeformationField);
00172 drfp->InitializeIteration();
00173 this->m_DifferenceFunction=drfp;
00174 }
00175
00176 void SetMetric( FiniteDifferenceFunctionTypePointer drfp )
00177 {
00178 this->SetDifferenceFunction( static_cast<FiniteDifferenceFunctionType *>(
00179 drfp.GetPointer() ) );
00180
00181 m_FixedSize=m_DeformationField->GetLargestPossibleRegion().GetSize();
00182 }
00183
00184
00185
00187 void SetMovingImage(MovingImageType* R)
00188 {
00189 m_MovingImage = R;
00190 m_MovingSize=m_MovingImage->GetLargestPossibleRegion().GetSize();
00191 if (this->m_DifferenceFunction) this->m_DifferenceFunction->SetMovingImage(m_MovingImage);
00192
00193 };
00195
00196
00198 void SetFixedImage(FixedImageType* T)
00199 {
00200 m_FixedImage=T;
00201 m_FixedSize=T->GetLargestPossibleRegion().GetSize();
00202 if (this->m_DifferenceFunction) this->m_DifferenceFunction->SetFixedImage(m_MovingImage);
00203
00204 };
00206
00207
00208 MovingPointer GetMovingImage() { return m_MovingImage; };
00209 FixedPointer GetFixedImage() { return m_FixedImage; };
00210
00212 void SetMetricRadius(MovingRadiusType T) {m_MetricRadius = T; };
00213
00215 MovingRadiusType GetMetricRadius() { return m_MetricRadius; };
00216
00221 void SetNumberOfIntegrationPoints(unsigned int i){ m_NumberOfIntegrationPoints=i;}
00222 unsigned int GetNumberOfIntegrationPoints(){ return m_NumberOfIntegrationPoints;}
00224
00228 void SetSign(Float s) {m_Sign=s;}
00229
00231 void SetTemp(Float s) {m_Temp=s;}
00232
00233
00235 void SetGamma(Float s) {m_Gamma=s;}
00236
00237 void SetSolution(Solution::ConstPointer ptr) { m_Solution=ptr; }
00238 Solution::ConstPointer GetSolution() { return m_Solution; }
00239
00240
00241 Float GetSolution(unsigned int i,unsigned int which=0)
00242 {
00243 return m_Solution->GetSolutionValue(i,which);
00244 }
00245
00246 FiniteDifferenceFunctionLoad();
00247 Float EvaluateMetricGivenSolution ( Element::ArrayType* el, Float step=1.0);
00248
00252 VectorType Fe1(VectorType);
00253 FEMVectorType Fe(FEMVectorType,FEMVectorType);
00255
00256 static Baseclass* NewFiniteDifferenceFunctionLoad(void)
00257 { return new FiniteDifferenceFunctionLoad; }
00258
00259
00261 void SetDeformationField( DeformationFieldTypePointer df)
00262 { m_DeformationField=df;}
00263
00265 DeformationFieldTypePointer GetDeformationField() { return m_DeformationField;}
00266 void InitializeIteration();
00267 void InitializeMetric();
00269
00270 void PrintCurrentEnergy();
00271 double GetCurrentEnergy();
00272 void SetCurrentEnergy( double e = 0.0);
00273
00274 protected:
00275
00276
00277 private:
00278 MovingPointer m_MovingImage;
00279 FixedPointer m_FixedImage;
00281 typename MovingImageType::SizeType m_MovingSize;
00282 typename FixedImageType::SizeType m_FixedSize;
00283 unsigned int m_NumberOfIntegrationPoints;
00284 unsigned int m_SolutionIndex;
00285 unsigned int m_SolutionIndex2;
00286 Float m_Temp;
00287 Float m_Gamma;
00288 typename Solution::ConstPointer m_Solution;
00289
00290 float m_GradSigma;
00291 float m_Sign;
00292 float m_WhichMetric;
00293 FiniteDifferenceFunctionTypePointer m_DifferenceFunction;
00294
00295 typename DeformationFieldType::Pointer m_DeformationField;
00298 static const int DummyCLID;
00299
00300 };
00301
00302
00303
00304
00305 }}
00306
00307 #ifndef ITK_MANUAL_INSTANTIATION
00308 #include "itkFEMFiniteDifferenceFunctionLoad.txx"
00309 #endif
00310
00311 #endif
00312