public override void OnDraw()
{
#if SourceDepth24
pixfmt_alpha_blend_rgb pf = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr());
#else
FormatRGBA pf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
#endif
FormatClippingProxy ren_base = new FormatClippingProxy(pf);
ren_base.Clear(new RGBA_Doubles(1.0, 1.0, 1.0));
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
#if true
render_gouraud(sl, ras);
#else
agg.span_allocator span_alloc = new span_allocator();
span_gouraud_rgba span_gen = new span_gouraud_rgba(new rgba8(255, 0, 0, 255), new rgba8(0, 255, 0, 255), new rgba8(0, 0, 255, 255), 320, 220, 100, 100, 200, 100, 0);
span_gouraud test_sg = new span_gouraud(new rgba8(0, 0, 0, 255), new rgba8(0, 0, 0, 255), new rgba8(0, 0, 0, 255), 320, 220, 100, 100, 200, 100, 0);
ras.add_path(test_sg);
renderer_scanlines.render_scanlines_aa(ras, sl, ren_base, span_alloc, span_gen);
//renderer_scanlines.render_scanlines_aa_solid(ras, sl, ren_base, new rgba8(0, 0, 0, 255));
#endif
ras.Gamma(new GammaNone());
m_dilation.SetTransform(trans_affine_resizing());
//m_dilation.Render(ras, sl, ren_base);
m_gamma.SetTransform(trans_affine_resizing());
//m_gamma.Render(ras, sl, ren_base);
m_alpha.SetTransform(trans_affine_resizing());
//m_alpha.Render(ras, sl, ren_base);
base.OnDraw();
}
image_resample_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_gamma_lut = new GammaLut(2.0);
m_quad = new AGG.UI.polygon_ctrl <T>(4, 5.0);
m_trans_type = new AGG.UI.rbox_ctrl <T>(400, 5.0, 430 + 170.0, 100.0);
m_gamma = new AGG.UI.SliderWidget <T>(5.0, 5.0 + 15 * 0, 400 - 5, 10.0 + 15 * 0);
m_blur = new AGG.UI.SliderWidget <T>(5.0, 5.0 + 15 * 1, 400 - 5, 10.0 + 15 * 1);
m_old_gamma = M.New <T>(2);
g_rasterizer = new RasterizerScanlineAA <T>();
g_scanline = new ScanlineUnpacked8();
m_trans_type.text_size(7);
m_trans_type.add_item("Affine No Resample");
m_trans_type.add_item("Affine Resample");
m_trans_type.add_item("Perspective No Resample LERP");
m_trans_type.add_item("Perspective No Resample Exact");
m_trans_type.add_item("Perspective Resample LERP");
m_trans_type.add_item("Perspective Resample Exact");
m_trans_type.cur_item(4);
AddChild(m_trans_type);
m_gamma.range(0.5, 3.0);
m_gamma.value(2.0);
m_gamma.label("Gamma={0:F3}");
AddChild(m_gamma);
m_blur.range(0.5, 5.0);
m_blur.value(1.0);
m_blur.label("Blur={0:F3}");
AddChild(m_blur);
}
public override void OnDraw()
{
#if SourceDepth24
pixfmt_alpha_blend_rgb pf = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr());
#else
FormatRGBA pf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pf);
clippingProxy.Clear(new RGBA_Doubles(0, 0, 0));
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
ScanlineBin sl_bin = new ScanlineBin();
RasterizerCompoundAA <T> rasc = new RasterizerCompoundAA <T>();
SpanAllocator alloc = new SpanAllocator();
uint i;
styles_gouraud styles = new styles_gouraud(m_mesh, m_gamma);
start_timer();
rasc.Reset();
//rasc.clip_box(40, 40, width() - 40, height() - 40);
for (i = 0; i < m_mesh.num_edges(); i++)
{
mesh_edge e = m_mesh.edge(i);
mesh_point p1 = m_mesh.vertex(e.p1);
mesh_point p2 = m_mesh.vertex(e.p2);
rasc.Styles(e.tl, e.tr);
rasc.MoveToDbl(p1.x, p1.y);
rasc.LineToDbl(p2.x, p2.y);
}
Renderer <T> .RenderCompound(rasc, sl, sl_bin, clippingProxy, alloc, styles);
double tm = elapsed_time();
GsvText <T> t = new GsvText <T>();
t.SetFontSize(10.0);
ConvStroke <T> pt = new ConvStroke <T>(t);
pt.Width = M.New <T>(1.5);
pt.LineCap = LineCap.Round;
pt.LineJoin = LineJoin.RoundJoin;
string buf = string.Format("{0:F2} ms, {1} triangles, {2:F0} tri/sec",
tm,
m_mesh.num_triangles(),
m_mesh.num_triangles() / tm * 1000.0);
t.StartPoint(10.0, 10.0);
t.Text = buf;
ras.AddPath(pt);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(1, 1, 1).GetAsRGBA_Bytes());
if (m_gamma.Gamma() != 1.0)
{
pf.ApplyGammaInv(m_gamma);
}
}
public override void Draw(Painter p)
{
//specific for agg
if (p is PixelFarm.Agg.AggPainter)
{
var p2 = (PixelFarm.Agg.AggPainter)p;
AggRenderSurface aggsx = p2.RenderSurface;
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
var widgetsSubImage = ImageHelper.CreateSubImgRW(aggsx.DestImage, aggsx.GetClippingRect());
aggsx.UseSubPixelRendering = false;
PixelBlenderBGRA normalBlender = new PixelBlenderBGRA();
PixelBlenderBGRA gammaBlender = new PixelBlenderBGRA(); //TODO: revisit, and fix this again
gammaBlender.GammaValue = this.GammaValue;
gammaBlender.EnableGamma = true;
var rasterGamma = new SubImageRW(widgetsSubImage, gammaBlender);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(widgetsSubImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
int size_mul = (int)this.PixelSize;
CustomScanlineRasToBmp_EnlargedSubPixelRendering ren_en = new CustomScanlineRasToBmp_EnlargedSubPixelRendering(size_mul, aggsx.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
ren_en.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//----------------------------------------
ScanlineRasToDestBitmapRenderer sclineRasToBmp = aggsx.ScanlineRasToDestBitmap;
aggsx.UseSubPixelRendering = false;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
rasterizer.ResetGamma(new GammaNone());
aggsx.UseSubPixelRendering = false;
//----------------------------------------
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
//----------------------------------------
//Stroke stroke = new Stroke(ps);
//stroke.Width = 2;
//rasterizer.AddPath(stroke.MakeVxs(ps.MakeVxs()));
VectorToolBox.GetFreeVxs(out var v1);
rasterizer.AddPath(stroke.MakeVxs(ps.Vxs, v1));
VectorToolBox.ReleaseVxs(ref v1);
//----------------------------------------
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
}
}
public void OnDraw(Graphics2D graphics2D)
{
var widgetsSubImage = ImageHelper.CreateChildImage(graphics2D.DestImage, graphics2D.GetClippingRect());
graphics2D.UseSubPixelRendering = false;
IPixelBlender NormalBlender = new PixelBlenderBGRA();
IPixelBlender GammaBlender = new PixelBlenderGammaBGRA(this.GammaValue);
var rasterGamma = new ChildImage(widgetsSubImage, GammaBlender);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(widgetsSubImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(ColorRGBA.White);
var rasterizer = graphics2D.ScanlineRasterizer;
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
int size_mul = (int)this.PixelSize;
CustomScanlineRasToBmp_EnlargedV3 ren_en = new CustomScanlineRasToBmp_EnlargedV3(size_mul, graphics2D.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
ren_en.RenderWithColor(clippingProxyGamma, rasterizer, sl, ColorRGBA.Black);
//----------------------------------------
ScanlineRasToDestBitmapRenderer sclineRasToBmp = graphics2D.ScanlineRasToDestBitmap;
graphics2D.UseSubPixelRendering = true;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, ColorRGBA.Black);
rasterizer.ResetGamma(new GammaNone());
graphics2D.UseSubPixelRendering = false;
//----------------------------------------
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
//----------------------------------------
//Stroke stroke = new Stroke(ps);
//stroke.Width = 2;
//rasterizer.AddPath(stroke.MakeVxs(ps.MakeVxs()));
rasterizer.AddPath(StrokeHelp.MakeVxs(ps.Vxs, 2));
//----------------------------------------
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new ColorRGBA(0, 150, 160, 200));
}
public override void OnMouseDown(MouseEventArgs mouseEvent)
{
uint i;
if (mouseEvent.Button == MouseButtons.Right)
{
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
start_timer();
for (i = 0; i < 100; i++)
{
render_gouraud(sl, ras);
}
string buf;
buf = "Time=" + elapsed_time().ToString() + "ms";
message(buf);
}
if (mouseEvent.Button == MouseButtons.Left)
{
T x = M.New <T>(mouseEvent.X);
T y = M.New <T>(mouseEvent.Y);
for (i = 0; i < 3; i++)
{
T mdx = x.Subtract(m_x[i]), mdy = y.Subtract(m_y[i]);
if (M.Length(mdx, mdy).LessThan(10.0))
{
m_dx = mdx; // x - m_x[i];
m_dy = mdy; // y - m_y[i];
m_idx = (int)i;
break;
}
}
if (i == 3)
{
if (MathUtil.PointInTriangle(m_x[0], m_y[0],
m_x[1], m_y[1],
m_x[2], m_y[2],
x, y))
{
m_dx = x.Subtract(m_x[0]);
m_dy = y.Subtract(m_y[0]);
m_idx = 3;
}
}
}
base.OnMouseDown(mouseEvent);
}
public override void Draw(CanvasPainter p)
{
//specific for agg
if (p is PixelFarm.Agg.AggCanvasPainter)
{
var p2 = (PixelFarm.Agg.AggCanvasPainter)p;
Graphics2D gx = p2.Graphics;
var widgetsSubImage = ImageHelper.CreateChildImage(gx.DestImage, gx.GetClippingRect());
gx.UseSubPixelRendering = false;
IPixelBlender NormalBlender = new PixelBlenderBGRA();
IPixelBlender GammaBlender = new PixelBlenderGammaBGRA(this.GammaValue);
var rasterGamma = new ChildImage(widgetsSubImage, GammaBlender);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(widgetsSubImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
var rasterizer = gx.ScanlineRasterizer;
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
int size_mul = (int)this.PixelSize;
CustomScanlineRasToBmp_EnlargedSubPixelRendering ren_en = new CustomScanlineRasToBmp_EnlargedSubPixelRendering(size_mul, gx.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
ren_en.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//----------------------------------------
ScanlineRasToDestBitmapRenderer sclineRasToBmp = gx.ScanlineRasToDestBitmap;
gx.UseSubPixelRendering = true;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
rasterizer.ResetGamma(new GammaNone());
gx.UseSubPixelRendering = false;
//----------------------------------------
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
//----------------------------------------
//Stroke stroke = new Stroke(ps);
//stroke.Width = 2;
//rasterizer.AddPath(stroke.MakeVxs(ps.MakeVxs()));
var v1 = GetFreeVxs();
rasterizer.AddPath(stroke.MakeVxs(ps.Vxs, v1));
ReleaseVxs(ref v1);
//----------------------------------------
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
}
}
public void OnDraw(Graphics2D graphics2D)
{
var childImage = ImageHelper.CreateChildImage(graphics2D.DestImage, graphics2D.GetClippingRect());
//IRecieveBlenderByte rasterBlender = new BlenderBGRA();
var rasterGamma = new ChildImage(childImage, new PixelBlenderGammaBGRA(this.GammaValue));
ClipProxyImage clippingProxyNormal = new ClipProxyImage(childImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(ColorRGBA.White);
var rasterizer = graphics2D.ScanlineRasterizer;
var sl = new ScanlineUnpacked8();
int size_mul = this.PixelSize;
CustomScanlineRasToBmp_EnlargedV2 sclineToBmpEn2 = new CustomScanlineRasToBmp_EnlargedV2(size_mul, graphics2D.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
sclineToBmpEn2.RenderWithColor(clippingProxyGamma, rasterizer, sl, ColorRGBA.Black);
ScanlineRasToDestBitmapRenderer sclineRasToBmp = graphics2D.ScanlineRasToDestBitmap;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, ColorRGBA.Black);
//-----------------------------------------------------------------------------------------------------------
rasterizer.ResetGamma(new GammaNone());
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
rasterizer.AddPath((new Stroke(2)).MakeVxs(ps.Vxs));
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new ColorRGBA(0, 150, 160, 200));
}
public override void Draw(Painter p)
{
//this specific for agg
#if DEBUG
//low-level scanline rasterizer example
if (p is AggPainter)
{
AggPainter p2 = (AggPainter)p;
AggRenderSurface aggsx = p2.RenderSurface;
PixelProcessing.SubBitmapBlender subImg = PixelProcessing.BitmapBlenderExtension.CreateSubBitmapBlender(aggsx.DestBitmapBlender, aggsx.GetClippingRect());
//TODO: review here again
PixelBlenderBGRA blenderWithGamma = new PixelProcessing.PixelBlenderBGRA();
SubBitmapBlender rasterGamma = new SubBitmapBlender(subImg, blenderWithGamma);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(subImg);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
var sl = new ScanlineUnpacked8();
int size_mul = this.PixelSize;
var sclineToBmpEn2 = new CustomRas_EnlargeV2(size_mul, aggsx.DestBitmap);
rasterizer.Reset();
rasterizer.dbugDevMoveTo(_x[0] / size_mul, _y[0] / size_mul);
rasterizer.dbugDevLineTo(_x[1] / size_mul, _y[1] / size_mul);
rasterizer.dbugDevLineTo(_x[2] / size_mul, _y[2] / size_mul);
sclineToBmpEn2.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
DestBitmapRasterizer bmpRas = aggsx.BitmapRasterizer;
bmpRas.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//-----------------------------------------------------------------------------------------------------------
rasterizer.ResetGamma(new GammaNone());
using (Tools.BorrowVxs(out var v1, out var v2))
using (Tools.BorrowPathWriter(v1, out PathWriter ps))
{
ps.Clear();
ps.MoveTo(_x[0], _y[0]);
ps.LineTo(_x[1], _y[1]);
ps.LineTo(_x[2], _y[2]);
ps.LineTo(_x[0], _y[0]);
rasterizer.AddPath((new Stroke(2)).MakeVxs(v1, v2));
bmpRas.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
}
}
#endif
}
public override void Draw(Painter p)
{
//this specific for agg
if (p is AggPainter)
{
AggPainter p2 = (AggPainter)p;
AggRenderSurface aggsx = p2.RenderSurface;
SubImageRW subImg = ImageHelper.CreateSubImgRW(aggsx.DestImage, aggsx.GetClippingRect());
//TODO: review here again
PixelBlenderBGRA blenderWithGamma = new PixelBlenderBGRA();
SubImageRW rasterGamma = new SubImageRW(subImg, blenderWithGamma);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(subImg);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
var sl = new ScanlineUnpacked8();
int size_mul = this.PixelSize;
var sclineToBmpEn2 = new CustomScanlineRasToBmp_EnlargedV2(size_mul, aggsx.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
sclineToBmpEn2.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
ScanlineRasToDestBitmapRenderer sclineRasToBmp = aggsx.ScanlineRasToDestBitmap;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//-----------------------------------------------------------------------------------------------------------
rasterizer.ResetGamma(new GammaNone());
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
VectorToolBox.GetFreeVxs(out var v1);
rasterizer.AddPath((new Stroke(2)).MakeVxs(ps.Vxs, v1));
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
VectorToolBox.ReleaseVxs(ref v1);
}
}
public override void Draw(CanvasPainter p)
{
//this specific for agg
if (p is PixelFarm.Agg.AggCanvasPainter)
{
PixelFarm.Agg.AggCanvasPainter p2 = (PixelFarm.Agg.AggCanvasPainter)p;
Graphics2D gx = p2.Graphics;
var childImage = ImageHelper.CreateChildImage(gx.DestImage, gx.GetClippingRect());
//IRecieveBlenderByte rasterBlender = new BlenderBGRA();
var rasterGamma = new ChildImage(childImage, new PixelBlenderGammaBGRA(this.GammaValue));
ClipProxyImage clippingProxyNormal = new ClipProxyImage(childImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
var rasterizer = gx.ScanlineRasterizer;
var sl = new ScanlineUnpacked8();
int size_mul = this.PixelSize;
var sclineToBmpEn2 = new CustomScanlineRasToBmp_EnlargedV2(size_mul, gx.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
sclineToBmpEn2.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
ScanlineRasToDestBitmapRenderer sclineRasToBmp = gx.ScanlineRasToDestBitmap;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//-----------------------------------------------------------------------------------------------------------
rasterizer.ResetGamma(new GammaNone());
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
var v1 = GetFreeVxs();
rasterizer.AddPath((new Stroke(2)).MakeVxs(ps.Vxs, v1));
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
ReleaseVxs(ref v1);
}
}
image_filters_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_step = new SliderWidget <T>(115, 5, 400, 11);
m_radius = new SliderWidget <T>(115, 5 + 15, 400, 11 + 15);
m_filters = new rbox_ctrl <T>(0.0, 0.0, 110.0, 210.0);
m_normalize = new cbox_ctrl <T>(8.0, 215.0, "Normalize Filter");
m_refresh = new ButtonWidget <T>(8.0, 273.0, "Refresh", 8, 1, 1, 3);
m_refresh.ButtonClick += RefreshImage;
m_run = new ButtonWidget <T>(8.0, 253.0, "RUN Test!", 8, 1, 1, 3);
m_run.ButtonClick += RunTest;
m_single_step = new ButtonWidget <T>(8.0, 233.0, "Single Step", 8, 1, 1, 3);
m_single_step.ButtonClick += 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 ScanlinePacked8();
m_Rasterizer = new RasterizerScanlineAA <T>();
m_ScanlineUnpacked = new ScanlineUnpacked8();
m_SpanAllocator = new SpanAllocator();
AddChild(m_radius);
AddChild(m_step);
AddChild(m_filters);
AddChild(m_run);
AddChild(m_single_step);
AddChild(m_normalize);
AddChild(m_refresh);
//m_single_step.text_size(7.5);
m_normalize.SetFontSize(7.5);
m_normalize.status(true);
m_radius.label("Filter Radius={0:F2}");
m_step.label("Step={0:F2}");
m_radius.range(2.0, 8.0);
m_radius.value(4.0);
m_step.range(1.0, 10.0);
m_step.value(5.0);
m_filters.add_item("simple (NN)");
m_filters.add_item("bilinear");
m_filters.add_item("bicubic");
m_filters.add_item("spline16");
m_filters.add_item("spline36");
m_filters.add_item("hanning");
m_filters.add_item("hamming");
m_filters.add_item("hermite");
m_filters.add_item("kaiser");
m_filters.add_item("quadric");
m_filters.add_item("catrom");
m_filters.add_item("gaussian");
m_filters.add_item("bessel");
m_filters.add_item("mitchell");
m_filters.add_item("sinc");
m_filters.add_item("lanczos");
m_filters.add_item("blackman");
m_filters.cur_item(1);
m_filters.border_width(0, 0);
m_filters.background_color(new RGBA_Doubles(0.0, 0.0, 0.0, 0.1));
m_filters.text_size(6.0);
m_filters.text_thickness(0.85);
}
public override void OnDraw()
{
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
#if SourceDepth24
FormatRGB pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
#else
FormatRGBA pixf = new FormatRGBA(rbuf_window(), new blender_bgra32());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(0, 0, 0));
m_profile.text_size(8.0);
//m_profile.Render(ras, sl, clippingProxy);
//m_spline_r.Render(ras, sl, clippingProxy);
//m_spline_g.Render(ras, sl, clippingProxy);
//m_spline_b.Render(ras, sl, clippingProxy);
//m_spline_a.Render(ras, sl, clippingProxy);
//m_GradTypeRBox.Render(ras, sl, clippingProxy);
//m_GradWrapRBox.Render(ras, sl, clippingProxy);
// draw a background to show how the alpha is working
int RectWidth = 32;
int xoffset = 238;
int yoffset = 171;
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 7; j++)
{
if ((i + j) % 2 != 0)
{
VertexSource.RoundedRect <T> rect = new VertexSource.RoundedRect <T>(i * RectWidth + xoffset, j * RectWidth + yoffset,
(i + 1) * RectWidth + xoffset, (j + 1) * RectWidth + yoffset, 2);
rect.NormalizeRadius();
// Drawing as an outline
ras.AddPath(rect);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(.9, .9, .9));
}
}
}
double ini_scale = 1.0;
IAffineTransformMatrix <T> mtx1 = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx1.Scale(MatrixFactory <T> .CreateVector2D(ini_scale, ini_scale));
mtx1.Translate(MatrixFactory <T> .CreateVector2D(center_x, center_y));
mtx1.Add(trans_affine_resizing());
VertexSource.Ellipse <T> e1 = new AGG.VertexSource.Ellipse <T>();
e1.Init(0.0, 0.0, 110.0, 110.0, 64);
IAffineTransformMatrix <T> mtx_g1 = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(ini_scale, ini_scale));
mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(m_SaveData.m_scale, m_SaveData.m_scale));
mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(m_scale_x, m_scale_y));
mtx_g1.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_SaveData.m_angle.ToDouble());
mtx_g1.Translate(MatrixFactory <T> .CreateVector2D(m_SaveData.m_center_x, m_SaveData.m_center_y));
mtx_g1.Add(trans_affine_resizing());
mtx_g1 = mtx_g1.Inverse;
RGBA_Bytes[] color_profile = new RGBA_Bytes[256]; // color_type is defined in pixel_formats.h
for (int i = 0; i < 256; i++)
{
color_profile[i] = new RGBA_Bytes(m_spline_r.spline()[i].ToInt(),
m_spline_g.spline()[i].ToInt(),
m_spline_b.spline()[i].ToInt(),
m_spline_a.spline()[i].ToInt());
}
ConvTransform <T> t1 = new ConvTransform <T>(e1, mtx1);
IGradient innerGradient = null;
switch (m_GradTypeRBox.cur_item())
{
case 0:
innerGradient = new GradientRadial();
break;
case 1:
innerGradient = new GradientDiamond();
break;
case 2:
innerGradient = new GradientX();
break;
case 3:
innerGradient = new GradientXY();
break;
case 4:
innerGradient = new GradientSqrtXY();
break;
case 5:
innerGradient = new GradientConic();
break;
}
IGradient outerGradient = null;
switch (m_GradWrapRBox.cur_item())
{
case 0:
outerGradient = new GradientReflectAdaptor(innerGradient);
break;
case 1:
outerGradient = new GradientRepeatAdaptor(innerGradient);
break;
case 2:
outerGradient = new GradientClampAdaptor(innerGradient);
break;
}
SpanAllocator span_alloc = new SpanAllocator();
ColorFunctionProfile colors = new ColorFunctionProfile(color_profile, m_profile.gamma());
SpanInterpolatorLinear <T> inter = new SpanInterpolatorLinear <T>(mtx_g1);
SpanGradient <T> span_gen = new SpanGradient <T>(inter, outerGradient, colors, 0, 150);
ras.AddPath(t1);
Renderer <T> .GenerateAndRender(ras, sl, clippingProxy, span_alloc, span_gen);
base.OnDraw();
}
public override void Draw(Painter p)
{
//specific for agg
#if DEBUG
//low-level scanline rasterizer example
if (p is PixelFarm.CpuBlit.AggPainter p2)
{
AggRenderSurface aggsx = p2.RenderSurface;
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
var widgetsSubImage = PixelProcessing.BitmapBlenderExtension.CreateSubBitmapBlender(aggsx.DestBitmapBlender, aggsx.GetClippingRect());
aggsx.UseSubPixelLcdEffect = false;
PixelProcessing.PixelBlenderBGRA normalBlender = new PixelProcessing.PixelBlenderBGRA();
PixelProcessing.PixelBlenderBGRA gammaBlender = new PixelProcessing.PixelBlenderBGRA(); //TODO: revisit, and fix this again
gammaBlender.GammaValue = this.GammaValue;
gammaBlender.EnableGamma = true;
var rasterGamma = new PixelProcessing.SubBitmapBlender(widgetsSubImage, gammaBlender);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(widgetsSubImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
int size_mul = (int)this.PixelSize;
CustomScanlineRasToBmp_EnlargedSubPixelRendering ren_en = new CustomScanlineRasToBmp_EnlargedSubPixelRendering(size_mul, aggsx.DestBitmap);
rasterizer.Reset();
rasterizer.dbugDevMoveTo(_x[0] / size_mul, _y[0] / size_mul);
rasterizer.dbugDevLineTo(_x[1] / size_mul, _y[1] / size_mul);
rasterizer.dbugDevLineTo(_x[2] / size_mul, _y[2] / size_mul);
ren_en.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//----------------------------------------
DestBitmapRasterizer sclineRasToBmp = aggsx.BitmapRasterizer;
aggsx.UseSubPixelLcdEffect = false;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
rasterizer.ResetGamma(new GammaNone());
aggsx.UseSubPixelLcdEffect = false;
//----------------------------------------
using (Tools.BorrowVxs(out var v1, out var v2))
using (Tools.BorrowPathWriter(v1, out PathWriter ps))
{
ps.Clear();
ps.MoveTo(_x[0], _y[0]);
ps.LineTo(_x[1], _y[1]);
ps.LineTo(_x[2], _y[2]);
ps.LineTo(_x[0], _y[0]);
rasterizer.AddPath(_stroke.MakeVxs(v1, v2));
}
//----------------------------------------
//Stroke stroke = new Stroke(ps);
//stroke.Width = 2;
//rasterizer.AddPath(stroke.MakeVxs(ps.MakeVxs()));
//----------------------------------------
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
}
#endif
}
public override void OnDraw()
{
//typedef agg::renderer_base<pixfmt> renderer_base;
//typedef agg::renderer_base<pixfmt_pre> renderer_base_pre;
#if SourceDepth24
pixfmt_alpha_blend_rgb pixf = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr());
pixfmt_alpha_blend_rgb pixf_pre = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr_pre());
#else
FormatRGBA pixf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
FormatRGBA pixf_pre = new FormatRGBA(rbuf_window(), new BlenderPreMultBGRA());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
FormatClippingProxy clippingProxy_pre = new FormatClippingProxy(pixf_pre);
clippingProxy.Clear(new RGBA_Doubles(1.0, 1.0, 1.0));
IAffineTransformMatrix <T> src_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Negative().Divide(2).Subtract(10), initial_height().Negative().Divide(2).Subtract(30)));
src_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_angle.value().Multiply(Math.PI / 180.0).ToDouble());
src_mtx.Scale(m_scale.value());
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Divide(2), initial_height().Divide(2).Add(20)));
src_mtx.Multiply(trans_affine_resizing());
IAffineTransformMatrix <T> img_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
img_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Negative().Divide(2).Add(10), initial_height().Negative().Divide(2).Add(30)));
img_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_angle.value().Multiply(Math.PI / 180.0).ToDouble());
img_mtx.Scale(m_scale.value());
img_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Divide(2), initial_height().Divide(2).Add(20)));
img_mtx.Multiply(trans_affine_resizing());
img_mtx = img_mtx.Inverse;
AGG.SpanAllocator sa = new SpanAllocator();
SpanInterpolatorLinear <T> interpolator = new SpanInterpolatorLinear <T>(img_mtx);
#if SourceDepth24
pixfmt_alpha_blend_rgb img_pixf = new pixfmt_alpha_blend_rgb(rbuf_img(0), new blender_bgr());
#else
FormatRGBA img_pixf = new FormatRGBA(rbuf_img(0), new BlenderBGRA());
#endif
#if SourceDepth24
span_image_filter_rgb_bilinear_clip sg;
sg = new span_image_filter_rgb_bilinear_clip(img_pixf, rgba.rgba_pre(0, 0.4, 0, 0.5), interpolator);
#else
SpanImageFilterRgbaBilinearClip <T> sg;
RasterBufferAccessorClip source = new RasterBufferAccessorClip(img_pixf, RGBA_Doubles.RgbaPre(0, 0, 0, 0));
sg = new SpanImageFilterRgbaBilinearClip <T>(source, RGBA_Doubles.RgbaPre(0, 0.4, 0, 0.5), interpolator);
#endif
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ras.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), width(), height());
//agg.scanline_packed_8 sl = new scanline_packed_8();
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
T r = initial_width();
if (initial_height().Subtract(60).LessThan(r))
{
r = initial_height().Subtract(60);
}
Ellipse <T> ell = new Ellipse <T>(initial_width().Divide(2.0).Add(10),
initial_height().Divide(2.0).Add(30),
r.Divide(2.0).Add(16.0),
r.Divide(2.0).Add(16.0), 200);
ConvTransform <T> tr = new ConvTransform <T>(ell, src_mtx);
ras.AddPath(tr);
#if use_timers
for (uint j = 0; j < 10; j++)
{
Renderer.GenerateAndRender(ras, sl, clippingProxy_pre, sa, sg);
}
AllTimer.Start();
image1_100_Times.Start();
for (uint i = 0; i < 500; i++)
{
#endif
//clippingProxy_pre.SetClippingBox(30, 0, (int)width(), (int)height());
//clippingProxy.SetClippingBox(30, 0, (int)width(), (int)height());
Renderer <T> .GenerateAndRender(ras, sl, clippingProxy_pre, sa, sg);
#if use_timers
}
image1_100_Times.Stop();
#endif
//m_angle.SetTransform(trans_affine_resizing());
//m_scale.SetTransform(trans_affine_resizing());
#if use_timers
AllTimer.Stop();
CExecutionTimer.Instance.AppendResultsToFile("TimingTest.txt", AllTimer.GetTotalSeconds());
CExecutionTimer.Instance.Reset();
#endif
base.OnDraw();
}
