public AlphaMaskAdaptor(IImageByte image, IAlphaMask mask)
: base(image)
{
linkedImage = image;
m_mask = mask;
m_span = new ArrayPOD<byte>(255);
}
public ButtonViewThreeImage(IImageByte normal, IImageByte hover, IImageByte pressed)
{
hoverOpacity = 0;
normalIMage = normal;
hoverImage = hover;
pressedImage = pressed;
}
protected override void RenderSolidSingleScanLine(IImageByte destImage, IScanlineCache scanLineCache, RGBA_Bytes color)
{
int y = scanLineCache.y();
int num_spans = scanLineCache.num_spans();
ScanlineSpan scanlineSpan = scanLineCache.begin();
byte[] ManagedCoversArray = scanLineCache.GetCovers();
for (; ; )
{
int x = scanlineSpan.x;
int num_pix = scanlineSpan.len;
int coverIndex = scanlineSpan.cover_index;
do
{
int a = (ManagedCoversArray[coverIndex++] * color.Alpha0To255) >> 8;
m_square.draw(destImage.NewGraphics2D().Rasterizer, m_sl, destImage,
new RGBA_Bytes(color.Red0To255, color.Green0To255, color.Blue0To255, a),
x, y);
++x;
}
while (--num_pix > 0);
if (--num_spans == 0) break;
scanlineSpan = scanLineCache.GetNextScanlineSpan();
}
}
private void attach(IImageByte pixf)
{
m_SourceImage = pixf;
m_Buffer = m_SourceImage.GetBuffer();
m_Width = m_SourceImage.Width;
m_DistanceBetweenPixelsInclusive = m_SourceImage.GetBytesBetweenPixelsInclusive();
}
//private bool m_clipping;
//---------------------------------------------------------------------
//typedef renderer_outline_image<BaseRenderer, ImagePattern> self_type;
//---------------------------------------------------------------------
public ImageLineRenderer(IImageByte ren, line_image_pattern patt)
{
m_ren = ren;
m_pattern = patt;
m_start = (0);
m_scale_x = (1.0);
m_clip_box = new RectangleInt(0, 0, 0, 0);
//m_clipping = (false);
}
public ImageBuffer(IImageByte sourceImageToCopy, IRecieveBlenderByte blender, int distanceBetweenPixelsInclusive, int bufferOffset, int bitsPerPixel)
{
SetDimmensionAndFormat(sourceImageToCopy.Width, sourceImageToCopy.Height, sourceImageToCopy.StrideInBytes(), bitsPerPixel, distanceBetweenPixelsInclusive, true);
int offset = sourceImageToCopy.GetBufferOffsetXY(0, 0);
byte[] buffer = sourceImageToCopy.GetBuffer();
byte[] newBuffer = new byte[buffer.Length];
agg_basics.memcpy(newBuffer, offset, buffer, offset, buffer.Length - offset);
SetBuffer(newBuffer, offset + bufferOffset);
SetRecieveBlender(blender);
}
public void RenderSolid(IImageByte destImage, IRasterizer rasterizer, IScanlineCache scanLine, RGBA_Bytes color)
{
if (rasterizer.rewind_scanlines())
{
scanLine.reset(rasterizer.min_x(), rasterizer.max_x());
while (rasterizer.sweep_scanline(scanLine))
{
RenderSolidSingleScanLine(destImage, scanLine, color);
}
}
}
public void RenderSolid(IImageByte destImage, IRasterizer rasterizer, IScanlineCache scanLine, RGBA_Bytes color)
{
if (rasterizer.rewind_scanlines())
{
scanLine.reset(rasterizer.min_x(), rasterizer.max_x());
while (rasterizer.sweep_scanline(scanLine))
{
RenderSolidSingleScanLine(destImage, scanLine, color);
}
}
}
public void draw(ScanlineRasterizer ras, IScanlineCache sl, IImageByte destImage, RGBA_Bytes color,
double x, double y)
{
ras.reset();
ras.move_to_d(x * m_size, y * m_size);
ras.line_to_d(x * m_size + m_size, y * m_size);
ras.line_to_d(x * m_size + m_size, y * m_size + m_size);
ras.line_to_d(x * m_size, y * m_size + m_size);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.RenderSolid(destImage, ras, sl, color);
}
public void CopyFrom(IImageByte sourceImage)
{
Allocate(sourceImage.Width, sourceImage.Height, sourceImage.StrideInBytesAbs(), sourceImage.BitDepth);
// make sure we make an exact copy
SetRecieveBlender(new BlenderBGRAExactCopy());
CopyFrom(sourceImage, sourceImage.GetBounds(), 0, 0);
// then set the blender to what we expect
SetRecieveBlender(sourceImage.GetRecieveBlender());
}
public void draw(ScanlineRasterizer ras, IScanlineCache sl, IImageByte destImage, RGBA_Bytes color,
double x, double y)
{
ras.reset();
ras.move_to_d(x * m_size, y * m_size);
ras.line_to_d(x * m_size + m_size, y * m_size);
ras.line_to_d(x * m_size + m_size, y * m_size + m_size);
ras.line_to_d(x * m_size, y * m_size + m_size);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.render_scanlines_aa_solid(destImage, ras, sl, color);
}
public ImageBuffer(IImageByte sourceImage, IRecieveBlenderByte recieveBlender)
{
SetDimmensionAndFormat(sourceImage.Width, sourceImage.Height, sourceImage.StrideInBytes(), sourceImage.BitDepth, sourceImage.GetBytesBetweenPixelsInclusive(), true);
int offset = sourceImage.GetBufferOffsetXY(0, 0);
byte[] buffer = sourceImage.GetBuffer();
byte[] newBuffer = new byte[buffer.Length];
agg_basics.memcpy(newBuffer, offset, buffer, offset, buffer.Length - offset);
SetBuffer(newBuffer, offset);
SetRecieveBlender(recieveBlender);
}
public static bool SaveImageData(string filename, IImageByte sourceImage)
{
if (!File.Exists(filename))
{
using (var fs = new FileStream(filename, FileMode.CreateNew))
{
return(SaveImageData(fs, Path.GetExtension(filename), sourceImage));
}
}
return(false);
}
public void DrawDebug(Agg.Graphics2D graphics2D)
{
if (validResponsesBotomToTopList.Count < 1)
{
return;
}
if (graphics2D.DestImage == null)
{
throw new Exception("Your graphics2D must be for a buffered Image.");
}
if (lowestCorrner != null)
{
lowestCorrner.Render(graphics2D);
}
int width = allResponsesGrid.Width;
int height = allResponsesGrid.Height;
IImageByte imageBuffer = graphics2D.DestImage;
ValidResponseData prevValidResponse = validResponsesBotomToTopList[0];
foreach (ValidResponseData validResponse in validResponsesBotomToTopList)
{
if (validResponse.totalResponse > 0)
{
Vector2 start = new Vector2(10, 0);
start.Rotate(validResponse.orientation * MathHelper.DegreesToRadians(22.5));
graphics2D.Line(validResponse.position + start, validResponse.position - start, RGBA_Bytes.Green);
graphics2D.Circle(validResponse.position, 2, RGBA_Bytes.Red);
if (validResponse.has4ChessboardNeighbors)
{
Ellipse elipse = new Ellipse(validResponse.position, 10);
graphics2D.Render(new Stroke(elipse, 1), RGBA_Bytes.Red);
}
//graphics2D.Line(validResponse.position, prevValidResponse.position, RGBA_Bytes.Red);
prevValidResponse = validResponse;
}
}
#if SHOW_SUB_PIXEL_LOGIC
graphics2D.Render(gray, 0, 0);
#endif
}
private void DrawImage(IImageByte sourceImage, ISpanGenerator spanImageFilter, Affine destRectTransform)
{
if (destImageByte.OriginOffset.x != 0 || destImageByte.OriginOffset.y != 0)
{
destRectTransform *= Affine.NewTranslation(-destImageByte.OriginOffset.x, -destImageByte.OriginOffset.y);
}
VertexSourceApplyTransform transformedRect = new VertexSourceApplyTransform(drawImageRectPath, destRectTransform);
Rasterizer.add_path(transformedRect);
{
ImageClippingProxy destImageWithClipping = new ImageClippingProxy(destImageByte);
scanlineRenderer.GenerateAndRender(Rasterizer, drawImageScanlineCache, destImageWithClipping, destImageSpanAllocatorCache, spanImageFilter);
}
}
public ButtonViewThreeImage(IImageByte normal, IImageByte hover, IImageByte pressed, IImageByte disabled = null)
{
if (disabled == null)
{
disabled = normal;
}
hoverOpacity = 0;
normalImage = normal;
hoverImage = hover;
pressedImage = pressed;
disabledImage = disabled;
this.HAnchor = HAnchor.Stretch;
this.VAnchor = VAnchor.Stretch;
}
public void RenderSolidAllPaths(IImageByte destImage,
IRasterizer ras,
IScanlineCache sl,
IVertexSource vs,
RGBA_Bytes[] color_storage,
int[] path_id,
int num_paths)
{
for (int i = 0; i < num_paths; i++)
{
ras.reset();
ras.add_path(vs, path_id[i]);
RenderSolid(destImage, ras, sl, color_storage[i]);
}
}
public void RenderSolidAllPaths(IImageByte destImage,
IRasterizer ras,
IScanlineCache sl,
IVertexSource vs,
RGBA_Bytes[] color_storage,
int[] path_id,
int num_paths)
{
for (int i = 0; i < num_paths; i++)
{
ras.reset();
ras.add_path(vs, path_id[i]);
RenderSolid(destImage, ras, sl, color_storage[i]);
}
}
internal void render_gouraud(IImageByte backBuffer, IScanlineCache sl, IRasterizer ras, RenderPoint[] points)
{
ImageBuffer image = new ImageBuffer();
image.Attach(backBuffer, new BlenderZBuffer());
ImageClippingProxy ren_base = new ImageClippingProxy(image);
MatterHackers.Agg.span_allocator span_alloc = new span_allocator();
span_gouraud_rgba span_gen = new span_gouraud_rgba();
span_gen.colors(points[0].color, points[1].color, points[2].color);
span_gen.triangle(points[0].position.x, points[0].position.y, points[1].position.x, points[1].position.y, points[2].position.x, points[2].position.y);
ras.add_path(span_gen);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
}
public override void CopyFrom(IImageByte sourceImage,
RectangleInt sourceImageRect,
int destXOffset,
int destYOffset)
{
RectangleInt destRect = sourceImageRect;
destRect.Offset(destXOffset, destYOffset);
RectangleInt clippedSourceRect = new RectangleInt();
if (clippedSourceRect.IntersectRectangles(destRect, m_ClippingRect))
{
// move it back relative to the source
clippedSourceRect.Offset(-destXOffset, -destYOffset);
base.CopyFrom(sourceImage, clippedSourceRect, destXOffset, destYOffset);
}
}
private void DrawImageGetDestBounds(IImageByte sourceImage,
double destX,
double destY,
double hotspotOffsetX,
double hotspotOffsetY,
double scaleX,
double scaleY,
double angleRad,
out Affine destRectTransform)
{
destRectTransform = Affine.NewIdentity();
if (hotspotOffsetX != 0.0f || hotspotOffsetY != 0.0f)
{
destRectTransform *= Affine.NewTranslation(-hotspotOffsetX, -hotspotOffsetY);
}
if (scaleX != 1 || scaleY != 1)
{
destRectTransform *= Affine.NewScaling(scaleX, scaleY);
}
if (angleRad != 0)
{
destRectTransform *= Affine.NewRotation(angleRad);
}
if (destX != 0 || destY != 0)
{
destRectTransform *= Affine.NewTranslation(destX, destY);
}
int sourceBufferWidth = (int)sourceImage.Width;
int sourceBufferHeight = (int)sourceImage.Height;
drawImageRectPath.remove_all();
drawImageRectPath.MoveTo(0, 0);
drawImageRectPath.LineTo(sourceBufferWidth, 0);
drawImageRectPath.LineTo(sourceBufferWidth, sourceBufferHeight);
drawImageRectPath.LineTo(0, sourceBufferHeight);
drawImageRectPath.ClosePolygon();
}
/// <summary>
/// This will create a new ImageBuffer that references the same memory as the image that you took the sub image from.
/// It will modify the original main image when you draw to it.
/// </summary>
/// <param name="imageContainingSubImage"></param>
/// <param name="subImageBounds"></param>
/// <returns></returns>
public static ImageBuffer NewSubImageReference(IImageByte imageContainingSubImage, RectangleDouble subImageBounds)
{
ImageBuffer subImage = new ImageBuffer();
if (subImageBounds.Left < 0 || subImageBounds.Bottom < 0 || subImageBounds.Right > imageContainingSubImage.Width || subImageBounds.Top > imageContainingSubImage.Height ||
subImageBounds.Left >= subImageBounds.Right || subImageBounds.Bottom >= subImageBounds.Top)
{
throw new ArgumentException("The subImageBounds must be on the image and valid.");
}
int left = Math.Max(0, (int)Math.Floor(subImageBounds.Left));
int bottom = Math.Max(0, (int)Math.Floor(subImageBounds.Bottom));
int width = Math.Min(imageContainingSubImage.Width - left, (int)subImageBounds.Width);
int height = Math.Min(imageContainingSubImage.Height - bottom, (int)subImageBounds.Height);
int bufferOffsetToFirstPixel = imageContainingSubImage.GetBufferOffsetXY(left, bottom);
subImage.AttachBuffer(imageContainingSubImage.GetBuffer(), bufferOffsetToFirstPixel, width, height, imageContainingSubImage.StrideInBytes(), imageContainingSubImage.BitDepth, imageContainingSubImage.GetBytesBetweenPixelsInclusive());
subImage.SetRecieveBlender(imageContainingSubImage.GetRecieveBlender());
return(subImage);
}
public void CopyFrom(IImageByte sourceImage, RectangleInt sourceImageRect, int destXOffset, int destYOffset)
{
RectangleInt sourceImageBounds = sourceImage.GetBounds();
RectangleInt clippedSourceImageRect = new RectangleInt();
if (clippedSourceImageRect.IntersectRectangles(sourceImageRect, sourceImageBounds))
{
RectangleInt destImageRect = clippedSourceImageRect;
destImageRect.Offset(destXOffset, destYOffset);
RectangleInt destImageBounds = GetBounds();
RectangleInt clippedDestImageRect = new RectangleInt();
if (clippedDestImageRect.IntersectRectangles(destImageRect, destImageBounds))
{
// we need to make sure the source is also clipped to the dest. So, we'll copy this back to source and offset it.
clippedSourceImageRect = clippedDestImageRect;
clippedSourceImageRect.Offset(-destXOffset, -destYOffset);
CopyFromNoClipping(sourceImage, clippedSourceImageRect, destXOffset, destYOffset);
}
}
}
public void RenderMaxSize(IImageByte image, double x, double y, double maxX, double maxY, out Vector2 size)
{
size.X = image.Width;
size.Y = image.Height;
if (size.X > maxX)
{
size.X = maxX;
var ratio = size.X / image.Width;
size.Y = image.Height * ratio;
}
if (size.Y > maxY)
{
size.Y = maxY;
var ratio = size.Y / image.Height;
size.X = image.Width * ratio;
}
this.Render(image, x, y, size.X, size.Y);
}
public override void OnDraw(Graphics2D graphics2D)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
IImageByte backBuffer = widgetsSubImage;
if (firstTime)
{
firstTime = false;
m_SuperFast = new MatterHackers.Agg.UI.CheckBox(10, 10, "Run Super Fast");
AddChild(m_SuperFast);
m_Controller = new CController(backBuffer, 30, 40, .1, .7, .3, 4, 1, 2000);
}
graphics2D.Clear(new RGBA_Floats(1, 1, 1, 1));
graphics2D.Rasterizer.SetVectorClipBox(0, 0, (int)Width, (int)Height);
m_Controller.FastRender(m_SuperFast.Checked);
m_Controller.Render(graphics2D);
//m_SuperFast.Render(graphics2D);
base.OnDraw(graphics2D);
}
private void DrawImageGetDestBounds(IImageByte sourceImage,
double DestX, double DestY,
double HotspotOffsetX, double HotspotOffsetY,
double ScaleX, double ScaleY,
double AngleRad, out Affine destRectTransform)
{
destRectTransform = Affine.NewIdentity();
if (HotspotOffsetX != 0.0f || HotspotOffsetY != 0.0f)
{
destRectTransform *= Affine.NewTranslation(-HotspotOffsetX, -HotspotOffsetY);
}
if (ScaleX != 1 || ScaleY != 1)
{
destRectTransform *= Affine.NewScaling(ScaleX, ScaleY);
}
if (AngleRad != 0)
{
destRectTransform *= Affine.NewRotation(AngleRad);
}
if (DestX != 0 || DestY != 0)
{
destRectTransform *= Affine.NewTranslation(DestX, DestY);
}
int SourceBufferWidth = (int)sourceImage.Width;
int SourceBufferHeight = (int)sourceImage.Height;
drawImageRectPath.remove_all();
drawImageRectPath.MoveTo(0, 0);
drawImageRectPath.LineTo(SourceBufferWidth, 0);
drawImageRectPath.LineTo(SourceBufferWidth, SourceBufferHeight);
drawImageRectPath.LineTo(0, SourceBufferHeight);
drawImageRectPath.ClosePolygon();
}
public bool Attach(IImageByte sourceImage, int x1, int y1, int x2, int y2)
{
m_ByteBuffer = null;
DettachBuffer();
if (x1 > x2 || y1 > y2)
{
throw new Exception("You need to have your x1 and y1 be the lower left corner of your sub image.");
}
RectangleInt boundsRect = new RectangleInt(x1, y1, x2, y2);
if (boundsRect.clip(new RectangleInt(0, 0, (int)sourceImage.Width - 1, (int)sourceImage.Height - 1)))
{
SetDimmensionAndFormat(boundsRect.Width, boundsRect.Height, sourceImage.StrideInBytes(), sourceImage.BitDepth, sourceImage.GetBytesBetweenPixelsInclusive(), false);
int bufferOffset = sourceImage.GetBufferOffsetXY(boundsRect.Left, boundsRect.Bottom);
byte[] buffer = sourceImage.GetBuffer();
SetBuffer(buffer, bufferOffset);
return(true);
}
return(false);
}
private void DrawImageGetDestBounds(IImageByte sourceImage,
double DestX, double DestY,
double HotspotOffsetX, double HotspotOffsetY,
double ScaleX, double ScaleY,
double AngleRad, out Affine destRectTransform)
{
destRectTransform = Affine.NewIdentity();
if (HotspotOffsetX != 0.0f || HotspotOffsetY != 0.0f)
{
destRectTransform *= Affine.NewTranslation(-HotspotOffsetX, -HotspotOffsetY);
}
if (ScaleX != 1 || ScaleY != 1)
{
destRectTransform *= Affine.NewScaling(ScaleX, ScaleY);
}
if (AngleRad != 0)
{
destRectTransform *= Affine.NewRotation(AngleRad);
}
if (DestX != 0 || DestY != 0)
{
destRectTransform *= Affine.NewTranslation(DestX, DestY);
}
int SourceBufferWidth = (int)sourceImage.Width;
int SourceBufferHeight = (int)sourceImage.Height;
drawImageRectPath.remove_all();
drawImageRectPath.MoveTo(0, 0);
drawImageRectPath.LineTo(SourceBufferWidth, 0);
drawImageRectPath.LineTo(SourceBufferWidth, SourceBufferHeight);
drawImageRectPath.LineTo(0, SourceBufferHeight);
drawImageRectPath.ClosePolygon();
}
protected virtual void RenderSolidSingleScanLine(IImageByte destImage, IScanlineCache scanLine, RGBA_Bytes color)
{
int y = scanLine.y();
int num_spans = scanLine.num_spans();
ScanlineSpan scanlineSpan = scanLine.begin();
byte[] ManagedCoversArray = scanLine.GetCovers();
for (; ; )
{
int x = scanlineSpan.x;
if (scanlineSpan.len > 0)
{
destImage.blend_solid_hspan(x, y, scanlineSpan.len, color, ManagedCoversArray, scanlineSpan.cover_index);
}
else
{
int x2 = (x - (int)scanlineSpan.len - 1);
destImage.blend_hline(x, y, x2, color, ManagedCoversArray[scanlineSpan.cover_index]);
}
if (--num_spans == 0) break;
scanlineSpan = scanLine.GetNextScanlineSpan();
}
}
public ImageBufferAccessorCommon(IImageByte pixf)
{
attach(pixf);
}
public ImageBufferAccessorClip(IImageByte sourceImage, RGBA_Bytes bk)
: base(sourceImage)
{
m_OutsideBufferColor = new byte[4];
m_OutsideBufferColor[0] = bk.red;
m_OutsideBufferColor[1] = bk.green;
m_OutsideBufferColor[2] = bk.blue;
m_OutsideBufferColor[3] = bk.alpha;
}
// Create
//--------------------------------------------------------------------
public void create(IImageByte src)
{
// we are going to create a dilated image for filtering
// we add m_dilation pixels to every side of the image and then copy the image in the x
// direction into each end so that we can sample into this image to get filtering on x repeating
// if the original image look like this
//
// 123456
//
// the new image would look like this
//
// 0000000000
// 0000000000
// 5612345612
// 0000000000
// 0000000000
m_height = (int)agg_basics.uceil(src.Height);
m_width = (int)agg_basics.uceil(src.Width);
m_width_hr = (int)agg_basics.uround(src.Width * LineAABasics.line_subpixel_scale);
m_half_height_hr = (int)agg_basics.uround(src.Height * LineAABasics.line_subpixel_scale / 2);
m_offset_y_hr = m_dilation_hr + m_half_height_hr - LineAABasics.line_subpixel_scale / 2;
m_half_height_hr += LineAABasics.line_subpixel_scale / 2;
int bufferWidth = m_width + m_dilation * 2;
int bufferHeight = m_height + m_dilation * 2;
int bytesPerPixel = src.BitDepth / 8;
int NewSizeInBytes = bufferWidth * bufferHeight * bytesPerPixel;
if (m_DataSizeInBytes < NewSizeInBytes)
{
m_DataSizeInBytes = NewSizeInBytes;
m_data = new byte[m_DataSizeInBytes];
}
m_buf.AttachBuffer(m_data, 0, bufferWidth, bufferHeight, bufferWidth * bytesPerPixel, src.BitDepth, bytesPerPixel);
byte[] destBuffer = m_buf.GetBuffer();
byte[] sourceBuffer = src.GetBuffer();
// copy the image into the middle of the dest
for (int y = 0; y < m_height; y++)
{
for (int x = 0; x < m_width; x++)
{
int sourceOffset = src.GetBufferOffsetXY(x, y);
int destOffset = m_buf.GetBufferOffsetXY(m_dilation, y + m_dilation);
for (int channel = 0; channel < bytesPerPixel; channel++)
{
destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
}
}
}
// copy the first two pixels form the end into the beginning and from the beginning into the end
for (int y = 0; y < m_height; y++)
{
int s1Offset = src.GetBufferOffsetXY(0, y);
int d1Offset = m_buf.GetBufferOffsetXY(m_dilation + m_width, y);
int s2Offset = src.GetBufferOffsetXY(m_width - m_dilation, y);
int d2Offset = m_buf.GetBufferOffsetXY(0, y);
for (int x = 0; x < m_dilation; x++)
{
for (int channel = 0; channel < bytesPerPixel; channel++)
{
destBuffer[d1Offset++] = sourceBuffer[s1Offset++];
destBuffer[d2Offset++] = sourceBuffer[s2Offset++];
}
}
}
}
public Graphics2D(IImageByte destImage, ScanlineRasterizer rasterizer)
: this()
{
Initialize(destImage, rasterizer);
}
public ImageBuffer(IImageByte sourceImage, IRecieveBlenderByte recieveBlender)
{
SetDimmensionAndFormat(sourceImage.Width, sourceImage.Height, sourceImage.StrideInBytes(), sourceImage.BitDepth, sourceImage.GetBytesBetweenPixelsInclusive(), true);
int offset = sourceImage.GetBufferOffsetXY(0, 0);
byte[] buffer = sourceImage.GetBuffer();
byte[] newBuffer = new byte[buffer.Length];
agg_basics.memcpy(newBuffer, offset, buffer, offset, buffer.Length - offset);
SetBuffer(newBuffer, offset);
SetRecieveBlender(recieveBlender);
}
public AlphaMaskByteUnclipped(IImageByte rbuf, uint Step, uint Offset)
{
m_Step = Step;
m_Offset = Offset;
m_rbuf = rbuf;
}
protected void CopyFromNoClipping(IImageByte sourceImage, RectangleInt clippedSourceImageRect, int destXOffset, int destYOffset)
{
if (GetBytesBetweenPixelsInclusive() != BitDepth / 8
|| sourceImage.GetBytesBetweenPixelsInclusive() != sourceImage.BitDepth / 8)
{
throw new Exception("WIP we only support packed pixel formats at this time.");
}
if (BitDepth == sourceImage.BitDepth)
{
int lengthInBytes = clippedSourceImageRect.Width * GetBytesBetweenPixelsInclusive();
int sourceOffset = sourceImage.GetBufferOffsetXY(clippedSourceImageRect.Left, clippedSourceImageRect.Bottom);
byte[] sourceBuffer = sourceImage.GetBuffer();
int destOffset;
byte[] destBuffer = GetPixelPointerXY(clippedSourceImageRect.Left + destXOffset, clippedSourceImageRect.Bottom + destYOffset, out destOffset);
for (int i = 0; i < clippedSourceImageRect.Height; i++)
{
agg_basics.memmove(destBuffer, destOffset, sourceBuffer, sourceOffset, lengthInBytes);
sourceOffset += sourceImage.StrideInBytes();
destOffset += StrideInBytes();
}
}
else
{
bool haveConversion = true;
switch (sourceImage.BitDepth)
{
case 24:
switch (BitDepth)
{
case 32:
{
int numPixelsToCopy = clippedSourceImageRect.Width;
for (int i = clippedSourceImageRect.Bottom; i < clippedSourceImageRect.Top; i++)
{
int sourceOffset = sourceImage.GetBufferOffsetXY(clippedSourceImageRect.Left, clippedSourceImageRect.Bottom + i);
byte[] sourceBuffer = sourceImage.GetBuffer();
int destOffset;
byte[] destBuffer = GetPixelPointerXY(
clippedSourceImageRect.Left + destXOffset,
clippedSourceImageRect.Bottom + i + destYOffset,
out destOffset);
for (int x = 0; x < numPixelsToCopy; x++)
{
destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
destBuffer[destOffset++] = 255;
}
}
}
break;
default:
haveConversion = false;
break;
}
break;
default:
haveConversion = false;
break;
}
if (!haveConversion)
{
throw new NotImplementedException("You need to write the " + sourceImage.BitDepth.ToString() + " to " + BitDepth.ToString() + " conversion");
}
}
}
public void CopyFrom(IImageByte sourceImage, RectangleInt sourceImageRect, int destXOffset, int destYOffset)
{
RectangleInt sourceImageBounds = sourceImage.GetBounds();
RectangleInt clippedSourceImageRect = new RectangleInt();
if (clippedSourceImageRect.IntersectRectangles(sourceImageRect, sourceImageBounds))
{
RectangleInt destImageRect = clippedSourceImageRect;
destImageRect.Offset(destXOffset, destYOffset);
RectangleInt destImageBounds = GetBounds();
RectangleInt clippedDestImageRect = new RectangleInt();
if (clippedDestImageRect.IntersectRectangles(destImageRect, destImageBounds))
{
// we need to make sure the source is also clipped to the dest. So, we'll copy this back to source and offset it.
clippedSourceImageRect = clippedDestImageRect;
clippedSourceImageRect.Offset(-destXOffset, -destYOffset);
CopyFromNoClipping(sourceImage, clippedSourceImageRect, destXOffset, destYOffset);
}
}
}
public ImageGraphics2D(IImageByte destImage, ScanlineRasterizer rasterizer, IScanlineCache scanlineCache)
: base(destImage, rasterizer)
{
m_ScanlineCache = scanlineCache;
}
public override void Render(IImageByte source,
double destX, double destY,
double angleRadians,
double inScaleX, double inScaleY)
{
{ // exit early if the dest and source bounds don't touch.
// TODO: <BUG> make this do rotation and scalling
RectangleInt sourceBounds = source.GetBounds();
RectangleInt destBounds = this.destImageByte.GetBounds();
sourceBounds.Offset((int)destX, (int)destY);
if (!RectangleInt.DoIntersect(sourceBounds, destBounds))
{
if (inScaleX != 1 || inScaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
return;
}
}
double scaleX = inScaleX;
double scaleY = inScaleY;
Affine graphicsTransform = GetTransform();
if (!graphicsTransform.is_identity())
{
if (scaleX != 1 || scaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
graphicsTransform.transform(ref destX, ref destY);
}
#if false // this is an optomization that eliminates the drawing of images that have their alpha set to all 0 (happens with generated images like explosions).
MaxAlphaFrameProperty maxAlphaFrameProperty = MaxAlphaFrameProperty::GetMaxAlphaFrameProperty(source);
if((maxAlphaFrameProperty.GetMaxAlpha() * color.A_Byte) / 256 <= ALPHA_CHANNEL_BITS_DIVISOR)
{
m_OutFinalBlitBounds.SetRect(0,0,0,0);
}
#endif
bool IsScaled = (scaleX != 1 || scaleY != 1);
bool IsRotated = true;
if (Math.Abs(angleRadians) < (0.1 * MathHelper.Tau / 360))
{
IsRotated = false;
angleRadians = 0;
}
//bool IsMipped = false;
double sourceOriginOffsetX = source.OriginOffset.x;
double sourceOriginOffsetY = source.OriginOffset.y;
bool CanUseMipMaps = IsScaled;
if (scaleX > 0.5 || scaleY > 0.5)
{
CanUseMipMaps = false;
}
bool renderRequriesSourceSampling = IsScaled || IsRotated || destX != (int)destX || destY != (int)destY;
// this is the fast drawing path
if (renderRequriesSourceSampling)
{
#if false // if the scalling is small enough the results can be improved by using mip maps
if(CanUseMipMaps)
{
CMipMapFrameProperty* pMipMapFrameProperty = CMipMapFrameProperty::GetMipMapFrameProperty(source);
double OldScaleX = scaleX;
double OldScaleY = scaleY;
const CFrameInterface* pMippedFrame = pMipMapFrameProperty.GetMipMapFrame(ref scaleX, ref scaleY);
if(pMippedFrame != source)
{
IsMipped = true;
source = pMippedFrame;
sourceOriginOffsetX *= (OldScaleX / scaleX);
sourceOriginOffsetY *= (OldScaleY / scaleY);
}
HotspotOffsetX *= (inScaleX / scaleX);
HotspotOffsetY *= (inScaleY / scaleY);
}
#endif
Affine destRectTransform;
DrawImageGetDestBounds(source, destX, destY, sourceOriginOffsetX, sourceOriginOffsetY, scaleX, scaleY, angleRadians, out destRectTransform);
Affine sourceRectTransform = new Affine(destRectTransform);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
sourceRectTransform.invert();
span_image_filter spanImageFilter;
span_interpolator_linear interpolator = new span_interpolator_linear(sourceRectTransform);
ImageBufferAccessorClip sourceAccessor = new ImageBufferAccessorClip(source, RGBA_Floats.rgba_pre(0, 0, 0, 0).GetAsRGBA_Bytes());
spanImageFilter = new span_image_filter_rgba_bilinear_clip(sourceAccessor, RGBA_Floats.rgba_pre(0, 0, 0, 0), interpolator);
DrawImage(source, spanImageFilter, destRectTransform);
#if false // this is some debug you can enable to visualize the dest bounding box
LineFloat(BoundingRect.left, BoundingRect.top, BoundingRect.right, BoundingRect.top, WHITE);
LineFloat(BoundingRect.right, BoundingRect.top, BoundingRect.right, BoundingRect.bottom, WHITE);
LineFloat(BoundingRect.right, BoundingRect.bottom, BoundingRect.left, BoundingRect.bottom, WHITE);
LineFloat(BoundingRect.left, BoundingRect.bottom, BoundingRect.left, BoundingRect.top, WHITE);
#endif
}
else // TODO: this can be even faster if we do not use an intermediat buffer
{
Affine destRectTransform;
DrawImageGetDestBounds(source, destX, destY, sourceOriginOffsetX, sourceOriginOffsetY, scaleX, scaleY, angleRadians, out destRectTransform);
Affine sourceRectTransform = new Affine(destRectTransform);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
sourceRectTransform.invert();
span_interpolator_linear interpolator = new span_interpolator_linear(sourceRectTransform);
ImageBufferAccessorClip sourceAccessor = new ImageBufferAccessorClip(source, RGBA_Floats.rgba_pre(0, 0, 0, 0).GetAsRGBA_Bytes());
span_image_filter spanImageFilter = null;
switch (source.BitDepth)
{
case 32:
spanImageFilter = new span_image_filter_rgba_nn_stepXby1(sourceAccessor, interpolator);
break;
case 24:
spanImageFilter = new span_image_filter_rgb_nn_stepXby1(sourceAccessor, interpolator);
break;
case 8:
spanImageFilter = new span_image_filter_gray_nn_stepXby1(sourceAccessor, interpolator);
break;
default:
throw new NotImplementedException();
}
//spanImageFilter = new span_image_filter_rgba_nn(sourceAccessor, interpolator);
DrawImage(source, spanImageFilter, destRectTransform);
DestImage.MarkImageChanged();
}
}
private void DrawImage(IImageByte sourceImage, ISpanGenerator spanImageFilter, Affine destRectTransform)
{
if (destImageByte.OriginOffset.x != 0 || destImageByte.OriginOffset.y != 0)
{
destRectTransform *= Affine.NewTranslation(-destImageByte.OriginOffset.x, -destImageByte.OriginOffset.y);
}
VertexSourceApplyTransform transformedRect = new VertexSourceApplyTransform(drawImageRectPath, destRectTransform);
Rasterizer.add_path(transformedRect);
{
ImageClippingProxy destImageWithClipping = new ImageClippingProxy(destImageByte);
scanlineRenderer.GenerateAndRender(Rasterizer, drawImageScanlineCache, destImageWithClipping, destImageSpanAllocatorCache, spanImageFilter);
}
}
public void Initialize(IImageFloat destImage, ScanlineRasterizer rasterizer)
{
destImageByte = null;
destImageFloat = destImage;
this.rasterizer = rasterizer;
}
public void Render(IImageByte imageSource, Point2D position)
{
Render(imageSource, position.x, position.y);
}
public void attach(IImageByte rbuf)
{
m_rbuf = rbuf;
}
public void Render(IImageByte imageSource, Vector2 position, double width, double height)
{
Render(imageSource, position.X, position.Y, width, height);
}
public void Render(IImageByte imageSource, double x, double y, double width, double height)
{
Render(imageSource, x, y, 0, width / imageSource.Width, height / imageSource.Height);
}
internal void render_gouraud(IImageByte backBuffer, IScanlineCache sl, IRasterizer ras, RenderPoint[] points)
{
ImageBuffer image = new ImageBuffer();
image.Attach(backBuffer, new BlenderZBuffer());
ImageClippingProxy ren_base = new ImageClippingProxy(image);
MatterHackers.Agg.span_allocator span_alloc = new span_allocator();
span_gouraud_rgba span_gen = new span_gouraud_rgba();
span_gen.colors(points[0].color, points[1].color, points[2].color);
span_gen.triangle(points[0].position.x, points[0].position.y, points[1].position.x, points[1].position.y, points[2].position.x, points[2].position.y);
ras.add_path(span_gen);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
}
public void Render(IImageByte imageSource, Vector2 position)
{
Render(imageSource, position.X, position.Y);
}
public void Render(IImageByte imageSource, Point2D position)
{
Render(imageSource, position.x, position.y);
}
public void Render(IImageByte imageSource, double x, double y)
{
Render(imageSource, x, y, 0, 1, 1);
}
public void Render(IImageByte imageSource, Vector2 position)
{
Render(imageSource, position.x, position.y);
}
public abstract void Render(IImageByte imageSource,
double x, double y,
double angleRadians,
double scaleX, double ScaleY);
public void Render(IImageByte imageSource, Vector2 position, double width, double height)
{
Render(imageSource, position.x, position.y, width, height);
}
public void Initialize(IImageFloat destImage, ScanlineRasterizer rasterizer)
{
destImageByte = null;
destImageFloat = destImage;
this.rasterizer = rasterizer;
}
public void Render(IImageByte imageSource, double x, double y)
{
Render(imageSource, x, y, 0, 1, 1);
}
public void attach(IImageByte ren)
{
m_ren = ren;
}
public void Render(IImageByte imageSource, double x, double y, double width, double height)
{
Render(imageSource, x, y, 0, width / imageSource.Width, height / imageSource.Height);
}
public ImageBufferAccessorClamp(IImageByte pixf)
: base(pixf)
{
}
public abstract void Render(IImageByte imageSource, double x, double y, double angleRadians, double scaleX, double ScaleY);
public override bool SaveImageData(String filename, IImageByte sourceImage)
{
if (File.Exists(filename))
{
File.Delete(filename);
}
ImageFormat format = ImageFormat.Jpeg;
if (filename.ToLower().EndsWith(".png"))
{
format = ImageFormat.Png;
}
else if (!filename.ToLower().EndsWith(".jpg") && !filename.ToLower().EndsWith(".jpeg"))
{
filename += ".jpg";
}
if (!System.IO.File.Exists(filename))
{
if (sourceImage.BitDepth == 32)
{
Bitmap bitmapToSave = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format32bppArgb);
BitmapData bitmapData = bitmapToSave.LockBits(new Rectangle(0, 0, bitmapToSave.Width, bitmapToSave.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmapToSave.PixelFormat);
int destIndex = 0;
unsafe
{
byte[] sourceBuffer = sourceImage.GetBuffer();
byte* pDestBuffer = (byte*)bitmapData.Scan0;
int scanlinePadding = bitmapData.Stride - bitmapData.Width * 4;
for (int y = 0; y < sourceImage.Height; y++)
{
int sourceIndex = sourceImage.GetBufferOffsetXY(0, sourceImage.Height - 1 - y);
for (int x = 0; x < sourceImage.Width; x++)
{
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
}
destIndex += scanlinePadding;
}
}
bitmapToSave.Save(filename, format);
bitmapToSave.UnlockBits(bitmapData);
return true;
}
else if (sourceImage.BitDepth == 8 && format == ImageFormat.Png)
{
Bitmap bitmapToSave = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format8bppIndexed);
ColorPalette palette = bitmapToSave.Palette;
for (int i = 0; i < palette.Entries.Length; i++)
{
palette.Entries[i] = Color.FromArgb(i, i, i);
}
bitmapToSave.Palette = palette;
BitmapData bitmapData = bitmapToSave.LockBits(new Rectangle(0, 0, bitmapToSave.Width, bitmapToSave.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmapToSave.PixelFormat);
int destIndex = 0;
unsafe
{
byte[] sourceBuffer = sourceImage.GetBuffer();
byte* pDestBuffer = (byte*)bitmapData.Scan0;
for (int y = 0; y < sourceImage.Height; y++)
{
int sourceIndex = sourceImage.GetBufferOffsetXY(0, sourceImage.Height - 1 - y);
for (int x = 0; x < sourceImage.Width; x++)
{
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
}
}
}
bitmapToSave.Save(filename, format);
bitmapToSave.UnlockBits(bitmapData);
return true;
}
else
{
throw new System.NotImplementedException();
}
}
return false;
}
public Graphics2D(IImageByte destImage, ScanlineRasterizer rasterizer)
: this()
{
Initialize(destImage, rasterizer);
}
