* src/gdcm.h and gdcmHeader.cxx are now "Big Endian transfer syntax"

[gdcm.git] / src / gdcm.h

diff --git a/src/gdcm.h b/src/gdcm.h
index 82df4e543333a60a0015cdfbf0a4f48f6c35df53..c84f9c00ec36534a23b86c8a615977d8601deb17 100644 (file)
--- a/src/gdcm.h
+++ b/src/gdcm.h
@@ -17,21 +17,37 @@
 
 #include <string>
 #include <iostream>
-#include <stddef.h>    // For size_t
+#include <stddef.h>   // For size_t
+#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)
+                      // 2/ should be sortable (i.e. sorted by TagKey). This
+                      //    condition shall be droped since the Win32/VC++
+                      //    implementation doesn't look a sorted one. Pffff....
+                      // 3/ Make sure we can setup some default size value,
+                      //    which should be around 4500 entries which is the
+                      //    average dictionary size (said JPR)
+#ifdef __GNUC__
+#include <stdint.h>
+#define guint16 uint16_t
+#define guint32 uint32_t
+#define g_malloc malloc
+#define g_free   free
+#endif
+#ifdef _MSC_VER
 #include <glib.h>
-#include <stdio.h>
+#endif
 
-
-// The requirement for the hash table (or map) that we shall use:
-// 1/ First, next, last (iterators)
-// 2/ should be sortable (i.e. sorted by TagKey). This condition
-//    shall be droped since the Win32/VC++ implementation doesn't look
-//    a sorted one. Pffff....
-// 3/ Make sure we can setup some default size value, which should be
-//    around 4500 entries which is the average dictionary size (said JPR)
-#include <map>
-using namespace std;
+#ifdef _MSC_VER
+       using namespace std;  // string type lives in the std namespace on VC++
+#endif
+#ifdef _MSC_VER
 #define GDCM_EXPORT __declspec( dllexport )
+#else
+#define GDCM_EXPORT
+#endif
+
 // Tag based hash tables.
 // We shall use as keys the strings (as the C++ type) obtained by
 // concatenating the group value and the element value (both of type
@@ -72,12 +88,15 @@ private:
 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;};
@@ -134,19 +153,28 @@ class GDCM_EXPORT ElValue {
 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(); };
@@ -185,7 +213,7 @@ typedef map<TagKey, VRAtr> VRHT;    // Value Representation Hash Table
 // 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, 
@@ -220,9 +248,13 @@ private:
        void FindLength(ElValue *);
        void FindVR(ElValue *);
        void LoadElementValue(ElValue *);
+       void LoadElementValueSafe(ElValue *);
        void SkipElementValue(ElValue *);
        void InitVRDict(void);
-       bool IsAnInteger(guint16, guint16, string, guint32);
+       void SwitchSwapToBigEndian(void);
+       void FixFoundLength(ElValue*, guint32);
+       bool IsAnInteger(ElValue *);
+       bool IsBigEndianTransferSyntax(void);
        ElValue * ReadNextElement(void);
        gdcmDictEntry * IsInDicts(guint32, guint32);
        size_t GetPixelOffset(void);