]> Creatis software - gdcm.git/blob - Testing/TestAllReadCompareDicom.cxx
ENH: Add function declaration for atoi and isdigit
[gdcm.git] / Testing / TestAllReadCompareDicom.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: TestAllReadCompareDicom.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/05/02 17:56:44 $
7   Version:   $Revision: 1.42 $
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 the first " << MAX_NUMBER_OF_DIFFERENCE
519                    << " pixels differing (pos : test - ref) :" 
520                    << std::endl;
521          int i;
522          unsigned int j;
523          for(i=0, j=0;i<testedDataSize && j<MAX_NUMBER_OF_DIFFERENCE;i++)
524          {
525             if(testedImageData[i]!=referenceImageData[i])
526               {
527                std::cout << std::hex << "(" << i << " : " 
528                          << std::hex << (int)(testedImageData[i]) << " - "
529                          << std::hex << (int)(referenceImageData[i]) << ") "
530                          << std::dec;
531                ++j;
532               }
533          }
534          std::cout << std::endl;
535
536          delete tested;
537          delete reference;
538          return 1;
539       }
540
541       //////////////// Clean up:
542       delete tested;
543       delete reference;
544
545       std::cout << "OK." << std::endl;
546       
547       return 0;
548 }
549
550 int TestAllReadCompareDicom(int argc, char *argv[]) 
551 {
552    if ( argc == 3 )
553    {
554       // The test is specified a specific filename, use it instead of looping
555       // over all images
556       const std::string input = argv[1];
557       const std::string reference = argv[2];
558       return InternalTest( input, reference );
559    }
560    else if ( argc > 3 || argc == 2 )
561    {
562       std::cerr << "   Usage: " << argv[0]
563                 << " (no arguments needed)." << std::endl;
564       std::cerr << "or   Usage: " << argv[0]
565                 << " filename.dcm reference.dcm" << std::endl;
566       return 1;
567    }
568    // else other cases:
569    
570    std::cout << "   Description (Test::TestAllReadCompareDicom): "
571              << std::endl;
572    std::cout << "   For all images in gdcmData (and not blacklisted in "
573                 "Test/CMakeLists.txt)"
574              << std::endl;
575    std::cout << "   apply the following to each filename.xxx: "
576              << std::endl;
577    std::cout << "   step 1: parse the image (as gdcmFile) and call"
578              << " IsReadable(). "
579              << std::endl;
580    std::cout << "   step 2: find in GDCM_DATA_ROOT/BaselineDicom/filename.tst"
581              << std::endl
582              << "           special internal file format containing the"
583              << std::endl
584              << "           caracteristic of the image and the pixel datas "
585              << "(uncompressed). This file is written if it's not found."
586              << std::endl;
587    std::cout << "   step 3: compare the DICOM image with the reference image"
588              << std::endl
589              << "           (.tst file). The test is made on the caracteristics"
590              << std::endl
591              << "           of the image and the pixel datas"
592              << std::endl << std::endl;
593
594    int i = 0;
595    int result = 0;
596    while( gdcmDataImages[i] != 0 )
597    {
598       ////// Check for existence of reference baseline directory
599
600       std::string baseLineDir = GDCM_DATA_ROOT;
601       baseLineDir += "/BaselineDicom";
602
603       if( !gdcm::DirList::IsDirectory(baseLineDir) )
604       {
605          std::cerr << "   The reference baseline directory " << std::endl
606                    << "      "
607                    << baseLineDir << std::endl
608                    << "   couldn't be opened."
609                    << std::endl;
610          return 1;
611       }
612
613       ////// Step 1 (see above description):
614       std::string filename = GDCM_DATA_ROOT;
615       filename += "/";
616       filename += gdcmDataImages[i];
617       
618       baseLineDir += '/';
619       std::string referenceFileName = baseLineDir + gdcmDataImages[i++];
620       std::string::size_type slash_pos = referenceFileName.rfind( "." );
621       if( slash_pos != std::string::npos )
622       {
623          referenceFileName.replace( slash_pos + 1, 3, "tst" );
624       }
625
626       if( InternalTest( filename, referenceFileName ) != 0 )
627       {
628          result++;
629       }
630    }
631
632    return result;
633 }