示例#1
0
        /// <summary>
        /// Combines the parsed tags with the current dictionary.  Record any differences found, or existing
        /// dictionary entries that are not found in the new list.
        /// </summary>
        static void Combine()
        {
            StreamWriter differences = new StreamWriter("differences.txt");
            StreamWriter missing     = new StreamWriter("missing.txt");

            // tags contains what we were able to successfully parse this time
            // compare that to the dictionary, to see what may be missing or different

            // go through the known dictionary
            foreach (Tag tag in EK.Capture.Dicom.DicomToolKit.Dictionary.Instance)
            {
                string key = tag.ToString().ToUpper();
                // if it is already known, but was not found this time, add it in and record it as missing
                if (!tags.ContainsKey(key))
                {
                    missing.WriteLine(String.Format("Tag {0} {1}", key, tag.Description));
                    tags.Add(tag.ToString().ToUpper(), new Tag2(tag));
                }
                else
                {
                    Tag2   temp  = tags[key];
                    string check = temp.Check ? "*" : String.Empty;
                    // if we find any differences, record the differences
                    string difference = String.Empty;
                    if (tag.Description.Trim() != temp.Description.Trim())
                    {
                    }
                    if (tag.VR != temp.VR)
                    {
                        if (difference != String.Empty)
                        {
                            difference += " ";
                        }
                        difference += String.Format("vr {0} >> {1}", tag.VR, temp.VR);
                    }
                    if (tag.VM != temp.VM)
                    {
                        if (difference != String.Empty)
                        {
                            difference += " ";
                        }
                        difference += String.Format("vm {0} >> {1}", tag.VM, temp.VM);
                    }
                    if (difference.Length > 0)
                    {
                        differences.WriteLine(String.Format("{0}Tag {1} {2}", check, key, difference));
                    }
                }
            }

            differences.Close();
            differences.Dispose();

            missing.Close();
            missing.Dispose();
        }
示例#2
0
        /// <summary>
        /// Parse a combined line into a Tag
        /// </summary>
        /// <param name="line">The line to parse</param>
        /// <returns>A Tag</returns>
        static Tag2 Parse(string line, bool check)
        {
            // we break each line into words based on whitespace
            string[] strings = line.Split(" \t".ToCharArray());

            Tag2 tag = null;

            try
            {
                tag = Tag2.Parse(strings[0].ToUpper().Replace('X', '0'));
                // retired tags are at the end of the line
                tag.Retired = (strings[strings.Length - 1] == "RET");

                tag.VM          = String.Empty;
                tag.VR          = String.Empty;
                tag.Description = String.Empty;

                try
                {
                    // the next part of the line looks somethign like this
                    // Related General SOP Class UID RelatedGeneralSOPClassUI D UI 1-n
                    // the spaces are generally there because of the lines being appended
                    // we have the name with spaces, the name without spaces, VR and VM
                    int index = 2;
                    tag.Description = EK.Capture.Dicom.DicomToolKit.Dictionary.ModifyWordForDescription(strings[1]);
                    string first = EK.Capture.Dicom.DicomToolKit.Dictionary.ModifyWordForEnumeration(strings[1]).ToLower();
                    // we keep adding up the description until we encounter a word that
                    // starts with the first word, in the example above, the first word is Related
                    // and we want to stop adding up the description at RelatedGeneralSOPClassUI
                    while (!strings[index].ToLower().Contains(first))
                    {
                        tag.Description += " " + EK.Capture.Dicom.DicomToolKit.Dictionary.ModifyWordForDescription(strings[index++]);
                    }
                    tag.Check = false;
                }
                catch
                {
                    // if we encounter any problems, i.e. never match the first word,
                    // we have to check the result
                    tag.Check  = true;;
                    tag.Reason = "never matched first word";
                }

                // we have the tag, we have the description, now we just need to get the VM and VR
                // there are four things to parse, tag, description, VR, and VM
                if (strings.Length >= 4)
                {
                    // VM is the last word, or second to the last if RET is present
                    tag.VM = (tag.Retired) ? strings[strings.Length - 2] : strings[strings.Length - 1];
                    // if we do not recognize the multiplicity, check it
                    if (!multiplicity.Contains(tag.VM))
                    {
                        tag.Check  = true;
                        tag.Reason = "unknown value multiplicity";
                        tag.VM     = "?";
                    }
                    // VR is the second or third to last string
                    tag.VR = (tag.Retired) ? strings[strings.Length - 3] : strings[strings.Length - 2];
                    // if we do recognize it, check it
                    if (!EK.Capture.Dicom.DicomToolKit.Dictionary.DicomTypes.Contains(tag.VR))
                    {
                        tag.Check  = true;
                        tag.Reason = "unknown value representation";
                        tag.VR     = "?";
                    }
                    if (tag.VM != "1" && !multipletypes.Contains(tag.VR))
                    {
                        multipletypes.Add(tag.VR);
                    }
                    // if the tag can have multiple VRs, we find the word "or", and we need to check
                    for (int n = 3; n < strings.Length; n++)
                    {
                        if (strings[n] == "or")
                        {
                            tag.Check  = true;
                            tag.Reason = "possible multiple VRs";
                            tag.VR     = "?";
                        }
                    }
                }

                // if we are going to check the tag, we may as well give it all the text we have.
                if (tag.Check)
                {
                    tag.Description = line.Substring(12);
                }
            }
            catch
            {
                tag = null;
            }
            if (tag == null || tag.VM == String.Empty || tag.VR == String.Empty || tag.Description == String.Empty)
            {
                tag = null;
            }
            return(tag);
        }
示例#3
0
        /// <summary>
        /// Scans the input file and creates two sets of tags, those that are accepted and
        /// those that are rejected.  The results are written to two text files, and the
        /// accepted tags are also added to a collection of tags.
        /// </summary>
        /// <param name="filename">The filename to parse</param>
        static void Extract(string filename)
        {
            string line, next;

            tags = new SortedDictionary <string, Tag2>();

            StreamWriter cleaned  = new StreamWriter("cleaned.txt");
            StreamWriter rejected = new StreamWriter("rejected.txt");

            StreamReader input = new StreamReader(filename);

            line = input.ReadLine();
            //as long as there are lines to read in the input file
            while ((next = input.ReadLine()) != null)
            {
                // assume that we will get a clean parse of a tag
                bool check = false;
                // we can automatically reject some common lines
                if (IsEasilyRejected(line))
                {
                    rejected.WriteLine(line);
                }
                else
                {
                    // some lines are split into several lines
                    // we need to combine partial lines until they fit the proper format
                    // the proper format is a dicom tag followed by a description and keyword, a VR, a VM, and then maybe a "RET"
                    // the tag is strings[0]
                    // "RET" may be at strings[strings.Length - 1]
                    // if the tag is not retired the VR is at strings[strings.Length - 2]
                    // the description is everything after the tag and before strings[strings.Length - 3]

                    // append each next line from the input as long as
                    // they do not start with a DICOM tag
                    while (!Matches(DicomTagPattern, next))
                    {
                        if (next != null)
                        {
                            // ignore the next line if it is a page number or other recognizable string
                            if (IsEasilyRejected(next))
                            {
                                rejected.WriteLine(next);
                                next = input.ReadLine();
                                continue;
                            }
                        }
                        // we have had to append lines to get a complete line
                        // we need to check the output to make sure.
                        check = true;
                        // append it with a space
                        line += " ";
                        line += next;
                        next  = input.ReadLine();
                        if (next == null)
                        {
                            break;
                        }
                    }

                    // when we reach here, we may have a properly combined line

                    string key = line.Substring(0, 11).ToUpper();
                    // if the line begins with a DICOM tag
                    if (Matches(DicomTagPattern, key))
                    {
                        // try and parse what we have put together
                        Tag2 tag = Parse(line, check);
                        if (tag != null)
                        {
                            cleaned.WriteLine(line);
                            tags.Add(tag.Name.ToUpper(), tag);
                        }
                        else
                        {
                            rejected.WriteLine(line);
                        }
                    }
                    // reject everything else
                    else
                    {
                        rejected.WriteLine(line);
                    }
                }
                line = next;
            }
            // the above loop drops the last line.

            input.Close();
            input.Dispose();

            cleaned.Close();
            cleaned.Dispose();

            rejected.Close();
            rejected.Dispose();
        }