public void ReAllocateStudyTree()
{
if (_studyTree != null)
{
_studyTree.Dispose();
_studyTree = null;
_studyTree = new StudyTree();
}
}
private void Test(StudyTree studyTree, StudyBuilder builder, DisplaySetCreationOptions options, bool expectModalityDisplaySet, int expectedDisplaySetCount)
{
var filler = new LayoutManager.ImageSetFiller(studyTree, options);
var imageSet = new ImageSet {
Uid = builder.StudyInstanceUid
};
var study = studyTree.Studies.First();
try
{
//NOTE: follow the same pattern as the layout manager where we add the "all images" display sets
//first, then we add ones for the individual series after.
filler.AddMultiSeriesDisplaySets(imageSet, study);
Assert.AreEqual(expectModalityDisplaySet ? 1 : 0, imageSet.DisplaySets.Count, "Empty Image Set");
foreach (var series in study.Series)
{
filler.AddSeriesDisplaySets(imageSet, series);
}
Assert.AreEqual(expectedDisplaySetCount, imageSet.DisplaySets.Count, "Display Set Counts");
}
finally
{
studyTree.Dispose();
imageSet.Dispose();
}
}
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 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();
}
}
/// <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;
}
}
}
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;
}
}
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 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();
}
}
}
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 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();
}
}
private void TestSeriesSplittingSingleImage_MixedMultiframeSeries(int numberOfMultiframes, int numberOfSingleframes)
{
const int numberOfSeries = 1;
int instancesPerSeries = numberOfMultiframes + numberOfSingleframes;
const int multiFrameNumberOfFrames = 5;
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
for (int i = 0; i < numberOfMultiframes; ++i)
{
TestDataSource multiFrameDataSource = dataSources[i];
multiFrameDataSource.File.DataSet[DicomTags.NumberOfFrames].SetInt32(0, multiFrameNumberOfFrames);
}
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
BasicDisplaySetFactory factory = new BasicDisplaySetFactory {
CreateSingleImageDisplaySets = instancesPerSeries > 1
};
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
int numberOfMultiframesFound = 0;
int numberOfSingleframesFound = 0;
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);
foreach (IDisplaySet displaySet in displaySets)
{
ImageSop imageSop = ((IImageSopProvider)displaySet.PresentationImages[0]).ImageSop;
if (imageSop.NumberOfFrames > 1)
{
++numberOfMultiframesFound;
Assert.AreEqual(multiFrameNumberOfFrames, displaySet.PresentationImages.Count, "There should be {0} presentation image per display set", multiFrameNumberOfFrames);
if (instancesPerSeries > 1)
{
Assert.AreEqual(typeof(MultiframeDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.IsTrue(displaySet.Name.Contains("Multiframe #"), "display set name doesn't contain \"Multiframe #\"");
}
}
else
{
++numberOfSingleframesFound;
Assert.AreEqual(1, displaySet.PresentationImages.Count, "There should be only one presentation image per display set");
if (instancesPerSeries > 1)
{
Assert.AreEqual(typeof(SingleImageDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.IsTrue(displaySet.Name.Contains("Image #"), "display set name doesn't contain \"Image #\"");
}
}
if (instancesPerSeries == 1)
{
if (numberOfMultiframes == 1)
{
Assert.AreEqual(multiFrameNumberOfFrames, displaySet.PresentationImages.Count, "There should be one presentation image per frame");
}
else
{
Assert.AreEqual(1, displaySet.PresentationImages.Count, "There should be only one presentation image per display set");
}
Assert.AreEqual(typeof(SeriesDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
}
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
Assert.AreEqual(numberOfMultiframes, numberOfMultiframesFound, "Incorrect number of multiframes");
Assert.AreEqual(numberOfSingleframes, numberOfSingleframesFound, "Incorrect number of singleframes");
}