ITK  5.4.0
Insight Toolkit
itkImageToImageMetricv4.h
Go to the documentation of this file.
1/*=========================================================================
2 *
3 * Copyright NumFOCUS
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0.txt
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *=========================================================================*/
18#ifndef itkImageToImageMetricv4_h
19#define itkImageToImageMetricv4_h
20
21#include "itkCovariantVector.h"
22#include "itkImageFunction.h"
25#include "itkSpatialObject.h"
31#include "itkPointSet.h"
34
35namespace itk
36{
168template <typename TFixedImage,
169 typename TMovingImage,
170 typename TVirtualImage = TFixedImage,
171 typename TInternalComputationValueType = double,
172 typename TMetricTraits =
173 DefaultImageToImageMetricTraitsv4<TFixedImage, TMovingImage, TVirtualImage, TInternalComputationValueType>>
174class ITK_TEMPLATE_EXPORT ImageToImageMetricv4
175 : public ObjectToObjectMetric<TFixedImage::ImageDimension,
176 TMovingImage::ImageDimension,
177 TVirtualImage,
178 TInternalComputationValueType>
179{
180public:
181 ITK_DISALLOW_COPY_AND_MOVE(ImageToImageMetricv4);
182
185 using Superclass = ObjectToObjectMetric<TFixedImage::ImageDimension,
186 TMovingImage::ImageDimension,
187 TVirtualImage,
188 TInternalComputationValueType>;
191
193 itkOverrideGetNameOfClassMacro(ImageToImageMetricv4);
194
198 using InternalComputationValueType = TInternalComputationValueType;
199
201 using typename Superclass::CoordinateRepresentationType;
202
204 using typename Superclass::ParametersType;
205 using typename Superclass::ParametersValueType;
206
208 using typename Superclass::GradientSourceEnum;
209
211 using typename Superclass::DimensionType;
212 using ImageDimensionType = typename Superclass::DimensionType;
213
215 using typename Superclass::FixedTransformType;
216 using typename Superclass::FixedTransformPointer;
217 using typename Superclass::FixedInputPointType;
218 using typename Superclass::FixedOutputPointType;
219 using typename Superclass::FixedTransformParametersType;
220
221 using typename Superclass::MovingTransformType;
222 using typename Superclass::MovingTransformPointer;
223 using typename Superclass::MovingInputPointType;
224 using typename Superclass::MovingOutputPointType;
225 using typename Superclass::MovingTransformParametersType;
226
227 using typename Superclass::JacobianType;
228 using typename Superclass::FixedTransformJacobianType;
229 using typename Superclass::MovingTransformJacobianType;
230
231 using ObjectType = typename Superclass::ObjectType;
232
234 using FixedImageType = TFixedImage;
235 using FixedImagePixelType = typename FixedImageType::PixelType;
241 using MovingImageType = TMovingImage;
242 using MovingImagePixelType = typename MovingImageType::PixelType;
249
251 using VirtualImageType = typename Superclass::VirtualImageType;
252 using typename Superclass::VirtualImagePointer;
253 using typename Superclass::VirtualPixelType;
254 using typename Superclass::VirtualRegionType;
255 using typename Superclass::VirtualSizeType;
256 using typename Superclass::VirtualSpacingType;
257 using VirtualOriginType = typename Superclass::VirtualPointType;
258 using typename Superclass::VirtualPointType;
259 using typename Superclass::VirtualDirectionType;
260 using VirtualRadiusType = typename Superclass::VirtualSizeType;
261 using typename Superclass::VirtualIndexType;
262 using typename Superclass::VirtualPointSetType;
263 using typename Superclass::VirtualPointSetPointer;
264
266 using MetricTraits = TMetricTraits;
267
268 /* Image dimension accessors */
269 static constexpr DimensionType FixedImageDimension = Superclass::FixedDimension;
270 static constexpr DimensionType MovingImageDimension = Superclass::MovingDimension;
271 static constexpr DimensionType VirtualImageDimension = Superclass::VirtualDimension;
272
278
284
289
295
297 using FixedImageGradientType = typename MetricTraits::FixedImageGradientType;
298 using MovingImageGradientType = typename MetricTraits::MovingImageGradientType;
299 using VirtualImageGradientType = typename MetricTraits::VirtualImageGradientType;
300
303
306
309
313 using FixedRealType = typename MetricTraits::FixedRealType;
314 using MovingRealType = typename MetricTraits::MovingRealType;
315
318
319 using FixedGradientPixelType = typename MetricTraits::FixedGradientPixelType;
320 using MovingGradientPixelType = typename MetricTraits::MovingGradientPixelType;
321
322 using FixedImageGradientImageType = typename MetricTraits::FixedImageGradientImageType;
323 using MovingImageGradientImageType = typename MetricTraits::MovingImageGradientImageType;
324
327
328 using FixedImageGradientFilterType = typename MetricTraits::FixedImageGradientFilterType;
329 using MovingImageGradientFilterType = typename MetricTraits::MovingImageGradientFilterType;
330
333
334
336 using DefaultFixedImageGradientFilter = typename MetricTraits::DefaultFixedImageGradientFilter;
337 using DefaultMovingImageGradientFilter = typename MetricTraits::DefaultMovingImageGradientFilter;
338
341 using FixedImageGradientCalculatorType = typename MetricTraits::FixedImageGradientCalculatorType;
342 using MovingImageGradientCalculatorType = typename MetricTraits::MovingImageGradientCalculatorType;
343
346
348 using DefaultFixedImageGradientCalculator = typename MetricTraits::DefaultFixedImageGradientCalculator;
349 using DefaultMovingImageGradientCalculator = typename MetricTraits::DefaultMovingImageGradientCalculator;
350
352 using typename Superclass::MeasureType;
353
355 using typename Superclass::DerivativeType;
357
360 using typename Superclass::NumberOfParametersType;
361
363 void
364 SetFixedObject(const ObjectType * object) override
365 {
366 auto * image = dynamic_cast<FixedImageType *>(const_cast<ObjectType *>(object));
367 if (image != nullptr)
368 {
369 this->SetFixedImage(image);
370 }
371 else
372 {
373 itkExceptionMacro("Incorrect object type. Should be an image.");
374 }
375 }
379 void
380 SetMovingObject(const ObjectType * object) override
381 {
382 auto * image = dynamic_cast<MovingImageType *>(const_cast<ObjectType *>(object));
383 if (image != nullptr)
384 {
385 this->SetMovingImage(image);
386 }
387 else
388 {
389 itkExceptionMacro("Incorrect object type. Should be an image.");
390 }
391 }
394 /* Get/Set the Fixed Image. */
395 itkSetConstObjectMacro(FixedImage, FixedImageType);
396 itkGetConstObjectMacro(FixedImage, FixedImageType);
397
399 itkSetConstObjectMacro(MovingImage, MovingImageType);
400 itkGetConstObjectMacro(MovingImage, MovingImageType);
404 itkSetObjectMacro(FixedInterpolator, FixedInterpolatorType);
405
407 itkGetModifiableObjectMacro(FixedInterpolator, FixedInterpolatorType);
408
410 itkSetObjectMacro(MovingInterpolator, MovingInterpolatorType);
411
413 itkGetModifiableObjectMacro(MovingInterpolator, MovingInterpolatorType);
414
416#ifndef ITK_FUTURE_LEGACY_REMOVE
417 virtual void
418 SetMovingImageMask(MovingImageMaskType * const arg)
419 {
420 const auto * const constArg = arg;
421 // Call the overload defined by itkSetConstObjectMacro, or an override.
422 this->SetMovingImageMask(constArg);
423 }
424#endif
425 itkSetConstObjectMacro(MovingImageMask, MovingImageMaskType);
426 itkGetConstObjectMacro(MovingImageMask, MovingImageMaskType);
430#ifndef ITK_FUTURE_LEGACY_REMOVE
431 virtual void
432 SetFixedImageMask(FixedImageMaskType * const arg)
433 {
434 const auto * const constArg = arg;
435 // Call the overload defined by itkSetConstObjectMacro, or an override.
436 this->SetFixedImageMask(constArg);
437 }
438#endif
439 itkSetConstObjectMacro(FixedImageMask, FixedImageMaskType);
440 itkGetConstObjectMacro(FixedImageMask, FixedImageMaskType);
446#ifndef ITK_FUTURE_LEGACY_REMOVE
447 virtual void
448 SetFixedSampledPointSet(FixedSampledPointSetType * const arg)
449 {
450 const auto * const constArg = arg;
451 // Call the overload defined by itkSetConstObjectMacro, or an override.
452 this->SetFixedSampledPointSet(constArg);
453 }
454#endif
455 itkSetConstObjectMacro(FixedSampledPointSet, FixedSampledPointSetType);
456 itkGetConstObjectMacro(FixedSampledPointSet, FixedSampledPointSetType);
460 itkSetObjectMacro(VirtualSampledPointSet, VirtualPointSetType);
461 itkGetConstObjectMacro(VirtualSampledPointSet, VirtualPointSetType);
465 itkSetMacro(UseSampledPointSet, bool);
466 itkGetConstReferenceMacro(UseSampledPointSet, bool);
467 itkBooleanMacro(UseSampledPointSet);
472 itkSetMacro(UseVirtualSampledPointSet, bool);
473 itkGetConstReferenceMacro(UseVirtualSampledPointSet, bool);
474 itkBooleanMacro(UseVirtualSampledPointSet);
477#if !defined(ITK_LEGACY_REMOVE)
480 itkLegacyMacro(virtual void SetUseFixedSampledPointSet(bool v)) { this->SetUseSampledPointSet(v); }
481 itkLegacyMacro(virtual bool GetUseFixedSampledPointSet() const) { return this->GetUseSampledPointSet(); }
482 itkLegacyMacro(virtual void UseFixedSampledPointSetOn()) { return this->UseSampledPointSetOn(); }
483 itkLegacyMacro(virtual void UseFixedSampledPointSetOff()) { return this->UseSampledPointSetOff(); }
484#endif
489 itkSetObjectMacro(FixedImageGradientFilter, FixedImageGradientFilterType);
490 itkGetModifiableObjectMacro(FixedImageGradientFilter, FixedImageGradientFilterType);
491 itkSetObjectMacro(MovingImageGradientFilter, MovingImageGradientFilterType);
492 itkGetModifiableObjectMacro(MovingImageGradientFilter, MovingImageGradientFilterType);
496 itkSetObjectMacro(FixedImageGradientCalculator, FixedImageGradientCalculatorType);
497 itkGetModifiableObjectMacro(FixedImageGradientCalculator, FixedImageGradientCalculatorType);
498 itkSetObjectMacro(MovingImageGradientCalculator, MovingImageGradientCalculatorType);
499 itkGetModifiableObjectMacro(MovingImageGradientCalculator, MovingImageGradientCalculatorType);
504 itkSetMacro(UseFixedImageGradientFilter, bool);
505 itkGetConstReferenceMacro(UseFixedImageGradientFilter, bool);
506 itkBooleanMacro(UseFixedImageGradientFilter);
510 itkSetMacro(UseMovingImageGradientFilter, bool);
511 itkGetConstReferenceMacro(UseMovingImageGradientFilter, bool);
512 itkBooleanMacro(UseMovingImageGradientFilter);
518 virtual ThreadIdType
520
524 virtual void
526 virtual ThreadIdType
530#if !defined(ITK_LEGACY_REMOVE)
536 itkLegacyMacro(virtual ThreadIdType GetNumberOfThreadsUsed() const) { return this->GetNumberOfWorkUnitsUsed(); }
537
544 itkLegacyMacro(virtual void SetMaximumNumberOfThreads(const ThreadIdType count))
545 {
546 this->SetMaximumNumberOfWorkUnits(count);
547 }
548 itkLegacyMacro(virtual ThreadIdType GetMaximumNumberOfThreads() const) { return this->GetMaximumNumberOfWorkUnits(); }
549#endif // !ITK_LEGACY_REMOVE
560 virtual void
561 FinalizeThread(const ThreadIdType /*threadId*/)
562 { /*Do nothing by default */
563 }
564
566 itkGetModifiableObjectMacro(FixedImageGradientImage, FixedImageGradientImageType);
567
569 itkGetModifiableObjectMacro(MovingImageGradientImage, MovingImageGradientImageType);
570
577
591 itkSetMacro(UseFloatingPointCorrection, bool);
592 itkGetConstReferenceMacro(UseFloatingPointCorrection, bool);
593 itkBooleanMacro(UseFloatingPointCorrection);
600 itkSetMacro(FloatingPointCorrectionResolution, DerivativeValueType);
601 itkGetConstMacro(FloatingPointCorrectionResolution, DerivativeValueType);
604 /* Initialize the metric before calling GetValue or GetDerivative.
605 * Derived classes must call this Superclass version if they override
606 * this to perform their own initialization.
607 * \note This is meant to be called once for a particular metric setup.
608 * That is, when used in registration, this method would be called once
609 * before entering the registration loop, during which GetValue or
610 * GetDerivative will be called repeatedly. It must be called again if
611 * metric settings are changed before beginning a new registration. */
612 void
613 Initialize() override;
614
616 GetValue() const override;
617
618 void
619 GetDerivative(DerivativeType &) const override;
620
626 void
627 GetValueAndDerivative(MeasureType & value, DerivativeType & derivative) const override;
628
632 itkGetConstReferenceMacro(NumberOfSkippedFixedSampledPoints, SizeValueType);
633
634 bool
636 {
637 return true;
638 }
639
640 using typename Superclass::MetricCategoryType;
641
643 MetricCategoryType
644 GetMetricCategory() const override
645 {
646 return MetricCategoryType::IMAGE_METRIC;
647 }
648
649protected:
650 /* Interpolators for image gradient filters. */
655
657 ThreadedImageRegionPartitioner<VirtualImageDimension>,
658 Self>;
661 Self>;
663
664 /* A DenseGetValueAndDerivativeThreader
665 * Derived classes must define this class and assign it in their constructor
666 * if threaded processing in GetValueAndDerivative is performed. */
669 /* A SparseGetValueAndDerivativeThreader
670 * Derived classes must define this class and assign it in their constructor
671 * if threaded processing in GetValueAndDerivative is performed. */
674
679 virtual void
681
689 bool
691 FixedImagePointType & mappedFixedPoint,
692 FixedImagePixelType & mappedFixedPixelValue) const;
693
695 bool
697 MovingImagePointType & mappedMovingPoint,
698 MovingImagePixelType & mappedMovingPixelValue) const;
699
701 virtual void
703
705 virtual void
707
711 virtual void
713
717 virtual void
719
726 virtual void
728
731 virtual void
733 virtual void
738 itkGetConstMacro(ComputeDerivative, bool);
739
741 MovingImageConstPointer m_MovingImage{};
742
744 FixedInterpolatorPointer m_FixedInterpolator{};
745 MovingInterpolatorPointer m_MovingInterpolator{};
746 typename FixedImageGradientInterpolatorType::Pointer m_FixedImageGradientInterpolator{};
747 typename MovingImageGradientInterpolatorType::Pointer m_MovingImageGradientInterpolator{};
748
751 bool m_UseFixedImageGradientFilter{};
752 bool m_UseMovingImageGradientFilter{};
753
755 FixedImageGradientFilterPointer m_FixedImageGradientFilter{};
756 MovingImageGradientFilterPointer m_MovingImageGradientFilter{};
757
760 typename DefaultFixedImageGradientFilter::Pointer m_DefaultFixedImageGradientFilter{};
761 typename DefaultMovingImageGradientFilter::Pointer m_DefaultMovingImageGradientFilter{};
762
765 typename DefaultFixedImageGradientCalculator::Pointer m_DefaultFixedImageGradientCalculator{};
766 typename DefaultMovingImageGradientCalculator::Pointer m_DefaultMovingImageGradientCalculator{};
767
769 mutable FixedImageGradientImagePointer m_FixedImageGradientImage{};
770 mutable MovingImageGradientImagePointer m_MovingImageGradientImage{};
771
773 FixedImageGradientCalculatorPointer m_FixedImageGradientCalculator{};
774 MovingImageGradientCalculatorPointer m_MovingImageGradientCalculator{};
775
782 mutable DerivativeType * m_DerivativeResult{};
783
785 FixedImageMaskConstPointer m_FixedImageMask{};
786 MovingImageMaskConstPointer m_MovingImageMask{};
787
789 FixedSampledPointSetConstPointer m_FixedSampledPointSet{};
790 VirtualPointSetPointer m_VirtualSampledPointSet{};
791
793 bool m_UseSampledPointSet{};
794
797 bool m_UseVirtualSampledPointSet{};
798
800 ~ImageToImageMetricv4() override = default;
801
802 void
803 PrintSelf(std::ostream & os, Indent indent) const override;
804
805private:
807 void
809
811 void
813 typename FixedTransformType::OutputPointType & mappedFixedPoint) const
814 {
815 mappedFixedPoint = this->m_FixedTransform->TransformPoint(virtualPoint);
816 }
817 // cast the virtual point
818 template <typename TVirtualPoint>
819 void
820 LocalTransformPoint(const TVirtualPoint & virtualPoint,
821 typename FixedTransformType::OutputPointType & mappedFixedPoint) const
822 {
823 typename FixedTransformType::OutputPointType localVirtualPoint;
826 localVirtualPoint.CastFrom(virtualPoint);
827
828 mappedFixedPoint = this->m_FixedTransform->TransformPoint(localVirtualPoint);
829 }
830 // cast the mapped Fixed Point
831 template <typename TFixedImagePoint>
832 void
834 TFixedImagePoint & mappedFixedPoint) const
835 {
836 typename FixedTransformType::OutputPointType localMappedFixedPoint;
837 localMappedFixedPoint.CastFrom(mappedFixedPoint);
838 localMappedFixedPoint = this->m_FixedTransform->TransformPoint(virtualPoint);
839 mappedFixedPoint.CastFrom(localMappedFixedPoint);
840 }
841 // cast both mapped and fixed point.
842 template <typename TVirtualPoint, typename TFixedImagePoint>
843 void
844 LocalTransformPoint(const TVirtualPoint & virtualPoint, TFixedImagePoint & mappedFixedPoint) const
845 {
846 typename FixedTransformType::OutputPointType localVirtualPoint;
847 typename FixedTransformType::OutputPointType localMappedFixedPoint;
848
849 localVirtualPoint.CastFrom(virtualPoint);
850 localMappedFixedPoint.CastFrom(mappedFixedPoint);
851
852 localMappedFixedPoint = this->m_FixedTransform->TransformPoint(localVirtualPoint);
853 mappedFixedPoint.CastFrom(localMappedFixedPoint);
854 }
855
858 mutable bool m_HaveMadeGetValueWarning{};
859
863 SizeValueType m_NumberOfSkippedFixedSampledPoints{};
864
865 bool m_UseFloatingPointCorrection{};
866 DerivativeValueType m_FloatingPointCorrectionResolution{};
867
868 MetricTraits m_MetricTraits{};
869
871 mutable bool m_ComputeDerivative{};
872
875#ifdef ITK_USE_CONCEPT_CHECKING
880#endif // ITK_USE_CONCEPT_CHECKING
881};
882} // namespace itk
885#ifndef ITK_MANUAL_INSTANTIATION
886# include "itkImageToImageMetricv4.hxx"
887#endif
888
889#endif
A templated class holding a n-Dimensional covariant vector.
Provides threading for ImageToImageMetricv4::GetValueAndDerivative.
void LocalTransformPoint(const TVirtualPoint &virtualPoint, TFixedImagePoint &mappedFixedPoint) const
typename DerivativeType::ValueType DerivativeValueType
typename MetricTraits::DefaultFixedImageGradientCalculator DefaultFixedImageGradientCalculator
virtual void ComputeFixedImageGradientAtPoint(const FixedImagePointType &mappedPoint, FixedImageGradientType &gradient) const
~ImageToImageMetricv4() override=default
virtual void InitializeDefaultFixedImageGradientFilter()
virtual void ComputeMovingImageGradientFilterImage() const
typename MovingImageType::ConstPointer MovingImageConstPointer
typename PixelTraits< FixedImagePixelType >::ValueType FixedImagePixelValueType
typename MetricTraits::MovingImageGradientFilterType MovingImageGradientFilterType
typename MetricTraits::MovingImageGradientImageType MovingImageGradientImageType
typename MovingImageType::PointType MovingImagePointType
ImageToImageMetricv4GetValueAndDerivativeThreader< ThreadedImageRegionPartitioner< VirtualImageDimension >, Self >::Pointer m_DenseGetValueAndDerivativeThreader
typename Superclass::VirtualImageType VirtualImageType
typename MetricTraits::DefaultFixedImageGradientFilter DefaultFixedImageGradientFilter
virtual void InitializeForIteration() const
typename MovingImageType::Pointer MovingImagePointer
TInternalComputationValueType InternalComputationValueType
typename FixedImageGradientImageType::Pointer FixedImageGradientImagePointer
typename PixelTraits< MovingImagePixelType >::ValueType MovingImagePixelValueType
typename FixedImageMaskType::Pointer FixedImageMaskPointer
typename FixedImageType::PixelType FixedImagePixelType
void Initialize() override
MovingImagePixelType MovingPixelType
typename Superclass::VirtualSizeType VirtualRadiusType
typename MetricTraits::DefaultMovingImageGradientCalculator DefaultMovingImageGradientCalculator
typename MovingImageGradientCalculatorType::Pointer MovingImageGradientCalculatorPointer
bool TransformAndEvaluateFixedPoint(const VirtualPointType &virtualPoint, FixedImagePointType &mappedFixedPoint, FixedImagePixelType &mappedFixedPixelValue) const
void SetFixedObject(const ObjectType *object) override
MetricCategoryType GetMetricCategory() const override
MeasureType GetValue() const override
typename NumericTraits< MovingRealType >::ScalarRealType MovingScalarRealType
void GetDerivative(DerivativeType &) const override
typename MetricTraits::FixedImageGradientImageType FixedImageGradientImageType
typename MovingImageGradientImageType::Pointer MovingImageGradientImagePointer
virtual void SetMaximumNumberOfWorkUnits(const ThreadIdType number)
typename FixedImageGradientCalculatorType::Pointer FixedImageGradientCalculatorPointer
void GetValueAndDerivative(MeasureType &value, DerivativeType &derivative) const override
typename FixedImageMaskType::ConstPointer FixedImageMaskConstPointer
SizeValueType GetNumberOfDomainPoints() const
virtual void ComputeFixedImageGradientFilterImage()
virtual void GetValueAndDerivativeExecute() const
typename MetricTraits::DefaultMovingImageGradientFilter DefaultMovingImageGradientFilter
typename FixedImageType::PointType FixedImagePointType
typename MovingImageType::RegionType MovingImageRegionType
typename MetricTraits::VirtualImageGradientType VirtualImageGradientType
typename MetricTraits::FixedGradientPixelType FixedGradientPixelType
typename MovingInterpolatorType::Pointer MovingInterpolatorPointer
bool TransformAndEvaluateMovingPoint(const VirtualPointType &virtualPoint, MovingImagePointType &mappedMovingPoint, MovingImagePixelType &mappedMovingPixelValue) const
typename MetricTraits::MovingImageGradientCalculatorType MovingImageGradientCalculatorType
typename MetricTraits::MovingRealType MovingRealType
typename FixedImageType::Pointer FixedImagePointer
typename FixedSampledPointSetType::ConstPointer FixedSampledPointSetConstPointer
void LocalTransformPoint(const typename FixedTransformType::OutputPointType &virtualPoint, typename FixedTransformType::OutputPointType &mappedFixedPoint) const
void LocalTransformPoint(const TVirtualPoint &virtualPoint, typename FixedTransformType::OutputPointType &mappedFixedPoint) const
ImageToImageMetricv4GetValueAndDerivativeThreader< ThreadedIndexedContainerPartitioner, Self >::Pointer m_SparseGetValueAndDerivativeThreader
virtual ThreadIdType GetMaximumNumberOfWorkUnits() const
typename MetricTraits::FixedImageGradientCalculatorType FixedImageGradientCalculatorType
typename MetricTraits::MovingImageGradientType MovingImageGradientType
typename MetricTraits::FixedImageGradientFilterType FixedImageGradientFilterType
void LocalTransformPoint(const typename FixedTransformType::OutputPointType &virtualPoint, TFixedImagePoint &mappedFixedPoint) const
typename MovingImageType::IndexType MovingImageIndexType
typename MovingImageType::PixelType MovingImagePixelType
void PrintSelf(std::ostream &os, Indent indent) const override
void SetMovingObject(const ObjectType *object) override
bool SupportsArbitraryVirtualDomainSamples() const override
typename FixedImageGradientFilterType::Pointer FixedImageGradientFilterPointer
virtual void FinalizeThread(const ThreadIdType)
typename Superclass::VirtualPointType VirtualOriginType
typename MetricTraits::MovingGradientPixelType MovingGradientPixelType
typename Superclass::DimensionType ImageDimensionType
typename FixedInterpolatorType::Pointer FixedInterpolatorPointer
typename MovingImageMaskType::ConstPointer MovingImageMaskConstPointer
typename Superclass::ObjectType ObjectType
typename MetricTraits::FixedRealType FixedRealType
typename FixedSampledPointSetType::Pointer FixedSampledPointSetPointer
virtual ThreadIdType GetNumberOfWorkUnitsUsed() const
typename NumericTraits< FixedRealType >::ScalarRealType FixedScalarRealType
typename FixedImageType::ConstPointer FixedImageConstPointer
typename FixedImageType::IndexType FixedImageIndexType
typename MovingImageMaskType::Pointer MovingImageMaskPointer
virtual void ComputeMovingImageGradientAtPoint(const MovingImagePointType &mappedPoint, MovingImageGradientType &gradient) const
typename MovingImageGradientFilterType::Pointer MovingImageGradientFilterPointer
virtual void InitializeDefaultMovingImageGradientFilter()
typename MetricTraits::FixedImageGradientType FixedImageGradientType
Control indentation during Print() invocation.
Definition: itkIndent.h:50
Base class for all image interpolators.
Light weight base class for most itk classes.
Linearly interpolate an image at specified positions.
Computes similarity between regions of two objects.
typename TPixelType::ValueType ValueType
A superclass of the N-dimensional mesh structure; supports point (geometric coordinate and attribute)...
Definition: itkPointSet.h:83
A templated class holding a geometric point in n-Dimensional space.
Definition: itkPoint.h:54
void CastFrom(const Point< TCoordRepB, VPointDimension > &pa)
Definition: itkPoint.h:265
Implementation of the composite pattern.
Class for partitioning of an ImageRegion.
SmartPointer< const Self > ConstPointer
SmartPointer< Self > Pointer
#define itkConceptMacro(name, concept)
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
unsigned int ThreadIdType
Definition: itkIntTypes.h:99
unsigned long SizeValueType
Definition: itkIntTypes.h:83