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(Object.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);
Assert.IsTrue(SopDataCache.ItemCount == 0, "The Sop data cache is NOT empty.");
}
public void TestSeriesSplittingMREcho()
{
const int numberOfSeries = 5;
const int instancesPerSeries = 10;
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
MREchoDisplaySetFactory factory = new MREchoDisplaySetFactory();
factory.SetStudyTree(studyTree);
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
try
{
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Assert.AreEqual(numberOfSeries, study.Series.Count, "There should be exactly {0} series", numberOfSeries);
Series series2 = study.Series[1];
Series series3 = study.Series[2];
MakeEchoSeries(series2);
MakeEchoSeries(series3);
foreach (Series series in study.Series)
{
Assert.AreEqual(instancesPerSeries, series.Sops.Count, "There should be exactly {0} sops", instancesPerSeries);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(series);
allDisplaySets.AddRange(displaySets);
if (series == series2 || series == series3)
{
IDisplaySet displaySet = displaySets[0];
Assert.AreEqual(2, displaySets.Count, "There should be exactly 2 display sets");
Assert.AreEqual(series.Sops.Count / 2, displaySet.PresentationImages.Count, "#presentation images should be #Sops/2");
Assert.AreNotEqual(series.SeriesInstanceUid, displaySet.Descriptor.Uid, "Series UID and Display Set UID don't match");
Assert.AreEqual(typeof(MREchoDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.IsTrue(displaySet.Name.Contains("Echo"), "Display Set name not correct");
ValidateEchoDisplaySet(displaySets[0], 1);
ValidateEchoDisplaySet(displaySets[1], 2);
}
else
{
Assert.AreEqual(0, displaySets.Count, "There should be no display sets");
}
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
public void ReAllocateStudyTree()
{
if (_studyTree != null)
{
_studyTree.Dispose();
_studyTree = null;
_studyTree = new StudyTree();
}
}
public StudyTree CreateStudyTree(List <Sop> sops)
{
StudyTree studyTree = new StudyTree();
foreach (Sop sop in sops)
{
studyTree.AddSop(sop);
}
return(studyTree);
}
private List <Study> GetStudies(IEnumerable <IImageSet> imageSets, StudyTree studyTree)
{
List <Study> studies = new List <Study>();
foreach (IImageSet imageSet in imageSets)
{
studies.Add(studyTree.GetStudy(imageSet.Uid));
}
return(studies);
}
public Study AddStudy(StudyTree studyTree)
{
var sops = BuildSops();
foreach (var sop in sops)
{
studyTree.AddSop(sop);
}
return(studyTree.GetStudy(sops[0].StudyInstanceUid));
}
private static string GetPrimaryStudyInstanceUid(StudyTree studyTree)
{
foreach (Patient patient in studyTree.Patients)
{
foreach (Study study in patient.Studies)
{
return(study.StudyInstanceUid);
}
}
return(null);
}
private static IDicomServiceNode FindStudySourceServer(StudyTree studyTree, string studyInstanceUid)
{
try
{
return(studyTree.GetStudy(studyInstanceUid).Series.SelectMany(s => s.Sops).Select(s => s.DataSource.Server).FirstOrDefault(source => source != null));
}
catch (Exception ex)
{
Platform.Log(LogLevel.Warn, ex, "Failed to identify source server for study {0}", studyInstanceUid);
return(null);
}
}
public override void Prepare()
{
if (_displayData != null)
{
return;
}
//Console.Write("Prepare for a cell\t");
var sopInstanceUid = _imageBase.SOPInstanceUID;
if (StudyTree.GetSop(sopInstanceUid) == null)
{
DataLoader.LoadSopByUid(sopInstanceUid);
}
}
public override void SetImageViewer(IImageViewer imageViewer)
{
base.SetImageViewer(imageViewer);
StudyTree studyTree = null;
if (imageViewer != null)
{
studyTree = imageViewer.StudyTree;
}
_reconciliationStrategy.SetStudyTree(studyTree);
_imageSetFiller = new ImageSetFiller(studyTree, DisplaySetCreationOptions);
}
public KeyImageClipboard(StudyTree studyTree)
{
_studyTree = studyTree;
_currentContext = new KeyImageInformation();
_availableContexts = new List <KeyImageInformation> {
_currentContext
};
_availableContexts.AddRange(_studyTree.Studies
.SelectMany(s => s.Series)
.SelectMany(s => s.Sops)
.Where(s => s.SopClassUid == SopClass.KeyObjectSelectionDocumentStorageUid)
.Select(s => new KeyImageInformation(studyTree, s))
.OrderByDescending(s => s.ContentDateTime)
.ThenBy(s => s.SeriesNumber));
}
/// <summary>
/// Implementation of the <see cref="IDisposable"/> pattern
/// </summary>
/// <param name="disposing">True if this object is being disposed, false if it is being finalized</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
ParentDesktopObject = null;
if (_toolSet != null)
{
_toolSet.Dispose();
_toolSet = null;
}
StopLoadingPriors();
StopPrefetching();
if (_physicalWorkspace != null)
{
_physicalWorkspace.Dispose();
_physicalWorkspace = null;
}
if (_logicalWorkspace != null)
{
_logicalWorkspace.Dispose();
_logicalWorkspace = null;
}
if (_studyTree != null)
{
_studyTree.Dispose();
_studyTree = null;
}
if (_layoutManager != null)
{
_layoutManager.Dispose();
_layoutManager = null;
}
if (ExtensionData != null)
{
ExtensionData.Dispose();
ExtensionData = null;
}
}
}
public void TestNoSeriesSplitting()
{
const int numberOfSeries = 5;
const int instancesPerSeries = 10;
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
BasicDisplaySetFactory factory = new BasicDisplaySetFactory();
factory.SetStudyTree(studyTree);
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
try
{
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Assert.AreEqual(numberOfSeries, study.Series.Count, "There should be exactly {0} series", numberOfSeries);
foreach (Series series in study.Series)
{
Assert.AreEqual(instancesPerSeries, series.Sops.Count, "There should be exactly {0} sops", instancesPerSeries);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(series);
allDisplaySets.AddRange(displaySets);
Assert.AreEqual(1, displaySets.Count, "There should be exactly {0} display sets", 1);
IDisplaySet displaySet = displaySets[0];
Assert.AreEqual(series.Sops.Count, displaySet.PresentationImages.Count, "#Sops should match #presentation images");
Assert.AreEqual(series.SeriesInstanceUid, displaySet.Descriptor.Uid, "Series UID and Display Set UID don't match");
Assert.AreEqual(typeof(SeriesDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
public KeyImageInformation(StudyTree studyTree, Sop keyObjectSelectionDocument)
: base(CreateClipboardItems(studyTree, keyObjectSelectionDocument))
{
var koDeserializer = new KeyImageDeserializer(keyObjectSelectionDocument);
var description = koDeserializer.DeserializeDescriptions().OfType <KeyObjectDescriptionContentItem>().FirstOrDefault();
var author = koDeserializer.DeserializeObserverContexts().OfType <PersonObserverContextContentItem>().FirstOrDefault();
_parentStudyInstanceUid = keyObjectSelectionDocument.StudyInstanceUid;
_documentInstanceUid = keyObjectSelectionDocument.SopInstanceUid;
_author = author != null ? author.PersonObserverName : string.Empty;
_description = description != null ? description.Description : string.Empty;
_documentTitle = koDeserializer.DocumentTitle ?? KeyObjectSelectionDocumentTitleContextGroup.OfInterest;
_seriesDescription = keyObjectSelectionDocument.SeriesDescription;
_seriesNumber = keyObjectSelectionDocument.SeriesNumber;
_contentDateTime = DateTimeParser.ParseDateAndTime(null, keyObjectSelectionDocument.ContentDate, keyObjectSelectionDocument.ContentTime);
_name = string.Format(SR.FormatOriginalKeyImageSelection, keyObjectSelectionDocument.SeriesNumber, keyObjectSelectionDocument.SeriesDescription, Format.DateTime(_contentDateTime));
}
protected override DisplayData CreateDisplayData()
{
var sopInstanceUid = _imageBase.SOPInstanceUID;
if (DisplayDataTable.ContainsKey(sopInstanceUid))
{
return(DisplayDataTable[sopInstanceUid]);
}
var sop = StudyTree.GetSop(sopInstanceUid);
var displayData = sop == null
? DataAccessor.CreateImageDataBySOPInstanceUID(sopInstanceUid, true)
: CreateDisplayDataBy(sop);
DisplayDataTable.Add(sopInstanceUid, displayData);
return(displayData);
}
public ImageModel()
{
try
{
Logger.LogFuncUp();
//DataManagement for separation UI with data
var studyTree = new StudyTree();
_dataLoader = DataLoaderFactory.Instance().CreateLoader(studyTree, DBWrapperHelper.DBWrapper);
_dataLoader.SopLoadedHandler += OnImageDataLoaded;
Logger.LogFuncDown();
}
catch (Exception ex)
{
Logger.LogFuncException(ex.Message + ex.StackTrace);
throw;
}
}
public ImageSetFiller(StudyTree studyTree, IDisplaySetCreationOptions displaySetCreationOptions)
{
_displaySetCreationOptions = displaySetCreationOptions;
foreach (IModalityDisplaySetCreationOptions option in displaySetCreationOptions)
{
_modalityDisplaySetFactories[option.Modality] = new DisplaySetFactory(option);
}
_modalityDisplaySetFactory = new ModalityDisplaySetFactory();
_defaultDisplaySetFactory = new BasicDisplaySetFactory();
foreach (IDisplaySetFactory displaySetFactory in _modalityDisplaySetFactories.Values)
{
displaySetFactory.SetStudyTree(studyTree);
}
_modalityDisplaySetFactory.SetStudyTree(studyTree);
_defaultDisplaySetFactory.SetStudyTree(studyTree);
}
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);
}
public void TestCT(int expectedDisplaySetCount)
{
var studyTree = new StudyTree();
var builder = StudyBuilderFactory.CreateCTChestBuilder("Patient1", "Test^Patient", "Chest", null, "Scout", "Axial", 22);
Assert.AreEqual(2, builder.Series.Count);
foreach (var series in builder.Series)
{
Assert.IsTrue(series.Images.Count > 1);
}
builder.AddStudy(studyTree);
var options = new DisplaySetCreationOptions();
var o = (StoredDisplaySetCreationSetting)options["CT"];
Assert.IsTrue(o.ShowOriginalSeries);
Test(studyTree, builder, options, false, expectedDisplaySetCount);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_toolSet != null)
{
_toolSet.Dispose();
_toolSet = null;
}
if (_studyTree != null)
{
_studyTree.Dispose();
_studyTree = null;
}
if (DicomPrintComponent != null)
{
DicomPrintComponent.Dispose();
}
referenceLines.Clear();
referenceLines = null;
if (this.DisplaySet != null && this.DisplaySet.PresentationImages != null)
{
foreach (var selectPresentationImage in this.DisplaySet.PresentationImages)
{
selectPresentationImage.Dispose();
}
DisplaySet.PresentationImages.Clear();
}
if (_rootImageBox != null)
{
_rootImageBox.Dispose();
}
PrintPresentationImagesHost.ImageViewerComponent = null;
}
}
public void TestMR(bool createEchos, bool split, bool showOriginal, bool showOriginalSeries, int expectedDisplaySetCount)
{
Trace.WriteLine(String.Format("MR Echo: split={0}, showOriginal={1}, showOriginalSeries={2}", split, showOriginal, showOriginalSeries));
var studyTree = new StudyTree();
var builder = StudyBuilderFactory.CreateMRBuilder("Patient1", "Test^Patient", "MR Echo", null, "Series1", "Series2", 1, createEchos, false);
builder.AddStudy(studyTree);
var options = new DisplaySetCreationOptions();
var o = (StoredDisplaySetCreationSetting)options["MR"];
Assert.IsTrue(o.SplitMultiEchoSeries);
Assert.IsFalse(o.ShowOriginalMultiEchoSeries);
Assert.IsTrue(o.ShowOriginalSeries);
o.SplitMultiEchoSeries = split;
o.ShowOriginalMultiEchoSeries = showOriginal;
o.ShowOriginalSeries = showOriginalSeries;
Test(studyTree, builder, options, false, expectedDisplaySetCount);
}
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);
}
public override void SetStudyTree(StudyTree studyTree)
{
base.SetStudyTree(studyTree);
_basicFactory.SetStudyTree(studyTree);
if (_echoFactory != null)
{
_echoFactory.SetStudyTree(studyTree);
}
if (_mixedMultiFrameFactory != null)
{
_mixedMultiFrameFactory.SetStudyTree(studyTree);
}
_placeholderDisplaySetFactory.SetStudyTree(studyTree);
foreach (var factory in _externalFactories)
{
factory.SetStudyTree(studyTree);
}
}
/// <summary>
/// Sets the <see cref="StudyManagement.StudyTree"/> where the factory can search for referenced <see cref="Sop"/>s.
/// </summary>
public virtual void SetStudyTree(StudyTree studyTree)
{
_studyTree = studyTree;
PresentationImageFactory.SetStudyTree(_studyTree);
}
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 IImageSet BuildImageSet(StudyTree studyTree, out Study study)
{
if (IsRemote)
{
study = null;
//Add only the image set, which essentially makes it a remote study.
var identifier = new StudyRootStudyIdentifier(this, this, new StudyIdentifier())
{
PatientId = ReconciledPatientId ?? PatientId
};
return new ImageSet(new DicomImageSetDescriptor(identifier));
}
study = AddStudy(studyTree);
var studyIdentifier = study.GetIdentifier();
studyIdentifier = new StudyRootStudyIdentifier(studyIdentifier) { PatientId = ReconciledPatientId ?? study.ParentPatient.PatientId };
var imageSet = new ImageSet(new DicomImageSetDescriptor(studyIdentifier));
foreach (var series in study.Series)
{
foreach (var displaySet in DisplaySetFactory.CreateDisplaySets(series))
imageSet.DisplaySets.Add(displaySet);
}
return imageSet;
}
public Study AddStudy(StudyTree studyTree)
{
var sops = BuildSops();
foreach (var sop in sops)
studyTree.AddSop(sop);
return studyTree.GetStudy(sops[0].StudyInstanceUid);
}
public void TestSeriesSplittingEnhancedMREcho()
{
const int numberOfSeries = 2;
const int instancesPerSeries = 3;
const int framesPerInstance = 10;
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
foreach (var dicomFile in dataSources.Select(d => d.File))
{
dicomFile.DataSet[DicomTags.NumberOfFrames].SetInt32(0, framesPerInstance);
if (dicomFile.DataSet[DicomTags.SeriesNumber].GetInt32(0, 0) != 2)
{
continue;
}
var dimUid = "1.2.3.4.5";
var mfdModule = new MultiFrameDimensionModuleIod(dicomFile.DataSet);
mfdModule.DimensionOrganizationSequence = new[] { new DimensionOrganizationSequenceItem {
DimensionOrganizationUid = dimUid
} };
mfdModule.DimensionIndexSequence = new[]
{
new DimensionIndexSequenceItem {
DimensionIndexPointer = DicomTags.StackId, FunctionalGroupPointer = DicomTags.FrameContentSequence, DimensionOrganizationUid = dimUid
},
new DimensionIndexSequenceItem {
DimensionIndexPointer = DicomTags.InStackPositionNumber, FunctionalGroupPointer = DicomTags.FrameContentSequence, DimensionOrganizationUid = dimUid
},
new DimensionIndexSequenceItem {
DimensionIndexPointer = DicomTags.EffectiveEchoTime, FunctionalGroupPointer = DicomTags.MrEchoSequence, DimensionOrganizationUid = dimUid
}
};
var mffgModule = new MultiFrameFunctionalGroupsModuleIod(dicomFile.DataSet);
mffgModule.PerFrameFunctionalGroupsSequence = Enumerable.Range(0, framesPerInstance).Select(i =>
{
var fg = new FunctionalGroupsSequenceItem();
ushort inStackPositionNumber = (ushort)(i % 5 + 1);
ushort echoNumber = (ushort)(i / 5 + 1);
fg.GetFunctionalGroup <FrameContentFunctionalGroup>().FrameContentSequence = new FrameContentSequenceItem {
InStackPositionNumber = inStackPositionNumber, StackId = "1", DimensionIndexValues = new uint[] { 1, inStackPositionNumber, echoNumber }
};
fg.GetFunctionalGroup <MrEchoFunctionalGroup>().MrEchoSequence = new MrEchoSequenceItem {
EffectiveEchoTime = echoNumber + 5 / 1000f
};
return(fg);
}).ToArray();
}
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
MREchoDisplaySetFactory factory = new MREchoDisplaySetFactory();
factory.SetStudyTree(studyTree);
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
try
{
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Assert.AreEqual(numberOfSeries, study.Series.Count, "There should be exactly {0} series", numberOfSeries);
Series series2 = study.Series[1];
foreach (Series series in study.Series)
{
Assert.AreEqual(instancesPerSeries, series.Sops.Count, "There should be exactly {0} sops", instancesPerSeries);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(series);
allDisplaySets.AddRange(displaySets);
if (series == series2)
{
Assert.AreEqual(2, displaySets.Count, "There should be exactly 4 display sets");
IDisplaySet displaySet = displaySets[0];
Assert.AreEqual(series.Sops.Count * framesPerInstance / 2, displaySet.PresentationImages.Count, "#presentation images should be #Sops/2");
Assert.AreNotEqual(series.SeriesInstanceUid, displaySet.Descriptor.Uid, "Series UID and Display Set UID don't match");
Assert.AreEqual(typeof(MREchoDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.IsTrue(displaySet.Name.Contains("Echo"), "Display Set name not correct");
ValidateMultiframeEchoDisplaySet(displaySets[0], 1);
ValidateMultiframeEchoDisplaySet(displaySets[1], 2);
}
else
{
//Assert.AreEqual(0, displaySets.Count, "There should be no display sets");
}
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
public void TestMixedMultiframes(int numberOfSingleFrames, int[] multiFramesNumberOfFrames)
{
const int numberOfSeries = 1;
int instancesPerSeries = numberOfSingleFrames + multiFramesNumberOfFrames.Length;
int numberOfMultiframes = multiFramesNumberOfFrames.Length;
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
for (int i = 0; i < numberOfMultiframes; i++)
{
dataSources[i].File.DataSet[DicomTags.NumberOfFrames].SetInt32(0, multiFramesNumberOfFrames[i]);
}
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
MixedMultiFrameDisplaySetFactory factory = new MixedMultiFrameDisplaySetFactory();
factory.SetStudyTree(studyTree);
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Series series = study.Series[0];
if (instancesPerSeries == 1)
{
try
{
Assert.AreEqual(instancesPerSeries, series.Sops.Count, "There should be exactly {0} sops", instancesPerSeries);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(series);
allDisplaySets.AddRange(displaySets);
Assert.AreEqual(0, displaySets.Count, "This scenario should produce no display sets");
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
else
{
try
{
Assert.AreEqual(instancesPerSeries, series.Sops.Count, "There should be exactly {0} sops", instancesPerSeries);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(series);
allDisplaySets.AddRange(displaySets);
if (series.SeriesInstanceUid == dataSources[0].SeriesInstanceUid)
{
int numberOfDisplaySets = numberOfSingleFrames > 0 ? 1 : 0;
numberOfDisplaySets += numberOfMultiframes;
Assert.AreEqual(numberOfDisplaySets, displaySets.Count, "There should be exactly {0} display sets", numberOfDisplaySets);
if (numberOfSingleFrames > 0)
{
IDisplaySet singleFramesDisplaySet = displaySets[0];
Assert.AreEqual(numberOfSingleFrames, singleFramesDisplaySet.PresentationImages.Count, "#Presentation images should match #singe frames in series");
Assert.AreEqual(typeof(SingleImagesDisplaySetDescriptor), singleFramesDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.AreEqual(String.Format("{0}:SingleImages", series.SeriesInstanceUid), singleFramesDisplaySet.Uid);
}
int multiFramesStartIndex = numberOfSingleFrames > 0 ? 1 : 0;
for (int i = multiFramesStartIndex; i < displaySets.Count; i++)
{
IDisplaySet multiFrameDisplaySet = displaySets[i];
int numberOfFrames = multiFramesNumberOfFrames[i - multiFramesStartIndex];
ImageSop multiFrame = ((IImageSopProvider)multiFrameDisplaySet.PresentationImages[0]).ImageSop;
Assert.AreEqual(numberOfFrames, multiFrameDisplaySet.PresentationImages.Count, "#Presentation images should match #frames in multiframe");
Assert.AreEqual(typeof(MultiframeDisplaySetDescriptor), multiFrameDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.AreEqual(multiFrame.SopInstanceUid, multiFrameDisplaySet.Uid);
}
}
else
{
Assert.AreEqual(0, displaySets.Count, "There should be no display sets");
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
}
internal static IEnumerable <IDisplaySet> CreateSeriesDisplaySets(Series series, StudyTree studyTree)
{
BasicDisplaySetFactory factory = new BasicDisplaySetFactory();
factory.SetStudyTree(studyTree);
return(factory.CreateDisplaySets(series));
}
void IPresentationImageFactory.SetStudyTree(StudyTree studyTree)
{
_studyTree = studyTree;
}
void IImageSetFactory.SetStudyTree(StudyTree studyTree)
{
_studyTree = studyTree;
_displaySetFactory.SetStudyTree(studyTree);
}
