/// <summary>
/// Constructs a new linear region of interest.
/// </summary>
/// <param name="point1">The first end point of the line.</param>
/// <param name="point2">The second end point of the line.</param>
/// <param name="presentationImage">The image containing the source pixel data.</param>
public LinearRoi(PointF point1, PointF point2, IPresentationImage presentationImage) : base(presentationImage)
{
List<PointF> points = new List<PointF>();
points.Add(point1);
points.Add(point2);
_points = points.AsReadOnly();
}
public void Apply(IPresentationImage image)
{
var transform = ResetImageOperation.GetSpatialTransform(image);
if (transform != null)
{
transform.Scale = 1.0f;
transform.TranslationX = 0.0f;
transform.TranslationY = 0.0f;
transform.FlipY = false;
transform.FlipX = false;
transform.RotationXY = 0;
transform.ScaleToFit = true;
}
var transform3D = ResetImageOperation.GetSpatialTransform3D(image);
if (transform3D != null)
{
transform3D.Scale = 1.0f;
transform3D.TranslationX = 0.0f;
transform3D.TranslationY = 0.0f;
transform3D.TranslationZ = 0.0f;
transform3D.FlipYZ = false;
transform3D.FlipXZ = false;
transform3D.FlipXY = false;
transform3D.Rotation = null;
}
}
public override string GetAnnotationText(IPresentationImage presentationImage)
{
if (presentationImage != null && presentationImage.ParentDisplaySet != null)
{
if (presentationImage.ParentDisplaySet.ParentImageSet != null)
{
return String.Format(SR.FormatDisplaySetNumberAndCount, presentationImage.ParentDisplaySet.Number,
presentationImage.ParentDisplaySet.ParentImageSet.DisplaySets.Count);
}
else
{
// try to find a corresponding display set in the logical workspace with a matching UID, and let display set number reflect that
// this happens particularly when the image is part of a generated display set derived from a display set based on stored DICOM SOP instances
var displaySetUid = presentationImage.ParentDisplaySet.Uid ?? string.Empty;
var sourceDisplaySet = presentationImage.ImageViewer.LogicalWorkspace.ImageSets.SelectMany(s => s.DisplaySets).FirstOrDefault(s => s.Uid == displaySetUid);
if (sourceDisplaySet != null)
return string.Format(SR.FormatDisplaySetNumberAndCount, sourceDisplaySet.Number, sourceDisplaySet.ParentImageSet.DisplaySets.Count);
return presentationImage.ParentDisplaySet.Number.ToString(System.Globalization.CultureInfo.InvariantCulture);
}
}
else
{
return "";
}
}
/// <summary>
/// Initializes a new instance of <see cref="PresentationImageChangedEventArgs"/>.
/// </summary>
/// <param name="oldPresentationImage"></param>
/// <param name="newPresentationImage"></param>
public PresentationImageChangedEventArgs(
IPresentationImage oldPresentationImage,
IPresentationImage newPresentationImage)
{
_oldPresentationImage = oldPresentationImage;
_newPresentationImage = newPresentationImage;
}
/// <summary>
/// Gets the annotation text.
/// </summary>
/// <param name="presentationImage">the input presentation image.</param>
/// <returns>the annotation text.</returns>
public override string GetAnnotationText(IPresentationImage presentationImage)
{
string markerText = "";
if (presentationImage != null)
{
ISpatialTransformProvider associatedTransform = presentationImage as ISpatialTransformProvider;
IImageSopProvider associatedDicom = presentationImage as IImageSopProvider;
if (associatedDicom != null && associatedTransform != null)
{
var spatialTransform = associatedTransform.SpatialTransform as SpatialTransform;
if (spatialTransform != null)
{
var imageOrientationPatient = associatedDicom.Frame.ImageOrientationPatient;
var patientOrientation = associatedDicom.Frame.PatientOrientation;
if (imageOrientationPatient != null && !imageOrientationPatient.IsNull)
markerText = GetAnnotationTextInternal(spatialTransform, imageOrientationPatient);
else if (patientOrientation != null && patientOrientation.IsValid)
markerText = GetAnnotationTextInternal(spatialTransform, patientOrientation);
}
}
}
return markerText;
}
private static IMemorable GetLayerOpacityManager(IPresentationImage image)
{
if (image is FusionPresentationImage)
return ((FusionPresentationImage) image).LayerOpacityManager;
return null;
}
private static IMemorable GetTransform(IPresentationImage image)
{
if (image is ISpatialTransformProvider)
return ((ISpatialTransformProvider)image).SpatialTransform;
return null;
}
private static IMemorable GetVoiLutManager(IPresentationImage image)
{
if (image is IVoiLutProvider)
return ((IVoiLutProvider)image).VoiLutManager;
return null;
}
/// <summary>
/// Constructs a new region of interest, specifying an <see cref="IPresentationImage"/> as the source of the pixel data.
/// </summary>
/// <param name="presentationImage">The image containing the source pixel data.</param>
protected Roi(IPresentationImage presentationImage)
{
IImageGraphicProvider provider = presentationImage as IImageGraphicProvider;
if (provider == null)
return;
_imageRows = provider.ImageGraphic.Rows;
_imageColumns = provider.ImageGraphic.Columns;
_presentationImage = presentationImage;
_pixelData = provider.ImageGraphic.PixelData;
if (presentationImage is IModalityLutProvider)
_modalityLut = ((IModalityLutProvider) presentationImage).ModalityLut;
if (presentationImage is IImageSopProvider)
{
Frame frame = ((IImageSopProvider) presentationImage).Frame;
_normalizedPixelSpacing = frame.NormalizedPixelSpacing;
_pixelAspectRatio = frame.PixelAspectRatio;
_modality = frame.ParentImageSop.Modality;
_modalityLutUnits = frame.RescaleUnits;
_subnormalModalityLut = frame.IsSubnormalRescale;
}
else
{
_normalizedPixelSpacing = new PixelSpacing(0, 0);
_pixelAspectRatio = new PixelAspectRatio(0, 0);
_modalityLutUnits = RescaleUnits.None;
_subnormalModalityLut = false;
}
}
public static DicomImagePlane FromImage(IPresentationImage sourceImage)
{
if (sourceImage == null)
return null;
Frame frame = GetFrame(sourceImage);
SpatialTransform transform = GetSpatialTransform(sourceImage);
if (transform == null || frame == null)
return null;
if (String.IsNullOrEmpty(frame.FrameOfReferenceUid) || String.IsNullOrEmpty(frame.ParentImageSop.StudyInstanceUid))
return null;
DicomImagePlane plane;
if (_referenceCount > 0)
plane = CreateFromCache(frame);
else
plane = CreateFromFrame(frame);
if (plane != null)
{
plane._sourceImage = sourceImage;
plane._sourceImageTransform = transform;
plane._sourceFrame = frame;
}
return plane;
}
public override string GetAnnotationText(IPresentationImage presentationImage)
{
if (presentationImage == null)
return String.Empty;
IImageSopProvider imageSopProvider = presentationImage as IImageSopProvider;
if (imageSopProvider == null)
return String.Empty;
ISpatialTransformProvider spatialTransformProvider = presentationImage as ISpatialTransformProvider;
if (spatialTransformProvider == null)
return String.Empty;
// 2D DFOV value doesn't make a lot of sense when the "image" is 3D, so we're blanking it out until we define what DFOV means in this context
if (presentationImage is ISpatialTransform3DProvider)
return String.Empty;
IImageSpatialTransform transform = spatialTransformProvider.SpatialTransform as IImageSpatialTransform;
if (transform == null)
return String.Empty;
if (transform.RotationXY%90 != 0)
return SR.ValueNotApplicable;
Frame frame = imageSopProvider.Frame;
PixelSpacing normalizedPixelSpacing = frame.NormalizedPixelSpacing;
if (normalizedPixelSpacing.IsNull)
return String.Empty;
RectangleF sourceRectangle = new RectangleF(0, 0, frame.Columns, frame.Rows);
RectangleF destinationRectangle = transform.ConvertToDestination(sourceRectangle);
destinationRectangle = RectangleUtilities.Intersect(destinationRectangle, presentationImage.ClientRectangle);
//Convert the displayed width and height to source dimensions
SizeF widthInSource = transform.ConvertToSource(new SizeF(destinationRectangle.Width, 0));
SizeF heightInSource = transform.ConvertToSource(new SizeF(0, destinationRectangle.Height));
//The displayed FOV is given by the magnitude of each line in source coordinates, but
//for each of the 2 lines, one of x or y will be zero, so we can optimize.
float x1 = Math.Abs(widthInSource.Width);
float y1 = Math.Abs(widthInSource.Height);
float x2 = Math.Abs(heightInSource.Width);
float y2 = Math.Abs(heightInSource.Height);
double displayedFieldOfViewX, displayedFieldOfViewY;
if (x1 > y1) //the image is not rotated
{
displayedFieldOfViewX = x1*normalizedPixelSpacing.Column/10;
displayedFieldOfViewY = y2*normalizedPixelSpacing.Row/10;
}
else //the image is rotated by 90 or 270 degrees
{
displayedFieldOfViewX = x2*normalizedPixelSpacing.Column/10;
displayedFieldOfViewY = y1*normalizedPixelSpacing.Row/10;
}
return String.Format(SR.FormatCentimeters, String.Format(SR.Format2Dimensions, displayedFieldOfViewX.ToString("F1"), displayedFieldOfViewY.ToString("F1")));
}
public IMemorable GetOriginator(IPresentationImage image)
{
if (image is IVoiLutProvider)
return ((IVoiLutProvider) image).VoiLutManager;
return null;
}
public override string GetAnnotationText(IPresentationImage presentationImage)
{
if (presentationImage != null && presentationImage.ParentDisplaySet != null)
return presentationImage.ParentDisplaySet.Description ?? "";
else
return "";
}
/// <summary>
/// Adds an <see cref="IPresentationImage"/> to the clipboard.
/// </summary>
/// <param name="image"></param>
/// <remarks>
/// When called, a copy of the specified <see cref="IPresentationImage"/> is made and stored
/// in the clipbaord. This ensures that the <see cref="IPresentationImage"/> is in fact a
/// snapshot and not a reference that could be changed in unpredictable ways.
/// Pixel data, however, is not replicated.
/// </remarks>
public static void Add(IPresentationImage image)
{
Platform.CheckForNullReference(image, "image");
var clipboard = Default;
clipboard._items.Add(clipboard.CreatePresentationImageItem(image));
}
public override string GetAnnotationText(IPresentationImage presentationImage)
{
var imageSopProvider = presentationImage as IImageSopProvider;
if (imageSopProvider == null)
return string.Empty;
var details = imageSopProvider.Frame.NormalizedPixelSpacing.CalibrationDetails;
switch (imageSopProvider.Frame.NormalizedPixelSpacing.CalibrationType)
{
case NormalizedPixelSpacingCalibrationType.None:
return string.Empty;
case NormalizedPixelSpacingCalibrationType.Manual:
return SR.ValueManualCalibration;
case NormalizedPixelSpacingCalibrationType.CrossSectionalSpacing:
return SR.ValueActualSpacingCalibration;
case NormalizedPixelSpacingCalibrationType.Detector:
return SR.ValueDetectorSpacingCalibration;
case NormalizedPixelSpacingCalibrationType.Geometry:
return FormatCalibrationDetails(SR.ValueGeometricCalibration, details);
case NormalizedPixelSpacingCalibrationType.Fiducial:
return FormatCalibrationDetails(SR.ValueFiducialCalibration, details);
case NormalizedPixelSpacingCalibrationType.Magnified:
return FormatCalibrationDetails(SR.ValueMagnifiedCalibration, details);
case NormalizedPixelSpacingCalibrationType.Unknown:
default:
return FormatCalibrationDetails(SR.ValueUnknownCalibration, details);
}
}
public override string GetAnnotationText(IPresentationImage presentationImage)
{
IImageSopProvider provider = presentationImage as IImageSopProvider;
if (provider == null)
return "";
Frame frame = provider.Frame;
string str;
if (frame.ParentImageSop.ParentSeries != null)
{
//TODO: figure out how to do this without the parent series!
str = String.Format(SR.FormatImageNumberAndCount, frame.ParentImageSop.InstanceNumber, frame.ParentImageSop.ParentSeries.Sops.Count);
}
else
{
str = frame.ParentImageSop.InstanceNumber.ToString();
}
if (frame.ParentImageSop.NumberOfFrames > 1)
{
string frameString = String.Format(
SR.FormatFrameNumberAndCount,
frame.FrameNumber,
frame.ParentImageSop.NumberOfFrames);
str += " " + frameString;
}
return str;
}
public static bool IsImageMarkupPresent(IPresentationImage image)
{
IOverlayGraphicsProvider currentOverlayGraphics = image as IOverlayGraphicsProvider;
if (currentOverlayGraphics != null)
{
foreach (IGraphic graphic in currentOverlayGraphics.OverlayGraphics)
{
if (graphic is RoiGraphic)
return true;
ContextMenuControlGraphic contextMenuControlGraphic = graphic as ContextMenuControlGraphic;
if (contextMenuControlGraphic != null && contextMenuControlGraphic.Subject != null)
{
UserCalloutGraphic userCalloutGraphic = contextMenuControlGraphic.Subject as UserCalloutGraphic;
if (userCalloutGraphic != null)
return true;
InvariantTextPrimitive invariantTextPrimitive = contextMenuControlGraphic.Subject as InvariantTextPrimitive;
if (invariantTextPrimitive != null)
return true;
UserCrosshairCalloutGraphic crosshairGraphic = contextMenuControlGraphic.Subject as UserCrosshairCalloutGraphic;
if (crosshairGraphic != null)
return true;
}
}
}
return false;
}
public static GraphicsVisibilityHelper CreateForOverlayGraphics(IPresentationImage image)
{
var provider = image as IOverlayGraphicsProvider;
if (provider == null)
return null;
return new GraphicsVisibilityHelper(provider.OverlayGraphics);
}
protected override void UpdateVisibility(IPresentationImage image, bool visible)
{
if (image is IDicomPresentationImage)
{
foreach (OverlayPlaneGraphic overlayGraphic in GetOverlayPlanesGraphic(image as IDicomPresentationImage))
overlayGraphic.Visible = Checked;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="referenceImage">The 'current' (or reference) <see cref="IPresentationImage"/>.</param>
/// <param name="operation">The operation to be performed on the current <see cref="IPresentationImage"/> and/or its linked images.</param>
public ImageOperationApplicator(IPresentationImage referenceImage, IUndoableOperation<IPresentationImage> operation)
{
Platform.CheckForNullReference(referenceImage, "referenceImage");
Platform.CheckForNullReference(operation, "operation");
_imageEnumerator = new LinkedImageEnumerator(referenceImage);
_operation = operation;
}
public static DicomImagePlane FromImage(IPresentationImage sourceImage)
{
if (sourceImage == null)
return null;
Frame frame = GetFrame(sourceImage);
return FromFrame(frame);
}
public ProtractorRoi(PointF point1, PointF vertex, PointF point2, IPresentationImage presentationImage)
: base(presentationImage)
{
_points = new List<PointF>();
_points.Add(point1);
_points.Add(vertex);
_points.Add(point2);
}
/// <summary>
/// Determines and returns the initial Voi Lut that should be applied to the input <see cref="IPresentationImage"/>.
/// </summary>
/// <param name="presentationImage">The <see cref="IPresentationImage"/> whose intial Lut is to be determined.</param>
/// <returns>The Voi Lut as an <see cref="IVoiLut"/>.</returns>
public IVoiLut GetLut(IPresentationImage presentationImage)
{
IVoiLut lut = null;
if (_extensionProvider != null)
lut = _extensionProvider.GetLut(presentationImage);
return lut;
}
protected override void UpdateVisibility(IPresentationImage image, bool visible)
{
if (image is IAnnotationLayoutProvider)
{
foreach (AnnotationBox box in ((IAnnotationLayoutProvider)image).AnnotationLayout.AnnotationBoxes)
box.Visible = visible;
}
}
public override void Apply(IPresentationImage presentationImage)
{
var applicator = AutoVoiLutApplicator.Create(presentationImage);
if (applicator == null)
throw new InvalidOperationException("The input presentation image is not supported.");
applicator.ApplyNextLut();
}
private ImageItem DoInsertImage(IPresentationImage pImage) {
IImageSopProvider sop = pImage as IImageSopProvider;
DicomFile dcf = sop.ImageSop.NativeDicomObject as DicomFile;
PatientItem patient = _patients.GetById(dcf.DataSet);
StudyItem study = patient.Studies.GetByUid(dcf.DataSet);
SeriesItem series = study.Series.GetByUid(dcf.DataSet);
ImageItem image = series.Images.GetByUid(dcf, pImage);
return image;
}
public override void SetOverlayVisible(IPresentationImage image, bool visible)
{
var annotationLayoutProvider = image as IAnnotationLayoutProvider;
if (annotationLayoutProvider == null)
return;
foreach (AnnotationBox box in annotationLayoutProvider.AnnotationLayout.AnnotationBoxes)
box.Visible = visible;
}
internal static string BuildMessage(IPresentationImage sourceImage)
{
string message = "An error has occurred while attempting to clone an image";
if (!String.IsNullOrEmpty(sourceImage.Uid))
message += string.Format(" (uid = {0})", sourceImage.Uid);
message += ".";
return message;
}
/// <summary>
/// Constructs a new polygonal region of interest.
/// </summary>
/// <param name="vertices">The ordered vertices defining the polygonal region of interest.</param>
/// <param name="presentationImage">The image containing the source pixel data.</param>
public PolygonalRoi(IEnumerable<PointF> vertices, IPresentationImage presentationImage) : base(presentationImage)
{
var list = new List<PointF>(vertices);
if (list.Count < 3) // a valid list of vertices needs 3 items
throw new ArgumentException("Three vertices are required to define a polygon.", "vertices");
// vertices should not contain repeated start point
_polygon = new PolygonF(vertices);
}
public override void SetOverlayVisible(IPresentationImage image, bool visible)
{
var dicomPresentationImage = image as IDicomPresentationImage;
if (dicomPresentationImage == null) return;
DicomGraphicsPlane dicomGraphicsPlane = DicomGraphicsPlane.GetDicomGraphicsPlane(dicomPresentationImage, true);
if (dicomGraphicsPlane != null)
dicomGraphicsPlane.Layers.Enabled = visible;
}
/// <summary>
/// Constructs a new region of interest, specifying an <see cref="IPresentationImage"/> as the source of the pixel data.
/// </summary>
/// <param name="presentationImage">The image containing the source pixel data.</param>
protected Roi(IPresentationImage presentationImage)
{
_presentationImage = presentationImage;
IImageGraphicProvider provider = presentationImage as IImageGraphicProvider;
if (provider != null)
{
_imageRows = provider.ImageGraphic.Rows;
_imageColumns = provider.ImageGraphic.Columns;
_pixelData = provider.ImageGraphic.PixelData;
}
var modalityLutProvider = presentationImage as IModalityLutProvider;
if (modalityLutProvider != null)
{
_modalityLut = (modalityLutProvider).ModalityLut;
}
if (presentationImage is IImageSopProvider)
{
Frame frame = ((IImageSopProvider)presentationImage).Frame;
_normalizedPixelSpacing = frame.NormalizedPixelSpacing;
_pixelAspectRatio = frame.PixelAspectRatio;
_modality = frame.ParentImageSop.Modality;
_modalityLutUnits = frame.RescaleUnits;
_subnormalModalityLut = frame.IsSubnormalRescale;
}
else
{
_normalizedPixelSpacing = new PixelSpacing(0, 0);
_pixelAspectRatio = new PixelAspectRatio(0, 0);
_modalityLutUnits = RescaleUnits.None;
_subnormalModalityLut = false;
}
}
private void AddPinwheelGraphic()
{
IPresentationImage selectedImage = base.SelectedPresentationImage;
if (selectedImage == null)
{
return;
}
if (!base.IsMprImage(selectedImage))
{
return;
}
MprDisplaySet displaySet = (MprDisplaySet)selectedImage.ParentDisplaySet;
if (displaySet.Identifier == MprDisplaySetIdentifier.Oblique)
{
return;
}
IOverlayGraphicsProvider overlayProvider = selectedImage as IOverlayGraphicsProvider;
IImageGraphicProvider imageGraphicProvider = selectedImage as IImageGraphicProvider;
if (overlayProvider != null && imageGraphicProvider != null)
{
_currentPinwheelGraphic = new PinwheelGraphic();
int width = imageGraphicProvider.ImageGraphic.Columns;
int height = imageGraphicProvider.ImageGraphic.Rows;
overlayProvider.OverlayGraphics.Add(_currentPinwheelGraphic);
_currentPinwheelGraphic.CoordinateSystem = CoordinateSystem.Source;
_currentPinwheelGraphic.Rotation = GetRotationAngle();
_currentPinwheelGraphic.Draw();
}
}
/// <summary>
/// Computes the closest image in a display set to the specified position in patient coordinates.
/// </summary>
private static IPresentationImage GetClosestSlice(Vector3D positionPatient, IDisplaySet displaySet)
{
float closestDistance = float.MaxValue;
IPresentationImage closestImage = null;
foreach (IPresentationImage image in displaySet.PresentationImages)
{
if (image is IImageSopProvider)
{
Frame frame = (image as IImageSopProvider).Frame;
Vector3D positionCenterOfImage = frame.ImagePlaneHelper.ConvertToPatient(new PointF((frame.Columns - 1) / 2F, (frame.Rows - 1) / 2F));
Vector3D distanceVector = positionCenterOfImage - positionPatient;
float distance = distanceVector.Magnitude;
if (distance <= closestDistance)
{
closestDistance = distance;
closestImage = image;
}
}
}
return(closestImage);
}
/// <summary>
/// Moves the graphic from where ever it is to the target image.
/// </summary>
private static void TranslocateGraphic(IGraphic graphic, IPresentationImage targetImage)
{
IPresentationImage oldImage = graphic.ParentPresentationImage;
if (oldImage != targetImage)
{
IApplicationGraphicsProvider imageOnUnexecute = oldImage as IApplicationGraphicsProvider;
if (imageOnUnexecute != null)
{
imageOnUnexecute.ApplicationGraphics.Remove(graphic);
}
IApplicationGraphicsProvider imageOnExecute = targetImage as IApplicationGraphicsProvider;
if (imageOnExecute != null)
{
imageOnExecute.ApplicationGraphics.Add(graphic);
}
if (oldImage != null)
{
oldImage.Draw();
}
}
}
/// <summary>
/// Draws the Text Overlay.
/// </summary>
protected void DrawTextOverlay(IPresentationImage presentationImage)
{
#if DEBUG
CodeClock clock = new CodeClock();
clock.Start();
#endif
var layoutProvider = presentationImage as IAnnotationLayoutProvider;
if (layoutProvider == null)
{
return;
}
var layout = layoutProvider.AnnotationLayout;
if (layout == null || !layout.Visible)
{
return;
}
foreach (AnnotationBox annotationBox in layout.AnnotationBoxes)
{
if (!annotationBox.Visible)
{
continue;
}
string annotationText = annotationBox.GetAnnotationText(presentationImage);
if (!String.IsNullOrEmpty(annotationText))
{
DrawAnnotationBox(annotationText, annotationBox);
}
}
#if DEBUG
clock.Stop();
PerformanceReportBroker.PublishReport(_rendererTypeId, "DrawTextOverlay", clock.Seconds);
#endif
}
public RenderImageHelper(IPresentationImage image)
{
_image = image;
var annotationLayoutProvider = image as IAnnotationLayoutProvider;
if (annotationLayoutProvider != null)
{
_annotationLayoutVisible = annotationLayoutProvider.AnnotationLayout.Visible;
annotationLayoutProvider.AnnotationLayout.Visible = false;
}
var overlayGraphicsProvider = image as IOverlayGraphicsProvider;
if (overlayGraphicsProvider != null)
{
_overlayGraphicsVisible = overlayGraphicsProvider.OverlayGraphics.Visible;
overlayGraphicsProvider.OverlayGraphics.Visible = true;
}
var applicationGraphicsProvider = image as IApplicationGraphicsProvider;
if (applicationGraphicsProvider != null)
{
_applicationGraphicsVisible = applicationGraphicsProvider.ApplicationGraphics.Visible;
applicationGraphicsProvider.ApplicationGraphics.Visible = false;
}
var dicomPresentationImage = image as IDicomPresentationImage;
if (dicomPresentationImage != null)
{
_dicomGraphicsVisible = dicomPresentationImage.DicomGraphics.Visible;
dicomPresentationImage.DicomGraphics.Visible = false;
}
}
public void Delete()
{
IGraphic graphic = base.Context.Graphic;
if (graphic == null)
{
return;
}
IPresentationImage image = graphic.ParentPresentationImage;
if (image == null)
{
return;
}
DrawableUndoableCommand command = new DrawableUndoableCommand(graphic.ParentPresentationImage);
command.Enqueue(new RemoveGraphicUndoableCommand(graphic));
command.Execute();
command.Name = SR.CommandDeleteAnnotation;
image.ImageViewer.CommandHistory.AddCommand(command);
}
private static Bitmap DrawCompleteImageToBitmap(IPresentationImage image, float scale, float dpi)
{
IImageSpatialTransform transform = (IImageSpatialTransform)((ISpatialTransformProvider)image).SpatialTransform;
object restoreMemento = transform.CreateMemento();
try
{
Rectangle imageRectangle = new Rectangle(new Point(0, 0), image.SceneSize);
transform.Initialize();
transform.ScaleToFit = false;
transform.Scale = scale;
RectangleF displayRectangle = transform.ConvertToDestination(imageRectangle);
int width = (int)Math.Round(displayRectangle.Width);
int height = (int)Math.Round(displayRectangle.Height);
transform.ScaleToFit = true;
return(ImageDrawToBitmap(image, width, height, dpi));
}
finally
{
transform.SetMemento(restoreMemento);
}
}
public static bool UpdateKeyImage(this IPresentationImage image, KeyImageInformation context)
{
if (context != null)
{
var presentationStateUid = GetPresentationStateSopInstanceUid(image);
var clipboardItems = context.Items;
var result = clipboardItems.Where(IsSerialized).Select((k, i) => new { k.Item, Index = i, MetaData = k.ExtensionData.GetOrCreate <KeyImageItemMetaData>() }).FirstOrDefault(c => GetPresentationStateSopInstanceUid((c.Item as IPresentationImage)) == presentationStateUid);
if (result != null)
{
var keyImageItem = context.CreateKeyImageItem(image, hasChanges: true);
var metadata = ((IClipboardItem)keyImageItem).ExtensionData.GetOrCreate <KeyImageItemMetaData>();
metadata.Changes = true;
metadata.Guid = result.MetaData.Guid;
metadata.KoSopInstanceUid = result.MetaData.KoSopInstanceUid;
metadata.OriginalItem = result.MetaData.OriginalItem ?? clipboardItems[result.Index];
clipboardItems[result.Index] = keyImageItem;
return(true);
}
}
return(false);
}
/// <summary>
/// Gets the text to be rendered into the area defined by <see cref="NormalizedRectangle"/> for the input <paramref name="presentationImage"/>.
/// </summary>
/// <param name="presentationImage">The presentation image.</param>
public string GetAnnotationText(IPresentationImage presentationImage)
{
if (_annotationItem == null)
{
return(string.Empty);
}
string annotationText = _annotationItem.GetAnnotationText(presentationImage);
string annotationLabel = _annotationItem.GetLabel();
if (string.IsNullOrEmpty(annotationText))
{
if (this.ConfigurationOptions.ShowLabelIfValueEmpty)
{
annotationText = string.Format(SR.FormatAnnotationItem, annotationLabel, SR.ValueNil);
}
}
else if (this.ConfigurationOptions.ShowLabel)
{
annotationText = string.Format(SR.FormatAnnotationItem, annotationLabel, annotationText);
}
return(annotationText);
}
protected static Bitmap DrawToBitmap(IPresentationImage presentationImage)
{
var imageGraphicProvider = (IImageGraphicProvider)presentationImage;
var annotationLayoutProvider = presentationImage as IAnnotationLayoutProvider;
var annotationLayoutVisible = true;
if (annotationLayoutProvider != null)
{
annotationLayoutVisible = annotationLayoutProvider.AnnotationLayout.Visible;
annotationLayoutProvider.AnnotationLayout.Visible = false;
}
try
{
return(presentationImage.DrawToBitmap(imageGraphicProvider.ImageGraphic.Columns, imageGraphicProvider.ImageGraphic.Rows));
}
finally
{
if (annotationLayoutProvider != null)
{
annotationLayoutProvider.AnnotationLayout.Visible = annotationLayoutVisible;
}
}
}
// Populates given IPresentationImage with graphics from the given annotation
internal bool ReadGraphicsFromAnnotation(IAimDocumentInstance annotationDoc, IPresentationImage presentationImage)
{
if (annotationDoc == null)
{
return(false);
}
Platform.CheckForNullReference(presentationImage, "presentationImage");
var isRead = false;
switch (annotationDoc.AimVersion)
{
case AimVersion.AimVersion3:
var aim3AnnotationDoc = (Aim3.Aim3DocumentInstance)annotationDoc;
foreach (var annotation in aim3AnnotationDoc.AimAnnotations.OfType <Aim3.Aim3AnnotationInstance>())
{
isRead |= Aim3.AimNativeConverter.ReadGraphicsFromAnnotation(annotation, presentationImage);
}
break;
case AimVersion.AimVersion4:
var aim4AnnotationDoc = (Aim4.Aim4DocumentInstance)annotationDoc;
foreach (var annotation in aim4AnnotationDoc.AimAnnotations.OfType <Aim4.Aim4AnnotationInstance>())
{
isRead |= Aim4.AimNativeConverter.ReadGraphicsFromAnnotation(annotation, presentationImage);
}
break;
default:
Debug.Assert(false, "AimManager.ReadGraphicsFromAnnotation: Unexpected AIM version");
break;
}
return(isRead);
}
public static AutoVoiLutSelector CreateFrom(IPresentationImage image)
{
var applicator = AutoVoiLutApplicator.Create(image);
if (applicator == null)
{
return(null);
}
var autoLut = applicator.GetAppliedLut();
if (autoLut == null)
{
return(null);
}
return(!autoLut.IsHeader ? null
: new AutoVoiLutSelector
{
IsData = autoLut.IsData,
LutExplanation = autoLut.Explanation,
LutIndex = autoLut.Index
});
}
public static Bitmap CreatePresentationImageIcon(IPresentationImage image, RectangleF destRange, double tileRatio)
{
if (destRange == RectangleF.Empty)
{
return(null);
}
ISpatialTransformProvider provider = image as ISpatialTransformProvider;
if (provider == null)
{
throw new Exception(SR.ConvertTransformProviderFailed);
}
ImageSpatialTransform spatialTransform = provider.SpatialTransform as ImageSpatialTransform;
object memento = spatialTransform.CreateMemento();
spatialTransform.MoveTo(destRange);
Size destSize = new Size(Convert.ToInt32(destRange.Width), Convert.ToInt32(destRange.Height));
Bitmap original = DrawToFilmSizeBitmap(destSize, image, tileRatio, true);
Bitmap bitmap2 = new Bitmap(original, _iconWidth, (int)(_iconWidth * tileRatio));
original.Dispose();
spatialTransform.SetMemento(memento);
return(bitmap2);
}
public TileMemento(IPresentationImage image)
{
// image can be null if the Tile is empty, so we don't check for null
_presentationImage = image;
}
public static bool CanCreate(IPresentationImage image)
{
return(Grayscale.CanCreateFrom(image) || Color.CanCreateFrom(image) || Other.CanCreateFrom(image));
}
/// <summary>
/// Called when the value of the <see cref="ParentPresentationImage"/> property changes.
/// </summary>
/// <param name="oldParentPresentationImage">A reference to the old parent presentation image.</param>
/// <param name="newParentPresentationImage">A reference to the new parent presentation image.</param>
protected virtual void OnParentPresentationImageChanged(IPresentationImage oldParentPresentationImage, IPresentationImage newParentPresentationImage)
{
}
internal ImageDrawingEventArgs(IPresentationImage presentationImage)
{
Platform.CheckForNullReference(presentationImage, "presentationImage");
_presentationImage = presentationImage;
}
void IUndoableOperation <IPresentationImage> .Apply(IPresentationImage image)
{
}
bool IUndoableOperation <IPresentationImage> .AppliesTo(IPresentationImage image)
{
return(image is IDynamicTeProvider);
}
/// <summary>
/// Initializes a new instance of <see cref="BasicPatientPresentation"/>.
/// </summary>
/// <param name="owner">The owner image.</param>
public BasicPatientPresentation(IPresentationImage owner)
{
_owner = owner;
}
protected virtual bool CanStart(IPresentationImage image)
{
return(image != null && image is IOverlayGraphicsProvider);
}
public ImageItem InsertImage(IPresentationImage image)
{
ImageItem node = DoInsertImage(image);
return(node);
}
public void TestCloningShowAnglesToolCompositeGraphicLineSelection()
{
MockShowAnglesTool mockOwnerTool = new MockShowAnglesTool();
using (MockPresentationImage image = new MockPresentationImage(100, 100))
{
ShowAnglesTool.ShowAnglesToolCompositeGraphic composite = new ShowAnglesTool.ShowAnglesToolCompositeGraphic(mockOwnerTool);
image.OverlayGraphics.Add(composite);
using (IPresentationImage clone = image.Clone())
{
var cloneComposite = FindShowAnglesToolComposite(clone);
Assert.IsNotNull(cloneComposite, "ShowAnglesToolCompositeGraphic should be cloneable.");
}
PolylineGraphic line1 = new PolylineGraphic();
line1.Points.Add(new PointF(0, 0));
line1.Points.Add(new PointF(10, 10));
VerticesControlGraphic control1 = new VerticesControlGraphic(line1);
image.OverlayGraphics.Add(control1);
composite.Select(control1);
composite.OnDrawing();
using (IPresentationImage clone = image.Clone())
{
var cloneComposite = FindShowAnglesToolComposite(clone);
cloneComposite.CoordinateSystem = line1.CoordinateSystem;
try
{
Assert.IsNotNull(cloneComposite.SelectedLine, "Cloned ShowAnglesToolCompositeGraphic should retain line graphic selection.");
Assert.AreEqual(line1.Points[0], cloneComposite.SelectedLine.Points[0], "Cloned ShowAnglesToolCompositeGraphic should retain line graphic selection (X).");
Assert.AreEqual(line1.Points[1], cloneComposite.SelectedLine.Points[1], "Cloned ShowAnglesToolCompositeGraphic should retain line graphic selection (Y).");
}
finally
{
cloneComposite.ResetCoordinateSystem();
}
}
PolylineGraphic line2 = new PolylineGraphic();
line2.Points.Add(new PointF(0, 10));
line2.Points.Add(new PointF(10, 0));
VerticesControlGraphic control2 = new VerticesControlGraphic(line2);
image.OverlayGraphics.Add(control2);
composite.Select(control2);
composite.OnDrawing();
using (IPresentationImage clone = image.Clone())
{
var cloneComposite = FindShowAnglesToolComposite(clone);
cloneComposite.CoordinateSystem = line2.CoordinateSystem;
try
{
Assert.IsNotNull(cloneComposite.SelectedLine, "Cloned ShowAnglesToolCompositeGraphic should retain line graphic selection (2).");
Assert.AreEqual(line2.Points[0], cloneComposite.SelectedLine.Points[0], "Cloned ShowAnglesToolCompositeGraphic should retain line graphic selection (X2).");
Assert.AreEqual(line2.Points[1], cloneComposite.SelectedLine.Points[1], "Cloned ShowAnglesToolCompositeGraphic should retain line graphic selection (Y2).");
}
finally
{
cloneComposite.ResetCoordinateSystem();
}
}
}
}
private static ShowAnglesTool.ShowAnglesToolCompositeGraphic FindShowAnglesToolComposite(IPresentationImage image)
{
IOverlayGraphicsProvider imageOverlayGraphics = (IOverlayGraphicsProvider)image;
IGraphic graphic = imageOverlayGraphics.OverlayGraphics.FirstOrDefault(IsOfType <ShowAnglesTool.ShowAnglesToolCompositeGraphic>);
if (graphic is CompositeGraphic)
{
((CompositeGraphic)graphic).OnDrawing();
}
return((ShowAnglesTool.ShowAnglesToolCompositeGraphic)graphic);
}
private void Refresh(bool force)
{
lock (_syncLock)
{
if (_imageBox.DisplaySet == null || _imageBox.DisplaySet.PresentationImages.Count == 0)
{
_frames.Clear();
return;
}
if (!force && _currentIndex == _imageBox.TopLeftPresentationImageIndex)
{
return;
}
_frames.Clear();
_currentIndex = _imageBox.TopLeftPresentationImageIndex;
int numberOfImages = _imageBox.DisplaySet.PresentationImages.Count;
int lastImageIndex = numberOfImages - 1;
int selectionWindow;
if (_window >= 0)
{
selectionWindow = 2 * _window + 1;
}
else
{
//not terribly efficient, but by default will end up including all images.
selectionWindow = 2 * numberOfImages + 1;
}
int offsetFromCurrent = 0;
for (int i = 0; i < selectionWindow; ++i)
{
int index = _currentIndex + offsetFromCurrent;
if (index >= 0 && index <= lastImageIndex)
{
IPresentationImage image = _imageBox.DisplaySet.PresentationImages[index];
if (image is IImageSopProvider)
{
Frame frame = ((IImageSopProvider)image).Frame;
if (_canFetchFrame(frame))
{
_frames.Enqueue(frame);
}
}
}
if (offsetFromCurrent == 0)
{
++offsetFromCurrent;
}
else if (offsetFromCurrent > 0)
{
offsetFromCurrent = -offsetFromCurrent;
}
else
{
offsetFromCurrent = -offsetFromCurrent + 1;
}
}
string message = String.Format("Current: {0}, Window: {1}, Queue: {2}", _currentIndex, selectionWindow, _frames.Count);
Trace.WriteLine(message);
}
//trigger another round of retrievals.
_notifyChanged();
}
/// <summary>
/// Creates a copy of this <see cref="Roi"/> using the same region of interest shape but using a different image as the source pixel data.
/// </summary>
/// <param name="presentationImage">The image upon which to copy this region of interest.</param>
/// <returns>A new <see cref="Roi"/> of the same type and shape as the current region of interest.</returns>
public override Roi CopyTo(IPresentationImage presentationImage)
{
return(new EllipticalRoi(_bounds, presentationImage));
}
public override bool AppliesTo(IPresentationImage presentationImage)
{
return(AutoVoiLutApplicator.CanCreate(presentationImage));
}
internal PresentationImageSelectedEventArgs(
IPresentationImage selectedPresentationImage)
{
Platform.CheckForNullReference(selectedPresentationImage, "selectedPresentationImage");
_selectedPresentationImage = selectedPresentationImage;
}
private void Invert(IPresentationImage image)
{
IVoiLutManager manager = (IVoiLutManager)_operation.GetOriginator(image);
manager.Invert = !manager.Invert;
}
