public void AddDuplicateImage()
{
IImageViewer viewer = new ImageViewerComponent();
StudyTree studyTree = viewer.StudyTree;
string studyUid1 = DicomUid.GenerateUid().UID;
string seriesUid1 = DicomUid.GenerateUid().UID;
string imageUid1 = DicomUid.GenerateUid().UID;
ImageSop image1 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
ImageSop image2 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
//The sop has already silently disposed the 2nd data source.
Assert.IsTrue(ReferenceEquals(image1.DataSource, image2.DataSource));
studyTree.AddSop(image1);
studyTree.AddSop(image2);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid1].Sops.Count == 1);
TestDataSource dataSource = (TestDataSource)image1.DataSource;
viewer.Dispose();
Assert.IsTrue(dataSource.IsDisposed);
}
public StudyTree CreateStudyTree(List <Sop> sops)
{
StudyTree studyTree = new StudyTree();
foreach (Sop sop in sops)
{
studyTree.AddSop(sop);
}
return(studyTree);
}
public Study AddStudy(StudyTree studyTree)
{
var sops = BuildSops();
foreach (var sop in sops)
{
studyTree.AddSop(sop);
}
return(studyTree.GetStudy(sops[0].StudyInstanceUid));
}
public void AddDuplicateImage()
{
IImageViewer viewer = new ImageViewerComponent();
StudyTree studyTree = viewer.StudyTree;
string studyUid1 = DicomUid.GenerateUid().UID;
string seriesUid1 = DicomUid.GenerateUid().UID;
string imageUid1 = DicomUid.GenerateUid().UID;
ImageSop image1 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
ImageSop image2 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
Assert.IsTrue(studyTree.AddSop(image1));
Assert.IsFalse(studyTree.AddSop(image2));
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid1].Sops.Count == 1);
TestDataSource dataSource = (TestDataSource)image1.DataSource;
viewer.Dispose();
Assert.IsTrue(dataSource.IsDisposed);
}
private static List <IDisplaySet> CreateDisplaySets(IDisplaySetFactory displaySetFactory, IEnumerable <ISopDataSource> sopDataSources, out StudyTree studyTree)
{
studyTree = new StudyTree();
foreach (var sopDataSource in sopDataSources)
{
studyTree.AddSop(new ImageSop(sopDataSource));
}
displaySetFactory.SetStudyTree(studyTree);
var displaySets = new List <IDisplaySet>();
foreach (var patient in studyTree.Patients)
{
foreach (var study in patient.Studies)
{
displaySets.AddRange(displaySetFactory.CreateDisplaySets(study));
}
}
return(displaySets);
}
private void TestSortingImageSetsByStudyDate(bool reverse, bool useSops, bool testLayoutManagerSort)
{
ImageSetCollection orderedCollection = new ImageSetCollection();
ImageSetCollection nonOrderedCollection = new ImageSetCollection();
StudyTree studyTree = new StudyTree();
for (int i = 0; i <= 20; ++i)
{
string id = i.ToString();
ImageSet imageSet = new ImageSet();
imageSet.Name = id;
string studyDate;
if (i == 0)
{
studyDate = "";
}
else
{
studyDate = String.Format("200801{0}", i.ToString("00"));
}
if (useSops)
{
DisplaySet displaySet = new DisplaySet(id, id);
ImageSop sop = NewImageSop(id, id, i);
imageSet.Uid = sop.StudyInstanceUid;
studyTree.AddSop(sop);
IPresentationImage image = new DicomGrayscalePresentationImage(sop.Frames[1]);
IImageSopProvider sopProvider = (IImageSopProvider)image;
DicomMessageSopDataSource dataSource = ((DicomMessageSopDataSource)sopProvider.ImageSop.DataSource);
dataSource.SourceMessage.DataSet[DicomTags.StudyDate].SetString(0, studyDate);
imageSet.DisplaySets.Add(displaySet);
displaySet.PresentationImages.Add(image);
}
else
{
StudyRootStudyIdentifier identifier = new StudyRootStudyIdentifier();
identifier.StudyDate = studyDate;
identifier.StudyInstanceUid = id;
ImageSetDescriptor descriptor = new DicomImageSetDescriptor(identifier);
imageSet.Descriptor = descriptor;
}
orderedCollection.Add(imageSet);
}
if (reverse)
{
List <IImageSet> temp = new List <IImageSet>();
temp.AddRange(orderedCollection);
temp.Reverse();
orderedCollection.Clear();
foreach (IImageSet imageSet in temp)
{
orderedCollection.Add(imageSet);
}
}
Randomize(orderedCollection, nonOrderedCollection);
Debug.WriteLine("Before Sort\n------------------------\n");
CollectionUtils.ForEach(nonOrderedCollection,
imageSet => Debug.WriteLine(String.Format("name: {0}, date: {1}", imageSet.Name,
((IImageSopProvider)(imageSet.DisplaySets[0].PresentationImages[0])).
ImageSop.StudyDate)));
if (testLayoutManagerSort)
{
LayoutManager.SortImageSets(nonOrderedCollection, GetStudies(orderedCollection, studyTree));
}
else
{
nonOrderedCollection.Sort(new StudyDateComparer(reverse));
}
Debug.WriteLine("\nAfter Sort\n------------------------\n");
CollectionUtils.ForEach(nonOrderedCollection,
imageSet => Debug.WriteLine(String.Format("name: {0}, date: {1}", imageSet.Name,
((IImageSopProvider)(imageSet.DisplaySets[0].PresentationImages[0])).
ImageSop.StudyDate)));
if (reverse)
{
nonOrderedCollection.RemoveAt(20);
}
else
{
nonOrderedCollection.RemoveAt(0);
}
int j = reverse ? 20 : 1;
foreach (IImageSet set in nonOrderedCollection)
{
Assert.AreEqual(j.ToString(), set.Name);
j += reverse ? -1 : 1;
}
foreach (IImageSet set in nonOrderedCollection)
{
set.Dispose();
}
foreach (IImageSet set in orderedCollection)
{
set.Dispose();
}
studyTree.Dispose();
}
public Study AddStudy(StudyTree studyTree)
{
var sops = BuildSops();
foreach (var sop in sops)
studyTree.AddSop(sop);
return studyTree.GetStudy(sops[0].StudyInstanceUid);
}
public void TestKeyImages(int numberOfFrames, int numberOfMultiframeKeyImages, int numberOfSingleFrameKeyImages, bool doSplitting)
{
Assert.IsTrue(numberOfFrames == 0 || numberOfFrames > 1);
Assert.IsTrue(numberOfMultiframeKeyImages <= numberOfFrames);
const int numberOfSeries = 1;
int instancesPerSeries = numberOfSingleFrameKeyImages + ((numberOfFrames > 0) ? 1 : 0);
Assert.IsTrue(instancesPerSeries > 0);
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
if (numberOfFrames > 0)
{
TestDataSource multiFrameDataSource = dataSources[0];
DicomAttributeCollection oldDataSet = multiFrameDataSource.File.DataSet;
DicomAttributeCollection newDataSet = new DicomAttributeCollection();
DicomFile newFile = new DicomFile("", new DicomAttributeCollection(), newDataSet);
//Yes this is the world's crappiest hack.
base.SetupMultiframeXA(newDataSet, 512, 512, (uint)numberOfFrames);
//because of an exception that gets thrown from the DateTimeParser
newDataSet[DicomTags.StudyDate].SetNullValue();
newDataSet[DicomTags.StudyTime].SetNullValue();
newDataSet[DicomTags.SeriesDate].SetNullValue();
newDataSet[DicomTags.SeriesTime].SetNullValue();
newDataSet[DicomTags.ReferencedStudySequence].SetEmptyValue();
newDataSet[DicomTags.Modality].SetStringValue("MR");
newDataSet[DicomTags.StudyInstanceUid].SetStringValue(oldDataSet[DicomTags.StudyInstanceUid].ToString());
newDataSet[DicomTags.SeriesInstanceUid].SetStringValue(oldDataSet[DicomTags.SeriesInstanceUid].ToString());
dataSources[0] = new TestDataSource(newFile);
}
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
KeyImageSerializer serializer = new KeyImageSerializer();
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Series sourceSeries = study.Series[0];
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
BasicDisplaySetFactory factory = new BasicDisplaySetFactory();
factory.SetStudyTree(studyTree);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(sourceSeries);
allDisplaySets.AddRange(displaySets);
List <DicomFile> presentationStates = new List <DicomFile>();
int numberOfMultiframeKeyImagesCreated = 0;
foreach (IDisplaySet displaySet in displaySets)
{
foreach (IPresentationImage image in displaySet.PresentationImages)
{
Frame frame = ((IImageSopProvider)image).Frame;
if (frame.ParentImageSop.NumberOfFrames > 1)
{
if (numberOfMultiframeKeyImagesCreated >= numberOfMultiframeKeyImages)
{
continue;
}
++numberOfMultiframeKeyImagesCreated;
}
DicomSoftcopyPresentationState presentationState = DicomSoftcopyPresentationState.Create(image);
//because of an exception that gets thrown from the DateTimeParser
presentationState.DicomFile.DataSet[DicomTags.StudyDate].SetNullValue();
presentationState.DicomFile.DataSet[DicomTags.StudyTime].SetNullValue();
presentationState.DicomFile.DataSet[DicomTags.SeriesDate].SetNullValue();
presentationState.DicomFile.DataSet[DicomTags.SeriesTime].SetNullValue();
presentationStates.Add(presentationState.DicomFile);
serializer.AddImage(frame, presentationState);
}
}
List <DicomFile> files = serializer.Serialize();
List <TestDataSource> keyImageDataSources = ConvertToDataSources(files);
List <Sop> keyImageSops = ConvertToSops(keyImageDataSources);
keyImageSops.AddRange(ConvertToSops(ConvertToDataSources(presentationStates)));
foreach (Sop sop in keyImageSops)
{
studyTree.AddSop(sop);
}
try
{
foreach (Series series in study.Series)
{
if (series.Modality != "KO")
{
continue;
}
List <IDisplaySet> keyImageDisplaySets;
if (doSplitting)
{
factory.CreateSingleImageDisplaySets = true;
keyImageDisplaySets = factory.CreateDisplaySets(series);
if (keyImageDisplaySets.Count == 0)
{
factory.CreateSingleImageDisplaySets = false;
keyImageDisplaySets = factory.CreateDisplaySets(series);
}
}
else
{
keyImageDisplaySets = factory.CreateDisplaySets(series);
}
allDisplaySets.AddRange(keyImageDisplaySets);
int numberOfKeyImages = numberOfMultiframeKeyImages + numberOfSingleFrameKeyImages;
if (!doSplitting)
{
Assert.AreEqual(1, keyImageDisplaySets.Count, "There should be only one display set");
IDisplaySet keyImageDisplaySet = keyImageDisplaySets[0];
Assert.AreEqual(numberOfKeyImages, keyImageDisplaySet.PresentationImages.Count, "Expected {0} images", numberOfKeyImages);
Assert.AreEqual(typeof(KOSelectionDocumentDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
else
{
Assert.AreEqual(numberOfKeyImages, keyImageDisplaySets.Count, "Expected {0} display sets", numberOfKeyImages);
foreach (IDisplaySet keyImageDisplaySet in keyImageDisplaySets)
{
Assert.AreEqual(1, keyImageDisplaySet.PresentationImages.Count, "There should be only one presentation image");
IPresentationImage keyImage = keyImageDisplaySet.PresentationImages[0];
ImageSop sop = ((IImageSopProvider)keyImage).ImageSop;
Assert.AreEqual(sourceSeries.SeriesInstanceUid, sop.SeriesInstanceUid, "Series Instance Uid is not that of the source series");
if (numberOfKeyImages == 1)
{
Assert.AreEqual(typeof(KOSelectionDocumentDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
else if (sop.NumberOfFrames > 1)
{
Assert.AreEqual(typeof(KOSelectionSingleFrameDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
else
{
Assert.AreEqual(typeof(KOSelectionSingleImageDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
}
}
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
public void BuildStudyTree()
{
IImageViewer viewer = new ImageViewerComponent();
StudyTree studyTree = viewer.StudyTree;
string studyUid1 = DicomUid.GenerateUid().UID;
string studyUid2 = DicomUid.GenerateUid().UID;
string studyUid3 = DicomUid.GenerateUid().UID;
string seriesUid1 = DicomUid.GenerateUid().UID;
string seriesUid2 = DicomUid.GenerateUid().UID;
string seriesUid3 = DicomUid.GenerateUid().UID;
string seriesUid4 = DicomUid.GenerateUid().UID;
string seriesUid5 = DicomUid.GenerateUid().UID;
string imageUid1 = DicomUid.GenerateUid().UID;
string imageUid2 = DicomUid.GenerateUid().UID;
string imageUid3 = DicomUid.GenerateUid().UID;
string imageUid4 = DicomUid.GenerateUid().UID;
string imageUid5 = DicomUid.GenerateUid().UID;
string imageUid6 = DicomUid.GenerateUid().UID;
string imageUid7 = DicomUid.GenerateUid().UID;
string imageUid8 = DicomUid.GenerateUid().UID;
string imageUid9 = DicomUid.GenerateUid().UID;
ImageSop image1 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
ImageSop image2 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid2);
ImageSop image3 = CreateImageSop("patient1", studyUid1, seriesUid2, imageUid3);
ImageSop image4 = CreateImageSop("patient1", studyUid1, seriesUid2, imageUid4);
ImageSop image5 = CreateImageSop("patient1", studyUid2, seriesUid3, imageUid5);
ImageSop image6 = CreateImageSop("patient1", studyUid2, seriesUid3, imageUid6);
ImageSop image7 = CreateImageSop("patient2", studyUid3, seriesUid4, imageUid7);
ImageSop image8 = CreateImageSop("patient2", studyUid3, seriesUid4, imageUid8);
ImageSop image9 = CreateImageSop("patient2", studyUid3, seriesUid5, imageUid9);
// This is an internal method. We would never do this from real
// client code, but we do it here because we just want to test that
// images are being properly added to the tree.
studyTree.AddSop(image1);
studyTree.AddSop(image2);
studyTree.AddSop(image3);
studyTree.AddSop(image4);
studyTree.AddSop(image5);
studyTree.AddSop(image6);
studyTree.AddSop(image7);
studyTree.AddSop(image8);
studyTree.AddSop(image9);
Assert.IsTrue(studyTree.Patients.Count == 2);
Assert.IsTrue(studyTree.Patients["patient1"].Studies.Count == 2);
Assert.IsTrue(studyTree.Patients["patient2"].Studies.Count == 1);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series.Count == 2);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid2].Series.Count == 1);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid2].Series.Count == 1);
Assert.IsTrue(studyTree.Patients["patient2"].Studies[studyUid3].Series.Count == 2);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid1].Sops.Count == 2);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid2].Sops.Count == 2);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid2].Series[seriesUid3].Sops.Count == 2);
Assert.IsTrue(studyTree.Patients["patient2"].Studies[studyUid3].Series[seriesUid4].Sops.Count == 2);
Assert.IsTrue(studyTree.Patients["patient2"].Studies[studyUid3].Series[seriesUid5].Sops.Count == 1);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid1].Sops[imageUid1].SopInstanceUid == image1.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid1].Sops[imageUid2].SopInstanceUid == image2.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid2].Sops[imageUid3].SopInstanceUid == image3.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid2].Sops[imageUid4].SopInstanceUid == image4.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid2].Series[seriesUid3].Sops[imageUid5].SopInstanceUid == image5.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid2].Series[seriesUid3].Sops[imageUid6].SopInstanceUid == image6.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient2"].Studies[studyUid3].Series[seriesUid4].Sops[imageUid7].SopInstanceUid == image7.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient2"].Studies[studyUid3].Series[seriesUid4].Sops[imageUid8].SopInstanceUid == image8.SopInstanceUid);
Assert.IsTrue(studyTree.Patients["patient2"].Studies[studyUid3].Series[seriesUid5].Sops[imageUid9].SopInstanceUid == image9.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid1).SopInstanceUid == image1.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid2).SopInstanceUid == image2.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid3).SopInstanceUid == image3.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid4).SopInstanceUid == image4.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid5).SopInstanceUid == image5.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid6).SopInstanceUid == image6.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid7).SopInstanceUid == image7.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid8).SopInstanceUid == image8.SopInstanceUid);
Assert.IsTrue(studyTree.GetSop(imageUid9).SopInstanceUid == image9.SopInstanceUid);
viewer.Dispose();
}
/// <summary>
/// Called by the framework when the user clicks the "apply" menu item or toolbar button.
/// </summary>
public void SeriesQuery()
{
string callingAE = ServerTree.GetClientAETitle();
List <SeriesItem> SeriesList = new List <SeriesItem>();
#region remote datastore
// If remote data store, need to query server for series level information
if (!this.Context.SelectedServerGroup.IsLocalDatastore)
{
// Loop through all selected servers
foreach (Server node in this.Context.SelectedServerGroup.Servers)
{
DicomAttributeCollection dicomAttributeCollection = new DicomAttributeCollection();
// Query on "Series" Level
dicomAttributeCollection[DicomTags.QueryRetrieveLevel].SetStringValue("SERIES");
string studyUID = this.Context.SelectedStudies[0].StudyInstanceUid;
dicomAttributeCollection[DicomTags.StudyInstanceUid].SetStringValue(studyUID);
dicomAttributeCollection[DicomTags.SeriesDescription].SetNullValue();
dicomAttributeCollection[DicomTags.SeriesInstanceUid].SetNullValue();
dicomAttributeCollection[DicomTags.SeriesNumber].SetNullValue();
dicomAttributeCollection[DicomTags.Modality].SetNullValue();
dicomAttributeCollection[DicomTags.Date].SetNullValue();
dicomAttributeCollection[DicomTags.Time].SetNullValue();
dicomAttributeCollection[DicomTags.RepetitionTime].SetNullValue();
IList <DicomAttributeCollection> resultsList;
StudyRootFindScu findScu = new StudyRootFindScu();
List <string> seriesUIDs = new List <string>();
resultsList = findScu.Find(
callingAE,
node.AETitle,
node.Host,
node.Port,
dicomAttributeCollection);
findScu.CloseAssociation();
findScu.Dispose();
foreach (DicomAttributeCollection msg in resultsList)
{
string text = msg[DicomTags.SeriesInstanceUid];
Platform.Log(LogLevel.Info, text);
SeriesItem series = new SeriesItem();
series.SeriesNumber = msg[DicomTags.SeriesNumber];
series.SeriesDescription = msg[DicomTags.SeriesDescription];
series.StudyInstanceUID = msg[DicomTags.StudyInstanceUid];
series.SeriesInstanceUID = msg[DicomTags.SeriesInstanceUid];
series.Modality = msg[DicomTags.Modality];
series.Date = msg[DicomTags.Date];
series.Time = msg[DicomTags.Time];
//series.NumberOfSeriesRelatedInstances = int.Parse(msg[DicomTags.NumberOfSeriesRelatedInstances].ToString());
SeriesList.Add(series);
}
_component = new SeriesBrowserComponent(SeriesList, node);
_shelf = ApplicationComponent.LaunchAsShelf(this.Context.DesktopWindow, _component, "Series Browser", ShelfDisplayHint.DockBottom | ShelfDisplayHint.DockAutoHide);
_shelf.Closed += Shelf_Closed;
}
}
#endregion
#region Local Datastore
// If local datastore, can obtain series information by building study tree
else
{
IImageViewer viewer = new ImageViewerComponent();
StudyTree studyTree = viewer.StudyTree;
// Add selected objects studies to study tree
foreach (StudyItem selectedstudy in this.Context.SelectedStudies)
{
string studyUID = selectedstudy.StudyInstanceUid;
int numberOfSops = LocalStudyLoader.Start(new StudyLoaderArgs(studyUID, null));
for (int i = 0; i < numberOfSops; ++i)
{
Sop imageSop = LocalStudyLoader.LoadNextSop();
studyTree.AddSop(imageSop);
}
}
foreach (Patient patient in studyTree.Patients)
{
foreach (Study study in patient.Studies)
{
foreach (Series series in study.Series)
{
SeriesItem seriesitem = new SeriesItem();
seriesitem.SeriesNumber = series.SeriesNumber.ToString();
seriesitem.SeriesDescription = series.SeriesDescription;
seriesitem.StudyInstanceUID = study.StudyInstanceUid;
seriesitem.SeriesInstanceUID = series.SeriesInstanceUid;
seriesitem.Modality = series.Modality;
seriesitem.Date = series.SeriesDate;
seriesitem.Time = series.SeriesTime;
//series.NumberOfSeriesRelatedInstances = int.Parse(msg[DicomTags.NumberOfSeriesRelatedInstances].ToString());
seriesitem.NumberOfSeriesRelatedInstances = series.Sops.Count.ToString();
SeriesList.Add(seriesitem);
}
_component = new SeriesBrowserComponent(SeriesList, null);
_shelf = ApplicationComponent.LaunchAsShelf(this.Context.DesktopWindow, _component, DicomDataFormatHelper.PersonNameFormatter(patient.PatientsName), ShelfDisplayHint.DockBottom | ShelfDisplayHint.DockAutoHide);
_shelf.Closed += Shelf_Closed;
}
}
}
#endregion
}
/// <summary>
/// Called by the framework when the user clicks the "apply" menu item or toolbar button.
/// </summary>
public void Apply()
{
List <string> seriesUIDs = new List <string>();
List <string> studyUIDs = new List <string>();
foreach (SeriesItem item in this.Context.SelectedMultipleSeries)
{
string foo = item.SeriesInstanceUID;
Platform.Log(LogLevel.Info, foo);
seriesUIDs.Add(item.SeriesInstanceUID);
studyUIDs.Add(item.StudyInstanceUID);
}
// Code for local data store only (tool should be disabled for remote devices
IImageViewer viewer = new ImageViewerComponent();
StudyTree studyTree = viewer.StudyTree;
List <SeriesItem> imageList = new List <SeriesItem>();
// Add selected objects studies to study tree
foreach (SeriesItem selectedseries in this.Context.SelectedMultipleSeries)
{
string studyUID = selectedseries.StudyInstanceUID;
int numberOfSops = LocalStudyLoader.Start(new StudyLoaderArgs(studyUID, null));
for (int i = 0; i < numberOfSops; ++i)
{
Sop imageSop = LocalStudyLoader.LoadNextSop();
studyTree.AddSop(imageSop);
}
}
foreach (Patient patient in studyTree.Patients)
{
foreach (Study study in patient.Studies)
{
string description = "";
foreach (Series series in study.Series)
{
string saveseries = seriesUIDs.Find(delegate(string s) { return(s.Equals(series.SeriesInstanceUid)); });
if (saveseries != null)
{
foreach (Sop sop in series.Sops)
{
SeriesItem image = new SeriesItem();
DicomFile file = ((ILocalSopDataSource)sop.DataSource).File;
StudyData originalData = new StudyData();
file.DataSet.LoadDicomFields(originalData);
image.Time = file.DataSet[DicomTags.TriggerTime];
image.SeriesDescription = file.DataSet[DicomTags.SeriesDescription];
image.Modality = file.DataSet[DicomTags.Modality];
image.SeriesNumber = sop.InstanceNumber.ToString();
image.Date = file.DataSet[DicomTags.StudyDate];
imageList.Add(image);
description = image.SeriesDescription;
}
}
}
_component = new ImageBrowserComponent(imageList, null);
_image_shelf = ApplicationComponent.LaunchAsShelf(this.Context.DesktopWindow, _component, DicomDataFormatHelper.PersonNameFormatter(patient.PatientsName) + ": " + description, ShelfDisplayHint.DockBottom | ShelfDisplayHint.DockAutoHide);
_image_shelf.Closed += Image_Shelf_Closed;
}
}
}