X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmHeader.cxx;h=5e6c2c876cd2c1c4b6146b12c9b6b5215243ff57;hb=bb2cb788a245b6377a70de3e8a502dab036165ab;hp=cfa470a3cc374fb748e1632dddc93b345c9947a4;hpb=25efc388a88895fc1ba2b961d5f27488ab3c073c;p=gdcm.git diff --git a/src/gdcmHeader.cxx b/src/gdcmHeader.cxx index cfa470a3..5e6c2c87 100644 --- a/src/gdcmHeader.cxx +++ b/src/gdcmHeader.cxx @@ -13,6 +13,8 @@ #include "gdcmUtil.h" #include "gdcmHeader.h" +#include "iddcmjpeg.h" + // Refer to gdcmHeader::CheckSwap() #define HEADER_LENGTH_TO_READ 256 // Refer to gdcmHeader::SetMaxSizeLoadElementValue() @@ -41,6 +43,7 @@ gdcmHeader::gdcmHeader(const char *InFilename, bool exception_on_error) else dbg.Error(!fp, "gdcmHeader::gdcmHeader cannot open file", InFilename); ParseHeader(); + LoadElements(); AddAndDefaultElements(); } @@ -128,8 +131,9 @@ void gdcmHeader::CheckSwap() if(filetype == TrueDicom) { // Next, determine the value representation (VR). Let's skip to the - // first element (0002, 0000) and check there if we find "UL", in - // which case we (almost) know it is explicit VR. + // first element (0002, 0000) and check there if we find "UL" + // - or "OB" if the 1st one is (0002,0001) -, + // in which case we (almost) know it is explicit VR. // WARNING: if it happens to be implicit VR then what we will read // is the length of the group. If this ascii representation of this // length happens to be "UL" then we shall believe it is explicit VR. @@ -139,10 +143,12 @@ void gdcmHeader::CheckSwap() // We need to skip : // * the 128 bytes of File Preamble (often padded with zeroes), // * the 4 bytes of "DICM" string, - // * the 4 bytes of the first tag (0002, 0000), + // * the 4 bytes of the first tag (0002, 0000),or (0002, 0001) // i.e. a total of 136 bytes. entCur = deb + 136; - if(memcmp(entCur, "UL", (size_t)2) == 0) { + if( (memcmp(entCur, "UL", (size_t)2) == 0) || + (memcmp(entCur, "OB", (size_t)2) == 0) ) + { filetype = ExplicitVR; dbg.Verbose(1, "gdcmHeader::CheckSwap:", "explicit Value Representation"); @@ -241,7 +247,11 @@ void gdcmHeader::GetPixels(size_t lgrTotale, void* _Pixels) { size_t pixelsOffset; pixelsOffset = GetPixelOffset(); fseek(fp, pixelsOffset, SEEK_SET); - fread(_Pixels, 1, lgrTotale, fp); + if (IsJPEGLossless()) { + _Pixels=_IdDcmJpegRead(fp); + } else { + fread(_Pixels, 1, lgrTotale, fp); + } } @@ -250,7 +260,7 @@ void gdcmHeader::GetPixels(size_t lgrTotale, void* _Pixels) { * \ingroup gdcmHeader * \brief Find the value representation of the current tag. */ -void gdcmHeader::FindVR( ElValue *ElVal) { +void gdcmHeader::FindVR( gdcmElValue *ElVal) { if (filetype != ExplicitVR) return; @@ -286,7 +296,7 @@ void gdcmHeader::FindVR( ElValue *ElVal) { // PostPone this test in an optional integrity check at the end // of parsing or only in debug mode. if ( RealExplicit && !dicom_vr->count(vr) ) - RealExplicit = false; + RealExplicit= false; if ( RealExplicit ) { if ( ElVal->IsVrUnknown() ) { @@ -334,7 +344,7 @@ void gdcmHeader::FindVR( ElValue *ElVal) { * @return True when ImplicitVRLittleEndian found. False in all other cases. */ bool gdcmHeader::IsImplicitVRLittleEndianTransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -352,7 +362,7 @@ bool gdcmHeader::IsImplicitVRLittleEndianTransferSyntax(void) { * @return True when ExplicitVRLittleEndian found. False in all other cases. */ bool gdcmHeader::IsExplicitVRLittleEndianTransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -370,7 +380,7 @@ bool gdcmHeader::IsExplicitVRLittleEndianTransferSyntax(void) { * @return True when DeflatedExplicitVRLittleEndian found. False in all other cases. */ bool gdcmHeader::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -388,12 +398,12 @@ bool gdcmHeader::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) { * @return True when big endian found. False in all other cases. */ bool gdcmHeader::IsExplicitVRBigEndianTransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); string Transfer = Element->GetValue(); - if ( Transfer == "1.2.840.10008.1.2.2" ) + if ( Transfer == "1.2.840.10008.1.2.2" ) //1.2.2 ??? A verifier ! return true; return false; } @@ -406,7 +416,7 @@ bool gdcmHeader::IsExplicitVRBigEndianTransferSyntax(void) { * @return True when JPEGBaseLineProcess1found. False in all other cases. */ bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -416,6 +426,20 @@ bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) { return false; } +// faire qq chose d'intelligent a la place de ça + +bool gdcmHeader::IsJPEGLossless(void) { + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); + if ( !Element ) + return false; + LoadElementValueSafe(Element); + 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; + return false; +} + + /** * \ingroup gdcmHeader * \brief Determines if the Transfer Syntax was allready encountered @@ -424,7 +448,7 @@ bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) { * @return True when JPEGExtendedProcess2-4 found. False in all other cases. */ bool gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -442,7 +466,7 @@ bool gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(void) { * @return True when JPEGExtendedProcess3-5 found. False in all other cases. */ bool gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -461,7 +485,7 @@ bool gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(void) { * other cases. */ bool gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void) { - ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010); + gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010); if ( !Element ) return false; LoadElementValueSafe(Element); @@ -477,7 +501,7 @@ bool gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void) { * the parser went Jabberwocky) one can hope improving things by * applying this heuristic. */ -void gdcmHeader::FixFoundLength(ElValue * ElVal, guint32 FoundLength) { +void gdcmHeader::FixFoundLength(gdcmElValue * ElVal, guint32 FoundLength) { if ( FoundLength == 0xffffffff) FoundLength = 0; ElVal->SetLength(FoundLength); @@ -521,7 +545,7 @@ guint32 gdcmHeader::FindLengthOB(void) { return TotalLength; } -void gdcmHeader::FindLength(ElValue * ElVal) { +void gdcmHeader::FindLength(gdcmElValue * ElVal) { guint16 element = ElVal->GetElement(); string vr = ElVal->GetVR(); guint16 length16; @@ -660,7 +684,7 @@ void gdcmHeader::SkipBytes(guint32 NBytes) { (void)fseek(fp, (long)NBytes, SEEK_CUR); } -void gdcmHeader::SkipElementValue(ElValue * ElVal) { +void gdcmHeader::SkipElementValue(gdcmElValue * ElVal) { SkipBytes(ElVal->GetLength()); } @@ -680,7 +704,7 @@ void gdcmHeader::SetMaxSizeLoadElementValue(long NewSize) { * than the value specified with * gdcmHeader::SetMaxSizeLoadElementValue() */ -void gdcmHeader::LoadElementValue(ElValue * ElVal) { +void gdcmHeader::LoadElementValue(gdcmElValue * ElVal) { size_t item_read; guint16 group = ElVal->GetGroup(); guint16 elem = ElVal->GetElement(); @@ -690,13 +714,14 @@ void gdcmHeader::LoadElementValue(ElValue * ElVal) { fseek(fp, (long)ElVal->GetOffset(), SEEK_SET); - // Sequences not treated yet ! + // FIXME Sequences not treated yet ! // // Ne faudrait-il pas au contraire trouver immediatement // une maniere 'propre' de traiter les sequences (vr = SQ) // car commencer par les ignorer risque de conduire a qq chose // qui pourrait ne pas etre generalisable - // + // Well, I'm expecting your code !!! + if( vr == "SQ" ) SkipLoad = true; @@ -706,16 +731,7 @@ void gdcmHeader::LoadElementValue(ElValue * ElVal) { if( group == 0xfffe ) SkipLoad = true; - // The group length doesn't represent data to be loaded in memory, since - // each element of the group shall be loaded individualy. - if( elem == 0 ) - //SkipLoad = true; // modif sauvage JPR - // On charge la longueur du groupe - // quand l'element 0x0000 est présent ! - if ( SkipLoad ) { - // FIXME the following skip is not necessary - SkipElementValue(ElVal); ElVal->SetLength(0); ElVal->SetValue("gdcm::Skipped"); return; @@ -741,21 +757,44 @@ void gdcmHeader::LoadElementValue(ElValue * ElVal) { // 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. - if ( IsAnInteger(ElVal) ) { - guint32 NewInt; - if( length == 2 ) { - NewInt = ReadInt16(); - } else if( length == 4 ) { - NewInt = ReadInt32(); - } else - dbg.Error(true, "LoadElementValue: Inconsistency when reading Int."); - - //FIXME: make the following an util fonction - ostringstream s; - s << NewInt; - ElVal->SetValue(s.str()); - return; - } + + // pour les elements de Value Multiplicity > 1 + // on aura en fait une serie d'entiers + + // on devrait pouvoir faire + compact (?) + + if ( IsAnInteger(ElVal) ) { + guint32 NewInt; + ostringstream s; + int nbInt; + if (vr == "US" || vr == "SS") { + nbInt = length / 2; + NewInt = ReadInt16(); + s << NewInt; + if (nbInt > 1) { + for (int i=1; i < nbInt; i++) { + s << '\\'; + NewInt = ReadInt16(); + s << NewInt; + //printf("%s\n", s.str().c_str()); + } + } + + } else if (vr == "UL" || vr == "SL") { + nbInt = length / 4; + NewInt = ReadInt32(); + s << NewInt; + if (nbInt > 1) { + for (int i=1; i < nbInt; i++) { + s << '\\'; + NewInt = ReadInt32(); + s << NewInt; + } + } + } + ElVal->SetValue(s.str()); + return; + } // FIXME The exact size should be length if we move to strings or whatever char* NewValue = (char*)malloc(length+1); @@ -783,7 +822,7 @@ void gdcmHeader::LoadElementValue(ElValue * ElVal) { * @param ElVal Element whose value shall be loaded. * @return */ -void gdcmHeader::LoadElementValueSafe(ElValue * ElVal) { +void gdcmHeader::LoadElementValueSafe(gdcmElValue * ElVal) { long PositionOnEntry = ftell(fp); LoadElementValue(ElVal); fseek(fp, PositionOnEntry, SEEK_SET); @@ -826,21 +865,35 @@ guint32 gdcmHeader::ReadInt32(void) { * @param Group group of the underlying DictEntry * @param Elem element of the underlying DictEntry */ -ElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) { +gdcmElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) { // Find out if the tag we encountered is in the dictionaries: gdcmDictEntry * NewTag = GetDictEntryByKey(Group, Elem); if (!NewTag) NewTag = new gdcmDictEntry(Group, Elem); - ElValue* NewElVal = new ElValue(NewTag); + gdcmElValue* NewElVal = new gdcmElValue(NewTag); if (!NewElVal) { dbg.Verbose(1, "gdcmHeader::NewElValueByKey", - "failed to allocate ElValue"); - return (ElValue*)0; + "failed to allocate gdcmElValue"); + return (gdcmElValue*)0; } return NewElVal; } +/** + * \ingroup gdcmHeader + * \brief TODO + * @param + */ +int gdcmHeader::ReplaceOrCreateByNumber(guint16 Group, guint16 Elem, string Value) { + + gdcmElValue* nvElValue=NewElValueByKey(Group, Elem); + PubElValSet.Add(nvElValue); + PubElValSet.SetElValueByNumber(Value, Group, Elem); + return(1); +} + + /** * \ingroup gdcmHeader * \brief Build a new Element Value from all the low level arguments. @@ -848,17 +901,17 @@ ElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) { * a default one when absent. * @param Name Name of the underlying DictEntry */ -ElValue* gdcmHeader::NewElValueByName(string Name) { +gdcmElValue* gdcmHeader::NewElValueByName(string Name) { gdcmDictEntry * NewTag = GetDictEntryByName(Name); if (!NewTag) NewTag = new gdcmDictEntry(0xffff, 0xffff, "LO", "Unknown", Name); - ElValue* NewElVal = new ElValue(NewTag); + gdcmElValue* NewElVal = new gdcmElValue(NewTag); if (!NewElVal) { dbg.Verbose(1, "gdcmHeader::ObtainElValueByName", - "failed to allocate ElValue"); - return (ElValue*)0; + "failed to allocate gdcmElValue"); + return (gdcmElValue*)0; } return NewElVal; } @@ -868,24 +921,24 @@ ElValue* gdcmHeader::NewElValueByName(string Name) { * \brief Read the next tag but WITHOUT loading it's value * @return On succes the newly created ElValue, NULL on failure. */ -ElValue * gdcmHeader::ReadNextElement(void) { - guint16 g; - guint16 n; - ElValue * NewElVal; +gdcmElValue * gdcmHeader::ReadNextElement(void) { + + guint16 g,n; + gdcmElValue * NewElVal; g = ReadInt16(); n = ReadInt16(); if (errno == 1) // We reached the EOF (or an error occured) and header parsing // has to be considered as finished. - return (ElValue *)0; + return (gdcmElValue *)0; NewElVal = NewElValueByKey(g, n); FindVR(NewElVal); FindLength(NewElVal); if (errno == 1) // Call it quits - return (ElValue *)0; + return (gdcmElValue *)0; NewElVal->SetOffset(ftell(fp)); return NewElVal; } @@ -897,7 +950,7 @@ ElValue * gdcmHeader::ReadNextElement(void) { * @param ElVal The element value on which to apply the predicate. * @return The result of the heuristical predicate. */ -bool gdcmHeader::IsAnInteger(ElValue * ElVal) { +bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) { guint16 group = ElVal->GetGroup(); guint16 element = ElVal->GetElement(); string vr = ElVal->GetVR(); @@ -980,7 +1033,7 @@ size_t gdcmHeader::GetPixelOffset(void) { numPixel = 0x1010; else numPixel = 0x0010; - ElValue* PixelElement = PubElVals.GetElementByNumber(grPixel, numPixel); + gdcmElValue* PixelElement = PubElValSet.GetElementByNumber(grPixel, numPixel); if (PixelElement) return PixelElement->GetOffset(); else @@ -1053,7 +1106,7 @@ gdcmDictEntry * gdcmHeader::GetDictEntryByName(string Name) { * "gdcm::Unfound" otherwise. */ string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) { - return PubElVals.GetElValueByNumber(group, element); + return PubElValSet.GetElValueByNumber(group, element); } /** @@ -1071,7 +1124,7 @@ string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) { * and the string "gdcm::Unfound" otherwise. */ string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) { - ElValue* elem = PubElVals.GetElementByNumber(group, element); + gdcmElValue* elem = PubElValSet.GetElementByNumber(group, element); if ( !elem ) return "gdcm::Unfound"; return elem->GetVR(); @@ -1086,7 +1139,7 @@ string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) { * "gdcm::Unfound" otherwise. */ string gdcmHeader::GetPubElValByName(string TagName) { - return PubElVals.GetElValueByName(TagName); + return PubElValSet.GetElValueByName(TagName); } /** @@ -1103,7 +1156,7 @@ string gdcmHeader::GetPubElValByName(string TagName) { * and the string "gdcm::Unfound" otherwise. */ string gdcmHeader::GetPubElValRepByName(string TagName) { - ElValue* elem = PubElVals.GetElementByName(TagName); + gdcmElValue* elem = PubElValSet.GetElementByName(TagName); if ( !elem ) return "gdcm::Unfound"; return elem->GetVR(); @@ -1119,7 +1172,7 @@ string gdcmHeader::GetPubElValRepByName(string TagName) { * and the string "gdcm::Unfound" otherwise. */ string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) { - return ShaElVals.GetElValueByNumber(group, element); + return ShaElValSet.GetElValueByNumber(group, element); } /** @@ -1137,7 +1190,7 @@ string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) { * and the string "gdcm::Unfound" otherwise. */ string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) { - ElValue* elem = ShaElVals.GetElementByNumber(group, element); + gdcmElValue* elem = ShaElValSet.GetElementByNumber(group, element); if ( !elem ) return "gdcm::Unfound"; return elem->GetVR(); @@ -1152,7 +1205,7 @@ string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) { * "gdcm::Unfound" otherwise. */ string gdcmHeader::GetShaElValByName(string TagName) { - return ShaElVals.GetElValueByName(TagName); + return ShaElValSet.GetElValueByName(TagName); } /** @@ -1169,7 +1222,7 @@ string gdcmHeader::GetShaElValByName(string TagName) { * and the string "gdcm::Unfound" otherwise. */ string gdcmHeader::GetShaElValRepByName(string TagName) { - ElValue* elem = ShaElVals.GetElementByName(TagName); + gdcmElValue* elem = ShaElValSet.GetElementByName(TagName); if ( !elem ) return "gdcm::Unfound"; return elem->GetVR(); @@ -1253,7 +1306,7 @@ string gdcmHeader::GetElValRepByName(string TagName) { /** * \ingroup gdcmHeader - * \brief Accesses an existing ElValue in the PubElVals of this instance + * \brief Accesses an existing gdcmElValue in the PubElValSet of this instance * through it's (group, element) and modifies it's content with * the given value. * @param content new value to substitute with @@ -1263,44 +1316,61 @@ string gdcmHeader::GetElValRepByName(string TagName) { int gdcmHeader::SetPubElValByNumber(string content, guint16 group, guint16 element) { - return ( PubElVals.SetElValueByNumber (content, group, element) ); + return ( PubElValSet.SetElValueByNumber (content, group, element) ); } /** * \ingroup gdcmHeader - * \brief Accesses an existing ElValue in the PubElVals of this instance + * \brief Accesses an existing gdcmElValue in the PubElValSet of this instance * through tag name and modifies it's content with the given value. * @param content new value to substitute with * @param TagName name of the tag to be modified */ int gdcmHeader::SetPubElValByName(string content, string TagName) { - return ( PubElVals.SetElValueByName (content, TagName) ); + return ( PubElValSet.SetElValueByName (content, TagName) ); +} + +/** + * \ingroup gdcmHeader + * \brief Accesses an existing gdcmElValue in the PubElValSet of this instance + * through it's (group, element) and modifies it's length with + * the given value. + * \warning Use with extreme caution. + * @param length new length to substitute with + * @param group group of the ElVal to modify + * @param element element of the ElVal to modify + * @return 1 on success, 0 otherwise. + */ + +int gdcmHeader::SetPubElValLengthByNumber(guint32 length, guint16 group, + guint16 element) { + return ( PubElValSet.SetElValueLengthByNumber (length, group, element) ); } /** * \ingroup gdcmHeader - * \brief Accesses an existing ElValue in the ShaElVals of this instance + * \brief Accesses an existing gdcmElValue in the ShaElValSet of this instance * through it's (group, element) and modifies it's content with * the given value. * @param content new value to substitute with * @param group group of the ElVal to modify * @param element element of the ElVal to modify + * @return 1 on success, 0 otherwise. */ int gdcmHeader::SetShaElValByNumber(string content, - guint16 group, guint16 element) -{ - return ( ShaElVals.SetElValueByNumber (content, group, element) ); + guint16 group, guint16 element) { + return ( ShaElValSet.SetElValueByNumber (content, group, element) ); } /** * \ingroup gdcmHeader - * \brief Accesses an existing ElValue in the ShaElVals of this instance + * \brief Accesses an existing gdcmElValue in the ShaElValSet of this instance * through tag name and modifies it's content with the given value. * @param content new value to substitute with * @param TagName name of the tag to be modified */ int gdcmHeader::SetShaElValByName(string content, string TagName) { - return ( ShaElVals.SetElValueByName (content, TagName) ); + return ( ShaElValSet.SetElValueByName (content, TagName) ); } /** @@ -1308,20 +1378,20 @@ int gdcmHeader::SetShaElValByName(string content, string TagName) { * \brief Parses the header of the file but WITHOUT loading element values. */ void gdcmHeader::ParseHeader(bool exception_on_error) throw(gdcmFormatError) { - ElValue * newElValue = (ElValue *)0; + gdcmElValue * newElValue = (gdcmElValue *)0; rewind(fp); CheckSwap(); while ( (newElValue = ReadNextElement()) ) { SkipElementValue(newElValue); - PubElVals.Add(newElValue); + PubElValSet.Add(newElValue); } } /** * \ingroup gdcmHeader * \brief Once the header is parsed add some gdcm convenience/helper elements - * in the ElValSet. For example add: + * in the gdcmElValSet. For example add: * - gdcmImageType which is an entry containing a short for the * type of image and whose value ranges in * I8 (unsigned 8 bit image) @@ -1331,19 +1401,97 @@ void gdcmHeader::ParseHeader(bool exception_on_error) throw(gdcmFormatError) { * the ones of the official DICOM fields Rows, Columns and Planes. */ void gdcmHeader::AddAndDefaultElements(void) { - ElValue* NewEntry = (ElValue*)0; + gdcmElValue* NewElVal = (gdcmElValue*)0; + string NewVal; + + NewElVal = NewManualElValToPubDict("gdcmXSize", "US"); + if (!NewElVal) return; + NewVal = GetElValByName("Rows"); + if (NewVal != "gdcm::Unfound") + NewElVal->SetValue(NewVal); + else + NewElVal->SetValue("0"); + + NewElVal = NewManualElValToPubDict("gdcmYSize", "US"); + if (!NewElVal) return; + NewVal = GetElValByName("Columns"); + if (NewVal != "gdcm::Unfound") + NewElVal->SetValue(NewVal); + else + NewElVal->SetValue("0"); + + + NewElVal = NewManualElValToPubDict("gdcmZSize", "US"); + if (!NewElVal) return; + NewVal = GetElValByNumber(0x0028,0x0008); // 0028 0008 IS IMG Number of Frames (DICOM) + if (NewVal == "gdcm::Unfound") { + NewVal = GetElValByNumber(0x0028,0x0012); // 028 0012 US IMG Planes (ACR-NEMA) + if (NewVal == "gdcm::Unfound") { // Warning !!! : 6000 0012 US OLY Planes + NewElVal->SetValue("0"); + } else { + NewElVal->SetValue(NewVal); + } + } else { + NewElVal->SetValue(NewVal); + } // length is still wrong +} // do we care about it? + + +/** + * \ingroup gdcmHeader + * \brief This predicate, based on hopefully reasonnable 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. + * @return true when gdcmHeader is the one of a reasonable Dicom file, + * false otherwise. + */ +bool gdcmHeader::IsReadable(void) { + if ( GetElValByName("Image Dimensions") != "gdcm::Unfound" + && atoi(GetElValByName("Image Dimensions").c_str()) > 4 ) { + return false; + } + if ( GetElValByName("Bits Allocated") == "gdcm::Unfound" ) + return false; + if ( GetElValByName("Bits Stored") == "gdcm::Unfound" ) + return false; + if ( GetElValByName("High Bit") == "gdcm::Unfound" ) + return false; + if ( GetElValByName("Pixel Representation") == "gdcm::Unfound" ) + return false; + return true; +} - NewEntry = NewElValueByName("gdcmXSize"); - NewEntry->SetValue(GetElValByName("Rows")); - PubElVals.Add(NewEntry); - NewEntry = NewElValueByName("gdcmYSize"); - NewEntry->SetValue(GetElValByName("Columns")); - PubElVals.Add(NewEntry); +/** + * \ingroup gdcmHeader + * \brief Small utility function that creates a new manually crafted + * (as opposed as read from the file) gdcmElValue with user + * specified name and adds it to the public tag hash table. + * Refer to gdcmHeader::AddAndDefaultElements for a typical usage. + * \note A fake TagKey is generated so the PubDict can keep it's coherence. + * @param NewTagName The name to be given to this new tag. + * @param VR The Value Representation to be given to this new tag. + * @ return The newly hand crafted Element Value. + */ +gdcmElValue* gdcmHeader::NewManualElValToPubDict(string NewTagName, string VR) { + gdcmElValue* NewElVal = (gdcmElValue*)0; + guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info + guint32 FreeElem = 0; + gdcmDictEntry* NewEntry = (gdcmDictEntry*)0; + + FreeElem = PubElValSet.GenerateFreeTagKeyInGroup(StuffGroup); + if (FreeElem == UINT32_MAX) { + dbg.Verbose(1, "gdcmHeader::NewManualElValToPubDict", + "Group 0xffff in Public Dict is full"); + return (gdcmElValue*)0; + } + NewEntry = new gdcmDictEntry(StuffGroup, FreeElem, + VR, "GDCM", NewTagName); + NewElVal = new gdcmElValue(NewEntry); + PubElValSet.Add(NewElVal); + return NewElVal; - NewEntry = NewElValueByName("gdcmZSize"); - NewEntry->SetValue(GetElValByName("Planes")); - PubElVals.Add(NewEntry); } /** @@ -1353,14 +1501,14 @@ void gdcmHeader::AddAndDefaultElements(void) { */ void gdcmHeader::LoadElements(void) { rewind(fp); - TagElValueHT ht = PubElVals.GetTagHt(); + TagElValueHT ht = PubElValSet.GetTagHt(); for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag) { LoadElementValue(tag->second); } } void gdcmHeader::PrintPubElVal(ostream & os) { - PubElVals.Print(os); + PubElValSet.Print(os); } void gdcmHeader::PrintPubDict(ostream & os) {