gdcmFile Class Reference

#include <gdcmFile.h>

List of all members.

Public Member Functions
	gdcmFile (gdcmHeader *header)
	Constructor dedicated to writing a new DICOMV3 part10 compliant file (see SetFileName, SetDcmTag and Write) Opens (in read only and when possible) an existing file and checks for DICOM compliance. Returns NULL on failure.
	gdcmFile (std::string &filename)
	Constructor dedicated to writing a new DICOMV3 part10 compliant file (see SetFileName, SetDcmTag and Write) Opens (in read only and when possible) an existing file and checks for DICOM compliance. Returns NULL on failure.
	gdcmFile (const char *filename)
	Constructor dedicated to writing a new DICOMV3 part10 compliant file (see SetFileName, SetDcmTag and Write) Opens (in read only and when possible) an existing file and checks for DICOM compliance. Returns NULL on failure.
virtual	~gdcmFile (void)
	canonical destructor If the gdcmHeader is created by the gdcmFile, it is destroyed by the gdcmFile
gdcmHeader *	GetHeader (void)
void	SetPixelDataSizeFromHeader (void)
	computes the length (in bytes) to ALLOCATE to receive the image(s) pixels (multiframes taken into account)
size_t	GetImageDataSize ()
	Returns the size (in bytes) of required memory to hold the pixel data represented in this file.
size_t	GetImageDataSizeRaw ()
	Returns the size (in bytes) of required memory to hold the pixel data represented in this file, when user DOESN'T want to get RGB pixels image when it's stored as a PALETTE COLOR image -the (vtk) user is supposed to know how deal with LUTs-.
void *	GetImageData ()
	Allocates necessary memory, copies the pixel data (image[s]/volume[s]) to newly allocated zone. Transforms YBR pixels into RGB pixels if any Transforms 3 planes R, G, B into a single RGB Plane Transforms single Grey plane + 3 Palettes into a RGB Plane.
size_t	GetImageDataIntoVector (void *destination, size_t MaxSize)
	Copies at most MaxSize bytes of pixel data to caller's memory space.
void *	GetImageDataRaw ()
	Allocates necessary memory, copies the pixel data (image[s]/volume[s]) to newly allocated zone. Transforms YBR pixels into RGB pixels if any Transforms 3 planes R, G, B into a single RGB Plane DOES NOT transform Grey plane + 3 Palettes into a RGB Plane.
size_t	GetImageDataIntoVectorRaw (void *destination, size_t MaxSize)
	Copies at most MaxSize bytes of pixel data to caller's memory space.
bool	SetImageData (void *Data, size_t ExpectedSize)
	TODO JPR.
bool	WriteRawData (std::string fileName)
	Writes on disk A SINGLE Dicom file NO test is performed on processor "Endiannity". It's up to the user to call his Reader properly.
bool	WriteDcmImplVR (std::string fileName)
	Writes on disk A SINGLE Dicom file NO test is performed on processor "Endiannity".
bool	WriteDcmImplVR (const char *fileName)
bool	WriteDcmExplVR (std::string fileName)
bool	WriteAcr (std::string fileName)
	Ecrit au format ACR-NEMA sur disque l'entete et les pixels (a l'attention des logiciels cliniques qui ne prennent en entrée QUE des images ACR ...
bool	ParsePixelData (void)
	Parse pixel data from disk and *prints* the result \ For multi-fragment Jpeg/Rle files checking purpose *only* \ Allows to 'see' if the file *does* conform \ (some of them do not) \ with Dicom Part 3, Annex A (PS 3.5-2003, page 58, page 85).
Protected Member Functions
bool	WriteBase (std::string FileName, FileType type)
Private Member Functions
void	SwapZone (void *im, int swap, int lgr, int nb)
	Swap the bytes, according to swap code.
bool	ReadPixelData (void *destination)
	Read pixel data from disk (optionaly decompressing) into the caller specified memory location.
bool	gdcm_read_JPEG_file (FILE *fp, void *image_buffer)
bool	gdcm_read_JPEG_file12 (FILE *fp, void *image_buffer)
bool	gdcm_read_JPEG2000_file (FILE *fp, void *image_buffer)
bool	gdcm_read_RLE_file (FILE *fp, void *image_buffer)
	Reads a 'Run Length Encoded' Dicom encapsulated file.
Static Private Member Functions
int	gdcm_read_RLE_fragment (char **areaToRead, long lengthToDecode, long uncompressedSegmentSize, FILE *fp)
Private Attributes
gdcmHeader *	Header
bool	SelfHeader
void *	PixelData
size_t	lgrTotaleRaw
size_t	lgrTotale
int	PixelRead
int	Parsed
std::string	OrigFileName

---

Constructor & Destructor Documentation

gdcmFile::gdcmFile (  gdcmHeader *  header  )

Constructor dedicated to writing a new DICOMV3 part10 compliant file (see SetFileName, SetDcmTag and Write) Opens (in read only and when possible) an existing file and checks for DICOM compliance. Returns NULL on failure. Note: the in-memory representation of all available tags found in the DICOM header is post-poned to first header information access. This avoid a double parsing of public part of the header when one sets an a posteriori shadow dictionary (efficiency can be seen as a side effect). Parameters: header  file to be opened for reading datas Returns: Definition at line 26 of file gdcmFile.cxx. References Header, gdcmHeader::IsReadable(), PixelRead, SelfHeader, and SetPixelDataSizeFromHeader(). { Header=header; SelfHeader=false; PixelRead=-1; // no ImageData read yet. if (Header->IsReadable()) SetPixelDataSizeFromHeader(); }

gdcmFile::gdcmFile (  std::string &  filename  )

Constructor dedicated to writing a new DICOMV3 part10 compliant file (see SetFileName, SetDcmTag and Write) Opens (in read only and when possible) an existing file and checks for DICOM compliance. Returns NULL on failure. Note: the in-memory representation of all available tags found in the DICOM header is post-poned to first header information access. This avoid a double parsing of public part of the header when one sets an a posteriori shadow dictionary (efficiency can be seen as a side effect). Parameters: filename  file to be opened for parsing Definition at line 48 of file gdcmFile.cxx. References Header, gdcmHeader::IsReadable(), PixelRead, SelfHeader, and SetPixelDataSizeFromHeader(). { Header=new gdcmHeader(filename.c_str()); SelfHeader=true; PixelRead=-1; // no ImageData read yet. if (Header->IsReadable()) SetPixelDataSizeFromHeader(); }

gdcmFile::gdcmFile (  const char *  filename  )

Constructor dedicated to writing a new DICOMV3 part10 compliant file (see SetFileName, SetDcmTag and Write) Opens (in read only and when possible) an existing file and checks for DICOM compliance. Returns NULL on failure. Note: the in-memory representation of all available tags found in the DICOM header is post-poned to first header information access. This avoid a double parsing of public part of the header when one sets an a posteriori shadow dictionary (efficiency can be seen as a side effect). Parameters: filename  file to be opened for parsing Definition at line 70 of file gdcmFile.cxx. References Header, gdcmHeader::IsReadable(), PixelRead, SelfHeader, and SetPixelDataSizeFromHeader(). { Header=new gdcmHeader(filename); SelfHeader=true; PixelRead=-1; // no ImageData read yet. if (Header->IsReadable()) SetPixelDataSizeFromHeader(); }

gdcmFile::~gdcmFile (  void   )  [virtual]

canonical destructor If the gdcmHeader is created by the gdcmFile, it is destroyed by the gdcmFile Definition at line 85 of file gdcmFile.cxx. References Header, and SelfHeader. { if(SelfHeader) delete Header; Header=NULL; }

---

Member Function Documentation

bool gdcmFile::gdcm_read_JPEG2000_file (  FILE *  fp, void *  image_buffer )  [private]

Definition at line 7 of file gdcmJpeg2000.cxx. Referenced by ReadPixelData(). { printf("Sorry JPEG 2000 File not yet taken into account\n"); return false; }

bool gdcmFile::gdcm_read_JPEG_file (  FILE *  fp, void *  image_buffer )  [private]

Referenced by ReadPixelData().

bool gdcmFile::gdcm_read_JPEG_file12 (  FILE *  fp, void *  image_buffer )  [private]

Definition at line 164 of file gdcmJpeg12.cxx. References BITS_IN_JSAMPLE, DEBUG, jpeg_create_decompress, jpeg_destroy_decompress, jpeg_finish_decompress, jpeg_read_header, jpeg_read_scanlines, jpeg_start_decompress, jpeg_std_error, jpeg_stdio_src, my_error_exit, my_error_mgr::pub, and my_error_mgr::setjmp_buffer. Referenced by ReadPixelData(). { char *pimage; /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* -------------- inside, we found : * JDIMENSION image_width; // input image width * JDIMENSION image_height; // input image height * int input_components; // nb of color components in input image * J_COLOR_SPACE in_color_space; // colorspace of input image * double input_gamma; // image gamma of input image * -------------- */ /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct my_error_mgr jerr; /* More stuff */ JSAMPARRAY buffer; /* Output row buffer */ // rappel : // ------ // typedef unsigned char JSAMPLE; // typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ // typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ // typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ int row_stride; /* physical row width in output buffer */ if (DEBUG) printf("entree dans gdcmFile::gdcm_read_JPEG_file12, depuis gdcmJpeg\n"); /* In this example we want to open the input file before doing anything else, * so that the setjmp() error recovery below can assume the file is open. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to read binary files. */ /* Step 1: allocate and initialize JPEG decompression object */ if (DEBUG)printf("Entree Step 1\n"); /* We set up the normal JPEG error routines, then override error_exit. */ cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp(jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_decompress(&cinfo); return(false); } /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* Step 2: specify data source (eg, a file) */ if (DEBUG) printf("Entree Step 2\n"); jpeg_stdio_src(&cinfo, fp); /* Step 3: read file parameters with jpeg_read_header() */ if (DEBUG) printf("Entree Step 3\n"); (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ if (DEBUG) { printf("--------------Header contents :----------------\n"); printf("image_width %d image_height %d\n", cinfo.image_width , cinfo.image_height); printf("bits of precision in image data %d \n", cinfo.output_components); printf("nb of color components returned %d \n", cinfo.data_precision); } /* * JDIMENSION image_width; // input image width * JDIMENSION image_height; // input image height * int output_components; // # of color components returned * J_COLOR_SPACE in_color_space; // colorspace of input image * double input_gamma; // image gamma of input image * int data_precision; // bits of precision in image data */ /* Step 4: set parameters for decompression */ if (DEBUG) printf("Entree Step 4\n"); /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ /* Step 5: Start decompressor */ if (DEBUG) printf("Entree Step 5\n"); (void) jpeg_start_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* JSAMPLEs per row in output buffer */ row_stride = cinfo.output_width * cinfo.output_components; if (DEBUG) printf ("cinfo.output_width %d cinfo.output_components %d row_stride %d\n", cinfo.output_width, cinfo.output_components,row_stride); /* Make a one-row-high sample array that will go away when done with image */ buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); /* Step 6: while (scan lines remain to be read) */ if (DEBUG) printf("Entree Step 6\n"); /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ if (DEBUG) printf ("cinfo.output_height %d cinfo.output_width %d\n", cinfo.output_height,cinfo.output_width); pimage=(char *)image_buffer; while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ (void) jpeg_read_scanlines(&cinfo, buffer, 1); if ( BITS_IN_JSAMPLE == 8) { memcpy( pimage, buffer[0],row_stride); pimage+=row_stride; } else { memcpy( pimage, buffer[0],row_stride*2 ); // FIXME : *2 car 16 bits?!? pimage+=row_stride*2; // FIXME : *2 car 16 bits?!? } } /* Step 7: Finish decompression */ if (DEBUG) printf("Entree Step 7\n"); (void) jpeg_finish_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ if (DEBUG) printf("Entree Step 8\n"); /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&cinfo); /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */ /* And we're done! */ return(true); }

bool gdcmFile::gdcm_read_RLE_file (  FILE *  fp, void *  image_buffer )  [private]

Reads a 'Run Length Encoded' Dicom encapsulated file. Parameters: fp  already open File Pointer image_buffer  destination Address (in caller's memory space) at which the pixel data should be copied Returns: Boolean Definition at line 19 of file gdcmRLE.cxx. References gdcm_read_RLE_fragment(), gdcmHeader::GetBitsAllocated(), gdcmParser::GetSwapCode(), gdcmHeader::GetXSize(), gdcmHeader::GetYSize(), gdcmHeader::GetZSize(), Header, lgrTotale, str2num, gdcmParser::SwapLong(), and gdcmParser::SwapShort(). Referenced by ReadPixelData(). { long fragmentBegining; // for ftell, fseek char * im = (char *)image_buffer; long RleSegmentLength[15],fragmentLength,uncompressedSegmentSize;; long ftellRes, ln; guint32 nbRleSegments; guint32 RleSegmentOffsetTable[15]; guint16 ItemTagGr,ItemTagEl; uncompressedSegmentSize=Header->GetXSize()*Header->GetYSize(); ftellRes=ftell(fp); // Basic Offset Table with Item Value // Item Tag fread(&ItemTagGr,2,1,fp); // Reading (fffe):Basic Offset Table Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000):Basic Offset Table Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } // Item Length ftellRes=ftell(fp); fread(&ln,4,1,fp); if(Header->GetSwapCode()) ln=Header->SwapLong(ln); // Basic Offset Table Item Lentgh if (ln != 0) { // What is it used for ?? char * BasicOffsetTableItemValue= (char *)malloc(ln+1); fread(BasicOffsetTableItemValue,ln,1,fp); guint32 a; for (int i=0;i<ln;i+=4){ a=str2num(&BasicOffsetTableItemValue[i],guint32); } } ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } // while 'Sequence Delimiter Item' (fffe,e0dd) not found while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) { // Parse fragments of the current Fragment (Frame) ftellRes=ftell(fp); fread(&fragmentLength,4,1,fp); if(Header->GetSwapCode()) fragmentLength=Header->SwapLong(fragmentLength); // length //------------------ scanning (not reading) fragment pixels fread(&nbRleSegments,4,1,fp); // Reading : Number of RLE Segments if(Header->GetSwapCode()) nbRleSegments=Header->SwapLong(nbRleSegments); for(int k=1; k<=15; k++) { // Reading RLE Segments Offset Table ftellRes=ftell(fp); fread(&RleSegmentOffsetTable[k],4,1,fp); if(Header->GetSwapCode()) RleSegmentOffsetTable[k]=Header->SwapLong(RleSegmentOffsetTable[k]); } if (nbRleSegments>1) { for(int k=1; k<=nbRleSegments-1; k++) { // reading RLE Segments RleSegmentLength[k]=RleSegmentOffsetTable[k+1]-RleSegmentOffsetTable[k]; ftellRes=ftell(fp); fragmentBegining=ftell(fp); gdcm_read_RLE_fragment (&im, RleSegmentLength[k],uncompressedSegmentSize,fp); fseek(fp,fragmentBegining,SEEK_SET); fseek(fp,RleSegmentLength[k],SEEK_CUR); } } RleSegmentLength[nbRleSegments] = fragmentLength - RleSegmentOffsetTable[nbRleSegments]; ftellRes=ftell(fp); fragmentBegining=ftell(fp); gdcm_read_RLE_fragment (&im, RleSegmentLength[nbRleSegments],uncompressedSegmentSize, fp); fseek(fp,fragmentBegining,SEEK_SET); fseek(fp,RleSegmentLength[nbRleSegments],SEEK_CUR); // end of scanning fragment pixels ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } } if (Header->GetBitsAllocated()==16) { // try to deal with RLE 16 Bits im = (char *)image_buffer; // need to make 16 Bits Pixels from Low Byte and Hight Byte 'Planes' int l = Header->GetXSize()*Header->GetYSize(); int nbFrames = Header->GetZSize(); char * newDest = (char*) malloc(l*nbFrames*2); char *x = newDest; char * a = (char *)image_buffer; char * b = a + l; for (int i=0;i<nbFrames;i++) { for (int j=0;j<l; j++) { *(x++) = *(a++); *(x++) = *(b++); } } memmove(image_buffer,newDest,lgrTotale); free(newDest); } return(true); }

int gdcmFile::gdcm_read_RLE_fragment (  char **  areaToRead, long  lengthToDecode, long  uncompressedSegmentSize, FILE *  fp )  [static, private]

Definition at line 139 of file gdcmRLE.cxx. Referenced by gdcm_read_RLE_file(). { long ftellRes; int count; long numberOfOutputBytes=0; char n, car; ftellRes =ftell(fp); while(numberOfOutputBytes<uncompressedSegmentSize) { ftellRes =ftell(fp); fread(&n,sizeof(char),1,fp); count=n; if (count >= 0 && count <= 127) { fread(*areaToRead,(count+1)*sizeof(char),1,fp); *areaToRead+=count+1; numberOfOutputBytes+=count+1; } else { if (count <= -1 && count >= -127) { fread(&car,sizeof(char),1,fp); for(int i=0; i<-count+1; i++) { (*areaToRead)[i]=car; } *areaToRead+=(-count+1); numberOfOutputBytes+=(-count+1); } } // if count = 128 output nothing (See : PS 3.5-2003 Page 86) } return 1; }

gdcmHeader * gdcmFile::GetHeader (  void   )

Returns: Definition at line 101 of file gdcmFile.cxx. References Header. { return(Header); }

void * gdcmFile::GetImageData (  void   )

Allocates necessary memory, copies the pixel data (image[s]/volume[s]) to newly allocated zone. Transforms YBR pixels into RGB pixels if any Transforms 3 planes R, G, B into a single RGB Plane Transforms single Grey plane + 3 Palettes into a RGB Plane. Returns: Pointer to newly allocated pixel data. NULL if alloc fails Definition at line 195 of file gdcmFile.cxx. References GetImageDataIntoVector(), lgrTotale, PixelData, and PixelRead. { PixelData = (void *) malloc(lgrTotale); if (PixelData) GetImageDataIntoVector(PixelData, lgrTotale); PixelRead=0; // no PixelRaw return(PixelData); }

size_t gdcmFile::GetImageDataIntoVector (  void *  destination, size_t  MaxSize )

Copies at most MaxSize bytes of pixel data to caller's memory space. Warning: This function was designed to avoid people that want to build a volume from an image stack to need first to get the image pixels and then move them to the volume area. It's absolutely useless for any VTK user since vtk chooses to invert the lines of an image, that is the last line comes first (for some axis related reasons?). Hence he will have to load the image line by line, starting from the end. VTK users have to call GetImageData Parameters: destination  Address (in caller's memory space) at which the pixel data should be copied MaxSize  Maximum number of bytes to be copied. When MaxSize is not sufficient to hold the pixel data the copy is not executed (i.e. no partial copy). Returns: On success, the number of bytes actually copied. Zero on failure e.g. MaxSize is lower than necessary. Definition at line 224 of file gdcmFile.cxx. References GetImageDataIntoVectorRaw(), gdcmHeader::GetLUTRGBA(), gdcmHeader::HasLUT(), Header, lgrTotale, lgrTotaleRaw, PixelRead, and gdcmHeader::SetEntryByNumber(). Referenced by GetImageData(). { size_t l = GetImageDataIntoVectorRaw (destination, MaxSize); PixelRead=0 ; // no PixelRaw if (!Header->HasLUT()) return lgrTotale; // from Lut R + Lut G + Lut B unsigned char * newDest = (unsigned char *)malloc(lgrTotale); unsigned char * a = (unsigned char *)destination; unsigned char * lutRGBA = Header->GetLUTRGBA(); if (lutRGBA) { int l = lgrTotaleRaw; memmove(newDest, destination, l);// move Gray pixels to temp area int j; for (int i=0;i<l; i++) { // Build RGB Pixels j=newDest[i]*4; *a++ = lutRGBA[j]; *a++ = lutRGBA[j+1]; *a++ = lutRGBA[j+2]; } free(newDest); // now, it's an RGB image // Lets's write it in the Header // CreateOrReplaceIfExist ? std::string spp = "3"; // Samples Per Pixel Header->SetEntryByNumber(spp,0x0028,0x0002); std::string rgb= "RGB "; // Photometric Interpretation Header->SetEntryByNumber(rgb,0x0028,0x0004); std::string planConfig = "0"; // Planar Configuration Header->SetEntryByNumber(planConfig,0x0028,0x0006); } else { // need to make RGB Pixels (?) // from grey Pixels (?!) // and Gray Lut (!?!) // or Segmented xxx Palette Color Lookup Table Data and so on // Oops! I get one (gdcm-US-ALOKA-16.dcm) // No idea how to manage such an image // It seems that *no Dicom Viewer* has any idea :-( // Segmented xxx Palette Color are *more* than 65535 long ?!? std::string rgb= "MONOCHROME1 "; // Photometric Interpretation Header->SetEntryByNumber(rgb,0x0028,0x0004); } // TODO : Drop Palette Color out of the Header? return lgrTotale; }

size_t gdcmFile::GetImageDataIntoVectorRaw (  void *  destination, size_t  MaxSize )

Copies at most MaxSize bytes of pixel data to caller's memory space. Warning: This function was designed to avoid people that want to build a volume from an image stack to need first to get the image pixels and then move them to the volume area. It's absolutely useless for any VTK user since vtk chooses to invert the lines of an image, that is the last line comes first (for some axis related reasons?). Hence he will have to load the image line by line, starting from the end. VTK users hace to call GetImageData DOES NOT transform the Grey Plane + Palette Color (if any) into a single RGB Pixels Plane the (VTK) user will manage the palettes Parameters: destination  Address (in caller's memory space) at which the pixel data should be copied MaxSize  Maximum number of bytes to be copied. When MaxSize is not sufficient to hold the pixel data the copy is not executed (i.e. no partial copy). Returns: On success, the number of bytes actually copied. Zero on failure e.g. MaxSize is lower than necessary. Definition at line 322 of file gdcmFile.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmHeader::GetPlanarConfiguration(), gdcmParser::GetSwapCode(), gdcmHeader::GetXSize(), gdcmHeader::GetYSize(), gdcmHeader::GetZSize(), Header, lgrTotale, PixelRead, ReadPixelData(), gdcmHeader::SetEntryByNumber(), SwapZone(), and gdcmDebug::Verbose(). Referenced by GetImageDataIntoVector(), and GetImageDataRaw(). { int nb, nbu, highBit, signe; std::string str_nbFrames, str_nb, str_nbu, str_highBit, str_signe; PixelRead=1 ; // PixelRaw if ( lgrTotale > MaxSize ) { dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: pixel data bigger" "than caller's expected MaxSize"); return (size_t)0; } (void)ReadPixelData(destination); // Number of Bits Allocated for storing a Pixel str_nb = Header->GetEntryByNumber(0x0028,0x0100); if (str_nb == GDCM_UNFOUND ) { nb = 16; } else { nb = atoi(str_nb.c_str() ); } // Number of Bits actually used str_nbu=Header->GetEntryByNumber(0x0028,0x0101); if (str_nbu == GDCM_UNFOUND ) { nbu = nb; } else { nbu = atoi(str_nbu.c_str() ); } // High Bit Position str_highBit=Header->GetEntryByNumber(0x0028,0x0102); if (str_highBit == GDCM_UNFOUND ) { highBit = nb - 1; } else { highBit = atoi(str_highBit.c_str() ); } // Pixel sign // 0 = Unsigned // 1 = Signed str_signe=Header->GetEntryByNumber(0x0028,0x0103); if (str_signe == GDCM_UNFOUND ) { signe = 0; // default is unsigned } else { signe = atoi(str_signe.c_str() ); } // re arange bytes inside the integer (processor endianity) if (nb != 8) SwapZone(destination, Header->GetSwapCode(), lgrTotale, nb); // to avoid pb with some xmedcon breakers images if (nb==16 && nbu<nb && signe==0) { int l = (int)lgrTotale / (nb/8); guint16 *deb = (guint16 *)destination; for(int i = 0; i<l; i++) { if(*deb == 0xffff) *deb=0; deb++; } } // re arange bits inside the bytes if (nbu != nb){ int l = (int)lgrTotale / (nb/8); if (nb == 16) { guint16 mask = 0xffff; mask = mask >> (nb-nbu); guint16 *deb = (guint16 *)destination; for(int i = 0; i<l; i++) { *deb = (*deb >> (nbu-highBit-1)) & mask; deb ++; } } else if (nb == 32 ) { guint32 mask = 0xffffffff; mask = mask >> (nb-nbu); guint32 *deb = (guint32 *)destination; for(int i = 0; i<l; i++) { *deb = (*deb >> (nbu-highBit-1)) & mask; deb ++; } } else { dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: wierd image"); return (size_t)0; } } // DO NOT remove this code commented out. // Nobody knows what's expecting you ... // Just to 'see' what was actually read on disk :-( // FILE * f2; // f2 = fopen("SpuriousFile.RAW","wb"); // fwrite(destination,lgrTotale,1,f2); // fclose(f2); // Deal with the color // ------------------- std::string str_PhotometricInterpretation = Header->GetEntryByNumber(0x0028,0x0004); if ( (str_PhotometricInterpretation == "MONOCHROME1 ") || (str_PhotometricInterpretation == "MONOCHROME2 ") ) { return lgrTotale; } // Planar configuration = 0 : Pixels are already RGB // Planar configuration = 1 : 3 planes : R, G, B // Planar configuration = 2 : 1 gray Plane + 3 LUT // Well ... supposed to be ! // See US-PAL-8-10x-echo.dcm: PlanarConfiguration=0, // PhotometricInterpretation=PALETTE COLOR // and heuristic has to be found :-( int planConf=Header->GetPlanarConfiguration(); // 0028,0006 // Whatever Planar Configuration is, // "PALETTE COLOR " implies that we deal with the palette. if (str_PhotometricInterpretation == "PALETTE COLOR ") planConf=2; switch (planConf) { case 0: // Pixels are already RGB break; case 1: { if (str_PhotometricInterpretation == "YBR_FULL") { // Warning : YBR_FULL_422 acts as RGB // : we need to make RGB Pixels from Planes Y,cB,cR // 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 = Header->GetXSize()*Header->GetYSize(); int nbFrames = Header->GetZSize(); unsigned char * newDest = (unsigned char*) malloc(lgrTotale); unsigned char *x = newDest; unsigned char * a = (unsigned char *)destination; unsigned char * b = a + l; unsigned char * c = b + l; double R,G,B; // TODO : Replace by the 'well known' // integer computation counterpart // see http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf // for code optimisation for (int i=0;i<nbFrames;i++) { for (int j=0;j<l; j++) { R= 1.164 *(*a-16) + 1.596 *(*c -128) + 0.5; G= 1.164 *(*a-16) - 0.813 *(*c -128) - 0.392 *(*b -128) + 0.5; B= 1.164 *(*a-16) + 2.017 *(*b -128) + 0.5; if (R<0.0) R=0.0; if (G<0.0) G=0.0; if (B<0.0) B=0.0; if (R>255.0) R=255.0; if (G>255.0) G=255.0; if (B>255.0) B=255.0; *(x++) = (unsigned char)R; *(x++) = (unsigned char)G; *(x++) = (unsigned char)B; a++; b++; c++; } } memmove(destination,newDest,lgrTotale); free(newDest); } else { // need to make RGB Pixels from R,G,B Planes // (all the Frames at a time) int l = Header->GetXSize()*Header->GetYSize()*Header->GetZSize(); char * newDest = (char*) malloc(lgrTotale); char * x = newDest; char * a = (char *)destination; char * b = a + l; char * c = b + l; for (int j=0;j<l; j++) { *(x++) = *(a++); *(x++) = *(b++); *(x++) = *(c++); } memmove(destination,newDest,lgrTotale); free(newDest); } break; } case 2: // Palettes were found // Let the user deal with them ! return lgrTotale; } // now, it's an RGB image // Lets's write it in the Header // CreateOrReplaceIfExist ? std::string spp = "3"; // Samples Per Pixel Header->SetEntryByNumber(spp,0x0028,0x0002); std::string rgb="RGB "; // Photometric Interpretation Header->SetEntryByNumber(rgb,0x0028,0x0004); std::string planConfig = "0"; // Planar Configuration Header->SetEntryByNumber(planConfig,0x0028,0x0006); // TODO : Drop Palette Color out of the Header? return lgrTotale; }

void * gdcmFile::GetImageDataRaw (  void   )

Allocates necessary memory, copies the pixel data (image[s]/volume[s]) to newly allocated zone. Transforms YBR pixels into RGB pixels if any Transforms 3 planes R, G, B into a single RGB Plane DOES NOT transform Grey plane + 3 Palettes into a RGB Plane. Returns: Pointer to newly allocated pixel data. \ NULL if alloc fails Definition at line 286 of file gdcmFile.cxx. References GetImageDataIntoVectorRaw(), gdcmHeader::HasLUT(), Header, lgrTotale, PixelData, and PixelRead. { if (Header->HasLUT()) lgrTotale /= 3; // TODO Let gdcmHeadar user a chance // to get the right value // Create a member lgrTotaleRaw ??? PixelData = (void *) malloc(lgrTotale); if (PixelData) GetImageDataIntoVectorRaw(PixelData, lgrTotale); PixelRead=1; // PixelRaw return(PixelData); }

size_t gdcmFile::GetImageDataSize (  void   )

Returns the size (in bytes) of required memory to hold the pixel data represented in this file. Returns: The size of pixel data in bytes. Definition at line 168 of file gdcmFile.cxx. References lgrTotale. { return (lgrTotale); }

size_t gdcmFile::GetImageDataSizeRaw (  void   )

Returns the size (in bytes) of required memory to hold the pixel data represented in this file, when user DOESN'T want to get RGB pixels image when it's stored as a PALETTE COLOR image -the (vtk) user is supposed to know how deal with LUTs-. Warning: to be used with GetImagePixelsRaw() Returns: The size of pixel data in bytes. Definition at line 181 of file gdcmFile.cxx. References lgrTotaleRaw. { return (lgrTotaleRaw); }

bool gdcmFile::ParsePixelData (  void   )

Parse pixel data from disk and *prints* the result \ For multi-fragment Jpeg/Rle files checking purpose *only* \ Allows to 'see' if the file *does* conform \ (some of them do not) \ with Dicom Part 3, Annex A (PS 3.5-2003, page 58, page 85). Definition at line 30 of file gdcmParsePixels.cxx. References gdcmParser::CloseFile(), GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmHeader::GetPixelOffset(), gdcmHeader::GetSamplesPerPixel(), gdcmParser::GetSwapCode(), gdcmHeader::GetXSize(), gdcmHeader::GetYSize(), Header, gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsDicomV3(), gdcmParser::IsExplicitVRBigEndianTransferSyntax(), gdcmParser::IsExplicitVRLittleEndianTransferSyntax(), gdcmParser::IsImplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsRLELossLessTransferSyntax(), gdcmParser::OpenFile(), str2num, gdcmParser::SwapLong(), and gdcmParser::SwapShort(). { // DO NOT remove the printf s. // The ONLY purpose of this method is to PRINT the content FILE *fp; if ( !(fp=Header->OpenFile())) return false; if ( fseek(fp, Header->GetPixelOffset(), SEEK_SET) == -1 ) { Header->CloseFile(); return false; } if ( !Header->IsDicomV3() || Header->IsImplicitVRLittleEndianTransferSyntax() || Header->IsExplicitVRLittleEndianTransferSyntax() || Header->IsExplicitVRBigEndianTransferSyntax() || Header->IsDeflatedExplicitVRLittleEndianTransferSyntax() ) { printf ("gdcmFile::ParsePixelData : non JPEG/RLE File\n"); return false; } int nb; std::string str_nb=Header->GetEntryByNumber(0x0028,0x0100); if (str_nb == GDCM_UNFOUND ) { nb = 16; } else { nb = atoi(str_nb.c_str() ); if (nb == 12) nb =16; } int nBytes= nb/8; int taille = Header->GetXSize() * Header->GetYSize() * Header->GetSamplesPerPixel(); printf ("Checking the Dicom-encapsulated Jpeg/RLE Pixels\n"); guint16 ItemTagGr,ItemTagEl; int ln; long ftellRes; char * destination = NULL; // -------------------- for Parsing : Position on begining of Jpeg/RLE Pixels if( !Header->IsRLELossLessTransferSyntax()) { // JPEG Image ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); //Reading (fffe):Basic Offset Table Item Tag Gr fread(&ItemTagEl,2,1,fp); //Reading (e000):Basic Offset Table Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } printf ("at %x : ItemTag (should be fffe,e000): %04x,%04x\n", ftellRes,ItemTagGr,ItemTagEl ); ftellRes=ftell(fp); fread(&ln,4,1,fp); if(Header->GetSwapCode()) ln=Header->SwapLong(ln); // Basic Offset Table Item Length printf("at %x : Basic Offset Table Item Length (??) %d x(%08x)\n", ftellRes,ln,ln); if (ln != 0) { // What is it used for ?? char * BasicOffsetTableItemValue= (char *)malloc(ln+1); fread(BasicOffsetTableItemValue,ln,1,fp); guint32 a; for (int i=0;i<ln;i+=4){ a=str2num(&BasicOffsetTableItemValue[i],guint32); printf(" x(%08x) %d\n",a,a); } } ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n", ftellRes,ItemTagGr,ItemTagEl ); while ( ( ItemTagGr==0xfffe) && (ItemTagEl!=0xe0dd) ) { // Parse fragments ftellRes=ftell(fp); fread(&ln,4,1,fp); if(Header->GetSwapCode()) ln=Header->SwapLong(ln); // length printf(" at %x : fragment length %d x(%08x)\n", ftellRes, ln,ln); // destination += taille * nBytes; // location in user's memory //printf (" Destination will be x(%x) = %d \n", // destination,destination ); // ------------------------ fseek(fp,ln,SEEK_CUR); // skipping (not reading) fragment pixels // ------------------------ ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n", ftellRes,ItemTagGr,ItemTagEl ); } } else { // RLE Image long RleSegmentLength[15],fragmentLength; guint32 nbRleSegments; guint32 RleSegmentOffsetTable[15]; ftellRes=ftell(fp); // Basic Offset Table with Item Value // Item Tag fread(&ItemTagGr,2,1,fp); //Reading (fffe):Basic Offset Table Item Tag Gr fread(&ItemTagEl,2,1,fp); //Reading (e000):Basic Offset Table Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } printf ("at %x : ItemTag (should be fffe,e000): %04x,%04x\n", ftellRes,ItemTagGr,ItemTagEl ); // Item Length ftellRes=ftell(fp); fread(&ln,4,1,fp); if(Header->GetSwapCode()) ln=Header->SwapLong(ln); // Basic Offset Table Item Length printf("at %x : Basic Offset Table Item Length (??) %d x(%08x)\n", ftellRes,ln,ln); if (ln != 0) { // What is it used for ?? char * BasicOffsetTableItemValue= (char *)malloc(ln+1); fread(BasicOffsetTableItemValue,ln,1,fp); guint32 a; for (int i=0;i<ln;i+=4){ a=str2num(&BasicOffsetTableItemValue[i],guint32); printf(" x(%08x) %d\n",a,a); } } ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n", ftellRes,ItemTagGr,ItemTagEl ); // while 'Sequence Delimiter Item' (fffe,e0dd) not found while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) { // Parse fragments of the current Fragment (Frame) ftellRes=ftell(fp); fread(&fragmentLength,4,1,fp); if(Header->GetSwapCode()) fragmentLength=Header->SwapLong(fragmentLength); // length printf(" at %x : 'fragment' length %d x(%08x)\n", ftellRes, fragmentLength,fragmentLength); //------------------ scanning (not reading) fragment pixels fread(&nbRleSegments,4,1,fp); // Reading : Number of RLE Segments if(Header->GetSwapCode()) nbRleSegments=Header->SwapLong(nbRleSegments); printf(" Nb of RLE Segments : %d\n",nbRleSegments); for(int k=1; k<=15; k++) { // Reading RLE Segments Offset Table ftellRes=ftell(fp); fread(&RleSegmentOffsetTable[k],4,1,fp); if(Header->GetSwapCode()) RleSegmentOffsetTable[k]=Header->SwapLong(RleSegmentOffsetTable[k]); printf(" at : %x Offset Segment %d : %d (%x)\n", ftellRes,k,RleSegmentOffsetTable[k], RleSegmentOffsetTable[k]); } if (nbRleSegments>1) { // skipping (not reading) RLE Segments for(int k=1; k<=nbRleSegments-1; k++) { RleSegmentLength[k]= RleSegmentOffsetTable[k+1] - RleSegmentOffsetTable[k]; ftellRes=ftell(fp); printf (" Segment %d : Length = %d x(%x) Start at %x\n", k,RleSegmentLength[k],RleSegmentLength[k], ftellRes); fseek(fp,RleSegmentLength[k],SEEK_CUR); } } RleSegmentLength[nbRleSegments]= fragmentLength - RleSegmentOffsetTable[nbRleSegments]; ftellRes=ftell(fp); printf (" Segment %d : Length = %d x(%x) Start at %x\n", nbRleSegments,RleSegmentLength[nbRleSegments], RleSegmentLength[nbRleSegments],ftellRes); fseek(fp,RleSegmentLength[nbRleSegments],SEEK_CUR); // ------------------ end of scanning fragment pixels ftellRes=ftell(fp); fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } printf ("at %x : ItemTag (should be fffe,e000 or e0dd): %04x,%04x\n", ftellRes,ItemTagGr,ItemTagEl ); } } return true; }

bool gdcmFile::ReadPixelData (  void *  destination  )  [private]

Read pixel data from disk (optionaly decompressing) into the caller specified memory location. Parameters: destination  where the pixel data should be stored. Definition at line 830 of file gdcmFile.cxx. References gdcmParser::CloseFile(), gdcm_read_JPEG2000_file(), gdcm_read_JPEG_file(), gdcm_read_JPEG_file12(), gdcm_read_RLE_file(), GDCM_UNFOUND, gdcmHeader::GetBitsAllocated(), gdcmHeader::GetBitsStored(), gdcmHeader::GetEntryByNumber(), gdcmHeader::GetPixelAreaLength(), gdcmHeader::GetPixelOffset(), gdcmHeader::GetPixelSize(), gdcmHeader::GetSamplesPerPixel(), gdcmParser::GetSwapCode(), gdcmHeader::GetXSize(), gdcmHeader::GetYSize(), Header, gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsDicomV3(), gdcmParser::IsExplicitVRBigEndianTransferSyntax(), gdcmParser::IsExplicitVRLittleEndianTransferSyntax(), gdcmParser::IsImplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsJPEG2000(), gdcmHeader::IsJPEGLossless(), gdcmHeader::IsRLELossLessTransferSyntax(), gdcmParser::OpenFile(), gdcmParser::SwapLong(), and gdcmParser::SwapShort(). Referenced by GetImageDataIntoVectorRaw(). { FILE *fp; if ( !(fp=Header->OpenFile())) return false; if ( fseek(fp, Header->GetPixelOffset(), SEEK_SET) == -1 ) { Header->CloseFile(); return false; } // ---------------------- Compacted File (12 Bits Per Pixel) /* unpack 12 Bits pixels into 16 Bits pixels */ /* 2 pixels 12bit = [0xABCDEF] */ /* 2 pixels 16bit = [0x0ABD] + [0x0FCE] */ if (Header->GetBitsAllocated()==12) { int nbPixels = Header->GetXSize() * Header->GetYSize(); unsigned char b0, b1, b2; unsigned short int* pdestination = (unsigned short int*)destination; for(int p=0;p<nbPixels;p+=2) { fread(&b0,1,1,fp); fread(&b1,1,1,fp); fread(&b2,1,1,fp); //Two steps is necessary to please VC++ *pdestination++ = ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f); /* A */ /* B */ /* D */ *pdestination++ = ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4); /* F */ /* C */ /* E */ // Troubles expected on Big-Endian processors ? } Header->CloseFile(); return(true); } // ---------------------- Uncompressed File if ( !Header->IsDicomV3() || Header->IsImplicitVRLittleEndianTransferSyntax() || Header->IsExplicitVRLittleEndianTransferSyntax() || Header->IsExplicitVRBigEndianTransferSyntax() || Header->IsDeflatedExplicitVRLittleEndianTransferSyntax() ) { size_t ItemRead = fread(destination, Header->GetPixelAreaLength(), 1, fp); if ( ItemRead != 1 ) { Header->CloseFile(); return false; } else { Header->CloseFile(); return true; } } // ---------------------- Run Length Encoding if (Header->IsRLELossLessTransferSyntax()) { bool res = (bool)gdcm_read_RLE_file (fp,destination); Header->CloseFile(); return res; } // --------------- SingleFrame/Multiframe JPEG Lossless/Lossy/2000 int nb; std::string str_nb=Header->GetEntryByNumber(0x0028,0x0100); if (str_nb == GDCM_UNFOUND ) { nb = 16; } else { nb = atoi(str_nb.c_str() ); if (nb == 12) nb =16; // ?? 12 should be ACR-NEMA only ? } int nBytes= nb/8; int taille = Header->GetXSize() * Header->GetYSize() * Header->GetSamplesPerPixel(); long fragmentBegining; // for ftell, fseek bool jpg2000 = Header->IsJPEG2000(); bool jpgLossless = Header->IsJPEGLossless(); bool res = true; guint16 ItemTagGr,ItemTagEl; int ln; // Position on begining of Jpeg Pixels fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } fread(&ln,4,1,fp); if(Header->GetSwapCode()) ln=Header->SwapLong(ln); // Basic Offset Table Item length if (ln != 0) { // What is it used for ?!? char *BasicOffsetTableItemValue = (char *)malloc(ln+1); fread(BasicOffsetTableItemValue,ln,1,fp); } // first Fragment initialisation fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } // parsing fragments until Sequence Delim. Tag found while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) { // --- for each Fragment fread(&ln,4,1,fp); if(Header->GetSwapCode()) ln=Header->SwapLong(ln); // Fragment Item length fragmentBegining=ftell(fp); if (jpg2000) { // JPEG 2000 : call to ??? res = (bool)gdcm_read_JPEG2000_file (fp,destination); // Not Yet written } // ------------------------------------- endif (JPEG2000) else if (jpgLossless) { // JPEG LossLess : call to xmedcom JPEG JPEGLosslessDecodeImage (fp, // Reading Fragment pixels (unsigned short *)destination, Header->GetPixelSize()*8* Header->GetSamplesPerPixel(), ln); res=1; // in order not to break the loop } // ------------------------------------- endif (JPEGLossless) else { // JPEG Lossy : call to IJG 6b if (Header->GetBitsStored() == 8) { res = (bool)gdcm_read_JPEG_file (fp,destination); // Reading Fragment pixels } else { res = (bool)gdcm_read_JPEG_file12 (fp,destination);// Reading Fragment pixels } } // ------------------------------------- endif (JPEGLossy) if (!res) break; destination = (char *)destination + taille * nBytes; // location in user's memory // for next fragment (if any) fseek(fp,fragmentBegining,SEEK_SET); // To be sure we start fseek(fp,ln,SEEK_CUR); // at the begining of next fragment ItemTagGr = ItemTagEl =0; fread(&ItemTagGr,2,1,fp); // Reading (fffe) : Item Tag Gr fread(&ItemTagEl,2,1,fp); // Reading (e000) : Item Tag El if(Header->GetSwapCode()) { ItemTagGr=Header->SwapShort(ItemTagGr); ItemTagEl=Header->SwapShort(ItemTagEl); } } // endWhile parsing fragments until Sequence Delim. Tag found Header->CloseFile(); return res; }

bool gdcmFile::SetImageData (  void *  inData, size_t  ExpectedSize )

TODO JPR. Warning: doit-etre etre publique ? : y a-t-il un inconvenient à fusioner ces 2 fonctions Parameters: inData  ExpectedSize  Returns: boolean Definition at line 553 of file gdcmFile.cxx. References Header, lgrTotale, PixelData, and gdcmHeader::SetImageDataSize(). { Header->SetImageDataSize(ExpectedSize); PixelData = inData; lgrTotale = ExpectedSize; return(true); }

void gdcmFile::SetPixelDataSizeFromHeader (  void   )

computes the length (in bytes) to ALLOCATE to receive the image(s) pixels (multiframes taken into account) Warning: : it is NOT the group 7FE0 length (no interest for compressed images). Returns: length to allocate Definition at line 113 of file gdcmFile.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmHeader::GetSamplesPerPixel(), gdcmHeader::GetXSize(), gdcmHeader::GetYSize(), gdcmHeader::GetZSize(), gdcmHeader::HasLUT(), Header, lgrTotale, and lgrTotaleRaw. Referenced by gdcmFile(). { // see PS 3.3-2003 : C.7.6.3.2.1 // // MONOCHROME1 // MONOCHROME2 // PALETTE COLOR // RGB // HSV (Retired) // ARGB (Retired) // CMYK (Retired) // YBR_FULL // YBR_FULL_422 (no LUT, no Palette) // YBR_PARTIAL_422 // YBR_ICT // YBR_RCT // LUT's // ex : gdcm-US-ALOKA-16.dcm // 0028|1221 [OW] [Segmented Red Palette Color Lookup Table Data] // 0028|1222 [OW] [Segmented Green Palette Color Lookup Table Data] // 0028|1223 [OW] [Segmented Blue Palette Color Lookup Table Data] // ex : OT-PAL-8-face.dcm // 0028|1201 [US] [Red Palette Color Lookup Table Data] // 0028|1202 [US] [Green Palette Color Lookup Table Data] // 0028|1203 [US] [Blue Palette Color Lookup Table Data] int nb; std::string str_nb; str_nb=Header->GetEntryByNumber(0x0028,0x0100); if (str_nb == GDCM_UNFOUND ) { nb = 16; } else { nb = atoi(str_nb.c_str() ); if (nb == 12) nb =16; } lgrTotale = lgrTotaleRaw = Header->GetXSize() * Header->GetYSize() * Header->GetZSize() * (nb/8)* Header->GetSamplesPerPixel(); std::string str_PhotometricInterpretation = Header->GetEntryByNumber(0x0028,0x0004); /*if ( str_PhotometricInterpretation == "PALETTE COLOR " )*/ // pb when undealt Segmented Palette Color if (Header->HasLUT()) { lgrTotale*=3; } }

void gdcmFile::SwapZone (  void *  im, int  swap, int  lgr, int  nb )  [private]

Swap the bytes, according to swap code. Warning: not end user intended Parameters: im  area to deal with swap  swap code lgr  Area Length nb  Pixels Bit number Definition at line 754 of file gdcmFile.cxx. Referenced by GetImageDataIntoVectorRaw(). { guint32 s32; guint16 fort,faible; int i; if(nb == 16) switch(swap) { case 0: case 12: case 1234: break; case 21: case 3412: case 2143: case 4321: for(i=0;i<lgr;i++) ((unsigned short int*)im)[i]= ((((unsigned short int*)im)[i])>>8) | ((((unsigned short int*)im)[i])<<8); break; default: printf("SWAP value (16 bits) not allowed : %d\n", swap); } if( nb == 32 ) switch (swap) { case 0: case 1234: break; case 4321: for(i=0;i<lgr;i++) { faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 4321 */ fort =((unsigned long int*)im)[i]>>16; fort= (fort>>8) | (fort<<8); faible=(faible>>8) | (faible<<8); s32=faible; ((unsigned long int*)im)[i]=(s32<<16)|fort; } break; case 2143: for(i=0;i<lgr;i++) { faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 2143 */ fort=((unsigned long int*)im)[i]>>16; fort= (fort>>8) | (fort<<8); faible=(faible>>8) | (faible<<8); s32=fort; ((unsigned long int*)im)[i]=(s32<<16)|faible; } break; case 3412: for(i=0;i<lgr;i++) { faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 3412 */ fort=((unsigned long int*)im)[i]>>16; s32=faible; ((unsigned long int*)im)[i]=(s32<<16)|fort; } break; default: printf("SWAP value (32 bits) not allowed : %d\n", swap); } return; }

bool gdcmFile::WriteAcr (  std::string  fileName  )

Ecrit au format ACR-NEMA sur disque l'entete et les pixels (a l'attention des logiciels cliniques qui ne prennent en entrée QUE des images ACR ... Warning: if a DICOM_V3 header is supplied, groups < 0x0008 and shadow groups are ignored) NO TEST is performed on processor "Endiannity". Ca fonctionnera correctement (?) sur processeur Intel (Equivalent a IdDcmWrite) Parameters: fileName  name of the file to be created (any already existing file is overwritten) Returns: false if write fails Definition at line 635 of file gdcmFile.cxx. References ACR, and WriteBase(). { return WriteBase(fileName, ACR); }

bool gdcmFile::WriteBase (  std::string  fileName, FileType  type )  [protected]

Parameters: fileName  name of the file to be created (any already existing file is overwritten) type  file type (ExplicitVR, ImplicitVR, ...) Returns: false if write fails Definition at line 649 of file gdcmFile.cxx. References ACR_LIBIDO, DICOMDIR, ExplicitVR, gdcmParser::GetEntry(), gdcmHeader::GetEntryByNumber(), gdcmParser::GetFileType(), gdcmParser::GetGrPixel(), gdcmParser::GetNumPixel(), Header, IterHT, lgrTotale, lgrTotaleRaw, PixelData, PixelRead, gdcmHeader::SetEntryByNumber(), gdcmHeaderEntry::SetLength(), TagKey, gdcmDictEntry::TranslateToKey(), and gdcmParser::Write(). Referenced by WriteAcr(), WriteDcmExplVR(), and WriteDcmImplVR(). { FILE * fp1; if (PixelRead==-1 && type != DICOMDIR) { /* std::cout << "U never Read the pixels; U cannot write the file" << std::endl;*/ return false; } fp1 = fopen(fileName.c_str(),"wb"); if (fp1 == NULL) { printf("Failed to open (write) File [%s] \n",fileName.c_str()); return (false); } if ( (type == ImplicitVR) || (type == ExplicitVR) ) { char * filePreamble; // writing Dicom File Preamble filePreamble=(char*)calloc(128,1); fwrite(filePreamble,128,1,fp1); fwrite("DICM",4,1,fp1); free (filePreamble); } // -------------------------------------------------------------- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images // // if recognition code tells us we dealt with a LibIDO image // we reproduce on disk the switch between lineNumber and columnNumber // just before writting ... // TODO : the best trick would be *change* the recognition code // but pb expected if user deals with, e.g. COMPLEX images std::string rows, columns; if ( Header->GetFileType() == ACR_LIBIDO){ rows = Header->GetEntryByNumber(0x0028, 0x0010); columns = Header->GetEntryByNumber(0x0028, 0x0011); Header->SetEntryByNumber(columns, 0x0028, 0x0010); Header->SetEntryByNumber(rows , 0x0028, 0x0011); } // ----------------- End of Special Patch ---------------- // TODO : get the grPixel, numPixel values (for some ACR-NEMA images only) guint16 grPixel =Header->GetGrPixel(); guint16 numPixel=Header->GetNumPixel();; // Update Pixel Data Length // the *last* of the (GrPixel, NumPixel), if many. TagKey key = gdcmDictEntry::TranslateToKey(grPixel, numPixel); TagHeaderEntryHT::iterator p2; gdcmHeaderEntry * PixelElement; IterHT it= Header->GetEntry().equal_range(key); // get a pair of iterators first-last synonym if (Header->GetEntry().count(key) == 1) // only the first is significant p2=it.first; // iterator on the first (unique) synonym else p2=it.second;// iterator on the last synonym PixelElement=p2->second; // H Table target column (2-nd col) // PixelElement->SetPrintLevel(2); // PixelElement->Print(); if (PixelRead==1) PixelElement->SetLength(lgrTotaleRaw); else if (PixelRead==0) PixelElement->SetLength(lgrTotale); //PixelElement->SetPrintLevel(2); //PixelElement->Print(); Header->Write(fp1, type); // -------------------------------------------------------------- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images // // ...and we restore the Header to be Dicom Compliant again // just after writting if (Header->GetFileType() == ACR_LIBIDO){ Header->SetEntryByNumber(rows , 0x0028, 0x0010); Header->SetEntryByNumber(columns, 0x0028, 0x0011); } // ----------------- End of Special Patch ---------------- fwrite(PixelData, lgrTotale, 1, fp1); fclose (fp1); return(true); }

bool gdcmFile::WriteDcmExplVR (  std::string  fileName  )

Parameters: fileName  name of the file to be created (any already existing file is overwritten) Returns: false if write fails Definition at line 615 of file gdcmFile.cxx. References ExplicitVR, and WriteBase(). { return WriteBase(fileName, ExplicitVR); }

bool gdcmFile::WriteDcmImplVR (  const char *  fileName  )

Parameters: fileName  name of the file to be created (any already existing file is overwritten) Returns: false if write fails Definition at line 603 of file gdcmFile.cxx. References WriteDcmImplVR(). { return WriteDcmImplVR (std::string (fileName)); }

bool gdcmFile::WriteDcmImplVR (  std::string  fileName  )

Writes on disk A SINGLE Dicom file NO test is performed on processor "Endiannity". Parameters: fileName  name of the file to be created (any already existing file is overwritten) Returns: false if write fails Definition at line 591 of file gdcmFile.cxx. References WriteBase(). Referenced by WriteDcmImplVR(). { return WriteBase(fileName, ImplicitVR); }

bool gdcmFile::WriteRawData (  std::string  fileName  )

Writes on disk A SINGLE Dicom file NO test is performed on processor "Endiannity". It's up to the user to call his Reader properly. Parameters: fileName  name of the file to be created (any already existing file is over written) Returns: false if write fails Definition at line 570 of file gdcmFile.cxx. References lgrTotale, and PixelData. { FILE * fp1; fp1 = fopen(fileName.c_str(),"wb"); if (fp1 == NULL) { printf("Fail to open (write) file [%s] \n",fileName.c_str()); return (false); } fwrite (PixelData,lgrTotale, 1, fp1); fclose (fp1); return(true); }

---

Member Data Documentation

gdcmHeader* gdcmFile::Header [private]

Definition at line 92 of file gdcmFile.h. Referenced by gdcm_read_RLE_file(), gdcmFile(), GetHeader(), GetImageDataIntoVector(), GetImageDataIntoVectorRaw(), GetImageDataRaw(), ParsePixelData(), ReadPixelData(), SetImageData(), SetPixelDataSizeFromHeader(), WriteBase(), and ~gdcmFile().

size_t gdcmFile::lgrTotale [private]

Definition at line 97 of file gdcmFile.h. Referenced by gdcm_read_RLE_file(), GetImageData(), GetImageDataIntoVector(), GetImageDataIntoVectorRaw(), GetImageDataRaw(), GetImageDataSize(), SetImageData(), SetPixelDataSizeFromHeader(), WriteBase(), and WriteRawData().

size_t gdcmFile::lgrTotaleRaw [private]

Definition at line 96 of file gdcmFile.h. Referenced by GetImageDataIntoVector(), GetImageDataSizeRaw(), SetPixelDataSizeFromHeader(), and WriteBase().

std::string gdcmFile::OrigFileName [private]

Definition at line 104 of file gdcmFile.h.

int gdcmFile::Parsed [private]

Definition at line 103 of file gdcmFile.h.

void* gdcmFile::PixelData [private]

Definition at line 95 of file gdcmFile.h. Referenced by GetImageData(), GetImageDataRaw(), SetImageData(), WriteBase(), and WriteRawData().

int gdcmFile::PixelRead [private]

Definition at line 99 of file gdcmFile.h. Referenced by gdcmFile(), GetImageData(), GetImageDataIntoVector(), GetImageDataIntoVectorRaw(), GetImageDataRaw(), and WriteBase().

bool gdcmFile::SelfHeader [private]

Definition at line 93 of file gdcmFile.h. Referenced by gdcmFile(), and ~gdcmFile().

---

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

• gdcmFile.h
• gdcmFile.cxx
• gdcmJpeg12.cxx
• gdcmJpeg2000.cxx
• gdcmParsePixels.cxx
• gdcmRLE.cxx

---