Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/04/22 12:59:58 $
- Version: $Revision: 1.235 $
+ Date: $Date: 2005/06/22 08:01:41 $
+ Version: $Revision: 1.249 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
namespace gdcm
{
//-----------------------------------------------------------------------------
-// Refer to Document::CheckSwap()
-//const unsigned int Document::HEADER_LENGTH_TO_READ = 256;
// Refer to Document::SetMaxSizeLoadEntry()
const unsigned int Document::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff; // 4096
Initialize();
SwapCode = 1234;
Filetype = ExplicitVR;
+ // Load will set it to true if sucessfull
Group0002Parsed = false;
+ IsDocumentAlreadyLoaded = false;
LoadMode = 0x00000000; // default : load everything, later
}
/**
* \brief Constructor (not to break the API)
- * @param filename 'Document' (File or DicomDir) to be opened for parsing
+ * @param fileName 'Document' (File or DicomDir) to be open for parsing
*/
-Document::Document( std::string const &filename )
+Document::Document( std::string const &fileName )
:ElementSet(-1)
{
Fp = 0;
Group0002Parsed = false;
LoadMode = 0x00000000; // Load everything
- Load(filename);
+ // Load will set it to true if sucessfull
+ IsDocumentAlreadyLoaded = false;
+
+ Load(fileName);
}
/**
* \brief Canonical destructor.
/**
* \brief Loader
- * @param filename 'Document' (File or DicomDir) to be opened for parsing
+ * @param fileName 'Document' (File or DicomDir) to be open for parsing
+ * @return false if file cannot be open or no swap info was found,
+ * or no tag was found.
*/
-void Document::Load( std::string const &filename )
+bool Document::Load( std::string const &fileName )
{
- Filename = filename;
-
// We should clean out anything that already exists.
+ // Check IsDocumentAlreadyLoaded to be sure.
+ if( IsDocumentAlreadyLoaded )
+ {
+ gdcmWarningMacro( "A file was already parsed inside this "
+ << "gdcm::Document (previous name was: "
+ << Filename.c_str() << ". New name is :"
+ << fileName );
+ // todo : clean out the 'Document'
+ // Should we call ClearEntry() on the parent object ?!?
+ }
+
+ Filename = fileName;
Fp = 0;
if ( !OpenFile() )
{
- return;
+ // warning already performed in OpenFile()
+ //gdcmWarningMacro( "Unable to open as an ACR/DICOM file: "
+ // << Filename.c_str() );
+ Filetype = Unknown;
+ return false;
}
Group0002Parsed = false;
Fp->seekg(0, std::ios::beg);
- CheckSwap();
+ // CheckSwap returns a boolean
+ // (false if no swap info of any kind was found)
+ if (! CheckSwap() )
+ {
+ gdcmWarningMacro( "Neither a DICOM V3 nor an ACR-NEMA file: "
+ << Filename.c_str());
+ CloseFile();
+ return false;
+ }
+
long beg = Fp->tellg(); // just after DICOM preamble (if any)
lgt -= beg; // remaining length to parse
ParseDES( this, beg, lgt, false); // Loading is done during parsing
+ if ( IsEmpty() )
+ {
+ gdcmWarningMacro( "No tag in internal hash table for: "
+ << Filename.c_str());
+ CloseFile();
+ return false;
+ }
+ IsDocumentAlreadyLoaded = true;
+
Fp->seekg( 0, std::ios::beg);
// Load 'non string' values
std::string PhotometricInterpretation = GetEntryValue(0x0028,0x0004);
if( PhotometricInterpretation == "PALETTE COLOR " )
{
- LoadEntryBinArea(0x0028,0x1200); // gray LUT
- /// FIXME FIXME FIXME
+ // FIXME
+ // Probabely this line should be outside the 'if'
+ // Try to find an image sample holding a 'gray LUT'
+ LoadEntryBinArea(0x0028,0x1200); // gray LUT
+
+ /// FIXME
/// The tags refered by the three following lines used to be CORRECTLY
/// defined as having an US Value Representation in the public
/// dictionary. BUT the semantics implied by the three following
LoadEntryBinArea(0x0028,0x1222);
// Segmented Blue Palette Color LUT Data
LoadEntryBinArea(0x0028,0x1223);
- }
+ }
+
//FIXME later : how to use it?
- LoadEntryBinArea(0x0028,0x3006); //LUT Data (CTX dependent)
+ SeqEntry *modLutSeq = GetSeqEntry(0x0028,0x3000);
+ if ( modLutSeq !=0 )
+ {
+ SQItem *sqi= modLutSeq->GetFirstSQItem();
+ if ( sqi != 0 )
+ {
+ BinEntry *b = sqi->GetBinEntry(0x0028,0x3006);
+ if ( b != 0 )
+ {
+ if ( b->GetLength() != 0 )
+ {
+ LoadEntryBinArea(b); //LUT Data (CTX dependent)
+ }
+ }
+ }
+ }
CloseFile();
SetValEntry(rows , 0x0028, 0x0011);
}
// --- End of ACR-LibIDO kludge ---
+
+ return true;
}
/**
}
/**
- * \brief This predicate, based on hopefully reasonable heuristics,
- * decides whether or not the current Document was properly parsed
- * and contains the mandatory information for being considered as
- * a well formed and usable Dicom/Acr File.
- * @return true when Document is the one of a reasonable Dicom/Acr file,
- * false otherwise.
+ * \brief This predicate tells us whether or not the current Document
+ * was properly parsed and contains at least *one* Dicom Element
+ * (and nothing more, sorry).
+ * @return false when we're 150 % sure it's NOT a Dicom/Acr file,
+ * true otherwise.
*/
bool Document::IsReadable()
{
bool Document::IsDicomV3()
{
// Checking if Transfer Syntax exists is enough
- // Anyway, it's to late check if the 'Preamble' was found ...
+ // Anyway, it's too late check if the 'Preamble' was found ...
// And ... would it be a rich idea to check ?
// (some 'no Preamble' DICOM images exist !)
return GetDocEntry(0x0002, 0x0010) != NULL;
Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary);
if( ! *Fp )
{
- gdcmDebugMacro( "Cannot open file: " << Filename.c_str());
+ // Don't user gdcmErrorMacro :
+ // a spurious message will appear when you use, for instance
+ // gdcm::FileHelper *fh = new gdcm::FileHelper( outputFileName );
+ // to create outputFileName.
+ gdcmWarningMacro( "Cannot open file: " << Filename.c_str());
delete Fp;
Fp = 0;
return 0;
+ //exit(1); // No function is allowed to leave the application instead
+ // of warning the caller
}
uint16_t zero = 0;
return 0;
}
- //ACR -- or DICOM with no Preamble; may start with a Shadow Group --
+ //-- 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 )
{
- std::string msg
- = Util::Format("ACR/DICOM with no preamble: (%04x)\n", zero);
+ std::string msg = Util::Format(
+ "ACR/DICOM starting at the begining of the file:(%04x)\n", zero);
gdcmWarningMacro( msg.c_str() );
return Fp;
}
- //DICOM
+ //-- DICOM --
Fp->seekg(126L, std::ios::cur);
char dicm[4] = {' ',' ',' ',' '};
Fp->read(dicm, (size_t)4);
HasDCMPreamble = true;
return Fp;
}
-
+
+ // -- Neither ACR/No Preamble Dicom nor DICOMV3 file
CloseFile();
- gdcmWarningMacro( "Not DICOM/ACR (missing preamble)" << Filename.c_str());
-
+ gdcmWarningMacro( "Neither ACR/No Preamble Dicom nor DICOMV3 file: "
+ << Filename.c_str());
return 0;
}
if( filetype == ExplicitVR )
{
- if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
+ if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || (vr == "UT") )
{
- // explicit VR AND OB, OW, SQ : 4 more bytes
+ // explicit VR AND OB, OW, SQ, UT : 4 more bytes
groupLength += 4;
}
}
if ( strLgrGroup != GDCM_UNFOUND)
{
lgrGroup = atoi(strLgrGroup.c_str());
- Fp->seekg(lgrGroup , std::ios::cur);
+ Fp->seekg(lgrGroup, std::ios::cur);
used = false;
continue;
}
{
if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) )
{
- //s << "gdcm::NotLoaded (BinEntry)";
s << GDCM_NOTLOADED;
s << " Ad.:" << (long)entry->GetOffset();
s << " x(" << std::hex << entry->GetOffset() << ")";
s << " x(" << std::hex << entry->GetLength() << ")";
binEntryPtr->SetValue(s.str());
}
- // Be carefull : a BinEntry IS_A ValEntry ...
else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) )
{
- // s << "gdcm::NotLoaded. (ValEntry)";
s << GDCM_NOTLOADED;
s << " Address:" << (long)entry->GetOffset();
s << " Length:" << entry->GetLength();
uint32_t NewInt;
int nbInt;
// When short integer(s) are expected, read and convert the following
- // n *two characters properly i.e. consider them as short integers as
+ // (n * 2) characters properly i.e. consider them as short integers as
// opposed to strings.
// Elements with Value Multiplicity > 1
// contain a set of integers (not a single one)
{
newValue = Util::DicomString(str, length+1);
gdcmWarningMacro("Warning: bad length: " << length <<
- ",For string :" << newValue.c_str());
+ " For string :" << newValue.c_str());
// Since we change the length of string update it length
//entry->SetReadLength(length+1);
}
{
if ( Fp->fail() || Fp->eof())
{
- gdcmWarningMacro("Unread element value");
+ if ( Fp->fail() )
+ gdcmWarningMacro("--> fail");
+
+ gdcmWarningMacro("Unread element value " << valEntry->GetKey()
+ << " lgt : " << valEntry->GetReadLength()
+ << " at " << std::hex << valEntry->GetOffset());
valEntry->SetValue(GDCM_UNREAD);
return;
}
}
else
{
- gdcmErrorMacro( "Should have a ValEntry, here !");
+ gdcmWarningMacro("Should have a ValEntry, here ! " << valEntry->GetKey()
+ << " lgt : " << valEntry->GetReadLength()
+ << " at " << std::hex << valEntry->GetOffset());
}
}
if ( Filetype == ExplicitVR && !entry->IsImplicitVR() )
{
- if ( vr == "OB" || vr == "OW" || vr == "SQ" || vr == "UN" )
+ if ( vr == "OB" || vr == "OW" || vr == "SQ" || vr == "UT" || vr == "UN" )
{
// The following reserved two bytes (see PS 3.5-2003, section
// "7.1.2 Data element structure with explicit vr", p 27) must be
// Allthough not recent many such GE corrupted images are still present
// on Creatis hard disks. Hence this fix shall remain when such images
// are no longer in use (we are talking a few years, here)...
- // Note: XMedCom probably uses such a trick since it is able to read
+ // Note: XMedCon probably uses such a trick since it is able to read
// those pesky GE images ...
if ( foundLength == 13)
{
// Position the file position indicator at first tag
// (i.e. after the file preamble and the "DICM" string).
- Fp->seekg(0, std::ios::beg);
+
+ Fp->seekg(0, std::ios::beg); // FIXME : Is it usefull?
+
Fp->seekg ( 132L, std::ios::beg);
return true;
- } // End of DicomV3
+ } // ------------------------------- End of DicomV3 ----------------
// Alas, this is not a DicomV3 file and whatever happens there is no file
// preamble. We can reset the file position indicator to where the data
// is (i.e. the beginning of the file).
- gdcmWarningMacro( "Not a DICOM Version3 file");
+
+ gdcmWarningMacro( "Not a Kosher DICOM Version3 file (no preamble)");
+
Fp->seekg(0, std::ios::beg);
+ // Let's check 'No Preamble Dicom File' :
+ // Should start with group 0x0002
+ // and be Explicit Value Representation
+
+ s16 = *((uint16_t *)(deb));
+ SwapCode = 0;
+ switch ( s16 )
+ {
+ case 0x0002 :
+ SwapCode = 1234;
+ entCur = deb + 4;
+ break;
+ case 0x0200 :
+ SwapCode = 4321;
+ entCur = deb + 6;
+ }
+
+ if ( SwapCode != 0 )
+ {
+ if( memcmp(entCur, "UL", (size_t)2) == 0 ||
+ memcmp(entCur, "OB", (size_t)2) == 0 ||
+ memcmp(entCur, "UI", (size_t)2) == 0 ||
+ memcmp(entCur, "SH", (size_t)2) == 0 ||
+ memcmp(entCur, "AE", (size_t)2) == 0 ||
+ memcmp(entCur, "OB", (size_t)2) == 0 )
+ {
+ Filetype = ExplicitVR;
+ gdcmWarningMacro( "Group 0002 : Explicit Value Representation");
+ return true;
+ }
+ }
+// ------------------------------- End of 'No Preamble' DicomV3 -------------
+
// 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.
+ // By clean we mean that the length of the first group is written down.
// If this is the case and since the length of the first group HAS to be
// four (bytes), then determining the proper swap code is straightforward.
// representation of a 32 bits integer. Hence the following dirty
// trick :
s32 = *((uint32_t *)(entCur));
-
switch( s32 )
{
case 0x00040000 :
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff