gdcm::File Class Reference

DICOM elements and their corresponding values (and additionaly the corresponding DICOM dictionary entry) of the header of a DICOM file. More...

#include <gdcmFile.h>

Inheritance diagram for gdcm::File:

List of all members.

Public Types
typedef std::list< Element >	ListElements
Public Member Functions
	File ()
	Constructor used when we want to generate dicom files from scratch.
	File (std::string const &filename)
	Constructor.
	~File ()
	Canonical destructor.
bool	IsReadable ()
	This predicate, based on hopefully reasonable heuristics, decides whether or not the current File was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File.
int	GetImageNumber ()
	gets the info from 0020,0013 : Image Number else 0.
ModalityType	GetModality ()
	gets the info from 0008,0060 : Modality
int	GetXSize ()
	Retrieve the number of columns of image.
int	GetYSize ()
	Retrieve the number of lines of image.
int	GetZSize ()
	Retrieve the number of planes of volume or the number of frames of a multiframe.
float	GetXSpacing ()
	gets the info from 0028,0030 : Pixel Spacing else 1.0
float	GetYSpacing ()
	gets the info from 0028,0030 : Pixel Spacing else 1.0
float	GetZSpacing ()
	gets the info from 0018,0088 : Space Between Slices else from 0018,0050 : Slice Thickness else 1.0
float	GetXOrigin ()
	gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0.
float	GetYOrigin ()
	gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0.
float	GetZOrigin ()
	gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else from 0020,1041 : Slice Location else from 0020,0050 : Location else 0.
void	GetImageOrientationPatient (float iop[6])
	gets the info from 0020,0037 : Image Orientation Patient (needed to organize DICOM files based on their x,y,z position)
int	GetBitsStored ()
	Retrieve the number of Bits Stored (actually used) (as opposed to number of Bits Allocated).
int	GetBitsAllocated ()
	Retrieve the number of Bits Allocated (8, 12 -compacted ACR-NEMA files, 16, ...).
int	GetHighBitPosition ()
	Retrieve the high bit position.
int	GetSamplesPerPixel ()
	Retrieve the number of Samples Per Pixel (1 : gray level, 3 : RGB -1 or 3 Planes-).
int	GetPlanarConfiguration ()
	Retrieve the Planar Configuration for RGB images (0 : RGB Pixels , 1 : R Plane + G Plane + B Plane).
int	GetPixelSize ()
	Return the size (in bytes) of a single pixel of data.
std::string	GetPixelType ()
	Build the Pixel Type of the image. Possible values are: -8U unsigned 8 bit, -8S signed 8 bit, -16U unsigned 16 bit, -16S signed 16 bit, -32U unsigned 32 bit, -32S signed 32 bit, -FD floating double 64 bits (Not kosher DICOM, but so usefull!).
bool	IsSignedPixelData ()
	Check whether the pixels are signed or UNsigned data.
bool	IsMonochrome ()
	Check whether this a monochrome picture or not by accessing the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
bool	IsPaletteColor ()
	Check whether this a "PALETTE COLOR" picture or not by accessing the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
bool	IsYBRFull ()
	Check whether this a "YBR_FULL" color picture or not by accessing the "Photometric Interpretation" tag ( 0x0028, 0x0004 ).
bool	HasLUT ()
	tells us if LUT are used
int	GetLUTNbits ()
	gets the info from 0028,1101 : Lookup Table Desc-Red else 0
float	GetRescaleIntercept ()
	gets the info from 0028,1052 : Rescale Intercept
float	GetRescaleSlope ()
	gets the info from 0028,1053 : Rescale Slope
int	GetNumberOfScalarComponents ()
	This function is intended to user who doesn't want to have to manage a LUT and expects to get an RBG Pixel image (or a monochrome one ...).
int	GetNumberOfScalarComponentsRaw ()
	This function is intended to user that DOESN'T want to get RGB pixels image when it's stored as a PALETTE COLOR image -the (vtk) user is supposed to know how deal with LUTs -.
uint16_t	GetGrPixel ()
	Accessor to File::GrPixel.
uint16_t	GetNumPixel ()
	Accessor to File::NumPixel.
size_t	GetPixelOffset ()
	Recover the offset (from the beginning of the file) of *image* pixels (not *icone image* pixels, if any !).
size_t	GetPixelAreaLength ()
	Recover the pixel area length (in Bytes).
RLEFramesInfo *	GetRLEInfo ()
	returns the RLE info
JPEGFragmentsInfo *	GetJPEGInfo ()
	Returns the JPEG Fragments info.
void	AddAnonymizeElement (uint16_t group, uint16_t elem, std::string const &value)
	Adds the characteristics of a new element we want to anonymize.
void	ClearAnonymizeList ()
	Clears the list of elements to be anonymized.
void	AnonymizeNoLoad ()
	Overwrites in the file the values of the DicomElements held in the list.
bool	AnonymizeFile ()
	anonymize a File (removes Patient's personal info passed with AddAnonymizeElement()
bool	Write (std::string fileName, FileType filetype)
	Performs some consistency checking on various 'File related' (as opposed to 'DicomDir related') entries then writes in a file all the (Dicom Elements) included the Pixels.
Dict *	GetPubDict ()
	Get the public dictionary used.
Dict *	GetShaDict ()
	Get the shadow dictionary used.
bool	SetShaDict (Dict *dict)
	Set the shadow dictionary used.
bool	SetShaDict (DictKey const &dictName)
	Set the shadow dictionary used.
bool	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
void	InitializeDefaultFile ()
	Initialize a default DICOM File that should contain all the field require by other reader. DICOM standard does not explicitely defines those fields, heuristic has been choosen. This is not perfect as we are writting a CT image...
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
RLEFramesInfo *	RLEInfo
	Store the RLE frames info obtained during parsing of pixels.
JPEGFragmentsInfo *	JPEGInfo
	Store the JPEG fragments info obtained during parsing of pixels.
uint16_t	NumPixel
	In some cases (e.g. for some ACR-NEMA images) the Entry Element Number of the 'Pixel Element' is *not* found at 0x0010. In order to make things easier the parser shall store the proper value in NumPixel to provide a unique access facility.
uint16_t	GrPixel
	In some cases (e.g. for some ACR-NEMA images) the header entry for the group of pixels is *not* found at 0x7fe0. In order to make things easier the parser shall store the proper value in GrPixel to provide a unique access facility.
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	ComputeRLEInfo ()
	Parse pixel data from disk of [multi-]fragment RLE encoding. Compute the RLE extra information and store it in RLEInfo for later pixel retrieval usage.
void	ComputeJPEGFragmentInfo ()
	Parse pixel data from disk of [multi-]fragment Jpeg encoding. Compute the jpeg extra information (fragment[s] offset[s] and length) and store it[them] in JPEGInfo for later pixel retrieval usage.
bool	ReadTag (uint16_t, uint16_t)
	Assuming the internal file pointer Document::Fp is placed at the beginning of a tag check whether this tag is (TestGroup, TestElement).
uint32_t	ReadTagLength (uint16_t, uint16_t)
	Assuming the internal file pointer Document::Fp is placed at the beginning of a tag (TestGroup, TestElement), read the length associated to the Tag.
void	ReadAndSkipEncapsulatedBasicOffsetTable ()
	When parsing the Pixel Data of an encapsulated file, read the basic offset table (when present, and BTW dump it).

---

Detailed Description

DICOM elements and their corresponding values (and additionaly the corresponding DICOM dictionary entry) of the header of a DICOM file.

The typical usage of instances of class File is to classify a set of dicom files according to header information e.g. to create a file hierarchy reflecting the Patient/Study/Serie informations, or extracting a given SerieId. Accessing the content (image[s] or volume[s]) is beyond the functionality of this class and belongs to gdmcFile.

Note:

The various entries of the explicit value representation (VR) shall be managed within a dictionary which is shared by all File instances.

The File::Set*Tag* family members cannot be defined as protected due to Swig limitations for as Has_a dependency between File and FileHelper.

Definition at line 95 of file gdcmFile.h.

---

Member Typedef Documentation

typedef std::list<Element> gdcm::Document::ListElements [inherited]

Definition at line 47 of file gdcmDocument.h.

---

Constructor & Destructor Documentation

gdcm::File::File (   )

Constructor used when we want to generate dicom files from scratch. Definition at line 152 of file gdcmFile.cxx. References InitializeDefaultFile(), JPEGInfo, and RLEInfo. : Document() { RLEInfo = new RLEFramesInfo; JPEGInfo = new JPEGFragmentsInfo; InitializeDefaultFile(); }

gdcm::File::File (  std::string const &  filename  )

Constructor. Parameters: filename  name of the file whose header we want to analyze Definition at line 53 of file gdcmFile.cxx. References gdcm::ElementSet::AddEntry(), gdcm::Document::CloseFile(), ComputeJPEGFragmentInfo(), ComputeRLEInfo(), gdcm::ContentEntry::Copy(), gdcm::GDCM_UNFOUND, gdcm::BinEntry::GetBinArea(), GetBitsAllocated(), gdcm::ElementSet::GetDocEntry(), gdcm::DocEntrySet::GetEntryValue(), gdcm::DocEntry::GetOffset(), gdcm::Document::GetTransferSyntax(), gdcm::DocEntry::GetVR(), GrPixel, gdcm::BinEntry::IsSelfArea(), JPEGInfo, gdcm::DocEntrySet::NewVirtualDictEntry(), NumPixel, gdcm::Document::OpenFile(), gdcm::ElementSet::RemoveEntry(), RLEInfo, gdcm::BinEntry::SetBinArea(), and gdcm::BinEntry::SetSelfArea(). :Document( filename ) { RLEInfo = new RLEFramesInfo; JPEGInfo = new JPEGFragmentsInfo; // for some ACR-NEMA images GrPixel, NumPixel is *not* 7fe0,0010 // We may encounter the 'RETired' (0x0028, 0x0200) tag // (Image Location") . This entry contains the number of // the group that contains the pixel data (hence the "Pixel Data" // is found by indirection through the "Image Location"). // Inside the group pointed by "Image Location" the searched element // is conventionally the element 0x0010 (when the norm is respected). // When the "Image Location" is missing we default to group 0x7fe0. // Note: this IS the right place for the code // Image Location const std::string &imgLocation = GetEntryValue(0x0028, 0x0200); if ( imgLocation == GDCM_UNFOUND ) { // default value GrPixel = 0x7fe0; } else { GrPixel = (uint16_t) atoi( imgLocation.c_str() ); } // sometimes Image Location value doesn't follow // the supposed processor endianness. // see gdcmData/cr172241.dcm if ( GrPixel == 0xe07f ) { GrPixel = 0x7fe0; } if ( GrPixel != 0x7fe0 ) { // This is a kludge for old dirty Philips imager. NumPixel = 0x1010; } else { NumPixel = 0x0010; } // Now, we know GrPixel and NumPixel. // Let's create a VirtualDictEntry to allow a further VR modification // and force VR to match with BitsAllocated. DocEntry *entry = GetDocEntry(GrPixel, NumPixel); if ( entry != 0 ) { // Compute the RLE or JPEG info OpenFile(); std::string ts = GetTransferSyntax(); Fp->seekg( entry->GetOffset(), std::ios::beg ); if ( Global::GetTS()->IsRLELossless(ts) ) ComputeRLEInfo(); else if ( Global::GetTS()->IsJPEG(ts) ) ComputeJPEGFragmentInfo(); CloseFile(); // Create a new BinEntry to change the the DictEntry // The changed DictEntry will have // - a correct PixelVR OB or OW) // - a VM to "PXL" // - the name to "Pixel Data" BinEntry *oldEntry = dynamic_cast<BinEntry *>(entry); if(oldEntry) { std::string PixelVR; // 8 bits allocated is a 'O Bytes' , as well as 24 (old ACR-NEMA RGB) // more than 8 (i.e 12, 16) is a 'O Words' if ( GetBitsAllocated() == 8 || GetBitsAllocated() == 24 ) PixelVR = "OB"; else PixelVR = "OW"; // Change only made if usefull if( PixelVR != oldEntry->GetVR() ) { DictEntry* newDict = NewVirtualDictEntry(GrPixel,NumPixel, PixelVR,"1","Pixel Data"); BinEntry *newEntry = new BinEntry(newDict); newEntry->Copy(entry); newEntry->SetBinArea(oldEntry->GetBinArea(),oldEntry->IsSelfArea()); oldEntry->SetSelfArea(false); RemoveEntry(oldEntry); AddEntry(newEntry); } } } }

gdcm::File::~File (   )

Canonical destructor. Definition at line 163 of file gdcmFile.cxx. References JPEGInfo, and RLEInfo. { if( RLEInfo ) delete RLEInfo; if( JPEGInfo ) delete JPEGInfo; }

---

Member Function Documentation

void gdcm::File::AddAnonymizeElement (  uint16_t  group, uint16_t  elem, std::string const &  value )

Adds the characteristics of a new element we want to anonymize. Definition at line 1144 of file gdcmFile.cxx. References gdcm::Element::Elem, gdcm::Element::Group, and gdcm::Element::Value. { Element el; el.Group = group; el.Elem = elem; el.Value = value; AnonymizeList.push_back(el); }

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 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::File::AnonymizeFile (   )

anonymize a File (removes Patient's personal info passed with AddAnonymizeElement() Definition at line 1206 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcm::ElementSet::GetDocEntry(), gdcm::DocEntrySet::GetEntryValue(), and gdcm::DocEntrySet::SetValEntry(). { // If Anonymisation list is empty, let's perform some basic anonymization if ( AnonymizeList.begin() == AnonymizeList.end() ) { // If exist, replace by spaces SetValEntry (" ",0x0010, 0x2154); // Telephone SetValEntry (" ",0x0010, 0x1040); // Adress SetValEntry (" ",0x0010, 0x0020); // Patient ID DocEntry* patientNameHE = GetDocEntry (0x0010, 0x0010); if ( patientNameHE ) // we replace it by Study Instance UID (why not ?) { std::string studyInstanceUID = GetEntryValue (0x0020, 0x000d); if ( studyInstanceUID != GDCM_UNFOUND ) { SetValEntry(studyInstanceUID, 0x0010, 0x0010); } else { SetValEntry("anonymised", 0x0010, 0x0010); } } } else { gdcm::DocEntry *d; for (ListElements::iterator it = AnonymizeList.begin(); it != AnonymizeList.end(); ++it) { d = GetDocEntry( (*it).Group, (*it).Elem); if ( d == NULL) continue; if ( dynamic_cast<BinEntry *>(d) || dynamic_cast<SeqEntry *>(d) ) continue; SetValEntry ((*it).Value, (*it).Group, (*it).Elem); } } // In order to make definitively impossible any further identification // remove or replace all the stuff that contains a Date //0008 0012 DA ID Instance Creation Date //0008 0020 DA ID Study Date //0008 0021 DA ID Series Date //0008 0022 DA ID Acquisition Date //0008 0023 DA ID Content Date //0008 0024 DA ID Overlay Date //0008 0025 DA ID Curve Date //0008 002a DT ID Acquisition Datetime //0018 9074 DT ACQ Frame Acquisition Datetime //0018 9151 DT ACQ Frame Reference Datetime //0018 a002 DT ACQ Contribution Date Time //0020 3403 SH REL Modified Image Date (RET) //0032 0032 DA SDY Study Verified Date //0032 0034 DA SDY Study Read Date //0032 1000 DA SDY Scheduled Study Start Date //0032 1010 DA SDY Scheduled Study Stop Date //0032 1040 DA SDY Study Arrival Date //0032 1050 DA SDY Study Completion Date //0038 001a DA VIS Scheduled Admission Date //0038 001c DA VIS Scheduled Discharge Date //0038 0020 DA VIS Admitting Date //0038 0030 DA VIS Discharge Date //0040 0002 DA PRC Scheduled Procedure Step Start Date //0040 0004 DA PRC Scheduled Procedure Step End Date //0040 0244 DA PRC Performed Procedure Step Start Date //0040 0250 DA PRC Performed Procedure Step End Date //0040 2004 DA PRC Issue Date of Imaging Service Request //0040 4005 DT PRC Scheduled Procedure Step Start Date and Time //0040 4011 DT PRC Expected Completion Date and Time //0040 a030 DT PRC Verification Date Time //0040 a032 DT PRC Observation Date Time //0040 a120 DT PRC DateTime //0040 a121 DA PRC Date //0040 a13a DT PRC Referenced Datetime //0070 0082 DA ??? Presentation Creation Date //0100 0420 DT ??? SOP Autorization Date and Time //0400 0105 DT ??? Digital Signature DateTime //2100 0040 DA PJ Creation Date //3006 0008 DA SSET Structure Set Date //3008 0024 DA ??? Treatment Control Point Date //3008 0054 DA ??? First Treatment Date //3008 0056 DA ??? Most Recent Treatment Date //3008 0162 DA ??? Safe Position Exit Date //3008 0166 DA ??? Safe Position Return Date //3008 0250 DA ??? Treatment Date //300a 0006 DA RT RT Plan Date //300a 022c DA RT Air Kerma Rate Reference Date //300e 0004 DA RT Review Date return true; }

void gdcm::File::AnonymizeNoLoad (   )

Overwrites in the file the values of the DicomElements held in the list. Definition at line 1159 of file gdcmFile.cxx. References gdcm::ElementSet::GetDocEntry(), gdcm::DocEntry::GetLength(), and gdcm::DocEntry::GetOffset(). { std::fstream *fp = new std::fstream(Filename.c_str(), std::ios::in | std::ios::out | std::ios::binary); // TODO : FIXME // how to white out disk space if longer than 50 ? gdcm::DocEntry *d; uint32_t offset; uint32_t lgth; uint32_t valLgth; std::string *spaces; for (ListElements::iterator it = AnonymizeList.begin(); it != AnonymizeList.end(); ++it) { d = GetDocEntry( (*it).Group, (*it).Elem); if ( d == NULL) continue; if ( dynamic_cast<BinEntry *>(d) || dynamic_cast<SeqEntry *>(d) ) continue; offset = d->GetOffset(); lgth = d->GetLength(); if (valLgth < lgth) { spaces = new std::string( lgth-valLgth, ' '); (*it).Value = (*it).Value + *spaces; delete spaces; } fp->seekp( offset, std::ios::beg ); fp->write( (*it).Value.c_str(), lgth ); } fp->close(); delete fp; }

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; }

void gdcm::File::ClearAnonymizeList (   )  [inline]

Clears the list of elements to be anonymized. Definition at line 162 of file gdcmFile.h. { AnonymizeList.clear(); }

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 (   )  [inherited]

closes the file Returns: TRUE if the close was successfull Definition at line 464 of file gdcmDocument.cxx. References gdcm::Document::Fp. Referenced by gdcm::Document::Document(), File(), gdcm::FileHelper::GetRaw(), gdcm::Document::LoadEntryBinArea(), and gdcm::Document::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, inherited]

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 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::File::ComputeJPEGFragmentInfo (   )  [private]

Parse pixel data from disk of [multi-]fragment Jpeg encoding. Compute the jpeg extra information (fragment[s] offset[s] and length) and store it[them] in JPEGInfo for later pixel retrieval usage. Definition at line 1588 of file gdcmFile.cxx. References gdcm::JPEGFragmentsInfo::AddFragment(), gdcmWarningMacro, gdcm::Document::GetTransferSyntax(), JPEGInfo, ReadAndSkipEncapsulatedBasicOffsetTable(), ReadTag(), ReadTagLength(), gdcm::JPEGFragment::SetLength(), gdcm::JPEGFragment::SetOffset(), and gdcm::Document::SkipBytes(). Referenced by File(). { // If you need to, look for comments of ComputeRLEInfo(). std::string ts = GetTransferSyntax(); if ( ! Global::GetTS()->IsJPEG(ts) ) { return; } ReadAndSkipEncapsulatedBasicOffsetTable(); // Loop on the fragments[s] and store the parsed information in a // JPEGInfo. long fragmentLength; while ( (fragmentLength = ReadTagLength(0xfffe, 0xe000)) ) { long fragmentOffset = Fp->tellg(); // Store the collected info JPEGFragment *newFragment = new JPEGFragment; newFragment->SetOffset(fragmentOffset); newFragment->SetLength(fragmentLength); JPEGInfo->AddFragment(newFragment); SkipBytes(fragmentLength); } // Make sure that at the end of the item we encounter a 'Sequence // Delimiter Item': if ( !ReadTag(0xfffe, 0xe0dd) ) { gdcmWarningMacro( "No sequence delimiter item at end of JPEG item sequence"); } }

void gdcm::File::ComputeRLEInfo (   )  [private]

Parse pixel data from disk of [multi-]fragment RLE encoding. Compute the RLE extra information and store it in RLEInfo for later pixel retrieval usage. Definition at line 1492 of file gdcmFile.cxx. References gdcm::RLEFramesInfo::AddFrame(), gdcmWarningMacro, gdcm::Document::GetTransferSyntax(), ReadAndSkipEncapsulatedBasicOffsetTable(), gdcm::Document::ReadInt32(), ReadTag(), ReadTagLength(), RLEInfo, gdcm::RLEFrame::SetLength(), gdcm::RLEFrame::SetNumberOfFragments(), gdcm::RLEFrame::SetOffset(), and gdcm::Document::SkipBytes(). Referenced by File(). { std::string ts = GetTransferSyntax(); if ( !Global::GetTS()->IsRLELossless(ts) ) { return; } // Encoded pixel data: for the time being we are only concerned with // Jpeg or RLE Pixel data encodings. // As stated in PS 3.5-2003, section 8.2 p44: // "If sent in Encapsulated Format (i.e. other than the Native Format) the // value representation OB is used". // Hence we expect an OB value representation. Concerning OB VR, // the section PS 3.5-2003, section A.4.c p 58-59, states: // "For the Value Representations OB and OW, the encoding shall meet the // following specifications depending on the Data element tag:" // [...snip...] // - the first item in the sequence of items before the encoded pixel // data stream shall be basic offset table item. The basic offset table // item value, however, is not required to be present" ReadAndSkipEncapsulatedBasicOffsetTable(); // Encapsulated RLE Compressed Images (see PS 3.5-2003, Annex G) // Loop on the individual frame[s] and store the information // on the RLE fragments in a RLEFramesInfo. // Note: - when only a single frame is present, this is a // classical image. // - when more than one frame are present, then we are in // the case of a multi-frame image. long frameLength; while ( (frameLength = ReadTagLength(0xfffe, 0xe000)) ) { // Parse the RLE Header and store the corresponding RLE Segment // Offset Table information on fragments of this current Frame. // Note that the fragment pixels themselves are not loaded // (but just skipped). long frameOffset = Fp->tellg(); uint32_t nbRleSegments = ReadInt32(); if ( nbRleSegments > 16 ) { // There should be at most 15 segments (refer to RLEFrame class) gdcmWarningMacro( "Too many segments."); } uint32_t rleSegmentOffsetTable[16]; for( int k = 1; k <= 15; k++ ) { rleSegmentOffsetTable[k] = ReadInt32(); } // Deduce from both the RLE Header and the frameLength the // fragment length, and again store this info in a // RLEFramesInfo. long rleSegmentLength[15]; // skipping (not reading) RLE Segments if ( nbRleSegments > 1) { for(unsigned int k = 1; k <= nbRleSegments-1; k++) { rleSegmentLength[k] = rleSegmentOffsetTable[k+1] - rleSegmentOffsetTable[k]; SkipBytes(rleSegmentLength[k]); } } rleSegmentLength[nbRleSegments] = frameLength - rleSegmentOffsetTable[nbRleSegments]; SkipBytes(rleSegmentLength[nbRleSegments]); // Store the collected info RLEFrame *newFrame = new RLEFrame; newFrame->SetNumberOfFragments(nbRleSegments); for( unsigned int uk = 1; uk <= nbRleSegments; uk++ ) { newFrame->SetOffset(uk,frameOffset + rleSegmentOffsetTable[uk]); newFrame->SetLength(uk,rleSegmentLength[uk]); } RLEInfo->AddFrame(newFrame); } // Make sure that at the end of the item we encounter a 'Sequence // Delimiter Item': if ( !ReadTag(0xfffe, 0xe0dd) ) { gdcmWarningMacro( "No sequence delimiter item at end of RLE item sequence"); } }

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); }

int gdcm::File::GetBitsAllocated (   )

Retrieve the number of Bits Allocated (8, 12 -compacted ACR-NEMA files, 16, ...). Returns: The encountered number of Bits Allocated, 0 by default. 0 means the file is NOT USABLE. The caller has to check it ! Definition at line 675 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::FileHelper::CheckWriteIntegrity(), File(), gdcm::PixelReadConvert::GrabInformationsFromFile(), gdcm::FileHelper::SetWriteToRaw(), and gdcm::FileHelper::SetWriteToRGB(). { std::string strSize = GetEntryValue(0x0028,0x0100); if ( strSize == GDCM_UNFOUND ) { gdcmWarningMacro( "(0028,0100) is supposed to be mandatory"); return 0; // It's supposed to be mandatory // the caller will have to check } return atoi( strSize.c_str() ); }

int gdcm::File::GetBitsStored (   )

Retrieve the number of Bits Stored (actually used) (as opposed to number of Bits Allocated). Returns: The encountered number of Bits Stored, 0 by default. 0 means the file is NOT USABLE. The caller has to check it ! Definition at line 657 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { std::string strSize = GetEntryValue( 0x0028, 0x0101 ); if ( strSize == GDCM_UNFOUND ) { gdcmWarningMacro("(0028,0101) is supposed to be mandatory"); return 0; // It's supposed to be mandatory // the caller will have to check } return atoi( strSize.c_str() ); }

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 gdcm::Document::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 AnonymizeFile(), AnonymizeNoLoad(), gdcm::FileHelper::CopyBinEntry(), gdcm::FileHelper::CopyValEntry(), gdcm::DicomDir::CreateDicomDir(), gdcm::DicomDir::DicomDir(), File(), GetPixelAreaLength(), GetPixelOffset(), gdcm::Document::GetTransferSyntax(), HasLUT(), gdcm::Document::IsDicomV3(), gdcm::Document::IsPapyrus(), IsReadable(), gdcm::Document::LoadEntryBinArea(), gdcm::DocEntryArchive::Push(), gdcm::DocEntryArchive::Restore(), gdcm::FileHelper::SetWriteToLibido(), gdcm::FileHelper::SetWriteToNoLibido(), and Write(). { TagKey key = DictEntry::TranslateToKey(group, elem); TagDocEntryHT::iterator it = TagHT.find(key); if ( it!=TagHT.end() ) return it->second; return NULL; }

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

Gets (from Header) a 'non string' element value. Parameters: group  group number of the Entry elem  element number of the Entry Returns: Pointer to the 'non string' area Definition at line 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 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(), AnonymizeFile(), gdcm::Document::Document(), File(), GetBitsAllocated(), GetBitsStored(), GetHighBitPosition(), GetImageNumber(), GetImageOrientationPatient(), GetLUTNbits(), GetModality(), GetNumberOfScalarComponents(), GetPixelType(), GetPlanarConfiguration(), GetRescaleIntercept(), GetRescaleSlope(), GetSamplesPerPixel(), gdcm::Document::GetTransferSyntaxName(), GetXOrigin(), GetXSize(), GetXSpacing(), GetYOrigin(), GetYSize(), GetYSpacing(), GetZOrigin(), GetZSize(), GetZSpacing(), gdcm::PixelReadConvert::GrabInformationsFromFile(), IsMonochrome(), IsPaletteColor(), IsReadable(), IsSignedPixelData(), IsYBRFull(), gdcm::Document::operator<(), gdcm::DicomDir::SetElement(), and 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, inherited]

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 (   )  [inherited]

returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown) Returns: the FileType code Definition at line 276 of file gdcmDocument.cxx. References gdcm::Document::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 gdcm::Document::ComputeGroup0002Length(), gdcm::DicomDir::DicomDir(), and gdcm::DicomDir::NewMeta(). { ItTagHT = TagHT.begin(); if (ItTagHT != TagHT.end()) return ItTagHT->second; return NULL; }

uint16_t gdcm::File::GetGrPixel (   )  [inline]

Accessor to File::GrPixel. Definition at line 146 of file gdcmFile.h. { return GrPixel; }

int gdcm::File::GetHighBitPosition (   )

Retrieve the high bit position. Warning: The method defaults to 0 when information is Missing. The responsability of checking this value is left to the caller. Returns: The high bit positin when present. 0 when Missing. Definition at line 693 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { std::string strSize = GetEntryValue( 0x0028, 0x0102 ); if ( strSize == GDCM_UNFOUND ) { gdcmWarningMacro( "(0028,0102) is supposed to be mandatory"); return 0; } return atoi( strSize.c_str() ); }

int gdcm::File::GetImageNumber (   )

gets the info from 0020,0013 : Image Number else 0. Returns: image number Definition at line 217 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::SerieHelper::ImageNumberLessThan(). { // The function i atoi() takes the address of an area of memory as // parameter and converts the string stored at that location to an integer // using the external decimal to internal binary conversion rules. This may // be preferable to sscanf() since atoi() is a much smaller, simpler and // faster function. sscanf() can do all possible conversions whereas // atoi() can only do single decimal integer conversions. //0020 0013 IS REL Image Number std::string strImNumber = GetEntryValue(0x0020,0x0013); if ( strImNumber != GDCM_UNFOUND ) { return atoi( strImNumber.c_str() ); } return 0; //Hopeless }

void gdcm::File::GetImageOrientationPatient (  float  iop[6]  )

gets the info from 0020,0037 : Image Orientation Patient (needed to organize DICOM files based on their x,y,z position) Parameters: iop  adress of the (6)float aray to receive values Returns: cosines of image orientation patient Definition at line 624 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). { std::string strImOriPat; //iop is supposed to be float[6] iop[0] = iop[1] = iop[2] = iop[3] = iop[4] = iop[5] = 0.; // 0020 0037 DS REL Image Orientation (Patient) if ( (strImOriPat = GetEntryValue(0x0020,0x0037)) != GDCM_UNFOUND ) { if( sscanf( strImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f", &iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6 ) { gdcmWarningMacro( "Wrong Image Orientation Patient (0020,0037). Less than 6 values were found." ); } } //For ACR-NEMA // 0020 0035 DS REL Image Orientation (RET) else if ( (strImOriPat = GetEntryValue(0x0020,0x0035)) != GDCM_UNFOUND ) { if( sscanf( strImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f", &iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6 ) { gdcmWarningMacro( "wrong Image Orientation Patient (0020,0035). Less than 6 values were found." ); } } }

JPEGFragmentsInfo* gdcm::File::GetJPEGInfo (   )  [inline]

Returns the JPEG Fragments info. Definition at line 156 of file gdcmFile.h. Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { return JPEGInfo; }

int gdcm::File::GetLUTNbits (   )

gets the info from 0028,1101 : Lookup Table Desc-Red else 0 Returns: Lookup Table number of Bits , 0 by default when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] @ return bit number of each LUT item Definition at line 961 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, and gdcm::DocEntrySet::GetEntryValue(). { std::vector<std::string> tokens; int lutNbits; //Just hope Lookup Table Desc-Red = Lookup Table Desc-Red // = Lookup Table Desc-Blue // Consistency already checked in GetLUTLength std::string lutDescription = GetEntryValue(0x0028,0x1101); if ( lutDescription == GDCM_UNFOUND ) { return 0; } tokens.clear(); // clean any previous value Util::Tokenize ( lutDescription, tokens, "\\" ); //LutLength=atoi(tokens[0].c_str()); //LutDepth=atoi(tokens[1].c_str()); lutNbits = atoi( tokens[2].c_str() ); tokens.clear(); return lutNbits; }

ModalityType gdcm::File::GetModality (   )

gets the info from 0008,0060 : Modality Returns: Modality Type Todo: throw error return value ??? specified <> unknown in our database Definition at line 238 of file gdcmFile.cxx. References gdcm::AS, gdcm::AU, gdcm::BI, gdcm::CF, gdcm::CP, gdcm::CR, gdcm::CS, gdcm::CT, gdcm::DD, gdcm::DF, gdcm::DG, gdcm::DM, gdcm::DS, gdcm::DX, gdcm::ECG, gdcm::EPS, gdcm::FA, gdcm::FS, gdcm::GDCM_UNFOUND, gdcm::DocEntrySet::GetEntryValue(), gdcm::HC, gdcm::HD, gdcm::LP, gdcm::LS, gdcm::MA, gdcm::ModalityType, gdcm::MR, gdcm::NM, gdcm::OT, gdcm::PT, gdcm::RF, gdcm::RG, gdcm::RTDOSE, gdcm::RTIMAGE, gdcm::RTPLAN, gdcm::RTSTRUCT, gdcm::SM, gdcm::ST, gdcm::TG, gdcm::Unknow, gdcm::US, gdcm::VF, gdcm::XA, and gdcm::XC. { // 0008 0060 CS ID Modality std::string strModality = GetEntryValue(0x0008,0x0060); if ( strModality != GDCM_UNFOUND ) { if ( strModality.find("AU") < strModality.length()) return AU; else if ( strModality.find("AS") < strModality.length()) return AS; else if ( strModality.find("BI") < strModality.length()) return BI; else if ( strModality.find("CF") < strModality.length()) return CF; else if ( strModality.find("CP") < strModality.length()) return CP; else if ( strModality.find("CR") < strModality.length()) return CR; else if ( strModality.find("CT") < strModality.length()) return CT; else if ( strModality.find("CS") < strModality.length()) return CS; else if ( strModality.find("DD") < strModality.length()) return DD; else if ( strModality.find("DF") < strModality.length()) return DF; else if ( strModality.find("DG") < strModality.length()) return DG; else if ( strModality.find("DM") < strModality.length()) return DM; else if ( strModality.find("DS") < strModality.length()) return DS; else if ( strModality.find("DX") < strModality.length()) return DX; else if ( strModality.find("ECG") < strModality.length()) return ECG; else if ( strModality.find("EPS") < strModality.length()) return EPS; else if ( strModality.find("FA") < strModality.length()) return FA; else if ( strModality.find("FS") < strModality.length()) return FS; else if ( strModality.find("HC") < strModality.length()) return HC; else if ( strModality.find("HD") < strModality.length()) return HD; else if ( strModality.find("LP") < strModality.length()) return LP; else if ( strModality.find("LS") < strModality.length()) return LS; else if ( strModality.find("MA") < strModality.length()) return MA; else if ( strModality.find("MR") < strModality.length()) return MR; else if ( strModality.find("NM") < strModality.length()) return NM; else if ( strModality.find("OT") < strModality.length()) return OT; else if ( strModality.find("PT") < strModality.length()) return PT; else if ( strModality.find("RF") < strModality.length()) return RF; else if ( strModality.find("RG") < strModality.length()) return RG; else if ( strModality.find("RTDOSE") < strModality.length()) return RTDOSE; else if ( strModality.find("RTIMAGE") < strModality.length()) return RTIMAGE; else if ( strModality.find("RTPLAN") < strModality.length()) return RTPLAN; else if ( strModality.find("RTSTRUCT") < strModality.length()) return RTSTRUCT; else if ( strModality.find("SM") < strModality.length()) return SM; else if ( strModality.find("ST") < strModality.length()) return ST; else if ( strModality.find("TG") < strModality.length()) return TG; else if ( strModality.find("US") < strModality.length()) return US; else if ( strModality.find("VF") < strModality.length()) return VF; else if ( strModality.find("XA") < strModality.length()) return XA; else if ( strModality.find("XC") < strModality.length()) return XC; else { return Unknow; } } return Unknow; }

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 gdcm::Document::ComputeGroup0002Length(). { gdcmAssertMacro (ItTagHT != TagHT.end()); ++ItTagHT; if (ItTagHT != TagHT.end()) return ItTagHT->second; return NULL; }

int gdcm::File::GetNumberOfScalarComponents (   )

This function is intended to user who doesn't want to have to manage a LUT and expects to get an RBG Pixel image (or a monochrome one ...). Warning: to be used with GetImagePixels() Returns: 1 if Gray level, 3 if Color (RGB, YBR or PALETTE COLOR) Definition at line 1035 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcm::DocEntrySet::GetEntryValue(), GetSamplesPerPixel(), and HasLUT(). Referenced by vtkGdcmReader::CheckFileCoherence(), gdcm::FileHelper::SetWriteToRaw(), and gdcm::FileHelper::SetWriteToRGB(). { if ( GetSamplesPerPixel() == 3 ) { return 3; } // 0028 0100 US IMG Bits Allocated // (in order no to be messed up by old RGB images) if ( GetEntryValue(0x0028,0x0100) == "24" ) { return 3; } std::string strPhotometricInterpretation = GetEntryValue(0x0028,0x0004); if ( ( strPhotometricInterpretation == "PALETTE COLOR ") ) { if ( HasLUT() )// PALETTE COLOR is NOT enough { return 3; } else { return 1; } } // beware of trailing space at end of string // DICOM tags are never of odd length if ( strPhotometricInterpretation == GDCM_UNFOUND || Util::DicomStringEqual(strPhotometricInterpretation, "MONOCHROME1") || Util::DicomStringEqual(strPhotometricInterpretation, "MONOCHROME2") ) { return 1; } else { // we assume that *all* kinds of YBR are dealt with return 3; } }

int gdcm::File::GetNumberOfScalarComponentsRaw (   )

This function is intended to user that DOESN'T want to get RGB pixels image when it's stored as a PALETTE COLOR image -the (vtk) user is supposed to know how deal with LUTs -. Warning: to be used with GetImagePixelsRaw() Returns: 1 if Gray level, 3 if Color (RGB or YBR - NOT 'PALETTE COLOR' -) Definition at line 1085 of file gdcmFile.cxx. References GetSamplesPerPixel(). Referenced by vtkGdcmReader::CheckFileCoherence(). { // 0028 0100 US IMG Bits Allocated // (in order no to be messed up by old RGB images) if ( File::GetEntryValue(0x0028,0x0100) == "24" ) { return 3; } // we assume that *all* kinds of YBR are dealt with return GetSamplesPerPixel(); }

uint16_t gdcm::File::GetNumPixel (   )  [inline]

Accessor to File::NumPixel. Definition at line 148 of file gdcmFile.h. { return NumPixel; }

size_t gdcm::File::GetPixelAreaLength (   )

Recover the pixel area length (in Bytes). Returns: Pixel Element Length, as stored in the header (NOT the memory space necessary to hold the Pixels -in case of embeded compressed image-) 0 : NOT USABLE file. The caller has to check. Definition at line 1125 of file gdcmFile.cxx. References gdcmDebugMacro, gdcm::ElementSet::GetDocEntry(), gdcm::DocEntry::GetLength(), GrPixel, and NumPixel. Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { DocEntry *pxlElement = GetDocEntry(GrPixel, NumPixel); if ( pxlElement ) { return pxlElement->GetLength(); } else { gdcmDebugMacro( "Big trouble : Pixel Element (" << std::hex << GrPixel<<","<< NumPixel<< ") NOT found" ); return 0; } }

size_t gdcm::File::GetPixelOffset (   )

Recover the offset (from the beginning of the file) of *image* pixels (not *icone image* pixels, if any !). Returns: Pixel Offset Definition at line 1103 of file gdcmFile.cxx. References gdcmDebugMacro, gdcm::ElementSet::GetDocEntry(), gdcm::DocEntry::GetOffset(), GrPixel, and NumPixel. Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { DocEntry *pxlElement = GetDocEntry(GrPixel, NumPixel); if ( pxlElement ) { return pxlElement->GetOffset(); } else { gdcmDebugMacro( "Big trouble : Pixel Element (" << std::hex << GrPixel<<","<< NumPixel<< ") NOT found" ); return 0; } }

int gdcm::File::GetPixelSize (   )

Return the size (in bytes) of a single pixel of data. Returns: The size in bytes of a single pixel of data; 0 by default 0 means the file is NOT USABLE; the caller will have to check Definition at line 743 of file gdcmFile.cxx. References gdcmWarningMacro, and GetPixelType(). Referenced by vtkGdcmReader::CheckFileCoherence(), and gdcm::PixelReadConvert::GrabInformationsFromFile(). { // 0028 0100 US IMG Bits Allocated // (in order no to be messed up by old RGB images) // if (File::GetEntryValue(0x0028,0x0100) == "24") // return 3; std::string pixelType = GetPixelType(); if ( pixelType == "8U" || pixelType == "8S" ) { return 1; } if ( pixelType == "16U" || pixelType == "16S") { return 2; } if ( pixelType == "32U" || pixelType == "32S") { return 4; } if ( pixelType == "FD" ) { return 8; } gdcmWarningMacro( "Unknown pixel type"); return 0; }

std::string gdcm::File::GetPixelType (   )

Build the Pixel Type of the image. Possible values are: -8U unsigned 8 bit, -8S signed 8 bit, -16U unsigned 16 bit, -16S signed 16 bit, -32U unsigned 32 bit, -32S signed 32 bit, -FD floating double 64 bits (Not kosher DICOM, but so usefull!). Warning: 12 bit images appear as 16 bit. 24 bit images appear as 8 bit Returns: 0S if nothing found. NOT USABLE file. The caller has to check Definition at line 785 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by vtkGdcmReader::CheckFileCoherence(), and GetPixelSize(). { std::string bitsAlloc = GetEntryValue(0x0028, 0x0100); // Bits Allocated if ( bitsAlloc == GDCM_UNFOUND ) { gdcmWarningMacro( "Missing Bits Allocated (0028,0100)"); bitsAlloc = "16"; // default and arbitrary value, not to polute the output } if ( bitsAlloc == "64" ) { return "FD"; } else if ( bitsAlloc == "12" ) { // It will be unpacked bitsAlloc = "16"; } else if ( bitsAlloc == "24" ) { // (in order no to be messed up bitsAlloc = "8"; // by old RGB images) } std::string sign = GetEntryValue(0x0028, 0x0103);//"Pixel Representation" if (sign == GDCM_UNFOUND ) { gdcmWarningMacro( "Missing Pixel Representation (0028,0103)"); sign = "U"; // default and arbitrary value, not to polute the output } else if ( sign == "0" ) { sign = "U"; } else { sign = "S"; } return bitsAlloc + sign; }

int gdcm::File::GetPlanarConfiguration (   )

Retrieve the Planar Configuration for RGB images (0 : RGB Pixels , 1 : R Plane + G Plane + B Plane). Returns: The encountered Planar Configuration, 0 by default. Definition at line 727 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { std::string strSize = GetEntryValue(0x0028,0x0006); if ( strSize == GDCM_UNFOUND ) { gdcmWarningMacro( "Not found : Planar Configuration (0028,0006)"); return 0; } return atoi( strSize.c_str() ); }

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 (   )  [inherited]

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

float gdcm::File::GetRescaleIntercept (   )

gets the info from 0028,1052 : Rescale Intercept Returns: Rescale Intercept 0028 1052 DS IMG Rescale Intercept Definition at line 990 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). { float resInter = 0.; const std::string &strRescInter = GetEntryValue(0x0028,0x1052); if ( strRescInter != GDCM_UNFOUND ) { if( sscanf( strRescInter.c_str(), "%f", &resInter) != 1 ) { // bug in the element 0x0028,0x1052 gdcmWarningMacro( "Rescale Intercept (0028,1052) is empty." ); } } return resInter; }

float gdcm::File::GetRescaleSlope (   )

gets the info from 0028,1053 : Rescale Slope Returns: Rescale Slope Definition at line 1011 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). { float resSlope = 1.; //0028 1053 DS IMG Rescale Slope std::string strRescSlope = GetEntryValue(0x0028,0x1053); if ( strRescSlope != GDCM_UNFOUND ) { if( sscanf( strRescSlope.c_str(), "%f", &resSlope) != 1) { // bug in the element 0x0028,0x1053 gdcmWarningMacro( "Rescale Slope (0028,1053) is empty."); } } return resSlope; }

RLEFramesInfo* gdcm::File::GetRLEInfo (   )  [inline]

returns the RLE info Definition at line 154 of file gdcmFile.h. Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { return RLEInfo; }

int gdcm::File::GetSamplesPerPixel (   )

Retrieve the number of Samples Per Pixel (1 : gray level, 3 : RGB -1 or 3 Planes-). Returns: The encountered number of Samples Per Pixel, 1 by default. (Gray level Pixels) Definition at line 710 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::FileHelper::CheckWriteIntegrity(), GetNumberOfScalarComponents(), GetNumberOfScalarComponentsRaw(), and gdcm::PixelReadConvert::GrabInformationsFromFile(). { const std::string &strSize = GetEntryValue(0x0028,0x0002); if ( strSize == GDCM_UNFOUND ) { gdcmWarningMacro( "(0028,0002) is supposed to be mandatory"); return 1; // Well, it's supposed to be mandatory ... // but sometimes it's missing : *we* assume Gray pixels } return atoi( strSize.c_str() ); }

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 (   )  [inherited]

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

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

'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 (   )  [inherited]

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 gdcm::Document::LoadDocEntrySafe(). Referenced by ComputeJPEGFragmentInfo(), ComputeRLEInfo(), File(), gdcm::PixelReadConvert::GrabInformationsFromFile(), and gdcm::Document::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 (   )  [inherited]

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 gdcm::Document::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 Write(). { DocEntry *currentEntry = GetDocEntry(group, elem); if ( !currentEntry ) return NULL; return dynamic_cast<ValEntry*>(currentEntry); }

float gdcm::File::GetXOrigin (   )

gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0. Returns: up-left image corner X position Definition at line 490 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). { float xImPos, yImPos, zImPos; std::string strImPos = GetEntryValue(0x0020,0x0032); if ( strImPos == GDCM_UNFOUND ) { gdcmWarningMacro( "Unfound Image Position Patient (0020,0032)"); strImPos = GetEntryValue(0x0020,0x0030); // For ACR-NEMA images if ( strImPos == GDCM_UNFOUND ) { gdcmWarningMacro( "Unfound Image Position (RET) (0020,0030)"); return 0.; } } if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3 ) { return 0.; } return xImPos; }

int gdcm::File::GetXSize (   )

Retrieve the number of columns of image. Returns: The encountered size when found, 0 by default. 0 means the file is NOT USABLE. The caller will have to check Definition at line 301 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, and gdcm::DocEntrySet::GetEntryValue(). Referenced by vtkGdcmReader::CheckFileCoherence(), gdcm::FileHelper::CheckWriteIntegrity(), and gdcm::PixelReadConvert::GrabInformationsFromFile(). { const std::string &strSize = GetEntryValue(0x0028,0x0011); if ( strSize == GDCM_UNFOUND ) { return 0; } return atoi( strSize.c_str() ); }

float gdcm::File::GetXSpacing (   )

gets the info from 0028,0030 : Pixel Spacing else 1.0 Returns: X dimension of a pixel Definition at line 368 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmAssertMacro, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by vtkGdcmReader::CheckFileCoherence(). { float xspacing = 1.0; float yspacing = 1.0; const std::string &strSpacing = GetEntryValue(0x0028,0x0030); if( strSpacing == GDCM_UNFOUND ) { gdcmWarningMacro( "Unfound Pixel Spacing (0028,0030)" ); return 1.; } int nbValues; if( ( nbValues = sscanf( strSpacing.c_str(), "%f\\%f", &yspacing, &xspacing)) != 2 ) { // if no values, xspacing is set to 1.0 if( nbValues == 0 ) xspacing = 1.0; // if single value is found, xspacing is defaulted to yspacing if( nbValues == 1 ) xspacing = yspacing; if ( xspacing == 0.0 ) xspacing = 1.0; return xspacing; } // to avoid troubles with David Clunie's-like images if ( xspacing == 0. && yspacing == 0.) return 1.; if ( xspacing == 0.) { gdcmWarningMacro("gdcmData/CT-MONO2-8-abdo.dcm problem"); // seems to be a bug in the header ... nbValues = sscanf( strSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing); gdcmAssertMacro( nbValues == 2 ); } return xspacing; }

float gdcm::File::GetYOrigin (   )

gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0. Returns: up-left image corner Y position Definition at line 520 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). { float xImPos, yImPos, zImPos; std::string strImPos = GetEntryValue(0x0020,0x0032); if ( strImPos == GDCM_UNFOUND) { gdcmWarningMacro( "Unfound Image Position Patient (0020,0032)"); strImPos = GetEntryValue(0x0020,0x0030); // For ACR-NEMA images if ( strImPos == GDCM_UNFOUND ) { gdcmWarningMacro( "Unfound Image Position (RET) (0020,0030)"); return 0.; } } if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3 ) { return 0.; } return yImPos; }

int gdcm::File::GetYSize (   )

Retrieve the number of lines of image. Warning: The defaulted value is 1 as opposed to File::GetXSize() Returns: The encountered size when found, 1 by default (The ACR-NEMA file contains a Signal, not an Image). Definition at line 318 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcm::DocEntrySet::GetEntryValue(), and gdcm::Document::IsDicomV3(). Referenced by vtkGdcmReader::CheckFileCoherence(), gdcm::FileHelper::CheckWriteIntegrity(), and gdcm::PixelReadConvert::GrabInformationsFromFile(). { const std::string &strSize = GetEntryValue(0x0028,0x0010); if ( strSize != GDCM_UNFOUND ) { return atoi( strSize.c_str() ); } if ( IsDicomV3() ) { return 0; } // The Rows (0028,0010) entry was optional for ACR/NEMA. It might // hence be a signal (1D image). So we default to 1: return 1; }

float gdcm::File::GetYSpacing (   )

gets the info from 0028,0030 : Pixel Spacing else 1.0 Returns: Y dimension of a pixel Definition at line 418 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by vtkGdcmReader::CheckFileCoherence(). { float yspacing = 1.; std::string strSpacing = GetEntryValue(0x0028,0x0030); if ( strSpacing == GDCM_UNFOUND ) { gdcmWarningMacro("Unfound Pixel Spacing (0028,0030)"); return 1.; } // if sscanf cannot read any float value, it won't affect yspacing int nbValues = sscanf( strSpacing.c_str(), "%f", &yspacing); // if no values, xspacing is set to 1.0 if( nbValues == 0 ) yspacing = 1.0; if ( yspacing == 0.0 ) yspacing = 1.0; return yspacing; }

float gdcm::File::GetZOrigin (   )

gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else from 0020,1041 : Slice Location else from 0020,0050 : Location else 0. Returns: up-left image corner Z position Definition at line 552 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). { float xImPos, yImPos, zImPos; std::string strImPos = GetEntryValue(0x0020,0x0032); if ( strImPos != GDCM_UNFOUND ) { if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) { gdcmWarningMacro( "Wrong Image Position Patient (0020,0032)"); return 0.; // bug in the element 0x0020,0x0032 } else { return zImPos; } } strImPos = GetEntryValue(0x0020,0x0030); // For ACR-NEMA images if ( strImPos != GDCM_UNFOUND ) { if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos ) != 3 ) { gdcmWarningMacro( "Wrong Image Position (RET) (0020,0030)"); return 0.; // bug in the element 0x0020,0x0032 } else { return zImPos; } } std::string strSliceLocation = GetEntryValue(0x0020,0x1041); // for *very* old ACR-NEMA images if ( strSliceLocation != GDCM_UNFOUND ) { if( sscanf( strSliceLocation.c_str(), "%f", &zImPos) != 1) { gdcmWarningMacro( "Wrong Slice Location (0020,1041)"); return 0.; // bug in the element 0x0020,0x1041 } else { return zImPos; } } gdcmWarningMacro( "Unfound Slice Location (0020,1041)"); std::string strLocation = GetEntryValue(0x0020,0x0050); if ( strLocation != GDCM_UNFOUND ) { if( sscanf( strLocation.c_str(), "%f", &zImPos) != 1) { gdcmWarningMacro( "Wrong Location (0020,0050)"); return 0.; // bug in the element 0x0020,0x0050 } else { return zImPos; } } gdcmWarningMacro( "Unfound Location (0020,0050)"); return 0.; // Hopeless }

int gdcm::File::GetZSize (   )

Retrieve the number of planes of volume or the number of frames of a multiframe. Warning: When present we consider the "Number of Frames" as the third dimension. When Missing we consider the third dimension as being the ACR-NEMA "Planes" tag content. Returns: The encountered size when found, 1 by default (single image). Definition at line 343 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, and gdcm::DocEntrySet::GetEntryValue(). Referenced by vtkGdcmReader::CheckFileCoherence(), gdcm::FileHelper::CheckWriteIntegrity(), and gdcm::PixelReadConvert::GrabInformationsFromFile(). { // Both DicomV3 and ACR/Nema consider the "Number of Frames" // as the third dimension. const std::string &strSize = GetEntryValue(0x0028,0x0008); if ( strSize != GDCM_UNFOUND ) { return atoi( strSize.c_str() ); } // We then consider the "Planes" entry as the third dimension const std::string &strSize2 = GetEntryValue(0x0028,0x0012); if ( strSize2 != GDCM_UNFOUND ) { return atoi( strSize2.c_str() ); } return 1; }

float gdcm::File::GetZSpacing (   )

gets the info from 0018,0088 : Space Between Slices else from 0018,0050 : Slice Thickness else 1.0 Returns: Z dimension of a voxel-to be Definition at line 448 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by vtkGdcmReader::CheckFileCoherence(). { // Spacing Between Slices : distance entre le milieu de chaque coupe // Les coupes peuvent etre : // jointives (Spacing between Slices = Slice Thickness) // chevauchantes (Spacing between Slices < Slice Thickness) // disjointes (Spacing between Slices > Slice Thickness) // Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal // ca interesse le physicien de l'IRM, pas le visualisateur de volumes ... // Si le Spacing Between Slices est Missing, // on suppose que les coupes sont jointives const std::string &strSpacingBSlices = GetEntryValue(0x0018,0x0088); if ( strSpacingBSlices == GDCM_UNFOUND ) { gdcmWarningMacro("Unfound Spacing Between Slices (0018,0088)"); const std::string &strSliceThickness = GetEntryValue(0x0018,0x0050); if ( strSliceThickness == GDCM_UNFOUND ) { gdcmWarningMacro("Unfound Slice Thickness (0018,0050)"); return 1.; } else { // if no 'Spacing Between Slices' is found, // we assume slices join together // (no overlapping, no interslice gap) // if they don't, we're fucked up return (float)atof( strSliceThickness.c_str() ); } } //else return (float)atof( strSpacingBSlices.c_str() ); }

bool gdcm::File::HasLUT (   )

tells us if LUT are used Warning: Right now, 'Segmented xxx Palette Color Lookup Table Data' are NOT considered as LUT, since nobody knows how to deal with them Please warn me if you know sbdy that *does* know ... jprx Returns: true if LUT Descriptors and LUT Tables were found Definition at line 915 of file gdcmFile.cxx. References gdcm::ElementSet::GetDocEntry(). Referenced by vtkGdcmReader::CheckFileCoherence(), gdcm::FileHelper::CheckWriteIntegrity(), gdcm::FileHelper::GetImageData(), gdcm::FileHelper::GetImageDataIntoVector(), GetNumberOfScalarComponents(), gdcm::PixelReadConvert::GrabInformationsFromFile(), and gdcm::FileHelper::SetWriteToRaw(). { // Check the presence of the LUT Descriptors, and LUT Tables // LutDescriptorRed if ( !GetDocEntry(0x0028,0x1101) ) { return false; } // LutDescriptorGreen if ( !GetDocEntry(0x0028,0x1102) ) { return false; } // LutDescriptorBlue if ( !GetDocEntry(0x0028,0x1103) ) { return false; } // Red Palette Color Lookup Table Data if ( !GetDocEntry(0x0028,0x1201) ) { return false; } // Green Palette Color Lookup Table Data if ( !GetDocEntry(0x0028,0x1202) ) { return false; } // Blue Palette Color Lookup Table Data if ( !GetDocEntry(0x0028,0x1203) ) { return false; } // FIXME : (0x0028,0x3006) : LUT Data (CTX dependent) // NOT taken into account, but we don't know how to use it ... return true; }

void gdcm::File::InitializeDefaultFile (   )  [protected]

Initialize a default DICOM File that should contain all the field require by other reader. DICOM standard does not explicitely defines those fields, heuristic has been choosen. This is not perfect as we are writting a CT image... Definition at line 1406 of file gdcmFile.cxx. References GrPixel, gdcm::DocEntrySet::InsertBinEntry(), gdcm::DocEntrySet::InsertValEntry(), and NumPixel. Referenced by File(). { std::string date = Util::GetCurrentDate(); std::string time = Util::GetCurrentTime(); std::string uid = Util::CreateUniqueUID(); std::string uidMedia = uid; std::string uidInst = uid; std::string uidClass = Util::CreateUniqueUID(); std::string uidStudy = Util::CreateUniqueUID(); std::string uidSerie = Util::CreateUniqueUID(); // Meta Element Group Length InsertValEntry("146 ", 0x0002, 0x0000); // Media Storage SOP Class UID (CT Image Storage) InsertValEntry("1.2.840.10008.5.1.4.1.1.2", 0x0002, 0x0002); // Media Storage SOP Instance UID InsertValEntry(uidMedia.c_str(), 0x0002, 0x0003); // Transfer Syntax UID (Explicit VR Little Endian) InsertValEntry("1.2.840.10008.1.2.1 ", 0x0002, 0x0010); // META Implementation Class UID InsertValEntry(uidClass.c_str(), 0x0002, 0x0012); // Source Application Entity Title InsertValEntry("GDCM", 0x0002, 0x0016); // Instance Creation Date InsertValEntry(date.c_str(), 0x0008, 0x0012); // Instance Creation Time InsertValEntry(time.c_str(), 0x0008, 0x0013); // SOP Class UID InsertValEntry("1.2.840.10008.5.1.4.1.1.2", 0x0008, 0x0016); // SOP Instance UID InsertValEntry(uidInst.c_str(), 0x0008, 0x0018); // Modality InsertValEntry("CT", 0x0008, 0x0060); // Manufacturer InsertValEntry("GDCM", 0x0008, 0x0070); // Institution Name InsertValEntry("GDCM", 0x0008, 0x0080); // Institution Address InsertValEntry("http://www-creatis.insa-lyon.fr/Public/Gdcm", 0x0008, 0x0081); // Patient's Name InsertValEntry("GDCM", 0x0010, 0x0010); // Patient ID InsertValEntry("GDCMID", 0x0010, 0x0020); // Study Instance UID InsertValEntry(uidStudy.c_str(), 0x0020, 0x000d); // Series Instance UID InsertValEntry(uidSerie.c_str(), 0x0020, 0x000e); // StudyID InsertValEntry("1", 0x0020, 0x0010); // SeriesNumber InsertValEntry("1", 0x0020, 0x0011); // Samples per pixel 1 or 3 InsertValEntry("1", 0x0028, 0x0002); // photochromatic interpretation InsertValEntry("MONOCHROME1", 0x0028, 0x0004); // nbRows InsertValEntry("0", 0x0028, 0x0010); // nbCols InsertValEntry("0", 0x0028, 0x0011); // BitsAllocated 8 or 12 or 16 InsertValEntry("8", 0x0028, 0x0100); // BitsStored <= BitsAllocated InsertValEntry("8", 0x0028, 0x0101); // HighBit <= BitsAllocated - 1 InsertValEntry("7", 0x0028, 0x0102); // Pixel Representation 0(unsigned) or 1(signed) InsertValEntry("0", 0x0028, 0x0103); // default value // Special case this is the image (not a string) GrPixel = 0x7fe0; NumPixel = 0x0010; InsertBinEntry(0, 0, GrPixel, NumPixel); }

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 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 InitializeDefaultFile(), gdcm::FileHelper::InsertValEntry(), and 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 (   )  [inherited]

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 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::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 gdcm::Document::IsReadable(). { return TagHT.empty(); };

bool gdcm::File::IsMonochrome (   )

Check whether this a monochrome picture or not by accessing the "Photometric Interpretation" tag ( 0x0028, 0x0004 ). Returns: true when "MONOCHROME1" or "MONOCHROME2". False otherwise. Definition at line 854 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { const std::string &PhotometricInterp = GetEntryValue( 0x0028, 0x0004 ); if ( Util::DicomStringEqual(PhotometricInterp, "MONOCHROME1") || Util::DicomStringEqual(PhotometricInterp, "MONOCHROME2") ) { return true; } if ( PhotometricInterp == GDCM_UNFOUND ) { gdcmWarningMacro( "Not found : Photometric Interpretation (0028,0004)"); } return false; }

bool gdcm::File::IsPaletteColor (   )

Check whether this a "PALETTE COLOR" picture or not by accessing the "Photometric Interpretation" tag ( 0x0028, 0x0004 ). Returns: true when "PALETTE COLOR". False otherwise. Definition at line 874 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { std::string PhotometricInterp = GetEntryValue( 0x0028, 0x0004 ); if ( PhotometricInterp == "PALETTE COLOR " ) { return true; } if ( PhotometricInterp == GDCM_UNFOUND ) { gdcmWarningMacro( "Not found : Palette color (0028,0004)"); } return false; }

bool gdcm::Document::IsPapyrus (   )  [inherited]

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::File::IsReadable (   )  [virtual]

This predicate, based on hopefully reasonable heuristics, decides whether or not the current File was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File. Returns: true when File is the one of a reasonable Dicom/Acr file, false otherwise. Reimplemented from gdcm::Document. Definition at line 181 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcm::ElementSet::GetDocEntry(), and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::SerieHelper::AddFileName(), vtkGdcmReader::CheckFileCoherence(), gdcm::DicomDir::CreateDicomDirChainedList(), and gdcm::FileHelper::Initialize(). { if( !Document::IsReadable() ) { return false; } const std::string &res = GetEntryValue(0x0028, 0x0005); if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 ) { return false; // Image Dimensions } if ( !GetDocEntry(0x0028, 0x0100) ) { return false; // "Bits Allocated" } if ( !GetDocEntry(0x0028, 0x0101) ) { return false; // "Bits Stored" } if ( !GetDocEntry(0x0028, 0x0102) ) { return false; // "High Bit" } if ( !GetDocEntry(0x0028, 0x0103) ) { return false; // "Pixel Representation" i.e. 'Sign' } return true; }

bool gdcm::File::IsSignedPixelData (   )

Check whether the pixels are signed or UNsigned data. Warning: The method defaults to false (UNsigned) when information is Missing. The responsability of checking this value is left to the caller. Returns: True when signed, false when UNsigned Definition at line 833 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { std::string strSize = GetEntryValue( 0x0028, 0x0103 ); if ( strSize == GDCM_UNFOUND ) { gdcmWarningMacro( "(0028,0103) is supposed to be mandatory"); return false; } int sign = atoi( strSize.c_str() ); if ( sign == 0 ) { return false; } return true; }

bool gdcm::File::IsYBRFull (   )

Check whether this a "YBR_FULL" color picture or not by accessing the "Photometric Interpretation" tag ( 0x0028, 0x0004 ). Returns: true when "YBR_FULL". False otherwise. Definition at line 893 of file gdcmFile.cxx. References gdcm::GDCM_UNFOUND, gdcmWarningMacro, and gdcm::DocEntrySet::GetEntryValue(). Referenced by gdcm::PixelReadConvert::GrabInformationsFromFile(). { std::string PhotometricInterp = GetEntryValue( 0x0028, 0x0004 ); if ( PhotometricInterp == "YBR_FULL" ) { return true; } if ( PhotometricInterp == GDCM_UNFOUND ) { gdcmWarningMacro( "Not found : YBR Full (0028,0004)"); } return false; }

void gdcm::Document::LoadDocEntrySafe (  DocEntry *  entry  )  [inherited]

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 gdcm::Document::Fp, and gdcm::Document::LoadDocEntry(). Referenced by gdcm::Document::GetTransferSyntax(). { if(Fp) { long PositionOnEntry = Fp->tellg(); LoadDocEntry(entry); Fp->seekg(PositionOnEntry, std::ios::beg); } }

void gdcm::Document::LoadEntryBinArea (  BinEntry *  elem  )  [virtual, inherited]

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 gdcm::Document::CloseFile(), gdcm::Document::Fp, gdcmWarningMacro, gdcm::BinEntry::GetBinArea(), gdcm::DocEntry::GetLength(), gdcm::DocEntry::GetOffset(), gdcm::Document::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, inherited]

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 gdcm::Document::Document(), gdcm::PixelReadConvert::GrabInformationsFromFile(), and gdcm::Document::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 gdcm::Document::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 gdcm::Document::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 gdcm::Document::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 File(), and gdcm::DocEntrySet::GetDictEntry(). { return Global::GetDicts()->NewVirtualDictEntry(group,elem,vr,vm,name); }

std::ifstream * gdcm::Document::OpenFile (   )  [inherited]

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 gdcm::Document::CloseFile(), gdcm::Document::Fp, gdcmDebugMacro, gdcmWarningMacro, and gdcm::Document::HasDCMPreamble. Referenced by gdcm::Document::Document(), File(), gdcm::FileHelper::GetRaw(), and gdcm::Document::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  )  [inherited]

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::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; } }

void gdcm::File::ReadAndSkipEncapsulatedBasicOffsetTable (   )  [private]

When parsing the Pixel Data of an encapsulated file, read the basic offset table (when present, and BTW dump it). Definition at line 1708 of file gdcmFile.cxx. References gdcmWarningMacro, ReadTagLength(), and str2num. Referenced by ComputeJPEGFragmentInfo(), and ComputeRLEInfo(). { uint32_t itemLength = ReadTagLength(0xfffe, 0xe000); // When present, read the basic offset table itself. // Notes: - since the presence of this basic offset table is optional // we can't rely on it for the implementation, and we will simply // trash it's content (when present). // - still, when present, we could add some further checks on the // lengths, but we won't bother with such fuses for the time being. if ( itemLength != 0 ) { char *basicOffsetTableItemValue = new char[itemLength + 1]; Fp->read(basicOffsetTableItemValue, itemLength); #ifdef GDCM_DEBUG for (unsigned int i=0; i < itemLength; i += 4 ) { uint32_t individualLength = str2num( &basicOffsetTableItemValue[i], uint32_t); gdcmWarningMacro( "Read one length: " << std::hex << individualLength ); } #endif //GDCM_DEBUG delete[] basicOffsetTableItemValue; } }

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

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 gdcm::Document::LoadDocEntry(), gdcm::Document::ReadNextDocEntry(), and 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, inherited]

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 ComputeRLEInfo(), gdcm::Document::LoadDocEntry(), and 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; }

bool gdcm::File::ReadTag (  uint16_t  testGroup, uint16_t  testElement )  [private]

Assuming the internal file pointer Document::Fp is placed at the beginning of a tag check whether this tag is (TestGroup, TestElement). Warning: On success the internal file pointer Document::Fp is modified to point after the tag. On failure (i.e. when the tag wasn't the expected tag (TestGroup, TestElement) the internal file pointer Document::Fp is restored to it's original position. Parameters: testGroup  The expected group of the tag. testElement  The expected Element of the tag. Returns: True on success, false otherwise. Definition at line 1636 of file gdcmFile.cxx. References gdcmWarningMacro, and gdcm::Document::ReadInt16(). Referenced by ComputeJPEGFragmentInfo(), ComputeRLEInfo(), and ReadTagLength(). { long positionOnEntry = Fp->tellg(); long currentPosition = Fp->tellg(); // On debugging purposes // Read the Item Tag group and element, and make // sure they are what we expected: uint16_t itemTagGroup; uint16_t itemTagElement; try { itemTagGroup = ReadInt16(); itemTagElement = ReadInt16(); } catch ( FormatError e ) { //std::cerr << e << std::endl; return false; } if ( itemTagGroup != testGroup || itemTagElement != testElement ) { gdcmWarningMacro( "Wrong Item Tag found:" << " We should have found tag (" << std::hex << testGroup << "," << testElement << ")" << std::endl << " but instead we encountered tag (" << std::hex << itemTagGroup << "," << itemTagElement << ")" << " at address: " << " 0x(" << (unsigned int)currentPosition << ")" ) ; Fp->seekg(positionOnEntry, std::ios::beg); return false; } return true; }

uint32_t gdcm::File::ReadTagLength (  uint16_t  testGroup, uint16_t  testElement )  [private]

Assuming the internal file pointer Document::Fp is placed at the beginning of a tag (TestGroup, TestElement), read the length associated to the Tag. Warning: On success the internal file pointer Document::Fp is modified to point after the tag and it's length. On failure (i.e. when the tag wasn't the expected tag (TestGroup, TestElement) the internal file pointer Document::Fp is restored to it's original position. Parameters: testGroup  The expected group of the tag. testElement  The expected Element of the tag. Returns: On success returns the length associated to the tag. On failure returns 0. Definition at line 1685 of file gdcmFile.cxx. References gdcmWarningMacro, gdcm::Document::ReadInt32(), and ReadTag(). Referenced by ComputeJPEGFragmentInfo(), ComputeRLEInfo(), and ReadAndSkipEncapsulatedBasicOffsetTable(). { if ( !ReadTag(testGroup, testElement) ) { return 0; } long currentPosition = Fp->tellg(); uint32_t itemLength = ReadInt32(); { gdcmWarningMacro( "Basic Item Length is: " << itemLength << std::endl << " at address: " << std::hex << (unsigned int)currentPosition); } return itemLength; }

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 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 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, inherited]

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

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  )  [inherited]

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 gdcm::Document::RefShaDict. { RefShaDict = Global::GetDicts()->GetDict(dictName); return !RefShaDict; }

bool gdcm::Document::SetShaDict (  Dict *  dict  )  [inherited]

Set the shadow dictionary used. Parameters: dict  dictionary to use in shadow Definition at line 200 of file gdcmDocument.cxx. References gdcm::Document::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 AnonymizeFile(), gdcm::Document::Document(), gdcm::DocEntrySet::InsertValEntry(), gdcm::FileHelper::SetValEntry(), and 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, inherited]

skips bytes inside the source file Warning: NOT end user intended method ! Returns: Definition at line 707 of file gdcmDocument.cxx. References gdcm::Document::Fp. Referenced by ComputeJPEGFragmentInfo(), ComputeRLEInfo(), and gdcm::Document::SkipDocEntry(). { //FIXME don't dump the returned value Fp->seekg((long)nBytes, std::ios::cur); }

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

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 gdcm::Document::SwapCode. Referenced by gdcm::Document::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  )  [inherited]

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 gdcm::Document::SwapCode. Referenced by gdcm::Document::GetDocEntryValue(), and gdcm::Document::HandleOutOfGroup0002(). { if ( SwapCode == 4321 || SwapCode == 2143 ) { a = ((( a << 8 ) & 0xff00 ) | (( a >> 8 ) & 0x00ff ) ); } return a; }

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

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, inherited]

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);}

bool gdcm::File::Write (  std::string  fileName, FileType  filetype )

Performs some consistency checking on various 'File related' (as opposed to 'DicomDir related') entries then writes in a file all the (Dicom Elements) included the Pixels. Parameters: fileName  file name to write to filetype  Type of the File to be written (ACR, ExplicitVR, ImplicitVR) Definition at line 1314 of file gdcmFile.cxx. References gdcm::Document::ComputeGroup0002Length(), gdcmWarningMacro, gdcm::ElementSet::GetDocEntry(), gdcm::DocEntrySet::GetEntryLength(), gdcm::DocEntrySet::GetEntryValue(), gdcm::DocEntrySet::GetValEntry(), GrPixel, gdcm::DocEntrySet::InsertValEntry(), NumPixel, gdcm::ElementSet::RemoveEntryNoDestroy(), gdcm::DocEntrySet::SetValEntry(), and gdcm::ValEntry::SetValue(). Referenced by gdcm::FileHelper::Write(). { std::ofstream *fp = new std::ofstream(fileName.c_str(), std::ios::out | std::ios::binary); if (*fp == NULL) { gdcmWarningMacro("Failed to open (write) File: " << fileName.c_str()); return false; } // Entry : 0002|0000 = group length -> recalculated ValEntry *e0002 = GetValEntry(0x0002,0x0000); if( e0002 ) { std::ostringstream sLen; sLen << ComputeGroup0002Length(filetype); e0002->SetValue(sLen.str()); } // Bits Allocated if ( GetEntryValue(0x0028,0x0100) == "12") { SetValEntry("16", 0x0028,0x0100); } int i_lgPix = GetEntryLength(GrPixel, NumPixel); if (i_lgPix != -2) { // no (GrPixel, NumPixel) element std::string s_lgPix = Util::Format("%d", i_lgPix+12); s_lgPix = Util::DicomString( s_lgPix.c_str() ); InsertValEntry(s_lgPix,GrPixel, 0x0000); } // FIXME : should be nice if we could move it to File // (or in future gdcmPixelData class) // Drop Palette Color, if necessary if ( GetEntryValue(0x0028,0x0002).c_str()[0] == '3' ) { // if SamplesPerPixel = 3, sure we don't need any LUT ! // Drop 0028|1101, 0028|1102, 0028|1103 // Drop 0028|1201, 0028|1202, 0028|1203 DocEntry *e = GetDocEntry(0x0028,0x01101); if (e) { RemoveEntryNoDestroy(e); } e = GetDocEntry(0x0028,0x1102); if (e) { RemoveEntryNoDestroy(e); } e = GetDocEntry(0x0028,0x1103); if (e) { RemoveEntryNoDestroy(e); } e = GetDocEntry(0x0028,0x01201); if (e) { RemoveEntryNoDestroy(e); } e = GetDocEntry(0x0028,0x1202); if (e) { RemoveEntryNoDestroy(e); } e = GetDocEntry(0x0028,0x1203); if (e) { RemoveEntryNoDestroy(e); } } Document::WriteContent(fp, filetype); fp->close(); delete fp; return true; }

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

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, inherited]

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

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

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

FileType gdcm::Document::Filetype [protected, inherited]

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

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

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

bool gdcm::Document::Group0002Parsed [protected, inherited]

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

uint16_t gdcm::File::GrPixel [protected]

In some cases (e.g. for some ACR-NEMA images) the header entry for the group of pixels is *not* found at 0x7fe0. In order to make things easier the parser shall store the proper value in GrPixel to provide a unique access facility. Definition at line 187 of file gdcmFile.h. Referenced by File(), GetPixelAreaLength(), GetPixelOffset(), InitializeDefaultFile(), and Write().

bool gdcm::Document::HasDCMPreamble [protected, inherited]

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

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

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

JPEGFragmentsInfo* gdcm::File::JPEGInfo [protected]

Store the JPEG fragments info obtained during parsing of pixels. Definition at line 176 of file gdcmFile.h. Referenced by ComputeJPEGFragmentInfo(), File(), and ~File().

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

Elements whose value is longer than MAX_SIZE_LOAD_ELEMENT_VALUE are NOT loaded. Definition at line 51 of file gdcmDocument.cxx. Referenced by gdcm::Document::Document().

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

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

uint16_t gdcm::File::NumPixel [protected]

In some cases (e.g. for some ACR-NEMA images) the Entry Element Number of the 'Pixel Element' is *not* found at 0x0010. In order to make things easier the parser shall store the proper value in NumPixel to provide a unique access facility. Definition at line 182 of file gdcmFile.h. Referenced by File(), GetPixelAreaLength(), GetPixelOffset(), InitializeDefaultFile(), and Write().

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().

RLEFramesInfo* gdcm::File::RLEInfo [protected]

Store the RLE frames info obtained during parsing of pixels. Definition at line 174 of file gdcmFile.h. Referenced by ComputeRLEInfo(), File(), and ~File().

int gdcm::Document::SwapCode [protected, inherited]

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 gdcm::Document::CheckSwap(), gdcm::Document::Document(), gdcm::Document::SwapLong(), gdcm::Document::SwapShort(), and gdcm::Document::SwitchByteSwapCode().

---

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

• gdcmFile.h
• gdcmFile.cxx

---