int cmdtree(char **para, int np) { static float x1, x2, w, h; static int fontsz=7; if(strcmp(para[0],"dash")==0 && np==2) vp_set_dash(atof(para[1])); else if(strcmp(para[0],"color")==0 && np==2) vp_color(atoi(para[1])); else if(strcmp(para[0],"style")==0 && np==2) vp_style(atoi(para[1])); else if(strcmp(para[0],"fat")==0 && np==2) vp_fat(atoi(para[1])); else if(strcmp(para[0],"fontsz")==0 && np==2) fontsz=atoi(para[1]); else if(strcmp(para[0],"move")==0 && np==3) { x1 = atof(para[1]); x2 = atof(para[2]); vp_move(x1, x2); } else if(strcmp(para[0],"line")==0 && np==3) vp_draw(atof(para[1]), atof(para[2])); else if(strcmp(para[0],"text")==0) switch(np) { case 4: vp_text(x1, x2, atoi(para[1]), atof(para[2]), para[3]); break; case 3: vp_text(x1, x2, fontsz, atof(para[1]), para[2]); break; case 2: vp_text(x1, x2, fontsz, 0.0, para[1]); break; default: break; } else if(strcmp(para[0],"box")==0) switch(np) { case 4: box(x1, x2, atof(para[1]), atof(para[2]), atof(para[3])*SF_PI/180); break; case 3: box(x1, x2, atof(para[1]), atof(para[2]), 0.0); break; default: break; } else if(strcmp(para[0],"frame")==0 && np==4 ) { w = atof(para[1]); h = atof(para[2]); box(x1+w/2, x2+h/2, w, h, 0.0); vp_text(x1+0.1, x2+0.1, fontsz, 0.0, para[3]); }else if(strcmp(para[0],"ell")==0 && np==4) ell(x1, x2, atof(para[1]), atof(para[2]), atof(para[3])*SF_PI/180); else if(strcmp(para[0],"arrow")==0 && np==4) vp_arrow(x1, x2, atof(para[1]), atof(para[2]), atof(para[3])); else return -1; return 0; }
void ooo(float x,float y,float h,float w) { glBegin(GL_POINTS); ell(x+w/2,y+h/2,w/2,h/2); glEnd(); xnxt+=w; xnxt+=sp; }
void qqq(float x,float y,float h,float w) { glBegin(GL_POINTS); ell(x+w/2,y+h/2,w/2,h/2); mid(x+w/2,y+h/3,x+w,y); glEnd(); xnxt+=w; xnxt+=sp; }
//David: I think the above fails because Ellipse has a Plane whose memory layout is not synonymous with ON_Plane RH_C_FUNCTION int ON_Ellipse_GetNurbForm2( const ON_PLANE_STRUCT* plane, double r0, double r1, ON_NurbsCurve* pNurbsCurve ) { int rc = 0; if( plane && pNurbsCurve ) { ON_Plane temp = FromPlaneStruct(*plane); ON_Ellipse ell(temp, r0, r1); rc = ell.GetNurbForm(*pNurbsCurve); } return rc; }
//------------------------------------------------------------------------ void draw_nodes_fine(scanline_rasterizer& ras) { gradient_span_alloc sa; pixfmt pixf(rbuf_window()); base_renderer rb(pixf); int i; for(i = 0; i < m_graph.get_num_nodes(); i++) { graph::node n = m_graph.get_node(i, width(), height()); agg::ellipse ell(n.x, n.y, 5.0 * m_width.value(), 5.0 * m_width.value()); double x, y; switch(m_draw) { case 0: ell.rewind(0); while(!agg::is_stop(ell.vertex(&x, &y))); break; case 1: ras.reset(); ras.add_path(ell); break; case 2: ras.reset(); ras.add_path(ell); ras.sort(); break; case 3: { gradient_function gf; agg::trans_affine mtx; mtx *= agg::trans_affine_scaling(m_width.value() / 2.0); mtx *= agg::trans_affine_translation(n.x, n.y); mtx.invert(); interpolator inter(mtx); gradient_span_gen sg(inter, gf, m_gradient_colors, 0.0, 10.0); gradient_renderer ren(rb, sa, sg); ras.add_path(ell); agg::render_scanlines(ras, m_sl, ren); } break; } } }
void generate_circles(agg::path_storage& ps, const double* quad, unsigned num_circles, double radius) { ps.remove_all(); unsigned i; for(i = 0; i < 4; ++i) { unsigned n1 = i * 2; unsigned n2 = (i < 3) ? i * 2 + 2 : 0; unsigned j; for(j = 0; j < num_circles; j++) { agg::ellipse ell(quad[n1] + (quad[n2] - quad[n1]) * j / num_circles, quad[n1 + 1] + (quad[n2 + 1] - quad[n1 + 1]) * j / num_circles, radius, radius, 100); ps.concat_path(ell); } } }
double fdz_integrate (double z, void* params) { struct fdz_integrate_params *par = (struct fdz_integrate_params *)params; double z0 = (par->z0); double u = (par->u); double r = (par->r); double x = (r*r + u*u + z*z) / (2.0*r*u); double x2 = x*x; double p = x - sqrt(x2 - 1); if (p > 0.0001) return ell(p)*f_densz(z / z0) / sqrt(p); else { double m2 = p*p / 8.0; double m = sqrt(m2); return 2.0*M_PI*m2*m*(1.0 + 3.0*m2)*f_densz(z / z0)*M_SQRT1_2*sqrt(M_SQRT1_2); }; }
void radial_shape(RenBase& rbase, const ColorRamp& colors, double x1, double y1, double x2, double y2) { typedef RenBase renderer_base_type; typedef agg::gradient_radial gradient_func_type; typedef ColorRamp color_func_type; typedef agg::span_interpolator_linear<> interpolator_type; typedef agg::span_allocator<color> span_allocator_type; typedef agg::span_gradient<color, interpolator_type, gradient_func_type, color_func_type> span_gradient_type; gradient_func_type gradient_func; // The gradient function agg::trans_affine gradient_mtx; interpolator_type span_interpolator(gradient_mtx); // Span interpolator span_allocator_type span_allocator; // Span Allocator span_gradient_type span_gradient(span_interpolator, gradient_func, colors, 0, 100); double cx = (x1 + x2) / 2.0; double cy = (y1 + y2) / 2.0; double r = 0.5 * (((x2 - x1) < (y2 - y1)) ? (x2 - x1) : (y2 - y1)); gradient_mtx *= agg::trans_affine_scaling(r / 100.0); gradient_mtx *= agg::trans_affine_translation(cx, cy); gradient_mtx *= trans_affine_resizing(); gradient_mtx.invert(); agg::ellipse ell(cx, cy, r, r, 100); agg::conv_transform<agg::ellipse> trans(ell, trans_affine_resizing()); m_ras.add_path(trans); agg::render_scanlines_aa(m_ras, m_sl, rbase, span_allocator, span_gradient); }
void circle(RenBase& rbase, color c1, color c2, double x1, double y1, double x2, double y2, double shadow_alpha) { typedef RenBase renderer_base_type; typedef agg::gradient_x gradient_func_type; typedef agg::gradient_linear_color<color> color_func_type; typedef agg::span_interpolator_linear<> interpolator_type; typedef agg::span_allocator<color> span_allocator_type; typedef agg::span_gradient<color, interpolator_type, gradient_func_type, color_func_type> span_gradient_type; gradient_func_type gradient_func; // The gradient function agg::trans_affine gradient_mtx = gradient_affine(x1, y1, x2, y2, 100); interpolator_type span_interpolator(gradient_mtx); // Span interpolator span_allocator_type span_allocator; // Span Allocator color_func_type color_func(c1, c2); span_gradient_type span_gradient(span_interpolator, gradient_func, color_func, 0, 100); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; double r = agg::calc_distance(x1, y1, x2, y2) / 2; agg::ellipse ell((x1+x2)/2+5, (y1+y2)/2-3, r, r, 100); ras.add_path(ell); agg::render_scanlines_aa_solid(ras, sl, rbase, agg::rgba(0.6, 0.6, 0.6, 0.7*shadow_alpha)); ell.init((x1+x2)/2, (y1+y2)/2, r, r, 100); ras.add_path(ell); agg::render_scanlines_aa(ras, sl, rbase, span_allocator, span_gradient); }
virtual void on_draw() { typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_base<pixfmt_pre> renderer_base_pre; pixfmt pixf(rbuf_window()); pixfmt_pre pixf_pre(rbuf_window()); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-initial_width()/2 - 10, -initial_height()/2 - 20 - 10); src_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); src_mtx *= agg::trans_affine_scaling(m_scale.value()); src_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2 + 20); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx; img_mtx *= agg::trans_affine_translation(-initial_width()/2 + 10, -initial_height()/2 + 20 + 10); img_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); img_mtx *= agg::trans_affine_scaling(m_scale.value()); img_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2 + 20); img_mtx *= trans_affine_resizing(); img_mtx.invert(); agg::span_allocator<color_type> sa; typedef agg::span_interpolator_linear<> interpolator_type; interpolator_type interpolator(img_mtx); typedef agg::image_accessor_clip<pixfmt> img_source_type; pixfmt img_pixf(rbuf_img(0)); img_source_type img_src(img_pixf, agg::rgba_pre(0, 0.4, 0, 0.5)); /* // Version without filtering (nearest neighbor) //------------------------------------------ typedef agg::span_image_filter_rgb_nn<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator); //------------------------------------------ */ // Version with "hardcoded" bilinear filter and without // image_accessor (direct filter, the old variant) //------------------------------------------ typedef agg::span_image_filter_rgb_bilinear_clip<pixfmt, interpolator_type> span_gen_type; span_gen_type sg(img_pixf, agg::rgba_pre(0, 0.4, 0, 0.5), interpolator); //------------------------------------------ /* // Version with arbitrary 2x2 filter //------------------------------------------ typedef agg::span_image_filter_rgb_2x2<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_kaiser> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ /* // Version with arbitrary filter //------------------------------------------ typedef agg::span_image_filter_rgb<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_spline36> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ agg::rasterizer_scanline_aa<> ras; ras.clip_box(0, 0, width(), height()); agg::scanline_u8 sl; double r = initial_width(); if(initial_height() - 60 < r) r = initial_height() - 60; agg::ellipse ell(initial_width() / 2.0 + 10, initial_height() / 2.0 + 20 + 10, r / 2.0 + 16.0, r / 2.0 + 16.0, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb_pre, sa, sg); agg::render_ctrl(ras, sl, rb, m_angle); agg::render_ctrl(ras, sl, rb, m_scale); }
virtual void on_draw() { pixfmt pixf(rbuf_window()); renderer_base rb(pixf); renderer_solid r(rb); rb.clear(agg::rgba(1, 1, 1)); g_rasterizer.clip_box(0, 0, width(), height()); if(m_trans_type.cur_item() == 0) { agg::trans_bilinear tr(g_x1, g_y1, g_x2, g_y2, m_quad.polygon()); if(tr.is_valid()) { //-------------------------- // Render transformed lion // agg::conv_transform<agg::path_storage, agg::trans_bilinear> trans(g_path, tr); agg::render_all_paths(g_rasterizer, g_scanline, r, trans, g_colors, g_path_idx, g_npaths); //-------------------------- //-------------------------- // Render transformed ellipse // agg::ellipse ell((g_x1 + g_x2) * 0.5, (g_y1 + g_y2) * 0.5, (g_x2 - g_x1) * 0.5, (g_y2 - g_y1) * 0.5, 200); agg::conv_stroke<agg::ellipse> ell_stroke(ell); ell_stroke.width(3.0); agg::conv_transform<agg::ellipse, agg::trans_bilinear> trans_ell(ell, tr); agg::conv_transform<agg::conv_stroke<agg::ellipse>, agg::trans_bilinear> trans_ell_stroke(ell_stroke, tr); g_rasterizer.add_path(trans_ell); r.color(agg::rgba(0.5, 0.3, 0.0, 0.3)); agg::render_scanlines(g_rasterizer, g_scanline, r); g_rasterizer.add_path(trans_ell_stroke); r.color(agg::rgba(0.0, 0.3, 0.2, 1.0)); agg::render_scanlines(g_rasterizer, g_scanline, r); //-------------------------- } } else { agg::trans_perspective tr(g_x1, g_y1, g_x2, g_y2, m_quad.polygon()); if(tr.is_valid()) { //-------------------------- // Render transformed lion // agg::conv_transform<agg::path_storage, agg::trans_perspective> trans(g_path, tr); agg::render_all_paths(g_rasterizer, g_scanline, r, trans, g_colors, g_path_idx, g_npaths); //-------------------------- //-------------------------- // Render transformed ellipse // agg::ellipse ell((g_x1 + g_x2) * 0.5, (g_y1 + g_y2) * 0.5, (g_x2 - g_x1) * 0.5, (g_y2 - g_y1) * 0.5, 200); agg::conv_stroke<agg::ellipse> ell_stroke(ell); ell_stroke.width(3.0); agg::conv_transform<agg::ellipse, agg::trans_perspective> trans_ell(ell, tr); agg::conv_transform<agg::conv_stroke<agg::ellipse>, agg::trans_perspective> trans_ell_stroke(ell_stroke, tr); g_rasterizer.add_path(trans_ell); r.color(agg::rgba(0.5, 0.3, 0.0, 0.3)); agg::render_scanlines(g_rasterizer, g_scanline, r); g_rasterizer.add_path(trans_ell_stroke); r.color(agg::rgba(0.0, 0.3, 0.2, 1.0)); agg::render_scanlines(g_rasterizer, g_scanline, r); //-------------------------- // Testing the reverse transformations //agg::trans_perspective tr2(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2); //if(tr2.is_valid()) //{ // double x, y; // x = m_quad.xn(0); y = m_quad.yn(0); tr2.transform(&x, &y); // g_rasterizer.move_to_d(x, y); // x = m_quad.xn(1); y = m_quad.yn(1); tr2.transform(&x, &y); // g_rasterizer.line_to_d(x, y); // x = m_quad.xn(2); y = m_quad.yn(2); tr2.transform(&x, &y); // g_rasterizer.line_to_d(x, y); // x = m_quad.xn(3); y = m_quad.yn(3); tr2.transform(&x, &y); // g_rasterizer.line_to_d(x, y); // r.color(agg::rgba(0.5, 0.0, 0.0, 0.5)); // agg::render_scanlines(g_rasterizer, g_scanline, r); //} //else //{ // message("Singularity..."); //} } } //-------------------------- // Render the "quad" tool and controls g_rasterizer.add_path(m_quad); r.color(agg::rgba(0, 0.3, 0.5, 0.6)); agg::render_scanlines(g_rasterizer, g_scanline, r); agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type); //-------------------------- }
virtual void on_draw() { double img_width = rbuf_img(0).width(); double img_height = rbuf_img(0).height(); typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; pixfmt pixf(rbuf_window()); pixfmt img_pixf(rbuf_img(0)); renderer_base rb(pixf); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); src_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); src_mtx *= agg::trans_affine_translation(img_width/2 + 10, img_height/2 + 10 + 40); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx; img_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); img_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); img_mtx *= agg::trans_affine_scaling(m_scale.value()); img_mtx *= agg::trans_affine_translation(img_width/2 + 10, img_height/2 + 10 + 40); img_mtx *= trans_affine_resizing(); img_mtx.invert(); typedef agg::span_allocator<agg::rgba8> span_alloc_type; span_alloc_type sa; typedef agg::span_interpolator_adaptor<agg::span_interpolator_linear<>, periodic_distortion> interpolator_type; periodic_distortion* dist = 0; distortion_wave dist_wave; distortion_swirl dist_swirl; distortion_wave_swirl dist_wave_swirl; distortion_swirl_wave dist_swirl_wave; switch(m_distortion.cur_item()) { case 0: dist = &dist_wave; break; case 1: dist = &dist_swirl; break; case 2: dist = &dist_wave_swirl; break; case 3: dist = &dist_swirl_wave; break; } dist->period(m_period.value()); dist->amplitude(m_amplitude.value()); dist->phase(m_phase); double cx = m_center_x; double cy = m_center_y; img_mtx.transform(&cx, &cy); dist->center(cx, cy); interpolator_type interpolator(img_mtx, *dist); typedef agg::image_accessor_clip<pixfmt> img_source_type; img_source_type img_src(img_pixf, agg::rgba(1,1,1)); /* // Version without filtering (nearest neighbor) //------------------------------------------ typedef agg::span_image_filter_rgb_nn<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator); //------------------------------------------ */ // Version with "hardcoded" bilinear filter and without // image_accessor (direct filter, the old variant) //------------------------------------------ typedef agg::span_image_filter_rgb_bilinear_clip<pixfmt, interpolator_type> span_gen_type; span_gen_type sg(img_pixf, agg::rgba(1,1,1), interpolator); //------------------------------------------ /* // Version with arbitrary 2x2 filter //------------------------------------------ typedef agg::span_image_filter_rgb_2x2<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_kaiser> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ /* // Version with arbitrary filter //------------------------------------------ typedef agg::span_image_filter_rgb<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_spline36> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; double r = img_width; if(img_height < r) r = img_height; agg::ellipse ell(img_width / 2.0, img_height / 2.0, r / 2.0 - 20.0, r / 2.0 - 20.0, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb, sa, sg); src_mtx *= ~trans_affine_resizing(); src_mtx *= agg::trans_affine_translation(img_width - img_width/10, 0.0); src_mtx *= trans_affine_resizing(); ras.add_path(tr); agg::render_scanlines_aa_solid(ras, sl, rb, agg::rgba8(0,0,0)); typedef agg::span_gradient<agg::rgba8, interpolator_type, agg::gradient_circle, color_array_type> gradient_span_gen; agg::gradient_circle gradient_function; color_array_type gradient_colors(m_gradient_colors); gradient_span_gen span_gradient(interpolator, gradient_function, gradient_colors, 0, 180); agg::trans_affine gr1_mtx; gr1_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); gr1_mtx *= agg::trans_affine_scaling(0.8); gr1_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); gr1_mtx *= agg::trans_affine_translation(img_width - img_width/10 + img_width/2 + 10, img_height/2 + 10 + 40); gr1_mtx *= trans_affine_resizing(); agg::trans_affine gr2_mtx; gr2_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); gr2_mtx *= agg::trans_affine_scaling(m_scale.value()); gr2_mtx *= agg::trans_affine_translation(img_width - img_width/10 + img_width/2 + 10 + 50, img_height/2 + 10 + 40 + 50); gr2_mtx *= trans_affine_resizing(); gr2_mtx.invert(); cx = m_center_x + img_width - img_width/10; cy = m_center_y; gr2_mtx.transform(&cx, &cy); dist->center(cx, cy); interpolator.transformer(gr2_mtx); agg::conv_transform<agg::ellipse> tr2(ell, gr1_mtx); ras.add_path(tr2); agg::render_scanlines_aa(ras, sl, rb, sa, span_gradient); agg::render_ctrl(ras, sl, rb, m_angle); agg::render_ctrl(ras, sl, rb, m_scale); agg::render_ctrl(ras, sl, rb, m_amplitude); agg::render_ctrl(ras, sl, rb, m_period); agg::render_ctrl(ras, sl, rb, m_distortion); }
virtual void on_draw() { #if ENABLE_GAMMA_CTRL typedef agg::gamma_lut<agg::int8u, agg::int8u, 8, 8> gamma_type; typedef pixfmt_gamma<gamma_type> pixfmt_type; typedef agg::renderer_base<pixfmt_type> ren_base; double g = m_gamma.value(); gamma_type gamma(g); pixfmt_type pixf(rbuf_window(), gamma); #else typedef agg::renderer_base<pixfmt> ren_base; pixfmt pixf(rbuf_window()); #endif ren_base renb(pixf); renb.clear(agg::rgba(1, 1, 1)); double dark = 1.0 - m_contrast.value(); double light = m_contrast.value(); renb.copy_bar(0,0,int(width())/2, int(height()), agg::rgba(dark,dark,dark)); renb.copy_bar(int(width())/2+1,0, int(width()), int(height()), agg::rgba(light,light,light)); renb.copy_bar(0,int(height())/2+1, int(width()), int(height()), agg::rgba(1.0,dark,dark)); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; agg::path_storage path; #if ENABLE_GAMMA_CTRL unsigned i; double x = (width() - 256.0) / 2.0; double y = 50.0; path.remove_all(); agg::gamma_power gp(g); for(i = 0; i < 256; i++) { double v = double(i) / 255.0; double gval = gp(v); double dy = gval * 255.0; if(i == 0) path.move_to(x + i, y + dy); else path.line_to(x + i, y + dy); } agg::conv_stroke<agg::path_storage> gpoly(path); gpoly.width(2.0); ras.reset(); ras.add_path(gpoly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(80,127,80)); #endif agg::ellipse ell(width() / 2, height() / 2, m_rx, m_ry, 150); agg::conv_stroke<agg::ellipse> poly(ell); poly.width(m_thickness.value()); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(255,0,0)); ell.init(width() / 2, height() / 2, m_rx-5.0, m_ry-5.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(0,255,0)); ell.init(width() / 2, height() / 2, m_rx-10.0, m_ry-10.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(0,0,255)); ell.init(width() / 2, height() / 2, m_rx-15.0, m_ry-15.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(0,0,0)); ell.init(width() / 2, height() / 2, m_rx-20.0, m_ry-20.0, 150); ras.reset(); ras.add_path(poly); agg::render_scanlines_aa_solid(ras, sl, renb, agg::srgba8(255,255,255)); agg::render_ctrl(ras, sl, renb, m_thickness); agg::render_ctrl(ras, sl, renb, m_contrast); #if ENABLE_GAMMA_CTRL agg::render_ctrl(ras, sl, renb, m_gamma); #endif }
void transform_image(double angle) { double width = rbuf_img(0).width(); double height = rbuf_img(0).height(); pixfmt pixf(rbuf_img(0)); pixfmt_pre pixf_pre(rbuf_img(0)); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; agg::span_allocator<color_type> sa; agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-width/2.0, -height/2.0); src_mtx *= agg::trans_affine_rotation(angle * agg::pi / 180.0); src_mtx *= agg::trans_affine_translation(width/2.0, height/2.0); agg::trans_affine img_mtx = src_mtx; img_mtx.invert(); double r = width; if(height < r) r = height; r *= 0.5; r -= 4.0; agg::ellipse ell(width / 2.0, height / 2.0, r, r, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); m_num_pix += r * r * agg::pi; typedef agg::span_interpolator_linear<> interpolator_type; interpolator_type interpolator(img_mtx); agg::image_filter_lut filter; bool norm = m_normalize.status(); switch(m_filters.cur_item()) { case 0: { typedef agg::span_image_filter_nn<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; case 1: { typedef agg::span_image_filter_bilinear<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; case 5: case 6: case 7: { switch(m_filters.cur_item()) { case 5: filter.calculate(agg::image_filter_hanning(), norm); break; case 6: filter.calculate(agg::image_filter_hamming(), norm); break; case 7: filter.calculate(agg::image_filter_hermite(), norm); break; } typedef agg::span_image_filter_2x2<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator, filter); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; case 2: case 3: case 4: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: { switch(m_filters.cur_item()) { case 2: filter.calculate(agg::image_filter_bicubic(), norm); break; case 3: filter.calculate(agg::image_filter_spline16(), norm); break; case 4: filter.calculate(agg::image_filter_spline36(), norm); break; case 8: filter.calculate(agg::image_filter_kaiser(), norm); break; case 9: filter.calculate(agg::image_filter_quadric(), norm); break; case 10: filter.calculate(agg::image_filter_catrom(), norm); break; case 11: filter.calculate(agg::image_filter_gaussian(), norm); break; case 12: filter.calculate(agg::image_filter_bessel(), norm); break; case 13: filter.calculate(agg::image_filter_mitchell(), norm); break; case 14: filter.calculate(agg::image_filter_sinc(m_radius.value()), norm); break; case 15: filter.calculate(agg::image_filter_lanczos(m_radius.value()), norm); break; case 16: filter.calculate(agg::image_filter_blackman(m_radius.value()), norm); break; } typedef agg::span_image_filter<color_type, #ifdef AGG_COMPONENT_ORDER component_order, #endif interpolator_type> span_gen_type; typedef agg::renderer_scanline_aa<renderer_base_pre, span_gen_type> renderer_type; span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator, filter); renderer_type ri(rb_pre, sg); ras.add_path(tr); agg::render_scanlines(ras, sl, ri); } break; } }
int main(int argc, char* argv[]) { #ifdef HAVE_MPI MPI::Init(argc, argv); #endif RCP<MxComm> myComm = rcp(new MxComm()); #if 0 #ifdef HAVE_MPI MPI::Init(argc, argv); //MPI_Init(argc, argv); Epetra_MpiComm myComm(MPI_COMM_WORLD); #else Epetra_SerialComm myComm; #endif #endif // input file method #if 1 std::string inFile; Teuchos::CommandLineProcessor cmdp(false, true); cmdp.setOption("infile", &inFile, "XML format input file."); if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) { return -1; } if (inFile == "") { std::cout << "Please specify an input file using --infile=your_file.mx\n"; exit(0); } // now read the input file with trilinos XML reader Teuchos::XMLObject xmlObj(Teuchos::FileInputSource(inFile).getObject()); // get simulation dimension int dim = atoi(MxUtil::XML::getAttr("dim", xmlObj).c_str()); if (dim < 1 or dim > 3) { std::cout << "Simulation dimension invalid or not given, using 3D.\n"; dim = 3; } // get simulation type std::string domain = MxUtil::XML::getAttr("domain", xmlObj).c_str(); if (domain != "frequency" and domain != "time") { std::cout << "Simulation domain invalid or not given, using frequency-domain.\n"; domain = "frequency"; } // create problem MxProblem<1> * prob1d; MxProblem<2> * prob2d; MxProblem<3> * prob3d; switch (dim) { case 1: prob1d = new MxProblem<1>(xmlObj, myComm); prob1d->solve(); delete prob1d; break; case 2: prob2d = new MxProblem<2>(xmlObj, myComm); prob2d->solve(); delete prob2d; break; case 3: prob3d = new MxProblem<3>(xmlObj, myComm); prob3d->solve(); delete prob3d; break; } #endif #if 0 // epetra stuff test MxMap map(10, 0, myComm); Epetra_CrsMatrix mat(Copy, map, 0); int ind = 2; double val = 0; mat.InsertGlobalValues(1, 1, &val, &ind); ind = 3; val = 4; mat.InsertGlobalValues(1, 1, &val, &ind); mat.FillComplete(map, map); Epetra_Vector myvec(map); myvec.Random(); std::cout << myvec; mat.Apply(myvec, myvec); std::cout << myvec; Epetra_CrsMatrix copy(mat); std::cout << mat; MxUtil::Epetra::stripZeros(mat); std::cout << mat; //throw 1; #endif typedef MxDimVector<double, 3> vecd3; typedef MxDimVector<int, 3> veci3; vecd3 midPt(0); #if 0 //std::cout << "Crab cavity setup:\n"; int crabNumCells = 4; double crabCellLen = 2.0 * 0.0192; //meters double crabCavRad = 0.04719; double crabIrisRad = 0.015; double crabCavRho = 0.0136; double crabIrisRho = 0.00331; int crabCellRes = 40; int padCells = 2; int cnx, cny, cnz; double clx, cly, clz; double cox, coy, coz; double crabDelta = crabCellLen / double(crabCellRes); cnz = crabNumCells * crabCellRes + 2 * padCells; clz = double(cnz) * crabDelta; coz = -0.5 * clz; cny = cnx = 2 * (int(ceil(crabCavRad / crabDelta)) + padCells); cly = clx = double(cnx) * crabDelta; coy = cox = -0.5 * clx; veci3 crabN; crabN[0] = cnx; crabN[1] = cny; crabN[2] = cnz; vecd3 crabL; crabL[0] = clx; crabL[1] = cly; crabL[2] = clz; vecd3 crabO; crabO[0] = cox; crabO[1] = coy; crabO[2] = coz; //crabN.print(); //crabL.print(); //crabO.print(); MxGrid<3> crabGrid(crabO, crabN, crabL, &myComm); crabGrid.print(); MxCrabCav crabCav(midPt, crabNumCells, crabCellLen, crabIrisRad, crabCavRad, crabIrisRho, crabCavRho); crabCav.save(crabGrid); Teuchos::ParameterList crabList; crabList.set("geo-mg : levels", 1); crabList.set("geo-mg : smoothers : sweeps", 5); crabList.set("amg : smoothers : sweeps", 1); crabList.set("amg : smoothers : type", "Chebyshev"); crabList.set("eigensolver : output", 2); crabList.set("eigensolver : nev", 15); crabList.set("eigensolver : tol", 1.e-8); crabList.set("eigensolver : block size", 2); crabList.set("eigensolver : num blocks", 30); crabList.set("eigensolver : spectrum", "LM"); crabList.set("wave operator : invert", true); crabList.set("wave operator : invert : tol", 1.e-10); //crabList.set("wave operator : invert : shift", 1000.0); crabList.set("wave operator : invert : max basis size", 40); MxEMSim<dim> crabSim; crabSim.setGrid(&crabGrid); crabSim.setPEC(&crabCav); //crabSim.setGrid(&sphGrid); //crabSim.setPEC(&ell); crabSim.setParameters(crabList); crabSim.setup(); MxSolver<dim> * solver; solver = new MxSolver<dim>(&crabSim, crabList); solver->solve(); delete solver; //return 1; #endif // optimized phc cavity #if 0 double rodRad = 0.003175; // meters const int numRods = 24; double rodx[numRods] = {0.0158406582694, 0.0551748491968, 0.0209567636489, 0.0384658321918, 0.00792032913471, 0.0338604938991, 0.00477355412058, 0.00485955186622, -0.00792032913471, -0.0213143552977, -0.0161832095283, -0.0336062803256, -0.0158406582694, -0.0551748491968, -0.0209567636489, -0.0384658321918, -0.00792032913471, -0.0338604938991, -0.00477355412058, -0.00485955186622, 0.00792032913471, 0.0213143552977, 0.0161832095283, 0.0336062803256}; double rody[numRods] = {0.0, -0.00724351649877, 0.006587367621, 0.0165969314144, 0.013718412474, 0.044161062805, 0.0214427735115, 0.041610853563, 0.013718412474, 0.0514045793038, 0.0148554058905, 0.0250139221487, 1.9399211446e-18, 0.00724351649877, -0.006587367621, -0.0165969314144, -0.013718412474, -0.044161062805, -0.0214427735115, -0.041610853563, -0.013718412474, -0.0514045793038, -0.0148554058905, -0.0250139221487}; std::vector<MxShape<3> *> rods; MxShapeUnion<3> rodsShape; vecd3 rodPos; vecd3 zhat(0); zhat[2] = 1.0; for (int i = 0; i < numRods; i++) { rodPos[0] = rodx[i]; rodPos[1] = rody[i]; rodPos[2] = 0.0; rods.push_back(new MxCylinder(rodPos, zhat, rodRad)); rodsShape.add(rods[i]); } MxDimMatrix<double, 3> sapphEps(0); sapphEps(0, 0) = 9.3; sapphEps(1, 1) = 9.3; sapphEps(2, 2) = 11.5; MxDielectric<3> phcDiel; phcDiel.add(&rodsShape, sapphEps); // conducting cavity double cavLen = 0.019624116824498831; double cavRad = 0.1; MxCylinder cavCyl(0, zhat, cavRad); MxSlab<3> cavCaps(0, zhat, cavLen); MxShapeIntersection<3> phcCav; phcCav.add(&cavCyl); phcCav.add(&cavCaps); // setup grid int rodDiaCells = 6; int pad = 2; double delta = 2.0 * rodRad / double(rodDiaCells); veci3 phcN; phcN[0] = phcN[1] = int(2.0 * cavRad / delta) + 2 * pad; phcN[2] = int(cavLen / delta) + 2 * pad; vecd3 phcL; phcL[0] = phcL[1] = delta * double(phcN[0]); phcL[2] = delta * double(phcN[2]); vecd3 phcO; phcO[0] = phcO[1] = -0.5 * phcL[0]; phcO[2] = -0.5 * phcL[2]; MxGrid<3> phcGrid(phcO, phcN, phcL, &myComm); phcGrid.print(); Teuchos::ParameterList phcList; phcList.set("geo-mg : levels", 1); phcList.set("geo-mg : smoothers : sweeps", 5); phcList.set("eigensolver : output", 2); phcList.set("eigensolver : nev", 15); phcList.set("eigensolver : tol", 1.e-8); phcList.set("eigensolver : block size", 1); phcList.set("eigensolver : num blocks", 30); phcList.set("eigensolver : spectrum", "LM"); phcList.set("wave operator : invert", true); phcList.set("wave operator : invert : tol", 1.e-8); //phcList.set("wave operator : invert : shift", 1000.0); phcList.set("wave operator : invert : max basis size", 40); MxEMSim<dim> phcSim; phcSim.setGrid(&phcGrid); //phcSim.setPEC(&phcCav); phcSim.setDielectric(&phcDiel); phcSim.setParameters(phcList); phcSim.setup(); MxSolver<dim> * solver; solver = new MxSolver<dim>(&phcSim, phcList); solver->solve(); delete solver; for (int i = 0; i < numRods; i++) delete rods[i]; #endif #if 0 double sphR = 0.37; int sphN = 64; MxEllipsoid ell(0.0, sphR); MxGrid<3> sphGrid(-0.5, sphN, 1.0, &myComm); sphGrid.print(); MxDimMatrix<double, 3> rotSapphEps(0); rotSapphEps(0, 0) = 10.225; rotSapphEps(1, 1) = 10.225; rotSapphEps(2, 2) = 9.95; rotSapphEps(0, 1) = rotSapphEps(1, 0) = -0.825; rotSapphEps(0, 2) = rotSapphEps(2, 0) = -0.67360967926537398; rotSapphEps(1, 2) = rotSapphEps(2, 1) = 0.67360967926537398; MxDielectric<3> phcDiel; phcDiel.add(&ell, rotSapphEps); vecd3 ell2Loc(0); ell2Loc[0] = 0.6; vecd3 ell3Loc(0); ell3Loc[0] = 0.3; ell3Loc[2] = 0.3; MxEllipsoid ell2(ell2Loc, sphR); MxEllipsoid ell3(ell3Loc, sphR); MxShapeUnion<3> shUnion; shUnion.add(&ell); shUnion.add(&ell2); shUnion.add(&ell3); //shUnion.save(sphGrid); MxShapeIntersection<3> shInt; shInt.add(&ell); shInt.add(&ell2); shInt.add(&ell3); //shInt.save(sphGrid); MxShapeSubtract<3> shSub; shSub.setBaseShape(&ell); shSub.subtractShape(&ell2); shSub.subtractShape(&ell3); //shSub.save(sphGrid); MxDielectric<3> dielEll; MxDimMatrix<double, 3> epsEll(vecd3(10.0)); // isotropic eps = 10 dielEll.add(&ell, epsEll); Teuchos::ParameterList sphList; sphList.set("geo-mg : levels", 1); sphList.set("geo-mg : smoothers : sweeps", 4); sphList.set("eigensolver : output", 2); sphList.set("eigensolver : nev", 12); sphList.set("eigensolver : tol", 1.e-8); sphList.set("eigensolver : block size", 1); sphList.set("eigensolver : num blocks", 30); sphList.set("eigensolver : spectrum", "LM"); sphList.set("wave operator : invert", true); sphList.set("wave operator : invert : tol", 1.e-8); //sphList.set("wave operator : invert : shift", -0.1); sphList.set("wave operator : invert : shift", 1.0); sphList.set("wave operator : invert : max basis size", 40); MxEMSim<dim> sphSim; sphSim.setGrid(&sphGrid); //sphSim.setDielectric(&dielEll); sphSim.setDielectric(&phcDiel); //sphSim.setPEC(&sphCav); //sphSim.setPEC(&ell); sphSim.setParameters(sphList); sphSim.setup(); MxSolver<dim> * solver; solver = new MxSolver<dim>(&sphSim, sphList); solver->solve(); delete solver; #endif #ifdef HAVE_MPI MPI::Finalize(); //MPI_Finalize(); #endif return 0; }
EllipsoidFitter::Calibration EllipsoidFitter::calculateFit(void) const { /********************************************************************* First step: Fit a quadric to the point set by least-squares minimization based on algebraic distance. *********************************************************************/ /* Create the least-squares system: */ Math::Matrix a(10,10,0.0); /* Process all points: */ for(Misc::ChunkedArray<Point>::const_iterator pIt=points.begin();pIt!=points.end();++pIt) { /* Create the point's associated linear equation: */ double eq[10]; eq[0]=(*pIt)[0]*(*pIt)[0]; eq[1]=2.0*(*pIt)[0]*(*pIt)[1]; eq[2]=2.0*(*pIt)[0]*(*pIt)[2]; eq[3]=2.0*(*pIt)[0]; eq[4]=(*pIt)[1]*(*pIt)[1]; eq[5]=2.0*(*pIt)[1]*(*pIt)[2]; eq[6]=2.0*(*pIt)[1]; eq[7]=(*pIt)[2]*(*pIt)[2]; eq[8]=2.0*(*pIt)[2]; eq[9]=1.0; /* Insert the equation into the least-squares system: */ for(unsigned int i=0;i<10;++i) for(unsigned int j=0;j<10;++j) a(i,j)+=eq[i]*eq[j]; } /* Find the least-squares system's smallest eigenvalue: */ std::pair<Math::Matrix,Math::Matrix> qe=a.jacobiIteration(); unsigned int minEIndex=0; double minE=Math::abs(qe.second(0,0)); for(unsigned int i=1;i<10;++i) { if(minE>Math::abs(qe.second(i,0))) { minEIndex=i; minE=Math::abs(qe.second(i,0)); } } /* Create the quadric's defining matrices: */ Math::Matrix qa(3,3); qa(0,0)=qe.first(0,minEIndex); qa(0,1)=qe.first(1,minEIndex); qa(0,2)=qe.first(2,minEIndex); qa(1,0)=qe.first(1,minEIndex); qa(1,1)=qe.first(4,minEIndex); qa(1,2)=qe.first(5,minEIndex); qa(2,0)=qe.first(2,minEIndex); qa(2,1)=qe.first(5,minEIndex); qa(2,2)=qe.first(7,minEIndex); Math::Matrix qb(3,1); qb(0)=qe.first(3,minEIndex); qb(1)=qe.first(6,minEIndex); qb(2)=qe.first(8,minEIndex); double qc=qe.first(9,minEIndex); /* Calculate the quadric's principal axes: */ qe=qa.jacobiIteration(); std::cout<<std::fixed<<std::setprecision(6); std::cout<<std::setw(9)<<qe.first<<std::endl; std::cout<<std::setw(9)<<qe.second<<std::endl<<std::endl; std::cout.unsetf(std::ios_base::floatfield); /* "Complete the square" to calculate the quadric's centroid and radii: */ Math::Matrix qbp=qb.divideFullPivot(qe.first); Math::Matrix cp(3,1); for(int i=0;i<3;++i) cp(i)=-qbp(i)/qe.second(i); Math::Matrix c=qe.first*cp; std::cout<<"Centroid: "<<c(0)<<", "<<c(1)<<", "<<c(2)<<std::endl; double rhs=-qc; for(int i=0;i<3;++i) rhs+=Math::sqr(qbp(i))/qe.second(i); double radii[3]; for(int i=0;i<3;++i) radii[i]=Math::sqrt(rhs/qe.second(i)); std::cout<<"Radii: "<<radii[0]<<", "<<radii[1]<<", "<<radii[2]<<std::endl; Scalar averageRadius=Math::pow(radii[0]*radii[1]*radii[2],1.0/3.0); std::cout<<"Average radius: "<<averageRadius<<std::endl; /* Calculate the calibration matrix: */ Math::Matrix ellP(4,4,1.0); for(int i=0;i<3;++i) for(int j=0;j<3;++j) ellP(i,j)=qe.first(i,j); Math::Matrix ellScale(4,4,1.0); for(int i=0;i<3;++i) ellScale(i,i)=averageRadius/radii[i]; Math::Matrix ell=ellP; ell.makePrivate(); for(int i=0;i<3;++i) ell(i,3)=c(i); Math::Matrix ellInv=ell.inverseFullPivot(); Math::Matrix calib=ellP*ellScale*ellInv; std::cout<<std::fixed<<std::setprecision(6); std::cout<<std::setw(9)<<calib<<std::endl; std::cout.unsetf(std::ios_base::floatfield); /* Calculate the calibration residual: */ double rms=0.0; for(Misc::ChunkedArray<Point>::const_iterator pIt=points.begin();pIt!=points.end();++pIt) { /* Calibrate the point: */ Math::Matrix p(4,1); for(int i=0;i<3;++i) p(i)=(*pIt)[i]; p(3)=1.0; Math::Matrix cp=calib*p; rms+=Math::sqr(Math::sqrt(Math::sqr(cp(0))+Math::sqr(cp(1))+Math::sqr(cp(2)))-averageRadius); } std::cout<<"Calibration residual: "<<Math::sqrt(rms/double(points.size()))<<std::endl; /* Create and return the calibration result: */ Matrix result; for(int i=0;i<3;++i) for(int j=0;j<4;++j) result(i,j)=calib(i,j); return Calibration(result,averageRadius); }
virtual void on_draw() { typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid; pixfmt pixf(rbuf_window()); renderer_base rb(pixf); renderer_solid rs(rb); rb.clear(agg::rgba(1, 1, 1)); agg::trans_affine mtx; agg::conv_transform<agg::path_storage, agg::trans_affine> trans(g_path, mtx); mtx *= agg::trans_affine_translation(-g_base_dx, -g_base_dy); mtx *= agg::trans_affine_scaling(g_scale, g_scale); mtx *= agg::trans_affine_rotation(g_angle + agg::pi); mtx *= agg::trans_affine_skewing(g_skew_x/1000.0, g_skew_y/1000.0); mtx *= agg::trans_affine_translation(initial_width()/4, initial_height()/2); mtx *= trans_affine_resizing(); agg::rasterizer_scanline_aa<> ras2; agg::scanline_p8 sl; agg::scanline_u8 sl2; agg::render_all_paths(ras2, sl, rs, trans, g_colors, g_path_idx, g_npaths); mtx *= ~trans_affine_resizing(); mtx *= agg::trans_affine_translation(initial_width()/2, 0); mtx *= trans_affine_resizing(); agg::line_profile_aa profile; profile.width(1.0); agg::renderer_outline_aa<renderer_base> rp(rb, profile); agg::rasterizer_outline_aa<agg::renderer_outline_aa<renderer_base> > ras(rp); ras.round_cap(true); ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths); agg::ellipse ell(m_cx, m_cy, 100.0, 100.0, 100); agg::conv_stroke<agg::ellipse> ell_stroke1(ell); ell_stroke1.width(6.0); agg::conv_stroke<agg::conv_stroke<agg::ellipse> > ell_stroke2(ell_stroke1); ell_stroke2.width(2.0); rs.color(agg::rgba(0,0.2,0)); ras2.add_path(ell_stroke2); agg::render_scanlines(ras2, sl, rs); typedef agg::span_simple_blur_rgb24<agg::order_bgr> span_blur_gen; typedef agg::span_allocator<span_blur_gen::color_type> span_blur_alloc; span_blur_alloc sa; span_blur_gen sg; sg.source_image(rbuf_img(0)); ras2.add_path(ell); copy_window_to_img(0); agg::render_scanlines_aa(ras2, sl2, rb, sa, sg); // More blur if desired :-) //copy_window_to_img(0); //agg::render_scanlines(ras2, sl2, rblur); //copy_window_to_img(0); //agg::render_scanlines(ras2, sl2, rblur); //copy_window_to_img(0); //agg::render_scanlines(ras2, sl2, rblur); }
virtual void on_draw() { typedef agg::renderer_base<agg::pixfmt_bgra32> ren_base; typedef agg::renderer_base<agg::pixfmt_bgra32_pre> ren_base_pre; agg::gamma_lut<agg::int8u, agg::int8u> lut(2.0); agg::pixfmt_bgra32 pixf(rbuf_window()); ren_base renb(pixf); agg::pixfmt_bgra32_pre pixf_pre(rbuf_window()); ren_base_pre renb_pre(pixf_pre); // Clear the window with a gradient agg::pod_vector<agg::rgba8> gr(pixf_pre.width()); unsigned i; for(i = 0; i < pixf.width(); i++) { gr.add(agg::rgba8(255, 255, 0).gradient(agg::rgba8(0, 255, 255), double(i) / pixf.width())); } for(i = 0; i < pixf.height(); i++) { renb.copy_color_hspan(0, i, pixf.width(), &gr[0]); } pixf.apply_gamma_dir(lut); agg::rasterizer_scanline_aa<> ras; agg::rasterizer_compound_aa<agg::rasterizer_sl_clip_dbl> rasc; agg::scanline_u8 sl; agg::span_allocator<agg::rgba8> alloc; // Draw two triangles ras.move_to_d(0, 0); ras.line_to_d(width(), 0); ras.line_to_d(width(), height()); agg::render_scanlines_aa_solid(ras, sl, renb, agg::rgba8(lut.dir(0), lut.dir(100), lut.dir(0))); ras.move_to_d(0, 0); ras.line_to_d(0, height()); ras.line_to_d(width(), 0); agg::render_scanlines_aa_solid(ras, sl, renb, agg::rgba8(lut.dir(0), lut.dir(100), lut.dir(100))); agg::trans_affine mtx; mtx *= agg::trans_affine_scaling(4.0); mtx *= agg::trans_affine_translation(150, 100); agg::conv_transform<agg::path_storage> trans(m_path, mtx); agg::conv_curve<agg::conv_transform<agg::path_storage> > curve(trans); agg::conv_stroke <agg::conv_curve <agg::conv_transform <agg::path_storage> > > stroke(curve); compose_path(); agg::rgba8 styles[4]; if(m_invert_order.status()) { rasc.layer_order(agg::layer_inverse); } else { rasc.layer_order(agg::layer_direct); } styles[3] = agg::rgba8(lut.dir(255), lut.dir(0), lut.dir(108), 200).premultiply(); styles[2] = agg::rgba8(lut.dir(51), lut.dir(0), lut.dir(151), 180).premultiply(); styles[1] = agg::rgba8(lut.dir(143), lut.dir(90), lut.dir(6), 200).premultiply(); styles[0] = agg::rgba8(lut.dir(0), lut.dir(0), lut.dir(255), 220).premultiply(); style_handler sh(styles, 4); stroke.width(m_width.value()); rasc.reset(); rasc.master_alpha(3, m_alpha1.value()); rasc.master_alpha(2, m_alpha2.value()); rasc.master_alpha(1, m_alpha3.value()); rasc.master_alpha(0, m_alpha4.value()); agg::ellipse ell(220.0, 180.0, 120.0, 10.0, 128, false); agg::conv_stroke<agg::ellipse> str_ell(ell); str_ell.width(m_width.value() / 2); rasc.styles(3, -1); rasc.add_path(str_ell); rasc.styles(2, -1); rasc.add_path(ell); rasc.styles(1, -1); rasc.add_path(stroke); rasc.styles(0, -1); rasc.add_path(curve); agg::render_scanlines_compound_layered(rasc, sl, renb_pre, alloc, sh); agg::render_ctrl(ras, sl, renb, m_width); agg::render_ctrl(ras, sl, renb, m_alpha1); agg::render_ctrl(ras, sl, renb, m_alpha2); agg::render_ctrl(ras, sl, renb, m_alpha3); agg::render_ctrl(ras, sl, renb, m_alpha4); agg::render_ctrl(ras, sl, renb, m_invert_order); pixf.apply_gamma_inv(lut); }