A variety of compile fixes which appear when legacy is disabled

Examples/ANTSUseLandmarkImagesToGetBSplineDisplacementField.cxx

@@ -11,6 +11,7 @@
 #include "itkImportImageFilter.h"
 #include "itkVectorLinearInterpolateImageFunction.h"
 #include "itkPointSet.h"
+#include "itkFloatTypes.h"
 
 #include <string>
 #include <vector>
@@ -283,7 +284,8 @@ LandmarkBasedDisplacementFieldTransformInitializer(int argc, char * argv[])
         }
 
         itk::ContinuousIndex<double, ImageDimension> fixedCidx;
-        fixedImage->TransformPhysicalPointToContinuousIndex(fixedPhysicalPoint, fixedCidx);
+        fixedCidx = fixedImage->
+                template TransformPhysicalPointToContinuousIndex<double, itk::SpacePrecisionType>(fixedPhysicalPoint);
 
         typename DisplacementFieldType::PointType fieldPoint;
         parametricInputImage->TransformContinuousIndexToPhysicalPoint(fixedCidx, fieldPoint);
@@ -540,13 +542,11 @@ ANTSUseLandmarkImagesToGetBSplineDisplacementField(std::vector<std::string> args
 
   switch (imageIO->GetNumberOfDimensions())
   {
-    case 2:
-    {
+    case 2: {
       LandmarkBasedDisplacementFieldTransformInitializer<2>(argc, argv);
     }
     break;
-    case 3:
-    {
+    case 3: {
       LandmarkBasedDisplacementFieldTransformInitializer<3>(argc, argv);
     }
     break;

Examples/Atropos.cxx

@@ -1322,25 +1322,25 @@ AtroposInitializeCommandLineOptions(itk::ants::CommandLineParser * parser)
   }
 
   {
-    std::string description = std::string("Different posterior probability formulations are possible as ") +
-                              std::string("are different update options.  To guarantee theoretical ") +
-                              std::string("convergence properties, a proper formulation of the well-known ") +
-                              std::string("iterated conditional modes (ICM) uses an asynchronous update step ") +
-                              std::string("modulated by a specified annealing temperature.  If one sets ") +
-                              std::string("the AnnealingTemperature > 1 in the posterior formulation ") +
-                              std::string("a traditional code set for a proper ICM update will be created. ") +
-                              std::string("Otherwise, a synchronous update step will take place at each iteration. ") +
-                              std::string("The annealing temperature, T, converts the posteriorProbability ") +
-                              std::string("to posteriorProbability^(1/T) over the course of optimization. ");
-    std::string("Options include the following:  ") +
+    std::string description =
+      std::string("Different posterior probability formulations are possible as ") +
+      std::string("are different update options.  To guarantee theoretical ") +
+      std::string("convergence properties, a proper formulation of the well-known ") +
+      std::string("iterated conditional modes (ICM) uses an asynchronous update step ") +
+      std::string("modulated by a specified annealing temperature.  If one sets ") +
+      std::string("the AnnealingTemperature > 1 in the posterior formulation ") +
+      std::string("a traditional code set for a proper ICM update will be created. ") +
+      std::string("Otherwise, a synchronous update step will take place at each iteration. ") +
+      std::string("The annealing temperature, T, converts the posteriorProbability ") +
+      std::string("to posteriorProbability^(1/T) over the course of optimization. ") +
+      std::string("Options include the following:  ") +
       std::string(" Socrates: posteriorProbability = (spatialPrior)^priorWeight") +
       std::string("*(likelihood*mrfPrior)^(1-priorWeight), ") + std::string(" Plato: posteriorProbability = 1.0, ") +
-      std::string(" Aristotle: posteriorProbability = 1.0, ") +
-      std::string(" Sigmoid: posteriorProbability = 1.0, ") /* +
-   std::string( " Zeno: posteriorProbability = 1.0\n" ) +
-   std::string( " Diogenes: posteriorProbability = 1.0\n" ) +
-   std::string( " Thales: posteriorProbability = 1.0\n" ) +
-   std::string( " Democritus: posteriorProbability = 1.0.\n" ) */
+      std::string(" Aristotle: posteriorProbability = 1.0, ") + std::string(" Sigmoid: posteriorProbability = 1.0, ")
+      // std::string( " Zeno: posteriorProbability = 1.0\n" ) +
+      // std::string( " Diogenes: posteriorProbability = 1.0\n" ) +
+      // std::string( " Thales: posteriorProbability = 1.0\n" ) +
+      // std::string( " Democritus: posteriorProbability = 1.0.\n" )
       ;
 
     OptionType::Pointer option = OptionType::New();

Examples/AverageAffineTransform.cxx

@@ -311,7 +311,7 @@ AverageAffineTransform(std::vector<std::string> args, std::ostream * /*out_strea
   {
     kImageDim = std::stoi(argv[1]);
   }
-  catch (const std::invalid_argument & e)
+  catch (const std::invalid_argument &)
   {
     std::cerr << "Invalid image dimension: " << argv[1] << std::endl;
     return EXIT_FAILURE;

Examples/CreateTiledMosaic.cxx

@@ -826,7 +826,9 @@ CreateMosaic(itk::ants::CommandLineParser * parser)
           rgbPadder->SetInput(rgbExtracter->GetOutput());
           rgbPadder->SetPadLowerBound(lowerBound);
           rgbPadder->SetPadUpperBound(upperBound);
-          rgbPadder->SetConstant(static_cast<PixelType>(padValue));
+          RgbPixelType rgbPadValue;
+          rgbPadValue.Fill(padValue);
+          rgbPadder->SetConstant(rgbPadValue);
 
           outputRgbSlice = rgbPadder->GetOutput();
           outputRgbSlice->Update();

Examples/DeNrrd.cxx

@@ -26,6 +26,7 @@
 #include <itkNrrdImageIO.h>
 #include <itkVectorImage.h>
 #include <itkVariableLengthVector.h>
+#include <itkCommonEnums.h>
 
 #include <itkMetaDataDictionary.h>
 
@@ -113,7 +114,7 @@ DeNrrd(std::vector<std::string> args, std::ostream * /*out_stream = nullptr */)
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   // io->SetNrrdVectorType( nrrdKindList );
-  io->SetFileType(itk::ImageIOBase::ASCII);
+  io->SetFileType(itk::CommonEnums::IOFile::ASCII);
 
   // std::cout  << "Number of dwi values " << reader->GetOutput()->GetNumberOfComponentsPerPixel() << std::endl;
 

Examples/ImageMath_Templates.hxx

@@ -3756,8 +3756,8 @@ TimeSeriesToMatrix(int argc, char * argv[])
       {
         typename MatrixImageType::IndexType matind;
         matind.Fill(0);
-        matind[1] = t;
-        matind[2] = voxct;
+        matind[0] = t;
+        matind[1] = voxct;
         tind[ImageDimension - 1] = t;
         Scalar pix = image1->GetPixel(tind);
         mSample(t) = pix;
@@ -5916,7 +5916,11 @@ VImageMath(int argc, char * argv[])
 
     if (strcmp(operation.c_str(), "vm") == 0)
     {
-      result = pix1 * pix2;
+      // element-wise multiplication
+      for (unsigned d = 0; d < pix1.GetNumberOfComponents(); ++d)
+      {
+        result[d] = pix1[d] * pix2[d];
+      }
     }
     else if (strcmp(operation.c_str(), "v+") == 0)
     {
@@ -5933,7 +5937,7 @@ VImageMath(int argc, char * argv[])
     }
     else if (strcmp(operation.c_str(), "vtotal") == 0)
     {
-      result += pix1 * pix2;
+      result.Fill(pix1 * pix2);
     }
     vfIter2.Set(result);
   }

Examples/MultiplyImages.cxx

@@ -114,7 +114,13 @@ MultiplyImages(int argc, char * argv[])
     }
     else
     {
-      vfIter2.Set(pix1 * image2->GetPixel(ind));
+      // element-wise multiplication
+      PixelType result = image2->GetPixel(ind);
+      for (unsigned d = 0; d < pix1.GetNumberOfComponents(); ++d)
+      {
+        result[d] *= pix1[d];
+      }
+      vfIter2.Set(result);
     }
   }
   typename writertype::Pointer writer = writertype::New();

Examples/PrintHeader.cxx

@@ -52,58 +52,58 @@ try_print_metadata(itk::MetaDataDictionary & mdd, std::string key)
 }
 
 string
-get_rai_code(itk::SpatialOrientation::ValidCoordinateOrientationFlags code)
+get_rai_code(itk::SpatialOrientationEnums::ValidCoordinateOrientations code)
 {
-  std::map<itk::SpatialOrientation::ValidCoordinateOrientationFlags, string> m_CodeToString;
-
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RIP] = "RIP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LIP] = "LIP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RSP] = "RSP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LSP] = "LSP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RIA] = "RIA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LIA] = "LIA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RSA] = "RSA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LSA] = "LSA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_IRP] = "IRP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ILP] = "ILP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SRP] = "SRP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SLP] = "SLP";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_IRA] = "IRA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ILA] = "ILA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SRA] = "SRA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SLA] = "SLA";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RPI] = "RPI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LPI] = "LPI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RAI] = "RAI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LAI] = "LAI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RPS] = "RPS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LPS] = "LPS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RAS] = "RAS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LAS] = "LAS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PRI] = "PRI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PLI] = "PLI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ARI] = "ARI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ALI] = "ALI";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PRS] = "PRS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PLS] = "PLS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ARS] = "ARS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ALS] = "ALS";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_IPR] = "IPR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SPR] = "SPR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_IAR] = "IAR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SAR] = "SAR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_IPL] = "IPL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SPL] = "SPL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_IAL] = "IAL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_SAL] = "SAL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PIR] = "PIR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PSR] = "PSR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_AIR] = "AIR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ASR] = "ASR";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PIL] = "PIL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_PSL] = "PSL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_AIL] = "AIL";
-  m_CodeToString[itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ASL] = "ASL";
+  std::map<itk::SpatialOrientationEnums::ValidCoordinateOrientations, string> m_CodeToString;
+
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RIP] = "RIP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LIP] = "LIP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RSP] = "RSP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LSP] = "LSP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RIA] = "RIA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LIA] = "LIA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RSA] = "RSA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LSA] = "LSA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_IRP] = "IRP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ILP] = "ILP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SRP] = "SRP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SLP] = "SLP";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_IRA] = "IRA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ILA] = "ILA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SRA] = "SRA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SLA] = "SLA";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RPI] = "RPI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LPI] = "LPI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RAI] = "RAI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LAI] = "LAI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RPS] = "RPS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LPS] = "LPS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_RAS] = "RAS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_LAS] = "LAS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PRI] = "PRI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PLI] = "PLI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ARI] = "ARI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ALI] = "ALI";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PRS] = "PRS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PLS] = "PLS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ARS] = "ARS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ALS] = "ALS";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_IPR] = "IPR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SPR] = "SPR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_IAR] = "IAR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SAR] = "SAR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_IPL] = "IPL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SPL] = "SPL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_IAL] = "IAL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_SAL] = "SAL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PIR] = "PIR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PSR] = "PSR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_AIR] = "AIR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ASR] = "ASR";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PIL] = "PIL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_PSL] = "PSL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_AIL] = "AIL";
+  m_CodeToString[itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_ASL] = "ASL";
   return m_CodeToString[code];
 }
 
@@ -280,7 +280,7 @@ PrintHeader(int argc, char * argv[])
     {
       // Get the metadata as a generic object
       string                                                   key = itMeta->first, v_string;
-      itk::SpatialOrientation::ValidCoordinateOrientationFlags v_oflags =
+      itk::SpatialOrientationEnums::ValidCoordinateOrientations v_oflags =
         itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_COORDINATE_ORIENTATION_INVALID;
 
       if (itk::ExposeMetaData<string>(mdd, key, v_string))

Examples/antsJointTensorFusion.cxx

@@ -248,11 +248,11 @@ antsJointTensorFusion(itk::ants::CommandLineParser * parser)
     ConvertToLowerCase(metricString);
     if (metricString.compare("pc") == 0)
     {
-      fusionFilter->SetSimilarityMetric(FusionFilterType::PEARSON_CORRELATION);
+      fusionFilter->SetSimilarityMetric(itk::NonLocalPatchBasedImageFilterEnums::SimilarityMetric::PEARSON_CORRELATION);
     }
     else if (metricString.compare("msq") == 0)
     {
-      fusionFilter->SetSimilarityMetric(FusionFilterType::MEAN_SQUARES);
+      fusionFilter->SetSimilarityMetric(itk::NonLocalPatchBasedImageFilterEnums::SimilarityMetric::MEAN_SQUARES);
     }
     else
     {

Examples/antsLandmarkBasedTransformInitializer.cxx

@@ -13,6 +13,7 @@
 #include "itkRigid2DTransform.h"
 #include "itkVersorRigid3DTransform.h"
 #include "itkTransformFileWriter.h"
+#include "itkFloatTypes.h"
 
 #include <string>
 #include <vector>
@@ -372,10 +373,12 @@ InitializeBSplineTransform(int argc, char * argv[])
         }
 
         itk::ContinuousIndex<double, ImageDimension> fixedCidx;
-        fixedImage->TransformPhysicalPointToContinuousIndex(fixedPhysicalPoint, fixedCidx);
+        fixedCidx = fixedImage->
+                template TransformPhysicalPointToContinuousIndex<double, itk::SpacePrecisionType>(fixedPhysicalPoint);
 
         typename DisplacementFieldType::PointType fieldPoint;
-        parametricInputImage->TransformContinuousIndexToPhysicalPoint(fixedCidx, fieldPoint);
+        fieldPoint = parametricInputImage->
+                template TransformContinuousIndexToPhysicalPoint<double, itk::SpacePrecisionType>(fixedCidx);
 
         fieldPoints->SetPoint(count, fieldPoint);
         fieldPoints->SetPointData(count, vector);