From d73a7833a28e6111e1e805efae5df3ab18a240e2 Mon Sep 17 00:00:00 2001 From: guigues Date: Tue, 5 Feb 2008 12:02:43 +0000 Subject: [PATCH] *** empty log message *** --- packages/CMakeLists.txt | 3 +- packages/itk/CMakeLists.txt | 9 +- .../itk/src/bbitkAnyImageToTypedImage.cxx | 185 ++++++ packages/itk/src/bbitkAnyImageToTypedImage.h | 117 ++++ .../src/bbitkBinaryThresholdImageFilter.cxx | 19 + .../itk/src/bbitkBinaryThresholdImageFilter.h | 148 +++++ packages/itk/src/bbitkExtractImageFilter.cxx | 22 + packages/itk/src/bbitkExtractImageFilter.h | 91 +++ packages/itk/src/bbitkImage.cxx | 21 + packages/itk/src/bbitkImage.h | 561 ++++++++++++++++++ packages/itk/src/bbitkImageProperties.cxx | 87 +++ packages/itk/src/bbitkImageProperties.h | 81 +++ packages/itk/src/bbitkImageReader.cxx | 93 +++ packages/itk/src/bbitkImageReader.h | 71 +++ packages/itk/src/bbitkImageRegion.cxx | 72 +++ packages/itk/src/bbitkImageRegion.h | 76 +++ packages/itk/src/bbitkImageSeriesReader.cxx | 103 ++++ packages/itk/src/bbitkImageSeriesReader.h | 72 +++ packages/itk/src/bbitkImageToString.cxx | 45 ++ packages/itk/src/bbitkImageToString.h | 17 + packages/itk/src/bbitkImageWriter.cxx | 77 +++ packages/itk/src/bbitkImageWriter.h | 71 +++ packages/itk/src/bbitkResampleImageFilter.cxx | 15 + packages/itk/src/bbitkResampleImageFilter.h | 160 +++++ .../itk/src/bbitkTypedImageToAnyImage.cxx | 125 ++++ packages/itk/src/bbitkTypedImageToAnyImage.h | 47 ++ packages/std/src/bbstdRelay.h | 34 ++ 27 files changed, 2417 insertions(+), 5 deletions(-) create mode 100644 packages/itk/src/bbitkAnyImageToTypedImage.cxx create mode 100644 packages/itk/src/bbitkAnyImageToTypedImage.h create mode 100644 packages/itk/src/bbitkBinaryThresholdImageFilter.cxx create mode 100644 packages/itk/src/bbitkBinaryThresholdImageFilter.h create mode 100644 packages/itk/src/bbitkExtractImageFilter.cxx create mode 100644 packages/itk/src/bbitkExtractImageFilter.h create mode 100644 packages/itk/src/bbitkImage.cxx create mode 100644 packages/itk/src/bbitkImage.h create mode 100644 packages/itk/src/bbitkImageProperties.cxx create mode 100644 packages/itk/src/bbitkImageProperties.h create mode 100644 packages/itk/src/bbitkImageReader.cxx create mode 100644 packages/itk/src/bbitkImageReader.h create mode 100644 packages/itk/src/bbitkImageRegion.cxx create mode 100644 packages/itk/src/bbitkImageRegion.h create mode 100644 packages/itk/src/bbitkImageSeriesReader.cxx create mode 100644 packages/itk/src/bbitkImageSeriesReader.h create mode 100644 packages/itk/src/bbitkImageToString.cxx create mode 100644 packages/itk/src/bbitkImageToString.h create mode 100644 packages/itk/src/bbitkImageWriter.cxx create mode 100644 packages/itk/src/bbitkImageWriter.h create mode 100644 packages/itk/src/bbitkResampleImageFilter.cxx create mode 100644 packages/itk/src/bbitkResampleImageFilter.h create mode 100644 packages/itk/src/bbitkTypedImageToAnyImage.cxx create mode 100644 packages/itk/src/bbitkTypedImageToAnyImage.h create mode 100644 packages/std/src/bbstdRelay.h diff --git a/packages/CMakeLists.txt b/packages/CMakeLists.txt index d1f2b32..928170f 100644 --- a/packages/CMakeLists.txt +++ b/packages/CMakeLists.txt @@ -3,6 +3,7 @@ SET(BBTK_CORE_PACKAGE ON) #----------------------------------------------------------------------------- #SUBDIRS(void) -SUBDIRS(wx) SUBDIRS(std) +SUBDIRS(wx) +SUBDIRS(itk) #----------------------------------------------------------------------------- diff --git a/packages/itk/CMakeLists.txt b/packages/itk/CMakeLists.txt index 33103f8..5d08ad1 100644 --- a/packages/itk/CMakeLists.txt +++ b/packages/itk/CMakeLists.txt @@ -16,10 +16,10 @@ SET(BBTK_PACKAGE_NAME itk) #=========================================================================== # UNCOMMENT EACH LIBRARY NEEDED -# SET(BBTK_PACKAGE_USE_VTK ON) -# SET(BBTK_PACKAGE_USE_ITK ON) -# SET(BBTK_PACKAGE_USE_GDCM ON) -# SET(BBTK_PACKAGE_USE_GSMIS ON) +# SET(${BBTK_PACKAGE_NAME}_USE_VTK ON) +SET(${BBTK_PACKAGE_NAME}_USE_ITK ON) +# SET(${BBTK_PACKAGE_NAME}_USE_GDCM ON) +# SET(${BBTK_PACKAGE_NAME}_USE_GSMIS ON) # SET(${BBTK_PACKAGE_NAME}_USE_WXWIDGETS ON) #=========================================================================== @@ -94,6 +94,7 @@ INCLUDE_DIRECTORIES( # LIST HERE YOUR INCLUDE DIRECTORIES # EXCEPT BBTK'S AND THE INCLUDE DIRS THAT WERE SET # BY INCLUDING A LIBRARY USE FILE + ../std/src ) #=========================================================================== diff --git a/packages/itk/src/bbitkAnyImageToTypedImage.cxx b/packages/itk/src/bbitkAnyImageToTypedImage.cxx new file mode 100644 index 0000000..254b35c --- /dev/null +++ b/packages/itk/src/bbitkAnyImageToTypedImage.cxx @@ -0,0 +1,185 @@ +#ifdef _USE_ITK_ +#include "bbitkAnyImageToTypedImage.h" +#include "bbitkPackage.h" + +namespace bbitk +{ + //==================================================================== + BBTK_USER_BLACK_BOX_TEMPLATE_IMPLEMENTATION(AnyImageToTypedImage, + bbtk::UserBlackBox); + BBTK_USER_BLACK_BOX_TEMPLATE2_IMPLEMENTATION(AnyImageToConstTypedImage, + bbtk::UserBlackBox); + //==================================================================== + + +#ifdef BBTK_ITK_IMAGE_DIM_2 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int8_t_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int16_t_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int32_t_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint8_t_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint16_t_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint32_t_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_float_2_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_double_2_ptr); +# endif +#endif + + + +#ifdef BBTK_ITK_IMAGE_DIM_3 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int8_t_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int16_t_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int32_t_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint8_t_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint16_t_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint32_t_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_float_3_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_double_3_ptr); +# endif +#endif + + + + +#ifdef BBTK_ITK_IMAGE_DIM_4 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int8_t_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int16_t_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_int32_t_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint8_t_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint16_t_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_uint32_t_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_float_4_ptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,AnyImageToTypedImage,Image_double_4_ptr); +# endif +#endif + + +#ifdef BBTK_ITK_IMAGE_DIM_2 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int8_t_2_ptr,Image_int8_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int16_t_2_ptr,Image_int16_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int32_t_2_ptr,Image_int32_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint8_t_2_ptr,Image_uint8_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint16_t_2_ptr,Image_uint16_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint32_t_2_ptr,Image_uint32_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_float_2_ptr,Image_float_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_double_2_ptr,Image_double_2_cptr); +# endif +#endif + +#ifdef BBTK_ITK_IMAGE_DIM_3 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int8_t_3_ptr,Image_int8_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int16_t_3_ptr,Image_int16_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int32_t_3_ptr,Image_int32_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint8_t_3_ptr,Image_uint8_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint16_t_3_ptr,Image_uint16_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint32_t_3_ptr,Image_uint32_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_float_3_ptr,Image_float_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_double_3_ptr,Image_double_3_cptr); +# endif +#endif + +#ifdef BBTK_ITK_IMAGE_DIM_4 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int8_t_4_ptr,Image_int8_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int16_t_4_ptr,Image_int16_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_int32_t_4_ptr,Image_int32_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint8_t_4_ptr,Image_uint8_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint16_t_4_ptr,Image_uint16_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_uint32_t_4_ptr,Image_uint32_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_float_4_ptr,Image_float_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(itk,AnyImageToConstTypedImage,Image_double_4_ptr,Image_double_4_cptr); +# endif +#endif + + +} +#endif diff --git a/packages/itk/src/bbitkAnyImageToTypedImage.h b/packages/itk/src/bbitkAnyImageToTypedImage.h new file mode 100644 index 0000000..b780362 --- /dev/null +++ b/packages/itk/src/bbitkAnyImageToTypedImage.h @@ -0,0 +1,117 @@ +#ifdef _USE_ITK_ + +#ifndef __bbitkAnyImageToTypedImage_h_INCLUDED__ +#define __bbitkAnyImageToTypedImage_h_INCLUDED__ + +#include "bbtkUserBlackBox.h" +#include "bbitkImage.h" + +namespace bbitk +{ + + //================================================================= + // UserBlackBox declaration + template + class AnyImageToTypedImage : public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(AnyImageToTypedImage, + bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,anyImagePointer); + BBTK_DECLARE_OUTPUT(Out,itkImageTypePointer); + BBTK_PROCESS(DoIt); + void DoIt(); + }; + //================================================================= + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_TEMPLATE_BLACK_BOX(AnyImageToTypedImage); + BBTK_NAME(bbtk::HumanTypeName() + "To"+bbtk::HumanTypeName()); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Transforms a generic itk image ("+ + bbtk::HumanTypeName()+ + ") into a typed itk image ("+ + bbtk::HumanTypeName()+"*)"); + BBTK_DEFAULT_ADAPTOR(); + BBTK_TEMPLATE_INPUT(AnyImageToTypedImage,In, + "Input generic image",anyImagePointer); + BBTK_TEMPLATE_OUTPUT(AnyImageToTypedImage,Out, + "Output typed image",T); + BBTK_END_DESCRIBE_TEMPLATE_BLACK_BOX(AnyImageToTypedImage); + //================================================================= + + //================================================================= + template + void AnyImageToTypedImage::DoIt() + { + if ( bbGetInputIn().type() == typeid(itkImageTypePointer) ) + { + bbSetOutputOut ( bbGetInputIn().template unsafe_get < itkImageTypePointer >() ); + } + else + { + bbtkError(this->bbGetFullName()<<+" : transform of <" + < into <" + <()<<"> not implemented"); + } + } + //================================================================= + + //================================================================= + // UserBlackBox declaration + template + class AnyImageToConstTypedImage : public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(AnyImageToConstTypedImage, + bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,anyImagePointer); + BBTK_DECLARE_OUTPUT(Out,itkImageTypeConstPointer); + BBTK_PROCESS(DoIt); + void DoIt(); + }; + //================================================================= + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_TEMPLATE2_BLACK_BOX(AnyImageToConstTypedImage); + BBTK_NAME("Convert<"+bbtk::TypeName() + "," + + bbtk::TypeName()+">"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Transforms a generic itk image ("+ + bbtk::TypeName()+ + ") into a typed itk image ("+ + bbtk::TypeName()+"*)"); + BBTK_DEFAULT_ADAPTOR(); + BBTK_TEMPLATE2_INPUT(AnyImageToConstTypedImage,In, + "Input generic image",anyImagePointer); + BBTK_TEMPLATE2_OUTPUT(AnyImageToConstTypedImage,Out, + "Output typed image",T2); + BBTK_END_DESCRIBE_TEMPLATE2_BLACK_BOX(AnyImageToConstTypedImage); + //================================================================= + + //================================================================= + template + void AnyImageToConstTypedImage::DoIt() + { + if ( bbGetInputIn().type() == typeid(itkImageTypeConstPointer) ) + { + bbSetOutputOut ( bbGetInputIn().template unsafe_get < itkImageTypeConstPointer >() ); + } + else if ( bbGetInputIn().type() == typeid(itkImageTypePointer) ) + { + bbSetOutputOut ( bbGetInputIn().template unsafe_get < itkImageTypePointer >() ); + } + else + { + bbtkError(this->bbGetFullName()<<+" : transform of <" + < into <" + <()<<"> not implemented"); + } + } + //================================================================= + + +} +#endif +#endif diff --git a/packages/itk/src/bbitkBinaryThresholdImageFilter.cxx b/packages/itk/src/bbitkBinaryThresholdImageFilter.cxx new file mode 100644 index 0000000..5d8bae2 --- /dev/null +++ b/packages/itk/src/bbitkBinaryThresholdImageFilter.cxx @@ -0,0 +1,19 @@ +#ifdef _USE_ITK_ + +#include "bbitkBinaryThresholdImageFilter.h" +#include "bbitkPackage.h" +namespace bbitk +{ + + BBTK_USER_BLACK_BOX_TEMPLATE_IMPLEMENTATION(BinaryThresholdImageFilter, + bbtk::UserBlackBox); + BBTK_USER_BLACK_BOX_IMPLEMENTATION(BinaryThresholdImageFilterGeneric, + bbtk::UserBlackBox); + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk, + BinaryThresholdImageFilterGeneric); +} + +// EO namespace bbtk + +#endif //_USE_ITK_ + diff --git a/packages/itk/src/bbitkBinaryThresholdImageFilter.h b/packages/itk/src/bbitkBinaryThresholdImageFilter.h new file mode 100644 index 0000000..1e2677a --- /dev/null +++ b/packages/itk/src/bbitkBinaryThresholdImageFilter.h @@ -0,0 +1,148 @@ +#ifdef _USE_ITK_ + +#include "bbtkUserBlackBox.h" +#include "itkBinaryThresholdImageFilter.h" +#include "bbitkImage.h" + +namespace bbitk +{ + + template + class /*BBTK_EXPORT*/ BinaryThresholdImageFilter + : + public bbtk::UserBlackBox, + public itk::BinaryThresholdImageFilter + { + BBTK_USER_BLACK_BOX_INTERFACE(BinaryThresholdImageFilter, + bbtk::UserBlackBox); + typedef itk::BinaryThresholdImageFilter itkParent; + BBTK_DECLARE_ITK_INPUT(itkParent,In,const T*); + BBTK_DECLARE_ITK_PARAM(itkParent,LowerThreshold,typename T::PixelType); + BBTK_DECLARE_ITK_PARAM(itkParent,UpperThreshold,typename T::PixelType); + BBTK_DECLARE_ITK_PARAM(itkParent,InsideValue,typename T::PixelType); + BBTK_DECLARE_ITK_PARAM(itkParent,OutsideValue,typename T::PixelType); + BBTK_DECLARE_ITK_OUTPUT(itkParent,Out,T*); + BBTK_PROCESS(itkParent::Update); + void bbDelete() { itkParent::UnRegister(); } + + void bbUserConstructor() { Init(); } + void bbUserCopyConstructor() { Init(); } + void Init(); + + }; + + BBTK_BEGIN_DESCRIBE_TEMPLATE_BLACK_BOX(BinaryThresholdImageFilter); + BBTK_NAME("BinaryThresholdImageFilter<"+bbtk::TypeName()+">"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Binarizes an image by thresholding (bbification of itk::BinaryThresholdImageFilter)"); + BBTK_TEMPLATE_INPUT(BinaryThresholdImageFilter,In,"Input image",const T*); + BBTK_TEMPLATE_INPUT(BinaryThresholdImageFilter,LowerThreshold, + "Lower threshold",typename T::PixelType); + BBTK_TEMPLATE_INPUT(BinaryThresholdImageFilter,UpperThreshold, + "Upper threshold",typename T::PixelType); + BBTK_TEMPLATE_INPUT(BinaryThresholdImageFilter,InsideValue, + "Output value for pixels inside thresholds", + typename T::PixelType); + BBTK_TEMPLATE_INPUT(BinaryThresholdImageFilter,OutsideValue, + "Output value for pixels outside thresholds", + typename T::PixelType); + BBTK_TEMPLATE_OUTPUT(BinaryThresholdImageFilter,Out,"Output image",T*); + BBTK_END_DESCRIBE_TEMPLATE_BLACK_BOX(BinaryThresholdImageFilter); + + //=================================================== + // Generic "untemplatized" filter + //=================================================== + class /*BBTK_EXPORT*/ BinaryThresholdImageFilterGeneric + : + public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(BinaryThresholdImageFilterGeneric, + bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,anyImagePointer); + BBTK_DECLARE_INPUT(LowerThreshold,double); + BBTK_DECLARE_INPUT(UpperThreshold,double); + BBTK_DECLARE_INPUT(InsideValue,double); + BBTK_DECLARE_INPUT(OutsideValue,double); + BBTK_DECLARE_OUTPUT(Out,anyImagePointer); + BBTK_PROCESS(ProcessSwitch); + private : + inline void ProcessSwitch(); + template void Process(); + void bbUserConstructor() { Init(); } + void bbUserCopyConstructor() { Init(); } + void Init(); + }; + + BBTK_BEGIN_DESCRIBE_BLACK_BOX(BinaryThresholdImageFilterGeneric, + bbtk::UserBlackBox); + BBTK_NAME("BinaryThresholdImageFilter"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Binarizes an image by thresholding (generic bbification of itk::BinaryThresholdImageFilter)"); + BBTK_INPUT(BinaryThresholdImageFilterGeneric,In, + "Input image. Can be any itk::Image*",anyImagePointer); + BBTK_INPUT(BinaryThresholdImageFilterGeneric,LowerThreshold, + "Lower threshold",double); + BBTK_INPUT(BinaryThresholdImageFilterGeneric,UpperThreshold, + "Upper threshold",double); + BBTK_INPUT(BinaryThresholdImageFilterGeneric,InsideValue, + "Output value for pixels inside thresholds",double); + BBTK_INPUT(BinaryThresholdImageFilterGeneric,OutsideValue, + "Output value for pixels outside thresholds",double); + BBTK_OUTPUT(BinaryThresholdImageFilterGeneric,Out, + "Output image. Of the same type and dimension than the input image", + anyImagePointer); + BBTK_END_DESCRIBE_BLACK_BOX(BinaryThresholdImageFilterGeneric); + + + + void BinaryThresholdImageFilterGeneric::ProcessSwitch() + { + BBTK_TEMPLATE_ITK_IMAGE_SWITCH(bbGetInputIn().type(), this->Process); + } + + template + void BinaryThresholdImageFilterGeneric::Process() + { + bbtkDebugMessageInc("Core",9, + "bbitk::BinaryThresholdImageFilterGeneric::Process<" + <()<<">()"< FilterType; + FilterType* f = FilterType::bbNew("Temp"); + f->bbSetInputIn( this->bbGetInputIn().get()); + f->bbSetInputLowerThreshold ( (typename T::PixelType) + this->bbGetInputLowerThreshold() ); + f->bbSetInputUpperThreshold ( (typename T::PixelType) + this->bbGetInputUpperThreshold() ); + f->bbSetInputInsideValue ( (typename T::PixelType) + this->bbGetInputInsideValue() ); + f->bbSetInputOutsideValue ( (typename T::PixelType) + this->bbGetInputOutsideValue() ); + f->bbExecute(); + f->bbGetOutputOut()->Register(); + this->bbSetOutputOut( f->bbGetOutputOut() ); + f->bbDelete(); + bbtkDebugDecTab("Core",9); + } + + template + void BinaryThresholdImageFilter::Init() + { + bbSetInputLowerThreshold(0); + bbSetInputUpperThreshold(100); + bbSetInputInsideValue(255); + bbSetInputOutsideValue(0); + } + + void BinaryThresholdImageFilterGeneric::Init() + { + bbSetInputLowerThreshold(0); + bbSetInputUpperThreshold(100); + bbSetInputInsideValue(255); + bbSetInputOutsideValue(0); + } + +} +// EO namespace bbtk + +#endif diff --git a/packages/itk/src/bbitkExtractImageFilter.cxx b/packages/itk/src/bbitkExtractImageFilter.cxx new file mode 100644 index 0000000..b1dee2c --- /dev/null +++ b/packages/itk/src/bbitkExtractImageFilter.cxx @@ -0,0 +1,22 @@ +#ifdef _USE_ITK_ + +#include "bbitkExtractImageFilter.h" +#include "bbitkPackage.h" + +namespace bbitk +{ + + BBTK_USER_BLACK_BOX_TEMPLATE_IMPLEMENTATION(ExtractImageFilter, + bbtk::UserBlackBox); + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ExtractImageFilterGeneric, + bbtk::UserBlackBox); + + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ExtractImageFilterGeneric) + + +} +// EO namespace bbitk + + +#endif // _USE_ITK_ + diff --git a/packages/itk/src/bbitkExtractImageFilter.h b/packages/itk/src/bbitkExtractImageFilter.h new file mode 100644 index 0000000..6266b8b --- /dev/null +++ b/packages/itk/src/bbitkExtractImageFilter.h @@ -0,0 +1,91 @@ +#ifdef _USE_ITK_ + +#include "bbtkUserBlackBox.h" +#include "itkExtractImageFilter.h" +#include "bbitkImage.h" +#include "bbitkImageRegion.h" + +namespace bbitk +{ + + + template + class /*BBTK_EXPORT*/ ExtractImageFilter + : + public bbtk::UserBlackBox, + public itk::ExtractImageFilter + { + BBTK_USER_BLACK_BOX_INTERFACE(ExtractImageFilter,bbtk::UserBlackBox); + typedef itk::ExtractImageFilter itkParent; + + BBTK_DECLARE_ITK_INPUT(itkParent,In,const T*); + BBTK_DECLARE_ITK_PARAM(itkParent,ExtractionRegion,typename T::RegionType); + BBTK_DECLARE_ITK_OUTPUT(itkParent,Out,T*); + BBTK_PROCESS(itkParent::Update); + + void bbDelete() { itkParent::UnRegister(); } + }; + + + BBTK_BEGIN_DESCRIBE_TEMPLATE_BLACK_BOX(ExtractImageFilter); + BBTK_NAME("ExtractImageFilter<"+bbtk::TypeName()+">"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Decrease the image size by cropping the image to the selected region bounds (bbification of itk::ExtractImageFilter)"); + BBTK_TEMPLATE_INPUT(ExtractImageFilter,In,"Input image",const T*); + BBTK_TEMPLATE_INPUT(ExtractImageFilter,ExtractionRegion,"Extraction region",typename T::RegionType); + BBTK_TEMPLATE_OUTPUT(ExtractImageFilter,Out,"Output image",T*); + BBTK_END_DESCRIBE_TEMPLATE_BLACK_BOX(ExtractImageFilter); + + //=================================================== + // Generic "untemplatized" filter + //=================================================== + class /*BBTK_EXPORT*/ ExtractImageFilterGeneric + : public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(ExtractImageFilterGeneric, + bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,anyImagePointer); + BBTK_DECLARE_INPUT(Region,anyImageRegion); + BBTK_DECLARE_OUTPUT(Out,anyImagePointer); + BBTK_PROCESS(ProcessSwitch); + private : + inline void ProcessSwitch(); + template void Process(); + }; + + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ExtractImageFilterGeneric,bbtk::UserBlackBox); + BBTK_NAME("ExtractImageFilter"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Decrease the image size by cropping the image to the selected region bounds (bbification of itk::ExtractImageFilter)"); + BBTK_INPUT(ExtractImageFilterGeneric,In,"Input image",anyImagePointer); + BBTK_INPUT(ExtractImageFilterGeneric,Region,"Extraction region",anyImageRegion); + BBTK_OUTPUT(ExtractImageFilterGeneric,Out,"Output image",anyImagePointer); + BBTK_END_DESCRIBE_BLACK_BOX(ExtractImageFilterGeneric); + void ExtractImageFilterGeneric::ProcessSwitch() + { + BBTK_TEMPLATE_ITK_IMAGE_SWITCH(bbGetInputIn().type(), this->Process); + } + + template + void ExtractImageFilterGeneric::Process() + { + bbtkDebugMessageInc("Core",9, + "bbitk::ExtractImageFilterGeneric::Process<" + <()<<">()"< FilterType; + FilterType* f = FilterType::bbNew("Temp"); + f->bbSetInputIn( this->bbGetInputIn().unsafe_get() ); + f->bbSetInputExtractionRegion ( this->bbGetInputRegion().get() ); + f->bbExecute(); + f->bbGetOutputOut()->Register(); + this->bbSetOutputOut( f->bbGetOutputOut() ); + f->bbDelete(); + + bbtkDebugDecTab("Core",9); + } + +} +// EO namespace bbitk + +#endif diff --git a/packages/itk/src/bbitkImage.cxx b/packages/itk/src/bbitkImage.cxx new file mode 100644 index 0000000..36a2c99 --- /dev/null +++ b/packages/itk/src/bbitkImage.cxx @@ -0,0 +1,21 @@ +#ifdef _USE_ITK_ + +#include "bbitkImage.h" +#include "bbstdRelay.h" +#include "bbitkPackage.h" + +namespace bbstd +{ + + //==================================================================== + BBTK_USER_BLACK_BOX_TEMPLATE_IMPLEMENTATION(Relay, + bbtk::UserBlackBox); + //==================================================================== +} +using namespace bbstd; +namespace bbitk +{ + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,Relay,anyImagePointer); +} // namespace bbitk + +#endif diff --git a/packages/itk/src/bbitkImage.h b/packages/itk/src/bbitkImage.h new file mode 100644 index 0000000..2e67462 --- /dev/null +++ b/packages/itk/src/bbitkImage.h @@ -0,0 +1,561 @@ +#ifdef _USE_ITK_ + +#ifndef __BBITKIMAGE_H_INCLUDED__ +#define __BBITKIMAGE_H_INCLUDED__ + +#include "itkImage.h" +#include "bbtkAny.h" +#include "bbtkSystem.h" + +namespace bbitk +{ + + // bbtk typedefs for itk images +#define BBTK_TYPEDEF_ITK_IMAGE(TYPE,DIM) \ + typedef itk::Image Image_##TYPE##_##DIM; \ + typedef const Image_##TYPE##_##DIM Image_##TYPE##_##DIM##_c; \ + typedef Image_##TYPE##_##DIM * Image_##TYPE##_##DIM##_ptr; \ + typedef Image_##TYPE##_##DIM##_c * Image_##TYPE##_##DIM##_cptr; + + +#define BBTK_TYPEDEF_ITK_IMAGES_DIM(DIM) \ + BBTK_TYPEDEF_ITK_IMAGE(int8_t,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(uint8_t,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(int16_t,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(uint16_t,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(int32_t,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(uint32_t,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(float,DIM); \ + BBTK_TYPEDEF_ITK_IMAGE(double,DIM) + + BBTK_TYPEDEF_ITK_IMAGES_DIM(2); + BBTK_TYPEDEF_ITK_IMAGES_DIM(3); + BBTK_TYPEDEF_ITK_IMAGES_DIM(4); + //BBTK_TYPEDEF_ITK_IMAGES_DIM(5) + + + +#define BBTK_BEGIN_TEMPLATE_SWITCH(TYPE_INFO) if (false) {} + +#define BBTK_END_TEMPLATE_SWITCH(TYPE_INFO) else { bbtkError("bbtk was not built for itk images of type <"<< bbtk::demangle_type_name(TYPE_INFO.name())<<">"); } + +#define BBTK_END_TEMPLATE_SWITCH_MESSAGE(TYPE_INFO,MESSAGE) else { bbtkError(MESSAGE); } + + /// Generic macro which calls a TEMPLATE_FUNCTION instanciated + /// on TEMPLATE_TYPE iff TYPE_INFO == typeid(TEST_TYPE). + /// This macro must be used (maybe several times) between a pair of BEGIN_TEMPLATE_SWITCH and END_TEMPLATE_SWITCH macros +#define TEMPLATE_SWITCH(TYPE_INFO,TEST_TYPE,TEMPLATE_FUNCTION,TEMPLATE_TYPE) \ + else if (TYPE_INFO == typeid(bbitk::TEST_TYPE)) \ + { TEMPLATE_FUNCTION(); } + + +// DIMENSION 2 +#ifdef BBTK_ITK_IMAGE_DIM_2 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t +# define BBTK_SWITCH_ITK_IMAGE_int8_t_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int8_t_2_##CONST##ptr,FUN,Image_int8_t_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_int8_t_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t +# define BBTK_SWITCH_ITK_IMAGE_int16_t_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int16_t_2_##CONST##ptr,FUN,Image_int16_t_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_int16_t_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t +# define BBTK_SWITCH_ITK_IMAGE_int32_t_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int32_t_2_##CONST##ptr,FUN,Image_int32_t_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_int32_t_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint8_t_2_##CONST##ptr,FUN,Image_uint8_t_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint16_t_2_##CONST##ptr,FUN,Image_uint16_t_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint32_t_2_##CONST##ptr,FUN,Image_uint32_t_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float +# define BBTK_SWITCH_ITK_IMAGE_float_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_float_2_##CONST##ptr,FUN,Image_float_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_float_2(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double +# define BBTK_SWITCH_ITK_IMAGE_double_2(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_double_2_##CONST##ptr,FUN,Image_double_2) +# else +# define BBTK_SWITCH_ITK_IMAGE_double_2(TYPE_INFO,FUN,CONST) +# endif +#else +# define BBTK_SWITCH_ITK_IMAGE_int8_t_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_int16_t_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_int32_t_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_float_2(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_double_2(TYPE_INFO,FUN,CONST) +#endif + + +// DIMENSION 3 +#ifdef BBTK_ITK_IMAGE_DIM_3 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t +# define BBTK_SWITCH_ITK_IMAGE_int8_t_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int8_t_3_##CONST##ptr,FUN,Image_int8_t_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_int8_t_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t +# define BBTK_SWITCH_ITK_IMAGE_int16_t_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int16_t_3_##CONST##ptr,FUN,Image_int16_t_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_int16_t_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t +# define BBTK_SWITCH_ITK_IMAGE_int32_t_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int32_t_3_##CONST##ptr,FUN,Image_int32_t_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_int32_t_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint8_t_3_##CONST##ptr,FUN,Image_uint8_t_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint16_t_3_##CONST##ptr,FUN,Image_uint16_t_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint32_t_3_##CONST##ptr,FUN,Image_uint32_t_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float +# define BBTK_SWITCH_ITK_IMAGE_float_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_float_3_##CONST##ptr,FUN,Image_float_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_float_3(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double +# define BBTK_SWITCH_ITK_IMAGE_double_3(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_double_3_##CONST##ptr,FUN,Image_double_3) +# else +# define BBTK_SWITCH_ITK_IMAGE_double_3(TYPE_INFO,FUN,CONST) +# endif +#else +# define BBTK_SWITCH_ITK_IMAGE_int8_t_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_int16_t_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_int32_t_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_float_3(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_double_3(TYPE_INFO,FUN,CONST) +#endif + + + // DIMENSION 4 +#ifdef BBTK_ITK_IMAGE_DIM_4 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t +# define BBTK_SWITCH_ITK_IMAGE_int8_t_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int8_t_4_##CONST##ptr,FUN,Image_int8_t_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_int8_t_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t +# define BBTK_SWITCH_ITK_IMAGE_int16_t_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int16_t_4_##CONST##ptr,FUN,Image_int16_t_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_int16_t_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t +# define BBTK_SWITCH_ITK_IMAGE_int32_t_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_int32_t_4_##CONST##ptr,FUN,Image_int32_t_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_int32_t_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint8_t_4_##CONST##ptr,FUN,Image_uint8_t_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint16_t_4_##CONST##ptr,FUN,Image_uint16_t_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_uint32_t_4_##CONST##ptr,FUN,Image_uint32_t_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float +# define BBTK_SWITCH_ITK_IMAGE_float_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_float_4_##CONST##ptr,FUN,Image_float_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_float_4(TYPE_INFO,FUN,CONST) +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double +# define BBTK_SWITCH_ITK_IMAGE_double_4(TYPE_INFO,FUN,CONST) \ + TEMPLATE_SWITCH(TYPE_INFO,Image_double_4_##CONST##ptr,FUN,Image_double_4) +# else +# define BBTK_SWITCH_ITK_IMAGE_double_4(TYPE_INFO,FUN,CONST) +# endif +#else +# define BBTK_SWITCH_ITK_IMAGE_int8_t_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_int16_t_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_int32_t_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint8_t_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint16_t_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_uint32_t_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_float_4(TYPE_INFO,FUN,CONST) +# define BBTK_SWITCH_ITK_IMAGE_double_4(TYPE_INFO,FUN,CONST) +#endif + + + /// General macro which calls the template function FUN instanciated + /// on the right type of itk image depending on the value of TYPE_INFO (which must be of type type_info). +#define BBTK_TEMPLATE_ITK_IMAGE_SWITCH(TYPE_INFO,FUN) \ + BBTK_BEGIN_TEMPLATE_SWITCH(TYPE_INFO) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_float_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_double_2(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_float_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_double_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_float_4(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_double_4(TYPE_INFO,FUN,) \ + BBTK_END_TEMPLATE_SWITCH(TYPE_INFO) + + /// General macro which calls the template function FUN instanciated + /// on the right type of itk image depending on the value of TYPE_INFO (which must be of type type_info). +#define BBTK_TEMPLATE_ITK_IMAGE_DIM_3_SWITCH(TYPE_INFO,FUN,ERROR_MESSAGE) \ + BBTK_BEGIN_TEMPLATE_SWITCH(TYPE_INFO) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_float_3(TYPE_INFO,FUN,) \ + BBTK_SWITCH_ITK_IMAGE_double_3(TYPE_INFO,FUN,) \ + BBTK_END_TEMPLATE_SWITCH_MESSAGE(TYPE_INFO,ERROR_MESSAGE) + + + /// General macro which calls the template function FUN instanciated + /// on the right type of itk image depending on the value of TYPE_INFO (which must be of type type_info). + +#define BBTK_TEMPLATE_CONST_ITK_IMAGE_SWITCH(TYPE_INFO,FUN) \ + BBTK_BEGIN_TEMPLATE_SWITCH(TYPE_INFO) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_float_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_double_2(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_float_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_double_3(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int8_t_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int16_t_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_int32_t_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint8_t_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint16_t_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_uint32_t_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_float_4(TYPE_INFO,FUN,c) \ + BBTK_SWITCH_ITK_IMAGE_double_4(TYPE_INFO,FUN,c) \ + BBTK_END_TEMPLATE_SWITCH(TYPE_INFO) + +#define BBTK_GITIFPTI_DIM(DIM) \ + if (pti == typeid(unsigned char)) \ + return typeid(itk::Image*); \ + if (pti == typeid(unsigned short)) \ + return typeid(itk::Image*); \ + if (pti == typeid(unsigned int)) \ + return typeid(itk::Image*); \ + if (pti == typeid(unsigned long)) \ + return typeid(itk::Image*); \ + if (pti == typeid(signed char)) \ + return typeid(itk::Image*); \ + if (pti == typeid(signed short)) \ + return typeid(itk::Image*); \ + if (pti == typeid(signed int)) \ + return typeid(itk::Image*); \ + if (pti == typeid(signed long)) \ + return typeid(itk::Image*); \ + if (pti == typeid(float)) \ + return typeid(itk::Image*); \ + if (pti == typeid(double)) \ + return typeid(itk::Image*); + + + inline bbtk::TypeInfo GetITKImagePtrTypeInfoFromPixelTypeInfoAndDimension( + bbtk::TypeInfo pti, + unsigned int dim ) + { + if (dim==2) { BBTK_GITIFPTI_DIM(2); } + else if (dim==3) { BBTK_GITIFPTI_DIM(3); } + else if (dim==4) { BBTK_GITIFPTI_DIM(4); } + else + { + //bbtkGlobalError("GetImageTypeInfoFromPixelTypeInfo : itk::Images not compiled for dim "< +class TypeMapping +{ +public: + TypeMapping() {} + + template + ValueType& value() + { + return m_map[ (void*)typeid(T).name() ]; + } + template + ValueType& operator[]( const T& ) + { + return m_map[ (void*)typeid(T).name() ]; + } + + ValueType& operator[]( const std::type_info& t) + { + return m_map[ (void*)t.name() ]; + } + + unsigned int size() const { return m_map.size(); } + + typedef typename std::map::const_iterator const_iterator; + + const_iterator begin() const { return m_map.begin(); } + const_iterator end() const { return m_map.end(); } + +protected: + std::map m_map; +}; + +#define BBTK_BUILD_ITK_IMAGE_FUNCTION_MAPPING(MAP,FUN) \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; \ + MAP.value() = FUN; + + //======================================================================= + + + //======================================================================= + // Type traits ImagePointer to define bbtk::any + /// The TypeTraits for all itk::Image pointer types + template struct ImagePointer { static const bool value = false; }; + + typedef bbtk::any anyImagePointer; + + // Specialisations for instantiated image types + // DIMENSION 2 +#ifdef BBTK_ITK_IMAGE_DIM_2 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + template <> struct ImagePointer { static const bool value = true; }; +# endif +#endif + + + +#ifdef BBTK_ITK_IMAGE_DIM_3 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + template <> struct ImagePointer { static const bool value = true; }; +# endif +#endif + + + +#ifdef BBTK_ITK_IMAGE_DIM_4 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + template <> struct ImagePointer { static const bool value = true; }; +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + template <> struct ImagePointer { static const bool value = true; }; +# endif +#endif + + +} // namespace bbitk + +namespace bbtk +{ + BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbitk::anyImagePointer,"anyItkImagePointer"); +// BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbitk::Image_double_2_ptr,"itkImageDouble3ptr"); +// BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbitk::Image_double_3_ptr,"itkImageDouble3ptr"); + + // Human readable names for itk images +// #define BBTK_HUMAN_READABLE_ITK_IMAGE_NAME(TYPE,DIM) std::string("itkImage")+HumanTypeName()+std::string(#DIM)+std::string("ptr") + +#define BBTK_HUMAN_READABLE_ITK_IMAGE(TYPE,DIM) \ +template <> inline std::string HumanTypeName< bbitk::Image_##TYPE##_##DIM##_ptr >() \ + { std::string n("itkImage"); \ + n+= HumanTypeName();\ + n += std::string(#DIM);\ +n += std::string("ptr"); \ + return n; } \ + template <> inline std::string HumanTypeName< bbitk::Image_##TYPE##_##DIM##_ptr >(const bbitk::Image_##TYPE##_##DIM##_ptr &) \ + { std::string n("itkImage");\ + n+= HumanTypeName(); \ + n += std::string(#DIM); \ +n+= std::string("ptr"); \ + return n; } + +//BBTK_HUMAN_READABLE_ITK_IMAGE(int8_t,2); + +// BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbitk::Image_##TYPE##_##DIM##_ptr,BBTK_HUMAN_READABLE_ITK_IMAGE_NAME(TYPE,DIM) ) + + +#define BBTK_HUMAN_READABLE_ITK_IMAGES_DIM(DIM) \ + BBTK_HUMAN_READABLE_ITK_IMAGE(int8_t,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(uint8_t,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(int16_t,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(uint16_t,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(int32_t,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(uint32_t,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(float,DIM); \ + BBTK_HUMAN_READABLE_ITK_IMAGE(double,DIM) + + BBTK_HUMAN_READABLE_ITK_IMAGES_DIM(2); + BBTK_HUMAN_READABLE_ITK_IMAGES_DIM(3); + BBTK_HUMAN_READABLE_ITK_IMAGES_DIM(4); + //BBTK_HUMAN_READABLE_ITK_IMAGES_DIM(5) + + +} // namespace bbtk + +#endif +#endif diff --git a/packages/itk/src/bbitkImageProperties.cxx b/packages/itk/src/bbitkImageProperties.cxx new file mode 100644 index 0000000..3202074 --- /dev/null +++ b/packages/itk/src/bbitkImageProperties.cxx @@ -0,0 +1,87 @@ +/*========================================================================= + + Program: bbtk + Module: $RCSfile: bbitkImageProperties.cxx,v $ + Language: C++ + Date: $Date: 2008/02/05 12:03:01 $ + Version: $Revision: 1.1 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +/** + * \file + * \brief + */ +#ifdef _USE_ITK_ + +#include "bbitkImageProperties.h" +#include "bbitkPackage.h" + +namespace bbitk +{ + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ImageProperties,bbtk::UserBlackBox); + + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ImageProperties); + + + + + void ImageProperties::DoIt() + { + BBTK_TEMPLATE_ITK_IMAGE_SWITCH(bbGetInputIn().type(),DoIt); + } + + + + /** + Template Processing + */ + template + void ImageProperties::DoIt() + { + bbtkDebugMessageInc("Core",9,"bbitk::ImageProperties::DoIt<" + <() + <<">()"<(); + unsigned int dim = im->GetImageDimension(); + + bbSetOutputTypeName(bbtk::TypeName()); + bbSetOutputDimension(dim); + const typename itkImageType::RegionType& r =im->GetLargestPossibleRegion(); + bbSetOutputLargestPossibleRegion(r); + + const typename itkImageType::IndexType& ind = r.GetIndex(); + std::vector vind; + for (int i=0;i vsz; + for (int i=0;iGetSpacing(); + std::vector vsp; + for (int i=0;i); + BBTK_DECLARE_OUTPUT(Size,std::vector); + BBTK_DECLARE_OUTPUT(Spacing,std::vector); + BBTK_PROCESS(DoIt); + void DoIt(); + + private: + // Template doit method + template void DoIt(); + }; + + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ImageProperties,bbtk::UserBlackBox); + BBTK_NAME("ImageProperties"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Extracts the different properties of an image (type, dimension, size, spacing, ...)"); + BBTK_INPUT(ImageProperties,In,"Input image",anyImagePointer); + BBTK_OUTPUT(ImageProperties,TypeName,"Pixel type name",std::string); + BBTK_OUTPUT(ImageProperties,Dimension,"Dimension",unsigned int); + BBTK_OUTPUT(ImageProperties,LargestPossibleRegion,"Global extent of the image",anyImageRegion); + BBTK_OUTPUT(ImageProperties,Index,"Origin of the image",std::vector); + BBTK_OUTPUT(ImageProperties,Size,"Size in each dimension",std::vector); + BBTK_OUTPUT(ImageProperties,Spacing,"Size of the voxels",std::vector); + BBTK_END_DESCRIBE_BLACK_BOX(ImageProperties); + //================================================================= + + +} +//namespace bbitk +#endif + +#endif diff --git a/packages/itk/src/bbitkImageReader.cxx b/packages/itk/src/bbitkImageReader.cxx new file mode 100644 index 0000000..bb7938d --- /dev/null +++ b/packages/itk/src/bbitkImageReader.cxx @@ -0,0 +1,93 @@ +/*========================================================================= + + Program: bbtk + Module: $RCSfile: bbitkImageReader.cxx,v $ + Language: C++ + Date: $Date: 2008/02/05 12:03:01 $ + Version: $Revision: 1.1 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +/** + * \file + * \brief + */ +#ifdef _USE_ITK_ + +#include "bbitkImageReader.h" +#include "bbitkPackage.h" +#include "itkImageFileReader.h" + +namespace bbitk +{ + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ImageReader,bbtk::UserBlackBox); + + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ImageReader); + + + + + void ImageReader::Read() + { + std::string filename = bbGetInputFilename(); + + itk::ImageIOBase::Pointer genericReader = + itk::ImageIOFactory::CreateImageIO(filename.c_str(), + itk::ImageIOFactory::ReadMode); + if (!genericReader) + { + bbtkError("File format unknown (while reading \"" << filename << "\")"); + } + genericReader->SetFileName(filename.c_str()); + genericReader->ReadImageInformation(); + + bbtk::TypeInfo typ = GetITKImagePtrTypeInfoFromPixelTypeInfoAndDimension(genericReader->GetComponentTypeInfo(), genericReader->GetNumberOfDimensions()); + + BBTK_TEMPLATE_ITK_IMAGE_SWITCH( typ, Read); + } + + + + /** + Template Processing + */ + template + void ImageReader::Read() + { + bbtkDebugMessageInc("Core",9,"itkImageReader<"<< + bbtk::TypeName() + <<">::Read()"< itkReaderType; + + typename itkReaderType::Pointer reader = itkReaderType::New(); + std::string filename = bbGetInputFilename(); + reader->SetFileName(filename.c_str()); + try { reader->Update(); } + catch( std::exception& e ) + { + bbtkError("could not read image \""<< filename << "\" : "<GetOutput()->Register(); + bbSetOutputOut( reader->GetOutput() ); + + bbtkDebugDecTab("Core",9); + } + + + + + + +} +// eo namespace bbtk + +#endif diff --git a/packages/itk/src/bbitkImageReader.h b/packages/itk/src/bbitkImageReader.h new file mode 100644 index 0000000..53a9fe8 --- /dev/null +++ b/packages/itk/src/bbitkImageReader.h @@ -0,0 +1,71 @@ +/*========================================================================= + + Program: bbtk + Module: $RCSfile: bbitkImageReader.h,v $ + Language: C++ + Date: $Date: 2008/02/05 12:03:01 $ + Version: $Revision: 1.1 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*//** +/** + * \file + * \brief class ITKImageReader : generic ITKImage reader + */ +/** + * \class bbtk::ITKImageReader + * \brief Generic ITKImage reader + */ +#ifdef _USE_ITK_ + +#ifndef __bbitkImageReader_h_INCLUDED__ +#define __bbitkImageReader_h_INCLUDED__ + +#include "bbtkUserBlackBox.h" +#include "bbitkImage.h" + +namespace bbitk +{ + + class ImageReader : public bbtk::UserBlackBox + { + + BBTK_USER_BLACK_BOX_INTERFACE(ImageReader, + bbtk::UserBlackBox); + + BBTK_DECLARE_INPUT(Filename,std::string); + BBTK_DECLARE_OUTPUT(Out,anyImagePointer); + BBTK_PROCESS(Read); + void Read(); + + private: + // Template read method + template void Read(); + }; + + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ImageReader,bbtk::UserBlackBox); + BBTK_NAME("ImageReader"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Generic itk image reader"); + BBTK_INPUT(ImageReader,Filename, + "filename with complete path",std::string); + BBTK_OUTPUT(ImageReader,Out,"Output image",anyImagePointer); + BBTK_END_DESCRIBE_BLACK_BOX(ImageReader); + //================================================================= + + +} +//namespace bbtk +#endif + +#endif diff --git a/packages/itk/src/bbitkImageRegion.cxx b/packages/itk/src/bbitkImageRegion.cxx new file mode 100644 index 0000000..746d97b --- /dev/null +++ b/packages/itk/src/bbitkImageRegion.cxx @@ -0,0 +1,72 @@ +#ifdef _USE_ITK_ + +#include "bbitkImageRegion.h" +#include "bbitkPackage.h" + +namespace bbitk +{ + + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ImageRegionCreator, + bbtk::UserBlackBox); + + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ImageRegionCreator); + + + void ImageRegionCreator::DoIt() + { + const std::vector& index = bbGetInputIndex(); + const std::vector& size = bbGetInputSize(); + // std::cout<< "isize="< + void ImageRegionCreator::DoIt() + { + std::vector index = bbGetInputIndex(); + std::vector size = bbGetInputSize(); + // std::cout<< "isize="< + template struct ImageRegion { static const bool value = false; }; + // Specialisations for instantiated image types +#ifdef BBTK_ITK_IMAGE_DIM_2 + typedef itk::ImageRegion<2> ImageRegion_2; + template <> struct ImageRegion { static const bool value = true; }; +#endif +#ifdef BBTK_ITK_IMAGE_DIM_3 + typedef itk::ImageRegion<3> ImageRegion_3; + template <> struct ImageRegion { static const bool value = true; }; +#endif +#ifdef BBTK_ITK_IMAGE_DIM_4 + typedef itk::ImageRegion<4> ImageRegion_4; + template <> struct ImageRegion { static const bool value = true; }; +#endif + + /// + typedef bbtk::any anyImageRegion; +} // namespace bbitk + +namespace bbtk +{ + /// Human readable name for bbtk::any + BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbitk::anyImageRegion,"anyItkImageRegion"); +} // namespace bbtk + + + +namespace bbitk +{ + //======================================================================= + /// Black Box which creates an anyImageRegion + class /*BBTK_EXPORT*/ ImageRegionCreator + : public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(ImageRegionCreator,bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(Index,std::vector); + BBTK_DECLARE_INPUT(Size,std::vector); + BBTK_DECLARE_OUTPUT(Out,anyImageRegion); + BBTK_PROCESS(DoIt); + private: + void DoIt(); + template void DoIt(); + }; + + + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ImageRegionCreator,bbtk::UserBlackBox); + BBTK_NAME("ImageRegion"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Creates a generic ImageRegion ("+bbtk::TypeName()+") from two vectors providing the index and size of the region. The dimension D of the actual itk::ImageRegion created is the max of the sizes of Index and Size (the smallest vector is padded by zeros)."); + typedef std::vector vectoroflong; + BBTK_INPUT(ImageRegionCreator,Index,"Vector of region indices", + vectoroflong); + BBTK_INPUT(ImageRegionCreator,Size,"Vector of region sizes", + vectoroflong); + BBTK_OUTPUT(ImageRegionCreator,Out,"Output generic region",anyImageRegion); + BBTK_END_DESCRIBE_BLACK_BOX(ImageRegionCreator); + +} // namespace bbitk + + +#endif +#endif diff --git a/packages/itk/src/bbitkImageSeriesReader.cxx b/packages/itk/src/bbitkImageSeriesReader.cxx new file mode 100644 index 0000000..ac3c114 --- /dev/null +++ b/packages/itk/src/bbitkImageSeriesReader.cxx @@ -0,0 +1,103 @@ +/*========================================================================= + + Program: bbtk + Module: $RCSfile: bbitkImageSeriesReader.cxx,v $ + Language: C++ + Date: $Date: 2008/02/05 12:03:01 $ + Version: $Revision: 1.1 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +/** + * \file + * \brief + */ +#ifdef _USE_ITK_ + +#include "bbitkImageSeriesReader.h" +#include "bbitkPackage.h" +#include "itkImageSeriesReader.h" + +namespace bbitk +{ + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ImageSeriesReader,bbtk::UserBlackBox); + + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ImageSeriesReader); + + + + + void ImageSeriesReader::Read() + { + const std::vector& filenames = bbGetInputFileNames(); + if (!filenames.size()) + { + bbtkError("Void vector passed to "<SetFileName(filename.c_str()); + genericReader->ReadImageInformation(); + + bbtk::TypeInfo typ = GetITKImagePtrTypeInfoFromPixelTypeInfoAndDimension(genericReader->GetComponentTypeInfo(), genericReader->GetNumberOfDimensions()); + + BBTK_TEMPLATE_ITK_IMAGE_SWITCH(typ,Read); + + } + + + + /** + Template Processing + */ + template + void ImageSeriesReader::Read() + { + bbtkDebugMessageInc("Core",9,"bbitk::ImageSeriesReader<" + <() + <<">::Read()"< itkReaderType; + + typename itkReaderType::Pointer reader = itkReaderType::New(); + const std::vector& filenames = bbGetInputFileNames(); + reader->SetFileNames(filenames); + try { reader->Update(); } + catch( std::exception& e ) + { + bbtkError("could not read image series : "<GetOutput()->Register(); + bbSetOutputOut ( reader->GetOutput() ); + + bbtkDebugDecTab("Core",9); + } + + + + + + +} +// eo namespace bbtk + +#endif diff --git a/packages/itk/src/bbitkImageSeriesReader.h b/packages/itk/src/bbitkImageSeriesReader.h new file mode 100644 index 0000000..58f7818 --- /dev/null +++ b/packages/itk/src/bbitkImageSeriesReader.h @@ -0,0 +1,72 @@ +/*========================================================================= + + Program: bbtk + Module: $RCSfile: bbitkImageSeriesReader.h,v $ + Language: C++ + Date: $Date: 2008/02/05 12:03:02 $ + Version: $Revision: 1.1 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*//** +/** + * \file + * \brief class ITKImageSeriesReader : generic ITKImage reader + */ +/** + * \class bbtk::ITKImageSeriesReader + * \brief Generic ITKImage reader + */ +#ifdef _USE_ITK_ + +#ifndef __bbitkImageSeriesReader_h_INCLUDED__ +#define __bbitkImageSeriesReader_h_INCLUDED__ + +#include "bbtkUserBlackBox.h" +#include "bbitkImage.h" + +namespace bbitk +{ + + class ImageSeriesReader : public bbtk::UserBlackBox + { + + BBTK_USER_BLACK_BOX_INTERFACE(ImageSeriesReader, + bbtk::UserBlackBox); + + BBTK_DECLARE_INPUT(FileNames,std::vector); + BBTK_DECLARE_OUTPUT(Out,anyImagePointer); + BBTK_PROCESS(Read); + void Read(); + + private: + // Template read method + template void Read(); + }; + + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ImageSeriesReader,bbtk::UserBlackBox); + BBTK_NAME("ImageSeriesReader"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Generic itk image series reader"); + typedef std::vector vectorofstring; + BBTK_INPUT(ImageSeriesReader,FileNames, + "vector of file names with complete paths",vectorofstring); + BBTK_OUTPUT(ImageSeriesReader,Out,"Output itk::image with type T and dimension D determined by the content of the files",anyImagePointer); + BBTK_END_DESCRIBE_BLACK_BOX(ImageSeriesReader); + //================================================================= + + +} +//namespace bbtk +#endif + +#endif diff --git a/packages/itk/src/bbitkImageToString.cxx b/packages/itk/src/bbitkImageToString.cxx new file mode 100644 index 0000000..23c30c4 --- /dev/null +++ b/packages/itk/src/bbitkImageToString.cxx @@ -0,0 +1,45 @@ +#ifdef _USE_ITK_ + +#include "bbstdToString.h" +#include "bbitkImage.h" +#include "bbitkPackage.h" +#include + +namespace bbstd +{ + + + //==================================================================== + BBTK_USER_BLACK_BOX_TEMPLATE_IMPLEMENTATION(ToString, + bbtk::UserBlackBox); + //==================================================================== + + //==================================================================== + template <> void ToString > ::DoIt() + { + std::ostringstream s; + itk::Object* o1 = bbGetInputIn().unsafe_get(); + o1->Print(s); + + bbSetOutputOut( s.str() ); + } + //==================================================================== +} // namespace bbstd + + +using namespace bbstd; +namespace bbitk +{ + // typedef bbstd::ToString ToString; + //==================================================================== + // Add the specialized adaptors to the package + typedef bbitk::anyImagePointer anyItkImagePointer; + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,ToString, + anyItkImagePointer); + //typedef const bbtk::itkImage* itkImageConstPointer; + //BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itkBase,ScalarToString,itkImageConstPointer); + +} + + +#endif //_USE_ITK_ diff --git a/packages/itk/src/bbitkImageToString.h b/packages/itk/src/bbitkImageToString.h new file mode 100644 index 0000000..65b4f31 --- /dev/null +++ b/packages/itk/src/bbitkImageToString.h @@ -0,0 +1,17 @@ +/* +#include "ScalarToString.h" +#include "ITKImage.h" +#include "bbPackageITKBase.h" + +//==================================================================== +template <> void ScalarToString ::DoIt() +{ + bbSetOutputOut( bbGetInputIn()->GetInfoString() ); +} +//==================================================================== + +//==================================================================== +// Add the specialized adaptors to the package +typedef itkImage* itkImagePointer; +BBTK_ADD_TEMPLATE_ADAPTOR_TO_PACKAGE(ITKBase,ScalarToString,itkImagePointer); +*/ diff --git a/packages/itk/src/bbitkImageWriter.cxx b/packages/itk/src/bbitkImageWriter.cxx new file mode 100644 index 0000000..8edcc04 --- /dev/null +++ b/packages/itk/src/bbitkImageWriter.cxx @@ -0,0 +1,77 @@ +/*========================================================================= + + Program: bbtk + Module: $RCSfile: bbitkImageWriter.cxx,v $ + Language: C++ + Date: $Date: 2008/02/05 12:03:02 $ + Version: $Revision: 1.1 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +/** + * \file + * \brief + */ +#ifdef _USE_ITK_ + +#include "bbitkImageWriter.h" +#include "bbitkPackage.h" +#include "itkImageFileWriter.h" + +namespace bbitk +{ + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ImageWriter,bbtk::UserBlackBox); + + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ImageWriter); + + + + + void ImageWriter::Write() + { + BBTK_TEMPLATE_ITK_IMAGE_SWITCH(bbGetInputIn().type(),Write); + } + + + + /** + Template Processing + */ + template + void ImageWriter::Write() + { + bbtkDebugMessageInc("Core",9,"bbitk::ImageWriter::Write<" + <() + <<">()"< itkWriterType; + typename itkWriterType::Pointer writer = itkWriterType::New(); + writer->SetInput(bbGetInputIn().unsafe_get()); + writer->SetFileName(bbGetInputFilename().c_str()); + + try { writer->Update(); } + catch( std::exception & e ) + { + bbtkError("could not write image \""<< bbGetInputFilename() + << "\" : "< void Write(); + }; + + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ImageWriter,bbtk::UserBlackBox); + BBTK_NAME("ImageWriter"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Generic itk image writer"); + BBTK_INPUT(ImageWriter,Filename, + "filename with complete path",std::string); + BBTK_INPUT(ImageWriter,In,"Image to write",anyImagePointer); + BBTK_END_DESCRIBE_BLACK_BOX(ImageWriter); + //================================================================= + + +} +//namespace bbitk +#endif + +#endif // _USE_ITK_ diff --git a/packages/itk/src/bbitkResampleImageFilter.cxx b/packages/itk/src/bbitkResampleImageFilter.cxx new file mode 100644 index 0000000..bb51c41 --- /dev/null +++ b/packages/itk/src/bbitkResampleImageFilter.cxx @@ -0,0 +1,15 @@ +#ifdef _USE_ITK_ + +#include "bbitkResampleImageFilter.h" +#include "bbitkPackage.h" +namespace bbitk +{ + + BBTK_USER_BLACK_BOX_IMPLEMENTATION(ResampleImageFilter,bbtk::UserBlackBox); + BBTK_ADD_BLACK_BOX_TO_PACKAGE(itk,ResampleImageFilter); +} + +// EO namespace bbitk + +#endif //_USE_ITK_ + diff --git a/packages/itk/src/bbitkResampleImageFilter.h b/packages/itk/src/bbitkResampleImageFilter.h new file mode 100644 index 0000000..a46bf4c --- /dev/null +++ b/packages/itk/src/bbitkResampleImageFilter.h @@ -0,0 +1,160 @@ +#ifdef _USE_ITK_ + +#include +#include "bbtkUserBlackBox.h" +#include "itkResampleImageFilter.h" +#include "bbitkImage.h" +#include "itkNearestNeighborInterpolateImageFunction.h" +#include "itkLinearInterpolateImageFunction.h" +#include "itkBSplineInterpolateImageFunction.h" + +namespace bbitk +{ + + + class /*BBTK_EXPORT*/ ResampleImageFilter + : + public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(ResampleImageFilter, + bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,anyImagePointer); + BBTK_DECLARE_INPUT(Spacing,std::vector); + BBTK_DECLARE_INPUT(Interpolation,std::string); + BBTK_DECLARE_OUTPUT(Out,anyImagePointer); + BBTK_PROCESS(ProcessSwitch); + private : + inline void ProcessSwitch(); + template void Process(); + void bbUserConstructor() { Init(); } + void bbUserCopyConstructor() { Init(); } + void Init(); + itk::Object* mOutput; + }; + + BBTK_BEGIN_DESCRIBE_BLACK_BOX(ResampleImageFilter, + bbtk::UserBlackBox); + BBTK_NAME("ResampleImageFilter"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Resamples an image"); + BBTK_INPUT(ResampleImageFilter,In, + "Input image. Can be any itk::Image*",anyImagePointer); + BBTK_INPUT(ResampleImageFilter,Spacing, + "Spacing",std::vector); + BBTK_INPUT(ResampleImageFilter,Interpolation, + "Interpolation",std::string); + BBTK_OUTPUT(ResampleImageFilter,Out, + "Output image. Of the same type and dimension than the input image", + anyImagePointer); + BBTK_END_DESCRIBE_BLACK_BOX(ResampleImageFilter); + + + + void ResampleImageFilter::ProcessSwitch() + { + bbtk::TypeInfo t = bbGetInputIn().type(); + BBTK_TEMPLATE_ITK_IMAGE_SWITCH(t, this->Process); + } + + template + void ResampleImageFilter::Process() + { + bbtkDebugMessageInc("Core",9, + "bbitk::ResampleImageFilter::Process<" + <()<<">()"< FilterType; + typename FilterType::Pointer filter = FilterType::New(); + const unsigned int Dimension = ImageType::ImageDimension; + + // Input + T* in = this->bbGetInputIn().get(); + filter->SetInput( in ); + + // Size, Spacing, Origin and DefaultPixelVal + typename ImageType::SizeType size; + typename ImageType::SpacingType spacing; + typename ImageType::PointType origin; + typename ImageType::RegionType LPR; + LPR = in->GetLargestPossibleRegion(); + size = LPR.GetSize(); + // origin = LPR.GetIndex(); //in->GetOrigin(); + for (int i=0;iGetSpacing()[i]; + spacing[i] = bbGetInputSpacing()[i]; + double tmp = (LPR.GetSize()[i]*in->GetSpacing()[i]/spacing[i] ) + 0.5; + size[i] = (long)floor(tmp); +// size[i] = (long)lrint(LPR.GetSize()[i]*in->GetSpacing()[i]/spacing[i]); + } + + filter->SetOutputOrigin (origin); + filter->SetSize (size); + filter->SetOutputSpacing( spacing ); + + filter->SetDefaultPixelValue (0); + filter->SetOutputDirection( in->GetDirection() ); + + + + // Transform + typedef itk::AffineTransform < double, Dimension> TransformType; + + // Instance of the transform object to be passed to the resample filter + // By default, identity transform is applied + typename TransformType::Pointer transform = TransformType::New(); + filter->SetTransform ( transform ); + + + // Interpolation + if ( bbGetInputInterpolation() == "Linear" ) { + typedef itk::LinearInterpolateImageFunction < ImageType, double > InterpolatorType; + // We create an interpolator of the found type + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator( interpolator ); + } + else if ( bbGetInputInterpolation() == "NearestNeighbor" ) { + typedef itk::NearestNeighborInterpolateImageFunction < ImageType, double > InterpolatorType; + // We create an interpolator of the found type + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator( interpolator ); + } + else if ( bbGetInputInterpolation() == "BSpline") { + typedef itk::BSplineInterpolateImageFunction < ImageType, double > InterpolatorType; + // We create an interpolator of the found type + typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); + filter->SetInterpolator(interpolator); + // When handling unsigned data, it is possible that the interpolated value is negative + // if ( (m_InputImage->GetComponentTypeAsString() == "uchar") || + // (m_InputImage->GetComponentTypeAsString() == "ushort") || + // (m_InputImage->GetComponentTypeAsString() == "uint") ) { + // std::cout << "Warning! you're using unsigned data ! The interpolated value may result negative! "<< std::endl; + // } + } //end else if + + + filter->Update(); + filter->GetOutput()->Register(); + if (mOutput) mOutput->UnRegister(); + this->bbSetOutputOut( filter->GetOutput() ); + mOutput = filter->GetOutput(); + + bbtkDebugDecTab("Core",9); + } + + + void ResampleImageFilter::Init() + { + std::vector res; + res.push_back(1); + res.push_back(1); + res.push_back(1); + bbSetInputSpacing(res); + mOutput = 0; + } + +} +// EO namespace bbtk + +#endif diff --git a/packages/itk/src/bbitkTypedImageToAnyImage.cxx b/packages/itk/src/bbitkTypedImageToAnyImage.cxx new file mode 100644 index 0000000..165d7e7 --- /dev/null +++ b/packages/itk/src/bbitkTypedImageToAnyImage.cxx @@ -0,0 +1,125 @@ +#ifdef _USE_ITK_ +#include "bbitkTypedImageToAnyImage.h" +#include "bbitkPackage.h" + +namespace bbitk +{ + //==================================================================== + BBTK_USER_BLACK_BOX_TEMPLATE_IMPLEMENTATION(TypedImageToAnyImage, + bbtk::UserBlackBox); + + //==================================================================== + + +#ifdef BBTK_ITK_IMAGE_DIM_2 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int8_t_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int8_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int16_t_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int16_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int32_t_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int32_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint8_t_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint8_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint16_t_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint16_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint32_t_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint32_t_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_float_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_float_2_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_double_2_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_double_2_cptr); +# endif +#endif + + + +#ifdef BBTK_ITK_IMAGE_DIM_3 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int8_t_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int8_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int16_t_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int16_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int32_t_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int32_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint8_t_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint8_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint16_t_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint16_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint32_t_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint32_t_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_float_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_float_3_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_double_3_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_double_3_cptr); +# endif +#endif + + + + +#ifdef BBTK_ITK_IMAGE_DIM_4 +# ifdef BBTK_ITK_IMAGE_TYPE_int8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int8_t_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int8_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int16_t_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int16_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_int32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int32_t_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_int32_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint8_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint8_t_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint8_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint16_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint16_t_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint16_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_uint32_t + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint32_t_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_uint32_t_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_float + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_float_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_float_4_cptr); +# endif +# ifdef BBTK_ITK_IMAGE_TYPE_double + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_double_4_ptr); + BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(itk,TypedImageToAnyImage,Image_double_4_cptr); +# endif +#endif + +} +#endif diff --git a/packages/itk/src/bbitkTypedImageToAnyImage.h b/packages/itk/src/bbitkTypedImageToAnyImage.h new file mode 100644 index 0000000..2733e9f --- /dev/null +++ b/packages/itk/src/bbitkTypedImageToAnyImage.h @@ -0,0 +1,47 @@ +#ifdef _USE_ITK_ + +#ifndef __bbTypedItkImage2GenericItkImage_h__ +#define __bbTypedItkImage2GenericItkImage_h__ + +#include "bbtkUserBlackBox.h" +#include "bbitkImage.h" +#include "bbtkSystem.h" + +namespace bbitk +{ + + //================================================================= + // UserBlackBox declaration + template + class TypedImageToAnyImage : public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(TypedImageToAnyImage, + bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,itkImageTypePointer); + BBTK_DECLARE_OUTPUT(Out,anyImagePointer); + BBTK_PROCESS(DoIt); + void DoIt() { bbSetOutputOut( bbGetInputIn() ); bbGetInputIn()->Register(); } + }; + //================================================================= + + //================================================================= + // UserBlackBox description + BBTK_BEGIN_DESCRIBE_TEMPLATE_BLACK_BOX(TypedImageToAnyImage); + BBTK_NAME(bbtk::HumanTypeName() + + "To" + bbtk::HumanTypeName()); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Transforms a typed itk image ("+bbtk::HumanTypeName()+ + ") into a generic itk image ("+ + bbtk::HumanTypeName()+")"); + BBTK_DEFAULT_ADAPTOR(); + BBTK_TEMPLATE_INPUT(TypedImageToAnyImage,In, + "Input typed image",T); + BBTK_TEMPLATE_OUTPUT(TypedImageToAnyImage,Out, + "Output generic image",anyImagePointer); + BBTK_END_DESCRIBE_TEMPLATE_BLACK_BOX(TypedImageToAnyImage); + //================================================================= + + +} +#endif +#endif diff --git a/packages/std/src/bbstdRelay.h b/packages/std/src/bbstdRelay.h new file mode 100644 index 0000000..b41c9f4 --- /dev/null +++ b/packages/std/src/bbstdRelay.h @@ -0,0 +1,34 @@ +#ifndef __bbstdRelay_h_INCLUDED_H__ +#define __bbstdRelay_h_INCLUDED_H__ + +#include "bbtkUserBlackBox.h" + +namespace bbstd +{ + + template + class /*BBTK_EXPORT*/ Relay + : + public bbtk::UserBlackBox + { + BBTK_USER_BLACK_BOX_INTERFACE(Relay,bbtk::UserBlackBox); + BBTK_DECLARE_INPUT(In,T); + BBTK_DECLARE_OUTPUT(Out,T); + BBTK_PROCESS(Process); + protected: + void Process() { bbSetOutputOut ( bbGetInputIn() ); } + }; + + + BBTK_BEGIN_DESCRIBE_TEMPLATE_BLACK_BOX(Relay); + BBTK_NAME(bbtk::HumanTypeName()+"Relay"); + BBTK_AUTHOR("laurent.guigues@creatis.insa-lyon.fr"); + BBTK_DESCRIPTION("Relays a "+bbtk::TypeName()); + BBTK_TEMPLATE_INPUT(Relay,In,"Input",T); + BBTK_TEMPLATE_OUTPUT(Relay,Out,"Output",T); + BBTK_END_DESCRIBE_TEMPLATE_BLACK_BOX(Relay); + +} +// namespace bbstd + +#endif // __bbstdRelay_h_INCLUDED_H__ -- 2.45.1