Testing/TestAllReadCompareDicom.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: TestAllReadCompareDicom.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/11/09 10:52:37 $
   7   Version:   $Revision: 1.53 $
   8
   9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  10   l'Image). All rights reserved. See Doc/License.txt or
  11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
  12
  13      This software is distributed WITHOUT ANY WARRANTY; without even
  14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15      PURPOSE.  See the above copyright notices for more information.
  16
  17 =========================================================================*/
  18 #include "gdcmDirList.h"
  19 #include "gdcmFile.h"
  20 #include "gdcmFileHelper.h"
  21 #include "gdcmGlobal.h"
  22 #include "gdcmTS.h"
  23 #include "gdcmDebug.h"
  24
  25 #include <iostream>
  26
  27 //Generated file:
  28 #include "gdcmDataImages.h"
  29
  30 //-->
  31 //--> WARNING :
  32 //-->          The .tst files *must* be generated on a Little Endian based computer.
  33 //-->
  34 /**
  35  * /brief   File Read/Writer specific for the TestAllReadCompareDicom test
  36  * /remarks The Test file format is (only in little endian) :
  37  *  - 4 bytes : 'gdcm'
  38  *  - 4 bytes : size X
  39  *  - 4 bytes : size Y
  40  *  - 4 bytes : size Z
  41  *  - 2 bytes : scalar size (8,16,32) --> ?!? 1 or 2 only in DICOM V3 !
  42  *  - 2 bytes : number of components per pixel (1,2,3) ---> 1 or 3 only in DICOMV3 !
  43  *  - n bytes : data
  44  */
  45 class TestFile
  46 {
  47 public:
  48    TestFile();
  49    ~TestFile();
  50
  51    bool IsReadable() {return readable;}
  52
  53    int GetXSize() {return SizeX;}
  54    int GetYSize() {return SizeY;}
  55    int GetZSize() {return SizeZ;}
  56
  57    void SetXSize(int size) {SizeX = size;}
  58    void SetYSize(int size) {SizeY = size;}
  59    void SetZSize(int size) {SizeZ = size;}
  60
  61    int GetScalarSize()                  {return ScalarSize;}
  62    void SetScalarSize(int size)         {ScalarSize = size;}
  63
  64    int GetNumberOfComponents()          {return Components;}
  65    void SetNumberOfComponents(int size) {Components = size;}
  66    int GetSwapCode() {return SwapCode;}
  67
  68    unsigned long GetDataSize() {return GetLineSize()*SizeY*SizeZ;}
  69    uint8_t *GetData() {return Data;}
  70    void SetData(const uint8_t *newData);
  71
  72    void Load(const std::string &filename);
  73    void Write(const std::string &filename);
  74
  75 private:
  76    unsigned long GetLineSize() {return SizeX*ScalarSize*Components;}
  77    int ComputeSwapCode(uint32_t tag);
  78
  79    void NewData();
  80    void DeleteData();
  81
  82    void ReadFile();
  83    bool ReadFileHeader(std::ifstream *fp);
  84    bool ReadFileData(std::ifstream *fp);
  85    void WriteFile();
  86    bool WriteFileHeader(std::ofstream *fp);
  87    bool WriteFileData(std::ofstream *fp);
  88
  89    uint8_t  ReadInt8 (std::ifstream *fp)
  90 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
  91  throw( std::ios::failure );
  92 #else
  93  ;
  94 #endif
  95    uint16_t ReadInt16(std::ifstream *fp)
  96 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
  97   throw( std::ios::failure );
  98 #else
  99  ;
 100 #endif
 101    uint32_t ReadInt32(std::ifstream *fp)
 102 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 103   throw( std::ios::failure );
 104 #else
 105  ;
 106 #endif
 107    void WriteInt8 (std::ofstream *fp,uint8_t  value);
 108    void WriteInt16(std::ofstream *fp,uint16_t value);
 109    void WriteInt32(std::ofstream *fp,uint32_t value);
 110
 111    std::string fileName;
 112    bool readable;
 113
 114    int SizeX;
 115    int SizeY;
 116    int SizeZ;
 117    uint16_t ScalarSize;
 118    uint16_t Components;
 119    uint8_t *Data;
 120    int SwapCode;
 121
 122    static const unsigned int HEADER_SIZE;
 123 };
 124
 125 const unsigned int MAX_NUMBER_OF_DIFFERENCE = 10;
 126 const unsigned int TestFile::HEADER_SIZE = 20;
 127
 128 TestFile::TestFile()
 129 {
 130    fileName = "";
 131    readable=false;
 132
 133    SizeX = 0;
 134    SizeY = 0;
 135    SizeZ = 0;
 136    ScalarSize = 0;
 137    Components = 0;
 138    Data = NULL;
 139
 140    SwapCode = 1234;
 141 }
 142
 143 TestFile::~TestFile()
 144 {
 145    DeleteData();
 146 }
 147
 148 void TestFile::SetData(const uint8_t *newData)
 149 {
 150    DeleteData();
 151    NewData();
 152    if( Data )
 153       memcpy(Data,newData,GetDataSize());
 154 }
 155
 156 void TestFile::Load(const std::string &filename)
 157 {
 158    fileName = filename;
 159    ReadFile();
 160 }
 161
 162 void TestFile::Write(const std::string &filename)
 163 {
 164    fileName = filename;
 165    WriteFile();
 166 }
 167
 168 int TestFile::ComputeSwapCode(uint32_t tag)
 169 {
 170    int swap = 0;
 171    for(int i=0;i<4;i++)
 172    {
 173       switch(tag&0x000000FF)
 174       {
 175          case 'g':
 176             swap += (i+1)*1000;
 177             break;
 178          case 'd':
 179             swap += (i+1)*100;
 180             break;
 181          case 'c':
 182             swap += (i+1)*10;
 183             break;
 184          case 'm':
 185             swap += (i+1);
 186             break;
 187          default:
 188             return 0;
 189       }
 190       tag >>= 8;
 191    }
 192    return swap;
 193 }
 194
 195 void TestFile::NewData()
 196 {
 197    DeleteData();
 198    if( GetDataSize() == 0 )
 199       return;
 200    Data = new uint8_t[GetDataSize()];
 201 }
 202
 203 void TestFile::DeleteData()
 204 {
 205    if( Data )
 206       delete[] Data;
 207    Data = NULL;
 208 }
 209
 210 void TestFile::ReadFile()
 211 {
 212    readable=true;
 213    std::ifstream fp(fileName.c_str(),std::ios::in | std::ios::binary);
 214
 215    if(!fp)
 216    {
 217       readable=false;
 218       return;
 219    }
 220
 221    try
 222    {
 223       readable=ReadFileHeader(&fp);
 224       if(!readable)
 225       {
 226          std::cout << "Problems when reading Header part" << std::endl;
 227          fp.close();
 228          return;
 229       }
 230
 231       readable=ReadFileData(&fp);
 232       if(!readable)
 233       {
 234          std::cout << "Problems when reading data" << std::endl;
 235          fp.close();
 236          return;
 237       }
 238    }
 239    catch(...)
 240    {
 241       readable=false;
 242       fp.close();
 243       return;
 244    }
 245
 246    fp.close();
 247 }
 248
 249 bool TestFile::ReadFileHeader(std::ifstream *fp)
 250 {
 251    uint32_t tag = ReadInt32(fp);
 252    SwapCode = ComputeSwapCode(tag);
 253    if( SwapCode == 0 )
 254    {
 255       std::cout << "TestFile: Bad tag - Must be 'gdcm'" << std::endl;
 256       return(false);
 257    }
 258
 259    SizeX = ReadInt32(fp); // Size X
 260    SizeY = ReadInt32(fp); // Size Y
 261    SizeZ = ReadInt32(fp); // Size Z
 262    ScalarSize = ReadInt16(fp)/8; // bits per scalar
 263    Components = ReadInt16(fp);   // Number of components
 264
 265    return(true);
 266 }
 267
 268 bool TestFile::ReadFileData(std::ifstream *fp)
 269 {
 270    DeleteData();
 271
 272    // Allocate data
 273    NewData();
 274    if( !Data )
 275       return(false);
 276
 277    // Read data
 278    fp->read((char *)Data,GetDataSize());
 279
 280    if (GetScalarSize() == 1 || GetSwapCode() == 1234)
 281    {
 282       return true;
 283    }
 284    // We *know* the .tst files are written in 'Little Endian' format.
 285    // We *know* DataSize may be 1 or 2 !
 286    uint16_t g;
 287
 288 // Track BigEndian troubles
 289 std::cout << " calarSize : " << GetScalarSize()
 290           << " SwapCode:" << GetSwapCode()
 291           << std::endl;
 292
 293    for (unsigned int i=0; i<GetDataSize()/2; i++)
 294    {
 295       g = ((uint16_t *)Data)[i];
 296       g = ( g << 8 |  g >> 8  );
 297       ((uint16_t *)Data)[i] = g;
 298    }
 299    return(true);
 300 }
 301
 302 void TestFile::WriteFile()
 303 {
 304    std::ofstream fp(fileName.c_str(),std::ios::out | std::ios::binary);
 305
 306    if(!fp)
 307    {
 308       readable=false;
 309       return;
 310    }
 311
 312    WriteFileHeader(&fp);
 313    WriteFileData(&fp);
 314
 315    fp.close();
 316 }
 317
 318 bool TestFile::WriteFileHeader(std::ofstream *fp)
 319 {
 320    WriteInt8(fp,'g'); // Bitmap tag - must be 'g'
 321    WriteInt8(fp,'d'); // Bitmap tag - must be 'd'
 322    WriteInt8(fp,'c'); // Bitmap tag - must be 'c'
 323    WriteInt8(fp,'m'); // Bitmap tag - must be 'm'
 324    WriteInt32(fp,SizeX); // Size X
 325    WriteInt32(fp,SizeY); // Size Y
 326    WriteInt32(fp,SizeZ); // Size Z
 327    WriteInt16(fp,ScalarSize*8); // bits per scalar
 328    WriteInt16(fp,Components);   // number of components
 329
 330    return(true);
 331 }
 332
 333 bool TestFile::WriteFileData(std::ofstream *fp)
 334 {
 335    fp->write((char *)Data,GetDataSize());
 336
 337    return(true);
 338 }
 339
 340 uint8_t  TestFile::ReadInt8 (std::ifstream *fp)
 341 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 342    throw( std::ios::failure )
 343 #endif
 344 {
 345    uint8_t g;
 346    fp->read ((char*)&g, (size_t)1);
 347 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 348    if ( fp->fail() )
 349       throw std::ios::failure( "TestFile::ReadInt8() - file error." );
 350    if( fp->eof() )
 351       throw std::ios::failure( "TestFile::ReadInt8() - EOF." );
 352 #endif
 353    return g;
 354 }
 355
 356 uint16_t TestFile::ReadInt16(std::ifstream *fp)
 357 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 358    throw( std::ios::failure )
 359 #endif
 360 {
 361    uint16_t g;
 362    fp->read ((char*)&g, (size_t)2);
 363 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 364    if ( fp->fail() )
 365       throw std::ios::failure( "TestFile::ReadInt16() - file error." );
 366    if( fp->eof() )
 367       throw std::ios::failure( "TestFile::ReadInt16() - EOF." );
 368 #endif
 369
 370 #if defined(GDCM_WORDS_BIGENDIAN)
 371    g = ( g << 8 |  g >> 8  );
 372 #endif
 373    return g;
 374 }
 375
 376 uint32_t TestFile::ReadInt32(std::ifstream *fp)
 377 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 378    throw( std::ios::failure )
 379 #endif
 380 {
 381    uint32_t g;
 382    fp->read ((char*)&g, (size_t)4);
 383 #if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 384    if ( fp->fail() )
 385       throw std::ios::failure( "TestFile::ReadInt32() - file error." );
 386    if( fp->eof() )
 387       throw std::ios::failure( "TestFile::ReadInt32() - EOF." );
 388 #endif
 389
 390 #if defined(GDCM_WORDS_BIGENDIAN)
 391    g = (  (g<<24)               | ((g<<8)  & 0x00ff0000) |
 392        (  (g>>8)  & 0x0000ff00) |  (g>>24)               );
 393 #endif
 394    return g;
 395 }
 396
 397 void TestFile::WriteInt8 (std::ofstream *fp,uint8_t value)
 398 {
 399    fp->write((char*)&value, (size_t)1);
 400 }
 401
 402 void TestFile::WriteInt16(std::ofstream *fp,uint16_t value)
 403 {
 404 #if defined(GDCM_WORDS_BIGENDIAN)
 405    value = ( value << 8 |  value >> 8  );
 406 #endif
 407    fp->write((char*)&value, (size_t)2);
 408 }
 409
 410 void TestFile::WriteInt32(std::ofstream *fp,uint32_t value)
 411 {
 412 #if defined(GDCM_WORDS_BIGENDIAN)
 413    value = (  (value<<24)               | ((value<<8)  & 0x00ff0000) |
 414            (  (value>>8)  & 0x0000ff00) |  (value>>24)               );
 415 #endif
 416    fp->write((char*)&value, (size_t)4);
 417 }
 418
 419 int InternalTest(std::string const &filename,
 420                  std::string const &referenceFileName )
 421 {
 422       std::cout << "   Testing: " << filename << std::endl;
 423       std::cout << "      ";
 424
 425       ////// Step 1:
 426       std::cout << "1...";
 427
 428        // new style
 429       gdcm::File *f = gdcm::File::New();
 430       f->SetLoadMode ( gdcm::LD_ALL ); // Load everything
 431       f->SetFileName( filename );
 432       f->Load();
 433
 434       if( !f->IsReadable() )
 435       {
 436         std::cout << " Failed" << std::endl
 437                    << "      Image not gdcm compatible:"
 438                   << filename << std::endl;
 439         f->Delete();
 440         return 1;
 441       }
 442       gdcm::FileHelper *tested = gdcm::FileHelper::New( f );
 443
 444       ////// Step 2:
 445       ////// Check for existence of reference baseline dicom file:
 446       std::cout << "2...";
 447
 448       TestFile *reference = new TestFile();
 449       std::ifstream refFile(referenceFileName.c_str(),
 450                             std::ios::binary|std::ios::in);
 451       if(!refFile)
 452       {
 453          std::cout << " Failed" << std::endl
 454                    << "      Image not found:"
 455                    << referenceFileName << std::endl;
 456          reference->SetXSize(tested->GetFile()->GetXSize());
 457          reference->SetYSize(tested->GetFile()->GetYSize());
 458          reference->SetZSize(tested->GetFile()->GetZSize());
 459          reference->SetScalarSize(tested->GetFile()->GetPixelSize());
 460          reference->SetNumberOfComponents(tested->GetFile()->GetNumberOfScalarComponents());
 461          reference->SetData(tested->GetImageData());
 462          reference->Write(referenceFileName);
 463       }
 464       else
 465          refFile.close();
 466
 467       reference->Load(referenceFileName);
 468       if(!reference->IsReadable())
 469       {
 470         std::cout << " Failed" << std::endl
 471                    << "      Image not Testing compatible:"
 472                   << filename << std::endl;
 473          delete reference;
 474          tested->Delete();
 475          f->Delete();
 476          return 1;
 477       }
 478
 479       ////// Step 3:
 480       std::string PixelType = tested->GetFile()->GetPixelType();
 481       std::cout << "3...";
 482       int testedDataSize    = tested->GetImageDataSize();
 483       uint8_t *testedImageData = tested->GetImageData();
 484
 485       int    referenceDataSize = reference->GetDataSize();
 486       uint8_t *referenceImageData = reference->GetData();
 487
 488       // Test the image size
 489       if (tested->GetFile()->GetXSize() != reference->GetXSize() ||
 490           tested->GetFile()->GetYSize() != reference->GetYSize() ||
 491           tested->GetFile()->GetZSize() != reference->GetZSize())
 492       {
 493          std::cout << "Failed" << std::endl
 494                    << "        Size differs: "
 495                    << "X: " << tested->GetFile()->GetXSize() << " # "
 496                    << reference->GetXSize() << " | "
 497                    << "Y: " << tested->GetFile()->GetYSize() << " # "
 498                    << reference->GetYSize() << " | "
 499                    << "Z: " << tested->GetFile()->GetZSize() << " # "
 500                    << reference->GetZSize() << std::endl;
 501          delete reference;
 502          tested->Delete();
 503          f->Delete();
 504          return 1;
 505       }
 506
 507       // Test the pixel size
 508       if (tested->GetFile()->GetPixelSize() != reference->GetScalarSize() ||
 509           tested->GetFile()->GetNumberOfScalarComponents() != reference->GetNumberOfComponents())
 510       {
 511          std::cout << "Failed" << std::endl
 512                    << "        Pixel size differs: " << std::endl
 513                    << "        Scalar size: " << tested->GetFile()->GetPixelSize() << " # "
 514                    << reference->GetScalarSize() << std::endl
 515                    << "        Number of scalar: " << tested->GetFile()->GetNumberOfScalarComponents() << " # "
 516                    << reference->GetNumberOfComponents() << std::endl
 517                    << "        Pixel type: " << tested->GetFile()->GetPixelType() << std::endl;
 518          delete reference;
 519          tested->Delete();
 520          f->Delete();
 521          return 1;
 522       }
 523
 524       // Test the data size
 525       if (testedDataSize != referenceDataSize)
 526       {
 527          std::cout << " Failed" << std::endl
 528                    << "        pixel ("
 529                    << PixelType
 530                    <<") areas lengths differ: "
 531                    << testedDataSize << " # " << referenceDataSize
 532                    << std::endl
 533                    << "        Image size: ("
 534                    << tested->GetFile()->GetXSize() << ","
 535                    << tested->GetFile()->GetYSize() << ","
 536                    << tested->GetFile()->GetZSize() << ")"
 537                    << std::endl;
 538          tested->Delete();
 539          delete reference;
 540          f->Delete();
 541          return 1;
 542       }
 543
 544       // Test the data content
 545       if ( memcmp(testedImageData, referenceImageData,
 546                            testedDataSize) != 0 )
 547       {
 548          std::string ts  = tested->GetFile()->GetTransferSyntax();
 549
 550          std::cout << " Failed" << std::endl
 551                    << "        pixel ("
 552                    << PixelType
 553                    << ") differ (as expanded in memory)."
 554                    << std::endl
 555                    << "        compression : "
 556                    << gdcm::Global::GetTS()->GetValue(ts) << std::endl;
 557
 558          std::cout << "        list of the first " << MAX_NUMBER_OF_DIFFERENCE
 559                    << " pixels differing (pos : test - ref) :"
 560                    << std::endl;
 561          int i;
 562          unsigned int j;
 563          for(i=0, j=0;i<testedDataSize && j<MAX_NUMBER_OF_DIFFERENCE;i++)
 564          {
 565             if(testedImageData[i]!=referenceImageData[i])
 566               {
 567                std::cout << std::hex << "(" << i << " : "
 568                          << std::hex << (int)(testedImageData[i]) << " - "
 569                          << std::hex << (int)(referenceImageData[i]) << ") "
 570                          << std::dec;
 571                ++j;
 572               }
 573          }
 574          std::cout << std::endl;
 575
 576          tested->Delete();
 577          delete reference;
 578          f->Delete();
 579          return 1;
 580       }
 581
 582       //////////////// Clean up:
 583       tested->Delete();
 584       delete reference;
 585       f->Delete();
 586
 587       std::cout << "OK." << std::endl;
 588
 589       return 0;
 590 }
 591
 592 int TestAllReadCompareDicom(int argc, char *argv[])
 593 {
 594 // Temporarily added, to track BigEndian troubles
 595 gdcm::Debug::WarningOn();
 596
 597    if (argc == 4)
 598       gdcm::Debug::DebugOn();
 599
 600    if ( argc >= 3 )
 601    {
 602       // The test is specified a specific filename, use it instead of looping
 603       // over all images
 604       const std::string input = argv[1];
 605       const std::string reference = argv[2];
 606       return InternalTest( input, reference );
 607    }
 608    else if ( argc > 4 || argc == 2 )
 609    {
 610       std::cerr << "   Usage: " << argv[0]
 611                 << " (no arguments needed)." << std::endl;
 612       std::cerr << "or   Usage: " << argv[0]
 613                 << " filename.dcm reference.dcm" << std::endl;
 614       return 1;
 615    }
 616    // else other cases:
 617
 618    std::cout << "   Description (Test::TestAllReadCompareDicom): "
 619              << std::endl;
 620    std::cout << "   For all images in gdcmData (and not blacklisted in "
 621                 "Test/CMakeLists.txt)"
 622              << std::endl;
 623    std::cout << "   apply the following to each filename.xxx: "
 624              << std::endl;
 625    std::cout << "   step 1: parse the image (as gdcmFile) and call"
 626              << " IsReadable(). "
 627              << std::endl;
 628    std::cout << "   step 2: find in GDCM_DATA_ROOT/BaselineDicom/filename.tst"
 629              << std::endl
 630              << "           special internal file format containing the"
 631              << std::endl
 632              << "           caracteristic of the image and the pixel data "
 633              << "(uncompressed). This file is written if it's not found."
 634              << std::endl;
 635    std::cout << "   step 3: compare the DICOM image with the reference image"
 636              << std::endl
 637              << "           (.tst file). The test is made on the caracteristics"
 638              << std::endl
 639              << "           of the image and the pixel data"
 640              << std::endl << std::endl;
 641
 642    int i = 0;
 643    int result = 0;
 644    while( gdcmDataImages[i] != 0 )
 645    {
 646       ////// Check for existence of reference baseline directory
 647
 648       std::string baseLineDir = GDCM_DATA_ROOT;
 649       baseLineDir += "/BaselineDicom";
 650
 651       if( !gdcm::DirList::IsDirectory(baseLineDir) )
 652       {
 653          std::cerr << "   The reference baseline directory " << std::endl
 654                    << "      "
 655                    << baseLineDir << std::endl
 656                    << "   couldn't be opened."
 657                    << std::endl;
 658          return 1;
 659       }
 660
 661       ////// Step 1 (see above description):
 662       std::string filename = GDCM_DATA_ROOT;
 663       filename += "/";
 664       filename += gdcmDataImages[i];
 665
 666       baseLineDir += '/';
 667       std::string referenceFileName = baseLineDir + gdcmDataImages[i++];
 668       std::string::size_type slash_pos = referenceFileName.rfind( "." );
 669       if( slash_pos != std::string::npos )
 670       {
 671          referenceFileName.replace( slash_pos + 1, 3, "tst" );
 672       }
 673
 674       if( InternalTest( filename, referenceFileName ) != 0 )
 675       {
 676          result++;
 677       }
 678    }
 679
 680    return result;
 681 }