src/creaImageIOWxAnySimpleDlg.cpp

   1 /*
   2 # ---------------------------------------------------------------------
   3 #
   4 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   5 #                        pour la Santé)
   6 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   7 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   8 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   9 #
  10 #  This software is governed by the CeCILL-B license under French law and
  11 #  abiding by the rules of distribution of free software. You can  use,
  12 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  13 #  license as circulated by CEA, CNRS and INRIA at the following URL
  14 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  15 #  or in the file LICENSE.txt.
  16 #
  17 #  As a counterpart to the access to the source code and  rights to copy,
  18 #  modify and redistribute granted by the license, users are provided only
  19 #  with a limited warranty  and the software's author,  the holder of the
  20 #  economic rights,  and the successive licensors  have only  limited
  21 #  liability.
  22 #
  23 #  The fact that you are presently reading this means that you have had
  24 #  knowledge of the CeCILL-B license and that you accept its terms.
  25 # ------------------------------------------------------------------------
  26 */
  27
  28
  29 #include "creaImageIOWxAnySimpleDlg.h"
  30
  31 #include "creaImageIOWxGimmickReaderDialog.h"
  32
  33 #if ITK_VERSION_MAJOR < 4 //  : WARNING: deprecated in ITK 4.0
  34 #  include <itkAnalyzeImageIO.h>
  35 #  include <itkDICOMSeriesFileNames.h>
  36 #else // ITK_VERSION_MAJOR < 4
  37 #  include <itkGDCMSeriesFileNames.h>
  38 #endif // ITK_VERSION_MAJOR < 4
  39
  40 #include <itkImageFileReader.h>
  41 #include <itkImageSeriesReader.h>
  42 #include <itkImage.h>
  43 #include <itkImageSeriesWriter.h>
  44 #include <itkGDCMImageIO.h>
  45 #include <itkNumericSeriesFileNames.h>
  46 #include <itkVectorImage.h>
  47 #include <itkMetaImageIO.h>
  48 #include <vtkImageReader2.h>
  49 #include <vtkMetaImageReader.h>
  50 #include <boost/filesystem/path.hpp>
  51 #include <boost/filesystem.hpp>
  52 #include <boost/utility.hpp>
  53 #include <creaVtkBasicSlicer.h>
  54
  55
  56 namespace creaImageIO
  57 {
  58
  59    ///Ctor
  60    WxAnySimpleDlg::WxAnySimpleDlg(wxWindow *parent,
  61                                   wxString i_title,
  62                                   const std::string i_namedescp ,
  63                                   const std::string i_namedb)
  64     : wxDialog(parent, -1,_T("DISPLAY IMAGES"), wxDefaultPosition, wxSize(230,150))
  65    {
  66         namedescp    = i_namedescp;
  67         namedb       = i_namedb;
  68
  69        if(!i_title.empty())
  70        {
  71             this->SetTitle(i_title);
  72        }
  73        // Button to select file(s)
  74        wxButton *fileBut = new wxButton(this, -1,_T("Select a file to display"), wxPoint(10,7) );
  75        Connect( fileBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxAnySimpleDlg::OnReadFile );
  76
  77        // Button to select directory
  78        wxButton *directoryBut = new wxButton(this, -1,_T("Select a directory to display"), wxPoint(10,40) );
  79        Connect( directoryBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxAnySimpleDlg::OnReadDirectory );
  80
  81        // button to select creaImageIO
  82        wxButton *gimmickBut = new wxButton(this, -1,_T("Select Gimmick"), wxPoint(10,70) );
  83        Connect( gimmickBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxAnySimpleDlg::OnReadGimmick );
  84
  85        /// \TODO  Button to select Bruker directory
  86         m_dicom = false;
  87         Layout();
  88     }
  89
  90 //////////////////////////////////////////////////////////////////////
  91 //                                                                  //
  92 //////////////////////////////////////////////////////////////////////
  93
  94      void WxAnySimpleDlg::OnReadFile(wxCommandEvent& event)
  95       {
  96           int resultShowModal;
  97           wxFileDialog* fileDlg = new wxFileDialog( 0,  _T("Select file"), _T(""), _T(""), crea::std2wx("*"), wxOPEN |wxFD_MULTIPLE, wxDefaultPosition);
  98
  99           resultShowModal = fileDlg->ShowModal();
 100           if ( resultShowModal==wxID_OK )
 101           {
 102                 wxArrayString wxArray;
 103                 fileDlg->GetPaths(wxArray);
 104                 if(wxArray.size() >0)
 105                 {
 106                     for( int i = 0; i < wxArray.GetCount(); i++)
 107                     {
 108                         std::string name = crea::wx2std(wxArray[i]);
 109                         // FOR THE MOMENT ONLY short 3D et short 4D
 110                         readImg(name);
 111                     } // for
 112                 } else {
 113                     // TO DO WARNING MESSAGES
 114                 } // if
 115           } // if
 116           SetReturnCode( resultShowModal );
 117 //         Close();
 118           EndModal( resultShowModal );
 119       }
 120
 121
 122 /////////////////////////////////////////////////////////////////////
 123 //                                                                  //
 124 //////////////////////////////////////////////////////////////////////
 125      void WxAnySimpleDlg::setExts(std::vector<std::string> i_exts)
 126      {
 127          m_exts = i_exts;
 128      }
 129
 130 /////////////////////////////////////////////////////////////////////
 131 //                                                                  //
 132 //////////////////////////////////////////////////////////////////////
 133       void WxAnySimpleDlg::OnReadDirectory(wxCommandEvent &event)
 134       {
 135          int resultShowModal;
 136          bool bvalid = false;
 137          long style = wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST;
 138          wxDirDialog* dirDlg = new wxDirDialog( 0, _T("Select the directory to display"), _T(""), style);
 139
 140          resultShowModal = dirDlg->ShowModal();
 141          if ( resultShowModal==wxID_OK )
 142          {
 143             std::string path = crea::wx2std(dirDlg->GetPath());
 144
 145 /*
 146             typedef boost::filesystem::directory_iterator dir_it;
 147             dir_it itr(path);
 148             dir_it end_itr;
 149 //            if (boost::filesystem::exists(path))
 150 //            {
 151                 for(;itr != end_itr; ++itr)
 152                 {
 153 //EED
 154 // All files have the same extention
 155 //                      bvalid = m_exts.size() == 0? true : false;
 156 //                      std::vector<std::string>::iterator it = m_exts.begin();
 157 //                                         std::string ext = itr->path().filename().string().substr(itr->path().filename().string().find_last_of("."));
 158 //                       for(; it != m_exts.end(); it++)
 159 //                       {
 160 //                           if(ext == (*it) )
 161 //                           {
 162 //                               bvalid = true;
 163 //                               break;
 164 //                           }
 165 //                       } // for
 166 bvalid=true;
 167                        if (!boost::filesystem::is_directory(itr->status()) && bvalid)
 168                        {
 169 printf("EED WxAnySimpleDlg::OnReadDirectory  Each file %s \n", itr->path().string().c_str() );
 170                            readImg( itr->path().string().c_str() );
 171                        } // if
 172                 } // for itr
 173 */
 174
 175                                 typedef vector<boost::filesystem::path> vec;             // store paths
 176                                 vec v;                                // so we can sort them later
 177                                 copy(boost::filesystem::directory_iterator(path), boost::filesystem::directory_iterator(), back_inserter(v));
 178                                 sort(v.begin(), v.end());             // sort, since directory iteration
 179                                                                       // is not ordered on some file systems
 180                                 for (vec::const_iterator it (v.begin()); it != v.end(); ++it)
 181                                 {
 182                            readImg( it->string().c_str() );
 183                                 } // for
 184
 185
 186
 187
 188          } // if OK
 189          SetReturnCode( resultShowModal );
 190 //         Close();
 191          EndModal( resultShowModal );
 192
 193       }
 194
 195 //////////////////////////////////////////////////////////////////////
 196 //                                                                  //
 197 //////////////////////////////////////////////////////////////////////
 198
 199       void WxAnySimpleDlg::OnReadGimmick(wxCommandEvent &event)
 200       {
 201           // Run Gimmick
 202          WxGimmickReaderDialog dlg(0,-1,
 203                    namedescp,
 204                    namedb,
 205                    _T("Select image(s)        - Gimmick! (c) CREATIS-LRMN 2008"),
 206                    wxDefaultPosition,
 207                    wxSize(810,750),
 208                    GIMMICK_2D_IMAGE_SELECTION,
 209                    GIMMICK_3D_IMAGE_SELECTION,
 210                    _3D,
 211                    1);
 212          dlg.ShowModal();
 213          if (dlg.GetReturnCode() == wxID_OK)
 214          {
 215             std::vector<std::string> out;
 216             dlg.stopReading();
 217             dlg.GetSelectedFiles(out);
 218             if(m_dicom)
 219             {
 220                 readDicomImg( out);
 221             }
 222             else
 223             {
 224                 std::vector<std::string>::iterator ii = out.begin();
 225                 for (;ii != out.end();ii++)
 226                 {
 227                     readImg( (*ii).c_str() );
 228                 }
 229             }
 230             dlg.OnExit();
 231          }
 232          SetReturnCode( dlg.GetReturnCode() );
 233 //         Close();
 234          EndModal( dlg.GetReturnCode() );
 235        }
 236
 237
 238
 239     wxString WxAnySimpleDlg::getInfoImage()
 240     {
 241         return infoimage;
 242     }
 243
 244
 245       // FCY : just to check but not needed, we hardly suppose that we load only same type and dim of images
 246     const std::type_info & WxAnySimpleDlg::getType(const std::string &i_name)
 247     {
 248             typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 249             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 250             imageIO->SetFileName(i_name.c_str());
 251             imageIO->ReadImageInformation();
 252             return imageIO->GetComponentTypeInfo();//AsString( imageIO->GetComponentType());
 253      }
 254
 255      const size_t WxAnySimpleDlg::getNumberOfDimensions(const std::string &i_name)
 256      {
 257             typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 258             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 259             imageIO->SetFileName(i_name.c_str());
 260             imageIO->ReadImageInformation();
 261             return imageIO->GetNumberOfDimensions();
 262      }
 263
 264
 265      void WxAnySimpleDlg::readImg(const std::string &i_name)
 266      {
 267           size_t dims = getNumberOfDimensions(i_name);
 268
 269           //const std::type_info  *type= &getType(i_name);
 270           switch(dims)
 271           {
 272            case 3:
 273                if (getType(i_name) ==  typeid(unsigned char))
 274                {
 275                     typedef itk::Image<unsigned char, 3> TImage;
 276                     typedef itk::ImageFileReader<TImage> ReaderType;
 277                     ReaderType::Pointer reader = ReaderType::New();
 278                     reader->SetFileName( i_name );
 279                     reader->Update();
 280                     reader->GetOutput()->Register();
 281                     m_AnyImages.push_back(reader->GetOutput());
 282                }
 283                else if (getType(i_name) ==  typeid(signed char))
 284                {
 285                     typedef itk::Image<signed char, 3> TImage;
 286                     typedef itk::ImageFileReader<TImage> ReaderType;
 287                     ReaderType::Pointer reader = ReaderType::New();
 288                     reader->SetFileName( i_name );
 289                     reader->Update();
 290                     reader->GetOutput()->Register();
 291                     m_AnyImages.push_back(reader->GetOutput());
 292                }
 293                else if (getType(i_name) ==  typeid(short))
 294                {
 295                     typedef itk::Image<short, 3> TImage;
 296                     typedef itk::ImageFileReader<TImage> ReaderType;
 297                     ReaderType::Pointer reader = ReaderType::New();
 298                     reader->SetFileName( i_name );
 299                     reader->Update();
 300                     reader->GetOutput()->Register();
 301                     m_AnyImages.push_back(reader->GetOutput());
 302                }
 303                else if (getType(i_name) ==  typeid(unsigned short))
 304                {
 305                     typedef itk::Image<unsigned short, 3> TImage;
 306                     typedef itk::ImageFileReader<TImage> ReaderType;
 307                     ReaderType::Pointer reader = ReaderType::New();
 308                     reader->SetFileName( i_name );
 309                     reader->Update();
 310                     reader->GetOutput()->Register();
 311                     m_AnyImages.push_back(reader->GetOutput());
 312               }
 313               else if (getType(i_name) ==  typeid(unsigned int))
 314               {
 315                     typedef itk::Image<unsigned int, 3> TImage;
 316                     typedef itk::ImageFileReader<TImage> ReaderType;
 317                     ReaderType::Pointer reader = ReaderType::New();
 318                     reader->SetFileName( i_name );
 319                     reader->Update();
 320                     reader->GetOutput()->Register();
 321                     m_AnyImages.push_back(reader->GetOutput());
 322               }
 323               else if (getType(i_name) ==  typeid(signed int))
 324               {
 325                     typedef itk::Image<signed int, 3> TImage;
 326                     typedef itk::ImageFileReader<TImage> ReaderType;
 327                     ReaderType::Pointer reader = ReaderType::New();
 328                     reader->SetFileName( i_name );
 329                     reader->Update();
 330                     reader->GetOutput()->Register();
 331                     m_AnyImages.push_back(reader->GetOutput());
 332               }
 333               else if (getType(i_name) ==  typeid(unsigned long))
 334               {
 335                     typedef itk::Image<unsigned long, 3> TImage;
 336                     typedef itk::ImageFileReader<TImage> ReaderType;
 337                     ReaderType::Pointer reader = ReaderType::New();
 338                     reader->SetFileName( i_name );
 339                     reader->Update();
 340                     reader->GetOutput()->Register();
 341                     m_AnyImages.push_back(reader->GetOutput());
 342               }
 343               else if (getType(i_name) ==  typeid(signed long))
 344               {
 345                     typedef itk::Image<signed long, 3> TImage;
 346                     typedef itk::ImageFileReader<TImage> ReaderType;
 347                     ReaderType::Pointer reader = ReaderType::New();
 348                     reader->SetFileName( i_name );
 349                     reader->Update();
 350                     reader->GetOutput()->Register();
 351                     m_AnyImages.push_back(reader->GetOutput());
 352               }
 353               else if (getType(i_name) ==  typeid(float))
 354               {
 355                     typedef itk::Image<float, 3> TImage;
 356                     typedef itk::ImageFileReader<TImage> ReaderType;
 357                     ReaderType::Pointer reader = ReaderType::New();
 358                     reader->SetFileName( i_name );
 359                     reader->Update();
 360                     reader->GetOutput()->Register();
 361                     m_AnyImages.push_back(reader->GetOutput());
 362               }
 363               else if (getType(i_name) ==  typeid(double))
 364               {
 365                     typedef itk::Image<double, 3> TImage;
 366                     typedef itk::ImageFileReader<TImage> ReaderType;
 367                     ReaderType::Pointer reader = ReaderType::New();
 368                     reader->SetFileName( i_name );
 369                     reader->Update();
 370                     reader->GetOutput()->Register();
 371                     m_AnyImages.push_back(reader->GetOutput());
 372               }
 373               else
 374               {
 375                                 printf("EED WxAnySimpleDlg::readImg Not type found   for DIM 3 \n");
 376                   //????FCY, so what the type????
 377               }
 378               break;
 379               //assume that we have only one 4D file
 380             case 4:
 381                 if (getType(i_name) ==  typeid(unsigned char))
 382                 {
 383                     typedef itk::Image<unsigned char, 4> TImage;
 384                     typedef itk::ImageFileReader<TImage> ReaderType;
 385                     ReaderType::Pointer reader = ReaderType::New();
 386                     reader->SetFileName( i_name );
 387                     reader->Update();
 388                     reader->GetOutput()->Register();
 389                     m_AnyImages.push_back(reader->GetOutput());
 390                     split4Din3Dvtk<TImage>(reader->GetOutput());
 391                 }
 392                 else if (getType(i_name) ==  typeid(signed char))
 393                 {
 394                     typedef itk::Image<signed char, 4> TImage;
 395                     typedef itk::ImageFileReader<TImage> ReaderType;
 396                     ReaderType::Pointer reader = ReaderType::New();
 397                     reader->SetFileName( i_name );
 398                     reader->Update();
 399                     reader->GetOutput()->Register();
 400                     m_AnyImages.push_back(reader->GetOutput());
 401                     split4Din3Dvtk<TImage>(reader->GetOutput());
 402                 }
 403                 else    if (getType(i_name) ==  typeid(unsigned short))
 404                 {
 405                     typedef itk::Image<unsigned short, 4> TImage;
 406                     typedef itk::ImageFileReader<TImage> ReaderType;
 407                     ReaderType::Pointer reader = ReaderType::New();
 408                     reader->SetFileName( i_name );
 409                     reader->Update();
 410                     reader->GetOutput()->Register();
 411                     m_AnyImages.push_back(reader->GetOutput());
 412                     split4Din3Dvtk<TImage>(reader->GetOutput());
 413                 }
 414                 else if(getType(i_name) == typeid(short))
 415                 {
 416                     typedef itk::Image<short, 4> TImage;
 417                     typedef itk::ImageFileReader<TImage> ReaderType;
 418                     ReaderType::Pointer reader = ReaderType::New();
 419                     reader->SetFileName( i_name );
 420                     try
 421                     {
 422                         reader->Update();
 423                     }
 424                     catch( itk::ExceptionObject & err )
 425                     {
 426                         std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 427                         std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 428                         throw err;
 429                     }
 430                     catch(...)
 431                     {
 432                         std::cout << "Error while reading image " << i_name << std::endl;
 433                         throw;
 434                     }
 435                     reader->GetOutput()->Register();
 436                     m_AnyImages.push_back(reader->GetOutput());
 437                     split4Din3Dvtk<TImage>(reader->GetOutput());
 438                 }
 439                 else if (getType(i_name) ==  typeid(unsigned short))
 440                 {
 441                     typedef itk::Image<unsigned short, 4> TImage;
 442                     typedef itk::ImageFileReader<TImage> ReaderType;
 443                     ReaderType::Pointer reader = ReaderType::New();
 444                     reader->SetFileName( i_name );
 445                     reader->Update();
 446                     reader->GetOutput()->Register();
 447                     m_AnyImages.push_back(reader->GetOutput());
 448                     split4Din3Dvtk<TImage>(reader->GetOutput());
 449                }
 450                else if (getType(i_name) ==  typeid(unsigned int))
 451                {
 452                     typedef itk::Image<unsigned int, 4> TImage;
 453                     typedef itk::ImageFileReader<TImage> ReaderType;
 454                     ReaderType::Pointer reader = ReaderType::New();
 455                     reader->SetFileName( i_name );
 456                     reader->Update();
 457                     reader->GetOutput()->Register();
 458                     m_AnyImages.push_back(reader->GetOutput());
 459                     split4Din3Dvtk<TImage>(reader->GetOutput());
 460                }
 461                else if (getType(i_name) ==  typeid(signed int))
 462                {
 463                     typedef itk::Image<signed int, 4> TImage;
 464                     typedef itk::ImageFileReader<TImage> ReaderType;
 465                     ReaderType::Pointer reader = ReaderType::New();
 466                     reader->SetFileName( i_name );
 467                     reader->Update();
 468                     reader->GetOutput()->Register();
 469                     m_AnyImages.push_back(reader->GetOutput());
 470                     split4Din3Dvtk<TImage>(reader->GetOutput());
 471                }
 472                else if (getType(i_name) ==  typeid(unsigned long))
 473                {
 474                     typedef itk::Image<unsigned long, 4> TImage;
 475                     typedef itk::ImageFileReader<TImage> ReaderType;
 476                     ReaderType::Pointer reader = ReaderType::New();
 477                     reader->SetFileName( i_name );
 478                     reader->Update();
 479                     reader->GetOutput()->Register();
 480                     m_AnyImages.push_back(reader->GetOutput());
 481                     split4Din3Dvtk<TImage>(reader->GetOutput());
 482                }
 483                else if (getType(i_name) ==  typeid(signed long))
 484                {
 485                     typedef itk::Image<signed long, 4> TImage;
 486                     typedef itk::ImageFileReader<TImage> ReaderType;
 487                     ReaderType::Pointer reader = ReaderType::New();
 488                     reader->SetFileName( i_name );
 489                     reader->Update();
 490                     reader->GetOutput()->Register();
 491                     m_AnyImages.push_back(reader->GetOutput());
 492                     split4Din3Dvtk<TImage>(reader->GetOutput());
 493                }
 494                else if (getType(i_name) ==  typeid(float))
 495                {
 496                     typedef itk::Image<float, 4> TImage;
 497                     typedef itk::ImageFileReader<TImage> ReaderType;
 498                     ReaderType::Pointer reader = ReaderType::New();
 499                     reader->SetFileName( i_name );
 500                     reader->Update();
 501                     reader->GetOutput()->Register();
 502                     m_AnyImages.push_back(reader->GetOutput());
 503                     split4Din3Dvtk<TImage>(reader->GetOutput());
 504                }
 505                else if (getType(i_name) ==  typeid(double))
 506                {
 507                     typedef itk::Image<double, 4> TImage;
 508                     typedef itk::ImageFileReader<TImage> ReaderType;
 509                     ReaderType::Pointer reader = ReaderType::New();
 510                     reader->SetFileName( i_name );
 511                     reader->Update();
 512                     reader->GetOutput()->Register();
 513                     m_AnyImages.push_back(reader->GetOutput());
 514                     split4Din3Dvtk<TImage>(reader->GetOutput());
 515                }
 516                else
 517                {
 518                                 printf("EED WxAnySimpleDlg::readImg Not type found   for DIM 4 \n");
 519                   //????FCY, so what the type????
 520                }
 521                break;
 522            }
 523
 524            // Test to know if we have to add new type
 525            bool btest = false;
 526            if( m_AnyDims.size() != 0)
 527            {
 528                btest = true;
 529            }
 530            else
 531            {
 532                m_AnyDims.push_back(dims);
 533                m_AnyType.push_back((std::type_info*)&getType(i_name));  //JPR cast
 534            }
 535            if (btest)
 536            {
 537                if(m_AnyDims.front() != dims || m_AnyType.front()->before(getType(i_name)))
 538                {
 539                    m_AnyDims.push_back(dims);
 540                    m_AnyType.push_back((std::type_info*)&getType(i_name)); //JPR cast
 541                }
 542                else{}
 543            }
 544            else  {}
 545       }
 546
 547       void WxAnySimpleDlg::readDicomImg(const std::vector<std::string> &i_names)
 548       {
 549           typedef itk::Image<short,3> TImage;
 550           typedef itk::GDCMImageIO GDCMType;
 551 #if ITK_VERSION_MAJOR < 4
 552           typedef itk::DICOMSeriesFileNames dicnames;
 553 #else // ITK_VERSION_MAJOR < 4
 554           typedef itk::GDCMSeriesFileNames dicnames;
 555 #endif // ITK_VERSION_MAJOR < 4
 556           GDCMType::Pointer gdcmIO = GDCMType::New();
 557           dicnames::Pointer generator = dicnames::New();
 558
 559
 560             typedef itk::ImageSeriesReader<TImage> ReaderType;
 561             ReaderType::Pointer reader = ReaderType::New();
 562             reader->SetImageIO(gdcmIO);
 563             reader->SetFileNames(i_names);
 564         //    reader->SetFileName( i_name );
 565             try
 566             {
 567                 reader->Update();
 568             }
 569             catch( itk::ExceptionObject & err )
 570             {
 571             //    std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 572                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 573                 throw err;
 574             }
 575             catch(...)
 576             {
 577                 //std::cout << "Error while reading image " << i_name << std::endl;
 578                 throw;
 579             }
 580             //m_Iresults.push_back(reader->GetOutput());
 581
 582       }
 583
 584   /*    template <typename TImage>
 585       void WxAnySimpleDlg::split3Din3Dvtk(TImage* i_Img)
 586       {
 587           typedef itk::ImageToVTKImageFilter< TImage > ConnectorType;
 588           typename ConnectorType::Pointer       connector = ConnectorType::New();
 589           connector->SetInput(i_Img);
 590           connector->GetImporter()->SetDataScalarTypeToUnsignedChar();
 591           connector->Update();
 592           vtkImageData *im = vtkImageData::New();
 593           im->ShallowCopy(connector->GetOutput());
 594           im->Update();
 595           m_Vresults.push_back(im);
 596       }*/
 597
 598
 599       template <typename TImage>
 600       void WxAnySimpleDlg::split4Din3Dvtk(TImage* i_Img)
 601       {
 602           if(i_Img->GetImageDimension() == 4)
 603           {
 604               // size of fourth dimension
 605               int dsize = i_Img->GetLargestPossibleRegion().GetSize(3);
 606               // Output Type
 607               typedef itk::Image<unsigned char,3> ImageOutputType;
 608               typedef itk::ImageSeriesWriter<TImage, ImageOutputType >  SeriesWriterType;
 609               typedef itk::MetaImageIO MetaImageType;
 610               MetaImageType::Pointer metaIO;
 611               typename SeriesWriterType::Pointer seriesWriter = SeriesWriterType::New();
 612
 613               // from JPR file to generate output files
 614               typedef itk::NumericSeriesFileNames NamesGeneratorType;
 615               NamesGeneratorType::Pointer namesGenerator = NamesGeneratorType::New();
 616               namesGenerator->SetStartIndex(0);
 617               namesGenerator->SetEndIndex(dsize-1);
 618               namesGenerator->SetIncrementIndex(1);
 619               std::string format = m_dir;
 620               format += "/image%03d.mhd";
 621               namesGenerator->SetSeriesFormat( format.c_str() );
 622
 623               const std::vector<std::string> names = namesGenerator->GetFileNames();
 624               seriesWriter->SetFileNames( names );
 625               seriesWriter->SetInput(i_Img);
 626               seriesWriter->SetImageIO(metaIO);
 627               try
 628               {
 629                  seriesWriter->Update();
 630                  vtkMetaImageReader *vReader = vtkMetaImageReader::New();
 631                  std::vector<std::string>::const_iterator it = names.begin();
 632                  for( ;it !=  names.end(); ++it)
 633                  {
 634                      vReader->SetFileName((*it).c_str());
 635                      vReader->Update();
 636                      m_Vresults.push_back(vReader->GetOutput());
 637
 638                  }
 639               }
 640               catch( itk::ExceptionObject & excp )
 641               {
 642                  std::cerr << "Exception thrown while writing the series " << std::endl;
 643                  std::cerr << excp << std::endl;
 644                  //return EXIT_FAILURE;
 645               }
 646           }
 647       }
 648
 649       bool WxAnySimpleDlg::AllSameType()
 650       {
 651            if(m_AnyType.size() == 1)
 652            {
 653                return true;
 654            }
 655            else
 656            {
 657                return false;
 658            }
 659
 660       }
 661
 662  } // namespace end
 663