src/creaImageIOWxISimpleDlg.hpp

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