From 86b10d02b0a033496c9ed0d68c38092dfa2e1c72 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:33:46 -0400 Subject: [PATCH 01/76] ENH: Initial commit. Initial import from http://hdl.handle.net/10380/3505 http://insight-journal.org/browse/publication/953 Add missing LICENSE file. Test data is uploaded to midas3.kitware.com and content links are added instead. --- .../AnisotropicDiffusionLBR/CMakeLists.txt | 2 + .../AnisotropicDiffusionLBR/itk-module.cmake | 20 + .../src/CMakeLists.txt | 12 + .../src/CoherenceEnhancingDiffusion.cxx | 16 + .../AnisotropicDiffusionLBRImageFilter.h | 110 +++++ .../AnisotropicDiffusionLBRImageFilter.hxx | 118 +++++ .../src/Headers/CMakeLists.txt | 17 + .../CoherenceEnhancingDiffusionCommandLine.h | 210 +++++++++ .../CoherenceEnhancingDiffusionFilter.h | 120 +++++ .../LinearAnisotropicDiffusionCommandLine.h | 196 ++++++++ ...LinearAnisotropicDiffusionLBRImageFilter.h | 145 ++++++ ...nearAnisotropicDiffusionLBRImageFilter.hxx | 432 ++++++++++++++++++ .../src/Headers/Macro.h | 21 + .../src/Headers/StructureTensorImageFilter.h | 91 ++++ .../Headers/StructureTensorImageFilter.hxx | 157 +++++++ .../UnaryFunctorWithIndexImageFilter.h | 66 +++ .../test/Baseline/Cos3D_cCED.vtk.md5 | 1 + .../test/Baseline/FingerPrint_I_20.png.md5 | 1 + .../test/Baseline/FingerPrint_cCED_20.png.md5 | 1 + .../test/Baseline/FingerPrint_cEED_20.png.md5 | 1 + .../test/Baseline/Lena_Detail_I_2.png.md5 | 1 + .../test/Baseline/Lena_Detail_cCED_2.png.md5 | 1 + .../test/Baseline/Lena_Detail_cEED_2.png.md5 | 1 + .../test/Baseline/Oscillations1_CED.png.md5 | 1 + .../test/Baseline/Oscillations1_cCED.png.md5 | 1 + .../test/Baseline/PacMan_I.png.md5 | 1 + .../test/Baseline/PacMan_cCED.png.md5 | 1 + .../test/Baseline/PacMan_cEED.png.md5 | 1 + .../test/Baseline/Triangle_EED.png.md5 | 1 + .../test/Baseline/Triangle_cEED.png.md5 | 1 + .../Baseline/VectorField_Circle_cEED.vtk.md5 | 1 + .../test/Baseline/mrbrain_cEED.vtk.md5 | 1 + .../test/CMakeLists.txt | 99 ++++ .../test/CoherenceEnhancingDiffusionTest.cxx | 26 ++ .../test/Input/Cos3D_Noisy.vtk.md5 | 1 + .../test/Input/FingerPrint.png.md5 | 1 + .../test/Input/Lena_Detail.png.md5 | 1 + .../test/Input/Oscillations_Noisy1.png.md5 | 1 + .../test/Input/PacMan.png.md5 | 1 + .../test/Input/Triangle.png.md5 | 1 + .../Input/VectorField_CircleOpposites.vtk.md5 | 1 + .../test/Input/mrbrain_noisy.vtk.md5 | 1 + 42 files changed, 1882 insertions(+) create mode 100755 Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt create mode 100755 Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake create mode 100755 Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt create mode 100755 Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.hxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CMakeLists.txt create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionCommandLine.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionCommandLine.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.hxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/Macro.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.hxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/UnaryFunctorWithIndexImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Cos3D_cCED.vtk.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_I_20.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cCED_20.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cEED_20.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_I_2.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cCED_2.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cEED_2.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_CED.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_cCED.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_I.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cCED.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cEED.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_EED.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_cEED.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/VectorField_Circle_cEED.vtk.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/mrbrain_cEED.vtk.md5 create mode 100755 Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt create mode 100755 Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Cos3D_Noisy.vtk.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/FingerPrint.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Lena_Detail.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Oscillations_Noisy1.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/PacMan.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Triangle.png.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/VectorField_CircleOpposites.vtk.md5 create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/Input/mrbrain_noisy.vtk.md5 diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt new file mode 100755 index 00000000000..33be936e6db --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -0,0 +1,2 @@ +project(ITKAnisotropicDiffusionLBR) +itk_module_impl() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake new file mode 100755 index 00000000000..fbd0af242ea --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake @@ -0,0 +1,20 @@ +set(DOCUMENTATION "This module implements Anisotropic Diffusion, using Lattice Basis Reduction.") + +# itk_module() defines the module dependencies in ITKAnisotropicFastMarchingLBR; +# ITKAnisotropicFastMarchingLBR depends on ITKCommon; +# The testing module in ITKExternalTemplate depends on ITKTestKernel, +# and ITKMetaIO for image IO (besides ITKAnisotropicDiffusionLBR itself) + +itk_module(ITKAnisotropicDiffusionLBR + DEPENDS + ITKCommon + ITKIOImageBase + ITKIOSpatialObjects + ITKMetaIO + ITKImageGradient + TEST_DEPENDS + ITKTestKernel + EXCLUDE_FROM_DEFAULT + DESCRIPTION + "${DOCUMENTATION}" +) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt new file mode 100755 index 00000000000..ac23e504ec4 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt @@ -0,0 +1,12 @@ +add_subdirectory("Headers") + +include_directories(${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + +set(${itk-module}_SRC +CoherenceEnhancingDiffusion.cxx +) + +add_library(${itk-module} ${${itk-module}_SRC} ${ADLBR_Headers}) + +target_link_libraries(${itk-module} ${${itk-module}_LIBRARIES}) +itk_module_target(${itk-module}) \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx new file mode 100755 index 00000000000..ab6654323c1 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx @@ -0,0 +1,16 @@ +#include +#include +#include "CoherenceEnhancingDiffusionCommandLine.h" + +int main(int argc, char **argv) +{ + try { + CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); + } catch (itk::ExceptionObject& e) { + std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; + return EXIT_FAILURE; + } + return EXIT_SUCCESS; +} + + diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.h new file mode 100644 index 00000000000..ad663abf85f --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.h @@ -0,0 +1,110 @@ +// +// AnisotropicDiffusionLBRImageFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkDiffusion_AnisotropicDiffusionLBRImageFilter_h +#define itkDiffusion_AnisotropicDiffusionLBRImageFilter_h + +#include "LinearAnisotropicDiffusionLBRImageFilter.h" +#include "StructureTensorImageFilter.h" +//#include "itkVectorMagnitudeImageFilter.h" +//#include "itkRescaleIntensityImageFilter.h" + +namespace itk +{ + /** Implementation of Non-linear Anisotropic Diffusion. + This class repeatedly calls the LinearAnisotropicDiffusionLBRImageFilter, with non-linear diffusion tensors built on the fly. These tensors are obtained by computing the image structure tensors, and appropriately modifying their eigenvalues with the method EigenValuesTransform. The latter method is not implemented, and needs to be provided in a subclass, such as CoherenceEnhancingDiffusionFilter.h + */ + template + class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage> + { + public: + typedef AnisotropicDiffusionLBRImageFilter Self; + typedef ImageToImageFilter< TImage, TImage> Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(AnisotropicDiffusionLBRImageFilter, Superclass); + + typedef TImage ImageType; + static const unsigned int Dimension = ImageType::ImageDimension; + + typedef typename ImageType::PixelType PixelType; + typedef TScalar ScalarType; + + typedef SymmetricSecondRankTensor TensorType; + typedef Image TensorImageType; + + typedef StructureTensorImageFilter StructureTensorFilterType; + typedef LinearAnisotropicDiffusionLBRImageFilter LinearDiffusionFilterType; + + + itkSetMacro(NoiseScale, ScalarType); /// Passed to a StructureTensorImageFilter. + itkGetConstMacro(NoiseScale, ScalarType); + itkSetMacro(FeatureScale, ScalarType); /// Passed to a StructureTensorImageFilter. + itkGetConstMacro(FeatureScale, ScalarType); + + itkSetMacro(RatioToMaxStableTimeStep, ScalarType); /// Passed to a LinearAnisotropicDiffusion Filter. + itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); + itkSetMacro(MaxTimeStepsBetweenTensorUpdates, int); + itkGetConstMacro(MaxTimeStepsBetweenTensorUpdates, int); + + itkSetMacro(DiffusionTime, ScalarType); + itkGetConstMacro(DiffusionTime, ScalarType); + + ///If true, uses unit pixel spacing, and rescales structure tensors for uni maximum trace.. + itkSetMacro(Adimensionize, bool); + itkGetConstMacro(Adimensionize, bool); + + + typedef typename TensorType::EigenValuesArrayType EigenValuesArrayType; + /// Transformation of the Structure tensor eigenvalues into the diffusion tensor eigenvalues. Needs to be overloaded in a subclass. (Structure tensor eigenvalues are sorted by increasing order for convenience). + virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const + {itkExceptionMacro("Undefined tensor eigenvalues transform");}; + + virtual typename TensorImageType::Pointer GetLastTensorImage(){return tensorImage;} + typedef std::vector< std::pair > EffectiveTimesAndIterationsType; + itkGetConstReferenceMacro(LinearFilterEffectiveTimesAndIterations, EffectiveTimesAndIterationsType); + + protected: + ScalarType m_NoiseScale, m_FeatureScale; + + ScalarType m_RatioToMaxStableTimeStep; + int m_MaxTimeStepsBetweenTensorUpdates; + + AnisotropicDiffusionLBRImageFilter(){ + m_DiffusionTime=1; + m_Adimensionize=true; + + m_NoiseScale=0.5; + m_FeatureScale=2; + + m_RatioToMaxStableTimeStep=0.7; + m_MaxTimeStepsBetweenTensorUpdates=5; + }; + ~AnisotropicDiffusionLBRImageFilter(){}; + + typename TensorImageType::Pointer tensorImage; + virtual void ComputeDiffusionTensors(ImageType*); + + + ScalarType m_DiffusionTime; + bool m_Adimensionize; + + virtual void GenerateData(); + + EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; + + struct DiffusionTensorFunctor; + }; +} + +#include "AnisotropicDiffusionLBRImageFilter.hxx" +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.hxx new file mode 100644 index 00000000000..dd7f6c07125 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.hxx @@ -0,0 +1,118 @@ +// +// AnisotropicDiffusionLBRImageFilter.hxx +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkDiffusion_AnisotropicDiffusionLBRImageFilter_hxx +#define itkDiffusion_AnisotropicDiffusionLBRImageFilter_hxx + +namespace itk { + + template + void AnisotropicDiffusionLBRImageFilter::GenerateData(){ + typename ImageType::Pointer inputImage=const_cast(this->GetInput()); + typename ImageType::Pointer image = inputImage; + + typedef typename ImageType::SpacingType SpacingType; + const SpacingType referenceSpacing = inputImage->GetSpacing(); + + // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. + double minSpacing = referenceSpacing[0]; + for(int i=1; i<(int)Dimension; ++i) minSpacing = std::min(minSpacing,referenceSpacing[i]); + const SpacingType unitSpacing = referenceSpacing/minSpacing; + + if(m_Adimensionize) inputImage->SetSpacing(unitSpacing); + + ScalarType remainingTime = m_DiffusionTime; + + while(remainingTime>0){ + ComputeDiffusionTensors(image); + typename LinearDiffusionFilterType::Pointer linearDiffusionFilter = LinearDiffusionFilterType::New(); + linearDiffusionFilter->SetMaxNumberOfTimeSteps(m_MaxTimeStepsBetweenTensorUpdates); + linearDiffusionFilter->SetRatioToMaxStableTimeStep(m_RatioToMaxStableTimeStep); + + linearDiffusionFilter->SetInputImage(image); + linearDiffusionFilter->SetInputTensor(tensorImage); + linearDiffusionFilter->SetMaxDiffusionTime(remainingTime); + linearDiffusionFilter->Update(); + image = linearDiffusionFilter->GetOutput(); + remainingTime -= linearDiffusionFilter->GetEffectiveDiffusionTime(); + + m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair(linearDiffusionFilter->GetEffectiveDiffusionTime(),linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); + + this->UpdateProgress(1.-remainingTime/m_DiffusionTime); + } + + if(m_Adimensionize) { + inputImage->SetSpacing(referenceSpacing); + image->SetSpacing(referenceSpacing); + } + this->GraftOutput(image); + } + + + + template + struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor { + Self * eigenValuesFunctor; + struct OrderingType; + TensorType operator()(const TensorType & S){ + EigenValuesArrayType eigenValues; + typename TensorType::EigenVectorsMatrixType eigenVectors; + S.ComputeEigenAnalysis(eigenValues,eigenVectors); + + // For convenience, eigenvalues are sorted by increasing order + Vector order; + for(int i=0; i<(int)Dimension; ++i) order[i]=i; + + OrderingType ordering(eigenValues); + + std::sort(order.Begin(), order.End(),ordering); + + std::sort(eigenValues.Begin(), eigenValues.End()); + EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); + + TensorType DiffusionTensor; + for(int i=0; i<(int)Dimension; ++i){ + DiffusionTensor(order[i],order[i]) = ev[i]; + for(int j=0; jbool {return eigenValues[i] + struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor::OrderingType { + bool operator()(int i, int j) const {return this->e[i]e[j];} + const EigenValuesArrayType & e; + OrderingType(const EigenValuesArrayType & e_):e(e_){}; + }; + + template + void AnisotropicDiffusionLBRImageFilter::ComputeDiffusionTensors(ImageType*image){ + typename StructureTensorFilterType::Pointer structureTensorFilter = StructureTensorFilterType::New(); + + structureTensorFilter->SetNoiseScale(m_NoiseScale); + structureTensorFilter->SetFeatureScale(m_FeatureScale); + structureTensorFilter->SetRescaleForUnitMaximumTrace(m_Adimensionize); + structureTensorFilter->SetInput(image); + + typedef UnaryFunctorImageFilter ImageFunctorType; + typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); + imageFunctor->GetFunctor().eigenValuesFunctor = this; + imageFunctor->SetInput(structureTensorFilter->GetOutput()); + + imageFunctor->Update(); + tensorImage=imageFunctor->GetOutput(); + } + +} + + + + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CMakeLists.txt new file mode 100644 index 00000000000..61ade0b69e0 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CMakeLists.txt @@ -0,0 +1,17 @@ +set(ADLBR_Headers + ${CMAKE_CURRENT_SOURCE_DIR}/AnisotropicDiffusionLBRImageFilter.h + ${CMAKE_CURRENT_SOURCE_DIR}/AnisotropicDiffusionLBRImageFilter.hxx + ${CMAKE_CURRENT_SOURCE_DIR}/LinearAnisotropicDiffusionLBRImageFilter.h + ${CMAKE_CURRENT_SOURCE_DIR}/LinearAnisotropicDiffusionLBRImageFilter.hxx + ${CMAKE_CURRENT_SOURCE_DIR}/StructureTensorImageFilter.h + ${CMAKE_CURRENT_SOURCE_DIR}/StructureTensorImageFilter.hxx + ${CMAKE_CURRENT_SOURCE_DIR}/CoherenceEnhancingDiffusionFilter.h + ${CMAKE_CURRENT_SOURCE_DIR}/LinearAnisotropicDiffusionCommandLine.h + ${CMAKE_CURRENT_SOURCE_DIR}/CoherenceEnhancingDiffusionCommandLine.h + ${CMAKE_CURRENT_SOURCE_DIR}/UnaryFunctorWithIndexImageFilter.h + ${CMAKE_CURRENT_SOURCE_DIR}/Macro.h + PARENT_SCOPE +) + +set(PROJECT_DIR ${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR} PARENT_SCOPE) + diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionCommandLine.h new file mode 100644 index 00000000000..4c71fa8e339 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionCommandLine.h @@ -0,0 +1,210 @@ +// +// CoherenceEnhancingDiffusionCommandLine.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 20/11/2014. +// +// + +#ifndef itkDiffusion_CoherenceEnhancingDiffusionCommandLine_h +#define itkDiffusion_CoherenceEnhancingDiffusionCommandLine_h + +#include "itkImageFileReader.h" +#include "itkImageFileWriter.h" +#include "CoherenceEnhancingDiffusionFilter.h" +#include "LinearAnisotropicDiffusionCommandLine.h" + +namespace CoherenceEnhancingDiffusionCommandLine { + + void Usage(){ + std::cerr << + "Input image filename. 2D and 3D images supported. Required.\n" << + "Output image filename. Required.\n" << + "Diffusion time. Suggested range: 0.5-5, up to 50 for strong noise. Default: 2.\n" << + "Lambda. Small values detect more edges. Suggested range: 0.05, 0.0001. Default: 0.01\n" << + "Weickert diffusion type. Accepted values: Edge, Coherence. Default: Edge.\n" << + "Noise scale. Suggested range: 0.5 - 4. Default 1.\n" << + "Feature scale. Suggested range: 2-6. Default 2.\n" + << "\n"; + } + + using namespace itk; + + int Execute(int argc, char * argv[]); + + template + int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); + + template + int Execute(int argc, char * argv[], int nComponents); + + template + int Execute(int argc, char * argv[]); + + + typedef LinearAnisotropicDiffusionCommandLine::ReportProgressToCErrType ReportProgressToCErrType; + +int Execute(int argc, char * argv[]) +{ + using std::cerr; + using std::endl; + using namespace itk; + + if(argc<2+1) {Usage(); return EXIT_SUCCESS ;} + + const char *ImageFileName =argv[0+1]; + typedef ImageFileReader > ReaderType; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(ImageFileName); + + reader->UpdateOutputInformation(); + + const ImageIOBase * io = reader->GetImageIO(); + const int ImageDimension = io->GetNumberOfDimensions(); + const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); + const int nComponents = io->GetNumberOfComponents(); + + switch (ImageDimension) { + case 2: return Execute<2>(argc,argv,componentType,nComponents); + case 3: return Execute<3>(argc,argv,componentType,nComponents); + default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); + } +} + +template +int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents){ + switch (componentType) { + case itk::ImageIOBase::UCHAR: return Execute(argc,argv,nComponents); + case itk::ImageIOBase::FLOAT: return Execute(argc,argv,nComponents); + case itk::ImageIOBase::DOUBLE:return Execute(argc,argv,nComponents); + default: itkGenericExceptionMacro("Sorry, unsupported component type"); + } +} + +template +int Execute(int argc, char * argv[], int nComponents){ + switch (nComponents) { + case 1: return Execute(argc,argv); + case 2: return Execute,Vector >(argc,argv); + case 3: return Execute,Vector >(argc,argv); + default: itkGenericExceptionMacro("Sorry, unsupported number of components"); + } +} + +template +int Execute(int argc, char * argv[]){ + + typedef Image ImageType; + + typedef ImageFileReader ReaderType; + typename ReaderType::Pointer reader = ReaderType::New(); + + const char *imageFileName =argv[0+1]; + const char *outputFileName =argv[1+1]; + reader->SetFileName(imageFileName); + + /*{ + reader->Update(); + auto image = reader->GetOutput(); + std::cerr << image->GetRequestedRegion() << "\n\n"; + std::cerr << image->GetRequestedRegion() << "\n\n"; + }*/ + + typedef CoherenceEnhancingDiffusionFilter DiffusionFilterType; + typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); + diffusionFilter->SetInput(reader->GetOutput()); + + ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); + diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); + + int argIndex = 3; + if(argIndexSetDiffusionTime(diffusionTime); + } + + if(argIndexSetLambda(lambda); + } + + if(argIndexSetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. + else if(!strcmp(enhancement,"cEED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. + else if(!strcmp(enhancement,"CED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. + else if(!strcmp(enhancement, "cCED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. + else if(!strcmp(enhancement, "Isotropic")) + diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); //Perona-Mali's exponent: 2. + else + itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); + } + + if(argIndexSetNoiseScale(noiseScale); + } + + if(argIndexSetFeatureScale(featureScale); + } + + if(argIndexSetExponent(exponent); + } + + if(argIndexGetDiffusionTime() << "\n" << + "Lambda: " << diffusionFilter->GetLambda() << "\n" << + "argc: " << argc << "\n"; + + diffusionFilter->Update(); + auto image = diffusionFilter->GetOutput(); + std::cerr << + image->GetBufferedRegion() << "\n\n" << + "pixel export size: " << sizeof(ExportPixelType) << "\n"; + ; + + }*/ + + + typedef Image ExportImageType; + typedef CastImageFilter CasterType; + typename CasterType::Pointer caster = CasterType::New(); + caster->SetInput(diffusionFilter->GetOutput()); + + //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; + typedef ImageFileWriter WriterType; + typename WriterType::Pointer writer = WriterType::New(); + writer->SetInput(caster->GetOutput()); + writer->SetFileName(outputFileName); + + clock_t top=-clock(); + writer->Update(); + top+=clock(); std::cout << "Took : " << top/double(CLOCKS_PER_SEC) << "s\n"; + + return EXIT_SUCCESS; +} + + + +} + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionFilter.h new file mode 100644 index 00000000000..11e99e2f4a1 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionFilter.h @@ -0,0 +1,120 @@ +// +// CoherenceEnhancingDiffusionFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 06/03/2014. +// +// + +#ifndef itkDiffusion_CoherenceEnhancingDiffusionFilter_h +#define itkDiffusion_CoherenceEnhancingDiffusionFilter_h + +#include "AnisotropicDiffusionLBRImageFilter.h" + + +namespace itk { +/** + Implementation of Coherence Enhancing Diffusion (CED), and Edge Enhancing Diffusion (EED), as described by Weickert. CED heuristically smoothes everywhere except accross image contours, while EED smoothes nowhere but tangentially to image contours. + + The non-linear diffusion tensor is defined in terms of the structure tensor. + Denote by \f$\mu_i\f$ the structure tensor eigenvalues, at a given point \f$x\f$, with \f$0\leq i < d\f$. Let also \f$\mu_{\rm min}\f$ and \f$\mu_{\rm max}\f$, be the smallest and largest eigenvalues respectively. The diffusion tensor is defined by the same eigenvectors, but with modified with eigenvalues \f$\lambda_i\f$. + + Coherence Enhancing Diffusion : \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$.\br + + Edge enhancing diffusion \f$\lambda_i := g(\mu_{\rm max} - \mu_i)\f$, where \f$g(s) = \alpha + (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = \alpha\f$, \f$g(\infty) = 1\f$. + */ + template + class CoherenceEnhancingDiffusionFilter : public AnisotropicDiffusionLBRImageFilter { + public: + typedef CoherenceEnhancingDiffusionFilter Self; + typedef AnisotropicDiffusionLBRImageFilter Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(CoherenceEnhancingDiffusionFilter, Superclass); + + typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; + virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const; + + typedef typename Superclass::ScalarType ScalarType; + /// Exponent m involved in the function g defining eigenvalues. + itkSetMacro(Exponent, ScalarType); + itkSetMacro(Lambda, ScalarType); + itkSetMacro(Alpha, ScalarType); + + itkGetMacro(Exponent, ScalarType); + itkGetMacro(Lambda, ScalarType); + itkGetMacro(Alpha, ScalarType); + + enum EnhancementType {CED, cCED, EED, cEED, Isotropic}; + /// Switch between CED, EED, and variants. + itkSetEnumMacro(Enhancement, EnhancementType); + itkGetEnumMacro(Enhancement, EnhancementType); + + protected: + ScalarType m_Lambda; + ScalarType m_Exponent; + ScalarType m_Alpha; + EnhancementType m_Enhancement; + + ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} + ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} + + CoherenceEnhancingDiffusionFilter(){ + m_Lambda = 0.05; + m_Exponent = 2; + m_Alpha = 0.01; + m_Enhancement = CED; + } + }; + + template + typename CoherenceEnhancingDiffusionFilter::EigenValuesArrayType + CoherenceEnhancingDiffusionFilter::EigenValuesTransform(const EigenValuesArrayType & ev0) const { + static const int Dimension = Superclass::Dimension; + const ScalarType evMin = ev0[0], evMax = ev0[Dimension-1]; + EigenValuesArrayType ev; + switch(m_Enhancement){ + + // Weickert's filter. + case CED: + for(int i=0; i +int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); + +template +int Execute(int argc, char * argv[], int nComponents); + +template +int Execute(int argc, char * argv[]); + + +struct ReportProgressToCErrType : public itk::Command +{ + itkNewMacro(ReportProgressToCErrType); + void Execute(itk::Object *caller, const itk::EventObject & event){ + Execute( (const itk::Object *)caller, event); + } + + void Execute(const itk::Object * object, const itk::EventObject &){ + std::cout << object->GetNameOfClass() << " has completed: " + << int(100*dynamic_cast(object)->GetProgress()) + << "%" << std::endl; + } +}; + + +int Execute(int argc, char * argv[]) +{ + using std::cerr; + using std::endl; + using namespace itk; + + if(argc<4+1) {Usage(); return EXIT_SUCCESS ;} + + const char *imageFileName =argv[0+1]; + typedef ImageFileReader > ReaderType; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(imageFileName); + + reader->UpdateOutputInformation(); + + const ImageIOBase * io = reader->GetImageIO(); + const int ImageDimension = io->GetNumberOfDimensions(); + const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); + const int nComponents = io->GetNumberOfComponents(); + + { + const char *tensorFileName = argv[1+1]; + ReaderType::Pointer reader2 = ReaderType::New(); + reader2->SetFileName(tensorFileName); + reader2->UpdateOutputInformation(); + const ImageIOBase * io2 = reader2->GetImageIO(); + if(io2->GetComponentType() != componentType) + std::cerr << "Warning: image and tensors have distinct component types.\n"; + if(ImageDimension != (int)io2->GetNumberOfDimensions()) + itkGenericExceptionMacro("Error: image and tensor image have distinct dimension"); + const int TensorDimension = (ImageDimension*(ImageDimension+1))/2; + if(TensorDimension != (int)io2->GetNumberOfComponents()) + itkGenericExceptionMacro("Error: wrong tensor dimension, should be n*(n+1)/2 where n=ImageDimension."); + if(io2->GetPixelType() == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR) + std::cerr << "Warning: tensor image pixel type not marked as Symmetric Second Rank Tensor.\n"; + } + + switch (ImageDimension) { + case 2: return Execute<2>(argc,argv,componentType,nComponents); +// case 3: return Execute<3>(argc,argv,componentType,nComponents); + default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); + } +} + +template +int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents){ + switch (componentType) { + case itk::ImageIOBase::UCHAR: return Execute(argc,argv,nComponents); + case itk::ImageIOBase::FLOAT: return Execute(argc,argv,nComponents); + case itk::ImageIOBase::DOUBLE:return Execute(argc,argv,nComponents); + default: itkGenericExceptionMacro("Sorry, unsupported component type"); + } +} + +template +int Execute(int argc, char * argv[], int nComponents){ + switch (nComponents) { + case 1: return Execute(argc,argv); + case 2: return Execute,Vector >(argc,argv); + case 3: return Execute,Vector >(argc,argv); + default: itkGenericExceptionMacro("Sorry, unsupported number of components"); + } +} + +template +int Execute(int argc, char * argv[]){ + + // Import image + typedef Image ImageType; + typedef ImageFileReader ReaderType; + typename ReaderType::Pointer reader = ReaderType::New(); + const char *imageFileName =argv[0+1]; + reader->SetFileName(imageFileName); + + // Import tensors + typedef SymmetricSecondRankTensor TensorType; + typedef Image TensorImageType; + typedef ImageFileReader TensorReaderType; + typename TensorReaderType::Pointer tensorReader = TensorReaderType::New(); + const char * tensorImageFileName = argv[1+1]; + tensorReader->SetFileName(tensorImageFileName); + + // Import diffusion time + const double diffusionTime = atof(argv[2+1]); + if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); + + // Import output image filename + const char *outputFileName = argv[3+1]; + + // Setup diffusion filter + typedef LinearAnisotropicDiffusionLBRImageFilter DiffusionFilterType; + typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); + diffusionFilter->SetInputImage(reader->GetOutput()); + diffusionFilter->SetInputTensor(tensorReader->GetOutput()); + diffusionFilter->SetMaxDiffusionTime(diffusionTime); + + int argIndex = 4+1; + if(argIndexSetRatioToMaxStableTimeStep(ratioToMaxStableTimeStep); + } + + if(argIndexSetMaxNumberOfTimeSteps(maxNumberOfTimeSteps); + } else + diffusionFilter->SetMaxNumberOfTimeSteps(200); + + ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); + diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); + + typedef Image ExportImageType; + typedef CastImageFilter CasterType; + typename CasterType::Pointer caster = CasterType::New(); + caster->SetInput(diffusionFilter->GetOutput()); + + //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; + typedef ImageFileWriter WriterType; + typename WriterType::Pointer writer = WriterType::New(); + writer->SetInput(caster->GetOutput()); + writer->SetFileName(outputFileName); + writer->Update(); + + const ScalarType effectiveDiffusionTime=diffusionFilter->GetEffectiveDiffusionTime(); + if(effectiveDiffusionTime < 0.99 * diffusionTime){ + std::cerr << + "Warning: early abort at effective diffusion time: " << effectiveDiffusionTime << + ", you may want to increase the max number of time steps: " << diffusionFilter->GetMaxNumberOfTimeSteps() << "\n"; + Usage(); + } + + return EXIT_SUCCESS; + +} +} + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.h new file mode 100644 index 00000000000..dcca0b5da7f --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.h @@ -0,0 +1,145 @@ +// +// LinearAnisotropicDiffusionLBRImageFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_h +#define itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_h + + +#include "itkImageToImageFilter.h" + +namespace itk +{ + /** + Implementation of Anisotropic Diffusion + \f[\partial_t u = {\rm div} (D \nabla u),\f] + with Neumann boundary conditions. The numerical scheme is stable and satisfies the maximum principle, even for strongly anisotropic tensors, thanks to an adaptive discretization using arithmetic techniques (Lattice Basis Reduction, LBR). + */ + template< + typename TImage, + typename TScalar = typename TImage::PixelType + > + class LinearAnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > + { + public: + /** Standard class typedefs. */ + typedef LinearAnisotropicDiffusionLBRImageFilter Self; + typedef ImageToImageFilter< TImage, TImage > Superclass; + typedef SmartPointer< Self > Pointer; + + /** Method for creation through the object factory. */ + itkNewMacro(Self); + + /** Run-time type information (and related methods). */ + itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); + + typedef TImage ImageType; + static const int Dimension = ImageType::ImageDimension; + typedef typename ImageType::PixelType PixelType; + + typedef TScalar ScalarType; + typedef SymmetricSecondRankTensor TensorType; + typedef Image TensorImageType; + typedef ImageRegion RegionType; + + void SetInputImage(const ImageType* image); + void SetInputTensor(const TensorImageType* tensorImage); + + void SetMaxDiffusionTime(ScalarType time); + itkGetConstMacro(DiffusionTime, ScalarType); + + void SetMaxNumberOfTimeSteps(int n); + itkGetConstMacro(MaxNumberOfTimeSteps, int); + + void SetRatioToMaxStableTimeStep(ScalarType ratio); + itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); + + itkGetConstMacro(EffectiveDiffusionTime, ScalarType); + itkGetConstMacro(EffectiveNumberOfTimeSteps, int); + + itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); + itkGetConstMacro(IterationsTimeCost, ScalarType); + protected: + LinearAnisotropicDiffusionLBRImageFilter(); + ~LinearAnisotropicDiffusionLBRImageFilter(){} + + typename ImageType::ConstPointer GetInputImage(); + typename TensorImageType::ConstPointer GetInputTensor(); + + typedef Index IndexType; + + // ******* Containers for the stencils used in the discretization + static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; + static const unsigned int StencilSize = 2*HalfStencilSize; + + typedef Vector StencilCoefficientsType; + typedef Offset OffsetType; + typedef Vector StencilOffsetsType; + + typedef int InternalSizeT; + typedef Vector StencilBufferIndicesType; + + // ****************** Stencil support ****************** + + template struct GetDiffusion; + + template struct GetDiffusion<2,Dummy>{ + static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); + }; + + template struct GetDiffusion<3,Dummy>{ + static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); + }; + + // *************** Computation ***************** + virtual void GenerateData(); + virtual void GenerateStencils(); /// Automatically called by GenerateData + virtual void ImageUpdateLoop(); /// Automatically called by GenerateData + + typedef std::pair StencilType; + typedef Image StencilImageType; + typename StencilImageType::Pointer stencilImage; + + typedef Image ScalarImageType; + typename ScalarImageType::Pointer diagonalCoefficients; + + virtual ScalarType MaxStableTimeStep(); + + ScalarType m_DiffusionTime; + ScalarType m_RatioToMaxStableTimeStep; + int m_MaxNumberOfTimeSteps; + + ScalarType m_EffectiveDiffusionTime; + int m_EffectiveNumberOfTimeSteps; + + virtual void ImageUpdate(ScalarType delta); + typename ImageType::Pointer previousImage, nextImage; + + virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} + + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} + + ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; + + + struct StencilFunctor; + struct FunctorType; + + typedef Vector VectorType; + static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); + private: + LinearAnisotropicDiffusionLBRImageFilter(const Self &); //purposely not implemented + void operator=(const Self &); //purposely not implemented + }; +} //namespace ITK + + +#ifndef ITK_MANUAL_INSTANTIATION +#include "LinearAnisotropicDiffusionLBRImageFilter.hxx" +#endif + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.hxx new file mode 100644 index 00000000000..d2758981f46 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.hxx @@ -0,0 +1,432 @@ +// +// LinearAnisotropicDiffusionLBRImageFilter.hxx +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_hxx +#define itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_hxx + +#include "itkUnaryFunctorImageFilter.h" +#include "itkImageRegionIterator.h" +#include "itkMinimumMaximumImageCalculator.h" +#include "itkCastImageFilter.h" +#include "itkExtractImageFilter.h" +#include "sys/time.h" + + +#include "UnaryFunctorWithIndexImageFilter.h" +#include "itkTernaryFunctorImageFilter.h" + +namespace itk +{ + + template + LinearAnisotropicDiffusionLBRImageFilter::LinearAnisotropicDiffusionLBRImageFilter() + { + this->SetNumberOfRequiredInputs(2); + m_DiffusionTime = 1; + m_RatioToMaxStableTimeStep = 0.7; + m_MaxNumberOfTimeSteps = 10; + + m_EffectiveDiffusionTime=0; + m_EffectiveNumberOfTimeSteps=0; + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::SetInputImage(const ImageType* image) + { + this->SetNthInput(0, const_cast(image)); + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::SetInputTensor(const TensorImageType* tensorImage) + { + this->SetNthInput(1, const_cast(tensorImage)); + } + + template + typename TI::ConstPointer LinearAnisotropicDiffusionLBRImageFilter::GetInputImage() + { + return static_cast< const ImageType * > + ( this->ProcessObject::GetInput(0) ); + } + + template + typename LinearAnisotropicDiffusionLBRImageFilter::TensorImageType::ConstPointer + LinearAnisotropicDiffusionLBRImageFilter::GetInputTensor() + { + return static_cast< const TensorImageType * > + ( this->ProcessObject::GetInput(1) ); + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::GenerateData() + { + timeval start, end; + gettimeofday(&start, NULL); // nullptr is not accepted by older compilers + + GenerateStencils(); + this->UpdateProgress(0.5); + + gettimeofday(&end, NULL); + m_SparseMatrixAssemblyTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; + start=end; + + + ImageUpdateLoop(); + + gettimeofday(&end, NULL); + m_IterationsTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; + } + +// **************************** Computation *********************** + template + struct LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor { + typedef typename TensorImageType::SpacingType SpacingType; + void Initialize(RegionType region_, SpacingType spacing){ + region = region_; + prod[0]=1; + for(int i=1; iprod[i]*(x[i]-this->region.GetIndex()[i]); + return ans; + } + + StencilType operator()(const TensorType & tensor, const IndexType & x) const { + StencilType stencil; + StencilOffsetsType offsets; + + // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. + + TensorType D; + for(int i=0; iinvSpacing[i]*this->invSpacing[j]; + GetDiffusion<>::Stencil(D,offsets,stencil.second); + + InternalSizeT * yIndex = &stencil.first[0]; + + //Compute buffer offsets from geometrical offsets + for(int i=0; i<(int)HalfStencilSize; ++i){ + for(int orientation = 0; orientation<2; ++orientation, ++yIndex){ + const IndexType y = orientation ? x-offsets[i] : x+offsets[i]; + if(this->region.IsInside(y)){ + *yIndex = this->BufferIndex(y); + } else { + // Neumann boundary conditions. + *yIndex = this->OutsideBufferIndex(); + } // if y + } // for eps + } // for i + return stencil; + } + protected: + RegionType region; + IndexType prod; + SpacingType invSpacing; + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} + }; + + template + void LinearAnisotropicDiffusionLBRImageFilter::GenerateStencils(){ + + // Stencil type is a pair type because itk::UnaryFunctorImage filter + // only produces one output +// typedef typename TensorImageType::SpacingType SpacingType; + const RegionType region = GetRequestedRegion(); + + typedef UnaryFunctorWithIndexImageFilter FunctorFilterType; + typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); + filter->SetInput(GetInputTensor()); + filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); + filter->Update(); + stencilImage = filter->GetOutput(); + + + //setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. + + diagonalCoefficients = ScalarImageType::New(); + diagonalCoefficients->CopyInformation(GetInputTensor()); + diagonalCoefficients->SetRegions(GetRequestedRegion()); + diagonalCoefficients->Allocate(); + diagonalCoefficients->FillBuffer(ScalarType(0)); + + ImageRegionConstIterator stencilIt(stencilImage,region); + ImageRegionIterator diagIt(diagonalCoefficients, region); + ScalarType * diagBuffer = diagonalCoefficients->GetBufferPointer(); + + for(stencilIt.GoToBegin(), diagIt.GoToBegin(); + !stencilIt.IsAtEnd(); + ++stencilIt, ++diagIt) + for(int i=0; i<(int)StencilSize; ++i) { + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if(yIndex!=OutsideBufferIndex()){ + const ScalarType coefficient = stencilIt.Value().second[i/2]; + diagIt.Value() += coefficient; + diagBuffer[yIndex] += coefficient; + } // if y + } // for i + // for stencilIt, diagIt + } + + template + typename LinearAnisotropicDiffusionLBRImageFilter::ScalarType + LinearAnisotropicDiffusionLBRImageFilter::MaxStableTimeStep(){ + typedef MinimumMaximumImageCalculator MaxCalculatorType; + typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); + maximumCalculator->SetImage(diagonalCoefficients); + maximumCalculator->SetRegion(GetRequestedRegion()); + maximumCalculator->ComputeMaximum(); + return 1./maximumCalculator->GetMaximum(); + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::SetMaxDiffusionTime(ScalarType time){ + if(time<0) + itkExceptionMacro("diffusion time must be finite and positive"); + m_DiffusionTime = time; + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::SetRatioToMaxStableTimeStep(ScalarType ratio){ + if(ratio<=0 || ratio>1) + itkExceptionMacro("Ratio to max time step " << ratio << "should be within ]0,1]"); + m_RatioToMaxStableTimeStep=ratio; + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::SetMaxNumberOfTimeSteps(int n){ + if(n<=0) + itkExceptionMacro("Max number of time steps must be positive"); + m_MaxNumberOfTimeSteps=n; + } + + template + void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdateLoop(){ + ScalarType delta = MaxStableTimeStep() * m_RatioToMaxStableTimeStep; + int n = ceil(m_DiffusionTime / delta); + if(n>m_MaxNumberOfTimeSteps) { + n=m_MaxNumberOfTimeSteps; + m_EffectiveDiffusionTime = n*delta; + } else { + delta = m_DiffusionTime/n; + m_EffectiveDiffusionTime = m_DiffusionTime; + } + m_EffectiveNumberOfTimeSteps=n; + + // Extraction of the region of interest is required for image buffer access. + typedef ExtractImageFilter InputCasterType; + typename InputCasterType::Pointer inputCaster = InputCasterType::New(); + inputCaster->SetInput(GetInputImage()); + inputCaster->SetExtractionRegion(GetRequestedRegion()); + inputCaster->SetDirectionCollapseToIdentity(); + inputCaster->Update(); + previousImage = inputCaster->GetOutput(); + + nextImage = ImageType::New(); + nextImage->CopyInformation(previousImage); + nextImage->SetRegions(previousImage->GetBufferedRegion()); + nextImage->Allocate(); + + for(int k=0; kUpdateProgress(0.5+0.5*k/float(n)); + } + this->GraftOutput(previousImage); + } + + template + struct LinearAnisotropicDiffusionLBRImageFilter::FunctorType { + ScalarType delta; + PixelType operator()(PixelType output, PixelType input, ScalarType diag){ + return output*this->delta + input*(ScalarType(1)-this->delta*diag); + } + }; + + template + void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdate(ScalarType delta){ + + //Setting up iterators + + ImageRegion region = GetRequestedRegion(); + + ImageRegionConstIterator inputIt(previousImage,region); + ImageRegionIterator outputIt(nextImage,region); + + const PixelType * inputBuffer = previousImage->GetBufferPointer(); + PixelType * outputBuffer = nextImage->GetBufferPointer(); + + ImageRegionConstIterator diagIt(diagonalCoefficients, region); + ImageRegionConstIterator stencilIt(stencilImage, region); + + // Rest of function is a hand-made (sparse matrix)*vector product. + nextImage->FillBuffer(0.); + + // Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer + for(inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); + !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++stencilIt){ + for(int i=0; i<(int)StencilSize; ++i){ + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if(yIndex!=OutsideBufferIndex()){ + const ScalarType coefficient = stencilIt.Value().second[i/2]; + outputIt.Value() += coefficient * (inputBuffer[yIndex]); + outputBuffer[yIndex] += coefficient * inputIt.Value(); + } + } + } + + typedef TernaryFunctorImageFilter ImageFunctorType; + typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); + imageFunctor->SetInput1(nextImage); + imageFunctor->SetInput2(previousImage); + imageFunctor->SetInput3(diagonalCoefficients); + imageFunctor->GetFunctor().delta = delta; + + assert(imageFunctor->CanRunInPlace()); + imageFunctor->InPlaceOn(); + imageFunctor->Update(); + nextImage=imageFunctor->GetOutput(); + + /* + // Old Serial version for diagonal elements + for(inputIt.GoToBegin(), outputIt.GoToBegin(), diagIt.GoToBegin(); + !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++diagIt) + outputIt.Value() = delta*outputIt.Value() + (1-delta*diagIt.Value())*inputIt.Value(); + */ + } + +// **************************** subclass SSRT_Traits call method ************************** + +template +TS +LinearAnisotropicDiffusionLBRImageFilter::ScalarProduct(const TensorType & m, + const VectorType & u, + const VectorType & v){ + ScalarType result(0); + for(int i=0; i template +void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<2,Dummy>:: +Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ + + // Construct a superbase, and make it obtuse with Selling's algorithm + VectorType sb[Dimension+1]; //SuperBase + for(int i=0; i 0 ){ + const VectorType u=sb[i], v=sb[j]; + sb[0]=v-u; + sb[1]=u; + sb[2]=-v; + same=false; + } + if(same) break; + } + if(iter==maxIter) + std::cerr << "Warning: Selling's algorithm not stabilized.\n"; + + for(int i=0; i<3; ++i){ + Coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); + assert(Coefficients[i]>=0); + + Offsets[i][0] = static_cast(-sb[i][1]); + Offsets[i][1] = static_cast( sb[i][0]); + } + +} // 2D stencil construction + + + // 3D stencil construction +template template +void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<3,Dummy>:: +Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ + + // Construct a superbase, and make it obtuse with Selling's algorithm + typedef Vector VectorType; + VectorType sb[Dimension+1]; + for(int i=0; i 0 ){ + const VectorType u=sb[i], v=sb[j]; + for(int k=0,l=0; k<=Dimension; ++k) + if(k!=i && k!=j) + sb[l++]=sb[k]+u; + sb[2]=-u; + sb[3]=v; + same=false; + } + if(same) break; + } + if(iter==maxIter) + std::cerr << "Warning: Selling's algorithm not stabilized.\n"; + + // Computation of the weights + itk::SymmetricSecondRankTensor Weights; + for(int i=1; im_##name;} \ + virtual const type & Get##name() const {return this->m_##name;} \ + virtual void Set##name(const type & _arg) {m_##name = _arg; this->Modified();} +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.h new file mode 100644 index 00000000000..9f3282fb399 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.h @@ -0,0 +1,91 @@ +// +// StructureTensorImageFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 05/03/2014. +// +// + +#ifndef itkDiffusion_StructureTensorImageFilter_h +#define itkDiffusion_StructureTensorImageFilter_h + +#include "itkCastImageFilter.h" +#include "itkGradientRecursiveGaussianImageFilter.h" +#include "itkAddImageFilter.h" +#include "itkVectorIndexSelectionCastImageFilter.h" +#include "itkGradientImageFilter.h" + +namespace itk { + /** + Implementation of the structure tensor, defined by + \f[K_\rho (\nabla u_\sigma \otimes \nabla u_\sigma),\f] where \f$K_\rho\f$ denotes the gaussian kernel of standard deviation \f$\rho\f$, and \f$u_\sigma := K_\sigma * u\f$. + */ + template< + typename TImage, + typename TTensorImage = Image< + SymmetricSecondRankTensor, + TImage::ImageDimension> + > + class StructureTensorImageFilter : public ImageToImageFilter { + public: + typedef StructureTensorImageFilter Self; + typedef ImageToImageFilter< TImage, TImage> Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(StructureTensorImageFilter, Superclass); + + typedef TImage ImageType; + typedef typename ImageType::PixelType PixelType; + static const unsigned int Dimension = ImageType::ImageDimension; + typedef TTensorImage TensorImageType; + typedef typename TensorImageType::PixelType TensorType; + typedef typename TensorType::ComponentType ScalarType; + typedef Image ScalarImageType; + + ///Parameter \f$\sigma\f$ of the structure tensor definition. + itkSetMacro(NoiseScale, ScalarType); + ///Parameter \f$\rho\f$ of the structure tensor definition. + itkSetMacro(FeatureScale, ScalarType); + ///Rescales all structure tensors by a common factor, so that the maximum trace is 1. + itkSetMacro(RescaleForUnitMaximumTrace, bool); + + itkGetConstMacro(NoiseScale, ScalarType); + itkGetConstMacro(FeatureScale, ScalarType); + itkGetConstMacro(RescaleForUnitMaximumTrace, bool); + itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. + + bool m_UseGradientRecursiveGaussianImageFilter; + protected: + virtual void GenerateData(); + + ScalarType m_FeatureScale, m_NoiseScale; + bool m_RescaleForUnitMaximumTrace; + ScalarType m_PostRescaling; + + template::is_specialized> + struct IntermediateFilter; + typename TensorImageType::Pointer intermediateResult; + + typedef CovariantVector CovariantVectorType; + typedef Image CovariantImageType; + + struct OuterFunctor; + struct TraceFunctor; + struct ScaleFunctor; + + StructureTensorImageFilter(){ + m_FeatureScale=2; + m_NoiseScale=1; + m_RescaleForUnitMaximumTrace=false; + m_UseGradientRecursiveGaussianImageFilter=true; + } + }; +} + +#include "StructureTensorImageFilter.hxx" + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.hxx new file mode 100644 index 00000000000..37c2bb8a72e --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.hxx @@ -0,0 +1,157 @@ +// +// StructureTensorImageFilter.hxx +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 21/11/2014. +// +// + +#ifndef itkDiffusion_StructureTensorImageFilter_hxx +#define itkDiffusion_StructureTensorImageFilter_hxx + + +namespace itk { + template + struct StructureTensorImageFilter::OuterFunctor { + TensorType operator()(const CovariantVectorType & u) const { + TensorType m; + for(int i=0; i<(int)Dimension; ++i) + for(int j=i; j<(int)Dimension; ++j) + m(i,j) = u[i]*u[j]; + return m; + } + }; + + + template + template + struct StructureTensorImageFilter::IntermediateFilter { + void operator()(Self *self){ + typedef GradientRecursiveGaussianImageFilter GradientFilterType; + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + gradientFilter->SetInput(self->GetInput()); + gradientFilter->SetSigma(self->m_NoiseScale); + + typedef UnaryFunctorImageFilter OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + outerFilter->SetInput(gradientFilter->GetOutput()); + + outerFilter->Update(); + self->intermediateResult = outerFilter->GetOutput(); + } + }; + + template + template + struct StructureTensorImageFilter::IntermediateFilter { + void operator()(Self *self){ + + typename ImageType::ConstPointer input = self->GetInput(); + typename TensorImageType::Pointer output = TensorImageType::New(); + output->CopyInformation(input); + output->SetRegions(input->GetRequestedRegion()); + output->Allocate(); + output->FillBuffer(TensorType(0.)); + + for(int index=0; index SelectionFilterType; + typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); + selectionFilter->SetIndex(index); + selectionFilter->SetInput(input); + + typedef RecursiveGaussianImageFilter GaussianFilterType; + typedef GradientImageFilter GradientFilterType; + typedef GradientRecursiveGaussianImageFilter GradientGaussianFilterType; + + typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); + + gaussianFilter->SetSigma(self->m_NoiseScale); + gradientGaussianFilter->SetSigma(self->m_NoiseScale); + + typedef UnaryFunctorImageFilter OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + + if(self->m_UseGradientRecursiveGaussianImageFilter){ + gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); + outerFilter->SetInput(gradientGaussianFilter->GetOutput()); + } else { + gaussianFilter->SetInput(selectionFilter->GetOutput()); + gradientFilter->SetInput(gaussianFilter->GetOutput()); + outerFilter->SetInput(gradientFilter->GetOutput()); + } + + typedef AddImageFilter AddFilterType; + typename AddFilterType::Pointer addFilter = AddFilterType::New(); + addFilter->InPlaceOn(); + addFilter->SetInput1(output); + addFilter->SetInput2(outerFilter->GetOutput()); + addFilter->Update(); + output = addFilter->GetOutput(); + + self->UpdateProgress(index/float(PixelType::Dimension+1)); + } + self->intermediateResult = output; + } + }; + + + template + struct StructureTensorImageFilter::TraceFunctor { + ScalarType operator()(const TensorType & t) const { + return t.GetTrace(); + } + }; + + template + struct StructureTensorImageFilter::ScaleFunctor { + ScalarType scaling; + TensorType operator()(const TensorType & t) const { + return t*scaling; + } + }; + + template + void StructureTensorImageFilter::GenerateData(){ + IntermediateFilter<>()(this); + + typedef RecursiveGaussianImageFilter GaussianFilterType; + typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); + gaussianFilter->SetInput(intermediateResult); + gaussianFilter->SetSigma(m_FeatureScale); + + if(!m_RescaleForUnitMaximumTrace){ + m_PostRescaling=1.; + gaussianFilter->Update(); + this->GraftOutput(gaussianFilter->GetOutput()); + return; + } + + // *** Rescaling for normalization of largest trace *** + + typedef UnaryFunctorImageFilter TraceFilterType; + typename TraceFilterType::Pointer traceFilter = TraceFilterType::New(); + traceFilter->SetInput(gaussianFilter->GetOutput()); + + typedef MinimumMaximumImageCalculator MaximumCalculatorType; + typename MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); + maximumCalculator->SetImage(traceFilter->GetOutput()); + + typedef UnaryFunctorImageFilter ScaleFilterType; + typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); + scaleFilter->SetInput(gaussianFilter->GetOutput()); + + traceFilter->Update(); + maximumCalculator->ComputeMaximum(); + m_PostRescaling = 1./maximumCalculator->GetMaximum(); + scaleFilter->GetFunctor().scaling = m_PostRescaling; + scaleFilter->Update(); + this->GraftOutput(scaleFilter->GetOutput()); + } +} + + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/UnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/UnaryFunctorWithIndexImageFilter.h new file mode 100644 index 00000000000..2edcf30e073 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/UnaryFunctorWithIndexImageFilter.h @@ -0,0 +1,66 @@ +// +// UnaryFunctorWithIndexImageFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 07/03/2014. +// +// + +#ifndef itkDiffusion_UnaryFunctorWithIndexImageFilter_h +#define itkDiffusion_UnaryFunctorWithIndexImageFilter_h + +#include "itkImageRegionConstIteratorWithIndex.h" +#include "itkImageScanlineIterator.h" +#include "Macro.h" +/** A (simplification of) UnaryFunctorImageFilter, which provides the pixel index to the functor. + */ + +namespace itk { + template + class UnaryFunctorWithIndexImageFilter : public ImageToImageFilter { + public: + typedef UnaryFunctorWithIndexImageFilter Self; + typedef ImageToImageFilter Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(UnaryFunctorWithIndexImageFilter, Superclass); + + typedef TInputImage InputImageType; + typedef TOutputImage OutputImageType; + typedef TFunctor FunctorType; + + GetSetFunctorMacro(Functor, FunctorType); + + protected: + UnaryFunctorWithIndexImageFilter(){}; + + FunctorType m_Functor; + + typedef typename InputImageType::RegionType InputRegionType; + typedef typename OutputImageType::RegionType OutputRegionType; + + virtual void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType){ + if(region.GetSize()[0]==0) return; + + ImageRegionConstIteratorWithIndex inputIt( this->GetInput(), region); + ImageScanlineIterator< OutputImageType > outputIt( this->GetOutput(), region); + + for(inputIt.GoToBegin(), outputIt.GoToBegin(); + !outputIt.IsAtEnd(); + ){ + while(!outputIt.IsAtEndOfLine()){ + outputIt.Set(m_Functor(inputIt.Value(), inputIt.GetIndex())); + ++inputIt; + ++outputIt; + } + outputIt.NextLine(); + } + } + }; +} + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Cos3D_cCED.vtk.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Cos3D_cCED.vtk.md5 new file mode 100644 index 00000000000..3df854dded2 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Cos3D_cCED.vtk.md5 @@ -0,0 +1 @@ +df95fdb0657f7f8472bdc16c73c5bed0 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_I_20.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_I_20.png.md5 new file mode 100644 index 00000000000..3b5dbe8354c --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_I_20.png.md5 @@ -0,0 +1 @@ +e4e5e233b434ea4c85059d7c62f15554 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cCED_20.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cCED_20.png.md5 new file mode 100644 index 00000000000..750c29db86b --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cCED_20.png.md5 @@ -0,0 +1 @@ +07435f1d44aeb66fd98e642945437662 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cEED_20.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cEED_20.png.md5 new file mode 100644 index 00000000000..76c2e516e80 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/FingerPrint_cEED_20.png.md5 @@ -0,0 +1 @@ +5e752e3fa0e46bb530fedc94c7794c73 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_I_2.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_I_2.png.md5 new file mode 100644 index 00000000000..b80ed7eb732 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_I_2.png.md5 @@ -0,0 +1 @@ +ff36663855e6794712b081689aac70e5 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cCED_2.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cCED_2.png.md5 new file mode 100644 index 00000000000..f6a2c0d79ae --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cCED_2.png.md5 @@ -0,0 +1 @@ +b741b80ce65e20c59f286244f621344a \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cEED_2.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cEED_2.png.md5 new file mode 100644 index 00000000000..d529c7f1aa4 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Lena_Detail_cEED_2.png.md5 @@ -0,0 +1 @@ +c606fea9c82019d1b4e80d351b803d92 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_CED.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_CED.png.md5 new file mode 100644 index 00000000000..b5cb7d21602 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_CED.png.md5 @@ -0,0 +1 @@ +50da37ff706c93536c0f33390da4287c \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_cCED.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_cCED.png.md5 new file mode 100644 index 00000000000..35dfbe815ba --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Oscillations1_cCED.png.md5 @@ -0,0 +1 @@ +21e83dc09f4c58a44eeb676e49ec3d99 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_I.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_I.png.md5 new file mode 100644 index 00000000000..6a1cf5d0156 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_I.png.md5 @@ -0,0 +1 @@ +c5b358267defea8babcfebbc66c9fa8b \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cCED.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cCED.png.md5 new file mode 100644 index 00000000000..223ef256a52 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cCED.png.md5 @@ -0,0 +1 @@ +fd8d652016508d93ee861c1db83f3ed4 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cEED.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cEED.png.md5 new file mode 100644 index 00000000000..a08c69480fd --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/PacMan_cEED.png.md5 @@ -0,0 +1 @@ +edf293e2cce2eae1df4f8598e8179641 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_EED.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_EED.png.md5 new file mode 100644 index 00000000000..09f2a9ab526 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_EED.png.md5 @@ -0,0 +1 @@ +f823b62e9135a37c7438fa07a9e54096 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_cEED.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_cEED.png.md5 new file mode 100644 index 00000000000..ff3bfe4ac73 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/Triangle_cEED.png.md5 @@ -0,0 +1 @@ +12473a0cb8d3afa0f8d7eb4f61e6216b \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/VectorField_Circle_cEED.vtk.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/VectorField_Circle_cEED.vtk.md5 new file mode 100644 index 00000000000..77458bed992 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/VectorField_Circle_cEED.vtk.md5 @@ -0,0 +1 @@ +23c4495de1a746648418abc144972e92 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/mrbrain_cEED.vtk.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/mrbrain_cEED.vtk.md5 new file mode 100644 index 00000000000..9e91116b83f --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Baseline/mrbrain_cEED.vtk.md5 @@ -0,0 +1 @@ +db41c262fba84a75eb399e1e154a5974 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt new file mode 100755 index 00000000000..b3732345540 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt @@ -0,0 +1,99 @@ +add_subdirectory("../src/Headers" "${CMAKE_CURRENT_BINARY_DIR}/src/Headers") + +include_directories(${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + +itk_module_test() + +Set(ITK${itk-module}Tests + CoherenceEnhancingDiffusionTest.cxx +) + +CreateTestDriver(${itk-module} "${${itk-module}-Test_LIBRARIES}" "${ITK${itk-module}Tests}") + +set(TestInput ${${itk-module}_SOURCE_DIR}/test/Input) +set(TestOutput ${ITK_TEST_OUTPUT_DIR}) +set(TestBaseline ${${itk-module}_SOURCE_DIR}/test/Baseline) + +################ fig:PacMan ################# + +itk_add_test(NAME PacMan_cEED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/PacMan_cEED.png ${TestOutput}/PacMan_cEED.png + CoherenceEnhancingDiffusionTest ${TestInput}/PacMan.png ${TestOutput}/PacMan_cEED.png 20 0.05 cEED 3) + +itk_add_test(NAME PacMan_cCED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/PacMan_cCED.png ${TestOutput}/PacMan_cCED.png + CoherenceEnhancingDiffusionTest ${TestInput}/PacMan.png ${TestOutput}/PacMan_cCED.png 20 0.05 cCED 3) + +itk_add_test(NAME PacMan_I COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/PacMan_I.png ${TestOutput}/PacMan_I.png + CoherenceEnhancingDiffusionTest ${TestInput}/PacMan.png ${TestOutput}/PacMan_I.png 20 0.05 Isotropic 3) + +############# fig : Fingerprint ############# + +itk_add_test(NAME FingerPrint_cEED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/FingerPrint_cEED_20.png ${TestOutput}/FingerPrint_cEED_20.png + CoherenceEnhancingDiffusionTest ${TestInput}/FingerPrint.png ${TestOutput}/FingerPrint_cEED_20.png 20 0.02 cEED ) + +itk_add_test(NAME FingerPrint_cCED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/FingerPrint_cCED_20.png ${TestOutput}/FingerPrint_cCED_20.png + CoherenceEnhancingDiffusionTest ${TestInput}/FingerPrint.png ${TestOutput}/FingerPrint_cCED_20.png 20 0.02 cCED ) + +itk_add_test(NAME FingerPrint_I COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/FingerPrint_I_20.png ${TestOutput}/FingerPrint_I_20.png + CoherenceEnhancingDiffusionTest ${TestInput}/FingerPrint.png ${TestOutput}/FingerPrint_I_20.png 20 0.02 Isotropic ) + + +################ fig : Cos3D ################ + +itk_add_test(NAME Cos3D_cCED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Cos3D_cCED.vtk ${TestOutput}/Cos3D_cCED.vtk + CoherenceEnhancingDiffusionTest ${TestInput}/Cos3D_Noisy.vtk ${TestOutput}/Cos3D_cCED.vtk 10 0.02 cCED 4 10 ) + + +################ fig : Brain ################ + +itk_add_test(NAME mrbrain_cEED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/mrbrain_cEED.vtk ${TestOutput}/mrbrain_cEED.vtk + CoherenceEnhancingDiffusionTest ${TestInput}/mrbrain_noisy.vtk ${TestOutput}/mrbrain_cEED.vtk 5 0.003 cEED ) + +################# fig : Lena ################ + +itk_add_test(NAME Lena_Detail_cCED_2 COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Lena_Detail_cCED_2.png ${TestOutput}/Lena_Detail_cCED_2.png + CoherenceEnhancingDiffusionTest ${TestInput}/Lena_Detail.png ${TestOutput}/Lena_Detail_cCED_2.png 2 0.003 cCED 0.5 2 4 ) + + +itk_add_test(NAME Lena_Detail_cEED_2 COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Lena_Detail_cEED_2.png ${TestOutput}/Lena_Detail_cEED_2.png + CoherenceEnhancingDiffusionTest ${TestInput}/Lena_Detail.png ${TestOutput}/Lena_Detail_cEED_2.png 2 0.003 cEED 0.5 2 4 ) + +itk_add_test(NAME Lena_Detail_I_2 COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Lena_Detail_I_2.png ${TestOutput}/Lena_Detail_I_2.png + CoherenceEnhancingDiffusionTest ${TestInput}/Lena_Detail.png ${TestOutput}/Lena_Detail_I_2.png 2 0.003 Isotropic 0.5 2 4 ) + + +############## fig : Vector field ########### + +itk_add_test(NAME VectorField_Circle_cEED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/VectorField_Circle_cEED.vtk ${TestOutput}/VectorField_Circle_cEED.vtk + CoherenceEnhancingDiffusionTest ${TestInput}/VectorField_CircleOpposites.vtk ${TestOutput}/VectorField_Circle_cEED.vtk 10 0.05 cEED ) + + +############### fig : Triangle ############## + + +itk_add_test(NAME Triangle_cEED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Triangle_cEED.png ${TestOutput}/Triangle_cEED.png + CoherenceEnhancingDiffusionTest ${TestInput}/Triangle.png ${TestOutput}/Triangle_cEED.png 5 0.03 cEED ) + +itk_add_test(NAME Triangle_EED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Triangle_EED.png ${TestOutput}/Triangle_EED.png + CoherenceEnhancingDiffusionTest ${TestInput}/Triangle.png ${TestOutput}/Triangle_EED.png 5 0.03 EED ) + +itk_add_test(NAME Oscillations1_cCED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Oscillations1_cCED.png ${TestOutput}/Oscillations1_cCED.png + CoherenceEnhancingDiffusionTest ${TestInput}/Oscillations_Noisy1.png ${TestOutput}/Oscillations1_cCED.png 20 0.05 cCED ) + +itk_add_test(NAME Oscillations1_CED COMMAND ${itk-module}TestDriver + --compare ${TestBaseline}/Oscillations1_CED.png ${TestOutput}/Oscillations1_CED.png + CoherenceEnhancingDiffusionTest ${TestInput}/Oscillations_Noisy1.png ${TestOutput}/Oscillations1_CED.png 20 0.05 CED ) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx new file mode 100755 index 00000000000..9771ff23821 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx @@ -0,0 +1,26 @@ +#include +#include +#include "CoherenceEnhancingDiffusionCommandLine.h" + +int CoherenceEnhancingDiffusionTest(int argc, char **argv) +{ + try { + CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); + } catch (itk::ExceptionObject& e) { + std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; + return EXIT_FAILURE; + } + return EXIT_SUCCESS; +} + +/* +int LinearAnisotropicDiffusionTest(int argc, char **argv) +{ + try { + LinearAnisotropicDiffusionCommandLine::Execute(argc, argv); + } catch (itk::ExceptionObject& e) { + std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; + return EXIT_FAILURE; + } + return EXIT_SUCCESS; +}*/ \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Cos3D_Noisy.vtk.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Cos3D_Noisy.vtk.md5 new file mode 100644 index 00000000000..c48093eec6b --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Cos3D_Noisy.vtk.md5 @@ -0,0 +1 @@ +3a7d9131a732794fcb4100909cd3fd1c \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/FingerPrint.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/FingerPrint.png.md5 new file mode 100644 index 00000000000..2992b7a556c --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/FingerPrint.png.md5 @@ -0,0 +1 @@ +ed7342b4598d44574b2714834b705cad \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Lena_Detail.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Lena_Detail.png.md5 new file mode 100644 index 00000000000..2d8222d7362 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Lena_Detail.png.md5 @@ -0,0 +1 @@ +45a1845c6fa452c7465bebda5bbe9b0f \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Oscillations_Noisy1.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Oscillations_Noisy1.png.md5 new file mode 100644 index 00000000000..4797a352a96 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Oscillations_Noisy1.png.md5 @@ -0,0 +1 @@ +75818e9d765fb6838a8cf5845ac19b9a \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/PacMan.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/PacMan.png.md5 new file mode 100644 index 00000000000..0abec1e6758 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/PacMan.png.md5 @@ -0,0 +1 @@ +d7955368c6f49cbb451d8901aa40add6 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Triangle.png.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Triangle.png.md5 new file mode 100644 index 00000000000..c5594b80c04 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/Triangle.png.md5 @@ -0,0 +1 @@ +bce40d3af4f491d728aaba8bb8c9ede9 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/VectorField_CircleOpposites.vtk.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/VectorField_CircleOpposites.vtk.md5 new file mode 100644 index 00000000000..e664c2ad407 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/VectorField_CircleOpposites.vtk.md5 @@ -0,0 +1 @@ +0a9e85b2b8dfadb4ab25b828a0f23852 \ No newline at end of file diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/mrbrain_noisy.vtk.md5 b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/mrbrain_noisy.vtk.md5 new file mode 100644 index 00000000000..2e105fba437 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/Input/mrbrain_noisy.vtk.md5 @@ -0,0 +1 @@ +ff88f04e75dc478b283ecdf39d8d7687 \ No newline at end of file From 156817cb360d710c48cb9a36e117f80fb50530f1 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:37:08 -0400 Subject: [PATCH 02/76] BUG: Remove executable bit from source files. --- Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt | 0 Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake | 0 Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt | 0 .../AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx | 0 Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt | 0 .../test/CoherenceEnhancingDiffusionTest.cxx | 0 6 files changed, 0 insertions(+), 0 deletions(-) mode change 100755 => 100644 Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt mode change 100755 => 100644 Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake mode change 100755 => 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt mode change 100755 => 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx mode change 100755 => 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt mode change 100755 => 100644 Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake old mode 100755 new mode 100644 diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx old mode 100755 new mode 100644 diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx old mode 100755 new mode 100644 From 883b102b3ef1e6afda752397c5b3021dd253e70c Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:37:56 -0400 Subject: [PATCH 03/76] BUG: Move headers into the module include/ directory. --- .../{src/Headers => include}/AnisotropicDiffusionLBRImageFilter.h | 0 .../Headers => include}/AnisotropicDiffusionLBRImageFilter.hxx | 0 .../{src/Headers => include}/CMakeLists.txt | 0 .../Headers => include}/CoherenceEnhancingDiffusionCommandLine.h | 0 .../{src/Headers => include}/CoherenceEnhancingDiffusionFilter.h | 0 .../Headers => include}/LinearAnisotropicDiffusionCommandLine.h | 0 .../LinearAnisotropicDiffusionLBRImageFilter.h | 0 .../LinearAnisotropicDiffusionLBRImageFilter.hxx | 0 .../AnisotropicDiffusionLBR/{src/Headers => include}/Macro.h | 0 .../{src/Headers => include}/StructureTensorImageFilter.h | 0 .../{src/Headers => include}/StructureTensorImageFilter.hxx | 0 .../{src/Headers => include}/UnaryFunctorWithIndexImageFilter.h | 0 12 files changed, 0 insertions(+), 0 deletions(-) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/AnisotropicDiffusionLBRImageFilter.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/AnisotropicDiffusionLBRImageFilter.hxx (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/CMakeLists.txt (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/CoherenceEnhancingDiffusionCommandLine.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/CoherenceEnhancingDiffusionFilter.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/LinearAnisotropicDiffusionCommandLine.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/LinearAnisotropicDiffusionLBRImageFilter.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/LinearAnisotropicDiffusionLBRImageFilter.hxx (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/Macro.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/StructureTensorImageFilter.h (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/StructureTensorImageFilter.hxx (100%) rename Modules/Filtering/AnisotropicDiffusionLBR/{src/Headers => include}/UnaryFunctorWithIndexImageFilter.h (100%) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.hxx similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/AnisotropicDiffusionLBRImageFilter.hxx rename to Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.hxx diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/include/CMakeLists.txt similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CMakeLists.txt rename to Modules/Filtering/AnisotropicDiffusionLBR/include/CMakeLists.txt diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionCommandLine.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionFilter.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/CoherenceEnhancingDiffusionFilter.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionFilter.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionCommandLine.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.hxx similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/LinearAnisotropicDiffusionLBRImageFilter.hxx rename to Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.hxx diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/Macro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/Macro.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/Macro.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/Macro.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.hxx similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/StructureTensorImageFilter.hxx rename to Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.hxx diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/UnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/UnaryFunctorWithIndexImageFilter.h similarity index 100% rename from Modules/Filtering/AnisotropicDiffusionLBR/src/Headers/UnaryFunctorWithIndexImageFilter.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/UnaryFunctorWithIndexImageFilter.h From 8f642535acdd5e71b5b236b298ea1b95eb59c970 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:40:28 -0400 Subject: [PATCH 04/76] DOC: Add link to the IJ article in the module documentation. --- .../Filtering/AnisotropicDiffusionLBR/itk-module.cmake | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake index fbd0af242ea..619fb8fd1f9 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake +++ b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake @@ -1,4 +1,11 @@ -set(DOCUMENTATION "This module implements Anisotropic Diffusion, using Lattice Basis Reduction.") +set(DOCUMENTATION "This module implements Anisotropic Diffusion, using Lattice Basis Reduction. + +Documentation can be found in the Insight Journal article, 'Anisotropic +Diffusion in ITK', by Mirebeau J., Fehrenbach J., Risser L., Tobji S. + +http://insight-journal.org/browse/publication/953 +http://hdl.handle.net/10380/3505 +") # itk_module() defines the module dependencies in ITKAnisotropicFastMarchingLBR; # ITKAnisotropicFastMarchingLBR depends on ITKCommon; From 514b74d83697b006e7613658983ea6e3caa2853f Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:41:00 -0400 Subject: [PATCH 05/76] ENH: Remove "ITK" from the module name. This is a requirement to add the file to ITK as a Remote Module. --- Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt | 2 +- Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index 33be936e6db..b46532119bb 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,2 +1,2 @@ -project(ITKAnisotropicDiffusionLBR) +project(AnisotropicDiffusionLBR) itk_module_impl() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake index 619fb8fd1f9..39369cb6bb4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake +++ b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake @@ -12,7 +12,7 @@ http://hdl.handle.net/10380/3505 # The testing module in ITKExternalTemplate depends on ITKTestKernel, # and ITKMetaIO for image IO (besides ITKAnisotropicDiffusionLBR itself) -itk_module(ITKAnisotropicDiffusionLBR +itk_module(AnisotropicDiffusionLBR DEPENDS ITKCommon ITKIOImageBase From e60a2088425f5574938a3a252e7bf11db3a5e19f Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:42:59 -0400 Subject: [PATCH 06/76] BUG: Remove unnecessary include/CMakeLists.txt --- .../include/CMakeLists.txt | 17 ----------------- .../AnisotropicDiffusionLBR/src/CMakeLists.txt | 4 +--- 2 files changed, 1 insertion(+), 20 deletions(-) delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/CMakeLists.txt diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/include/CMakeLists.txt deleted file mode 100644 index 61ade0b69e0..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CMakeLists.txt +++ /dev/null @@ -1,17 +0,0 @@ -set(ADLBR_Headers - ${CMAKE_CURRENT_SOURCE_DIR}/AnisotropicDiffusionLBRImageFilter.h - ${CMAKE_CURRENT_SOURCE_DIR}/AnisotropicDiffusionLBRImageFilter.hxx - ${CMAKE_CURRENT_SOURCE_DIR}/LinearAnisotropicDiffusionLBRImageFilter.h - ${CMAKE_CURRENT_SOURCE_DIR}/LinearAnisotropicDiffusionLBRImageFilter.hxx - ${CMAKE_CURRENT_SOURCE_DIR}/StructureTensorImageFilter.h - ${CMAKE_CURRENT_SOURCE_DIR}/StructureTensorImageFilter.hxx - ${CMAKE_CURRENT_SOURCE_DIR}/CoherenceEnhancingDiffusionFilter.h - ${CMAKE_CURRENT_SOURCE_DIR}/LinearAnisotropicDiffusionCommandLine.h - ${CMAKE_CURRENT_SOURCE_DIR}/CoherenceEnhancingDiffusionCommandLine.h - ${CMAKE_CURRENT_SOURCE_DIR}/UnaryFunctorWithIndexImageFilter.h - ${CMAKE_CURRENT_SOURCE_DIR}/Macro.h - PARENT_SCOPE -) - -set(PROJECT_DIR ${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR} PARENT_SCOPE) - diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt index ac23e504ec4..de140e9ef83 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt @@ -1,5 +1,3 @@ -add_subdirectory("Headers") - include_directories(${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) set(${itk-module}_SRC @@ -9,4 +7,4 @@ CoherenceEnhancingDiffusion.cxx add_library(${itk-module} ${${itk-module}_SRC} ${ADLBR_Headers}) target_link_libraries(${itk-module} ${${itk-module}_LIBRARIES}) -itk_module_target(${itk-module}) \ No newline at end of file +itk_module_target(${itk-module}) From 9dce3fbd66c135e1eb5422e80e4115e8a0d27651 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 21:46:38 -0400 Subject: [PATCH 07/76] ENH: Cleanup of the src/ directory. --- .../src/CMakeLists.txt | 8 +++----- .../src/CoherenceEnhancingDiffusion.cxx | 19 ++++++++++--------- 2 files changed, 13 insertions(+), 14 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt index de140e9ef83..40a7f5e7d62 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt @@ -1,10 +1,8 @@ -include_directories(${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) - -set(${itk-module}_SRC +set(${itk-module}_SRCS CoherenceEnhancingDiffusion.cxx -) + ) -add_library(${itk-module} ${${itk-module}_SRC} ${ADLBR_Headers}) +add_library(${itk-module} ${${itk-module}_SRCS}) target_link_libraries(${itk-module} ${${itk-module}_LIBRARIES}) itk_module_target(${itk-module}) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx index ab6654323c1..c5392d6c108 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx @@ -3,14 +3,15 @@ #include "CoherenceEnhancingDiffusionCommandLine.h" int main(int argc, char **argv) -{ - try { - CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); - } catch (itk::ExceptionObject& e) { - std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; - return EXIT_FAILURE; +{ + try + { + CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); } - return EXIT_SUCCESS; + catch(itk::ExceptionObject& e) + { + std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; + return EXIT_FAILURE; + } + return EXIT_SUCCESS; } - - From f5b6ef0868cab894039a297b9ac40442cf9eed37 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 23:00:38 -0400 Subject: [PATCH 08/76] BUG: Add missing content link dereferences in test/CMakeLists.txt. --- .../test/CMakeLists.txt | 77 +++++++++---------- 1 file changed, 35 insertions(+), 42 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt index b3732345540..ab025231137 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt @@ -1,99 +1,92 @@ -add_subdirectory("../src/Headers" "${CMAKE_CURRENT_BINARY_DIR}/src/Headers") - -include_directories(${PROJECT_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) - itk_module_test() -Set(ITK${itk-module}Tests +set(${itk-module}Tests CoherenceEnhancingDiffusionTest.cxx -) + ) -CreateTestDriver(${itk-module} "${${itk-module}-Test_LIBRARIES}" "${ITK${itk-module}Tests}") +CreateTestDriver(${itk-module} "${${itk-module}-Test_LIBRARIES}" "${${itk-module}Tests}") -set(TestInput ${${itk-module}_SOURCE_DIR}/test/Input) set(TestOutput ${ITK_TEST_OUTPUT_DIR}) -set(TestBaseline ${${itk-module}_SOURCE_DIR}/test/Baseline) ################ fig:PacMan ################# itk_add_test(NAME PacMan_cEED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/PacMan_cEED.png ${TestOutput}/PacMan_cEED.png - CoherenceEnhancingDiffusionTest ${TestInput}/PacMan.png ${TestOutput}/PacMan_cEED.png 20 0.05 cEED 3) + --compare DATA{Baseline/PacMan_cEED.png} ${TestOutput}/PacMan_cEED.png + CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cEED.png 20 0.05 cEED 3) itk_add_test(NAME PacMan_cCED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/PacMan_cCED.png ${TestOutput}/PacMan_cCED.png - CoherenceEnhancingDiffusionTest ${TestInput}/PacMan.png ${TestOutput}/PacMan_cCED.png 20 0.05 cCED 3) + --compare DATA{Baseline/PacMan_cCED.png} ${TestOutput}/PacMan_cCED.png + CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cCED.png 20 0.05 cCED 3) itk_add_test(NAME PacMan_I COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/PacMan_I.png ${TestOutput}/PacMan_I.png - CoherenceEnhancingDiffusionTest ${TestInput}/PacMan.png ${TestOutput}/PacMan_I.png 20 0.05 Isotropic 3) + --compare DATA{Baseline/PacMan_I.png} ${TestOutput}/PacMan_I.png + CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_I.png 20 0.05 Isotropic 3) ############# fig : Fingerprint ############# itk_add_test(NAME FingerPrint_cEED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/FingerPrint_cEED_20.png ${TestOutput}/FingerPrint_cEED_20.png - CoherenceEnhancingDiffusionTest ${TestInput}/FingerPrint.png ${TestOutput}/FingerPrint_cEED_20.png 20 0.02 cEED ) + --compare DATA{Baseline/FingerPrint_cEED_20.png} ${TestOutput}/FingerPrint_cEED_20.png + CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cEED_20.png 20 0.02 cEED ) itk_add_test(NAME FingerPrint_cCED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/FingerPrint_cCED_20.png ${TestOutput}/FingerPrint_cCED_20.png - CoherenceEnhancingDiffusionTest ${TestInput}/FingerPrint.png ${TestOutput}/FingerPrint_cCED_20.png 20 0.02 cCED ) + --compare DATA{Baseline/FingerPrint_cCED_20.png} ${TestOutput}/FingerPrint_cCED_20.png + CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cCED_20.png 20 0.02 cCED ) itk_add_test(NAME FingerPrint_I COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/FingerPrint_I_20.png ${TestOutput}/FingerPrint_I_20.png - CoherenceEnhancingDiffusionTest ${TestInput}/FingerPrint.png ${TestOutput}/FingerPrint_I_20.png 20 0.02 Isotropic ) + --compare DATA{Baseline/FingerPrint_I_20.png} ${TestOutput}/FingerPrint_I_20.png + CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_I_20.png 20 0.02 Isotropic ) ################ fig : Cos3D ################ itk_add_test(NAME Cos3D_cCED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Cos3D_cCED.vtk ${TestOutput}/Cos3D_cCED.vtk - CoherenceEnhancingDiffusionTest ${TestInput}/Cos3D_Noisy.vtk ${TestOutput}/Cos3D_cCED.vtk 10 0.02 cCED 4 10 ) + --compare DATA{Baseline/Cos3D_cCED.vtk} ${TestOutput}/Cos3D_cCED.vtk + CoherenceEnhancingDiffusionTest DATA{Input/Cos3D_Noisy.vtk} ${TestOutput}/Cos3D_cCED.vtk 10 0.02 cCED 4 10 ) ################ fig : Brain ################ itk_add_test(NAME mrbrain_cEED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/mrbrain_cEED.vtk ${TestOutput}/mrbrain_cEED.vtk - CoherenceEnhancingDiffusionTest ${TestInput}/mrbrain_noisy.vtk ${TestOutput}/mrbrain_cEED.vtk 5 0.003 cEED ) + --compare DATA{Baseline/mrbrain_cEED.vtk} ${TestOutput}/mrbrain_cEED.vtk + CoherenceEnhancingDiffusionTest DATA{Input/mrbrain_noisy.vtk} ${TestOutput}/mrbrain_cEED.vtk 5 0.003 cEED ) ################# fig : Lena ################ itk_add_test(NAME Lena_Detail_cCED_2 COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Lena_Detail_cCED_2.png ${TestOutput}/Lena_Detail_cCED_2.png - CoherenceEnhancingDiffusionTest ${TestInput}/Lena_Detail.png ${TestOutput}/Lena_Detail_cCED_2.png 2 0.003 cCED 0.5 2 4 ) - + --compare DATA{Baseline/Lena_Detail_cCED_2.png} ${TestOutput}/Lena_Detail_cCED_2.png + CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cCED_2.png 2 0.003 cCED 0.5 2 4 ) itk_add_test(NAME Lena_Detail_cEED_2 COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Lena_Detail_cEED_2.png ${TestOutput}/Lena_Detail_cEED_2.png - CoherenceEnhancingDiffusionTest ${TestInput}/Lena_Detail.png ${TestOutput}/Lena_Detail_cEED_2.png 2 0.003 cEED 0.5 2 4 ) + --compare DATA{Baseline/Lena_Detail_cEED_2.png} ${TestOutput}/Lena_Detail_cEED_2.png + CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cEED_2.png 2 0.003 cEED 0.5 2 4 ) itk_add_test(NAME Lena_Detail_I_2 COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Lena_Detail_I_2.png ${TestOutput}/Lena_Detail_I_2.png - CoherenceEnhancingDiffusionTest ${TestInput}/Lena_Detail.png ${TestOutput}/Lena_Detail_I_2.png 2 0.003 Isotropic 0.5 2 4 ) + --compare DATA{Baseline/Lena_Detail_I_2.png} ${TestOutput}/Lena_Detail_I_2.png + CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_I_2.png 2 0.003 Isotropic 0.5 2 4 ) ############## fig : Vector field ########### itk_add_test(NAME VectorField_Circle_cEED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/VectorField_Circle_cEED.vtk ${TestOutput}/VectorField_Circle_cEED.vtk - CoherenceEnhancingDiffusionTest ${TestInput}/VectorField_CircleOpposites.vtk ${TestOutput}/VectorField_Circle_cEED.vtk 10 0.05 cEED ) + --compare DATA{Baseline/VectorField_Circle_cEED.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk + CoherenceEnhancingDiffusionTest DATA{Input/VectorField_CircleOpposites.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk 10 0.05 cEED ) ############### fig : Triangle ############## itk_add_test(NAME Triangle_cEED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Triangle_cEED.png ${TestOutput}/Triangle_cEED.png - CoherenceEnhancingDiffusionTest ${TestInput}/Triangle.png ${TestOutput}/Triangle_cEED.png 5 0.03 cEED ) + --compare DATA{Baseline/Triangle_cEED.png} ${TestOutput}/Triangle_cEED.png + CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_cEED.png 5 0.03 cEED ) itk_add_test(NAME Triangle_EED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Triangle_EED.png ${TestOutput}/Triangle_EED.png - CoherenceEnhancingDiffusionTest ${TestInput}/Triangle.png ${TestOutput}/Triangle_EED.png 5 0.03 EED ) + --compare DATA{Baseline/Triangle_EED.png} ${TestOutput}/Triangle_EED.png + CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_EED.png 5 0.03 EED ) itk_add_test(NAME Oscillations1_cCED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Oscillations1_cCED.png ${TestOutput}/Oscillations1_cCED.png - CoherenceEnhancingDiffusionTest ${TestInput}/Oscillations_Noisy1.png ${TestOutput}/Oscillations1_cCED.png 20 0.05 cCED ) + --compare DATA{Baseline/Oscillations1_cCED.png} ${TestOutput}/Oscillations1_cCED.png + CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_cCED.png 20 0.05 cCED ) itk_add_test(NAME Oscillations1_CED COMMAND ${itk-module}TestDriver - --compare ${TestBaseline}/Oscillations1_CED.png ${TestOutput}/Oscillations1_CED.png - CoherenceEnhancingDiffusionTest ${TestInput}/Oscillations_Noisy1.png ${TestOutput}/Oscillations1_CED.png 20 0.05 CED ) + --compare DATA{Baseline/Oscillations1_CED.png} ${TestOutput}/Oscillations1_CED.png + CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_CED.png 20 0.05 CED ) From 888f1e1698af8b868e9f6b9314c6d7da4bef7c68 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 23:17:09 -0400 Subject: [PATCH 09/76] STYLE: Rename header files to have the itk prefix. Also fix trailing whitespace, indentation, some comments. --- .../AnisotropicDiffusionLBRImageFilter.h | 110 ----- .../AnisotropicDiffusionLBRImageFilter.hxx | 118 ----- .../CoherenceEnhancingDiffusionCommandLine.h | 2 +- .../CoherenceEnhancingDiffusionFilter.h | 120 ----- .../LinearAnisotropicDiffusionCommandLine.h | 45 +- ...LinearAnisotropicDiffusionLBRImageFilter.h | 145 ------ ...nearAnisotropicDiffusionLBRImageFilter.hxx | 432 ------------------ .../include/StructureTensorImageFilter.h | 91 ---- .../include/StructureTensorImageFilter.hxx | 157 ------- .../UnaryFunctorWithIndexImageFilter.h | 66 --- .../itkAnisotropicDiffusionLBRImageFilter.h | 112 +++++ .../itkAnisotropicDiffusionLBRImageFilter.hxx | 116 +++++ ...ro.h => itkAnisotropicDiffusionLBRMacro.h} | 6 +- .../itkCoherenceEnhancingDiffusionFilter.h | 121 +++++ ...LinearAnisotropicDiffusionLBRImageFilter.h | 145 ++++++ ...nearAnisotropicDiffusionLBRImageFilter.hxx | 431 +++++++++++++++++ .../include/itkStructureTensorImageFilter.h | 95 ++++ .../include/itkStructureTensorImageFilter.hxx | 159 +++++++ .../itkUnaryFunctorWithIndexImageFilter.h | 68 +++ 19 files changed, 1274 insertions(+), 1265 deletions(-) delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.h delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.hxx delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionFilter.h delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.h delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.hxx delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.h delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.hxx delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/UnaryFunctorWithIndexImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx rename Modules/Filtering/AnisotropicDiffusionLBR/include/{Macro.h => itkAnisotropicDiffusionLBRMacro.h} (85%) create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.h deleted file mode 100644 index ad663abf85f..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.h +++ /dev/null @@ -1,110 +0,0 @@ -// -// AnisotropicDiffusionLBRImageFilter.h -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 28/02/2014. -// -// - -#ifndef itkDiffusion_AnisotropicDiffusionLBRImageFilter_h -#define itkDiffusion_AnisotropicDiffusionLBRImageFilter_h - -#include "LinearAnisotropicDiffusionLBRImageFilter.h" -#include "StructureTensorImageFilter.h" -//#include "itkVectorMagnitudeImageFilter.h" -//#include "itkRescaleIntensityImageFilter.h" - -namespace itk -{ - /** Implementation of Non-linear Anisotropic Diffusion. - This class repeatedly calls the LinearAnisotropicDiffusionLBRImageFilter, with non-linear diffusion tensors built on the fly. These tensors are obtained by computing the image structure tensors, and appropriately modifying their eigenvalues with the method EigenValuesTransform. The latter method is not implemented, and needs to be provided in a subclass, such as CoherenceEnhancingDiffusionFilter.h - */ - template - class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage> - { - public: - typedef AnisotropicDiffusionLBRImageFilter Self; - typedef ImageToImageFilter< TImage, TImage> Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; - - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(AnisotropicDiffusionLBRImageFilter, Superclass); - - typedef TImage ImageType; - static const unsigned int Dimension = ImageType::ImageDimension; - - typedef typename ImageType::PixelType PixelType; - typedef TScalar ScalarType; - - typedef SymmetricSecondRankTensor TensorType; - typedef Image TensorImageType; - - typedef StructureTensorImageFilter StructureTensorFilterType; - typedef LinearAnisotropicDiffusionLBRImageFilter LinearDiffusionFilterType; - - - itkSetMacro(NoiseScale, ScalarType); /// Passed to a StructureTensorImageFilter. - itkGetConstMacro(NoiseScale, ScalarType); - itkSetMacro(FeatureScale, ScalarType); /// Passed to a StructureTensorImageFilter. - itkGetConstMacro(FeatureScale, ScalarType); - - itkSetMacro(RatioToMaxStableTimeStep, ScalarType); /// Passed to a LinearAnisotropicDiffusion Filter. - itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); - itkSetMacro(MaxTimeStepsBetweenTensorUpdates, int); - itkGetConstMacro(MaxTimeStepsBetweenTensorUpdates, int); - - itkSetMacro(DiffusionTime, ScalarType); - itkGetConstMacro(DiffusionTime, ScalarType); - - ///If true, uses unit pixel spacing, and rescales structure tensors for uni maximum trace.. - itkSetMacro(Adimensionize, bool); - itkGetConstMacro(Adimensionize, bool); - - - typedef typename TensorType::EigenValuesArrayType EigenValuesArrayType; - /// Transformation of the Structure tensor eigenvalues into the diffusion tensor eigenvalues. Needs to be overloaded in a subclass. (Structure tensor eigenvalues are sorted by increasing order for convenience). - virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const - {itkExceptionMacro("Undefined tensor eigenvalues transform");}; - - virtual typename TensorImageType::Pointer GetLastTensorImage(){return tensorImage;} - typedef std::vector< std::pair > EffectiveTimesAndIterationsType; - itkGetConstReferenceMacro(LinearFilterEffectiveTimesAndIterations, EffectiveTimesAndIterationsType); - - protected: - ScalarType m_NoiseScale, m_FeatureScale; - - ScalarType m_RatioToMaxStableTimeStep; - int m_MaxTimeStepsBetweenTensorUpdates; - - AnisotropicDiffusionLBRImageFilter(){ - m_DiffusionTime=1; - m_Adimensionize=true; - - m_NoiseScale=0.5; - m_FeatureScale=2; - - m_RatioToMaxStableTimeStep=0.7; - m_MaxTimeStepsBetweenTensorUpdates=5; - }; - ~AnisotropicDiffusionLBRImageFilter(){}; - - typename TensorImageType::Pointer tensorImage; - virtual void ComputeDiffusionTensors(ImageType*); - - - ScalarType m_DiffusionTime; - bool m_Adimensionize; - - virtual void GenerateData(); - - EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; - - struct DiffusionTensorFunctor; - }; -} - -#include "AnisotropicDiffusionLBRImageFilter.hxx" -#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.hxx deleted file mode 100644 index dd7f6c07125..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/AnisotropicDiffusionLBRImageFilter.hxx +++ /dev/null @@ -1,118 +0,0 @@ -// -// AnisotropicDiffusionLBRImageFilter.hxx -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 28/02/2014. -// -// - -#ifndef itkDiffusion_AnisotropicDiffusionLBRImageFilter_hxx -#define itkDiffusion_AnisotropicDiffusionLBRImageFilter_hxx - -namespace itk { - - template - void AnisotropicDiffusionLBRImageFilter::GenerateData(){ - typename ImageType::Pointer inputImage=const_cast(this->GetInput()); - typename ImageType::Pointer image = inputImage; - - typedef typename ImageType::SpacingType SpacingType; - const SpacingType referenceSpacing = inputImage->GetSpacing(); - - // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. - double minSpacing = referenceSpacing[0]; - for(int i=1; i<(int)Dimension; ++i) minSpacing = std::min(minSpacing,referenceSpacing[i]); - const SpacingType unitSpacing = referenceSpacing/minSpacing; - - if(m_Adimensionize) inputImage->SetSpacing(unitSpacing); - - ScalarType remainingTime = m_DiffusionTime; - - while(remainingTime>0){ - ComputeDiffusionTensors(image); - typename LinearDiffusionFilterType::Pointer linearDiffusionFilter = LinearDiffusionFilterType::New(); - linearDiffusionFilter->SetMaxNumberOfTimeSteps(m_MaxTimeStepsBetweenTensorUpdates); - linearDiffusionFilter->SetRatioToMaxStableTimeStep(m_RatioToMaxStableTimeStep); - - linearDiffusionFilter->SetInputImage(image); - linearDiffusionFilter->SetInputTensor(tensorImage); - linearDiffusionFilter->SetMaxDiffusionTime(remainingTime); - linearDiffusionFilter->Update(); - image = linearDiffusionFilter->GetOutput(); - remainingTime -= linearDiffusionFilter->GetEffectiveDiffusionTime(); - - m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair(linearDiffusionFilter->GetEffectiveDiffusionTime(),linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); - - this->UpdateProgress(1.-remainingTime/m_DiffusionTime); - } - - if(m_Adimensionize) { - inputImage->SetSpacing(referenceSpacing); - image->SetSpacing(referenceSpacing); - } - this->GraftOutput(image); - } - - - - template - struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor { - Self * eigenValuesFunctor; - struct OrderingType; - TensorType operator()(const TensorType & S){ - EigenValuesArrayType eigenValues; - typename TensorType::EigenVectorsMatrixType eigenVectors; - S.ComputeEigenAnalysis(eigenValues,eigenVectors); - - // For convenience, eigenvalues are sorted by increasing order - Vector order; - for(int i=0; i<(int)Dimension; ++i) order[i]=i; - - OrderingType ordering(eigenValues); - - std::sort(order.Begin(), order.End(),ordering); - - std::sort(eigenValues.Begin(), eigenValues.End()); - EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); - - TensorType DiffusionTensor; - for(int i=0; i<(int)Dimension; ++i){ - DiffusionTensor(order[i],order[i]) = ev[i]; - for(int j=0; jbool {return eigenValues[i] - struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor::OrderingType { - bool operator()(int i, int j) const {return this->e[i]e[j];} - const EigenValuesArrayType & e; - OrderingType(const EigenValuesArrayType & e_):e(e_){}; - }; - - template - void AnisotropicDiffusionLBRImageFilter::ComputeDiffusionTensors(ImageType*image){ - typename StructureTensorFilterType::Pointer structureTensorFilter = StructureTensorFilterType::New(); - - structureTensorFilter->SetNoiseScale(m_NoiseScale); - structureTensorFilter->SetFeatureScale(m_FeatureScale); - structureTensorFilter->SetRescaleForUnitMaximumTrace(m_Adimensionize); - structureTensorFilter->SetInput(image); - - typedef UnaryFunctorImageFilter ImageFunctorType; - typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); - imageFunctor->GetFunctor().eigenValuesFunctor = this; - imageFunctor->SetInput(structureTensorFilter->GetOutput()); - - imageFunctor->Update(); - tensorImage=imageFunctor->GetOutput(); - } - -} - - - - -#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 4c71fa8e339..47a0ec6c7ed 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -11,7 +11,7 @@ #include "itkImageFileReader.h" #include "itkImageFileWriter.h" -#include "CoherenceEnhancingDiffusionFilter.h" +#include "itkCoherenceEnhancingDiffusionFilter.h" #include "LinearAnisotropicDiffusionCommandLine.h" namespace CoherenceEnhancingDiffusionCommandLine { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionFilter.h deleted file mode 100644 index 11e99e2f4a1..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionFilter.h +++ /dev/null @@ -1,120 +0,0 @@ -// -// CoherenceEnhancingDiffusionFilter.h -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 06/03/2014. -// -// - -#ifndef itkDiffusion_CoherenceEnhancingDiffusionFilter_h -#define itkDiffusion_CoherenceEnhancingDiffusionFilter_h - -#include "AnisotropicDiffusionLBRImageFilter.h" - - -namespace itk { -/** - Implementation of Coherence Enhancing Diffusion (CED), and Edge Enhancing Diffusion (EED), as described by Weickert. CED heuristically smoothes everywhere except accross image contours, while EED smoothes nowhere but tangentially to image contours. - - The non-linear diffusion tensor is defined in terms of the structure tensor. - Denote by \f$\mu_i\f$ the structure tensor eigenvalues, at a given point \f$x\f$, with \f$0\leq i < d\f$. Let also \f$\mu_{\rm min}\f$ and \f$\mu_{\rm max}\f$, be the smallest and largest eigenvalues respectively. The diffusion tensor is defined by the same eigenvectors, but with modified with eigenvalues \f$\lambda_i\f$. - - Coherence Enhancing Diffusion : \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$.\br - - Edge enhancing diffusion \f$\lambda_i := g(\mu_{\rm max} - \mu_i)\f$, where \f$g(s) = \alpha + (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = \alpha\f$, \f$g(\infty) = 1\f$. - */ - template - class CoherenceEnhancingDiffusionFilter : public AnisotropicDiffusionLBRImageFilter { - public: - typedef CoherenceEnhancingDiffusionFilter Self; - typedef AnisotropicDiffusionLBRImageFilter Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; - - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(CoherenceEnhancingDiffusionFilter, Superclass); - - typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; - virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const; - - typedef typename Superclass::ScalarType ScalarType; - /// Exponent m involved in the function g defining eigenvalues. - itkSetMacro(Exponent, ScalarType); - itkSetMacro(Lambda, ScalarType); - itkSetMacro(Alpha, ScalarType); - - itkGetMacro(Exponent, ScalarType); - itkGetMacro(Lambda, ScalarType); - itkGetMacro(Alpha, ScalarType); - - enum EnhancementType {CED, cCED, EED, cEED, Isotropic}; - /// Switch between CED, EED, and variants. - itkSetEnumMacro(Enhancement, EnhancementType); - itkGetEnumMacro(Enhancement, EnhancementType); - - protected: - ScalarType m_Lambda; - ScalarType m_Exponent; - ScalarType m_Alpha; - EnhancementType m_Enhancement; - - ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} - ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} - - CoherenceEnhancingDiffusionFilter(){ - m_Lambda = 0.05; - m_Exponent = 2; - m_Alpha = 0.01; - m_Enhancement = CED; - } - }; - - template - typename CoherenceEnhancingDiffusionFilter::EigenValuesArrayType - CoherenceEnhancingDiffusionFilter::EigenValuesTransform(const EigenValuesArrayType & ev0) const { - static const int Dimension = Superclass::Dimension; - const ScalarType evMin = ev0[0], evMax = ev0[Dimension-1]; - EigenValuesArrayType ev; - switch(m_Enhancement){ - - // Weickert's filter. - case CED: - for(int i=0; iGetNameOfClass() << " has completed: " << int(100*dynamic_cast(object)->GetProgress()) @@ -60,21 +61,21 @@ int Execute(int argc, char * argv[]) using std::cerr; using std::endl; using namespace itk; - + if(argc<4+1) {Usage(); return EXIT_SUCCESS ;} - + const char *imageFileName =argv[0+1]; typedef ImageFileReader > ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFileName); - + reader->UpdateOutputInformation(); - + const ImageIOBase * io = reader->GetImageIO(); const int ImageDimension = io->GetNumberOfDimensions(); const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); const int nComponents = io->GetNumberOfComponents(); - + { const char *tensorFileName = argv[1+1]; ReaderType::Pointer reader2 = ReaderType::New(); @@ -91,7 +92,7 @@ int Execute(int argc, char * argv[]) if(io2->GetPixelType() == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR) std::cerr << "Warning: tensor image pixel type not marked as Symmetric Second Rank Tensor.\n"; } - + switch (ImageDimension) { case 2: return Execute<2>(argc,argv,componentType,nComponents); // case 3: return Execute<3>(argc,argv,componentType,nComponents); @@ -121,7 +122,7 @@ int Execute(int argc, char * argv[], int nComponents){ template int Execute(int argc, char * argv[]){ - + // Import image typedef Image ImageType; typedef ImageFileReader ReaderType; @@ -136,14 +137,14 @@ int Execute(int argc, char * argv[]){ typename TensorReaderType::Pointer tensorReader = TensorReaderType::New(); const char * tensorImageFileName = argv[1+1]; tensorReader->SetFileName(tensorImageFileName); - + // Import diffusion time const double diffusionTime = atof(argv[2+1]); if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); - + // Import output image filename const char *outputFileName = argv[3+1]; - + // Setup diffusion filter typedef LinearAnisotropicDiffusionLBRImageFilter DiffusionFilterType; typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); @@ -164,22 +165,22 @@ int Execute(int argc, char * argv[]){ diffusionFilter->SetMaxNumberOfTimeSteps(maxNumberOfTimeSteps); } else diffusionFilter->SetMaxNumberOfTimeSteps(200); - + ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); - + typedef Image ExportImageType; typedef CastImageFilter CasterType; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(diffusionFilter->GetOutput()); - + //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; typedef ImageFileWriter WriterType; typename WriterType::Pointer writer = WriterType::New(); writer->SetInput(caster->GetOutput()); writer->SetFileName(outputFileName); writer->Update(); - + const ScalarType effectiveDiffusionTime=diffusionFilter->GetEffectiveDiffusionTime(); if(effectiveDiffusionTime < 0.99 * diffusionTime){ std::cerr << @@ -187,10 +188,10 @@ int Execute(int argc, char * argv[]){ ", you may want to increase the max number of time steps: " << diffusionFilter->GetMaxNumberOfTimeSteps() << "\n"; Usage(); } - - return EXIT_SUCCESS; + return EXIT_SUCCESS; } -} + +} // end namespace LinearAnisotropicDiffusionCommandLine #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.h deleted file mode 100644 index dcca0b5da7f..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.h +++ /dev/null @@ -1,145 +0,0 @@ -// -// LinearAnisotropicDiffusionLBRImageFilter.h -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 28/02/2014. -// -// - -#ifndef itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_h -#define itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_h - - -#include "itkImageToImageFilter.h" - -namespace itk -{ - /** - Implementation of Anisotropic Diffusion - \f[\partial_t u = {\rm div} (D \nabla u),\f] - with Neumann boundary conditions. The numerical scheme is stable and satisfies the maximum principle, even for strongly anisotropic tensors, thanks to an adaptive discretization using arithmetic techniques (Lattice Basis Reduction, LBR). - */ - template< - typename TImage, - typename TScalar = typename TImage::PixelType - > - class LinearAnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > - { - public: - /** Standard class typedefs. */ - typedef LinearAnisotropicDiffusionLBRImageFilter Self; - typedef ImageToImageFilter< TImage, TImage > Superclass; - typedef SmartPointer< Self > Pointer; - - /** Method for creation through the object factory. */ - itkNewMacro(Self); - - /** Run-time type information (and related methods). */ - itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); - - typedef TImage ImageType; - static const int Dimension = ImageType::ImageDimension; - typedef typename ImageType::PixelType PixelType; - - typedef TScalar ScalarType; - typedef SymmetricSecondRankTensor TensorType; - typedef Image TensorImageType; - typedef ImageRegion RegionType; - - void SetInputImage(const ImageType* image); - void SetInputTensor(const TensorImageType* tensorImage); - - void SetMaxDiffusionTime(ScalarType time); - itkGetConstMacro(DiffusionTime, ScalarType); - - void SetMaxNumberOfTimeSteps(int n); - itkGetConstMacro(MaxNumberOfTimeSteps, int); - - void SetRatioToMaxStableTimeStep(ScalarType ratio); - itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); - - itkGetConstMacro(EffectiveDiffusionTime, ScalarType); - itkGetConstMacro(EffectiveNumberOfTimeSteps, int); - - itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); - itkGetConstMacro(IterationsTimeCost, ScalarType); - protected: - LinearAnisotropicDiffusionLBRImageFilter(); - ~LinearAnisotropicDiffusionLBRImageFilter(){} - - typename ImageType::ConstPointer GetInputImage(); - typename TensorImageType::ConstPointer GetInputTensor(); - - typedef Index IndexType; - - // ******* Containers for the stencils used in the discretization - static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; - static const unsigned int StencilSize = 2*HalfStencilSize; - - typedef Vector StencilCoefficientsType; - typedef Offset OffsetType; - typedef Vector StencilOffsetsType; - - typedef int InternalSizeT; - typedef Vector StencilBufferIndicesType; - - // ****************** Stencil support ****************** - - template struct GetDiffusion; - - template struct GetDiffusion<2,Dummy>{ - static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); - }; - - template struct GetDiffusion<3,Dummy>{ - static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); - }; - - // *************** Computation ***************** - virtual void GenerateData(); - virtual void GenerateStencils(); /// Automatically called by GenerateData - virtual void ImageUpdateLoop(); /// Automatically called by GenerateData - - typedef std::pair StencilType; - typedef Image StencilImageType; - typename StencilImageType::Pointer stencilImage; - - typedef Image ScalarImageType; - typename ScalarImageType::Pointer diagonalCoefficients; - - virtual ScalarType MaxStableTimeStep(); - - ScalarType m_DiffusionTime; - ScalarType m_RatioToMaxStableTimeStep; - int m_MaxNumberOfTimeSteps; - - ScalarType m_EffectiveDiffusionTime; - int m_EffectiveNumberOfTimeSteps; - - virtual void ImageUpdate(ScalarType delta); - typename ImageType::Pointer previousImage, nextImage; - - virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} - - InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} - - ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; - - - struct StencilFunctor; - struct FunctorType; - - typedef Vector VectorType; - static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); - private: - LinearAnisotropicDiffusionLBRImageFilter(const Self &); //purposely not implemented - void operator=(const Self &); //purposely not implemented - }; -} //namespace ITK - - -#ifndef ITK_MANUAL_INSTANTIATION -#include "LinearAnisotropicDiffusionLBRImageFilter.hxx" -#endif - -#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.hxx deleted file mode 100644 index d2758981f46..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionLBRImageFilter.hxx +++ /dev/null @@ -1,432 +0,0 @@ -// -// LinearAnisotropicDiffusionLBRImageFilter.hxx -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 28/02/2014. -// -// - -#ifndef itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_hxx -#define itkDiffusion_LinearAnisotropicDiffusionLBRImageFilter_hxx - -#include "itkUnaryFunctorImageFilter.h" -#include "itkImageRegionIterator.h" -#include "itkMinimumMaximumImageCalculator.h" -#include "itkCastImageFilter.h" -#include "itkExtractImageFilter.h" -#include "sys/time.h" - - -#include "UnaryFunctorWithIndexImageFilter.h" -#include "itkTernaryFunctorImageFilter.h" - -namespace itk -{ - - template - LinearAnisotropicDiffusionLBRImageFilter::LinearAnisotropicDiffusionLBRImageFilter() - { - this->SetNumberOfRequiredInputs(2); - m_DiffusionTime = 1; - m_RatioToMaxStableTimeStep = 0.7; - m_MaxNumberOfTimeSteps = 10; - - m_EffectiveDiffusionTime=0; - m_EffectiveNumberOfTimeSteps=0; - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::SetInputImage(const ImageType* image) - { - this->SetNthInput(0, const_cast(image)); - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::SetInputTensor(const TensorImageType* tensorImage) - { - this->SetNthInput(1, const_cast(tensorImage)); - } - - template - typename TI::ConstPointer LinearAnisotropicDiffusionLBRImageFilter::GetInputImage() - { - return static_cast< const ImageType * > - ( this->ProcessObject::GetInput(0) ); - } - - template - typename LinearAnisotropicDiffusionLBRImageFilter::TensorImageType::ConstPointer - LinearAnisotropicDiffusionLBRImageFilter::GetInputTensor() - { - return static_cast< const TensorImageType * > - ( this->ProcessObject::GetInput(1) ); - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::GenerateData() - { - timeval start, end; - gettimeofday(&start, NULL); // nullptr is not accepted by older compilers - - GenerateStencils(); - this->UpdateProgress(0.5); - - gettimeofday(&end, NULL); - m_SparseMatrixAssemblyTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; - start=end; - - - ImageUpdateLoop(); - - gettimeofday(&end, NULL); - m_IterationsTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; - } - -// **************************** Computation *********************** - template - struct LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor { - typedef typename TensorImageType::SpacingType SpacingType; - void Initialize(RegionType region_, SpacingType spacing){ - region = region_; - prod[0]=1; - for(int i=1; iprod[i]*(x[i]-this->region.GetIndex()[i]); - return ans; - } - - StencilType operator()(const TensorType & tensor, const IndexType & x) const { - StencilType stencil; - StencilOffsetsType offsets; - - // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. - - TensorType D; - for(int i=0; iinvSpacing[i]*this->invSpacing[j]; - GetDiffusion<>::Stencil(D,offsets,stencil.second); - - InternalSizeT * yIndex = &stencil.first[0]; - - //Compute buffer offsets from geometrical offsets - for(int i=0; i<(int)HalfStencilSize; ++i){ - for(int orientation = 0; orientation<2; ++orientation, ++yIndex){ - const IndexType y = orientation ? x-offsets[i] : x+offsets[i]; - if(this->region.IsInside(y)){ - *yIndex = this->BufferIndex(y); - } else { - // Neumann boundary conditions. - *yIndex = this->OutsideBufferIndex(); - } // if y - } // for eps - } // for i - return stencil; - } - protected: - RegionType region; - IndexType prod; - SpacingType invSpacing; - InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} - }; - - template - void LinearAnisotropicDiffusionLBRImageFilter::GenerateStencils(){ - - // Stencil type is a pair type because itk::UnaryFunctorImage filter - // only produces one output -// typedef typename TensorImageType::SpacingType SpacingType; - const RegionType region = GetRequestedRegion(); - - typedef UnaryFunctorWithIndexImageFilter FunctorFilterType; - typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); - filter->SetInput(GetInputTensor()); - filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); - filter->Update(); - stencilImage = filter->GetOutput(); - - - //setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. - - diagonalCoefficients = ScalarImageType::New(); - diagonalCoefficients->CopyInformation(GetInputTensor()); - diagonalCoefficients->SetRegions(GetRequestedRegion()); - diagonalCoefficients->Allocate(); - diagonalCoefficients->FillBuffer(ScalarType(0)); - - ImageRegionConstIterator stencilIt(stencilImage,region); - ImageRegionIterator diagIt(diagonalCoefficients, region); - ScalarType * diagBuffer = diagonalCoefficients->GetBufferPointer(); - - for(stencilIt.GoToBegin(), diagIt.GoToBegin(); - !stencilIt.IsAtEnd(); - ++stencilIt, ++diagIt) - for(int i=0; i<(int)StencilSize; ++i) { - const InternalSizeT yIndex = stencilIt.Value().first[i]; - if(yIndex!=OutsideBufferIndex()){ - const ScalarType coefficient = stencilIt.Value().second[i/2]; - diagIt.Value() += coefficient; - diagBuffer[yIndex] += coefficient; - } // if y - } // for i - // for stencilIt, diagIt - } - - template - typename LinearAnisotropicDiffusionLBRImageFilter::ScalarType - LinearAnisotropicDiffusionLBRImageFilter::MaxStableTimeStep(){ - typedef MinimumMaximumImageCalculator MaxCalculatorType; - typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); - maximumCalculator->SetImage(diagonalCoefficients); - maximumCalculator->SetRegion(GetRequestedRegion()); - maximumCalculator->ComputeMaximum(); - return 1./maximumCalculator->GetMaximum(); - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::SetMaxDiffusionTime(ScalarType time){ - if(time<0) - itkExceptionMacro("diffusion time must be finite and positive"); - m_DiffusionTime = time; - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::SetRatioToMaxStableTimeStep(ScalarType ratio){ - if(ratio<=0 || ratio>1) - itkExceptionMacro("Ratio to max time step " << ratio << "should be within ]0,1]"); - m_RatioToMaxStableTimeStep=ratio; - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::SetMaxNumberOfTimeSteps(int n){ - if(n<=0) - itkExceptionMacro("Max number of time steps must be positive"); - m_MaxNumberOfTimeSteps=n; - } - - template - void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdateLoop(){ - ScalarType delta = MaxStableTimeStep() * m_RatioToMaxStableTimeStep; - int n = ceil(m_DiffusionTime / delta); - if(n>m_MaxNumberOfTimeSteps) { - n=m_MaxNumberOfTimeSteps; - m_EffectiveDiffusionTime = n*delta; - } else { - delta = m_DiffusionTime/n; - m_EffectiveDiffusionTime = m_DiffusionTime; - } - m_EffectiveNumberOfTimeSteps=n; - - // Extraction of the region of interest is required for image buffer access. - typedef ExtractImageFilter InputCasterType; - typename InputCasterType::Pointer inputCaster = InputCasterType::New(); - inputCaster->SetInput(GetInputImage()); - inputCaster->SetExtractionRegion(GetRequestedRegion()); - inputCaster->SetDirectionCollapseToIdentity(); - inputCaster->Update(); - previousImage = inputCaster->GetOutput(); - - nextImage = ImageType::New(); - nextImage->CopyInformation(previousImage); - nextImage->SetRegions(previousImage->GetBufferedRegion()); - nextImage->Allocate(); - - for(int k=0; kUpdateProgress(0.5+0.5*k/float(n)); - } - this->GraftOutput(previousImage); - } - - template - struct LinearAnisotropicDiffusionLBRImageFilter::FunctorType { - ScalarType delta; - PixelType operator()(PixelType output, PixelType input, ScalarType diag){ - return output*this->delta + input*(ScalarType(1)-this->delta*diag); - } - }; - - template - void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdate(ScalarType delta){ - - //Setting up iterators - - ImageRegion region = GetRequestedRegion(); - - ImageRegionConstIterator inputIt(previousImage,region); - ImageRegionIterator outputIt(nextImage,region); - - const PixelType * inputBuffer = previousImage->GetBufferPointer(); - PixelType * outputBuffer = nextImage->GetBufferPointer(); - - ImageRegionConstIterator diagIt(diagonalCoefficients, region); - ImageRegionConstIterator stencilIt(stencilImage, region); - - // Rest of function is a hand-made (sparse matrix)*vector product. - nextImage->FillBuffer(0.); - - // Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer - for(inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); - !inputIt.IsAtEnd(); - ++inputIt, ++outputIt, ++stencilIt){ - for(int i=0; i<(int)StencilSize; ++i){ - const InternalSizeT yIndex = stencilIt.Value().first[i]; - if(yIndex!=OutsideBufferIndex()){ - const ScalarType coefficient = stencilIt.Value().second[i/2]; - outputIt.Value() += coefficient * (inputBuffer[yIndex]); - outputBuffer[yIndex] += coefficient * inputIt.Value(); - } - } - } - - typedef TernaryFunctorImageFilter ImageFunctorType; - typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); - imageFunctor->SetInput1(nextImage); - imageFunctor->SetInput2(previousImage); - imageFunctor->SetInput3(diagonalCoefficients); - imageFunctor->GetFunctor().delta = delta; - - assert(imageFunctor->CanRunInPlace()); - imageFunctor->InPlaceOn(); - imageFunctor->Update(); - nextImage=imageFunctor->GetOutput(); - - /* - // Old Serial version for diagonal elements - for(inputIt.GoToBegin(), outputIt.GoToBegin(), diagIt.GoToBegin(); - !inputIt.IsAtEnd(); - ++inputIt, ++outputIt, ++diagIt) - outputIt.Value() = delta*outputIt.Value() + (1-delta*diagIt.Value())*inputIt.Value(); - */ - } - -// **************************** subclass SSRT_Traits call method ************************** - -template -TS -LinearAnisotropicDiffusionLBRImageFilter::ScalarProduct(const TensorType & m, - const VectorType & u, - const VectorType & v){ - ScalarType result(0); - for(int i=0; i template -void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<2,Dummy>:: -Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ - - // Construct a superbase, and make it obtuse with Selling's algorithm - VectorType sb[Dimension+1]; //SuperBase - for(int i=0; i 0 ){ - const VectorType u=sb[i], v=sb[j]; - sb[0]=v-u; - sb[1]=u; - sb[2]=-v; - same=false; - } - if(same) break; - } - if(iter==maxIter) - std::cerr << "Warning: Selling's algorithm not stabilized.\n"; - - for(int i=0; i<3; ++i){ - Coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); - assert(Coefficients[i]>=0); - - Offsets[i][0] = static_cast(-sb[i][1]); - Offsets[i][1] = static_cast( sb[i][0]); - } - -} // 2D stencil construction - - - // 3D stencil construction -template template -void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<3,Dummy>:: -Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ - - // Construct a superbase, and make it obtuse with Selling's algorithm - typedef Vector VectorType; - VectorType sb[Dimension+1]; - for(int i=0; i 0 ){ - const VectorType u=sb[i], v=sb[j]; - for(int k=0,l=0; k<=Dimension; ++k) - if(k!=i && k!=j) - sb[l++]=sb[k]+u; - sb[2]=-u; - sb[3]=v; - same=false; - } - if(same) break; - } - if(iter==maxIter) - std::cerr << "Warning: Selling's algorithm not stabilized.\n"; - - // Computation of the weights - itk::SymmetricSecondRankTensor Weights; - for(int i=1; i, - TImage::ImageDimension> - > - class StructureTensorImageFilter : public ImageToImageFilter { - public: - typedef StructureTensorImageFilter Self; - typedef ImageToImageFilter< TImage, TImage> Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; - - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(StructureTensorImageFilter, Superclass); - - typedef TImage ImageType; - typedef typename ImageType::PixelType PixelType; - static const unsigned int Dimension = ImageType::ImageDimension; - typedef TTensorImage TensorImageType; - typedef typename TensorImageType::PixelType TensorType; - typedef typename TensorType::ComponentType ScalarType; - typedef Image ScalarImageType; - - ///Parameter \f$\sigma\f$ of the structure tensor definition. - itkSetMacro(NoiseScale, ScalarType); - ///Parameter \f$\rho\f$ of the structure tensor definition. - itkSetMacro(FeatureScale, ScalarType); - ///Rescales all structure tensors by a common factor, so that the maximum trace is 1. - itkSetMacro(RescaleForUnitMaximumTrace, bool); - - itkGetConstMacro(NoiseScale, ScalarType); - itkGetConstMacro(FeatureScale, ScalarType); - itkGetConstMacro(RescaleForUnitMaximumTrace, bool); - itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. - - bool m_UseGradientRecursiveGaussianImageFilter; - protected: - virtual void GenerateData(); - - ScalarType m_FeatureScale, m_NoiseScale; - bool m_RescaleForUnitMaximumTrace; - ScalarType m_PostRescaling; - - template::is_specialized> - struct IntermediateFilter; - typename TensorImageType::Pointer intermediateResult; - - typedef CovariantVector CovariantVectorType; - typedef Image CovariantImageType; - - struct OuterFunctor; - struct TraceFunctor; - struct ScaleFunctor; - - StructureTensorImageFilter(){ - m_FeatureScale=2; - m_NoiseScale=1; - m_RescaleForUnitMaximumTrace=false; - m_UseGradientRecursiveGaussianImageFilter=true; - } - }; -} - -#include "StructureTensorImageFilter.hxx" - -#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.hxx deleted file mode 100644 index 37c2bb8a72e..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/StructureTensorImageFilter.hxx +++ /dev/null @@ -1,157 +0,0 @@ -// -// StructureTensorImageFilter.hxx -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 21/11/2014. -// -// - -#ifndef itkDiffusion_StructureTensorImageFilter_hxx -#define itkDiffusion_StructureTensorImageFilter_hxx - - -namespace itk { - template - struct StructureTensorImageFilter::OuterFunctor { - TensorType operator()(const CovariantVectorType & u) const { - TensorType m; - for(int i=0; i<(int)Dimension; ++i) - for(int j=i; j<(int)Dimension; ++j) - m(i,j) = u[i]*u[j]; - return m; - } - }; - - - template - template - struct StructureTensorImageFilter::IntermediateFilter { - void operator()(Self *self){ - typedef GradientRecursiveGaussianImageFilter GradientFilterType; - typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); - gradientFilter->SetInput(self->GetInput()); - gradientFilter->SetSigma(self->m_NoiseScale); - - typedef UnaryFunctorImageFilter OuterFilterType; - typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - outerFilter->SetInput(gradientFilter->GetOutput()); - - outerFilter->Update(); - self->intermediateResult = outerFilter->GetOutput(); - } - }; - - template - template - struct StructureTensorImageFilter::IntermediateFilter { - void operator()(Self *self){ - - typename ImageType::ConstPointer input = self->GetInput(); - typename TensorImageType::Pointer output = TensorImageType::New(); - output->CopyInformation(input); - output->SetRegions(input->GetRequestedRegion()); - output->Allocate(); - output->FillBuffer(TensorType(0.)); - - for(int index=0; index SelectionFilterType; - typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); - selectionFilter->SetIndex(index); - selectionFilter->SetInput(input); - - typedef RecursiveGaussianImageFilter GaussianFilterType; - typedef GradientImageFilter GradientFilterType; - typedef GradientRecursiveGaussianImageFilter GradientGaussianFilterType; - - typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); - typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); - - gaussianFilter->SetSigma(self->m_NoiseScale); - gradientGaussianFilter->SetSigma(self->m_NoiseScale); - - typedef UnaryFunctorImageFilter OuterFilterType; - typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - - if(self->m_UseGradientRecursiveGaussianImageFilter){ - gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); - outerFilter->SetInput(gradientGaussianFilter->GetOutput()); - } else { - gaussianFilter->SetInput(selectionFilter->GetOutput()); - gradientFilter->SetInput(gaussianFilter->GetOutput()); - outerFilter->SetInput(gradientFilter->GetOutput()); - } - - typedef AddImageFilter AddFilterType; - typename AddFilterType::Pointer addFilter = AddFilterType::New(); - addFilter->InPlaceOn(); - addFilter->SetInput1(output); - addFilter->SetInput2(outerFilter->GetOutput()); - addFilter->Update(); - output = addFilter->GetOutput(); - - self->UpdateProgress(index/float(PixelType::Dimension+1)); - } - self->intermediateResult = output; - } - }; - - - template - struct StructureTensorImageFilter::TraceFunctor { - ScalarType operator()(const TensorType & t) const { - return t.GetTrace(); - } - }; - - template - struct StructureTensorImageFilter::ScaleFunctor { - ScalarType scaling; - TensorType operator()(const TensorType & t) const { - return t*scaling; - } - }; - - template - void StructureTensorImageFilter::GenerateData(){ - IntermediateFilter<>()(this); - - typedef RecursiveGaussianImageFilter GaussianFilterType; - typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - gaussianFilter->SetInput(intermediateResult); - gaussianFilter->SetSigma(m_FeatureScale); - - if(!m_RescaleForUnitMaximumTrace){ - m_PostRescaling=1.; - gaussianFilter->Update(); - this->GraftOutput(gaussianFilter->GetOutput()); - return; - } - - // *** Rescaling for normalization of largest trace *** - - typedef UnaryFunctorImageFilter TraceFilterType; - typename TraceFilterType::Pointer traceFilter = TraceFilterType::New(); - traceFilter->SetInput(gaussianFilter->GetOutput()); - - typedef MinimumMaximumImageCalculator MaximumCalculatorType; - typename MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); - maximumCalculator->SetImage(traceFilter->GetOutput()); - - typedef UnaryFunctorImageFilter ScaleFilterType; - typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); - scaleFilter->SetInput(gaussianFilter->GetOutput()); - - traceFilter->Update(); - maximumCalculator->ComputeMaximum(); - m_PostRescaling = 1./maximumCalculator->GetMaximum(); - scaleFilter->GetFunctor().scaling = m_PostRescaling; - scaleFilter->Update(); - this->GraftOutput(scaleFilter->GetOutput()); - } -} - - -#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/UnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/UnaryFunctorWithIndexImageFilter.h deleted file mode 100644 index 2edcf30e073..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/UnaryFunctorWithIndexImageFilter.h +++ /dev/null @@ -1,66 +0,0 @@ -// -// UnaryFunctorWithIndexImageFilter.h -// itkDiffusion -// -// Created by Jean-Marie Mirebeau on 07/03/2014. -// -// - -#ifndef itkDiffusion_UnaryFunctorWithIndexImageFilter_h -#define itkDiffusion_UnaryFunctorWithIndexImageFilter_h - -#include "itkImageRegionConstIteratorWithIndex.h" -#include "itkImageScanlineIterator.h" -#include "Macro.h" -/** A (simplification of) UnaryFunctorImageFilter, which provides the pixel index to the functor. - */ - -namespace itk { - template - class UnaryFunctorWithIndexImageFilter : public ImageToImageFilter { - public: - typedef UnaryFunctorWithIndexImageFilter Self; - typedef ImageToImageFilter Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; - - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(UnaryFunctorWithIndexImageFilter, Superclass); - - typedef TInputImage InputImageType; - typedef TOutputImage OutputImageType; - typedef TFunctor FunctorType; - - GetSetFunctorMacro(Functor, FunctorType); - - protected: - UnaryFunctorWithIndexImageFilter(){}; - - FunctorType m_Functor; - - typedef typename InputImageType::RegionType InputRegionType; - typedef typename OutputImageType::RegionType OutputRegionType; - - virtual void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType){ - if(region.GetSize()[0]==0) return; - - ImageRegionConstIteratorWithIndex inputIt( this->GetInput(), region); - ImageScanlineIterator< OutputImageType > outputIt( this->GetOutput(), region); - - for(inputIt.GoToBegin(), outputIt.GoToBegin(); - !outputIt.IsAtEnd(); - ){ - while(!outputIt.IsAtEndOfLine()){ - outputIt.Set(m_Functor(inputIt.Value(), inputIt.GetIndex())); - ++inputIt; - ++outputIt; - } - outputIt.NextLine(); - } - } - }; -} - -#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h new file mode 100644 index 00000000000..fb3ec4062fb --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -0,0 +1,112 @@ +// +// AnisotropicDiffusionLBRImageFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkAnisotropicDiffusionLBRImageFilter_h +#define itkAnisotropicDiffusionLBRImageFilter_h + +#include "itkLinearAnisotropicDiffusionLBRImageFilter.h" +#include "itkStructureTensorImageFilter.h" + +namespace itk +{ + +/** Implementation of Non-linear Anisotropic Diffusion. + This class repeatedly calls the LinearAnisotropicDiffusionLBRImageFilter, with non-linear diffusion tensors built on the fly. These tensors are obtained by computing the image structure tensors, and appropriately modifying their eigenvalues with the method EigenValuesTransform. The latter method is not implemented, and needs to be provided in a subclass, such as CoherenceEnhancingDiffusionFilter.h +*/ +template +class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage> +{ +public: + typedef AnisotropicDiffusionLBRImageFilter Self; + typedef ImageToImageFilter< TImage, TImage> Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(AnisotropicDiffusionLBRImageFilter, Superclass); + + typedef TImage ImageType; + static const unsigned int Dimension = ImageType::ImageDimension; + + typedef typename ImageType::PixelType PixelType; + typedef TScalar ScalarType; + + typedef SymmetricSecondRankTensor TensorType; + typedef Image TensorImageType; + + typedef StructureTensorImageFilter StructureTensorFilterType; + typedef LinearAnisotropicDiffusionLBRImageFilter LinearDiffusionFilterType; + + + itkSetMacro(NoiseScale, ScalarType); /// Passed to a StructureTensorImageFilter. + itkGetConstMacro(NoiseScale, ScalarType); + itkSetMacro(FeatureScale, ScalarType); /// Passed to a StructureTensorImageFilter. + itkGetConstMacro(FeatureScale, ScalarType); + + itkSetMacro(RatioToMaxStableTimeStep, ScalarType); /// Passed to a LinearAnisotropicDiffusion Filter. + itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); + itkSetMacro(MaxTimeStepsBetweenTensorUpdates, int); + itkGetConstMacro(MaxTimeStepsBetweenTensorUpdates, int); + + itkSetMacro(DiffusionTime, ScalarType); + itkGetConstMacro(DiffusionTime, ScalarType); + + ///If true, uses unit pixel spacing, and rescales structure tensors for uni maximum trace.. + itkSetMacro(Adimensionize, bool); + itkGetConstMacro(Adimensionize, bool); + + + typedef typename TensorType::EigenValuesArrayType EigenValuesArrayType; + /// Transformation of the Structure tensor eigenvalues into the diffusion tensor eigenvalues. Needs to be overloaded in a subclass. (Structure tensor eigenvalues are sorted by increasing order for convenience). + virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const + {itkExceptionMacro("Undefined tensor eigenvalues transform");}; + + virtual typename TensorImageType::Pointer GetLastTensorImage(){return tensorImage;} + typedef std::vector< std::pair > EffectiveTimesAndIterationsType; + itkGetConstReferenceMacro(LinearFilterEffectiveTimesAndIterations, EffectiveTimesAndIterationsType); + +protected: + ScalarType m_NoiseScale, m_FeatureScale; + + ScalarType m_RatioToMaxStableTimeStep; + int m_MaxTimeStepsBetweenTensorUpdates; + + AnisotropicDiffusionLBRImageFilter(){ + m_DiffusionTime=1; + m_Adimensionize=true; + + m_NoiseScale=0.5; + m_FeatureScale=2; + + m_RatioToMaxStableTimeStep=0.7; + m_MaxTimeStepsBetweenTensorUpdates=5; + }; + ~AnisotropicDiffusionLBRImageFilter(){}; + + typename TensorImageType::Pointer tensorImage; + virtual void ComputeDiffusionTensors(ImageType*); + + + ScalarType m_DiffusionTime; + bool m_Adimensionize; + + virtual void GenerateData(); + + EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; + + struct DiffusionTensorFunctor; +}; +} + +#ifndef ITK_MANUAL_INSTANTIATION +#include "itkAnisotropicDiffusionLBRImageFilter.hxx" +#endif + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx new file mode 100644 index 00000000000..b86632df89e --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -0,0 +1,116 @@ +// +// AnisotropicDiffusionLBRImageFilter.hxx +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkAnisotropicDiffusionLBRImageFilter_hxx +#define itkAnisotropicDiffusionLBRImageFilter_hxx + +namespace itk +{ + +template +void AnisotropicDiffusionLBRImageFilter::GenerateData(){ + typename ImageType::Pointer inputImage=const_cast(this->GetInput()); + typename ImageType::Pointer image = inputImage; + + typedef typename ImageType::SpacingType SpacingType; + const SpacingType referenceSpacing = inputImage->GetSpacing(); + + // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. + double minSpacing = referenceSpacing[0]; + for(int i=1; i<(int)Dimension; ++i) minSpacing = std::min(minSpacing,referenceSpacing[i]); + const SpacingType unitSpacing = referenceSpacing/minSpacing; + + if(m_Adimensionize) inputImage->SetSpacing(unitSpacing); + + ScalarType remainingTime = m_DiffusionTime; + + while(remainingTime>0){ + ComputeDiffusionTensors(image); + typename LinearDiffusionFilterType::Pointer linearDiffusionFilter = LinearDiffusionFilterType::New(); + linearDiffusionFilter->SetMaxNumberOfTimeSteps(m_MaxTimeStepsBetweenTensorUpdates); + linearDiffusionFilter->SetRatioToMaxStableTimeStep(m_RatioToMaxStableTimeStep); + + linearDiffusionFilter->SetInputImage(image); + linearDiffusionFilter->SetInputTensor(tensorImage); + linearDiffusionFilter->SetMaxDiffusionTime(remainingTime); + linearDiffusionFilter->Update(); + image = linearDiffusionFilter->GetOutput(); + remainingTime -= linearDiffusionFilter->GetEffectiveDiffusionTime(); + + m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair(linearDiffusionFilter->GetEffectiveDiffusionTime(),linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); + + this->UpdateProgress(1.-remainingTime/m_DiffusionTime); + } + + if(m_Adimensionize) { + inputImage->SetSpacing(referenceSpacing); + image->SetSpacing(referenceSpacing); + } + this->GraftOutput(image); +} + + + +template +struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor { + Self * eigenValuesFunctor; + struct OrderingType; + TensorType operator()(const TensorType & S){ + EigenValuesArrayType eigenValues; + typename TensorType::EigenVectorsMatrixType eigenVectors; + S.ComputeEigenAnalysis(eigenValues,eigenVectors); + + // For convenience, eigenvalues are sorted by increasing order + Vector order; + for(int i=0; i<(int)Dimension; ++i) order[i]=i; + + OrderingType ordering(eigenValues); + + std::sort(order.Begin(), order.End(),ordering); + + std::sort(eigenValues.Begin(), eigenValues.End()); + EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); + + TensorType DiffusionTensor; + for(int i=0; i<(int)Dimension; ++i){ + DiffusionTensor(order[i],order[i]) = ev[i]; + for(int j=0; jbool {return eigenValues[i] +struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor::OrderingType { + bool operator()(int i, int j) const {return this->e[i]e[j];} + const EigenValuesArrayType & e; + OrderingType(const EigenValuesArrayType & e_):e(e_){}; +}; + +template +void AnisotropicDiffusionLBRImageFilter::ComputeDiffusionTensors(ImageType*image){ + typename StructureTensorFilterType::Pointer structureTensorFilter = StructureTensorFilterType::New(); + + structureTensorFilter->SetNoiseScale(m_NoiseScale); + structureTensorFilter->SetFeatureScale(m_FeatureScale); + structureTensorFilter->SetRescaleForUnitMaximumTrace(m_Adimensionize); + structureTensorFilter->SetInput(image); + + typedef UnaryFunctorImageFilter ImageFunctorType; + typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); + imageFunctor->GetFunctor().eigenValuesFunctor = this; + imageFunctor->SetInput(structureTensorFilter->GetOutput()); + + imageFunctor->Update(); + tensorImage=imageFunctor->GetOutput(); +} + +} // end namespace itk + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/Macro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h similarity index 85% rename from Modules/Filtering/AnisotropicDiffusionLBR/include/Macro.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h index d61d836bf31..930bc7fe60c 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/Macro.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h @@ -6,16 +6,16 @@ // // -#ifndef itkDiffusion_Macro_h -#define itkDiffusion_Macro_h +#ifndef itkAnisotropicDiffusionLBRMacro_h +#define itkAnisotropicDiffusionLBRMacro_h /** Getters and setters for functor types, inspired by UnaryFunctorImageFilter. No equality test performed for the setter. */ - #define GetSetFunctorMacro(name, type) \ virtual type & Get##name() {return this->m_##name;} \ virtual const type & Get##name() const {return this->m_##name;} \ virtual void Set##name(const type & _arg) {m_##name = _arg; this->Modified();} + #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h new file mode 100644 index 00000000000..a4bfa0cc255 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h @@ -0,0 +1,121 @@ +// +// CoherenceEnhancingDiffusionFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 06/03/2014. +// +// + +#ifndef itkCoherenceEnhancingDiffusionFilter_h +#define itkCoherenceEnhancingDiffusionFilter_h + +#include "itkAnisotropicDiffusionLBRImageFilter.h" + + +namespace itk +{ +/** + Implementation of Coherence Enhancing Diffusion (CED), and Edge Enhancing Diffusion (EED), as described by Weickert. CED heuristically smoothes everywhere except accross image contours, while EED smoothes nowhere but tangentially to image contours. + + The non-linear diffusion tensor is defined in terms of the structure tensor. + Denote by \f$\mu_i\f$ the structure tensor eigenvalues, at a given point \f$x\f$, with \f$0\leq i < d\f$. Let also \f$\mu_{\rm min}\f$ and \f$\mu_{\rm max}\f$, be the smallest and largest eigenvalues respectively. The diffusion tensor is defined by the same eigenvectors, but with modified with eigenvalues \f$\lambda_i\f$. + + Coherence Enhancing Diffusion : \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$.\br + + Edge enhancing diffusion \f$\lambda_i := g(\mu_{\rm max} - \mu_i)\f$, where \f$g(s) = \alpha + (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = \alpha\f$, \f$g(\infty) = 1\f$. + */ +template +class CoherenceEnhancingDiffusionFilter : public AnisotropicDiffusionLBRImageFilter { +public: + typedef CoherenceEnhancingDiffusionFilter Self; + typedef AnisotropicDiffusionLBRImageFilter Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(CoherenceEnhancingDiffusionFilter, Superclass); + + typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; + virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const; + + typedef typename Superclass::ScalarType ScalarType; + /// Exponent m involved in the function g defining eigenvalues. + itkSetMacro(Exponent, ScalarType); + itkSetMacro(Lambda, ScalarType); + itkSetMacro(Alpha, ScalarType); + + itkGetMacro(Exponent, ScalarType); + itkGetMacro(Lambda, ScalarType); + itkGetMacro(Alpha, ScalarType); + + enum EnhancementType {CED, cCED, EED, cEED, Isotropic}; + /// Switch between CED, EED, and variants. + itkSetEnumMacro(Enhancement, EnhancementType); + itkGetEnumMacro(Enhancement, EnhancementType); + +protected: + ScalarType m_Lambda; + ScalarType m_Exponent; + ScalarType m_Alpha; + EnhancementType m_Enhancement; + + ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} + ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} + + CoherenceEnhancingDiffusionFilter(){ + m_Lambda = 0.05; + m_Exponent = 2; + m_Alpha = 0.01; + m_Enhancement = CED; + } +}; + +template +typename CoherenceEnhancingDiffusionFilter::EigenValuesArrayType +CoherenceEnhancingDiffusionFilter::EigenValuesTransform(const EigenValuesArrayType & ev0) const { + static const int Dimension = Superclass::Dimension; + const ScalarType evMin = ev0[0], evMax = ev0[Dimension-1]; + EigenValuesArrayType ev; + switch(m_Enhancement){ + + // Weickert's filter. + case CED: + for(int i=0; i +class LinearAnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > +{ +public: + /** Standard class typedefs. */ + typedef LinearAnisotropicDiffusionLBRImageFilter Self; + typedef ImageToImageFilter< TImage, TImage > Superclass; + typedef SmartPointer< Self > Pointer; + + /** Method for creation through the object factory. */ + itkNewMacro(Self); + + /** Run-time type information (and related methods). */ + itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); + + typedef TImage ImageType; + static const int Dimension = ImageType::ImageDimension; + typedef typename ImageType::PixelType PixelType; + + typedef TScalar ScalarType; + typedef SymmetricSecondRankTensor TensorType; + typedef Image TensorImageType; + typedef ImageRegion RegionType; + + void SetInputImage(const ImageType* image); + void SetInputTensor(const TensorImageType* tensorImage); + + void SetMaxDiffusionTime(ScalarType time); + itkGetConstMacro(DiffusionTime, ScalarType); + + void SetMaxNumberOfTimeSteps(int n); + itkGetConstMacro(MaxNumberOfTimeSteps, int); + + void SetRatioToMaxStableTimeStep(ScalarType ratio); + itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); + + itkGetConstMacro(EffectiveDiffusionTime, ScalarType); + itkGetConstMacro(EffectiveNumberOfTimeSteps, int); + + itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); + itkGetConstMacro(IterationsTimeCost, ScalarType); +protected: + LinearAnisotropicDiffusionLBRImageFilter(); + ~LinearAnisotropicDiffusionLBRImageFilter(){} + + typename ImageType::ConstPointer GetInputImage(); + typename TensorImageType::ConstPointer GetInputTensor(); + + typedef Index IndexType; + + // ******* Containers for the stencils used in the discretization + static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; + static const unsigned int StencilSize = 2*HalfStencilSize; + + typedef Vector StencilCoefficientsType; + typedef Offset OffsetType; + typedef Vector StencilOffsetsType; + + typedef int InternalSizeT; + typedef Vector StencilBufferIndicesType; + + // ****************** Stencil support ****************** + + template struct GetDiffusion; + + template struct GetDiffusion<2,Dummy>{ + static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); + }; + + template struct GetDiffusion<3,Dummy>{ + static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); + }; + + // *************** Computation ***************** + virtual void GenerateData(); + virtual void GenerateStencils(); /// Automatically called by GenerateData + virtual void ImageUpdateLoop(); /// Automatically called by GenerateData + + typedef std::pair StencilType; + typedef Image StencilImageType; + typename StencilImageType::Pointer stencilImage; + + typedef Image ScalarImageType; + typename ScalarImageType::Pointer diagonalCoefficients; + + virtual ScalarType MaxStableTimeStep(); + + ScalarType m_DiffusionTime; + ScalarType m_RatioToMaxStableTimeStep; + int m_MaxNumberOfTimeSteps; + + ScalarType m_EffectiveDiffusionTime; + int m_EffectiveNumberOfTimeSteps; + + virtual void ImageUpdate(ScalarType delta); + typename ImageType::Pointer previousImage, nextImage; + + virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} + + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} + + ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; + + + struct StencilFunctor; + struct FunctorType; + + typedef Vector VectorType; + static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); +private: + LinearAnisotropicDiffusionLBRImageFilter(const Self &); //purposely not implemented + void operator=(const Self &); //purposely not implemented +}; +} // end namespace itk + + +#ifndef ITK_MANUAL_INSTANTIATION +#include "itkLinearAnisotropicDiffusionLBRImageFilter.hxx" +#endif + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx new file mode 100644 index 00000000000..1c587263b0f --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -0,0 +1,431 @@ +// +// LinearAnisotropicDiffusionLBRImageFilter.hxx +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 28/02/2014. +// +// + +#ifndef itkLinearAnisotropicDiffusionLBRImageFilter_hxx +#define itkLinearAnisotropicDiffusionLBRImageFilter_hxx + +#include "itkUnaryFunctorImageFilter.h" +#include "itkImageRegionIterator.h" +#include "itkMinimumMaximumImageCalculator.h" +#include "itkCastImageFilter.h" +#include "itkExtractImageFilter.h" +#include "sys/time.h" + + +#include "itkUnaryFunctorWithIndexImageFilter.h" +#include "itkTernaryFunctorImageFilter.h" + +namespace itk +{ + +template +LinearAnisotropicDiffusionLBRImageFilter::LinearAnisotropicDiffusionLBRImageFilter() +{ + this->SetNumberOfRequiredInputs(2); + m_DiffusionTime = 1; + m_RatioToMaxStableTimeStep = 0.7; + m_MaxNumberOfTimeSteps = 10; + + m_EffectiveDiffusionTime=0; + m_EffectiveNumberOfTimeSteps=0; +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::SetInputImage(const ImageType* image) +{ + this->SetNthInput(0, const_cast(image)); +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::SetInputTensor(const TensorImageType* tensorImage) +{ + this->SetNthInput(1, const_cast(tensorImage)); +} + +template +typename TI::ConstPointer LinearAnisotropicDiffusionLBRImageFilter::GetInputImage() +{ + return static_cast< const ImageType * > + ( this->ProcessObject::GetInput(0) ); +} + +template +typename LinearAnisotropicDiffusionLBRImageFilter::TensorImageType::ConstPointer +LinearAnisotropicDiffusionLBRImageFilter::GetInputTensor() +{ + return static_cast< const TensorImageType * > + ( this->ProcessObject::GetInput(1) ); +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::GenerateData() +{ + timeval start, end; + gettimeofday(&start, NULL); // nullptr is not accepted by older compilers + + GenerateStencils(); + this->UpdateProgress(0.5); + + gettimeofday(&end, NULL); + m_SparseMatrixAssemblyTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; + start=end; + + + ImageUpdateLoop(); + + gettimeofday(&end, NULL); + m_IterationsTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; +} + +// **************************** Computation *********************** +template +struct LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor { + typedef typename TensorImageType::SpacingType SpacingType; + void Initialize(RegionType region_, SpacingType spacing){ + region = region_; + prod[0]=1; + for(int i=1; iprod[i]*(x[i]-this->region.GetIndex()[i]); + return ans; + } + + StencilType operator()(const TensorType & tensor, const IndexType & x) const { + StencilType stencil; + StencilOffsetsType offsets; + + // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. + + TensorType D; + for(int i=0; iinvSpacing[i]*this->invSpacing[j]; + GetDiffusion<>::Stencil(D,offsets,stencil.second); + + InternalSizeT * yIndex = &stencil.first[0]; + + //Compute buffer offsets from geometrical offsets + for(int i=0; i<(int)HalfStencilSize; ++i){ + for(int orientation = 0; orientation<2; ++orientation, ++yIndex){ + const IndexType y = orientation ? x-offsets[i] : x+offsets[i]; + if(this->region.IsInside(y)){ + *yIndex = this->BufferIndex(y); + } else { + // Neumann boundary conditions. + *yIndex = this->OutsideBufferIndex(); + } // if y + } // for eps + } // for i + return stencil; + } +protected: + RegionType region; + IndexType prod; + SpacingType invSpacing; + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} +}; + +template +void LinearAnisotropicDiffusionLBRImageFilter::GenerateStencils(){ + + // Stencil type is a pair type because itk::UnaryFunctorImage filter + // only produces one output +// typedef typename TensorImageType::SpacingType SpacingType; + const RegionType region = GetRequestedRegion(); + + typedef UnaryFunctorWithIndexImageFilter FunctorFilterType; + typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); + filter->SetInput(GetInputTensor()); + filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); + filter->Update(); + stencilImage = filter->GetOutput(); + + + //setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. + + diagonalCoefficients = ScalarImageType::New(); + diagonalCoefficients->CopyInformation(GetInputTensor()); + diagonalCoefficients->SetRegions(GetRequestedRegion()); + diagonalCoefficients->Allocate(); + diagonalCoefficients->FillBuffer(ScalarType(0)); + + ImageRegionConstIterator stencilIt(stencilImage,region); + ImageRegionIterator diagIt(diagonalCoefficients, region); + ScalarType * diagBuffer = diagonalCoefficients->GetBufferPointer(); + + for(stencilIt.GoToBegin(), diagIt.GoToBegin(); + !stencilIt.IsAtEnd(); + ++stencilIt, ++diagIt) + for(int i=0; i<(int)StencilSize; ++i) { + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if(yIndex!=OutsideBufferIndex()){ + const ScalarType coefficient = stencilIt.Value().second[i/2]; + diagIt.Value() += coefficient; + diagBuffer[yIndex] += coefficient; + } // if y + } // for i + // for stencilIt, diagIt +} + +template +typename LinearAnisotropicDiffusionLBRImageFilter::ScalarType +LinearAnisotropicDiffusionLBRImageFilter::MaxStableTimeStep(){ + typedef MinimumMaximumImageCalculator MaxCalculatorType; + typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); + maximumCalculator->SetImage(diagonalCoefficients); + maximumCalculator->SetRegion(GetRequestedRegion()); + maximumCalculator->ComputeMaximum(); + return 1./maximumCalculator->GetMaximum(); +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::SetMaxDiffusionTime(ScalarType time){ + if(time<0) + itkExceptionMacro("diffusion time must be finite and positive"); + m_DiffusionTime = time; +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::SetRatioToMaxStableTimeStep(ScalarType ratio){ + if(ratio<=0 || ratio>1) + itkExceptionMacro("Ratio to max time step " << ratio << "should be within ]0,1]"); + m_RatioToMaxStableTimeStep=ratio; +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::SetMaxNumberOfTimeSteps(int n){ + if(n<=0) + itkExceptionMacro("Max number of time steps must be positive"); + m_MaxNumberOfTimeSteps=n; +} + +template +void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdateLoop(){ + ScalarType delta = MaxStableTimeStep() * m_RatioToMaxStableTimeStep; + int n = ceil(m_DiffusionTime / delta); + if(n>m_MaxNumberOfTimeSteps) { + n=m_MaxNumberOfTimeSteps; + m_EffectiveDiffusionTime = n*delta; + } else { + delta = m_DiffusionTime/n; + m_EffectiveDiffusionTime = m_DiffusionTime; + } + m_EffectiveNumberOfTimeSteps=n; + + // Extraction of the region of interest is required for image buffer access. + typedef ExtractImageFilter InputCasterType; + typename InputCasterType::Pointer inputCaster = InputCasterType::New(); + inputCaster->SetInput(GetInputImage()); + inputCaster->SetExtractionRegion(GetRequestedRegion()); + inputCaster->SetDirectionCollapseToIdentity(); + inputCaster->Update(); + previousImage = inputCaster->GetOutput(); + + nextImage = ImageType::New(); + nextImage->CopyInformation(previousImage); + nextImage->SetRegions(previousImage->GetBufferedRegion()); + nextImage->Allocate(); + + for(int k=0; kUpdateProgress(0.5+0.5*k/float(n)); + } + this->GraftOutput(previousImage); +} + +template +struct LinearAnisotropicDiffusionLBRImageFilter::FunctorType { + ScalarType delta; + PixelType operator()(PixelType output, PixelType input, ScalarType diag){ + return output*this->delta + input*(ScalarType(1)-this->delta*diag); + } +}; + +template +void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdate(ScalarType delta){ + +//Setting up iterators + +ImageRegion region = GetRequestedRegion(); + +ImageRegionConstIterator inputIt(previousImage,region); +ImageRegionIterator outputIt(nextImage,region); + +const PixelType * inputBuffer = previousImage->GetBufferPointer(); +PixelType * outputBuffer = nextImage->GetBufferPointer(); + +ImageRegionConstIterator diagIt(diagonalCoefficients, region); +ImageRegionConstIterator stencilIt(stencilImage, region); + +// Rest of function is a hand-made (sparse matrix)*vector product. +nextImage->FillBuffer(0.); + +// Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer +for(inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); + !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++stencilIt){ + for(int i=0; i<(int)StencilSize; ++i){ + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if(yIndex!=OutsideBufferIndex()){ + const ScalarType coefficient = stencilIt.Value().second[i/2]; + outputIt.Value() += coefficient * (inputBuffer[yIndex]); + outputBuffer[yIndex] += coefficient * inputIt.Value(); + } + } +} + +typedef TernaryFunctorImageFilter ImageFunctorType; +typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); +imageFunctor->SetInput1(nextImage); +imageFunctor->SetInput2(previousImage); +imageFunctor->SetInput3(diagonalCoefficients); +imageFunctor->GetFunctor().delta = delta; + +assert(imageFunctor->CanRunInPlace()); +imageFunctor->InPlaceOn(); +imageFunctor->Update(); +nextImage=imageFunctor->GetOutput(); + +/* +// Old Serial version for diagonal elements +for(inputIt.GoToBegin(), outputIt.GoToBegin(), diagIt.GoToBegin(); + !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++diagIt) + outputIt.Value() = delta*outputIt.Value() + (1-delta*diagIt.Value())*inputIt.Value(); +*/ +} + +// **************************** subclass SSRT_Traits call method ************************** + +template +TS +LinearAnisotropicDiffusionLBRImageFilter::ScalarProduct(const TensorType & m, + const VectorType & u, + const VectorType & v){ +ScalarType result(0); +for(int i=0; i template +void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<2,Dummy>:: +Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ + +// Construct a superbase, and make it obtuse with Selling's algorithm +VectorType sb[Dimension+1]; //SuperBase +for(int i=0; i 0 ){ + const VectorType u=sb[i], v=sb[j]; + sb[0]=v-u; + sb[1]=u; + sb[2]=-v; + same=false; + } + if(same) break; +} +if(iter==maxIter) + std::cerr << "Warning: Selling's algorithm not stabilized.\n"; + +for(int i=0; i<3; ++i){ + Coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); + assert(Coefficients[i]>=0); + + Offsets[i][0] = static_cast(-sb[i][1]); + Offsets[i][1] = static_cast( sb[i][0]); +} + +} // 2D stencil construction + + +// 3D stencil construction +template template +void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<3,Dummy>:: +Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ + +// Construct a superbase, and make it obtuse with Selling's algorithm +typedef Vector VectorType; +VectorType sb[Dimension+1]; +for(int i=0; i 0 ){ + const VectorType u=sb[i], v=sb[j]; + for(int k=0,l=0; k<=Dimension; ++k) + if(k!=i && k!=j) + sb[l++]=sb[k]+u; + sb[2]=-u; + sb[3]=v; + same=false; + } + if(same) break; +} +if(iter==maxIter) + std::cerr << "Warning: Selling's algorithm not stabilized.\n"; + +// Computation of the weights +itk::SymmetricSecondRankTensor Weights; +for(int i=1; i, + TImage::ImageDimension> +> +class StructureTensorImageFilter : public ImageToImageFilter { +public: + typedef StructureTensorImageFilter Self; + typedef ImageToImageFilter< TImage, TImage> Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(StructureTensorImageFilter, Superclass); + + typedef TImage ImageType; + typedef typename ImageType::PixelType PixelType; + static const unsigned int Dimension = ImageType::ImageDimension; + typedef TTensorImage TensorImageType; + typedef typename TensorImageType::PixelType TensorType; + typedef typename TensorType::ComponentType ScalarType; + typedef Image ScalarImageType; + + ///Parameter \f$\sigma\f$ of the structure tensor definition. + itkSetMacro(NoiseScale, ScalarType); + ///Parameter \f$\rho\f$ of the structure tensor definition. + itkSetMacro(FeatureScale, ScalarType); + ///Rescales all structure tensors by a common factor, so that the maximum trace is 1. + itkSetMacro(RescaleForUnitMaximumTrace, bool); + + itkGetConstMacro(NoiseScale, ScalarType); + itkGetConstMacro(FeatureScale, ScalarType); + itkGetConstMacro(RescaleForUnitMaximumTrace, bool); + itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. + + bool m_UseGradientRecursiveGaussianImageFilter; +protected: + virtual void GenerateData(); + + ScalarType m_FeatureScale, m_NoiseScale; + bool m_RescaleForUnitMaximumTrace; + ScalarType m_PostRescaling; + + template::is_specialized> + struct IntermediateFilter; + typename TensorImageType::Pointer intermediateResult; + + typedef CovariantVector CovariantVectorType; + typedef Image CovariantImageType; + + struct OuterFunctor; + struct TraceFunctor; + struct ScaleFunctor; + + StructureTensorImageFilter(){ + m_FeatureScale=2; + m_NoiseScale=1; + m_RescaleForUnitMaximumTrace=false; + m_UseGradientRecursiveGaussianImageFilter=true; + } +}; + +} // end namespace itk + +#ifndef ITK_MANUAL_INSTANTIATION +#include "itkStructureTensorImageFilter.hxx" +#endif + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx new file mode 100644 index 00000000000..729d1a79a29 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -0,0 +1,159 @@ +// +// StructureTensorImageFilter.hxx +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 21/11/2014. +// +// + +#ifndef itkStructureTensorImageFilter_hxx +#define itkStructureTensorImageFilter_hxx + + +namespace itk +{ + +template +struct StructureTensorImageFilter::OuterFunctor { + TensorType operator()(const CovariantVectorType & u) const { + TensorType m; + for(int i=0; i<(int)Dimension; ++i) + for(int j=i; j<(int)Dimension; ++j) + m(i,j) = u[i]*u[j]; + return m; + } +}; + + +template +template +struct StructureTensorImageFilter::IntermediateFilter { + void operator()(Self *self){ + typedef GradientRecursiveGaussianImageFilter GradientFilterType; + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + gradientFilter->SetInput(self->GetInput()); + gradientFilter->SetSigma(self->m_NoiseScale); + + typedef UnaryFunctorImageFilter OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + outerFilter->SetInput(gradientFilter->GetOutput()); + + outerFilter->Update(); + self->intermediateResult = outerFilter->GetOutput(); + } +}; + +template +template +struct StructureTensorImageFilter::IntermediateFilter { + void operator()(Self *self){ + + typename ImageType::ConstPointer input = self->GetInput(); + typename TensorImageType::Pointer output = TensorImageType::New(); + output->CopyInformation(input); + output->SetRegions(input->GetRequestedRegion()); + output->Allocate(); + output->FillBuffer(TensorType(0.)); + + for(int index=0; index SelectionFilterType; + typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); + selectionFilter->SetIndex(index); + selectionFilter->SetInput(input); + + typedef RecursiveGaussianImageFilter GaussianFilterType; + typedef GradientImageFilter GradientFilterType; + typedef GradientRecursiveGaussianImageFilter GradientGaussianFilterType; + + typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); + + gaussianFilter->SetSigma(self->m_NoiseScale); + gradientGaussianFilter->SetSigma(self->m_NoiseScale); + + typedef UnaryFunctorImageFilter OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + + if(self->m_UseGradientRecursiveGaussianImageFilter){ + gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); + outerFilter->SetInput(gradientGaussianFilter->GetOutput()); + } else { + gaussianFilter->SetInput(selectionFilter->GetOutput()); + gradientFilter->SetInput(gaussianFilter->GetOutput()); + outerFilter->SetInput(gradientFilter->GetOutput()); + } + + typedef AddImageFilter AddFilterType; + typename AddFilterType::Pointer addFilter = AddFilterType::New(); + addFilter->InPlaceOn(); + addFilter->SetInput1(output); + addFilter->SetInput2(outerFilter->GetOutput()); + addFilter->Update(); + output = addFilter->GetOutput(); + + self->UpdateProgress(index/float(PixelType::Dimension+1)); + } + self->intermediateResult = output; + } +}; + + +template +struct StructureTensorImageFilter::TraceFunctor { + ScalarType operator()(const TensorType & t) const { + return t.GetTrace(); + } +}; + +template +struct StructureTensorImageFilter::ScaleFunctor { + ScalarType scaling; + TensorType operator()(const TensorType & t) const { + return t*scaling; + } +}; + +template +void StructureTensorImageFilter::GenerateData(){ + IntermediateFilter<>()(this); + + typedef RecursiveGaussianImageFilter GaussianFilterType; + typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); + gaussianFilter->SetInput(intermediateResult); + gaussianFilter->SetSigma(m_FeatureScale); + + if(!m_RescaleForUnitMaximumTrace){ + m_PostRescaling=1.; + gaussianFilter->Update(); + this->GraftOutput(gaussianFilter->GetOutput()); + return; + } + + // *** Rescaling for normalization of largest trace *** + + typedef UnaryFunctorImageFilter TraceFilterType; + typename TraceFilterType::Pointer traceFilter = TraceFilterType::New(); + traceFilter->SetInput(gaussianFilter->GetOutput()); + + typedef MinimumMaximumImageCalculator MaximumCalculatorType; + typename MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); + maximumCalculator->SetImage(traceFilter->GetOutput()); + + typedef UnaryFunctorImageFilter ScaleFilterType; + typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); + scaleFilter->SetInput(gaussianFilter->GetOutput()); + + traceFilter->Update(); + maximumCalculator->ComputeMaximum(); + m_PostRescaling = 1./maximumCalculator->GetMaximum(); + scaleFilter->GetFunctor().scaling = m_PostRescaling; + scaleFilter->Update(); + this->GraftOutput(scaleFilter->GetOutput()); +} + +} // end namespace itk + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h new file mode 100644 index 00000000000..12074c97aac --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -0,0 +1,68 @@ +// +// UnaryFunctorWithIndexImageFilter.h +// itkDiffusion +// +// Created by Jean-Marie Mirebeau on 07/03/2014. +// +// + +#ifndef itkUnaryFunctorWithIndexImageFilter_h +#define itkUnaryFunctorWithIndexImageFilter_h + +#include "itkImageRegionConstIteratorWithIndex.h" +#include "itkImageScanlineIterator.h" +#include "itkAnisotropicDiffusionLBRMacro.h" +/** A (simplification of) UnaryFunctorImageFilter, which provides the pixel index to the functor. + */ + +namespace itk +{ +template +class UnaryFunctorWithIndexImageFilter : public ImageToImageFilter { +public: + typedef UnaryFunctorWithIndexImageFilter Self; + typedef ImageToImageFilter Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(UnaryFunctorWithIndexImageFilter, Superclass); + + typedef TInputImage InputImageType; + typedef TOutputImage OutputImageType; + typedef TFunctor FunctorType; + + GetSetFunctorMacro(Functor, FunctorType); + +protected: + UnaryFunctorWithIndexImageFilter(){}; + + FunctorType m_Functor; + + typedef typename InputImageType::RegionType InputRegionType; + typedef typename OutputImageType::RegionType OutputRegionType; + + virtual void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType){ + if(region.GetSize()[0]==0) return; + + ImageRegionConstIteratorWithIndex inputIt( this->GetInput(), region); + ImageScanlineIterator< OutputImageType > outputIt( this->GetOutput(), region); + + for(inputIt.GoToBegin(), outputIt.GoToBegin(); + !outputIt.IsAtEnd(); + ){ + while(!outputIt.IsAtEndOfLine()){ + outputIt.Set(m_Functor(inputIt.Value(), inputIt.GetIndex())); + ++inputIt; + ++outputIt; + } + outputIt.NextLine(); + } + } +}; + +} // end namespace itk + +#endif From 27c8b2256ebe95c221e724a6dff3f866f7b44995 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 23:25:29 -0400 Subject: [PATCH 10/76] BUG: Add missing license headers. --- .../CoherenceEnhancingDiffusionCommandLine.h | 19 ++++++++++++++-- .../LinearAnisotropicDiffusionCommandLine.h | 20 ++++++++++++++--- .../itkAnisotropicDiffusionLBRImageFilter.h | 20 ++++++++++++++--- .../itkAnisotropicDiffusionLBRImageFilter.hxx | 20 ++++++++++++++--- .../include/itkAnisotropicDiffusionLBRMacro.h | 20 ++++++++++++++--- .../itkCoherenceEnhancingDiffusionFilter.h | 20 ++++++++++++++--- ...LinearAnisotropicDiffusionLBRImageFilter.h | 22 ++++++++++++++++--- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 20 ++++++++++++++--- .../include/itkStructureTensorImageFilter.h | 20 ++++++++++++++--- .../include/itkStructureTensorImageFilter.hxx | 20 ++++++++++++++--- .../itkUnaryFunctorWithIndexImageFilter.h | 20 ++++++++++++++--- .../src/CoherenceEnhancingDiffusion.cxx | 17 ++++++++++++++ .../test/CoherenceEnhancingDiffusionTest.cxx | 19 +++++++++++++++- 13 files changed, 224 insertions(+), 33 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 47a0ec6c7ed..6a58dfa4445 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -1,6 +1,21 @@ +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // -// CoherenceEnhancingDiffusionCommandLine.h -// itkDiffusion // // Created by Jean-Marie Mirebeau on 20/11/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index c88d1da5e71..6811187d664 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -1,6 +1,20 @@ -// -// LinearAnisotropicDiffusionCommandLine.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 01/12/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index fb3ec4062fb..11ba34291ff 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -1,6 +1,20 @@ -// -// AnisotropicDiffusionLBRImageFilter.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index b86632df89e..eacb943b80f 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -1,6 +1,20 @@ -// -// AnisotropicDiffusionLBRImageFilter.hxx -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h index 930bc7fe60c..d97854d09d4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h @@ -1,6 +1,20 @@ -// -// Macro.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 07/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h index a4bfa0cc255..19ff8d5fe04 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h @@ -1,6 +1,20 @@ -// -// CoherenceEnhancingDiffusionFilter.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 06/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index f3ecff45d6a..da6a0c0433f 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -1,6 +1,20 @@ -// -// LinearAnisotropicDiffusionLBRImageFilter.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 28/02/2014. // @@ -15,6 +29,8 @@ namespace itk { /** + * \class LinearAnisotropicDiffusionLBRImageFilter + * Implementation of Anisotropic Diffusion \f[\partial_t u = {\rm div} (D \nabla u),\f] with Neumann boundary conditions. The numerical scheme is stable and satisfies the maximum principle, even for strongly anisotropic tensors, thanks to an adaptive discretization using arithmetic techniques (Lattice Basis Reduction, LBR). diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 1c587263b0f..e96166f8550 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -1,6 +1,20 @@ -// -// LinearAnisotropicDiffusionLBRImageFilter.hxx -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index c82d084ebfd..c2d055339ac 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -1,6 +1,20 @@ -// -// StructureTensorImageFilter.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 05/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 729d1a79a29..230354eeff8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -1,6 +1,20 @@ -// -// StructureTensorImageFilter.hxx -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 21/11/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 12074c97aac..6db34b3931f 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -1,6 +1,20 @@ -// -// UnaryFunctorWithIndexImageFilter.h -// itkDiffusion +/*========================================================================= + * + * 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. + * + *=========================================================================*/ // // Created by Jean-Marie Mirebeau on 07/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx index c5392d6c108..5f92d0fc8dc 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx @@ -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. + * + *=========================================================================*/ #include #include #include "CoherenceEnhancingDiffusionCommandLine.h" diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx index 9771ff23821..b2c1ee4024d 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx @@ -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. + * + *=========================================================================*/ #include #include #include "CoherenceEnhancingDiffusionCommandLine.h" @@ -23,4 +40,4 @@ int LinearAnisotropicDiffusionTest(int argc, char **argv) return EXIT_FAILURE; } return EXIT_SUCCESS; -}*/ \ No newline at end of file +}*/ From e517fc29f9e2a4dde9fb84b10bbecce48f5862a1 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 27 May 2015 23:59:17 -0400 Subject: [PATCH 11/76] BUG: Get StructureTensorImageFilter to compile. --- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 2 +- .../include/itkStructureTensorImageFilter.h | 149 +++++----- .../include/itkStructureTensorImageFilter.hxx | 256 +++++++++--------- 3 files changed, 216 insertions(+), 191 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index e96166f8550..0062d9f2246 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -442,4 +442,4 @@ Coefficients[Dimension+2] = Weights(1,2); } // end namespace itk -#ndif +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index c2d055339ac..28c338f0748 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -32,72 +32,99 @@ namespace itk { /** - Implementation of the structure tensor, defined by - \f[K_\rho (\nabla u_\sigma \otimes \nabla u_\sigma),\f] where \f$K_\rho\f$ denotes the gaussian kernel of standard deviation \f$\rho\f$, and \f$u_\sigma := K_\sigma * u\f$. + * \class StructureTensorImageFilter + * + * Implementation of the structure tensor, defined by + * + * \f[K_\rho (\nabla u_\sigma \otimes \nabla u_\sigma),\f] + * + * where \f$K_\rho\f$ denotes the gaussian kernel of standard deviation \f$\rho\f$, + * and \f$u_\sigma := K_\sigma * u\f$. */ -template< -typename TImage, -typename TTensorImage = Image< - SymmetricSecondRankTensor, - TImage::ImageDimension> +template< typename TImage, + typename TTensorImage = + Image< SymmetricSecondRankTensor< typename TImage::PixelType,TImage::ImageDimension >, TImage::ImageDimension > > -class StructureTensorImageFilter : public ImageToImageFilter { +class StructureTensorImageFilter: + public ImageToImageFilter< TImage, TTensorImage > +{ public: - typedef StructureTensorImageFilter Self; - typedef ImageToImageFilter< TImage, TImage> Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; - - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(StructureTensorImageFilter, Superclass); - - typedef TImage ImageType; - typedef typename ImageType::PixelType PixelType; - static const unsigned int Dimension = ImageType::ImageDimension; - typedef TTensorImage TensorImageType; - typedef typename TensorImageType::PixelType TensorType; - typedef typename TensorType::ComponentType ScalarType; - typedef Image ScalarImageType; - - ///Parameter \f$\sigma\f$ of the structure tensor definition. - itkSetMacro(NoiseScale, ScalarType); - ///Parameter \f$\rho\f$ of the structure tensor definition. - itkSetMacro(FeatureScale, ScalarType); - ///Rescales all structure tensors by a common factor, so that the maximum trace is 1. - itkSetMacro(RescaleForUnitMaximumTrace, bool); - - itkGetConstMacro(NoiseScale, ScalarType); - itkGetConstMacro(FeatureScale, ScalarType); - itkGetConstMacro(RescaleForUnitMaximumTrace, bool); - itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. - - bool m_UseGradientRecursiveGaussianImageFilter; + typedef StructureTensorImageFilter Self; + typedef ImageToImageFilter< TImage, TImage> Superclass; + typedef SmartPointer Pointer; + typedef SmartPointer ConstPointer; + + /// Method for creation through the object factory. + itkNewMacro(Self); + /// Run-time type information (and related methods). + itkTypeMacro(StructureTensorImageFilter, Superclass); + + typedef TImage ImageType; + typedef typename ImageType::PixelType PixelType; + static const unsigned int Dimension = ImageType::ImageDimension; + typedef TTensorImage TensorImageType; + typedef typename TensorImageType::PixelType TensorType; + typedef typename TensorType::ComponentType ScalarType; + typedef Image ScalarImageType; + + ///Parameter \f$\sigma\f$ of the structure tensor definition. + itkSetMacro(NoiseScale, ScalarType); + ///Parameter \f$\rho\f$ of the structure tensor definition. + itkSetMacro(FeatureScale, ScalarType); + ///Rescales all structure tensors by a common factor, so that the maximum trace is 1. + itkSetMacro(RescaleForUnitMaximumTrace, bool); + + itkGetConstMacro(NoiseScale, ScalarType); + itkGetConstMacro(FeatureScale, ScalarType); + itkGetConstMacro(RescaleForUnitMaximumTrace, bool); + itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. + protected: - virtual void GenerateData(); - - ScalarType m_FeatureScale, m_NoiseScale; - bool m_RescaleForUnitMaximumTrace; - ScalarType m_PostRescaling; - - template::is_specialized> - struct IntermediateFilter; - typename TensorImageType::Pointer intermediateResult; - - typedef CovariantVector CovariantVectorType; - typedef Image CovariantImageType; - - struct OuterFunctor; - struct TraceFunctor; - struct ScaleFunctor; - - StructureTensorImageFilter(){ - m_FeatureScale=2; - m_NoiseScale=1; - m_RescaleForUnitMaximumTrace=false; - m_UseGradientRecursiveGaussianImageFilter=true; + virtual void GenerateData() ITK_OVERRIDE; + + ScalarType m_FeatureScale; + ScalarType m_NoiseScale; + bool m_RescaleForUnitMaximumTrace; + ScalarType m_PostRescaling; + bool m_UseGradientRecursiveGaussianImageFilter; + + template< typename Dummy=void, bool b=std::numeric_limits::is_specialized > + struct IntermediateFilter; + typename TensorImageType::Pointer intermediateResult; + + typedef CovariantVector CovariantVectorType; + typedef Image CovariantImageType; + + struct OuterFunctor + { + TensorType operator()(const CovariantVectorType & u) const + { + TensorType m; + for( unsigned int i = 0; i < Dimension; ++i ) + { + for( unsigned int j = i; j < Dimension; ++j) + { + m(i,j) = u[i]*u[j]; + } + } + return m; + } + }; + struct TraceFunctor + { + ScalarType operator()(const TensorType & t) const { + return t.GetTrace(); + } + }; + struct ScaleFunctor + { + ScalarType scaling; + TensorType operator()(const TensorType & t) const { + return t*scaling; } + }; + + StructureTensorImageFilter(); }; } // end namespace itk diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 230354eeff8..634ea635c73 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -23,149 +23,147 @@ #ifndef itkStructureTensorImageFilter_hxx #define itkStructureTensorImageFilter_hxx +#include "itkStructureTensorImageFilter.h" namespace itk { -template -struct StructureTensorImageFilter::OuterFunctor { - TensorType operator()(const CovariantVectorType & u) const { - TensorType m; - for(int i=0; i<(int)Dimension; ++i) - for(int j=i; j<(int)Dimension; ++j) - m(i,j) = u[i]*u[j]; - return m; - } -}; - - -template -template -struct StructureTensorImageFilter::IntermediateFilter { - void operator()(Self *self){ - typedef GradientRecursiveGaussianImageFilter GradientFilterType; - typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); - gradientFilter->SetInput(self->GetInput()); - gradientFilter->SetSigma(self->m_NoiseScale); - - typedef UnaryFunctorImageFilter OuterFilterType; - typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - outerFilter->SetInput(gradientFilter->GetOutput()); - - outerFilter->Update(); - self->intermediateResult = outerFilter->GetOutput(); - } -}; - -template -template -struct StructureTensorImageFilter::IntermediateFilter { - void operator()(Self *self){ - - typename ImageType::ConstPointer input = self->GetInput(); - typename TensorImageType::Pointer output = TensorImageType::New(); - output->CopyInformation(input); - output->SetRegions(input->GetRequestedRegion()); - output->Allocate(); - output->FillBuffer(TensorType(0.)); - - for(int index=0; index SelectionFilterType; - typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); - selectionFilter->SetIndex(index); - selectionFilter->SetInput(input); - - typedef RecursiveGaussianImageFilter GaussianFilterType; - typedef GradientImageFilter GradientFilterType; - typedef GradientRecursiveGaussianImageFilter GradientGaussianFilterType; - - typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); - typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); - - gaussianFilter->SetSigma(self->m_NoiseScale); - gradientGaussianFilter->SetSigma(self->m_NoiseScale); - - typedef UnaryFunctorImageFilter OuterFilterType; - typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - - if(self->m_UseGradientRecursiveGaussianImageFilter){ - gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); - outerFilter->SetInput(gradientGaussianFilter->GetOutput()); - } else { - gaussianFilter->SetInput(selectionFilter->GetOutput()); - gradientFilter->SetInput(gaussianFilter->GetOutput()); - outerFilter->SetInput(gradientFilter->GetOutput()); - } - - typedef AddImageFilter AddFilterType; - typename AddFilterType::Pointer addFilter = AddFilterType::New(); - addFilter->InPlaceOn(); - addFilter->SetInput1(output); - addFilter->SetInput2(outerFilter->GetOutput()); - addFilter->Update(); - output = addFilter->GetOutput(); - - self->UpdateProgress(index/float(PixelType::Dimension+1)); - } - self->intermediateResult = output; - } -}; +template< typename TImage, typename TTensorImage > +StructureTensorImageFilter< TImage, TTensorImage > +::StructureTensorImageFilter(): + m_FeatureScale( 2 ), + m_NoiseScale( 1 ), + m_RescaleForUnitMaximumTrace( false ), + m_UseGradientRecursiveGaussianImageFilter( true ) +{ +} -template -struct StructureTensorImageFilter::TraceFunctor { - ScalarType operator()(const TensorType & t) const { - return t.GetTrace(); - } +template< typename TImage, typename TTensorImage > +template< typename Dummy > +struct StructureTensorImageFilter< TImage, TTensorImage > +::IntermediateFilter< Dummy, true > +{ + typedef StructureTensorImageFilter< TImage, TTensorImage > Self; + void operator()(Self *self) + { + typedef GradientRecursiveGaussianImageFilter< TImage, Self::CovariantImageType > GradientFilterType; + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + gradientFilter->SetInput(self->GetInput()); + gradientFilter->SetSigma(self->m_NoiseScale); + + typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + outerFilter->SetInput(gradientFilter->GetOutput()); + + outerFilter->Update(); + self->intermediateResult = outerFilter->GetOutput(); + } }; -template -struct StructureTensorImageFilter::ScaleFunctor { - ScalarType scaling; - TensorType operator()(const TensorType & t) const { - return t*scaling; - } -}; -template -void StructureTensorImageFilter::GenerateData(){ - IntermediateFilter<>()(this); +template< typename TImage, typename TTensorImage > +template< typename Dummy > +struct StructureTensorImageFilter< TImage, TTensorImage > +::IntermediateFilter< Dummy, false > +{ + typedef StructureTensorImageFilter< TImage, TTensorImage > Self; + void operator()(Self *self) + { + typename Self::ImageType::ConstPointer input = self->GetInput(); + typename Self::TensorImageType::Pointer output = Self::TensorImageType::New(); + output->CopyInformation(input); + output->SetRegions(input->GetRequestedRegion()); + output->Allocate(); + output->FillBuffer(Self::TensorType(0.)); + + for( unsigned int index = 0; index < Self::PixelType::Dimension; ++index ) + { + typedef VectorIndexSelectionCastImageFilter< Self::ImageType, Self::ScalarImageType > SelectionFilterType; + typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); + selectionFilter->SetIndex(index); + selectionFilter->SetInput(input); + + typedef RecursiveGaussianImageFilter< Self::ScalarImageType > GaussianFilterType; + typedef GradientImageFilter< Self::ScalarImageType, Self::ScalarType, Self::ScalarType, Self::CovariantImageType > GradientFilterType; + typedef GradientRecursiveGaussianImageFilter< Self::ScalarImageType, Self::CovariantImageType > GradientGaussianFilterType; - typedef RecursiveGaussianImageFilter GaussianFilterType; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - gaussianFilter->SetInput(intermediateResult); - gaussianFilter->SetSigma(m_FeatureScale); - - if(!m_RescaleForUnitMaximumTrace){ - m_PostRescaling=1.; - gaussianFilter->Update(); - this->GraftOutput(gaussianFilter->GetOutput()); - return; + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); + + gaussianFilter->SetSigma(self->m_NoiseScale); + gradientGaussianFilter->SetSigma(self->m_NoiseScale); + + typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + + if( self->m_UseGradientRecursiveGaussianImageFilter ) + { + gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); + outerFilter->SetInput(gradientGaussianFilter->GetOutput()); + } + else + { + gaussianFilter->SetInput(selectionFilter->GetOutput()); + gradientFilter->SetInput(gaussianFilter->GetOutput()); + outerFilter->SetInput(gradientFilter->GetOutput()); + } + + typedef AddImageFilter< Self::TensorImageType > AddFilterType; + typename AddFilterType::Pointer addFilter = AddFilterType::New(); + addFilter->InPlaceOn(); + addFilter->SetInput1(output); + addFilter->SetInput2(outerFilter->GetOutput()); + addFilter->Update(); + output = addFilter->GetOutput(); + + self->UpdateProgress(index/float( Self::PixelType::Dimension+1 )); } + self->intermediateResult = output; + } +}; - // *** Rescaling for normalization of largest trace *** - - typedef UnaryFunctorImageFilter TraceFilterType; - typename TraceFilterType::Pointer traceFilter = TraceFilterType::New(); - traceFilter->SetInput(gaussianFilter->GetOutput()); - - typedef MinimumMaximumImageCalculator MaximumCalculatorType; - typename MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); - maximumCalculator->SetImage(traceFilter->GetOutput()); - - typedef UnaryFunctorImageFilter ScaleFilterType; - typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); - scaleFilter->SetInput(gaussianFilter->GetOutput()); - traceFilter->Update(); - maximumCalculator->ComputeMaximum(); - m_PostRescaling = 1./maximumCalculator->GetMaximum(); - scaleFilter->GetFunctor().scaling = m_PostRescaling; - scaleFilter->Update(); - this->GraftOutput(scaleFilter->GetOutput()); +template< typename TImage, typename TTensorImage > +void +StructureTensorImageFilter< TImage, TTensorImage > +::GenerateData() +{ + IntermediateFilter<>()(this); + + typedef RecursiveGaussianImageFilter GaussianFilterType; + typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); + gaussianFilter->SetInput(intermediateResult); + gaussianFilter->SetSigma(m_FeatureScale); + + if(!m_RescaleForUnitMaximumTrace){ + m_PostRescaling=1.; + gaussianFilter->Update(); + this->GraftOutput(gaussianFilter->GetOutput()); + return; + } + + // *** Rescaling for normalization of largest trace *** + + typedef UnaryFunctorImageFilter TraceFilterType; + typename TraceFilterType::Pointer traceFilter = TraceFilterType::New(); + traceFilter->SetInput(gaussianFilter->GetOutput()); + + typedef MinimumMaximumImageCalculator MaximumCalculatorType; + typename MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); + maximumCalculator->SetImage(traceFilter->GetOutput()); + + typedef UnaryFunctorImageFilter ScaleFilterType; + typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); + scaleFilter->SetInput(gaussianFilter->GetOutput()); + + traceFilter->Update(); + maximumCalculator->ComputeMaximum(); + m_PostRescaling = 1./maximumCalculator->GetMaximum(); + scaleFilter->GetFunctor().scaling = m_PostRescaling; + scaleFilter->Update(); + this->GraftOutput(scaleFilter->GetOutput()); } } // end namespace itk From 1ed2e6534d135eedfe7c019bcf82863c9e92a0b2 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 31 May 2015 21:59:42 -0400 Subject: [PATCH 12/76] DOC: Fix the doxygen group test. --- .../itkAnisotropicDiffusionLBRImageFilter.h | 16 +++- ...LinearAnisotropicDiffusionLBRImageFilter.h | 81 ++++++++++--------- .../include/itkStructureTensorImageFilter.h | 7 +- 3 files changed, 61 insertions(+), 43 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 11ba34291ff..21596b017a8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -29,9 +29,19 @@ namespace itk { -/** Implementation of Non-linear Anisotropic Diffusion. - This class repeatedly calls the LinearAnisotropicDiffusionLBRImageFilter, with non-linear diffusion tensors built on the fly. These tensors are obtained by computing the image structure tensors, and appropriately modifying their eigenvalues with the method EigenValuesTransform. The latter method is not implemented, and needs to be provided in a subclass, such as CoherenceEnhancingDiffusionFilter.h -*/ +/** \class AnisotropicDiffusionLBRImageFilter + * + * \brief Non-linear anisotropic diffusion using lattice basis reduction. + * + * This class repeatedly calls the LinearAnisotropicDiffusionLBRImageFilter, + * with non-linear diffusion tensors built on the fly. These tensors are + * obtained by computing the image structure tensors, and appropriately + * modifying their eigenvalues with the method EigenValuesTransform. The + * latter method is not implemented, and needs to be provided in a subclass, + * such as CoherenceEnhancingDiffusionFilter. + * + * \ingroup AnisotropicDiffusionLBR + */ template class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage> { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index da6a0c0433f..3bc71c127d9 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -31,120 +31,125 @@ namespace itk /** * \class LinearAnisotropicDiffusionLBRImageFilter * - Implementation of Anisotropic Diffusion - \f[\partial_t u = {\rm div} (D \nabla u),\f] - with Neumann boundary conditions. The numerical scheme is stable and satisfies the maximum principle, even for strongly anisotropic tensors, thanks to an adaptive discretization using arithmetic techniques (Lattice Basis Reduction, LBR). + * \brief Anisotropic diffusion using lattice basis reduction. + * + * \f[\partial_t u = {\rm div} (D \nabla u),\f] + * + * with Neumann boundary conditions. The numerical scheme is stable and + * satisfies the maximum principle, even for strongly anisotropic tensors, + * thanks to an adaptive discretization using arithmetic techniques + * (Lattice Basis Reduction, LBR). + * + * \ingroup AnisotropicDiffusionLBR */ -template< -typename TImage, -typename TScalar = typename TImage::PixelType -> -class LinearAnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > +template< typename TImage, typename TScalar = typename TImage::PixelType > +class LinearAnisotropicDiffusionLBRImageFilter: + public ImageToImageFilter< TImage, TImage > { public: /** Standard class typedefs. */ typedef LinearAnisotropicDiffusionLBRImageFilter Self; typedef ImageToImageFilter< TImage, TImage > Superclass; typedef SmartPointer< Self > Pointer; - + /** Method for creation through the object factory. */ itkNewMacro(Self); - + /** Run-time type information (and related methods). */ itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); - + typedef TImage ImageType; static const int Dimension = ImageType::ImageDimension; typedef typename ImageType::PixelType PixelType; - + typedef TScalar ScalarType; typedef SymmetricSecondRankTensor TensorType; typedef Image TensorImageType; typedef ImageRegion RegionType; - + void SetInputImage(const ImageType* image); void SetInputTensor(const TensorImageType* tensorImage); - + void SetMaxDiffusionTime(ScalarType time); itkGetConstMacro(DiffusionTime, ScalarType); - + void SetMaxNumberOfTimeSteps(int n); itkGetConstMacro(MaxNumberOfTimeSteps, int); - + void SetRatioToMaxStableTimeStep(ScalarType ratio); itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); - + itkGetConstMacro(EffectiveDiffusionTime, ScalarType); itkGetConstMacro(EffectiveNumberOfTimeSteps, int); - + itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); itkGetConstMacro(IterationsTimeCost, ScalarType); protected: LinearAnisotropicDiffusionLBRImageFilter(); ~LinearAnisotropicDiffusionLBRImageFilter(){} - + typename ImageType::ConstPointer GetInputImage(); typename TensorImageType::ConstPointer GetInputTensor(); - + typedef Index IndexType; // ******* Containers for the stencils used in the discretization static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; static const unsigned int StencilSize = 2*HalfStencilSize; - + typedef Vector StencilCoefficientsType; typedef Offset OffsetType; typedef Vector StencilOffsetsType; - + typedef int InternalSizeT; typedef Vector StencilBufferIndicesType; - + // ****************** Stencil support ****************** - + template struct GetDiffusion; - + template struct GetDiffusion<2,Dummy>{ static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); }; - + template struct GetDiffusion<3,Dummy>{ static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); }; - + // *************** Computation ***************** virtual void GenerateData(); virtual void GenerateStencils(); /// Automatically called by GenerateData virtual void ImageUpdateLoop(); /// Automatically called by GenerateData - + typedef std::pair StencilType; typedef Image StencilImageType; typename StencilImageType::Pointer stencilImage; - + typedef Image ScalarImageType; typename ScalarImageType::Pointer diagonalCoefficients; - + virtual ScalarType MaxStableTimeStep(); - + ScalarType m_DiffusionTime; ScalarType m_RatioToMaxStableTimeStep; int m_MaxNumberOfTimeSteps; - + ScalarType m_EffectiveDiffusionTime; int m_EffectiveNumberOfTimeSteps; virtual void ImageUpdate(ScalarType delta); typename ImageType::Pointer previousImage, nextImage; - + virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} - + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} - + ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; - - + + struct StencilFunctor; struct FunctorType; - + typedef Vector VectorType; static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); private: diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 28c338f0748..b23b0519c54 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -34,17 +34,20 @@ namespace itk /** * \class StructureTensorImageFilter * + * \brief Computes the structure tensor. + * * Implementation of the structure tensor, defined by * * \f[K_\rho (\nabla u_\sigma \otimes \nabla u_\sigma),\f] * * where \f$K_\rho\f$ denotes the gaussian kernel of standard deviation \f$\rho\f$, * and \f$u_\sigma := K_\sigma * u\f$. + * + * \ingroup AnisotropicDiffusionLBR */ template< typename TImage, typename TTensorImage = - Image< SymmetricSecondRankTensor< typename TImage::PixelType,TImage::ImageDimension >, TImage::ImageDimension > -> + Image< SymmetricSecondRankTensor< typename TImage::PixelType,TImage::ImageDimension >, TImage::ImageDimension > > class StructureTensorImageFilter: public ImageToImageFilter< TImage, TTensorImage > { From 262e1b21b754c2ee4799687f0c21f97fcbd651ac Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Mon, 1 Jun 2015 00:13:09 -0400 Subject: [PATCH 13/76] STYLE: Fix KWStyle test. --- .../itkAnisotropicDiffusionLBRImageFilter.h | 77 +- .../itkAnisotropicDiffusionLBRImageFilter.hxx | 207 ++--- .../itkCoherenceEnhancingDiffusionFilter.h | 174 ++--- .../itkCoherenceEnhancingDiffusionFilter.hxx | 95 +++ ...LinearAnisotropicDiffusionLBRImageFilter.h | 151 ++-- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 709 ++++++++++-------- .../include/itkStructureTensorImageFilter.h | 8 +- .../include/itkStructureTensorImageFilter.hxx | 23 +- .../itkUnaryFunctorWithIndexImageFilter.h | 72 +- 9 files changed, 878 insertions(+), 638 deletions(-) create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 21596b017a8..2767e99c049 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -46,35 +46,36 @@ template class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage> { public: - typedef AnisotropicDiffusionLBRImageFilter Self; - typedef ImageToImageFilter< TImage, TImage> Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; + typedef AnisotropicDiffusionLBRImageFilter Self; + typedef ImageToImageFilter< TImage, TImage > 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(AnisotropicDiffusionLBRImageFilter, Superclass); - typedef TImage ImageType; - static const unsigned int Dimension = ImageType::ImageDimension; - + typedef TImage ImageType; typedef typename ImageType::PixelType PixelType; - typedef TScalar ScalarType; + typedef TScalar ScalarType; - typedef SymmetricSecondRankTensor TensorType; - typedef Image TensorImageType; + static const unsigned int Dimension = ImageType::ImageDimension; - typedef StructureTensorImageFilter StructureTensorFilterType; - typedef LinearAnisotropicDiffusionLBRImageFilter LinearDiffusionFilterType; + typedef SymmetricSecondRankTensor< ScalarType, Dimension > TensorType; + typedef Image< TensorType, Dimension > TensorImageType; + typedef StructureTensorImageFilter StructureTensorFilterType; + typedef LinearAnisotropicDiffusionLBRImageFilter LinearDiffusionFilterType; - itkSetMacro(NoiseScale, ScalarType); /// Passed to a StructureTensorImageFilter. + /** Passed to a StructureTensorImageFilter. */ + itkSetMacro(NoiseScale, ScalarType); itkGetConstMacro(NoiseScale, ScalarType); - itkSetMacro(FeatureScale, ScalarType); /// Passed to a StructureTensorImageFilter. + itkSetMacro(FeatureScale, ScalarType); itkGetConstMacro(FeatureScale, ScalarType); - itkSetMacro(RatioToMaxStableTimeStep, ScalarType); /// Passed to a LinearAnisotropicDiffusion Filter. + /** Passed to a LinearAnisotropicDiffusion Filter. */ + itkSetMacro(RatioToMaxStableTimeStep, ScalarType); itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); itkSetMacro(MaxTimeStepsBetweenTensorUpdates, int); itkGetConstMacro(MaxTimeStepsBetweenTensorUpdates, int); @@ -82,52 +83,52 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI itkSetMacro(DiffusionTime, ScalarType); itkGetConstMacro(DiffusionTime, ScalarType); - ///If true, uses unit pixel spacing, and rescales structure tensors for uni maximum trace.. + /** If true, uses unit pixel spacing, and rescales structure + * tensors for uni maximum trace. */ itkSetMacro(Adimensionize, bool); itkGetConstMacro(Adimensionize, bool); - typedef typename TensorType::EigenValuesArrayType EigenValuesArrayType; - /// Transformation of the Structure tensor eigenvalues into the diffusion tensor eigenvalues. Needs to be overloaded in a subclass. (Structure tensor eigenvalues are sorted by increasing order for convenience). + /** Transformation of the Structure tensor eigenvalues into the diffusion + * tensor eigenvalues. Needs to be overloaded in a subclass. + * (Structure tensor eigenvalues are sorted by increasing order for convenience). */ virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const - {itkExceptionMacro("Undefined tensor eigenvalues transform");}; - - virtual typename TensorImageType::Pointer GetLastTensorImage(){return tensorImage;} + { + itkExceptionMacro("Undefined tensor eigenvalues transform"); + } + + virtual typename TensorImageType::Pointer GetLastTensorImage() + { + return m_TensorImage; + } typedef std::vector< std::pair > EffectiveTimesAndIterationsType; itkGetConstReferenceMacro(LinearFilterEffectiveTimesAndIterations, EffectiveTimesAndIterationsType); protected: - ScalarType m_NoiseScale, m_FeatureScale; + ScalarType m_NoiseScale; + ScalarType m_FeatureScale; ScalarType m_RatioToMaxStableTimeStep; - int m_MaxTimeStepsBetweenTensorUpdates; - - AnisotropicDiffusionLBRImageFilter(){ - m_DiffusionTime=1; - m_Adimensionize=true; + int m_MaxTimeStepsBetweenTensorUpdates; - m_NoiseScale=0.5; - m_FeatureScale=2; + AnisotropicDiffusionLBRImageFilter(); + virtual ~AnisotropicDiffusionLBRImageFilter(){} - m_RatioToMaxStableTimeStep=0.7; - m_MaxTimeStepsBetweenTensorUpdates=5; - }; - ~AnisotropicDiffusionLBRImageFilter(){}; + typename TensorImageType::Pointer m_TensorImage; - typename TensorImageType::Pointer tensorImage; virtual void ComputeDiffusionTensors(ImageType*); - ScalarType m_DiffusionTime; - bool m_Adimensionize; + bool m_Adimensionize; - virtual void GenerateData(); + virtual void GenerateData() ITK_OVERRIDE; EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; struct DiffusionTensorFunctor; }; -} + +} // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION #include "itkAnisotropicDiffusionLBRImageFilter.hxx" diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index eacb943b80f..a517cd03415 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -26,103 +26,136 @@ namespace itk { -template -void AnisotropicDiffusionLBRImageFilter::GenerateData(){ - typename ImageType::Pointer inputImage=const_cast(this->GetInput()); - typename ImageType::Pointer image = inputImage; - - typedef typename ImageType::SpacingType SpacingType; - const SpacingType referenceSpacing = inputImage->GetSpacing(); - - // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. - double minSpacing = referenceSpacing[0]; - for(int i=1; i<(int)Dimension; ++i) minSpacing = std::min(minSpacing,referenceSpacing[i]); - const SpacingType unitSpacing = referenceSpacing/minSpacing; - - if(m_Adimensionize) inputImage->SetSpacing(unitSpacing); - - ScalarType remainingTime = m_DiffusionTime; - - while(remainingTime>0){ - ComputeDiffusionTensors(image); - typename LinearDiffusionFilterType::Pointer linearDiffusionFilter = LinearDiffusionFilterType::New(); - linearDiffusionFilter->SetMaxNumberOfTimeSteps(m_MaxTimeStepsBetweenTensorUpdates); - linearDiffusionFilter->SetRatioToMaxStableTimeStep(m_RatioToMaxStableTimeStep); - - linearDiffusionFilter->SetInputImage(image); - linearDiffusionFilter->SetInputTensor(tensorImage); - linearDiffusionFilter->SetMaxDiffusionTime(remainingTime); - linearDiffusionFilter->Update(); - image = linearDiffusionFilter->GetOutput(); - remainingTime -= linearDiffusionFilter->GetEffectiveDiffusionTime(); - - m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair(linearDiffusionFilter->GetEffectiveDiffusionTime(),linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); - - this->UpdateProgress(1.-remainingTime/m_DiffusionTime); +template< typename TImage, typename TScalar > +AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::AnisotropicDiffusionLBRImageFilter(): + m_NoiseScale( 0.5 ), + m_FeatureScale( 2 ), + m_RatioToMaxStableTimeStep( 0.7 ), + m_MaxTimeStepsBetweenTensorUpdates( 5 ), + m_DiffusionTime( 1 ), + m_Adimensionize( true ) +{ +} + + +template< typename TImage, typename TScalar > +void +AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GenerateData() +{ + typename ImageType::Pointer inputImage = const_cast(this->GetInput()); + typename ImageType::Pointer image = inputImage; + + typedef typename ImageType::SpacingType SpacingType; + const SpacingType referenceSpacing = inputImage->GetSpacing(); + + // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. + double minSpacing = referenceSpacing[0]; + for( unsigned int i = 1; i < Dimension; ++i ) + { + minSpacing = std::min(minSpacing,referenceSpacing[i]); } - - if(m_Adimensionize) { - inputImage->SetSpacing(referenceSpacing); - image->SetSpacing(referenceSpacing); + const SpacingType unitSpacing = referenceSpacing/minSpacing; + + if( m_Adimensionize ) + { + inputImage->SetSpacing(unitSpacing); } - this->GraftOutput(image); -} + ScalarType remainingTime = m_DiffusionTime; + + while( remainingTime > 0 ) + { + ComputeDiffusionTensors(image); + typename LinearDiffusionFilterType::Pointer linearDiffusionFilter = LinearDiffusionFilterType::New(); + linearDiffusionFilter->SetMaxNumberOfTimeSteps(m_MaxTimeStepsBetweenTensorUpdates); + linearDiffusionFilter->SetRatioToMaxStableTimeStep(m_RatioToMaxStableTimeStep); + + linearDiffusionFilter->SetInputImage(image); + linearDiffusionFilter->SetInputTensor(m_TensorImage); + linearDiffusionFilter->SetMaxDiffusionTime(remainingTime); + linearDiffusionFilter->Update(); + image = linearDiffusionFilter->GetOutput(); + remainingTime -= linearDiffusionFilter->GetEffectiveDiffusionTime(); + m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair(linearDiffusionFilter->GetEffectiveDiffusionTime(),linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); -template -struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor { - Self * eigenValuesFunctor; - struct OrderingType; - TensorType operator()(const TensorType & S){ - EigenValuesArrayType eigenValues; - typename TensorType::EigenVectorsMatrixType eigenVectors; - S.ComputeEigenAnalysis(eigenValues,eigenVectors); - - // For convenience, eigenvalues are sorted by increasing order - Vector order; - for(int i=0; i<(int)Dimension; ++i) order[i]=i; - - OrderingType ordering(eigenValues); - - std::sort(order.Begin(), order.End(),ordering); - - std::sort(eigenValues.Begin(), eigenValues.End()); - EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); - - TensorType DiffusionTensor; - for(int i=0; i<(int)Dimension; ++i){ - DiffusionTensor(order[i],order[i]) = ev[i]; - for(int j=0; jUpdateProgress(1.-remainingTime/m_DiffusionTime); } + + if(m_Adimensionize) + { + inputImage->SetSpacing(referenceSpacing); + image->SetSpacing(referenceSpacing); + } + this->GraftOutput(image); +} + + +template< typename TImage, typename TScalar > +struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::DiffusionTensorFunctor +{ + Self * eigenValuesFunctor; + struct OrderingType; + TensorType operator()(const TensorType & S) + { + EigenValuesArrayType eigenValues; + typename TensorType::EigenVectorsMatrixType eigenVectors; + S.ComputeEigenAnalysis(eigenValues,eigenVectors); + + // For convenience, eigenvalues are sorted by increasing order + Vector order; + for(int i=0; i<(int)Dimension; ++i) order[i]=i; + + OrderingType ordering(eigenValues); + + std::sort(order.Begin(), order.End(),ordering); + + std::sort(eigenValues.Begin(), eigenValues.End()); + EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); + + TensorType DiffusionTensor; + for(int i=0; i<(int)Dimension; ++i){ + DiffusionTensor(order[i],order[i]) = ev[i]; + for(int j=0; jbool {return eigenValues[i] -struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor::OrderingType { - bool operator()(int i, int j) const {return this->e[i]e[j];} - const EigenValuesArrayType & e; - OrderingType(const EigenValuesArrayType & e_):e(e_){}; + +// c++ 11 would be : [& eigenValues](int i, int j)->bool {return eigenValues[i] +struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::DiffusionTensorFunctor +::OrderingType +{ + bool operator()(int i, int j) const {return this->e[i]e[j];} + const EigenValuesArrayType & e; + OrderingType(const EigenValuesArrayType & e_):e(e_){}; }; -template -void AnisotropicDiffusionLBRImageFilter::ComputeDiffusionTensors(ImageType*image){ - typename StructureTensorFilterType::Pointer structureTensorFilter = StructureTensorFilterType::New(); - - structureTensorFilter->SetNoiseScale(m_NoiseScale); - structureTensorFilter->SetFeatureScale(m_FeatureScale); - structureTensorFilter->SetRescaleForUnitMaximumTrace(m_Adimensionize); - structureTensorFilter->SetInput(image); - - typedef UnaryFunctorImageFilter ImageFunctorType; - typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); - imageFunctor->GetFunctor().eigenValuesFunctor = this; - imageFunctor->SetInput(structureTensorFilter->GetOutput()); - - imageFunctor->Update(); - tensorImage=imageFunctor->GetOutput(); +template< typename TImage, typename TScalar > +void +AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::ComputeDiffusionTensors( ImageType * image ) +{ + typename StructureTensorFilterType::Pointer structureTensorFilter = StructureTensorFilterType::New(); + + structureTensorFilter->SetNoiseScale(m_NoiseScale); + structureTensorFilter->SetFeatureScale(m_FeatureScale); + structureTensorFilter->SetRescaleForUnitMaximumTrace(m_Adimensionize); + structureTensorFilter->SetInput(image); + + typedef UnaryFunctorImageFilter ImageFunctorType; + typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); + imageFunctor->GetFunctor().eigenValuesFunctor = this; + imageFunctor->SetInput(structureTensorFilter->GetOutput()); + + imageFunctor->Update(); + m_TensorImage = imageFunctor->GetOutput(); } } // end namespace itk diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h index 19ff8d5fe04..004d9683cd4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h @@ -29,107 +29,89 @@ namespace itk { /** - Implementation of Coherence Enhancing Diffusion (CED), and Edge Enhancing Diffusion (EED), as described by Weickert. CED heuristically smoothes everywhere except accross image contours, while EED smoothes nowhere but tangentially to image contours. - - The non-linear diffusion tensor is defined in terms of the structure tensor. - Denote by \f$\mu_i\f$ the structure tensor eigenvalues, at a given point \f$x\f$, with \f$0\leq i < d\f$. Let also \f$\mu_{\rm min}\f$ and \f$\mu_{\rm max}\f$, be the smallest and largest eigenvalues respectively. The diffusion tensor is defined by the same eigenvectors, but with modified with eigenvalues \f$\lambda_i\f$. - - Coherence Enhancing Diffusion : \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$.\br - - Edge enhancing diffusion \f$\lambda_i := g(\mu_{\rm max} - \mu_i)\f$, where \f$g(s) = \alpha + (1-\alpha)*exp(-(\lambda/s)^m)\f$. Note the limit values \f$g(0) = \alpha\f$, \f$g(\infty) = 1\f$. + * \class CoherenceEnhancingDiffusionFilter + * + * \brief Coherence enhanging diffusion and edge enhancing diffusion. + * + * Implementation of Coherence Enhancing Diffusion (CED), and + * Edge Enhancing Diffusion (EED), as described by Weickert. + * + * CED heuristically smoothes everywhere except accross image contours, + * while EED smoothes nowhere but tangentially to image contours. + * + * The non-linear diffusion tensor is defined in terms of the structure tensor. + * + * Denote by \f$\mu_i\f$ the structure tensor eigenvalues, at a given point \f$x\f$, + * with \f$0\leq i < d\f$. Let also \f$\mu_{\rm min}\f$ and \f$\mu_{\rm max}\f$, + * be the smallest and largest eigenvalues respectively. The diffusion tensor is + * defined by the same eigenvectors, but with modified with eigenvalues \f$\lambda_i\f$. + * + * Coherence Enhancing Diffusion: + * + * \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$ + * + * Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$.\br + * + * Edge enhancing diffusion: + * + * \f$\lambda_i := g(\mu_{\rm max} - \mu_i)\f$, where \f$g(s) = \alpha + (1-\alpha)*exp(-(\lambda/s)^m)\f$ + * + * Note the limit values \f$g(0) = \alpha\f$, \f$g(\infty) = 1\f$. + * + * \ingroup AnisotropicDiffusionLBR */ -template -class CoherenceEnhancingDiffusionFilter : public AnisotropicDiffusionLBRImageFilter { +template< typename TImage, typename TScalar=typename TImage::PixelType > +class CoherenceEnhancingDiffusionFilter: + public AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +{ public: - typedef CoherenceEnhancingDiffusionFilter Self; - typedef AnisotropicDiffusionLBRImageFilter Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; - - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(CoherenceEnhancingDiffusionFilter, Superclass); - - typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; - virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const; - - typedef typename Superclass::ScalarType ScalarType; - /// Exponent m involved in the function g defining eigenvalues. - itkSetMacro(Exponent, ScalarType); - itkSetMacro(Lambda, ScalarType); - itkSetMacro(Alpha, ScalarType); - - itkGetMacro(Exponent, ScalarType); - itkGetMacro(Lambda, ScalarType); - itkGetMacro(Alpha, ScalarType); - - enum EnhancementType {CED, cCED, EED, cEED, Isotropic}; - /// Switch between CED, EED, and variants. - itkSetEnumMacro(Enhancement, EnhancementType); - itkGetEnumMacro(Enhancement, EnhancementType); - + typedef CoherenceEnhancingDiffusionFilter Self; + typedef AnisotropicDiffusionLBRImageFilter< TImage, TScalar > 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(CoherenceEnhancingDiffusionFilter, Superclass); + + static const unsigned int Dimension = Superclass::Dimension; + + typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; + virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const; + + typedef typename Superclass::ScalarType ScalarType; + /** Exponent m involved in the function g defining eigenvalues. */ + itkSetMacro(Exponent, ScalarType); + itkSetMacro(Lambda, ScalarType); + itkSetMacro(Alpha, ScalarType); + + itkGetMacro(Exponent, ScalarType); + itkGetMacro(Lambda, ScalarType); + itkGetMacro(Alpha, ScalarType); + + enum EnhancementType {CED, cCED, EED, cEED, Isotropic}; + /// Switch between CED, EED, and variants. + itkSetEnumMacro(Enhancement, EnhancementType); + itkGetEnumMacro(Enhancement, EnhancementType); + protected: - ScalarType m_Lambda; - ScalarType m_Exponent; - ScalarType m_Alpha; - EnhancementType m_Enhancement; - - ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} - ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} - - CoherenceEnhancingDiffusionFilter(){ - m_Lambda = 0.05; - m_Exponent = 2; - m_Alpha = 0.01; - m_Enhancement = CED; - } -}; + ScalarType m_Lambda; + ScalarType m_Exponent; + ScalarType m_Alpha; + EnhancementType m_Enhancement; + + ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} + ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} -template -typename CoherenceEnhancingDiffusionFilter::EigenValuesArrayType -CoherenceEnhancingDiffusionFilter::EigenValuesTransform(const EigenValuesArrayType & ev0) const { - static const int Dimension = Superclass::Dimension; - const ScalarType evMin = ev0[0], evMax = ev0[Dimension-1]; - EigenValuesArrayType ev; - switch(m_Enhancement){ - - // Weickert's filter. - case CED: - for(int i=0; i +CoherenceEnhancingDiffusionFilter< TImage, TScalar > +::CoherenceEnhancingDiffusionFilter(): + m_Lambda( 0.05 ), + m_Exponent( 2 ), + m_Alpha( 0.01 ), + m_Enhancement( CED ) +{ +} + + +template< typename TImage, typename TScalar > +typename CoherenceEnhancingDiffusionFilter< TImage, TScalar >::EigenValuesArrayType +CoherenceEnhancingDiffusionFilter< TImage, TScalar > +::EigenValuesTransform(const EigenValuesArrayType & ev0) const +{ + const ScalarType evMin = ev0[0]; + const ScalarType evMax = ev0[Dimension-1]; + + EigenValuesArrayType ev; + switch(m_Enhancement) + { + // Weickert's filter. + case CED: + for( unsigned int i = 0; i < Dimension; ++i ) + { + ev[i] = g_CED(evMax-ev0[i]); + } + break; + + // A variance, requiring stronger coherence. + case cCED: + for( unsigned int i = 0; i < Dimension; ++i ) + { + ev[i] = g_CED( (evMax-ev0[i])/(1.+ev0[i]/m_Lambda) ); + } + break; + + // Weickert's filter. + case EED: + for( unsigned int i = 0; i < Dimension; ++i ) + { + ev[i] = g_EED(ev0[i]-evMin); + } + break; + + // A variant, promoting diffusion in at least one direction at each point. + case cEED: + for( unsigned int i = 0; i < Dimension; ++i ) + { + ev[i] = g_EED(ev0[i]); + } + break; + + // Isotropic tensors, closely related to Perona-Malik's approach. + case Isotropic: + for( unsigned int i = 0; i < Dimension; ++i ) + { + ev[i] = g_EED(evMax); + } + break; + + default: + itkExceptionMacro("Unsupported diffusion type"); + } + return ev; +} + +} // end namespace itk + +#endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 3bc71c127d9..30bace355e8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -47,114 +47,117 @@ class LinearAnisotropicDiffusionLBRImageFilter: public ImageToImageFilter< TImage, TImage > { public: - /** Standard class typedefs. */ - typedef LinearAnisotropicDiffusionLBRImageFilter Self; - typedef ImageToImageFilter< TImage, TImage > Superclass; - typedef SmartPointer< Self > Pointer; + /** Standard class typedefs. */ + typedef LinearAnisotropicDiffusionLBRImageFilter Self; + typedef ImageToImageFilter< TImage, TImage > Superclass; + typedef SmartPointer< Self > Pointer; + typedef SmartPointer< const Self > ConstPointer; - /** Method for creation through the object factory. */ - itkNewMacro(Self); + /** Method for creation through the object factory. */ + itkNewMacro(Self); - /** Run-time type information (and related methods). */ - itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); + /** Run-time type information (and related methods). */ + itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); - typedef TImage ImageType; - static const int Dimension = ImageType::ImageDimension; - typedef typename ImageType::PixelType PixelType; + typedef TImage ImageType; + typedef typename ImageType::PixelType PixelType; - typedef TScalar ScalarType; - typedef SymmetricSecondRankTensor TensorType; - typedef Image TensorImageType; - typedef ImageRegion RegionType; + static const int Dimension = ImageType::ImageDimension; - void SetInputImage(const ImageType* image); - void SetInputTensor(const TensorImageType* tensorImage); + typedef TScalar ScalarType; + typedef SymmetricSecondRankTensor< ScalarType, Dimension > TensorType; + typedef Image< TensorType, Dimension > TensorImageType; + typedef ImageRegion< Dimension > RegionType; - void SetMaxDiffusionTime(ScalarType time); - itkGetConstMacro(DiffusionTime, ScalarType); + void SetInputImage(const ImageType* image); + void SetInputTensor(const TensorImageType* tensorImage); - void SetMaxNumberOfTimeSteps(int n); - itkGetConstMacro(MaxNumberOfTimeSteps, int); + void SetMaxDiffusionTime(ScalarType time); + itkGetConstMacro(DiffusionTime, ScalarType); - void SetRatioToMaxStableTimeStep(ScalarType ratio); - itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); + void SetMaxNumberOfTimeSteps(int n); + itkGetConstMacro(MaxNumberOfTimeSteps, int); - itkGetConstMacro(EffectiveDiffusionTime, ScalarType); - itkGetConstMacro(EffectiveNumberOfTimeSteps, int); + void SetRatioToMaxStableTimeStep(ScalarType ratio); + itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); - itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); - itkGetConstMacro(IterationsTimeCost, ScalarType); + itkGetConstMacro(EffectiveDiffusionTime, ScalarType); + itkGetConstMacro(EffectiveNumberOfTimeSteps, int); + + itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); + itkGetConstMacro(IterationsTimeCost, ScalarType); protected: - LinearAnisotropicDiffusionLBRImageFilter(); - ~LinearAnisotropicDiffusionLBRImageFilter(){} + LinearAnisotropicDiffusionLBRImageFilter(); + virtual ~LinearAnisotropicDiffusionLBRImageFilter(){} - typename ImageType::ConstPointer GetInputImage(); - typename TensorImageType::ConstPointer GetInputTensor(); + typename ImageType::ConstPointer GetInputImage(); + typename TensorImageType::ConstPointer GetInputTensor(); - typedef Index IndexType; + typedef Index IndexType; - // ******* Containers for the stencils used in the discretization - static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; - static const unsigned int StencilSize = 2*HalfStencilSize; + // ******* Containers for the stencils used in the discretization + static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; + static const unsigned int StencilSize = 2 * HalfStencilSize; - typedef Vector StencilCoefficientsType; - typedef Offset OffsetType; - typedef Vector StencilOffsetsType; + typedef Vector StencilCoefficientsType; + typedef Offset OffsetType; + typedef Vector StencilOffsetsType; - typedef int InternalSizeT; - typedef Vector StencilBufferIndicesType; + typedef int InternalSizeT; + typedef Vector StencilBufferIndicesType; - // ****************** Stencil support ****************** + // ****************** Stencil support ****************** - template struct GetDiffusion; + template struct GetDiffusion; - template struct GetDiffusion<2,Dummy>{ - static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); - }; + template struct GetDiffusion<2,Dummy>{ + static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); + }; - template struct GetDiffusion<3,Dummy>{ - static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); - }; + template struct GetDiffusion<3,Dummy>{ + static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); + }; - // *************** Computation ***************** - virtual void GenerateData(); - virtual void GenerateStencils(); /// Automatically called by GenerateData - virtual void ImageUpdateLoop(); /// Automatically called by GenerateData + // *************** Computation ***************** + virtual void GenerateData() ITK_OVERRIDE; + virtual void GenerateStencils(); /// Automatically called by GenerateData + virtual void ImageUpdateLoop(); /// Automatically called by GenerateData - typedef std::pair StencilType; - typedef Image StencilImageType; - typename StencilImageType::Pointer stencilImage; + typedef std::pair< StencilBufferIndicesType, StencilCoefficientsType > StencilType; + typedef Image< StencilType, Dimension > StencilImageType; + typename StencilImageType::Pointer m_StencilImage; - typedef Image ScalarImageType; - typename ScalarImageType::Pointer diagonalCoefficients; + typedef Image ScalarImageType; + typename ScalarImageType::Pointer m_DiagonalCoefficients; - virtual ScalarType MaxStableTimeStep(); + virtual ScalarType MaxStableTimeStep(); - ScalarType m_DiffusionTime; - ScalarType m_RatioToMaxStableTimeStep; - int m_MaxNumberOfTimeSteps; + ScalarType m_DiffusionTime; + ScalarType m_RatioToMaxStableTimeStep; + int m_MaxNumberOfTimeSteps; - ScalarType m_EffectiveDiffusionTime; - int m_EffectiveNumberOfTimeSteps; + ScalarType m_EffectiveDiffusionTime; + int m_EffectiveNumberOfTimeSteps; - virtual void ImageUpdate(ScalarType delta); - typename ImageType::Pointer previousImage, nextImage; + virtual void ImageUpdate(ScalarType delta); + typename ImageType::Pointer m_PreviousImage; + typename ImageType::Pointer m_NextImage; - virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} + virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} - InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} - ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; + ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; + struct StencilFunctor; + struct FunctorType; - struct StencilFunctor; - struct FunctorType; + typedef Vector VectorType; + static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); - typedef Vector VectorType; - static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); private: - LinearAnisotropicDiffusionLBRImageFilter(const Self &); //purposely not implemented - void operator=(const Self &); //purposely not implemented + LinearAnisotropicDiffusionLBRImageFilter(const Self &); //purposely not implemented + void operator=(const Self &); //purposely not implemented }; } // end namespace itk diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 0062d9f2246..d304a9a7e45 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -37,365 +37,468 @@ namespace itk { -template -LinearAnisotropicDiffusionLBRImageFilter::LinearAnisotropicDiffusionLBRImageFilter() +template< typename TImage, typename TScalar > +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::LinearAnisotropicDiffusionLBRImageFilter(): + m_DiffusionTime( 1 ), + m_RatioToMaxStableTimeStep( 0.7 ), + m_MaxNumberOfTimeSteps( 10 ), + m_EffectiveDiffusionTime( 0 ), + m_EffectiveNumberOfTimeSteps( 0 ) { - this->SetNumberOfRequiredInputs(2); - m_DiffusionTime = 1; - m_RatioToMaxStableTimeStep = 0.7; - m_MaxNumberOfTimeSteps = 10; - - m_EffectiveDiffusionTime=0; - m_EffectiveNumberOfTimeSteps=0; + this->SetNumberOfRequiredInputs(2); } -template -void LinearAnisotropicDiffusionLBRImageFilter::SetInputImage(const ImageType* image) + +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::SetInputImage( const ImageType * image ) { - this->SetNthInput(0, const_cast(image)); + this->SetNthInput(0, const_cast(image)); } -template -void LinearAnisotropicDiffusionLBRImageFilter::SetInputTensor(const TensorImageType* tensorImage) + +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::SetInputTensor( const TensorImageType* tensorImage ) { - this->SetNthInput(1, const_cast(tensorImage)); + this->SetNthInput(1, const_cast(tensorImage)); } -template -typename TI::ConstPointer LinearAnisotropicDiffusionLBRImageFilter::GetInputImage() + +template< typename TImage, typename TScalar > +typename TImage::ConstPointer LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GetInputImage() { - return static_cast< const ImageType * > - ( this->ProcessObject::GetInput(0) ); + return static_cast< const ImageType * > ( this->ProcessObject::GetInput(0) ); } -template -typename LinearAnisotropicDiffusionLBRImageFilter::TensorImageType::ConstPointer -LinearAnisotropicDiffusionLBRImageFilter::GetInputTensor() + +template< typename TImage, typename TScalar > +typename LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar >::TensorImageType::ConstPointer +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GetInputTensor() { - return static_cast< const TensorImageType * > - ( this->ProcessObject::GetInput(1) ); + return static_cast< const TensorImageType * > ( this->ProcessObject::GetInput(1) ); } -template -void LinearAnisotropicDiffusionLBRImageFilter::GenerateData() + +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GenerateData() { - timeval start, end; - gettimeofday(&start, NULL); // nullptr is not accepted by older compilers + timeval start; + timeval end; + gettimeofday(&start, NULL); // nullptr is not accepted by older compilers - GenerateStencils(); - this->UpdateProgress(0.5); + GenerateStencils(); + this->UpdateProgress(0.5); - gettimeofday(&end, NULL); - m_SparseMatrixAssemblyTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; - start=end; + gettimeofday(&end, NULL); + m_SparseMatrixAssemblyTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; + start=end; - ImageUpdateLoop(); + ImageUpdateLoop(); - gettimeofday(&end, NULL); - m_IterationsTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; + gettimeofday(&end, NULL); + m_IterationsTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; } // **************************** Computation *********************** -template -struct LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor { - typedef typename TensorImageType::SpacingType SpacingType; - void Initialize(RegionType region_, SpacingType spacing){ - region = region_; - prod[0]=1; - for(int i=1; i +struct LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::StencilFunctor +{ +public: + typedef typename TensorImageType::SpacingType SpacingType; + void Initialize(RegionType region_, SpacingType spacing) + { + region = region_; + prod[0] = 1; + for( int i = 1; i < Dimension; ++i ) + { + prod[i]=prod[i-1]*region.GetSize()[i-1]; + } + for(int i = 0; i < Dimension; ++i ) + { + invSpacing[i] = ScalarType(1) / spacing[i]; + } } - InternalSizeT BufferIndex(const IndexType & x) const { - IndexValueType ans=0; - for(int i=0; iprod[i]*(x[i]-this->region.GetIndex()[i]); - return ans; - } + InternalSizeT BufferIndex(const IndexType & x) const + { + IndexValueType ans=0; + for( int i = 0; i < Dimension; ++i ) + { + ans += this->prod[i] * ( x[i] - this->region.GetIndex()[i] ); + } + return ans; + } + + StencilType operator()(const TensorType & tensor, const IndexType & x) const + { + StencilType stencil; + StencilOffsetsType offsets; + + // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. + + TensorType D; + for(int i=0; iinvSpacing[i]*this->invSpacing[j]; + GetDiffusion<>::Stencil(D,offsets,stencil.second); + + InternalSizeT * yIndex = &stencil.first[0]; + + //Compute buffer offsets from geometrical offsets + for(int i=0; i<(int)HalfStencilSize; ++i){ + for(int orientation = 0; orientation<2; ++orientation, ++yIndex){ + const IndexType y = orientation ? x-offsets[i] : x+offsets[i]; + if(this->region.IsInside(y)){ + *yIndex = this->BufferIndex(y); + } else { + // Neumann boundary conditions. + *yIndex = this->OutsideBufferIndex(); + } // if y + } // for eps + } // for i + return stencil; + } - StencilType operator()(const TensorType & tensor, const IndexType & x) const { - StencilType stencil; - StencilOffsetsType offsets; - - // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. - - TensorType D; - for(int i=0; iinvSpacing[i]*this->invSpacing[j]; - GetDiffusion<>::Stencil(D,offsets,stencil.second); - - InternalSizeT * yIndex = &stencil.first[0]; - - //Compute buffer offsets from geometrical offsets - for(int i=0; i<(int)HalfStencilSize; ++i){ - for(int orientation = 0; orientation<2; ++orientation, ++yIndex){ - const IndexType y = orientation ? x-offsets[i] : x+offsets[i]; - if(this->region.IsInside(y)){ - *yIndex = this->BufferIndex(y); - } else { - // Neumann boundary conditions. - *yIndex = this->OutsideBufferIndex(); - } // if y - } // for eps - } // for i - return stencil; - } protected: - RegionType region; - IndexType prod; - SpacingType invSpacing; - InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} + RegionType region; + IndexType prod; + SpacingType invSpacing; + InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} }; -template -void LinearAnisotropicDiffusionLBRImageFilter::GenerateStencils(){ +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GenerateStencils() +{ // Stencil type is a pair type because itk::UnaryFunctorImage filter // only produces one output // typedef typename TensorImageType::SpacingType SpacingType; - const RegionType region = GetRequestedRegion(); - - typedef UnaryFunctorWithIndexImageFilter FunctorFilterType; - typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); - filter->SetInput(GetInputTensor()); - filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); - filter->Update(); - stencilImage = filter->GetOutput(); - - - //setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. - - diagonalCoefficients = ScalarImageType::New(); - diagonalCoefficients->CopyInformation(GetInputTensor()); - diagonalCoefficients->SetRegions(GetRequestedRegion()); - diagonalCoefficients->Allocate(); - diagonalCoefficients->FillBuffer(ScalarType(0)); - - ImageRegionConstIterator stencilIt(stencilImage,region); - ImageRegionIterator diagIt(diagonalCoefficients, region); - ScalarType * diagBuffer = diagonalCoefficients->GetBufferPointer(); - - for(stencilIt.GoToBegin(), diagIt.GoToBegin(); - !stencilIt.IsAtEnd(); - ++stencilIt, ++diagIt) - for(int i=0; i<(int)StencilSize; ++i) { - const InternalSizeT yIndex = stencilIt.Value().first[i]; - if(yIndex!=OutsideBufferIndex()){ - const ScalarType coefficient = stencilIt.Value().second[i/2]; - diagIt.Value() += coefficient; - diagBuffer[yIndex] += coefficient; - } // if y - } // for i - // for stencilIt, diagIt + const RegionType region = GetRequestedRegion(); + + typedef UnaryFunctorWithIndexImageFilter FunctorFilterType; + typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); + filter->SetInput(GetInputTensor()); + filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); + filter->Update(); + m_StencilImage = filter->GetOutput(); + + + //setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. + + m_DiagonalCoefficients = ScalarImageType::New(); + m_DiagonalCoefficients->CopyInformation(GetInputTensor()); + m_DiagonalCoefficients->SetRegions(GetRequestedRegion()); + m_DiagonalCoefficients->Allocate(); + m_DiagonalCoefficients->FillBuffer(ScalarType(0)); + + ImageRegionConstIterator stencilIt(m_StencilImage,region); + ImageRegionIterator diagIt(m_DiagonalCoefficients, region); + ScalarType * diagBuffer = m_DiagonalCoefficients->GetBufferPointer(); + + for(stencilIt.GoToBegin(), diagIt.GoToBegin(); + !stencilIt.IsAtEnd(); + ++stencilIt, ++diagIt) + { + for(int i = 0; i < (int)StencilSize; ++i) + { + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if( yIndex != OutsideBufferIndex() ) + { + const ScalarType coefficient = stencilIt.Value().second[i/2]; + diagIt.Value() += coefficient; + diagBuffer[yIndex] += coefficient; + } // if y + } // for i + } // for stencilIt, diagIt } -template -typename LinearAnisotropicDiffusionLBRImageFilter::ScalarType -LinearAnisotropicDiffusionLBRImageFilter::MaxStableTimeStep(){ - typedef MinimumMaximumImageCalculator MaxCalculatorType; - typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); - maximumCalculator->SetImage(diagonalCoefficients); - maximumCalculator->SetRegion(GetRequestedRegion()); - maximumCalculator->ComputeMaximum(); - return 1./maximumCalculator->GetMaximum(); -} -template -void LinearAnisotropicDiffusionLBRImageFilter::SetMaxDiffusionTime(ScalarType time){ - if(time<0) - itkExceptionMacro("diffusion time must be finite and positive"); - m_DiffusionTime = time; +template< typename TImage, typename TScalar > +typename LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar >::ScalarType +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::MaxStableTimeStep() +{ + typedef MinimumMaximumImageCalculator MaxCalculatorType; + typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); + maximumCalculator->SetImage(m_DiagonalCoefficients); + maximumCalculator->SetRegion(GetRequestedRegion()); + maximumCalculator->ComputeMaximum(); + return 1./maximumCalculator->GetMaximum(); } -template -void LinearAnisotropicDiffusionLBRImageFilter::SetRatioToMaxStableTimeStep(ScalarType ratio){ - if(ratio<=0 || ratio>1) - itkExceptionMacro("Ratio to max time step " << ratio << "should be within ]0,1]"); - m_RatioToMaxStableTimeStep=ratio; -} -template -void LinearAnisotropicDiffusionLBRImageFilter::SetMaxNumberOfTimeSteps(int n){ - if(n<=0) - itkExceptionMacro("Max number of time steps must be positive"); - m_MaxNumberOfTimeSteps=n; -} - -template -void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdateLoop(){ - ScalarType delta = MaxStableTimeStep() * m_RatioToMaxStableTimeStep; - int n = ceil(m_DiffusionTime / delta); - if(n>m_MaxNumberOfTimeSteps) { - n=m_MaxNumberOfTimeSteps; - m_EffectiveDiffusionTime = n*delta; - } else { - delta = m_DiffusionTime/n; - m_EffectiveDiffusionTime = m_DiffusionTime; - } - m_EffectiveNumberOfTimeSteps=n; - - // Extraction of the region of interest is required for image buffer access. - typedef ExtractImageFilter InputCasterType; - typename InputCasterType::Pointer inputCaster = InputCasterType::New(); - inputCaster->SetInput(GetInputImage()); - inputCaster->SetExtractionRegion(GetRequestedRegion()); - inputCaster->SetDirectionCollapseToIdentity(); - inputCaster->Update(); - previousImage = inputCaster->GetOutput(); - - nextImage = ImageType::New(); - nextImage->CopyInformation(previousImage); - nextImage->SetRegions(previousImage->GetBufferedRegion()); - nextImage->Allocate(); - - for(int k=0; kUpdateProgress(0.5+0.5*k/float(n)); +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::SetMaxDiffusionTime(ScalarType time) +{ + if(time<0) + { + itkExceptionMacro("diffusion time must be finite and positive"); } - this->GraftOutput(previousImage); + m_DiffusionTime = time; } -template -struct LinearAnisotropicDiffusionLBRImageFilter::FunctorType { - ScalarType delta; - PixelType operator()(PixelType output, PixelType input, ScalarType diag){ - return output*this->delta + input*(ScalarType(1)-this->delta*diag); + +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::SetRatioToMaxStableTimeStep(ScalarType ratio) +{ + if(ratio<=0 || ratio>1) + { + itkExceptionMacro("Ratio to max time step " << ratio << "should be within ]0,1]"); } -}; + m_RatioToMaxStableTimeStep=ratio; +} -template -void LinearAnisotropicDiffusionLBRImageFilter::ImageUpdate(ScalarType delta){ -//Setting up iterators +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::SetMaxNumberOfTimeSteps(int n) +{ + if(n<=0) + { + itkExceptionMacro("Max number of time steps must be positive"); + } + m_MaxNumberOfTimeSteps=n; +} -ImageRegion region = GetRequestedRegion(); -ImageRegionConstIterator inputIt(previousImage,region); -ImageRegionIterator outputIt(nextImage,region); +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::ImageUpdateLoop() +{ + ScalarType delta = MaxStableTimeStep() * m_RatioToMaxStableTimeStep; + int n = ceil(m_DiffusionTime / delta); + if(n>m_MaxNumberOfTimeSteps) + { + n = m_MaxNumberOfTimeSteps; + m_EffectiveDiffusionTime = n*delta; + } + else + { + delta = m_DiffusionTime / n; + m_EffectiveDiffusionTime = m_DiffusionTime; + } + m_EffectiveNumberOfTimeSteps = n; + + // Extraction of the region of interest is required for image buffer access. + typedef ExtractImageFilter< ImageType, ImageType > InputCasterType; + typename InputCasterType::Pointer inputCaster = InputCasterType::New(); + inputCaster->SetInput(GetInputImage()); + inputCaster->SetExtractionRegion(GetRequestedRegion()); + inputCaster->SetDirectionCollapseToIdentity(); + inputCaster->Update(); + m_PreviousImage = inputCaster->GetOutput(); + + m_NextImage = ImageType::New(); + m_NextImage->CopyInformation(m_PreviousImage); + m_NextImage->SetRegions(m_PreviousImage->GetBufferedRegion()); + m_NextImage->Allocate(); + + for( int k = 0; k < n; ++k ) + { + ImageUpdate(delta); + std::swap(m_PreviousImage, m_NextImage); + this->UpdateProgress(0.5+0.5*k/float(n)); + } + this->GraftOutput(m_PreviousImage); +} -const PixelType * inputBuffer = previousImage->GetBufferPointer(); -PixelType * outputBuffer = nextImage->GetBufferPointer(); -ImageRegionConstIterator diagIt(diagonalCoefficients, region); -ImageRegionConstIterator stencilIt(stencilImage, region); +template< typename TImage, typename TScalar > +struct LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::FunctorType +{ + ScalarType delta; + PixelType operator()(PixelType output, PixelType input, ScalarType diag){ + return output*this->delta + input*(ScalarType(1)-this->delta*diag); + } +}; -// Rest of function is a hand-made (sparse matrix)*vector product. -nextImage->FillBuffer(0.); -// Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer -for(inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); - !inputIt.IsAtEnd(); - ++inputIt, ++outputIt, ++stencilIt){ - for(int i=0; i<(int)StencilSize; ++i){ - const InternalSizeT yIndex = stencilIt.Value().first[i]; - if(yIndex!=OutsideBufferIndex()){ - const ScalarType coefficient = stencilIt.Value().second[i/2]; - outputIt.Value() += coefficient * (inputBuffer[yIndex]); - outputBuffer[yIndex] += coefficient * inputIt.Value(); +template< typename TImage, typename TScalar > +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::ImageUpdate(ScalarType delta) +{ + //Setting up iterators + ImageRegion region = GetRequestedRegion(); + + ImageRegionConstIterator inputIt(m_PreviousImage,region); + ImageRegionIterator outputIt(m_NextImage,region); + + const PixelType * inputBuffer = m_PreviousImage->GetBufferPointer(); + PixelType * outputBuffer = m_NextImage->GetBufferPointer(); + + ImageRegionConstIterator diagIt(m_DiagonalCoefficients, region); + ImageRegionConstIterator stencilIt(m_StencilImage, region); + + // Rest of function is a hand-made (sparse matrix)*vector product. + m_NextImage->FillBuffer(0.); + + // Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer + for( inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); + !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++stencilIt ) + { + for( int i = 0; i < (int)StencilSize; ++i ) + { + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if( yIndex != OutsideBufferIndex() ) + { + const ScalarType coefficient = stencilIt.Value().second[i/2]; + outputIt.Value() += coefficient * (inputBuffer[yIndex]); + outputBuffer[yIndex] += coefficient * inputIt.Value(); } + } } -} -typedef TernaryFunctorImageFilter ImageFunctorType; -typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); -imageFunctor->SetInput1(nextImage); -imageFunctor->SetInput2(previousImage); -imageFunctor->SetInput3(diagonalCoefficients); -imageFunctor->GetFunctor().delta = delta; - -assert(imageFunctor->CanRunInPlace()); -imageFunctor->InPlaceOn(); -imageFunctor->Update(); -nextImage=imageFunctor->GetOutput(); - -/* -// Old Serial version for diagonal elements -for(inputIt.GoToBegin(), outputIt.GoToBegin(), diagIt.GoToBegin(); - !inputIt.IsAtEnd(); - ++inputIt, ++outputIt, ++diagIt) - outputIt.Value() = delta*outputIt.Value() + (1-delta*diagIt.Value())*inputIt.Value(); -*/ + typedef TernaryFunctorImageFilter ImageFunctorType; + typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); + imageFunctor->SetInput1(m_NextImage); + imageFunctor->SetInput2(m_PreviousImage); + imageFunctor->SetInput3(m_DiagonalCoefficients); + imageFunctor->GetFunctor().delta = delta; + + assert(imageFunctor->CanRunInPlace()); + imageFunctor->InPlaceOn(); + imageFunctor->Update(); + m_NextImage=imageFunctor->GetOutput(); + + /* + // Old Serial version for diagonal elements + for(inputIt.GoToBegin(), outputIt.GoToBegin(), diagIt.GoToBegin(); + !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++diagIt) + outputIt.Value() = delta*outputIt.Value() + (1-delta*diagIt.Value())*inputIt.Value(); + */ } // **************************** subclass SSRT_Traits call method ************************** -template -TS -LinearAnisotropicDiffusionLBRImageFilter::ScalarProduct(const TensorType & m, - const VectorType & u, - const VectorType & v){ -ScalarType result(0); -for(int i=0; i +TScalar +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar> +::ScalarProduct(const TensorType & m, + const VectorType & u, + const VectorType & v) +{ + ScalarType result(0); + for( int i = 0; i < Dimension; ++i ) + { + result += m(i,i) * u[i] * v[i]; + } + for( int i = 0; i < Dimension; ++i ) + { + for( int j = i+1; j < Dimension; ++j ) + { + result += m(i,j) * (u[i] * v[j] + u[j] * v[i]); + } + } + return result; } // 2D stencil construction. -template template -void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<2,Dummy>:: -Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ - -// Construct a superbase, and make it obtuse with Selling's algorithm -VectorType sb[Dimension+1]; //SuperBase -for(int i=0; i +template +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GetDiffusion<2,Dummy> +::Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients) +{ + // Construct a superbase, and make it obtuse with Selling's algorithm + VectorType sb[Dimension+1]; //SuperBase + for(int i=0; i 0 ){ - const VectorType u=sb[i], v=sb[j]; - sb[0]=v-u; - sb[1]=u; - sb[2]=-v; - same=false; - } - if(same) break; -} -if(iter==maxIter) - std::cerr << "Warning: Selling's algorithm not stabilized.\n"; + { + for(int j=0; j 0 ) + { + const VectorType u=sb[i], v=sb[j]; + sb[0]=v-u; + sb[1]=u; + sb[2]=-v; + same=false; + } + } + } + if(same) + { + break; + } + } + if( iter == maxIter ) + { + std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; + } -for(int i=0; i<3; ++i){ + for( int i = 0; i < 3; ++i ) + { Coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); assert(Coefficients[i]>=0); Offsets[i][0] = static_cast(-sb[i][1]); Offsets[i][1] = static_cast( sb[i][0]); -} + } } // 2D stencil construction // 3D stencil construction -template template -void LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion<3,Dummy>:: -Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients){ - -// Construct a superbase, and make it obtuse with Selling's algorithm -typedef Vector VectorType; -VectorType sb[Dimension+1]; -for(int i=0; i +template +void +LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > +::GetDiffusion<3,Dummy>:: +Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients) +{ + // Construct a superbase, and make it obtuse with Selling's algorithm + typedef Vector VectorType; + VectorType sb[Dimension+1]; + for(int i=0; i Weights; -for(int i=1; i Weights; + for(int i=1; i::is_specialized > struct IntermediateFilter; - typename TensorImageType::Pointer intermediateResult; + typename TensorImageType::Pointer m_IntermediateResult; typedef CovariantVector CovariantVectorType; - typedef Image CovariantImageType; + typedef Image CovariantImageType; struct OuterFunctor { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 634ea635c73..3ca2a7503d4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -57,7 +57,7 @@ struct StructureTensorImageFilter< TImage, TTensorImage > outerFilter->SetInput(gradientFilter->GetOutput()); outerFilter->Update(); - self->intermediateResult = outerFilter->GetOutput(); + self->m_IntermediateResult = outerFilter->GetOutput(); } }; @@ -120,7 +120,7 @@ struct StructureTensorImageFilter< TImage, TTensorImage > self->UpdateProgress(index/float( Self::PixelType::Dimension+1 )); } - self->intermediateResult = output; + self->m_IntermediateResult = output; } }; @@ -134,15 +134,16 @@ StructureTensorImageFilter< TImage, TTensorImage > typedef RecursiveGaussianImageFilter GaussianFilterType; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - gaussianFilter->SetInput(intermediateResult); - gaussianFilter->SetSigma(m_FeatureScale); - - if(!m_RescaleForUnitMaximumTrace){ - m_PostRescaling=1.; - gaussianFilter->Update(); - this->GraftOutput(gaussianFilter->GetOutput()); - return; - } + gaussianFilter->SetInput( m_IntermediateResult ); + gaussianFilter->SetSigma( m_FeatureScale ); + + if( !m_RescaleForUnitMaximumTrace ) + { + m_PostRescaling = 1.; + gaussianFilter->Update(); + this->GraftOutput(gaussianFilter->GetOutput()); + return; + } // *** Rescaling for normalization of largest trace *** diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 6db34b3931f..a8a9ad8479e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -31,50 +31,60 @@ namespace itk { + template -class UnaryFunctorWithIndexImageFilter : public ImageToImageFilter { +class UnaryFunctorWithIndexImageFilter: + public ImageToImageFilter +{ public: - typedef UnaryFunctorWithIndexImageFilter Self; - typedef ImageToImageFilter Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; + typedef UnaryFunctorWithIndexImageFilter Self; + typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass; + typedef SmartPointer< Self > Pointer; + typedef SmartPointer< const Self > ConstPointer; + + /** Method for creation through the object factory. */ + itkNewMacro(Self); - /// Method for creation through the object factory. - itkNewMacro(Self); - /// Run-time type information (and related methods). - itkTypeMacro(UnaryFunctorWithIndexImageFilter, Superclass); + /** Run-time type information (and related methods). */ + itkTypeMacro(UnaryFunctorWithIndexImageFilter, Superclass); - typedef TInputImage InputImageType; - typedef TOutputImage OutputImageType; - typedef TFunctor FunctorType; + typedef TInputImage InputImageType; + typedef TOutputImage OutputImageType; + typedef TFunctor FunctorType; - GetSetFunctorMacro(Functor, FunctorType); + GetSetFunctorMacro(Functor, FunctorType); protected: - UnaryFunctorWithIndexImageFilter(){}; + UnaryFunctorWithIndexImageFilter(){} - FunctorType m_Functor; + FunctorType m_Functor; - typedef typename InputImageType::RegionType InputRegionType; - typedef typename OutputImageType::RegionType OutputRegionType; + typedef typename InputImageType::RegionType InputRegionType; + typedef typename OutputImageType::RegionType OutputRegionType; - virtual void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType){ - if(region.GetSize()[0]==0) return; + virtual void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) ITK_OVERRIDE + { + if( region.GetSize()[0] == 0 ) + { + return; + } - ImageRegionConstIteratorWithIndex inputIt( this->GetInput(), region); - ImageScanlineIterator< OutputImageType > outputIt( this->GetOutput(), region); + ImageRegionConstIteratorWithIndex< InputImageType > inputIt( this->GetInput(), region); + ImageScanlineIterator< OutputImageType > outputIt( this->GetOutput(), region); - for(inputIt.GoToBegin(), outputIt.GoToBegin(); - !outputIt.IsAtEnd(); - ){ - while(!outputIt.IsAtEndOfLine()){ - outputIt.Set(m_Functor(inputIt.Value(), inputIt.GetIndex())); - ++inputIt; - ++outputIt; - } - outputIt.NextLine(); + for( inputIt.GoToBegin(), outputIt.GoToBegin(); + !outputIt.IsAtEnd(); + ) + { + while(!outputIt.IsAtEndOfLine()) + { + outputIt.Set(m_Functor(inputIt.Value(), inputIt.GetIndex())); + ++inputIt; + ++outputIt; } - } + outputIt.NextLine(); + } + } }; } // end namespace itk From 8ad47ff93ae41d7cb7bafa4ca19ba82dd53ca9bc Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sat, 20 Jun 2015 14:56:51 -0400 Subject: [PATCH 14/76] COMP: Add missing includes. --- .../include/itkCoherenceEnhancingDiffusionFilter.hxx | 2 ++ .../include/itkStructureTensorImageFilter.h | 1 + 2 files changed, 3 insertions(+) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx index e4fdbe090f8..3f763db005d 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx @@ -19,6 +19,8 @@ #ifndef itkCoherenceEnhancingDiffusionFilter_hxx #define itkCoherenceEnhancingDiffusionFilter_hxx +#include "itkCoherenceEnhancingDiffusionFilter.h" + namespace itk { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index baf1f101dda..63aefaf841e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -28,6 +28,7 @@ #include "itkAddImageFilter.h" #include "itkVectorIndexSelectionCastImageFilter.h" #include "itkGradientImageFilter.h" +#include "itkSymmetricSecondRankTensor.h" namespace itk { From d04d6605c6ecdc10f0b603db084b10930ebafeaf Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sat, 20 Jun 2015 14:57:43 -0400 Subject: [PATCH 15/76] ENH: Use explicit name in CMakeLists.txt. This causes issues when building outside the ITK source tree. --- .../src/CMakeLists.txt | 8 ++--- .../test/CMakeLists.txt | 36 +++++++++---------- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt index 40a7f5e7d62..a9fff05fc91 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt @@ -1,8 +1,8 @@ -set(${itk-module}_SRCS +set(AnisotropicDiffusionLBR_SRCS CoherenceEnhancingDiffusion.cxx ) -add_library(${itk-module} ${${itk-module}_SRCS}) +add_library(AnisotropicDiffusionLBR ${AnisotropicDiffusionLBR_SRCS}) -target_link_libraries(${itk-module} ${${itk-module}_LIBRARIES}) -itk_module_target(${itk-module}) +target_link_libraries(AnisotropicDiffusionLBR ${AnisotropicDiffusionLBR_LIBRARIES}) +itk_module_target(AnisotropicDiffusionLBR) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt index ab025231137..e45f2c7ba4a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt @@ -1,73 +1,73 @@ itk_module_test() -set(${itk-module}Tests +set(AnisotropciDiffusionLBRTests CoherenceEnhancingDiffusionTest.cxx ) -CreateTestDriver(${itk-module} "${${itk-module}-Test_LIBRARIES}" "${${itk-module}Tests}") +CreateTestDriver(AnisotropciDiffusionLBR "${AnisotropciDiffusionLBR-Test_LIBRARIES}" "${AnisotropciDiffusionLBRTests}") set(TestOutput ${ITK_TEST_OUTPUT_DIR}) ################ fig:PacMan ################# -itk_add_test(NAME PacMan_cEED COMMAND ${itk-module}TestDriver +itk_add_test(NAME PacMan_cEED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/PacMan_cEED.png} ${TestOutput}/PacMan_cEED.png CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cEED.png 20 0.05 cEED 3) -itk_add_test(NAME PacMan_cCED COMMAND ${itk-module}TestDriver +itk_add_test(NAME PacMan_cCED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/PacMan_cCED.png} ${TestOutput}/PacMan_cCED.png CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cCED.png 20 0.05 cCED 3) -itk_add_test(NAME PacMan_I COMMAND ${itk-module}TestDriver +itk_add_test(NAME PacMan_I COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/PacMan_I.png} ${TestOutput}/PacMan_I.png CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_I.png 20 0.05 Isotropic 3) ############# fig : Fingerprint ############# -itk_add_test(NAME FingerPrint_cEED COMMAND ${itk-module}TestDriver +itk_add_test(NAME FingerPrint_cEED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/FingerPrint_cEED_20.png} ${TestOutput}/FingerPrint_cEED_20.png CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cEED_20.png 20 0.02 cEED ) -itk_add_test(NAME FingerPrint_cCED COMMAND ${itk-module}TestDriver +itk_add_test(NAME FingerPrint_cCED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/FingerPrint_cCED_20.png} ${TestOutput}/FingerPrint_cCED_20.png CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cCED_20.png 20 0.02 cCED ) -itk_add_test(NAME FingerPrint_I COMMAND ${itk-module}TestDriver +itk_add_test(NAME FingerPrint_I COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/FingerPrint_I_20.png} ${TestOutput}/FingerPrint_I_20.png CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_I_20.png 20 0.02 Isotropic ) ################ fig : Cos3D ################ -itk_add_test(NAME Cos3D_cCED COMMAND ${itk-module}TestDriver +itk_add_test(NAME Cos3D_cCED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Cos3D_cCED.vtk} ${TestOutput}/Cos3D_cCED.vtk CoherenceEnhancingDiffusionTest DATA{Input/Cos3D_Noisy.vtk} ${TestOutput}/Cos3D_cCED.vtk 10 0.02 cCED 4 10 ) ################ fig : Brain ################ -itk_add_test(NAME mrbrain_cEED COMMAND ${itk-module}TestDriver +itk_add_test(NAME mrbrain_cEED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/mrbrain_cEED.vtk} ${TestOutput}/mrbrain_cEED.vtk CoherenceEnhancingDiffusionTest DATA{Input/mrbrain_noisy.vtk} ${TestOutput}/mrbrain_cEED.vtk 5 0.003 cEED ) ################# fig : Lena ################ -itk_add_test(NAME Lena_Detail_cCED_2 COMMAND ${itk-module}TestDriver +itk_add_test(NAME Lena_Detail_cCED_2 COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Lena_Detail_cCED_2.png} ${TestOutput}/Lena_Detail_cCED_2.png CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cCED_2.png 2 0.003 cCED 0.5 2 4 ) -itk_add_test(NAME Lena_Detail_cEED_2 COMMAND ${itk-module}TestDriver +itk_add_test(NAME Lena_Detail_cEED_2 COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Lena_Detail_cEED_2.png} ${TestOutput}/Lena_Detail_cEED_2.png CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cEED_2.png 2 0.003 cEED 0.5 2 4 ) -itk_add_test(NAME Lena_Detail_I_2 COMMAND ${itk-module}TestDriver +itk_add_test(NAME Lena_Detail_I_2 COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Lena_Detail_I_2.png} ${TestOutput}/Lena_Detail_I_2.png CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_I_2.png 2 0.003 Isotropic 0.5 2 4 ) ############## fig : Vector field ########### -itk_add_test(NAME VectorField_Circle_cEED COMMAND ${itk-module}TestDriver +itk_add_test(NAME VectorField_Circle_cEED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/VectorField_Circle_cEED.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk CoherenceEnhancingDiffusionTest DATA{Input/VectorField_CircleOpposites.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk 10 0.05 cEED ) @@ -75,18 +75,18 @@ itk_add_test(NAME VectorField_Circle_cEED COMMAND ${itk-module}TestDriver ############### fig : Triangle ############## -itk_add_test(NAME Triangle_cEED COMMAND ${itk-module}TestDriver +itk_add_test(NAME Triangle_cEED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Triangle_cEED.png} ${TestOutput}/Triangle_cEED.png CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_cEED.png 5 0.03 cEED ) -itk_add_test(NAME Triangle_EED COMMAND ${itk-module}TestDriver +itk_add_test(NAME Triangle_EED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Triangle_EED.png} ${TestOutput}/Triangle_EED.png CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_EED.png 5 0.03 EED ) -itk_add_test(NAME Oscillations1_cCED COMMAND ${itk-module}TestDriver +itk_add_test(NAME Oscillations1_cCED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Oscillations1_cCED.png} ${TestOutput}/Oscillations1_cCED.png CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_cCED.png 20 0.05 cCED ) -itk_add_test(NAME Oscillations1_CED COMMAND ${itk-module}TestDriver +itk_add_test(NAME Oscillations1_CED COMMAND AnisotropciDiffusionLBRTestDriver --compare DATA{Baseline/Oscillations1_CED.png} ${TestOutput}/Oscillations1_CED.png CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_CED.png 20 0.05 CED ) From 2a6cb9aabbdf9286d096cc9938d564a768c1dcb3 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sat, 20 Jun 2015 15:23:15 -0400 Subject: [PATCH 16/76] STYLE: Style fixes to CoherenecEnhancingDiffusionCommandLine. --- .../AnisotropicDiffusionLBR/CMakeLists.txt | 13 +- .../CoherenceEnhancingDiffusionCommandLine.h | 334 +++++++++--------- 2 files changed, 179 insertions(+), 168 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index b46532119bb..c6e8fe76477 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,2 +1,13 @@ project(AnisotropicDiffusionLBR) -itk_module_impl() + +if(ITK_SOURCE_DIR) + itk_module_impl() +else() + cmake_minimum_required(VERSION 2.8) + find_package(ITK REQUIRED) + set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ITK_CMAKE_DIR}) + include(ITKExternalModuleMacros) + itk_module_impl() + #add_subdirectory(src) + #add_subdirectory(test) +endif() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 6a58dfa4445..4816cdc8ecd 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -29,63 +29,66 @@ #include "itkCoherenceEnhancingDiffusionFilter.h" #include "LinearAnisotropicDiffusionCommandLine.h" -namespace CoherenceEnhancingDiffusionCommandLine { - - void Usage(){ - std::cerr << - "Input image filename. 2D and 3D images supported. Required.\n" << - "Output image filename. Required.\n" << - "Diffusion time. Suggested range: 0.5-5, up to 50 for strong noise. Default: 2.\n" << - "Lambda. Small values detect more edges. Suggested range: 0.05, 0.0001. Default: 0.01\n" << - "Weickert diffusion type. Accepted values: Edge, Coherence. Default: Edge.\n" << - "Noise scale. Suggested range: 0.5 - 4. Default 1.\n" << - "Feature scale. Suggested range: 2-6. Default 2.\n" - << "\n"; - } - - using namespace itk; - - int Execute(int argc, char * argv[]); - - template - int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); - - template - int Execute(int argc, char * argv[], int nComponents); - - template - int Execute(int argc, char * argv[]); - - - typedef LinearAnisotropicDiffusionCommandLine::ReportProgressToCErrType ReportProgressToCErrType; - +namespace CoherenceEnhancingDiffusionCommandLine +{ + +void Usage() + { + std::cerr << + "Input image filename. 2D and 3D images supported. Required.\n" << + "Output image filename. Required.\n" << + "Diffusion time. Suggested range: 0.5-5, up to 50 for strong noise. Default: 2.\n" << + "Lambda. Small values detect more edges. Suggested range: 0.05, 0.0001. Default: 0.01\n" << + "Weickert diffusion type. Accepted values: Edge, Coherence. Default: Edge.\n" << + "Noise scale. Suggested range: 0.5 - 4. Default 1.\n" << + "Feature scale. Suggested range: 2-6. Default 2.\n" + << "\n"; + } + +using namespace itk; + +int Execute(int argc, char * argv[]); + +template +int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); + +template +int Execute(int argc, char * argv[], int nComponents); + +template +int Execute(int argc, char * argv[]); + + +typedef LinearAnisotropicDiffusionCommandLine::ReportProgressToCErrType ReportProgressToCErrType; + int Execute(int argc, char * argv[]) { - using std::cerr; - using std::endl; - using namespace itk; - - if(argc<2+1) {Usage(); return EXIT_SUCCESS ;} - - const char *ImageFileName =argv[0+1]; - typedef ImageFileReader > ReaderType; - ReaderType::Pointer reader = ReaderType::New(); - reader->SetFileName(ImageFileName); - - reader->UpdateOutputInformation(); - - const ImageIOBase * io = reader->GetImageIO(); - const int ImageDimension = io->GetNumberOfDimensions(); - const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); - const int nComponents = io->GetNumberOfComponents(); - - switch (ImageDimension) { - case 2: return Execute<2>(argc,argv,componentType,nComponents); - case 3: return Execute<3>(argc,argv,componentType,nComponents); - default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); + using std::cerr; + using std::endl; + using namespace itk; + + if(argc<2+1) {Usage(); return EXIT_SUCCESS ;} + + const char *ImageFileName =argv[0+1]; + typedef ImageFileReader > ReaderType; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(ImageFileName); + + reader->UpdateOutputInformation(); + + const ImageIOBase * io = reader->GetImageIO(); + const int ImageDimension = io->GetNumberOfDimensions(); + const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); + const int nComponents = io->GetNumberOfComponents(); + + switch (ImageDimension) + { + case 2: return Execute<2>(argc,argv,componentType,nComponents); + case 3: return Execute<3>(argc,argv,componentType,nComponents); + default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); } } - + template int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents){ switch (componentType) { @@ -95,7 +98,7 @@ int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType component default: itkGenericExceptionMacro("Sorry, unsupported component type"); } } - + template int Execute(int argc, char * argv[], int nComponents){ switch (nComponents) { @@ -105,121 +108,118 @@ int Execute(int argc, char * argv[], int nComponents){ default: itkGenericExceptionMacro("Sorry, unsupported number of components"); } } - + template -int Execute(int argc, char * argv[]){ - - typedef Image ImageType; - - typedef ImageFileReader ReaderType; - typename ReaderType::Pointer reader = ReaderType::New(); - - const char *imageFileName =argv[0+1]; - const char *outputFileName =argv[1+1]; - reader->SetFileName(imageFileName); - - /*{ - reader->Update(); - auto image = reader->GetOutput(); - std::cerr << image->GetRequestedRegion() << "\n\n"; - std::cerr << image->GetRequestedRegion() << "\n\n"; - }*/ - - typedef CoherenceEnhancingDiffusionFilter DiffusionFilterType; - typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); - diffusionFilter->SetInput(reader->GetOutput()); - - ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); - diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); - - int argIndex = 3; - if(argIndexSetDiffusionTime(diffusionTime); - } - - if(argIndexSetLambda(lambda); - } - - if(argIndexSetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. - else if(!strcmp(enhancement,"cEED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. - else if(!strcmp(enhancement,"CED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. - else if(!strcmp(enhancement, "cCED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. - else if(!strcmp(enhancement, "Isotropic")) - diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); //Perona-Mali's exponent: 2. - else - itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); - } - - if(argIndexSetNoiseScale(noiseScale); - } +int Execute(int argc, char * argv[]) +{ + typedef Image ImageType; - if(argIndexSetFeatureScale(featureScale); - } - - if(argIndexSetExponent(exponent); - } - - if(argIndexGetDiffusionTime() << "\n" << - "Lambda: " << diffusionFilter->GetLambda() << "\n" << - "argc: " << argc << "\n"; - - diffusionFilter->Update(); - auto image = diffusionFilter->GetOutput(); - std::cerr << - image->GetBufferedRegion() << "\n\n" << - "pixel export size: " << sizeof(ExportPixelType) << "\n"; - ; - - }*/ - - - typedef Image ExportImageType; - typedef CastImageFilter CasterType; - typename CasterType::Pointer caster = CasterType::New(); - caster->SetInput(diffusionFilter->GetOutput()); - - //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; - typedef ImageFileWriter WriterType; - typename WriterType::Pointer writer = WriterType::New(); - writer->SetInput(caster->GetOutput()); - writer->SetFileName(outputFileName); - - clock_t top=-clock(); - writer->Update(); - top+=clock(); std::cout << "Took : " << top/double(CLOCKS_PER_SEC) << "s\n"; - - return EXIT_SUCCESS; -} - - - + typedef ImageFileReader ReaderType; + typename ReaderType::Pointer reader = ReaderType::New(); + + const char *imageFileName =argv[0+1]; + const char *outputFileName =argv[1+1]; + reader->SetFileName(imageFileName); + + /*{ + reader->Update(); + auto image = reader->GetOutput(); + std::cerr << image->GetRequestedRegion() << "\n\n"; + std::cerr << image->GetRequestedRegion() << "\n\n"; + }*/ + + typedef CoherenceEnhancingDiffusionFilter DiffusionFilterType; + typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); + diffusionFilter->SetInput(reader->GetOutput()); + + ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); + diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); + + int argIndex = 3; + if(argIndexSetDiffusionTime(diffusionTime); + } + + if(argIndexSetLambda(lambda); + } + + if(argIndexSetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. + else if(!strcmp(enhancement,"cEED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. + else if(!strcmp(enhancement,"CED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. + else if(!strcmp(enhancement, "cCED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. + else if(!strcmp(enhancement, "Isotropic")) + diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); //Perona-Mali's exponent: 2. + else + itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); + } + + if(argIndexSetNoiseScale(noiseScale); + } + + if(argIndexSetFeatureScale(featureScale); + } + + if(argIndexSetExponent(exponent); + } + + if(argIndexGetDiffusionTime() << "\n" << + "Lambda: " << diffusionFilter->GetLambda() << "\n" << + "argc: " << argc << "\n"; + + diffusionFilter->Update(); + auto image = diffusionFilter->GetOutput(); + std::cerr << + image->GetBufferedRegion() << "\n\n" << + "pixel export size: " << sizeof(ExportPixelType) << "\n"; + ; + + }*/ + + typedef Image ExportImageType; + typedef CastImageFilter CasterType; + typename CasterType::Pointer caster = CasterType::New(); + caster->SetInput(diffusionFilter->GetOutput()); + + //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; + typedef ImageFileWriter WriterType; + typename WriterType::Pointer writer = WriterType::New(); + writer->SetInput(caster->GetOutput()); + writer->SetFileName(outputFileName); + + clock_t top=-clock(); + writer->Update(); + top +=clock(); + std::cout << "Took : " << top/double(CLOCKS_PER_SEC) << "s\n"; + + return EXIT_SUCCESS; } +} // end namespace CoherenceEnhancingDiffusionCommandLine + #endif From e70ab47bbe4f01a9360832dcd3b981fa0fdf4bf7 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sat, 20 Jun 2015 16:04:21 -0400 Subject: [PATCH 17/76] ENH: Move the CoherenceEnhanncingDiffusion executable into an examples/ directory. --- .../src/CMakeLists.txt | 8 ----- .../src/CoherenceEnhancingDiffusion.cxx | 34 ------------------- .../test/CoherenceEnhancingDiffusionTest.cxx | 15 ++++---- 3 files changed, 9 insertions(+), 48 deletions(-) delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt deleted file mode 100644 index a9fff05fc91..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -set(AnisotropicDiffusionLBR_SRCS -CoherenceEnhancingDiffusion.cxx - ) - -add_library(AnisotropicDiffusionLBR ${AnisotropicDiffusionLBR_SRCS}) - -target_link_libraries(AnisotropicDiffusionLBR ${AnisotropicDiffusionLBR_LIBRARIES}) -itk_module_target(AnisotropicDiffusionLBR) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx deleted file mode 100644 index 5f92d0fc8dc..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/src/CoherenceEnhancingDiffusion.cxx +++ /dev/null @@ -1,34 +0,0 @@ -/*========================================================================= - * - * 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 -#include -#include "CoherenceEnhancingDiffusionCommandLine.h" - -int main(int argc, char **argv) -{ - try - { - CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); - } - catch(itk::ExceptionObject& e) - { - std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; - return EXIT_FAILURE; - } - return EXIT_SUCCESS; -} diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx index b2c1ee4024d..10398da8b2b 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx @@ -21,13 +21,16 @@ int CoherenceEnhancingDiffusionTest(int argc, char **argv) { - try { - CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); - } catch (itk::ExceptionObject& e) { - std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; - return EXIT_FAILURE; + try + { + CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); } - return EXIT_SUCCESS; + catch (itk::ExceptionObject& e) + { + std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; + return EXIT_FAILURE; + } + return EXIT_SUCCESS; } /* From 27d00bb8427f37d50d30675d0eaf338fd38d0eb6 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 21 Jun 2015 11:30:41 -0400 Subject: [PATCH 18/76] ENH: Create the ImageIO directly get the input image information. --- .../CoherenceEnhancingDiffusionCommandLine.h | 173 ++++++++++-------- 1 file changed, 95 insertions(+), 78 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 4816cdc8ecd..1bebdabb5b9 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -67,45 +67,62 @@ int Execute(int argc, char * argv[]) using std::endl; using namespace itk; - if(argc<2+1) {Usage(); return EXIT_SUCCESS ;} + if(argc < 2 + 1 ) + { + Usage(); + return EXIT_SUCCESS; + } - const char *ImageFileName =argv[0+1]; - typedef ImageFileReader > ReaderType; - ReaderType::Pointer reader = ReaderType::New(); - reader->SetFileName(ImageFileName); + const char * imageFileName = argv[1]; - reader->UpdateOutputInformation(); + itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( imageFileName, itk::ImageIOFactory::ReadMode ); + imageIO->SetFileName( imageFileName ); + imageIO->ReadImageInformation(); - const ImageIOBase * io = reader->GetImageIO(); - const int ImageDimension = io->GetNumberOfDimensions(); - const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); - const int nComponents = io->GetNumberOfComponents(); + const unsigned int imageDimension = imageIO->GetNumberOfDimensions(); + const itk::ImageIOBase::IOComponentType componentType = imageIO->GetComponentType(); + const unsigned int nComponents = imageIO->GetNumberOfComponents(); - switch (ImageDimension) + switch( imageDimension ) { - case 2: return Execute<2>(argc,argv,componentType,nComponents); - case 3: return Execute<3>(argc,argv,componentType,nComponents); - default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); + case 2: + return Execute<2>(argc,argv,componentType,nComponents); + case 3: + return Execute<3>(argc,argv,componentType,nComponents); + default: + itkGenericExceptionMacro("Sorry, unsupported image dimension."); } } template -int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents){ - switch (componentType) { - case itk::ImageIOBase::UCHAR: return Execute(argc,argv,nComponents); - case itk::ImageIOBase::FLOAT: return Execute(argc,argv,nComponents); - case itk::ImageIOBase::DOUBLE:return Execute(argc,argv,nComponents); - default: itkGenericExceptionMacro("Sorry, unsupported component type"); +int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents) +{ + switch(componentType) + { + case itk::ImageIOBase::UCHAR: + return Execute(argc,argv,nComponents); + case itk::ImageIOBase::FLOAT: + return Execute(argc,argv,nComponents); + case itk::ImageIOBase::DOUBLE: + return Execute(argc,argv,nComponents); + default: + itkGenericExceptionMacro("Sorry, unsupported component type"); } } template -int Execute(int argc, char * argv[], int nComponents){ - switch (nComponents) { - case 1: return Execute(argc,argv); - case 2: return Execute,Vector >(argc,argv); - case 3: return Execute,Vector >(argc,argv); - default: itkGenericExceptionMacro("Sorry, unsupported number of components"); +int Execute(int argc, char * argv[], int nComponents) +{ + switch(nComponents) + { + case 1: + return Execute(argc,argv); + case 2: + return Execute,Vector >(argc,argv); + case 3: + return Execute,Vector >(argc,argv); + default: + itkGenericExceptionMacro("Sorry, unsupported number of components"); } } @@ -117,17 +134,10 @@ int Execute(int argc, char * argv[]) typedef ImageFileReader ReaderType; typename ReaderType::Pointer reader = ReaderType::New(); - const char *imageFileName =argv[0+1]; - const char *outputFileName =argv[1+1]; + const char * imageFileName = argv[1]; + const char * outputFileName = argv[2]; reader->SetFileName(imageFileName); - /*{ - reader->Update(); - auto image = reader->GetOutput(); - std::cerr << image->GetRequestedRegion() << "\n\n"; - std::cerr << image->GetRequestedRegion() << "\n\n"; - }*/ - typedef CoherenceEnhancingDiffusionFilter DiffusionFilterType; typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); diffusionFilter->SetInput(reader->GetOutput()); @@ -136,55 +146,62 @@ int Execute(int argc, char * argv[]) diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); int argIndex = 3; - if(argIndexSetDiffusionTime(diffusionTime); - } + if( argIndex < argc ) + { + const double diffusionTime = atof(argv[argIndex++]); + if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); + diffusionFilter->SetDiffusionTime(diffusionTime); + } - if(argIndexSetLambda(lambda); - } + if( argIndex < argc ) + { + const double lambda = atof(argv[argIndex++]); + if(lambda==0.) itkGenericExceptionMacro("Error: Unrecognized lambda (fourth argument).\n"); + diffusionFilter->SetLambda(lambda); + } - if(argIndexSetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. - else if(!strcmp(enhancement,"cEED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. - else if(!strcmp(enhancement,"CED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. - else if(!strcmp(enhancement, "cCED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. - else if(!strcmp(enhancement, "Isotropic")) - diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); //Perona-Mali's exponent: 2. - else - itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); - } + if( argIndex < argc ) + { + const char * enhancement = argv[argIndex++]; + if(!strcmp(enhancement,"EED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. + else if(!strcmp(enhancement,"cEED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. + else if(!strcmp(enhancement,"CED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. + else if(!strcmp(enhancement, "cCED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. + else if(!strcmp(enhancement, "Isotropic")) + diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); //Perona-Mali's exponent: 2. + else + itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); + } - if(argIndexSetNoiseScale(noiseScale); - } + if( argIndex < argc ) + { + const double noiseScale = atof(argv[argIndex++]); + if(noiseScale==0.) itkGenericExceptionMacro("Error: Unrecognized noiseScale (sixth argument).\n"); + diffusionFilter->SetNoiseScale(noiseScale); + } - if(argIndexSetFeatureScale(featureScale); - } + if( argIndex < argc ) + { + const double featureScale = atof(argv[argIndex++]); + if(featureScale==0.) itkGenericExceptionMacro("Error: Unrecognized featureScale (seventh argument).\n"); + diffusionFilter->SetFeatureScale(featureScale); + } - if(argIndexSetExponent(exponent); - } + if( argIndex < argc ) + { + const double exponent = atof(argv[argIndex++]); + if(exponent==0.) itkGenericExceptionMacro("Error: Unrecognized exponent (eighth argument).\n"); + diffusionFilter->SetExponent(exponent); + } - if(argIndex Date: Sun, 21 Jun 2015 15:00:32 -0400 Subject: [PATCH 19/76] ENH: Use itk::TimeProbe to measure runtime. This is cross platform. --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 1bebdabb5b9..0bcad507035 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -28,6 +28,7 @@ #include "itkImageFileWriter.h" #include "itkCoherenceEnhancingDiffusionFilter.h" #include "LinearAnisotropicDiffusionCommandLine.h" +#include "itkTimeProbe.h" namespace CoherenceEnhancingDiffusionCommandLine { @@ -229,10 +230,11 @@ int Execute(int argc, char * argv[]) writer->SetInput(caster->GetOutput()); writer->SetFileName(outputFileName); - clock_t top=-clock(); + itk::TimeProbe clock; + clock.Start(); writer->Update(); - top +=clock(); - std::cout << "Took : " << top/double(CLOCKS_PER_SEC) << "s\n"; + clock.Stop(); + std::cout << "Took: " << clock.GetMean() << " seconds\n"; return EXIT_SUCCESS; } From 2f412b5bd9636b9910bd2ee787b1db75c9ccab05 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 21 Jun 2015 23:15:00 -0400 Subject: [PATCH 20/76] ENH: Add check for valid ImageIO created. --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 0bcad507035..5251e6d5bbb 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -77,6 +77,11 @@ int Execute(int argc, char * argv[]) const char * imageFileName = argv[1]; itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( imageFileName, itk::ImageIOFactory::ReadMode ); + if( imageIO.IsNull() ) + { + std::cerr << "Could not create ImageIO" << std::endl; + return EXIT_FAILURE; + } imageIO->SetFileName( imageFileName ); imageIO->ReadImageInformation(); From 85eee03a8db8c3624dd61a12d9a7bf5f697649a1 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 24 Jun 2015 10:44:42 -0400 Subject: [PATCH 21/76] COMP: Add missing SymmetricSecondRankTensor header. --- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 1 + 1 file changed, 1 insertion(+) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 30bace355e8..8ad76480772 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -25,6 +25,7 @@ #include "itkImageToImageFilter.h" +#include "itkSymmetricSecondRankTensor.h" namespace itk { From 40b9064c2143ab4790f20f02c7ab61c29e604661 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 24 Jun 2015 10:46:25 -0400 Subject: [PATCH 22/76] COMP: Remove sys/time.h header. This is not found in Windows. itk::TimeProbe is a cross-platform replacement. This was used for debug code, so that was removed. --- ...itkLinearAnisotropicDiffusionLBRImageFilter.h | 4 ---- ...kLinearAnisotropicDiffusionLBRImageFilter.hxx | 16 +--------------- 2 files changed, 1 insertion(+), 19 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 8ad76480772..03f975b76f1 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -85,8 +85,6 @@ class LinearAnisotropicDiffusionLBRImageFilter: itkGetConstMacro(EffectiveDiffusionTime, ScalarType); itkGetConstMacro(EffectiveNumberOfTimeSteps, int); - itkGetConstMacro(SparseMatrixAssemblyTimeCost, ScalarType); - itkGetConstMacro(IterationsTimeCost, ScalarType); protected: LinearAnisotropicDiffusionLBRImageFilter(); virtual ~LinearAnisotropicDiffusionLBRImageFilter(){} @@ -148,8 +146,6 @@ class LinearAnisotropicDiffusionLBRImageFilter: InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} - ScalarType m_SparseMatrixAssemblyTimeCost, m_IterationsTimeCost; - struct StencilFunctor; struct FunctorType; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index d304a9a7e45..ff2fdf70b8e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -28,8 +28,6 @@ #include "itkMinimumMaximumImageCalculator.h" #include "itkCastImageFilter.h" #include "itkExtractImageFilter.h" -#include "sys/time.h" - #include "itkUnaryFunctorWithIndexImageFilter.h" #include "itkTernaryFunctorImageFilter.h" @@ -90,22 +88,10 @@ void LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > ::GenerateData() { - timeval start; - timeval end; - gettimeofday(&start, NULL); // nullptr is not accepted by older compilers - GenerateStencils(); this->UpdateProgress(0.5); - gettimeofday(&end, NULL); - m_SparseMatrixAssemblyTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; - start=end; - - - ImageUpdateLoop(); - - gettimeofday(&end, NULL); - m_IterationsTimeCost = (end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.; + this->ImageUpdateLoop(); } // **************************** Computation *********************** From 942a3c9e3b85f8a3e460bd763a83b528d06c97b1 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 24 Jun 2015 17:19:01 -0400 Subject: [PATCH 23/76] BUG: Fix ReportProgressToCOutType name. Uses std::cout instead of std::cerr. --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 4 ++-- .../include/LinearAnisotropicDiffusionCommandLine.h | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 5251e6d5bbb..dcd9a227979 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -60,7 +60,7 @@ templateSetInput(reader->GetOutput()); - ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); + ReportProgressToCOutType::Pointer reportDiffusionProgress = ReportProgressToCOutType::New(); diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); int argIndex = 3; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 6811187d664..8b220ffc694 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -55,9 +55,9 @@ templateSetMaxNumberOfTimeSteps(200); - ReportProgressToCErrType::Pointer reportDiffusionProgress = ReportProgressToCErrType::New(); + ReportProgressToCOutType::Pointer reportDiffusionProgress = ReportProgressToCOutType::New(); diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); typedef Image ExportImageType; From 074c93f0097d82cea7e4d442a18d2f37c9096014 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Wed, 24 Jun 2015 20:18:32 -0400 Subject: [PATCH 24/76] COMP: Address CoherenceEnhancingDiffusionTest signature. --- .../test/CoherenceEnhancingDiffusionTest.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx index 10398da8b2b..ec6970a6d76 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx @@ -19,7 +19,7 @@ #include #include "CoherenceEnhancingDiffusionCommandLine.h" -int CoherenceEnhancingDiffusionTest(int argc, char **argv) +int CoherenceEnhancingDiffusionTest( int argc, char * argv[] ) { try { From c87674ccb45637cb64d56f97ed9a32c2455a2dc5 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 26 Jun 2015 12:40:32 -0400 Subject: [PATCH 25/76] COMP: Use overload dispatch for stencil computation. This is for: c:\jenkins\workspace\itkgerritwindows\itk-src\modules\remote\anisotropicdiffusionlbr\include\itkLinearAnisotropicDiffusionLBRImageFilter.h(110) : warning C4348: 'itk::LinearAnisotropicDiffusionLBRImageFilter::GetDiffusion' : redefinition of default parameter : parameter 1 --- ...LinearAnisotropicDiffusionLBRImageFilter.h | 11 - ...nearAnisotropicDiffusionLBRImageFilter.hxx | 272 +++++++++--------- 2 files changed, 130 insertions(+), 153 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 03f975b76f1..f0540e5c342 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -105,17 +105,6 @@ class LinearAnisotropicDiffusionLBRImageFilter: typedef int InternalSizeT; typedef Vector StencilBufferIndicesType; - // ****************** Stencil support ****************** - - template struct GetDiffusion; - - template struct GetDiffusion<2,Dummy>{ - static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); - }; - - template struct GetDiffusion<3,Dummy>{ - static void Stencil(const TensorType &, StencilOffsetsType &, StencilCoefficientsType &); - }; // *************** Computation ***************** virtual void GenerateData() ITK_OVERRIDE; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index ff2fdf70b8e..af76f267db7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -136,7 +136,7 @@ public: for(int i=0; iinvSpacing[i]*this->invSpacing[j]; - GetDiffusion<>::Stencil(D,offsets,stencil.second); + this->Stencil( Dispatch< Dimension >(), D, offsets, stencil.second ); InternalSizeT * yIndex = &stencil.first[0]; @@ -156,6 +156,135 @@ public: } protected: + struct DispatchBase {}; + template< unsigned int > + struct Dispatch: public DispatchBase {}; + + static void Stencil(const Dispatch< 2 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) + { + // Construct a superbase, and make it obtuse with Selling's algorithm + VectorType sb[Dimension+1]; //SuperBase + for(int i=0; i 0 ) + { + const VectorType u=sb[i], v=sb[j]; + sb[0]=v-u; + sb[1]=u; + sb[2]=-v; + same=false; + } + } + } + if(same) + { + break; + } + } + if( iter == maxIter ) + { + std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; + } + + for( int i = 0; i < 3; ++i ) + { + coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); + assert(coefficients[i]>=0); + + offsets[i][0] = static_cast(-sb[i][1]); + offsets[i][1] = static_cast( sb[i][0]); + } + } + static void Stencil(const Dispatch< 3 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) + { + // Construct a superbase, and make it obtuse with Selling's algorithm + typedef Vector VectorType; + VectorType sb[Dimension+1]; + for(int i=0; i 0 ){ + const VectorType u=sb[i], v=sb[j]; + for(int k=0,l=0; k<=Dimension; ++k) + if(k!=i && k!=j) + sb[l++]=sb[k]+u; + sb[2]=-u; + sb[3]=v; + same=false; + } + if(same) break; + } + if(iter==maxIter) + { + std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; + } + + // Computation of the weights + SymmetricSecondRankTensor Weights; + for(int i=1; i return result; } - -// 2D stencil construction. -template< typename TImage, typename TScalar > -template -void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GetDiffusion<2,Dummy> -::Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients) -{ - // Construct a superbase, and make it obtuse with Selling's algorithm - VectorType sb[Dimension+1]; //SuperBase - for(int i=0; i 0 ) - { - const VectorType u=sb[i], v=sb[j]; - sb[0]=v-u; - sb[1]=u; - sb[2]=-v; - same=false; - } - } - } - if(same) - { - break; - } - } - if( iter == maxIter ) - { - std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; - } - - for( int i = 0; i < 3; ++i ) - { - Coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); - assert(Coefficients[i]>=0); - - Offsets[i][0] = static_cast(-sb[i][1]); - Offsets[i][1] = static_cast( sb[i][0]); - } - -} // 2D stencil construction - - -// 3D stencil construction -template< typename TImage, typename TScalar > -template -void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GetDiffusion<3,Dummy>:: -Stencil(const TensorType &D, StencilOffsetsType &Offsets, StencilCoefficientsType &Coefficients) -{ - // Construct a superbase, and make it obtuse with Selling's algorithm - typedef Vector VectorType; - VectorType sb[Dimension+1]; - for(int i=0; i 0 ){ - const VectorType u=sb[i], v=sb[j]; - for(int k=0,l=0; k<=Dimension; ++k) - if(k!=i && k!=j) - sb[l++]=sb[k]+u; - sb[2]=-u; - sb[3]=v; - same=false; - } - if(same) break; - } - if(iter==maxIter) - { - std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; - } - - // Computation of the weights - SymmetricSecondRankTensor Weights; - for(int i=1; i Date: Fri, 26 Jun 2015 14:47:17 -0400 Subject: [PATCH 26/76] COMP: Use overload dispatch in StructureTensorImageFilter. This is for: c:\jenkins\workspace\itkgerritwindows\itk-src\modules\remote\anisotropicdiffusionlbr\include\itkStructureTensorImageFilter.h(95) : warning C4348: 'itk::StructureTensorImageFilter,itk::Image>::IntermediateFilter' : redefinition of default parameter : parameter 1 on MSVC. --- .../include/itkStructureTensorImageFilter.h | 8 ++- .../include/itkStructureTensorImageFilter.hxx | 56 ++++++++----------- 2 files changed, 30 insertions(+), 34 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 63aefaf841e..191605b35e6 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -92,8 +92,12 @@ class StructureTensorImageFilter: ScalarType m_PostRescaling; bool m_UseGradientRecursiveGaussianImageFilter; - template< typename Dummy=void, bool b=std::numeric_limits::is_specialized > - struct IntermediateFilter; + struct DispatchBase {}; + template< bool > + struct Dispatch: public DispatchBase {}; + + void IntermediateFilter( const Dispatch< true > & ); + void IntermediateFilter( const Dispatch< false > & ); typename TensorImageType::Pointer m_IntermediateResult; typedef CovariantVector CovariantVectorType; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 3ca2a7503d4..0132a52c49e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -40,37 +40,30 @@ StructureTensorImageFilter< TImage, TTensorImage > template< typename TImage, typename TTensorImage > -template< typename Dummy > -struct StructureTensorImageFilter< TImage, TTensorImage > -::IntermediateFilter< Dummy, true > +void +StructureTensorImageFilter< TImage, TTensorImage > +::IntermediateFilter( const Dispatch< true > & ) { - typedef StructureTensorImageFilter< TImage, TTensorImage > Self; - void operator()(Self *self) - { - typedef GradientRecursiveGaussianImageFilter< TImage, Self::CovariantImageType > GradientFilterType; - typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); - gradientFilter->SetInput(self->GetInput()); - gradientFilter->SetSigma(self->m_NoiseScale); + typedef GradientRecursiveGaussianImageFilter< TImage, Self::CovariantImageType > GradientFilterType; + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + gradientFilter->SetInput(this->GetInput()); + gradientFilter->SetSigma(this->m_NoiseScale); - typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; - typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - outerFilter->SetInput(gradientFilter->GetOutput()); + typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; + typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); + outerFilter->SetInput(gradientFilter->GetOutput()); - outerFilter->Update(); - self->m_IntermediateResult = outerFilter->GetOutput(); - } -}; + outerFilter->Update(); + this->m_IntermediateResult = outerFilter->GetOutput(); +} template< typename TImage, typename TTensorImage > -template< typename Dummy > -struct StructureTensorImageFilter< TImage, TTensorImage > -::IntermediateFilter< Dummy, false > +void +StructureTensorImageFilter< TImage, TTensorImage > +::IntermediateFilter( const Dispatch< false > & ) { - typedef StructureTensorImageFilter< TImage, TTensorImage > Self; - void operator()(Self *self) - { - typename Self::ImageType::ConstPointer input = self->GetInput(); + typename Self::ImageType::ConstPointer input = this->GetInput(); typename Self::TensorImageType::Pointer output = Self::TensorImageType::New(); output->CopyInformation(input); output->SetRegions(input->GetRequestedRegion()); @@ -92,13 +85,13 @@ struct StructureTensorImageFilter< TImage, TTensorImage > typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); - gaussianFilter->SetSigma(self->m_NoiseScale); - gradientGaussianFilter->SetSigma(self->m_NoiseScale); + gaussianFilter->SetSigma(this->m_NoiseScale); + gradientGaussianFilter->SetSigma(this->m_NoiseScale); typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - if( self->m_UseGradientRecursiveGaussianImageFilter ) + if( this->m_UseGradientRecursiveGaussianImageFilter ) { gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); outerFilter->SetInput(gradientGaussianFilter->GetOutput()); @@ -118,11 +111,10 @@ struct StructureTensorImageFilter< TImage, TTensorImage > addFilter->Update(); output = addFilter->GetOutput(); - self->UpdateProgress(index/float( Self::PixelType::Dimension+1 )); + this->UpdateProgress(index/float( Self::PixelType::Dimension+1 )); } - self->m_IntermediateResult = output; - } -}; + this->m_IntermediateResult = output; +} template< typename TImage, typename TTensorImage > @@ -130,7 +122,7 @@ void StructureTensorImageFilter< TImage, TTensorImage > ::GenerateData() { - IntermediateFilter<>()(this); + this->IntermediateFilter( Dispatch< std::numeric_limits< PixelType >::is_specialized >() ); typedef RecursiveGaussianImageFilter GaussianFilterType; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); From 8e186a98a8710f39ba8dfbaadb17933e51693eb7 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Tue, 28 Jul 2015 15:14:11 -0400 Subject: [PATCH 27/76] COMP: Remove doxygen unknown command \br. --- .../include/itkCoherenceEnhancingDiffusionFilter.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h index 004d9683cd4..a4641247550 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h @@ -50,7 +50,7 @@ namespace itk * * \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$ * - * Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$.\br + * Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$. * * Edge enhancing diffusion: * From 47d5ac83a3ba0aca75f7dfe1f65aafa6e77d3488 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 17 Jan 2016 23:00:04 -0500 Subject: [PATCH 28/76] BUG: Update ExternalModule build for ITK 4.9. --- .../AnisotropicDiffusionLBR/CMakeLists.txt | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index c6e8fe76477..d9115867005 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,13 +1,10 @@ +cmake_minimum_required(VERSION 2.8.9) project(AnisotropicDiffusionLBR) -if(ITK_SOURCE_DIR) - itk_module_impl() +if(NOT ITK_SOURCE_DIR) + find_package(ITK 4.9 REQUIRED) + list(APPEND CMAKE_MODULE_PATH ${ITK_CMAKE_DIR}) + include(ITKModuleExternal) else() - cmake_minimum_required(VERSION 2.8) - find_package(ITK REQUIRED) - set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ITK_CMAKE_DIR}) - include(ITKExternalModuleMacros) itk_module_impl() - #add_subdirectory(src) - #add_subdirectory(test) endif() From fbc250f8f2223fa5752fc1ebe835b99267df56fd Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 11 Sep 2016 20:07:40 -0400 Subject: [PATCH 29/76] ENH: Add better default template argument for TScalar (RealType) --- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkCoherenceEnhancingDiffusionFilter.h | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 2767e99c049..bdca14ecaaa 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -42,8 +42,8 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template -class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage> +template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > +class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > { public: typedef AnisotropicDiffusionLBRImageFilter Self; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h index a4641247550..215596eb719 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h @@ -60,7 +60,7 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template< typename TImage, typename TScalar=typename TImage::PixelType > +template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > class CoherenceEnhancingDiffusionFilter: public AnisotropicDiffusionLBRImageFilter< TImage, TScalar > { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index f0540e5c342..2d516246077 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -43,7 +43,7 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template< typename TImage, typename TScalar = typename TImage::PixelType > +template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > class LinearAnisotropicDiffusionLBRImageFilter: public ImageToImageFilter< TImage, TImage > { From 4715bf75fc8d00763aff65606eeeaa3b2653e749 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 11 Sep 2016 20:23:43 -0400 Subject: [PATCH 30/76] ENH: Add Python wrapping --- .../Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt | 3 +++ .../wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap | 3 +++ .../wrapping/itkCoherenceEnhancingDiffusionFilter.wrap | 3 +++ 3 files changed, 9 insertions(+) create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt new file mode 100644 index 00000000000..0db043cd281 --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt @@ -0,0 +1,3 @@ +itk_wrap_module(AnisotropicDiffusionLBR) +itk_auto_load_submodules() +itk_end_wrap_module() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap new file mode 100644 index 00000000000..475a7ab755f --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap @@ -0,0 +1,3 @@ +itk_wrap_class("itk::AnisotropicDiffusionLBRImageFilter" POINTER) + itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1) +itk_end_wrap_class() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap new file mode 100644 index 00000000000..b780c71ef8a --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap @@ -0,0 +1,3 @@ +itk_wrap_class("itk::CoherenceEnhancingDiffusionFilter" POINTER) + itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1) +itk_end_wrap_class() From 8c90ef19c22e0235a750dbd1751dc13f073b1e8c Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Sun, 11 Sep 2016 20:41:06 -0400 Subject: [PATCH 31/76] STYLE: Rename itk::CoherenceEnhancingDiffusionImageFilter Follow ITK style naming conventions (image filters should end with ImageFilter). --- .../CoherenceEnhancingDiffusionCommandLine.h | 4 ++-- .../LinearAnisotropicDiffusionCommandLine.h | 2 +- .../itkAnisotropicDiffusionLBRImageFilter.h | 2 +- ... itkCoherenceEnhancingDiffusionImageFilter.h} | 16 ++++++++-------- ...tkCoherenceEnhancingDiffusionImageFilter.hxx} | 14 +++++++------- .../itkCoherenceEnhancingDiffusionFilter.wrap | 3 --- ...tkCoherenceEnhancingDiffusionImageFilter.wrap | 3 +++ 7 files changed, 22 insertions(+), 22 deletions(-) rename Modules/Filtering/AnisotropicDiffusionLBR/include/{itkCoherenceEnhancingDiffusionFilter.h => itkCoherenceEnhancingDiffusionImageFilter.h} (90%) rename Modules/Filtering/AnisotropicDiffusionLBR/include/{itkCoherenceEnhancingDiffusionFilter.hxx => itkCoherenceEnhancingDiffusionImageFilter.hxx} (84%) delete mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index dcd9a227979..2cd9063cd21 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -26,7 +26,7 @@ #include "itkImageFileReader.h" #include "itkImageFileWriter.h" -#include "itkCoherenceEnhancingDiffusionFilter.h" +#include "itkCoherenceEnhancingDiffusionImageFilter.h" #include "LinearAnisotropicDiffusionCommandLine.h" #include "itkTimeProbe.h" @@ -144,7 +144,7 @@ int Execute(int argc, char * argv[]) const char * outputFileName = argv[2]; reader->SetFileName(imageFileName); - typedef CoherenceEnhancingDiffusionFilter DiffusionFilterType; + typedef CoherenceEnhancingDiffusionImageFilter DiffusionFilterType; typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); diffusionFilter->SetInput(reader->GetOutput()); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 8b220ffc694..59ed7814d7e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -25,7 +25,7 @@ #include "itkImageFileReader.h" #include "itkImageFileWriter.h" -#include "itkCoherenceEnhancingDiffusionFilter.h" +#include "itkCoherenceEnhancingDiffusionImageFilter.h" namespace LinearAnisotropicDiffusionCommandLine { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index bdca14ecaaa..dc0b114f692 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -38,7 +38,7 @@ namespace itk * obtained by computing the image structure tensors, and appropriately * modifying their eigenvalues with the method EigenValuesTransform. The * latter method is not implemented, and needs to be provided in a subclass, - * such as CoherenceEnhancingDiffusionFilter. + * such as CoherenceEnhancingDiffusionImageFilter. * * \ingroup AnisotropicDiffusionLBR */ diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h similarity index 90% rename from Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h rename to Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index 215596eb719..abf664865a8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -20,8 +20,8 @@ // // -#ifndef itkCoherenceEnhancingDiffusionFilter_h -#define itkCoherenceEnhancingDiffusionFilter_h +#ifndef itkCoherenceEnhancingDiffusionImageFilter_h +#define itkCoherenceEnhancingDiffusionImageFilter_h #include "itkAnisotropicDiffusionLBRImageFilter.h" @@ -29,7 +29,7 @@ namespace itk { /** - * \class CoherenceEnhancingDiffusionFilter + * \class CoherenceEnhancingDiffusionImageFilter * * \brief Coherence enhanging diffusion and edge enhancing diffusion. * @@ -61,11 +61,11 @@ namespace itk * \ingroup AnisotropicDiffusionLBR */ template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > -class CoherenceEnhancingDiffusionFilter: +class CoherenceEnhancingDiffusionImageFilter: public AnisotropicDiffusionLBRImageFilter< TImage, TScalar > { public: - typedef CoherenceEnhancingDiffusionFilter Self; + typedef CoherenceEnhancingDiffusionImageFilter Self; typedef AnisotropicDiffusionLBRImageFilter< TImage, TScalar > Superclass; typedef SmartPointer< Self > Pointer; typedef SmartPointer< const Self > ConstPointer; @@ -74,7 +74,7 @@ class CoherenceEnhancingDiffusionFilter: itkNewMacro(Self); /** Run-time type information (and related methods). */ - itkTypeMacro(CoherenceEnhancingDiffusionFilter, Superclass); + itkTypeMacro(CoherenceEnhancingDiffusionImageFilter, Superclass); static const unsigned int Dimension = Superclass::Dimension; @@ -105,13 +105,13 @@ class CoherenceEnhancingDiffusionFilter: ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} - CoherenceEnhancingDiffusionFilter(); + CoherenceEnhancingDiffusionImageFilter(); }; } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION -#include "itkCoherenceEnhancingDiffusionFilter.hxx" +#include "itkCoherenceEnhancingDiffusionImageFilter.hxx" #endif #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx similarity index 84% rename from Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx rename to Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx index 3f763db005d..558b80cdc8d 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx @@ -16,17 +16,17 @@ * *=========================================================================*/ -#ifndef itkCoherenceEnhancingDiffusionFilter_hxx -#define itkCoherenceEnhancingDiffusionFilter_hxx +#ifndef itkCoherenceEnhancingDiffusionImageFilter_hxx +#define itkCoherenceEnhancingDiffusionImageFilter_hxx -#include "itkCoherenceEnhancingDiffusionFilter.h" +#include "itkCoherenceEnhancingDiffusionImageFilter.h" namespace itk { template< typename TImage, typename TScalar > -CoherenceEnhancingDiffusionFilter< TImage, TScalar > -::CoherenceEnhancingDiffusionFilter(): +CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > +::CoherenceEnhancingDiffusionImageFilter(): m_Lambda( 0.05 ), m_Exponent( 2 ), m_Alpha( 0.01 ), @@ -36,8 +36,8 @@ CoherenceEnhancingDiffusionFilter< TImage, TScalar > template< typename TImage, typename TScalar > -typename CoherenceEnhancingDiffusionFilter< TImage, TScalar >::EigenValuesArrayType -CoherenceEnhancingDiffusionFilter< TImage, TScalar > +typename CoherenceEnhancingDiffusionImageFilter< TImage, TScalar >::EigenValuesArrayType +CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > ::EigenValuesTransform(const EigenValuesArrayType & ev0) const { const ScalarType evMin = ev0[0]; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap deleted file mode 100644 index b780c71ef8a..00000000000 --- a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionFilter.wrap +++ /dev/null @@ -1,3 +0,0 @@ -itk_wrap_class("itk::CoherenceEnhancingDiffusionFilter" POINTER) - itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1) -itk_end_wrap_class() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap new file mode 100644 index 00000000000..98432a7183e --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap @@ -0,0 +1,3 @@ +itk_wrap_class("itk::CoherenceEnhancingDiffusionImageFilter" POINTER) + itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1) +itk_end_wrap_class() From ced16afa255db32ac5d5168d055da8a776e7a79b Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Mon, 12 Sep 2016 17:48:57 -0400 Subject: [PATCH 32/76] COMP: Add missing header to itkStructureTensorImageFilter.hxx --- .../include/itkStructureTensorImageFilter.hxx | 1 + 1 file changed, 1 insertion(+) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 0132a52c49e..7c019687bf9 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -24,6 +24,7 @@ #define itkStructureTensorImageFilter_hxx #include "itkStructureTensorImageFilter.h" +#include "itkMinimumMaximumImageCalculator.h" namespace itk { From 8e2d0eba39ceecf72c7574fd95a7a23079a3b988 Mon Sep 17 00:00:00 2001 From: Francois Budin Date: Mon, 2 Jan 2017 14:40:10 -0500 Subject: [PATCH 33/76] BUG: Missing include header in hxx files itkAnisotropicDiffusionLBRImageFilter.hxx and itkLinearAnisotropicDiffusionLBRImageFilter.hxx did not include their respective header files. The automatically generated test created by BuildHeaderTest.py AnisotropicDiffusionLBRHeaderTest1.cxx was not compiling as it includes the "hxx" files instead of the "h" files when the former are available. --- .../include/itkAnisotropicDiffusionLBRImageFilter.hxx | 2 ++ .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index a517cd03415..cf032e587fc 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -23,6 +23,8 @@ #ifndef itkAnisotropicDiffusionLBRImageFilter_hxx #define itkAnisotropicDiffusionLBRImageFilter_hxx +#include "itkAnisotropicDiffusionLBRImageFilter.h" + namespace itk { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index af76f267db7..bc563f947c8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -28,7 +28,7 @@ #include "itkMinimumMaximumImageCalculator.h" #include "itkCastImageFilter.h" #include "itkExtractImageFilter.h" - +#include "itkLinearAnisotropicDiffusionLBRImageFilter.h" #include "itkUnaryFunctorWithIndexImageFilter.h" #include "itkTernaryFunctorImageFilter.h" From 23b2c69ab387a0612a0205c04c25fda18ba5bbc0 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Thu, 31 Aug 2017 15:24:06 -0400 Subject: [PATCH 34/76] COMP: Add missing ImageToImageFilter base class #include To address: ITK-src/Modules/Remote/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h:37:28: error: expected template-name before '<' token --- .../include/itkUnaryFunctorWithIndexImageFilter.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index a8a9ad8479e..9828fdd7e15 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -26,12 +26,15 @@ #include "itkImageRegionConstIteratorWithIndex.h" #include "itkImageScanlineIterator.h" #include "itkAnisotropicDiffusionLBRMacro.h" -/** A (simplification of) UnaryFunctorImageFilter, which provides the pixel index to the functor. - */ +#include "itkImageToImageFilter.h" namespace itk { +/** \class UnaryFunctorWithIndexImageFilter + * + * \brief A (simplification of) UnaryFunctorImageFilter, which provides the pixel index to the functor. + */ template class UnaryFunctorWithIndexImageFilter: public ImageToImageFilter From 954f435f9789ad57b30515f3504660ca0394152d Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 1 Sep 2017 11:59:36 -0400 Subject: [PATCH 35/76] BUG: Add module Doxygen group --- .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 9828fdd7e15..770bdd5d111 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -34,6 +34,8 @@ namespace itk /** \class UnaryFunctorWithIndexImageFilter * * \brief A (simplification of) UnaryFunctorImageFilter, which provides the pixel index to the functor. + * + * \ingroup AnisotropicDiffusionLBR */ template class UnaryFunctorWithIndexImageFilter: From 7430c6853637dddfffd50dc674cd2d247b808a39 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 8 Sep 2017 14:27:43 -0400 Subject: [PATCH 36/76] BUG: Correct command line example diffusion types --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 2cd9063cd21..5a7e2af6ee0 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -40,7 +40,7 @@ void Usage() "Output image filename. Required.\n" << "Diffusion time. Suggested range: 0.5-5, up to 50 for strong noise. Default: 2.\n" << "Lambda. Small values detect more edges. Suggested range: 0.05, 0.0001. Default: 0.01\n" << - "Weickert diffusion type. Accepted values: Edge, Coherence. Default: Edge.\n" << + "Weickert diffusion type. Accepted values: CED, cCED, EED, cEED, Isotropic. Default: CED.\n" << "Noise scale. Suggested range: 0.5 - 4. Default 1.\n" << "Feature scale. Suggested range: 2-6. Default 2.\n" << "\n"; From 3ebd7e6e38298247fbc01afe9b80b2dccffc12c8 Mon Sep 17 00:00:00 2001 From: Jon Haitz Legarreta Date: Wed, 17 Jan 2018 17:08:15 +0100 Subject: [PATCH 37/76] ENH: Require cmake minimum version to be 3.9.5. Require CMake minimum version to be 3.9.5 following ITKv5 requiring C++11: https://discourse.itk.org/t/minimum-cmake-version-update/585 --- Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index d9115867005..e34f6085468 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 2.8.9) +cmake_minimum_required(VERSION 3.9.5) project(AnisotropicDiffusionLBR) if(NOT ITK_SOURCE_DIR) From 7455c3ad1c3a11cf421008764ddf6defc7d247b5 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Sat, 16 Dec 2017 19:16:53 -0600 Subject: [PATCH 38/76] 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/LinearAnisotropicDiffusionCommandLine.h | 4 ++-- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkStructureTensorImageFilter.h | 2 +- .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 +- 6 files changed, 9 insertions(+), 9 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 59ed7814d7e..e319a810e01 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -58,11 +58,11 @@ int Execute(int argc, char * argv[]); struct ReportProgressToCOutType : public itk::Command { itkNewMacro(ReportProgressToCOutType); - void Execute(itk::Object *caller, const itk::EventObject & event){ + void Execute(itk::Object *caller, const itk::EventObject & event) ITK_OVERRIDE{ Execute( (const itk::Object *)caller, event); } - void Execute(const itk::Object * object, const itk::EventObject &){ + void Execute(const itk::Object * object, const itk::EventObject &) ITK_OVERRIDE{ std::cout << object->GetNameOfClass() << " has completed: " << int(100*dynamic_cast(object)->GetProgress()) << "%" << std::endl; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index dc0b114f692..d1a1c80ec89 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -112,7 +112,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI int m_MaxTimeStepsBetweenTensorUpdates; AnisotropicDiffusionLBRImageFilter(); - virtual ~AnisotropicDiffusionLBRImageFilter(){} + ~AnisotropicDiffusionLBRImageFilter() ITK_OVERRIDE{} typename TensorImageType::Pointer m_TensorImage; @@ -121,7 +121,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI ScalarType m_DiffusionTime; bool m_Adimensionize; - virtual void GenerateData() ITK_OVERRIDE; + void GenerateData() ITK_OVERRIDE; EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index abf664865a8..dd44c66e76a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -79,7 +79,7 @@ class CoherenceEnhancingDiffusionImageFilter: static const unsigned int Dimension = Superclass::Dimension; typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; - virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const; + EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const ITK_OVERRIDE; typedef typename Superclass::ScalarType ScalarType; /** Exponent m involved in the function g defining eigenvalues. */ diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 2d516246077..ae1b2391244 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -87,7 +87,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: protected: LinearAnisotropicDiffusionLBRImageFilter(); - virtual ~LinearAnisotropicDiffusionLBRImageFilter(){} + ~LinearAnisotropicDiffusionLBRImageFilter() ITK_OVERRIDE{} typename ImageType::ConstPointer GetInputImage(); typename TensorImageType::ConstPointer GetInputTensor(); @@ -107,7 +107,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: // *************** Computation ***************** - virtual void GenerateData() ITK_OVERRIDE; + void GenerateData() ITK_OVERRIDE; virtual void GenerateStencils(); /// Automatically called by GenerateData virtual void ImageUpdateLoop(); /// Automatically called by GenerateData diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 191605b35e6..1e37012dfa1 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -84,7 +84,7 @@ class StructureTensorImageFilter: itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. protected: - virtual void GenerateData() ITK_OVERRIDE; + void GenerateData() ITK_OVERRIDE; ScalarType m_FeatureScale; ScalarType m_NoiseScale; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 770bdd5d111..ce8a5f44268 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -67,7 +67,7 @@ class UnaryFunctorWithIndexImageFilter: typedef typename InputImageType::RegionType InputRegionType; typedef typename OutputImageType::RegionType OutputRegionType; - virtual void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) ITK_OVERRIDE + void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) ITK_OVERRIDE { if( region.GetSize()[0] == 0 ) { From f40517b2f414405432318a4b7aa36c7b842d7b00 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Sat, 16 Dec 2017 19:36:24 -0600 Subject: [PATCH 39/76] 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/LinearAnisotropicDiffusionCommandLine.h | 4 ++-- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkStructureTensorImageFilter.h | 2 +- .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 +- 6 files changed, 9 insertions(+), 9 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index e319a810e01..7591c0975fa 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -58,11 +58,11 @@ int Execute(int argc, char * argv[]); struct ReportProgressToCOutType : public itk::Command { itkNewMacro(ReportProgressToCOutType); - void Execute(itk::Object *caller, const itk::EventObject & event) ITK_OVERRIDE{ + void Execute(itk::Object *caller, const itk::EventObject & event) override{ Execute( (const itk::Object *)caller, event); } - void Execute(const itk::Object * object, const itk::EventObject &) ITK_OVERRIDE{ + void Execute(const itk::Object * object, const itk::EventObject &) override{ std::cout << object->GetNameOfClass() << " has completed: " << int(100*dynamic_cast(object)->GetProgress()) << "%" << std::endl; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index d1a1c80ec89..2b77a157cd3 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -112,7 +112,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI int m_MaxTimeStepsBetweenTensorUpdates; AnisotropicDiffusionLBRImageFilter(); - ~AnisotropicDiffusionLBRImageFilter() ITK_OVERRIDE{} + ~AnisotropicDiffusionLBRImageFilter() override{} typename TensorImageType::Pointer m_TensorImage; @@ -121,7 +121,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI ScalarType m_DiffusionTime; bool m_Adimensionize; - void GenerateData() ITK_OVERRIDE; + void GenerateData() override; EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index dd44c66e76a..1685d8ebc07 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -79,7 +79,7 @@ class CoherenceEnhancingDiffusionImageFilter: static const unsigned int Dimension = Superclass::Dimension; typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; - EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const ITK_OVERRIDE; + EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const override; typedef typename Superclass::ScalarType ScalarType; /** Exponent m involved in the function g defining eigenvalues. */ diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index ae1b2391244..93d28e846e5 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -87,7 +87,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: protected: LinearAnisotropicDiffusionLBRImageFilter(); - ~LinearAnisotropicDiffusionLBRImageFilter() ITK_OVERRIDE{} + ~LinearAnisotropicDiffusionLBRImageFilter() override{} typename ImageType::ConstPointer GetInputImage(); typename TensorImageType::ConstPointer GetInputTensor(); @@ -107,7 +107,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: // *************** Computation ***************** - void GenerateData() ITK_OVERRIDE; + void GenerateData() override; virtual void GenerateStencils(); /// Automatically called by GenerateData virtual void ImageUpdateLoop(); /// Automatically called by GenerateData diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 1e37012dfa1..3c7e0724b8c 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -84,7 +84,7 @@ class StructureTensorImageFilter: itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. protected: - void GenerateData() ITK_OVERRIDE; + void GenerateData() override; ScalarType m_FeatureScale; ScalarType m_NoiseScale; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index ce8a5f44268..d097c0e55c7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -67,7 +67,7 @@ class UnaryFunctorWithIndexImageFilter: typedef typename InputImageType::RegionType InputRegionType; typedef typename OutputImageType::RegionType OutputRegionType; - void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) ITK_OVERRIDE + void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) override { if( region.GetSize()[0] == 0 ) { From e979121a1a0a4a837ea2e1c13347ea92fac92776 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Sun, 14 Jan 2018 10:49:55 -0700 Subject: [PATCH 40/76] STYLE: Remove unused typedef --- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 1 - 1 file changed, 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index bc563f947c8..ac30555405e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -214,7 +214,6 @@ protected: static void Stencil(const Dispatch< 3 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) { // Construct a superbase, and make it obtuse with Selling's algorithm - typedef Vector VectorType; VectorType sb[Dimension+1]; for(int i=0; i Date: Mon, 12 Feb 2018 23:29:25 -0600 Subject: [PATCH 41/76] 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. --- .../CoherenceEnhancingDiffusionCommandLine.h | 18 ++++---- .../LinearAnisotropicDiffusionCommandLine.h | 24 +++++------ .../itkAnisotropicDiffusionLBRImageFilter.h | 26 ++++++------ .../itkAnisotropicDiffusionLBRImageFilter.hxx | 4 +- ...tkCoherenceEnhancingDiffusionImageFilter.h | 12 +++--- ...LinearAnisotropicDiffusionLBRImageFilter.h | 42 +++++++++---------- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 12 +++--- .../include/itkStructureTensorImageFilter.h | 24 +++++------ .../include/itkStructureTensorImageFilter.hxx | 24 +++++------ .../itkUnaryFunctorWithIndexImageFilter.h | 18 ++++---- 10 files changed, 102 insertions(+), 102 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 5a7e2af6ee0..a0c5e114c3f 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -60,7 +60,7 @@ template int Execute(int argc, char * argv[]) { - typedef Image ImageType; + using ImageType = Image; - typedef ImageFileReader ReaderType; + using ReaderType = ImageFileReader; typename ReaderType::Pointer reader = ReaderType::New(); const char * imageFileName = argv[1]; const char * outputFileName = argv[2]; reader->SetFileName(imageFileName); - typedef CoherenceEnhancingDiffusionImageFilter DiffusionFilterType; + using DiffusionFilterType = CoherenceEnhancingDiffusionImageFilter; typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); diffusionFilter->SetInput(reader->GetOutput()); @@ -220,17 +220,17 @@ int Execute(int argc, char * argv[]) std::cerr << image->GetBufferedRegion() << "\n\n" << "pixel export size: " << sizeof(ExportPixelType) << "\n"; - ; +; }*/ - typedef Image ExportImageType; - typedef CastImageFilter CasterType; + using ExportImageType = Image; + using CasterType = CastImageFilter; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(diffusionFilter->GetOutput()); - //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; - typedef ImageFileWriter WriterType; + //using ScalarImageType = typename DiffusionFilterType::ScalarImageType; + using WriterType = ImageFileWriter; typename WriterType::Pointer writer = WriterType::New(); writer->SetInput(caster->GetOutput()); writer->SetFileName(outputFileName); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 7591c0975fa..3bb9dbe82ca 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -76,10 +76,10 @@ int Execute(int argc, char * argv[]) using std::endl; using namespace itk; - if(argc<4+1) {Usage(); return EXIT_SUCCESS ;} + if(argc<4+1) {Usage(); return EXIT_SUCCESS;} const char *imageFileName =argv[0+1]; - typedef ImageFileReader > ReaderType; + using ReaderType = ImageFileReader >; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(imageFileName); @@ -138,16 +138,16 @@ template ImageType; - typedef ImageFileReader ReaderType; + using ImageType = Image; + using ReaderType = ImageFileReader; typename ReaderType::Pointer reader = ReaderType::New(); const char *imageFileName =argv[0+1]; reader->SetFileName(imageFileName); // Import tensors - typedef SymmetricSecondRankTensor TensorType; - typedef Image TensorImageType; - typedef ImageFileReader TensorReaderType; + using TensorType = SymmetricSecondRankTensor; + using TensorImageType = Image; + using TensorReaderType = ImageFileReader; typename TensorReaderType::Pointer tensorReader = TensorReaderType::New(); const char * tensorImageFileName = argv[1+1]; tensorReader->SetFileName(tensorImageFileName); @@ -160,7 +160,7 @@ int Execute(int argc, char * argv[]){ const char *outputFileName = argv[3+1]; // Setup diffusion filter - typedef LinearAnisotropicDiffusionLBRImageFilter DiffusionFilterType; + using DiffusionFilterType = LinearAnisotropicDiffusionLBRImageFilter; typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); diffusionFilter->SetInputImage(reader->GetOutput()); diffusionFilter->SetInputTensor(tensorReader->GetOutput()); @@ -183,13 +183,13 @@ int Execute(int argc, char * argv[]){ ReportProgressToCOutType::Pointer reportDiffusionProgress = ReportProgressToCOutType::New(); diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); - typedef Image ExportImageType; - typedef CastImageFilter CasterType; + using ExportImageType = Image; + using CasterType = CastImageFilter; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(diffusionFilter->GetOutput()); - //typedef typename DiffusionFilterType::ScalarImageType ScalarImageType; - typedef ImageFileWriter WriterType; + //using ScalarImageType = typename DiffusionFilterType::ScalarImageType; + using WriterType = ImageFileWriter; typename WriterType::Pointer writer = WriterType::New(); writer->SetInput(caster->GetOutput()); writer->SetFileName(outputFileName); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 2b77a157cd3..97e8f285016 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -46,27 +46,27 @@ template< typename TImage, typename TScalar = typename NumericTraits< typename T class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > { public: - typedef AnisotropicDiffusionLBRImageFilter Self; - typedef ImageToImageFilter< TImage, TImage > Superclass; - typedef SmartPointer< Self > Pointer; - typedef SmartPointer< const Self > ConstPointer; + using Self = AnisotropicDiffusionLBRImageFilter; + using Superclass = ImageToImageFilter< TImage, TImage >; + using Pointer = SmartPointer< Self >; + using ConstPointer = SmartPointer< const Self >; /// Method for creation through the object factory. itkNewMacro(Self); /// Run-time type information (and related methods). itkTypeMacro(AnisotropicDiffusionLBRImageFilter, Superclass); - typedef TImage ImageType; - typedef typename ImageType::PixelType PixelType; - typedef TScalar ScalarType; + using ImageType = TImage; + using PixelType = typename ImageType::PixelType; + using ScalarType = TScalar; static const unsigned int Dimension = ImageType::ImageDimension; - typedef SymmetricSecondRankTensor< ScalarType, Dimension > TensorType; - typedef Image< TensorType, Dimension > TensorImageType; + using TensorType = SymmetricSecondRankTensor< ScalarType, Dimension >; + using TensorImageType = Image< TensorType, Dimension >; - typedef StructureTensorImageFilter StructureTensorFilterType; - typedef LinearAnisotropicDiffusionLBRImageFilter LinearDiffusionFilterType; + using StructureTensorFilterType = StructureTensorImageFilter; + using LinearDiffusionFilterType = LinearAnisotropicDiffusionLBRImageFilter; /** Passed to a StructureTensorImageFilter. */ itkSetMacro(NoiseScale, ScalarType); @@ -88,7 +88,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI itkSetMacro(Adimensionize, bool); itkGetConstMacro(Adimensionize, bool); - typedef typename TensorType::EigenValuesArrayType EigenValuesArrayType; + using EigenValuesArrayType = typename TensorType::EigenValuesArrayType; /** Transformation of the Structure tensor eigenvalues into the diffusion * tensor eigenvalues. Needs to be overloaded in a subclass. * (Structure tensor eigenvalues are sorted by increasing order for convenience). */ @@ -101,7 +101,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI { return m_TensorImage; } - typedef std::vector< std::pair > EffectiveTimesAndIterationsType; + using EffectiveTimesAndIterationsType = std::vector< std::pair >; itkGetConstReferenceMacro(LinearFilterEffectiveTimesAndIterations, EffectiveTimesAndIterationsType); protected: diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index cf032e587fc..5743da38992 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -49,7 +49,7 @@ AnisotropicDiffusionLBRImageFilter< TImage, TScalar > typename ImageType::Pointer inputImage = const_cast(this->GetInput()); typename ImageType::Pointer image = inputImage; - typedef typename ImageType::SpacingType SpacingType; + using SpacingType = typename ImageType::SpacingType; const SpacingType referenceSpacing = inputImage->GetSpacing(); // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. @@ -151,7 +151,7 @@ AnisotropicDiffusionLBRImageFilter< TImage, TScalar > structureTensorFilter->SetRescaleForUnitMaximumTrace(m_Adimensionize); structureTensorFilter->SetInput(image); - typedef UnaryFunctorImageFilter ImageFunctorType; + using ImageFunctorType = UnaryFunctorImageFilter; typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); imageFunctor->GetFunctor().eigenValuesFunctor = this; imageFunctor->SetInput(structureTensorFilter->GetOutput()); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index 1685d8ebc07..30d8f1925ee 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -65,10 +65,10 @@ class CoherenceEnhancingDiffusionImageFilter: public AnisotropicDiffusionLBRImageFilter< TImage, TScalar > { public: - typedef CoherenceEnhancingDiffusionImageFilter Self; - typedef AnisotropicDiffusionLBRImageFilter< TImage, TScalar > Superclass; - typedef SmartPointer< Self > Pointer; - typedef SmartPointer< const Self > ConstPointer; + using Self = CoherenceEnhancingDiffusionImageFilter; + using Superclass = AnisotropicDiffusionLBRImageFilter< TImage, TScalar >; + using Pointer = SmartPointer< Self >; + using ConstPointer = SmartPointer< const Self >; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -78,10 +78,10 @@ class CoherenceEnhancingDiffusionImageFilter: static const unsigned int Dimension = Superclass::Dimension; - typedef typename Superclass::EigenValuesArrayType EigenValuesArrayType; + using EigenValuesArrayType = typename Superclass::EigenValuesArrayType; EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const override; - typedef typename Superclass::ScalarType ScalarType; + using ScalarType = typename Superclass::ScalarType; /** Exponent m involved in the function g defining eigenvalues. */ itkSetMacro(Exponent, ScalarType); itkSetMacro(Lambda, ScalarType); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 93d28e846e5..a74ed653c54 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -48,11 +48,11 @@ class LinearAnisotropicDiffusionLBRImageFilter: public ImageToImageFilter< TImage, TImage > { public: - /** Standard class typedefs. */ - typedef LinearAnisotropicDiffusionLBRImageFilter Self; - typedef ImageToImageFilter< TImage, TImage > Superclass; - typedef SmartPointer< Self > Pointer; - typedef SmartPointer< const Self > ConstPointer; + /** Standard class type alias. */ + using Self = LinearAnisotropicDiffusionLBRImageFilter; + using Superclass = ImageToImageFilter< TImage, TImage >; + using Pointer = SmartPointer< Self >; + using ConstPointer = SmartPointer< const Self >; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -60,15 +60,15 @@ class LinearAnisotropicDiffusionLBRImageFilter: /** Run-time type information (and related methods). */ itkTypeMacro(LinearAnisotropicDiffusionLBRImageFilter, ImageToImageFilter); - typedef TImage ImageType; - typedef typename ImageType::PixelType PixelType; + using ImageType = TImage; + using PixelType = typename ImageType::PixelType; static const int Dimension = ImageType::ImageDimension; - typedef TScalar ScalarType; - typedef SymmetricSecondRankTensor< ScalarType, Dimension > TensorType; - typedef Image< TensorType, Dimension > TensorImageType; - typedef ImageRegion< Dimension > RegionType; + using ScalarType = TScalar; + using TensorType = SymmetricSecondRankTensor< ScalarType, Dimension >; + using TensorImageType = Image< TensorType, Dimension >; + using RegionType = ImageRegion< Dimension >; void SetInputImage(const ImageType* image); void SetInputTensor(const TensorImageType* tensorImage); @@ -92,18 +92,18 @@ class LinearAnisotropicDiffusionLBRImageFilter: typename ImageType::ConstPointer GetInputImage(); typename TensorImageType::ConstPointer GetInputTensor(); - typedef Index IndexType; + using IndexType = Index; // ******* Containers for the stencils used in the discretization static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; static const unsigned int StencilSize = 2 * HalfStencilSize; - typedef Vector StencilCoefficientsType; - typedef Offset OffsetType; - typedef Vector StencilOffsetsType; + using StencilCoefficientsType = Vector; + using OffsetType = Offset; + using StencilOffsetsType = Vector; - typedef int InternalSizeT; - typedef Vector StencilBufferIndicesType; + using InternalSizeT = int; + using StencilBufferIndicesType = Vector; // *************** Computation ***************** @@ -111,11 +111,11 @@ class LinearAnisotropicDiffusionLBRImageFilter: virtual void GenerateStencils(); /// Automatically called by GenerateData virtual void ImageUpdateLoop(); /// Automatically called by GenerateData - typedef std::pair< StencilBufferIndicesType, StencilCoefficientsType > StencilType; - typedef Image< StencilType, Dimension > StencilImageType; + using StencilType = std::pair< StencilBufferIndicesType, StencilCoefficientsType >; + using StencilImageType = Image< StencilType, Dimension >; typename StencilImageType::Pointer m_StencilImage; - typedef Image ScalarImageType; + using ScalarImageType = Image; typename ScalarImageType::Pointer m_DiagonalCoefficients; virtual ScalarType MaxStableTimeStep(); @@ -138,7 +138,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: struct StencilFunctor; struct FunctorType; - typedef Vector VectorType; + using VectorType = Vector; static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); private: diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index ac30555405e..5cfb90619a0 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -100,7 +100,7 @@ struct LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > ::StencilFunctor { public: - typedef typename TensorImageType::SpacingType SpacingType; + using SpacingType = typename TensorImageType::SpacingType; void Initialize(RegionType region_, SpacingType spacing) { region = region_; @@ -298,10 +298,10 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > { // Stencil type is a pair type because itk::UnaryFunctorImage filter // only produces one output -// typedef typename TensorImageType::SpacingType SpacingType; +// using SpacingType = typename TensorImageType::SpacingType; const RegionType region = GetRequestedRegion(); - typedef UnaryFunctorWithIndexImageFilter FunctorFilterType; + using FunctorFilterType = UnaryFunctorWithIndexImageFilter; typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); filter->SetInput(GetInputTensor()); filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); @@ -344,7 +344,7 @@ typename LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar >::ScalarType LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > ::MaxStableTimeStep() { - typedef MinimumMaximumImageCalculator MaxCalculatorType; + using MaxCalculatorType = MinimumMaximumImageCalculator; typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); maximumCalculator->SetImage(m_DiagonalCoefficients); maximumCalculator->SetRegion(GetRequestedRegion()); @@ -412,7 +412,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > m_EffectiveNumberOfTimeSteps = n; // Extraction of the region of interest is required for image buffer access. - typedef ExtractImageFilter< ImageType, ImageType > InputCasterType; + using InputCasterType = ExtractImageFilter< ImageType, ImageType >; typename InputCasterType::Pointer inputCaster = InputCasterType::New(); inputCaster->SetInput(GetInputImage()); inputCaster->SetExtractionRegion(GetRequestedRegion()); @@ -483,7 +483,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > } } - typedef TernaryFunctorImageFilter ImageFunctorType; + using ImageFunctorType = TernaryFunctorImageFilter; typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); imageFunctor->SetInput1(m_NextImage); imageFunctor->SetInput2(m_PreviousImage); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 3c7e0724b8c..f2d3089f3be 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -53,23 +53,23 @@ class StructureTensorImageFilter: public ImageToImageFilter< TImage, TTensorImage > { public: - typedef StructureTensorImageFilter Self; - typedef ImageToImageFilter< TImage, TImage> Superclass; - typedef SmartPointer Pointer; - typedef SmartPointer ConstPointer; + using Self = StructureTensorImageFilter; + using Superclass = ImageToImageFilter< TImage, TImage>; + using Pointer = SmartPointer; + using ConstPointer = SmartPointer; /// Method for creation through the object factory. itkNewMacro(Self); /// Run-time type information (and related methods). itkTypeMacro(StructureTensorImageFilter, Superclass); - typedef TImage ImageType; - typedef typename ImageType::PixelType PixelType; + using ImageType = TImage; + using PixelType = typename ImageType::PixelType; static const unsigned int Dimension = ImageType::ImageDimension; - typedef TTensorImage TensorImageType; - typedef typename TensorImageType::PixelType TensorType; - typedef typename TensorType::ComponentType ScalarType; - typedef Image ScalarImageType; + using TensorImageType = TTensorImage; + using TensorType = typename TensorImageType::PixelType; + using ScalarType = typename TensorType::ComponentType; + using ScalarImageType = Image; ///Parameter \f$\sigma\f$ of the structure tensor definition. itkSetMacro(NoiseScale, ScalarType); @@ -100,8 +100,8 @@ class StructureTensorImageFilter: void IntermediateFilter( const Dispatch< false > & ); typename TensorImageType::Pointer m_IntermediateResult; - typedef CovariantVector CovariantVectorType; - typedef Image CovariantImageType; + using CovariantVectorType = CovariantVector; + using CovariantImageType = Image; struct OuterFunctor { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 7c019687bf9..402b4395ba0 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -45,12 +45,12 @@ void StructureTensorImageFilter< TImage, TTensorImage > ::IntermediateFilter( const Dispatch< true > & ) { - typedef GradientRecursiveGaussianImageFilter< TImage, Self::CovariantImageType > GradientFilterType; + using GradientFilterType = GradientRecursiveGaussianImageFilter< TImage, Self::CovariantImageType >; typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); gradientFilter->SetInput(this->GetInput()); gradientFilter->SetSigma(this->m_NoiseScale); - typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; + using OuterFilterType = UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor >; typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); outerFilter->SetInput(gradientFilter->GetOutput()); @@ -73,14 +73,14 @@ StructureTensorImageFilter< TImage, TTensorImage > for( unsigned int index = 0; index < Self::PixelType::Dimension; ++index ) { - typedef VectorIndexSelectionCastImageFilter< Self::ImageType, Self::ScalarImageType > SelectionFilterType; + using SelectionFilterType = VectorIndexSelectionCastImageFilter< Self::ImageType, Self::ScalarImageType >; typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); selectionFilter->SetIndex(index); selectionFilter->SetInput(input); - typedef RecursiveGaussianImageFilter< Self::ScalarImageType > GaussianFilterType; - typedef GradientImageFilter< Self::ScalarImageType, Self::ScalarType, Self::ScalarType, Self::CovariantImageType > GradientFilterType; - typedef GradientRecursiveGaussianImageFilter< Self::ScalarImageType, Self::CovariantImageType > GradientGaussianFilterType; + using GaussianFilterType = RecursiveGaussianImageFilter< Self::ScalarImageType >; + using GradientFilterType = GradientImageFilter< Self::ScalarImageType, Self::ScalarType, Self::ScalarType, Self::CovariantImageType >; + using GradientGaussianFilterType = GradientRecursiveGaussianImageFilter< Self::ScalarImageType, Self::CovariantImageType >; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); @@ -89,7 +89,7 @@ StructureTensorImageFilter< TImage, TTensorImage > gaussianFilter->SetSigma(this->m_NoiseScale); gradientGaussianFilter->SetSigma(this->m_NoiseScale); - typedef UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor > OuterFilterType; + using OuterFilterType = UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor >; typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); if( this->m_UseGradientRecursiveGaussianImageFilter ) @@ -104,7 +104,7 @@ StructureTensorImageFilter< TImage, TTensorImage > outerFilter->SetInput(gradientFilter->GetOutput()); } - typedef AddImageFilter< Self::TensorImageType > AddFilterType; + using AddFilterType = AddImageFilter< Self::TensorImageType >; typename AddFilterType::Pointer addFilter = AddFilterType::New(); addFilter->InPlaceOn(); addFilter->SetInput1(output); @@ -125,7 +125,7 @@ StructureTensorImageFilter< TImage, TTensorImage > { this->IntermediateFilter( Dispatch< std::numeric_limits< PixelType >::is_specialized >() ); - typedef RecursiveGaussianImageFilter GaussianFilterType; + using GaussianFilterType = RecursiveGaussianImageFilter; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput( m_IntermediateResult ); gaussianFilter->SetSigma( m_FeatureScale ); @@ -140,15 +140,15 @@ StructureTensorImageFilter< TImage, TTensorImage > // *** Rescaling for normalization of largest trace *** - typedef UnaryFunctorImageFilter TraceFilterType; + using TraceFilterType = UnaryFunctorImageFilter; typename TraceFilterType::Pointer traceFilter = TraceFilterType::New(); traceFilter->SetInput(gaussianFilter->GetOutput()); - typedef MinimumMaximumImageCalculator MaximumCalculatorType; + using MaximumCalculatorType = MinimumMaximumImageCalculator; typename MaximumCalculatorType::Pointer maximumCalculator = MaximumCalculatorType::New(); maximumCalculator->SetImage(traceFilter->GetOutput()); - typedef UnaryFunctorImageFilter ScaleFilterType; + using ScaleFilterType = UnaryFunctorImageFilter; typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); scaleFilter->SetInput(gaussianFilter->GetOutput()); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index d097c0e55c7..715ce38f9a8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -42,10 +42,10 @@ class UnaryFunctorWithIndexImageFilter: public ImageToImageFilter { public: - typedef UnaryFunctorWithIndexImageFilter Self; - typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass; - typedef SmartPointer< Self > Pointer; - typedef SmartPointer< const Self > ConstPointer; + using Self = UnaryFunctorWithIndexImageFilter; + using Superclass = ImageToImageFilter< TInputImage, TOutputImage >; + using Pointer = SmartPointer< Self >; + using ConstPointer = SmartPointer< const Self >; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -53,9 +53,9 @@ class UnaryFunctorWithIndexImageFilter: /** Run-time type information (and related methods). */ itkTypeMacro(UnaryFunctorWithIndexImageFilter, Superclass); - typedef TInputImage InputImageType; - typedef TOutputImage OutputImageType; - typedef TFunctor FunctorType; + using InputImageType = TInputImage; + using OutputImageType = TOutputImage; + using FunctorType = TFunctor; GetSetFunctorMacro(Functor, FunctorType); @@ -64,8 +64,8 @@ class UnaryFunctorWithIndexImageFilter: FunctorType m_Functor; - typedef typename InputImageType::RegionType InputRegionType; - typedef typename OutputImageType::RegionType OutputRegionType; + using InputRegionType = typename InputImageType::RegionType; + using OutputRegionType = typename OutputImageType::RegionType; void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) override { From 748fe00faea574505c1db8e762e5b1349631716b Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Tue, 13 Feb 2018 08:23:44 -0600 Subject: [PATCH 42/76] STYLE: Prefer constexpr for const numeric literals Use constexpr for constant numeric literals. --- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 5cfb90619a0..80d2ce57598 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -173,7 +173,7 @@ protected: } sb[Dimension] = -(sb[0]+sb[1]); - const int maxIter=200; + constexpr int maxIter = 200; int iter=0; for(; iter Date: Mon, 19 Feb 2018 22:26:54 +0100 Subject: [PATCH 43/76] DOC: Fix EED and CED diffusion tensor eignevalues doc error. Fix documentation error in the EED and the CED expressions of the diffusion tensor eigenvalues. Changed according to the expressions in the IJ paper: http://insight-journal.org/browse/publication/953 Fixes #17. --- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index 30d8f1925ee..a49bab7c9e6 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -46,13 +46,13 @@ namespace itk * be the smallest and largest eigenvalues respectively. The diffusion tensor is * defined by the same eigenvectors, but with modified with eigenvalues \f$\lambda_i\f$. * - * Coherence Enhancing Diffusion: + * Edge Enhancing Diffusion: * * \f$\lambda_i := g(\mu_i - \mu_{\rm min})\f$, where \f$g(s) = 1 - (1-\alpha)*exp(-(\lambda/s)^m)\f$ * * Note the limit values \f$g(0) = 1\f$, \f$g(\infty) = \alpha\f$. * - * Edge enhancing diffusion: + * Coherence Enhancing Diffusion: * * \f$\lambda_i := g(\mu_{\rm max} - \mu_i)\f$, where \f$g(s) = \alpha + (1-\alpha)*exp(-(\lambda/s)^m)\f$ * From 48664759baffababd227cc6d57675fd2fedb9c22 Mon Sep 17 00:00:00 2001 From: Jon Haitz Legarreta Date: Sat, 14 Apr 2018 19:22:35 +0200 Subject: [PATCH 44/76] 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/itkLinearAnisotropicDiffusionLBRImageFilter.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index a74ed653c54..6f64c8078df 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -48,6 +48,8 @@ class LinearAnisotropicDiffusionLBRImageFilter: public ImageToImageFilter< TImage, TImage > { public: + ITK_DISALLOW_COPY_AND_ASSIGN(LinearAnisotropicDiffusionLBRImageFilter); + /** Standard class type alias. */ using Self = LinearAnisotropicDiffusionLBRImageFilter; using Superclass = ImageToImageFilter< TImage, TImage >; @@ -141,9 +143,6 @@ class LinearAnisotropicDiffusionLBRImageFilter: using VectorType = Vector; static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); -private: - LinearAnisotropicDiffusionLBRImageFilter(const Self &); //purposely not implemented - void operator=(const Self &); //purposely not implemented }; } // end namespace itk From 886131804eeac09ada0579196b5aebb88d3bcedc Mon Sep 17 00:00:00 2001 From: Jon Haitz Legarreta Date: Sat, 5 May 2018 12:20:11 +0200 Subject: [PATCH 45/76] COMP: Set the minimum required CMake version to 3.10.2. As agreed in: https://discourse.itk.org/t/cmake-update/870/ Set the `cmake_minimum_required` to version **3.10.2**. --- Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index e34f6085468..090935b87e2 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.9.5) +cmake_minimum_required(VERSION 3.10.2) project(AnisotropicDiffusionLBR) if(NOT ITK_SOURCE_DIR) From 1e244aa9cf66a05cbc4a8b993c45a93e0bb19a9f Mon Sep 17 00:00:00 2001 From: Jon Haitz Legarreta Date: Mon, 21 May 2018 18:55:47 +0200 Subject: [PATCH 46/76] BUG: Fix test errors steming from the new multi-threading mechanism. Fix errors steming from the use of the new `itk::PoolMultiThreader` class for multi-threading. The errors stemmed when this gerrit topic got merged: http://review.source.kitware.com/#/c/23175/ And were later related to the following gerrit-topic: http://review.source.kitware.com/#/c/23434/ The solution adopted in this patch set was based on the proposal in: http://review.source.kitware.com/#/c/23439/ --- .../include/itkUnaryFunctorWithIndexImageFilter.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 715ce38f9a8..9f0009616b6 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -60,14 +60,15 @@ class UnaryFunctorWithIndexImageFilter: GetSetFunctorMacro(Functor, FunctorType); protected: - UnaryFunctorWithIndexImageFilter(){} + UnaryFunctorWithIndexImageFilter() + { this->DynamicMultiThreadingOn(); } FunctorType m_Functor; using InputRegionType = typename InputImageType::RegionType; using OutputRegionType = typename OutputImageType::RegionType; - void ThreadedGenerateData(const OutputRegionType & region, ThreadIdType) override + void DynamicThreadedGenerateData(const OutputRegionType & region) override { if( region.GetSize()[0] == 0 ) { From 2a64ac2c151f764d14c1e3a3e6ee7e43030850c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?= Date: Thu, 1 Nov 2018 21:59:49 -0400 Subject: [PATCH 47/76] STYLE: Prefer error checked std::sto[id] over ato[if]. The `ato[if]` functions do not provide mechanisms for distinguishing between `0` and the error condition where the input can not be converted. `std::sto[id]` provides exception handling and detects when an invalid string attempts to be converted to an [integer|double]. `ato[if]()` - **Con**: No error handling. - **Con**: Handle neither hexadecimal nor octal. The use of `ato[if]` in code can cause it to be subtly broken. `ato[if]` makes two very big assumptions indeed: - The string represents an integer/floating point value. - The integer can fit into an int. In agreement with: http://review.source.kitware.com/#/c/23738/ --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 10 +++++----- .../include/LinearAnisotropicDiffusionCommandLine.h | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index a0c5e114c3f..977684d4699 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -154,14 +154,14 @@ int Execute(int argc, char * argv[]) int argIndex = 3; if( argIndex < argc ) { - const double diffusionTime = atof(argv[argIndex++]); + const double diffusionTime = std::stod(argv[argIndex++]); if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); diffusionFilter->SetDiffusionTime(diffusionTime); } if( argIndex < argc ) { - const double lambda = atof(argv[argIndex++]); + const double lambda = std::stod(argv[argIndex++]); if(lambda==0.) itkGenericExceptionMacro("Error: Unrecognized lambda (fourth argument).\n"); diffusionFilter->SetLambda(lambda); } @@ -185,21 +185,21 @@ int Execute(int argc, char * argv[]) if( argIndex < argc ) { - const double noiseScale = atof(argv[argIndex++]); + const double noiseScale = std::stod(argv[argIndex++]); if(noiseScale==0.) itkGenericExceptionMacro("Error: Unrecognized noiseScale (sixth argument).\n"); diffusionFilter->SetNoiseScale(noiseScale); } if( argIndex < argc ) { - const double featureScale = atof(argv[argIndex++]); + const double featureScale = std::stod(argv[argIndex++]); if(featureScale==0.) itkGenericExceptionMacro("Error: Unrecognized featureScale (seventh argument).\n"); diffusionFilter->SetFeatureScale(featureScale); } if( argIndex < argc ) { - const double exponent = atof(argv[argIndex++]); + const double exponent = std::stod(argv[argIndex++]); if(exponent==0.) itkGenericExceptionMacro("Error: Unrecognized exponent (eighth argument).\n"); diffusionFilter->SetExponent(exponent); } diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 3bb9dbe82ca..973e11aaad3 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -153,7 +153,7 @@ int Execute(int argc, char * argv[]){ tensorReader->SetFileName(tensorImageFileName); // Import diffusion time - const double diffusionTime = atof(argv[2+1]); + const double diffusionTime = std::stod(argv[2+1]); if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); // Import output image filename @@ -168,13 +168,13 @@ int Execute(int argc, char * argv[]){ int argIndex = 4+1; if(argIndexSetRatioToMaxStableTimeStep(ratioToMaxStableTimeStep); } if(argIndexSetMaxNumberOfTimeSteps(maxNumberOfTimeSteps); } else From 6e6b3d8c5770816bc8deaa9438e37b2fe6bb850c Mon Sep 17 00:00:00 2001 From: Bradley Lowekamp Date: Wed, 21 Mar 2018 10:30:57 -0400 Subject: [PATCH 48/76] Fix type in CoherenceEnhancingDiffusionImageFilter brief section --- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index a49bab7c9e6..ef749a11120 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -31,7 +31,7 @@ namespace itk /** * \class CoherenceEnhancingDiffusionImageFilter * - * \brief Coherence enhanging diffusion and edge enhancing diffusion. + * \brief Coherence enhancing diffusion and edge enhancing diffusion. * * Implementation of Coherence Enhancing Diffusion (CED), and * Edge Enhancing Diffusion (EED), as described by Weickert. From 5e3efc43956a62fb75e92016c18d2befcdc1fee4 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 21 Dec 2018 21:51:32 -0500 Subject: [PATCH 49/76] COMP: Clean up class constructors and destructors --- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 6 ++++-- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 5 ++++- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkStructureTensorImageFilter.h | 2 ++ .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 ++ 5 files changed, 14 insertions(+), 5 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 97e8f285016..668ff026e02 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -46,6 +46,8 @@ template< typename TImage, typename TScalar = typename NumericTraits< typename T class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > { public: + ITK_DISALLOW_COPY_AND_ASSIGN(AnisotropicDiffusionLBRImageFilter); + using Self = AnisotropicDiffusionLBRImageFilter; using Superclass = ImageToImageFilter< TImage, TImage >; using Pointer = SmartPointer< Self >; @@ -54,7 +56,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI /// Method for creation through the object factory. itkNewMacro(Self); /// Run-time type information (and related methods). - itkTypeMacro(AnisotropicDiffusionLBRImageFilter, Superclass); + itkTypeMacro(AnisotropicDiffusionLBRImageFilter, ImageToImageFilter); using ImageType = TImage; using PixelType = typename ImageType::PixelType; @@ -112,7 +114,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI int m_MaxTimeStepsBetweenTensorUpdates; AnisotropicDiffusionLBRImageFilter(); - ~AnisotropicDiffusionLBRImageFilter() override{} + ~AnisotropicDiffusionLBRImageFilter() override = default; typename TensorImageType::Pointer m_TensorImage; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index ef749a11120..a7295de3687 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -65,6 +65,8 @@ class CoherenceEnhancingDiffusionImageFilter: public AnisotropicDiffusionLBRImageFilter< TImage, TScalar > { public: + ITK_DISALLOW_COPY_AND_ASSIGN(CoherenceEnhancingDiffusionImageFilter); + using Self = CoherenceEnhancingDiffusionImageFilter; using Superclass = AnisotropicDiffusionLBRImageFilter< TImage, TScalar >; using Pointer = SmartPointer< Self >; @@ -74,7 +76,7 @@ class CoherenceEnhancingDiffusionImageFilter: itkNewMacro(Self); /** Run-time type information (and related methods). */ - itkTypeMacro(CoherenceEnhancingDiffusionImageFilter, Superclass); + itkTypeMacro(CoherenceEnhancingDiffusionImageFilter, AnisotropicDiffusionLBRImageFilter); static const unsigned int Dimension = Superclass::Dimension; @@ -106,6 +108,7 @@ class CoherenceEnhancingDiffusionImageFilter: ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} CoherenceEnhancingDiffusionImageFilter(); + ~CoherenceEnhancingDiffusionImageFilter() override = default; }; } // end namespace itk diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 6f64c8078df..cfb76a2e7ab 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -65,7 +65,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: using ImageType = TImage; using PixelType = typename ImageType::PixelType; - static const int Dimension = ImageType::ImageDimension; + static constexpr unsigned int Dimension = ImageType::ImageDimension; using ScalarType = TScalar; using TensorType = SymmetricSecondRankTensor< ScalarType, Dimension >; @@ -89,7 +89,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: protected: LinearAnisotropicDiffusionLBRImageFilter(); - ~LinearAnisotropicDiffusionLBRImageFilter() override{} + ~LinearAnisotropicDiffusionLBRImageFilter() override = default; typename ImageType::ConstPointer GetInputImage(); typename TensorImageType::ConstPointer GetInputTensor(); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index f2d3089f3be..2cb11631983 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -53,6 +53,8 @@ class StructureTensorImageFilter: public ImageToImageFilter< TImage, TTensorImage > { public: + ITK_DISALLOW_COPY_AND_ASSIGN(StructureTensorImageFilter); + using Self = StructureTensorImageFilter; using Superclass = ImageToImageFilter< TImage, TImage>; using Pointer = SmartPointer; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 9f0009616b6..2a9358dcb22 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -42,6 +42,8 @@ class UnaryFunctorWithIndexImageFilter: public ImageToImageFilter { public: + ITK_DISALLOW_COPY_AND_ASSIGN(UnaryFunctorWithIndexImageFilter); + using Self = UnaryFunctorWithIndexImageFilter; using Superclass = ImageToImageFilter< TInputImage, TOutputImage >; using Pointer = SmartPointer< Self >; From e5993d24f5b75fb60bac34963e0251ad77d613bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?= Date: Sun, 23 Dec 2018 19:50:43 -0500 Subject: [PATCH 50/76] ENH: Allow building examples. Use the ITK CMake macros to build the examples module. --- Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index 090935b87e2..7db54336ac4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -8,3 +8,5 @@ if(NOT ITK_SOURCE_DIR) else() itk_module_impl() endif() + +itk_module_examples() From 157b10da86d54765dd50f836b453412e16fde85b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?= Date: Tue, 26 Mar 2019 09:23:40 -0400 Subject: [PATCH 51/76] COMP: Fix compiler warnings Fix compiler warnings: use the `auto` keyword for counter variables in `for`loops systematically. Fixes: ``` Modules/Remote/AnisotropicDiffusionLBR/include/ itkLinearAnisotropicDiffusionLBRImageFilter.hxx:108:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] for( int i = 1; i < Dimension; ++i ) ^ ``` errors. Reported at: http://testing.cdash.org/viewBuildError.php?type=1&buildid=5820473 http://testing.cdash.org/viewBuildError.php?type=1&buildid=5820239 --- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 56 +++++++++---------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 80d2ce57598..333e5b2409a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -105,11 +105,11 @@ public: { region = region_; prod[0] = 1; - for( int i = 1; i < Dimension; ++i ) + for( auto i = 1; i < Dimension; ++i ) { prod[i]=prod[i-1]*region.GetSize()[i-1]; } - for(int i = 0; i < Dimension; ++i ) + for(auto i = 0; i < Dimension; ++i ) { invSpacing[i] = ScalarType(1) / spacing[i]; } @@ -118,7 +118,7 @@ public: InternalSizeT BufferIndex(const IndexType & x) const { IndexValueType ans=0; - for( int i = 0; i < Dimension; ++i ) + for( auto i = 0; i < Dimension; ++i ) { ans += this->prod[i] * ( x[i] - this->region.GetIndex()[i] ); } @@ -133,16 +133,16 @@ public: // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. TensorType D; - for(int i=0; iinvSpacing[i]*this->invSpacing[j]; this->Stencil( Dispatch< Dimension >(), D, offsets, stencil.second ); InternalSizeT * yIndex = &stencil.first[0]; //Compute buffer offsets from geometrical offsets - for(int i=0; i<(int)HalfStencilSize; ++i){ - for(int orientation = 0; orientation<2; ++orientation, ++yIndex){ + for(auto i=0; i<(int)HalfStencilSize; ++i){ + for(auto orientation = 0; orientation<2; ++orientation, ++yIndex){ const IndexType y = orientation ? x-offsets[i] : x+offsets[i]; if(this->region.IsInside(y)){ *yIndex = this->BufferIndex(y); @@ -164,9 +164,9 @@ protected: { // Construct a superbase, and make it obtuse with Selling's algorithm VectorType sb[Dimension+1]; //SuperBase - for(int i=0; i 0 ) { @@ -202,7 +202,7 @@ protected: std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; } - for( int i = 0; i < 3; ++i ) + for( auto i = 0; i < 3; ++i ) { coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); assert(coefficients[i]>=0); @@ -215,9 +215,9 @@ protected: { // Construct a superbase, and make it obtuse with Selling's algorithm VectorType sb[Dimension+1]; - for(int i=0; i 0 ){ const VectorType u=sb[i], v=sb[j]; - for(int k=0,l=0; k<=Dimension; ++k) + for(auto k=0,l=0; k<=Dimension; ++k) if(k!=i && k!=j) sb[l++]=sb[k]+u; sb[2]=-u; @@ -249,9 +249,9 @@ protected: // Computation of the weights SymmetricSecondRankTensor Weights; - for(int i=1; i !stencilIt.IsAtEnd(); ++stencilIt, ++diagIt) { - for(int i = 0; i < (int)StencilSize; ++i) + for(auto i = 0; i < (int)StencilSize; ++i) { const InternalSizeT yIndex = stencilIt.Value().first[i]; if( yIndex != OutsideBufferIndex() ) @@ -425,7 +425,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > m_NextImage->SetRegions(m_PreviousImage->GetBufferedRegion()); m_NextImage->Allocate(); - for( int k = 0; k < n; ++k ) + for( auto k = 0; k < n; ++k ) { ImageUpdate(delta); std::swap(m_PreviousImage, m_NextImage); @@ -471,7 +471,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > !inputIt.IsAtEnd(); ++inputIt, ++outputIt, ++stencilIt ) { - for( int i = 0; i < (int)StencilSize; ++i ) + for( auto i = 0; i < (int)StencilSize; ++i ) { const InternalSizeT yIndex = stencilIt.Value().first[i]; if( yIndex != OutsideBufferIndex() ) @@ -514,13 +514,13 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar> const VectorType & v) { ScalarType result(0); - for( int i = 0; i < Dimension; ++i ) + for( auto i = 0; i < Dimension; ++i ) { result += m(i,i) * u[i] * v[i]; } - for( int i = 0; i < Dimension; ++i ) + for( auto i = 0; i < Dimension; ++i ) { - for( int j = i+1; j < Dimension; ++j ) + for( auto j = i+1; j < Dimension; ++j ) { result += m(i,j) * (u[i] * v[j] + u[j] * v[i]); } From 516ffa60574eee36375c08b771effb7d1dd4d7e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?= Date: Thu, 4 Apr 2019 22:07:17 -0400 Subject: [PATCH 52/76] COMP: Fix compiler warnings Fix compiler warnings: use the type aliases and image dimensions constants properly defined in the class header for the image dimensionality. Fixes: ``` Modules/Remote/AnisotropicDiffusionLBR/include/ itkLinearAnisotropicDiffusionLBRImageFilter.hxx:108:24: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] for( auto i = 1; i < Dimension; ++i ) ^ ``` errors. reported at: http://testing.cdash.org/viewBuildError.php?type=1&buildid=5840769 --- .../itkAnisotropicDiffusionLBRImageFilter.h | 7 +- .../itkAnisotropicDiffusionLBRImageFilter.hxx | 8 +- ...tkCoherenceEnhancingDiffusionImageFilter.h | 3 +- ...CoherenceEnhancingDiffusionImageFilter.hxx | 12 +-- ...LinearAnisotropicDiffusionLBRImageFilter.h | 21 ++--- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 84 +++++++++---------- .../include/itkStructureTensorImageFilter.h | 14 ++-- 7 files changed, 77 insertions(+), 72 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 668ff026e02..8636f503e87 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -62,10 +62,11 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI using PixelType = typename ImageType::PixelType; using ScalarType = TScalar; - static const unsigned int Dimension = ImageType::ImageDimension; + using ImageDimensionType = typename ImageType::ImageDimensionType; + static constexpr ImageDimensionType ImageDimension = ImageType::ImageDimension; - using TensorType = SymmetricSecondRankTensor< ScalarType, Dimension >; - using TensorImageType = Image< TensorType, Dimension >; + using TensorType = SymmetricSecondRankTensor< ScalarType, ImageDimension >; + using TensorImageType = Image< TensorType, ImageDimension >; using StructureTensorFilterType = StructureTensorImageFilter; using LinearDiffusionFilterType = LinearAnisotropicDiffusionLBRImageFilter; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index 5743da38992..b95d58df086 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -54,7 +54,7 @@ AnisotropicDiffusionLBRImageFilter< TImage, TScalar > // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. double minSpacing = referenceSpacing[0]; - for( unsigned int i = 1; i < Dimension; ++i ) + for( ImageDimensionType i = 1; i < ImageDimension; ++i ) { minSpacing = std::min(minSpacing,referenceSpacing[i]); } @@ -108,8 +108,8 @@ struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > S.ComputeEigenAnalysis(eigenValues,eigenVectors); // For convenience, eigenvalues are sorted by increasing order - Vector order; - for(int i=0; i<(int)Dimension; ++i) order[i]=i; + Vector order; + for(ImageDimensionType i=0; i < ImageDimension; ++i) order[i]=i; OrderingType ordering(eigenValues); @@ -119,7 +119,7 @@ struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); TensorType DiffusionTensor; - for(int i=0; i<(int)Dimension; ++i){ + for(ImageDimensionType i=0; i < ImageDimension; ++i){ DiffusionTensor(order[i],order[i]) = ev[i]; for(int j=0; j ::EigenValuesTransform(const EigenValuesArrayType & ev0) const { const ScalarType evMin = ev0[0]; - const ScalarType evMax = ev0[Dimension-1]; + const ScalarType evMax = ev0[InputImageDimension-1]; EigenValuesArrayType ev; switch(m_Enhancement) { // Weickert's filter. case CED: - for( unsigned int i = 0; i < Dimension; ++i ) + for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) { ev[i] = g_CED(evMax-ev0[i]); } @@ -56,7 +56,7 @@ CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > // A variance, requiring stronger coherence. case cCED: - for( unsigned int i = 0; i < Dimension; ++i ) + for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) { ev[i] = g_CED( (evMax-ev0[i])/(1.+ev0[i]/m_Lambda) ); } @@ -64,7 +64,7 @@ CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > // Weickert's filter. case EED: - for( unsigned int i = 0; i < Dimension; ++i ) + for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) { ev[i] = g_EED(ev0[i]-evMin); } @@ -72,7 +72,7 @@ CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > // A variant, promoting diffusion in at least one direction at each point. case cEED: - for( unsigned int i = 0; i < Dimension; ++i ) + for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) { ev[i] = g_EED(ev0[i]); } @@ -80,7 +80,7 @@ CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > // Isotropic tensors, closely related to Perona-Malik's approach. case Isotropic: - for( unsigned int i = 0; i < Dimension; ++i ) + for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) { ev[i] = g_EED(evMax); } diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index cfb76a2e7ab..29abca8d7f0 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -65,12 +65,13 @@ class LinearAnisotropicDiffusionLBRImageFilter: using ImageType = TImage; using PixelType = typename ImageType::PixelType; - static constexpr unsigned int Dimension = ImageType::ImageDimension; + using ImageDimensionType = typename ImageType::ImageDimensionType; + static constexpr ImageDimensionType ImageDimension = ImageType::ImageDimension; using ScalarType = TScalar; - using TensorType = SymmetricSecondRankTensor< ScalarType, Dimension >; - using TensorImageType = Image< TensorType, Dimension >; - using RegionType = ImageRegion< Dimension >; + using TensorType = SymmetricSecondRankTensor< ScalarType, ImageDimension >; + using TensorImageType = Image< TensorType, ImageDimension >; + using RegionType = ImageRegion< ImageDimension >; void SetInputImage(const ImageType* image); void SetInputTensor(const TensorImageType* tensorImage); @@ -94,14 +95,14 @@ class LinearAnisotropicDiffusionLBRImageFilter: typename ImageType::ConstPointer GetInputImage(); typename TensorImageType::ConstPointer GetInputTensor(); - using IndexType = Index; + using IndexType = Index; // ******* Containers for the stencils used in the discretization - static const unsigned int HalfStencilSize = (Dimension == 2) ? 3 : 6; + static const unsigned int HalfStencilSize = (ImageDimension == 2) ? 3 : 6; static const unsigned int StencilSize = 2 * HalfStencilSize; using StencilCoefficientsType = Vector; - using OffsetType = Offset; + using OffsetType = Offset; using StencilOffsetsType = Vector; using InternalSizeT = int; @@ -114,10 +115,10 @@ class LinearAnisotropicDiffusionLBRImageFilter: virtual void ImageUpdateLoop(); /// Automatically called by GenerateData using StencilType = std::pair< StencilBufferIndicesType, StencilCoefficientsType >; - using StencilImageType = Image< StencilType, Dimension >; + using StencilImageType = Image< StencilType, ImageDimension >; typename StencilImageType::Pointer m_StencilImage; - using ScalarImageType = Image; + using ScalarImageType = Image; typename ScalarImageType::Pointer m_DiagonalCoefficients; virtual ScalarType MaxStableTimeStep(); @@ -140,7 +141,7 @@ class LinearAnisotropicDiffusionLBRImageFilter: struct StencilFunctor; struct FunctorType; - using VectorType = Vector; + using VectorType = Vector; static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); }; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 333e5b2409a..69eac856515 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -105,11 +105,11 @@ public: { region = region_; prod[0] = 1; - for( auto i = 1; i < Dimension; ++i ) + for( ImageDimensionType i = 1; i < ImageDimension; ++i ) { prod[i]=prod[i-1]*region.GetSize()[i-1]; } - for(auto i = 0; i < Dimension; ++i ) + for(ImageDimensionType i = 0; i < ImageDimension; ++i ) { invSpacing[i] = ScalarType(1) / spacing[i]; } @@ -118,7 +118,7 @@ public: InternalSizeT BufferIndex(const IndexType & x) const { IndexValueType ans=0; - for( auto i = 0; i < Dimension; ++i ) + for( ImageDimensionType i = 0; i < ImageDimension; ++i ) { ans += this->prod[i] * ( x[i] - this->region.GetIndex()[i] ); } @@ -133,15 +133,15 @@ public: // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. TensorType D; - for(auto i=0; iinvSpacing[i]*this->invSpacing[j]; - this->Stencil( Dispatch< Dimension >(), D, offsets, stencil.second ); + this->Stencil( Dispatch< ImageDimension >(), D, offsets, stencil.second ); InternalSizeT * yIndex = &stencil.first[0]; //Compute buffer offsets from geometrical offsets - for(auto i=0; i<(int)HalfStencilSize; ++i){ + for(unsigned int i=0; iregion.IsInside(y)){ @@ -163,24 +163,24 @@ protected: static void Stencil(const Dispatch< 2 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) { // Construct a superbase, and make it obtuse with Selling's algorithm - VectorType sb[Dimension+1]; //SuperBase - for(auto i=0; i 0 ) { @@ -202,7 +202,7 @@ protected: std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; } - for( auto i = 0; i < 3; ++i ) + for( ImageDimensionType i = 0; i < 3; ++i ) { coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); assert(coefficients[i]>=0); @@ -214,26 +214,26 @@ protected: static void Stencil(const Dispatch< 3 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) { // Construct a superbase, and make it obtuse with Selling's algorithm - VectorType sb[Dimension+1]; - for(auto i=0; i 0 ){ const VectorType u=sb[i], v=sb[j]; - for(auto k=0,l=0; k<=Dimension; ++k) + for(auto k=0,l=0; k<=ImageDimension; ++k) if(k!=i && k!=j) sb[l++]=sb[k]+u; sb[2]=-u; @@ -248,40 +248,40 @@ protected: } // Computation of the weights - SymmetricSecondRankTensor Weights; - for(auto i=1; i Weights; + for(ImageDimensionType i=1; i !stencilIt.IsAtEnd(); ++stencilIt, ++diagIt) { - for(auto i = 0; i < (int)StencilSize; ++i) + for(unsigned int i = 0; i < StencilSize; ++i) { const InternalSizeT yIndex = stencilIt.Value().first[i]; if( yIndex != OutsideBufferIndex() ) @@ -452,7 +452,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > ::ImageUpdate(ScalarType delta) { //Setting up iterators - ImageRegion region = GetRequestedRegion(); + ImageRegion region = GetRequestedRegion(); ImageRegionConstIterator inputIt(m_PreviousImage,region); ImageRegionIterator outputIt(m_NextImage,region); @@ -471,7 +471,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > !inputIt.IsAtEnd(); ++inputIt, ++outputIt, ++stencilIt ) { - for( auto i = 0; i < (int)StencilSize; ++i ) + for( unsigned int i = 0; i < StencilSize; ++i ) { const InternalSizeT yIndex = stencilIt.Value().first[i]; if( yIndex != OutsideBufferIndex() ) @@ -514,13 +514,13 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar> const VectorType & v) { ScalarType result(0); - for( auto i = 0; i < Dimension; ++i ) + for( ImageDimensionType i = 0; i < ImageDimension; ++i ) { result += m(i,i) * u[i] * v[i]; } - for( auto i = 0; i < Dimension; ++i ) + for( ImageDimensionType i = 0; i < ImageDimension; ++i ) { - for( auto j = i+1; j < Dimension; ++j ) + for( ImageDimensionType j = i+1; j < ImageDimension; ++j ) { result += m(i,j) * (u[i] * v[j] + u[j] * v[i]); } diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 2cb11631983..bfed36fecbb 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -65,13 +65,15 @@ class StructureTensorImageFilter: /// Run-time type information (and related methods). itkTypeMacro(StructureTensorImageFilter, Superclass); + using InputImageDimensionType = typename Superclass::InputImageType::ImageDimensionType; + static constexpr InputImageDimensionType InputImageDimension = Superclass::InputImageType::ImageDimension; + using ImageType = TImage; using PixelType = typename ImageType::PixelType; - static const unsigned int Dimension = ImageType::ImageDimension; using TensorImageType = TTensorImage; using TensorType = typename TensorImageType::PixelType; using ScalarType = typename TensorType::ComponentType; - using ScalarImageType = Image; + using ScalarImageType = Image; ///Parameter \f$\sigma\f$ of the structure tensor definition. itkSetMacro(NoiseScale, ScalarType); @@ -102,17 +104,17 @@ class StructureTensorImageFilter: void IntermediateFilter( const Dispatch< false > & ); typename TensorImageType::Pointer m_IntermediateResult; - using CovariantVectorType = CovariantVector; - using CovariantImageType = Image; + using CovariantVectorType = CovariantVector; + using CovariantImageType = Image; struct OuterFunctor { TensorType operator()(const CovariantVectorType & u) const { TensorType m; - for( unsigned int i = 0; i < Dimension; ++i ) + for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) { - for( unsigned int j = i; j < Dimension; ++j) + for( InputImageDimensionType j = i; j < InputImageDimension; ++j) { m(i,j) = u[i]*u[j]; } From fd2c83c81e9f08c89bb900cd9a9f3799a73bd68c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=20Haitz=20Legarreta=20Gorro=C3=B1o?= Date: Tue, 9 Apr 2019 00:02:52 -0400 Subject: [PATCH 53/76] COMP: Fix signed and unsigned integer comparison warnings Fix signed and unsiged integer comparison warnings. Fixes: ``` AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx:124:25: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] ``` raised at: http://testing.cdash.org/viewBuildError.php?type=1&buildid=5846916 http://testing.cdash.org/viewBuildError.php?type=1&buildid=5847167 --- .../include/itkAnisotropicDiffusionLBRImageFilter.hxx | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index b95d58df086..cc5e2540965 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -121,7 +121,7 @@ struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > TensorType DiffusionTensor; for(ImageDimensionType i=0; i < ImageDimension; ++i){ DiffusionTensor(order[i],order[i]) = ev[i]; - for(int j=0; j 0 ){ const VectorType u=sb[i], v=sb[j]; - for(auto k=0,l=0; k<=ImageDimension; ++k) + for(ImageDimensionType k=0,l=0; k<=ImageDimension; ++k) if(k!=i && k!=j) sb[l++]=sb[k]+u; sb[2]=-u; From a4598ab773bd979b8b34f6f59474600e53009d86 Mon Sep 17 00:00:00 2001 From: "Hans J. Johnson" Date: Tue, 30 Jul 2019 14:25:09 -0500 Subject: [PATCH 54/76] ENH: Fix spelling error s/tropci/tropic/g The spelling error affected the variable name for library linkage with ITK libraries in the module system. --- .../test/CMakeLists.txt | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt index e45f2c7ba4a..bb16d5d7f8b 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt @@ -1,73 +1,73 @@ itk_module_test() -set(AnisotropciDiffusionLBRTests +set(AnisotropicDiffusionLBRTests CoherenceEnhancingDiffusionTest.cxx ) -CreateTestDriver(AnisotropciDiffusionLBR "${AnisotropciDiffusionLBR-Test_LIBRARIES}" "${AnisotropciDiffusionLBRTests}") +CreateTestDriver(AnisotropicDiffusionLBR "${AnisotropicDiffusionLBR-Test_LIBRARIES}" "${AnisotropicDiffusionLBRTests}") set(TestOutput ${ITK_TEST_OUTPUT_DIR}) ################ fig:PacMan ################# -itk_add_test(NAME PacMan_cEED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME PacMan_cEED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/PacMan_cEED.png} ${TestOutput}/PacMan_cEED.png CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cEED.png 20 0.05 cEED 3) -itk_add_test(NAME PacMan_cCED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME PacMan_cCED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/PacMan_cCED.png} ${TestOutput}/PacMan_cCED.png CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cCED.png 20 0.05 cCED 3) -itk_add_test(NAME PacMan_I COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME PacMan_I COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/PacMan_I.png} ${TestOutput}/PacMan_I.png CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_I.png 20 0.05 Isotropic 3) ############# fig : Fingerprint ############# -itk_add_test(NAME FingerPrint_cEED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME FingerPrint_cEED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/FingerPrint_cEED_20.png} ${TestOutput}/FingerPrint_cEED_20.png CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cEED_20.png 20 0.02 cEED ) -itk_add_test(NAME FingerPrint_cCED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME FingerPrint_cCED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/FingerPrint_cCED_20.png} ${TestOutput}/FingerPrint_cCED_20.png CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cCED_20.png 20 0.02 cCED ) -itk_add_test(NAME FingerPrint_I COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME FingerPrint_I COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/FingerPrint_I_20.png} ${TestOutput}/FingerPrint_I_20.png CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_I_20.png 20 0.02 Isotropic ) ################ fig : Cos3D ################ -itk_add_test(NAME Cos3D_cCED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Cos3D_cCED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Cos3D_cCED.vtk} ${TestOutput}/Cos3D_cCED.vtk CoherenceEnhancingDiffusionTest DATA{Input/Cos3D_Noisy.vtk} ${TestOutput}/Cos3D_cCED.vtk 10 0.02 cCED 4 10 ) ################ fig : Brain ################ -itk_add_test(NAME mrbrain_cEED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME mrbrain_cEED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/mrbrain_cEED.vtk} ${TestOutput}/mrbrain_cEED.vtk CoherenceEnhancingDiffusionTest DATA{Input/mrbrain_noisy.vtk} ${TestOutput}/mrbrain_cEED.vtk 5 0.003 cEED ) ################# fig : Lena ################ -itk_add_test(NAME Lena_Detail_cCED_2 COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Lena_Detail_cCED_2 COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Lena_Detail_cCED_2.png} ${TestOutput}/Lena_Detail_cCED_2.png CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cCED_2.png 2 0.003 cCED 0.5 2 4 ) -itk_add_test(NAME Lena_Detail_cEED_2 COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Lena_Detail_cEED_2 COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Lena_Detail_cEED_2.png} ${TestOutput}/Lena_Detail_cEED_2.png CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cEED_2.png 2 0.003 cEED 0.5 2 4 ) -itk_add_test(NAME Lena_Detail_I_2 COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Lena_Detail_I_2 COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Lena_Detail_I_2.png} ${TestOutput}/Lena_Detail_I_2.png CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_I_2.png 2 0.003 Isotropic 0.5 2 4 ) ############## fig : Vector field ########### -itk_add_test(NAME VectorField_Circle_cEED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME VectorField_Circle_cEED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/VectorField_Circle_cEED.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk CoherenceEnhancingDiffusionTest DATA{Input/VectorField_CircleOpposites.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk 10 0.05 cEED ) @@ -75,18 +75,18 @@ itk_add_test(NAME VectorField_Circle_cEED COMMAND AnisotropciDiffusionLBRTestDri ############### fig : Triangle ############## -itk_add_test(NAME Triangle_cEED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Triangle_cEED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Triangle_cEED.png} ${TestOutput}/Triangle_cEED.png CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_cEED.png 5 0.03 cEED ) -itk_add_test(NAME Triangle_EED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Triangle_EED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Triangle_EED.png} ${TestOutput}/Triangle_EED.png CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_EED.png 5 0.03 EED ) -itk_add_test(NAME Oscillations1_cCED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Oscillations1_cCED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Oscillations1_cCED.png} ${TestOutput}/Oscillations1_cCED.png CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_cCED.png 20 0.05 cCED ) -itk_add_test(NAME Oscillations1_CED COMMAND AnisotropciDiffusionLBRTestDriver +itk_add_test(NAME Oscillations1_CED COMMAND AnisotropicDiffusionLBRTestDriver --compare DATA{Baseline/Oscillations1_CED.png} ${TestOutput}/Oscillations1_CED.png CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_CED.png 20 0.05 CED ) From 49d5d2e2a3df0ebdfbb2ed1a4a5d2e9fd831061a Mon Sep 17 00:00:00 2001 From: "Mathew J. Seng" Date: Fri, 16 Aug 2019 15:56:23 -0500 Subject: [PATCH 55/76] STYLE: Change enum to new enum class definition Changed to enum class: FileModeType Module: Modules_AnisotropicDiffusionLBR --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 977684d4699..ff865e5b02a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -1,4 +1,4 @@ -/*========================================================================= + /*========================================================================= * * Copyright Insight Software Consortium * @@ -76,7 +76,7 @@ int Execute(int argc, char * argv[]) const char * imageFileName = argv[1]; - itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( imageFileName, itk::ImageIOFactory::ReadMode ); + itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( imageFileName, itk::ImageIOFactory::FileModeType::ReadMode ); if( imageIO.IsNull() ) { std::cerr << "Could not create ImageIO" << std::endl; From 21d9287a5f1de78d365f69c8396445cf6c0a8279 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 19 Feb 2020 15:03:06 -0600 Subject: [PATCH 56/76] ENH: Add .gitattributes to allow running ITK clang-formatting scripts ``` git filter-branch -f \ --tree-filter "~/ITK/Utilities/Maintenance/clang-format.bash --clang-format ~/Dashboard/src/ITK-clang11/clang-format-Linux --tracked" \ master.. ``` --- .../CoherenceEnhancingDiffusionCommandLine.h | 204 +++---- .../LinearAnisotropicDiffusionCommandLine.h | 344 ++++++------ .../itkAnisotropicDiffusionLBRImageFilter.h | 30 +- .../itkAnisotropicDiffusionLBRImageFilter.hxx | 129 ++--- .../include/itkAnisotropicDiffusionLBRMacro.h | 12 +- ...tkCoherenceEnhancingDiffusionImageFilter.h | 37 +- ...CoherenceEnhancingDiffusionImageFilter.hxx | 91 ++- ...LinearAnisotropicDiffusionLBRImageFilter.h | 81 +-- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 516 +++++++++--------- .../include/itkStructureTensorImageFilter.h | 65 ++- .../include/itkStructureTensorImageFilter.hxx | 88 ++- .../itkUnaryFunctorWithIndexImageFilter.h | 39 +- .../test/CoherenceEnhancingDiffusionTest.cxx | 13 +- 13 files changed, 880 insertions(+), 769 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index ff865e5b02a..95561ba5ab7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -1,4 +1,4 @@ - /*========================================================================= +/*========================================================================= * * Copyright Insight Software Consortium * @@ -33,109 +33,118 @@ namespace CoherenceEnhancingDiffusionCommandLine { -void Usage() - { - std::cerr << - "Input image filename. 2D and 3D images supported. Required.\n" << - "Output image filename. Required.\n" << - "Diffusion time. Suggested range: 0.5-5, up to 50 for strong noise. Default: 2.\n" << - "Lambda. Small values detect more edges. Suggested range: 0.05, 0.0001. Default: 0.01\n" << - "Weickert diffusion type. Accepted values: CED, cCED, EED, cEED, Isotropic. Default: CED.\n" << - "Noise scale. Suggested range: 0.5 - 4. Default 1.\n" << - "Feature scale. Suggested range: 2-6. Default 2.\n" - << "\n"; - } +void +Usage() +{ + std::cerr << "Input image filename. 2D and 3D images supported. Required.\n" + << "Output image filename. Required.\n" + << "Diffusion time. Suggested range: 0.5-5, up to 50 for strong noise. Default: 2.\n" + << "Lambda. Small values detect more edges. Suggested range: 0.05, 0.0001. Default: 0.01\n" + << "Weickert diffusion type. Accepted values: CED, cCED, EED, cEED, Isotropic. Default: CED.\n" + << "Noise scale. Suggested range: 0.5 - 4. Default 1.\n" + << "Feature scale. Suggested range: 2-6. Default 2.\n" + << "\n"; +} using namespace itk; -int Execute(int argc, char * argv[]); +int +Execute(int argc, char * argv[]); -template -int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); +template +int +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); -template -int Execute(int argc, char * argv[], int nComponents); +template +int +Execute(int argc, char * argv[], int nComponents); -template -int Execute(int argc, char * argv[]); +template +int +Execute(int argc, char * argv[]); using ReportProgressToCOutType = LinearAnisotropicDiffusionCommandLine::ReportProgressToCOutType; -int Execute(int argc, char * argv[]) +int +Execute(int argc, char * argv[]) { using std::cerr; using std::endl; using namespace itk; - if(argc < 2 + 1 ) - { + if (argc < 2 + 1) + { Usage(); return EXIT_SUCCESS; - } + } const char * imageFileName = argv[1]; - itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( imageFileName, itk::ImageIOFactory::FileModeType::ReadMode ); - if( imageIO.IsNull() ) - { + itk::ImageIOBase::Pointer imageIO = + itk::ImageIOFactory::CreateImageIO(imageFileName, itk::ImageIOFactory::FileModeType::ReadMode); + if (imageIO.IsNull()) + { std::cerr << "Could not create ImageIO" << std::endl; return EXIT_FAILURE; - } - imageIO->SetFileName( imageFileName ); + } + imageIO->SetFileName(imageFileName); imageIO->ReadImageInformation(); - const unsigned int imageDimension = imageIO->GetNumberOfDimensions(); + const unsigned int imageDimension = imageIO->GetNumberOfDimensions(); const itk::ImageIOBase::IOComponentType componentType = imageIO->GetComponentType(); - const unsigned int nComponents = imageIO->GetNumberOfComponents(); + const unsigned int nComponents = imageIO->GetNumberOfComponents(); - switch( imageDimension ) - { + switch (imageDimension) + { case 2: - return Execute<2>(argc,argv,componentType,nComponents); + return Execute<2>(argc, argv, componentType, nComponents); case 3: - return Execute<3>(argc,argv,componentType,nComponents); + return Execute<3>(argc, argv, componentType, nComponents); default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); - } + } } -template -int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents) +template +int +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents) { - switch(componentType) - { + switch (componentType) + { case itk::ImageIOBase::UCHAR: - return Execute(argc,argv,nComponents); + return Execute(argc, argv, nComponents); case itk::ImageIOBase::FLOAT: - return Execute(argc,argv,nComponents); + return Execute(argc, argv, nComponents); case itk::ImageIOBase::DOUBLE: - return Execute(argc,argv,nComponents); + return Execute(argc, argv, nComponents); default: itkGenericExceptionMacro("Sorry, unsupported component type"); - } + } } -template -int Execute(int argc, char * argv[], int nComponents) +template +int +Execute(int argc, char * argv[], int nComponents) { - switch(nComponents) - { + switch (nComponents) + { case 1: - return Execute(argc,argv); + return Execute(argc, argv); case 2: - return Execute,Vector >(argc,argv); + return Execute, Vector>(argc, argv); case 3: - return Execute,Vector >(argc,argv); + return Execute, Vector>(argc, argv); default: itkGenericExceptionMacro("Sorry, unsupported number of components"); - } + } } -template -int Execute(int argc, char * argv[]) +template +int +Execute(int argc, char * argv[]) { - using ImageType = Image; + using ImageType = Image; using ReaderType = ImageFileReader; typename ReaderType::Pointer reader = ReaderType::New(); @@ -144,7 +153,7 @@ int Execute(int argc, char * argv[]) const char * outputFileName = argv[2]; reader->SetFileName(imageFileName); - using DiffusionFilterType = CoherenceEnhancingDiffusionImageFilter; + using DiffusionFilterType = CoherenceEnhancingDiffusionImageFilter; typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); diffusionFilter->SetInput(reader->GetOutput()); @@ -152,62 +161,67 @@ int Execute(int argc, char * argv[]) diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); int argIndex = 3; - if( argIndex < argc ) - { + if (argIndex < argc) + { const double diffusionTime = std::stod(argv[argIndex++]); - if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); + if (diffusionTime == 0) + itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); diffusionFilter->SetDiffusionTime(diffusionTime); - } + } - if( argIndex < argc ) - { + if (argIndex < argc) + { const double lambda = std::stod(argv[argIndex++]); - if(lambda==0.) itkGenericExceptionMacro("Error: Unrecognized lambda (fourth argument).\n"); + if (lambda == 0.) + itkGenericExceptionMacro("Error: Unrecognized lambda (fourth argument).\n"); diffusionFilter->SetLambda(lambda); - } + } - if( argIndex < argc ) - { + if (argIndex < argc) + { const char * enhancement = argv[argIndex++]; - if(!strcmp(enhancement,"EED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. - else if(!strcmp(enhancement,"cEED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. - else if(!strcmp(enhancement,"CED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. - else if(!strcmp(enhancement, "cCED")) - diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. - else if(!strcmp(enhancement, "Isotropic")) - diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); //Perona-Mali's exponent: 2. + if (!strcmp(enhancement, "EED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::EED); // Weickert's exponent : 4. + else if (!strcmp(enhancement, "cEED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cEED); // Weickert's exponent : 4. + else if (!strcmp(enhancement, "CED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::CED); // Weickert's exponent : 2. + else if (!strcmp(enhancement, "cCED")) + diffusionFilter->SetEnhancement(DiffusionFilterType::cCED); // Weickert's exponent : 2. + else if (!strcmp(enhancement, "Isotropic")) + diffusionFilter->SetEnhancement(DiffusionFilterType::Isotropic); // Perona-Mali's exponent: 2. else - itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); - } + itkGenericExceptionMacro("Error: Unrecognized enhancement (fifth argument).\n"); + } - if( argIndex < argc ) - { + if (argIndex < argc) + { const double noiseScale = std::stod(argv[argIndex++]); - if(noiseScale==0.) itkGenericExceptionMacro("Error: Unrecognized noiseScale (sixth argument).\n"); + if (noiseScale == 0.) + itkGenericExceptionMacro("Error: Unrecognized noiseScale (sixth argument).\n"); diffusionFilter->SetNoiseScale(noiseScale); - } + } - if( argIndex < argc ) - { + if (argIndex < argc) + { const double featureScale = std::stod(argv[argIndex++]); - if(featureScale==0.) itkGenericExceptionMacro("Error: Unrecognized featureScale (seventh argument).\n"); + if (featureScale == 0.) + itkGenericExceptionMacro("Error: Unrecognized featureScale (seventh argument).\n"); diffusionFilter->SetFeatureScale(featureScale); - } + } - if( argIndex < argc ) - { + if (argIndex < argc) + { const double exponent = std::stod(argv[argIndex++]); - if(exponent==0.) itkGenericExceptionMacro("Error: Unrecognized exponent (eighth argument).\n"); + if (exponent == 0.) + itkGenericExceptionMacro("Error: Unrecognized exponent (eighth argument).\n"); diffusionFilter->SetExponent(exponent); - } + } - if( argIndex < argc ) - { + if (argIndex < argc) + { itkGenericExceptionMacro("Error: excessive number of arguments"); - } + } /*{ std::cerr << @@ -224,12 +238,12 @@ int Execute(int argc, char * argv[]) }*/ - using ExportImageType = Image; + using ExportImageType = Image; using CasterType = CastImageFilter; typename CasterType::Pointer caster = CasterType::New(); caster->SetInput(diffusionFilter->GetOutput()); - //using ScalarImageType = typename DiffusionFilterType::ScalarImageType; + // using ScalarImageType = typename DiffusionFilterType::ScalarImageType; using WriterType = ImageFileWriter; typename WriterType::Pointer writer = WriterType::New(); writer->SetInput(caster->GetOutput()); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 973e11aaad3..ff9898af16d 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -30,180 +30,220 @@ namespace LinearAnisotropicDiffusionCommandLine { -void Usage(){ - std::cerr << - "Input image filename. 2D and 3D images supported. Required.\n" << - "Output tensor field filename. Required.\n" << - "Diffusion time. Required.\n" << - "Output image filename. Required.\n" << - "RatioToMaxStableStep. Range: ]0,1]. Default: 0.7. Optionnal.\n" << - "MaxNumberOfIterations. Range: 1...Infinity. Default: 200. Optionnal.\n" - << "\n"; +void +Usage() +{ + std::cerr << "Input image filename. 2D and 3D images supported. Required.\n" + << "Output tensor field filename. Required.\n" + << "Diffusion time. Required.\n" + << "Output image filename. Required.\n" + << "RatioToMaxStableStep. Range: ]0,1]. Default: 0.7. Optionnal.\n" + << "MaxNumberOfIterations. Range: 1...Infinity. Default: 200. Optionnal.\n" + << "\n"; } using namespace itk; -int Execute(int argc, char * argv[]); +int +Execute(int argc, char * argv[]); -template -int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); +template +int +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); -template -int Execute(int argc, char * argv[], int nComponents); +template +int +Execute(int argc, char * argv[], int nComponents); -template -int Execute(int argc, char * argv[]); +template +int +Execute(int argc, char * argv[]); struct ReportProgressToCOutType : public itk::Command { - itkNewMacro(ReportProgressToCOutType); - void Execute(itk::Object *caller, const itk::EventObject & event) override{ - Execute( (const itk::Object *)caller, event); - } - - void Execute(const itk::Object * object, const itk::EventObject &) override{ - std::cout << object->GetNameOfClass() << " has completed: " - << int(100*dynamic_cast(object)->GetProgress()) - << "%" << std::endl; - } + itkNewMacro(ReportProgressToCOutType); + void + Execute(itk::Object * caller, const itk::EventObject & event) override + { + Execute((const itk::Object *)caller, event); + } + + void + Execute(const itk::Object * object, const itk::EventObject &) override + { + std::cout << object->GetNameOfClass() + << " has completed: " << int(100 * dynamic_cast(object)->GetProgress()) << "%" + << std::endl; + } }; -int Execute(int argc, char * argv[]) +int +Execute(int argc, char * argv[]) { - using std::cerr; - using std::endl; - using namespace itk; - - if(argc<4+1) {Usage(); return EXIT_SUCCESS;} - - const char *imageFileName =argv[0+1]; - using ReaderType = ImageFileReader >; - ReaderType::Pointer reader = ReaderType::New(); - reader->SetFileName(imageFileName); - - reader->UpdateOutputInformation(); - - const ImageIOBase * io = reader->GetImageIO(); - const int ImageDimension = io->GetNumberOfDimensions(); - const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); - const int nComponents = io->GetNumberOfComponents(); - - { - const char *tensorFileName = argv[1+1]; - ReaderType::Pointer reader2 = ReaderType::New(); - reader2->SetFileName(tensorFileName); - reader2->UpdateOutputInformation(); - const ImageIOBase * io2 = reader2->GetImageIO(); - if(io2->GetComponentType() != componentType) - std::cerr << "Warning: image and tensors have distinct component types.\n"; - if(ImageDimension != (int)io2->GetNumberOfDimensions()) - itkGenericExceptionMacro("Error: image and tensor image have distinct dimension"); - const int TensorDimension = (ImageDimension*(ImageDimension+1))/2; - if(TensorDimension != (int)io2->GetNumberOfComponents()) - itkGenericExceptionMacro("Error: wrong tensor dimension, should be n*(n+1)/2 where n=ImageDimension."); - if(io2->GetPixelType() == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR) - std::cerr << "Warning: tensor image pixel type not marked as Symmetric Second Rank Tensor.\n"; - } - - switch (ImageDimension) { - case 2: return Execute<2>(argc,argv,componentType,nComponents); -// case 3: return Execute<3>(argc,argv,componentType,nComponents); - default: itkGenericExceptionMacro("Sorry, unsupported image dimension."); - } + using std::cerr; + using std::endl; + using namespace itk; + + if (argc < 4 + 1) + { + Usage(); + return EXIT_SUCCESS; + } + + const char * imageFileName = argv[0 + 1]; + using ReaderType = ImageFileReader>; + ReaderType::Pointer reader = ReaderType::New(); + reader->SetFileName(imageFileName); + + reader->UpdateOutputInformation(); + + const ImageIOBase * io = reader->GetImageIO(); + const int ImageDimension = io->GetNumberOfDimensions(); + const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); + const int nComponents = io->GetNumberOfComponents(); + + { + const char * tensorFileName = argv[1 + 1]; + ReaderType::Pointer reader2 = ReaderType::New(); + reader2->SetFileName(tensorFileName); + reader2->UpdateOutputInformation(); + const ImageIOBase * io2 = reader2->GetImageIO(); + if (io2->GetComponentType() != componentType) + std::cerr << "Warning: image and tensors have distinct component types.\n"; + if (ImageDimension != (int)io2->GetNumberOfDimensions()) + itkGenericExceptionMacro("Error: image and tensor image have distinct dimension"); + const int TensorDimension = (ImageDimension * (ImageDimension + 1)) / 2; + if (TensorDimension != (int)io2->GetNumberOfComponents()) + itkGenericExceptionMacro("Error: wrong tensor dimension, should be n*(n+1)/2 where n=ImageDimension."); + if (io2->GetPixelType() == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR) + std::cerr << "Warning: tensor image pixel type not marked as Symmetric Second Rank Tensor.\n"; + } + + switch (ImageDimension) + { + case 2: + return Execute<2>(argc, argv, componentType, nComponents); + // case 3: return Execute<3>(argc,argv,componentType,nComponents); + default: + itkGenericExceptionMacro("Sorry, unsupported image dimension."); + } } -template -int Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents){ - switch (componentType) { - case itk::ImageIOBase::UCHAR: return Execute(argc,argv,nComponents); - case itk::ImageIOBase::FLOAT: return Execute(argc,argv,nComponents); - case itk::ImageIOBase::DOUBLE:return Execute(argc,argv,nComponents); - default: itkGenericExceptionMacro("Sorry, unsupported component type"); - } +template +int +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents) +{ + switch (componentType) + { + case itk::ImageIOBase::UCHAR: + return Execute(argc, argv, nComponents); + case itk::ImageIOBase::FLOAT: + return Execute(argc, argv, nComponents); + case itk::ImageIOBase::DOUBLE: + return Execute(argc, argv, nComponents); + default: + itkGenericExceptionMacro("Sorry, unsupported component type"); + } } -template -int Execute(int argc, char * argv[], int nComponents){ - switch (nComponents) { - case 1: return Execute(argc,argv); - case 2: return Execute,Vector >(argc,argv); - case 3: return Execute,Vector >(argc,argv); - default: itkGenericExceptionMacro("Sorry, unsupported number of components"); - } +template +int +Execute(int argc, char * argv[], int nComponents) +{ + switch (nComponents) + { + case 1: + return Execute(argc, argv); + case 2: + return Execute, Vector>(argc, argv); + case 3: + return Execute, Vector>(argc, argv); + default: + itkGenericExceptionMacro("Sorry, unsupported number of components"); + } } -template -int Execute(int argc, char * argv[]){ - - // Import image - using ImageType = Image; - using ReaderType = ImageFileReader; - typename ReaderType::Pointer reader = ReaderType::New(); - const char *imageFileName =argv[0+1]; - reader->SetFileName(imageFileName); - - // Import tensors - using TensorType = SymmetricSecondRankTensor; - using TensorImageType = Image; - using TensorReaderType = ImageFileReader; - typename TensorReaderType::Pointer tensorReader = TensorReaderType::New(); - const char * tensorImageFileName = argv[1+1]; - tensorReader->SetFileName(tensorImageFileName); - - // Import diffusion time - const double diffusionTime = std::stod(argv[2+1]); - if(diffusionTime==0) itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); - - // Import output image filename - const char *outputFileName = argv[3+1]; - - // Setup diffusion filter - using DiffusionFilterType = LinearAnisotropicDiffusionLBRImageFilter; - typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); - diffusionFilter->SetInputImage(reader->GetOutput()); - diffusionFilter->SetInputTensor(tensorReader->GetOutput()); - diffusionFilter->SetMaxDiffusionTime(diffusionTime); - - int argIndex = 4+1; - if(argIndexSetRatioToMaxStableTimeStep(ratioToMaxStableTimeStep); - } - - if(argIndexSetMaxNumberOfTimeSteps(maxNumberOfTimeSteps); - } else - diffusionFilter->SetMaxNumberOfTimeSteps(200); - - ReportProgressToCOutType::Pointer reportDiffusionProgress = ReportProgressToCOutType::New(); - diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); - - using ExportImageType = Image; - using CasterType = CastImageFilter; - typename CasterType::Pointer caster = CasterType::New(); - caster->SetInput(diffusionFilter->GetOutput()); - - //using ScalarImageType = typename DiffusionFilterType::ScalarImageType; - using WriterType = ImageFileWriter; - typename WriterType::Pointer writer = WriterType::New(); - writer->SetInput(caster->GetOutput()); - writer->SetFileName(outputFileName); - writer->Update(); - - const ScalarType effectiveDiffusionTime=diffusionFilter->GetEffectiveDiffusionTime(); - if(effectiveDiffusionTime < 0.99 * diffusionTime){ - std::cerr << - "Warning: early abort at effective diffusion time: " << effectiveDiffusionTime << - ", you may want to increase the max number of time steps: " << diffusionFilter->GetMaxNumberOfTimeSteps() << "\n"; - Usage(); - } +template +int +Execute(int argc, char * argv[]) +{ - return EXIT_SUCCESS; + // Import image + using ImageType = Image; + using ReaderType = ImageFileReader; + typename ReaderType::Pointer reader = ReaderType::New(); + const char * imageFileName = argv[0 + 1]; + reader->SetFileName(imageFileName); + + // Import tensors + using TensorType = SymmetricSecondRankTensor; + using TensorImageType = Image; + using TensorReaderType = ImageFileReader; + typename TensorReaderType::Pointer tensorReader = TensorReaderType::New(); + const char * tensorImageFileName = argv[1 + 1]; + tensorReader->SetFileName(tensorImageFileName); + + // Import diffusion time + const double diffusionTime = std::stod(argv[2 + 1]); + if (diffusionTime == 0) + itkGenericExceptionMacro("Error: Unrecognized diffusion time (third argument).\n"); + + // Import output image filename + const char * outputFileName = argv[3 + 1]; + + // Setup diffusion filter + using DiffusionFilterType = LinearAnisotropicDiffusionLBRImageFilter; + typename DiffusionFilterType::Pointer diffusionFilter = DiffusionFilterType::New(); + diffusionFilter->SetInputImage(reader->GetOutput()); + diffusionFilter->SetInputTensor(tensorReader->GetOutput()); + diffusionFilter->SetMaxDiffusionTime(diffusionTime); + + int argIndex = 4 + 1; + if (argIndex < argc) + { + const double ratioToMaxStableTimeStep = std::stod(argv[argIndex++]); + if (ratioToMaxStableTimeStep == 0) + itkGenericExceptionMacro("Error: Unrecognized RatioToMaxStableTimeStep (fourth argument).\n"); + diffusionFilter->SetRatioToMaxStableTimeStep(ratioToMaxStableTimeStep); + } + + if (argIndex < argc) + { + const int maxNumberOfTimeSteps = std::stoi(argv[argIndex++]); + if (maxNumberOfTimeSteps == 0) + itkGenericExceptionMacro("Error: Unrecognized maxNumberOfTimeSteps (fifth argument).\n"); + diffusionFilter->SetMaxNumberOfTimeSteps(maxNumberOfTimeSteps); + } + else + diffusionFilter->SetMaxNumberOfTimeSteps(200); + + ReportProgressToCOutType::Pointer reportDiffusionProgress = ReportProgressToCOutType::New(); + diffusionFilter->AddObserver(ProgressEvent(), reportDiffusionProgress); + + using ExportImageType = Image; + using CasterType = CastImageFilter; + typename CasterType::Pointer caster = CasterType::New(); + caster->SetInput(diffusionFilter->GetOutput()); + + // using ScalarImageType = typename DiffusionFilterType::ScalarImageType; + using WriterType = ImageFileWriter; + typename WriterType::Pointer writer = WriterType::New(); + writer->SetInput(caster->GetOutput()); + writer->SetFileName(outputFileName); + writer->Update(); + + const ScalarType effectiveDiffusionTime = diffusionFilter->GetEffectiveDiffusionTime(); + if (effectiveDiffusionTime < 0.99 * diffusionTime) + { + std::cerr << "Warning: early abort at effective diffusion time: " << effectiveDiffusionTime + << ", you may want to increase the max number of time steps: " + << diffusionFilter->GetMaxNumberOfTimeSteps() << "\n"; + Usage(); + } + + return EXIT_SUCCESS; } } // end namespace LinearAnisotropicDiffusionCommandLine diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 8636f503e87..93804b28cb7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -42,16 +42,16 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > -class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TImage > +template ::RealType> +class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter { public: ITK_DISALLOW_COPY_AND_ASSIGN(AnisotropicDiffusionLBRImageFilter); using Self = AnisotropicDiffusionLBRImageFilter; - using Superclass = ImageToImageFilter< TImage, TImage >; - using Pointer = SmartPointer< Self >; - using ConstPointer = SmartPointer< const Self >; + using Superclass = ImageToImageFilter; + using Pointer = SmartPointer; + using ConstPointer = SmartPointer; /// Method for creation through the object factory. itkNewMacro(Self); @@ -65,8 +65,8 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI using ImageDimensionType = typename ImageType::ImageDimensionType; static constexpr ImageDimensionType ImageDimension = ImageType::ImageDimension; - using TensorType = SymmetricSecondRankTensor< ScalarType, ImageDimension >; - using TensorImageType = Image< TensorType, ImageDimension >; + using TensorType = SymmetricSecondRankTensor; + using TensorImageType = Image; using StructureTensorFilterType = StructureTensorImageFilter; using LinearDiffusionFilterType = LinearAnisotropicDiffusionLBRImageFilter; @@ -95,16 +95,18 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI /** Transformation of the Structure tensor eigenvalues into the diffusion * tensor eigenvalues. Needs to be overloaded in a subclass. * (Structure tensor eigenvalues are sorted by increasing order for convenience). */ - virtual EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const + virtual EigenValuesArrayType + EigenValuesTransform(const EigenValuesArrayType &) const { itkExceptionMacro("Undefined tensor eigenvalues transform"); } - virtual typename TensorImageType::Pointer GetLastTensorImage() + virtual typename TensorImageType::Pointer + GetLastTensorImage() { return m_TensorImage; } - using EffectiveTimesAndIterationsType = std::vector< std::pair >; + using EffectiveTimesAndIterationsType = std::vector>; itkGetConstReferenceMacro(LinearFilterEffectiveTimesAndIterations, EffectiveTimesAndIterationsType); protected: @@ -119,12 +121,14 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI typename TensorImageType::Pointer m_TensorImage; - virtual void ComputeDiffusionTensors(ImageType*); + virtual void + ComputeDiffusionTensors(ImageType *); ScalarType m_DiffusionTime; bool m_Adimensionize; - void GenerateData() override; + void + GenerateData() override; EffectiveTimesAndIterationsType m_LinearFilterEffectiveTimesAndIterations; @@ -134,7 +138,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter< TImage, TI } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION -#include "itkAnisotropicDiffusionLBRImageFilter.hxx" +# include "itkAnisotropicDiffusionLBRImageFilter.hxx" #endif #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index cc5e2540965..f5bdbb6b1d5 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -28,25 +28,22 @@ namespace itk { -template< typename TImage, typename TScalar > -AnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::AnisotropicDiffusionLBRImageFilter(): - m_NoiseScale( 0.5 ), - m_FeatureScale( 2 ), - m_RatioToMaxStableTimeStep( 0.7 ), - m_MaxTimeStepsBetweenTensorUpdates( 5 ), - m_DiffusionTime( 1 ), - m_Adimensionize( true ) -{ -} - - -template< typename TImage, typename TScalar > +template +AnisotropicDiffusionLBRImageFilter::AnisotropicDiffusionLBRImageFilter() + : m_NoiseScale(0.5) + , m_FeatureScale(2) + , m_RatioToMaxStableTimeStep(0.7) + , m_MaxTimeStepsBetweenTensorUpdates(5) + , m_DiffusionTime(1) + , m_Adimensionize(true) +{} + + +template void -AnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GenerateData() +AnisotropicDiffusionLBRImageFilter::GenerateData() { - typename ImageType::Pointer inputImage = const_cast(this->GetInput()); + typename ImageType::Pointer inputImage = const_cast(this->GetInput()); typename ImageType::Pointer image = inputImage; using SpacingType = typename ImageType::SpacingType; @@ -54,21 +51,21 @@ AnisotropicDiffusionLBRImageFilter< TImage, TScalar > // const SpacingType unitSpacing(1); // Better below for non-uniform spacing. double minSpacing = referenceSpacing[0]; - for( ImageDimensionType i = 1; i < ImageDimension; ++i ) - { - minSpacing = std::min(minSpacing,referenceSpacing[i]); - } - const SpacingType unitSpacing = referenceSpacing/minSpacing; + for (ImageDimensionType i = 1; i < ImageDimension; ++i) + { + minSpacing = std::min(minSpacing, referenceSpacing[i]); + } + const SpacingType unitSpacing = referenceSpacing / minSpacing; - if( m_Adimensionize ) - { + if (m_Adimensionize) + { inputImage->SetSpacing(unitSpacing); - } + } ScalarType remainingTime = m_DiffusionTime; - while( remainingTime > 0 ) - { + while (remainingTime > 0) + { ComputeDiffusionTensors(image); typename LinearDiffusionFilterType::Pointer linearDiffusionFilter = LinearDiffusionFilterType::New(); linearDiffusionFilter->SetMaxNumberOfTimeSteps(m_MaxTimeStepsBetweenTensorUpdates); @@ -81,68 +78,74 @@ AnisotropicDiffusionLBRImageFilter< TImage, TScalar > image = linearDiffusionFilter->GetOutput(); remainingTime -= linearDiffusionFilter->GetEffectiveDiffusionTime(); - m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair(linearDiffusionFilter->GetEffectiveDiffusionTime(),linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); + m_LinearFilterEffectiveTimesAndIterations.push_back(std::pair( + linearDiffusionFilter->GetEffectiveDiffusionTime(), linearDiffusionFilter->GetEffectiveNumberOfTimeSteps())); - this->UpdateProgress(1.-remainingTime/m_DiffusionTime); - } + this->UpdateProgress(1. - remainingTime / m_DiffusionTime); + } - if(m_Adimensionize) - { + if (m_Adimensionize) + { inputImage->SetSpacing(referenceSpacing); image->SetSpacing(referenceSpacing); - } + } this->GraftOutput(image); } -template< typename TImage, typename TScalar > -struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::DiffusionTensorFunctor +template +struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor { Self * eigenValuesFunctor; struct OrderingType; - TensorType operator()(const TensorType & S) - { - EigenValuesArrayType eigenValues; - typename TensorType::EigenVectorsMatrixType eigenVectors; - S.ComputeEigenAnalysis(eigenValues,eigenVectors); + TensorType + operator()(const TensorType & S) + { + EigenValuesArrayType eigenValues; + typename TensorType::EigenVectorsMatrixType eigenVectors; + S.ComputeEigenAnalysis(eigenValues, eigenVectors); - // For convenience, eigenvalues are sorted by increasing order - Vector order; - for(ImageDimensionType i=0; i < ImageDimension; ++i) order[i]=i; + // For convenience, eigenvalues are sorted by increasing order + Vector order; + for (ImageDimensionType i = 0; i < ImageDimension; ++i) + order[i] = i; - OrderingType ordering(eigenValues); + OrderingType ordering(eigenValues); - std::sort(order.Begin(), order.End(),ordering); + std::sort(order.Begin(), order.End(), ordering); - std::sort(eigenValues.Begin(), eigenValues.End()); - EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); + std::sort(eigenValues.Begin(), eigenValues.End()); + EigenValuesArrayType ev = this->eigenValuesFunctor->EigenValuesTransform(eigenValues); - TensorType DiffusionTensor; - for(ImageDimensionType i=0; i < ImageDimension; ++i){ - DiffusionTensor(order[i],order[i]) = ev[i]; - for(ImageDimensionType j=0; jbool {return eigenValues[i] -struct AnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::DiffusionTensorFunctor -::OrderingType +template +struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunctor ::OrderingType { - bool operator()(int i, int j) const {return this->e[i]e[j];} + bool + operator()(int i, int j) const + { + return this->e[i] < this->e[j]; + } const EigenValuesArrayType & e; - OrderingType(const EigenValuesArrayType & e_):e(e_){}; + OrderingType(const EigenValuesArrayType & e_) + : e(e_){}; }; -template< typename TImage, typename TScalar > +template void -AnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::ComputeDiffusionTensors( ImageType * image ) +AnisotropicDiffusionLBRImageFilter::ComputeDiffusionTensors(ImageType * image) { typename StructureTensorFilterType::Pointer structureTensorFilter = StructureTensorFilterType::New(); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h index d97854d09d4..23f2a04d46e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h @@ -27,9 +27,13 @@ Getters and setters for functor types, inspired by UnaryFunctorImageFilter. No equality test performed for the setter. */ -#define GetSetFunctorMacro(name, type) \ - virtual type & Get##name() {return this->m_##name;} \ - virtual const type & Get##name() const {return this->m_##name;} \ - virtual void Set##name(const type & _arg) {m_##name = _arg; this->Modified();} +#define GetSetFunctorMacro(name, type) \ + virtual type & Get##name() { return this->m_##name; } \ + virtual const type & Get##name() const { return this->m_##name; } \ + virtual void Set##name(const type & _arg) \ + { \ + m_##name = _arg; \ + this->Modified(); \ + } #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index 62be1d2f842..0f9be559714 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -60,17 +60,16 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > -class CoherenceEnhancingDiffusionImageFilter: - public AnisotropicDiffusionLBRImageFilter< TImage, TScalar > +template ::RealType> +class CoherenceEnhancingDiffusionImageFilter : public AnisotropicDiffusionLBRImageFilter { public: ITK_DISALLOW_COPY_AND_ASSIGN(CoherenceEnhancingDiffusionImageFilter); using Self = CoherenceEnhancingDiffusionImageFilter; - using Superclass = AnisotropicDiffusionLBRImageFilter< TImage, TScalar >; - using Pointer = SmartPointer< Self >; - using ConstPointer = SmartPointer< const Self >; + using Superclass = AnisotropicDiffusionLBRImageFilter; + using Pointer = SmartPointer; + using ConstPointer = SmartPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -82,7 +81,8 @@ class CoherenceEnhancingDiffusionImageFilter: static constexpr InputImageDimensionType InputImageDimension = Superclass::InputImageType::ImageDimension; using EigenValuesArrayType = typename Superclass::EigenValuesArrayType; - EigenValuesArrayType EigenValuesTransform(const EigenValuesArrayType &) const override; + EigenValuesArrayType + EigenValuesTransform(const EigenValuesArrayType &) const override; using ScalarType = typename Superclass::ScalarType; /** Exponent m involved in the function g defining eigenvalues. */ @@ -94,7 +94,14 @@ class CoherenceEnhancingDiffusionImageFilter: itkGetMacro(Lambda, ScalarType); itkGetMacro(Alpha, ScalarType); - enum EnhancementType {CED, cCED, EED, cEED, Isotropic}; + enum EnhancementType + { + CED, + cCED, + EED, + cEED, + Isotropic + }; /// Switch between CED, EED, and variants. itkSetEnumMacro(Enhancement, EnhancementType); itkGetEnumMacro(Enhancement, EnhancementType); @@ -105,8 +112,16 @@ class CoherenceEnhancingDiffusionImageFilter: ScalarType m_Alpha; EnhancementType m_Enhancement; - ScalarType g_CED(ScalarType s) const {return s<=0 ? m_Alpha : m_Alpha + (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} - ScalarType g_EED(ScalarType s) const {return s<=0 ? 1 : 1 - (1-m_Alpha)*exp(-pow(m_Lambda/s,m_Exponent));} + ScalarType + g_CED(ScalarType s) const + { + return s <= 0 ? m_Alpha : m_Alpha + (1 - m_Alpha) * exp(-pow(m_Lambda / s, m_Exponent)); + } + ScalarType + g_EED(ScalarType s) const + { + return s <= 0 ? 1 : 1 - (1 - m_Alpha) * exp(-pow(m_Lambda / s, m_Exponent)); + } CoherenceEnhancingDiffusionImageFilter(); ~CoherenceEnhancingDiffusionImageFilter() override = default; @@ -115,7 +130,7 @@ class CoherenceEnhancingDiffusionImageFilter: } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION -#include "itkCoherenceEnhancingDiffusionImageFilter.hxx" +# include "itkCoherenceEnhancingDiffusionImageFilter.hxx" #endif #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx index f0facf60b2d..c548f49ab1e 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx @@ -24,70 +24,67 @@ namespace itk { -template< typename TImage, typename TScalar > -CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > -::CoherenceEnhancingDiffusionImageFilter(): - m_Lambda( 0.05 ), - m_Exponent( 2 ), - m_Alpha( 0.01 ), - m_Enhancement( CED ) -{ -} +template +CoherenceEnhancingDiffusionImageFilter::CoherenceEnhancingDiffusionImageFilter() + : m_Lambda(0.05) + , m_Exponent(2) + , m_Alpha(0.01) + , m_Enhancement(CED) +{} -template< typename TImage, typename TScalar > -typename CoherenceEnhancingDiffusionImageFilter< TImage, TScalar >::EigenValuesArrayType -CoherenceEnhancingDiffusionImageFilter< TImage, TScalar > -::EigenValuesTransform(const EigenValuesArrayType & ev0) const +template +typename CoherenceEnhancingDiffusionImageFilter::EigenValuesArrayType +CoherenceEnhancingDiffusionImageFilter::EigenValuesTransform(const EigenValuesArrayType & ev0) const { const ScalarType evMin = ev0[0]; - const ScalarType evMax = ev0[InputImageDimension-1]; + const ScalarType evMax = ev0[InputImageDimension - 1]; EigenValuesArrayType ev; - switch(m_Enhancement) - { - // Weickert's filter. + switch (m_Enhancement) + { + // Weickert's filter. case CED: - for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) - { - ev[i] = g_CED(evMax-ev0[i]); - } - break; + for (InputImageDimensionType i = 0; i < InputImageDimension; ++i) + { + ev[i] = g_CED(evMax - ev0[i]); + } + break; - // A variance, requiring stronger coherence. + // A variance, requiring stronger coherence. case cCED: - for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) - { - ev[i] = g_CED( (evMax-ev0[i])/(1.+ev0[i]/m_Lambda) ); - } - break; + for (InputImageDimensionType i = 0; i < InputImageDimension; ++i) + { + ev[i] = g_CED((evMax - ev0[i]) / (1. + ev0[i] / m_Lambda)); + } + break; - // Weickert's filter. + // Weickert's filter. case EED: - for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) - { - ev[i] = g_EED(ev0[i]-evMin); - } - break; + for (InputImageDimensionType i = 0; i < InputImageDimension; ++i) + { + ev[i] = g_EED(ev0[i] - evMin); + } + break; - // A variant, promoting diffusion in at least one direction at each point. + // A variant, promoting diffusion in at least one direction at each point. case cEED: - for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) - { - ev[i] = g_EED(ev0[i]); - } - break; + for (InputImageDimensionType i = 0; i < InputImageDimension; ++i) + { + ev[i] = g_EED(ev0[i]); + } + break; - // Isotropic tensors, closely related to Perona-Malik's approach. + // Isotropic tensors, closely related to Perona-Malik's approach. case Isotropic: - for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) - { - ev[i] = g_EED(evMax); - } - break; + for (InputImageDimensionType i = 0; i < InputImageDimension; ++i) + { + ev[i] = g_EED(evMax); + } + break; default: - itkExceptionMacro("Unsupported diffusion type"); + itkExceptionMacro("Unsupported diffusion type"); } return ev; } diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 29abca8d7f0..dd5d198e9bd 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -43,18 +43,17 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template< typename TImage, typename TScalar = typename NumericTraits< typename TImage::PixelType >::RealType > -class LinearAnisotropicDiffusionLBRImageFilter: - public ImageToImageFilter< TImage, TImage > +template ::RealType> +class LinearAnisotropicDiffusionLBRImageFilter : public ImageToImageFilter { public: ITK_DISALLOW_COPY_AND_ASSIGN(LinearAnisotropicDiffusionLBRImageFilter); /** Standard class type alias. */ using Self = LinearAnisotropicDiffusionLBRImageFilter; - using Superclass = ImageToImageFilter< TImage, TImage >; - using Pointer = SmartPointer< Self >; - using ConstPointer = SmartPointer< const Self >; + using Superclass = ImageToImageFilter; + using Pointer = SmartPointer; + using ConstPointer = SmartPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -69,20 +68,25 @@ class LinearAnisotropicDiffusionLBRImageFilter: static constexpr ImageDimensionType ImageDimension = ImageType::ImageDimension; using ScalarType = TScalar; - using TensorType = SymmetricSecondRankTensor< ScalarType, ImageDimension >; - using TensorImageType = Image< TensorType, ImageDimension >; - using RegionType = ImageRegion< ImageDimension >; + using TensorType = SymmetricSecondRankTensor; + using TensorImageType = Image; + using RegionType = ImageRegion; - void SetInputImage(const ImageType* image); - void SetInputTensor(const TensorImageType* tensorImage); + void + SetInputImage(const ImageType * image); + void + SetInputTensor(const TensorImageType * tensorImage); - void SetMaxDiffusionTime(ScalarType time); + void + SetMaxDiffusionTime(ScalarType time); itkGetConstMacro(DiffusionTime, ScalarType); - void SetMaxNumberOfTimeSteps(int n); + void + SetMaxNumberOfTimeSteps(int n); itkGetConstMacro(MaxNumberOfTimeSteps, int); - void SetRatioToMaxStableTimeStep(ScalarType ratio); + void + SetRatioToMaxStableTimeStep(ScalarType ratio); itkGetConstMacro(RatioToMaxStableTimeStep, ScalarType); itkGetConstMacro(EffectiveDiffusionTime, ScalarType); @@ -92,8 +96,10 @@ class LinearAnisotropicDiffusionLBRImageFilter: LinearAnisotropicDiffusionLBRImageFilter(); ~LinearAnisotropicDiffusionLBRImageFilter() override = default; - typename ImageType::ConstPointer GetInputImage(); - typename TensorImageType::ConstPointer GetInputTensor(); + typename ImageType::ConstPointer + GetInputImage(); + typename TensorImageType::ConstPointer + GetInputTensor(); using IndexType = Index; @@ -101,27 +107,31 @@ class LinearAnisotropicDiffusionLBRImageFilter: static const unsigned int HalfStencilSize = (ImageDimension == 2) ? 3 : 6; static const unsigned int StencilSize = 2 * HalfStencilSize; - using StencilCoefficientsType = Vector; + using StencilCoefficientsType = Vector; using OffsetType = Offset; using StencilOffsetsType = Vector; using InternalSizeT = int; - using StencilBufferIndicesType = Vector; + using StencilBufferIndicesType = Vector; // *************** Computation ***************** - void GenerateData() override; - virtual void GenerateStencils(); /// Automatically called by GenerateData - virtual void ImageUpdateLoop(); /// Automatically called by GenerateData - - using StencilType = std::pair< StencilBufferIndicesType, StencilCoefficientsType >; - using StencilImageType = Image< StencilType, ImageDimension >; + void + GenerateData() override; + virtual void + GenerateStencils(); /// Automatically called by GenerateData + virtual void + ImageUpdateLoop(); /// Automatically called by GenerateData + + using StencilType = std::pair; + using StencilImageType = Image; typename StencilImageType::Pointer m_StencilImage; using ScalarImageType = Image; typename ScalarImageType::Pointer m_DiagonalCoefficients; - virtual ScalarType MaxStableTimeStep(); + virtual ScalarType + MaxStableTimeStep(); ScalarType m_DiffusionTime; ScalarType m_RatioToMaxStableTimeStep; @@ -130,26 +140,35 @@ class LinearAnisotropicDiffusionLBRImageFilter: ScalarType m_EffectiveDiffusionTime; int m_EffectiveNumberOfTimeSteps; - virtual void ImageUpdate(ScalarType delta); + virtual void + ImageUpdate(ScalarType delta); typename ImageType::Pointer m_PreviousImage; typename ImageType::Pointer m_NextImage; - virtual RegionType GetRequestedRegion(){return GetInputImage()->GetRequestedRegion();} + virtual RegionType + GetRequestedRegion() + { + return GetInputImage()->GetRequestedRegion(); + } - InternalSizeT OutsideBufferIndex() const {return NumericTraits::max();} + InternalSizeT + OutsideBufferIndex() const + { + return NumericTraits::max(); + } struct StencilFunctor; struct FunctorType; using VectorType = Vector; - static ScalarType ScalarProduct(const TensorType &, const VectorType &, const VectorType &); - + static ScalarType + ScalarProduct(const TensorType &, const VectorType &, const VectorType &); }; } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION -#include "itkLinearAnisotropicDiffusionLBRImageFilter.hxx" +# include "itkLinearAnisotropicDiffusionLBRImageFilter.hxx" #endif #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index cc117eb9f7e..cf9f18718f7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -35,58 +35,53 @@ namespace itk { -template< typename TImage, typename TScalar > -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::LinearAnisotropicDiffusionLBRImageFilter(): - m_DiffusionTime( 1 ), - m_RatioToMaxStableTimeStep( 0.7 ), - m_MaxNumberOfTimeSteps( 10 ), - m_EffectiveDiffusionTime( 0 ), - m_EffectiveNumberOfTimeSteps( 0 ) +template +LinearAnisotropicDiffusionLBRImageFilter::LinearAnisotropicDiffusionLBRImageFilter() + : m_DiffusionTime(1) + , m_RatioToMaxStableTimeStep(0.7) + , m_MaxNumberOfTimeSteps(10) + , m_EffectiveDiffusionTime(0) + , m_EffectiveNumberOfTimeSteps(0) { this->SetNumberOfRequiredInputs(2); } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::SetInputImage( const ImageType * image ) +LinearAnisotropicDiffusionLBRImageFilter::SetInputImage(const ImageType * image) { - this->SetNthInput(0, const_cast(image)); + this->SetNthInput(0, const_cast(image)); } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::SetInputTensor( const TensorImageType* tensorImage ) +LinearAnisotropicDiffusionLBRImageFilter::SetInputTensor(const TensorImageType * tensorImage) { - this->SetNthInput(1, const_cast(tensorImage)); + this->SetNthInput(1, const_cast(tensorImage)); } -template< typename TImage, typename TScalar > -typename TImage::ConstPointer LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GetInputImage() +template +typename TImage::ConstPointer +LinearAnisotropicDiffusionLBRImageFilter::GetInputImage() { - return static_cast< const ImageType * > ( this->ProcessObject::GetInput(0) ); + return static_cast(this->ProcessObject::GetInput(0)); } -template< typename TImage, typename TScalar > -typename LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar >::TensorImageType::ConstPointer -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GetInputTensor() +template +typename LinearAnisotropicDiffusionLBRImageFilter::TensorImageType::ConstPointer +LinearAnisotropicDiffusionLBRImageFilter::GetInputTensor() { - return static_cast< const TensorImageType * > ( this->ProcessObject::GetInput(1) ); + return static_cast(this->ProcessObject::GetInput(1)); } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GenerateData() +LinearAnisotropicDiffusionLBRImageFilter::GenerateData() { GenerateStencils(); this->UpdateProgress(0.5); @@ -95,213 +90,237 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > } // **************************** Computation *********************** -template< typename TImage, typename TScalar > -struct LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::StencilFunctor +template +struct LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor { public: using SpacingType = typename TensorImageType::SpacingType; - void Initialize(RegionType region_, SpacingType spacing) - { + void + Initialize(RegionType region_, SpacingType spacing) + { region = region_; prod[0] = 1; - for( ImageDimensionType i = 1; i < ImageDimension; ++i ) - { - prod[i]=prod[i-1]*region.GetSize()[i-1]; - } - for(ImageDimensionType i = 0; i < ImageDimension; ++i ) - { + for (ImageDimensionType i = 1; i < ImageDimension; ++i) + { + prod[i] = prod[i - 1] * region.GetSize()[i - 1]; + } + for (ImageDimensionType i = 0; i < ImageDimension; ++i) + { invSpacing[i] = ScalarType(1) / spacing[i]; - } } + } - InternalSizeT BufferIndex(const IndexType & x) const + InternalSizeT + BufferIndex(const IndexType & x) const { - IndexValueType ans=0; - for( ImageDimensionType i = 0; i < ImageDimension; ++i ) - { - ans += this->prod[i] * ( x[i] - this->region.GetIndex()[i] ); - } + IndexValueType ans = 0; + for (ImageDimensionType i = 0; i < ImageDimension; ++i) + { + ans += this->prod[i] * (x[i] - this->region.GetIndex()[i]); + } return ans; } - StencilType operator()(const TensorType & tensor, const IndexType & x) const + StencilType + operator()(const TensorType & tensor, const IndexType & x) const { - StencilType stencil; + StencilType stencil; StencilOffsetsType offsets; // Diffusion tensors are homogeneous to the inverse of norms, and are thus rescaled with an inverse spacing. TensorType D; - for(ImageDimensionType i=0; iinvSpacing[i]*this->invSpacing[j]; - this->Stencil( Dispatch< ImageDimension >(), D, offsets, stencil.second ); + for (ImageDimensionType i = 0; i < ImageDimension; ++i) + for (ImageDimensionType j = i; j < ImageDimension; ++j) + D(i, j) = tensor(i, j) * this->invSpacing[i] * this->invSpacing[j]; + this->Stencil(Dispatch(), D, offsets, stencil.second); InternalSizeT * yIndex = &stencil.first[0]; - //Compute buffer offsets from geometrical offsets - for(unsigned int i=0; iregion.IsInside(y)){ - *yIndex = this->BufferIndex(y); - } else { - // Neumann boundary conditions. - *yIndex = this->OutsideBufferIndex(); - } // if y - } // for eps - } // for i + // Compute buffer offsets from geometrical offsets + for (unsigned int i = 0; i < HalfStencilSize; ++i) + { + for (auto orientation = 0; orientation < 2; ++orientation, ++yIndex) + { + const IndexType y = orientation ? x - offsets[i] : x + offsets[i]; + if (this->region.IsInside(y)) + { + *yIndex = this->BufferIndex(y); + } + else + { + // Neumann boundary conditions. + *yIndex = this->OutsideBufferIndex(); + } // if y + } // for eps + } // for i return stencil; } protected: - struct DispatchBase {}; - template< unsigned int > - struct Dispatch: public DispatchBase {}; - - static void Stencil(const Dispatch< 2 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) + struct DispatchBase + {}; + template + struct Dispatch : public DispatchBase + {}; + + static void + Stencil(const Dispatch<2> &, + const TensorType & D, + StencilOffsetsType & offsets, + StencilCoefficientsType & coefficients) { // Construct a superbase, and make it obtuse with Selling's algorithm - VectorType sb[ImageDimension+1]; //SuperBase - for(ImageDimensionType i=0; i 0) { - if( ScalarProduct(D,sb[i],sb[j]) > 0 ) - { - const VectorType u=sb[i], v=sb[j]; - sb[0]=v-u; - sb[1]=u; - sb[2]=-v; - same=false; - } + const VectorType u = sb[i], v = sb[j]; + sb[0] = v - u; + sb[1] = u; + sb[2] = -v; + same = false; } } - if(same) - { - break; - } } - if( iter == maxIter ) + if (same) { - std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; + break; } + } + if (iter == maxIter) + { + std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; + } - for( ImageDimensionType i = 0; i < 3; ++i ) - { - coefficients[i] = (-0.5)*ScalarProduct(D,sb[(i+1)%3],sb[(i+2)%3]); - assert(coefficients[i]>=0); + for (ImageDimensionType i = 0; i < 3; ++i) + { + coefficients[i] = (-0.5) * ScalarProduct(D, sb[(i + 1) % 3], sb[(i + 2) % 3]); + assert(coefficients[i] >= 0); offsets[i][0] = static_cast(-sb[i][1]); - offsets[i][1] = static_cast( sb[i][0]); - } + offsets[i][1] = static_cast(sb[i][0]); + } } - static void Stencil(const Dispatch< 3 > &, const TensorType & D, StencilOffsetsType & offsets, StencilCoefficientsType & coefficients) + static void + Stencil(const Dispatch<3> &, + const TensorType & D, + StencilOffsetsType & offsets, + StencilCoefficientsType & coefficients) { // Construct a superbase, and make it obtuse with Selling's algorithm - VectorType sb[ImageDimension+1]; - for(ImageDimensionType i=0; i 0 ){ - const VectorType u=sb[i], v=sb[j]; - for(ImageDimensionType k=0,l=0; k<=ImageDimension; ++k) - if(k!=i && k!=j) - sb[l++]=sb[k]+u; - sb[2]=-u; - sb[3]=v; - same=false; - } - if(same) break; - } - if(iter==maxIter) - { + int iter = 0; + for (; iter < maxIter; ++iter) + { + bool same = true; + for (ImageDimensionType i = 1; i <= ImageDimension && same; ++i) + for (ImageDimensionType j = 0; j < i && same; ++j) + if (ScalarProduct(D, sb[i], sb[j]) > 0) + { + const VectorType u = sb[i], v = sb[j]; + for (ImageDimensionType k = 0, l = 0; k <= ImageDimension; ++k) + if (k != i && k != j) + sb[l++] = sb[k] + u; + sb[2] = -u; + sb[3] = v; + same = false; + } + if (same) + break; + } + if (iter == maxIter) + { std::cerr << "Warning: Selling's algorithm not stabilized." << std::endl; - } + } // Computation of the weights - SymmetricSecondRankTensor Weights; - for(ImageDimensionType i=1; i Weights; + for (ImageDimensionType i = 1; i < ImageDimension + 1; ++i) + { + for (ImageDimensionType j = 0; j < i; ++j) { - for(ImageDimensionType j=0; j::max();} + InternalSizeT + OutsideBufferIndex() const + { + return NumericTraits::max(); + } }; -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::GenerateStencils() +LinearAnisotropicDiffusionLBRImageFilter::GenerateStencils() { - // Stencil type is a pair type because itk::UnaryFunctorImage filter - // only produces one output -// using SpacingType = typename TensorImageType::SpacingType; + // Stencil type is a pair type because itk::UnaryFunctorImage filter + // only produces one output + // using SpacingType = typename TensorImageType::SpacingType; const RegionType region = GetRequestedRegion(); - using FunctorFilterType = UnaryFunctorWithIndexImageFilter; + using FunctorFilterType = UnaryFunctorWithIndexImageFilter; typename FunctorFilterType::Pointer filter = FunctorFilterType::New(); filter->SetInput(GetInputTensor()); filter->GetFunctor().Initialize(region, GetInputTensor()->GetSpacing()); @@ -309,7 +328,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > m_StencilImage = filter->GetOutput(); - //setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. + // setup diagonal coefficients. Cannot be parallelized due to non-local modifications of diagBuffer. m_DiagonalCoefficients = ScalarImageType::New(); m_DiagonalCoefficients->CopyInformation(GetInputTensor()); @@ -317,102 +336,95 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > m_DiagonalCoefficients->Allocate(); m_DiagonalCoefficients->FillBuffer(ScalarType(0)); - ImageRegionConstIterator stencilIt(m_StencilImage,region); - ImageRegionIterator diagIt(m_DiagonalCoefficients, region); - ScalarType * diagBuffer = m_DiagonalCoefficients->GetBufferPointer(); + ImageRegionConstIterator stencilIt(m_StencilImage, region); + ImageRegionIterator diagIt(m_DiagonalCoefficients, region); + ScalarType * diagBuffer = m_DiagonalCoefficients->GetBufferPointer(); - for(stencilIt.GoToBegin(), diagIt.GoToBegin(); - !stencilIt.IsAtEnd(); - ++stencilIt, ++diagIt) + for (stencilIt.GoToBegin(), diagIt.GoToBegin(); !stencilIt.IsAtEnd(); ++stencilIt, ++diagIt) + { + for (unsigned int i = 0; i < StencilSize; ++i) { - for(unsigned int i = 0; i < StencilSize; ++i) - { const InternalSizeT yIndex = stencilIt.Value().first[i]; - if( yIndex != OutsideBufferIndex() ) - { - const ScalarType coefficient = stencilIt.Value().second[i/2]; + if (yIndex != OutsideBufferIndex()) + { + const ScalarType coefficient = stencilIt.Value().second[i / 2]; diagIt.Value() += coefficient; diagBuffer[yIndex] += coefficient; - } // if y - } // for i - } // for stencilIt, diagIt + } // if y + } // for i + } // for stencilIt, diagIt } -template< typename TImage, typename TScalar > -typename LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar >::ScalarType -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::MaxStableTimeStep() +template +typename LinearAnisotropicDiffusionLBRImageFilter::ScalarType +LinearAnisotropicDiffusionLBRImageFilter::MaxStableTimeStep() { using MaxCalculatorType = MinimumMaximumImageCalculator; typename MaxCalculatorType::Pointer maximumCalculator = MaxCalculatorType::New(); maximumCalculator->SetImage(m_DiagonalCoefficients); maximumCalculator->SetRegion(GetRequestedRegion()); maximumCalculator->ComputeMaximum(); - return 1./maximumCalculator->GetMaximum(); + return 1. / maximumCalculator->GetMaximum(); } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::SetMaxDiffusionTime(ScalarType time) +LinearAnisotropicDiffusionLBRImageFilter::SetMaxDiffusionTime(ScalarType time) { - if(time<0) - { + if (time < 0) + { itkExceptionMacro("diffusion time must be finite and positive"); - } + } m_DiffusionTime = time; } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::SetRatioToMaxStableTimeStep(ScalarType ratio) +LinearAnisotropicDiffusionLBRImageFilter::SetRatioToMaxStableTimeStep(ScalarType ratio) { - if(ratio<=0 || ratio>1) - { + if (ratio <= 0 || ratio > 1) + { itkExceptionMacro("Ratio to max time step " << ratio << "should be within ]0,1]"); - } - m_RatioToMaxStableTimeStep=ratio; + } + m_RatioToMaxStableTimeStep = ratio; } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::SetMaxNumberOfTimeSteps(int n) +LinearAnisotropicDiffusionLBRImageFilter::SetMaxNumberOfTimeSteps(int n) { - if(n<=0) - { + if (n <= 0) + { itkExceptionMacro("Max number of time steps must be positive"); - } - m_MaxNumberOfTimeSteps=n; + } + m_MaxNumberOfTimeSteps = n; } -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::ImageUpdateLoop() +LinearAnisotropicDiffusionLBRImageFilter::ImageUpdateLoop() { ScalarType delta = MaxStableTimeStep() * m_RatioToMaxStableTimeStep; - int n = ceil(m_DiffusionTime / delta); - if(n>m_MaxNumberOfTimeSteps) - { + int n = ceil(m_DiffusionTime / delta); + if (n > m_MaxNumberOfTimeSteps) + { n = m_MaxNumberOfTimeSteps; - m_EffectiveDiffusionTime = n*delta; - } + m_EffectiveDiffusionTime = n * delta; + } else - { + { delta = m_DiffusionTime / n; m_EffectiveDiffusionTime = m_DiffusionTime; - } + } m_EffectiveNumberOfTimeSteps = n; // Extraction of the region of interest is required for image buffer access. - using InputCasterType = ExtractImageFilter< ImageType, ImageType >; + using InputCasterType = ExtractImageFilter; typename InputCasterType::Pointer inputCaster = InputCasterType::New(); inputCaster->SetInput(GetInputImage()); inputCaster->SetExtractionRegion(GetRequestedRegion()); @@ -425,63 +437,62 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > m_NextImage->SetRegions(m_PreviousImage->GetBufferedRegion()); m_NextImage->Allocate(); - for( auto k = 0; k < n; ++k ) - { + for (auto k = 0; k < n; ++k) + { ImageUpdate(delta); std::swap(m_PreviousImage, m_NextImage); - this->UpdateProgress(0.5+0.5*k/float(n)); - } + this->UpdateProgress(0.5 + 0.5 * k / float(n)); + } this->GraftOutput(m_PreviousImage); } -template< typename TImage, typename TScalar > -struct LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::FunctorType +template +struct LinearAnisotropicDiffusionLBRImageFilter::FunctorType { ScalarType delta; - PixelType operator()(PixelType output, PixelType input, ScalarType diag){ - return output*this->delta + input*(ScalarType(1)-this->delta*diag); + PixelType + operator()(PixelType output, PixelType input, ScalarType diag) + { + return output * this->delta + input * (ScalarType(1) - this->delta * diag); } }; -template< typename TImage, typename TScalar > +template void -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > -::ImageUpdate(ScalarType delta) +LinearAnisotropicDiffusionLBRImageFilter::ImageUpdate(ScalarType delta) { - //Setting up iterators + // Setting up iterators ImageRegion region = GetRequestedRegion(); - ImageRegionConstIterator inputIt(m_PreviousImage,region); - ImageRegionIterator outputIt(m_NextImage,region); + ImageRegionConstIterator inputIt(m_PreviousImage, region); + ImageRegionIterator outputIt(m_NextImage, region); - const PixelType * inputBuffer = m_PreviousImage->GetBufferPointer(); - PixelType * outputBuffer = m_NextImage->GetBufferPointer(); + const PixelType * inputBuffer = m_PreviousImage->GetBufferPointer(); + PixelType * outputBuffer = m_NextImage->GetBufferPointer(); - ImageRegionConstIterator diagIt(m_DiagonalCoefficients, region); - ImageRegionConstIterator stencilIt(m_StencilImage, region); + ImageRegionConstIterator diagIt(m_DiagonalCoefficients, region); + ImageRegionConstIterator stencilIt(m_StencilImage, region); // Rest of function is a hand-made (sparse matrix)*vector product. m_NextImage->FillBuffer(0.); // Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer - for( inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); - !inputIt.IsAtEnd(); - ++inputIt, ++outputIt, ++stencilIt ) + for (inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); !inputIt.IsAtEnd(); + ++inputIt, ++outputIt, ++stencilIt) + { + for (unsigned int i = 0; i < StencilSize; ++i) { - for( unsigned int i = 0; i < StencilSize; ++i ) + const InternalSizeT yIndex = stencilIt.Value().first[i]; + if (yIndex != OutsideBufferIndex()) { - const InternalSizeT yIndex = stencilIt.Value().first[i]; - if( yIndex != OutsideBufferIndex() ) - { - const ScalarType coefficient = stencilIt.Value().second[i/2]; + const ScalarType coefficient = stencilIt.Value().second[i / 2]; outputIt.Value() += coefficient * (inputBuffer[yIndex]); outputBuffer[yIndex] += coefficient * inputIt.Value(); - } } } + } using ImageFunctorType = TernaryFunctorImageFilter; typename ImageFunctorType::Pointer imageFunctor = ImageFunctorType::New(); @@ -493,7 +504,7 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > assert(imageFunctor->CanRunInPlace()); imageFunctor->InPlaceOn(); imageFunctor->Update(); - m_NextImage=imageFunctor->GetOutput(); + m_NextImage = imageFunctor->GetOutput(); /* // Old Serial version for diagonal elements @@ -506,25 +517,24 @@ LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar > // **************************** subclass SSRT_Traits call method ************************** -template< typename TImage, typename TScalar > +template TScalar -LinearAnisotropicDiffusionLBRImageFilter< TImage, TScalar> -::ScalarProduct(const TensorType & m, - const VectorType & u, - const VectorType & v) +LinearAnisotropicDiffusionLBRImageFilter::ScalarProduct(const TensorType & m, + const VectorType & u, + const VectorType & v) { ScalarType result(0); - for( ImageDimensionType i = 0; i < ImageDimension; ++i ) - { - result += m(i,i) * u[i] * v[i]; - } - for( ImageDimensionType i = 0; i < ImageDimension; ++i ) + for (ImageDimensionType i = 0; i < ImageDimension; ++i) + { + result += m(i, i) * u[i] * v[i]; + } + for (ImageDimensionType i = 0; i < ImageDimension; ++i) + { + for (ImageDimensionType j = i + 1; j < ImageDimension; ++j) { - for( ImageDimensionType j = i+1; j < ImageDimension; ++j ) - { - result += m(i,j) * (u[i] * v[j] + u[j] * v[i]); - } + result += m(i, j) * (u[i] * v[j] + u[j] * v[i]); } + } return result; } diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index bfed36fecbb..ace41ce22eb 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -46,17 +46,16 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template< typename TImage, - typename TTensorImage = - Image< SymmetricSecondRankTensor< typename TImage::PixelType,TImage::ImageDimension >, TImage::ImageDimension > > -class StructureTensorImageFilter: - public ImageToImageFilter< TImage, TTensorImage > +template , + TImage::ImageDimension>> +class StructureTensorImageFilter : public ImageToImageFilter { public: ITK_DISALLOW_COPY_AND_ASSIGN(StructureTensorImageFilter); using Self = StructureTensorImageFilter; - using Superclass = ImageToImageFilter< TImage, TImage>; + using Superclass = ImageToImageFilter; using Pointer = SmartPointer; using ConstPointer = SmartPointer; @@ -75,11 +74,11 @@ class StructureTensorImageFilter: using ScalarType = typename TensorType::ComponentType; using ScalarImageType = Image; - ///Parameter \f$\sigma\f$ of the structure tensor definition. + /// Parameter \f$\sigma\f$ of the structure tensor definition. itkSetMacro(NoiseScale, ScalarType); - ///Parameter \f$\rho\f$ of the structure tensor definition. + /// Parameter \f$\rho\f$ of the structure tensor definition. itkSetMacro(FeatureScale, ScalarType); - ///Rescales all structure tensors by a common factor, so that the maximum trace is 1. + /// Rescales all structure tensors by a common factor, so that the maximum trace is 1. itkSetMacro(RescaleForUnitMaximumTrace, bool); itkGetConstMacro(NoiseScale, ScalarType); @@ -88,7 +87,8 @@ class StructureTensorImageFilter: itkGetConstMacro(PostRescaling, ScalarType); /// Global rescaling constant used. protected: - void GenerateData() override; + void + GenerateData() override; ScalarType m_FeatureScale; ScalarType m_NoiseScale; @@ -96,12 +96,16 @@ class StructureTensorImageFilter: ScalarType m_PostRescaling; bool m_UseGradientRecursiveGaussianImageFilter; - struct DispatchBase {}; - template< bool > - struct Dispatch: public DispatchBase {}; + struct DispatchBase + {}; + template + struct Dispatch : public DispatchBase + {}; - void IntermediateFilter( const Dispatch< true > & ); - void IntermediateFilter( const Dispatch< false > & ); + void + IntermediateFilter(const Dispatch &); + void + IntermediateFilter(const Dispatch &); typename TensorImageType::Pointer m_IntermediateResult; using CovariantVectorType = CovariantVector; @@ -109,30 +113,35 @@ class StructureTensorImageFilter: struct OuterFunctor { - TensorType operator()(const CovariantVectorType & u) const - { + TensorType + operator()(const CovariantVectorType & u) const + { TensorType m; - for( InputImageDimensionType i = 0; i < InputImageDimension; ++i ) + for (InputImageDimensionType i = 0; i < InputImageDimension; ++i) + { + for (InputImageDimensionType j = i; j < InputImageDimension; ++j) { - for( InputImageDimensionType j = i; j < InputImageDimension; ++j) - { - m(i,j) = u[i]*u[j]; - } + m(i, j) = u[i] * u[j]; } - return m; } + return m; + } }; struct TraceFunctor { - ScalarType operator()(const TensorType & t) const { - return t.GetTrace(); + ScalarType + operator()(const TensorType & t) const + { + return t.GetTrace(); } }; struct ScaleFunctor { ScalarType scaling; - TensorType operator()(const TensorType & t) const { - return t*scaling; + TensorType + operator()(const TensorType & t) const + { + return t * scaling; } }; @@ -142,7 +151,7 @@ class StructureTensorImageFilter: } // end namespace itk #ifndef ITK_MANUAL_INSTANTIATION -#include "itkStructureTensorImageFilter.hxx" +# include "itkStructureTensorImageFilter.hxx" #endif #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 402b4395ba0..c1361000146 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -29,28 +29,25 @@ namespace itk { -template< typename TImage, typename TTensorImage > -StructureTensorImageFilter< TImage, TTensorImage > -::StructureTensorImageFilter(): - m_FeatureScale( 2 ), - m_NoiseScale( 1 ), - m_RescaleForUnitMaximumTrace( false ), - m_UseGradientRecursiveGaussianImageFilter( true ) -{ -} +template +StructureTensorImageFilter::StructureTensorImageFilter() + : m_FeatureScale(2) + , m_NoiseScale(1) + , m_RescaleForUnitMaximumTrace(false) + , m_UseGradientRecursiveGaussianImageFilter(true) +{} -template< typename TImage, typename TTensorImage > +template void -StructureTensorImageFilter< TImage, TTensorImage > -::IntermediateFilter( const Dispatch< true > & ) +StructureTensorImageFilter::IntermediateFilter(const Dispatch &) { - using GradientFilterType = GradientRecursiveGaussianImageFilter< TImage, Self::CovariantImageType >; + using GradientFilterType = GradientRecursiveGaussianImageFilter; typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); gradientFilter->SetInput(this->GetInput()); gradientFilter->SetSigma(this->m_NoiseScale); - using OuterFilterType = UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor >; + using OuterFilterType = UnaryFunctorImageFilter; typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); outerFilter->SetInput(gradientFilter->GetOutput()); @@ -59,52 +56,54 @@ StructureTensorImageFilter< TImage, TTensorImage > } -template< typename TImage, typename TTensorImage > +template void -StructureTensorImageFilter< TImage, TTensorImage > -::IntermediateFilter( const Dispatch< false > & ) +StructureTensorImageFilter::IntermediateFilter(const Dispatch &) { - typename Self::ImageType::ConstPointer input = this->GetInput(); + typename Self::ImageType::ConstPointer input = this->GetInput(); typename Self::TensorImageType::Pointer output = Self::TensorImageType::New(); output->CopyInformation(input); output->SetRegions(input->GetRequestedRegion()); output->Allocate(); output->FillBuffer(Self::TensorType(0.)); - for( unsigned int index = 0; index < Self::PixelType::Dimension; ++index ) - { - using SelectionFilterType = VectorIndexSelectionCastImageFilter< Self::ImageType, Self::ScalarImageType >; + for (unsigned int index = 0; index < Self::PixelType::Dimension; ++index) + { + using SelectionFilterType = VectorIndexSelectionCastImageFilter; typename SelectionFilterType::Pointer selectionFilter = SelectionFilterType::New(); selectionFilter->SetIndex(index); selectionFilter->SetInput(input); - using GaussianFilterType = RecursiveGaussianImageFilter< Self::ScalarImageType >; - using GradientFilterType = GradientImageFilter< Self::ScalarImageType, Self::ScalarType, Self::ScalarType, Self::CovariantImageType >; - using GradientGaussianFilterType = GradientRecursiveGaussianImageFilter< Self::ScalarImageType, Self::CovariantImageType >; + using GaussianFilterType = RecursiveGaussianImageFilter; + using GradientFilterType = + GradientImageFilter; + using GradientGaussianFilterType = + GradientRecursiveGaussianImageFilter; - typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); + typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); + typename GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); typename GradientGaussianFilterType::Pointer gradientGaussianFilter = GradientGaussianFilterType::New(); gaussianFilter->SetSigma(this->m_NoiseScale); gradientGaussianFilter->SetSigma(this->m_NoiseScale); - using OuterFilterType = UnaryFunctorImageFilter< Self::CovariantImageType, Self::TensorImageType, Self::OuterFunctor >; + using OuterFilterType = + UnaryFunctorImageFilter; typename OuterFilterType::Pointer outerFilter = OuterFilterType::New(); - if( this->m_UseGradientRecursiveGaussianImageFilter ) - { + if (this->m_UseGradientRecursiveGaussianImageFilter) + { gradientGaussianFilter->SetInput(selectionFilter->GetOutput()); outerFilter->SetInput(gradientGaussianFilter->GetOutput()); - } + } else - { + { gaussianFilter->SetInput(selectionFilter->GetOutput()); gradientFilter->SetInput(gaussianFilter->GetOutput()); outerFilter->SetInput(gradientFilter->GetOutput()); - } + } - using AddFilterType = AddImageFilter< Self::TensorImageType >; + using AddFilterType = AddImageFilter; typename AddFilterType::Pointer addFilter = AddFilterType::New(); addFilter->InPlaceOn(); addFilter->SetInput1(output); @@ -112,31 +111,30 @@ StructureTensorImageFilter< TImage, TTensorImage > addFilter->Update(); output = addFilter->GetOutput(); - this->UpdateProgress(index/float( Self::PixelType::Dimension+1 )); - } + this->UpdateProgress(index / float(Self::PixelType::Dimension + 1)); + } this->m_IntermediateResult = output; } -template< typename TImage, typename TTensorImage > +template void -StructureTensorImageFilter< TImage, TTensorImage > -::GenerateData() +StructureTensorImageFilter::GenerateData() { - this->IntermediateFilter( Dispatch< std::numeric_limits< PixelType >::is_specialized >() ); + this->IntermediateFilter(Dispatch::is_specialized>()); using GaussianFilterType = RecursiveGaussianImageFilter; typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); - gaussianFilter->SetInput( m_IntermediateResult ); - gaussianFilter->SetSigma( m_FeatureScale ); + gaussianFilter->SetInput(m_IntermediateResult); + gaussianFilter->SetSigma(m_FeatureScale); - if( !m_RescaleForUnitMaximumTrace ) - { + if (!m_RescaleForUnitMaximumTrace) + { m_PostRescaling = 1.; gaussianFilter->Update(); this->GraftOutput(gaussianFilter->GetOutput()); return; - } + } // *** Rescaling for normalization of largest trace *** @@ -154,7 +152,7 @@ StructureTensorImageFilter< TImage, TTensorImage > traceFilter->Update(); maximumCalculator->ComputeMaximum(); - m_PostRescaling = 1./maximumCalculator->GetMaximum(); + m_PostRescaling = 1. / maximumCalculator->GetMaximum(); scaleFilter->GetFunctor().scaling = m_PostRescaling; scaleFilter->Update(); this->GraftOutput(scaleFilter->GetOutput()); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 2a9358dcb22..56444262daa 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -37,17 +37,16 @@ namespace itk * * \ingroup AnisotropicDiffusionLBR */ -template -class UnaryFunctorWithIndexImageFilter: - public ImageToImageFilter +template +class UnaryFunctorWithIndexImageFilter : public ImageToImageFilter { public: ITK_DISALLOW_COPY_AND_ASSIGN(UnaryFunctorWithIndexImageFilter); using Self = UnaryFunctorWithIndexImageFilter; - using Superclass = ImageToImageFilter< TInputImage, TOutputImage >; - using Pointer = SmartPointer< Self >; - using ConstPointer = SmartPointer< const Self >; + using Superclass = ImageToImageFilter; + using Pointer = SmartPointer; + using ConstPointer = SmartPointer; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -62,36 +61,34 @@ class UnaryFunctorWithIndexImageFilter: GetSetFunctorMacro(Functor, FunctorType); protected: - UnaryFunctorWithIndexImageFilter() - { this->DynamicMultiThreadingOn(); } + UnaryFunctorWithIndexImageFilter() { this->DynamicMultiThreadingOn(); } FunctorType m_Functor; using InputRegionType = typename InputImageType::RegionType; using OutputRegionType = typename OutputImageType::RegionType; - void DynamicThreadedGenerateData(const OutputRegionType & region) override + void + DynamicThreadedGenerateData(const OutputRegionType & region) override { - if( region.GetSize()[0] == 0 ) - { + if (region.GetSize()[0] == 0) + { return; - } + } - ImageRegionConstIteratorWithIndex< InputImageType > inputIt( this->GetInput(), region); - ImageScanlineIterator< OutputImageType > outputIt( this->GetOutput(), region); + ImageRegionConstIteratorWithIndex inputIt(this->GetInput(), region); + ImageScanlineIterator outputIt(this->GetOutput(), region); - for( inputIt.GoToBegin(), outputIt.GoToBegin(); - !outputIt.IsAtEnd(); - ) + for (inputIt.GoToBegin(), outputIt.GoToBegin(); !outputIt.IsAtEnd();) + { + while (!outputIt.IsAtEndOfLine()) { - while(!outputIt.IsAtEndOfLine()) - { outputIt.Set(m_Functor(inputIt.Value(), inputIt.GetIndex())); ++inputIt; ++outputIt; - } - outputIt.NextLine(); } + outputIt.NextLine(); + } } }; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx index ec6970a6d76..170bbf50db4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx @@ -19,17 +19,18 @@ #include #include "CoherenceEnhancingDiffusionCommandLine.h" -int CoherenceEnhancingDiffusionTest( int argc, char * argv[] ) +int +CoherenceEnhancingDiffusionTest(int argc, char * argv[]) { try - { + { CoherenceEnhancingDiffusionCommandLine::Execute(argc, argv); - } - catch (itk::ExceptionObject& e) - { + } + catch (itk::ExceptionObject & e) + { std::cerr << "ITK Exception : " << e.GetDescription() << std::endl; return EXIT_FAILURE; - } + } return EXIT_SUCCESS; } From 4b5dc91a4d5aa9fe7c16f9a84119a08ce2739960 Mon Sep 17 00:00:00 2001 From: Mathew Seng Date: Mon, 17 Feb 2020 17:46:46 -0600 Subject: [PATCH 57/76] ENH: Update enums from recent enum changes in ITK --- .../CoherenceEnhancingDiffusionCommandLine.h | 15 +++++++-------- .../LinearAnisotropicDiffusionCommandLine.h | 14 +++++++------- 2 files changed, 14 insertions(+), 15 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 95561ba5ab7..035db2fd588 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -53,7 +53,7 @@ Execute(int argc, char * argv[]); template int -Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentEnum, int nComponents); template int @@ -81,8 +81,7 @@ Execute(int argc, char * argv[]) const char * imageFileName = argv[1]; - itk::ImageIOBase::Pointer imageIO = - itk::ImageIOFactory::CreateImageIO(imageFileName, itk::ImageIOFactory::FileModeType::ReadMode); + itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO(imageFileName, itk::IOFileModeEnum::ReadMode); if (imageIO.IsNull()) { std::cerr << "Could not create ImageIO" << std::endl; @@ -92,7 +91,7 @@ Execute(int argc, char * argv[]) imageIO->ReadImageInformation(); const unsigned int imageDimension = imageIO->GetNumberOfDimensions(); - const itk::ImageIOBase::IOComponentType componentType = imageIO->GetComponentType(); + const itk::ImageIOBase::IOComponentEnum componentType = imageIO->GetComponentType(); const unsigned int nComponents = imageIO->GetNumberOfComponents(); switch (imageDimension) @@ -108,15 +107,15 @@ Execute(int argc, char * argv[]) template int -Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents) +Execute(int argc, char * argv[], itk::IOComponentEnum componentType, int nComponents) { switch (componentType) { - case itk::ImageIOBase::UCHAR: + case itk::IOComponentEnum::UCHAR: return Execute(argc, argv, nComponents); - case itk::ImageIOBase::FLOAT: + case itk::IOComponentEnum::FLOAT: return Execute(argc, argv, nComponents); - case itk::ImageIOBase::DOUBLE: + case itk::IOComponentEnum::DOUBLE: return Execute(argc, argv, nComponents); default: itkGenericExceptionMacro("Sorry, unsupported component type"); diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index ff9898af16d..2c6c039a43a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -49,7 +49,7 @@ Execute(int argc, char * argv[]); template int -Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType, int nComponents); +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentEnum, int nComponents); template int @@ -101,7 +101,7 @@ Execute(int argc, char * argv[]) const ImageIOBase * io = reader->GetImageIO(); const int ImageDimension = io->GetNumberOfDimensions(); - const itk::ImageIOBase::IOComponentType componentType = io->GetComponentType(); + const itk::ImageIOBase::IOComponentEnum componentType = io->GetComponentType(); const int nComponents = io->GetNumberOfComponents(); { @@ -117,7 +117,7 @@ Execute(int argc, char * argv[]) const int TensorDimension = (ImageDimension * (ImageDimension + 1)) / 2; if (TensorDimension != (int)io2->GetNumberOfComponents()) itkGenericExceptionMacro("Error: wrong tensor dimension, should be n*(n+1)/2 where n=ImageDimension."); - if (io2->GetPixelType() == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR) + if (io2->GetPixelType() == itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR) std::cerr << "Warning: tensor image pixel type not marked as Symmetric Second Rank Tensor.\n"; } @@ -133,15 +133,15 @@ Execute(int argc, char * argv[]) template int -Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentType componentType, int nComponents) +Execute(int argc, char * argv[], itk::ImageIOBase::IOComponentEnum componentType, int nComponents) { switch (componentType) { - case itk::ImageIOBase::UCHAR: + case itk::IOComponentEnum::UCHAR: return Execute(argc, argv, nComponents); - case itk::ImageIOBase::FLOAT: + case itk::IOComponentEnum::FLOAT: return Execute(argc, argv, nComponents); - case itk::ImageIOBase::DOUBLE: + case itk::IOComponentEnum::DOUBLE: return Execute(argc, argv, nComponents); default: itkGenericExceptionMacro("Sorry, unsupported component type"); From c4d7296199fa50e0fc43c291d997555713263c68 Mon Sep 17 00:00:00 2001 From: Mathew Seng Date: Tue, 18 Feb 2020 06:39:03 -0600 Subject: [PATCH 58/76] BUG: Fixes header mismatch test fail --- .../include/LinearAnisotropicDiffusionCommandLine.h | 3 ++- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 4 +++- .../include/itkAnisotropicDiffusionLBRImageFilter.hxx | 3 ++- .../include/itkAnisotropicDiffusionLBRMacro.h | 3 ++- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 3 ++- .../include/itkCoherenceEnhancingDiffusionImageFilter.hxx | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 3 ++- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 3 ++- .../include/itkStructureTensorImageFilter.h | 3 ++- .../include/itkStructureTensorImageFilter.hxx | 3 ++- .../include/itkUnaryFunctorWithIndexImageFilter.h | 3 ++- .../test/CoherenceEnhancingDiffusionTest.cxx | 3 ++- 12 files changed, 24 insertions(+), 12 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 2c6c039a43a..4c22ba5cadd 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 01/12/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 93804b28cb7..6a06d2e8258 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.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. @@ -15,6 +15,8 @@ * limitations under the License. * *=========================================================================*/ + + // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index f5bdbb6b1d5..b44301bc505 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h index 23f2a04d46e..5e470f78834 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 07/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index 0f9be559714..eb59ff5ffe7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 06/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx index c548f49ab1e..a9aca799245 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.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/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index dd5d198e9bd..28a92b170fc 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index cf9f18718f7..34f36ae99c1 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 28/02/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index ace41ce22eb..fd652d84634 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 05/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index c1361000146..e0bbc9271c4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 21/11/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index 56444262daa..c936e2a1a03 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + // // Created by Jean-Marie Mirebeau on 07/03/2014. // diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx index 170bbf50db4..6d5f8c74263 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.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. @@ -15,6 +15,7 @@ * limitations under the License. * *=========================================================================*/ + #include #include #include "CoherenceEnhancingDiffusionCommandLine.h" From 61437e72d7c6baedbe9771548f392e54738e9c01 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Mon, 17 Feb 2020 15:50:20 -0600 Subject: [PATCH 59/76] 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’. --- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../include/itkAnisotropicDiffusionLBRImageFilter.hxx | 7 ++++--- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 4 ++-- .../itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 7 ++++--- .../include/itkStructureTensorImageFilter.h | 4 ++-- .../include/itkStructureTensorImageFilter.hxx | 3 +-- 6 files changed, 15 insertions(+), 14 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 6a06d2e8258..39171ccb18d 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -116,7 +116,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter::AnisotropicDiffusionLBRImag : m_NoiseScale(0.5) , m_FeatureScale(2) , m_RatioToMaxStableTimeStep(0.7) - , m_MaxTimeStepsBetweenTensorUpdates(5) - , m_DiffusionTime(1) - , m_Adimensionize(true) + , + + m_DiffusionTime(1) + {} diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 28a92b170fc..ce8760d3c3c 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -136,10 +136,10 @@ class LinearAnisotropicDiffusionLBRImageFilter : public ImageToImageFilter LinearAnisotropicDiffusionLBRImageFilter::LinearAnisotropicDiffusionLBRImageFilter() : m_DiffusionTime(1) , m_RatioToMaxStableTimeStep(0.7) - , m_MaxNumberOfTimeSteps(10) - , m_EffectiveDiffusionTime(0) - , m_EffectiveNumberOfTimeSteps(0) + , + + m_EffectiveDiffusionTime(0) + { this->SetNumberOfRequiredInputs(2); } diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index fd652d84634..17dd85bbc2a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -93,9 +93,9 @@ class StructureTensorImageFilter : public ImageToImageFilter StructureTensorImageFilter::StructureTensorImageFilter() : m_FeatureScale(2) , m_NoiseScale(1) - , m_RescaleForUnitMaximumTrace(false) - , m_UseGradientRecursiveGaussianImageFilter(true) + {} From 92292b32281aa63bd70f5c1f126d2383651c7258 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 19 Feb 2020 10:45:25 -0600 Subject: [PATCH 60/76] 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/CoherenceEnhancingDiffusionCommandLine.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index 035db2fd588..b9b4a92f94a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.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. From fda8f3a36c3ddcc9cc7a14b956842ae2e256040d Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Thu, 20 Feb 2020 15:24:38 -0600 Subject: [PATCH 61/76] ENH: Make similar to module template Add project version and language features. Set ITKGitTag to v5.1rc02 for azure CI A newer version of ITK is needed for CI build to succeed. Prefer https vs http for ctest submission. --- .../AnisotropicDiffusionLBR/CMakeLists.txt | 10 +++++++-- .../AnisotropicDiffusionLBR/itk-module.cmake | 21 +++++++------------ 2 files changed, 15 insertions(+), 16 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index 7db54336ac4..b264e7574f7 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,11 +1,17 @@ cmake_minimum_required(VERSION 3.10.2) -project(AnisotropicDiffusionLBR) + +project(AnisotropicDiffusionLBR + VERSION 5.1.0 #Version should track with ITK + LANGUAGES CXX) + +# Header only module, no libraries set(AnisotropicDiffusionLBR_LIBRARIES AnisotropicDiffusionLBR) if(NOT ITK_SOURCE_DIR) - find_package(ITK 4.9 REQUIRED) + find_package(ITK 5.1 REQUIRED) list(APPEND CMAKE_MODULE_PATH ${ITK_CMAKE_DIR}) include(ITKModuleExternal) else() + set(ITK_DIR ${CMAKE_BINARY_DIR}) itk_module_impl() endif() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake index 39369cb6bb4..7ffa0c45513 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake +++ b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake @@ -1,17 +1,9 @@ -set(DOCUMENTATION "This module implements Anisotropic Diffusion, using Lattice Basis Reduction. - -Documentation can be found in the Insight Journal article, 'Anisotropic -Diffusion in ITK', by Mirebeau J., Fehrenbach J., Risser L., Tobji S. - -http://insight-journal.org/browse/publication/953 -http://hdl.handle.net/10380/3505 -") - -# itk_module() defines the module dependencies in ITKAnisotropicFastMarchingLBR; -# ITKAnisotropicFastMarchingLBR depends on ITKCommon; -# The testing module in ITKExternalTemplate depends on ITKTestKernel, -# and ITKMetaIO for image IO (besides ITKAnisotropicDiffusionLBR itself) +# the top-level README is used for describing this module, just +# re-used it for documentation here +get_filename_component(MY_CURRENT_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +file(READ "${MY_CURRENT_DIR}/README.rst" DOCUMENTATION) +# define the dependencies of the include module and the tests itk_module(AnisotropicDiffusionLBR DEPENDS ITKCommon @@ -21,7 +13,8 @@ itk_module(AnisotropicDiffusionLBR ITKImageGradient TEST_DEPENDS ITKTestKernel - EXCLUDE_FROM_DEFAULT DESCRIPTION "${DOCUMENTATION}" + EXCLUDE_FROM_DEFAULT + # Header only library, no ENABLE_SHARED ) From 2a8cc2877671ad8576366433fef7827c8abb44e1 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Sat, 26 Dec 2020 17:32:58 -0600 Subject: [PATCH 62/76] COMP: Update to new ITK_DISALLOW_COPY_AND_MOVE macro Replace the deprecated ITK_DISALLOW_COPY_AND_ASSIGN with new better descriptive name ITK_DISALLOW_COPY_AND_MOVE. --- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 2 +- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 2 +- .../include/itkStructureTensorImageFilter.h | 2 +- .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 39171ccb18d..28f985498d3 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -48,7 +48,7 @@ template { public: - ITK_DISALLOW_COPY_AND_ASSIGN(AnisotropicDiffusionLBRImageFilter); + ITK_DISALLOW_COPY_AND_MOVE(AnisotropicDiffusionLBRImageFilter); using Self = AnisotropicDiffusionLBRImageFilter; using Superclass = ImageToImageFilter; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index eb59ff5ffe7..0dfe67e0f6b 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h @@ -65,7 +65,7 @@ template { public: - ITK_DISALLOW_COPY_AND_ASSIGN(CoherenceEnhancingDiffusionImageFilter); + ITK_DISALLOW_COPY_AND_MOVE(CoherenceEnhancingDiffusionImageFilter); using Self = CoherenceEnhancingDiffusionImageFilter; using Superclass = AnisotropicDiffusionLBRImageFilter; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index ce8760d3c3c..57af8f6cd82 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h @@ -48,7 +48,7 @@ template { public: - ITK_DISALLOW_COPY_AND_ASSIGN(LinearAnisotropicDiffusionLBRImageFilter); + ITK_DISALLOW_COPY_AND_MOVE(LinearAnisotropicDiffusionLBRImageFilter); /** Standard class type alias. */ using Self = LinearAnisotropicDiffusionLBRImageFilter; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 17dd85bbc2a..b4621c006da 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -53,7 +53,7 @@ template { public: - ITK_DISALLOW_COPY_AND_ASSIGN(StructureTensorImageFilter); + ITK_DISALLOW_COPY_AND_MOVE(StructureTensorImageFilter); using Self = StructureTensorImageFilter; using Superclass = ImageToImageFilter; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index c936e2a1a03..c490778d5cb 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h @@ -42,7 +42,7 @@ template class UnaryFunctorWithIndexImageFilter : public ImageToImageFilter { public: - ITK_DISALLOW_COPY_AND_ASSIGN(UnaryFunctorWithIndexImageFilter); + ITK_DISALLOW_COPY_AND_MOVE(UnaryFunctorWithIndexImageFilter); using Self = UnaryFunctorWithIndexImageFilter; using Superclass = ImageToImageFilter; From 581544476fef9e61474036e71f34de820b03ca57 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Mon, 15 Mar 2021 21:07:03 -0400 Subject: [PATCH 63/76] COMP: Constrain wrapping to 2D, 3D images MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 4D images, enabled in the ITK 5.2 wrapping, are not currently supported. To address: In file included from ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.h:172, from ../../../include/itkAnisotropicDiffusionLBRImageFilter.h:28, from ../../../include/itkCoherenceEnhancingDiffusionImageFilter.h:27, from ../../../ITK-cp36-cp36m-manylinux2014_x64/Wrapping/Typedefs/itkCoherenceEnhancingDiffusionImageFilterSwigInterface.h:18, from Wrapping/Modules/AnisotropicDiffusionLBR/itkCoherenceEnhancingDiffusionImageFilterPython.cpp:3533: ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx: In instantiation of ‘itk::LinearAnisotropicDiffusionLBRImageFilter::StencilType itk::LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor::operator()(const TensorType&, const IndexType&) const [with TImage = itk::Image; TScalar = double; itk::LinearAnisotropicDiffusionLBRImageFilter::StencilType = std::pair, itk::Vector >; itk::LinearAnisotropicDiffusionLBRImageFilter::TensorType = itk::SymmetricSecondRankTensor; itk::LinearAnisotropicDiffusionLBRImageFilter::IndexType = itk::Index<4>]’: ../../../include/itkUnaryFunctorWithIndexImageFilter.h:87:9: required from ‘void itk::UnaryFunctorWithIndexImageFilter::DynamicThreadedGenerateData(const OutputRegionType&) [with TInputImage = itk::Image, 4>; TOutputImage = itk::Image, itk::Vector >, 4>; TFunctor = itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor; itk::UnaryFunctorWithIndexImageFilter::OutputRegionType = itk::ImageRegion<4>]’ ../../../include/itkUnaryFunctorWithIndexImageFilter.h:73:3: required from here ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx:138:5: error: no matching function for call to ‘itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor::Stencil(itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor::Dispatch<4>, itk::LinearAnisotropicDiffusionLBRImageFilter, double>::TensorType&, itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilOffsetsType&, itk::Vector&) const’ 138 | this->Stencil(Dispatch(), D, offsets, stencil.second); | ^~~~ ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx:170:3: note: candidate: ‘static void itk::LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor::Stencil(const itk::LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor::Dispatch<2>&, const TensorType&, itk::LinearAnisotropicDiffusionLBRImageFilter::StencilOffsetsType&, itk::LinearAnisotropicDiffusionLBRImageFilter::StencilCoefficientsType&) [with TImage = itk::Image; TScalar = double; itk::LinearAnisotropicDiffusionLBRImageFilter::TensorType = itk::SymmetricSecondRankTensor; itk::LinearAnisotropicDiffusionLBRImageFilter::StencilOffsetsType = itk::Vector, 6>; itk::LinearAnisotropicDiffusionLBRImageFilter::StencilCoefficientsType = itk::Vector]’ 170 | Stencil(const Dispatch<2> &, | ^~~~~~~ ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx:170:11: note: no known conversion for argument 1 from ‘itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor::Dispatch<4>’ to ‘const itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor::Dispatch<2>&’ 170 | Stencil(const Dispatch<2> &, | ^~~~~~~~~~~~~~~~~~~ ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx:225:3: note: candidate: ‘static void itk::LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor::Stencil(const itk::LinearAnisotropicDiffusionLBRImageFilter::StencilFunctor::Dispatch<3>&, const TensorType&, itk::LinearAnisotropicDiffusionLBRImageFilter::StencilOffsetsType&, itk::LinearAnisotropicDiffusionLBRImageFilter::StencilCoefficientsType&) [with TImage = itk::Image; TScalar = double; itk::LinearAnisotropicDiffusionLBRImageFilter::TensorType = itk::SymmetricSecondRankTensor; itk::LinearAnisotropicDiffusionLBRImageFilter::StencilOffsetsType = itk::Vector, 6>; itk::LinearAnisotropicDiffusionLBRImageFilter::StencilCoefficientsType = itk::Vector]’ 225 | Stencil(const Dispatch<3> &, | ^~~~~~~ ../../../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx:225:11: note: no known conversion for argument 1 from ‘itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor::Dispatch<4>’ to ‘const itk::LinearAnisotropicDiffusionLBRImageFilter, double>::StencilFunctor::Dispatch<3>&’ 225 | Stencil(const Dispatch<3> &, | ^~~~~~~~~~~~~~~~~~~ --- .../wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap | 2 +- .../wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap index 475a7ab755f..a1c612cfc4f 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkAnisotropicDiffusionLBRImageFilter.wrap @@ -1,3 +1,3 @@ itk_wrap_class("itk::AnisotropicDiffusionLBRImageFilter" POINTER) - itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1) + itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1 "2;3") itk_end_wrap_class() diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap index 98432a7183e..1172fffc7ab 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap @@ -1,3 +1,3 @@ itk_wrap_class("itk::CoherenceEnhancingDiffusionImageFilter" POINTER) - itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1) + itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1 "2;3") itk_end_wrap_class() From 03b0c9850988de8b1366c77382721637d4064866 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Fri, 17 Dec 2021 09:25:10 -0600 Subject: [PATCH 64/76] 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/itkAnisotropicDiffusionLBRImageFilter.hxx | 1 - .../include/itkCoherenceEnhancingDiffusionImageFilter.hxx | 1 - .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 1 - .../include/itkStructureTensorImageFilter.hxx | 1 - 4 files changed, 4 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index 27646fb14e4..19064cc8ecf 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -24,7 +24,6 @@ #ifndef itkAnisotropicDiffusionLBRImageFilter_hxx #define itkAnisotropicDiffusionLBRImageFilter_hxx -#include "itkAnisotropicDiffusionLBRImageFilter.h" namespace itk { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx index a9aca799245..ef920535dd8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx @@ -19,7 +19,6 @@ #ifndef itkCoherenceEnhancingDiffusionImageFilter_hxx #define itkCoherenceEnhancingDiffusionImageFilter_hxx -#include "itkCoherenceEnhancingDiffusionImageFilter.h" namespace itk { diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 762f92937f1..ef05931a580 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -29,7 +29,6 @@ #include "itkMinimumMaximumImageCalculator.h" #include "itkCastImageFilter.h" #include "itkExtractImageFilter.h" -#include "itkLinearAnisotropicDiffusionLBRImageFilter.h" #include "itkUnaryFunctorWithIndexImageFilter.h" #include "itkTernaryFunctorImageFilter.h" diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 5a433dbb200..11dc83838c5 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx @@ -24,7 +24,6 @@ #ifndef itkStructureTensorImageFilter_hxx #define itkStructureTensorImageFilter_hxx -#include "itkStructureTensorImageFilter.h" #include "itkMinimumMaximumImageCalculator.h" namespace itk From c4b43af2642e65df411f0d841dbbde35618a2fd6 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 9 Mar 2022 10:47:34 -0600 Subject: [PATCH 65/76] COMP: Avoid single value vector constructor Implicit conversion of a single scalar value to a container (which would _fill_ the container by the scalar value) is discouraged. With ITK 5.3, when having `ITK_LEGACY_REMOVE=ON`, the constructors of `Point`, `RGBPixel`, `RGBAPixel`, and `Vector` that accept a single scalar value as argument are declared `explicit`. ITK 5.3 has included a preferable alternative to these constructors: `itk::MakeFilled(value)`. --- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index ef05931a580..dd91800e340 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -477,7 +477,7 @@ LinearAnisotropicDiffusionLBRImageFilter::ImageUpdate(ScalarTyp ImageRegionConstIterator stencilIt(m_StencilImage, region); // Rest of function is a hand-made (sparse matrix)*vector product. - m_NextImage->FillBuffer(0.); + m_NextImage->FillBuffer({}); // Taking care of Off-Diagonal matrix elements. Cannot be parallelized due to non-local modifications of outputBuffer for (inputIt.GoToBegin(), outputIt.GoToBegin(), stencilIt.GoToBegin(); !inputIt.IsAtEnd(); From 6f9a6c2b4d0dd2fd454d95b4954130de1d5b9db8 Mon Sep 17 00:00:00 2001 From: Tom Birdsong Date: Tue, 31 May 2022 11:23:26 -0400 Subject: [PATCH 66/76] ENH: Bump ITK and replace http with https using script --- .../include/CoherenceEnhancingDiffusionCommandLine.h | 2 +- .../include/LinearAnisotropicDiffusionCommandLine.h | 2 +- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 2 +- .../include/itkAnisotropicDiffusionLBRImageFilter.hxx | 2 +- .../include/itkAnisotropicDiffusionLBRMacro.h | 2 +- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 2 +- .../include/itkCoherenceEnhancingDiffusionImageFilter.hxx | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 2 +- .../include/itkStructureTensorImageFilter.h | 2 +- .../include/itkStructureTensorImageFilter.hxx | 2 +- .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 +- .../test/CoherenceEnhancingDiffusionTest.cxx | 2 +- 13 files changed, 13 insertions(+), 13 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index b9b4a92f94a..a570cba12aa 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.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/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index 4c22ba5cadd..e3ff2a0c4a3 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.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/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 28f985498d3..0e25df0d589 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.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/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index 19064cc8ecf..be95e556bb1 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.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/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h index 5e470f78834..6917ec9c669 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.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/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h index 0dfe67e0f6b..e328b235f15 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.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/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx index ef920535dd8..1e00bb70bd1 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkCoherenceEnhancingDiffusionImageFilter.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/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h index 57af8f6cd82..40982345ab8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.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/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index dd91800e340..576debf2f2a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.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/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index b4621c006da..6a18980f94f 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.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/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx index 11dc83838c5..82e8d640edb 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.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/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h index c490778d5cb..21938012ae4 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkUnaryFunctorWithIndexImageFilter.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/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx index 6d5f8c74263..d2465caacf8 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.cxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CoherenceEnhancingDiffusionTest.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 a740b7ec721c44a2debd83c1198aef44c0dba870 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Sun, 16 Mar 2025 13:04:04 -0500 Subject: [PATCH 67/76] ENH: Update minimum cmake version to 3.16.3 Match version for ITK v5.4.2 --- Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index b264e7574f7..1d14e9e68ce 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.10.2) +cmake_minimum_required(VERSION 3.16.3) project(AnisotropicDiffusionLBR VERSION 5.1.0 #Version should track with ITK From a0696cda55298cf8eb53efe9d7fb1d16fe57bdaa Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Sat, 25 Jan 2025 10:05:18 -0600 Subject: [PATCH 68/76] COMP: Use modern macro for name of class MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When preparing for the future with ITK by setting ITK_FUTURE_LEGACY_REMOVE:BOOL=ON ITK_LEGACY_REMOVEBOOL=ON The future preferred macro should be used │ - itkTypeMacro │ + itkOverrideGetNameOfClassMacro --- .../include/itkAnisotropicDiffusionLBRImageFilter.h | 2 +- .../include/itkCoherenceEnhancingDiffusionImageFilter.h | 2 +- .../include/itkLinearAnisotropicDiffusionLBRImageFilter.h | 2 +- .../include/itkStructureTensorImageFilter.h | 2 +- .../include/itkUnaryFunctorWithIndexImageFilter.h | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h index 0e25df0d589..8c9030f1de6 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.h @@ -58,7 +58,7 @@ class AnisotropicDiffusionLBRImageFilter : public ImageToImageFilter Date: Sat, 25 Jan 2025 14:08:18 -0600 Subject: [PATCH 69/76] STYLE: Update to match clang-format-19 from ITK --- .../itkAnisotropicDiffusionLBRImageFilter.hxx | 2 +- .../include/itkAnisotropicDiffusionLBRMacro.h | 14 +++++++------- ...itkLinearAnisotropicDiffusionLBRImageFilter.hxx | 8 ++++---- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx index be95e556bb1..dfa544ff390 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRImageFilter.hxx @@ -141,7 +141,7 @@ struct AnisotropicDiffusionLBRImageFilter::DiffusionTensorFunct } const EigenValuesArrayType & e; OrderingType(const EigenValuesArrayType & e_) - : e(e_){}; + : e(e_) {}; }; template diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h index 6917ec9c669..b9cf06c274a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkAnisotropicDiffusionLBRMacro.h @@ -28,13 +28,13 @@ Getters and setters for functor types, inspired by UnaryFunctorImageFilter. No equality test performed for the setter. */ -#define GetSetFunctorMacro(name, type) \ - virtual type & Get##name() { return this->m_##name; } \ - virtual const type & Get##name() const { return this->m_##name; } \ - virtual void Set##name(const type & _arg) \ - { \ - m_##name = _arg; \ - this->Modified(); \ +#define GetSetFunctorMacro(name, type) \ + virtual type & Get##name() { return this->m_##name; } \ + virtual const type & Get##name() const { return this->m_##name; } \ + virtual void Set##name(const type & _arg) \ + { \ + m_##name = _arg; \ + this->Modified(); \ } #endif diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 576debf2f2a..04a523a8c73 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -153,8 +153,8 @@ public: // Neumann boundary conditions. *yIndex = this->OutsideBufferIndex(); } // if y - } // for eps - } // for i + } // for eps + } // for i return stencil; } @@ -352,8 +352,8 @@ LinearAnisotropicDiffusionLBRImageFilter::GenerateStencils() diagIt.Value() += coefficient; diagBuffer[yIndex] += coefficient; } // if y - } // for i - } // for stencilIt, diagIt + } // for i + } // for stencilIt, diagIt } From 4c0df82b24948b7f9dac52ebce4763dcde5ea5ef Mon Sep 17 00:00:00 2001 From: Matthew McCormick Date: Tue, 18 Mar 2025 11:46:12 -0400 Subject: [PATCH 70/76] BUG: Ensure itkAnisotropicDiffusionLBRImageFilter wrapped first For: itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< short >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< short, 3 >, double > --- .../AnisotropicDiffusionLBR/wrapping/CMakeLists.txt | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt index 0db043cd281..cb5aa8e3202 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt @@ -1,3 +1,5 @@ itk_wrap_module(AnisotropicDiffusionLBR) -itk_auto_load_submodules() -itk_end_wrap_module() +set(WRAPPING_SUBMODULE_ORDER + itkAnisotropicDiffusionLBRImageFilter + ) +itk_auto_load_and_end_wrap_submodules() From 21b84263b134c1e67b0a475f6d6ef7fe8ebe3ffc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C5=BEenan=20Zuki=C4=87?= Date: Mon, 24 Mar 2025 09:16:02 -0400 Subject: [PATCH 71/76] COMP: Fix warnings: ITK type not wrapped, or currently not known This commit fixes the following warnings: itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< short >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< short, 3 >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< unsigned char >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< unsigned char, 3 >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< unsigned short >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< unsigned short, 3 >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< float >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< float, 3 >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< double >, double > itkCoherenceEnhancingDiffusionImageFilter: warning(4): ITK type not wrapped, or currently not known: itk::AnisotropicDiffusionLBRImageFilter< itk::Image< double, 3 >, double > --- .../wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap index 1172fffc7ab..e02e4cfd944 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/itkCoherenceEnhancingDiffusionImageFilter.wrap @@ -1,3 +1,3 @@ -itk_wrap_class("itk::CoherenceEnhancingDiffusionImageFilter" POINTER) +itk_wrap_class("itk::CoherenceEnhancingDiffusionImageFilter" POINTER_WITH_SUPERCLASS) itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 1 "2;3") itk_end_wrap_class() From 05609066dabbb6de88ec7b0ad03bb4dda66529cc Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 22 Apr 2026 16:44:23 +0000 Subject: [PATCH 72/76] DOC: Add README.md pointing at archived upstream for AnisotropicDiffusionLBR Provides in-tree pointer to the upstream ITKAnisotropicDiffusionLBR repo and documents what was deliberately left outside the whitelist (Old/, examples/, test/azure-pipelines.yml, test/Docker/, README.rst, packaging scaffolding) and why. --- .../AnisotropicDiffusionLBR/README.md | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 Modules/Filtering/AnisotropicDiffusionLBR/README.md diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/README.md b/Modules/Filtering/AnisotropicDiffusionLBR/README.md new file mode 100644 index 00000000000..d0710dbd3df --- /dev/null +++ b/Modules/Filtering/AnisotropicDiffusionLBR/README.md @@ -0,0 +1,60 @@ +# AnisotropicDiffusionLBR + +In-tree ITK module providing coherence-enhancing (CED) and +edge-enhancing (EED) anisotropic diffusion filters built on the +Lattice-Basis-Reduction (LBR) stencil scheme by Jean-Marie Mirebeau. + +## Origin + +Ingested from the standalone remote module +[**InsightSoftwareConsortium/ITKAnisotropicDiffusionLBR**](https://github.com/InsightSoftwareConsortium/ITKAnisotropicDiffusionLBR) +on 2026-04-22, at upstream commit +[`203260b9`](https://github.com/InsightSoftwareConsortium/ITKAnisotropicDiffusionLBR/commit/203260b929acda68a1f64b1267b0d89e825904ec). +The upstream repository will be archived read-only after this PR +merges; it remains reachable at the URL above. + +## What lives here + +Per the v3 ingestion strategy (see +`Utilities/Maintenance/RemoteModuleIngest/INGESTION_STRATEGY.md`), only +paths matching the narrow whitelist (code, headers, tests, wrapping, +module CMake) crossed the merge boundary: + +- `include/` — public C++ headers. +- `test/` — Google-test / CTest drivers and content-link stubs. +- `wrapping/` — Python wrapping descriptors. +- `CMakeLists.txt`, `itk-module.cmake` — build + module descriptors. + +Every surviving commit preserves original authorship; `git blame` +walks across the merge boundary to upstream authors from 2014. + +## What was intentionally left upstream + +Everything outside the whitelist stays in the archived upstream repo. +If you need any of it, clone +. + +| Content in upstream | Why it did not ingest | +|---|---| +| `Old/` | Pre-refactor legacy trees; no current test depends on them. | +| `examples/` + `examples/Data/` | Per-module `examples/` are routed to top-level [`Examples/`](https://github.com/InsightSoftwareConsortium/ITK/tree/main/Examples) via a separate follow-up PR. | +| `README.rst` | Algorithm citations + background are folded into the Doxygen on the filter headers. | +| `test/azure-pipelines.yml`, `test/Docker/` | Standalone-build CI scaffolding; not useful in-tree. | +| `CTestConfig.cmake`, `pyproject.toml`, `.github/`, `.clang-format`, `LICENSE` | Packaging / CI / style scaffolding superseded by ITK root. | + +## Long-form documentation + +- **Algorithm description** — see the Doxygen on + `itkAnisotropicDiffusionLBRImageFilter` and + `itkCoherenceEnhancingDiffusionImageFilter`, plus embedded citations + (Mirebeau et al.). +- **Standalone build + usage examples** — see the archived upstream at + . + +## Content-link status + +The 24 baseline and input content-links under `test/Baseline/` and +`test/Input/` are currently `.md5` stubs. Per the v3 strategy they +should be normalized to `.cid` (IPFS Content Identifier) before this +PR merges; see +`Utilities/Maintenance/RemoteModuleIngest/cid-normalize.sh`. From 55453da3740205327443f93385ba539398894fb9 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 22 Apr 2026 16:45:08 +0000 Subject: [PATCH 73/76] COMP: Fix upstream bugs in ingested AnisotropicDiffusionLBR MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two defects noticed during the ingest review; both are pre-existing in the upstream tip. Fixing them here keeps subsequent commits in this series able to configure + build + test. * itk-module.cmake called file(READ README.rst) at configure time, but README.rst was stripped by the v3 whitelist (not an ITK module-tree file). Replace with an inline set(DOCUMENTATION ...) per ITK in-tree convention; drop the redundant ITKIOSpatialObjects and ITKMetaIO entries from DEPENDS (greptile P2 — no in-source references). * itkStructureTensorImageFilter used using Superclass = ImageToImageFilter; but the class inherits from ImageToImageFilter. TTensorImage defaults to Image,...>, not TImage, so the alias is wrong. Any downstream code resolving Superclass::OutputImageType would get the wrong type. Fixed (greptile P1). --- .../AnisotropicDiffusionLBR/CMakeLists.txt | 6 ++++- .../CoherenceEnhancingDiffusionCommandLine.h | 4 ++-- .../LinearAnisotropicDiffusionCommandLine.h | 4 ++-- ...nearAnisotropicDiffusionLBRImageFilter.hxx | 2 +- .../include/itkStructureTensorImageFilter.h | 2 +- .../AnisotropicDiffusionLBR/itk-module.cmake | 23 +++++++++++-------- 6 files changed, 24 insertions(+), 17 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index 1d14e9e68ce..91e8e93091b 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -15,4 +15,8 @@ else() itk_module_impl() endif() -itk_module_examples() +# itk_module_examples() is intentionally omitted: the upstream +# examples/ directory is not part of the whitelist-based ingest +# (see Modules/Filtering/AnisotropicDiffusionLBR/README.md), so +# expanding this call under BUILD_EXAMPLES=ON would fail at CMake +# configure time looking for a non-existent subdirectory. diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h index a570cba12aa..0f44efdb2ff 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/CoherenceEnhancingDiffusionCommandLine.h @@ -33,7 +33,7 @@ namespace CoherenceEnhancingDiffusionCommandLine { -void +inline void Usage() { std::cerr << "Input image filename. 2D and 3D images supported. Required.\n" @@ -66,7 +66,7 @@ Execute(int argc, char * argv[]); using ReportProgressToCOutType = LinearAnisotropicDiffusionCommandLine::ReportProgressToCOutType; -int +inline int Execute(int argc, char * argv[]) { using std::cerr; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h index e3ff2a0c4a3..5cfed7d8b6a 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/LinearAnisotropicDiffusionCommandLine.h @@ -31,7 +31,7 @@ namespace LinearAnisotropicDiffusionCommandLine { -void +inline void Usage() { std::cerr << "Input image filename. 2D and 3D images supported. Required.\n" @@ -80,7 +80,7 @@ struct ReportProgressToCOutType : public itk::Command }; -int +inline int Execute(int argc, char * argv[]) { using std::cerr; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx index 04a523a8c73..e6027776aef 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkLinearAnisotropicDiffusionLBRImageFilter.hxx @@ -158,7 +158,7 @@ public: return stencil; } -protected: +private: struct DispatchBase {}; template diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h index 6b0ec1e0e4d..103a574eac9 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h +++ b/Modules/Filtering/AnisotropicDiffusionLBR/include/itkStructureTensorImageFilter.h @@ -56,7 +56,7 @@ class StructureTensorImageFilter : public ImageToImageFilter; + using Superclass = ImageToImageFilter; using Pointer = SmartPointer; using ConstPointer = SmartPointer; diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake index 7ffa0c45513..b8f62526703 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake +++ b/Modules/Filtering/AnisotropicDiffusionLBR/itk-module.cmake @@ -1,20 +1,23 @@ -# the top-level README is used for describing this module, just -# re-used it for documentation here -get_filename_component(MY_CURRENT_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) -file(READ "${MY_CURRENT_DIR}/README.rst" DOCUMENTATION) +set( + DOCUMENTATION + "This module provides coherence-enhancing (CED) and edge-enhancing +(EED) anisotropic diffusion filters built on the +Lattice-Basis-Reduction (LBR) stencil scheme by Jean-Marie Mirebeau. +See the Doxygen on \\\\ref AnisotropicDiffusionLBRImageFilter and +\\\\ref CoherenceEnhancingDiffusionImageFilter for the algorithm and +citations, and the module README for in-tree vs archived-upstream +scope." +) -# define the dependencies of the include module and the tests -itk_module(AnisotropicDiffusionLBR +itk_module( + AnisotropicDiffusionLBR DEPENDS ITKCommon ITKIOImageBase - ITKIOSpatialObjects - ITKMetaIO ITKImageGradient TEST_DEPENDS ITKTestKernel - DESCRIPTION - "${DOCUMENTATION}" + DESCRIPTION "${DOCUMENTATION}" EXCLUDE_FROM_DEFAULT # Header only library, no ENABLE_SHARED ) From 7c223216d382db1f39799a88e8992ad72e425231 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 22 Apr 2026 16:45:21 +0000 Subject: [PATCH 74/76] COMP: Remove AnisotropicDiffusionLBR.remote.cmake; now in-tree --- .../AnisotropicDiffusionLBR.remote.cmake | 68 ------------------- 1 file changed, 68 deletions(-) delete mode 100644 Modules/Remote/AnisotropicDiffusionLBR.remote.cmake diff --git a/Modules/Remote/AnisotropicDiffusionLBR.remote.cmake b/Modules/Remote/AnisotropicDiffusionLBR.remote.cmake deleted file mode 100644 index a019883e2ba..00000000000 --- a/Modules/Remote/AnisotropicDiffusionLBR.remote.cmake +++ /dev/null @@ -1,68 +0,0 @@ -#-- # Grading Level Criteria Report -#-- EVALUATION DATE: 2020-03-01 -#-- EVALUATORS: [<>,<>] -#-- -#-- ## 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 - -itk_fetch_module( - AnisotropicDiffusionLBR - "Anisotropic Non-Linear Diffusion is a powerful image processing technique, - which allows to simultaneously remove the noise and enhance sharp features - in two or three dimensional images. Anisotropic Diffusion is understood here - in the sense of Weickert, meaning that diffusion tensors are anisotropic and - reflect the local orientation of image features. This is in contrast with - the non-linear diffusion filter of Perona and Malik, which only involves - scalar diffusion coefficients, in other words isotropic diffusion tensors. - - In this module, an anisotropic non-linear diffusion technique based on a recent - adaptive scheme making the diffusion stable and requiring limited numerical resources - is available. - - From the Insight Journal Article: - - \"Anisotropic Diffusion in ITK\" - Mirebeau J., Fehrenbach J., Risser L., Tobji S. - The Insight Journal. 2014 January-December. - ttps://doi.org/10.54294/en3833 - " - MODULE_COMPLIANCE_LEVEL 2 - GIT_REPOSITORY https://github.com/InsightSoftwareConsortium/ITKAnisotropicDiffusionLBR.git - GIT_TAG 753f2498af4dbd4a864fe6378da72e92654b7f80 - ) From 9ab5f3fb6830af478a572bd327de253ff39b92e8 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 22 Apr 2026 16:45:22 +0000 Subject: [PATCH 75/76] ENH: Enable AnisotropicDiffusionLBR in CI via configure-ci Per @dzenanz nitpick on PR #6093: keep -DITK_COMPUTER_MEMORY_SIZE (the line carrying the closing ''') at the end of the cmd variable so that future -DModule_X:BOOL=ON additions are +1-line diffs without moving the closing-quote position. --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 5333ba058f1..26dc2343519 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,6 +52,7 @@ cmd = '''cmake -DITK_USE_CCACHE:BOOL=ON -DCMAKE_C_COMPILER_LAUNCHER:STRING=ccache -DCMAKE_CXX_COMPILER_LAUNCHER:STRING=ccache + -DModule_AnisotropicDiffusionLBR:BOOL=ON -DITK_COMPUTER_MEMORY_SIZE:STRING=11 -DModule_StructuralSimilarity:BOOL=ON''' description = "Configure ITK for CI (with ccache compiler launcher)" From 0fe0ab3a37a863e5ce4ab667eac3626f2bf444a2 Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Wed, 22 Apr 2026 16:51:12 +0000 Subject: [PATCH 76/76] STYLE: Apply ITK gersemi formatting to ingested AnisotropicDiffusionLBR Upstream ITKAnisotropicDiffusionLBR's CMakeLists.txt files predate the ITK gersemi pre-commit hook. Reformat the three ingested files to satisfy .gersemi.config (0.19.3): collapse single-arg set(), expand itk_add_test() arg lists, lowercase command names. No functional change. --- .../AnisotropicDiffusionLBR/CMakeLists.txt | 10 +- .../test/CMakeLists.txt | 297 ++++++++++++++---- .../wrapping/CMakeLists.txt | 4 +- 3 files changed, 248 insertions(+), 63 deletions(-) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt index 91e8e93091b..b746377e0ab 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/CMakeLists.txt @@ -1,8 +1,12 @@ cmake_minimum_required(VERSION 3.16.3) -project(AnisotropicDiffusionLBR - VERSION 5.1.0 #Version should track with ITK - LANGUAGES CXX) +project( + AnisotropicDiffusionLBR + VERSION + 5.1.0 #Version should track with ITK + LANGUAGES + CXX +) # Header only module, no libraries set(AnisotropicDiffusionLBR_LIBRARIES AnisotropicDiffusionLBR) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt index bb16d5d7f8b..12b772071f5 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/test/CMakeLists.txt @@ -1,92 +1,275 @@ itk_module_test() -set(AnisotropicDiffusionLBRTests - CoherenceEnhancingDiffusionTest.cxx - ) +set(AnisotropicDiffusionLBRTests CoherenceEnhancingDiffusionTest.cxx) -CreateTestDriver(AnisotropicDiffusionLBR "${AnisotropicDiffusionLBR-Test_LIBRARIES}" "${AnisotropicDiffusionLBRTests}") +createtestdriver(AnisotropicDiffusionLBR "${AnisotropicDiffusionLBR-Test_LIBRARIES}" "${AnisotropicDiffusionLBRTests}") set(TestOutput ${ITK_TEST_OUTPUT_DIR}) ################ fig:PacMan ################# -itk_add_test(NAME PacMan_cEED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/PacMan_cEED.png} ${TestOutput}/PacMan_cEED.png - CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cEED.png 20 0.05 cEED 3) +itk_add_test( + NAME PacMan_cEED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/PacMan_cEED.png} + ${TestOutput}/PacMan_cEED.png + CoherenceEnhancingDiffusionTest + DATA{Input/PacMan.png} + ${TestOutput}/PacMan_cEED.png + 20 + 0.05 + cEED + 3 +) -itk_add_test(NAME PacMan_cCED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/PacMan_cCED.png} ${TestOutput}/PacMan_cCED.png - CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_cCED.png 20 0.05 cCED 3) +itk_add_test( + NAME PacMan_cCED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/PacMan_cCED.png} + ${TestOutput}/PacMan_cCED.png + CoherenceEnhancingDiffusionTest + DATA{Input/PacMan.png} + ${TestOutput}/PacMan_cCED.png + 20 + 0.05 + cCED + 3 +) -itk_add_test(NAME PacMan_I COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/PacMan_I.png} ${TestOutput}/PacMan_I.png - CoherenceEnhancingDiffusionTest DATA{Input/PacMan.png} ${TestOutput}/PacMan_I.png 20 0.05 Isotropic 3) +itk_add_test( + NAME PacMan_I + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/PacMan_I.png} + ${TestOutput}/PacMan_I.png + CoherenceEnhancingDiffusionTest + DATA{Input/PacMan.png} + ${TestOutput}/PacMan_I.png + 20 + 0.05 + Isotropic + 3 +) ############# fig : Fingerprint ############# -itk_add_test(NAME FingerPrint_cEED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/FingerPrint_cEED_20.png} ${TestOutput}/FingerPrint_cEED_20.png - CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cEED_20.png 20 0.02 cEED ) +itk_add_test( + NAME FingerPrint_cEED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/FingerPrint_cEED_20.png} + ${TestOutput}/FingerPrint_cEED_20.png + CoherenceEnhancingDiffusionTest + DATA{Input/FingerPrint.png} + ${TestOutput}/FingerPrint_cEED_20.png + 20 + 0.02 + cEED +) -itk_add_test(NAME FingerPrint_cCED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/FingerPrint_cCED_20.png} ${TestOutput}/FingerPrint_cCED_20.png - CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_cCED_20.png 20 0.02 cCED ) - -itk_add_test(NAME FingerPrint_I COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/FingerPrint_I_20.png} ${TestOutput}/FingerPrint_I_20.png - CoherenceEnhancingDiffusionTest DATA{Input/FingerPrint.png} ${TestOutput}/FingerPrint_I_20.png 20 0.02 Isotropic ) +itk_add_test( + NAME FingerPrint_cCED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/FingerPrint_cCED_20.png} + ${TestOutput}/FingerPrint_cCED_20.png + CoherenceEnhancingDiffusionTest + DATA{Input/FingerPrint.png} + ${TestOutput}/FingerPrint_cCED_20.png + 20 + 0.02 + cCED +) +itk_add_test( + NAME FingerPrint_I + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/FingerPrint_I_20.png} + ${TestOutput}/FingerPrint_I_20.png + CoherenceEnhancingDiffusionTest + DATA{Input/FingerPrint.png} + ${TestOutput}/FingerPrint_I_20.png + 20 + 0.02 + Isotropic +) ################ fig : Cos3D ################ -itk_add_test(NAME Cos3D_cCED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Cos3D_cCED.vtk} ${TestOutput}/Cos3D_cCED.vtk - CoherenceEnhancingDiffusionTest DATA{Input/Cos3D_Noisy.vtk} ${TestOutput}/Cos3D_cCED.vtk 10 0.02 cCED 4 10 ) - +itk_add_test( + NAME Cos3D_cCED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Cos3D_cCED.vtk} + ${TestOutput}/Cos3D_cCED.vtk + CoherenceEnhancingDiffusionTest + DATA{Input/Cos3D_Noisy.vtk} + ${TestOutput}/Cos3D_cCED.vtk + 10 + 0.02 + cCED + 4 + 10 +) ################ fig : Brain ################ -itk_add_test(NAME mrbrain_cEED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/mrbrain_cEED.vtk} ${TestOutput}/mrbrain_cEED.vtk - CoherenceEnhancingDiffusionTest DATA{Input/mrbrain_noisy.vtk} ${TestOutput}/mrbrain_cEED.vtk 5 0.003 cEED ) +itk_add_test( + NAME mrbrain_cEED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/mrbrain_cEED.vtk} + ${TestOutput}/mrbrain_cEED.vtk + CoherenceEnhancingDiffusionTest + DATA{Input/mrbrain_noisy.vtk} + ${TestOutput}/mrbrain_cEED.vtk + 5 + 0.003 + cEED +) ################# fig : Lena ################ -itk_add_test(NAME Lena_Detail_cCED_2 COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Lena_Detail_cCED_2.png} ${TestOutput}/Lena_Detail_cCED_2.png - CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cCED_2.png 2 0.003 cCED 0.5 2 4 ) - -itk_add_test(NAME Lena_Detail_cEED_2 COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Lena_Detail_cEED_2.png} ${TestOutput}/Lena_Detail_cEED_2.png - CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_cEED_2.png 2 0.003 cEED 0.5 2 4 ) +itk_add_test( + NAME Lena_Detail_cCED_2 + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Lena_Detail_cCED_2.png} + ${TestOutput}/Lena_Detail_cCED_2.png + CoherenceEnhancingDiffusionTest + DATA{Input/Lena_Detail.png} + ${TestOutput}/Lena_Detail_cCED_2.png + 2 + 0.003 + cCED + 0.5 + 2 + 4 +) -itk_add_test(NAME Lena_Detail_I_2 COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Lena_Detail_I_2.png} ${TestOutput}/Lena_Detail_I_2.png - CoherenceEnhancingDiffusionTest DATA{Input/Lena_Detail.png} ${TestOutput}/Lena_Detail_I_2.png 2 0.003 Isotropic 0.5 2 4 ) +itk_add_test( + NAME Lena_Detail_cEED_2 + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Lena_Detail_cEED_2.png} + ${TestOutput}/Lena_Detail_cEED_2.png + CoherenceEnhancingDiffusionTest + DATA{Input/Lena_Detail.png} + ${TestOutput}/Lena_Detail_cEED_2.png + 2 + 0.003 + cEED + 0.5 + 2 + 4 +) +itk_add_test( + NAME Lena_Detail_I_2 + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Lena_Detail_I_2.png} + ${TestOutput}/Lena_Detail_I_2.png + CoherenceEnhancingDiffusionTest + DATA{Input/Lena_Detail.png} + ${TestOutput}/Lena_Detail_I_2.png + 2 + 0.003 + Isotropic + 0.5 + 2 + 4 +) ############## fig : Vector field ########### -itk_add_test(NAME VectorField_Circle_cEED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/VectorField_Circle_cEED.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk - CoherenceEnhancingDiffusionTest DATA{Input/VectorField_CircleOpposites.vtk} ${TestOutput}/VectorField_Circle_cEED.vtk 10 0.05 cEED ) - +itk_add_test( + NAME VectorField_Circle_cEED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/VectorField_Circle_cEED.vtk} + ${TestOutput}/VectorField_Circle_cEED.vtk + CoherenceEnhancingDiffusionTest + DATA{Input/VectorField_CircleOpposites.vtk} + ${TestOutput}/VectorField_Circle_cEED.vtk + 10 + 0.05 + cEED +) ############### fig : Triangle ############## +itk_add_test( + NAME Triangle_cEED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Triangle_cEED.png} + ${TestOutput}/Triangle_cEED.png + CoherenceEnhancingDiffusionTest + DATA{Input/Triangle.png} + ${TestOutput}/Triangle_cEED.png + 5 + 0.03 + cEED +) -itk_add_test(NAME Triangle_cEED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Triangle_cEED.png} ${TestOutput}/Triangle_cEED.png - CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_cEED.png 5 0.03 cEED ) - -itk_add_test(NAME Triangle_EED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Triangle_EED.png} ${TestOutput}/Triangle_EED.png - CoherenceEnhancingDiffusionTest DATA{Input/Triangle.png} ${TestOutput}/Triangle_EED.png 5 0.03 EED ) +itk_add_test( + NAME Triangle_EED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Triangle_EED.png} + ${TestOutput}/Triangle_EED.png + CoherenceEnhancingDiffusionTest + DATA{Input/Triangle.png} + ${TestOutput}/Triangle_EED.png + 5 + 0.03 + EED +) -itk_add_test(NAME Oscillations1_cCED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Oscillations1_cCED.png} ${TestOutput}/Oscillations1_cCED.png - CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_cCED.png 20 0.05 cCED ) +itk_add_test( + NAME Oscillations1_cCED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Oscillations1_cCED.png} + ${TestOutput}/Oscillations1_cCED.png + CoherenceEnhancingDiffusionTest + DATA{Input/Oscillations_Noisy1.png} + ${TestOutput}/Oscillations1_cCED.png + 20 + 0.05 + cCED +) -itk_add_test(NAME Oscillations1_CED COMMAND AnisotropicDiffusionLBRTestDriver - --compare DATA{Baseline/Oscillations1_CED.png} ${TestOutput}/Oscillations1_CED.png - CoherenceEnhancingDiffusionTest DATA{Input/Oscillations_Noisy1.png} ${TestOutput}/Oscillations1_CED.png 20 0.05 CED ) +itk_add_test( + NAME Oscillations1_CED + COMMAND + AnisotropicDiffusionLBRTestDriver + --compare + DATA{Baseline/Oscillations1_CED.png} + ${TestOutput}/Oscillations1_CED.png + CoherenceEnhancingDiffusionTest + DATA{Input/Oscillations_Noisy1.png} + ${TestOutput}/Oscillations1_CED.png + 20 + 0.05 + CED +) diff --git a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt index cb5aa8e3202..cd368a77b2c 100644 --- a/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt +++ b/Modules/Filtering/AnisotropicDiffusionLBR/wrapping/CMakeLists.txt @@ -1,5 +1,3 @@ itk_wrap_module(AnisotropicDiffusionLBR) -set(WRAPPING_SUBMODULE_ORDER - itkAnisotropicDiffusionLBRImageFilter - ) +set(WRAPPING_SUBMODULE_ORDER itkAnisotropicDiffusionLBRImageFilter) itk_auto_load_and_end_wrap_submodules()