/// <summary> /// Gets the <see cref="StudyXml"/> if it exists in this storage location. /// </summary> /// <remarks> /// </remarks> /// <returns></returns> public StudyXml LoadStudyXml() { // TODO: Use FileStreamOpener instead // Can't do it until we break the dependency of ImageServer.Common on Model if (_studyXml == null) { lock (SyncRoot) { try { Stream xmlStream = Open(GetStudyXmlPath()); if (xmlStream != null) { var theMemento = new StudyXmlMemento(); using (xmlStream) { StudyXmlIo.Read(theMemento, xmlStream); xmlStream.Close(); } _studyXml = new StudyXml(); _studyXml.SetMemento(theMemento); } } catch (Exception) { } } } return(_studyXml); }
public void TestMultipleSerializations() { List <DicomFile> images = SetupImages(4); StudyXmlMemento doc = null; StudyXml xml; int i; for (i = 0; i < images.Count; ++i) { xml = new StudyXml(); if (doc != null) { xml.SetMemento(doc); } xml.AddFile(images[i]); StudyXmlOutputSettings settings = new StudyXmlOutputSettings(); doc = xml.GetMemento(settings); } xml = new StudyXml(); xml.SetMemento(doc); List <InstanceXmlDicomAttributeCollection> dataSets = GetInstanceXmlDataSets(xml); i = 0; foreach (DicomFile file in images) { ValidateEqualExceptExclusions(file.DataSet, dataSets[i++], DicomTags.ImageComments, DicomTags.PixelData); } }
/// <summary> /// Get a list of paths to the first image in each series within the study being processed. /// </summary> /// <returns></returns> private List <string> GetFirstInstanceInEachStudySeries() { var fileList = new List <string>(); if (_studyXml == null) { string studyXml = _location.GetStudyXmlPath(); if (!File.Exists(studyXml)) { return(fileList); } _studyXml = new StudyXml(); using (FileStream stream = FileStreamOpener.OpenForRead(studyXml, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, stream); stream.Close(); _studyXml.SetMemento(theMemento); } } // Note, we try and force ourselves to have an uncompressed // image, if one exists. That way the rules will be reapplied on the object // if necessary for compression. foreach (SeriesXml seriesXml in _studyXml) { InstanceXml saveInstance = null; foreach (InstanceXml instance in seriesXml) { if (instance.TransferSyntax.Encapsulated) { if (saveInstance == null) { saveInstance = instance; } } else { saveInstance = instance; break; } } if (saveInstance != null) { string path = Path.Combine(_location.GetStudyPath(), seriesXml.SeriesInstanceUid); path = Path.Combine(path, saveInstance.SopInstanceUid + ServerPlatform.DicomFileExtension); fileList.Add(path); } } return(fileList); }
private static StudyXml GetStudyXml(StudyStorageLocation storageLocation) { StudyXml studyXml = new StudyXml(); string studyXmlPath = Path.Combine(storageLocation.GetStudyPath(), storageLocation.StudyInstanceUid + ".xml"); using (Stream stream = FileStreamOpener.OpenForRead(studyXmlPath, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, stream); studyXml.SetMemento(theMemento); stream.Close(); } return(studyXml); }
/// <summary> /// Load the StudyXml file. /// </summary> /// <param name="studyXmlFile"></param> public void LoadStudyXml(string studyXmlFile) { using (Stream fileStream = FileStreamOpener.OpenForRead(studyXmlFile, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); _studyXml = new StudyXml(_storageLocation.StudyInstanceUid); _studyXml.SetMemento(theMemento); fileStream.Close(); } }
/// <summary> /// Helper method to load a <see cref="StudyXml"/> instance for a given study location. /// </summary> /// <param name="location"></param> /// <returns></returns> public static StudyXml LoadStudyXml(StudyStorageLocation location) { String streamFile = Path.Combine(location.GetStudyPath(), location.StudyInstanceUid + ".xml"); var theXml = new StudyXml(); if (File.Exists(streamFile)) { // allocate the random number generator here, in case we need it below var rand = new Random(); // Go into a retry loop, to handle if the study is being processed right now for (int i = 0; ; i++) { try { using (Stream fileStream = FileStreamOpener.OpenForRead(streamFile, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); theXml.SetMemento(theMemento); fileStream.Close(); return(theXml); } } catch (IOException) { if (i < 5) { Thread.Sleep(rand.Next(5, 50)); // Sleep 5-50 milliseconds continue; } throw; } } } return(theXml); }
/// <summary> /// Gets the study header (via <see cref="GetStudyHeader"/>), unzips the gzipped stream, and returns it as <see cref="StudyXml"/>. /// </summary> /// <param name="callingAETitle">AE title of the local application.</param> /// <param name="parameters">Input parameters.</param> /// <returns></returns> public StudyXml GetStudyXml(string callingAETitle, HeaderStreamingParameters parameters) { StudyXmlMemento theMemento; using (var stream = GetStudyHeader(callingAETitle, parameters)) { using (var gzStream = new GZipStream(stream, CompressionMode.Decompress)) { theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, gzStream); gzStream.Close(); } } var studyXml = new StudyXml(); studyXml.SetMemento(theMemento); return(studyXml); }
/// <summary> /// Load a <see cref="StudyXml"/> file for a given <see cref="StudyStorageLocation"/> /// </summary> /// <param name="location">The location a study is stored.</param> /// <returns>The <see cref="StudyXml"/> instance for <paramref name="location"/></returns> private StudyXml LoadStudyStream(string location) { StudyXml theXml = new StudyXml(); if (File.Exists(location)) { using (Stream fileStream = new FileStream(location, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); theXml.SetMemento(theMemento); fileStream.Close(); } } return(theXml); }
/// <summary> /// Load a <see cref="StudyXml"/> file for a given <see cref="StudyStorageLocation"/> /// </summary> /// <param name="location">The location a study is stored.</param> /// <returns>The <see cref="StudyXml"/> instance for <paramref name="location"/></returns> private StudyXml LoadStudyStream(string location) { StudyXml theXml = new StudyXml(); if (File.Exists(location)) { using (Stream fileStream = new FileStream(location, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); theXml.SetMemento(theMemento); fileStream.Close(); } } return theXml; }
/// <summary> /// Load a <see cref="StudyXml"/> file for the <see cref="StudyLocation"/> /// </summary> /// <returns>The <see cref="StudyXml"/> instance</returns> public StudyXml LoadStudyXml() { var theXml = new StudyXml(); string streamFile = GetStudyXmlPath(); if (File.Exists(streamFile)) { using (Stream fileStream = FileStreamOpener.OpenForRead(streamFile, FileMode.Open)) { var memento = new StudyXmlMemento(); StudyXmlIo.Read(memento, fileStream); theXml.SetMemento(memento); fileStream.Close(); } } return(theXml); }
public StudyXml LoadStudyXml(bool refresh) { lock (SyncRoot) { Stream xmlStream = Open(GetStudyXmlPath()); if (xmlStream != null) { var theMemento = new StudyXmlMemento(); using (xmlStream) { StudyXmlIo.Read(theMemento, xmlStream); xmlStream.Close(); } _studyXml = new StudyXml(); _studyXml.SetMemento(theMemento); } } return(_studyXml); }
/// <summary> /// Load a <see cref="StudyXml"/> file for a given <see cref="StudyStorageLocation"/> /// </summary> /// <param name="location">The location a study is stored.</param> /// <returns>The <see cref="StudyXml"/> instance for <paramref name="location"/></returns> protected virtual StudyXml LoadStudyXml(StudyStorageLocation location) { StudyXml theXml = new StudyXml(); String streamFile = Path.Combine(location.GetStudyPath(), location.StudyInstanceUid + ".xml"); if (File.Exists(streamFile)) { using (Stream fileStream = FileStreamOpener.OpenForRead(streamFile, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); theXml.SetMemento(theMemento); fileStream.Close(); } } return(theXml); }
/// <summary> /// Load a <see cref="StudyXml"/> file for a given <see cref="StudyStorageLocation"/> /// </summary> /// <returns>The <see cref="StudyXml"/> instance for the study</returns> private StudyXml LoadStudyXml() { var theXml = new StudyXml(); String streamFile = Path.Combine(_rootPath, _studyInstanceUid + ".xml"); if (File.Exists(streamFile)) { using (Stream fileStream = FileStreamOpener.OpenForRead(streamFile, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); theXml.SetMemento(theMemento); fileStream.Close(); } } return(theXml); }
/// <summary> /// Load the first instance from the first series of the StudyXml file for a study. /// </summary> /// <param name="location">The storage location of the study.</param> /// <returns></returns> protected static DicomFile LoadInstance(StudyStorageLocation location) { string studyXml = Path.Combine(location.GetStudyPath(), location.StudyInstanceUid + ".xml"); if (!File.Exists(studyXml)) { return(null); } FileStream stream = FileStreamOpener.OpenForRead(studyXml, FileMode.Open); var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, stream); stream.Close(); stream.Dispose(); var xml = new StudyXml(); xml.SetMemento(theMemento); IEnumerator <SeriesXml> seriesEnumerator = xml.GetEnumerator(); if (seriesEnumerator.MoveNext()) { SeriesXml seriesXml = seriesEnumerator.Current; IEnumerator <InstanceXml> instanceEnumerator = seriesXml.GetEnumerator(); if (instanceEnumerator.MoveNext()) { InstanceXml instance = instanceEnumerator.Current; var file = new DicomFile("file.dcm", new DicomAttributeCollection(), instance.Collection) { TransferSyntax = instance.TransferSyntax }; return(file); } } return(null); }
public void Run() { HeaderStreamingServiceClient client = null; studies = null; StudyInfo study = null; while (true) { Random r = new Random(); if (String.IsNullOrEmpty(FixedStudyInstanceUid)) { bool refresh = false; if (studies == null) { refresh = r.Next() % 10 == 0; } else { refresh = r.NextDouble() < (1.0f / studies.Count / 1000f); } if (refresh) { studies = new List <StudyInfo>(); CFindSCU cfind = new CFindSCU(); cfind.AETitle = LocalAE; cfind.OnResultReceive += new CFindSCU.ResultReceivedHandler(cfind_OnResultReceive); cfind.OnQueryCompleted += new CFindSCU.QueryCompletedHandler(cfind_OnQueryCompleted); cfind.Query(RemoteAE, RemoteHost, RemotePort); waitHandle.WaitOne(); } } else { studies = new List <StudyInfo>(); study = new StudyInfo(); study.StudyUid = FixedStudyInstanceUid; studies.Add(study); } if (studies != null && studies.Count > 0) { try { if (client == null) { client = new HeaderStreamingServiceClient(); client.ClientCredentials.ClientCertificate.SetCertificate( StoreLocation.LocalMachine, StoreName.My, X509FindType.FindBySubjectName, Dns.GetHostName()); client.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None; } study = studies[r.Next(studies.Count - 1)]; HeaderStreamingParameters param = new HeaderStreamingParameters(); param.ServerAETitle = RemoteAE; param.StudyInstanceUID = study.StudyUid; param.ReferenceID = Guid.NewGuid().ToString(); TimeSpanStatistics ts = new TimeSpanStatistics(); ts.Start(); Console.WriteLine("************ RETRIEVING... {0} **************", LocalAE); Stream input = client.GetStudyHeader(LocalAE, param); if (input != null) { string outputdir = Path.Combine("./output", LocalAE); if (!Directory.Exists(outputdir)) { Directory.CreateDirectory(outputdir); } string temp = Path.Combine(outputdir, study.StudyUid + ".xml"); Console.WriteLine("Reading"); using (FileStream output = new FileStream(temp, FileMode.OpenOrCreate)) { GZipStream gzStream = new GZipStream(input, CompressionMode.Decompress); byte[] buffer = new byte[32 * 1024 * 1024]; int size = gzStream.Read(buffer, 0, buffer.Length); int count = 0; while (size > 0) { output.Write(buffer, 0, size); count += size; Console.Write("\r{0} KB", count / 1024); size = gzStream.Read(buffer, 0, buffer.Length); } output.Close(); } using (FileStream output = new FileStream(temp, FileMode.Open)) { var theMemento = new StudyXmlMemento(); Console.WriteLine("Reading into xml"); StudyXmlIo.Read(theMemento, output); Console.WriteLine("Done"); } } else { Console.WriteLine("{2} - {1,-16} {0,-64}... NOT FOUND", study.StudyUid, LocalAE, System.Diagnostics.Stopwatch.GetTimestamp()); } ts.End(); input.Close(); //File.Delete(temp); Console.WriteLine("{3} - {2,-16} {0,-64}... OK {1}", study.StudyUid, ts.FormattedValue, LocalAE, System.Diagnostics.Stopwatch.GetTimestamp()); } catch (TimeoutException) { // try again Console.WriteLine("{2} - {1,-16} {0,-64}... TIMEOUT", study.StudyUid, LocalAE, System.Diagnostics.Stopwatch.GetTimestamp()); } catch (Exception fault) { Console.WriteLine("{3} - {2,-16} {0,-64}... FAILED {1}", study.StudyUid, fault.Message, LocalAE, System.Diagnostics.Stopwatch.GetTimestamp()); if (client != null) { client.Abort(); client.Close(); client = null; } } Thread.Sleep(r.Next(Delay)); } else { Thread.Sleep(r.Next(1000, 3000)); } } }
private void PopulateSeries(string studyInstanceUid) { LogTextPanel.Text = ""; StatisticsLog.Text = ""; HeaderStreamingServiceClient proxy = null; try { proxy = new HeaderStreamingServiceClient(); HeaderStreamingParameters parms = new HeaderStreamingParameters(); parms.StudyInstanceUID = studyInstanceUid; parms.ServerAETitle = ServerAE.Text; parms.ReferenceID = Guid.NewGuid().ToString(); TimeSpanStatistics servicecall = new TimeSpanStatistics(); servicecall.Start(); Stream stream = proxy.GetStudyHeader(AETitle.Text, parms); servicecall.End(); var decompression = new TimeSpanStatistics(); decompression.Start(); //GZipStream gzipStream = new GZipStream(stream, CompressionMode.Decompress); var theMemento = new StudyXmlMemento(); StudyXmlIo.ReadGzip(theMemento, stream); //doc.Load(gzipStream); decompression.End(); var settings = new XmlWriterSettings(); //settings.Indent = true; settings.NewLineOnAttributes = false; settings.OmitXmlDeclaration = true; settings.Encoding = Encoding.UTF8; StringWriter sw = new StringWriter(); XmlWriter writer = XmlWriter.Create(sw, settings); theMemento.Document.WriteTo(writer); writer.Flush(); Log(sw.ToString()); TimeSpanStatistics loading = new TimeSpanStatistics(); loading.Start(); StudyXml xml = new StudyXml(); xml.SetMemento(theMemento); loading.End(); int sopCounter = 0; SeriesTree.Nodes.Clear(); foreach (SeriesXml series in xml) { TreeNode seriesNode = new TreeNode(series.SeriesInstanceUid); SeriesTree.Nodes.Add(seriesNode); foreach (InstanceXml instance in series) { TreeNode instanceNode = new TreeNode(instance.SopInstanceUid); seriesNode.Nodes.Add(instanceNode); sopCounter++; } } StatisticsLog.Text = ""; StatisticsLog.Text += String.Format("\r\nHeader Size (Decompressed): {0} KB", sw.ToString().Length / 1024); StatisticsLog.Text += String.Format("\r\nWCF Service call : {0} ms", servicecall.Value.TotalMilliseconds); StatisticsLog.Text += String.Format("\r\nDecompression : {0} ms", decompression.Value.TotalMilliseconds); StatisticsLog.Text += String.Format("\r\nLoading StudyXml : {0} ms", loading.Value.TotalMilliseconds); SeriesLabel.Text = String.Format("Series : {0} \tInstances: {1}", SeriesTree.Nodes.Count, sopCounter); stream.Close(); } catch (FaultException <StudyIsInUseFault> ex) { timer1.Stop(); MessageBox.Show(String.Format("StudyIsInUseFault received:{0}\n\nState={1}", ex.Message, ex.Detail.StudyState)); } catch (FaultException <StudyIsNearlineFault> ex) { timer1.Stop(); MessageBox.Show("StudyIsNearlineFault received:\n" + ex.Message); } catch (FaultException <StudyNotFoundFault> ex) { timer1.Stop(); MessageBox.Show("StudyNotFoundFault received:\n" + ex.Message); } catch (Exception ex) { timer1.Stop(); MessageBox.Show(ex.Message); } finally { if (proxy.State == CommunicationState.Opened) { proxy.Close(); } } }
public void GetStudy(string studyInstanceUid, Uri baseUri, string serverAE, bool singleImage) { Console.WriteLine("[{0}] : Loading {1}", _id, studyInstanceUid); string uri = String.Format("http://{0}:{1}/HeaderStreaming/HeaderStreaming", "localhost", 50221); EndpointAddress endpoint = new EndpointAddress(uri); BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None); binding.TransferMode = TransferMode.Streamed; binding.MessageEncoding = WSMessageEncoding.Mtom; binding.MaxReceivedMessageSize = Int32.MaxValue; binding.TextEncoding = Encoding.UTF8; HeaderStreamingServiceClient headerClient = new HeaderStreamingServiceClient(binding, endpoint); using (headerClient) { HeaderStreamingParameters parms = new HeaderStreamingParameters(); parms.StudyInstanceUID = studyInstanceUid; parms.ReferenceID = Guid.NewGuid().ToString(); parms.ServerAETitle = "ImageServer"; Stream stream = headerClient.GetStudyHeader("TEST", parms); var theMemento = new StudyXmlMemento(); StudyXmlIo.ReadGzip(theMemento, stream); _studyXml = new StudyXml(studyInstanceUid); _studyXml.SetMemento(theMemento); stream.Close(); headerClient.Close(); } if (singleImage) { ulong size = 0; StreamingClient client = new StreamingClient(baseUri); foreach (SeriesXml series in _studyXml) { foreach (InstanceXml instance in series) { do { Stream image = client.RetrieveImage(serverAE, studyInstanceUid, series.SeriesInstanceUid, instance.SopInstanceUid); byte[] buffer = new byte[image.Length]; image.Read(buffer, 0, buffer.Length); image.Close(); Console.Write("."); } while (true); } Console.WriteLine("\n[{0}] : Finish Loading {1} [{2}]", _id, studyInstanceUid, ByteCountFormatter.Format(size)); } } else { Random ran = new Random(); do { ulong size = 0; StreamingClient client = new StreamingClient(baseUri); foreach (SeriesXml series in _studyXml) { foreach (InstanceXml instance in series) { Stream image = client.RetrieveImage(serverAE, studyInstanceUid, series.SeriesInstanceUid, instance.SopInstanceUid); byte[] buffer = new byte[image.Length]; image.Read(buffer, 0, buffer.Length); image.Close(); size += (ulong)buffer.Length; Console.Write("."); } Console.WriteLine("\n[{0}] : Finish Loading {1} [{2}]", _id, studyInstanceUid, ByteCountFormatter.Format(size)); } Thread.Sleep(ran.Next(1000, 5000)); } while (true); } }
/// <summary> /// Apply the rules. /// </summary> /// <remarks> /// When rules are applied, we are simply adding new <see cref="ServerDatabaseCommand"/> instances /// for the rules to the currently executing <see cref="ServerCommandProcessor"/>. They will be /// executed after all other rules have been executed. /// </remarks> protected override void OnExecute(CommandProcessor theProcessor) { string studyXmlFile = Path.Combine(_directory, String.Format("{0}.xml", _studyInstanceUid)); StudyXml theXml = new StudyXml(_studyInstanceUid); if (File.Exists(studyXmlFile)) { using (Stream fileStream = FileStreamOpener.OpenForRead(studyXmlFile, FileMode.Open)) { var theMemento = new StudyXmlMemento(); StudyXmlIo.Read(theMemento, fileStream); theXml.SetMemento(theMemento); fileStream.Close(); } } else { string errorMsg = String.Format("Unable to load study XML file of restored study: {0}", studyXmlFile); Platform.Log(LogLevel.Error, errorMsg); throw new ApplicationException(errorMsg); } DicomFile defaultFile = null; bool rulesExecuted = false; foreach (SeriesXml seriesXml in theXml) { foreach (InstanceXml instanceXml in seriesXml) { // Skip non-image objects if (instanceXml.SopClass.Equals(SopClass.KeyObjectSelectionDocumentStorage) || instanceXml.SopClass.Equals(SopClass.GrayscaleSoftcopyPresentationStateStorageSopClass) || instanceXml.SopClass.Equals(SopClass.BlendingSoftcopyPresentationStateStorageSopClass) || instanceXml.SopClass.Equals(SopClass.ColorSoftcopyPresentationStateStorageSopClass)) { // Save the first one encountered, just in case the whole study is non-image objects. if (defaultFile == null) { defaultFile = new DicomFile("test", new DicomAttributeCollection(), instanceXml.Collection); } continue; } DicomFile file = new DicomFile("test", new DicomAttributeCollection(), instanceXml.Collection); _context.Message = file; _engine.Execute(_context); rulesExecuted = true; break; } if (rulesExecuted) { break; } } if (!rulesExecuted && defaultFile != null) { _context.Message = defaultFile; _engine.Execute(_context); } }