Testing/TestWriteSimple.cxx

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