X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2Fgdcm.h;h=735bd98c326ee678b33756a2d727c4a70bfc3aa7;hb=885580b981648efd2b861bb92873c43d09757f27;hp=22f3eb9e7044877b912090b28ae43bf0a16f9217;hpb=f66abc53491ab130c2dbea483ba241edf6da2e88;p=gdcm.git diff --git a/src/gdcm.h b/src/gdcm.h index 22f3eb9e..735bd98c 100644 --- a/src/gdcm.h +++ b/src/gdcm.h @@ -1,9 +1,11 @@ +// gdcm.h + // gdcmlib Intro: // * gdcmlib is a library dedicated to reading and writing dicom files. // * LGPL for the license -// * lightweigth as opposed to CTN or DCMTK wich come bundled which try +// * lightweigth as opposed to CTN or DCMTK which come bundled which try // to implement the full DICOM standard (networking...). gdcmlib concentrates -// on reading and +// on reading and writing // * Formats: this lib should be able to read ACR-NEMA v1 and v2, Dicom v3 (as // stated in part10). [cf dcmtk/dcmdata/docs/datadict.txt] // * Targeted plateforms: Un*xes and Win32/VC++6.0 @@ -15,11 +17,21 @@ // problems appears at loading of _gdcm.[so/dll]). So, simply uncomment // the declaration once you provided the definition of the method... +#ifndef GDCM_H +#define GDCM_H + #include +using namespace std; + #include #include // For size_t #include // FIXME For FILE on GCC only -#include // The requirement for the hash table (or map) that +#include +#include +#include "gdcmException.h" + + + // 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 @@ -28,26 +40,39 @@ // 3/ Make sure we can setup some default size value, // which should be around 4500 entries which is the // average dictionary size (said JPR) + // + // En fait, je disais que dans LE Directory Dicom (dans son etat 2001) + // il y a +/- 1600 entrees. + // Une valeur raisonable pour un majorant du nombre d'entrees + // dans une entete DICOM d'une image semble semble etre 300 + // Si on 'decortique' les elements SQ (ce qui ne semble pas etre fait pour le moment) + // on risque en fait de depasser ... un nombre non previsible dans le cas d'une entree SQ + // contenant lui même un tres grand nombre d'entrees ?!?) + // Quant au nombre d'entrees dans un DICOMDIR, c'est encore pire : il n'est limité + // que par la taille d'un CD-ROM (les DVD-ROM ne sont pas encore pris en compte) + // On peut s'attendre a 30 entrees par fichier dicom présent sur le CD-ROM + // REMARQUE : il faudra se pencher sur le pb de la creation du DICOMDIR lorsqu'on voudra + // exporter des images lisibles par les consoles cliniques + // et pas seulement importables dans e-film. + #ifdef __GNUC__ #include #define guint16 uint16_t #define guint32 uint32_t -#define g_malloc malloc -#define g_free free -#endif -#ifdef _MSC_VER -#include #endif -#ifdef _MSC_VER - using namespace std; // string type lives in the std namespace on VC++ +#ifdef _MSC_VER +typedef unsigned short guint16; +typedef unsigned int guint32; #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 @@ -56,25 +81,25 @@ // Then the corresponding TagKey shall be the string 0010|0010 (where // the | (pipe symbol) acts as a separator). Refer to // gdcmDictEntry::TranslateToKey for this conversion function. + typedef string TagKey; +typedef string TagName; class GDCM_EXPORT gdcmDictEntry { private: guint16 group; // e.g. 0x0010 - guint16 element; // e.g. 0x0010 + guint16 element; // e.g. 0x0103 string vr; // Value Representation i.e. some clue about the nature // of the data represented e.g. "FD" short for // "Floating Point Double" - // CLEAN ME: find the official dicom name for this field ! + // CLEANME: find the official dicom name for this field ! string fourth; // Fourth field containing some semantics. string name; // e.g. "Patient_Name" - TagKey key; // This is redundant zith (group, element) but we add + TagKey key; // Redundant with (group, element) but we add it // on efficiency purposes. // DCMTK has many fields for handling a DictEntry (see below). What are the // relevant ones for gdcmlib ? // struct DBI_SimpleEntry { - // Uint16 group; - // Uint16 element; // Uint16 upperGroup; // Uint16 upperElement; // DcmEVR evr; @@ -86,67 +111,92 @@ private: // DcmDictRangeRestriction elementRestriction; // }; public: - //CLEANME gdcmDictEntry(); - gdcmDictEntry(guint16 group, guint16 element, + gdcmDictEntry(guint16 group, + guint16 element, string vr = "Unknown", - string fourth = "Unknown", - string name = "Unknown"); + string fourth = "Unknown", + string name = "Unknown"); + // fabrique une 'clé' par concaténation du numGroupe et du numElement static TagKey TranslateToKey(guint16 group, guint16 element); - guint16 GetGroup(void) { return group;}; + + guint16 GetGroup(void) { return group; }; guint16 GetElement(void){return element;}; - string GetVR(void) {return vr; }; + string GetVR(void) {return vr; }; void SetVR(string); + void SetKey(string k){ key = k; } bool IsVrUnknown(void); string GetFourth(void) {return fourth;}; - string GetName(void) {return name;}; - string GetKey(void) {return key;}; + string GetName(void) {return name; }; + string GetKey(void) {return key; }; }; -typedef map TagHT; - +//////////////////////////////////////////////////////////////////////////// // A single DICOM dictionary i.e. a container for a collection of dictionary // entries. 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... + +typedef map TagKeyHT; +typedef map TagNameHT; + class GDCM_EXPORT gdcmDict { string name; string filename; - TagHT entries; + TagKeyHT KeyHt; // Both accesses with a TagKey or with a + TagNameHT NameHt; // TagName are required. public: - gdcmDict(const char* FileName); // Read Dict from disk - // TODO Swig int AppendEntry(gdcmDictEntry* NewEntry); - gdcmDictEntry * GetTag(guint32 group, guint32 element); + gdcmDict(const char* FileName); // Reads Dict from ascii file + int AddNewEntry (gdcmDictEntry* NewEntry); + int ReplaceEntry(gdcmDictEntry* NewEntry); + int RemoveEntry (TagKey key); + int RemoveEntry (guint16 group, guint16 element); + gdcmDictEntry * GetTagByKey(guint16 group, guint16 element); + gdcmDictEntry * GetTagByName(TagName name); void Print(ostream&); + void PrintByKey(ostream&); + void PrintByName(ostream&); + TagKeyHT & GetEntries(void) { return KeyHt; } }; + +//////////////////////////////////////////////////////////////////////////// // Container for managing a set of loaded dictionaries. Sharing dictionaries // should avoid : -// * reloading an allready loaded dictionary. +// * reloading an allready loaded dictionary, // * having many in memory representations of the same dictionary. + typedef string DictKey; typedef map DictSetHT; + class GDCM_EXPORT gdcmDictSet { private: - string DictPath; // Directory path to dictionaries DictSetHT dicts; int AppendDict(gdcmDict* NewDict); - int LoadDictFromFile(string filename, DictKey); - void SetDictPath(void); + void LoadDictFromFile(string filename, DictKey); +private: + static string DictPath; // Directory path to dictionaries + static string BuildDictPath(void); + static gdcmDict* DefaultPubDict; public: - gdcmDictSet(void); // loads THE DICOM v3 dictionary + static list * GetPubDictTagNames(void); + static map >* GetPubDictTagNamesByCategory(void); + static gdcmDict* LoadDefaultPubDict(void); + + gdcmDictSet(void); // TODO Swig int LoadDictFromFile(string filename); -///// QUESTION: the following function might not be thread safe !? Maybe -///// we need some mutex here, to avoid concurent creation of -///// the same dictionary !?!?! + // QUESTION: the following function might not be thread safe !? Maybe + // we need some mutex here, to avoid concurent creation of + // the same dictionary !?!?! // TODO Swig int LoadDictFromName(string filename); // TODO Swig int LoadAllDictFromDirectory(string DirectoryName); // TODO Swig string* GetAllDictNames(); - int LoadDicomV3Dict(void); + // void Print(ostream&); gdcmDict* GetDict(DictKey DictName); - gdcmDict* GetDefaultPublicDict(void); + gdcmDict* GetDefaultPubDict(void); }; +/////////////////////////////////////////////////////////////////////////// // The dicom header of a Dicom file contains a set of such ELement VALUES // (when successfuly parsed against a given Dicom dictionary) class GDCM_EXPORT ElValue { @@ -157,92 +207,118 @@ private: // 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 + string value; size_t Offset; // Offset from the begining of file for direct user access + ElValue(gdcmDictEntry*); 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; }; - size_t GetOffset(void) { return Offset; }; - guint16 GetGroup(void) { return entry->GetGroup(); }; - guint16 GetElement(void) { return entry->GetElement(); }; - string GetKey(void) { return entry->GetKey(); }; - string GetName(void) { return entry->GetName();}; + + guint16 GetGroup(void) { return entry->GetGroup(); }; + guint16 GetElement(void) { return entry->GetElement();}; + string GetKey(void) { return entry->GetKey(); }; + string GetName(void) { return entry->GetName(); }; + string GetVR(void) { return entry->GetVR(); }; + void SetVR(string v) { entry->SetVR(v); }; + void SetLength(guint32 l){ LgrElem = l; }; + guint32 GetLength(void) { return LgrElem; }; + + // Question : SetLength est public + // (sinon, on ne pourrait pas l'appeler dans ElValSet) + // alors que *personne* ne devrait s'en servir ! + // c'est *forcément* la lgr de la string 'value', non? + + void SetValue(string val){ value = val; }; + string GetValue(void) { return value;}; + + void SetOffset(size_t of){ Offset = of; }; + size_t GetOffset(void) { return Offset;}; + // Question : SetOffset est public ... + // Quel utilisateur serait ammené à modifier l'Offset ? }; + +//////////////////////////////////////////////////////////////////////////// +// Container for a set of successfully parsed ElValues. typedef map TagElValueHT; typedef map TagElValueNameHT; -// Container for a set of succefully parsed ElValues. + class GDCM_EXPORT ElValSet { - // We need both accesses with a TagKey and the Dicentry.Name - TagElValueHT tagHt; - TagElValueNameHT NameHt; -public: - void Add(ElValue*); + TagElValueHT tagHt; // Both accesses with a TagKey or with a + TagElValueNameHT NameHt; // the DictEntry.Name are required. +public: + void Add(ElValue*); void Print(ostream &); void PrintByName(ostream &); - ElValue* GetElement(guint32 group, guint32 element); - string GetElValue(guint32 group, guint32 element); - string GetElValue(string); - TagElValueHT & GetTagHt(void); -}; + int Write(FILE *fp); + ElValue* GetElementByNumber(guint32 group, guint32 element); + ElValue* GetElementByName (string); + string GetElValueByNumber(guint32 group, guint32 element); + string GetElValueByName (string); + + TagElValueHT & GetTagHt(void); + + int SetElValueByNumber(string content, guint32 group, guint32 element); + int SetElValueByName (string content, string TagName); + + int SetElValueLengthByNumber(guint32 l, guint32 group, guint32 element); + int SetElValueLengthByName (guint32 l, string TagName); -// The various entries of the explicit value representation (VR) shall -// be managed within a dictionary. -typedef string VRKey; -typedef string VRAtr; -typedef map VRHT; // Value Representation Hash Table +}; -// The typical usage of objects of this class is to classify a set of -// dicom files according to header information e.g. to create a file hierachy +//////////////////////////////////////////////////////////////////////////// +// The purpous of an instance of gdcmHeader is to act as a container of +// all the elements and their corresponding values (and additionaly the +// corresponding DICOM dictionary entry) of the header of a DICOM file. +// +// The typical usage of instances of class gdcmHeader is to classify a set of +// dicom files according to header information e.g. to create a file hierarchy // reflecting the Patient/Study/Serie informations, or extracting a given // SerieId. Accesing the content (image[s] or volume[s]) is beyond the -// functionality of this class (see dmcFile below). +// functionality of this class and belong to gdmcFile (see below). // Notes: +// * the various entries of the explicit value representation (VR) shall +// be managed within a dictionary which is shared by all gdcmHeader instances // * the gdcmHeader::Set*Tag* family members cannot be defined as protected // (Swig limitations for as Has_a dependency between gdcmFile and gdcmHeader) + +typedef string VRKey; +typedef string VRAtr; +typedef map VRHT; // Value Representation Hash Table + class GDCM_EXPORT gdcmHeader { -//FIXME sw should be qn EndianType !!! - //enum EndianType { - //LittleEndian, - //BadLittleEndian, - //BigEndian, - //BadBigEndian}; + void SkipBytes(guint32); private: - // 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) + + gdcmDictSet* Dicts; // global dictionary container + gdcmDict* RefPubDict; // public dictionary + gdcmDict* RefShaDict; // shadow dictionary (optional) // 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; + string filename; // refering underlying file FILE * fp; - // The tag Image Location ((0028,0200) containing the adress of - // the pixels) is not allways present. When we store this information - // FIXME - // outside of the elements: guint16 grPixel; guint16 numPixel; - // Swap code (little, big, big-bad endian): this code is not fixed - // during parsing. + // Ne faudrait-il pas une indication sur la presence ou non + // du 'groupe des pixels' dans l'entete? + // (voir pb du DICOMDIR) + + // Swap code (little, big, bad-big, bad-little endian): this code is not fixed + // during parsing.FIXME sw should be an enum e.g. + //enum EndianType { + //LittleEndian, + //BadLittleEndian, + //BigEndian, + //BadBigEndian}; int sw; - // Only the elements whose size are below this bound shall be loaded. + + // Only the elements whose size is below this bound will 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; @@ -251,22 +327,38 @@ private: guint32 ReadInt32(void); guint16 SwapShort(guint16); guint32 SwapLong(guint32); + guint32 FindLengthOB(void); void Initialise(void); void CheckSwap(void); + void InitVRDict(void); + void SwitchSwapToBigEndian(void); + void AddAndDefaultElements(void); + void SetMaxSizeLoadElementValue(long); + + gdcmDictEntry * GetDictEntryByKey(guint16, guint16); + gdcmDictEntry * GetDictEntryByName(string name); + + // ElValue related utilities + ElValue * ReadNextElement(void); + ElValue * NewElValueByKey(guint16 group, guint16 element); + ElValue * NewElValueByName(string name); void FindLength(ElValue *); void FindVR(ElValue *); void LoadElementValue(ElValue *); void LoadElementValueSafe(ElValue *); void SkipElementValue(ElValue *); - void InitVRDict(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); + + bool IsImplicitVRLittleEndianTransferSyntax(void); + bool IsExplicitVRLittleEndianTransferSyntax(void); + bool IsDeflatedExplicitVRLittleEndianTransferSyntax(void); + bool IsExplicitVRBigEndianTransferSyntax(void); + bool IsJPEGBaseLineProcess1TransferSyntax(void); + bool IsJPEGExtendedProcess2_4TransferSyntax(void); + bool IsJPEGExtendedProcess3_5TransferSyntax(void); + bool IsJPEGSpectralSelectionProcess6_8TransferSyntax(void); + protected: enum FileType { Unknown = 0, @@ -274,76 +366,99 @@ protected: ExplicitVR, ImplicitVR, ACR, - ACR_LIBIDO}; + ACR_LIBIDO}; // CLEANME FileType filetype; -///// QUESTION: Maybe Print is a better name than write !? int write(ostream&); -///// QUESTION: Maybe anonymize should be a friend function !?!? -///// See below for an example of how anonymize might be implemented. - int anonymize(ostream&); + int anonymize(ostream&); // FIXME : anonymize should be a friend ? public: void LoadElements(void); - virtual void ParseHeader(void); - gdcmHeader(const char* filename); + virtual void ParseHeader(bool exception_on_error = false) + throw(gdcmFormatError); + gdcmHeader(const char *filename, bool exception_on_error = false) + throw(gdcmFileError); virtual ~gdcmHeader(); + + size_t GetPixelOffset(void); + void GetPixels(size_t, void *); + int GetSwapCode(void) { return sw; } // TODO Swig int SetPubDict(string filename); - // When some proprietary shadow groups are disclosed, whe can set - // up an additional specific dictionary to access extra information. + // When some proprietary shadow groups are disclosed, we can set up + // an additional specific dictionary to access extra information. // TODO Swig int SetShaDict(string filename); - // Retrieve all potentially available tag [tag = (group, element)] names - // from the standard (or public) dictionary (hence static). Typical usage: - // enable the user of a GUI based interface to select his favorite fields - // for sorting or selection. - // TODO Swig string* GetPubTagNames(); // Get the element values themselves: string GetPubElValByName(string TagName); string GetPubElValByNumber(guint16 group, guint16 element); - // Get the element value representation: (VR) might be needed by caller - // to convert the string typed content to caller's native type (think - // of C/C++ vs Python). - // TODO Swig string GetPubElValRepByName(string TagName); - // TODO Swig string GetPubElValRepByNumber(guint16 group, guint16 element); + + // Getting the element value representation (VR) might be needed by caller + // to convert the string typed content to caller's native type + // (think of C/C++ vs Python). + + string GetPubElValRepByName(string TagName); + string GetPubElValRepByNumber(guint16 group, guint16 element); + TagElValueHT & GetPubElVal(void) { return PubElVals.GetTagHt(); }; void PrintPubElVal(ostream & os = cout); - void PrintPubDict(ostream &); + void PrintPubDict(ostream & os = cout); // Same thing with the shadow : // TODO Swig string* GetShaTagNames(); - // TODO Swig string GetShaElValByName(string TagName); - // TODO Swig string GetShaElValByNumber(guint16 group, guint16 element); - // TODO Swig string GetShaElValRepByName(string TagName); - // TODO Swig string GetShaElValRepByNumber(guint16 group, guint16 element); - - // Wrappers of the above (both public and shadow) to avoid bugging the - // caller with knowing if ElVal is from the public or shadow dictionary. - // TODO Swig string GetElValByName(string TagName); - // TODO Swig string GetElValByNumber(guint16 group, guint16 element); - // TODO Swig string GetElValRepByName(string TagName); - // TODO Swig string GetElValRepByNumber(guint16 group, guint16 element); - - // TODO Swig int SetPubElValByName(string content, string TagName); - // TODO Swig int SetPubElValByNumber(string content, guint16 group, guint16 element); - // TODO Swig int SetShaElValByName(string content, string ShadowTagName); - // TODO Swig int SetShaElValByNumber(string content, guint16 group, guint16 element); - - // TODO Swig int GetSwapCode(); + string GetShaElValByName(string TagName); + string GetShaElValByNumber(guint16 group, guint16 element); + string GetShaElValRepByName(string TagName); + string GetShaElValRepByNumber(guint16 group, guint16 element); + + // Wrappers of the above (public is privileged over shadow) to avoid + // bugging the caller with knowing if ElVal is from the public or shadow + // dictionary. + string GetElValByName(string TagName); + string GetElValByNumber(guint16 group, guint16 element); + string GetElValRepByName(string TagName); + string GetElValRepByNumber(guint16 group, guint16 element); + + int SetPubElValByName(string content, string TagName); + int SetPubElValByNumber(string content, guint16 group, guint16 element); + int SetShaElValByName(string content, string ShadowTagName); + int SetShaElValByNumber(string content, guint16 group, guint16 element); + + ElValSet GetPubElVals() { return(PubElVals); } }; +// +// ---------------------------------------------------- gdcmFile +// +// un fichier EST_UNE entete, ou A_UNE entete ? +// +// On dit 'EST_UNE' ... + + +//////////////////////////////////////////////////////////////////////////// // In addition to Dicom header exploration, this class is designed // for accessing the image/volume content. One can also use it to // write Dicom files. -////// QUESTION: this looks still like an open question wether the +////// QUESTION: this looks still like an open question whether the ////// relationship between a gdcmFile and gdcmHeader is of ////// type IS_A or HAS_A ! -class GDCM_EXPORT gdcmFile: gdcmHeader + +class GDCM_EXPORT gdcmFile: public gdcmHeader { private: + // QUESTION : + // Data pointe sur quoi? + // sur les Pixels lus? + // --> j'ajoute un champ public : Pixels + // (il faudra que l'utilisateur puisse modifier les pixels ?) + void* Data; - int Parsed; // weather allready parsed - string OrigFileName; // To avoid file overwrite + int Parsed; // weather allready parsed + string OrigFileName; // To avoid file overwrite public: + // je ne suis pas sur d'avoir compris *où* il serait légitime de ranger ca. + // on pourra tjs le deplacer, et mettre des accesseurs + void * Pixels; + size_t lgrTotale; + // Constructor dedicated to writing a new DICOMV3 part10 compliant // file (see SetFileName, SetDcmTag and Write) // TODO Swig gdcmFile(); @@ -353,52 +468,79 @@ public: // the DICOM header is post-poned to first header information access. // This avoid a double parsing of public part of the header when // one sets an a posteriori shadow dictionary (efficiency can be - // seen a a side effect). + // seen as a side effect). + gdcmFile(string & filename); + // For promotion (performs a deepcopy of pointed header object) // TODO Swig gdcmFile(gdcmHeader* header); // TODO Swig ~gdcmFile(); // On writing purposes. When instance was created through // gdcmFile(string filename) then the filename argument MUST be different - // from the constructor's one (no overwriting aloud). + // from the constructor's one (no overwriting allowed). // TODO Swig int SetFileName(string filename); // Allocates necessary memory, copies the data (image[s]/volume[s]) to // newly allocated zone and return a pointer to it: - // TODO Swig void * GetImageData(); + + void * GetImageData(); + // Returns size (in bytes) of required memory to contain data // represented in this file. - // TODO Swig size_t GetImageDataSize(); + + size_t GetImageDataSize(); + // Copies (at most MaxSize bytes) of data to caller's memory space. // Returns an error code on failure (if MaxSize is not big enough) - // TODO Swig int PutImageDataHere(void* destination, size_t MaxSize ); + + int GetImageDataIntoVector(void* destination, size_t MaxSize ); + + // Question : + // + // GetImageData et GetImageDataIntoVector + // Get et Put pour 2 fonctions qui font presque la meme chose :-( + // + // Allocates ExpectedSize bytes of memory at this->Data and copies the // pointed data to it. + + // Question : + // Pourquoi dupliquer les pixels, alors qu'on les a deja en mémoire, + // et que Data (dans le gdcmHeader) est un pointeur ? + // TODO Swig int SetImageData(void * Data, size_t ExpectedSize); + // Push to disk. + // A NE PAS OUBLIER : que fait-on en cas de Transfert Syntax (dans l'entete) + // incohérente avec l'ordre des octets en mémoire // TODO Swig int Write(); + + // Ecrit sur disque les pixels d'UNE image + // Aucun test n'est fait sur l'"Endiannerie" du processeur. + // Ca sera à l'utilisateur d'appeler son Reader correctement + + int WriteRawData (string nomFichier); + int WriteDcm (string nomFichier); }; +// +// ---------------------------------------------------- gdcmSerie +// +// une serie EST_UN fichier ???? +// +// + //class gdcmSerie : gdcmFile; -//class gdcmMultiFrame : gdcmFile; // -//Examples: -// * gdcmFile WriteDicom; -// WriteDicom.SetFileName("MyDicomFile.dcm"); -// string * AllTags = gdcmHeader.GetDcmTagNames(); -// WriteDicom.SetDcmTag(AllTags[5], "253"); -// WriteDicom.SetDcmTag("Patient Name", "bozo"); -// WriteDicom.SetDcmTag("Patient Name", "bozo"); -// WriteDicom.SetImageData(Image); -// WriteDicom.Write(); +// ---------------------------------------------------- gdcmMultiFrame // +// un fichierMultiFrame EST_UN fichier // -// Anonymize(ostream& output) { -// a = gdcmFile("toto1"); -// a.SetPubValueByName("Patient Name", ""); -// a.SetPubValueByName("Date", ""); -// a.SetPubValueByName("Study Date", ""); -// a.write(output); -// } +// + +//class gdcmMultiFrame : gdcmFile; + + +#endif // #ifndef GDCM_H