+ 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 (gdcmElValue *)0;
+
+ NewElVal = NewElValueByKey(g, n);
+ FindVR(NewElVal);
+ FindLength(NewElVal);
+ if (errno == 1)
+ // Call it quits
+ return (gdcmElValue *)0;
+ NewElVal->SetOffset(ftell(fp));
+ return NewElVal;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Apply some heuristics to predict wether the considered
+ * element value contains/represents an integer or not.
+ * @param ElVal The element value on which to apply the predicate.
+ * @return The result of the heuristical predicate.
+ */
+bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) {
+ guint16 group = ElVal->GetGroup();
+ guint16 element = ElVal->GetElement();
+ string vr = ElVal->GetVR();
+ guint32 length = ElVal->GetLength();
+
+ // When we have some semantics on the element we just read, and if we
+ // a priori know we are dealing with an integer, then we shall be
+ // able to swap it's element value properly.
+ if ( element == 0 ) { // This is the group length of the group
+ if (length == 4)
+ return true;
+ else {
+ printf("Erroneous Group Length element length %d\n",length);
+
+ dbg.Error("gdcmHeader::IsAnInteger",
+ "Erroneous Group Length element length.");
+ }
+ }
+
+ if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
+ return true;
+
+ return false;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Recover the offset (from the beginning of the file) of the pixels.
+ */
+size_t gdcmHeader::GetPixelOffset(void) {
+ // If this file complies with the norm we should encounter the
+ // "Image Location" tag (0x0028, 0x0200). This tag contains the
+ // the group that contains the pixel data (hence the "Pixel Data"
+ // is found by indirection through the "Image Location").
+ // Inside the group pointed by "Image Location" the searched element
+ // is conventionally the element 0x0010 (when the norm is respected).
+ // When the "Image Location" is absent we default to group 0x7fe0.
+ guint16 grPixel;
+ guint16 numPixel;
+ string ImageLocation = GetPubElValByName("Image Location");
+ if ( ImageLocation == "gdcm::Unfound" ) {
+ grPixel = 0x7fe0;
+ } else {
+ grPixel = (guint16) atoi( ImageLocation.c_str() );
+ }
+ if (grPixel != 0x7fe0)
+ // This is a kludge for old dirty Philips imager.
+ numPixel = 0x1010;
+ else
+ numPixel = 0x0010;
+ gdcmElValue* PixelElement = PubElValSet.GetElementByNumber(grPixel, numPixel);
+ if (PixelElement)
+ return PixelElement->GetOffset();
+ else
+ return 0;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches both the public and the shadow dictionary (when they
+ * exist) for the presence of the DictEntry with given
+ * group and element. The public dictionary has precedence on the
+ * shadow one.
+ * @param group group of the searched DictEntry
+ * @param element element of the searched DictEntry
+ * @return Corresponding DictEntry when it exists, NULL otherwise.
+ */
+gdcmDictEntry * gdcmHeader::GetDictEntryByKey(guint16 group, guint16 element) {
+ gdcmDictEntry * found = (gdcmDictEntry*)0;
+ if (!RefPubDict && !RefShaDict) {
+ dbg.Verbose(0, "gdcmHeader::GetDictEntry",
+ "we SHOULD have a default dictionary");
+ }
+ if (RefPubDict) {
+ found = RefPubDict->GetTagByKey(group, element);
+ if (found)
+ return found;
+ }
+ if (RefShaDict) {
+ found = RefShaDict->GetTagByKey(group, element);
+ if (found)
+ return found;
+ }
+ return found;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches both the public and the shadow dictionary (when they
+ * exist) for the presence of the DictEntry with given name.
+ * The public dictionary has precedence on the shadow one.
+ * @param Name name of the searched DictEntry
+ * @return Corresponding DictEntry when it exists, NULL otherwise.
+ */
+gdcmDictEntry * gdcmHeader::GetDictEntryByName(string Name) {
+ gdcmDictEntry * found = (gdcmDictEntry*)0;
+ if (!RefPubDict && !RefShaDict) {
+ dbg.Verbose(0, "gdcmHeader::GetDictEntry",
+ "we SHOULD have a default dictionary");
+ }
+ if (RefPubDict) {
+ found = RefPubDict->GetTagByName(Name);
+ if (found)
+ return found;
+ }
+ if (RefShaDict) {
+ found = RefShaDict->GetTagByName(Name);
+ if (found)
+ return found;
+ }
+ return found;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within the public dictionary for element value of
+ * a given tag.
+ * @param group Group of the researched tag.
+ * @param element Element of the researched tag.
+ * @return Corresponding element value when it exists, and the string
+ * "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
+ return PubElValSet.GetElValueByNumber(group, element);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within the public dictionary for element value
+ * representation of a given tag.
+ *
+ * Obtaining the VR (Value Representation) might be needed by caller
+ * 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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
+ gdcmElValue* elem = PubElValSet.GetElementByNumber(group, element);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within the public dictionary for element value of
+ * a given tag.
+ * @param TagName name of the researched element.
+ * @return Corresponding element value when it exists, and the string
+ * "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetPubElValByName(string TagName) {
+ return PubElValSet.GetElValueByName(TagName);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within the elements parsed with the public dictionary for
+ * the element value representation of a given tag.
+ *
+ * Obtaining the VR (Value Representation) might be needed by caller
+ * 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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetPubElValRepByName(string TagName) {
+ gdcmElValue* elem = PubElValSet.GetElementByName(TagName);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+/**
+ * \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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
+ return ShaElValSet.GetElValueByNumber(group, element);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within the elements parsed with the SHADOW dictionary
+ * for the element value representation of a given tag.
+ *
+ * Obtaining the VR (Value Representation) might be needed by caller
+ * 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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
+ gdcmElValue* elem = ShaElValSet.GetElementByNumber(group, element);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+/**
+ * \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.
+ * @return Corresponding element value when it exists, and the string
+ * "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetShaElValByName(string TagName) {
+ return ShaElValSet.GetElValueByName(TagName);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within the elements parsed with the shadow dictionary for
+ * the element value representation of a given tag.
+ *
+ * Obtaining the VR (Value Representation) might be needed by caller
+ * 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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetShaElValRepByName(string TagName) {
+ gdcmElValue* elem = ShaElValSet.GetElementByName(TagName);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
+ string pub = GetPubElValByNumber(group, element);
+ if (pub.length())
+ return pub;
+ return GetShaElValByNumber(group, element);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within elements parsed with the public dictionary
+ * and then within the elements parsed with the shadow dictionary
+ * for the element value representation of a given tag.
+ *
+ * Obtaining the VR (Value Representation) might be needed by caller
+ * 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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
+ string pub = GetPubElValRepByNumber(group, element);
+ if (pub.length())
+ return pub;
+ return GetShaElValRepByNumber(group, element);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \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.
+ * @return Corresponding element value when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetElValByName(string TagName) {
+ string pub = GetPubElValByName(TagName);
+ if (pub.length())
+ return pub;
+ return GetShaElValByName(TagName);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Searches within elements parsed with the public dictionary
+ * and then within the elements parsed with the shadow dictionary
+ * for the element value representation of a given tag.
+ *
+ * Obtaining the VR (Value Representation) might be needed by caller
+ * 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.
+ * @return Corresponding element value representation when it exists,
+ * and the string "gdcm::Unfound" otherwise.
+ */
+string gdcmHeader::GetElValRepByName(string TagName) {
+ string pub = GetPubElValRepByName(TagName);
+ if (pub.length())
+ return pub;
+ return GetShaElValRepByName(TagName);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \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
+ * @param group group of the ElVal to modify
+ * @param element element of the ElVal to modify
+ */
+int gdcmHeader::SetPubElValByNumber(string content, guint16 group,
+ guint16 element)
+{
+ return ( PubElValSet.SetElValueByNumber (content, group, element) );
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \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 ( 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 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 ( ShaElValSet.SetElValueByNumber (content, group, element) );
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \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 ( ShaElValSet.SetElValueByName (content, TagName) );
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Parses the header of the file but WITHOUT loading element values.
+ */
+void gdcmHeader::ParseHeader(bool exception_on_error) throw(gdcmFormatError) {
+ gdcmElValue * newElValue = (gdcmElValue *)0;
+
+ rewind(fp);
+ CheckSwap();
+ while ( (newElValue = ReadNextElement()) ) {
+ SkipElementValue(newElValue);
+ PubElValSet.Add(newElValue);
+ }
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Retrieve the number of columns of image.
+ * @return The encountered size when found, 0 by default.
+ */
+int gdcmHeader::GetXSize(void) {
+ // We cannot check for "Columns" because the "Columns" tag is present
+ // both in IMG (0028,0011) and OLY (6000,0011) sections of the dictionary.
+ string StrSize = GetPubElValByNumber(0x0028,0x0011);
+ if (StrSize == "gdcm::Unfound")
+ return 0;
+ return atoi(StrSize.c_str());
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Retrieve the number of lines of image.
+ * \warning The defaulted value is 1 as opposed to gdcmHeader::GetXSize()
+ * @return The encountered size when found, 1 by default.
+ */
+int gdcmHeader::GetYSize(void) {
+ // We cannot check for "Rows" because the "Rows" tag is present
+ // both in IMG (0028,0010) and OLY (6000,0010) sections of the dictionary.
+ string StrSize = GetPubElValByNumber(0x0028,0x0010);
+ if (StrSize != "gdcm::Unfound")
+ return atoi(StrSize.c_str());
+ if ( IsDicomV3() )
+ return 0;
+ else
+ // The Rows (0028,0010) entry is optional for ACR/NEMA. It might
+ // hence be a signal (1d image). So we default to 1:
+ return 1;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Retrieve the number of planes of volume or the number
+ * of frames of a multiframe.
+ * \warning When present we consider the "Number of Frames" as the third
+ * dimension. When absent we consider the third dimension as
+ * being the "Planes" tag content.
+ * @return The encountered size when found, 1 by default.
+ */
+int gdcmHeader::GetZSize(void) {
+ // Both in DicomV3 and ACR/Nema the consider the "Number of Frames"
+ // as the third dimension.
+ string StrSize = GetPubElValByNumber(0x0028,0x0008);
+ if (StrSize != "gdcm::Unfound")
+ return atoi(StrSize.c_str());
+
+ // We then consider the "Planes" entry as the third dimension [we
+ // cannot retrieve by name since "Planes tag is present both in
+ // IMG (0028,0012) and OLY (6000,0012) sections of the dictionary].
+ StrSize = GetPubElValByNumber(0x0028,0x0012);
+ if (StrSize != "gdcm::Unfound")
+ return atoi(StrSize.c_str());
+ return 1;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Build the Pixel Type of the image.
+ * Possible values are:
+ * - U8 unsigned 8 bit,
+ * - S8 signed 8 bit,
+ * - U16 unsigned 16 bit,
+ * - S16 signed 16 bit,
+ * - U32 unsigned 32 bit,
+ * - S32 signed 32 bit,
+ * \warning 12 bit images appear as 16 bit.
+ * @return
+ */
+string gdcmHeader::GetPixelType(void) {
+ string BitsAlloc;
+ BitsAlloc = GetElValByName("Bits Allocated");
+ if (BitsAlloc == "gdcm::Unfound") {
+ dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
+ BitsAlloc = string("16");
+ }
+ if (BitsAlloc == "12")
+ BitsAlloc = string("16");
+
+ string Signed;
+ Signed = GetElValByName("Pixel Representation");
+ if (Signed == "gdcm::Unfound") {
+ dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
+ BitsAlloc = string("0");
+ }
+ if (Signed == "0")
+ Signed = string("U");
+ else
+ Signed = string("S");
+
+ return( BitsAlloc + Signed);
+}
+
+/**
+ * \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;
+}
+
+/**
+ * \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.
+ * \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;
+
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Loads the element values of all the elements present in the
+ * 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);
+ }
+}
+
+void gdcmHeader::PrintPubElVal(ostream & os) {
+ PubElValSet.Print(os);
+}
+
+void gdcmHeader::PrintPubDict(ostream & os) {
+ RefPubDict->Print(os);
+}
+
+int gdcmHeader::Write(FILE * fp, FileType type) {
+ return PubElValSet.Write(fp, type);