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);
}
