gdcm::Document Class Reference

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

#include <gdcmDocument.h>

Inheritance diagram for gdcm::Document:

List of all members.

Public Types
typedef std::list< Element >	ListElements
Public Member Functions
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.
virtual bool	IsReadable ()
	This predicate, based on hopefully reasonable heuristics, decides whether or not the current Document was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File.
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 )
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.
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.
const std::string &	GetFileName () const
	Accessor to Filename.
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 Header 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 (BinEntry *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.
bool	operator< (Document &document)
	Compares two documents, according to DicomDir rules.
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.
bool	RemoveEntryNoDestroy (DocEntry *EntryToRemove)
	Clear the hash table from given entry BUT keep 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	GetEntryValue (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	GetEntryVR (uint16_t group, uint16_t elem)
	Searches within Header Entries (Dicom Elements) parsed with the public [and private dictionaries] for the element value representation of a given tag.. Obtaining the VR (Value Representation) might be needed by caller to convert the string typed content to caller's native type (think of C++ vs Python). The VR is actually of a higher level of semantics than just the native C++ type.
ValEntry *	GetValEntry (uint16_t group, uint16_t elem)
	Same as Document::GetDocEntry except it only returns a result when the corresponding entry is of type ValEntry.
BinEntry *	GetBinEntry (uint16_t group, uint16_t elem)
	Same as Document::GetDocEntry except it only returns a result when the corresponding entry is of type BinEntry.
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	SetValEntry (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	SetValEntry (std::string const &content, ValEntry *entry)
	Accesses an existing DocEntry (i.e. a Dicom Element) and modifies it's content with the given value.
bool	SetBinEntry (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	SetBinEntry (uint8_t *content, int lgth, BinEntry *entry)
	Accesses an existing BinEntry (i.e. a Dicom Element) and modifies it's content with the given value.
ValEntry *	InsertValEntry (std::string const &value, uint16_t group, uint16_t elem, TagName const &vr=GDCM_UNKNOWN)
	Modifies the value of a given Doc Entry (Dicom Element) when it exists. Create it with the given value when unexistant.
BinEntry *	InsertBinEntry (uint8_t *binArea, int lgth, uint16_t group, uint16_t elem, TagName const &vr=GDCM_UNKNOWN)
	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.
ValEntry *	NewValEntry (uint16_t group, uint16_t elem, TagName const &vr=GDCM_UNKNOWN)
	Build a new Val Entry from all the low level arguments. Check for existence of dictionary entry, and build a default one when absent.
BinEntry *	NewBinEntry (uint16_t group, uint16_t elem, TagName const &vr=GDCM_UNKNOWN)
	Build a new Bin 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.
DictEntry *	NewVirtualDictEntry (uint16_t group, uint16_t elem, TagName const &vr=GDCM_UNKNOWN, TagName const &vm=GDCM_UNKNOWN, TagName const &name=GDCM_UNKNOWN)
	Request a new virtual dict entry to the dict set.
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 doesn't parse the file. You should then invoke Document::SetFileName and then the parsing.
	Document (std::string const &filename)
	constructor
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 (FileType filetype)
	Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader.
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.
DictEntry *	GetDictEntry (uint16_t group, uint16_t elem, TagName 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	AnonymizeList
	List of element to Anonymize.
int	PrintLevel
	Amount of printed details for each Dicom Entries : 0 : stands for the least detail level.
Static Protected Attributes
const unsigned int	HEADER_LENGTH_TO_READ
	After opening the file, we read HEADER_LENGTH_TO_READ bytes.
const unsigned int	MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff
	Elements whose value is longer than MAX_SIZE_LOAD_ELEMENT_VALUE are NOT loaded.
const unsigned int	MAX_SIZE_PRINT_ELEMENT_VALUE = 0x7fffffff
	Elements whose value is longer than MAX_SIZE_PRINT_ELEMENT_VALUE are NOT printed.
Private Member Functions
void	Initialize ()
	Loads all the needed Dictionaries.
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)
	Loads the element content if its length doesn't exceed the value specified with Document::SetMaxSizeLoadEntry().
void	FindDocEntryLength (DocEntry *e) throw ( FormatError )
	Find the value Length of the passed Header Entry.
uint32_t	FindDocEntryLengthOBOrOW () throw ( FormatUnexpected )
	Find the Length till the next sequence delimiter.
std::string	FindDocEntryVR ()
	Find the Value Representation of the current Dicom Element.
bool	CheckDocEntryVR (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.
std::string	GetDocEntryValue (DocEntry *entry)
	Get the transformed value of the header entry. The VR value is used to define the transformation to operate on the value.
std::string	GetDocEntryUnvalue (DocEntry *entry)
	Get the reverse transformed value of the header entry. The VR value is used to define the reverse transformation to operate on the value.
void	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
void	SetMaxSizePrintEntry (long)
	Header Elements too long will not be printed.
DocEntry *	ReadNextDocEntry ()
	Read the next tag but 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 switch 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.
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).
uint32_t	MaxSizePrintEntry
	Size threshold above which an element value will NOT be *printed* in order no to polute the screen output. By default, this upper bound is fixed to 64 bytes.

---

Detailed Description

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

Definition at line 43 of file gdcmDocument.h.

---

Member Typedef Documentation

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

Definition at line 47 of file gdcmDocument.h.

---

Constructor & Destructor Documentation

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

This default constructor doesn't parse the file. You should then invoke Document::SetFileName and then the parsing. Definition at line 157 of file gdcmDocument.cxx. References gdcm::ExplicitVR, Filetype, Fp, Group0002Parsed, Initialize(), MAX_SIZE_LOAD_ELEMENT_VALUE, SetMaxSizeLoadEntry(), and SwapCode. :ElementSet(-1) { Fp = 0; SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); Initialize(); SwapCode = 1234; Filetype = ExplicitVR; Group0002Parsed = false; }

gdcm::Document::Document (  std::string const &  filename  )  [protected]

constructor Parameters: filename  'Document' (File or DicomDir) to be opened for parsing FIXME FIXME FIXME 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 decided 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 61 of file gdcmDocument.cxx. References gdcm::ACR_LIBIDO, CheckSwap(), CloseFile(), Filetype, Fp, gdcmWarningMacro, gdcm::DocEntrySet::GetEntryValue(), Group0002Parsed, Initialize(), LoadEntryBinArea(), MAX_SIZE_LOAD_ELEMENT_VALUE, OpenFile(), ParseDES(), SetMaxSizeLoadEntry(), and gdcm::DocEntrySet::SetValEntry(). :ElementSet(-1) { SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); Filename = filename; Initialize(); Fp = 0; if ( !OpenFile() ) { return; } Group0002Parsed = false; gdcmWarningMacro( "Starting parsing of file: " << Filename.c_str()); Fp->seekg(0, std::ios::end); long lgt = Fp->tellg(); Fp->seekg(0, std::ios::beg); CheckSwap(); long beg = Fp->tellg(); lgt -= beg; ParseDES( this, beg, lgt, false); // Loading is done during parsing Fp->seekg( 0, std::ios::beg); // Load 'non string' values std::string PhotometricInterpretation = GetEntryValue(0x0028,0x0004); if( PhotometricInterpretation == "PALETTE COLOR " ) { LoadEntryBinArea(0x0028,0x1200); // gray LUT 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? LoadEntryBinArea(0x0028,0x3006); //LUT Data (CTX dependent) 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 years) // we keep this kludge to allow a smooth move to gdcm for // CREATIS developpers (sorry folks). // // if recognition code tells us we deal with a LibIDO image // we switch lineNumber and columnNumber // std::string RecCode; RecCode = GetEntryValue(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 = GetEntryValue(0x0028, 0x0010); std::string columns = GetEntryValue(0x0028, 0x0011); SetValEntry(columns, 0x0028, 0x0010); SetValEntry(rows , 0x0028, 0x0011); } // --- End of ACR-LibIDO kludge --- }

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

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

---

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 69 of file gdcmElementSet.cxx. References gdcmWarningMacro, gdcm::DocEntry::GetKey(), gdcm::ElementSet::TagHT, and gdcm::TagKey. Referenced by gdcm::File::File(), gdcm::DocEntryArchive::Push(), and gdcm::DocEntryArchive::Restore(). { const TagKey &key = newEntry->GetKey(); if( TagHT.count(key) == 1 ) { gdcmWarningMacro( "Key already present: " << key.c_str()); return false; } else { TagHT.insert(TagDocEntryHT::value_type(newEntry->GetKey(), newEntry)); return true; } }

bool gdcm::Document::CheckDocEntryVR (  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 of if the VR isn't referenced otherwise, it returns true Definition at line 1439 of file gdcmDocument.cxx. References gdcm::VRKey. Referenced by FindDocEntryVR(). { if ( !Global::GetVR()->IsValidVR(vr) ) return false; return true; }

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 434 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 1725 of file gdcmDocument.cxx. References gdcm::ACR, gdcm::ExplicitVR, Filetype, Fp, gdcmWarningMacro, gdcm::ImplicitVR, SwapCode, and gdcm::Unknown. Referenced by Document(). { // The only guaranted way of finding the swap code is to find a // group tag since we know it's length has to be of four bytes i.e. // 0x00000004. Finding the swap code in then straigthforward. Trouble // occurs when we can't find such group... uint32_t x = 4; // x : for ntohs bool net2host; // true when HostByteOrder is the same as NetworkByteOrder 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). if ( x == ntohs(x) ) { net2host = true; } else { net2host = false; } // 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 ) { gdcmWarningMacro( "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; gdcmWarningMacro( "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; gdcmWarningMacro( "HostByteOrder != NetworkByteOrder"); } else { SwapCode = 1234; gdcmWarningMacro( "HostByteOrder = NetworkByteOrder"); } // Position the file position indicator at first tag // (i.e. after the file preamble and the "DICM" string). Fp->seekg(0, std::ios::beg); 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 DICOM Version3 file"); Fp->seekg(0, std::ios::beg); // Our next best chance would be to be considering a 'clean' ACR/NEMA file. // By clean we mean that the length of the first tag is written down. // If this is the case and since the length of the first group HAS to be // four (bytes), then determining the proper swap code is straightforward. entCur = deb + 4; // We assume the array of char we are considering contains the binary // representation of a 32 bits integer. Hence the following dirty // trick : s32 = *((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 (Really hopeless !)"); Filetype = Unknown; return false; } } }

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

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

bool gdcm::Document::CloseFile (   )

closes the file Returns: TRUE if the close was successfull Definition at line 464 of file gdcmDocument.cxx. References Fp. Referenced by Document(), gdcm::File::File(), gdcm::FileHelper::GetRaw(), LoadEntryBinArea(), and OpenFile(). { if( Fp ) { Fp->close(); delete Fp; Fp = 0; } return true; //FIXME how do we detect a non-closed ifstream ? }

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

Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader. Parameters: filetype  Type of the File to be written Definition at line 717 of file gdcmDocument.cxx. References gdcm::ExplicitVR, 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; std::string 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( filetype == ExplicitVR ) { if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) { // explicit VR AND OB, OW, SQ : 4 more bytes groupLength += 4; } } groupLength += 2 + 2 + 4 + entry->GetLength(); } } else if (found0002 ) break; entry = GetNextEntry(); } return groupLength; }

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

Find the value Length of the passed Header Entry. Parameters: entry  Header Entry whose length of the value shall be loaded. Definition at line 1201 of file gdcmDocument.cxx. References gdcm::ExplicitVR. Referenced by ReadNextDocEntry(). { std::string vr = entry->GetVR(); uint16_t length16; if ( Filetype == ExplicitVR && !entry->IsImplicitVR() ) { if ( vr == "OB" || vr == "OW" || vr == "SQ" || 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. 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(); // FIXME : This heuristic supposes that the first group following // group 0002 *has* and element 0000. // BUT ... Element 0000 is optionnal :-( // Fixed using : HandleOutOfGroup0002() // (first hereafter strategy ...) // We can tell the current file is encoded in big endian (like // Data/US-RGB-8-epicard) when we find the "Transfer Syntax" tag // and it's value is the one of the encoding of a big endian file. // In order to deal with such big endian encoded files, we have // (at least) two strategies: // * when we load the "Transfer Syntax" tag with value of big endian // encoding, we raise the proper flags. Then we wait for the end // of the META group (0x0002) among which is "Transfer Syntax", // before switching the swap code to big endian. We have to postpone // the switching of the swap code since the META group is fully encoded // in little endian, and big endian coding only starts at the next // group. The corresponding code can be hard to analyse and adds // many additional unnecessary tests for regular tags. // * the second strategy consists in waiting for trouble, that shall // appear when we find the first group with big endian encoding. This // is easy to detect since the length of a "Group Length" tag (the // ones with zero as element number) has to be of 4 (0x0004). When we // encounter 1024 (0x0400) chances are the encoding changed and we // found a group with big endian encoding. //---> Unfortunately, element 0000 is optional. //---> This will not work when missing! // We shall use this second strategy. In order to make sure that we // can interpret the presence of an apparently big endian encoded // length of a "Group Length" without committing a big mistake, we // add an additional check: we look in the already parsed elements // for the presence of a "Transfer Syntax" whose value has to be "big // endian encoding". When this is the case, chances are we have got our // hands on a big endian encoded file: we switch the swap code to // big endian and proceed... // if ( element == 0x0000 && length16 == 0x0400 ) // { // std::string ts = GetTransferSyntax(); // if ( Global::GetTS()->GetSpecialTransferSyntax(ts) // != TS::ExplicitVRBigEndian ) // { // throw FormatError( "Document::FindDocEntryLength()", // " not explicit VR." ); // return; // } // length16 = 4; // SwitchByteSwapCode(); // // // Restore the unproperly loaded values i.e. the group, the element // // and the dictionary entry depending on them. // uint16_t correctGroup = SwapShort( entry->GetGroup() ); // uint16_t correctElem = SwapShort( entry->GetElement() ); // DictEntry *newTag = GetDictEntry( correctGroup, correctElem ); // if ( !newTag ) // { // // This correct tag is not in the dictionary. Create a new one. // newTag = NewVirtualDictEntry(correctGroup, correctElem); // } // // FIXME this can create a memory leaks on the old entry that be // // left unreferenced. // entry->SetDictEntry( newTag ); // } // 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 ...' FixDocEntryFoundLength( entry, ReadInt32() ); return; } }

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

Find the Length till the next sequence delimiter. Warning: NOT end user intended method ! Returns: Definition at line 1349 of file gdcmDocument.cxx. References gdcmWarningMacro. { // 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; }

std::string gdcm::Document::FindDocEntryVR (   )  [private]

Find the Value Representation of the current Dicom Element. Returns: Value Representation of the current Entry Definition at line 1405 of file gdcmDocument.cxx. References CheckDocEntryVR(), gdcm::ExplicitVR, Filetype, Fp, and gdcm::GDCM_UNKNOWN. Referenced by ReadNextDocEntry(). { if ( Filetype != ExplicitVR ) return GDCM_UNKNOWN; 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. Alas this // doesn't guarantee that all the tags will be in explicit VR. In some // cases (see e-film filtered files) one finds implicit VR tags mixed // within an explicit VR file. Hence we make sure the present tag // is in explicit VR and try to fix things if it happens not to be // the case. char vr[3]; Fp->read (vr, (size_t)2); vr[2] = 0; if( !CheckDocEntryVR(vr) ) { Fp->seekg(positionOnEntry, std::ios::beg); return GDCM_UNKNOWN; } 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 Todo: a bug is to be fixed !? a bug is to be fixed !? Definition at line 1606 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: XMedCom 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); } } // 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); } 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; } } entry->SetLength(foundLength); }

BinEntry * gdcm::DocEntrySet::GetBinEntry (  uint16_t  group, uint16_t  elem )  [inherited]

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

DictEntry * gdcm::DocEntrySet::GetDictEntry (  uint16_t  group, uint16_t  elem, TagName 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  Value Representation to use, if necessary Returns: Corresponding DictEntry when it exists, NULL otherwise. Definition at line 558 of file gdcmDocEntrySet.cxx. References gdcm::GDCM_UNKNOWN, gdcm::DocEntrySet::GetDictEntry(), gdcm::DictEntry::GetName(), gdcm::DictEntry::GetVR(), gdcm::DocEntrySet::NewVirtualDictEntry(), and gdcm::TagName. { DictEntry *dictEntry = GetDictEntry(group,elem); DictEntry *goodEntry = dictEntry; std::string goodVR = vr; if (elem == 0x0000) goodVR="UL"; if ( goodEntry ) { if ( goodVR != goodEntry->GetVR() && goodVR != GDCM_UNKNOWN ) { goodEntry = NULL; } } // Create a new virtual DictEntry if necessary if (!goodEntry) { if (dictEntry) { goodEntry = NewVirtualDictEntry(group, elem, goodVR, "FIXME", dictEntry->GetName() ); } else { goodEntry = NewVirtualDictEntry(group, elem, goodVR); } } 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. Parameters: group  group number of the searched DictEntry elem  element number of the searched DictEntry Returns: Corresponding DictEntry when it exists, NULL otherwise. Definition at line 534 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, and gdcm::Dict::GetEntry(). Referenced by gdcm::DocEntrySet::GetDictEntry(), gdcm::DocEntrySet::NewBinEntry(), gdcm::DocEntrySet::NewSeqEntry(), gdcm::DocEntrySet::NewValEntry(), 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); } 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 172 of file gdcmElementSet.cxx. References gdcm::ElementSet::TagHT, and gdcm::TagKey. Referenced by gdcm::File::AnonymizeFile(), gdcm::File::AnonymizeNoLoad(), gdcm::FileHelper::CopyBinEntry(), gdcm::FileHelper::CopyValEntry(), gdcm::DicomDir::CreateDicomDir(), gdcm::DicomDir::DicomDir(), gdcm::File::File(), gdcm::File::GetPixelAreaLength(), gdcm::File::GetPixelOffset(), GetTransferSyntax(), gdcm::File::HasLUT(), IsDicomV3(), IsPapyrus(), gdcm::File::IsReadable(), LoadEntryBinArea(), gdcm::DocEntryArchive::Push(), gdcm::DocEntryArchive::Restore(), gdcm::FileHelper::SetWriteToLibido(), gdcm::FileHelper::SetWriteToNoLibido(), and gdcm::File::Write(). { TagKey key = DictEntry::TranslateToKey(group, elem); TagDocEntryHT::iterator it = TagHT.find(key); if ( it!=TagHT.end() ) return it->second; return NULL; }

std::string gdcm::Document::GetDocEntryUnvalue (  DocEntry *  entry  )  [private]

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

std::string gdcm::Document::GetDocEntryValue (  DocEntry *  entry  )  [private]

Get the transformed value of the header entry. The VR value is used to define the transformation to operate on the value. Warning: NOT end user intended method ! Parameters: entry  entry to tranform Returns: Transformed entry value Definition at line 1454 of file gdcmDocument.cxx. References gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetVR(), IsDocEntryAnInteger(), gdcm::DocEntry::IsImplicitVR(), SwapLong(), and SwapShort(). { if ( IsDocEntryAnInteger(entry) && entry->IsImplicitVR() ) { std::string val = ((ValEntry *)entry)->GetValue(); std::string vr = entry->GetVR(); uint32_t length = entry->GetLength(); std::ostringstream s; int nbInt; // When short integer(s) are expected, read and convert the following // n * 2 bytes properly i.e. as a multivaluated strings // (each single value is separated fromthe next one by '\' // as usual for standard multivaluated filels // Elements with Value Multiplicity > 1 // contain a set of short integers (not a single one) if( vr == "US" || vr == "SS" ) { uint16_t newInt16; nbInt = length / 2; for (int i=0; i < nbInt; i++) { if( i != 0 ) { s << '\\'; } newInt16 = ( val[2*i+0] & 0xFF ) + ( ( val[2*i+1] & 0xFF ) << 8); newInt16 = SwapShort( newInt16 ); s << newInt16; } } // When integer(s) are expected, read and convert the following // n * 4 bytes properly i.e. as a multivaluated strings // (each single value is separated fromthe next one by '\' // as usual for standard multivaluated filels // Elements with Value Multiplicity > 1 // contain a set of integers (not a single one) else if( vr == "UL" || vr == "SL" ) { uint32_t newInt32; nbInt = length / 4; for (int i=0; i < nbInt; i++) { if( i != 0) { s << '\\'; } newInt32 = ( val[4*i+0] & 0xFF ) + (( val[4*i+1] & 0xFF ) << 8 ) + (( val[4*i+2] & 0xFF ) << 16 ) + (( val[4*i+3] & 0xFF ) << 24 ); newInt32 = SwapLong( newInt32 ); s << newInt32; } } #ifdef GDCM_NO_ANSI_STRING_STREAM s << std::ends; // to avoid oddities on Solaris #endif //GDCM_NO_ANSI_STRING_STREAM return s.str(); } return ((ValEntry *)entry)->GetValue(); }

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 57 of file gdcmDocEntrySet.cxx. References gdcm::BinEntry::GetBinArea(), and gdcm::DocEntrySet::GetBinEntry(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { BinEntry *entry = GetBinEntry(group, elem); if( entry ) return entry->GetBinArea(); return 0; }

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 73 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::GetEntryValue (  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 ("gdcm::Unfound") otherwise. Definition at line 43 of file gdcmDocEntrySet.cxx. References gdcm::GDCM_UNFOUND, gdcm::DocEntrySet::GetDocEntry(), and gdcm::ContentEntry::GetValue(). Referenced by gdcm::SerieHelper::AddFileName(), gdcm::File::AnonymizeFile(), Document(), gdcm::File::File(), gdcm::File::GetBitsAllocated(), gdcm::File::GetBitsStored(), gdcm::File::GetHighBitPosition(), gdcm::File::GetImageNumber(), gdcm::File::GetImageOrientationPatient(), gdcm::File::GetLUTNbits(), gdcm::File::GetModality(), gdcm::File::GetNumberOfScalarComponents(), gdcm::File::GetPixelType(), gdcm::File::GetPlanarConfiguration(), gdcm::File::GetRescaleIntercept(), gdcm::File::GetRescaleSlope(), gdcm::File::GetSamplesPerPixel(), GetTransferSyntaxName(), 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::PixelReadConvert::GrabInformationsFromFile(), gdcm::File::IsMonochrome(), gdcm::File::IsPaletteColor(), gdcm::File::IsReadable(), gdcm::File::IsSignedPixelData(), gdcm::File::IsYBRFull(), operator<(), gdcm::DicomDir::SetElement(), and gdcm::File::Write(). { ContentEntry *entry = dynamic_cast<ContentEntry *>(GetDocEntry(group,elem)); if( entry ) return entry->GetValue(); return GDCM_UNFOUND; }

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

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

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

Accessor to Filename. Definition at line 79 of file gdcmDocument.h. Referenced by gdcm::SerieHelper::FileNameLessThan(), 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 276 of file gdcmDocument.cxx. References Filetype, and gdcm::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 142 of file gdcmElementSet.cxx. References gdcm::ElementSet::ItTagHT, and gdcm::ElementSet::TagHT. Referenced by ComputeGroup0002Length(), gdcm::DicomDir::DicomDir(), and gdcm::DicomDir::NewMeta(). { 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 156 of file gdcmElementSet.cxx. References gdcmAssertMacro, gdcm::ElementSet::ItTagHT, and gdcm::ElementSet::TagHT. Referenced by ComputeGroup0002Length(). { 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 48 of file gdcmBase.h. { return PrintLevel; };

Dict * gdcm::Document::GetPubDict (   )

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

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 148 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, and gdcm::DocEntrySet::GetDocEntry(). { DocEntry *currentEntry = GetDocEntry(group, elem); if ( !currentEntry ) { gdcmWarningMacro( "No corresponding SeqEntry " << std::hex << group << "," << elem); return NULL; } return dynamic_cast<SeqEntry*>(currentEntry); }

Dict * gdcm::Document::GetShaDict (   )

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

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

'Swap code' accessor (see SwapCode ) Definition at line 66 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. Definition at line 287 of file gdcmDocument.cxx. References gdcm::GDCM_UNKNOWN, gdcm::ElementSet::GetDocEntry(), gdcm::ContentEntry::GetValue(), and LoadDocEntrySafe(). Referenced by gdcm::File::ComputeJPEGFragmentInfo(), gdcm::File::ComputeRLEInfo(), gdcm::File::File(), 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 (ValEntry *valEntry = dynamic_cast< ValEntry* >(entry) ) { std::string transfer = valEntry->GetValue(); // 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 return GDCM_UNKNOWN; } while ( !isdigit((unsigned char)transfer[transfer.length()-1]) ) { transfer.erase(transfer.length()-1, 1); } 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 322 of file gdcmDocument.cxx. References gdcm::GDCM_NOTLOADED, gdcm::GDCM_UNFOUND, gdcmErrorMacro, gdcmWarningMacro, gdcm::DocEntrySet::GetEntryValue(), and gdcm::TSKey. Referenced by HandleOutOfGroup0002(). { // use the TS (TS : Transfer Syntax) std::string transferSyntax = GetEntryValue(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 ) { gdcmWarningMacro( "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; }

ValEntry * gdcm::DocEntrySet::GetValEntry (  uint16_t  group, uint16_t  elem )  [inherited]

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

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

Handle broken private tag from Philips NTSCAN where the endianess is being switch to BigEndian for no apparent reason. Returns: no return Definition at line 2052 of file gdcmDocument.cxx. References 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 reversedEndian++; SwitchByteSwapCode(); // fix the tag group = 0xfffe; elem = 0xe000; } else if (group == 0xfffe && elem == 0xe00d && reversedEndian) { // end of reversed endian group reversedEndian--; SwitchByteSwapCode(); } }

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 2079 of file gdcmDocument.cxx. References Filetype, gdcmWarningMacro, GetTransferSyntax(), GetTransferSyntaxName(), 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 ( !Global::GetTS()->IsTransferSyntax(ts) ) { gdcmWarningMacro("True DICOM File, with NO Tansfer Syntax: " << ts ); return; } // Group 0002 is always 'Explicit ...' enven when Transfer Syntax says 'Implicit ..." if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian ) { Filetype = ImplicitVR; } // FIXME Strangely, this works with //'Implicit VR Transfer Syntax (GE Private) if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian ) { gdcmWarningMacro("Transfer Syntax Name = [" << GetTransferSyntaxName() << "]" ); SwitchByteSwapCode(); group = SwapShort(group); elem = SwapShort(elem); } } }

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

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

BinEntry * gdcm::DocEntrySet::InsertBinEntry (  uint8_t *  binArea, int  lgth, uint16_t  group, uint16_t  elem, TagName const &  vr = GDCM_UNKNOWN )  [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 309 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::AddEntry(), gdcmWarningMacro, gdcm::DocEntrySet::GetDocEntry(), gdcm::DocEntry::GetVR(), gdcm::DocEntrySet::NewBinEntry(), gdcm::DocEntrySet::RemoveEntry(), gdcm::DocEntrySet::SetBinEntry(), and gdcm::TagName. Referenced by gdcm::File::InitializeDefaultFile(), and gdcm::FileHelper::InsertBinEntry(). { BinEntry *binEntry = 0; DocEntry *currentEntry = GetDocEntry( group, elem ); // Verify the currentEntry if (currentEntry) { binEntry = dynamic_cast<BinEntry *>(currentEntry); // Verify the VR if( binEntry ) if( binEntry->GetVR()!=vr ) binEntry = NULL; // if currentEntry doesn't correspond to the requested valEntry if( !binEntry) { if( !RemoveEntry(currentEntry) ) { gdcmWarningMacro( "Removal of previous DocEntry failed."); return NULL; } } } // Create a new binEntry if necessary if( !binEntry) { binEntry = NewBinEntry(group, elem, vr); if ( !AddEntry(binEntry) ) { gdcmWarningMacro( "AddEntry failed allthough this is a creation."); delete binEntry; return NULL; } } // Set the binEntry value uint8_t *tmpArea; if( lgth>0 && binArea ) { tmpArea = new uint8_t[lgth]; memcpy(tmpArea,binArea,lgth); } else { tmpArea = 0; } if( !SetBinEntry(tmpArea,lgth,binEntry) ) { if( tmpArea ) { delete[] tmpArea; } } return binEntry; }

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 382 of file gdcmDocEntrySet.cxx. References gdcm::DocEntrySet::AddEntry(), 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 allthough this is a creation."); delete seqEntry; return NULL; } } // TODO : Find a trick to insert a SequenceDelimitationItem // in the SeqEntry, at the end. return seqEntry; }

ValEntry * gdcm::DocEntrySet::InsertValEntry (  std::string const &  value, uint16_t  group, uint16_t  elem, TagName const &  vr = GDCM_UNKNOWN )  [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(), gdcmWarningMacro, gdcm::DocEntrySet::GetDocEntry(), gdcm::DocEntry::GetVR(), gdcm::DocEntrySet::NewValEntry(), gdcm::DocEntrySet::RemoveEntry(), gdcm::DocEntrySet::SetValEntry(), and gdcm::TagName. Referenced by gdcm::File::InitializeDefaultFile(), gdcm::FileHelper::InsertValEntry(), and gdcm::File::Write(). { ValEntry *valEntry = 0; DocEntry *currentEntry = GetDocEntry( group, elem ); if (currentEntry) { valEntry = dynamic_cast<ValEntry *>(currentEntry); // Verify the VR if( valEntry ) if( valEntry->GetVR()!=vr ) valEntry = NULL; // if currentEntry doesn't correspond to the requested valEntry if( !valEntry) { if( !RemoveEntry(currentEntry) ) { gdcmWarningMacro( "Removal of previous DocEntry failed."); return NULL; } } } // Create a new valEntry if necessary if( !valEntry ) { valEntry = NewValEntry( group, elem, vr ); if ( !AddEntry(valEntry) ) { gdcmWarningMacro("AddEntry failed although this is a creation."); delete valEntry; return NULL; } } // Set the binEntry value SetValEntry(value, valEntry); // The std::string value return valEntry; }

bool gdcm::Document::IsDicomV3 (   )

Predicate for dicom version 3 file. Returns: True when the file is a dicom version 3. Definition at line 245 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 to 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 1677 of file gdcmDocument.cxx. References Fp, gdcmWarningMacro, gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), and gdcm::DocEntry::GetVR(). Referenced by GetDocEntryUnvalue(), GetDocEntryValue(), and LoadDocEntry(). { uint16_t elem = entry->GetElement(); uint16_t group = entry->GetGroup(); const std::string &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 { // Allthough 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 63 of file gdcmElementSet.h. Referenced by IsReadable(). { 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 259 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::IsReadable (   )  [virtual]

This predicate, based on hopefully reasonable heuristics, decides whether or not the current Document was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File. Returns: true when Document is the one of a reasonable Dicom/Acr file, false otherwise. Reimplemented in gdcm::DicomDir, and gdcm::File. Definition at line 224 of file gdcmDocument.cxx. References Filetype, gdcmWarningMacro, gdcm::ElementSet::IsEmpty(), and gdcm::Unknown. { if( Filetype == Unknown) { gdcmWarningMacro( "Wrong filetype"); return false; } if ( IsEmpty() ) { gdcmWarningMacro( "No tag in internal hash table."); return false; } return true; }

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

Loads the element content if its length doesn't exceed the value specified with Document::SetMaxSizeLoadEntry(). Parameters: entry  Header Entry (Dicom Element) to be dealt with Todo: Any compacter code suggested (?) Definition at line 1030 of file gdcmDocument.cxx. References Fp, gdcm::GDCM_BINLOADED, gdcm::GDCM_NOTLOADED, gdcm::GDCM_UNREAD, gdcmErrorMacro, gdcmWarningMacro, gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetOffset(), gdcm::DocEntry::GetVR(), IsDocEntryAnInteger(), LoadEntryBinArea(), MaxSizeLoadEntry, ReadInt16(), ReadInt32(), gdcm::ValEntry::SetValue(), and gdcm::ContentEntry::SetValue(). Referenced by LoadDocEntrySafe(), and ParseDES(). { uint16_t group = entry->GetGroup(); std::string 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 if( group == 0xfffe ) { // NO more value field for SQ ! return; } // When the length is zero things are easy: if ( length == 0 ) { ((ValEntry *)entry)->SetValue(""); return; } // The elements whose length is bigger than the specified upper bound // are not loaded. Instead we leave a short notice of the offset of // the element content and it's length. std::ostringstream s; if (length > MaxSizeLoadEntry) { if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) ) { //s << "gdcm::NotLoaded (BinEntry)"; s << GDCM_NOTLOADED; s << " Address:" << (long)entry->GetOffset(); s << " Length:" << entry->GetLength(); s << " x(" << std::hex << entry->GetLength() << ")"; binEntryPtr->SetValue(s.str()); } // Be carefull : a BinEntry IS_A ValEntry ... else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) ) { // s << "gdcm::NotLoaded. (ValEntry)"; s << GDCM_NOTLOADED; s << " Address:" << (long)entry->GetOffset(); s << " Length:" << entry->GetLength(); s << " x(" << std::hex << entry->GetLength() << ")"; valEntryPtr->SetValue(s.str()); } else { // fusible gdcmErrorMacro( "MaxSizeLoadEntry exceeded, neither a BinEntry " << "nor a ValEntry ?! Should never print that !" ); } // to be sure we are at the end of the value ... Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(), std::ios::beg); return; } // When we find a BinEntry not very much can be done : if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) ) { s << GDCM_BINLOADED; binEntryPtr->SetValue(s.str()); LoadEntryBinArea(binEntryPtr); // last one, not to erase length ! return; } if ( IsDocEntryAnInteger(entry) ) { uint32_t NewInt; int nbInt; // When short integer(s) are expected, read and convert the following // n *two characters properly i.e. consider them as short integers as // opposed to strings. // Elements with Value Multiplicity > 1 // contain a set of integers (not a single one) if (vr == "US" || vr == "SS") { nbInt = length / 2; NewInt = ReadInt16(); s << NewInt; if (nbInt > 1) { for (int i=1; i < nbInt; i++) { s << '\\'; NewInt = ReadInt16(); s << NewInt; } } } // See above comment on multiple integers (mutatis mutandis). else if (vr == "UL" || vr == "SL") { nbInt = length / 4; NewInt = ReadInt32(); s << NewInt; if (nbInt > 1) { for (int i=1; i < nbInt; i++) { s << '\\'; NewInt = ReadInt32(); s << NewInt; } } } #ifdef GDCM_NO_ANSI_STRING_STREAM s << std::ends; // to avoid oddities on Solaris #endif //GDCM_NO_ANSI_STRING_STREAM ((ValEntry *)entry)->SetValue(s.str()); return; } // FIXME: We need an additional byte for storing \0 that is not on disk char *str = new char[length+1]; Fp->read(str, (size_t)length); str[length] = '\0'; //this is only useful when length is odd // Special DicomString call to properly handle \0 and even length std::string newValue; if( length % 2 ) { newValue = Util::DicomString(str, length+1); gdcmWarningMacro("Warning: bad length: " << length << ",For string :" << newValue.c_str()); // Since we change the length of string update it length //entry->SetReadLength(length+1); } else { newValue = Util::DicomString(str, length); } delete[] str; if ( ValEntry *valEntry = dynamic_cast<ValEntry* >(entry) ) { if ( Fp->fail() || Fp->eof()) { gdcmWarningMacro("Unread element value"); valEntry->SetValue(GDCM_UNREAD); return; } if( vr == "UI" ) { // Because of correspondance with the VR dic valEntry->SetValue(newValue); } else { valEntry->SetValue(newValue); } } else { gdcmErrorMacro( "Should have a ValEntry, here !"); } }

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 581 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 (  BinEntry *  elem  )  [virtual]

Loads (from disk) the element content when a string is not suitable. Parameters: elem  Entry whose binArea is going to be loaded Todo: check the result Definition at line 541 of file gdcmDocument.cxx. References CloseFile(), Fp, gdcmWarningMacro, gdcm::BinEntry::GetBinArea(), gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetOffset(), OpenFile(), and gdcm::BinEntry::SetBinArea(). { if(elem->GetBinArea()) return; bool openFile = !Fp; if(openFile) OpenFile(); size_t o =(size_t)elem->GetOffset(); Fp->seekg(o, std::ios::beg); size_t l = elem->GetLength(); uint8_t *a = new uint8_t[l]; if( !a ) { gdcmWarningMacro( "Cannot allocate BinEntry content"); return; } Fp->read((char*)a, l); if( Fp->fail() || Fp->eof()) { delete[] a; return; } elem->SetBinArea(a); 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 522 of file gdcmDocument.cxx. References gdcm::ElementSet::GetDocEntry(). Referenced by Document(), gdcm::PixelReadConvert::GrabInformationsFromFile(), and LoadDocEntry(). { // Search the corresponding DocEntry DocEntry *docElement = GetDocEntry(group, elem); if ( !docElement ) return; BinEntry *binElement = dynamic_cast<BinEntry *>(docElement); if( !binElement ) return; LoadEntryBinArea(binElement); }

BinEntry * gdcm::DocEntrySet::NewBinEntry (  uint16_t  group, uint16_t  elem, TagName const &  vr = GDCM_UNKNOWN )  [inherited]

Build a new Bin 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  VR of the new Entry Definition at line 471 of file gdcmDocEntrySet.cxx. References gdcmAssertMacro, gdcmWarningMacro, gdcm::DocEntrySet::GetDictEntry(), and gdcm::TagName. Referenced by gdcm::FileHelper::CopyBinEntry(), gdcm::DocEntrySet::InsertBinEntry(), and ReadNextDocEntry(). { DictEntry *dictEntry = GetDictEntry(group, elem, vr); gdcmAssertMacro(dictEntry); BinEntry *newEntry = new BinEntry(dictEntry); if (!newEntry) { gdcmWarningMacro( "Failed to allocate BinEntry"); 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 Definition at line 493 of file gdcmDocEntrySet.cxx. References gdcmAssertMacro, gdcmWarningMacro, and gdcm::DocEntrySet::GetDictEntry(). Referenced by gdcm::DocEntrySet::InsertSeqEntry(), and ReadNextDocEntry(). { DictEntry *dictEntry = GetDictEntry(group, elem, "SQ"); gdcmAssertMacro(dictEntry); SeqEntry *newEntry = new SeqEntry( dictEntry ); if (!newEntry) { gdcmWarningMacro( "Failed to allocate SeqEntry"); return 0; } return newEntry; }

ValEntry * gdcm::DocEntrySet::NewValEntry (  uint16_t  group, uint16_t  elem, TagName const &  vr = GDCM_UNKNOWN )  [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  VR of the new Entry Definition at line 447 of file gdcmDocEntrySet.cxx. References gdcmAssertMacro, gdcmWarningMacro, gdcm::DocEntrySet::GetDictEntry(), and gdcm::TagName. Referenced by gdcm::FileHelper::CopyValEntry(), gdcm::DocEntrySet::InsertValEntry(), and ReadNextDocEntry(). { DictEntry *dictEntry = GetDictEntry(group, elem, vr); gdcmAssertMacro(dictEntry); ValEntry *newEntry = new ValEntry(dictEntry); if (!newEntry) { gdcmWarningMacro( "Failed to allocate ValEntry"); return 0; } return newEntry; }

DictEntry * gdcm::DocEntrySet::NewVirtualDictEntry (  uint16_t  group, uint16_t  elem, TagName const &  vr = GDCM_UNKNOWN, TagName const &  vm = GDCM_UNKNOWN, TagName const &  name = GDCM_UNKNOWN )  [inherited]

Request a new virtual dict entry to the dict set. Parameters: group  group number of the underlying DictEntry elem  element number of the underlying DictEntry vr  VR (Value Representation) of the underlying DictEntry vm  VM (Value Multiplicity) of the underlying DictEntry name  english name Definition at line 515 of file gdcmDocEntrySet.cxx. References gdcm::TagName. Referenced by gdcm::File::File(), and gdcm::DocEntrySet::GetDictEntry(). { return Global::GetDicts()->NewVirtualDictEntry(group,elem,vr,vm,name); }

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 395 of file gdcmDocument.cxx. References CloseFile(), Fp, gdcmDebugMacro, gdcmWarningMacro, and HasDCMPreamble. Referenced by Document(), gdcm::File::File(), gdcm::FileHelper::GetRaw(), and LoadEntryBinArea(). { HasDCMPreamble = false; if (Filename.length() == 0) { return 0; } if(Fp) { gdcmWarningMacro( "File already open: " << Filename.c_str()); CloseFile(); } Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary); if( ! *Fp ) { gdcmDebugMacro( "Cannot open file: " << Filename.c_str()); delete Fp; Fp = 0; return 0; } uint16_t zero = 0; Fp->read((char*)&zero, (size_t)2); if( Fp->eof() ) { CloseFile(); return 0; } //ACR -- or DICOM with no Preamble; may start with a Shadow Group -- 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 with no preamble: (%04x)\n", zero); 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; } CloseFile(); gdcmWarningMacro( "Not DICOM/ACR (missing preamble)" << 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 598 of file gdcmDocument.cxx. References gdcm::DocEntrySet::GetEntryValue(). { // Patient Name std::string s1 = GetEntryValue(0x0010,0x0010); std::string s2 = document.GetEntryValue(0x0010,0x0010); if(s1 < s2) { return true; } else if( s1 > s2 ) { return false; } else { // Patient ID s1 = GetEntryValue(0x0010,0x0020); s2 = document.GetEntryValue(0x0010,0x0020); if ( s1 < s2 ) { return true; } else if ( s1 > s2 ) { return false; } else { // Study Instance UID s1 = GetEntryValue(0x0020,0x000d); s2 = document.GetEntryValue(0x0020,0x000d); if ( s1 < s2 ) { return true; } else if( s1 > s2 ) { return false; } else { // Serie Instance UID s1 = GetEntryValue(0x0020,0x000e); s2 = document.GetEntryValue(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). Returns: length of the parsed set. Definition at line 775 of file gdcmDocument.cxx. References gdcm::DocEntrySet::AddEntry(), gdcm::ExplicitVR, Filetype, Fp, gdcmWarningMacro, gdcm::SQItem::GetBaseTagKey(), gdcm::SQItem::GetDepthLevel(), gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetKey(), gdcm::DocEntry::GetOffset(), gdcm::DocEntry::GetReadLength(), gdcm::DocEntry::GetVR(), gdcm::DocEntry::IsItemDelimitor(), LoadDocEntry(), ParseSQ(), ReadNextDocEntry(), gdcm::SeqEntry::SetDelimitorMode(), gdcm::SeqEntry::SetDepthLevel(), gdcm::DocEntry::SetKey(), SkipToNextDocEntry(), and gdcm::VRKey. Referenced by Document(), and ParseSQ(). { DocEntry *newDocEntry = 0; ValEntry *newValEntry; BinEntry *newBinEntry; SeqEntry *newSeqEntry; VRKey vr; bool used = false; while (true) { if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { break; } used = true; newDocEntry = ReadNextDocEntry( ); if ( !newDocEntry ) { break; } vr = newDocEntry->GetVR(); newValEntry = dynamic_cast<ValEntry*>(newDocEntry); newBinEntry = dynamic_cast<BinEntry*>(newDocEntry); newSeqEntry = dynamic_cast<SeqEntry*>(newDocEntry); if ( newValEntry || newBinEntry ) { if ( newBinEntry ) { if ( Filetype == ExplicitVR && !Global::GetVR()->IsVROfBinaryRepresentable(vr) ) { gdcmWarningMacro( std::hex << newDocEntry->GetGroup() << "|" << newDocEntry->GetElement() << " : Neither Valentry, nor BinEntry." "Probably unknown VR."); } // When "this" is a Document the Key is simply of the // form ( group, elem )... if ( dynamic_cast< Document* > ( set ) ) { newBinEntry->SetKey( newBinEntry->GetKey() ); } // but when "this" is a SQItem, we are inserting this new // valEntry in a sequence item, and the key has the // generalized form (refer to \ref BaseTagKey): if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newBinEntry->SetKey( parentSQItem->GetBaseTagKey() + newBinEntry->GetKey() ); } LoadDocEntry( newBinEntry ); if( !set->AddEntry( newBinEntry ) ) { //Expect big troubles if here //delete newBinEntry; used=false; } } else { // When "set" is a Document, then we are at the top of the // hierarchy and the Key is simply of the form ( group, elem )... if ( dynamic_cast< Document* > ( set ) ) { newValEntry->SetKey( newValEntry->GetKey() ); } // ...but when "set" is a SQItem, we are inserting this new // valEntry in a sequence item. Hence the key has the // generalized form (refer to \ref BaseTagKey): if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newValEntry->SetKey( parentSQItem->GetBaseTagKey() + newValEntry->GetKey() ); } LoadDocEntry( newValEntry ); bool delimitor=newValEntry->IsItemDelimitor(); if( !set->AddEntry( newValEntry ) ) { // If here expect big troubles //delete newValEntry; //otherwise mem leak used=false; } if (delimitor) { if(!used) delete newDocEntry; break; } if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { if(!used) delete newDocEntry; break; } } // Just to make sure we are at the beginning of next entry. SkipToNextDocEntry(newDocEntry); } else { // VR = "SQ" unsigned long l = newDocEntry->GetReadLength(); if ( l != 0 ) // don't mess the delim_mode for zero-length sequence { if ( l == 0xffffffff ) { delim_mode = true; } else { delim_mode = false; } } // no other way to create it ... newSeqEntry->SetDelimitorMode( delim_mode ); // 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 (/*Document *dummy =*/ dynamic_cast< Document* > ( set ) ) { //(void)dummy; newSeqEntry->SetDepthLevel( 1 ); newSeqEntry->SetKey( newSeqEntry->GetKey() ); } // 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: if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 ); newSeqEntry->SetKey( parentSQItem->GetBaseTagKey() + newSeqEntry->GetKey() ); } if ( l != 0 ) { // Don't try to parse zero-length sequences ParseSQ( newSeqEntry, newDocEntry->GetOffset(), l, delim_mode); } if( !set->AddEntry( newSeqEntry ) ) { used = false; } if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { if( !used ) delete newDocEntry; break; } } if( !used ) delete newDocEntry; } }

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 952 of file gdcmDocument.cxx. References gdcm::SeqEntry::AddSQItem(), Fp, gdcm::SeqEntry::GetDepthLevel(), gdcm::DocEntry::GetKey(), gdcm::DocEntry::GetReadLength(), gdcm::DocEntry::IsSequenceDelimitor(), ParseDES(), ReadNextDocEntry(), gdcm::SQItem::SetBaseTagKey(), 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 ) { // FIXME Should warn user break; } if( delim_mode ) { if ( newDocEntry->IsSequenceDelimitor() ) { seqEntry->SetDelimitationItem( newDocEntry ); break; } } if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { delete newDocEntry; break; } // create the current SQItem SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() ); std::ostringstream newBase; newBase << seqEntry->GetKey() << "/" << SQItemNumber << "#"; itemSQ->SetBaseTagKey( newBase.str() ); unsigned int l = newDocEntry->GetReadLength(); if ( l == 0xffffffff ) { dlm_mod = true; } else { dlm_mod = false; } // FIXME, TODO // when we're here, element fffe,e000 is already passed. // it's lost for the SQItem we're going to process !! //ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod); //delete newDocEntry; // FIXME well ... it's too late to use it ! // Let's try :------------ // remove fff0,e000, created out of the SQItem delete newDocEntry; 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(); // end try ----------------- seqEntry->AddSQItem( itemSQ, SQItemNumber ); 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 195 of file gdcmElementSet.cxx. References gdcm::DocEntry::Print(), gdcm::Base::SetPrintLevel(), and gdcm::ElementSet::TagHT. Referenced by gdcm::FileHelper::Print(). { 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 663 of file gdcmDocument.cxx. Referenced by LoadDocEntry(), 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 685 of file gdcmDocument.cxx. Referenced by gdcm::File::ComputeRLEInfo(), LoadDocEntry(), 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 but 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 1970 of file gdcmDocument.cxx. References gdcm::ExplicitVR, Filetype, FindDocEntryLength(), FindDocEntryVR(), Fp, gdcm::GDCM_UNKNOWN, gdcmWarningMacro, gdcm::DocEntrySet::GetDictEntry(), gdcm::DocEntry::GetElement(), gdcm::DocEntry::GetGroup(), gdcm::DictEntry::GetVR(), HandleBrokenEndian(), HandleOutOfGroup0002(), HasDCMPreamble, gdcm::DocEntrySet::NewBinEntry(), gdcm::DocEntrySet::NewSeqEntry(), gdcm::DocEntrySet::NewValEntry(), ReadInt16(), gdcm::DocEntry::SetImplicitVR(), and gdcm::DocEntry::SetOffset(). Referenced by ParseDES(), and ParseSQ(). { uint16_t group; uint16_t elem; try { group = ReadInt16(); elem = ReadInt16(); } catch ( FormatError e ) { // 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(group, elem); // In 'true DICOM' files Group 0002 is always little endian if ( HasDCMPreamble ) HandleOutOfGroup0002(group, elem); std::string vr = FindDocEntryVR(); std::string realVR = vr; if( vr == GDCM_UNKNOWN) { DictEntry *dictEntry = GetDictEntry(group,elem); if( dictEntry ) realVR = dictEntry->GetVR(); } DocEntry *newEntry; if( Global::GetVR()->IsVROfSequence(realVR) ) newEntry = NewSeqEntry(group, elem); else if( Global::GetVR()->IsVROfStringRepresentable(realVR) ) newEntry = NewValEntry(group, elem,vr); else newEntry = NewBinEntry(group, elem,vr); if( vr == GDCM_UNKNOWN ) { 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; msg = Util::Format("Entry (%04x,%04x) should be Explicit VR\n", newEntry->GetGroup(), newEntry->GetElement()); gdcmWarningMacro( msg.c_str() ); } } newEntry->SetImplicitVR(); } try { FindDocEntryLength(newEntry); } catch ( FormatError e ) { // Call it quits //std::cout << e; delete newEntry; return 0; } newEntry->SetOffset(Fp->tellg()); return newEntry; }

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 89 of file gdcmElementSet.cxx. References gdcmWarningMacro, gdcm::DocEntry::GetKey(), gdcm::ElementSet::TagHT, and gdcm::TagKey. Referenced by gdcm::File::File(), and gdcm::DocEntryArchive::Restore(). { const TagKey &key = entryToRemove->GetKey(); if( TagHT.count(key) == 1 ) { TagHT.erase(key); //gdcmWarningMacro( "One element erased."); delete entryToRemove; return true; } gdcmWarningMacro( "Key not present"); return false ; }

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

Clear the hash table from given entry BUT keep the entry. Parameters: entryToRemove  Entry to remove. Implements gdcm::DocEntrySet. Definition at line 108 of file gdcmElementSet.cxx. References gdcmWarningMacro, gdcm::DocEntry::GetKey(), gdcm::ElementSet::TagHT, and gdcm::TagKey. Referenced by gdcm::DicomDir::NewMeta(), gdcm::DocEntryArchive::Push(), and gdcm::File::Write(). { const TagKey &key = entryToRemove->GetKey(); if( TagHT.count(key) == 1 ) { TagHT.erase(key); //gdcmWarningMacro( "One element erased."); return true; } gdcmWarningMacro( "Key not present"); return false ; }

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

Accesses an existing BinEntry (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 228 of file gdcmDocEntrySet.cxx. References gdcm::GDCM_BINLOADED, gdcm::BinEntry::SetBinArea(), gdcm::DocEntry::SetLength(), and gdcm::ContentEntry::SetValue(). { if(entry) { entry->SetBinArea(content); entry->SetLength(lgth); entry->SetValue(GDCM_BINLOADED); return true; } return false; }

bool gdcm::DocEntrySet::SetBinEntry (  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 191 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, and gdcm::DocEntrySet::GetBinEntry(). Referenced by gdcm::DocEntrySet::InsertBinEntry(), and gdcm::FileHelper::SetBinEntry(). { BinEntry *entry = GetBinEntry(group, elem); if (!entry ) { gdcmWarningMacro( "No corresponding ValEntry " << std::hex << group << "," << elem << " element (try promotion first)."); return false; } return SetBinEntry(content,lgth,entry); }

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

Accessor to Filename. Definition at line 81 of file gdcmDocument.h. Referenced by gdcm::DicomDir::DicomDir(). { Filename = fileName; }

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

during parsing, Header Elements too long are not loaded in memory Parameters: newSize  Definition at line 1929 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::Document::SetMaxSizePrintEntry (  long  newSize  )  [private]

Header Elements too long will not be printed. Todo: See comments of Document::MAX_SIZE_PRINT_ELEMENT_VALUE Parameters: newSize  Definition at line 1948 of file gdcmDocument.cxx. References MaxSizePrintEntry. { if ( newSize < 0 ) { return; } if ((uint32_t)newSize >= (uint32_t)0xffffffff ) { MaxSizePrintEntry = 0xffffffff; return; } MaxSizePrintEntry = 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 Definition at line 45 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 210 of file gdcmDocument.cxx. References gdcm::DictKey, 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 200 of file gdcmDocument.cxx. References RefShaDict. { RefShaDict = dict; return !RefShaDict; }

bool gdcm::DocEntrySet::SetValEntry (  std::string const &  content, ValEntry *  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 211 of file gdcmDocEntrySet.cxx. References gdcm::ValEntry::SetValue(). { if(entry) { entry->SetValue(content); return true; } return false; }

bool gdcm::DocEntrySet::SetValEntry (  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 169 of file gdcmDocEntrySet.cxx. References gdcmWarningMacro, and gdcm::DocEntrySet::GetValEntry(). Referenced by gdcm::File::AnonymizeFile(), Document(), gdcm::DocEntrySet::InsertValEntry(), gdcm::FileHelper::SetValEntry(), and gdcm::File::Write(). { ValEntry *entry = GetValEntry(group, elem); if (!entry ) { gdcmWarningMacro( "No corresponding ValEntry " << std::hex << group << "," << elem << " element (try promotion first)."); return false; } return SetValEntry(content,entry); }

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

skips bytes inside the source file Warning: NOT end user intended method ! Returns: Definition at line 707 of file gdcmDocument.cxx. References Fp. Referenced by gdcm::File::ComputeJPEGFragmentInfo(), gdcm::File::ComputeRLEInfo(), 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. Warning: NOT end user intended method ! Parameters: entry  entry to skip Definition at line 1582 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. Warning: NOT end user intended method ! Parameters: currentDocEntry  entry to skip Definition at line 1592 of file gdcmDocument.cxx. References Fp, gdcm::DocEntry::GetGroup(), gdcm::DocEntry::GetOffset(), and gdcm::DocEntry::GetReadLength(). Referenced by ParseDES(). { Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg); if (currentDocEntry->GetGroup() != 0xfffe) // for fffe pb Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur); }

uint32_t gdcm::Document::SwapLong (  uint32_t  a  )

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

uint16_t gdcm::Document::SwapShort (  uint16_t  a  )

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

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

Change the Byte Swap code. Definition at line 1904 of file gdcmDocument.cxx. References gdcmWarningMacro, and SwapCode. Referenced by HandleBrokenEndian(), and HandleOutOfGroup0002(). { gdcmWarningMacro( "Switching Byte Swap code from "<< SwapCode); if ( SwapCode == 1234 ) { SwapCode = 4321; } else if ( SwapCode == 4321 ) { SwapCode = 1234; } else if ( SwapCode == 3412 ) { SwapCode = 2143; } else if ( SwapCode == 2143 ) { SwapCode = 3412; } }

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

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

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

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

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

Writes in a file all the Header 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) Returns: Always true. Reimplemented from gdcm::ElementSet. Definition at line 482 of file gdcmDocument.cxx. References gdcm::ExplicitVR, and gdcm::ImplicitVR. { // \TODO move the following lines (and a lot of others, to be written) // to a future function CheckAndCorrectHeader // (necessary if user wants to write a DICOM V3 file // starting from an ACR-NEMA (V2) Header if ( filetype == ImplicitVR || filetype == ExplicitVR ) { // 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); */ ElementSet::WriteContent(fp, filetype); // This one is recursive }

---

Member Data Documentation

ListElements gdcm::Document::AnonymizeList [protected]

List of element to Anonymize. Definition at line 150 of file gdcmDocument.h.

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

Refering underlying filename. Definition at line 112 of file gdcmDocument.h.

FileType gdcm::Document::Filetype [protected]

ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown. Definition at line 138 of file gdcmDocument.h. Referenced by CheckSwap(), Document(), FindDocEntryVR(), GetFileType(), HandleOutOfGroup0002(), Initialize(), IsReadable(), ParseDES(), and ReadNextDocEntry().

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

File Pointer, opened during Document parsing. Definition at line 135 of file gdcmDocument.h. Referenced by CheckSwap(), CloseFile(), Document(), FindDocEntryVR(), IsDocEntryAnInteger(), LoadDocEntry(), LoadDocEntrySafe(), LoadEntryBinArea(), OpenFile(), ParseDES(), ParseSQ(), ReadNextDocEntry(), SkipBytes(), and SkipToNextDocEntry().

bool gdcm::Document::Group0002Parsed [protected]

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

bool gdcm::Document::HasDCMPreamble [protected]

whether file has a DCM Preamble Definition at line 132 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 141 of file gdcmDocument.h.

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 51 of file gdcmDocument.cxx. Referenced by Document().

const unsigned int gdcm::Document::MAX_SIZE_PRINT_ELEMENT_VALUE = 0x7fffffff [static, protected]

Elements whose value is longer than MAX_SIZE_PRINT_ELEMENT_VALUE are NOT printed. Definition at line 52 of file gdcmDocument.cxx.

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 197 of file gdcmDocument.h. Referenced by LoadDocEntry(), and SetMaxSizeLoadEntry().

uint32_t gdcm::Document::MaxSizePrintEntry [private]

Size threshold above which an element value will NOT be *printed* in order no to polute the screen output. By default, this upper bound is fixed to 64 bytes. Definition at line 202 of file gdcmDocument.h. Referenced by SetMaxSizePrintEntry().

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

Amount of printed details for each Dicom Entries : 0 : stands for the least detail level. Definition at line 53 of file gdcmBase.h. Referenced by gdcm::Base::Base().

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

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

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

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

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 126 of file gdcmDocument.h. Referenced by CheckSwap(), Document(), SwapLong(), SwapShort(), and SwitchByteSwapCode().

---

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

• gdcmDocument.h
• gdcmDocument.cxx

---