Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/01/06 13:35:38 $
- Version: $Revision: 1.13 $
+ Date: $Date: 2005/01/07 19:20:38 $
+ Version: $Revision: 1.16 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#define JOCTET uint8_t
// For JPEG 8 Bits, body in file gdcmJpeg8.cxx
-bool gdcm_read_JPEG_file8 (std::ifstream* fp, void* image_buffer);
-bool gdcm_read_JPEG_memory8 (const JOCTET* buffer, const size_t buflen,
- void* image_buffer,
+bool gdcm_read_JPEG_file8 (std::ifstream *fp, void *image_buffer);
+bool gdcm_read_JPEG_memory8 (const JOCTET *buffer, const size_t buflen,
+ void *image_buffer,
size_t *howManyRead, size_t *howManyWritten);
//
// For JPEG 12 Bits, body in file gdcmJpeg12.cxx
-bool gdcm_read_JPEG_file12 (std::ifstream* fp, void* image_buffer);
+bool gdcm_read_JPEG_file12 (std::ifstream *fp, void *image_buffer);
bool gdcm_read_JPEG_memory12 (const JOCTET *buffer, const size_t buflen,
- void* image_buffer,
+ void *image_buffer,
size_t *howManyRead, size_t *howManyWritten);
// For JPEG 16 Bits, body in file gdcmJpeg16.cxx
// Beware this is misleading there is no 16bits DCT algorithm, only
// jpeg lossless compression exist in 16bits.
-bool gdcm_read_JPEG_file16 (std::ifstream* fp, void* image_buffer);
+bool gdcm_read_JPEG_file16 (std::ifstream *fp, void *image_buffer);
bool gdcm_read_JPEG_memory16 (const JOCTET *buffer, const size_t buflen,
void* image_buffer,
size_t *howManyRead, size_t *howManyWritten);
* \brief Read from file a 12 bits per pixel image and decompress it
* into a 16 bits per pixel image.
*/
-void PixelReadConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream* fp )
+void PixelReadConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream *fp )
throw ( FormatError )
{
int nbPixels = XSize * YSize;
* @param fp File Pointer: on entry the position should be the one of
* the fragment to be decoded.
*/
-bool PixelReadConvert::ReadAndDecompressRLEFragment( uint8_t* subRaw,
+bool PixelReadConvert::ReadAndDecompressRLEFragment( uint8_t *subRaw,
long fragmentSize,
long RawSegmentSize,
- std::ifstream* fp )
+ std::ifstream *fp )
{
int8_t count;
long numberOfOutputBytes = 0;
if ( numberOfReadBytes > fragmentSize )
{
- dbg.Verbose(0, "PixelReadConvert::ReadAndDecompressRLEFragment: we "
+ gdcmVerboseMacro("PixelReadConvert::ReadAndDecompressRLEFragment: we "
"read more bytes than the segment size.");
return false;
}
* at which the pixel data should be copied
* @return Boolean
*/
-bool PixelReadConvert::ReadAndDecompressRLEFile( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressRLEFile( std::ifstream *fp )
{
- uint8_t* subRaw = Raw;
+ uint8_t *subRaw = Raw;
long RawSegmentSize = XSize * YSize;
// Loop on the frame[s]
if( BitsAllocated == 16 )
{
- uint16_t* im16 = (uint16_t*)Raw;
+ uint16_t *im16 = (uint16_t*)Raw;
switch( SwapCode )
{
case 0:
}
break;
default:
- dbg.Verbose( 0, "PixelReadConvert::ConvertSwapZone: SwapCode value "
+ gdcmVerboseMacro( "PixelReadConvert::ConvertSwapZone: SwapCode value "
"(16 bits) not allowed." );
}
}
}
break;
default:
- dbg.Verbose( 0, "PixelReadConvert::ConvertSwapZone: SwapCode value "
+ gdcmVerboseMacro( "PixelReadConvert::ConvertSwapZone: SwapCode value "
"(32 bits) not allowed." );
}
}
* @param fp File Pointer
* @return Boolean
*/
-bool PixelReadConvert::ReadAndDecompressJPEGFramesFromFile( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressJPEGFramesFromFile( std::ifstream *fp )
{
- uint8_t* localRaw = Raw;
+ uint8_t *localRaw = Raw;
// Loop on the fragment[s]
for( JPEGFragmentsInfo::JPEGFragmentsList::iterator
it = JPEGInfo->Fragments.begin();
else
{
// other JPEG lossy not supported
- dbg.Error("PixelReadConvert::ReadAndDecompressJPEGFile: unknown "
+ gdcmErrorMacro("PixelReadConvert::ReadAndDecompressJPEGFile: unknown "
"jpeg lossy compression ");
return false;
}
* @return Boolean
*/
bool PixelReadConvert::
-ReadAndDecompressJPEGSingleFrameFragmentsFromFile( std::ifstream* fp )
+ReadAndDecompressJPEGSingleFrameFragmentsFromFile( std::ifstream *fp )
{
// Loop on the fragment[s] to get total length
size_t totalLength = 0;
if ( ! gdcm_read_JPEG_memory8( buffer, totalLength, Raw,
&howManyRead, &howManyWritten ) )
{
- dbg.Error(
+ gdcmErrorMacro(
"PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg8 "
);
delete [] buffer;
if ( ! gdcm_read_JPEG_memory12( buffer, totalLength, Raw,
&howManyRead, &howManyWritten ) )
{
- dbg.Error(
+ gdcmErrorMacro(
"PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg12 "
);
delete [] buffer;
if ( ! gdcm_read_JPEG_memory16( buffer, totalLength, Raw,
&howManyRead, &howManyWritten ) )
{
- dbg.Error(
+ gdcmErrorMacro(
"PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg16 "
);
delete [] buffer;
else
{
// other JPEG lossy not supported
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: unknown "
+ gdcmErrorMacro("PixelConvert::ReadAndDecompressJPEGFile: unknown "
"jpeg lossy compression ");
delete [] buffer;
return false;
* @return Boolean
*/
bool PixelReadConvert::
-ReadAndDecompressJPEGFragmentedFramesFromFile( std::ifstream* fp )
+ReadAndDecompressJPEGFragmentedFramesFromFile( std::ifstream *fp )
{
// Loop on the fragment[s] to get total length
size_t totalLength = 0;
Raw+howManyWritten,
&howManyRead, &howManyWritten ) )
{
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg8 ");
+ gdcmErrorMacro("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg8 ");
delete [] buffer;
return false;
}
Raw+howManyWritten,
&howManyRead, &howManyWritten ) )
{
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg12 ");
+ gdcmErrorMacro("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg12 ");
delete [] buffer;
return false;
}
Raw+howManyWritten,
&howManyRead, &howManyWritten ) )
{
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg16 ");
+ gdcmErrorMacro("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg16 ");
delete [] buffer;
return false;
}
else
{
// other JPEG lossy not supported
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: unknown "
+ gdcmErrorMacro("PixelConvert::ReadAndDecompressJPEGFile: unknown "
"jpeg lossy compression ");
delete [] buffer;
return false;
* @param fp File Pointer
* @return Boolean
*/
-bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream *fp )
{
if ( IsJPEG2000 )
{
}
else
{
- dbg.Verbose(0, "PixelReadConvert::ConvertReArrangeBits: weird image");
+ gdcmVerboseMacro("PixelReadConvert::ConvertReArrangeBits: weird image");
throw FormatError( "PixelReadConvert::ConvertReArrangeBits()",
"weird image !?" );
}
*/
void PixelReadConvert::ConvertYcBcRPlanesToRGBPixels()
{
- uint8_t* localRaw = Raw;
- uint8_t* copyRaw = new uint8_t[ RawSize ];
+ uint8_t *localRaw = Raw;
+ uint8_t *copyRaw = new uint8_t[ RawSize ];
memmove( copyRaw, localRaw, RawSize );
// to see the tricks about YBR_FULL, YBR_FULL_422,
int l = XSize * YSize;
int nbFrames = ZSize;
- uint8_t* a = copyRaw;
- uint8_t* b = copyRaw + l;
- uint8_t* c = copyRaw + l + l;
+ uint8_t *a = copyRaw;
+ uint8_t *b = copyRaw + l;
+ uint8_t *c = copyRaw + l + l;
double R, G, B;
/// \todo : Replace by the 'well known' integer computation
*/
void PixelReadConvert::ConvertRGBPlanesToRGBPixels()
{
- uint8_t* localRaw = Raw;
- uint8_t* copyRaw = new uint8_t[ RawSize ];
+ uint8_t *localRaw = Raw;
+ uint8_t *copyRaw = new uint8_t[ RawSize ];
memmove( copyRaw, localRaw, RawSize );
int l = XSize * YSize * ZSize;
delete[] copyRaw;
}
-bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp )
{
// ComputeRawAndRGBSizes is already made by
// ::GrabInformationsFromHeader. So, the structure sizes are
//// First stage: get our hands on the Pixel Data.
if ( !fp )
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ gdcmVerboseMacro( "PixelReadConvert::ReadAndDecompressPixelData: "
"unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
if( fp->fail() || fp->eof()) //Fp->gcount() == 1
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ gdcmVerboseMacro( "PixelReadConvert::ReadAndDecompressPixelData: "
"unable to find PixelOffset in file." );
return false;
}
// variable). But RawSize is the right size of the image !
if( PixelDataLength != RawSize)
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ gdcmVerboseMacro( "PixelReadConvert::ReadAndDecompressPixelData: "
"Mismatch between PixelReadConvert and RawSize." );
}
if( PixelDataLength > RawSize)
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ gdcmVerboseMacro( "PixelReadConvert::ReadAndDecompressPixelData: "
"reading of Raw pixel data failed." );
return false;
}
{
if ( ! ReadAndDecompressRLEFile( fp ) )
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ gdcmVerboseMacro( "PixelReadConvert::ReadAndDecompressPixelData: "
"RLE decompressor failed." );
return false;
}
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ gdcmVerboseMacro( "PixelReadConvert::ReadAndDecompressPixelData: "
"JPEG decompressor failed." );
return false;
}
}
}
-void PixelReadConvert::GrabInformationsFromHeader( Header* header )
+void PixelReadConvert::GrabInformationsFromHeader( Header *header )
{
// Number of Bits Allocated for storing a Pixel is defaulted to 16
// when absent from the header.
LutRedData = (uint8_t*)header->GetEntryBinAreaByNumber( 0x0028, 0x1201 );
if ( ! LutRedData )
{
- dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
+ gdcmVerboseMacro("PixelReadConvert::GrabInformationsFromHeader: "
"unable to read red LUT data" );
}
LutGreenData = (uint8_t*)header->GetEntryBinAreaByNumber(0x0028, 0x1202 );
if ( ! LutGreenData)
{
- dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
+ gdcmVerboseMacro("PixelReadConvert::GrabInformationsFromHeader: "
"unable to read green LUT data" );
}
LutBlueData = (uint8_t*)header->GetEntryBinAreaByNumber( 0x0028, 0x1203 );
if ( ! LutBlueData )
{
- dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
+ gdcmVerboseMacro("PixelReadConvert::GrabInformationsFromHeader: "
"unable to read blue LUT data" );
}
}
&lengthR, &debR, &nbitsR );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong red LUT descriptor");
+ gdcmVerboseMacro("PixelReadConvert::BuildLUTRGBA: wrong red LUT descriptor");
}
int lengthG; // Green LUT length in Bytes
&lengthG, &debG, &nbitsG );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong green LUT descriptor");
+ gdcmVerboseMacro("PixelReadConvert::BuildLUTRGBA: wrong green LUT descriptor");
}
int lengthB; // Blue LUT length in Bytes
&lengthB, &debB, &nbitsB );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong blue LUT descriptor");
+ gdcmVerboseMacro("PixelReadConvert::BuildLUTRGBA: wrong blue LUT descriptor");
}
////////////////////////////////////////////////////////
}
else
{
- dbg.Verbose(0, "PixelReadConvert::Print: set as RLE file "
+ gdcmVerboseMacro("PixelReadConvert::Print: set as RLE file "
"but NO RLEinfo present.");
}
}
}
else
{
- dbg.Verbose(0, "PixelReadConvert::Print: set as JPEG file "
+ gdcmVerboseMacro("PixelReadConvert::Print: set as JPEG file "
"but NO JPEGinfo present.");
}
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff