X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=Example%2FWriteDicomAsJPEG.cxx;h=9c6e7fa36879a85fce7f101cc5823c2620c2cb7b;hb=86806f70a22e940f0bb0e7d23a570074ff81973f;hp=5e40401ca86788c144521966ff3356f9e7da4eb6;hpb=8b7ccc5d0086fd3df994c18e2883bc0e3f7d1984;p=gdcm.git diff --git a/Example/WriteDicomAsJPEG.cxx b/Example/WriteDicomAsJPEG.cxx index 5e40401c..9c6e7fa3 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 19:54:25 $ - Version: $Revision: 1.3 $ + Date: $Date: 2007/05/23 14:18:04 $ + Version: $Revision: 1.14 $ 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 @@ -30,6 +31,10 @@ extern "C" { #include "gdcmjpeg/8/jerror.h" } +#if defined(__BORLANDC__) + #include // for memcpy +#endif + #include "gdcmJPEGFragment.h" #include #include @@ -37,10 +42,108 @@ 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_NAME_SPACE::binary_write(*fp, group); + GDCM_NAME_SPACE::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_NAME_SPACE::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_NAME_SPACE::binary_write(*fp, group); + GDCM_NAME_SPACE::binary_write(*fp, elem); + // Item Length + uint32_t item_length = 0x0000; + GDCM_NAME_SPACE::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_NAME_SPACE::binary_write(*fp, group); + GDCM_NAME_SPACE::binary_write(*fp, elem); + // Item Length + uint32_t item_length = numFrag*4; // sizeof(uint32_t) + GDCM_NAME_SPACE::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); } + uint32_t offset = jp.first - first.first; + GDCM_NAME_SPACE::binary_write(*fp, offset); + //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 ); + uint32_t length = jp.second; + GDCM_NAME_SPACE::binary_write(*fp, length ); + //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_NAME_SPACE::binary_write(*fp, group); + GDCM_NAME_SPACE::binary_write(*fp, elem); + + uint32_t length = 0x0; + GDCM_NAME_SPACE::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 +151,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 +162,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 +177,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 +201,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: */ @@ -133,60 +238,147 @@ bool CreateOneFrame (std::ostream *fp, void *input_buffer, int fragment_size, */ if (sample_pixel == 3) { + assert( sample_pixel == 1 ); row_stride = image_width * 3;/* JSAMPLEs per row in image_buffer */ } else { 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; + + if( ((end-beg) % 2) ) + { + fp->put( '\0' ); + jp.second += 1; + } + assert( !(jp.second % 2) ); + std::cerr << "DIFF: " << i <<" -> " << jp.second << 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[]) { if( argc < 2) return 1; - std::string filename = argv[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 *f = new gdcm::File(); - f->SetLoadMode ( gdcm::LD_ALL ); // Load everything + GDCM_NAME_SPACE::File *f = GDCM_NAME_SPACE::File::New(); + f->SetLoadMode ( GDCM_NAME_SPACE::LD_ALL ); // Load everything f->SetFileName( filename ); f->Load(); - gdcm::FileHelper *tested = new gdcm::FileHelper( f ); + GDCM_NAME_SPACE::FileHelper *tested = GDCM_NAME_SPACE::FileHelper::New( f ); 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(); @@ -199,7 +391,28 @@ 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" @@ -211,6 +424,14 @@ int main(int argc, char *argv[]) std::streambuf* sb = of->rdbuf(); (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; + } @@ -218,46 +439,46 @@ int main(int argc, char *argv[]) // Step 1 : Create the header of the image - gdcm::File *fileToBuild = new gdcm::File(); + GDCM_NAME_SPACE::File *fileToBuild = GDCM_NAME_SPACE::File::New(); std::ostringstream str; // Set the image size str.str(""); str << xsize; - fileToBuild->InsertEntryString(str.str(),0x0028,0x0011); // Columns + fileToBuild->InsertEntryString(str.str(),0x0028,0x0011,"US"); // Columns str.str(""); str << ysize; - fileToBuild->InsertEntryString(str.str(),0x0028,0x0010); // Rows + fileToBuild->InsertEntryString(str.str(),0x0028,0x0010,"US"); // Rows - //if(img.sizeZ>1) - //{ - // str.str(""); - // str << img.sizeZ; - // fileToBuild->InsertEntryString(str.str(),0x0028,0x0008); // Number of Frames - //} + if(zsize>1) + { + str.str(""); + str << zsize; + fileToBuild->InsertEntryString(str.str(),0x0028,0x0008,"IS"); // Number of Frames + } // Set the pixel type str.str(""); str << 8; //img.componentSize; - fileToBuild->InsertEntryString(str.str(),0x0028,0x0100); // Bits Allocated + fileToBuild->InsertEntryString(str.str(),0x0028,0x0100,"US"); // Bits Allocated str.str(""); str << 8; //img.componentUse; - fileToBuild->InsertEntryString(str.str(),0x0028,0x0101); // Bits Stored + fileToBuild->InsertEntryString(str.str(),0x0028,0x0101,"US"); // Bits Stored str.str(""); str << 7; //( img.componentSize - 1 ); - fileToBuild->InsertEntryString(str.str(),0x0028,0x0102); // High Bit + fileToBuild->InsertEntryString(str.str(),0x0028,0x0102,"US"); // High Bit // Set the pixel representation str.str(""); str << 0; //img.sign; - fileToBuild->InsertEntryString(str.str(),0x0028,0x0103); // Pixel Representation + fileToBuild->InsertEntryString(str.str(),0x0028,0x0103,"US"); // Pixel Representation // Set the samples per pixel str.str(""); str << samplesPerPixel; //img.components; - fileToBuild->InsertEntryString(str.str(),0x0028,0x0002); // Samples per Pixel + fileToBuild->InsertEntryString(str.str(),0x0028,0x0002,"US"); // Samples per Pixel // Step 2 : Create the output image // std::cout << "2..."; @@ -265,11 +486,11 @@ 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]; - gdcm::FileHelper *fileH = new gdcm::FileHelper(fileToBuild); + GDCM_NAME_SPACE::FileHelper *fileH = GDCM_NAME_SPACE::FileHelper::New(fileToBuild); //fileH->SetImageData(imageData,size); assert( size == testedDataSize ); size = of->str().size(); @@ -281,8 +502,7 @@ int main(int argc, char *argv[]) //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; } @@ -290,17 +510,18 @@ int main(int argc, char *argv[]) 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); - std::cerr << "JPEG marker is: " << imageData[6] << imageData[7] << - imageData[8] << imageData[9] << std::endl; + //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; - delete tested; - delete fileToBuild; - delete fileH; + f->Delete(); + tested->Delete(); + fileToBuild->Delete(); + fileH->Delete(); return 0; }