//--------------------------------------------
protected void Attach(int width, int height, int bitsPerPixel, byte[] imgbuffer, IPixelBlender recieveBlender)
{
if (width <= 0 || height <= 0)
{
throw new ArgumentOutOfRangeException("You must have a width and height > than 0.");
}
if (bitsPerPixel != 32 && bitsPerPixel != 24 && bitsPerPixel != 8)
{
throw new Exception("Unsupported bits per pixel.");
}
this.bitDepth = bitsPerPixel;
int bytesPerPixel = (bitDepth + 7) / 8;
int stride = 4 * ((width * bytesPerPixel + 3) / 4);
//-------------------------------------------------------------------------------------------
SetDimmensionAndFormat(width, height, stride, bitsPerPixel, bitsPerPixel / 8);
this.m_ByteBuffer = imgbuffer;
SetUpLookupTables();
if (yTableArray.Length != height
|| xTableArray.Length != width)
{
throw new Exception("The yTable and xTable should be allocated correctly at this point. Figure out what happend."); // LBB, don't fix this if you don't understand what it's trying to do.
}
//--------------------------
SetRecieveBlender(recieveBlender);
}
public void SetRecieveBlender(IPixelBlender value)
{
if (BitDepth != 0 && value != null && value.NumPixelBits != BitDepth)
{
throw new NotSupportedException("The blender has to support the bit depth of this image.");
}
recieveBlender = value;
}
//---------------------------------------------------------------------
public OutlineRenderer(IImageReaderWriter destImage, IPixelBlender destPixelBlender, LineProfileAnitAlias profile)
{
destImageSurface = destImage;
lineProfile = profile;
clippingRectangle = new RectInt(0, 0, 0, 0);
doClipping = false;
this.destPixelBlender = destPixelBlender;
}
public ChildImage(IImageReaderWriter image,
IPixelBlender blender,
int distanceBetweenPixelsInclusive,
int bufferOffset,
int bitsPerPixel)
{
SetRecieveBlender(blender);
Attach(image, blender, distanceBetweenPixelsInclusive, bufferOffset, bitsPerPixel);
}
public SubImageRW(IImageReaderWriter image,
IPixelBlender blender,
int distanceBetweenPixelsInclusive,
int arrayOffset32,
int bitsPerPixel)
{
SetRecieveBlender(blender);
Attach(image, blender, distanceBetweenPixelsInclusive, arrayOffset32, bitsPerPixel);
}
public ChildImage(IImageReaderWriter image,
IPixelBlender blender,
int distanceBetweenPixelsInclusive,
int bufferOffset,
int bitsPerPixel)
{
SetRecieveBlender(blender);
Attach(image, blender, distanceBetweenPixelsInclusive, bufferOffset, bitsPerPixel);
}
public override void Draw(CanvasPainter p)
{
//-----------------------------------------------------------------
//control
CanvasPainter painter = p;
painter.Clear(this.WhiteOnBlack ? ColorRGBA.Black : ColorRGBA.White);
painter.FillColor = new ColorRGBA(127, 127, 127);
painter.FillCircle(m_x[0], m_y[0], 3); //left-bottom control box
painter.FillCircle(m_x[1], m_y[1], 3); //right-top control box
//-----------------------------------------------------------------
double d = this.SubPixelOffset;
AggCanvasPainter p2 = p as AggCanvasPainter;
IPixelBlender prevBlender = null;
Graphics2D gx = null;
if (p2 != null)
{
//for agg only
gx = p2.Graphics;
prevBlender = gx.PixelBlender;
//change gamma blender
gx.PixelBlender = new PixelBlenderGammaBGRA(this.Gamma);
}
if (this.FillRoundRect)
{
painter.FillColor = this.WhiteOnBlack ? ColorRGBA.White : ColorRGBA.Black;
painter.FillRoundRectangle(
m_x[0] + d,
m_y[0] + d,
m_x[1] + d,
m_y[1] + d,
this.Radius);
}
else
{
painter.StrokeColor = this.WhiteOnBlack ? ColorRGBA.White : ColorRGBA.Black;
painter.DrawRoundRect(
m_x[0] + d,
m_y[0] + d,
m_x[1] + d,
m_y[1] + d,
this.Radius);
}
if (gx != null)
{
gx.PixelBlender = prevBlender;
}
}
public ImageGraphics2D(ActualImage destImage)
{
//create from actual image
this.destActualImage = destImage;
this.destImageReaderWriter = new MyImageReaderWriter(destImage);
this.sclineRas = new ScanlineRasterizer();
this.sclineRasToBmp = new ScanlineRasToDestBitmapRenderer();
this.destWidth = destImage.Width;
this.destHeight = destImage.Height;
this.clipBox = new RectInt(0, 0, destImage.Width, destImage.Height);
this.sclineRas.SetClipBox(this.clipBox);
this.sclinePack8 = new ScanlinePacked8();
this.currentBlender = this.pixBlenderRGBA32 = new PixelBlenderBGRA();
}
static void CopyOrBlend_BasedOnAlpha(IPixelBlender recieveBlender, byte[] destBuffer, int bufferOffset, ColorRGBA sourceColor)
{
//if (sourceColor.m_A != 0)
{
#if false // we blend regardless of the alpha so that we can get Light Opacity working (used this way we have addative and faster blending in one blender) LBB
if (sourceColor.m_A == base_mask)
{
Blender.CopyPixel(pDestBuffer, sourceColor);
}
else
#endif
{
recieveBlender.BlendPixel(destBuffer, bufferOffset, sourceColor);
}
}
}
public ImageGraphics2D(ActualImage destImage)
{
//create from actual image
this.destImage = destImage;
this.destActualImage = destImage;
this.destImageReaderWriter = new MyImageReaderWriter();
destImageReaderWriter.ReloadImage(destImage);
this.sclineRas = new ScanlineRasterizer();
this.sclineRasToBmp = new ScanlineRasToDestBitmapRenderer();
this.destWidth = destImage.Width;
this.destHeight = destImage.Height;
this.clipBox = new RectInt(0, 0, destImage.Width, destImage.Height);
this.sclineRas.SetClipBox(this.clipBox);
this.sclinePack8 = new ScanlinePacked8();
this.currentBlender = this.pixBlenderRGBA32 = new PixelBlenderBGRA();
}
void Attach(IImageReaderWriter sourceImage,
IPixelBlender recieveBlender,
int distanceBetweenPixelsInclusive,
int bufferOffset,
int bitsPerPixel)
{
SetDimmensionAndFormat(sourceImage.Width,
sourceImage.Height,
sourceImage.Stride,
bitsPerPixel,
distanceBetweenPixelsInclusive);
int offset = sourceImage.GetBufferOffsetXY(0, 0);
byte[] buffer = sourceImage.GetBuffer();
SetBuffer(buffer, offset + bufferOffset);
SetRecieveBlender(recieveBlender);
}
void Attach(IImageReaderWriter sourceImage,
IPixelBlender recieveBlender,
int distanceBetweenPixelsInclusive,
int arrayElemOffset,
int bitsPerPixel)
{
_sourceImage = sourceImage;
SetDimmensionAndFormat(sourceImage.Width,
sourceImage.Height,
sourceImage.Stride,
bitsPerPixel,
distanceBetweenPixelsInclusive);
int srcOffset32 = sourceImage.GetByteBufferOffsetXY(0, 0) / 4;
int[] buffer = sourceImage.GetInt32Buffer();
SetBuffer(buffer, srcOffset32 + arrayElemOffset);
SetRecieveBlender(recieveBlender);
}
public void ReloadImage(ActualImage actualImage)
{
if (this.actualImage == actualImage)
{
return;
}
this.actualImage = actualImage;
//calculate image stride
switch (actualImage.PixelFormat)
{
case PixelFormat.ARGB32:
{
Attach(actualImage.Width,
actualImage.Height,
actualImage.BitDepth,
ActualImage.GetBuffer(actualImage),
pixelBlenderRGBA ?? (pixelBlenderRGBA = new PixelBlenderBGRA()));
//Attach(actualImage.Width,
// actualImage.Height,
// actualImage.BitDepth,
// ActualImage.GetBuffer(actualImage),
// pixelBlenderRGBA ?? (pixelBlenderRGBA = new PixelBlenderGammaBGRA(0.8f)));
}
break;
case PixelFormat.GrayScale8:
{
Attach(actualImage.Width,
actualImage.Height,
actualImage.BitDepth,
ActualImage.GetBuffer(actualImage),
pixelBlenderGray ?? (pixelBlenderGray = new PixelBlenderGray(1)));
}
break;
case PixelFormat.RGB24:
default:
{
throw new NotSupportedException();
}
}
}
/// <summary>
/// load image to the reader/writer
/// </summary>
/// <param name="actualImage"></param>
public void ReloadImage(ActualImage actualImage)
{
if (this.actualImage == actualImage)
{
return;
}
//in this version we support actual images
//in 2 formats :
//1. 32 bits ARGB
//2. 8 bits gray scale
//
this.actualImage = actualImage;
switch (actualImage.PixelFormat)
{
case PixelFormat.ARGB32:
{
Attach(actualImage.Width,
actualImage.Height,
actualImage.BitDepth,
ActualImage.GetBuffer(actualImage),
pixelBlenderRGBA ?? (pixelBlenderRGBA = new PixelBlenderBGRA()));
}
break;
case PixelFormat.GrayScale8:
{
Attach(actualImage.Width,
actualImage.Height,
actualImage.BitDepth,
ActualImage.GetBuffer(actualImage),
pixelBlenderGray ?? (pixelBlenderGray = new PixelBlenderGray(1)));
}
break;
default:
{
throw new NotSupportedException();
}
}
}
static void CopyOrBlend_BasedOnAlphaAndCover(IPixelBlender recieveBlender, byte[] destBuffer, int bufferOffset, Color sourceColor, int cover)
{
if (cover == 255)
{
CopyOrBlend_BasedOnAlpha(recieveBlender, destBuffer, bufferOffset, sourceColor);
}
else
{
//if (sourceColor.m_A != 0)
{
sourceColor.alpha = (byte)((sourceColor.alpha * (cover + 1)) >> 8);
#if false // we blend regardless of the alpha so that we can get Light Opacity working (used this way we have addative and faster blending in one blender) LBB
if (sourceColor.m_A == base_mask)
{
Blender.CopyPixel(pDestBuffer, sourceColor);
}
else
#endif
{
recieveBlender.BlendPixel(destBuffer, bufferOffset, sourceColor);
}
}
}
}
public void SetRecieveBlender(IPixelBlender value)
{
if (BitDepth != 0 && value != null && value.NumPixelBits != BitDepth)
{
throw new NotSupportedException("The blender has to support the bit depth of this image.");
}
recieveBlender = value;
}
public override void Draw(CanvasPainter p)
{
//specific for agg
if (!(p is AggCanvasPainter))
{
return;
}
AggCanvasPainter p2 = (AggCanvasPainter)p;
Graphics2D graphics2D = p2.Graphics;
if (graphics2D.DestImage != null)
{
IImageReaderWriter backBuffer = graphics2D.DestImage;
IPixelBlender currentPixelBlender = graphics2D.PixelBlender;
int distBetween = backBuffer.BytesBetweenPixelsInclusive;
//use different pixel blender
var redImageBuffer = new ChildImage(backBuffer, new PixelBlenderGray(distBetween), distBetween, CO.R, 8);
var greenImageBuffer = new ChildImage(backBuffer, new PixelBlenderGray(distBetween), distBetween, CO.G, 8);
var blueImageBuffer = new ChildImage(backBuffer, new PixelBlenderGray(distBetween), distBetween, CO.B, 8);
ClipProxyImage clippingProxy = new ClipProxyImage(backBuffer);
ClipProxyImage clippingProxyRed = new ClipProxyImage(redImageBuffer);
ClipProxyImage clippingProxyGreen = new ClipProxyImage(greenImageBuffer);
ClipProxyImage clippingProxyBlue = new ClipProxyImage(blueImageBuffer);
ScanlineRasterizer sclineRas = graphics2D.ScanlineRasterizer;
ScanlinePacked8 scline = graphics2D.ScanlinePacked8;
ColorRGBA clearColor = this.UseBlackBlackground ? new ColorRGBA(0, 0, 0) : new ColorRGBA(255, 255, 255);
clippingProxy.Clear(clearColor);
ColorRGBA fillColor = this.UseBlackBlackground ?
new ColorRGBA(255, 255, 255, (byte)(this.AlphaValue)) :
new ColorRGBA(0, 0, 0, (byte)(this.AlphaValue));
ScanlineRasToDestBitmapRenderer sclineRasToBmp = graphics2D.ScanlineRasToDestBitmap;
VertexSource.Ellipse er = new PixelFarm.Agg.VertexSource.Ellipse(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
sclineRas.AddPath(er.MakeVertexSnap());
sclineRasToBmp.RenderWithColor(clippingProxyRed, sclineRas, scline, fillColor);
VertexSource.Ellipse eg = new PixelFarm.Agg.VertexSource.Ellipse(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
sclineRas.AddPath(eg.MakeVertexSnap());
sclineRasToBmp.RenderWithColor(clippingProxyGreen, sclineRas, scline, fillColor);
VertexSource.Ellipse eb = new PixelFarm.Agg.VertexSource.Ellipse(Width / 2, Height / 2 + 50, 100, 100, 100);
sclineRas.AddPath(eb.MakeVertexSnap());
sclineRasToBmp.RenderWithColor(clippingProxyBlue, sclineRas, scline, fillColor);
}
// else if (graphics2D.DestImageFloat != null)
// {
//#if false
// IImageFloat backBuffer = graphics2D.DestImageFloat;
// int distBetween = backBuffer.GetFloatsBetweenPixelsInclusive();
// ImageBufferFloat redImageBuffer = new ImageBufferFloat();
// redImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 2, 8);
// ImageBufferFloat greenImageBuffer = new ImageBufferFloat();
// greenImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 1, 8);
// ImageBufferFloat blueImageBuffer = new ImageBufferFloat();
// blueImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 0, 8);
// ImageClippingProxy clippingProxy = new ImageClippingProxy(backBuffer);
// ImageClippingProxy clippingProxyRed = new ImageClippingProxy(redImageBuffer);
// ImageClippingProxy clippingProxyGreen = new ImageClippingProxy(greenImageBuffer);
// ImageClippingProxy clippingProxyBlue = new ImageClippingProxy(blueImageBuffer);
// ScanlineRasterizer ras = new ScanlineRasterizer();
// ScanlineCachePacked8 sl = new ScanlineCachePacked8();
// RGBA_Bytes clearColor = useBlackBackgroundCheckbox.Checked ? new RGBA_Bytes(0, 0, 0) : new RGBA_Bytes(255, 255, 255);
// clippingProxy.clear(clearColor);
// alphaSlider.View.BackGroundColor = clearColor;
// RGBA_Bytes FillColor = useBlackBackgroundCheckbox.Checked ? new RGBA_Bytes(255, 255, 255, (int)(alphaSlider.Value)) : new RGBA_Bytes(0, 0, 0, (int)(alphaSlider.Value));
// VertexSource.Ellipse er = new AGG.VertexSource.Ellipse(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
// ras.add_path(er);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyRed, ras, sl, FillColor);
// VertexSource.Ellipse eg = new AGG.VertexSource.Ellipse(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
// ras.add_path(eg);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyGreen, ras, sl, FillColor);
// VertexSource.Ellipse eb = new AGG.VertexSource.Ellipse(Width / 2, Height / 2 + 50, 100, 100, 100);
// ras.add_path(eb);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyBlue, ras, sl, FillColor);
//#endif
// }
}
static void CopyOrBlend_BasedOnAlphaAndCover(IPixelBlender recieveBlender, byte[] destBuffer, int bufferOffset, Color sourceColor, int cover)
{
if (cover == 255)
{
CopyOrBlend_BasedOnAlpha(recieveBlender, destBuffer, bufferOffset, sourceColor);
}
else
{
//if (sourceColor.m_A != 0)
{
sourceColor.alpha = (byte)((sourceColor.alpha * (cover + 1)) >> 8);
#if false // we blend regardless of the alpha so that we can get Light Opacity working (used this way we have addative and faster blending in one blender) LBB
if (sourceColor.m_A == base_mask)
{
Blender.CopyPixel(pDestBuffer, sourceColor);
}
else
#endif
{
recieveBlender.BlendPixel(destBuffer, bufferOffset, sourceColor);
}
}
}
}
//--------------------------------------------
protected void Attach(int width, int height, int bitsPerPixel, byte[] imgbuffer, IPixelBlender recieveBlender)
{
if (width <= 0 || height <= 0)
{
throw new ArgumentOutOfRangeException("You must have a width and height > than 0.");
}
if (bitsPerPixel != 32 && bitsPerPixel != 24 && bitsPerPixel != 8)
{
throw new Exception("Unsupported bits per pixel.");
}
this.bitDepth = bitsPerPixel;
int bytesPerPixel = (bitDepth + 7) / 8;
int stride = 4 * ((width * bytesPerPixel + 3) / 4);
//-------------------------------------------------------------------------------------------
SetDimmensionAndFormat(width, height, stride, bitsPerPixel, bitsPerPixel / 8);
this.m_ByteBuffer = imgbuffer;
SetUpLookupTables();
if (yTableArray.Length != height ||
xTableArray.Length != width)
{
throw new Exception("The yTable and xTable should be allocated correctly at this point. Figure out what happend."); // LBB, don't fix this if you don't understand what it's trying to do.
}
//--------------------------
SetRecieveBlender(recieveBlender);
}
public ChildImage(IImageReaderWriter image, IPixelBlender blender)
{
Attach(image, blender, image.BytesBetweenPixelsInclusive, 0, image.BitDepth);
}
public void SetRecieveBlender(IPixelBlender value)
{
linkedImage.SetRecieveBlender(value);
}
/// <summary>
/// attach image buffer and its information to the reader
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="bitsPerPixel"></param>
/// <param name="imgbuffer"></param>
/// <param name="recieveBlender"></param>
protected void Attach(int width, int height, int bitsPerPixel, int[] imgbuffer, IPixelBlender recieveBlender)
{
if (width <= 0 || height <= 0)
{
throw new ArgumentOutOfRangeException("You must have a width and height > than 0.");
}
if (bitsPerPixel != 32 && bitsPerPixel != 24 && bitsPerPixel != 8)
{
throw new Exception("Unsupported bits per pixel.");
}
//
//
int bytesPerPixel = (bitsPerPixel + 7) / 8;
int stride = 4 * ((width * bytesPerPixel + 3) / 4);
#if DEBUG
if (bytesPerPixel == 0)
{
}
#endif
//
SetDimmensionAndFormat(width, height, stride, bitsPerPixel, bitsPerPixel / 8);
SetUpLookupTables();
//
SetRecieveBlender(recieveBlender);
//
//this.m_ByteBuffer = imgbuffer;
this.raw_buffer32 = imgbuffer;
}
void SubPixRender(IImageReaderWriter dest, Scanline scanline, ColorRGBA color)
{
byte[] covers = scanline.GetCovers();
int num_spans = scanline.SpanCount;
int y = scanline.Y;
byte[] buffer = dest.GetBuffer();
IPixelBlender blender = dest.GetRecieveBlender();
int last_x = int.MinValue;
int prev_cover = 0;
int bufferOffset = 0;
ColorRGBA prevColor = ColorRGBA.White;
for (int i = 1; i <= num_spans; ++i)
{
//render span by span
ScanlineSpan span = scanline.GetSpan(i);
if (span.x != last_x + 1)
{
bufferOffset = dest.GetBufferOffsetXY(span.x, y);
//when skip then reset
prev_cover = 0;
prevColor = ColorRGBA.White;
}
last_x = span.x;
int num_pix = span.len;
if (num_pix < 0)
{
//special encode***
num_pix = -num_pix; //make it positive value
last_x += (num_pix - 1);
//long span with coverage
int coverageValue = covers[span.cover_index];
//-------------------------------------------
if (coverageValue >= 255)
{
//100% cover
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
ColorRGBA newc = prevColor = new ColorRGBA(color.red, color.green, color.blue);
ColorRGBA todrawColor = new ColorRGBA(newc, a);
prev_cover = 255;//full
while (num_pix > 0)
{
blender.BlendPixel(buffer, bufferOffset, todrawColor);
bufferOffset += 4; //1 pixel 4 bytes
--num_pix;
}
}
else
{
prev_cover = coverageValue;
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
ColorRGBA newc = prevColor = new ColorRGBA(color.red, color.green, color.blue);
ColorRGBA todrawColor = new ColorRGBA(newc, a);
while (num_pix > 0)
{
blender.BlendPixel(buffer, bufferOffset, todrawColor);
bufferOffset += 4; //1 pixel 4 bytes
--num_pix;
}
}
}
else
{
int coverIndex = span.cover_index;
last_x += (num_pix - 1);
while (num_pix > 0)
{
int coverageValue = covers[coverIndex++];
if (coverageValue >= 255)
{
//100% cover
ColorRGBA newc = new ColorRGBA(color.red, color.green, color.blue);
prevColor = newc;
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
prev_cover = 255;//full
}
else
{
//check direction :
bool isLeftToRight = coverageValue >= prev_cover;
prev_cover = coverageValue;
byte c_r, c_g, c_b;
float subpix_percent = ((float)(coverageValue) / 256f);
if (coverageValue < cover_1_3)
{
if (isLeftToRight)
{
c_r = 255;
c_g = 255;
c_b = (byte)(255 - (255f * (subpix_percent)));
}
else
{
c_r = (byte)(255 - (255f * (subpix_percent)));
c_g = 255;
c_b = 255;
}
ColorRGBA newc = prevColor = new ColorRGBA(c_r, c_g, c_b);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
}
else if (coverageValue < cover_2_3)
{
if (isLeftToRight)
{
c_r = prevColor.blue;
c_g = (byte)(255 - (255f * (subpix_percent)));
c_b = color.blue;
}
else
{
c_r = color.blue;
c_g = (byte)(255 - (255f * (subpix_percent)));
c_b = 255;
}
ColorRGBA newc = prevColor = new ColorRGBA(c_r, c_g, c_b);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
}
else
{
//cover > 2/3 but not full
if (isLeftToRight)
{
c_r = (byte)(255 - (255f * (subpix_percent)));
c_g = color.green;
c_b = color.blue;
}
else
{
c_r = prevColor.green;
c_g = prevColor.blue;
c_b = (byte)(255 - (255f * (subpix_percent)));
}
ColorRGBA newc = prevColor = new ColorRGBA(c_r, c_g, c_b);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
}
}
bufferOffset += 4; //1 pixel 4 bits
--num_pix;
}
}
}
}
public SubImageRW(IImageReaderWriter image, IPixelBlender blender)
{
Attach(image, blender, image.BytesBetweenPixelsInclusive, 0, image.BitDepth);
}
public ChildImage(IImageReaderWriter image, IPixelBlender blender, int x1, int y1, int x2, int y2)
{
SetRecieveBlender(blender);
Attach(image, x1, y1, x2, y2);
}
void Attach(IImageReaderWriter sourceImage,
IPixelBlender recieveBlender,
int distanceBetweenPixelsInclusive,
int bufferOffset,
int bitsPerPixel)
{
SetDimmensionAndFormat(sourceImage.Width,
sourceImage.Height,
sourceImage.Stride,
bitsPerPixel,
distanceBetweenPixelsInclusive);
int offset = sourceImage.GetBufferOffsetXY(0, 0);
byte[] buffer = sourceImage.GetBuffer();
SetBuffer(buffer, offset + bufferOffset);
SetRecieveBlender(recieveBlender);
}
public void SetRecieveBlender(IPixelBlender value)
{
linkedImage.SetRecieveBlender(value);
}
public override void Draw(PixelFarm.Drawing.Painter p)
{
//specific for agg
if (!(p is AggPainter))
{
return;
}
throw new NotSupportedException();
AggPainter p2 = (AggPainter)p;
AggRenderSurface aggRdsf = p2.RenderSurface;
if (aggRdsf.DestImage != null)
{
IImageReaderWriter backBuffer = aggRdsf.DestImage;
IPixelBlender currentPixelBlender = aggRdsf.PixelBlender;
int distBetween = backBuffer.BytesBetweenPixelsInclusive;
//use different pixel blender
var redImageBuffer = new SubImageRW(backBuffer, new PixelBlenderGray(distBetween), distBetween, CO.R, 8);
var greenImageBuffer = new SubImageRW(backBuffer, new PixelBlenderGray(distBetween), distBetween, CO.G, 8);
var blueImageBuffer = new SubImageRW(backBuffer, new PixelBlenderGray(distBetween), distBetween, CO.B, 8);
ClipProxyImage clippingProxy = new ClipProxyImage(backBuffer);
ClipProxyImage clippingProxyRed = new ClipProxyImage(redImageBuffer);
ClipProxyImage clippingProxyGreen = new ClipProxyImage(greenImageBuffer);
ClipProxyImage clippingProxyBlue = new ClipProxyImage(blueImageBuffer);
ScanlineRasterizer sclineRas = aggRdsf.ScanlineRasterizer;
ScanlinePacked8 scline = aggRdsf.ScanlinePacked8;
Drawing.Color clearColor = this.UseBlackBlackground ? Drawing.Color.FromArgb(0, 0, 0) : Drawing.Color.FromArgb(255, 255, 255);
clippingProxy.Clear(clearColor);
Drawing.Color fillColor = this.UseBlackBlackground ?
new Drawing.Color((byte)(this.AlphaValue), 255, 255, 255) :
new Drawing.Color((byte)(this.AlphaValue), 0, 0, 0);
ScanlineRasToDestBitmapRenderer sclineRasToBmp = aggRdsf.ScanlineRasToDestBitmap;
VertexSource.Ellipse er = new PixelFarm.Agg.VertexSource.Ellipse(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
//
VectorToolBox.GetFreeVxs(out var v1);
sclineRas.AddPath(er.MakeVxs(v1));
v1.Clear();
sclineRasToBmp.RenderWithColor(clippingProxyRed, sclineRas, scline, fillColor);
VertexSource.Ellipse eg = new PixelFarm.Agg.VertexSource.Ellipse(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
sclineRas.AddPath(eg.MakeVertexSnap(v1));
v1.Clear();
sclineRasToBmp.RenderWithColor(clippingProxyGreen, sclineRas, scline, fillColor);
VertexSource.Ellipse eb = new PixelFarm.Agg.VertexSource.Ellipse(Width / 2, Height / 2 + 50, 100, 100, 100);
sclineRas.AddPath(eb.MakeVertexSnap(v1));
v1.Clear();
sclineRasToBmp.RenderWithColor(clippingProxyBlue, sclineRas, scline, fillColor);
VectorToolBox.ReleaseVxs(ref v1);
}
// else if (graphics2D.DestImageFloat != null)
// {
//#if false
// IImageFloat backBuffer = graphics2D.DestImageFloat;
// int distBetween = backBuffer.GetFloatsBetweenPixelsInclusive();
// ImageBufferFloat redImageBuffer = new ImageBufferFloat();
// redImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 2, 8);
// ImageBufferFloat greenImageBuffer = new ImageBufferFloat();
// greenImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 1, 8);
// ImageBufferFloat blueImageBuffer = new ImageBufferFloat();
// blueImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 0, 8);
// ImageClippingProxy clippingProxy = new ImageClippingProxy(backBuffer);
// ImageClippingProxy clippingProxyRed = new ImageClippingProxy(redImageBuffer);
// ImageClippingProxy clippingProxyGreen = new ImageClippingProxy(greenImageBuffer);
// ImageClippingProxy clippingProxyBlue = new ImageClippingProxy(blueImageBuffer);
// ScanlineRasterizer ras = new ScanlineRasterizer();
// ScanlineCachePacked8 sl = new ScanlineCachePacked8();
// RGBA_Bytes clearColor = useBlackBackgroundCheckbox.Checked ? new RGBA_Bytes(0, 0, 0) : new RGBA_Bytes(255, 255, 255);
// clippingProxy.clear(clearColor);
// alphaSlider.View.BackGroundColor = clearColor;
// RGBA_Bytes FillColor = useBlackBackgroundCheckbox.Checked ? new RGBA_Bytes(255, 255, 255, (int)(alphaSlider.Value)) : new RGBA_Bytes(0, 0, 0, (int)(alphaSlider.Value));
// VertexSource.Ellipse er = new AGG.VertexSource.Ellipse(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
// ras.add_path(er);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyRed, ras, sl, FillColor);
// VertexSource.Ellipse eg = new AGG.VertexSource.Ellipse(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
// ras.add_path(eg);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyGreen, ras, sl, FillColor);
// VertexSource.Ellipse eb = new AGG.VertexSource.Ellipse(Width / 2, Height / 2 + 50, 100, 100, 100);
// ras.add_path(eb);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyBlue, ras, sl, FillColor);
//#endif
// }
}
//---------------------------------------------------------------------
public OutlineRenderer(IImageReaderWriter destImage, IPixelBlender destPixelBlender, LineProfileAnitAlias profile)
{
destImageSurface = destImage;
lineProfile = profile;
clippingRectangle = new RectInt(0, 0, 0, 0);
doClipping = false;
this.destPixelBlender = destPixelBlender;
}
public ChildImage(IImageReaderWriter image, IPixelBlender blender, int x1, int y1, int x2, int y2)
{
SetRecieveBlender(blender);
Attach(image, x1, y1, x2, y2);
}
