//--------------------------------------------------------------------
// 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);
#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<unsigned int>::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<std::string>::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<std::string> & filenames) {
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::SetInputFilenames(const std::vector<std::string> & 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<std::string> 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<std::string> & filenames)
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::SetOutputFilenames(const std::vector<std::string> & 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<vvImage::Pointer> clitk::ImageToImageGenericFilter::GetOutputVVImages()
+//--------------------------------------------------------------------
+std::vector<vvImage::Pointer> 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<vvImage::Pointer> input)
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::SetInputVVImages (std::vector<vvImage::Pointer> 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<mListOfAllowedDimension.size())) {
+ b = (mListOfAllowedDimension[i] == d);
+ i++;
+ }
+ return b;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+bool clitk::ImageToImageGenericFilterBase::CheckPixelType(std::string pt) {
+ bool b = false;
+ unsigned int i=0;
+ while ((!b) && (i<mListOfAllowedPixelType.size())) {
+ b = (mListOfAllowedPixelType[i] == pt);
+ i++;
+ }
+ return b;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+bool clitk::ImageToImageGenericFilterBase::CheckDimension() {
+ return CheckDimension(mDim);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+bool clitk::ImageToImageGenericFilterBase::CheckPixelType() {
+ return CheckPixelType(mPixelTypeName);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::PrintAvailableImageTypes() {
+ std::cout << "The filter <" << mFilterName << "> manages ";
+ for(unsigned int i=0; i<mListOfAllowedDimension.size(); i++) {
+ std::cout << mListOfAllowedDimension[i] << "D ";
+ }
+ std::cout << "images, with pixel types: ";
+ for(unsigned int i=0; i<mListOfAllowedPixelType.size(); i++) {
+ std::cout << mListOfAllowedPixelType[i] << " ";
+ }
+ std::cout << std::endl;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::ImageTypeError() {
+ std::cerr << "**Error** The filter <" << mFilterName << "> 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<mListOfAllowedDimension.size(); i++) {
+ std::cerr << mListOfAllowedDimension[i] << " ";
+ }
+ std::cerr << std::endl << "**Error** Allowed pixel types: \t";
+ for(unsigned int i=0; i<mListOfAllowedPixelType.size(); i++) {
+ std::cerr << mListOfAllowedPixelType[i] << " ";
+ }
+ std::cerr << std::endl;
+ exit(0);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::SetImageTypeError() {
+ std::cerr << "TODO ! " << std::endl;
+ exit(0);
+}
+//--------------------------------------------------------------------
-#ifndef CLITKIMAGETOIMAGEGENERICFILTER_H
-#define CLITKIMAGETOIMAGEGENERICFILTER_H
+/*=========================================================================
+
+ Program: clitk
+ Module: $RCSfile: clitkImageToImageGenericFilter.h,v $
+ Language: C++
+ Date: $Date: 2010/01/29 07:27:31 $
+ Version: $Revision: 1.2 $
+ Author : Joel Schaerer <joel.schaerer@creatis.insa-lyon.fr>
+ David Sarrut <david.sarrut@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
-/**
- ===================================================================
- * @file clitkImageToImageGenericFilter.h
- * @author David Sarrut <David.Sarrut@creatis.insa-lyon.fr>
- * @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 <http://www.gnu.org/licenses/>.
+
+ =========================================================================*/
+
+#ifndef CLITKIMAGETOIMAGEGENERICFILTER_H
+#define CLITKIMAGETOIMAGEGENERICFILTER_H
// clitk include
#include "clitkCommon.h"
#include "clitkImageCommon.h"
+#include "clitkCommonGenericFilter.h"
#include <itkImage.h>
+// vv include
#include <vvImage.h>
#include <vvFromITK.h>
#include <vvToITK.h>
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<Self> Pointer;
typedef itk::SmartPointer<const Self> 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);
vvImage::Pointer GetOutputVVImage ();
std::vector<vvImage::Pointer> 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<class ImageType>
- 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<class ImageType>
- typename ImageType::Pointer GetInput(unsigned int n);
+ typename ImageType::Pointer GetInput(unsigned int n);
std::vector<std::string> mInputFilenames;
std::list<std::string> mOutputFilenames;
unsigned int mDim;
std::string mPixelTypeName;
unsigned int mNbOfComponents;
+ std::string mFilterName;
std::vector<vvImage::Pointer> mInputVVImages;
std::vector<vvImage::Pointer> mOutputVVImages;
+ std::vector<std::string> mListOfAllowedPixelType;
+ std::vector<unsigned int> mListOfAllowedDimension;
+ bool CheckImageType();
+ bool CheckDimension();
+ bool CheckPixelType();
+ void ImageTypeError();
+ void SetImageTypeError();
+ bool mFailOnImageTypeError;
+
}; // end class clitk::ImageToImageGenericFilter
+
+ //--------------------------------------------------------------------
+ template<class FilterType>
+ class ImageToImageGenericFilter: public ImageToImageGenericFilterBase {
+
+ public:
+
+ typedef ImageToImageGenericFilter<FilterType> 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<FilterType> * mImageTypesManager;
+
+ }; // end class clitk::ImageToImageGenericFilter
+
+ // #define ADD_IMAGE_DIMENSION(DIM) Initialize<DIM>();
+
+#define ADD_IMAGE_TYPE(DIM, PT) this->mImageTypesManager->template AddNewDimensionAndPixelType<DIM, PT>();
+
+
+#include "clitkImageToImageGenericFilter.txx"
+
} // end namespace
-template<class ImageType>
-void clitk::ImageToImageGenericFilter::SetNextOutput(typename ImageType::Pointer output)
-{
- if (mOutputFilenames.size())
- {
- clitk::writeImage<ImageType>(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<ImageType::ImageDimension,typename ImageType::PixelType>(output));
-}
-template<class ImageType>
-typename ImageType::Pointer clitk::ImageToImageGenericFilter::GetInput(unsigned int n)
-{
- if (mInputFilenames.size() > n)
- return clitk::readImage<ImageType>(mInputFilenames[n], mIOVerbose);
- else if (mInputVVImages.size() > n)
- return typename ImageType::Pointer(const_cast<ImageType*>(vvImageToITK<ImageType>(mInputVVImages[n]).GetPointer()));
- else
- assert(false); //No input, this shouldn't happen
-}
#endif /* end #define CLITKIMAGETOIMAGEGENERICFILTER_H */
#ifndef VVIMAGE_CXX
#define VVIMAGE_CXX
-/*=========================================================================
+/*-------------------------------------------------------------------------
Program: vv
Language: C++
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
-=========================================================================*/
+-------------------------------------------------------------------------*/
#include "vvImage.h"
#include "vtkImageData.h"
#include "clitkCommon.h"
#include <cassert>
-//====================================================================
+//--------------------------------------------------------------------
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<vtkImageData*> images) {
for (unsigned int i = 0; i < mVtkImages.size(); i++) {
if (mVtkImages[i] != NULL)
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)
}
mVtkImages.resize(0);
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
int vvImage::GetNumberOfSpatialDimensions() {
int dim=GetNumberOfDimensions();
if (IsTimeSequence())
else
return dim;
}
-//====================================================================
+//--------------------------------------------------------------------
//
-//====================================================================
+//--------------------------------------------------------------------
int vvImage::GetNumberOfDimensions() const {
if (mVtkImages.size())
{
}
return 0;
}
-//====================================================================
+//--------------------------------------------------------------------
void vvImage::GetScalarRange(double* range)
{
assert(mVtkImages.size());
}
}
-//====================================================================
+//--------------------------------------------------------------------
std::string vvImage::GetScalarTypeAsString() {
return mVtkImages[0]->GetScalarTypeAsString();
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
int vvImage::GetNumberOfScalarComponents() {
return mVtkImages[0]->GetNumberOfScalarComponents();
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
int vvImage::GetScalarSize() {
return mVtkImages[0]->GetScalarSize();
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
std::vector<double> vvImage::GetSpacing() {
std::vector<double> spacing;
int dim = this->GetNumberOfDimensions();
}
return spacing;
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
std::vector<double> vvImage::GetOrigin() const {
std::vector<double> origin;
int dim = this->GetNumberOfDimensions();
}
return origin;
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
std::vector<int> vvImage::GetSize() {
std::vector<int> size0;
int dim = this->GetNumberOfDimensions();
}
return size0;
}
-//====================================================================
+//--------------------------------------------------------------------
-//====================================================================
+//--------------------------------------------------------------------
unsigned long vvImage::GetActualMemorySize() {
unsigned long size = 0;
for (unsigned int i = 0; i < mVtkImages.size(); i++) {
}
return size;
}
-//====================================================================
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+bool vvImage::IsTimeSequence() {
+ return mVtkImages.size()>1;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+const std::vector<vtkImageData*>& 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
/*=========================================================================
- 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 <http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
-=========================================================================*/
-#ifndef vvImage_h
-#define vvImage_h
+ =========================================================================*/
+#ifndef VVIMAGE_H
+#define VVIMAGE_H
#include <iostream>
#include <vector>
class vtkImageData;
-class vvImage : public itk::LightObject
-{
+class vvImage : public itk::LightObject {
public :
- typedef vvImage Self;
- typedef itk::SmartPointer<Self> Pointer;
- itkNewMacro(Self);
+ typedef vvImage Self;
+ typedef itk::SmartPointer<Self> Pointer;
+ itkNewMacro(Self);
- void Init();
- void SetImage(std::vector<vtkImageData*> images);
- void AddImage(vtkImageData* image);
- const std::vector<vtkImageData*>& 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<double> GetSpacing();
- std::vector<double> GetOrigin() const;
- std::vector<int> GetSize();
- std::string GetScalarTypeAsString();
- int GetNumberOfScalarComponents();
- int GetScalarSize();
- bool IsTimeSequence() {
- return mVtkImages.size()>1;
- }
+ void Init();
+ void SetImage(std::vector<vtkImageData*> images);
+ void AddImage(vtkImageData* image);
+ const std::vector<vtkImageData*>& 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<double> GetSpacing();
+ std::vector<double> GetOrigin() const;
+ std::vector<int> GetSize();
+ std::string GetScalarTypeAsString();
+ int GetNumberOfScalarComponents();
+ int GetScalarSize();
+ bool IsTimeSequence();
+ bool IsScalarTypeInteger();
+ bool IsScalarTypeInteger(int t);
private:
- vvImage();
- ~vvImage();
- std::vector<vtkImageData*> mVtkImages;
+ vvImage();
+ ~vvImage();
+ std::vector<vtkImageData*> mVtkImages;
};
#=========================================================
# 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})
* @brief
-------------------------------------------------------------------*/
+#include <sstream>
#include "clitkGuerreroVentilationGenericFilter.h"
#include <itkBinaryGuerreroFilter.h>
#include <itkImageDuplicator.h>
-//--------------------------------------------------------------------
-clitk::GuerreroVentilationGenericFilter::GuerreroVentilationGenericFilter()
-{
- blood_mass_factor=1.;
-}
-//--------------------------------------------------------------------
+#include <itkExtractImageFilter.h>
//--------------------------------------------------------------------
-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<Self>("GuerreroVentilationGenericFilter") {
+ blood_mass_factor=1.;
+ InitializeImageType<2>();
+ InitializeImageType<3>();
}
//--------------------------------------------------------------------
-//This is where you put the actual implementation
-
-#include <sstream>
-#include <itkExtractImageFilter.h>
-
-
//--------------------------------------------------------------------
template<unsigned int Dim>
-void clitk::GuerreroVentilationGenericFilter::Update_WithDim() {
-#define TRY_TYPE(TYPE) \
- if (IsSameType<TYPE>(mPixelTypeName)) { Update_WithDimAndPixelType<Dim, TYPE>(); 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<uchar, short, ushort, int, uint, float, double>();
- 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<unsigned int Dim, class PixelType>
-void clitk::GuerreroVentilationGenericFilter::Update_WithDimAndPixelType() {
+template<class ImageType>
+void clitk::GuerreroVentilationGenericFilter::UpdateWithInputImageType() {
- // Read input
+ // Input should be 2
assert(mInputFilenames.size() == 2);
- typedef itk::Image<PixelType,Dim> ImageType;
- typedef itk::Image<float,Dim> OutputImageType;
- typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames[0], mIOVerbose);
- typename ImageType::Pointer ref = clitk::readImage<ImageType>(mInputFilenames[1], mIOVerbose);
+ // Reading input
+ typedef ImageType InputImageType;
+ typename InputImageType::Pointer input = this->template GetInput<InputImageType>(0);
+ typename InputImageType::Pointer ref = this->template GetInput<InputImageType>(1);
+
+ typedef itk::Image<float,InputImageType::ImageDimension> OutputImageType;
+ // typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames[0], mIOVerbose);
+ //typename ImageType::Pointer ref = clitk::readImage<ImageType>(mInputFilenames[1], mIOVerbose);
typedef itk::BinaryGuerreroFilter<ImageType,ImageType,OutputImageType> GFilterType;
typename GFilterType::Pointer filter = GFilterType::New();
filter->SetBloodCorrectionFactor(blood_mass_factor);
filter->SetUseCorrectFormula(use_correct_formula);
filter->Update();
+
this->SetNextOutput<OutputImageType>(filter->GetOutput());
//clitk::writeImage<OutputImageType>(filter->GetOutput(), mOutputFilename, mIOVerbose);
//std::cout << "Warning: removed " << filter->GetFunctor().aberant_voxels << " aberant voxels from the ventilation image"
namespace clitk {
//--------------------------------------------------------------------
- class GuerreroVentilationGenericFilter : public ImageToImageGenericFilter {
-
+ class GuerreroVentilationGenericFilter :
+ public ImageToImageGenericFilter<GuerreroVentilationGenericFilter> {
public:
// Constructor
- GuerreroVentilationGenericFilter ();
+ GuerreroVentilationGenericFilter();
+ virtual ~GuerreroVentilationGenericFilter() {}
// Types
typedef GuerreroVentilationGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
+ typedef ImageToImageGenericFilterBase Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
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<class InputImageType>
+ void UpdateWithInputImageType();
protected:
+ template<unsigned int Dim> void InitializeImageType();
//Parameters
double blood_mass_factor;
bool use_correct_formula;
- //--------------------------------------------------------------------
- template<unsigned int Dim> void Update_WithDim();
- template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType();
- //--------------------------------------------------------------------
-
}; // end class GuerreroVentilationGenericFilter
//--------------------------------------------------------------------
#include "clitkImageArithmGenericFilter.h"
//--------------------------------------------------------------------
-clitk::ImageArithmGenericFilter::ImageArithmGenericFilter():mTypeOfOperation(0) {
+clitk::ImageArithmGenericFilter::ImageArithmGenericFilter()
+ :ImageToImageGenericFilter<Self>("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<unsigned int Dim>
+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<class ImageType>
+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;
}
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<ImageType>(mInputFilenames[0], mIOVerbose);
+ typename ImageType::Pointer input1 = this->template GetInput<ImageType>(0);
+ typename ImageType::Pointer outputImage;
+
+ // Read input2 (float is ok altough it could take too memory ...)
+ if (mIsOperationUseASecondImage) {
+ typedef itk::Image<float,ImageType::ImageDimension> ImageType2;
+ // typename ImageType2::Pointer input2 = clitk::readImage<ImageType2>(mInputFilenames[1], mIOVerbose);
+ typename ImageType2::Pointer input2 = this->template GetInput<ImageType2>(1);
+ outputImage = ComputeImage<ImageType, ImageType2>(input1, input2);
+ }
+ else {
+ outputImage = ComputeImage<ImageType>(input1);
+ }
+
+ // Write results
+ this->SetNextOutput<ImageType>(outputImage);
+ //clitk::writeImage<ImageType>(outputImage, mOutputFilename, mIOVerbose);
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType>
+typename ImageType::Pointer
+clitk::ImageArithmGenericFilter::ComputeImage(typename ImageType::Pointer inputImage) {
+
+ typedef typename ImageType::PixelType PixelType;
+ typedef itk::ImageRegionIterator<ImageType> IteratorType;
+ IteratorType it(inputImage, inputImage->GetLargestPossibleRegion());
+ it.GoToBegin();
+
+ switch (mTypeOfOperation) {
+ case 0: // Addition
+ while (!it.IsAtEnd()) {
+ it.Set(PixelTypeDownCast<double, PixelType>((double)it.Get() + mScalar) );
+ ++it;
+ }
+ break;
+ case 1: // Multiply
+ while (!it.IsAtEnd()) {
+ it.Set(PixelTypeDownCast<double, PixelType>((double)it.Get() * mScalar) );
+ ++it;
+ }
+ break;
+ case 2: // Inverse
+ while (!it.IsAtEnd()) {
+ if (it.Get() != 0)
+ it.Set(PixelTypeDownCast<double, PixelType>(mScalar / (double)it.Get()));
+ else it.Set(mDefaultPixelValue);
+ ++it;
+ }
+ break;
+ case 3: // Max
+ while (!it.IsAtEnd()) {
+ if (it.Get() < mScalar) it.Set(PixelTypeDownCast<double, PixelType>(mScalar));
+ ++it;
+ }
+ break;
+ case 4: // Min
+ while (!it.IsAtEnd()) {
+ if (it.Get() > mScalar) it.Set(PixelTypeDownCast<double, PixelType>(mScalar));
+ ++it;
+ }
+ break;
+ case 5: // Absolute value
+ while (!it.IsAtEnd()) {
+ if (it.Get() <= 0) it.Set(PixelTypeDownCast<double, PixelType>(-it.Get()));
+ // <= zero to avoid warning for unsigned types
+ ++it;
+ }
+ break;
+ case 6: // Squared value
+ while (!it.IsAtEnd()) {
+ it.Set(PixelTypeDownCast<double, PixelType>((double)it.Get()*(double)it.Get()));
+ ++it;
+ }
+ break;
+ case 7: // Log
+ while (!it.IsAtEnd()) {
+ if (it.Get() > 0)
+ it.Set(PixelTypeDownCast<double, PixelType>(log((double)it.Get())));
+ else it.Set(mDefaultPixelValue);
+ ++it;
+ }
+ break;
+ case 8: // exp
+ while (!it.IsAtEnd()) {
+ it.Set(PixelTypeDownCast<double, PixelType>(exp((double)it.Get())));
+ ++it;
+ }
+ break;
+ case 9: // sqrt
+ while (!it.IsAtEnd()) {
+ if (it.Get() > 0)
+ it.Set(PixelTypeDownCast<double, PixelType>(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<class ImageType1, class ImageType2>
+typename ImageType1::Pointer
+clitk::ImageArithmGenericFilter::ComputeImage(typename ImageType1::Pointer inputImage1,
+ typename ImageType2::Pointer inputImage2) {
+
+ typedef typename ImageType1::PixelType PixelType;
+ typedef itk::ImageRegionIterator<ImageType1> IteratorType;
+ IteratorType it1(inputImage1, inputImage1->GetLargestPossibleRegion());
+ it1.GoToBegin();
+
+ typedef itk::ImageRegionConstIterator<ImageType2> ConstIteratorType;
+ ConstIteratorType it2(inputImage2, inputImage2->GetLargestPossibleRegion());
+ it2.GoToBegin();
+
+ switch (mTypeOfOperation) {
+ case 0: // Addition
+ while (!it1.IsAtEnd()) {
+ it1.Set(PixelTypeDownCast<double, PixelType>((double)it1.Get() + (double)it2.Get()) );
+ ++it1; ++it2;
+ }
+ break;
+ case 1: // Multiply
+ while (!it1.IsAtEnd()) {
+ it1.Set(PixelTypeDownCast<double, PixelType>((double)it1.Get() * (double)it2.Get()) );
+ ++it1; ++it2;
+ }
+ break;
+ case 2: // Divide
+ while (!it1.IsAtEnd()) {
+ if (it1.Get() != 0)
+ it1.Set(PixelTypeDownCast<double, PixelType>((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<double, PixelType>(it2.Get()));
+ ++it1; ++it2;
+ }
+ break;
+ case 4: // Min
+ while (!it1.IsAtEnd()) {
+ if (it1.Get() > it2.Get()) it1.Set(PixelTypeDownCast<double, PixelType>(it2.Get()));
+ ++it1; ++it2;
+ }
+ break;
+ case 5: // Absolute difference
+ while (!it1.IsAtEnd()) {
+ it1.Set(PixelTypeDownCast<double, PixelType>(fabs(it2.Get()-it1.Get())));
+ ++it1; ++it2;
+ }
+ break;
+ case 6: // Squared differences
+ while (!it1.IsAtEnd()) {
+ it1.Set(PixelTypeDownCast<double, PixelType>(pow((double)it1.Get()-(double)it2.Get(),2)));
+ ++it1; ++it2;
+ }
+ break;
+ case 7: // Difference
+ while (!it1.IsAtEnd()) {
+ it1.Set(PixelTypeDownCast<double, PixelType>((double)it1.Get()-(double)it2.Get()));
+ ++it1; ++it2;
+ }
+ break;
+ case 8: // Relative Difference
+ while (!it1.IsAtEnd()) {
+ if (it1.Get() != 0) it1.Set(PixelTypeDownCast<double, PixelType>(((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;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// Main class for an Image Resample Generic Filter
// (multiple dimensions, multiple pixel types)
- class ImageArithmGenericFilter : public clitk::ImageToImageGenericFilter {
+ class ImageArithmGenericFilter:
+ public clitk::ImageToImageGenericFilter<ImageArithmGenericFilter> {
public:
// Types
typedef ImageArithmGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
+ typedef ImageToImageGenericFilterBase Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
int GetTypeOfOperation () { return mTypeOfOperation ;}
double GetScalar () { return mScalar ;}
- // Update
- void Update ();
+ //--------------------------------------------------------------------
+ // Main function called each time the filter is updated
+ template<class InputImageType>
+ void UpdateWithInputImageType();
protected:
+ template<unsigned int Dim> void InitializeImageType();
bool mIsOperationUseASecondImage;
double mScalar;
double mDefaultPixelValue;
int mTypeOfOperation;
- //--------------------------------------------------------------------
- template<unsigned int Dim> void Update_WithDim();
- template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType();
-
template<class ImageType>
typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage);
}; // end class ImageArithmGenericFilter
//--------------------------------------------------------------------
-#include "clitkImageArithmGenericFilter.txx"
+//#include "clitkImageArithmGenericFilter.txx"
} // end namespace
//--------------------------------------------------------------------
#include "clitkImageConvertGenericFilter.h"
//--------------------------------------------------------------------
-clitk::ImageConvertGenericFilter::ImageConvertGenericFilter():ImageToImageGenericFilter() {
+clitk::ImageConvertGenericFilter::ImageConvertGenericFilter():
+ clitk::ImageToImageGenericFilter<Self>("ImageConvert") {
mOutputPixelTypeName = "NotSpecified";
+ InitializeImageType<2>();
+ InitializeImageType<3>();
+ InitializeImageType<4>();
}
//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+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<class InputImageType>
+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;
}
}
}
- // 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<InputImageType>(mInputFilenames);
+ typename InputImageType::Pointer input = this->template GetInput<InputImageType>(0);
+ //clitk::writeImage<InputImageType>(input, mOutputFilename, mIOVerbose);
+ this->SetNextOutput<InputImageType>(input);
+ }
+ else {
+#define TRY_TYPE(TYPE) \
+ if (IsSameType<TYPE>(mOutputPixelTypeName)) { UpdateWithOutputType<InputImageType, TYPE>(); 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<char, uchar, short, ushort, int, float, double>();
+ std::cerr << "Error, I don't know the output type '" << mOutputPixelTypeName
+ << "'. " << std::endl << "Known types are " << list << "." << std::endl;
+ exit(0);
+ }
}
-//--------------------------------------------------------------------
+//====================================================================
+
+//====================================================================
+template<class InputImageType, class OutputPixelType>
+void clitk::ImageConvertGenericFilter::UpdateWithOutputType() {
+ // Read
+ typename InputImageType::Pointer input =this->template GetInput<InputImageType>(0);
+
+ // Typedef
+ typedef typename InputImageType::PixelType PixelType;
+
+ // Warning
+ if (std::numeric_limits<PixelType>::is_signed) {
+ if (!std::numeric_limits<OutputPixelType>::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<PixelType>::is_integer) {
+ if (std::numeric_limits<OutputPixelType>::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<PixelType>::digits10);
+ // DD(std::numeric_limits<OutputPixelType>::digits10);
+ if (!std::numeric_limits<PixelType>::is_integer) {
+ if (std::numeric_limits<OutputPixelType>::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<PixelType>::digits10 > std::numeric_limits<OutputPixelType>::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<OutputPixelType,InputImageType::ImageDimension> OutputImageType;
+ typedef itk::CastImageFilter<InputImageType, OutputImageType> FilterType;
+ typename FilterType::Pointer filter = FilterType::New();
+ filter->SetInput(input);
+ filter->Update();
+
+ // Write
+ SetNextOutput<OutputImageType>(filter->GetOutput());
+ //clitk::writeImage<OutputImageType>(filter->GetOutput(), mOutputFilename, mIOVerbose);
+}
+//====================================================================
+
#endif /* end #define CLITKIMAGECONVERTGENERICFILTER_CXX */
namespace clitk {
- class ImageConvertGenericFilter: public clitk::ImageToImageGenericFilter {
+ class ImageConvertGenericFilter:
+ public clitk::ImageToImageGenericFilter<ImageConvertGenericFilter> {
public:
// constructor - destructor
// Types
typedef ImageConvertGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
// Members functions
void SetOutputPixelType(std::string p) { mOutputPixelTypeName = p; }
- void Update();
+
+ //--------------------------------------------------------------------
+ // Main function called each time the filter is updated
+ template<class InputImageType>
+ void UpdateWithInputImageType();
protected:
+ template<unsigned int Dim> void InitializeImageType();
std::string mOutputPixelTypeName;
- template<unsigned int Dim> void Update_WithDim();
- template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType();
- template<unsigned int Dim, class PixelType, class OutputPixelType> void Update_WithDimAndPixelTypeAndOutputType();
+ template<class InputImageType, class OutputPixelType> void UpdateWithOutputType();
}; // end class ImageConvertGenericFilter
-#include "clitkImageConvertGenericFilter.txx"
+ //#include "clitkImageConvertGenericFilter.txx"
} // end namespace
#include "clitkImageFillRegionGenericFilter.h"
//--------------------------------------------------------------------
-clitk::ImageFillRegionGenericFilter::ImageFillRegionGenericFilter() {
+clitk::ImageFillRegionGenericFilter::ImageFillRegionGenericFilter():
+ clitk::ImageToImageGenericFilter<Self>("ImageFillRegion") {
+ InitializeImageType<2>();
+ InitializeImageType<3>();
mPixelValue = 0;
m_IsCentered=false;
- mSphericRegion=false;
+ mSphericRegion=false;
}
//--------------------------------------------------------------------
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+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<class ImageType>
+void clitk::ImageFillRegionGenericFilter::UpdateWithInputImageType() {
+
+ // Typedef
+ typedef typename ImageType::PixelType PixelType;
+ static unsigned int Dim = ImageType::ImageDimension;
+
+ // Spheric region
+ if (mSphericRegion) return Update_WithDimAndPixelType_SphericRegion<ImageType::ImageDimension,PixelType>();
+
+ // Read input
+ typename ImageType::Pointer input = GetInput<ImageType>(0);
+
+ // Get pixel value in correct type
+ PixelType value = PixelTypeDownCast<double, PixelType>(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<Dim; i++) {
+ size[i] = mSize[i];
+ start[i] = mStart[i];
+ }
+ region.SetSize(size);
+ region.SetIndex(start);
+
+ // Build iterator
+ typedef itk::ImageRegionIterator<ImageType> IteratorType;
+ IteratorType it(input, region);
+ it.GoToBegin();
+ while (!it.IsAtEnd()) {
+ it.Set(value);
+ ++it;
+ }
+
+ // Write results
+ SetNextOutput<ImageType>(input);
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<unsigned int Dim, class PixelType>
+void clitk::ImageFillRegionGenericFilter::Update_WithDimAndPixelType_SphericRegion() {
+
+ // Read input
+ typedef itk::Image<PixelType,Dim> ImageType;
+ //typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames[0], mIOVerbose);
+ typename ImageType::Pointer input = GetInput<ImageType>(0);
+
+ // Get pixel value in correct type
+ PixelType value = PixelTypeDownCast<double, PixelType>(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<Dim; i++)
+ mCenter[i]=origin[i]+(double)size[i]/2*spacing[i];
+ }
+
+ // Build iterator
+ typedef itk::ImageRegionIteratorWithIndex<ImageType> IteratorType;
+ IteratorType it(input, input->GetLargestPossibleRegion());
+ it.GoToBegin();
+
+ typename ImageType::PointType point;
+ //typename itk::Vector<double, Dim> 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<Dim; i++)
+ distance+=powf( ( (mCenter[i]-point[i])/mRadius[i] ), 2);
+
+ // inside= ( (fabs(distance[i])<fabs(mRadius[i])) && inside );
+ // distance[i]=mCenter[i]-point[i];
+ // inside= ( (fabs(distance[i])<fabs(mRadius[i])) && inside );
+ // }
+
+ if (distance<1)
+ it.Set(value);
+ ++it;
+ }
+
+ // Write results
+ SetNextOutput<ImageType>(input);
+}
+
+//--------------------------------------------------------------------
+
+
+
//--------------------------------------------------------------------
void clitk::ImageFillRegionGenericFilter::SetSphericRegion(std::vector<double> & radius,
std::vector<double> & center)
//--------------------------------------------------------------------
-//--------------------------------------------------------------------
-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
namespace clitk {
//--------------------------------------------------------------------
- class ImageFillRegionGenericFilter : public clitk::ImageToImageGenericFilter {
+ class ImageFillRegionGenericFilter:
+ public clitk::ImageToImageGenericFilter<ImageFillRegionGenericFilter> {
public:
// Types
typedef ImageFillRegionGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
void SetSphericRegion(std::vector<double> & radius, std::vector<double> & center);
void SetSphericRegion(std::vector<double> & radius);
- // Update
- void Update ();
+ //--------------------------------------------------------------------
+ // Main function called each time the filter is updated
+ template<class InputImageType>
+ void UpdateWithInputImageType();
protected:
+ template<unsigned int Dim> void InitializeImageType();
double mPixelValue;
int * mSize;
int * mStart;
bool mSphericRegion;
bool m_IsCentered;
-
- //--------------------------------------------------------------------
- template<unsigned int Dim> void Update_WithDim();
- template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType();
template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType_SphericRegion();
- //--------------------------------------------------------------------
}; // end class ImageFillRegionGenericFilter
//--------------------------------------------------------------------
*
-------------------------------------------------*/
-//--------------------------------------------------------------------
-template<unsigned int Dim>
-void ImageFillRegionGenericFilter::Update_WithDim() {
-#define TRY_TYPE(TYPE) \
- if (IsSameType<TYPE>(mPixelTypeName)) { Update_WithDimAndPixelType<Dim, TYPE>(); 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<uchar, short, ushort, int, uint, float, double>();
- 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<unsigned int Dim, class PixelType>
-void ImageFillRegionGenericFilter::Update_WithDimAndPixelType() {
-
- // Spheric region
- if (mSphericRegion) return Update_WithDimAndPixelType_SphericRegion<Dim,PixelType>();
-
- // Read input
- typedef itk::Image<PixelType,Dim> ImageType;
- typename ImageType::Pointer input = GetInput<ImageType>(0);
-
- // Get pixel value in correct type
- PixelType value = PixelTypeDownCast<double, PixelType>(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<Dim; i++) {
- size[i] = mSize[i];
- start[i] = mStart[i];
- }
- region.SetSize(size);
- region.SetIndex(start);
-
- // Build iterator
- typedef itk::ImageRegionIterator<ImageType> IteratorType;
- IteratorType it(input, region);
- it.GoToBegin();
- while (!it.IsAtEnd()) {
- it.Set(value);
- ++it;
- }
-
- // Write results
- SetNextOutput<ImageType>(input);
-}
-//--------------------------------------------------------------------
-
-//--------------------------------------------------------------------
-template<unsigned int Dim, class PixelType>
-void ImageFillRegionGenericFilter::Update_WithDimAndPixelType_SphericRegion() {
-
- // Read input
- typedef itk::Image<PixelType,Dim> ImageType;
- //typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames[0], mIOVerbose);
- typename ImageType::Pointer input = GetInput<ImageType>(0);
-
- // Get pixel value in correct type
- PixelType value = PixelTypeDownCast<double, PixelType>(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<Dim; i++)
- mCenter[i]=origin[i]+(double)size[i]/2*spacing[i];
- }
-
- // Build iterator
- typedef itk::ImageRegionIteratorWithIndex<ImageType> IteratorType;
- IteratorType it(input, input->GetLargestPossibleRegion());
- it.GoToBegin();
-
- typename ImageType::PointType point;
- //typename itk::Vector<double, Dim> 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<Dim; i++)
- distance+=powf( ( (mCenter[i]-point[i])/mRadius[i] ), 2);
-
- // inside= ( (fabs(distance[i])<fabs(mRadius[i])) && inside );
- // distance[i]=mCenter[i]-point[i];
- // inside= ( (fabs(distance[i])<fabs(mRadius[i])) && inside );
- // }
-
- if (distance<1)
- it.Set(value);
- ++it;
- }
-
- // Write results
- SetNextOutput<ImageType>(input);
-}
-
-//--------------------------------------------------------------------
-
#endif //#define CLITKIMAGEFILLREGIONGENERICFILTER_TXX
#include "clitkImageResampleGenericFilter.h"
//--------------------------------------------------------------------
-clitk::ImageResampleGenericFilter::ImageResampleGenericFilter() {
+clitk::ImageResampleGenericFilter::ImageResampleGenericFilter():
+ ImageToImageGenericFilter<Self>("ImageResample") {
mApplyGaussianFilterBefore = false;
mDefaultPixelValue = 0.0;
mInterpolatorName = "NN";
mBSplineOrder=3;
+ InitializeImageTypeWithDim<2>();
+ InitializeImageTypeWithDim<3>();
+ InitializeImageTypeWithDim<4>();
}
//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+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<class InputImageType>
+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<InputImageType>(0);
+
+ // Warning
+ if (!std::numeric_limits<PixelType>::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<InputImageType,InputImageType> 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<double, InputImageType::ImageDimension> 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; i<InputImageType::ImageDimension; i++) {
+ outputSize[i] = mOutputSize[i];
+ outputSpacing[i] = mOutputSpacing[i];
+ outputOrigin[i] = input->GetOrigin()[i];
+ }
+
+ filter->SetSize(outputSize);
+ filter->SetOutputSpacing(outputSpacing);
+ filter->SetOutputOrigin(outputOrigin);
+ filter->SetDefaultPixelValue(static_cast<PixelType>(mDefaultPixelValue));//DS TODO//JV comme ça?
+
+ // Select interpolator
+ if (mInterpolatorName == "nn") {
+ typedef itk::NearestNeighborInterpolateImageFunction<InputImageType, double> InterpolatorType;
+ typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
+ filter->SetInterpolator(interpolator);
+ }
+ else {
+ if (mInterpolatorName == "linear") {
+ typedef itk::LinearInterpolateImageFunction<InputImageType, double> InterpolatorType;
+ typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
+ filter->SetInterpolator(interpolator);
+ }
+ else {
+ if (mInterpolatorName == "bspline") {
+ typedef itk::BSplineInterpolateImageFunction<InputImageType, double> InterpolatorType;
+ typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
+ interpolator->SetSplineOrder(mBSplineOrder);
+ filter->SetInterpolator(interpolator);
+ }
+ else {
+ if (mInterpolatorName == "blut") {
+ typedef itk::BSplineInterpolateImageFunctionWithLUT<InputImageType, double> 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<InputImageType, InputImageType> GaussianFilterType;
+ std::vector<typename GaussianFilterType::Pointer> gaussianFilters;
+ if (mApplyGaussianFilterBefore) {
+ for(unsigned int i=0; i<InputImageType::ImageDimension; i++) {
+ // Create filter
+ gaussianFilters.push_back(GaussianFilterType::New());
+ // Set options
+ gaussianFilters[i]->SetDirection(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<InputImageType>(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<int> & size) {
mOutputSize.resize(size.size());
namespace clitk {
//--------------------------------------------------------------------
- class ImageResampleGenericFilter: public clitk::ImageToImageGenericFilter {
+ class ImageResampleGenericFilter:
+ public ImageToImageGenericFilter<ImageResampleGenericFilter> {
public:
// constructor
// Types
typedef ImageResampleGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
void SetBSplineOrder(int o) { mBSplineOrder = o; }
void SetBLUTSampling(int b) { mSamplingFactors.resize(1); mSamplingFactors[0] = b; }
- void Update();
+ //--------------------------------------------------------------------
+ template<class InputImageType> void UpdateWithInputImageType();
protected:
//--------------------------------------------------------------------
std::vector<int> mSamplingFactors;
//--------------------------------------------------------------------
- template<unsigned int Dim> void Update_WithDim();
- template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType();
-
- //--------------------------------------------------------------------
- template<class ImageType>
- typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage);
-
+ template<unsigned int Dim> void InitializeImageTypeWithDim();
+
}; // end class ImageResampleGenericFilter
//--------------------------------------------------------------------
*
------------------------------------------------=*/
-//--------------------------------------------------------------------
-template<unsigned int Dim>
-void ImageResampleGenericFilter::Update_WithDim() {
-
-#define TRY_TYPE(TYPE) \
- if (IsSameType<TYPE>(mPixelTypeName)) { Update_WithDimAndPixelType<Dim, TYPE>(); 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<char, uchar, short, ushort, int, float, double>();
- 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<unsigned int Dim, class PixelType>
-void ImageResampleGenericFilter::Update_WithDimAndPixelType() {
- // Reading input
- typedef itk::Image<PixelType,Dim> ImageType;
- //typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames, mIOVerbose);
- typename ImageType::Pointer input = this->GetInput<ImageType>(0);
-
- // Main filter
- typename ImageType::Pointer outputImage = ComputeImage<ImageType>(input);
-
- // Write results
- this->SetNextOutput<ImageType>(outputImage);
- //clitk::writeImage<ImageType>(outputImage, mOutputFilename, mIOVerbose);
-}
-//--------------------------------------------------------------------
-
-//--------------------------------------------------------------------
-template<class ImageType>
-typename ImageType::Pointer
-ImageResampleGenericFilter::ComputeImage(typename ImageType::Pointer inputImage) {
-
- // Warning
- if (!std::numeric_limits<typename ImageType::PixelType>::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<ImageType,ImageType> 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<double, ImageType::ImageDimension> 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; i<ImageType::ImageDimension; i++) {
- outputSize[i] = mOutputSize[i];
- outputSpacing[i] = mOutputSpacing[i];
- outputOrigin[i] = inputImage->GetOrigin()[i];
- }
-
- filter->SetSize(outputSize);
- filter->SetOutputSpacing(outputSpacing);
- filter->SetOutputOrigin(outputOrigin);
- filter->SetDefaultPixelValue(static_cast<typename ImageType::PixelType>(mDefaultPixelValue));//DS TODO//JV comme ça?
-
- // Select interpolator
- if (mInterpolatorName == "nn") {
- typedef itk::NearestNeighborInterpolateImageFunction<ImageType, double> InterpolatorType;
- typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
- filter->SetInterpolator(interpolator);
- }
- else {
- if (mInterpolatorName == "linear") {
- typedef itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
- typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
- filter->SetInterpolator(interpolator);
- }
- else {
- if (mInterpolatorName == "bspline") {
- typedef itk::BSplineInterpolateImageFunction<ImageType, double> InterpolatorType;
- typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
- interpolator->SetSplineOrder(mBSplineOrder);
- filter->SetInterpolator(interpolator);
- }
- else {
- if (mInterpolatorName == "blut") {
- typedef itk::BSplineInterpolateImageFunctionWithLUT<ImageType, double> 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<ImageType, ImageType> GaussianFilterType;
- std::vector<typename GaussianFilterType::Pointer> gaussianFilters;
- if (mApplyGaussianFilterBefore) {
- for(unsigned int i=0; i<ImageType::ImageDimension; i++) {
- // Create filter
- gaussianFilters.push_back(GaussianFilterType::New());
- // Set options
- gaussianFilters[i]->SetDirection(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 */
#include "clitkSplitImageGenericFilter.txx"
//--------------------------------------------------------------------
-clitk::SplitImageGenericFilter::SplitImageGenericFilter() {
+clitk::SplitImageGenericFilter::SplitImageGenericFilter():
+ clitk::ImageToImageGenericFilter<Self>("SplitImage") {
mSplitDimension = 0;
+ InitializeImageType<3>();
+ InitializeImageType<4>();
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+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<float, Dim> 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!!!"<<std::endl ;
- return;
- }
+template<class ImageType>
+void clitk::SplitImageGenericFilter::UpdateWithInputImageType() {
+
+ // Read input
+ typedef typename ImageType::PixelType PixelType;
+ typedef itk::Image<PixelType,ImageType::ImageDimension-1> OutputImageType;
+ typename ImageType::Pointer input = this->GetInput<ImageType>(0);
+ typedef itk::ExtractImageFilter<ImageType,OutputImageType> 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;i<number_of_output_images;i++)
+ {
+ std::ostringstream ss;
+ ss << i;
+ index[mSplitDimension]=i;
+ extracted_region.SetIndex(index);
+ filter->SetExtractionRegion(extracted_region);
+ filter->Update();
+ SetOutputFilename(base_filename+"_"+ss.str()+".mhd");
+ typename OutputImageType::Pointer output=filter->GetOutput();
+ SetNextOutput<OutputImageType>(output);
+ }
}
//--------------------------------------------------------------------
namespace clitk {
//--------------------------------------------------------------------
- class SplitImageGenericFilter : public clitk::ImageToImageGenericFilter {
+ class SplitImageGenericFilter:
+ public clitk::ImageToImageGenericFilter<SplitImageGenericFilter> {
public:
SplitImageGenericFilter ();
// Types
- typedef SplitImageGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
+ typedef SplitImageGenericFilter Self;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
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<class InputImageType>
+ void UpdateWithInputImageType();
protected:
+ template<unsigned int Dim> void InitializeImageType();
int mSplitDimension;
bool m_Verbose;
- //--------------------------------------------------------------------
- template<unsigned int Dim> void UpdateWithDim(std::string PixelType, int Components);
- template<unsigned int Dim, class PixelType> void UpdateWithDimAndPixelType();
- //--------------------------------------------------------------------
}; // end class SplitImageGenericFilter
//--------------------------------------------------------------------
#include <itkExtractImageFilter.h>
-//--------------------------------------------------------------------
-template<unsigned int Dimension>
-void clitk::SplitImageGenericFilter::UpdateWithDim(std::string PixelType, int Components) {
-
- if (m_Verbose) std::cout << "Image was detected to be "<<Dimension<<"D and "<<Components<<" component(s) of "<< PixelType<<"..."<<std::endl;
-
- if (Components==1)
- {
- if(PixelType == "short"){
- if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and signed short..." << std::endl;
- UpdateWithDimAndPixelType<Dimension, signed short>();
- }
- else if(PixelType == "unsigned_short"){
- if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and unsigned_short..." << std::endl;
- UpdateWithDimAndPixelType<Dimension, unsigned short>();
- }
-
- else if (PixelType == "unsigned_char"){
- if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and unsigned_char..." << std::endl;
- UpdateWithDimAndPixelType<Dimension, unsigned char>();
- }
-
- else if (PixelType == "char"){
- if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and signed_char..." << std::endl;
- UpdateWithDimAndPixelType<Dimension, signed char>();
- }
- else {
- if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and float..." << std::endl;
- UpdateWithDimAndPixelType<Dimension, float>();
- }
- }
-
- else if (Components==3)
- {
- if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and 3D float (DVF)" << std::endl;
- UpdateWithDimAndPixelType<Dimension, itk::Vector<float, Dimension> >();
- }
- else std::cerr<<"Number of components is "<<Components<<", not supported!"<<std::endl;
-
-}
-//--------------------------------------------------------------------
-
-//--------------------------------------------------------------------
-template<unsigned int Dimension, class PixelType>
-void clitk::SplitImageGenericFilter::UpdateWithDimAndPixelType() {
-
- // Read input
- typedef itk::Image<PixelType,Dimension> ImageType;
- typedef itk::Image<PixelType,Dimension-1> OutputImageType;
- typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames[0], mIOVerbose);
- typedef itk::ExtractImageFilter<ImageType,OutputImageType> 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;i<number_of_output_images;i++)
- {
- std::ostringstream ss;
- ss << i;
- index[mSplitDimension]=i;
- extracted_region.SetIndex(index);
- filter->SetExtractionRegion(extracted_region);
- filter->Update();
- SetOutputFilename(base_filename+"_"+ss.str()+".mhd");
- typename OutputImageType::Pointer output=filter->GetOutput();
- SetNextOutput<OutputImageType>(output);
- }
-}
-//--------------------------------------------------------------------
-
#endif //#define clitkSplitImageGenericFilter_TXX
#include "clitkVFResampleGenericFilter.h"
//--------------------------------------------------------------------
-clitk::VFResampleGenericFilter::VFResampleGenericFilter() {
+clitk::VFResampleGenericFilter::VFResampleGenericFilter():
+ clitk::ImageToImageGenericFilter<Self>("VFResample") {
+ InitializeImageType<2>();
+ InitializeImageType<3>();
+ InitializeImageType<4>();
mApplyGaussianFilterBefore = false;
mDefaultPixelValue = 0.0;
mInterpolatorName = "NN";
}
//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+void clitk::VFResampleGenericFilter::InitializeImageType() {
+ ADD_IMAGE_TYPE(Dim, float);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class ImageType>
+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<ImageType::ImageDimension,PixelType,2>();
+ if (mNbOfComponents == 3) Update_WithDimAndPixelTypeAndComponent<ImageType::ImageDimension,PixelType,3>();
+ if (mNbOfComponents == 4) Update_WithDimAndPixelTypeAndComponent<ImageType::ImageDimension,PixelType,4>();
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<unsigned int Dim, class PixelType, unsigned int DimCompo>
+void clitk::VFResampleGenericFilter::Update_WithDimAndPixelTypeAndComponent() {
+ // Reading input
+ typedef itk::Vector<PixelType, DimCompo> DisplacementType;
+ typedef itk::Image< DisplacementType, Dim > ImageType;
+
+ typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames, mIOVerbose);
+
+ // Main filter
+ typename ImageType::Pointer outputImage = ComputeImage<ImageType>(input);
+
+ // Write results
+ SetNextOutput<ImageType>(outputImage);
+}
+//--------------------------------------------------------------------
+
//--------------------------------------------------------------------
-void clitk::VFResampleGenericFilter::Update() {
- // Load image header
- itk::ImageIOBase::Pointer header = clitk::readImageHeader(mInputFilenames[0]);
+template<class ImageType>
+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<ImageType,ImageType> 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<double, ImageType::ImageDimension> 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; i<ImageType::ImageDimension; i++) {
+ outputSize[i] = mOutputSize[i];
+ outputSpacing[i] = mOutputSpacing[i];
+ outputOrigin[i] = inputImage->GetOrigin()[i];
+ }
+
+ filter->SetSize(outputSize);
+ filter->SetOutputSpacing(outputSpacing);
+ filter->SetOutputOrigin(outputOrigin);
+ filter->SetDefaultPixelValue(static_cast<typename ImageType::PixelType>(mDefaultPixelValue));
+
+ // Select interpolator
+ if (mInterpolatorName == "nn") {
+ typedef itk::VectorNearestNeighborInterpolateImageFunction<ImageType, double> InterpolatorType;
+ typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
+ filter->SetInterpolator(interpolator);
+ }
+ else {
+ if (mInterpolatorName == "linear") {
+ typedef itk::VectorLinearInterpolateImageFunction<ImageType, double> 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<ImageType, ImageType> GaussianFilterType;
+ std::vector<typename GaussianFilterType::Pointer> gaussianFilters;
+ if (mApplyGaussianFilterBefore) {
+ for(unsigned int i=0; i<ImageType::ImageDimension; i++) {
+ // Create filter
+ gaussianFilters.push_back(GaussianFilterType::New());
+ // Set options
+ gaussianFilters[i]->SetDirection(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<int> & size) {
mOutputSize.resize(size.size());
namespace clitk {
//--------------------------------------------------------------------
- class VFResampleGenericFilter: public clitk::ImageToImageGenericFilter {
+ class VFResampleGenericFilter:
+ public clitk::ImageToImageGenericFilter<VFResampleGenericFilter> {
public:
// constructor
VFResampleGenericFilter();
// Types
- typedef VFResampleGenericFilter Self;
- typedef ImageToImageGenericFilter Superclass;
+ typedef VFResampleGenericFilter Self;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
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<class InputImageType>
+ void UpdateWithInputImageType();
protected:
+ template<unsigned int Dim> void InitializeImageType();
//--------------------------------------------------------------------
std::string mInterpolatorName;
std::vector<int> mOutputSize;
std::vector<int> mSamplingFactors;
//--------------------------------------------------------------------
- template<unsigned int Dim> void Update_WithDim();
- template<unsigned int Dim, class PixelType> void Update_WithDimAndPixelType();
template<unsigned int Dim, class PixelType, unsigned int DimCompo>
void Update_WithDimAndPixelTypeAndComponent();
-
- //--------------------------------------------------------------------
template<class ImageType>
typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage);
------------------------------------------------=*/
//--------------------------------------------------------------------
-template<unsigned int Dim>
-void VFResampleGenericFilter::Update_WithDim() {
-#define TRY_TYPE(TYPE) \
- if (IsSameType<TYPE>(mPixelTypeName)) { Update_WithDimAndPixelType<Dim, TYPE>(); return; }
- TRY_TYPE(float);
-#undef TRY_TYPE
- std::string list = CreateListOfTypes<float, double>();
- 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<unsigned int Dim, class PixelType>
-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<Dim,PixelType,2>();
- if (mNbOfComponents == 3) Update_WithDimAndPixelTypeAndComponent<Dim,PixelType,3>();
- if (mNbOfComponents == 4) Update_WithDimAndPixelTypeAndComponent<Dim,PixelType,4>();
-}
-//--------------------------------------------------------------------
-
-//--------------------------------------------------------------------
-template<unsigned int Dim, class PixelType, unsigned int DimCompo>
-void VFResampleGenericFilter::Update_WithDimAndPixelTypeAndComponent() {
- // Reading input
- typedef itk::Vector<PixelType, DimCompo> DisplacementType;
- typedef itk::Image< DisplacementType, Dim > ImageType;
-
- typename ImageType::Pointer input = clitk::readImage<ImageType>(mInputFilenames, mIOVerbose);
-
- // Main filter
- typename ImageType::Pointer outputImage = ComputeImage<ImageType>(input);
-
- // Write results
- SetNextOutput<ImageType>(outputImage);
-}
-//--------------------------------------------------------------------
-
-//--------------------------------------------------------------------
-template<class ImageType>
-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<ImageType,ImageType> 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<double, ImageType::ImageDimension> 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; i<ImageType::ImageDimension; i++) {
- outputSize[i] = mOutputSize[i];
- outputSpacing[i] = mOutputSpacing[i];
- outputOrigin[i] = inputImage->GetOrigin()[i];
- }
-
- filter->SetSize(outputSize);
- filter->SetOutputSpacing(outputSpacing);
- filter->SetOutputOrigin(outputOrigin);
- filter->SetDefaultPixelValue(static_cast<typename ImageType::PixelType>(mDefaultPixelValue));
-
- // Select interpolator
- if (mInterpolatorName == "nn") {
- typedef itk::VectorNearestNeighborInterpolateImageFunction<ImageType, double> InterpolatorType;
- typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
- filter->SetInterpolator(interpolator);
- }
- else {
- if (mInterpolatorName == "linear") {
- typedef itk::VectorLinearInterpolateImageFunction<ImageType, double> 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<ImageType, ImageType> GaussianFilterType;
- std::vector<typename GaussianFilterType::Pointer> gaussianFilters;
- if (mApplyGaussianFilterBefore) {
- for(unsigned int i=0; i<ImageType::ImageDimension; i++) {
- // Create filter
- gaussianFilters.push_back(GaussianFilterType::New());
- // Set options
- gaussianFilters[i]->SetDirection(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 */
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)
)
TARGET_LINK_LIBRARIES(clitkGuerreroVentilation clitkCommon ITKIO ITKBasicFilters
clitkFilters)
+
+ADD_EXECUTABLE(clitkBinarizeImage clitkBinarizeImage.cxx clitkBinarizeImage_ggo.c)
+TARGET_LINK_LIBRARIES(clitkBinarizeImage ITKIO clitkCommon)
CLITK_INIT;
// Filter
- typedef clitk::AffineTransformGenericFilter<gengetopt_args_info_clitkAffineTransform> FilterType;
+ typedef clitk::AffineTransformGenericFilter<args_info_clitkAffineTransform> FilterType;
FilterType::Pointer genericFilter = FilterType::New();
genericFilter->SetArgsInfo(args_info);
CLITK_INIT;
// Filter
- typedef clitk::AverageTemporalDimensionGenericFilter<gengetopt_args_info_clitkAverageTemporalDimension> FilterType;
+ typedef clitk::AverageTemporalDimensionGenericFilter<args_info_clitkAverageTemporalDimension> FilterType;
FilterType::Pointer genericFilter = FilterType::New();
genericFilter->SetArgsInfo(args_info);
CLITK_INIT;
// Filter
- typedef clitk::InvertVFGenericFilter<gengetopt_args_info_clitkInvertVF> FilterType;
+ typedef clitk::InvertVFGenericFilter<args_info_clitkInvertVF> FilterType;
FilterType::Pointer genericFilter = FilterType::New();
genericFilter->SetArgsInfo(args_info);
//----------------------------------------
// 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;
//----------------------------------------
// Data members
//----------------------------------------
- gengetopt_args_info_clitkSetBackground m_ArgsInfo;
+ args_info_clitkSetBackground m_ArgsInfo;
bool m_Verbose;
std::string m_InputFileName;
#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;
public:
typedef itk::Vector<double,2> 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;
//----------------------------------------
// 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;
//----------------------------------------
// Data members
//----------------------------------------
- gengetopt_args_info_clitkWarpImage m_ArgsInfo;
+ args_info_clitkWarpImage m_ArgsInfo;
bool m_Verbose;
std::string m_InputFileName;
typename DeformationFieldType::Pointer deformationField =deformationFieldReader->GetOutput();
// Intensity interpolator
- typedef clitk::GenericVectorInterpolator<gengetopt_args_info_clitkWarpImage, DeformationFieldType, double> GenericInterpolatorType;
+ typedef clitk::GenericVectorInterpolator<args_info_clitkWarpImage, DeformationFieldType, double> GenericInterpolatorType;
typename GenericInterpolatorType::Pointer genericInterpolator=GenericInterpolatorType::New();
genericInterpolator->SetArgsInfo(m_ArgsInfo);
newSize[i]=(unsigned int) (input->GetLargestPossibleRegion().GetSize()[i]*input->GetSpacing()[i]/deformationField->GetSpacing()[i]);
// Get the interpolator
- typedef clitk::GenericVectorInterpolator<gengetopt_args_info_clitkWarpImage, DeformationFieldType, double> GenericInterpolatorType;
+ typedef clitk::GenericVectorInterpolator<args_info_clitkWarpImage, DeformationFieldType, double> GenericInterpolatorType;
typename GenericInterpolatorType::Pointer genericInterpolator=GenericInterpolatorType::New();
genericInterpolator->SetArgsInfo(m_ArgsInfo);
else
{
// Get the interpolator
- typedef clitk::GenericInterpolator<gengetopt_args_info_clitkWarpImage, InputImageType, double> GenericInterpolatorType;
+ typedef clitk::GenericInterpolator<args_info_clitkWarpImage, InputImageType, double> GenericInterpolatorType;
typename GenericInterpolatorType::Pointer genericInterpolator=GenericInterpolatorType::New();
genericInterpolator->SetArgsInfo(m_ArgsInfo);
CLITK_INIT;
// Filter
- typedef clitk::WriteDicomSeriesGenericFilter<gengetopt_args_info_clitkWriteDicomSeries> FilterType;
+ typedef clitk::WriteDicomSeriesGenericFilter<args_info_clitkWriteDicomSeries> FilterType;
FilterType::Pointer genericFilter = FilterType::New();
genericFilter->SetArgsInfo(args_info);
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff