Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/11/28 15:20:34 $
- Version: $Revision: 1.103 $
+ Date: $Date: 2007/08/29 08:10:14 $
+ Version: $Revision: 1.117 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include <fstream>
#include <stdio.h> //for sscanf
-namespace gdcm
+#if defined(__BORLANDC__)
+ #include <mem.h> // for memset
+#endif
+
+namespace GDCM_NAME_SPACE
{
//bool ReadMPEGFile (std::ifstream *fp, char *inputdata, size_t lenght);
/**
* \brief Gets various usefull informations from the file header
* @param file gdcm::File pointer
+ * @param fileHelper gdcm::FileHelper pointer
*/
-void PixelReadConvert::GrabInformationsFromFile( File *file )
+void PixelReadConvert::GrabInformationsFromFile( File *file,
+ FileHelper *fileHelper )
{
// Number of Bits Allocated for storing a Pixel is defaulted to 16
// when absent from the file.
BitsAllocated = 16;
}
+ else if (BitsAllocated > 8 && BitsAllocated < 16 && BitsAllocated != 12)
+ {
+ BitsAllocated = 16;
+ }
// Number of "Bits Stored", defaulted to number of "Bits Allocated"
// when absent from the file.
BitsStored = file->GetBitsStored();
XSize = file->GetXSize();
YSize = file->GetYSize();
ZSize = file->GetZSize();
+ TSize = file->GetTSize();
SamplesPerPixel = file->GetSamplesPerPixel();
//PixelSize = file->GetPixelSize(); Useless
PixelSign = file->IsSignedPixelData();
SwapCode = file->GetSwapCode();
-
+
IsPrivateGETransferSyntax = IsMPEG
= IsJPEG2000 = IsJPEGLS = IsJPEGLossy
= IsJPEGLossless = IsRLELossless
= false;
-
+
if (! file->IsDicomV3() ) // Should be ACR-NEMA file
{
IsRaw = true;
std::string ts = file->GetTransferSyntax();
IsRaw = false;
- while (true) // short to write than if elseif elseif elseif ...
+ while (true) // shorter 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::ImplicitVRLittleEndian ) break;
if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian) break;
if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRBigEndianPrivateGE) break;
- if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian) break;
+ // DeflatedExplicitVRLittleEndian syntax means the whole Dataset (Header + Pixels) is compressed !
+ // Not dealt with ! (Parser hangs)
+ //if( IsRaw = Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian) break;
break;
}
// cache whether this is a strange GE transfer syntax (which uses
if( IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts) ) break;
if( IsMPEG = Global::GetTS()->IsMPEG(ts) ) break;
if( IsJPEGLS = Global::GetTS()->IsJPEGLS(ts) ) break;
- gdcmStaticWarningMacro("Unexpected Transfer Syntax :[" << ts << "]");
+ // DeflatedExplicitVRLittleEndian is considered as 'Unexpected' (we don't know yet how to process !)
+ gdcmWarningMacro("Unexpected Transfer Syntax :[" << ts << "]");
break;
}
}
LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
if ( ! LutRedData )
{
- gdcmStaticWarningMacro("Unable to read Red Palette Color Lookup Table data");
+ gdcmWarningMacro("Unable to read Red Palette Color Lookup Table data");
}
// //// Green round:
LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
if ( ! LutGreenData)
{
- gdcmStaticWarningMacro("Unable to read Green Palette Color Lookup Table data");
+ gdcmWarningMacro("Unable to read Green Palette Color Lookup Table data");
}
// //// Blue round:
LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
if ( ! LutBlueData )
{
- gdcmStaticWarningMacro("Unable to read Blue Palette Color Lookup Table data");
+ gdcmWarningMacro("Unable to read Blue Palette Color Lookup Table data");
}
}
FileInternal = file;
-
+ FH = fileHelper;
ComputeRawAndRGBSizes();
}
//// First stage: get our hands on the Pixel Data.
if ( !fp )
{
- gdcmStaticWarningMacro( "Unavailable file pointer." );
+ gdcmWarningMacro( "Unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
if ( fp->fail() || fp->eof() )
{
- gdcmStaticWarningMacro( "Unable to find PixelOffset in file." );
+ gdcmWarningMacro( "Unable to find PixelOffset in file." );
return false;
}
AllocateRaw();
//////////////////////////////////////////////////
+
+ CallStartMethod(); // for progress bar
+ unsigned int count = 0;
+ unsigned int frameSize;
+ unsigned int bitsAllocated = BitsAllocated;
+ //if(bitsAllocated == 12)
+ if(bitsAllocated > 8 && bitsAllocated < 16)
+ bitsAllocated = 16;
+ frameSize = XSize*YSize*SamplesPerPixel*bitsAllocated/8;
+
//// Second stage: read from disk and decompress.
- if ( BitsAllocated == 12 )
+
+ if ( BitsAllocated == 12 ) // We suppose 'BitsAllocated' = 12 only exist for uncompressed files
{
ReadAndDecompress12BitsTo16Bits( fp);
}
// variable). But RawSize is the right size of the image !
if ( PixelDataLength != RawSize )
{
- gdcmStaticWarningMacro( "Mismatch between PixelReadConvert : "
- << PixelDataLength << " and RawSize : " << RawSize );
+ gdcmWarningMacro( "Mismatch between PixelReadConvert : "
+ << PixelDataLength << " and RawSize : " << RawSize );
}
+
+ //todo : is it the right patch?
+ char *raw = (char*)Raw;
+ uint32_t remainingLength;
+ unsigned int i;
+ unsigned int lengthToRead;
+
if ( PixelDataLength > RawSize )
- {
- fp->read( (char*)Raw, RawSize);
- }
+ lengthToRead = RawSize;
else
+ lengthToRead = PixelDataLength;
+
+ // perform a frame by frame reading
+ remainingLength = lengthToRead;
+ unsigned int nbFrames = lengthToRead / frameSize;
+ for (i=0;i<nbFrames; i++)
{
- fp->read( (char*)Raw, PixelDataLength);
+ Progress = (float)(count+1)/(float)nbFrames;
+ fp->read( raw, frameSize);
+ raw += frameSize;
+ remainingLength -= frameSize;
+ count++;
}
-
+ if (remainingLength !=0 )
+ fp->read( raw, remainingLength);
+
if ( fp->fail() || fp->eof())
{
- gdcmStaticWarningMacro( "Reading of Raw pixel data failed." );
+ gdcmWarningMacro( "Reading of Raw pixel data failed." );
return false;
}
}
else if ( IsRLELossless )
{
if ( ! RLEInfo->DecompressRLEFile
- ( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) )
+ ( fp, Raw, XSize, YSize, ZSize, TSize, BitsAllocated ) )
{
- gdcmStaticWarningMacro( "RLE decompressor failed." );
+ gdcmWarningMacro( "RLE decompressor failed." );
return false;
}
}
else if ( IsMPEG )
{
- //gdcmStaticWarningMacro( "Sorry, MPEG not yet taken into account" );
+ //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" );
//return false;
// fp has already been seek to start of mpeg
//ReadMPEGFile(fp, (char*)Raw, PixelDataLength);
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- gdcmStaticWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()"
+ gdcmWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()"
<< " method ) failed." );
return false;
}
return false;
}
- gdcmStaticDebugMacro( "--> BuildRGBImage" );
+ gdcmDebugMacro( "--> BuildRGBImage" );
// Build RGB Pixels
AllocateRGB();
void PixelReadConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream *fp )
throw ( FormatError )
{
- int nbPixels = XSize * YSize;
+ /// \todo Fix the 3D, 4D pb
+ int nbPixels = XSize * YSize * TSize;
uint16_t *localDecompres = (uint16_t*)Raw;
for( int p = 0; p < nbPixels; p += 2 )
inputlength += jpegfrag->GetLength();
jpegfrag = JPEGInfo->GetNextFragment();
}
- gdcmStaticAssertMacro( inputlength != 0);
+ gdcmAssertMacro( 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
- gdcmStaticWarningMacro( "gdcm_read_JPEG2000_file() failed ");
+ gdcmWarningMacro( "gdcm_read_JPEG2000_file() failed ");
return false;
}
else if ( IsJPEGLS )
inputlength += jpegfrag->GetLength();
jpegfrag = JPEGInfo->GetNextFragment();
}
- gdcmStaticAssertMacro( inputlength != 0);
+ gdcmAssertMacro( inputlength != 0);
uint8_t *inputdata = new uint8_t[inputlength];
char *pinputdata = (char*)inputdata;
jpegfrag = JPEGInfo->GetFirstFragment();
delete[] inputdata;
#endif
- gdcmStaticWarningMacro( "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;
// make sure this is the right JPEG compression
assert( !IsJPEGLS || !IsJPEG2000 );
// Precompute the offset localRaw will be shifted with
- int length = XSize * YSize * SamplesPerPixel;
+ int length = XSize * YSize * ZSize * SamplesPerPixel;
int numberBytes = BitsAllocated / 8;
-
+
JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length );
return true;
}
* and
* - (0028,1101),(0028,1102),(0028,1102)
* xxx Palette Color Lookup Table Descriptor are found
- * and
+ * and
* - (0028,1201),(0028,1202),(0028,1202)
* xxx Palette Color Lookup Table Data - are found
* \warning does NOT deal with :
|| LutGreenDescriptor == GDCM_UNFOUND
|| LutBlueDescriptor == GDCM_UNFOUND )
{
- gdcmStaticWarningMacro( "(At least) a LUT Descriptor is missing" );
+ gdcmWarningMacro( "(At least) a LUT Descriptor is missing" );
return;
}
&lengthR, &debR, &nbitsR );
if ( nbRead != 3 )
{
- gdcmStaticWarningMacro( "Wrong Red LUT descriptor" );
+ gdcmWarningMacro( "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 )
{
- gdcmStaticWarningMacro( "Wrong Green LUT descriptor" );
+ gdcmWarningMacro( "Wrong Green LUT descriptor" );
}
int lengthB; // Blue LUT length in Bytes
&lengthB, &debB, &nbitsB );
if ( nbRead != 3 )
{
- gdcmStaticWarningMacro( "Wrong Blue LUT descriptor" );
+ gdcmWarningMacro( "Wrong Blue LUT descriptor" );
}
- gdcmStaticDebugMacro(" lengthR " << lengthR << " debR "
- << debR << " nbitsR " << nbitsR);
- gdcmStaticDebugMacro(" lengthG " << lengthG << " debG "
- << debG << " nbitsG " << nbitsG);
- gdcmStaticDebugMacro(" lengthB " << lengthB << " debB "
- << debB << " nbitsB " << nbitsB);
+ gdcmDebugMacro(" lengthR " << lengthR << " debR "
+ << debR << " nbitsR " << nbitsR);
+ gdcmDebugMacro(" lengthG " << lengthG << " debG "
+ << debG << " nbitsG " << nbitsG);
+ gdcmDebugMacro(" lengthB " << lengthB << " debB "
+ << debB << " nbitsB " << nbitsB);
if ( !lengthR ) // if = 2^16, this shall be 0 see : CP-143
lengthR=65536;
if ( ( ! LutRedData ) || ( ! LutGreenData ) || ( ! LutBlueData ) )
{
- gdcmStaticWarningMacro( "(At least) a LUT is missing" );
+ gdcmWarningMacro( "(At least) a LUT is missing" );
return;
}
// with 65536 entries LUT ?!?
// Still looking for accurate info on the web :-(
- gdcmStaticWarningMacro( "Sorry Palette Color Lookup Tables not yet dealt with"
+ gdcmWarningMacro( "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;
-
+
// If this file is 'ImplicitVR BigEndian PrivateGE Transfer Syntax',
// then the header is in little endian format and the pixel data is in
// big endian format. When reading the header, GDCM has already established
}
break;
default:
- gdcmStaticWarningMacro("SwapCode value (16 bits) not allowed."
+ gdcmWarningMacro("SwapCode value (16 bits) not allowed."
<< tempSwapCode);
}
}
}
break;
default:
- gdcmStaticWarningMacro("SwapCode value (32 bits) not allowed." << tempSwapCode );
+ gdcmWarningMacro("SwapCode value (32 bits) not allowed." << tempSwapCode );
}
}
}
}
else
{
- gdcmStaticWarningMacro("Weird image (BitsAllocated !=8, 12, 16, 32)");
+ gdcmWarningMacro("Weird image (BitsAllocated !=8, 12, 16, 32)");
throw FormatError( "Weird image !?" );
}
}
*/
void PixelReadConvert::ConvertRGBPlanesToRGBPixels()
{
- gdcmStaticWarningMacro("--> ConvertRGBPlanesToRGBPixels");
+ gdcmWarningMacro("--> 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.
- gdcmStaticWarningMacro("--> ConvertYcBcRPlanesToRGBPixels");
+ gdcmWarningMacro("--> ConvertYcBcRPlanesToRGBPixels");
uint8_t *localRaw = Raw;
uint8_t *copyRaw = new uint8_t[ RawSize ];
// ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf
// and be *very* affraid
//
- int l = XSize * YSize;
+
+ /// \todo : find an example to see how 3rd dim and 4th dim work together
+ int l = XSize * YSize * TSize;
int nbFrames = ZSize;
uint8_t *a = copyRaw + 0;
// - [Planar 1] AND [Photo C] handled with ConvertYcBcRPlanesToRGBPixels()
// - [Planar 2] OR [Photo D] requires LUT intervention.
- gdcmStaticDebugMacro("--> ConvertHandleColor "
+ gdcmDebugMacro("--> ConvertHandleColor "
<< "Planar Configuration " << PlanarConfiguration );
if ( ! IsRawRGB() )
{
// [Planar 2] OR [Photo D]: LUT intervention done outside
- gdcmStaticDebugMacro("--> RawRGB : LUT intervention done outside");
+ gdcmDebugMacro("--> RawRGB : LUT intervention done outside");
return;
}
if ( IsYBRFull )
{
// [Planar 1] AND [Photo C] (remember YBR_FULL_422 acts as RGB)
- gdcmStaticDebugMacro("--> YBRFull");
+ gdcmDebugMacro("--> YBRFull");
ConvertYcBcRPlanesToRGBPixels();
}
else
{
// [Planar 1] AND [Photo C]
- gdcmStaticDebugMacro("--> YBRFull");
+ gdcmDebugMacro("--> YBRFull");
ConvertRGBPlanesToRGBPixels();
}
return;
if (IsRLELossless)
{
- gdcmStaticDebugMacro("--> RLE Lossless");
+ gdcmDebugMacro("--> RLE Lossless");
ConvertRGBPlanesToRGBPixels();
}
bitsAllocated = 16;
}
- RawSize = XSize * YSize * ZSize
+ RawSize = XSize * YSize * ZSize * TSize
* ( bitsAllocated / 8 )
* SamplesPerPixel;
if ( HasLUT )
else
{
RGBSize = RawSize;
+
}
+ RawSize += RawSize%2;
+ RGBSize += RGBSize%2;
}
/// Allocates room for RGB Pixels
}
else
{
- gdcmStaticWarningMacro("Set as RLE file but NO RLEinfo present.");
+ gdcmWarningMacro("Set as RLE file but NO RLEinfo present.");
}
}
}
else
{
- gdcmStaticWarningMacro("Set as JPEG file but NO JPEGinfo present.");
+ gdcmWarningMacro("Set as JPEG file but NO JPEGinfo present.");
}
}
}
+/**
+ * \brief CallStartMethod
+ */
+void PixelReadConvert::CallStartMethod()
+{
+ Progress = 0.0f;
+ Abort = false;
+ CommandManager::ExecuteCommand(FH,CMD_STARTPROGRESS);
+}
+
+/**
+ * \brief CallProgressMethod
+ */
+void PixelReadConvert::CallProgressMethod()
+{
+ CommandManager::ExecuteCommand(FH,CMD_PROGRESS);
+}
+
+/**
+ * \brief CallEndMethod
+ */
+void PixelReadConvert::CallEndMethod()
+{
+ Progress = 1.0f;
+ CommandManager::ExecuteCommand(FH,CMD_ENDPROGRESS);
+}
+
+
//-----------------------------------------------------------------------------
} // end namespace gdcm