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