GDCM_NAME_SPACE Namespace Reference

namespace for Grass root DiCoM More...


Classes

class  ArgMgr
 class designed for command line arguments management (to make programmer's live easier) NOT Dicom dependant (could be used for any kind of 'command line program') More...
class  Base
 Base class of all gdcm classes. Contains the Print related methods :
  • Print
  • SetPrintLevel / GetPrintLevel.
More...
class  CallbackCommand
 CallbackCommand base class to react on a gdcm event. More...
class  Command
 Command base class to react on a gdcm event. More...
class  CommandManager
 CommandManager base class to react on a gdcm event. More...
struct  DicomElement
 structure, for internal use only More...
class  DataEntry
 Any Dicom Document (File or DicomDir, or ...) contains a set of DocEntry - Dicom entries - (when successfuly parsed against a given Dicom dictionary) DataEntry is an elementary DocEntry (as opposed to SeqEntry). Depending on the type of its content,. More...
class  Debug
 Debug is an object for warning/logging/tracing programs. It has the following modes :
  • error : for bad library use, seriously wrong DICOM
  • debug : for information/debug messages
  • warning : Warns the user when some oddity occured.
  • log : we display messages when anything is not Dicom Kosher
  • debug : we help developper to trace, at a glance, the execution
  • assert : design by contract implementation. A function should have proper input and proper output. (should not happen, not user controlled).
More...
struct  DICT_ENTRY
struct  ELEMENT
class  DicomDir
 DicomDir defines an object representing a DICOMDIR in memory as a tree-like structure :. More...
class  DicomDirElement
 Represents elements contained in a DicomDir class for the chained lists from the file 'Dicts/DicomDir.dic'. More...
class  DicomDirImage
 describes an IMAGE within a SERIE (DicomDirSerie) of a given DICOMDIR (DicomDir) More...
class  DicomDirMeta
 Meta Elements (group 0002) of a DicomDir. More...
class  DicomDirObject
 Parent object for DicomDirPatient, DicomDirStudy, DicomDirSerie, DicomDirImage, of a DicomDir. More...
class  DicomDirPatient
 describes a PATIENT within a DICOMDIR (DicomDir) More...
class  DicomDirPrivate
 describes a PRIVATE within a within a SERIE (DicomDirSerie) of a given DICOMDIR (DicomDir) More...
class  DicomDirSerie
 describes a SERIE within a within a STUDY (DicomDirStudy) of a given DICOMDIR (DicomDir) More...
class  DicomDirStudy
 describes a STUDY within a within a PATIENT (DicomDirPatient) of a given DICOMDIR (DicomDir) More...
class  DicomDirVisit
 describes a VISIT within a within a STUDY (DicomDirStudy) of a given DICOMDIR (DicomDir) More...
class  DicomEntry
 a DicomEntry is an element contained by the Dict. It contains :
  • the key referenced by the DICOM norm or the manufacturer(for private keys) i.e.
    • - the Group number
    • - the Element number
  • the VR (Value Representation)
  • the VM (Value Multiplicity)
  • the corresponding name in english
More...
class  Dict
 Dict acts a memory representation of a dicom dictionary i.e. it is a container for a collection of dictionary entries. The dictionary is loaded from in an ascii file. There should be a single public dictionary (THE dictionary of the actual DICOM v3) but as many shadow dictionaries as imagers combined with all software versions... More...
class  DictEntry
 the DictEntry in an element contained by the Dict. It contains :
  • the key referenced by the DICOM norm or the constructor (for private keys) i.e. the Group number the Element number
  • the VR (Value Representation)
  • the VM (Value Multiplicity)
  • the corresponding name in english
More...
class  DictGroupName
 Container for dicom 'Group Name' Hash Table. (formerly NIH defined ACR-NEMA group name). More...
class  DictSet
 Container for managing a set of loaded dictionaries (Dict). More...
class  DirList
 List containing the file headers of all the 'gdcm readable' files found by exploring (possibly recursively) a root directory. More...
class  DocEntry
 The dicom header of a Dicom file contains a set of such entries (when successfuly parsed against a given Dicom dictionary). More...
class  DocEntryArchive
 Container It's goal is to change the File header correctly. At this time, the change is only made for the first level of the Document. In the future, it might consider Dicom Sequences (SeqEntry, within any SQItem). The change is made by replacing a DocEntry by an other that is created outside the class. The old value is kept. When we restore the File status, the added DocEntry is deleted and replaced by the old value. More...
class  DocEntrySet
 DocEntrySet is an abstract base class for ElementSet, SQItem which are both containers for DocEntries. More...
class  Document
 Derived by both gdcm::File and gdcm::DicomDir. More...
class  ElementSet
 ElementSet is based on the STL map<> container (see ElementSet::TagHT), as opposed to SQItem which is based on an STL list container (see ListDocEntry). It contains the 'zero-level- DocEntry (out of any Dicom Sequence) More...
class  Exception
 Any exception thrown in the gdcm library. More...
class  FileError
 File error exception thrown in the gdcm library. More...
class  FormatUnexpected
 Unexpected file format exception. More...
class  FormatError
 Invalid file format exception. More...
class  File
 DICOM elements and their corresponding values (and additionaly the corresponding DICOM dictionary entry) of the header of a DICOM file. More...
class  FileHelper
 In addition to Dicom header exploration, this class is designed for accessing the image/volume content. One can also use it to write Dicom/ACR-NEMA/RAW files. More...
class  Global
class  JPEGFragment
 *very* internal class . Shouldn't appear here ! Utility class for summerizing the informations of a JPEG fragment of an "Encapsulated JPEG Compressed Image". This information is a mix of:
  • the fragment offset
  • the fragment length
More...
class  JPEGFragmentsInfo
 Utility class for gathering the informations of the collection of JPEG fragment[s] (see JPEGFragment) when handling "Encapsulated JPEG Compressed Images". The informations on each frame are obtained during the pixel parsing of a gdcm::File (refer to File::ComputeJPEGFragmentInfo() ). They shall be used when (if necessary) decoding the fragments. More...
struct  vector3D
class  Orientation
 Orientation class for dealing with DICOM image orientation. More...
class  PixelReadConvert
 Utility container for gathering the various forms the pixel data migth take during the user demanded processes. WARNING : *none* of these functions may be invoked by gdcm user (internal use only). More...
class  PixelWriteConvert
class  RefCounter
 Integration of reference counting with a destruction of the object only when the reference is to zero. More...
class  RLEFrame
 Utility class for summerizing the informations of a SINGLE RLE frame of an "Encapsulated RLE Compressed Image" (refer to PS 3.5-2003 annex G). This information is a mix of:
  • the RLE Header (see PS 3.5-2003 section G5) and
  • the lengths of each RLE segment [ which can be decuded from both the above RLE Header and the itemlength of the frame).
More...
class  RLEFramesInfo
 Utility class for gathering the informations of the collection of RLE frame[s] (see RLEFrame) when handling "Encapsulated RLE Compressed Images" (see PS 3.5-2003 annex G). Note: a classical image can be considered as the degenerated case of a multiframe image. In this case the collection is limited to a single individual frame. The informations on each frame are obtained during the pixel parsing of a gdcm::File (refer to File::ComputeRLEInfo() ). They shall be used when (if necessary) decoding the frames. More...
class  SeqEntry
 a SeqEntry (as opposed to a DataEntry) is a non elementary DocEntry. It is composed by a set of SQItems. Each SQItem is composed by a set of DocEntry A DocEntry may be a SeqEntry ... and so forth More...
class  SerieHelper
 This class should be used for a stack of 2D dicom images. More...
class  SQItem
 a SeqEntry is composed by a set of SQItems. Each SQItem is composed by a set of DocEntry A DocEntry may be a SeqEntry ... and so forth More...
class  TagKey
class  Util
 Here are some utility functions, belonging to the gdcm::Util class, dealing with strings, file names... that can be called from anywhere by whomsoever they can help. More...
class  Validator
class  VR
 Container for dicom Value Representation Hash Table. More...
class  VRKey

Typedefs

typedef std::pair< const Base *,
unsigned int > 		CommandKey
typedef std::map< CommandKey,
Command * > 		CommandHT
typedef std::string TagName
 TagKey is made to hold the standard Dicom Tag (Group number, Element number) Instead of using the two '16 bits integers' as the Hask Table key, we converted into a string (e.g. 0x0018,0x0050 converted into "0018|0050") It appears to be a huge waste of time. We'll fix the mess up -without any change in the API- as soon as the bench marks are fully performed. TagName is made to hold the 'non hexa" fields (VR, VM, Name) of Dicom Entries.
typedef std::list< DicomDirPatient * > ListDicomDirPatient
typedef std::vector< Document * > VectDocument
typedef std::list< DicomElement > ListDicomDirElem
typedef std::list< DicomElement > ListDicomDirMetaElem
typedef std::list< DicomElement > ListDicomDirPatientElem
typedef std::list< DicomElement > ListDicomDirStudyElem
typedef std::list< DicomElement > ListDicomDirVisitElem
typedef std::list< DicomElement > ListDicomDirSerieElem
typedef std::list< DicomElement > ListDicomDirImageElem
typedef std::list< DicomElement > ListDicomDirPrivateElem
typedef std::list< DicomDirObject * > ListContent
typedef std::list< DicomDirStudy * > ListDicomDirStudy
typedef std::list< DicomDirImage * > ListDicomDirImage
typedef std::list< DicomDirPrivate * > ListDicomDirPrivate
typedef std::list< DicomDirSerie * > ListDicomDirSerie
typedef std::list< DicomDirVisit * > ListDicomDirVisit
typedef std::string DictKey
typedef std::map< TagKey,
DictEntry * > 		TagKeyHT
typedef std::map< uint16_t,
TagName > 		DictGroupNameHT
 Group Name Hash Table.
typedef std::map< DictKey,
Dict * > 		DictSetHT
typedef std::vector< std::string > DirListType
typedef std::map< TagKey,
DocEntry * > 		TagDocEntryHT
typedef std::map< uint16_t,
int > 		GroupHT
typedef void(* VOID_FUNCTION_PUINT8_PFILE_POINTER )(uint8_t *, File *)
typedef std::pair< double,
double > 		Res
typedef void(* VOID_FUNCTION_PUINT8_PFILE_POINTER )(uint8_t *, File *)
typedef std::pair< size_t,
uint32_t > 		JpegPair
typedef std::vector< JpegPair > JpegVector
typedef std::list< SQItem * > ListSQItem
typedef std::vector< File * > FileList
typedef std::vector< File * > GdcmFileList
typedef std::map< std::string,
FileList * > 		XCoherentFileSetmap
 XCoherent stands for 'Extra Coherent', (The name 'Coherent' would be enough but it was used before; I don't want to put a bomb in the code) Any 'better name' is welcome !
typedef bool(* BOOL_FUNCTION_PFILE_PFILE_POINTER )(File *, File *)
typedef std::list< DocEntry * > ListDocEntry
typedef std::map< uint16_t,
int > 		GroupHT
typedef std::string VRAtr
typedef std::map< VRKey, VRAtr > VRHT
 Value Representation Hash Table.

Enumerations

enum  CommandType {
  CMD_UNKNOWN = 0, CMD_DEBUG, CMD_WARNING, CMD_ERROR,
  CMD_ASSERT, CMD_STARTPROGRESS, CMD_ENDPROGRESS, CMD_PROGRESS
}
 Command list. More...
enum  FileType {
  Unknown = 0, ExplicitVR, ImplicitVR, ACR,
  ACR_LIBIDO, JPEG, JPEG2000
}
 various types of a DICOM file (for internal use only) More...
enum  DicomDirType {
  DD_UNKNOWN = 0, DD_META, DD_PATIENT, DD_STUDY,
  DD_SERIE, DD_IMAGE, DD_VISIT
}
 type of the elements composing a DICOMDIR (for internal use only) More...
enum  CompOperators {
  GDCM_EQUAL = 0, GDCM_DIFFERENT, GDCM_GREATER, GDCM_GREATEROREQUAL,
  GDCM_LESS, GDCM_LESSOREQUAL
}
 comparison operators (as used in SerieHelper::AddRestriction() ) More...
enum  LodModeType { LD_ALL = 0x00000000, LD_NOSEQ = 0x00000001, LD_NOSHADOW = 0x00000002, LD_NOSHADOWSEQ = 0x00000004 }
 Loading mode. More...
enum  ImageContentType { USER_OWN_IMAGE = 1, FILTERED_IMAGE, CREATED_IMAGE, UNMODIFIED_PIXELS_IMAGE }
 Only user knows what kind of image he is going to write ! More...
enum  ModalityType {
  Unknow, AU, AS, BI,
  CF, CP, CR, CS,
  CT, DD, DF, DG,
  DM, DS, DX, ECG,
  EPS, ES, FA, FS,
  HC, HD, LP, LS,
  MA, MR, NM, OT,
  PT, RF, RG, RTDOSE,
  RTIMAGE, RTPLAN, RTSTRUCT, SM,
  ST, TG, US, VF,
  XA, XC
}
enum  OrientationType {
  NotApplicable = 0, Axial = 1, AxialInvert = -1, Coronal = 2,
  CoronalInvert = -2, Sagital = 3, SagitalInvert = -3, HeartAxial = 4,
  HeartAxialInvert = -4, HeartCoronal = 5, HeartCoronalInvert = -5, HeartSagital = 6,
  HeartSagitalInvert = -6
}

Functions

void FillDefaultDataDict (Dict *d)
 auto generated function, to fill up the Dicom Dictionnary, if relevant file is not found on user's disk
void FillDefaultTSDict (TSHT &ts)
void FillDefaultVRDict (VRHT &vr)
 auto generated function, to fill up the 'Value Representation' Dictionnary, if relevant file is not found on user's disk
void FillDefaultDictGroupName (DictGroupNameHT &groupName)
 auto generated function, to fill up the 'Group Name' Dictionnary, if relevant file is not found on user's disk
void FillDefaultDIRDict (DicomDirElement *dde)
 auto generate function, to fill up the default elements for a DICOMDIR, if relevant file is not found on user's disk
std::ostream & operator<< (std::ostream &os, const Exception &e)
 Exception::operator <<.
void error_callback (const char *msg, void *)
 routine for JPEG decompression
void warning_callback (const char *msg, void *)
void info_callback (const char *msg, void *)
int int_ceildivpow2 (int a, int b)
bool gdcm_read_JPEG2000_file (void *raw, char *inputdata, size_t inputlength)
template<typename T>
void rawtoimage_fill (T *inputbuffer, int w, int h, int numcomps, opj_image_t *image)
opj_image_t * rawtoimage (char *inputbuffer, opj_cparameters_t *parameters, int fragment_size, int image_width, int image_height, int sample_pixel, int bitsallocated, int sign, int quality)
bool gdcm_write_JPEG2000_file (std::ostream *fp, char *inputdata, size_t inputlength, int image_width, int image_height, int numZ, int sample_pixel, int bitsallocated, int sign, int quality)
bool gdcm_read_JPEG2000_file (std::ifstream *fp, void *image_buffer)
bool gdcm_read_JPEGLS_file (std::ifstream *fp, void *image_buffer)
 routine for JPEG decompression. WARNING LPEG-LS is NOT the 'classical' jpeg lossless. See : http://www.jpeg.org/jpeg/jpegls.html gdcm DOES deal with 'classical' jpeg lossless
double square_dist (vector3D const &v1, vector3D const &v2)
void WriteDICOMItems (std::ostream *fp, JpegVector &v)
void EncodeWithoutBasicOffsetTable (std::ostream *fp, int numFrag)
void EncodeWithBasicOffsetTable (std::ostream *fp, int numFrag, size_t &start)
void UpdateBasicOffsetTable (std::ostream *fp, JpegVector const &v, size_t pos)
void UpdateJpegFragmentSize (std::ostream *fp, JpegVector const &v)
void CloseJpeg (std::ostream *fp, JpegVector &v)
bool gdcm_write_JPEG_file8 (std::ostream *fp, char *inputdata, size_t inputlength, int image_width, int image_height, int numZ, int sample_pixel, int bitsallocated, int quality)
bool gdcm_write_JPEG_file12 (std::ostream *fp, char *inputdata, size_t inputlength, int image_width, int image_height, int numZ, int sample_pixel, int bitsallocated, int quality)
bool gdcm_write_JPEG_file16 (std::ostream *fp, char *inputdata, size_t inputlength, int image_width, int image_height, int numZ, int sample_pixel, int bitsallocated, int quality)
std::ostream & operator<< (std::ostream &_os, const TagKey &_val)
int GetMacAddrSys (unsigned char *addr)
 gets current M.A.C adress (for internal use only)
int getlastdigit (unsigned char *data)
 Mini function to return the last digit from a number express in base 256 pre condition data contain an array of 6 unsigned char post condition carry contain the last digit.
std::ostream & binary_write (std::ostream &os, const uint16_t &val)
 binary_write binary_write
std::ostream & binary_write (std::ostream &os, const uint32_t &val)
 binary_write binary_write
std::ostream & binary_write (std::ostream &os, const double &val)
 binary_write binary_write
std::ostream & binary_write (std::ostream &os, const char *val)
 binary_write binary_write
std::ostream & binary_write (std::ostream &os, std::string const &val)
 binary_write binary_write
std::ostream & binary_write (std::ostream &os, const uint8_t *val, size_t len)
 binary_write binary_write
std::ostream & binary_write (std::ostream &os, const uint16_t *val, size_t len)
 binary_write binary_write
bool CheckVM (DataEntry *entry)
std::ostream & operator<< (std::ostream &_os, const VRKey &_val)
std::istream & operator>> (std::istream &_is, VRKey &_val)

Variables

GDCM_EXPORT const std::string GDCM_UNKNOWN
 Those global string that are returned by reference everywhere in gdcm code used to be in gdcmCommon.h but due to a 'bug' in gcc/MacOSX you cannot have static initialization in a multithreaded environment since there is a lazy construction everything got skrew up somehow Therefore the actual initialization is done in a cxx file (avoid duplicated symbol), and an extern is used in gdcmCommon.h.
GDCM_EXPORT const std::string GDCM_UNFOUND
GDCM_EXPORT const std::string GDCM_BINLOADED
GDCM_EXPORT const std::string GDCM_NOTLOADED
GDCM_EXPORT const std::string GDCM_UNREAD
GDCM_EXPORT const std::string GDCM_NOTASCII
GDCM_EXPORT const std::string GDCM_PIXELDATA
GDCM_EXPORT const char GDCM_VRUNKNOWN [2]
GDCM_EXPORT const char GDCM_FILESEPARATOR
static DICT_ENTRY datadir []
static ELEMENT dataElement []
const std::string GDCM_UNKNOWN = "GDCM::Unknown"
 Those global string that are returned by reference everywhere in gdcm code used to be in gdcmCommon.h but due to a 'bug' in gcc/MacOSX you cannot have static initialization in a multithreaded environment since there is a lazy construction everything got skrew up somehow Therefore the actual initialization is done in a cxx file (avoid duplicated symbol), and an extern is used in gdcmCommon.h.
const std::string GDCM_UNFOUND = "GDCM::Unfound"
const std::string GDCM_BINLOADED = "GDCM::Binary data loaded"
const std::string GDCM_NOTLOADED = "GDCM::NotLoaded"
const std::string GDCM_UNREAD = "GDCM::UnRead"
const std::string GDCM_NOTASCII = "GDCM::NotAscii"
const std::string GDCM_PIXELDATA = "GDCM::Pixel Data to be loaded"
const char GDCM_VRUNKNOWN [2] = {' ',' '}
const char GDCM_FILESEPARATOR = '/'
Global Glob
 Global container.
static const char * OrientationTypeStrings []
 THERALYS' Algorithm to determine the most similar basic orientation (Axial, Coronal, Sagital) of the image.

Detailed Description

namespace for Grass root DiCoM

Typedef Documentation

typedef bool(* GDCM_NAME_SPACE::BOOL_FUNCTION_PFILE_PFILE_POINTER)(File *, File *)
 

Definition at line 47 of file gdcmSerieHelper.h.

typedef std::map<CommandKey,Command *> GDCM_NAME_SPACE::CommandHT
 

Definition at line 32 of file gdcmCommandManager.h.

typedef std::pair<const Base *, unsigned int> GDCM_NAME_SPACE::CommandKey
 

Definition at line 30 of file gdcmCommandManager.h.

typedef std::map<uint16_t, TagName> GDCM_NAME_SPACE::DictGroupNameHT
 

Group Name Hash Table.

Definition at line 33 of file gdcmDictGroupName.h.

typedef std::string GDCM_NAME_SPACE::DictKey
 

Definition at line 34 of file gdcmDict.h.

typedef std::map<DictKey, Dict*> GDCM_NAME_SPACE::DictSetHT
 

Definition at line 32 of file gdcmDictSet.h.

typedef std::vector<std::string> GDCM_NAME_SPACE::DirListType
 

Definition at line 32 of file gdcmDirList.h.

typedef std::vector<File* > GDCM_NAME_SPACE::FileList
 

Definition at line 34 of file gdcmSerieHelper.h.

typedef std::vector<File* > GDCM_NAME_SPACE::GdcmFileList
 

Definition at line 38 of file gdcmSerieHelper.h.

typedef std::map<uint16_t, int> GDCM_NAME_SPACE::GroupHT
 

Definition at line 30 of file gdcmValidator.cxx.

typedef std::map<uint16_t, int> GDCM_NAME_SPACE::GroupHT
 

Definition at line 159 of file gdcmFileHelper.cxx.

typedef std::pair<size_t, uint32_t> GDCM_NAME_SPACE::JpegPair
 

Definition at line 129 of file gdcmPixelWriteConvert.cxx.

typedef std::vector<JpegPair> GDCM_NAME_SPACE::JpegVector
 

Definition at line 130 of file gdcmPixelWriteConvert.cxx.

typedef std::list<DicomDirObject *> GDCM_NAME_SPACE::ListContent
 

Definition at line 31 of file gdcmDicomDirObject.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirElem
 

Definition at line 32 of file gdcmDicomDirElement.h.

typedef std::list<DicomDirImage *> GDCM_NAME_SPACE::ListDicomDirImage
 

Definition at line 27 of file gdcmDicomDirSerie.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirImageElem
 

Definition at line 38 of file gdcmDicomDirElement.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirMetaElem
 

Definition at line 33 of file gdcmDicomDirElement.h.

typedef std::list<DicomDirPatient *> GDCM_NAME_SPACE::ListDicomDirPatient
 

Definition at line 39 of file gdcmDicomDir.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirPatientElem
 

Definition at line 34 of file gdcmDicomDirElement.h.

typedef std::list<DicomDirPrivate *> GDCM_NAME_SPACE::ListDicomDirPrivate
 

Definition at line 31 of file gdcmDicomDirSerie.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirPrivateElem
 

Definition at line 39 of file gdcmDicomDirElement.h.

typedef std::list<DicomDirSerie *> GDCM_NAME_SPACE::ListDicomDirSerie
 

Definition at line 27 of file gdcmDicomDirStudy.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirSerieElem
 

Definition at line 37 of file gdcmDicomDirElement.h.

typedef std::list<DicomDirStudy*> GDCM_NAME_SPACE::ListDicomDirStudy
 

Definition at line 26 of file gdcmDicomDirPatient.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirStudyElem
 

Definition at line 35 of file gdcmDicomDirElement.h.

typedef std::list<DicomDirVisit *> GDCM_NAME_SPACE::ListDicomDirVisit
 

Definition at line 33 of file gdcmDicomDirStudy.h.

typedef std::list<DicomElement> GDCM_NAME_SPACE::ListDicomDirVisitElem
 

Definition at line 36 of file gdcmDicomDirElement.h.

typedef std::list<DocEntry *> GDCM_NAME_SPACE::ListDocEntry
 

Definition at line 29 of file gdcmSQItem.h.

typedef std::list<SQItem *> GDCM_NAME_SPACE::ListSQItem
 

Definition at line 28 of file gdcmSeqEntry.h.

typedef std::pair<double, double> GDCM_NAME_SPACE::Res
 

Definition at line 34 of file gdcmOrientation.h.

typedef std::map<TagKey, DocEntry *> GDCM_NAME_SPACE::TagDocEntryHT
 

Definition at line 30 of file gdcmElementSet.h.

typedef std::map<TagKey, DictEntry *> GDCM_NAME_SPACE::TagKeyHT
 

Definition at line 35 of file gdcmDict.h.

typedef std::string GDCM_NAME_SPACE::TagName
 

TagKey is made to hold the standard Dicom Tag (Group number, Element number) Instead of using the two '16 bits integers' as the Hask Table key, we converted into a string (e.g. 0x0018,0x0050 converted into "0018|0050") It appears to be a huge waste of time. We'll fix the mess up -without any change in the API- as soon as the bench marks are fully performed. TagName is made to hold the 'non hexa" fields (VR, VM, Name) of Dicom Entries.

Definition at line 99 of file gdcmCommon.h.

typedef std::vector<Document *> GDCM_NAME_SPACE::VectDocument
 

Definition at line 42 of file gdcmDicomDir.h.

typedef void(* GDCM_NAME_SPACE::VOID_FUNCTION_PUINT8_PFILE_POINTER)(uint8_t *, File *)
 

Definition at line 36 of file gdcmPixelReadConvert.h.

typedef void(* GDCM_NAME_SPACE::VOID_FUNCTION_PUINT8_PFILE_POINTER)(uint8_t *, File *)
 

Definition at line 36 of file gdcmFileHelper.h.

typedef std::string GDCM_NAME_SPACE::VRAtr
 

Definition at line 33 of file gdcmVR.h.

typedef std::map<VRKey, VRAtr> GDCM_NAME_SPACE::VRHT
 

Value Representation Hash Table.

Definition at line 35 of file gdcmVR.h.

typedef std::map<std::string, FileList *> GDCM_NAME_SPACE::XCoherentFileSetmap
 

XCoherent stands for 'Extra Coherent', (The name 'Coherent' would be enough but it was used before; I don't want to put a bomb in the code) Any 'better name' is welcome !

Definition at line 45 of file gdcmSerieHelper.h.

Enumeration Type Documentation

enum GDCM_NAME_SPACE::CommandType
 

Command list.

Enumerator:
CMD_UNKNOWN 
CMD_DEBUG 
CMD_WARNING 
CMD_ERROR 
CMD_ASSERT 
CMD_STARTPROGRESS 
CMD_ENDPROGRESS 
CMD_PROGRESS 

Definition at line 31 of file gdcmCommand.h.

00031                  {
00032    CMD_UNKNOWN       =0,
00033    CMD_DEBUG,
00034    CMD_WARNING,
00035    CMD_ERROR,
00036    CMD_ASSERT,
00037    CMD_STARTPROGRESS,
00038    CMD_ENDPROGRESS,
00039    CMD_PROGRESS
00040 };

enum GDCM_NAME_SPACE::CompOperators
 

comparison operators (as used in SerieHelper::AddRestriction() )

Enumerator:
GDCM_EQUAL 
GDCM_DIFFERENT 
GDCM_GREATER 
GDCM_GREATEROREQUAL 
GDCM_LESS 
GDCM_LESSOREQUAL 

Definition at line 127 of file gdcmCommon.h.

00127                    {
00128    GDCM_EQUAL = 0,
00129    GDCM_DIFFERENT,
00130    GDCM_GREATER,
00131    GDCM_GREATEROREQUAL,
00132    GDCM_LESS,
00133    GDCM_LESSOREQUAL
00134 };

enum GDCM_NAME_SPACE::DicomDirType
 

type of the elements composing a DICOMDIR (for internal use only)

Enumerator:
DD_UNKNOWN 
DD_META 
DD_PATIENT 
DD_STUDY 
DD_SERIE 
DD_IMAGE 
DD_VISIT 

Definition at line 116 of file gdcmCommon.h.

00116                   {
00117    DD_UNKNOWN = 0,
00118    DD_META,
00119    DD_PATIENT,
00120    DD_STUDY,
00121    DD_SERIE,
00122    DD_IMAGE,
00123    DD_VISIT
00124 };

enum GDCM_NAME_SPACE::FileType
 

various types of a DICOM file (for internal use only)

Enumerator:
Unknown 
ExplicitVR 
ImplicitVR 
ACR 
ACR_LIBIDO 
JPEG 
Todo:
FIXME : an encapsulated JPEG file may be either ExplicitVR or ImplicitVR, right?
JPEG2000 

Definition at line 102 of file gdcmCommon.h.

00102               {
00103 // note to developer : don't forget to add as well in vtkGdcmWriter.h !
00104    Unknown = 0,
00105    ExplicitVR, // DicomDir is in this case. Except when it's ImplicitVR !...
00106    ImplicitVR,
00107    ACR,
00108    ACR_LIBIDO,
00111    JPEG,
00112    JPEG2000
00113 };

enum GDCM_NAME_SPACE::ImageContentType
 

Only user knows what kind of image he is going to write !

-1) user created ex nihilo his own image and wants to write it as a Dicom image. USER_OWN_IMAGE -2) user modified the pixels of an existing image. FILTERED_IMAGE -3) user created a new image, using existing images (eg MIP, MPR, cartography image) CREATED_IMAGE -4) user modified/added some tags *without processing* the pixels (anonymization... UNMODIFIED_PIXELS_IMAGE

Enumerator:
USER_OWN_IMAGE 
FILTERED_IMAGE 
CREATED_IMAGE 
UNMODIFIED_PIXELS_IMAGE 

Definition at line 157 of file gdcmCommon.h.

00158 {
00159 // note to developer : don't forget to add as well in vtkGdcmWriter.h !
00160       USER_OWN_IMAGE = 1,
00161       FILTERED_IMAGE,
00162       CREATED_IMAGE,      
00163       UNMODIFIED_PIXELS_IMAGE            
00164 };

enum GDCM_NAME_SPACE::LodModeType
 

Loading mode.

Enumerator:
LD_ALL 
LD_NOSEQ 
LD_NOSHADOW 
LD_NOSHADOWSEQ 

Definition at line 137 of file gdcmCommon.h.

00138 {
00139    LD_ALL         = 0x00000000, // Load all
00140    LD_NOSEQ       = 0x00000001, // Don't load Sequences
00141    LD_NOSHADOW    = 0x00000002, // Don't load odd groups
00142    LD_NOSHADOWSEQ = 0x00000004  // Don't load Sequences if they belong 
00143                                 //            to an odd group
00144                                 // (*exclusive* from LD_NOSEQ and LD_NOSHADOW)
00145 };

enum GDCM_NAME_SPACE::ModalityType
 

Enumerator:
Unknow 
AU 
AS 
BI 
CF 
CP 
CR 
CS 
CT 
DD 
DF 
DG 
DM 
DS 
DX 
ECG 
EPS 
ES 
FA 
FS 
HC 
HD 
LP 
LS 
MA 
MR 
NM 
OT 
PT 
RF 
RG 
RTDOSE 
RTIMAGE 
RTPLAN 
RTSTRUCT 
SM 
ST 
TG 
US 
VF 
XA 
XC 

Definition at line 35 of file gdcmFile.h.

00035                   {
00036    Unknow,
00037    AU,       // Voice Audio
00038    AS,       // Angioscopy
00039    BI,       // Biomagnetic Imaging
00040    CF,       // Cinefluorography
00041    CP,       // Culposcopy
00042    CR,       // Computed Radiography
00043    CS,       // Cystoscopy
00044    CT,       // Computed Tomography
00045    DD,       // Duplex Dopler
00046    DF,       // Digital Fluoroscopy
00047    DG,       // Diaphanography
00048    DM,       // Digital Microscopy
00049    DS,       // Digital Substraction Angiography
00050    DX,       // Digital Radiography
00051    ECG,      // Echocardiography
00052    EPS,      // Basic Cardiac EP
00053    ES,       // Endoscopy
00054    FA,       // Fluorescein Angiography
00055    FS,       // Fundoscopy
00056    HC,       // Hard Copy
00057    HD,       // Hemodynamic
00058    LP,       // Laparoscopy
00059    LS,       // Laser Surface Scan
00060    MA,       // Magnetic Resonance Angiography
00061    MR,       // Magnetic Resonance
00062    NM,       // Nuclear Medicine
00063    OT,       // Other
00064    PT,       // Positron Emission Tomography
00065    RF,       // Radio Fluoroscopy
00066    RG,       // Radiographic Imaging
00067    RTDOSE,   // Radiotherapy Dose
00068    RTIMAGE,  // Radiotherapy Image
00069    RTPLAN,   // Radiotherapy Plan
00070    RTSTRUCT, // Radiotherapy Structure Set
00071    SM,       // Microscopic Imaging
00072    ST,       // Single-photon Emission Computed Tomography
00073    TG,       // Thermography
00074    US,       // Ultrasound
00075    VF,       // Videofluorography
00076    XA,       // X-Ray Angiography
00077    XC        // Photographic Imaging
00078 };

enum GDCM_NAME_SPACE::OrientationType
 

Enumerator:
NotApplicable 
Axial 
AxialInvert 
Coronal 
CoronalInvert 
Sagital 
SagitalInvert 
HeartAxial 
HeartAxialInvert 
HeartCoronal 
HeartCoronalInvert 
HeartSagital 
HeartSagitalInvert 

Definition at line 37 of file gdcmOrientation.h.

00037              {
00038    NotApplicable = 0,
00039    Axial = 1,
00040    AxialInvert = -1,
00041    Coronal = 2,
00042    CoronalInvert = -2,
00043    Sagital = 3,
00044    SagitalInvert = -3,
00045    HeartAxial = 4,
00046    HeartAxialInvert = -4,
00047    HeartCoronal = 5,
00048    HeartCoronalInvert = -5,
00049    HeartSagital = 6,
00050    HeartSagitalInvert = -6
00051 } OrientationType;

Function Documentation

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
const uint16_t *  val,
size_t  len
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val 16 bits words aray to write
len length (in bytes) of the 'value' to be written

Definition at line 1086 of file gdcmUtil.cxx.

01087 {
01088 // This is tricky since we are writting two bytes buffer. 
01089 // Be carefull with little endian vs big endian. 
01090 // Also this other trick is to allocate a small (efficient) buffer that store
01091 // intermediate result before writting it.
01092 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
01093    const int BUFFER_SIZE = 4096;
01094    static char buffer[BUFFER_SIZE];
01095    uint16_t *binArea16 = (uint16_t*)val; //for the const
01096  
01097    // how many BUFFER_SIZE long pieces in binArea ?
01098    int nbPieces = len/BUFFER_SIZE; //(16 bits = 2 Bytes)
01099    int remainingSize = len%BUFFER_SIZE;
01100 
01101    for (int j=0;j<nbPieces;j++)
01102    {
01103       uint16_t *pbuffer  = (uint16_t*)buffer; //reinitialize pbuffer
01104       for (int i = 0; i < BUFFER_SIZE/2; i++)
01105       {
01106          *pbuffer = *binArea16 >> 8 | *binArea16 << 8;
01107          pbuffer++;
01108          binArea16++;
01109       }
01110       os.write ( buffer, BUFFER_SIZE );
01111    }
01112    if ( remainingSize > 0)
01113    {
01114       uint16_t *pbuffer  = (uint16_t*)buffer; //reinitialize pbuffer
01115       for (int i = 0; i < remainingSize/2; i++)
01116       {
01117          *pbuffer = *binArea16 >> 8 | *binArea16 << 8;
01118          pbuffer++;
01119          binArea16++;
01120       }
01121       os.write ( buffer, remainingSize );
01122    }
01123    return os;
01124 #else
01125    return os.write(reinterpret_cast<const char*>(val), len);
01126 #endif
01127 }

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
const uint8_t *  val,
size_t  len
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val 8 bits 'characters' aray to write
len length of the 'value' to be written

Definition at line 1074 of file gdcmUtil.cxx.

01075 {
01076    // We are writting sizeof(char) thus no need to swap bytes
01077    return os.write(reinterpret_cast<const char*>(val), len);
01078 }

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
std::string const &  val
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val std::string value to write

Definition at line 1063 of file gdcmUtil.cxx.

01064 {
01065    return os.write(val.c_str(), val.size());
01066 }

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
const char *  val
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val 8 bits characters aray to write

Definition at line 1053 of file gdcmUtil.cxx.

01054 {
01055    return os.write(val, strlen(val));
01056 }

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
const double &  val
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val double (64 bits) value to write

Definition at line 1026 of file gdcmUtil.cxx.

01027 {
01028 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)    
01029    double swap = val;
01030    
01031    char *beg = (char *)&swap;
01032    char *end = beg + 7;
01033    char t;
01034    for (unsigned int i = 0; i<7; i++)
01035    {
01036       t    = *beg;
01037       *beg = *end;
01038       *end = t;
01039       beg++,
01040       end--;  
01041    }  
01042    return os.write(reinterpret_cast<const char*>(&swap), 8);
01043 #else
01044    return os.write(reinterpret_cast<const char*>(&val), 8);
01045 #endif //GDCM_WORDS_BIGENDIAN
01046 }

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
const uint32_t &  val
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val 32 bits value to write

Definition at line 1009 of file gdcmUtil.cxx.

01010 {
01011 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
01012    uint32_t swap;
01013    swap = (  (val<<24)               | ((val<<8)  & 0x00ff0000) | 
01014             ((val>>8)  & 0x0000ff00) |  (val>>24)               );
01015    return os.write(reinterpret_cast<const char*>(&swap), 4);
01016 #else
01017    return os.write(reinterpret_cast<const char*>(&val), 4);
01018 #endif //GDCM_WORDS_BIGENDIAN
01019 }

GDCM_EXPORT std::ostream & GDCM_NAME_SPACE::binary_write (  std::ostream &  os,
const uint16_t &  val
) 
 

binary_write binary_write

Parameters:
os ostream to write to
val 16 bits value to write

Definition at line 992 of file gdcmUtil.cxx.

Referenced by CloseJpeg(), EncodeWithBasicOffsetTable(), EncodeWithoutBasicOffsetTable(), UpdateJpegFragmentSize(), GDCM_NAME_SPACE::DicomDir::Write(), GDCM_NAME_SPACE::SQItem::WriteContent(), GDCM_NAME_SPACE::DocEntry::WriteContent(), GDCM_NAME_SPACE::DataEntry::WriteContent(), and WriteDICOMItems().

00993 {
00994 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
00995    uint16_t swap;
00996    swap = ( val << 8 | val >> 8 );
00997 
00998    return os.write(reinterpret_cast<const char*>(&swap), 2);
00999 #else
01000    return os.write(reinterpret_cast<const char*>(&val), 2);
01001 #endif //GDCM_WORDS_BIGENDIAN
01002 }

bool GDCM_NAME_SPACE::CheckVM (  DataEntry *  entry  ) 
 

Definition at line 43 of file gdcmValidator.cxx.

References GDCM_NAME_SPACE::Util::CountSubstring(), GDCM_NAME_SPACE::DataEntry::GetString(), GDCM_NAME_SPACE::DocEntry::GetVM(), and GDCM_NAME_SPACE::DocEntry::GetVR().

Referenced by GDCM_NAME_SPACE::Validator::SetInput().

00044 {
00045   // Don't waste time checking tags where VM is OB and OW, since we know
00046   // it's always 1, whatever the actual length (found on disc)
00047   
00048   if ( entry->GetVR() == "OB" ||  entry->GetVR() == "OW" )
00049      return true;
00050 
00051   const std::string &s = entry->GetString();
00052 
00053   unsigned int n = Util::CountSubstring( s , "\\");
00054   
00055   n++; // number of '\' + 1 == Value Multiplicity
00056 
00057   std::string vmFromDict = entry->GetVM();
00058   if ( vmFromDict == "1-n" || vmFromDict == "2-n" || vmFromDict == "3-n" )
00059      return true;
00060      
00061   unsigned int m;
00062   std::istringstream is;
00063   is.str( vmFromDict );
00064   is >> m;
00065 
00066   return n == m;
00067 }

void GDCM_NAME_SPACE::CloseJpeg (  std::ostream *  fp,
JpegVector &  v
) 
 

Definition at line 218 of file gdcmPixelWriteConvert.cxx.

References binary_write(), and UpdateJpegFragmentSize().

00219 {
00220   // sequence terminator
00221   uint16_t group = 0xfffe;
00222   uint16_t elem  = 0xe0dd;
00223   GDCM_NAME_SPACE::binary_write(*fp, group);
00224   GDCM_NAME_SPACE::binary_write(*fp, elem);
00225 
00226   uint32_t length = 0x0;
00227   GDCM_NAME_SPACE::binary_write(*fp, length);
00228 
00229   // Jpeg is done, now update the frag length
00230   UpdateJpegFragmentSize(fp, v);
00231 }

void GDCM_NAME_SPACE::EncodeWithBasicOffsetTable (  std::ostream *  fp,
int  numFrag,
size_t &  start
) 
 

Definition at line 170 of file gdcmPixelWriteConvert.cxx.

References binary_write().

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEG2000UserData(), and GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEGUserData().

00171 {
00172   // Item tag:
00173   uint16_t group = 0xfffe;
00174   uint16_t elem  = 0xe000;
00175   GDCM_NAME_SPACE::binary_write(*fp, group);
00176   GDCM_NAME_SPACE::binary_write(*fp, elem);
00177   // Item Length
00178   uint32_t item_length = numFrag*4; // sizeof(uint32_t)
00179   GDCM_NAME_SPACE::binary_write(*fp, item_length);
00180 
00181   // Just prepare the space
00182   start = fp->tellp(); //to be able to rewind
00183   for(int i=0; i<numFrag;++i)
00184     {
00185     uint32_t dummy = 0x0000;
00186     GDCM_NAME_SPACE::binary_write(*fp, dummy);
00187     }
00188 }

void GDCM_NAME_SPACE::EncodeWithoutBasicOffsetTable (  std::ostream *  fp,
int  numFrag
) 
 

Definition at line 154 of file gdcmPixelWriteConvert.cxx.

References binary_write().

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEG2000UserData(), and GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEGUserData().

00155 {
00156   assert( numFrag == 1);
00157 
00158   // Item tag:
00159   uint16_t group = 0xfffe;
00160   uint16_t elem  = 0xe000;
00161   GDCM_NAME_SPACE::binary_write(*fp, group);
00162   GDCM_NAME_SPACE::binary_write(*fp, elem);
00163   // Item Length
00164   uint32_t item_length = 0x0000;
00165   GDCM_NAME_SPACE::binary_write(*fp, item_length);
00166 
00167 }

void GDCM_NAME_SPACE::error_callback (  const char *  msg,
void * 
) 
 

routine for JPEG decompression

sample error callback expecting a FILE* client object

Definition at line 65 of file gdcmJpeg2000.cxx.

Referenced by gdcm_read_JPEG2000_file().

00065                                              {
00066   std::cerr << "Error in gdcmopenjpeg" << msg << std::endl;
00067 }

void GDCM_NAME_SPACE::FillDefaultDataDict (  Dict *  d  ) 
 

auto generated function, to fill up the Dicom Dictionnary, if relevant file is not found on user's disk

Definition at line 2603 of file gdcmDefaultDicts.cxx.

References GDCM_NAME_SPACE::Dict::AddEntry(), datadir, GDCM_NAME_SPACE::RefCounter::Delete(), GDCM_NAME_SPACE::DICT_ENTRY::element, GDCM_NAME_SPACE::DICT_ENTRY::group, GDCM_NAME_SPACE::DICT_ENTRY::name, GDCM_NAME_SPACE::DictEntry::New(), GDCM_NAME_SPACE::DICT_ENTRY::vm, and GDCM_NAME_SPACE::DICT_ENTRY::vr.

Referenced by GDCM_NAME_SPACE::Dict::Dict().

02604 {
02605    DictEntry *e;
02606    unsigned int i = 0;
02607    DICT_ENTRY n = datadir[i];
02608    while( n.name != 0 )
02609    {
02610       e = DictEntry::New( n.group, n.element, n.vr, n.vm, n.name);
02611       d->AddEntry( e );
02612       e->Delete();
02613       n = datadir[++i];
02614    }
02615 }

void GDCM_NAME_SPACE::FillDefaultDictGroupName (  DictGroupNameHT &  groupName  ) 
 

auto generated function, to fill up the 'Group Name' Dictionnary, if relevant file is not found on user's disk

Definition at line 2851 of file gdcmDefaultDicts.cxx.

Referenced by GDCM_NAME_SPACE::DictGroupName::DictGroupName().

02852 {
02853 
02854   groupName[0x0000] = "Command"; 
02855   groupName[0x0002] = "Meta Elements"; 
02856   groupName[0x0004] = "Directory"; 
02857   groupName[0x0008] = "Identifing"; 
02858   groupName[0x0010] = "Patient"; 
02859   groupName[0x0012] = "Clinical Trial"; 
02860   groupName[0x0018] = "Acquisition"; 
02861   groupName[0x0020] = "Relationship"; 
02862   groupName[0x0028] = "Image Presentation"; 
02863   groupName[0x0032] = "Study"; 
02864   groupName[0x0038] = "Visit"; 
02865   groupName[0x003a] = "Waveform"; 
02866   groupName[0x0040] = "Procedure"; 
02867   groupName[0x0050] = "Device"; 
02868   groupName[0x0054] = "Nuclear Medicine"; 
02869   groupName[0x2000] = "BFS"; 
02870   groupName[0x2010] = "BFB"; 
02871   groupName[0x2020] = "BAB"; 
02872   groupName[0x2040] = "IOB"; 
02873   groupName[0x2100] = "Print Job"; 
02874   groupName[0x2110] = "Printer"; 
02875   groupName[0x3002] = "Radio Therapy"; 
02876   groupName[0x3004] = "DVH"; 
02877   groupName[0x3006] = "SSET"; 
02878   groupName[0x300a] = "RT"; 
02879   groupName[0x300b] = "RT"; 
02880   groupName[0x300e] = "Review"; 
02881   groupName[0x4000] = "Text"; 
02882   groupName[0x4008] = "Results"; 
02883   groupName[0x5000] = "Curves"; 
02884   groupName[0x5002] = "Curves"; 
02885   groupName[0x5004] = "Curves"; 
02886   groupName[0x5006] = "Curves"; 
02887   groupName[0x5008] = "Curves"; 
02888   groupName[0x500a] = "Curves"; 
02889   groupName[0x500c] = "Curves"; 
02890   groupName[0x500e] = "Curves"; 
02891   groupName[0x5010] = "Curves"; 
02892   groupName[0x5012] = "Curves"; 
02893   groupName[0x5014] = "Curves"; 
02894   groupName[0x5016] = "Curves"; 
02895   groupName[0x5018] = "Curves"; 
02896   groupName[0x501a] = "Curves"; 
02897   groupName[0x501c] = "Curves"; 
02898   groupName[0x501e] = "Curves"; 
02899   groupName[0x6000] = "Overlays"; 
02900   groupName[0x6002] = "Overlays"; 
02901   groupName[0x6004] = "Overlays"; 
02902   groupName[0x6006] = "Overlays"; 
02903   groupName[0x6008] = "Overlays"; 
02904   groupName[0x600a] = "Overlays"; 
02905   groupName[0x600c] = "Overlays"; 
02906   groupName[0x600e] = "Overlays"; 
02907   groupName[0x6010] = "Overlays"; 
02908   groupName[0x6012] = "Overlays"; 
02909   groupName[0x6014] = "Overlays"; 
02910   groupName[0x6016] = "Overlays"; 
02911   groupName[0x6018] = "Overlays"; 
02912   groupName[0x601a] = "Overlays"; 
02913   groupName[0x601c] = "Overlays"; 
02914   groupName[0x601e] = "Overlays"; 
02915   groupName[0x7fe0] = "Pixels"; 
02916 }

void GDCM_NAME_SPACE::FillDefaultDIRDict (  DicomDirElement *  dde  ) 
 

auto generate function, to fill up the default elements for a DICOMDIR, if relevant file is not found on user's disk

Definition at line 3024 of file gdcmDefaultDicts.cxx.

References GDCM_NAME_SPACE::DicomDirElement::AddEntry(), dataElement, DD_IMAGE, DD_META, DD_PATIENT, DD_SERIE, DD_STUDY, DD_UNKNOWN, GDCM_NAME_SPACE::DicomElement::Elem, GDCM_NAME_SPACE::ELEMENT::element, GDCM_NAME_SPACE::ELEMENT::group, GDCM_NAME_SPACE::DicomElement::Group, GDCM_NAME_SPACE::ELEMENT::type, GDCM_NAME_SPACE::ELEMENT::value, GDCM_NAME_SPACE::DicomElement::Value, GDCM_NAME_SPACE::ELEMENT::vr, and GDCM_NAME_SPACE::DicomElement::VR.

Referenced by GDCM_NAME_SPACE::DicomDirElement::DicomDirElement().

03025 {
03026    unsigned int i = 0;
03027    ELEMENT e = dataElement[i];
03028    DicomElement elem;
03029    DicomDirType type;
03030    std::string strType;
03031 
03032    while( e.type != 0 )
03033    {
03034       // Force to use the string comparison operator ==
03035       strType = e.type;
03036       if( strType == "metaElem" )
03037          type = DD_META;
03038       else if( strType == "patientElem" )
03039          type = DD_PATIENT;
03040       else if( strType == "studyElem" )
03041          type = DD_STUDY;
03042       else if( strType == "serieElem" )
03043          type = DD_SERIE;
03044       else if( strType == "imageElem" )
03045          type = DD_IMAGE;
03046       else
03047          type = DD_UNKNOWN;
03048 
03049       elem.Group = e.group;
03050       elem.Elem  = e.element;
03051       elem.VR    = e.vr;
03052       elem.Value = e.value;
03053       dde->AddEntry( type, elem);
03054       e = dataElement[++i];
03055    }
03056 }

void GDCM_NAME_SPACE::FillDefaultTSDict (  TSHT &  ts  ) 
 

Definition at line 2617 of file gdcmDefaultDicts.cxx.

02618 {
02619 
02620   ts["1.2.840.10008.1.2"] = "Implicit VR - Little Endian"; 
02621   ts["1.2.840.10008.1.2.1"] = "Explicit VR - Little Endian"; 
02622   ts["1.2.840.10008.1.2.1.99"] = "Deflated Explicit VR - Little Endian"; 
02623   ts["1.2.840.10008.1.2.2"] = "Explicit VR - Big Endian"; 
02624   ts["1.2.840.10008.1.2.4.50"] = "JPEG Baseline (Process 1)"; 
02625   ts["1.2.840.10008.1.2.4.51"] = "JPEG Extended (Process 2 & 4)"; 
02626   ts["1.2.840.10008.1.2.4.52"] = "JPEG Extended (Process 3 & 5) (Retired)"; 
02627   ts["1.2.840.10008.1.2.4.53"] = "JPEG Spectral Selection, Non-Hierarchical (Process 6 & 8) (Retired)"; 
02628   ts["1.2.840.10008.1.2.4.54"] = "JPEG Spectral Selection, Non-Hierarchical (Process 7 & 9) (Retired)"; 
02629   ts["1.2.840.10008.1.2.4.55"] = "JPEG Full Progression, Non-Hierarchical (Process 10 & 12) (Retired)"; 
02630   ts["1.2.840.10008.1.2.4.56"] = "JPEG Full Progression, Non-Hierarchical (Process 11 & 13) (Retired)"; 
02631   ts["1.2.840.10008.1.2.4.57"] = "JPEG Lossless Non-Hierarchical (Process 14)"; 
02632   ts["1.2.840.10008.1.2.4.58"] = "JPEG Lossless Non-Hierarchical (Process 15) (Retired)"; 
02633   ts["1.2.840.10008.1.2.4.59"] = "JPEG Extended Hierarchical (Process 16 & 18) (Retired)"; 
02634   ts["1.2.840.10008.1.2.4.60"] = "JPEG Spectral Selection, Non-Hierarchical (Process 17 & 19) (Retired)"; 
02635   ts["1.2.840.10008.1.2.4.61"] = "JPEG Spectral Selection, Hierarchical (Process 20 & 22) (Retired)"; 
02636   ts["1.2.840.10008.1.2.4.62"] = "JPEG Spectral Selection, Hierarchical (Process 21 & 23) (Retired)"; 
02637   ts["1.2.840.10008.1.2.4.63"] = "JPEG Full Progression, Hierarchical (Process 24 & 26) (Retired)"; 
02638   ts["1.2.840.10008.1.2.4.64"] = "JPEG Full Progression, Hierarchical (Process 25 & 27) (Retired)"; 
02639   ts["1.2.840.10008.1.2.4.65"] = "JPEG Lossless, Hierarchical (Process 28) (Retired)"; 
02640   ts["1.2.840.10008.1.2.4.66"] = "JPEG Lossless, Hierarchical (Process 29) (Retired))"; 
02641   ts["1.2.840.10008.1.2.4.70"] = "JPEG Lossless, Non-Hierarchical, First-Order Prediction (Process 14 [Selection Value 1])"; 
02642   ts["1.2.840.10008.1.2.4.80"] = "JPEG-LS Lossless Image Compression"; 
02643   ts["1.2.840.10008.1.2.4.81"] = "JPEG-LS Lossy (Near-Lossless) Image Compression"; 
02644   ts["1.2.840.10008.1.2.4.90"] = "JPEG 2000 Image Compression (Lossless Only)"; 
02645   ts["1.2.840.10008.1.2.4.91"] = "JPEG 2000 Image Compression"; 
02646   ts["1.2.840.10008.1.2.4.100"] = "MPEG2 Main Profile @ Main Level"; 
02647   ts["1.2.840.10008.1.2.5"] = "RLE Lossless"; 
02648   ts["1.2.840.113619.5.2"] = "Implicit VR - Big Endian (G.E Private)"; 
02649   ts["1.2.528.1.1001.4.1.1.2"] = "Explicit VR, AMI Wavelet Progressive Lossy Compression  (G.E Private) "; 
02650   ts["1.2.528.1.1001.4.2.1.1"] = "Explicit VR, AMI JPEG Lossy Compression 8-bit (G.E Private)"; 
02651   ts["1.2.528.1.1001.4.2.1.2"] = "Explicit VR, AMI JPEG Lossy Compression 12-bit (G.E Private)"; 
02652   ts["1.2.528.1.1001.4.4.1"] = "Explicit VR, AMI ZLIB Lossless Compression (G.E Private)"; 
02653   ts["1.2.840.10008.1.3.10"] = "Media Storage Directory Storage"; 
02654   ts["1.2.840.10008.1.4.1.1"] = "Talairach Brain Atlas Frame of Reference"; 
02655   ts["1.2.840.10008.1.4.1.2"] = "SPM2 T1 Frame of Reference"; 
02656   ts["1.2.840.10008.1.4.1.3"] = "SPM2 T2 Frame of Reference"; 
02657   ts["1.2.840.10008.1.4.1.4"] = "SPM2 PD Frame of Reference"; 
02658   ts["1.2.840.10008.1.4.1.5"] = "SPM2 EPI Frame of Reference"; 
02659   ts["1.2.840.10008.1.4.1.6"] = "SPM2 FIL T1 Frame of Reference"; 
02660   ts["1.2.840.10008.1.4.1.7"] = "SPM2 PET Frame of Reference"; 
02661   ts["1.2.840.10008.1.4.1.8"] = "SPM2 TRANSM Frame of Reference"; 
02662   ts["1.2.840.10008.1.4.1.9"] = "SPM2 SPECT Frame of Reference"; 
02663   ts["1.2.840.10008.1.4.1.10"] = "SPM2 GRAY Frame of Reference"; 
02664   ts["1.2.840.10008.1.4.1.11"] = "SPM2 WHITE Frame of Reference"; 
02665   ts["1.2.840.10008.1.4.1.12"] = "SPM2 CSF Frame of Reference"; 
02666   ts["1.2.840.10008.1.4.1.13"] = "SPM2 BRAINMASK Frame of Reference"; 
02667   ts["1.2.840.10008.1.4.1.14"] = "SPM2 AVG305T1 Frame of Reference"; 
02668   ts["1.2.840.10008.1.4.1.15"] = "SPM2 AVG152T1 Frame of Reference"; 
02669   ts["1.2.840.10008.1.4.1.16"] = "SPM2 AVG152T2 Frame of Reference"; 
02670   ts["1.2.840.10008.1.4.1.17"] = "SPM2 AVG152PD Frame of Reference"; 
02671   ts["1.2.840.10008.1.4.1.18"] = "SPM2 SINGLESUBJT1 Frame of Reference"; 
02672   ts["1.2.840.10008.1.4.2.1"] = "ICBM 452 T1 Frame of Reference"; 
02673   ts["1.2.840.10008.1.4.2.2"] = "ICBM Single Subject MRI Frame of Reference"; 
02674   ts["1.2.840.10008.1.1"] = "Verification SOP Class"; 
02675   ts["1.2.840.10008.1.9"] = "Basic Study Content Notification SOP Class"; 
02676   ts["1.2.840.10008.1.20.1"] = "Image Commitment Push Model SOP Class"; 
02677   ts["1.2.840.10008.1.20.1.1"] = "Image Commitment Push Model SOP Instance"; 
02678   ts["1.2.840.10008.1.20.2"] = "Image Commitment Push Model SOP Class (Retired)"; 
02679   ts["1.2.840.10008.1.20.2.1"] = "Image Commitment Push Model SOP Instance (Retired)"; 
02680   ts["1.2.840.10008.1.40"] = "Procedural Event Logging SOP Class"; 
02681   ts["1.2.840.10008.1.40.1"] = "Procedural Event Logging SOP Instance"; 
02682   ts["1.2.840.10008.2.16.4"] = "DICOM Controlled Terminology"; 
02683   ts["1.2.840.10008.3.1.1.1"] = "DICOM Application Context Name"; 
02684   ts["1.2.840.10008.3.1.2.1.1"] = "Detached Patient Management SOP Class"; 
02685   ts["1.2.840.10008.3.1.2.1.4"] = "Detached Patient Management Meta SOP Class"; 
02686   ts["1.2.840.10008.3.1.2.2.1"] = "Detached Visit Management SOP Class"; 
02687   ts["1.2.840.10008.3.1.2.3.1"] = "Detached Study Management SOP Class"; 
02688   ts["1.2.840.10008.3.1.2.3.2"] = "Study Component Management SOP Class"; 
02689   ts["1.2.840.10008.3.1.2.3.3"] = "Modality Performed Procedure Step SOP Class"; 
02690   ts["1.2.840.10008.3.1.2.3.4"] = "Modality Performed Procedure Step Retrieve SOP Class"; 
02691   ts["1.2.840.10008.3.1.2.3.5"] = "Modality Performed Procedure Step Notification SOP Class"; 
02692   ts["1.2.840.10008.3.1.2.5.1"] = "Detached Results Management SOP Class"; 
02693   ts["1.2.840.10008.3.1.2.5.4"] = "Detached Results Management Meta SOP Class"; 
02694   ts["1.2.840.10008.3.1.2.5.5"] = "Detached Study Management Meta SOP Class"; 
02695   ts["1.2.840.10008.3.1.2.6.1"] = "Detached Interpretation Management SOP Class"; 
02696   ts["1.2.840.10008.4.2"] = "Storage Device Class"; 
02697   ts["1.2.840.10008.5.1.1.1"] = "Basic Film Session SOP Class"; 
02698   ts["1.2.840.10008.5.1.1.2"] = "Basic Film Box SOP Class"; 
02699   ts["1.2.840.10008.5.1.1.4"] = "Basic Gray Scale Image Box SOP Class"; 
02700   ts["1.2.840.10008.5.1.1.4.1"] = "Basic Color Image Box SOP Class"; 
02701   ts["1.2.840.10008.5.1.1.4.2"] = "Referenced Image Box SOP Class (Retired)"; 
02702   ts["1.2.840.10008.5.1.1.9"] = "Basic Gray Scale Print Management Meta SOP Class"; 
02703   ts["1.2.840.10008.5.1.1.9.1"] = "Referenced Gray Scale Print Management Meta SOP Class(Retired)"; 
02704   ts["1.2.840.10008.5.1.1.14"] = "Print Job SOP Class"; 
02705   ts["1.2.840.10008.5.1.1.15"] = "Basic Annotation Box SOP Class"; 
02706   ts["1.2.840.10008.5.1.1.16"] = "Printer SOP Class"; 
02707   ts["1.2.840.10008.5.1.1.16.376"] = "Printer Configuration Retrieval SOP Class"; 
02708   ts["1.2.840.10008.5.1.1.17"] = "Printer SOP Instance"; 
02709   ts["1.2.840.10008.5.1.1.17.376"] = "Printer Configuration Retrieval SOP Instance"; 
02710   ts["1.2.840.10008.5.1.1.18"] = "Basic Color Print Management Meta SOP Class"; 
02711   ts["1.2.840.10008.5.1.1.18.1"] = "Referenced Color Print Management Meta SOP Class (Retired)"; 
02712   ts["1.2.840.10008.5.1.1.22"] = "VOI LUT Box SOP Class"; 
02713   ts["1.2.840.10008.5.1.1.23"] = "Presentation LUT Box SOP Class"; 
02714   ts["1.2.840.10008.5.1.1.24"] = "Image Overlay Box SOP Class (Retired)"; 
02715   ts["1.2.840.10008.5.1.1.24.1"] = "Basic Print Image Overlay Box SOP Class"; 
02716   ts["1.2.840.10008.5.1.1.25"] = "Print Queue SOP Instance"; 
02717   ts["1.2.840.10008.5.1.1.26"] = "Print Queue Management SOP Class"; 
02718   ts["1.2.840.10008.5.1.1.27"] = "Stored Print Storage SOP Class"; 
02719   ts["1.2.840.10008.5.1.1.29"] = "Hardcopy Grayscale Image Storage SOP Class"; 
02720   ts["1.2.840.10008.5.1.1.30"] = "Hardcopy Color Image Storage SOP Class"; 
02721   ts["1.2.840.10008.5.1.1.31"] = "Pull Print Request SOP Class"; 
02722   ts["1.2.840.10008.5.1.1.32"] = "Pull Stored Print Management Meta SOP Class"; 
02723   ts["1.2.840.10008.5.1.1.33"] = "Media Creation Management SOP Class UID"; 
02724   ts["1.2.840.10008.5.1.4.1.1.1"] = "Computed Radiography Image Storage"; 
02725   ts["1.2.840.10008.5.1.4.1.1.1.1"] = "Digital X-Ray Image Storage - For Presentation"; 
02726   ts["1.2.840.10008.5.1.4.1.1.1.1.1"] = "Digital X-Ray Image Storage - For Processing"; 
02727   ts["1.2.840.10008.5.1.4.1.1.1.2"] = "Digital Mammography Image Storage - For Presentation"; 
02728   ts["1.2.840.10008.5.1.4.1.1.1.2.1"] = "Digital Mammography Image Storage - For Processing"; 
02729   ts["1.2.840.10008.5.1.4.1.1.1.3"] = "Digital Intra-oral X-ray Image Storage - For Presentation"; 
02730   ts["1.2.840.10008.5.1.4.1.1.1.3.1"] = "Digital Intra-oral X-Ray Image Storage - For Processing"; 
02731   ts["1.2.840.10008.5.1.4.1.1.2"] = "CT Image Storage"; 
02732   ts["1.2.840.10008.5.1.4.1.1.2.1"] = "Enhanced CT Image Storage"; 
02733   ts["1.2.840.10008.5.1.4.1.1.3"] = "Ultrasound Multi-Frame Image Storage (Retired)"; 
02734   ts["1.2.840.10008.5.1.4.1.1.3.1"] = "Ultrasound Multi-Frame Image Storage"; 
02735   ts["1.2.840.10008.5.1.4.1.1.4"] = "MR Image Storage"; 
02736   ts["1.2.840.10008.5.1.4.1.1.4.1"] = "Enhanced MR Image Storage"; 
02737   ts["1.2.840.10008.5.1.4.1.1.4.2"] = "MR Spectroscopy Storage"; 
02738   ts["1.2.840.10008.5.1.4.1.1.5"] = "Nuclear Medicine Image Storage (Retired)"; 
02739   ts["1.2.840.10008.5.1.4.1.1.6"] = "Ultrasound Image Storage (Retired)"; 
02740   ts["1.2.840.10008.5.1.4.1.1.6.1"] = "Ultrasound Image Storage"; 
02741   ts["1.2.840.10008.5.1.4.1.1.7"] = "Secondary Capture Image Storage"; 
02742   ts["1.2.840.10008.5.1.4.1.1.7.1"] = "Multi-frame Single Bit Secondary Capture Image Storage"; 
02743   ts["1.2.840.10008.5.1.4.1.1.7.2"] = "Multi-frame Grayscale Byte Secondary Capture Image Storage"; 
02744   ts["1.2.840.10008.5.1.4.1.1.7.3"] = "Multi-frame Grayscale Word Secondary Capture Image Storage"; 
02745   ts["1.2.840.10008.5.1.4.1.1.7.4"] = "Multi-frame True Color Secondary Capture Image Storage"; 
02746   ts["1.2.840.10008.5.1.4.1.1.8"] = "Standalone Overlay Storage"; 
02747   ts["1.2.840.10008.5.1.4.1.1.9"] = "Standalone Curve Storage"; 
02748   ts["1.2.840.10008.5.1.4.1.1.9.1.1"] = "12-Lead ECG Waveform Storage"; 
02749   ts["1.2.840.10008.5.1.4.1.1.9.1.2"] = "General ECG Waveform Storage"; 
02750   ts["1.2.840.10008.5.1.4.1.1.9.1.3"] = "Ambulatory ECG Waveform Storage"; 
02751   ts["1.2.840.10008.5.1.4.1.1.9.2.1"] = "Hemodynamic Waveform Storage"; 
02752   ts["1.2.840.10008.5.1.4.1.1.9.3.1"] = "Cardiac Electrophysiology Waveform Storage"; 
02753   ts["1.2.840.10008.5.1.4.1.1.9.4.1"] = "Basic Voice Audio Waveform Storage"; 
02754   ts["1.2.840.10008.5.1.4.1.1.10"] = "Standalone Modality LUT Storage"; 
02755   ts["1.2.840.10008.5.1.4.1.1.11"] = "Standalone VOI LUT Storage"; 
02756   ts["1.2.840.10008.5.1.4.1.1.11.1"] = "Grayscale Softcopy Presentation State Storage SOP Class"; 
02757   ts["1.2.840.10008.5.1.4.1.1.12.1"] = "X-Ray Angiographic Image Storage"; 
02758   ts["1.2.840.10008.5.1.4.1.1.12.2"] = "X-Ray Radiofluoroscoping Image Storage"; 
02759   ts["1.2.840.10008.5.1.4.1.1.12.3"] = "X-Ray Angiographic Bi-Plane Image Storage (Retired)"; 
02760   ts["1.2.840.10008.5.1.4.1.1.20"] = "Nuclear Medicine Image Storage"; 
02761   ts["1.2.840.10008.5.1.4.1.1.66"] = "Raw Data Storage"; 
02762   ts["1.2.840.10008.5.1.4.1.1.66.1"] = "Spacial Registration Storage"; 
02763   ts["1.2.840.10008.5.1.4.1.1.66.2"] = "Spacial Fiducials Storage"; 
02764   ts["1.2.840.10008.5.1.4.1.1.77.1"] = "VL Image Storage (Retired)"; 
02765   ts["1.2.840.10008.5.1.4.1.1.77.2"] = "VL MultiFrame Image Storage (Retired)"; 
02766   ts["1.2.840.10008.5.1.4.1.1.77.1.1"] = "VL Endoscoping Image Storage"; 
02767   ts["1.2.840.10008.5.1.4.1.1.77.1.1.1"] = "Video Endoscoping Image Storage"; 
02768   ts["1.2.840.10008.5.1.4.1.1.77.1.2"] = "VL Microscoping Image Storage"; 
02769   ts["1.2.840.10008.5.1.4.1.1.77.1.2.1"] = "Video Microscoping Image Storage"; 
02770   ts["1.2.840.10008.5.1.4.1.1.77.1.3"] = "VL Slide-Coordinates Microscoping Image Storage"; 
02771   ts["1.2.840.10008.5.1.4.1.1.77.1.4"] = "VL Photographic Image Storage"; 
02772   ts["1.2.840.10008.5.1.4.1.1.77.1.4.1"] = "Video Photographic Image Storage"; 
02773   ts["1.2.840.10008.5.1.4.1.1.77.1.5.1"] = "Ophthalmic Photography 8 Bit Image Storage"; 
02774   ts["1.2.840.10008.5.1.4.1.1.77.1.5.2"] = "Ophthalmic Photography 16 Bit Image Storage"; 
02775   ts["1.2.840.10008.5.1.4.1.1.77.1.5.3"] = "Stereometric Relationship Storage"; 
02776   ts["1.2.840.10008.5.1.4.1.1.88.1"] = "SR Text Storage"; 
02777   ts["1.2.840.10008.5.1.4.1.1.88.2"] = "SR Audio Storage"; 
02778   ts["1.2.840.10008.5.1.4.1.1.88.3"] = "SR Detail Storage"; 
02779   ts["1.2.840.10008.5.1.4.1.1.88.4"] = "SR Comprehensive Storage"; 
02780   ts["1.2.840.10008.5.1.4.1.1.88.11"] = "Basic Text SR"; 
02781   ts["1.2.840.10008.5.1.4.1.1.88.22"] = "Enhanced SR"; 
02782   ts["1.2.840.10008.5.1.4.1.1.88.33"] = "Comprehensive SR"; 
02783   ts["1.2.840.10008.5.1.4.1.1.88.40"] = "Procedure Log Storage"; 
02784   ts["1.2.840.10008.5.1.4.1.1.88.50"] = "Mammography CAD SR"; 
02785   ts["1.2.840.10008.5.1.4.1.1.88.59"] = "Key Object Selection Document"; 
02786   ts["1.2.840.10008.5.1.4.1.1.88.65"] = "Chest CAD SR"; 
02787   ts["1.2.840.10008.5.1.4.1.1.104.1"] = "Encapsulated PDF Storage"; 
02788   ts["1.2.840.10008.5.1.4.1.1.128"] = "Positron Emission Tomography Image Storage"; 
02789   ts["1.2.840.10008.5.1.4.1.1.129"] = "Standalone PET Curve Storage"; 
02790   ts["1.2.840.10008.5.1.4.1.1.481.1"] = "RT Image Storage"; 
02791   ts["1.2.840.10008.5.1.4.1.1.481.2"] = "RT Dose Storage"; 
02792   ts["1.2.840.10008.5.1.4.1.1.481.3"] = "RT Structure Set Storage"; 
02793   ts["1.2.840.10008.5.1.4.1.1.481.4"] = "RT Beams Treatment Record Storage"; 
02794   ts["1.2.840.10008.5.1.4.1.1.481.5"] = "RT Plan Storage"; 
02795   ts["1.2.840.10008.5.1.4.1.1.481.6"] = "RT Brachy Treatment Record Storage"; 
02796   ts["1.2.840.10008.5.1.4.1.1.481.7"] = "RT Treatment Summary Record Storage"; 
02797   ts["1.2.840.10008.5.1.4.1.2.1.1"] = "Patient Root Query/Retrieve Information Model - FIND"; 
02798   ts["1.2.840.10008.5.1.4.1.2.1.2"] = "Patient Root Query/Retrieve Information Model - MOVE"; 
02799   ts["1.2.840.10008.5.1.4.1.2.1.3"] = "Patient Root Query/Retrieve Information Model - GET"; 
02800   ts["1.2.840.10008.5.1.4.1.2.2.1"] = "Study Root Query/Retrieve Information Model - FIND"; 
02801   ts["1.2.840.10008.5.1.4.1.2.2.2"] = "Study Root Query/Retrieve Information Model - MOVE"; 
02802   ts["1.2.840.10008.5.1.4.1.2.2.3"] = "Study Root Query/Retrieve Information Model - GET"; 
02803   ts["1.2.840.10008.5.1.4.1.2.3.1"] = "Patient/Study Only Query/Retrieve Information Model - FIND"; 
02804   ts["1.2.840.10008.5.1.4.1.2.3.2"] = "Patient/Study Only Query/Retrieve Information Model - GET"; 
02805   ts["1.2.840.10008.5.1.4.1.2.3.3"] = "Patient/Study Only Query/Retrieve Information Model - MOVE"; 
02806   ts["1.2.840.10008.5.1.4.31"] = "Modality Worklist Information Model - FIND"; 
02807   ts["1.2.840.10008.5.1.4.32.1"] = "General Purpose Worklist Information Model - FIND"; 
02808   ts["1.2.840.10008.5.1.4.32.2"] = "General Purpose Scheduled Procedure Step SOP Class"; 
02809   ts["1.2.840.10008.5.1.4.32.3"] = "General Purpose Performed Procedure Step SOP Class"; 
02810   ts["1.2.840.10008.5.1.4.32"] = "General Purpose Worklist Management Meta SOP Class"; 
02811   ts["1.2.840.10008.5.1.4.33"] = "Instance Availability Notification SOP Class"; 
02812   ts["1.2.840.10008.5.1.4.37.1"] = "General Relevant Patient Information Query"; 
02813   ts["1.2.840.10008.5.1.4.37.2"] = "Breast Imaging Relevant Patient Information Query"; 
02814   ts["1.2.840.10008.5.1.4.37.3"] = "Cardiac Relevant Patient Information Query"; 
02815   ts["1.3.12.2.1107.5.9.1"] = "CSA Non-Image Storage"; 
02816   ts["1.3.46.670589.2.5.1.1"] = "3D Subpage Storage"; 
02817 }

void GDCM_NAME_SPACE::FillDefaultVRDict (  VRHT &  vr  ) 
 

auto generated function, to fill up the 'Value Representation' Dictionnary, if relevant file is not found on user's disk

Definition at line 2819 of file gdcmDefaultDicts.cxx.

Referenced by GDCM_NAME_SPACE::VR::VR().

02820 {
02821 
02822   vr["AE"] = "Application Entity"; 
02823   vr["AS"] = "Age String"; 
02824   vr["AT"] = "Attribute Tag"; 
02825   vr["CS"] = "Code String"; 
02826   vr["DA"] = "Date"; 
02827   vr["DS"] = "Decimal String"; 
02828   vr["DT"] = "Date Time"; 
02829   vr["FL"] = "Floating Point Single"; 
02830   vr["FD"] = "Floating Point Double"; 
02831   vr["IS"] = "Integer String"; 
02832   vr["LO"] = "Long String"; 
02833   vr["LT"] = "Long Text"; 
02834   vr["OB"] = "Other Byte String"; 
02835   vr["OW"] = "Other Word String"; 
02836   vr["OF"] = "Other Float String"; 
02837   vr["PN"] = "Person Name"; 
02838   vr["SH"] = "Short String"; 
02839   vr["SL"] = "Signed Long"; 
02840   vr["SQ"] = "Sequence of Items"; 
02841   vr["SS"] = "Signed Short"; 
02842   vr["ST"] = "Short Text"; 
02843   vr["TM"] = "Time"; 
02844   vr["UI"] = "Unique Identifier"; 
02845   vr["UL"] = "Unsigned Long"; 
02846   vr["UN"] = "Unknown"; 
02847   vr["US"] = "Unsigned Short"; 
02848   vr["UT"] = "Unlimited Text"; 
02849 }

bool GDCM_NAME_SPACE::gdcm_read_JPEG2000_file (  std::ifstream *  fp,
void *  image_buffer
) 
 

bool GDCM_NAME_SPACE::gdcm_read_JPEG2000_file (  void *  raw,
char *  inputdata,
size_t  inputlength
) 
 

Definition at line 102 of file gdcmJpeg2000.cxx.

References error_callback(), info_callback(), int_ceildivpow2(), J2K_CFMT, PGX_DFMT, and warning_callback().

Referenced by GDCM_NAME_SPACE::PixelReadConvert::ReadAndDecompressJPEGFile().

00103 {
00104   opj_dparameters_t parameters;  /* decompression parameters */
00105   opj_event_mgr_t event_mgr;    /* event manager */
00106   opj_image_t *image;
00107   opj_dinfo_t* dinfo;  /* handle to a decompressor */
00108   opj_cio_t *cio;
00109   unsigned char *src = (unsigned char*)inputdata; 
00110   int file_length = static_cast< int >( inputlength );
00111 
00112   /* configure the event callbacks (not required) */
00113   memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
00114   event_mgr.error_handler = error_callback;
00115   event_mgr.warning_handler = warning_callback;
00116   event_mgr.info_handler = info_callback;
00117 
00118   /* set decoding parameters to default values */
00119   opj_set_default_decoder_parameters(&parameters);
00120  
00121    // default blindly copied
00122    parameters.cp_layer=0;
00123    parameters.cp_reduce=0;
00124 //   parameters.decod_format=-1;
00125 //   parameters.cod_format=-1;
00126 
00127       /* JPEG-2000 codestream */
00128     parameters.decod_format = J2K_CFMT;
00129     assert(parameters.decod_format == J2K_CFMT);
00130   parameters.cod_format = PGX_DFMT;
00131   assert(parameters.cod_format == PGX_DFMT);
00132 
00133       /* get a decoder handle */
00134       dinfo = opj_create_decompress(CODEC_J2K);
00135 
00136       /* catch events using our callbacks and give a local context */
00137       opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, NULL);
00138 
00139       /* setup the decoder decoding parameters using user parameters */
00140       opj_setup_decoder(dinfo, &parameters);
00141 
00142       /* open a byte stream */
00143       cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
00144 
00145       /* decode the stream and fill the image structure */
00146       image = opj_decode(dinfo, cio);
00147       if(!image) {
00148         opj_destroy_decompress(dinfo);
00149         opj_cio_close(cio);
00150         return 1;
00151       }
00152       
00153       /* close the byte stream */
00154       opj_cio_close(cio);
00155 
00156   /* free the memory containing the code-stream */
00157   delete[] src;  //FIXME
00158 
00159    // Copy buffer
00160    for (int compno = 0; compno < image->numcomps; compno++)
00161    {
00162       opj_image_comp_t *comp = &image->comps[compno];
00163 
00164       int w = image->comps[compno].w;
00165       int wr = int_ceildivpow2(image->comps[compno].w, image->comps[compno].factor);
00166 
00167       //int h = image.comps[compno].h;
00168       int hr = int_ceildivpow2(image->comps[compno].h, image->comps[compno].factor);
00169 
00170       if (comp->prec <= 8)
00171       {
00172          uint8_t *data8 = (uint8_t*)raw + compno;
00173          for (int i = 0; i < wr * hr; i++)
00174          {
00175             int v = image->comps[compno].data[i / wr * w + i % wr];
00176             *data8 = (uint8_t)v;
00177             data8 += image->numcomps;
00178          }
00179       }
00180       else if (comp->prec <= 16)
00181       {
00182          uint16_t *data16 = (uint16_t*)raw + compno;
00183          for (int i = 0; i < wr * hr; i++)
00184          {
00185             int v = image->comps[compno].data[i / wr * w + i % wr];
00186             *data16 = (uint16_t)v;
00187             data16 += image->numcomps;
00188          }
00189       }
00190       else
00191       {
00192          uint32_t *data32 = (uint32_t*)raw + compno;
00193          for (int i = 0; i < wr * hr; i++)
00194          {
00195             int v = image->comps[compno].data[i / wr * w + i % wr];
00196             *data32 = (uint32_t)v;
00197             data32 += image->numcomps;
00198          }
00199       }
00200       //free(image.comps[compno].data);
00201    }
00202 
00203 
00204   /* free remaining structures */
00205   if(dinfo) {
00206     opj_destroy_decompress(dinfo);
00207   }
00208 
00209   /* free image data structure */
00210   opj_image_destroy(image);
00211 
00212   return true;
00213 }

bool GDCM_NAME_SPACE::gdcm_read_JPEGLS_file (  std::ifstream *  fp,
void *  image_buffer
) 
 

routine for JPEG decompression. WARNING LPEG-LS is NOT the 'classical' jpeg lossless. See : http://www.jpeg.org/jpeg/jpegls.html gdcm DOES deal with 'classical' jpeg lossless

Parameters:
fp pointer to an already open file descriptor JPEG-LS encoded image
image_buffer to receive uncompressed pixels
Returns:
1 on success, 0 on error
Warning:
: not yet made

Definition at line 41 of file gdcmJpegLS.cxx.

References gdcmWarningMacro.

00042 {
00043    (void)fp;
00044    (void)image_buffer;
00045    gdcmWarningMacro( "Sorry JPEG-LS File not yet taken into account" );
00046    return false;
00047 }

bool GDCM_NAME_SPACE::gdcm_write_JPEG2000_file (  std::ostream *  fp,
char *  inputdata,
size_t  inputlength,
int  image_width,
int  image_height,
int  numZ,
int  sample_pixel,
int  bitsallocated,
int  sign,
int  quality
) 
 

Definition at line 331 of file gdcmJpeg2000.cxx.

References error_callback(), info_callback(), J2K_CFMT, rawtoimage(), and warning_callback().

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEG2000UserData().

00334 {
00337   (void)numZ;
00338   bool bSuccess;
00339   //bool delete_comment = true;
00340   opj_cparameters_t parameters;  /* compression parameters */
00341   opj_event_mgr_t event_mgr;    /* event manager */
00342   opj_image_t *image = NULL;
00343   //quality = 100;
00344 
00345   /*
00346   configure the event callbacks (not required)
00347   setting of each callback is optionnal
00348   */
00349   memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
00350   event_mgr.error_handler = error_callback;
00351   event_mgr.warning_handler = warning_callback;
00352   event_mgr.info_handler = info_callback;
00353 
00354   /* set encoding parameters to default values */
00355   memset(&parameters, 0, sizeof(parameters));
00356   opj_set_default_encoder_parameters(&parameters);
00357 
00358   /* if no rate entered, lossless by default */
00359   parameters.tcp_rates[0] = 0;
00360   parameters.tcp_numlayers = 1;
00361   parameters.cp_disto_alloc = 1;
00362 
00363   if(parameters.cp_comment == NULL) {
00364     const char comment[] = "Created by GDCM/OpenJPEG version 1.0";
00365     parameters.cp_comment = (char*)malloc(strlen(comment) + 1);
00366     strcpy(parameters.cp_comment, comment);
00367     /* no need to delete parameters.cp_comment on exit */
00368     //delete_comment = false;
00369   }
00370 
00371   
00372   /* decode the source image */
00373   /* ----------------------- */
00374 
00375   image = rawtoimage((char*)inputdata, &parameters, 
00376     static_cast<int>( inputlength ), 
00377     image_width, image_height,
00378     sample_pixel, bitsallocated, sign, quality);
00379   if (!image) {
00380     return 1;
00381   }
00382 
00383     /* encode the destination image */
00384   /* ---------------------------- */
00385    parameters.cod_format = J2K_CFMT; /* J2K format output */
00386     int codestream_length;
00387     opj_cio_t *cio = NULL;
00388     //FILE *f = NULL;
00389 
00390     /* get a J2K compressor handle */
00391     opj_cinfo_t* cinfo = opj_create_compress(CODEC_J2K);
00392 
00393     /* catch events using our callbacks and give a local context */
00394     opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
00395 
00396     /* setup the encoder parameters using the current image and using user parameters */
00397     opj_setup_encoder(cinfo, &parameters, image);
00398 
00399     /* open a byte stream for writing */
00400     /* allocate memory for all tiles */
00401     cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
00402 
00403     /* encode the image */
00404     bSuccess = opj_encode(cinfo, cio, image, parameters.index);
00405     if (!bSuccess) {
00406       opj_cio_close(cio);
00407       fprintf(stderr, "failed to encode image\n");
00408       return 1;
00409     }
00410     codestream_length = cio_tell(cio);
00411 
00412     /* write the buffer to disk */
00413     //f = fopen(parameters.outfile, "wb");
00414     //if (!f) {
00415     //  fprintf(stderr, "failed to open %s for writing\n", parameters.outfile);
00416     //  return 1;
00417     //}
00418     //fwrite(cio->buffer, 1, codestream_length, f);
00419 //#define MDEBUG
00420 #ifdef MDEBUG
00421     static int c = 0;
00422     std::ostringstream os;
00423     os << "/tmp/debug";
00424     os << c;
00425     c++;
00426     os << ".j2k";
00427     std::ofstream debug(os.str().c_str());
00428     debug.write((char*)(cio->buffer), codestream_length);
00429     debug.close();
00430 #endif
00431     fp->write((char*)(cio->buffer), codestream_length);
00432     //fclose(f);
00433 
00434     /* close and free the byte stream */
00435     opj_cio_close(cio);
00436 
00437     /* free remaining compression structures */
00438     opj_destroy_compress(cinfo);
00439 
00440 
00441       /* free user parameters structure */
00442   //if(delete_comment) {
00443     if(parameters.cp_comment) free(parameters.cp_comment);
00444   //}
00445   if(parameters.cp_matrice) free(parameters.cp_matrice);
00446 
00447   /* free image data */
00448   opj_image_destroy(image);
00449 
00450 
00451 
00452 
00453   return true;
00454 }

bool GDCM_NAME_SPACE::gdcm_write_JPEG_file12 (  std::ostream *  fp,
char *  inputdata,
size_t  inputlength,
int  image_width,
int  image_height,
int  numZ,
int  sample_pixel,
int  bitsallocated,
int  quality
) 
 

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEGUserData().

bool GDCM_NAME_SPACE::gdcm_write_JPEG_file16 (  std::ostream *  fp,
char *  inputdata,
size_t  inputlength,
int  image_width,
int  image_height,
int  numZ,
int  sample_pixel,
int  bitsallocated,
int  quality
) 
 

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEGUserData().

bool GDCM_NAME_SPACE::gdcm_write_JPEG_file8 (  std::ostream *  fp,
char *  inputdata,
size_t  inputlength,
int  image_width,
int  image_height,
int  numZ,
int  sample_pixel,
int  bitsallocated,
int  quality
) 
 

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEGUserData().

int GDCM_NAME_SPACE::getlastdigit (  unsigned char *  data  )  [inline]
 

Mini function to return the last digit from a number express in base 256 pre condition data contain an array of 6 unsigned char post condition carry contain the last digit.

Definition at line 876 of file gdcmUtil.cxx.

Referenced by GDCM_NAME_SPACE::Util::GetMACAddress().

00877 {
00878   int extended, carry = 0;
00879   for(int i=0;i<6;i++)
00880     {
00881     extended = (carry << 8) + data[i];
00882     data[i] = extended / 10;
00883     carry = extended % 10;
00884     }
00885   return carry;
00886 }

int GDCM_NAME_SPACE::GetMacAddrSys (  unsigned char *  addr  ) 
 

gets current M.A.C adress (for internal use only)

Todo:
FIXME I wish we don't pollute command line applications when no Ethernet cable !

Definition at line 598 of file gdcmUtil.cxx.

Referenced by GDCM_NAME_SPACE::Util::GetMACAddress().

00599 {
00600 #ifdef _WIN32
00601    WSADATA WinsockData;
00602    if ( (WSAStartup(MAKEWORD(2, 0), &WinsockData)) != 0 ) 
00603    {
00604       std::cerr << "in Get MAC Adress (internal) : This program requires Winsock 2.x!" 
00605              << std::endl;
00606       return -1;
00607    }
00608 
00609    HANDLE PollForTrapEvent;
00610    AsnObjectIdentifier SupportedView;
00611    UINT OID_ifEntryType[]  = { 1, 3, 6, 1, 2, 1, 2, 2, 1, 3 };
00612    UINT OID_ifEntryNum[]   = { 1, 3, 6, 1, 2, 1, 2, 1 };
00613    UINT OID_ipMACEntAddr[] = { 1, 3, 6, 1, 2, 1, 2, 2, 1, 6 };
00614    AsnObjectIdentifier MIB_ifMACEntAddr = {
00615        sizeof(OID_ipMACEntAddr) / sizeof(UINT), OID_ipMACEntAddr };
00616    AsnObjectIdentifier MIB_ifEntryType = {
00617        sizeof(OID_ifEntryType) / sizeof(UINT), OID_ifEntryType };
00618    AsnObjectIdentifier MIB_ifEntryNum = {
00619        sizeof(OID_ifEntryNum) / sizeof(UINT), OID_ifEntryNum };
00620    RFC1157VarBindList varBindList;
00621    RFC1157VarBind varBind[2];
00622    AsnInteger errorStatus;
00623    AsnInteger errorIndex;
00624    AsnObjectIdentifier MIB_NULL = { 0, 0 };
00625    int ret;
00626    int dtmp;
00627    int j = 0;
00628 
00629    // Load the SNMP dll and get the addresses of the functions necessary
00630    HINSTANCE m_hInst = LoadLibrary("inetmib1.dll");
00631    if (m_hInst < (HINSTANCE) HINSTANCE_ERROR)
00632    {
00633       return -1;
00634    }
00635    pSnmpExtensionInit m_Init =
00636        (pSnmpExtensionInit) GetProcAddress(m_hInst, "SnmpExtensionInit");
00637    pSnmpExtensionQuery m_Query =
00638        (pSnmpExtensionQuery) GetProcAddress(m_hInst, "SnmpExtensionQuery");
00639    m_Init(GetTickCount(), &PollForTrapEvent, &SupportedView);
00640 
00641    /* Initialize the variable list to be retrieved by m_Query */
00642    varBindList.list = varBind;
00643    varBind[0].name = MIB_NULL;
00644    varBind[1].name = MIB_NULL;
00645 
00646    // Copy in the OID to find the number of entries in the
00647    // Inteface table
00648    varBindList.len = 1;        // Only retrieving one item
00649    SNMP_oidcpy(&varBind[0].name, &MIB_ifEntryNum);
00650    m_Query(ASN_RFC1157_GETNEXTREQUEST, &varBindList, &errorStatus,
00651                  &errorIndex);
00652 //   printf("# of adapters in this system : %i\n",
00653 //          varBind[0].value.asnValue.number);
00654    varBindList.len = 2;
00655 
00656    // Copy in the OID of ifType, the type of interface
00657    SNMP_oidcpy(&varBind[0].name, &MIB_ifEntryType);
00658 
00659    // Copy in the OID of ifPhysAddress, the address
00660    SNMP_oidcpy(&varBind[1].name, &MIB_ifMACEntAddr);
00661 
00662    do
00663    {
00664       // Submit the query.  Responses will be loaded into varBindList.
00665       // We can expect this call to succeed a # of times corresponding
00666       // to the # of adapters reported to be in the system
00667       ret = m_Query(ASN_RFC1157_GETNEXTREQUEST, &varBindList, &errorStatus,
00668                     &errorIndex); 
00669       if (!ret)
00670       {
00671          ret = 1;
00672       }
00673       else
00674       {
00675          // Confirm that the proper type has been returned
00676          ret = SNMP_oidncmp(&varBind[0].name, &MIB_ifEntryType,
00677                             MIB_ifEntryType.idLength);
00678       }
00679       if (!ret)
00680       {
00681          j++;
00682          dtmp = varBind[0].value.asnValue.number;
00683 
00684          // Type 6 describes ethernet interfaces
00685          if (dtmp == 6)
00686          {
00687             // Confirm that we have an address here
00688             ret = SNMP_oidncmp(&varBind[1].name, &MIB_ifMACEntAddr,
00689                                MIB_ifMACEntAddr.idLength);
00690             if ( !ret && varBind[1].value.asnValue.address.stream != NULL )
00691             {
00692                if ( (varBind[1].value.asnValue.address.stream[0] == 0x44)
00693                  && (varBind[1].value.asnValue.address.stream[1] == 0x45)
00694                  && (varBind[1].value.asnValue.address.stream[2] == 0x53)
00695                  && (varBind[1].value.asnValue.address.stream[3] == 0x54)
00696                  && (varBind[1].value.asnValue.address.stream[4] == 0x00) )
00697                {
00698                    // Ignore all dial-up networking adapters
00699                    std::cerr << "in Get MAC Adress (internal) : Interface #" 
00700                              << j << " is a DUN adapter\n";
00701                    continue;
00702                }
00703                if ( (varBind[1].value.asnValue.address.stream[0] == 0x00)
00704                  && (varBind[1].value.asnValue.address.stream[1] == 0x00)
00705                  && (varBind[1].value.asnValue.address.stream[2] == 0x00)
00706                  && (varBind[1].value.asnValue.address.stream[3] == 0x00)
00707                  && (varBind[1].value.asnValue.address.stream[4] == 0x00)
00708                  && (varBind[1].value.asnValue.address.stream[5] == 0x00) )
00709                {
00710                   // Ignore NULL addresses returned by other network
00711                   // interfaces
00712                   std::cerr << "in Get MAC Adress (internal) :  Interface #" 
00713                             << j << " is a NULL address\n";
00714                   continue;
00715                }
00716                memcpy( addr, varBind[1].value.asnValue.address.stream, 6);
00717             }
00718          }
00719       }
00720    } while (!ret);
00721 
00722    // Free the bindings
00723    SNMP_FreeVarBind(&varBind[0]);
00724    SNMP_FreeVarBind(&varBind[1]);
00725    return 0;
00726 #endif //Win32 version
00727 
00728 #if defined(__sgi)
00729    return SGIGetMacAddress(addr);
00730 #endif // __sgi
00731 
00732 
00733 // implementation for POSIX system
00734 #if defined(CMAKE_HAVE_NET_IF_ARP_H) && defined(__sun)
00735    //The POSIX version is broken anyway on Solaris, plus would require full
00736    //root power
00737    struct  arpreq          parpreq;
00738    struct  sockaddr_in     *psa;
00739    struct  hostent         *phost;
00740    char                    hostname[MAXHOSTNAMELEN];
00741    char                    **paddrs;
00742    int                     sock, status=0;
00743 
00744    if (gethostname(hostname,  MAXHOSTNAMELEN) != 0 )
00745    {
00746       perror("in Get MAC Adress (internal) : gethostname");
00747       return -1;
00748    }
00749    phost = gethostbyname(hostname);
00750    paddrs = phost->h_addr_list;
00751 
00752    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
00753    if (sock == -1 )
00754    {
00755       perror("in Get MAC Adress (internal) : sock");
00756       return -1;
00757    }
00758    memset(&parpreq, 0, sizeof(struct arpreq));
00759    psa = (struct sockaddr_in *) &parpreq.arp_pa;
00760 
00761    memset(psa, 0, sizeof(struct sockaddr_in));
00762    psa->sin_family = AF_INET;
00763    memcpy(&psa->sin_addr, *paddrs, sizeof(struct in_addr));
00764 
00765    status = ioctl(sock, SIOCGARP, &parpreq);
00766    if (status == -1 )
00767    {
00768       perror("in Get MAC Adress (internal) : SIOCGARP");
00769       return -1;
00770    }
00771    memcpy(addr, parpreq.arp_ha.sa_data, 6);
00772 
00773    return 0;
00774 #else
00775 #ifdef CMAKE_HAVE_NET_IF_H
00776    int       sd;
00777    struct ifreq    ifr, *ifrp;
00778    struct ifconf    ifc;
00779    char buf[1024];
00780    int      n, i;
00781    unsigned char    *a;
00782 #if defined(AF_LINK) && (!defined(SIOCGIFHWADDR) && !defined(SIOCGENADDR))
00783    struct sockaddr_dl *sdlp;
00784 #endif
00785 
00786 //
00787 // BSD 4.4 defines the size of an ifreq to be
00788 // max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
00789 // However, under earlier systems, sa_len isn't present, so the size is 
00790 // just sizeof(struct ifreq)
00791 // We should investigate the use of SIZEOF_ADDR_IFREQ
00792 //
00793 #ifdef HAVE_SA_LEN
00794    #ifndef max
00795       #define max(a,b) ((a) > (b) ? (a) : (b))
00796    #endif
00797    #define ifreq_size(i) max(sizeof(struct ifreq),\
00798         sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
00799 #else
00800    #define ifreq_size(i) sizeof(struct ifreq)
00801 #endif // HAVE_SA_LEN
00802 
00803    if ( (sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0 )
00804    {
00805       return -1;
00806    }
00807    memset(buf, 0, sizeof(buf));
00808    ifc.ifc_len = sizeof(buf);
00809    ifc.ifc_buf = buf;
00810    if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0)
00811    {
00812       close(sd);
00813       return -1;
00814    }
00815    n = ifc.ifc_len;
00816    for (i = 0; i < n; i+= ifreq_size(*ifrp) )
00817    {
00818       ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
00819       strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
00820 #ifdef SIOCGIFHWADDR
00821       if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
00822          continue;
00823       a = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
00824 #else
00825 #ifdef SIOCGENADDR
00826       // In theory this call should also work on Sun Solaris, but apparently
00827       // SIOCGENADDR is not implemented properly thus the call 
00828       // ioctl(sd, SIOCGENADDR, &ifr) always returns errno=2 
00829       // (No such file or directory)
00830       // Furthermore the DLAPI seems to require full root access
00831       if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
00832          continue;
00833       a = (unsigned char *) ifr.ifr_enaddr;
00834 #else
00835 #ifdef AF_LINK
00836       sdlp = (struct sockaddr_dl *) &ifrp->ifr_addr;
00837       if ((sdlp->sdl_family != AF_LINK) || (sdlp->sdl_alen != 6))
00838          continue;
00839       a = (unsigned char *) &sdlp->sdl_data[sdlp->sdl_nlen];
00840 #else
00841       perror("in Get MAC Adress (internal) : No way to access hardware");
00842       close(sd);
00843       return -1;
00844 #endif // AF_LINK
00845 #endif // SIOCGENADDR
00846 #endif // SIOCGIFHWADDR
00847       if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5]) continue;
00848 
00849       if (addr) 
00850       {
00851          memcpy(addr, a, 6);
00852          close(sd);
00853          return 0;
00854       }
00855    }
00856    close(sd);
00857 #endif
00858    // Not implemented platforms (or no Ethernet cable !)
00859    
00861    //perror("Probabely your computer is not connected on a network, therefore its MAC adress cannot be found (or there is a configuration problem on your platform)");
00862 
00863    // But the following -> error: invalid use of 'this' in non-member function
00864    //gdcmWarningMacro( "Probabely your computer is not connected on a network, therefore its MAC adress cannot be found (or there is a configuration problem on your platform)");
00865 
00866    memset(addr,0,6);
00867    return -1;
00868 #endif //__sun
00869 }

void GDCM_NAME_SPACE::info_callback (  const char *  msg,
void * 
) 
 

sample debug callback expecting no client object

Definition at line 77 of file gdcmJpeg2000.cxx.

Referenced by gdcm_read_JPEG2000_file().

00077                                             {
00078   std::cerr << "Info in gdcmopenjpeg" << msg << std::endl;
00079 }

int GDCM_NAME_SPACE::int_ceildivpow2 (  int  a,
int  b
)  [inline]
 

Definition at line 95 of file gdcmJpeg2000.cxx.

Referenced by gdcm_read_JPEG2000_file().

00095                                          {
00096   return (a + (1 << b) - 1) >> b;
00097 }

std::ostream& GDCM_NAME_SPACE::operator<< (  std::ostream &  _os,
const VRKey &  _val
)  [inline]
 

Definition at line 115 of file gdcmVRKey.h.

References GDCM_NAME_SPACE::VRKey::key.

00116 {
00117    _os << _val.key[0] << _val.key[1];
00118    return _os;
00119 }

std::ostream& GDCM_NAME_SPACE::operator<< (  std::ostream &  _os,
const TagKey &  _val
)  [inline]
 

Definition at line 103 of file gdcmTagKey.h.

References GDCM_NAME_SPACE::TagKey::tag.

00104 {
00105    _os.setf( std::ios::right);
00106    _os << std::hex << std::setw( 4 ) << std::setfill( '0' )
00107        << _val.tag[0] << '|' << std::setw( 4 ) << std::setfill( '0' )
00108        << _val.tag[1] << std::setfill( ' ' ) << std::dec;
00109    return _os;
00110 }

std::ostream & GDCM_NAME_SPACE::operator<< (  std::ostream &  os,
const Exception &  e
) 
 

Exception::operator <<.

Parameters:
os ostream to write to
e exception to raise

Definition at line 129 of file gdcmException.cxx.

References GDCM_NAME_SPACE::Exception::fatal(), GDCM_NAME_SPACE::Exception::getError(), and GDCM_NAME_SPACE::Exception::getName().

00130 {
00131    try 
00132    {
00133       os << "Exception " << e.getName() << " thrown: " << e.getError() << std::endl;
00134    }
00135    catch(...) 
00136    {
00137       Exception::fatal("operator<<(std::ostream &, const Exception&)");
00138    }
00139    return os;
00140 }

std::istream& GDCM_NAME_SPACE::operator>> (  std::istream &  _is,
VRKey &  _val
)  [inline]
 

Definition at line 121 of file gdcmVRKey.h.

References GDCM_NAME_SPACE::VRKey::key.

00122 {
00123    _is >> _val.key[0] >> _val.key[1];
00124    return _is;
00125 }

opj_image_t* GDCM_NAME_SPACE::rawtoimage (  char *  inputbuffer,
opj_cparameters_t *  parameters,
int  fragment_size,
int  image_width,
int  image_height,
int  sample_pixel,
int  bitsallocated,
int  sign,
int  quality
) 
 

Definition at line 230 of file gdcmJpeg2000.cxx.

Referenced by gdcm_write_JPEG2000_file().

00233 {
00234   (void)quality;
00235   (void)fragment_size;
00236   int w, h;
00237   int numcomps;
00238   OPJ_COLOR_SPACE color_space;
00239   opj_image_cmptparm_t cmptparm[3]; /* maximum of 3 components */
00240   opj_image_t * image = NULL;
00241 
00242   assert( sample_pixel == 1 || sample_pixel == 3 );
00243   if( sample_pixel == 1 )
00244     {
00245     numcomps = 1;
00246     color_space = CLRSPC_GRAY;
00247     }
00248   else // sample_pixel == 3
00249     {
00250     numcomps = 3;
00251     color_space = CLRSPC_SRGB;
00252     }
00253   int subsampling_dx = parameters->subsampling_dx;
00254   int subsampling_dy = parameters->subsampling_dy;
00255 
00256   // FIXME
00257   w = image_width;
00258   h = image_height;
00259 
00260   /* initialize image components */
00261   memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
00262   //assert( bitsallocated == 8 );
00263   for(int i = 0; i < numcomps; i++) {
00264     cmptparm[i].prec = bitsallocated;
00265     cmptparm[i].bpp = bitsallocated;
00266     cmptparm[i].sgnd = sign;
00267     cmptparm[i].dx = subsampling_dx;
00268     cmptparm[i].dy = subsampling_dy;
00269     cmptparm[i].w = w;
00270     cmptparm[i].h = h;
00271   }
00272 
00273   /* create the image */
00274   image = opj_image_create(numcomps, &cmptparm[0], color_space);
00275   if(!image) {
00276     return NULL;
00277   }
00278   /* set image offset and reference grid */
00279   image->x0 = parameters->image_offset_x0;
00280   image->y0 = parameters->image_offset_y0;
00281   image->x1 = parameters->image_offset_x0 + (w - 1) * subsampling_dx + 1;
00282   image->y1 = parameters->image_offset_y0 + (h - 1) * subsampling_dy + 1;
00283 
00284   /* set image data */
00285 
00286   //assert( fragment_size == numcomps*w*h*(bitsallocated/8) );
00287   if (bitsallocated <= 8)
00288     {
00289     if( sign )
00290       {
00291       rawtoimage_fill<int8_t>((int8_t*)inputbuffer,w,h,numcomps,image);
00292       }
00293     else
00294       {
00295       rawtoimage_fill<uint8_t>((uint8_t*)inputbuffer,w,h,numcomps,image);
00296       }
00297     }
00298   else if (bitsallocated <= 16)
00299     {
00300     if( sign )
00301       {
00302       rawtoimage_fill<int16_t>((int16_t*)inputbuffer,w,h,numcomps,image);
00303       }
00304     else
00305       {
00306       rawtoimage_fill<uint16_t>((uint16_t*)inputbuffer,w,h,numcomps,image);
00307       }
00308     }
00309   else if (bitsallocated <= 32)
00310     {
00311     if( sign )
00312       {
00313       rawtoimage_fill<int32_t>((int32_t*)inputbuffer,w,h,numcomps,image);
00314       }
00315     else
00316       {
00317       rawtoimage_fill<uint32_t>((uint32_t*)inputbuffer,w,h,numcomps,image);
00318       }
00319     }
00320   else
00321     {
00322     abort();
00323     }
00324 
00325   return image;
00326 }

template<typename T>
void GDCM_NAME_SPACE::rawtoimage_fill (  T *  inputbuffer,
int  w,
int  h,
int  numcomps,
opj_image_t *  image
) 
 

Definition at line 216 of file gdcmJpeg2000.cxx.

00217 {
00218   T *p = inputbuffer;
00219   for (int i = 0; i < w * h; i++)
00220     {
00221     for(int compno = 0; compno < numcomps; compno++)
00222       {
00223       /* compno : 0 = GREY, (0, 1, 2) = (R, G, B) */
00224       image->comps[compno].data[i] = *p;
00225       ++p;
00226       }
00227     }
00228 }

double GDCM_NAME_SPACE::square_dist (  vector3D const &  v1,
vector3D const &  v2
)  [inline]
 

Definition at line 154 of file gdcmOrientation.cxx.

References GDCM_NAME_SPACE::vector3D::x, GDCM_NAME_SPACE::vector3D::y, and GDCM_NAME_SPACE::vector3D::z.

Referenced by GDCM_NAME_SPACE::Orientation::CalculLikelyhood2Vec().

00155 {
00156   double res;
00157   res = (v1.x - v2.x)*(v1.x - v2.x) +
00158         (v1.y - v2.y)*(v1.y - v2.y) +
00159         (v1.z - v2.z)*(v1.z - v2.z);
00160   return res;
00161 }

void GDCM_NAME_SPACE::UpdateBasicOffsetTable (  std::ostream *  fp,
JpegVector const &  v,
size_t  pos
) 
 

Definition at line 190 of file gdcmPixelWriteConvert.cxx.

00191 {
00192   JpegVector::const_iterator i;
00193   fp->seekp( pos );
00194   const JpegPair &first = v[0];
00195   for(i=v.begin(); i!=v.end(); ++i)
00196     {
00197     const JpegPair &jp = *i;
00198     if(i == v.begin() ){ assert( jp.first - first.first == 0); }
00199     uint32_t offset = (uint32_t)(jp.first - first.first);
00200     GDCM_NAME_SPACE::binary_write(*fp, offset);
00201     //std::cerr << "Updating Table:" << jp.first - first.first << std::endl;
00202     }
00203 }

void GDCM_NAME_SPACE::UpdateJpegFragmentSize (  std::ostream *  fp,
JpegVector const &  v
) 
 

Definition at line 205 of file gdcmPixelWriteConvert.cxx.

References binary_write().

Referenced by CloseJpeg().

00206 {
00207   JpegVector::const_iterator i;
00208   for(i= v.begin(); i!=v.end(); ++i)
00209     {
00210     const JpegPair &jp = *i;
00211     fp->seekp( jp.first );
00212     uint32_t length = jp.second;
00213     GDCM_NAME_SPACE::binary_write(*fp, length);
00214     //std::cerr << "Updating:" << jp.first << "," << jp.second << std::endl;
00215     }
00216 }

void GDCM_NAME_SPACE::warning_callback (  const char *  msg,
void * 
) 
 

sample warning callback expecting a FILE* client object

Definition at line 71 of file gdcmJpeg2000.cxx.

Referenced by gdcm_read_JPEG2000_file().

00071                                                {
00072   std::cerr << "Warning in gdcmopenjpeg" << msg << std::endl;
00073 }

void GDCM_NAME_SPACE::WriteDICOMItems (  std::ostream *  fp,
JpegVector &  v
) 
 

Definition at line 137 of file gdcmPixelWriteConvert.cxx.

References binary_write().

Referenced by GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEG2000UserData(), and GDCM_NAME_SPACE::PixelWriteConvert::SetCompressJPEGUserData().

00138 {
00139   // Item tag:
00140   uint16_t group = 0xfffe;
00141   uint16_t elem  = 0xe000;
00142   GDCM_NAME_SPACE::binary_write(*fp, group);
00143   GDCM_NAME_SPACE::binary_write(*fp, elem);
00144   // Item Length
00145   uint32_t dummy = 0x12345678;
00146   size_t offset = fp->tellp();
00147   JpegPair jp;
00148   jp.first = offset;
00149   v.push_back(jp);
00150   GDCM_NAME_SPACE::binary_write(*fp, dummy);
00151 }

Variable Documentation

DICT_ENTRY GDCM_NAME_SPACE::datadir[] [static]
 

Definition at line 41 of file gdcmDefaultDicts.cxx.

Referenced by FillDefaultDataDict().

ELEMENT GDCM_NAME_SPACE::dataElement[] [static]
 

Definition at line 2928 of file gdcmDefaultDicts.cxx.

Referenced by FillDefaultDIRDict().

const std::string GDCM_NAME_SPACE::GDCM_BINLOADED = "GDCM::Binary data loaded"
 

Definition at line 40 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DataEntry::Print().

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_BINLOADED
 

Definition at line 40 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DataEntry::Print().

const char GDCM_NAME_SPACE::GDCM_FILESEPARATOR = '/'
 

Definition at line 51 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::Util::GetName(), GDCM_NAME_SPACE::Util::GetPath(), GDCM_NAME_SPACE::Util::NormalizePath(), and GDCM_NAME_SPACE::DicomDir::SetElement().

GDCM_EXPORT const char GDCM_NAME_SPACE::GDCM_FILESEPARATOR
 

Definition at line 51 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::Util::GetName(), GDCM_NAME_SPACE::Util::GetPath(), GDCM_NAME_SPACE::Util::NormalizePath(), and GDCM_NAME_SPACE::DicomDir::SetElement().

const std::string GDCM_NAME_SPACE::GDCM_NOTASCII = "GDCM::NotAscii"
 

Definition at line 43 of file gdcmGlobal.cxx.

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_NOTASCII
 

Definition at line 43 of file gdcmGlobal.cxx.

const std::string GDCM_NAME_SPACE::GDCM_NOTLOADED = "GDCM::NotLoaded"
 

Definition at line 41 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DocEntrySet::GetEntryString(), and GDCM_NAME_SPACE::Document::GetTransferSyntaxName().

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_NOTLOADED
 

Definition at line 41 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DocEntrySet::GetEntryString(), and GDCM_NAME_SPACE::Document::GetTransferSyntaxName().

const std::string GDCM_NAME_SPACE::GDCM_PIXELDATA = "GDCM::Pixel Data to be loaded"
 

Definition at line 44 of file gdcmGlobal.cxx.

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_PIXELDATA
 

Definition at line 44 of file gdcmGlobal.cxx.

const std::string GDCM_NAME_SPACE::GDCM_UNFOUND = "GDCM::Unfound"
 

Definition at line 39 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::File::AnonymizeFile(), GDCM_NAME_SPACE::PixelReadConvert::BuildLUTRGBA(), GDCM_NAME_SPACE::SerieHelper::CreateUniqueSeriesIdentifier(), GDCM_NAME_SPACE::SerieHelper::CreateUserDefinedFileIdentifier(), GDCM_NAME_SPACE::File::DoTheLoadingJob(), GDCM_NAME_SPACE::DocEntrySet::GetEntryString(), GDCM_NAME_SPACE::File::GetImageNumber(), GDCM_NAME_SPACE::File::GetImageOrientationPatient(), GDCM_NAME_SPACE::File::GetImagePositionPatient(), GDCM_NAME_SPACE::File::GetLUTNbits(), GDCM_NAME_SPACE::File::GetModality(), GDCM_NAME_SPACE::DictGroupName::GetName(), GDCM_NAME_SPACE::File::GetNumberOfScalarComponents(), GDCM_NAME_SPACE::Orientation::GetOrientation(), GDCM_NAME_SPACE::File::GetPixelType(), GDCM_NAME_SPACE::File::GetRescaleSlope(), GDCM_NAME_SPACE::File::GetRescaleSlopeIntercept(), GDCM_NAME_SPACE::File::GetSpacing(), GDCM_NAME_SPACE::Document::GetTransferSyntaxName(), GDCM_NAME_SPACE::File::IsMonochrome(), GDCM_NAME_SPACE::File::IsMonochrome1(), GDCM_NAME_SPACE::File::IsPaletteColor(), GDCM_NAME_SPACE::File::IsReadable(), GDCM_NAME_SPACE::File::IsYBRFull(), GDCM_NAME_SPACE::DicomDir::SetElement(), and GDCM_NAME_SPACE::SerieHelper::SplitOnPosition().

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_UNFOUND
 

Definition at line 39 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::File::AnonymizeFile(), GDCM_NAME_SPACE::PixelReadConvert::BuildLUTRGBA(), GDCM_NAME_SPACE::SerieHelper::CreateUniqueSeriesIdentifier(), GDCM_NAME_SPACE::SerieHelper::CreateUserDefinedFileIdentifier(), GDCM_NAME_SPACE::File::DoTheLoadingJob(), GDCM_NAME_SPACE::DocEntrySet::GetEntryString(), GDCM_NAME_SPACE::File::GetImageNumber(), GDCM_NAME_SPACE::File::GetImageOrientationPatient(), GDCM_NAME_SPACE::File::GetImagePositionPatient(), GDCM_NAME_SPACE::File::GetLUTNbits(), GDCM_NAME_SPACE::File::GetModality(), GDCM_NAME_SPACE::DictGroupName::GetName(), GDCM_NAME_SPACE::File::GetNumberOfScalarComponents(), GDCM_NAME_SPACE::Orientation::GetOrientation(), GDCM_NAME_SPACE::File::GetPixelType(), GDCM_NAME_SPACE::File::GetRescaleSlope(), GDCM_NAME_SPACE::File::GetRescaleSlopeIntercept(), GDCM_NAME_SPACE::File::GetSpacing(), GDCM_NAME_SPACE::Document::GetTransferSyntaxName(), GDCM_NAME_SPACE::File::IsMonochrome(), GDCM_NAME_SPACE::File::IsMonochrome1(), GDCM_NAME_SPACE::File::IsPaletteColor(), GDCM_NAME_SPACE::File::IsReadable(), GDCM_NAME_SPACE::File::IsYBRFull(), GDCM_NAME_SPACE::DicomDir::SetElement(), and GDCM_NAME_SPACE::SerieHelper::SplitOnPosition().

const std::string GDCM_NAME_SPACE::GDCM_UNKNOWN = "GDCM::Unknown"
 

Those global string that are returned by reference everywhere in gdcm code used to be in gdcmCommon.h but due to a 'bug' in gcc/MacOSX you cannot have static initialization in a multithreaded environment since there is a lazy construction everything got skrew up somehow Therefore the actual initialization is done in a cxx file (avoid duplicated symbol), and an extern is used in gdcmCommon.h.

Definition at line 38 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DocEntry::GetName(), GDCM_NAME_SPACE::Document::GetTransferSyntax(), GDCM_NAME_SPACE::DocEntry::GetVM(), GDCM_NAME_SPACE::Document::HandleOutOfGroup0002(), GDCM_NAME_SPACE::DictEntry::IsVMUnknown(), GDCM_NAME_SPACE::DocEntry::IsVMUnknown(), and GDCM_NAME_SPACE::Validator::SetInput().

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_UNKNOWN
 

Those global string that are returned by reference everywhere in gdcm code used to be in gdcmCommon.h but due to a 'bug' in gcc/MacOSX you cannot have static initialization in a multithreaded environment since there is a lazy construction everything got skrew up somehow Therefore the actual initialization is done in a cxx file (avoid duplicated symbol), and an extern is used in gdcmCommon.h.

Definition at line 38 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DocEntry::GetName(), GDCM_NAME_SPACE::Document::GetTransferSyntax(), GDCM_NAME_SPACE::DocEntry::GetVM(), GDCM_NAME_SPACE::Document::HandleOutOfGroup0002(), GDCM_NAME_SPACE::DocEntry::IsVMUnknown(), GDCM_NAME_SPACE::DictEntry::IsVMUnknown(), and GDCM_NAME_SPACE::Validator::SetInput().

const std::string GDCM_NAME_SPACE::GDCM_UNREAD = "GDCM::UnRead"
 

Definition at line 42 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DocEntrySet::GetEntryString().

GDCM_EXPORT const std::string GDCM_NAME_SPACE::GDCM_UNREAD
 

Definition at line 42 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::DocEntrySet::GetEntryString().

const char GDCM_NAME_SPACE::GDCM_VRUNKNOWN[2] = {' ',' '}
 

Definition at line 46 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::FileHelper::CopyDataEntry(), GDCM_NAME_SPACE::Document::FindDocEntryVR(), GDCM_NAME_SPACE::DocEntrySet::InsertEntryString(), GDCM_NAME_SPACE::DicomEntry::IsVRUnknown(), GDCM_NAME_SPACE::DictEntry::IsVRUnknown(), GDCM_NAME_SPACE::DocEntry::IsVRUnknown(), GDCM_NAME_SPACE::DocEntry::Print(), and GDCM_NAME_SPACE::Document::ReadNextDocEntry().

GDCM_EXPORT const char GDCM_NAME_SPACE::GDCM_VRUNKNOWN[2]
 

Definition at line 46 of file gdcmGlobal.cxx.

Referenced by GDCM_NAME_SPACE::FileHelper::CopyDataEntry(), GDCM_NAME_SPACE::Document::FindDocEntryVR(), GDCM_NAME_SPACE::DocEntrySet::InsertEntryString(), GDCM_NAME_SPACE::DocEntry::IsVRUnknown(), GDCM_NAME_SPACE::DictEntry::IsVRUnknown(), GDCM_NAME_SPACE::DicomEntry::IsVRUnknown(), GDCM_NAME_SPACE::DocEntry::Print(), and GDCM_NAME_SPACE::Document::ReadNextDocEntry().

Global GDCM_NAME_SPACE::Glob
 

Global container.

Definition at line 67 of file gdcmGlobal.cxx.

const char* GDCM_NAME_SPACE::OrientationTypeStrings[] [static]
 

Initial value:

 { 
  "Not Applicable",
  "Axial",
  "Coronal",
  "Sagital",
  "Heart Axial",
  "Heart Coronal",
  "Heart Sagital",
  "Axial invert",
  "Coronal invert",
  "Sagital invert",
  "Heart Axial invert",
  "Heart Coronal invert",
  "Heart Sagital invert",
  NULL
}
THERALYS' Algorithm to determine the most similar basic orientation (Axial, Coronal, Sagital) of the image.

Note:
Should be run on the first gdcm::File of a 'coherent' Serie
Returns:
orientation code # 0 : Not Applicable (neither 0020,0037 Image Orientation Patient # nor 0020,0032 Image Position found) # 1 : Axial # -1 : Axial invert # 2 : Coronal # -2 : Coronal invert # 3 : Sagital # -3 : Sagital invert # 4 : Heart Axial # -4 : Heart Axial invert # 5 : Heart Coronal # -5 : Heart Coronal invert # 6 : Heart Sagital # -6 : Heart Sagital invert

Definition at line 55 of file gdcmOrientation.cxx.

Referenced by GDCM_NAME_SPACE::Orientation::GetOrientationTypeString().

Generated on Fri Aug 24 13:01:20 2007 for gdcm by  doxygen 1.4.6