Testing/TestAllReadCompareDicom.cxx

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