X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmElValSet.cxx;h=fe5df93739c928d7815f837bc2d43db4d2a47c08;hb=4ea2f357cc50dd9238c6bdf4f29c275aab1aa1a9;hp=85ea5fc5aa024e3c0441197ba0d9d3792af6d7aa;hpb=a631c1cc8f402dcef308999aefe5aec531934e8f;p=gdcm.git diff --git a/src/gdcmElValSet.cxx b/src/gdcmElValSet.cxx index 85ea5fc5..fe5df937 100644 --- a/src/gdcmElValSet.cxx +++ b/src/gdcmElValSet.cxx @@ -1,63 +1,382 @@ -#include "gdcmlib.h" +// gdcmElValSet.cxx + +#include #include "gdcmUtil.h" +#include "gdcmElValSet.h" + +#define DEBUG 0 -TagElValueHT & ElValSet::GetTagHt(void) { + +TagElValueHT & gdcmElValSet::GetTagHt(void) { return tagHt; } -void ElValSet::Add(ElValue * newElValue) { - tagHt[newElValue->GetKey()] = newElValue; +void gdcmElValSet::Add(gdcmElValue * newElValue) { + tagHt [newElValue->GetKey()] = newElValue; NameHt[newElValue->GetName()] = newElValue; } -void ElValSet::Print(ostream & os) { +void gdcmElValSet::Print(ostream & os) { for (TagElValueHT::iterator tag = tagHt.begin(); tag != tagHt.end(); ++tag){ os << tag->first << ": "; os << "[" << tag->second->GetValue() << "]"; os << "[" << tag->second->GetName() << "]"; - os << "[" << tag->second->GetVR() << "]" << endl; + os << "[" << tag->second->GetVR() << "]"; + os << " lgr : " << tag->second->GetLength(); + os << endl; } -} +} -void ElValSet::PrintByName(ostream & os) { +void gdcmElValSet::PrintByName(ostream & os) { for (TagElValueNameHT::iterator tag = NameHt.begin(); tag != NameHt.end(); ++tag){ os << tag->first << ": "; os << "[" << tag->second->GetValue() << "]"; - os << "[" << tag->second->GetKey() << "]"; + os << "[" << tag->second->GetKey() << "]"; os << "[" << tag->second->GetVR() << "]" << endl; } } -ElValue* ElValSet::GetElement(guint32 group, guint32 element) { +gdcmElValue* gdcmElValSet::GetElementByNumber(guint16 group, guint16 element) { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHt.count(key)) - return (ElValue*)0; - if (tagHt.count(key) > 1) - dbg.Verbose(0, "ElValSet::GetElValue", - "multiple entries for this key (FIXME) !"); + return (gdcmElValue*)0; return tagHt.find(key)->second; } -string ElValSet::GetElValue(guint32 group, guint32 element) { +gdcmElValue* gdcmElValSet::GetElementByName(string TagName) { + if ( ! NameHt.count(TagName)) + return (gdcmElValue*)0; + return NameHt.find(TagName)->second; +} + +string gdcmElValSet::GetElValueByNumber(guint16 group, guint16 element) { TagKey key = gdcmDictEntry::TranslateToKey(group, element); if ( ! tagHt.count(key)) - return "UNFOUND"; - if (tagHt.count(key) > 1) - dbg.Verbose(0, "ElValSet::GetElValue", - "multiple entries for this key (FIXME) !"); + return "gdcm::Unfound"; return tagHt.find(key)->second->GetValue(); } -string ElValSet::GetElValue(string TagName) { +string gdcmElValSet::GetElValueByName(string TagName) { if ( ! NameHt.count(TagName)) - return "UNFOUND"; - if (NameHt.count(TagName) > 1) - dbg.Verbose(0, "ElValSet::GetElValue", - "multipe entries for this key (FIXME) !"); + return "gdcm::Unfound"; return NameHt.find(TagName)->second->GetValue(); } + +int gdcmElValSet::SetElValueByNumber(string content, + guint16 group, guint16 element) { + TagKey key = gdcmDictEntry::TranslateToKey(group, element); + if ( ! tagHt.count(key)) + return 0; + tagHt[key]->SetValue(content); + tagHt[key]->SetLength(content.length()); + return 1; +} + +int gdcmElValSet::SetElValueByName(string content, string TagName) { + if ( ! NameHt.count(TagName)) + return 0; + NameHt[TagName]->SetValue(content); + NameHt[TagName]->SetLength(content.length()); + return 1; +} + +/** + * \ingroup gdcmElValSet + * \brief Generate a free TagKey i.e. a TagKey that is not present + * in the TagHt dictionary. + * @param group The generated tag must belong to this group. + * @return The element of tag with given group which is fee. + */ +guint32 gdcmElValSet::GenerateFreeTagKeyInGroup(guint16 group) { + for (guint32 elem = 0; elem < UINT32_MAX; elem++) { + TagKey key = gdcmDictEntry::TranslateToKey(group, elem); + if (tagHt.count(key) == 0) + return elem; + } + return UINT32_MAX; +} + +int gdcmElValSet::SetElValueLengthByNumber(guint32 length, + guint16 group, guint16 element) { + TagKey key = gdcmDictEntry::TranslateToKey(group, element); + if ( ! tagHt.count(key)) + return 0; + tagHt[key]->SetLength(length); + return 1 ; +} + + +int gdcmElValSet::SetElValueLengthByName(guint32 length, string TagName) { + if ( ! NameHt.count(TagName)) + return 0; + NameHt.find(TagName)->second->SetLength(length); + return 1 ; +} + +void gdcmElValSet::UpdateGroupLength(bool SkipSequence) { + + // TODO : reecrire entierement : une HTable dans la quelle on stocke les groupes, puis leur lgr + // Voir juste apres + + // On parcourt la table pour recalculer la longueur des 'elements 0x0000' + // au cas ou un tag ai été ajouté par rapport à ce qui a été lu + // dans l'image native + // + // cf : code IdDcmWriteFile dans libido/src/dcmwrite.c + + // On fait de l'implicit VR little Endian + // (pour moins se fairche sur processeur INTEL) + // On force le TRANSFERT SYNTAX UID + guint16 gr, el; + string vr; + guint32 lgrCalcGroupe=0; + gdcmElValue *elem, *elemZ, *elemZPrec; + guint16 grCourant = 0; + + TagElValueHT::iterator tag = tagHt.begin(); + + elem = tag->second; + gr = elem->GetGroup(); + el = elem->GetElement(); + + if (el != 0x0000) { + if(DEBUG)printf("ajout elem OOOO premiere fois\n"); + gdcmDictEntry * tagZ = new gdcmDictEntry(gr, 0x0000, "UL"); + elemZPrec = new gdcmElValue(tagZ); // on le cree + elemZPrec->SetLength(4); + Add(elemZPrec); // On l'accroche à sa place + } else { + elemZPrec = elem; + if(DEBUG)printf("Pas d'ajout elem OOOO premiere fois\n"); + } + lgrCalcGroupe = 0; + if(DEBUG)printf("init-1 lgr (%d) pour gr %04x\n",lgrCalcGroupe, gr); + grCourant = gr; + + for (tag = ++tagHt.begin(); + tag != tagHt.end(); + ++tag){ + + elem = tag->second; + gr = elem->GetGroup(); + el = elem->GetElement(); + vr = elem->GetVR(); + + if (SkipSequence && vr == "SQ") continue; + // pas SEQUENCE en ACR-NEMA + // WARNING : pb CERTAIN + // si on est descendu 'a l'interieur' des SQ + + if ( (gr != grCourant) /*&& // On arrive sur un nv Groupe + (el != 0xfffe) */ ) { + + if (el != 0x0000) { + gdcmDictEntry * tagZ = new gdcmDictEntry(gr, 0x0000, "UL"); + elemZ = new gdcmElValue(tagZ); // on le cree + elemZ->SetLength(4); + Add(elemZ); // On l'accroche à sa place + if(DEBUG)printf("ajout elem OOOO pour gr %04x\n",gr); + } else { + elemZ=elem; + if(DEBUG)printf("maj elemZ\n"); + } + + ostringstream f; + f << lgrCalcGroupe; + //sprintf(str_lgrCalcGroupe,"%d",lgrCalcGroupe); + elemZPrec->SetValue(f.str()); + if(DEBUG)printf("ecriture lgr (%d, %s) pour gr %04x\n",lgrCalcGroupe, f.str().c_str(), grCourant); + if(DEBUG)printf ("%04x %04x [%s]\n",elemZPrec->GetGroup(), elemZPrec->GetElement(), + elemZPrec->GetValue().c_str()); + if(DEBUG)cout << "Addresse elemZPrec " << elemZPrec<< endl; + elemZPrec=elemZ; + lgrCalcGroupe = 0; + grCourant = gr; + // BUG : + // calcule lgr erronnée si ExplicitVR et VR =OB, SQ, etc + // + if(DEBUG)printf("init-2 lgr (%d) pour gr %04x\n",lgrCalcGroupe, gr); + } else { // On n'EST PAS sur un nv Groupe + lgrCalcGroupe += 2 + 2 + 4 + elem->GetLength(); // Gr + Num + Lgr + LgrElem + if(DEBUG)printf("increment (%d) el %04x-->lgr (%d) pour gr %04x\n", + elem->GetLength(), el, lgrCalcGroupe, gr); + } + } + + // BUG : + // Ecriture incorrecte si (7FE0 0000) absent et aucun element apres groupe 7FE0 :-( + // A JETTER ! + // +} + +// +// Remplacera UpdateGroupLength +// Commite par precaution. +// Ne pas utiliser +// + +void gdcmElValSet::UpdateGroupLengthNew(bool SkipSequence, FileType type) { + guint16 gr, el; + string vr; + + gdcmElValue *elem; + char trash[10]; + GroupKey key; + GroupHT groupHt; + + for (TagElValueHT::iterator tag2 = tagHt.begin(); + tag2 != tagHt.end(); + ++tag2){ + + elem = tag2->second; + gr = elem->GetGroup(); + el = elem->GetElement(); + vr = elem->GetVR(); + + sprintf(trash, "%04x", gr); + key = trash; + + if (SkipSequence && vr == "SQ") continue; + // pas SEQUENCE en ACR-NEMA + // WARNING : pb CERTAIN + // si on est descendu 'a l'interieur' des SQ + // + // --> la descente a l'interieur' des SQ + // devra etre faite avec une liste chainee, pas avec une HTable... + + if ( groupHt.count(key) == 0) { + groupHt[key] = 2 + 2 + 4 + 4; // creation automatique, par affectation ??? + } else { + if (type = ExplicitVR) { + if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) { + groupHt[key] += 4; + } + } + groupHt[key] += 2 + 2 + 4 + elem->GetLength(); + } + } + + // Liberer groupHt ! +} + + + +void gdcmElValSet::WriteElements(FileType type, FILE * _fp) { + guint16 gr, el; + guint32 lgr; + const char * val; + string vr; + guint32 val_uint32; + guint16 val_uint16; + + vector tokens; + + void *ptr; + + // Tout ceci ne marche QUE parce qu'on est sur un proc Little Endian + // restent à tester les echecs en écriture (apres chaque fwrite) + + for (TagElValueHT::iterator tag2=tagHt.begin(); + tag2 != tagHt.end(); + ++tag2){ + + gr = tag2->second->GetGroup(); + el = tag2->second->GetElement(); + lgr = tag2->second->GetLength(); + val = tag2->second->GetValue().c_str(); + vr = tag2->second->GetVR(); + if(DEBUG)printf ("%04x %04x [%s] : [%s]\n",gr, el, vr.c_str(), val); + + if ( type == ACR ) { + if (gr < 0x0008) continue; + if (gr %2) continue; + if (vr == "SQ" ) continue; + } + + fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group + fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element + + if ( (type == ExplicitVR) && (gr <= 0x0002) ) { + // On est en EXPLICIT VR + guint16 z=0, shortLgr; + fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp); + + if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) { + fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp); + fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp); + + } else { + shortLgr=lgr; + fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp); + } + } else { + fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp); + } + + tokens.erase(tokens.begin(),tokens.end()); + Tokenize (tag2->second->GetValue(), tokens, "\\"); + + if (vr == "US" || vr == "SS") { + for (unsigned int i=0; i