gdcm::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 gdm user (internal use only). More...

#include <gdcmPixelReadConvert.h>

Inheritance diagram for gdcm::PixelReadConvert:

[legend]Collaboration diagram for gdcm::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	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 gdm user (internal use only).

Definition at line 44 of file gdcmPixelReadConvert.h.

---

Constructor & Destructor Documentation

gdcm::PixelReadConvert::PixelReadConvert (   )  [private]

Constructor. Definition at line 43 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::PixelReadConvert::~PixelReadConvert (   )  [private, virtual]

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

---

Member Function Documentation

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

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

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

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

void gdcm::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 614 of file gdcmPixelReadConvert.cxx. References BitsAllocated, gdcm::GDCM_UNFOUND, gdcmDebugMacro, gdcmWarningMacro, IsPaletteColor, LutBlueData, LutBlueDescriptor, LutGreenData, LutGreenDescriptor, LutItemNumber, LutItemSize, LutRedData, LutRedDescriptor, and LutRGBA. Referenced by BuildRGBImage(), and gdcm::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::PixelReadConvert::BuildRGBImage (   )  [private]

Build the RGB image from the Raw image and the LUTs. Definition at line 387 of file gdcmPixelReadConvert.cxx. References AllocateRGB(), BitsAllocated, BuildLUTRGBA(), gdcmDebugMacro, LutRGBA, Raw, RawSize, and RGB. Referenced by gdcm::FileHelper::GetImageData(), and gdcm::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::PixelReadConvert::CallEndMethod (   )  [private]

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

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

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

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

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

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

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

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

Deal with Grey levels i.e. re-arange them to have low values = dark, high values = bright. Definition at line 983 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, IsMonochrome1, PixelSign, Raw, and RawSize. Referenced by ReadAndDecompressPixelData(). { 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::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 1245 of file gdcmPixelReadConvert.cxx. References ConvertRGBPlanesToRGBPixels(), ConvertYcBcRPlanesToRGBPixels(), gdcmDebugMacro, IsRawRGB(), IsRLELossless, IsYBRFull, and PlanarConfiguration. Referenced by ReadAndDecompressPixelData(). { // 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::PixelReadConvert::ConvertReArrangeBits (   )  throw ( FormatError ) [private]

Re-arrange the bits within the bytes. Returns: Boolean always true Definition at line 1052 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, gdcmWarningMacro, HighBitPosition, PixelSign, Raw, and RawSize. Referenced by ReadAndDecompressPixelData(). { 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::PixelReadConvert::ConvertReorderEndianity (   )  [private]

Deal with endianness i.e. re-arange bytes inside the integer. Definition at line 954 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, ConvertSwapZone(), PixelSign, Raw, and RawSize. Referenced by ReadAndDecompressPixelData(). { 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::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 1147 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::PixelReadConvert::ConvertSwapZone (   )  [private]

Swap the bytes, according to SwapCode. Definition at line 837 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::PixelReadConvert::ConvertYcBcRPlanesToRGBPixels (   )  [private]

Convert (cY plane, cB plane, cR plane) to RGB pixels. Warning: Works on all the frames at a time 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 1174 of file gdcmPixelReadConvert.cxx. References gdcmWarningMacro, Raw, RawSize, 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; 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::PixelReadConvert::GetLutItemNumber (   )  [inline, private]

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

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

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

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

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

int gdcm::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::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::FileHelper::GetImageData(), gdcm::FileHelper::GetRaw(), gdcm::FileHelper::GetRawData(), gdcm::FileHelper::SetWriteToRaw(), gdcm::FileHelper::SetWriteToRGB(), and gdcm::FileHelper::WriteRawData(). { return Raw; }

size_t gdcm::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::FileHelper::GetImageDataRawSize(), gdcm::FileHelper::GetRawDataSize(), gdcm::FileHelper::SetWriteToRaw(), gdcm::FileHelper::SetWriteToRGB(), and gdcm::FileHelper::WriteRawData(). { return RawSize; }

uint8_t* gdcm::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::FileHelper::GetImageData(), gdcm::FileHelper::GetRGBData(), gdcm::FileHelper::SetWriteToRGB(), and gdcm::FileHelper::WriteRawData(). { return RGB; }

size_t gdcm::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::FileHelper::GetImageDataSize(), gdcm::FileHelper::GetRGBDataSize(), gdcm::FileHelper::SetWriteToRGB(), and gdcm::FileHelper::WriteRawData(). { return RGBSize; }

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

Gets various usefull informations from the file header. Parameters: file  gdcm::File pointer Definition at line 85 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, ComputeRawAndRGBSizes(), FH, FileInternal, gdcmWarningMacro, gdcm::File::GetBitsAllocated(), gdcm::File::GetBitsStored(), gdcm::DocEntrySet::GetEntryBinArea(), gdcm::DocEntrySet::GetEntryString(), gdcm::File::GetHighBitPosition(), gdcm::File::GetJPEGInfo(), gdcm::File::GetPixelAreaLength(), gdcm::File::GetPixelOffset(), gdcm::File::GetPlanarConfiguration(), gdcm::File::GetRLEInfo(), gdcm::File::GetSamplesPerPixel(), gdcm::Document::GetSwapCode(), gdcm::Document::GetTransferSyntax(), gdcm::Global::GetTS(), gdcm::File::GetXSize(), gdcm::File::GetYSize(), gdcm::File::GetZSize(), gdcm::File::HasLUT(), HasLUT, HighBitPosition, gdcm::Document::IsDicomV3(), IsJPEG2000, IsJPEGLossless, IsJPEGLossy, IsJPEGLS, gdcm::File::IsMonochrome(), IsMonochrome, gdcm::File::IsMonochrome1(), IsMonochrome1, IsMPEG, gdcm::File::IsPaletteColor(), IsPaletteColor, IsPrivateGETransferSyntax, IsRaw, IsRLELossless, gdcm::File::IsSignedPixelData(), gdcm::File::IsYBRFull(), IsYBRFull, JPEGInfo, gdcm::Document::LoadEntryBinArea(), LutBlueData, LutBlueDescriptor, LutGreenData, LutGreenDescriptor, LutRedData, LutRedDescriptor, PixelDataLength, PixelOffset, PixelSign, PlanarConfiguration, RLEInfo, SamplesPerPixel, SwapCode, XSize, YSize, and ZSize. Referenced by gdcm::FileHelper::FileHelper(), and gdcm::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; } // 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(); 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) // short 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; 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; 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::PixelReadConvert::IsRawRGB (   )  [private]

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

void gdcm::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::Base. Definition at line 1372 of file gdcmPixelReadConvert.cxx. References gdcmWarningMacro, IsJPEG2000, IsJPEGLossless, IsJPEGLossy, IsJPEGLS, IsRLELossless, JPEGInfo, PixelDataLength, PixelOffset, and RLEInfo. Referenced by gdcm::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::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: JPR Troubles expected on Big-Endian processors ? Definition at line 450 of file gdcmPixelReadConvert.cxx. Referenced by ReadAndDecompressPixelData(). { int nbPixels = XSize * YSize; 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::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 500 of file gdcmPixelReadConvert.cxx. References BitsAllocated, BitsStored, gdcm::JPEGFragmentsInfo::DecompressFromFile(), gdcm::gdcm_read_JPEG2000_file(), gdcmAssertMacro, gdcmWarningMacro, gdcm::JPEGFragmentsInfo::GetFirstFragment(), gdcm::JPEGFragmentsInfo::GetFragmentCount(), gdcm::JPEGFragment::GetLength(), gdcm::JPEGFragmentsInfo::GetNextFragment(), gdcm::JPEGFragment::GetOffset(), IsJPEG2000, IsJPEGLossless, IsJPEGLossy, IsJPEGLS, JPEGInfo, Raw, SamplesPerPixel, XSize, and YSize. Referenced by ReadAndDecompressPixelData(). { 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 * SamplesPerPixel; int numberBytes = BitsAllocated / 8; JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length ); return true; } }

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

Reads from disk and decompresses Pixels. Definition at line 236 of file gdcmPixelReadConvert.cxx. References AllocateRaw(), BitsAllocated, CallStartMethod(), ConvertFixGreyLevels(), ConvertHandleColor(), ConvertReArrangeBits(), ConvertReorderEndianity(), gdcm::RLEFramesInfo::DecompressRLEFile(), FileInternal, gdcmWarningMacro, IsMPEG, IsRaw, IsRLELossless, PixelDataLength, PixelOffset, Progress, Raw, RawSize, ReadAndDecompress12BitsTo16Bits(), ReadAndDecompressJPEGFile(), RLEInfo, SamplesPerPixel, Squeeze(), UserFunction, XSize, YSize, and ZSize. Referenced by gdcm::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) 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 ( PixelDataLength > RawSize ) //{ // fp->read( (char*)Raw, RawSize); // Read all the frames with a single fread //} //else //{ // fp->read( (char*)Raw, PixelDataLength); // Read all the frames with a single fread //} 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, 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::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::SQItem::Print(), gdcm::SeqEntry::Print(), gdcm::FileHelper::Print(), gdcm::ElementSet::Print(), and gdcm::DicomDir::Print(). { PrintLevel = level; }

void gdcm::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::FileHelper::GetRaw(). { UserFunction = userFunc; }

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

Deletes Pixels Area. Definition at line 369 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::PixelReadConvert::Abort [mutable, private]

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

int gdcm::PixelReadConvert::BitsAllocated [private]

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

int gdcm::PixelReadConvert::BitsStored [private]

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

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

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

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

Definition at line 172 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile(), PixelReadConvert(), and ReadAndDecompressPixelData().

bool gdcm::PixelReadConvert::HasLUT [private]

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

int gdcm::PixelReadConvert::HighBitPosition [private]

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

bool gdcm::PixelReadConvert::IsJPEG [private]

Definition at line 150 of file gdcmPixelReadConvert.h.

bool gdcm::PixelReadConvert::IsJPEG2000 [private]

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

bool gdcm::PixelReadConvert::IsJPEGLossless [private]

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

bool gdcm::PixelReadConvert::IsJPEGLossy [private]

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

bool gdcm::PixelReadConvert::IsJPEGLS [private]

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

bool gdcm::PixelReadConvert::IsMonochrome [private]

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

bool gdcm::PixelReadConvert::IsMonochrome1 [private]

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

bool gdcm::PixelReadConvert::IsMPEG [private]

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

bool gdcm::PixelReadConvert::IsPaletteColor [private]

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

bool gdcm::PixelReadConvert::IsPrivateGETransferSyntax [private]

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

bool gdcm::PixelReadConvert::IsRaw [private]

Definition at line 145 of file gdcmPixelReadConvert.h. Referenced by GrabInformationsFromFile(), and ReadAndDecompressPixelData().

bool gdcm::PixelReadConvert::IsRLELossless [private]

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

bool gdcm::PixelReadConvert::IsYBRFull [private]

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

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

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

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

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

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

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

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

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

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

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

int gdcm::PixelReadConvert::LutItemNumber [private]

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

int gdcm::PixelReadConvert::LutItemSize [private]

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

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

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

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

Definition at line 165 of file gdcmPixelReadConvert.h. Referenced by BuildLUTRGBA(), and GrabInformationsFromFile().

uint8_t* gdcm::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::PixelReadConvert::PixelDataLength [private]

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

size_t gdcm::PixelReadConvert::PixelOffset [private]

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

bool gdcm::PixelReadConvert::PixelSign [private]

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

int gdcm::PixelReadConvert::PlanarConfiguration [private]

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

int gdcm::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::SQItem::Print(), gdcm::SeqEntry::Print(), gdcm::FileHelper::Print(), gdcm::ElementSet::Print(), gdcm::DocEntry::Print(), gdcm::DictEntry::Print(), gdcm::DicomDirStudy::Print(), gdcm::DicomDirSerie::Print(), gdcm::DicomDirPatient::Print(), gdcm::DicomDirMeta::Print(), gdcm::DicomDir::Print(), and gdcm::DataEntry::Print().

float gdcm::PixelReadConvert::Progress [private]

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

uint8_t* gdcm::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(), ReadAndDecompressPixelData(), and Squeeze().

size_t gdcm::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(), PixelReadConvert(), and ReadAndDecompressPixelData().

uint8_t* gdcm::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::PixelReadConvert::RGBSize [private]

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

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

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

int gdcm::PixelReadConvert::SamplesPerPixel [private]

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

int gdcm::PixelReadConvert::SwapCode [private]

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

VOID_FUNCTION_PUINT8_PFILE_POINTER gdcm::PixelReadConvert::UserFunction [private]

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

int gdcm::PixelReadConvert::XSize [private]

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

int gdcm::PixelReadConvert::YSize [private]

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

int gdcm::PixelReadConvert::ZSize [private]

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

---

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

• gdcmPixelReadConvert.h
• gdcmPixelReadConvert.cxx

---