public override void OnDraw(Graphics2D graphics2D)
{
ImageClippingProxy ren_base = new ImageClippingProxy(graphics2D.DestImage);
ren_base.clear(new RGBA_Floats(1.0, 1.0, .95));
ScanlineRasterizer ras = new ScanlineRasterizer();
ScanlineCachePacked8 sl = new ScanlineCachePacked8();
// Pattern source. Must have an interface:
// width() const
// height() const
// pixel(int x, int y) const
// Any agg::renderer_base<> or derived
// is good for the use as a source.
//-----------------------------------
pattern_src_brightness_to_alpha_RGBA_Bytes p1 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img0);
pattern_src_brightness_to_alpha_RGBA_Bytes p2 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img1);
pattern_src_brightness_to_alpha_RGBA_Bytes p3 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img2);
pattern_src_brightness_to_alpha_RGBA_Bytes p4 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img3);
pattern_src_brightness_to_alpha_RGBA_Bytes p5 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img4);
pattern_src_brightness_to_alpha_RGBA_Bytes p6 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img5);
pattern_src_brightness_to_alpha_RGBA_Bytes p7 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img6);
pattern_src_brightness_to_alpha_RGBA_Bytes p8 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img7);
pattern_src_brightness_to_alpha_RGBA_Bytes p9 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img8);
//pattern_filter_bilinear_RGBA_Bytes fltr = new pattern_filter_bilinear_RGBA_Bytes(); // Filtering functor
// agg::line_image_pattern is the main container for the patterns. It creates
// a copy of the patterns extended according to the needs of the filter.
// agg::line_image_pattern can operate with arbitrary image width, but if the
// width of the pattern is power of 2, it's better to use the modified
// version agg::line_image_pattern_pow2 because it works about 15-25 percent
// faster than agg::line_image_pattern (because of using simple masking instead
// of expensive '%' operation).
//-- Create with specifying the source
//-- Create uninitialized and set the source
line_image_pattern patt = new line_image_pattern(new pattern_filter_bilinear_RGBA_Bytes());
ImageLineRenderer ren_img = new ImageLineRenderer(ren_base, patt);
rasterizer_outline_aa ras_img = new rasterizer_outline_aa(ren_img);
draw_curve(patt, ras_img, ren_img, p1, m_curve1.curve());
/*
* draw_curve(patt, ras_img, ren_img, p2, m_curve2.curve());
* draw_curve(patt, ras_img, ren_img, p3, m_curve3.curve());
* draw_curve(patt, ras_img, ren_img, p4, m_curve4.curve());
* draw_curve(patt, ras_img, ren_img, p5, m_curve5.curve());
* draw_curve(patt, ras_img, ren_img, p6, m_curve6.curve());
* draw_curve(patt, ras_img, ren_img, p7, m_curve7.curve());
* draw_curve(patt, ras_img, ren_img, p8, m_curve8.curve());
* draw_curve(patt, ras_img, ren_img, p9, m_curve9.curve());
*/
base.OnDraw(graphics2D);
}
private void _InternalRender(IVertexSource vertexSource, RGBA_Bytes color)
{
if (_clipBuffer != null)
{
// DEBUG_saveImageBuffer(_clipBuffer);
// DEBUG_saveImageBuffer(this.imb);
IAlphaMask alphaMask = new AlphaMaskByteClipped(_clipBuffer, 1, 0);
AlphaMaskAdaptor imageAlphaMaskAdaptor = new AlphaMaskAdaptor(aggGc.DestImage, alphaMask);
ImageClippingProxy alphaMaskClippingProxy = new ImageClippingProxy(imageAlphaMaskAdaptor);
var scanlineRenderer = new ScanlineRenderer();
var rasterizer = new ScanlineRasterizer();
var scanlineCache = new ScanlineCachePacked8();
VertexSourceApplyTransform trans = new VertexSourceApplyTransform(vertexSource, aggGc.GetTransform());
rasterizer.add_path(trans);
scanlineRenderer.render_scanlines_aa_solid(alphaMaskClippingProxy, rasterizer, scanlineCache, color);
aggGc.DestImage.MarkImageChanged();
}
else
{
aggGc.Render(vertexSource, color);
}
}
internal InternalImageGraphics2D(ImageBuffer owner)
: base()
{
ScanlineRasterizer rasterizer = new ScanlineRasterizer();
ImageClippingProxy imageClippingProxy = new ImageClippingProxy(owner);
Initialize(imageClippingProxy, rasterizer);
ScanlineCache = new ScanlineCachePacked8();
}
public blur()
{
m_rbuf2 = new ImageBuffer();
m_shape_bounds = new RectangleDouble();
m_method = new RadioButtonGroup(new Vector2(10.0, 10.0), new Vector2(130.0, 60.0));
m_radius = new Slider(new Vector2(130 + 10.0, 10.0 + 4.0), new Vector2(290, 8.0));
m_shadow_ctrl = new PolygonEditWidget(4);
m_channel_r = new CheckBox(10.0, 80.0, "Red");
m_channel_g = new CheckBox(10.0, 95.0, "Green");
m_channel_b = new CheckBox(10.0, 110.0, "Blue");
m_FlattenCurves = new CheckBox(10, 315, "Convert And Flatten Curves");
m_FlattenCurves.Checked = true;
AddChild(m_method);
m_method.AddRadioButton("Stack Blur");
m_method.AddRadioButton("Recursive Blur");
m_method.AddRadioButton("Channels");
m_method.SelectedIndex = 1;
AddChild(m_radius);
m_radius.SetRange(0.0, 40.0);
m_radius.Value = 15.0;
m_radius.Text = "Blur Radius={0:F2}";
AddChild(m_shadow_ctrl);
AddChild(m_channel_r);
AddChild(m_channel_g);
AddChild(m_channel_b);
AddChild(m_FlattenCurves);
m_channel_g.Checked = true;
m_sl = new ScanlineCachePacked8();
StyledTypeFace typeFaceForLargeA = new StyledTypeFace(LiberationSansFont.Instance, 300, flatenCurves: false);
m_path = typeFaceForLargeA.GetGlyphForCharacter('a');
Affine shape_mtx = Affine.NewIdentity();
shape_mtx *= Affine.NewTranslation(150, 100);
m_path = new VertexSourceApplyTransform(m_path, shape_mtx);
m_shape = new FlattenCurves(m_path);
bounding_rect.bounding_rect_single(m_shape, 0, ref m_shape_bounds);
m_shadow_ctrl.SetXN(0, m_shape_bounds.Left);
m_shadow_ctrl.SetYN(0, m_shape_bounds.Bottom);
m_shadow_ctrl.SetXN(1, m_shape_bounds.Right);
m_shadow_ctrl.SetYN(1, m_shape_bounds.Bottom);
m_shadow_ctrl.SetXN(2, m_shape_bounds.Right);
m_shadow_ctrl.SetYN(2, m_shape_bounds.Top);
m_shadow_ctrl.SetXN(3, m_shape_bounds.Left);
m_shadow_ctrl.SetYN(3, m_shape_bounds.Top);
m_shadow_ctrl.line_color(new ColorF(0, 0.3, 0.5, 0.3));
}
private unsafe void generate_alpha_mask(int cx, int cy)
{
alphaByteArray = new byte[cx * cy];
{
#if USE_CLIPPING_ALPHA_MASK
alphaMaskImageBuffer.AttachBuffer(alphaByteArray, 20 * cx + 20, cx - 40, cy - 40, cx, 8, 1);
#else
alphaMaskImageBuffer.attach(alphaByteArray, (int)cx, (int)cy, cx, 1);
#endif
ImageBuffer image = new ImageBuffer();
image.Attach(alphaMaskImageBuffer, new blender_gray(1), 1, 0, 8);
ImageClippingProxy clippingProxy = new ImageClippingProxy(image);
ScanlineCachePacked8 sl = new ScanlineCachePacked8();
clippingProxy.clear(new ColorF(0));
VertexSource.Ellipse ellipseForMask = new MatterHackers.Agg.VertexSource.Ellipse();
System.Random randGenerator = new Random(1432);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
int i;
int num = (int)numMasksSlider.Value;
for (i = 0; i < num; i++)
{
if (i == num - 1)
{
ellipseForMask.init(Width / 2, Height / 2, 110, 110, 100);
rasterizer.add_path(ellipseForMask);
scanlineRenderer.RenderSolid(clippingProxy, rasterizer, sl, new Color(0, 0, 0, 255));
ellipseForMask.init(ellipseForMask.originX, ellipseForMask.originY, ellipseForMask.radiusX - 10, ellipseForMask.radiusY - 10, 100);
rasterizer.add_path(ellipseForMask);
scanlineRenderer.RenderSolid(clippingProxy, rasterizer, sl, new Color(255, 0, 0, 255));
}
else
{
ellipseForMask.init(randGenerator.Next() % cx,
randGenerator.Next() % cy,
randGenerator.Next() % 100 + 20,
randGenerator.Next() % 100 + 20,
100);
// set the color to draw into the alpha channel.
// there is not very much reason to set the alpha as you will get the amount of
// transparency based on the color you draw. (you might want some type of different edeg effect but it will be minor).
rasterizer.add_path(ellipseForMask);
scanlineRenderer.RenderSolid(clippingProxy, rasterizer, sl, new Color((int)((float)i / (float)num * 255), 0, 0, 255));
}
}
alphaMaskImageBuffer.DettachBuffer();
}
}
private void DrawBigA(Graphics2D graphics2D)
{
ScanlineRasterizer m_ras = new ScanlineRasterizer();
m_ras.SetVectorClipBox(0, 0, Width, Height);
TypeFacePrinter bigAPrinter = new TypeFacePrinter("a", 150);
FlattenCurves flattenedBigA = new FlattenCurves(bigAPrinter);
VertexSourceApplyTransform scaleAndTranslate = new VertexSourceApplyTransform(flattenedBigA, Affine.NewTranslation(155, 55));
ScanlineCachePacked8 m_sl = new ScanlineCachePacked8();
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
#if false
ImageProxySubpxelLcd24 clippingProxy = new ImageProxySubpxelLcd24(graphics2D.DestImage, new lcd_distribution_lut());
VertexSourceApplyTransform scaledWide = new VertexSourceApplyTransform(scaleAndTranslate, Affine.NewScaling(3, 1));
m_ras.add_path(scaledWide);
scanlineRenderer.render_scanlines_aa_solid(clippingProxy, m_ras, m_sl, RGBA_Bytes.Black);
#else
m_ras.add_path(scaleAndTranslate);
ImageClippingProxy clippingProxy = new ImageClippingProxy(graphics2D.DestImage);
scanlineRenderer.RenderSolid(clippingProxy, m_ras, m_sl, RGBA_Bytes.Black);
#endif
}
public override void OnDraw(Graphics2D graphics2D)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
if (orignialSize.x == 0)
{
orignialSize.x = WindowSize.x;
orignialSize.y = WindowSize.y;
}
ImageBuffer destImageWithPreMultBlender = new ImageBuffer();
switch (widgetsSubImage.BitDepth)
{
case 24:
destImageWithPreMultBlender.Attach(widgetsSubImage, new BlenderPreMultBGR());
break;
case 32:
destImageWithPreMultBlender.Attach(widgetsSubImage, new BlenderPreMultBGRA());
break;
default:
throw new Exception("Unknown bit depth");
}
ImageClippingProxy clippingProxy_pre = new ImageClippingProxy(destImageWithPreMultBlender);
clippingProxy_pre.clear(new RGBA_Floats(1.0, 1.0, 1.0));
Affine src_mtx = Affine.NewIdentity();
src_mtx *= Affine.NewTranslation(-orignialSize.x / 2 - 10, -orignialSize.y / 2 - 20 - 10);
src_mtx *= Affine.NewRotation(drawAngle.Value * Math.PI / 180.0);
src_mtx *= Affine.NewScaling(drawScale.Value);
src_mtx *= Affine.NewTranslation(orignialSize.x / 2, orignialSize.y / 2 + 20);
Affine img_mtx = Affine.NewIdentity();
img_mtx *= Affine.NewTranslation(-orignialSize.x / 2 + 10, -orignialSize.y / 2 + 20 + 10);
img_mtx *= Affine.NewRotation(drawAngle.Value * Math.PI / 180.0);
img_mtx *= Affine.NewScaling(drawScale.Value);
img_mtx *= Affine.NewTranslation(orignialSize.x / 2, orignialSize.y / 2 + 20);
img_mtx.invert();
MatterHackers.Agg.span_allocator sa = new span_allocator();
span_interpolator_linear interpolator = new span_interpolator_linear(img_mtx);
span_image_filter sg;
switch (sourceImage.BitDepth)
{
case 24:
{
ImageBufferAccessorClip source = new ImageBufferAccessorClip(sourceImage, RGBA_Floats.rgba_pre(0, 0, 0, 0).GetAsRGBA_Bytes());
sg = new span_image_filter_rgb_bilinear_clip(source, RGBA_Floats.rgba_pre(0, 0.4, 0, 0.5), interpolator);
}
break;
case 32:
{
ImageBufferAccessorClip source = new ImageBufferAccessorClip(sourceImage, RGBA_Floats.rgba_pre(0, 0, 0, 0).GetAsRGBA_Bytes());
sg = new span_image_filter_rgba_bilinear_clip(source, RGBA_Floats.rgba_pre(0, 0.4, 0, 0.5), interpolator);
}
break;
default:
throw new Exception("Bad sourc depth");
}
ScanlineRasterizer ras = new ScanlineRasterizer();
ras.SetVectorClipBox(0, 0, Width, Height);
ScanlineCachePacked8 sl = new ScanlineCachePacked8();
//scanline_unpacked_8 sl = new scanline_unpacked_8();
double r = orignialSize.x;
if (orignialSize.y - 60 < r)
{
r = orignialSize.y - 60;
}
VertexSource.Ellipse ell = new VertexSource.Ellipse(orignialSize.x / 2.0 + 10,
orignialSize.y / 2.0 + 20 + 10,
r / 2.0 + 16.0,
r / 2.0 + 16.0, 200);
VertexSourceApplyTransform tr = new VertexSourceApplyTransform(ell, src_mtx);
ras.add_path(tr);
//clippingProxy_pre.SetClippingBox(30, 0, (int)width(), (int)height());
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.GenerateAndRender(ras, sl, clippingProxy_pre, sa, sg);
if (false) // this is test code to check different quality settings for scalling
{
Vector2 screenCenter = new Vector2(Width / 2, Height / 2);
Vector2 deltaToMouse = mousePosition - screenCenter;
double angleToMouse = Math.Atan2(deltaToMouse.y, deltaToMouse.x);
double diagonalSize = Math.Sqrt(sourceImage.Width * sourceImage.Width + sourceImage.Height * sourceImage.Height);
double distToMouse = deltaToMouse.Length;
double scalling = distToMouse / diagonalSize;
graphics2D.Render(sourceImage, Width / 2, Height / 2, angleToMouse - MathHelper.Tau / 8, scalling, scalling);
}
base.OnDraw(graphics2D);
}
public override void OnDraw(Graphics2D graphics2D)
{
if (graphics2D.DestImage != null)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
IImageByte backBuffer = widgetsSubImage;
int distBetween = backBuffer.GetBytesBetweenPixelsInclusive();
ImageBuffer redImageBuffer = new ImageBuffer();
redImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 2, 8);
ImageBuffer greenImageBuffer = new ImageBuffer();
greenImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 1, 8);
ImageBuffer blueImageBuffer = new ImageBuffer();
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 MatterHackers.Agg.VertexSource.Ellipse(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
ras.add_path(er);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.RenderSolid(clippingProxyRed, ras, sl, FillColor);
VertexSource.Ellipse eg = new MatterHackers.Agg.VertexSource.Ellipse(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
ras.add_path(eg);
scanlineRenderer.RenderSolid(clippingProxyGreen, ras, sl, FillColor);
VertexSource.Ellipse eb = new MatterHackers.Agg.VertexSource.Ellipse(Width / 2, Height / 2 + 50, 100, 100, 100);
ras.add_path(eb);
scanlineRenderer.RenderSolid(clippingProxyBlue, ras, sl, 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
}
base.OnDraw(graphics2D);
}
public image_filters()
: base(FlowDirection.BottomToTop)
{
m_step = new Slider(new Vector2(115, 5), new Vector2(285, 6));
m_radius = new Slider(new Vector2(115, 5 + 15), new Vector2(285, 6));
filterSelectionButtons = new RadioButtonGroup(new Vector2(0.0, 10.0), new Vector2(110.0, 210.0));
m_normalize = new CheckBox(8.0, 215.0, "Normalize Filter");
m_refresh = new Button(8.0, 273.0, new ButtonViewText("Refresh", 8, 1, 3));
m_refresh.Click += RefreshImage;
m_run = new Button(8.0, 253.0, new ButtonViewText("RUN Test!", 8, 1, 3));
m_run.Click += RunTest;
m_single_step = new Button(8.0, 233.0, new ButtonViewText("Single Step", 8, 1, 3));
m_single_step.Click += SingleStep;
m_cur_angle = (0.0);
m_cur_filter = (1);
m_num_steps = (0);
m_num_pix = (0.0);
m_time1 = (0);
m_time2 = (0);
m_ScanlinePacked = new ScanlineCachePacked8();
m_Rasterizer = new ScanlineRasterizer();
m_ScanlineUnpacked = new scanline_unpacked_8();
m_SpanAllocator = new span_allocator();
AddChild(m_radius);
AddChild(m_step);
AddChild(filterSelectionButtons);
AddChild(m_run);
AddChild(m_single_step);
AddChild(m_normalize);
AddChild(m_refresh);
m_normalize.Checked = true;
m_radius.Text = "Filter Radius={0:F2}";
m_step.Text = "Step={0:F2}";
m_radius.SetRange(2.0, 8.0);
m_radius.Value = 4.0;
m_step.SetRange(1.0, 10.0);
m_step.Value = 5.0;
filterSelectionButtons.AddRadioButton("simple (NN)");
filterSelectionButtons.AddRadioButton("bilinear");
filterSelectionButtons.AddRadioButton("bicubic");
filterSelectionButtons.AddRadioButton("spline16");
filterSelectionButtons.AddRadioButton("spline36");
filterSelectionButtons.AddRadioButton("hanning");
filterSelectionButtons.AddRadioButton("hamming");
filterSelectionButtons.AddRadioButton("hermite");
filterSelectionButtons.AddRadioButton("kaiser");
filterSelectionButtons.AddRadioButton("quadric");
filterSelectionButtons.AddRadioButton("catrom");
filterSelectionButtons.AddRadioButton("gaussian");
filterSelectionButtons.AddRadioButton("bessel");
filterSelectionButtons.AddRadioButton("mitchell");
filterSelectionButtons.AddRadioButton("sinc");
filterSelectionButtons.AddRadioButton("lanczos");
filterSelectionButtons.AddRadioButton("blackman");
filterSelectionButtons.SelectedIndex = 1;
filterSelectionButtons.background_color(new ColorF(0.0, 0.0, 0.0, 0.1));
}
public override void OnDraw(Graphics2D graphics2D)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
IImageByte backBuffer = widgetsSubImage;
GammaLookUpTable gamma = new GammaLookUpTable(m_gamma.Value);
IRecieveBlenderByte NormalBlender = new BlenderBGRA();
IRecieveBlenderByte GammaBlender = new BlenderGammaBGRA(gamma);
ImageBuffer rasterNormal = new ImageBuffer();
rasterNormal.Attach(backBuffer, NormalBlender);
ImageBuffer rasterGamma = new ImageBuffer();
rasterGamma.Attach(backBuffer, GammaBlender);
ImageClippingProxy clippingProxyNormal = new ImageClippingProxy(rasterNormal);
ImageClippingProxy clippingProxyGamma = new ImageClippingProxy(rasterGamma);
clippingProxyNormal.clear(m_white_on_black.Checked ? new ColorF(0, 0, 0) : new ColorF(1, 1, 1));
ScanlineRasterizer ras = new ScanlineRasterizer();
ScanlineCachePacked8 sl = new ScanlineCachePacked8();
VertexSource.Ellipse e = new VertexSource.Ellipse();
// TODO: If you drag the control circles below the bottom of the window we get an exception. This does not happen in AGG.
// It needs to be debugged. Turning on clipping fixes it. But standard agg works without clipping. Could be a bigger problem than this.
//ras.clip_box(0, 0, width(), height());
// Render two "control" circles
e.init(m_x[0], m_y[0], 3, 3, 16);
ras.add_path(e);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.RenderSolid(clippingProxyNormal, ras, sl, new Color(127, 127, 127));
e.init(m_x[1], m_y[1], 3, 3, 16);
ras.add_path(e);
scanlineRenderer.RenderSolid(clippingProxyNormal, ras, sl, new Color(127, 127, 127));
double d = m_offset.Value;
// Creating a rounded rectangle
VertexSource.RoundedRect r = new VertexSource.RoundedRect(m_x[0] + d, m_y[0] + d, m_x[1] + d, m_y[1] + d, m_radius.Value);
r.normalize_radius();
// Drawing as an outline
if (!m_DrawAsOutlineCheckBox.Checked)
{
Stroke p = new Stroke(r);
p.width(1.0);
ras.add_path(p);
}
else
{
ras.add_path(r);
}
scanlineRenderer.RenderSolid(clippingProxyGamma, ras, sl, m_white_on_black.Checked ? new Color(255, 255, 255) : new Color(0, 0, 0));
base.OnDraw(graphics2D);
}
public override void OnDraw(Graphics2D graphics2D)
{
GammaLookUpTable gamma = new GammaLookUpTable(m_gamma.Value);
IRecieveBlenderByte NormalBlender = new BlenderBGRA();
IRecieveBlenderByte GammaBlender = new BlenderGammaBGRA(gamma);
ImageBuffer rasterNormal = new ImageBuffer(NewGraphics2D().DestImage, NormalBlender);
ImageBuffer rasterGamma = new ImageBuffer(NewGraphics2D().DestImage, GammaBlender);
ImageClippingProxy clippingProxyNormal = new ImageClippingProxy(rasterNormal);
ImageClippingProxy clippingProxyGamma = new ImageClippingProxy(rasterGamma);
clippingProxyNormal.clear(new ColorF(0, 0, 0));
ScanlineRasterizer ras = new ScanlineRasterizer();
ScanlineCachePacked8 sl = new ScanlineCachePacked8();
VertexSource.Ellipse e = new VertexSource.Ellipse();
// TODO: If you drag the control circles below the bottom of the window we get an exception. This does not happen in AGG.
// It needs to be debugged. Turning on clipping fixes it. But standard agg works without clipping. Could be a bigger problem than this.
//ras.clip_box(0, 0, width(), height());
// Render two "control" circles
e.init(m_x[0], m_y[0], 3, 3, 16);
ras.add_path(e);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.RenderSolid(clippingProxyNormal, ras, sl, new Color(127, 127, 127));
e.init(m_x[1], m_y[1], 3, 3, 16);
ras.add_path(e);
scanlineRenderer.RenderSolid(clippingProxyNormal, ras, sl, new Color(127, 127, 127));
// Creating a rounded rectangle
VertexSource.RoundedRect r = new VertexSource.RoundedRect(m_x[0], m_y[0], m_x[1], m_y[1], 10);
r.normalize_radius();
// Drawing as an outline
Stroke p = new Stroke(r);
p.width(1.0);
ras.add_path(p);
//Renderer.RenderSolid(clippingProxyGamma, ras, sl, new RGBA_Bytes(0, 0, 0));
scanlineRenderer.RenderSolid(clippingProxyGamma, ras, sl, new Color(255, 1, 1));
/*
* int i;
*
* // radial line test
* //-------------------------
* dashed_line<rasterizer_type,
* renderer_scanline_type,
* scanline_type> dash(ras, ren_sl, sl);
*
* double cx = width() / 2.0;
* double cy = height() / 2.0;
*
* ren_sl.color(agg::rgba(1.0, 1.0, 1.0, 0.2));
* for(i = 180; i > 0; i--)
* {
* double n = 2.0 * agg::pi * i / 180.0;
* dash.draw(cx + min(cx, cy) * sin(n), cy + min(cx, cy) * cos(n),
* cx, cy,
* 1.0, (i < 90) ? i : 0.0);
* }
*
* typedef agg::gradient_x gradient_func_type;
* typedef agg::span_interpolator_linear<> interpolator_type;
* typedef agg::span_allocator<color_type> span_allocator_type;
* typedef agg::pod_auto_array<color_type, 256> color_array_type;
* typedef agg::span_gradient<color_type,
* interpolator_type,
* gradient_func_type,
* color_array_type> span_gradient_type;
*
* typedef agg::renderer_scanline_aa<renderer_base_type,
* span_allocator_type,
* span_gradient_type> renderer_gradient_type;
*
* gradient_func_type gradient_func; // The gradient function
* agg::trans_affine gradient_mtx; // Affine transformer
* interpolator_type span_interpolator(gradient_mtx); // Span interpolator
* span_allocator_type span_allocator; // Span Allocator
* color_array_type gradient_colors; // The gradient colors
* span_gradient_type span_gradient(span_interpolator,
* gradient_func,
* gradient_colors,
* 0, 100);
*
* renderer_gradient_type ren_gradient(ren_base, span_allocator, span_gradient);
*
* dashed_line<rasterizer_type,
* renderer_gradient_type,
* scanline_type> dash_gradient(ras, ren_gradient, sl);
*
* double x1, y1, x2, y2;
*
* for(i = 1; i <= 20; i++)
* {
* ren_sl.color(agg::rgba(1,1,1));
*
* // integral point sizes 1..20
* //----------------
* agg::ellipse ell;
*
* ell.init(20 + i * (i + 1) + 0.5,
* 20.5,
* i / 2.0,
* i / 2.0,
* 8 + i);
* ras.reset();
* ras.add_path(ell);
* agg::render_scanlines(ras, sl, ren_sl);
*
* // fractional point sizes 0..2
* //----------------
* ell.init(18 + i * 4 + 0.5, 33 + 0.5,
* i/20.0, i/20.0,
* 8);
* ras.reset();
* ras.add_path(ell);
* agg::render_scanlines(ras, sl, ren_sl);
*
* // fractional point positioning
* //---------------
* ell.init(18 + i * 4 + (i-1) / 10.0 + 0.5,
* 27 + (i - 1) / 10.0 + 0.5,
* 0.5, 0.5, 8);
* ras.reset();
* ras.add_path(ell);
* agg::render_scanlines(ras, sl, ren_sl);
*
* // integral line widths 1..20
* //----------------
* fill_color_array(gradient_colors,
* agg::rgba(1,1,1),
* agg::rgba(i % 2, (i % 3) * 0.5, (i % 5) * 0.25));
*
* x1 = 20 + i* (i + 1);
* y1 = 40.5;
* x2 = 20 + i * (i + 1) + (i - 1) * 4;
* y2 = 100.5;
* calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx);
* dash_gradient.draw(x1, y1, x2, y2, i, 0);
*
* fill_color_array(gradient_colors,
* agg::rgba(1,0,0),
* agg::rgba(0,0,1));
*
* // fractional line lengths H (red/blue)
* //----------------
* x1 = 17.5 + i * 4;
* y1 = 107;
* x2 = 17.5 + i * 4 + i/6.66666667;
* y2 = 107;
* calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx);
* dash_gradient.draw(x1, y1, x2, y2, 1.0, 0);
*
* // fractional line lengths V (red/blue)
* //---------------
* x1 = 18 + i * 4;
* y1 = 112.5;
* x2 = 18 + i * 4;
* y2 = 112.5 + i / 6.66666667;
* calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx);
* dash_gradient.draw(x1, y1, x2, y2, 1.0, 0);
*
* // fractional line positioning (red)
* //---------------
* fill_color_array(gradient_colors,
* agg::rgba(1,0,0),
* agg::rgba(1,1,1));
* x1 = 21.5;
* y1 = 120 + (i - 1) * 3.1;
* x2 = 52.5;
* y2 = 120 + (i - 1) * 3.1;
* calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx);
* dash_gradient.draw(x1, y1, x2, y2, 1.0, 0);
*
* // fractional line width 2..0 (green)
* fill_color_array(gradient_colors,
* agg::rgba(0,1,0),
* agg::rgba(1,1,1));
* x1 = 52.5;
* y1 = 118 + i * 3;
* x2 = 83.5;
* y2 = 118 + i * 3;
* calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx);
* dash_gradient.draw(x1, y1, x2, y2, 2.0 - (i - 1) / 10.0, 0);
*
* // stippled fractional width 2..0 (blue)
* fill_color_array(gradient_colors,
* agg::rgba(0,0,1),
* agg::rgba(1,1,1));
* x1 = 83.5;
* y1 = 119 + i * 3;
* x2 = 114.5;
* y2 = 119 + i * 3;
* calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx);
* dash_gradient.draw(x1, y1, x2, y2, 2.0 - (i - 1) / 10.0, 3.0);
*
* ren_sl.color(agg::rgba(1,1,1));
* if(i <= 10)
* {
* // integral line width, horz aligned (mipmap test)
* //-------------------
* dash.draw(125.5, 119.5 + (i + 2) * (i / 2.0),
* 135.5, 119.5 + (i + 2) * (i / 2.0),
* i, 0.0);
* }
*
* // fractional line width 0..2, 1 px H
* //-----------------
* dash.draw(17.5 + i * 4, 192, 18.5 + i * 4, 192, i / 10.0, 0);
*
* // fractional line positioning, 1 px H
* //-----------------
* dash.draw(17.5 + i * 4 + (i - 1) / 10.0, 186,
* 18.5 + i * 4 + (i - 1) / 10.0, 186,
* 1.0, 0);
* }
*
* // Triangles
* //---------------
* for (int i = 1; i <= 13; i++)
* {
* fill_color_array(gradient_colors,
* agg::rgba(1,1,1),
* agg::rgba(i % 2, (i % 3) * 0.5, (i % 5) * 0.25));
* calc_linear_gradient_transform(width() - 150,
* height() - 20 - i * (i + 1.5),
* width() - 20,
* height() - 20 - i * (i + 1),
* gradient_mtx);
* ras.reset();
* ras.move_to_d(width() - 150, height() - 20 - i * (i + 1.5));
* ras.line_to_d(width() - 20, height() - 20 - i * (i + 1));
* ras.line_to_d(width() - 20, height() - 20 - i * (i + 2));
* agg::render_scanlines(ras, sl, ren_gradient);
* }
*/
base.OnDraw(graphics2D);
}
