ITK  6.0.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))
481 {
482 this->SetUseSampledPointSet(v);
483 }
484 itkLegacyMacro(virtual bool GetUseFixedSampledPointSet() const)
485 {
486 return this->GetUseSampledPointSet();
487 }
488 itkLegacyMacro(virtual void UseFixedSampledPointSetOn())
489 {
490 return this->UseSampledPointSetOn();
491 }
492 itkLegacyMacro(virtual void UseFixedSampledPointSetOff())
493 {
494 return this->UseSampledPointSetOff();
495 }
496#endif
501 itkSetObjectMacro(FixedImageGradientFilter, FixedImageGradientFilterType);
502 itkGetModifiableObjectMacro(FixedImageGradientFilter, FixedImageGradientFilterType);
503 itkSetObjectMacro(MovingImageGradientFilter, MovingImageGradientFilterType);
504 itkGetModifiableObjectMacro(MovingImageGradientFilter, MovingImageGradientFilterType);
508 itkSetObjectMacro(FixedImageGradientCalculator, FixedImageGradientCalculatorType);
509 itkGetModifiableObjectMacro(FixedImageGradientCalculator, FixedImageGradientCalculatorType);
510 itkSetObjectMacro(MovingImageGradientCalculator, MovingImageGradientCalculatorType);
511 itkGetModifiableObjectMacro(MovingImageGradientCalculator, MovingImageGradientCalculatorType);
516 itkSetMacro(UseFixedImageGradientFilter, bool);
517 itkGetConstReferenceMacro(UseFixedImageGradientFilter, bool);
518 itkBooleanMacro(UseFixedImageGradientFilter);
522 itkSetMacro(UseMovingImageGradientFilter, bool);
523 itkGetConstReferenceMacro(UseMovingImageGradientFilter, bool);
524 itkBooleanMacro(UseMovingImageGradientFilter);
530 virtual ThreadIdType
532
536 virtual void
538 virtual ThreadIdType
542#if !defined(ITK_LEGACY_REMOVE)
548 itkLegacyMacro(virtual ThreadIdType GetNumberOfThreadsUsed() const)
549 {
550 return this->GetNumberOfWorkUnitsUsed();
551 }
552
559 itkLegacyMacro(virtual void SetMaximumNumberOfThreads(const ThreadIdType count))
560 {
561 this->SetMaximumNumberOfWorkUnits(count);
562 }
563 itkLegacyMacro(virtual ThreadIdType GetMaximumNumberOfThreads() const)
564 {
565 return this->GetMaximumNumberOfWorkUnits();
566 }
567#endif // !ITK_LEGACY_REMOVE
578 virtual void
579 FinalizeThread(const ThreadIdType /*threadId*/)
580 { /*Do nothing by default */
581 }
582
584 itkGetModifiableObjectMacro(FixedImageGradientImage, FixedImageGradientImageType);
585
587 itkGetModifiableObjectMacro(MovingImageGradientImage, MovingImageGradientImageType);
588
595
609 itkSetMacro(UseFloatingPointCorrection, bool);
610 itkGetConstReferenceMacro(UseFloatingPointCorrection, bool);
611 itkBooleanMacro(UseFloatingPointCorrection);
618 itkSetMacro(FloatingPointCorrectionResolution, DerivativeValueType);
619 itkGetConstMacro(FloatingPointCorrectionResolution, DerivativeValueType);
622 /* Initialize the metric before calling GetValue or GetDerivative.
623 * Derived classes must call this Superclass version if they override
624 * this to perform their own initialization.
625 * \note This is meant to be called once for a particular metric setup.
626 * That is, when used in registration, this method would be called once
627 * before entering the registration loop, during which GetValue or
628 * GetDerivative will be called repeatedly. It must be called again if
629 * metric settings are changed before beginning a new registration. */
630 void
631 Initialize() override;
632
634 GetValue() const override;
635
636 void
637 GetDerivative(DerivativeType &) const override;
638
644 void
645 GetValueAndDerivative(MeasureType & value, DerivativeType & derivative) const override;
646
650 itkGetConstReferenceMacro(NumberOfSkippedFixedSampledPoints, SizeValueType);
651
652 bool
654 {
655 return true;
656 }
657
658 using typename Superclass::MetricCategoryType;
659
661 MetricCategoryType
662 GetMetricCategory() const override
663 {
664 return MetricCategoryType::IMAGE_METRIC;
665 }
666
667protected:
668 /* Interpolators for image gradient filters. */
673
675 ThreadedImageRegionPartitioner<VirtualImageDimension>,
676 Self>;
679 Self>;
681
682 /* A DenseGetValueAndDerivativeThreader
683 * Derived classes must define this class and assign it in their constructor
684 * if threaded processing in GetValueAndDerivative is performed. */
687 /* A SparseGetValueAndDerivativeThreader
688 * Derived classes must define this class and assign it in their constructor
689 * if threaded processing in GetValueAndDerivative is performed. */
692
697 virtual void
699
707 bool
709 FixedImagePointType & mappedFixedPoint,
710 FixedImagePixelType & mappedFixedPixelValue) const;
711
713 bool
715 MovingImagePointType & mappedMovingPoint,
716 MovingImagePixelType & mappedMovingPixelValue) const;
717
719 virtual void
721
723 virtual void
725
729 virtual void
731
735 virtual void
737
744 virtual void
746
749 virtual void
751 virtual void
756 itkGetConstMacro(ComputeDerivative, bool);
757
759 MovingImageConstPointer m_MovingImage{};
760
762 FixedInterpolatorPointer m_FixedInterpolator{};
763 MovingInterpolatorPointer m_MovingInterpolator{};
764 typename FixedImageGradientInterpolatorType::Pointer m_FixedImageGradientInterpolator{};
765 typename MovingImageGradientInterpolatorType::Pointer m_MovingImageGradientInterpolator{};
766
769 bool m_UseFixedImageGradientFilter{};
770 bool m_UseMovingImageGradientFilter{};
771
773 FixedImageGradientFilterPointer m_FixedImageGradientFilter{};
774 MovingImageGradientFilterPointer m_MovingImageGradientFilter{};
775
778 typename DefaultFixedImageGradientFilter::Pointer m_DefaultFixedImageGradientFilter{};
779 typename DefaultMovingImageGradientFilter::Pointer m_DefaultMovingImageGradientFilter{};
780
783 typename DefaultFixedImageGradientCalculator::Pointer m_DefaultFixedImageGradientCalculator{};
784 typename DefaultMovingImageGradientCalculator::Pointer m_DefaultMovingImageGradientCalculator{};
785
787 mutable FixedImageGradientImagePointer m_FixedImageGradientImage{};
788 mutable MovingImageGradientImagePointer m_MovingImageGradientImage{};
789
791 FixedImageGradientCalculatorPointer m_FixedImageGradientCalculator{};
792 MovingImageGradientCalculatorPointer m_MovingImageGradientCalculator{};
793
800 mutable DerivativeType * m_DerivativeResult{};
801
803 FixedImageMaskConstPointer m_FixedImageMask{};
804 MovingImageMaskConstPointer m_MovingImageMask{};
805
807 FixedSampledPointSetConstPointer m_FixedSampledPointSet{};
808 VirtualPointSetPointer m_VirtualSampledPointSet{};
809
811 bool m_UseSampledPointSet{};
812
815 bool m_UseVirtualSampledPointSet{};
816
818 ~ImageToImageMetricv4() override = default;
819
820 void
821 PrintSelf(std::ostream & os, Indent indent) const override;
822
823private:
825 void
827
829 void
831 typename FixedTransformType::OutputPointType & mappedFixedPoint) const
832 {
833 mappedFixedPoint = this->m_FixedTransform->TransformPoint(virtualPoint);
834 }
835 // cast the virtual point
836 template <typename TVirtualPoint>
837 void
838 LocalTransformPoint(const TVirtualPoint & virtualPoint,
839 typename FixedTransformType::OutputPointType & mappedFixedPoint) const
840 {
841 typename FixedTransformType::OutputPointType localVirtualPoint;
844 localVirtualPoint.CastFrom(virtualPoint);
845
846 mappedFixedPoint = this->m_FixedTransform->TransformPoint(localVirtualPoint);
847 }
848 // cast the mapped Fixed Point
849 template <typename TFixedImagePoint>
850 void
852 TFixedImagePoint & mappedFixedPoint) const
853 {
854 typename FixedTransformType::OutputPointType localMappedFixedPoint;
855 localMappedFixedPoint.CastFrom(mappedFixedPoint);
856 localMappedFixedPoint = this->m_FixedTransform->TransformPoint(virtualPoint);
857 mappedFixedPoint.CastFrom(localMappedFixedPoint);
858 }
859 // cast both mapped and fixed point.
860 template <typename TVirtualPoint, typename TFixedImagePoint>
861 void
862 LocalTransformPoint(const TVirtualPoint & virtualPoint, TFixedImagePoint & mappedFixedPoint) const
863 {
864 typename FixedTransformType::OutputPointType localVirtualPoint;
865 typename FixedTransformType::OutputPointType localMappedFixedPoint;
866
867 localVirtualPoint.CastFrom(virtualPoint);
868 localMappedFixedPoint.CastFrom(mappedFixedPoint);
869
870 localMappedFixedPoint = this->m_FixedTransform->TransformPoint(localVirtualPoint);
871 mappedFixedPoint.CastFrom(localMappedFixedPoint);
872 }
873
876 mutable bool m_HaveMadeGetValueWarning{};
877
881 SizeValueType m_NumberOfSkippedFixedSampledPoints{};
882
883 bool m_UseFloatingPointCorrection{};
884 DerivativeValueType m_FloatingPointCorrectionResolution{};
885
886 MetricTraits m_MetricTraits{};
887
889 mutable bool m_ComputeDerivative{};
890
893#ifdef ITK_USE_CONCEPT_CHECKING
898#endif // ITK_USE_CONCEPT_CHECKING
899};
900} // namespace itk
903#ifndef ITK_MANUAL_INSTANTIATION
904# include "itkImageToImageMetricv4.hxx"
905#endif
906
907#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:82
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:102
unsigned long SizeValueType
Definition: itkIntTypes.h:86