Program: gdcm
Module: $RCSfile: gdcmFile.cxx,v $
Language: C++
- Date: $Date: 2004/09/30 12:51:55 $
- Version: $Revision: 1.133 $
+ Date: $Date: 2004/10/08 17:24:54 $
+ Version: $Revision: 1.137 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmFile.h"
#include "gdcmDebug.h"
+#include "gdcmPixelConvert.h"
#include "jpeg/ljpg/jpegless.h"
typedef std::pair<TagDocEntryHT::iterator,TagDocEntryHT::iterator> IterHT;
bool signedPixel = Header->IsSignedPixelData();
- ConvertReorderEndianity( (uint8_t*) destination,
+ gdcmPixelConvert::ConvertReorderEndianity(
+ (uint8_t*) destination,
ImageDataSize,
numberBitsStored,
numberBitsAllocated,
+ Header->GetSwapCode(),
signedPixel );
ConvertReArrangeBits( (uint8_t*) destination,
}
}
-/**
- * \brief Deal with endianity i.e. re-arange bytes inside the integer
- */
-void gdcmFile::ConvertReorderEndianity( uint8_t* pixelZone,
- size_t imageDataSize,
- int numberBitsStored,
- int numberBitsAllocated,
- bool signedPixel)
-{
- if ( numberBitsAllocated != 8 )
- {
- SwapZone( pixelZone, Header->GetSwapCode(), 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 Convert (Y plane, cB plane, cR plane) to RGB pixels
* \warning Works on all the frames at a time
//-----------------------------------------------------------------------------
// Private
-/**
- * \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 gdcmFile::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 Read pixel data from disk (optionaly decompressing) into the
* caller specified memory location.
return false;
}
- // ---------------------- Compacted File (12 Bits Per Pixel)
- // unpack 12 Bits pixels into 16 Bits pixels
- // 2 pixels 12bit = [0xABCDEF]
- // 2 pixels 16bit = [0x0ABD] + [0x0FCE]
-
if ( Header->GetBitsAllocated() == 12 )
{
- int nbPixels = Header->GetXSize() * Header->GetYSize();
- uint8_t b0, b1, b2;
-
- uint16_t* pdestination = (uint16_t*)destination;
- for(int p = 0; p < nbPixels; p += 2 )
- {
- fread(&b0,1,1,fp);
- fread(&b1,1,1,fp);
- fread(&b2,1,1,fp);
-
- //Two steps is necessary to please VC++
- *pdestination++ = ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f);
- // A B D
- *pdestination++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
- // F C E
-
- // Troubles expected on Big-Endian processors ?
- }
-
+ gdcmPixelConvert::ConvertDecompress12BitsTo16Bits(
+ (uint8_t*)destination,
+ Header->GetXSize(),
+ Header->GetYSize(),
+ fp);
Header->CloseFile();
return true;
}
// ---------------------- Run Length Encoding
if ( Header->IsRLELossLessTransferSyntax() )
{
- bool res = gdcm_read_RLE_file (fp,destination);
+ bool res = gdcmPixelConvert::gdcm_read_RLE_file ( destination,
+ Header->GetXSize(),
+ Header->GetYSize(),
+ Header->GetZSize(),
+ Header->GetBitsAllocated(),
+ &(Header->RLEInfo),
+ fp );
Header->CloseFile();
return res;
}
// --------------- SingleFrame/Multiframe JPEG Lossless/Lossy/2000
- int nb;
- std::string str_nb = Header->GetEntryByNumber(0x0028,0x0100);
- if ( str_nb == GDCM_UNFOUND )
- {
- nb = 16;
- }
- else
+ int numberBitsAllocated = Header->GetBitsAllocated();
+ if ( ( numberBitsAllocated == 0 ) || ( numberBitsAllocated == 12 ) )
{
- nb = atoi( str_nb.c_str() );
- if ( nb == 12 )
- {
- nb = 16; // ?? 12 should be ACR-NEMA only
- }
+ numberBitsAllocated = 16;
}
- int nBytes= nb/8;
+ int nBytes= numberBitsAllocated/8;
int taille = Header->GetXSize() * Header->GetYSize()
* Header->GetSamplesPerPixel();
long fragmentBegining; // for ftell, fseek
// Reading Fragment pixels
res = gdcm_read_JPEG_file (fp,destination);
}
- else
+ else if ( Header->GetBitsStored() == 12)
{
// Reading Fragment pixels
res = gdcm_read_JPEG_file12 (fp,destination);
}
+ else
+ {
+ // other JPEG lossy not supported
+ dbg.Error(" gdcmFile::ReadPixelData : unknown jpeg lossy compression");
+ return 0;
+ }
// ------------------------------------- endif (JPEGLossy)
}
Header->CloseFile();
return res;
}
-//-----------------------------------------------------------------------------
+