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