WIP: Tests for "streaming for resample image filter in case of linear transforms"

Modules/Filtering/ImageGrid/test/Baseline/ResampleImageTest2.mha.sha512

@@ -0,0 +1 @@
+6dcda44ce36e39fb6a792e26c8cd93830bab8edbe9f33385dc59b24bd6b40c99bbadf9b6ada967b1d1b6624e986f1161960d86db63b2d6b71da58eec0a2b911c

Modules/Filtering/ImageGrid/test/Baseline/ResampleImageTest2NearestExtrapolate.mha.sha512

@@ -0,0 +1 @@
+bbc1a32a82e88334df11c79f54ba4260ea291f8316c882d6360e7546739eb92109a169cc07abe32250a4e12e49a4bb8bad22c45580ccb78c4ee482fa68675e4f

Modules/Filtering/ImageGrid/test/CMakeLists.txt

@@ -45,10 +45,12 @@ itkWrapPadImageTest.cxx
 itkMirrorPadImageTest.cxx
 itkResampleImageTest.cxx
 itkResampleImageTest2.cxx
+itkResampleImageTest2s.cxx
 itkResampleImageTest3.cxx
 itkResampleImageTest4.cxx
 itkResampleImageTest5.cxx
 itkResampleImageTest6.cxx
+itkResampleImageTest7.cxx
 itkResamplePhasedArray3DSpecialCoordinatesImageTest.cxx
 itkPushPopTileImageFilterTest.cxx
 itkShrinkImageStreamingTest.cxx
@@ -223,6 +225,22 @@ itk_add_test(NAME itkResampleImageTest2
                           ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2b.png
                           ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2c.png
                           ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2d.png)
+itk_add_test(NAME itkResampleImageTest2s
+      COMMAND ITKImageGridTestDriver
+    --compare DATA{Baseline/ResampleImageTest2.mha}
+              ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2a.mha
+    --compare DATA{Baseline/ResampleImageTest2.mha}
+              ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2b.mha
+    --compare DATA{Baseline/ResampleImageTest2NearestExtrapolate.mha}
+              ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2c.mha
+    --compare DATA{Baseline/ResampleImageTest2NearestExtrapolate.mha}
+              ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2d.mha
+    itkResampleImageTest2s DATA{${ITK_DATA_ROOT}/Input/cthead1.png}
+                          DATA{${ITK_DATA_ROOT}/Input/circle.png}
+                          ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2a.mha
+                          ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2b.mha
+                          ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2c.mha
+                          ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest2d.mha)
 itk_add_test(NAME itkResampleImageTest3
       COMMAND ITKImageGridTestDriver
     --compare DATA{Baseline/ResampleImageTest3.png}
@@ -241,6 +259,8 @@ itk_add_test(NAME itkResampleImageTest6
     --compare DATA{Baseline/ResampleImageTest6.png}
               ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest6.png
     itkResampleImageTest6 10 ${ITK_TEST_OUTPUT_DIR}/ResampleImageTest6.png)
+itk_add_test(NAME itkResampleImageTest7
+      COMMAND ITKImageGridTestDriver itkResampleImageTest7)
 itk_add_test(NAME itkResamplePhasedArray3DSpecialCoordinatesImageTest
       COMMAND ITKImageGridTestDriver itkResamplePhasedArray3DSpecialCoordinatesImageTest)
 itk_add_test(NAME itkPushPopTileImageFilterTest

Modules/Filtering/ImageGrid/test/itkResampleImageTest2s.cxx

@@ -0,0 +1,267 @@
+/*=========================================================================
+ *
+ *  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 <iostream>
+
+#include "itkAffineTransform.h"
+#include "itkImageFileReader.h"
+#include "itkImageFileWriter.h"
+#include "itkResampleImageFilter.h"
+#include "itkNearestNeighborExtrapolateImageFunction.h"
+#include "itkPipelineMonitorImageFilter.h"
+#include "itkTestingMacros.h"
+
+/* Further testing of itkResampleImageFilter
+ * Output is compared with baseline image using the cmake itk_add_test
+ * '--compare' option.
+ */
+
+namespace {
+
+template<typename TCoordRepType, unsigned int NDimensions>
+class NonlinearAffineTransform:
+  public itk::AffineTransform<TCoordRepType,NDimensions>
+{
+public:
+  /** Standard class typedefs.   */
+  typedef NonlinearAffineTransform                           Self;
+  typedef itk::AffineTransform< TCoordRepType, NDimensions > Superclass;
+  typedef itk::SmartPointer< Self >                          Pointer;
+  typedef itk::SmartPointer< const Self >                    ConstPointer;
+
+  /** New macro for creation of through a smart pointer. */
+  itkSimpleNewMacro(Self);
+
+  /** Run-time type information (and related methods). */
+  itkTypeMacro(NonlinearAffineTransform, AffineTransform);
+
+  /** Override this. See test below. */
+    virtual bool IsLinear() const ITK_OVERRIDE { return false; }
+};
+}
+
+int itkResampleImageTest2s(int argc, char * argv [] )
+{
+
+  if( argc < 5 )
+    {
+    std::cerr << "Missing arguments ! " << std::endl;
+    std::cerr << "Usage : " << std::endl;
+    std::cerr << argv[0] << "inputImage referenceImage "
+              << "resampledImageLinear resampledImageNonLinear "
+              << "resampledImageLinearNearestExtrapolate"
+              << "resampledImageNonLinearNearestExtrapolate";
+    std::cerr << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  const unsigned int NDimensions = 2;
+
+  typedef unsigned char                          PixelType;
+  typedef itk::Image<PixelType, NDimensions>     ImageType;
+  typedef double                                 CoordRepType;
+
+  typedef itk::AffineTransform<CoordRepType,NDimensions>
+                                                 AffineTransformType;
+  typedef NonlinearAffineTransform<CoordRepType,NDimensions>
+                                                 NonlinearAffineTransformType;
+  typedef itk::LinearInterpolateImageFunction<ImageType,CoordRepType>
+                                                 InterpolatorType;
+  typedef itk::NearestNeighborExtrapolateImageFunction<ImageType,CoordRepType>
+                                                 ExtrapolatorType;
+
+  typedef itk::ImageFileReader< ImageType > ReaderType;
+  typedef itk::ImageFileWriter< ImageType > WriterType;
+
+  ReaderType::Pointer reader1 = ReaderType::New();
+  ReaderType::Pointer reader2 = ReaderType::New();
+  ReaderType::Pointer reader3 = ReaderType::New();
+  ReaderType::Pointer reader4 = ReaderType::New();
+
+  WriterType::Pointer writer1 = WriterType::New();
+  WriterType::Pointer writer2 = WriterType::New();
+  WriterType::Pointer writer3 = WriterType::New();
+  WriterType::Pointer writer4 = WriterType::New();
+
+  reader1->SetFileName( argv[1] );
+  reader2->SetFileName( argv[2] );
+  reader3->SetFileName( argv[3] );
+  reader4->SetFileName( argv[4] );
+
+  writer1->SetFileName( argv[3] );
+  writer2->SetFileName( argv[4] );
+  writer3->SetFileName( argv[5] );
+  writer4->SetFileName( argv[6] );
+
+  // Create an affine transformation
+  AffineTransformType::Pointer affineTransform = AffineTransformType::New();
+  affineTransform->Scale(2.0);
+
+  // Create a linear interpolation image function
+  InterpolatorType::Pointer interpolator = InterpolatorType::New();
+
+  // Create a nearest neighbor extrapolate image function
+  ExtrapolatorType::Pointer extrapolator = ExtrapolatorType::New();
+
+  // Create and configure a resampling filter
+  typedef itk::ResampleImageFilter< ImageType, ImageType > ResampleFilterType;
+
+  ResampleFilterType::Pointer resample = ResampleFilterType::New();
+
+  typedef itk::PipelineMonitorImageFilter< ImageType > MonitorFilter;
+
+  MonitorFilter::Pointer monitor = MonitorFilter::New();
+
+  EXERCISE_BASIC_OBJECT_METHODS( resample, ResampleImageFilter, ImageToImageFilter );
+
+  resample->SetInput( reader1->GetOutput() );
+  TEST_SET_GET_VALUE( reader1->GetOutput(), resample->GetInput() );
+
+  resample->SetReferenceImage( reader2->GetOutput() );
+  TEST_SET_GET_VALUE( reader2->GetOutput(), resample->GetReferenceImage() );
+
+  resample->UseReferenceImageOn();
+  TEST_EXPECT_TRUE( resample->GetUseReferenceImage() );
+
+  resample->SetTransform( affineTransform );
+  TEST_SET_GET_VALUE( affineTransform, resample->GetTransform() );
+
+  resample->SetInterpolator( interpolator );
+  TEST_SET_GET_VALUE( interpolator, resample->GetInterpolator() );
+
+  monitor->SetInput( resample->GetOutput() );
+  writer1->SetInput( monitor->GetOutput() );
+
+  // Check GetReferenceImage
+  if( resample->GetReferenceImage() != reader2->GetOutput() )
+    {
+    std::cerr << "GetReferenceImage() failed ! " << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Run the resampling filter with the normal, linear, affine transform.
+  // This will use ResampleImageFilter::LinearThreadedGenerateData().
+  std::cout << "Test with normal AffineTransform." << std::endl;
+  try
+    {
+    writer1->SetNumberOfStreamDivisions(8); //split into 8 pieces for streaming.
+    writer1->Update();
+    }
+  catch( itk::ExceptionObject & excp )
+    {
+    std::cerr << excp << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // this verifies that the pipeline was executed as expected along
+  // with correct region propagation and output information
+  if (!monitor->VerifyAllInputCanStream(8))
+    {
+    std::cout << "Streaming failed to execute as expected!" << std::endl;
+    std::cout << monitor;
+    return EXIT_FAILURE;
+    }
+
+  // Assign an affine transform that returns
+  // false for IsLinear() instead of true, to force
+  // the filter to use the NonlinearThreadedGenerateData method
+  // instead of LinearThreadedGenerateData. This will test that
+  // we get the same results for both methods.
+  std::cout << "Test with NonlinearAffineTransform." << std::endl;
+  NonlinearAffineTransformType::Pointer nonlinearAffineTransform =
+                                    NonlinearAffineTransformType::New();
+
+  nonlinearAffineTransform->Scale(2.0);
+  resample->SetTransform( nonlinearAffineTransform );
+  writer2->SetInput( resample->GetOutput() );
+  try
+    {
+    writer2->SetNumberOfStreamDivisions(8); //demand splitting into 8 pieces for streaming, but faked non-linearity will disable streaming
+    writer2->Update();
+    }
+  catch( itk::ExceptionObject & excp )
+    {
+    std::cerr << excp << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Instead of using the default pixel when sampling outside the input image,
+  // we use a nearest neighbor extrapolator.
+  resample->SetTransform( affineTransform );
+  resample->SetExtrapolator( extrapolator );
+  writer3->SetInput( resample->GetOutput() );
+  std::cout << "Test with nearest neighbor extrapolator, affine transform." << std::endl;
+  try
+    {
+    writer3->SetNumberOfStreamDivisions(8); //split into 8 pieces for streaming.
+    writer3->Update();
+    }
+  catch( itk::ExceptionObject & excp )
+    {
+    std::cerr << excp << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Instead of using the default pixel when sampling outside the input image,
+  // we use a nearest neighbor extrapolator.
+  resample->SetTransform( nonlinearAffineTransform );
+  writer4->SetInput( resample->GetOutput() );
+  std::cout << "Test with nearest neighbor extrapolator, nonlinear transform." << std::endl;
+  try
+    {
+    writer4->SetNumberOfStreamDivisions(8); //demand splitting into 8 pieces for streaming, but faked non-linearity will disable streaming
+    writer4->Update();
+    }
+  catch( itk::ExceptionObject & excp )
+    {
+    std::cerr << excp << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Check UseReferenceImage methods
+  resample->UseReferenceImageOff();
+  if( resample->GetUseReferenceImage() )
+    {
+    std::cerr << "GetUseReferenceImage() or UseReferenceImageOff() failed ! ";
+    std::cerr << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Check UseReferenceImage methods
+  resample->UseReferenceImageOn();
+  if( !resample->GetUseReferenceImage() )
+    {
+    std::cerr << "GetUseReferenceImage() or UseReferenceImageOn() failed ! ";
+    std::cerr << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Check UseReferenceImage methods
+  resample->SetUseReferenceImage( false );
+  if( resample->GetUseReferenceImage() )
+    {
+    std::cerr << "GetUseReferenceImage() or SetUseReferenceImage() failed ! ";
+    std::cerr << std::endl;
+    return EXIT_FAILURE;
+    }
+
+
+ std::cout << "Test passed." << std::endl;
+ return EXIT_SUCCESS;
+
+}