/*Function of the 1th (radial) momentum component differential equation for the geodesics.
${p1}^{dot} = f1(x^{\alpha},p^{\alpha})$.*/
mydbl geodesic_equation_r(gsl_spline *spline1, gsl_interp_accel *acc1, gsl_spline *spline2, gsl_interp_accel *acc2, mydbl p0, mydbl pr, mydbl x0, mydbl r)
{
double t = (double)(1.0*x0/C);
mydbl a = (mydbl) 1.0*interpolator(spline1, t, acc1);
mydbl adot = (mydbl) 1.0*interpolator(spline2, t, acc2);
mydbl f = - (der_potential(r)*p0*p0)/(a*a*C*C*(1.0 - 2.0*potential(r)/(C*C))) - (2.0*adot*p0*pr)/(C*a) + (der_potential(r)/(C*C))*(pr*pr)/(1.0 - 2.0*potential(r)/(C*C));
return f;
}
std::vector<Volatility> SabrVolSurface::volatilitySpreads(const Date& d) const {
Size nOptionsTimes = optionTimes_.size();
Size nAtmRateSpreads = atmRateSpreads_.size();
std::vector<Volatility> interpolatedVols(nAtmRateSpreads);
std::vector<Volatility> vols(nOptionsTimes); // the volspread at a given strike
for (Size i=0; i<nAtmRateSpreads; ++i) {
for (Size j=0; j<nOptionsTimes; ++j) {
vols[j] = (**volSpreads_[j][i]).value();
}
LinearInterpolation interpolator(optionTimes_.begin(), optionTimes_.end(),
vols.begin());
interpolatedVols[i] = interpolator(timeFromReference(d),true);
}
return interpolatedVols;
}
bool THRawBitmap::_checkScaled(THRenderTarget* pCanvas, SDL_Rect& rcDest)
{
float fFactor;
if(!pCanvas->shouldScaleBitmaps(&fFactor))
return false;
int iScaledWidth = (int)((float)m_pBitmap->w * fFactor);
if(!m_pCachedScaledBitmap || m_pCachedScaledBitmap->w != iScaledWidth)
{
SDL_FreeSurface(m_pCachedScaledBitmap);
Uint32 iRMask, iGMask, iBMask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
iRMask = 0xff000000;
iGMask = 0x00ff0000;
iBMask = 0x0000ff00;
#else
iRMask = 0x000000ff;
iGMask = 0x0000ff00;
iBMask = 0x00ff0000;
#endif
m_pCachedScaledBitmap = SDL_CreateRGBSurface(SDL_SWSURFACE, iScaledWidth, (int)((float)m_pBitmap->h * fFactor), 24, iRMask, iGMask, iBMask, 0);
SDL_LockSurface(m_pCachedScaledBitmap);
SDL_LockSurface(m_pBitmap);
typedef agg::pixfmt_rgb24_pre pixfmt_pre_t;
typedef agg::renderer_base<pixfmt_pre_t> renbase_pre_t;
typedef image_accessor_clip_rgb24_pal8<pixfmt_pre_t> imgsrc_t;
typedef agg::span_interpolator_linear<> interpolator_t;
typedef agg::span_image_filter_rgb_2x2<imgsrc_t, interpolator_t> span_gen_type;
agg::scanline_p8 sl;
agg::span_allocator<pixfmt_pre_t::color_type> sa;
agg::image_filter<agg::image_filter_bilinear> filter;
agg::trans_affine_scaling img_mtx(1.0 / fFactor);
agg::rendering_buffer rbuf_src(m_pData, m_pBitmap->w, m_pBitmap->h, m_pBitmap->pitch);
imgsrc_t img_src(rbuf_src, *m_pPalette, agg::rgba(0.0, 0.0, 0.0));
interpolator_t interpolator(img_mtx);
span_gen_type sg(img_src, interpolator, filter);
agg::rendering_buffer rbuf(reinterpret_cast<unsigned char*>(m_pCachedScaledBitmap->pixels), m_pCachedScaledBitmap->w, m_pCachedScaledBitmap->h, m_pCachedScaledBitmap->pitch);
pixfmt_pre_t pixf_pre(rbuf);
renbase_pre_t rbase_pre(pixf_pre);
rasterizer_scanline_rect ras(0, 0, rbuf.width(), rbuf.height());
rbase_pre.clear(agg::rgba(1.0,0,0,0));
agg::render_scanlines_aa(ras, sl, rbase_pre, sa, sg);
SDL_UnlockSurface(m_pBitmap);
SDL_UnlockSurface(m_pCachedScaledBitmap);
}
rcDest.x = (Sint16)((float)rcDest.x * fFactor);
rcDest.y = (Sint16)((float)rcDest.y * fFactor);
return true;
}
int agg2RenderPixmapSymbol(imageObj *img, double x, double y, symbolObj *symbol, symbolStyleObj * style)
{
AGG2Renderer *r = AGG_RENDERER(img);
rasterBufferObj *pixmap = symbol->pixmap_buffer;
assert(pixmap->type == MS_BUFFER_BYTE_RGBA);
rendering_buffer b(pixmap->data.rgba.pixels,pixmap->width,pixmap->height,pixmap->data.rgba.row_step);
pixel_format pf(b);
r->m_rasterizer_aa.reset();
r->m_rasterizer_aa.filling_rule(mapserver::fill_non_zero);
if ( (style->rotation != 0 && style->rotation != MS_PI*2.)|| style->scale != 1) {
mapserver::trans_affine image_mtx;
image_mtx *= mapserver::trans_affine_translation(-(pf.width()/2.),-(pf.height()/2.));
/*agg angles are antitrigonometric*/
image_mtx *= mapserver::trans_affine_rotation(-style->rotation);
image_mtx *= mapserver::trans_affine_scaling(style->scale);
image_mtx *= mapserver::trans_affine_translation(x,y);
image_mtx.invert();
typedef mapserver::span_interpolator_linear<> interpolator_type;
interpolator_type interpolator(image_mtx);
mapserver::span_allocator<color_type> sa;
// "hardcoded" bilinear filter
//------------------------------------------
typedef mapserver::span_image_filter_rgba_bilinear_clip<pixel_format, interpolator_type> span_gen_type;
span_gen_type sg(pf, mapserver::rgba(0,0,0,0), interpolator);
mapserver::path_storage pixmap_bbox;
int ims_2 = MS_NINT(MS_MAX(pixmap->width,pixmap->height)*style->scale*1.415)/2+1;
pixmap_bbox.move_to(x-ims_2,y-ims_2);
pixmap_bbox.line_to(x+ims_2,y-ims_2);
pixmap_bbox.line_to(x+ims_2,y+ims_2);
pixmap_bbox.line_to(x-ims_2,y+ims_2);
r->m_rasterizer_aa.add_path(pixmap_bbox);
mapserver::render_scanlines_aa(r->m_rasterizer_aa, r->sl_poly, r->m_renderer_base, sa, sg);
} else {
//just copy the image at the correct location (we place the pixmap on
//the nearest integer pixel to avoid blurring)
r->m_renderer_base.blend_from(pf,0,MS_NINT(x-pixmap->width/2.),MS_NINT(y-pixmap->height/2.));
}
return MS_SUCCESS;
}
TEST(InterpolatorTests, ShouldInterpolateNumbers){
Vector p1(-7, 5, 3);
int p1Value = 10;
Vector p2(3, 2, 3);
int p2Value = 2;
Vector p3(-2, -2, 3);
int p3Value = -20;
Vector interpolatedPoint(-1, 0, 3);
Triangle3DInterpolator<double> interpolator(p1, p1Value, p2, p2Value, p3, p3Value);
double interpolatedValue = interpolator.Interpolate(interpolatedPoint);
EXPECT_NEAR(interpolatedValue, -9.928, 0.001);
}
void render_raster_marker(agg::trans_affine const& marker_tr,
double opacity)
{
double width = src_.width();
double height = src_.height();
double p[8];
p[0] = 0; p[1] = 0;
p[2] = width; p[3] = 0;
p[4] = width; p[5] = height;
p[6] = 0; p[7] = height;
marker_tr.transform(&p[0], &p[1]);
marker_tr.transform(&p[2], &p[3]);
marker_tr.transform(&p[4], &p[5]);
marker_tr.transform(&p[6], &p[7]);
ras_.move_to_d(p[0],p[1]);
ras_.line_to_d(p[2],p[3]);
ras_.line_to_d(p[4],p[5]);
ras_.line_to_d(p[6],p[7]);
agg::span_allocator<color_type> sa;
agg::image_filter_bilinear filter_kernel;
agg::image_filter_lut filter(filter_kernel, false);
agg::rendering_buffer marker_buf((unsigned char *)src_.getBytes(),
src_.width(),
src_.height(),
src_.width()*4);
agg::pixfmt_rgba32_pre pixf(marker_buf);
typedef agg::image_accessor_clone<agg::pixfmt_rgba32_pre> img_accessor_type;
typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
typedef agg::span_image_filter_rgba_2x2<img_accessor_type,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa_alpha<renderer_base,
agg::span_allocator<color_type>,
span_gen_type> renderer_type;
img_accessor_type ia(pixf);
interpolator_type interpolator(agg::trans_affine(p, 0, 0, width, height) );
span_gen_type sg(ia, interpolator, filter);
renderer_type rp(renb_,sa, sg, unsigned(opacity*255));
agg::render_scanlines(ras_, sl_, rp);
}
bool ConfigureInterpolatorItem(const TiXmlElement *element, std::vector<unsigned int> &buffer, int width, const char * const names[], const float data[])
{
if (!element->FirstChildElement())
return false;
// temporary interpolator
InterpolatorTemplate interpolator(width);
// start at zero time
float time = 0.0f;
element->QueryFloatAttribute("time", &time);
// get time scale
float scale = 1.0f;
element->QueryFloatAttribute("timescale", &scale);
if (element->QueryFloatAttribute("rate", &scale) == TIXML_SUCCESS)
scale = 1.0f / scale;
// process child elements
for (const TiXmlElement *child = element->FirstChildElement(); child != NULL; child = child->NextSiblingElement())
{
const char *label = child->Value();
switch (Hash(label))
{
case 0x0691ea25 /* "constant" */:
{
// TO DO: process constant interpolator
}
break;
case 0xd00594c0 /* "linear" */:
{
// process linear interpolator
time = ConfigureInterpolatorKeyItems(child, interpolator, time, scale, names, data);
}
break;
case 0x9c265311 /* "hermite" */:
{
// TO DO: process hermite interpolator
}
break;
case 0x6815c86c /* "key" */:
{
ConfigureInterpolatorKeyItem(child, interpolator, time, scale, names, data);
}
break;
case 0xc7441a0f /* "step" */:
{
ConfigureInterpolatorKeyItem(child, interpolator, time, 0, names, data);
float duration = 0.0f;
if (child->QueryFloatAttribute("time", &duration) == TIXML_SUCCESS)
time += duration * scale;
}
break;
}
}
// if not enough keys...
if (interpolator.mCount < 2)
{
// add a final key
float *key = interpolator.AddKey(time);
if (interpolator.mCount == 1)
{
memcpy(&key[1], data, interpolator.mWidth*sizeof(float));
key = interpolator.AddKey(time);
}
memcpy(&key[1], interpolator.GetValues(interpolator.mCount-2), interpolator.mWidth*sizeof(float));
}
// push into the buffer
buffer.push_back(interpolator.mCount);
for (int i = 0; i < interpolator.mCount * interpolator.mStride; i++)
buffer.push_back(*reinterpret_cast<unsigned int *>(&interpolator.mKeys[i]));
return true;
}
virtual void on_draw()
{
pixfmt pixf(rbuf_window());
pixfmt_pre pixf_pre(rbuf_window());
renderer_base rb(pixf);
renderer_base_pre rb_pre(pixf_pre);
if(!m_test_flag)
{
rb.clear(agg::rgba(1, 1, 1));
}
if(m_trans_type.cur_item() == 0)
{
// For the affine parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.xn(3) = m_quad.xn(0) + (m_quad.xn(2) - m_quad.xn(1));
m_quad.yn(3) = m_quad.yn(0) + (m_quad.yn(2) - m_quad.yn(1));
}
if(!m_test_flag)
{
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.add_path(m_quad);
agg::render_scanlines_aa_solid(g_rasterizer, g_scanline, rb, agg::rgba(0, 0.3, 0.5, 0.6));
//--------------------------
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type);
}
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.clip_box(0, 0, width(), height());
g_rasterizer.reset();
g_rasterizer.move_to_d(m_quad.xn(0), m_quad.yn(0));
g_rasterizer.line_to_d(m_quad.xn(1), m_quad.yn(1));
g_rasterizer.line_to_d(m_quad.xn(2), m_quad.yn(2));
g_rasterizer.line_to_d(m_quad.xn(3), m_quad.yn(3));
typedef agg::span_allocator<color_type> span_alloc_type;
span_alloc_type sa;
agg::image_filter<agg::image_filter_hanning> filter;
typedef agg::wrap_mode_reflect_auto_pow2 remainder_type;
typedef agg::image_accessor_wrap<pixfmt,
remainder_type,
remainder_type> img_source_type;
pixfmt img_pixf(rbuf_img(0));
img_source_type img_src(img_pixf);
enum subdiv_shift_e { subdiv_shift = 2 };
switch(m_trans_type.cur_item())
{
case 0:
{
// Note that we consruct an affine matrix that transforms
// a parallelogram to a rectangle, i.e., it's inverted.
// It's actually the same as:
// tr(g_x1, g_y1, g_x2, g_y2, m_triangle.polygon());
// tr.invert();
agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
// Also note that we can use the linear interpolator instead of
// arbitrary span_interpolator_trans. It works much faster,
// but the transformations must be linear and parellel.
typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
interpolator_type interpolator(tr);
typedef span_image_filter_2x2<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
break;
}
case 1:
{
agg::trans_bilinear tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
if(tr.is_valid())
{
typedef agg::span_interpolator_linear<agg::trans_bilinear> interpolator_type;
interpolator_type interpolator(tr);
typedef span_image_filter_2x2<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
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, 8> interpolator_type;
interpolator_type interpolator(tr);
typedef span_image_filter_2x2<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
}
break;
}
}
}
virtual void on_draw()
{
if(m_gamma.value() != m_old_gamma)
{
m_gamma_lut.gamma(m_gamma.value());
load_img(0, "spheres");
pixfmt pixf(rbuf_img(0));
pixf.apply_gamma_dir(m_gamma_lut);
m_old_gamma = m_gamma.value();
}
pixfmt pixf(rbuf_window());
pixfmt_pre pixf_pre(rbuf_window());
renderer_base rb(pixf);
renderer_base_pre rb_pre(pixf_pre);
renderer_solid r(rb);
rb.clear(agg::rgba(1, 1, 1));
if(m_trans_type.cur_item() < 2)
{
// For the affine parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.xn(3) = m_quad.xn(0) + (m_quad.xn(2) - m_quad.xn(1));
m_quad.yn(3) = m_quad.yn(0) + (m_quad.yn(2) - m_quad.yn(1));
}
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.add_path(m_quad);
r.color(agg::rgba(0, 0.3, 0.5, 0.1));
agg::render_scanlines(g_rasterizer, g_scanline, r);
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.clip_box(0, 0, width(), height());
g_rasterizer.reset();
int b = 0;
g_rasterizer.move_to_d(m_quad.xn(0)-b, m_quad.yn(0)-b);
g_rasterizer.line_to_d(m_quad.xn(1)+b, m_quad.yn(1)-b);
g_rasterizer.line_to_d(m_quad.xn(2)+b, m_quad.yn(2)+b);
g_rasterizer.line_to_d(m_quad.xn(3)-b, m_quad.yn(3)+b);
typedef agg::span_allocator<color_type> span_alloc_type;
span_alloc_type sa;
agg::image_filter_bilinear filter_kernel;
agg::image_filter_lut filter(filter_kernel, true);
pixfmt pixf_img(rbuf_img(0));
typedef agg::image_accessor_clone<pixfmt> source_type;
source_type source(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;
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;
}
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);
char buf[64];
agg::gsv_text t;
t.size(10.0);
agg::conv_stroke<agg::gsv_text> pt(t);
pt.width(1.5);
sprintf(buf, "%3.2f ms", tm);
t.start_point(10.0, 70.0);
t.text(buf);
g_rasterizer.add_path(pt);
r.color(agg::rgba(0,0,0));
agg::render_scanlines(g_rasterizer, g_scanline, r);
//--------------------------
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type);
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_gamma);
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_blur);
}
void CellByCellUniformSampling::generate_particles( const kvs::StructuredVolumeObject* volume )
{
CellByCellSampling::ParticleDensityMap density_map;
density_map.setSamplingStep( m_sampling_step );
density_map.attachCamera( m_camera );
density_map.attachObject( volume );
density_map.create( BaseClass::transferFunction().opacityMap() );
const kvs::Vec3ui ncells( volume->resolution() - kvs::Vector3ui::All(1) );
const kvs::ColorMap color_map( BaseClass::transferFunction().colorMap() );
// Calculate number of particles.
size_t N = 0;
kvs::ValueArray<kvs::UInt32> nparticles( ncells.x() * ncells.y() * ncells.z() );
KVS_OMP_PARALLEL()
{
kvs::TrilinearInterpolator interpolator( volume );
CellByCellSampling::GridSampler<T> sampler( &interpolator, &density_map );
KVS_OMP_FOR( reduction(+:N) )
for ( kvs::UInt32 z = 0; z < ncells.z(); ++z )
{
size_t cell_index_counter = z * ncells.x() * ncells.y();
for ( kvs::UInt32 y = 0; y < ncells.y(); ++y )
{
for ( kvs::UInt32 x = 0; x < ncells.x(); ++x )
{
sampler.bind( kvs::Vec3ui( x, y, z ) );
const size_t n = sampler.numberOfParticles();
const kvs::UInt32 index = cell_index_counter++;
nparticles[index] = n;
N += n;
}
}
}
}
// Genrate a set of particles.
const kvs::UInt32 repetitions = m_repetition_level;
CellByCellSampling::ColoredParticles particles( color_map );
particles.allocate( N * repetitions );
/*
kvs::ValueArray<kvs::Real32> coords( 3 * N * repetitions );
kvs::ValueArray<kvs::Real32> normals( 3 * N * repetitions );
kvs::ValueArray<kvs::UInt8> colors( 3 * N * repetitions );
*/
KVS_OMP_PARALLEL()
{
kvs::TrilinearInterpolator interpolator( volume );
CellByCellSampling::GridSampler<T> sampler( &interpolator, &density_map );
KVS_OMP_FOR( schedule(static) )
for ( kvs::UInt32 r = 0; r < repetitions; ++r )
{
size_t cell_index_counter = 0;
size_t particle_index_counter = N * r;
for ( kvs::UInt32 z = 0; z < ncells.z(); ++z )
{
for ( kvs::UInt32 y = 0; y < ncells.y(); ++y )
{
for ( kvs::UInt32 x = 0; x < ncells.x(); ++x )
{
const kvs::UInt32 index = cell_index_counter++;
const size_t n = nparticles[index];
if ( n == 0 ) continue;
sampler.bind( kvs::Vec3ui( x, y, z ) );
for ( size_t i = 0; i < n; ++i )
{
sampler.sample();
const CellByCellSampling::Particle& p = sampler.accept();
const size_t particle_index = particle_index_counter++;
particles.push( particle_index, p );
/*
const kvs::RGBColor color = color_map.at( p.scalar );
const size_t index3 = ( particle_index_counter++ ) * 3;
coords[ index3 + 0 ] = p.coord.x();
coords[ index3 + 1 ] = p.coord.y();
coords[ index3 + 2 ] = p.coord.z();
normals[ index3 + 0 ] = p.normal.x();
normals[ index3 + 1 ] = p.normal.y();
normals[ index3 + 2 ] = p.normal.z();
colors[ index3 + 0 ] = color.r();
colors[ index3 + 1 ] = color.g();
colors[ index3 + 2 ] = color.b();
*/
}
}
}
}
}
}
SuperClass::setCoords( particles.coords() );
SuperClass::setColors( particles.colors() );
SuperClass::setNormals( particles.normals() );
SuperClass::setSize( 1.0f );
}
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()
{
typedef agg::pixfmt_bgr24 pixfmt;
typedef agg::renderer_base<pixfmt> renderer_base;
pixfmt pixf(rbuf_window());
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(-initial_width()/2, -initial_height()/2);
src_mtx *= agg::trans_affine_rotation(10.0 * agg::pi / 180.0);
src_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2);
src_mtx *= trans_affine_resizing();
agg::trans_affine img_mtx = src_mtx;
img_mtx.invert();
typedef agg::span_allocator<agg::rgba8> span_alloc;
unsigned i;
unsigned char brightness_alpha_array[agg::span_conv_brightness_alpha_rgb8::array_size];
for(i = 0; i < agg::span_conv_brightness_alpha_rgb8::array_size; i++)
{
brightness_alpha_array[i] =
agg::int8u(m_alpha.value(double(i) /
double(agg::span_conv_brightness_alpha_rgb8::array_size)) * 255.0);
}
agg::span_conv_brightness_alpha_rgb8 color_alpha(brightness_alpha_array);
typedef agg::image_accessor_clip<pixfmt> img_source_type;
typedef agg::span_interpolator_linear<> interpolator_type;
typedef agg::span_image_filter_rgb_bilinear<img_source_type,
interpolator_type> span_gen;
typedef agg::span_converter<span_gen,
agg::span_conv_brightness_alpha_rgb8> span_conv;
span_alloc sa;
interpolator_type interpolator(img_mtx);
pixfmt img_pixf(rbuf_img(0));
img_source_type img_src(img_pixf, agg::rgba(0,0,0,0));
span_gen sg(img_src, interpolator);
span_conv sc(sg, color_alpha);
agg::ellipse ell;
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
for(i = 0; i < 50; i++)
{
ell.init(m_x[i], m_y[i], m_rx[i], m_ry[i], 50);
ras.add_path(ell);
agg::render_scanlines_aa_solid(ras, sl, rb, m_colors[i]);
}
ell.init(initial_width() / 2.0,
initial_height() / 2.0,
initial_width() / 1.9,
initial_height() / 1.9, 200);
agg::conv_transform<agg::ellipse> tr(ell, src_mtx);
ras.add_path(tr);
agg::render_scanlines_aa(ras, sl, rb, sa, sc);
agg::render_ctrl(ras, sl, rb, m_alpha);
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
{
scalarField samples(4);
samples[0] = 0;
samples[1] = 1;
samples[2] = 2;
samples[3] = 3;
scalarField values(4);
values = 1.0;
//values[0] = 0.0;
//values[1] = 1.0;
//linearInterpolationWeights interpolator
splineInterpolationWeights interpolator
(
samples
);
labelList indices;
scalarField weights;
interpolator.integrationWeights(1.1, 1.2, indices, weights);
Pout<< "indices:" << indices << endl;
Pout<< "weights:" << weights << endl;
scalar baseSum = interpolator.weightedSum
(
weights,
UIndirectList<scalar>(values, indices)
);
Pout<< "baseSum=" << baseSum << nl << nl << endl;
// interpolator.integrationWeights(-0.01, 0, indices, weights);
// scalar partialSum = interpolator.weightedSum
// (
// weights,
// UIndirectList<scalar>(values, indices)
// );
// Pout<< "partialSum=" << partialSum << nl << nl << endl;
//
//
// interpolator.integrationWeights(-0.01, 1, indices, weights);
// //Pout<< "samples:" << samples << endl;
// //Pout<< "indices:" << indices << endl;
// //Pout<< "weights:" << weights << endl;
// scalar sum = interpolator.weightedSum
// (
// weights,
// UIndirectList<scalar>(values, indices)
// );
// Pout<< "integrand=" << sum << nl << nl << endl;
return 1;
}
IOdictionary dataEntryProperties
(
IOobject
(
"dataEntryProperties",
runTime.constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
autoPtr<DataEntry<scalar> > dataEntry
(
DataEntry<scalar>::New
(
"dataEntry",
dataEntryProperties
)
);
scalar x0 = readScalar(dataEntryProperties.lookup("x0"));
scalar x1 = readScalar(dataEntryProperties.lookup("x1"));
Info<< "Data entry type: " << dataEntry().type() << nl << endl;
Info<< "Inputs" << nl
<< " x0 = " << x0 << nl
<< " x1 = " << x1 << nl
<< endl;
Info<< "Interpolation" << nl
<< " f(x0) = " << dataEntry().value(x0) << nl
<< " f(x1) = " << dataEntry().value(x1) << nl
<< endl;
Info<< "Integration" << nl
<< " int(f(x)) lim(x0->x1) = " << dataEntry().integrate(x0, x1) << nl
<< endl;
return 0;
}
Py::Object
Image::resize(const Py::Tuple& args) {
_VERBOSE("Image::resize");
args.verify_length(2);
if (bufferIn ==NULL)
throw Py::RuntimeError("You must first load the image");
int numcols = Py::Int(args[0]);
int numrows = Py::Int(args[1]);
colsOut = numcols;
rowsOut = numrows;
size_t NUMBYTES(numrows * numcols * BPP);
agg::int8u *buffer = new agg::int8u[NUMBYTES];
if (buffer ==NULL) //todo: also handle allocation throw
throw Py::MemoryError("Image::resize could not allocate memory");
rbufOut = new agg::rendering_buffer;
rbufOut->attach(buffer, numcols, numrows, numcols * BPP);
// init the output rendering/rasterizing stuff
pixfmt pixf(*rbufOut);
renderer_base rb(pixf);
rb.clear(bg);
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
//srcMatrix *= resizingMatrix;
//imageMatrix *= resizingMatrix;
imageMatrix.invert();
interpolator_type interpolator(imageMatrix);
agg::image_filter_base* filter = 0;
agg::span_allocator<agg::rgba8> sa;
agg::rgba8 background(agg::rgba8(int(255*bg.r),
int(255*bg.g),
int(255*bg.b),
int(255*bg.a)));
// the image path
agg::path_storage path;
agg::int8u *bufferPad = NULL;
agg::rendering_buffer rbufPad;
double x0, y0, x1, y1;
if (interpolation==NEAREST) {
x0 = 0.0;
x1 = colsIn;
y0 = 0.0;
y1 = rowsIn;
}
else {
// if interpolation != nearest, create a new input buffer with the
// edges mirrored on all size. Then new buffer size is colsIn+2 by
// rowsIn+2
x0 = 1.0;
x1 = colsIn+1;
y0 = 1.0;
y1 = rowsIn+1;
bufferPad = new agg::int8u[(rowsIn+2) * (colsIn+2) * BPP];
if (bufferPad ==NULL)
throw Py::MemoryError("Image::resize could not allocate memory");
//pad the input buffer
for (size_t rowNum=0; rowNum<rowsIn+2; rowNum++)
for (size_t colNum=0; colNum<colsIn+2; colNum++) {
if ( (colNum==0) && (rowNum==1||(rowNum==rowsIn+1))) {
//rewind to begining of column
bufferIn -= colsIn * BPP;
}
*bufferPad++ = *bufferIn++; //red
*bufferPad++ = *bufferIn++; //green
*bufferPad++ = *bufferIn++; //blue
*bufferPad++ = *bufferIn++; //alpha
//rewind one byte on the first and next to last columns
if ( colNum==0 || colNum==colsIn) bufferIn-=4;
}
//rewind the input buffers
bufferIn -= rowsIn * colsIn * BPP;
bufferPad -= (rowsIn+2) * (colsIn+2) * BPP;
rbufPad.attach(bufferPad, colsIn+2, rowsIn+2, (colsIn+2) * BPP);
}
if (buffer ==NULL) //todo: also handle allocation throw
throw Py::MemoryError("Image::resize could not allocate memory");
path.move_to(x0, y0);
path.line_to(x1, y0);
path.line_to(x1, y1);
path.line_to(x0, y1);
path.close_polygon();
agg::conv_transform<agg::path_storage> imageBox(path, srcMatrix);
ras.add_path(imageBox);
switch(interpolation)
{
case NEAREST:
{
typedef agg::span_image_filter_rgba32_nn<agg::order_rgba32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type;
span_gen_type sg(sa, *rbufIn, background, interpolator);
renderer_type ri(rb, sg);
agg::render_scanlines(ras, sl, ri);
}
break;
case BILINEAR:
{
typedef agg::span_image_filter_rgba32_bilinear<agg::order_rgba32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type;
span_gen_type sg(sa, rbufPad, background, interpolator);
renderer_type ri(rb, sg);
agg::render_scanlines(ras, sl, ri);
}
break;
case BICUBIC: filter = new agg::image_filter<agg::image_filter_bicubic>;
case SPLINE16: filter = new agg::image_filter<agg::image_filter_spline16>;
case SPLINE36: filter = new agg::image_filter<agg::image_filter_spline36>;
case SINC64: filter = new agg::image_filter<agg::image_filter_sinc64>;
case SINC144: filter = new agg::image_filter<agg::image_filter_sinc144>;
case SINC256: filter = new agg::image_filter<agg::image_filter_sinc256>;
case BLACKMAN64: filter = new agg::image_filter<agg::image_filter_blackman64>;
case BLACKMAN100: filter = new agg::image_filter<agg::image_filter_blackman100>;
case BLACKMAN256: filter = new agg::image_filter<agg::image_filter_blackman256>;
typedef agg::span_image_filter_rgba32<agg::order_rgba32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type;
span_gen_type sg(sa, rbufPad, background, interpolator, *filter);
renderer_type ri(rb, sg);
agg::render_scanlines(ras, sl, ri);
}
/*
std::ofstream of2( "image_out.raw", std::ios::binary|std::ios::out);
for (size_t i=0; i<NUMBYTES; ++i)
of2.write((char*)&buffer[i], sizeof(char));
*/
bufferOut = buffer;
delete [] bufferPad;
return Py::Object();
}
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);
}
Py::Object
Image::resize(const Py::Tuple& args) {
_VERBOSE("Image::resize");
args.verify_length(2);
if (bufferIn ==NULL)
throw Py::RuntimeError("You must first load the image");
int numcols = Py::Int(args[0]);
int numrows = Py::Int(args[1]);
colsOut = numcols;
rowsOut = numrows;
size_t NUMBYTES(numrows * numcols * BPP);
agg::int8u *buffer = new agg::int8u[NUMBYTES];
if (buffer ==NULL) //todo: also handle allocation throw
throw Py::MemoryError("Image::resize could not allocate memory");
rbufOut = new agg::rendering_buffer;
rbufOut->attach(buffer, numcols, numrows, numcols * BPP);
// init the output rendering/rasterizing stuff
pixfmt pixf(*rbufOut);
renderer_base rb(pixf);
rb.clear(bg);
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
//srcMatrix *= resizingMatrix;
//imageMatrix *= resizingMatrix;
imageMatrix.invert();
interpolator_type interpolator(imageMatrix);
// the image path
agg::path_storage path;
path.move_to(0, 0);
path.line_to(colsIn, 0);
path.line_to(colsIn, rowsIn);
path.line_to(0, rowsIn);
path.close_polygon();
agg::conv_transform<agg::path_storage> imageBox(path, srcMatrix);
ras.add_path(imageBox);
agg::image_filter_base* filter = 0;
agg::span_allocator<agg::rgba8> sa;
switch(interpolation)
{
case NEAREST:
{
typedef agg::span_image_filter_rgba32_nn<agg::order_rgba32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_u<renderer_base, span_gen_type> renderer_type;
span_gen_type sg(sa, *rbufIn, agg::rgba(1,1,1,0), interpolator);
renderer_type ri(rb, sg);
ras.add_path(imageBox);
ras.render(sl, ri);
}
break;
case BILINEAR:
{
typedef agg::span_image_filter_rgba32_bilinear<agg::order_rgba32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_u<renderer_base, span_gen_type> renderer_type;
span_gen_type sg(sa, *rbufIn, agg::rgba(1,1,1,0), interpolator);
renderer_type ri(rb, sg);
ras.add_path(imageBox);
ras.render(sl, ri);
}
break;
case BICUBIC:
filter = new agg::image_filter<agg::image_filter_bicubic>;
case SPLINE16:
filter = new agg::image_filter<agg::image_filter_spline16>;
case SPLINE36:
filter = new agg::image_filter<agg::image_filter_spline36>;
case SINC64:
filter = new agg::image_filter<agg::image_filter_sinc64>;
case SINC144:
filter = new agg::image_filter<agg::image_filter_sinc144>;
case SINC256:
filter = new agg::image_filter<agg::image_filter_sinc256>;
case BLACKMAN64:
filter = new agg::image_filter<agg::image_filter_blackman64>;
case BLACKMAN100:
filter = new agg::image_filter<agg::image_filter_blackman100>;
case BLACKMAN256:
filter = new agg::image_filter<agg::image_filter_blackman256>;
typedef agg::span_image_filter_rgba32<agg::order_rgba32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_u<renderer_base, span_gen_type> renderer_type;
span_gen_type sg(sa, *rbufIn, agg::rgba(1,1,1,0), interpolator, *filter);
renderer_type ri(rb, sg);
ras.render(sl, ri);
}
/*
std::ofstream of2( "image_out.raw", std::ios::binary|std::ios::out);
for (size_t i=0; i<NUMBYTES; ++i)
of2.write((char*)&buffer[i], sizeof(char));
*/
bufferOut = buffer;
return Py::Object();
}
int main()
{
// Create model from sample Predicted Parameterized Times
// (from cycle accurate simulator or real machine)
EventInterpolator interpolator(CYCLE_TIMES_FILE, KEEP_RATIO);
int totalProcs, numX, numY, numZ, numCth, numWth, numPes;
double ratio_sum=0.0;
unsigned long ratio_count= 0;
double ratio_bracketed_sum=0.0;
unsigned long ratio_bracketed_count = 0;
double old_times_sum=0.0;
double old_bracketed_times_sum=0.0;
double new_bracketed_times_sum=0.0;
ofstream of_ratio_all("ratio_all");
ofstream of_ratio_bracketed("ratio_bracketed");
interpolator.printCoefficients();
// load bg trace summary file
printf("Loading bgTrace ... \n");
int status = BgLoadTraceSummary("bgTrace", totalProcs, numX, numY, numZ, numCth, numWth, numPes);
if (status == -1) exit(1);
printf("========= BgLog Version: %d ========= \n", bglog_version);
printf("Found %d (%dx%dx%d:%dw-%dc) emulated procs on %d real procs.\n", totalProcs, numX, numY, numZ, numWth, numCth, numPes);
int* allNodeOffsets = BgLoadOffsets(totalProcs,numPes);
printf("========= Loading All Logs ========= \n");
// load each individual trace file for each bg proc
unsigned found_event_count=0;
unsigned total_count=0;
bool negative_durations_occured = false;
printf("Loading bgTrace files ...\n");
// Create output directory
mkdir(OUTPUTDIR, 0777);
int numNodes = totalProcs / numWth;
for (int fileNum=0; fileNum<numPes; fileNum++){
BgTimeLineRec *tlinerecs = new BgTimeLineRec[totalProcs/numPes+1];
int rec_count = 0;
//for(int procNum=fileNum;procNum<totalProcs;procNum+=numPes){
for (int nodeNum=fileNum;nodeNum<numNodes;nodeNum+=numPes) {
for (int procNum=nodeNum*numWth; procNum<(nodeNum+1)*numWth; procNum++) {
BgTimeLineRec &tlinerec = tlinerecs[rec_count];
rec_count++;
currTline = &tlinerec;
currTlineIdx = procNum;
int fileNum = BgReadProc(procNum,numWth,numPes,totalProcs,allNodeOffsets,tlinerec);
CmiAssert(fileNum != -1);
#ifdef DEBUG
printf("Load log of BG proc %d from bgTrace%d... \n", procNum, fileNum);
#endif
BgTimeLine &timeLine = tlinerec.timeline; // Really a CkQ< BgTimeLog *>
#ifdef DEBUG
printf("%d entries in timeLine\n", timeLine.length());
#endif
// Scan through each event for this emulated processor
for(int j=0;j<timeLine.length();j++){
BgTimeLog* timeLog = timeLine[j];
std::string name(timeLog->name);
total_count++;
double old_start = timeLog->startTime;
double old_end = timeLog->endTime;
double old_duration = old_end-old_start;
double old_bracket_start=0.0;
double old_bracket_end=0.0;
int have_bracket_start=0;
int have_bracket_end=0;
double begin_piece=0.0;
double middle_piece=old_duration;
double end_piece=0.0;
assert(old_duration >= 0.0);
assert(old_end >= 0.0);
if(old_end > old_start){
old_times_sum += old_duration;
//FIXME: check only the right kind of events.
// Look for BG_EVENT_PRINT 'events' inside this event.
for(int i=0;i<timeLog->evts.length();i++){
char *data = (char*)timeLog->evts[i]->data;
if(strncmp(data,"startTraceBigSim",16)==0){
old_bracket_start = old_start+timeLog->evts[i]->rTime;
have_bracket_start = 1;
}
else if(strncmp(data,"endTraceBigSim",14)==0){
old_bracket_end = old_start+timeLog->evts[i]->rTime;
have_bracket_end = 1;
}
}
// If we have bracketed timings, the middle part will be the old
// bracketed time region, and the begin and end pieces will be non-zero
if(have_bracket_end && have_bracket_start){
begin_piece = old_bracket_start - old_start;
middle_piece = old_bracket_end - old_bracket_start;
end_piece = old_duration - begin_piece - middle_piece;
old_bracketed_times_sum += middle_piece;
assert(begin_piece >= 0.0);
assert(middle_piece >= 0.0);
assert(end_piece >= 0.0);
}
else{
old_bracket_start = old_start;
old_bracket_end = old_end;
assert(old_bracket_end - old_bracket_start >= 0.0);
}
// If this event occurs in the paramerter file and cycle-accurate simulations, use that data to predict its runtime
if( interpolator.haveNewTiming(procNum,timeLog->seqno) ) {
double old_middle_piece = middle_piece;
// GAGAN : Making it directly based on the model
//middle_piece = interpolator.getNewTiming(procNum,timeLog->seqno) * sec_per_cycle;
middle_piece = interpolator.getNewTiming(procNum,timeLog->seqno);
found_event_count ++;
double ratio = old_middle_piece / middle_piece;
if(ratio > 1e-10 && ratio < 1e10){
ratio_bracketed_sum += ratio;
ratio_bracketed_count ++;
of_ratio_bracketed << ratio << endl;
}
// cout<<" used interpolation tool"<<endl;
}
// If event is not in parameter file then we just scale its duration by a simple constant
else {
// cout<<" used time dilation for "<< procNum <<" "<< timeLog->seqno<<endl;
middle_piece = middle_piece*time_dilation_factor ;
}
if(middle_piece < 0.0) {
middle_piece=0.0;
negative_durations_occured=true;
}
if(have_bracket_end && have_bracket_start){
new_bracketed_times_sum += middle_piece;
}
// Scale the begin and end pieces by time_dilation_factor;
begin_piece = begin_piece*time_dilation_factor;
end_piece = end_piece*time_dilation_factor;
assert(begin_piece >= 0.0);
assert(middle_piece >= 0.0);
assert(end_piece >= 0.0);
double new_start = old_start;
double new_duration = begin_piece + middle_piece + end_piece;
double new_end = new_start + new_duration;
timeLog->startTime = new_start;
timeLog->endTime = new_end;
timeLog->execTime = new_duration;
double new_bracket_start = new_start+begin_piece;
double new_bracket_end = new_start+begin_piece+middle_piece;
#ifdef PRINT_NEW_TIMES
printf("Rewriting duration of event %d name=%s from [%.10lf , %.10lf] (%.10lf) to [%.10lf , %.10lf] (%.10lf) ratio=%.10lf\n", j, timeLog->name, old_start,old_end,old_end-old_start,new_start,new_end,new_end-new_start,(old_end-old_start)/(new_end-new_start));
#endif
double ratio = (old_duration)/(new_duration);
if(ratio >= 1e-10 && ratio <= 1e10){
ratio_sum += ratio;
ratio_count ++;
of_ratio_all << ratio << endl;
}
// Rewrite times of messages sent from this event
for(int m=0;m<timeLog->msgs.length();m++){
double old_send = timeLog->msgs[m]->sendTime;
double new_send, new_recv;
double old_recv;
assert(old_send <= old_end);
assert(old_send >= old_start);
// We have three places where the message is coming from
// We linearly map the value into the beginning, middle, or end piece
if(old_send < old_bracket_start){
new_send = map_linearly_to_interval(old_send, old_start,old_bracket_start,new_start,new_bracket_start);
}
else if(old_send < old_bracket_end){
new_send = map_linearly_to_interval(old_send, old_bracket_start,old_bracket_end,new_bracket_start,new_bracket_end);
}
else {
new_send = map_linearly_to_interval(old_send, old_bracket_end,old_end,new_bracket_end,new_end);
}
timeLog->msgs[m]->sendTime = new_send;
#ifdef PRINT_NEW_TIMES
printf("pe=%d changing message %d send time from %.10lf to %.10lf\n", procNum, m, old_send, new_send);
printf("pe=%d compare %d send time from %.10lf to recv time %.10lf\n", procNum, m, new_send,timeLog->msgs[m]->recvTime );
#endif
old_recv = timeLog->msgs[m]->recvTime ;
new_recv = (old_recv - old_send) + new_send;
timeLog->msgs[m]->recvTime = new_recv;
assert(new_send <= new_end);
assert(new_send >= new_start);
assert(old_recv >= old_send);
if(new_recv < new_send)
{
printf( "Bad case send: %.10f recv: %.10f \n", new_send, new_recv);
}
assert(new_recv >= new_send);
}
}
}
}
}
#ifdef WRITE_OUTPUT_FILES
// Write out the file
cout << "writing " << rec_count << " simulated processors to this bgTrace file" << endl;
BgWriteTimelines(fileNum,tlinerecs,rec_count,OUTPUTDIR);
#endif
delete[] tlinerecs;
}
if(negative_durations_occured){
cerr << "====================== WARNING ======================" << endl;
cerr << "|| One or more new durations were less than zero. \n|| This probably means your model or input times are \n|| not good enough." << endl;
cerr << "======================================================" << endl;
}
interpolator.printMinInterpolatedTimes();
printf("Writing new bgTrace files ...\n");
printf("average duration speedup(including unbracketed pieces): %.8lf\n", ratio_sum / (double)ratio_count);
printf("average bracketed speedup: %.8lf\n", ratio_bracketed_sum / (double)ratio_bracketed_count);
cout << "Sum of times of bracketed portions of input logs: " << old_bracketed_times_sum << endl;
cout << "Sum of times of bracketed portions of output logs: " << new_bracketed_times_sum << endl;
const char* fname = "bgTrace";
#ifdef WRITE_OUTPUT_FILES
// Write out the timelines to the same number of files as we started with.
BgWriteTraceSummary(numPes, numX, numY, numZ, numWth, numCth, fname , OUTPUTDIR);
#endif
delete [] allNodeOffsets;
cout << "Of the " << total_count << " events found in the bgTrace files, " << found_event_count << " were found in the param files" << endl;
interpolator.printMatches();
cout << "The sum of all positive duration events from the original bgTrace files is: " << old_times_sum << endl;
cout << "End of program" << endl;
}
MAPNIK_DECL void warp_image (T & target, T const& source, proj_transform const& prj_trans,
box2d<double> const& target_ext, box2d<double> const& source_ext,
double offset_x, double offset_y, unsigned mesh_size, scaling_method_e scaling_method, double filter_factor)
{
using image_type = T;
using pixel_type = typename image_type::pixel_type;
using pixfmt_pre = typename detail::agg_scaling_traits<image_type>::pixfmt_pre;
using color_type = typename detail::agg_scaling_traits<image_type>::color_type;
using renderer_base = agg::renderer_base<pixfmt_pre>;
using interpolator_type = typename detail::agg_scaling_traits<image_type>::interpolator_type;
constexpr std::size_t pixel_size = sizeof(pixel_type);
view_transform ts(source.width(), source.height(),
source_ext);
view_transform tt(target.width(), target.height(),
target_ext, offset_x, offset_y);
std::size_t mesh_nx = std::ceil(source.width()/double(mesh_size) + 1);
std::size_t mesh_ny = std::ceil(source.height()/double(mesh_size) + 1);
image_gray64f xs(mesh_nx, mesh_ny, false);
image_gray64f ys(mesh_nx, mesh_ny, false);
// Precalculate reprojected mesh
for(std::size_t j = 0; j < mesh_ny; ++j)
{
for (std::size_t i=0; i<mesh_nx; ++i)
{
xs(i,j) = std::min(i*mesh_size,source.width());
ys(i,j) = std::min(j*mesh_size,source.height());
ts.backward(&xs(i,j), &ys(i,j));
}
}
prj_trans.backward(xs.getData(), ys.getData(), nullptr, mesh_nx*mesh_ny);
agg::rasterizer_scanline_aa<> rasterizer;
agg::scanline_bin scanline;
agg::rendering_buffer buf(target.getBytes(),
target.width(),
target.height(),
target.width() * pixel_size);
pixfmt_pre pixf(buf);
renderer_base rb(pixf);
rasterizer.clip_box(0, 0, target.width(), target.height());
agg::rendering_buffer buf_tile(
const_cast<unsigned char*>(source.getBytes()),
source.width(),
source.height(),
source.width() * pixel_size);
pixfmt_pre pixf_tile(buf_tile);
using img_accessor_type = agg::image_accessor_clone<pixfmt_pre>;
img_accessor_type ia(pixf_tile);
agg::span_allocator<color_type> sa;
// Project mesh cells into target interpolating raster inside each one
for (std::size_t j = 0; j < mesh_ny - 1; ++j)
{
for (std::size_t i = 0; i < mesh_nx - 1; ++i)
{
double polygon[8] = {xs(i,j), ys(i,j),
xs(i+1,j), ys(i+1,j),
xs(i+1,j+1), ys(i+1,j+1),
xs(i,j+1), ys(i,j+1)};
tt.forward(polygon+0, polygon+1);
tt.forward(polygon+2, polygon+3);
tt.forward(polygon+4, polygon+5);
tt.forward(polygon+6, polygon+7);
rasterizer.reset();
rasterizer.move_to_d(std::floor(polygon[0]), std::floor(polygon[1]));
rasterizer.line_to_d(std::floor(polygon[2]), std::floor(polygon[3]));
rasterizer.line_to_d(std::floor(polygon[4]), std::floor(polygon[5]));
rasterizer.line_to_d(std::floor(polygon[6]), std::floor(polygon[7]));
std::size_t x0 = i * mesh_size;
std::size_t y0 = j * mesh_size;
std::size_t x1 = (i+1) * mesh_size;
std::size_t y1 = (j+1) * mesh_size;
x1 = std::min(x1, source.width());
y1 = std::min(y1, source.height());
agg::trans_affine tr(polygon, x0, y0, x1, y1);
if (tr.is_valid())
{
interpolator_type interpolator(tr);
if (scaling_method == SCALING_NEAR)
{
using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_filter;
span_gen_type sg(ia, interpolator);
agg::render_scanlines_bin(rasterizer, scanline, rb, sa, sg);
}
else
{
using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_resample_affine;
agg::image_filter_lut filter;
detail::set_scaling_method(filter, scaling_method, filter_factor);
span_gen_type sg(ia, interpolator, filter);
agg::render_scanlines_bin(rasterizer, scanline, rb, sa, sg);
}
}
}
}
}
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;
}
}
void reproject_and_scale_raster(raster & target, raster const& source,
proj_transform const& prj_trans,
double offset_x, double offset_y,
unsigned mesh_size,
double filter_radius,
scaling_method_e scaling_method)
{
CoordTransform ts(source.data_.width(), source.data_.height(),
source.ext_);
CoordTransform tt(target.data_.width(), target.data_.height(),
target.ext_, offset_x, offset_y);
unsigned i, j;
unsigned mesh_nx = ceil(source.data_.width()/double(mesh_size)+1);
unsigned mesh_ny = ceil(source.data_.height()/double(mesh_size)+1);
ImageData<double> xs(mesh_nx, mesh_ny);
ImageData<double> ys(mesh_nx, mesh_ny);
// Precalculate reprojected mesh
for(j=0; j<mesh_ny; j++) {
for (i=0; i<mesh_nx; i++) {
xs(i,j) = i*mesh_size;
ys(i,j) = j*mesh_size;
ts.backward(&xs(i,j), &ys(i,j));
}
}
prj_trans.backward(xs.getData(), ys.getData(), NULL, mesh_nx*mesh_ny);
// Initialize AGG objects
typedef agg::pixfmt_rgba32 pixfmt;
typedef pixfmt::color_type color_type;
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::pixfmt_rgba32_pre pixfmt_pre;
typedef agg::renderer_base<pixfmt_pre> renderer_base_pre;
agg::rasterizer_scanline_aa<> rasterizer;
agg::scanline_u8 scanline;
agg::rendering_buffer buf((unsigned char*)target.data_.getData(),
target.data_.width(),
target.data_.height(),
target.data_.width()*4);
pixfmt_pre pixf_pre(buf);
renderer_base_pre rb_pre(pixf_pre);
rasterizer.clip_box(0, 0, target.data_.width(), target.data_.height());
agg::rendering_buffer buf_tile(
(unsigned char*)source.data_.getData(),
source.data_.width(),
source.data_.height(),
source.data_.width() * 4);
pixfmt pixf_tile(buf_tile);
typedef agg::image_accessor_clone<pixfmt> img_accessor_type;
img_accessor_type ia(pixf_tile);
agg::span_allocator<color_type> sa;
// Initialize filter
agg::image_filter_lut filter;
switch(scaling_method)
{
case SCALING_NEAR: break;
case SCALING_BILINEAR8: // TODO - impl this or remove?
case SCALING_BILINEAR:
filter.calculate(agg::image_filter_bilinear(), true); break;
case SCALING_BICUBIC:
filter.calculate(agg::image_filter_bicubic(), true); break;
case SCALING_SPLINE16:
filter.calculate(agg::image_filter_spline16(), true); break;
case SCALING_SPLINE36:
filter.calculate(agg::image_filter_spline36(), true); break;
case SCALING_HANNING:
filter.calculate(agg::image_filter_hanning(), true); break;
case SCALING_HAMMING:
filter.calculate(agg::image_filter_hamming(), true); break;
case SCALING_HERMITE:
filter.calculate(agg::image_filter_hermite(), true); break;
case SCALING_KAISER:
filter.calculate(agg::image_filter_kaiser(), true); break;
case SCALING_QUADRIC:
filter.calculate(agg::image_filter_quadric(), true); break;
case SCALING_CATROM:
filter.calculate(agg::image_filter_catrom(), true); break;
case SCALING_GAUSSIAN:
filter.calculate(agg::image_filter_gaussian(), true); break;
case SCALING_BESSEL:
filter.calculate(agg::image_filter_bessel(), true); break;
case SCALING_MITCHELL:
filter.calculate(agg::image_filter_mitchell(), true); break;
case SCALING_SINC:
filter.calculate(agg::image_filter_sinc(filter_radius), true); break;
case SCALING_LANCZOS:
filter.calculate(agg::image_filter_lanczos(filter_radius), true); break;
case SCALING_BLACKMAN:
filter.calculate(agg::image_filter_blackman(filter_radius), true); break;
}
// Project mesh cells into target interpolating raster inside each one
for(j=0; j<mesh_ny-1; j++) {
for (i=0; i<mesh_nx-1; i++) {
double polygon[8] = {xs(i,j), ys(i,j),
xs(i+1,j), ys(i+1,j),
xs(i+1,j+1), ys(i+1,j+1),
xs(i,j+1), ys(i,j+1)};
tt.forward(polygon+0, polygon+1);
tt.forward(polygon+2, polygon+3);
tt.forward(polygon+4, polygon+5);
tt.forward(polygon+6, polygon+7);
rasterizer.reset();
rasterizer.move_to_d(polygon[0]-1, polygon[1]-1);
rasterizer.line_to_d(polygon[2]+1, polygon[3]-1);
rasterizer.line_to_d(polygon[4]+1, polygon[5]+1);
rasterizer.line_to_d(polygon[6]-1, polygon[7]+1);
unsigned x0 = i * mesh_size;
unsigned y0 = j * mesh_size;
unsigned x1 = (i+1) * mesh_size;
unsigned y1 = (j+1) * mesh_size;
agg::trans_affine tr(polygon, x0, y0, x1, y1);
if (tr.is_valid())
{
typedef agg::span_interpolator_linear<agg::trans_affine>
interpolator_type;
interpolator_type interpolator(tr);
if (scaling_method == SCALING_NEAR) {
typedef agg::span_image_filter_rgba_nn
<img_accessor_type, interpolator_type>
span_gen_type;
span_gen_type sg(ia, interpolator);
agg::render_scanlines_aa(rasterizer, scanline, rb_pre,
sa, sg);
} else {
typedef mapnik::span_image_resample_rgba_affine
<img_accessor_type> span_gen_type;
span_gen_type sg(ia, interpolator, filter);
agg::render_scanlines_aa(rasterizer, scanline, rb_pre,
sa, sg);
}
}
}
}
}
Ephemeris* PlatformPosition::Interpolate(JSDDateTime date)
{
const double JOURCIVIL_LENGTH = 86400.0 ;
Ephemeris* ephem = NULL;
if (_nbrData<=1)
{
std::cout << "a..." << std::endl;
ephem = NULL;
}
else
{
/*
* The first element of the list is cloned to ensure that the output ephemeris is expressed in the same coordinate system as input ones
*/
ephem = _data[0]->Clone();
/* NORMAL CASE */
/*------------*/
double * x = new double[_nbrData];
double * y = new double[_nbrData];
double * yd = new double[_nbrData];
double dt = 0.0;
//double d;
x[0] = 0.0 ;
for (int i = 1 ; i < _nbrData ; i++)
{
x[i] = (_data[i]->get_date().get_day0hTU().get_julianDate() - _data[0]->get_date().get_day0hTU().get_julianDate())
* JOURCIVIL_LENGTH
+ _data[i]->get_date().get_second() - _data[0]->get_date().get_second()
+ _data[i]->get_date().get_decimal() - _data[0]->get_date().get_decimal();
}
if (ephem != NULL)
{
ephem->set_date(date);
dt = (date.get_day0hTU().get_julianDate() - _data[0]->get_date().get_day0hTU().get_julianDate()) * JOURCIVIL_LENGTH
+ date.get_second() - _data[0]->get_date().get_second()
+ date.get_decimal() - _data[0]->get_date().get_decimal();
/* Computation by Everett */
/*---------------------*/
double pos[3];
double vit[3];
for (int j = 0 ; j < 3 ; j++)
{
for (int i = 0 ; i < _nbrData ; i++)
{
y[i] = _data[i]->get_position()[j] ;
yd[i] = _data[i]->get_vitesse()[j] ;
}
HermiteInterpolator interpolator(_nbrData,x,y,yd);
interpolator.Interpolate(dt, pos[j], vit[j]);
}
ephem->set_position(pos);
ephem->set_vitesse(vit);
}
delete[] x;
delete[] y;
delete[] yd;
}
return ephem;
}
void CellByCellMetropolisSampling::generate_particles( const kvs::StructuredVolumeObject* volume )
{
kvs::TrilinearInterpolator interpolator( volume );
kvs::CellByCellSampling::ParticleDensityMap density_map;
density_map.setSamplingStep( m_sampling_step );
density_map.setSubpixelLevel( m_subpixel_level );
density_map.attachCamera( m_camera );
density_map.attachObject( volume );
density_map.create( BaseClass::transferFunction().opacityMap() );
// Generate particles for each cell.
kvs::CellByCellSampling::GridSampler<T> sampler( &interpolator, &density_map );
const kvs::Vec3ui ncells( volume->resolution() - kvs::Vec3ui::All(1) );
const kvs::ColorMap color_map( BaseClass::transferFunction().colorMap() );
for ( kvs::UInt32 z = 0; z < ncells.z(); ++z )
{
for ( kvs::UInt32 y = 0; y < ncells.y(); ++y )
{
for ( kvs::UInt32 x = 0; x < ncells.x(); ++x )
{
sampler.bind( kvs::Vec3ui( x, y, z ) );
const size_t nparticles = sampler.numberOfParticles();
const size_t max_loops = nparticles * 10;
if ( nparticles == 0 ) continue;
size_t nduplications = 0;
size_t counter = 0;
kvs::Real32 density = sampler.sample( max_loops );
while ( counter < nparticles )
{
// Trial point.
const kvs::Real32 density_trial = sampler.trySample();
const kvs::Real32 ratio = density_trial / density;
if ( ratio >= 1.0f )
{
sampler.acceptTrial( color_map );
density = density_trial;
counter++;
}
else
{
if ( ratio >= kvs::CellByCellSampling::RandomNumber() )
{
sampler.acceptTrial( color_map );
density = density_trial;
counter++;
}
else
{
#ifdef DUPLICATION
sampler.accept( color_map );
counter++;
#else
if ( ++nduplications > max_loops ) { break; }
#endif
}
}
} // end of 'paricle' while-loop
} // end of 'x' loop
} // end of 'y' loop
} // end of 'z' loop
SuperClass::setCoords( sampler.particles().coords() );
SuperClass::setColors( sampler.particles().colors() );
SuperClass::setNormals( sampler.particles().normals() );
SuperClass::setSize( 1.0f );
}
void scale_image_agg(T & target, T const& source, scaling_method_e scaling_method,
double image_ratio_x, double image_ratio_y, double x_off_f, double y_off_f,
double filter_factor)
{
// "the image filters should work namely in the premultiplied color space"
// http://old.nabble.com/Re:--AGG--Basic-image-transformations-p1110665.html
// "Yes, you need to use premultiplied images only. Only in this case the simple weighted averaging works correctly in the image fitering."
// http://permalink.gmane.org/gmane.comp.graphics.agg/3443
using image_type = T;
using pixel_type = typename image_type::pixel_type;
using pixfmt_pre = typename detail::agg_scaling_traits<image_type>::pixfmt_pre;
using color_type = typename detail::agg_scaling_traits<image_type>::color_type;
using img_src_type = typename detail::agg_scaling_traits<image_type>::img_src_type;
using interpolator_type = typename detail::agg_scaling_traits<image_type>::interpolator_type;
using renderer_base_pre = agg::renderer_base<pixfmt_pre>;
constexpr std::size_t pixel_size = sizeof(pixel_type);
// define some stuff we'll use soon
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::span_allocator<color_type> sa;
// initialize source AGG buffer
agg::rendering_buffer rbuf_src(const_cast<unsigned char*>(source.bytes()),
source.width(), source.height(), source.width() * pixel_size);
pixfmt_pre pixf_src(rbuf_src);
img_src_type img_src(pixf_src);
// initialize destination AGG buffer (with transparency)
agg::rendering_buffer rbuf_dst(target.bytes(), target.width(), target.height(), target.width() * pixel_size);
pixfmt_pre pixf_dst(rbuf_dst);
renderer_base_pre rb_dst_pre(pixf_dst);
// create a scaling matrix
agg::trans_affine img_mtx;
img_mtx /= agg::trans_affine_scaling(image_ratio_x, image_ratio_y);
// create a linear interpolator for our scaling matrix
interpolator_type interpolator(img_mtx);
// draw an anticlockwise polygon to render our image into
double scaled_width = target.width();
double scaled_height = target.height();
ras.reset();
ras.move_to_d(x_off_f, y_off_f);
ras.line_to_d(x_off_f + scaled_width, y_off_f);
ras.line_to_d(x_off_f + scaled_width, y_off_f + scaled_height);
ras.line_to_d(x_off_f, y_off_f + scaled_height);
if (scaling_method == SCALING_NEAR)
{
using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_filter;
span_gen_type sg(img_src, interpolator);
agg::render_scanlines_aa(ras, sl, rb_dst_pre, sa, sg);
}
else
{
using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_resample_affine;
agg::image_filter_lut filter;
detail::set_scaling_method(filter, scaling_method, filter_factor);
span_gen_type sg(img_src, interpolator, filter);
agg::render_scanlines_aa(ras, sl, rb_dst_pre, sa, sg);
}
}
void qAnimationDlg::preview()
{
//we'll take the rendering time into account!
QElapsedTimer timer;
timer.start();
setEnabled(false);
size_t vp1 = previewFromSelectedCheckBox->isChecked() ? static_cast<size_t>(getCurrentStepIndex()) : 0;
//count the total number of frames
int frameCount = countFrames(loopCheckBox->isChecked() ? 0 : vp1);
int fps = fpsSpinBox->value();
//show progress dialog
QProgressDialog progressDialog(QString("Frames: %1").arg(frameCount), "Cancel", 0, frameCount, this);
progressDialog.setWindowTitle("Preview");
progressDialog.show();
progressDialog.setModal(true);
progressDialog.setAutoClose(false);
QApplication::processEvents();
assert(stepSelectionList->count() >= m_videoSteps.size());
int frameIndex = 0;
size_t vp2 = 0;
while (getNextSegment(vp1, vp2))
{
Step& step1 = m_videoSteps[vp1];
Step& step2 = m_videoSteps[vp2];
//theoretical waiting time per frame
qint64 delay_ms = static_cast<int>(1000 * step1.duration_sec / fps);
int frameCount = static_cast<int>( fps * step1.duration_sec );
ViewInterpolate interpolator(step1.viewport, step2.viewport);
interpolator.setMaxStep(frameCount);
cc2DViewportObject currentParams;
while ( interpolator.nextView( currentParams ) )
{
timer.restart();
applyViewport ( ¤tParams );
qint64 dt_ms = timer.elapsed();
progressDialog.setValue(++frameIndex);
QApplication::processEvents();
if (progressDialog.wasCanceled())
{
break;
}
//remaining time
if (dt_ms < delay_ms)
{
int wait_ms = static_cast<int>(delay_ms - dt_ms);
#if defined(CC_WINDOWS)
::Sleep( wait_ms );
#else
usleep( wait_ms * 1000 );
#endif
}
}
if (progressDialog.wasCanceled())
{
break;
}
if (vp2 == 0)
{
assert(loopCheckBox->isChecked());
frameIndex = 0;
}
vp1 = vp2;
}
//reset view
onCurrentStepChanged(getCurrentStepIndex());
setEnabled(true);
}
int main(void)
{
/***READ SCALE FACTOR DATA AND PREPARE OBJECTS FOR INTERPOLATION ***/
int i; //For array manipulation
/*Pointer to scale_factor.data file*/
FILE *frw;
frw = fopen("scale_factor.dat","r");
/*Variables and arrays to read the data*/
double cosmictime[NLINESFRW], conftime, scale_factor[NLINESFRW], der_scale_factor[NLINESFRW];
/*Reading the data*/
for(i=0; i<NLINESFRW; i++)
{
fscanf(frw,"%lf %lf %lf %lf", &cosmictime[i], &conftime, &scale_factor[i], &der_scale_factor[i]);
}
/*Free space in memory*/
fclose(frw);
/*** Initializes objects for interpolation. 1 is for interpolation of scale factor, 2 is for interpolation of derivative of scale factor ***/
/*Allocate space in memory*/
gsl_interp_accel *acc1 = gsl_interp_accel_alloc(); //Acceleration type object (for index lookup)
gsl_interp_accel *acc2 = gsl_interp_accel_alloc();
gsl_spline *spline1 = gsl_spline_alloc(gsl_interp_cspline, NLINESFRW); //Spline type object (define interpolation type and space in memory, works for both)
gsl_spline *spline2 = gsl_spline_alloc(gsl_interp_cspline, NLINESFRW);
/*Initializes objects for interpolation*/
gsl_spline_init(spline1, cosmictime, scale_factor, NLINESFRW); //Initializes spline object for data cosmictime, scale_factor of size NLINES
gsl_spline_init(spline2, cosmictime, der_scale_factor, NLINESFRW); //Initializes spline object for data cosmictime, der_scale_factor of size NLINES
/************************************************************************************/
/***SOLVES GEODESIC EQUATIONS FOR PERTURBED FRW UNIVERSE WITH STATIC PLUMMER POTENTIAL ***/
/*Initial conditions*/
mydbl ti = 7.0 ,x0, r = -500.0, p0 = 1.0e-3, pr, lambda = 0.0, energy1, energy, v, difft, difference;
double difftfrw, aem, aobs;
x0 = C*ti;
aem = interpolator(spline1, (double)(1.0*ti), acc1);
pr = condition_factor(r, aem)*p0;
energy1 = C*energy_factor(r)*p0;
v = violation(r, p0, pr, aem);
difft = (energy1 - energy1)/energy1;
difftfrw = (aem/aem) - 1.0;
difference = difft - (mydbl)(1.0*difftfrw);
/*Pointer to file where solution of differential equation will be saved.*/
FILE *geodesic;
geodesic = fopen("geodesic_solution.dat","w");
/*Write line of initial values in file*/
fprintf(geodesic, "%16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8e %16.8Le\n", lambda, x0, r, p0, pr, energy1, v, difft, difftfrw, difference);
long long int ii;
/*Solution of the differential equation*/
for(ii=0; ii< NSTEPS; ii++)
{
runge_kutta_4(spline1, acc1, spline2, acc2, &x0, &r, &p0, &pr, &lambda);
if((ii%(NSTEPS/NLINES)) == 0)
{
energy = C*energy_factor(r)*p0;
difft = (energy - energy1)/energy1;
ti = x0/C;
aobs = interpolator(spline1, (double)(1.0*ti), acc1);
v = violation(r, p0, pr, aobs);
difftfrw = (aem/aobs) - 1.0;
difference = difft - (mydbl)(1.0*difftfrw);
fprintf(geodesic, "%16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8e %16.8Le\n", lambda, x0, r, p0, pr, energy, v, difft, difftfrw, difference);
}
}
/************************************************************************************/
/*** Releasing all used space in memory ***/
fclose(geodesic); //Close file storing the results
gsl_spline_free(spline1); //Free memory of spline object
gsl_spline_free(spline2);
gsl_interp_accel_free(acc1); //Free memory of accel object
gsl_interp_accel_free(acc2);
}
void render_raster_marker(agg::trans_affine const& marker_tr,
double opacity)
{
using pixfmt_pre = agg::pixfmt_rgba32_pre;
agg::scanline_u8 sl_;
double width = src_.width();
double height = src_.height();
if (std::fabs(1.0 - scale_factor_) < 0.001
&& (std::fabs(1.0 - marker_tr.sx) < agg::affine_epsilon)
&& (std::fabs(0.0 - marker_tr.shy) < agg::affine_epsilon)
&& (std::fabs(0.0 - marker_tr.shx) < agg::affine_epsilon)
&& (std::fabs(1.0 - marker_tr.sy) < agg::affine_epsilon))
{
agg::rendering_buffer src_buffer((unsigned char *)src_.getBytes(),src_.width(),src_.height(),src_.width() * 4);
pixfmt_pre pixf_mask(src_buffer);
if (snap_to_pixels_)
{
renb_.blend_from(pixf_mask,
0,
std::floor(marker_tr.tx + .5),
std::floor(marker_tr.ty + .5),
unsigned(255*opacity));
}
else
{
renb_.blend_from(pixf_mask,
0,
marker_tr.tx,
marker_tr.ty,
unsigned(255*opacity));
}
}
else
{
using img_accessor_type = agg::image_accessor_clone<pixfmt_pre>;
using interpolator_type = agg::span_interpolator_linear<>;
//using span_gen_type = agg::span_image_filter_rgba_2x2<img_accessor_type,interpolator_type>;
using span_gen_type = agg::span_image_resample_rgba_affine<img_accessor_type>;
using renderer_type = agg::renderer_scanline_aa_alpha<renderer_base,
agg::span_allocator<color_type>,
span_gen_type>;
double p[8];
p[0] = 0; p[1] = 0;
p[2] = width; p[3] = 0;
p[4] = width; p[5] = height;
p[6] = 0; p[7] = height;
marker_tr.transform(&p[0], &p[1]);
marker_tr.transform(&p[2], &p[3]);
marker_tr.transform(&p[4], &p[5]);
marker_tr.transform(&p[6], &p[7]);
agg::span_allocator<color_type> sa;
agg::image_filter_lut filter;
filter.calculate(agg::image_filter_bilinear(), true);
agg::rendering_buffer marker_buf((unsigned char *)src_.getBytes(),
src_.width(),
src_.height(),
src_.width()*4);
pixfmt_pre pixf(marker_buf);
img_accessor_type ia(pixf);
agg::trans_affine final_tr(p, 0, 0, width, height);
if (snap_to_pixels_)
{
final_tr.tx = std::floor(final_tr.tx+.5);
final_tr.ty = std::floor(final_tr.ty+.5);
}
interpolator_type interpolator(final_tr);
span_gen_type sg(ia, interpolator, filter);
renderer_type rp(renb_,sa, sg, unsigned(opacity*255));
ras_.move_to_d(p[0],p[1]);
ras_.line_to_d(p[2],p[3]);
ras_.line_to_d(p[4],p[5]);
ras_.line_to_d(p[6],p[7]);
agg::render_scanlines(ras_, sl_, rp);
}
}
virtual void on_draw()
{
pixfmt pixf(rbuf_window());
renderer_base rb(pixf);
rb.clear(agg::rgba(1.0, 1.0, 1.0));
rb.copy_from(rbuf_img(0), 0, 110, 35);
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::rendering_buffer img_rbuf(g_image, 4, 4, 4*4);
double para[] = { 200, 40, 200+300, 40, 200+300, 40+300, 200, 40+300 };
agg::trans_affine img_mtx(para, 0,0,4,4);
typedef agg::span_interpolator_linear<> interpolator_type;
interpolator_type interpolator(img_mtx);
agg::span_allocator<agg::rgba8> sa;
pixfmt img_pixf(img_rbuf);
typedef agg::image_accessor_clone<pixfmt> img_source_type;
img_source_type source(img_pixf);
ras.reset();
ras.move_to_d(para[0], para[1]);
ras.line_to_d(para[2], para[3]);
ras.line_to_d(para[4], para[5]);
ras.line_to_d(para[6], para[7]);
switch(m_filters.cur_item())
{
case 0:
{
typedef agg::span_image_filter_rgba_nn<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(source, interpolator);
agg::render_scanlines_aa(ras, sl, rb, sa, sg);
}
break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
{
agg::image_filter_lut filter;
bool norm = m_normalize.status();
switch(m_filters.cur_item())
{
case 1:
filter.calculate(agg::image_filter_bilinear(), norm);
break;
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 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;
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_rgba<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(source, interpolator, filter);
agg::render_scanlines_aa(ras, sl, rb, sa, sg);
agg::gamma_lut<agg::int8u, agg::int8u, 8, 8> gamma(m_gamma.value());
pixf.apply_gamma_inv(gamma);
double x_start = 5.0;
double x_end = 195.0;
double y_start = 235.0;
double y_end = initial_height() - 5.0;
double x_center = (x_start + x_end) / 2;
agg::path_storage p;
agg::conv_stroke<agg::path_storage> stroke(p);
stroke.width(0.8);
unsigned i;
for(i = 0; i <= 16; i++)
{
double x = x_start + (x_end - x_start) * i / 16.0;
p.remove_all();
p.move_to(x+0.5, y_start);
p.line_to(x+0.5, y_end);
ras.add_path(stroke);
agg::render_scanlines_aa_solid(ras, sl, rb,
agg::rgba8(0, 0, 0, i == 8 ? 255 : 100));
}
double ys = y_start + (y_end - y_start) / 6.0;
p.remove_all();
p.move_to(x_start, ys);
p.line_to(x_end, ys);
ras.add_path(stroke);
agg::render_scanlines_aa_solid(ras, sl, rb, agg::rgba8(0, 0, 0));
double radius = filter.radius();
unsigned n = unsigned(radius * 256 * 2);
double dx = (x_end - x_start) * radius / 8.0;
double dy = y_end - ys;
const agg::int16* weights = filter.weight_array();
double xs = (x_end + x_start)/2.0 - (filter.diameter() * (x_end - x_start) / 32.0);
unsigned nn = filter.diameter() * 256;
p.remove_all();
p.move_to(xs+0.5, ys + dy * weights[0] / agg::image_filter_scale);
for(i = 1; i < nn; i++)
{
p.line_to(xs + dx * i / n + 0.5,
ys + dy * weights[i] / agg::image_filter_scale);
}
ras.add_path(stroke);
agg::render_scanlines_aa_solid(ras, sl, rb, agg::rgba8(100, 0, 0));
}
break;
}
agg::render_ctrl(ras, sl, rb, m_gamma);
if(m_filters.cur_item() >= 14)
{
agg::render_ctrl(ras, sl, rb, m_radius);
}
agg::render_ctrl(ras, sl, rb, m_filters);
agg::render_ctrl(ras, sl, rb, m_normalize);
}
// _DrawBitmap32
void
Painter::_DrawBitmap32(const agg::rendering_buffer& srcBuffer,
BRect actualBitmapRect, BRect bitmapRect, BRect viewRect) const
{
typedef agg::span_allocator<agg::rgba8> span_alloc_type;
typedef agg::span_interpolator_linear<> interpolator_type;
typedef agg::span_image_filter_rgba32_nn<agg::order_bgra32,
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> image_renderer_type;
if (bitmapRect.IsValid() && bitmapRect.Intersects(actualBitmapRect)
&& viewRect.IsValid()) {
// compensate for the lefttop offset the actualBitmapRect might have
// NOTE: I have no clue why enabling the next call gives a wrong result!
// According to the BeBook, bitmapRect is supposed to be in native
// bitmap space!
// bitmapRect.OffsetBy(-actualBitmapRect.left, -actualBitmapRect.top);
actualBitmapRect.OffsetBy(-actualBitmapRect.left, -actualBitmapRect.top);
// calculate the scaling
double xScale = (viewRect.Width() + 1) / (bitmapRect.Width() + 1);
double yScale = (viewRect.Height() + 1) / (bitmapRect.Height() + 1);
// constrain rect to passed bitmap bounds
// and transfer the changes to the viewRect
if (bitmapRect.left < actualBitmapRect.left) {
float diff = actualBitmapRect.left - bitmapRect.left;
viewRect.left += diff * xScale;
bitmapRect.left = actualBitmapRect.left;
}
if (bitmapRect.top < actualBitmapRect.top) {
float diff = actualBitmapRect.top - bitmapRect.top;
viewRect.top += diff;
bitmapRect.top = actualBitmapRect.top;
}
if (bitmapRect.right > actualBitmapRect.right) {
float diff = bitmapRect.right - actualBitmapRect.right;
viewRect.right -= diff;
bitmapRect.right = actualBitmapRect.right;
}
if (bitmapRect.bottom > actualBitmapRect.bottom) {
float diff = bitmapRect.right - actualBitmapRect.bottom;
viewRect.bottom -= diff;
bitmapRect.bottom = actualBitmapRect.bottom;
}
float xOffset = viewRect.left - (bitmapRect.left * xScale);
float yOffset = viewRect.top - (bitmapRect.top * yScale);
agg::trans_affine srcMatrix;
// srcMatrix *= agg::trans_affine_translation(-actualBitmapRect.left, -actualBitmapRect.top);
srcMatrix *= agg::trans_affine_scaling(fScale, fScale);
srcMatrix *= agg::trans_affine_translation(fOrigin.x, fOrigin.y);
agg::trans_affine imgMatrix;
imgMatrix *= agg::trans_affine_scaling(xScale, yScale);
imgMatrix *= agg::trans_affine_translation(xOffset, yOffset);
imgMatrix *= agg::trans_affine_scaling(fScale, fScale);
imgMatrix *= agg::trans_affine_translation(fOrigin.x, fOrigin.y);
imgMatrix.invert();
span_alloc_type sa;
interpolator_type interpolator(imgMatrix);
span_gen_type sg(sa, srcBuffer, agg::rgba(0, 0, 0, 0), interpolator);
image_renderer_type ri(*fBaseRenderer, sg);
agg::rasterizer_scanline_aa<> pf;
agg::scanline_u8 sl;
// path encloses image
agg::path_storage path;
path.move_to(viewRect.left, viewRect.top);
path.line_to(viewRect.right + 1, viewRect.top);
path.line_to(viewRect.right + 1, viewRect.bottom + 1);
path.line_to(viewRect.left, viewRect.bottom + 1);
path.close_polygon();
agg::conv_transform<agg::path_storage> tr(path, srcMatrix);
pf.add_path(tr);
agg::render_scanlines(pf, sl, ri);
}
}
void qAnimationDlg::render()
{
if (!m_view3d)
{
assert(false);
return;
}
QString outputFilename = outputFileLineEdit->text();
//save to persistent settings
{
QSettings settings;
settings.beginGroup("qAnimation");
settings.setValue("filename", outputFilename);
settings.endGroup();
}
setEnabled(false);
//count the total number of frames
int frameCount = countFrames(0);
int fps = fpsSpinBox->value();
int superRes = superResolutionSpinBox->value();
//show progress dialog
QProgressDialog progressDialog(QString("Frames: %1").arg(frameCount), "Cancel", 0, frameCount, this);
progressDialog.setWindowTitle("Render");
progressDialog.show();
QApplication::processEvents();
#ifdef QFFMPEG_SUPPORT
//get original viewport size
QSize originalViewSize = m_view3d->size();
//hack: as the encoder requires that the video dimensions are multiples of 8, we resize the window a little bit...
{
//find the nearest multiples of 8
QSize customSize = originalViewSize;
if (originalViewSize.width() % 8 || originalViewSize.height() % 8)
{
if (originalViewSize.width() % 8)
customSize.setWidth((originalViewSize.width() / 8 + 1) * 8);
if (originalViewSize.height() % 8)
customSize.setHeight((originalViewSize.height() / 8 + 1) * 8);
m_view3d->resize(customSize);
QApplication::processEvents();
}
}
int bitrate = bitrateSpinBox->value() * 1024;
int gop = fps;
QVideoEncoder encoder(outputFilename, m_view3d->width(), m_view3d->height(), bitrate, gop, static_cast<unsigned>(fpsSpinBox->value()));
QString errorString;
if (!encoder.open(&errorString))
{
QMessageBox::critical(this, "Error", QString("Failed to open file for output: %1").arg(errorString));
setEnabled(true);
return;
}
#endif
bool lodWasEnabled = m_view3d->isLODEnabled();
m_view3d->setLODEnabled(false);
int frameIndex = 0;
bool success = true;
size_t vp1 = 0, vp2 = 0;
while (getNextSegment(vp1, vp2))
{
Step& step1 = m_videoSteps[vp1];
Step& step2 = m_videoSteps[vp2];
ViewInterpolate interpolator(step1.viewport, step2.viewport);
int frameCount = static_cast<int>( fps * step1.duration_sec );
interpolator.setMaxStep(frameCount);
cc2DViewportObject current_params;
while ( interpolator.nextView( current_params ) )
{
applyViewport ( ¤t_params );
//render to image
QImage image = m_view3d->renderToImage(superRes, false, false, true );
if (image.isNull())
{
QMessageBox::critical(this, "Error", "Failed to grab the screen!");
success = false;
break;
}
if (superRes > 1)
{
image = image.scaled(image.width()/superRes, image.height()/superRes, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}
#ifdef QFFMPEG_SUPPORT
if (!encoder.encodeImage(image, frameIndex, &errorString))
{
QMessageBox::critical(this, "Error", QString("Failed to encode frame #%1: %2").arg(frameIndex+1).arg(errorString));
success = false;
break;
}
#else
QString filename = QString("frame_%1.png").arg(frameIndex, 6, 10, QChar('0'));
QString fullPath = QDir(outputFilename).filePath(filename);
if (!image.save(fullPath))
{
QMessageBox::critical(this, "Error", QString("Failed to save frame #%1").arg(frameIndex+1));
success = false;
break;
}
#endif
++frameIndex;
progressDialog.setValue(frameIndex);
QApplication::processEvents();
if (progressDialog.wasCanceled())
{
QMessageBox::warning(this, "Warning", QString("Process has been cancelled"));
success = false;
break;
}
}
if (!success)
{
break;
}
if (vp2 == 0)
{
//stop loop here!
break;
}
vp1 = vp2;
}
m_view3d->setLODEnabled(lodWasEnabled);
#ifdef QFFMPEG_SUPPORT
encoder.close();
//hack: restore original size
m_view3d->resize(originalViewSize);
QApplication::processEvents();
#endif
progressDialog.hide();
QApplication::processEvents();
if (success)
{
QMessageBox::information(this, "Job done", "The animation has been saved successfully");
}
setEnabled(true);
}
//------------------------------------------------------------------------
virtual void on_draw() {
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid;
pixfmt pixf(rbuf_window());
pixfmt pixf_img(rbuf_img(0));
renderer_base rb(pixf);
renderer_solid rs(rb);
rb.clear(agg::rgba(1.0, 1.0, 1.0));
agg::trans_affine image_mtx;
agg::trans_affine polygon_mtx;
polygon_mtx *= agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy);
polygon_mtx *=
agg::trans_affine_rotation(m_polygon_angle.value() * agg::pi / 180.0);
polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
polygon_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
switch (m_example.cur_item()) {
default:
case 0:
// --------------(Example 0, Identity matrix)
break;
case 1:
// --------------(Example 1)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
image_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
image_mtx.invert();
break;
case 2:
// --------------(Example 2)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_translation(m_image_cx, m_image_cy);
image_mtx.invert();
break;
case 3:
// --------------(Example 3)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
image_mtx.invert();
break;
case 4:
// --------------(Example 4)
image_mtx *= agg::trans_affine_translation(-m_image_cx, -m_image_cy);
image_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
image_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
image_mtx.invert();
break;
case 5:
// --------------(Example 5)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
image_mtx *= agg::trans_affine_translation(m_image_cx, m_image_cy);
image_mtx.invert();
break;
case 6:
// --------------(Example 6)
image_mtx *= agg::trans_affine_translation(-m_image_cx, -m_image_cy);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_translation(m_image_cx, m_image_cy);
image_mtx.invert();
break;
}
typedef agg::span_interpolator_linear<> interpolator_type;
interpolator_type interpolator(image_mtx);
agg::span_allocator<color_type> sa;
// "hardcoded" bilinear filter
//------------------------------------------
typedef agg::span_image_filter_rgba_bilinear_clip<pixfmt, interpolator_type>
span_gen_type;
span_gen_type sg(pixf_img, agg::rgba(1, 1, 1), interpolator);
//------------------------------------------
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::path_storage ps;
create_star(ps);
agg::conv_transform<agg::path_storage> tr(ps, polygon_mtx);
ras.add_path(tr);
agg::render_scanlines_aa(ras, sl, rb, sa, sg);
agg::ellipse e1(m_image_cx, m_image_cy, 5, 5, 20);
agg::ellipse e2(m_image_cx, m_image_cy, 2, 2, 20);
agg::conv_stroke<agg::ellipse> c1(e1);
rs.color(agg::rgba(0.7, 0.8, 0));
ras.add_path(e1);
agg::render_scanlines(ras, sl, rs);
rs.color(agg::rgba(0, 0, 0));
ras.add_path(c1);
agg::render_scanlines(ras, sl, rs);
ras.add_path(e2);
agg::render_scanlines(ras, sl, rs);
agg::render_ctrl(ras, sl, rb, m_polygon_angle);
agg::render_ctrl(ras, sl, rb, m_polygon_scale);
agg::render_ctrl(ras, sl, rb, m_image_angle);
agg::render_ctrl(ras, sl, rb, m_image_scale);
agg::render_ctrl(ras, sl, rb, m_rotate_polygon);
agg::render_ctrl(ras, sl, rb, m_rotate_image);
agg::render_ctrl(ras, sl, rb, m_example);
}