Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/11/09 11:22:51 $
- Version: $Revision: 1.100 $
+ Date: $Date: 2005/11/28 15:30:04 $
+ Version: $Revision: 1.104 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
namespace gdcm
{
-bool ReadMPEGFile (std::ifstream *fp, char *inputdata, 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);
//-----------------------------------------------------------------------------
PixelSign = file->IsSignedPixelData();
SwapCode = file->GetSwapCode();
- if (! file->IsDicomV3() ) // Should be ACR-NEMA file
- {
- IsRaw = true;
- // Don't loose time checking unexistant Transfer Syntax !
- IsPrivateGETransferSyntax = IsMPEG
+ 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)
+ while (true) // short 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::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 = IsJPEG2000 = IsJPEGLS = IsJPEGLossy = IsJPEGLossless = IsRLELossless = false;
-
if (!IsRaw)
{
while(true)
if( IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts) ) break;
if( IsMPEG = Global::GetTS()->IsMPEG(ts) ) break;
if( IsJPEGLS = Global::GetTS()->IsJPEGLS(ts) ) break;
- gdcmWarningMacro("Unexepected Transfer Syntax :[" << ts << "]");
+ gdcmStaticWarningMacro("Unexpected Transfer Syntax :[" << ts << "]");
break;
}
}
LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
if ( ! LutRedData )
{
- gdcmWarningMacro("Unable to read Red Palette Color Lookup Table data");
+ gdcmStaticWarningMacro("Unable to read Red Palette Color Lookup Table data");
}
// //// Green round:
LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
if ( ! LutGreenData)
{
- gdcmWarningMacro("Unable to read Green Palette Color Lookup Table data");
+ gdcmStaticWarningMacro("Unable to read Green Palette Color Lookup Table data");
}
// //// Blue round:
LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
if ( ! LutBlueData )
{
- gdcmWarningMacro("Unable to read Blue Palette Color Lookup Table data");
+ gdcmStaticWarningMacro("Unable to read Blue Palette Color Lookup Table data");
}
}
FileInternal = file;
//// First stage: get our hands on the Pixel Data.
if ( !fp )
{
- gdcmWarningMacro( "Unavailable file pointer." );
+ gdcmStaticWarningMacro( "Unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
if ( fp->fail() || fp->eof() )
{
- gdcmWarningMacro( "Unable to find PixelOffset in file." );
+ gdcmStaticWarningMacro( "Unable to find PixelOffset in file." );
return false;
}
// variable). But RawSize is the right size of the image !
if ( PixelDataLength != RawSize )
{
- gdcmWarningMacro( "Mismatch between PixelReadConvert : "
- << PixelDataLength << " and RawSize : " << RawSize );
+ gdcmStaticWarningMacro( "Mismatch between PixelReadConvert : "
+ << PixelDataLength << " and RawSize : " << RawSize );
}
if ( PixelDataLength > RawSize )
{
if ( fp->fail() || fp->eof())
{
- gdcmWarningMacro( "Reading of Raw pixel data failed." );
+ gdcmStaticWarningMacro( "Reading of Raw pixel data failed." );
return false;
}
}
if ( ! RLEInfo->DecompressRLEFile
( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) )
{
- gdcmWarningMacro( "RLE decompressor failed." );
+ gdcmStaticWarningMacro( "RLE decompressor failed." );
return false;
}
}
else if ( IsMPEG )
{
- //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" );
+ //gdcmStaticWarningMacro( "Sorry, MPEG not yet taken into account" );
//return false;
// fp has already been seek to start of mpeg
- ReadMPEGFile(fp, (char*)Raw, PixelDataLength);
+ //ReadMPEGFile(fp, (char*)Raw, PixelDataLength);
return true;
}
else
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- gdcmWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()"
- << " method ) failed." );
+ gdcmStaticWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()"
+ << " method ) failed." );
return false;
}
}
return false;
}
- gdcmDebugMacro( "--> BuildRGBImage" );
+ gdcmStaticDebugMacro( "--> BuildRGBImage" );
// Build RGB Pixels
AllocateRGB();
inputlength += jpegfrag->GetLength();
jpegfrag = JPEGInfo->GetNextFragment();
}
- gdcmAssertMacro( inputlength != 0);
+ gdcmStaticAssertMacro( inputlength != 0);
uint8_t *inputdata = new uint8_t[inputlength];
char *pinputdata = (char*)inputdata;
jpegfrag = JPEGInfo->GetFirstFragment();
return true;
}
// wow what happen, must be an error
- gdcmWarningMacro( "gdcm_read_JPEG2000_file() failed ");
+ gdcmStaticWarningMacro( "gdcm_read_JPEG2000_file() failed ");
return false;
}
else if ( IsJPEGLS )
inputlength += jpegfrag->GetLength();
jpegfrag = JPEGInfo->GetNextFragment();
}
- gdcmAssertMacro( inputlength != 0);
+ gdcmStaticAssertMacro( inputlength != 0);
uint8_t *inputdata = new uint8_t[inputlength];
char *pinputdata = (char*)inputdata;
jpegfrag = JPEGInfo->GetFirstFragment();
delete[] inputdata;
#endif
- gdcmWarningMacro( "Sorry, JPEG-LS not yet taken into account" );
+ gdcmStaticWarningMacro( "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;
|| LutGreenDescriptor == GDCM_UNFOUND
|| LutBlueDescriptor == GDCM_UNFOUND )
{
- gdcmWarningMacro( "(At least) a LUT Descriptor is missing" );
+ gdcmStaticWarningMacro( "(At least) a LUT Descriptor is missing" );
return;
}
&lengthR, &debR, &nbitsR );
if ( nbRead != 3 )
{
- gdcmWarningMacro( "Wrong Red LUT descriptor" );
+ gdcmStaticWarningMacro( "Wrong Red LUT descriptor" );
}
int lengthG; // Green LUT length in Bytes
int debG; // Subscript of the first Lut Value
&lengthG, &debG, &nbitsG );
if ( nbRead != 3 )
{
- gdcmWarningMacro( "Wrong Green LUT descriptor" );
+ gdcmStaticWarningMacro( "Wrong Green LUT descriptor" );
}
int lengthB; // Blue LUT length in Bytes
&lengthB, &debB, &nbitsB );
if ( nbRead != 3 )
{
- gdcmWarningMacro( "Wrong Blue LUT descriptor" );
+ gdcmStaticWarningMacro( "Wrong Blue LUT descriptor" );
}
- gdcmDebugMacro(" lengthR " << lengthR << " debR "
- << debR << " nbitsR " << nbitsR);
- gdcmDebugMacro(" lengthG " << lengthG << " debG "
- << debG << " nbitsG " << nbitsG);
- gdcmDebugMacro(" lengthB " << lengthB << " debB "
- << debB << " nbitsB " << nbitsB);
+ gdcmStaticDebugMacro(" lengthR " << lengthR << " debR "
+ << debR << " nbitsR " << nbitsR);
+ gdcmStaticDebugMacro(" lengthG " << lengthG << " debG "
+ << debG << " nbitsG " << nbitsG);
+ gdcmStaticDebugMacro(" lengthB " << lengthB << " debB "
+ << debB << " nbitsB " << nbitsB);
if ( !lengthR ) // if = 2^16, this shall be 0 see : CP-143
lengthR=65536;
if ( ( ! LutRedData ) || ( ! LutGreenData ) || ( ! LutBlueData ) )
{
- gdcmWarningMacro( "(At least) a LUT is missing" );
+ gdcmStaticWarningMacro( "(At least) a LUT is missing" );
return;
}
// with 65536 entries LUT ?!?
// Still looking for accurate info on the web :-(
- gdcmWarningMacro( "Sorry Palette Color Lookup Tables not yet dealt with"
+ gdcmStaticWarningMacro( "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
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
// 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.
-
+
+ int tempSwapCode = SwapCode;
if ( IsPrivateGETransferSyntax )
{
+ gdcmStaticWarningMacro(" 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;
}
break;
default:
- gdcmWarningMacro("SwapCode value (16 bits) not allowed.");
+ gdcmStaticWarningMacro("SwapCode value (16 bits) not allowed."
+ << tempSwapCode);
}
}
else if ( BitsAllocated == 32 )
uint16_t high;
uint16_t low;
uint32_t *im32 = (uint32_t*)Raw;
- switch ( localSwapCode )
+ switch ( tempSwapCode )
{
case 1234:
break;
}
break;
default:
- gdcmWarningMacro("SwapCode value (32 bits) not allowed." );
+ gdcmStaticWarningMacro("SwapCode value (32 bits) not allowed." << tempSwapCode );
}
}
}
}
else
{
- gdcmWarningMacro("Weird image (BitsAllocated !=8, 12, 16, 32)");
+ gdcmStaticWarningMacro("Weird image (BitsAllocated !=8, 12, 16, 32)");
throw FormatError( "Weird image !?" );
}
}
*/
void PixelReadConvert::ConvertRGBPlanesToRGBPixels()
{
- gdcmWarningMacro("--> ConvertRGBPlanesToRGBPixels");
+ gdcmStaticWarningMacro("--> ConvertRGBPlanesToRGBPixels");
uint8_t *localRaw = Raw;
uint8_t *copyRaw = new uint8_t[ RawSize ];
// On such images, RLE achieves a compression ratio that is much better
// than the compression ratio on an equivalent RGB image.
- gdcmWarningMacro("--> ConvertYcBcRPlanesToRGBPixels");
+ gdcmStaticWarningMacro("--> ConvertYcBcRPlanesToRGBPixels");
uint8_t *localRaw = Raw;
uint8_t *copyRaw = new uint8_t[ RawSize ];
// - [Planar 1] AND [Photo C] handled with ConvertYcBcRPlanesToRGBPixels()
// - [Planar 2] OR [Photo D] requires LUT intervention.
- gdcmDebugMacro("--> ConvertHandleColor "
- << "Planar Configuration " << PlanarConfiguration );
+ gdcmStaticDebugMacro("--> ConvertHandleColor "
+ << "Planar Configuration " << PlanarConfiguration );
if ( ! IsRawRGB() )
{
// [Planar 2] OR [Photo D]: LUT intervention done outside
- gdcmDebugMacro("--> RawRGB : LUT intervention done outside");
+ gdcmStaticDebugMacro("--> RawRGB : LUT intervention done outside");
return;
}
if ( IsYBRFull )
{
// [Planar 1] AND [Photo C] (remember YBR_FULL_422 acts as RGB)
- gdcmDebugMacro("--> YBRFull");
+ gdcmStaticDebugMacro("--> YBRFull");
ConvertYcBcRPlanesToRGBPixels();
}
else
{
// [Planar 1] AND [Photo C]
- gdcmDebugMacro("--> YBRFull");
+ gdcmStaticDebugMacro("--> YBRFull");
ConvertRGBPlanesToRGBPixels();
}
return;
if (IsRLELossless)
{
- gdcmDebugMacro("--> RLE Lossless");
+ gdcmStaticDebugMacro("--> RLE Lossless");
ConvertRGBPlanesToRGBPixels();
}
}
else
{
- gdcmWarningMacro("Set as RLE file but NO RLEinfo present.");
+ gdcmStaticWarningMacro("Set as RLE file but NO RLEinfo present.");
}
}
}
else
{
- gdcmWarningMacro("Set as JPEG file but NO JPEGinfo present.");
+ gdcmStaticWarningMacro("Set as JPEG file but NO JPEGinfo present.");
}
}
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff