-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.110 2003/11/05 17:59:42 malaterre Exp $
+// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.115 2003/11/12 15:35:19 jpr Exp $
#include "gdcmHeader.h"
* @param InFilename
* @param exception_on_error
*/
-gdcmHeader::gdcmHeader(const char *InFilename, bool exception_on_error) {
+gdcmHeader::gdcmHeader(const char *InFilename,
+ bool exception_on_error,
+ bool enable_sequences ) {
+ if (enable_sequences)
+ enableSequences = 1;
+ else
+ enableSequences = 0;
+
SetMaxSizeLoadElementValue(_MaxSizeLoadElementValue_);
filename = InFilename;
Initialise();
const char * Transfert = Element->GetValue().c_str();
if ( memcmp(Transfert+strlen(Transfert)-2 ,"70",2)==0) return true;
if ( memcmp(Transfert+strlen(Transfert)-2 ,"55",2)==0) return true;
- if (Element->GetValue() == "1.2.840.10008.1.2.4.57") return true;
+ if (Element->GetValue() == "1.2.840.10008.1.2.4.57") return true;
return false;
}
* applying this heuristic.
*/
void gdcmHeader::FixFoundLength(gdcmElValue * ElVal, guint32 FoundLength) {
- if ( FoundLength == 0xffffffff)
+
+ ElVal->SetReadLength(FoundLength); // will be updated only if a bug is found
+
+ if ( FoundLength == 0xffffffff) {
FoundLength = 0;
+ }
// Sorry for the patch!
// XMedCom did the trick to read some nasty GE images ...
else if (FoundLength == 13) {
// The following 'if' will be removed when there is no more
// images on Creatis HDs with a 13 length for Manufacturer...
- if ( (ElVal->GetGroup() != 0x0008) || (ElVal->GetElement() != 0x0070)) {
+ if ( (ElVal->GetGroup() != 0x0008) &&
+ ( (ElVal->GetElement() != 0x0070) || (ElVal->GetElement() != 0x0080) ) ) {
// end of remove area
FoundLength =10;
+ ElVal->SetReadLength(10); // a bug is to be fixed
}
}
// to fix some garbage 'Leonardo' Siemens images
// May be commented out to avoid overhead
else if ( (ElVal->GetGroup() == 0x0009)
&&
- ( (ElVal->GetElement() == 0x1113) || (ElVal->GetElement() == 0x1114) ) )
- FoundLength =4;
-
- ElVal->SetLength(FoundLength);
+ ( (ElVal->GetElement() == 0x1113) || (ElVal->GetElement() == 0x1114) ) ){
+ FoundLength =4;
+ ElVal->SetReadLength(4); // a bug is to be fixed
+ }
+ // end of fix
+
+ // to try to 'go inside' SeQuences (with length), and not to skip them
+ else if ( ElVal->GetVR() == "SQ") {
+ if (enableSequences) // only if the user does want to !
+ FoundLength =0;
+ }
+
+ // a SeQuence Element is beginning
+ // Let's forget it's length
+ // (we want to 'go inside')
+ else if(ElVal->GetGroup() == 0xfffe){
+ FoundLength =0;
+ }
+
+ ElVal->SetUsableLength(FoundLength);
}
/**
ElVal->SetLength(FindLengthOB());
return;
}
- FixFoundLength(ElVal, length32);
+ FixFoundLength(ElVal, length32);
return;
}
// appear when we find the first group with big endian encoding. This
// is easy to detect since the length of a "Group Length" tag (the
// ones with zero as element number) has to be of 4 (0x0004). When we
- // encouter 1024 (0x0400) chances are the encoding changed and we
+ // encounter 1024 (0x0400) chances are the encoding changed and we
// found a group with big endian encoding.
// We shall use this second strategy. In order to make sure that we
// can interpret the presence of an apparently big endian encoded
// not coexist in a Data Set and Data Sets nested within it".]
// Length is on 4 bytes.
FixFoundLength(ElVal, ReadInt32());
+ return;
}
/**
* @return
*/
void gdcmHeader::SkipElementValue(gdcmElValue * ElVal) {
- SkipBytes(ElVal->GetLength());
+ SkipBytes(ElVal->GetLength());
}
/**
// car commencer par les ignorer risque de conduire a qq chose
// qui pourrait ne pas etre generalisable
// Well, I'm expecting your code !!!
+
+ // the test was commented out to 'go inside' the SeQuences
+ // we don't any longer skip them !
- if( vr == "SQ" )
- SkipLoad = true;
+ // if( vr == "SQ" )
+ // SkipLoad = true;
- // A sequence "contains" a set of Elements.
+ // A SeQuence "contains" a set of Elements.
// (fffe e000) tells us an Element is beginning
// (fffe e00d) tells us an Element just ended
- // (fffe e0dd) tells us the current SQuence just ended
+ // (fffe e0dd) tells us the current SeQuence just ended
if( group == 0xfffe )
SkipLoad = true;
s << "gdcm::NotLoaded.";
s << " Address:" << (long)ElVal->GetOffset();
s << " Length:" << ElVal->GetLength();
+ s << " x(" << std::hex << ElVal->GetLength() << ")";
ElVal->SetValue(s.str());
return;
}
// When an integer is expected, read and convert the following two or
// four bytes properly i.e. as an integer as opposed to a string.
- // pour les elements de Value Multiplicity > 1
- // on aura en fait une serie d'entiers
- // on devrait pouvoir faire + compact (?)
+ // Actually, elements with Value Multiplicity > 1
+ // contain a set of integers (not a single one)
+ // Any compacter code suggested (?)
if ( IsAnInteger(ElVal) ) {
guint32 NewInt;
*/
int gdcmHeader::ReplaceOrCreateByNumber(std::string Value,
guint16 Group, guint16 Elem ) {
-
// TODO : FIXME JPRx
// curieux, non ?
// on (je) cree une Elvalue ne contenant pas de valeur
NewElVal = NewElValueByNumber(g, n);
FindVR(NewElVal);
FindLength(NewElVal);
+
if (errno == 1) {
// Call it quits
return (gdcmElValue *)0;
* \ingroup gdcmHeader
* \brief Searches within the public dictionary for element value of
* a given tag.
- * @param TagName name of the researched element.
+ * @param TagName name of the searched element.
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* to convert the string typed content to caller's native type
* (think of C++ vs Python). The VR is actually of a higher level
* of semantics than just the native C++ type.
- * @param TagName name of the researched element.
+ * @param TagName name of the searched element.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* \ingroup gdcmHeader
* \brief Searches within elements parsed with the SHADOW dictionary
* for the element value of a given tag.
- * @param group Group of the researched tag.
- * @param element Element of the researched tag.
+ * @param group Group of the searched tag.
+ * @param element Element of the searched tag.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* to convert the string typed content to caller's native type
* (think of C++ vs Python). The VR is actually of a higher level
* of semantics than just the native C++ type.
- * @param group Group of the researched tag.
- * @param element Element of the researched tag.
+ * @param group Group of the searched tag.
+ * @param element Element of the searched tag.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* \ingroup gdcmHeader
* \brief Searches within the elements parsed with the shadow dictionary
* for an element value of given tag.
- * @param TagName name of the researched element.
+ * @param TagName name of the searched element.
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* to convert the string typed content to caller's native type
* (think of C++ vs Python). The VR is actually of a higher level
* of semantics than just the native C++ type.
- * @param TagName name of the researched element.
+ * @param TagName name of the searched element.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* \brief Searches within elements parsed with the public dictionary
* and then within the elements parsed with the shadow dictionary
* for the element value of a given tag.
- * @param group Group of the researched tag.
- * @param element Element of the researched tag.
+ * @param group Group of the searched tag.
+ * @param element Element of the searched tag.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* to convert the string typed content to caller's native type
* (think of C++ vs Python). The VR is actually of a higher level
* of semantics than just the native C++ type.
- * @param group Group of the researched tag.
- * @param element Element of the researched tag.
+ * @param group Group of the searched tag.
+ * @param element Element of the searched tag.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* \brief Searches within elements parsed with the public dictionary
* and then within the elements parsed with the shadow dictionary
* for the element value of a given tag.
- * @param TagName name of the researched element.
+ * @param TagName name of the searched element.
* @return Corresponding element value when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
* to convert the string typed content to caller's native type
* (think of C++ vs Python). The VR is actually of a higher level
* of semantics than just the native C++ type.
- * @param TagName name of the researched element.
+ * @param TagName name of the searched element.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
rewind(fp);
CheckSwap();
- while ( (newElValue = ReadNextElement()) ) {
+ while ( (newElValue = ReadNextElement()) ) {
SkipElementValue(newElValue);
PubElValSet.Add(newElValue);
}
/**
* \ingroup gdcmHeader
- * \brief This predicate, based on hopefully reasonnable heuristics,
+ * \brief This predicate, based on hopefully reasonable heuristics,
* decides whether or not the current gdcmHeader was properly parsed
* and contains the mandatory information for being considered as
* a well formed and usable image.
* public tag based hash table.
*/
void gdcmHeader::LoadElements(void) {
- rewind(fp);
- TagElValueHT ht = PubElValSet.GetTagHt();
- for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag) {
- LoadElementValue(tag->second);
- }
+ rewind(fp);
+
+ // We don't use any longer the HashTable, since a lot a stuff is missing
+ // when SeQuences were encountered
+ //
+ //TagElValueHT ht = PubElValSet.GetTagHt();
+ //for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag) {
+ // LoadElementValue(tag->second);
+ //}
+
+ for (std::list<gdcmElValue*>::iterator i = GetListElem().begin();
+ i != GetListElem().end();
+ ++i){
+ LoadElementValue(*i);
+ }
+
rewind(fp);
// Load 'non string' values
*/
int gdcmHeader::Write(FILE * fp, FileType type) {
-
- // TODO : move the following lines (and a lot of others)
+ // TODO : move the following lines (and a lot of others, to be written)
// to a future function CheckAndCorrectHeader
if (type == ImplicitVR) {
if (gdcmHeader::GetPubElValByNumber(0x0028,0x0004) != "PALETTE COLOR ") {
return NULL;
}
-
- void * LutR,*LutG,*LutB;
- int l;
+
int lengthR, debR, nbitsR;
int lengthG, debG, nbitsG;
int lengthB, debB, nbitsB;
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff