public void Apply(IPresentationImage image)
{
if (image == ReferenceImage)
{
return;
}
//Turn off scale to fit and start with scale=1, then adjust it.
//We do this because images that have been "scaled to fit", but have not been shown yet,
//have no client rectangle and their scale is often very small. This is safer
//and could produce a more accurate result.
IImageSpatialTransform matchTransform = GetImageTransform(image);
matchTransform.ScaleToFit = false;
matchTransform.Scale = 1;
//get the displayed width (in mm) for the same size display rectangle in the image to be matched.
float matchDisplayedWidth = GetDisplayedWidth(image, _referenceDisplayRectangle);
float rescaleAmount = matchDisplayedWidth / _referenceDisplayedWidth;
matchTransform.Scale *= rescaleAmount;
//ISpatialTransform transform = (ISpatialTransform)_operation.GetOriginator(image);
matchTransform.TranslationX = this.SelectedSpatialTransformProvider.SpatialTransform.TranslationX;
matchTransform.TranslationY = this.SelectedSpatialTransformProvider.SpatialTransform.TranslationY;
IVoiLutLinear selectedLut = (IVoiLutLinear)this.SelectedVoiLutProvider.VoiLutManager.VoiLut;
IVoiLutProvider provider = ((IVoiLutProvider)image);
if (!(provider.VoiLutManager.VoiLut is IBasicVoiLutLinear))
{
BasicVoiLutLinear installLut = new BasicVoiLutLinear(selectedLut.WindowWidth, selectedLut.WindowCenter);
provider.VoiLutManager.InstallVoiLut(installLut);
}
IBasicVoiLutLinear lut = (IBasicVoiLutLinear)provider.VoiLutManager.VoiLut;
lut.WindowWidth = selectedLut.WindowWidth;
lut.WindowCenter = selectedLut.WindowCenter;
}
public void Apply(IPresentationImage image)
{
if (image == ReferenceImage)
{
return;
}
//Turn off scale to fit and start with scale=1, then adjust it.
//We do this because images that have been "scaled to fit", but have not been shown yet,
//have no client rectangle and their scale is often very small. This is safer
//and could produce a more accurate result.
IImageSpatialTransform matchTransform = GetImageTransform(image);
matchTransform.ScaleToFit = false;
matchTransform.Scale = 1;
//get the displayed width (in mm) for the same size display rectangle in the image to be matched.
float matchDisplayedWidth = GetDisplayedWidth(image, _referenceDisplayRectangle);
float rescaleAmount = matchDisplayedWidth / _referenceDisplayedWidth;
matchTransform.Scale *= rescaleAmount;
}
protected void DeserializeSpatialTransform(SpatialTransformModuleIod module, T image)
{
ISpatialTransform spatialTransform = image.SpatialTransform;
if (spatialTransform is IImageSpatialTransform)
{
IImageSpatialTransform iist = (IImageSpatialTransform)spatialTransform;
iist.ScaleToFit = false;
}
if (module.ImageHorizontalFlip == ImageHorizontalFlip.Y)
{
spatialTransform.FlipX = false;
spatialTransform.FlipY = true;
spatialTransform.RotationXY = (360 - module.ImageRotation) % 360;
}
else
{
spatialTransform.FlipX = false;
spatialTransform.FlipY = false;
spatialTransform.RotationXY = module.ImageRotation;
}
}
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);
}
}
protected void DeserializeDisplayedArea(DisplayedAreaModuleIod dispAreaMod, out RectangleF displayedArea, T image)
{
ISpatialTransform spatialTransform = image.SpatialTransform;
foreach (DisplayedAreaModuleIod.DisplayedAreaSelectionSequenceItem item in dispAreaMod.DisplayedAreaSelectionSequence)
{
var dictionary = !DeserializeIgnoreImageRelationship ? new ImageSopInstanceReferenceDictionary(item.ReferencedImageSequence, true) : null;
if (dictionary == null || dictionary.ReferencesFrame(image.Frame.SopInstanceUid, image.Frame.FrameNumber))
{
// get the displayed area of the image in source coordinates (stored values do not have sub-pixel accuracy)
var displayRect = RectangleF.FromLTRB(item.DisplayedAreaTopLeftHandCorner.X,
item.DisplayedAreaTopLeftHandCorner.Y,
item.DisplayedAreaBottomRightHandCorner.X,
item.DisplayedAreaBottomRightHandCorner.Y);
displayRect = RectangleUtilities.ConvertToPositiveRectangle(displayRect);
displayRect.Location = displayRect.Location - new SizeF(1, 1);
displayRect.Size = displayRect.Size + new SizeF(1, 1);
var centerDisplay = true;
switch (item.PresentationSizeMode)
{
case DisplayedAreaModuleIod.PresentationSizeMode.Magnify:
// displays selected area at specified magnification factor
spatialTransform.Scale = (float)item.PresentationPixelMagnificationRatio.GetValueOrDefault(1);
break;
case DisplayedAreaModuleIod.PresentationSizeMode.TrueSize:
// currently no support for determining true size, so default to scale area to fit
case DisplayedAreaModuleIod.PresentationSizeMode.ScaleToFit:
case DisplayedAreaModuleIod.PresentationSizeMode.None:
default:
if (spatialTransform is IImageSpatialTransform && displayRect.Location == new PointF(0, 0) && displayRect.Size == new SizeF(image.ImageGraphic.Columns, image.ImageGraphic.Rows))
{
// if the display rect is the whole image, then take advantage of the built-in scale image to fit functionality
IImageSpatialTransform iist = (IImageSpatialTransform)spatialTransform;
iist.ScaleToFit = true;
centerDisplay = false; // when ScaleToFit is true, the image will automatically be positioned correctly in the client area
}
else
{
var clientArea = image.ClientRectangle.Size;
var displaySize = displayRect.Size;
// if image is rotated 90 or 270, transpose width/height
if (Math.Abs(Math.Round(Math.Sin(spatialTransform.RotationXY * Math.PI / 180))) > 0)
{
displaySize = new SizeF(displaySize.Height, displaySize.Width);
}
// compute the maximum magnification that allows the entire displayRect to be visible
spatialTransform.Scale = Math.Min(clientArea.Width / displaySize.Width, clientArea.Height / displaySize.Height);
}
break;
}
if (centerDisplay)
{
// compute translation so that the displayRect is centered in the clientRect
var displayCentre = GetRectangleCenter(displayRect);
var clientCentre = spatialTransform.ConvertToSource(GetRectangleCenter(image.ClientRectangle));
spatialTransform.TranslationX = clientCentre.X - displayCentre.X;
spatialTransform.TranslationY = clientCentre.Y - displayCentre.Y;
}
displayedArea = displayRect;
return;
}
}
displayedArea = new RectangleF(0, 0, image.ImageGraphic.Columns, image.ImageGraphic.Rows);
}
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 static Bitmap DrawToBitmap(IPresentationImage image, ExportImageParams exportParams)
{
Platform.CheckForNullReference(image, "image");
Platform.CheckForNullReference(exportParams, "exportParams");
if (!(image is ISpatialTransformProvider))
{
throw new ArgumentException("The image must have a valid ImageSpatialTransform in order to be exported.");
}
if (exportParams.ExportOption == ExportOption.TrueSize)
{
var imageSopProvider = image as IImageSopProvider;
var pixelSpacing = imageSopProvider == null ? null : imageSopProvider.Frame.NormalizedPixelSpacing;
if (pixelSpacing == null || pixelSpacing.IsNull)
{
throw new ArgumentException("The image does not contain pixel spacing information. TrueSize export is not possible.");
}
}
IImageSpatialTransform transform = ((ISpatialTransformProvider)image).SpatialTransform as IImageSpatialTransform;
if (transform == null)
{
throw new ArgumentException("The image must have a valid ImageSpatialTransform in order to be exported.");
}
if (exportParams.ExportOption == ExportOption.TrueSize)
{
return(DrawTrueSizeImageToBitmap(image, exportParams.OutputSize, exportParams.Dpi));
}
if (exportParams.SizeMode == SizeMode.Scale)
{
// TODO: Refactor ImageExporter, so there only the displayRectangle and OutputRectangle are provided
// Scale can be automatically figured out.
// A "Padded" option can be provided to distinguish between the current Fixed and ScaleToFit options
// TODO: Refactor ImageExporter, so there are separate exporters for each ExportOption.
// The ExportImageParams is getting too many options and not all of them are applicable to each exporter
// Instead, each exporter should have its own parameters.
if (exportParams.ExportOption == ExportOption.Wysiwyg)
{
return(DrawWysiwygImageToBitmap(image, exportParams.DisplayRectangle, exportParams.Scale, exportParams.Dpi));
}
else
{
return(DrawCompleteImageToBitmap(image, exportParams.Scale, exportParams.Dpi));
}
}
else if (exportParams.SizeMode == SizeMode.ScaleToFit)
{
if (exportParams.ExportOption == ExportOption.Wysiwyg)
{
var scale = ScaleToFit(exportParams.DisplayRectangle.Size, exportParams.OutputSize);
return(DrawWysiwygImageToBitmap(image, exportParams.DisplayRectangle, scale, exportParams.Dpi));
}
else
{
var scale = ScaleToFit(image.SceneSize, exportParams.OutputSize);
return(DrawCompleteImageToBitmap(image, scale, exportParams.Dpi));
}
}
else
{
Bitmap paddedImage = new Bitmap(exportParams.OutputSize.Width, exportParams.OutputSize.Height);
using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(paddedImage))
{
// paint background
using (Brush b = new SolidBrush(exportParams.BackgroundColor))
{
graphics.FillRectangle(b, new Rectangle(Point.Empty, exportParams.OutputSize));
}
// paint image portion
Bitmap bmp;
if (exportParams.ExportOption == ExportOption.Wysiwyg)
{
float scale = ScaleToFit(exportParams.DisplayRectangle.Size, exportParams.OutputSize);
bmp = DrawWysiwygImageToBitmap(image, exportParams.DisplayRectangle, scale, exportParams.Dpi);
}
else
{
float scale = ScaleToFit(image.SceneSize, exportParams.OutputSize);
bmp = DrawCompleteImageToBitmap(image, scale, exportParams.Dpi);
}
graphics.DrawImageUnscaledAndClipped(bmp, new Rectangle(CenterRectangles(bmp.Size, exportParams.OutputSize), bmp.Size));
bmp.Dispose();
}
return(paddedImage);
}
}
