void grid_renderer<T>::render_marker(Feature const& feature, unsigned int step, const int x, const int y, marker &marker, const agg::trans_affine & tr, double opacity)
{
if (marker.is_vector())
{
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::renderer_base<mapnik::pixfmt_gray16> ren_base;
typedef agg::renderer_scanline_bin_solid<ren_base> renderer;
agg::scanline_bin sl;
grid_rendering_buffer buf(pixmap_.raw_data(), width_, height_, width_);
mapnik::pixfmt_gray16 pixf(buf);
ren_base renb(pixf);
renderer ren(renb);
ras_ptr->reset();
box2d<double> const& bbox = (*marker.get_vector_data())->bounding_box();
coord<double,2> c = bbox.center();
// center the svg marker on '0,0'
agg::trans_affine mtx = agg::trans_affine_translation(-c.x,-c.y);
// apply symbol transformation to get to map space
mtx *= tr;
mtx *= agg::trans_affine_scaling(scale_factor_*(1.0/step));
// render the marker at the center of the marker box
mtx.translate(x+0.5 * marker.width(), y+0.5 * marker.height());
vertex_stl_adapter<svg_path_storage> stl_storage((*marker.get_vector_data())->source());
svg_path_adapter svg_path(stl_storage);
svg_renderer<svg_path_adapter,
agg::pod_bvector<path_attributes>,
renderer,
mapnik::pixfmt_gray16> svg_renderer(svg_path,
(*marker.get_vector_data())->attributes());
svg_renderer.render_id(*ras_ptr, sl, renb, feature.id(), mtx, opacity, bbox);
}
else
{
image_data_32 const& data = **marker.get_bitmap_data();
if (step == 1 && scale_factor_ == 1.0)
{
pixmap_.set_rectangle(feature.id(), data, x, y);
}
else
{
double ratio = (1.0/step);
image_data_32 target(ratio * data.width(), ratio * data.height());
mapnik::scale_image_agg<image_data_32>(target,data, SCALING_NEAR,
scale_factor_, 0.0, 0.0, 1.0, ratio);
pixmap_.set_rectangle(feature.id(), target, x, y);
}
}
pixmap_.add_feature(feature);
}
void BaseTestReadOnly::testRead() {
File file = File::open("test_read_only.h5", FileMode::ReadOnly);
Section section = file.getSection(section_id);
Block block = file.getBlock(block_id);
DataArray data_array = block.getDataArray(data_array_id);
Dimension dim = data_array.getDimension(dim_index);
SampledDimension dim_sampled = data_array.getDimension(dim_sampled_index).asSampledDimension();
RangeDimension dim_range = data_array.getDimension(dim_range_index).asRangeDimension();
SetDimension dim_set = data_array.getDimension(dim_set_index).asSetDimension();
Tag tag = block.getTag(tag_id);
MultiTag mtag = block.getMultiTag(mtag_id);
Feature feature = tag.getFeature(feature_id);
Property property = section.getProperty(property_id);
// TODO use assertions here
s << block.id() << block.name();
s << data_array.id() << data_array.name();
s << tag.id() << tag.name();
s << mtag.id() << mtag.name();
s << feature.id();
s << property.id() << property.name();
s << dim.index();
s << dim_sampled.index();
s << dim_range.index();
s << dim_set.index();
file.close();
}
void BaseTestReadOnly::init(nix::File &file) {
startup_time = time(NULL);
std::vector<nix::Value> values = { nix::Value(1.0),
nix::Value(2.0),
nix::Value(-99.99) };
std::vector<double> ticks = {1.0, 2.0, 3.4, 42.0};
Section section = file.createSection("foo_section", "metadata");
Block block = file.createBlock("block_one", "dataset");
DataArray positions = block.createDataArray("positions_DataArray", "dataArray",
DataType::Double, NDSize({ 0, 0 }));
DataArray data_array = block.createDataArray("array_one",
"testdata",
nix::DataType::Double,
nix::NDSize({ 0, 0, 0 }));
Dimension dim = data_array.appendSampledDimension(3.14);
SampledDimension dim_sampled = data_array.appendSampledDimension(3.14);
RangeDimension dim_range = data_array.appendRangeDimension(ticks);
SetDimension dim_set = data_array.appendSetDimension();
Tag tag = block.createTag("featureTest", "Test", {0.0, 2.0, 3.4});
MultiTag mtag = block.createMultiTag("tag_one", "test_tag", positions);
Feature feature = tag.createFeature(data_array, nix::LinkType::Tagged);
Property property = section.createProperty("doubleProperty", values);
section_id = section.id(); feature_id = feature.id(); tag_id = tag.id();
mtag_id = mtag.id(); property_id = property.id(); block_id = block.id();
data_array_id = data_array.id(); dim_index = dim.index();
dim_sampled_index = dim_sampled.index(); dim_range_index = dim_range.index();
dim_set_index = dim_set.index();
file.close();
}
bool Tag::deleteFeature(const Feature &feature) {
if (feature == none) {
throw std::runtime_error("Tag::deleteFeature: Empty Feature entity given!");
}
return backend()->deleteFeature(feature.id());
}
bool Tag::hasFeature(const Feature &feature) const {
if (feature == none) {
throw std::runtime_error("Tag::hasFeature: Empty DataArray entity given!");
}
return backend()->hasFeature(feature.id());
}
void grid_renderer<T>::process(line_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::renderer_base<mapnik::pixfmt_gray16> ren_base;
typedef agg::renderer_scanline_bin_solid<ren_base> renderer;
agg::scanline_bin sl;
grid_rendering_buffer buf(pixmap_.raw_data(), width_, height_, width_);
mapnik::pixfmt_gray16 pixf(buf);
ren_base renb(pixf);
renderer ren(renb);
ras_ptr->reset();
stroke const& stroke_ = sym.get_stroke();
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 1)
{
path_type path(t_,geom,prj_trans);
if (stroke_.has_dash())
{
agg::conv_dash<path_type> dash(path);
dash_array const& d = stroke_.get_dash_array();
dash_array::const_iterator itr = d.begin();
dash_array::const_iterator end = d.end();
for (;itr != end;++itr)
{
dash.add_dash(itr->first * scale_factor_,
itr->second * scale_factor_);
}
agg::conv_stroke<agg::conv_dash<path_type > > stroke(dash);
line_join_e join=stroke_.get_line_join();
if ( join == MITER_JOIN)
stroke.generator().line_join(agg::miter_join);
else if( join == MITER_REVERT_JOIN)
stroke.generator().line_join(agg::miter_join);
else if( join == ROUND_JOIN)
stroke.generator().line_join(agg::round_join);
else
stroke.generator().line_join(agg::bevel_join);
line_cap_e cap=stroke_.get_line_cap();
if (cap == BUTT_CAP)
stroke.generator().line_cap(agg::butt_cap);
else if (cap == SQUARE_CAP)
stroke.generator().line_cap(agg::square_cap);
else
stroke.generator().line_cap(agg::round_cap);
stroke.generator().miter_limit(4.0);
stroke.generator().width(stroke_.get_width() * scale_factor_);
ras_ptr->add_path(stroke);
}
else
{
agg::conv_stroke<path_type> stroke(path);
line_join_e join=stroke_.get_line_join();
if ( join == MITER_JOIN)
stroke.generator().line_join(agg::miter_join);
else if( join == MITER_REVERT_JOIN)
stroke.generator().line_join(agg::miter_join);
else if( join == ROUND_JOIN)
stroke.generator().line_join(agg::round_join);
else
stroke.generator().line_join(agg::bevel_join);
line_cap_e cap=stroke_.get_line_cap();
if (cap == BUTT_CAP)
stroke.generator().line_cap(agg::butt_cap);
else if (cap == SQUARE_CAP)
stroke.generator().line_cap(agg::square_cap);
else
stroke.generator().line_cap(agg::round_cap);
stroke.generator().miter_limit(4.0);
stroke.generator().width(stroke_.get_width() * scale_factor_);
ras_ptr->add_path(stroke);
}
}
}
// render id
ren.color(mapnik::gray16(feature.id()));
agg::render_scanlines(*ras_ptr, sl, ren);
// add feature properties to grid cache
pixmap_.add_feature(feature);
}
bool Tag::hasFeature(const Feature &feature) const {
if (!util::checkEntityInput(feature, false)) {
return false;
}
return backend()->hasFeature(feature.id());
}
bool MultiTag::hasFeature(const Feature &feature) const {
util::checkEntityInput(feature);
return backend()->hasFeature(feature.id());
}
bool MultiTag::deleteFeature(const Feature &feature) {
util::checkEntityInput(feature);
return backend()->deleteFeature(feature.id());
}
void grid_renderer<T>::process(text_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry_type> path_type;
bool placement_found = false;
text_placement_info_ptr placement_options = sym.get_placement_options()->get_placement_info();
while (!placement_found && placement_options->next())
{
expression_ptr name_expr = sym.get_name();
if (!name_expr) return;
value_type result = boost::apply_visitor(evaluate<Feature,value_type>(feature),*name_expr);
UnicodeString text = result.to_unicode();
if ( sym.get_text_transform() == UPPERCASE)
{
text = text.toUpper();
}
else if ( sym.get_text_transform() == LOWERCASE)
{
text = text.toLower();
}
else if ( sym.get_text_transform() == CAPITALIZE)
{
text = text.toTitle(NULL);
}
if ( text.length() <= 0 ) continue;
color const& fill = sym.get_fill();
face_set_ptr faces;
if (sym.get_fontset().size() > 0)
{
faces = font_manager_.get_face_set(sym.get_fontset());
}
else
{
faces = font_manager_.get_face_set(sym.get_face_name());
}
stroker_ptr strk = font_manager_.get_stroker();
if (!(faces->size() > 0 && strk))
{
throw config_error("Unable to find specified font face '" + sym.get_face_name() + "'");
}
text_renderer<T> ren(pixmap_, faces, *strk);
ren.set_pixel_size(placement_options->text_size * (scale_factor_ * (1.0/pixmap_.get_resolution())));
ren.set_fill(fill);
ren.set_halo_fill(sym.get_halo_fill());
ren.set_halo_radius(sym.get_halo_radius() * scale_factor_);
ren.set_opacity(sym.get_text_opacity());
// /pixmap_.get_resolution() ?
box2d<double> dims(0,0,width_,height_);
placement_finder<label_collision_detector4> finder(detector_,dims);
string_info info(text);
faces->get_string_info(info);
unsigned num_geom = feature.num_geometries();
for (unsigned i=0; i<num_geom; ++i)
{
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() == 0) continue; // don't bother with empty geometries
while (!placement_found && placement_options->next_position_only())
{
placement text_placement(info, sym, scale_factor_);
text_placement.avoid_edges = sym.get_avoid_edges();
if (sym.get_label_placement() == POINT_PLACEMENT ||
sym.get_label_placement() == INTERIOR_PLACEMENT)
{
double label_x, label_y, z=0.0;
if (sym.get_label_placement() == POINT_PLACEMENT)
geom.label_position(&label_x, &label_y);
else
geom.label_interior_position(&label_x, &label_y);
prj_trans.backward(label_x,label_y, z);
t_.forward(&label_x,&label_y);
double angle = 0.0;
expression_ptr angle_expr = sym.get_orientation();
if (angle_expr)
{
// apply rotation
value_type result = boost::apply_visitor(evaluate<Feature,value_type>(feature),*angle_expr);
angle = result.to_double();
}
finder.find_point_placement(text_placement, placement_options,
label_x, label_y,
angle, sym.get_line_spacing(),
sym.get_character_spacing());
finder.update_detector(text_placement);
}
else if ( geom.num_points() > 1 && sym.get_label_placement() == LINE_PLACEMENT)
{
path_type path(t_,geom,prj_trans);
finder.find_line_placements<path_type>(text_placement, placement_options, path);
}
if (!text_placement.placements.size()) continue;
placement_found = true;
for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ii)
{
double x = text_placement.placements[ii].starting_x;
double y = text_placement.placements[ii].starting_y;
ren.prepare_glyphs(&text_placement.placements[ii]);
ren.render_id(feature.id(),x,y,2);
}
}
}
}
if (placement_found)
pixmap_.add_feature(feature);
}
