X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmPixelReadConvert.cxx;h=b75ecb9a8308707b63049a81299e0776ebcda228;hb=df5a9566b70f78134a66ce582efe40d07b30ba3c;hp=071e72e372ef40b35df061c25dc6262341cb331a;hpb=ccdf70de6047db491a0e1b13c643063a9fda346a;p=gdcm.git diff --git a/src/gdcmPixelReadConvert.cxx b/src/gdcmPixelReadConvert.cxx index 071e72e3..b75ecb9a 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/10/25 18:14:49 $ - Version: $Revision: 1.88 $ + Date: $Date: 2007/09/05 08:22:57 $ + Version: $Revision: 1.122 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -28,10 +28,14 @@ #include #include //for sscanf -namespace gdcm +#if defined(__BORLANDC__) + #include // for memset +#endif + +namespace GDCM_NAME_SPACE { -//bool ReadMPEGFile (std::ifstream *fp, void *image_buffer, size_t lenght); +//bool ReadMPEGFile (std::ifstream *fp, char *inputdata, size_t lenght); bool gdcm_read_JPEG2000_file (void* raw, char *inputdata, size_t inputlength); //----------------------------------------------------------------------------- @@ -81,8 +85,10 @@ bool PixelReadConvert::IsRawRGB() /** * \brief Gets various usefull informations from the file header * @param file gdcm::File pointer + * @param fileHelper gdcm::FileHelper pointer */ -void PixelReadConvert::GrabInformationsFromFile( File *file ) +void PixelReadConvert::GrabInformationsFromFile( File *file, + FileHelper *fileHelper ) { // Number of Bits Allocated for storing a Pixel is defaulted to 16 // when absent from the file. @@ -91,6 +97,10 @@ void PixelReadConvert::GrabInformationsFromFile( File *file ) { BitsAllocated = 16; } + else if ( BitsAllocated > 8 && BitsAllocated < 16 && BitsAllocated != 12 ) + { + BitsAllocated = 16; + } // Number of "Bits Stored", defaulted to number of "Bits Allocated" // when absent from the file. @@ -110,33 +120,62 @@ void PixelReadConvert::GrabInformationsFromFile( File *file ) XSize = file->GetXSize(); YSize = file->GetYSize(); ZSize = file->GetZSize(); + TSize = file->GetTSize(); SamplesPerPixel = file->GetSamplesPerPixel(); //PixelSize = file->GetPixelSize(); Useless PixelSign = file->IsSignedPixelData(); SwapCode = file->GetSwapCode(); - std::string ts = file->GetTransferSyntax(); - if ( ts == GDCM_UNKNOWN ) - { - gdcmErrorMacro( "Could someone tell me how in the world could this happen !" ); - abort(); // DO NOT REMOVE. WE SHOULD NEVER READ SUCH IMAGE EVER (only gdcm can write such broekn dicom file) - } - IsRaw = - ( ! file->IsDicomV3() ) - || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian - || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRBigEndianPrivateGE - || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRLittleEndian - || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian - || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian; - - IsPrivateGETransferSyntax = + + IsPrivateGETransferSyntax = IsMPEG + = IsJPEG2000 = IsJPEGLS = IsJPEGLossy + = IsJPEGLossless = IsRLELossless + = false; + + if (! file->IsDicomV3() ) // Should be ACR-NEMA file + { + IsRaw = true; + } + else + { + std::string ts = file->GetTransferSyntax(); + + IsRaw = false; + while (true) // shorter to write than 'if elseif elseif elseif' ... + { + // mind the order : check the most usual first. + if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRLittleEndian) break; + if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian ) break; + if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian) break; + if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRBigEndianPrivateGE) break; + // DeflatedExplicitVRLittleEndian syntax means the whole Dataset (Header + Pixels) is compressed ! + // Not dealt with ! (Parser hangs) + //if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian) break; + break; + } + // cache whether this is a strange GE transfer syntax (which uses + // a little endian transfer syntax for the header and a big endian + // transfer syntax for the pixel data). + IsPrivateGETransferSyntax = ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRBigEndianPrivateGE ); - IsMPEG = Global::GetTS()->IsMPEG(ts); - IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts); - IsJPEGLS = Global::GetTS()->IsJPEGLS(ts); - IsJPEGLossy = Global::GetTS()->IsJPEGLossy(ts); - IsJPEGLossless = Global::GetTS()->IsJPEGLossless(ts); - IsRLELossless = Global::GetTS()->IsRLELossless(ts); + IsMPEG = IsJPEG2000 = IsJPEGLS = IsJPEGLossy = IsJPEGLossless = IsRLELossless = false; + if (!IsRaw) + { + while(true) + { + // mind the order : check the most usual first. + if( IsJPEGLossy = Global::GetTS()->IsJPEGLossy(ts) ) break; + if( IsJPEGLossless = Global::GetTS()->IsJPEGLossless(ts) ) break; + if( IsRLELossless = Global::GetTS()->IsRLELossless(ts) ) break; + if( IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts) ) break; + if( IsMPEG = Global::GetTS()->IsMPEG(ts) ) break; + if( IsJPEGLS = Global::GetTS()->IsJPEGLS(ts) ) break; + // DeflatedExplicitVRLittleEndian is considered as 'Unexpected' (we don't know yet how to process !) + gdcmWarningMacro("Unexpected Transfer Syntax :[" << ts << "]"); + break; + } + } + } PixelOffset = file->GetPixelOffset(); PixelDataLength = file->GetPixelAreaLength(); @@ -160,7 +199,7 @@ void PixelReadConvert::GrabInformationsFromFile( File *file ) LutGreenDescriptor = file->GetEntryString( 0x0028, 0x1102 ); LutBlueDescriptor = file->GetEntryString( 0x0028, 0x1103 ); - // The following comment is probabely meaningless, since LUT are *always* + // FIXME : The following comment is probabely meaningless, since LUT are *always* // loaded at parsing time, whatever their length is. // Depending on the value of Document::MAX_SIZE_LOAD_ELEMENT_VALUE @@ -202,7 +241,7 @@ void PixelReadConvert::GrabInformationsFromFile( File *file ) } } FileInternal = file; - + FH = fileHelper; ComputeRawAndRGBSizes(); } @@ -232,8 +271,19 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) AllocateRaw(); ////////////////////////////////////////////////// + + CallStartMethod(); // for progress bar + unsigned int count = 0; + unsigned int frameSize; + unsigned int bitsAllocated = BitsAllocated; + //if(bitsAllocated == 12) + if(bitsAllocated > 8 && bitsAllocated < 16) + bitsAllocated = 16; + frameSize = XSize*YSize*SamplesPerPixel*bitsAllocated/8; + //// Second stage: read from disk and decompress. - if ( BitsAllocated == 12 ) + + if ( BitsAllocated == 12 ) // We suppose 'BitsAllocated' = 12 only exist for uncompressed files { ReadAndDecompress12BitsTo16Bits( fp); } @@ -246,16 +296,33 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) if ( PixelDataLength != RawSize ) { gdcmWarningMacro( "Mismatch between PixelReadConvert : " - << PixelDataLength << " and RawSize : " << RawSize ); + << PixelDataLength << " and RawSize : " << RawSize ); } + + //todo : is it the right patch? + char *raw = (char*)Raw; + uint32_t remainingLength; + unsigned int i; + unsigned int lengthToRead; + if ( PixelDataLength > RawSize ) - { - fp->read( (char*)Raw, RawSize); - } + lengthToRead = RawSize; else + lengthToRead = PixelDataLength; + + // perform a frame by frame reading + remainingLength = lengthToRead; + unsigned int nbFrames = lengthToRead / frameSize; + for (i=0;iread( (char*)Raw, PixelDataLength); + Progress = (float)(count+1)/(float)nbFrames; + fp->read( raw, frameSize); + raw += frameSize; + remainingLength -= frameSize; + count++; } + if (remainingLength !=0 ) + fp->read( raw, remainingLength); if ( fp->fail() || fp->eof()) { @@ -266,7 +333,7 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) else if ( IsRLELossless ) { if ( ! RLEInfo->DecompressRLEFile - ( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) ) + ( fp, Raw, XSize, YSize, ZSize, TSize, BitsAllocated ) ) { gdcmWarningMacro( "RLE decompressor failed." ); return false; @@ -277,7 +344,7 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" ); //return false; // fp has already been seek to start of mpeg - //ReadMPEGFile(fp, Raw, PixelDataLength); + //ReadMPEGFile(fp, (char*)Raw, PixelDataLength); return true; } else @@ -285,7 +352,8 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) // Default case concerns JPEG family if ( ! ReadAndDecompressJPEGFile( fp ) ) { - gdcmWarningMacro( "JPEG decompressor failed." ); + gdcmWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()" + << " method ) failed." ); return false; } } @@ -342,7 +410,7 @@ bool PixelReadConvert::BuildRGBImage() return false; } - gdcmWarningMacro( "--> BuildRGBImage" ); + gdcmDebugMacro( "--> BuildRGBImage" ); // Build RGB Pixels AllocateRGB(); @@ -387,7 +455,8 @@ bool PixelReadConvert::BuildRGBImage() void PixelReadConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream *fp ) throw ( FormatError ) { - int nbPixels = XSize * YSize; + /// \todo Fix the 3D, 4D pb + int nbPixels = XSize * YSize * TSize; uint16_t *localDecompres = (uint16_t*)Raw; for( int p = 0; p < nbPixels; p += 2 ) @@ -444,32 +513,60 @@ bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream *fp ) // 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 ) - { + if( ZSize == 1 ) + { + 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 ) - { + } + 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 ) ) - { + } + // Warning the inputdata buffer is deleted in the function + if ( gdcm_read_JPEG2000_file( Raw, + (char*)inputdata, inputlength ) ) + { return true; - } - // wow what happen, must be an error - return false; + } + // wow what happen, must be an error + gdcmWarningMacro( "gdcm_read_JPEG2000_file() failed "); + return false; + } + else + { + if( (unsigned int)ZSize != JPEGInfo->GetFragmentCount() ) + { + gdcmErrorMacro( "Sorry GDCM does not handle this type of fragments" ); + return false; + } + // Hopefully every dicom fragment is *exactly* the j2k stream + JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment(); + char *praw = (char*)Raw; + while( jpegfrag ) + { + unsigned long inputlength = jpegfrag->GetLength(); + char *inputdata = new char[inputlength]; + fp->seekg( jpegfrag->GetOffset(), std::ios::beg); + fp->read(inputdata, jpegfrag->GetLength()); + // Warning the inputdata buffer is deleted in the function + gdcm_read_JPEG2000_file( praw, + inputdata, inputlength) ; + praw += XSize*YSize*SamplesPerPixel*(BitsAllocated/8); + jpegfrag = JPEGInfo->GetNextFragment(); + } + return true; + } } else if ( IsJPEGLS ) { @@ -522,10 +619,16 @@ bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream *fp ) // 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 length = XSize * YSize * ZSize * SamplesPerPixel; int numberBytes = BitsAllocated / 8; - JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length ); + // to avoid major troubles when BitsStored == 8 && BitsAllocated==16 ! + int dummy; + if (BitsStored == 8 && BitsAllocated==16) + dummy = 16; + else + dummy = BitsStored; + JPEGInfo->DecompressFromFile(fp, Raw, dummy, numberBytes, length ); return true; } } @@ -536,7 +639,7 @@ bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream *fp ) * and * - (0028,1101),(0028,1102),(0028,1102) * xxx Palette Color Lookup Table Descriptor are found - * and + * and * - (0028,1201),(0028,1202),(0028,1202) * xxx Palette Color Lookup Table Data - are found * \warning does NOT deal with : @@ -612,12 +715,12 @@ 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); + gdcmDebugMacro(" lengthR " << lengthR << " debR " + << debR << " nbitsR " << nbitsR); + gdcmDebugMacro(" lengthG " << lengthG << " debG " + << debG << " nbitsG " << nbitsG); + gdcmDebugMacro(" lengthB " << lengthB << " debB " + << debB << " nbitsB " << nbitsB); if ( !lengthR ) // if = 2^16, this shall be 0 see : CP-143 lengthR=65536; @@ -773,8 +876,7 @@ void PixelReadConvert::BuildLUTRGBA() void PixelReadConvert::ConvertSwapZone() { unsigned int i; - uint16_t localSwapCode = SwapCode; - + // If this file is 'ImplicitVR BigEndian PrivateGE Transfer Syntax', // then the header is in little endian format and the pixel data is in // big endian format. When reading the header, GDCM has already established @@ -801,28 +903,27 @@ void PixelReadConvert::ConvertSwapZone() // Therefore, in either case, if the file is in // 'ImplicitVR BigEndian PrivateGE Transfer Syntax', then GDCM needs to switch // the byte swapping code when entering the pixel data. - -/* //Let me check something. - //I wait for the Dashboard ! + + int tempSwapCode = SwapCode; if ( IsPrivateGETransferSyntax ) { + gdcmWarningMacro(" IsPrivateGETransferSyntax found; turn the SwapCode"); // PrivateGETransferSyntax only exists for 'true' Dicom images // we assume there is no 'exotic' 32 bits endianess! - switch (localSwapCode) + if (SwapCode == 1234) { - case 1234: - localSwapCode = 4321; - break; - case 4321: - localSwapCode = 1234; - break; - } + tempSwapCode = 4321; + } + else if (SwapCode == 4321) + { + tempSwapCode = 1234; + } } -*/ + if ( BitsAllocated == 16 ) { uint16_t *im16 = (uint16_t*)Raw; - switch( localSwapCode ) + switch( tempSwapCode ) { case 1234: break; @@ -835,7 +936,8 @@ void PixelReadConvert::ConvertSwapZone() } break; default: - gdcmWarningMacro("SwapCode value (16 bits) not allowed."); + gdcmWarningMacro("SwapCode value (16 bits) not allowed." + << tempSwapCode); } } else if ( BitsAllocated == 32 ) @@ -844,7 +946,7 @@ void PixelReadConvert::ConvertSwapZone() uint16_t high; uint16_t low; uint32_t *im32 = (uint32_t*)Raw; - switch ( localSwapCode ) + switch ( tempSwapCode ) { case 1234: break; @@ -880,7 +982,7 @@ void PixelReadConvert::ConvertSwapZone() } break; default: - gdcmWarningMacro("SwapCode value (32 bits) not allowed." ); + gdcmWarningMacro("SwapCode value (32 bits) not allowed." << tempSwapCode ); } } } @@ -996,27 +1098,38 @@ bool PixelReadConvert::ConvertReArrangeBits() throw ( FormatError ) { // pmask : to mask the 'unused bits' (may contain overlays) uint16_t pmask = 0xffff; - pmask = pmask >> ( BitsAllocated - BitsStored ); + + // It's up to the user to decide if he wants to ignore overlays (if any), + // not to gdcm, without asking. + // default is NOT TO LOAD, in order not to confuse ITK users (and others!). + + if ( !FH->GetKeepOverlays() ) // mask spurious bits ! (overlay are NOT loaded!) + { + pmask = pmask >> ( BitsAllocated - BitsStored ); + } + // else : it's up to the user to manage the 'pixels + overlays' he just loaded! uint16_t *deb = (uint16_t*)Raw; if ( !PixelSign ) // Pixels are unsigned { for(int i = 0; i> (BitsStored - HighBitPosition - 1)) & pmask; deb++; } } else // Pixels are signed { + // Hope there is never ACR-NEMA-like overlays within signed pixels (?!?) + // smask : to check the 'sign' when BitsStored != BitsAllocated uint16_t smask = 0x0001; smask = smask << ( 16 - (BitsAllocated - BitsStored + 1) ); // nmask : to propagate sign bit on negative values int16_t nmask = (int16_t)0x8000; nmask = nmask >> ( BitsAllocated - BitsStored - 1 ); - + for(int i = 0; i> (BitsStored - HighBitPosition - 1); @@ -1118,9 +1231,9 @@ void PixelReadConvert::ConvertYcBcRPlanesToRGBPixels() // except for the few patches of color on the image. // On such images, RLE achieves a compression ratio that is much better // than the compression ratio on an equivalent RGB image. - + gdcmWarningMacro("--> ConvertYcBcRPlanesToRGBPixels"); - + uint8_t *localRaw = Raw; uint8_t *copyRaw = new uint8_t[ RawSize ]; memmove( copyRaw, localRaw, RawSize ); @@ -1130,7 +1243,9 @@ void PixelReadConvert::ConvertYcBcRPlanesToRGBPixels() // ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf // and be *very* affraid // - int l = XSize * YSize; + + /// \todo : find an example to see how 3rd dim and 4th dim work together + int l = XSize * YSize * TSize; int nbFrames = ZSize; uint8_t *a = copyRaw + 0; @@ -1219,13 +1334,13 @@ void PixelReadConvert::ConvertHandleColor() // - [Planar 1] AND [Photo C] handled with ConvertYcBcRPlanesToRGBPixels() // - [Planar 2] OR [Photo D] requires LUT intervention. - gdcmWarningMacro("--> ConvertHandleColor" - << "Planar Configuration " << PlanarConfiguration ); + gdcmDebugMacro("--> ConvertHandleColor " + << "Planar Configuration " << PlanarConfiguration ); if ( ! IsRawRGB() ) { // [Planar 2] OR [Photo D]: LUT intervention done outside - gdcmWarningMacro("--> RawRGB : LUT intervention done outside"); + gdcmDebugMacro("--> RawRGB : LUT intervention done outside"); return; } @@ -1234,13 +1349,13 @@ void PixelReadConvert::ConvertHandleColor() if ( IsYBRFull ) { // [Planar 1] AND [Photo C] (remember YBR_FULL_422 acts as RGB) - gdcmWarningMacro("--> YBRFull"); + gdcmDebugMacro("--> YBRFull"); ConvertYcBcRPlanesToRGBPixels(); } else { // [Planar 1] AND [Photo C] - gdcmWarningMacro("--> YBRFull"); + gdcmDebugMacro("--> YBRFull"); ConvertRGBPlanesToRGBPixels(); } return; @@ -1251,7 +1366,7 @@ void PixelReadConvert::ConvertHandleColor() if (IsRLELossless) { - gdcmWarningMacro("--> RLE Lossless"); + gdcmDebugMacro("--> RLE Lossless"); ConvertRGBPlanesToRGBPixels(); } @@ -1270,7 +1385,7 @@ void PixelReadConvert::ComputeRawAndRGBSizes() bitsAllocated = 16; } - RawSize = XSize * YSize * ZSize + RawSize = XSize * YSize * ZSize * TSize * ( bitsAllocated / 8 ) * SamplesPerPixel; if ( HasLUT ) @@ -1281,6 +1396,8 @@ void PixelReadConvert::ComputeRawAndRGBSizes() { RGBSize = RawSize; } + RawSize += RawSize%2; + RGBSize += RGBSize%2; } /// Allocates room for RGB Pixels @@ -1343,6 +1460,33 @@ void PixelReadConvert::Print( std::ostream &os, std::string const &indent ) } } +/** + * \brief CallStartMethod + */ +void PixelReadConvert::CallStartMethod() +{ + Progress = 0.0f; + Abort = false; + CommandManager::ExecuteCommand(FH,CMD_STARTPROGRESS); +} + +/** + * \brief CallProgressMethod + */ +void PixelReadConvert::CallProgressMethod() +{ + CommandManager::ExecuteCommand(FH,CMD_PROGRESS); +} + +/** + * \brief CallEndMethod + */ +void PixelReadConvert::CallEndMethod() +{ + Progress = 1.0f; + CommandManager::ExecuteCommand(FH,CMD_ENDPROGRESS); +} + //----------------------------------------------------------------------------- } // end namespace gdcm