src/creaImageIOWxISimpleDlg.hpp

   1 //#include "creaImageIOWxISimpleDlg.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 "itkImageToVTKImageFilter.h"
  14 #include <itkOrientedImage.h>
  15 #include <vtkImageReader2.h>
  16 #include <boost/filesystem/path.hpp>
  17 #include <boost/filesystem.hpp>
  18 #include <boost/utility.hpp>
  19 #include <creaVtkBasicSlicer.h>
  20
  21 namespace creaImageIO
  22 {
  23                 template <typename TImage2>
  24   typename TImage2::Pointer ReadImage( const std::string &fileName)
  25   {
  26
  27
  28
  29     typename TImage2::Pointer image;
  30
  31     typedef itk::ImageFileReader<TImage2> ReaderType;
  32     typename ReaderType::Pointer reader = ReaderType::New();
  33     reader->SetFileName( fileName.c_str() );
  34     try
  35       {
  36       reader->Update();
  37       }
  38     catch( itk::ExceptionObject & err )
  39       {
  40       std::cout << "Caught an exception reading" << fileName << ": " << std::endl;
  41       std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
  42       throw err;
  43       }
  44     catch(...)
  45       {
  46       std::cout << "Error while reading image " << fileName << std::endl;
  47       throw;
  48       }
  49      image = reader->GetOutput();
  50
  51     return image;
  52   }
  53
  54
  55         ///Ctor
  56   template <typename TImage>
  57    WxISimpleDlg<TImage>::WxISimpleDlg(wxWindow *parent,
  58                                                         wxString i_title,
  59                                                         const std::string i_namedescp ,
  60                                                         const std::string i_namedb)
  61     : wxDialog(parent, -1,_T("DISPLAY IMAGES"), wxDefaultPosition, wxSize(230,150))
  62    {
  63                 namedescp       = i_namedescp;
  64                 namedb          = i_namedb;
  65
  66            if(!i_title.empty())
  67            {
  68                         this->SetTitle(i_title);
  69            }
  70            // Button to select file(s)
  71            wxButton *fileBut = new wxButton(this, -1,_T("Select a file to display"), wxPoint(10,7) );
  72            Connect( fileBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxISimpleDlg::OnReadFile );
  73
  74            // Button to select directory
  75            wxButton *directoryBut = new wxButton(this, -1,_T("Select a directory to display"), wxPoint(10,40) );
  76            Connect( directoryBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxISimpleDlg::OnReadDirectory );
  77
  78            // button to select creaImageIO
  79            wxButton *gimmickBut = new wxButton(this, -1,_T("Select Gimmick"), wxPoint(10,70) );
  80            Connect( gimmickBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxISimpleDlg::OnReadGimmick );
  81
  82            /// \TODO  Button to select Bruker directory
  83                 m_dicom = true;
  84         Layout();
  85
  86         }
  87 //////////////////////////////////////////////////////////////////////
  88 //                                                                  //
  89 //////////////////////////////////////////////////////////////////////
  90      template <typename TImage>
  91           void WxISimpleDlg<TImage>::OnReadFile(wxCommandEvent& event)
  92           {
  93                   int resultShowModal;
  94                   wxFileDialog* fileDlg = new wxFileDialog( 0,  _T("Select file"), _T(""), _T(""), crea::std2wx("*"), wxOPEN |wxFD_MULTIPLE, wxDefaultPosition);
  95
  96                     resultShowModal = fileDlg->ShowModal();
  97                         if ( resultShowModal==wxID_OK )
  98                         {
  99                                 wxArrayString wxArray;
 100                                 fileDlg->GetPaths(wxArray);
 101                                 if(wxArray.size() >0)
 102                                 {
 103                                         for( int i = 0; i < wxArray.GetCount(); i++)
 104                                         {
 105                                                 readImg( crea::wx2std(wxArray[i]));
 106                                         }
 107                                 }
 108                                 else {
 109                                         // TO DO WARNING MESSAGES
 110                                 }
 111                         }
 112                   SetReturnCode( resultShowModal );
 113 //               Close();
 114                  EndModal( resultShowModal );
 115           }
 116
 117
 118             template <typename TImage>
 119                 void WxISimpleDlg<TImage>::setExts(std::vector<std::string> i_exts)
 120                 {
 121                         m_exts = i_exts;
 122                 }
 123  //////////////////////////////////////////////////////////////////////
 124 //                                                                                                                                      //
 125 //////////////////////////////////////////////////////////////////////
 126             template <typename TImage>
 127           void WxISimpleDlg<TImage>::OnReadDirectory(wxCommandEvent &event)
 128           {
 129                   int resultShowModal;
 130                   bool bvalid = false;
 131              long style = wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST;
 132                  wxDirDialog* dirDlg = new wxDirDialog( 0, _T("Select the directory to display"), _T(""), style);
 133
 134                  resultShowModal = dirDlg->ShowModal();
 135                  if ( resultShowModal==wxID_OK )
 136                  {
 137                         std::string path = crea::wx2std(dirDlg->GetPath());
 138                         typedef boost::filesystem::directory_iterator dir_it;
 139                         dir_it itr(path);
 140                         dir_it end_itr;
 141                         /*if (boost::filesystem::exists(path))
 142                         {*/
 143                                 for(;itr != end_itr; ++itr)
 144                                 {
 145                                            bvalid = m_exts.size() == 0? true : false;
 146                                            std::vector<std::string>::iterator it = m_exts.begin();
 147                                            std::string ext = itr->filename().substr(itr->filename().find_last_of("."));
 148                                            for(; it != m_exts.end(); it++)
 149                                            {
 150                                                    if(ext == (*it) )
 151                                                    {
 152                                                            bvalid = true;
 153                                                            break;
 154                                                    }
 155                                            }
 156                                         if (!boost::filesystem::is_directory(itr->status()) && bvalid)
 157                                         {
 158                                                 readImg(itr->string().c_str());
 159                                         }
 160                                 }
 161                  }
 162                  SetReturnCode( resultShowModal );
 163 //               Close();
 164                  EndModal( resultShowModal );
 165           }
 166
 167           //////////////////////////////////////////////////////////////////////
 168 //                                                                                                                                      //
 169 //////////////////////////////////////////////////////////////////////
 170                     template <typename TImage>
 171           void WxISimpleDlg<TImage>::OnReadGimmick(wxCommandEvent &event)
 172           {
 173                   // Run Gimmick
 174                    WxGimmickReaderDialog dlg(0,-1,
 175                                    namedescp,
 176                                    namedb,
 177                                    _T("Select image(s)        - Gimmick! (c) CREATIS-LRMN 2008"),
 178                    wxDefaultPosition,
 179                    wxSize(810,750),
 180                    GIMMICK_2D_IMAGE_SELECTION,
 181                    GIMMICK_3D_IMAGE_SELECTION,
 182                    _3D,
 183                                    1);
 184                  dlg.ShowModal();
 185                  if (dlg.GetReturnCode() == wxID_OK)
 186              {
 187                         std::vector<std::string> out;
 188                         dlg.stopReading();
 189                         dlg.GetSelectedFiles(out);
 190                         if(m_dicom)
 191                         {
 192                                 readDicomImg( out);
 193                         }
 194                         else
 195                         {
 196                                 std::vector<std::string>::iterator ii = out.begin();
 197                                 for (;ii != out.end();ii++)
 198                                 {
 199                                         readImg( (*ii).c_str() );
 200                                 }
 201                         }
 202                         dlg.OnExit();
 203                  }
 204                  SetReturnCode( dlg.GetReturnCode() );
 205 //               Close();
 206                  EndModal( dlg.GetReturnCode() );
 207            }
 208
 209
 210      template <typename TImage>
 211          wxString WxISimpleDlg<TImage>::getInfoImage()
 212         {
 213                 return infoimage;
 214         }
 215
 216
 217     //////////////////////////////////////////////////////////////////////
 218     // Return the results vector                                                                                //
 219     //////////////////////////////////////////////////////////////////////
 220          template <typename TImage>
 221          std::vector<typename TImage::Pointer> WxISimpleDlg<TImage>::getImagesSelected()
 222           {
 223                   return m_Iresults;
 224           }
 225
 226           template <typename TImage>
 227           void WxISimpleDlg<TImage>::readImg(const std::string &i_name)
 228           {
 229                     // FCY : just to check but not needed, we hardly suppose that we load only same type and dim of images
 230                     // uncomment to test
 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                         ScalarPixelType pixelType = imageIO->GetComponentType();
 236                         const size_t dims =  imageIO->GetNumberOfDimensions();*/
 237
 238                         typedef itk::ImageFileReader<TImage> ReaderType;
 239                     typename ReaderType::Pointer reader = ReaderType::New();
 240                         reader->SetFileName( i_name );
 241                         try
 242                         {
 243                                 reader->Update();
 244                         }
 245                         catch( itk::ExceptionObject & err )
 246                         {
 247                                 std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 248                                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 249                                 throw err;
 250                         }
 251                         catch(...)
 252                         {
 253                                 std::cout << "Error while reading image " << i_name << std::endl;
 254                                 throw;
 255                         }
 256                         m_Iresults.push_back(reader->GetOutput());
 257
 258           }
 259
 260
 261
 262           template <typename TImage>
 263           void WxISimpleDlg<TImage>::readDicomImg(const std::vector<std::string> &i_names)
 264           {
 265                   typedef itk::GDCMImageIO GDCMType;
 266                   typedef itk::DICOMSeriesFileNames dicnames;
 267                   GDCMType::Pointer gdcmIO = GDCMType::New();
 268                   dicnames::Pointer generator = dicnames::New();
 269 //                generator->SetInput(i_names);
 270                         typedef itk::ImageSeriesReader<TImage> ReaderType;
 271                     typename ReaderType::Pointer reader = ReaderType::New();
 272                         reader->SetImageIO(gdcmIO);
 273                         reader->SetFileNames(i_names);
 274                 //      reader->SetFileName( i_name );
 275                         try
 276                         {
 277                                 reader->Update();
 278                         }
 279                         catch( itk::ExceptionObject & err )
 280                         {
 281                         //      std::cout << "Caught an exception reading" << i_name << ": " << std::endl;
 282                                 std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl;
 283                                 throw err;
 284                         }
 285                         catch(...)
 286                         {
 287                                 //std::cout << "Error while reading image " << i_name << std::endl;
 288                                 throw;
 289                         }
 290                         m_Iresults.push_back(reader->GetOutput());
 291
 292           }
 293
 294
 295
 296
 297           template <typename TImage>
 298           void WxISimpleDlg<TImage>::split3Din3Dvtk()
 299           {
 300                   if ((m_Iresults).size() != 0)
 301                   {
 302                           typedef itk::ImageToVTKImageFilter<  TImage > ConnectorType;
 303                           ConnectorType::Pointer          connector = ConnectorType::New();
 304               for(unsigned int i = 0 ;i < m_Iresults.size(); i++)
 305                       {
 306                                         connector->SetInput(m_Iresults[i]);
 307                                         connector->GetImporter()->SetDataScalarTypeToUnsignedChar();
 308                                         connector->Update();
 309                                         vtkImageData *im = vtkImageData::New();
 310                                         im->ShallowCopy(connector->GetOutput());
 311                                         im->Update();
 312                                         m_Vresults.push_back(im);
 313                      }
 314                   }
 315           }
 316
 317
 318
 319           template <typename TImage>
 320           void WxISimpleDlg<TImage>::split4Din3Dvtk(const std::string &i_dir)
 321           {
 322                         if ((m_Iresults).size() != 0)
 323                         {
 324                             typename TImage::Pointer image = m_Iresults[0];
 325
 326                                  // Size and dims for Input Image
 327                                 typedef itk::Size<4> iSize; // TO REMOVE
 328                                 typedef const itk::Size<4>::SizeValueType iSizeVal; // TO REMOVE
 329                                 iSize size = image->GetLargestPossibleRegion().GetSize();
 330                                 iSizeVal *dims_size  = size.GetSize();
 331
 332                                  // Output Type
 333                                  typedef itk::Image<unsigned char,3> ImageOutputType;
 334                              typedef itk::ImageSeriesWriter<TImage, ImageOutputType >  SeriesWriterType;
 335
 336                                 /* typedef itk::VectorImage<short, 3> VectorImageType;
 337                                  VectorImageType::Pointer vect = VectorImageType::New();
 338                                  vect.*/
 339
 340
 341                                  SeriesWriterType::Pointer seriesWriter = SeriesWriterType::New();
 342                                  seriesWriter->SetInput( image);
 343
 344                                  // from JPR file to generate output files
 345                                  typedef itk::NumericSeriesFileNames NamesGeneratorType;
 346                                  NamesGeneratorType::Pointer namesGenerator = NamesGeneratorType::New();
 347                                  namesGenerator->SetStartIndex(0);
 348                                  namesGenerator->SetEndIndex(dims_size[3]-1); // TO CHANGE
 349                                  namesGenerator->SetIncrementIndex(1);
 350                                  std::string format = i_dir;
 351                              format += "/image%03d.vtk";
 352                                  namesGenerator->SetSeriesFormat( format.c_str() );
 353                                  const std::vector<std::string> names = namesGenerator->GetFileNames();
 354                                  seriesWriter->SetFileNames( names );
 355
 356                                  try
 357                                 {
 358                                         seriesWriter->Update();
 359                                         vtkImageReader2 *vReader = vtkImageReader2::New();
 360                                         vReader->SetFilePrefix(".vtk");
 361                                         std::vector<std::string>::const_iterator it = names.begin();
 362                                         for( ;it !=  names.end(); ++it)
 363                                         {
 364                                                 vReader->SetFileName((*it).c_str());
 365                                                 vReader->Update();
 366                                                 crea::VtkBasicSlicer(vReader->GetOutput());
 367                                                 m_Vresults.push_back(vReader->GetOutput());
 368                                         }
 369                                 }
 370                                 catch( itk::ExceptionObject & excp )
 371                                 {
 372                                         std::cerr << "Exception thrown while writing the series " << std::endl;
 373                                         std::cerr << excp << std::endl;
 374                                         //return EXIT_FAILURE;
 375                                 }
 376
 377                   }
 378
 379           }
 380
 381  }// namespace end
 382