X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmPixelReadConvert.cxx;h=264f30bc7343543efd45a93140b556eb6f4dc4e0;hb=4d688a4874380bbde4dff31775ab4d56d49f7f9e;hp=89ae9952792082dbe313ef45d1eb4be3b4709407;hpb=97d652e4a54b414d3dacead9d31e9597e6f516e5;p=gdcm.git diff --git a/src/gdcmPixelReadConvert.cxx b/src/gdcmPixelReadConvert.cxx index 89ae9952..264f30bc 100644 --- a/src/gdcmPixelReadConvert.cxx +++ b/src/gdcmPixelReadConvert.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmPixelReadConvert.cxx,v $ Language: C++ - Date: $Date: 2005/02/17 10:53:21 $ - Version: $Revision: 1.52 $ + Date: $Date: 2005/06/17 12:35:00 $ + Version: $Revision: 1.67 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -16,11 +16,11 @@ =========================================================================*/ +#include "gdcmPixelReadConvert.h" #include "gdcmDebug.h" #include "gdcmFile.h" #include "gdcmGlobal.h" #include "gdcmTS.h" -#include "gdcmPixelReadConvert.h" #include "gdcmDocEntry.h" #include "gdcmRLEFramesInfo.h" #include "gdcmJPEGFragmentsInfo.h" @@ -30,6 +30,10 @@ namespace gdcm { + +//bool ReadMPEGFile (std::ifstream *fp, void *image_buffer, size_t lenght); +bool gdcm_read_JPEG2000_file (void* raw, + char *inputdata, size_t inputlength); //----------------------------------------------------------------------------- #define str2num(str, typeNum) *((typeNum *)(str)) @@ -115,6 +119,7 @@ void PixelReadConvert::GrabInformationsFromFile( File *file ) || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian; + IsMPEG = Global::GetTS()->IsMPEG(ts); IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts); IsJPEGLS = Global::GetTS()->IsJPEGLS(ts); IsJPEGLossy = Global::GetTS()->IsJPEGLossy(ts); @@ -250,6 +255,13 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) return false; } } + else if ( IsMPEG ) + { + //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" ); + //return false; + //ReadMPEGFile(fp, Raw, PixelDataLength); // fp has already been seek to start of mpeg + return true; + } else { // Default case concerns JPEG family @@ -287,7 +299,7 @@ void PixelReadConvert::Squeeze() } /** - * \brief Build the RGB image from the Raw imagage and the LUTs. + * \brief Build the RGB image from the Raw image and the LUTs. */ bool PixelReadConvert::BuildRGBImage() { @@ -312,14 +324,32 @@ bool PixelReadConvert::BuildRGBImage() // Build RGB Pixels AllocateRGB(); - uint8_t *localRGB = RGB; - for (size_t i = 0; i < RawSize; ++i ) + + int j; + if( BitsAllocated <= 8) { - int j = Raw[i] * 4; - *localRGB++ = LutRGBA[j]; - *localRGB++ = LutRGBA[j+1]; - *localRGB++ = LutRGBA[j+2]; - } + uint8_t *localRGB = RGB; + for (size_t i = 0; i < RawSize; ++i ) + { + j = Raw[i] * 4; + *localRGB++ = LutRGBA[j]; + *localRGB++ = LutRGBA[j+1]; + *localRGB++ = LutRGBA[j+2]; + } + } + + else // deal with 16 bits pixels and 16 bits Palette color + { + uint16_t *localRGB = (uint16_t *)RGB; + for (size_t i = 0; i < RawSize/2; ++i ) + { + j = ((uint16_t *)Raw)[i] * 4; + *localRGB++ = ((uint16_t *)LutRGBA)[j]; + *localRGB++ = ((uint16_t *)LutRGBA)[j+1]; + *localRGB++ = ((uint16_t *)LutRGBA)[j+2]; + } + } + return true; } @@ -386,27 +416,96 @@ bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream *fp ) { if ( IsJPEG2000 ) { - gdcmWarningMacro( "Sorry, JPEG2000 not yet taken into account" ); - fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg); -// if ( ! gdcm_read_JPEG2000_file( fp,Raw ) ) - return false; + // make sure this is the right JPEG compression + assert( !IsJPEGLossless || !IsJPEGLossy || !IsJPEGLS ); + // FIXME this is really ugly but it seems I have to load the complete + // jpeg2000 stream to use jasper: + // I don't think we'll ever be able to deal with multiple fragments properly + + unsigned long inputlength = 0; + JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment(); + while( jpegfrag ) + { + inputlength += jpegfrag->GetLength(); + jpegfrag = JPEGInfo->GetNextFragment(); + } + gdcmAssertMacro( inputlength != 0); + uint8_t *inputdata = new uint8_t[inputlength]; + char *pinputdata = (char*)inputdata; + jpegfrag = JPEGInfo->GetFirstFragment(); + while( jpegfrag ) + { + fp->seekg( jpegfrag->GetOffset(), std::ios::beg); + fp->read(pinputdata, jpegfrag->GetLength()); + pinputdata += jpegfrag->GetLength(); + jpegfrag = JPEGInfo->GetNextFragment(); + } + // Warning the inputdata buffer is delete in the function + if ( ! gdcm_read_JPEG2000_file( Raw, + (char*)inputdata, inputlength ) ) + { + return true; + } + // wow what happen, must be an error + return false; } - - if ( IsJPEGLS ) + else if ( IsJPEGLS ) { + // make sure this is the right JPEG compression + assert( !IsJPEGLossless || !IsJPEGLossy || !IsJPEG2000 ); + // WARNING : JPEG-LS is NOT the 'classical' Jpeg Lossless : + // [JPEG-LS is the basis for new lossless/near-lossless compression + // standard for continuous-tone images intended for JPEG2000. The standard + // is based on the LOCO-I algorithm (LOw COmplexity LOssless COmpression + // for Images) developed at Hewlett-Packard Laboratories] + // + // see http://datacompression.info/JPEGLS.shtml + // +#if 0 + std::cerr << "count:" << JPEGInfo->GetFragmentCount() << std::endl; + unsigned long inputlength = 0; + JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment(); + while( jpegfrag ) + { + inputlength += jpegfrag->GetLength(); + jpegfrag = JPEGInfo->GetNextFragment(); + } + gdcmAssertMacro( inputlength != 0); + uint8_t *inputdata = new uint8_t[inputlength]; + char *pinputdata = (char*)inputdata; + jpegfrag = JPEGInfo->GetFirstFragment(); + while( jpegfrag ) + { + fp->seekg( jpegfrag->GetOffset(), std::ios::beg); + fp->read(pinputdata, jpegfrag->GetLength()); + pinputdata += jpegfrag->GetLength(); + jpegfrag = JPEGInfo->GetNextFragment(); + } + + //fp->read((char*)Raw, PixelDataLength); + + std::ofstream out("/tmp/jpegls.jpg"); + out.write((char*)inputdata, inputlength); + out.close(); + delete[] inputdata; +#endif + gdcmWarningMacro( "Sorry, JPEG-LS not yet taken into account" ); fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg); // if ( ! gdcm_read_JPEGLS_file( fp,Raw ) ) return false; } - - // else ?? - // Precompute the offset localRaw will be shifted with - int length = XSize * YSize * SamplesPerPixel; - int numberBytes = BitsAllocated / 8; - - JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length ); - return true; + else + { + // make sure this is the right JPEG compression + assert( !IsJPEGLS || !IsJPEG2000 ); + // Precompute the offset localRaw will be shifted with + int length = XSize * YSize * SamplesPerPixel; + int numberBytes = BitsAllocated / 8; + + JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length ); + return true; + } } /** @@ -442,6 +541,7 @@ void PixelReadConvert::BuildLUTRGBA() || LutGreenDescriptor == GDCM_UNFOUND || LutBlueDescriptor == GDCM_UNFOUND ) { + gdcmWarningMacro( "(At least) a LUT Descriptor is missing" ); return; } @@ -450,20 +550,22 @@ void PixelReadConvert::BuildLUTRGBA() int lengthR; // Red LUT length in Bytes int debR; // Subscript of the first Lut Value int nbitsR; // Lut item size (in Bits) - int nbRead = sscanf( LutRedDescriptor.c_str(), + int nbRead; // nb of items in LUT descriptor (must be = 3) + + nbRead = sscanf( LutRedDescriptor.c_str(), "%d\\%d\\%d", &lengthR, &debR, &nbitsR ); if( nbRead != 3 ) { gdcmWarningMacro( "Wrong Red LUT descriptor" ); - } - + } int lengthG; // Green LUT length in Bytes int debG; // Subscript of the first Lut Value int nbitsG; // Lut item size (in Bits) + nbRead = sscanf( LutGreenDescriptor.c_str(), "%d\\%d\\%d", - &lengthG, &debG, &nbitsG ); + &lengthG, &debG, &nbitsG ); if( nbRead != 3 ) { gdcmWarningMacro( "Wrong Green LUT descriptor" ); @@ -479,67 +581,153 @@ void PixelReadConvert::BuildLUTRGBA() { gdcmWarningMacro( "Wrong Blue LUT descriptor" ); } + + gdcmWarningMacro(" lengthR " << lengthR << " debR " + << debR << " nbitsR " << nbitsR); + gdcmWarningMacro(" lengthG " << lengthG << " debG " + << debG << " nbitsG " << nbitsG); + gdcmWarningMacro(" lengthB " << lengthB << " debB " + << debB << " nbitsB " << nbitsB); + + if ( !lengthR ) // if = 2^16, this shall be 0 see : CP-143 + lengthR=65536; + if( !lengthG ) // if = 2^16, this shall be 0 + lengthG=65536; + if ( !lengthB ) // if = 2^16, this shall be 0 + lengthB=65536; //////////////////////////////////////////////////////// + if ( ( ! LutRedData ) || ( ! LutGreenData ) || ( ! LutBlueData ) ) { + gdcmWarningMacro( "(At least) a LUT is missing" ); return; } - //////////////////////////////////////////////// - // forge the 4 * 8 Bits Red/Green/Blue/Alpha LUT - LutRGBA = new uint8_t[ 1024 ]; // 256 * 4 (R, G, B, Alpha) - if ( !LutRGBA ) - return; - - memset( LutRGBA, 0, 1024 ); - - int mult; - if ( ( nbitsR == 16 ) && ( BitsAllocated == 8 ) ) - { - // when LUT item size is different than pixel size - mult = 2; // high byte must be = low byte - } - else + // ------------------------------------------------------------- + + if ( BitsAllocated <= 8) { - // See PS 3.3-2003 C.11.1.1.2 p 619 - mult = 1; - } + // forge the 4 * 8 Bits Red/Green/Blue/Alpha LUT + LutRGBA = new uint8_t[ 1024 ]; // 256 * 4 (R, G, B, Alpha) + if ( !LutRGBA ) + return; + LutItemNumber = 256; + LutItemSize = 8; + memset( LutRGBA, 0, 1024 ); - // if we get a black image, let's just remove the '+1' - // from 'i*mult+1' and check again - // if it works, we shall have to check the 3 Palettes - // to see which byte is ==0 (first one, or second one) - // and fix the code - // We give up the checking to avoid some (useless ?) overhead - // (optimistic asumption) - int i; - uint8_t *a = LutRGBA + 0; - for( i=0; i < lengthR; ++i ) - { - *a = LutRedData[i*mult+1]; - a += 4; - } + int mult; + if ( ( nbitsR == 16 ) && ( BitsAllocated == 8 ) ) + { + // when LUT item size is different than pixel size + mult = 2; // high byte must be = low byte + } + else + { + // See PS 3.3-2003 C.11.1.1.2 p 619 + mult = 1; + } - a = LutRGBA + 1; - for( i=0; i < lengthG; ++i) - { - *a = LutGreenData[i*mult+1]; - a += 4; - } + // if we get a black image, let's just remove the '+1' + // from 'i*mult+1' and check again + // if it works, we shall have to check the 3 Palettes + // to see which byte is ==0 (first one, or second one) + // and fix the code + // We give up the checking to avoid some (useless ?) overhead + // (optimistic asumption) + int i; + uint8_t *a; + + //take "Subscript of the first Lut Value" (debR,debG,debB) into account! + + a = LutRGBA + 0 + debR; + for( i=0; i < lengthR; ++i ) + { + *a = LutRedData[i*mult+1]; + a += 4; + } - a = LutRGBA + 2; - for(i=0; i < lengthB; ++i) - { - *a = LutBlueData[i*mult+1]; - a += 4; - } + a = LutRGBA + 1 + debG; + for( i=0; i < lengthG; ++i) + { + *a = LutGreenData[i*mult+1]; + a += 4; + } + + a = LutRGBA + 2 + debB; + for(i=0; i < lengthB; ++i) + { + *a = LutBlueData[i*mult+1]; + a += 4; + } - a = LutRGBA + 3; - for(i=0; i < 256; ++i) + a = LutRGBA + 3 ; + for(i=0; i < 256; ++i) + { + *a = 1; // Alpha component + a += 4; + } + } + else { - *a = 1; // Alpha component - a += 4; + // Probabely the same stuff is to be done for 16 Bits Pixels + // with 65536 entries LUT ?!? + // Still looking for accurate info on the web :-( + + gdcmWarningMacro( "Sorry Palette Color Lookup Tables not yet dealt with" + << " for 16 Bits Per Pixel images" ); + + // forge the 4 * 16 Bits Red/Green/Blue/Alpha LUT + + LutRGBA = (uint8_t *)new uint16_t[ 65536*4 ]; // 2^16 * 4 (R, G, B, Alpha) + if ( !LutRGBA ) + return; + memset( LutRGBA, 0, 65536*4*2 ); // 16 bits = 2 bytes ;-) + + LutItemNumber = 65536; + LutItemSize = 16; + + int i; + uint16_t *a16; + + //take "Subscript of the first Lut Value" (debR,debG,debB) into account! + + a16 = (uint16_t*)LutRGBA + 0 + debR; + for( i=0; i < lengthR; ++i ) + { + *a16 = ((uint16_t*)LutRedData)[i]; + a16 += 4; + } + + a16 = (uint16_t*)LutRGBA + 1 + debG; + for( i=0; i < lengthG; ++i) + { + *a16 = ((uint16_t*)LutGreenData)[i]; + a16 += 4; + } + + a16 = (uint16_t*)LutRGBA + 2 + debB; + for(i=0; i < lengthB; ++i) + { + *a16 = ((uint16_t*)LutBlueData)[i]; + a16 += 4; + } + + a16 = (uint16_t*)LutRGBA + 3 ; + for(i=0; i < 65536; ++i) + { + *a16 = 1; // Alpha component + a16 += 4; + } +/* + a16=(uint16_t*)LutRGBA; + for (int j=0;j<65536;j++) + { + std::cout << *a16 << " " << *(a16+1) << " " + << *(a16+2) << " " << *(a16+3) << std::endl; + a16+=4; + } +*/ } } @@ -690,8 +878,8 @@ void PixelReadConvert::ConvertFixGreyLevels() { if ( BitsAllocated == 8 ) { - int8_t smask8 = 255; - int8_t *deb = (int8_t *)Raw; + uint8_t smask8 = 255; + uint8_t *deb = (uint8_t *)Raw; for (i=0; i>15; + G = (G+16384)>>15; + B = (B+16384)>>15; - if (R < 0.0) R = 0.0; - if (G < 0.0) G = 0.0; - if (B < 0.0) B = 0.0; - if (R > 255.0) R = 255.0; - if (G > 255.0) G = 255.0; - if (B > 255.0) B = 255.0; + if (R < 0) R = 0; + if (G < 0) G = 0; + if (B < 0) B = 0; + if (R > 255) R = 255; + if (G > 255) G = 255; + if (B > 255) B = 255; *(localRaw++) = (uint8_t)R; *(localRaw++) = (uint8_t)G; @@ -865,7 +1067,7 @@ void PixelReadConvert::ConvertHandleColor() // - "Planar Configuration" = 0, // - "Photometric Interpretation" = "PALETTE COLOR". // Hence gdcm will use the folowing "heuristic" in order to be tolerant - // towards Dicom-non-conformance files: + // towards Dicom-non-conformant files: // << whatever the "Planar Configuration" value might be, a // "Photometric Interpretation" set to "PALETTE COLOR" forces // a LUT intervention >> @@ -924,7 +1126,7 @@ void PixelReadConvert::ComputeRawAndRGBSizes() * SamplesPerPixel; if ( HasLUT ) { - RGBSize = 3 * RawSize; + RGBSize = 3 * RawSize; // works for 8 and 16 bits per Pixel } else {