]> Creatis software - gdcm.git/blob - Testing/TestAllReadCompareDicom.cxx
ENH: Add 0020,1003/1005 see post of dicom newsgroup
[gdcm.git] / 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 }