void send_images(List <IPresentationImage> queue)
{
AEInformation destination = get_server();
SendSopInstancesRequest image_request = new SendSopInstancesRequest();
DicomSendServiceClient sender = new DicomSendServiceClient();
if (destination != null)
{
image_request.DestinationAEInformation = destination;
List <string> studyUids = new List <string>();
List <string> seriesUids = new List <string>();
List <string> imageSopUids = new List <string>();
foreach (IPresentationImage image in queue)
{
if (image is IImageSopProvider)
{
ImageSop imageSop = ((IImageSopProvider)image).ImageSop;
studyUids.Add(imageSop.StudyInstanceUid);
seriesUids.Add(imageSop.SeriesInstanceUid);
imageSopUids.Add(imageSop.SopInstanceUid);
}
}
image_request.StudyInstanceUid = studyUids[0];
image_request.SeriesInstanceUid = seriesUids[0];
image_request.SopInstanceUids = imageSopUids;
sender.SendSopInstances(image_request);
sender.Close();
LocalDataStoreActivityMonitorComponentManager.ShowSendReceiveActivityComponent(this.Context.DesktopWindow);
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
_frame = null;
_dicomFile = null;
if (_imageSop != null)
{
_imageSop.Dispose();
_imageSop = null;
}
if (_sopDataSource != null)
{
_sopDataSource.Dispose();
_sopDataSource = null;
}
if (_filename != null)
{
if (File.Exists(_filename))
{
File.Delete(_filename);
}
_filename = null;
}
}
base.Dispose(disposing);
}
private List <PresetVoiLut> GetApplicablePresets()
{
List <PresetVoiLut> presets = new List <PresetVoiLut>();
if (this.SelectedPresentationImage is IImageSopProvider)
{
//Only temporary until we enable the full functionality in the presets.
PresetVoiLut autoPreset = new PresetVoiLut(new AutoPresetVoiLutOperationComponent());
autoPreset.KeyStroke = XKeys.F2;
presets.Add(autoPreset);
ImageSop sop = ((IImageSopProvider)this.SelectedPresentationImage).ImageSop;
PresetVoiLutGroupCollection groups = PresetVoiLutSettings.DefaultInstance.GetPresetGroups();
PresetVoiLutGroup group = CollectionUtils.SelectFirst(groups,
delegate(PresetVoiLutGroup testGroup)
{
return(testGroup.AppliesTo(sop));
});
if (group != null)
{
foreach (PresetVoiLut preset in group.Clone().Presets)
{
if (preset.Operation.AppliesTo(this.SelectedPresentationImage))
{
presets.Add(preset);
}
}
}
presets.Sort(new PresetVoiLutComparer());
}
return(presets);
}
protected static IPresentationImage GetImage(ImageKey key)
{
string filename = string.Format(_testImagePathFormat, key.ToString().ToLower());
try
{
LocalSopDataSource dataSource = new LocalSopDataSource(filename);
ImageSop imageSop = new ImageSop(dataSource);
IPresentationImage theOne = null;
foreach (IPresentationImage image in PresentationImageFactory.Create(imageSop))
{
if (theOne == null)
{
theOne = image;
continue;
}
image.Dispose();
}
imageSop.Dispose();
return(theOne);
}
catch (Exception ex)
{
throw new FileNotFoundException("Unable to load requested test image. Please check that the assembly has been built.", filename, ex);
}
}
private IEnumerable <Frame> GetAcquisitionTimeTestFrames()
{
int i = 0;
foreach (DateTime dateTime in GetAquisitionDateTimes())
{
ImageSop sop = NewImageSop("123", "123", i++);
Frame frame = sop.Frames[1];
DicomMessageSopDataSource dataSource = ((DicomMessageSopDataSource)frame.ParentImageSop.DataSource);
if (i % 2 == 0)
{
dataSource.SourceMessage.DataSet[DicomTags.AcquisitionDate].SetStringValue(dateTime.Date.ToString(DateParser.DicomDateFormat));
dataSource.SourceMessage.DataSet[DicomTags.AcquisitionTime].SetStringValue(dateTime.ToString(TimeParser.DicomFullTimeFormat));
}
else
{
dataSource.SourceMessage.DataSet[DicomTags.AcquisitionDatetime].SetStringValue(dateTime.ToString(DateTimeParser.DicomFullDateTimeFormat));
}
yield return(frame);
sop.Dispose();
}
}
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);
}
protected virtual List <IPresentationImage> CreateImages(KeyImageContentItem item)
{
List <IPresentationImage> images = new List <IPresentationImage>();
ImageSop imageSop = FindReferencedImageSop(item.ReferencedImageSopInstanceUid, item.Source.GeneralStudy.StudyInstanceUid);
if (imageSop != null)
{
int frameNumber = item.FrameNumber.GetValueOrDefault(-1);
if (item.FrameNumber.HasValue)
{
// FramesCollection is a 1-based index!!!
if (frameNumber > 0 && frameNumber <= imageSop.Frames.Count)
{
images.Add(Create(imageSop.Frames[frameNumber]));
}
else
{
Platform.Log(LogLevel.Error, "The referenced key image {0} does not have a frame {1} (referenced in Key Object Selection {2})", item.ReferencedImageSopInstanceUid, frameNumber, item.Source.SopCommon.SopInstanceUid);
images.Add(new KeyObjectPlaceholderImage(SR.MessageReferencedKeyImageFrameNotFound));
}
}
else
{
foreach (Frame frame in imageSop.Frames)
{
images.Add(Create(frame));
}
}
Sop presentationStateSop = FindReferencedSop(item.PresentationStateSopInstanceUid, item.Source.GeneralStudy.StudyInstanceUid);
if (presentationStateSop != null)
{
foreach (IPresentationImage image in images)
{
if (image is IPresentationStateProvider)
{
try
{
IPresentationStateProvider presentationStateProvider = (IPresentationStateProvider)image;
presentationStateProvider.PresentationState = DicomSoftcopyPresentationState.Load(presentationStateSop.DataSource);
}
catch (Exception ex)
{
Platform.Log(LogLevel.Warn, ex, SR.MessagePresentationStateReadFailure);
}
}
}
}
}
else
{
Platform.Log(LogLevel.Warn, "The referenced key image {0} is not loaded as part of the current study (referenced in Key Object Selection {1})", item.ReferencedImageSopInstanceUid, item.Source.SopCommon.SopInstanceUid);
images.Add(new KeyObjectPlaceholderImage(SR.MessageReferencedKeyImageFromOtherStudy));
}
return(images);
}
public StoredLayout GetLayout(ImageSop imageSop)
{
if (imageSop == null)
{
return(this.DefaultLayout);
}
return(GetLayout(imageSop.Modality));
}
private static void TestVolume(bool signed, VolumeFunction f, IEnumerable <IVolumeSlicerParams> slicerParams, string testName, ImageKernelFunction imageKernel, VolumeKernelFunction volumeKernel)
{
const int FULL_SCALE = 65535;
VolumeFunction normalizedFunction = f.Normalize(100);
using (Volume volume = normalizedFunction.CreateVolume(100, signed))
{
float offset = signed ? -32768 : 0;
foreach (IVolumeSlicerParams slicing in slicerParams)
{
List <double> list = new List <double>();
using (VolumeSlicer slicer = new VolumeSlicer(volume, slicing, DicomUid.GenerateUid().UID))
{
foreach (ISopDataSource slice in slicer.CreateSlices())
{
using (ImageSop imageSop = new ImageSop(slice))
{
foreach (IPresentationImage image in PresentationImageFactory.Create(imageSop))
{
IImageSopProvider imageSopProvider = (IImageSopProvider)image;
IImageGraphicProvider imageGraphicProvider = (IImageGraphicProvider)image;
DicomImagePlane dip = DicomImagePlane.FromImage(image);
for (int y = 1; y < imageSopProvider.Frame.Rows - 1; y++)
{
for (int x = 1; x < imageSopProvider.Frame.Columns - 1; x++)
{
// pixels on the extreme sides of the volume tend to have more interpolation error due to MPR padding values
Vector3D vector = dip.ConvertToPatient(new PointF(x, y)); // +new Vector3D(-0.5f, -0.5f, 0);
if (Between(vector.X, 1, 98) && Between(vector.Y, 1, 98) && Between(vector.Z, 1, 98))
{
float expected = volumeKernel.Invoke(normalizedFunction, vector.X, vector.Y, vector.Z) + offset;
float actual = imageKernel.Invoke(imageGraphicProvider.ImageGraphic.PixelData, x, y);
list.Add(Math.Abs(expected - actual));
}
}
}
image.Dispose();
}
}
slice.Dispose();
}
}
Statistics stats = new Statistics(list);
Trace.WriteLine(string.Format("Testing {0}", testName));
Trace.WriteLine(string.Format("\tFunction/Slicing: {0} / {1}", normalizedFunction.Name, slicing.Description));
Trace.WriteLine(string.Format("\t Pixel Rep: {0}", signed ? "signed" : "unsigned"));
Trace.WriteLine(string.Format("\t Voxels Compared: {0}", list.Count));
Trace.WriteLine(string.Format("\t Mean Delta: {0:f2} ({1:p2} of full scale)", stats.Mean, stats.Mean / FULL_SCALE));
Trace.WriteLine(string.Format("\t StdDev Delta: {0:f2} ({1:p2} of full scale)", stats.StandardDeviation, stats.StandardDeviation / FULL_SCALE));
Assert.Less(stats.Mean, FULL_SCALE * 0.05, "Mean delta exceeds 5% of full scale ({0})", FULL_SCALE);
Assert.Less(stats.StandardDeviation, FULL_SCALE * 0.05, "StdDev delta exceeds 5% of full scale ({0})", FULL_SCALE);
}
}
}
protected internal byte[] GetOverlay(Frame baseFrame, out OverlayFrameParams overlayFrameParams)
{
var volume = this.Volume;
// compute the bounds of the target base image frame in patient coordinates
var baseTopLeft = baseFrame.ImagePlaneHelper.ConvertToPatient(new PointF(0, 0));
var baseTopRight = baseFrame.ImagePlaneHelper.ConvertToPatient(new PointF(baseFrame.Columns, 0));
var baseBottomLeft = baseFrame.ImagePlaneHelper.ConvertToPatient(new PointF(0, baseFrame.Rows));
var baseFrameCentre = (baseTopRight + baseBottomLeft) / 2;
// compute the rotated volume slicing basis axes
var volumeXAxis = (volume.ConvertToVolume(baseTopRight) - volume.ConvertToVolume(baseTopLeft)).Normalize();
var volumeYAxis = (volume.ConvertToVolume(baseBottomLeft) - volume.ConvertToVolume(baseTopLeft)).Normalize();
var volumeZAxis = volumeXAxis.Cross(volumeYAxis);
var @params = new VolumeSlicerParams(volumeXAxis, volumeYAxis, volumeZAxis);
using (var slice = new VolumeSliceSopDataSource(volume, @params, volume.ConvertToVolume(baseFrameCentre)))
{
using (var sliceSop = new ImageSop(slice))
{
using (var overlayFrame = sliceSop.Frames[1])
{
// compute the bounds of the target overlay image frame in patient coordinates
var overlayTopLeft = overlayFrame.ImagePlaneHelper.ConvertToPatient(new PointF(0, 0));
var overlayTopRight = overlayFrame.ImagePlaneHelper.ConvertToPatient(new PointF(overlayFrame.Columns, 0));
var overlayBottomLeft = overlayFrame.ImagePlaneHelper.ConvertToPatient(new PointF(0, overlayFrame.Rows));
var overlayOffset = overlayTopLeft - baseTopLeft;
// compute the overlay and base image resolution in pixels per unit patient space (mm).
var overlayResolutionX = overlayFrame.Columns / (overlayTopRight - overlayTopLeft).Magnitude;
var overlayResolutionY = overlayFrame.Rows / (overlayBottomLeft - overlayTopLeft).Magnitude;
var baseResolutionX = baseFrame.Columns / (baseTopRight - baseTopLeft).Magnitude;
var baseResolutionY = baseFrame.Rows / (baseBottomLeft - baseTopLeft).Magnitude;
// compute parameters to register the overlay on the base image
var scale = new PointF(baseResolutionX / overlayResolutionX, baseResolutionY / overlayResolutionY);
var offset = new PointF(overlayOffset.X * overlayResolutionX, overlayOffset.Y * overlayResolutionY);
//TODO (CR Sept 2010): could this be negative?
// validate computed transform parameters
Platform.CheckTrue(overlayOffset.Z < 0.5f, "Compute OffsetZ != 0");
overlayFrameParams = new OverlayFrameParams(
overlayFrame.Rows, overlayFrame.Columns,
overlayFrame.BitsAllocated, overlayFrame.BitsStored,
overlayFrame.HighBit, overlayFrame.PixelRepresentation != 0 ? true : false,
overlayFrame.PhotometricInterpretation == PhotometricInterpretation.Monochrome1 ? true : false,
overlayFrame.RescaleSlope, overlayFrame.RescaleIntercept,
scale, offset);
return(overlayFrame.GetNormalizedPixelData());
}
}
}
}
private static DisposableList <IPresentationImage> CreateImages(DicomFile dicomFile)
{
using (var dataSource = new LocalSopDataSource(dicomFile))
{
using (var sop = new ImageSop(dataSource))
{
return(new DisposableList <IPresentationImage>(PresentationImageFactory.Create(sop)));
}
}
}
public static void Create(IDesktopWindow desktopWindow, IImageViewer viewer)
{
IDisplaySet selectedDisplaySet = viewer.SelectedImageBox.DisplaySet;
string name = String.Format("{0} - Dynamic TE", selectedDisplaySet.Name);
IDisplaySet t2DisplaySet = new DisplaySet(name, "");
double currentSliceLocation = 0.0;
BackgroundTask task = new BackgroundTask(
delegate(IBackgroundTaskContext context)
{
int i = 0;
foreach (IPresentationImage image in selectedDisplaySet.PresentationImages)
{
IImageSopProvider imageSopProvider = image as IImageSopProvider;
if (imageSopProvider == null)
{
continue;
}
ImageSop imageSop = imageSopProvider.ImageSop;
Frame frame = imageSopProvider.Frame;
if (frame.SliceLocation != currentSliceLocation)
{
currentSliceLocation = frame.SliceLocation;
try
{
DynamicTePresentationImage t2Image = CreateT2Image(imageSop, frame);
t2DisplaySet.PresentationImages.Add(t2Image);
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e);
desktopWindow.ShowMessageBox("Unable to create T2 series. Please check the log for details.",
MessageBoxActions.Ok);
break;
}
}
string message = String.Format("Processing {0} of {1} images", i, selectedDisplaySet.PresentationImages.Count);
i++;
BackgroundTaskProgress progress = new BackgroundTaskProgress(i, selectedDisplaySet.PresentationImages.Count, message);
context.ReportProgress(progress);
}
}, false);
ProgressDialog.Show(task, desktopWindow, true, ProgressBarStyle.Blocks);
viewer.LogicalWorkspace.ImageSets[0].DisplaySets.Add(t2DisplaySet);
}
private void Select()
{
if (!this.Selected)
{
//Platform.CheckMemberIsSet(this.DisplaySet, "ImageBox.DisplaySet");
Platform.CheckMemberIsSet(this.ParentPhysicalWorkspace, "ImageBox.ParentPhysicalWorkspace");
Platform.CheckMemberIsSet(this.ImageViewer, "ImageBox.ImageViewer");
this.Selected = true;
_parentPhysicalWorkspace.SelectedImageBox = this;
this.ImageViewer.EventBroker.OnImageBoxSelected(new ImageBoxSelectedEventArgs(this));
if (_displaySet != null)
{
_displaySet.Selected = true;
}
}
try
{
ImageViewerComponent view = this.ImageViewer as ImageViewerComponent;
ActionModelNode node = view.ToolbarModel;
ActionModelNode tempNode = null;
IAction[] action = null;
foreach (ActionModelNode tempnode in node.ChildNodes)
{
if (tempnode.PathSegment.ResourceKey == "ToolbarSynchronizeStacking")
{
tempNode = tempnode;
break;
}
}
if (tempNode != null)
{
action = tempNode.GetActionsInOrder();
}
if ((action != null) && (action.Count() > 0))
{
ButtonAction ac = action[0] as ButtonAction;
ImageSop sop = ((IImageSopProvider)this.TopLeftPresentationImage).ImageSop;
if (sop.Modality == "DX" || sop.Modality == "CR" || sop.Modality == "RF")
{
ac.Checked = false;
}
else
{
ac.Checked = true;
}
}
}
catch (Exception ex)
{
}
}
private IEnumerable <PresentationImage> NewDicomImages(string studyUID, string seriesUID, int instanceNumber, int numberOfFrames)
{
ImageSop sop = NewImageSop(studyUID, seriesUID, instanceNumber, numberOfFrames);
for (int i = 1; i <= numberOfFrames; ++i)
{
yield return(new DicomGrayscalePresentationImage(sop.Frames[i]));
}
sop.Dispose();
}
protected static void ValidateVolumeSlicePoints(Volumes.Volume volume, IVolumeSlicerParams slicerParams, IList <KnownSample> expectedPoints,
double xAxialGantryTilt, double yAxialGantryTilt, bool gantryTiltInDegrees)
{
if (gantryTiltInDegrees)
{
xAxialGantryTilt *= Math.PI / 180;
yAxialGantryTilt *= Math.PI / 180;
}
Trace.WriteLine(string.Format("Using slice plane: {0}", slicerParams.Description));
using (VolumeSlicer slicer = new VolumeSlicer(volume, slicerParams))
{
foreach (ISopDataSource slice in slicer.CreateSliceSops())
{
using (ImageSop imageSop = new ImageSop(slice))
{
foreach (IPresentationImage image in PresentationImageFactory.Create(imageSop))
{
IImageGraphicProvider imageGraphicProvider = (IImageGraphicProvider)image;
DicomImagePlane dip = DicomImagePlane.FromImage(image);
foreach (KnownSample sample in expectedPoints)
{
Vector3D patientPoint = sample.Point;
if (xAxialGantryTilt != 0 && yAxialGantryTilt == 0)
{
float cos = (float)Math.Cos(xAxialGantryTilt);
float sin = (float)Math.Sin(xAxialGantryTilt);
patientPoint = new Vector3D(patientPoint.X,
patientPoint.Y * cos + (xAxialGantryTilt > 0 ? 100 * sin : 0),
patientPoint.Z / cos - patientPoint.Y * sin - (xAxialGantryTilt > 0 ? 100 * sin * sin / cos : 0));
}
else if (yAxialGantryTilt != 0)
{
Assert.Fail("Unit test not designed to work with gantry tilts about Y (i.e. slew)");
}
Vector3D slicedPoint = dip.ConvertToImagePlane(patientPoint);
if (slicedPoint.Z > -0.5 && slicedPoint.Z < 0.5)
{
int actual = imageGraphicProvider.ImageGraphic.PixelData.GetPixel((int)slicedPoint.X, (int)slicedPoint.Y);
Trace.WriteLine(string.Format("Sample {0} @{1} (SLICE: {2}; PATIENT: {3})", actual, FormatVector(sample.Point), FormatVector(slicedPoint), FormatVector(patientPoint)));
Assert.AreEqual(sample.Value, actual, "Wrong colour sample @{0}", sample.Point);
}
}
image.Dispose();
}
}
slice.Dispose();
}
}
}
public void Send()
{
foreach (IClipboardItem item in this.Context.SelectedClipboardItems)
{
string message = String.Format("{0}", item.ToString());
Platform.Log(LogLevel.Info, message);
List <IPresentationImage> image_queue = new List <IPresentationImage>();
// If Display set, then can use send series, else need to make list of images
// to send individually
if (item.Item is IDisplaySet)
{
Enqueue(image_queue, (IDisplaySet)item.Item);
ImageSop imageSop = ((IImageSopProvider)image_queue[0]).ImageSop;
string studyUid = imageSop.StudyInstanceUid;
string seriesUid = imageSop.SeriesInstanceUid;
// Check if display set contains all images in series by comparing number of
// images in display set with NumberOfFrames in DICOM header
int num_images_in_series = imageSop.ParentSeries.Sops.Count;
string message2 = String.Format("{0}", num_images_in_series + " ?= " + image_queue.Count);
Platform.Log(LogLevel.Info, message2);
// Send entire series
if (num_images_in_series.Equals(image_queue.Count))
{
send_series(studyUid, seriesUid);
}
else
{
send_images(image_queue);
}
}
else
{
if (item.Item is IPresentationImage)
{
Enqueue(image_queue, (IPresentationImage)item.Item);
}
else if (item.Item is IImageSet)
{
Enqueue(image_queue, (IImageSet)item.Item);
}
send_images(image_queue);
}
}
}
private void ValidateEchoDisplaySet(IDisplaySet displaySet, int echoNumber)
{
string seriesInstanceUid = null;
foreach (IPresentationImage presentationImage in displaySet.PresentationImages)
{
ImageSop sop = ((IImageSopProvider)presentationImage).ImageSop;
seriesInstanceUid = sop.SeriesInstanceUid;
Assert.AreEqual(echoNumber, sop[DicomTags.EchoNumbers].GetUInt32(0, 0), "Echo number must be {0} for each image in the series", echoNumber);
}
Assert.IsNotNull(seriesInstanceUid);
Assert.AreEqual(String.Format("{0}:Echo{1}", seriesInstanceUid, echoNumber), displaySet.Uid);
}
public TestPresentationImage() : base(TestPattern.CreateRGBKCorners(new Size(_width, _height)))
{
DicomFile dcf = new DicomFile();
dcf.DataSet[DicomTags.StudyInstanceUid].SetStringValue("1");
dcf.DataSet[DicomTags.SeriesInstanceUid].SetStringValue("2");
dcf.DataSet[DicomTags.SopInstanceUid].SetStringValue("3");
dcf.DataSet[DicomTags.SopClassUid].SetStringValue(SopClass.SecondaryCaptureImageStorageUid);
dcf.DataSet[DicomTags.InstanceNumber].SetStringValue("1");
dcf.DataSet[DicomTags.NumberOfFrames].SetStringValue("1");
dcf.MetaInfo[DicomTags.TransferSyntaxUid].SetStringValue(TransferSyntax.ImplicitVrLittleEndianUid);
dcf.MetaInfo[DicomTags.MediaStorageSopClassUid].SetStringValue(SopClass.SecondaryCaptureImageStorageUid);
dcf.MetaInfo[DicomTags.MediaStorageSopInstanceUid].SetStringValue("3");
_imageSop = new ImageSop(new TestDataSource(dcf));
}
public override bool Start(IMouseInformation mouseInformation)
{
if (this.SelectedImageGraphicProvider == null)
{
return(false);
}
_selectedTile = mouseInformation.Tile as Tile;
_selectedTile.InformationBox = new InformationBox();
_selectedImageGraphic = this.SelectedImageGraphicProvider.ImageGraphic;
_selectedImageSop = (this.SelectedPresentationImage as IImageSopProvider).ImageSop;
Probe(mouseInformation.Location);
return(true);
}
public void Save()
{
string path;
using (FolderBrowserDialog dialog = new FolderBrowserDialog())
{
dialog.Description = "Choose destination folder for saving DICOM images";
if (DialogResult.OK == dialog.ShowDialog())
{
path = dialog.SelectedPath;
}
else
{
return;
}
}
foreach (IClipboardItem item in this.Context.SelectedClipboardItems)
{
List <IPresentationImage> queue = new List <IPresentationImage>();
if (item.Item is IPresentationImage)
{
Enqueue(queue, (IPresentationImage)item.Item);
}
else if (item.Item is IDisplaySet)
{
Enqueue(queue, (IDisplaySet)item.Item);
}
else if (item.Item is IImageSet)
{
Enqueue(queue, (IImageSet)item.Item);
}
foreach (IPresentationImage image in queue)
{
if (image is IImageSopProvider)
{
ImageSop imageSop = ((IImageSopProvider)image).ImageSop;
ILocalSopDataSource localsource = (ILocalSopDataSource)imageSop.DataSource;
File.Copy(localsource.Filename, path + "\\" + imageSop[DicomTags.SopInstanceUid] + ".dcm");
}
}
}
}
private void TestSortingDisplaySetsBySeriesNumber(bool reverse)
{
DisplaySetCollection orderedCollection = new DisplaySetCollection();
DisplaySetCollection nonOrderedCollection = new DisplaySetCollection();
for (int i = 1; i <= 20; ++i)
{
string id = i.ToString();
DisplaySet displaySet = new DisplaySet(id, id);
ImageSop sop = NewImageSop(id, id, i);
IPresentationImage image = new DicomGrayscalePresentationImage(sop.Frames[1]);
sop.Dispose();
IImageSopProvider sopProvider = (IImageSopProvider)image;
DicomMessageSopDataSource dataSource = ((DicomMessageSopDataSource)sopProvider.ImageSop.DataSource);
dataSource.SourceMessage.DataSet[DicomTags.SeriesNumber].SetInt32(0, i);
displaySet.PresentationImages.Add(image);
orderedCollection.Add(displaySet);
}
Randomize(orderedCollection, nonOrderedCollection);
Debug.WriteLine("Before Sort\n------------------------\n");
CollectionUtils.ForEach(nonOrderedCollection, delegate(IDisplaySet displaySet) { Debug.WriteLine(String.Format("name: {0}", displaySet.Name)); });
nonOrderedCollection.Sort(new SeriesNumberComparer(reverse));
Debug.WriteLine("\nAfter Sort\n------------------------\n");
CollectionUtils.ForEach(nonOrderedCollection, delegate(IDisplaySet displaySet) { Debug.WriteLine(String.Format("name: {0}", displaySet.Name)); });
int j = reverse ? 20 : 1;
foreach (IDisplaySet set in nonOrderedCollection)
{
Assert.AreEqual(j.ToString(), set.Name);
j += reverse ? -1 : 1;
}
foreach (DisplaySet set in nonOrderedCollection)
{
set.Dispose();
}
foreach (DisplaySet set in orderedCollection)
{
set.Dispose();
}
}
public static bool IsValid(TreeNode node)
{
try
{
LocalSopDataSource _dicomDataSource = new LocalSopDataSource(((FileInfo)node.Tag).FullName);
ImageSop isop = new ImageSop(_dicomDataSource);
//DicomFile dcf = new DicomFile(((FileInfo)node.Tag).FullName);
//dcf.Load(DicomReadOptions.DoNotStorePixelDataInDataSet);
//00:00:01.5625000
//00:00:01.7625000
//00:00:00.0468750
}
catch (Exception ex)
{
return(false);
}
return(true);
}
private static bool IsSamePatient(IEnumerable <ISelectPresentationsInformation> collection)
{
string str = null;
foreach (ISelectPresentationsInformation local in collection)
{
ImageSop imageSop = ((IImageSopProvider)local.Image).ImageSop;
string str2 = imageSop.PatientId;
if (str == null)
{
str = str2;
}
else if (str != str2)
{
return(true);
}
}
return(false);
}
private IEnumerable <ImageSop> GetSliceLocationTestImageSops()
{
int i = 0;
int instanceNumber = 1;
foreach (ImageOrientationPatient orientation in GetSliceLocationOrientations())
{
for (int j = -3; j <= 3; ++j)
{
//we're not testing the study, series etc grouping because the 'instance and frame number one does that'
ImageSop sop = NewImageSop("123", "1", instanceNumber++);
DicomMessageSopDataSource dataSource = ((DicomMessageSopDataSource)sop.Frames[1].ParentImageSop.DataSource);
dataSource.SourceMessage.DataSet[DicomTags.ImagePositionPatient].SetStringValue(GetSliceLocationPosition(i, j).ToString());
dataSource.SourceMessage.DataSet[DicomTags.ImageOrientationPatient].SetStringValue(orientation.ToString());
yield return(sop);
}
++i;
}
}
private IImageSet CreateImageSet(string patientId, string description)
{
string studyInstanceUid = DicomUid.GenerateUid().UID;
string seriesInstanceUid = DicomUid.GenerateUid().UID;
string sopInstanceUid = DicomUid.GenerateUid().UID;
ImageSop sop = CreateImageSop(patientId, studyInstanceUid, seriesInstanceUid, sopInstanceUid);
DicomGrayscalePresentationImage img = new DicomGrayscalePresentationImage(sop.Frames[1]);
sop.Dispose();
DisplaySet displaySet = new DisplaySet(patientId, seriesInstanceUid);
displaySet.PresentationImages.Add(img);
ImageSet imageSet = new ImageSet();
imageSet.PatientInfo = description;
imageSet.DisplaySets.Add(displaySet);
return(imageSet);
}
public MockDicomPresentationImage(string filename) : base(new GrayscaleImageGraphic(10, 10))
{
if (Path.IsPathRooted(filename))
{
_filename = filename;
}
else
{
_filename = Path.Combine(Environment.CurrentDirectory, filename);
}
_dicomFile = new DicomFile();
_dicomFile.DataSet[DicomTags.SopClassUid].SetStringValue(SopClass.SecondaryCaptureImageStorageUid);
_dicomFile.DataSet[DicomTags.SopInstanceUid].SetStringValue(DicomUid.GenerateUid().UID);
_dicomFile.MetaInfo[DicomTags.MediaStorageSopClassUid].SetStringValue(_dicomFile.DataSet[DicomTags.SopClassUid].ToString());
_dicomFile.MetaInfo[DicomTags.MediaStorageSopInstanceUid].SetStringValue(_dicomFile.DataSet[DicomTags.SopInstanceUid].ToString());
_dicomFile.Save(_filename);
_sopDataSource = new LocalSopDataSource(_dicomFile);
_imageSop = new ImageSop(_sopDataSource);
_frame = new MockFrame(_imageSop, 1);
}
public DicomElement(string filePath)
{
this.FilePath = filePath;
DicomFile = new DicomFile(filePath);
DicomFile.Load();
ImageSop = new ClearCanvas.ImageViewer.StudyManagement.LocalImageSop(filePath);
PresentationImage =
PresentationImageFactory.Create(ImageSop.Frames[1]);
int width = ImageSop.Frames[1].Columns;
int height = ImageSop.Frames[1].Rows;
this.Bitmap = PresentationImage.DrawToBitmap(width, height);
if (DicomFile.DataSet[DicomTags.InstanceNumber] == null)
{
throw new Exception("Tag 'Instance Number' not found!");
}
this.InstanceNumber = DicomFile.DataSet[DicomTags.InstanceNumber].GetInt32(0, 1);
}
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 DynamicTePresentationImage CreateT2Image(ImageSop imageSop, Frame frame)
{
DicomFile pdMap = FindMap(imageSop.StudyInstanceUID, frame.SliceLocation, "PD");
pdMap.Load(DicomReadOptions.Default);
DicomFile t2Map = FindMap(imageSop.StudyInstanceUID, frame.SliceLocation, "T2");
t2Map.Load(DicomReadOptions.Default);
DicomFile probMap = FindMap(imageSop.StudyInstanceUID, frame.SliceLocation, "CHI2PROB");
probMap.Load(DicomReadOptions.Default);
DynamicTePresentationImage t2Image = new DynamicTePresentationImage(
frame,
(byte[])pdMap.DataSet[DicomTags.PixelData].Values,
(byte[])t2Map.DataSet[DicomTags.PixelData].Values,
(byte[])probMap.DataSet[DicomTags.PixelData].Values);
t2Image.DynamicTe.Te = 50.0f;
return(t2Image);
}
internal static AuditedInstances GetAuditedInstances(IEnumerable <ISelectPresentationsInformation> collection)
{
AuditedInstances instances = new AuditedInstances();
IEnumerator <ISelectPresentationsInformation> enumerator1 = collection.GetEnumerator();
using (IEnumerator <ISelectPresentationsInformation> enumerator = enumerator1)
{
while (enumerator.MoveNext())
{
ISelectPresentationsInformation selectitem = enumerator.Current;
IPresentationImage image = selectitem.Image;
IImageSopProvider provider = image as IImageSopProvider;
if (provider != null)
{
ImageSop imageSop = provider.ImageSop;
PersonName patientsName = imageSop.PatientsName;
string studyInstanceUid = imageSop.StudyInstanceUid;
instances.AddInstance(imageSop.PatientId, patientsName.ToString(), studyInstanceUid);
}
}
}
return(instances);
}
