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