src/creaImageIOWxISimpleDlg.hpp

   1
   2 #ifndef __creaImageIOWxSimpleDlg_hpp_INCLUDED__
   3 #define __creaImageIOWxSimpleDlg_hpp_INCLUDED__
   4
   5
   6 //#include "creaImageIOWxISimpleDlg.h"
   7
   8 #include "creaImageIOWxGimmickReaderDialog.h"
   9 #include <itkAnalyzeImageIO.h>
  10 #include <itkImageFileReader.h>
  11 #include <itkImageSeriesReader.h>
  12 #include <itkImage.h>
  13 #include <itkImageSeriesWriter.h>
  14 #include <itkGDCMImageIO.h>
  15 #include <itkDICOMSeriesFileNames.h>
  16 #include <itkNumericSeriesFileNames.h>
  17 #include <itkVectorImage.h>
  18 #include <itkMetaImageIO.h>
  19 #include <itkOrientedImage.h>
  20 #include <vtkImageReader2.h>
  21 #include <vtkMetaImageReader.h>
  22 #include <boost/filesystem/path.hpp>
  23 #include <boost/filesystem.hpp>
  24 #include <boost/utility.hpp>
  25 #include <creaVtkBasicSlicer.h>
  26
  27 namespace creaImageIO
  28 {
  29   template <typename TImage2>
  30   typename TImage2::Pointer ReadImage( const std::string &fileName)
  31   {
  32     typename TImage2::Pointer image;
  33
  34     typedef itk::ImageFileReader<TImage2> ReaderType;
  35     typename ReaderType::Pointer reader = ReaderType::New();
  36     reader->SetFileName( fileName.c_str() );
  37     try
  38       {
  39       reader->Update();
  40       }
  41     catch( itk::ExceptionObject & err )
  42       {
  43       std::cout << "Caught an exception reading" << fileName << ": " << std::endl;
  44       std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
  45       throw err;
  46       }
  47     catch(...)
  48       {
  49       std::cout << "Error while reading image " << fileName << std::endl;
  50       throw;
  51       }
  52      image = reader->GetOutput();
  53
  54     return image;
  55   }
  56
  57
  58   ///Ctor
  59   template <typename TImage>
  60    WxISimpleDlg<TImage>::WxISimpleDlg(wxWindow *parent,
  61                                       wxString i_title,
  62                                       const std::string i_namedescp ,
  63                                       const std::string i_namedb)
  64     : wxDialog(parent, -1,_T("SELECT IMAGE(S)"), 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) &WxISimpleDlg::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) &WxISimpleDlg::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) &WxISimpleDlg::OnReadGimmick );
  84
  85        /// \TODO  Button to select Bruker directory
  86        m_dicom = true;
  87        Layout();
  88
  89     }
  90 //////////////////////////////////////////////////////////////////////
  91 //                                                                  //
  92 //////////////////////////////////////////////////////////////////////
  93      template <typename TImage>
  94       void WxISimpleDlg<TImage>::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                         readImg( crea::wx2std(wxArray[i]));
 109                     }
 110                 }
 111                 else {
 112                     /// \TODO WARNING MESSAGES
 113                 }
 114             }
 115          SetReturnCode( resultShowModal );
 116 //       Close();
 117          EndModal( resultShowModal );
 118       }
 119
 120
 121         template <typename TImage>
 122         void WxISimpleDlg<TImage>::setExts(std::vector<std::string> i_exts)
 123         {
 124             m_exts = i_exts;
 125         }
 126 //////////////////////////////////////////////////////////////////////
 127 //                                                                  //
 128 //////////////////////////////////////////////////////////////////////
 129    template <typename TImage>
 130       void WxISimpleDlg<TImage>::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->filename().substr(itr->filename().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->string().c_str());
 162                     }
 163                 }
 164          }
 165          SetReturnCode( resultShowModal );
 166 //         Close();
 167          EndModal( resultShowModal );
 168       }
 169
 170 //////////////////////////////////////////////////////////////////////
 171 //                                                                  //
 172 //////////////////////////////////////////////////////////////////////
 173             template <typename TImage>
 174       void WxISimpleDlg<TImage>::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      template <typename TImage>
 214      wxString WxISimpleDlg<TImage>::getInfoImage()
 215     {
 216         return infoimage;
 217     }
 218
 219
 220     //////////////////////////////////////////////////////////////////////
 221     // Return the results vector                                        //
 222     //////////////////////////////////////////////////////////////////////
 223      template <typename TImage>
 224      std::vector<typename TImage::Pointer> WxISimpleDlg<TImage>::getImagesSelected()
 225       {
 226           return m_Iresults;
 227       }
 228
 229       template <typename TImage>
 230       void WxISimpleDlg<TImage>::readImg(const std::string &i_name)
 231       {
 232             // FCY : just to check but not needed, we hardly suppose that we load only same type and dim of images
 233             // uncomment to test
 234               /*typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
 235             itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
 236             imageIO->SetFileName(i_name.c_str());
 237             imageIO->ReadImageInformation();
 238             ScalarPixelType pixelType = imageIO->GetComponentType();
 239             const size_t dims =  imageIO->GetNumberOfDimensions();*/
 240
 241             typedef itk::ImageFileReader<TImage> ReaderType;
 242             typename ReaderType::Pointer reader = ReaderType::New();
 243             reader->SetFileName( i_name );
 244             try
 245             {
 246                 reader->Update();
 247             }
 248             catch( itk::ExceptionObject & err )
 249             {
 250                 std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 251                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 252                 throw err;
 253             }
 254             catch(...)
 255             {
 256                 std::cout << "Error while reading image " << i_name << std::endl;
 257                 throw;
 258             }
 259             m_Iresults.push_back(reader->GetOutput());
 260       }
 261
 262
 263
 264       template <typename TImage>
 265       void WxISimpleDlg<TImage>::readDicomImg(const std::vector<std::string> &i_names)
 266       {
 267             typedef itk::GDCMImageIO GDCMType;
 268             typedef itk::DICOMSeriesFileNames dicnames;
 269             GDCMType::Pointer gdcmIO = GDCMType::New();
 270             dicnames::Pointer generator = dicnames::New();
 271 //          generator->SetInput(i_names);
 272             typedef itk::ImageSeriesReader<TImage> ReaderType;
 273             typename ReaderType::Pointer reader = ReaderType::New();
 274             reader->SetImageIO(gdcmIO);
 275             reader->SetFileNames(i_names);
 276         //    reader->SetFileName( i_name );
 277             try
 278             {
 279                 reader->Update();
 280             }
 281             catch( itk::ExceptionObject & err )
 282             {
 283             //    std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 284                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 285                 throw err;
 286             }
 287             catch(...)
 288             {
 289                 //std::cout << "Error while reading image " << i_name << std::endl;
 290                 throw;
 291             }
 292             m_Iresults.push_back(reader->GetOutput());
 293       }
 294
 295
 296
 297
 298       template <typename TImage>
 299       void WxISimpleDlg<TImage>::split3Din3Dvtk()
 300       {
 301           if ((m_Iresults).size() != 0)
 302           {
 303               typedef itk::ImageToVTKImageFilter<  TImage > ConnectorType;
 304               ConnectorType::Pointer       connector = ConnectorType::New();
 305                for(unsigned int i = 0 ;i < m_Iresults.size(); i++)
 306               {
 307                     connector->SetInput(m_Iresults[i]);
 308                     connector->GetImporter()->SetDataScalarTypeToUnsignedChar();
 309                     connector->Update();
 310                     vtkImageData *im = vtkImageData::New();
 311                     im->ShallowCopy(connector->GetOutput());
 312                     im->Update();
 313                     m_Vresults.push_back(im);
 314              }
 315           }
 316       }
 317
 318
 319
 320       template <typename TImage>
 321       void WxISimpleDlg<TImage>::split4Din3Dvtk(const std::string &i_dir)
 322       {
 323             if ((m_Iresults).size() != 0)
 324             {
 325                 typename TImage::Pointer image = m_Iresults[0];
 326
 327                  if(image->GetImageDimension() == 4)
 328                  {
 329                      // size of fourth dimension
 330                      int dsize = image->GetLargestPossibleRegion().GetSize(3);
 331                      // Output Type
 332                      typedef itk::Image<unsigned char,3> ImageOutputType;
 333                      typedef itk::ImageSeriesWriter<TImage, ImageOutputType >  SeriesWriterType;
 334                      typedef itk::MetaImageIO MetaImageType;
 335                      MetaImageType::Pointer metaIO;
 336                      SeriesWriterType::Pointer seriesWriter = SeriesWriterType::New();
 337
 338                      // from JPR file to generate output files
 339                      typedef itk::NumericSeriesFileNames NamesGeneratorType;
 340                      NamesGeneratorType::Pointer namesGenerator = NamesGeneratorType::New();
 341                      namesGenerator->SetStartIndex(0);
 342                      namesGenerator->SetEndIndex(dsize-1);
 343                      namesGenerator->SetIncrementIndex(1);
 344                      std::string format = i_dir;
 345                      format += "/image%03d.mhd";
 346                      namesGenerator->SetSeriesFormat( format.c_str() );
 347
 348                      const std::vector<std::string> names = namesGenerator->GetFileNames();
 349                      seriesWriter->SetFileNames( names );
 350                      seriesWriter->SetInput(image);
 351                      seriesWriter->SetImageIO(metaIO);
 352                      try
 353                      {
 354                         seriesWriter->Update();
 355                         vtkMetaImageReader *vReader = vtkMetaImageReader::New();
 356                         std::vector<std::string>::const_iterator it = names.begin();
 357                         for( ;it !=  names.end(); ++it)
 358                         {
 359                             vReader->SetFileName((*it).c_str());
 360                             vReader->Update();
 361                             m_Vresults.push_back(vReader->GetOutput());
 362                         }
 363                     }
 364                     catch( itk::ExceptionObject & excp )
 365                     {
 366                         std::cerr << "Exception thrown while writing the series " << std::endl;
 367                         std::cerr << excp << std::endl;
 368                         //return EXIT_FAILURE;
 369                     }
 370                  }
 371               }
 372       }
 373
 374  }// namespace end
 375
 376 #endif //__creaImageIOWxSimpleDlg_hpp_INCLUDED__
 377