From 75b56261f31743f02c851b1b182a0bc554838548 Mon Sep 17 00:00:00 2001
From: "Matt McCormick (thewtex)" <matt@mmmccormick.com>
Date: Tue, 12 Oct 2010 16:03:09 -0500
Subject: [PATCH 01/41] ENH: File structure skeleton.

---
 .../CMakeLists.txt                            | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
new file mode 100644
index 00000000000..083112e5842
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -0,0 +1,37 @@
+project(ITK_SECOND_ORDER_GRADIENT)
+
+find_package(ITK REQUIRED)
+include(${ITK_USE_FILE})
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -ggdb3")
+
+  set(
+    CMAKE_CXX_FLAGS_RELEASE
+    "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG -march=native -ffast-math"
+  )
+  #to test, the 'graphite' gcc 4.4 optimizations
+  #set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG
+  #-march=native -ffast-math -floop-interchange -floop-strip-mine -floop-block" )
+
+  set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} -g")
+  set(
+    CMAKE_SHARED_LINKER_FLAGS_RELEASE
+    "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -O"
+  )
+endif(CMAKE_COMPILER_IS_GNUCXX)
+
+# where all the executables go
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ITK_SECOND_ORDER_GRADIENT_BINARY_DIR}/bin)
+
+include_directories(${ITK_SECOND_ORDER_GRADIENT_SOURCE_DIR}/Code)
+
+include(CTest)
+if(BUILD_TESTING)
+  enable_testing()
+  add_subdirectory(Testing)
+endif(BUILD_TESTING)
+
+add_subdirectory(Code)

From 15e9e839b0452f5a5b3216575b719d22037cb742 Mon Sep 17 00:00:00 2001
From: "Matt McCormick (thewtex)" <matt@mmmccormick.com>
Date: Wed, 13 Oct 2010 23:19:01 -0500
Subject: [PATCH 02/41] STYLE: Rename from SecondOrder to NthOrderAccurate.

Why limit ourselves to 2nd order?  Found a nice paper.
---
 .../Filtering/HigherOrderAccurateGradient/CMakeLists.txt | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
index 083112e5842..1107549756c 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -1,4 +1,4 @@
-project(ITK_SECOND_ORDER_GRADIENT)
+project(ITK_NTH_ORDER_ACCURATE_GRADIENT)
 
 find_package(ITK REQUIRED)
 include(${ITK_USE_FILE})
@@ -24,9 +24,12 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 endif(CMAKE_COMPILER_IS_GNUCXX)
 
 # where all the executables go
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ITK_SECOND_ORDER_GRADIENT_BINARY_DIR}/bin)
+set(
+  CMAKE_RUNTIME_OUTPUT_DIRECTORY
+  ${ITK_NTH_ORDER_ACCURATE_GRADIENT_BINARY_DIR}/bin
+)
 
-include_directories(${ITK_SECOND_ORDER_GRADIENT_SOURCE_DIR}/Code)
+include_directories(${ITK_NTH_ORDER_ACCURATE_GRADIENT_SOURCE_DIR}/Code)
 
 include(CTest)
 if(BUILD_TESTING)

From 4e14fd5a39716a8701e12f75a57a6bab4f6d79ca Mon Sep 17 00:00:00 2001
From: "Matt McCormick (thewtex)" <matt@mmmccormick.com>
Date: Thu, 28 Oct 2010 16:44:32 -0500
Subject: [PATCH 03/41] STYLE: Rename 'Nth' to 'Higher'

A little less confusing since the radius of the kernel corresponds to a 2N
Taylor series accuracy.
---
 .../Filtering/HigherOrderAccurateGradient/CMakeLists.txt    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
index 1107549756c..f16997675a2 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -1,4 +1,4 @@
-project(ITK_NTH_ORDER_ACCURATE_GRADIENT)
+project(ITK_HIGHER_ORDER_ACCURATE_GRADIENT)
 
 find_package(ITK REQUIRED)
 include(${ITK_USE_FILE})
@@ -26,10 +26,10 @@ endif(CMAKE_COMPILER_IS_GNUCXX)
 # where all the executables go
 set(
   CMAKE_RUNTIME_OUTPUT_DIRECTORY
-  ${ITK_NTH_ORDER_ACCURATE_GRADIENT_BINARY_DIR}/bin
+  ${ITK_HIGHER_ORDER_ACCURATE_GRADIENT_BINARY_DIR}/bin
 )
 
-include_directories(${ITK_NTH_ORDER_ACCURATE_GRADIENT_SOURCE_DIR}/Code)
+include_directories(${ITK_HIGHER_ORDER_ACCURATE_GRADIENT_SOURCE_DIR}/Code)
 
 include(CTest)
 if(BUILD_TESTING)

From 97e22e7f8778ceae23029cf0ed1e19af60a2ed6b Mon Sep 17 00:00:00 2001
From: "Matt McCormick (thewtex)" <matt@mmmccormick.com>
Date: Fri, 12 Nov 2010 07:03:47 -0600
Subject: [PATCH 04/41] ENH: Require ITKv4.

Otherwise test will fail.
---
 Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
index f16997675a2..2f8bf593177 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -2,6 +2,9 @@ project(ITK_HIGHER_ORDER_ACCURATE_GRADIENT)
 
 find_package(ITK REQUIRED)
 include(${ITK_USE_FILE})
+if(${ITK_VERSION_MAJOR} VERSION_LESS 4)
+  message(SEND_ERROR "This project requires ITKv4.")
+endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

From 0297b03a9ec73a74fa54df41c2273e9d9272a072 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt@mmmccormick.com>
Date: Sat, 7 Jul 2012 00:14:23 -0400
Subject: [PATCH 05/41] COMP: Disable test because of missing itkTestMain.h.

Will refactor for ITKv4 as a Module.
---
 Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
index 2f8bf593177..e535a9498ce 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -37,7 +37,8 @@ include_directories(${ITK_HIGHER_ORDER_ACCURATE_GRADIENT_SOURCE_DIR}/Code)
 include(CTest)
 if(BUILD_TESTING)
   enable_testing()
-  add_subdirectory(Testing)
+  # Disable until can refactor as an ITK Module.
+  #add_subdirectory( Testing )
 endif(BUILD_TESTING)
 
 add_subdirectory(Code)

From 7820f6e8dbd69cde17b87f8ca46ef29baa08633e Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 28 Sep 2014 23:41:22 -0400
Subject: [PATCH 06/41] ENH: Reorganize as an ITK module.

---
 .../CMakeLists.txt                            |  46 +---
 ...HigherOrderAccurateDerivativeImageFilter.h | 163 +++++++++++++
 ...gherOrderAccurateDerivativeImageFilter.txx | 156 +++++++++++++
 ...itkHigherOrderAccurateDerivativeOperator.h | 162 +++++++++++++
 ...kHigherOrderAccurateDerivativeOperator.txx |  70 ++++++
 ...tkHigherOrderAccurateGradientImageFilter.h | 153 ++++++++++++
 ...HigherOrderAccurateGradientImageFilter.txx | 217 ++++++++++++++++++
 .../itk-module.cmake                          |  25 ++
 .../test/CMakeLists.txt                       |  36 +++
 .../test/Input/foot.mha.md5                   |   1 +
 ...OrderAccurateDerivativeImageFilterTest.cxx |  79 +++++++
 ...erOrderAccurateGradientImageFilterTest.cxx |  74 ++++++
 12 files changed, 1138 insertions(+), 44 deletions(-)
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
index e535a9498ce..fae9f7d82a2 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -1,44 +1,2 @@
-project(ITK_HIGHER_ORDER_ACCURATE_GRADIENT)
-
-find_package(ITK REQUIRED)
-include(${ITK_USE_FILE})
-if(${ITK_VERSION_MAJOR} VERSION_LESS 4)
-  message(SEND_ERROR "This project requires ITKv4.")
-endif()
-
-if(CMAKE_COMPILER_IS_GNUCXX)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -ggdb3")
-
-  set(
-    CMAKE_CXX_FLAGS_RELEASE
-    "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG -march=native -ffast-math"
-  )
-  #to test, the 'graphite' gcc 4.4 optimizations
-  #set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG
-  #-march=native -ffast-math -floop-interchange -floop-strip-mine -floop-block" )
-
-  set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} -g")
-  set(
-    CMAKE_SHARED_LINKER_FLAGS_RELEASE
-    "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -O"
-  )
-endif(CMAKE_COMPILER_IS_GNUCXX)
-
-# where all the executables go
-set(
-  CMAKE_RUNTIME_OUTPUT_DIRECTORY
-  ${ITK_HIGHER_ORDER_ACCURATE_GRADIENT_BINARY_DIR}/bin
-)
-
-include_directories(${ITK_HIGHER_ORDER_ACCURATE_GRADIENT_SOURCE_DIR}/Code)
-
-include(CTest)
-if(BUILD_TESTING)
-  enable_testing()
-  # Disable until can refactor as an ITK Module.
-  #add_subdirectory( Testing )
-endif(BUILD_TESTING)
-
-add_subdirectory(Code)
+project(HigherOrderAccurateGradient)
+itk_module_impl()
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
new file mode 100644
index 00000000000..c8c87edfe1c
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -0,0 +1,163 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    itkHigherOrderAccurateDerivativeImageFilter.h
+  Language:  C++
+
+  Copyright (c) Insight Software Consortium. All rights reserved.
+  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __itkHigherOrderAccurateDerivativeImageFilter_h
+#define __itkHigherOrderAccurateDerivativeImageFilter_h
+
+#include "itkImageToImageFilter.h"
+
+namespace itk
+{
+/** \class HigherOrderAccurateDerivativeImageFilter
+ * \brief Computes the higher order accurate directional derivative of an image.
+ * The directional derivative at each pixel location is computed by convolution
+ * with a higher order accurate derivative operator of user-specified order.
+ *
+ * SetOrder() specifies the order of the derivative.
+ *
+ * SetDirection() specifies the direction of the derivative with respect to the
+ * coordinate axes of the image.
+ *
+ * To specify the order of accuracy, use SetOrderOfAccuracy().  The
+ * approximation will be accurate to two times the OrderOfAccuracy in terms of
+ * Taylor series terms.
+ *
+ * \sa Image
+ * \sa Neighborhood
+ * \sa NeighborhoodOperator
+ * \sa NeighborhoodIterator
+ *
+ * \ingroup ImageFeatureExtraction
+ * \ingroup HigherOrderAccurateGradient
+ */
+template <class TInputImage, class TOutputImage>
+class ITK_EXPORT HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
+{
+public:
+  /** Standard class typedefs. */
+  typedef HigherOrderAccurateDerivativeImageFilter      Self;
+  typedef ImageToImageFilter<TInputImage, TOutputImage> Superclass;
+  typedef SmartPointer<Self>                            Pointer;
+  typedef SmartPointer<const Self>                      ConstPointer;
+
+  /** Extract some information from the image types.  Dimensionality
+   * of the two images is assumed to be the same. */
+  typedef typename TOutputImage::PixelType         OutputPixelType;
+  typedef typename TOutputImage::InternalPixelType OutputInternalPixelType;
+  typedef typename TInputImage::PixelType          InputPixelType;
+  typedef typename TInputImage::InternalPixelType  InputInternalPixelType;
+
+  /** Extract some information from the image types.  Dimensionality
+   * of the two images is assumed to be the same. */
+  itkStaticConstMacro(ImageDimension, unsigned int, TOutputImage::ImageDimension);
+
+  /** Image typedef support. */
+  typedef TInputImage  InputImageType;
+  typedef TOutputImage OutputImageType;
+
+  /** Method for creation through the object factory. */
+  itkNewMacro(Self);
+
+  /** Run-time type information (and related methods). */
+  itkTypeMacro(HigherOrderAccurateDerivativeImageFilter, ImageToImageFilter);
+
+  /** The output pixel type must be signed. */
+#ifdef ITK_USE_CONCEPT_CHECKING
+  /** Begin concept checking */
+  itkConceptMacro(SignedOutputPixelType, (Concept::Signed<OutputPixelType>));
+  /** End concept checking */
+#endif
+
+  /** Standard get/set macros for filter parameters. */
+  itkSetMacro(Order, unsigned int);
+  itkGetConstMacro(Order, unsigned int);
+  itkSetMacro(OrderOfAccuracy, unsigned int);
+  itkGetConstMacro(OrderOfAccuracy, unsigned int);
+  itkSetMacro(Direction, unsigned int);
+  itkGetConstMacro(Direction, unsigned int);
+
+  /** Use the image spacing information in calculations. Use this option if you
+   *  want derivatives in physical space. Default is UseImageSpacingOn. */
+  void
+  SetUseImageSpacingOn()
+  {
+    this->SetUseImageSpacing(true);
+  }
+
+  /** Ignore the image spacing. Use this option if you want derivatives in
+      isotropic pixel space.  Default is UseImageSpacingOn. */
+  void
+  SetUseImageSpacingOff()
+  {
+    this->SetUseImageSpacing(false);
+  }
+
+  /** Set/Get whether or not the filter will use the spacing of the input
+      image in its calculations */
+  itkSetMacro(UseImageSpacing, bool);
+  itkGetConstMacro(UseImageSpacing, bool);
+
+  /** HigherOrderAccurateDerivativeImageFilter needs a larger input requested region than
+   * the output requested region (larger in the direction of the
+   * derivative).  As such, HigherOrderAccurateDerivativeImageFilter needs to provide an
+   * implementation for GenerateInputRequestedRegion() in order to
+   * inform the pipeline execution model.
+   *
+   * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
+  virtual void
+  GenerateInputRequestedRegion() throw(InvalidRequestedRegionError);
+
+protected:
+  HigherOrderAccurateDerivativeImageFilter()
+    : m_Order(1)
+    , m_OrderOfAccuracy(2)
+    , m_Direction(0)
+    , m_UseImageSpacing(true)
+  {}
+
+  virtual ~HigherOrderAccurateDerivativeImageFilter() {}
+  void
+  PrintSelf(std::ostream & os, Indent indent) const;
+
+  /** Standard pipeline method. While this class does not implement a
+   * ThreadedGenerateData(), its GenerateData() delegates all
+   * calculations to an NeighborhoodOperatorImageFilter.  Since the
+   * NeighborhoodOperatorImageFilter is multithreaded, this filter is
+   * multithreaded by default. */
+  void
+  GenerateData();
+
+private:
+  HigherOrderAccurateDerivativeImageFilter(const Self &); // purposely not implemented
+  void
+  operator=(const Self &); // purposely not implemented
+
+  /** The order of the derivative. */
+  unsigned int m_Order;
+
+  /** Order of accuracy. */
+  unsigned int m_OrderOfAccuracy;
+
+  /** The direction of the derivative. */
+  unsigned int m_Direction;
+
+  bool m_UseImageSpacing;
+};
+} // end namespace itk
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#  include "itkHigherOrderAccurateDerivativeImageFilter.txx"
+#endif
+
+#endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
new file mode 100644
index 00000000000..cd4047a0820
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
@@ -0,0 +1,156 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    itkHigherOrderAccurateDerivativeImageFilter.txx
+  Language:  C++
+
+  Copyright (c) Insight Software Consortium. All rights reserved.
+  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __itkHigherOrderAccurateDerivativeImageFilter_txx
+#define __itkHigherOrderAccurateDerivativeImageFilter_txx
+#include "itkHigherOrderAccurateDerivativeImageFilter.h"
+
+#include "itkNumericTraits.h"
+#include "itkNeighborhoodOperatorImageFilter.h"
+#include "itkHigherOrderAccurateDerivativeOperator.h"
+#include "itkProgressAccumulator.h"
+
+namespace itk
+{
+template <class TInputImage, class TOutputImage>
+void
+HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateInputRequestedRegion() throw(
+  InvalidRequestedRegionError)
+{
+  // call the superclass' implementation of this method. this should
+  // copy the output requested region to the input requested region
+  Superclass::GenerateInputRequestedRegion();
+
+  // get pointers to the input and output
+  typename Superclass::InputImagePointer inputPtr = const_cast<InputImageType *>(this->GetInput());
+
+  if (!inputPtr)
+  {
+    return;
+  }
+
+  // Build an operator so that we can determine the kernel size
+  HigherOrderAccurateDerivativeOperator<OutputPixelType, ImageDimension> oper;
+  oper.SetDirection(m_Direction);
+  oper.SetOrder(m_Order);
+  oper.SetOrderOfAccuracy(m_OrderOfAccuracy);
+  oper.CreateDirectional();
+
+  // get a copy of the input requested region (should equal the output
+  // requested region)
+  typename TInputImage::RegionType inputRequestedRegion;
+  inputRequestedRegion = inputPtr->GetRequestedRegion();
+
+  // pad the input requested region by the operator radius
+  inputRequestedRegion.PadByRadius(oper.GetRadius());
+
+  // crop the input requested region at the input's largest possible region
+  if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()))
+  {
+    inputPtr->SetRequestedRegion(inputRequestedRegion);
+    return;
+  }
+  else
+  {
+    // Couldn't crop the region (requested region is outside the largest
+    // possible region).  Throw an exception.
+
+    // store what we tried to request (prior to trying to crop)
+    inputPtr->SetRequestedRegion(inputRequestedRegion);
+
+    // build an exception
+    InvalidRequestedRegionError e(__FILE__, __LINE__);
+    e.SetLocation(ITK_LOCATION);
+    e.SetDescription("Requested region is (at least partially) outside the largest possible region.");
+    e.SetDataObject(inputPtr);
+    throw e;
+  }
+}
+
+template <class TInputImage, class TOutputImage>
+void
+HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateData()
+{
+  ZeroFluxNeumannBoundaryCondition<TInputImage> nbc;
+
+  // Define the operator value type so that we can filter integral
+  // images and have the proper operator defined.
+  typedef typename NumericTraits<OutputPixelType>::RealType OperatorValueType;
+
+  // Filter
+  HigherOrderAccurateDerivativeOperator<OperatorValueType, ImageDimension> oper;
+  oper.SetDirection(m_Direction);
+  oper.SetOrder(m_Order);
+  oper.SetOrderOfAccuracy(m_OrderOfAccuracy);
+  oper.CreateDirectional();
+  oper.FlipAxes();
+
+  if (m_UseImageSpacing == true)
+  {
+    if (this->GetInput()->GetSpacing()[m_Direction] == 0.0)
+    {
+      itkExceptionMacro(<< "Image spacing cannot be zero.");
+    }
+    else
+    {
+      oper.ScaleCoefficients(1.0 / this->GetInput()->GetSpacing()[m_Direction]);
+    }
+  }
+
+  typename NeighborhoodOperatorImageFilter<InputImageType, OutputImageType, OperatorValueType>::Pointer filter =
+    NeighborhoodOperatorImageFilter<InputImageType, OutputImageType, OperatorValueType>::New();
+
+  // Create a process accumulator for tracking the progress of this minipipeline
+  ProgressAccumulator::Pointer progress = ProgressAccumulator::New();
+  progress->SetMiniPipelineFilter(this);
+
+  // Register the filter with the with progress accumulator using
+  // equal weight proportion
+  progress->RegisterInternalFilter(filter, 1.0f);
+
+  filter->OverrideBoundaryCondition(&nbc);
+
+  //
+  // Set up the mini-pipline
+  //
+  filter->SetOperator(oper);
+  filter->SetInput(this->GetInput());
+
+  // Graft this filter's output to the mini-pipeline.  this sets up
+  // the mini-pipeline to write to this filter's output and copies
+  // region ivars and meta-data
+  filter->GraftOutput(this->GetOutput());
+
+  // Execute the mini-pipeline.
+  filter->Update();
+
+  // Graft the output of the mini-pipeline back onto the filter's output,
+  // this copies back the region ivars and meta-data.
+  this->GraftOutput(filter->GetOutput());
+}
+
+template <class TInputImage, class TOutputImage>
+void
+HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::PrintSelf(std::ostream & os, Indent indent) const
+{
+  Superclass::PrintSelf(os, indent);
+
+  os << indent << "Order: " << m_Order << std::endl;
+  os << indent << "OrderOfAccuracy: " << m_OrderOfAccuracy << std::endl;
+  os << indent << "Direction: " << m_Direction << std::endl;
+  os << indent << "UseImageSpacing: " << m_UseImageSpacing << std::endl;
+}
+} // end namespace itk
+
+#endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
new file mode 100644
index 00000000000..afc43f42291
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -0,0 +1,162 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    itkHigherOrderAccurateDerivativeOperator.h
+  Language:  C++
+
+  Copyright (c) Insight Software Consortium. All rights reserved.
+  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __itkHigherOrderAccurateDerivativeOperator_h
+#define __itkHigherOrderAccurateDerivativeOperator_h
+
+#include "itkNeighborhoodOperator.h"
+
+namespace itk
+{
+/**
+ * \class HigherOrderAccurateDerivativeOperator
+ * \brief A NeighborhoodOperator for calculating an n-th order accurate derivative
+ * at a pixel.
+ *
+ * \brief Calculate the image derivative from a higher order accurate
+ * central-difference derivative kernel.
+ *
+ * Based on the work here:
+ *
+ * Khan, IR and Ohba, Ryoji.  "Closed-form expressions for the finite difference
+ * approximations of first and higher derivatives based on Taylor series."
+ * Journal of Computational and Applied Mathematics.  vol 107.  p. 179-193.
+ * 1999.
+ *
+ * Khan, IR and Ohba, Ryoji.  "Taylor series based finite difference
+ * approximations of higher-degree derivatives."  Journal of Computational and
+ * Applied Mathematics.  vol 154.  p. 115-124.  2003.
+ *
+ * To specify the order of accuracy, use SetOrderOfAccuracy().  The
+ * approximation will be accurate to two times the OrderOfAccuracy in terms of
+ * Taylor series terms.
+ *
+ * @todo: implement support for higher order derivatives.
+ *
+ * \sa DerivativeOperator
+ * \sa NeighborhoodOperator
+ * \sa Neighborhood
+ * \sa ForwardDifferenceOperator
+ * \sa BackwardDifferenceOperator
+ *
+ * \ingroup Operators
+ * \ingroup HigherOrderAccurateGradient
+ */
+template <class TPixel, unsigned int VDimension = 2, class TAllocator = NeighborhoodAllocator<TPixel>>
+class ITK_EXPORT HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel, VDimension, TAllocator>
+{
+public:
+  /** Standard class typedefs. */
+  typedef HigherOrderAccurateDerivativeOperator                Self;
+  typedef NeighborhoodOperator<TPixel, VDimension, TAllocator> Superclass;
+
+  typedef typename Superclass::PixelType     PixelType;
+  typedef typename Superclass::PixelRealType PixelRealType;
+
+  /** Run-time type information (and related methods). */
+  itkTypeMacro(HigherOrderAccurateDerivativeOperator, NeighborhoodOperator);
+
+  /** Constructor. */
+  HigherOrderAccurateDerivativeOperator()
+    : m_Order(1)
+    , m_OrderOfAccuracy(2)
+  {}
+
+  /** Copy constructor. */
+  HigherOrderAccurateDerivativeOperator(const Self & other)
+    : NeighborhoodOperator<TPixel, VDimension, TAllocator>(other)
+  {
+    m_Order = other.m_Order;
+  }
+
+  /** Assignment operator */
+  Self &
+  operator=(const Self & other)
+  {
+    Superclass::operator=(other);
+    m_Order = other.m_Order;
+    return *this;
+  }
+
+  /** Sets the order of the derivative. */
+  void
+  SetOrder(const unsigned int & order)
+  {
+    this->m_Order = order;
+  }
+
+  /** Returns the order of the derivative. */
+  unsigned int
+  GetOrder() const
+  {
+    return m_Order;
+  }
+
+  /** Sets the order of accuracy of the derivative. The derivative estimate will
+   * be accurate out to two times the given order in terms of Taylor Series terms.  The
+   * radius of the neighborhood operator is also equal to the given order.  */
+  void
+  SetOrderOfAccuracy(const unsigned int & order)
+  {
+    this->m_OrderOfAccuracy = order;
+  }
+
+  unsigned int
+  GetOrderOfAccuracy() const
+  {
+    return m_OrderOfAccuracy;
+  }
+
+  /** Prints some debugging information */
+  virtual void
+  PrintSelf(std::ostream & os, Indent i) const
+  {
+    os << i << "HigherOrderAccurateDerivativeOperator { this=" << this << ", m_Order = " << m_Order
+       << ", m_OrderOfAccuracy = " << m_OrderOfAccuracy << "}" << std::endl;
+    Superclass::PrintSelf(os, i.GetNextIndent());
+  }
+
+protected:
+  /** Typedef support for coefficient vector type.  Necessary to
+   * work around compiler bug on VC++. */
+  typedef typename Superclass::CoefficientVector CoefficientVector;
+
+  /** Calculates operator coefficients. */
+  CoefficientVector
+  GenerateCoefficients();
+
+  /** Arranges coefficients spatially in the memory buffer. */
+  void
+  Fill(const CoefficientVector & coeff)
+  {
+    Superclass::FillCenteredDirectional(coeff);
+  }
+
+private:
+  CoefficientVector
+  GenerateFirstOrderCoefficients();
+
+  /** Order of the derivative. */
+  unsigned int m_Order;
+
+  /** Order of accuracy. */
+  unsigned int m_OrderOfAccuracy;
+};
+} // namespace itk
+
+#if ITK_TEMPLATE_TXX
+#  include "itkHigherOrderAccurateDerivativeOperator.txx"
+#endif
+
+#endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
new file mode 100644
index 00000000000..12bd68a6222
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
@@ -0,0 +1,70 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    itkHigherOrderAccurateDerivativeOperator.txx
+  Language:  C++
+
+  Copyright (c) Insight Software Consortium. All rights reserved.
+  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __itkHigherOrderAccurateDerivativeOperator_txx
+#define __itkHigherOrderAccurateDerivativeOperator_txx
+#include "itkHigherOrderAccurateDerivativeOperator.h"
+
+#include "itkNumericTraits.h"
+
+namespace itk
+{
+template <class TPixel, unsigned int VDimension, class TAllocator>
+typename HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::CoefficientVector
+HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateCoefficients()
+{
+  switch (m_Order)
+  {
+    case 1:
+      return this->GenerateFirstOrderCoefficients();
+    default:
+      itkExceptionMacro(<< "The specified derivative order/degree is not yet supported.");
+  }
+}
+
+template <class TPixel, unsigned int VDimension, class TAllocator>
+typename HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::CoefficientVector
+HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateFirstOrderCoefficients()
+{
+  unsigned int      order = this->m_OrderOfAccuracy;
+  unsigned int      length = 2 * order + 1;
+  CoefficientVector coeff(length);
+
+  coeff[order + 1] = static_cast<double>(order) / (order + 1);
+  coeff[order - 1] = -1 * coeff[order + 1];
+
+  unsigned int i;
+  for (i = 1; i < order; ++i)
+  {
+    coeff[order + 1 + i] =
+      -1 * (i * static_cast<double>(order - i)) / (static_cast<double>(order + i + 1) * (i + 1)) * coeff[order + i];
+    coeff[order - 1 - i] = -1 * coeff[order + 1 + i];
+  }
+
+  // We perform a flip of axes here to keep in line with
+  // itk::DerivativeOperator.  The DerivativeImageFilter then calls FlipAxes(),
+  // so I am not sure why they put it in reverse order in the first place.  Note
+  // that a flip in this case is the same as flipping the sign.
+  for (i = 0; i < length; ++i)
+    coeff[i] *= -1;
+
+  // Center point.
+  coeff[order] = 0.0;
+
+  return coeff;
+}
+
+} // namespace itk
+
+#endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
new file mode 100644
index 00000000000..b60d4330663
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -0,0 +1,153 @@
+#ifndef __itkHigherOrderAccurateGradientImageFilter_h
+#define __itkHigherOrderAccurateGradientImageFilter_h
+
+#include "itkImageToImageFilter.h"
+#include "itkCovariantVector.h"
+
+namespace itk
+{
+/** \class HigherOrderAccurateGradientImageFilter
+ *
+ * \brief Calculate the image gradient from a higher order accurate
+ * central-difference derivative kernel.
+ *
+ * Based on the work here:
+ *
+ * Khan, IR and Ohba, Ryoji.  "Closed-form expressions for the finite difference
+ * approximations of first and higher derivatives based on Taylor series."
+ * Journal of Computational and Applied Mathematics.  vol 107.  p. 179-193.
+ * 1999.
+ *
+ * Khan, IR and Ohba, Ryoji.  "Taylor series based finite difference
+ * approximations of higher-degree derivatives."  Journal of Computational and
+ * Applied Mathematics.  vol 154.  p. 115-124.  2003.
+ *
+ * To specify the order of accuracy, use SetOrderOfAccuracy().  The
+ * approximation will be accurate to two times the OrderOfAccuracy in terms of
+ * Taylor series terms.
+ *
+ * \sa HigherOrderAccurateDerivativeOperator
+ * \sa HigherOrderAccurateDerivativeImageFilter
+ *
+ * \ingroup GradientFilters
+ * \ingroup HigherOrderAccurateGradient
+ */
+template <class TInputImage, class TOperatorValueType = float, class TOutputValueType = float>
+class ITK_EXPORT HigherOrderAccurateGradientImageFilter
+  : public ImageToImageFilter<
+      TInputImage,
+      Image<CovariantVector<TOutputValueType, TInputImage::ImageDimension>, TInputImage::ImageDimension>>
+{
+public:
+  /** Extract dimension from input image. */
+  itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension);
+
+  /** Standard class typedefs. */
+  typedef HigherOrderAccurateGradientImageFilter Self;
+
+  /** Convenient typedefs for simplifying declarations. */
+  typedef TInputImage                      InputImageType;
+  typedef typename InputImageType::Pointer InputImagePointer;
+  typedef Image<CovariantVector<TOutputValueType, itkGetStaticConstMacro(OutputImageDimension)>,
+                itkGetStaticConstMacro(OutputImageDimension)>
+                                            OutputImageType;
+  typedef typename OutputImageType::Pointer OutputImagePointer;
+
+  /** Standard class typedefs. */
+  typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
+  typedef SmartPointer<Self>                                  Pointer;
+  typedef SmartPointer<const Self>                            ConstPointer;
+
+  /** Method for creation through the object factory. */
+  itkNewMacro(Self);
+
+  /** Run-time type information (and related methods). */
+  itkTypeMacro(HigherOrderAccurateGradientImageFilter, ImageToImageFilter);
+
+  /** Image typedef support. */
+  typedef typename InputImageType::PixelType                                             InputPixelType;
+  typedef TOperatorValueType                                                             OperatorValueType;
+  typedef TOutputValueType                                                               OutputValueType;
+  typedef CovariantVector<OutputValueType, itkGetStaticConstMacro(OutputImageDimension)> OutputPixelType;
+  typedef typename OutputImageType::RegionType                                           OutputImageRegionType;
+
+  /** GradientImageFilter needs a larger input requested region than
+   * the output requested region.  As such, GradientImageFilter needs
+   * to provide an implementation for GenerateInputRequestedRegion()
+   * in order to inform the pipeline execution model.
+   *
+   * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
+  virtual void
+  GenerateInputRequestedRegion() throw(InvalidRequestedRegionError);
+
+  /** Set/Get whether or not the filter will use the spacing of the input
+      image in its calculations */
+  itkSetMacro(UseImageSpacing, bool);
+  itkGetConstMacro(UseImageSpacing, bool);
+  itkBooleanMacro(UseImageSpacing);
+
+#ifdef ITK_USE_CONCEPT_CHECKING
+  /** Begin concept checking */
+  itkConceptMacro(InputConvertibleToOutputCheck, (Concept::Convertible<InputPixelType, OutputValueType>));
+  itkConceptMacro(OutputHasNumericTraitsCheck, (Concept::HasNumericTraits<OutputValueType>));
+  /** End concept checking */
+#endif
+
+  /** The UseImageDirection flag determines whether image derivatives are
+   * computed with respect to the image grid or with respect to the physical
+   * space. When this flag is ON the derivatives are computed with respect to
+   * the coodinate system of physical space. The difference is whether we take
+   * into account the image Direction or not. The flag ON will take into
+   * account the image direction and will result in an extra matrix
+   * multiplication compared to the amount of computation performed when the
+   * flag is OFF.
+   * The default value of this flag is On.
+   */
+  itkSetMacro(UseImageDirection, bool);
+  itkGetConstMacro(UseImageDirection, bool);
+  itkBooleanMacro(UseImageDirection);
+
+  /** Set/Get the order of accuracy of the derivative operator.  For more
+   * information, see HigherOrderAccurateDerivativeOperator. */
+  itkSetMacro(OrderOfAccuracy, unsigned int);
+itkGetConstMacro(OrderOfAccuracy, unsigned int)
+
+  protected : HigherOrderAccurateGradientImageFilter();
+  virtual ~HigherOrderAccurateGradientImageFilter() {}
+  void
+  PrintSelf(std::ostream & os, Indent indent) const;
+
+  /** GradientImageFilter can be implemented as a multithreaded filter.
+   * Therefore, this implementation provides a ThreadedGenerateData()
+   * routine which is called for each processing thread. The output
+   * image data is allocated automatically by the superclass prior to
+   * calling ThreadedGenerateData().  ThreadedGenerateData can only
+   * write to the portion of the output image specified by the
+   * parameter "outputRegionForThread"
+   *
+   * \sa ImageToImageFilter::ThreadedGenerateData(),
+   *     ImageToImageFilter::GenerateData() */
+  void
+  ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId);
+
+private:
+  HigherOrderAccurateGradientImageFilter(const Self &); // purposely not implemented
+  void
+  operator=(const Self &); // purposely not implemented
+
+  bool m_UseImageSpacing;
+
+  // flag to take or not the image direction into account
+  // when computing the derivatives.
+  bool m_UseImageDirection;
+
+  unsigned int m_OrderOfAccuracy;
+};
+
+} // end namespace itk
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#  include "itkHigherOrderAccurateGradientImageFilter.txx"
+#endif
+
+#endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
new file mode 100644
index 00000000000..8a46edfeb01
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
@@ -0,0 +1,217 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    itkHigherOrderAccurateGradientImageFilter.txx
+  Language:  C++
+
+  Copyright (c) Insight Software Consortium. All rights reserved.
+  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __itkHigherOrderAccurateGradientImageFilter_txx
+#define __itkHigherOrderAccurateGradientImageFilter_txx
+#include "itkHigherOrderAccurateGradientImageFilter.h"
+
+#include "itkConstNeighborhoodIterator.h"
+#include "itkNeighborhoodInnerProduct.h"
+#include "itkImageRegionIterator.h"
+#include "itkHigherOrderAccurateDerivativeOperator.h"
+#include "itkNeighborhoodAlgorithm.h"
+#include "itkOffset.h"
+#include "itkProgressReporter.h"
+
+namespace itk
+{
+template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
+  HigherOrderAccurateGradientImageFilter()
+  : m_UseImageSpacing(true)
+  , m_UseImageDirection(true)
+  , m_OrderOfAccuracy(2)
+{}
+
+template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+void
+HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
+  GenerateInputRequestedRegion() throw(InvalidRequestedRegionError)
+{
+  // call the superclass' implementation of this method
+  Superclass::GenerateInputRequestedRegion();
+
+  // get pointers to the input and output
+  InputImagePointer  inputPtr = const_cast<InputImageType *>(this->GetInput());
+  OutputImagePointer outputPtr = this->GetOutput();
+
+  if (!inputPtr || !outputPtr)
+  {
+    return;
+  }
+
+  // Build an operator so that we can determine the kernel size
+  HigherOrderAccurateDerivativeOperator<OperatorValueType, ImageDimension> oper;
+  oper.SetDirection(0);
+  oper.SetOrder(1);
+  oper.SetOrderOfAccuracy(this->m_OrderOfAccuracy);
+  oper.CreateDirectional();
+  unsigned long radius = oper.GetRadius()[0];
+
+  // get a copy of the input requested region (should equal the output
+  // requested region)
+  typename TInputImage::RegionType inputRequestedRegion;
+  inputRequestedRegion = inputPtr->GetRequestedRegion();
+
+  // pad the input requested region by the operator radius
+  inputRequestedRegion.PadByRadius(radius);
+
+  // crop the input requested region at the input's largest possible region
+  if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()))
+  {
+    inputPtr->SetRequestedRegion(inputRequestedRegion);
+    return;
+  }
+  else
+  {
+    // Couldn't crop the region (requested region is outside the largest
+    // possible region).  Throw an exception.
+
+    // store what we tried to request (prior to trying to crop)
+    inputPtr->SetRequestedRegion(inputRequestedRegion);
+
+    // build an exception
+    InvalidRequestedRegionError e(__FILE__, __LINE__);
+    e.SetLocation(ITK_LOCATION);
+    e.SetDescription("Requested region is (at least partially) outside the largest possible region.");
+    e.SetDataObject(inputPtr);
+    throw e;
+  }
+}
+
+template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+void
+HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::ThreadedGenerateData(
+  const OutputImageRegionType & outputRegionForThread,
+  ThreadIdType                  threadId)
+{
+  unsigned int    i;
+  OutputPixelType gradient;
+
+  ZeroFluxNeumannBoundaryCondition<InputImageType> nbc;
+
+  ConstNeighborhoodIterator<InputImageType> nit;
+  ImageRegionIterator<OutputImageType>      it;
+
+  NeighborhoodInnerProduct<InputImageType, OperatorValueType, OutputValueType> SIP;
+
+  // Get the input and output
+  OutputImageType *      outputImage = this->GetOutput();
+  const InputImageType * inputImage = this->GetInput();
+
+  // Set up operators
+  HigherOrderAccurateDerivativeOperator<OperatorValueType, ImageDimension> op[ImageDimension];
+
+  for (i = 0; i < ImageDimension; i++)
+  {
+    op[i].SetDirection(0);
+    op[i].SetOrder(1);
+    op[i].SetOrderOfAccuracy(this->m_OrderOfAccuracy);
+    op[i].CreateDirectional();
+
+    // Reverse order of coefficients for the convolution with the image to
+    // follow.
+    op[i].FlipAxes();
+
+    // Take into account the pixel spacing if necessary
+    if (m_UseImageSpacing == true)
+    {
+      if (this->GetInput()->GetSpacing()[i] == 0.0)
+      {
+        itkExceptionMacro(<< "Image spacing cannot be zero.");
+      }
+      else
+      {
+        op[i].ScaleCoefficients(1.0 / this->GetInput()->GetSpacing()[i]);
+      }
+    }
+  }
+
+  // Calculate iterator radius
+  Size<ImageDimension> radius;
+  for (i = 0; i < ImageDimension; ++i)
+  {
+    radius[i] = op[0].GetRadius()[0];
+  }
+
+  // Find the data-set boundary "faces"
+  typename NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType>::FaceListType faceList;
+  NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType>                        bC;
+  faceList = bC(inputImage, outputRegionForThread, radius);
+
+  typename NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator fit;
+  fit = faceList.begin();
+
+  // support progress methods/callbacks
+  ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());
+
+  // Initialize the x_slice array
+  nit = ConstNeighborhoodIterator<InputImageType>(radius, inputImage, *fit);
+
+  std::slice          x_slice[ImageDimension];
+  const unsigned long center = nit.Size() / 2;
+  for (i = 0; i < ImageDimension; ++i)
+  {
+    x_slice[i] = std::slice(center - nit.GetStride(i) * radius[i], op[i].GetSize()[0], nit.GetStride(i));
+  }
+
+  // Process non-boundary face and then each of the boundary faces.
+  // These are N-d regions which border the edge of the buffer.
+  for (fit = faceList.begin(); fit != faceList.end(); ++fit)
+  {
+    nit = ConstNeighborhoodIterator<InputImageType>(radius, inputImage, *fit);
+    it = ImageRegionIterator<OutputImageType>(outputImage, *fit);
+    nit.OverrideBoundaryCondition(&nbc);
+    nit.GoToBegin();
+
+    while (!nit.IsAtEnd())
+    {
+      for (i = 0; i < ImageDimension; ++i)
+      {
+        gradient[i] = SIP(x_slice[i], nit, op[i]);
+      }
+
+      if (this->m_UseImageDirection)
+      {
+        inputImage->TransformLocalVectorToPhysicalVector(gradient, it.Value());
+      }
+      else
+      {
+        it.Value() = gradient;
+      }
+      ++nit;
+      ++it;
+      progress.CompletedPixel();
+    }
+  }
+}
+
+/**
+ * Standard "PrintSelf" method
+ */
+template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+void
+HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::PrintSelf(
+  std::ostream & os,
+  Indent         indent) const
+{
+  Superclass::PrintSelf(os, indent);
+
+  os << indent << "UseImageSpacing: " << (this->m_UseImageSpacing ? "On" : "Off") << std::endl;
+  os << indent << "UseImageDirection = " << (this->m_UseImageDirection ? "On" : "Off") << std::endl;
+  os << indent << "OrderOfAccuracy: " << this->m_OrderOfAccuracy << std::endl;
+}
+} // end namespace itk
+
+#endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
new file mode 100644
index 00000000000..f35a56fc21b
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
@@ -0,0 +1,25 @@
+# Maintainer: Matt McCormick <matt.mccormick@kitware.com>
+set(
+  DOCUMENTATION
+  "This module contains a filter to compute higher order
+accurate numerical derivatives and gradients from an input scalar image.
+field from a displacement field image.
+Higher Order Accurate Derivative and Gradient Calculation in ITK
+http://www.insight-journal.org/browse/publication/775
+http://hdl.handle.net/10380/3231
+"
+)
+
+itk_module(
+  HigherOrderAccurateGradient
+  DEPENDS
+    ITKCommon
+    ITKImageGradient
+    ITKImageIntensity
+    ITKImageFeature
+    SplitComponents
+  TEST_DEPENDS
+    ITKTestKernel
+  EXCLUDE_FROM_DEFAULT
+  DESCRIPTION "${DOCUMENTATION}"
+)
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt
new file mode 100644
index 00000000000..6acf13c3fe8
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt
@@ -0,0 +1,36 @@
+itk_module_test()
+
+set(
+  HigherOrderAccurateGradientTests
+  itkHigherOrderAccurateGradientImageFilterTest.cxx
+  itkHigherOrderAccurateDerivativeImageFilterTest.cxx
+)
+
+createtestdriver(HigherOrderAccurateGradient "${HigherOrderAccurateGradient-Test_LIBRARIES}" "${HigherOrderAccurateGradientTests}")
+
+itk_add_test(
+  NAME itkHigherOrderAccurateGradientImageFilterTest
+  COMMAND
+    HigherOrderAccurateGradientTestDriver
+    --compare
+    itkHigherOrderAccurateDerivativeImageFilterTest_Accuracy1_Direction0.mha
+    itkHigherOrderAccurateDerivativeImageFilterTest_DerivativeImageFilter_Direction0.mha
+    --compare
+    itkHigherOrderAccurateDerivativeImageFilterTest_Accuracy1_Direction1.mha
+    itkHigherOrderAccurateDerivativeImageFilterTest_DerivativeImageFilter_Direction1.mha
+    itkHigherOrderAccurateGradientImageFilterTest
+    DATA{Input/foot.mha}
+    itkHigherOrderAccurateGradientImageFilterTest
+)
+
+itk_add_test(
+  NAME itkHigherOrderAccurateDerivativeImageFilterTest
+  COMMAND
+    HigherOrderAccurateGradientTestDriver
+    --compare
+    itkHigherOrderAccurateGradientImageFilterTest_Accuracy1_Magnitude.mha
+    itkHigherOrderAccurateGradientImageFilterTest_GradientImageFilter_Magnitude.mha
+    itkHigherOrderAccurateDerivativeImageFilterTest
+    DATA{Input/foot.mha}
+    itkHigherOrderAccurateDerivativeImageFilterTest
+)
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5 b/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5
new file mode 100644
index 00000000000..f724c8ba7a0
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5
@@ -0,0 +1 @@
+91bc3fa357c90c337dda72612c53a712
\ No newline at end of file
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
new file mode 100644
index 00000000000..2ec677c57eb
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
@@ -0,0 +1,79 @@
+#include <sstream>
+
+#include "itkDerivativeImageFilter.h"
+#include "itkImageFileReader.h"
+#include "itkImageFileWriter.h"
+
+#include "itkHigherOrderAccurateDerivativeImageFilter.h"
+
+int
+itkHigherOrderAccurateDerivativeImageFilterTest(int argc, char * argv[])
+{
+  if (argc < 3)
+  {
+    std::cerr << "Usage: " << argv[0];
+    std::cerr << " inputImage outputPrefix ";
+    std::cerr << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  const unsigned int                       Dimension = 2;
+  typedef float                            PixelType;
+  typedef itk::Image<PixelType, Dimension> ImageType;
+
+  std::string outputPrefix = argv[2];
+
+  typedef itk::ImageFileReader<ImageType> ReaderType;
+  ReaderType::Pointer                     reader = ReaderType::New();
+  reader->SetFileName(argv[1]);
+
+  typedef itk::HigherOrderAccurateDerivativeImageFilter<ImageType, ImageType> HigherFilterType;
+  HigherFilterType::Pointer                                                   nthFilter = HigherFilterType::New();
+  nthFilter->SetInput(reader->GetOutput());
+  nthFilter->SetOrder(1);
+
+  typedef itk::ImageFileWriter<ImageType> WriterType;
+  WriterType::Pointer                     nthWriter = WriterType::New();
+  nthWriter->SetInput(nthFilter->GetOutput());
+
+  // First order accurate.
+  typedef itk::DerivativeImageFilter<ImageType, ImageType> FirstFilterType;
+  FirstFilterType::Pointer                                 firstFilter = FirstFilterType::New();
+  firstFilter->SetInput(reader->GetOutput());
+  firstFilter->SetOrder(1);
+
+  typedef itk::ImageFileWriter<ImageType> WriterType;
+  WriterType::Pointer                     firstWriter = WriterType::New();
+  firstWriter->SetInput(firstFilter->GetOutput());
+
+  std::ostringstream ostrm;
+  try
+  {
+    for (unsigned int direction = 0; direction < 2; ++direction)
+    {
+      firstFilter->SetDirection(direction);
+      ostrm.str("");
+      ostrm << outputPrefix << "_DerivativeImageFilter_Direction" << direction << ".mha";
+      firstWriter->SetFileName(ostrm.str());
+      firstWriter->Update();
+
+      for (unsigned int accuracy = 1; accuracy < 6; ++accuracy)
+      {
+        nthFilter->SetDirection(direction);
+        nthFilter->SetOrderOfAccuracy(accuracy);
+        ostrm.str("");
+        ostrm << outputPrefix << "_Accuracy" << accuracy << "_Direction" << direction << ".mha";
+        nthWriter->SetFileName(ostrm.str());
+        nthWriter->Update();
+      }
+    }
+  }
+  catch (itk::ExceptionObject & ex)
+  {
+    std::cerr << "Exception caught!" << std::endl;
+    std::cerr << ex << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
new file mode 100644
index 00000000000..2b9c718a2ac
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
@@ -0,0 +1,74 @@
+#include <sstream>
+
+#include "itkGradientImageFilter.h"
+#include "itkVectorMagnitudeImageFilter.h"
+#include "itkImageFileReader.h"
+#include "itkImageFileWriter.h"
+
+#include "itkHigherOrderAccurateGradientImageFilter.h"
+
+int
+itkHigherOrderAccurateGradientImageFilterTest(int argc, char * argv[])
+{
+  if (argc < 3)
+  {
+    std::cerr << "Usage: " << argv[0];
+    std::cerr << " inputImage outputPrefix ";
+    std::cerr << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  const unsigned int                       Dimension = 2;
+  typedef float                            PixelType;
+  typedef itk::Image<PixelType, Dimension> ImageType;
+
+  typedef itk::ImageFileReader<ImageType> ReaderType;
+  ReaderType::Pointer                     reader = ReaderType::New();
+  reader->SetFileName(argv[1]);
+
+  // First order accurate.
+  typedef itk::GradientImageFilter<ImageType, float, float> FirstFilterType;
+  FirstFilterType::Pointer                                  firstFilter = FirstFilterType::New();
+  firstFilter->SetInput(reader->GetOutput());
+
+  typedef itk::HigherOrderAccurateGradientImageFilter<ImageType, float, float> FilterType;
+  typedef FilterType::OutputImageType                                          GradientImageType;
+  FilterType::Pointer                                                          filter = FilterType::New();
+  filter->SetInput(reader->GetOutput());
+
+  std::string outputPrefix = argv[2];
+
+  typedef itk::VectorMagnitudeImageFilter<GradientImageType, ImageType> GradientMagnitudeFilterType;
+  GradientMagnitudeFilterType::Pointer gradientMagnitude = GradientMagnitudeFilterType::New();
+
+  typedef itk::ImageFileWriter<ImageType> GradientMagnitudeWriterType;
+  GradientMagnitudeWriterType::Pointer    gradientMagnitudeWriter = GradientMagnitudeWriterType::New();
+  gradientMagnitudeWriter->SetInput(gradientMagnitude->GetOutput());
+
+  std::ostringstream ostrm;
+  try
+  {
+    gradientMagnitude->SetInput(firstFilter->GetOutput());
+    ostrm.str("");
+    ostrm << outputPrefix + "_GradientImageFilter_Magnitude.mha";
+    gradientMagnitudeWriter->SetFileName(ostrm.str());
+    gradientMagnitudeWriter->Update();
+    gradientMagnitude->SetInput(filter->GetOutput());
+    for (unsigned int accuracy = 1; accuracy < 6; ++accuracy)
+    {
+      filter->SetOrderOfAccuracy(accuracy);
+      ostrm.str("");
+      ostrm << outputPrefix << "_Accuracy" << accuracy << "_Magnitude.mha";
+      gradientMagnitudeWriter->SetFileName(ostrm.str());
+      gradientMagnitudeWriter->Update();
+    }
+  }
+  catch (itk::ExceptionObject & ex)
+  {
+    std::cerr << "Exception caught!" << std::endl;
+    std::cerr << ex << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}

From e2a65a84db131e8934f9d21350d4fec68203e8ea Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 28 Sep 2014 23:44:52 -0400
Subject: [PATCH 07/41] BUG: Add missing LICENSE file, update license headers.

---
 ...HigherOrderAccurateDerivativeImageFilter.h | 29 ++++++++++---------
 ...gherOrderAccurateDerivativeImageFilter.txx | 29 ++++++++++---------
 ...itkHigherOrderAccurateDerivativeOperator.h | 29 ++++++++++---------
 ...kHigherOrderAccurateDerivativeOperator.txx | 29 ++++++++++---------
 ...tkHigherOrderAccurateGradientImageFilter.h | 17 +++++++++++
 ...HigherOrderAccurateGradientImageFilter.txx | 29 ++++++++++---------
 ...OrderAccurateDerivativeImageFilterTest.cxx | 19 ++++++++++--
 ...erOrderAccurateGradientImageFilterTest.cxx | 19 ++++++++++--
 8 files changed, 131 insertions(+), 69 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index c8c87edfe1c..815061cc9de 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -1,17 +1,20 @@
 /*=========================================================================
-
-  Program:   Insight Segmentation & Registration Toolkit
-  Module:    itkHigherOrderAccurateDerivativeImageFilter.h
-  Language:  C++
-
-  Copyright (c) Insight Software Consortium. All rights reserved.
-  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
+ *
+ *  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 __itkHigherOrderAccurateDerivativeImageFilter_h
 #define __itkHigherOrderAccurateDerivativeImageFilter_h
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
index cd4047a0820..ab2bc00af81 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
@@ -1,17 +1,20 @@
 /*=========================================================================
-
-  Program:   Insight Segmentation & Registration Toolkit
-  Module:    itkHigherOrderAccurateDerivativeImageFilter.txx
-  Language:  C++
-
-  Copyright (c) Insight Software Consortium. All rights reserved.
-  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
+ *
+ *  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 __itkHigherOrderAccurateDerivativeImageFilter_txx
 #define __itkHigherOrderAccurateDerivativeImageFilter_txx
 #include "itkHigherOrderAccurateDerivativeImageFilter.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index afc43f42291..a6a381586e9 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -1,17 +1,20 @@
 /*=========================================================================
-
-  Program:   Insight Segmentation & Registration Toolkit
-  Module:    itkHigherOrderAccurateDerivativeOperator.h
-  Language:  C++
-
-  Copyright (c) Insight Software Consortium. All rights reserved.
-  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
+ *
+ *  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 __itkHigherOrderAccurateDerivativeOperator_h
 #define __itkHigherOrderAccurateDerivativeOperator_h
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
index 12bd68a6222..b1644aa4df2 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
@@ -1,17 +1,20 @@
 /*=========================================================================
-
-  Program:   Insight Segmentation & Registration Toolkit
-  Module:    itkHigherOrderAccurateDerivativeOperator.txx
-  Language:  C++
-
-  Copyright (c) Insight Software Consortium. All rights reserved.
-  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
+ *
+ *  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 __itkHigherOrderAccurateDerivativeOperator_txx
 #define __itkHigherOrderAccurateDerivativeOperator_txx
 #include "itkHigherOrderAccurateDerivativeOperator.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index b60d4330663..a9cb25908ef 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -1,3 +1,20 @@
+/*=========================================================================
+ *
+ *  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 __itkHigherOrderAccurateGradientImageFilter_h
 #define __itkHigherOrderAccurateGradientImageFilter_h
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
index 8a46edfeb01..bfb5baacb60 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
@@ -1,17 +1,20 @@
 /*=========================================================================
-
-  Program:   Insight Segmentation & Registration Toolkit
-  Module:    itkHigherOrderAccurateGradientImageFilter.txx
-  Language:  C++
-
-  Copyright (c) Insight Software Consortium. All rights reserved.
-  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
+ *
+ *  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 __itkHigherOrderAccurateGradientImageFilter_txx
 #define __itkHigherOrderAccurateGradientImageFilter_txx
 #include "itkHigherOrderAccurateGradientImageFilter.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
index 2ec677c57eb..b5dcfcf44b4 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
@@ -1,5 +1,20 @@
-#include <sstream>
-
+/*=========================================================================
+ *
+ *  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.
+ *
+ *=========================================================================*/
 #include "itkDerivativeImageFilter.h"
 #include "itkImageFileReader.h"
 #include "itkImageFileWriter.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
index 2b9c718a2ac..52629b6f457 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
@@ -1,5 +1,20 @@
-#include <sstream>
-
+/*=========================================================================
+ *
+ *  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.
+ *
+ *=========================================================================*/
 #include "itkGradientImageFilter.h"
 #include "itkVectorMagnitudeImageFilter.h"
 #include "itkImageFileReader.h"

From 8bc3517bde8117162fbea3b934ad33c519217ed0 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 28 Sep 2014 23:54:00 -0400
Subject: [PATCH 08/41] STYLE: .txx -> .hxx.

---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h     | 2 +-
 ...er.txx => itkHigherOrderAccurateDerivativeImageFilter.hxx} | 4 ++--
 .../include/itkHigherOrderAccurateDerivativeOperator.h        | 4 ++--
 ...rator.txx => itkHigherOrderAccurateDerivativeOperator.hxx} | 4 ++--
 .../include/itkHigherOrderAccurateGradientImageFilter.h       | 2 +-
 ...lter.txx => itkHigherOrderAccurateGradientImageFilter.hxx} | 4 ++--
 6 files changed, 10 insertions(+), 10 deletions(-)
 rename Modules/Filtering/HigherOrderAccurateGradient/include/{itkHigherOrderAccurateDerivativeImageFilter.txx => itkHigherOrderAccurateDerivativeImageFilter.hxx} (97%)
 rename Modules/Filtering/HigherOrderAccurateGradient/include/{itkHigherOrderAccurateDerivativeOperator.txx => itkHigherOrderAccurateDerivativeOperator.hxx} (95%)
 rename Modules/Filtering/HigherOrderAccurateGradient/include/{itkHigherOrderAccurateGradientImageFilter.txx => itkHigherOrderAccurateGradientImageFilter.hxx} (98%)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 815061cc9de..85f6ea3d880 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -160,7 +160,7 @@ class ITK_EXPORT HigherOrderAccurateDerivativeImageFilter : public ImageToImageF
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
-#  include "itkHigherOrderAccurateDerivativeImageFilter.txx"
+#  include "itkHigherOrderAccurateDerivativeImageFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
similarity index 97%
rename from Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
rename to Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index ab2bc00af81..6f7489d7038 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.txx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateDerivativeImageFilter_txx
-#define __itkHigherOrderAccurateDerivativeImageFilter_txx
+#ifndef __itkHigherOrderAccurateDerivativeImageFilter_hxx
+#define __itkHigherOrderAccurateDerivativeImageFilter_hxx
 #include "itkHigherOrderAccurateDerivativeImageFilter.h"
 
 #include "itkNumericTraits.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index a6a381586e9..f32b67c823e 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -158,8 +158,8 @@ class ITK_EXPORT HigherOrderAccurateDerivativeOperator : public NeighborhoodOper
 };
 } // namespace itk
 
-#if ITK_TEMPLATE_TXX
-#  include "itkHigherOrderAccurateDerivativeOperator.txx"
+#ifndef ITK_MANUAL_INSTANTIATION
+#  include "itkHigherOrderAccurateDerivativeOperator.hxx"
 #endif
 
 #endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
similarity index 95%
rename from Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
rename to Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index b1644aa4df2..c83bd237c14 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.txx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateDerivativeOperator_txx
-#define __itkHigherOrderAccurateDerivativeOperator_txx
+#ifndef __itkHigherOrderAccurateDerivativeOperator_hxx
+#define __itkHigherOrderAccurateDerivativeOperator_hxx
 #include "itkHigherOrderAccurateDerivativeOperator.h"
 
 #include "itkNumericTraits.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index a9cb25908ef..9f8a6e0ea7d 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -164,7 +164,7 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
-#  include "itkHigherOrderAccurateGradientImageFilter.txx"
+#  include "itkHigherOrderAccurateGradientImageFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
similarity index 98%
rename from Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
rename to Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index bfb5baacb60..cd145f9fb69 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.txx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateGradientImageFilter_txx
-#define __itkHigherOrderAccurateGradientImageFilter_txx
+#ifndef __itkHigherOrderAccurateGradientImageFilter_hxx
+#define __itkHigherOrderAccurateGradientImageFilter_hxx
 #include "itkHigherOrderAccurateGradientImageFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"

From edeab200ead7ce1cc5d4ce450441141854265f4f Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Mon, 29 Sep 2014 00:00:23 -0400
Subject: [PATCH 09/41] STYLE: Various style fixes.

---
 ...HigherOrderAccurateDerivativeImageFilter.h | 30 ++++++++++---------
 ...gherOrderAccurateDerivativeImageFilter.hxx |  7 +++--
 ...itkHigherOrderAccurateDerivativeOperator.h |  4 ++-
 ...tkHigherOrderAccurateGradientImageFilter.h | 27 +++++++++--------
 ...HigherOrderAccurateGradientImageFilter.hxx |  9 +++---
 5 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 85f6ea3d880..9faa07d0568 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -22,6 +22,7 @@
 
 namespace itk
 {
+
 /** \class HigherOrderAccurateDerivativeImageFilter
  * \brief Computes the higher order accurate directional derivative of an image.
  * The directional derivative at each pixel location is computed by convolution
@@ -45,7 +46,7 @@ namespace itk
  * \ingroup HigherOrderAccurateGradient
  */
 template <class TInputImage, class TOutputImage>
-class ITK_EXPORT HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
+class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
 {
 public:
   /** Standard class typedefs. */
@@ -111,16 +112,6 @@ class ITK_EXPORT HigherOrderAccurateDerivativeImageFilter : public ImageToImageF
   itkSetMacro(UseImageSpacing, bool);
   itkGetConstMacro(UseImageSpacing, bool);
 
-  /** HigherOrderAccurateDerivativeImageFilter needs a larger input requested region than
-   * the output requested region (larger in the direction of the
-   * derivative).  As such, HigherOrderAccurateDerivativeImageFilter needs to provide an
-   * implementation for GenerateInputRequestedRegion() in order to
-   * inform the pipeline execution model.
-   *
-   * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
-  virtual void
-  GenerateInputRequestedRegion() throw(InvalidRequestedRegionError);
-
 protected:
   HigherOrderAccurateDerivativeImageFilter()
     : m_Order(1)
@@ -130,16 +121,26 @@ class ITK_EXPORT HigherOrderAccurateDerivativeImageFilter : public ImageToImageF
   {}
 
   virtual ~HigherOrderAccurateDerivativeImageFilter() {}
-  void
+  virtual void
   PrintSelf(std::ostream & os, Indent indent) const;
 
+  /** HigherOrderAccurateDerivativeImageFilter needs a larger input requested region than
+   * the output requested region (larger in the direction of the
+   * derivative).  As such, HigherOrderAccurateDerivativeImageFilter needs to provide an
+   * implementation for GenerateInputRequestedRegion() in order to
+   * inform the pipeline execution model.
+   *
+   * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
+  virtual void
+  GenerateInputRequestedRegion() ITK_OVERRIDE;
+
   /** Standard pipeline method. While this class does not implement a
    * ThreadedGenerateData(), its GenerateData() delegates all
    * calculations to an NeighborhoodOperatorImageFilter.  Since the
    * NeighborhoodOperatorImageFilter is multithreaded, this filter is
    * multithreaded by default. */
-  void
-  GenerateData();
+  virtual void
+  GenerateData() ITK_OVERRIDE;
 
 private:
   HigherOrderAccurateDerivativeImageFilter(const Self &); // purposely not implemented
@@ -157,6 +158,7 @@ class ITK_EXPORT HigherOrderAccurateDerivativeImageFilter : public ImageToImageF
 
   bool m_UseImageSpacing;
 };
+
 } // end namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index 6f7489d7038..f1349e1baa1 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -26,10 +26,10 @@
 
 namespace itk
 {
+
 template <class TInputImage, class TOutputImage>
 void
-HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateInputRequestedRegion() throw(
-  InvalidRequestedRegionError)
+HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateInputRequestedRegion()
 {
   // call the superclass' implementation of this method. this should
   // copy the output requested region to the input requested region
@@ -81,6 +81,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateInp
   }
 }
 
+
 template <class TInputImage, class TOutputImage>
 void
 HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateData()
@@ -143,6 +144,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateDat
   this->GraftOutput(filter->GetOutput());
 }
 
+
 template <class TInputImage, class TOutputImage>
 void
 HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::PrintSelf(std::ostream & os, Indent indent) const
@@ -154,6 +156,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::PrintSelf(s
   os << indent << "Direction: " << m_Direction << std::endl;
   os << indent << "UseImageSpacing: " << m_UseImageSpacing << std::endl;
 }
+
 } // end namespace itk
 
 #endif
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index f32b67c823e..2f99d77c6d7 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -22,6 +22,7 @@
 
 namespace itk
 {
+
 /**
  * \class HigherOrderAccurateDerivativeOperator
  * \brief A NeighborhoodOperator for calculating an n-th order accurate derivative
@@ -57,7 +58,7 @@ namespace itk
  * \ingroup HigherOrderAccurateGradient
  */
 template <class TPixel, unsigned int VDimension = 2, class TAllocator = NeighborhoodAllocator<TPixel>>
-class ITK_EXPORT HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel, VDimension, TAllocator>
+class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel, VDimension, TAllocator>
 {
 public:
   /** Standard class typedefs. */
@@ -156,6 +157,7 @@ class ITK_EXPORT HigherOrderAccurateDerivativeOperator : public NeighborhoodOper
   /** Order of accuracy. */
   unsigned int m_OrderOfAccuracy;
 };
+
 } // namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 9f8a6e0ea7d..538a72b950f 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -23,6 +23,7 @@
 
 namespace itk
 {
+
 /** \class HigherOrderAccurateGradientImageFilter
  *
  * \brief Calculate the image gradient from a higher order accurate
@@ -50,7 +51,7 @@ namespace itk
  * \ingroup HigherOrderAccurateGradient
  */
 template <class TInputImage, class TOperatorValueType = float, class TOutputValueType = float>
-class ITK_EXPORT HigherOrderAccurateGradientImageFilter
+class HigherOrderAccurateGradientImageFilter
   : public ImageToImageFilter<
       TInputImage,
       Image<CovariantVector<TOutputValueType, TInputImage::ImageDimension>, TInputImage::ImageDimension>>
@@ -88,15 +89,6 @@ class ITK_EXPORT HigherOrderAccurateGradientImageFilter
   typedef CovariantVector<OutputValueType, itkGetStaticConstMacro(OutputImageDimension)> OutputPixelType;
   typedef typename OutputImageType::RegionType                                           OutputImageRegionType;
 
-  /** GradientImageFilter needs a larger input requested region than
-   * the output requested region.  As such, GradientImageFilter needs
-   * to provide an implementation for GenerateInputRequestedRegion()
-   * in order to inform the pipeline execution model.
-   *
-   * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
-  virtual void
-  GenerateInputRequestedRegion() throw(InvalidRequestedRegionError);
-
   /** Set/Get whether or not the filter will use the spacing of the input
       image in its calculations */
   itkSetMacro(UseImageSpacing, bool);
@@ -131,9 +123,18 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
 
   protected : HigherOrderAccurateGradientImageFilter();
   virtual ~HigherOrderAccurateGradientImageFilter() {}
-  void
+  virtual void
   PrintSelf(std::ostream & os, Indent indent) const;
 
+  /** GradientImageFilter needs a larger input requested region than
+   * the output requested region.  As such, GradientImageFilter needs
+   * to provide an implementation for GenerateInputRequestedRegion()
+   * in order to inform the pipeline execution model.
+   *
+   * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
+  virtual void
+  GenerateInputRequestedRegion();
+
   /** GradientImageFilter can be implemented as a multithreaded filter.
    * Therefore, this implementation provides a ThreadedGenerateData()
    * routine which is called for each processing thread. The output
@@ -144,8 +145,8 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    *
    * \sa ImageToImageFilter::ThreadedGenerateData(),
    *     ImageToImageFilter::GenerateData() */
-  void
-  ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId);
+  virtual void
+  ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) ITK_OVERRIDE;
 
 private:
   HigherOrderAccurateGradientImageFilter(const Self &); // purposely not implemented
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index cd145f9fb69..e02bd45adf9 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -29,6 +29,7 @@
 
 namespace itk
 {
+
 template <class TInputImage, class TOperatorValueType, class TOutputValueType>
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
   HigherOrderAccurateGradientImageFilter()
@@ -40,7 +41,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
 template <class TInputImage, class TOperatorValueType, class TOutputValueType>
 void
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
-  GenerateInputRequestedRegion() throw(InvalidRequestedRegionError)
+  GenerateInputRequestedRegion()
 {
   // call the superclass' implementation of this method
   Superclass::GenerateInputRequestedRegion();
@@ -93,6 +94,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
   }
 }
 
+
 template <class TInputImage, class TOperatorValueType, class TOutputValueType>
 void
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::ThreadedGenerateData(
@@ -200,9 +202,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
   }
 }
 
-/**
- * Standard "PrintSelf" method
- */
+
 template <class TInputImage, class TOperatorValueType, class TOutputValueType>
 void
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::PrintSelf(
@@ -215,6 +215,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
   os << indent << "UseImageDirection = " << (this->m_UseImageDirection ? "On" : "Off") << std::endl;
   os << indent << "OrderOfAccuracy: " << this->m_OrderOfAccuracy << std::endl;
 }
+
 } // end namespace itk
 
 #endif

From 6b57233bc7509c2a2fcc3430a7ffc4b95873a9ce Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Mon, 29 Sep 2014 00:04:36 -0400
Subject: [PATCH 10/41] BUG: Fix the test baseline paths.

---
 .../test/CMakeLists.txt                        | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt
index 6acf13c3fe8..0619328aa3c 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/CMakeLists.txt
@@ -13,14 +13,11 @@ itk_add_test(
   COMMAND
     HigherOrderAccurateGradientTestDriver
     --compare
-    itkHigherOrderAccurateDerivativeImageFilterTest_Accuracy1_Direction0.mha
-    itkHigherOrderAccurateDerivativeImageFilterTest_DerivativeImageFilter_Direction0.mha
-    --compare
-    itkHigherOrderAccurateDerivativeImageFilterTest_Accuracy1_Direction1.mha
-    itkHigherOrderAccurateDerivativeImageFilterTest_DerivativeImageFilter_Direction1.mha
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateGradientImageFilterTest_Accuracy1_Magnitude.mha
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateGradientImageFilterTest_GradientImageFilter_Magnitude.mha
     itkHigherOrderAccurateGradientImageFilterTest
     DATA{Input/foot.mha}
-    itkHigherOrderAccurateGradientImageFilterTest
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateGradientImageFilterTest
 )
 
 itk_add_test(
@@ -28,9 +25,12 @@ itk_add_test(
   COMMAND
     HigherOrderAccurateGradientTestDriver
     --compare
-    itkHigherOrderAccurateGradientImageFilterTest_Accuracy1_Magnitude.mha
-    itkHigherOrderAccurateGradientImageFilterTest_GradientImageFilter_Magnitude.mha
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateDerivativeImageFilterTest_Accuracy1_Direction0.mha
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateDerivativeImageFilterTest_DerivativeImageFilter_Direction0.mha
+    --compare
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateDerivativeImageFilterTest_Accuracy1_Direction1.mha
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateDerivativeImageFilterTest_DerivativeImageFilter_Direction1.mha
     itkHigherOrderAccurateDerivativeImageFilterTest
     DATA{Input/foot.mha}
-    itkHigherOrderAccurateDerivativeImageFilterTest
+    ${ITK_TEST_OUTPUT_DIR}/itkHigherOrderAccurateDerivativeImageFilterTest
 )

From 70158cb8601b23aad73dbd3ce03b0c5c9e50041e Mon Sep 17 00:00:00 2001
From: Bradley Lowekamp <blowekamp@mail.nih.gov>
Date: Thu, 16 Oct 2014 13:41:06 -0400
Subject: [PATCH 11/41] ENH: Update
 itkHigherOrderAccurateDerivativeOperator.hxx

---
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx         | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index c83bd237c14..b626dd13506 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -48,6 +48,7 @@ HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateF
   coeff[order - 1] = -1 * coeff[order + 1];
 
   unsigned int i;
+  // TODO Try to refactor this loop to pull out common multiplications
   for (i = 1; i < order; ++i)
   {
     coeff[order + 1 + i] =

From 6272ce0b9a79842721727e03c0e90ff453bff782 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Thu, 23 Apr 2015 15:44:05 -0400
Subject: [PATCH 12/41] STYLE: Do not use double underscore for header guards.

Double underscore is reserved for compiler defined preprocessor variables.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h     | 4 ++--
 .../include/itkHigherOrderAccurateDerivativeImageFilter.hxx   | 4 ++--
 .../include/itkHigherOrderAccurateDerivativeOperator.h        | 4 ++--
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx      | 4 ++--
 .../include/itkHigherOrderAccurateGradientImageFilter.h       | 4 ++--
 .../include/itkHigherOrderAccurateGradientImageFilter.hxx     | 4 ++--
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 9faa07d0568..8b11f280aa7 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateDerivativeImageFilter_h
-#define __itkHigherOrderAccurateDerivativeImageFilter_h
+#ifndef itkHigherOrderAccurateDerivativeImageFilter_h
+#define itkHigherOrderAccurateDerivativeImageFilter_h
 
 #include "itkImageToImageFilter.h"
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index f1349e1baa1..3d59bc92b20 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateDerivativeImageFilter_hxx
-#define __itkHigherOrderAccurateDerivativeImageFilter_hxx
+#ifndef itkHigherOrderAccurateDerivativeImageFilter_hxx
+#define itkHigherOrderAccurateDerivativeImageFilter_hxx
 #include "itkHigherOrderAccurateDerivativeImageFilter.h"
 
 #include "itkNumericTraits.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 2f99d77c6d7..2f4b9b5db00 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateDerivativeOperator_h
-#define __itkHigherOrderAccurateDerivativeOperator_h
+#ifndef itkHigherOrderAccurateDerivativeOperator_h
+#define itkHigherOrderAccurateDerivativeOperator_h
 
 #include "itkNeighborhoodOperator.h"
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index b626dd13506..ff2299cd843 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateDerivativeOperator_hxx
-#define __itkHigherOrderAccurateDerivativeOperator_hxx
+#ifndef itkHigherOrderAccurateDerivativeOperator_hxx
+#define itkHigherOrderAccurateDerivativeOperator_hxx
 #include "itkHigherOrderAccurateDerivativeOperator.h"
 
 #include "itkNumericTraits.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 538a72b950f..dd3f854d7b3 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateGradientImageFilter_h
-#define __itkHigherOrderAccurateGradientImageFilter_h
+#ifndef itkHigherOrderAccurateGradientImageFilter_h
+#define itkHigherOrderAccurateGradientImageFilter_h
 
 #include "itkImageToImageFilter.h"
 #include "itkCovariantVector.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index e02bd45adf9..d098f827500 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -15,8 +15,8 @@
  *  limitations under the License.
  *
  *=========================================================================*/
-#ifndef __itkHigherOrderAccurateGradientImageFilter_hxx
-#define __itkHigherOrderAccurateGradientImageFilter_hxx
+#ifndef itkHigherOrderAccurateGradientImageFilter_hxx
+#define itkHigherOrderAccurateGradientImageFilter_hxx
 #include "itkHigherOrderAccurateGradientImageFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"

From 20f41c9a2a90d17c8d48fe369a196d8326e9c359 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Sat, 16 Dec 2017 14:49:56 -0600
Subject: [PATCH 13/41] ENH: Initial ITKv5 conversions.

Provide initial conversion of features to ITKv5.
---
 .../itkHigherOrderAccurateDerivativeImageFilter.h    | 10 +++++-----
 .../itkHigherOrderAccurateDerivativeOperator.h       |  8 ++++----
 .../itkHigherOrderAccurateGradientImageFilter.h      | 12 ++++++------
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 8b11f280aa7..a80574c861e 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -120,9 +120,9 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
     , m_UseImageSpacing(true)
   {}
 
-  virtual ~HigherOrderAccurateDerivativeImageFilter() {}
-  virtual void
-  PrintSelf(std::ostream & os, Indent indent) const;
+  ~HigherOrderAccurateDerivativeImageFilter() override {}
+  void
+  PrintSelf(std::ostream & os, Indent indent) const override;
 
   /** HigherOrderAccurateDerivativeImageFilter needs a larger input requested region than
    * the output requested region (larger in the direction of the
@@ -131,7 +131,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
    * inform the pipeline execution model.
    *
    * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
-  virtual void
+  void
   GenerateInputRequestedRegion() ITK_OVERRIDE;
 
   /** Standard pipeline method. While this class does not implement a
@@ -139,7 +139,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
    * calculations to an NeighborhoodOperatorImageFilter.  Since the
    * NeighborhoodOperatorImageFilter is multithreaded, this filter is
    * multithreaded by default. */
-  virtual void
+  void
   GenerateData() ITK_OVERRIDE;
 
 private:
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 2f4b9b5db00..119b1c57818 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -123,8 +123,8 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
   }
 
   /** Prints some debugging information */
-  virtual void
-  PrintSelf(std::ostream & os, Indent i) const
+  void
+  PrintSelf(std::ostream & os, Indent i) const ITK_OVERRIDE
   {
     os << i << "HigherOrderAccurateDerivativeOperator { this=" << this << ", m_Order = " << m_Order
        << ", m_OrderOfAccuracy = " << m_OrderOfAccuracy << "}" << std::endl;
@@ -138,11 +138,11 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
 
   /** Calculates operator coefficients. */
   CoefficientVector
-  GenerateCoefficients();
+  GenerateCoefficients() ITK_OVERRIDE;
 
   /** Arranges coefficients spatially in the memory buffer. */
   void
-  Fill(const CoefficientVector & coeff)
+  Fill(const CoefficientVector & coeff) ITK_OVERRIDE
   {
     Superclass::FillCenteredDirectional(coeff);
   }
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index dd3f854d7b3..745ceb63873 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -122,9 +122,9 @@ class HigherOrderAccurateGradientImageFilter
 itkGetConstMacro(OrderOfAccuracy, unsigned int)
 
   protected : HigherOrderAccurateGradientImageFilter();
-  virtual ~HigherOrderAccurateGradientImageFilter() {}
-  virtual void
-  PrintSelf(std::ostream & os, Indent indent) const;
+  ~HigherOrderAccurateGradientImageFilter() override {}
+  void
+  PrintSelf(std::ostream & os, Indent indent) const override;
 
   /** GradientImageFilter needs a larger input requested region than
    * the output requested region.  As such, GradientImageFilter needs
@@ -132,8 +132,8 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    * in order to inform the pipeline execution model.
    *
    * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
-  virtual void
-  GenerateInputRequestedRegion();
+  void
+  GenerateInputRequestedRegion() override;
 
   /** GradientImageFilter can be implemented as a multithreaded filter.
    * Therefore, this implementation provides a ThreadedGenerateData()
@@ -145,7 +145,7 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    *
    * \sa ImageToImageFilter::ThreadedGenerateData(),
    *     ImageToImageFilter::GenerateData() */
-  virtual void
+  void
   ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) ITK_OVERRIDE;
 
 private:

From 4e5ceb28f655dab8379c4653c6cd9cb784915fbc Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Sat, 16 Dec 2017 19:16:58 -0600
Subject: [PATCH 14/41] ENH: ITKv5 override consistency
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Provide remove virtual and override

Use clang-tidy to add ITK_OVERRIDE, and to remove
redundant virtual on functions.

cd ../ITK;
clang-tidy -p ITK-clangtidy $find Modules/[A-J]*  -name *.cxx |fgrep -v ThirdParty) -checks=-*,modernize-use-override  -header-filter=.* -fix
clang-tidy -p ITK-clangtidy $(find Modules/[K-Z]*  -name *.cxx |fgrep -v ThirdParty) -checks=-*,modernize-use-override  -header-filter=.* -fix

https://stackoverflow.com/questions/39932391/virtual-override-or-both-c

When you override a function you don't technically need to write either virtual
or override.

The original base class declaration needs the keyword virtual to mark it as virtual.

In the derived class the function is virtual by way of having the ¹same type as
the base class function.

However, an override can help avoid bugs by producing a compilation error when
the intended override isn't technically an override. E.g. that the function
type isn't exactly like the base class function. Or that a maintenance of the
base class changes that function's type, e.g. adding a defaulted argument.

In the same way, a virtual keyword in the derived class can make such a bug
more subtle, by ensuring that the function is still is virtual in further
derived classes.

So the general advice is,

virtual for the base class function declaration.
This is technically necessary.

Use override (only) for a derived class' override.
This helps with maintenance.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h   | 4 ++--
 .../include/itkHigherOrderAccurateGradientImageFilter.h     | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index a80574c861e..80e19c64b8e 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -120,9 +120,9 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
     , m_UseImageSpacing(true)
   {}
 
-  ~HigherOrderAccurateDerivativeImageFilter() override {}
+  ~HigherOrderAccurateDerivativeImageFilter() ITK_OVERRIDE {}
   void
-  PrintSelf(std::ostream & os, Indent indent) const override;
+  PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
 
   /** HigherOrderAccurateDerivativeImageFilter needs a larger input requested region than
    * the output requested region (larger in the direction of the
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 745ceb63873..cfd37714c92 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -122,9 +122,9 @@ class HigherOrderAccurateGradientImageFilter
 itkGetConstMacro(OrderOfAccuracy, unsigned int)
 
   protected : HigherOrderAccurateGradientImageFilter();
-  ~HigherOrderAccurateGradientImageFilter() override {}
+  ~HigherOrderAccurateGradientImageFilter() ITK_OVERRIDE {}
   void
-  PrintSelf(std::ostream & os, Indent indent) const override;
+  PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
 
   /** GradientImageFilter needs a larger input requested region than
    * the output requested region.  As such, GradientImageFilter needs
@@ -133,7 +133,7 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    *
    * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
   void
-  GenerateInputRequestedRegion() override;
+  GenerateInputRequestedRegion() ITK_OVERRIDE;
 
   /** GradientImageFilter can be implemented as a multithreaded filter.
    * Therefore, this implementation provides a ThreadedGenerateData()

From cdc68e03415821a624320f5749990940d483a044 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Sat, 16 Dec 2017 19:36:25 -0600
Subject: [PATCH 15/41] COMP:  Use C++11 override directly

git grep -l "ITK_OVERRIDE" |   fgrep -v itk_compiler_detection.h | fgrep -v CMakeLists.txt |fgrep -v .cmake |   xargs sed -i '' -e "s/ITK_OVERRIDE/override/g"
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h | 8 ++++----
 .../include/itkHigherOrderAccurateDerivativeOperator.h    | 6 +++---
 .../include/itkHigherOrderAccurateGradientImageFilter.h   | 8 ++++----
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 80e19c64b8e..1a2d228c2c7 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -120,9 +120,9 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
     , m_UseImageSpacing(true)
   {}
 
-  ~HigherOrderAccurateDerivativeImageFilter() ITK_OVERRIDE {}
+  ~HigherOrderAccurateDerivativeImageFilter() override {}
   void
-  PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
+  PrintSelf(std::ostream & os, Indent indent) const override;
 
   /** HigherOrderAccurateDerivativeImageFilter needs a larger input requested region than
    * the output requested region (larger in the direction of the
@@ -132,7 +132,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
    *
    * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
   void
-  GenerateInputRequestedRegion() ITK_OVERRIDE;
+  GenerateInputRequestedRegion() override;
 
   /** Standard pipeline method. While this class does not implement a
    * ThreadedGenerateData(), its GenerateData() delegates all
@@ -140,7 +140,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
    * NeighborhoodOperatorImageFilter is multithreaded, this filter is
    * multithreaded by default. */
   void
-  GenerateData() ITK_OVERRIDE;
+  GenerateData() override;
 
 private:
   HigherOrderAccurateDerivativeImageFilter(const Self &); // purposely not implemented
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 119b1c57818..4416044d75f 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -124,7 +124,7 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
 
   /** Prints some debugging information */
   void
-  PrintSelf(std::ostream & os, Indent i) const ITK_OVERRIDE
+  PrintSelf(std::ostream & os, Indent i) const override
   {
     os << i << "HigherOrderAccurateDerivativeOperator { this=" << this << ", m_Order = " << m_Order
        << ", m_OrderOfAccuracy = " << m_OrderOfAccuracy << "}" << std::endl;
@@ -138,11 +138,11 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
 
   /** Calculates operator coefficients. */
   CoefficientVector
-  GenerateCoefficients() ITK_OVERRIDE;
+  GenerateCoefficients() override;
 
   /** Arranges coefficients spatially in the memory buffer. */
   void
-  Fill(const CoefficientVector & coeff) ITK_OVERRIDE
+  Fill(const CoefficientVector & coeff) override
   {
     Superclass::FillCenteredDirectional(coeff);
   }
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index cfd37714c92..8436b6dead7 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -122,9 +122,9 @@ class HigherOrderAccurateGradientImageFilter
 itkGetConstMacro(OrderOfAccuracy, unsigned int)
 
   protected : HigherOrderAccurateGradientImageFilter();
-  ~HigherOrderAccurateGradientImageFilter() ITK_OVERRIDE {}
+  ~HigherOrderAccurateGradientImageFilter() override {}
   void
-  PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
+  PrintSelf(std::ostream & os, Indent indent) const override;
 
   /** GradientImageFilter needs a larger input requested region than
    * the output requested region.  As such, GradientImageFilter needs
@@ -133,7 +133,7 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    *
    * \sa ImageToImageFilter::GenerateInputRequestedRegion() */
   void
-  GenerateInputRequestedRegion() ITK_OVERRIDE;
+  GenerateInputRequestedRegion() override;
 
   /** GradientImageFilter can be implemented as a multithreaded filter.
    * Therefore, this implementation provides a ThreadedGenerateData()
@@ -146,7 +146,7 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    * \sa ImageToImageFilter::ThreadedGenerateData(),
    *     ImageToImageFilter::GenerateData() */
   void
-  ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) ITK_OVERRIDE;
+  ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) override;
 
 private:
   HigherOrderAccurateGradientImageFilter(const Self &); // purposely not implemented

From c5d6ac214180242fca4c6ad351a51ca5137f5bef Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Mon, 12 Feb 2018 21:03:24 -0600
Subject: [PATCH 16/41] STYLE: Replace itkStaticConstMacro with static
 constexpr

Use static constexpr directly now that C++11 conformance
is required by all compilers.

:%s/itkStaticConstMacro *( *\([^,]*\),[ \_s]*\([^,]*\),\_s*\([^)]*\)) */static constexpr \2 \1 = \3/ge
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h       | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.h         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 1a2d228c2c7..567816ff794 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -64,7 +64,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
 
   /** Extract some information from the image types.  Dimensionality
    * of the two images is assumed to be the same. */
-  itkStaticConstMacro(ImageDimension, unsigned int, TOutputImage::ImageDimension);
+  static constexpr unsigned int ImageDimension = TOutputImage::ImageDimension;
 
   /** Image typedef support. */
   typedef TInputImage  InputImageType;
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 8436b6dead7..5ce0f20e5f4 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -58,7 +58,7 @@ class HigherOrderAccurateGradientImageFilter
 {
 public:
   /** Extract dimension from input image. */
-  itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension);
+  static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
 
   /** Standard class typedefs. */
   typedef HigherOrderAccurateGradientImageFilter Self;

From d2c6773794e08d5d50858f4baac62d07136abc2d Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Mon, 12 Feb 2018 23:29:50 -0600
Subject: [PATCH 17/41] STYLE: Prefer C++11 type alias over typedef

== http://en.cppreference.com/w/cpp/language/type_alias ==

Type alias is a name that refers to a previously defined type (similar
to typedef).

A type alias declaration introduces a name which can be used as a
synonym for the type denoted by type-id. It does not introduce a new
type and it cannot change the meaning of an existing type name. There is
no difference between a type alias declaration and typedef declaration.
This declaration may appear in block scope, class scope, or namespace
scope.

== https://www.quora.com/Is-using-typedef-in-C++-considered-a-bad-practice ==

While typedef is still available for backward compatibility, the new
Type Alias syntax 'using Alias = ExistingLongName;' is more consistent
with the flow of C++ than the old typedef syntax 'typedef
ExistingLongName Alias;', and it also works for templates (Type alias,
alias template (since C++11)), so leftover 'typedef' aliases will differ
in style from any alias templates.
---
 ...HigherOrderAccurateDerivativeImageFilter.h | 24 +++++------
 ...gherOrderAccurateDerivativeImageFilter.hxx |  2 +-
 ...itkHigherOrderAccurateDerivativeOperator.h | 12 +++---
 ...tkHigherOrderAccurateGradientImageFilter.h | 41 +++++++++----------
 ...OrderAccurateDerivativeImageFilterTest.cxx | 26 ++++++------
 ...erOrderAccurateGradientImageFilterTest.cxx | 26 ++++++------
 6 files changed, 65 insertions(+), 66 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 567816ff794..3aa8e056f85 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -49,26 +49,26 @@ template <class TInputImage, class TOutputImage>
 class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
 {
 public:
-  /** Standard class typedefs. */
-  typedef HigherOrderAccurateDerivativeImageFilter      Self;
-  typedef ImageToImageFilter<TInputImage, TOutputImage> Superclass;
-  typedef SmartPointer<Self>                            Pointer;
-  typedef SmartPointer<const Self>                      ConstPointer;
+  /** Standard class type alias. */
+  using Self = HigherOrderAccurateDerivativeImageFilter;
+  using Superclass = ImageToImageFilter<TInputImage, TOutputImage>;
+  using Pointer = SmartPointer<Self>;
+  using ConstPointer = SmartPointer<const Self>;
 
   /** Extract some information from the image types.  Dimensionality
    * of the two images is assumed to be the same. */
-  typedef typename TOutputImage::PixelType         OutputPixelType;
-  typedef typename TOutputImage::InternalPixelType OutputInternalPixelType;
-  typedef typename TInputImage::PixelType          InputPixelType;
-  typedef typename TInputImage::InternalPixelType  InputInternalPixelType;
+  using OutputPixelType = typename TOutputImage::PixelType;
+  using OutputInternalPixelType = typename TOutputImage::InternalPixelType;
+  using InputPixelType = typename TInputImage::PixelType;
+  using InputInternalPixelType = typename TInputImage::InternalPixelType;
 
   /** Extract some information from the image types.  Dimensionality
    * of the two images is assumed to be the same. */
   static constexpr unsigned int ImageDimension = TOutputImage::ImageDimension;
 
-  /** Image typedef support. */
-  typedef TInputImage  InputImageType;
-  typedef TOutputImage OutputImageType;
+  /** Image type alias support. */
+  using InputImageType = TInputImage;
+  using OutputImageType = TOutputImage;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index 3d59bc92b20..c9b69116b16 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -90,7 +90,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateDat
 
   // Define the operator value type so that we can filter integral
   // images and have the proper operator defined.
-  typedef typename NumericTraits<OutputPixelType>::RealType OperatorValueType;
+  using OperatorValueType = typename NumericTraits<OutputPixelType>::RealType;
 
   // Filter
   HigherOrderAccurateDerivativeOperator<OperatorValueType, ImageDimension> oper;
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 4416044d75f..a432ae83546 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -61,12 +61,12 @@ template <class TPixel, unsigned int VDimension = 2, class TAllocator = Neighbor
 class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel, VDimension, TAllocator>
 {
 public:
-  /** Standard class typedefs. */
-  typedef HigherOrderAccurateDerivativeOperator                Self;
-  typedef NeighborhoodOperator<TPixel, VDimension, TAllocator> Superclass;
+  /** Standard class type alias. */
+  using Self = HigherOrderAccurateDerivativeOperator;
+  using Superclass = NeighborhoodOperator<TPixel, VDimension, TAllocator>;
 
-  typedef typename Superclass::PixelType     PixelType;
-  typedef typename Superclass::PixelRealType PixelRealType;
+  using PixelType = typename Superclass::PixelType;
+  using PixelRealType = typename Superclass::PixelRealType;
 
   /** Run-time type information (and related methods). */
   itkTypeMacro(HigherOrderAccurateDerivativeOperator, NeighborhoodOperator);
@@ -134,7 +134,7 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
 protected:
   /** Typedef support for coefficient vector type.  Necessary to
    * work around compiler bug on VC++. */
-  typedef typename Superclass::CoefficientVector CoefficientVector;
+  using CoefficientVector = typename Superclass::CoefficientVector;
 
   /** Calculates operator coefficients. */
   CoefficientVector
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 5ce0f20e5f4..6bfda8cdacc 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -60,21 +60,20 @@ class HigherOrderAccurateGradientImageFilter
   /** Extract dimension from input image. */
   static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
 
-  /** Standard class typedefs. */
-  typedef HigherOrderAccurateGradientImageFilter Self;
-
-  /** Convenient typedefs for simplifying declarations. */
-  typedef TInputImage                      InputImageType;
-  typedef typename InputImageType::Pointer InputImagePointer;
-  typedef Image<CovariantVector<TOutputValueType, itkGetStaticConstMacro(OutputImageDimension)>,
-                itkGetStaticConstMacro(OutputImageDimension)>
-                                            OutputImageType;
-  typedef typename OutputImageType::Pointer OutputImagePointer;
-
-  /** Standard class typedefs. */
-  typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
-  typedef SmartPointer<Self>                                  Pointer;
-  typedef SmartPointer<const Self>                            ConstPointer;
+  /** Standard class type alias. */
+  using Self = HigherOrderAccurateGradientImageFilter;
+
+  /** Convenient type alias for simplifying declarations. */
+  using InputImageType = TInputImage;
+  using InputImagePointer = typename InputImageType::Pointer;
+  using OutputImageType = Image<CovariantVector<TOutputValueType, itkGetStaticConstMacro(OutputImageDimension)>,
+                                itkGetStaticConstMacro(OutputImageDimension)>;
+  using OutputImagePointer = typename OutputImageType::Pointer;
+
+  /** Standard class type alias. */
+  using Superclass = ImageToImageFilter<InputImageType, OutputImageType>;
+  using Pointer = SmartPointer<Self>;
+  using ConstPointer = SmartPointer<const Self>;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
@@ -82,12 +81,12 @@ class HigherOrderAccurateGradientImageFilter
   /** Run-time type information (and related methods). */
   itkTypeMacro(HigherOrderAccurateGradientImageFilter, ImageToImageFilter);
 
-  /** Image typedef support. */
-  typedef typename InputImageType::PixelType                                             InputPixelType;
-  typedef TOperatorValueType                                                             OperatorValueType;
-  typedef TOutputValueType                                                               OutputValueType;
-  typedef CovariantVector<OutputValueType, itkGetStaticConstMacro(OutputImageDimension)> OutputPixelType;
-  typedef typename OutputImageType::RegionType                                           OutputImageRegionType;
+  /** Image type alias support. */
+  using InputPixelType = typename InputImageType::PixelType;
+  using OperatorValueType = TOperatorValueType;
+  using OutputValueType = TOutputValueType;
+  using OutputPixelType = CovariantVector<OutputValueType, itkGetStaticConstMacro(OutputImageDimension)>;
+  using OutputImageRegionType = typename OutputImageType::RegionType;
 
   /** Set/Get whether or not the filter will use the spacing of the input
       image in its calculations */
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
index b5dcfcf44b4..3736b3ba03a 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
@@ -32,33 +32,33 @@ itkHigherOrderAccurateDerivativeImageFilterTest(int argc, char * argv[])
     return EXIT_FAILURE;
   }
 
-  const unsigned int                       Dimension = 2;
-  typedef float                            PixelType;
-  typedef itk::Image<PixelType, Dimension> ImageType;
+  const unsigned int Dimension = 2;
+  using PixelType = float;
+  using ImageType = itk::Image<PixelType, Dimension>;
 
   std::string outputPrefix = argv[2];
 
-  typedef itk::ImageFileReader<ImageType> ReaderType;
-  ReaderType::Pointer                     reader = ReaderType::New();
+  using ReaderType = itk::ImageFileReader<ImageType>;
+  ReaderType::Pointer reader = ReaderType::New();
   reader->SetFileName(argv[1]);
 
-  typedef itk::HigherOrderAccurateDerivativeImageFilter<ImageType, ImageType> HigherFilterType;
-  HigherFilterType::Pointer                                                   nthFilter = HigherFilterType::New();
+  using HigherFilterType = itk::HigherOrderAccurateDerivativeImageFilter<ImageType, ImageType>;
+  HigherFilterType::Pointer nthFilter = HigherFilterType::New();
   nthFilter->SetInput(reader->GetOutput());
   nthFilter->SetOrder(1);
 
-  typedef itk::ImageFileWriter<ImageType> WriterType;
-  WriterType::Pointer                     nthWriter = WriterType::New();
+  using WriterType = itk::ImageFileWriter<ImageType>;
+  WriterType::Pointer nthWriter = WriterType::New();
   nthWriter->SetInput(nthFilter->GetOutput());
 
   // First order accurate.
-  typedef itk::DerivativeImageFilter<ImageType, ImageType> FirstFilterType;
-  FirstFilterType::Pointer                                 firstFilter = FirstFilterType::New();
+  using FirstFilterType = itk::DerivativeImageFilter<ImageType, ImageType>;
+  FirstFilterType::Pointer firstFilter = FirstFilterType::New();
   firstFilter->SetInput(reader->GetOutput());
   firstFilter->SetOrder(1);
 
-  typedef itk::ImageFileWriter<ImageType> WriterType;
-  WriterType::Pointer                     firstWriter = WriterType::New();
+  using WriterType = itk::ImageFileWriter<ImageType>;
+  WriterType::Pointer firstWriter = WriterType::New();
   firstWriter->SetInput(firstFilter->GetOutput());
 
   std::ostringstream ostrm;
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
index 52629b6f457..f1e06efcc58 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
@@ -33,31 +33,31 @@ itkHigherOrderAccurateGradientImageFilterTest(int argc, char * argv[])
     return EXIT_FAILURE;
   }
 
-  const unsigned int                       Dimension = 2;
-  typedef float                            PixelType;
-  typedef itk::Image<PixelType, Dimension> ImageType;
+  const unsigned int Dimension = 2;
+  using PixelType = float;
+  using ImageType = itk::Image<PixelType, Dimension>;
 
-  typedef itk::ImageFileReader<ImageType> ReaderType;
-  ReaderType::Pointer                     reader = ReaderType::New();
+  using ReaderType = itk::ImageFileReader<ImageType>;
+  ReaderType::Pointer reader = ReaderType::New();
   reader->SetFileName(argv[1]);
 
   // First order accurate.
-  typedef itk::GradientImageFilter<ImageType, float, float> FirstFilterType;
-  FirstFilterType::Pointer                                  firstFilter = FirstFilterType::New();
+  using FirstFilterType = itk::GradientImageFilter<ImageType, float, float>;
+  FirstFilterType::Pointer firstFilter = FirstFilterType::New();
   firstFilter->SetInput(reader->GetOutput());
 
-  typedef itk::HigherOrderAccurateGradientImageFilter<ImageType, float, float> FilterType;
-  typedef FilterType::OutputImageType                                          GradientImageType;
-  FilterType::Pointer                                                          filter = FilterType::New();
+  using FilterType = itk::HigherOrderAccurateGradientImageFilter<ImageType, float, float>;
+  using GradientImageType = FilterType::OutputImageType;
+  FilterType::Pointer filter = FilterType::New();
   filter->SetInput(reader->GetOutput());
 
   std::string outputPrefix = argv[2];
 
-  typedef itk::VectorMagnitudeImageFilter<GradientImageType, ImageType> GradientMagnitudeFilterType;
+  using GradientMagnitudeFilterType = itk::VectorMagnitudeImageFilter<GradientImageType, ImageType>;
   GradientMagnitudeFilterType::Pointer gradientMagnitude = GradientMagnitudeFilterType::New();
 
-  typedef itk::ImageFileWriter<ImageType> GradientMagnitudeWriterType;
-  GradientMagnitudeWriterType::Pointer    gradientMagnitudeWriter = GradientMagnitudeWriterType::New();
+  using GradientMagnitudeWriterType = itk::ImageFileWriter<ImageType>;
+  GradientMagnitudeWriterType::Pointer gradientMagnitudeWriter = GradientMagnitudeWriterType::New();
   gradientMagnitudeWriter->SetInput(gradientMagnitude->GetOutput());
 
   std::ostringstream ostrm;

From 55d432a713b48d60a78e218bcd74e82f36a9e02d Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Tue, 13 Feb 2018 08:24:15 -0600
Subject: [PATCH 18/41] STYLE: Prefer constexpr for const numeric literals

Use constexpr for constant numeric literals.
---
 .../test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx    | 2 +-
 .../test/itkHigherOrderAccurateGradientImageFilterTest.cxx      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
index 3736b3ba03a..ceda8c10299 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
@@ -32,7 +32,7 @@ itkHigherOrderAccurateDerivativeImageFilterTest(int argc, char * argv[])
     return EXIT_FAILURE;
   }
 
-  const unsigned int Dimension = 2;
+  constexpr unsigned int Dimension = 2;
   using PixelType = float;
   using ImageType = itk::Image<PixelType, Dimension>;
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
index f1e06efcc58..1464496a7a6 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
@@ -33,7 +33,7 @@ itkHigherOrderAccurateGradientImageFilterTest(int argc, char * argv[])
     return EXIT_FAILURE;
   }
 
-  const unsigned int Dimension = 2;
+  constexpr unsigned int Dimension = 2;
   using PixelType = float;
   using ImageType = itk::Image<PixelType, Dimension>;
 

From f1a3b773e6c74224d4daacde2d01259dbf9a71b2 Mon Sep 17 00:00:00 2001
From: Jon Haitz Legarreta <jhlegarreta@vicomtech.org>
Date: Sat, 14 Apr 2018 19:16:38 +0200
Subject: [PATCH 19/41] COMP: Move ITK_DISALLOW_COPY_AND_ASSIGN calls to public
 section.

Move `ITK_DISALLOW_COPY_AND_ASSIGN` calls to public section following
the discussion in
https://discourse.itk.org/t/noncopyable

If legacy (pre-macro) copy and assing methods existed, subsitute them
for the `ITK_DISALLOW_COPY_AND_ASSIGN` macro.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h   | 6 ++----
 .../include/itkHigherOrderAccurateGradientImageFilter.h     | 6 ++----
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 3aa8e056f85..acc847ef8d4 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -49,6 +49,8 @@ template <class TInputImage, class TOutputImage>
 class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
 {
 public:
+  ITK_DISALLOW_COPY_AND_ASSIGN(HigherOrderAccurateDerivativeImageFilter);
+
   /** Standard class type alias. */
   using Self = HigherOrderAccurateDerivativeImageFilter;
   using Superclass = ImageToImageFilter<TInputImage, TOutputImage>;
@@ -143,10 +145,6 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
   GenerateData() override;
 
 private:
-  HigherOrderAccurateDerivativeImageFilter(const Self &); // purposely not implemented
-  void
-  operator=(const Self &); // purposely not implemented
-
   /** The order of the derivative. */
   unsigned int m_Order;
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 6bfda8cdacc..f5ef564e301 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -57,6 +57,8 @@ class HigherOrderAccurateGradientImageFilter
       Image<CovariantVector<TOutputValueType, TInputImage::ImageDimension>, TInputImage::ImageDimension>>
 {
 public:
+  ITK_DISALLOW_COPY_AND_ASSIGN(HigherOrderAccurateGradientImageFilter);
+
   /** Extract dimension from input image. */
   static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
 
@@ -148,10 +150,6 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
   ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) override;
 
 private:
-  HigherOrderAccurateGradientImageFilter(const Self &); // purposely not implemented
-  void
-  operator=(const Self &); // purposely not implemented
-
   bool m_UseImageSpacing;
 
   // flag to take or not the image direction into account

From cc207e9117a429bf66612a41c8266e58eb40ff33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?=
 <jhlegarreta@vicomtech.org>
Date: Thu, 7 Jun 2018 19:49:51 +0200
Subject: [PATCH 20/41] ENH: Add CI configuration files.

Add CircleCI configuration files and badges.
---
 .../wrapping/CMakeLists.txt                           |  3 +++
 .../itkHigherOrderAccurateDerivativeImageFilter.wrap  | 11 +++++++++++
 .../itkHigherOrderAccurateDerivativeOperator.wrap     | 11 +++++++++++
 .../itkHigherOrderAccurateGradientmageFilter.wrap     | 11 +++++++++++
 4 files changed, 36 insertions(+)
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/wrapping/CMakeLists.txt
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/CMakeLists.txt
new file mode 100644
index 00000000000..838523995e4
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/CMakeLists.txt
@@ -0,0 +1,3 @@
+itk_wrap_module(HigherOrderAccurateGradient)
+itk_auto_load_submodules()
+itk_end_wrap_module()
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap
new file mode 100644
index 00000000000..2715188a5ff
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap
@@ -0,0 +1,11 @@
+itk_wrap_class("itk::HigherOrderAccurateGradientImageFilter" POINTER)
+foreach(d ${ITK_WRAP_IMAGE_DIMS})
+  set(vector_dim ${d}) # Wrap only vector dimensions which are the same as image dimensions
+  foreach(p D)
+    itk_wrap_template(
+        "${ITKM_IV${p}${vector_dim}${d}}${ITKM_${p}}${ITKM_${p}}"
+        "${ITKT_IV${p}${vector_dim}${d}}, ${ITKT_${p}}, ${ITKT_${p}}"
+    )
+  endforeach()
+endforeach()
+itk_end_wrap_class()
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap
new file mode 100644
index 00000000000..8a819d2ad46
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap
@@ -0,0 +1,11 @@
+itk_wrap_class("itk::HigherOrderAccurateDerivativeOperator" POINTER)
+foreach(d ${ITK_WRAP_IMAGE_DIMS})
+  set(vector_dim ${d}) # Wrap only vector dimensions which are the same as image dimensions
+  foreach(p D)
+    itk_wrap_template(
+        "${ITKM_IV${p}${vector_dim}${d}}${ITKM_${p}}${ITKM_${p}}"
+        "${ITKT_IV${p}${vector_dim}${d}}, ${ITKT_${p}}, ${ITKT_${p}}"
+    )
+  endforeach()
+endforeach()
+itk_end_wrap_class()
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap
new file mode 100644
index 00000000000..2715188a5ff
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap
@@ -0,0 +1,11 @@
+itk_wrap_class("itk::HigherOrderAccurateGradientImageFilter" POINTER)
+foreach(d ${ITK_WRAP_IMAGE_DIMS})
+  set(vector_dim ${d}) # Wrap only vector dimensions which are the same as image dimensions
+  foreach(p D)
+    itk_wrap_template(
+        "${ITKM_IV${p}${vector_dim}${d}}${ITKM_${p}}${ITKM_${p}}"
+        "${ITKT_IV${p}${vector_dim}${d}}, ${ITKT_${p}}, ${ITKT_${p}}"
+    )
+  endforeach()
+endforeach()
+itk_end_wrap_class()

From 5463473c978b854a1430306afe73cc281efe5252 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 15 Jul 2018 19:35:46 -0400
Subject: [PATCH 21/41] BUG: Add external module CMake configuration

---
 Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
index fae9f7d82a2..e56131d5a48 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
+++ b/Modules/Filtering/HigherOrderAccurateGradient/CMakeLists.txt
@@ -1,2 +1,3 @@
 project(HigherOrderAccurateGradient)
+
 itk_module_impl()

From 17e2a30a00c9b20f6f661bb2f54dd5b03be3abfc Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 15 Jul 2018 20:15:26 -0400
Subject: [PATCH 22/41] BUG: Fix Python wrapping

Instantiated types should be compatible with class template
specification.

Types should correspond to selected wrapping types.
---
 .../itkHigherOrderAccurateDerivativeImageFilter.h     |  2 +-
 .../itkHigherOrderAccurateDerivativeOperator.h        |  2 +-
 .../itkHigherOrderAccurateGradientImageFilter.h       |  2 +-
 .../itkHigherOrderAccurateDerivativeImageFilter.wrap  |  9 ++++-----
 .../itkHigherOrderAccurateDerivativeOperator.wrap     | 11 -----------
 .../itkHigherOrderAccurateGradientmageFilter.wrap     |  7 +++----
 6 files changed, 10 insertions(+), 23 deletions(-)
 delete mode 100644 Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index acc847ef8d4..ca7a01ae807 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -45,7 +45,7 @@ namespace itk
  * \ingroup ImageFeatureExtraction
  * \ingroup HigherOrderAccurateGradient
  */
-template <class TInputImage, class TOutputImage>
+template <typename TInputImage, typename TOutputImage>
 class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
 {
 public:
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index a432ae83546..5159db16614 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -57,7 +57,7 @@ namespace itk
  * \ingroup Operators
  * \ingroup HigherOrderAccurateGradient
  */
-template <class TPixel, unsigned int VDimension = 2, class TAllocator = NeighborhoodAllocator<TPixel>>
+template <typename TPixel, unsigned int VDimension = 2, typename TAllocator = NeighborhoodAllocator<TPixel>>
 class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel, VDimension, TAllocator>
 {
 public:
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index f5ef564e301..96f2faef709 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -50,7 +50,7 @@ namespace itk
  * \ingroup GradientFilters
  * \ingroup HigherOrderAccurateGradient
  */
-template <class TInputImage, class TOperatorValueType = float, class TOutputValueType = float>
+template <typename TInputImage, typename TOperatorValueType = float, class TOutputValueType = float>
 class HigherOrderAccurateGradientImageFilter
   : public ImageToImageFilter<
       TInputImage,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap
index 2715188a5ff..dcc2e92f4e0 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap
+++ b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeImageFilter.wrap
@@ -1,10 +1,9 @@
-itk_wrap_class("itk::HigherOrderAccurateGradientImageFilter" POINTER)
+itk_wrap_class("itk::HigherOrderAccurateDerivativeImageFilter" POINTER)
 foreach(d ${ITK_WRAP_IMAGE_DIMS})
-  set(vector_dim ${d}) # Wrap only vector dimensions which are the same as image dimensions
-  foreach(p D)
+  foreach(t ${WRAP_ITK_REAL})
     itk_wrap_template(
-        "${ITKM_IV${p}${vector_dim}${d}}${ITKM_${p}}${ITKM_${p}}"
-        "${ITKT_IV${p}${vector_dim}${d}}, ${ITKT_${p}}, ${ITKT_${p}}"
+        "${ITKM_I${t}${d}}${ITKM_I${t}${d}}"
+        "${ITKT_I${t}${d}}, ${ITKT_I${t}${d}}"
     )
   endforeach()
 endforeach()
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap
deleted file mode 100644
index 8a819d2ad46..00000000000
--- a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateDerivativeOperator.wrap
+++ /dev/null
@@ -1,11 +0,0 @@
-itk_wrap_class("itk::HigherOrderAccurateDerivativeOperator" POINTER)
-foreach(d ${ITK_WRAP_IMAGE_DIMS})
-  set(vector_dim ${d}) # Wrap only vector dimensions which are the same as image dimensions
-  foreach(p D)
-    itk_wrap_template(
-        "${ITKM_IV${p}${vector_dim}${d}}${ITKM_${p}}${ITKM_${p}}"
-        "${ITKT_IV${p}${vector_dim}${d}}, ${ITKT_${p}}, ${ITKT_${p}}"
-    )
-  endforeach()
-endforeach()
-itk_end_wrap_class()
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap
index 2715188a5ff..09f2d124255 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap
+++ b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap
@@ -1,10 +1,9 @@
 itk_wrap_class("itk::HigherOrderAccurateGradientImageFilter" POINTER)
 foreach(d ${ITK_WRAP_IMAGE_DIMS})
-  set(vector_dim ${d}) # Wrap only vector dimensions which are the same as image dimensions
-  foreach(p D)
+  foreach(t ${WRAP_ITK_REAL})
     itk_wrap_template(
-        "${ITKM_IV${p}${vector_dim}${d}}${ITKM_${p}}${ITKM_${p}}"
-        "${ITKT_IV${p}${vector_dim}${d}}, ${ITKT_${p}}, ${ITKT_${p}}"
+        "${ITKM_I${t}${d}}${ITKM_${t}}${ITKM_${t}}"
+        "${ITKT_I${t}${d}}, ${ITKT_${t}}, ${ITKT_${t}}"
     )
   endforeach()
 endforeach()

From fb18a7031bba7bb769dea56511370298d3fbf933 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 15 Jul 2018 20:21:27 -0400
Subject: [PATCH 23/41] COMP: Update to use DynamicThreadedGenerateData

---
 .../itkHigherOrderAccurateGradientImageFilter.h        |  2 +-
 .../itkHigherOrderAccurateGradientImageFilter.hxx      | 10 ++--------
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 96f2faef709..f930275b1f0 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -147,7 +147,7 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
    * \sa ImageToImageFilter::ThreadedGenerateData(),
    *     ImageToImageFilter::GenerateData() */
   void
-  ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) override;
+  DynamicThreadedGenerateData(const OutputImageRegionType & outputRegionForThread) override;
 
 private:
   bool m_UseImageSpacing;
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index d098f827500..d213659e3be 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -25,7 +25,6 @@
 #include "itkHigherOrderAccurateDerivativeOperator.h"
 #include "itkNeighborhoodAlgorithm.h"
 #include "itkOffset.h"
-#include "itkProgressReporter.h"
 
 namespace itk
 {
@@ -97,9 +96,8 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
 
 template <class TInputImage, class TOperatorValueType, class TOutputValueType>
 void
-HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::ThreadedGenerateData(
-  const OutputImageRegionType & outputRegionForThread,
-  ThreadIdType                  threadId)
+HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::DynamicThreadedGenerateData(
+  const OutputImageRegionType & outputRegionForThread)
 {
   unsigned int    i;
   OutputPixelType gradient;
@@ -158,9 +156,6 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
   typename NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator fit;
   fit = faceList.begin();
 
-  // support progress methods/callbacks
-  ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());
-
   // Initialize the x_slice array
   nit = ConstNeighborhoodIterator<InputImageType>(radius, inputImage, *fit);
 
@@ -197,7 +192,6 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
       }
       ++nit;
       ++it;
-      progress.CompletedPixel();
     }
   }
 }

From c80c28d1faf2f6f7105933ea78d943d730822fcd Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 15 Jul 2018 20:23:35 -0400
Subject: [PATCH 24/41] STYLE: Use typename instead of class

---
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx | 6 ++++--
 .../itkHigherOrderAccurateGradientImageFilter.hxx        | 9 +++++----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index ff2299cd843..11535a1e9f7 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -23,7 +23,8 @@
 
 namespace itk
 {
-template <class TPixel, unsigned int VDimension, class TAllocator>
+
+template <typename TPixel, unsigned int VDimension, typename TAllocator>
 typename HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::CoefficientVector
 HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateCoefficients()
 {
@@ -36,7 +37,8 @@ HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateC
   }
 }
 
-template <class TPixel, unsigned int VDimension, class TAllocator>
+
+template <typename TPixel, unsigned int VDimension, typename TAllocator>
 typename HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::CoefficientVector
 HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateFirstOrderCoefficients()
 {
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index d213659e3be..818e3da03e1 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -29,7 +29,7 @@
 namespace itk
 {
 
-template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
   HigherOrderAccurateGradientImageFilter()
   : m_UseImageSpacing(true)
@@ -37,7 +37,8 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
   , m_OrderOfAccuracy(2)
 {}
 
-template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+
+template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
 void
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
   GenerateInputRequestedRegion()
@@ -94,7 +95,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
 }
 
 
-template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
 void
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::DynamicThreadedGenerateData(
   const OutputImageRegionType & outputRegionForThread)
@@ -197,7 +198,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
 }
 
 
-template <class TInputImage, class TOperatorValueType, class TOutputValueType>
+template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
 void
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::PrintSelf(
   std::ostream & os,

From d8fff95804d4366eee1247c7b7cd6be0e2f6ada7 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Sun, 15 Jul 2018 20:26:31 -0400
Subject: [PATCH 25/41] BUG: Remove extra SplitComponent module dependency

---
 Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
index f35a56fc21b..244bac429dc 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
+++ b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
@@ -17,7 +17,6 @@ itk_module(
     ITKImageGradient
     ITKImageIntensity
     ITKImageFeature
-    SplitComponents
   TEST_DEPENDS
     ITKTestKernel
   EXCLUDE_FROM_DEFAULT

From 38adf42f7be29f5bec73d0b90fd3c24bb9dd7986 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?=
 <jon.haitz.legarreta@gmail.com>
Date: Sat, 20 Oct 2018 16:23:10 -0400
Subject: [PATCH 26/41] STYLE: Use "typename" for template parameters.

As discussed in:
http://review.source.kitware.com/#/c/12655/

the use of the template keyword "class" was substituted by "typename" in
the toolkit for the reasons stated in that topic.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.hxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index c9b69116b16..0e73af45eda 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -27,7 +27,7 @@
 namespace itk
 {
 
-template <class TInputImage, class TOutputImage>
+template <typename TInputImage, typename TOutputImage>
 void
 HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateInputRequestedRegion()
 {
@@ -82,7 +82,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateInp
 }
 
 
-template <class TInputImage, class TOutputImage>
+template <typename TInputImage, typename TOutputImage>
 void
 HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateData()
 {
@@ -145,7 +145,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateDat
 }
 
 
-template <class TInputImage, class TOutputImage>
+template <typename TInputImage, typename TOutputImage>
 void
 HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::PrintSelf(std::ostream & os, Indent indent) const
 {

From c870f37ac2c07cce4fa18af1284de33b970e8461 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Mon, 17 Feb 2020 14:29:58 -0600
Subject: [PATCH 27/41] STYLE: Prefer = default to explicitly trivial
 implementations

This check replaces default bodies of special member functions with
= default;. The explicitly defaulted function declarations enable more
opportunities in optimization, because the compiler might treat
explicitly defaulted functions as trivial.

Additionally, the C++11 use of = default more clearly expreses the
intent for the special member functions.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h       | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.h         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index ca7a01ae807..256fce3e4fd 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -122,7 +122,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
     , m_UseImageSpacing(true)
   {}
 
-  ~HigherOrderAccurateDerivativeImageFilter() override {}
+  ~HigherOrderAccurateDerivativeImageFilter() override = default;
   void
   PrintSelf(std::ostream & os, Indent indent) const override;
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index f930275b1f0..14331127548 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -123,7 +123,7 @@ class HigherOrderAccurateGradientImageFilter
 itkGetConstMacro(OrderOfAccuracy, unsigned int)
 
   protected : HigherOrderAccurateGradientImageFilter();
-  ~HigherOrderAccurateGradientImageFilter() override {}
+  ~HigherOrderAccurateGradientImageFilter() override = default;
   void
   PrintSelf(std::ostream & os, Indent indent) const override;
 

From c9c5c2eabb49cd8378c9b1c852fdf7cf9bc2b727 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Mon, 17 Feb 2020 15:50:21 -0600
Subject: [PATCH 28/41] STYLE: Use default member initialization
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Converts a default constructor’s member initializers into the new
default member initializers in C++11. Other member initializers that match the
default member initializer are removed. This can reduce repeated code or allow
use of ‘= default’.
---
 .../itkHigherOrderAccurateDerivativeImageFilter.h | 15 +++++----------
 .../itkHigherOrderAccurateDerivativeOperator.h    |  9 +++------
 .../itkHigherOrderAccurateGradientImageFilter.h   |  6 +++---
 .../itkHigherOrderAccurateGradientImageFilter.hxx |  4 +---
 4 files changed, 12 insertions(+), 22 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 256fce3e4fd..084450da25b 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -115,12 +115,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
   itkGetConstMacro(UseImageSpacing, bool);
 
 protected:
-  HigherOrderAccurateDerivativeImageFilter()
-    : m_Order(1)
-    , m_OrderOfAccuracy(2)
-    , m_Direction(0)
-    , m_UseImageSpacing(true)
-  {}
+  HigherOrderAccurateDerivativeImageFilter() {}
 
   ~HigherOrderAccurateDerivativeImageFilter() override = default;
   void
@@ -146,15 +141,15 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
 
 private:
   /** The order of the derivative. */
-  unsigned int m_Order;
+  unsigned int m_Order{ 1 };
 
   /** Order of accuracy. */
-  unsigned int m_OrderOfAccuracy;
+  unsigned int m_OrderOfAccuracy{ 2 };
 
   /** The direction of the derivative. */
-  unsigned int m_Direction;
+  unsigned int m_Direction{ 0 };
 
-  bool m_UseImageSpacing;
+  bool m_UseImageSpacing{ true };
 };
 
 } // end namespace itk
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 5159db16614..35cbdb92a5b 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -72,10 +72,7 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
   itkTypeMacro(HigherOrderAccurateDerivativeOperator, NeighborhoodOperator);
 
   /** Constructor. */
-  HigherOrderAccurateDerivativeOperator()
-    : m_Order(1)
-    , m_OrderOfAccuracy(2)
-  {}
+  HigherOrderAccurateDerivativeOperator() {}
 
   /** Copy constructor. */
   HigherOrderAccurateDerivativeOperator(const Self & other)
@@ -152,10 +149,10 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
   GenerateFirstOrderCoefficients();
 
   /** Order of the derivative. */
-  unsigned int m_Order;
+  unsigned int m_Order{ 1 };
 
   /** Order of accuracy. */
-  unsigned int m_OrderOfAccuracy;
+  unsigned int m_OrderOfAccuracy{ 2 };
 };
 
 } // namespace itk
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index 14331127548..c372ac5c847 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -150,13 +150,13 @@ itkGetConstMacro(OrderOfAccuracy, unsigned int)
   DynamicThreadedGenerateData(const OutputImageRegionType & outputRegionForThread) override;
 
 private:
-  bool m_UseImageSpacing;
+  bool m_UseImageSpacing{ true };
 
   // flag to take or not the image direction into account
   // when computing the derivatives.
-  bool m_UseImageDirection;
+  bool m_UseImageDirection{ true };
 
-  unsigned int m_OrderOfAccuracy;
+  unsigned int m_OrderOfAccuracy{ 2 };
 };
 
 } // end namespace itk
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index 818e3da03e1..7b806877ab1 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -32,9 +32,7 @@ namespace itk
 template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
   HigherOrderAccurateGradientImageFilter()
-  : m_UseImageSpacing(true)
-  , m_UseImageDirection(true)
-  , m_OrderOfAccuracy(2)
+
 {}
 
 

From 0cf7bc32c2461abf7868772fd3b824825cf4dc1f Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Mon, 17 Feb 2020 18:09:35 -0600
Subject: [PATCH 29/41] STYLE: Prefer = default to explicitly trivial
 implementations

This check replaces default bodies of special member functions with
= default;. The explicitly defaulted function declarations enable more
opportunities in optimization, because the compiler might treat
explicitly defaulted functions as trivial.

Additionally, the C++11 use of = default more clearly expreses the
intent for the special member functions.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h     | 4 +++-
 .../include/itkHigherOrderAccurateDerivativeOperator.h        | 4 +++-
 .../include/itkHigherOrderAccurateGradientImageFilter.hxx     | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 084450da25b..a7fa624aaea 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -115,7 +115,9 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
   itkGetConstMacro(UseImageSpacing, bool);
 
 protected:
-  HigherOrderAccurateDerivativeImageFilter() {}
+  HigherOrderAccurateDerivativeImageFilter()
+
+    = default;
 
   ~HigherOrderAccurateDerivativeImageFilter() override = default;
   void
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 35cbdb92a5b..16ec4eb87ee 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -72,7 +72,9 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
   itkTypeMacro(HigherOrderAccurateDerivativeOperator, NeighborhoodOperator);
 
   /** Constructor. */
-  HigherOrderAccurateDerivativeOperator() {}
+  HigherOrderAccurateDerivativeOperator()
+
+    = default;
 
   /** Copy constructor. */
   HigherOrderAccurateDerivativeOperator(const Self & other)
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index 7b806877ab1..fe3abba9dbd 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -33,7 +33,7 @@ template <typename TInputImage, typename TOperatorValueType, typename TOutputVal
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
   HigherOrderAccurateGradientImageFilter()
 
-{}
+  = default;
 
 
 template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>

From 72334ce3d8db39e2f09ed05cb525b10241c0d329 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Wed, 19 Feb 2020 10:45:25 -0600
Subject: [PATCH 30/41] DOC: Update copyright assignment to NumFOCUS

The mission of NumFOCUS is to promote open
practices in research, data, and scientific
computing.

https://numfocus.org
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h       | 2 +-
 .../include/itkHigherOrderAccurateDerivativeImageFilter.hxx     | 2 +-
 .../include/itkHigherOrderAccurateDerivativeOperator.h          | 2 +-
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx        | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.h         | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.hxx       | 2 +-
 .../test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx    | 2 +-
 .../test/itkHigherOrderAccurateGradientImageFilterTest.cxx      | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index a7fa624aaea..d78c4200c83 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index 0e73af45eda..f64b3215442 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 16ec4eb87ee..b0a03770d52 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index 11535a1e9f7..9270236178a 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index c372ac5c847..ecbcb9cf5e5 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index fe3abba9dbd..06e6c1358e4 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
index ceda8c10299..bb3356449eb 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
index 1464496a7a6..b9605b4cc69 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
@@ -1,6 +1,6 @@
 /*=========================================================================
  *
- *  Copyright Insight Software Consortium
+ *  Copyright NumFOCUS
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.

From f2d9e58a6076be8189f19b9a780d99df6db8710a Mon Sep 17 00:00:00 2001
From: Mathew Seng <mathewseng@gmail.com>
Date: Wed, 14 Oct 2020 11:10:08 -0500
Subject: [PATCH 31/41] STYLE: Rename ITK_DISALLOW_COPY_AND_ASSIGN to
 ITK_DISALLOW_COPY_AND_MOVE

Fixes changes made in #2053. ITK_DISALLOW_COPY_AND_ASSIGN will be used if ITK_FUTURE_LEGACY_REMOVE=OFF.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h       | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.h         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index d78c4200c83..2fb82b2515b 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -49,7 +49,7 @@ template <typename TInputImage, typename TOutputImage>
 class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
 {
 public:
-  ITK_DISALLOW_COPY_AND_ASSIGN(HigherOrderAccurateDerivativeImageFilter);
+  ITK_DISALLOW_COPY_AND_MOVE(HigherOrderAccurateDerivativeImageFilter);
 
   /** Standard class type alias. */
   using Self = HigherOrderAccurateDerivativeImageFilter;
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index ecbcb9cf5e5..d834be050fd 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -57,7 +57,7 @@ class HigherOrderAccurateGradientImageFilter
       Image<CovariantVector<TOutputValueType, TInputImage::ImageDimension>, TInputImage::ImageDimension>>
 {
 public:
-  ITK_DISALLOW_COPY_AND_ASSIGN(HigherOrderAccurateGradientImageFilter);
+  ITK_DISALLOW_COPY_AND_MOVE(HigherOrderAccurateGradientImageFilter);
 
   /** Extract dimension from input image. */
   static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;

From 8f700d0775ed6df449cce2d28146b4a9d4517388 Mon Sep 17 00:00:00 2001
From: Mathew Seng <mathewseng@gmail.com>
Date: Mon, 28 Dec 2020 10:20:03 -0600
Subject: [PATCH 32/41] COMP: Add missing ';' at end of macro

A ';' is required at the end of macros in a future version of ITK
---
 .../include/itkHigherOrderAccurateGradientImageFilter.h      | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index d834be050fd..b816203e640 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -120,9 +120,10 @@ class HigherOrderAccurateGradientImageFilter
   /** Set/Get the order of accuracy of the derivative operator.  For more
    * information, see HigherOrderAccurateDerivativeOperator. */
   itkSetMacro(OrderOfAccuracy, unsigned int);
-itkGetConstMacro(OrderOfAccuracy, unsigned int)
+  itkGetConstMacro(OrderOfAccuracy, unsigned int);
 
-  protected : HigherOrderAccurateGradientImageFilter();
+protected:
+  HigherOrderAccurateGradientImageFilter();
   ~HigherOrderAccurateGradientImageFilter() override = default;
   void
   PrintSelf(std::ostream & os, Indent indent) const override;

From 613bd982e0711ff082b54780defc505f422130c7 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Fri, 17 Dec 2021 09:35:30 -0600
Subject: [PATCH 33/41] COMP: Remove inclusion of .hxx files as headers

The ability to include either .h or .hxx files as
header files required recursively reading the
.h files twice.  The added complexity is
unnecessary, costly, and can confuse static
analysis tools that monitor header guardes (due
to reaching the maximum depth of recursion
limits for nested #ifdefs in checking).
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.hxx      | 1 -
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx         | 1 -
 .../include/itkHigherOrderAccurateGradientImageFilter.hxx        | 1 -
 3 files changed, 3 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index f64b3215442..a57f471da22 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -17,7 +17,6 @@
  *=========================================================================*/
 #ifndef itkHigherOrderAccurateDerivativeImageFilter_hxx
 #define itkHigherOrderAccurateDerivativeImageFilter_hxx
-#include "itkHigherOrderAccurateDerivativeImageFilter.h"
 
 #include "itkNumericTraits.h"
 #include "itkNeighborhoodOperatorImageFilter.h"
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index 9270236178a..dc6812e3cc7 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -17,7 +17,6 @@
  *=========================================================================*/
 #ifndef itkHigherOrderAccurateDerivativeOperator_hxx
 #define itkHigherOrderAccurateDerivativeOperator_hxx
-#include "itkHigherOrderAccurateDerivativeOperator.h"
 
 #include "itkNumericTraits.h"
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index 06e6c1358e4..3f6f96a3744 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -17,7 +17,6 @@
  *=========================================================================*/
 #ifndef itkHigherOrderAccurateGradientImageFilter_hxx
 #define itkHigherOrderAccurateGradientImageFilter_hxx
-#include "itkHigherOrderAccurateGradientImageFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"
 #include "itkNeighborhoodInnerProduct.h"

From a4e9e4b42044fae18c55102c5e7c52e52fe3bae4 Mon Sep 17 00:00:00 2001
From: Tom Birdsong <tom.birdsong@kitware.com>
Date: Tue, 31 May 2022 11:27:36 -0400
Subject: [PATCH 34/41] ENH: Bump ITK and replace http with https using script

---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h     | 2 +-
 .../include/itkHigherOrderAccurateDerivativeImageFilter.hxx   | 2 +-
 .../include/itkHigherOrderAccurateDerivativeOperator.h        | 2 +-
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx      | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.h       | 2 +-
 .../include/itkHigherOrderAccurateGradientImageFilter.hxx     | 2 +-
 .../Filtering/HigherOrderAccurateGradient/itk-module.cmake    | 4 ++--
 .../test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx  | 2 +-
 .../test/itkHigherOrderAccurateGradientImageFilterTest.cxx    | 2 +-
 9 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index 2fb82b2515b..cddcfd15a5f 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index a57f471da22..987249d9821 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index b0a03770d52..118a6cadac6 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index dc6812e3cc7..07f5760c89d 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
index b816203e640..efc205851fd 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.h
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index 3f6f96a3744..9616d5270a3 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
index 244bac429dc..86f64da228c 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
+++ b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
@@ -5,8 +5,8 @@ set(
 accurate numerical derivatives and gradients from an input scalar image.
 field from a displacement field image.
 Higher Order Accurate Derivative and Gradient Calculation in ITK
-http://www.insight-journal.org/browse/publication/775
-http://hdl.handle.net/10380/3231
+https://www.insight-journal.org/browse/publication/775
+https://hdl.handle.net/10380/3231
 "
 )
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
index bb3356449eb..9fb7d05c61d 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateDerivativeImageFilterTest.cxx
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
index b9605b4cc69..d23e0d00d26 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/itkHigherOrderAccurateGradientImageFilterTest.cxx
@@ -6,7 +6,7 @@
  *  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
+ *         https://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,

From 3f2b04020c9ecc0f70fc80119317bbd2bcb30f4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?=
 <jon.haitz.legarreta@gmail.com>
Date: Fri, 23 Sep 2022 21:11:25 -0400
Subject: [PATCH 35/41] DOC: Fix module description

Fix module description: remove hanging sentence part.
---
 Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
index 86f64da228c..4d92b0e1818 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
+++ b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
@@ -3,7 +3,6 @@ set(
   DOCUMENTATION
   "This module contains a filter to compute higher order
 accurate numerical derivatives and gradients from an input scalar image.
-field from a displacement field image.
 Higher Order Accurate Derivative and Gradient Calculation in ITK
 https://www.insight-journal.org/browse/publication/775
 https://hdl.handle.net/10380/3231

From 7daf68fd478ae886c16bb1d843b754228f835111 Mon Sep 17 00:00:00 2001
From: "Hans J. Johnson" <hans-johnson@uiowa.edu>
Date: Wed, 22 Apr 2026 18:52:37 -0500
Subject: [PATCH 36/41] ENH: Convert from md5 to .cid tags.

---
 .../HigherOrderAccurateGradient/test/Input/foot.mha.cid          | 1 +
 .../HigherOrderAccurateGradient/test/Input/foot.mha.md5          | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.cid
 delete mode 100644 Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.cid b/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.cid
new file mode 100644
index 00000000000..cb03d7b09a1
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.cid
@@ -0,0 +1 @@
+bafkreicsnenkzoqwpvk5qscxqdmavlmfjmb3totuplgy6btdkiauwj5gma
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5 b/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5
deleted file mode 100644
index f724c8ba7a0..00000000000
--- a/Modules/Filtering/HigherOrderAccurateGradient/test/Input/foot.mha.md5
+++ /dev/null
@@ -1 +0,0 @@
-91bc3fa357c90c337dda72612c53a712
\ No newline at end of file

From 028109e441ccb064fba51f63aee34cb37c27ee34 Mon Sep 17 00:00:00 2001
From: "Hans J. Johnson" <hans-johnson@uiowa.edu>
Date: Fri, 8 May 2026 20:54:30 -0500
Subject: [PATCH 37/41] DOC: Add HigherOrderAccurateGradient README pointing at
 upstream

---
 .../HigherOrderAccurateGradient/README.md     | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Modules/Filtering/HigherOrderAccurateGradient/README.md

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/README.md b/Modules/Filtering/HigherOrderAccurateGradient/README.md
new file mode 100644
index 00000000000..98adbf9706b
--- /dev/null
+++ b/Modules/Filtering/HigherOrderAccurateGradient/README.md
@@ -0,0 +1,25 @@
+# HigherOrderAccurateGradient
+
+In-tree ITK module providing higher-order accurate numerical
+derivative and gradient image filters. The flagship classes
+`itk::HigherOrderAccurateDerivativeImageFilter`,
+`itk::HigherOrderAccurateDerivativeOperator`, and
+`itk::HigherOrderAccurateGradientImageFilter` compute centered finite
+differences of arbitrary even order on N-dimensional scalar images.
+
+## Origin
+
+Ingested from the standalone remote module
+[**InsightSoftwareConsortium/ITKHigherOrderAccurateGradient**](https://github.com/InsightSoftwareConsortium/ITKHigherOrderAccurateGradient)
+on 2026-05-08, following the v4 ingestion guidelines defined in
+InsightSoftwareConsortium/ITK#6204. The upstream repository will be
+archived read-only after this PR merges; it remains reachable at the
+URL above for historical reference (notably the `doc/` directory,
+which was intentionally left in the upstream archive).
+
+## References
+
+- McCormick M.M., Liu X., Jomier J., Marion C., Ibanez L.
+  *Higher Order Accurate Derivative and Gradient Calculation in ITK.*
+  The Insight Journal. January-December. 2014.
+  <https://hdl.handle.net/10380/3231>

From 380235784896a584953b3f619230fdb71e4ae335 Mon Sep 17 00:00:00 2001
From: "Hans J. Johnson" <hans-johnson@uiowa.edu>
Date: Fri, 8 May 2026 20:54:31 -0500
Subject: [PATCH 38/41] COMP: Remove HigherOrderAccurateGradient .remote.cmake
 (in-tree)

---
 .../HigherOrderAccurateGradient.remote.cmake  | 54 -------------------
 1 file changed, 54 deletions(-)
 delete mode 100644 Modules/Remote/HigherOrderAccurateGradient.remote.cmake

diff --git a/Modules/Remote/HigherOrderAccurateGradient.remote.cmake b/Modules/Remote/HigherOrderAccurateGradient.remote.cmake
deleted file mode 100644
index 9b101929e7a..00000000000
--- a/Modules/Remote/HigherOrderAccurateGradient.remote.cmake
+++ /dev/null
@@ -1,54 +0,0 @@
-#-- # Grading Level Criteria Report
-#-- EVALUATION DATE: 2020-03-01
-#-- EVALUATORS: [<<NO EVALUATOR>>,<<NO EVALUATOR>>]
-#--
-#-- ## Compliance level 5 star (AKA ITK main modules, or remote modules that could become core modules)
-#--   - [ ] Widespread community dependance
-#--   - [ ] Above 90% code coverage
-#--   - [ ] CI dashboards and testing monitored rigorously
-#--   - [ ] Key API features are exposed in wrapping interface
-#--   - [ ] All requirements of Levels 4,3,2,1
-#--
-#-- ## Compliance Level 4 star (Very high-quality code, perhaps small community dependance)
-#--   - [ ] Meets all ITK code style standards
-#--   - [ ] No external requirements beyond those needed by ITK proper
-#--   - [ ] Builds and passes tests on all supported platforms within 1 month of each core tagged release
-#--            - [ ] Windows Shared Library Build with Visual Studio
-#--            - [ ] Mac with clang compiller
-#--            - [ ] Linux with gcc compiler
-#--   - [ ] Active developer community dedicated to maintaining code-base
-#--   - [ ] 75% code coverage demonstrated for testing suite
-#--   - [ ] Continuous integration testing performed
-#--   - [ ] All requirements of Levels 3,2,1
-#--
-#-- ## Compliance Level 3 star (Quality beta code)
-#--   - [ ] API | executable interface is considered mostly stable and feature complete
-#--   - [ ] 10% C0-code coverage demonstrated for testing suite
-#--   - [ ] Some tests exist and pass on at least some platform
-#--   - [X] All requirements of Levels 2,1
-#--
-#-- ## Compliance Level 2 star (Alpha code feature API development or niche community/execution environment dependance )
-#--   - [X] Compiles for at least 1 niche set of execution envirionments, and perhaps others
-#--         (may depend on specific external tools like a java environment, or specific external libraries to work )
-#--   - [X] All requirements of Levels 1
-#--
-#-- ## Compliance Level 1 star (Pre-alpha features under development and code of unknown quality)
-#--   - [X] Code complies on at least 1 platform
-#--
-#-- ## Compliance Level 0 star ( Code/Feature of known poor-quality or deprecated status )
-#--   - [ ] Code reviewed and explicitly identified as not recommended for use
-#--
-#-- ### Please document here any justification for the criteria above
-#       Code style enforced by clang-format on 2020-02-19, and clang-tidy modernizations completed
-
-# Contact: Matt McCormick <matt.mccormick@kitware.com>
-itk_fetch_module(
-  HigherOrderAccurateGradient
-  "This module contains a filter to compute higher order
-  accurate numerical derivatives and gradients from an input scalar image.
-  Higher Order Accurate Derivative and Gradient Calculation in ITK
-  https://doi.org/10.54294/zv7979"
-  MODULE_COMPLIANCE_LEVEL 2
-  GIT_REPOSITORY https://github.com/InsightSoftwareConsortium/ITKHigherOrderAccurateGradient.git
-  GIT_TAG 7c074d12718a7de9e7219b2ce27415a590411e72
-  )

From 2deed6bd0aa48df639a54dccd81581e70eacda5c Mon Sep 17 00:00:00 2001
From: "Hans J. Johnson" <hans-johnson@uiowa.edu>
Date: Fri, 8 May 2026 20:55:00 -0500
Subject: [PATCH 39/41] ENH: Enable Module_HigherOrderAccurateGradient in
 configure-ci

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index 3f7fc02a387..4766f57dcf3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -58,6 +58,7 @@ cmd = '''cmake \
   -DModule_Montage:BOOL=ON \
   -DModule_FastBilateral:BOOL=ON \
   -DModule_GenericLabelInterpolator:BOOL=ON \
+  -DModule_HigherOrderAccurateGradient:BOOL=ON \
   -DModule_IOMeshSTL:BOOL=ON \
   -DModule_LabelErodeDilate:BOOL=ON \
   -DModule_MeshNoise:BOOL=ON \

From 8055fc7037936b4cb59163ab5fb5af49ca6386a3 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Sat, 9 May 2026 06:56:48 -0500
Subject: [PATCH 40/41] COMP: Inline static DESCRIPTION in itk-module.cmake

Replace the set(DOCUMENTATION "...") + DESCRIPTION "${DOCUMENTATION}"
indirection with a static one-liner literal.

itk_module() is a CMake macro, so ${ARGN} re-tokenizes its arguments
and list-splits any embedded ";". A future edit adding a semicolon or
"[" to the DOCUMENTATION string would silently produce spurious
"Unknown argument" AUTHOR_WARNINGs from CMake/ITKModuleMacros.cmake:111
on every configure (see PRs #6220, #6245).

The v4 ingestion pipeline (PR #6204) enforces this via
sanitize-history.py:patch_dynamic_description.
---
 .../HigherOrderAccurateGradient/itk-module.cmake    | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
index 4d92b0e1818..e048c143122 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
+++ b/Modules/Filtering/HigherOrderAccurateGradient/itk-module.cmake
@@ -1,14 +1,4 @@
 # Maintainer: Matt McCormick <matt.mccormick@kitware.com>
-set(
-  DOCUMENTATION
-  "This module contains a filter to compute higher order
-accurate numerical derivatives and gradients from an input scalar image.
-Higher Order Accurate Derivative and Gradient Calculation in ITK
-https://www.insight-journal.org/browse/publication/775
-https://hdl.handle.net/10380/3231
-"
-)
-
 itk_module(
   HigherOrderAccurateGradient
   DEPENDS
@@ -19,5 +9,6 @@ itk_module(
   TEST_DEPENDS
     ITKTestKernel
   EXCLUDE_FROM_DEFAULT
-  DESCRIPTION "${DOCUMENTATION}"
+  DESCRIPTION
+    "Filters that compute higher-order accurate numerical derivatives and gradients from a scalar image (Insight Journal: https://www.insight-journal.org/browse/publication/775, https://hdl.handle.net/10380/3231)."
 )

From b2712b1f6a8dd34858d62e2f59d5883aa39ec2d8 Mon Sep 17 00:00:00 2001
From: Hans Johnson <hans-johnson@uiowa.edu>
Date: Sat, 9 May 2026 09:26:24 -0500
Subject: [PATCH 41/41] STYLE: Address Greptile review on
 HigherOrderAccurateGradient

- Drop `== true` boolean comparisons (itkHigherOrderAccurateDerivativeImageFilter.hxx,
  itkHigherOrderAccurateGradientImageFilter.hxx).
- Collapse stray blank line between `Ctor()` signature and `= default;` in
  Derivative filter, GradientImageFilter ctor, and DerivativeOperator ctor.
- Document SetOrder() limitation: only `order == 1` is implemented;
  GenerateCoefficients() throws on any other value.
- Rename misnamed wrap file
  itkHigherOrderAccurateGradientmageFilter.wrap ->
  itkHigherOrderAccurateGradientImageFilter.wrap.
---
 .../include/itkHigherOrderAccurateDerivativeImageFilter.h | 4 +---
 .../itkHigherOrderAccurateDerivativeImageFilter.hxx       | 2 +-
 .../include/itkHigherOrderAccurateDerivativeOperator.h    | 8 ++++----
 .../include/itkHigherOrderAccurateDerivativeOperator.hxx  | 6 +++++-
 .../include/itkHigherOrderAccurateGradientImageFilter.hxx | 6 ++----
 ...rap => itkHigherOrderAccurateGradientImageFilter.wrap} | 0
 6 files changed, 13 insertions(+), 13 deletions(-)
 rename Modules/Filtering/HigherOrderAccurateGradient/wrapping/{itkHigherOrderAccurateGradientmageFilter.wrap => itkHigherOrderAccurateGradientImageFilter.wrap} (100%)

diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
index cddcfd15a5f..065bce56efa 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.h
@@ -115,9 +115,7 @@ class HigherOrderAccurateDerivativeImageFilter : public ImageToImageFilter<TInpu
   itkGetConstMacro(UseImageSpacing, bool);
 
 protected:
-  HigherOrderAccurateDerivativeImageFilter()
-
-    = default;
+  HigherOrderAccurateDerivativeImageFilter() = default;
 
   ~HigherOrderAccurateDerivativeImageFilter() override = default;
   void
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
index 987249d9821..a42b947a86e 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeImageFilter.hxx
@@ -99,7 +99,7 @@ HigherOrderAccurateDerivativeImageFilter<TInputImage, TOutputImage>::GenerateDat
   oper.CreateDirectional();
   oper.FlipAxes();
 
-  if (m_UseImageSpacing == true)
+  if (m_UseImageSpacing)
   {
     if (this->GetInput()->GetSpacing()[m_Direction] == 0.0)
     {
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
index 118a6cadac6..5a426f5798b 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.h
@@ -72,9 +72,7 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
   itkTypeMacro(HigherOrderAccurateDerivativeOperator, NeighborhoodOperator);
 
   /** Constructor. */
-  HigherOrderAccurateDerivativeOperator()
-
-    = default;
+  HigherOrderAccurateDerivativeOperator() = default;
 
   /** Copy constructor. */
   HigherOrderAccurateDerivativeOperator(const Self & other)
@@ -92,7 +90,9 @@ class HigherOrderAccurateDerivativeOperator : public NeighborhoodOperator<TPixel
     return *this;
   }
 
-  /** Sets the order of the derivative. */
+  /** Sets the order of the derivative. Only `order == 1` is currently
+   * implemented; any other value triggers a runtime exception in
+   * GenerateCoefficients(). */
   void
   SetOrder(const unsigned int & order)
   {
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
index 07f5760c89d..73ed9621e68 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateDerivativeOperator.hxx
@@ -41,7 +41,11 @@ template <typename TPixel, unsigned int VDimension, typename TAllocator>
 typename HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::CoefficientVector
 HigherOrderAccurateDerivativeOperator<TPixel, VDimension, TAllocator>::GenerateFirstOrderCoefficients()
 {
-  unsigned int      order = this->m_OrderOfAccuracy;
+  unsigned int order = this->m_OrderOfAccuracy;
+  if (order == 0)
+  {
+    itkExceptionMacro(<< "OrderOfAccuracy must be >= 1.");
+  }
   unsigned int      length = 2 * order + 1;
   CoefficientVector coeff(length);
 
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
index 9616d5270a3..f355e60da98 100644
--- a/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
+++ b/Modules/Filtering/HigherOrderAccurateGradient/include/itkHigherOrderAccurateGradientImageFilter.hxx
@@ -30,9 +30,7 @@ namespace itk
 
 template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
 HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputValueType>::
-  HigherOrderAccurateGradientImageFilter()
-
-  = default;
+  HigherOrderAccurateGradientImageFilter() = default;
 
 
 template <typename TInputImage, typename TOperatorValueType, typename TOutputValueType>
@@ -126,7 +124,7 @@ HigherOrderAccurateGradientImageFilter<TInputImage, TOperatorValueType, TOutputV
     op[i].FlipAxes();
 
     // Take into account the pixel spacing if necessary
-    if (m_UseImageSpacing == true)
+    if (m_UseImageSpacing)
     {
       if (this->GetInput()->GetSpacing()[i] == 0.0)
       {
diff --git a/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap b/Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientImageFilter.wrap
similarity index 100%
rename from Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientmageFilter.wrap
rename to Modules/Filtering/HigherOrderAccurateGradient/wrapping/itkHigherOrderAccurateGradientImageFilter.wrap