Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2004/11/30 16:24:31 $
- Version: $Revision: 1.143 $
+ Date: $Date: 2005/01/05 16:53:23 $
+ Version: $Revision: 1.152 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmGlobal.h"
#include "gdcmUtil.h"
#include "gdcmDebug.h"
+#include "gdcmTS.h"
+#include "gdcmException.h"
+#include "gdcmDictSet.h"
+#include "gdcmRLEFramesInfo.h"
+#include "gdcmJPEGFragmentsInfo.h"
+#include "gdcmDocEntrySet.h"
+#include "gdcmSQItem.h"
#include <vector>
#include <iomanip>
dbg.Verbose(0, "Document::Document: starting parsing of file: ",
Filename.c_str());
- Fp->seekg( 0, std::ios_base::beg);
+ Fp->seekg( 0, std::ios::beg);
- Fp->seekg(0, std::ios_base::end);
+ Fp->seekg(0, std::ios::end);
long lgt = Fp->tellg();
- Fp->seekg( 0, std::ios_base::beg);
+ Fp->seekg( 0, std::ios::beg);
CheckSwap();
long beg = Fp->tellg();
lgt -= beg;
ParseDES( this, beg, lgt, false); // le Load sera fait a la volee
- Fp->seekg( 0, std::ios_base::beg);
+ Fp->seekg( 0, std::ios::beg);
// Load 'non string' values
SetEntryByNumber(rows , 0x0028, 0x0011);
}
// ----------------- End of ACR-LibIDO kludge ------------------
-
- PrintLevel = 1; // 'Medium' print level by default
}
/**
Initialise();
SwapCode = 0;
Filetype = ExplicitVR;
- PrintLevel = 1; // 'Medium' print level by default
}
/**
*/
void Document::PrintPubDict(std::ostream & os)
{
+ RefPubDict->SetPrintLevel(PrintLevel);
RefPubDict->Print(os);
}
*/
void Document::PrintShaDict(std::ostream & os)
{
+ RefShaDict->SetPrintLevel(PrintLevel);
RefShaDict->Print(os);
}
*/
std::ifstream* Document::OpenFile()
{
- if (Filename.length() == 0) return 0;
+ if (Filename.length() == 0)
+ {
+ return 0;
+ }
+
if(Fp)
{
dbg.Verbose( 0,
}
Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary);
-
- if(!Fp)
+ if( ! *Fp )
{
dbg.Verbose( 0,
"Document::OpenFile cannot open file: ",
Filename.c_str());
+ delete Fp;
+ Fp = 0;
return 0;
}
uint16_t zero;
- Fp->read((char*)&zero, (size_t)2 );
+ Fp->read((char*)&zero, (size_t)2);
+ if( Fp->eof() )
+ {
+ CloseFile();
+ return 0;
+ }
//ACR -- or DICOM with no Preamble; may start with a Shadow Group --
if(
}
//DICOM
- Fp->seekg(126L, std::ios_base::cur);
+ Fp->seekg(126L, std::ios::cur);
char dicm[4];
Fp->read(dicm, (size_t)4);
+ if( Fp->eof() )
+ {
+ CloseFile();
+ return 0;
+ }
if( memcmp(dicm, "DICM", 4) == 0 )
{
return Fp;
dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry"
" failed allthough this is a creation.");
}
+ delete currentEntry;
}
else
{
std::string Document::GetEntryByNumber(uint16_t group, uint16_t element)
{
TagKey key = DictEntry::TranslateToKey(group, element);
- /// \todo use map methods, instead of multimap JPR
if ( !TagHT.count(key))
{
return GDCM_UNFOUND;
bool Document::SetEntryByNumber(std::string const& content,
uint16_t group, uint16_t element)
{
- int c;
- int l;
-
ValEntry* valEntry = GetValEntryByNumber(group, element);
if (!valEntry )
{
return false;
}
// Non even content must be padded with a space (020H)...
- std::string finalContent = Util::DicomString( content.c_str() );
- assert( !(finalContent.size() % 2) );
- valEntry->SetValue(finalContent);
-
- // Integers have a special treatement for their length:
-
- l = finalContent.length();
- if ( l != 0) // To avoid to be cheated by 'zero length' integers
- {
- VRKey vr = valEntry->GetVR();
- if( vr == "US" || vr == "SS" )
- {
- // for multivaluated items
- c = Util::CountSubstring(content, "\\") + 1;
- l = c*2;
- }
- else if( vr == "UL" || vr == "SL" )
- {
- // for multivaluated items
- c = Util::CountSubstring(content, "\\") + 1;
- l = c*4;;
- }
- }
- valEntry->SetLength(l);
+ valEntry->SetValue(content);
return true;
}
return true;
}
-/**
- * \brief Accesses an existing DocEntry (i.e. a Dicom Element)
- * in the PubDocEntrySet of this instance
- * through it's (group, element) and modifies it's length with
- * the given value.
- * \warning Use with extreme caution.
- * @param l new length to substitute with
- * @param group group number of the Entry to modify
- * @param element element number of the Entry to modify
- * @return true on success, false otherwise.
- */
-/*bool Document::SetEntryLengthByNumber(uint32_t l,
- uint16_t group, uint16_t element)
-{
- /// \todo use map methods, instead of multimap JPR
- TagKey key = DictEntry::TranslateToKey(group, element);
- if ( !TagHT.count(key) )
- {
- return false;
- }
- if ( l % 2 )
- {
- l++; // length must be even
- }
- ( ((TagHT.equal_range(key)).first)->second )->SetLength(l);
-
- return true ;
-}*/
-
-/**
- * \brief Gets (from Header) the offset of a 'non string' element value
- * (LoadElementValues has already be executed)
- * @param group group number of the Entry
- * @param elem element number of the Entry
- * @return File Offset of the Element Value
- */
-/*size_t Document::GetEntryOffsetByNumber(uint16_t group, uint16_t elem)
-{
- DocEntry* entry = GetDocEntryByNumber(group, elem);
- if (!entry)
- {
- dbg.Verbose(1, "Document::GetDocEntryByNumber: no entry present.");
- return 0;
- }
- return entry->GetOffset();
-}*/
-
/**
* \brief Gets (from Header) a 'non string' element value
* (LoadElementValues has already be executed)
OpenFile();
size_t o =(size_t)element->GetOffset();
- Fp->seekg(o, std::ios_base::beg);
+ Fp->seekg(o, std::ios::beg);
size_t l = element->GetLength();
uint8_t* a = new uint8_t[l];
{
long PositionOnEntry = Fp->tellg();
LoadDocEntry(entry);
- Fp->seekg(PositionOnEntry, std::ios_base::beg);
+ Fp->seekg(PositionOnEntry, std::ios::beg);
}
}
if ( ts == RLELossless )
{
long PositionOnEntry = Fp->tellg();
- Fp->seekg( newDocEntry->GetOffset(), std::ios_base::beg );
+ Fp->seekg( newDocEntry->GetOffset(), std::ios::beg );
ComputeRLEInfo();
- Fp->seekg( PositionOnEntry, std::ios_base::beg );
+ Fp->seekg( PositionOnEntry, std::ios::beg );
}
else if ( IsJPEG() )
{
long PositionOnEntry = Fp->tellg();
- Fp->seekg( newDocEntry->GetOffset(), std::ios_base::beg );
+ Fp->seekg( newDocEntry->GetOffset(), std::ios::beg );
ComputeJPEGFragmentInfo();
- Fp->seekg( PositionOnEntry, std::ios_base::beg );
+ Fp->seekg( PositionOnEntry, std::ios::beg );
}
}
std::string vr = entry->GetVR();
uint32_t length = entry->GetLength();
- Fp->seekg((long)entry->GetOffset(), std::ios_base::beg);
+ Fp->seekg((long)entry->GetOffset(), std::ios::beg);
// A SeQuence "contains" a set of Elements.
// (fffe e000) tells us an Element is beginning
// to be sure we are at the end of the value ...
Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(),
- std::ios_base::beg);
+ std::ios::beg);
return;
}
// The following reserved two bytes (see PS 3.5-2003, section
// "7.1.2 Data element structure with explicit vr", p 27) must be
// skipped before proceeding on reading the length on 4 bytes.
- Fp->seekg( 2L, std::ios_base::cur);
+ Fp->seekg( 2L, std::ios::cur);
uint32_t length32 = ReadInt32();
if ( (vr == "OB" || vr == "OW") && length32 == 0xffffffff )
// until the end of the file. Hence we artificially fix the
// the length and proceed.
long currentPosition = Fp->tellg();
- Fp->seekg(0L,std::ios_base::end);
+ Fp->seekg(0L,std::ios::end);
long lengthUntilEOF = (long)(Fp->tellg())-currentPosition;
- Fp->seekg(currentPosition, std::ios_base::beg);
+ Fp->seekg(currentPosition, std::ios::beg);
entry->SetLength(lengthUntilEOF);
return;
}
// within an explicit VR file. Hence we make sure the present tag
// is in explicit VR and try to fix things if it happens not to be
// the case.
-
Fp->read (vr, (size_t)2);
vr[2] = 0;
if( !CheckDocEntryVR(entry, vr) )
{
- Fp->seekg(positionOnEntry, std::ios_base::beg);
+ Fp->seekg(positionOnEntry, std::ios::beg);
// When this element is known in the dictionary we shall use, e.g. for
// the semantics (see the usage of IsAnInteger), the VR proposed by the
// dictionary entry. Still we have to flag the element as implicit since
*/
void Document::SkipToNextDocEntry(DocEntry *entry)
{
- Fp->seekg((long)(entry->GetOffset()), std::ios_base::beg);
- Fp->seekg( (long)(entry->GetReadLength()), std::ios_base::cur);
+ Fp->seekg((long)(entry->GetOffset()), std::ios::beg);
+ Fp->seekg( (long)(entry->GetReadLength()), std::ios::cur);
}
/**
if ( vr == "UL" || vr == "US" || vr == "SL" || vr == "SS" )
{
return true;
- }
-
+ }
return false;
}
{
dbg.Verbose(1, "Document::FindDocEntryLengthOB: neither an Item "
"tag nor a Sequence delimiter tag.");
- Fp->seekg(positionOnEntry, std::ios_base::beg);
+ Fp->seekg(positionOnEntry, std::ios::beg);
throw FormatUnexpected("Document::FindDocEntryLengthOB()",
"Neither an Item tag nor a Sequence "
"delimiter tag.");
break;
}
}
- Fp->seekg( positionOnEntry, std::ios_base::beg);
+ Fp->seekg( positionOnEntry, std::ios::beg);
return totalLength;
}
void Document::SkipBytes(uint32_t nBytes)
{
//FIXME don't dump the returned value
- Fp->seekg((long)nBytes, std::ios_base::cur);
+ Fp->seekg((long)nBytes, std::ios::cur);
}
/**
RefShaDict = NULL;
RLEInfo = new RLEFramesInfo;
JPEGInfo = new JPEGFragmentsInfo;
+ Filetype = Unknown;
}
/**
// Position the file position indicator at first tag (i.e.
// after the file preamble and the "DICM" string).
- Fp->seekg(0, std::ios_base::beg);
- Fp->seekg ( 132L, std::ios_base::beg);
+ Fp->seekg(0, std::ios::beg);
+ Fp->seekg ( 132L, std::ios::beg);
return true;
} // End of DicomV3
// preamble. We can reset the file position indicator to where the data
// is (i.e. the beginning of the file).
dbg.Verbose(1, "Document::CheckSwap:", "not a DICOM Version3 file");
- Fp->seekg(0, std::ios_base::beg);
+ Fp->seekg(0, std::ios::beg);
// Our next best chance would be to be considering a 'clean' ACR/NEMA file.
// By clean we mean that the length of the first tag is written down.
reversedEndian--;
SwitchSwapToBigEndian();
}
-
}
/**
s << " at address: " << (unsigned)currentPosition << std::endl;
dbg.Verbose(0, "Document::ReadItemTagLength: wrong Item Tag found:");
dbg.Verbose(0, s.str().c_str());
- Fp->seekg(positionOnEntry, std::ios_base::beg);
+ Fp->seekg(positionOnEntry, std::ios::beg);
return false;
}
return false;
}
+
+/**
+ * \brief Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
+ * @param filetype Type of the File to be written
+ */
+int Document::ComputeGroup0002Length( FileType filetype )
+{
+ uint16_t gr, el;
+ std::string vr;
+
+ int groupLength = 0;
+ bool found0002 = false;
+
+ // for each zero-level Tag in the DCM Header
+ DocEntry *entry;
+
+ Initialize();
+
+ for (;;)
+ {
+ entry = GetNextEntry();
+
+ if ( entry == 0 )
+ break;
+
+ gr = entry->GetGroup();
+
+ if (gr == 0x0002)
+ found0002 = true;
+ else
+ if (found0002 )
+ break;
+ else
+ continue;
+
+ el = entry->GetElement();
+ vr = entry->GetVR();
+
+ if (filetype == ExplicitVR)
+ {
+ if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
+ {
+ groupLength += 4; // explicit VR AND OB, OW, SQ : 4 more bytes
+ }
+ }
+ groupLength += 2 + 2 + 4 + entry->GetLength();
+ }
+ return groupLength;
+}
+
} // end namespace gdcm
//-----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff