/// <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);
}
}
