Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/10/25 17:54:55 $
- Version: $Revision: 1.87 $
+ Date: $Date: 2008/05/20 09:22:03 $
+ Version: $Revision: 1.128 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmDocEntry.h"
#include "gdcmRLEFramesInfo.h"
#include "gdcmJPEGFragmentsInfo.h"
+#include "gdcmSegmentedPalette.h"
#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, void *image_buffer, 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);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Constructor / Destructor
/// Constructor
-PixelReadConvert::PixelReadConvert()
+PixelReadConvert::PixelReadConvert()
{
RGB = 0;
RGBSize = 0;
// Public
/**
* \brief Predicate to know whether the image[s] (once Raw) is RGB.
- * \note See comments of \ref ConvertHandleColor
+ * \note See comments of ConvertHandleColor
*/
bool PixelReadConvert::IsRawRGB()
{
/**
* \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.
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();
- std::string ts = file->GetTransferSyntax();
- if ( ts == GDCM_UNKNOWN )
- gdcmErrorMacro( "Could someone tell me how in the world could this happen !" );
- IsRaw =
- ( ! file->IsDicomV3() )
- || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian
- || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRBigEndianPrivateGE
- || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRLittleEndian
- || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian
- || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian;
-
- IsPrivateGETransferSyntax =
+
+ 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) // 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;
+ // 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
+ // 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 = Global::GetTS()->IsMPEG(ts);
- IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts);
- IsJPEGLS = Global::GetTS()->IsJPEGLS(ts);
- IsJPEGLossy = Global::GetTS()->IsJPEGLossy(ts);
- IsJPEGLossless = Global::GetTS()->IsJPEGLossless(ts);
- IsRLELossless = Global::GetTS()->IsRLELossless(ts);
+ IsMPEG = IsJPEG2000 = IsJPEGLS = IsJPEGLossy = IsJPEGLossless = IsRLELossless = false;
+ if (!IsRaw)
+ {
+ while(true)
+ {
+ // mind the order : check the most usual first.
+ if( IsJPEGLossy = (Global::GetTS()->IsJPEGLossy(ts))) break;
+ if( IsJPEGLossless = (Global::GetTS()->IsJPEGLossless(ts))) break;
+ if( IsRLELossless = (Global::GetTS()->IsRLELossless(ts))) break;
+ if( IsJPEG2000 = (Global::GetTS()->IsJPEG2000(ts))) break;
+ if( IsMPEG = (Global::GetTS()->IsMPEG(ts))) break;
+ if( IsJPEGLS = (Global::GetTS()->IsJPEGLS(ts))) break;
+ // DeflatedExplicitVRLittleEndian is considered as 'Unexpected'
+ // (we don't know yet how to process !)
+ gdcmWarningMacro("Unexpected Transfer Syntax :[" << ts << "]");
+ break;
+ }
+ }
+ }
PixelOffset = file->GetPixelOffset();
PixelDataLength = file->GetPixelAreaLength();
HasLUT = file->HasLUT();
if ( HasLUT )
{
- // Just in case some access to a File element requires disk access.
+/*
+ C.7.6.3.1.5
+ The three values of Palette Color Lookup Table Descriptor (0028,1101-1103)
+ describe the format of the Lookup Table Data in the corresponding
+ Data Element (0028,1201-1203) or (0028,1221-1223).
+
+ The first value is the number of entries in the lookup table.
+ When the number of table entries is equal to 2**16 then this value shall be 0.
+
+ The second value is the first stored pixel value mapped.
+ This pixel value is mapped to the first entry in the Lookup Table Data.
+ All image pixel values less than the first entry value mapped are also
+ mapped to the first entry in the Lookup Table Data.
+ An image pixel value one greater than the first entry value mapped is
+ mapped to the second entry in the Lookup Table Data.
+ Subsequent image pixel values are mapped to the subsequent entries in
+ the Lookup Table Data up to an image pixel value equal to number of
+ entries + first entry value mapped - 1 which is mapped to the last entry
+ in the Lookup Table Data.
+ Image pixel values greater than or equal to number of entries + first entry
+ value mapped are also mapped to the last entry in the Lookup Table Data.
+
+ The third value specifies the number of bits for each entry in the Lookup
+ Table Data. It shall take the value of 8 or 16.
+ The LUT Data shall be stored in a format equivalent to 8 or 16 bits
+ allocated where the high bit is equal to bits allocated-1.
+
+ When the Palette Color Lookup Table Descriptor (0028,1101-1103) are used as
+ part of the Palette Color Lookup Table Module, the third value shall be
+ equal to 16.
+
+ Note: A value of 16 indicates the Lookup Table Data will range from (0,0,0)
+ minimum intensity to (65535,65535,65535) maximum intensity.
+
+*/
+
+ // Just in case some access to a File element requires disk access.
LutRedDescriptor = file->GetEntryString( 0x0028, 0x1101 );
LutGreenDescriptor = file->GetEntryString( 0x0028, 0x1102 );
LutBlueDescriptor = file->GetEntryString( 0x0028, 0x1103 );
-
- // The following comment is probabely meaningless, since LUT are *always*
- // loaded at parsing time, whatever their length is.
-
- // Depending on the value of Document::MAX_SIZE_LOAD_ELEMENT_VALUE
- // [ refer to invocation of Document::SetMaxSizeLoadEntry() in
- // Document::Document() ], the loading of the value (content) of a
- // [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. DataEntry::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
- file->LoadEntryBinArea(0x0028, 0x1201);
- LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
- if ( ! LutRedData )
- {
- gdcmWarningMacro("Unable to read Red Palette Color Lookup Table data");
- }
-
- // //// Green round:
- file->LoadEntryBinArea(0x0028, 0x1202);
- LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
- if ( ! LutGreenData)
- {
- gdcmWarningMacro("Unable to read Green Palette Color Lookup Table data");
- }
-
- // //// Blue round:
- file->LoadEntryBinArea(0x0028, 0x1203);
- LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
- if ( ! LutBlueData )
- {
- gdcmWarningMacro("Unable to read Blue Palette Color Lookup Table data");
- }
+ // Is it a Segmented Palette ? Check if we find the red one:
+ if( file->GetDocEntry(0x0028,0x1221) ) // no need to check for blue & green
+ {
+ GDCM_NAME_SPACE::TagKey DCM_RedPaletteColorLookupTableDescriptor (0x0028, 0x1101);
+ GDCM_NAME_SPACE::TagKey DCM_GreenPaletteColorLookupTableDescriptor (0x0028, 0x1102);
+ GDCM_NAME_SPACE::TagKey DCM_BluePaletteColorLookupTableDescriptor (0x0028, 0x1103);
+
+ GDCM_NAME_SPACE::TagKey DCM_SegmentedRedPaletteColorLookupTableData (0x0028, 0x1221);
+ GDCM_NAME_SPACE::TagKey DCM_SegmentedGreenPaletteColorLookupTableData (0x0028, 0x1222);
+ GDCM_NAME_SPACE::TagKey DCM_SegmentedBluePaletteColorLookupTableData (0x0028, 0x1223);
+
+
+ LutRedData = new uint8_t[65535*2]; // FIXME: leak
+ LutGreenData = new uint8_t[65535*2];
+ LutBlueData = new uint8_t[65535*2];
+ // TODO need to check file is indeed PALETTE COLOR:
+ ReadPaletteInto(file, DCM_RedPaletteColorLookupTableDescriptor,
+ DCM_SegmentedRedPaletteColorLookupTableData,LutRedData);
+ ReadPaletteInto(file, DCM_GreenPaletteColorLookupTableDescriptor,
+ DCM_SegmentedGreenPaletteColorLookupTableData,LutGreenData);
+ ReadPaletteInto(file, DCM_BluePaletteColorLookupTableDescriptor,
+ DCM_SegmentedBluePaletteColorLookupTableData,LutBlueData);
+
+ }
+ else
+ {
+
+ // FIXME : The following comment is probabely meaningless, since LUT are *always*
+ // loaded at parsing time, whatever their length is.
+
+ // Depending on the value of Document::MAX_SIZE_LOAD_ELEMENT_VALUE
+ // [ refer to invocation of Document::SetMaxSizeLoadEntry() in
+ // Document::Document() ], the loading of the value (content) of a
+ // [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. DataEntry::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
+ file->LoadEntryBinArea(0x0028, 0x1201);
+ LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
+ if ( ! LutRedData )
+ {
+ gdcmWarningMacro("Unable to read Red Palette Color Lookup Table data");
+ }
+
+ // //// Green round:
+ file->LoadEntryBinArea(0x0028, 0x1202);
+ LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
+ if ( ! LutGreenData)
+ {
+ gdcmWarningMacro("Unable to read Green Palette Color Lookup Table data");
+ }
+
+ // //// Blue round:
+ file->LoadEntryBinArea(0x0028, 0x1203);
+ LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
+ if ( ! LutBlueData )
+ {
+ gdcmWarningMacro("Unable to read Blue Palette Color Lookup Table data");
+ }
+ }
}
FileInternal = file;
-
+ FH = fileHelper;
ComputeRawAndRGBSizes();
}
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);
}
if ( PixelDataLength != RawSize )
{
gdcmWarningMacro( "Mismatch between PixelReadConvert : "
- << PixelDataLength << " and RawSize : " << RawSize );
+ << 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())
{
else if ( IsRLELossless )
{
if ( ! RLEInfo->DecompressRLEFile
- ( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) )
+ ( fp, Raw, XSize, YSize, ZSize, TSize, BitsAllocated ) )
{
gdcmWarningMacro( "RLE decompressor failed." );
return false;
//gdcmWarningMacro( "Sorry, MPEG not yet taken into account" );
//return false;
// fp has already been seek to start of mpeg
- //ReadMPEGFile(fp, Raw, PixelDataLength);
+ //ReadMPEGFile(fp, (char*)Raw, PixelDataLength);
return true;
}
else
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- gdcmWarningMacro( "JPEG decompressor failed." );
+ gdcmWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()"
+ << " method ) failed." );
return false;
}
}
delete [] Raw;
Raw = 0;
- if ( LutRGBA )
- delete [] LutRGBA;
- LutRGBA = 0;
+ //if ( LutRGBA )
+ // delete [] LutRGBA;
+ //LutRGBA = 0;
}
/**
return false;
}
- gdcmWarningMacro( "--> 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 )
// jpeg2000 stream to use jasper:
// I don't think we'll ever be able to deal with multiple fragments properly
- unsigned long inputlength = 0;
- JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment();
- while( jpegfrag )
- {
+ if( ZSize == 1 )
+ {
+ unsigned long inputlength = 0;
+ JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment();
+ while( jpegfrag )
+ {
inputlength += jpegfrag->GetLength();
jpegfrag = JPEGInfo->GetNextFragment();
- }
- gdcmAssertMacro( inputlength != 0);
- uint8_t *inputdata = new uint8_t[inputlength];
- char *pinputdata = (char*)inputdata;
- jpegfrag = JPEGInfo->GetFirstFragment();
- while( jpegfrag )
- {
+ }
+ gdcmAssertMacro( inputlength != 0);
+ uint8_t *inputdata = new uint8_t[inputlength];
+ char *pinputdata = (char*)inputdata;
+ jpegfrag = JPEGInfo->GetFirstFragment();
+ while( jpegfrag )
+ {
fp->seekg( jpegfrag->GetOffset(), std::ios::beg);
fp->read(pinputdata, jpegfrag->GetLength());
pinputdata += jpegfrag->GetLength();
jpegfrag = JPEGInfo->GetNextFragment();
- }
- // Warning the inputdata buffer is delete in the function
- if ( ! gdcm_read_JPEG2000_file( Raw,
- (char*)inputdata, inputlength ) )
- {
+ }
+ // Warning the inputdata buffer is deleted in the function
+ if ( gdcm_read_JPEG2000_file( Raw,
+ (char*)inputdata, inputlength ) )
+ {
return true;
- }
- // wow what happen, must be an error
- return false;
+ }
+ // wow what happen, must be an error
+ gdcmWarningMacro( "gdcm_read_JPEG2000_file() failed ");
+ return false;
+ }
+ else
+ {
+ if( (unsigned int)ZSize != JPEGInfo->GetFragmentCount() )
+ {
+ gdcmErrorMacro( "Sorry GDCM does not handle this type of fragments" );
+ return false;
+ }
+ // Hopefully every dicom fragment is *exactly* the j2k stream
+ JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment();
+ char *praw = (char*)Raw;
+ while( jpegfrag )
+ {
+ unsigned long inputlength = jpegfrag->GetLength();
+ char *inputdata = new char[inputlength];
+ fp->seekg( jpegfrag->GetOffset(), std::ios::beg);
+ fp->read(inputdata, jpegfrag->GetLength());
+ // Warning the inputdata buffer is deleted in the function
+ gdcm_read_JPEG2000_file( praw,
+ inputdata, inputlength) ;
+ praw += XSize*YSize*SamplesPerPixel*(BitsAllocated/8);
+ jpegfrag = JPEGInfo->GetNextFragment();
+ }
+ return true;
+ }
}
else if ( IsJPEGLS )
{
// if ( ! gdcm_read_JPEGLS_file( fp,Raw ) )
return false;
}
- else
+ else if( JPEGInfo )
{
// 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 );
+ // to avoid major troubles when BitsStored == 8 && BitsAllocated==16 !
+ int dummy;
+ if (BitsStored == 8 && BitsAllocated==16)
+ dummy = 16;
+ else
+ dummy = BitsStored;
+ JPEGInfo->DecompressFromFile(fp, Raw, dummy, numberBytes, length );
return true;
}
+ //else (not sure how get there...), must be one of those crazy DICOM file
+ return false;
}
/**
* 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 :
gdcmWarningMacro( "Wrong Blue LUT descriptor" );
}
- gdcmWarningMacro(" lengthR " << lengthR << " debR "
- << debR << " nbitsR " << nbitsR);
- gdcmWarningMacro(" lengthG " << lengthG << " debG "
- << debG << " nbitsG " << nbitsG);
- gdcmWarningMacro(" 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;
*a16 = 1; // Alpha component
a16 += 4;
}
-/* Just to 'see' the LUT, at debug time
+// Just to 'see' the LUT, at debug time
// Don't remove this commented out code.
a16=(uint16_t*)LutRGBA;
<< *(a16+2) << " " << *(a16+3) << std::endl;
a16+=4;
}
-*/
+
}
}
/**
- * \brief Swap the bytes, according to \ref SwapCode.
+ * \brief Swap the bytes, according to SwapCode.
*/
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
// big endian format. When reading the header, GDCM has already established
// 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.
-
-/* //Let me check something.
- //I wait for the Dashboard !
+
+ int tempSwapCode = SwapCode;
if ( IsPrivateGETransferSyntax )
{
+ gdcmWarningMacro(" 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.");
+ gdcmWarningMacro("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." );
+ gdcmWarningMacro("SwapCode value (32 bits) not allowed." << tempSwapCode );
}
}
}
{
// pmask : to mask the 'unused bits' (may contain overlays)
uint16_t pmask = 0xffff;
- pmask = pmask >> ( BitsAllocated - BitsStored );
+
+ // It's up to the user to decide if he wants to ignore overlays (if any),
+ // not to gdcm, without asking.
+ // default is NOT TO LOAD, in order not to confuse ITK users (and others!).
+
+ if ( !FH->GetKeepOverlays() ) // mask spurious bits ! (overlay are NOT loaded!)
+ {
+ pmask = pmask >> ( BitsAllocated - BitsStored );
+ }
+ // else : it's up to the user to manage the 'pixels + overlays' he just loaded!
uint16_t *deb = (uint16_t*)Raw;
if ( !PixelSign ) // Pixels are unsigned
{
for(int i = 0; i<l; i++)
- {
+ {
*deb = (*deb >> (BitsStored - HighBitPosition - 1)) & pmask;
deb++;
}
}
else // Pixels are signed
{
+ // Hope there is never ACR-NEMA-like overlays within signed pixels (?!?)
+
// smask : to check the 'sign' when BitsStored != BitsAllocated
uint16_t smask = 0x0001;
smask = smask << ( 16 - (BitsAllocated - BitsStored + 1) );
// nmask : to propagate sign bit on negative values
int16_t nmask = (int16_t)0x8000;
nmask = nmask >> ( BitsAllocated - BitsStored - 1 );
-
+
for(int i = 0; i<l; i++)
{
*deb = *deb >> (BitsStored - HighBitPosition - 1);
// except for the few patches of color on the image.
// On such images, RLE achieves a compression ratio that is much better
// than the compression ratio on an equivalent RGB image.
-
+
gdcmWarningMacro("--> ConvertYcBcRPlanesToRGBPixels");
-
+
uint8_t *localRaw = Raw;
uint8_t *copyRaw = new uint8_t[ RawSize ];
memmove( copyRaw, localRaw, 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.
- gdcmWarningMacro("--> ConvertHandleColor"
- << "Planar Configuration " << PlanarConfiguration );
+ gdcmDebugMacro("--> ConvertHandleColor "
+ << "Planar Configuration " << PlanarConfiguration );
if ( ! IsRawRGB() )
{
// [Planar 2] OR [Photo D]: LUT intervention done outside
- gdcmWarningMacro("--> 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)
- gdcmWarningMacro("--> YBRFull");
+ gdcmDebugMacro("--> YBRFull");
ConvertYcBcRPlanesToRGBPixels();
}
else
{
// [Planar 1] AND [Photo C]
- gdcmWarningMacro("--> YBRFull");
+ gdcmDebugMacro("--> YBRFull");
ConvertRGBPlanesToRGBPixels();
}
return;
if (IsRLELossless)
{
- gdcmWarningMacro("--> RLE Lossless");
+ gdcmDebugMacro("--> RLE Lossless");
ConvertRGBPlanesToRGBPixels();
}
int bitsAllocated = BitsAllocated;
// Number of "Bits Allocated" is fixed to 16 when it's 12, since
// in this case we will expand the image to 16 bits (see
- // \ref ReadAndDecompress12BitsTo16Bits() )
+ // ReadAndDecompress12BitsTo16Bits() )
if ( BitsAllocated == 12 )
{
bitsAllocated = 16;
}
- RawSize = XSize * YSize * ZSize
+ RawSize = XSize * YSize * ZSize * TSize
* ( bitsAllocated / 8 )
* SamplesPerPixel;
if ( HasLUT )
{
RGBSize = RawSize;
}
+ RawSize += RawSize%2;
+ RGBSize += RGBSize%2;
}
/// Allocates room for RGB Pixels
}
}
+/**
+ * \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
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff