void setup_label_transform(agg::trans_affine & tr, box2d<double> const& bbox, mapnik::feature_impl const& feature, T const& sym)
{
double width = 0;
double height = 0;
expression_ptr const& width_expr = sym.get_width();
if (width_expr)
width = boost::apply_visitor(evaluate<Feature,value_type>(feature), *width_expr).to_double();
expression_ptr const& height_expr = sym.get_height();
if (height_expr)
height = boost::apply_visitor(evaluate<Feature,value_type>(feature), *height_expr).to_double();
if (width > 0 && height > 0)
{
double sx = width/bbox.width();
double sy = height/bbox.height();
tr *= agg::trans_affine_scaling(sx,sy);
}
else if (width > 0)
{
double sx = width/bbox.width();
tr *= agg::trans_affine_scaling(sx);
}
else if (height > 0)
{
double sy = height/bbox.height();
tr *= agg::trans_affine_scaling(sy);
}
else
{
evaluate_transform(tr, feature, sym.get_image_transform());
}
}
view_transform(int _width, int _height, box2d<double> const& _extent,
double _offset_x = 0.0, double _offset_y = 0.0)
: width_(_width),
height_(_height),
extent_(_extent),
sx_(extent_.width() > 0 ? static_cast<double>(width_) / extent_.width() : 1.0),
sy_(extent_.height() > 0 ? static_cast<double>(height_) / extent_.height() : 1.0),
offset_x_(_offset_x),
offset_y_(_offset_y),
offset_(0) {}
void grid_renderer<T>::start_layer_processing(layer const& lay, box2d<double> const& query_extent)
{
MAPNIK_LOG_DEBUG(grid_renderer) << "grid_renderer: Start processing layer=" << lay.name();
MAPNIK_LOG_DEBUG(grid_renderer) << "grid_renderer: datasource=" << lay.datasource().get();
MAPNIK_LOG_DEBUG(grid_renderer) << "grid_renderer: query_extent = " << query_extent;
if (lay.clear_label_cache())
{
detector_->clear();
}
query_extent_ = query_extent;
int buffer_size = lay.buffer_size();
if (buffer_size != 0 )
{
double padding = buffer_size * (double)(query_extent.width()/pixmap_.width());
double x0 = query_extent_.minx();
double y0 = query_extent_.miny();
double x1 = query_extent_.maxx();
double y1 = query_extent_.maxy();
query_extent_.init(x0 - padding, y0 - padding, x1 + padding , y1 + padding);
}
boost::optional<box2d<double> > const& maximum_extent = lay.maximum_extent();
if (maximum_extent)
{
query_extent_.clip(*maximum_extent);
}
}
bool clip_line(T& x0,T& y0,T& x1,T& y1,box2d<T> const& box)
{
double tmin=0.0;
double tmax=1.0;
double dx=x1-x0;
if (clip_test<double>(-dx,x0,tmin,tmax))
{
if (clip_test<double>(dx,box.width()-x0,tmin,tmax))
{
double dy=y1-y0;
if (clip_test<double>(-dy,y0,tmin,tmax))
{
if (clip_test<double>(dy,box.height()-y0,tmin,tmax))
{
if (tmax<1.0)
{
x1=static_cast<T>(x0+tmax*dx);
y1=static_cast<T>(y0+tmax*dy);
}
if (tmin>0.0)
{
x0+=static_cast<T>(tmin*dx);
y0+=static_cast<T>(tmin*dy);
}
return true;
}
}
}
}
return false;
}
void envelope_points(std::vector< coord<double,2> > & coords, box2d<double>& env, int points)
{
double width = env.width();
double height = env.height();
int steps;
if (points <= 4) {
steps = 0;
} else {
steps = static_cast<int>(std::ceil((points - 4) / 4.0));
}
steps += 1;
double xstep = width / steps;
double ystep = height / steps;
for (int i=0; i<=steps; i++) {
coords.push_back(coord<double,2>(env.minx() + i * xstep, env.miny()));
coords.push_back(coord<double,2>(env.minx() + i * xstep, env.maxy()));
}
for (int i=1; i<steps; i++) {
coords.push_back(coord<double,2>(env.minx(), env.miny() + i * ystep));
coords.push_back(coord<double,2>(env.maxx(), env.miny() + i * ystep));
}
}
tiled_multi_file_policy(std::string const& file_pattern,
std::string const& format,
unsigned tile_size,
box2d<double> extent,
box2d<double> bbox,
unsigned width,
unsigned height,
unsigned tile_stride)
: image_width_(width),
image_height_(height),
tile_size_(tile_size),
tile_stride_(tile_stride)
{
double lox = extent.minx();
double loy = extent.miny();
//int max_x = int(std::ceil(double(width) / double(tile_size)));
//int max_y = int(std::ceil(double(height) / double(tile_size)));
double pixel_x = extent.width() / double(width);
double pixel_y = extent.height() / double(height);
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: PIXEL SIZE("<< pixel_x << "," << pixel_y << ")" << std::endl;
#endif
// intersection of query with extent => new query
box2d<double> e = bbox.intersect(extent);
const int x_min = int(std::floor((e.minx() - lox) / (tile_size * pixel_x)));
const int y_min = int(std::floor((e.miny() - loy) / (tile_size * pixel_y)));
const int x_max = int(std::ceil((e.maxx() - lox) / (tile_size * pixel_x)));
const int y_max = int(std::ceil((e.maxy() - loy) / (tile_size * pixel_y)));
for (int x = x_min; x < x_max; ++x)
{
for (int y = y_min; y < y_max; ++y)
{
// x0, y0, x1, y1 => projection-space image coordinates.
double x0 = lox + x*tile_size*pixel_x;
double y0 = loy + y*tile_size*pixel_y;
double x1 = x0 + tile_size*pixel_x;
double y1 = y0 + tile_size*pixel_y;
// check if it intersects the query
if (e.intersects(box2d<double>(x0,y0,x1,y1)))
{
// tile_box => intersection of tile with query in projection-space.
box2d<double> tile_box = e.intersect(box2d<double>(x0,y0,x1,y1));
std::string file = interpolate(file_pattern, x, y);
raster_info info(file,format,tile_box,tile_size,tile_size);
infos_.push_back(info);
}
}
}
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: INFO SIZE=" << infos_.size() << " " << file_pattern << std::endl;
#endif
}
agg::trans_affine transform(box2d<double> & bbox) const
{
bbox *= image_tr_;
coord<double, 2> c = bbox.center();
agg::trans_affine mtx = agg::trans_affine_translation(
0.5 * bbox.width() - c.x,
0.5 * bbox.height() - c.y);
return image_tr_ * mtx;
}
void split_box(box2d<double> const& node_extent,box2d<double> * ext)
{
double width=node_extent.width();
double height=node_extent.height();
double lox=node_extent.minx();
double loy=node_extent.miny();
double hix=node_extent.maxx();
double hiy=node_extent.maxy();
ext[0]=box2d<double>(lox,loy,lox + width * ratio_,loy + height * ratio_);
ext[1]=box2d<double>(hix - width * ratio_,loy,hix,loy + height * ratio_);
ext[2]=box2d<double>(lox,hiy - height*ratio_,lox + width * ratio_,hiy);
ext[3]=box2d<double>(hix - width * ratio_,hiy - height*ratio_,hix,hiy);
}
coord<unsigned, 2> offset(Sym const & sym,
mapnik::feature_impl const & feature,
proj_transform const & prj_trans,
renderer_common const & common,
box2d<double> const & clip_box)
{
coord<unsigned, 2> off(0, 0);
pattern_alignment_enum alignment = get<pattern_alignment_enum, keys::alignment>(sym, feature, common.vars_);
if (alignment == LOCAL_ALIGNMENT)
{
coord<double, 2> alignment(0, 0);
apply_local_alignment apply(common.t_, prj_trans, clip_box, alignment.x, alignment.y);
util::apply_visitor(geometry::vertex_processor<apply_local_alignment>(apply), feature.get_geometry());
off.x = std::abs(clip_box.width() - alignment.x);
off.y = std::abs(clip_box.height() - alignment.y);
}
return off;
}
tiled_file_policy(std::string const& file,
std::string const& format,
unsigned tile_size,
box2d<double> extent,
box2d<double> bbox,
unsigned width,
unsigned height)
{
double lox = extent.minx();
double loy = extent.miny();
int max_x = int(std::ceil(double(width) / double(tile_size)));
int max_y = int(std::ceil(double(height) / double(tile_size)));
double pixel_x = extent.width() / double(width);
double pixel_y = extent.height() / double(height);
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: PIXEL SIZE("<< pixel_x << "," << pixel_y << ")" << std::endl;
#endif
box2d<double> e = bbox.intersect(extent);
for (int x = 0; x < max_x; ++x)
{
for (int y = 0; y < max_y; ++y)
{
double x0 = lox + x * tile_size * pixel_x;
double y0 = loy + y * tile_size * pixel_y;
double x1 = x0 + tile_size * pixel_x;
double y1 = y0 + tile_size * pixel_y;
if (e.intersects(box2d<double>(x0, y0, x1, y1)))
{
box2d<double> tile_box = e.intersect(box2d<double>(x0,y0,x1,y1));
raster_info info(file,format,tile_box,tile_size,tile_size);
infos_.push_back(info);
}
}
}
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: INFO SIZE=" << infos_.size() << " " << file << std::endl;
#endif
}
image_gray8 create_bitmap(box2d<T> box)
{
if (!box.valid())
{
return image_gray8(0, 0);
}
try
{
return image_gray8(box.width(), box.height());
}
catch (std::runtime_error const & e)
{
// TODO: Scale down in this case.
MAPNIK_LOG_ERROR(grid_vertex_adapter) << "grid vertex adapter: Cannot allocate underlaying bitmap. Bbox: "
<< box.to_string() << "; " << e.what();
return image_gray8(0, 0);
}
}
grid_vertex_adapter(PathType & path, T dx, T dy, box2d<T> box)
: dx_(dx), dy_(dy),
img_(create_bitmap(box)),
vt_(img_.width(), img_.height(), box),
si_(box.width() / dx, box.height() / dy)
{
transform_path<PathType, coord_type, view_transform> tp(path, vt_);
tp.rewind(0);
agg::rasterizer_scanline_aa<> ras;
ras.add_path(tp);
agg::rendering_buffer buf(img_.data(), img_.width(), img_.height(), img_.row_size());
agg::pixfmt_gray8 pixfmt(buf);
using renderer_base = agg::renderer_base<agg::pixfmt_gray8>;
using renderer_bin = agg::renderer_scanline_bin_solid<renderer_base>;
renderer_base rb(pixfmt);
renderer_bin ren_bin(rb);
ren_bin.color(agg::gray8(1));
agg::scanline_bin sl_bin;
agg::render_scanlines(ras, sl_bin, ren_bin);
}
bool proj_transform::forward(box2d<double>& env, int points) const
{
if (is_source_equal_dest_)
return true;
std::vector<coord<double,2> > coords;
envelope_points(coords, env, points);
double z;
for (std::vector<coord<double,2> >::iterator it = coords.begin(); it!=coords.end(); ++it) {
z = 0;
if (!forward(it->x, it->y, z)) {
return false;
}
}
box2d<double> result = calculate_bbox(coords);
env.re_center(result.center().x, result.center().y);
env.height(result.height());
env.width(result.width());
return true;
}