mitkImageAccessByItk.h
Go to the documentation of this file.
00001 /*========================================================================= 00002 00003 Program: Medical Imaging & Interaction Toolkit 00004 Language: C++ 00005 Date: $Date$ 00006 Version: $Revision$ 00007 00008 Copyright (c) German Cancer Research Center, Division of Medical and 00009 Biological Informatics. All rights reserved. 00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details. 00011 00012 This software is distributed WITHOUT ANY WARRANTY; without even 00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 00014 PURPOSE. See the above copyright notices for more information. 00015 00016 =========================================================================*/ 00017 00018 00019 #ifndef MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED 00020 #define MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED 00021 00022 #include <itkCastImageFilter.h> 00023 #include <mitkImageToItk.h> 00024 00025 #ifndef DOXYGEN_SKIP 00026 #define _accessByItkWarning \ 00027 { \ 00028 itkGenericOutputMacro(<< "Pixel type " << pixelType.GetItkTypeAsString() \ 00029 << " not supported by AccessByItk") \ 00030 } 00031 00032 #define _accessByItkWarningParam(pixelType, accessor) \ 00033 { \ 00034 itkGenericOutputMacro(<< "Pixel type " << pixelType.GetItkTypeAsString() \ 00035 << " not supported by " << accessor) \ 00036 } 00037 00038 #define _accessByItk(mitkImage, itkImageTypeFunction, pixeltype, dimension) \ 00039 if ( pixelType == typeid(pixeltype) ) \ 00040 { \ 00041 typedef itk::Image<pixeltype, dimension> ImageType; \ 00042 typedef mitk::ImageToItk<ImageType> ImageToItkType; \ 00043 itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \ 00044 imagetoitk->SetInput(mitkImage); \ 00045 imagetoitk->Update(); \ 00046 itkImageTypeFunction(imagetoitk->GetOutput()); \ 00047 } \ 00048 00049 #define _accessAllTypesByItk(mitkImage, itkImageTypeFunction, dimension) \ 00050 _accessByItk(mitkImage, itkImageTypeFunction, double, dimension) else \ 00051 _accessByItk(mitkImage, itkImageTypeFunction, float, dimension) else \ 00052 _accessByItk(mitkImage, itkImageTypeFunction, int, dimension) else \ 00053 _accessByItk(mitkImage, itkImageTypeFunction, unsigned int, dimension) else \ 00054 _accessByItk(mitkImage, itkImageTypeFunction, short, dimension) else \ 00055 _accessByItk(mitkImage, itkImageTypeFunction, unsigned short, dimension) else \ 00056 _accessByItk(mitkImage, itkImageTypeFunction, char, dimension) else \ 00057 _accessByItk(mitkImage, itkImageTypeFunction, unsigned char, dimension) else \ 00058 _accessByItkWarning 00059 #endif //DOXYGEN_SKIP 00060 00096 #define AccessByItk(mitkImage, itkImageTypeFunction) \ 00097 { \ 00098 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00099 const mitk::Image* constImage = mitkImage; \ 00100 const_cast<mitk::Image*>(constImage)->Update(); \ 00101 assert((mitkImage)->GetDimension()>=2 && (mitkImage)->GetDimension()<=3); \ 00102 if((mitkImage)->GetDimension()==2) \ 00103 { \ 00104 _accessAllTypesByItk(mitkImage, itkImageTypeFunction, 2); \ 00105 } \ 00106 else \ 00107 { \ 00108 _accessAllTypesByItk(mitkImage, itkImageTypeFunction, 3) \ 00109 } \ 00110 } 00111 00112 //##Documentation 00113 //## @brief Access an mitk-image with known dimension by an itk-image 00114 //## 00115 //## For usage, see AccessByItk. 00116 //## @param dimension dimension of the mitk-image. 00117 //## 00118 //## If the image has a different dimension, an exception is thrown 00119 //## (by assert). 00120 //## If you do not know the dimension for sure, use AccessByItk. 00121 //## \sa AccessByItk 00122 //## \sa AccessFixedDimensionByItk 00123 //## \sa AccessFixedTypeByItk 00124 //## \sa AccessFixedPixelTypeByItk 00125 //## @ingroup Adaptor 00126 #define AccessFixedDimensionByItk(mitkImage, itkImageTypeFunction, dimension) \ 00127 { \ 00128 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00129 const mitk::Image* constImage = mitkImage; \ 00130 const_cast<mitk::Image*>(constImage)->Update(); \ 00131 assert((mitkImage)->GetDimension()==dimension); \ 00132 _accessAllTypesByItk(mitkImage, itkImageTypeFunction, dimension) \ 00133 } 00134 00135 //##Documentation 00136 //## @brief Access an mitk-image with known type (pixel type and dimension) 00137 //## by an itk-image 00138 //## 00139 //## For usage, see AccessByItk. 00140 //## @param dimension dimension of the mitk-image. If the image 00141 //## has a different dimension, an exception is thrown (by assert). 00142 //## If you do not know the dimension for sure, use AccessByItk. 00143 //## \sa AccessByItk 00144 //## \sa AccessFixedDimensionByItk 00145 //## \sa AccessFixedTypeByItk 00146 //## \sa AccessFixedPixelTypeByItk 00147 //## @ingroup Adaptor 00148 #define AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, pixeltype, dimension) \ 00149 { \ 00150 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00151 const mitk::Image* constImage = mitkImage; \ 00152 const_cast<mitk::Image*>(constImage)->Update(); \ 00153 assert((mitkImage)->GetDimension()==dimension); \ 00154 _accessByItk(mitkImage, itkImageTypeFunction, pixeltype, dimension) else \ 00155 _accessByItkWarning \ 00156 } 00157 00158 //##Documentation 00159 //## @brief Access an mitk-image with known pixeltype (but unknown dimension) 00160 //## by an itk-image and pass two additional parameters to the access-function 00161 //## 00162 //## For usage, see AccessByItk. 00163 //## @param pixeltype pixel type of the mitk-image. 00164 //## 00165 //## If the image has a different pixel type, an exception is 00166 //## thrown (by assert). 00167 //## If you do not know the pixel type for sure, use AccessByItk. 00168 //## \sa AccessByItk 00169 //## \sa AccessFixedDimensionByItk 00170 //## \sa AccessFixedTypeByItk 00171 //## \sa AccessFixedPixelTypeByItk 00172 //## @ingroup Adaptor 00173 #define AccessFixedPixelTypeByItk(mitkImage, itkImageTypeFunction, pixeltype) \ 00174 { \ 00175 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00176 const mitk::Image* constImage = mitkImage; \ 00177 const_cast<mitk::Image*>(constImage)->Update(); \ 00178 assert((mitkImage)->GetDimension()>=2 && (mitkImage)->GetDimension()<=3); \ 00179 if((mitkImage)->GetDimension()==2) \ 00180 { \ 00181 _accessByItk(mitkImage, itkImageTypeFunction, pixeltype, 2) else \ 00182 _accessByItkWarning \ 00183 } \ 00184 else \ 00185 { \ 00186 _accessByItk(mitkImage, itkImageTypeFunction, pixeltype, 3) else \ 00187 _accessByItkWarning \ 00188 } \ 00189 } 00190 00191 //----------------------- version with 1 additional paramater ------------------ 00192 #ifndef DOXYGEN_SKIP 00193 #define _accessByItk_1(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1) \ 00194 if ( pixelType == typeid(pixeltype) ) \ 00195 { \ 00196 typedef itk::Image<pixeltype, dimension> ImageType; \ 00197 typedef mitk::ImageToItk<ImageType> ImageToItkType; \ 00198 itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \ 00199 imagetoitk->SetInput(mitkImage); \ 00200 imagetoitk->Update(); \ 00201 itkImageTypeFunction(imagetoitk->GetOutput(), param1); \ 00202 } 00203 00204 #define _accessAllTypesByItk_1(mitkImage, itkImageTypeFunction, dimension, param1) \ 00205 _accessByItk_1(mitkImage, itkImageTypeFunction, double, dimension, param1) else \ 00206 _accessByItk_1(mitkImage, itkImageTypeFunction, float, dimension, param1) else \ 00207 _accessByItk_1(mitkImage, itkImageTypeFunction, int, dimension, param1) else \ 00208 _accessByItk_1(mitkImage, itkImageTypeFunction, unsigned int, dimension, param1) else \ 00209 _accessByItk_1(mitkImage, itkImageTypeFunction, short, dimension, param1) else \ 00210 _accessByItk_1(mitkImage, itkImageTypeFunction, unsigned short, dimension, param1) else \ 00211 _accessByItk_1(mitkImage, itkImageTypeFunction, char, dimension, param1) else \ 00212 _accessByItk_1(mitkImage, itkImageTypeFunction, unsigned char, dimension, param1) else \ 00213 _accessByItkWarning \ 00214 00215 #endif //DOXYGEN_SKIP 00216 00217 //##Documentation 00218 //## @brief Access an mitk-image by an itk-image and pass one 00219 //## additional parameter to the access-function 00220 //## 00221 //## For usage, see AccessByItk. The only difference to AccessByItk 00222 //## is that an additional parameter (@a param1) is passed. 00223 //## @note If you know the dimension of your input mitk-image, 00224 //## it is better to use AccessFixedDimensionByItk_1 (less code 00225 //## is generated). 00226 //## \sa AccessByItk 00227 //## \sa AccessFixedDimensionByItk_1 00228 //## \sa AccessFixedTypeByItk_1 00229 //## \sa AccessFixedPixelTypeByItk_1 00230 //## @ingroup Adaptor 00231 #define AccessByItk_1(mitkImage, itkImageTypeFunction, param1) \ 00232 { \ 00233 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00234 const mitk::Image* constImage = mitkImage; \ 00235 const_cast<mitk::Image*>(constImage)->Update(); \ 00236 assert(mitkImage->GetDimension()>=2 && mitkImage->GetDimension()<=3); \ 00237 if(mitkImage->GetDimension()==2) \ 00238 { \ 00239 _accessAllTypesByItk_1(mitkImage, itkImageTypeFunction, 2, param1); \ 00240 } \ 00241 else \ 00242 { \ 00243 _accessAllTypesByItk_1(mitkImage, itkImageTypeFunction, 3, param1) \ 00244 } \ 00245 } 00246 00247 //##Documentation 00248 //## @brief Access an mitk-image with known dimension by an itk-image 00249 //## and pass one additional parameter to the access-function 00250 //## 00251 //## For usage, see AccessByItk_1 and AccessByItk. 00252 //## @param dimension dimension of the mitk-image. 00253 //## 00254 //## If the image has a different dimension, an exception is thrown 00255 //## (by assert). 00256 //## If you do not know the dimension for sure, use AccessByItk_1. 00257 //## \sa AccessByItk_2 00258 //## \sa AccessByItk 00259 //## \sa AccessFixedDimensionByItk_1 00260 //## \sa AccessFixedTypeByItk_1 00261 //## \sa AccessFixedPixelTypeByItk_1 00262 //## @ingroup Adaptor 00263 #define AccessFixedDimensionByItk_1(mitkImage, itkImageTypeFunction, dimension, param1) \ 00264 { \ 00265 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00266 const mitk::Image* constImage = mitkImage; \ 00267 const_cast<mitk::Image*>(constImage)->Update(); \ 00268 assert(mitkImage->GetDimension()==dimension); \ 00269 _accessAllTypesByItk_1(mitkImage, itkImageTypeFunction, dimension, param1) \ 00270 } 00271 00272 //##Documentation 00273 //## @brief Access an mitk-image with known type (pixel type and dimension) 00274 //## by an itk-image and pass one additional parameters to the access-function 00275 //## 00276 //## For usage, see AccessByItk_1 and AccessByItk. 00277 //## @param pixeltype pixel type of the mitk-image. 00278 //## @param dimension dimension of the mitk-image. 00279 //## 00280 //## If the image has a different pixel type or dimension, an exception is 00281 //## thrown (by assert). 00282 //## If you do not know the pixel type and dimension for sure, use AccessByItk_1. 00283 //## \sa AccessByItk_1 00284 //## \sa AccessByItk 00285 //## \sa AccessFixedDimensionByItk_1 00286 //## \sa AccessFixedTypeByItk_1 00287 //## \sa AccessFixedPixelTypeByItk_1 00288 //## @ingroup Adaptor 00289 #define AccessFixedTypeByItk_1(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1) \ 00290 { \ 00291 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00292 const mitk::Image* constImage = mitkImage; \ 00293 const_cast<mitk::Image*>(constImage)->Update(); \ 00294 assert(mitkImage->GetDimension()==dimension); \ 00295 _accessByItk_1(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1) else \ 00296 _accessByItkWarning \ 00297 } 00298 00299 //##Documentation 00300 //## @brief Access an mitk-image with known pixeltype (but unknown dimension) 00301 //## by an itk-image and pass one additional parameters to the access-function 00302 //## 00303 //## For usage, see AccessByItk_1 and AccessByItk. 00304 //## @param pixeltype pixel type of the mitk-image. 00305 //## 00306 //## If the image has a different pixel type, an exception is 00307 //## thrown (by assert). 00308 //## If you do not know the pixel type for sure, use AccessByItk_2. 00309 //## \sa AccessByItk_1 00310 //## \sa AccessByItk 00311 //## \sa AccessFixedDimensionByItk 00312 //## \sa AccessFixedTypeByItk_1 00313 //## \sa AccessFixedPixelTypeByItk_1 00314 //## @ingroup Adaptor 00315 #define AccessFixedPixelTypeByItk_1(mitkImage, itkImageTypeFunction, pixeltype, param1) \ 00316 { \ 00317 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00318 const mitk::Image* constImage = mitkImage; \ 00319 const_cast<mitk::Image*>(constImage)->Update(); \ 00320 assert(mitkImage->GetDimension()>=2 && mitkImage->GetDimension()<=3); \ 00321 if(mitkImage->GetDimension()==2) \ 00322 { \ 00323 _accessByItk_1(mitkImage, itkImageTypeFunction, pixeltype, 2, param1) else \ 00324 _accessByItkWarning \ 00325 } \ 00326 else \ 00327 { \ 00328 _accessByItk_1(mitkImage, itkImageTypeFunction, pixeltype, 3, param1) else \ 00329 _accessByItkWarning \ 00330 } \ 00331 } 00332 00333 //----------------------- version with 2 additional paramaters ----------------- 00334 #ifndef DOXYGEN_SKIP 00335 #define _accessByItk_2(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1, param2) \ 00336 if ( pixelType == typeid(pixeltype) ) \ 00337 { \ 00338 typedef itk::Image<pixeltype, dimension> ImageType; \ 00339 typedef mitk::ImageToItk<ImageType> ImageToItkType; \ 00340 itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \ 00341 imagetoitk->SetInput(mitkImage); \ 00342 imagetoitk->Update(); \ 00343 itkImageTypeFunction(imagetoitk->GetOutput(), param1, param2); \ 00344 } 00345 00346 #define _accessAllTypesByItk_2(mitkImage, itkImageTypeFunction, dimension, param1, param2) \ 00347 _accessByItk_2(mitkImage, itkImageTypeFunction, double, dimension, param1, param2) else \ 00348 _accessByItk_2(mitkImage, itkImageTypeFunction, float, dimension, param1, param2) else \ 00349 _accessByItk_2(mitkImage, itkImageTypeFunction, int, dimension, param1, param2) else \ 00350 _accessByItk_2(mitkImage, itkImageTypeFunction, unsigned int, dimension, param1, param2) else \ 00351 _accessByItk_2(mitkImage, itkImageTypeFunction, short, dimension, param1, param2) else \ 00352 _accessByItk_2(mitkImage, itkImageTypeFunction, unsigned short, dimension, param1, param2) else \ 00353 _accessByItk_2(mitkImage, itkImageTypeFunction, char, dimension, param1, param2) else \ 00354 _accessByItk_2(mitkImage, itkImageTypeFunction, unsigned char, dimension, param1, param2) else \ 00355 _accessByItkWarning \ 00356 00357 #endif //DOXYGEN_SKIP 00358 00359 //##Documentation 00360 //## @brief Access an mitk-image by an itk-image and pass two 00361 //## additional parameters to the access-function 00362 //## 00363 //## For usage, see AccessByItk. The only difference to AccessByItk 00364 //## is that two additional parameters (@a param1, @a param2) are passed. 00365 //## @note If you know the dimension of your input mitk-image, 00366 //## it is better to use AccessFixedDimensionByItk_2 (less code 00367 //## is generated). 00368 //## \sa AccessByItk 00369 //## \sa AccessFixedDimensionByItk_2 00370 //## \sa AccessFixedTypeByItk_2 00371 //## \sa AccessFixedPixelTypeByItk_2 00372 //## @ingroup Adaptor 00373 #define AccessByItk_2(mitkImage, itkImageTypeFunction, param1, param2) \ 00374 { \ 00375 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00376 const mitk::Image* constImage = mitkImage; \ 00377 const_cast<mitk::Image*>(constImage)->Update(); \ 00378 assert(mitkImage->GetDimension()>=2 && mitkImage->GetDimension()<=3); \ 00379 if(mitkImage->GetDimension()==2) \ 00380 { \ 00381 _accessAllTypesByItk_2(mitkImage, itkImageTypeFunction, 2, param1, param2); \ 00382 } \ 00383 else \ 00384 { \ 00385 _accessAllTypesByItk_2(mitkImage, itkImageTypeFunction, 3, param1, param2) \ 00386 } \ 00387 } 00388 00389 //##Documentation 00390 //## @brief Access an mitk-image with known dimension by an itk-image 00391 //## and pass two additional parameters to the access-function 00392 //## 00393 //## For usage, see AccessByItk_2 and AccessByItk. 00394 //## @param dimension dimension of the mitk-image. 00395 //## 00396 //## If the image has a different dimension, an exception is thrown 00397 //## (by assert). 00398 //## If you do not know the dimension for sure, use AccessByItk_2. 00399 //## \sa AccessByItk_2 00400 //## \sa AccessByItk 00401 //## \sa AccessFixedDimensionByItk_2 00402 //## \sa AccessFixedTypeByItk_2 00403 //## \sa AccessFixedPixelTypeByItk_2 00404 //## @ingroup Adaptor 00405 #define AccessFixedDimensionByItk_2(mitkImage, itkImageTypeFunction, dimension, param1, param2) \ 00406 { \ 00407 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00408 const mitk::Image* constImage = mitkImage; \ 00409 const_cast<mitk::Image*>(constImage)->Update(); \ 00410 assert(mitkImage->GetDimension()==dimension); \ 00411 _accessAllTypesByItk_2(mitkImage, itkImageTypeFunction, dimension, param1, param2) \ 00412 } 00413 00414 //##Documentation 00415 //## @brief Access an mitk-image with known type (pixel type and dimension) 00416 //## by an itk-image and pass two additional parameters to the access-function 00417 //## 00418 //## For usage, see AccessByItk_2 and AccessByItk. 00419 //## @param pixeltype pixel type of the mitk-image. 00420 //## @param dimension dimension of the mitk-image. 00421 //## 00422 //## If the image has a different pixel type or dimension, an exception is 00423 //## thrown (by assert). 00424 //## If you do not know the pixel type and dimension for sure, use AccessByItk_2. 00425 //## \sa AccessByItk_2 00426 //## \sa AccessByItk 00427 //## \sa AccessFixedDimensionByItk 00428 //## \sa AccessFixedTypeByItk_2 00429 //## \sa AccessFixedPixelTypeByItk_2 00430 //## @ingroup Adaptor 00431 #define AccessFixedTypeByItk_2(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1, param2) \ 00432 { \ 00433 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00434 const mitk::Image* constImage = mitkImage; \ 00435 const_cast<mitk::Image*>(constImage)->Update(); \ 00436 assert(mitkImage->GetDimension()==dimension); \ 00437 _accessByItk_2(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1, param2) else \ 00438 _accessByItkWarning \ 00439 } 00440 00441 //##Documentation 00442 //## @brief Access an mitk-image with known pixel type (but unknown dimension) 00443 //## by an itk-image and pass two additional parameters to the access-function 00444 //## 00445 //## For usage, see AccessByItk_2 and AccessByItk. 00446 //## @param pixeltype pixel type of the mitk-image. 00447 //## 00448 //## If the image has a different pixel type, an exception is 00449 //## thrown (by assert). 00450 //## If you do not know the pixel type for sure, use AccessByItk_2. 00451 //## \sa AccessByItk_2 00452 //## \sa AccessByItk 00453 //## \sa AccessFixedDimensionByItk 00454 //## \sa AccessFixedTypeByItk_2 00455 //## \sa AccessFixedPixelTypeByItk_2 00456 //## @ingroup Adaptor 00457 #define AccessFixedPixelTypeByItk_2(mitkImage, itkImageTypeFunction, pixeltype, param1, param2) \ 00458 { \ 00459 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00460 const mitk::Image* constImage = mitkImage; \ 00461 const_cast<mitk::Image*>(constImage)->Update(); \ 00462 assert(mitkImage->GetDimension()>=2 && mitkImage->GetDimension()<=3); \ 00463 if(mitkImage->GetDimension()==2) \ 00464 { \ 00465 _accessByItk_2(mitkImage, itkImageTypeFunction, pixeltype, 2, param1, param2) else \ 00466 _accessByItkWarning \ 00467 } \ 00468 else \ 00469 { \ 00470 _accessByItk_2(mitkImage, itkImageTypeFunction, pixeltype, 3, param1, param2) else \ 00471 _accessByItkWarning \ 00472 } \ 00473 } 00474 00475 #define _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, pixeltype2, dimension) \ 00476 if ( pixelType2 == typeid(pixeltype2) ) \ 00477 { \ 00478 typedef itk::Image<pixeltype, dimension> ImageType1; \ 00479 typedef itk::Image<pixeltype2, dimension> ImageType2; \ 00480 typedef mitk::ImageToItk<ImageType1> ImageToItkType1; \ 00481 typedef mitk::ImageToItk<ImageType2> ImageToItkType2; \ 00482 itk::SmartPointer<ImageToItkType1> imagetoitk1 = ImageToItkType1::New(); \ 00483 imagetoitk1->SetInput(mitkImage1); \ 00484 imagetoitk1->Update(); \ 00485 itk::SmartPointer<ImageToItkType2> imagetoitk2 = ImageToItkType2::New(); \ 00486 imagetoitk2->SetInput(mitkImage2); \ 00487 imagetoitk2->Update(); \ 00488 itkImageTypeFunction(imagetoitk1->GetOutput(), imagetoitk2->GetOutput()); \ 00489 } 00490 00491 #define _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, dimension) \ 00492 if ( pixelType1 == typeid(pixeltype) ) \ 00493 { \ 00494 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, double, dimension) else \ 00495 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, float, dimension) else \ 00496 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, int, dimension) else \ 00497 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, unsigned int, dimension) else \ 00498 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, short, dimension) else \ 00499 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, unsigned short, dimension) else \ 00500 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, char, dimension) else \ 00501 _accessTwoImagesByItk2(mitkImage1, mitkImage2, itkImageTypeFunction, pixeltype, unsigned char, dimension) else \ 00502 _accessByItkWarningParam(pixelType2, "_accessTwoImagesByItk") \ 00503 } 00504 00505 #define _accessTwoImagesAllTypesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, dimension) \ 00506 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, double, dimension) else \ 00507 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, float, dimension) else \ 00508 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, int, dimension) else \ 00509 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, unsigned int, dimension) else \ 00510 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, short, dimension) else \ 00511 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, unsigned short, dimension) else \ 00512 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, char, dimension) else \ 00513 _accessTwoImagesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, unsigned char, dimension) else \ 00514 _accessByItkWarningParam(pixelType1, "_accessTwoImagesByItk") 00515 00516 00517 //----------------------- version with 3 additional parameters ----------------- 00518 #ifndef DOXYGEN_SKIP 00519 #define _accessByItk_3(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1, param2, param3) \ 00520 if ( pixelType == typeid(pixeltype) ) \ 00521 { \ 00522 typedef itk::Image<pixeltype, dimension> ImageType; \ 00523 typedef mitk::ImageToItk<ImageType> ImageToItkType; \ 00524 itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \ 00525 imagetoitk->SetInput(mitkImage); \ 00526 imagetoitk->Update(); \ 00527 itkImageTypeFunction(imagetoitk->GetOutput(), param1, param2, param3); \ 00528 } 00529 00530 #define _accessAllTypesByItk_3(mitkImage, itkImageTypeFunction, dimension, param1, param2, param3) \ 00531 _accessByItk_3(mitkImage, itkImageTypeFunction, double, dimension, param1, param2, param3) else \ 00532 _accessByItk_3(mitkImage, itkImageTypeFunction, float, dimension, param1, param2, param3) else \ 00533 _accessByItk_3(mitkImage, itkImageTypeFunction, int, dimension, param1, param2, param3) else \ 00534 _accessByItk_3(mitkImage, itkImageTypeFunction, unsigned int, dimension, param1, param2, param3) else \ 00535 _accessByItk_3(mitkImage, itkImageTypeFunction, short, dimension, param1, param2, param3) else \ 00536 _accessByItk_3(mitkImage, itkImageTypeFunction, unsigned short, dimension, param1, param2, param3) else \ 00537 _accessByItk_3(mitkImage, itkImageTypeFunction, char, dimension, param1, param2, param3) else \ 00538 _accessByItk_3(mitkImage, itkImageTypeFunction, unsigned char, dimension, param1, param2, param3) else \ 00539 _accessByItkWarning \ 00540 00541 #endif //DOXYGEN_SKIP 00542 00543 //##Documentation 00544 //## @brief Access an mitk-image by an itk-image and pass three 00545 //## additional parameters to the access-function 00546 //## 00547 //## For usage, see AccessByItk. The only difference to AccessByItk 00548 //## is that two additional parameters (@a param1, @a param2) are passed. 00549 //## @note If you know the dimension of your input mitk-image, 00550 //## it is better to use AccessFixedDimensionByItk_3 (less code 00551 //## is generated). 00552 //## \sa AccessByItk 00553 //## \sa AccessFixedDimensionByItk_3 00554 //## \sa AccessFixedPixelTypeByItk_3 00555 //## @ingroup Adaptor 00556 #define AccessByItk_3(mitkImage, itkImageTypeFunction, param1, param2, param3) \ 00557 { \ 00558 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00559 const mitk::Image* constImage = mitkImage; \ 00560 const_cast<mitk::Image*>(constImage)->Update(); \ 00561 assert(mitkImage->GetDimension()>=2 && mitkImage->GetDimension()<=3); \ 00562 if(mitkImage->GetDimension()==2) \ 00563 { \ 00564 _accessAllTypesByItk_3(mitkImage, itkImageTypeFunction, 2, param1, param2, param3); \ 00565 } \ 00566 else \ 00567 { \ 00568 _accessAllTypesByItk_3(mitkImage, itkImageTypeFunction, 3, param1, param2, param3) \ 00569 } \ 00570 } 00571 00572 //##Documentation 00573 //## @brief Access an mitk-image with known dimension by an itk-image 00574 //## and pass three additional parameters to the access-function 00575 //## 00576 //## For usage, see AccessByItk_3 and AccessByItk. 00577 //## @param dimension dimension of the mitk-image. 00578 //## 00579 //## If the image has a different dimension, an exception is thrown 00580 //## (by assert). 00581 //## If you do not know the dimension for sure, use AccessByItk_3. 00582 //## \sa AccessByItk_3 00583 //## \sa AccessByItk 00584 //## \sa AccessFixedDimensionByItk_3 00585 //## \sa AccessFixedTypeByItk_3 00586 //## \sa AccessFixedPixelTypeByItk_3 00587 //## @ingroup Adaptor 00588 #define AccessFixedDimensionByItk_3(mitkImage, itkImageTypeFunction, dimension, param1, param2, param3) \ 00589 { \ 00590 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00591 const mitk::Image* constImage = mitkImage; \ 00592 const_cast<mitk::Image*>(constImage)->Update(); \ 00593 assert(mitkImage->GetDimension()==dimension); \ 00594 _accessAllTypesByItk_3(mitkImage, itkImageTypeFunction, dimension, param1, param2, param3) \ 00595 } 00596 00597 //##Documentation 00598 //## @brief Access an mitk-image with known type (pixel type and dimension) 00599 //## by an itk-image and pass three additional parameters to the access-function 00600 //## 00601 //## For usage, see AccessByItk_3 and AccessByItk. 00602 //## @param pixeltype pixel type of the mitk-image. 00603 //## @param dimension dimension of the mitk-image. 00604 //## 00605 //## If the image has a different pixel type or dimension, an exception is 00606 //## thrown (by assert). 00607 //## If you do not know the pixel type and dimension for sure, use AccessByItk_3. 00608 //## \sa AccessByItk_3 00609 //## \sa AccessByItk 00610 //## \sa AccessFixedDimensionByItk 00611 //## \sa AccessFixedPixelTypeByItk_3 00612 //## @ingroup Adaptor 00613 #define AccessFixedTypeByItk_3(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1, param2, param3) \ 00614 { \ 00615 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00616 const mitk::Image* constImage = mitkImage; \ 00617 const_cast<mitk::Image*>(constImage)->Update(); \ 00618 assert(mitkImage->GetDimension()==dimension); \ 00619 _accessByItk_3(mitkImage, itkImageTypeFunction, pixeltype, dimension, param1, param2, param3) else \ 00620 _accessByItkWarning \ 00621 } 00622 00623 //##Documentation 00624 //## @brief Access an mitk-image with known pixel type (but unknown dimension) 00625 //## by an itk-image and pass three additional parameters to the access-function 00626 //## 00627 //## For usage, see AccessByItk_3 and AccessByItk. 00628 //## @param pixeltype pixel type of the mitk-image. 00629 //## 00630 //## If the image has a different pixel type, an exception is 00631 //## thrown (by assert). 00632 //## If you do not know the pixel type for sure, use AccessByItk_3. 00633 //## \sa AccessByItk_3 00634 //## \sa AccessByItk 00635 //## \sa AccessFixedDimensionByItk 00636 //## \sa AccessFixedTypeByItk_3 00637 //## \sa AccessFixedPixelTypeByItk_3 00638 //## @ingroup Adaptor 00639 #define AccessFixedPixelTypeByItk_3(mitkImage, itkImageTypeFunction, pixeltype, param1, param2, param3) \ 00640 { \ 00641 const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \ 00642 const mitk::Image* constImage = mitkImage; \ 00643 const_cast<mitk::Image*>(constImage)->Update(); \ 00644 assert(mitkImage->GetDimension()>=2 && mitkImage->GetDimension()<=3); \ 00645 if(mitkImage->GetDimension()==2) \ 00646 { \ 00647 _accessByItk_3(mitkImage, itkImageTypeFunction, pixeltype, 2, param1, param2, param3) else \ 00648 _accessByItkWarning \ 00649 } \ 00650 else \ 00651 { \ 00652 _accessByItk_3(mitkImage, itkImageTypeFunction, pixeltype, 3, param1, param2, param3) else \ 00653 _accessByItkWarning \ 00654 } \ 00655 } 00656 00657 00658 00659 //##Documentation 00660 //## @brief Access two mitk-images with known dimension by itk-images 00661 //## 00662 //## For usage, see AccessByItk. 00663 //## @param dimension dimension of the mitk-image. 00664 //## 00665 //## If one of the images has a different dimension, an exception is thrown 00666 //## (by assert). 00667 //## If you do not know the dimension for sure, use AccessByItk. 00668 //## \sa AccessByItk 00669 //## \sa AccessFixedDimensionByItk 00670 //## \sa AccessFixedTypeByItk 00671 //## \sa AccessFixedPixelTypeByItk 00672 //## @ingroup Adaptor 00673 #define AccessTwoImagesFixedDimensionByItk(mitkImage1, mitkImage2, itkImageTypeFunction, dimension) \ 00674 { \ 00675 const mitk::PixelType& pixelType1 = mitkImage1->GetPixelType(); \ 00676 const mitk::PixelType& pixelType2 = mitkImage2->GetPixelType(); \ 00677 const mitk::Image* constImage1 = mitkImage1; \ 00678 const mitk::Image* constImage2 = mitkImage2; \ 00679 const_cast<mitk::Image*>(constImage1)->Update(); \ 00680 const_cast<mitk::Image*>(constImage2)->Update(); \ 00681 assert((mitkImage1)->GetDimension()==dimension); \ 00682 assert((mitkImage2)->GetDimension()==dimension); \ 00683 _accessTwoImagesAllTypesByItk(mitkImage1, mitkImage2, itkImageTypeFunction, dimension) \ 00684 } 00685 00686 #ifdef mitkCore_EXPORTS 00687 #define MITK_CORE_EXPORT_EXTERN 00688 #else 00689 #define MITK_CORE_EXPORT_EXTERN extern 00690 #endif 00691 00692 //----------------------- cast functions. Will be moved to mitkImageCast.h ----------------- 00693 namespace mitk 00694 { 00695 #ifndef DOXYGEN_SKIP 00696 template < typename TPixel, unsigned int VImageDimension, class ItkOutputImageType > 00697 void _CastToItkImage2Access( itk::Image<TPixel, VImageDimension>* itkInputImage, itk::SmartPointer<ItkOutputImageType>& itkOutputImage); 00698 #endif //DOXYGEN_SKIP 00699 //##Documentation 00700 //## @brief Cast an mitk::Image to an itk::Image with a specific type. You don't have to initialize the itk::Image<..>::Pointer. 00701 //## @ingroup Adaptor 00702 template <typename ItkOutputImageType> extern void MITK_CORE_EXPORT CastToItkImage(const mitk::Image * mitkImage, itk::SmartPointer<ItkOutputImageType>& itkOutputImage); 00703 } 00704 00705 //----------------------- include to be removed ----------------------- 00706 #include <mitkInstantiateAccessFunctions.h> 00707 00708 #endif // of MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
