dataelementdictionary.cs

Open Dicom source code C#

                            }
                            else
                            {
                                DataElementDictionaryEntry entry = 
                                    new DataElementDictionaryEntry(tag, 
                                        result[1].Trim(), result[2].Trim(), 
                                        result[3].Trim(), retired);
                                Add(entry);
                            }
                        }
                        catch (Exception e)
                        {
                            throw new DicomException("Wrong entry in line " +
                                lineNumber.ToString() + ": " + e.Message);
                        }
                    }
                    else
                        throw new DicomException("Wrong entry in line " +
                            lineNumber.ToString() + ".");
                }
                line = textReader.ReadLine();
                lineNumber++;
            }            
        }

        protected virtual void LoadFromXml(TextReader textReader)
        {
            XmlTextReader xmlTextReader = new XmlTextReader(textReader);
            string tag = null;
            string description = null;
            string vr = null;
            string vm = null;
            string retired = null;
            while (xmlTextReader.Read())
            {
                switch(xmlTextReader.Name)
                {
                    case "DictionaryEntry":
                        retired = xmlTextReader["retired"];
                        break;
                    case "Tag":
                        xmlTextReader.MoveToContent();
                        tag = xmlTextReader.ReadString();
                        break;
                    case "Description":
                        xmlTextReader.MoveToContent();
                        description = xmlTextReader.ReadString();
                        break;
                    case "VR":
                        xmlTextReader.MoveToContent();
                        vr = xmlTextReader.ReadString();
                        break;
                    case "VM":
                        xmlTextReader.MoveToContent();
                        vm = xmlTextReader.ReadString();
                        break;
                }
                if (tag != null && description != null && vr != null && 
                    vm != null)
                {
                    try
                    {
                        if (Regex.IsMatch(tag.ToLower(), "(50xx|60xx)"))
                        {
                            // Dicom repeating groups
                            for (int i = 0; i <= 0x1E; i += 2)
                            {
                                string uniqueTag = tag.ToLower()
                                   .Replace("xx", string.Format("{0:X2}", i));
                                DataElementDictionaryEntry entry = 
                                    new DataElementDictionaryEntry(
                                        uniqueTag, 
                                        description.Trim(),
                                        vr.Trim(), vm.Trim(), retired);
                                Add(entry);
                            }
                        }
                        else if (Regex.IsMatch(tag.ToLower(), "0020,31xx"))
                        {
                            // Not official, but useful!
                            for (int i = 0; i <= 0xFF; i++)
                            {
                               string uniqueTag = tag.ToLower()
                                  .Replace("xx", string.Format("{0:X2}", i));
                               DataElementDictionaryEntry entry = 
                                   new DataElementDictionaryEntry(
                                       uniqueTag, 
                                       description.Trim(), vr.Trim(),
                                       vm.Trim(), retired);
                               Add(entry);
                            }
                        }
                        else
                        {
                            DataElementDictionaryEntry entry = 
                                new DataElementDictionaryEntry(tag, 
                                    description.Trim(),
                                    vr.Trim(), vm.Trim(), retired);
                            Add(entry);
                        }
                    }
                    catch (Exception e)
                    {
                        throw new DicomException("Wrong entry at tag " +
                            tag + ": " + e.Message);
                    }
                    tag = description = vr = vm = retired = null;
                }                
            }
            xmlTextReader.Close();
        }

        /// <summary>
        ///     Re-creates a data element dictionary instance and fills it
        ///     with entries from the specified data element dictionary file
        ///     of given file format.
        /// </summary>
        public void LoadFrom(string fileName, DictionaryFileFormat fileFormat)
        {
            if (! IsEmpty) Clear();
            StreamReader streamReader = new StreamReader(fileName);
            switch (fileFormat)
            {
                case DictionaryFileFormat.BinaryFile:
                    LoadFromBinary(streamReader); break;
                case DictionaryFileFormat.PropertyFile:
                    LoadFromProperty(streamReader); break;
                case DictionaryFileFormat.CsvFile:
                    LoadFromCsv(streamReader); break;
                case DictionaryFileFormat.XmlFile:
                    LoadFromXml(streamReader); break;
            }
            streamReader.Close();
            if (global == null) Global = this;
        }

        private void SaveAsBinary(StreamWriter streamWriter, 
            DataElementDictionaryEntry[] entryArray)
        {
            streamWriter.AutoFlush = true;
            BinaryWriter binaryWriter = new BinaryWriter(streamWriter.BaseStream);
            foreach (DataElementDictionaryEntry entry in entryArray)
            {
                binaryWriter.Write(int.Parse(entry.Tag.Group,
                    NumberStyles.HexNumber));
                binaryWriter.Write(int.Parse(entry.Tag.Element,
                    NumberStyles.HexNumber));
                binaryWriter.Write(entry.Description.Length);
                streamWriter.Write(entry.Description);
                if (entry.VR.IsUndefined)
                    streamWriter.Write("  ");
                else
                    streamWriter.Write(entry.VR.Name);
                binaryWriter.Write(entry.VM.Value.Length);
                streamWriter.Write(entry.VM.Value);
                binaryWriter.Write(entry.IsRetired);
            }
        }

        private void SaveAsProperty(TextWriter textWriter, 
            DataElementDictionaryEntry[] entryArray)
        {
            textWriter.WriteLine("# " + fileComment);
            foreach (DataElementDictionaryEntry entry in entryArray)
            {
                if (entry.IsRetired)
                    textWriter.WriteLine(entry.Tag.ToString() + " = " + 
                        entry.Description + ", " + entry.VR.Name + 
                        ", " + entry.VM + ", RET");
                else
                    textWriter.WriteLine(entry.Tag.ToString() + " = " + 
                        entry.Description + ", " + entry.VR.Name + 
                        ", " + entry.VM);
            }
        }

        private void SaveAsCsv(TextWriter textWriter, 
            DataElementDictionaryEntry[] entryArray)
        {
            textWriter.WriteLine("# " + fileComment);
            foreach (DataElementDictionaryEntry entry in entryArray)
            {
                if (entry.IsRetired)
                    textWriter.WriteLine(entry.Tag.ToString() + "; " + 
                        entry.Description + "; " + entry.VR.Name + 
                        "; " + entry.VM + "; RET");
                else
                    textWriter.WriteLine(entry.Tag.ToString() + "; " + 
                        entry.Description + "; " + entry.VR.Name + 
                        "; " + entry.VM);
            }
        }

        protected virtual void SaveAsXml(TextWriter textWriter, 
            DataElementDictionaryEntry[] entryArray)
        {
            XmlTextWriter xmlTextWriter = new XmlTextWriter(textWriter);
            xmlTextWriter.Formatting = Formatting.Indented;
            xmlTextWriter.Indentation = 4;
            xmlTextWriter.WriteStartDocument();
            xmlTextWriter.WriteComment(" " + fileComment + " ");
            xmlTextWriter.WriteStartElement("DicomDataDictionary");
            foreach (DataElementDictionaryEntry entry in entryArray)
            {
                xmlTextWriter.WriteStartElement("DictionaryEntry");
                if (entry.IsRetired)
                    xmlTextWriter.WriteAttributeString("retired", "true");
                xmlTextWriter.WriteElementString("Tag", 
                    entry.Tag.ToString());
                xmlTextWriter.WriteElementString("Description",
                    entry.Description);
                xmlTextWriter.WriteElementString("VR", entry.VR.Name);
                xmlTextWriter.WriteElementString("VM", entry.VM.Value);
                xmlTextWriter.WriteEndElement();
            }
            xmlTextWriter.WriteEndElement();
            xmlTextWriter.Close();
        }

        /// <summary>
        ///     Saves the entire data element dictionary instance content to
        ///     file using specified file format.
        /// </summary>
        public void SaveTo(string fileName, DictionaryFileFormat fileFormat)
        {
            StreamWriter streamWriter = new StreamWriter(fileName);
            switch (fileFormat)
            {
                case DictionaryFileFormat.BinaryFile:
                    SaveAsBinary(streamWriter, ToArray()); break;
                case DictionaryFileFormat.PropertyFile:
                    SaveAsProperty(streamWriter, ToArray()); break;
                case DictionaryFileFormat.CsvFile:
                    SaveAsCsv(streamWriter, ToArray()); break;
                case DictionaryFileFormat.XmlFile:
                    SaveAsXml(streamWriter, ToArray()); break;
            }
            streamWriter.Close();
        }

        /// <summary>
        ///     Returns the entire data element dictionary as array of
        ///     <see cref="DataElementDictionaryEntry" />.
        /// </summary>
        public DataElementDictionaryEntry[] ToArray()
        {
            DataElementDictionaryEntry[] entryArray = 
                new DataElementDictionaryEntry[hashTable.Count];
            hashTable.Values.CopyTo(entryArray, 0);
            Array.Sort(entryArray);
            return entryArray;
        }

        /// <summary>
        ///     Adds a new data element dictionary entry to a data element
        ///     dictionary instance.
        /// </summary>
        public void Add(DataElementDictionaryEntry entry)
        {
            if (entry != null)
            {
                if ( ! Contains(entry.Tag))
                    hashTable.Add(entry.Tag.ToString(), entry);
                else
                    throw new DicomException(
                        "Tag already exists in data element dictionary.", 
                        "entry.Tag", entry.Tag.ToString());
            }
            else
                throw new DicomException("entry is null.", "entry");
        }

        /// <summary>
        ///     Clears all data element dictionary properties.
        /// </summary>
        public void Clear()
        {
            hashTable.Clear();
        }

        /// <summary>
        ///     Determines whether a DICOM tag already is in use within a data
        ///     element dictionary instance.
        /// </summary>      
        public bool Contains(Tag tag)
        {
            return hashTable.Contains(tag.ToString());
        }

        /// <summary>
        ///     Returns a dictionary entry by specified DICOM tag.
        /// </summary>      
        public DataElementDictionaryEntry GetDictionaryEntry(Tag tag)
        {
            return this[tag];
        }
    }
    
}