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/12 15:22:23 $
+ Version: $Revision: 1.25 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmDebug.h"
#include "gdcmHeader.h"
+#include "gdcmGlobal.h"
+#include "gdcmTS.h"
#include "gdcmPixelReadConvert.h"
#include "gdcmDocEntry.h"
#include "gdcmRLEFramesInfo.h"
#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;
/**
* \brief Try to deal with RLE 16 Bits.
- * We assume the RLE has allready been parsed and loaded in
+ * We assume the RLE has already been parsed and loaded in
* Raw (through \ref ReadAndDecompressJPEGFile ).
* We here need to make 16 Bits Pixels from Low Byte and
* High Byte 'Planes'...(for what it may mean)
* @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 "
- "read more bytes than the segment size.");
+ gdcmVerboseMacro( "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:
- case 12:
case 1234:
break;
- case 21:
case 3412:
case 2143:
case 4321:
}
break;
default:
- dbg.Verbose( 0, "PixelReadConvert::ConvertSwapZone: SwapCode value "
- "(16 bits) not allowed." );
+ gdcmVerboseMacro("SwapCode value (16 bits) not allowed.");
}
}
else if( BitsAllocated == 32 )
uint32_t* im32 = (uint32_t*)Raw;
switch ( SwapCode )
{
- case 0:
case 1234:
break;
case 4321:
}
break;
default:
- dbg.Verbose( 0, "PixelReadConvert::ConvertSwapZone: SwapCode value "
- "(32 bits) not allowed." );
+ gdcmVerboseMacro("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();
{
return false;
}
- //assert( IsJPEGLossless );
+ //gdcmAssertMacro( IsJPEGLossless );
}
else
{
// other JPEG lossy not supported
- dbg.Error("PixelReadConvert::ReadAndDecompressJPEGFile: unknown "
- "jpeg lossy compression ");
+ gdcmErrorMacro( "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(
- "PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg8 "
- );
+ gdcmErrorMacro( "Failed to read jpeg8 ");
delete [] buffer;
return false;
}
if ( ! gdcm_read_JPEG_memory12( buffer, totalLength, Raw,
&howManyRead, &howManyWritten ) )
{
- dbg.Error(
- "PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg12 "
- );
+ gdcmErrorMacro( "Failed to read jpeg12 ");
delete [] buffer;
return false;
}
if ( ! gdcm_read_JPEG_memory16( buffer, totalLength, Raw,
&howManyRead, &howManyWritten ) )
{
- dbg.Error(
- "PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg16 "
- );
+ gdcmErrorMacro( "Failed to read jpeg16 ");
delete [] buffer;
return false;
}
else
{
// other JPEG lossy not supported
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: unknown "
- "jpeg lossy compression ");
+ gdcmErrorMacro( "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( "Failed to read jpeg8");
delete [] buffer;
return false;
}
Raw+howManyWritten,
&howManyRead, &howManyWritten ) )
{
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg12 ");
+ gdcmErrorMacro( "Failed to read jpeg12");
delete [] buffer;
return false;
}
Raw+howManyWritten,
&howManyRead, &howManyWritten ) )
{
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: failed to read jpeg16 ");
+ gdcmErrorMacro( "Failed to read jpeg16 ");
delete [] buffer;
return false;
}
else
{
// other JPEG lossy not supported
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: unknown "
- "jpeg lossy compression ");
+ gdcmErrorMacro( "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");
- throw FormatError( "PixelReadConvert::ConvertReArrangeBits()",
- "weird image !?" );
+ gdcmVerboseMacro("Weird image");
+ throw FormatError( "Weird image !?" );
}
}
return true;
*/
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: "
- "unavailable file pointer." );
+ gdcmVerboseMacro( "Unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
- if( fp->fail() || fp->eof()) //Fp->gcount() == 1
+ if( fp->fail() || fp->eof())
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
- "unable to find PixelOffset in file." );
+ gdcmVerboseMacro( "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: "
- "Mismatch between PixelReadConvert and RawSize." );
+ gdcmVerboseMacro( "Mismatch between PixelReadConvert and RawSize." );
}
if( PixelDataLength > RawSize)
{
fp->read( (char*)Raw, PixelDataLength);
}
- if ( fp->fail() || fp->eof())//Fp->gcount() == 1
+ if ( fp->fail() || fp->eof())
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
- "reading of Raw pixel data failed." );
+ gdcmVerboseMacro( "Reading of Raw pixel data failed." );
return false;
}
}
{
if ( ! ReadAndDecompressRLEFile( fp ) )
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
- "RLE decompressor failed." );
+ gdcmVerboseMacro( "RLE decompressor failed." );
return false;
}
}
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
- "JPEG decompressor failed." );
+ gdcmVerboseMacro( "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.
PixelSize = header->GetPixelSize();
PixelSign = header->IsSignedPixelData();
SwapCode = header->GetSwapCode();
- TransferSyntaxType ts = header->GetTransferSyntax();
+ std::string ts = header->GetTransferSyntax();
IsRaw =
( ! header->IsDicomV3() )
- || ts == ImplicitVRLittleEndian
- || ts == ImplicitVRLittleEndianDLXGE
- || ts == ExplicitVRLittleEndian
- || ts == ExplicitVRBigEndian
- || ts == DeflatedExplicitVRLittleEndian;
- IsJPEG2000 = header->IsJPEG2000();
- IsJPEGLossless = header->IsJPEGLossless();
- IsRLELossless = ( ts == RLELossless );
+ || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian
+ || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndianDLXGE
+ || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRLittleEndian
+ || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian
+ || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian;
+ IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts);
+ IsJPEGLossless = Global::GetTS()->IsJPEGLossless(ts);
+ IsRLELossless = Global::GetTS()->IsRLELossless(ts);
PixelOffset = header->GetPixelOffset();
PixelDataLength = header->GetPixelAreaLength();
RLEInfo = header->GetRLEInfo();
if ( HasLUT )
{
// Just in case some access to a Header element requires disk access.
- LutRedDescriptor = header->GetEntryByNumber( 0x0028, 0x1101 );
- LutGreenDescriptor = header->GetEntryByNumber( 0x0028, 0x1102 );
- LutBlueDescriptor = header->GetEntryByNumber( 0x0028, 0x1103 );
+ LutRedDescriptor = header->GetEntry( 0x0028, 0x1101 );
+ LutGreenDescriptor = header->GetEntry( 0x0028, 0x1102 );
+ LutBlueDescriptor = header->GetEntry( 0x0028, 0x1103 );
// Depending on the value of Document::MAX_SIZE_LOAD_ELEMENT_VALUE
// [ refer to invocation of Document::SetMaxSizeLoadEntry() in
////// Red round
header->LoadEntryBinArea(0x0028, 0x1201);
- LutRedData = (uint8_t*)header->GetEntryBinAreaByNumber( 0x0028, 0x1201 );
+ LutRedData = (uint8_t*)header->GetEntryBinArea( 0x0028, 0x1201 );
if ( ! LutRedData )
{
- dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
- "unable to read red LUT data" );
+ gdcmVerboseMacro( "Unable to read red LUT data" );
}
////// Green round:
header->LoadEntryBinArea(0x0028, 0x1202);
- LutGreenData = (uint8_t*)header->GetEntryBinAreaByNumber(0x0028, 0x1202 );
+ LutGreenData = (uint8_t*)header->GetEntryBinArea(0x0028, 0x1202 );
if ( ! LutGreenData)
{
- dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
- "unable to read green LUT data" );
+ gdcmVerboseMacro( "Unable to read green LUT data" );
}
////// Blue round:
header->LoadEntryBinArea(0x0028, 0x1203);
- LutBlueData = (uint8_t*)header->GetEntryBinAreaByNumber( 0x0028, 0x1203 );
+ LutBlueData = (uint8_t*)header->GetEntryBinArea( 0x0028, 0x1203 );
if ( ! LutBlueData )
{
- dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
- "unable to read blue LUT data" );
+ gdcmVerboseMacro( "Unable to read blue LUT data" );
}
}
&lengthR, &debR, &nbitsR );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong red LUT descriptor");
+ gdcmVerboseMacro( "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( "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( "Wrong blue LUT descriptor" );
}
////////////////////////////////////////////////////////
}
else
{
- dbg.Verbose(0, "PixelReadConvert::Print: set as RLE file "
- "but NO RLEinfo present.");
+ gdcmVerboseMacro("Set as RLE file but NO RLEinfo present.");
}
}
}
else
{
- dbg.Verbose(0, "PixelReadConvert::Print: set as JPEG file "
- "but NO JPEGinfo present.");
+ gdcmVerboseMacro("Set as JPEG file but NO JPEGinfo present.");
}
}
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff