X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=Example%2FWriteDicomAsJPEG.cxx;h=e848a915ea8d652c044761ae0dcead9db0b830f9;hb=329b5524e57929ecf64495be9fe757b69ba64613;hp=dbdd5aa1ebe7360854f078cd51d5a356a01ab475;hpb=4353f27a34a17d0802f78a8dc33c31841aa60ee1;p=gdcm.git diff --git a/Example/WriteDicomAsJPEG.cxx b/Example/WriteDicomAsJPEG.cxx index dbdd5aa1..e848a915 100644 --- a/Example/WriteDicomAsJPEG.cxx +++ b/Example/WriteDicomAsJPEG.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: WriteDicomAsJPEG.cxx,v $ Language: C++ - Date: $Date: 2005/10/18 18:36:53 $ - Version: $Revision: 1.1 $ + Date: $Date: 2005/10/19 22:19:20 $ + Version: $Revision: 1.8 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -18,6 +18,7 @@ #include "gdcmFile.h" #include "gdcmFileHelper.h" +#include "gdcmUtil.h" #include #include @@ -37,10 +38,106 @@ extern "C" { #include "jdatasrc.cxx" #include "jdatadst.cxx" -bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, - int image_width, int image_height, int sample_pixel, int quality) +typedef std::pair JpegPair; //offset, jpeg size +typedef std::vector JpegVector; + +void WriteDICOMItems(std::ostream *fp, JpegVector &v) +{ + // Item tag: + uint16_t group = 0xfffe; + uint16_t elem = 0xe000; + gdcm::binary_write(*fp, group); + gdcm::binary_write(*fp, elem); + // Item Length + uint32_t dummy = 0x12345678; + size_t offset = fp->tellp(); + JpegPair jp; + jp.first = offset; + v.push_back(jp); + gdcm::binary_write(*fp, dummy); +} + +// PS 3.5, page 66 +void EncodeWithoutBasicOffsetTable(std::ostream *fp, int numFrag)// JpegVector& v) //, uint32_t length) +{ + assert( numFrag == 1); + + // Item tag: + uint16_t group = 0xfffe; + uint16_t elem = 0xe000; + gdcm::binary_write(*fp, group); + gdcm::binary_write(*fp, elem); + // Item Length + uint32_t item_length = 0x0000; + gdcm::binary_write(*fp, item_length); + +} + +// PS 3.5, page 67 +void EncodeWithBasicOffsetTable(std::ostream *fp, int numFrag, size_t &start) +{ + // Item tag: + uint16_t group = 0xfffe; + uint16_t elem = 0xe000; + gdcm::binary_write(*fp, group); + gdcm::binary_write(*fp, elem); + // Item Length + uint32_t item_length = numFrag*4; // sizeof(uint32_t) + gdcm::binary_write(*fp, item_length); + + // Just prepare the space + start = fp->tellp(); //to be able to rewind + for(int i=0; iseekp( pos ); + const JpegPair &first = v[0]; + for(i=v.begin(); i!=v.end(); ++i) + { + const JpegPair &jp = *i; + if(i == v.begin() ){ assert( jp.first - first.first == 0); } + gdcm::binary_write(*fp, jp.first - first.first); + std::cerr << "Updating Table:" << jp.first - first.first << std::endl; + } +} + +void UpdateJpegFragmentSize(std::ostream *fp, JpegVector const &v) +{ + JpegVector::const_iterator i; + for(i= v.begin(); i!=v.end(); ++i) + { + const JpegPair &jp = *i; + fp->seekp( jp.first ); + gdcm::binary_write(*fp, jp.second ); + std::cerr << "Updating:" << jp.first << "," << jp.second << std::endl; + } +} + +void CloseJpeg(std::ostream *fp, JpegVector &v) +{ + // sequence terminator + uint16_t group = 0xfffe; + uint16_t elem = 0xe000; + gdcm::binary_write(*fp, group); + gdcm::binary_write(*fp, elem); + + uint32_t length = 0x0; + gdcm::binary_write(*fp, length); + + // Jpeg is done, now update the frag length + UpdateJpegFragmentSize(fp, v); +} + +bool InitializeJpeg(std::ostream *fp, int fragment_size, int image_width, int image_height, + int sample_pixel, int quality, struct jpeg_compress_struct &cinfo, int &row_stride) { - JSAMPLE *image_buffer = (JSAMPLE*) input_buffer; /* This struct contains the JPEG compression parameters and pointers to * working space (which is allocated as needed by the JPEG library). @@ -48,7 +145,7 @@ bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, * compression/decompression processes, in existence at once. We refer * to any one struct (and its associated working data) as a "JPEG object". */ - struct jpeg_compress_struct cinfo; + //struct jpeg_compress_struct cinfo; /* This struct represents a JPEG error handler. It is declared separately * because applications often want to supply a specialized error handler * (see the second half of this file for an example). But here we just @@ -59,9 +156,6 @@ bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, */ struct jpeg_error_mgr jerr; /* More stuff */ - //FILE* outfile; /* target FILE* / - JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ - int row_stride; /* physical row width in image buffer */ /* Step 1: allocate and initialize JPEG compression object */ @@ -77,17 +171,7 @@ bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, /* Step 2: specify data destination (eg, a file) */ /* Note: steps 2 and 3 can be done in either order. */ - /* Here we use the library-supplied code to send compressed data to a - * stdio stream. You can also write your own code to do something else. - * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that - * requires it in order to write binary files. - */ - // if ((outfile = fopen(filename, "wb")) == NULL) { - // fprintf(stderr, "can't open %s\n", filename); - // exit(1); - // - // } - jpeg_stdio_dest(&cinfo, fp, fragment_size); + jpeg_stdio_dest(&cinfo, fp, fragment_size, 1); /* Step 3: set parameters for compression */ @@ -111,6 +195,21 @@ bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, * since the defaults depend on the source color space.) */ jpeg_set_defaults(&cinfo); + /* + * http://www.koders.com/c/fid80DBBF1D49D004EF71CE7C493C34610C4F17D3D3.aspx + * http://studio.imagemagick.org/pipermail/magick-users/2002-September/004685.html + * You need to set -quality 101 or greater. If quality is 100 or less you + * get regular JPEG output. This is not explained in the documentation, only + * in the comments in coder/jpeg.c. When you have configured libjpeg with + * lossless support, then + * + * quality=predictor*100 + point_transform + * + * If you don't know what these values should be, just use 101. + * They only affect the compression ratio, not the image appearance, + * which is lossless. + */ + jpeg_simple_lossless (&cinfo, 1, 1); /* Now you can set any non-default parameters you wish to. * Here we just illustrate the use of quality (quantization table) scaling: */ @@ -139,44 +238,122 @@ bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, { row_stride = image_width * 1;/* JSAMPLEs per row in image_buffer */ } - - while (cinfo.next_scanline < cinfo.image_height) { - /* jpeg_write_scanlines expects an array of pointers to scanlines. - * Here the array is only one element long, but you could pass - * more than one scanline at a time if that's more convenient. - */ - row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride]; - - (void) jpeg_write_scanlines(&cinfo, row_pointer, 1); - } + /* everything was ok */ + return true; +} +bool FinalizeJpeg(struct jpeg_compress_struct &cinfo) +{ /* Step 6: Finish compression */ jpeg_finish_compress(&cinfo); - /* After finish_compress, we can close the output file. */ - - // fclose(fp); --> the caller will close (multiframe treatement) - /* Step 7: release JPEG compression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_compress(&cinfo); /* And we're done! */ + return true; +} + +// If false then suspension return +bool WriteScanlines(struct jpeg_compress_struct &cinfo, void *input_buffer, int row_stride) +{ + JSAMPLE *image_buffer = (JSAMPLE*) input_buffer; + JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ + row_pointer[0] = image_buffer; + while (cinfo.next_scanline < cinfo.image_height) { + /* jpeg_write_scanlines expects an array of pointers to scanlines. + * Here the array is only one element long, but you could pass + * more than one scanline at a time if that's more convenient. + */ + //row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride]; + + if( jpeg_write_scanlines(&cinfo, row_pointer, 1) != 1) + { + //entering suspension mode, basically we wrote the whole jpeg fragment + // technically we could enforce that by checkig the value of row_pointer to + // actually be at the end of the image...TODO + return false; + } + row_pointer[0] += row_stride; + } + + // Well looks like we are done writting the scanlines return true; } +// input_buffer is ONE image +// fragment_size is the size of this image (fragment) +bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, + int image_width, int image_height, int numZ, int sample_pixel, int quality, JpegVector &v) +{ + struct jpeg_compress_struct cinfo; + int row_stride; /* physical row width in image buffer */ + size_t beg = fp->tellp(); + bool r = InitializeJpeg(fp, fragment_size, image_width, image_height, + sample_pixel, quality, cinfo, row_stride); + assert( r ); + (void)numZ; + + uint8_t *pbuffer = (uint8_t*)input_buffer; + //int i; + //for(i=0; itellp(); +// std::cerr << "DIFF: " << end-beg << std::endl; + +// JpegPair &jp = v[i]; +// jp.second = end-beg; + //beg = end; // + // } + + r = FinalizeJpeg(cinfo); + assert( r ); + size_t end = fp->tellp(); + static int i = 0; + JpegPair &jp = v[i]; + jp.second = end-beg; + std::cerr << "DIFF: " << i <<" -> " << end-beg << std::endl; + ++i; + + //JpegPair &jp = v[0]; + //jp.second = 15328; + + return true; +} + +//bool CreateMultipleFrames (std::ostream *fp, void *input_buffer, int fragment_size, +// int image_width, int image_height, int sample_pixel, int quality, JpegVector &v) +//{ +//} + +#define WITHOFFSETTABLE 1 + // Open a dicom file and compress it as JPEG stream int main(int argc, char *argv[]) { - std::string filename = argv[1]; + if( argc < 2) + return 1; + + std::string filename = argv[1]; + std::string outfilename = "/tmp/bla.dcm"; + if( argc >= 3 ) + outfilename = argv[2]; + int quality = 100; + if( argc >= 4 ) + quality = atoi(argv[2]); + std::cerr << "Using quality: " << quality << std::endl; // Step 1 : Create the header of the image - gdcm::File *header = new gdcm::File(); - gdcm::File *f = new gdcm::File(); f->SetLoadMode ( gdcm::LD_ALL ); // Load everything f->SetFileName( filename ); @@ -186,6 +363,7 @@ int main(int argc, char *argv[]) std::string PixelType = tested->GetFile()->GetPixelType(); int xsize = f->GetXSize(); int ysize = f->GetYSize(); + int zsize = f->GetZSize(); int samplesPerPixel = f->GetSamplesPerPixel(); size_t testedDataSize = tested->GetImageDataSize(); @@ -198,7 +376,27 @@ int main(int argc, char *argv[]) std::cout << "Y: " << ysize << std::endl; std::cout << "Sample: " << samplesPerPixel << std::endl; int fragment_size = xsize*ysize*samplesPerPixel; - CreateOneFrame(of, testedImageData, fragment_size, xsize, ysize, samplesPerPixel, 100); + + JpegVector JpegFragmentSize; +#if WITHOFFSETTABLE + size_t bots; //basic offset table start + EncodeWithBasicOffsetTable(of, zsize, bots); +#else + EncodeWithoutBasicOffsetTable(of, 1); +#endif + uint8_t *pImageData = testedImageData; + for(int i=0; iIsReadable() ) { std::cerr << "-------------------------------\n" @@ -208,13 +406,16 @@ int main(int argc, char *argv[]) return 1; } std::streambuf* sb = of->rdbuf(); - //of->close(); - std::ofstream out("/tmp/jpeg2.jpg"); - //out.write( of->str(), of - out << of->str(); //faster than going through str() - //out.rdbuf( *sb ); - out.close(); + (void)sb; + // Let save the file as jpeg standalone + { + std::ofstream *jof = new std::ofstream( "/tmp/test.jpg" ); + CreateOneFrame(jof, testedImageData, fragment_size, xsize, ysize, zsize, + samplesPerPixel, 70, JpegFragmentSize); + jof->close(); + delete jof; + } @@ -228,44 +429,40 @@ int main(int argc, char *argv[]) // Set the image size str.str(""); str << xsize; - fileToBuild->InsertValEntry(str.str(),0x0028,0x0011); // Columns + fileToBuild->InsertEntryString(str.str(),0x0028,0x0011); // Columns str.str(""); str << ysize; - fileToBuild->InsertValEntry(str.str(),0x0028,0x0010); // Rows + fileToBuild->InsertEntryString(str.str(),0x0028,0x0010); // Rows - //if(img.sizeZ>1) - //{ - // str.str(""); - // str << img.sizeZ; - // fileToBuild->InsertValEntry(str.str(),0x0028,0x0008); // Number of Frames - //} + if(zsize>1) + { + str.str(""); + str << zsize; + fileToBuild->InsertEntryString(str.str(),0x0028,0x0008); // Number of Frames + } // Set the pixel type str.str(""); str << 8; //img.componentSize; - fileToBuild->InsertValEntry(str.str(),0x0028,0x0100); // Bits Allocated + fileToBuild->InsertEntryString(str.str(),0x0028,0x0100); // Bits Allocated str.str(""); str << 8; //img.componentUse; - fileToBuild->InsertValEntry(str.str(),0x0028,0x0101); // Bits Stored + fileToBuild->InsertEntryString(str.str(),0x0028,0x0101); // Bits Stored str.str(""); str << 7; //( img.componentSize - 1 ); - fileToBuild->InsertValEntry(str.str(),0x0028,0x0102); // High Bit + fileToBuild->InsertEntryString(str.str(),0x0028,0x0102); // High Bit // Set the pixel representation str.str(""); str << 0; //img.sign; - fileToBuild->InsertValEntry(str.str(),0x0028,0x0103); // Pixel Representation + fileToBuild->InsertEntryString(str.str(),0x0028,0x0103); // Pixel Representation // Set the samples per pixel str.str(""); str << samplesPerPixel; //img.components; - fileToBuild->InsertValEntry(str.str(),0x0028,0x0002); // Samples per Pixel - - str.str(""); - str << "1.2.840.10008.1.2.4.50"; - fileToBuild->InsertValEntry(str.str(),0x0002,0x0010); // Transfer Syntax UID + fileToBuild->InsertEntryString(str.str(),0x0028,0x0002); // Samples per Pixel // Step 2 : Create the output image // std::cout << "2..."; @@ -273,25 +470,36 @@ int main(int argc, char *argv[]) // { // img.componentSize += 8-img.componentSize%8; // } - size_t size = xsize * ysize * 1 /*Z*/ + size_t size = xsize * ysize * zsize * samplesPerPixel /* * img.componentSize / 8*/; - //uint8_t *imageData = new uint8_t[size]; + uint8_t *imageData = new uint8_t[size]; gdcm::FileHelper *fileH = new gdcm::FileHelper(fileToBuild); //fileH->SetImageData(imageData,size); assert( size == testedDataSize ); size = of->str().size(); //size = sb->in_avail(); std::cerr << "Size JPEG:" << size << std::endl; - fileH->SetImageData((uint8_t*)of->str().c_str(), size); + //fileH->SetImageData((uint8_t*)of->str().c_str(), size); + memcpy(imageData, of->str().c_str(), size); + fileH->SetImageData(imageData, size); //str::string *s = of->str(); //fileH->SetWriteTypeToDcmExplVR(); fileH->SetWriteTypeToJPEG( ); - std::string fileName = "/tmp/bla.dcm"; - if( !fileH->Write(fileName) ) + if( !fileH->Write(outfilename) ) { std::cerr << "Badddd" << std::endl; } + //of->close(); + std::ofstream out("/tmp/jpeg2.jpg"); + //out.write( of->str(), of + //out << of->str(); //rdbuf is faster than going through str() + //out.write( (char*)imageData, size); + out.write( of->str().c_str(), size); + //std::cerr << "JPEG marker is: " << imageData[6] << imageData[7] << + // imageData[8] << imageData[9] << std::endl; + //out.rdbuf( *sb ); + out.close(); delete of; delete f;