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 <vtkVersionMacros.h>
  30 #include "creaImageIOWxAnySimpleDlg.h"
  31
  32 #include "creaImageIOWxGimmickReaderDialog.h"
  33
  34 #if ITK_VERSION_MAJOR < 4 //  : WARNING: deprecated in ITK 4.0
  35 #  include <itkAnalyzeImageIO.h>
  36 #  include <itkDICOMSeriesFileNames.h>
  37 #else // ITK_VERSION_MAJOR < 4
  38 #  include <itkGDCMSeriesFileNames.h>
  39 #endif // ITK_VERSION_MAJOR < 4
  40
  41 #include <itkImageFileReader.h>
  42 #include <itkImageSeriesReader.h>
  43 #include <itkImage.h>
  44 #include <itkImageSeriesWriter.h>
  45 #include <itkGDCMImageIO.h>
  46 #include <itkNumericSeriesFileNames.h>
  47 #include <itkVectorImage.h>
  48 #include <itkMetaImageIO.h>
  49 #include <vtkImageReader2.h>
  50 #include <vtkMetaImageReader.h>
  51 #include <boost/filesystem/path.hpp>
  52 #include <boost/filesystem.hpp>
  53 #include <boost/utility.hpp>
  54 #include <creaVtkBasicSlicer.h>
  55
  56
  57 namespace creaImageIO
  58 {
  59
  60    ///Ctor
  61    WxAnySimpleDlg::WxAnySimpleDlg(wxWindow *parent,
  62                                   wxString i_title,
  63                                   const std::string i_namedescp ,
  64                                   const std::string i_namedb)
  65     : wxDialog(parent, -1,_T("DISPLAY IMAGES"), wxDefaultPosition, wxSize(230,150))
  66    {
  67         namedescp    = i_namedescp;
  68         namedb       = i_namedb;
  69
  70        if(!i_title.empty())
  71        {
  72             this->SetTitle(i_title);
  73        }
  74        // Button to select file(s)
  75        wxButton *fileBut = new wxButton(this, -1,_T("Select a file to display"), wxPoint(10,7) );
  76        Connect( fileBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxAnySimpleDlg::OnReadFile );
  77
  78        // Button to select directory
  79        wxButton *directoryBut = new wxButton(this, -1,_T("Select a directory to display"), wxPoint(10,40) );
  80        Connect( directoryBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxAnySimpleDlg::OnReadDirectory );
  81
  82        // button to select creaImageIO
  83        wxButton *gimmickBut = new wxButton(this, -1,_T("Select Gimmick"), wxPoint(10,70) );
  84        Connect( gimmickBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxAnySimpleDlg::OnReadGimmick );
  85
  86        /// \TODO  Button to select Bruker directory
  87         m_dicom = false;
  88         Layout();
  89     }
  90
  91 //////////////////////////////////////////////////////////////////////
  92 //                                                                  //
  93 //////////////////////////////////////////////////////////////////////
  94
  95      void WxAnySimpleDlg::OnReadFile(wxCommandEvent& event)
  96       {
  97           int resultShowModal;
  98 //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
  99 #if wxMAJOR_VERSION <= 2
 100           wxFileDialog* fileDlg = new wxFileDialog( 0,  _T("Select file"), _T(""), _T(""), crea::std2wx("*"), wxOPEN |wxFD_MULTIPLE, wxDefaultPosition);
 101 #else
 102           wxFileDialog* fileDlg = new wxFileDialog( 0,  _T("Select file"), _T(""), _T(""), crea::std2wx("*"), wxFD_OPEN |wxFD_MULTIPLE, wxDefaultPosition);
 103 #endif
 104
 105           resultShowModal = fileDlg->ShowModal();
 106           if ( resultShowModal==wxID_OK )
 107           {
 108                 wxArrayString wxArray;
 109                 fileDlg->GetPaths(wxArray);
 110                 if(wxArray.size() >0)
 111                 {
 112                     for( int i = 0; i < wxArray.GetCount(); i++)
 113                     {
 114                         std::string name = crea::wx2std(wxArray[i]);
 115                         // FOR THE MOMENT ONLY short 3D et short 4D
 116                         readImg(name);
 117                     } // for
 118                 } else {
 119                     // TO DO WARNING MESSAGES
 120                 } // if
 121           } // if
 122           SetReturnCode( resultShowModal );
 123 //         Close();
 124           EndModal( resultShowModal );
 125       }
 126
 127
 128 /////////////////////////////////////////////////////////////////////
 129 //                                                                  //
 130 //////////////////////////////////////////////////////////////////////
 131      void WxAnySimpleDlg::setExts(std::vector<std::string> i_exts)
 132      {
 133          m_exts = i_exts;
 134      }
 135
 136 /////////////////////////////////////////////////////////////////////
 137 //                                                                  //
 138 //////////////////////////////////////////////////////////////////////
 139       void WxAnySimpleDlg::OnReadDirectory(wxCommandEvent &event)
 140       {
 141          int resultShowModal;
 142          bool bvalid = false;
 143          long style = wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST;
 144          wxDirDialog* dirDlg = new wxDirDialog( 0, _T("Select the directory to display"), _T(""), style);
 145
 146          resultShowModal = dirDlg->ShowModal();
 147          if ( resultShowModal==wxID_OK )
 148          {
 149             std::string path = crea::wx2std(dirDlg->GetPath());
 150
 151 /*
 152             typedef boost::filesystem::directory_iterator dir_it;
 153             dir_it itr(path);
 154             dir_it end_itr;
 155 //            if (boost::filesystem::exists(path))
 156 //            {
 157                 for(;itr != end_itr; ++itr)
 158                 {
 159 //EED
 160 // All files have the same extention
 161 //                      bvalid = m_exts.size() == 0? true : false;
 162 //                      std::vector<std::string>::iterator it = m_exts.begin();
 163 //                                         std::string ext = itr->path().filename().string().substr(itr->path().filename().string().find_last_of("."));
 164 //                       for(; it != m_exts.end(); it++)
 165 //                       {
 166 //                           if(ext == (*it) )
 167 //                           {
 168 //                               bvalid = true;
 169 //                               break;
 170 //                           }
 171 //                       } // for
 172 bvalid=true;
 173                        if (!boost::filesystem::is_directory(itr->status()) && bvalid)
 174                        {
 175 printf("EED WxAnySimpleDlg::OnReadDirectory  Each file %s \n", itr->path().string().c_str() );
 176                            readImg( itr->path().string().c_str() );
 177                        } // if
 178                 } // for itr
 179 */
 180
 181                                 typedef vector<boost::filesystem::path> vec;             // store paths
 182                                 vec v;                                // so we can sort them later
 183                                 copy(boost::filesystem::directory_iterator(path), boost::filesystem::directory_iterator(), back_inserter(v));
 184                                 sort(v.begin(), v.end());             // sort, since directory iteration
 185                                                                       // is not ordered on some file systems
 186                                 for (vec::const_iterator it (v.begin()); it != v.end(); ++it)
 187                                 {
 188                            readImg( it->string().c_str() );
 189                                 } // for
 190
 191
 192
 193
 194          } // if OK
 195          SetReturnCode( resultShowModal );
 196 //         Close();
 197          EndModal( resultShowModal );
 198
 199       }
 200
 201 //////////////////////////////////////////////////////////////////////
 202 //                                                                  //
 203 //////////////////////////////////////////////////////////////////////
 204
 205       void WxAnySimpleDlg::OnReadGimmick(wxCommandEvent &event)
 206       {
 207           // Run Gimmick
 208          WxGimmickReaderDialog dlg(0,-1,
 209                    namedescp,
 210                    namedb,
 211                    _T("Select image(s)        - Gimmick! (c) CREATIS-LRMN 2008"),
 212                    wxDefaultPosition,
 213                    wxSize(810,750),
 214                    GIMMICK_2D_IMAGE_SELECTION,
 215                    GIMMICK_3D_IMAGE_SELECTION,
 216                    _3D,
 217                    1);
 218          dlg.ShowModal();
 219          if (dlg.GetReturnCode() == wxID_OK)
 220          {
 221             std::vector<std::string> out;
 222             dlg.stopReading();
 223             dlg.GetSelectedFiles(out);
 224             if(m_dicom)
 225             {
 226                 readDicomImg( out);
 227             }
 228             else
 229             {
 230                 std::vector<std::string>::iterator ii = out.begin();
 231                 for (;ii != out.end();ii++)
 232                 {
 233                     readImg( (*ii).c_str() );
 234                 }
 235             }
 236             dlg.OnExit();
 237          }
 238          SetReturnCode( dlg.GetReturnCode() );
 239 //         Close();
 240          EndModal( dlg.GetReturnCode() );
 241        }
 242
 243
 244
 245     wxString WxAnySimpleDlg::getInfoImage()
 246     {
 247         return infoimage;
 248     }
 249
 250
 251       // FCY : just to check but not needed, we hardly suppose that we load only same type and dim of images
 252     const std::type_info & WxAnySimpleDlg::getType(const std::string &i_name)
 253     {
 254             typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 255             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 256             imageIO->SetFileName(i_name.c_str());
 257             imageIO->ReadImageInformation();
 258             return imageIO->GetComponentTypeInfo();//AsString( imageIO->GetComponentType());
 259      }
 260
 261      const size_t WxAnySimpleDlg::getNumberOfDimensions(const std::string &i_name)
 262      {
 263             typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 264             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 265             imageIO->SetFileName(i_name.c_str());
 266             imageIO->ReadImageInformation();
 267             return imageIO->GetNumberOfDimensions();
 268      }
 269
 270
 271      void WxAnySimpleDlg::readImg(const std::string &i_name)
 272      {
 273           size_t dims = getNumberOfDimensions(i_name);
 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