sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

+ simplify geometry implementation

Browse source 
+ removed multiple geometry typedefs
+ use geometry_type
+ revert to storing vertices in vector_vertex
  (previous implementation using std::vector was
   fragmenting heap causing performance issues with large geometries)
+ FIXME: hit_test is broken!
This commit is contained in:
Artem Pavlenko 2010-11-03 13:19:15 +00:00
parent 0361061053
commit ab101401cd
41 changed files with 333 additions and 623 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bindings/python/mapnik_feature.cpp
View file

@ -33,7 +33,7 @@
#include <mapnik/datasource.hpp>
#include <mapnik/wkb.hpp>
mapnik::geometry2d & (mapnik::Feature::*get_geom1)(unsigned) = &mapnik::Feature::get_geometry;
mapnik::geometry_type & (mapnik::Feature::*get_geom1)(unsigned) = &mapnik::Feature::get_geometry;
namespace {

14
bindings/python/mapnik_geometry.cpp
View file

@ -29,12 +29,12 @@
void export_geometry()
{
using namespace boost::python;
using mapnik::geometry2d;
class_<geometry2d, boost::noncopyable>("Geometry2d",no_init)
.def("envelope",&geometry2d::envelope)
// .def("__str__",&geometry2d::to_string)
.def("type",&geometry2d::type)
// TODO add other geometry2d methods
using mapnik::geometry_type;
class_<geometry_type, boost::noncopyable>("GeometryType",no_init)
.def("envelope",&geometry_type::envelope)
// .def("__str__",&geometry_type::to_string)
.def("type",&geometry_type::type)
// TODO add other geometry_type methods
;
}

4
demo/viewer/mapwidget.cpp
View file

@ -177,11 +177,11 @@ void MapWidget::mousePressEvent(QMouseEvent* e)
itr->second.to_string().c_str()));
}
}
typedef mapnik::coord_transform2<mapnik::CoordTransform,mapnik::geometry2d> path_type;
typedef mapnik::coord_transform2<mapnik::CoordTransform,mapnik::geometry_type> path_type;
for (unsigned i=0; i<feat->num_geometries();++i)
{
mapnik::geometry2d & geom = feat->get_geometry(i);
mapnik::geometry_type & geom = feat->get_geometry(i);
path_type path(t,geom,prj_trans);
if (geom.num_points() > 0)
{

4
include/mapnik/feature.hpp
View file

@ -102,7 +102,7 @@ public:
box2d<double> result;
for (unsigned i=0;i<num_geometries();++i)
{
geometry2d const& geom = get_geometry(i);
geometry_type const& geom = get_geometry(i);
if (i==0)
{
box2d<double> box = geom.envelope();
@ -160,7 +160,7 @@ public:
}
};
typedef feature<geometry2d,raster_ptr> Feature;
typedef feature<geometry_type,raster_ptr> Feature;
inline std::ostream& operator<< (std::ostream & out,Feature const& f)
{

280
include/mapnik/geometry.hpp
View file

@ -35,115 +35,16 @@
#include <boost/ptr_container/ptr_vector.hpp>
namespace mapnik {
enum GeomType {
enum eGeomType {
Point = 1,
LineString = 2,
Polygon = 3
};
template <typename T>
class geometry : private boost::noncopyable
{
public:
typedef T vertex_type;
typedef typename vertex_type::type value_type;
public:
geometry () {}
box2d<double> envelope() const
{
box2d<double> result;
double x(0);
double y(0);
rewind(0);
for (unsigned i=0;i<num_points();++i)
{
vertex(&x,&y);
if (i==0)
{
result.init(x,y,x,y);
}
else
{
result.expand_to_include(x,y);
}
}
return result;
}
virtual int type() const=0;
virtual double area() const=0;
virtual bool hit_test(value_type x,value_type y, double tol) const=0;
virtual void label_position(double *x, double *y) const=0;
virtual void move_to(value_type x,value_type y)=0;
virtual void line_to(value_type x,value_type y)=0;
virtual unsigned num_points() const = 0;
virtual unsigned vertex(double* x, double* y) const=0;
virtual void rewind(unsigned) const=0;
virtual void set_capacity(size_t size)=0;
virtual ~geometry() {}
};
template <typename T>
class point : public geometry<T>
{
typedef geometry<T> geometry_base;
typedef typename geometry<T>::vertex_type vertex_type;
typedef typename geometry<T>::value_type value_type;
private:
vertex_type pt_;
public:
point() : geometry<T>() {}
int type() const
{
return Point;
}
double area() const
{
return 0;
}
void label_position(double *x, double *y) const
{
*x = pt_.x;
*y = pt_.y;
}
void move_to(value_type x,value_type y)
{
pt_.x = x;
pt_.y = y;
}
void line_to(value_type ,value_type ) {}
unsigned num_points() const
{
return 1;
}
unsigned vertex(double* x, double* y) const
{
*x = pt_.x;
*y = pt_.y;
return SEG_LINETO;
}
void rewind(unsigned ) const {}
bool hit_test(value_type x,value_type y, double tol) const
{
return point_in_circle(pt_.x,pt_.y, x,y,tol);
}
void set_capacity(size_t) {}
virtual ~point() {}
};
template <typename T, template <typename> class Container=vertex_vector2>
class polygon //: public geometry<T>
template <typename T, template <typename> class Container=vertex_vector>
class geometry
{
public:
typedef T vertex_type;
@ -151,31 +52,20 @@ public:
typedef Container<vertex_type> container_type;
private:
container_type cont_;
eGeomType type_;
mutable unsigned itr_;
public:
typedef typename container_type::const_iterator iterator;
iterator begin() const
{
return cont_.begin();
}
iterator end() const
{
return cont_.end();
}
polygon()
: //geometry_base(),
itr_(0)
geometry(eGeomType type)
: type_(type),
itr_(0)
{}
int type() const
eGeomType type() const
{
return Polygon;
return type_;
}
double area() const
{
double sum = 0.0;
@ -340,18 +230,20 @@ public:
itr_=0;
}
bool hit_test(value_type x,value_type y, double tol) const
bool hit_test(value_type x, value_type y, double tol) const
{
// FIXME !!!!!!!!!
// FIXME: this is a workaround around the regression metioned in
// http://trac.mapnik.org/ticket/560, not a definitive solution
if (cont_.size() > 1) {
return point_inside_path(x,y,cont_.begin(),cont_.end());
} else if (cont_.size() == 1) {
//if (cont_.size() > 1) {
// return point_inside_path(x,y,cont_.begin(),cont_.end());
//} else if (cont_.size() == 1) {
// Handle points
double x0=boost::get<0>(*cont_.begin());
double y0=boost::get<1>(*cont_.begin());
return distance(x, y, x0, y0) <= abs(tol);
}
// double x0=boost::get<0>(*cont_.begin());
// double y0=boost::get<1>(*cont_.begin());
// return distance(x, y, x0, y0) <= abs(tol);
//}
return false;
}
@ -359,132 +251,12 @@ public:
{
cont_.set_capacity(size);
}
//virtual ~polygon() {}
};
template <typename T, template <typename> class Container=vertex_vector2>
class line_string : public geometry<T>
{
typedef geometry<T> geometry_base;
typedef typename geometry_base::value_type value_type;
typedef typename geometry<T>::vertex_type vertex_type;
typedef Container<vertex_type> container_type;
private:
container_type cont_;
mutable unsigned itr_;
public:
line_string()
: geometry_base(),
itr_(0)
{}
int type() const
{
return LineString;
}
typedef geometry<vertex2d,vertex_vector> geometry_type;
typedef boost::shared_ptr<geometry_type> geometry_ptr;
typedef boost::ptr_vector<geometry_type> geometry_containter;
double area() const
{
return 0;
}
void label_position(double *x, double *y) const
{
// calculate mid point on line string
double x0=0;
double y0=0;
double x1=0;
double y1=0;
unsigned size = cont_.size();
if (size == 1)
{
cont_.get_vertex(0,x,y);
}
else if (size == 2)
{
cont_.get_vertex(0,&x0,&y0);
cont_.get_vertex(1,&x1,&y1);
*x = 0.5 * (x1 + x0);
*y = 0.5 * (y1 + y0);
}
else
{
double len=0.0;
for (unsigned pos = 1; pos < size; ++pos)
{
cont_.get_vertex(pos-1,&x0,&y0);
cont_.get_vertex(pos,&x1,&y1);
double dx = x1 - x0;
double dy = y1 - y0;
len += std::sqrt(dx * dx + dy * dy);
}
double midlen = 0.5 * len;
double dist = 0.0;
for (unsigned pos = 1; pos < size;++pos)
{
cont_.get_vertex(pos-1,&x0,&y0);
cont_.get_vertex(pos,&x1,&y1);
double dx = x1 - x0;
double dy = y1 - y0;
double seg_len = std::sqrt(dx * dx + dy * dy);
if (( dist + seg_len) >= midlen)
{
double r = (midlen - dist)/seg_len;
*x = x0 + (x1 - x0) * r;
*y = y0 + (y1 - y0) * r;
break;
}
dist += seg_len;
}
}
}
void line_to(value_type x,value_type y)
{
cont_.push_back(x,y,SEG_LINETO);
}
void move_to(value_type x,value_type y)
{
cont_.push_back(x,y,SEG_MOVETO);
}
unsigned num_points() const
{
return cont_.size();
}
unsigned vertex(double* x, double* y) const
{
return cont_.get_vertex(itr_++,x,y);
}
void rewind(unsigned ) const
{
itr_=0;
}
bool hit_test(value_type x,value_type y, double tol) const
{
return point_on_path(x,y,cont_.begin(),cont_.end(),tol);
}
void set_capacity(size_t size)
{
cont_.set_capacity(size);
}
virtual ~line_string() {}
};
//typedef point<vertex2d> point_impl;
//typedef line_string<vertex2d,vertex_vector2> line_string_impl;
typedef polygon<vertex2d,vertex_vector2> point_impl;
typedef polygon<vertex2d,vertex_vector2> line_string_impl;
typedef polygon<vertex2d,vertex_vector2> polygon_impl;
typedef polygon_impl geometry2d;
typedef boost::shared_ptr<geometry2d> geometry_ptr;
typedef boost::ptr_vector<geometry2d> geometry_containter;
}
#endif //GEOMETRY_HPP

2
include/mapnik/hit_test_filter.hpp
View file

@ -40,7 +40,7 @@ public:
{
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.hit_test(x_,y_,tol_))
return true;
}

17
include/mapnik/memory_datasource.hpp
View file

@ -45,27 +45,18 @@ public:
layer_descriptor get_descriptor() const;
size_t size() const;
private:
std::vector<mapnik::feature_ptr> features_;
std::vector<feature_ptr> features_;
};
// This class implements a simple way of displaying point-based data
// TODO -- possible redesign, move into separate file
//
class MAPNIK_DECL point_datasource : public mapnik::memory_datasource {
class MAPNIK_DECL point_datasource : public memory_datasource {
public:
point_datasource() : feat_id(0) {}
void add_point(double x, double y, const char* key, const char* value) {
mapnik::feature_ptr feature(mapnik::feature_factory::create(feat_id++));
mapnik::geometry2d * pt = new mapnik::point_impl;
pt->move_to(x,y);
feature->add_geometry(pt);
mapnik::transcoder tr("utf-8");
(*feature)[key] = tr.transcode(value);
this->push(feature);
}
int type() const { return mapnik::datasource::Vector; }
void add_point(double x, double y, const char* key, const char* value);
inline int type() const { return datasource::Vector; }
private:
int feat_id;

2
include/mapnik/memory_featureset.hpp
View file

@ -44,7 +44,7 @@ public:
while (pos_ != end_)
{
for (unsigned i=0; i<(*pos_)->num_geometries();++i) {
geometry2d & geom = (*pos_)->get_geometry(i);
geometry_type & geom = (*pos_)->get_geometry(i);
#ifdef MAPNIK_DEBUG
std::clog << "bbox_=" << bbox_ << ", geom.envelope=" << geom.envelope() << "\n";
#endif

2
include/mapnik/metawriter.hpp
View file

@ -71,7 +71,7 @@ public:
class metawriter
{
public:
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
metawriter(metawriter_properties dflt_properties) : dflt_properties_(dflt_properties) {}
virtual ~metawriter() {};
/** Output a rectangular area.

2
include/mapnik/svg/svg_generator.hpp
View file

@ -44,7 +44,7 @@ namespace mapnik { namespace svg {
template <typename OutputIterator>
class svg_generator : private boost::noncopyable
{
typedef coord_transform2<CoordTransform, geometry2d> path_type;
typedef coord_transform2<CoordTransform, geometry_type> path_type;
typedef svg::svg_root_attributes_grammar<OutputIterator> root_attributes_grammar;
typedef svg::svg_rect_attributes_grammar<OutputIterator> rect_attributes_grammar;

24
include/mapnik/svg/svg_output_grammars.hpp
View file

@ -104,38 +104,38 @@ BOOST_FUSION_ADAPT_CLASS(
)
/*!
* mapnik::geometry2d is adapted to conform to the concepts
* mapnik::geometry_type is adapted to conform to the concepts
* required by Karma to be recognized as a container of
* attributes for output generation.
*/
namespace boost { namespace spirit { namespace traits {
template <>
struct is_container<mapnik::geometry2d const>
struct is_container<mapnik::geometry_type const>
: mpl::true_
{};
template <>
struct container_iterator<mapnik::geometry2d const>
struct container_iterator<mapnik::geometry_type const>
{
typedef mapnik::geometry2d::iterator type;
typedef mapnik::geometry_type::iterator type;
};
template <>
struct begin_container<mapnik::geometry2d const>
struct begin_container<mapnik::geometry_type const>
{
static mapnik::geometry2d::iterator
call(mapnik::geometry2d const& g)
static mapnik::geometry_type::iterator
call(mapnik::geometry_type const& g)
{
return g.begin();
}
};
template <>
struct end_container<mapnik::geometry2d const>
struct end_container<mapnik::geometry_type const>
{
static mapnik::geometry2d::iterator
call(mapnik::geometry2d const& g)
static mapnik::geometry_type::iterator
call(mapnik::geometry_type const& g)
{
return g.end();
}
@ -191,7 +191,7 @@ namespace mapnik { namespace svg {
};
template <typename OutputIterator, typename PathType>
struct svg_path_data_grammar : karma::grammar<OutputIterator, mapnik::geometry2d()>
struct svg_path_data_grammar : karma::grammar<OutputIterator, mapnik::geometry_type()>
{
typedef path_coordinate_transformer<PathType> coordinate_transformer;
typedef mapnik::vertex_vector2<mapnik::vertex2d>::vertex_type vertex_type;
@ -234,7 +234,7 @@ namespace mapnik { namespace svg {
path_vertex_transformed_y = double_[_1 = _a][bind(&coordinate_transformer::current_y, &ct_, _a)];
}
karma::rule<OutputIterator, mapnik::geometry2d()> svg_path;
karma::rule<OutputIterator, mapnik::geometry_type()> svg_path;
karma::rule<OutputIterator, vertex_type()> path_vertex;
karma::rule<OutputIterator, int()> path_vertex_command;
karma::rule<OutputIterator, vertex_component_type(), karma::locals<double> > path_vertex_component_x, path_vertex_component_y;

54
include/mapnik/vertex_vector.hpp
View file

@ -75,10 +75,10 @@ public:
value_type** vertexs=vertexs_ + num_blocks_ - 1;
while ( num_blocks_-- )
{
delete [] *vertexs;
::operator delete(*vertexs);
--vertexs;
}
delete [] vertexs_;
::operator delete(vertexs_);
}
}
unsigned size() const
@ -121,66 +121,26 @@ private:
{
if (block >= max_blocks_)
{
value_type** new_vertexs = new value_type* [(max_blocks_ + grow_by) * 2];
value_type** new_vertexs =
static_cast<value_type**>(::operator new (sizeof(value_type*)*((max_blocks_ + grow_by) * 2)));
unsigned char** new_commands = (unsigned char**)(new_vertexs + max_blocks_ + grow_by);
if (vertexs_)
{
std::memcpy(new_vertexs,vertexs_,max_blocks_ * sizeof(value_type*));
std::memcpy(new_commands,commands_,max_blocks_ * sizeof(unsigned char*));
delete [] vertexs_;
::operator delete(vertexs_);
}
vertexs_ = new_vertexs;
commands_ = new_commands;
max_blocks_ += grow_by;
}
vertexs_[block] = new value_type [block_size * 2 + block_size / (sizeof(value_type))];
vertexs_[block] = static_cast<value_type*>(::operator new(sizeof(value_type)*(block_size * 2 + block_size / (sizeof(value_type)))));
commands_[block] = (unsigned char*)(vertexs_[block] + block_size*2);
++num_blocks_;
}
};
template <typename T>
struct vertex_vector2 //: boost::noncopyable
{
typedef typename T::type value_type;
typedef boost::tuple<value_type,value_type,char> vertex_type;
typedef typename std::vector<vertex_type>::const_iterator const_iterator;
vertex_vector2() {}
unsigned size() const
{
return cont_.size();
}
void push_back (value_type x,value_type y,unsigned command)
{
cont_.push_back(vertex_type(x,y,command));
}
unsigned get_vertex(unsigned pos,value_type* x,value_type* y) const
{
if (pos >= cont_.size()) return SEG_END;
vertex_type const& c = cont_[pos];
*x = boost::get<0>(c);
*y = boost::get<1>(c);
return boost::get<2>(c);
}
const_iterator begin() const
{
return cont_.begin();
}
const_iterator end() const
{
return cont_.end();
}
void set_capacity(size_t size)
{
cont_.reserve(size);
}
private:
std::vector<vertex_type> cont_;
};
}
#endif //VERTEX_VECTOR_HPP

7
plugins/input/gdal/gdal_featureset.cpp
View file

@ -33,8 +33,7 @@ using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr;
using mapnik::CoordTransform;
using mapnik::point_impl;
using mapnik::geometry2d;
using mapnik::geometry_type;
using mapnik::datasource_exception;
@ -345,7 +344,7 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
double det2 = gt[2]*Y + gt[5]*X;
unsigned x = det2/det, y = det1/det;
if(0<=x && x<raster_xsize && 0<=y && y<raster_ysize) {
if(x<raster_xsize && y<raster_ysize) {
#ifdef MAPNIK_DEBUG
std::clog << boost::format("GDAL Plugin: pt.x=%f pt.y=%f\n") % pt.x % pt.y;
std::clog << boost::format("GDAL Plugin: x=%f y=%f\n") % x % y;
@ -358,7 +357,7 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
if(!hasNoData || value!=nodata) {
// construct feature
feature_ptr feature(new Feature(1));
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(pt.x, pt.y);
feature->add_geometry(point);
(*feature)["value"] = value;

4
plugins/input/kismet/kismet_featureset.cpp
View file

@ -72,8 +72,8 @@ feature_ptr kismet_featureset::next()
{
value = "wlan_crypted";
}
mapnik::geometry2d * pt = new mapnik::point_impl;
mapnik::geometry_type * pt = new mapnik::geometry_type(mapnik::Point);
pt->move_to(knd.bestlon_, knd.bestlat_);
feature->add_geometry(pt);
(*feature)[key] = tr_->transcode(value.c_str ());

32
plugins/input/occi/occi_featureset.cpp
View file

@ -44,7 +44,7 @@ using mapnik::feature_ptr;
using mapnik::point_impl;
using mapnik::line_string_impl;
using mapnik::polygon_impl;
using mapnik::geometry2d;
using mapnik::geometry_type;
using mapnik::geometry_utils;
using mapnik::transcoder;
using mapnik::datasource_exception;
@ -243,7 +243,7 @@ void occi_featureset::convert_point (SDOGeometry* geom, feature_ptr feature, int
SDOPointType* sdopoint = geom->getSdo_point();
if (sdopoint && ! sdopoint->isNull())
{
geometry2d* point = new point_impl;
geometry_type* point = new geometry_type(mapnik::Point);
point->move_to (sdopoint->getX(), sdopoint->getY());
@ -259,10 +259,10 @@ void occi_featureset::convert_linestring (SDOGeometry* geom, feature_ptr feature
if (ord_size >= dimensions)
{
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity (ord_size);
fill_geometry2d (line, elem_info, ordinates, dimensions, false);
fill_geometry_type (line, elem_info, ordinates, dimensions, false);
feature->add_geometry (line);
}
@ -276,10 +276,10 @@ void occi_featureset::convert_polygon (SDOGeometry* geom, feature_ptr feature, i
if (ord_size >= dimensions)
{
geometry2d * poly = new polygon_impl;
geometry_type * poly = new geometry_type(mapnik::Polygon);
poly->set_capacity (ord_size);
fill_geometry2d (poly, elem_info, ordinates, dimensions, false);
fill_geometry_type (poly, elem_info, ordinates, dimensions, false);
feature->add_geometry (poly);
}
@ -293,9 +293,9 @@ void occi_featureset::convert_multipoint (SDOGeometry* geom, feature_ptr feature
if (ord_size >= dimensions)
{
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
fill_geometry2d (point, elem_info, ordinates, dimensions, true);
fill_geometry_type (point, elem_info, ordinates, dimensions, true);
feature->add_geometry (point);
}
@ -320,10 +320,10 @@ void occi_featureset::convert_multilinestring (SDOGeometry* geom, feature_ptr fe
if (ord_size >= dimensions)
{
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity (ord_size);
fill_geometry2d (line, elem_info, ordinates, dimensions, false);
fill_geometry_type (line, elem_info, ordinates, dimensions, false);
feature->add_geometry (line);
}
@ -348,10 +348,10 @@ void occi_featureset::convert_multipolygon (SDOGeometry* geom, feature_ptr featu
if (ord_size >= dimensions)
{
geometry2d * poly = new polygon_impl;
geometry_type * poly = new geometry_type(mapnik::Polygon);
poly->set_capacity (ord_size);
fill_geometry2d (poly, elem_info, ordinates, dimensions, false);
fill_geometry_type (poly, elem_info, ordinates, dimensions, false);
feature->add_geometry (poly);
}
@ -383,7 +383,7 @@ void occi_featureset::convert_collection (SDOGeometry* geom, feature_ptr feature
}
*/
void occi_featureset::fill_geometry2d (geometry2d * geom,
void occi_featureset::fill_geometry_type (geometry_type * geom,
const std::vector<Number>& elem_info,
const std::vector<Number>& ordinates,
const int dimensions,
@ -447,7 +447,7 @@ void occi_featureset::fill_geometry2d (geometry2d * geom,
if (is_linear_element)
{
fill_geometry2d (geom,
fill_geometry_type (geom,
offset - 1,
next_offset - 1,
ordinates,
@ -462,7 +462,7 @@ void occi_featureset::fill_geometry2d (geometry2d * geom,
}
else
{
fill_geometry2d (geom,
fill_geometry_type (geom,
offset - 1,
ord_size,
ordinates,
@ -472,7 +472,7 @@ void occi_featureset::fill_geometry2d (geometry2d * geom,
}
}
void occi_featureset::fill_geometry2d (geometry2d * geom,
void occi_featureset::fill_geometry_type (geometry_type * geom,
const int real_offset,
const int next_offset,
const std::vector<Number>& ordinates,

4
plugins/input/occi/occi_featureset.hpp
View file

@ -58,12 +58,12 @@ class occi_featureset : public mapnik::Featureset
void convert_multipolygon (SDOGeometry* geom, mapnik::feature_ptr feature, int dims);
//void convert_multipolygon_2 (SDOGeometry* geom, mapnik::feature_ptr feature, int dims);
//void convert_collection (SDOGeometry* geom, mapnik::feature_ptr feature, int dims);
void fill_geometry2d (mapnik::geometry2d * geom,
void fill_geometry_type (mapnik::geometry_type * geom,
const std::vector<oracle::occi::Number>& elem_info,
const std::vector<oracle::occi::Number>& ordinates,
const int dimensions,
const bool is_point_geom);
void fill_geometry2d (mapnik::geometry2d * geom,
void fill_geometry_type (mapnik::geometry_type * geom,
const int real_offset,
const int next_offset,
const std::vector<oracle::occi::Number>& ordinates,

28
plugins/input/ogr/ogr_converter.cpp
View file

@ -37,17 +37,7 @@ using std::endl;
using mapnik::feature_ptr;
using mapnik::geometry_utils;
using mapnik::geometry2d;
using mapnik::point_impl;
using mapnik::line_string_impl;
using mapnik::polygon_impl;
/*
using mapnik::query;
using mapnik::box2d;
using mapnik::CoordTransform;
using mapnik::Feature;
*/
using mapnik::geometry_type;
void ogr_converter::convert_geometry (OGRGeometry* geom, feature_ptr feature, bool multiple_geometries)
{
@ -102,7 +92,7 @@ void ogr_converter::convert_geometry (OGRGeometry* geom, feature_ptr feature, bo
void ogr_converter::convert_point (OGRPoint* geom, feature_ptr feature)
{
geometry2d* point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to (geom->getX(), geom->getY());
feature->add_geometry (point);
}
@ -110,7 +100,7 @@ void ogr_converter::convert_point (OGRPoint* geom, feature_ptr feature)
void ogr_converter::convert_linestring (OGRLineString* geom, feature_ptr feature)
{
int num_points = geom->getNumPoints ();
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity (num_points);
line->move_to (geom->getX (0), geom->getY (0));
for (int i=1;i<num_points;++i)
@ -132,7 +122,7 @@ void ogr_converter::convert_polygon (OGRPolygon* geom, feature_ptr feature)
capacity += interior->getNumPoints ();
}
geometry2d * poly = new polygon_impl;
geometry_type * poly = new geometry_type(mapnik::Polygon);
poly->set_capacity (num_points + capacity);
poly->move_to (exterior->getX (0), exterior->getY (0));
for (int i=1;i<num_points;++i)
@ -155,8 +145,8 @@ void ogr_converter::convert_polygon (OGRPolygon* geom, feature_ptr feature)
void ogr_converter::convert_multipoint (OGRMultiPoint* geom, feature_ptr feature)
{
int num_geometries = geom->getNumGeometries ();
geometry2d* point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
for (int i=0;i<num_geometries;i++)
{
OGRPoint* ogrpoint = static_cast<OGRPoint*>(geom->getGeometryRef (i));
@ -188,9 +178,9 @@ void ogr_converter::convert_multilinestring (OGRMultiLineString* geom, feature_p
num_points += ls->getNumPoints ();
}
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity (num_points);
for (int i=0;i<num_geometries;i++)
{
OGRLineString* ls = static_cast<OGRLineString*>(geom->getGeometryRef (i));
@ -231,7 +221,7 @@ void ogr_converter::convert_multipolygon (OGRMultiPolygon* geom, feature_ptr fea
}
}
geometry2d * poly = new polygon_impl;
geometry_type * poly = new geometry_type(mapnik::Polygon);
poly->set_capacity (capacity);
for (int i=0;i<num_geometries;i++)

184
plugins/input/osm/osm_featureset.cpp
View file

@ -27,113 +27,109 @@
using mapnik::Feature;
using mapnik::feature_ptr;
using mapnik::geometry2d;
using mapnik::point_impl;
using mapnik::line_string_impl;
using mapnik::polygon_impl;
using mapnik::geometry_type;
using std::cerr;
using std::endl;
template <typename filterT>
osm_featureset<filterT>::osm_featureset(const filterT& filter,
osm_dataset * dataset,
const std::set<std::string>&
attribute_names,
std::string const& encoding)
: filter_(filter),
query_ext_(),
tr_(new transcoder(encoding)),
count_(0),
dataset_ (dataset),
attribute_names_ (attribute_names)
osm_dataset * dataset,
const std::set<std::string>&
attribute_names,
std::string const& encoding)
: filter_(filter),
query_ext_(),
tr_(new transcoder(encoding)),
count_(0),
dataset_ (dataset),
attribute_names_ (attribute_names)
{
dataset_->rewind();
dataset_->rewind();
}
template <typename filterT>
feature_ptr osm_featureset<filterT>::next()
{
osm_item * cur_item = dataset_->next_item();
feature_ptr feature;
bool success=false;
if(cur_item != NULL)
{
if(dataset_->current_item_is_node())
{
feature= feature_ptr(new Feature(count_++));
double lat = static_cast<osm_node*>(cur_item)->lat;
double lon = static_cast<osm_node*>(cur_item)->lon;
geometry2d * point = new point_impl;
point->move_to(lon,lat);
feature->add_geometry(point);
success=true;
}
else if (dataset_->current_item_is_way())
{
bounds b = static_cast<osm_way*>(cur_item)->get_bounds();
// Loop until we find a feature which passes the filter
while(cur_item != NULL &&
!filter_.pass(box2d<double>(b.w,b.s,b.e,b.n)))
{
cur_item = dataset_->next_item();
if(cur_item!=NULL)
b = static_cast<osm_way*>(cur_item)->get_bounds();
}
if(cur_item != NULL)
{
if(static_cast<osm_way*>(cur_item)->nodes.size())
{
feature=feature_ptr(new Feature(count_++));
geometry2d *geom;
if(static_cast<osm_way*>(cur_item)->is_polygon())
geom=new polygon_impl;
else
geom=new line_string_impl;
osm_item * cur_item = dataset_->next_item();
feature_ptr feature;
bool success=false;
if(cur_item != NULL)
{
if(dataset_->current_item_is_node())
{
feature= feature_ptr(new Feature(count_++));
double lat = static_cast<osm_node*>(cur_item)->lat;
double lon = static_cast<osm_node*>(cur_item)->lon;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(lon,lat);
feature->add_geometry(point);
success=true;
}
else if (dataset_->current_item_is_way())
{
bounds b = static_cast<osm_way*>(cur_item)->get_bounds();
// Loop until we find a feature which passes the filter
while(cur_item != NULL &&
!filter_.pass(box2d<double>(b.w,b.s,b.e,b.n)))
{
cur_item = dataset_->next_item();
if(cur_item!=NULL)
b = static_cast<osm_way*>(cur_item)->get_bounds();
}
if(cur_item != NULL)
{
if(static_cast<osm_way*>(cur_item)->nodes.size())
{
feature=feature_ptr(new Feature(count_++));
geometry_type *geom;
if(static_cast<osm_way*>(cur_item)->is_polygon())
geom=new geometry_type(mapnik::Polygon);
else
geom=new geometry_type(mapnik::LineString);
geom->set_capacity(static_cast<osm_way*>(cur_item)->
nodes.size());
geom->move_to(static_cast<osm_way*>(cur_item)->
nodes[0]->lon,
static_cast<osm_way*>(cur_item)->
nodes[0]->lat);
for(unsigned int count=1; count<static_cast<osm_way*>(cur_item)
->nodes.size(); count++)
{
geom->line_to(static_cast<osm_way*>(cur_item)
->nodes[count]->lon,
static_cast<osm_way*>(cur_item)
->nodes[count]->lat);
}
feature->add_geometry(geom);
success=true;
}
}
}
// can feature_ptr be compared to NULL? - no
if(success)
{
std::map<std::string,std::string>::iterator i=
cur_item->keyvals.begin();
geom->set_capacity(static_cast<osm_way*>(cur_item)->
nodes.size());
geom->move_to(static_cast<osm_way*>(cur_item)->
nodes[0]->lon,
static_cast<osm_way*>(cur_item)->
nodes[0]->lat);
for(unsigned int count=1; count<static_cast<osm_way*>(cur_item)
->nodes.size(); count++)
{
geom->line_to(static_cast<osm_way*>(cur_item)
->nodes[count]->lon,
static_cast<osm_way*>(cur_item)
->nodes[count]->lat);
}
feature->add_geometry(geom);
success=true;
}
}
}
// can feature_ptr be compared to NULL? - no
if(success)
{
std::map<std::string,std::string>::iterator i=
cur_item->keyvals.begin();
// add the keyvals to the feature. the feature seems to be a map
// of some sort so this should work - see dbf_file::add_attribute()
while(i != cur_item->keyvals.end())
{
//only add if in the specified set of attribute names
if(attribute_names_.find(i->first) != attribute_names_.end())
(*feature)[i->first] = tr_->transcode(i->second.c_str());
i++;
}
return feature;
}
}
return feature_ptr();
// add the keyvals to the feature. the feature seems to be a map
// of some sort so this should work - see dbf_file::add_attribute()
while(i != cur_item->keyvals.end())
{
//only add if in the specified set of attribute names
if(attribute_names_.find(i->first) != attribute_names_.end())
(*feature)[i->first] = tr_->transcode(i->second.c_str());
i++;
}
return feature;
}
}
return feature_ptr();
}

2
plugins/input/postgis/postgisfs.cpp
View file

@ -36,7 +36,7 @@ using boost::bad_lexical_cast;
using boost::trim_copy;
using std::string;
using mapnik::Feature;
using mapnik::geometry2d;
using mapnik::geometry_type;
using mapnik::byte;
using mapnik::geometry_utils;

2
plugins/input/rasterlite/rasterlite_featureset.cpp
View file

@ -34,7 +34,7 @@ using mapnik::Feature;
using mapnik::feature_ptr;
using mapnik::CoordTransform;
using mapnik::point_impl;
using mapnik::geometry2d;
using mapnik::geometry_type;
using mapnik::query;

26
plugins/input/shape/shape_featureset.cpp
View file

@ -74,7 +74,7 @@ shape_featureset<filterT>::shape_featureset(const filterT& filter,
template <typename filterT>
feature_ptr shape_featureset<filterT>::next()
{
using mapnik::point_impl;
using mapnik::geometry_type;
std::streampos pos=shape_.shp().pos();
if (pos < std::streampos(file_length_ * 2))
@ -86,7 +86,7 @@ feature_ptr shape_featureset<filterT>::next()
{
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
++count_;
@ -96,7 +96,7 @@ feature_ptr shape_featureset<filterT>::next()
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
shape_.shp().skip(8); //m
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
++count_;
@ -113,7 +113,7 @@ feature_ptr shape_featureset<filterT>::next()
{
shape_.shp().skip(8);
}
geometry2d * point=new point_impl;
geometry_type * point=new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
++count_;
@ -146,7 +146,7 @@ feature_ptr shape_featureset<filterT>::next()
{
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
}
@ -160,7 +160,7 @@ feature_ptr shape_featureset<filterT>::next()
{
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
}
@ -177,7 +177,7 @@ feature_ptr shape_featureset<filterT>::next()
{
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
}
@ -197,42 +197,42 @@ feature_ptr shape_featureset<filterT>::next()
}
case shape_io::shape_polyline:
{
geometry2d * line = shape_.read_polyline();
geometry_type * line = shape_.read_polyline();
feature->add_geometry(line);
++count_;
break;
}
case shape_io::shape_polylinem:
{
geometry2d * line = shape_.read_polylinem();
geometry_type * line = shape_.read_polylinem();
feature->add_geometry(line);
++count_;
break;
}
case shape_io::shape_polylinez:
{
geometry2d * line = shape_.read_polylinez();
geometry_type * line = shape_.read_polylinez();
feature->add_geometry(line);
++count_;
break;
}
case shape_io::shape_polygon:
{
geometry2d * poly = shape_.read_polygon();
geometry_type * poly = shape_.read_polygon();
feature->add_geometry(poly);
++count_;
break;
}
case shape_io::shape_polygonm:
{
geometry2d * poly = shape_.read_polygonm();
geometry_type * poly = shape_.read_polygonm();
feature->add_geometry(poly);
++count_;
break;
}
case shape_io::shape_polygonz:
{
geometry2d * poly = shape_.read_polygonz();
geometry_type * poly = shape_.read_polygonz();
feature->add_geometry(poly);
++count_;
break;

22
plugins/input/shape/shape_index_featureset.cpp
View file

@ -91,7 +91,7 @@ template <typename filterT>
feature_ptr shape_index_featureset<filterT>::next()
{
using mapnik::feature_factory;
using mapnik::point_impl;
using mapnik::geometry_type;
if (itr_!=ids_.end())
{
int pos=*itr_++;
@ -103,7 +103,7 @@ feature_ptr shape_index_featureset<filterT>::next()
{
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
++count_;
@ -114,7 +114,7 @@ feature_ptr shape_index_featureset<filterT>::next()
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
shape_.shp().skip(8);// skip m
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
++count_;
@ -131,7 +131,7 @@ feature_ptr shape_index_featureset<filterT>::next()
{
shape_.shp().skip(8);
}
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
++count_;
@ -156,7 +156,7 @@ feature_ptr shape_index_featureset<filterT>::next()
{
double x=shape_.shp().read_double();
double y=shape_.shp().read_double();
geometry2d * point = new point_impl;
geometry_type * point = new geometry_type(mapnik::Point);
point->move_to(x,y);
feature->add_geometry(point);
}
@ -166,42 +166,42 @@ feature_ptr shape_index_featureset<filterT>::next()
}
case shape_io::shape_polyline:
{
geometry2d * line = shape_.read_polyline();
geometry_type * line = shape_.read_polyline();
feature->add_geometry(line);
++count_;
break;
}
case shape_io::shape_polylinem:
{
geometry2d * line = shape_.read_polylinem();
geometry_type * line = shape_.read_polylinem();
feature->add_geometry(line);
++count_;
break;
}
case shape_io::shape_polylinez:
{
geometry2d * line = shape_.read_polylinez();
geometry_type * line = shape_.read_polylinez();
feature->add_geometry(line);
++count_;
break;
}
case shape_io::shape_polygon:
{
geometry2d * poly = shape_.read_polygon();
geometry_type * poly = shape_.read_polygon();
feature->add_geometry(poly);
++count_;
break;
}
case shape_io::shape_polygonm:
{
geometry2d * poly = shape_.read_polygonm();
geometry_type * poly = shape_.read_polygonm();
feature->add_geometry(poly);
++count_;
break;
}
case shape_io::shape_polygonz:
{
geometry2d * poly = shape_.read_polygonz();
geometry_type * poly = shape_.read_polygonz();
feature->add_geometry(poly);
++count_;
break;

31
plugins/input/shape/shape_io.cpp
View file

@ -27,6 +27,7 @@
using mapnik::datasource_exception;
using mapnik::geometry_type;
const std::string shape_io::SHP = ".shp";
const std::string shape_io::DBF = ".dbf";
@ -106,14 +107,13 @@ dbf_file& shape_io::dbf()
return dbf_;
}
geometry2d * shape_io::read_polyline()
geometry_type * shape_io::read_polyline()
{
using mapnik::line_string_impl;
shape_file::record_type record(reclength_*2-36);
shp_.read_record(record);
int num_parts=record.read_ndr_integer();
int num_points=record.read_ndr_integer();
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity(num_points + num_parts);
if (num_parts == 1)
{
@ -161,14 +161,13 @@ geometry2d * shape_io::read_polyline()
return line;
}
geometry2d * shape_io::read_polylinem()
geometry_type * shape_io::read_polylinem()
{
using mapnik::line_string_impl;
shape_file::record_type record(reclength_*2-36);
shp_.read_record(record);
int num_parts=record.read_ndr_integer();
int num_points=record.read_ndr_integer();
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity(num_points + num_parts);
if (num_parts == 1)
{
@ -224,14 +223,13 @@ geometry2d * shape_io::read_polylinem()
return line;
}
geometry2d * shape_io::read_polylinez()
geometry_type * shape_io::read_polylinez()
{
using mapnik::line_string_impl;
shape_file::record_type record(reclength_*2-36);
shp_.read_record(record);
int num_parts=record.read_ndr_integer();
int num_points=record.read_ndr_integer();
geometry2d * line = new line_string_impl;
geometry_type * line = new geometry_type(mapnik::LineString);
line->set_capacity(num_points + num_parts);
if (num_parts == 1)
{
@ -294,15 +292,14 @@ geometry2d * shape_io::read_polylinez()
return line;
}
geometry2d * shape_io::read_polygon()
geometry_type * shape_io::read_polygon()
{
using mapnik::polygon_impl;
shape_file::record_type record(reclength_*2-36);
shp_.read_record(record);
int num_parts=record.read_ndr_integer();
int num_points=record.read_ndr_integer();
std::vector<int> parts(num_parts);
geometry2d * poly = new polygon_impl;
geometry_type * poly = new geometry_type(mapnik::Polygon);
poly->set_capacity(num_points + num_parts);
for (int i=0;i<num_parts;++i)
{
@ -335,15 +332,14 @@ geometry2d * shape_io::read_polygon()
return poly;
}
geometry2d * shape_io::read_polygonm()
geometry_type * shape_io::read_polygonm()
{
using mapnik::polygon_impl;
shape_file::record_type record(reclength_*2-36);
shp_.read_record(record);
int num_parts=record.read_ndr_integer();
int num_points=record.read_ndr_integer();
std::vector<int> parts(num_parts);
geometry2d * poly = new polygon_impl;
geometry_type * poly = new geometry_type(mapnik::Polygon);
poly->set_capacity(num_points + num_parts);
for (int i=0;i<num_parts;++i)
{
@ -384,15 +380,14 @@ geometry2d * shape_io::read_polygonm()
return poly;
}
geometry2d * shape_io::read_polygonz()
geometry_type * shape_io::read_polygonz()
{
using mapnik::polygon_impl;
shape_file::record_type record(reclength_*2-36);
shp_.read_record(record);
int num_parts=record.read_ndr_integer();
int num_points=record.read_ndr_integer();
std::vector<int> parts(num_parts);
geometry2d * poly=new polygon_impl;
geometry_type * poly=new geometry_type(mapnik::Polygon);
poly->set_capacity(num_points + num_parts);
for (int i=0;i<num_parts;++i)
{

14
plugins/input/shape/shape_io.hpp
View file

@ -35,8 +35,6 @@
#include <boost/iostreams/device/file.hpp>
#include <boost/iostreams/device/mapped_file.hpp>
using mapnik::geometry2d;
struct shape_io : boost::noncopyable
{
static const std::string SHP;
@ -89,12 +87,12 @@ public:
void move_to(int id);
int type() const;
const box2d<double>& current_extent() const;
geometry2d * read_polyline();
geometry2d * read_polylinem();
geometry2d * read_polylinez();
geometry2d * read_polygon();
geometry2d * read_polygonm();
geometry2d * read_polygonz();
mapnik::geometry_type * read_polyline();
mapnik::geometry_type * read_polylinem();
mapnik::geometry_type * read_polylinez();
mapnik::geometry_type * read_polygon();
mapnik::geometry_type * read_polygonm();
mapnik::geometry_type * read_polygonz();
};
#endif //SHAPE_IO_HPP

4
plugins/input/sqlite/sqlite_featureset.cpp
View file

@ -41,10 +41,6 @@ using mapnik::box2d;
using mapnik::CoordTransform;
using mapnik::Feature;
using mapnik::feature_ptr;
using mapnik::point_impl;
using mapnik::line_string_impl;
using mapnik::polygon_impl;
using mapnik::geometry2d;
using mapnik::geometry_utils;
using mapnik::transcoder;

2
plugins/input/templates/helloworld/hello_featureset.cpp
View file

@ -24,7 +24,7 @@ mapnik::feature_ptr hello_featureset::next()
mapnik::coord2d center = box_.center();
// create a new geometry
mapnik::geometry2d * point = new mapnik::point_impl;
mapnik::geometry_type * point = new mapnik::point_impl;
// we use path type geometries in Mapnik to fit nicely with AGG and Cairo
// here we stick an x,y pair into the geometry

12
src/agg/process_building_symbolizer.cpp
View file

@ -54,8 +54,8 @@ void agg_renderer<T>::process(building_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform3<CoordTransform,geometry2d> path_type_roof;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef coord_transform3<CoordTransform,geometry_type> path_type_roof;
typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
@ -78,11 +78,11 @@ void agg_renderer<T>::process(building_symbolizer const& sym,
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 2)
{
boost::scoped_ptr<geometry2d> frame(new line_string_impl);
boost::scoped_ptr<geometry2d> roof(new polygon_impl);
boost::scoped_ptr<geometry_type> frame(new geometry_type(LineString));
boost::scoped_ptr<geometry_type> roof(new geometry_type(Polygon));
std::deque<segment_t> face_segments;
double x0(0);
double y0(0);
@ -109,7 +109,7 @@ void agg_renderer<T>::process(building_symbolizer const& sym,
std::deque<segment_t>::const_iterator itr=face_segments.begin();
for (;itr!=face_segments.end();++itr)
{
boost::scoped_ptr<geometry2d> faces(new polygon_impl);
boost::scoped_ptr<geometry_type> faces(new geometry_type(Polygon));
faces->move_to(itr->get<0>(),itr->get<1>());
faces->line_to(itr->get<2>(),itr->get<3>());
faces->line_to(itr->get<2>(),itr->get<3>() + height);

4
src/agg/process_line_pattern_symbolizer.cpp
View file

@ -48,7 +48,7 @@ void agg_renderer<T>::process(line_pattern_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8> pattern_type;
typedef agg::renderer_base<agg::pixfmt_rgba32_plain> renderer_base;
typedef agg::renderer_outline_image<renderer_base, pattern_type> renderer_type;
@ -72,7 +72,7 @@ void agg_renderer<T>::process(line_pattern_symbolizer const& sym,
metawriter_with_properties writer = sym.get_metawriter();
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 1)
{
path_type path(t_,geom,prj_trans);

4
src/agg/process_line_symbolizer.cpp
View file

@ -50,7 +50,7 @@ void agg_renderer<T>::process(line_symbolizer const& sym,
proj_transform const& prj_trans)
{
typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base;
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::renderer_outline_aa<ren_base> renderer_oaa;
typedef agg::rasterizer_outline_aa<renderer_oaa> rasterizer_outline_aa;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
@ -73,7 +73,7 @@ void agg_renderer<T>::process(line_symbolizer const& sym,
metawriter_with_properties writer = sym.get_metawriter();
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 1)
{
path_type path(t_,geom,prj_trans);

6
src/agg/process_markers_symbolizer.cpp
View file

@ -49,7 +49,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::pixfmt_rgba32 pixfmt;
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid;
@ -94,7 +94,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
for (unsigned i=0; i<feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() <= 1)
{
std::clog << "### Warning svg markers not supported yet for points within markers_symbolizer\n";
@ -175,7 +175,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
for (unsigned i=0; i<feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
//if (geom.num_points() <= 1) continue;
if (placement_method == MARKER_POINT_PLACEMENT || geom.num_points() <= 1)
{

4
src/agg/process_point_symbolizer.cpp
View file

@ -94,7 +94,7 @@ void agg_renderer<T>::process(point_symbolizer const& sym,
for (unsigned i=0; i<feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
geom.label_position(&x,&y);
prj_trans.backward(x,y,z);
t_.forward(&x,&y);
@ -142,7 +142,7 @@ void agg_renderer<T>::process(point_symbolizer const& sym,
{
for (unsigned i=0; i<feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
geom.label_position(&x,&y);
prj_trans.backward(x,y,z);

4
src/agg/process_polygon_pattern_symbolizer.cpp
View file

@ -47,7 +47,7 @@ void agg_renderer<T>::process(polygon_pattern_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base;
typedef agg::wrap_mode_repeat wrap_x_type;
typedef agg::wrap_mode_repeat wrap_y_type;
@ -108,7 +108,7 @@ void agg_renderer<T>::process(polygon_pattern_symbolizer const& sym,
metawriter_with_properties writer = sym.get_metawriter();
for (unsigned i=0;i<num_geometries;++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 2)
{
path_type path(t_,geom,prj_trans);

4
src/agg/process_polygon_symbolizer.cpp
View file

@ -44,7 +44,7 @@ void agg_renderer<T>::process(polygon_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
@ -66,7 +66,7 @@ void agg_renderer<T>::process(polygon_symbolizer const& sym,
metawriter_with_properties writer = sym.get_metawriter();
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry2d const& geom=feature.get_geometry(i);
geometry_type const& geom=feature.get_geometry(i);
if (geom.num_points() > 2)
{
path_type path(t_,geom,prj_trans);

6
src/agg/process_shield_symbolizer.cpp
View file

@ -43,7 +43,7 @@ void agg_renderer<T>::process(shield_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef agg::pixfmt_rgba32 pixfmt;
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid;
@ -143,7 +143,7 @@ void agg_renderer<T>::process(shield_symbolizer const& sym,
for (unsigned i=0;i<num_geom;++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 0 )
{
path_type path(t_,geom,prj_trans);
@ -274,7 +274,7 @@ void agg_renderer<T>::process(shield_symbolizer const& sym,
unsigned num_geom = feature.num_geometries();
for (unsigned i=0;i<num_geom;++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 0 )
{
path_type path(t_,geom,prj_trans);

4
src/agg/process_text_symbolizer.cpp
View file

@ -40,7 +40,7 @@ void agg_renderer<T>::process(text_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
expression_ptr name_expr = sym.get_name();
if (!name_expr) return;
@ -89,7 +89,7 @@ void agg_renderer<T>::process(text_symbolizer const& sym,
unsigned num_geom = feature.num_geometries();
for (unsigned i=0;i<num_geom;++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 0) // don't bother with empty geometries
{
placement text_placement(info,sym,scale_factor_);

42
src/cairo_renderer.cpp
View file

@ -568,7 +568,7 @@ void cairo_renderer_base::process(polygon_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
cairo_context context(context_);
@ -576,7 +576,7 @@ void cairo_renderer_base::process(polygon_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 2)
{
@ -600,8 +600,8 @@ void cairo_renderer_base::process(building_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform3<CoordTransform,geometry2d> path_type_roof;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef coord_transform3<CoordTransform,geometry_type> path_type_roof;
cairo_context context(context_);
@ -610,12 +610,12 @@ void cairo_renderer_base::process(building_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 2)
{
boost::scoped_ptr<geometry2d> frame(new line_string_impl);
boost::scoped_ptr<geometry2d> roof(new polygon_impl);
boost::scoped_ptr<geometry_type> frame(new line_string_impl);
boost::scoped_ptr<geometry_type> roof(new polygon_impl);
std::deque<segment_t> face_segments;
double x0(0);
double y0(0);
@ -649,7 +649,7 @@ void cairo_renderer_base::process(building_symbolizer const& sym,
std::deque<segment_t>::const_iterator itr = face_segments.begin();
for (; itr != face_segments.end(); ++itr)
{
boost::scoped_ptr<geometry2d> faces(new polygon_impl);
boost::scoped_ptr<geometry_type> faces(new polygon_impl);
faces->move_to(itr->get<0>(), itr->get<1>());
faces->line_to(itr->get<2>(), itr->get<3>());
@ -703,7 +703,7 @@ void cairo_renderer_base::process(line_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
cairo_context context(context_);
mapnik::stroke const& stroke_ = sym.get_stroke();
@ -712,7 +712,7 @@ void cairo_renderer_base::process(line_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 1)
{
@ -756,7 +756,7 @@ void cairo_renderer_base::process(point_symbolizer const& sym,
{
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
double x;
double y;
double z = 0;
@ -791,7 +791,7 @@ void cairo_renderer_base::process(shield_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
expression_ptr name_expr = sym.get_name();
if (!name_expr) return;
@ -831,7 +831,7 @@ void cairo_renderer_base::process(shield_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 0) // don't bother with empty geometries
{
@ -921,7 +921,7 @@ void cairo_renderer_base::process(line_pattern_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
std::string filename = path_processor_type::evaluate( *sym.get_filename(), feature);
boost::optional<mapnik::image_ptr> image = mapnik::image_cache::instance()->find(filename,true);
@ -939,7 +939,7 @@ void cairo_renderer_base::process(line_pattern_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 1)
{
@ -990,7 +990,7 @@ void cairo_renderer_base::process(polygon_pattern_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
cairo_context context(context_);
std::string filename = path_processor_type::evaluate( *sym.get_filename(), feature);
@ -1006,7 +1006,7 @@ void cairo_renderer_base::process(polygon_pattern_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 2)
{
@ -1067,7 +1067,7 @@ void cairo_renderer_base::process(markers_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
arrow arrow_;
cairo_context context(context_);
@ -1076,7 +1076,7 @@ void cairo_renderer_base::process(markers_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 1)
{
@ -1163,7 +1163,7 @@ void cairo_renderer_base::process(text_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry2d> path_type;
typedef coord_transform2<CoordTransform,geometry_type> path_type;
expression_ptr name_expr = sym.get_name();
if (!name_expr) return;
value_type result = boost::apply_visitor(evaluate<Feature,value_type>(feature),*name_expr);
@ -1203,7 +1203,7 @@ void cairo_renderer_base::process(text_symbolizer const& sym,
for (unsigned i = 0; i < feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 0) // don't bother with empty geometries
{

15
src/memory_datasource.cpp
View file

@ -37,7 +37,7 @@ struct accumulate_extent
{
for (unsigned i=0;i<feat->num_geometries();++i)
{
geometry2d & geom = feat->get_geometry(i);
geometry_type & geom = feat->get_geometry(i);
if ( first_ )
{
first_ = false;
@ -100,4 +100,17 @@ size_t memory_datasource::size() const
{
return features_.size();
}
// point_datasource
void point_datasource::add_point(double x, double y, const char* key, const char* value)
{
feature_ptr feature(feature_factory::create(feat_id++));
geometry_type * pt = new geometry_type(Point);
pt->move_to(x,y);
feature->add_geometry(pt);
transcoder tr("utf-8");
(*feature)[key] = tr.transcode(value);
this->push(feature);
}
}

2
src/placement_finder.cpp
View file

@ -942,7 +942,7 @@ void placement_finder<DetectorT>::clear()
detector_.clear();
}
typedef coord_transform2<CoordTransform,geometry2d> PathType;
typedef coord_transform2<CoordTransform,geometry_type> PathType;
typedef label_collision_detector4 DetectorType;
template class placement_finder<DetectorType>;

66
src/svg/process_symbolizers.cpp
View file

@ -26,43 +26,43 @@
namespace mapnik {
template <typename OutputIterator>
bool svg_renderer<OutputIterator>::process(rule_type::symbolizers const& syms,
Feature const& feature,
proj_transform const& prj_trans)
template <typename OutputIterator>
bool svg_renderer<OutputIterator>::process(rule_type::symbolizers const& syms,
Feature const& feature,
proj_transform const& prj_trans)
{
// svg renderer supports processing of multiple symbolizers.
typedef coord_transform2<CoordTransform, geometry_type> path_type;
// process each symbolizer to collect its (path) information.
// path information (attributes from line_ and polygon_ symbolizers)
// is collected with the path_attributes_ data member.
BOOST_FOREACH(symbolizer const& sym, syms)
{
// svg renderer supports processing of multiple symbolizers.
boost::apply_visitor(symbol_dispatch(*this, feature, prj_trans), sym);
}
typedef coord_transform2<CoordTransform, geometry2d> path_type;
// generate path output for each geometry of the current feature.
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);
generator_.generate_path(path, path_attributes_);
}
}
// process each symbolizer to collect its (path) information.
// path information (attributes from line_ and polygon_ symbolizers)
// is collected with the path_attributes_ data member.
BOOST_FOREACH(symbolizer const& sym, syms)
{
boost::apply_visitor(symbol_dispatch(*this, feature, prj_trans), sym);
}
// set the previously collected values back to their defaults
// for the feature that will be processed next.
path_attributes_.reset();
// generate path output for each geometry of the current feature.
for(unsigned i=0; i<feature.num_geometries(); ++i)
{
geometry2d const& geom = feature.get_geometry(i);
if(geom.num_points() > 1)
{
path_type path(t_, geom, prj_trans);
generator_.generate_path(path, path_attributes_);
}
}
return true;
};
// set the previously collected values back to their defaults
// for the feature that will be processed next.
path_attributes_.reset();
return true;
};
template bool svg_renderer<std::ostream_iterator<char> >::process(rule_type::symbolizers const& syms,
Feature const& feature,
proj_transform const& prj_trans);
template bool svg_renderer<std::ostream_iterator<char> >::process(rule_type::symbolizers const& syms,
Feature const& feature,
proj_transform const& prj_trans);
}

12
src/wkb.cpp
View file

@ -203,7 +203,7 @@ private:
void read_point(Feature & feature)
{
geometry2d * pt = new geometry2d;//new point<vertex2d>;
geometry_type * pt = new geometry_type(Point);
double x = read_double();
double y = read_double();
pt->move_to(x,y);
@ -222,7 +222,7 @@ private:
void read_multipoint_2(Feature & feature)
{
geometry2d * pt = new geometry2d;//point<vertex2d>;
geometry_type * pt = new geometry_type(Point);
int num_points = read_integer();
for (int i=0;i<num_points;++i)
{
@ -236,7 +236,7 @@ private:
void read_linestring(Feature & feature)
{
geometry2d * line = new geometry2d;//line_string<vertex2d>;
geometry_type * line = new geometry_type(LineString);
int num_points=read_integer();
CoordinateArray ar(num_points);
read_coords(ar);
@ -261,7 +261,7 @@ private:
void read_multilinestring_2(Feature & feature)
{
geometry2d * line = new geometry2d;//line_string<vertex2d>;
geometry_type * line = new geometry_type(LineString);
int num_lines=read_integer();
unsigned capacity = 0;
for (int i=0;i<num_lines;++i)
@ -283,7 +283,7 @@ private:
void read_polygon(Feature & feature)
{
geometry2d * poly = new polygon<vertex2d>;
geometry_type * poly = new geometry_type(Polygon);
int num_rings=read_integer();
unsigned capacity = 0;
for (int i=0;i<num_rings;++i)
@ -314,7 +314,7 @@ private:
void read_multipolygon_2(Feature & feature)
{
geometry2d * poly = new polygon<vertex2d>;
geometry_type * poly = new geometry_type(Polygon);
int num_polys=read_integer();
unsigned capacity = 0;
for (int i=0;i<num_polys;++i)

2
utils/pgsql2sqlite/pgsql2sqlite.hpp
View file

@ -364,7 +364,7 @@ void pgsql2sqlite(Connection conn,
geometry_utils::from_wkb(feat,buf,size,false,wkbGeneric);
if (feat.num_geometries() > 0)
{
geometry2d const& geom=feat.get_geometry(0);
geometry_type const& geom=feat.get_geometry(0);
box2d<double> bbox = geom.envelope();
if (valid_envelope(bbox))
{