-// gdcmDocument.cxx
-//-----------------------------------------------------------------------------
+/*=========================================================================
+
+ Program: gdcm
+ Module: $RCSfile: gdcmDocument.cxx,v $
+ Language: C++
+ Date: $Date: 2004/06/21 12:38:29 $
+ Version: $Revision: 1.21 $
+
+ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
+ l'Image). All rights reserved. See Doc/License.txt or
+ http://www.creatis.insa-lyon.fr/Public/Gdcm/License.htm for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
#include "gdcmDocument.h"
#include "gdcmValEntry.h"
* with a FALSE value for the 'enable_sequence' param.
* ('public elements' may be embedded in 'shadow Sequences')
*/
-gdcmDocument::gdcmDocument(const char *inFilename,
- bool exception_on_error,
- bool enable_sequences,
- bool ignore_shadow)
+gdcmDocument::gdcmDocument(std::string const & inFilename,
+ bool exception_on_error,
+ bool enable_sequences,
+ bool ignore_shadow)
: gdcmElementSet(-1) {
enableSequences=enable_sequences;
- ignoreShadow =ignore_shadow;
+ IgnoreShadow =ignore_shadow;
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
- filename = inFilename;
+ Filename = inFilename;
Initialise();
if ( !OpenFile(exception_on_error))
return;
dbg.Verbose(0, "gdcmDocument::gdcmDocument: starting parsing of file: ",
- filename.c_str());
+ Filename.c_str());
rewind(fp);
fseek(fp,0L,SEEK_END);
SQDepthLevel=0;
long l=ParseDES( this, beg, lgt, false); // le Load sera fait a la volee
+ (void)l; //is l used anywhere ?
CloseFile();
// --------------------------------------------------------------
RecCode == "CANRME_AILIBOD1_1." ) // for brain-damaged softwares
// with "little-endian strings"
{
- filetype = gdcmACR_LIBIDO;
+ Filetype = gdcmACR_LIBIDO;
std::string rows = GetEntryByNumber(0x0028, 0x0010);
std::string columns = GetEntryByNumber(0x0028, 0x0011);
SetEntryByNumber(columns, 0x0028, 0x0010);
// Recursive clean up of sequences
for (TagDocEntryHT::iterator it = tagHT.begin(); it != tagHT.end(); ++it )
{
- gdcmDocEntry * entry = it->second;
- if ( gdcmSeqEntry* SeqEntry = dynamic_cast<gdcmSeqEntry*>(entry) )
- {
- delete SeqEntry;
- RemoveEntry(SeqEntry);
- }
- else
- {
- RemoveEntry(entry);
- }
+ delete (it->second);
}
tagHT.clear();
}
* false otherwise.
*/
bool gdcmDocument::IsReadable(void) {
- if(filetype==gdcmUnknown) {
+ if(Filetype==gdcmUnknown) {
dbg.Verbose(0, "gdcmDocument::IsReadable: wrong filetype");
return(false);
}
* @return the FileType code
*/
FileType gdcmDocument::GetFileType(void) {
- return(filetype);
+ return Filetype;
}
/**
FILE *gdcmDocument::OpenFile(bool exception_on_error)
throw(gdcmFileError)
{
- fp=fopen(filename.c_str(),"rb");
+ fp=fopen(Filename.c_str(),"rb");
if(!fp)
{
throw gdcmFileError("gdcmDocument::gdcmDocument(const char *, bool)");
else
{
- std::cout <<"gdcmDocument::OpenFile cannot open file: "
- << filename.c_str() << std::endl;
dbg.Verbose(0, "gdcmDocument::OpenFile cannot open file: ",
- filename.c_str());
- return (NULL);
+ Filename.c_str());
+ return NULL;
}
}
//ACR -- or DICOM with no Preamble --
if( zero == 0x0008 || zero == 0x0800 || zero == 0x0002 || zero == 0x0200)
- return(fp);
+ return fp;
//DICOM
fseek(fp, 126L, SEEK_CUR);
char dicm[4];
fread(dicm, (size_t)4, (size_t)1, fp);
if( memcmp(dicm, "DICM", 4) == 0 )
- return(fp);
+ return fp;
fclose(fp);
- dbg.Verbose(0, "gdcmDocument::OpenFile not DICOM/ACR", filename.c_str());
+ dbg.Verbose(0, "gdcmDocument::OpenFile not DICOM/ACR", Filename.c_str());
}
else {
- dbg.Verbose(0, "gdcmDocument::OpenFile cannot open file", filename.c_str());
+ dbg.Verbose(0, "gdcmDocument::OpenFile cannot open file", Filename.c_str());
}
- return(NULL);
+ return NULL;
}
/**
*/
WriteEntries(fp,type);
- return(true);
+ return true;
}
/**
gdcmValEntry * gdcmDocument::ReplaceOrCreateByNumber(
std::string Value,
guint16 Group,
- guint16 Elem ){
+ guint16 Elem )
+{
gdcmDocEntry* CurrentEntry;
gdcmValEntry* ValEntry;
{
dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: call to"
" NewDocEntryByNumber failed.");
- return (gdcmValEntry *)0;
+ return NULL;
}
ValEntry = new gdcmValEntry(CurrentEntry);
if ( !AddEntry(ValEntry))
{
dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: removal"
" of previous DocEntry failed.");
- return (gdcmValEntry *)0;
+ return NULL;
}
if ( !AddEntry(ValEntry))
{
dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: adding"
" promoted ValEntry failed.");
- return (gdcmValEntry *)0;
+ return NULL;
}
}
}
* \return pointer to the modified/created Header Entry (NULL when creation
* failed).
*/
-
-
gdcmBinEntry * gdcmDocument::ReplaceOrCreateByNumber(
void *voidArea,
int lgth,
guint16 Group,
- guint16 Elem ){
+ guint16 Elem)
+{
gdcmDocEntry* a;
gdcmBinEntry* b;
a = GetDocEntryByNumber( Group, Elem);
a =NewBinEntryByNumber(Group, Elem);
if (a == NULL)
return NULL;
+
b = new gdcmBinEntry(a);
AddEntry(b);
}
SetEntryByNumber(voidArea, lgth, Group, Elem);
b->SetVoidArea(voidArea);
- return (gdcmBinEntry*)b;
+
+ return b;
}
*/
int gdcmDocument::CheckIfEntryExistByNumber(guint16 group, guint16 element ) {
std::string key = gdcmDictEntry::TranslateToKey(group, element );
- return (tagHT.count(key));
+ return tagHT.count(key);
}
/**
if( dictEntry == NULL)
return GDCM_UNFOUND;
- return(GetEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement()));
+ return GetEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement());
}
/**
if( dictEntry == NULL)
return false;
- return(SetEntryByNumber(content,dictEntry->GetGroup(),
- dictEntry->GetElement()));
+ return SetEntryByNumber(content,dictEntry->GetGroup(),
+ dictEntry->GetElement());
}
/**
guint16 group,
guint16 element)
{
+ (void)lgth; //not used
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
gdcmDocEntry* Entry = GetDocEntryByNumber(Group, Elem);
if (!Entry)
{
- dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber",
- "failed to Locate gdcmDocEntry");
+ dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber: no entry present.");
return (size_t)0;
}
return Entry->GetOffset();
gdcmDocEntry* Entry = GetDocEntryByNumber(Group, Elem);
if (!Entry)
{
- dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber",
- "failed to Locate gdcmDocEntry");
+ dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber: no entry");
return (NULL);
}
return ((gdcmBinEntry *)Entry)->GetVoidArea();
return NULL;
size_t o =(size_t)Element->GetOffset();
fseek(fp, o, SEEK_SET);
- size_t l=Element->GetLength();
+ size_t l = Element->GetLength();
char* a = new char[l];
- if(!a)
+ if(!a) {
+ dbg.Verbose(0, "gdcmDocument::LoadEntryVoidArea cannot allocate a");
return NULL;
-
+ }
SetEntryVoidAreaByNumber(a, Group, Elem);
/// \todo check the result
size_t l2 = fread(a, 1, l ,fp);
* Only non even entries are analyzed
*/
void gdcmDocument::UpdateShaEntries(void) {
- gdcmDictEntry *entry;
+ //gdcmDictEntry *entry;
std::string vr;
/// \todo TODO : still any use to explore recursively the whole structure?
*/
// \todo TODO : to be re -written recursively !
-void gdcmDocument::WriteEntryValue(gdcmDocEntry *tag, FILE *_fp,FileType type)
+void gdcmDocument::WriteEntryValue(gdcmDocEntry *Entry, FILE *_fp,FileType type)
{
(void)type;
- guint16 group = tag->GetGroup();
- VRKey vr = tag->GetVR();
- guint32 lgr = tag->GetReadLength();
+ guint16 group = Entry->GetGroup();
+ VRKey vr = Entry->GetVR();
+ guint32 lgr = Entry->GetReadLength();
if (vr == "SQ")
// SeQuences have no value:
// Delimiters have no associated value:
return;
- //--------------------------------
- //
- // FIXME :right now, both value and voidArea belong to gdcmValue
- //
- // -------------------------------
-
-// if (gdcmBinEntry* BinEntry = dynamic_cast< gdcmBinEntry* >(tag) ) {
+// if (gdcmBinEntry* BinEntry = dynamic_cast< gdcmBinEntry* >(Entry) ) {
void *voidArea;
- gdcmBinEntry *BinEntry= (gdcmBinEntry *)tag;;
+ gdcmBinEntry *BinEntry= (gdcmBinEntry *)Entry;;
voidArea = BinEntry->GetVoidArea();
if (voidArea != NULL)
{ // there is a 'non string' LUT, overlay, etc
// we split the string and write each value as a short int
std::vector<std::string> tokens;
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
- Tokenize (((gdcmValEntry *)tag)->GetValue(), tokens, "\\");
+ Tokenize (((gdcmValEntry *)Entry)->GetValue(), tokens, "\\");
for (unsigned int i=0; i<tokens.size();i++)
{
guint16 val_uint16 = atoi(tokens[i].c_str());
// along the '\' and write each value as an int:
std::vector<std::string> tokens;
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
- Tokenize (((gdcmValEntry *)tag)->GetValue(), tokens, "\\");
+ Tokenize (((gdcmValEntry *)Entry)->GetValue(), tokens, "\\");
for (unsigned int i=0; i<tokens.size();i++)
{
guint32 val_uint32 = atoi(tokens[i].c_str());
tokens.clear();
return;
}
- fwrite (((gdcmValEntry *)tag)->GetValue().c_str(),
+ fwrite (((gdcmValEntry *)Entry)->GetValue().c_str(),
(size_t)lgr ,(size_t)1, _fp); // Elem value
}
if (gdcmBinEntry* BinEntry = dynamic_cast< gdcmBinEntry* >(tag) )
{
+ (void)BinEntry; //not used
/// \todo FIXME : when voidArea belong to gdcmBinEntry only, fix
/// voidArea length
//
WriteEntryValue(tag, _fp, type);
return true;
}
+
+ return false; //default behavior ?
}
/**
long gdcmDocument::ParseDES(gdcmDocEntrySet *set, long offset, long l_max, bool delim_mode) {
gdcmDocEntry *NewDocEntry = (gdcmDocEntry *)0;
- gdcmValEntry *vl;
+ gdcmValEntry *NewValEntry = (gdcmValEntry *)0;
gdcmBinEntry *bn;
gdcmSeqEntry *sq;
VRKey vr;
- long l;
+ unsigned long l;
int depth;
depth = set->GetDepthLevel();
break;
vr = NewDocEntry->GetVR();
- if (vr!="SQ") {
+ if (vr!="SQ")
+ {
if ( gdcmGlobal::GetVR()->IsVROfGdcmStringRepresentable(vr) )
{
/////// ValEntry
- vl= new gdcmValEntry(NewDocEntry->GetDictEntry());
- vl->Copy(NewDocEntry);
- vl->SetDepthLevel(depth);
- set->AddEntry(vl);
- LoadDocEntry(vl);
- if (/*!delim_mode && */vl->isItemDelimitor())
+ NewValEntry = new gdcmValEntry(NewDocEntry->GetDictEntry());
+ NewValEntry->Copy(NewDocEntry);
+ NewValEntry->SetDepthLevel(depth);
+ set->AddEntry(NewValEntry);
+ LoadDocEntry(NewValEntry);
+ if (/*!delim_mode && */NewValEntry->isItemDelimitor())
break;
if ( !delim_mode && ftell(fp)-offset >= l_max)
{
SkipToNextDocEntry(NewDocEntry);
l = NewDocEntry->GetFullLength();
}
- } else { // VR = "SQ"
+ }
+ else
+ { // VR = "SQ"
l=NewDocEntry->GetReadLength();
if (l != 0) // don't mess the delim_mode for zero-length sequence
long lgt = ParseSQ( sq,
NewDocEntry->GetOffset(),
l, delim_mode);
+ (void)lgt; //not used...
}
// FIXME : on en fait quoi, de lgt ?
set->AddEntry(sq);
break;
}
}
+ delete NewDocEntry;
}
- delete NewDocEntry;
return l; // ??
}
gdcmDocEntry *NewDocEntry = (gdcmDocEntry *)0;
gdcmSQItem *itemSQ;
bool dlm_mod;
- int lgr, l, lgth;
+ int lgr, lgth;
+ unsigned int l;
int depth = set->GetDepthLevel();
+ (void)depth; //not used
while (true) {
NewDocEntry = ReadNextDocEntry();
* the value specified with gdcmDocument::SetMaxSizeLoadEntry()
* @param Entry Header Entry (Dicom Element) to be dealt with
*/
-void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry) {
+void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
+{
size_t item_read;
guint16 group = Entry->GetGroup();
std::string vr= Entry->GetVR();
guint16 length16;
- if ( (filetype == gdcmExplicitVR) && (! Entry->IsImplicitVR()) )
+ if ( (Filetype == gdcmExplicitVR) && (! Entry->IsImplicitVR()) )
{
if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") )
{
*/
void gdcmDocument::FindDocEntryVR( gdcmDocEntry *Entry)
{
- if (filetype != gdcmExplicitVR)
+ if (Filetype != gdcmExplicitVR)
return;
char VR[3];
* (swaps it depending on processor endianity)
* @return read value
*/
-guint16 gdcmDocument::ReadInt16(void) {
+guint16 gdcmDocument::ReadInt16() {
guint16 g;
size_t item_read;
item_read = fread (&g, (size_t)2,(size_t)1, fp);
* (swaps it depending on processor endianity)
* @return read value
*/
-guint32 gdcmDocument::ReadInt32(void) {
+guint32 gdcmDocument::ReadInt32() {
guint32 g;
size_t item_read;
item_read = fread (&g, (size_t)4,(size_t)1, fp);
void gdcmDocument::Initialise(void)
{
RefPubDict = gdcmGlobal::GetDicts()->GetDefaultPubDict();
- RefShaDict = (gdcmDict*)0;
+ RefShaDict = NULL;
}
/**
// Use gdcmDocument::dicom_vr to test all the possibilities
// instead of just checking for UL, OB and UI !? group 0000
{
- filetype = gdcmExplicitVR;
+ Filetype = gdcmExplicitVR;
dbg.Verbose(1, "gdcmDocument::CheckSwap:",
"explicit Value Representation");
}
else
{
- filetype = gdcmImplicitVR;
+ Filetype = gdcmImplicitVR;
dbg.Verbose(1, "gdcmDocument::CheckSwap:",
"not an explicit Value Representation");
}
switch (s32) {
case 0x00040000 :
sw = 3412;
- filetype = gdcmACR;
+ Filetype = gdcmACR;
return true;
case 0x04000000 :
sw = 4321;
- filetype = gdcmACR;
+ Filetype = gdcmACR;
return true;
case 0x00000400 :
sw = 2143;
- filetype = gdcmACR;
+ Filetype = gdcmACR;
return true;
case 0x00000004 :
sw = 0;
- filetype = gdcmACR;
+ Filetype = gdcmACR;
return true;
default :
case 0x0004 :
case 0x0008 :
sw = 0;
- filetype = gdcmACR;
+ Filetype = gdcmACR;
return true;
case 0x0200 :
case 0x0400 :
case 0x0800 :
sw = 4321;
- filetype = gdcmACR;
+ Filetype = gdcmACR;
return true;
default :
dbg.Verbose(0, "gdcmDocument::CheckSwap:",
"ACR/NEMA unfound swap info (Really hopeless !)");
- filetype = gdcmUnknown;
+ Filetype = gdcmUnknown;
return false;
}
// header parsing has to be considered as finished.
return (gdcmDocEntry *)0;
-// Pb : how to propagate the element length (used in SkipDocEntry)
-// direct call to SkipBytes ?
-
-// if (ignoreShadow == 1 && g%2 ==1)
- // if user wants to skip shadow groups
- // and current element *is* a shadow element
- // we don't create anything
-// return (gdcmDocEntry *)1; // to tell caller it's NOT finished
-
NewEntry = NewDocEntryByNumber(g, n);
FindDocEntryVR(NewEntry);
FindDocEntryLength(NewEntry);
* @param Group group number of the underlying DictEntry
* @param Elem element number of the underlying DictEntry
*/
-gdcmDocEntry *gdcmDocument::NewDocEntryByNumber(guint16 Group, guint16 Elem)
+gdcmDocEntry* gdcmDocument::NewDocEntryByNumber(guint16 Group, guint16 Elem)
{
// Find out if the tag we encountered is in the dictionaries:
gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem);
{
dbg.Verbose(1, "gdcmDocument::NewDocEntryByNumber",
"failed to allocate gdcmDocEntry");
- return NULL;
+ return (gdcmDocEntry*)0;
}
return NewEntry;
}
// BTW, what is the purpous of those length anyhow !?
char * BasicOffsetTableItemValue = new char[ItemLength + 1];
fread(BasicOffsetTableItemValue, ItemLength, 1, fp);
- for (int i=0; i < ItemLength; i += 4){
+ for (unsigned int i=0; i < ItemLength; i += 4){
guint32 IndividualLength;
IndividualLength = str2num(&BasicOffsetTableItemValue[i],guint32);
std::ostringstream s;
// JPEG Image
//// We then skip (not reading them) all the fragments of images:
- while ( ItemLength = ReadItemTagLength() )
+ while ( (ItemLength = ReadItemTagLength()) )
{
SkipBytes(ItemLength);
}
long RleSegmentLength[15], fragmentLength;
// while 'Sequence Delimiter Item' (fffe,e0dd) not found
- while ( fragmentLength = ReadSequenceDelimiterTagLength() )
+ while ( (fragmentLength = ReadSequenceDelimiterTagLength()) )
{
// Parse fragments of the current Fragment (Frame)
//------------------ scanning (not reading) fragment pixels
SkipBytes(RleSegmentLength[nbRleSegments]);
}
}
- return;
}
/**
* @param document
* @return true if 'smaller'
*/
- bool gdcmDocument::operator<(gdcmDocument &document){
+bool gdcmDocument::operator<(gdcmDocument &document)
+{
std::string s1,s2;
// Patient Name
s1=this->GetEntryByNumber(0x0010,0x0010);
s2=document.GetEntryByNumber(0x0010,0x0010);
if(s1 < s2)
- return(true);
+ return true;
else if(s1 > s2)
- return(false);
+ return false;
else
{
// Patient ID
s1=this->GetEntryByNumber(0x0010,0x0020);
s2=document.GetEntryByNumber(0x0010,0x0020);
if (s1 < s2)
- return(true);
+ return true;
else if (s1 > s2)
- return(1);
+ return true;
else
{
// Study Instance UID
s1=this->GetEntryByNumber(0x0020,0x000d);
s2=document.GetEntryByNumber(0x0020,0x000d);
if (s1 < s2)
- return(true);
+ return true;
else if(s1 > s2)
- return(false);
+ return false;
else
{
// Serie Instance UID
s1=this->GetEntryByNumber(0x0020,0x000e);
s2=document.GetEntryByNumber(0x0020,0x000e);
if (s1 < s2)
- return(true);
+ return true;
else if(s1 > s2)
- return(false);
+ return false;
}
}
}
- return(false);
+
+ return false;
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff