From 9bcf64b7f7c5a7f0a39843df634c05b5d9e4e237 Mon Sep 17 00:00:00 2001 From: dsarrut Date: Fri, 29 Jan 2010 07:27:31 +0000 Subject: [PATCH] - new GF system --- common/clitkCommon.h | 18 +- common/clitkImageToImageGenericFilter.cxx | 205 +++++++++++++-- common/clitkImageToImageGenericFilter.h | 132 +++++++--- common/vvImage.cxx | 110 +++++--- common/vvImage.h | 95 +++---- filters/CMakeLists.txt | 19 +- .../clitkGuerreroVentilationGenericFilter.cxx | 68 ++--- .../clitkGuerreroVentilationGenericFilter.h | 21 +- filters/clitkImageArithmGenericFilter.cxx | 235 ++++++++++++++++-- filters/clitkImageArithmGenericFilter.h | 18 +- filters/clitkImageConvertGenericFilter.cxx | 111 +++++++-- filters/clitkImageConvertGenericFilter.h | 17 +- filters/clitkImageFillRegionGenericFilter.cxx | 148 +++++++++-- filters/clitkImageFillRegionGenericFilter.h | 16 +- filters/clitkImageFillRegionGenericFilter.txx | 123 --------- filters/clitkImageResampleGenericFilter.cxx | 160 +++++++++++- filters/clitkImageResampleGenericFilter.h | 16 +- filters/clitkImageResampleGenericFilter.txx | 175 ------------- filters/clitkSplitImageGenericFilter.cxx | 67 +++-- filters/clitkSplitImageGenericFilter.h | 17 +- filters/clitkSplitImageGenericFilter.txx | 79 ------ filters/clitkVFResampleGenericFilter.cxx | 168 +++++++++++-- filters/clitkVFResampleGenericFilter.h | 16 +- filters/clitkVFResampleGenericFilter.txx | 154 ------------ tools/CMakeLists.txt | 10 + tools/clitkAffineTransform.cxx | 2 +- tools/clitkAverageTemporalDimension.cxx | 2 +- tools/clitkInvertVF.cxx | 2 +- tools/clitkSetBackgroundGenericFilter.h | 4 +- tools/clitkSignalMeanPositionFilter.cxx | 2 +- tools/clitkSignalMeanPositionFilter.h | 4 +- tools/clitkWarpImageGenericFilter.h | 4 +- tools/clitkWarpImageGenericFilter.txx | 6 +- tools/clitkWriteDicomSeries.cxx | 2 +- 34 files changed, 1307 insertions(+), 919 deletions(-) diff --git a/common/clitkCommon.h b/common/clitkCommon.h index 5831d7b..ce70757 100644 --- a/common/clitkCommon.h +++ b/common/clitkCommon.h @@ -50,25 +50,13 @@ namespace clitk { //-------------------------------------------------------------------- // GGO with modified struct name -#define GGO(ggo_filename, args_info) \ - gengetopt_args_info_##ggo_filename args_info; \ - cmdline_parser2(argc, argv, &args_info, 1, 1, 0); \ - if (args_info.config_given) \ - cmdline_parser_configfile (args_info.config_arg, &args_info, 0, 0, 1); \ - else cmdline_parser(argc, argv, &args_info); - - - /* //-------------------------------------------------------------------- - // GGO default #define GGO(ggo_filename, args_info) \ - gengetopt_args_info_##ggo_filename args_info; \ + args_info_##ggo_filename args_info; \ cmdline_parser2(argc, argv, &args_info, 1, 1, 0); \ if (args_info.config_given) \ cmdline_parser_configfile (args_info.config_arg, &args_info, 0, 0, 1); \ - else cmdline_parser(argc, argv, &args_info); - - //-------------------------------------------------------------------- - */ + else cmdline_parser(argc, argv, &args_info); + //-------------------------------------------------------------------- // skip line with # void skipComment(std::istream & is); diff --git a/common/clitkImageToImageGenericFilter.cxx b/common/clitkImageToImageGenericFilter.cxx index 0428c70..f41f8d3 100644 --- a/common/clitkImageToImageGenericFilter.cxx +++ b/common/clitkImageToImageGenericFilter.cxx @@ -2,89 +2,242 @@ #include "clitkImageCommon.h" //-------------------------------------------------------------------- -clitk::ImageToImageGenericFilter::ImageToImageGenericFilter() : - mIOVerbose(false) -{} +clitk::ImageToImageGenericFilterBase::ImageToImageGenericFilterBase(std::string n) + :mIOVerbose(false) { + mFilterName = n; + mListOfAllowedDimension.clear(); + mListOfAllowedPixelType.clear(); + mFailOnImageTypeError = true; +} //-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::AddImageType(unsigned int d, std::string p) { + // Search for dimension (to not duplicate) + std::vector::const_iterator it = + std::find (mListOfAllowedDimension.begin(), + mListOfAllowedDimension.end(), d); + if (it == mListOfAllowedDimension.end()) mListOfAllowedDimension.push_back(d); + // Search for PixelType (to not duplicate) + std::vector::const_iterator itt = + std::find (mListOfAllowedPixelType.begin(), + mListOfAllowedPixelType.end(), p); + if (itt == mListOfAllowedPixelType.end()) mListOfAllowedPixelType.push_back(p); +} //-------------------------------------------------------------------- -void clitk::ImageToImageGenericFilter::SetInputFilenames(const std::vector & filenames) { + + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::SetInputFilenames(const std::vector & filenames) { mInputFilenames.resize(filenames.size()); std::copy(filenames.begin(), filenames.end(), mInputFilenames.begin()); } +//-------------------------------------------------------------------- + -void clitk::ImageToImageGenericFilter::SetInputFilename(const std::string & filename) { +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::SetInputFilename(const std::string & filename) { std::vector f; f.push_back(filename); SetInputFilenames(f); } +//-------------------------------------------------------------------- -void clitk::ImageToImageGenericFilter::AddInputFilename(const std::string & filename) { + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::AddInputFilename(const std::string & filename) { mInputFilenames.push_back(filename); } //-------------------------------------------------------------------- + //-------------------------------------------------------------------- -void clitk::ImageToImageGenericFilter::SetOutputFilename(const std::string & filename) { +void clitk::ImageToImageGenericFilterBase::SetOutputFilename(const std::string & filename) { mOutputFilenames.clear(); mOutputFilenames.push_back(filename); } -void clitk::ImageToImageGenericFilter::AddOutputFilename(const std::string & filename) +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::AddOutputFilename(const std::string & filename) { mOutputFilenames.push_back(filename); } -void clitk::ImageToImageGenericFilter::SetOutputFilenames(const std::vector & filenames) +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::SetOutputFilenames(const std::vector & filenames) { std::copy(filenames.begin(), filenames.end(), mOutputFilenames.begin()); } -std::string clitk::ImageToImageGenericFilter::GetOutputFilename() +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +std::string clitk::ImageToImageGenericFilterBase::GetOutputFilename() { assert(mOutputFilenames.size() == 1); return mOutputFilenames.front(); } //-------------------------------------------------------------------- -void clitk::ImageToImageGenericFilter::GetInputImageDimensionAndPixelType(unsigned int& dim,\ + + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::GetInputImageDimensionAndPixelType(unsigned int& dim, \ std::string& pixeltype,unsigned int& components) { - if (mInputFilenames.size()) + if (mInputFilenames.size()) { - int comp_temp,dim_temp; //clitkCommonImage takes ints - ReadImageDimensionAndPixelType(mInputFilenames[0], dim_temp, pixeltype,comp_temp); - components=comp_temp; dim=dim_temp; + int comp_temp,dim_temp; //clitkCommonImage takes ints + ReadImageDimensionAndPixelType(mInputFilenames[0], dim_temp, pixeltype,comp_temp); + components=comp_temp; dim=dim_temp; } - else if (mInputVVImages.size()) + else if (mInputVVImages.size()) { - pixeltype=mInputVVImages[0]->GetScalarTypeAsString(); - dim=mInputVVImages[0]->GetNumberOfDimensions(); - components=mInputVVImages[0]->GetNumberOfScalarComponents(); + pixeltype=mInputVVImages[0]->GetScalarTypeAsString(); + dim=mInputVVImages[0]->GetNumberOfDimensions(); + components=mInputVVImages[0]->GetNumberOfScalarComponents(); } - else - assert(false); //No input image, shouldn't happen + else + assert(false); //No input image, shouldn't happen + + if (mIOVerbose) { + std::cout << "Input is " << mDim << "D " << mPixelTypeName << "." << std::endl; + } } -vvImage::Pointer clitk::ImageToImageGenericFilter::GetOutputVVImage () +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +vvImage::Pointer clitk::ImageToImageGenericFilterBase::GetOutputVVImage () { assert(mOutputVVImages.size()); return mOutputVVImages[0]; } +//-------------------------------------------------------------------- + -std::vector clitk::ImageToImageGenericFilter::GetOutputVVImages() +//-------------------------------------------------------------------- +std::vector clitk::ImageToImageGenericFilterBase::GetOutputVVImages() { return mOutputVVImages; } +//-------------------------------------------------------------------- + -void clitk::ImageToImageGenericFilter::SetInputVVImage (vvImage::Pointer input) +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::SetInputVVImage (vvImage::Pointer input) { mInputVVImages.clear(); mInputVVImages.push_back(input); } +//-------------------------------------------------------------------- + -void clitk::ImageToImageGenericFilter::AddInputVVImage (vvImage::Pointer input) +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::AddInputVVImage (vvImage::Pointer input) { mInputVVImages.push_back(input); } +//-------------------------------------------------------------------- -void clitk::ImageToImageGenericFilter::SetInputVVImages (std::vector input) + +//-------------------------------------------------------------------- +void clitk::ImageToImageGenericFilterBase::SetInputVVImages (std::vector input) { mInputVVImages=input; } +//-------------------------------------------------------------------- + + + +//-------------------------------------------------------------------- +bool clitk::ImageToImageGenericFilterBase::CheckImageType() { + return (CheckDimension() && CheckPixelType()); +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +bool clitk::ImageToImageGenericFilterBase::CheckDimension(unsigned int d) { + bool b = false; + unsigned int i=0; + while ((!b) && (i manages "; + for(unsigned int i=0; i is not available for " + << mDim << "D images with pixel=" + << mPixelTypeName << "." << std::endl; + std::cerr << "**Error** Allowed image dim: \t"; + for(unsigned int i=0; i + David Sarrut + + Copyright (C) 2008 + Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr + CREATIS-LRMN http://www.creatis.insa-lyon.fr -/** - =================================================================== - * @file clitkImageToImageGenericFilter.h - * @author David Sarrut - * @date 05 May 2008 14:40:51 + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 3 of the License. - * @brief + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. - ===================================================================*/ + You should have received a copy of the GNU General Public License + along with this program. If not, see . + + =========================================================================*/ + +#ifndef CLITKIMAGETOIMAGEGENERICFILTER_H +#define CLITKIMAGETOIMAGEGENERICFILTER_H // clitk include #include "clitkCommon.h" #include "clitkImageCommon.h" +#include "clitkCommonGenericFilter.h" #include +// vv include #include #include #include @@ -23,18 +43,24 @@ namespace clitk { - class ImageToImageGenericFilter: public itk::Object { + //-------------------------------------------------------------------- + class ImageToImageGenericFilterBase: public itk::Object { public: // constructor - destructor - ImageToImageGenericFilter(); + ImageToImageGenericFilterBase(std::string filterName); + virtual ~ImageToImageGenericFilterBase() {} // Types - typedef ImageToImageGenericFilter Self; + typedef ImageToImageGenericFilterBase Self; typedef Object Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; + // Filters information + const std::string & GetFilterName() { return mFilterName; } + void SetFilterName(std::string & n) { mFilterName = n; } + // Generic IO /// Returns the dimension and pixel type of the *first* input void GetInputImageDimensionAndPixelType(unsigned int& dim, std::string& pixeltype,unsigned int & components); @@ -56,16 +82,25 @@ namespace clitk { vvImage::Pointer GetOutputVVImage (); std::vector GetOutputVVImages (); - /// Main function to implement - virtual void Update() = 0; - - protected: + // Information on available image types + void PrintAvailableImageTypes(); + bool CheckDimension(unsigned int d); + bool CheckPixelType(std::string pt); + + // Main function to call for using the filter. + virtual bool Update() = 0; + + // Use internally only (TO PUT PROTECTED !!!) + void AddImageType(unsigned int d, std::string p); + + protected: /// Call this function to dispatch an output towards the correct sink template - void SetNextOutput(typename ImageType::Pointer output); + void SetNextOutput(typename ImageType::Pointer output); + /// Call this function to get the nth itk input image, regardless of input source template - typename ImageType::Pointer GetInput(unsigned int n); + typename ImageType::Pointer GetInput(unsigned int n); std::vector mInputFilenames; std::list mOutputFilenames; @@ -74,34 +109,53 @@ namespace clitk { unsigned int mDim; std::string mPixelTypeName; unsigned int mNbOfComponents; + std::string mFilterName; std::vector mInputVVImages; std::vector mOutputVVImages; + std::vector mListOfAllowedPixelType; + std::vector mListOfAllowedDimension; + bool CheckImageType(); + bool CheckDimension(); + bool CheckPixelType(); + void ImageTypeError(); + void SetImageTypeError(); + bool mFailOnImageTypeError; + }; // end class clitk::ImageToImageGenericFilter + + //-------------------------------------------------------------------- + template + class ImageToImageGenericFilter: public ImageToImageGenericFilterBase { + + public: + + typedef ImageToImageGenericFilter Self; + + // constructor - destructor + ImageToImageGenericFilter(std::string filterName); + virtual ~ImageToImageGenericFilter() { delete mImageTypesManager; } + + // Main function to call for using the filter. + virtual bool Update(); + + protected: + // Object that will manage the list of templatized function for + // each image type. + ImageTypesManager * mImageTypesManager; + + }; // end class clitk::ImageToImageGenericFilter + + // #define ADD_IMAGE_DIMENSION(DIM) Initialize(); + +#define ADD_IMAGE_TYPE(DIM, PT) this->mImageTypesManager->template AddNewDimensionAndPixelType(); + + +#include "clitkImageToImageGenericFilter.txx" + } // end namespace -template -void clitk::ImageToImageGenericFilter::SetNextOutput(typename ImageType::Pointer output) -{ - if (mOutputFilenames.size()) - { - clitk::writeImage(output, mOutputFilenames.front(), mIOVerbose); - mOutputFilenames.pop_front(); - } - if (mInputVVImages.size()) //We assume that if a vv image is set as input, we want one as the output - mOutputVVImages.push_back(vvImageFromITK(output)); -} -template -typename ImageType::Pointer clitk::ImageToImageGenericFilter::GetInput(unsigned int n) -{ - if (mInputFilenames.size() > n) - return clitk::readImage(mInputFilenames[n], mIOVerbose); - else if (mInputVVImages.size() > n) - return typename ImageType::Pointer(const_cast(vvImageToITK(mInputVVImages[n]).GetPointer())); - else - assert(false); //No input, this shouldn't happen -} #endif /* end #define CLITKIMAGETOIMAGEGENERICFILTER_H */ diff --git a/common/vvImage.cxx b/common/vvImage.cxx index 7d68a14..ae5c5a6 100644 --- a/common/vvImage.cxx +++ b/common/vvImage.cxx @@ -1,7 +1,7 @@ #ifndef VVIMAGE_CXX #define VVIMAGE_CXX -/*========================================================================= +/*------------------------------------------------------------------------- Program: vv Language: C++ @@ -23,29 +23,29 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . -=========================================================================*/ +-------------------------------------------------------------------------*/ #include "vvImage.h" #include "vtkImageData.h" #include "clitkCommon.h" #include -//==================================================================== +//-------------------------------------------------------------------- vvImage::vvImage() { mVtkImages.resize(0); } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- vvImage::~vvImage() { for (unsigned int i = 0; i < mVtkImages.size(); i++) { if (mVtkImages[i] != NULL) mVtkImages[i]->Delete(); } } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- void vvImage::SetImage(std::vector images) { for (unsigned int i = 0; i < mVtkImages.size(); i++) { if (mVtkImages[i] != NULL) @@ -56,15 +56,15 @@ void vvImage::SetImage(std::vector images) { mVtkImages.push_back(images[i]); } } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- void vvImage::AddImage(vtkImageData* image) { mVtkImages.push_back(image); } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- void vvImage::Init() { for (unsigned int i = 0; i < mVtkImages.size(); i++) { if (mVtkImages[i] != NULL) @@ -72,9 +72,9 @@ void vvImage::Init() { } mVtkImages.resize(0); } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- int vvImage::GetNumberOfSpatialDimensions() { int dim=GetNumberOfDimensions(); if (IsTimeSequence()) @@ -82,9 +82,9 @@ int vvImage::GetNumberOfSpatialDimensions() { else return dim; } -//==================================================================== +//-------------------------------------------------------------------- // -//==================================================================== +//-------------------------------------------------------------------- int vvImage::GetNumberOfDimensions() const { if (mVtkImages.size()) { @@ -99,7 +99,7 @@ int vvImage::GetNumberOfDimensions() const { } return 0; } -//==================================================================== +//-------------------------------------------------------------------- void vvImage::GetScalarRange(double* range) { assert(mVtkImages.size()); @@ -113,25 +113,25 @@ void vvImage::GetScalarRange(double* range) } } -//==================================================================== +//-------------------------------------------------------------------- std::string vvImage::GetScalarTypeAsString() { return mVtkImages[0]->GetScalarTypeAsString(); } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- int vvImage::GetNumberOfScalarComponents() { return mVtkImages[0]->GetNumberOfScalarComponents(); } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- int vvImage::GetScalarSize() { return mVtkImages[0]->GetScalarSize(); } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- std::vector vvImage::GetSpacing() { std::vector spacing; int dim = this->GetNumberOfDimensions(); @@ -144,9 +144,9 @@ std::vector vvImage::GetSpacing() { } return spacing; } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- std::vector vvImage::GetOrigin() const { std::vector origin; int dim = this->GetNumberOfDimensions(); @@ -159,9 +159,9 @@ std::vector vvImage::GetOrigin() const { } return origin; } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- std::vector vvImage::GetSize() { std::vector size0; int dim = this->GetNumberOfDimensions(); @@ -174,9 +174,9 @@ std::vector vvImage::GetSize() { } return size0; } -//==================================================================== +//-------------------------------------------------------------------- -//==================================================================== +//-------------------------------------------------------------------- unsigned long vvImage::GetActualMemorySize() { unsigned long size = 0; for (unsigned int i = 0; i < mVtkImages.size(); i++) { @@ -184,6 +184,56 @@ unsigned long vvImage::GetActualMemorySize() { } return size; } -//==================================================================== +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +bool vvImage::IsTimeSequence() { + return mVtkImages.size()>1; +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +const std::vector& vvImage::GetVTKImages() { + return mVtkImages; +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +vtkImageData* vvImage::GetFirstVTKImageData() { + return mVtkImages[0]; +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +bool vvImage::IsScalarTypeInteger() { + assert(mVtkImages.size()> 0); + int t = mVtkImages[0]->GetScalarType(); + return IsScalarTypeInteger(t); +} +//-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +bool vvImage::IsScalarTypeInteger(int t) { + if ((t == VTK_BIT) || + (t == VTK_CHAR) || + (t == VTK_UNSIGNED_CHAR) || + (t == VTK_SHORT) || + (t == VTK_UNSIGNED_SHORT) || + (t == VTK_INT) || + (t == VTK_UNSIGNED_INT) || + (t == VTK_LONG) || + (t == VTK_UNSIGNED_LONG)) { + return true; + } + else { + return false; + } +} +//-------------------------------------------------------------------- + #endif // VVIMAGE_CXX diff --git a/common/vvImage.h b/common/vvImage.h index 6ab4c2b..ae2b7a6 100644 --- a/common/vvImage.h +++ b/common/vvImage.h @@ -1,28 +1,31 @@ /*========================================================================= - Program: vv - Language: C++ - Author : Pierre Seroul (pierre.seroul@gmail.com) + Program: vv + Module: $RCSfile: vvImage.h,v $ + Language: C++ + Date: $Date: 2010/01/29 07:27:45 $ + Version: $Revision: 1.3 $ + Author : Pierre Seroul (pierre.seroul@gmail.com) -Copyright (C) 2008 -Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr -CREATIS-LRMN http://www.creatis.insa-lyon.fr + Copyright (C) 2008 + Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr + CREATIS-LRMN http://www.creatis.insa-lyon.fr -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, version 3 of the License. + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 3 of the License. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program. If not, see . + You should have received a copy of the GNU General Public License + along with this program. If not, see . -=========================================================================*/ -#ifndef vvImage_h -#define vvImage_h + =========================================================================*/ +#ifndef VVIMAGE_H +#define VVIMAGE_H #include #include @@ -30,39 +33,37 @@ along with this program. If not, see . class vtkImageData; -class vvImage : public itk::LightObject -{ +class vvImage : public itk::LightObject { public : - typedef vvImage Self; - typedef itk::SmartPointer Pointer; - itkNewMacro(Self); + typedef vvImage Self; + typedef itk::SmartPointer Pointer; + itkNewMacro(Self); - void Init(); - void SetImage(std::vector images); - void AddImage(vtkImageData* image); - const std::vector& GetVTKImages() { - return mVtkImages; - } - - int GetNumberOfDimensions() const; - int GetNumberOfSpatialDimensions(); - ///Writes the scalar range to the provided array, which must have room for two doubles - void GetScalarRange(double* range); - unsigned long GetActualMemorySize(); - std::vector GetSpacing(); - std::vector GetOrigin() const; - std::vector GetSize(); - std::string GetScalarTypeAsString(); - int GetNumberOfScalarComponents(); - int GetScalarSize(); - bool IsTimeSequence() { - return mVtkImages.size()>1; - } + void Init(); + void SetImage(std::vector images); + void AddImage(vtkImageData* image); + const std::vector& GetVTKImages(); + vtkImageData* GetFirstVTKImageData(); + + int GetNumberOfDimensions() const; + int GetNumberOfSpatialDimensions(); + ///Writes the scalar range to the provided array, which must have room for two doubles + void GetScalarRange(double* range); + unsigned long GetActualMemorySize(); + std::vector GetSpacing(); + std::vector GetOrigin() const; + std::vector GetSize(); + std::string GetScalarTypeAsString(); + int GetNumberOfScalarComponents(); + int GetScalarSize(); + bool IsTimeSequence(); + bool IsScalarTypeInteger(); + bool IsScalarTypeInteger(int t); private: - vvImage(); - ~vvImage(); - std::vector mVtkImages; + vvImage(); + ~vvImage(); + std::vector mVtkImages; }; diff --git a/filters/CMakeLists.txt b/filters/CMakeLists.txt index 0172d19..469d17b 100644 --- a/filters/CMakeLists.txt +++ b/filters/CMakeLists.txt @@ -3,14 +3,15 @@ #========================================================= # make clitk libraries -SET( clitkFilters_SRC -clitkGuerreroVentilationGenericFilter.cxx -clitkImageArithmGenericFilter.cxx -clitkImageConvertGenericFilter.cxx -clitkImageFillRegionGenericFilter.cxx -clitkImageResampleGenericFilter.cxx -clitkSplitImageGenericFilter.cxx -clitkVFResampleGenericFilter.cxx -) +SET(clitkFilters_SRC + clitkGuerreroVentilationGenericFilter.cxx + clitkImageArithmGenericFilter.cxx + clitkImageConvertGenericFilter.cxx + clitkImageFillRegionGenericFilter.cxx + clitkImageResampleGenericFilter.cxx + clitkSplitImageGenericFilter.cxx + clitkVFResampleGenericFilter.cxx + clitkBinarizeImageGenericFilter.cxx + ) ADD_LIBRARY(clitkFilters STATIC ${clitkFilters_SRC}) diff --git a/filters/clitkGuerreroVentilationGenericFilter.cxx b/filters/clitkGuerreroVentilationGenericFilter.cxx index 426765b..47a0359 100644 --- a/filters/clitkGuerreroVentilationGenericFilter.cxx +++ b/filters/clitkGuerreroVentilationGenericFilter.cxx @@ -19,69 +19,44 @@ * @brief -------------------------------------------------------------------*/ +#include #include "clitkGuerreroVentilationGenericFilter.h" #include #include -//-------------------------------------------------------------------- -clitk::GuerreroVentilationGenericFilter::GuerreroVentilationGenericFilter() -{ - blood_mass_factor=1.; -} -//-------------------------------------------------------------------- +#include //-------------------------------------------------------------------- -void clitk::GuerreroVentilationGenericFilter::Update () { - - // Determine dim, pixel type, number of components - this->GetInputImageDimensionAndPixelType(mDim,mPixelTypeName,mNbOfComponents); - - // Switch by dimension - if (mDim == 3) { Update_WithDim<3>(); return; } - if (mDim == 2) { Update_WithDim<2>(); return; } - std::cerr << "Error, dimension of input image is " << mDim << ", but I only work with 2 or 3." << std::endl; - exit(0); +clitk::GuerreroVentilationGenericFilter::GuerreroVentilationGenericFilter() + :ImageToImageGenericFilter("GuerreroVentilationGenericFilter") { + blood_mass_factor=1.; + InitializeImageType<2>(); + InitializeImageType<3>(); } //-------------------------------------------------------------------- -//This is where you put the actual implementation - -#include -#include - - //-------------------------------------------------------------------- template -void clitk::GuerreroVentilationGenericFilter::Update_WithDim() { -#define TRY_TYPE(TYPE) \ - if (IsSameType(mPixelTypeName)) { Update_WithDimAndPixelType(); return; } - // TRY_TYPE(signed char); - // TRY_TYPE(uchar); - TRY_TYPE(short); - //TRY_TYPE(ushort); - // TRY_TYPE(int); -// TRY_TYPE(unsigned int); - //TRY_TYPE(float); - // TRY_TYPE(double); -#undef TRY_TYPE - - std::string list = CreateListOfTypes(); - std::cerr << "Error, I don't know the type '" << mPixelTypeName << "' for the input image '" - << mInputFilenames[0] << "'." << std::endl << "Known types are " << list << std::endl; - exit(0); +void clitk::GuerreroVentilationGenericFilter::InitializeImageType() { + ADD_IMAGE_TYPE(Dim, short); } //-------------------------------------------------------------------- + //-------------------------------------------------------------------- -template -void clitk::GuerreroVentilationGenericFilter::Update_WithDimAndPixelType() { +template +void clitk::GuerreroVentilationGenericFilter::UpdateWithInputImageType() { - // Read input + // Input should be 2 assert(mInputFilenames.size() == 2); - typedef itk::Image ImageType; - typedef itk::Image OutputImageType; - typename ImageType::Pointer input = clitk::readImage(mInputFilenames[0], mIOVerbose); - typename ImageType::Pointer ref = clitk::readImage(mInputFilenames[1], mIOVerbose); + // Reading input + typedef ImageType InputImageType; + typename InputImageType::Pointer input = this->template GetInput(0); + typename InputImageType::Pointer ref = this->template GetInput(1); + + typedef itk::Image OutputImageType; + // typename ImageType::Pointer input = clitk::readImage(mInputFilenames[0], mIOVerbose); + //typename ImageType::Pointer ref = clitk::readImage(mInputFilenames[1], mIOVerbose); typedef itk::BinaryGuerreroFilter GFilterType; typename GFilterType::Pointer filter = GFilterType::New(); @@ -90,6 +65,7 @@ void clitk::GuerreroVentilationGenericFilter::Update_WithDimAndPixelType() { filter->SetBloodCorrectionFactor(blood_mass_factor); filter->SetUseCorrectFormula(use_correct_formula); filter->Update(); + this->SetNextOutput(filter->GetOutput()); //clitk::writeImage(filter->GetOutput(), mOutputFilename, mIOVerbose); //std::cout << "Warning: removed " << filter->GetFunctor().aberant_voxels << " aberant voxels from the ventilation image" diff --git a/filters/clitkGuerreroVentilationGenericFilter.h b/filters/clitkGuerreroVentilationGenericFilter.h index c3fd2b1..5d1062a 100644 --- a/filters/clitkGuerreroVentilationGenericFilter.h +++ b/filters/clitkGuerreroVentilationGenericFilter.h @@ -34,16 +34,17 @@ namespace clitk { //-------------------------------------------------------------------- - class GuerreroVentilationGenericFilter : public ImageToImageGenericFilter { - + class GuerreroVentilationGenericFilter : + public ImageToImageGenericFilter { public: // Constructor - GuerreroVentilationGenericFilter (); + GuerreroVentilationGenericFilter(); + virtual ~GuerreroVentilationGenericFilter() {} // Types typedef GuerreroVentilationGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; + typedef ImageToImageGenericFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -54,19 +55,17 @@ namespace clitk { void SetBloodCorrectionFactor(double f) {blood_mass_factor=f;} void SetUseCorrectFormula(bool u) {use_correct_formula=u;} - // Update - void Update (); + //-------------------------------------------------------------------- + // Main function called each time the filter is updated + template + void UpdateWithInputImageType(); protected: + template void InitializeImageType(); //Parameters double blood_mass_factor; bool use_correct_formula; - //-------------------------------------------------------------------- - template void Update_WithDim(); - template void Update_WithDimAndPixelType(); - //-------------------------------------------------------------------- - }; // end class GuerreroVentilationGenericFilter //-------------------------------------------------------------------- diff --git a/filters/clitkImageArithmGenericFilter.cxx b/filters/clitkImageArithmGenericFilter.cxx index 2683a93..7e344e7 100644 --- a/filters/clitkImageArithmGenericFilter.cxx +++ b/filters/clitkImageArithmGenericFilter.cxx @@ -25,22 +25,39 @@ #include "clitkImageArithmGenericFilter.h" //-------------------------------------------------------------------- -clitk::ImageArithmGenericFilter::ImageArithmGenericFilter():mTypeOfOperation(0) { +clitk::ImageArithmGenericFilter::ImageArithmGenericFilter() + :ImageToImageGenericFilter("ImageArithmGenericFilter"),mTypeOfOperation(0) { + InitializeImageType<2>(); + InitializeImageType<3>(); + InitializeImageType<4>(); mIsOperationUseASecondImage = false; } //-------------------------------------------------------------------- //-------------------------------------------------------------------- -void clitk::ImageArithmGenericFilter::Update () { - - // Load image header - itk::ImageIOBase::Pointer header = clitk::readImageHeader(mInputFilenames[0]); - - // Determine dim, pixel type, number of components - mDim = header->GetNumberOfDimensions(); - mPixelTypeName = header->GetComponentTypeAsString(header->GetComponentType()); - mNbOfComponents = header->GetNumberOfComponents(); - +template +void clitk::ImageArithmGenericFilter::InitializeImageType() { + ADD_IMAGE_TYPE(Dim, char); + ADD_IMAGE_TYPE(Dim, short); + /* ADD_IMAGE_TYPE(Dim, short); + ADD_IMAGE_TYPE(Dim, ushort; + ADD_IMAGE_TYPE(Dim, int); + ADD_IMAGE_TYPE(Dim, unsigned int); + ADD_IMAGE_TYPE(Dim, float); + ADD_IMAGE_TYPE(Dim, double); + */ +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +template +void clitk::ImageArithmGenericFilter::UpdateWithInputImageType() { + + // Check Input + + //DS TO BE CHANGED IN GetNumberOfInput() !!!!!!!! + if (mInputFilenames.size() == 0) { std::cerr << "ERROR : please provide at least a input filename." << std::endl; } @@ -54,13 +71,197 @@ void clitk::ImageArithmGenericFilter::Update () { std::cerr << "ERROR : please provide only 1 or 2 input filenames." << std::endl; } - // Switch by dimension - if (mDim == 2) { Update_WithDim<2>(); return; } - if (mDim == 3) { Update_WithDim<3>(); return; } - if (mDim == 4) { Update_WithDim<4>(); return; } + // Read input1 + // typename ImageType::Pointer input1 = clitk::readImage(mInputFilenames[0], mIOVerbose); + typename ImageType::Pointer input1 = this->template GetInput(0); + typename ImageType::Pointer outputImage; + + // Read input2 (float is ok altough it could take too memory ...) + if (mIsOperationUseASecondImage) { + typedef itk::Image ImageType2; + // typename ImageType2::Pointer input2 = clitk::readImage(mInputFilenames[1], mIOVerbose); + typename ImageType2::Pointer input2 = this->template GetInput(1); + outputImage = ComputeImage(input1, input2); + } + else { + outputImage = ComputeImage(input1); + } + + // Write results + this->SetNextOutput(outputImage); + //clitk::writeImage(outputImage, mOutputFilename, mIOVerbose); +} +//-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +template +typename ImageType::Pointer +clitk::ImageArithmGenericFilter::ComputeImage(typename ImageType::Pointer inputImage) { + + typedef typename ImageType::PixelType PixelType; + typedef itk::ImageRegionIterator IteratorType; + IteratorType it(inputImage, inputImage->GetLargestPossibleRegion()); + it.GoToBegin(); + + switch (mTypeOfOperation) { + case 0: // Addition + while (!it.IsAtEnd()) { + it.Set(PixelTypeDownCast((double)it.Get() + mScalar) ); + ++it; + } + break; + case 1: // Multiply + while (!it.IsAtEnd()) { + it.Set(PixelTypeDownCast((double)it.Get() * mScalar) ); + ++it; + } + break; + case 2: // Inverse + while (!it.IsAtEnd()) { + if (it.Get() != 0) + it.Set(PixelTypeDownCast(mScalar / (double)it.Get())); + else it.Set(mDefaultPixelValue); + ++it; + } + break; + case 3: // Max + while (!it.IsAtEnd()) { + if (it.Get() < mScalar) it.Set(PixelTypeDownCast(mScalar)); + ++it; + } + break; + case 4: // Min + while (!it.IsAtEnd()) { + if (it.Get() > mScalar) it.Set(PixelTypeDownCast(mScalar)); + ++it; + } + break; + case 5: // Absolute value + while (!it.IsAtEnd()) { + if (it.Get() <= 0) it.Set(PixelTypeDownCast(-it.Get())); + // <= zero to avoid warning for unsigned types + ++it; + } + break; + case 6: // Squared value + while (!it.IsAtEnd()) { + it.Set(PixelTypeDownCast((double)it.Get()*(double)it.Get())); + ++it; + } + break; + case 7: // Log + while (!it.IsAtEnd()) { + if (it.Get() > 0) + it.Set(PixelTypeDownCast(log((double)it.Get()))); + else it.Set(mDefaultPixelValue); + ++it; + } + break; + case 8: // exp + while (!it.IsAtEnd()) { + it.Set(PixelTypeDownCast(exp((double)it.Get()))); + ++it; + } + break; + case 9: // sqrt + while (!it.IsAtEnd()) { + if (it.Get() > 0) + it.Set(PixelTypeDownCast(sqrt((double)it.Get()))); + else { + if (it.Get() ==0) it.Set(0); + else it.Set(mDefaultPixelValue); + } + ++it; + } + break; + default: // error ? + std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl; + exit(-1); + } + + return inputImage; +} +//-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +template +typename ImageType1::Pointer +clitk::ImageArithmGenericFilter::ComputeImage(typename ImageType1::Pointer inputImage1, + typename ImageType2::Pointer inputImage2) { + + typedef typename ImageType1::PixelType PixelType; + typedef itk::ImageRegionIterator IteratorType; + IteratorType it1(inputImage1, inputImage1->GetLargestPossibleRegion()); + it1.GoToBegin(); + + typedef itk::ImageRegionConstIterator ConstIteratorType; + ConstIteratorType it2(inputImage2, inputImage2->GetLargestPossibleRegion()); + it2.GoToBegin(); + + switch (mTypeOfOperation) { + case 0: // Addition + while (!it1.IsAtEnd()) { + it1.Set(PixelTypeDownCast((double)it1.Get() + (double)it2.Get()) ); + ++it1; ++it2; + } + break; + case 1: // Multiply + while (!it1.IsAtEnd()) { + it1.Set(PixelTypeDownCast((double)it1.Get() * (double)it2.Get()) ); + ++it1; ++it2; + } + break; + case 2: // Divide + while (!it1.IsAtEnd()) { + if (it1.Get() != 0) + it1.Set(PixelTypeDownCast((double)it1.Get() / (double)it2.Get())); + else it1.Set(mDefaultPixelValue); + ++it1; ++it2; + } + break; + case 3: // Max + while (!it1.IsAtEnd()) { + if (it1.Get() < it2.Get()) it1.Set(PixelTypeDownCast(it2.Get())); + ++it1; ++it2; + } + break; + case 4: // Min + while (!it1.IsAtEnd()) { + if (it1.Get() > it2.Get()) it1.Set(PixelTypeDownCast(it2.Get())); + ++it1; ++it2; + } + break; + case 5: // Absolute difference + while (!it1.IsAtEnd()) { + it1.Set(PixelTypeDownCast(fabs(it2.Get()-it1.Get()))); + ++it1; ++it2; + } + break; + case 6: // Squared differences + while (!it1.IsAtEnd()) { + it1.Set(PixelTypeDownCast(pow((double)it1.Get()-(double)it2.Get(),2))); + ++it1; ++it2; + } + break; + case 7: // Difference + while (!it1.IsAtEnd()) { + it1.Set(PixelTypeDownCast((double)it1.Get()-(double)it2.Get())); + ++it1; ++it2; + } + break; + case 8: // Relative Difference + while (!it1.IsAtEnd()) { + if (it1.Get() != 0) it1.Set(PixelTypeDownCast(((double)it1.Get()-(double)it2.Get()))/(double)it1.Get()); + else it1.Set(0.0); + ++it1; ++it2; + } + break; + default: // error ? + std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl; + exit(-1); + } - std::cerr << "Error, dimension of input image is " << mDim << ", but I only work with 2,3." << std::endl; - exit(0); + return inputImage1; } //-------------------------------------------------------------------- diff --git a/filters/clitkImageArithmGenericFilter.h b/filters/clitkImageArithmGenericFilter.h index 8844911..afc6134 100644 --- a/filters/clitkImageArithmGenericFilter.h +++ b/filters/clitkImageArithmGenericFilter.h @@ -38,7 +38,8 @@ namespace clitk { //-------------------------------------------------------------------- // Main class for an Image Resample Generic Filter // (multiple dimensions, multiple pixel types) - class ImageArithmGenericFilter : public clitk::ImageToImageGenericFilter { + class ImageArithmGenericFilter: + public clitk::ImageToImageGenericFilter { public: @@ -47,7 +48,7 @@ namespace clitk { // Types typedef ImageArithmGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; + typedef ImageToImageGenericFilterBase Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -64,19 +65,18 @@ namespace clitk { int GetTypeOfOperation () { return mTypeOfOperation ;} double GetScalar () { return mScalar ;} - // Update - void Update (); + //-------------------------------------------------------------------- + // Main function called each time the filter is updated + template + void UpdateWithInputImageType(); protected: + template void InitializeImageType(); bool mIsOperationUseASecondImage; double mScalar; double mDefaultPixelValue; int mTypeOfOperation; - //-------------------------------------------------------------------- - template void Update_WithDim(); - template void Update_WithDimAndPixelType(); - template typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage); @@ -89,7 +89,7 @@ namespace clitk { }; // end class ImageArithmGenericFilter //-------------------------------------------------------------------- -#include "clitkImageArithmGenericFilter.txx" +//#include "clitkImageArithmGenericFilter.txx" } // end namespace //-------------------------------------------------------------------- diff --git a/filters/clitkImageConvertGenericFilter.cxx b/filters/clitkImageConvertGenericFilter.cxx index 6afb8ab..b4b8bc4 100644 --- a/filters/clitkImageConvertGenericFilter.cxx +++ b/filters/clitkImageConvertGenericFilter.cxx @@ -15,25 +15,38 @@ #include "clitkImageConvertGenericFilter.h" //-------------------------------------------------------------------- -clitk::ImageConvertGenericFilter::ImageConvertGenericFilter():ImageToImageGenericFilter() { +clitk::ImageConvertGenericFilter::ImageConvertGenericFilter(): + clitk::ImageToImageGenericFilter("ImageConvert") { mOutputPixelTypeName = "NotSpecified"; + InitializeImageType<2>(); + InitializeImageType<3>(); + InitializeImageType<4>(); } //-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +template +void clitk::ImageConvertGenericFilter::InitializeImageType() { + ADD_IMAGE_TYPE(Dim, char); + ADD_IMAGE_TYPE(Dim, short); + ADD_IMAGE_TYPE(Dim, unsigned short); + ADD_IMAGE_TYPE(Dim, int); + ADD_IMAGE_TYPE(Dim, float); + ADD_IMAGE_TYPE(Dim, double); +} //-------------------------------------------------------------------- -void clitk::ImageConvertGenericFilter::Update() { - // Load image header - itk::ImageIOBase::Pointer header = clitk::readImageHeader(mInputFilenames[0]); - // Determine dim, pixel type, number of components - mDim = header->GetNumberOfDimensions(); - mPixelTypeName = header->GetComponentTypeAsString(header->GetComponentType()); - mNbOfComponents = header->GetNumberOfComponents(); + +//-------------------------------------------------------------------- +template +void clitk::ImageConvertGenericFilter::UpdateWithInputImageType() { // Verbose stuff if (mIOVerbose) { if (mInputFilenames.size() == 1) { std::cout << "Input image <" << mInputFilenames[0] << "> is "; + itk::ImageIOBase::Pointer header = clitk::readImageHeader(mInputFilenames[0]); printImageHeader(header, std::cout); std::cout << std::endl; } @@ -47,16 +60,82 @@ void clitk::ImageConvertGenericFilter::Update() { } } - // Switch by dimension - if (mInputFilenames.size() > 1) mDim++; - if (mDim == 2) { Update_WithDim<2>(); return; } - if (mDim == 3) { Update_WithDim<3>(); return; } - if (mDim == 4) { Update_WithDim<4>(); return; } - std::cerr << "Error, dimension of input image is " << mDim << ", but I only work with 2,3,4." << std::endl; - exit(0); + if ((mPixelTypeName == mOutputPixelTypeName) || (mOutputPixelTypeName == "NotSpecified")) { + // typename InputImageType::Pointer input = clitk::readImage(mInputFilenames); + typename InputImageType::Pointer input = this->template GetInput(0); + //clitk::writeImage(input, mOutputFilename, mIOVerbose); + this->SetNextOutput(input); + } + else { +#define TRY_TYPE(TYPE) \ + if (IsSameType(mOutputPixelTypeName)) { UpdateWithOutputType(); return; } + TRY_TYPE(char); + // TRY_TYPE(signed char); + TRY_TYPE(uchar); + TRY_TYPE(short); + TRY_TYPE(ushort); + TRY_TYPE(int); // no uint ... + TRY_TYPE(float); + TRY_TYPE(double); +#undef TRY_TYPE + + std::string list = CreateListOfTypes(); + std::cerr << "Error, I don't know the output type '" << mOutputPixelTypeName + << "'. " << std::endl << "Known types are " << list << "." << std::endl; + exit(0); + } } -//-------------------------------------------------------------------- +//==================================================================== + +//==================================================================== +template +void clitk::ImageConvertGenericFilter::UpdateWithOutputType() { + // Read + typename InputImageType::Pointer input =this->template GetInput(0); + + // Typedef + typedef typename InputImageType::PixelType PixelType; + + // Warning + if (std::numeric_limits::is_signed) { + if (!std::numeric_limits::is_signed) { + std::cerr << "Warning, input type is signed (" << mPixelTypeName << ") while output type is not (" + << mOutputPixelTypeName << "), use at your own responsability." << std::endl; + } + } + if (!std::numeric_limits::is_integer) { + if (std::numeric_limits::is_integer) { + std::cerr << "Warning, input type is not integer (" << mPixelTypeName << ") while output type is (" + << mOutputPixelTypeName << "), use at your own responsability." << std::endl; + } + } + // DD(std::numeric_limits::digits10); + // DD(std::numeric_limits::digits10); + if (!std::numeric_limits::is_integer) { + if (std::numeric_limits::is_integer) { + std::cerr << "Warning, input type is not integer (" << mPixelTypeName << ") while output type is (" + << mOutputPixelTypeName << "), use at your own responsability." << std::endl; + } + } + if (std::numeric_limits::digits10 > std::numeric_limits::digits10) { + std::cerr << "Warning, possible loss of precision : input type is (" << mPixelTypeName << ") while output type is (" + << mOutputPixelTypeName << "), use at your own responsability." << std::endl; + } + + // Cast + typedef itk::Image OutputImageType; + typedef itk::CastImageFilter FilterType; + typename FilterType::Pointer filter = FilterType::New(); + filter->SetInput(input); + filter->Update(); + + // Write + SetNextOutput(filter->GetOutput()); + //clitk::writeImage(filter->GetOutput(), mOutputFilename, mIOVerbose); +} +//==================================================================== + #endif /* end #define CLITKIMAGECONVERTGENERICFILTER_CXX */ diff --git a/filters/clitkImageConvertGenericFilter.h b/filters/clitkImageConvertGenericFilter.h index 50f80ef..e46fb26 100644 --- a/filters/clitkImageConvertGenericFilter.h +++ b/filters/clitkImageConvertGenericFilter.h @@ -19,7 +19,8 @@ namespace clitk { - class ImageConvertGenericFilter: public clitk::ImageToImageGenericFilter { + class ImageConvertGenericFilter: + public clitk::ImageToImageGenericFilter { public: // constructor - destructor @@ -27,7 +28,6 @@ namespace clitk { // Types typedef ImageConvertGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -36,18 +36,21 @@ namespace clitk { // Members functions void SetOutputPixelType(std::string p) { mOutputPixelTypeName = p; } - void Update(); + + //-------------------------------------------------------------------- + // Main function called each time the filter is updated + template + void UpdateWithInputImageType(); protected: + template void InitializeImageType(); std::string mOutputPixelTypeName; - template void Update_WithDim(); - template void Update_WithDimAndPixelType(); - template void Update_WithDimAndPixelTypeAndOutputType(); + template void UpdateWithOutputType(); }; // end class ImageConvertGenericFilter -#include "clitkImageConvertGenericFilter.txx" + //#include "clitkImageConvertGenericFilter.txx" } // end namespace diff --git a/filters/clitkImageFillRegionGenericFilter.cxx b/filters/clitkImageFillRegionGenericFilter.cxx index 59bbff4..8e5e35d 100644 --- a/filters/clitkImageFillRegionGenericFilter.cxx +++ b/filters/clitkImageFillRegionGenericFilter.cxx @@ -25,14 +25,137 @@ #include "clitkImageFillRegionGenericFilter.h" //-------------------------------------------------------------------- -clitk::ImageFillRegionGenericFilter::ImageFillRegionGenericFilter() { +clitk::ImageFillRegionGenericFilter::ImageFillRegionGenericFilter(): + clitk::ImageToImageGenericFilter("ImageFillRegion") { + InitializeImageType<2>(); + InitializeImageType<3>(); mPixelValue = 0; m_IsCentered=false; - mSphericRegion=false; + mSphericRegion=false; } //-------------------------------------------------------------------- +//-------------------------------------------------------------------- +template +void clitk::ImageFillRegionGenericFilter::InitializeImageType() { + // ADD_IMAGE_TYPE(Dim, char); + ADD_IMAGE_TYPE(Dim, short); + // ADD_IMAGE_TYPE(Dim, unsigned short); +// ADD_IMAGE_TYPE(Dim, int); + ADD_IMAGE_TYPE(Dim, float); + // ADD_IMAGE_TYPE(Dim, double); +} +//-------------------------------------------------------------------- + + + +//-------------------------------------------------------------------- +template +void clitk::ImageFillRegionGenericFilter::UpdateWithInputImageType() { + + // Typedef + typedef typename ImageType::PixelType PixelType; + static unsigned int Dim = ImageType::ImageDimension; + + // Spheric region + if (mSphericRegion) return Update_WithDimAndPixelType_SphericRegion(); + + // Read input + typename ImageType::Pointer input = GetInput(0); + + // Get pixel value in correct type + PixelType value = PixelTypeDownCast(mPixelValue); + + // Get region + typedef typename ImageType::RegionType RegionType; + typedef typename ImageType::SizeType SizeType; + typedef typename ImageType::IndexType IndexType; + RegionType region; + SizeType size; + IndexType start; + for(unsigned int i=0; i IteratorType; + IteratorType it(input, region); + it.GoToBegin(); + while (!it.IsAtEnd()) { + it.Set(value); + ++it; + } + + // Write results + SetNextOutput(input); +} +//-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +template +void clitk::ImageFillRegionGenericFilter::Update_WithDimAndPixelType_SphericRegion() { + + // Read input + typedef itk::Image ImageType; + //typename ImageType::Pointer input = clitk::readImage(mInputFilenames[0], mIOVerbose); + typename ImageType::Pointer input = GetInput(0); + + // Get pixel value in correct type + PixelType value = PixelTypeDownCast(mPixelValue); + + // Centered? + if(m_IsCentered) + { + typename ImageType::SizeType size= input->GetLargestPossibleRegion().GetSize(); + typename ImageType::SpacingType spacing= input->GetSpacing(); + typename ImageType::PointType origin= input->GetOrigin(); + mCenter.resize(Dim); + for (unsigned int i=0; i IteratorType; + IteratorType it(input, input->GetLargestPossibleRegion()); + it.GoToBegin(); + + typename ImageType::PointType point; + //typename itk::Vector distance; + typename ImageType::IndexType index; + //bool inside; + double distance; + + while (!it.IsAtEnd()) + { + // inside=true; + index=it.GetIndex(); + input->TransformIndexToPhysicalPoint(index, point); + distance=0.0; + for(unsigned int i=0; i(input); +} + +//-------------------------------------------------------------------- + + + //-------------------------------------------------------------------- void clitk::ImageFillRegionGenericFilter::SetSphericRegion(std::vector & radius, std::vector & center) @@ -57,25 +180,4 @@ void clitk::ImageFillRegionGenericFilter::SetSphericRegion(std::vector & //-------------------------------------------------------------------- -//-------------------------------------------------------------------- -void clitk::ImageFillRegionGenericFilter::Update () { - - // Load image header - itk::ImageIOBase::Pointer header = clitk::readImageHeader(mInputFilenames[0]); - - // Determine dim, pixel type, number of components - mDim = header->GetNumberOfDimensions(); - mPixelTypeName = header->GetComponentTypeAsString(header->GetComponentType()); - mNbOfComponents = header->GetNumberOfComponents(); - - // Switch by dimension - if (mDim == 2) { Update_WithDim<2>(); return; } - if (mDim == 3) { Update_WithDim<3>(); return; } - // if (mDim == 4) { Update_WithDim<4>(); return; } - - std::cerr << "Error, dimension of input image is " << mDim << ", but I only work with 2,3,4." << std::endl; - exit(0); -} -//-------------------------------------------------------------------- - #endif //define CLITKIMAGEFILLREGIONGENERICFILTER_CXX diff --git a/filters/clitkImageFillRegionGenericFilter.h b/filters/clitkImageFillRegionGenericFilter.h index ea128b9..22e5fec 100644 --- a/filters/clitkImageFillRegionGenericFilter.h +++ b/filters/clitkImageFillRegionGenericFilter.h @@ -35,7 +35,8 @@ namespace clitk { //-------------------------------------------------------------------- - class ImageFillRegionGenericFilter : public clitk::ImageToImageGenericFilter { + class ImageFillRegionGenericFilter: + public clitk::ImageToImageGenericFilter { public: @@ -45,7 +46,6 @@ namespace clitk { // Types typedef ImageFillRegionGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -58,10 +58,13 @@ namespace clitk { void SetSphericRegion(std::vector & radius, std::vector & center); void SetSphericRegion(std::vector & radius); - // Update - void Update (); + //-------------------------------------------------------------------- + // Main function called each time the filter is updated + template + void UpdateWithInputImageType(); protected: + template void InitializeImageType(); double mPixelValue; int * mSize; int * mStart; @@ -70,12 +73,7 @@ namespace clitk { bool mSphericRegion; bool m_IsCentered; - - //-------------------------------------------------------------------- - template void Update_WithDim(); - template void Update_WithDimAndPixelType(); template void Update_WithDimAndPixelType_SphericRegion(); - //-------------------------------------------------------------------- }; // end class ImageFillRegionGenericFilter //-------------------------------------------------------------------- diff --git a/filters/clitkImageFillRegionGenericFilter.txx b/filters/clitkImageFillRegionGenericFilter.txx index 4d81f0e..79defad 100644 --- a/filters/clitkImageFillRegionGenericFilter.txx +++ b/filters/clitkImageFillRegionGenericFilter.txx @@ -20,127 +20,4 @@ * -------------------------------------------------*/ -//-------------------------------------------------------------------- -template -void ImageFillRegionGenericFilter::Update_WithDim() { -#define TRY_TYPE(TYPE) \ - if (IsSameType(mPixelTypeName)) { Update_WithDimAndPixelType(); return; } - // TRY_TYPE(signed char); - // TRY_TYPE(uchar); - TRY_TYPE(short); - //TRY_TYPE(ushort); - // TRY_TYPE(int); - // TRY_TYPE(unsigned int); - TRY_TYPE(float); - // TRY_TYPE(double); -#undef TRY_TYPE - - std::string list = CreateListOfTypes(); - std::cerr << "Error, I don't know the type '" << mPixelTypeName << "' for the input image '" - << mInputFilenames[0] << "'." << std::endl << "Known types are " << list << std::endl; - exit(0); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -void ImageFillRegionGenericFilter::Update_WithDimAndPixelType() { - - // Spheric region - if (mSphericRegion) return Update_WithDimAndPixelType_SphericRegion(); - - // Read input - typedef itk::Image ImageType; - typename ImageType::Pointer input = GetInput(0); - - // Get pixel value in correct type - PixelType value = PixelTypeDownCast(mPixelValue); - - // Get region - typedef typename ImageType::RegionType RegionType; - typedef typename ImageType::SizeType SizeType; - typedef typename ImageType::IndexType IndexType; - RegionType region; - SizeType size; - IndexType start; - for(unsigned int i=0; i IteratorType; - IteratorType it(input, region); - it.GoToBegin(); - while (!it.IsAtEnd()) { - it.Set(value); - ++it; - } - - // Write results - SetNextOutput(input); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -void ImageFillRegionGenericFilter::Update_WithDimAndPixelType_SphericRegion() { - - // Read input - typedef itk::Image ImageType; - //typename ImageType::Pointer input = clitk::readImage(mInputFilenames[0], mIOVerbose); - typename ImageType::Pointer input = GetInput(0); - - // Get pixel value in correct type - PixelType value = PixelTypeDownCast(mPixelValue); - - // Centered? - if(m_IsCentered) - { - typename ImageType::SizeType size= input->GetLargestPossibleRegion().GetSize(); - typename ImageType::SpacingType spacing= input->GetSpacing(); - typename ImageType::PointType origin= input->GetOrigin(); - mCenter.resize(Dim); - for (unsigned int i=0; i IteratorType; - IteratorType it(input, input->GetLargestPossibleRegion()); - it.GoToBegin(); - - typename ImageType::PointType point; - //typename itk::Vector distance; - typename ImageType::IndexType index; - //bool inside; - double distance; - - while (!it.IsAtEnd()) - { - // inside=true; - index=it.GetIndex(); - input->TransformIndexToPhysicalPoint(index, point); - distance=0.0; - for(unsigned int i=0; i(input); -} - -//-------------------------------------------------------------------- - #endif //#define CLITKIMAGEFILLREGIONGENERICFILTER_TXX diff --git a/filters/clitkImageResampleGenericFilter.cxx b/filters/clitkImageResampleGenericFilter.cxx index 0187e49..da510c6 100644 --- a/filters/clitkImageResampleGenericFilter.cxx +++ b/filters/clitkImageResampleGenericFilter.cxx @@ -14,30 +14,170 @@ #include "clitkImageResampleGenericFilter.h" //-------------------------------------------------------------------- -clitk::ImageResampleGenericFilter::ImageResampleGenericFilter() { +clitk::ImageResampleGenericFilter::ImageResampleGenericFilter(): + ImageToImageGenericFilter("ImageResample") { mApplyGaussianFilterBefore = false; mDefaultPixelValue = 0.0; mInterpolatorName = "NN"; mBSplineOrder=3; + InitializeImageTypeWithDim<2>(); + InitializeImageTypeWithDim<3>(); + InitializeImageTypeWithDim<4>(); } //-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +template +void clitk::ImageResampleGenericFilter::InitializeImageTypeWithDim() { + ADD_IMAGE_TYPE(Dim, char); + ADD_IMAGE_TYPE(Dim, short); + ADD_IMAGE_TYPE(Dim, int); + ADD_IMAGE_TYPE(Dim, float); +} //-------------------------------------------------------------------- -void clitk::ImageResampleGenericFilter::Update() { - // Determine dim, pixel type, number of components - this->GetInputImageDimensionAndPixelType(mDim,mPixelTypeName,mNbOfComponents); - // Switch by dimension - if (mDim == 2) { Update_WithDim<2>(); return; } - if (mDim == 3) { Update_WithDim<3>(); return; } - if (mDim == 4) { Update_WithDim<4>(); return; } +//-------------------------------------------------------------------- +template +void clitk::ImageResampleGenericFilter::UpdateWithInputImageType() { + + // Some typedefs + typedef typename InputImageType::SizeType SizeType; + typedef typename InputImageType::SpacingType SpacingType; + typedef typename InputImageType::PointType PointType; + typedef typename InputImageType::PixelType PixelType; + static unsigned int dim = InputImageType::ImageDimension; + + // Reading input + typename InputImageType::Pointer input = this->GetInput(0); + + // Warning + if (!std::numeric_limits::is_signed) { + if ((mInterpolatorName == "bspline") || (mInterpolatorName == "blut")) { + std::cerr << "Warning : input pixel type is not signed, use bspline interpolation at your own risk ..." << std::endl; + } + } + + // Check options + if (mOutputSize.size() != dim) { + std::cerr << "Please set size with " << dim << " dimensions." << std::endl; + return; + } + if (mOutputSpacing.size() != dim) { + std::cerr << "Please set spacing with " << dim << " dimensions." << std::endl; + return; + } + mOutputOrigin.resize(dim); + + if (mApplyGaussianFilterBefore && mSigma.size() != dim) { + std::cerr << "Please set sigma with " << dim << " dimensions." << std::endl; + return; + } + + // Create Image Filter + typedef itk::ResampleImageFilter FilterType; + typename FilterType::Pointer filter = FilterType::New(); + + // Instance of the transform object to be passed to the resample + // filter. By default, identity transform is applied + typedef itk::AffineTransform TransformType; + typename TransformType::Pointer transform = TransformType::New(); + filter->SetTransform(transform); + + // Set filter's parameters + SizeType outputSize; + SpacingType outputSpacing; + PointType outputOrigin; + for(unsigned int i=0; iGetOrigin()[i]; + } + + filter->SetSize(outputSize); + filter->SetOutputSpacing(outputSpacing); + filter->SetOutputOrigin(outputOrigin); + filter->SetDefaultPixelValue(static_cast(mDefaultPixelValue));//DS TODO//JV comme ça? + + // Select interpolator + if (mInterpolatorName == "nn") { + typedef itk::NearestNeighborInterpolateImageFunction InterpolatorType; + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator(interpolator); + } + else { + if (mInterpolatorName == "linear") { + typedef itk::LinearInterpolateImageFunction InterpolatorType; + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator(interpolator); + } + else { + if (mInterpolatorName == "bspline") { + typedef itk::BSplineInterpolateImageFunction InterpolatorType; + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + interpolator->SetSplineOrder(mBSplineOrder); + filter->SetInterpolator(interpolator); + } + else { + if (mInterpolatorName == "blut") { + typedef itk::BSplineInterpolateImageFunctionWithLUT InterpolatorType; + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + interpolator->SetSplineOrder(mBSplineOrder); + interpolator->SetLUTSamplingFactor(mSamplingFactors[0]); + filter->SetInterpolator(interpolator); + } + else { + std::cerr << "Sorry, I do not know the interpolator '" << mInterpolatorName + << "'. Known interpolators are : nn, linear, bspline, blut" << std::endl; + exit(0); + } + } + } + } + + // Build initial Gaussian bluring (if needed) + typedef itk::RecursiveGaussianImageFilter GaussianFilterType; + std::vector gaussianFilters; + if (mApplyGaussianFilterBefore) { + for(unsigned int i=0; iSetDirection(i); + gaussianFilters[i]->SetOrder(GaussianFilterType::ZeroOrder); + gaussianFilters[i]->SetNormalizeAcrossScale(false); + gaussianFilters[i]->SetSigma(mSigma[i]); // in millimeter ! + // Set input + if (i==0) gaussianFilters[i]->SetInput(input); + else gaussianFilters[i]->SetInput(gaussianFilters[i-1]->GetOutput()); + } + filter->SetInput(gaussianFilters[InputImageType::ImageDimension-1]->GetOutput()); + } + else { + filter->SetInput(input); + } + + // Go ! + try { + filter->Update(); + } + catch( itk::ExceptionObject & err ) { + std::cerr << "Error while filtering " << mInputFilenames[0].c_str() + << " " << err << std::endl; + exit(0); + } + + // Get result + typename InputImageType::Pointer outputImage = filter->GetOutput(); + + // Write/save results + this->SetNextOutput(outputImage); - std::cerr << "Error, dimension of input image is " << mDim << ", but I only work with 2,3,4." << std::endl; - exit(0); } //-------------------------------------------------------------------- + //-------------------------------------------------------------------- void clitk::ImageResampleGenericFilter::SetOutputSize(const std::vector & size) { mOutputSize.resize(size.size()); diff --git a/filters/clitkImageResampleGenericFilter.h b/filters/clitkImageResampleGenericFilter.h index d4ccc1f..5bd8972 100644 --- a/filters/clitkImageResampleGenericFilter.h +++ b/filters/clitkImageResampleGenericFilter.h @@ -32,7 +32,8 @@ namespace clitk { //-------------------------------------------------------------------- - class ImageResampleGenericFilter: public clitk::ImageToImageGenericFilter { + class ImageResampleGenericFilter: + public ImageToImageGenericFilter { public: // constructor @@ -40,7 +41,6 @@ namespace clitk { // Types typedef ImageResampleGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -55,7 +55,8 @@ namespace clitk { void SetBSplineOrder(int o) { mBSplineOrder = o; } void SetBLUTSampling(int b) { mSamplingFactors.resize(1); mSamplingFactors[0] = b; } - void Update(); + //-------------------------------------------------------------------- + template void UpdateWithInputImageType(); protected: //-------------------------------------------------------------------- @@ -70,13 +71,8 @@ namespace clitk { std::vector mSamplingFactors; //-------------------------------------------------------------------- - template void Update_WithDim(); - template void Update_WithDimAndPixelType(); - - //-------------------------------------------------------------------- - template - typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage); - + template void InitializeImageTypeWithDim(); + }; // end class ImageResampleGenericFilter //-------------------------------------------------------------------- diff --git a/filters/clitkImageResampleGenericFilter.txx b/filters/clitkImageResampleGenericFilter.txx index bdc33c0..1a34568 100644 --- a/filters/clitkImageResampleGenericFilter.txx +++ b/filters/clitkImageResampleGenericFilter.txx @@ -12,181 +12,6 @@ * ------------------------------------------------=*/ -//-------------------------------------------------------------------- -template -void ImageResampleGenericFilter::Update_WithDim() { - -#define TRY_TYPE(TYPE) \ - if (IsSameType(mPixelTypeName)) { Update_WithDimAndPixelType(); return; } - TRY_TYPE(signed char); - TRY_TYPE(uchar); - TRY_TYPE(short); - TRY_TYPE(ushort); - TRY_TYPE(int); - TRY_TYPE(unsigned int); - TRY_TYPE(float); - TRY_TYPE(double); -#undef TRY_TYPE - - std::string list = CreateListOfTypes(); - std::cerr << "Error, I don't know the type '" << mPixelTypeName << "' for the input image '" - << mInputFilenames[0] << "'." << std::endl << "Known types are " << list << std::endl; - exit(0); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -void ImageResampleGenericFilter::Update_WithDimAndPixelType() { - // Reading input - typedef itk::Image ImageType; - //typename ImageType::Pointer input = clitk::readImage(mInputFilenames, mIOVerbose); - typename ImageType::Pointer input = this->GetInput(0); - - // Main filter - typename ImageType::Pointer outputImage = ComputeImage(input); - - // Write results - this->SetNextOutput(outputImage); - //clitk::writeImage(outputImage, mOutputFilename, mIOVerbose); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -typename ImageType::Pointer -ImageResampleGenericFilter::ComputeImage(typename ImageType::Pointer inputImage) { - - // Warning - if (!std::numeric_limits::is_signed) { - if ((mInterpolatorName == "bspline") || (mInterpolatorName == "blut")) { - std::cerr << "Warning : input pixel type is not signed, use bspline interpolation at your own risk ..." << std::endl; - } - } - - // Check options - static unsigned int dim = ImageType::ImageDimension; - if (mOutputSize.size() != dim) { - std::cerr << "Please set size with " << dim << " dimensions." << std::endl; - return NULL; - } - if (mOutputSpacing.size() != dim) { - std::cerr << "Please set spacing with " << dim << " dimensions." << std::endl; - return NULL; - } - mOutputOrigin.resize(dim); - - if (mApplyGaussianFilterBefore && mSigma.size() != dim) { - std::cerr << "Please set sigma with " << dim << " dimensions." << std::endl; - return NULL; - } - - // Some typedefs - typedef typename ImageType::SizeType SizeType; - typedef typename ImageType::SpacingType SpacingType; - typedef typename ImageType::PointType PointType; - - - // Create Image Filter - typedef itk::ResampleImageFilter FilterType; - typename FilterType::Pointer filter = FilterType::New(); - - // Instance of the transform object to be passed to the resample - // filter. By default, identity transform is applied - typedef itk::AffineTransform TransformType; - typename TransformType::Pointer transform = TransformType::New(); - filter->SetTransform(transform); - - // Set filter's parameters - SizeType outputSize; - SpacingType outputSpacing; - PointType outputOrigin; - for(unsigned int i=0; iGetOrigin()[i]; - } - - filter->SetSize(outputSize); - filter->SetOutputSpacing(outputSpacing); - filter->SetOutputOrigin(outputOrigin); - filter->SetDefaultPixelValue(static_cast(mDefaultPixelValue));//DS TODO//JV comme ça? - - // Select interpolator - if (mInterpolatorName == "nn") { - typedef itk::NearestNeighborInterpolateImageFunction InterpolatorType; - typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); - filter->SetInterpolator(interpolator); - } - else { - if (mInterpolatorName == "linear") { - typedef itk::LinearInterpolateImageFunction InterpolatorType; - typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); - filter->SetInterpolator(interpolator); - } - else { - if (mInterpolatorName == "bspline") { - typedef itk::BSplineInterpolateImageFunction InterpolatorType; - typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); - interpolator->SetSplineOrder(mBSplineOrder); - filter->SetInterpolator(interpolator); - } - else { - if (mInterpolatorName == "blut") { - typedef itk::BSplineInterpolateImageFunctionWithLUT InterpolatorType; - typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); - interpolator->SetSplineOrder(mBSplineOrder); - interpolator->SetLUTSamplingFactor(mSamplingFactors[0]); - filter->SetInterpolator(interpolator); - } - else { - std::cerr << "Sorry, I do not know the interpolator '" << mInterpolatorName - << "'. Known interpolators are : nn, linear, bspline, blut" << std::endl; - exit(0); - } - } - } - } - - // Build initial Gaussian bluring (if needed) - typedef itk::RecursiveGaussianImageFilter GaussianFilterType; - std::vector gaussianFilters; - if (mApplyGaussianFilterBefore) { - for(unsigned int i=0; iSetDirection(i); - gaussianFilters[i]->SetOrder(GaussianFilterType::ZeroOrder); - gaussianFilters[i]->SetNormalizeAcrossScale(false); - gaussianFilters[i]->SetSigma(mSigma[i]); // in millimeter ! - // Set input - if (i==0) gaussianFilters[i]->SetInput(inputImage); - else gaussianFilters[i]->SetInput(gaussianFilters[i-1]->GetOutput()); - } - filter->SetInput(gaussianFilters[ImageType::ImageDimension-1]->GetOutput()); - } - else { - filter->SetInput(inputImage); - } - - // Go ! - try { - filter->Update(); - } - catch( itk::ExceptionObject & err ) { - std::cerr << "Error while filtering " << mInputFilenames[0].c_str() - << " " << err << std::endl; - exit(0); - } - - // Return result - return filter->GetOutput(); - -} -//-------------------------------------------------------------------- - - #endif /* end #define CLITKIMAGERESAMPLEGENERICFILTER_TXX */ diff --git a/filters/clitkSplitImageGenericFilter.cxx b/filters/clitkSplitImageGenericFilter.cxx index bb46dd9..c74f0e4 100644 --- a/filters/clitkSplitImageGenericFilter.cxx +++ b/filters/clitkSplitImageGenericFilter.cxx @@ -23,27 +23,60 @@ #include "clitkSplitImageGenericFilter.txx" //-------------------------------------------------------------------- -clitk::SplitImageGenericFilter::SplitImageGenericFilter() { +clitk::SplitImageGenericFilter::SplitImageGenericFilter(): + clitk::ImageToImageGenericFilter("SplitImage") { mSplitDimension = 0; + InitializeImageType<3>(); + InitializeImageType<4>(); +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +template +void clitk::SplitImageGenericFilter::InitializeImageType() { + ADD_IMAGE_TYPE(Dim, char); + ADD_IMAGE_TYPE(Dim, short); + ADD_IMAGE_TYPE(Dim, int); + ADD_IMAGE_TYPE(Dim, float); + typedef itk::Vector DVF; + ADD_IMAGE_TYPE(Dim, DVF); } //-------------------------------------------------------------------- //-------------------------------------------------------------------- -void clitk::SplitImageGenericFilter::Update () { - - // Read the Dimension and PixelType - int Dimension, Components; - std::string PixelType; - ReadImageDimensionAndPixelType(this->mInputFilenames[0], Dimension, PixelType, Components); - - - // Call UpdateWithDim - if(Dimension==3) UpdateWithDim<3>(PixelType, Components); - else if (Dimension==4)UpdateWithDim<4>(PixelType, Components); - else - { - std::cout<<"Error, Only for 3 or 4 Dimensions!!!"< +void clitk::SplitImageGenericFilter::UpdateWithInputImageType() { + + // Read input + typedef typename ImageType::PixelType PixelType; + typedef itk::Image OutputImageType; + typename ImageType::Pointer input = this->GetInput(0); + typedef itk::ExtractImageFilter FilterType; + typename FilterType::Pointer filter= FilterType::New(); + + filter->SetInput(input); + typename ImageType::SizeType size=input->GetLargestPossibleRegion().GetSize(); + size[mSplitDimension]=0; + typename ImageType::RegionType extracted_region; + extracted_region.SetSize(size); + filter->SetExtractionRegion(extracted_region); + filter->Update(); + + typename ImageType::IndexType index=input->GetLargestPossibleRegion().GetIndex(); + std::string base_filename=GetOutputFilename(); + unsigned int number_of_output_images=input->GetLargestPossibleRegion().GetSize()[mSplitDimension]; + for (unsigned int i=0;iSetExtractionRegion(extracted_region); + filter->Update(); + SetOutputFilename(base_filename+"_"+ss.str()+".mhd"); + typename OutputImageType::Pointer output=filter->GetOutput(); + SetNextOutput(output); + } } //-------------------------------------------------------------------- diff --git a/filters/clitkSplitImageGenericFilter.h b/filters/clitkSplitImageGenericFilter.h index 8df8a28..359464c 100644 --- a/filters/clitkSplitImageGenericFilter.h +++ b/filters/clitkSplitImageGenericFilter.h @@ -34,7 +34,8 @@ namespace clitk { //-------------------------------------------------------------------- - class SplitImageGenericFilter : public clitk::ImageToImageGenericFilter { + class SplitImageGenericFilter: + public clitk::ImageToImageGenericFilter { public: @@ -42,8 +43,7 @@ namespace clitk { SplitImageGenericFilter (); // Types - typedef SplitImageGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; + typedef SplitImageGenericFilter Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -54,16 +54,15 @@ namespace clitk { void SetSplitDimension (int dim) { mSplitDimension = dim; } void SetVerbose (const bool v) { m_Verbose = v; } - // Update - void Update (); + //-------------------------------------------------------------------- + // Main function called each time the filter is updated + template + void UpdateWithInputImageType(); protected: + template void InitializeImageType(); int mSplitDimension; bool m_Verbose; - //-------------------------------------------------------------------- - template void UpdateWithDim(std::string PixelType, int Components); - template void UpdateWithDimAndPixelType(); - //-------------------------------------------------------------------- }; // end class SplitImageGenericFilter //-------------------------------------------------------------------- diff --git a/filters/clitkSplitImageGenericFilter.txx b/filters/clitkSplitImageGenericFilter.txx index ff7a92e..4b50a91 100644 --- a/filters/clitkSplitImageGenericFilter.txx +++ b/filters/clitkSplitImageGenericFilter.txx @@ -19,83 +19,4 @@ #include -//-------------------------------------------------------------------- -template -void clitk::SplitImageGenericFilter::UpdateWithDim(std::string PixelType, int Components) { - - if (m_Verbose) std::cout << "Image was detected to be "<(); - } - else if(PixelType == "unsigned_short"){ - if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and unsigned_short..." << std::endl; - UpdateWithDimAndPixelType(); - } - - else if (PixelType == "unsigned_char"){ - if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and unsigned_char..." << std::endl; - UpdateWithDimAndPixelType(); - } - - else if (PixelType == "char"){ - if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and signed_char..." << std::endl; - UpdateWithDimAndPixelType(); - } - else { - if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and float..." << std::endl; - UpdateWithDimAndPixelType(); - } - } - - else if (Components==3) - { - if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and 3D float (DVF)" << std::endl; - UpdateWithDimAndPixelType >(); - } - else std::cerr<<"Number of components is "< -void clitk::SplitImageGenericFilter::UpdateWithDimAndPixelType() { - - // Read input - typedef itk::Image ImageType; - typedef itk::Image OutputImageType; - typename ImageType::Pointer input = clitk::readImage(mInputFilenames[0], mIOVerbose); - typedef itk::ExtractImageFilter FilterType; - typename FilterType::Pointer filter= FilterType::New(); - - filter->SetInput(input); - typename ImageType::SizeType size=input->GetLargestPossibleRegion().GetSize(); - size[mSplitDimension]=0; - typename ImageType::RegionType extracted_region; - extracted_region.SetSize(size); - filter->SetExtractionRegion(extracted_region); - filter->Update(); - - typename ImageType::IndexType index=input->GetLargestPossibleRegion().GetIndex(); - std::string base_filename=GetOutputFilename(); - unsigned int number_of_output_images=input->GetLargestPossibleRegion().GetSize()[mSplitDimension]; - for (unsigned int i=0;iSetExtractionRegion(extracted_region); - filter->Update(); - SetOutputFilename(base_filename+"_"+ss.str()+".mhd"); - typename OutputImageType::Pointer output=filter->GetOutput(); - SetNextOutput(output); - } -} -//-------------------------------------------------------------------- - #endif //#define clitkSplitImageGenericFilter_TXX diff --git a/filters/clitkVFResampleGenericFilter.cxx b/filters/clitkVFResampleGenericFilter.cxx index 9eb995b..f335415 100644 --- a/filters/clitkVFResampleGenericFilter.cxx +++ b/filters/clitkVFResampleGenericFilter.cxx @@ -14,7 +14,11 @@ #include "clitkVFResampleGenericFilter.h" //-------------------------------------------------------------------- -clitk::VFResampleGenericFilter::VFResampleGenericFilter() { +clitk::VFResampleGenericFilter::VFResampleGenericFilter(): + clitk::ImageToImageGenericFilter("VFResample") { + InitializeImageType<2>(); + InitializeImageType<3>(); + InitializeImageType<4>(); mApplyGaussianFilterBefore = false; mDefaultPixelValue = 0.0; mInterpolatorName = "NN"; @@ -22,26 +26,158 @@ clitk::VFResampleGenericFilter::VFResampleGenericFilter() { } //-------------------------------------------------------------------- + +//-------------------------------------------------------------------- +template +void clitk::VFResampleGenericFilter::InitializeImageType() { + ADD_IMAGE_TYPE(Dim, float); +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +template +void clitk::VFResampleGenericFilter::UpdateWithInputImageType() { + + if (mNbOfComponents == 1) { + std::cerr << "Error, only one components ? Use clitkImageResample instead." << std::endl; + exit(0); + } + typedef typename ImageType::PixelType PixelType; + if (mNbOfComponents == 2) Update_WithDimAndPixelTypeAndComponent(); + if (mNbOfComponents == 3) Update_WithDimAndPixelTypeAndComponent(); + if (mNbOfComponents == 4) Update_WithDimAndPixelTypeAndComponent(); +} +//-------------------------------------------------------------------- + + +//-------------------------------------------------------------------- +template +void clitk::VFResampleGenericFilter::Update_WithDimAndPixelTypeAndComponent() { + // Reading input + typedef itk::Vector DisplacementType; + typedef itk::Image< DisplacementType, Dim > ImageType; + + typename ImageType::Pointer input = clitk::readImage(mInputFilenames, mIOVerbose); + + // Main filter + typename ImageType::Pointer outputImage = ComputeImage(input); + + // Write results + SetNextOutput(outputImage); +} +//-------------------------------------------------------------------- + //-------------------------------------------------------------------- -void clitk::VFResampleGenericFilter::Update() { - // Load image header - itk::ImageIOBase::Pointer header = clitk::readImageHeader(mInputFilenames[0]); +template +typename ImageType::Pointer +clitk::VFResampleGenericFilter::ComputeImage(typename ImageType::Pointer inputImage) { + + // Check options + static unsigned int dim = ImageType::ImageDimension; + if (mOutputSize.size() != dim) { + std::cerr << "Please set size with " << dim << " dimensions." << std::endl; + return NULL; + } + if (mOutputSpacing.size() != dim) { + std::cerr << "Please set spacing with " << dim << " dimensions." << std::endl; + return NULL; + } + mOutputOrigin.resize(dim); + + if (mApplyGaussianFilterBefore && mSigma.size() != dim) { + std::cerr << "Please set sigma with " << dim << " dimensions." << std::endl; + return NULL; + } + + // Some typedefs + typedef typename ImageType::SizeType SizeType; + typedef typename ImageType::SpacingType SpacingType; + typedef typename ImageType::PointType PointType; + + // Create Image Filter + typedef itk::VectorResampleImageFilter FilterType; + typename FilterType::Pointer filter = FilterType::New(); + + // Instance of the transform object to be passed to the resample + // filter. By default, identity transform is applied + typedef itk::AffineTransform TransformType; + typename TransformType::Pointer transform = TransformType::New(); + filter->SetTransform(transform); + + // Set filter's parameters + SizeType outputSize; + SpacingType outputSpacing; + PointType outputOrigin; + for(unsigned int i=0; iGetOrigin()[i]; + } + + filter->SetSize(outputSize); + filter->SetOutputSpacing(outputSpacing); + filter->SetOutputOrigin(outputOrigin); + filter->SetDefaultPixelValue(static_cast(mDefaultPixelValue)); + + // Select interpolator + if (mInterpolatorName == "nn") { + typedef itk::VectorNearestNeighborInterpolateImageFunction InterpolatorType; + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator(interpolator); + } + else { + if (mInterpolatorName == "linear") { + typedef itk::VectorLinearInterpolateImageFunction InterpolatorType; + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator(interpolator); + } + else { + std::cerr << "Sorry, I do not know the interpolator (for vector field) '" << mInterpolatorName + << "'. Known interpolators are : nn, linear" << std::endl; + exit(0); + } + } + + // Build initial Gaussian bluring (if needed) + typedef itk::RecursiveGaussianImageFilter GaussianFilterType; + std::vector gaussianFilters; + if (mApplyGaussianFilterBefore) { + for(unsigned int i=0; iSetDirection(i); + gaussianFilters[i]->SetOrder(GaussianFilterType::ZeroOrder); + gaussianFilters[i]->SetNormalizeAcrossScale(false); + gaussianFilters[i]->SetSigma(mSigma[i]); // in millimeter ! + // Set input + if (i==0) gaussianFilters[i]->SetInput(inputImage); + else gaussianFilters[i]->SetInput(gaussianFilters[i-1]->GetOutput()); + } + filter->SetInput(gaussianFilters[ImageType::ImageDimension-1]->GetOutput()); + } + else { + filter->SetInput(inputImage); + } + + // Go ! + try { + filter->Update(); + } + catch( itk::ExceptionObject & err ) { + std::cerr << "Error while filtering " << mInputFilenames[0].c_str() + << " " << err << std::endl; + exit(0); + } + + // Return result + return filter->GetOutput(); - // Determine dim, pixel type, number of components - mDim = header->GetNumberOfDimensions(); - mPixelTypeName = header->GetComponentTypeAsString(header->GetComponentType()); - mNbOfComponents = header->GetNumberOfComponents(); - - // Switch by dimension - if (mDim == 2) { Update_WithDim<2>(); return; } - if (mDim == 3) { Update_WithDim<3>(); return; } - if (mDim == 4) { Update_WithDim<4>(); return; } - - std::cerr << "Error, dimension of input image is " << mDim << ", but I only work with 2,3,4." << std::endl; - exit(0); } //-------------------------------------------------------------------- + //-------------------------------------------------------------------- void clitk::VFResampleGenericFilter::SetOutputSize(const std::vector & size) { mOutputSize.resize(size.size()); diff --git a/filters/clitkVFResampleGenericFilter.h b/filters/clitkVFResampleGenericFilter.h index b1c4568..9eac9f1 100644 --- a/filters/clitkVFResampleGenericFilter.h +++ b/filters/clitkVFResampleGenericFilter.h @@ -34,15 +34,15 @@ namespace clitk { //-------------------------------------------------------------------- - class VFResampleGenericFilter: public clitk::ImageToImageGenericFilter { + class VFResampleGenericFilter: + public clitk::ImageToImageGenericFilter { public: // constructor VFResampleGenericFilter(); // Types - typedef VFResampleGenericFilter Self; - typedef ImageToImageGenericFilter Superclass; + typedef VFResampleGenericFilter Self; typedef itk::SmartPointer Pointer; typedef itk::SmartPointer ConstPointer; @@ -57,9 +57,13 @@ namespace clitk { void SetBSplineOrder(int o) { mBSplineOrder = o; } void SetBLUTSampling(int b) { mSamplingFactors.resize(1); mSamplingFactors[0] = b; } - void Update(); + //-------------------------------------------------------------------- + // Main function called each time the filter is updated + template + void UpdateWithInputImageType(); protected: + template void InitializeImageType(); //-------------------------------------------------------------------- std::string mInterpolatorName; std::vector mOutputSize; @@ -72,12 +76,8 @@ namespace clitk { std::vector mSamplingFactors; //-------------------------------------------------------------------- - template void Update_WithDim(); - template void Update_WithDimAndPixelType(); template void Update_WithDimAndPixelTypeAndComponent(); - - //-------------------------------------------------------------------- template typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage); diff --git a/filters/clitkVFResampleGenericFilter.txx b/filters/clitkVFResampleGenericFilter.txx index 98f3c06..20f330e 100644 --- a/filters/clitkVFResampleGenericFilter.txx +++ b/filters/clitkVFResampleGenericFilter.txx @@ -13,160 +13,6 @@ ------------------------------------------------=*/ //-------------------------------------------------------------------- -template -void VFResampleGenericFilter::Update_WithDim() { -#define TRY_TYPE(TYPE) \ - if (IsSameType(mPixelTypeName)) { Update_WithDimAndPixelType(); return; } - TRY_TYPE(float); -#undef TRY_TYPE - std::string list = CreateListOfTypes(); - std::cerr << "Error, I don't know the type '" << mPixelTypeName << "' for the input image '" - << mInputFilenames[0] << "'." << std::endl << "Known types are " << list << std::endl; - exit(0); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -void VFResampleGenericFilter::Update_WithDimAndPixelType() { - - if (mNbOfComponents == 1) { - std::cerr << "Error, only one components ? Use clitkImageResample instead." << std::endl; - exit(0); - } - if (mNbOfComponents == 2) Update_WithDimAndPixelTypeAndComponent(); - if (mNbOfComponents == 3) Update_WithDimAndPixelTypeAndComponent(); - if (mNbOfComponents == 4) Update_WithDimAndPixelTypeAndComponent(); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -void VFResampleGenericFilter::Update_WithDimAndPixelTypeAndComponent() { - // Reading input - typedef itk::Vector DisplacementType; - typedef itk::Image< DisplacementType, Dim > ImageType; - - typename ImageType::Pointer input = clitk::readImage(mInputFilenames, mIOVerbose); - - // Main filter - typename ImageType::Pointer outputImage = ComputeImage(input); - - // Write results - SetNextOutput(outputImage); -} -//-------------------------------------------------------------------- - -//-------------------------------------------------------------------- -template -typename ImageType::Pointer -VFResampleGenericFilter::ComputeImage(typename ImageType::Pointer inputImage) { - - // Check options - static unsigned int dim = ImageType::ImageDimension; - if (mOutputSize.size() != dim) { - std::cerr << "Please set size with " << dim << " dimensions." << std::endl; - return NULL; - } - if (mOutputSpacing.size() != dim) { - std::cerr << "Please set spacing with " << dim << " dimensions." << std::endl; - return NULL; - } - mOutputOrigin.resize(dim); - - if (mApplyGaussianFilterBefore && mSigma.size() != dim) { - std::cerr << "Please set sigma with " << dim << " dimensions." << std::endl; - return NULL; - } - - // Some typedefs - typedef typename ImageType::SizeType SizeType; - typedef typename ImageType::SpacingType SpacingType; - typedef typename ImageType::PointType PointType; - - // Create Image Filter - typedef itk::VectorResampleImageFilter FilterType; - typename FilterType::Pointer filter = FilterType::New(); - - // Instance of the transform object to be passed to the resample - // filter. By default, identity transform is applied - typedef itk::AffineTransform TransformType; - typename TransformType::Pointer transform = TransformType::New(); - filter->SetTransform(transform); - - // Set filter's parameters - SizeType outputSize; - SpacingType outputSpacing; - PointType outputOrigin; - for(unsigned int i=0; iGetOrigin()[i]; - } - - filter->SetSize(outputSize); - filter->SetOutputSpacing(outputSpacing); - filter->SetOutputOrigin(outputOrigin); - filter->SetDefaultPixelValue(static_cast(mDefaultPixelValue)); - - // Select interpolator - if (mInterpolatorName == "nn") { - typedef itk::VectorNearestNeighborInterpolateImageFunction InterpolatorType; - typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); - filter->SetInterpolator(interpolator); - } - else { - if (mInterpolatorName == "linear") { - typedef itk::VectorLinearInterpolateImageFunction InterpolatorType; - typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); - filter->SetInterpolator(interpolator); - } - else { - std::cerr << "Sorry, I do not know the interpolator (for vector field) '" << mInterpolatorName - << "'. Known interpolators are : nn, linear" << std::endl; - exit(0); - } - } - - // Build initial Gaussian bluring (if needed) - typedef itk::RecursiveGaussianImageFilter GaussianFilterType; - std::vector gaussianFilters; - if (mApplyGaussianFilterBefore) { - for(unsigned int i=0; iSetDirection(i); - gaussianFilters[i]->SetOrder(GaussianFilterType::ZeroOrder); - gaussianFilters[i]->SetNormalizeAcrossScale(false); - gaussianFilters[i]->SetSigma(mSigma[i]); // in millimeter ! - // Set input - if (i==0) gaussianFilters[i]->SetInput(inputImage); - else gaussianFilters[i]->SetInput(gaussianFilters[i-1]->GetOutput()); - } - filter->SetInput(gaussianFilters[ImageType::ImageDimension-1]->GetOutput()); - } - else { - filter->SetInput(inputImage); - } - - // Go ! - try { - filter->Update(); - } - catch( itk::ExceptionObject & err ) { - std::cerr << "Error while filtering " << mInputFilenames[0].c_str() - << " " << err << std::endl; - exit(0); - } - - // Return result - return filter->GetOutput(); - -} -//-------------------------------------------------------------------- - - #endif /* end #define CLITKVFRESAMPLEGENERICFILTER_TXX */ diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt index a1a6f92..ef6e50d 100644 --- a/tools/CMakeLists.txt +++ b/tools/CMakeLists.txt @@ -3,6 +3,13 @@ INCLUDE(${PROJECT_SOURCE_DIR}/cmake/common.cmake) #========================================================= +SET(clitkGGO_SRC + clitkImageResample_ggo.c + clitkBinarizeImage_ggo.c + ) + +ADD_LIBRARY(clitkGGO STATIC ${clitkGGO_SRC}) + ADD_EXECUTABLE(clitkDicomInfo clitkDicomInfo.cxx clitkDicomInfo_ggo.c) TARGET_LINK_LIBRARIES(clitkDicomInfo ITKIO clitkCommon) @@ -76,3 +83,6 @@ ADD_EXECUTABLE(clitkGuerreroVentilation clitkGuerreroVentilation.cxx ) TARGET_LINK_LIBRARIES(clitkGuerreroVentilation clitkCommon ITKIO ITKBasicFilters clitkFilters) + +ADD_EXECUTABLE(clitkBinarizeImage clitkBinarizeImage.cxx clitkBinarizeImage_ggo.c) +TARGET_LINK_LIBRARIES(clitkBinarizeImage ITKIO clitkCommon) diff --git a/tools/clitkAffineTransform.cxx b/tools/clitkAffineTransform.cxx index 3717b6b..0ca81d4 100644 --- a/tools/clitkAffineTransform.cxx +++ b/tools/clitkAffineTransform.cxx @@ -33,7 +33,7 @@ int main(int argc, char * argv[]) { CLITK_INIT; // Filter - typedef clitk::AffineTransformGenericFilter FilterType; + typedef clitk::AffineTransformGenericFilter FilterType; FilterType::Pointer genericFilter = FilterType::New(); genericFilter->SetArgsInfo(args_info); diff --git a/tools/clitkAverageTemporalDimension.cxx b/tools/clitkAverageTemporalDimension.cxx index fb50ce3..14f2d08 100644 --- a/tools/clitkAverageTemporalDimension.cxx +++ b/tools/clitkAverageTemporalDimension.cxx @@ -34,7 +34,7 @@ int main(int argc, char * argv[]) { CLITK_INIT; // Filter - typedef clitk::AverageTemporalDimensionGenericFilter FilterType; + typedef clitk::AverageTemporalDimensionGenericFilter FilterType; FilterType::Pointer genericFilter = FilterType::New(); genericFilter->SetArgsInfo(args_info); diff --git a/tools/clitkInvertVF.cxx b/tools/clitkInvertVF.cxx index 2360adf..1f13867 100644 --- a/tools/clitkInvertVF.cxx +++ b/tools/clitkInvertVF.cxx @@ -34,7 +34,7 @@ int main(int argc, char * argv[]) { CLITK_INIT; // Filter - typedef clitk::InvertVFGenericFilter FilterType; + typedef clitk::InvertVFGenericFilter FilterType; FilterType::Pointer genericFilter = FilterType::New(); genericFilter->SetArgsInfo(args_info); diff --git a/tools/clitkSetBackgroundGenericFilter.h b/tools/clitkSetBackgroundGenericFilter.h index 266fcf2..50afb61 100644 --- a/tools/clitkSetBackgroundGenericFilter.h +++ b/tools/clitkSetBackgroundGenericFilter.h @@ -50,7 +50,7 @@ namespace clitk //---------------------------------------- // Set & Get //---------------------------------------- - void SetArgsInfo(const gengetopt_args_info_clitkSetBackground & a) + void SetArgsInfo(const args_info_clitkSetBackground & a) { m_ArgsInfo=a; m_Verbose=m_ArgsInfo.verbose_flag; @@ -82,7 +82,7 @@ namespace clitk //---------------------------------------- // Data members //---------------------------------------- - gengetopt_args_info_clitkSetBackground m_ArgsInfo; + args_info_clitkSetBackground m_ArgsInfo; bool m_Verbose; std::string m_InputFileName; diff --git a/tools/clitkSignalMeanPositionFilter.cxx b/tools/clitkSignalMeanPositionFilter.cxx index f4ec04c..912d9ee 100644 --- a/tools/clitkSignalMeanPositionFilter.cxx +++ b/tools/clitkSignalMeanPositionFilter.cxx @@ -16,7 +16,7 @@ #include "clitkSignalMeanPositionFilter.h" //--------------------------------------------------------------------- -void clitk::SignalMeanPositionFilter::SetParameters(gengetopt_args_info_clitkSignalMeanPositionTracking & args) { +void clitk::SignalMeanPositionFilter::SetParameters(args_info_clitkSignalMeanPositionTracking & args) { args_info = args; mEtaIsSet = false; mOutputFilenameIsSet = false; diff --git a/tools/clitkSignalMeanPositionFilter.h b/tools/clitkSignalMeanPositionFilter.h index 1f7f5d6..4cbc4f0 100644 --- a/tools/clitkSignalMeanPositionFilter.h +++ b/tools/clitkSignalMeanPositionFilter.h @@ -28,11 +28,11 @@ namespace clitk { public: typedef itk::Vector Vector2d; - void SetParameters(gengetopt_args_info_clitkSignalMeanPositionTracking & args_info); + void SetParameters(args_info_clitkSignalMeanPositionTracking & args_info); void Update(); protected: - gengetopt_args_info_clitkSignalMeanPositionTracking args_info; + args_info_clitkSignalMeanPositionTracking args_info; clitk::Signal mInput; clitk::Signal mAugmentedInputX; clitk::Signal mAugmentedInputY; diff --git a/tools/clitkWarpImageGenericFilter.h b/tools/clitkWarpImageGenericFilter.h index 90a3665..c6a30dc 100644 --- a/tools/clitkWarpImageGenericFilter.h +++ b/tools/clitkWarpImageGenericFilter.h @@ -54,7 +54,7 @@ namespace clitk //---------------------------------------- // Set & Get //---------------------------------------- - void SetArgsInfo(const gengetopt_args_info_clitkWarpImage & a) + void SetArgsInfo(const args_info_clitkWarpImage & a) { m_ArgsInfo=a; m_Verbose=m_ArgsInfo.verbose_flag; @@ -86,7 +86,7 @@ namespace clitk //---------------------------------------- // Data members //---------------------------------------- - gengetopt_args_info_clitkWarpImage m_ArgsInfo; + args_info_clitkWarpImage m_ArgsInfo; bool m_Verbose; std::string m_InputFileName; diff --git a/tools/clitkWarpImageGenericFilter.txx b/tools/clitkWarpImageGenericFilter.txx index 6b33824..425368d 100644 --- a/tools/clitkWarpImageGenericFilter.txx +++ b/tools/clitkWarpImageGenericFilter.txx @@ -78,7 +78,7 @@ namespace clitk typename DeformationFieldType::Pointer deformationField =deformationFieldReader->GetOutput(); // Intensity interpolator - typedef clitk::GenericVectorInterpolator GenericInterpolatorType; + typedef clitk::GenericVectorInterpolator GenericInterpolatorType; typename GenericInterpolatorType::Pointer genericInterpolator=GenericInterpolatorType::New(); genericInterpolator->SetArgsInfo(m_ArgsInfo); @@ -94,7 +94,7 @@ namespace clitk newSize[i]=(unsigned int) (input->GetLargestPossibleRegion().GetSize()[i]*input->GetSpacing()[i]/deformationField->GetSpacing()[i]); // Get the interpolator - typedef clitk::GenericVectorInterpolator GenericInterpolatorType; + typedef clitk::GenericVectorInterpolator GenericInterpolatorType; typename GenericInterpolatorType::Pointer genericInterpolator=GenericInterpolatorType::New(); genericInterpolator->SetArgsInfo(m_ArgsInfo); @@ -174,7 +174,7 @@ namespace clitk else { // Get the interpolator - typedef clitk::GenericInterpolator GenericInterpolatorType; + typedef clitk::GenericInterpolator GenericInterpolatorType; typename GenericInterpolatorType::Pointer genericInterpolator=GenericInterpolatorType::New(); genericInterpolator->SetArgsInfo(m_ArgsInfo); diff --git a/tools/clitkWriteDicomSeries.cxx b/tools/clitkWriteDicomSeries.cxx index 840c74e..0b74591 100644 --- a/tools/clitkWriteDicomSeries.cxx +++ b/tools/clitkWriteDicomSeries.cxx @@ -34,7 +34,7 @@ int main(int argc, char * argv[]) { CLITK_INIT; // Filter - typedef clitk::WriteDicomSeriesGenericFilter FilterType; + typedef clitk::WriteDicomSeriesGenericFilter FilterType; FilterType::Pointer genericFilter = FilterType::New(); genericFilter->SetArgsInfo(args_info); -- 2.46.1