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

Merge branch 'master' into bigint

Browse source 
Conflicts:
	plugins/input/geojson/geojson_datasource.cpp
	plugins/input/postgis/postgis_featureset.cpp
This commit is contained in:
artemp 2012-12-18 13:57:39 +00:00
commit a38b252ccd
126 changed files with 1015 additions and 1042 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
SConstruct
View file

@ -1331,7 +1331,7 @@ if not preconfigured:
else:
color_print(4,'Not building with cairo support, pass CAIRO=True to enable')
if 'python' in env['BINDINGS']:
if 'python' in env['BINDINGS'] or 'python' in env['REQUESTED_PLUGINS']:
if not os.access(env['PYTHON'], os.X_OK):
color_print(1,"Cannot run python interpreter at '%s', make sure that you have the permissions to execute it." % env['PYTHON'])
Exit(1)
@ -1386,22 +1386,22 @@ if not preconfigured:
else:
env['PYTHON_IS_64BIT'] = False
if py3 and env['BOOST_PYTHON_LIB'] == 'boost_python':
env['BOOST_PYTHON_LIB'] = 'boost_python3%s' % env['BOOST_APPEND']
elif env['BOOST_PYTHON_LIB'] == 'boost_python':
env['BOOST_PYTHON_LIB'] = 'boost_python%s' % env['BOOST_APPEND']
if 'python' in env['BINDINGS']:
if py3 and env['BOOST_PYTHON_LIB'] == 'boost_python':
env['BOOST_PYTHON_LIB'] = 'boost_python3%s' % env['BOOST_APPEND']
elif env['BOOST_PYTHON_LIB'] == 'boost_python':
env['BOOST_PYTHON_LIB'] = 'boost_python%s' % env['BOOST_APPEND']
if not conf.CheckHeader(header='boost/python/detail/config.hpp',language='C++'):
color_print(1,'Could not find required header files for boost python')
env['MISSING_DEPS'].append('boost python')
if not conf.CheckHeader(header='boost/python/detail/config.hpp',language='C++'):
color_print(1,'Could not find required header files for boost python')
env['MISSING_DEPS'].append('boost python')
if env['CAIRO']:
if conf.CheckPKGConfig('0.15.0') and conf.CheckPKG('pycairo'):
env['HAS_PYCAIRO'] = True
if env['CAIRO']:
if conf.CheckPKGConfig('0.15.0') and conf.CheckPKG('pycairo'):
env['HAS_PYCAIRO'] = True
else:
env['SKIPPED_DEPS'].extend(['pycairo'])
else:
env['SKIPPED_DEPS'].extend(['pycairo'])
else:
color_print(4,'Not building with pycairo support, pass CAIRO=True to enable')
color_print(4,'Not building with pycairo support, pass CAIRO=True to enable')
#### End Config Stage for Required Dependencies ####
@ -1526,7 +1526,7 @@ if not preconfigured:
if env['DEBUG_UNDEFINED']:
env.Append(CXXFLAGS = '-fcatch-undefined-behavior -ftrapv -fwrapv')
if 'python' in env['BINDINGS']:
if 'python' in env['BINDINGS'] or 'python' in env['REQUESTED_PLUGINS']:
majver, minver = env['PYTHON_VERSION'].split('.')
# we don't want the includes it in the main environment...
# as they are later set in the python build.py
@ -1542,9 +1542,10 @@ if not preconfigured:
color_print(1,"Python version 2.2 or greater required")
Exit(1)
color_print(4,'Bindings Python version... %s' % env['PYTHON_VERSION'])
color_print(4,'Python %s prefix... %s' % (env['PYTHON_VERSION'], env['PYTHON_SYS_PREFIX']))
color_print(4,'Python bindings will install in... %s' % os.path.normpath(env['PYTHON_INSTALL_LOCATION']))
if 'python' in env['BINDINGS']:
color_print(4,'Bindings Python version... %s' % env['PYTHON_VERSION'])
color_print(4,'Python %s prefix... %s' % (env['PYTHON_VERSION'], env['PYTHON_SYS_PREFIX']))
color_print(4,'Python bindings will install in... %s' % os.path.normpath(env['PYTHON_INSTALL_LOCATION']))
env.Replace(**backup)
# if requested, sort LIBPATH and CPPPATH one last time before saving...

13
bindings/python/mapnik_datasource.cpp
View file

@ -23,6 +23,7 @@
// boost
#include <boost/python.hpp>
#include <boost/python/detail/api_placeholder.hpp>
#include <boost/noncopyable.hpp>
// stl
#include <sstream>
@ -49,24 +50,15 @@ namespace
using namespace boost::python;
boost::shared_ptr<mapnik::datasource> create_datasource(const dict& d)
{
bool bind=true;
mapnik::parameters params;
boost::python::list keys=d.keys();
for (int i=0; i<len(keys); ++i)
{
std::string key = extract<std::string>(keys[i]);
object obj = d[key];
if (key == "bind")
{
bind = extract<bool>(obj)();
continue;
}
extract<std::string> ex0(obj);
extract<mapnik::value_integer> ex1(obj);
extract<double> ex2(obj);
if (ex0.check())
{
params[key] = ex0();
@ -81,7 +73,7 @@ boost::shared_ptr<mapnik::datasource> create_datasource(const dict& d)
}
}
return mapnik::datasource_cache::instance().create(params, bind);
return mapnik::datasource_cache::instance().create(params);
}
boost::python::dict describe(boost::shared_ptr<mapnik::datasource> const& ds)
@ -169,7 +161,6 @@ void export_datasource()
.def("describe",&describe)
.def("envelope",&datasource::envelope)
.def("features",&datasource::features)
.def("bind",&datasource::bind)
.def("fields",&fields)
.def("field_types",&field_types)
.def("features_at_point",&datasource::features_at_point, (arg("coord"),arg("tolerance")=0))

12
bindings/python/mapnik_datasource_cache.cpp
View file

@ -21,6 +21,8 @@
*****************************************************************************/
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
#include <mapnik/datasource_cache.hpp>
namespace {
@ -29,20 +31,12 @@ using namespace boost::python;
boost::shared_ptr<mapnik::datasource> create_datasource(const dict& d)
{
bool bind=true;
mapnik::parameters params;
boost::python::list keys=d.keys();
for (int i=0; i<len(keys); ++i)
{
std::string key = extract<std::string>(keys[i]);
object obj = d[key];
if (key == "bind")
{
bind = extract<bool>(obj)();
continue;
}
extract<std::string> ex0(obj);
extract<mapnik::value_integer> ex1(obj);
extract<double> ex2(obj);
@ -61,7 +55,7 @@ boost::shared_ptr<mapnik::datasource> create_datasource(const dict& d)
}
}
return mapnik::datasource_cache::instance().create(params, bind);
return mapnik::datasource_cache::instance().create(params);
}
void register_datasources(std::string const& path)

2
bindings/python/mapnik_expression.cpp
View file

@ -23,6 +23,8 @@
// boost
#include <boost/python.hpp>
#include <boost/variant.hpp>
#include <boost/noncopyable.hpp>
// mapnik
#include <mapnik/feature.hpp>

2
bindings/python/mapnik_feature.cpp
View file

@ -28,6 +28,8 @@
#include <boost/python/tuple.hpp>
#include <boost/python/to_python_converter.hpp>
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
// mapnik
#include <mapnik/feature.hpp>

1
bindings/python/mapnik_featureset.cpp
View file

@ -22,6 +22,7 @@
// boost
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
// mapnik
#include <mapnik/feature.hpp>

2
bindings/python/mapnik_font_engine.cpp
View file

@ -21,6 +21,8 @@
*****************************************************************************/
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
#include <mapnik/font_engine_freetype.hpp>
void export_font_engine()

2
bindings/python/mapnik_geometry.cpp
View file

@ -26,6 +26,8 @@
#include <boost/python/iterator.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
// mapnik
#include <mapnik/geometry.hpp>

2
bindings/python/mapnik_label_collision_detector.cpp
View file

@ -24,6 +24,8 @@
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <mapnik/label_collision_detector.hpp>
#include <mapnik/map.hpp>

2
bindings/python/mapnik_logger.cpp
View file

@ -21,6 +21,8 @@
*****************************************************************************/
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/utils.hpp>
#include "mapnik_enumeration.hpp"

1
bindings/python/mapnik_palette.cpp
View file

@ -23,6 +23,7 @@
// boost
#include <boost/python.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
//mapnik
#include <mapnik/palette.hpp>

1
bindings/python/mapnik_proj_transform.cpp
View file

@ -22,6 +22,7 @@
// mapnik
#include <mapnik/proj_transform.hpp>
#include <boost/noncopyable.hpp>
// boost
#include <boost/python.hpp>

1
bindings/python/mapnik_text_placement.cpp
View file

@ -21,6 +21,7 @@
*****************************************************************************/
#include <boost/python.hpp>
#include <boost/python/stl_iterator.hpp>
#include <boost/noncopyable.hpp>
#include <mapnik/text_properties.hpp>
#include <mapnik/text_placements/simple.hpp>

1
bindings/python/python_optional.hpp
View file

@ -22,6 +22,7 @@
#include <boost/optional/optional.hpp>
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
// boost::optional<T> to/from converter from John Wiegley

5
demo/viewer/styles_model.cpp
View file

@ -20,17 +20,18 @@
#include "styles_model.hpp"
#include <mapnik/expression_string.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/concept_check.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/utility.hpp>
// qt
#include <QList>
#include <QIcon>
#include <QPainter>
#include <QPixmap>
class node : private boost::noncopyable
class node : private mapnik::noncopyable
{
struct node_base
{

6
include/mapnik/agg_pattern_source.hpp
View file

@ -25,9 +25,7 @@
// mapnik
#include <mapnik/image_data.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_color_rgba.h"
@ -35,7 +33,7 @@
namespace mapnik
{
class pattern_source : private boost::noncopyable
class pattern_source : private mapnik::noncopyable
{
public:
pattern_source(image_data_32 const& pattern)

6
include/mapnik/agg_rasterizer.hpp
View file

@ -23,15 +23,15 @@
#ifndef MAPNIK_AGG_RASTERIZER_HPP
#define MAPNIK_AGG_RASTERIZER_HPP
// boost
#include <boost/utility.hpp>
// mapnik
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_rasterizer_scanline_aa.h"
namespace mapnik {
struct rasterizer : agg::rasterizer_scanline_aa<>, boost::noncopyable {};
struct rasterizer : agg::rasterizer_scanline_aa<>, mapnik::noncopyable {};
}

4
include/mapnik/agg_renderer.hpp
View file

@ -30,9 +30,9 @@
#include <mapnik/label_collision_detector.hpp>
#include <mapnik/map.hpp>
#include <mapnik/rule.hpp> // for all symbolizers
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
@ -53,7 +53,7 @@ struct rasterizer;
template <typename T>
class MAPNIK_DECL agg_renderer : public feature_style_processor<agg_renderer<T> >,
private boost::noncopyable
private mapnik::noncopyable
{
public:

5
include/mapnik/attribute_collector.hpp
View file

@ -26,8 +26,9 @@
// mapnik
#include <mapnik/rule.hpp>
#include <mapnik/transform_processor.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/variant.hpp>
#include <boost/concept_check.hpp>
// stl
@ -206,7 +207,7 @@ private:
};
class attribute_collector : public boost::noncopyable
class attribute_collector : public mapnik::noncopyable
{
private:
std::set<std::string>& names_;

6
include/mapnik/cairo_renderer.hpp
View file

@ -32,13 +32,13 @@
#include <mapnik/label_collision_detector.hpp>
#include <mapnik/map.hpp>
#include <mapnik/rule.hpp> // for all symbolizers
#include <mapnik/noncopyable.hpp>
// cairo
#include <cairomm/context.h>
#include <cairomm/surface.h>
// boost
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
// FIXME
@ -57,7 +57,7 @@ class cairo_face;
typedef boost::shared_ptr<cairo_face> cairo_face_ptr;
class cairo_face_manager : private boost::noncopyable
class cairo_face_manager : private mapnik::noncopyable
{
public:
cairo_face_manager(boost::shared_ptr<freetype_engine> engine);
@ -69,7 +69,7 @@ private:
cairo_face_cache cache_;
};
class MAPNIK_DECL cairo_renderer_base : private boost::noncopyable
class MAPNIK_DECL cairo_renderer_base : private mapnik::noncopyable
{
protected:
cairo_renderer_base(Map const& m, Cairo::RefPtr<Cairo::Context> const& context, double scale_factor=1.0, unsigned offset_x=0, unsigned offset_y=0);

24
include/mapnik/datasource.hpp
View file

@ -29,9 +29,9 @@
#include <mapnik/feature.hpp>
#include <mapnik/query.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
// stl
@ -42,7 +42,7 @@ namespace mapnik {
typedef MAPNIK_DECL boost::shared_ptr<Feature> feature_ptr;
struct MAPNIK_DECL Featureset : private boost::noncopyable
struct MAPNIK_DECL Featureset : private mapnik::noncopyable
{
virtual feature_ptr next() = 0;
virtual ~Featureset() {}
@ -70,7 +70,7 @@ private:
std::string message_;
};
class MAPNIK_DECL datasource : private boost::noncopyable
class MAPNIK_DECL datasource : private mapnik::noncopyable
{
public:
enum datasource_t {
@ -86,10 +86,7 @@ public:
};
datasource (parameters const& params)
: params_(params),
is_bound_(false)
{
}
: params_(params) {}
/*!
* @brief Get the configuration parameters of the data source.
@ -108,12 +105,6 @@ public:
* @return The type of the datasource (Vector or Raster)
*/
virtual datasource_t type() const = 0;
/*!
* @brief Connect to the datasource
*/
virtual void bind() const {}
virtual featureset_ptr features(query const& q) const = 0;
virtual featureset_ptr features_at_point(coord2d const& pt, double tol = 0) const = 0;
virtual box2d<double> envelope() const = 0;
@ -122,11 +113,10 @@ public:
virtual ~datasource() {}
protected:
parameters params_;
mutable bool is_bound_;
};
typedef const char * datasource_name();
typedef datasource* create_ds(parameters const& params, bool bind);
typedef datasource* create_ds(parameters const& params);
typedef void destroy_ds(datasource *ds);
class datasource_deleter
@ -145,9 +135,9 @@ typedef boost::shared_ptr<datasource> datasource_ptr;
{ \
return classname::name(); \
} \
extern "C" MAPNIK_EXP datasource* create(parameters const& params, bool bind) \
extern "C" MAPNIK_EXP datasource* create(parameters const& params) \
{ \
return new classname(params, bind); \
return new classname(params); \
} \
extern "C" MAPNIK_EXP void destroy(datasource *ds) \
{ \

6
include/mapnik/datasource_cache.hpp
View file

@ -28,9 +28,9 @@
#include <mapnik/params.hpp>
#include <mapnik/plugin.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
// stl
@ -40,7 +40,7 @@ namespace mapnik {
class MAPNIK_DECL datasource_cache
: public singleton<datasource_cache, CreateStatic>,
private boost::noncopyable
private mapnik::noncopyable
{
friend class CreateStatic<datasource_cache>;
public:
@ -48,7 +48,7 @@ public:
std::string plugin_directories();
void register_datasources(std::string const& path);
bool register_datasource(std::string const& path);
boost::shared_ptr<datasource> create(parameters const& params, bool bind=true);
boost::shared_ptr<datasource> create(parameters const& params);
private:
datasource_cache();
~datasource_cache();

8
include/mapnik/debug.hpp
View file

@ -26,9 +26,9 @@
// mapnik (should not depend on anything that need to use this)
#include <mapnik/config.hpp>
#include <mapnik/utils.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/unordered_map.hpp>
#ifdef MAPNIK_THREADSAFE
#include <boost/thread/mutex.hpp>
@ -50,7 +50,7 @@ namespace mapnik {
*/
class MAPNIK_DECL logger :
public singleton<logger,CreateStatic>,
private boost::noncopyable
private mapnik::noncopyable
{
public:
enum severity_type
@ -186,7 +186,7 @@ namespace mapnik {
class Ch = char,
class Tr = std::char_traits<Ch>,
class A = std::allocator<Ch> >
class base_log : public boost::noncopyable
class base_log : public mapnik::noncopyable
{
public:
typedef OutputPolicy<Ch, Tr, A> output_policy;
@ -245,7 +245,7 @@ namespace mapnik {
class Ch = char,
class Tr = std::char_traits<Ch>,
class A = std::allocator<Ch> >
class base_log_always : public boost::noncopyable
class base_log_always : public mapnik::noncopyable
{
public:
typedef OutputPolicy<Ch, Tr, A> output_policy;

8
include/mapnik/feature.hpp
View file

@ -29,6 +29,8 @@
#include <mapnik/geometry.hpp>
#include <mapnik/raster.hpp>
#include <mapnik/feature_kv_iterator.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/version.hpp>
#if BOOST_VERSION >= 104000
@ -36,7 +38,7 @@
#else
#include <boost/property_map.hpp>
#endif
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
@ -52,7 +54,7 @@ typedef boost::shared_ptr<raster> raster_ptr;
class feature_impl;
template <typename T>
class context : private boost::noncopyable,
class context : private mapnik::noncopyable,
public boost::associative_property_map<T>
{
@ -95,7 +97,7 @@ typedef MAPNIK_DECL boost::shared_ptr<context_type> context_ptr;
static const value default_value;
class MAPNIK_DECL feature_impl : private boost::noncopyable
class MAPNIK_DECL feature_impl : private mapnik::noncopyable
{
friend class feature_kv_iterator;
public:

16
include/mapnik/font_engine_freetype.hpp
View file

@ -32,6 +32,7 @@
#include <mapnik/char_info.hpp>
#include <mapnik/pixel_position.hpp>
#include <mapnik/image_compositing.hpp>
#include <mapnik/noncopyable.hpp>
// freetype2
extern "C"
@ -45,7 +46,6 @@ extern "C"
// boost
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/utility.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/foreach.hpp>
#ifdef MAPNIK_THREADSAFE
@ -69,7 +69,7 @@ class string_info;
typedef boost::shared_ptr<font_face> face_ptr;
class MAPNIK_DECL font_glyph : private boost::noncopyable
class MAPNIK_DECL font_glyph : private mapnik::noncopyable
{
public:
font_glyph(face_ptr face, unsigned index)
@ -91,7 +91,7 @@ private:
typedef boost::shared_ptr<font_glyph> glyph_ptr;
class font_face : boost::noncopyable
class font_face : mapnik::noncopyable
{
public:
font_face(FT_Face face)
@ -145,7 +145,7 @@ private:
FT_Face face_;
};
class MAPNIK_DECL font_face_set : private boost::noncopyable
class MAPNIK_DECL font_face_set : private mapnik::noncopyable
{
public:
font_face_set(void)
@ -200,7 +200,7 @@ private:
};
// FT_Stroker wrapper
class stroker : boost::noncopyable
class stroker : mapnik::noncopyable
{
public:
explicit stroker(FT_Stroker s)
@ -264,7 +264,7 @@ private:
};
template <typename T>
class MAPNIK_DECL face_manager : private boost::noncopyable
class MAPNIK_DECL face_manager : private mapnik::noncopyable
{
typedef T font_engine_type;
typedef std::map<std::string,face_ptr> face_ptr_cache_type;
@ -351,9 +351,9 @@ private:
};
template <typename T>
struct text_renderer : private boost::noncopyable
struct text_renderer : private mapnik::noncopyable
{
struct glyph_t : boost::noncopyable
struct glyph_t : mapnik::noncopyable
{
FT_Glyph image;
char_properties *properties;

6
include/mapnik/formatting/registry.hpp
View file

@ -25,9 +25,7 @@
// mapnik
#include <mapnik/utils.hpp>
#include <mapnik/formatting/base.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// stl
#include <string>
@ -41,7 +39,7 @@ namespace formatting
typedef node_ptr (*from_xml_function_ptr)(xml_node const& xml);
class registry : public singleton<registry, CreateStatic>,
private boost::noncopyable
private mapnik::noncopyable
{
public:
registry();

35
include/mapnik/geometry.hpp
View file

@ -26,10 +26,10 @@
// mapnik
#include <mapnik/vertex_vector.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
namespace mapnik {
@ -42,7 +42,7 @@ enum eGeomType {
};
template <typename T, template <typename> class Container=vertex_vector>
class geometry : private::boost::noncopyable
class geometry : private::mapnik::noncopyable
{
public:
typedef T coord_type;
@ -91,10 +91,11 @@ public:
double x = 0;
double y = 0;
rewind(0);
for (unsigned i=0;i<size();++i)
for (unsigned i=0; i < size(); ++i)
{
vertex(&x,&y);
if (i==0)
unsigned cmd = vertex(&x,&y);
if (cmd == SEG_CLOSE) continue;
if (i == 0)
{
result.init(x,y,x,y);
}
@ -126,11 +127,31 @@ public:
push_vertex(x,y,SEG_CLOSE);
}
void close()
void set_close()
{
if (cont_.size() > 3)
{
cont_.set_command(cont_.size() - 1, SEG_CLOSE);
unsigned cmd;
double x,y;
int index = cont_.size() - 1;
unsigned last_cmd = cont_.get_vertex(index,&x,&y);
if (last_cmd == SEG_LINETO)
{
double last_x = x;
double last_y = y;
for (int pos = index - 1; pos >=0 ; --pos)
{
cmd = cont_.get_vertex(pos,&x,&y);
if (cmd == SEG_MOVETO)
{
if (x == last_x && y == last_y)
{
cont_.set_command(index , SEG_CLOSE);
}
break;
}
}
}
}
}

4
include/mapnik/grid/grid_rasterizer.hpp
View file

@ -23,12 +23,12 @@
#ifndef MAPNIK_GRID_RASTERIZER_HPP
#define MAPNIK_GRID_RASTERIZER_HPP
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
#include "agg_rasterizer_scanline_aa.h"
namespace mapnik {
struct grid_rasterizer : agg::rasterizer_scanline_aa<>, boost::noncopyable {};
struct grid_rasterizer : agg::rasterizer_scanline_aa<>, mapnik::noncopyable {};
}

4
include/mapnik/grid/grid_renderer.hpp
View file

@ -31,9 +31,9 @@
#include <mapnik/map.hpp>
#include <mapnik/rule.hpp> // for all symbolizers
#include <mapnik/grid/grid.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
// FIXME
@ -52,7 +52,7 @@ struct grid_rasterizer;
template <typename T>
class MAPNIK_DECL grid_renderer : public feature_style_processor<grid_renderer<T> >,
private boost::noncopyable
private mapnik::noncopyable
{
public:

4
include/mapnik/hextree.hpp
View file

@ -26,9 +26,9 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/palette.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/version.hpp>
#include <boost/unordered_map.hpp>
#if BOOST_VERSION >= 104600
@ -60,7 +60,7 @@ struct RGBAPolicy
};
template <typename T, typename InsertPolicy = RGBAPolicy >
class hextree : private boost::noncopyable
class hextree : private mapnik::noncopyable
{
struct node
{

3
include/mapnik/json/feature_collection_grammar.hpp
View file

@ -25,6 +25,7 @@
// mapnik
#include <mapnik/json/feature_grammar.hpp>
#include <mapnik/feature.hpp>
// spirit::qi
#include <boost/config/warning_disable.hpp>
@ -88,7 +89,7 @@ struct feature_collection_grammar :
> lit(']')
;
feature = eps[_a = construct<feature_ptr>(new_<feature_impl>(ctx_,generate_id_()))]
feature = eps[_a = construct<mapnik::feature_ptr>(new_<mapnik::feature_impl>(ctx_,generate_id_()))]
>> feature_g(*_a)[push_back(_r1,_a)]
;

5
include/mapnik/json/feature_collection_parser.hpp
View file

@ -27,10 +27,11 @@
#include <mapnik/config.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/scoped_ptr.hpp>
#include <boost/utility.hpp>
// stl
#include <vector>
@ -39,7 +40,7 @@ namespace mapnik { namespace json {
template <typename Iterator, typename FeatureType> struct feature_collection_grammar;
template <typename Iterator>
class feature_collection_parser : private boost::noncopyable
class feature_collection_parser : private mapnik::noncopyable
{
typedef Iterator iterator_type;
typedef mapnik::Feature feature_type;

11
include/mapnik/json/geojson_generator.hpp
View file

@ -25,8 +25,9 @@
#include <mapnik/config.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/utility.hpp>
#include <string>
namespace mapnik { namespace json {
@ -36,7 +37,7 @@ namespace mapnik { namespace json {
template <typename OutputIterator> struct feature_generator_grammar;
template <typename OutputIterator> struct multi_geometry_generator_grammar;
class MAPNIK_DECL feature_generator : private boost::noncopyable
class MAPNIK_DECL feature_generator : private mapnik::noncopyable
{
typedef std::back_insert_iterator<std::string> sink_type;
public:
@ -47,7 +48,7 @@ private:
boost::scoped_ptr<feature_generator_grammar<sink_type> > grammar_;
};
class MAPNIK_DECL geometry_generator : private boost::noncopyable
class MAPNIK_DECL geometry_generator : private mapnik::noncopyable
{
typedef std::back_insert_iterator<std::string> sink_type;
public:
@ -60,7 +61,7 @@ private:
#else
class MAPNIK_DECL feature_generator : private boost::noncopyable
class MAPNIK_DECL feature_generator : private mapnik::noncopyable
{
public:
feature_generator() {}
@ -68,7 +69,7 @@ public:
bool generate(std::string & geojson, mapnik::Feature const& f);
};
class MAPNIK_DECL geometry_generator : private boost::noncopyable
class MAPNIK_DECL geometry_generator : private mapnik::noncopyable
{
public:
geometry_generator() {}

23
include/mapnik/json/geometry_generator_grammar.hpp
View file

@ -116,7 +116,28 @@ struct json_coordinate_policy : karma::real_policies<T>
{
typedef boost::spirit::karma::real_policies<T> base_type;
static int floatfield(T n) { return base_type::fmtflags::fixed; }
static unsigned precision(T n) { return 12 ;}
static unsigned precision(T n)
{
if (n == 0.0) return 0;
using namespace boost::spirit;
return static_cast<unsigned>(15 - boost::math::trunc(log10(traits::get_absolute_value(n))));
}
template <typename OutputIterator>
static bool dot(OutputIterator& sink, T n, unsigned precision)
{
if (n == 0) return true;
return base_type::dot(sink, n, precision);
}
template <typename OutputIterator>
static bool fraction_part(OutputIterator& sink, T n
, unsigned adjprec, unsigned precision)
{
if (n == 0) return true;
return base_type::fraction_part(sink, n, adjprec, precision);
}
};
}

2
include/mapnik/json/geometry_grammar.hpp
View file

@ -69,7 +69,7 @@ struct close_path
void operator() (T path) const
{
BOOST_ASSERT( path!=0 );
path->close();
path->set_close();
}
};

5
include/mapnik/json/geometry_parser.hpp
View file

@ -26,10 +26,11 @@
// mapnik
#include <mapnik/config.hpp>
#include <mapnik/geometry.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/scoped_ptr.hpp>
#include <boost/utility.hpp>
// stl
//#include <vector>
@ -40,7 +41,7 @@ template <typename Iterator> struct geometry_grammar;
MAPNIK_DECL bool from_geojson(std::string const& json, boost::ptr_vector<geometry_type> & paths);
template <typename Iterator>
class MAPNIK_DECL geometry_parser : private boost::noncopyable
class MAPNIK_DECL geometry_parser : private mapnik::noncopyable
{
typedef Iterator iterator_type;
public:

7
include/mapnik/label_collision_detector.hpp
View file

@ -25,6 +25,7 @@
// mapnik
#include <mapnik/quad_tree.hpp>
#include <mapnik/noncopyable.hpp>
// stl
#include <vector>
@ -63,7 +64,7 @@ private:
};
// quad_tree based label collision detector
class label_collision_detector2 : boost::noncopyable
class label_collision_detector2 : mapnik::noncopyable
{
typedef quad_tree<box2d<double> > tree_t;
tree_t tree_;
@ -97,7 +98,7 @@ public:
};
// quad_tree based label collision detector with seperate check/insert
class label_collision_detector3 : boost::noncopyable
class label_collision_detector3 : mapnik::noncopyable
{
typedef quad_tree< box2d<double> > tree_t;
tree_t tree_;
@ -135,7 +136,7 @@ public:
//quad tree based label collision detector so labels dont appear within a given distance
class label_collision_detector4 : boost::noncopyable
class label_collision_detector4 : mapnik::noncopyable
{
public:
struct label

4
include/mapnik/mapped_memory_cache.hpp
View file

@ -26,9 +26,9 @@
// mapnik
#include <mapnik/config.hpp>
#include <mapnik/utils.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/unordered_map.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <boost/shared_ptr.hpp>
@ -43,7 +43,7 @@ typedef boost::shared_ptr<mapped_region> mapped_region_ptr;
struct MAPNIK_DECL mapped_memory_cache :
public singleton<mapped_memory_cache, CreateStatic>,
private boost::noncopyable
private mapnik::noncopyable
{
friend class CreateStatic<mapped_memory_cache>;
boost::unordered_map<std::string,mapped_region_ptr> cache_;

4
include/mapnik/marker.hpp
View file

@ -29,12 +29,12 @@
#include <mapnik/svg/svg_path_attributes.hpp>
#include <mapnik/svg/svg_storage.hpp>
#include <mapnik/svg/svg_path_adapter.hpp>
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_path_storage.h"
// boost
#include <boost/utility.hpp>
#include <boost/unordered_map.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
@ -55,7 +55,7 @@ typedef boost::shared_ptr<image_data_32> image_ptr;
* A class to hold either vector or bitmap marker data. This allows these to be treated equally
* in the image caches and most of the render paths.
*/
class marker: private boost::noncopyable
class marker: private mapnik::noncopyable
{
public:
marker()

4
include/mapnik/marker_cache.hpp
View file

@ -26,9 +26,9 @@
// mapnik
#include <mapnik/utils.hpp>
#include <mapnik/config.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/unordered_map.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
@ -43,7 +43,7 @@ typedef boost::shared_ptr<marker> marker_ptr;
class MAPNIK_DECL marker_cache :
public singleton <marker_cache, CreateUsingNew>,
private boost::noncopyable
private mapnik::noncopyable
{
friend class CreateUsingNew<marker_cache>;
private:

6
include/mapnik/markers_placement.hpp
View file

@ -30,9 +30,7 @@
#include <mapnik/label_collision_detector.hpp>
#include <mapnik/global.hpp> //round
#include <mapnik/box2d.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_basics.h"
@ -48,7 +46,7 @@
namespace mapnik {
template <typename Locator, typename Detector>
class markers_placement : boost::noncopyable
class markers_placement : mapnik::noncopyable
{
public:
/** Constructor for markers_placement object.

45
include/mapnik/noncopyable.hpp Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2012 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 MAPNIK_NONCOPYABLE_HPP
#define MAPNIK_NONCOPYABLE_HPP
namespace mapnik {
namespace non_copyable_
{
class noncopyable
{
protected:
noncopyable() {}
~noncopyable() {}
private:
noncopyable( const noncopyable& );
const noncopyable& operator=( const noncopyable& );
};
}
typedef non_copyable_::noncopyable noncopyable;
} // namespace mapnik
#endif // MAPNIK_NONCOPYABLE_HPP

6
include/mapnik/octree.hpp
View file

@ -26,9 +26,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/palette.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// stl
#include <vector>
@ -51,7 +49,7 @@ struct RGBPolicy
};
template <typename T, typename InsertPolicy = RGBPolicy >
class octree : private boost::noncopyable
class octree : private mapnik::noncopyable
{
struct node
{

4
include/mapnik/palette.hpp
View file

@ -26,9 +26,9 @@
// mapnik
#include <mapnik/config.hpp>
#include <mapnik/global.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/unordered_map.hpp>
// stl
@ -126,7 +126,7 @@ struct rgba
typedef boost::unordered_map<unsigned, unsigned> rgba_hash_table;
class MAPNIK_DECL rgba_palette : private boost::noncopyable {
class MAPNIK_DECL rgba_palette : private mapnik::noncopyable {
public:
enum palette_type { PALETTE_RGBA = 0, PALETTE_RGB = 1, PALETTE_ACT = 2 };

3
include/mapnik/placement_finder.hpp
View file

@ -30,6 +30,7 @@
#include <mapnik/symbolizer_helpers.hpp>
#include <mapnik/label_collision_detector.hpp>
#include <mapnik/ctrans.hpp>
#include <mapnik/noncopyable.hpp>
// agg
@ -54,7 +55,7 @@ typedef label_collision_detector4 DetectorType;
template <typename DetectorT>
class placement_finder : boost::noncopyable
class placement_finder : mapnik::noncopyable
{
public:
placement_finder(Feature const& feature,

6
include/mapnik/plugin.hpp
View file

@ -23,8 +23,8 @@
#ifndef MAPNIK_PLUGIN_HPP
#define MAPNIK_PLUGIN_HPP
// boost
#include <boost/utility.hpp>
// mapnik
#include <mapnik/noncopyable.hpp>
// stl
#include <string>
@ -34,7 +34,7 @@
namespace mapnik
{
class PluginInfo : boost::noncopyable
class PluginInfo : mapnik::noncopyable
{
private:
std::string name_;

4
include/mapnik/pool.hpp
View file

@ -26,10 +26,10 @@
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/utils.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#ifdef MAPNIK_THREADSAFE
#include <boost/thread/mutex.hpp>
#endif
@ -65,7 +65,7 @@ private:
};
template <typename T,template <typename> class Creator>
class Pool : private boost::noncopyable
class Pool : private mapnik::noncopyable
{
typedef boost::shared_ptr<T> HolderType;
typedef std::deque<HolderType> ContType;

3
include/mapnik/processed_text.hpp
View file

@ -26,11 +26,12 @@
#include <mapnik/text_properties.hpp>
#include <mapnik/font_engine_freetype.hpp>
#include <mapnik/text_path.hpp>
#include <mapnik/noncopyable.hpp>
namespace mapnik
{
class processed_text : boost::noncopyable
class processed_text : mapnik::noncopyable
{
public:
class processed_expression

6
include/mapnik/proj_transform.hpp
View file

@ -26,13 +26,11 @@
// mapnik
#include <mapnik/projection.hpp>
#include <mapnik/box2d.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
namespace mapnik {
class MAPNIK_DECL proj_transform : private boost::noncopyable
class MAPNIK_DECL proj_transform : private mapnik::noncopyable
{
public:
proj_transform(projection const& source,

4
include/mapnik/quad_tree.hpp
View file

@ -25,10 +25,10 @@
// mapnik
#include <mapnik/box2d.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/noncopyable.hpp>
// stl
#include <vector>
@ -37,7 +37,7 @@
namespace mapnik
{
template <typename T>
class quad_tree : boost::noncopyable
class quad_tree : mapnik::noncopyable
{
struct node
{

6
include/mapnik/raster.hpp
View file

@ -26,12 +26,10 @@
// mapnik
#include <mapnik/box2d.hpp>
#include <mapnik/image_data.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
namespace mapnik {
class raster : private boost::noncopyable
class raster : private mapnik::noncopyable
{
public:
box2d<double> ext_;

3
include/mapnik/simplify_converter.hpp
View file

@ -5,6 +5,7 @@
#include <mapnik/box2d.hpp>
#include <mapnik/vertex.hpp>
#include <mapnik/simplify.hpp>
#include <mapnik/noncopyable.hpp>
// STL
#include <limits>
@ -17,7 +18,7 @@
namespace mapnik
{
struct weighted_vertex : private boost::noncopyable
struct weighted_vertex : private mapnik::noncopyable
{
vertex2d coord;
double weight;

5
include/mapnik/svg/output/svg_generator.hpp
View file

@ -30,9 +30,8 @@
#include <mapnik/util/geometry_svg_generator.hpp>
#include <mapnik/svg/output/svg_output_grammars.hpp>
#include <mapnik/svg/output/svg_output_attributes.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
namespace mapnik { namespace svg {
@ -43,7 +42,7 @@ namespace mapnik { namespace svg {
* structure.
*/
template <typename OutputIterator>
class svg_generator : private boost::noncopyable
class svg_generator : private mapnik::noncopyable
{
typedef svg::svg_root_attributes_grammar<OutputIterator> root_attributes_grammar;
typedef svg::svg_rect_attributes_grammar<OutputIterator> rect_attributes_grammar;

8
include/mapnik/svg/output/svg_renderer.hpp
View file

@ -28,6 +28,7 @@
#include <mapnik/map.hpp>
#include <mapnik/svg/output/svg_generator.hpp>
#include <mapnik/svg/output/svg_output_attributes.hpp>
#include <mapnik/noncopyable.hpp>
// stl
#include <string>
@ -39,7 +40,7 @@ namespace mapnik
// can target many other output destinations besides streams.
template <typename OutputIterator>
class MAPNIK_DECL svg_renderer : public feature_style_processor<svg_renderer<OutputIterator> >,
private boost::noncopyable
private mapnik::noncopyable
{
public:
typedef svg_renderer<OutputIterator> processor_impl_type;
@ -103,6 +104,11 @@ public:
// nothing to do
}
inline eAttributeCollectionPolicy attribute_collection_policy() const
{
return DEFAULT;
}
inline OutputIterator& get_output_iterator()
{
return output_iterator_;

6
include/mapnik/svg/svg_converter.hpp
View file

@ -26,9 +26,7 @@
// mapnik
#include <mapnik/svg/svg_path_attributes.hpp>
#include <mapnik/svg/svg_path_adapter.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_path_storage.h"
@ -46,7 +44,7 @@ namespace mapnik {
namespace svg {
template <typename VertexSource, typename AttributeSource>
class svg_converter : boost::noncopyable
class svg_converter : mapnik::noncopyable
{
public:

4
include/mapnik/svg/svg_parser.hpp
View file

@ -28,9 +28,9 @@
#include <mapnik/svg/svg_converter.hpp>
#include <mapnik/svg/svg_path_adapter.hpp>
#include <mapnik/gradient.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <libxml/xmlreader.h>
// stl
@ -38,7 +38,7 @@
namespace mapnik { namespace svg {
class svg_parser : private boost::noncopyable
class svg_parser : private mapnik::noncopyable
{
public:
explicit svg_parser(svg_converter_type & path);

6
include/mapnik/svg/svg_path_adapter.hpp
View file

@ -24,7 +24,7 @@
#define MAPNIK_SVG_PATH_ADAPTER_HPP
// mapnik
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_math.h"
@ -40,7 +40,7 @@ namespace svg {
using namespace agg;
template<class VertexContainer> class path_adapter : boost::noncopyable
template<class VertexContainer> class path_adapter : mapnik::noncopyable
{
public:
typedef VertexContainer container_type;
@ -838,7 +838,7 @@ void path_adapter<VC>::translate_all_paths(double dx, double dy)
}
template<class Container> class vertex_stl_adapter : boost::noncopyable
template<class Container> class vertex_stl_adapter : mapnik::noncopyable
{
public:

4
include/mapnik/svg/svg_renderer_agg.hpp
View file

@ -29,9 +29,9 @@
#include <mapnik/gradient.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/grid/grid_pixel.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/foreach.hpp>
// agg
@ -100,7 +100,7 @@ private:
};
template <typename VertexSource, typename AttributeSource, typename ScanlineRenderer, typename PixelFormat>
class svg_renderer_agg : boost::noncopyable
class svg_renderer_agg : mapnik::noncopyable
{
public:
typedef agg::conv_curve<VertexSource> curved_type;

6
include/mapnik/svg/svg_storage.hpp
View file

@ -25,15 +25,13 @@
// mapnik
#include <mapnik/box2d.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
namespace mapnik {
namespace svg {
template <typename VertexSource ,typename AttributeSource>
class svg_storage : boost::noncopyable
class svg_storage : mapnik::noncopyable
{
public:
svg_storage() {}

6
include/mapnik/text_path.hpp
View file

@ -26,12 +26,12 @@
// mapnik
#include <mapnik/char_info.hpp>
#include <mapnik/pixel_position.hpp>
#include <mapnik/noncopyable.hpp>
//stl
#include <vector>
// boost
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
// uci
@ -40,7 +40,7 @@
namespace mapnik
{
class string_info : private boost::noncopyable
class string_info : private mapnik::noncopyable
{
protected:
typedef std::vector<char_info> characters_t;
@ -122,7 +122,7 @@ typedef char_info const * char_info_ptr;
/** List of all characters and their positions and formats for a placement. */
class text_path : boost::noncopyable
class text_path : mapnik::noncopyable
{
struct character_node
{

2
include/mapnik/text_placements/base.hpp
View file

@ -37,7 +37,7 @@ class MAPNIK_DECL text_placements;
* This placement has first to be tested by placement_finder to verify it
* can actually be used.
*/
class text_placement_info : boost::noncopyable
class text_placement_info : mapnik::noncopyable
{
public:
/** Constructor. Takes the parent text_placements object as a parameter

6
include/mapnik/text_placements/registry.hpp
View file

@ -25,9 +25,7 @@
// mapnik
#include <mapnik/utils.hpp>
#include <mapnik/text_placements/base.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
// stl
#include <string>
@ -42,7 +40,7 @@ typedef text_placements_ptr (*from_xml_function_ptr)(
xml_node const& xml, fontset_map const & fontsets);
class registry : public singleton<registry, CreateStatic>,
private boost::noncopyable
private mapnik::noncopyable
{
public:
registry();

4
include/mapnik/unicode.hpp
View file

@ -25,13 +25,13 @@
//mapnik
#include <mapnik/config.hpp>
#include <mapnik/noncopyable.hpp>
// icu
#include <unicode/unistr.h>
#include <unicode/ucnv.h>
// boost
#include <boost/utility.hpp>
#include <boost/cstdint.hpp>
// stl
@ -39,7 +39,7 @@
namespace mapnik {
class MAPNIK_DECL transcoder : private boost::noncopyable
class MAPNIK_DECL transcoder : private mapnik::noncopyable
{
public:
explicit transcoder (std::string const& encoding);

74
include/mapnik/util/conversions.hpp
View file

@ -73,12 +73,80 @@ template <typename T>
struct double_policy : boost::spirit::karma::real_policies<T>
{
typedef boost::spirit::karma::real_policies<T> base_type;
static int floatfield(T n) { return base_type::fmtflags::fixed; }
static unsigned precision(T n) { return static_cast<unsigned>(15 - boost::math::trunc(log10(n))); }
static int floatfield(T n) {
using namespace boost::spirit; // for traits
if (traits::test_zero(n))
return base_type::fmtflags::fixed;
T abs_n = traits::get_absolute_value(n);
return (abs_n >= 1e16 || abs_n < 1e-4)
? base_type::fmtflags::scientific : base_type::fmtflags::fixed;
}
static unsigned precision(T n) {
if ( n == 0.0 ) return 0;
using namespace boost::spirit; // for traits
return static_cast<unsigned>(15 - boost::math::trunc(log10(traits::get_absolute_value(n))));
}
template <typename OutputIterator>
static bool dot(OutputIterator& sink, T n, unsigned precision) {
return n ? *sink = '.', true : false;
if (n == 0.0) return true; // avoid trailing zeroes
return base_type::dot(sink, n, precision);
}
template <typename OutputIterator>
static bool fraction_part (OutputIterator& sink, T n
, unsigned precision_, unsigned precision)
{
// NOTE: copied from karma only to avoid trailing zeroes
// (maybe a bug ?)
// allow for ADL to find the correct overload for floor and log10
using namespace std;
using namespace boost::spirit; // for traits
using namespace boost::spirit::karma; // for char_inserter
using namespace boost; // for remove_const
if ( traits::test_zero(n) ) return true; // this part added to karma
// The following is equivalent to:
// generate(sink, right_align(precision, '0')[ulong], n);
// but it's spelled out to avoid inter-modular dependencies.
typename remove_const<T>::type digits =
(traits::test_zero(n) ? 0 : floor(log10(n))) + 1;
bool r = true;
for (/**/; r && digits < precision_; digits = digits + 1)
r = char_inserter<>::call(sink, '0');
if (precision && r)
r = int_inserter<10>::call(sink, n);
return r;
}
template <typename CharEncoding, typename Tag, typename OutputIterator>
static bool exponent (OutputIterator& sink, long n)
{
// NOTE: copied from karma to force sign in exponent
const bool force_sign = true;
using namespace boost::spirit; // for traits
using namespace boost::spirit::karma; // for char_inserter, sign_inserter
long abs_n = traits::get_absolute_value(n);
bool r = char_inserter<CharEncoding, Tag>::call(sink, 'e') &&
sign_inserter::call(sink, traits::test_zero(n)
, traits::test_negative(n), force_sign);
// the C99 Standard requires at least two digits in the exponent
if (r && abs_n < 10)
r = char_inserter<CharEncoding, Tag>::call(sink, '0');
return r && int_inserter<10>::call(sink, abs_n);
}
};

9
include/mapnik/util/geometry_to_wkb.hpp
View file

@ -172,6 +172,8 @@ wkb_buffer_ptr to_polygon_wkb( GeometryType const& g, wkbByteOrder byte_order)
double x = 0;
double y = 0;
double start_x = 0;
double start_y = 0;
std::size_t size = 1 + 4 + 4 ; // byteOrder + wkbType + numRings
for (unsigned i=0; i< num_points; ++i)
{
@ -179,8 +181,15 @@ wkb_buffer_ptr to_polygon_wkb( GeometryType const& g, wkbByteOrder byte_order)
if (command == SEG_MOVETO)
{
rings.push_back(new linear_ring); // start new loop
start_x = x;
start_y = y;
size += 4; // num_points
}
else if (command == SEG_CLOSE)
{
x = start_x;
y = start_y;
}
rings.back().push_back(std::make_pair(x,y));
size += 2 * 8; // point
}

59
include/mapnik/util/geometry_wkt_generator.hpp
View file

@ -37,6 +37,7 @@
#include <boost/fusion/include/boost_tuple.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/math/special_functions/trunc.hpp> // trunc to avoid needing C++11
//#define BOOST_SPIRIT_USE_PHOENIX_V3 1
namespace boost { namespace spirit { namespace traits {
@ -92,13 +93,40 @@ struct multi_geometry_
template <typename U>
struct result { typedef bool type; };
bool operator() (geometry_container const& geom) const
{
return geom.size() > 1 ? true : false;
}
};
template <typename T>
struct get_x
{
typedef T value_type;
template <typename U>
struct result { typedef double type; };
double operator() (value_type const& val) const
{
return boost::get<1>(val);
}
};
template <typename T>
struct get_y
{
typedef T value_type;
template <typename U>
struct result { typedef double type; };
double operator() (value_type const& val) const
{
return boost::get<2>(val);
}
};
template <typename T>
struct multi_geometry_type
{
@ -116,7 +144,28 @@ struct wkt_coordinate_policy : karma::real_policies<T>
{
typedef boost::spirit::karma::real_policies<T> base_type;
static int floatfield(T n) { return base_type::fmtflags::fixed; }
static unsigned precision(T n) { return 6 ;}
static unsigned precision(T n)
{
if (n == 0.0) return 0;
return 6;
//using namespace boost::spirit; // for traits
//return std::max(6u, static_cast<unsigned>(15 - boost::math::trunc(log10(traits::get_absolute_value(n)))));
}
template <typename OutputIterator>
static bool dot(OutputIterator& sink, T n, unsigned precision)
{
if (n == 0) return true;
return base_type::dot(sink, n, precision);
}
template <typename OutputIterator>
static bool fraction_part(OutputIterator& sink, T n
, unsigned adjprec, unsigned precision)
{
if (n == 0) return true;
return base_type::fraction_part(sink, n, adjprec, precision);
}
};
}
@ -136,13 +185,15 @@ struct wkt_generator :
karma::rule<OutputIterator, geometry_type const& ()> polygon;
karma::rule<OutputIterator, geometry_type const& ()> coords;
karma::rule<OutputIterator, karma::locals<unsigned>, geometry_type const& ()> coords2;
karma::rule<OutputIterator, karma::locals<unsigned,double,double>, geometry_type const& ()> coords2;
karma::rule<OutputIterator, coord_type ()> point_coord;
karma::rule<OutputIterator, coord_type (unsigned& )> polygon_coord;
karma::rule<OutputIterator, karma::locals<double,double>, coord_type (unsigned&, double&, double& )> polygon_coord;
// phoenix functions
phoenix::function<detail::get_type<geometry_type> > _type;
phoenix::function<detail::get_first<geometry_type> > _first;
phoenix::function<detail::get_x<typename geometry_type::value_type> > _x;
phoenix::function<detail::get_y<typename geometry_type::value_type> > _y;
//
karma::real_generator<double, detail::wkt_coordinate_policy<double> > coordinate;
};

4
include/mapnik/vertex_converters.hpp
View file

@ -44,13 +44,13 @@
#include <boost/fusion/include/make_vector.hpp>
#include <boost/foreach.hpp>
#include <boost/utility.hpp>
#include <boost/array.hpp>
// mapnik
#include <mapnik/agg_helpers.hpp>
#include <mapnik/offset_converter.hpp>
#include <mapnik/simplify_converter.hpp>
#include <mapnik/noncopyable.hpp>
// agg
#include "agg_conv_clip_polygon.h"
@ -317,7 +317,7 @@ struct dispatcher
template <typename B, typename R, typename S, typename T, typename P, typename A, typename C >
struct vertex_converter : private boost::noncopyable
struct vertex_converter : private mapnik::noncopyable
{
typedef C conv_types;
typedef B bbox_type;

4
include/mapnik/vertex_vector.hpp
View file

@ -29,9 +29,9 @@
// mapnik
#include <mapnik/vertex.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/tuple/tuple.hpp>
#include <cstring> // required for memcpy with linux/g++
@ -40,7 +40,7 @@ namespace mapnik
{
template <typename T>
class vertex_vector : private boost::noncopyable
class vertex_vector : private mapnik::noncopyable
{
typedef T coord_type;
typedef vertex<coord_type,2> vertex_type;

6
include/mapnik/wkb.hpp
View file

@ -25,9 +25,7 @@
// mapnik
#include <mapnik/geometry.hpp>
// boost
#include <boost/utility.hpp>
#include <mapnik/noncopyable.hpp>
namespace mapnik
{
@ -50,7 +48,7 @@ enum wkbFormat
wkbSpatiaLite=3
};
class MAPNIK_DECL geometry_utils : private boost::noncopyable
class MAPNIK_DECL geometry_utils : private mapnik::noncopyable
{
public:

5
include/mapnik/wkt/wkt_factory.hpp
View file

@ -27,8 +27,9 @@
#include <mapnik/config.hpp>
#include <mapnik/geometry.hpp>
#include <mapnik/wkt/wkt_grammar.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/version.hpp>
@ -42,7 +43,7 @@ MAPNIK_DECL bool from_wkt(std::string const& wkt, boost::ptr_vector<geometry_typ
#if BOOST_VERSION >= 104700
class MAPNIK_DECL wkt_parser : boost::noncopyable
class MAPNIK_DECL wkt_parser : mapnik::noncopyable
{
typedef std::string::const_iterator iterator_type;
public:

2
include/mapnik/wkt/wkt_grammar.hpp
View file

@ -71,7 +71,7 @@ namespace mapnik { namespace wkt {
void operator() (T path) const
{
BOOST_ASSERT( path!=0 );
path->close();
path->set_close();
}
};

55
plugins/input/csv/csv_datasource.cpp
View file

@ -56,23 +56,23 @@ using namespace boost::spirit;
DATASOURCE_PLUGIN(csv_datasource)
csv_datasource::csv_datasource(parameters const& params, bool bind)
csv_datasource::csv_datasource(parameters const& params)
: datasource(params),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")),
extent_(),
filename_(),
inline_string_(),
file_length_(0),
row_limit_(*params_.get<int>("row_limit", 0)),
row_limit_(*params.get<int>("row_limit", 0)),
features_(),
escape_(*params_.get<std::string>("escape", "")),
separator_(*params_.get<std::string>("separator", "")),
quote_(*params_.get<std::string>("quote", "")),
escape_(*params.get<std::string>("escape", "")),
separator_(*params.get<std::string>("separator", "")),
quote_(*params.get<std::string>("quote", "")),
headers_(),
manual_headers_(mapnik::util::trim_copy(*params_.get<std::string>("headers", ""))),
strict_(*params_.get<mapnik::boolean>("strict", false)),
quiet_(*params_.get<mapnik::boolean>("quiet", false)),
filesize_max_(*params_.get<float>("filesize_max", 20.0)), // MB
manual_headers_(mapnik::util::trim_copy(*params.get<std::string>("headers", ""))),
strict_(*params.get<mapnik::boolean>("strict", false)),
quiet_(*params.get<mapnik::boolean>("quiet", false)),
filesize_max_(*params.get<float>("filesize_max", 20.0)), // MB
ctx_(boost::make_shared<mapnik::context_type>())
{
/* TODO:
@ -97,36 +97,22 @@ csv_datasource::csv_datasource(parameters const& params, bool bind)
http://boost-spirit.com/home/articles/qi-example/tracking-the-input-position-while-parsing/
*/
boost::optional<std::string> inline_string = params_.get<std::string>("inline");
boost::optional<std::string> inline_string = params.get<std::string>("inline");
if (inline_string)
{
inline_string_ = *inline_string;
}
else
{
boost::optional<std::string> file = params_.get<std::string>("file");
boost::optional<std::string> file = params.get<std::string>("file");
if (!file) throw mapnik::datasource_exception("CSV Plugin: missing <file> parameter");
boost::optional<std::string> base = params_.get<std::string>("base");
boost::optional<std::string> base = params.get<std::string>("base");
if (base)
filename_ = *base + "/" + *file;
else
filename_ = *file;
}
if (bind)
{
this->bind();
}
}
csv_datasource::~csv_datasource() { }
void csv_datasource::bind() const
{
if (is_bound_) return;
if (!inline_string_.empty())
{
std::istringstream in(inline_string_);
@ -140,14 +126,16 @@ void csv_datasource::bind() const
parse_csv(in,escape_, separator_, quote_);
in.close();
}
is_bound_ = true;
}
csv_datasource::~csv_datasource() { }
template <typename T>
void csv_datasource::parse_csv(T & stream,
std::string const& escape,
std::string const& separator,
std::string const& quote) const
std::string const& quote)
{
stream.seekg(0, std::ios::end);
file_length_ = stream.tellg();
@ -890,14 +878,11 @@ datasource::datasource_t csv_datasource::type() const
mapnik::box2d<double> csv_datasource::envelope() const
{
if (!is_bound_) bind();
return extent_;
}
boost::optional<mapnik::datasource::geometry_t> csv_datasource::get_geometry_type() const
{
if (! is_bound_) bind();
boost::optional<mapnik::datasource::geometry_t> result;
int multi_type = 0;
unsigned num_features = features_.size();
@ -920,15 +905,11 @@ boost::optional<mapnik::datasource::geometry_t> csv_datasource::get_geometry_typ
mapnik::layer_descriptor csv_datasource::get_descriptor() const
{
if (!is_bound_) bind();
return desc_;
}
mapnik::featureset_ptr csv_datasource::features(mapnik::query const& q) const
{
if (!is_bound_) bind();
const std::set<std::string>& attribute_names = q.property_names();
std::set<std::string>::const_iterator pos = attribute_names.begin();
while (pos != attribute_names.end())
@ -958,7 +939,5 @@ mapnik::featureset_ptr csv_datasource::features(mapnik::query const& q) const
mapnik::featureset_ptr csv_datasource::features_at_point(mapnik::coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
throw mapnik::datasource_exception("CSV Plugin: features_at_point is not supported yet");
}

37
plugins/input/csv/csv_datasource.hpp
View file

@ -42,7 +42,7 @@
class csv_datasource : public mapnik::datasource
{
public:
csv_datasource(mapnik::parameters const& params, bool bind=true);
csv_datasource(mapnik::parameters const& params);
virtual ~csv_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -51,31 +51,30 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
template <typename T>
void parse_csv(T & stream,
std::string const& escape,
std::string const& separator,
std::string const& quote) const;
std::string const& quote);
private:
mutable mapnik::layer_descriptor desc_;
mutable mapnik::box2d<double> extent_;
mutable std::string filename_;
mutable std::string inline_string_;
mutable unsigned file_length_;
mutable int row_limit_;
mutable std::vector<mapnik::feature_ptr> features_;
mutable std::string escape_;
mutable std::string separator_;
mutable std::string quote_;
mutable std::vector<std::string> headers_;
mutable std::string manual_headers_;
mutable bool strict_;
mutable bool quiet_;
mutable double filesize_max_;
mutable mapnik::context_ptr ctx_;
mapnik::layer_descriptor desc_;
mapnik::box2d<double> extent_;
std::string filename_;
std::string inline_string_;
unsigned file_length_;
int row_limit_;
std::vector<mapnik::feature_ptr> features_;
std::string escape_;
std::string separator_;
std::string quote_;
std::vector<std::string> headers_;
std::string manual_headers_;
bool strict_;
bool quiet_;
double filesize_max_;
mapnik::context_ptr ctx_;
};
#endif // MAPNIK_CSV_DATASOURCE_HPP

39
plugins/input/gdal/gdal_datasource.cpp
View file

@ -73,20 +73,24 @@ inline GDALDataset* gdal_datasource::open_dataset() const
}
gdal_datasource::gdal_datasource(parameters const& params, bool bind)
gdal_datasource::gdal_datasource(parameters const& params)
: datasource(params),
desc_(*params.get<std::string>("type"), "utf-8"),
filter_factor_(*params_.get<double>("filter_factor", 0.0)),
nodata_value_(params_.get<double>("nodata"))
filter_factor_(*params.get<double>("filter_factor", 0.0)),
nodata_value_(params.get<double>("nodata"))
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Initializing...";
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "gdal_datasource::init");
#endif
GDALAllRegister();
boost::optional<std::string> file = params.get<std::string>("file");
if (! file) throw datasource_exception("missing <file> parameter");
boost::optional<std::string> base = params_.get<std::string>("base");
boost::optional<std::string> base = params.get<std::string>("base");
if (base)
{
dataset_name_ = *base + "/" + *file;
@ -96,22 +100,8 @@ gdal_datasource::gdal_datasource(parameters const& params, bool bind)
dataset_name_ = *file;
}
if (bind)
{
this->bind();
}
}
void gdal_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "gdal_datasource::bind");
#endif
shared_dataset_ = *params_.get<mapnik::boolean>("shared", false);
band_ = *params_.get<int>("band", -1);
shared_dataset_ = *params.get<mapnik::boolean>("shared", false);
band_ = *params.get<int>("band", -1);
GDALDataset *dataset = open_dataset();
@ -121,7 +111,7 @@ void gdal_datasource::bind() const
double tr[6];
bool bbox_override = false;
boost::optional<std::string> bbox_s = params_.get<std::string>("extent");
boost::optional<std::string> bbox_s = params.get<std::string>("extent");
if (bbox_s)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: BBox Parameter=" << *bbox_s;
@ -188,7 +178,6 @@ void gdal_datasource::bind() const
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Size=" << width_ << "," << height_;
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Extent=" << extent_;
is_bound_ = true;
}
gdal_datasource::~gdal_datasource()
@ -207,8 +196,6 @@ const char * gdal_datasource::name()
box2d<double> gdal_datasource::envelope() const
{
if (! is_bound_) bind();
return extent_;
}
@ -224,8 +211,6 @@ layer_descriptor gdal_datasource::get_descriptor() const
featureset_ptr gdal_datasource::features(query const& q) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "gdal_datasource::features");
#endif
@ -248,8 +233,6 @@ featureset_ptr gdal_datasource::features(query const& q) const
featureset_ptr gdal_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "gdal_datasource::features_at_point");
#endif

19
plugins/input/gdal/gdal_datasource.hpp
View file

@ -45,7 +45,7 @@
class gdal_datasource : public mapnik::datasource
{
public:
gdal_datasource(mapnik::parameters const& params, bool bind = true);
gdal_datasource(mapnik::parameters const& params);
virtual ~gdal_datasource();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -54,19 +54,18 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
GDALDataset* open_dataset() const;
mutable mapnik::box2d<double> extent_;
mapnik::box2d<double> extent_;
std::string dataset_name_;
mutable int band_;
int band_;
mapnik::layer_descriptor desc_;
mutable unsigned width_;
mutable unsigned height_;
mutable double dx_;
mutable double dy_;
mutable int nbands_;
mutable bool shared_dataset_;
unsigned width_;
unsigned height_;
double dx_;
double dy_;
int nbands_;
bool shared_dataset_;
double filter_factor_;
boost::optional<double> nodata_value_;
};

38
plugins/input/geojson/geojson_datasource.cpp
View file

@ -49,24 +49,6 @@ using mapnik::parameters;
DATASOURCE_PLUGIN(geojson_datasource)
geojson_datasource::geojson_datasource(parameters const& params, bool bind)
: datasource(params),
type_(datasource::Vector),
desc_(*params_.get<std::string>("type"),
*params_.get<std::string>("encoding","utf-8")),
file_(*params_.get<std::string>("file","")),
extent_(),
tr_(new mapnik::transcoder(*params_.get<std::string>("encoding","utf-8"))),
features_(),
tree_(16,1)
{
if (file_.empty()) throw mapnik::datasource_exception("GeoJSON Plugin: missing <file> parameter");
if (bind)
{
this->bind();
}
}
struct attr_value_converter : public boost::static_visitor<mapnik::eAttributeType>
{
mapnik::eAttributeType operator() (mapnik::value_integer /*val*/) const
@ -105,9 +87,18 @@ struct attr_value_converter : public boost::static_visitor<mapnik::eAttributeTyp
}
};
void geojson_datasource::bind() const
geojson_datasource::geojson_datasource(parameters const& params)
: datasource(params),
type_(datasource::Vector),
desc_(*params.get<std::string>("type"),
*params.get<std::string>("encoding","utf-8")),
file_(*params.get<std::string>("file","")),
extent_(),
tr_(new mapnik::transcoder(*params.get<std::string>("encoding","utf-8"))),
features_(),
tree_(16,1)
{
if (is_bound_) return;
if (file_.empty()) throw mapnik::datasource_exception("GeoJSON Plugin: missing <file> parameter");
typedef std::istreambuf_iterator<char> base_iterator_type;
@ -149,7 +140,6 @@ void geojson_datasource::bind() const
}
tree_.insert(box_type(point_type(box.minx(),box.miny()),point_type(box.maxx(),box.maxy())), count++);
}
is_bound_ = true;
}
geojson_datasource::~geojson_datasource() { }
@ -188,21 +178,16 @@ mapnik::datasource::datasource_t geojson_datasource::type() const
mapnik::box2d<double> geojson_datasource::envelope() const
{
if (!is_bound_) bind();
return extent_;
}
mapnik::layer_descriptor geojson_datasource::get_descriptor() const
{
if (!is_bound_) bind();
return desc_;
}
mapnik::featureset_ptr geojson_datasource::features(mapnik::query const& q) const
{
if (!is_bound_) bind();
// if the query box intersects our world extent then query for features
mapnik::box2d<double> const& b = q.get_bbox();
if (extent_.intersects(b))
@ -218,7 +203,6 @@ mapnik::featureset_ptr geojson_datasource::features(mapnik::query const& q) cons
// FIXME
mapnik::featureset_ptr geojson_datasource::features_at_point(mapnik::coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
throw mapnik::datasource_exception("GeoJSON Plugin: features_at_point is not supported yet");
return mapnik::featureset_ptr();
}

15
plugins/input/geojson/geojson_datasource.hpp
View file

@ -55,7 +55,7 @@ public:
typedef boost::geometry::index::rtree<box_type,std::size_t> spatial_index_type;
// constructor
geojson_datasource(mapnik::parameters const& params, bool bind=true);
geojson_datasource(mapnik::parameters const& params);
virtual ~geojson_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -64,16 +64,15 @@ public:
mapnik::box2d<double> envelope() const;
mapnik::layer_descriptor get_descriptor() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
void bind() const;
private:
mapnik::datasource::datasource_t type_;
mutable std::map<std::string, mapnik::parameters> statistics_;
mutable mapnik::layer_descriptor desc_;
mutable std::string file_;
mutable mapnik::box2d<double> extent_;
std::map<std::string, mapnik::parameters> statistics_;
mapnik::layer_descriptor desc_;
std::string file_;
mapnik::box2d<double> extent_;
boost::shared_ptr<mapnik::transcoder> tr_;
mutable std::vector<mapnik::feature_ptr> features_;
mutable spatial_index_type tree_;
std::vector<mapnik::feature_ptr> features_;
spatial_index_type tree_;
mutable std::deque<std::size_t> index_array_;
};

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

@ -85,7 +85,7 @@ void geos_error(const char* format, ...)
}
geos_datasource::geos_datasource(parameters const& params, bool bind)
geos_datasource::geos_datasource(parameters const& params)
: datasource(params),
extent_(),
extent_initialized_(false),
@ -99,42 +99,22 @@ geos_datasource::geos_datasource(parameters const& params, bool bind)
if (! geometry) throw datasource_exception("missing <wkt> parameter");
geometry_string_ = *geometry;
boost::optional<std::string> ext = params_.get<std::string>("extent");
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");
boost::optional<int> id = params.get<int>("gid");
if (id) geometry_id_ = *id;
boost::optional<std::string> gdata = params_.get<std::string>("field_data");
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");
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));
if (bind)
{
this->bind();
}
}
geos_datasource::~geos_datasource()
{
if (is_bound_)
{
geometry_.set_feature(0);
finishGEOS();
}
}
void geos_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::bind");
mapnik::progress_timer __stats__(std::clog, "geos_datasource::init");
#endif
// open geos driver
@ -151,7 +131,7 @@ void geos_datasource::bind() const
if (! extent_initialized_)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "geos_datasource::bind(initialize_extent)");
mapnik::progress_timer __stats2__(std::clog, "geos_datasource::init(initialize_extent)");
#endif
MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Initializing extent from geometry";
@ -222,9 +202,18 @@ void geos_datasource::bind() const
throw datasource_exception("GEOS Plugin: cannot determine extent for <wkt> geometry");
}
is_bound_ = true;
}
geos_datasource::~geos_datasource()
{
{
geometry_.set_feature(0);
finishGEOS();
}
}
const char * geos_datasource::name()
{
return "geos";
@ -237,14 +226,11 @@ mapnik::datasource::datasource_t geos_datasource::type() const
box2d<double> geos_datasource::envelope() const
{
if (! is_bound_) bind();
return extent_;
}
boost::optional<mapnik::datasource::geometry_t> geos_datasource::get_geometry_type() const
{
if (! is_bound_) bind();
boost::optional<mapnik::datasource::geometry_t> result;
#ifdef MAPNIK_STATS
@ -280,15 +266,11 @@ boost::optional<mapnik::datasource::geometry_t> geos_datasource::get_geometry_ty
layer_descriptor geos_datasource::get_descriptor() const
{
if (! is_bound_) bind();
return desc_;
}
featureset_ptr geos_datasource::features(query const& q) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::features");
#endif
@ -316,8 +298,6 @@ featureset_ptr geos_datasource::features(query const& q) const
featureset_ptr geos_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::features_at_point");
#endif

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

@ -45,7 +45,7 @@
class geos_datasource : public mapnik::datasource
{
public:
geos_datasource(mapnik::parameters const& params, bool bind = true);
geos_datasource(mapnik::parameters const& params);
virtual ~geos_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -54,17 +54,17 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
mutable mapnik::box2d<double> extent_;
mutable bool extent_initialized_;
void init(mapnik::parameters const& params);
mapnik::box2d<double> extent_;
bool extent_initialized_;
mapnik::datasource::datasource_t type_;
mutable mapnik::layer_descriptor desc_;
mapnik::layer_descriptor desc_;
mutable geos_feature_ptr geometry_;
mutable std::string geometry_data_;
mutable std::string geometry_data_name_;
mutable int geometry_id_;
std::string geometry_data_;
std::string geometry_data_name_;
int geometry_id_;
std::string geometry_string_;
};

27
plugins/input/kismet/kismet_datasource.cpp
View file

@ -67,7 +67,7 @@ boost::mutex knd_list_mutex;
std::list<kismet_network_data> knd_list;
const unsigned int queue_size = 20;
kismet_datasource::kismet_datasource(parameters const& params, bool bind)
kismet_datasource::kismet_datasource(parameters const& params)
: datasource(params),
extent_(),
extent_initialized_(false),
@ -75,7 +75,7 @@ kismet_datasource::kismet_datasource(parameters const& params, bool bind)
srs_("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs"),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
{
boost::optional<std::string> host = params_.get<std::string>("host");
boost::optional<std::string> host = params.get<std::string>("host");
if (host)
{
host_ = *host;
@ -85,37 +85,25 @@ kismet_datasource::kismet_datasource(parameters const& params, bool bind)
throw datasource_exception("Kismet Plugin: missing <host> parameter");
}
boost::optional<unsigned int> port = params_.get<unsigned int>("port", 2501);
boost::optional<unsigned int> port = params.get<unsigned int>("port", 2501);
if (port)
{
port_ = *port;
}
boost::optional<std::string> srs = params_.get<std::string>("srs");
boost::optional<std::string> srs = params.get<std::string>("srs");
if (srs)
{
srs_ = *srs;
}
boost::optional<std::string> ext = params_.get<std::string>("extent");
boost::optional<std::string> ext = params.get<std::string>("extent");
if (ext)
{
extent_initialized_ = extent_.from_string(*ext);
}
kismet_thread.reset(new boost::thread(boost::bind(&kismet_datasource::run, this, host_, port_)));
if (bind)
{
this->bind();
}
}
void kismet_datasource::bind() const
{
if (is_bound_) return;
is_bound_ = true;
}
kismet_datasource::~kismet_datasource()
@ -134,7 +122,6 @@ mapnik::datasource::datasource_t kismet_datasource::type() const
box2d<double> kismet_datasource::envelope() const
{
if (! is_bound_) bind();
return extent_;
}
@ -150,8 +137,6 @@ layer_descriptor kismet_datasource::get_descriptor() const
featureset_ptr kismet_datasource::features(query const& q) const
{
if (! is_bound_) bind();
MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource::features()";
// TODO: use box2d to filter bbox before adding to featureset_ptr
@ -168,8 +153,6 @@ featureset_ptr kismet_datasource::features(query const& q) const
featureset_ptr kismet_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (! is_bound_) bind();
MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource::features_at_point()";
return featureset_ptr();

5
plugins/input/kismet/kismet_datasource.hpp
View file

@ -47,7 +47,7 @@
class kismet_datasource : public mapnik::datasource
{
public:
kismet_datasource(mapnik::parameters const& params, bool bind = true);
kismet_datasource(mapnik::parameters const& params);
virtual ~kismet_datasource ();
datasource::datasource_t type() const;
static const char * name();
@ -56,7 +56,6 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
void run (std::string const& host, const unsigned int port);
@ -67,7 +66,7 @@ private:
unsigned int port_;
mapnik::datasource::datasource_t type_;
std::string srs_;
mutable mapnik::layer_descriptor desc_;
mapnik::layer_descriptor desc_;
boost::shared_ptr<boost::thread> kismet_thread;
};

124
plugins/input/occi/occi_datasource.cpp
View file

@ -68,25 +68,29 @@ const std::string occi_datasource::METADATA_TABLE = "USER_SDO_GEOM_METADATA";
DATASOURCE_PLUGIN(occi_datasource)
occi_datasource::occi_datasource(parameters const& params, bool bind)
occi_datasource::occi_datasource(parameters const& params)
: datasource (params),
type_(datasource::Vector),
fields_(*params_.get<std::string>("fields", "*")),
geometry_field_(*params_.get<std::string>("geometry_field", "")),
fields_(*params.get<std::string>("fields", "*")),
geometry_field_(*params.get<std::string>("geometry_field", "")),
srid_initialized_(false),
extent_initialized_(false),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
use_wkb_(*params_.get<mapnik::boolean>("use_wkb", false)),
row_limit_(*params_.get<int>("row_limit", 0)),
row_prefetch_(*params_.get<int>("row_prefetch", 100)),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")),
use_wkb_(*params.get<mapnik::boolean>("use_wkb", false)),
row_limit_(*params.get<int>("row_limit", 0)),
row_prefetch_(*params.get<int>("row_prefetch", 100)),
pool_(0),
conn_(0)
{
if (! params_.get<std::string>("user")) throw datasource_exception("OCCI Plugin: no <user> specified");
if (! params_.get<std::string>("password")) throw datasource_exception("OCCI Plugin: no <password> specified");
if (! params_.get<std::string>("host")) throw datasource_exception("OCCI Plugin: no <host> string specified");
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::init");
#endif
boost::optional<std::string> table = params_.get<std::string>("table");
if (! params.get<std::string>("user")) throw datasource_exception("OCCI Plugin: no <user> specified");
if (! params.get<std::string>("password")) throw datasource_exception("OCCI Plugin: no <password> specified");
if (! params.get<std::string>("host")) throw datasource_exception("OCCI Plugin: no <host> string specified");
boost::optional<std::string> table = params.get<std::string>("table");
if (! table)
{
throw datasource_exception("OCCI Plugin: no <table> parameter specified");
@ -95,57 +99,20 @@ occi_datasource::occi_datasource(parameters const& params, bool bind)
{
table_ = *table;
}
estimate_extent_ = *params.get<mapnik::boolean>("estimate_extent",false);
use_spatial_index_ = *params.get<mapnik::boolean>("use_spatial_index",true);
use_connection_pool_ = *params.get<mapnik::boolean>("use_connection_pool",true);
use_spatial_index_ = *params_.get<mapnik::boolean>("use_spatial_index",true);
use_connection_pool_ = *params_.get<mapnik::boolean>("use_connection_pool",true);
boost::optional<std::string> ext = params_.get<std::string>("extent");
boost::optional<std::string> ext = params.get<std::string>("extent");
if (ext) extent_initialized_ = extent_.from_string(*ext);
boost::optional<int> srid = params_.get<int>("srid");
boost::optional<int> srid = params.get<int>("srid");
if (srid)
{
srid_ = *srid;
srid_initialized_ = true;
}
if (bind)
{
this->bind();
}
}
occi_datasource::~occi_datasource()
{
if (is_bound_)
{
Environment* env = occi_environment::get_environment();
if (use_connection_pool_)
{
if (pool_ != 0)
{
env->terminateStatelessConnectionPool(pool_, StatelessConnectionPool::SPD_FORCE);
}
}
else
{
if (conn_ != 0)
{
env->terminateConnection(conn_);
}
}
}
}
void occi_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::bind");
#endif
// connect to environment
if (use_connection_pool_)
{
@ -154,11 +121,11 @@ void occi_datasource::bind() const
Environment* env = occi_environment::get_environment();
pool_ = env->createStatelessConnectionPool(
*params_.get<std::string>("user"),
*params_.get<std::string>("password"),
*params_.get<std::string>("host"),
*params_.get<int>("max_size", 5),
*params_.get<int>("initial_size", 1),
*params.get<std::string>("user"),
*params.get<std::string>("password"),
*params.get<std::string>("host"),
*params.get<int>("max_size", 5),
*params.get<int>("initial_size", 1),
1,
StatelessConnectionPool::HOMOGENEOUS);
}
@ -174,9 +141,9 @@ void occi_datasource::bind() const
Environment* env = occi_environment::get_environment();
conn_ = env->createConnection(
*params_.get<std::string>("user"),
*params_.get<std::string>("password"),
*params_.get<std::string>("host"));
*params.get<std::string>("user"),
*params.get<std::string>("password"),
*params.get<std::string>("host"));
}
catch (SQLException& ex)
{
@ -348,8 +315,28 @@ void occi_datasource::bind() const
throw datasource_exception(ex.getMessage());
}
}
}
is_bound_ = true;
occi_datasource::~occi_datasource()
{
{
Environment* env = occi_environment::get_environment();
if (use_connection_pool_)
{
if (pool_ != 0)
{
env->terminateStatelessConnectionPool(pool_, StatelessConnectionPool::SPD_FORCE);
}
}
else
{
if (conn_ != 0)
{
env->terminateConnection(conn_);
}
}
}
}
const char * occi_datasource::name()
@ -365,14 +352,11 @@ mapnik::datasource::datasource_t occi_datasource::type() const
box2d<double> occi_datasource::envelope() const
{
if (extent_initialized_) return extent_;
if (! is_bound_) bind();
double lox = 0.0, loy = 0.0, hix = 0.0, hiy = 0.0;
boost::optional<mapnik::boolean> estimate_extent =
params_.get<mapnik::boolean>("estimate_extent",false);
if (estimate_extent && *estimate_extent)
if (estimate_extent_)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::envelope(estimate_extent)");
@ -487,22 +471,16 @@ box2d<double> occi_datasource::envelope() const
boost::optional<mapnik::datasource::geometry_t> occi_datasource::get_geometry_type() const
{
// FIXME
//if (! is_bound_) bind();
return boost::optional<mapnik::datasource::geometry_t>();
}
layer_descriptor occi_datasource::get_descriptor() const
{
if (! is_bound_) bind();
return desc_;
}
featureset_ptr occi_datasource::features(query const& q) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::features");
#endif
@ -592,8 +570,6 @@ featureset_ptr occi_datasource::features(query const& q) const
featureset_ptr occi_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::features_at_point");
#endif

24
plugins/input/occi/occi_datasource.hpp
View file

@ -46,7 +46,7 @@
class occi_datasource : public mapnik::datasource
{
public:
occi_datasource(mapnik::parameters const& params, bool bind = true);
occi_datasource(mapnik::parameters const& params);
virtual ~occi_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -55,28 +55,28 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
static const std::string METADATA_TABLE;
mapnik::datasource::datasource_t type_;
mutable std::string table_;
mutable std::string table_name_;
mutable std::string fields_;
mutable std::string geometry_field_;
mutable int srid_;
mutable bool srid_initialized_;
std::string table_;
std::string table_name_;
std::string fields_;
std::string geometry_field_;
int srid_;
bool srid_initialized_;
mutable bool extent_initialized_;
mutable mapnik::box2d<double> extent_;
mutable mapnik::layer_descriptor desc_;
mutable bool use_wkb_;
mapnik::layer_descriptor desc_;
bool use_wkb_;
int row_limit_;
int row_prefetch_;
mutable oracle::occi::StatelessConnectionPool* pool_;
mutable oracle::occi::Connection* conn_;
oracle::occi::StatelessConnectionPool* pool_;
oracle::occi::Connection* conn_;
bool use_connection_pool_;
bool use_spatial_index_;
bool estimate_extent_;
};
#endif // OCCI_DATASOURCE_HPP

71
plugins/input/ogr/ogr_datasource.cpp
View file

@ -57,13 +57,32 @@ using mapnik::filter_in_box;
using mapnik::filter_at_point;
ogr_datasource::ogr_datasource(parameters const& params, bool bind)
ogr_datasource::ogr_datasource(parameters const& params)
: datasource(params),
extent_(),
type_(datasource::Vector),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")),
indexed_(false)
{
init(params);
}
ogr_datasource::~ogr_datasource()
{
// free layer before destroying the datasource
layer_.free_layer();
OGRDataSource::DestroyDataSource (dataset_);
}
void ogr_datasource::init(mapnik::parameters const& params)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "ogr_datasource::init");
#endif
// initialize ogr formats
OGRRegisterAll();
boost::optional<std::string> file = params.get<std::string>("file");
boost::optional<std::string> string = params.get<std::string>("string");
if (! file && ! string)
@ -88,35 +107,7 @@ ogr_datasource::ogr_datasource(parameters const& params, bool bind)
}
}
if (bind)
{
this->bind();
}
}
ogr_datasource::~ogr_datasource()
{
if (is_bound_)
{
// free layer before destroying the datasource
layer_.free_layer();
OGRDataSource::DestroyDataSource (dataset_);
}
}
void ogr_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "ogr_datasource::bind");
#endif
// initialize ogr formats
OGRRegisterAll();
std::string driver = *params_.get<std::string>("driver","");
std::string driver = *params.get<std::string>("driver","");
if (! driver.empty())
{
@ -147,9 +138,9 @@ void ogr_datasource::bind() const
}
// initialize layer
boost::optional<std::string> layer_by_name = params_.get<std::string>("layer");
boost::optional<unsigned> layer_by_index = params_.get<unsigned>("layer_by_index");
boost::optional<std::string> layer_by_sql = params_.get<std::string>("layer_by_sql");
boost::optional<std::string> layer_by_name = params.get<std::string>("layer");
boost::optional<unsigned> layer_by_index = params.get<unsigned>("layer_by_index");
boost::optional<std::string> layer_by_sql = params.get<std::string>("layer_by_sql");
int passed_parameters = 0;
passed_parameters += layer_by_name ? 1 : 0;
@ -185,7 +176,7 @@ void ogr_datasource::bind() const
else if (layer_by_sql)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats_sql__(std::clog, "ogr_datasource::bind(layer_by_sql)");
mapnik::progress_timer __stats_sql__(std::clog, "ogr_datasource::init(layer_by_sql)");
#endif
layer_.layer_by_sql(dataset_, *layer_by_sql);
@ -278,7 +269,7 @@ void ogr_datasource::bind() const
#endif
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "ogr_datasource::bind(get_column_description)");
mapnik::progress_timer __stats2__(std::clog, "ogr_datasource::init(get_column_description)");
#endif
// deal with attributes descriptions
@ -328,8 +319,6 @@ void ogr_datasource::bind() const
}
}
}
is_bound_ = true;
}
const char * ogr_datasource::name()
@ -344,7 +333,6 @@ mapnik::datasource::datasource_t ogr_datasource::type() const
box2d<double> ogr_datasource::envelope() const
{
if (! is_bound_) bind();
return extent_;
}
@ -432,7 +420,6 @@ boost::optional<mapnik::datasource::geometry_t> ogr_datasource::get_geometry_typ
layer_descriptor ogr_datasource::get_descriptor() const
{
if (! is_bound_) bind();
return desc_;
}
@ -475,8 +462,6 @@ void validate_attribute_names(query const& q, std::vector<attribute_descriptor>
featureset_ptr ogr_datasource::features(query const& q) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "ogr_datasource::features");
#endif
@ -522,8 +507,6 @@ featureset_ptr ogr_datasource::features(query const& q) const
featureset_ptr ogr_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "ogr_datasource::features_at_point");
#endif

18
plugins/input/ogr/ogr_datasource.hpp
View file

@ -47,7 +47,7 @@
class ogr_datasource : public mapnik::datasource
{
public:
ogr_datasource(mapnik::parameters const& params, bool bind=true);
ogr_datasource(mapnik::parameters const& params);
virtual ~ogr_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -56,18 +56,18 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
mutable mapnik::box2d<double> extent_;
void init(mapnik::parameters const& params);
mapnik::box2d<double> extent_;
mapnik::datasource::datasource_t type_;
std::string dataset_name_;
mutable std::string index_name_;
mutable OGRDataSource* dataset_;
mutable ogr_layer_ptr layer_;
mutable std::string layer_name_;
mutable mapnik::layer_descriptor desc_;
mutable bool indexed_;
std::string index_name_;
OGRDataSource* dataset_;
ogr_layer_ptr layer_;
std::string layer_name_;
mapnik::layer_descriptor desc_;
bool indexed_;
};
#endif // OGR_DATASOURCE_HPP

30
plugins/input/osm/osm_datasource.cpp
View file

@ -49,28 +49,17 @@ using mapnik::attribute_descriptor;
DATASOURCE_PLUGIN(osm_datasource)
osm_datasource::osm_datasource(const parameters& params, bool bind)
osm_datasource::osm_datasource(const parameters& params)
: datasource (params),
extent_(),
type_(datasource::Vector),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8"))
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8"))
{
if (bind)
{
this->bind();
}
}
void osm_datasource::bind() const
{
if (is_bound_) return;
osm_data_ = NULL;
std::string osm_filename = *params_.get<std::string>("file", "");
std::string parser = *params_.get<std::string>("parser", "libxml2");
std::string url = *params_.get<std::string>("url", "");
std::string bbox = *params_.get<std::string>("bbox", "");
std::string osm_filename = *params.get<std::string>("file", "");
std::string parser = *params.get<std::string>("parser", "libxml2");
std::string url = *params.get<std::string>("url", "");
std::string bbox = *params.get<std::string>("bbox", "");
// load the data
if (url != "" && bbox != "")
@ -118,7 +107,6 @@ void osm_datasource::bind() const
// Get the bounds of the data and set extent_ accordingly
bounds b = osm_data_->get_bounds();
extent_ = box2d<double>(b.w, b.s, b.e, b.n);
is_bound_ = true;
}
osm_datasource::~osm_datasource()
@ -144,8 +132,6 @@ layer_descriptor osm_datasource::get_descriptor() const
featureset_ptr osm_datasource::features(const query& q) const
{
if (!is_bound_) bind();
filter_in_box filter(q.get_bbox());
// so we need to filter osm features by bbox here...
@ -157,8 +143,6 @@ featureset_ptr osm_datasource::features(const query& q) const
featureset_ptr osm_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
filter_at_point filter(pt);
// collect all attribute names
std::vector<attribute_descriptor> const& desc_vector = desc_.get_descriptors();
@ -180,12 +164,10 @@ featureset_ptr osm_datasource::features_at_point(coord2d const& pt, double tol)
box2d<double> osm_datasource::envelope() const
{
if (!is_bound_) bind();
return extent_;
}
boost::optional<mapnik::datasource::geometry_t> osm_datasource::get_geometry_type() const
{
if (! is_bound_) bind();
return boost::optional<mapnik::datasource::geometry_t>(mapnik::datasource::Collection);
}

9
plugins/input/osm/osm_datasource.hpp
View file

@ -53,7 +53,7 @@ using mapnik::box2d;
class osm_datasource : public datasource
{
public:
osm_datasource(const parameters& params, bool bind = true);
osm_datasource(const parameters& params);
virtual ~osm_datasource();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -62,13 +62,12 @@ public:
box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
layer_descriptor get_descriptor() const;
void bind() const;
private:
mutable box2d<double> extent_;
mutable osm_dataset* osm_data_;
box2d<double> extent_;
osm_dataset* osm_data_;
mapnik::datasource::datasource_t type_;
mutable layer_descriptor desc_;
layer_descriptor desc_;
};
#endif // OSM_DATASOURCE_HPP

96
plugins/input/postgis/postgis_datasource.cpp
View file

@ -55,20 +55,20 @@ using boost::shared_ptr;
using mapnik::PoolGuard;
using mapnik::attribute_descriptor;
postgis_datasource::postgis_datasource(parameters const& params, bool bind)
postgis_datasource::postgis_datasource(parameters const& params)
: datasource(params),
table_(*params_.get<std::string>("table", "")),
table_(*params.get<std::string>("table", "")),
schema_(""),
geometry_table_(*params_.get<std::string>("geometry_table", "")),
geometry_field_(*params_.get<std::string>("geometry_field", "")),
key_field_(*params_.get<std::string>("key_field", "")),
cursor_fetch_size_(*params_.get<int>("cursor_size", 0)),
row_limit_(*params_.get<int>("row_limit", 0)),
geometry_table_(*params.get<std::string>("geometry_table", "")),
geometry_field_(*params.get<std::string>("geometry_field", "")),
key_field_(*params.get<std::string>("key_field", "")),
cursor_fetch_size_(*params.get<int>("cursor_size", 0)),
row_limit_(*params.get<int>("row_limit", 0)),
type_(datasource::Vector),
srid_(*params_.get<int>("srid", 0)),
srid_(*params.get<int>("srid", 0)),
extent_initialized_(false),
simplify_geometries_(false),
desc_(*params_.get<std::string>("type"), "utf-8"),
desc_(*params.get<std::string>("type"), "utf-8"),
creator_(params.get<std::string>("host"),
params.get<std::string>("port"),
params.get<std::string>("dbname"),
@ -79,45 +79,32 @@ postgis_datasource::postgis_datasource(parameters const& params, bool bind)
scale_denom_token_("!scale_denominator!"),
pixel_width_token_("!pixel_width!"),
pixel_height_token_("!pixel_height!"),
persist_connection_(*params_.get<mapnik::boolean>("persist_connection", true)),
extent_from_subquery_(*params_.get<mapnik::boolean>("extent_from_subquery", false)),
persist_connection_(*params.get<mapnik::boolean>("persist_connection", true)),
extent_from_subquery_(*params.get<mapnik::boolean>("extent_from_subquery", false)),
// params below are for testing purposes only (will likely be removed at any time)
intersect_min_scale_(*params_.get<int>("intersect_min_scale", 0)),
intersect_max_scale_(*params_.get<int>("intersect_max_scale", 0))
intersect_min_scale_(*params.get<int>("intersect_min_scale", 0)),
intersect_max_scale_(*params.get<int>("intersect_max_scale", 0))
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "postgis_datasource::init");
#endif
if (table_.empty())
{
throw mapnik::datasource_exception("Postgis Plugin: missing <table> parameter");
}
boost::optional<std::string> ext = params_.get<std::string>("extent");
boost::optional<std::string> ext = params.get<std::string>("extent");
if (ext && !ext->empty())
{
extent_initialized_ = extent_.from_string(*ext);
}
if (bind)
{
this->bind();
}
}
void postgis_datasource::bind() const
{
if (is_bound_)
{
return;
}
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "postgis_datasource::bind");
#endif
boost::optional<int> initial_size = params_.get<int>("initial_size", 1);
boost::optional<int> max_size = params_.get<int>("max_size", 10);
boost::optional<mapnik::boolean> autodetect_key_field = params_.get<mapnik::boolean>("autodetect_key_field", false);
boost::optional<mapnik::boolean> simplify_opt = params_.get<mapnik::boolean>("simplify_geometries", false);
boost::optional<int> initial_size = params.get<int>("initial_size", 1);
boost::optional<int> max_size = params.get<int>("max_size", 10);
boost::optional<mapnik::boolean> autodetect_key_field = params.get<mapnik::boolean>("autodetect_key_field", false);
boost::optional<mapnik::boolean> estimate_extent = params.get<mapnik::boolean>("estimate_extent", false);
estimate_extent_ = estimate_extent && *estimate_extent;
boost::optional<mapnik::boolean> simplify_opt = params.get<mapnik::boolean>("simplify_geometries", false);
simplify_geometries_ = simplify_opt && *simplify_opt;
ConnectionManager::instance().registerPool(creator_, *initial_size, *max_size);
@ -158,7 +145,7 @@ void postgis_datasource::bind() const
if (geometryColumn_.empty() || srid_ == 0)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_srid_and_geometry_column)");
mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::init(get_srid_and_geometry_column)");
#endif
std::ostringstream s;
@ -424,14 +411,13 @@ void postgis_datasource::bind() const
rs->close();
is_bound_ = true;
}
}
}
}
postgis_datasource::~postgis_datasource()
{
if (is_bound_ && ! persist_connection_)
if (! persist_connection_)
{
shared_ptr< Pool<Connection,ConnectionCreator> > pool = ConnectionManager::instance().getPool(creator_.id());
if (pool)
@ -457,11 +443,6 @@ mapnik::datasource::datasource_t postgis_datasource::type() const
layer_descriptor postgis_datasource::get_descriptor() const
{
if (! is_bound_)
{
bind();
}
return desc_;
}
@ -603,11 +584,6 @@ boost::shared_ptr<IResultSet> postgis_datasource::get_resultset(boost::shared_pt
featureset_ptr postgis_datasource::features(const query& q) const
{
if (! is_bound_)
{
bind();
}
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "postgis_datasource::features");
#endif
@ -725,11 +701,6 @@ featureset_ptr postgis_datasource::features(const query& q) const
featureset_ptr postgis_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (! is_bound_)
{
bind();
}
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "postgis_datasource::features_at_point");
#endif
@ -817,11 +788,6 @@ box2d<double> postgis_datasource::envelope() const
return extent_;
}
if (! is_bound_)
{
bind();
}
shared_ptr< Pool<Connection,ConnectionCreator> > pool = ConnectionManager::instance().getPool(creator_.id());
if (pool)
{
@ -832,9 +798,6 @@ box2d<double> postgis_datasource::envelope() const
std::ostringstream s;
boost::optional<mapnik::boolean> estimate_extent =
params_.get<mapnik::boolean>("estimate_extent", false);
if (geometryColumn_.empty())
{
std::ostringstream s_error;
@ -852,7 +815,7 @@ box2d<double> postgis_datasource::envelope() const
throw mapnik::datasource_exception("Postgis Plugin: " + s_error.str());
}
if (estimate_extent && *estimate_extent)
if (estimate_extent_)
{
s << "SELECT ST_XMin(ext),ST_YMin(ext),ST_XMax(ext),ST_YMax(ext)"
<< " FROM (SELECT ST_Estimated_Extent('";
@ -915,11 +878,6 @@ box2d<double> postgis_datasource::envelope() const
boost::optional<mapnik::datasource::geometry_t> postgis_datasource::get_geometry_type() const
{
if (! is_bound_)
{
bind();
}
boost::optional<mapnik::datasource::geometry_t> result;
shared_ptr< Pool<Connection,ConnectionCreator> > pool = ConnectionManager::instance().getPool(creator_.id());

18
plugins/input/postgis/postgis_datasource.hpp
View file

@ -58,7 +58,7 @@ using mapnik::coord2d;
class postgis_datasource : public datasource
{
public:
postgis_datasource(const parameters &params, bool bind=true);
postgis_datasource(const parameters &params);
~postgis_datasource();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -67,7 +67,6 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
layer_descriptor get_descriptor() const;
void bind() const;
private:
std::string sql_bbox(box2d<double> const& env) const;
@ -84,19 +83,19 @@ private:
const std::string username_;
const std::string password_;
const std::string table_;
mutable std::string schema_;
mutable std::string geometry_table_;
std::string schema_;
std::string geometry_table_;
const std::string geometry_field_;
mutable std::string key_field_;
std::string key_field_;
const int cursor_fetch_size_;
const int row_limit_;
mutable std::string geometryColumn_;
std::string geometryColumn_;
mapnik::datasource::datasource_t type_;
mutable int srid_;
int srid_;
mutable bool extent_initialized_;
mutable mapnik::box2d<double> extent_;
mutable bool simplify_geometries_;
mutable layer_descriptor desc_;
bool simplify_geometries_;
layer_descriptor desc_;
ConnectionCreator<Connection> creator_;
const std::string bbox_token_;
const std::string scale_denom_token_;
@ -104,6 +103,7 @@ private:
const std::string pixel_height_token_;
bool persist_connection_;
bool extent_from_subquery_;
bool estimate_extent_;
// params below are for testing purposes only (will likely be removed at any time)
int intersect_min_scale_;
int intersect_max_scale_;

3
plugins/input/postgis/postgis_featureset.cpp
View file

@ -75,8 +75,9 @@ feature_ptr postgis_featureset::next()
const char* buf = rs_->getValue(pos);
std::string name = rs_->getFieldName(pos);
// validation happens of this type at bind()
// validation happens of this type at initialization
mapnik::value_integer val;
if (oid == 20)
{
val = int8net(buf);

71
plugins/input/python/python_datasource.cpp
View file

@ -20,53 +20,27 @@ using mapnik::parameters;
DATASOURCE_PLUGIN(python_datasource)
python_datasource::python_datasource(parameters const& params, bool bind)
python_datasource::python_datasource(parameters const& params)
: datasource(params),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding","utf-8")),
factory_(*params_.get<std::string>("factory", ""))
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8")),
factory_(*params.get<std::string>("factory", ""))
{
// extract any remaining parameters as keyword args for the factory
BOOST_FOREACH(const mapnik::parameters::value_type& kv, params_)
BOOST_FOREACH(const mapnik::parameters::value_type& kv, params)
{
if((kv.first != "type") && (kv.first != "factory"))
{
kwargs_.insert(std::make_pair(kv.first, *params_.get<std::string>(kv.first)));
kwargs_.insert(std::make_pair(kv.first, *params.get<std::string>(kv.first)));
}
}
if (bind)
{
this->bind();
}
}
python_datasource::~python_datasource() { }
// This name must match the plugin filename, eg 'python.input'
const char* python_datasource::name_="python";
const char* python_datasource::name()
{
return name_;
}
mapnik::layer_descriptor python_datasource::get_descriptor() const
{
if (!is_bound_) bind();
return desc_;
}
// The following methods call into the Python interpreter and hence require, unfortunately, that the GIL be held.
void python_datasource::bind() const
{
// The following methods call into the Python interpreter and hence require, unfortunately, that the GIL be held.
using namespace boost;
if (is_bound_) return;
// if no factory callable is defined, bind is a nop
if (factory_.empty()) return;
if (factory_.empty())
{
throw mapnik::datasource_exception("Python: 'factory' option must be defined");
}
try
{
@ -111,16 +85,27 @@ void python_datasource::bind() const
{
throw mapnik::datasource_exception(extractException());
}
}
is_bound_ = true;
python_datasource::~python_datasource() { }
// This name must match the plugin filename, eg 'python.input'
const char* python_datasource::name_="python";
const char* python_datasource::name()
{
return name_;
}
mapnik::layer_descriptor python_datasource::get_descriptor() const
{
return desc_;
}
mapnik::datasource::datasource_t python_datasource::type() const
{
typedef boost::optional<mapnik::datasource::geometry_t> return_type;
if (!is_bound_) bind();
try
{
ensure_gil lock;
@ -137,8 +122,6 @@ mapnik::datasource::datasource_t python_datasource::type() const
mapnik::box2d<double> python_datasource::envelope() const
{
if (!is_bound_) bind();
try
{
ensure_gil lock;
@ -154,8 +137,6 @@ boost::optional<mapnik::datasource::geometry_t> python_datasource::get_geometry_
{
typedef boost::optional<mapnik::datasource::geometry_t> return_type;
if (!is_bound_) bind();
try
{
ensure_gil lock;
@ -181,8 +162,6 @@ boost::optional<mapnik::datasource::geometry_t> python_datasource::get_geometry_
mapnik::featureset_ptr python_datasource::features(mapnik::query const& q) const
{
if (!is_bound_) bind();
try
{
// if the query box intersects our world extent then query for features
@ -209,8 +188,6 @@ mapnik::featureset_ptr python_datasource::features(mapnik::query const& q) const
mapnik::featureset_ptr python_datasource::features_at_point(mapnik::coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
try
{
ensure_gil lock;

9
plugins/input/python/python_datasource.hpp
View file

@ -12,7 +12,7 @@ class python_datasource : public mapnik::datasource
public:
// constructor
// arguments must not change
python_datasource(mapnik::parameters const& params, bool bind=true);
python_datasource(mapnik::parameters const& params);
// destructor
virtual ~python_datasource ();
@ -41,15 +41,12 @@ public:
// mandatory: return the layer descriptor
mapnik::layer_descriptor get_descriptor() const;
// mandatory: will bind the datasource given params
void bind() const;
private:
static const char* name_;
mutable mapnik::layer_descriptor desc_;
mapnik::layer_descriptor desc_;
const std::string factory_;
std::map<std::string, std::string> kwargs_;
mutable boost::python::object datasource_;
boost::python::object datasource_;
};

38
plugins/input/raster/raster_datasource.cpp
View file

@ -45,7 +45,7 @@ using mapnik::image_reader;
DATASOURCE_PLUGIN(raster_datasource)
raster_datasource::raster_datasource(parameters const& params, bool bind)
raster_datasource::raster_datasource(parameters const& params)
: datasource(params),
desc_(*params.get<std::string>("type"), "utf-8"),
extent_initialized_(false)
@ -61,17 +61,18 @@ raster_datasource::raster_datasource(parameters const& params, bool bind)
else
filename_ = *file;
multi_tiles_ = *params_.get<bool>("multi", false);
tile_size_ = *params_.get<unsigned>("tile_size", 256);
tile_stride_ = *params_.get<unsigned>("tile_stride", 1);
multi_tiles_ = *params.get<bool>("multi", false);
tile_size_ = *params.get<unsigned>("tile_size", 256);
tile_stride_ = *params.get<unsigned>("tile_stride", 1);
format_ = *params_.get<std::string>("format","tiff");
format_ = *params.get<std::string>("format","tiff");
boost::optional<double> lox = params_.get<double>("lox");
boost::optional<double> loy = params_.get<double>("loy");
boost::optional<double> hix = params_.get<double>("hix");
boost::optional<double> hiy = params_.get<double>("hiy");
boost::optional<std::string> ext = params_.get<std::string>("extent");
boost::optional<double> lox = params.get<double>("lox");
boost::optional<double> loy = params.get<double>("loy");
boost::optional<double> hix = params.get<double>("hix");
boost::optional<double> hiy = params.get<double>("hiy");
boost::optional<std::string> ext = params.get<std::string>("extent");
if (lox && loy && hix && hiy)
{
@ -88,20 +89,10 @@ raster_datasource::raster_datasource(parameters const& params, bool bind)
throw datasource_exception("Raster Plugin: valid <extent> or <lox> <loy> <hix> <hiy> are required");
}
if (bind)
{
this->bind();
}
}
void raster_datasource::bind() const
{
if (is_bound_) return;
if (multi_tiles_)
{
boost::optional<unsigned> x_width = params_.get<unsigned>("x_width");
boost::optional<unsigned> y_width = params_.get<unsigned>("y_width");
boost::optional<unsigned> x_width = params.get<unsigned>("x_width");
boost::optional<unsigned> y_width = params.get<unsigned>("y_width");
if (! x_width)
{
@ -148,7 +139,6 @@ void raster_datasource::bind() const
MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Raster size=" << width_ << "," << height_;
is_bound_ = true;
}
raster_datasource::~raster_datasource()
@ -182,8 +172,6 @@ layer_descriptor raster_datasource::get_descriptor() const
featureset_ptr raster_datasource::features(query const& q) const
{
if (! is_bound_) bind();
mapnik::CoordTransform t(width_, height_, extent_, 0, 0);
mapnik::box2d<double> intersect = extent_.intersect(q.get_bbox());
mapnik::box2d<double> ext = t.forward(intersect);

7
plugins/input/raster/raster_datasource.hpp
View file

@ -44,7 +44,7 @@
class raster_datasource : public mapnik::datasource
{
public:
raster_datasource(const mapnik::parameters& params, bool bind=true);
raster_datasource(const mapnik::parameters& params);
virtual ~raster_datasource();
datasource::datasource_t type() const;
static const char * name();
@ -54,7 +54,6 @@ public:
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
bool log_enabled() const;
void bind() const;
private:
mapnik::layer_descriptor desc_;
@ -65,8 +64,8 @@ private:
bool multi_tiles_;
unsigned tile_size_;
unsigned tile_stride_;
mutable unsigned width_;
mutable unsigned height_;
unsigned width_;
unsigned height_;
};
#endif // RASTER_DATASOURCE_HPP

19
plugins/input/rasterlite/rasterlite_datasource.cpp
View file

@ -71,7 +71,7 @@ inline void* rasterlite_datasource::open_dataset() const
}
rasterlite_datasource::rasterlite_datasource(parameters const& params, bool bind)
rasterlite_datasource::rasterlite_datasource(parameters const& params)
: datasource(params),
desc_(*params.get<std::string>("type"),"utf-8")
{
@ -91,16 +91,11 @@ rasterlite_datasource::rasterlite_datasource(parameters const& params, bool bind
else
dataset_name_ = *file;
if (bind)
{
this->bind();
}
this->init(params);
}
void rasterlite_datasource::bind() const
void rasterlite_datasource::init(mapnik::parameters const& params)
{
if (is_bound_) return;
if (!boost::filesystem::exists(dataset_name_)) throw datasource_exception(dataset_name_ + " does not exist");
void *dataset = open_dataset();
@ -158,8 +153,6 @@ void rasterlite_datasource::bind() const
#endif
rasterliteClose(dataset);
is_bound_ = true;
}
rasterlite_datasource::~rasterlite_datasource()
@ -178,8 +171,6 @@ mapnik::datasource::datasource_t rasterlite_datasource::type() const
box2d<double> rasterlite_datasource::envelope() const
{
if (!is_bound_) bind();
return extent_;
}
@ -195,16 +186,12 @@ layer_descriptor rasterlite_datasource::get_descriptor() const
featureset_ptr rasterlite_datasource::features(query const& q) const
{
if (!is_bound_) bind();
rasterlite_query gq = q;
return boost::make_shared<rasterlite_featureset>(open_dataset(), gq);
}
featureset_ptr rasterlite_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
rasterlite_query gq = pt;
return boost::make_shared<rasterlite_featureset>(open_dataset(), gq);
}

5
plugins/input/rasterlite/rasterlite_datasource.hpp
View file

@ -45,7 +45,7 @@
class rasterlite_datasource : public mapnik::datasource
{
public:
rasterlite_datasource(mapnik::parameters const& params, bool bind = true);
rasterlite_datasource(mapnik::parameters const& params);
virtual ~rasterlite_datasource ();
mapnik::datasource::datasource_t type() const;
static const char * name();
@ -54,11 +54,10 @@ public:
mapnik::box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
void* open_dataset() const;
mutable mapnik::box2d<double> extent_;
mapnik::box2d<double> extent_;
std::string dataset_name_;
std::string table_name_;
mapnik::layer_descriptor desc_;

6
plugins/input/shape/dbfile.hpp
View file

@ -23,9 +23,11 @@
#ifndef DBFFILE_HPP
#define DBFFILE_HPP
// mapnik
#include <mapnik/feature.hpp>
#include <mapnik/noncopyable.hpp>
// boost
#include <boost/utility.hpp>
#include <boost/interprocess/streams/bufferstream.hpp>
// stl
@ -48,7 +50,7 @@ struct field_descriptor
};
class dbf_file : private boost::noncopyable
class dbf_file : private mapnik::noncopyable
{
private:
int num_records_;

37
plugins/input/shape/shape_datasource.cpp
View file

@ -55,14 +55,17 @@ using mapnik::filter_in_box;
using mapnik::filter_at_point;
using mapnik::attribute_descriptor;
shape_datasource::shape_datasource(const parameters &params, bool bind)
shape_datasource::shape_datasource(const parameters &params)
: datasource (params),
type_(datasource::Vector),
file_length_(0),
indexed_(false),
row_limit_(*params_.get<int>("row_limit",0)),
row_limit_(*params.get<int>("row_limit",0)),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::init");
#endif
boost::optional<std::string> file = params.get<std::string>("file");
if (!file) throw datasource_exception("Shape Plugin: missing <file> parameter");
@ -74,20 +77,6 @@ shape_datasource::shape_datasource(const parameters &params, bool bind)
boost::algorithm::ireplace_last(shape_name_,".shp","");
if (bind)
{
this->bind();
}
}
void shape_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::bind");
#endif
if (!boost::filesystem::exists(shape_name_ + ".shp"))
{
throw datasource_exception("Shape Plugin: shapefile '" + shape_name_ + ".shp' does not exist");
@ -107,7 +96,7 @@ void shape_datasource::bind() const
try
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "shape_datasource::bind(get_column_description)");
mapnik::progress_timer __stats2__(std::clog, "shape_datasource::init(get_column_description)");
#endif
boost::shared_ptr<shape_io> shape_ref = boost::make_shared<shape_io>(shape_name_);
@ -171,12 +160,9 @@ void shape_datasource::bind() const
throw;
}
is_bound_ = true;
}
shape_datasource::~shape_datasource() {}
void shape_datasource::init(shape_io& shape) const
void shape_datasource::init(shape_io& shape)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::init");
@ -240,6 +226,8 @@ void shape_datasource::init(shape_io& shape) const
MAPNIK_LOG_DEBUG(shape) << "shape_datasource: Shape type=" << shape_type_;
}
shape_datasource::~shape_datasource() {}
const char * shape_datasource::name()
{
return "shape";
@ -252,14 +240,11 @@ datasource::datasource_t shape_datasource::type() const
layer_descriptor shape_datasource::get_descriptor() const
{
if (!is_bound_) bind();
return desc_;
}
featureset_ptr shape_datasource::features(const query& q) const
{
if (!is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::features");
#endif
@ -290,8 +275,6 @@ featureset_ptr shape_datasource::features(const query& q) const
featureset_ptr shape_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::features_at_point");
#endif
@ -334,8 +317,6 @@ featureset_ptr shape_datasource::features_at_point(coord2d const& pt, double tol
box2d<double> shape_datasource::envelope() const
{
if (!is_bound_) bind();
return extent_;
}

17
plugins/input/shape/shape_datasource.hpp
View file

@ -52,7 +52,7 @@ using mapnik::coord2d;
class shape_datasource : public datasource
{
public:
shape_datasource(const parameters &params, bool bind=true);
shape_datasource(const parameters &params);
virtual ~shape_datasource();
datasource::datasource_t type() const;
static const char * name();
@ -61,20 +61,19 @@ public:
box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
layer_descriptor get_descriptor() const;
void bind() const;
private:
void init(shape_io& shape) const;
void init(shape_io& shape);
datasource::datasource_t type_;
std::string shape_name_;
mutable boost::shared_ptr<shape_io> shape_;
mutable shape_io::shapeType shape_type_;
mutable long file_length_;
mutable box2d<double> extent_;
mutable bool indexed_;
boost::shared_ptr<shape_io> shape_;
shape_io::shapeType shape_type_;
long file_length_;
box2d<double> extent_;
bool indexed_;
const int row_limit_;
mutable layer_descriptor desc_;
layer_descriptor desc_;
};
#endif //SHAPE_HPP

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

@ -175,7 +175,8 @@ void shape_io::read_polygon(shape_file::record_type & record, mapnik::geometry_c
double x = record.read_double();
double y = record.read_double();
poly->move_to(x, y);
double start_x = x;
double start_y = y;
for (int j=start+1;j<end-1;j++)
{
x = record.read_double();
@ -184,8 +185,14 @@ void shape_io::read_polygon(shape_file::record_type & record, mapnik::geometry_c
}
x = record.read_double();
y = record.read_double();
poly->close(x, y);
if (x == start_x && y == start_y)
{
poly->close(x, y);
}
else
{
poly->line_to(x, y);
}
geom.push_back(poly);
}
}

Some files were not shown because too many files have changed in this diff Show more