Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

gdcm 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...
class  DicomDir
 DicomDir defines an object representing a DICOMDIR in memory as a tree-like structure DicomDirPatient -> DicomDirStudy -> DicomDirSerie -> DicomDirImage. 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  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 (possibely 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 and 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 gdm user (internal use only). More...
class  PixelWriteConvert
 Utility container for gathering the various forms the pixel data migth take during the user requiered processes. More...
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< DicomDirObject * > ListContent
typedef std::list< DicomDirStudy * > ListDicomDirStudy
typedef std::list< DicomDirImage * > ListDicomDirImage
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 std::list< SQItem * > ListSQItem
typedef std::vector< File * > FileList
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::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
}
 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  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 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
void FillDefaultDataDict (Dict *d)
 auto generated function, to fill up the Dicom 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
std::ostream & operator<< (std::ostream &os, const Exception &e)
 Exception::operator <<.
bool gdcm_read_JPEG2000_file (void *raw, char *inputdata, size_t inputlength)
 routine for JPEG decompression
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
static int Headers ()
 routine for MPEG decompression
static void DeInitialize_Decoder ()
static void Deinitialize_Sequence ()
static void Initialize_Sequence ()
static int video_sequence (int *Bitstream_Framenumber)
static int Decode_Bitstream ()
static void Initialize_Decoder ()
bool ReadMPEGFile (std::ifstream *fp, char *image_buffer, size_t length)
double square_dist (vector3D const &v1, vector3D const &v2)
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)
void FillDefaultVRDict (VRHT &vr)
 auto generated function, to fill up the 'Value Representation' Dictionnary, if relevant file is not found on user's disk
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 = "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::Unfound"
GDCM_EXPORT const std::string GDCM_BINLOADED = "gdcm::Binary data loaded"
GDCM_EXPORT const std::string GDCM_NOTLOADED = "gdcm::NotLoaded"
GDCM_EXPORT const std::string GDCM_UNREAD = "gdcm::UnRead"
GDCM_EXPORT const std::string GDCM_NOTASCII = "gdcm::NotAscii"
GDCM_EXPORT const std::string GDCM_PIXELDATA = "gdcm::Pixel Data to be loaded"
GDCM_EXPORT const std::string GDCM_VRUNKNOWN = " "
GDCM_EXPORT 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::BOOL_FUNCTION_PFILE_PFILE_POINTER)(File *, File *)
 

Definition at line 42 of file gdcmSerieHelper.h.

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

Definition at line 32 of file gdcmCommandManager.h.

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

Definition at line 30 of file gdcmCommandManager.h.

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

Group Name Hash Table.

Definition at line 33 of file gdcmDictGroupName.h.

typedef std::string gdcm::DictKey
 

Definition at line 34 of file gdcmDict.h.

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

Definition at line 31 of file gdcmDictSet.h.

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

Definition at line 31 of file gdcmDirList.h.

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

Definition at line 32 of file gdcmSerieHelper.h.

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

Definition at line 117 of file gdcmFileHelper.cxx.

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

Definition at line 31 of file gdcmDicomDirObject.h.

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

Definition at line 31 of file gdcmDicomDirElement.h.

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

Definition at line 26 of file gdcmDicomDirSerie.h.

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

Definition at line 37 of file gdcmDicomDirElement.h.

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

Definition at line 32 of file gdcmDicomDirElement.h.

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

Definition at line 38 of file gdcmDicomDir.h.

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

Definition at line 33 of file gdcmDicomDirElement.h.

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

Definition at line 27 of file gdcmDicomDirStudy.h.

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

Definition at line 36 of file gdcmDicomDirElement.h.

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

Definition at line 26 of file gdcmDicomDirPatient.h.

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

Definition at line 34 of file gdcmDicomDirElement.h.

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

Definition at line 33 of file gdcmDicomDirStudy.h.

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

Definition at line 35 of file gdcmDicomDirElement.h.

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

Definition at line 29 of file gdcmSQItem.h.

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

Definition at line 28 of file gdcmSeqEntry.h.

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

Definition at line 35 of file gdcmOrientation.h.

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

Definition at line 30 of file gdcmElementSet.h.

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

Definition at line 35 of file gdcmDict.h.

typedef std::string gdcm::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 85 of file gdcmCommon.h.

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

Definition at line 41 of file gdcmDicomDir.h.

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

Definition at line 35 of file gdcmFileHelper.h.

typedef std::string gdcm::VRAtr
 

Definition at line 33 of file gdcmVR.h.

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

Value Representation Hash Table.

Definition at line 35 of file gdcmVR.h.

typedef std::map<std::string, FileList *> gdcm::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 40 of file gdcmSerieHelper.h.

Enumeration Type Documentation

enum gdcm::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::CompOperators
 

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

Enumerator:
GDCM_EQUAL 
GDCM_DIFFERENT 
GDCM_GREATER 
GDCM_GREATEROREQUAL 
GDCM_LESS 
GDCM_LESSOREQUAL 

Definition at line 109 of file gdcmCommon.h.

00109                    {
00110    GDCM_EQUAL = 0,
00111    GDCM_DIFFERENT,
00112    GDCM_GREATER,
00113    GDCM_GREATEROREQUAL,
00114    GDCM_LESS,
00115    GDCM_LESSOREQUAL
00116 };

enum gdcm::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 98 of file gdcmCommon.h.

00098                   {
00099    DD_UNKNOWN = 0,
00100    DD_META,
00101    DD_PATIENT,
00102    DD_STUDY,
00103    DD_SERIE,
00104    DD_IMAGE,
00105    DD_VISIT
00106 };

enum gdcm::FileType
 

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

Enumerator:
Unknown 
ExplicitVR 
ImplicitVR 
ACR 
ACR_LIBIDO 
JPEG 

Definition at line 88 of file gdcmCommon.h.

00088               {
00089    Unknown = 0,
00090    ExplicitVR, // DicomDir is in this case. Except when it's ImplicitVR !...
00091    ImplicitVR,
00092    ACR,
00093    ACR_LIBIDO,
00094    JPEG
00095 };

enum gdcm::LodModeType
 

Loading mode.

Enumerator:
LD_ALL 
LD_NOSEQ 
LD_NOSHADOW 
LD_NOSHADOWSEQ 

Definition at line 119 of file gdcmCommon.h.

00120 {
00121    LD_ALL         = 0x00000000, // Load all
00122    LD_NOSEQ       = 0x00000001, // Don't load Sequences
00123    LD_NOSHADOW    = 0x00000002, // Don't load odd groups
00124    LD_NOSHADOWSEQ = 0x00000004  // Don't load Sequences if they belong 
00125                                 //            to an odd group
00126                                 // (*exclusive* from LD_NOSEQ and LD_NOSHADOW)
00127 };

enum gdcm::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::OrientationType
 

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

Definition at line 38 of file gdcmOrientation.h.

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

Function Documentation

GDCM_EXPORT std::ostream & gdcm::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 1055 of file gdcmUtil.cxx.

01056 {
01057 // This is tricky since we are writting two bytes buffer. 
01058 // Be carefull with little endian vs big endian. 
01059 // Also this other trick is to allocate a small (efficient) buffer that store
01060 // intermediate result before writting it.
01061 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
01062    const int BUFFER_SIZE = 4096;
01063    static char buffer[BUFFER_SIZE];
01064    uint16_t *binArea16 = (uint16_t*)val; //for the const
01065  
01066    // how many BUFFER_SIZE long pieces in binArea ?
01067    int nbPieces = len/BUFFER_SIZE; //(16 bits = 2 Bytes)
01068    int remainingSize = len%BUFFER_SIZE;
01069 
01070    for (int j=0;j<nbPieces;j++)
01071    {
01072       uint16_t *pbuffer  = (uint16_t*)buffer; //reinitialize pbuffer
01073       for (int i = 0; i < BUFFER_SIZE/2; i++)
01074       {
01075          *pbuffer = *binArea16 >> 8 | *binArea16 << 8;
01076          pbuffer++;
01077          binArea16++;
01078       }
01079       os.write ( buffer, BUFFER_SIZE );
01080    }
01081    if ( remainingSize > 0)
01082    {
01083       uint16_t *pbuffer  = (uint16_t*)buffer; //reinitialize pbuffer
01084       for (int i = 0; i < remainingSize/2; i++)
01085       {
01086          *pbuffer = *binArea16 >> 8 | *binArea16 << 8;
01087          pbuffer++;
01088          binArea16++;
01089       }
01090       os.write ( buffer, remainingSize );
01091    }
01092    return os;
01093 #else
01094    return os.write(reinterpret_cast<const char*>(val), len);
01095 #endif
01096 }

GDCM_EXPORT std::ostream & gdcm::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 1043 of file gdcmUtil.cxx.

01044 {
01045    // We are writting sizeof(char) thus no need to swap bytes
01046    return os.write(reinterpret_cast<const char*>(val), len);
01047 }

GDCM_EXPORT std::ostream & gdcm::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 1032 of file gdcmUtil.cxx.

01033 {
01034    return os.write(val.c_str(), val.size());
01035 }

GDCM_EXPORT std::ostream & gdcm::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 1022 of file gdcmUtil.cxx.

01023 {
01024    return os.write(val, strlen(val));
01025 }

GDCM_EXPORT std::ostream & gdcm::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 994 of file gdcmUtil.cxx.

00995 {
00996 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)    
00997    double swap = val;
00998    
00999    char *beg = (char *)&swap;
01000    char *end = beg + 7;
01001    char t;
01002    for (unsigned int i = 0; i<7; i++)
01003    {
01004       t    = *beg;
01005       *beg = *end;
01006       *end = t;
01007       beg++,
01008       end--;  
01009    }  
01010    return os.write(reinterpret_cast<const char*>(&swap), 8);
01011 #else
01012    return os.write(reinterpret_cast<const char*>(&val), 8);
01013 #endif //GDCM_WORDS_BIGENDIAN
01014 }

GDCM_EXPORT std::ostream & gdcm::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 976 of file gdcmUtil.cxx.

00977 {
00978 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
00979    uint32_t swap;
00980    swap = (  (val<<24)               | ((val<<8)  & 0x00ff0000) | 
00981             ((val>>8)  & 0x0000ff00) |  (val>>24)               );
00982    return os.write(reinterpret_cast<const char*>(&swap), 4);
00983 #else
00984    return os.write(reinterpret_cast<const char*>(&val), 4);
00985 #endif //GDCM_WORDS_BIGENDIAN
00986 }

GDCM_EXPORT std::ostream & gdcm::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 959 of file gdcmUtil.cxx.

Referenced by gdcm::DicomDir::Write(), gdcm::SQItem::WriteContent(), gdcm::SeqEntry::WriteContent(), gdcm::DocEntry::WriteContent(), and gdcm::DataEntry::WriteContent().

00960 {
00961 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
00962    uint16_t swap;
00963    swap = ( val << 8 | val >> 8 );
00964 
00965    return os.write(reinterpret_cast<const char*>(&swap), 2);
00966 #else
00967    return os.write(reinterpret_cast<const char*>(&val), 2);
00968 #endif //GDCM_WORDS_BIGENDIAN
00969 }

bool gdcm::CheckVM (  DataEntry *  entry  ) 
 

Definition at line 43 of file gdcmValidator.cxx.

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

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

00044 {
00045   // Don't waste time checking tags where VM is OB and OW, since we know
00046   // it's allways 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 }

static int gdcm::Decode_Bitstream (   )  [static]
 

Definition at line 275 of file gdcmMpeg.cxx.

References Headers(), and video_sequence().

Referenced by ReadMPEGFile().

00276 {
00277   int ret;
00278   int Bitstream_Framenum;
00279 
00280   Bitstream_Framenum = 0;
00281 
00282   for(;;)
00283   {
00284 
00285 #ifdef VERIFY
00286     Clear_Verify_Headers();
00287 #endif /* VERIFY */
00288 
00289     ret = Headers();
00290     
00291     if(ret==1)
00292     {
00293       ret = video_sequence(&Bitstream_Framenum);
00294     }
00295     else
00296       return(ret);
00297   }
00298 
00299 }

static void gdcm::DeInitialize_Decoder (   )  [static]
 

Definition at line 76 of file gdcmMpeg.cxx.

Referenced by ReadMPEGFile().

00077 {
00078   free(Clip-384); /* I love magic number */
00079 }

static void gdcm::Deinitialize_Sequence (   )  [static]
 

Definition at line 80 of file gdcmMpeg.cxx.

Referenced by video_sequence().

00081 {
00082   int i;
00083 
00084   /* First cleanup the static buffer in store.c */
00085   FreeStaticBuffer();
00086 
00087   /* clear flags */
00088   base.MPEG2_Flag=0;
00089 
00090   for(i=0;i<3;i++)
00091   {
00092     free(backward_reference_frame[i]);
00093     free(forward_reference_frame[i]);
00094     free(auxframe[i]);
00095 
00096     if (base.scalable_mode==SC_SPAT)
00097     {
00098      free(llframe0[i]);
00099      free(llframe1[i]);
00100     }
00101   }
00102 
00103   if (base.scalable_mode==SC_SPAT)
00104     free(lltmp);
00105 
00106 #ifdef DISPLAY
00107   if (Output_Type==T_X11) 
00108     Terminate_Display_Process();
00109 #endif
00110 }

void gdcm::FillDefaultDataDict (  Dict *  d  ) 
 

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

Referenced by gdcm::Dict::Dict().

void gdcm::FillDefaultDictGroupName (  DictGroupNameHT &  groupName  ) 
 

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

Referenced by gdcm::DictGroupName::DictGroupName().

void gdcm::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

Referenced by gdcm::DicomDirElement::DicomDirElement().

void gdcm::FillDefaultVRDict (  VRHT &  vr  ) 
 

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

Referenced by gdcm::VR::VR().

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

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

routine for JPEG decompression

Parameters:
raw raw
inputdata inputdata
inputlength inputlength
Returns:
1 on success, 0 on error

Definition at line 39 of file gdcmJpeg2000.cxx.

References gdcmStaticErrorMacro.

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

00040 {
00041    j2k_image_t img;
00042    j2k_cp_t cp;
00043  
00044    // default blindly copied
00045    cp.layer=0;
00046    cp.reduce=0;
00047    cp.decod_format=-1;
00048    cp.cod_format=-1;
00049  
00050    cp.cod_format=J2K_CFMT;
00051    cp.decod_format = PGX_DFMT;
00052    int len = inputlength;
00053    unsigned char *src = (unsigned char*)inputdata;
00054  
00055    // Decompression
00056    if (!j2k_decode(src, len, &img, &cp))
00057    {
00058       gdcmStaticErrorMacro( "ERROR -> j2k_to_image: failed to decode image!" );
00059       return false;
00060    }
00061  
00062    // Copy buffer
00063    for (int compno = 0; compno < img.numcomps; compno++)
00064    {
00065       j2k_comp_t *comp = &img.comps[compno];
00066   
00067       int w = img.comps[compno].w;
00068       int wr = int_ceildivpow2(img.comps[compno].w, img.comps[compno].factor);
00069   
00070       //int h = img.comps[compno].h;
00071       int hr = int_ceildivpow2(img.comps[compno].h, img.comps[compno].factor);
00072   
00073       if (comp->prec <= 8)
00074       {
00075          uint8_t *data8 = (uint8_t*)raw;
00076          for (int i = 0; i < wr * hr; i++) 
00077          {
00078             int v = img.comps[compno].data[i / wr * w + i % wr];
00079             *data8++ = (uint8_t)v;
00080          }
00081       }
00082       else if (comp->prec <= 16)
00083       {
00084          uint16_t *data16 = (uint16_t*)raw;
00085          for (int i = 0; i < wr * hr; i++) 
00086          {
00087             int v = img.comps[compno].data[i / wr * w + i % wr];
00088             *data16++ = (uint16_t)v;
00089          }
00090       }
00091       else
00092       {
00093          uint32_t *data32 = (uint32_t*)raw;
00094          for (int i = 0; i < wr * hr; i++) 
00095          {
00096             int v = img.comps[compno].data[i / wr * w + i % wr];
00097             *data32++ = (uint32_t)v;
00098          }
00099       }
00100       free(img.comps[compno].data);
00101    }
00102  
00103    // Free remaining structures
00104    j2k_dec_release();
00105    // FIXME
00106    delete[] inputdata;
00107  
00108    return true;
00109 }

bool gdcm::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 }

int gdcm::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 843 of file gdcmUtil.cxx.

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

00844 {
00845   int extended, carry = 0;
00846   for(int i=0;i<6;i++)
00847     {
00848     extended = (carry << 8) + data[i];
00849     data[i] = extended / 10;
00850     carry = extended % 10;
00851     }
00852   return carry;
00853 }

int gdcm::GetMacAddrSys (  unsigned char *  addr  ) 
 

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

Definition at line 575 of file gdcmUtil.cxx.

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

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

static int gdcm::Headers (   )  [static]
 

routine for MPEG decompression

Parameters:
fp pointer to an already open file descriptor 8 significant bits per pixel
image_buffer to receive uncompressed pixels
length length
Returns:
1 on success, 0 on error

Definition at line 252 of file gdcmMpeg.cxx.

Referenced by Decode_Bitstream(), and video_sequence().

00253 {
00254   int ret;
00255 
00256   ld = &base;
00257   
00258 
00259   /* return when end of sequence (0) or picture
00260      header has been parsed (1) */
00261 
00262   ret = Get_Hdr();
00263 
00264 
00265   if (Two_Streams)
00266   {
00267     ld = &enhan;
00268     if (Get_Hdr()!=ret && !Quiet_Flag)
00269       fprintf(stderr,"streams out of sync\n");
00270     ld = &base;
00271   }
00272 
00273   return ret;
00274 }

static void gdcm::Initialize_Decoder (   )  [static]
 

Definition at line 303 of file gdcmMpeg.cxx.

Referenced by ReadMPEGFile().

00304 {
00305   int i;
00306 
00307   /* Clip table */
00308   if (!(Clip=(unsigned char *)malloc(1024)))
00309     Error("Clip[] malloc failed\n");
00310 
00311   Clip += 384;
00312 
00313   for (i=-384; i<640; i++)
00314     Clip[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
00315 
00316   /* IDCT */
00317   if (Reference_IDCT_Flag)
00318     Initialize_Reference_IDCT();
00319   else
00320     Initialize_Fast_IDCT();
00321 
00322 }

static void gdcm::Initialize_Sequence (   )  [static]
 

Definition at line 113 of file gdcmMpeg.cxx.

Referenced by video_sequence().

00114 {
00115   int cc, size;
00116   static int Table_6_20[3] = {6,8,12};
00117 
00118   /* check scalability mode of enhancement layer */
00119   if (Two_Streams && (enhan.scalable_mode!=SC_SNR) && (base.scalable_mode!=SC_DP))
00120     Error("unsupported scalability mode\n");
00121 
00122   /* force MPEG-1 parameters for proper decoder behavior */
00123   /* see ISO/IEC 13818-2 section D.9.14 */
00124   if (!base.MPEG2_Flag)
00125   {
00126     progressive_sequence = 1;
00127     progressive_frame = 1;
00128     picture_structure = FRAME_PICTURE;
00129     frame_pred_frame_dct = 1;
00130     chroma_format = CHROMA420;
00131     matrix_coefficients = 5;
00132   }
00133 
00134   /* round to nearest multiple of coded macroblocks */
00135   /* ISO/IEC 13818-2 section 6.3.3 sequence_header() */
00136   mb_width = (horizontal_size+15)/16;
00137   mb_height = (base.MPEG2_Flag && !progressive_sequence) ? 2*((vertical_size+31)/32)
00138                                         : (vertical_size+15)/16;
00139 
00140   Coded_Picture_Width = 16*mb_width;
00141   Coded_Picture_Height = 16*mb_height;
00142 
00143   /* ISO/IEC 13818-2 sections 6.1.1.8, 6.1.1.9, and 6.1.1.10 */
00144   Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width
00145                                            : Coded_Picture_Width>>1;
00146   Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height
00147                                             : Coded_Picture_Height>>1;
00148   
00149   /* derived based on Table 6-20 in ISO/IEC 13818-2 section 6.3.17 */
00150   block_count = Table_6_20[chroma_format-1];
00151 
00152   for (cc=0; cc<3; cc++)
00153   {
00154     if (cc==0)
00155       size = Coded_Picture_Width*Coded_Picture_Height;
00156     else
00157       size = Chroma_Width*Chroma_Height;
00158 
00159     if (!(backward_reference_frame[cc] = (unsigned char *)malloc(size)))
00160       Error("backward_reference_frame[] malloc failed\n");
00161 
00162     if (!(forward_reference_frame[cc] = (unsigned char *)malloc(size)))
00163       Error("forward_reference_frame[] malloc failed\n");
00164 
00165     if (!(auxframe[cc] = (unsigned char *)malloc(size)))
00166       Error("auxframe[] malloc failed\n");
00167 
00168     if(Ersatz_Flag)
00169       if (!(substitute_frame[cc] = (unsigned char *)malloc(size)))
00170         Error("substitute_frame[] malloc failed\n");
00171 
00172 
00173     if (base.scalable_mode==SC_SPAT)
00174     {
00175       /* this assumes lower layer is 4:2:0 */
00176       if (!(llframe0[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))
00177         Error("llframe0 malloc failed\n");
00178       if (!(llframe1[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))
00179         Error("llframe1 malloc failed\n");
00180     }
00181   }
00182 
00183   /* SCALABILITY: Spatial */
00184   if (base.scalable_mode==SC_SPAT)
00185   {
00186     if (!(lltmp = (short *)malloc(lower_layer_prediction_horizontal_size*((lower_layer_prediction_vertical_size*vertical_subsampling_factor_n)/vertical_subsampling_factor_m)*sizeof(short))))
00187       Error("lltmp malloc failed\n");
00188   }
00189 
00190 #ifdef DISPLAY
00191   if (Output_Type==T_X11)
00192   {
00193     Initialize_Display_Process("");
00194     Initialize_Dither_Matrix();
00195   }
00196 #endif /* DISPLAY */
00197 
00198 }

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

Definition at line 114 of file gdcmVRKey.h.

References gdcm::VRKey::key.

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

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

Definition at line 98 of file gdcmTagKey.h.

References gdcm::TagKey::tag.

00099 {
00100    _os.setf( std::ios::right);
00101    _os << std::hex << std::setw( 4 ) << std::setfill( '0' )
00102        << _val.tag[0] << '|' << std::setw( 4 ) << std::setfill( '0' )
00103        << _val.tag[1] << std::setfill( ' ' ) << std::dec;
00104    return _os;
00105 }

std::ostream & gdcm::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::Exception::fatal(), gdcm::Exception::getError(), and gdcm::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::operator>> (  std::istream &  _is,
VRKey &  _val
)  [inline]
 

Definition at line 120 of file gdcmVRKey.h.

References gdcm::VRKey::key.

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

bool gdcm::ReadMPEGFile (  std::ifstream *  fp,
char *  image_buffer,
size_t  length
) 
 

Definition at line 324 of file gdcmMpeg.cxx.

References Decode_Bitstream(), DeInitialize_Decoder(), istream::InFd, Initialize_Decoder(), my_close(), my_read(), and my_seek().

00325 {
00326   std::streampos mpeg_start = fp->tellg(); // the MPEG stream in our case does not start at 0
00327 #if 0
00328   fp->read((char*)image_buffer, length);
00329   std::ofstream out("/tmp/etiam.mpeg");
00330   out.write((char*)image_buffer, length);
00331   out.close();
00332 #else
00333   (void)length;
00334 #endif
00335 
00336   int ret, code;
00337   istream bos,eos;
00338   /*base.open_stream = my_open;*/
00339   base.seek_stream = my_seek;
00340   base.read_stream = my_read;
00341   base.close_stream = my_close;
00342 
00343   Verbose_Flag                         = 0;
00344   Output_Type                          = T_MEM; //store in mem
00345   Output_Picture_Filename              = "/tmp/rec%d";
00346   hiQdither                            = 0;
00347   Frame_Store_Flag                     = 1;
00348   Spatial_Flag                         = 0;
00349   Lower_Layer_Picture_Filename         = "";
00350   Reference_IDCT_Flag                  = 1;
00351   Trace_Flag                           = 0;
00352   Quiet_Flag                           = 0;
00353   Ersatz_Flag                          = 0;
00354   Substitute_Picture_Filename          = "";
00355   Two_Streams                          = 0;
00356   Enhancement_Layer_Bitstream_Filename = "";
00357   Big_Picture_Flag                     = 0;
00358   Main_Bitstream_Flag                  = 1;
00359   Main_Bitstream_Filename              = "/tmp/etiam.mpeg";
00360   Main_Bitstream_Filename              = "/tmp/ts.mpg";
00361   Verify_Flag                          = 0;
00362   Stats_Flag                           = 0;
00363   User_Data_Flag                       = 0;
00364   OUTMEM                               = (char*)image_buffer;
00365 
00366 
00367   ld = &base; /* select base layer context */
00368 
00369   /* open MPEG base layer bitstream file(s) */
00370   /* NOTE: this is either a base layer stream or a spatial enhancement stream */
00371 /*  if ((base.Infile=open(Main_Bitstream_Filename,O_RDONLY|O_BINARY))<0) */
00372   /*base.Infile = ld->open_stream(Main_Bitstream_Filename);*/
00373   base.Infile = &bos;
00374 #ifdef FILESTAR
00375   //base.Infile->InFd = fopen(Main_Bitstream_Filename, "rb");
00376   //base.Infile->InFd.open(Main_Bitstream_Filename, std::ios::binary | std::ios::in);
00377   base.Infile->InFd = fp;
00378 #else
00379   base.Infile->InFd = open(Main_Bitstream_Filename,O_RDONLY|O_BINARY );
00380 #endif
00381   if( !base.Infile->InFd)
00382   {
00383     fprintf(stderr,"Base layer input file %s not found\n", Main_Bitstream_Filename);
00384     exit(1);
00385   }
00386 
00387 
00388   if(base.Infile != 0)
00389   {
00390     Initialize_Buffer();
00391 
00392     if(Show_Bits(8)==0x47)
00393     {
00394       sprintf(Error_Text,"Decoder currently does not parse transport streams\n");
00395       Error(Error_Text);
00396     }
00397 
00398     next_start_code();
00399     code = Show_Bits(32);
00400 
00401     switch(code)
00402     {
00403     case SEQUENCE_HEADER_CODE:
00404       break;
00405     case PACK_START_CODE:
00406       System_Stream_Flag = 1;
00407     case VIDEO_ELEMENTARY_STREAM:
00408       System_Stream_Flag = 1;
00409       break;
00410     default:
00411       sprintf(Error_Text,"Unable to recognize stream type\n");
00412       Error(Error_Text);
00413       break;
00414     }
00415 
00416     /*lseek(base.Infile, 0l, SEEK_SET);*/
00417     ld->seek_stream(base.Infile,mpeg_start,SEEK_SET);
00418     Initialize_Buffer(); 
00419   }
00420 
00421   if(base.Infile!=0)
00422   {
00423     /*lseek(base.Infile, 0l, SEEK_SET);*/
00424     ld->seek_stream(base.Infile,mpeg_start,SEEK_SET);
00425   }
00426 
00427   Initialize_Buffer(); 
00428 
00429   if(Two_Streams)
00430   {
00431     ld = &enhan; /* select enhancement layer context */
00432 
00433     /*if ((enhan.Infile = open(Enhancement_Layer_Bitstream_Filename,O_RDONLY|O_BINARY))<0)*/
00434     /*enhan.Infile = ld->open_stream(Enhancement_Layer_Bitstream_Filename);*/
00435     enhan.Infile = &eos;
00436 #ifdef FILESTAR
00437     //enhan.Infile->InFd = fopen(Main_Bitstream_Filename, "rb");
00438     enhan.Infile->InFd->open(Main_Bitstream_Filename, std::ios::binary|std::ios::in);
00439     abort();
00440 #else
00441     enhan.Infile->InFd = open(Enhancement_Layer_Bitstream_Filename,O_RDONLY|O_BINARY);
00442 #endif
00443     if (enhan.Infile->InFd)
00444     {
00445       sprintf(Error_Text,"enhancment layer bitstream file %s not found\n",
00446         Enhancement_Layer_Bitstream_Filename);
00447 
00448       Error(Error_Text);
00449     }
00450 
00451     Initialize_Buffer();
00452     ld = &base;
00453   }
00454 
00455   Initialize_Decoder();
00456 
00457   ret = Decode_Bitstream();
00458 
00459   /*close(base.Infile);*/
00460   ld->close_stream(base.Infile);
00461 
00462   if (Two_Streams)
00463     /*close(enhan.Infile);*/
00464     ld->close_stream(enhan.Infile);
00465 
00466   DeInitialize_Decoder();
00467 
00468 #if 0
00469   std::ofstream out2("/tmp/etiam.raw");
00470   out2.write((char*)image_buffer, 352*240*3*10);
00471   out2.close();
00472 #endif
00473 
00474   return ret;
00475 }

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

Definition at line 154 of file gdcmOrientation.cxx.

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

Referenced by gdcm::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 }

static int gdcm::video_sequence (  int *  Bitstream_Framenumber  )  [static]
 

Definition at line 199 of file gdcmMpeg.cxx.

References Deinitialize_Sequence(), Headers(), and Initialize_Sequence().

Referenced by Decode_Bitstream().

00201 {
00202   int Bitstream_Framenum;
00203   int Sequence_Framenum;
00204   int Return_Value;
00205 
00206   Bitstream_Framenum = *Bitstream_Framenumber;
00207   Sequence_Framenum=0;
00208 
00209   Initialize_Sequence();
00210 
00211   /* decode picture whose header has already been parsed in 
00212      Decode_Bitstream() */
00213 
00214 
00215   Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
00216 
00217   /* update picture numbers */
00218   if (!Second_Field)
00219   {
00220     Bitstream_Framenum++;
00221     Sequence_Framenum++;
00222   }
00223 
00224   /* loop through the rest of the pictures in the sequence */
00225   while ((Return_Value=Headers()))
00226   {
00227     Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
00228 
00229     if (!Second_Field)
00230     {
00231       Bitstream_Framenum++;
00232       Sequence_Framenum++;
00233     }
00234   }
00235 
00236   /* put last frame */
00237   if (Sequence_Framenum!=0)
00238   {
00239     Output_Last_Frame_of_Sequence(Bitstream_Framenum);
00240   }
00241 
00242   Deinitialize_Sequence();
00243 
00244 #ifdef VERIFY
00245     Clear_Verify_Headers();
00246 #endif /* VERIFY */
00247 
00248   *Bitstream_Framenumber = Bitstream_Framenum;
00249   return(Return_Value);
00250 }

Variable Documentation

const std::string gdcm::GDCM_BINLOADED = "gdcm::Binary data loaded"
 

Definition at line 40 of file gdcmGlobal.cxx.

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

const char gdcm::GDCM_FILESEPARATOR = '/'
 

Definition at line 51 of file gdcmGlobal.cxx.

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

const std::string gdcm::GDCM_NOTASCII = "gdcm::NotAscii"
 

Definition at line 43 of file gdcmGlobal.cxx.

const std::string gdcm::GDCM_NOTLOADED = "gdcm::NotLoaded"
 

Definition at line 41 of file gdcmGlobal.cxx.

Referenced by gdcm::DocEntrySet::GetEntryString(), gdcm::Document::GetTransferSyntaxName(), and gdcm::DataEntry::Print().

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

Definition at line 44 of file gdcmGlobal.cxx.

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

const std::string gdcm::GDCM_UNFOUND = "gdcm::Unfound"
 

Definition at line 39 of file gdcmGlobal.cxx.

Referenced by gdcm::File::AnonymizeFile(), gdcm::PixelReadConvert::BuildLUTRGBA(), gdcm::FileHelper::CheckMandatoryElements(), gdcm::SerieHelper::CreateUniqueSeriesIdentifier(), gdcm::File::DoTheLoadingJob(), gdcm::DocEntrySet::GetEntryString(), gdcm::File::GetImageNumber(), gdcm::File::GetImageOrientationPatient(), gdcm::File::GetLUTNbits(), gdcm::File::GetModality(), gdcm::DictGroupName::GetName(), gdcm::File::GetNumberOfScalarComponents(), gdcm::Orientation::GetOrientation(), gdcm::File::GetPixelType(), gdcm::Document::GetTransferSyntaxName(), gdcm::File::IsMonochrome(), gdcm::File::IsMonochrome1(), gdcm::File::IsPaletteColor(), gdcm::File::IsReadable(), gdcm::File::IsYBRFull(), gdcm::DataEntry::Print(), gdcm::DicomDir::SetElement(), and gdcm::SerieHelper::SplitOnPosition().

const std::string gdcm::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::Document::GetTransferSyntax(), gdcm::Document::HandleOutOfGroup0002(), gdcm::DictEntry::IsVMUnknown(), and gdcm::Validator::SetInput().

const std::string gdcm::GDCM_UNREAD = "gdcm::UnRead"
 

Definition at line 42 of file gdcmGlobal.cxx.

Referenced by gdcm::DocEntrySet::GetEntryString(), and gdcm::DataEntry::Print().

const std::string gdcm::GDCM_VRUNKNOWN = " "
 

Definition at line 46 of file gdcmGlobal.cxx.

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

Global gdcm::Glob
 

Global container.

Definition at line 65 of file gdcmGlobal.cxx.

const char* gdcm::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::Orientation::GetOrientationTypeString().

Generated on Fri Jan 20 10:15:01 2006 for gdcm by  doxygen 1.4.4