Testing/TestAllReadCompareDicom.cxx

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