#include <string>
#include <iostream>
#include <stddef.h> // For size_t
-#include <glib.h>
-#include <stdio.h> // CLEANME
+#include <stdio.h> // FIXME For FILE on GCC only
#include <map> // The requirement for the hash table (or map) that
// we shall use:
// 1/ First, next, last (iterators)
// which should be around 4500 entries which is the
// average dictionary size (said JPR)
-#ifdef _MSC_VR
+#define g_malloc malloc
+#define g_free free
+
+#ifdef __GNUC__
+#include <stdint.h>
+#define guint16 uint16_t
+#define guint32 uint32_t
+#endif
+#ifdef _MSC_VER
+typedef unsigned short guint16;
+typedef unsigned int guint32;
+
+#endif
+
+#ifdef _MSC_VER
using namespace std; // string type lives in the std namespace on VC++
#endif
-#ifdef _MSC_VR
+#ifdef _MSC_VER
#define GDCM_EXPORT __declspec( dllexport )
#else
#define GDCM_EXPORT
public:
//CLEANME gdcmDictEntry();
gdcmDictEntry(guint16 group, guint16 element,
- string vr, string fourth, string name);
+ string vr = "Unknown",
+ string fourth = "Unknown",
+ string name = "Unknown");
static TagKey TranslateToKey(guint16 group, guint16 element);
guint16 GetGroup(void) { return group;};
guint16 GetElement(void){return element;};
string GetVR(void) {return vr; };
- void SetVR(string in){vr = in; };
+ void SetVR(string);
+ bool IsVrUnknown(void);
string GetFourth(void) {return fourth;};
string GetName(void) {return name;};
string GetKey(void) {return key;};
private:
gdcmDictEntry *entry;
guint32 LgrElem;
+ bool ImplicitVr; // Even when reading explicit vr files, some
+ // elements happen to be implicit. Flag them here
+ // since we can't use the entry->vr without breaking
+ // the underlying dictionary.
// Might prove of some interest (see _ID_DCM_ELEM)
// int Swap;
public:
string value; // used to be char * valeurElem
size_t Offset; // Offset from the begining of file for direct user access
ElValue(gdcmDictEntry*);
- void SetVR(string);
- string GetVR(void);
+ void SetDictEntry(gdcmDictEntry *NewEntry) { entry = NewEntry; };
+
+ bool IsVrUnknown(void) { return entry->IsVrUnknown(); };
void SetLength(guint32 l){LgrElem = l; };
void SetValue(string val){ value = val; };
void SetOffset(size_t of){ Offset = of; };
+ void SetImplicitVr(void) { ImplicitVr = true; };
+ bool IsImplicitVr(void) { return ImplicitVr; };
+ void SetVR(string);
+ string GetVR(void);
string GetValue(void) { return value; };
- guint32 GetLength(void) { return LgrElem; };
+ guint32 GetLength(void) { return LgrElem; };
size_t GetOffset(void) { return Offset; };
guint16 GetGroup(void) { return entry->GetGroup(); };
guint16 GetElement(void) { return entry->GetElement(); };
typedef map<string, ElValue*> TagElValueNameHT;
// Container for a set of succefully parsed ElValues.
class GDCM_EXPORT ElValSet {
- // We need both accesses with a TagKey and the Dicentry.Name
+ // We need both accesses with a TagKey and the Dictentry.Name
TagElValueHT tagHt;
TagElValueNameHT NameHt;
public:
// Notes:
// * the gdcmHeader::Set*Tag* family members cannot be defined as protected
// (Swig limitations for as Has_a dependency between gdcmFile and gdcmHeader)
-class GDCM_EXPORT gdcmHeader {
+class GDCM_EXPORT gdcmHeader {
//FIXME sw should be qn EndianType !!!
//enum EndianType {
//LittleEndian,
//BigEndian,
//BadBigEndian};
private:
- // All instances share the same value representation dictionary
+ // All instances share the same Value Representation dictionary
static VRHT *dicom_vr;
+ // Dictionaries of data elements:
static gdcmDictSet* Dicts; // Global dictionary container
gdcmDict* RefPubDict; // Public Dictionary
gdcmDict* RefShaDict; // Shadow Dictionary (optional)
- ElValSet PubElVals; // Element Values parsed with Public Dictionary
- ElValSet ShaElVals; // Element Values parsed with Shadow Dictionary
+ // Parsed element values:
+ ElValSet PubElVals; // parsed with Public Dictionary
+ ElValSet ShaElVals; // parsed with Shadow Dictionary
// In order to inspect/navigate through the file
string filename;
FILE * fp;
// outside of the elements:
guint16 grPixel;
guint16 numPixel;
+ // Swap code (little, big, big-bad endian): this code is not fixed
+ // during parsing.
int sw;
+ // Only the elements whose size are below this bound shall be loaded.
+ // By default, this upper bound is limited to 1024 (which looks reasonable
+ // when one considers the definition of the various VR contents).
+ guint32 MaxSizeLoadElementValue;
guint16 ReadInt16(void);
guint32 ReadInt32(void);
void FindLength(ElValue *);
void FindVR(ElValue *);
void LoadElementValue(ElValue *);
+ void LoadElementValueSafe(ElValue *);
void SkipElementValue(ElValue *);
void InitVRDict(void);
- bool IsAnInteger(guint16, guint16, string, guint32);
- ElValue * ReadNextElement(void);
+ void SwitchSwapToBigEndian(void);
+ void FixFoundLength(ElValue*, guint32);
+ bool IsAnInteger(ElValue *);
+ bool IsBigEndianTransferSyntax(void);
+ void SetMaxSizeLoadElementValue(long);
+ ElValue * ReadNextElement(void);
gdcmDictEntry * IsInDicts(guint32, guint32);
size_t GetPixelOffset(void);
protected:
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff