Testing/TestWriteSimple.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: TestWriteSimple.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/01/08 23:18:31 $
   7   Version:   $Revision: 1.11 $
   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
  19 /**
  20  * Write a dicom file from nothing
  21  * The written image is 256x256, 8 bits, unsigned char
  22  * The image content is a horizontal grayscale from
  23  *
  24  */
  25 #include "gdcmHeader.h"
  26 #include "gdcmFile.h"
  27
  28 #include <iostream>
  29 #include <sstream>
  30
  31 typedef struct
  32 {
  33    int sizeX;         // Size X of the image
  34    int sizeY;         // Size Y of the image
  35    int sizeZ;         // Size Z of the image
  36    int components;    // Number of components for a pixel
  37    int componentSize; // Component size (in bits : 8, 16)
  38    int componentUse ; // Component size (in bits)
  39    int sign;          // Sign of components
  40    char writeMode;    // Write mode
  41                       //  - 'a' : ACR
  42                       //  - 'e' : Explicit VR
  43                       //  - 'i' : Implicit VR
  44 } Image;
  45
  46 Image Images [] = {
  47    {256, 256, 1, 1, 8,  8,  0, 'a'},
  48    {256, 256, 1, 1, 8,  8,  0, 'e'},
  49    {256, 256, 1, 1, 8,  8,  0, 'i'},
  50
  51    {512, 256, 1, 1, 8,  8,  0, 'a'},
  52    {512, 256, 1, 1, 8,  8,  0, 'e'},
  53    {512, 256, 1, 1, 8,  8,  0, 'i'},
  54
  55    {256, 512, 1, 1, 8,  8,  0, 'a'},
  56    {256, 512, 1, 1, 8,  8,  0, 'e'},
  57    {256, 512, 1, 1, 8,  8,  0, 'i'},
  58
  59    {256, 512, 1, 1, 16, 16, 0, 'a'},
  60    {256, 512, 1, 1, 16, 16, 0, 'e'},
  61    {256, 512, 1, 1, 16, 16, 0, 'i'},
  62    {256, 512, 1, 1, 16, 16, 0, 'a'},
  63    {256, 512, 1, 1, 16, 16, 0, 'e'},
  64    {256, 512, 1, 1, 16, 16, 0, 'i'},
  65    {0,   0,   1, 1, 8,  8,  0, 'i'} // to find the end
  66 };
  67
  68 int WriteSimple(Image &img)
  69 {
  70    std::string fileName = "TestWriteSimple.dcm";
  71
  72 // Step 1 : Create the header of the image
  73    std::cout << "        1...";
  74    gdcm::Header *header = new gdcm::Header();
  75    std::ostringstream str;
  76
  77    // Set the image size
  78    str.str("");
  79    str << img.sizeX;
  80    header->ReplaceOrCreate(str.str(),0x0028,0x0011); // Columns
  81
  82    str.str("");
  83    str << img.sizeY;
  84    header->ReplaceOrCreate(str.str(),0x0028,0x0010); // Rows
  85
  86    if(img.sizeZ>1)
  87    {
  88       str.str("");
  89       str << img.sizeZ;
  90       header->ReplaceOrCreate(str.str(),0x0028,0x0008); // Number of Frames
  91    }
  92
  93    // Set the pixel type
  94    str.str("");
  95    str << img.componentSize;
  96    header->ReplaceOrCreate(str.str(),0x0028,0x0100); // Bits Allocated
  97
  98    str.str("");
  99    str << img.componentUse;
 100    header->ReplaceOrCreate(str.str(),0x0028,0x0101); // Bits Stored
 101
 102    str.str("");
 103    str << img.componentSize - 1;
 104    header->ReplaceOrCreate(str.str(),0x0028,0x0102); // High Bit
 105
 106    // Set the pixel representation
 107    str.str("");
 108    str << img.sign;
 109    header->ReplaceOrCreate(str.str(),0x0028,0x0103); // Pixel Representation
 110
 111    // Set the samples per pixel
 112    str.str("");
 113    str << img.components;
 114    header->ReplaceOrCreate(str.str(),0x0028,0x0002); // Samples per Pixel
 115
 116    if( !header->IsReadable() )
 117    {
 118       std::cout << "Failed\n"
 119                 << "        Prepared image isn't readable\n";
 120
 121       delete header;
 122       return 1;
 123    }
 124
 125 // Step 2 : Create the output image
 126    std::cout << "2...";
 127    if( img.componentSize%8 > 0 )
 128    {
 129       img.componentSize += 8-img.componentSize%8;
 130    }
 131    size_t size = img.sizeX * img.sizeY * img.sizeZ
 132                * img.components * img.componentSize / 8;
 133    unsigned char *imageData = new unsigned char[size];
 134
 135    // FIXME : find a best heuristic to create the image
 136    unsigned char *tmp = imageData;
 137    for(int k=0;k<img.sizeZ;k++)
 138    {
 139       for(int j=0;j<img.sizeY;j++)
 140       {
 141          for(int i=0;i<img.sizeX;i++)
 142          {
 143             for(int c=0;c<img.components;c++)
 144             {
 145                *tmp = j%256;
 146                if( img.componentSize>8 )
 147                {
 148                   *(tmp+1) = j/256;
 149                }
 150                tmp += img.componentSize * img.components/8;
 151             }
 152          }
 153       }
 154    }
 155
 156 // Step 3 : Create the file of the image
 157    std::cout << "3...";
 158    gdcm::File *file = new gdcm::File(header);
 159    file->SetImageData(imageData,size);
 160
 161 // Step 4 : Set the writting mode and write the image
 162    std::cout << "4...";
 163
 164    file->SetWriteModeToRaw();
 165    switch (img.writeMode)
 166    {
 167       case 'a' : // Write an ACR file
 168          file->SetWriteTypeToAcr();
 169          break;
 170
 171       case 'e' : // Write a DICOM Explicit VR file
 172          file->SetWriteTypeToDcmExplVR();
 173          break;
 174
 175       case 'i' : // Write a DICOM Implicit VR file
 176          file->SetWriteTypeToDcmImplVR();
 177          break;
 178
 179       default :
 180          std::cout << "Failed\n"
 181                    << "        Write mode '"<<img.writeMode<<"' is undefined\n";
 182
 183          delete file;
 184          delete header;
 185          delete[] imageData;
 186          return 1;
 187    }
 188
 189    if( !file->Write(fileName) )
 190    {
 191       std::cout << "Failed\n"
 192                 << "File in unwrittable\n";
 193
 194       delete file;
 195       delete header;
 196       delete[] imageData;
 197       return 1;
 198    }
 199
 200 // Step 5 : Read the written image
 201    std::cout << "5...";
 202    gdcm::File* reread = new gdcm::File( fileName );
 203    if( !reread->GetHeader()->IsReadable() )
 204    {
 205      std::cerr << "Failed" << std::endl
 206                << "Test::TestReadWriteReadCompare: Could not reread image "
 207                << "written:" << fileName << std::endl;
 208      delete header;
 209      delete file;
 210      delete reread;
 211      return 1;
 212    }
 213
 214 // Step 6 : Compare to the written image
 215    std::cout << "6...";
 216    size_t dataSizeWritten = reread->GetImageDataSize();
 217    uint8_t* imageDataWritten = reread->GetImageData();
 218
 219    // Test the image size
 220    if (header->GetXSize() != reread->GetHeader()->GetXSize() ||
 221        header->GetYSize() != reread->GetHeader()->GetYSize() ||
 222        header->GetZSize() != reread->GetHeader()->GetZSize())
 223    {
 224       std::cout << "Failed" << std::endl
 225          << "        X Size differs: "
 226          << "X: " << header->GetXSize() << " # "
 227                   << reread->GetHeader()->GetXSize() << " | "
 228          << "Y: " << header->GetYSize() << " # "
 229                   << reread->GetHeader()->GetYSize() << " | "
 230          << "Z: " << header->GetZSize() << " # "
 231                   << reread->GetHeader()->GetZSize() << std::endl;
 232       delete header;
 233       delete file;
 234       delete reread;
 235       delete[] imageData;
 236
 237       return 1;
 238    }
 239
 240    // Test the data size
 241    if (size != dataSizeWritten)
 242    {
 243       std::cout << "Failed" << std::endl
 244          << "        Pixel areas lengths differ: "
 245          << size << " # " << dataSizeWritten << std::endl;
 246       delete header;
 247       delete file;
 248       delete reread;
 249       delete[] imageData;
 250
 251       return 1;
 252    }
 253
 254    // Test the data's content
 255    if (int res = memcmp(imageData, imageDataWritten, size) !=0)
 256    {
 257       (void)res;
 258       std::cout << "Failed" << std::endl
 259                 << "        Pixel differ (as expanded in memory)." << std::endl;
 260       delete header;
 261       delete file;
 262       delete reread;
 263       delete[] imageData;
 264
 265       return 1;
 266    }
 267
 268    std::cout << "OK" << std::endl;
 269
 270    delete header;
 271    delete file;
 272    delete reread;
 273    delete[] imageData;
 274
 275    return 0;
 276 }
 277
 278 int TestWriteSimple(int argc, char* argv[])
 279 {
 280    if (argc < 1)
 281    {
 282       std::cerr << "usage: \n"
 283                 << argv[0] << " (without parameters) " << std::endl
 284                 << std::endl;
 285       return 1;
 286    }
 287
 288    int ret=0;
 289    int i=0;
 290    while( Images[i].sizeX>0 && Images[i].sizeY>0 )
 291    {
 292       ret += WriteSimple(Images[i]);
 293       i++;
 294    }
 295
 296    return ret;
 297 }