Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2004/11/16 02:54:35 $
- Version: $Revision: 1.124 $
+ Date: $Date: 2004/11/24 11:17:47 $
+ Version: $Revision: 1.136 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
static const char *TransferSyntaxStrings[] = {
// Implicit VR Little Endian
"1.2.840.10008.1.2",
+ // Implicit VR Little Endian DLX G.E?
+ "1.2.840.113619.5.2",
// Explicit VR Little Endian
"1.2.840.10008.1.2.1",
// Deflated Explicit VR Little Endian
RefPubDict = NULL;
RefShaDict = NULL;
- // Recursive clean up of sequences
- for (TagDocEntryHT::const_iterator it = TagHT.begin();
- it != TagHT.end(); ++it )
- {
- //delete it->second; //temp remove
- }
- TagHT.clear();
delete RLEInfo;
delete JPEGInfo;
}
return true;
}
-
/**
- * \brief Internal function that checks whether the Transfer Syntax given
- * as argument is the one present in the current document.
- * @param syntaxToCheck The transfert syntax we need to check against.
- * @return True when SyntaxToCheck corresponds to the Transfer Syntax of
- * the current document. False either when the document contains
- * no Transfer Syntax, or when the Tranfer Syntaxes doesn't match.
+ * \brief Accessor to the Transfer Syntax (when present) of the
+ * current document (it internally handles reading the
+ * value from disk when only parsing occured).
+ * @return The encountered Transfer Syntax of the current document.
*/
TransferSyntaxType Document::GetTransferSyntax()
{
// for brain damaged headers
return UnknownTS;
}
- while ( !isdigit(transfer[transfer.length()-1]) )
+ while ( !isdigit((unsigned char)transfer[transfer.length()-1]) )
{
transfer.erase(transfer.length()-1, 1);
}
uint16_t zero;
Fp->read((char*)&zero, (size_t)2 );
- //ACR -- or DICOM with no Preamble --
- if( zero == 0x0008 || zero == 0x0800 || zero == 0x0002 || zero == 0x0200 )
+ //ACR -- or DICOM with no Preamble; may start with a Shadow Group --
+ if(
+ zero == 0x0001 || zero == 0x0100 || zero == 0x0002 || zero == 0x0200 ||
+ zero == 0x0003 || zero == 0x0300 || zero == 0x0004 || zero == 0x0400 ||
+ zero == 0x0005 || zero == 0x0500 || zero == 0x0006 || zero == 0x0600 ||
+ zero == 0x0007 || zero == 0x0700 || zero == 0x0008 || zero == 0x0800 )
{
return Fp;
}
* @param value (string) Value to be set
* @param group Group number of the Entry
* @param elem Element number of the Entry
- * @param VR V(alue) R(epresentation) of the Entry -if private Entry-
+ * @param vr V(alue) R(epresentation) of the Entry -if private Entry-
* \return pointer to the modified/created Header Entry (NULL when creation
* failed).
*/
" NewDocEntryByNumber failed.");
return NULL;
}
+
valEntry = new ValEntry(currentEntry);
+ delete currentEntry;
+
if ( !AddEntry(valEntry))
{
delete valEntry;
dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry"
" failed allthough this is a creation.");
+ return NULL;
}
- // This is the reason why NewDocEntryByNumber are a real
- // bad habit !!! FIXME
- delete currentEntry;
}
else
{
/*
* \brief Modifies the value of a given Header Entry (Dicom Element)
* when it exists. Create it with the given value when unexistant.
+ * A copy of the binArea is made to be kept in the Document.
* @param binArea (binary) value to be set
* @param Group Group number of the Entry
* @param Elem Element number of the Entry
}
}
- SetEntryByNumber(binArea, lgth, group, elem);
+ uint8_t *tmpArea;
+ if (lgth>0 && binArea)
+ {
+ tmpArea = new uint8_t[lgth];
+ memcpy(tmpArea,binArea,lgth);
+ }
+ else
+ {
+ tmpArea = 0;
+ }
+ if (!SetEntryByNumber(tmpArea, lgth, group, elem))
+ {
+ if (tmpArea)
+ {
+ delete[] tmpArea;
+ }
+ }
return binEntry;
}
* @param tagName name of the searched Dicom Element.
* @return true when found
*/
-bool Document::SetEntryByName(std::string const & content,
- TagName const & tagName)
+bool Document::SetEntryByName( std::string const & content,
+ TagName const & tagName)
{
DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( !dictEntry )
//content = content + '\0'; // fing a trick to enlarge a binary field?
}
*/
- BinEntry* a = (BinEntry *)TagHT[key];
- a->SetBinArea(content);
- a->SetLength(lgth);
- a->SetValue(GDCM_BINLOADED);
+ BinEntry* entry = (BinEntry *)TagHT[key];
+ entry->SetBinArea(content);
+ entry->SetLength(lgth);
+ entry->SetValue(GDCM_BINLOADED);
return true;
}
if ( !docElement )
return;
- size_t o =(size_t)docElement->GetOffset();
+ BinEntry *binElement = dynamic_cast<BinEntry *>(docElement);
+ if( !binElement )
+ return;
+
+ LoadEntryBinArea(binElement);
+/* size_t o =(size_t)docElement->GetOffset();
Fp->seekg( o, std::ios_base::beg);
size_t l = docElement->GetLength();
uint8_t* a = new uint8_t[l];
{
delete[] a;
dbg.Verbose(0, "Document::LoadEntryBinArea setting failed.");
- }
+ }*/
}
+
/**
* \brief Loads (from disk) the element content
* when a string is not suitable
*/
void Document::LoadEntryBinArea(BinEntry* element)
{
+ bool openFile = !Fp;
+ if(openFile)
+ OpenFile();
+
size_t o =(size_t)element->GetOffset();
Fp->seekg(o, std::ios_base::beg);
+
size_t l = element->GetLength();
uint8_t* a = new uint8_t[l];
if( !a )
return;
}
- element->SetBinArea((uint8_t*)a);
+ element->SetBinArea(a);
+
+ if(openFile)
+ CloseFile();
}
/**
long l_max, bool delim_mode)
{
DocEntry *newDocEntry = 0;
-
+
while (true)
- {
- if ( !delim_mode && (Fp->tellg()-offset) >= l_max)
+ {
+ if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
break;
}
+ newValEntry->GetKey() );
}
+ LoadDocEntry( newValEntry );
+ bool delimitor=newValEntry->IsItemDelimitor();
if( !set->AddEntry( newValEntry ) )
{
// If here expect big troubles
delete newValEntry; //otherwise mem leak
}
- LoadDocEntry( newValEntry );
- if (newValEntry->IsItemDelimitor())
+
+ if (delimitor)
{
+ delete newDocEntry;
break;
}
- if ( !delim_mode && (Fp->tellg()-offset) >= l_max)
+ if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
+ delete newDocEntry;
break;
}
}
}
//////////////////// BinEntry or UNKOWN VR:
- BinEntry* newBinEntry =
+/* BinEntry* newBinEntry =
new BinEntry( newDocEntry->GetDictEntry() ); //LEAK
- newBinEntry->Copy( newDocEntry );
+ newBinEntry->Copy( newDocEntry );*/
+ BinEntry* newBinEntry = new BinEntry( newDocEntry ); //LEAK
// When "this" is a Document the Key is simply of the
// form ( group, elem )...
+ newBinEntry->GetKey() );
}
+ LoadDocEntry( newBinEntry );
if( !set->AddEntry( newBinEntry ) )
{
//Expect big troubles if here
delete newBinEntry;
}
- LoadDocEntry( newBinEntry );
}
if ( ( newDocEntry->GetGroup() == 0x7fe0 )
// Just to make sure we are at the beginning of next entry.
SkipToNextDocEntry(newDocEntry);
+ //delete newDocEntry;
}
else
{
l, delim_mode);
}
set->AddEntry( newSeqEntry );
- if ( !delim_mode && (Fp->tellg()-offset) >= l_max)
+ if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
+ delete newDocEntry;
break;
}
}
{
if ( newDocEntry->IsSequenceDelimitor() )
{
- seqEntry->SetSequenceDelimitationItem( newDocEntry );
+ seqEntry->SetSequenceDelimitationItem( newDocEntry );
break;
}
}
- if ( !delim_mode && (Fp->tellg()-offset) >= l_max)
+ if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
- break;
+ delete newDocEntry;
+ break;
}
SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() );
}
ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod);
+ delete newDocEntry;
seqEntry->AddEntry( itemSQ, SQItemNumber );
SQItemNumber++;
- if ( !delim_mode && ( Fp->tellg() - offset ) >= l_max )
+ if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max )
{
break;
}
// the length and proceed.
long currentPosition = Fp->tellg();
Fp->seekg(0L,std::ios_base::end);
- long lengthUntilEOF = Fp->tellg() - currentPosition;
+ long lengthUntilEOF = (long)(Fp->tellg())-currentPosition;
Fp->seekg(currentPosition, std::ios_base::beg);
entry->SetLength(lengthUntilEOF);
return;
// expected VR read happens to be non-ascii characters we consider
// we hit falsely explicit VR tag.
- if ( !isalpha(vr[0]) && !isalpha(vr[1]) )
+ if ( !isalpha((unsigned char)vr[0]) && !isalpha((unsigned char)vr[1]) )
{
realExplicit = false;
}
// So, let's check if this file wouldn't happen to be 'dirty' ACR/NEMA,
// i.e. the 'group length' element is not present :
- // check the supposed to be 'group number'
- // 0x0002 or 0x0004 or 0x0008
+ // check the supposed-to-be 'group number'
+ // in ( 0x0001 .. 0x0008 )
// to determine ' SwapCode' value .
// Only 0 or 4321 will be possible
// (no oportunity to check for the formerly well known
// ACR-NEMA 'Bad Big Endian' or 'Bad Little Endian'
- // if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -4, 8-)
+ // if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -3, 4, ..., 8-)
// the file IS NOT ACR-NEMA nor DICOM V3
// Find a trick to tell it the caller...
switch ( s16 )
{
+ case 0x0001 :
case 0x0002 :
+ case 0x0003 :
case 0x0004 :
- case 0x0008 :
+ case 0x0005 :
+ case 0x0006 :
+ case 0x0007 :
+ case 0x0008 :
SwapCode = 0;
Filetype = ACR;
return true;
+ case 0x0100 :
case 0x0200 :
+ case 0x0300 :
case 0x0400 :
- case 0x0800 :
+ case 0x0500 :
+ case 0x0600 :
+ case 0x0700 :
+ case 0x0800 :
SwapCode = 4321;
Filetype = ACR;
return true;
default :
dbg.Verbose(0, "Document::CheckSwap:",
- "ACR/NEMA unfound swap info (Really hopeless !)");
- Filetype = Unknown;
+ "ACR/NEMA unfound swap info (Really hopeless !)");
+ Filetype = Unknown;
return false;
}
// Then the only info we have is the net2host one.
}
}
+
+
/**
* \brief Restore the unproperly loaded values i.e. the group, the element
* and the dictionary entry depending on them.
dbg.Verbose(0, "Document::ComputeRLEInfo: too many segments.");
}
- uint32_t rleSegmentOffsetTable[15];
+ uint32_t rleSegmentOffsetTable[16];
for( int k = 1; k <= 15; k++ )
{
rleSegmentOffsetTable[k] = ReadInt32();
* Document.
*
* The structure used by a Document (through \ref ElementSet),
- * in order to old the parsed entries of a Dicom header, is a recursive
+ * in order to hold the parsed entries of a Dicom header, is a recursive
* one. This is due to the fact that the sequences (when present)
* can be nested. Additionaly, the sequence items (represented in
* gdcm as \ref SQItem) add an extra complexity to the data
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff