double paramList::getDouble(unsigned int const paramNumber, double const minimum, double const maximum) const { if (paramNumber >= this->paramVector.size()) throw(fault("Not enough parameters", fault::CODE_TYPE)); if (this->paramVector[paramNumber].type() != value::TYPE_DOUBLE) throw(fault("Parameter that is supposed to be floating point number " "is not", fault::CODE_TYPE)); double const doublevalue(static_cast<double>( value_double(this->paramVector[paramNumber]))); if (doublevalue < minimum) throw(fault("Floating point number parameter too low", fault::CODE_TYPE)); if (doublevalue > maximum) throw(fault("Floating point number parameter too high", fault::CODE_TYPE)); return doublevalue; }
bool text_placement_info_simple::next() const { while (true) { if (state > 0) { if (state > text_sizes_.size()) return false; properties.format_defaults.text_size = value_double(text_sizes_[state-1]); } if (!next_position_only()) { ++state; position_state = 0; } else break; } return true; }
void produce_csv_value_csv(void *csv_metadata, const char *s, size_t len) { struct csv_metadata *c = (struct csv_metadata *)csv_metadata; readstat_variable_t *var = &c->variables[c->columns]; int is_date = c->is_date[c->columns]; int obs_index = c->rows - 1; // TODO: ??? readstat_value_t value; if (len == 0) { value = value_sysmiss(s, len, c); } else if (is_date) { value = value_string(s, len, c); } else if (var->type == READSTAT_TYPE_DOUBLE) { value = value_double(s, len, c); } else if (var->type == READSTAT_TYPE_STRING) { value = value_string(s, len, c); } else { fprintf(stderr, "%s:%d unsupported variable type %d\n", __FILE__, __LINE__, var->type); exit(EXIT_FAILURE); } c->handle.value(obs_index, var, value, c->user_ctx); }
void grid_renderer<T>::process(line_pattern_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { std::string filename = get<std::string>(sym, keys::file, feature, common_.vars_); if (filename.empty()) return; boost::optional<mapnik::marker_ptr> mark = marker_cache::instance().find(filename, true); if (!mark) return; if (!(*mark)->is_bitmap()) { MAPNIK_LOG_DEBUG(agg_renderer) << "agg_renderer: Only images (not '" << filename << "') are supported in the line_pattern_symbolizer"; return; } boost::optional<image_ptr> pat = (*mark)->get_bitmap_data(); if (!pat) return; bool clip = get<value_bool>(sym, keys::clip, feature, common_.vars_, true); double offset = get<value_double>(sym, keys::offset, feature, common_.vars_, 0.0); double simplify_tolerance = get<value_double>(sym, keys::simplify_tolerance, feature, common_.vars_, 0.0); double smooth = get<value_double>(sym, keys::smooth, feature, common_.vars_, false); typedef typename grid_renderer_base_type::pixfmt_type pixfmt_type; typedef typename grid_renderer_base_type::pixfmt_type::color_type color_type; typedef agg::renderer_scanline_bin_solid<grid_renderer_base_type> renderer_type; typedef boost::mpl::vector<clip_line_tag, transform_tag, offset_transform_tag, affine_transform_tag, simplify_tag, smooth_tag, stroke_tag> conv_types; agg::scanline_bin sl; grid_rendering_buffer buf(pixmap_.raw_data(), common_.width_, common_.height_, common_.width_); pixfmt_type pixf(buf); grid_renderer_base_type renb(pixf); renderer_type ren(renb); ras_ptr->reset(); int stroke_width = (*pat)->width(); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); } box2d<double> clipping_extent = common_.query_extent_; if (clip) { double padding = (double)(common_.query_extent_.width()/pixmap_.width()); double half_stroke = stroke_width/2.0; if (half_stroke > 1) padding *= half_stroke; if (std::fabs(offset) > 0) padding *= std::fabs(offset) * 1.2; padding *= common_.scale_factor_; clipping_extent.pad(padding); } // to avoid the complexity of using an agg pattern filter instead // we create a line_symbolizer in order to fake the pattern line_symbolizer line; put<value_double>(line, keys::stroke_width, value_double(stroke_width)); // TODO: really should pass the offset to the fake line too, but // this wasn't present in the previous version and makes the test // fail - in this case, probably the test should be updated. //put<value_double>(line, keys::offset, value_double(offset)); put<value_double>(line, keys::simplify_tolerance, value_double(simplify_tolerance)); put<value_double>(line, keys::smooth, value_double(smooth)); vertex_converter<box2d<double>, grid_rasterizer, line_symbolizer, CoordTransform, proj_transform, agg::trans_affine, conv_types, feature_impl> converter(clipping_extent,*ras_ptr,line,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (clip) converter.set<clip_line_tag>(); // optional clip (default: true) converter.set<transform_tag>(); // always transform if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter converter.set<stroke_tag>(); //always stroke for (geometry_type & geom : feature.paths()) { if (geom.size() > 1) { converter.apply(geom); } } // render id ren.color(color_type(feature.id())); agg::render_scanlines(*ras_ptr, sl, ren); // add feature properties to grid cache pixmap_.add_feature(feature); }
void grid_renderer<T>::process(line_pattern_symbolizer const& sym, mapnik::feature_impl & feature, proj_transform const& prj_trans) { std::string filename = get<std::string, keys::file>(sym, feature, common_.vars_); if (filename.empty()) return; std::shared_ptr<mapnik::marker const> mark = marker_cache::instance().find(filename, true); if (mark->is<mapnik::marker_null>()) return; if (!mark->is<mapnik::marker_rgba8>()) { MAPNIK_LOG_DEBUG(agg_renderer) << "agg_renderer: Only images (not '" << filename << "') are supported in the line_pattern_symbolizer"; return; } value_bool clip = get<value_bool, keys::clip>(sym, feature, common_.vars_); value_double offset = get<value_double, keys::offset>(sym, feature, common_.vars_); value_double simplify_tolerance = get<value_double, keys::simplify_tolerance>(sym, feature, common_.vars_); value_double smooth = get<value_double, keys::smooth>(sym, feature, common_.vars_); using pixfmt_type = typename grid_renderer_base_type::pixfmt_type; using color_type = typename grid_renderer_base_type::pixfmt_type::color_type; using renderer_type = agg::renderer_scanline_bin_solid<grid_renderer_base_type>; agg::scanline_bin sl; grid_rendering_buffer buf(pixmap_.raw_data(), common_.width_, common_.height_, common_.width_); pixfmt_type pixf(buf); grid_renderer_base_type renb(pixf); renderer_type ren(renb); ras_ptr->reset(); line_pattern_enum pattern = get<line_pattern_enum, keys::line_pattern>(sym, feature, common_.vars_); std::size_t stroke_width = (pattern == LINE_PATTERN_WARP) ? mark->width() : get<value_double, keys::stroke_width>(sym, feature, common_.vars_); agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); } box2d<double> clipping_extent = common_.query_extent_; if (clip) { double pad_per_pixel = static_cast<double>(common_.query_extent_.width()/common_.width_); double pixels = std::ceil(std::max(stroke_width / 2.0 + std::fabs(offset), (std::fabs(offset) * offset_converter_default_threshold))); double padding = pad_per_pixel * pixels * common_.scale_factor_; clipping_extent.pad(padding); } // to avoid the complexity of using an agg pattern filter instead // we create a line_symbolizer in order to fake the pattern line_symbolizer line; put<value_double>(line, keys::stroke_width, value_double(stroke_width)); // TODO: really should pass the offset to the fake line too, but // this wasn't present in the previous version and makes the test // fail - in this case, probably the test should be updated. //put<value_double>(line, keys::offset, value_double(offset)); put<value_double>(line, keys::simplify_tolerance, value_double(simplify_tolerance)); put<value_double>(line, keys::smooth, value_double(smooth)); using vertex_converter_type = vertex_converter<clip_line_tag, transform_tag, affine_transform_tag, simplify_tag,smooth_tag, offset_transform_tag,stroke_tag>; vertex_converter_type converter(clipping_extent,line,common_.t_,prj_trans,tr,feature,common_.vars_,common_.scale_factor_); if (clip) converter.set<clip_line_tag>(); converter.set<transform_tag>(); // always transform if (std::fabs(offset) > 0.0) converter.set<offset_transform_tag>(); // parallel offset converter.set<affine_transform_tag>(); // optional affine transform if (simplify_tolerance > 0.0) converter.set<simplify_tag>(); // optional simplify converter if (smooth > 0.0) converter.set<smooth_tag>(); // optional smooth converter converter.set<stroke_tag>(); //always stroke using apply_vertex_converter_type = detail::apply_vertex_converter<vertex_converter_type,grid_rasterizer>; using vertex_processor_type = geometry::vertex_processor<apply_vertex_converter_type>; apply_vertex_converter_type apply(converter, *ras_ptr); mapnik::util::apply_visitor(vertex_processor_type(apply),feature.get_geometry()); // render id ren.color(color_type(feature.id())); agg::render_scanlines(*ras_ptr, sl, ren); // add feature properties to grid cache pixmap_.add_feature(feature); }
void value(double value) { value_double(value); }
void value(float value) { value_double((double)value); }