gdcmParser Class Reference

#include <gdcmParser.h>

Inheritance diagram for gdcmParser:

List of all members.

Public Member Functions
	gdcmParser (bool exception_on_error=false)
	gdcmParser (const char *filename, bool exception_on_error=false, bool enable_sequences=false, bool ignore_shadow=false)
virtual	~gdcmParser (void)
	Canonical destructor.
void	SetPrintLevel (int level)
	Sets the print level for the Dicom Header.
virtual void	Print (std::ostream &os=std::cout)
virtual void	PrintEntry (std::ostream &os=std::cout)
	Prints the Header Entries (Dicom Elements) both from the H Table and the chained list.
virtual void	PrintPubDict (std::ostream &os=std::cout)
	Prints The Dict Entries of THE public Dicom Dictionnry.
virtual void	PrintShaDict (std::ostream &os=std::cout)
	Prints The Dict Entries of THE shadow Dicom Dictionnry.
std::string	GetFileName (void)
gdcmDict *	GetPubDict (void)
	Get the public dictionary used.
gdcmDict *	GetShaDict (void)
	Get the shadow dictionary used.
bool	SetShaDict (gdcmDict *dict)
	Set the shadow dictionary used.
bool	SetShaDict (DictKey dictName)
	Set the shadow dictionary used.
virtual bool	IsReadable (void)
	This predicate, based on hopefully reasonable heuristics, decides whether or not the current gdcmParser was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File.
bool	IsImplicitVRLittleEndianTransferSyntax (void)
	Determines if the Transfer Syntax was already encountered and if it corresponds to a ImplicitVRLittleEndian one.
bool	IsExplicitVRLittleEndianTransferSyntax (void)
	Determines if the Transfer Syntax was already encountered and if it corresponds to a ExplicitVRLittleEndian one.
bool	IsDeflatedExplicitVRLittleEndianTransferSyntax (void)
	Determines if the Transfer Syntax was already encountered and if it corresponds to a DeflatedExplicitVRLittleEndian one.
bool	IsExplicitVRBigEndianTransferSyntax (void)
	Determines if the Transfer Syntax was already encountered and if it corresponds to a Explicit VR Big Endian one.
FileType	GetFileType (void)
	returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
TagHeaderEntryHT &	GetEntry (void)
	returns a ref to the Dicom Header H table (multimap) return the Dicom Header H table
ListTag &	GetListEntry (void)
	returns a ref to the Dicom Header chained list return the Dicom Header chained list
FILE *	OpenFile (bool exception_on_error=false) throw (gdcmFileError)
	opens the file
bool	CloseFile (void)
	closes the file
virtual bool	Write (FILE *, FileType)
bool	ReplaceOrCreateByNumber (std::string Value, guint16 Group, guint16 Elem)
	Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't.
bool	ReplaceOrCreateByNumber (char *Value, guint16 Group, guint16 Elem)
	Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't.
bool	ReplaceIfExistByNumber (char *Value, guint16 Group, guint16 Elem)
	Set a new value if the invoked element exists Seems to be useless !!!
int	GetSwapCode (void)
guint16	GetGrPixel (void)
guint16	GetNumPixel (void)
guint16	SwapShort (guint16)
	Swaps the bytes so they agree with the processor order.
guint32	SwapLong (guint32)
	Swaps back the bytes of 4-byte long integer accordingly to processor order.
guint16	UnswapShort (guint16)
	Unswaps the bytes so they agree with the processor order.
guint32	UnswapLong (guint32)
	Unswaps back the bytes of 4-byte long integer accordingly to processor order.
Protected Member Functions
int	CheckIfEntryExistByNumber (guint16 Group, guint16 Elem)
	Checks if a given Dicom Element exists within the H table.
virtual std::string	GetEntryByName (std::string tagName)
	Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value of a given tag.
virtual std::string	GetEntryVRByName (std::string tagName)
	Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag.
virtual std::string	GetEntryByNumber (guint16 group, guint16 element)
	Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag.
virtual std::string	GetEntryVRByNumber (guint16 group, guint16 element)
	Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag..
virtual bool	SetEntryByName (std::string content, std::string tagName)
	Sets the value (string) of the Header Entry (Dicom Element).
virtual bool	SetEntryByNumber (std::string content, guint16 group, guint16 element)
	Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value.
virtual bool	SetEntryLengthByNumber (guint32 length, guint16 group, guint16 element)
	Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) in the PubHeaderEntrySet of this instance through it's (group, element) and modifies it's length with the given value.
virtual size_t	GetEntryOffsetByNumber (guint16 Group, guint16 Elem)
	Gets (from Header) the offset of a 'non string' element value (LoadElementValues has already be executed).
virtual void *	GetEntryVoidAreaByNumber (guint16 Group, guint16 Elem)
	Gets (from Header) a 'non string' element value (LoadElementValues has already be executed).
virtual void *	LoadEntryVoidArea (guint16 Group, guint16 Element)
	Loads (from disk) the element content when a string is not suitable.
virtual bool	SetEntryVoidAreaByNumber (void *a, guint16 Group, guint16 Elem)
	Sets a 'non string' value to a given Dicom Element.
virtual void	UpdateShaEntries (void)
	Update the entries with the shadow dictionary. Only non even entries are analyzed.
gdcmHeaderEntry *	GetHeaderEntryByNumber (guint16 group, guint16 element)
	retrieves a Dicom Element (the first one) using (group, element)
gdcmHeaderEntry *	GetHeaderEntryByName (std::string Name)
	Searches within the Header Entries for a Dicom Element of a given tag.
IterHT	GetHeaderEntrySameNumber (guint16 group, guint16 element)
	retrieves the Dicom Elements (all of them) using (group, element)
void	LoadHeaderEntrySafe (gdcmHeaderEntry *)
	Loads the element while preserving the current underlying file position indicator as opposed to to LoadHeaderEntry that modifies it.
void	UpdateGroupLength (bool SkipSequence=false, FileType type=ImplicitVR)
	Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader.
void	WriteEntries (FILE *_fp, FileType type)
	writes on disc according to the requested format (ACR-NEMA, ExplicitVR, ImplicitVR) the image
Protected Attributes
FILE *	fp
FileType	filetype
TagHeaderEntryHT	tagHT
ListTag	listEntries
int	enableSequences
int	printLevel
guint16	GrPixel
guint16	NumPixel
int	countGrPixel
Static Protected Attributes
const unsigned int	HEADER_LENGTH_TO_READ = 256
const unsigned int	MAX_SIZE_LOAD_ELEMENT_VALUE = 4096
const unsigned int	MAX_SIZE_PRINT_ELEMENT_VALUE = 64
Private Member Functions
bool	ParseHeader (bool exception_on_error=false) throw (gdcmFormatError)
	Parses the header of the file but WITHOUT loading element values.
void	LoadHeaderEntries (void)
	Loads the element values of all the Header Entries pointed in the public Chained List.
void	LoadHeaderEntry (gdcmHeaderEntry *)
	Loads the element content if its length doesn't exceed the value specified with gdcmParser::SetMaxSizeLoadEntry().
void	AddHeaderEntry (gdcmHeaderEntry *)
	add a new Dicom Element pointer to the H Table and to the chained List
void	FindHeaderEntryLength (gdcmHeaderEntry *)
void	FindHeaderEntryVR (gdcmHeaderEntry *)
	Find the Value Representation of the current Dicom Element.
bool	CheckHeaderEntryVR (gdcmHeaderEntry *, VRKey)
	Check the correspondance between the VR of the header entry and the taken VR. If they are different, the header entry is updated with the new VR.
std::string	GetHeaderEntryValue (gdcmHeaderEntry *)
	Get the transformed value of the header entry. The VR value is used to define the transformation to operate on the value.
std::string	GetHeaderEntryUnvalue (gdcmHeaderEntry *)
	Get the reverse transformed value of the header entry. The VR value is used to define the reverse transformation to operate on the value.
void	SkipHeaderEntry (gdcmHeaderEntry *)
	Skip a given Header Entry.
void	FixHeaderEntryFoundLength (gdcmHeaderEntry *, guint32)
	When the length of an element value is obviously wrong (because the parser went Jabberwocky) one can hope improving things by applying this heuristic.
bool	IsHeaderEntryAnInteger (gdcmHeaderEntry *)
	Apply some heuristics to predict wether the considered element value contains/represents an integer or not.
guint32	FindHeaderEntryLengthOB (void)
guint16	ReadInt16 (void)
	Reads a supposed to be 16 Bits integer (swaps it depending on processor endianity).
guint32	ReadInt32 (void)
	Reads a supposed to be 32 Bits integer (swaps it depending on processor endianity).
void	SkipBytes (guint32)
void	Initialise (void)
bool	CheckSwap (void)
	Discover what the swap code is (among little endian, big endian, bad little endian, bad big endian). sw is set.
void	SwitchSwapToBigEndian (void)
void	SetMaxSizeLoadEntry (long)
	during parsing, Header Elements too long are not loaded in memory
void	SetMaxSizePrintEntry (long)
	Header Elements too long will not be printed.
gdcmDictEntry *	GetDictEntryByName (std::string Name)
	Searches both the public and the shadow dictionary (when they exist) for the presence of the DictEntry with given name. The public dictionary has precedence on the shadow one.
gdcmDictEntry *	GetDictEntryByNumber (guint16, guint16)
	Searches both the public and the shadow dictionary (when they exist) for the presence of the DictEntry with given group and element. The public dictionary has precedence on the shadow one.
gdcmDictEntry *	NewVirtualDictEntry (guint16 group, guint16 element, std::string vr="unkn", std::string fourth="unkn", std::string name="unkn")
	Request a new virtual dict entry to the dict set.
gdcmDictEntry *	NewVirtualDictEntry (gdcmHeaderEntry *)
gdcmHeaderEntry *	ReadNextHeaderEntry (void)
	Read the next tag but WITHOUT loading it's value.
gdcmHeaderEntry *	NewHeaderEntryByNumber (guint16 group, guint16 element)
	Build a new Element Value from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent.
gdcmHeaderEntry *	NewHeaderEntryByName (std::string Name)
	Build a new Element Value from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent.
guint32	GenerateFreeTagKeyInGroup (guint16 group)
	Small utility function that creates a new manually crafted (as opposed as read from the file) gdcmHeaderEntry with user specified name and adds it to the public tag hash table. Generate a free TagKey i.e. a TagKey that is not present in the TagHt dictionary.
Private Attributes
std::string	filename
gdcmDict *	RefPubDict
gdcmDict *	RefShaDict
int	wasUpdated
int	ignoreShadow
int	sw
guint32	MaxSizeLoadEntry
guint32	MaxSizePrintEntry

---

Constructor & Destructor Documentation

gdcmParser::gdcmParser (  bool  exception_on_error = false  )

Parameters: exception_on_error  Definition at line 121 of file gdcmParser.cxx. References enableSequences, Initialise(), MAX_SIZE_LOAD_ELEMENT_VALUE, SetMaxSizeLoadEntry(), and wasUpdated. { enableSequences=0; SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); Initialise(); wasUpdated = 0; // will be set to 1 if user adds an entry printLevel = 1; // 'Medium' print level by default }

gdcmParser::gdcmParser (  const char *  InFilename, bool  exception_on_error = false, bool  enable_sequences = false, bool  ignore_shadow = false )

Parameters: InFilename  exception_on_error  enable_sequences  = true to allow the header to be parsed *inside* the SeQuences, when they have an actual length ignore_shadow  to allow skipping the shadow elements, to save memory space. Warning: The TRUE value for this param has to be used with a FALSE value for the 'enable_sequence' param. ('public elements' may be embedded in 'shadow Sequences') Definition at line 94 of file gdcmParser.cxx. References CloseFile(), enableSequences, ignoreShadow, Initialise(), LoadHeaderEntries(), MAX_SIZE_LOAD_ELEMENT_VALUE, OpenFile(), ParseHeader(), SetMaxSizeLoadEntry(), and wasUpdated. { enableSequences=enable_sequences; ignoreShadow =ignore_shadow; SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); filename = InFilename; Initialise(); if ( !OpenFile(exception_on_error)) return; if (ParseHeader()) { LoadHeaderEntries(); } CloseFile(); wasUpdated = 0; // will be set to 1 if user adds an entry printLevel = 1; // 'Medium' print level by default }

gdcmParser::~gdcmParser (  void   )  [virtual]

Canonical destructor. Definition at line 135 of file gdcmParser.cxx. References RefPubDict, and RefShaDict. { RefPubDict = NULL; RefShaDict = NULL; }

---

Member Function Documentation

void gdcmParser::AddHeaderEntry (  gdcmHeaderEntry *  newHeaderEntry  )  [private]

add a new Dicom Element pointer to the H Table and to the chained List Warning: push_bash in listEntries ONLY during ParseHeader Todo: something to allow further Elements addition, (at their right place in the chained list) when position to be taken care of Parameters: newHeaderEntry  Definition at line 1404 of file gdcmParser.cxx. References gdcmHeaderEntry::GetKey(), listEntries, PairHT, tagHT, and wasUpdated. Referenced by ReplaceOrCreateByNumber(), and UpdateGroupLength(). { tagHT.insert( PairHT( newHeaderEntry->GetKey(),newHeaderEntry) ); listEntries.push_back(newHeaderEntry); wasUpdated = 1; }

bool gdcmParser::CheckHeaderEntryVR (  gdcmHeaderEntry *  Entry, VRKey  vr )  [private]

Check the correspondance between the VR of the header entry and the taken VR. If they are different, the header entry is updated with the new VR. Parameters: Entry  Header Entry to check vr  Dicom Value Representation Returns: false if the VR is incorrect of if the VR isn't referenced otherwise, it returns true Definition at line 1576 of file gdcmParser.cxx. References gdcmVR::Count(), dbg, gdcmHeaderEntry::GetElement(), gdcmHeaderEntry::GetGroup(), gdcmHeaderEntry::GetName(), gdcmHeaderEntry::GetVR(), gdcmGlobal::GetVR(), gdcmHeaderEntry::IsVRUnknown(), NewVirtualDictEntry(), gdcmHeaderEntry::SetDictEntry(), gdcmHeaderEntry::SetVR(), gdcmDebug::Verbose(), and VRKey. Referenced by FindHeaderEntryVR(), and UpdateShaEntries(). { char msg[100]; // for sprintf bool RealExplicit = true; // Assume we are reading a falsely explicit VR file i.e. we reached // a tag where we expect reading a VR but are in fact we read the // first to bytes of the length. Then we will interogate (through find) // the dicom_vr dictionary with oddities like "\004\0" which crashes // both GCC and VC++ implementations of the STL map. Hence when the // expected VR read happens to be non-ascii characters we consider // we hit falsely explicit VR tag. if ( (!isalpha(vr[0])) && (!isalpha(vr[1])) ) RealExplicit = false; // CLEANME searching the dicom_vr at each occurence is expensive. // PostPone this test in an optional integrity check at the end // of parsing or only in debug mode. if ( RealExplicit && !gdcmGlobal::GetVR()->Count(vr) ) RealExplicit= false; if ( !RealExplicit ) { // We thought this was explicit VR, but we end up with an // implicit VR tag. Let's backtrack. sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n", Entry->GetGroup(),Entry->GetElement()); dbg.Verbose(1, "gdcmParser::FindVR: ",msg); if (Entry->GetGroup()%2 && Entry->GetElement() == 0x0000) { // Group length is UL ! gdcmDictEntry* NewEntry = NewVirtualDictEntry( Entry->GetGroup(),Entry->GetElement(), "UL","FIXME","Group Length"); Entry->SetDictEntry(NewEntry); } return(false); } if ( Entry->IsVRUnknown() ) { // When not a dictionary entry, we can safely overwrite the VR. if (Entry->GetElement() == 0x0000) { // Group length is UL ! Entry->SetVR("UL"); } else { Entry->SetVR(vr); } } else if ( Entry->GetVR() != vr ) { // The VR present in the file and the dictionary disagree. We assume // the file writer knew best and use the VR of the file. Since it would // be unwise to overwrite the VR of a dictionary (since it would // compromise it's next user), we need to clone the actual DictEntry // and change the VR for the read one. gdcmDictEntry* NewEntry = NewVirtualDictEntry( Entry->GetGroup(),Entry->GetElement(), vr,"FIXME",Entry->GetName()); Entry->SetDictEntry(NewEntry); } return(true); }

int gdcmParser::CheckIfEntryExistByNumber (  guint16  group, guint16  element )  [protected]

Checks if a given Dicom Element exists within the H table. Parameters: group  Group number of the searched Dicom Element element  Element number of the searched Dicom Element Returns: number of occurences Definition at line 509 of file gdcmParser.cxx. References tagHT, and gdcmDictEntry::TranslateToKey(). Referenced by ReplaceOrCreateByNumber(). { std::string key = gdcmDictEntry::TranslateToKey(group, element ); return (tagHT.count(key)); }

bool gdcmParser::CheckSwap (  void   )  [private]

Discover what the swap code is (among little endian, big endian, bad little endian, bad big endian). sw is set. Returns: false when we are absolutely sure it's neither ACR-NEMA nor DICOM true when we hope ours assuptions are OK Definition at line 2003 of file gdcmParser.cxx. References ACR, dbg, ExplicitVR, filetype, fp, HEADER_LENGTH_TO_READ, sw, Unknown, and gdcmDebug::Verbose(). { // The only guaranted way of finding the swap code is to find a // group tag since we know it's length has to be of four bytes i.e. // 0x00000004. Finding the swap code in then straigthforward. Trouble // occurs when we can't find such group... guint32 x=4; // x : for ntohs bool net2host; // true when HostByteOrder is the same as NetworkByteOrder guint32 s32; guint16 s16; int lgrLue; char *entCur; char deb[HEADER_LENGTH_TO_READ]; // First, compare HostByteOrder and NetworkByteOrder in order to // determine if we shall need to swap bytes (i.e. the Endian type). if (x==ntohs(x)) net2host = true; else net2host = false; // The easiest case is the one of a DICOM header, since it possesses a // file preamble where it suffice to look for the string "DICM". lgrLue = fread(deb, 1, HEADER_LENGTH_TO_READ, fp); entCur = deb + 128; if(memcmp(entCur, "DICM", (size_t)4) == 0) { dbg.Verbose(1, "gdcmParser::CheckSwap:", "looks like DICOM Version3"); // Next, determine the value representation (VR). Let's skip to the // first element (0002, 0000) and check there if we find "UL" // - or "OB" if the 1st one is (0002,0001) -, // in which case we (almost) know it is explicit VR. // WARNING: if it happens to be implicit VR then what we will read // is the length of the group. If this ascii representation of this // length happens to be "UL" then we shall believe it is explicit VR. // FIXME: in order to fix the above warning, we could read the next // element value (or a couple of elements values) in order to make // sure we are not commiting a big mistake. // We need to skip : // * the 128 bytes of File Preamble (often padded with zeroes), // * the 4 bytes of "DICM" string, // * the 4 bytes of the first tag (0002, 0000),or (0002, 0001) // i.e. a total of 136 bytes. entCur = deb + 136; // FIXME : FIXME: // Sometimes (see : gdcmData/icone.dcm) group 0x0002 *is* Explicit VR, // but elem 0002,0010 (Transfert Syntax) tells us the file is *Implicit* VR. // -and it is !- if( (memcmp(entCur, "UL", (size_t)2) == 0) || (memcmp(entCur, "OB", (size_t)2) == 0) || (memcmp(entCur, "UI", (size_t)2) == 0) || (memcmp(entCur, "CS", (size_t)2) == 0) ) // CS, to remove later // when Write DCM *adds* // FIXME // Use gdcmParser::dicom_vr to test all the possibilities // instead of just checking for UL, OB and UI !? // group 0000 { filetype = ExplicitVR; dbg.Verbose(1, "gdcmParser::CheckSwap:", "explicit Value Representation"); } else { filetype = ImplicitVR; dbg.Verbose(1, "gdcmParser::CheckSwap:", "not an explicit Value Representation"); } if (net2host) { sw = 4321; dbg.Verbose(1, "gdcmParser::CheckSwap:", "HostByteOrder != NetworkByteOrder"); } else { sw = 0; dbg.Verbose(1, "gdcmParser::CheckSwap:", "HostByteOrder = NetworkByteOrder"); } // Position the file position indicator at first tag (i.e. // after the file preamble and the "DICM" string). rewind(fp); fseek (fp, 132L, SEEK_SET); return true; } // End of DicomV3 // Alas, this is not a DicomV3 file and whatever happens there is no file // preamble. We can reset the file position indicator to where the data // is (i.e. the beginning of the file). dbg.Verbose(1, "gdcmParser::CheckSwap:", "not a DICOM Version3 file"); rewind(fp); // Our next best chance would be to be considering a 'clean' ACR/NEMA file. // By clean we mean that the length of the first tag is written down. // If this is the case and since the length of the first group HAS to be // four (bytes), then determining the proper swap code is straightforward. entCur = deb + 4; // We assume the array of char we are considering contains the binary // representation of a 32 bits integer. Hence the following dirty // trick : s32 = *((guint32 *)(entCur)); switch (s32) { case 0x00040000 : sw = 3412; filetype = ACR; return true; case 0x04000000 : sw = 4321; filetype = ACR; return true; case 0x00000400 : sw = 2143; filetype = ACR; return true; case 0x00000004 : sw = 0; filetype = ACR; return true; default : // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file. // It is time for despaired wild guesses. // So, let's check if this file wouldn't happen to be 'dirty' ACR/NEMA, // i.e. the 'group length' element is not present : // check the supposed to be 'group number' // 0x0002 or 0x0004 or 0x0008 // to determine ' sw' value . // Only 0 or 4321 will be possible // (no oportunity to check for the formerly well known // ACR-NEMA 'Bad Big Endian' or 'Bad Little Endian' // if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -4, 8-) // the file IS NOT ACR-NEMA nor DICOM V3 // Find a trick to tell it the caller... s16 = *((guint16 *)(deb)); switch (s16) { case 0x0002 : case 0x0004 : case 0x0008 : sw = 0; filetype = ACR; return true; case 0x0200 : case 0x0400 : case 0x0800 : sw = 4321; filetype = ACR; return true; default : dbg.Verbose(0, "gdcmParser::CheckSwap:", "ACR/NEMA unfound swap info (Really hopeless !)"); filetype = Unknown; return false; } // Then the only info we have is the net2host one. //if (! net2host ) // sw = 0; //else // sw = 4321; //return; } }

bool gdcmParser::CloseFile (  void   )

closes the file Returns: TRUE if the close was successfull Definition at line 365 of file gdcmParser.cxx. References fp. Referenced by gdcmParser(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { int closed = fclose(fp); fp = (FILE *)0; if (! closed) return false; return true; }

void gdcmParser::FindHeaderEntryLength (  gdcmHeaderEntry *  Entry  )  [private]

Parameters: Entry  Header Entry whose length of the value shall be loaded. Returns: Definition at line 1416 of file gdcmParser.cxx. References dbg, ExplicitVR, filetype, FindHeaderEntryLengthOB(), FixHeaderEntryFoundLength(), fp, GDCM_DEBUG, GetDictEntryByNumber(), gdcmHeaderEntry::GetElement(), gdcmHeaderEntry::GetGroup(), gdcmHeaderEntry::GetVR(), GrPixel, IsExplicitVRBigEndianTransferSyntax(), gdcmHeaderEntry::IsImplicitVR(), NewVirtualDictEntry(), NumPixel, ReadInt16(), ReadInt32(), gdcmDebug::SetDebug(), gdcmHeaderEntry::SetDictEntry(), gdcmHeaderEntry::SetLength(), SwapShort(), SwitchSwapToBigEndian(), and gdcmDebug::Verbose(). Referenced by ReadNextHeaderEntry(). { guint16 element = Entry->GetElement(); guint16 group = Entry->GetGroup(); std::string vr = Entry->GetVR(); guint16 length16; if( (element == NumPixel) && (group == GrPixel) ) { dbg.SetDebug(GDCM_DEBUG); dbg.Verbose(2, "gdcmParser::FindLength: ", "we reached (GrPixel,NumPixel)"); } if ( (filetype == ExplicitVR) && (! Entry->IsImplicitVR()) ) { if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") ) { // The following reserved two bytes (see PS 3.5-2001, section // 7.1.2 Data element structure with explicit vr p27) must be // skipped before proceeding on reading the length on 4 bytes. fseek(fp, 2L, SEEK_CUR); guint32 length32 = ReadInt32(); if ( (vr == "OB") && (length32 == 0xffffffff) ) { Entry->SetLength(FindHeaderEntryLengthOB()); return; } FixHeaderEntryFoundLength(Entry, length32); return; } // Length is encoded on 2 bytes. length16 = ReadInt16(); // We can tell the current file is encoded in big endian (like // Data/US-RGB-8-epicard) when we find the "Transfer Syntax" tag // and it's value is the one of the encoding of a big endian file. // In order to deal with such big endian encoded files, we have // (at least) two strategies: // * when we load the "Transfer Syntax" tag with value of big endian // encoding, we raise the proper flags. Then we wait for the end // of the META group (0x0002) among which is "Transfer Syntax", // before switching the swap code to big endian. We have to postpone // the switching of the swap code since the META group is fully encoded // in little endian, and big endian coding only starts at the next // group. The corresponding code can be hard to analyse and adds // many additional unnecessary tests for regular tags. // * the second strategy consists in waiting for trouble, that shall // appear when we find the first group with big endian encoding. This // is easy to detect since the length of a "Group Length" tag (the // ones with zero as element number) has to be of 4 (0x0004). When we // encounter 1024 (0x0400) chances are the encoding changed and we // found a group with big endian encoding. // We shall use this second strategy. In order to make sure that we // can interpret the presence of an apparently big endian encoded // length of a "Group Length" without committing a big mistake, we // add an additional check: we look in the already parsed elements // for the presence of a "Transfer Syntax" whose value has to be "big // endian encoding". When this is the case, chances are we have got our // hands on a big endian encoded file: we switch the swap code to // big endian and proceed... if ( (element == 0x0000) && (length16 == 0x0400) ) { if ( ! IsExplicitVRBigEndianTransferSyntax() ) { dbg.Verbose(0, "gdcmParser::FindLength", "not explicit VR"); errno = 1; return; } length16 = 4; SwitchSwapToBigEndian(); // Restore the unproperly loaded values i.e. the group, the element // and the dictionary entry depending on them. guint16 CorrectGroup = SwapShort(Entry->GetGroup()); guint16 CorrectElem = SwapShort(Entry->GetElement()); gdcmDictEntry * NewTag = GetDictEntryByNumber(CorrectGroup, CorrectElem); if (!NewTag) { // This correct tag is not in the dictionary. Create a new one. NewTag = NewVirtualDictEntry(CorrectGroup, CorrectElem); } // FIXME this can create a memory leaks on the old entry that be // left unreferenced. Entry->SetDictEntry(NewTag); } // Heuristic: well some files are really ill-formed. if ( length16 == 0xffff) { length16 = 0; //dbg.Verbose(0, "gdcmParser::FindLength", // "Erroneous element length fixed."); // Actually, length= 0xffff means that we deal with // Unknown Sequence Length } FixHeaderEntryFoundLength(Entry, (guint32)length16); return; } else { // Either implicit VR or a non DICOM conformal (see not below) explicit // VR that ommited the VR of (at least) this element. Farts happen. // [Note: according to the part 5, PS 3.5-2001, section 7.1 p25 // on Data elements "Implicit and Explicit VR Data Elements shall // not coexist in a Data Set and Data Sets nested within it".] // Length is on 4 bytes. FixHeaderEntryFoundLength(Entry, ReadInt32()); return; } }

guint32 gdcmParser::FindHeaderEntryLengthOB (  void   )  [private]

Warning: NOT end user intended method ! Returns: Definition at line 1886 of file gdcmParser.cxx. References dbg, fp, ReadInt16(), ReadInt32(), SkipBytes(), and gdcmDebug::Verbose(). Referenced by FindHeaderEntryLength(). { // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data. guint16 g; guint16 n; long PositionOnEntry = ftell(fp); bool FoundSequenceDelimiter = false; guint32 TotalLength = 0; guint32 ItemLength; while ( ! FoundSequenceDelimiter) { g = ReadInt16(); n = ReadInt16(); if (errno == 1) return 0; TotalLength += 4; // We even have to decount the group and element if ( g != 0xfffe && g!=0xb00c ) /*for bogus header */ { char msg[100]; // for sprintf. Sorry sprintf(msg,"wrong group (%04x) for an item sequence (%04x,%04x)\n",g, g,n); dbg.Verbose(1, "gdcmParser::FindLengthOB: ",msg); errno = 1; return 0; } if ( n == 0xe0dd || ( g==0xb00c && n==0x0eb6 ) ) /* for bogus header */ FoundSequenceDelimiter = true; else if ( n != 0xe000 ) { char msg[100]; // for sprintf. Sorry sprintf(msg,"wrong element (%04x) for an item sequence (%04x,%04x)\n", n, g,n); dbg.Verbose(1, "gdcmParser::FindLengthOB: ",msg); errno = 1; return 0; } ItemLength = ReadInt32(); TotalLength += ItemLength + 4; // We add 4 bytes since we just read // the ItemLength with ReadInt32 SkipBytes(ItemLength); } fseek(fp, PositionOnEntry, SEEK_SET); return TotalLength; }

void gdcmParser::FindHeaderEntryVR (  gdcmHeaderEntry *  Entry  )  [private]

Find the Value Representation of the current Dicom Element. Parameters: Entry  Definition at line 1534 of file gdcmParser.cxx. References CheckHeaderEntryVR(), ExplicitVR, filetype, fp, gdcmHeaderEntry::IsVRUnknown(), gdcmHeaderEntry::SetImplicitVR(), and gdcmHeaderEntry::SetVR(). Referenced by ReadNextHeaderEntry(). { if (filetype != ExplicitVR) return; char VR[3]; long PositionOnEntry = ftell(fp); // Warning: we believe this is explicit VR (Value Representation) because // we used a heuristic that found "UL" in the first tag. Alas this // doesn't guarantee that all the tags will be in explicit VR. In some // cases (see e-film filtered files) one finds implicit VR tags mixed // within an explicit VR file. Hence we make sure the present tag // is in explicit VR and try to fix things if it happens not to be // the case. int lgrLue=fread (&VR, (size_t)2,(size_t)1, fp); // lgrLue not used VR[2]=0; if(!CheckHeaderEntryVR(Entry,VR)) { fseek(fp, PositionOnEntry, SEEK_SET); // When this element is known in the dictionary we shall use, e.g. for // the semantics (see the usage of IsAnInteger), the VR proposed by the // dictionary entry. Still we have to flag the element as implicit since // we know now our assumption on expliciteness is not furfilled. // avoid . if ( Entry->IsVRUnknown() ) Entry->SetVR("Implicit"); Entry->SetImplicitVR(); } }

void gdcmParser::FixHeaderEntryFoundLength (  gdcmHeaderEntry *  Entry, guint32  FoundLength )  [private]

When the length of an element value is obviously wrong (because the parser went Jabberwocky) one can hope improving things by applying this heuristic. Definition at line 1766 of file gdcmParser.cxx. References dbg, enableSequences, gdcmHeaderEntry::GetElement(), gdcmHeaderEntry::GetGroup(), gdcmHeaderEntry::GetVR(), gdcmHeaderEntry::SetReadLength(), gdcmHeaderEntry::SetUsableLength(), and gdcmDebug::Verbose(). Referenced by FindHeaderEntryLength(). { Entry->SetReadLength(FoundLength); // will be updated only if a bug is found if ( FoundLength == 0xffffffff) { FoundLength = 0; } guint16 gr =Entry->GetGroup(); guint16 el =Entry->GetElement(); if (FoundLength%2) { std::ostringstream s; s << "Warning : Tag with uneven length " << FoundLength << " in x(" << std::hex << gr << "," << el <<")" << std::dec; dbg.Verbose(0,s.str().c_str()); } // Sorry for the patch! // XMedCom did the trick to read some nasty GE images ... if (FoundLength == 13) { // The following 'if' will be removed when there is no more // images on Creatis HDs with a 13 length for Manufacturer... if ( (Entry->GetGroup() != 0x0008) || ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ){ // end of remove area FoundLength =10; Entry->SetReadLength(10); // a bug is to be fixed } } // to fix some garbage 'Leonardo' Siemens images // May be commented out to avoid overhead else if ( (Entry->GetGroup() == 0x0009) && ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) ){ FoundLength =4; Entry->SetReadLength(4); // a bug is to be fixed } // end of fix // to try to 'go inside' SeQuences (with length), and not to skip them else if ( Entry->GetVR() == "SQ") { if (enableSequences) // only if the user does want to ! FoundLength =0; // ReadLength is unchanged } // a SeQuence Element is beginning // Let's forget it's length // (we want to 'go inside') // Pb : *normaly* fffe|e000 is just a marker, its length *should be* zero // in gdcm-MR-PHILIPS-16-Multi-Seq.dcm we find lengthes as big as 28800 // if we set the length to zero IsHeaderEntryAnInteger() breaks... // if we don't, we lost 28800 characters from the Header :-( else if(Entry->GetGroup() == 0xfffe) { // sometimes, length seems to be wrong FoundLength =0; // some more clever checking to be done ! // I give up! // only gdcm-MR-PHILIPS-16-Multi-Seq.dcm // causes troubles :-( } Entry->SetUsableLength(FoundLength); }

guint32 gdcmParser::GenerateFreeTagKeyInGroup (  guint16  group  )  [private]

Small utility function that creates a new manually crafted (as opposed as read from the file) gdcmHeaderEntry with user specified name and adds it to the public tag hash table. Generate a free TagKey i.e. a TagKey that is not present in the TagHt dictionary. Parameters: group  The generated tag must belong to this group. Returns: The element of tag with given group which is fee. Definition at line 2453 of file gdcmParser.cxx. References tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). { for (guint32 elem = 0; elem < UINT32_MAX; elem++) { TagKey key = gdcmDictEntry::TranslateToKey(group, elem); if (tagHT.count(key) == 0) return elem; } return UINT32_MAX; }

gdcmDictEntry * gdcmParser::GetDictEntryByName (  std::string  Name  )  [private]

Searches both the public and the shadow dictionary (when they exist) for the presence of the DictEntry with given name. The public dictionary has precedence on the shadow one. Parameters: Name  name of the searched DictEntry Returns: Corresponding DictEntry when it exists, NULL otherwise. Definition at line 2254 of file gdcmParser.cxx. References dbg, gdcmDict::GetDictEntryByName(), RefPubDict, RefShaDict, and gdcmDebug::Verbose(). Referenced by NewHeaderEntryByName(). { gdcmDictEntry *found = (gdcmDictEntry *)0; if (!RefPubDict && !RefShaDict) { dbg.Verbose(0, "gdcmParser::GetDictEntry", "we SHOULD have a default dictionary"); } if (RefPubDict) { found = RefPubDict->GetDictEntryByName(Name); if (found) return found; } if (RefShaDict) { found = RefShaDict->GetDictEntryByName(Name); if (found) return found; } return found; }

gdcmDictEntry * gdcmParser::GetDictEntryByNumber (  guint16  group, guint16  element )  [private]

Searches both the public and the shadow dictionary (when they exist) for the presence of the DictEntry with given group and element. The public dictionary has precedence on the shadow one. Parameters: group  group of the searched DictEntry element  element of the searched DictEntry Returns: Corresponding DictEntry when it exists, NULL otherwise. Definition at line 2287 of file gdcmParser.cxx. References dbg, gdcmDict::GetDictEntryByNumber(), RefPubDict, RefShaDict, and gdcmDebug::Verbose(). Referenced by FindHeaderEntryLength(), and NewHeaderEntryByNumber(). { gdcmDictEntry *found = (gdcmDictEntry *)0; if (!RefPubDict && !RefShaDict) { dbg.Verbose(0, "gdcmParser::GetDictEntry", "we SHOULD have a default dictionary"); } if (RefPubDict) { found = RefPubDict->GetDictEntryByNumber(group, element); if (found) return found; } if (RefShaDict) { found = RefShaDict->GetDictEntryByNumber(group, element); if (found) return found; } return found; }

TagHeaderEntryHT& gdcmParser::GetEntry (  void   )  [inline]

returns a ref to the Dicom Header H table (multimap) return the Dicom Header H table Definition at line 80 of file gdcmParser.h. References TagHeaderEntryHT. Referenced by gdcmHeader::gdcmHeader(), and gdcmFile::WriteBase(). { return tagHT; };

std::string gdcmParser::GetEntryByName (  std::string  tagName  )  [protected, virtual]

Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value of a given tag. Warning: Don't use any longer : use GetPubEntryByName Parameters: tagName  name of the searched element. Returns: Corresponding element value when it exists, and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise. Reimplemented in gdcmHeader. Definition at line 524 of file gdcmParser.cxx. References GDCM_UNFOUND, gdcmDict::GetDictEntryByName(), gdcmDictEntry::GetElement(), GetEntryByNumber(), gdcmDictEntry::GetGroup(), and RefPubDict. Referenced by gdcmHeader::GetEntryByName(). { gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); if( dictEntry == NULL) return GDCM_UNFOUND; return(GetEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement())); }

std::string gdcmParser::GetEntryByNumber (  guint16  group, guint16  element )  [protected, virtual]

Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag. Parameters: group  Group of the searched tag. element  Element of the searched tag. Returns: Corresponding element value representation when it exists, and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise. Reimplemented in gdcmHeader. Definition at line 566 of file gdcmParser.cxx. References GDCM_UNFOUND, tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by GetEntryByName(), gdcmHeader::GetEntryByNumber(), and LoadHeaderEntries(). { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHT.count(key)) return GDCM_UNFOUND; return tagHT.find(key)->second->GetValue(); }

size_t gdcmParser::GetEntryOffsetByNumber (  guint16  Group, guint16  Elem )  [protected, virtual]

Gets (from Header) the offset of a 'non string' element value (LoadElementValues has already be executed). Parameters: Group  group of the Entry Elem  element of the Entry Returns: File Offset of the Element Value Definition at line 695 of file gdcmParser.cxx. References dbg, GetHeaderEntryByNumber(), gdcmHeaderEntry::GetOffset(), and gdcmDebug::Verbose(). { gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem); if (!Entry) { dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber", "failed to Locate gdcmHeaderEntry"); return (size_t)0; } return Entry->GetOffset(); }

void * gdcmParser::GetEntryVoidAreaByNumber (  guint16  Group, guint16  Elem )  [protected, virtual]

Gets (from Header) a 'non string' element value (LoadElementValues has already be executed). Parameters: Group  group of the Entry Elem  element of the Entry Returns: Pointer to the 'non string' area Definition at line 715 of file gdcmParser.cxx. References dbg, GetHeaderEntryByNumber(), gdcmHeaderEntry::GetVoidArea(), and gdcmDebug::Verbose(). Referenced by gdcmHeader::GetLUTRGBA(). { gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem); if (!Entry) { dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber", "failed to Locate gdcmHeaderEntry"); return (NULL); } return Entry->GetVoidArea(); }

std::string gdcmParser::GetEntryVRByName (  std::string  tagName  )  [protected, virtual]

Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag. Obtaining the VR (Value Representation) might be needed by caller to convert the string typed content to caller's native type (think of C++ vs Python). The VR is actually of a higher level of semantics than just the native C++ type. Parameters: tagName  name of the searched element. Returns: Corresponding element value representation when it exists, and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise. Reimplemented in gdcmHeader. Definition at line 546 of file gdcmParser.cxx. References GDCM_UNFOUND, gdcmDict::GetDictEntryByName(), gdcmDictEntry::GetElement(), gdcmDictEntry::GetGroup(), GetHeaderEntryByNumber(), gdcmHeaderEntry::GetVR(), and RefPubDict. Referenced by gdcmHeader::GetEntryVRByName(). { gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); if( dictEntry == NULL) return GDCM_UNFOUND; gdcmHeaderEntry* elem = GetHeaderEntryByNumber(dictEntry->GetGroup(), dictEntry->GetElement()); return elem->GetVR(); }

std::string gdcmParser::GetEntryVRByNumber (  guint16  group, guint16  element )  [protected, virtual]

Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag.. Obtaining the VR (Value Representation) might be needed by caller to convert the string typed content to caller's native type (think of C++ vs Python). The VR is actually of a higher level of semantics than just the native C++ type. Parameters: group  Group of the searched tag. element  Element of the searched tag. Returns: Corresponding element value representation when it exists, and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise. Reimplemented in gdcmHeader. Definition at line 588 of file gdcmParser.cxx. References GDCM_UNFOUND, GetHeaderEntryByNumber(), and gdcmHeaderEntry::GetVR(). Referenced by gdcmHeader::GetEntryVRByNumber(). { gdcmHeaderEntry* elem = GetHeaderEntryByNumber(group, element); if ( !elem ) return GDCM_UNFOUND; return elem->GetVR(); }

std::string gdcmParser::GetFileName (  void   )  [inline]

Definition at line 58 of file gdcmParser.h. Referenced by gdcmDicomDir::GetPath(), and gdcmDicomDir::SetElement(). {return filename;}

FileType gdcmParser::GetFileType (  void   )

returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown) Returns: the FileType code Definition at line 315 of file gdcmParser.cxx. References filetype, and FileType. Referenced by gdcmFile::WriteBase(). { return(filetype); }

guint16 gdcmParser::GetGrPixel (  void   )  [inline]

Definition at line 102 of file gdcmParser.h. Referenced by gdcmFile::WriteBase(). {return GrPixel;}

gdcmHeaderEntry * gdcmParser::GetHeaderEntryByName (  std::string  tagName  )  [protected]

Searches within the Header Entries for a Dicom Element of a given tag. Parameters: tagName  name of the searched Dicom Element. Returns: Corresponding Dicom Element when it exists, and NULL otherwise. Definition at line 829 of file gdcmParser.cxx. References gdcmDict::GetDictEntryByName(), gdcmDictEntry::GetElement(), gdcmDictEntry::GetGroup(), GetHeaderEntryByNumber(), and RefPubDict. { gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); if( dictEntry == NULL) return NULL; return(GetHeaderEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement())); }

gdcmHeaderEntry * gdcmParser::GetHeaderEntryByNumber (  guint16  group, guint16  element )  [protected]

retrieves a Dicom Element (the first one) using (group, element) Warning: (group, element) IS NOT an identifier inside the Dicom Header if you think it's NOT UNIQUE, check the count number and use iterators to retrieve ALL the Dicoms Elements within a given couple (group, element) Parameters: group  Group number of the searched Dicom Element element  Element number of the searched Dicom Element Returns: Definition at line 848 of file gdcmParser.cxx. References tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmHeader::anonymizeHeader(), GetEntryOffsetByNumber(), GetEntryVoidAreaByNumber(), GetEntryVRByName(), GetEntryVRByNumber(), GetHeaderEntryByName(), gdcmHeader::HasLUT(), IsDeflatedExplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsDicomV3(), IsExplicitVRBigEndianTransferSyntax(), IsExplicitVRLittleEndianTransferSyntax(), IsImplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsJPEG2000(), gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(), gdcmHeader::IsJPEGLossless(), gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(), gdcmHeader::IsReadable(), gdcmHeader::IsRLELossLessTransferSyntax(), LoadEntryVoidArea(), gdcmHeader::SetImageDataSize(), and UpdateGroupLength(). { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHT.count(key)) return NULL; return tagHT.find(key)->second; }

IterHT gdcmParser::GetHeaderEntrySameNumber (  guint16  group, guint16  element )  [protected]

retrieves the Dicom Elements (all of them) using (group, element) Parameters: group  Group number of the searched Dicom Element. element  Element number of the searched Dicom Element. Returns: a range (i.e.pair<,>) containing all elements whose key is group|element) Definition at line 864 of file gdcmParser.cxx. References IterHT, tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmHeader::GetPixelAreaLength(), and gdcmHeader::GetPixelOffset(). { TagKey key = gdcmDictEntry::TranslateToKey(group, element); return (tagHT.equal_range(key)); }

std::string gdcmParser::GetHeaderEntryUnvalue (  gdcmHeaderEntry *  Entry  )  [private]

Get the reverse transformed value of the header entry. The VR value is used to define the reverse transformation to operate on the value. Warning: NOT end user intended method ! Parameters: Entry  Returns: Reverse transformed entry value Definition at line 1704 of file gdcmParser.cxx. References gdcmHeaderEntry::GetValue(), gdcmHeaderEntry::GetVR(), IsHeaderEntryAnInteger(), gdcmHeaderEntry::IsImplicitVR(), and Tokenize(). Referenced by UpdateShaEntries(). { if ( (IsHeaderEntryAnInteger(Entry)) && (Entry->IsImplicitVR()) ) { std::string vr=Entry->GetVR(); std::ostringstream s; std::vector<std::string> tokens; if (vr == "US" || vr == "SS") { guint16 NewInt16; tokens.erase(tokens.begin(),tokens.end()); // clean any previous value Tokenize (Entry->GetValue(), tokens, "\\"); for (unsigned int i=0; i<tokens.size();i++) { NewInt16 = atoi(tokens[i].c_str()); s<<(NewInt16&0xFF)<<((NewInt16>>8)&0xFF); } tokens.clear(); } if (vr == "UL" || vr == "SL") { guint32 NewInt32; tokens.erase(tokens.begin(),tokens.end()); // clean any previous value Tokenize (Entry->GetValue(), tokens, "\\"); for (unsigned int i=0; i<tokens.size();i++) { NewInt32 = atoi(tokens[i].c_str()); s<<(char)(NewInt32&0xFF)<<(char)((NewInt32>>8)&0xFF) <<(char)((NewInt32>>16)&0xFF)<<(char)((NewInt32>>24)&0xFF); } tokens.clear(); } #ifdef GDCM_NO_ANSI_STRING_STREAM s << std::ends; // to avoid oddities on Solaris #endif //GDCM_NO_ANSI_STRING_STREAM return(s.str()); } return(Entry->GetValue()); }

std::string gdcmParser::GetHeaderEntryValue (  gdcmHeaderEntry *  Entry  )  [private]

Get the transformed value of the header entry. The VR value is used to define the transformation to operate on the value. Warning: NOT end user intended method ! Parameters: Entry  Returns: Transformed entry value Definition at line 1646 of file gdcmParser.cxx. References gdcmHeaderEntry::GetLength(), gdcmHeaderEntry::GetValue(), gdcmHeaderEntry::GetVR(), IsHeaderEntryAnInteger(), gdcmHeaderEntry::IsImplicitVR(), SwapLong(), and SwapShort(). Referenced by UpdateShaEntries(). { if ( (IsHeaderEntryAnInteger(Entry)) && (Entry->IsImplicitVR()) ) { std::string val=Entry->GetValue(); std::string vr=Entry->GetVR(); guint32 length = Entry->GetLength(); std::ostringstream s; int nbInt; if (vr == "US" || vr == "SS") { guint16 NewInt16; nbInt = length / 2; for (int i=0; i < nbInt; i++) { if(i!=0) s << '\\'; NewInt16 = (val[2*i+0]&0xFF)+((val[2*i+1]&0xFF)<<8); NewInt16 = SwapShort(NewInt16); s << NewInt16; } } else if (vr == "UL" || vr == "SL") { guint32 NewInt32; nbInt = length / 4; for (int i=0; i < nbInt; i++) { if(i!=0) s << '\\'; NewInt32= (val[4*i+0]&0xFF)+((val[4*i+1]&0xFF)<<8)+ ((val[4*i+2]&0xFF)<<16)+((val[4*i+3]&0xFF)<<24); NewInt32=SwapLong(NewInt32); s << NewInt32; } } #ifdef GDCM_NO_ANSI_STRING_STREAM s << std::ends; // to avoid oddities on Solaris #endif //GDCM_NO_ANSI_STRING_STREAM return(s.str()); } return(Entry->GetValue()); }

ListTag& gdcmParser::GetListEntry (  void   )  [inline]

returns a ref to the Dicom Header chained list return the Dicom Header chained list Definition at line 87 of file gdcmParser.h. References ListTag. Referenced by gdcmDicomDir::CreateDicomDir(), gdcmDicomDir::gdcmDicomDir(), and LoadHeaderEntries(). { return listEntries; };

guint16 gdcmParser::GetNumPixel (  void   )  [inline]

Definition at line 103 of file gdcmParser.h. Referenced by gdcmFile::WriteBase(). {return NumPixel;}

gdcmDict * gdcmParser::GetPubDict (  void   )

Get the public dictionary used. Definition at line 185 of file gdcmParser.cxx. References RefPubDict. Referenced by gdcmDicomDir::SetElement(). { return(RefPubDict); }

gdcmDict * gdcmParser::GetShaDict (  void   )

Get the shadow dictionary used. Definition at line 193 of file gdcmParser.cxx. References RefShaDict. { return(RefShaDict); }

int gdcmParser::GetSwapCode (  void   )  [inline]

Definition at line 101 of file gdcmParser.h. Referenced by gdcmFile::gdcm_read_RLE_file(), gdcmFile::GetImageDataIntoVectorRaw(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { return sw; }

void gdcmParser::Initialise (  void   )  [private]

Definition at line 1988 of file gdcmParser.cxx. References gdcmDictSet::GetDefaultPubDict(), gdcmGlobal::GetDicts(), RefPubDict, and RefShaDict. Referenced by gdcmParser(). { RefPubDict = gdcmGlobal::GetDicts()->GetDefaultPubDict(); RefShaDict = (gdcmDict*)0; }

bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax (  void   )

Determines if the Transfer Syntax was already encountered and if it corresponds to a DeflatedExplicitVRLittleEndian one. Returns: True when DeflatedExplicitVRLittleEndian found. False in all other cases. Definition at line 279 of file gdcmParser.cxx. References GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2_1_99. Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadHeaderEntrySafe(Element); std::string Transfer = Element->GetValue(); if ( Transfer == UI1_2_840_10008_1_2_1_99 ) return true; return false; }

bool gdcmParser::IsExplicitVRBigEndianTransferSyntax (  void   )

Determines if the Transfer Syntax was already encountered and if it corresponds to a Explicit VR Big Endian one. Returns: True when big endian found. False in all other cases. Definition at line 297 of file gdcmParser.cxx. References GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2_2. Referenced by FindHeaderEntryLength(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadHeaderEntrySafe(Element); std::string Transfer = Element->GetValue(); if ( Transfer == UI1_2_840_10008_1_2_2 ) //1.2.2 ??? A verifier ! return true; return false; }

bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax (  void   )

Determines if the Transfer Syntax was already encountered and if it corresponds to a ExplicitVRLittleEndian one. Returns: True when ExplicitVRLittleEndian found. False in all other cases. Definition at line 261 of file gdcmParser.cxx. References GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2_1. Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadHeaderEntrySafe(Element); std::string Transfer = Element->GetValue(); if ( Transfer == UI1_2_840_10008_1_2_1 ) return true; return false; }

bool gdcmParser::IsHeaderEntryAnInteger (  gdcmHeaderEntry *  Entry  )  [private]

Apply some heuristics to predict wether the considered element value contains/represents an integer or not. Parameters: Entry  The element value on which to apply the predicate. Returns: The result of the heuristical predicate. Definition at line 1841 of file gdcmParser.cxx. References fp, gdcmHeaderEntry::GetElement(), gdcmHeaderEntry::GetGroup(), gdcmHeaderEntry::GetLength(), and gdcmHeaderEntry::GetVR(). Referenced by GetHeaderEntryUnvalue(), GetHeaderEntryValue(), and LoadHeaderEntry(). { guint16 element = Entry->GetElement(); guint16 group = Entry->GetGroup(); std::string vr = Entry->GetVR(); guint32 length = Entry->GetLength(); // When we have some semantics on the element we just read, and if we // a priori know we are dealing with an integer, then we shall be // able to swap it's element value properly. if ( element == 0 ) // This is the group length of the group { if (length == 4) return true; else { std::ostringstream s; int filePosition = ftell(fp); s << "Erroneous Group Length element length on : (" \ << std::hex << group << " , " << element << ") -before- position x(" << filePosition << ")" << "lgt : " << length; // These 2 lines commented out : a *very dirty* patch // to go on PrintHeader'ing gdcm-MR-PHILIPS-16-Multi-Seq.dcm. // have a glance at offset x(8336) ... // For *regular* headers, the test is useless.. // lets's print a warning message and go on, // instead of giving up with an error message //std::cout << s.str().c_str() << std::endl; // dbg.Error("gdcmParser::IsHeaderEntryAnInteger", // s.str().c_str()); } } if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") ) return true; return false; }

bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax (  void   )

Determines if the Transfer Syntax was already encountered and if it corresponds to a ImplicitVRLittleEndian one. Returns: True when ImplicitVRLittleEndian found. False in all other cases. Definition at line 243 of file gdcmParser.cxx. References GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2. Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { gdcmHeaderEntry *Element = GetHeaderEntryByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadHeaderEntrySafe(Element); std::string Transfer = Element->GetValue(); if ( Transfer == UI1_2_840_10008_1_2 ) return true; return false; }

bool gdcmParser::IsReadable (  void   )  [virtual]

This predicate, based on hopefully reasonable heuristics, decides whether or not the current gdcmParser was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File. Returns: true when gdcmParser is the one of a reasonable Dicom/Acr file, false otherwise. Reimplemented in gdcmHeader. Definition at line 226 of file gdcmParser.cxx. References filetype, listEntries, and Unknown. Referenced by gdcmHeader::IsReadable(). { if(filetype==Unknown) { return(false); } if(listEntries.size()<=0) { return(false); } return(true); }

void * gdcmParser::LoadEntryVoidArea (  guint16  Group, guint16  Elem )  [protected, virtual]

Loads (from disk) the element content when a string is not suitable. Parameters: Group  group of the Entry Elem  element of the Entry Definition at line 734 of file gdcmParser.cxx. References fp, GetHeaderEntryByNumber(), gdcmHeaderEntry::GetLength(), gdcmHeaderEntry::GetOffset(), and SetEntryVoidAreaByNumber(). Referenced by LoadHeaderEntries(). { gdcmHeaderEntry * Element= GetHeaderEntryByNumber(Group, Elem); if ( !Element ) return NULL; size_t o =(size_t)Element->GetOffset(); fseek(fp, o, SEEK_SET); int l=Element->GetLength(); void * a = malloc(l); if(!a) return NULL; SetEntryVoidAreaByNumber(a, Group, Elem); // TODO check the result size_t l2 = fread(a, 1, l ,fp); if(l != l2) { free(a); return NULL; } return a; }

void gdcmParser::LoadHeaderEntries (  void   )  [private]

Loads the element values of all the Header Entries pointed in the public Chained List. Definition at line 1237 of file gdcmParser.cxx. References ACR_LIBIDO, filetype, fp, GetEntryByNumber(), GetListEntry(), LoadEntryVoidArea(), LoadHeaderEntry(), and SetEntryByNumber(). Referenced by gdcmParser(). { rewind(fp); for (ListTag::iterator i = GetListEntry().begin(); i != GetListEntry().end(); ++i) { LoadHeaderEntry(*i); } rewind(fp); // Load 'non string' values std::string PhotometricInterpretation = GetEntryByNumber(0x0028,0x0004); if( PhotometricInterpretation == "PALETTE COLOR " ) { LoadEntryVoidArea(0x0028,0x1200); // gray LUT LoadEntryVoidArea(0x0028,0x1201); // R LUT LoadEntryVoidArea(0x0028,0x1202); // G LUT LoadEntryVoidArea(0x0028,0x1203); // B LUT LoadEntryVoidArea(0x0028,0x1221); // Segmented Red Palette Color LUT Data LoadEntryVoidArea(0x0028,0x1222); // Segmented Green Palette Color LUT Data LoadEntryVoidArea(0x0028,0x1223); // Segmented Blue Palette Color LUT Data } //FIXME : how to use it? LoadEntryVoidArea(0x0028,0x3006); //LUT Data (CTX dependent) // -------------------------------------------------------------- // Special Patch to allow gdcm to read ACR-LibIDO formated images // // if recognition code tells us we deal with a LibIDO image // we switch lineNumber and columnNumber // std::string RecCode; RecCode = GetEntryByNumber(0x0008, 0x0010); // recognition code if (RecCode == "ACRNEMA_LIBIDO_1.1" || RecCode == "CANRME_AILIBOD1_1." ) { filetype = ACR_LIBIDO; std::string rows = GetEntryByNumber(0x0028, 0x0010); std::string columns = GetEntryByNumber(0x0028, 0x0011); SetEntryByNumber(columns, 0x0028, 0x0010); SetEntryByNumber(rows , 0x0028, 0x0011); } // ----------------- End of Special Patch ---------------- }

void gdcmParser::LoadHeaderEntry (  gdcmHeaderEntry *  Entry  )  [private]

Loads the element content if its length doesn't exceed the value specified with gdcmParser::SetMaxSizeLoadEntry(). Parameters: Entry  Header Entry (Dicom Element) to be dealt with Definition at line 1289 of file gdcmParser.cxx. References dbg, fp, gdcmHeaderEntry::GetGroup(), gdcmHeaderEntry::GetLength(), gdcmHeaderEntry::GetOffset(), gdcmHeaderEntry::GetVR(), IsHeaderEntryAnInteger(), MaxSizeLoadEntry, ReadInt16(), ReadInt32(), gdcmHeaderEntry::SetLength(), gdcmHeaderEntry::SetValue(), and gdcmDebug::Verbose(). Referenced by LoadHeaderEntries(), and LoadHeaderEntrySafe(). { size_t item_read; guint16 group = Entry->GetGroup(); std::string vr= Entry->GetVR(); guint32 length = Entry->GetLength(); bool SkipLoad = false; fseek(fp, (long)Entry->GetOffset(), SEEK_SET); // the test was commented out to 'go inside' the SeQuences // we don't any longer skip them ! // if( vr == "SQ" ) // (DO NOT remove this comment) // SkipLoad = true; // A SeQuence "contains" a set of Elements. // (fffe e000) tells us an Element is beginning // (fffe e00d) tells us an Element just ended // (fffe e0dd) tells us the current SeQuence just ended if( group == 0xfffe ) SkipLoad = true; if ( SkipLoad ) { Entry->SetLength(0); Entry->SetValue("gdcm::Skipped"); return; } // When the length is zero things are easy: if ( length == 0 ) { Entry->SetValue(""); return; } // The elements whose length is bigger than the specified upper bound // are not loaded. Instead we leave a short notice of the offset of // the element content and it's length. if (length > MaxSizeLoadEntry) { std::ostringstream s; s << "gdcm::NotLoaded."; s << " Address:" << (long)Entry->GetOffset(); s << " Length:" << Entry->GetLength(); s << " x(" << std::hex << Entry->GetLength() << ")"; Entry->SetValue(s.str()); return; } // When integer(s) are expected, read and convert the following // n *(two or four bytes) // properly i.e. as integers as opposed to strings. // Elements with Value Multiplicity > 1 // contain a set of integers (not a single one) // Any compacter code suggested (?) if ( IsHeaderEntryAnInteger(Entry) ) { guint32 NewInt; std::ostringstream s; int nbInt; if (vr == "US" || vr == "SS") { nbInt = length / 2; NewInt = ReadInt16(); s << NewInt; if (nbInt > 1){ for (int i=1; i < nbInt; i++) { s << '\\'; NewInt = ReadInt16(); s << NewInt; } } } else if (vr == "UL" || vr == "SL") { nbInt = length / 4; NewInt = ReadInt32(); s << NewInt; if (nbInt > 1) { for (int i=1; i < nbInt; i++) { s << '\\'; NewInt = ReadInt32(); s << NewInt; } } } #ifdef GDCM_NO_ANSI_STRING_STREAM s << std::ends; // to avoid oddities on Solaris #endif //GDCM_NO_ANSI_STRING_STREAM Entry->SetValue(s.str()); return; } // We need an additional byte for storing \0 that is not on disk std::string NewValue(length,0); item_read = fread(&(NewValue[0]), (size_t)length, (size_t)1, fp); if ( item_read != 1 ) { dbg.Verbose(1, "gdcmParser::LoadElementValue","unread element value"); Entry->SetValue("gdcm::UnRead"); return; } if( (vr == "UI") ) // Because of correspondance with the VR dic Entry->SetValue(NewValue.c_str()); // ??? JPR ??? else Entry->SetValue(NewValue); }

void gdcmParser::LoadHeaderEntrySafe (  gdcmHeaderEntry *  entry  )  [protected]

Loads the element while preserving the current underlying file position indicator as opposed to to LoadHeaderEntry that modifies it. Parameters: entry  Header Entry whose value shall be loaded. Returns: Definition at line 877 of file gdcmParser.cxx. References fp, and LoadHeaderEntry(). Referenced by IsDeflatedExplicitVRLittleEndianTransferSyntax(), IsExplicitVRBigEndianTransferSyntax(), IsExplicitVRLittleEndianTransferSyntax(), IsImplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsJPEG2000(), gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(), gdcmHeader::IsJPEGLossless(), gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(), and gdcmHeader::IsRLELossLessTransferSyntax(). { long PositionOnEntry = ftell(fp); LoadHeaderEntry(entry); fseek(fp, PositionOnEntry, SEEK_SET); }

gdcmHeaderEntry * gdcmParser::NewHeaderEntryByName (  std::string  Name  )  [private]

Build a new Element Value from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent. Parameters: Name  Name of the underlying DictEntry Definition at line 2354 of file gdcmParser.cxx. References dbg, GetDictEntryByName(), NewVirtualDictEntry(), and gdcmDebug::Verbose(). { gdcmDictEntry *NewTag = GetDictEntryByName(Name); if (!NewTag) NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "unkn", Name); gdcmHeaderEntry* NewEntry = new gdcmHeaderEntry(NewTag); if (!NewEntry) { dbg.Verbose(1, "gdcmParser::ObtainHeaderEntryByName", "failed to allocate gdcmHeaderEntry"); return (gdcmHeaderEntry *)0; } return NewEntry; }

gdcmHeaderEntry * gdcmParser::NewHeaderEntryByNumber (  guint16  Group, guint16  Elem )  [private]

Build a new Element Value from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent. Parameters: Group  group of the underlying DictEntry Elem  element of the underlying DictEntry Definition at line 2395 of file gdcmParser.cxx. References dbg, GetDictEntryByNumber(), NewVirtualDictEntry(), and gdcmDebug::Verbose(). Referenced by ReadNextHeaderEntry(), and ReplaceOrCreateByNumber(). { // Find out if the tag we encountered is in the dictionaries: gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem); if (!DictEntry) DictEntry = NewVirtualDictEntry(Group, Elem); gdcmHeaderEntry *NewEntry = new gdcmHeaderEntry(DictEntry); if (!NewEntry) { dbg.Verbose(1, "gdcmParser::NewHeaderEntryByNumber", "failed to allocate gdcmHeaderEntry"); return NULL; } return NewEntry; }

gdcmDictEntry* gdcmParser::NewVirtualDictEntry (  gdcmHeaderEntry *   )  [private]

gdcmDictEntry * gdcmParser::NewVirtualDictEntry (  guint16  group, guint16  element, std::string  vr = "unkn", std::string  fourth = "unkn", std::string  name = "unkn" )  [private]

Request a new virtual dict entry to the dict set. Parameters: group  group of the underlying DictEntry element  element of the underlying DictEntry vr  VR of the underlying DictEntry fourth  owner group name  english name Definition at line 2379 of file gdcmParser.cxx. References gdcmGlobal::GetDicts(), and gdcmDictSet::NewVirtualDictEntry(). Referenced by CheckHeaderEntryVR(), FindHeaderEntryLength(), NewHeaderEntryByName(), NewHeaderEntryByNumber(), and UpdateShaEntries(). { return gdcmGlobal::GetDicts()->NewVirtualDictEntry(group,element,vr,fourth,name); }

FILE * gdcmParser::OpenFile (  bool  exception_on_error = false  )  throw (gdcmFileError)

opens the file Parameters: exception_on_error  Returns: Definition at line 325 of file gdcmParser.cxx. References dbg, and gdcmDebug::Verbose(). Referenced by gdcmParser(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData(). { fp=fopen(filename.c_str(),"rb"); if(exception_on_error) { if(!fp) throw gdcmFileError("gdcmParser::gdcmParser(const char *, bool)"); } if ( fp ) { guint16 zero; fread(&zero, (size_t)2, (size_t)1, fp); //ACR -- or DICOM with no Preamble -- if( zero == 0x0008 || zero == 0x0800 || zero == 0x0002 || zero == 0x0200) return(fp); //DICOM fseek(fp, 126L, SEEK_CUR); char dicm[4]; fread(dicm, (size_t)4, (size_t)1, fp); if( memcmp(dicm, "DICM", 4) == 0 ) return(fp); fclose(fp); dbg.Verbose(0, "gdcmParser::OpenFile not DICOM/ACR", filename.c_str()); } else { dbg.Verbose(0, "gdcmParser::OpenFile cannot open file", filename.c_str()); } return(NULL); }

bool gdcmParser::ParseHeader (  bool  exception_on_error = false  )  throw (gdcmFormatError) [private]

Parses the header of the file but WITHOUT loading element values. Returns: false if file is not ACR-NEMA / DICOM Definition at line 1216 of file gdcmParser.cxx. References gdcmHeaderEntry::GetGroup(). Referenced by gdcmParser(). { rewind(fp); if (!CheckSwap()) return false; gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0; while ( (newHeaderEntry = ReadNextHeaderEntry()) ) { SkipHeaderEntry(newHeaderEntry); if ( (ignoreShadow==0) || (newHeaderEntry->GetGroup()%2) == 0) { AddHeaderEntry(newHeaderEntry); } } return true; }

virtual void gdcmParser::Print (  std::ostream &  os = std::cout  )  [inline, virtual]

Reimplemented in gdcmDicomDir. Definition at line 52 of file gdcmParser.h. {PrintEntry(os);};

void gdcmParser::PrintEntry (  std::ostream &  os = std::cout  )  [virtual]

Prints the Header Entries (Dicom Elements) both from the H Table and the chained list. Returns: Definition at line 148 of file gdcmParser.cxx. References listEntries. { std::ostringstream s; for (ListTag::iterator i = listEntries.begin(); i != listEntries.end(); ++i) { (*i)->SetPrintLevel(printLevel); (*i)->Print(os); } os<<s.str(); }

void gdcmParser::PrintPubDict (  std::ostream &  os = std::cout  )  [virtual]

Prints The Dict Entries of THE public Dicom Dictionnry. Returns: Definition at line 166 of file gdcmParser.cxx. References gdcmDict::Print(), and RefPubDict. { RefPubDict->Print(os); }

void gdcmParser::PrintShaDict (  std::ostream &  os = std::cout  )  [virtual]

Prints The Dict Entries of THE shadow Dicom Dictionnry. Returns: Definition at line 175 of file gdcmParser.cxx. References gdcmDict::Print(), and RefShaDict. { RefShaDict->Print(os); }

guint16 gdcmParser::ReadInt16 (  void   )  [private]

Reads a supposed to be 16 Bits integer (swaps it depending on processor endianity). Returns: read value Definition at line 1937 of file gdcmParser.cxx. References dbg, fp, SwapShort(), and gdcmDebug::Verbose(). Referenced by FindHeaderEntryLength(), FindHeaderEntryLengthOB(), LoadHeaderEntry(), and ReadNextHeaderEntry(). { guint16 g; size_t item_read; item_read = fread (&g, (size_t)2,(size_t)1, fp); if ( item_read != 1 ) { if(ferror(fp)) dbg.Verbose(0, "gdcmParser::ReadInt16", " File Error"); errno = 1; return 0; } errno = 0; g = SwapShort(g); return g; }

guint32 gdcmParser::ReadInt32 (  void   )  [private]

Reads a supposed to be 32 Bits integer (swaps it depending on processor endianity). Returns: read value Definition at line 1958 of file gdcmParser.cxx. References dbg, fp, SwapLong(), and gdcmDebug::Verbose(). Referenced by FindHeaderEntryLength(), FindHeaderEntryLengthOB(), and LoadHeaderEntry(). { guint32 g; size_t item_read; item_read = fread (&g, (size_t)4,(size_t)1, fp); if ( item_read != 1 ) { if(ferror(fp)) dbg.Verbose(0, "gdcmParser::ReadInt32", " File Error"); errno = 1; return 0; } errno = 0; g = SwapLong(g); return g; }

gdcmHeaderEntry * gdcmParser::ReadNextHeaderEntry (  void   )  [private]

Read the next tag but WITHOUT loading it's value. Returns: On succes the newly created HeaderEntry, NULL on failure. Definition at line 2315 of file gdcmParser.cxx. References FindHeaderEntryLength(), FindHeaderEntryVR(), fp, NewHeaderEntryByNumber(), ReadInt16(), and gdcmHeaderEntry::SetOffset(). { guint16 g,n; gdcmHeaderEntry *NewEntry; g = ReadInt16(); n = ReadInt16(); if (errno == 1) // We reached the EOF (or an error occured) therefore // header parsing has to be considered as finished. return (gdcmHeaderEntry *)0; /* Pb : how to propagate the element length (used in SkipHeaderEntry) // direct call to SkipBytes ? if (ignoreShadow == 1 && g%2 ==1) //JPR // if user wants to skip shadow groups // and current element *is* a shadow element // we don't create anything return (gdcmHeaderEntry *)1; // to tell caller it's NOT finished */ NewEntry = NewHeaderEntryByNumber(g, n); FindHeaderEntryVR(NewEntry); FindHeaderEntryLength(NewEntry); if (errno == 1) { // Call it quits return NULL; } NewEntry->SetOffset(ftell(fp)); return NewEntry; }

bool gdcmParser::ReplaceIfExistByNumber (  char *  Value, guint16  Group, guint16  Elem )

Set a new value if the invoked element exists Seems to be useless !!! Parameters: Value  new element value Group  group of the Entry Elem  element of the Entry Returns: boolean Definition at line 491 of file gdcmParser.cxx. References SetEntryByNumber(). Referenced by gdcmHeader::anonymizeHeader(). { std::string v = Value; SetEntryByNumber(v, Group, Elem); return true; }

bool gdcmParser::ReplaceOrCreateByNumber (  char *  Value, guint16  Group, guint16  Elem )

Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't. Parameters: Value  passed as a char* Group  group of the Entry Elem  element of the Entry Returns: boolean Definition at line 469 of file gdcmParser.cxx. References AddHeaderEntry(), NewHeaderEntryByNumber(), and SetEntryByNumber(). { gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem); if(!nvHeaderEntry) return(false); AddHeaderEntry(nvHeaderEntry); std::string v = Value; SetEntryByNumber(v, Group, Elem); return(true); }

bool gdcmParser::ReplaceOrCreateByNumber (  std::string  Value, guint16  Group, guint16  Elem )

Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't. Parameters: Value  passed as a std::string Group  Elem  Returns: false only if new element creation fails Definition at line 446 of file gdcmParser.cxx. References AddHeaderEntry(), CheckIfEntryExistByNumber(), NewHeaderEntryByNumber(), and SetEntryByNumber(). Referenced by gdcmHeader::anonymizeHeader(), and Write(). { if (CheckIfEntryExistByNumber(Group, Elem) == 0) { gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem); if (a == NULL) return false; AddHeaderEntry(a); } SetEntryByNumber(Value, Group, Elem); return(true); }

bool gdcmParser::SetEntryByName (  std::string  content, std::string  tagName )  [protected, virtual]

Sets the value (string) of the Header Entry (Dicom Element). Parameters: content  string value of the Dicom Element tagName  name of the searched Dicom Element. Returns: true when found Reimplemented in gdcmHeader. Definition at line 602 of file gdcmParser.cxx. References gdcmDict::GetDictEntryByName(), gdcmDictEntry::GetElement(), gdcmDictEntry::GetGroup(), RefPubDict, and SetEntryByNumber(). Referenced by gdcmHeader::SetEntryByName(). { gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); if( dictEntry == NULL) return false; return(SetEntryByNumber(content,dictEntry->GetGroup(), dictEntry->GetElement())); }

bool gdcmParser::SetEntryByNumber (  std::string  content, guint16  group, guint16  element )  [protected, virtual]

Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value. Warning: Don't use any longer : use SetPubEntryByNumber Parameters: content  new value to substitute with group  group of the Dicom Element to modify element  element of the Dicom Element to modify Reimplemented in gdcmHeader. Definition at line 621 of file gdcmParser.cxx. References gdcmHeaderEntry::GetVR(), IterHT, gdcmHeaderEntry::SetLength(), tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by LoadHeaderEntries(), ReplaceIfExistByNumber(), ReplaceOrCreateByNumber(), SetEntryByName(), and gdcmHeader::SetEntryByNumber(). { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHT.count(key)) return false; int l = content.length(); if(l%2) // Non even length are padded with a space (020H). { l++; content = content + '\0'; } gdcmHeaderEntry * a; IterHT p; TagHeaderEntryHT::iterator p2; // DO NOT remove the following lines : they explain the stuff //p= tagHT.equal_range(key); // get a pair of iterators first-last synonym //p2=p.first; // iterator on the first synonym //a=p2->second; // H Table target column (2-nd col) // or, easier : a = ((tagHT.equal_range(key)).first)->second; a-> SetValue(content); std::string vr = a->GetVR(); guint32 lgr; if( (vr == "US") || (vr == "SS") ) lgr = 2; else if( (vr == "UL") || (vr == "SL") ) lgr = 4; else lgr = l; a->SetLength(lgr); return true; }

bool gdcmParser::SetEntryLengthByNumber (  guint32  l, guint16  group, guint16  element )  [protected, virtual]

Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) in the PubHeaderEntrySet of this instance through it's (group, element) and modifies it's length with the given value. Warning: Use with extreme caution. Parameters: l  new length to substitute with group  group of the Entry to modify element  element of the Entry to modify Returns: 1 on success, 0 otherwise. Reimplemented in gdcmHeader. Definition at line 674 of file gdcmParser.cxx. References tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmHeader::SetEntryLengthByNumber(), and Write(). { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHT.count(key)) return false; if (l%2) l++; // length must be even ( ((tagHT.equal_range(key)).first)->second )->SetLength(l); return true ; }

bool gdcmParser::SetEntryVoidAreaByNumber (  void *  area, guint16  group, guint16  element )  [protected, virtual]

Sets a 'non string' value to a given Dicom Element. Parameters: area  group  Group number of the searched Dicom Element element  Element number of the searched Dicom Element Returns: Definition at line 766 of file gdcmParser.cxx. References tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by LoadEntryVoidArea(). { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHT.count(key)) return false; ( ((tagHT.equal_range(key)).first)->second )->SetVoidArea(area); return true; }

void gdcmParser::SetMaxSizeLoadEntry (  long  NewSize  )  [private]

during parsing, Header Elements too long are not loaded in memory Parameters: NewSize  Definition at line 2211 of file gdcmParser.cxx. References MaxSizeLoadEntry. Referenced by gdcmParser(). { if (NewSize < 0) return; if ((guint32)NewSize >= (guint32)0xffffffff) { MaxSizeLoadEntry = 0xffffffff; return; } MaxSizeLoadEntry = NewSize; }

void gdcmParser::SetMaxSizePrintEntry (  long  NewSize  )  [private]

Header Elements too long will not be printed. Warning: Todo: : not yet usable (see MAX_SIZE_PRINT_ELEMENT_VALUE in gdcmHeaderEntry gdcmLoadEntry) Parameters: NewSize  Definition at line 2234 of file gdcmParser.cxx. References MaxSizePrintEntry. { if (NewSize < 0) return; if ((guint32)NewSize >= (guint32)0xffffffff) { MaxSizePrintEntry = 0xffffffff; return; } MaxSizePrintEntry = NewSize; }

void gdcmParser::SetPrintLevel (  int  level  )  [inline]

Sets the print level for the Dicom Header. Note: 0 for Light Print; 1 for 'medium' Print, 2 for Heavy Reimplemented in gdcmDicomDir. Definition at line 51 of file gdcmParser.h. { printLevel = level; };

bool gdcmParser::SetShaDict (  DictKey  dictName  )

Set the shadow dictionary used. Parameters: dictName  name of the dictionary to use in shadow Definition at line 212 of file gdcmParser.cxx. References DictKey, gdcmDictSet::GetDict(), gdcmGlobal::GetDicts(), and RefShaDict. { RefShaDict=gdcmGlobal::GetDicts()->GetDict(dictName); return(!RefShaDict); }

bool gdcmParser::SetShaDict (  gdcmDict *  dict  )

Set the shadow dictionary used. Parameters: dict  dictionary to use in shadow Definition at line 202 of file gdcmParser.cxx. References RefShaDict. { RefShaDict=dict; return(!RefShaDict); }

void gdcmParser::SkipBytes (  guint32  NBytes  )  [private]

Warning: NOT end user intended method ! Returns: Definition at line 1979 of file gdcmParser.cxx. References fp. Referenced by FindHeaderEntryLengthOB(), and SkipHeaderEntry(). { //FIXME don't dump the returned value (void)fseek(fp, (long)NBytes, SEEK_CUR); }

void gdcmParser::SkipHeaderEntry (  gdcmHeaderEntry *  entry  )  [private]

Skip a given Header Entry. Warning: NOT end user intended method ! Parameters: entry  Definition at line 1755 of file gdcmParser.cxx. References gdcmHeaderEntry::GetLength(), and SkipBytes(). { SkipBytes(entry->GetLength()); }

guint32 gdcmParser::SwapLong (  guint32  a  )

Swaps back the bytes of 4-byte long integer accordingly to processor order. Returns: The properly swaped 32 bits integer. Definition at line 1156 of file gdcmParser.cxx. References dbg, gdcmDebug::Error(), and sw. Referenced by gdcmFile::gdcm_read_RLE_file(), GetHeaderEntryValue(), gdcmFile::ParsePixelData(), ReadInt32(), gdcmFile::ReadPixelData(), and UnswapLong(). { switch (sw) { case 0 : break; case 4321 : a=( ((a<<24) & 0xff000000) | ((a<<8) & 0x00ff0000) | ((a>>8) & 0x0000ff00) | ((a>>24) & 0x000000ff) ); break; case 3412 : a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) ); break; case 2143 : a=( ((a<<8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff) ); break; default : dbg.Error(" gdcmParser::SwapLong : unset swap code"); a=0; } return(a); }

guint16 gdcmParser::SwapShort (  guint16  a  )

Swaps the bytes so they agree with the processor order. Returns: The properly swaped 16 bits integer. Definition at line 1194 of file gdcmParser.cxx. References sw. Referenced by FindHeaderEntryLength(), gdcmFile::gdcm_read_RLE_file(), GetHeaderEntryValue(), gdcmFile::ParsePixelData(), ReadInt16(), gdcmFile::ReadPixelData(), and UnswapShort(). { if ( (sw==4321) || (sw==2143) ) a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff)); return (a); }

void gdcmParser::SwitchSwapToBigEndian (  void   )  [private]

Definition at line 2183 of file gdcmParser.cxx. References dbg, sw, and gdcmDebug::Verbose(). Referenced by FindHeaderEntryLength(). { dbg.Verbose(1, "gdcmParser::SwitchSwapToBigEndian", "Switching to BigEndian mode."); if ( sw == 0 ) { sw = 4321; return; } if ( sw == 4321 ) { sw = 0; return; } if ( sw == 3412 ) { sw = 2143; return; } if ( sw == 2143 ) sw = 3412; }

guint32 gdcmParser::UnswapLong (  guint32  a  )

Unswaps back the bytes of 4-byte long integer accordingly to processor order. Returns: The properly unswaped 32 bits integer. Definition at line 1185 of file gdcmParser.cxx. References SwapLong(). { return (SwapLong(a)); }

guint16 gdcmParser::UnswapShort (  guint16  a  )

Unswaps the bytes so they agree with the processor order. Returns: The properly unswaped 16 bits integer. Definition at line 1205 of file gdcmParser.cxx. References SwapShort(). { return (SwapShort(a)); }

void gdcmParser::UpdateGroupLength (  bool  SkipSequence = false, FileType  type = ImplicitVR )  [protected]

Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader. Warning: : to be re-written using the chained list instead of the H table. : DO NOT use (doesn't work any longer because of the multimap) Todo: : to be re-written using the chained list instead of the H table Parameters: SkipSequence  TRUE if we don't want to write Sequences (ACR-NEMA Files) type  Type of the File (ExplicitVR,ImplicitVR, ACR, ...) Definition at line 892 of file gdcmParser.cxx. References AddHeaderEntry(), ExplicitVR, gdcmHeaderEntry::GetElement(), gdcmHeaderEntry::GetGroup(), GetHeaderEntryByNumber(), gdcmHeaderEntry::GetLength(), gdcmHeaderEntry::GetVR(), GroupHT, GroupKey, gdcmHeaderEntry::SetLength(), gdcmHeaderEntry::SetValue(), tagHT, and TagKey. { guint16 gr, el; std::string vr; gdcmHeaderEntry *elem; char trash[10]; std::string str_trash; GroupKey key; GroupHT groupHt; // to hold the length of each group TagKey tk; // remember : // typedef std::map<GroupKey, int> GroupHT; gdcmHeaderEntry *elemZ; // for each Tag in the DCM Header for (TagHeaderEntryHT::iterator tag2 = tagHT.begin(); tag2 != tagHT.end(); ++tag2) { elem = tag2->second; gr = elem->GetGroup(); el = elem->GetElement(); vr = elem->GetVR(); sprintf(trash, "%04x", gr); key = trash; // generate 'group tag' // if the caller decided not to take SEQUENCEs into account // e.g : he wants to write an ACR-NEMA File if (SkipSequence && vr == "SQ") continue; // Still unsolved problem : // we cannot find the 'Sequence Delimitation Item' // since it's at the end of the Hash Table // (fffe,e0dd) // pas SEQUENCE en ACR-NEMA // WARNING : // --> la descente a l'interieur' des SQ // devrait etre faite avec une liste chainee, pas avec une HTable... if ( groupHt.count(key) == 0) // we just read the first elem of a given group { if (el == 0x0000) // the first elem is 0x0000 { groupHt[key] = 0; // initialize group length } else { groupHt[key] = 2 + 2 + 4 + elem->GetLength(); // non 0x0000 first group elem } } else // any elem but the first { if (type == ExplicitVR) { if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) { groupHt[key] += 4; // explicit VR AND OB, OW, SQ : 4 more bytes } } groupHt[key] += 2 + 2 + 4 + elem->GetLength(); } } unsigned short int gr_bid; for (GroupHT::iterator g = groupHt.begin(); // for each group we found g != groupHt.end(); ++g) { // FIXME: g++ -Wall -Wstrict-prototypes reports on following line: // warning: unsigned int format, different type arg sscanf(g->first.c_str(),"%x",&gr_bid); tk = g->first + "|0000"; // generate the element full tag if ( tagHT.count(tk) == 0) // if element 0x0000 not found { gdcmDictEntry * tagZ = new gdcmDictEntry(gr_bid, 0x0000, "UL"); elemZ = new gdcmHeaderEntry(tagZ); elemZ->SetLength(4); AddHeaderEntry(elemZ); // create it } else { elemZ=GetHeaderEntryByNumber(gr_bid, 0x0000); } sprintf(trash ,"%d",g->second); str_trash=trash; elemZ->SetValue(str_trash); } }

void gdcmParser::UpdateShaEntries (  void   )  [protected, virtual]

Update the entries with the shadow dictionary. Only non even entries are analyzed. Reimplemented in gdcmHeader. Definition at line 782 of file gdcmParser.cxx. References CheckHeaderEntryVR(), gdcmDict::GetDictEntryByNumber(), GetHeaderEntryUnvalue(), GetHeaderEntryValue(), gdcmDictEntry::GetVR(), listEntries, NewVirtualDictEntry(), and RefShaDict. Referenced by gdcmHeader::UpdateShaEntries(). { gdcmDictEntry *entry; std::string vr; for(ListTag::iterator it=listEntries.begin(); it!=listEntries.end(); ++it) { // Odd group => from public dictionary if((*it)->GetGroup()%2==0) continue; // Peer group => search the corresponding dict entry if(RefShaDict) entry=RefShaDict->GetDictEntryByNumber((*it)->GetGroup(),(*it)->GetElement()); else entry=NULL; if((*it)->IsImplicitVR()) vr="Implicit"; else vr=(*it)->GetVR(); (*it)->SetValue(GetHeaderEntryUnvalue(*it)); if(entry){ // Set the new entry and the new value (*it)->SetDictEntry(entry); CheckHeaderEntryVR(*it,vr); (*it)->SetValue(GetHeaderEntryValue(*it)); } else { // Remove precedent value transformation (*it)->SetDictEntry(NewVirtualDictEntry((*it)->GetGroup(),(*it)->GetElement(),vr)); } } }

bool gdcmParser::Write (  FILE *  fp, FileType  type )  [virtual]

Parameters: fp  file pointer on an already open file type  type of the File to be written (ACR-NEMA, ExplicitVR, ImplicitVR) Returns: always "True" ?! Definition at line 381 of file gdcmParser.cxx. References ExplicitVR, ReplaceOrCreateByNumber(), SetEntryLengthByNumber(), UI1_2_840_10008_1_2, UI1_2_840_10008_1_2_1, and WriteEntries(). Referenced by gdcmFile::WriteBase(). { // ============== // TODO The stuff was rewritten using the chained list instead // of the H table // so we could remove the GroupHT from the gdcmParser // To be checked // ============= // TODO : move the following lines (and a lot of others, to be written) // to a future function CheckAndCorrectHeader // Question : // Comment pourrait-on savoir si le DcmHeader vient d'un fichier DicomV3 ou non // (FileType est un champ de gdcmParser ...) // WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA // no way // a moins de se livrer a un tres complique ajout des champs manquants. // faire un CheckAndCorrectHeader (?) if (type == ImplicitVR) { std::string implicitVRTransfertSyntax = UI1_2_840_10008_1_2; ReplaceOrCreateByNumber(implicitVRTransfertSyntax,0x0002, 0x0010); //FIXME Refer to standards on page 21, chapter 6.2 "Value representation": // values with a VR of UI shall be padded with a single trailing null // Dans le cas suivant on doit pader manuellement avec un 0 SetEntryLengthByNumber(18, 0x0002, 0x0010); } if (type == ExplicitVR) { std::string explicitVRTransfertSyntax = UI1_2_840_10008_1_2_1; ReplaceOrCreateByNumber(explicitVRTransfertSyntax,0x0002, 0x0010); //FIXME Refer to standards on page 21, chapter 6.2 "Value representation": // values with a VR of UI shall be padded with a single trailing null // Dans le cas suivant on doit pader manuellement avec un 0 SetEntryLengthByNumber(20, 0x0002, 0x0010); } /* TODO : rewrite later if ( (type == ImplicitVR) || (type == ExplicitVR) ) UpdateGroupLength(false,type); if ( type == ACR) UpdateGroupLength(true,ACR); */ WriteEntries(fp,type); return(true); }

void gdcmParser::WriteEntries (  FILE *  _fp, FileType  type )  [protected]

writes on disc according to the requested format (ACR-NEMA, ExplicitVR, ImplicitVR) the image Warning: does NOT add the missing elements in the header : it's up to the user doing it ! (function CheckHeaderCoherence to be written) DON'T try, right now, to write a DICOM image from an ACR Header (meta elements will be missing!) Parameters: type  type of the File to be written (ACR-NEMA, ExplicitVR, ImplicitVR) _fp  already open file pointer Definition at line 1003 of file gdcmParser.cxx. References ACR, countGrPixel, DICOMDIR, ExplicitVR, GrPixel, listEntries, NumPixel, and Tokenize(). Referenced by Write(), and gdcmDicomDir::Write(). { guint16 gr, el; guint32 lgr; std::string value; const char * val; std::string vr; guint32 val_uint32; guint16 val_uint16; guint16 valZero =0; void *voidArea; std::vector<std::string> tokens; // TODO : function CheckHeaderCoherence to be written // uses now listEntries to iterate, not TagHt! // // pb : gdcmParser.Add does NOT update listEntries // TODO : find a trick (in STL?) to do it, at low cost ! void *ptr; // TODO (?) tester les echecs en ecriture (apres chaque fwrite) int compte =0; for (ListTag::iterator tag2=listEntries.begin(); tag2 != listEntries.end(); ++tag2) { // === Deal with the length // -------------------- if(((*tag2)->GetLength())%2==1) { (*tag2)->SetValue((*tag2)->GetValue()+"\0"); (*tag2)->SetLength((*tag2)->GetLength()+1); } gr = (*tag2)->GetGroup(); el = (*tag2)->GetElement(); lgr = (*tag2)->GetReadLength(); val = (*tag2)->GetValue().c_str(); vr = (*tag2)->GetVR(); voidArea = (*tag2)->GetVoidArea(); if ( type == ACR ) { if (gr < 0x0008) continue; // ignore pure DICOM V3 groups if (gr %2) continue; // ignore shadow groups if (vr == "SQ" ) continue; // ignore Sequences // TODO : find a trick to *skip* the SeQuences ! // Not only ignore the SQ element if (gr == 0xfffe ) continue; // ignore delimiters } fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element // if ( (type == ExplicitVR) && (gr <= 0x0002) ) // ?!? < 2 if ( (type == ExplicitVR) || (type == DICOMDIR) ) { // EXPLICIT VR guint16 z=0, shortLgr; if (vr == "unkn") { // Unknown was 'written' shortLgr=lgr; fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp); fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp); } else { if (gr != 0xfffe) { // NO value for 'delimiters' if (vr == "unkn") // Unknown was 'written' fwrite(&z,(size_t)2 ,(size_t)1 ,_fp); else fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp); } if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || gr == 0xfffe) { if (gr != 0xfffe) fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp); fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp); } else { shortLgr=lgr; fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp); } } } else // IMPLICIT VR { fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp); } // === Deal with the value // ------------------- if (vr == "SQ") continue; // no "value" to write for the SEQuences if (gr == 0xfffe)continue; if (voidArea != NULL) { // there is a 'non string' LUT, overlay, etc fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value continue; } if (vr == "US" || vr == "SS") { tokens.erase(tokens.begin(),tokens.end()); // clean any previous value Tokenize ((*tag2)->GetValue(), tokens, "\\"); for (unsigned int i=0; i<tokens.size();i++) { val_uint16 = atoi(tokens[i].c_str()); ptr = &val_uint16; fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp); } tokens.clear(); continue; } if (vr == "UL" || vr == "SL") { tokens.erase(tokens.begin(),tokens.end()); // clean any previous value Tokenize ((*tag2)->GetValue(), tokens, "\\"); for (unsigned int i=0; i<tokens.size();i++) { val_uint32 = atoi(tokens[i].c_str()); ptr = &val_uint32; fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp); } tokens.clear(); continue; } // Pixels are never loaded in the element ! // we stop writting when Pixel are processed // FIX : we loose trailing elements (RAB, right now) if ((gr == GrPixel) && (el == NumPixel) ) { compte++; if (compte == countGrPixel) // we passed *all* the GrPixel,NumPixel break; } fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value } }

---

Member Data Documentation

int gdcmParser::countGrPixel [protected]

Definition at line 160 of file gdcmParser.h. Referenced by WriteEntries().

int gdcmParser::enableSequences [protected]

Definition at line 152 of file gdcmParser.h. Referenced by FixHeaderEntryFoundLength(), and gdcmParser().

std::string gdcmParser::filename [private]

Definition at line 215 of file gdcmParser.h.

FileType gdcmParser::filetype [protected]

Definition at line 142 of file gdcmParser.h. Referenced by CheckSwap(), FindHeaderEntryLength(), FindHeaderEntryVR(), GetFileType(), IsReadable(), and LoadHeaderEntries().

FILE* gdcmParser::fp [protected]

Definition at line 141 of file gdcmParser.h. Referenced by CheckSwap(), CloseFile(), FindHeaderEntryLength(), FindHeaderEntryLengthOB(), FindHeaderEntryVR(), IsHeaderEntryAnInteger(), LoadEntryVoidArea(), LoadHeaderEntries(), LoadHeaderEntry(), LoadHeaderEntrySafe(), ReadInt16(), ReadInt32(), ReadNextHeaderEntry(), and SkipBytes().

guint16 gdcmParser::GrPixel [protected]

Definition at line 156 of file gdcmParser.h. Referenced by FindHeaderEntryLength(), and WriteEntries().

const unsigned int gdcmParser::HEADER_LENGTH_TO_READ = 256 [static, protected]

Definition at line 69 of file gdcmParser.cxx. Referenced by CheckSwap().

int gdcmParser::ignoreShadow [private]

Definition at line 226 of file gdcmParser.h. Referenced by gdcmParser().

ListTag gdcmParser::listEntries [protected]

Definition at line 150 of file gdcmParser.h. Referenced by AddHeaderEntry(), IsReadable(), PrintEntry(), UpdateShaEntries(), and WriteEntries().

const unsigned int gdcmParser::MAX_SIZE_LOAD_ELEMENT_VALUE = 4096 [static, protected]

Definition at line 72 of file gdcmParser.cxx. Referenced by gdcmParser().

const unsigned int gdcmParser::MAX_SIZE_PRINT_ELEMENT_VALUE = 64 [static, protected]

Definition at line 76 of file gdcmParser.cxx.

guint32 gdcmParser::MaxSizeLoadEntry [private]

Definition at line 236 of file gdcmParser.h. Referenced by LoadHeaderEntry(), and SetMaxSizeLoadEntry().

guint32 gdcmParser::MaxSizePrintEntry [private]

Definition at line 240 of file gdcmParser.h. Referenced by SetMaxSizePrintEntry().

guint16 gdcmParser::NumPixel [protected]

Definition at line 157 of file gdcmParser.h. Referenced by FindHeaderEntryLength(), and WriteEntries().

int gdcmParser::printLevel [protected]

Definition at line 153 of file gdcmParser.h.

gdcmDict* gdcmParser::RefPubDict [private]

Definition at line 218 of file gdcmParser.h. Referenced by GetDictEntryByName(), GetDictEntryByNumber(), GetEntryByName(), GetEntryVRByName(), GetHeaderEntryByName(), GetPubDict(), Initialise(), PrintPubDict(), SetEntryByName(), and ~gdcmParser().

gdcmDict* gdcmParser::RefShaDict [private]

Definition at line 220 of file gdcmParser.h. Referenced by GetDictEntryByName(), GetDictEntryByNumber(), GetShaDict(), Initialise(), PrintShaDict(), SetShaDict(), UpdateShaEntries(), and ~gdcmParser().

int gdcmParser::sw [private]

Definition at line 230 of file gdcmParser.h. Referenced by CheckSwap(), SwapLong(), SwapShort(), and SwitchSwapToBigEndian().

TagHeaderEntryHT gdcmParser::tagHT [protected]

Definition at line 149 of file gdcmParser.h. Referenced by AddHeaderEntry(), CheckIfEntryExistByNumber(), GenerateFreeTagKeyInGroup(), GetEntryByNumber(), GetHeaderEntryByNumber(), GetHeaderEntrySameNumber(), SetEntryByNumber(), SetEntryLengthByNumber(), SetEntryVoidAreaByNumber(), and UpdateGroupLength().

int gdcmParser::wasUpdated [private]

Definition at line 223 of file gdcmParser.h. Referenced by AddHeaderEntry(), and gdcmParser().

---

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

• gdcmParser.h
• gdcmParser.cxx

---