GDCM_NAME_SPACE::PixelReadConvert Class Reference

Utility container for gathering the various forms the pixel data migth take during the user demanded processes. WARNING : *none* of these functions may be invoked by gdcm user (internal use only). More...

#include <gdcmPixelReadConvert.h>

Inheritance diagram for GDCM_NAME_SPACE::PixelReadConvert:

[legend]Collaboration diagram for GDCM_NAME_SPACE::PixelReadConvert:

[legend]List of all members.

Public Member Functions
void	SetPrintLevel (int level)
	Sets the print level for the Dicom Header Elements.
int	GetPrintLevel ()
	Gets the print level for the Dicom Entries.
Protected Attributes
int	PrintLevel
	Amount of printed details for each Dicom Entries : 0 : stands for the least detail level.
Private Member Functions
	PixelReadConvert ()
	Constructor.
virtual	~PixelReadConvert ()
	Canonical Destructor.
void	Print (std::ostream &os=std::cout, std::string const &indent="")
	Print self.
uint8_t *	GetRGB ()
	returns pixel area holding RGB Pixels, made from Grey level + LUT
size_t	GetRGBSize ()
	returns pixel area length -RGB Pixels, (from Grey level + LUT)-
uint8_t *	GetRaw ()
	returns pixel area holding native RGB Pixels or Grey level
size_t	GetRawSize ()
	returns pixel area size -native RGB Pixels or Grey level-
uint8_t *	GetLutRGBA ()
	returns Red Green Blue Alpha LUT
int	GetLutItemNumber ()
	returns Lut Item Number
int	GetLutItemSize ()
	returns Lut Item Size
bool	IsRawRGB ()
	Predicate to know whether the image[s] (once Raw) is RGB.
void	GrabInformationsFromFile (File *file, FileHelper *fileHelper)
	Gets various usefull informations from the file header.
bool	ReadAndDecompressPixelData (std::ifstream *fp)
	Reads from disk and decompresses Pixels.
void	Squeeze ()
	Deletes Pixels Area.
bool	BuildRGBImage ()
	Build the RGB image from the Raw image and the LUTs.
void	BuildLUTRGBA ()
	Build Red/Green/Blue/Alpha LUT from File when : (0028,0004) : Photometric Interpretation == [PALETTE COLOR ] and (0028,1101),(0028,1102),(0028,1102) xxx Palette Color Lookup Table Descriptor are found and (0028,1201),(0028,1202),(0028,1202) xxx Palette Color Lookup Table Data - are found.
void	SetUserFunction (VOID_FUNCTION_PUINT8_PFILE_POINTER userFunc)
	Allow user to pass his own function to modify pixels (e.g; mirror, upsidedown, ...) just after reading.
void	ReadAndDecompress12BitsTo16Bits (std::ifstream *fp) throw ( FormatError )
	Read from file a 12 bits per pixel image and decompress it into a 16 bits per pixel image.
bool	ReadAndDecompressJPEGFile (std::ifstream *fp)
	Reads from disk the Pixel Data of JPEG Dicom encapsulated file and decompress it.
void	ConvertSwapZone ()
	Swap the bytes, according to SwapCode.
void	ConvertReorderEndianity ()
	Deal with endianness i.e. re-arange bytes inside the integer.
bool	ConvertReArrangeBits () throw ( FormatError )
	Re-arrange the bits within the bytes.
void	ConvertFixGreyLevels ()
	Deal with Grey levels i.e. re-arange them to have low values = dark, high values = bright.
void	ConvertRGBPlanesToRGBPixels ()
	Convert (Red plane, Green plane, Blue plane) to RGB pixels.
void	ConvertYcBcRPlanesToRGBPixels ()
	Convert (cY plane, cB plane, cR plane) to RGB pixels.
void	ConvertHandleColor ()
	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	ComputeRawAndRGBSizes ()
	Computes the Pixels Size.
void	AllocateRGB ()
	Allocates room for RGB Pixels.
void	AllocateRaw ()
	Allocates room for RAW Pixels.
void	CallStartMethod ()
	CallStartMethod.
void	CallProgressMethod ()
	CallProgressMethod.
void	CallEndMethod ()
	CallEndMethod.
Private Attributes
uint8_t *	RGB
	Pixel data represented as RGB after LUT color interpretation. 'uint8_t' is just to avoid warnings at compile time. feel free to cast it as uint16_t if you need.
size_t	RGBSize
	Size of RGB image.
uint8_t *	Raw
	Pixel data after decompression and bit/byte rearrangement.
size_t	RawSize
	Size of Decompressed image.
uint8_t *	LutRGBA
	Red/Green/Blue/Alpha LookUpTable build out of the Red/Green/Blue LUT descriptors (see BuildLUTRGBA ).
int	LutItemNumber
int	LutItemSize
size_t	PixelOffset
size_t	PixelDataLength
int	XSize
int	YSize
int	ZSize
int	TSize
int	BitsAllocated
int	BitsStored
int	HighBitPosition
int	SamplesPerPixel
bool	PixelSign
int	SwapCode
bool	IsPrivateGETransferSyntax
bool	IsRaw
bool	IsJPEG2000
bool	IsJPEGLS
bool	IsJPEGLossless
bool	IsJPEGLossy
bool	IsJPEG
bool	IsRLELossless
bool	IsMPEG
RLEFramesInfo *	RLEInfo
JPEGFragmentsInfo *	JPEGInfo
int	PlanarConfiguration
bool	IsMonochrome
bool	IsMonochrome1
bool	IsPaletteColor
bool	IsYBRFull
bool	HasLUT
std::string	LutRedDescriptor
std::string	LutGreenDescriptor
std::string	LutBlueDescriptor
uint8_t *	LutRedData
uint8_t *	LutGreenData
uint8_t *	LutBlueData
File *	FileInternal
VOID_FUNCTION_PUINT8_PFILE_POINTER	UserFunction
FileHelper *	FH
	Needed for the progression bar stuff.
bool	Abort
float	Progress
Friends
class	FileHelper

---

Detailed Description

Utility container for gathering the various forms the pixel data migth take during the user demanded processes. WARNING : *none* of these functions may be invoked by gdcm user (internal use only).

Definition at line 44 of file gdcmPixelReadConvert.h.

---

Constructor & Destructor Documentation

GDCM_NAME_SPACE::PixelReadConvert::PixelReadConvert (   )  [private]

Constructor. Definition at line 47 of file gdcmPixelReadConvert.cxx. References FileInternal, JPEGInfo, LutBlueData, LutGreenData, LutRedData, LutRGBA, Raw, RawSize, RGB, RGBSize, RLEInfo, and UserFunction. { RGB = 0; RGBSize = 0; Raw = 0; RawSize = 0; LutRGBA = 0; LutRedData = 0; LutGreenData = 0; LutBlueData = 0; RLEInfo = 0; JPEGInfo = 0; UserFunction = 0; FileInternal = 0; }

GDCM_NAME_SPACE::PixelReadConvert::~PixelReadConvert (   )  [private, virtual]

Canonical Destructor. Definition at line 64 of file gdcmPixelReadConvert.cxx. References Squeeze(). { Squeeze(); }

---

Member Function Documentation

void GDCM_NAME_SPACE::PixelReadConvert::AllocateRaw (   )  [private]

Allocates room for RAW Pixels. Definition at line 1369 of file gdcmPixelReadConvert.cxx. References Raw, and RawSize. { if ( Raw ) delete [] Raw; Raw = new uint8_t[RawSize]; }

void GDCM_NAME_SPACE::PixelReadConvert::AllocateRGB (   )  [private]

Allocates room for RGB Pixels. Definition at line 1361 of file gdcmPixelReadConvert.cxx. References RGB, and RGBSize. Referenced by BuildRGBImage(). { if ( RGB ) delete [] RGB; RGB = new uint8_t[RGBSize]; }

void GDCM_NAME_SPACE::PixelReadConvert::BuildLUTRGBA (   )  [private]

Build Red/Green/Blue/Alpha LUT from File when : (0028,0004) : Photometric Interpretation == [PALETTE COLOR ] and (0028,1101),(0028,1102),(0028,1102) xxx Palette Color Lookup Table Descriptor are found and (0028,1201),(0028,1202),(0028,1202) xxx Palette Color Lookup Table Data - are found. Warning: does NOT deal with : 0028 1100 Gray Lookup Table Descriptor (Retired) 0028 1221 Segmented Red Palette Color Lookup Table Data 0028 1222 Segmented Green Palette Color Lookup Table Data 0028 1223 Segmented Blue Palette Color Lookup Table Data no known Dicom reader deals with them :-( Returns: a RGBA Lookup Table Definition at line 620 of file gdcmPixelReadConvert.cxx. References BitsAllocated, GDCM_NAME_SPACE::GDCM_UNFOUND, gdcmDebugMacro, gdcmWarningMacro, IsPaletteColor, LutBlueData, LutBlueDescriptor, LutGreenData, LutGreenDescriptor, LutItemNumber, LutItemSize, LutRedData, LutRedDescriptor, and LutRGBA. Referenced by BuildRGBImage(), and GDCM_NAME_SPACE::FileHelper::GetLutRGBA(). { // Note to code reviewers : // The problem is *much more* complicated, since a lot of manufacturers // Don't follow the norm : // have a look at David Clunie's remark at the end of this .cxx file. if ( LutRGBA ) { return; } // Not so easy : see // http://www.barre.nom.fr/medical/dicom2/limitations.html#Color%20Lookup%20Tables if ( ! IsPaletteColor ) { return; } if ( LutRedDescriptor == GDCM_UNFOUND || LutGreenDescriptor == GDCM_UNFOUND || LutBlueDescriptor == GDCM_UNFOUND ) { gdcmWarningMacro( "(At least) a LUT Descriptor is missing" ); return; } // Extract the info from the LUT descriptors int lengthR; // Red LUT length in Bytes int debR; // Subscript of the first Lut Value int nbitsR; // Lut item size (in Bits) int nbRead; // nb of items in LUT descriptor (must be = 3) nbRead = sscanf( LutRedDescriptor.c_str(), "%d\\%d\\%d", &lengthR, &debR, &nbitsR ); if ( nbRead != 3 ) { gdcmWarningMacro( "Wrong Red LUT descriptor" ); } int lengthG; // Green LUT length in Bytes int debG; // Subscript of the first Lut Value int nbitsG; // Lut item size (in Bits) nbRead = sscanf( LutGreenDescriptor.c_str(), "%d\\%d\\%d", &lengthG, &debG, &nbitsG ); if ( nbRead != 3 ) { gdcmWarningMacro( "Wrong Green LUT descriptor" ); } int lengthB; // Blue LUT length in Bytes int debB; // Subscript of the first Lut Value int nbitsB; // Lut item size (in Bits) nbRead = sscanf( LutRedDescriptor.c_str(), "%d\\%d\\%d", &lengthB, &debB, &nbitsB ); if ( nbRead != 3 ) { gdcmWarningMacro( "Wrong Blue LUT descriptor" ); } 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 ( !lengthG ) // if = 2^16, this shall be 0 lengthG=65536; if ( !lengthB ) // if = 2^16, this shall be 0 lengthB=65536; if ( ( ! LutRedData ) || ( ! LutGreenData ) || ( ! LutBlueData ) ) { gdcmWarningMacro( "(At least) a LUT is missing" ); return; } // ------------------------------------------------------------- if ( BitsAllocated <= 8 ) { // forge the 4 * 8 Bits Red/Green/Blue/Alpha LUT LutRGBA = new uint8_t[ 1024 ]; // 256 * 4 (R, G, B, Alpha) if ( !LutRGBA ) return; LutItemNumber = 256; LutItemSize = 8; memset( LutRGBA, 0, 1024 ); int mult; if ( ( nbitsR == 16 ) && ( BitsAllocated == 8 ) ) { // when LUT item size is different than pixel size mult = 2; // high byte must be = low byte } else { // See PS 3.3-2003 C.11.1.1.2 p 619 mult = 1; } // if we get a black image, let's just remove the '+1' // from 'i*mult+1' and check again // if it works, we shall have to check the 3 Palettes // to see which byte is ==0 (first one, or second one) // and fix the code // We give up the checking to avoid some (useless ?) overhead // (optimistic asumption) int i; uint8_t *a; //take "Subscript of the first Lut Value" (debR,debG,debB) into account! //FIXME : +1 : to get 'low value' byte // Trouble expected on Big Endian Processors ? // 16 BIts Per Pixel Palette Color to be swapped? a = LutRGBA + 0 + debR; for( i=0; i < lengthR; ++i ) { *a = LutRedData[i*mult+1]; a += 4; } a = LutRGBA + 1 + debG; for( i=0; i < lengthG; ++i) { *a = LutGreenData[i*mult+1]; a += 4; } a = LutRGBA + 2 + debB; for(i=0; i < lengthB; ++i) { *a = LutBlueData[i*mult+1]; a += 4; } a = LutRGBA + 3 ; for(i=0; i < 256; ++i) { *a = 1; // Alpha component a += 4; } } else { // Probabely the same stuff is to be done for 16 Bits Pixels // with 65536 entries LUT ?!? // Still looking for accurate info on the web :-( 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 LutRGBA = (uint8_t *)new uint16_t[ 65536*4 ]; // 2^16 * 4 (R, G, B, Alpha) if ( !LutRGBA ) return; memset( LutRGBA, 0, 65536*4*2 ); // 16 bits = 2 bytes ;-) LutItemNumber = 65536; LutItemSize = 16; int i; uint16_t *a16; //take "Subscript of the first Lut Value" (debR,debG,debB) into account! a16 = (uint16_t*)LutRGBA + 0 + debR; for( i=0; i < lengthR; ++i ) { *a16 = ((uint16_t*)LutRedData)[i]; a16 += 4; } a16 = (uint16_t*)LutRGBA + 1 + debG; for( i=0; i < lengthG; ++i) { *a16 = ((uint16_t*)LutGreenData)[i]; a16 += 4; } a16 = (uint16_t*)LutRGBA + 2 + debB; for(i=0; i < lengthB; ++i) { *a16 = ((uint16_t*)LutBlueData)[i]; a16 += 4; } a16 = (uint16_t*)LutRGBA + 3 ; for(i=0; i < 65536; ++i) { *a16 = 1; // Alpha component a16 += 4; } /* Just to 'see' the LUT, at debug time // Don't remove this commented out code. a16=(uint16_t*)LutRGBA; for (int j=0;j<65536;j++) { std::cout << *a16 << " " << *(a16+1) << " " << *(a16+2) << " " << *(a16+3) << std::endl; a16+=4; } */ } }

bool GDCM_NAME_SPACE::PixelReadConvert::BuildRGBImage (   )  [private]

Build the RGB image from the Raw image and the LUTs. Definition at line 392 of file gdcmPixelReadConvert.cxx. References AllocateRGB(), BitsAllocated, BuildLUTRGBA(), gdcmDebugMacro, LutRGBA, Raw, RawSize, and RGB. Referenced by GDCM_NAME_SPACE::FileHelper::SetWriteToRGB(). { if ( RGB ) { // The job is already done. return true; } if ( ! Raw ) { // The job can't be done return false; } BuildLUTRGBA(); if ( ! LutRGBA ) { // The job can't be done return false; } gdcmDebugMacro( "--> BuildRGBImage" ); // Build RGB Pixels AllocateRGB(); int j; if ( BitsAllocated <= 8 ) { uint8_t *localRGB = RGB; for (size_t i = 0; i < RawSize; ++i ) { j = Raw[i] * 4; *localRGB++ = LutRGBA[j]; *localRGB++ = LutRGBA[j+1]; *localRGB++ = LutRGBA[j+2]; } } else // deal with 16 bits pixels and 16 bits Palette color { uint16_t *localRGB = (uint16_t *)RGB; for (size_t i = 0; i < RawSize/2; ++i ) { j = ((uint16_t *)Raw)[i] * 4; *localRGB++ = ((uint16_t *)LutRGBA)[j]; *localRGB++ = ((uint16_t *)LutRGBA)[j+1]; *localRGB++ = ((uint16_t *)LutRGBA)[j+2]; } } return true; }

void GDCM_NAME_SPACE::PixelReadConvert::CallEndMethod (   )  [private]

CallEndMethod. Definition at line 1441 of file gdcmPixelReadConvert.cxx. References GDCM_NAME_SPACE::CMD_ENDPROGRESS, GDCM_NAME_SPACE::CommandManager::ExecuteCommand(), FH, and Progress. { Progress = 1.0f; CommandManager::ExecuteCommand(FH,CMD_ENDPROGRESS); }

void GDCM_NAME_SPACE::PixelReadConvert::CallProgressMethod (   )  [private]

CallProgressMethod. Definition at line 1433 of file gdcmPixelReadConvert.cxx. References GDCM_NAME_SPACE::CMD_PROGRESS, GDCM_NAME_SPACE::CommandManager::ExecuteCommand(), and FH. { CommandManager::ExecuteCommand(FH,CMD_PROGRESS); }

void GDCM_NAME_SPACE::PixelReadConvert::CallStartMethod (   )  [private]

CallStartMethod. Definition at line 1423 of file gdcmPixelReadConvert.cxx. References Abort, GDCM_NAME_SPACE::CMD_STARTPROGRESS, GDCM_NAME_SPACE::CommandManager::ExecuteCommand(), FH, and Progress. { Progress = 0.0f; Abort = false; CommandManager::ExecuteCommand(FH,CMD_STARTPROGRESS); }

void GDCM_NAME_SPACE::PixelReadConvert::ComputeRawAndRGBSizes (   )  [private]

Computes the Pixels Size. Definition at line 1333 of file gdcmPixelReadConvert.cxx. References BitsAllocated, HasLUT, RawSize, RGBSize, SamplesPerPixel, TSize, XSize, YSize, and ZSize. { 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() ) if ( BitsAllocated == 12 ) { bitsAllocated = 16; } RawSize = XSize * YSize * ZSize * TSize * ( bitsAllocated / 8 ) * SamplesPerPixel; if ( HasLUT ) { RGBSize = 3 * RawSize; // works for 8 and 16 bits per Pixel } else { RGBSize = RawSize; } RawSize += RawSize%2; RGBSize += RGBSize%2; }

void GDCM_NAME_SPACE::PixelReadConvert::ConvertFixGreyLevels (   )  [private]

Deal with Grey levels i.e. re-arange them to have low values = dark, high values = bright. Definition at line 989 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, IsMonochrome1, PixelSign, Raw, and RawSize. { if (!IsMonochrome1) return; uint32_t i; // to please M$VC6 int16_t j; if (!PixelSign) { if ( BitsAllocated == 8 ) { uint8_t *deb = (uint8_t *)Raw; for (i=0; i<RawSize; i++) { *deb = 255 - *deb; deb++; } return; } if ( BitsAllocated == 16 ) { uint16_t mask =1; for (j=0; j<BitsStored-1; j++) { mask = (mask << 1) +1; // will be fff when BitsStored=12 } uint16_t *deb = (uint16_t *)Raw; for (i=0; i<RawSize/2; i++) { *deb = mask - *deb; deb++; } return; } } else { if ( BitsAllocated == 8 ) { uint8_t smask8 = 255; uint8_t *deb = (uint8_t *)Raw; for (i=0; i<RawSize; i++) { *deb = smask8 - *deb; deb++; } return; } if ( BitsAllocated == 16 ) { uint16_t smask16 = 65535; uint16_t *deb = (uint16_t *)Raw; for (i=0; i<RawSize/2; i++) { *deb = smask16 - *deb; deb++; } return; } } }

void GDCM_NAME_SPACE::PixelReadConvert::ConvertHandleColor (   )  [private]

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"). Definition at line 1253 of file gdcmPixelReadConvert.cxx. References ConvertRGBPlanesToRGBPixels(), ConvertYcBcRPlanesToRGBPixels(), gdcmDebugMacro, IsRawRGB(), IsRLELossless, IsYBRFull, and PlanarConfiguration. { // Deal with the color decoding i.e. handle: // - R, G, B planes (as opposed to RGB pixels) // - YBR (various) encodings. // - LUT[s] (or "PALETTE COLOR"). // // The classification in the color decoding schema is based on the blending // of two Dicom tags values: // * "Photometric Interpretation" for which we have the cases: // - [Photo A] MONOCHROME[1|2] pictures, // - [Photo B] RGB or YBR_FULL_422 (which acts as RGB), // - [Photo C] YBR_* (with the above exception of YBR_FULL_422) // - [Photo D] "PALETTE COLOR" which indicates the presence of LUT[s]. // * "Planar Configuration" for which we have the cases: // - [Planar 0] 0 then Pixels are already RGB // - [Planar 1] 1 then we have 3 planes : R, G, B, // - [Planar 2] 2 then we have 1 gray Plane and 3 LUTs // // Now in theory, one could expect some coherence when blending the above // cases. For example we should not encounter files belonging at the // time to case [Planar 0] and case [Photo D]. // Alas, this was only theory ! Because in practice some odd (read ill // formated Dicom) files (e.g. gdcmData/US-PAL-8-10x-echo.dcm) we encounter: // - "Planar Configuration" = 0, // - "Photometric Interpretation" = "PALETTE COLOR". // Hence gdcm will use the folowing "heuristic" in order to be tolerant // towards Dicom-non-conformant files: // << whatever the "Planar Configuration" value might be, a // "Photometric Interpretation" set to "PALETTE COLOR" forces // a LUT intervention >> // // Now we are left with the following handling of the cases: // - [Planar 0] OR [Photo A] no color decoding (since respectively // Pixels are already RGB and monochrome pictures have no color :), // - [Planar 1] AND [Photo B] handled with ConvertRGBPlanesToRGBPixels() // - [Planar 1] AND [Photo C] handled with ConvertYcBcRPlanesToRGBPixels() // - [Planar 2] OR [Photo D] requires LUT intervention. gdcmDebugMacro("--> ConvertHandleColor " << "Planar Configuration " << PlanarConfiguration ); if ( ! IsRawRGB() ) { // [Planar 2] OR [Photo D]: LUT intervention done outside gdcmDebugMacro("--> RawRGB : LUT intervention done outside"); return; } if ( PlanarConfiguration == 1 ) { if ( IsYBRFull ) { // [Planar 1] AND [Photo C] (remember YBR_FULL_422 acts as RGB) gdcmDebugMacro("--> YBRFull"); ConvertYcBcRPlanesToRGBPixels(); } else { // [Planar 1] AND [Photo C] gdcmDebugMacro("--> YBRFull"); ConvertRGBPlanesToRGBPixels(); } return; } // When planarConf is 0, and RLELossless (forbidden by Dicom norm) // pixels need to be RGB-fyied anyway if (IsRLELossless) { gdcmDebugMacro("--> RLE Lossless"); ConvertRGBPlanesToRGBPixels(); } // In *normal *case, when planarConf is 0, pixels are already in RGB }

bool GDCM_NAME_SPACE::PixelReadConvert::ConvertReArrangeBits (   )  throw ( FormatError ) [private]

Re-arrange the bits within the bytes. Returns: Boolean always true Definition at line 1058 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, HighBitPosition, PixelSign, Raw, and RawSize. { if ( BitsStored != BitsAllocated ) { int l = (int)( RawSize / ( BitsAllocated / 8 ) ); if ( BitsAllocated == 16 ) { // pmask : to mask the 'unused bits' (may contain overlays) uint16_t pmask = 0xffff; pmask = pmask >> ( BitsAllocated - BitsStored ); 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 { // 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); if ( *deb & smask ) { *deb = *deb | nmask; } else { *deb = *deb & pmask; } deb++; } } } else if ( BitsAllocated == 32 ) { // pmask : to mask the 'unused bits' (may contain overlays) uint32_t pmask = 0xffffffff; pmask = pmask >> ( BitsAllocated - BitsStored ); uint32_t *deb = (uint32_t*)Raw; if ( !PixelSign ) { for(int i = 0; i<l; i++) { *deb = (*deb >> (BitsStored - HighBitPosition - 1)) & pmask; deb++; } } else { // smask : to check the 'sign' when BitsStored != BitsAllocated uint32_t smask = 0x00000001; smask = smask >> ( 32 - (BitsAllocated - BitsStored +1 )); // nmask : to propagate sign bit on negative values int32_t nmask = 0x80000000; nmask = nmask >> ( BitsAllocated - BitsStored -1 ); for(int i = 0; i<l; i++) { *deb = *deb >> (BitsStored - HighBitPosition - 1); if ( *deb & smask ) *deb = *deb | nmask; else *deb = *deb & pmask; deb++; } } } else { gdcmWarningMacro("Weird image (BitsAllocated !=8, 12, 16, 32)"); throw FormatError( "Weird image !?" ); } } return true; }

void GDCM_NAME_SPACE::PixelReadConvert::ConvertReorderEndianity (   )  [private]

Deal with endianness i.e. re-arange bytes inside the integer. Definition at line 960 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, ConvertSwapZone(), PixelSign, Raw, and RawSize. { if ( BitsAllocated != 8 ) { ConvertSwapZone(); } // Special kludge in order to deal with xmedcon broken images: if ( BitsAllocated == 16 && BitsStored < BitsAllocated && !PixelSign ) { int l = (int)( RawSize / ( BitsAllocated / 8 ) ); uint16_t *deb = (uint16_t *)Raw; for(int i = 0; i<l; i++) { if ( *deb == 0xffff ) { *deb = 0; } deb++; } } }

void GDCM_NAME_SPACE::PixelReadConvert::ConvertRGBPlanesToRGBPixels (   )  [private]

Convert (Red plane, Green plane, Blue plane) to RGB pixels. Warning: Works on all the frames at a time Definition at line 1153 of file gdcmPixelReadConvert.cxx. References gdcmWarningMacro, Raw, RawSize, XSize, YSize, and ZSize. Referenced by ConvertHandleColor(). { gdcmWarningMacro("--> ConvertRGBPlanesToRGBPixels"); uint8_t *localRaw = Raw; uint8_t *copyRaw = new uint8_t[ RawSize ]; memmove( copyRaw, localRaw, RawSize ); int l = XSize * YSize * ZSize; uint8_t *a = copyRaw; uint8_t *b = copyRaw + l; uint8_t *c = copyRaw + l + l; for (int j = 0; j < l; j++) { *(localRaw++) = *(a++); *(localRaw++) = *(b++); *(localRaw++) = *(c++); } delete[] copyRaw; }

void GDCM_NAME_SPACE::PixelReadConvert::ConvertSwapZone (   )  [private]

Swap the bytes, according to SwapCode. Definition at line 843 of file gdcmPixelReadConvert.cxx. References BitsAllocated, gdcmWarningMacro, IsPrivateGETransferSyntax, Raw, RawSize, and SwapCode. Referenced by ConvertReorderEndianity(). { 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 // a byte swapping code suitable for this machine to read the // header. In TS::ImplicitVRBigEndianPrivateGE, this code will need // to be switched in order to read the pixel data. This must be // done REGARDLESS of the processor endianess! // // Example: Assume we are on a little endian machine. When // GDCM reads the header, the header will match the machine // endianess and the swap code will be established as a no-op. // When GDCM reaches the pixel data, it will need to switch the // swap code to do big endian to little endian conversion. // // Now, assume we are on a big endian machine. When GDCM reads the // header, the header will be recognized as a different endianess // than the machine endianess, and a swap code will be established // to convert from little endian to big endian. When GDCM readers // the pixel data, the pixel data endianess will now match the // machine endianess. But we currently have a swap code that // converts from little endian to big endian. In this case, we // need to switch the swap code to a no-op. // // 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. 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! if (SwapCode == 1234) { tempSwapCode = 4321; } else if (SwapCode == 4321) { tempSwapCode = 1234; } } if ( BitsAllocated == 16 ) { uint16_t *im16 = (uint16_t*)Raw; switch( tempSwapCode ) { case 1234: break; case 3412: case 2143: case 4321: for( i = 0; i < RawSize / 2; i++ ) { im16[i]= (im16[i] >> 8) | (im16[i] << 8 ); } break; default: gdcmWarningMacro("SwapCode value (16 bits) not allowed." << tempSwapCode); } } else if ( BitsAllocated == 32 ) { uint32_t s32; uint16_t high; uint16_t low; uint32_t *im32 = (uint32_t*)Raw; switch ( tempSwapCode ) { case 1234: break; case 4321: for( i = 0; i < RawSize / 4; i++ ) { low = im32[i] & 0x0000ffff; // 4321 high = im32[i] >> 16; high = ( high >> 8 ) | ( high << 8 ); low = ( low >> 8 ) | ( low << 8 ); s32 = low; im32[i] = ( s32 << 16 ) | high; } break; case 2143: for( i = 0; i < RawSize / 4; i++ ) { low = im32[i] & 0x0000ffff; // 2143 high = im32[i] >> 16; high = ( high >> 8 ) | ( high << 8 ); low = ( low >> 8 ) | ( low << 8 ); s32 = high; im32[i] = ( s32 << 16 ) | low; } break; case 3412: for( i = 0; i < RawSize / 4; i++ ) { low = im32[i] & 0x0000ffff; // 3412 high = im32[i] >> 16; s32 = low; im32[i] = ( s32 << 16 ) | high; } break; default: gdcmWarningMacro("SwapCode value (32 bits) not allowed." << tempSwapCode ); } } }

void GDCM_NAME_SPACE::PixelReadConvert::ConvertYcBcRPlanesToRGBPixels (   )  [private]

Convert (cY plane, cB plane, cR plane) to RGB pixels. Warning: Works on all the frames at a time Todo: : find an example to see how 3rd dim and 4th dim work together We replaced easy to understand but time consuming floating point computations by the 'well known' integer computation counterpart Refer to : http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf for code optimisation. Definition at line 1180 of file gdcmPixelReadConvert.cxx. References G, gdcmWarningMacro, Raw, RawSize, TSize, XSize, YSize, and ZSize. Referenced by ConvertHandleColor(). { // Remarks for YBR newbees : // YBR_FULL works very much like RGB, i.e. three samples per pixel, // just the color space is YCbCr instead of RGB. This is particularly useful // for doppler ultrasound where most of the image is grayscale // (i.e. only populates the Y components) and Cb and Cr are mostly zero, // 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 ); // to see the tricks about YBR_FULL, YBR_FULL_422, // YBR_PARTIAL_422, YBR_ICT, YBR_RCT have a look at : // ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf // and be *very* affraid // int l = XSize * YSize * TSize; int nbFrames = ZSize; uint8_t *a = copyRaw + 0; uint8_t *b = copyRaw + l; uint8_t *c = copyRaw + l+ l; int32_t R, G, B; for ( int i = 0; i < nbFrames; i++ ) { for ( int j = 0; j < l; j++ ) { R = 38142 *(*a-16) + 52298 *(*c -128); G = 38142 *(*a-16) - 26640 *(*c -128) - 12845 *(*b -128); B = 38142 *(*a-16) + 66093 *(*b -128); R = (R+16384)>>15; G = (G+16384)>>15; B = (B+16384)>>15; if (R < 0) R = 0; if (G < 0) G = 0; if (B < 0) B = 0; if (R > 255) R = 255; if (G > 255) G = 255; if (B > 255) B = 255; *(localRaw++) = (uint8_t)R; *(localRaw++) = (uint8_t)G; *(localRaw++) = (uint8_t)B; a++; b++; c++; } } delete[] copyRaw; }

int GDCM_NAME_SPACE::PixelReadConvert::GetLutItemNumber (   )  [inline, private]

returns Lut Item Number Definition at line 66 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetLutItemNumber(). { return LutItemNumber; }

int GDCM_NAME_SPACE::PixelReadConvert::GetLutItemSize (   )  [inline, private]

returns Lut Item Size Definition at line 68 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetLutItemSize(). { return LutItemSize; }

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::GetLutRGBA (   )  [inline, private]

returns Red Green Blue Alpha LUT Definition at line 64 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetLutRGBA(). { return LutRGBA; }

int GDCM_NAME_SPACE::Base::GetPrintLevel (   )  [inline, inherited]

Gets the print level for the Dicom Entries. Definition at line 50 of file gdcmBase.h. { return PrintLevel; }

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::GetRaw (   )  [inline, private]

returns pixel area holding native RGB Pixels or Grey level Definition at line 60 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetRaw(), and GDCM_NAME_SPACE::FileHelper::GetRawData(). { return Raw; }

size_t GDCM_NAME_SPACE::PixelReadConvert::GetRawSize (   )  [inline, private]

returns pixel area size -native RGB Pixels or Grey level- Definition at line 62 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetRawDataSize(). { return RawSize; }

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::GetRGB (   )  [inline, private]

returns pixel area holding RGB Pixels, made from Grey level + LUT Definition at line 56 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetRGBData(), and GDCM_NAME_SPACE::FileHelper::SetWriteToRGB(). { return RGB; }

size_t GDCM_NAME_SPACE::PixelReadConvert::GetRGBSize (   )  [inline, private]

returns pixel area length -RGB Pixels, (from Grey level + LUT)- Definition at line 58 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetRGBDataSize(), and GDCM_NAME_SPACE::FileHelper::SetWriteToRGB(). { return RGBSize; }

void GDCM_NAME_SPACE::PixelReadConvert::GrabInformationsFromFile (  File *  file, FileHelper *  fileHelper )  [private]

Gets various usefull informations from the file header. Parameters: file  gdcm::File pointer fileHelper  gdcm::FileHelper pointer Definition at line 90 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, GDCM_NAME_SPACE::File::GetBitsAllocated(), GDCM_NAME_SPACE::File::GetBitsStored(), GDCM_NAME_SPACE::File::GetHighBitPosition(), GDCM_NAME_SPACE::File::GetSamplesPerPixel(), GDCM_NAME_SPACE::Document::GetSwapCode(), GDCM_NAME_SPACE::File::GetTSize(), GDCM_NAME_SPACE::File::GetXSize(), GDCM_NAME_SPACE::File::GetYSize(), GDCM_NAME_SPACE::File::GetZSize(), HighBitPosition, GDCM_NAME_SPACE::Document::IsDicomV3(), IsJPEG2000, IsJPEGLossless, IsJPEGLossy, IsJPEGLS, IsMPEG, IsPrivateGETransferSyntax, IsRaw, IsRLELossless, GDCM_NAME_SPACE::File::IsSignedPixelData(), PixelSign, SamplesPerPixel, SwapCode, TSize, XSize, YSize, and ZSize. Referenced by GDCM_NAME_SPACE::FileHelper::FileHelper(), and GDCM_NAME_SPACE::FileHelper::Load(). { // Number of Bits Allocated for storing a Pixel is defaulted to 16 // when absent from the file. BitsAllocated = file->GetBitsAllocated(); if ( BitsAllocated == 0 ) { 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(); if ( BitsStored == 0 ) { BitsStored = BitsAllocated; } // High Bit Position, defaulted to "Bits Allocated" - 1 HighBitPosition = file->GetHighBitPosition(); if ( HighBitPosition == 0 ) { HighBitPosition = BitsAllocated - 1; } 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; } 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 = 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(); RLEInfo = file->GetRLEInfo(); JPEGInfo = file->GetJPEGInfo(); IsMonochrome = file->IsMonochrome(); IsMonochrome1 = file->IsMonochrome1(); IsPaletteColor = file->IsPaletteColor(); IsYBRFull = file->IsYBRFull(); PlanarConfiguration = file->GetPlanarConfiguration(); // LUT section: HasLUT = file->HasLUT(); if ( HasLUT ) { // 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 ); // 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(); }

bool GDCM_NAME_SPACE::PixelReadConvert::IsRawRGB (   )  [private]

Predicate to know whether the image[s] (once Raw) is RGB. Note: See comments of ConvertHandleColor Definition at line 75 of file gdcmPixelReadConvert.cxx. References IsMonochrome, IsPaletteColor, and PlanarConfiguration. Referenced by ConvertHandleColor(). { if ( IsMonochrome || PlanarConfiguration == 2 || IsPaletteColor ) { return false; } return true; }

void GDCM_NAME_SPACE::PixelReadConvert::Print (  std::ostream &  os = std::cout, std::string const &  indent = "" )  [private, virtual]

Print self. Parameters: indent  Indentation string to be prepended during printing. os  Stream to print to. Reimplemented from GDCM_NAME_SPACE::Base. Definition at line 1383 of file gdcmPixelReadConvert.cxx. References gdcmWarningMacro, IsJPEG2000, IsJPEGLossless, IsJPEGLossy, IsJPEGLS, IsRLELossless, JPEGInfo, PixelDataLength, PixelOffset, and RLEInfo. Referenced by GDCM_NAME_SPACE::FileHelper::Print(). { os << indent << "--- Pixel information -------------------------" << std::endl; os << indent << "Pixel Data: offset " << PixelOffset << " x(" << std::hex << PixelOffset << std::dec << ") length " << PixelDataLength << " x(" << std::hex << PixelDataLength << std::dec << ")" << std::endl; if ( IsRLELossless ) { if ( RLEInfo ) { RLEInfo->Print( os, indent ); } else { gdcmWarningMacro("Set as RLE file but NO RLEinfo present."); } } if ( IsJPEG2000 || IsJPEGLossless || IsJPEGLossy || IsJPEGLS ) { if ( JPEGInfo ) { JPEGInfo->Print( os, indent ); } else { gdcmWarningMacro("Set as JPEG file but NO JPEGinfo present."); } } }

void GDCM_NAME_SPACE::PixelReadConvert::ReadAndDecompress12BitsTo16Bits (  std::ifstream *  fp  )  throw ( FormatError ) [private]

Read from file a 12 bits per pixel image and decompress it into a 16 bits per pixel image. Todo: Fix the 3D, 4D pb Todo: JPR Troubles expected on Big-Endian processors ? Definition at line 455 of file gdcmPixelReadConvert.cxx. { int nbPixels = XSize * YSize * TSize; uint16_t *localDecompres = (uint16_t*)Raw; for( int p = 0; p < nbPixels; p += 2 ) { uint8_t b0, b1, b2; fp->read( (char*)&b0, 1); if ( fp->fail() || fp->eof() ) { throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()", "Unfound first block" ); } fp->read( (char*)&b1, 1 ); if ( fp->fail() || fp->eof()) { throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()", "Unfound second block" ); } fp->read( (char*)&b2, 1 ); if ( fp->fail() || fp->eof()) { throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()", "Unfound second block" ); } // Two steps are necessary to please VC++ // // 2 pixels 12bit = [0xABCDEF] // 2 pixels 16bit = [0x0ABD] + [0x0FCE] // A B D *localDecompres++ = ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f); // F C E *localDecompres++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4); } }

bool GDCM_NAME_SPACE::PixelReadConvert::ReadAndDecompressJPEGFile (  std::ifstream *  fp  )  [private]

Reads from disk the Pixel Data of JPEG Dicom encapsulated file and decompress it. Parameters: fp  File Pointer Returns: Boolean Definition at line 506 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, GDCM_NAME_SPACE::JPEGFragmentsInfo::DecompressFromFile(), GDCM_NAME_SPACE::gdcm_read_JPEG2000_file(), gdcmAssertMacro, gdcmWarningMacro, GDCM_NAME_SPACE::JPEGFragmentsInfo::GetFirstFragment(), GDCM_NAME_SPACE::JPEGFragmentsInfo::GetFragmentCount(), GDCM_NAME_SPACE::JPEGFragment::GetLength(), GDCM_NAME_SPACE::JPEGFragmentsInfo::GetNextFragment(), GDCM_NAME_SPACE::JPEGFragment::GetOffset(), IsJPEG2000, IsJPEGLossless, IsJPEGLossy, IsJPEGLS, JPEGInfo, Raw, SamplesPerPixel, XSize, YSize, and ZSize. { if ( IsJPEG2000 ) { // make sure this is the right JPEG compression assert( !IsJPEGLossless || !IsJPEGLossy || !IsJPEGLS ); // FIXME this is really ugly but it seems I have to load the complete // 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 ) { 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 ) { 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 ) ) { return true; } // wow what happen, must be an error gdcmWarningMacro( "gdcm_read_JPEG2000_file() failed "); return false; } else if ( IsJPEGLS ) { // make sure this is the right JPEG compression assert( !IsJPEGLossless || !IsJPEGLossy || !IsJPEG2000 ); // WARNING : JPEG-LS is NOT the 'classical' Jpeg Lossless : // [JPEG-LS is the basis for new lossless/near-lossless compression // standard for continuous-tone images intended for JPEG2000. The standard // is based on the LOCO-I algorithm (LOw COmplexity LOssless COmpression // for Images) developed at Hewlett-Packard Laboratories] // // see http://datacompression.info/JPEGLS.shtml // #if 0 std::cerr << "count:" << JPEGInfo->GetFragmentCount() << std::endl; 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 ) { fp->seekg( jpegfrag->GetOffset(), std::ios::beg); fp->read(pinputdata, jpegfrag->GetLength()); pinputdata += jpegfrag->GetLength(); jpegfrag = JPEGInfo->GetNextFragment(); } //fp->read((char*)Raw, PixelDataLength); std::ofstream out("/tmp/jpegls.jpg"); out.write((char*)inputdata, inputlength); out.close(); delete[] inputdata; #endif 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; } else { // make sure this is the right JPEG compression assert( !IsJPEGLS || !IsJPEG2000 ); // Precompute the offset localRaw will be shifted with int length = XSize * YSize * ZSize * SamplesPerPixel; int numberBytes = BitsAllocated / 8; JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length ); return true; } }

bool GDCM_NAME_SPACE::PixelReadConvert::ReadAndDecompressPixelData (  std::ifstream *  fp  )  [private]

Reads from disk and decompresses Pixels. Definition at line 249 of file gdcmPixelReadConvert.cxx. References gdcmWarningMacro, PixelOffset, and Squeeze(). Referenced by GDCM_NAME_SPACE::FileHelper::GetRaw(). { // ComputeRawAndRGBSizes is already made by // ::GrabInformationsFromfile. So, the structure sizes are // correct Squeeze(); if ( !fp ) { gdcmWarningMacro( "Unavailable file pointer." ); return false; } fp->seekg( PixelOffset, std::ios::beg ); if ( fp->fail() || fp->eof() ) { 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; if ( BitsAllocated == 12 ) // We suppose 'BitsAllocated' = 12 only exist for uncompressed files { ReadAndDecompress12BitsTo16Bits( fp); } else if ( IsRaw ) { // This problem can be found when some obvious informations are found // after the field containing the image data. In this case, these // bad data are added to the size of the image (in the PixelDataLength // variable). But RawSize is the right size of the image ! if ( PixelDataLength != 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 ) lengthToRead = RawSize; else lengthToRead = PixelDataLength; // perform a frame by frame reading remainingLength = lengthToRead; unsigned int nbFrames = lengthToRead / frameSize; for (i=0;i<nbFrames; i++) { 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()) { gdcmWarningMacro( "Reading of Raw pixel data failed." ); return false; } } else if ( IsRLELossless ) { if ( ! RLEInfo->DecompressRLEFile ( fp, Raw, XSize, YSize, ZSize, TSize, BitsAllocated ) ) { gdcmWarningMacro( "RLE decompressor failed." ); return false; } } else if ( IsMPEG ) { //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" ); //return false; // fp has already been seek to start of mpeg //ReadMPEGFile(fp, (char*)Raw, PixelDataLength); return true; } else { // Default case concerns JPEG family if ( ! ReadAndDecompressJPEGFile( fp ) ) { gdcmWarningMacro( "JPEG decompressor ( ReadAndDecompressJPEGFile()" << " method ) failed." ); return false; } } ConvertReorderEndianity(); ConvertReArrangeBits(); ConvertFixGreyLevels(); if (UserFunction) // user is allowed to Mirror, TopDown, Rotate,...the image UserFunction( Raw, FileInternal); ConvertHandleColor(); return true; }

void GDCM_NAME_SPACE::Base::SetPrintLevel (  int  level  )  [inline, inherited]

Sets the print level for the Dicom Header Elements. Note: 0 for Light Print; 1 for 'medium' Print, 2 for Heavy Print Definition at line 47 of file gdcmBase.h. Referenced by GDCM_NAME_SPACE::FileHelper::Print(), and GDCM_NAME_SPACE::DicomDir::Print(). { PrintLevel = level; }

void GDCM_NAME_SPACE::PixelReadConvert::SetUserFunction (  VOID_FUNCTION_PUINT8_PFILE_POINTER  userFunc  )  [inline, private]

Allow user to pass his own function to modify pixels (e.g; mirror, upsidedown, ...) just after reading. Definition at line 80 of file gdcmPixelReadConvert.h. Referenced by GDCM_NAME_SPACE::FileHelper::GetRaw(). { UserFunction = userFunc; }

void GDCM_NAME_SPACE::PixelReadConvert::Squeeze (   )  [private]

Deletes Pixels Area. Definition at line 374 of file gdcmPixelReadConvert.cxx. References LutRGBA, Raw, and RGB. Referenced by ReadAndDecompressPixelData(), and ~PixelReadConvert(). { if ( RGB ) delete [] RGB; RGB = 0; if ( Raw ) delete [] Raw; Raw = 0; if ( LutRGBA ) delete [] LutRGBA; LutRGBA = 0; }

---

Friends And Related Function Documentation

friend class FileHelper [friend]

Definition at line 46 of file gdcmPixelReadConvert.h.

---

Member Data Documentation

bool GDCM_NAME_SPACE::PixelReadConvert::Abort [mutable, private]

Definition at line 177 of file gdcmPixelReadConvert.h. Referenced by CallStartMethod().

int GDCM_NAME_SPACE::PixelReadConvert::BitsAllocated [private]

Definition at line 134 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), BuildRGBImage(), ComputeRawAndRGBSizes(), ConvertFixGreyLevels(), ConvertReArrangeBits(), ConvertReorderEndianity(), ConvertSwapZone(), GrabInformationsFromFile(), and ReadAndDecompressJPEGFile().

int GDCM_NAME_SPACE::PixelReadConvert::BitsStored [private]

Definition at line 135 of file gdcmPixelReadConvert.h. Referenced by ConvertFixGreyLevels(), ConvertReArrangeBits(), ConvertReorderEndianity(), GrabInformationsFromFile(), and ReadAndDecompressJPEGFile().

FileHelper* GDCM_NAME_SPACE::PixelReadConvert::FH [private]

Needed for the progression bar stuff. Definition at line 176 of file gdcmPixelReadConvert.h. Referenced by CallEndMethod(), CallProgressMethod(), and CallStartMethod().

File* GDCM_NAME_SPACE::PixelReadConvert::FileInternal [private]

Definition at line 173 of file gdcmPixelReadConvert.h. Referenced by PixelReadConvert().

bool GDCM_NAME_SPACE::PixelReadConvert::HasLUT [private]

Definition at line 164 of file gdcmPixelReadConvert.h. Referenced by ComputeRawAndRGBSizes().

int GDCM_NAME_SPACE::PixelReadConvert::HighBitPosition [private]

Definition at line 136 of file gdcmPixelReadConvert.h. Referenced by ConvertReArrangeBits(), and GrabInformationsFromFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsJPEG [private]

Definition at line 151 of file gdcmPixelReadConvert.h.

bool GDCM_NAME_SPACE::PixelReadConvert::IsJPEG2000 [private]

Definition at line 147 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile(), Print(), and ReadAndDecompressJPEGFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsJPEGLossless [private]

Definition at line 149 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile(), Print(), and ReadAndDecompressJPEGFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsJPEGLossy [private]

Definition at line 150 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile(), Print(), and ReadAndDecompressJPEGFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsJPEGLS [private]

Definition at line 148 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile(), Print(), and ReadAndDecompressJPEGFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsMonochrome [private]

Definition at line 160 of file gdcmPixelReadConvert.h. Referenced by IsRawRGB().

bool GDCM_NAME_SPACE::PixelReadConvert::IsMonochrome1 [private]

Definition at line 161 of file gdcmPixelReadConvert.h. Referenced by ConvertFixGreyLevels().

bool GDCM_NAME_SPACE::PixelReadConvert::IsMPEG [private]

Definition at line 153 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsPaletteColor [private]

Definition at line 162 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), and IsRawRGB().

bool GDCM_NAME_SPACE::PixelReadConvert::IsPrivateGETransferSyntax [private]

Definition at line 144 of file gdcmPixelReadConvert.h. Referenced by ConvertSwapZone(), and GrabInformationsFromFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsRaw [private]

Definition at line 146 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile().

bool GDCM_NAME_SPACE::PixelReadConvert::IsRLELossless [private]

Definition at line 152 of file gdcmPixelReadConvert.h. Referenced by ConvertHandleColor(), GrabInformationsFromFile(), and Print().

bool GDCM_NAME_SPACE::PixelReadConvert::IsYBRFull [private]

Definition at line 163 of file gdcmPixelReadConvert.h. Referenced by ConvertHandleColor().

JPEGFragmentsInfo* GDCM_NAME_SPACE::PixelReadConvert::JPEGInfo [private]

Definition at line 156 of file gdcmPixelReadConvert.h. Referenced by PixelReadConvert(), Print(), and ReadAndDecompressJPEGFile().

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::LutBlueData [private]

Definition at line 171 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), and PixelReadConvert().

std::string GDCM_NAME_SPACE::PixelReadConvert::LutBlueDescriptor [private]

Definition at line 168 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA().

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::LutGreenData [private]

Definition at line 170 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), and PixelReadConvert().

std::string GDCM_NAME_SPACE::PixelReadConvert::LutGreenDescriptor [private]

Definition at line 167 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA().

int GDCM_NAME_SPACE::PixelReadConvert::LutItemNumber [private]

Definition at line 122 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA().

int GDCM_NAME_SPACE::PixelReadConvert::LutItemSize [private]

Definition at line 123 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA().

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::LutRedData [private]

Definition at line 169 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), and PixelReadConvert().

std::string GDCM_NAME_SPACE::PixelReadConvert::LutRedDescriptor [private]

Definition at line 166 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA().

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::LutRGBA [private]

Red/Green/Blue/Alpha LookUpTable build out of the Red/Green/Blue LUT descriptors (see BuildLUTRGBA ). Definition at line 121 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), BuildRGBImage(), PixelReadConvert(), and Squeeze().

size_t GDCM_NAME_SPACE::PixelReadConvert::PixelDataLength [private]

Definition at line 129 of file gdcmPixelReadConvert.h. Referenced by Print().

size_t GDCM_NAME_SPACE::PixelReadConvert::PixelOffset [private]

Definition at line 128 of file gdcmPixelReadConvert.h. Referenced by Print(), and ReadAndDecompressPixelData().

bool GDCM_NAME_SPACE::PixelReadConvert::PixelSign [private]

Definition at line 139 of file gdcmPixelReadConvert.h. Referenced by ConvertFixGreyLevels(), ConvertReArrangeBits(), ConvertReorderEndianity(), and GrabInformationsFromFile().

int GDCM_NAME_SPACE::PixelReadConvert::PlanarConfiguration [private]

Definition at line 159 of file gdcmPixelReadConvert.h. Referenced by ConvertHandleColor(), and IsRawRGB().

int GDCM_NAME_SPACE::Base::PrintLevel [protected, inherited]

Amount of printed details for each Dicom Entries : 0 : stands for the least detail level. Definition at line 55 of file gdcmBase.h. Referenced by GDCM_NAME_SPACE::SeqEntry::Print(), GDCM_NAME_SPACE::FileHelper::Print(), GDCM_NAME_SPACE::ElementSet::Print(), GDCM_NAME_SPACE::DocEntry::Print(), GDCM_NAME_SPACE::DictEntry::Print(), GDCM_NAME_SPACE::DicomDirStudy::Print(), GDCM_NAME_SPACE::DicomDirSerie::Print(), GDCM_NAME_SPACE::DicomDirPatient::Print(), GDCM_NAME_SPACE::DicomDirMeta::Print(), GDCM_NAME_SPACE::DicomDir::Print(), and GDCM_NAME_SPACE::DataEntry::Print().

float GDCM_NAME_SPACE::PixelReadConvert::Progress [private]

Definition at line 178 of file gdcmPixelReadConvert.h. Referenced by CallEndMethod(), and CallStartMethod().

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::Raw [private]

Pixel data after decompression and bit/byte rearrangement. Definition at line 116 of file gdcmPixelReadConvert.h. Referenced by AllocateRaw(), BuildRGBImage(), ConvertFixGreyLevels(), ConvertReArrangeBits(), ConvertReorderEndianity(), ConvertRGBPlanesToRGBPixels(), ConvertSwapZone(), ConvertYcBcRPlanesToRGBPixels(), PixelReadConvert(), ReadAndDecompressJPEGFile(), and Squeeze().

size_t GDCM_NAME_SPACE::PixelReadConvert::RawSize [private]

Size of Decompressed image. Definition at line 118 of file gdcmPixelReadConvert.h. Referenced by AllocateRaw(), BuildRGBImage(), ComputeRawAndRGBSizes(), ConvertFixGreyLevels(), ConvertReArrangeBits(), ConvertReorderEndianity(), ConvertRGBPlanesToRGBPixels(), ConvertSwapZone(), ConvertYcBcRPlanesToRGBPixels(), and PixelReadConvert().

uint8_t* GDCM_NAME_SPACE::PixelReadConvert::RGB [private]

Pixel data represented as RGB after LUT color interpretation. 'uint8_t' is just to avoid warnings at compile time. feel free to cast it as uint16_t if you need. Definition at line 112 of file gdcmPixelReadConvert.h. Referenced by AllocateRGB(), BuildRGBImage(), PixelReadConvert(), and Squeeze().

size_t GDCM_NAME_SPACE::PixelReadConvert::RGBSize [private]

Size of RGB image. Definition at line 114 of file gdcmPixelReadConvert.h. Referenced by AllocateRGB(), ComputeRawAndRGBSizes(), and PixelReadConvert().

RLEFramesInfo* GDCM_NAME_SPACE::PixelReadConvert::RLEInfo [private]

Definition at line 155 of file gdcmPixelReadConvert.h. Referenced by PixelReadConvert(), and Print().

int GDCM_NAME_SPACE::PixelReadConvert::SamplesPerPixel [private]

Definition at line 137 of file gdcmPixelReadConvert.h. Referenced by ComputeRawAndRGBSizes(), GrabInformationsFromFile(), and ReadAndDecompressJPEGFile().

int GDCM_NAME_SPACE::PixelReadConvert::SwapCode [private]

Definition at line 140 of file gdcmPixelReadConvert.h. Referenced by ConvertSwapZone(), and GrabInformationsFromFile().

int GDCM_NAME_SPACE::PixelReadConvert::TSize [private]

Definition at line 133 of file gdcmPixelReadConvert.h. Referenced by ComputeRawAndRGBSizes(), ConvertYcBcRPlanesToRGBPixels(), and GrabInformationsFromFile().

VOID_FUNCTION_PUINT8_PFILE_POINTER GDCM_NAME_SPACE::PixelReadConvert::UserFunction [private]

Definition at line 174 of file gdcmPixelReadConvert.h. Referenced by PixelReadConvert().

int GDCM_NAME_SPACE::PixelReadConvert::XSize [private]

Definition at line 130 of file gdcmPixelReadConvert.h. Referenced by ComputeRawAndRGBSizes(), ConvertRGBPlanesToRGBPixels(), ConvertYcBcRPlanesToRGBPixels(), GrabInformationsFromFile(), and ReadAndDecompressJPEGFile().

int GDCM_NAME_SPACE::PixelReadConvert::YSize [private]

Definition at line 131 of file gdcmPixelReadConvert.h. Referenced by ComputeRawAndRGBSizes(), ConvertRGBPlanesToRGBPixels(), ConvertYcBcRPlanesToRGBPixels(), GrabInformationsFromFile(), and ReadAndDecompressJPEGFile().

int GDCM_NAME_SPACE::PixelReadConvert::ZSize [private]

Definition at line 132 of file gdcmPixelReadConvert.h. Referenced by ComputeRawAndRGBSizes(), ConvertRGBPlanesToRGBPixels(), ConvertYcBcRPlanesToRGBPixels(), GrabInformationsFromFile(), and ReadAndDecompressJPEGFile().

---

The documentation for this class was generated from the following files:

• gdcmPixelReadConvert.h
• gdcmPixelReadConvert.cxx

---