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

remove geos plugin (moved to https://github.com/mapnik/non-core-plugins) - refs #1809

Browse source
This commit is contained in:
Dane Springmeyer 2013-04-19 14:09:25 -07:00
parent 1ae236c176
commit 4c38bf9b81
7 changed files with 2 additions and 754 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
SConstruct
View file

@ -58,7 +58,6 @@ pretty_dep_names = {
'ociei':'Oracle database library | configure with OCCI_LIBS & OCCI_INCLUDES | more info: https://github.com/mapnik/mapnik/wiki//OCCI',
'gdal':'GDAL C++ library | configured using gdal-config program | try setting GDAL_CONFIG SCons option | more info: https://github.com/mapnik/mapnik/wiki/GDAL',
'ogr':'OGR-enabled GDAL C++ Library | configured using gdal-config program | try setting GDAL_CONFIG SCons option | more info: https://github.com/mapnik/mapnik/wiki//OGR',
'geos_c':'GEOS Simple Geometry Specification C Library | configured with GEOS_LIB & GEOS_INCLUDE | more info: https://github.com/mapnik/mapnik/wiki//GEOS',
'cairo':'Cairo C library | configured using pkg-config | try setting PKG_CONFIG_PATH SCons option',
'pycairo':'Python bindings to Cairo library | configured using pkg-config | try setting PKG_CONFIG_PATH SCons option',
'proj':'Proj.4 C Projections library | configure with PROJ_LIBS & PROJ_INCLUDES | more info: http://trac.osgeo.org/proj/',
@ -74,7 +73,6 @@ pretty_dep_names = {
'pg_config':'pg_config program | try setting PG_CONFIG SCons option',
'xml2-config':'xml2-config program | try setting XML2_CONFIG SCons option',
'gdal-config':'gdal-config program | try setting GDAL_CONFIG SCons option',
'geos-config':'geos-config program | try setting GEOS_CONFIG SCons option',
'freetype-config':'freetype-config program | try setting FREETYPE_CONFIG SCons option',
'osm':'more info: https://github.com/mapnik/mapnik/wiki//OsmPlugin',
'curl':'libcurl is required for the "osm" plugin - more info: https://github.com/mapnik/mapnik/wiki//OsmPlugin',
@ -90,7 +88,6 @@ PLUGINS = { # plugins with external dependencies
'postgis': {'default':True,'path':None,'inc':'libpq-fe.h','lib':'pq','lang':'C'},
'gdal': {'default':True,'path':None,'inc':'gdal_priv.h','lib':'gdal','lang':'C++'},
'ogr': {'default':True,'path':None,'inc':'ogrsf_frmts.h','lib':'gdal','lang':'C++'},
'geos': {'default':False,'path':None,'inc':'geos_c.h','lib':'geos_c','lang':'C'},
# configured with custom paths, hence 'path': PREFIX/INCLUDES/LIBS
'occi': {'default':False,'path':'OCCI','inc':'occi.h','lib':'ociei','lang':'C++'},
'sqlite': {'default':True,'path':'SQLITE','inc':'sqlite3.h','lib':'sqlite3','lang':'C'},
@ -330,7 +327,6 @@ PathVariable.PathAccept),
BoolVariable('CPP_TESTS', 'Compile the C++ tests', 'True'),
# Variables for optional dependencies
('GEOS_CONFIG', 'The path to the geos-config executable.', 'geos-config'),
# Note: cairo and and pycairo are optional but configured automatically through pkg-config
# Therefore, we use a single boolean for whether to attempt to build cairo support.
BoolVariable('CAIRO', 'Attempt to build with Cairo rendering support', 'True'),
@ -549,7 +545,7 @@ def parse_config(context, config, checks='--libs --cflags'):
env = context.env
tool = config.lower().replace('_','-')
toolname = tool
if config in ('GDAL_CONFIG','GEOS_CONFIG'):
if config in ('GDAL_CONFIG'):
toolname += ' %s' % checks
context.Message( 'Checking for %s... ' % toolname)
cmd = '%s %s' % (env[config],checks)
@ -578,7 +574,7 @@ def parse_config(context, config, checks='--libs --cflags'):
ret = False
print ' (xml2-config not found!)'
if not parsed:
if config in ('GDAL_CONFIG','GEOS_CONFIG'):
if config in ('GDAL_CONFIG'):
# optional deps...
env['SKIPPED_DEPS'].append(tool)
conf.rollback_option(config)
@ -1284,11 +1280,6 @@ if not preconfigured:
libname = conf.get_pkg_lib('GDAL_CONFIG','ogr')
if libname:
details['lib'] = libname
elif plugin == 'geos':
if conf.parse_config('GEOS_CONFIG',checks='--ldflags --cflags'):
lgeos_c = env['PLUGINS']['geos']['lib']
env.Append(LIBS = lgeos_c)
elif details['path'] and details['lib'] and details['inc']:
backup = env.Clone().Dictionary()
# Note, the 'delete_existing' keyword makes sure that these paths are prepended

52
plugins/input/geos/build.py
View file

@ -1,52 +0,0 @@
#
# This file is part of Mapnik (c++ mapping toolkit)
#
# Copyright (C) 2007 Artem Pavlenko, Jean-Francois Doyon
#
# Mapnik is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
#
Import ('plugin_base')
Import ('env')
prefix = env['PREFIX']
plugin_env = plugin_base.Clone()
geos_src = Split(
"""
geos_datasource.cpp
geos_featureset.cpp
"""
)
libraries = [env['PLUGINS']['geos']['lib']]
# Link Library to Dependencies
libraries.append('mapnik')
libraries.append(env['ICU_LIB_NAME'])
libraries.append('boost_system%s' % env['BOOST_APPEND'])
libraries.append('boost_filesystem%s' % env['BOOST_APPEND'])
input_plugin = plugin_env.SharedLibrary('../geos', source=geos_src, SHLIBPREFIX='', SHLIBSUFFIX='.input', LIBS=libraries, LINKFLAGS=env['CUSTOM_LDFLAGS'])
# if the plugin links to libmapnik ensure it is built first
Depends(input_plugin, env.subst('../../../src/%s' % env['MAPNIK_LIB_NAME']))
if 'uninstall' not in COMMAND_LINE_TARGETS:
env.Install(env['MAPNIK_INPUT_PLUGINS_DEST'], input_plugin)
env.Alias('install', env['MAPNIK_INPUT_PLUGINS_DEST'])

317
plugins/input/geos/geos_datasource.cpp
View file

@ -1,317 +0,0 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#include "geos_datasource.hpp"
#include "geos_featureset.hpp"
// stl
#include <sstream>
#include <fstream>
#include <stdexcept>
#include <cstdarg>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp>
#include <mapnik/value_types.hpp>
// boost
#include <boost/algorithm/string.hpp>
#include <boost/limits.hpp>
#include <boost/tokenizer.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/make_shared.hpp>
// geos
#include <geos_c.h>
using mapnik::box2d;
using mapnik::coord2d;
using mapnik::query;
using mapnik::featureset_ptr;
using mapnik::layer_descriptor;
using mapnik::attribute_descriptor;
using mapnik::datasource_exception;
using mapnik::datasource;
using mapnik::parameters;
using mapnik::filter_in_box;
DATASOURCE_PLUGIN(geos_datasource)
void geos_notice(const char* format, ...)
{
#ifdef MAPNIK_LOG
char buffer[512];
va_list args;
va_start(args, format);
vsnprintf(buffer, 512, format, args);
va_end(args);
MAPNIK_LOG_WARN(geos) << "geos_datasource: " << buffer;
#endif
}
void geos_error(const char* format, ...)
{
#ifdef MAPNIK_LOG
char buffer[512];
va_list args;
va_start(args, format);
vsnprintf(buffer, 512, format, args);
va_end(args);
MAPNIK_LOG_ERROR(geos) << "geos_datasource: " << buffer;
#endif
}
geos_datasource::geos_datasource(parameters const& params)
: datasource(params),
extent_(),
extent_initialized_(false),
type_(datasource::Vector),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")),
geometry_data_(""),
geometry_data_name_("name"),
geometry_id_(1)
{
boost::optional<std::string> geometry = params.get<std::string>("wkt");
if (! geometry) throw datasource_exception("missing <wkt> parameter");
geometry_string_ = *geometry;
boost::optional<std::string> ext = params.get<std::string>("extent");
if (ext) extent_initialized_ = extent_.from_string(*ext);
boost::optional<int> id = params.get<int>("gid");
if (id) geometry_id_ = *id;
boost::optional<std::string> gdata = params.get<std::string>("field_data");
if (gdata) geometry_data_ = *gdata;
boost::optional<std::string> gdata_name = params.get<std::string>("field_name");
if (gdata_name) geometry_data_name_ = *gdata_name;
desc_.add_descriptor(attribute_descriptor(geometry_data_name_, mapnik::String));
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::init");
#endif
// open geos driver
initGEOS(geos_notice, geos_error);
// parse the string into geometry
geometry_.set_feature(GEOSGeomFromWKT(geometry_string_.c_str()));
if (*geometry_ == NULL || ! GEOSisValid(*geometry_))
{
throw datasource_exception("GEOS Plugin: invalid <wkt> geometry specified");
}
// try to obtain the extent from the geometry itself
if (! extent_initialized_)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "geos_datasource::init(initialize_extent)");
#endif
MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Initializing extent from geometry";
if (GEOSGeomTypeId(*geometry_) == GEOS_POINT)
{
double x, y;
unsigned int size;
const GEOSCoordSequence* cs = GEOSGeom_getCoordSeq(*geometry_);
GEOSCoordSeq_getSize(cs, &size);
GEOSCoordSeq_getX(cs, 0, &x);
GEOSCoordSeq_getY(cs, 0, &y);
extent_.init(x, y, x, y);
extent_initialized_ = true;
}
else
{
geos_feature_ptr envelope (GEOSEnvelope(*geometry_));
if (*envelope != NULL && GEOSisValid(*envelope))
{
#ifdef MAPNIK_LOG
char* wkt = GEOSGeomToWKT(*envelope);
MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Getting coord sequence from=" << wkt;
GEOSFree(wkt);
#endif
const GEOSGeometry* exterior = GEOSGetExteriorRing(*envelope);
if (exterior != NULL && GEOSisValid(exterior))
{
const GEOSCoordSequence* cs = GEOSGeom_getCoordSeq(exterior);
if (cs != NULL)
{
MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Iterating boundary points";
double x, y;
double minx = std::numeric_limits<float>::max(),
miny = std::numeric_limits<float>::max(),
maxx = -std::numeric_limits<float>::max(),
maxy = -std::numeric_limits<float>::max();
unsigned int num_points;
GEOSCoordSeq_getSize(cs, &num_points);
for (unsigned int i = 0; i < num_points; ++i)
{
GEOSCoordSeq_getX(cs, i, &x);
GEOSCoordSeq_getY(cs, i, &y);
if (x < minx) minx = x;
if (x > maxx) maxx = x;
if (y < miny) miny = y;
if (y > maxy) maxy = y;
}
extent_.init(minx, miny, maxx, maxy);
extent_initialized_ = true;
}
}
}
}
}
if (! extent_initialized_)
{
throw datasource_exception("GEOS Plugin: cannot determine extent for <wkt> geometry");
}
}
geos_datasource::~geos_datasource()
{
{
geometry_.set_feature(0);
finishGEOS();
}
}
const char * geos_datasource::name()
{
return "geos";
}
mapnik::datasource::datasource_t geos_datasource::type() const
{
return type_;
}
box2d<double> geos_datasource::envelope() const
{
return extent_;
}
boost::optional<mapnik::datasource::geometry_t> geos_datasource::get_geometry_type() const
{
boost::optional<mapnik::datasource::geometry_t> result;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::get_geometry_type");
#endif
// get geometry type
const int type = GEOSGeomTypeId(*geometry_);
switch (type)
{
case GEOS_POINT:
case GEOS_MULTIPOINT:
result.reset(mapnik::datasource::Point);
break;
case GEOS_LINESTRING:
case GEOS_LINEARRING:
case GEOS_MULTILINESTRING:
result.reset(mapnik::datasource::LineString);
break;
case GEOS_POLYGON:
case GEOS_MULTIPOLYGON:
result.reset(mapnik::datasource::Polygon);
break;
case GEOS_GEOMETRYCOLLECTION:
result.reset(mapnik::datasource::Collection);
break;
default:
break;
}
return result;
}
layer_descriptor geos_datasource::get_descriptor() const
{
return desc_;
}
featureset_ptr geos_datasource::features(query const& q) const
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::features");
#endif
const mapnik::box2d<double> extent = q.get_bbox();
std::ostringstream s;
s << "POLYGON(("
<< extent.minx() << " " << extent.miny() << ","
<< extent.maxx() << " " << extent.miny() << ","
<< extent.maxx() << " " << extent.maxy() << ","
<< extent.minx() << " " << extent.maxy() << ","
<< extent.minx() << " " << extent.miny()
<< "))";
MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Using extent=" << s.str();
return boost::make_shared<geos_featureset>(*geometry_,
GEOSGeomFromWKT(s.str().c_str()),
geometry_id_,
geometry_data_,
geometry_data_name_,
desc_.get_encoding());
}
featureset_ptr geos_datasource::features_at_point(coord2d const& pt, double tol) const
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::features_at_point");
#endif
std::ostringstream s;
s << "POINT(" << pt.x << " " << pt.y << ")";
MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Using point=" << s.str();
return boost::make_shared<geos_featureset>(*geometry_,
GEOSGeomFromWKT(s.str().c_str()),
geometry_id_,
geometry_data_,
geometry_data_name_,
desc_.get_encoding());
}

71
plugins/input/geos/geos_datasource.hpp
View file

@ -1,71 +0,0 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef GEOS_DATASOURCE_HPP
#define GEOS_DATASOURCE_HPP
// mapnik
#include <mapnik/datasource.hpp>
#include <mapnik/params.hpp>
#include <mapnik/query.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
// boost
#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
// stl
#include <vector>
#include <string>
#include "geos_feature_ptr.hpp"
class geos_datasource : public mapnik::datasource
{
public:
geos_datasource(mapnik::parameters const& params);
virtual ~geos_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
mapnik::featureset_ptr features(mapnik::query const& q) const;
mapnik::featureset_ptr features_at_point(mapnik::coord2d const& pt, double tol = 0) const;
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
private:
void init(mapnik::parameters const& params);
mapnik::box2d<double> extent_;
bool extent_initialized_;
mapnik::datasource::datasource_t type_;
mapnik::layer_descriptor desc_;
mutable geos_feature_ptr geometry_;
std::string geometry_data_;
std::string geometry_data_name_;
int geometry_id_;
std::string geometry_string_;
};
#endif // GEOS_DATASOURCE_HPP

108
plugins/input/geos/geos_feature_ptr.hpp
View file

@ -1,108 +0,0 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef GEOS_FEATURE_PTR_HPP
#define GEOS_FEATURE_PTR_HPP
// geos
#include <geos_c.h>
#include <cstdlib>
class geos_feature_ptr
{
public:
geos_feature_ptr ()
: feat_ (NULL)
{
}
explicit geos_feature_ptr (GEOSGeometry* const feat)
: feat_ (feat)
{
}
~geos_feature_ptr ()
{
if (feat_ != NULL)
GEOSGeom_destroy(feat_);
}
void set_feature (GEOSGeometry* const feat)
{
if (feat_ != NULL)
GEOSGeom_destroy(feat_);
feat_ = feat;
}
GEOSGeometry* operator*()
{
return feat_;
}
private:
GEOSGeometry* feat_;
};
class geos_wkb_ptr
{
public:
geos_wkb_ptr (GEOSGeometry* const geometry)
: data_ (NULL),
size_ (0)
{
data_ = GEOSGeomToWKB_buf(geometry, &size_);
}
~geos_wkb_ptr ()
{
if (data_ != NULL)
{
// We use std::free here instead of GEOSFree(data_) to support geos 3.1.0
std::free(data_);
}
}
bool is_valid() const
{
return (data_ != NULL) && (size_ > 0);
}
unsigned int size() const
{
return (unsigned int) size_;
}
const char* data()
{
return reinterpret_cast<const char*>(data_);
}
private:
unsigned char* data_;
size_t size_;
};
#endif // GEOS_FEATURE_PTR_HPP

129
plugins/input/geos/geos_featureset.cpp
View file

@ -1,129 +0,0 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/wkb.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/feature_factory.hpp>
#include "geos_featureset.hpp"
// boost
#include <boost/make_shared.hpp>
using mapnik::query;
using mapnik::box2d;
using mapnik::feature_ptr;
using mapnik::geometry_utils;
using mapnik::transcoder;
using mapnik::feature_factory;
geos_featureset::geos_featureset(GEOSGeometry* geometry,
GEOSGeometry* extent,
mapnik::value_integer feature_id,
std::string const& field,
std::string const& field_name,
std::string const& encoding)
: geometry_(geometry),
tr_(new transcoder(encoding)),
extent_(extent),
feature_id_(feature_id),
field_(field),
field_name_(field_name),
already_rendered_(false),
ctx_(boost::make_shared<mapnik::context_type>())
{
ctx_->push(field_name);
}
geos_featureset::~geos_featureset()
{
}
feature_ptr geos_featureset::next()
{
if (! already_rendered_)
{
already_rendered_ = true;
if (GEOSisValid(geometry_) && ! GEOSisEmpty(geometry_))
{
bool render_geometry = true;
if (*extent_ != NULL && GEOSisValid(*extent_) && ! GEOSisEmpty(*extent_))
{
const int type = GEOSGeomTypeId(*extent_);
render_geometry = false;
switch (type)
{
case GEOS_POINT:
if (GEOSIntersects(*extent_, geometry_))
{
render_geometry = true;
}
break;
case GEOS_POLYGON:
if (GEOSContains(*extent_, geometry_)
|| GEOSWithin(geometry_, *extent_)
|| GEOSEquals(geometry_, *extent_))
{
render_geometry = true;
}
break;
default:
MAPNIK_LOG_DEBUG(geos) << "geos_featureset: Unknown extent geometry_type=" << type;
break;
}
}
if (render_geometry)
{
geos_wkb_ptr wkb(geometry_);
if (wkb.is_valid())
{
feature_ptr feature(feature_factory::create(ctx_,feature_id_));
if (geometry_utils::from_wkb(feature->paths(),
wkb.data(),
wkb.size())
&& field_ != "")
{
feature->put(field_name_, tr_->transcode(field_.c_str()));
}
return feature;
}
}
}
}
return feature_ptr();
}

66
plugins/input/geos/geos_featureset.hpp
View file

@ -1,66 +0,0 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef GEOS_FEATURESET_HPP
#define GEOS_FEATURESET_HPP
// mapnik
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/geom_util.hpp>
// boost
#include <boost/scoped_ptr.hpp>
// geos
#include <geos_c.h>
#include "geos_feature_ptr.hpp"
class geos_featureset : public mapnik::Featureset
{
public:
geos_featureset(GEOSGeometry* geometry,
GEOSGeometry* extent,
mapnik::value_integer feature_id,
std::string const& field,
std::string const& field_name,
std::string const& encoding);
virtual ~geos_featureset();
mapnik::feature_ptr next();
private:
GEOSGeometry* geometry_;
boost::scoped_ptr<mapnik::transcoder> tr_;
geos_feature_ptr extent_;
mapnik::value_integer feature_id_;
std::string field_;
std::string field_name_;
bool already_rendered_;
mapnik::context_ptr ctx_;
geos_featureset(const geos_featureset&);
const geos_featureset& operator=(const geos_featureset&);
};
#endif // GEOS_FEATURESET_HPP