Program: gdcm
Module: $RCSfile: gdcmPixelConvert.cxx,v $
Language: C++
- Date: $Date: 2004/10/08 16:27:20 $
- Version: $Revision: 1.3 $
+ Date: $Date: 2004/10/12 04:35:47 $
+ 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
////////////////// TEMPORARY NOT
// look for "fixMem" and convert that to a member of this class
// Removing the prefix fixMem and dealing with allocations should do the trick
-#define str2num(str, typeNum) *((typeNum *)(str))
-
+//
+// grep PIXELCONVERT everywhere and clean up !
#include "gdcmDebug.h"
#include "gdcmPixelConvert.h"
+// External JPEG decompression
+
+// for JPEGLosslessDecodeImage
+#include "jpeg/ljpg/jpegless.h"
+
+
+namespace gdcm
+{
+
+#define str2num(str, typeNum) *((typeNum *)(str))
+
+// For JPEG 2000, body in file gdcmJpeg2000.cxx
+bool gdcm_read_JPEG2000_file (FILE* fp, void* image_buffer);
+
+// For JPEG 8 Bits, body in file gdcmJpeg8.cxx
+bool gdcm_read_JPEG_file (FILE* fp, void* image_buffer);
+
+// For JPEG 12 Bits, body in file gdcmJpeg12.cxx
+bool gdcm_read_JPEG_file12 (FILE* fp, void* image_buffer);
+
+
//-----------------------------------------------------------------------------
// Constructor / Destructor
-gdcmPixelConvert::gdcmPixelConvert()
+PixelConvert::PixelConvert()
{
RGB = 0;
RGBSize = 0;
UncompressedSize = 0;
}
-void gdcmPixelConvert::Squeeze()
+void PixelConvert::Squeeze()
{
if ( RGB ) {
delete [] RGB;
}
}
-gdcmPixelConvert::~gdcmPixelConvert()
+PixelConvert::~PixelConvert()
{
Squeeze();
}
-void gdcmPixelConvert::AllocateRGB()
+void PixelConvert::AllocateRGB()
{
if ( RGB ) {
delete [] RGB;
RGB = new uint8_t[RGBSize];
}
-void gdcmPixelConvert::AllocateUncompressed()
+void PixelConvert::AllocateUncompressed()
{
if ( Uncompressed ) {
delete [] Uncompressed;
* \brief Read from file a 12 bits per pixel image and uncompress it
* into a 16 bits per pixel image.
*/
-bool gdcmPixelConvert::ReadAndUncompress12Bits( FILE* filePointer,
- size_t uncompressedSize,
- size_t PixelNumber )
+void PixelConvert::ConvertDecompress12BitsTo16Bits(
+ uint8_t* pixelZone,
+ int sizeX,
+ int sizeY,
+ FILE* filePtr)
+ throw ( FormatError )
{
- SetUncompressedSize( uncompressedSize );
- AllocateUncompressed();
-
- uint16_t* pdestination = (uint16_t*)Uncompressed;
+ int nbPixels = sizeX * sizeY;
+ uint16_t* destination = (uint16_t*)pixelZone;
- for(int p = 0; p < PixelNumber; p += 2 )
+ for( int p = 0; p < nbPixels; p += 2 )
{
- // 2 pixels 12bit = [0xABCDEF]
- // 2 pixels 16bit = [0x0ABD] + [0x0FCE]
uint8_t b0, b1, b2;
size_t ItemRead;
- ItemRead = fread( &b0, 1, 1, filePointer);
+
+ ItemRead = fread( &b0, 1, 1, filePtr);
if ( ItemRead != 1 )
{
- return false;
+ throw FormatError( "File::ConvertDecompress12BitsTo16Bits()",
+ "Unfound first block" );
}
- ItemRead = fread( &b1, 1, 1, filePointer);
+
+ ItemRead = fread( &b1, 1, 1, filePtr);
if ( ItemRead != 1 )
{
- return false;
+ throw FormatError( "File::ConvertDecompress12BitsTo16Bits()",
+ "Unfound second block" );
}
- ItemRead = fread( &b2, 1, 1, filePointer);
+
+ ItemRead = fread( &b2, 1, 1, filePtr);
if ( ItemRead != 1 )
{
- return false;
+ throw FormatError( "File::ConvertDecompress12BitsTo16Bits()",
+ "Unfound second block" );
}
- //Two steps are necessary to please VC++
- *pdestination++ = ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f);
+ // Two steps are necessary to please VC++
+ //
+ // 2 pixels 12bit = [0xABCDEF]
+ // 2 pixels 16bit = [0x0ABD] + [0x0FCE]
// A B D
- *pdestination++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
+ *destination++ = ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f);
// F C E
+ *destination++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
/// \todo JPR Troubles expected on Big-Endian processors ?
}
- return true;
-}
-
-/**
- * \brief Read from file an uncompressed image.
- */
-bool gdcmPixelConvert::ReadUncompressed( FILE* filePointer,
- size_t uncompressedSize,
- size_t expectedSize )
-{
- if ( expectedSize > uncompressedSize )
- {
- dbg.Verbose(0, "gdcmPixelConvert::ReadUncompressed: expectedSize"
- "is bigger than it should");
- return false;
- }
- SetUncompressedSize( uncompressedSize );
- AllocateUncompressed();
- size_t ItemRead = fread( (void*)Uncompressed, expectedSize, 1, filePointer);
- if ( ItemRead != 1 )
- {
- return false;
- }
- return true;
-}
-
-/**
- * \brief Convert a Gray plane and ( Lut R, Lut G, Lut B ) into an
- * RGB plane.
- * @return True on success.
- */
-bool gdcmPixelConvert::ConvertGrayAndLutToRGB( uint8_t *lutRGBA )
-
-{
- /// We assume Uncompressed contains the decompressed gray plane
- /// and build the RGB image.
- SetRGBSize( UncompressedSize );
- AllocateRGB();
-
-//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-//COPY HERE THE CODE OF GetImageDataIntoVector
-
- /// \todo check that operator new []didn't fail, and sometimes return false
- return true;
}
/**
* \brief Try to deal with RLE 16 Bits.
* We assume the RLE has allready been parsed and loaded in
- * Uncompressed (through \ref ReadAndUncompressRLE8Bits ).
+ * Uncompressed (through \ref ReadAndDecompressJPEGFile ).
* We here need to make 16 Bits Pixels from Low Byte and
* High Byte 'Planes'...(for what it may mean)
* @return Boolean
*/
-bool gdcmPixelConvert::UncompressRLE16BitsFromRLE8Bits(
+bool PixelConvert::UncompressRLE16BitsFromRLE8Bits(
int XSize,
int YSize,
int NumberOfFrames,
for ( int i = 0; i < NumberOfFrames; i++ )
{
- for ( int j = 0; j < PixelNumber; j++ )
+ for ( unsigned int j = 0; j < PixelNumber; j++ )
{
*(x++) = *(a++);
*(x++) = *(b++);
* \brief Implementation of the RLE decoding algorithm for uncompressing
* a RLE fragment. [refer to PS 3.5-2003, section G.3.2 p 86]
*/
-bool gdcmPixelConvert::ReadAndUncompressRLEFragment( uint8_t* decodedZone,
+bool PixelConvert::ReadAndUncompressRLEFragment( uint8_t* decodedZone,
long fragmentSize,
long uncompressedSegmentSize,
FILE* fp )
if ( numberOfReadBytes > fragmentSize )
{
- dbg.Verbose(0, "gdcmFile::gdcm_read_RLE_fragment: we read more "
+ dbg.Verbose(0, "File::gdcm_read_RLE_fragment: we read more "
"bytes than the segment size.");
return false;
}
* at which the pixel data should be copied
* @return Boolean
*/
-bool gdcmPixelConvert::gdcm_read_RLE_file( void* image_buffer,
+bool PixelConvert::ReadAndDecompressRLEFile( void* image_buffer,
int XSize,
int YSize,
int ZSize,
int BitsAllocated,
- gdcmRLEFramesInfo* RLEInfo,
+ RLEFramesInfo* RLEInfo,
FILE* fp )
{
uint8_t* im = (uint8_t*)image_buffer;
// Loop on the frame[s]
- for( gdcmRLEFramesInfo::RLEFrameList::iterator
+ for( RLEFramesInfo::RLEFrameList::iterator
it = RLEInfo->Frames.begin();
it != RLEInfo->Frames.end();
++it )
// Loop on the fragments
for( unsigned int k = 1; k <= (*it)->NumberFragments; k++ )
{
- fseek( fp, (*it)->Offset[k] ,SEEK_SET);
- (void)gdcmPixelConvert::ReadAndUncompressRLEFragment(
+ fseek( fp, (*it)->Offset[k] ,SEEK_SET );
+ (void)PixelConvert::ReadAndUncompressRLEFragment(
(uint8_t*) im, (*it)->Length[k],
uncompressedSegmentSize, fp );
im += uncompressedSegmentSize;
if ( BitsAllocated == 16 )
{
// Try to deal with RLE 16 Bits
- (void)gdcmPixelConvert::UncompressRLE16BitsFromRLE8Bits(
+ (void)PixelConvert::UncompressRLE16BitsFromRLE8Bits(
XSize,
YSize,
ZSize,
return true;
}
+/**
+ * \brief Swap the bytes, according to swap code.
+ * \warning not end user intended
+ * @param im area to deal with
+ * @param swap swap code
+ * @param lgr Area Length
+ * @param nb Pixels Bit number
+ */
+void PixelConvert::SwapZone(void* im, int swap, int lgr, int nb)
+{
+ int i;
+
+ if( nb == 16 )
+ {
+ uint16_t* im16 = (uint16_t*)im;
+ switch( swap )
+ {
+ case 0:
+ case 12:
+ case 1234:
+ break;
+ case 21:
+ case 3412:
+ case 2143:
+ case 4321:
+ for(i=0; i < lgr/2; i++)
+ {
+ im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
+ }
+ break;
+ default:
+ std::cout << "SWAP value (16 bits) not allowed :i" << swap <<
+ std::endl;
+ }
+ }
+ else if( nb == 32 )
+ {
+ uint32_t s32;
+ uint16_t fort, faible;
+ uint32_t* im32 = (uint32_t*)im;
+ switch ( swap )
+ {
+ case 0:
+ case 1234:
+ break;
+ case 4321:
+ for(i = 0; i < lgr/4; i++)
+ {
+ faible = im32[i] & 0x0000ffff; // 4321
+ fort = im32[i] >> 16;
+ fort = ( fort >> 8 ) | ( fort << 8 );
+ faible = ( faible >> 8 ) | ( faible << 8);
+ s32 = faible;
+ im32[i] = ( s32 << 16 ) | fort;
+ }
+ break;
+ case 2143:
+ for(i = 0; i < lgr/4; i++)
+ {
+ faible = im32[i] & 0x0000ffff; // 2143
+ fort = im32[i] >> 16;
+ fort = ( fort >> 8 ) | ( fort << 8 );
+ faible = ( faible >> 8) | ( faible << 8);
+ s32 = fort;
+ im32[i] = ( s32 << 16 ) | faible;
+ }
+ break;
+ case 3412:
+ for(i = 0; i < lgr/4; i++)
+ {
+ faible = im32[i] & 0x0000ffff; // 3412
+ fort = im32[i] >> 16;
+ s32 = faible;
+ im32[i] = ( s32 << 16 ) | fort;
+ }
+ break;
+ default:
+ std::cout << "SWAP value (32 bits) not allowed : " << swap <<
+ std::endl;
+ }
+ }
+}
+
+
+
+/**
+ * \brief Deal with endianity i.e. re-arange bytes inside the integer
+ */
+void PixelConvert::ConvertReorderEndianity( uint8_t* pixelZone,
+ size_t imageDataSize,
+ int numberBitsStored,
+ int numberBitsAllocated,
+ int swapCode,
+ bool signedPixel)
+{
+ if ( numberBitsAllocated != 8 )
+ {
+ SwapZone( pixelZone, swapCode, imageDataSize, numberBitsAllocated );
+ }
+
+ // Special kludge in order to deal with xmedcon broken images:
+ if ( ( numberBitsAllocated == 16 )
+ && ( numberBitsStored < numberBitsAllocated )
+ && ( ! signedPixel ) )
+ {
+ int l = (int)(imageDataSize / (numberBitsAllocated/8));
+ uint16_t *deb = (uint16_t *)pixelZone;
+ for(int i = 0; i<l; i++)
+ {
+ if( *deb == 0xffff )
+ {
+ *deb = 0;
+ }
+ deb++;
+ }
+ }
+}
+
+/**
+ * \brief Reads from disk the Pixel Data of JPEG Dicom encapsulated
+ & file and uncompress it.
+ * @param fp already open File Pointer
+ * @param destination Where decompressed fragments should end up
+ * @return Boolean
+ */
+bool PixelConvert::ReadAndDecompressJPEGFile( uint8_t* destination,
+ int XSize,
+ int YSize,
+ int BitsAllocated,
+ int BitsStored,
+ int SamplesPerPixel,
+ int PixelSize,
+ bool isJPEG2000,
+ bool isJPEGLossless,
+ JPEGFragmentsInfo* JPEGInfo,
+ FILE* fp )
+{
+ // Loop on the fragment[s]
+ for( JPEGFragmentsInfo::JPEGFragmentsList::iterator
+ it = JPEGInfo->Fragments.begin();
+ it != JPEGInfo->Fragments.end();
+ ++it )
+ {
+ fseek( fp, (*it)->Offset, SEEK_SET );
+
+ if ( isJPEG2000 )
+ {
+ if ( ! gdcm_read_JPEG2000_file( fp, destination ) )
+ {
+ return false;
+ }
+ }
+ else if ( isJPEGLossless )
+ {
+ // JPEG LossLess : call to xmedcom Lossless JPEG
+ JPEGLosslessDecodeImage( fp,
+ (uint16_t*)destination,
+ PixelSize * 8 * SamplesPerPixel,
+ (*it)->Length );
+ }
+ else if ( BitsStored == 8)
+ {
+ // JPEG Lossy : call to IJG 6b
+ if ( ! gdcm_read_JPEG_file ( fp, destination ) )
+ {
+ return false;
+ }
+ }
+ else if ( BitsStored == 12)
+ {
+ // Reading Fragment pixels
+ if ( ! gdcm_read_JPEG_file12 ( fp, destination ) )
+ {
+ return false;
+ }
+ }
+ else
+ {
+ // other JPEG lossy not supported
+ dbg.Error(" File::ReadPixelData : unknown jpeg lossy "
+ " compression ");
+ return false;
+ }
+
+ // Advance to next free location in destination
+ // for next fragment decompression (if any)
+ int length = XSize * YSize * SamplesPerPixel;
+ int numberBytes = BitsAllocated / 8;
+
+ destination = (uint8_t*)destination + length * numberBytes;
+
+ }
+ return true;
+}
+
+/**
+ * \brief Re-arrange the bits within the bytes.
+ * @param fp already open File Pointer
+ * @param destination Where decompressed fragments should end up
+ * @return Boolean
+ */
+bool PixelConvert::ConvertReArrangeBits(
+ uint8_t* pixelZone,
+ size_t imageDataSize,
+ int numberBitsStored,
+ int numberBitsAllocated,
+ int highBitPosition )
+ throw ( FormatError )
+{
+ if ( numberBitsStored != numberBitsAllocated )
+ {
+ int l = (int)(imageDataSize / (numberBitsAllocated/8));
+ if ( numberBitsAllocated == 16 )
+ {
+ uint16_t mask = 0xffff;
+ mask = mask >> ( numberBitsAllocated - numberBitsStored );
+ uint16_t* deb = (uint16_t*)pixelZone;
+ for(int i = 0; i<l; i++)
+ {
+ *deb = (*deb >> (numberBitsStored - highBitPosition - 1)) & mask;
+ deb++;
+ }
+ }
+ else if ( numberBitsAllocated == 32 )
+ {
+ uint32_t mask = 0xffffffff;
+ mask = mask >> ( numberBitsAllocated - numberBitsStored );
+ uint32_t* deb = (uint32_t*)pixelZone;
+ for(int i = 0; i<l; i++)
+ {
+ *deb = (*deb >> (numberBitsStored - highBitPosition - 1)) & mask;
+ deb++;
+ }
+ }
+ else
+ {
+ dbg.Verbose(0, "PixelConvert::ConvertReArrangeBits: weird image");
+ throw FormatError( "File::ConvertReArrangeBits()",
+ "weird image !?" );
+ }
+ }
+ return true; //???
+}
+} // end namespace gdcm
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff