diff --git a/CMakeExternals/ITK-4.13.3.patch b/CMakeExternals/ITK-4.13.3.patch
new file mode 100644
index 0000000000..2c6e924e28
--- /dev/null
+++ b/CMakeExternals/ITK-4.13.3.patch
@@ -0,0 +1,39 @@
+diff --git a/Modules/Core/Common/include/itkBoundingBox.h b/Modules/Core/Common/include/itkBoundingBox.h
+index 36b03aaa7f..64205acfab 100644
+--- a/Modules/Core/Common/include/itkBoundingBox.h
++++ b/Modules/Core/Common/include/itkBoundingBox.h
+@@ -87,7 +87,7 @@ public:
+   itkTypeMacro(BoundingBox, Object);
+ 
+   /** Method for creation through the object factory. */
+-  itkNewMacro(Self);
++  itkFactorylessNewMacro(Self);
+ 
+   /** Hold on to the type information specified by the template parameters. */
+   typedef TPointIdentifier                       PointIdentifier;
+diff --git a/Modules/Core/Common/include/itkVectorContainer.h b/Modules/Core/Common/include/itkVectorContainer.h
+index 72293c4ce8..e6366c66b5 100644
+--- a/Modules/Core/Common/include/itkVectorContainer.h
++++ b/Modules/Core/Common/include/itkVectorContainer.h
+@@ -92,7 +92,7 @@ public:
+   typedef VectorType                     STLContainerType;
+ 
+   /** Method for creation through the object factory. */
+-  itkNewMacro(Self);
++  itkFactorylessNewMacro(Self);
+ 
+   /** Standard part of every itk Object. */
+   itkTypeMacro(VectorContainer, Object);
+diff --git a/Modules/Core/Transform/include/itkScalableAffineTransform.h b/Modules/Core/Transform/include/itkScalableAffineTransform.h
+index 4e830476a2..b5efeb95a4 100644
+--- a/Modules/Core/Transform/include/itkScalableAffineTransform.h
++++ b/Modules/Core/Transform/include/itkScalableAffineTransform.h
+@@ -47,7 +47,7 @@ public:
+   itkTypeMacro(ScalableAffineTransform, AffineTransform);
+ 
+   /** New macro for creation of through a Smart Pointer   */
+-  itkNewMacro(Self);
++  itkFactorylessNewMacro(Self);
+ 
+   /** Dimension of the domain space. */
+   itkStaticConstMacro(InputSpaceDimension, unsigned int, NDimensions);
diff --git a/CMakeExternals/ITK.cmake b/CMakeExternals/ITK.cmake
index 958f44c147..973e57229d 100644
--- a/CMakeExternals/ITK.cmake
+++ b/CMakeExternals/ITK.cmake
@@ -1,82 +1,84 @@
 #-----------------------------------------------------------------------------
 # ITK
 #-----------------------------------------------------------------------------
 
 # Sanity checks
 if(DEFINED ITK_DIR AND NOT EXISTS ${ITK_DIR})
   message(FATAL_ERROR "ITK_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj ITK)
 set(proj_DEPENDENCIES GDCM)
 
 if(MITK_USE_OpenCV)
   list(APPEND proj_DEPENDENCIES OpenCV)
 endif()
 
 if(MITK_USE_HDF5)
   list(APPEND proj_DEPENDENCIES HDF5)
 endif()
 
 set(ITK_DEPENDS ${proj})
 
 if(NOT DEFINED ITK_DIR)
 
   set(additional_cmake_args -DUSE_WRAP_ITK:BOOL=OFF)
 
   if(MITK_USE_OpenCV)
     list(APPEND additional_cmake_args
          -DModule_ITKVideoBridgeOpenCV:BOOL=ON
          -DOpenCV_DIR:PATH=${OpenCV_DIR}
         )
   endif()
 
   # Keep the behaviour of ITK 4.3 which by default turned on ITK Review
   # see MITK bug #17338
   list(APPEND additional_cmake_args
     -DModule_ITKReview:BOOL=ON
     -DModule_ITKOpenJPEG:BOOL=ON # for 4.7, the OpenJPEG is needed by review but the variable must be set
     -DModule_IsotropicWavelets:BOOL=ON
   )
 
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   mitk_query_custom_ep_vars()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      UPDATE_COMMAND ""
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/InsightToolkit-4.13.3.tar.gz
      URL_MD5 d1c10c8288b47577d718a71190444815
+     PATCH_COMMAND
+       ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/ITK-4.13.3.patch
      CMAKE_GENERATOR ${gen}
      CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        -DBUILD_EXAMPLES:BOOL=OFF
        -DITK_USE_SYSTEM_GDCM:BOOL=ON
        -DGDCM_DIR:PATH=${GDCM_DIR}
        -DITK_USE_SYSTEM_HDF5:BOOL=ON
        -DHDF5_DIR:PATH=${HDF5_DIR}
        ${${proj}_CUSTOM_CMAKE_ARGS}
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
        ${${proj}_CUSTOM_CMAKE_CACHE_ARGS}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
        ${${proj}_CUSTOM_CMAKE_CACHE_DEFAULT_ARGS}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(ITK_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp b/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp
index 8d354ca719..9794a91ce8 100644
--- a/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp
+++ b/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp
@@ -1,335 +1,335 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /*
 * mitkGeometryTransformHolder.cpp
 *
 *  Created on: Sep 3, 2014
 *      Author: wirkert
 */
 
 #include <cassert>
 #include <itkMatrix.h>
 #include <itkScalableAffineTransform.h>
 #include <itkSmartPointer.h>
 #include <mitkBaseGeometry.h>
 #include <mitkGeometryTransformHolder.h>
 #include <mitkMatrix.h>
 #include <mitkMatrixConvert.h>
 #include <mitkPoint.h>
 #include <mitkVector.h>
 #include <vnl/vnl_matrix_fixed.h>
 #include <vnl/vnl_vector.h>
 #include <vnl/vnl_vector_fixed.h>
 #include <vtkMatrix4x4.h>
 #include <vtkMatrixToLinearTransform.h>
 #include <vtkTransform.h>
 
 namespace mitk
 {
   void GeometryTransformHolder::CopySpacingFromTransform(const mitk::AffineTransform3D *transform,
                                                          mitk::Vector3D &spacing)
   {
     mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = transform->GetMatrix().GetVnlMatrix();
 
     spacing[0] = vnlmatrix.get_column(0).magnitude();
     spacing[1] = vnlmatrix.get_column(1).magnitude();
     spacing[2] = vnlmatrix.get_column(2).magnitude();
   }
 
   GeometryTransformHolder::GeometryTransformHolder()
   {
     m_VtkMatrix = vtkMatrix4x4::New();
     m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
     m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
     this->Initialize();
   }
 
   GeometryTransformHolder::GeometryTransformHolder(const GeometryTransformHolder &other)
   {
     m_VtkMatrix = vtkMatrix4x4::New();
     m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
     m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
     this->Initialize(&other);
   }
 
   GeometryTransformHolder::~GeometryTransformHolder()
   {
     m_VtkMatrix->Delete();
     m_VtkIndexToWorldTransform->Delete();
   }
 
   void GeometryTransformHolder::Initialize()
   {
     if (m_IndexToWorldTransform.IsNull())
       m_IndexToWorldTransform = TransformType::New();
     else
       m_IndexToWorldTransform->SetIdentity();
 
     m_VtkMatrix->Identity();
   }
 
   void GeometryTransformHolder::Initialize(const GeometryTransformHolder *other)
   {
     Initialize();
 
     if (other->GetIndexToWorldTransform())
     {
-      TransformType::Pointer indexToWorldTransform = other->GetIndexToWorldTransform()->Clone();
-      this->SetIndexToWorldTransform(indexToWorldTransform);
+      auto indexToWorldTransform = other->GetIndexToWorldTransform()->Clone();
+      this->SetIndexToWorldTransform(dynamic_cast<AffineTransform3D*>(indexToWorldTransform.GetPointer()));
     }
   }
 
   //##Documentation
   //## @brief Copy the ITK transform
   //## (m_IndexToWorldTransform) to the VTK transform
   //## \sa SetIndexToWorldTransform
   void GeometryTransformHolder::TransferItkToVtkTransform()
   {
     TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
   }
 
   //##Documentation
   //## @brief Copy the VTK transform
   //## to the ITK transform (m_IndexToWorldTransform)
   //## \sa SetIndexToWorldTransform
   void GeometryTransformHolder::TransferVtkToItkTransform()
   {
     TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
   }
 
   //##Documentation
   //## @brief Get the origin, e.g. the upper-left corner of the plane
   const Point3D GeometryTransformHolder::GetOrigin() const
   {
     mitk::Point3D origin = this->GetIndexToWorldTransform()->GetOffset();
     return origin;
   }
 
   //##Documentation
   //## @brief Set the origin, i.e. the upper-left corner of the plane
   //##
   void GeometryTransformHolder::SetOrigin(const Point3D &origin)
   {
     m_IndexToWorldTransform->SetOffset(origin.GetVectorFromOrigin());
     TransferItkToVtkTransform();
   }
 
   //##Documentation
   //## @brief Get the spacing (size of a pixel).
   //##
   const mitk::Vector3D GeometryTransformHolder::GetSpacing() const
   {
     mitk::Vector3D spacing;
     CopySpacingFromTransform(this->GetIndexToWorldTransform(), spacing);
     return spacing;
   }
 
   //##Documentation
   //## @brief Set the spacing.
   //##
   //##The spacing is also changed in the IndexToWorldTransform.
   void GeometryTransformHolder::SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing)
   {
     if (mitk::Equal(this->GetSpacing(), aSpacing) == false || enforceSetSpacing)
     {
       assert(aSpacing[0] > 0 && aSpacing[1] > 0 && aSpacing[2] > 0);
 
       AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
 
       vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
 
       mitk::VnlVector col;
       col = vnlmatrix.get_column(0);
       col.normalize();
       col *= aSpacing[0];
       vnlmatrix.set_column(0, col);
       col = vnlmatrix.get_column(1);
       col.normalize();
       col *= aSpacing[1];
       vnlmatrix.set_column(1, col);
       col = vnlmatrix.get_column(2);
       col.normalize();
       col *= aSpacing[2];
       vnlmatrix.set_column(2, col);
 
       Matrix3D matrix;
       matrix = vnlmatrix;
 
       AffineTransform3D::Pointer transform = AffineTransform3D::New();
       transform->SetMatrix(matrix);
       transform->SetOffset(m_IndexToWorldTransform->GetOffset());
 
       SetIndexToWorldTransform(transform.GetPointer());
     }
   }
 
   //##Documentation
   //## @brief Get the transformation used to convert from index
   //## to world coordinates
   mitk::AffineTransform3D *GeometryTransformHolder::GetIndexToWorldTransform() { return m_IndexToWorldTransform; }
   //##Documentation
   //## @brief Get the transformation used to convert from index
   //## to world coordinates
   const mitk::AffineTransform3D *GeometryTransformHolder::GetIndexToWorldTransform() const
   {
     return m_IndexToWorldTransform;
   }
 
   //## @brief Set the transformation used to convert from index
   //## to world coordinates. The spacing of the new transform is
   //## copied to m_spacing.
   void GeometryTransformHolder::SetIndexToWorldTransform(mitk::AffineTransform3D *transform)
   {
     m_IndexToWorldTransform = transform;
     TransferItkToVtkTransform();
   }
 
   //##Documentation
   //## @brief Convenience method for setting the ITK transform
   //## (m_IndexToWorldTransform) via an vtkMatrix4x4.The spacing of
   //## the new transform is copied to m_spacing.
   //## \sa SetIndexToWorldTransform
   void GeometryTransformHolder::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix)
   {
     m_VtkMatrix->DeepCopy(vtkmatrix);
     TransferVtkToItkTransform();
   }
 
   //## @brief Set the transformation used to convert from index
   //## to world coordinates.This function keeps the original spacing.
   void GeometryTransformHolder::SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform)
   {
     mitk::Vector3D originalSpacing = this->GetSpacing();
     this->SetIndexToWorldTransform(transform);
     this->SetSpacing(originalSpacing);
   }
 
   //##Documentation
   //## @brief Convenience method for setting the ITK transform
   //## (m_IndexToWorldTransform) via an vtkMatrix4x4. This function keeps the original spacing.
   //## \sa SetIndexToWorldTransform
   void GeometryTransformHolder::SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix)
   {
     mitk::Vector3D originalSpacing = this->GetSpacing();
     this->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
     this->SetSpacing(originalSpacing);
   }
 
   //## Get the Vtk Matrix which describes the transform.
   vtkMatrix4x4 *GeometryTransformHolder::GetVtkMatrix() { return m_VtkMatrix; }
   //## Get the Vtk Matrix which describes the transform.
   const vtkMatrix4x4 *GeometryTransformHolder::GetVtkMatrix() const { return m_VtkMatrix; }
   //##Documentation
   //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
   vtkLinearTransform *GeometryTransformHolder::GetVtkTransform() const
   {
     return (vtkLinearTransform *)m_VtkIndexToWorldTransform;
   }
 
   void GeometryTransformHolder::SetMatrix(Matrix3D &matrix)
   {
     m_IndexToWorldTransform->SetMatrix(matrix);
     TransferItkToVtkTransform();
   }
 
   void GeometryTransformHolder::SetIdentity()
   {
     m_IndexToWorldTransform->SetIdentity();
     TransferItkToVtkTransform();
   }
 
   void GeometryTransformHolder::Compose(const TransformType *other, bool pre)
   {
     m_IndexToWorldTransform->Compose(other, pre);
     TransferItkToVtkTransform();
   }
 
   void GeometryTransformHolder::SetVtkMatrixDeepCopy(vtkTransform *vtktransform)
   {
     m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
     TransferVtkToItkTransform();
   }
 
   bool GeometryTransformHolder::IsIndexToWorldTransformNull() { return m_IndexToWorldTransform.IsNull(); }
   AffineTransform3D::MatrixType::InternalMatrixType GeometryTransformHolder::GetVnlMatrix()
   {
     return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
   }
 }
 
 bool mitk::Equal(const mitk::GeometryTransformHolder *leftHandSide,
                  const mitk::GeometryTransformHolder *rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   if ((leftHandSide == nullptr) || (rightHandSide == nullptr))
   {
     MITK_ERROR << "mitk::Equal(const mitk::Geometry3D *leftHandSide, const mitk::Geometry3D *rightHandSide, ScalarType "
                   "eps, bool verbose) does not with nullptr pointer input.";
     return false;
   }
   return Equal(*leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::GeometryTransformHolder &leftHandSide,
                  const mitk::GeometryTransformHolder &rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   bool result = true;
 
   // Compare spacings
   if (!mitk::Equal(leftHandSide.GetSpacing(), rightHandSide.GetSpacing(), eps))
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D )] Spacing differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetSpacing() << " : leftHandSide is "
                 << leftHandSide.GetSpacing() << " and tolerance is " << eps;
     }
     result = false;
   }
 
   // Compare Origins
   if (!mitk::Equal(leftHandSide.GetOrigin(), rightHandSide.GetOrigin(), eps))
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D )] Origin differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetOrigin() << " : leftHandSide is "
                 << leftHandSide.GetOrigin() << " and tolerance is " << eps;
     }
     result = false;
   }
 
   // Compare IndexToWorldTransform Matrix
   if (!mitk::Equal(*leftHandSide.GetIndexToWorldTransform(), *rightHandSide.GetIndexToWorldTransform(), eps, verbose))
   {
     result = false;
   }
 
   // Compare vtk Matrix
   for (int i = 0; i < 4; i++)
   {
     for (int j = 0; j < 4; j++)
     {
       if (leftHandSide.GetVtkMatrix()->GetElement(i, j) != rightHandSide.GetVtkMatrix()->GetElement(i, j))
       {
         result = false;
       }
     }
   }
 
   return result;
 }