Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/02/03 10:03:07 $
- Version: $Revision: 1.46 $
+ Date: $Date: 2005/02/05 01:37:09 $
+ Version: $Revision: 1.49 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
//-----------------------------------------------------------------------------
// Constructor / Destructor
+/// Constructor
PixelReadConvert::PixelReadConvert()
{
RGB = 0;
LutBlueData = 0;
}
+/// Canonical Destructor
PixelReadConvert::~PixelReadConvert()
{
Squeeze();
// [Bin|Val]Entry occurence migth have been hindered (read simply NOT
// loaded). Hence, we first try to obtain the LUTs data from the file
// and when this fails we read the LUTs data directly from disk.
- /// \TODO Reading a [Bin|Val]Entry directly from disk is a kludge.
- /// We should NOT bypass the [Bin|Val]Entry class. Instead
- /// an access to an UNLOADED content of a [Bin|Val]Entry occurence
- /// (e.g. BinEntry::GetBinArea()) should force disk access from
- /// within the [Bin|Val]Entry class itself. The only problem
- /// is that the [Bin|Val]Entry is unaware of the FILE* is was
- /// parsed from. Fix that. FIXME.
+ // \TODO Reading a [Bin|Val]Entry directly from disk is a kludge.
+ // We should NOT bypass the [Bin|Val]Entry class. Instead
+ // an access to an UNLOADED content of a [Bin|Val]Entry occurence
+ // (e.g. BinEntry::GetBinArea()) should force disk access from
+ // within the [Bin|Val]Entry class itself. The only problem
+ // is that the [Bin|Val]Entry is unaware of the FILE* is was
+ // parsed from. Fix that. FIXME.
- ////// Red round
+ // //// Red round
file->LoadEntryBinArea(0x0028, 0x1201);
LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
if ( ! LutRedData )
{
- gdcmVerboseMacro( "Unable to read Red LUT data" );
+ gdcmWarningMacro( "Unable to read Red LUT data" );
}
- ////// Green round:
+ // //// Green round:
file->LoadEntryBinArea(0x0028, 0x1202);
LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
if ( ! LutGreenData)
{
- gdcmVerboseMacro( "Unable to read Green LUT data" );
+ gdcmWarningMacro( "Unable to read Green LUT data" );
}
- ////// Blue round:
+ // //// Blue round:
file->LoadEntryBinArea(0x0028, 0x1203);
LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
if ( ! LutBlueData )
{
- gdcmVerboseMacro( "Unable to read Blue LUT data" );
+ gdcmWarningMacro( "Unable to read Blue LUT data" );
}
}
ComputeRawAndRGBSizes();
}
+/// \brief Reads from disk and decompresses Pixels
bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp )
{
// ComputeRawAndRGBSizes is already made by
//// First stage: get our hands on the Pixel Data.
if ( !fp )
{
- gdcmVerboseMacro( "Unavailable file pointer." );
+ gdcmWarningMacro( "Unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
if( fp->fail() || fp->eof())
{
- gdcmVerboseMacro( "Unable to find PixelOffset in file." );
+ gdcmWarningMacro( "Unable to find PixelOffset in file." );
return false;
}
// variable). But RawSize is the right size of the image !
if( PixelDataLength != RawSize)
{
- gdcmVerboseMacro( "Mismatch between PixelReadConvert : "
+ gdcmWarningMacro( "Mismatch between PixelReadConvert : "
<< PixelDataLength << " and RawSize : " << RawSize );
}
if( PixelDataLength > RawSize)
if ( fp->fail() || fp->eof())
{
- gdcmVerboseMacro( "Reading of Raw pixel data failed." );
+ gdcmWarningMacro( "Reading of Raw pixel data failed." );
return false;
}
}
{
if ( ! RLEInfo->DecompressRLEFile( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) )
{
- gdcmVerboseMacro( "RLE decompressor failed." );
+ gdcmWarningMacro( "RLE decompressor failed." );
return false;
}
}
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- gdcmVerboseMacro( "JPEG decompressor failed." );
+ gdcmWarningMacro( "JPEG decompressor failed." );
return false;
}
}
return true;
}
+/// Deletes Pixels Area
void PixelReadConvert::Squeeze()
{
if ( RGB )
{
if ( IsJPEG2000 )
{
- gdcmVerboseMacro( "Sorry, JPEG2000 not yet taken into account" );
+ gdcmWarningMacro( "Sorry, JPEG2000 not yet taken into account" );
fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg);
// if ( ! gdcm_read_JPEG2000_file( fp,Raw ) )
return false;
if ( IsJPEGLS )
{
- gdcmVerboseMacro( "Sorry, JPEG-LS not yet taken into account" );
+ gdcmWarningMacro( "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;
&lengthR, &debR, &nbitsR );
if( nbRead != 3 )
{
- gdcmVerboseMacro( "Wrong Red LUT descriptor" );
+ gdcmWarningMacro( "Wrong Red LUT descriptor" );
}
int lengthG; // Green LUT length in Bytes
&lengthG, &debG, &nbitsG );
if( nbRead != 3 )
{
- gdcmVerboseMacro( "Wrong Green LUT descriptor" );
+ gdcmWarningMacro( "Wrong Green LUT descriptor" );
}
int lengthB; // Blue LUT length in Bytes
&lengthB, &debB, &nbitsB );
if( nbRead != 3 )
{
- gdcmVerboseMacro( "Wrong Blue LUT descriptor" );
+ gdcmWarningMacro( "Wrong Blue LUT descriptor" );
}
////////////////////////////////////////////////////////
}
break;
default:
- gdcmVerboseMacro("SwapCode value (16 bits) not allowed.");
+ gdcmWarningMacro("SwapCode value (16 bits) not allowed.");
}
}
else if( BitsAllocated == 32 )
}
break;
default:
- gdcmVerboseMacro("SwapCode value (32 bits) not allowed." );
+ gdcmWarningMacro("SwapCode value (32 bits) not allowed." );
}
}
}
}
else
{
- gdcmVerboseMacro("Weird image");
+ gdcmWarningMacro("Weird image");
throw FormatError( "Weird image !?" );
}
}
delete[] copyRaw;
}
+/// \brief Deals with the color decoding i.e. handle:
+/// - R, G, B planes (as opposed to RGB pixels)
+/// - YBR (various) encodings.
+/// - LUT[s] (or "PALETTE COLOR").
+
void PixelReadConvert::ConvertHandleColor()
{
//////////////////////////////////
// In *normal *case, when planarConf is 0, pixels are already in RGB
}
+/// Computes the Pixels Size
void PixelReadConvert::ComputeRawAndRGBSizes()
{
int bitsAllocated = BitsAllocated;
}
}
+/// Allocates room for RGB Pixels
void PixelReadConvert::AllocateRGB()
{
if ( RGB )
RGB = new uint8_t[RGBSize];
}
+/// Allocates room for RAW Pixels
void PixelReadConvert::AllocateRaw()
{
if ( Raw )
}
else
{
- gdcmVerboseMacro("Set as RLE file but NO RLEinfo present.");
+ gdcmWarningMacro("Set as RLE file but NO RLEinfo present.");
}
}
}
else
{
- gdcmVerboseMacro("Set as JPEG file but NO JPEGinfo present.");
+ gdcmWarningMacro("Set as JPEG file but NO JPEGinfo present.");
}
}
}