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 printf("EED WxAnySimpleDlg::OnReadDirectory Start\n");
 136          int resultShowModal;
 137          bool bvalid = false;
 138          long style = wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST;
 139          wxDirDialog* dirDlg = new wxDirDialog( 0, _T("Select the directory to display"), _T(""), style);
 140
 141          resultShowModal = dirDlg->ShowModal();
 142          if ( resultShowModal==wxID_OK )
 143          {
 144             std::string path = crea::wx2std(dirDlg->GetPath());
 145 printf("EED WxAnySimpleDlg::OnReadDirectory path %s\n", path.c_str() );
 146
 147 /*
 148             typedef boost::filesystem::directory_iterator dir_it;
 149             dir_it itr(path);
 150             dir_it end_itr;
 151 //            if (boost::filesystem::exists(path))
 152 //            {
 153                 for(;itr != end_itr; ++itr)
 154                 {
 155 //EED
 156 // All files have the same extention
 157 //                      bvalid = m_exts.size() == 0? true : false;
 158 //                      std::vector<std::string>::iterator it = m_exts.begin();
 159 //                                         std::string ext = itr->path().filename().string().substr(itr->path().filename().string().find_last_of("."));
 160 //                       for(; it != m_exts.end(); it++)
 161 //                       {
 162 //                           if(ext == (*it) )
 163 //                           {
 164 //                               bvalid = true;
 165 //                               break;
 166 //                           }
 167 //                       } // for
 168 bvalid=true;
 169                        if (!boost::filesystem::is_directory(itr->status()) && bvalid)
 170                        {
 171 printf("EED WxAnySimpleDlg::OnReadDirectory  Each file %s \n", itr->path().string().c_str() );
 172                            readImg( itr->path().string().c_str() );
 173                        } // if
 174                 } // for itr
 175 */
 176
 177                                 typedef vector<boost::filesystem::path> vec;             // store paths
 178                                 vec v;                                // so we can sort them later
 179                                 copy(boost::filesystem::directory_iterator(path), boost::filesystem::directory_iterator(), back_inserter(v));
 180                                 sort(v.begin(), v.end());             // sort, since directory iteration
 181                                                                       // is not ordered on some file systems
 182                                 for (vec::const_iterator it (v.begin()); it != v.end(); ++it)
 183                                 {
 184                            readImg( it->string().c_str() );
 185                                   cout << "   " << *it << '\n';
 186                                 }
 187
 188
 189
 190
 191          } // if OK
 192          SetReturnCode( resultShowModal );
 193 //         Close();
 194          EndModal( resultShowModal );
 195 printf("EED WxAnySimpleDlg::OnReadDirectory End\n");
 196
 197       }
 198
 199 //////////////////////////////////////////////////////////////////////
 200 //                                                                  //
 201 //////////////////////////////////////////////////////////////////////
 202
 203       void WxAnySimpleDlg::OnReadGimmick(wxCommandEvent &event)
 204       {
 205           // Run Gimmick
 206          WxGimmickReaderDialog dlg(0,-1,
 207                    namedescp,
 208                    namedb,
 209                    _T("Select image(s)        - Gimmick! (c) CREATIS-LRMN 2008"),
 210                    wxDefaultPosition,
 211                    wxSize(810,750),
 212                    GIMMICK_2D_IMAGE_SELECTION,
 213                    GIMMICK_3D_IMAGE_SELECTION,
 214                    _3D,
 215                    1);
 216          dlg.ShowModal();
 217          if (dlg.GetReturnCode() == wxID_OK)
 218          {
 219             std::vector<std::string> out;
 220             dlg.stopReading();
 221             dlg.GetSelectedFiles(out);
 222             if(m_dicom)
 223             {
 224                 readDicomImg( out);
 225             }
 226             else
 227             {
 228                 std::vector<std::string>::iterator ii = out.begin();
 229                 for (;ii != out.end();ii++)
 230                 {
 231                     readImg( (*ii).c_str() );
 232                 }
 233             }
 234             dlg.OnExit();
 235          }
 236          SetReturnCode( dlg.GetReturnCode() );
 237 //         Close();
 238          EndModal( dlg.GetReturnCode() );
 239        }
 240
 241
 242
 243     wxString WxAnySimpleDlg::getInfoImage()
 244     {
 245         return infoimage;
 246     }
 247
 248
 249       // FCY : just to check but not needed, we hardly suppose that we load only same type and dim of images
 250     const std::type_info & WxAnySimpleDlg::getType(const std::string &i_name)
 251     {
 252             typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 253             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 254             imageIO->SetFileName(i_name.c_str());
 255             imageIO->ReadImageInformation();
 256             return imageIO->GetComponentTypeInfo();//AsString( imageIO->GetComponentType());
 257      }
 258
 259      const size_t WxAnySimpleDlg::getNumberOfDimensions(const std::string &i_name)
 260      {
 261             typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 262             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 263             imageIO->SetFileName(i_name.c_str());
 264             imageIO->ReadImageInformation();
 265             return imageIO->GetNumberOfDimensions();
 266      }
 267
 268
 269      void WxAnySimpleDlg::readImg(const std::string &i_name)
 270      {
 271           size_t dims = getNumberOfDimensions(i_name);
 272
 273 printf("EED WxAnySimpleDlg::readImg dims=%d \n",dims);
 274
 275           //const std::type_info  *type= &getType(i_name);
 276           switch(dims)
 277           {
 278            case 3:
 279                if (getType(i_name) ==  typeid(unsigned char))
 280                {
 281                     typedef itk::Image<unsigned char, 3> TImage;
 282                     typedef itk::ImageFileReader<TImage> ReaderType;
 283                     ReaderType::Pointer reader = ReaderType::New();
 284                     reader->SetFileName( i_name );
 285                     reader->Update();
 286                     reader->GetOutput()->Register();
 287                     m_AnyImages.push_back(reader->GetOutput());
 288                }
 289                else if (getType(i_name) ==  typeid(signed char))
 290                {
 291                     typedef itk::Image<signed char, 3> TImage;
 292                     typedef itk::ImageFileReader<TImage> ReaderType;
 293                     ReaderType::Pointer reader = ReaderType::New();
 294                     reader->SetFileName( i_name );
 295                     reader->Update();
 296                     reader->GetOutput()->Register();
 297                     m_AnyImages.push_back(reader->GetOutput());
 298                }
 299                else if (getType(i_name) ==  typeid(short))
 300                {
 301                     typedef itk::Image<short, 3> TImage;
 302                     typedef itk::ImageFileReader<TImage> ReaderType;
 303                     ReaderType::Pointer reader = ReaderType::New();
 304                     reader->SetFileName( i_name );
 305                     reader->Update();
 306                     reader->GetOutput()->Register();
 307                     m_AnyImages.push_back(reader->GetOutput());
 308                }
 309                else if (getType(i_name) ==  typeid(unsigned short))
 310                {
 311                     typedef itk::Image<unsigned short, 3> TImage;
 312                     typedef itk::ImageFileReader<TImage> ReaderType;
 313                     ReaderType::Pointer reader = ReaderType::New();
 314                     reader->SetFileName( i_name );
 315                     reader->Update();
 316                     reader->GetOutput()->Register();
 317                     m_AnyImages.push_back(reader->GetOutput());
 318               }
 319               else if (getType(i_name) ==  typeid(unsigned int))
 320               {
 321                     typedef itk::Image<unsigned int, 3> TImage;
 322                     typedef itk::ImageFileReader<TImage> ReaderType;
 323                     ReaderType::Pointer reader = ReaderType::New();
 324                     reader->SetFileName( i_name );
 325                     reader->Update();
 326                     reader->GetOutput()->Register();
 327                     m_AnyImages.push_back(reader->GetOutput());
 328               }
 329               else if (getType(i_name) ==  typeid(signed int))
 330               {
 331                     typedef itk::Image<signed int, 3> TImage;
 332                     typedef itk::ImageFileReader<TImage> ReaderType;
 333                     ReaderType::Pointer reader = ReaderType::New();
 334                     reader->SetFileName( i_name );
 335                     reader->Update();
 336                     reader->GetOutput()->Register();
 337                     m_AnyImages.push_back(reader->GetOutput());
 338               }
 339               else if (getType(i_name) ==  typeid(unsigned long))
 340               {
 341                     typedef itk::Image<unsigned long, 3> TImage;
 342                     typedef itk::ImageFileReader<TImage> ReaderType;
 343                     ReaderType::Pointer reader = ReaderType::New();
 344                     reader->SetFileName( i_name );
 345                     reader->Update();
 346                     reader->GetOutput()->Register();
 347                     m_AnyImages.push_back(reader->GetOutput());
 348               }
 349               else if (getType(i_name) ==  typeid(signed long))
 350               {
 351                     typedef itk::Image<signed long, 3> TImage;
 352                     typedef itk::ImageFileReader<TImage> ReaderType;
 353                     ReaderType::Pointer reader = ReaderType::New();
 354                     reader->SetFileName( i_name );
 355                     reader->Update();
 356                     reader->GetOutput()->Register();
 357                     m_AnyImages.push_back(reader->GetOutput());
 358               }
 359               else if (getType(i_name) ==  typeid(float))
 360               {
 361                     typedef itk::Image<float, 3> TImage;
 362                     typedef itk::ImageFileReader<TImage> ReaderType;
 363                     ReaderType::Pointer reader = ReaderType::New();
 364                     reader->SetFileName( i_name );
 365                     reader->Update();
 366                     reader->GetOutput()->Register();
 367                     m_AnyImages.push_back(reader->GetOutput());
 368               }
 369               else if (getType(i_name) ==  typeid(double))
 370               {
 371                     typedef itk::Image<double, 3> TImage;
 372                     typedef itk::ImageFileReader<TImage> ReaderType;
 373                     ReaderType::Pointer reader = ReaderType::New();
 374                     reader->SetFileName( i_name );
 375                     reader->Update();
 376                     reader->GetOutput()->Register();
 377                     m_AnyImages.push_back(reader->GetOutput());
 378               }
 379               else
 380               {
 381                                 printf("EED WxAnySimpleDlg::readImg Not type found   for DIM 3 \n");
 382                   //????FCY, so what the type????
 383               }
 384               break;
 385               //assume that we have only one 4D file
 386             case 4:
 387                 if (getType(i_name) ==  typeid(unsigned char))
 388                 {
 389                     typedef itk::Image<unsigned char, 4> TImage;
 390                     typedef itk::ImageFileReader<TImage> ReaderType;
 391                     ReaderType::Pointer reader = ReaderType::New();
 392                     reader->SetFileName( i_name );
 393                     reader->Update();
 394                     reader->GetOutput()->Register();
 395                     m_AnyImages.push_back(reader->GetOutput());
 396                     split4Din3Dvtk<TImage>(reader->GetOutput());
 397                 }
 398                 else if (getType(i_name) ==  typeid(signed char))
 399                 {
 400                     typedef itk::Image<signed char, 4> TImage;
 401                     typedef itk::ImageFileReader<TImage> ReaderType;
 402                     ReaderType::Pointer reader = ReaderType::New();
 403                     reader->SetFileName( i_name );
 404                     reader->Update();
 405                     reader->GetOutput()->Register();
 406                     m_AnyImages.push_back(reader->GetOutput());
 407                     split4Din3Dvtk<TImage>(reader->GetOutput());
 408                 }
 409                 else    if (getType(i_name) ==  typeid(unsigned short))
 410                 {
 411                     typedef itk::Image<unsigned short, 4> TImage;
 412                     typedef itk::ImageFileReader<TImage> ReaderType;
 413                     ReaderType::Pointer reader = ReaderType::New();
 414                     reader->SetFileName( i_name );
 415                     reader->Update();
 416                     reader->GetOutput()->Register();
 417                     m_AnyImages.push_back(reader->GetOutput());
 418                     split4Din3Dvtk<TImage>(reader->GetOutput());
 419                 }
 420                 else if(getType(i_name) == typeid(short))
 421                 {
 422                     typedef itk::Image<short, 4> TImage;
 423                     typedef itk::ImageFileReader<TImage> ReaderType;
 424                     ReaderType::Pointer reader = ReaderType::New();
 425                     reader->SetFileName( i_name );
 426                     try
 427                     {
 428                         reader->Update();
 429                     }
 430                     catch( itk::ExceptionObject & err )
 431                     {
 432                         std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 433                         std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 434                         throw err;
 435                     }
 436                     catch(...)
 437                     {
 438                         std::cout << "Error while reading image " << i_name << std::endl;
 439                         throw;
 440                     }
 441                     reader->GetOutput()->Register();
 442                     m_AnyImages.push_back(reader->GetOutput());
 443                     split4Din3Dvtk<TImage>(reader->GetOutput());
 444                 }
 445                 else if (getType(i_name) ==  typeid(unsigned short))
 446                 {
 447                     typedef itk::Image<unsigned short, 4> TImage;
 448                     typedef itk::ImageFileReader<TImage> ReaderType;
 449                     ReaderType::Pointer reader = ReaderType::New();
 450                     reader->SetFileName( i_name );
 451                     reader->Update();
 452                     reader->GetOutput()->Register();
 453                     m_AnyImages.push_back(reader->GetOutput());
 454                     split4Din3Dvtk<TImage>(reader->GetOutput());
 455                }
 456                else if (getType(i_name) ==  typeid(unsigned int))
 457                {
 458                     typedef itk::Image<unsigned int, 4> TImage;
 459                     typedef itk::ImageFileReader<TImage> ReaderType;
 460                     ReaderType::Pointer reader = ReaderType::New();
 461                     reader->SetFileName( i_name );
 462                     reader->Update();
 463                     reader->GetOutput()->Register();
 464                     m_AnyImages.push_back(reader->GetOutput());
 465                     split4Din3Dvtk<TImage>(reader->GetOutput());
 466                }
 467                else if (getType(i_name) ==  typeid(signed int))
 468                {
 469                     typedef itk::Image<signed int, 4> TImage;
 470                     typedef itk::ImageFileReader<TImage> ReaderType;
 471                     ReaderType::Pointer reader = ReaderType::New();
 472                     reader->SetFileName( i_name );
 473                     reader->Update();
 474                     reader->GetOutput()->Register();
 475                     m_AnyImages.push_back(reader->GetOutput());
 476                     split4Din3Dvtk<TImage>(reader->GetOutput());
 477                }
 478                else if (getType(i_name) ==  typeid(unsigned long))
 479                {
 480                     typedef itk::Image<unsigned long, 4> TImage;
 481                     typedef itk::ImageFileReader<TImage> ReaderType;
 482                     ReaderType::Pointer reader = ReaderType::New();
 483                     reader->SetFileName( i_name );
 484                     reader->Update();
 485                     reader->GetOutput()->Register();
 486                     m_AnyImages.push_back(reader->GetOutput());
 487                     split4Din3Dvtk<TImage>(reader->GetOutput());
 488                }
 489                else if (getType(i_name) ==  typeid(signed long))
 490                {
 491                     typedef itk::Image<signed long, 4> TImage;
 492                     typedef itk::ImageFileReader<TImage> ReaderType;
 493                     ReaderType::Pointer reader = ReaderType::New();
 494                     reader->SetFileName( i_name );
 495                     reader->Update();
 496                     reader->GetOutput()->Register();
 497                     m_AnyImages.push_back(reader->GetOutput());
 498                     split4Din3Dvtk<TImage>(reader->GetOutput());
 499                }
 500                else if (getType(i_name) ==  typeid(float))
 501                {
 502                     typedef itk::Image<float, 4> TImage;
 503                     typedef itk::ImageFileReader<TImage> ReaderType;
 504                     ReaderType::Pointer reader = ReaderType::New();
 505                     reader->SetFileName( i_name );
 506                     reader->Update();
 507                     reader->GetOutput()->Register();
 508                     m_AnyImages.push_back(reader->GetOutput());
 509                     split4Din3Dvtk<TImage>(reader->GetOutput());
 510                }
 511                else if (getType(i_name) ==  typeid(double))
 512                {
 513                     typedef itk::Image<double, 4> TImage;
 514                     typedef itk::ImageFileReader<TImage> ReaderType;
 515                     ReaderType::Pointer reader = ReaderType::New();
 516                     reader->SetFileName( i_name );
 517                     reader->Update();
 518                     reader->GetOutput()->Register();
 519                     m_AnyImages.push_back(reader->GetOutput());
 520                     split4Din3Dvtk<TImage>(reader->GetOutput());
 521                }
 522                else
 523                {
 524                                 printf("EED WxAnySimpleDlg::readImg Not type found   for DIM 4 \n");
 525                   //????FCY, so what the type????
 526                }
 527                break;
 528            }
 529
 530            // Test to know if we have to add new type
 531            bool btest = false;
 532            if( m_AnyDims.size() != 0)
 533            {
 534                btest = true;
 535            }
 536            else
 537            {
 538                m_AnyDims.push_back(dims);
 539                m_AnyType.push_back((std::type_info*)&getType(i_name));  //JPR cast
 540            }
 541            if (btest)
 542            {
 543                if(m_AnyDims.front() != dims || m_AnyType.front()->before(getType(i_name)))
 544                {
 545                    m_AnyDims.push_back(dims);
 546                    m_AnyType.push_back((std::type_info*)&getType(i_name)); //JPR cast
 547                }
 548                else{}
 549            }
 550            else  {}
 551       }
 552
 553       void WxAnySimpleDlg::readDicomImg(const std::vector<std::string> &i_names)
 554       {
 555           typedef itk::Image<short,3> TImage;
 556           typedef itk::GDCMImageIO GDCMType;
 557 #if ITK_VERSION_MAJOR < 4
 558           typedef itk::DICOMSeriesFileNames dicnames;
 559 #else // ITK_VERSION_MAJOR < 4
 560           typedef itk::GDCMSeriesFileNames dicnames;
 561 #endif // ITK_VERSION_MAJOR < 4
 562           GDCMType::Pointer gdcmIO = GDCMType::New();
 563           dicnames::Pointer generator = dicnames::New();
 564
 565
 566             typedef itk::ImageSeriesReader<TImage> ReaderType;
 567             ReaderType::Pointer reader = ReaderType::New();
 568             reader->SetImageIO(gdcmIO);
 569             reader->SetFileNames(i_names);
 570         //    reader->SetFileName( i_name );
 571             try
 572             {
 573                 reader->Update();
 574             }
 575             catch( itk::ExceptionObject & err )
 576             {
 577             //    std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 578                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 579                 throw err;
 580             }
 581             catch(...)
 582             {
 583                 //std::cout << "Error while reading image " << i_name << std::endl;
 584                 throw;
 585             }
 586             //m_Iresults.push_back(reader->GetOutput());
 587
 588       }
 589
 590   /*    template <typename TImage>
 591       void WxAnySimpleDlg::split3Din3Dvtk(TImage* i_Img)
 592       {
 593           typedef itk::ImageToVTKImageFilter< TImage > ConnectorType;
 594           typename ConnectorType::Pointer       connector = ConnectorType::New();
 595           connector->SetInput(i_Img);
 596           connector->GetImporter()->SetDataScalarTypeToUnsignedChar();
 597           connector->Update();
 598           vtkImageData *im = vtkImageData::New();
 599           im->ShallowCopy(connector->GetOutput());
 600           im->Update();
 601           m_Vresults.push_back(im);
 602       }*/
 603
 604
 605       template <typename TImage>
 606       void WxAnySimpleDlg::split4Din3Dvtk(TImage* i_Img)
 607       {
 608           if(i_Img->GetImageDimension() == 4)
 609           {
 610               // size of fourth dimension
 611               int dsize = i_Img->GetLargestPossibleRegion().GetSize(3);
 612               // Output Type
 613               typedef itk::Image<unsigned char,3> ImageOutputType;
 614               typedef itk::ImageSeriesWriter<TImage, ImageOutputType >  SeriesWriterType;
 615               typedef itk::MetaImageIO MetaImageType;
 616               MetaImageType::Pointer metaIO;
 617               typename SeriesWriterType::Pointer seriesWriter = SeriesWriterType::New();
 618
 619               // from JPR file to generate output files
 620               typedef itk::NumericSeriesFileNames NamesGeneratorType;
 621               NamesGeneratorType::Pointer namesGenerator = NamesGeneratorType::New();
 622               namesGenerator->SetStartIndex(0);
 623               namesGenerator->SetEndIndex(dsize-1);
 624               namesGenerator->SetIncrementIndex(1);
 625               std::string format = m_dir;
 626               format += "/image%03d.mhd";
 627               namesGenerator->SetSeriesFormat( format.c_str() );
 628
 629               const std::vector<std::string> names = namesGenerator->GetFileNames();
 630               seriesWriter->SetFileNames( names );
 631               seriesWriter->SetInput(i_Img);
 632               seriesWriter->SetImageIO(metaIO);
 633               try
 634               {
 635                  seriesWriter->Update();
 636                  vtkMetaImageReader *vReader = vtkMetaImageReader::New();
 637                  std::vector<std::string>::const_iterator it = names.begin();
 638                  for( ;it !=  names.end(); ++it)
 639                  {
 640                      vReader->SetFileName((*it).c_str());
 641                      vReader->Update();
 642                      m_Vresults.push_back(vReader->GetOutput());
 643
 644                  }
 645               }
 646               catch( itk::ExceptionObject & excp )
 647               {
 648                  std::cerr << "Exception thrown while writing the series " << std::endl;
 649                  std::cerr << excp << std::endl;
 650                  //return EXIT_FAILURE;
 651               }
 652           }
 653       }
 654
 655       bool WxAnySimpleDlg::AllSameType()
 656       {
 657            if(m_AnyType.size() == 1)
 658            {
 659                return true;
 660            }
 661            else
 662            {
 663                return false;
 664            }
 665
 666       }
 667
 668  } // namespace end
 669