示例#1
0
		public SopInstance(InstanceXml xml, Series parent)
		{
			_xml = xml;
			ParentSeries = parent;
			_sequenceHasExcludedTags = new Dictionary<uint, bool>();

			_metaInfo = new DicomAttributeCollection();
			if (xml.TransferSyntax != null)
			{
				string transferSyntax = xml.TransferSyntax.UidString;
				if (!String.IsNullOrEmpty(transferSyntax))
					_metaInfo[DicomTags.TransferSyntaxUid].SetString(0, transferSyntax);
			}

			if (xml.SopClass != null)
			{
				string sopClass = xml.SopClass.Uid;
				if (!String.IsNullOrEmpty(sopClass))
					_metaInfo[DicomTags.SopClassUid].SetString(0, sopClass);
			}
		}
        public StreamingSopDataSource(InstanceXml instanceXml, IDicomFileLoader loader)
            : base(new DicomFile("", new DicomAttributeCollection(), instanceXml.Collection))
        {
            if (!loader.CanLoadCompleteHeader)
            {
                throw new ArgumentException("Loader must be capable of retrieving the full image header.", "loader");
            }
            if (!loader.CanLoadFramePixelData)
            {
                throw new ArgumentException("Loader must be capable of loading frame pixel data.", "loader");
            }

            _loader = loader;
            //These don't get set properly for instance xml.
            var sourceFile = (DicomFile)SourceMessage;

            sourceFile.TransferSyntaxUid          = instanceXml.TransferSyntax.UidString;
            sourceFile.MediaStorageSopInstanceUid = instanceXml.SopInstanceUid;

            sourceFile.MetaInfo[DicomTags.SopClassUid].SetString(0,
                                                                 instanceXml.SopClass == null
                                                                             ? instanceXml[DicomTags.SopClassUid].ToString()
                                                                             : instanceXml.SopClass.Uid);
        }
示例#3
0
        internal SopInstance(Series parentSeries, InstanceXml instanceXml)
        {
            _parentSeries = parentSeries;
            _xml          = instanceXml;
            _metaInfo     = new DicomAttributeCollection();

            if (instanceXml.TransferSyntax != null)
            {
                string transferSyntax = instanceXml.TransferSyntax.UidString;
                if (!String.IsNullOrEmpty(transferSyntax))
                {
                    _metaInfo[DicomTags.TransferSyntaxUid].SetString(0, transferSyntax);
                }
            }

            if (instanceXml.SopClass != null)
            {
                string sopClass = instanceXml.SopClass.Uid;
                if (!String.IsNullOrEmpty(sopClass))
                {
                    _metaInfo[DicomTags.SopClassUid].SetString(0, sopClass);
                }
            }
        }
示例#4
0
		private SopInstance GetSopInstance(InstanceXml xml)
		{
			return new SopInstance(xml, this, _dicomFileLoader);
		}
 public TestInstance(InstanceXml instanceXml, DicomFile real) : base(instanceXml)
 {
     _real = real;
 }
示例#6
0
        private void buttonMoveScuMove_Click(object sender, EventArgs e)
        {
            if (_moveScu != null)
            {
                if (_moveScu.Status == ScuOperationStatus.Running)
                {
                    _moveScu.Cancel();
                    return;
                }
                buttonMoveScuMove.Text = "Move";
                _moveScu.Dispose();
                _moveScu = null;
            }

            var theDoc = new XmlDocument();

            buttonMoveScuMove.Text = "Cancel";

            try
            {
                theDoc.LoadXml(textBoxMoveMessage.Text);
                var instanceXml = new InstanceXml(theDoc.DocumentElement, null);
                DicomAttributeCollection queryMessage = instanceXml.Collection;

                if (queryMessage == null)
                {
                    Platform.Log(LogLevel.Error, "Unexpected error parsing move message");
                    return;
                }



                if (comboBoxMoveScuQueryType.SelectedIndex == 0)
                {
                    _moveScu = new StudyRootMoveScu(textBoxMoveScuLocalAe.Text, textBoxMoveScuRemoteAe.Text, textBoxMoveScuRemoteHost.Text,
                                                    int.Parse(textBoxMoveScuRemotePort.Text), textBoxMoveScuMoveDestination.Text);
                }
                else
                {
                    _moveScu = new PatientRootMoveScu(textBoxMoveScuLocalAe.Text, textBoxMoveScuRemoteAe.Text,
                                                      textBoxMoveScuRemoteHost.Text,
                                                      int.Parse(textBoxMoveScuRemotePort.Text),
                                                      textBoxMoveScuMoveDestination.Text);
                }
                if (queryMessage.Contains(DicomTags.PatientId))
                {
                    var array = queryMessage[DicomTags.PatientId].Values as string[];
                    if (array != null)
                    {
                        foreach (string s in array)
                        {
                            _moveScu.AddPatientId(s);
                        }
                    }
                }
                if (queryMessage.Contains(DicomTags.StudyInstanceUid))
                {
                    var array = queryMessage[DicomTags.StudyInstanceUid].Values as string[];
                    if (array != null)
                    {
                        foreach (string s in array)
                        {
                            _moveScu.AddStudyInstanceUid(s);
                        }
                    }
                }
                if (queryMessage.Contains(DicomTags.SeriesInstanceUid))
                {
                    var array = queryMessage[DicomTags.SeriesInstanceUid].Values as string[];
                    if (array != null)
                    {
                        foreach (string s in array)
                        {
                            _moveScu.AddSeriesInstanceUid(s);
                        }
                    }
                }
                if (queryMessage.Contains(DicomTags.SopInstanceUid))
                {
                    var array = queryMessage[DicomTags.SopInstanceUid].Values as string[];
                    if (array != null)
                    {
                        foreach (string s in array)
                        {
                            _moveScu.AddSopInstanceUid(s);
                        }
                    }
                }

                _moveScu.ImageMoveCompleted += delegate(object o, EventArgs args)
                {
                    var eventScu = o as MoveScuBase;
                    if (eventScu != null)
                    {
                        Platform.Log(LogLevel.Info,
                                     "Total SubOps: {0}, Remaining SubOps {1}, Success SubOps: {2}, Failure SubOps: {3}, Warning SubOps: {4}, Failure Description: {5}",
                                     eventScu.TotalSubOperations,
                                     eventScu.RemainingSubOperations,
                                     eventScu.SuccessSubOperations,
                                     eventScu.FailureSubOperations,
                                     eventScu.WarningSubOperations,
                                     eventScu.FailureDescription);
                    }
                };
                _moveScu.BeginMove(delegate {
                    Invoke(new Action <string>(delegate { buttonMoveScuMove.Text = "Move"; }), new object[] { "Move" });
                }, this);
            }
            catch (Exception x)
            {
                Platform.Log(LogLevel.Error, x, "Unable to perform move");
                buttonMoveScuMove.Text = "Move";
            }
        }
示例#7
0
        private void buttonQueryScuSearch_Click(object sender, EventArgs e)
        {
            if (_findScu != null)
            {
                if (_findScu.Status == ScuOperationStatus.Running)
                {
                    return;
                }
                _findScu.Dispose();
                _findScu = null;
            }
            var theDoc = new XmlDocument();

            try
            {
                theDoc.LoadXml(textBoxQueryMessage.Text);
                var instanceXml = new InstanceXml(theDoc.DocumentElement, null);
                DicomAttributeCollection queryMessage = instanceXml.Collection;

                if (queryMessage == null)
                {
                    Platform.Log(LogLevel.Error, "Unexpected error parsing query message");
                }

                int maxResults;
                if (!int.TryParse(textBoxQueryScuMaxResults.Text, out maxResults))
                {
                    maxResults = -1;
                }

                IList <DicomAttributeCollection> resultsList;
                if (comboBoxQueryScuQueryType.SelectedIndex == 0)
                {
                    _findScu = new StudyRootFindScu
                    {
                        MaxResults = maxResults
                    };
                    _findScu.BeginFind(textBoxQueryScuLocalAe.Text,
                                       textBoxQueryScuRemoteAe.Text,
                                       textBoxQueryScuRemoteHost.Text,
                                       int.Parse(textBoxQueryScuRemotePort.Text), queryMessage, delegate
                    {
                        foreach (DicomAttributeCollection msg in _findScu.Results)
                        {
                            Platform.Log(LogLevel.Info, msg.DumpString);
                        }
                    }, this);
                }
                else
                {
                    _findScu = new PatientRootFindScu
                    {
                        MaxResults = maxResults
                    };
                    _findScu.BeginFind(textBoxQueryScuLocalAe.Text,
                                       textBoxQueryScuRemoteAe.Text,
                                       textBoxQueryScuRemoteHost.Text,
                                       int.Parse(textBoxQueryScuRemotePort.Text), queryMessage, delegate
                    {
                        foreach (DicomAttributeCollection msg in _findScu.Results)
                        {
                            Platform.Log(LogLevel.Info, msg.DumpString);
                        }
                    }, this);
                }
            }
            catch (Exception x)
            {
                Platform.Log(LogLevel.Error, x, "Unable to perform query");
            }
        }
 public void TestXmlEntityBasicUnescaping()
 {
     Assert.AreEqual(string.Empty, InstanceXml.TestXmlUnescapeString(null));
     Assert.AreEqual(string.Empty, InstanceXml.TestXmlUnescapeString(string.Empty));
     Assert.AreEqual("the 123,4567,890 jumpy foxes lazed over the quick brown dog", InstanceXml.TestXmlUnescapeString("the 123,4567,890 jumpy foxes lazed over the quick brown dog"));
     Assert.AreEqual("&amp;\"<'>", InstanceXml.TestXmlUnescapeString("&amp;amp;&quot;&lt;&apos;&gt;"));
     Assert.AreEqual("<a href=\"http://garba/\">tom&jerry's</a>", InstanceXml.TestXmlUnescapeString("&lt;a href=&quot;http://garba/&quot;&gt;tom&amp;jerry&apos;s&lt;/a&gt;"));
 }
        public void TestValidXmlOutput()
        {
            using (MemoryStream ms = new MemoryStream())
            {
                // generate the dataset
                DicomAttributeCollection dataset = new DicomAttributeCollection();
                {
                    Trace.WriteLine("Generating dataset using Unicode data");
                    Trace.WriteLine(" * US-ASCII Characters (0-127)");
                    // the line feed characters /r and /n are deliberately excluded because
                    // automatic line end handling would otherwise mangle them in the DicomAttribute
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0, 0xA)));
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xB, 0xD)));
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xE, 128)));
                    Trace.WriteLine(" * Extended ASCII Characters (128-255)");
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(128, 256)));
                    Trace.WriteLine(" * Unicode Basic Multilingual Plane");
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(256, 0x4000)));
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0x4000, 0x8000)));
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0x8000, 0xC000)));
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xC000, 0xD800)));
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xE000, 0x10000)));
                    Trace.WriteLine(" * Unicode UTF-16 Surrogate Pairs");
                    dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateSurrogatesBinaryString()));
                }

                // generate the InstanceXml document and dump into the MemoryStream
                {
                    XmlDocument xmlDocument = new XmlDocument();
                    xmlDocument.AppendChild(xmlDocument.CreateXmlDeclaration("1.0", "UTF-8", null));
                    InstanceXml instanceXml = new InstanceXml(dataset, SopClass.RawDataStorage, TransferSyntax.ExplicitVrLittleEndian);
                    Assert.IsTrue(instanceXml[DicomTags.FailedAttributesSequence].Count > 0);
                    XmlElement xmlRoot = xmlDocument.CreateElement("test");
                    xmlDocument.AppendChild(xmlRoot);
                    XmlElement xmlElement = instanceXml.GetMemento(xmlDocument, new StudyXmlOutputSettings());
                    xmlRoot.AppendChild(xmlElement);
                    XmlWriter xmlWriter = XmlWriter.Create(ms);
                    xmlDocument.WriteTo(xmlWriter);
                    xmlWriter.Close();
                    Assert.IsTrue(ms.Length > 0);
                    Trace.WriteLine(string.Format("XML fragment length: {0}", ms.Length));
                }

                // write the xml to a file
                ms.Seek(0, SeekOrigin.Begin);
                using (FileStream fs = File.OpenWrite("InstanceXmlTests.TestValidXmlOutput.Result.xml"))
                {
                    ms.WriteTo(fs);
                    fs.Close();
                }

                // parse and validate the xml using .NET
                ms.Seek(0, SeekOrigin.Begin);
                {
                    XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
                    xmlReaderSettings.CheckCharacters  = true;
                    xmlReaderSettings.ConformanceLevel = ConformanceLevel.Fragment;
                    XmlReader xmlReader = XmlReader.Create(ms, xmlReaderSettings);
                    while (xmlReader.Read())
                    {
                    }
                    xmlReader.Close();
                }

                // read it back as an InstanceXml
                ms.Seek(0, SeekOrigin.Begin);
                {
                    XmlDocument xmlDocument = new XmlDocument();
                    xmlDocument.Load(ms);
                    InstanceXml instanceXml = new InstanceXml(xmlDocument.GetElementsByTagName("test")[0].FirstChild, new DicomAttributeCollection());
                    Assert.IsTrue(instanceXml[DicomTags.FailedAttributesSequence].Count > 0);

                    int i = 0;
                    Trace.WriteLine("Validating decoded dataset for correct Unicode data");
                    Trace.WriteLine(" * US-ASCII Characters (0-127)");
                    // the line feed characters /r and /n are deliberately excluded because
                    // automatic line end handling would otherwise mangle them in the DicomAttribute
                    Assert.AreEqual(GenerateBinaryString(0, 0xA), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Assert.AreEqual(GenerateBinaryString(0xB, 0xD), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Assert.AreEqual(GenerateBinaryString(0xE, 128), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Trace.WriteLine(" * Extended ASCII Characters (128-255)");
                    Assert.AreEqual(GenerateBinaryString(128, 256), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Trace.WriteLine(" * Unicode Basic Multilingual Plane");
                    Assert.AreEqual(GenerateBinaryString(256, 0x4000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Assert.AreEqual(GenerateBinaryString(0x4000, 0x8000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Assert.AreEqual(GenerateBinaryString(0x8000, 0xC000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Assert.AreEqual(GenerateBinaryString(0xC000, 0xD800), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Assert.AreEqual(GenerateBinaryString(0xE000, 0x10000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                    Trace.WriteLine(" * Unicode UTF-16 Surrogate Pairs");
                    Assert.AreEqual(GenerateSurrogatesBinaryString(), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
                }

                ms.Close();
            }
        }
 public StreamingSopDataSource(InstanceXml instanceXml, ISopDicomFileLoader loader)
     : base(instanceXml)
 {
     _loader = loader;
     CheckLoaderCapabilities();
 }
示例#11
0
		public void TestValidXmlOutput()
		{
			using (MemoryStream ms = new MemoryStream())
			{
				// generate the dataset
				DicomAttributeCollection dataset = new DicomAttributeCollection();
				{
					Trace.WriteLine("Generating dataset using Unicode data");
					Trace.WriteLine(" * US-ASCII Characters (0-127)");
					// the line feed characters /r and /n are deliberately excluded because
					// automatic line end handling would otherwise mangle them in the DicomAttribute
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0, 0xA)));
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xB, 0xD)));
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xE, 128)));
					Trace.WriteLine(" * Extended ASCII Characters (128-255)");
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(128, 256)));
					Trace.WriteLine(" * Unicode Basic Multilingual Plane");
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(256, 0x4000)));
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0x4000, 0x8000)));
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0x8000, 0xC000)));
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xC000, 0xD800)));
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateBinaryString(0xE000, 0x10000)));
					Trace.WriteLine(" * Unicode UTF-16 Surrogate Pairs");
					dataset[DicomTags.FailedAttributesSequence].AddSequenceItem(CreateSequenceItem(GenerateSurrogatesBinaryString()));
				}

				// generate the InstanceXml document and dump into the MemoryStream
				{
					XmlDocument xmlDocument = new XmlDocument();
					xmlDocument.AppendChild(xmlDocument.CreateXmlDeclaration("1.0", "UTF-8", null));
					InstanceXml instanceXml = new InstanceXml(dataset, SopClass.RawDataStorage, TransferSyntax.ExplicitVrLittleEndian);
					Assert.IsTrue(instanceXml[DicomTags.FailedAttributesSequence].Count > 0);
					XmlElement xmlRoot = xmlDocument.CreateElement("test");
					xmlDocument.AppendChild(xmlRoot);
					XmlElement xmlElement = instanceXml.GetMemento(xmlDocument, new StudyXmlOutputSettings());
					xmlRoot.AppendChild(xmlElement);
					XmlWriter xmlWriter = XmlWriter.Create(ms);
					xmlDocument.WriteTo(xmlWriter);
					xmlWriter.Close();
					Assert.IsTrue(ms.Length > 0);
					Trace.WriteLine(string.Format("XML fragment length: {0}", ms.Length));
				}

				// write the xml to a file
				ms.Seek(0, SeekOrigin.Begin);
				using (FileStream fs = File.OpenWrite("InstanceXmlTests.TestValidXmlOutput.Result.xml"))
				{
					ms.WriteTo(fs);
					fs.Close();
				}

				// parse and validate the xml using .NET
				ms.Seek(0, SeekOrigin.Begin);
				{
					XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
					xmlReaderSettings.CheckCharacters = true;
					xmlReaderSettings.ConformanceLevel = ConformanceLevel.Fragment;
					XmlReader xmlReader = XmlReader.Create(ms, xmlReaderSettings);
					while (xmlReader.Read()) {}
					xmlReader.Close();
				}

				// read it back as an InstanceXml
				ms.Seek(0, SeekOrigin.Begin);
				{
					XmlDocument xmlDocument = new XmlDocument();
					xmlDocument.Load(ms);
					InstanceXml instanceXml = new InstanceXml(xmlDocument.GetElementsByTagName("test")[0].FirstChild, new DicomAttributeCollection());
					Assert.IsTrue(instanceXml[DicomTags.FailedAttributesSequence].Count > 0);

					int i = 0;
					Trace.WriteLine("Validating decoded dataset for correct Unicode data");
					Trace.WriteLine(" * US-ASCII Characters (0-127)");
					// the line feed characters /r and /n are deliberately excluded because
					// automatic line end handling would otherwise mangle them in the DicomAttribute
					Assert.AreEqual(GenerateBinaryString(0, 0xA), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Assert.AreEqual(GenerateBinaryString(0xB, 0xD), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Assert.AreEqual(GenerateBinaryString(0xE, 128), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Trace.WriteLine(" * Extended ASCII Characters (128-255)");
					Assert.AreEqual(GenerateBinaryString(128, 256), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Trace.WriteLine(" * Unicode Basic Multilingual Plane");
					Assert.AreEqual(GenerateBinaryString(256, 0x4000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Assert.AreEqual(GenerateBinaryString(0x4000, 0x8000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Assert.AreEqual(GenerateBinaryString(0x8000, 0xC000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Assert.AreEqual(GenerateBinaryString(0xC000, 0xD800), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Assert.AreEqual(GenerateBinaryString(0xE000, 0x10000), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
					Trace.WriteLine(" * Unicode UTF-16 Surrogate Pairs");
					Assert.AreEqual(GenerateSurrogatesBinaryString(), ReadSequenceItem(instanceXml[DicomTags.FailedAttributesSequence], i++));
				}

				ms.Close();
			}
		}
示例#12
0
 public BasicXmlSopDataSource(InstanceXml instanceXml, DicomStreamOpener streamOpener)
     : base(instanceXml)
 {
     _streamOpener = streamOpener;
 }
示例#13
0
 public BasicXmlSopDataSource(InstanceXml instanceXml, string path)
     : this(instanceXml, DicomStreamOpener.Create(path))
 {
 }
示例#14
0
        /// <summary>
        /// Populate at the IMAGE level a response message.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="response"></param>
        /// <param name="tagList"></param>
        /// <param name="theInstanceStream"></param>
        private void PopulateInstance(DicomAttributeCollection request, DicomMessage response, List <uint> tagList,
                                      InstanceXml theInstanceStream)
        {
            DicomAttributeCollection dataSet = response.DataSet;

            dataSet[DicomTags.RetrieveAeTitle].SetStringValue(Partition.AeTitle);
            dataSet[DicomTags.InstanceAvailability].SetStringValue("ONLINE");

            DicomAttributeCollection sourceDataSet = theInstanceStream.Collection;

            if (false == sourceDataSet.Contains(DicomTags.SpecificCharacterSet))
            {
                dataSet[DicomTags.SpecificCharacterSet].SetStringValue(sourceDataSet[DicomTags.SpecificCharacterSet].ToString());
                dataSet.SpecificCharacterSet = sourceDataSet[DicomTags.SpecificCharacterSet].ToString(); // this will ensure the data is encoded using the specified character set
            }

            foreach (uint tag in tagList)
            {
                try
                {
                    switch (tag)
                    {
                    case DicomTags.PatientId:
                        dataSet[DicomTags.PatientId].SetStringValue(request[DicomTags.PatientId].ToString());
                        break;

                    case DicomTags.StudyInstanceUid:
                        dataSet[DicomTags.StudyInstanceUid].SetStringValue(
                            request[DicomTags.StudyInstanceUid].ToString());
                        break;

                    case DicomTags.SeriesInstanceUid:
                        dataSet[DicomTags.SeriesInstanceUid].SetStringValue(
                            request[DicomTags.SeriesInstanceUid].ToString());
                        break;

                    case DicomTags.QueryRetrieveLevel:
                        dataSet[DicomTags.QueryRetrieveLevel].SetStringValue("IMAGE");
                        break;

                    default:
                        if (sourceDataSet.Contains(tag))
                        {
                            dataSet[tag] = sourceDataSet[tag].Copy();
                        }
                        else
                        {
                            dataSet[tag].SetNullValue();
                        }
                        break;

                    // Meta tags that should have not been in the RQ, but we've already set
                    case DicomTags.RetrieveAeTitle:
                    case DicomTags.InstanceAvailability:
                    case DicomTags.SpecificCharacterSet:
                        break;
                    }
                }
                catch (Exception e)
                {
                    Platform.Log(LogLevel.Warn, e, "Unexpected error setting tag {0} in C-FIND-RSP",
                                 dataSet[tag].Tag.ToString());
                    dataSet[tag].SetNullValue();
                }
            }
        }
示例#15
0
 private SopInstance GetSopInstance(InstanceXml xml)
 {
     return(new SopInstance(xml, this, _dicomFileLoader));
 }
示例#16
0
 internal SopInstance(Series parentSeries, InstanceXml instanceXml)
 {
     _parentSeries = parentSeries;
     _xml          = instanceXml;
 }