From 95dcce2c32665bcba9aa2d20c13390271a204e23 Mon Sep 17 00:00:00 2001 From: malaterre Date: Mon, 31 Jan 2005 06:17:22 +0000 Subject: [PATCH] ENH: Yet another pass to get RLE stuff similar to JPEG. I am still unhappy with the increment of Raw. Ideally the compressor superclass should hold this pointer instead of passing around subRaw thingy --- src/gdcmPixelReadConvert.cxx | 6 +-- src/gdcmRLEFrame.cxx | 86 ++++++++++++++++++++++++++++++++++-- src/gdcmRLEFrame.h | 17 ++++--- src/gdcmRLEFramesInfo.cxx | 85 ++++------------------------------- src/gdcmRLEFramesInfo.h | 13 ++---- 5 files changed, 109 insertions(+), 98 deletions(-) diff --git a/src/gdcmPixelReadConvert.cxx b/src/gdcmPixelReadConvert.cxx index 1536ad4a..56f941b7 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/01/31 05:24:21 $ - Version: $Revision: 1.41 $ + Date: $Date: 2005/01/31 06:17:22 $ + Version: $Revision: 1.42 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -440,7 +440,7 @@ bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp ) } else if ( IsRLELossless ) { - if ( ! RLEInfo->ReadAndDecompressRLEFile( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) ) + if ( ! RLEInfo->DecompressRLEFile( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) ) { gdcmVerboseMacro( "RLE decompressor failed." ); return false; diff --git a/src/gdcmRLEFrame.cxx b/src/gdcmRLEFrame.cxx index 7ed3a0a9..62da1c6c 100644 --- a/src/gdcmRLEFrame.cxx +++ b/src/gdcmRLEFrame.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmRLEFrame.cxx,v $ Language: C++ - Date: $Date: 2005/01/26 11:42:02 $ - Version: $Revision: 1.3 $ + Date: $Date: 2005/01/31 06:17:22 $ + Version: $Revision: 1.4 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -32,7 +32,7 @@ void RLEFrame::Print( std::ostream &os, std::string indent ) os << indent << "--- fragments" << std::endl; - for ( unsigned int i = 0; i < NumberFragments; i++ ) + for ( unsigned int i = 0; i < NumberOfFragments; i++ ) { os << indent << " offset : " << Offset[i] @@ -65,5 +65,85 @@ long RLEFrame::GetLength(unsigned int id) return Length[id]; } +uint8_t *RLEFrame::ReadAndDecompressRLEFrame( uint8_t *subRaw, + long rawSegmentSize, + std::ifstream *fp ) +{ + // Loop on the fragments + for( unsigned int k = 1; k <= NumberOfFragments; k++ ) + { + // First thing need to reset file to proper position: + fp->seekg(Offset[k], std::ios::beg); + ReadAndDecompressRLEFragment(subRaw, Length[k], + rawSegmentSize, fp); + subRaw += rawSegmentSize; + } + + return subRaw; +} + +/** + * \brief Implementation of the RLE decoding algorithm for decompressing + * a RLE fragment. [refer to PS 3.5-2003, section G.3.2 p 86] + * @param subRaw Sub region of \ref Raw where the decoded fragment + * should be placed. + * @param fragmentSize The length of the binary fragment as found on the disk. + * @param RawSegmentSize The expected length of the fragment ONCE + * Raw. + * @param fp File Pointer: on entry the position should be the one of + * the fragment to be decoded. + */ +bool RLEFrame::ReadAndDecompressRLEFragment( uint8_t *subRaw, + long fragmentSize, + long rawSegmentSize, + std::ifstream *fp ) +{ + int8_t count; + long numberOfOutputBytes = 0; + long numberOfReadBytes = 0; + + + while( numberOfOutputBytes < rawSegmentSize ) + { + fp->read( (char*)&count, 1 ); + numberOfReadBytes += 1; + if ( count >= 0 ) + // Note: count <= 127 comparison is always true due to limited range + // of data type int8_t [since the maximum of an exact width + // signed integer of width N is 2^(N-1) - 1, which for int8_t + // is 127]. + { + fp->read( (char*)subRaw, count + 1); + numberOfReadBytes += count + 1; + subRaw += count + 1; + numberOfOutputBytes += count + 1; + } + else + { + if ( count <= -1 && count >= -127 ) + { + int8_t newByte; + fp->read( (char*)&newByte, 1); + numberOfReadBytes += 1; + for( int i = 0; i < -count + 1; i++ ) + { + subRaw[i] = newByte; + } + subRaw += -count + 1; + numberOfOutputBytes += -count + 1; + } + } + // if count = 128 output nothing + + if ( numberOfReadBytes > fragmentSize ) + { + gdcmVerboseMacro( "Read more bytes than the segment size."); + return false; + } + } + return true; +} + + } // end namespace gdcm diff --git a/src/gdcmRLEFrame.h b/src/gdcmRLEFrame.h index ac8eac93..e32a29f3 100644 --- a/src/gdcmRLEFrame.h +++ b/src/gdcmRLEFrame.h @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmRLEFrame.h,v $ Language: C++ - Date: $Date: 2005/01/31 05:24:21 $ - Version: $Revision: 1.13 $ + Date: $Date: 2005/01/31 06:17:22 $ + 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 @@ -45,18 +45,23 @@ namespace gdcm class GDCM_EXPORT RLEFrame { public: - RLEFrame() { NumberFragments = 0; } + RLEFrame() { NumberOfFragments = 0; } void Print( std::ostream &os = std::cout, std::string indent = "" ); - void SetNumberOfFragments(unsigned int number) { NumberFragments = number; }; - unsigned int GetNumberOfFragments() { return NumberFragments; }; + void SetNumberOfFragments(unsigned int number) { NumberOfFragments = number; }; + unsigned int GetNumberOfFragments() { return NumberOfFragments; }; void SetOffset(unsigned int id, long offset); long GetOffset(unsigned int id); void SetLength(unsigned int id, long length); long GetLength(unsigned int id); + uint8_t *ReadAndDecompressRLEFrame( uint8_t *subRaw,long rawSegmentSize, + std::ifstream *fp ); + bool ReadAndDecompressRLEFragment( uint8_t *subRaw, long fragmentSize, + long rawSegmentSize, std::ifstream *fp ); + private: - unsigned int NumberFragments; + unsigned int NumberOfFragments; long Offset[15]; long Length[15]; }; diff --git a/src/gdcmRLEFramesInfo.cxx b/src/gdcmRLEFramesInfo.cxx index 6f9aed23..cc7a5ca9 100644 --- a/src/gdcmRLEFramesInfo.cxx +++ b/src/gdcmRLEFramesInfo.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmRLEFramesInfo.cxx,v $ Language: C++ - Date: $Date: 2005/01/31 05:24:21 $ - Version: $Revision: 1.9 $ + Date: $Date: 2005/01/31 06:17:22 $ + Version: $Revision: 1.10 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -85,96 +85,26 @@ RLEFrame *RLEFramesInfo::GetNextFrame() * at which the pixel data should be copied * @return Boolean */ -bool RLEFramesInfo::ReadAndDecompressRLEFile( std::ifstream *fp , uint8_t *raw, int xSize, int ySize, int zSize, int bitsAllocated ) +bool RLEFramesInfo::DecompressRLEFile( std::ifstream *fp , uint8_t *raw, int xSize, int ySize, int zSize, int bitsAllocated ) { uint8_t *subRaw = raw; - long RawSegmentSize = xSize * ySize; + long rawSegmentSize = xSize * ySize; // Loop on the frame[s] for(RLEFrameList::iterator it = Frames.begin(); it != Frames.end(); ++it) { - // Loop on the fragments - for( unsigned int k = 1; k <= (*it)->GetNumberOfFragments(); k++ ) - { - fp->seekg((*it)->GetOffset(k),std::ios::beg); - ReadAndDecompressRLEFragment(subRaw, - (*it)->GetLength(k), - RawSegmentSize, - fp); - subRaw += RawSegmentSize; - } + subRaw = (*it)->ReadAndDecompressRLEFrame( subRaw, rawSegmentSize, fp); } if ( bitsAllocated == 16 ) { // Try to deal with RLE 16 Bits - (void)DecompressRLE16BitsFromRLE8Bits( raw, xSize, ySize, zSize ); + ConvertRLE16BitsFromRLE8Bits( raw, xSize, ySize, zSize ); } return true; } -/** - * \brief Implementation of the RLE decoding algorithm for decompressing - * a RLE fragment. [refer to PS 3.5-2003, section G.3.2 p 86] - * @param subRaw Sub region of \ref Raw where the decoded fragment - * should be placed. - * @param fragmentSize The length of the binary fragment as found on the disk. - * @param RawSegmentSize The expected length of the fragment ONCE - * Raw. - * @param fp File Pointer: on entry the position should be the one of - * the fragment to be decoded. - */ -bool RLEFramesInfo::ReadAndDecompressRLEFragment( uint8_t *subRaw, - long fragmentSize, - long RawSegmentSize, - std::ifstream *fp ) -{ - int8_t count; - long numberOfOutputBytes = 0; - long numberOfReadBytes = 0; - - while( numberOfOutputBytes < RawSegmentSize ) - { - fp->read( (char*)&count, 1 ); - numberOfReadBytes += 1; - if ( count >= 0 ) - // Note: count <= 127 comparison is always true due to limited range - // of data type int8_t [since the maximum of an exact width - // signed integer of width N is 2^(N-1) - 1, which for int8_t - // is 127]. - { - fp->read( (char*)subRaw, count + 1); - numberOfReadBytes += count + 1; - subRaw += count + 1; - numberOfOutputBytes += count + 1; - } - else - { - if ( count <= -1 && count >= -127 ) - { - int8_t newByte; - fp->read( (char*)&newByte, 1); - numberOfReadBytes += 1; - for( int i = 0; i < -count + 1; i++ ) - { - subRaw[i] = newByte; - } - subRaw += -count + 1; - numberOfOutputBytes += -count + 1; - } - } - // if count = 128 output nothing - - if ( numberOfReadBytes > fragmentSize ) - { - gdcmVerboseMacro( "Read more bytes than the segment size."); - return false; - } - } - return true; -} - /** * \brief Try to deal with RLE 16 Bits. * We assume the RLE has already been parsed and loaded in @@ -183,7 +113,8 @@ bool RLEFramesInfo::ReadAndDecompressRLEFragment( uint8_t *subRaw, * High Byte 'Planes'...(for what it may mean) * @return Boolean */ -bool RLEFramesInfo::DecompressRLE16BitsFromRLE8Bits( uint8_t* raw, int xSize, int ySize,int numberOfFrames ) +bool RLEFramesInfo::ConvertRLE16BitsFromRLE8Bits( uint8_t* raw, int xSize, + int ySize,int numberOfFrames ) { size_t pixelNumber = xSize * ySize; size_t rawSize = xSize * ySize * numberOfFrames; diff --git a/src/gdcmRLEFramesInfo.h b/src/gdcmRLEFramesInfo.h index 27c42287..f4dc2787 100644 --- a/src/gdcmRLEFramesInfo.h +++ b/src/gdcmRLEFramesInfo.h @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmRLEFramesInfo.h,v $ Language: C++ - Date: $Date: 2005/01/31 05:24:22 $ - Version: $Revision: 1.16 $ + Date: $Date: 2005/01/31 06:17:22 $ + Version: $Revision: 1.17 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -45,13 +45,8 @@ class GDCM_EXPORT RLEFramesInfo public: ~RLEFramesInfo(); void Print( std::ostream &os = std::cout, std::string indent = "" ); - bool ReadAndDecompressRLEFile( std::ifstream *fp, uint8_t *subRaw, int xSize, int ySize, int zSize, int bitsAllocated ); - bool ReadAndDecompressRLEFragment( - uint8_t *subDecompressed, - long fragmentSize, - long decompressedSegmentSize, - std::ifstream *fp ); - bool DecompressRLE16BitsFromRLE8Bits( uint8_t* subRaw, int xSize, int ySize, int NumberOfFrames ); + bool DecompressRLEFile( std::ifstream *fp, uint8_t *subRaw, int xSize, int ySize, int zSize, int bitsAllocated ); + bool ConvertRLE16BitsFromRLE8Bits( uint8_t* subRaw, int xSize, int ySize, int NumberOfFrames ); void AddFrame(RLEFrame *frame); -- 2.48.1