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