src/creaImageIOWxAnySimpleDlg.cpp

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