gdcm::Document Class Reference

Derived by both gdcm::File and gdcm::DicomDir. More...

#include <gdcmDocument.h>

Inheritance diagram for gdcm::Document:

[legend]Collaboration diagram for gdcm::Document:

[legend]List of all members.

Public Types
typedef std::list< DicomElement >	ListElements
Public Member Functions
virtual bool	Load (std::string const &filename)
	Loader. (DEPRECATED : not to break the API).
virtual bool	Load ()
	Loader. use SetLoadMode(), SetFileName() before !
Dict *	GetPubDict ()
	Get the public dictionary used.
Dict *	GetShaDict ()
	Get the shadow dictionary used.
bool	SetShaDict (Dict *dict)
	Set the shadow dictionary used.
bool	SetShaDict (DictKey const &dictName)
	Set the shadow dictionary used.
bool	IsParsable ()
	This predicate tells us whether or not the current Document was properly parsed and contains at least *one* Dicom Element (and nothing more, sorry).
virtual bool	IsReadable ()
	This predicate tells us whether or not the current Document was properly parsed and contains at least *one* Dicom Element (and nothing more, sorry).
bool	IsDicomV3 ()
	Predicate for dicom version 3 file.
bool	IsPapyrus ()
	Predicate for Papyrus file Dedicated to whomsoever it may concern.
FileType	GetFileType ()
	returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
std::string	GetTransferSyntax ()
	Accessor to the Transfer Syntax (when present) of the current document (it internally handles reading the value from disk when only parsing occured).
std::string	GetTransferSyntaxName ()
	Accesses the info from 0002,0010 : Transfer Syntax and TS.
int	GetSwapCode ()
	'Swap code' accessor (see SwapCode )
const std::string &	GetFileName () const
	Accessor to Filename.
virtual void	SetFileName (std::string const &fileName)
	Accessor to Filename.
std::ifstream *	OpenFile ()
	Tries to open the file Document::Filename and checks the preamble when existing.
bool	CloseFile ()
	closes the file
void	WriteContent (std::ofstream *fp, FileType type)
	Writes in a file all the Entries (Dicom Elements).
virtual void	LoadEntryBinArea (uint16_t group, uint16_t elem)
	Loads (from disk) the element content when a string is not suitable.
virtual void	LoadEntryBinArea (DataEntry *entry)
	Loads (from disk) the element content when a string is not suitable.
void	LoadDocEntrySafe (DocEntry *entry)
	Loads the element while preserving the current underlying file position indicator as opposed to LoadDocEntry that modifies it.
void	AddForceLoadElement (uint16_t group, uint16_t elem)
	Adds a new element we want to load anyway.
bool	operator< (Document &document)
	Compares two documents, according to DicomDir rules.
void	SetLoadMode (int mode)
	Sets the LoadMode as a boolean string. LD_NOSEQ, LD_NOSHADOW, LD_NOSHADOWSEQ ... (nothing more, right now) WARNING : before using NO_SHADOW, be sure *all* your files contain accurate values in the 0x0000 element (if any) of *each* Shadow Group. The parser will fail if the size is wrong !
virtual void	Print (std::ostream &os=std::cout, std::string const &indent="")
	Prints the Header Entries (Dicom Elements) from the H Table.
bool	AddEntry (DocEntry *Entry)
	add a new Dicom Element pointer to the H Table
bool	RemoveEntry (DocEntry *EntryToRemove)
	Clear the hash table from given entry AND delete the entry.
void	ClearEntry ()
	delete all entries in the ElementSet
DocEntry *	GetFirstEntry ()
	Get the first entry while visiting *the* 'zero level' DocEntrySet (DocEntries out of any Sequence).
DocEntry *	GetNextEntry ()
	Get the next entry while visiting *the* 'zero level' DocEntrySet (DocEntries out of any Sequence).
DocEntry *	GetDocEntry (uint16_t group, uint16_t elem)
	retrieves a Dicom Element using (group, element)
bool	IsEmpty ()
	Tells us if the ElementSet contains no entry.
virtual std::string	GetEntryString (uint16_t group, uint16_t elem)
	Get the "std::string representable" value of the Dicom entry.
virtual void *	GetEntryBinArea (uint16_t group, uint16_t elem)
	Gets (from Header) a 'non string' element value.
virtual int	GetEntryLength (uint16_t group, uint16_t elem)
	Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the value length of a given tag..
virtual std::string	GetEntryForcedAsciiValue (uint16_t group, uint16_t elem)
	Return the value of the DataEntry if it's "std::string representable".
DataEntry *	GetDataEntry (uint16_t group, uint16_t elem)
	Same as Document::GetDocEntry except it only returns a result when the corresponding entry is of type DataEntry.
SeqEntry *	GetSeqEntry (uint16_t group, uint16_t elem)
	Same as Document::GetDocEntry except it only returns a result when the corresponding entry is of type SeqEntry.
bool	SetEntryString (std::string const &content, uint16_t group, uint16_t elem)
	Accesses an existing DocEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value.
bool	SetEntryString (std::string const &content, DataEntry *entry)
	Accesses an existing DocEntry (i.e. a Dicom Element) and modifies it's content with the given value.
bool	SetEntryBinArea (uint8_t *content, int lgth, uint16_t group, uint16_t elem)
	Accesses an existing DocEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value.
bool	SetEntryBinArea (uint8_t *content, int lgth, DataEntry *entry)
	Accesses an existing DataEntry (i.e. a Dicom Element) and modifies it's content with the given value.
DataEntry *	InsertEntryString (std::string const &value, uint16_t group, uint16_t elem, VRKey const &vr=GDCM_VRUNKNOWN)
	Modifies the value of a given Doc Entry (Dicom Element) when it exists. Create it with the given value when unexistant.
DataEntry *	InsertEntryBinArea (uint8_t *binArea, int lgth, uint16_t group, uint16_t elem, VRKey const &vr=GDCM_VRUNKNOWN)
	Modifies the value of a given Header Entry (Dicom Element) when it exists. Create it with the given value when unexistant. A copy of the binArea is made to be kept in the Document.
SeqEntry *	InsertSeqEntry (uint16_t group, uint16_t elem)
	Modifies the value of a given Doc Entry (Dicom Element) when it exists. Creates it when unexistant.
virtual bool	CheckIfEntryExist (uint16_t group, uint16_t elem)
	Checks if a given Dicom Element exists within the H table.
DataEntry *	NewDataEntry (uint16_t group, uint16_t elem, VRKey const &vr=GDCM_VRUNKNOWN)
	Build a new Val Entry from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent.
SeqEntry *	NewSeqEntry (uint16_t group, uint16_t elem)
	Build a new Seq Entry from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent.
void	Delete ()
	Delete the object.
void	Register ()
	Register the object.
void	Unregister ()
	Unregister the object.
const unsigned long &	GetRefCount () const
	Get the reference counting.
void	SetPrintLevel (int level)
	Sets the print level for the Dicom Header Elements.
int	GetPrintLevel ()
	Gets the print level for the Dicom Entries.
Protected Member Functions
	Document ()
	This default constructor neither loads nor parses the file. You should then invoke Document::Load.
virtual	~Document ()
	Canonical destructor.
uint16_t	ReadInt16 () throw ( FormatError )
	Reads a supposed to be 16 Bits integer (swaps it depending on processor endianness).
uint32_t	ReadInt32 () throw ( FormatError )
	Reads a supposed to be 32 Bits integer (swaps it depending on processor endianness).
void	SkipBytes (uint32_t)
	skips bytes inside the source file
int	ComputeGroup0002Length ()
	Re-computes the length of the Dicom group 0002.
bool	MayIWrite (uint16_t)
	Some group are illegal withing some Dicom Documents Only the Document knows it.
DictEntry *	GetDictEntry (uint16_t group, uint16_t elem)
	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(s), if any.
DictEntry *	GetDictEntry (uint16_t group, uint16_t elem, VRKey const &vr)
	Searches [both] the public [and the shadow dictionary (when they exist)] for the presence of the DictEntry with given group and element, and create a new virtual DictEntry if necessary.
Protected Attributes
std::string	Filename
	Refering underlying filename.
int	SwapCode
	Swap code gives an information on the byte order of a supposed to be an int32, as it's read on disc (depending on the image Transfer Syntax *and* on the processor endianess) as opposed as it should in memory to be dealt as an int32. For instance : a 'Little Endian' image, read with a little endian processor will have a SwapCode= 1234 (the order is OK; nothing to do) a 'Little Endian' image, read with a big endian procesor will have a SwapCode= 4321 (the order is wrong; int32 an int16 must be swapped) note : values 2143, 4321, 3412 remain for the ACR-NEMA time, and the well known 'Bad Big Endian' and 'Bad Little Endian' codes.
bool	Group0002Parsed
	whether we already parsed group 0002 (Meta Elements)
bool	HasDCMPreamble
	whether file has a DCM Preamble
std::ifstream *	Fp
	File Pointer, opened during Document parsing.
FileType	Filetype
	ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown.
ListElements	UserAnonymizeList
	User supplied list of elements to Anonymize.
ListElements	UserForceLoadList
	User supplied list of elements to force Load.
int	LoadMode
	Bit string integer (each one considered as a boolean) Bit 0 : Skip Sequences, if possible Bit 1 : Skip Shadow Groups if possible Probabely, some more to add.
bool	IsDocumentAlreadyLoaded
	Whether the gdcm::Document is already parsed/loaded : False from the creation of the gdcm::Document untill gdcm::Document:Load().
bool	IsDocumentModified
	Whether the gdcm::Document was modified since the last Load().
DocEntry *	PreviousDocEntry
	To be able to backtrack (Private Sequence, Implicit VR related pb).
int	PrintLevel
	Amount of printed details for each Dicom Entries : 0 : stands for the least detail level.
Static Protected Attributes
static const unsigned int	HEADER_LENGTH_TO_READ
	After opening the file, we read HEADER_LENGTH_TO_READ bytes.
static const unsigned int	MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff
	Elements whose value is longer than MAX_SIZE_LOAD_ELEMENT_VALUE are NOT loaded.
Private Member Functions
	gdcmTypeMacro (Document)
void	Initialize ()
	Loads all the needed Dictionaries.
bool	DoTheLoadingDocumentJob ()
	Performs the Loading Job (internal use only).
uint16_t	SwapShort (uint16_t)
	Swaps the bytes so they agree with the processor order.
uint32_t	SwapLong (uint32_t)
	Swaps back the bytes of 4-byte long integer accordingly to processor order.
double	SwapDouble (double)
	Swaps back the bytes of 8-byte long 'double' accordingly to processor order.
uint16_t	UnswapShort (uint16_t a)
	Unswaps back the bytes of 2-bytes long integer so they agree with the processor order.
uint32_t	UnswapLong (uint32_t a)
	Unswaps back the bytes of 4-byte long integer so they agree with the processor order.
void	ParseDES (DocEntrySet *set, long offset, long l_max, bool delim_mode)
	Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries).
void	ParseSQ (SeqEntry *seq, long offset, long l_max, bool delim_mode)
	Parses a Sequence ( SeqEntry after SeqEntry).
void	LoadDocEntry (DocEntry *e, bool forceLoad=false)
	Loads (or not) the element content depending if its length exceeds or not the value specified with Document::SetMaxSizeLoadEntry().
void	FindDocEntryLength (DocEntry *e) throw ( FormatError )
	Find the value Length of the passed Doc Entry.
uint32_t	FindDocEntryLengthOBOrOW () throw ( FormatUnexpected )
	Find the Length till the next sequence delimiter.
VRKey	FindDocEntryVR ()
	Find the Value Representation of the current Dicom Element.
bool	CheckDocEntryVR (const VRKey &k)
	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.
void	SkipDocEntry (DocEntry *entry)
	Skip a given Header Entry.
void	SkipToNextDocEntry (DocEntry *entry)
	Skips to the beginning of the next Header Entry.
void	FixDocEntryFoundLength (DocEntry *entry, uint32_t l)
	When the length of an element value is obviously wrong (because the parser went Jabberwocky) one can hope improving things by applying some heuristics.
bool	IsDocEntryAnInteger (DocEntry *entry)
	Apply some heuristics to predict whether the considered element value contains/represents an integer or not.
bool	CheckSwap ()
	Discover what the swap code is (among little endian, big endian, bad little endian, bad big endian). sw is set.
void	SwitchByteSwapCode ()
	Change the Byte Swap code.
void	SetMaxSizeLoadEntry (long)
	during parsing, Header Elements too long are not loaded in memory
DocEntry *	ReadNextDocEntry ()
	Read the next tag WITHOUT loading it's value (read the 'Group Number', the 'Element Number', gets the Dict Entry gets the VR, gets the length, gets the offset value).
void	HandleBrokenEndian (uint16_t &group, uint16_t &elem)
	Handle broken private tag from Philips NTSCAN where the endianess is being switched to BigEndian for no apparent reason.
void	HandleOutOfGroup0002 (uint16_t &group, uint16_t &elem)
	Group 0002 is always coded Little Endian whatever Transfer Syntax is.
DocEntry *	Backtrack (DocEntry *docEntry)
	When a private Sequence + Implicit VR is encountered we cannot guess it's a Sequence till we find the first Item Starter. We then backtrack to do the job.
Private Attributes
Dict *	RefPubDict
	Public dictionary used to parse this header.
Dict *	RefShaDict
	Optional "shadow dictionary" (private elements) used to parse this header.
uint32_t	MaxSizeLoadEntry
	Size threshold above which an element value will NOT be loaded in memory (to avoid loading the image/volume itself). By default, this upper bound is fixed to 1024 bytes (which might look reasonable when one considers the definition of the various VR contents).
uint16_t	CurrentGroup
	to allow any inner method to know current tag Group number
uint16_t	CurrentElem
	to allow any inner method to know current tag Element number

---

Detailed Description

Derived by both gdcm::File and gdcm::DicomDir.

Definition at line 40 of file gdcmDocument.h.

---

Member Typedef Documentation

typedef std::list<DicomElement> gdcm::Document::ListElements

Definition at line 45 of file gdcmDocument.h.

---

Constructor & Destructor Documentation

gdcm::Document::Document (   )  [protected]

This default constructor neither loads nor parses the file. You should then invoke Document::Load. Definition at line 52 of file gdcmDocument.cxx. References gdcm::ExplicitVR, Filetype, Fp, Group0002Parsed, Initialize(), IsDocumentAlreadyLoaded, IsDocumentModified, gdcm::LD_ALL, LoadMode, MAX_SIZE_LOAD_ELEMENT_VALUE, SetFileName(), SetMaxSizeLoadEntry(), and SwapCode. :ElementSet() { Fp = 0; SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); Initialize(); SwapCode = 1234; Filetype = ExplicitVR; // Load will set it to true if sucessfull Group0002Parsed = false; IsDocumentAlreadyLoaded = false; IsDocumentModified = true; LoadMode = LD_ALL; // default : load everything, later SetFileName(""); }

gdcm::Document::~Document (   )  [protected, virtual]

Canonical destructor. Definition at line 72 of file gdcmDocument.cxx. References CloseFile(). { CloseFile(); }

---

Member Function Documentation

bool gdcm::ElementSet::AddEntry (  DocEntry *  newEntry  )  [virtual, inherited]

add a new Dicom Element pointer to the H Table Parameters: newEntry  entry to add Implements gdcm::DocEntrySet. Definition at line 78 of file gdcmElementSet.cxx. References gdcmWarningMacro, gdcm::DocEntry::GetKey(), gdcm::RefCounter::Register(), and gdcm::ElementSet::TagHT. Referenced by gdcm::File::DoTheLoadingJob(), gdcm::DocEntryArchive::Push(), and gdcm::DocEntryArchive::Restore(). { const TagKey &key = newEntry->GetKey(); if ( TagHT.count(key) == 1 ) { gdcmWarningMacro( "Key already present: " << key ); return false; } else { TagHT.insert(TagDocEntryHT::value_type(newEntry->GetKey(), newEntry)); newEntry->Register(); return true; } }

void gdcm::Document::AddForceLoadElement (  uint16_t  group, uint16_t  elem )

Adds a new element we want to load anyway. Parameters: group  Group number of the target tag. elem  Element number of the target tag. Definition at line 290 of file gdcmDocument.cxx. References gdcm::DicomElement::Elem, gdcm::DicomElement::Group, and UserForceLoadList. { DicomElement el; el.Group = group; el.Elem = elem; UserForceLoadList.push_back(el); }

DocEntry * gdcm::Document::Backtrack (  DocEntry *  docEntry  )  [private]

When a private Sequence + Implicit VR is encountered we cannot guess it's a Sequence till we find the first Item Starter. We then backtrack to do the job. Parameters: docEntry  Item Starter that warned us Definition at line 1296 of file gdcmDocument.cxx. References gdcm::RefCounter::Delete(), Fp, gdcmDebugMacro, gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetOffset(), gdcm::DocEntrySet::NewSeqEntry(), gdcm::DocEntrySet::PreviousDocEntry, gdcm::ElementSet::RemoveEntry(), gdcm::DocEntry::SetLength(), and gdcm::DocEntry::SetOffset(). Referenced by ParseDES(). { // delete the Item Starter, built erroneously out of any Sequence // it's not yet in the HTable/chained list docEntry->Delete(); // Get all info we can from PreviousDocEntry uint16_t group = PreviousDocEntry->GetGroup(); uint16_t elem = PreviousDocEntry->GetElement(); uint32_t lgt = PreviousDocEntry->GetLength(); long offset = PreviousDocEntry->GetOffset(); gdcmDebugMacro( "Backtrack :" << std::hex << group << "|" << elem << " at offset " << offset ); RemoveEntry( PreviousDocEntry ); // forge the Seq Entry DocEntry *newEntry = NewSeqEntry(group, elem); newEntry->SetLength(lgt); newEntry->SetOffset(offset); // Move back to the beginning of the Sequence Fp->seekg( 0, std::ios::beg); Fp->seekg(offset, std::ios::cur); return newEntry; }

bool gdcm::Document::CheckDocEntryVR (  const 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: vr  Dicom Value Representation Returns: false if the VR is incorrect or if the VR isn't referenced otherwise, it returns true Definition at line 1576 of file gdcmDocument.cxx. References gdcm::Global::GetVR(), and gdcm::VR::IsValidVR(). Referenced by FindDocEntryVR(). { return Global::GetVR()->IsValidVR(vr); }

bool gdcm::DocEntrySet::CheckIfEntryExist (  uint16_t  group, uint16_t  elem )  [virtual, inherited]

Checks if a given Dicom Element exists within the H table. Parameters: group  Group number of the searched Dicom Element elem  Element number of the searched Dicom Element Returns: true is found Definition at line 430 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::GetDocEntry(). { return GetDocEntry(group,elem)!=NULL; }

bool gdcm::Document::CheckSwap (   )  [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 1737 of file gdcmDocument.cxx. References gdcm::ACR, gdcm::ExplicitVR, Filetype, Fp, gdcmDebugMacro, gdcmWarningMacro, gdcm::ImplicitVR, gdcm::Util::IsCurrentProcessorBigEndian(), SwapCode, and gdcm::Unknown. Referenced by DoTheLoadingDocumentJob(). { uint32_t s32; uint16_t s16; char deb[256]; // First, compare HostByteOrder and NetworkByteOrder in order to // determine if we shall need to swap bytes (i.e. the Endian type). bool net2host = Util::IsCurrentProcessorBigEndian(); // The easiest case is the one of a 'true' DICOM header, we just have // to look for the string "DICM" inside the file preamble. Fp->read(deb, 256); char *entCur = deb + 128; if ( memcmp(entCur, "DICM", (size_t)4) == 0 ) { gdcmDebugMacro( "Looks like DICOM Version3 (preamble + DCM)" ); // Group 0002 should always be VR, and the first element 0000 // Let's be carefull (so many wrong headers ...) // and 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. // 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; // group 0x0002 *is always* Explicit VR Sometimes , // even if elem 0002,0010 (Transfer Syntax) tells us the file is // *Implicit* VR (see former 'gdcmData/icone.dcm') 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 Document::dicom_vr to test all the possibilities // instead of just checking for UL, OB and UI !? group 0000 { Filetype = ExplicitVR; gdcmDebugMacro( "Group 0002 : Explicit Value Representation"); } else { Filetype = ImplicitVR; gdcmWarningMacro( "Group 0002 :Not an explicit Value Representation;" << "Looks like a bugged Header!"); } if ( net2host ) { SwapCode = 4321; gdcmDebugMacro( "HostByteOrder != NetworkByteOrder, SwapCode = 4321"); } else { SwapCode = 1234; gdcmDebugMacro( "HostByteOrder = NetworkByteOrder, SwapCode = 1234"); } // Position the file position indicator at first tag // (i.e. after the file preamble and the "DICM" string). Fp->seekg(0, std::ios::beg); // FIXME : Is it usefull? Fp->seekg ( 132L, std::ios::beg); 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). gdcmWarningMacro( "Not a Kosher DICOM Version3 file (no preamble)"); Fp->seekg(0, std::ios::beg); // Let's check 'No Preamble Dicom File' : // Should start with group 0x0002 // and be Explicit Value Representation s16 = *((uint16_t *)(deb)); SwapCode = 0; switch ( s16 ) { case 0x0002 : SwapCode = 1234; entCur = deb + 4; break; case 0x0200 : SwapCode = 4321; entCur = deb + 6; } if ( SwapCode != 0 ) { if ( memcmp(entCur, "UL", (size_t)2) == 0 || memcmp(entCur, "OB", (size_t)2) == 0 || memcmp(entCur, "UI", (size_t)2) == 0 || memcmp(entCur, "SH", (size_t)2) == 0 || memcmp(entCur, "AE", (size_t)2) == 0 || memcmp(entCur, "OB", (size_t)2) == 0 ) { Filetype = ExplicitVR; gdcmDebugMacro( "Group 0002 : Explicit Value Representation"); return true; } } // ------------------------------- End of 'No Preamble' DicomV3 ------------- // Our next best chance would be to be considering a 'clean' ACR/NEMA file. // By clean we mean that the length of the first group 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 = *((uint32_t *)(entCur)); switch( s32 ) { case 0x00040000 : SwapCode = 3412; Filetype = ACR; return true; case 0x04000000 : SwapCode = 4321; Filetype = ACR; return true; case 0x00000400 : SwapCode = 2143; Filetype = ACR; return true; case 0x00000004 : SwapCode = 1234; 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' // in ( 0x0001 .. 0x0008 ) // to determine ' SwapCode' 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-3, 4, ..., 8-) // the file IS NOT ACR-NEMA nor DICOM V3 // Find a trick to tell it the caller... s16 = *((uint16_t *)(deb)); switch ( s16 ) { case 0x0001 : case 0x0002 : case 0x0003 : case 0x0004 : case 0x0005 : case 0x0006 : case 0x0007 : case 0x0008 : SwapCode = 1234; Filetype = ACR; return true; case 0x0100 : case 0x0200 : case 0x0300 : case 0x0400 : case 0x0500 : case 0x0600 : case 0x0700 : case 0x0800 : SwapCode = 4321; Filetype = ACR; return true; default : gdcmWarningMacro("ACR/NEMA unfound swap info (Hopeless !)"); Filetype = Unknown; return false; } } }

void gdcm::ElementSet::ClearEntry (   )  [virtual, inherited]

delete all entries in the ElementSet Implements gdcm::DocEntrySet. Definition at line 116 of file gdcmElementSet.cxx. References gdcm::ElementSet::TagHT. Referenced by gdcm::DicomDir::CreateDicomDir(), DoTheLoadingDocumentJob(), gdcm::DicomDir::SetElements(), and gdcm::ElementSet::~ElementSet(). { for(TagDocEntryHT::iterator cc = TagHT.begin();cc != TagHT.end(); ++cc) { if ( cc->second ) { cc->second->Unregister(); } } TagHT.clear(); }

bool gdcm::Document::CloseFile (   )

closes the file Returns: TRUE if the close was successfull Definition at line 658 of file gdcmDocument.cxx. References Fp. Referenced by DoTheLoadingDocumentJob(), gdcm::File::DoTheLoadingJob(), gdcm::FileHelper::GetRaw(), LoadEntryBinArea(), OpenFile(), and ~Document(). { if ( Fp ) { Fp->close(); delete Fp; Fp = 0; } return true; }

int gdcm::Document::ComputeGroup0002Length (   )  [protected]

Re-computes the length of the Dicom group 0002. Definition at line 956 of file gdcmDocument.cxx. References gdcm::DocEntry::GetElement(), gdcm::ElementSet::GetFirstEntry(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), gdcm::ElementSet::GetNextEntry(), and gdcm::DocEntry::GetVR(). Referenced by gdcm::File::Write(). { uint16_t gr; VRKey vr; int groupLength = 0; bool found0002 = false; // for each zero-level Tag in the DCM Header DocEntry *entry = GetFirstEntry(); while( entry ) { gr = entry->GetGroup(); if ( gr == 0x0002 ) { found0002 = true; if ( entry->GetElement() != 0x0000 ) { vr = entry->GetVR(); //if ( (vr == "OB")||(vr == "OW")||(vr == "UT")||(vr == "SQ")) // (no SQ, OW, UT in group 0x0002;) if ( vr == "OB" ) { // explicit VR AND (OB, OW, SQ, UT) : 4 more bytes groupLength += 4; } groupLength += 2 + 2 + 4 + entry->GetLength(); } } else if (found0002 ) break; entry = GetNextEntry(); } return groupLength; }

void gdcm::RefCounter::Delete (   )  [inline, inherited]

Delete the object. Remarks: The object is deleted only if its reference counting is to zero Definition at line 40 of file gdcmRefCounter.h. Referenced by gdcm::SerieHelper::AddFileName(), Backtrack(), gdcm::FileHelper::CheckMandatoryElements(), gdcm::FileHelper::CheckMandatoryEntry(), gdcm::FileHelper::CopyMandatoryEntry(), gdcm::DicomDir::CreateDicomDirChainedList(), gdcm::File::DoTheLoadingJob(), gdcm::Dict::DoTheLoadingJob(), gdcm::DicomDirObject::FillObject(), gdcm::DocEntrySet::InsertEntryBinArea(), gdcm::DocEntrySet::InsertEntryString(), gdcm::DocEntrySet::InsertSeqEntry(), gdcm::DicomDir::NewMeta(), gdcm::DicomDirStudy::NewVisit(), ParseDES(), ParseSQ(), ReadNextDocEntry(), gdcm::DicomDir::SetElement(), gdcm::FileHelper::SetMandatoryEntry(), gdcm::FileHelper::SetWriteFileTypeToExplicitVR(), gdcm::FileHelper::SetWriteFileTypeToImplicitVR(), gdcm::FileHelper::SetWriteFileTypeToJPEG(), gdcm::FileHelper::SetWriteToLibido(), gdcm::FileHelper::SetWriteToNoLibido(), gdcm::FileHelper::SetWriteToRaw(), gdcm::FileHelper::SetWriteToRGB(), gdcm::DicomDir::~DicomDir(), and gdcm::Global::~Global(). { Unregister(); }

bool gdcm::Document::DoTheLoadingDocumentJob (   )  [private]

Performs the Loading Job (internal use only). Returns: false if file cannot be open or no swap info was found, or no tag was found. FIXME --> FIXME : The difference between BinEntry and DataEntry --> no longer exists, but the alteration of Dicom Dictionary remains. --> Old comment restored on purpose. --> New one (replacing both BinEntry and ValEntry by DataEntry) --> had absolutely no meaning. --> The whole comment will be removed when the stuff is cleaned ! --> The tags refered by the three following lines used to be CORRECTLY defined as having an US Value Representation in the public dictionary. BUT the semantics implied by the three following lines state that the corresponding tag contents are in fact the ones of a BinEntry. In order to fix things "Quick and Dirty" the dictionary was altered on PURPOSE but now contains a WRONG value. In order to fix things and restore the dictionary to its correct value, one needs to decide of the semantics by deciding whether the following tags are either : multivaluated US, and hence loaded as ValEntry, but afterwards also used as BinEntry, which requires the proper conversion, OW, and hence loaded as BinEntry, but afterwards also used as ValEntry, which requires the proper conversion. Definition at line 110 of file gdcmDocument.cxx. References gdcm::ACR_LIBIDO, CheckSwap(), gdcm::ElementSet::ClearEntry(), CloseFile(), Filename, Filetype, Fp, gdcmDebugMacro, gdcmErrorMacro, gdcmWarningMacro, gdcm::DocEntrySet::GetDataEntry(), gdcm::ElementSet::GetDocEntry(), gdcm::DocEntrySet::GetEntryString(), gdcm::SeqEntry::GetFirstSQItem(), gdcm::DocEntry::GetLength(), gdcm::DocEntrySet::GetSeqEntry(), Group0002Parsed, IsDocumentAlreadyLoaded, IsDocumentModified, gdcm::ElementSet::IsEmpty(), LoadDocEntry(), LoadEntryBinArea(), OpenFile(), ParseDES(), gdcm::DocEntrySet::SetEntryString(), gdcm::Unknown, and UserForceLoadList. Referenced by Load(). { if ( ! IsDocumentModified ) // Nothing to do ! return true; ClearEntry(); Fp = 0; if ( !OpenFile() ) { // warning already performed in OpenFile() Filetype = Unknown; return false; } Group0002Parsed = false; gdcmDebugMacro( "Starting parsing of file: " << Filename.c_str()); Fp->seekg(0, std::ios::end); long lgt = Fp->tellg(); // total length of the file Fp->seekg(0, std::ios::beg); // CheckSwap returns a boolean // (false if no swap info of any kind was found) if (! CheckSwap() ) { gdcmWarningMacro( "Neither a DICOM V3 nor an ACR-NEMA file: " << Filename.c_str()); CloseFile(); return false; } long beg = Fp->tellg(); // just after DICOM preamble (if any) lgt -= beg; // remaining length to parse // Recursive call. // Loading is done during parsing ParseDES( this, beg, lgt, false); // delim_mode is first defaulted to false if ( IsEmpty() ) { gdcmErrorMacro( "No tag in internal hash table for: " << Filename.c_str()); CloseFile(); return false; } IsDocumentAlreadyLoaded = true; Fp->seekg( 0, std::ios::beg); // Load 'non string' values std::string PhotometricInterpretation = GetEntryString(0x0028,0x0004); if ( PhotometricInterpretation == "PALETTE COLOR " ) { // FIXME // Probabely this line should be outside the 'if' // Try to find an image sample holding a 'gray LUT' LoadEntryBinArea(0x0028,0x1200); // gray LUT // --> OB (byte aray) or OW (short int aray) // The actual VR has to be deduced from other entries. // Our way of loading them may fail in some cases : // We must or not SwapByte depending on other field values. LoadEntryBinArea(0x0028,0x1201); // R LUT LoadEntryBinArea(0x0028,0x1202); // G LUT LoadEntryBinArea(0x0028,0x1203); // B LUT // Segmented Red Palette Color LUT Data LoadEntryBinArea(0x0028,0x1221); // Segmented Green Palette Color LUT Data LoadEntryBinArea(0x0028,0x1222); // Segmented Blue Palette Color LUT Data LoadEntryBinArea(0x0028,0x1223); } //FIXME later : how to use it? SeqEntry *modLutSeq = GetSeqEntry(0x0028,0x3000); if ( modLutSeq !=0 ) { SQItem *sqi= modLutSeq->GetFirstSQItem(); if ( sqi != 0 ) { DataEntry *dataEntry = sqi->GetDataEntry(0x0028,0x3006); if ( dataEntry != 0 ) { if ( dataEntry->GetLength() != 0 ) { // FIXME : CTX dependent means : contexted dependant. // see upper comment. LoadEntryBinArea(dataEntry); //LUT Data (CTX dependent) } } } } // Force Loading some more elements if user asked to. gdcm::DocEntry *d; for (ListElements::iterator it = UserForceLoadList.begin(); it != UserForceLoadList.end(); ++it) { gdcmDebugMacro( "Force Load " << std::hex << (*it).Group << "|" <<(*it).Elem ); d = GetDocEntry( (*it).Group, (*it).Elem); if ( d == NULL) { gdcmWarningMacro( "You asked toForce Load " << std::hex << (*it).Group <<"|"<< (*it).Elem << " that doesn't exist" ); continue; } LoadDocEntry(d, true); } CloseFile(); // ---------------------------- // Specific code to allow gdcm to read ACR-LibIDO formated images // Note: ACR-LibIDO is an extension of the ACR standard that was // used at CREATIS. For the time being (say a couple of years) // we keep this kludge to allow CREATIS users // reading their old images. // // if recognition code tells us we deal with a LibIDO image // we switch lineNumber and columnNumber // std::string RecCode; RecCode = GetEntryString(0x0008, 0x0010); // recognition code (RET) if (RecCode == "ACRNEMA_LIBIDO_1.1" || RecCode == "CANRME_AILIBOD1_1." ) // for brain-damaged softwares // with "little-endian strings" { Filetype = ACR_LIBIDO; std::string rows = GetEntryString(0x0028, 0x0010); std::string columns = GetEntryString(0x0028, 0x0011); SetEntryString(columns, 0x0028, 0x0010); SetEntryString(rows , 0x0028, 0x0011); } // --- End of ACR-LibIDO kludge --- return true; }

void gdcm::Document::FindDocEntryLength (  DocEntry *  entry  )  throw ( FormatError ) [private]

Find the value Length of the passed Doc Entry. Parameters: entry  Header Entry whose length of the value shall be loaded. Definition at line 1393 of file gdcmDocument.cxx. References gdcm::ExplicitVR, and gdcmWarningMacro. Referenced by ReadNextDocEntry(). { const VRKey &vr = entry->GetVR(); uint16_t length16; if ( Filetype == ExplicitVR && !entry->IsImplicitVR() ) { if ( vr == "OB" || vr == "OW" || vr == "SQ" || vr == "UT" || vr == "UN" ) { // The following reserved two bytes (see PS 3.5-2003, section // "7.1.2 Data element structure with explicit vr", p 27) must be // skipped before proceeding on reading the length on 4 bytes. Fp->seekg( 2L, std::ios::cur); uint32_t length32 = ReadInt32(); if ( (vr == "OB" || vr == "OW") && length32 == 0xffffffff ) { uint32_t lengthOB; try { lengthOB = FindDocEntryLengthOBOrOW(); } catch ( FormatUnexpected ) { // Computing the length failed (this happens with broken // files like gdcm-JPEG-LossLess3a.dcm). We still have a // chance to get the pixels by deciding the element goes // until the end of the file. Hence we artificially fix the // the length and proceed. gdcmWarningMacro( " Computing the length failed for " << entry->GetKey() <<" in " <<GetFileName()); long currentPosition = Fp->tellg(); Fp->seekg(0L,std::ios::end); long lengthUntilEOF = (long)(Fp->tellg())-currentPosition; Fp->seekg(currentPosition, std::ios::beg); entry->SetReadLength(lengthUntilEOF); entry->SetLength(lengthUntilEOF); return; } entry->SetReadLength(lengthOB); entry->SetLength(lengthOB); return; } FixDocEntryFoundLength(entry, length32); return; } // Length is encoded on 2 bytes. length16 = ReadInt16(); // 0xffff means that we deal with 'No Length' Sequence // or 'No Length' SQItem if ( length16 == 0xffff) { length16 = 0; } FixDocEntryFoundLength( entry, (uint32_t)length16 ); return; } else { // Either implicit VR or a non DICOM conformal (see note 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. // Well ... group 0002 is always coded in 'Explicit VR Litle Endian' // even if Transfer Syntax is 'Implicit VR ...' // --> Except for 'Implicit VR Big Endian Transfer Syntax GE Private' FixDocEntryFoundLength( entry, ReadInt32() ); return; } }

uint32_t gdcm::Document::FindDocEntryLengthOBOrOW (   )  throw ( FormatUnexpected ) [private]

Find the Length till the next sequence delimiter. Returns: Definition at line 1479 of file gdcmDocument.cxx. References Fp, gdcmWarningMacro, ReadInt16(), ReadInt32(), and SkipBytes(). { // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data. long positionOnEntry = Fp->tellg(); bool foundSequenceDelimiter = false; uint32_t totalLength = 0; while ( !foundSequenceDelimiter ) { uint16_t group; uint16_t elem; try { group = ReadInt16(); elem = ReadInt16(); } catch ( FormatError ) { throw FormatError("Unexpected end of file encountered during ", "Document::FindDocEntryLengthOBOrOW()"); } // We have to decount the group and element we just read totalLength += 4; if ( group != 0xfffe || ( ( elem != 0xe0dd ) && ( elem != 0xe000 ) ) ) { long filePosition = Fp->tellg(); gdcmWarningMacro( "Neither an Item tag nor a Sequence delimiter tag on :" << std::hex << group << " , " << elem << ") -before- position x(" << filePosition << ")" ); Fp->seekg(positionOnEntry, std::ios::beg); throw FormatUnexpected( "Neither an Item tag nor a Sequence delimiter tag."); } if ( elem == 0xe0dd ) { foundSequenceDelimiter = true; } uint32_t itemLength = ReadInt32(); // We add 4 bytes since we just read the ItemLength with ReadInt32 totalLength += itemLength + 4; SkipBytes(itemLength); if ( foundSequenceDelimiter ) { break; } } Fp->seekg( positionOnEntry, std::ios::beg); return totalLength; }

VRKey gdcm::Document::FindDocEntryVR (   )  [private]

Find the Value Representation of the current Dicom Element. Returns: Value Representation of the current Entry Definition at line 1537 of file gdcmDocument.cxx. References CheckDocEntryVR(), CurrentGroup, gdcm::ExplicitVR, Filetype, Fp, gdcm::GDCM_VRUNKNOWN, and gdcmWarningMacro. Referenced by ReadNextDocEntry(). { if ( Filetype != ExplicitVR ) return GDCM_VRUNKNOWN; long positionOnEntry = Fp->tellg(); // Warning: we believe this is explicit VR (Value Representation) because // we used a heuristic that found "UL" in the first tag and/or // 'Transfer Syntax' told us it is. // Alas this doesn't guarantee that all the tags will be in explicit VR. // In some cases 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. VRKey vr; Fp->read(&(vr[0]),(size_t)2); if ( !CheckDocEntryVR(vr) ) { // Don't warn user with useless messages // Often, delimiters (0xfffe), are not explicit VR ... if ( CurrentGroup != 0xfffe ) gdcmWarningMacro( "Unknown VR " << std::hex << "0x(" << (unsigned int)vr[0] << "|" << (unsigned int)vr[1] << ") at offset :" << positionOnEntry ); Fp->seekg(positionOnEntry, std::ios::beg); return GDCM_VRUNKNOWN; } return vr; }

void gdcm::Document::FixDocEntryFoundLength (  DocEntry *  entry, uint32_t  foundLength )  [private]

When the length of an element value is obviously wrong (because the parser went Jabberwocky) one can hope improving things by applying some heuristics. Parameters: entry  entry to check foundLength  first assumption about length Definition at line 1614 of file gdcmDocument.cxx. References gdcmWarningMacro, gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetVR(), gdcm::DocEntry::SetLength(), and gdcm::DocEntry::SetReadLength(). { entry->SetReadLength( foundLength );// will be updated only if a bug is found if ( foundLength == 0xffffffff) { foundLength = 0; } uint16_t gr = entry->GetGroup(); uint16_t elem = entry->GetElement(); if ( foundLength % 2) { gdcmWarningMacro( "Warning : Tag with uneven length " << foundLength << " in x(" << std::hex << gr << "," << elem <<")"); } // Allthough not recent many such GE corrupted images are still present // on Creatis hard disks. Hence this fix shall remain when such images // are no longer in use (we are talking a few years, here)... // Note: XMedCon probably uses such a trick since it is able to read // those pesky GE images ... if ( foundLength == 13) { // Only happens for this length ! if ( gr != 0x0008 || ( elem != 0x0070 && elem != 0x0080 ) ) { foundLength = 10; entry->SetReadLength(10); // a bug is to be fixed !? } } // Occurence of such images is quite low (unless one leaves close to a // 'Leonardo' source. Hence, one might consider commenting out the // following fix on efficiency reasons. else if ( gr == 0x0009 && ( elem == 0x1113 || elem == 0x1114 ) ) { foundLength = 4; entry->SetReadLength(4); // a bug is to be fixed ! } else if ( entry->GetVR() == "SQ" ) { foundLength = 0; // ReadLength is unchanged } // "fffe|xxxx" which is just a marker. Delimiters length should not be // taken into account. else if ( gr == 0xfffe ) { // According to the norm, fffe|0000 shouldn't exist. BUT the Philips // image gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm happens to // causes extra troubles... if ( entry->GetElement() != 0x0000 ) { foundLength = 0; } else { foundLength=12; // to skip the mess that follows this bugged Tag ! } } entry->SetLength(foundLength); }

gdcm::Document::gdcmTypeMacro (  Document   )  [private]

DataEntry * gdcm::DocEntrySet::GetDataEntry (  uint16_t  group, uint16_t  elem )  [inherited]

Same as Document::GetDocEntry except it only returns a result when the corresponding entry is of type DataEntry. Parameters: group  Group number of the searched Dicom Element elem  Element number of the searched Dicom Element Returns: When present, the corresponding DataEntry. Definition at line 136 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::GetDocEntry(). Referenced by gdcm::FileHelper::CheckMandatoryElements(), gdcm::FileHelper::CheckMandatoryEntry(), DoTheLoadingDocumentJob(), gdcm::File::GetBitsAllocated(), gdcm::File::GetBitsStored(), gdcm::DocEntrySet::GetEntryBinArea(), gdcm::File::GetHighBitPosition(), gdcm::File::GetPlanarConfiguration(), gdcm::File::GetRescaleIntercept(), gdcm::File::GetRescaleSlope(), gdcm::File::GetSamplesPerPixel(), gdcm::File::GetXOrigin(), gdcm::File::GetXSize(), gdcm::File::GetXSpacing(), gdcm::File::GetYOrigin(), gdcm::File::GetYSize(), gdcm::File::GetYSpacing(), gdcm::File::GetZOrigin(), gdcm::File::GetZSize(), gdcm::File::GetZSpacing(), gdcm::File::IsSignedPixelData(), gdcm::ElementSet::Print(), gdcm::DocEntrySet::SetEntryBinArea(), gdcm::DocEntrySet::SetEntryString(), gdcm::FileHelper::SetWriteToLibido(), gdcm::FileHelper::SetWriteToNoLibido(), gdcm::FileHelper::Write(), gdcm::File::Write(), and gdcm::DicomDirMeta::WriteContent(). { DocEntry *currentEntry = GetDocEntry(group, elem); if ( !currentEntry ) return NULL; return dynamic_cast<DataEntry*>(currentEntry); }

DictEntry * gdcm::DocEntrySet::GetDictEntry (  uint16_t  group, uint16_t  elem, VRKey const &  vr )  [protected, inherited]

Searches [both] the public [and the shadow dictionary (when they exist)] for the presence of the DictEntry with given group and element, and create a new virtual DictEntry if necessary. Parameters: group  group number of the searched DictEntry elem  element number of the searched DictEntry vr  V(alue) R(epresentation) to use, if necessary Returns: Corresponding DictEntry when it exists, NULL otherwise. Remarks: The returned DictEntry is registered Definition at line 520 of file gdcmDocEntrySet.cxx. References gdcm::GDCM_VRUNKNOWN, gdcm::DocEntrySet::GetDictEntry(), gdcm::DicomEntry::GetVR(), gdcm::DictEntry::New(), gdcm::RefCounter::Register(), and gdcm::RefCounter::Unregister(). { DictEntry *dictEntry = GetDictEntry(group,elem); DictEntry *goodEntry = dictEntry; VRKey goodVR = vr; if (elem == 0x0000) goodVR="UL"; if ( goodEntry ) { if ( goodVR != goodEntry->GetVR() && goodVR != GDCM_VRUNKNOWN ) { goodEntry = NULL; } dictEntry->Unregister(); } // Create a new virtual DictEntry if necessary if (!goodEntry) { if (dictEntry) { goodEntry = DictEntry::New(group, elem, goodVR, "FIXME", dictEntry->GetName() ); } else { goodEntry = DictEntry::New(group, elem, goodVR); } } else { goodEntry->Register(); } return goodEntry; }

DictEntry * gdcm::DocEntrySet::GetDictEntry (  uint16_t  group, uint16_t  elem )  [protected, inherited]

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(s), if any. Parameters: group  Group number of the searched DictEntry elem  Element number of the searched DictEntry Returns: Corresponding DictEntry when it exists, NULL otherwise. Remarks: The returned DictEntry is registered when existing Definition at line 493 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, gdcm::DictSet::GetDefaultPubDict(), gdcm::Global::GetDicts(), gdcm::Dict::GetEntry(), and gdcm::RefCounter::Register(). Referenced by gdcm::DocEntrySet::GetDictEntry(), gdcm::DocEntrySet::NewDataEntry(), gdcm::DocEntrySet::NewSeqEntry(), and ReadNextDocEntry(). { DictEntry *found = 0; Dict *pubDict = Global::GetDicts()->GetDefaultPubDict(); if (!pubDict) { gdcmWarningMacro( "We SHOULD have a default dictionary"); } else { found = pubDict->GetEntry(group, elem); if( found ) found->Register(); } return found; }

DocEntry * gdcm::ElementSet::GetDocEntry (  uint16_t  group, uint16_t  elem )  [virtual, inherited]

retrieves a Dicom Element using (group, element) Parameters: group  Group number of the searched Dicom Element elem  Element number of the searched Dicom Element Returns: Implements gdcm::DocEntrySet. Definition at line 163 of file gdcmElementSet.cxx. References gdcm::ElementSet::TagHT, and gdcm::DicomEntry::TranslateToKey(). Referenced by gdcm::File::AnonymizeFile(), gdcm::File::AnonymizeNoLoad(), gdcm::FileHelper::CopyDataEntry(), gdcm::DicomDir::CreateDicomDir(), DoTheLoadingDocumentJob(), gdcm::File::DoTheLoadingJob(), gdcm::DicomDir::DoTheLoadingJob(), gdcm::File::GetPixelAreaLength(), gdcm::File::GetPixelOffset(), GetTransferSyntax(), gdcm::File::HasLUT(), IsDicomV3(), IsPapyrus(), gdcm::File::IsReadable(), LoadEntryBinArea(), gdcm::DocEntryArchive::Push(), and gdcm::DocEntryArchive::Restore(). { TagKey key = DictEntry::TranslateToKey(group, elem); TagDocEntryHT::iterator it = TagHT.find(key); if ( it!=TagHT.end() ) return it->second; return NULL; }

void * gdcm::DocEntrySet::GetEntryBinArea (  uint16_t  group, uint16_t  elem )  [virtual, inherited]

Gets (from Header) a 'non string' element value. Parameters: group  group number of the Entry elem  element number of the Entry Returns: Pointer to the 'non string' area Definition at line 69 of file gdcmDocEntrySet.cxx. References gdcm::DataEntry::GetBinArea(), and gdcm::DocEntrySet::GetDataEntry(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { DataEntry *entry = GetDataEntry(group, elem); if ( entry ) return entry->GetBinArea(); return 0; }

std::string gdcm::DocEntrySet::GetEntryForcedAsciiValue (  uint16_t  group, uint16_t  elem )  [virtual, inherited]

Return the value of the DataEntry if it's "std::string representable". Parameters: group  Group number of the searched tag. elem  Element number of the searched tag. Returns: Corresponding element value when it's "std::string representable" and the string GDCM_NOTASCII otherwise. Definition at line 84 of file gdcmDocEntrySet.cxx. References gdcm::Util::CreateCleanString(), gdcm::GDCM_NOTASCII, gdcm::GDCM_NOTLOADED, gdcm::GDCM_UNFOUND, gdcm::GDCM_UNREAD, gdcm::DataEntry::GetBinArea(), gdcm::DocEntrySet::GetDocEntry(), gdcm::DocEntry::GetLength(), gdcm::DataEntry::GetString(), gdcm::DocEntry::GetVR(), gdcm::Global::GetVR(), gdcm::Util::IsCleanArea(), gdcm::DataEntry::IsNotLoaded(), gdcm::DataEntry::IsUnfound(), gdcm::DataEntry::IsUnread(), and gdcm::VR::IsVROfStringRepresentable(). { DocEntry *d = GetDocEntry(group,elem); if ( !d ) return GDCM_UNFOUND; DataEntry *de = dynamic_cast<DataEntry *>(d); if ( de ) { if( de->IsNotLoaded() ) return GDCM_NOTLOADED; if( de->IsUnfound() ) return GDCM_UNFOUND; if( de->IsUnread() ) return GDCM_UNREAD; } if( Global::GetVR()->IsVROfStringRepresentable( de->GetVR() ) ) return de->GetString(); else { uint8_t *a = de->GetBinArea(); if( Util::IsCleanArea(a, de->GetLength()) ) return Util::CreateCleanString(a, de->GetLength()); } return GDCM_NOTASCII; }

int gdcm::DocEntrySet::GetEntryLength (  uint16_t  group, uint16_t  elem )  [virtual, inherited]

Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the value length of a given tag.. Parameters: group  Group number of the searched tag. elem  Element number of the searched tag. Returns: Corresponding element length; -2 if not found Definition at line 120 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::GetDocEntry(), and gdcm::DocEntry::GetLength(). Referenced by gdcm::DicomDir::SetElement(), and gdcm::File::Write(). { DocEntry *entry = GetDocEntry(group, elem); if ( entry ) return entry->GetLength(); return -1; }

std::string gdcm::DocEntrySet::GetEntryString (  uint16_t  group, uint16_t  elem )  [virtual, inherited]

Get the "std::string representable" value of the Dicom entry. Parameters: group  Group number of the searched tag. elem  Element number of the searched tag. Returns: Corresponding element value when it exists, and the string GDCM_UNFOUND otherwise. Definition at line 47 of file gdcmDocEntrySet.cxx. References gdcm::GDCM_NOTLOADED, gdcm::GDCM_UNFOUND, gdcm::GDCM_UNREAD, gdcm::DocEntrySet::GetDocEntry(), gdcm::DataEntry::GetString(), gdcm::DataEntry::IsNotLoaded(), gdcm::DataEntry::IsUnfound(), and gdcm::DataEntry::IsUnread(). Referenced by gdcm::SerieHelper::AddFileName(), gdcm::File::AnonymizeFile(), gdcm::FileHelper::CheckMandatoryElements(), DoTheLoadingDocumentJob(), gdcm::File::DoTheLoadingJob(), gdcm::File::GetImageNumber(), gdcm::File::GetImageOrientationPatient(), gdcm::File::GetLUTNbits(), gdcm::File::GetModality(), gdcm::File::GetNumberOfScalarComponents(), gdcm::File::GetNumberOfScalarComponentsRaw(), gdcm::File::GetPixelSize(), gdcm::File::GetPixelType(), GetTransferSyntaxName(), gdcm::PixelReadConvert::GrabInformationsFromFile(), gdcm::File::IsMonochrome(), gdcm::File::IsMonochrome1(), gdcm::File::IsPaletteColor(), gdcm::File::IsReadable(), gdcm::File::IsYBRFull(), operator<(), and gdcm::DicomDir::SetElement(). { DataEntry *entry = dynamic_cast<DataEntry *>(GetDocEntry(group,elem)); if ( entry ) { if( entry->IsNotLoaded() ) return GDCM_NOTLOADED; if( entry->IsUnfound() ) return GDCM_UNFOUND; if( entry->IsUnread() ) return GDCM_UNREAD; return entry->GetString(); } return GDCM_UNFOUND; }

const std::string& gdcm::Document::GetFileName (   )  const [inline]

Accessor to Filename. Definition at line 74 of file gdcmDocument.h. Referenced by gdcm::DicomDir::DoTheLoadingJob(), gdcm::SerieHelper::FileNameGreaterThan(), gdcm::SerieHelper::FileNameLessThan(), IsParsable(), gdcm::DicomDir::IsReadable(), Load(), gdcm::DicomDir::ParseDirectory(), and gdcm::DicomDir::SetElement(). { return Filename; }

FileType gdcm::Document::GetFileType (   )

returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown) Returns: the FileType code Definition at line 403 of file gdcmDocument.cxx. References Filetype. { return Filetype; }

DocEntry * gdcm::ElementSet::GetFirstEntry (   )  [virtual, inherited]

Get the first entry while visiting *the* 'zero level' DocEntrySet (DocEntries out of any Sequence). Returns: The first DocEntry if found, otherwhise NULL Implements gdcm::DocEntrySet. Definition at line 133 of file gdcmElementSet.cxx. References gdcm::ElementSet::ItTagHT, and gdcm::ElementSet::TagHT. Referenced by ComputeGroup0002Length(), gdcm::DicomDir::DoTheLoadingJob(), gdcm::DicomDir::NewMeta(), and gdcm::Validator::SetInput(). { ItTagHT = TagHT.begin(); if (ItTagHT != TagHT.end()) return ItTagHT->second; return NULL; }

DocEntry * gdcm::ElementSet::GetNextEntry (   )  [virtual, inherited]

Get the next entry while visiting *the* 'zero level' DocEntrySet (DocEntries out of any Sequence). Note: : meaningfull only if GetFirstEntry already called Returns: The next DocEntry if found, otherwhise NULL Implements gdcm::DocEntrySet. Definition at line 147 of file gdcmElementSet.cxx. References gdcmAssertMacro, gdcm::ElementSet::ItTagHT, and gdcm::ElementSet::TagHT. Referenced by ComputeGroup0002Length(), and gdcm::Validator::SetInput(). { gdcmAssertMacro (ItTagHT != TagHT.end()); ++ItTagHT; if (ItTagHT != TagHT.end()) return ItTagHT->second; return NULL; }

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

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

Dict * gdcm::Document::GetPubDict (   )

Get the public dictionary used. Definition at line 300 of file gdcmDocument.cxx. References RefPubDict. Referenced by gdcm::DicomDir::SetElement(). { return RefPubDict; }

const unsigned long& gdcm::RefCounter::GetRefCount (   )  const [inline, inherited]

Get the reference counting. Returns: Reference count Definition at line 57 of file gdcmRefCounter.h. { return RefCount; }

SeqEntry * gdcm::DocEntrySet::GetSeqEntry (  uint16_t  group, uint16_t  elem )  [inherited]

Same as Document::GetDocEntry except it only returns a result when the corresponding entry is of type SeqEntry. Parameters: group  Group number of the searched Dicom Element elem  Element number of the searched Dicom Element Returns: When present, the corresponding SeqEntry. Definition at line 153 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::GetDocEntry(). Referenced by DoTheLoadingDocumentJob(). { DocEntry *currentEntry = GetDocEntry(group, elem); if ( !currentEntry ) return NULL; return dynamic_cast<SeqEntry*>(currentEntry); }

Dict * gdcm::Document::GetShaDict (   )

Get the shadow dictionary used. Definition at line 308 of file gdcmDocument.cxx. References RefShaDict. { return RefShaDict; }

int gdcm::Document::GetSwapCode (   )  [inline]

'Swap code' accessor (see SwapCode ) Definition at line 70 of file gdcmDocument.h. Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { return SwapCode; }

std::string gdcm::Document::GetTransferSyntax (   )

Accessor to the Transfer Syntax (when present) of the current document (it internally handles reading the value from disk when only parsing occured). Returns: The encountered Transfer Syntax of the current document, if DICOM. GDCM_UNKNOWN for ACR-NEMA files (or broken headers ...) Definition at line 415 of file gdcmDocument.cxx. References gdcm::GDCM_UNKNOWN, gdcmWarningMacro, gdcm::ElementSet::GetDocEntry(), and LoadDocEntrySafe(). Referenced by gdcm::File::ComputeJPEGFragmentInfo(), gdcm::File::ComputeRLEInfo(), gdcm::File::DoTheLoadingJob(), gdcm::PixelReadConvert::GrabInformationsFromFile(), and HandleOutOfGroup0002(). { DocEntry *entry = GetDocEntry(0x0002, 0x0010); if ( !entry ) { return GDCM_UNKNOWN; } // The entry might be present but not loaded (parsing and loading // happen at different stages): try loading and proceed with check... LoadDocEntrySafe(entry); if (DataEntry *dataEntry = dynamic_cast<DataEntry *>(entry) ) { std::string transfer = dataEntry->GetString(); // The actual transfer (as read from disk) might be padded. We // first need to remove the potential padding. We can make the // weak assumption that padding was not executed with digits... if ( transfer.length() == 0 ) { // for brain damaged headers gdcmWarningMacro( "Transfer Syntax has length = 0."); return GDCM_UNKNOWN; } while ( !isdigit((unsigned char)transfer[transfer.length()-1]) ) { transfer.erase(transfer.length()-1, 1); if ( transfer.length() == 0 ) { // for brain damaged headers gdcmWarningMacro( "Transfer Syntax contains no valid character."); return GDCM_UNKNOWN; } } return transfer; } return GDCM_UNKNOWN; }

std::string gdcm::Document::GetTransferSyntaxName (   )

Accesses the info from 0002,0010 : Transfer Syntax and TS. Returns: The full Transfer Syntax Name (as opposed to Transfer Syntax UID) Definition at line 457 of file gdcmDocument.cxx. References gdcm::GDCM_NOTLOADED, gdcm::GDCM_UNFOUND, gdcmDebugMacro, gdcmErrorMacro, gdcm::DocEntrySet::GetEntryString(), and gdcm::Global::GetTS(). Referenced by HandleOutOfGroup0002(). { // use the TS (TS : Transfer Syntax) std::string transferSyntax = GetEntryString(0x0002,0x0010); if ( (transferSyntax.find(GDCM_NOTLOADED) < transferSyntax.length()) ) { gdcmErrorMacro( "Transfer Syntax not loaded. " << std::endl << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE" ); return "Uncompressed ACR-NEMA"; } if ( transferSyntax == GDCM_UNFOUND ) { gdcmDebugMacro( "Unfound Transfer Syntax (0002,0010)"); return "Uncompressed ACR-NEMA"; } // we do it only when we need it const TSKey &tsName = Global::GetTS()->GetValue( transferSyntax ); // Global::GetTS() is a global static you shall never try to delete it! return tsName; }

void gdcm::Document::HandleBrokenEndian (  uint16_t &  group, uint16_t &  elem )  [private]

Handle broken private tag from Philips NTSCAN where the endianess is being switched to BigEndian for no apparent reason. Returns: no return Definition at line 2086 of file gdcmDocument.cxx. References gdcmDebugMacro, gdcmWarningMacro, and SwitchByteSwapCode(). Referenced by ReadNextDocEntry(). { // Endian reversion. // Some files contain groups of tags with reversed endianess. static int reversedEndian = 0; // try to fix endian switching in the middle of headers if ((group == 0xfeff) && (elem == 0x00e0)) { // start endian swap mark for group found gdcmDebugMacro( "Start endian swap mark found." ); reversedEndian++; SwitchByteSwapCode(); // fix the tag group = 0xfffe; elem = 0xe000; } else if (group == 0xfffe && elem == 0xe00d && reversedEndian) { // end of reversed endian group gdcmDebugMacro( "End of reversed endian." ); reversedEndian--; SwitchByteSwapCode(); } else if (group == 0xfeff && elem == 0xdde0) { // reversed Sequence Terminator found // probabely a bug in the header ! // Do what you want, it breaks ! //reversedEndian--; //SwitchByteSwapCode(); gdcmWarningMacro( "Should never get here! reversed Sequence Terminator!" ); // fix the tag group = 0xfffe; elem = 0xe0dd; } else if (group == 0xfffe && elem == 0xe0dd) { gdcmDebugMacro( "Straight Sequence Terminator." ); } }

void gdcm::Document::HandleOutOfGroup0002 (  uint16_t &  group, uint16_t &  elem )  [private]

Group 0002 is always coded Little Endian whatever Transfer Syntax is. Returns: no return Definition at line 2132 of file gdcmDocument.cxx. References Filetype, gdcm::GDCM_UNKNOWN, gdcmDebugMacro, gdcmWarningMacro, GetTransferSyntax(), GetTransferSyntaxName(), gdcm::Global::GetTS(), Group0002Parsed, gdcm::ImplicitVR, SwapShort(), and SwitchByteSwapCode(). Referenced by ReadNextDocEntry(). { // Endian reversion. // Some files contain groups of tags with reversed endianess. if ( !Group0002Parsed && group != 0x0002) { Group0002Parsed = true; // we just came out of group 0002 // if Transfer Syntax is Big Endian we have to change CheckSwap std::string ts = GetTransferSyntax(); if ( ts == GDCM_UNKNOWN ) { gdcmDebugMacro("True DICOM File, with NO Transfer Syntax (?!) " ); return; } if ( !Global::GetTS()->IsTransferSyntax(ts) ) { gdcmWarningMacro("True DICOM File, with illegal Transfer Syntax: [" << ts << "]"); return; } // Group 0002 is always 'Explicit ...' // even when Transfer Syntax says 'Implicit ..." if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian ) { Filetype = ImplicitVR; } // FIXME Strangely, this works with //'Implicit VR BigEndian Transfer Syntax (GE Private) // // --> Probabely normal, since we considered we never have // to trust manufacturers. // (we find very often 'Implicit VR' tag, // even when Transfer Syntax tells us it's Explicit ... if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian ) { gdcmDebugMacro("Transfer Syntax Name = [" << GetTransferSyntaxName() << "]" ); SwitchByteSwapCode(); group = SwapShort(group); elem = SwapShort(elem); } } }

void gdcm::Document::Initialize (   )  [private]

Loads all the needed Dictionaries. Reimplemented in gdcm::DicomDir. Definition at line 1002 of file gdcmDocument.cxx. References Filetype, gdcm::DictSet::GetDefaultPubDict(), gdcm::Global::GetDicts(), RefPubDict, RefShaDict, and gdcm::Unknown. Referenced by Document(). { RefPubDict = Global::GetDicts()->GetDefaultPubDict(); RefShaDict = NULL; Filetype = Unknown; }

DataEntry * gdcm::DocEntrySet::InsertEntryBinArea (  uint8_t *  binArea, int  lgth, uint16_t  group, uint16_t  elem, VRKey const &  vr = GDCM_VRUNKNOWN )  [inherited]

Modifies the value of a given Header Entry (Dicom Element) when it exists. Create it with the given value when unexistant. A copy of the binArea is made to be kept in the Document. Parameters: binArea  (binary) value to be set lgth  length of the Bin Area we want to set group  Group number of the Entry elem  Element number of the Entry vr  V(alue) R(epresentation) of the Entry -if private Entry- Returns: pointer to the modified/created Header Entry (NULL when creation failed). Definition at line 308 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::AddEntry(), gdcm::RefCounter::Delete(), gdcmWarningMacro, gdcm::DocEntrySet::GetDocEntry(), gdcm::DocEntry::GetVR(), gdcm::DocEntrySet::NewDataEntry(), gdcm::DocEntrySet::RemoveEntry(), and gdcm::DocEntrySet::SetEntryBinArea(). Referenced by gdcm::FileHelper::InsertEntryBinArea(). { DataEntry *dataEntry = 0; DocEntry *currentEntry = GetDocEntry( group, elem ); // Verify the currentEntry if (currentEntry) { dataEntry = dynamic_cast<DataEntry *>(currentEntry); // Verify the VR if ( dataEntry ) if ( dataEntry->GetVR()!=vr ) dataEntry = NULL; // if currentEntry doesn't correspond to the requested dataEntry if ( !dataEntry) { if ( !RemoveEntry(currentEntry) ) { gdcmWarningMacro( "Removal of previous DocEntry failed."); return NULL; } } } // Create a new dataEntry if necessary if ( !dataEntry) { dataEntry = NewDataEntry(group, elem, vr); if ( !AddEntry(dataEntry) ) { gdcmWarningMacro( "AddEntry failed although this is a creation."); dataEntry->Delete(); return NULL; } dataEntry->Delete(); } // Set the dataEntry value uint8_t *tmpArea; if ( lgth>0 && binArea ) { tmpArea = new uint8_t[lgth]; memcpy(tmpArea,binArea,lgth); } else { tmpArea = 0; } if ( !SetEntryBinArea(tmpArea,lgth,dataEntry) ) { if ( tmpArea ) { delete[] tmpArea; } } return dataEntry; }

DataEntry * gdcm::DocEntrySet::InsertEntryString (  std::string const &  value, uint16_t  group, uint16_t  elem, VRKey const &  vr = GDCM_VRUNKNOWN )  [inherited]

Modifies the value of a given Doc Entry (Dicom Element) when it exists. Create it with the given value when unexistant. Parameters: value  (string) Value to be set group  Group number of the Entry elem  Element number of the Entry vr  V(alue) R(epresentation) of the Entry -if private Entry- Returns: pointer to the modified/created Header Entry (NULL when creation failed). Definition at line 250 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::AddEntry(), gdcm::RefCounter::Delete(), gdcmWarningMacro, gdcm::DocEntrySet::GetDocEntry(), gdcm::DocEntry::GetVR(), gdcm::DocEntrySet::NewDataEntry(), gdcm::DocEntrySet::RemoveEntry(), and gdcm::DocEntrySet::SetEntryString(). Referenced by gdcm::FileHelper::InsertEntryString(), gdcm::FileHelper::Write(), and gdcm::File::Write(). { DataEntry *dataEntry = 0; DocEntry *currentEntry = GetDocEntry( group, elem ); if (currentEntry) { dataEntry = dynamic_cast<DataEntry *>(currentEntry); // Verify the VR if ( dataEntry ) if ( dataEntry->GetVR()!=vr ) dataEntry = NULL; // if currentEntry doesn't correspond to the requested dataEntry if ( !dataEntry) { if ( !RemoveEntry(currentEntry) ) { gdcmWarningMacro( "Removal of previous DocEntry failed."); return NULL; } } } // Create a new dataEntry if necessary if ( !dataEntry ) { dataEntry = NewDataEntry( group, elem, vr ); if ( !AddEntry(dataEntry) ) { gdcmWarningMacro("AddEntry failed although this is a creation."); dataEntry->Delete(); return NULL; } dataEntry->Delete(); } // Set the dataEntry value SetEntryString(value, dataEntry); // The std::string value return dataEntry; }

SeqEntry * gdcm::DocEntrySet::InsertSeqEntry (  uint16_t  group, uint16_t  elem )  [inherited]

Modifies the value of a given Doc Entry (Dicom Element) when it exists. Creates it when unexistant. Parameters: group  Group number of the Entry elem  Element number of the Entry Returns: pointer to the modified/created SeqEntry (NULL when creation failed). Definition at line 380 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::AddEntry(), gdcm::RefCounter::Delete(), gdcmWarningMacro, gdcm::DocEntrySet::GetDocEntry(), gdcm::DocEntrySet::NewSeqEntry(), and gdcm::DocEntrySet::RemoveEntry(). Referenced by gdcm::FileHelper::InsertSeqEntry(). { SeqEntry *seqEntry = 0; DocEntry *currentEntry = GetDocEntry( group, elem ); // Verify the currentEntry if ( currentEntry ) { seqEntry = dynamic_cast<SeqEntry *>(currentEntry); // Verify the VR if ( seqEntry ) seqEntry = NULL; // if currentEntry doesn't correspond to the requested seqEntry if ( !seqEntry ) { if (!RemoveEntry(currentEntry)) { gdcmWarningMacro( "Removal of previous DocEntry failed."); return NULL; } } } // Create a new seqEntry if necessary if ( !seqEntry ) { seqEntry = NewSeqEntry(group, elem); if ( !AddEntry(seqEntry) ) { gdcmWarningMacro( "AddEntry failed although this is a creation."); seqEntry->Delete(); return NULL; } seqEntry->Delete(); } // TODO : Find a trick to insert a SequenceDelimitationItem // in the SeqEntry, at the end. return seqEntry; }

bool gdcm::Document::IsDicomV3 (   )

Predicate for dicom version 3 file. Returns: True when the file is a dicom version 3. Definition at line 372 of file gdcmDocument.cxx. References gdcm::ElementSet::GetDocEntry(). Referenced by gdcm::File::GetYSize(), and gdcm::PixelReadConvert::GrabInformationsFromFile(). { // Checking if Transfer Syntax exists is enough // Anyway, it's too late check if the 'Preamble' was found ... // And ... would it be a rich idea to check ? // (some 'no Preamble' DICOM images exist !) return GetDocEntry(0x0002, 0x0010) != NULL; }

bool gdcm::Document::IsDocEntryAnInteger (  DocEntry *  entry  )  [private]

Apply some heuristics to predict whether 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 1689 of file gdcmDocument.cxx. References Fp, gdcmWarningMacro, gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), and gdcm::DocEntry::GetVR(). { uint16_t elem = entry->GetElement(); uint16_t group = entry->GetGroup(); const VRKey &vr = entry->GetVR(); uint32_t 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 ( elem == 0 ) // This is the group length of the group { if ( length == 4 ) { return true; } else { // Although this should never happen, still some images have a // corrupted group length [e.g. have a glance at offset x(8336) of // gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm. // Since for dicom compliant and well behaved headers, the present // test is useless (and might even look a bit paranoid), when we // encounter such an ill-formed image, we simply display a warning // message and proceed on parsing (while crossing fingers). long filePosition = Fp->tellg(); gdcmWarningMacro( "Erroneous Group Length element length on : (" << std::hex << group << " , " << elem << ") -before- position x(" << filePosition << ")" << "lgt : " << length ); } } if ( vr == "UL" || vr == "US" || vr == "SL" || vr == "SS" ) { return true; } return false; }

bool gdcm::ElementSet::IsEmpty (   )  [inline, virtual, inherited]

Tells us if the ElementSet contains no entry. Implements gdcm::DocEntrySet. Definition at line 60 of file gdcmElementSet.h. Referenced by DoTheLoadingDocumentJob(), and IsParsable(). { return TagHT.empty(); }

bool gdcm::Document::IsPapyrus (   )

Predicate for Papyrus file Dedicated to whomsoever it may concern. Returns: True when the file is a Papyrus file. Definition at line 386 of file gdcmDocument.cxx. References gdcm::ElementSet::GetDocEntry(). { // check for Papyrus private Sequence DocEntry *e = GetDocEntry(0x0041, 0x1050); if ( !e ) return false; // check if it's actually a Sequence if ( !dynamic_cast<SeqEntry*>(e) ) return false; return true; }

bool gdcm::Document::IsParsable (   )

This predicate tells us whether or not the current Document was properly parsed and contains at least *one* Dicom Element (and nothing more, sorry). Returns: false when we're 150 % sure it's NOT a Dicom/Acr file, true otherwise. Definition at line 340 of file gdcmDocument.cxx. References Filetype, gdcmWarningMacro, GetFileName(), gdcm::ElementSet::IsEmpty(), and gdcm::Unknown. Referenced by IsReadable(). { if ( Filetype == Unknown ) { gdcmWarningMacro( "Wrong filetype for " << GetFileName()); return false; } if ( IsEmpty() ) { gdcmWarningMacro( "No tag in internal hash table."); return false; } return true; }

bool gdcm::Document::IsReadable (   )  [virtual]

This predicate tells us whether or not the current Document was properly parsed and contains at least *one* Dicom Element (and nothing more, sorry). Returns: false when we're 150 % sure it's NOT a Dicom/Acr file, true otherwise. Reimplemented in gdcm::DicomDir, and gdcm::File. Definition at line 363 of file gdcmDocument.cxx. References IsParsable(). Referenced by gdcm::File::IsReadable(). { return IsParsable(); }

bool gdcm::Document::Load (   )  [virtual]

Loader. use SetLoadMode(), SetFileName() before ! Returns: false if file cannot be open or no swap info was found, or no tag was found. Reimplemented in gdcm::DicomDir, and gdcm::File. Definition at line 84 of file gdcmDocument.cxx. References DoTheLoadingDocumentJob(), gdcmWarningMacro, and GetFileName(). Referenced by gdcm::DicomDir::DoTheLoadingJob(). { if ( GetFileName() == "" ) { gdcmWarningMacro( "Use SetFileName, before !" ); return false; } return DoTheLoadingDocumentJob( ); }

bool gdcm::Document::Load (  std::string const &  fileName  )  [virtual]

Loader. (DEPRECATED : not to break the API). Parameters: fileName  'Document' (File or DicomDir) to be open for parsing Returns: false if file cannot be open or no swap info was found, or no tag was found. Definition at line 99 of file gdcmDocument.cxx. References DoTheLoadingDocumentJob(), and Filename. { Filename = fileName; return DoTheLoadingDocumentJob( ); }

void gdcm::Document::LoadDocEntry (  DocEntry *  entry, bool  forceLoad = false )  [private]

Loads (or not) the element content depending if its length exceeds or not the value specified with Document::SetMaxSizeLoadEntry(). Parameters: entry  Header Entry (Dicom Element) to be dealt with forceLoad  whether you want to force loading of 'long' elements Definition at line 1331 of file gdcmDocument.cxx. References Fp, gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetOffset(), gdcm::DocEntry::GetVR(), LoadEntryBinArea(), MaxSizeLoadEntry, gdcm::DataEntry::SetBinArea(), gdcm::DataEntry::SetState(), and gdcm::DataEntry::STATE_NOTLOADED. Referenced by DoTheLoadingDocumentJob(), LoadDocEntrySafe(), and ParseDES(). { uint16_t group = entry->GetGroup(); uint16_t elem = entry->GetElement(); const VRKey &vr = entry->GetVR(); uint32_t length = entry->GetLength(); Fp->seekg((long)entry->GetOffset(), std::ios::beg); // 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 // // (fffe 0000) is an 'impossible' tag value, // found in MR-PHILIPS-16-Multi-Seq.dcm if ( (group == 0xfffe && elem != 0x0000 ) || vr == "SQ" ) { // NO more value field for SQ ! return; } DataEntry *dataEntryPtr = dynamic_cast< DataEntry* >(entry); if( !dataEntryPtr ) { return; } // When the length is zero things are easy: if ( length == 0 ) { dataEntryPtr->SetBinArea(NULL,true); return; } // The elements whose length is bigger than the specified upper bound // are not loaded. std::ostringstream s; if (!forceLoad) { if (length > MaxSizeLoadEntry) { dataEntryPtr->SetBinArea(NULL,true); dataEntryPtr->SetState(DataEntry::STATE_NOTLOADED); // to be sure we are at the end of the value ... Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(), std::ios::beg); return; } } LoadEntryBinArea(dataEntryPtr); // last one, not to erase length ! }

void gdcm::Document::LoadDocEntrySafe (  DocEntry *  entry  )

Loads the element while preserving the current underlying file position indicator as opposed to LoadDocEntry that modifies it. Parameters: entry  DocEntry whose value will be loaded. Definition at line 822 of file gdcmDocument.cxx. References Fp, and LoadDocEntry(). Referenced by GetTransferSyntax(). { if ( Fp ) { long PositionOnEntry = Fp->tellg(); LoadDocEntry(entry); Fp->seekg(PositionOnEntry, std::ios::beg); } }

void gdcm::Document::LoadEntryBinArea (  DataEntry *  entry  )  [virtual]

Loads (from disk) the element content when a string is not suitable. Parameters: entry  Entry whose binArea is going to be loaded Definition at line 741 of file gdcmDocument.cxx. References CloseFile(), Fp, gdcmWarningMacro, gdcm::VR::GetAtomicElementLength(), gdcm::DataEntry::GetBinArea(), gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetOffset(), gdcm::DocEntry::GetVR(), gdcm::Global::GetVR(), OpenFile(), gdcm::DataEntry::SetBinArea(), gdcm::DataEntry::SetState(), gdcm::DataEntry::STATE_UNREAD, SwapDouble(), SwapLong(), and SwapShort(). { if( entry->GetBinArea() ) return; bool openFile = !Fp; if ( openFile ) OpenFile(); size_t o =(size_t)entry->GetOffset(); Fp->seekg(o, std::ios::beg); size_t l = entry->GetLength(); uint8_t *data = new uint8_t[l]; if ( !data ) { gdcmWarningMacro( "Cannot allocate DataEntry content for : " << std::hex << entry->GetGroup() << "|" << entry->GetElement() ); return; } // Read the data Fp->read((char*)data, l); if ( Fp->fail() || Fp->eof() ) { delete[] data; entry->SetState(DataEntry::STATE_UNREAD); return; } // Swap the data content if necessary uint32_t i; unsigned short vrLgth = Global::GetVR()->GetAtomicElementLength(entry->GetVR()); // FIXME : trouble expected if we read an ... OW Entry (LUT, etc ..) // if( entry->GetVR() == "OW" ) // vrLgth = 1; switch(vrLgth) { case 1: { break; } case 2: { uint16_t *data16 = (uint16_t *)data; for(i=0;i<l/vrLgth;i++) data16[i] = SwapShort(data16[i]); break; } case 4: { uint32_t *data32 = (uint32_t *)data; for(i=0;i<l/vrLgth;i++) data32[i] = SwapLong(data32[i]); break; } case 8: { double *data64 = (double *)data; for(i=0;i<l/vrLgth;i++) data64[i] = SwapDouble(data64[i]); break; } } entry->SetBinArea(data); if ( openFile ) CloseFile(); }

void gdcm::Document::LoadEntryBinArea (  uint16_t  group, uint16_t  elem )  [virtual]

Loads (from disk) the element content when a string is not suitable. Parameters: group  group number of the Entry elem  element number of the Entry Definition at line 716 of file gdcmDocument.cxx. References gdcmDebugMacro, gdcmWarningMacro, and gdcm::ElementSet::GetDocEntry(). Referenced by DoTheLoadingDocumentJob(), gdcm::PixelReadConvert::GrabInformationsFromFile(), and LoadDocEntry(). { // Search the corresponding DocEntry DocEntry *docEntry = GetDocEntry(group, elem); if ( !docEntry ) { gdcmDebugMacro(std::hex << group << "|" << elem << " doesn't exist" ); return; } DataEntry *dataEntry = dynamic_cast<DataEntry *>(docEntry); if ( !dataEntry ) { gdcmWarningMacro(std::hex << group << "|" << elem << " is NOT a DataEntry"); return; } LoadEntryBinArea(dataEntry); }

bool gdcm::ElementSet::MayIWrite (  uint16_t   )  [inline, protected, inherited]

Some group are illegal withing some Dicom Documents Only the Document knows it. Reimplemented in gdcm::File. Definition at line 67 of file gdcmElementSet.h. Referenced by gdcm::ElementSet::WriteContent(). { return true; }

DataEntry * gdcm::DocEntrySet::NewDataEntry (  uint16_t  group, uint16_t  elem, VRKey const &  vr = GDCM_VRUNKNOWN )  [inherited]

Build a new Val Entry from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent. Parameters: group  Group number of the new Entry elem  Element number of the new Entry vr  V(alue) R(epresentation) of the new Entry Remarks: The user of this method must destroy the DataEntry when unused Definition at line 444 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, gdcm::DocEntrySet::GetDictEntry(), gdcm::DataEntry::New(), and gdcm::RefCounter::Unregister(). Referenced by gdcm::FileHelper::CopyDataEntry(), gdcm::DocEntrySet::InsertEntryBinArea(), gdcm::DocEntrySet::InsertEntryString(), and ReadNextDocEntry(). { DictEntry *dictEntry = GetDictEntry(group, elem, vr); DataEntry *newEntry = DataEntry::New(dictEntry); dictEntry->Unregister(); // GetDictEntry register it if (!newEntry) { gdcmWarningMacro( "Failed to allocate DataEntry"); return 0; } return newEntry; }

SeqEntry * gdcm::DocEntrySet::NewSeqEntry (  uint16_t  group, uint16_t  elem )  [inherited]

Build a new Seq Entry from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent. Parameters: group  Group number of the new Entry elem  Element number of the new Entry Remarks: The user of this method must destroy the SeqEntry when unused Definition at line 467 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, gdcm::DocEntrySet::GetDictEntry(), gdcm::SeqEntry::New(), and gdcm::RefCounter::Unregister(). Referenced by Backtrack(), gdcm::DocEntrySet::InsertSeqEntry(), and ReadNextDocEntry(). { DictEntry *dictEntry = GetDictEntry(group, elem, "SQ"); SeqEntry *newEntry = SeqEntry::New( dictEntry ); dictEntry->Unregister(); // GetDictEntry register it if (!newEntry) { gdcmWarningMacro( "Failed to allocate SeqEntry"); return 0; } return newEntry; }

std::ifstream * gdcm::Document::OpenFile (   )

Tries to open the file Document::Filename and checks the preamble when existing. Returns: The FILE pointer on success. Definition at line 572 of file gdcmDocument.cxx. References CloseFile(), Filename, gdcm::Util::Format(), Fp, gdcmDebugMacro, gdcmWarningMacro, and HasDCMPreamble. Referenced by DoTheLoadingDocumentJob(), gdcm::File::DoTheLoadingJob(), gdcm::FileHelper::GetRaw(), and LoadEntryBinArea(). { HasDCMPreamble = false; if (Filename.length() == 0) { return 0; } if ( Fp ) { gdcmDebugMacro( "File already open: " << Filename.c_str()); CloseFile(); } Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary); if ( ! *Fp ) { // Don't user gdcmErrorMacro : // a spurious message will appear when you use, for instance // gdcm::FileHelper *fh = new gdcm::FileHelper( outputFileName ); // to create outputFileName. // FIXME : if the upper comment is still usefull // --> the constructor is not so good ... gdcmWarningMacro( "Cannot open file: " << Filename.c_str()); delete Fp; Fp = 0; return 0; //exit(1); // No function is allowed to leave the application instead // of warning the caller } uint16_t zero = 0; Fp->read((char*)&zero, (size_t)2); if ( Fp->eof() ) { CloseFile(); return 0; } //-- Broken ACR or DICOM with no Preamble; may start with a Shadow Group -- // FIXME : We cannot be sure the preable is only zeroes.. // (see ACUSON-24-YBR_FULL-RLE.dcm ) if ( zero == 0x0001 || zero == 0x0100 || zero == 0x0002 || zero == 0x0200 || zero == 0x0003 || zero == 0x0300 || zero == 0x0004 || zero == 0x0400 || zero == 0x0005 || zero == 0x0500 || zero == 0x0006 || zero == 0x0600 || zero == 0x0007 || zero == 0x0700 || zero == 0x0008 || zero == 0x0800 ) { std::string msg = Util::Format( "ACR/DICOM starting by 0x(%04x) at the beginning of the file\n", zero); // FIXME : is it a Warning message, or a Debug message? gdcmWarningMacro( msg.c_str() ); return Fp; } //-- DICOM -- Fp->seekg(126L, std::ios::cur); char dicm[4]; // = {' ',' ',' ',' '}; Fp->read(dicm, (size_t)4); if ( Fp->eof() ) { CloseFile(); return 0; } if ( memcmp(dicm, "DICM", 4) == 0 ) { HasDCMPreamble = true; return Fp; } // -- Neither ACR/No Preamble Dicom nor DICOMV3 file CloseFile(); // Don't user Warning nor Error, not to polute the output // while directory recursive parsing ... gdcmDebugMacro( "Neither ACR/No Preamble Dicom nor DICOMV3 file: " << Filename.c_str()); return 0; }

bool gdcm::Document::operator< (  Document &  document  )

Compares two documents, according to DicomDir rules. Warning: Does NOT work with ACR-NEMA files Todo: Find a trick to solve the pb (use RET fields ?) Parameters: document  to compare with current one Returns: true if 'smaller' Definition at line 839 of file gdcmDocument.cxx. References gdcm::DocEntrySet::GetEntryString(). { // Patient Name std::string s1 = GetEntryString(0x0010,0x0010); std::string s2 = document.GetEntryString(0x0010,0x0010); if (s1 < s2) { return true; } else if ( s1 > s2 ) { return false; } else { // Patient ID s1 = GetEntryString(0x0010,0x0020); s2 = document.GetEntryString(0x0010,0x0020); if ( s1 < s2 ) { return true; } else if ( s1 > s2 ) { return false; } else { // Study Instance UID s1 = GetEntryString(0x0020,0x000d); s2 = document.GetEntryString(0x0020,0x000d); if ( s1 < s2 ) { return true; } else if ( s1 > s2 ) { return false; } else { // Serie Instance UID s1 = GetEntryString(0x0020,0x000e); s2 = document.GetEntryString(0x0020,0x000e); if ( s1 < s2 ) { return true; } else if ( s1 > s2 ) { return false; } } } } return false; }

void gdcm::Document::ParseDES (  DocEntrySet *  set, long  offset, long  l_max, bool  delim_mode )  [private]

Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries). Parameters: set  DocEntrySet we are going to parse ('zero level' or a SQItem) offset  start of parsing l_max  length to parse (meaningless when we are in 'delimitor mode') delim_mode  : whether we are in 'delimitor mode' (l=0xffffff) or not Definition at line 1016 of file gdcmDocument.cxx. References gdcm::DocEntrySet::AddEntry(), Backtrack(), gdcm::RefCounter::Delete(), Fp, gdcmDebugMacro, gdcmWarningMacro, gdcm::Debug::GetDebugFlag(), gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetKey(), gdcm::DocEntry::GetOffset(), gdcm::DocEntry::GetReadLength(), gdcm::DataEntry::GetString(), gdcm::DocEntry::GetVR(), gdcm::DocEntry::IsItemDelimitor(), gdcm::DocEntry::IsItemStarter(), gdcm::DataEntry::IsUnfound(), gdcm::LD_NOSEQ, gdcm::LD_NOSHADOW, gdcm::LD_NOSHADOWSEQ, LoadDocEntry(), LoadMode, ParseSQ(), gdcm::DocEntrySet::PreviousDocEntry, ReadNextDocEntry(), gdcm::ElementSet::RemoveEntry(), gdcm::SeqEntry::SetDelimitorMode(), gdcm::SeqEntry::SetDepthLevel(), and SkipToNextDocEntry(). Referenced by DoTheLoadingDocumentJob(), and ParseSQ(). { DocEntry *newDocEntry; DataEntry *newDataEntry; SeqEntry *newSeqEntry; VRKey vr; bool used; // will be set to false when something wrong happens to an Entry. // (Entry will then be deleted) bool delim_mode_intern = delim_mode; bool first = true; gdcmDebugMacro( "Enter in ParseDES, delim-mode " << delim_mode << " at offset " << std::hex << offset ); while (true) { if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { break; } newDocEntry = ReadNextDocEntry( ); // Uncoment this cerr line to be able to 'follow' the DocEntries // when something *very* strange happens if( Debug::GetDebugFlag() ) std::cerr<<newDocEntry->GetKey()<<" "<<newDocEntry->GetVR()<<std::endl; if ( !newDocEntry ) { break; } // an Item Starter found elsewhere but the first position // of a SeqEntry means previous entry was a Sequence // but we didn't get it (private Sequence + Implicit VR) // we have to backtrack. if ( !first && newDocEntry->IsItemStarter() ) { // Debug message within the method ! newDocEntry = Backtrack(newDocEntry); } else { PreviousDocEntry = newDocEntry; } used = true; newDataEntry = dynamic_cast<DataEntry*>(newDocEntry); if ( newDataEntry ) { vr = newDocEntry->GetVR(); if ( !set->AddEntry( newDataEntry ) ) { gdcmDebugMacro( "in ParseDES : cannot add a DataEntry " << newDataEntry->GetKey() << " (at offset : " << newDataEntry->GetOffset() << " )" ); used=false; } else { newDataEntry->Delete(); // Load only if we can add (not a duplicate key) LoadDocEntry( newDataEntry ); } if ( newDataEntry->GetElement() == 0x0000 ) // if on group length { if ( newDataEntry->GetGroup()%2 != 0 ) // if Shadow Group { if ( LoadMode & LD_NOSHADOW ) // if user asked to skip shad.gr { std::string strLgrGroup = newDataEntry->GetString(); int lgrGroup; if ( newDataEntry->IsUnfound() ) { lgrGroup = atoi(strLgrGroup.c_str()); Fp->seekg(lgrGroup, std::ios::cur); //used = false; // never used RemoveEntry( newDocEntry ); // Remove and delete // bcc 5.5 is right "assigned a value that's never used" // newDocEntry = 0; continue; } } } } bool delimitor = newDataEntry->IsItemDelimitor(); if ( (delimitor) || (!delim_mode && ((long)(Fp->tellg())-offset) >= l_max) ) { if ( !used ) newDocEntry->Delete(); break; } // Just to make sure we are at the beginning of next entry. SkipToNextDocEntry(newDocEntry); } else { unsigned long l = newDocEntry->GetReadLength(); if ( l != 0 ) // don't mess the delim_mode for 'zero-length sequence' { if ( l == 0xffffffff ) { delim_mode_intern = true; } else { delim_mode_intern = false; } } if ( (LoadMode & LD_NOSHADOWSEQ) && ! delim_mode_intern ) { // User asked to skip SeQuences *only* if they belong to Shadow Group if ( newDocEntry->GetGroup()%2 != 0 ) { Fp->seekg( l, std::ios::cur); newDocEntry->Delete(); // Delete, not in the set continue; } } if ( (LoadMode & LD_NOSEQ) && ! delim_mode_intern ) { // User asked to skip *any* SeQuence Fp->seekg( l, std::ios::cur); newDocEntry->Delete(); // Delete, not in the set continue; } // delay the dynamic cast as late as possible newSeqEntry = dynamic_cast<SeqEntry*>(newDocEntry); // no other way to create the Delimitor ... newSeqEntry->SetDelimitorMode( delim_mode_intern ); // At the top of the hierarchy, stands a Document. When "set" // is a Document, then we are building the first depth level. // Hence the SeqEntry we are building simply has a depth // level of one: if ( set == this ) // ( dynamic_cast< Document* > ( set ) ) { newSeqEntry->SetDepthLevel( 1 ); } // But when "set" is already a SQItem, we are building a nested // sequence, and hence the depth level of the new SeqEntry // we are building, is one level deeper: // time waste hunting else if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 ); } if ( l != 0 ) { // Don't try to parse zero-length sequences gdcmDebugMacro( "Entry in ParseSQ, delim " << delim_mode_intern << " at offset " << std::hex << newDocEntry->GetOffset() ); ParseSQ( newSeqEntry, newDocEntry->GetOffset(), l, delim_mode_intern); gdcmDebugMacro( "Exit from ParseSQ, delim " << delim_mode_intern); } if ( !set->AddEntry( newSeqEntry ) ) { gdcmWarningMacro( "in ParseDES : cannot add a SeqEntry " << newSeqEntry->GetKey() << " (at offset : " << newSeqEntry->GetOffset() << " )" ); used = false; } else { newDocEntry->Delete(); } if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { if ( !used ) newDocEntry->Delete(); break; } } // end SeqEntry : VR = "SQ" if ( !used ) { newDocEntry->Delete(); } first = false; } // end While gdcmDebugMacro( "Exit from ParseDES, delim-mode " << delim_mode ); }

void gdcm::Document::ParseSQ (  SeqEntry *  seqEntry, long  offset, long  l_max, bool  delim_mode )  [private]

Parses a Sequence ( SeqEntry after SeqEntry). Returns: parsed length for this level Definition at line 1227 of file gdcmDocument.cxx. References gdcm::SeqEntry::AddSQItem(), gdcm::RefCounter::Delete(), Fp, gdcmWarningMacro, gdcm::SeqEntry::GetDepthLevel(), gdcm::DocEntry::GetReadLength(), gdcm::DocEntry::IsSequenceDelimitor(), gdcm::SQItem::New(), ParseDES(), ReadNextDocEntry(), and gdcm::SeqEntry::SetDelimitationItem(). Referenced by ParseDES(). { int SQItemNumber = 0; bool dlm_mod; long offsetStartCurrentSQItem = offset; while (true) { // the first time, we read the fff0,e000 of the first SQItem DocEntry *newDocEntry = ReadNextDocEntry(); if ( !newDocEntry ) { gdcmWarningMacro("in ParseSQ : should never get here!"); break; } if ( delim_mode ) { if ( newDocEntry->IsSequenceDelimitor() ) { seqEntry->SetDelimitationItem( newDocEntry ); newDocEntry->Delete(); break; } } if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { newDocEntry->Delete(); break; } // create the current SQItem SQItem *itemSQ = SQItem::New( seqEntry->GetDepthLevel() ); unsigned int l = newDocEntry->GetReadLength(); if ( l == 0xffffffff ) { dlm_mod = true; } else { dlm_mod = false; } // remove fff0,e000, created out of the SQItem Fp->seekg(offsetStartCurrentSQItem, std::ios::beg); // fill up the current SQItem, starting at the beginning of fff0,e000 ParseDES(itemSQ, offsetStartCurrentSQItem, l+8, dlm_mod); offsetStartCurrentSQItem = Fp->tellg(); seqEntry->AddSQItem( itemSQ, SQItemNumber ); itemSQ->Delete(); newDocEntry->Delete(); SQItemNumber++; if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max ) { break; } } }

void gdcm::ElementSet::Print (  std::ostream &  os = std::cout, std::string const &  indent = "" )  [virtual, inherited]

Prints the Header Entries (Dicom Elements) from the H Table. Parameters: os  ostream to write to indent  Indentation string to be prepended during printing Reimplemented from gdcm::Base. Reimplemented in gdcm::DicomDir. Definition at line 186 of file gdcmElementSet.cxx. References gdcm::DataEntry::FLAG_PIXELDATA, gdcm::DocEntrySet::GetDataEntry(), gdcm::DocEntry::Print(), gdcm::Base::PrintLevel, gdcm::DataEntry::SetFlag(), gdcm::Base::SetPrintLevel(), and gdcm::ElementSet::TagHT. Referenced by gdcm::FileHelper::Print(). { // Let's change the 'warning value' for Pixel Data, // to avoid human reader to be confused by 'gdcm::NotLoaded'. DataEntry *pixelElement = GetDataEntry(0x7fe0,0x0010); if ( pixelElement != 0 ) { pixelElement->SetFlag( DataEntry::FLAG_PIXELDATA ); } for( TagDocEntryHT::const_iterator i = TagHT.begin(); i != TagHT.end(); ++i) { DocEntry *entry = i->second; entry->SetPrintLevel(PrintLevel); entry->Print(os); if ( dynamic_cast<SeqEntry *>(entry) ) { // Avoid the newline for a sequence: continue; } os << std::endl; } }

uint16_t gdcm::Document::ReadInt16 (   )  throw ( FormatError ) [protected]

Reads a supposed to be 16 Bits integer (swaps it depending on processor endianness). Returns: read value Definition at line 904 of file gdcmDocument.cxx. References Fp, and SwapShort(). Referenced by FindDocEntryLengthOBOrOW(), ReadNextDocEntry(), and gdcm::File::ReadTag(). { uint16_t g; Fp->read ((char*)&g, (size_t)2); if ( Fp->fail() ) { throw FormatError( "Document::ReadInt16()", " file error." ); } if ( Fp->eof() ) { throw FormatError( "Document::ReadInt16()", "EOF." ); } g = SwapShort(g); return g; }

uint32_t gdcm::Document::ReadInt32 (   )  throw ( FormatError ) [protected]

Reads a supposed to be 32 Bits integer (swaps it depending on processor endianness). Returns: read value Definition at line 926 of file gdcmDocument.cxx. References Fp, and SwapLong(). Referenced by gdcm::File::ComputeRLEInfo(), FindDocEntryLengthOBOrOW(), and gdcm::File::ReadTagLength(). { uint32_t g; Fp->read ((char*)&g, (size_t)4); if ( Fp->fail() ) { throw FormatError( "Document::ReadInt32()", " file error." ); } if ( Fp->eof() ) { throw FormatError( "Document::ReadInt32()", "EOF." ); } g = SwapLong(g); return g; }

DocEntry * gdcm::Document::ReadNextDocEntry (   )  [private]

Read the next tag WITHOUT loading it's value (read the 'Group Number', the 'Element Number', gets the Dict Entry gets the VR, gets the length, gets the offset value). Returns: On succes : the newly created DocEntry, NULL on failure. Definition at line 1986 of file gdcmDocument.cxx. References CurrentElem, CurrentGroup, gdcm::RefCounter::Delete(), gdcm::ExplicitVR, Filetype, FindDocEntryLength(), FindDocEntryVR(), gdcm::Util::Format(), Fp, gdcm::GDCM_VRUNKNOWN, gdcmWarningMacro, gdcm::DocEntrySet::GetDictEntry(), gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::Global::GetVR(), gdcm::DicomEntry::GetVR(), HandleBrokenEndian(), HandleOutOfGroup0002(), HasDCMPreamble, gdcm::DocEntrySet::NewDataEntry(), gdcm::DocEntrySet::NewSeqEntry(), ReadInt16(), gdcm::DocEntry::SetImplicitVR(), gdcm::DocEntry::SetOffset(), gdcm::DataEntry::STATE_NOTLOADED, and gdcm::RefCounter::Unregister(). Referenced by ParseDES(), and ParseSQ(). { try { CurrentGroup = ReadInt16(); CurrentElem = ReadInt16(); } catch ( FormatError ) { // We reached the EOF (or an error occured) therefore // header parsing has to be considered as finished. return 0; } // Sometimes file contains groups of tags with reversed endianess. HandleBrokenEndian(CurrentGroup, CurrentElem); // In 'true DICOM' files Group 0002 is always little endian if ( HasDCMPreamble ) HandleOutOfGroup0002(CurrentGroup, CurrentElem); VRKey vr = FindDocEntryVR(); VRKey realVR = vr; if ( vr == GDCM_VRUNKNOWN ) { if ( CurrentElem == 0x0000 ) // Group Length { realVR = "UL"; // must be UL } else if (CurrentGroup%2 == 1 && (CurrentElem >= 0x0010 && CurrentElem <=0x00ff )) { // DICOM PS 3-5 7.8.1 a) states that those // (gggg-0010->00FF where gggg is odd) attributes have to be LO realVR = "LO"; } else { DictEntry *dictEntry = GetDictEntry(CurrentGroup,CurrentElem); if ( dictEntry ) { realVR = dictEntry->GetVR(); dictEntry->Unregister(); } } } // gdcmDebugMacro( "Found VR: " << vr << " / Real VR: " << realVR ); DocEntry *newEntry; if ( Global::GetVR()->IsVROfSequence(realVR) ) newEntry = NewSeqEntry(CurrentGroup, CurrentElem); else { newEntry = NewDataEntry(CurrentGroup, CurrentElem, realVR); static_cast<DataEntry *>(newEntry)->SetState(DataEntry::STATE_NOTLOADED); } if ( vr == GDCM_VRUNKNOWN ) { if ( Filetype == ExplicitVR ) { // We thought this was explicit VR, but we end up with an // implicit VR tag. Let's backtrack. if ( newEntry->GetGroup() != 0xfffe ) { std::string msg; int offset = Fp->tellg(); msg = Util::Format( "Entry (%04x,%04x) at x(%x) should be Explicit VR\n", newEntry->GetGroup(), newEntry->GetElement(), offset ); gdcmWarningMacro( msg.c_str() ); } } newEntry->SetImplicitVR(); } try { FindDocEntryLength(newEntry); } catch ( FormatError ) { // Call it quits newEntry->Delete(); return 0; } newEntry->SetOffset(Fp->tellg()); return newEntry; }

void gdcm::RefCounter::Register (   )  [inline, inherited]

Register the object. Remarks: It increments the reference counting Definition at line 45 of file gdcmRefCounter.h. Referenced by gdcm::SQItem::AddEntry(), gdcm::ElementSet::AddEntry(), gdcm::Dict::AddEntry(), gdcm::SeqEntry::AddSQItem(), gdcm::DocEntry::DocEntry(), gdcm::FileHelper::FileHelper(), gdcm::DocEntrySet::GetDictEntry(), gdcm::DocEntryArchive::Push(), gdcm::Dict::ReplaceEntry(), and gdcm::SeqEntry::SetDelimitationItem(). { RefCount++; }

bool gdcm::ElementSet::RemoveEntry (  DocEntry *  entryToRemove  )  [virtual, inherited]

Clear the hash table from given entry AND delete the entry. Parameters: entryToRemove  Entry to remove AND delete. Implements gdcm::DocEntrySet. Definition at line 99 of file gdcmElementSet.cxx. References gdcmWarningMacro, gdcm::DocEntry::GetKey(), gdcm::ElementSet::TagHT, and gdcm::RefCounter::Unregister(). Referenced by Backtrack(), gdcm::File::DoTheLoadingJob(), gdcm::DicomDir::NewMeta(), ParseDES(), gdcm::DocEntryArchive::Push(), and gdcm::DocEntryArchive::Restore(). { const TagKey &key = entryToRemove->GetKey(); if ( TagHT.count(key) == 1 ) { TagHT.erase(key); entryToRemove->Unregister(); return true; } gdcmWarningMacro( "Key not present : " << key); return false ; }

bool gdcm::DocEntrySet::SetEntryBinArea (  uint8_t *  content, int  lgth, DataEntry *  entry )  [inherited]

Accesses an existing DataEntry (i.e. a Dicom Element) and modifies it's content with the given value. Parameters: content  new value (void* -> uint8_t*) to substitute with entry  Entry to be modified lgth  new value length Definition at line 229 of file gdcmDocEntrySet.cxx. References gdcm::DataEntry::SetBinArea(), and gdcm::DocEntry::SetLength(). { if (entry) { entry->SetLength(lgth); entry->SetBinArea(content); return true; } return false; }

bool gdcm::DocEntrySet::SetEntryBinArea (  uint8_t *  content, int  lgth, uint16_t  group, uint16_t  elem )  [inherited]

Accesses an existing DocEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value. Parameters: content  new value (void* -> uint8_t*) to substitute with lgth  new value length group  group number of the Dicom Element to modify elem  element number of the Dicom Element to modify Definition at line 192 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, and gdcm::DocEntrySet::GetDataEntry(). Referenced by gdcm::DocEntrySet::InsertEntryBinArea(), and gdcm::FileHelper::SetEntryBinArea(). { DataEntry *entry = GetDataEntry(group, elem); if (!entry ) { gdcmWarningMacro( "No corresponding DataEntry " << std::hex << group << "," << elem << " element (try promotion first)."); return false; } return SetEntryBinArea(content,lgth,entry); }

bool gdcm::DocEntrySet::SetEntryString (  std::string const &  content, DataEntry *  entry )  [inherited]

Accesses an existing DocEntry (i.e. a Dicom Element) and modifies it's content with the given value. Parameters: content  new value (string) to substitute with entry  Entry to be modified Definition at line 212 of file gdcmDocEntrySet.cxx. References gdcm::DataEntry::SetString(). { if (entry) { entry->SetString(content); return true; } return false; }

bool gdcm::DocEntrySet::SetEntryString (  std::string const &  content, uint16_t  group, uint16_t  elem )  [inherited]

Accesses an existing DocEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value. Parameters: content  new value (string) to substitute with group  group number of the Dicom Element to modify elem  element number of the Dicom Element to modify Definition at line 170 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, and gdcm::DocEntrySet::GetDataEntry(). Referenced by gdcm::File::AnonymizeFile(), DoTheLoadingDocumentJob(), gdcm::DocEntrySet::InsertEntryString(), and gdcm::FileHelper::SetEntryString(). { DataEntry *entry = GetDataEntry(group, elem); if (!entry ) { gdcmWarningMacro( "No corresponding DataEntry " << std::hex << group << "," << elem << " element (try promotion first)."); return false; } return SetEntryString(content,entry); }

virtual void gdcm::Document::SetFileName (  std::string const &  fileName  )  [inline, virtual]

Accessor to Filename. Reimplemented in gdcm::DicomDir. Definition at line 76 of file gdcmDocument.h. Referenced by gdcm::SerieHelper::AddFileName(), gdcm::DicomDir::CreateDicomDirChainedList(), Document(), and gdcm::FileHelper::SetFileName(). { if (Filename != fileName) Filename = fileName, IsDocumentModified = true; }

void gdcm::Document::SetLoadMode (  int  mode  )  [inline]

Sets the LoadMode as a boolean string. LD_NOSEQ, LD_NOSHADOW, LD_NOSHADOWSEQ ... (nothing more, right now) WARNING : before using NO_SHADOW, be sure *all* your files contain accurate values in the 0x0000 element (if any) of *each* Shadow Group. The parser will fail if the size is wrong ! Parameters: mode  Load mode to be used Definition at line 103 of file gdcmDocument.h. Referenced by gdcm::SerieHelper::AddFileName(), gdcm::DicomDir::CreateDicomDirChainedList(), and gdcm::FileHelper::SetLoadMode(). { if (LoadMode != mode) LoadMode=mode, IsDocumentModified = true; }

void gdcm::Document::SetMaxSizeLoadEntry (  long  newSize  )  [private]

during parsing, Header Elements too long are not loaded in memory Parameters: newSize  new size Definition at line 1965 of file gdcmDocument.cxx. References MaxSizeLoadEntry. Referenced by Document(). { if ( newSize < 0 ) { return; } if ((uint32_t)newSize >= (uint32_t)0xffffffff ) { MaxSizeLoadEntry = 0xffffffff; return; } MaxSizeLoadEntry = newSize; }

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

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

bool gdcm::Document::SetShaDict (  DictKey const &  dictName  )

Set the shadow dictionary used. Parameters: dictName  name of the dictionary to use in shadow Definition at line 327 of file gdcmDocument.cxx. References gdcm::DictSet::GetDict(), gdcm::Global::GetDicts(), and RefShaDict. { RefShaDict = Global::GetDicts()->GetDict(dictName); return !RefShaDict; }

bool gdcm::Document::SetShaDict (  Dict *  dict  )

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

void gdcm::Document::SkipBytes (  uint32_t  nBytes  )  [protected]

skips bytes inside the source file Returns: Definition at line 947 of file gdcmDocument.cxx. References Fp. Referenced by gdcm::File::ComputeJPEGFragmentInfo(), gdcm::File::ComputeRLEInfo(), FindDocEntryLengthOBOrOW(), and SkipDocEntry(). { //FIXME don't dump the returned value Fp->seekg((long)nBytes, std::ios::cur); }

void gdcm::Document::SkipDocEntry (  DocEntry *  entry  )  [private]

Skip a given Header Entry. Parameters: entry  entry to skip Definition at line 1585 of file gdcmDocument.cxx. References gdcm::DocEntry::GetLength(), and SkipBytes(). { SkipBytes(entry->GetLength()); }

void gdcm::Document::SkipToNextDocEntry (  DocEntry *  currentDocEntry  )  [private]

Skips to the beginning of the next Header Entry. Parameters: currentDocEntry  entry to skip Definition at line 1594 of file gdcmDocument.cxx. References Fp, gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetOffset(), and gdcm::DocEntry::GetReadLength(). Referenced by ParseDES(). { int l = currentDocEntry->GetReadLength(); if ( l == -1 ) // length = 0xffff shouldn't appear here ... // ... but PMS imagers happen ! return; Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg); if (currentDocEntry->GetGroup() != 0xfffe) // for fffe pb { Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur); } }

double gdcm::Document::SwapDouble (  double  a  )  [private]

Swaps back the bytes of 8-byte long 'double' accordingly to processor order. Returns: The properly swaped 64 bits double. Definition at line 534 of file gdcmDocument.cxx. References gdcmErrorMacro, and SwapCode. Referenced by LoadEntryBinArea(). { switch (SwapCode) { // There were no 'double' at ACR-NEMA time. // We just have to deal with 'straight Little Endian' and // 'straight Big Endian' case 1234 : break; case 4321 : { char *beg = (char *)&a; char *end = beg + 7; char t; for (unsigned int i = 0; i<7; i++) { t = *beg; *beg = *end; *end = t; beg++, end--; } } break; default : gdcmErrorMacro( "Unexpected swap code:" << SwapCode ); a = 0.; } return a; }

uint32_t gdcm::Document::SwapLong (  uint32_t  a  )  [private]

Swaps back the bytes of 4-byte long integer accordingly to processor order. Returns: The properly swaped 32 bits integer. Definition at line 502 of file gdcmDocument.cxx. References gdcmErrorMacro, and SwapCode. Referenced by LoadEntryBinArea(), and ReadInt32(). { switch (SwapCode) { case 1234 : break; case 4321 : // a=( ((a<<24) & 0xff000000) | ((a<<8) & 0x00ff0000) | // ((a>>8) & 0x0000ff00) | ((a>>24) & 0x000000ff) ); // save CPU time a=( ( a<<24) | ((a<<8) & 0x00ff0000) | ((a>>8) & 0x0000ff00) | (a>>24) ); break; case 3412 : // a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) ); a=( (a<<16) | (a>>16) ); break; case 2143 : a=( ((a<< 8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff) ); break; default : gdcmErrorMacro( "Unexpected swap code:" << SwapCode ); a = 0; } return a; }

uint16_t gdcm::Document::SwapShort (  uint16_t  a  )  [private]

Swaps the bytes so they agree with the processor order. Returns: The properly swaped 16 bits integer. Definition at line 486 of file gdcmDocument.cxx. References SwapCode. Referenced by HandleOutOfGroup0002(), LoadEntryBinArea(), and ReadInt16(). { if ( SwapCode == 4321 || SwapCode == 2143 ) { //a = ((( a << 8 ) & 0xff00 ) | (( a >> 8 ) & 0x00ff ) ); // Save CPU time a = ( a << 8 ) | ( a >> 8 ); } return a; }

void gdcm::Document::SwitchByteSwapCode (   )  [private]

Change the Byte Swap code. Definition at line 1938 of file gdcmDocument.cxx. References Fp, gdcmDebugMacro, and SwapCode. Referenced by HandleBrokenEndian(), and HandleOutOfGroup0002(). { gdcmDebugMacro( "Switching Byte Swap code from "<< SwapCode << " at: 0x" << std::hex << Fp->tellg() ); if ( SwapCode == 1234 ) { SwapCode = 4321; } else if ( SwapCode == 4321 ) { SwapCode = 1234; } else if ( SwapCode == 3412 ) { SwapCode = 2143; } else if ( SwapCode == 2143 ) { SwapCode = 3412; } gdcmDebugMacro( " Into: "<< SwapCode ); }

void gdcm::RefCounter::Unregister (   )  [inline, inherited]

Unregister the object. Remarks: It decrements the reference counting Definition at line 49 of file gdcmRefCounter.h. Referenced by gdcm::SeqEntry::ClearSQItem(), gdcm::DocEntrySet::GetDictEntry(), gdcm::DocEntrySet::NewDataEntry(), gdcm::DocEntrySet::NewSeqEntry(), ReadNextDocEntry(), gdcm::SQItem::RemoveEntry(), gdcm::ElementSet::RemoveEntry(), gdcm::SeqEntry::SetDelimitationItem(), gdcm::DocEntry::~DocEntry(), and gdcm::FileHelper::~FileHelper(). { RefCount--; if(RefCount<=0) delete this; }

uint32_t gdcm::Document::UnswapLong (  uint32_t  a  )  [inline, private]

Unswaps back the bytes of 4-byte long integer so they agree with the processor order. Definition at line 189 of file gdcmDocument.h. { return SwapLong(a);}

uint16_t gdcm::Document::UnswapShort (  uint16_t  a  )  [inline, private]

Unswaps back the bytes of 2-bytes long integer so they agree with the processor order. Definition at line 186 of file gdcmDocument.h. { return SwapShort(a);}

void gdcm::Document::WriteContent (  std::ofstream *  fp, FileType  filetype )  [virtual]

Writes in a file all the Entries (Dicom Elements). Parameters: fp  file pointer on an already open file (actually: Output File Stream) filetype  Type of the File to be written (ACR-NEMA, ExplicitVR, ImplicitVR) Reimplemented from gdcm::ElementSet. Definition at line 675 of file gdcmDocument.cxx. References gdcm::ExplicitVR, gdcm::ImplicitVR, gdcm::JPEG, and gdcm::ElementSet::WriteContent(). Referenced by gdcm::File::Write(). { // Skip if user wants to write an ACR-NEMA file if ( filetype == ImplicitVR || filetype == ExplicitVR || filetype == JPEG ) { // writing Dicom File Preamble char filePreamble[128]; memset(filePreamble, 0, 128); fp->write(filePreamble, 128); fp->write("DICM", 4); } /* * \todo rewrite later, if really usefull * - 'Group Length' element is optional in DICOM * - but un-updated odd groups lengthes can causes pb * (xmedcon breaker) * * if ( (filetype == ImplicitVR) || (filetype == ExplicitVR) ) * UpdateGroupLength(false,filetype); * if ( filetype == ACR) * UpdateGroupLength(true,ACR); * * --> Computing group length for groups with embeded Sequences * --> was too much tricky / we were [in a hurry / too lazy] * --> We don't write the element 0x0000 (group length) */ ElementSet::WriteContent(fp, filetype); // This one is recursive }

---

Member Data Documentation

uint16_t gdcm::Document::CurrentElem [private]

to allow any inner method to know current tag Element number Definition at line 234 of file gdcmDocument.h. Referenced by ReadNextDocEntry().

uint16_t gdcm::Document::CurrentGroup [private]

to allow any inner method to know current tag Group number Definition at line 232 of file gdcmDocument.h. Referenced by FindDocEntryVR(), and ReadNextDocEntry().

std::string gdcm::Document::Filename [protected]

Refering underlying filename. Definition at line 121 of file gdcmDocument.h. Referenced by gdcm::File::AnonymizeNoLoad(), DoTheLoadingDocumentJob(), Load(), and OpenFile().

FileType gdcm::Document::Filetype [protected]

ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown. Definition at line 147 of file gdcmDocument.h. Referenced by CheckSwap(), Document(), DoTheLoadingDocumentJob(), FindDocEntryVR(), GetFileType(), HandleOutOfGroup0002(), Initialize(), IsParsable(), gdcm::DicomDir::IsReadable(), and ReadNextDocEntry().

std::ifstream* gdcm::Document::Fp [protected]

File Pointer, opened during Document parsing. Definition at line 144 of file gdcmDocument.h. Referenced by Backtrack(), CheckSwap(), CloseFile(), gdcm::File::ComputeJPEGFragmentInfo(), gdcm::File::ComputeRLEInfo(), Document(), DoTheLoadingDocumentJob(), gdcm::File::DoTheLoadingJob(), gdcm::DicomDir::DoTheLoadingJob(), FindDocEntryLengthOBOrOW(), FindDocEntryVR(), IsDocEntryAnInteger(), LoadDocEntry(), LoadDocEntrySafe(), LoadEntryBinArea(), OpenFile(), ParseDES(), ParseSQ(), gdcm::File::ReadEncapsulatedBasicOffsetTable(), ReadInt16(), ReadInt32(), ReadNextDocEntry(), gdcm::File::ReadTag(), gdcm::File::ReadTagLength(), SkipBytes(), SkipToNextDocEntry(), and SwitchByteSwapCode().

bool gdcm::Document::Group0002Parsed [protected]

whether we already parsed group 0002 (Meta Elements) Definition at line 138 of file gdcmDocument.h. Referenced by Document(), DoTheLoadingDocumentJob(), and HandleOutOfGroup0002().

bool gdcm::Document::HasDCMPreamble [protected]

whether file has a DCM Preamble Definition at line 141 of file gdcmDocument.h. Referenced by OpenFile(), and ReadNextDocEntry().

const unsigned int gdcm::Document::HEADER_LENGTH_TO_READ [static, protected]

After opening the file, we read HEADER_LENGTH_TO_READ bytes. Definition at line 150 of file gdcmDocument.h.

bool gdcm::Document::IsDocumentAlreadyLoaded [protected]

Whether the gdcm::Document is already parsed/loaded : False from the creation of the gdcm::Document untill gdcm::Document:Load(). Definition at line 170 of file gdcmDocument.h. Referenced by Document(), and DoTheLoadingDocumentJob().

bool gdcm::Document::IsDocumentModified [protected]

Whether the gdcm::Document was modified since the last Load(). Definition at line 173 of file gdcmDocument.h. Referenced by Document(), and DoTheLoadingDocumentJob().

int gdcm::Document::LoadMode [protected]

Bit string integer (each one considered as a boolean) Bit 0 : Skip Sequences, if possible Bit 1 : Skip Shadow Groups if possible Probabely, some more to add. Definition at line 165 of file gdcmDocument.h. Referenced by gdcm::DicomDir::CreateDicomDirChainedList(), Document(), and ParseDES().

const unsigned int gdcm::Document::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff [static, protected]

Elements whose value is longer than MAX_SIZE_LOAD_ELEMENT_VALUE are NOT loaded. Definition at line 153 of file gdcmDocument.h. Referenced by Document().

uint32_t gdcm::Document::MaxSizeLoadEntry [private]

Size threshold above which an element value will NOT be loaded in memory (to avoid loading the image/volume itself). By default, this upper bound is fixed to 1024 bytes (which might look reasonable when one considers the definition of the various VR contents). Definition at line 229 of file gdcmDocument.h. Referenced by LoadDocEntry(), and SetMaxSizeLoadEntry().

DocEntry* gdcm::DocEntrySet::PreviousDocEntry [protected, inherited]

To be able to backtrack (Private Sequence, Implicit VR related pb). Definition at line 124 of file gdcmDocEntrySet.h. Referenced by Backtrack(), gdcm::DocEntrySet::DocEntrySet(), and ParseDES().

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

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

Dict* gdcm::Document::RefPubDict [private]

Public dictionary used to parse this header. Definition at line 220 of file gdcmDocument.h. Referenced by GetPubDict(), and Initialize().

Dict* gdcm::Document::RefShaDict [private]

Optional "shadow dictionary" (private elements) used to parse this header. Definition at line 223 of file gdcmDocument.h. Referenced by GetShaDict(), Initialize(), and SetShaDict().

int gdcm::Document::SwapCode [protected]

Swap code gives an information on the byte order of a supposed to be an int32, as it's read on disc (depending on the image Transfer Syntax *and* on the processor endianess) as opposed as it should in memory to be dealt as an int32. For instance : a 'Little Endian' image, read with a little endian processor will have a SwapCode= 1234 (the order is OK; nothing to do) a 'Little Endian' image, read with a big endian procesor will have a SwapCode= 4321 (the order is wrong; int32 an int16 must be swapped) note : values 2143, 4321, 3412 remain for the ACR-NEMA time, and the well known 'Bad Big Endian' and 'Bad Little Endian' codes. Definition at line 135 of file gdcmDocument.h. Referenced by CheckSwap(), Document(), SwapDouble(), SwapLong(), SwapShort(), and SwitchByteSwapCode().

ListElements gdcm::Document::UserAnonymizeList [protected]

User supplied list of elements to Anonymize. Definition at line 156 of file gdcmDocument.h. Referenced by gdcm::File::AddAnonymizeElement(), gdcm::File::AnonymizeFile(), and gdcm::File::AnonymizeNoLoad().

ListElements gdcm::Document::UserForceLoadList [protected]

User supplied list of elements to force Load. Definition at line 159 of file gdcmDocument.h. Referenced by AddForceLoadElement(), and DoTheLoadingDocumentJob().

---

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

• gdcmDocument.h
• gdcmDocument.cxx

---