public static Bitmap RenderLayer(ImageGraphic layer, int dstWidth, int dstHeight)
{
Bitmap bitmap = new Bitmap(dstWidth, dstHeight);
Rectangle clientArea = new Rectangle(0, 0, dstWidth, dstHeight);
BitmapData bitmapData = LockBitmap(bitmap);
int bytesPerPixel = 4;
ImageRenderer.Render(layer, bitmapData.Scan0, bitmapData.Width, bytesPerPixel, clientArea);
bitmap.UnlockBits(bitmapData);
return bitmap;
}
public static void Render(
ImageGraphic imageGraphic,
IntPtr pDstPixelData,
int dstWidth,
int dstBytesPerPixel,
Rectangle clientRectangle)
{
if (clientRectangle.Width <= 0 || clientRectangle.Height <= 0)
return;
if (imageGraphic.SizeInBytes != imageGraphic.PixelData.Raw.Length)
throw new InvalidOperationException(String.Format(SR.ExceptionIncorrectPixelDataSize, imageGraphic.SizeInBytes, imageGraphic.PixelData.Raw.Length));
#if DEBUG
CodeClock clock = new CodeClock();
clock.Start();
#endif
RectangleF srcViewableRectangle;
Rectangle dstViewableRectangle;
CalculateVisibleRectangles(imageGraphic, clientRectangle, out dstViewableRectangle, out srcViewableRectangle);
var grayGraphic = imageGraphic as GrayscaleImageGraphic;
ColorImageGraphic colorGraphic;
if (grayGraphic != null)
{
RenderGrayscale(
grayGraphic,
srcViewableRectangle,
dstViewableRectangle,
pDstPixelData,
dstWidth,
dstBytesPerPixel);
}
else if (null != (colorGraphic = imageGraphic as ColorImageGraphic))
{
RenderColor(
colorGraphic,
srcViewableRectangle,
dstViewableRectangle,
pDstPixelData,
dstWidth,
dstBytesPerPixel);
}
else
{
throw new Exception("Unknown ImageGraphic.");
}
#if DEBUG
clock.Stop();
PerformanceReportBroker.PublishReport("ImageRenderer", "Render", clock.Seconds);
#endif
}
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 override IVoiLut CreateVoiLut(ImageGraphic imageGraphic)
{
return(_createVoiLutDelegate(imageGraphic));
}
/// <summary> /// Creates a Voi LUT suitable for the given <paramref name="imageGraphic"/>. /// </summary> /// <returns>The VOI LUT as an <see cref="IVoiLut"/>.</returns> public abstract IVoiLut CreateVoiLut(ImageGraphic imageGraphic);
public override IVoiLut CreateVoiLut(ImageGraphic imageGraphic)
{
return _createVoiLutDelegate(imageGraphic);
}
/// <summary> /// Creates a Voi LUT suitable for the given <paramref name="imageGraphic"/>. /// </summary> /// <returns>The VOI LUT as an <see cref="IVoiLut"/>.</returns> public abstract IVoiLut CreateVoiLut(ImageGraphic imageGraphic);
private unsafe static void CopyToUnsigned8(ImageGraphic image, itkImageBase itkImage)
{
fixed (byte* pSrcByte = image.PixelData.Raw)
{
itkImageRegionIterator_IUC2 inputIt = new itkImageRegionIterator_IUC2(itkImage, itkImage.LargestPossibleRegion);
byte* pSrc = (byte*)pSrcByte;
int height = image.Rows;
int width = image.Columns;
byte pixelValue;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
pixelValue = pSrc[0];
inputIt.Set(pixelValue);
pSrc++;
inputIt++;
}
}
}
}
/// <summary>
/// Draws an <see cref="ImageGraphic"/>.
/// </summary>
protected override void DrawImageGraphic(ImageGraphic imageGraphic)
{
CodeClock clock = new CodeClock();
clock.Start();
const int bytesPerPixel = 4;
Surface.ImageBuffer.Graphics.Clear(Color.FromArgb(0x0, 0xFF, 0xFF, 0xFF));
BitmapData bitmapData = Surface.ImageBuffer.Bitmap.LockBits(
new Rectangle(0, 0, Surface.ImageBuffer.Bitmap.Width, Surface.ImageBuffer.Bitmap.Height),
ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
try
{
ImageRenderer.Render(imageGraphic, bitmapData.Scan0, bitmapData.Width, bytesPerPixel, Surface.ClientRectangle);
}
finally
{
Surface.ImageBuffer.Bitmap.UnlockBits(bitmapData);
}
Surface.FinalBuffer.RenderImage(Surface.ImageBuffer);
clock.Stop();
PerformanceReportBroker.PublishReport("GDIRenderer", "DrawImageGraphic", clock.Seconds);
}
/// <summary>
/// Cloning constructor.
/// </summary>
protected ImageGraphic(ImageGraphic source, ICloningContext context)
{
context.CloneFields(source, this);
SetValidationPolicy();
}
private void CreateImageLayer(ImageTypes imageType)
{
if (imageType == ImageTypes.Mono16)
_image = new GrayscaleImageGraphic(_srcHeight, _srcWidth, 16, 16, 15, false, false, 1.9, 3, new byte[2 * _srcWidth * _srcHeight]);
else if (imageType == ImageTypes.Mono8)
_image = new GrayscaleImageGraphic(_srcHeight, _srcWidth, 8, 8, 7, false, false, 1.0, 0, new byte[_srcWidth * _srcHeight]);
if (imageType == ImageTypes.Mono16Signed)
_image = new GrayscaleImageGraphic(_srcHeight, _srcWidth, 16, 16, 15, true, false, 2.0, -630, new byte[2 * _srcWidth * _srcHeight]);
else if (imageType == ImageTypes.Mono8Signed)
_image = new GrayscaleImageGraphic(_srcHeight, _srcWidth, 8, 8, 7, true, false, 0.5, 4, new byte[_srcWidth * _srcHeight]);
else
_image = new ColorImageGraphic(_srcHeight, _srcWidth, new byte[4 * _srcWidth * _srcHeight]);
if (_image is GrayscaleImageGraphic)
{
(_image as IColorMapInstaller).InstallColorMap(new GrayscaleColorMap());
}
_containerGraphic = new CompositeImageGraphic(_image.Rows, _image.Columns);
_containerGraphic.Graphics.Add(_image);
ImageSpatialTransform transform = (ImageSpatialTransform)_containerGraphic.SpatialTransform;
transform.Initialize();
transform.ClientRectangle = new Rectangle(0, 0, _dstWidth, _dstHeight);
transform.ScaleToFit = _scaleToFit;
transform.Scale = _scale;
transform.FlipX = _flipHorizontal;
transform.FlipY = _flipVertical;
transform.RotationXY = _rotation;
transform.TranslationX = _translationX;
transform.TranslationY = _translationY;
}
/// <summary>
/// Cloning constructor.
/// </summary>
protected ImageGraphic(ImageGraphic source, ICloningContext context)
{
context.CloneFields(source, this);
SetValidationPolicy();
}
public override void Cancel()
{
if (_selectedTile == null || _selectedImageGraphic == null)
return;
_selectedImageGraphic = null;
_selectedTile.InformationBox.Visible = false;
_selectedTile.InformationBox = null;
_selectedTile = null;
}
private unsafe static void CopyFromUnsigned8(ImageGraphic image, itkImageBase itkImage)
{
fixed (byte* pDstByte = image.PixelData.Raw)
{
itkImageRegionConstIterator_IUC2 itkIt = new itkImageRegionConstIterator_IUC2(itkImage, itkImage.LargestPossibleRegion);
byte* pDst = (byte*)pDstByte;
int height = image.Rows;
int width = image.Columns;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
pDst[0] = itkIt.Get().ValueAsUC;
pDst++;
itkIt++;
}
}
}
}
/// <summary>
/// Draws an <see cref="ImageGraphic"/>.
/// </summary>
protected override void DrawImageGraphic(ImageGraphic imageGraphic)
{
CodeClock clock = new CodeClock();
clock.Start();
Surface.ImageBuffer.Graphics.Clear(Color.FromArgb(0x0, 0xFF, 0xFF, 0xFF));
DrawImageGraphic(Surface.ImageBuffer, imageGraphic);
Surface.FinalBuffer.RenderImage(Surface.ImageBuffer);
clock.Stop();
PerformanceReportBroker.PublishReport("GDIRenderer", "DrawImageGraphic", clock.Seconds);
}
/// <summary>
/// Draws an image graphic to the specified destination buffer.
/// </summary>
/// <param name="buffer">The destination buffer.</param>
/// <param name="imageGraphic">The image graphic to be drawn.</param>
public static void DrawImageGraphic(BitmapBuffer buffer, ImageGraphic imageGraphic)
{
const int bytesPerPixel = 4;
var bounds = ((IGdiBuffer) buffer).Bounds;
var bitmapData = buffer.Bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
try
{
ImageRenderer.Render(imageGraphic, bitmapData.Scan0, bitmapData.Width, bytesPerPixel, bounds);
}
finally
{
buffer.Bitmap.UnlockBits(bitmapData);
}
}
private static bool IsRotated(ImageGraphic imageGraphic)
{
float m12 = imageGraphic.SpatialTransform.CumulativeTransform.Elements[2];
return !FloatComparer.AreEqual(m12, 0.0f, 0.001f);
}
/// <summary> /// Draws an <see cref="ImageGraphic"/>. Must be overridden and implemented. /// </summary> protected abstract void DrawImageGraphic(ImageGraphic imageGraphic);
//internal for unit testing only.
internal static void CalculateVisibleRectangles(
ImageGraphic imageGraphic,
Rectangle clientRectangle,
out Rectangle dstVisibleRectangle,
out RectangleF srcVisibleRectangle)
{
Rectangle srcRectangle = new Rectangle(0, 0, imageGraphic.Columns, imageGraphic.Rows);
RectangleF dstRectangle = imageGraphic.SpatialTransform.ConvertToDestination(srcRectangle);
// Find the intersection between the drawable client rectangle and
// the transformed destination rectangle
dstRectangle = RectangleUtilities.RoundInflate(dstRectangle);
dstRectangle = RectangleUtilities.Intersect(clientRectangle, dstRectangle);
if (dstRectangle.IsEmpty)
{
dstVisibleRectangle = Rectangle.Empty;
srcVisibleRectangle = RectangleF.Empty;
return;
}
// Figure out what portion of the image is visible in source coordinates
srcVisibleRectangle = imageGraphic.SpatialTransform.ConvertToSource(dstRectangle);
//dstRectangle is already rounded, this is just a conversion to Rectangle.
dstVisibleRectangle = Rectangle.Round(dstRectangle);
}
