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
 265           template <typename TImage>
 266           void WxISimpleDlg<TImage>::readDicomImg(const std::vector<std::string> &i_names)
 267           {
 268                   typedef itk::GDCMImageIO GDCMType;
 269                   typedef itk::DICOMSeriesFileNames dicnames;
 270                   GDCMType::Pointer gdcmIO = GDCMType::New();
 271                   dicnames::Pointer generator = dicnames::New();
 272 //                generator->SetInput(i_names);
 273                         typedef itk::ImageSeriesReader<TImage> ReaderType;
 274                     typename ReaderType::Pointer reader = ReaderType::New();
 275                         reader->SetImageIO(gdcmIO);
 276                         reader->SetFileNames(i_names);
 277                 //      reader->SetFileName( i_name );
 278                         try
 279                         {
 280                                 reader->Update();
 281                         }
 282                         catch( itk::ExceptionObject & err )
 283                         {
 284                         //      std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 285                                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 286                                 throw err;
 287                         }
 288                         catch(...)
 289                         {
 290                                 //std::cout << "Error while reading image " << i_name << std::endl;
 291                                 throw;
 292                         }
 293                         m_Iresults.push_back(reader->GetOutput());
 294
 295           }
 296
 297
 298
 299
 300           template <typename TImage>
 301           void WxISimpleDlg<TImage>::split3Din3Dvtk()
 302           {
 303                   if ((m_Iresults).size() != 0)
 304                   {
 305                           typedef itk::ImageToVTKImageFilter<  TImage > ConnectorType;
 306                           ConnectorType::Pointer          connector = ConnectorType::New();
 307               for(unsigned int i = 0 ;i < m_Iresults.size(); i++)
 308                       {
 309                                         connector->SetInput(m_Iresults[i]);
 310                                         connector->GetImporter()->SetDataScalarTypeToUnsignedChar();
 311                                         connector->Update();
 312                                         vtkImageData *im = vtkImageData::New();
 313                                         im->ShallowCopy(connector->GetOutput());
 314                                         im->Update();
 315                                         m_Vresults.push_back(im);
 316                      }
 317                   }
 318           }
 319
 320
 321
 322           template <typename TImage>
 323           void WxISimpleDlg<TImage>::split4Din3Dvtk(const std::string &i_dir)
 324           {
 325                         if ((m_Iresults).size() != 0)
 326                         {
 327                             typename TImage::Pointer image = m_Iresults[0];
 328
 329                                  if(image->GetImageDimension() == 4)
 330                                  {
 331                                                         boost::any a1(image);
 332                                                         m_AnyImages.push_back(a1);
 333                                          // size of fourth dimension
 334                                          int dsize = image->GetLargestPossibleRegion().GetSize(3);
 335                                          // Output Type
 336                                          typedef itk::Image<unsigned char,3> ImageOutputType;
 337                                          typedef itk::ImageSeriesWriter<TImage, ImageOutputType >  SeriesWriterType;
 338                                          typedef itk::MetaImageIO MetaImageType;
 339                                          MetaImageType::Pointer metaIO;
 340                                          SeriesWriterType::Pointer seriesWriter = SeriesWriterType::New();
 341
 342                                          // from JPR file to generate output files
 343                                          typedef itk::NumericSeriesFileNames NamesGeneratorType;
 344                                          NamesGeneratorType::Pointer namesGenerator = NamesGeneratorType::New();
 345                                          namesGenerator->SetStartIndex(0);
 346                                          namesGenerator->SetEndIndex(dsize-1);
 347                                          namesGenerator->SetIncrementIndex(1);
 348                                          std::string format = i_dir;
 349                                          format += "/image%03d.mhd";
 350                                          namesGenerator->SetSeriesFormat( format.c_str() );
 351
 352                                          const std::vector<std::string> names = namesGenerator->GetFileNames();
 353                                          seriesWriter->SetFileNames( names );
 354                                          seriesWriter->SetInput(image);
 355                                          seriesWriter->SetImageIO(metaIO);
 356                                          try
 357                                         {
 358                                                 seriesWriter->Update();
 359                                                 vtkMetaImageReader *vReader = vtkMetaImageReader::New();
 360                                                 std::vector<std::string>::const_iterator it = names.begin();
 361                                                 for( ;it !=  names.end(); ++it)
 362                                                 {
 363                                                         vReader->SetFileName((*it).c_str());
 364                                                         vReader->Update();
 365                                                         m_Vresults.push_back(vReader->GetOutput());
 366
 367                                                 }
 368                                         }
 369                                         catch( itk::ExceptionObject & excp )
 370                                         {
 371                                                 std::cerr << "Exception thrown while writing the series " << std::endl;
 372                                                 std::cerr << excp << std::endl;
 373                                                 //return EXIT_FAILURE;
 374                                         }
 375                                  }
 376                           }
 377
 378           }
 379
 380  }// namespace end
 381
 382 #endif //__creaImageIOWxSimpleDlg_hpp_INCLUDED__
 383