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