public gamma_ctrl_impl(T x1, T y1, T x2, T y2)
:
base(x1, y1, x2, y2)
{
m_border_width = M.New <T>(2.0);
m_border_extra = M.New <T>(0.0);
m_curve_width = M.New <T>(2.0);
m_grid_width = M.New <T>(0.2);
m_text_thickness = M.New <T>(1.5);
m_point_size = M.New <T>(5.0);
m_text_height = M.New <T>(9.0);
m_xc1 = (x1);
m_yc1 = (y1);
m_xc2 = (x2);
m_yc2 = y2.Subtract(m_text_height.Multiply(2.0));
m_xt1 = (x1);
m_yt1 = y2.Subtract(m_text_height.Multiply(2.0));
m_xt2 = (x2);
m_yt2 = (y2);
m_curve_poly = new ConvStroke <T>(m_gamma_spline);
m_text_poly = new ConvStroke <T>(m_text);
m_idx = (0);
m_vertex = (0);
m_p1_active = (true);
m_mouse_point = (0);
m_pdx = M.New <T>(0.0);
m_pdy = M.New <T>(0.0);
calc_spline_box();
}
public override void OnDraw()
{
if (m_Selecting)
{
IVector <T> selectPosition = m_TextWidget.GetOffsetLeftOfCharacterIndex(m_SelectionIndexToStartBefore);
IVector <T> screenSelectStart = selectPosition;
screenSelectStart[0].AddEquals(2);
IVector <T> screenSelectEnd = MatrixFactory <T> .CreateVector2D(screenSelectStart[0], screenSelectStart[1].Add(Bounds.Height));
PointToScreen(ref screenSelectStart);
PointToScreen(ref screenSelectEnd);
GetRenderer().Line(screenSelectStart, screenSelectEnd, new RGBA_Bytes(0, 1.0, 0));
}
base.OnDraw();
RectDouble <T> boundsPlusPoint5 = Bounds;
boundsPlusPoint5.Inflate(M.New <T>(.5));
RoundedRect <T> borderRect = new RoundedRect <T>(boundsPlusPoint5, M.Zero <T>());
ConvStroke <T> borderLine = new ConvStroke <T>(borderRect);
GetRenderer().Render(borderLine, new RGBA_Bytes(0, 0, 0));
IVector <T> screenStart = m_BarPosition;
screenStart[0].AddEquals(2);
IVector <T> screenEnd = MatrixFactory <T> .CreateVector2D(screenStart[0], screenStart[1].Add(Bounds.Height));
PointToScreen(ref screenStart);
PointToScreen(ref screenEnd);
GetRenderer().Line(screenStart, screenEnd, new RGBA_Bytes(0, 0, 1.0));
}
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 SliderWidget(T x1, T y1, T x2, T y2)
: base(x1, y1, x2, y2)
{
m_border_width = M.One <T>();
m_border_extra = y2.Subtract(y1).Divide(2);
m_text_thickness = M.One <T>();
m_pdx = M.Zero <T>();
m_mouse_move = false;
m_value = M.New <T>(0.5);
m_preview_value = M.New <T>(0.5);
m_min = M.Zero <T>();
m_max = M.One <T>();
m_num_steps = (0);
m_descending = (false);
m_ellipse = new Ellipse <T>();
m_storage = new PathStorage <T>();
m_text = new GsvText <T>();
m_text_poly = new ConvStroke <T>(m_text);
calc_box();
m_background_color = (new RGBA_Doubles(1.0, 0.9, 0.8));
m_triangle_color = (new RGBA_Doubles(0.7, 0.6, 0.6));
m_text_color = (new RGBA_Doubles(0.0, 0.0, 0.0));
m_pointer_preview_color = (new RGBA_Doubles(0.6, 0.4, 0.4, 0.4));
m_pointer_color = (new RGBA_Doubles(0.8, 0.0, 0.0, 0.6));
}
public void Line(T x1, T y1, T x2, T y2, RGBA_Bytes color)
{
PathStorage <T> m_LinesToDraw = new PathStorage <T>();
m_LinesToDraw.RemoveAll();
m_LinesToDraw.MoveTo(x1, y1);
m_LinesToDraw.LineTo(x2, y2);
ConvStroke <T> StrockedLineToDraw = new ConvStroke <T>(m_LinesToDraw);
Render(StrockedLineToDraw, color);
}
public spline_ctrl_impl(T x1, T y1, T x2, T y2,
uint num_pnt)
: base(x1, y1, x2, y2)
{
m_curve_pnt = new PathStorage <T>();
m_curve_poly = new ConvStroke <T>(m_curve_pnt);
m_ellipse = new Ellipse <T>();
m_num_pnt = (num_pnt);
m_border_width = M.One <T>();
m_border_extra = M.Zero <T>();
m_curve_width = M.One <T>();
m_point_size = M.New <T>(3.0);
m_curve_poly = new ConvStroke <T>(m_curve_pnt);
m_idx = (0);
m_vertex = (0);
m_active_pnt = (-1);
m_move_pnt = (-1);
m_pdx = M.Zero <T>();
m_pdy = M.Zero <T>();
if (m_num_pnt < 4)
{
m_num_pnt = 4;
}
if (m_num_pnt > 32)
{
m_num_pnt = 32;
}
for (int i = 0; i < m_num_pnt; i++)
{
m_xp[i] = M.New <T>(i).Divide(m_num_pnt - 1);
m_yp[i] = M.New <T>(0.5);
}
calc_spline_box();
update_spline();
{
m_spline.Init((int)m_num_pnt, m_xp, m_yp);
for (int i = 0; i < 256; i++)
{
m_spline_values[i] = m_spline.Get(M.New <T>(i).Divide(255.0));
if (m_spline_values[i].LessThan(0.0))
{
m_spline_values[i] = M.Zero <T>();
}
if (m_spline_values[i].GreaterThan(1.0))
{
m_spline_values[i] = M.One <T>();
}
m_spline_values8[i] = (byte)(m_spline_values[i].ToDouble() * 255.0);
}
}
}
public cbox_ctrl(T x, T y, string label)
: base(x, y, x.Add(9.0 * 1.5), y.Add(9.0 * 1.5))
{
m_text_thickness = M.New <T>(1.5);
m_FontSize = M.New <T>(9.0);
m_status = (false);
m_text = new GsvText <T>();
m_text_poly = new ConvStroke <T>(m_text);
m_label = label;
m_text_color = new RGBA_Doubles(0.0, 0.0, 0.0);
m_inactive_color = new RGBA_Doubles(0.0, 0.0, 0.0);
m_active_color = new RGBA_Doubles(0.4, 0.0, 0.0);
}
public override void OnDraw()
{
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
IPixelFormat pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
IAffineTransformMatrix <T> mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
mtx.Scale(g_scale);
mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), g_angle.Add(Math.PI).ToDouble());
mtx.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2, height / 2));
if (m_scanline.status())
{
g_rasterizer.SetVectorClipBox(0, 0, width, height);
ConvStroke <T> stroke = new ConvStroke <T>(g_path);
stroke.Width = m_width_slider.value();
stroke.LineJoin = LineJoin.RoundJoin;
ConvTransform <T> trans = new ConvTransform <T>(stroke, mtx);
Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
}
else
{
/*
* double w = m_width_slider.Value() * mtx.scale();
*
* line_profile_aa profile = new line_profile_aa(w, new gamma_none());
* renderer_outline_aa ren = new renderer_outline_aa(rb, profile);
* rasterizer_outline_aa ras = new rasterizer_outline_aa(ren);
*
* conv_transform trans = new conv_transform(g_path, mtx);
*
* ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths);
*/
}
base.OnDraw();
}
public polygon_ctrl_impl(uint np, T point_radius)
: base(M.Zero <T>(), M.Zero <T>(), M.One <T>(), M.One <T>())
{
m_ellipse = new Ellipse <T>();
m_polygon = new ArrayPOD <T>(np * 2);
m_num_points = (np);
m_node = (-1);
m_edge = (-1);
m_vs = new simple_polygon_vertex_source <T>(m_polygon.Array, m_num_points, false);
m_stroke = new ConvStroke <T>(m_vs);
m_point_radius = (point_radius);
m_status = (0);
m_dx = M.Zero <T>();
m_dy = M.Zero <T>();
m_in_polygon_check = (true);
m_stroke.Width = M.One <T>();
}
public override void OnDraw()
{
#if SourceDepth24
FormatRGB pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
#else
pixfmt_alpha_blend_rgba32 pixf = new pixfmt_alpha_blend_rgba32(rbuf_window(), new blender_bgra32());
pixfmt_alpha_blend_rgba32 pixfImage = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra32());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1.0, 1.0, 1.0));
clippingProxy.CopyFrom(rbuf_img(0), new RectInt(0, 0, (int)Width.ToInt(), (int)Height.ToInt()), 110, 35);
string buf = string.Format("NSteps={0:F0}", m_num_steps);
GsvText <T> t = new GsvText <T>();
t.StartPoint(10.0, 295.0);
t.SetFontSize(10.0);
t.Text = buf;
ConvStroke <T> pt = new ConvStroke <T>(t);
pt.Width = M.New <T>(1.5);
m_Rasterizer.AddPath(pt);
Renderer <T> .RenderSolid(clippingProxy, m_Rasterizer, m_ScanlinePacked, new RGBA_Bytes(0, 0, 0));
if (m_time1 != m_time2 && m_num_pix > 0.0)
{
buf = string.Format("{0:F2} Kpix/sec", m_num_pix / (m_time2 - m_time1));
t.StartPoint(10.0, 310.0);
t.Text = buf;
m_Rasterizer.AddPath(pt);
Renderer <T> .RenderSolid(clippingProxy, m_Rasterizer, m_ScanlinePacked, new RGBA_Bytes(0, 0, 0));
}
if (m_filters.cur_item() >= 14)
{
m_radius.Visible = true;
}
else
{
m_radius.Visible = true;
}
base.OnDraw();
}
public curve3_ctrl_impl()
:
base(M.Zero <T>(), M.Zero <T>(), M.One <T>(), M.One <T>())
{
m_stroke = new ConvStroke <T>(m_curve);
m_poly = new polygon_ctrl_impl <T>(3, M.New <T>(5.0));
m_idx = 0;
m_curve = new Curve3 <T>();
m_ellipse = new Ellipse <T>();
m_poly.in_polygon_check(false);
m_poly.SetXN(0, M.New <T>(100.0));
m_poly.SetYN(0, M.Zero <T>());
m_poly.SetXN(1, M.New <T>(100.0));
m_poly.SetYN(1, M.New <T>(50.0));
m_poly.SetXN(2, M.New <T>(50.0));
m_poly.SetYN(2, M.New <T>(100.0));
}
public rbox_ctrl_impl(T x1, T y1, T x2, T y2)
: base(x1, y1, x2, y2)
{
m_border_width = M.One <T>();
m_border_extra = M.Zero <T>();
m_text_thickness = M.New <T>(1.5);
m_text_height = M.New <T>(9.0);
m_text_width = M.Zero <T>();
m_cur_item = -1;
m_ellipse = new Ellipse <T>();
m_ellipse_poly = new ConvStroke <T>(m_ellipse);
m_text = new GsvText <T>();
m_text_poly = new ConvStroke <T>(m_text);
m_idx = (0);
m_vertex = (0);
m_items = new List <string>();
calc_rbox();
}
public TextWidget(string Text, T left, T bottom, T CapitalHeight)
: base(M.Zero <T>(), M.Zero <T>(), M.Zero <T>(), M.Zero <T>())
{
m_text_color = (new RGBA_Doubles(0.0, 0.0, 0.0));
m_BorderSize = CapitalHeight.Multiply(.2);
m_Thickness = CapitalHeight.Divide(8);
m_CapsHeight = CapitalHeight;
m_text = new GsvText <T>();
m_text.Text = Text;
m_text_poly = new ConvStroke <T>(m_text);
m_idx = (0);
T MinX, MinY, MaxX, MaxY;
GetTextBounds(out MinX, out MinY, out MaxX, out MaxY);
T FullWidth = MaxX.Subtract(MinX).Add(m_BorderSize.Multiply(2));
T FullHeight = m_CapsHeight.Add(m_text.AscenderHeight).Add(m_text.DescenderHeight).Add(m_BorderSize.Multiply(2));
Bounds = new RectDouble <T>(left, bottom, left.Add(FullWidth), bottom.Add(FullHeight));
}
public override void OnDraw()
{
if (m_gamma.value().NotEqual(m_old_gamma))
{
m_gamma_lut.Gamma(m_gamma.value().ToDouble());
load_img(0, "spheres");
FormatRGB pixf_change_gamma = new FormatRGB(rbuf_img(0), new BlenderBGR());
//pixf_change_gamma.apply_gamma_dir(m_gamma_lut);
m_old_gamma = m_gamma.value();
}
#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, 1, 1));
if (m_trans_type.cur_item() < 2)
{
// For the IAffineTransformMatrix<T> parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.SetXN(3, m_quad.xn(0).Add(m_quad.xn(2).Subtract(m_quad.xn(1))));
m_quad.SetYN(3, m_quad.yn(0).Add(m_quad.yn(2).Subtract(m_quad.yn(1))));
}
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.AddPath(m_quad);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0.3, 0.5, 0.1));
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.SetVectorClipBox(0, 0, width().ToDouble(), height().ToDouble());
g_rasterizer.Reset();
int b = 0;
g_rasterizer.MoveToDbl(m_quad.xn(0).Subtract(b), m_quad.yn(0).Subtract(b));
g_rasterizer.LineToDbl(m_quad.xn(1).Add(b), m_quad.yn(1).Subtract(b));
g_rasterizer.LineToDbl(m_quad.xn(2).Add(b), m_quad.yn(2).Add(b));
g_rasterizer.LineToDbl(m_quad.xn(3).Subtract(b), m_quad.yn(3).Add(b));
//typedef agg::span_allocator<color_type> span_alloc_type;
SpanAllocator sa = new SpanAllocator();
ImageFilterBilinear <T> filter_kernel = new ImageFilterBilinear <T>();
ImageFilterLookUpTable <T> filter = new ImageFilterLookUpTable <T>(filter_kernel, true);
#if SourceDepth24
pixfmt_alpha_blend_rgb pixf_img = new pixfmt_alpha_blend_rgb(rbuf_img(0), new blender_bgr());
#else
FormatRGBA pixf_img = new FormatRGBA(rbuf_img(0), new BlenderBGRA());
#endif
RasterBufferAccessorClamp source = new RasterBufferAccessorClamp(pixf_img);
start_timer();
switch (m_trans_type.cur_item())
{
case 0:
{
/*
* agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
*
* typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
* interpolator_type interpolator(tr);
*
* typedef image_filter_2x2_type<source_type,
* interpolator_type> span_gen_type;
* span_gen_type sg(source, interpolator, filter);
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
*/
break;
}
case 1:
{
/*
* agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
*
* typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
* typedef image_resample_affine_type<source_type> span_gen_type;
*
* interpolator_type interpolator(tr);
* span_gen_type sg(source, interpolator, filter);
* sg.blur(m_blur.Value());
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
*/
break;
}
case 2:
{
/*
* agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
* if(tr.is_valid())
* {
* typedef agg::span_interpolator_linear_subdiv<agg::trans_perspective> interpolator_type;
* interpolator_type interpolator(tr);
*
* typedef image_filter_2x2_type<source_type,
* interpolator_type> span_gen_type;
* span_gen_type sg(source, interpolator, filter);
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
* }
*/
break;
}
case 3:
{
/*
* agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
* if(tr.is_valid())
* {
* typedef agg::span_interpolator_trans<agg::trans_perspective> interpolator_type;
* interpolator_type interpolator(tr);
*
* typedef image_filter_2x2_type<source_type,
* interpolator_type> span_gen_type;
* span_gen_type sg(source, interpolator, filter);
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
* }
*/
break;
}
case 4:
{
//typedef agg::span_interpolator_persp_lerp<> interpolator_type;
//typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type;
SpanInterpolatorPerspLerp <T> interpolator = new SpanInterpolatorPerspLerp <T>(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
SpanSubDivAdaptor <T> subdiv_adaptor = new SpanSubDivAdaptor <T>(interpolator);
if (interpolator.IsValid())
{
#if SourceDepth24
span_image_resample_rgb sg = new span_image_resample_rgb(source, subdiv_adaptor, filter);
#else
span_image_resample_rgba <T> sg = new span_image_resample_rgba <T>(source, subdiv_adaptor, filter);
#endif
sg.Blur = m_blur.value().ToDouble();
Renderer <T> .GenerateAndRender(g_rasterizer, g_scanline, clippingProxy_pre, sa, sg);
}
break;
}
case 5:
{
/*
* typedef agg::span_interpolator_persp_exact<> interpolator_type;
* typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type;
*
* interpolator_type interpolator(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
* subdiv_adaptor_type subdiv_adaptor(interpolator);
*
* if(interpolator.is_valid())
* {
* typedef image_resample_type<source_type,
* subdiv_adaptor_type> span_gen_type;
* span_gen_type sg(source, subdiv_adaptor, filter);
* sg.blur(m_blur.Value());
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
* }
*/
break;
}
}
double tm = elapsed_time();
//pixf.apply_gamma_inv(m_gamma_lut);
GsvText <T> t = new GsvText <T>();
t.SetFontSize(10.0);
ConvStroke <T> pt = new ConvStroke <T>(t);
pt.Width = M.New <T>(1.5);
string buf = string.Format("{0:F2} ms", tm);
t.StartPoint(10.0, 70.0);
t.Text = buf;
g_rasterizer.AddPath(pt);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0, 0));
//--------------------------
//m_trans_type.Render(g_rasterizer, g_scanline, clippingProxy);
//m_gamma.Render(g_rasterizer, g_scanline, clippingProxy);
//m_blur.Render(g_rasterizer, g_scanline, clippingProxy);
base.OnDraw();
}
public override void OnDraw()
{
GammaLut gamma = new GammaLut(m_gamma.value().ToDouble());
IBlender NormalBlender = new BlenderBGRA();
IBlender GammaBlender = new BlenderGammaBGRA(gamma);
FormatRGBA pixf = new FormatRGBA(rbuf_window(), NormalBlender);
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(m_white_on_black.status() ? new RGBA_Doubles(0, 0, 0) : new RGBA_Doubles(1, 1, 1));
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ScanlinePacked8 sl = new ScanlinePacked8();
Ellipse <T> e = new Ellipse <T>();
// 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], M.New <T>(3), M.New <T>(3), 16);
ras.AddPath(e);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(127, 127, 127));
e.Init(m_x[1], m_y[1], M.New <T>(3), M.New <T>(3), 16);
ras.AddPath(e);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(127, 127, 127));
T d = m_offset.value();
// Creating a rounded rectangle
RoundedRect <T> r = new RoundedRect <T>(m_x[0].Add(d), m_y[0].Add(d), m_x[1].Add(d), m_y[1].Add(d), m_radius.value());
r.NormalizeRadius();
// Drawing as an outline
if (!m_DrawAsOutlineCheckBox.status())
{
ConvStroke <T> p = new ConvStroke <T>(r);
p.Width = M.One <T>();
ras.AddPath(p);
}
else
{
ras.AddPath(r);
}
pixf.Blender = GammaBlender;
Renderer <T> .RenderSolid(clippingProxy, ras, sl, m_white_on_black.status()?new RGBA_Bytes(1, 1, 1) : new RGBA_Bytes(0, 0, 0));
// this was in the original demo, but it does nothing because we changed the blender not the gamma function.
//ras.gamma(new gamma_none());
// so let's change the blender instead
pixf.Blender = NormalBlender;
// Render the controls
//m_radius.Render(ras, sl, clippingProxy);
//m_gamma.Render(ras, sl, clippingProxy);
//m_offset.Render(ras, sl, clippingProxy);
//m_white_on_black.Render(ras, sl, clippingProxy);
//m_DrawAsOutlineCheckBox.Render(ras, sl, clippingProxy);
base.OnDraw();
}
public override void OnDraw()
{
IPixelFormat pixf;
if (this.bpp() == 32)
{
pixf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
//pixf = new pixfmt_alpha_blend_rgba32(rbuf_window(), new blender_rgba32());
}
else
{
if (bpp() != 24)
{
throw new System.NotSupportedException();
}
pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
}
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
g_rasterizer.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), width(), height());
if (m_trans_type.cur_item() == 0)
{
Bilinear <T> tr = new Bilinear <T>(g_x1, g_y1, g_x2, g_y2, m_quad.polygon());
if (tr.IsValid())
{
//--------------------------
// Render transformed lion
//
ConvTransform <T> trans = new ConvTransform <T>(g_path, tr);
Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
//--------------------------
//--------------------------
// Render transformed ellipse
//
VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>(g_x1.Add(g_x2).Multiply(0.5), g_y1.Add(g_y2).Multiply(0.5),
g_x2.Subtract(g_x1).Multiply(0.5), g_y2.Subtract(g_y1).Multiply(0.5),
200);
ConvStroke <T> ell_stroke = new ConvStroke <T>(ell);
ell_stroke.Width = M.New <T>(3.0);
ConvTransform <T> trans_ell = new ConvTransform <T>(ell, tr);
ConvTransform <T> trans_ell_stroke = new ConvTransform <T>(ell_stroke, tr);
g_rasterizer.AddPath(trans_ell);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.5, 0.3, 0.0, 0.3));
g_rasterizer.AddPath(trans_ell_stroke);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.0, 0.3, 0.2, 1.0));
}
}
else
{
Perspective <T> tr = new Perspective <T>(g_x1, g_y1, g_x2, g_y2, m_quad.polygon());
if (tr.IsValid())
{
// Render transformed lion
ConvTransform <T> trans = new ConvTransform <T>(g_path, tr);
Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
// Render transformed ellipse
VertexSource.Ellipse <T> FilledEllipse = new AGG.VertexSource.Ellipse <T>(g_x1.Add(g_x2).Multiply(0.5), g_y1.Add(g_y2).Multiply(0.5),
g_x2.Subtract(g_x1).Multiply(0.5), g_y2.Subtract(g_y1).Multiply(0.5),
200);
ConvStroke <T> EllipseOutline = new ConvStroke <T>(FilledEllipse);
EllipseOutline.Width = M.New <T>(3.0);
ConvTransform <T> TransformedFilledEllipse = new ConvTransform <T>(FilledEllipse, tr);
ConvTransform <T> TransformedEllipesOutline = new ConvTransform <T>(EllipseOutline, tr);
g_rasterizer.AddPath(TransformedFilledEllipse);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.5, 0.3, 0.0, 0.3));
g_rasterizer.AddPath(TransformedEllipesOutline);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.0, 0.3, 0.2, 1.0));
}
}
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.AddPath(m_quad);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0.3, 0.5, 0.6));
//m_trans_type.Render(g_rasterizer, g_scanline, clippingProxy);
base.OnDraw();
}
public RendererBase()
{
TextPath = new GsvText <T>();
StrockedText = new ConvStroke <T>(TextPath);
m_AffineTransformStack.Push(MatrixFactory <T> .NewIdentity(VectorDimension.Two));
}
public override void OnDraw()
{
//typedef agg::renderer_base<agg::pixfmt_bgr24> ren_base;
FormatRGB pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
m_ras.SetVectorClipBox(0, 0, width().ToDouble(), height().ToDouble());
IAffineTransformMatrix <T> move = MatrixFactory <T> .NewTranslation(10, 10);
Perspective <T> shadow_persp = new Perspective <T>(m_shape_bounds.x1, m_shape_bounds.y1,
m_shape_bounds.x2, m_shape_bounds.y2,
m_shadow_ctrl.polygon());
IVertexSource <T> shadow_trans;
if (m_FlattenCurves.status())
{
shadow_trans = new ConvTransform <T>(m_shape, shadow_persp);
}
else
{
shadow_trans = new ConvTransform <T>(m_path, shadow_persp);
// this will make it very smooth after the Transform
//shadow_trans = new conv_curve(shadow_trans);
}
// Render shadow
m_ras.AddPath(shadow_trans);
Renderer <T> .RenderSolid(clippingProxy, m_ras, m_sl, new RGBA_Doubles(0.2, 0.3, 0).GetAsRGBA_Bytes());
// Calculate the bounding box and extend it by the blur radius
RectDouble <T> bbox = new RectDouble <T>();
BoundingRect <T> .BoundingRectSingle(shadow_trans, 0, ref bbox);
bbox.x1.SubtractEquals(m_radius.value());
bbox.y1.SubtractEquals(m_radius.value());
bbox.x2.AddEquals(m_radius.value());
bbox.y2.AddEquals(m_radius.value());
if (m_method.cur_item() == 1)
{
// The recursive blur method represents the true Gaussian Blur,
// with theoretically infinite kernel. The restricted window size
// results in extra influence of edge pixels. It's impossible to
// solve correctly, but extending the right and top areas to another
// radius Value produces fair result.
//------------------
bbox.x2.AddEquals(m_radius.value());
bbox.y2.AddEquals(m_radius.value());
}
start_timer();
if (m_method.cur_item() != 2)
{
// Create a new pixel renderer and Attach it to the main one as a child image.
// It returns true if the attachment succeeded. It fails if the rectangle
// (bbox) is fully clipped.
//------------------
FormatRGB pixf2 = new FormatRGB(m_rbuf2, new BlenderBGR());
if (pixf2.Attach(pixf, (int)bbox.x1.ToInt(), (int)bbox.y1.ToInt(), (int)bbox.x2.ToInt(), (int)bbox.y2.ToInt()))
{
// Blur it
if (m_method.cur_item() == 0)
{
// More general method, but 30-40% slower.
//------------------
//m_stack_blur.blur(pixf2, agg::uround(m_radius.Value()));
// Faster, but bore specific.
// Works only for 8 bits per channel and only with radii <= 254.
//------------------
// agg::stack_blur_rgb24(pixf2, agg::uround(m_radius.Value()),
// agg::uround(m_radius.Value()));
}
else
{
// True Gaussian Blur, 3-5 times slower than Stack Blur,
// but still constant time of radius. Very sensitive
// to precision, doubles are must here.
//------------------
m_recursive_blur.Blur(pixf2, m_radius.value().ToDouble());
}
}
}
else
{
/*
* // Blur separate channels
* //------------------
* if(m_channel_r.status())
* {
* typedef agg::pixfmt_alpha_blend_gray<
* agg::blender_gray8,
* agg::rendering_buffer,
* 3, 2> pixfmt_gray8r;
*
* pixfmt_gray8r pixf2r(m_rbuf2);
* if(pixf2r.Attach(pixf, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2)))
* {
* agg::stack_blur_gray8(pixf2r, agg::uround(m_radius.Value()),
* agg::uround(m_radius.Value()));
* }
* }
*
* if(m_channel_g.status())
* {
* typedef agg::pixfmt_alpha_blend_gray<
* agg::blender_gray8,
* agg::rendering_buffer,
* 3, 1> pixfmt_gray8g;
*
* pixfmt_gray8g pixf2g(m_rbuf2);
* if(pixf2g.Attach(pixf, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2)))
* {
* agg::stack_blur_gray8(pixf2g, agg::uround(m_radius.Value()),
* agg::uround(m_radius.Value()));
* }
* }
*
* if(m_channel_b.status())
* {
* typedef agg::pixfmt_alpha_blend_gray<
* agg::blender_gray8,
* agg::rendering_buffer,
* 3, 0> pixfmt_gray8b;
*
* pixfmt_gray8b pixf2b(m_rbuf2);
* if(pixf2b.Attach(pixf, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2)))
* {
* agg::stack_blur_gray8(pixf2b, agg::uround(m_radius.Value()),
* agg::uround(m_radius.Value()));
* }
* }
*/
}
double tm = elapsed_time();
//m_shadow_ctrl.Render(m_ras, m_sl, clippingProxy);
// Render the shape itself
//------------------
if (m_FlattenCurves.status())
{
m_ras.AddPath(m_shape);
}
else
{
m_ras.AddPath(m_path);
}
Renderer <T> .RenderSolid(clippingProxy, m_ras, m_sl, new RGBA_Doubles(0.6, 0.9, 0.7, 0.8).GetAsRGBA_Bytes());
GsvText <T> t = new GsvText <T>();
t.SetFontSize(10.0);
ConvStroke <T> st = new ConvStroke <T>(t);
st.Width = M.New <T>(1.5);
string buf;
buf = string.Format("{0:F2} ms", tm);
t.StartPoint(140.0, 30.0);
t.Text = buf;
m_ras.AddPath(st);
Renderer <T> .RenderSolid(clippingProxy, m_ras, m_sl, new RGBA_Doubles(0, 0, 0).GetAsRGBA_Bytes());
//m_method.Render(m_ras, m_sl, clippingProxy);
//m_radius.Render(m_ras, m_sl, clippingProxy);
//m_channel_r.Render(m_ras, m_sl, clippingProxy);
//m_channel_g.Render(m_ras, m_sl, clippingProxy);
//m_channel_b.Render(m_ras, m_sl, clippingProxy);
//m_FlattenCurves.Render(m_ras, m_sl, clippingProxy);
base.OnDraw();
}
//this function plots a graph of the average and best fitnesses
//over the course of a run
void PlotStats(RendererBase <T> renderer)
{
if (m_vecBestFitness.Count == 0)
{
return;
}
string s = "Best Fitness: " + m_pGA.BestFitness.ToString();
TextWidget <T> InfoText = new TextWidget <T>(s, M.New <T>(5), M.New <T>(30), M.New <T>(9));
//InfoText.Render(renderer);
s = "Average Fitness: " + m_pGA.AverageFitness.ToString();
InfoText = new TextWidget <T>(s, M.New <T>(5), M.New <T>(45), M.New <T>(9));
//InfoText.Render(renderer);
//render the graph
T HSlice = M.New <T>((double)cxClient / (m_iGenerations + 1));
T VSlice = M.New <T>((double)(cyClient / ((m_BestFitnessYet + 1) * 2)));
bool foundNewBest = false;
if (m_vecBestFitness[m_vecBestFitness.Count - 1] > m_BestFitnessYet ||
m_BestLinesToDraw == null ||
LastFitnessCount != m_vecBestFitness.Count)
{
LastFitnessCount = m_vecBestFitness.Count;
m_BestFitnessYet = m_vecBestFitness[m_vecBestFitness.Count - 1];
foundNewBest = true;
}
if (foundNewBest)
{
//plot the graph for the best fitness
T x = M.Zero <T>();
m_BestPathToDraw.RemoveAll();
m_BestPathToDraw.MoveTo(M.Zero <T>(), M.Zero <T>());
for (int i = 0; i < m_vecBestFitness.Count; ++i)
{
m_BestPathToDraw.LineTo(x, VSlice.Multiply(m_vecBestFitness[i]));
x.AddEquals(HSlice);
}
m_BestLinesToDraw = new ConvStroke <T>(m_BestPathToDraw);
//plot the graph for the average fitness
x = M.Zero <T>();
m_AveragePathToDraw.RemoveAll();
m_AveragePathToDraw.MoveTo(M.Zero <T>(), M.Zero <T>());
for (int i = 0; i < m_vecAvFitness.Count; ++i)
{
m_AveragePathToDraw.LineTo(x, VSlice.Multiply(m_vecAvFitness[i]));
x.AddEquals(HSlice);
}
m_AverageLinesToDraw = new ConvStroke <T>(m_AveragePathToDraw);
}
else
{
renderer.Render(m_BestLinesToDraw, m_BluePen);
renderer.Render(m_AverageLinesToDraw, m_RedPen);
}
}
public RendererOpenGL(IPixelFormat PixelFormat, RasterizerScanlineAA <T> Rasterizer)
: base(PixelFormat, Rasterizer)
{
TextPath = new GsvText <T>();
StrockedText = new ConvStroke <T>(TextPath);
}
public void Draw(IAffineTransformMatrix <T> Position, RendererBase <T> renderer)
{
T TextHeight = m_Position[1].Subtract(20);
T Range = (m_DataViewMaxY.Subtract(m_DataViewMinY));
ConvTransform <T> TransformedLinesToDraw;
ConvStroke <T> StrockedTransformedLinesToDraw;
RoundedRect <T> BackGround = new RoundedRect <T>(m_Position[0], m_Position[1].Subtract(1), m_Position[0].Add(m_Width), m_Position[1].Subtract(1).Add(m_Height).Add(2), M.New <T>(5));
ConvTransform <T> TransformedBackGround = new ConvTransform <T>(BackGround, Position);
renderer.Render(TransformedBackGround, new RGBA_Bytes(0, 0, 0, .5));
// if the 0 line is within the window than draw it.
if (m_DataViewMinY.LessThan(0) && m_DataViewMaxY.GreaterThan(0))
{
m_LinesToDraw.RemoveAll();
m_LinesToDraw.MoveTo(m_Position[0],
m_Position[1].Add(m_DataViewMinY.Negative().Multiply(M.New <T>(m_Height).Divide(Range))));
m_LinesToDraw.LineTo(m_Position[0].Add((double)m_Width),
m_Position[1].Add(m_DataViewMinY.Negative().Multiply(M.New <T>((double)m_Height).Divide(Range))));
TransformedLinesToDraw = new ConvTransform <T>(m_LinesToDraw, Position);
StrockedTransformedLinesToDraw = new ConvStroke <T>(TransformedLinesToDraw);
renderer.Render(StrockedTransformedLinesToDraw, new RGBA_Bytes(0, 0, 0, 1));
}
T MaxMax = M.New <T>(-999999999);
T MinMin = M.New <T>(999999999);
T MaxAverage = M.Zero <T>();
foreach (KeyValuePair <String, HistoryData> historyKeyValue in m_DataHistoryArray)
{
HistoryData history = historyKeyValue.Value;
m_LinesToDraw.RemoveAll();
MaxMax = M.Max(MaxMax, history.GetMaxValue());
MinMin = M.Min(MinMin, history.GetMinValue());
MaxAverage = M.Max(MaxAverage, history.GetAverageValue());
for (int i = 0; i < m_Width - 1; i++)
{
if (i == 0)
{
m_LinesToDraw.MoveTo(m_Position[0].Add(i),
m_Position[1].Add(history.GetItem(i).Subtract(m_DataViewMinY).Multiply(M.New <T>(m_Height).Divide(Range))));
}
else
{
m_LinesToDraw.LineTo(m_Position[0].Add(i),
m_Position[1].Add(history.GetItem(i).Subtract(m_DataViewMinY).Multiply(M.New <T>((double)m_Height).Divide(Range))));
}
}
TransformedLinesToDraw = new ConvTransform <T>(m_LinesToDraw, Position);
StrockedTransformedLinesToDraw = new ConvStroke <T>(TransformedLinesToDraw);
renderer.Render(StrockedTransformedLinesToDraw, history.m_Color);
String Text = historyKeyValue.Key + ": Min:" + MinMin.ToString("0.0") + " Max:" + MaxMax.ToString("0.0");
renderer.DrawString(Text, m_Position[0], TextHeight.Subtract(m_Height));
TextHeight.SubtractEquals(20);
}
RoundedRect <T> BackGround2 = new RoundedRect <T>(
m_Position[0],
m_Position[1].Subtract(1),
m_Position[0].Add((double)m_Width),
m_Position[1].Subtract(1 + m_Height + 2), M.New <T>(5));
ConvTransform <T> TransformedBackGround2 = new ConvTransform <T>(BackGround2, Position);
ConvStroke <T> StrockedTransformedBackGround = new ConvStroke <T>(TransformedBackGround2);
renderer.Render(StrockedTransformedBackGround, new RGBA_Bytes(0.0, 0, 0, 1));
//renderer.Color = BoxColor;
//renderer.DrawRect(m_Position.x, m_Position.y - 1, m_Width, m_Height + 2);
}
