Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2004/11/25 16:35:16 $
- Version: $Revision: 1.141 $
+ Date: $Date: 2004/11/30 16:59:32 $
+ Version: $Revision: 1.144 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
//-----------------------------------------------------------------------------
// Refer to Document::CheckSwap()
-const unsigned int Document::HEADER_LENGTH_TO_READ = 256;
+//const unsigned int Document::HEADER_LENGTH_TO_READ = 256;
// Refer to Document::SetMaxSizeLoadEntry()
const unsigned int Document::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff; // 4096
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
}
//DICOM
- Fp->seekg(126L, std::ios_base::cur);
+ Fp->seekg(126L, std::ios::cur);
char dicm[4];
Fp->read(dicm, (size_t)4);
if( memcmp(dicm, "DICM", 4) == 0 )
* @param element element number of the Entry to modify
* @return true on success, false otherwise.
*/
-bool Document::SetEntryLengthByNumber(uint32_t l,
+/*bool Document::SetEntryLengthByNumber(uint32_t l,
uint16_t group, uint16_t element)
{
/// \todo use map methods, instead of multimap JPR
( ((TagHT.equal_range(key)).first)->second )->SetLength(l);
return true ;
-}
+}*/
/**
* \brief Gets (from Header) the offset of a 'non string' element value
* @param elem element number of the Entry
* @return File Offset of the Element Value
*/
-size_t Document::GetEntryOffsetByNumber(uint16_t group, uint16_t elem)
+/*size_t Document::GetEntryOffsetByNumber(uint16_t group, uint16_t elem)
{
DocEntry* entry = GetDocEntryByNumber(group, elem);
if (!entry)
return 0;
}
return entry->GetOffset();
-}
+}*/
/**
* \brief Gets (from Header) a 'non string' element value
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];
- if(!a)
- {
- dbg.Verbose(0, "Document::LoadEntryBinArea cannot allocate a");
- return;
- }
-
- // Read the value
- Fp->read((char*)a, l);
- if( Fp->fail() || Fp->eof() )//Fp->gcount() == 1
- {
- delete[] a;
- return;
- }
-
- // Set the value to the DocEntry
- if( !SetEntryBinAreaByNumber( a, group, elem ) )
- {
- delete[] a;
- dbg.Verbose(0, "Document::LoadEntryBinArea setting failed.");
- }*/
}
/**
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];
* @param element Element number of the searched Dicom Element
* @return
*/
-bool Document::SetEntryBinAreaByNumber(uint8_t* area,
+/*bool Document::SetEntryBinAreaByNumber(uint8_t* area,
uint16_t group, uint16_t element)
{
DocEntry* currentEntry = GetDocEntryByNumber(group, element);
}
return false;
-}
+}*/
/**
* \brief Update the entries with the shadow dictionary.
{
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;
}
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);
}
/**
{
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);
}
/**
uint32_t s32;
uint16_t s16;
- char deb[256]; //HEADER_LENGTH_TO_READ];
+ char deb[256];
// First, compare HostByteOrder and NetworkByteOrder in order to
// determine if we shall need to swap bytes (i.e. the Endian type).
// The easiest case is the one of a DICOM header, since it possesses a
// file preamble where it suffice to look for the string "DICM".
- Fp->read(deb, HEADER_LENGTH_TO_READ);
+ Fp->read(deb, 256);
char *entCur = deb + 128;
if( memcmp(entCur, "DICM", (size_t)4) == 0 )
// 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.
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;
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff