Testing/TestAllReadCompareDicom.cxx

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