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

implement new debug system

Browse source
This commit is contained in:
kunitoki 2012-04-08 02:20:56 +02:00
parent 19f5f77417
commit 1f351e0e09
133 changed files with 1870 additions and 1065 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
SConstruct
View file

@ -325,7 +325,7 @@ opts.AddVariables(
# Variables affecting rendering back-ends
BoolVariable('RENDERING_STATS', 'Output rendering statistics during style processing', 'False'),
BoolVariable('INTERNAL_LIBAGG', 'Use provided libagg', 'True'),
BoolVariable('SVG_RENDERER', 'build support for native svg renderer', 'False'),
@ -345,7 +345,12 @@ opts.AddVariables(
PathVariable('SQLITE_LIBS', 'Search path for SQLITE library files', '/usr/' + LIBDIR_SCHEMA, PathVariable.PathAccept),
PathVariable('RASTERLITE_INCLUDES', 'Search path for RASTERLITE include files', '/usr/include/', PathVariable.PathAccept),
PathVariable('RASTERLITE_LIBS', 'Search path for RASTERLITE library files', '/usr/' + LIBDIR_SCHEMA, PathVariable.PathAccept),
# Variables for logging and statistics
BoolVariable('ENABLE_LOG', 'Enable logging, which is enabled by default when building in *debug*', 'False'),
BoolVariable('ENABLE_STATS', 'Enable global statistics during map processing', 'False'),
('LOG_FORMAT_STRING', 'The format string used before log output string, piped through strftime (max length of 255 characters)', 'Mapnik LOG> %Y-%m-%d %H:%M:%S:'),
# Other variables
BoolVariable('SHAPE_MEMORY_MAPPED_FILE', 'Utilize memory-mapped files in Shapefile Plugin (higher memory usage, better performance)', 'True'),
('SYSTEM_FONTS','Provide location for python bindings to register fonts (if given aborts installation of bundled DejaVu fonts)',''),
@ -1163,7 +1168,7 @@ if not preconfigured:
env.Append(CXXFLAGS = '-DBOOST_REGEX_HAS_ICU')
else:
env['SKIPPED_DEPS'].append('boost_regex_icu')
env['REQUESTED_PLUGINS'] = [ driver.strip() for driver in Split(env['INPUT_PLUGINS'])]
if len(env['REQUESTED_PLUGINS']):
@ -1411,10 +1416,26 @@ if not preconfigured:
# Common debugging flags.
# http://lists.fedoraproject.org/pipermail/devel/2010-November/144952.html
debug_flags = '-g -fno-omit-frame-pointer -DDEBUG -DMAPNIK_DEBUG'
ndebug_flags = '-DNDEBUG'
# Enable logging in debug mode (always) and release mode (when specified)
log_enabled = ' -DMAPNIK_LOG -DMAPNIK_LOG_FORMAT="%s"' % env['LOG_FORMAT_STRING']
if env['DEBUG']:
debug_flags += log_enabled
else:
if env['ENABLE_LOG']:
ndebug_flags += log_enabled
# Enable statistics reporting
if env['ENABLE_STATS']:
debug_flags += ' -DMAPNIK_STATS'
ndebug_flags += ' -DMAPNIK_STATS'
# Add rdynamic to allow using statics between application and plugins
# http://stackoverflow.com/questions/8623657/multiple-instances-of-singleton-across-shared-libraries-on-linux
env.MergeFlags('-rdynamic')
# Customizing the C++ compiler flags depending on:
# (1) the C++ compiler used; and
# (2) whether debug binaries are requested.

1
bindings/python/mapnik_color.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

1
bindings/python/mapnik_coord.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

4
bindings/python/mapnik_datasource.cpp
View file

@ -19,10 +19,11 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
#include <boost/python/detail/api_placeholder.hpp>
// stl
#include <sstream>
#include <vector>
@ -89,6 +90,7 @@ boost::python::dict describe(boost::shared_ptr<mapnik::datasource> const& ds)
description["name"] = ld.get_name();
description["geometry_type"] = ds->get_geometry_type();
description["encoding"] = ld.get_encoding();
description["log"] = ds->log_enabled();
return description;
}

2
bindings/python/mapnik_datasource_cache.cpp
View file

@ -20,8 +20,6 @@
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include <mapnik/datasource_cache.hpp>

1
bindings/python/mapnik_envelope.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id: mapnik_envelope.cc 27 2005-03-30 21:45:40Z pavlenko $
// boost
#include <boost/python.hpp>

5
bindings/python/mapnik_expression.cpp
View file

@ -19,9 +19,11 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
#include <boost/variant.hpp>
// mapnik
#include <mapnik/feature.hpp>
#include <mapnik/expression.hpp>
@ -30,7 +32,6 @@
#include <mapnik/parse_path.hpp>
#include <mapnik/value.hpp>
#include <boost/variant.hpp>
using mapnik::Feature;
using mapnik::expression_ptr;

3
bindings/python/mapnik_feature.cpp
View file

@ -19,13 +19,10 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python/suite/indexing/indexing_suite.hpp>
//#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <boost/python/iterator.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/tuple.hpp>

2
bindings/python/mapnik_featureset.cpp
View file

@ -19,10 +19,10 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
// mapnik
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp>

1
bindings/python/mapnik_font_engine.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include <mapnik/font_engine_freetype.hpp>

1
bindings/python/mapnik_geometry.cpp
View file

@ -17,7 +17,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

1
bindings/python/mapnik_grid.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

1
bindings/python/mapnik_grid_view.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

1
bindings/python/mapnik_image.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
extern "C"
{

1
bindings/python/mapnik_image_view.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
extern "C"
{

1
bindings/python/mapnik_inmem_metawriter.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

2
bindings/python/mapnik_layer.cpp
View file

@ -19,8 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id: mapnik_layer.cc 17 2005-03-08 23:58:43Z pavlenko $
// boost
#include <boost/python.hpp>

1
bindings/python/mapnik_line_pattern_symbolizer.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>

1
bindings/python/mapnik_line_symbolizer.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include "mapnik_enumeration.hpp"

1
bindings/python/mapnik_map.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id: mapnik_map.cc 17 2005-03-08 23:58:43Z pavlenko $
// boost
#include <boost/python.hpp>

2
bindings/python/mapnik_markers_symbolizer.cpp
View file

@ -19,9 +19,9 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include <mapnik/graphics.hpp>
#include <mapnik/image_util.hpp>
#include <mapnik/markers_symbolizer.hpp>

1
bindings/python/mapnik_palette.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

5
bindings/python/mapnik_parameters.cpp
View file

@ -25,6 +25,7 @@
#include <boost/make_shared.hpp>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/params.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/value.hpp>
@ -102,7 +103,9 @@ struct parameters_pickle_suite : boost::python::pickle_suite
}
else
{
std::clog << "could not unpickle key: " << key << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "parameters_pickle_suite: Could not unpickle key=" << key;
#endif
}
}
}

1
bindings/python/mapnik_point_symbolizer.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include "mapnik_enumeration.hpp"

1
bindings/python/mapnik_polygon_pattern_symbolizer.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include <mapnik/image_util.hpp>

1
bindings/python/mapnik_polygon_symbolizer.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/python.hpp>
#include "mapnik_enumeration.hpp"

2
bindings/python/mapnik_proj_transform.cpp
View file

@ -19,10 +19,10 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// mapnik
#include <mapnik/proj_transform.hpp>
// boost
#include <boost/python.hpp>

3
bindings/python/mapnik_projection.cpp
View file

@ -19,9 +19,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
//boost
// boost
#include <boost/python.hpp>
// mapnik

5
bindings/python/mapnik_query.cpp
View file

@ -19,11 +19,14 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
// mapnik
#include <mapnik/query.hpp>
#include <mapnik/box2d.hpp>
using mapnik::query;
using mapnik::box2d;

4
bindings/python/mapnik_raster_colorizer.cpp
View file

@ -19,10 +19,12 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
// mapnik
#include <mapnik/raster_colorizer.hpp>
using mapnik::raster_colorizer;

4
bindings/python/mapnik_raster_symbolizer.cpp
View file

@ -19,9 +19,11 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
// mapnik
#include <mapnik/raster_symbolizer.hpp>
using mapnik::raster_symbolizer;

3
bindings/python/mapnik_rule.cpp
View file

@ -19,13 +19,14 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
#include <boost/python/implicit.hpp>
#include <boost/python/detail/api_placeholder.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
// mapnik
#include <mapnik/rule.hpp>
#include <mapnik/expression.hpp>
#include <mapnik/expression_string.hpp>

4
bindings/python/mapnik_shield_symbolizer.cpp
View file

@ -20,9 +20,11 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
// mapnik
#include <mapnik/shield_symbolizer.hpp>
#include <mapnik/image_util.hpp>
#include <mapnik/path_expression_grammar.hpp>

1
bindings/python/mapnik_stroke.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

3
bindings/python/mapnik_style.cpp
View file

@ -19,11 +19,12 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
// mapnik
#include "mapnik_enumeration.hpp"
#include <mapnik/feature_type_style.hpp>

3
bindings/python/mapnik_symbolizer.cpp
View file

@ -19,10 +19,11 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>
// mapnik
//symbolizer typdef here rather than mapnik/symbolizer.hpp
#include <mapnik/rule.hpp>

1
bindings/python/mapnik_view_transform.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
// boost
#include <boost/python.hpp>

1
bindings/python/python_cairo.cpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#if defined(HAVE_CAIRO) && defined(HAVE_PYCAIRO)

5
bindings/python/python_grid_utils.hpp
View file

@ -28,6 +28,7 @@
#include <boost/foreach.hpp>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/grid/grid_renderer.hpp>
#include <mapnik/grid/grid.hpp>
#include <mapnik/grid/grid_util.hpp>
@ -271,7 +272,9 @@ static void write_features(T const& grid_type,
}
else
{
std::clog << "should not get here: key '" << key << "' not found in grid feature properties\n";
#ifdef MAPNIK_LOG
mapnik::log() << "write_features: Should not get here: key " << key << " not found in grid feature properties";
#endif
}
}
}

1
bindings/python/python_optional.hpp
View file

@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#include <boost/optional/optional.hpp>
#include <boost/python.hpp>

41
include/mapnik/ctrans.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_CTRANS_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/vertex.hpp>
#include <mapnik/coord_array.hpp>
@ -239,9 +240,9 @@ struct MAPNIK_DECL coord_transform_parallel
angle_a = atan2((m_pre_y-m_cur_y),(m_pre_x-m_cur_x));
dx_pre = cos(angle_a + pi_by_2);
dy_pre = sin(angle_a + pi_by_2);
#ifdef MAPNIK_DEBUG
std::clog << "offsetting line by: " << offset_ << "\n";
std::clog << "initial dx=" << (dx_pre * offset_) << " dy=" << (dy_pre * offset_) << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "coord_transform_parallel: Offsetting line by=" << offset_;
mapnik::log() << "coord_transform_parallel: Initial dx=" << (dx_pre * offset_) << ",dy=" << (dy_pre * offset_);
#endif
*x = m_pre_x + (dx_pre * offset_);
*y = m_pre_y + (dy_pre * offset_);
@ -290,14 +291,14 @@ struct MAPNIK_DECL coord_transform_parallel
else // skip sharp spikes
{
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
dx_curr = cos(angle_a + pi_by_2);
dy_curr = sin(angle_a + pi_by_2);
sin_curve = dx_curr*dy_pre-dy_curr*dx_pre;
std::clog << "angle a: " << angle_a << "\n";
std::clog << "angle b: " << angle_b << "\n";
std::clog << "h: " << h << "\n";
std::clog << "sin_curve: " << sin_curve << "\n";
mapnik::log() << "coord_transform_parallel: angle a=" << angle_a;
mapnik::log() << "coord_transform_parallel: angle b=" << angle_b;
mapnik::log() << "coord_transform_parallel: h=" << h;
mapnik::log() << "coord_transform_parallel: sin_curve=" << sin_curve;
#endif
m_status = process;
break;
@ -309,21 +310,21 @@ struct MAPNIK_DECL coord_transform_parallel
sin_curve = dx_curr*dy_pre-dy_curr*dx_pre;
cos_curve = -dx_pre*dx_curr-dy_pre*dy_curr;
#ifdef MAPNIK_DEBUG
std::clog << "sin_curve value: " << sin_curve << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "coord_transform_parallel: sin_curve value=" << sin_curve;
#endif
if(sin_curve > -0.3 && sin_curve < 0.3) {
angle_b = atan2((m_cur_y-m_next_y),(m_cur_x-m_next_x));
h = tan((angle_b - angle_a)/2.0);
*x = m_cur_x + (dx_curr * offset_) - h * (dy_curr * offset_);
*y = m_cur_y + (dy_curr * offset_) + h * (dx_curr * offset_);
angle_b = atan2((m_cur_y-m_next_y),(m_cur_x-m_next_x));
h = tan((angle_b - angle_a)/2.0);
*x = m_cur_x + (dx_curr * offset_) - h * (dy_curr * offset_);
*y = m_cur_y + (dy_curr * offset_) + h * (dx_curr * offset_);
} else {
if (angle_b - angle_a > 0)
h = -1.0*(1.0+cos_curve)/sin_curve;
else
h = (1.0+cos_curve)/sin_curve;
*x = m_cur_x + (dx_curr + base_shift*dy_curr)*offset_;
*y = m_cur_y + (dy_curr - base_shift*dx_curr)*offset_;
if (angle_b - angle_a > 0)
h = -1.0*(1.0+cos_curve)/sin_curve;
else
h = (1.0+cos_curve)/sin_curve;
*x = m_cur_x + (dx_curr + base_shift*dy_curr)*offset_;
*y = m_cur_y + (dy_curr - base_shift*dx_curr)*offset_;
}
*/

11
include/mapnik/datasource.hpp
View file

@ -88,6 +88,7 @@ public:
datasource (parameters const& params)
: params_(params),
log_enabled_(false),
is_bound_(false)
{
}
@ -104,6 +105,15 @@ public:
return params_;
}
/*!
* @brief Get the status of detasource logging
* @return Return true if log is enabled, false otherwise
*/
bool log_enabled() const
{
return log_enabled_;
}
/*!
* @brief Get the type of the datasource
* @return The type of the datasource (Vector or Raster)
@ -123,6 +133,7 @@ public:
virtual ~datasource() {}
protected:
parameters params_;
bool log_enabled_;
mutable bool is_bound_;
};

127
include/mapnik/debug.hpp Normal file
View file

@ -0,0 +1,127 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef MAPNIK_DEBUG_HPP
#define MAPNIK_DEBUG_HPP
// mapnik
#include <mapnik/global.hpp>
// boost
#ifdef MAPNIK_THREADSAFE
#include <boost/thread/mutex.hpp>
#endif
// std
#include <iostream>
#include <cassert>
#include <sstream>
#include <ctime>
#include <ostream>
#include <fstream>
#ifdef MAPNIK_DEBUG
#define MAPNIK_DEBUG_AS_BOOL true
#else
#define MAPNIK_DEBUG_AS_BOOL false
#endif
#ifndef MAPNIK_LOG_FORMAT
#error Must run configure again to regenerate the correct log format string. See LOG_FORMAT_STRING scons option.
#endif
namespace mapnik {
namespace logger {
#define __xstr__(s) __str__(s)
#define __str__(s) #s
static inline std::string format_logger() {
char buf[256];
const time_t tm = time(0);
strftime(buf, sizeof(buf), __xstr__(MAPNIK_LOG_FORMAT), localtime(&tm));
return buf;
}
#undef __xstr__
#undef __str__
template<class Ch, class Tr, class A>
class no_output {
private:
struct null_buffer {
template<class T>
null_buffer &operator<<(const T &) {
return *this;
}
};
public:
typedef null_buffer stream_buffer;
public:
void operator()(const stream_buffer &) {
}
};
template<class Ch, class Tr, class A>
class output_to_clog {
public:
typedef std::basic_ostringstream<Ch, Tr, A> stream_buffer;
public:
void operator()(const stream_buffer &s) {
#ifdef MAPNIK_THREADSAFE
static boost::mutex mutex;
boost::mutex::scoped_lock lock(mutex);
#endif
std::clog << format_logger() << " " << s.str() << std::endl;
}
};
template<template <class Ch, class Tr, class A> class OutputPolicy,
class Ch = char,
class Tr = std::char_traits<Ch>,
class A = std::allocator<Ch> >
class base_log {
typedef OutputPolicy<Ch, Tr, A> output_policy;
public:
~base_log() {
output_policy()(streambuf_);
}
public:
template<class T>
base_log &operator<<(const T &x) {
streambuf_ << x;
return *this;
}
private:
typename output_policy::stream_buffer streambuf_;
};
}
class log : public logger::base_log<logger::output_to_clog>
{
};
}
#endif

12
include/mapnik/font_engine_freetype.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_FONT_ENGINE_FREETYPE_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/color.hpp>
#include <mapnik/utils.hpp>
#include <mapnik/ctrans.hpp>
@ -138,9 +139,8 @@ public:
~font_face()
{
#ifdef MAPNIK_DEBUG
std::clog << "~font_face: Clean up face \"" << family_name()
<< " " << style_name() << "\"" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "font_face: Clean up face \"" << family_name() << " " << style_name() << "\"";
#endif
FT_Done_Face(face_);
}
@ -225,9 +225,10 @@ public:
~stroker()
{
#ifdef MAPNIK_DEBUG
std::clog << "~stroker: destroy stroker:" << s_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "stroker: Destroy stroker=" << s_;
#endif
FT_Stroker_Done(s_);
}
private:
@ -310,6 +311,7 @@ public:
face_set->add(face);
} else {
#ifdef MAPNIK_DEBUG
// TODO - handle with mapnik::log
std::cerr << "Failed to find face '" << *name << "' in font set '" << fset.get_name() << "'\n";
#endif
}

10
include/mapnik/grid/grid.hpp
View file

@ -25,6 +25,7 @@
// mapnik
#include <mapnik/config.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/image_data.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/grid/grid_view.hpp>
@ -72,7 +73,6 @@ private:
public:
hit_grid(int width, int height, std::string const& key, unsigned int resolution)
:width_(width),
height_(height),
@ -136,7 +136,9 @@ public:
}
else
{
std::clog << "should not get here: key '" << key_ << "' not found in feature properties\n";
#ifdef MAPNIK_LOG
mapnik::log() << "hit_grid: Should not get here: key '" << key_ << "' not found in feature properties";
#endif
}
}
@ -153,7 +155,9 @@ public:
}
else
{
std::clog << "### Warning: key '" << key_ << "' was blank for " << *feature << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "hit_grid: Warning - key '" << key_ << "' was blank for " << *feature;
#endif
}
}

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

@ -103,7 +103,7 @@ struct feature_collection_grammar :
qi::on_error<qi::fail>
(
feature_collection
, std::clog
, std::cerr
<< phoenix::val("Error parsing GeoJSON ")
<< qi::_4
<< phoenix::val(" here: \"")

8
include/mapnik/memory_featureset.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_MEMORY_FEATURESET_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/memory_datasource.hpp>
// boost
@ -52,10 +53,11 @@ public:
{
while (pos_ != end_)
{
for (unsigned i=0; i<(*pos_)->num_geometries();++i) {
for (unsigned i=0; i<(*pos_)->num_geometries();++i)
{
geometry_type & geom = (*pos_)->get_geometry(i);
#ifdef MAPNIK_DEBUG
std::clog << "bbox_=" << bbox_ << ", geom.envelope=" << geom.envelope() << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "memory_featureset: BBox=" << bbox_ << ",Envelope=" << geom.envelope();
#endif
if (bbox_.intersects(geom.envelope()))
{

2
include/mapnik/metawriter_json.hpp
View file

@ -87,7 +87,7 @@ protected:
bool pixel_coordinates_;
virtual void write_header();
inline void write_feature_header(std::string type) {
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
if (count_ == STOPPED)
{
std::cerr << "WARNING: Metawriter not started before using it.\n";

17
include/mapnik/pool.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_POOL_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/utils.hpp>
// boost
@ -100,8 +101,8 @@ public:
typename ContType::iterator itr=unusedPool_.begin();
while ( itr!=unusedPool_.end())
{
#ifdef MAPNIK_DEBUG
std::clog<<"borrow "<<(*itr).get()<<"\n";
#ifdef MAPNIK_LOG
mapnik::log() << "pool: Borrow instance=" << (*itr).get();
#endif
if ((*itr)->isOK())
{
@ -111,8 +112,8 @@ public:
}
else
{
#ifdef MAPNIK_DEBUG
std::clog<<"bad connection (erase)" << (*itr).get()<<"\n";
#ifdef MAPNIK_LOG
mapnik::log() << "pool: Bad connection (erase) instance=" << (*itr).get();
#endif
itr=unusedPool_.erase(itr);
}
@ -123,8 +124,8 @@ public:
if (conn->isOK())
{
usedPool_.push_back(conn);
#ifdef MAPNIK_DEBUG
std::clog << "create << " << conn.get() << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "pool: Create connection=" << conn.get();
#endif
return conn;
}
@ -142,8 +143,8 @@ public:
{
if (obj.get()==(*itr).get())
{
#ifdef MAPNIK_DEBUG
std::clog<<"return "<<(*itr).get()<<"\n";
#ifdef MAPNIK_LOG
mapnik::log() << "pool: Return instance=" << (*itr).get();
#endif
unusedPool_.push_back(*itr);
usedPool_.erase(itr);

2
include/mapnik/rule.hpp
View file

@ -203,7 +203,7 @@ private:
template <class T>
void copy_text_ptr(T & sym) const
{
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
std::cerr << "Warning: Deep copying TextSymbolizers is broken!\n";
#endif
}

13
include/mapnik/svg/svg_renderer.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_SVG_RENDERER_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/svg/svg_path_attributes.hpp>
#include <mapnik/gradient.hpp>
#include <mapnik/box2d.hpp>
@ -141,11 +142,13 @@ public:
BOOST_FOREACH ( mapnik::stop_pair const& st, grad.get_stop_array() )
{
mapnik::color const& stop_color = st.second;
unsigned r= stop_color.red();
unsigned g= stop_color.green();
unsigned b= stop_color.blue();
unsigned a= stop_color.alpha();
//std::clog << "r: " << r << " g: " << g << " b: " << b << "a: " << a << "\n";
unsigned r = stop_color.red();
unsigned g = stop_color.green();
unsigned b = stop_color.blue();
unsigned a = stop_color.alpha();
#ifdef MAPNIK_LOG
//mapnik::log() << "svg_renderer: r=" << r << ",g=" << g << ",b=" << b << ",a=" << a;
#endif
m_gradient_lut.add_color(st.first, agg::rgba8(r, g, b, int(a * opacity)));
}
m_gradient_lut.build_lut();

80
include/mapnik/timer.hpp
View file

@ -30,8 +30,34 @@
#include <iomanip>
#include <ctime>
#ifndef WIN32
#include <sys/time.h> // for gettimeofday() on unix
#include <sys/resource.h>
#else
#include <windows.h>
#endif
namespace mapnik {
// Try to return the time now
inline double time_now()
{
#ifndef WIN32
struct timeval t;
struct timezone tzp;
gettimeofday(&t, &tzp);
return t.tv_sec + t.tv_usec * 1e-6;
#else
LARGE_INTEGER t, f;
QueryPerformanceCounter(&t);
QueryPerformanceFrequency(&f);
return double(t.QuadPart) / double(f.QuadPart);
#endif
}
// Measure times in both wall clock time and CPU times. Results are returned in milliseconds.
class timer
{
@ -41,44 +67,50 @@ public:
restart();
}
virtual ~timer()
{
}
void restart()
{
_stopped = false;
gettimeofday(&_wall_clock_start, NULL);
_cpu_start = clock();
stopped_ = false;
wall_clock_start_ = time_now();
cpu_start_ = clock();
}
virtual void stop() const
{
_stopped = true;
_cpu_end = clock();
gettimeofday(&_wall_clock_end, NULL);
stopped_ = true;
cpu_end_ = clock();
wall_clock_end_ = time_now();
}
double cpu_elapsed() const
{
// return elapsed CPU time in ms
if (!_stopped)
if (! stopped_)
{
stop();
}
return ((double) (_cpu_end - _cpu_start)) / CLOCKS_PER_SEC * 1000.0;
return ((double) (cpu_end_ - cpu_start_)) / CLOCKS_PER_SEC * 1000.0;
}
double wall_clock_elapsed() const
{
// return elapsed wall clock time in ms
if (!_stopped)
if (! stopped_)
{
stop();
}
long seconds = _wall_clock_end.tv_sec - _wall_clock_start.tv_sec;
long useconds = _wall_clock_end.tv_usec - _wall_clock_start.tv_usec;
return ((seconds) * 1000 + useconds / 1000.0) + 0.5;
return (wall_clock_end_ - wall_clock_start_) * 1000.0;
}
protected:
mutable timeval _wall_clock_start, _wall_clock_end;
mutable clock_t _cpu_start, _cpu_end;
mutable bool _stopped;
mutable double wall_clock_start_, wall_clock_end_;
mutable clock_t cpu_start_, cpu_end_;
mutable bool stopped_;
};
// A progress_timer behaves like a timer except that the destructor displays
@ -86,15 +118,17 @@ protected:
class progress_timer : public timer
{
public:
progress_timer(std::ostream & os, std::string const& base_message):
os_(os),
base_message_(base_message)
progress_timer(std::ostream & os, std::string const& base_message)
: os_(os),
base_message_(base_message)
{}
~progress_timer()
{
if (!_stopped)
if (! stopped_)
{
stop();
}
}
void stop() const
@ -112,8 +146,9 @@ public:
catch (...) {} // eat any exceptions
}
void discard() {
_stopped = true;
void discard()
{
stopped_ = true;
}
private:
@ -122,4 +157,5 @@ private:
};
};
#endif // MAPNIK_TIMER_HPP

24
include/mapnik/utils.hpp
View file

@ -23,10 +23,14 @@
#ifndef MAPNIK_UTILS_HPP
#define MAPNIK_UTILS_HPP
// boost
#ifdef MAPNIK_THREADSAFE
#include <boost/thread/mutex.hpp>
#endif
// mapnik
#include <mapnik/debug.hpp>
// stl
#include <stdexcept>
#include <cstdlib>
@ -86,7 +90,7 @@ public:
// Sun C++ Compiler doesn't handle `volatile` keyword same as GCC.
static void destroy(T* obj)
#else
static void destroy(volatile T* obj)
static void destroy(volatile T* obj)
#endif
{
obj->~T();
@ -109,6 +113,7 @@ template <typename T,
static bool destroyed_;
singleton(const singleton &rhs);
singleton& operator=(const singleton&);
static void onDeadReference()
{
throw std::runtime_error("dead reference!");
@ -119,8 +124,9 @@ template <typename T,
CreatePolicy<T>::destroy(pInstance_);
pInstance_ = 0;
destroyed_=true;
#ifdef MAPNIK_DEBUG
std::clog << " destroyed singleton \n";
#ifdef MAPNIK_LOG
mapnik::log() << "singleton: Destroyed instance";
#endif
}
@ -132,21 +138,25 @@ protected:
public:
static T* instance()
{
if (!pInstance_)
if (! pInstance_)
{
#ifdef MAPNIK_THREADSAFE
mutex::scoped_lock lock(mutex_);
#endif
if (!pInstance_)
if (! pInstance_)
{
if (destroyed_)
{
onDeadReference();
}
else
{
pInstance_=CreatePolicy<T>::create();
pInstance_ = CreatePolicy<T>::create();
#ifdef MAPNIK_LOG
mapnik::log() << "singleton: Created instance";
#endif
// register destruction
std::atexit(&DestroySingleton);
}

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

@ -1,3 +1,25 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#include "csv_datasource.hpp"
// boost
@ -9,6 +31,7 @@
#include <boost/spirit/include/phoenix_operator.hpp>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/feature_factory.hpp>
#include <mapnik/geometry.hpp>
@ -31,24 +54,26 @@ using namespace boost::spirit;
DATASOURCE_PLUGIN(csv_datasource)
csv_datasource::csv_datasource(parameters const& params, bool bind)
: datasource(params),
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)),
features_(),
escape_(*params_.get<std::string>("escape", "")),
separator_(*params_.get<std::string>("separator", "")),
quote_(*params_.get<std::string>("quote", "")),
headers_(),
manual_headers_(boost::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>())
: datasource(params),
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)),
features_(),
escape_(*params_.get<std::string>("escape", "")),
separator_(*params_.get<std::string>("separator", "")),
quote_(*params_.get<std::string>("quote", "")),
headers_(),
manual_headers_(boost::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>())
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
/* TODO:
general:
- refactor parser into generic class
@ -197,8 +222,9 @@ void csv_datasource::parse_csv(T& stream,
if (num_tabs > num_commas)
{
sep = "\t";
#ifdef MAPNIK_DEBUG
std::clog << "CSV Plugin: auto detected tab separator\n";
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "csv_datasource: auto detected tab separator";
#endif
}
}
@ -208,8 +234,9 @@ void csv_datasource::parse_csv(T& stream,
if (num_pipes > num_commas)
{
sep = "|";
#ifdef MAPNIK_DEBUG
std::clog << "CSV Plugin: auto detected '|' separator\n";
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "csv_datasource: auto detected '|' separator";
#endif
}
else // semicolons
@ -218,8 +245,9 @@ void csv_datasource::parse_csv(T& stream,
if (num_semicolons > num_commas)
{
sep = ";";
#ifdef MAPNIK_DEBUG
std::clog << "CSV Plugin: auto detected ';' separator\n";
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "csv_datasource: auto detected ';' separator";
#endif
}
}
@ -237,8 +265,8 @@ void csv_datasource::parse_csv(T& stream,
std::string quo = boost::trim_copy(quote);
if (quo.empty()) quo = "\"";
#ifdef MAPNIK_DEBUG
std::clog << "CSV Plugin: csv grammer: sep: '" << sep << "' quo: '" << quo << "' esc: '" << esc << "'\n";
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "csv_datasource: csv grammer: sep: '" << sep << "' quo: '" << quo << "' esc: '" << esc;
#endif
boost::escaped_list_separator<char> grammer;
@ -404,8 +432,8 @@ void csv_datasource::parse_csv(T& stream,
{
if ((row_limit_ > 0) && (line_number > row_limit_))
{
#ifdef MAPNIK_DEBUG
std::clog << "CSV Plugin: row limit hit, exiting at feature: " << feature_count << "\n";
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "csv_datasource: row limit hit, exiting at feature: " << feature_count;
#endif
break;
}
@ -417,12 +445,15 @@ void csv_datasource::parse_csv(T& stream,
{
std::string trimmed = csv_line;
boost::trim_if(trimmed,boost::algorithm::is_any_of("\",'\r\n"));
if (trimmed.empty()){
if (trimmed.empty())
{
++line_number;
continue;
#ifdef MAPNIK_DEBUG
std::clog << "CSV Plugin: empty row encountered at line: " << line_number << "\n";
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "csv_datasource: empty row encountered at line: " << line_number;
#endif
continue;
}
}
@ -524,7 +555,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
}
}
}
@ -548,7 +580,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
}
}
}
@ -585,7 +618,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
}
}
}
@ -618,7 +652,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
}
}
}
@ -711,7 +746,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
continue;
}
}
@ -744,7 +780,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
continue;
}
}
@ -795,7 +832,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
continue;
}
}
@ -810,7 +848,8 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << ex.what() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << ex.what() << "\n";
}
}
catch(const std::exception & ex)
@ -825,13 +864,15 @@ void csv_datasource::parse_csv(T& stream,
}
else
{
if (!quiet_) std::clog << s.str() << "\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << s.str() << "\n";
}
}
}
if (!feature_count > 0)
{
if (!quiet_) std::clog << "CSV Plugin: could not parse any lines of data\n";
// TODO - handle this with mapnik::log
if (!quiet_) std::cerr << "CSV Plugin: could not parse any lines of data\n";
}
}

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

@ -1,3 +1,25 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef MAPNIK_CSV_DATASOURCE_HPP
#define MAPNIK_CSV_DATASOURCE_HPP
@ -20,11 +42,13 @@ public:
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;
private:
mutable mapnik::layer_descriptor desc_;
mutable mapnik::box2d<double> extent_;
@ -44,5 +68,4 @@ private:
mutable mapnik::context_ptr ctx_;
};
#endif // MAPNIK_CSV_DATASOURCE_HPP

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

@ -25,8 +25,10 @@
#include "gdal_featureset.hpp"
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp>
#include <gdal_version.h>
@ -49,9 +51,8 @@ using mapnik::datasource_exception;
*/
inline GDALDataset* gdal_datasource::open_dataset() const
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: opening: " << dataset_name_ << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "gdal_datasource: Opening " << dataset_name_;
#endif
GDALDataset *dataset;
@ -81,8 +82,10 @@ gdal_datasource::gdal_datasource(parameters const& params, bool bind)
filter_factor_(*params_.get<double>("filter_factor", 0.0)),
nodata_value_(params_.get<double>("nodata"))
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Initializing..." << std::endl;
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "gdal_datasource: Initializing...";
#endif
GDALAllRegister();
@ -110,6 +113,10 @@ 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);
@ -124,8 +131,8 @@ void gdal_datasource::bind() const
boost::optional<std::string> bbox_s = params_.get<std::string>("bbox");
if (bbox_s)
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: bbox parameter=" << *bbox_s << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "gdal_datasource: BBox Parameter=" << *bbox_s;
#endif
bbox_override = extent_.from_string(*bbox_s);
@ -149,10 +156,13 @@ void gdal_datasource::bind() const
dataset->GetGeoTransform(tr);
}
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: geotransform=" << tr[0] << "," << tr[1] << ","
<< tr[2] << "," << tr[3] << ","
<< tr[4] << "," << tr[5] << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "gdal_datasource Geotransform=" << tr[0] << "," << tr[1] << ","
<< tr[2] << "," << tr[3] << ","
<< tr[4] << "," << tr[5];
}
#endif
// TODO - We should throw for true non-north up images, but the check
@ -188,9 +198,12 @@ void gdal_datasource::bind() const
GDALClose(dataset);
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Raster Size=" << width_ << "," << height_ << std::endl;
std::clog << "GDAL Plugin: Raster Extent=" << extent_ << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "gdal_datasource: Raster Size=" << width_ << "," << height_;
mapnik::log() << "gdal_datasource: Raster Extent=" << extent_;
}
#endif
is_bound_ = true;
@ -231,6 +244,10 @@ 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
gdal_query gq = q;
// TODO - move to boost::make_shared, but must reduce # of args to <= 9
@ -251,6 +268,10 @@ featureset_ptr gdal_datasource::features_at_point(coord2d const& pt) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "gdal_datasource::features_at_point");
#endif
gdal_query gq = pt;
// TODO - move to boost::make_shared, but must reduce # of args to <= 9

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

@ -46,6 +46,7 @@ public:
mapnik::layer_descriptor get_descriptor() const;
void bind() const;
private:
GDALDataset* open_dataset() const;
mutable mapnik::box2d<double> extent_;
std::string dataset_name_;
mutable int band_;
@ -58,8 +59,6 @@ private:
mutable bool shared_dataset_;
double filter_factor_;
boost::optional<double> nodata_value_;
inline GDALDataset* open_dataset() const;
};
#endif // GDAL_DATASOURCE_HPP

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

@ -22,14 +22,15 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/feature_factory.hpp>
#include "gdal_featureset.hpp"
#include <gdal_priv.h>
// boost
#include <boost/format.hpp>
#include "gdal_featureset.hpp"
#include <gdal_priv.h>
using mapnik::query;
using mapnik::coord2d;
using mapnik::box2d;
@ -75,8 +76,8 @@ gdal_featureset::gdal_featureset(GDALDataset& dataset,
gdal_featureset::~gdal_featureset()
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: closing dataset = " << &dataset_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Closing Dataset=" << &dataset_;
#endif
GDALClose(&dataset_);
@ -87,8 +88,9 @@ feature_ptr gdal_featureset::next()
if (first_)
{
first_ = false;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: featureset, dataset = " << &dataset_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Next feature in Dataset=" << &dataset_;
#endif
query *q = boost::get<query>(&gquery_);
@ -125,7 +127,9 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
double dx = tr[1];
double dy = tr[5];
std::clog << "dx_: " << dx_ << " dx: " << dx << " dy_: " << dy_ << "dy: " << dy << "\n";
#ifdef MAPNIK_DEBUG
mapnik::log() << "gdal_featureset: dx_=" << dx_ << " dx=" << dx << " dy_=" << dy_ << "dy=" << dy;
#endif
*/
CoordTransform t(raster_width_, raster_height_, raster_extent_, 0, 0);
@ -184,11 +188,11 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
box2d<double> feature_raster_extent(x_off, y_off, x_off + width, y_off + height);
intersect = t.backward(feature_raster_extent);
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Raster extent=" << raster_extent_ << std::endl;
std::clog << "GDAL Plugin: View extent=" << intersect << std::endl;
std::clog << "GDAL Plugin: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution()) << std::endl;
std::clog << boost::format("GDAL Plugin: StartX=%d StartY=%d Width=%d Height=%d") % x_off % y_off % width % height << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Raster extent=" << raster_extent_;
mapnik::log() << "gdal_featureset: View extent=" << intersect;
mapnik::log() << "gdal_featureset: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution());
mapnik::log() << boost::format("gdal_featureset: StartX=%d StartY=%d Width=%d Height=%d") % x_off % y_off % width % height;
#endif
if (width > 0 && height > 0)
@ -203,8 +207,9 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
{
im_width *= filter_factor_;
im_height *= filter_factor_;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: applying layer filter_factor: " << filter_factor_ << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Applying layer filter_factor=" << filter_factor_;
#endif
}
// otherwise respect symbolizer level factor applied to query, default of 1.0
@ -228,9 +233,9 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
mapnik::image_data_32 image(im_width, im_height);
image.set(0xffffffff);
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Image Size=(" << im_width << "," << im_height << ")" << std::endl;
std::clog << "GDAL Plugin: Reading band " << band_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Image Size=(" << im_width << "," << im_height << ")";
mapnik::log() << "gdal_featureset: Reading band=" << band_;
#endif
typedef std::vector<int,int> pallete;
@ -270,7 +275,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
{
GDALRasterBand * band = dataset_.GetRasterBand(i + 1);
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
get_overview_meta(band);
#endif
@ -279,68 +284,68 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
{
case GCI_RedBand:
red = band;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found red band" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found red band";
#endif
break;
case GCI_GreenBand:
green = band;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found green band" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found green band";
#endif
break;
case GCI_BlueBand:
blue = band;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found blue band" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found blue band";
#endif
break;
case GCI_AlphaBand:
alpha = band;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found alpha band" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found alpha band";
#endif
break;
case GCI_GrayIndex:
grey = band;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found gray band" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found gray band";
#endif
break;
case GCI_PaletteIndex:
{
grey = band;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found gray band, and colortable..." << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found gray band, and colortable...";
#endif
GDALColorTable *color_table = band->GetColorTable();
if (color_table)
{
int count = color_table->GetColorEntryCount();
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Color Table count = " << count << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Color Table count=" << count;
#endif
for (int j = 0; j < count; j++)
{
const GDALColorEntry *ce = color_table->GetColorEntry (j);
if (! ce) continue;
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Color entry RGB (" << ce->c1 << "," <<ce->c2 << "," << ce->c3 << ")" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Color entry RGB=" << ce->c1 << "," <<ce->c2 << "," << ce->c3;
#endif
}
}
break;
}
case GCI_Undefined:
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Found undefined band (assumming gray band)" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Found undefined band (assumming gray band)";
#endif
grey = band;
break;
default:
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: band type unknown!" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Band type unknown!";
#endif
break;
}
@ -348,8 +353,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
if (red && green && blue)
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: processing rgb bands..." << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Processing rgb bands...";
#endif
int hasNoData(0);
double nodata(0);
@ -401,8 +406,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
}
else if (grey)
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: processing gray band..." << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Processing gray band...";
#endif
int hasNoData(0);
double nodata(0);
@ -419,13 +424,10 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
if (hasNoData && ! color_table)
{
if (hasNoData)
{
feature->put("NODATA",nodata);
}
#ifdef MAPNIK_DEBUG
std::clog << "\tno data value for layer: " << nodata << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: No data value for layer=" << nodata;
#endif
feature->put("NODATA",nodata);
// first read the data in and create an alpha channel from the nodata values
float* imageData = (float*)image.getBytes();
grey->RasterIO(GF_Read, x_off, y_off, width, height,
@ -456,8 +458,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
if (color_table)
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Loading colour table..." << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: Loading colour table...";
#endif
unsigned nodata_value = static_cast<unsigned>(nodata);
if (hasNoData)
@ -496,8 +498,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
}
if (alpha)
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: processing alpha band..." << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "gdal_featureset: processing alpha band...";
#endif
alpha->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 3,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
@ -533,9 +535,9 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
if (x < raster_xsize && y < raster_ysize)
{
#ifdef MAPNIK_DEBUG
std::clog << boost::format("GDAL Plugin: pt.x=%f pt.y=%f") % pt.x % pt.y << std::endl;
std::clog << boost::format("GDAL Plugin: x=%f y=%f") % x % y << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << boost::format("gdal_featureset: pt.x=%f pt.y=%f") % pt.x % pt.y;
mapnik::log() << boost::format("gdal_featureset: x=%f y=%f") % x % y;
#endif
GDALRasterBand* band = dataset_.GetRasterBand(band_);
int hasNoData;
@ -558,24 +560,24 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
return feature_ptr();
}
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
void gdal_featureset::get_overview_meta(GDALRasterBand* band)
{
int band_overviews = band->GetOverviewCount();
if (band_overviews > 0)
{
std::clog << "GDAL Plugin: "<< band_overviews << " overviews found!" << std::endl;
mapnik::log() << "gdal_featureset: " << band_overviews << " overviews found!";
for (int b = 0; b < band_overviews; b++)
{
GDALRasterBand * overview = band->GetOverview(b);
std::clog << boost::format("GDAL Plugin: Overview=%d Width=%d Height=%d")
% b % overview->GetXSize() % overview->GetYSize() << std::endl;
mapnik::log() << boost::format("gdal_featureset: Overview=%d Width=%d Height=%d")
% b % overview->GetXSize() % overview->GetYSize();
}
}
else
{
std::clog << "GDAL Plugin: No overviews found!" << std::endl;
mapnik::log() << "gdal_featureset: No overviews found!";
}
int bsx,bsy;
@ -583,8 +585,8 @@ void gdal_featureset::get_overview_meta(GDALRasterBand* band)
band->GetBlockSize(&bsx, &bsy);
scale = band->GetScale();
std::clog << boost::format("GDAL Plugin: Block=%dx%d Scale=%f Type=%s Color=%s") % bsx % bsy % scale
mapnik::log() << boost::format("gdal_featureset: Block=%dx%d Scale=%f Type=%s Color=%s") % bsx % bsy % scale
% GDALGetDataTypeName(band->GetRasterDataType())
% GDALGetColorInterpretationName(band->GetColorInterpretation()) << std::endl;
% GDALGetColorInterpretationName(band->GetColorInterpretation());
}
#endif

2
plugins/input/gdal/gdal_featureset.hpp
View file

@ -55,7 +55,7 @@ public:
private:
mapnik::feature_ptr get_feature(mapnik::query const& q);
mapnik::feature_ptr get_feature_at_point(mapnik::coord2d const& p);
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
void get_overview_meta(GDALRasterBand * band);
#endif
GDALDataset & dataset_;

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

@ -30,8 +30,10 @@
#include <cstdarg>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp>
// boost
#include <boost/algorithm/string.hpp>
@ -63,8 +65,10 @@ DATASOURCE_PLUGIN(geos_datasource)
void geos_notice(const char* fmt, ...)
{
// TODO - handle with mapnik::log
va_list ap;
fprintf( stdout, "GEOS Plugin: (GEOS NOTICE) ");
fprintf( stdout, "Mapnik LOG> geos_datasource: (GEOS NOTICE) ");
va_start (ap, fmt);
vfprintf( stdout, fmt, ap);
@ -74,8 +78,10 @@ void geos_notice(const char* fmt, ...)
void geos_error(const char* fmt, ...)
{
// TODO - handle with mapnik::log
va_list ap;
fprintf( stdout, "GEOS Plugin: (GEOS ERROR) ");
fprintf( stdout, "Mapnik LOG> geos_datasource: (GEOS ERROR) ");
va_start (ap, fmt);
vfprintf( stdout, fmt, ap);
@ -94,6 +100,8 @@ geos_datasource::geos_datasource(parameters const& params, bool bind)
geometry_data_name_("name"),
geometry_id_(1)
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
boost::optional<std::string> geometry = params.get<std::string>("wkt");
if (! geometry) throw datasource_exception("missing <wkt> parameter");
geometry_string_ = *geometry;
@ -132,6 +140,10 @@ void geos_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::bind");
#endif
// open geos driver
initGEOS(geos_notice, geos_error);
@ -145,8 +157,12 @@ void geos_datasource::bind() const
// try to obtain the extent from the geometry itself
if (! extent_initialized_)
{
#ifdef MAPNIK_DEBUG
std::clog << "GEOS Plugin: initializing extent from geometry" << std::endl;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "geos_datasource::bind(initialize_extent)");
#endif
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "geos_datasource: Initializing extent from geometry";
#endif
if (GEOSGeomTypeId(*geometry_) == GEOS_POINT)
@ -168,10 +184,13 @@ void geos_datasource::bind() const
geos_feature_ptr envelope (GEOSEnvelope(*geometry_));
if (*envelope != NULL && GEOSisValid(*envelope))
{
#ifdef MAPNIK_DEBUG
char* wkt = GEOSGeomToWKT(*envelope);
std::clog << "GEOS Plugin: getting coord sequence from: " << wkt << std::endl;
GEOSFree(wkt);
#ifdef MAPNIK_LOG
if (log_enabled_)
{
char* wkt = GEOSGeomToWKT(*envelope);
mapnik::log() << "geos_datasource: Getting coord sequence from=" << wkt;
GEOSFree(wkt);
}
#endif
const GEOSGeometry* exterior = GEOSGetExteriorRing(*envelope);
@ -180,8 +199,8 @@ void geos_datasource::bind() const
const GEOSCoordSequence* cs = GEOSGeom_getCoordSeq(exterior);
if (cs != NULL)
{
#ifdef MAPNIK_DEBUG
std::clog << "GEOS Plugin: iterating boundary points" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "geos_datasource: Iterating boundary points";
#endif
double x, y;
@ -242,6 +261,10 @@ boost::optional<mapnik::datasource::geometry_t> geos_datasource::get_geometry_ty
if (! is_bound_) bind();
boost::optional<mapnik::datasource::geometry_t> result;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::get_geometry_type");
#endif
// get geometry type
const int type = GEOSGeomTypeId(*geometry_);
switch (type)
@ -280,6 +303,10 @@ 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
const mapnik::box2d<double> extent = q.get_bbox();
std::ostringstream s;
@ -291,8 +318,8 @@ featureset_ptr geos_datasource::features(query const& q) const
<< extent.minx() << " " << extent.miny()
<< "))";
#ifdef MAPNIK_DEBUG
std::clog << "GEOS Plugin: using extent: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "geos_datasource: Using extent=" << s.str();
#endif
return boost::make_shared<geos_featureset>(*geometry_,
@ -307,11 +334,15 @@ featureset_ptr geos_datasource::features_at_point(coord2d const& pt) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "geos_datasource::features_at_point");
#endif
std::ostringstream s;
s << "POINT(" << pt.x << " " << pt.y << ")";
#ifdef MAPNIK_DEBUG
std::clog << "GEOS Plugin: using point: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "geos_datasource: Using point=" << s.str();
#endif
return boost::make_shared<geos_featureset>(*geometry_,

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

@ -26,6 +26,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
@ -104,8 +105,8 @@ feature_ptr geos_featureset::next()
break;
default:
#ifdef MAPNIK_DEBUG
std::clog << "GEOS Plugin: unknown extent geometry_type=" << type << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "geos_featureset: Unknown extent geometry_type=" << type;
#endif
break;
}

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

@ -34,6 +34,7 @@
// mapnik
#include <mapnik/boolean.hpp>
#include <mapnik/debug.hpp>
// boost
#include <boost/algorithm/string.hpp>
@ -79,6 +80,8 @@ 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"))
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
boost::optional<std::string> host = params_.get<std::string>("host");
if (host)
{
@ -156,7 +159,9 @@ featureset_ptr kismet_datasource::features(query const& q) const
{
if (! is_bound_) bind();
// std::clog << "kismet_datasource::features()" << endl;
#ifdef MAPNIK_LOG
// mapnik::log() << "kismet_datasource::features()";
#endif
// TODO: use box2d to filter bbox before adding to featureset_ptr
// mapnik::box2d<double> const& e = q.get_bbox();
@ -174,15 +179,17 @@ featureset_ptr kismet_datasource::features_at_point(coord2d const& pt) const
{
if (! is_bound_) bind();
// std::clog << "kismet_datasource::features_at_point()" << endl;
#ifdef MAPNIK_LOG
// mapnik::log() << "kismet_datasource::features_at_point()";
#endif
return featureset_ptr();
}
void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
{
#ifdef MAPNIK_DEBUG
std::clog << "Kismet Plugin: enter run" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "kismet_datasource: Enter run";
#endif
int sockfd, n;
@ -219,7 +226,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
if (connect(sockfd, (struct sockaddr*) &sock_addr, sizeof(sock_addr)))
{
std::cerr << "KISMET Plugin: Error while connecting" << std::endl;
std::cerr << "Kismet Plugin: Error while connecting" << std::endl;
return;
}
@ -227,7 +234,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
if (write(sockfd, command.c_str(), command.length()) != (signed)command.length())
{
std::cerr << "KISMET Plugin: Error sending command to " << ip_host << std::endl;
std::cerr << "Kismet Plugin: Error sending command to " << ip_host << std::endl;
close(sockfd);
return;
@ -248,8 +255,8 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
buffer[n] = '\0';
std::string bufferObj(buffer); // TCP data send from kismet_server as STL string
#ifdef MAPNIK_DEBUG
std::clog << "Kismet Plugin: buffer_obj=" << bufferObj << "[END]" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "kismet_datasource: buffer_obj=" << bufferObj;
#endif
std::string::size_type found = 0;
@ -262,8 +269,8 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
{
kismet_line.assign(bufferObj, search_start, found - search_start);
#ifdef MAPNIK_DEBUG
std::clog << "Kismet Plugin: line=" << kismet_line << " [ENDL]" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "kismet_datasource: line=" << kismet_line;
#endif
int param_number = 5; // the number of parameters to parse
@ -277,9 +284,12 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
&bestlat,
&bestlon) == param_number)
{
#ifdef MAPNIK_DEBUG
std::clog << "Kismet Plugin: ssid=" << ssid << ", bssid=" << bssid
<< ", crypt=" << crypt << ", bestlat=" << bestlat << ", bestlon=" << bestlon << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "kismet_datasource: ssid=" << ssid << ", bssid=" << bssid
<< ", crypt=" << crypt << ", bestlat=" << bestlat << ", bestlon=" << bestlon;
}
#endif
kismet_network_data knd(ssid, bssid, bestlat, bestlon, crypt);
@ -312,8 +322,8 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
close(sockfd);
#ifdef MAPNIK_DEBUG
std::clog << "Kismet Plugin: exit run" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "kismet_datasource: Exit run";
#endif
}

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

@ -25,8 +25,10 @@
#include "occi_featureset.hpp"
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/timer.hpp>
// boost
#include <boost/algorithm/string.hpp>
@ -68,18 +70,21 @@ const std::string occi_datasource::METADATA_TABLE = "USER_SDO_GEOM_METADATA";
DATASOURCE_PLUGIN(occi_datasource)
occi_datasource::occi_datasource(parameters const& params, bool bind)
: datasource (params),
type_(datasource::Vector),
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")),
row_limit_(*params_.get<int>("row_limit", 0)),
row_prefetch_(*params_.get<int>("row_prefetch", 100)),
pool_(0),
conn_(0)
: datasource (params),
type_(datasource::Vector),
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)),
pool_(0),
conn_(0)
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
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");
@ -140,6 +145,10 @@ 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_)
{
@ -184,6 +193,10 @@ void occi_datasource::bind() const
// get SRID and/or GEOMETRY_FIELD from metadata table only if we need to
if (! srid_initialized_ || geometry_field_ == "")
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::get_srid_and_geometry_field");
#endif
std::ostringstream s;
s << "SELECT srid, column_name FROM " << METADATA_TABLE << " WHERE";
s << " LOWER(table_name) = LOWER('" << table_name_ << "')";
@ -193,8 +206,8 @@ void occi_datasource::bind() const
s << " AND LOWER(column_name) = LOWER('" << geometry_field_ << "')";
}
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
#endif
try
@ -226,11 +239,15 @@ void occi_datasource::bind() const
// get columns description
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::get_column_description");
#endif
std::ostringstream s;
s << "SELECT " << fields_ << " FROM (" << table_name_ << ") WHERE rownum < 1";
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
#endif
try
@ -321,16 +338,22 @@ void occi_datasource::bind() const
case oracle::occi::OCCI_SQLT_CLOB:
case oracle::occi::OCCI_SQLT_BLOB:
case oracle::occi::OCCI_SQLT_RSET:
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: unsupported datatype "
<< occi_enums::resolve_datatype(type_oid)
<< " (type_oid=" << type_oid << ")" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "occi_datasource: Unsupported datatype "
<< occi_enums::resolve_datatype(type_oid)
<< " (type_oid=" << type_oid << ")";
}
#endif
break;
default:
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: unknown datatype "
<< "(type_oid=" << type_oid << ")" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "occi_datasource: Unknown datatype "
<< "(type_oid=" << type_oid << ")";
}
#endif
break;
}
@ -368,13 +391,17 @@ box2d<double> occi_datasource::envelope() const
if (estimate_extent && *estimate_extent)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::envelope(estimate_extent)");
#endif
std::ostringstream s;
s << "SELECT MIN(c.x), MIN(c.y), MAX(c.x), MAX(c.y) FROM ";
s << " (SELECT SDO_AGGR_MBR(" << geometry_field_ << ") shape FROM " << table_ << ") a, ";
s << " TABLE(SDO_UTIL.GETVERTICES(a.shape)) c";
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
#endif
try
@ -397,7 +424,7 @@ box2d<double> occi_datasource::envelope() const
}
catch (bad_lexical_cast& ex)
{
std::clog << "OCCI Plugin: " << ex.what() << std::endl;
std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
}
}
}
@ -408,6 +435,10 @@ box2d<double> occi_datasource::envelope() const
}
else if (use_spatial_index_)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::envelope(use_spatial_index)");
#endif
std::ostringstream s;
s << "SELECT dim.sdo_lb, dim.sdo_ub FROM ";
s << METADATA_TABLE << " m, TABLE(m.diminfo) dim ";
@ -417,8 +448,8 @@ box2d<double> occi_datasource::envelope() const
s << METADATA_TABLE << " m, TABLE(m.diminfo) dim ";
s << " WHERE LOWER(m.table_name) = LOWER('" << table_name_ << "') AND dim.sdo_dimname = 'Y'";
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
#endif
try
@ -439,7 +470,7 @@ box2d<double> occi_datasource::envelope() const
}
catch (bad_lexical_cast& ex)
{
std::clog << "OCCI Plugin: " << ex.what() << std::endl;
std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
}
}
@ -452,7 +483,7 @@ box2d<double> occi_datasource::envelope() const
}
catch (bad_lexical_cast& ex)
{
std::clog << "OCCI Plugin: " << ex.what() << std::endl;
std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
}
}
@ -493,15 +524,27 @@ 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
box2d<double> const& box = q.get_bbox();
std::ostringstream s;
s << "SELECT " << geometry_field_;
s << "SELECT ";
if (use_wkb_)
{
s << "SDO_UTIL.TO_WKBGEOMETRY(" << geometry_field_ << ")";
}
else
{
s << geometry_field_;
}
std::set<std::string> const& props = q.property_names();
std::set<std::string>::const_iterator pos = props.begin();
std::set<std::string>::const_iterator end = props.end();
mapnik::context_ptr ctx = boost::make_shared<mapnik::context_type>();
for ( ;pos != end;++pos)
for (; pos != end; ++pos)
{
s << ", " << *pos;
ctx->push(*pos);
@ -532,8 +575,8 @@ featureset_ptr occi_datasource::features(query const& q) const
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: cannot determine where to add the spatial filter declaration" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: cannot determine where to add the spatial filter declaration";
#endif
}
}
@ -552,16 +595,16 @@ featureset_ptr occi_datasource::features(query const& q) const
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: cannot determine where to add the row limit declaration" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the row limit declaration";
#endif
}
}
s << query;
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
#endif
return boost::make_shared<occi_featureset>(pool_,
@ -570,6 +613,7 @@ featureset_ptr occi_datasource::features(query const& q) const
s.str(),
desc_.get_encoding(),
use_connection_pool_,
use_wkb_,
row_prefetch_);
}
@ -577,8 +621,20 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "occi_datasource::features_at_point");
#endif
std::ostringstream s;
s << "SELECT " << geometry_field_;
s << "SELECT ";
if (use_wkb_)
{
s << "SDO_UTIL.TO_WKBGEOMETRY(" << geometry_field_ << ")";
}
else
{
s << geometry_field_;
}
std::vector<attribute_descriptor>::const_iterator itr = desc_.get_descriptors().begin();
std::vector<attribute_descriptor>::const_iterator end = desc_.get_descriptors().end();
mapnik::context_ptr ctx = boost::make_shared<mapnik::context_type>();
@ -613,8 +669,8 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: cannot determine where to add the spatial filter declaration" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the spatial filter declaration";
#endif
}
}
@ -633,16 +689,16 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: cannot determine where to add the row limit declaration" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the row limit declaration";
#endif
}
}
s << query;
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
#endif
return boost::make_shared<occi_featureset>(pool_,
@ -651,5 +707,6 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
s.str(),
desc_.get_encoding(),
use_connection_pool_,
use_wkb_,
row_prefetch_);
}

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

@ -50,6 +50,8 @@ public:
void bind() const;
private:
static const std::string METADATA_TABLE;
mapnik::datasource::datasource_t type_;
mutable std::string table_;
mutable std::string table_name_;
@ -60,13 +62,13 @@ private:
mutable bool extent_initialized_;
mutable mapnik::box2d<double> extent_;
mutable mapnik::layer_descriptor desc_;
mutable bool use_wkb_;
int row_limit_;
int row_prefetch_;
mutable oracle::occi::StatelessConnectionPool* pool_;
mutable oracle::occi::Connection* conn_;
bool use_connection_pool_;
bool use_spatial_index_;
static const std::string METADATA_TABLE;
};
#endif // OCCI_DATASOURCE_HPP

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

@ -22,6 +22,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
@ -61,10 +62,12 @@ occi_featureset::occi_featureset(StatelessConnectionPool* pool,
std::string const& sqlstring,
std::string const& encoding,
bool use_connection_pool,
bool use_wkb,
unsigned prefetch_rows)
: tr_(new transcoder(encoding)),
feature_id_(1),
ctx_(ctx)
ctx_(ctx),
use_wkb_(use_wkb)
{
if (use_connection_pool)
{
@ -81,7 +84,7 @@ occi_featureset::occi_featureset(StatelessConnectionPool* pool,
}
catch (SQLException &ex)
{
std::clog << "OCCI Plugin: error processing " << sqlstring << " : " << ex.getMessage() << std::endl;
std::cerr << "OCCI Plugin: error processing " << sqlstring << " : " << ex.getMessage() << std::endl;
}
}
@ -96,10 +99,31 @@ feature_ptr occi_featureset::next()
feature_ptr feature(feature_factory::create(ctx_,feature_id_));
++feature_id_;
boost::scoped_ptr<SDOGeometry> geom(dynamic_cast<SDOGeometry*>(rs_->getObject(1)));
if (geom.get())
if (use_wkb_)
{
convert_geometry(geom.get(), feature);
Blob blob = rs_->getBlob (1);
blob.open(oracle::occi::OCCI_LOB_READONLY);
int size = blob.length();
if (buffer_.size() < size)
{
buffer_.resize(size);
}
oracle::occi::Stream* instream = blob.getStream(1,0);
instream->readBuffer(buffer_.data(), size);
blob.closeStream(instream);
blob.close();
geometry_utils::from_wkb(feature->paths(), buffer_.data(), size);
}
else
{
boost::scoped_ptr<SDOGeometry> geom(dynamic_cast<SDOGeometry*>(rs_->getObject(1)));
if (geom.get())
{
convert_geometry(geom.get(), feature);
}
}
std::vector<MetaData> listOfColumns = rs_->getColumnListMetaData();
@ -180,18 +204,22 @@ feature_ptr occi_featureset::next()
case oracle::occi::OCCI_SQLT_CLOB:
case oracle::occi::OCCI_SQLT_BLOB:
case oracle::occi::OCCI_SQLT_RSET:
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: unsupported datatype "
<< occi_enums::resolve_datatype(type_oid)
<< " (type_oid=" << type_oid << ")" << std::endl;
{
#ifdef MAPNIK_LOG
mapnik::log() << "occi_featureset: Unsupported datatype "
<< occi_enums::resolve_datatype(type_oid)
<< " (type_oid=" << type_oid << ")";
#endif
break;
break;
}
default: // shouldn't get here
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: unknown datatype "
<< "(type_oid=" << type_oid << ")" << std::endl;
{
#ifdef MAPNIK_LOG
mapnik::log() << "occi_featureset: Unknown datatype "
<< "(type_oid=" << type_oid << ")";
#endif
break;
break;
}
}
}
@ -209,20 +237,6 @@ void occi_featureset::convert_geometry(SDOGeometry* geom, feature_ptr feature)
int lrsvalue = (gtype - dimensions * 1000) / 100;
int geomtype = (gtype - dimensions * 1000 - lrsvalue * 100);
#if 0
std::clog << "-----------Geometry Object ------------" << std::endl;
std::clog << "SDO GTYPE = " << gtype << std::endl;
std::clog << "SDO DIMENSIONS = " << dimensions << std::endl;
std::clog << "SDO LRS = " << lrsvalue << std::endl;
std::clog << "SDO GEOMETRY TYPE = " << geomtype << std::endl;
Number sdo_srid = geom->getSdo_srid();
if (sdo_srid.isNull())
std::clog << "SDO SRID = " << "Null" << std::endl;
else
std::clog << "SDO SRID = " << (int)sdo_srid << std::endl;
#endif
const std::vector<Number>& elem_info = geom->getSdo_elem_info();
const std::vector<Number>& ordinates = geom->getSdo_ordinates();
const int ordinates_size = (int)ordinates.size();
@ -344,12 +358,14 @@ void occi_featureset::convert_geometry(SDOGeometry* geom, feature_ptr feature)
break;
case SDO_GTYPE_UNKNOWN:
default:
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: unknown <occi> "
<< occi_enums::resolve_gtype(geomtype)
<< "(gtype=" << gtype << ")" << std::endl;
{
#ifdef MAPNIK_LOG
mapnik::log() << "occi_featureset: Unknown oracle enum "
<< occi_enums::resolve_gtype(geomtype)
<< "(gtype=" << gtype << ")";
#endif
break;
}
break;
}
}

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

@ -35,6 +35,8 @@
// oci
#include "occi_types.hpp"
#include <vector>
class occi_featureset : public mapnik::Featureset
{
public:
@ -44,6 +46,7 @@ public:
std::string const& sqlstring,
std::string const& encoding,
bool use_connection_pool,
bool use_wkb,
unsigned prefetch_rows);
virtual ~occi_featureset();
mapnik::feature_ptr next();
@ -70,6 +73,8 @@ private:
const char* fidcolumn_;
mutable int feature_id_;
mapnik::context_ptr ctx_;
bool use_wkb_;
std::vector<char> buffer_;
};
#endif // OCCI_FEATURESET_HPP

9
plugins/input/occi/occi_types.hpp
View file

@ -24,6 +24,7 @@
#define OCCI_TYPES_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/utils.hpp>
// occi
@ -87,8 +88,8 @@ public:
{
if (env_ == 0)
{
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: occi_environment constructor" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "occi_environment: constructor";
#endif
const int mode = oracle::occi::Environment::OBJECT
@ -111,8 +112,8 @@ private:
{
if (env_)
{
#ifdef MAPNIK_DEBUG
std::clog << "OCCI Plugin: occi_environment destructor" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "occi_environment: destructor";
#endif
oracle::occi::Environment::terminateEnvironment(env_);

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

@ -22,6 +22,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp>
@ -68,10 +69,12 @@ void ogr_converter::convert_geometry(OGRGeometry* geom, feature_ptr feature)
case wkbNone:
case wkbUnknown:
default:
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unknown <ogr> geometry_type="
<< wkbFlatten(geom->getGeometryType()) << std::endl;
{
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_converter: unknown <ogr> geometry_type="
<< wkbFlatten(geom->getGeometryType());
#endif
}
break;
}
}

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

@ -33,8 +33,10 @@
#include <gdal_version.h>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp>
// boost
#include <boost/algorithm/string.hpp>
@ -63,6 +65,8 @@ ogr_datasource::ogr_datasource(parameters const& params, bool bind)
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
indexed_(false)
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
boost::optional<std::string> file = params.get<std::string>("file");
boost::optional<std::string> string = params.get<std::string>("string");
if (! file && ! string)
@ -108,6 +112,10 @@ 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();
@ -182,6 +190,10 @@ 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)");
#endif
layer_.layer_by_sql(dataset_, *layer_by_sql);
layer_name_ = layer_.layer_name();
}
@ -259,15 +271,23 @@ void ogr_datasource::bind() const
indexed_ = true;
index_file.close();
}
#ifdef MAPNIK_LOG
#if 0
// TODO - enable this warning once the ogrindex tool is a bit more stable/mature
else
{
std::clog << "### Notice: no ogrindex file found for " << dataset_name_
<< ", use the 'ogrindex' program to build an index for faster rendering"
<< std::endl;
if (log_enabled_)
{
mapnik::log() << "ogr_datasource: no ogrindex file found for " << dataset_name_
<< ", use the 'ogrindex' program to build an index for faster rendering";
}
}
#endif
#endif // MAPNIK_LOG
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "ogr_datasource::bind(get_column_description)");
#endif
// deal with attributes descriptions
OGRFeatureDefn* def = layer->GetLayerDefn();
@ -304,16 +324,16 @@ void ogr_datasource::bind() const
case OFTRealList:
case OFTStringList:
case OFTWideStringList: // deprecated !
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "ogr_datasource: Unhandled type_oid=" << type_oid;
#endif
break;
case OFTDate:
case OFTTime:
case OFTDateTime: // unhandled !
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "ogr_datasource: Unhandled type_oid=" << type_oid;
#endif
desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object));
break;
@ -350,7 +370,7 @@ boost::optional<mapnik::datasource::geometry_t> ogr_datasource::get_geometry_typ
#if GDAL_VERSION_NUM < 1800
switch (wkbFlatten(layer->GetLayerDefn()->GetGeomType()))
#else
switch (wkbFlatten(layer->GetGeomType()))
switch (wkbFlatten(layer->GetGeomType()))
#endif
{
case wkbPoint:
@ -464,6 +484,10 @@ 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
if (dataset_ && layer_.is_valid())
{
// First we validate query fields: https://github.com/mapnik/mapnik/issues/792
@ -511,6 +535,10 @@ featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
{
if (!is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "ogr_datasource::features_at_point");
#endif
if (dataset_ && layer_.is_valid())
{
std::vector<attribute_descriptor> const& desc_ar = desc_.get_descriptors();
@ -532,8 +560,7 @@ featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
*layer,
filter,
index_name_,
desc_.get_encoding()
));
desc_.get_encoding()));
}
else
{
@ -545,8 +572,7 @@ featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
*dataset_,
*layer,
point,
desc_.get_encoding()
));
desc_.get_encoding()));
}
}

27
plugins/input/ogr/ogr_featureset.cpp
View file

@ -22,6 +22,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
@ -102,11 +103,10 @@ feature_ptr ogr_featureset::next()
{
ogr_converter::convert_geometry(geom, feature);
}
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
else
{
std::clog << "OGR Plugin: feature with null geometry: "
<< (*feat)->GetFID() << std::endl;
mapnik::log() << "ogr_featureset: Feature with null geometry=" << (*feat)->GetFID();
}
#endif
++count_;
@ -145,16 +145,16 @@ feature_ptr ogr_featureset::next()
case OFTStringList:
case OFTWideStringList: // deprecated !
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
#endif
break;
}
case OFTBinary:
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
#endif
//feature->put(name,feat->GetFieldAsBinary (i, size));
break;
@ -164,16 +164,16 @@ feature_ptr ogr_featureset::next()
case OFTTime:
case OFTDateTime: // unhandled !
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
#endif
break;
}
default: // unknown
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unknown type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_featureset: Unknown type_oid=" << type_oid;
#endif
break;
}
@ -182,8 +182,9 @@ feature_ptr ogr_featureset::next()
return feature;
}
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: " << count_ << " features" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_featureset: " << count_ << " features";
#endif
return feature_ptr();
}

22
plugins/input/ogr/ogr_index_featureset.cpp
View file

@ -23,6 +23,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
@ -76,8 +77,8 @@ ogr_index_featureset<filterT>::ogr_index_featureset(mapnik::context_ptr const &
std::sort(ids_.begin(),ids_.end());
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: query size=" << ids_.size() << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_index_featureset: Query size=" << ids_.size();
#endif
itr_ = ids_.begin();
@ -110,10 +111,10 @@ feature_ptr ogr_index_featureset<filterT>::next()
{
ogr_converter::convert_geometry (geom, feature);
}
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
else
{
std::clog << "### Warning: feature with null geometry: " << (*feat)->GetFID() << "\n";
mapnik::log() << "ogr_index_featureset: Feature with null geometry=" << (*feat)->GetFID();
}
#endif
@ -151,16 +152,16 @@ feature_ptr ogr_index_featureset<filterT>::next()
case OFTStringList:
case OFTWideStringList: // deprecated !
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
#endif
break;
}
case OFTBinary:
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
#endif
//feature->put(name,feat->GetFieldAsBinary (i, size));
break;
@ -170,8 +171,8 @@ feature_ptr ogr_index_featureset<filterT>::next()
case OFTTime:
case OFTDateTime: // unhandled !
{
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
#endif
break;
}
@ -186,4 +187,3 @@ feature_ptr ogr_index_featureset<filterT>::next()
template class ogr_index_featureset<mapnik::filter_in_box>;
template class ogr_index_featureset<mapnik::filter_at_point>;

27
plugins/input/ogr/ogr_layer_ptr.hpp
View file

@ -23,6 +23,9 @@
#ifndef OGR_LAYER_PTR_HPP
#define OGR_LAYER_PTR_HPP
// mapnik
#include <mapnik/debug.hpp>
// stl
#include <iostream>
#include <fstream>
@ -75,12 +78,12 @@ public:
layer_ = ogr_layer;
is_valid_ = true;
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: layer_from_name layer is " << layer_name_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_layer_ptr: layer_from_name layer=" << layer_name_;
#endif
}
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
debug_print_last_error();
#endif
}
@ -102,13 +105,13 @@ public:
layer_name_ = def->GetName();
is_valid_ = true;
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: layer_from_index layer is " << layer_name_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_layer_ptr: layer_from_index layer=" << layer_name_;
#endif
}
}
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
debug_print_last_error();
#endif
}
@ -138,13 +141,13 @@ public:
layer_name_ = def->GetName();
is_valid_ = true;
#ifdef MAPNIK_DEBUG
std::clog << "OGR Plugin: layer_from_sql layer is " << layer_name_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "ogr_layer_ptr: layer_from_sql layer=" << layer_name_;
#endif
}
}
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
debug_print_last_error();
#endif
}
@ -166,7 +169,7 @@ public:
private:
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
void debug_print_last_error()
{
if (! is_valid_)
@ -174,11 +177,11 @@ private:
const std::string err = CPLGetLastErrorMsg();
if (err.size() == 0)
{
std::clog << "OGR Plugin: error getting layer" << std::endl;
mapnik::log() << "ogr_layer_ptr: Error getting layer";
}
else
{
std::clog << "OGR Plugin: " << err << std::endl;
mapnik::log() << "ogr_layer_ptr: " << err;
}
}
}

13
plugins/input/osm/dataset_deliverer.cpp
View file

@ -20,11 +20,18 @@
*
*****************************************************************************/
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
// boost
#include <boost/filesystem/operations.hpp>
// std
#include <sstream>
#include "dataset_deliverer.h"
#include "basiccurl.h"
#include <sstream>
osm_dataset * dataset_deliverer::dataset = NULL;
std::string dataset_deliverer::last_bbox = "";
@ -76,8 +83,8 @@ osm_dataset* dataset_deliverer::load_from_url(const string& url, const string& b
}
else if (bbox != last_bbox)
{
#ifdef MAPNIK_DEBUG
std::cerr << "Osm Plugin: BBOXES ARE DIFFERENT: " << last_bbox << "," << bbox << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset_deliverer: BBoxes are different=" << last_bbox << "," << bbox;
#endif
// Reload the dataset

38
plugins/input/osm/osm.cpp
View file

@ -24,6 +24,8 @@
#include "osmparser.h"
#include "basiccurl.h"
#include <mapnik/debug.hpp>
#include <libxml/parser.h>
#include <iostream>
#include <fstream>
@ -47,8 +49,8 @@ bool osm_dataset::load_from_url(const std::string& url,
{
if (parser == "libxml2")
{
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: osm_dataset::load_from_url url=" << url << " bbox=" << bbox << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: load_from_url url=" << url << ",bbox=" << bbox;
#endif
std::ostringstream str;
@ -57,8 +59,8 @@ bool osm_dataset::load_from_url(const std::string& url,
str << url << "?bbox=" << bbox;
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: FULL URL " << str.str() << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: Full url=" << str.str();
#endif
CURL_LOAD_DATA* resp = grab_http_response(str.str().c_str());
@ -69,8 +71,8 @@ bool osm_dataset::load_from_url(const std::string& url,
memcpy(blx, resp->data, resp->nbytes);
blx[resp->nbytes] = '\0';
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: CURL RESPONSE: " << blx << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: CURL Response=" << blx;
#endif
delete[] blx;
@ -88,36 +90,32 @@ osm_dataset::~osm_dataset()
void osm_dataset::clear()
{
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: osm_dataset::clear()" << std::endl;
std::clog << "Osm Plugin: deleting ways" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: Clear";
#endif
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: -- Deleting ways";
#endif
for (unsigned int count = 0; count < ways.size(); ++count)
{
delete ways[count];
ways[count] = NULL;
}
ways.clear();
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: deleting nodes" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: -- Deleting nodes";
#endif
for (unsigned int count = 0; count < nodes.size(); ++count)
{
delete nodes[count];
nodes[count] = NULL;
}
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: clearing ways/nodes" << std::endl;
#endif
ways.clear();
nodes.clear();
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: done" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "osm_dataset: Clear done";
#endif
}

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

@ -28,8 +28,10 @@
#include <set>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/geom_util.hpp>
#include <mapnik/query.hpp>
#include <mapnik/boolean.hpp>
// boost
#include <boost/make_shared.hpp>
@ -51,11 +53,13 @@ using mapnik::attribute_descriptor;
DATASOURCE_PLUGIN(osm_datasource)
osm_datasource::osm_datasource(const parameters& params, bool bind)
: datasource (params),
extent_(),
type_(datasource::Vector),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8"))
: datasource (params),
extent_(),
type_(datasource::Vector),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8"))
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
if (bind)
{
this->bind();
@ -77,9 +81,10 @@ void osm_datasource::bind() const
if (url != "" && bbox != "")
{
// if we supplied a url and a bounding box, load from the url
#ifdef MAPNIK_DEBUG
std::clog << "Osm Plugin: loading_from_url: url=" << url << " bbox=" << bbox << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "osm_datasource: loading_from_url url=" << url << ",bbox=" << bbox;
#endif
if ((osm_data_ = dataset_deliverer::load_from_url(url, bbox, parser)) == NULL)
{
throw datasource_exception("Error loading from URL");
@ -94,7 +99,9 @@ void osm_datasource::bind() const
s << "OSM Plugin: Error loading from file '" << osm_filename << "'";
throw datasource_exception(s.str());
}
} else {
}
else
{
throw datasource_exception("OSM Plugin: Neither 'file' nor 'url' and 'bbox' specified");
}

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

@ -43,21 +43,19 @@ public:
osm_datasource(const parameters& params, bool bind = true);
virtual ~osm_datasource();
mapnik::datasource::datasource_t type() const;
static std::string name();
featureset_ptr features(const query& q) const;
featureset_ptr features_at_point(coord2d const& pt) const;
box2d<double> envelope() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
layer_descriptor get_descriptor() const;
static std::string name();
void bind() const;
private:
mutable box2d<double> extent_;
mutable osm_dataset* osm_data_;
mapnik::datasource::datasource_t type_;
mutable layer_descriptor desc_;
// no copying
osm_datasource(const osm_datasource&);
osm_datasource& operator=(const osm_datasource&);
};
#endif // OSM_DATASOURCE_HPP

102
plugins/input/postgis/connection.hpp
View file

@ -20,10 +20,15 @@
*
*****************************************************************************/
#ifndef CONNECTION_HPP
#define CONNECTION_HPP
#ifndef POSTGIS_CONNECTION_HPP
#define POSTGIS_CONNECTION_HPP
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/timer.hpp>
// boost
#include <boost/make_shared.hpp>
// std
@ -38,14 +43,10 @@ extern "C" {
class Connection
{
private:
PGconn *conn_;
int cursorId;
bool closed_;
public:
Connection(std::string const& connection_str)
:cursorId(0),
closed_(false)
: cursorId(0),
closed_(false)
{
conn_ = PQconnectdb(connection_str.c_str());
if (PQstatus(conn_) != CONNECTION_OK)
@ -54,10 +55,10 @@ public:
s << "Postgis Plugin: ";
if (conn_ )
{
std::string msg = PQerrorMessage( conn_ );
if ( ! msg.empty() )
std::string msg = PQerrorMessage(conn_);
if (! msg.empty())
{
s << msg.substr( 0, msg.size() - 1 );
s << msg.substr(0, msg.size() - 1);
}
else
{
@ -69,39 +70,62 @@ public:
s << "unable to connect to postgres server";
}
s << "\n" << connection_str;
throw mapnik::datasource_exception( s.str() );
throw mapnik::datasource_exception(s.str());
}
}
~Connection()
{
if (! closed_)
{
PQfinish(conn_);
#ifdef MAPNIK_LOG
mapnik::log() << "postgis_connection: postgresql connection closed - " << conn_;
#endif
closed_ = true;
}
}
bool execute(const std::string& sql) const
{
PGresult *result = PQexec(conn_,sql.c_str());
bool ok=(result && (PQresultStatus(result) == PGRES_COMMAND_OK));
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, std::string("postgis_connection::execute ") + sql);
#endif
PGresult *result = PQexec(conn_, sql.c_str());
bool ok = (result && (PQresultStatus(result) == PGRES_COMMAND_OK));
PQclear(result);
return ok;
}
boost::shared_ptr<ResultSet> executeQuery(const std::string& sql,int type=0) const
boost::shared_ptr<ResultSet> executeQuery(const std::string& sql, int type = 0) const
{
PGresult *result=0;
if (type==1)
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, std::string("postgis_connection::execute_query ") + sql);
#endif
PGresult* result = 0;
if (type == 1)
{
result = PQexecParams(conn_,sql.c_str(),0,0,0,0,0,1);
result = PQexecParams(conn_,sql.c_str(), 0, 0, 0, 0, 0, 1);
}
else
{
result = PQexec(conn_,sql.c_str());
result = PQexec(conn_, sql.c_str());
}
if(!result || (PQresultStatus(result) != PGRES_TUPLES_OK))
if (! result || (PQresultStatus(result) != PGRES_TUPLES_OK))
{
std::ostringstream s;
s << "Postgis Plugin: PSQL error";
if (conn_ )
if (conn_)
{
std::string msg = PQerrorMessage( conn_ );
if ( ! msg.empty() )
std::string msg = PQerrorMessage(conn_);
if (! msg.empty())
{
s << ":\n" << msg.substr( 0, msg.size() - 1 );
s << ":\n" << msg.substr(0, msg.size() - 1);
}
s << "\nFull sql was: '" << sql << "'\n";
@ -110,9 +134,13 @@ public:
{
s << "unable to connect to database";
}
if (result)
{
PQclear(result);
throw mapnik::datasource_exception( s.str() );
}
throw mapnik::datasource_exception(s.str());
}
return boost::make_shared<ResultSet>(result);
@ -120,7 +148,7 @@ public:
std::string client_encoding() const
{
return PQparameterStatus(conn_,"client_encoding");
return PQparameterStatus(conn_, "client_encoding");
}
bool isOK() const
@ -130,11 +158,12 @@ public:
void close()
{
if (!closed_)
if (! closed_)
{
PQfinish(conn_);
#ifdef MAPNIK_DEBUG
std::clog << "PostGIS: datasource closed, also closing connection - " << conn_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "postgis_connection: datasource closed, also closing connection - " << conn_;
#endif
closed_ = true;
}
@ -147,17 +176,10 @@ public:
return s.str();
}
~Connection()
{
if (!closed_)
{
PQfinish(conn_);
#ifdef MAPNIK_DEBUG
std::clog << "PostGIS: postgresql connection closed - " << conn_ << std::endl;
#endif
closed_ = true;
}
}
private:
PGconn *conn_;
int cursorId;
bool closed_;
};
#endif //CONNECTION_HPP

19
plugins/input/postgis/connection_manager.hpp
View file

@ -20,23 +20,28 @@
*
*****************************************************************************/
#ifndef CONNECTION_MANAGER_HPP
#define CONNECTION_MANAGER_HPP
#ifndef POSTGIS_CONNECTION_MANAGER_HPP
#define POSTGIS_CONNECTION_MANAGER_HPP
#include <string>
#include <sstream>
#include "connection.hpp"
// mapnik
#include <mapnik/pool.hpp>
#include <mapnik/utils.hpp>
#include "connection.hpp"
// boost
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
#ifdef MAPNIK_THREADSAFE
#include <boost/thread/mutex.hpp>
//using boost::mutex;
#endif
// stl
#include <string>
#include <sstream>
using mapnik::Pool;
using mapnik::singleton;
using mapnik::CreateStatic;
@ -150,4 +155,4 @@ private:
ConnectionManager& operator=(const ConnectionManager);
};
#endif //CONNECTION_MANAGER_HPP
#endif // POSTGIS_CONNECTION_MANAGER_HPP

100
plugins/input/postgis/cursorresultset.hpp
View file

@ -1,33 +1,35 @@
#ifndef CURSORRESULTSET_HPP
#define CURSORRESULTSET_HPP
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef POSTGIS_CURSORRESULTSET_HPP
#define POSTGIS_CURSORRESULTSET_HPP
#include <mapnik/debug.hpp>
#include "connection.hpp"
#include "resultset.hpp"
class CursorResultSet : public IResultSet
{
private:
boost::shared_ptr<Connection> conn_;
std::string cursorName_;
boost::shared_ptr<ResultSet> rs_;
int fetch_size_;
bool is_closed_;
int *refCount_;
void getNextResultSet()
{
std::ostringstream s;
s << "FETCH FORWARD " << fetch_size_ << " FROM " << cursorName_;
#ifdef MAPNIK_DEBUG
std::clog << "Postgis Plugin: " << s.str() << std::endl;
#endif
rs_ = conn_->executeQuery(s.str());
is_closed_ = false;
#ifdef MAPNIK_DEBUG
std::clog << "Postgis Plugin: FETCH result (" << cursorName_ << "): " << rs_->size() << " rows" << std::endl;
#endif
}
public:
CursorResultSet(boost::shared_ptr<Connection> const &conn, std::string cursorName, int fetch_count)
: conn_(conn),
@ -50,6 +52,15 @@ public:
(*refCount_)++;
}
virtual ~CursorResultSet()
{
if (--(*refCount_)==0)
{
close();
delete refCount_,refCount_=0;
}
}
CursorResultSet& operator=(const CursorResultSet& rhs)
{
if (this==&rhs) return *this;
@ -73,25 +84,18 @@ public:
if (!is_closed_)
{
rs_.reset();
std::ostringstream s;
s << "CLOSE " << cursorName_;
#ifdef MAPNIK_DEBUG
std::clog << "Postgis Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "postgis_cursor_resultset: " << s.str();
#endif
conn_->execute(s.str());
is_closed_ = true;
}
}
virtual ~CursorResultSet()
{
if (--(*refCount_)==0)
{
close();
delete refCount_,refCount_=0;
}
}
virtual int getNumFields() const
{
return rs_->getNumFields();
@ -148,6 +152,30 @@ public:
{
return rs_->getValue(name);
}
private:
void getNextResultSet()
{
std::ostringstream s;
s << "FETCH FORWARD " << fetch_size_ << " FROM " << cursorName_;
#ifdef MAPNIK_LOG
mapnik::log() << "postgis_cursor_resultset: " << s.str();
#endif
rs_ = conn_->executeQuery(s.str());
is_closed_ = false;
#ifdef MAPNIK_LOG
mapnik::log() << "postgis_cursor_resultset: FETCH result (" << cursorName_ << "): " << rs_->size() << " rows";
#endif
}
boost::shared_ptr<Connection> conn_;
std::string cursorName_;
boost::shared_ptr<ResultSet> rs_;
int fetch_size_;
bool is_closed_;
int *refCount_;
};
#endif //CURSORRESULTSET_HPP
#endif // POSTGIS_CURSORRESULTSET_HPP

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

@ -25,10 +25,12 @@
#include "postgis_featureset.hpp"
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/global.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/util/conversions.hpp>
#include <mapnik/timer.hpp>
// boost
#include <boost/algorithm/string.hpp>
@ -79,8 +81,9 @@ postgis_datasource::postgis_datasource(parameters const& params, bool bind)
// 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))
//show_queries_(*params_.get<mapnik::boolean>("show_queries",false))
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
if (table_.empty())
{
throw mapnik::datasource_exception("Postgis Plugin: missing <table> parameter");
@ -105,6 +108,10 @@ void postgis_datasource::bind() const
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);
@ -148,6 +155,10 @@ void postgis_datasource::bind() const
geometryColumn_ = geometry_field_;
if (geometryColumn_.empty() || srid_ == 0)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_srid_and_geometry_column)");
#endif
std::ostringstream s;
s << "SELECT f_geometry_column, srid FROM "
<< GEOMETRY_COLUMNS <<" WHERE f_table_name='"
@ -168,13 +179,6 @@ void postgis_datasource::bind() const
<< "'";
}
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
}
*/
shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
if (rs->next())
{
@ -205,13 +209,6 @@ void postgis_datasource::bind() const
s << "SELECT ST_SRID(\"" << geometryColumn_ << "\") AS srid FROM "
<< populate_tokens(table_) << " WHERE \"" << geometryColumn_ << "\" IS NOT NULL LIMIT 1;";
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
}
*/
shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
if (rs->next())
{
@ -232,6 +229,10 @@ void postgis_datasource::bind() const
// detect primary key
if (*autodetect_key_field && key_field_.empty())
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_primary_key)");
#endif
std::ostringstream s;
s << "SELECT a.attname, a.attnum, t.typname, t.typname in ('int2','int4','int8') "
"AS is_int FROM pg_class c, pg_attribute a, pg_type t, pg_namespace n, pg_index i "
@ -267,9 +268,11 @@ void postgis_datasource::bind() const
{
key_field_ = std::string(key_field_string);
#ifdef MAPNIK_DEBUG
std::clog << "PostGIS Plugin: auto-detected key field of '"
<< key_field_ << "' on table '"
<< geometry_table_ << "'\n";
if (log_enabled_)
{
mapnik::log() << "postgis_datasource: auto-detected key field of '"
<< key_field_ << "' on table '" << geometry_table_ << "'";
}
#endif
}
}
@ -310,31 +313,29 @@ void postgis_datasource::bind() const
{
srid_ = -1;
#ifdef MAPNIK_DEBUG
std::clog << "Postgis Plugin: SRID warning, using srid=-1 for '" << table_ << "'" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "postgis_datasource: Table " << table_ << " is using SRID=-1";
#endif
}
// At this point the geometry_field may still not be known
// but we'll catch that where more useful...
#ifdef MAPNIK_DEBUG
std::clog << "Postgis Plugin: using SRID=" << srid_ << std::endl;
std::clog << "Postgis Plugin: using geometry_column=" << geometryColumn_ << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "postgis_datasource: Using SRID=" << srid_;
mapnik::log() << "postgis_datasource: Using geometry_column=" << geometryColumn_;
}
#endif
// collect attribute desc
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_column_description)");
#endif
std::ostringstream s;
s << "SELECT * FROM " << populate_tokens(table_) << " LIMIT 0";
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
}
*/
shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
int count = rs->getNumFields();
bool found_key_field = false;
@ -400,28 +401,24 @@ void postgis_datasource::bind() const
desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String));
break;
default: // should not get here
#ifdef MAPNIK_DEBUG
s.str("");
s << "SELECT oid, typname FROM pg_type WHERE oid = " << type_oid;
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
}
*/
shared_ptr<ResultSet> rs_oid = conn->executeQuery(s.str());
if (rs_oid->next())
#ifdef MAPNIK_LOG
if (log_enabled_)
{
std::clog << "Postgis Plugin: unknown type = " << rs_oid->getValue("typname")
<< " (oid:" << rs_oid->getValue("oid") << ")" << std::endl;
s.str("");
s << "SELECT oid, typname FROM pg_type WHERE oid = " << type_oid;
shared_ptr<ResultSet> rs_oid = conn->executeQuery(s.str());
if (rs_oid->next())
{
mapnik::log() << "postgis_datasource: Unknown type=" << rs_oid->getValue("typname")
<< " (oid:" << rs_oid->getValue("oid") << ")";
}
else
{
mapnik::log() << "postgis_datasource: Unknown type_oid=" << type_oid;
}
rs_oid->close();
}
else
{
std::clog << "Postgis Plugin: unknown oid type =" << type_oid << std::endl;
}
rs_oid->close();
#endif
break;
}
@ -435,6 +432,23 @@ void postgis_datasource::bind() const
}
}
postgis_datasource::~postgis_datasource()
{
if (is_bound_ && ! persist_connection_)
{
ConnectionManager* mgr = ConnectionManager::instance();
shared_ptr< Pool<Connection,ConnectionCreator> > pool = mgr->getPool(creator_.id());
if (pool)
{
shared_ptr<Connection> conn = pool->borrowObject();
if (conn)
{
conn->close();
}
}
}
}
std::string postgis_datasource::name()
{
return "postgis";
@ -547,13 +561,6 @@ boost::shared_ptr<IResultSet> postgis_datasource::get_resultset(boost::shared_pt
csql << "DECLARE " << cursor_name << " BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR " << sql << " FOR READ ONLY";
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % csql.str();
}
*/
if (! conn->execute(csql.str()))
{
// TODO - better error
@ -567,13 +574,6 @@ boost::shared_ptr<IResultSet> postgis_datasource::get_resultset(boost::shared_pt
{
// no cursor
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % sql;
}
*/
return conn->executeQuery(sql, 1);
}
}
@ -585,6 +585,10 @@ featureset_ptr postgis_datasource::features(const query& q) const
bind();
}
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "postgis_datasource::features");
#endif
box2d<double> const& box = q.get_bbox();
double scale_denom = q.scale_denominator();
@ -678,6 +682,10 @@ featureset_ptr postgis_datasource::features_at_point(coord2d const& pt) const
bind();
}
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "postgis_datasource::features_at_point");
#endif
ConnectionManager* mgr = ConnectionManager::instance();
shared_ptr< Pool<Connection,ConnectionCreator> > pool = mgr->getPool(creator_.id());
if (pool)
@ -836,13 +844,6 @@ box2d<double> postgis_datasource::envelope() const
}
}
/*
if (show_queries_)
{
std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
}
*/
shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
if (rs->next() && ! rs->isNull(0))
{
@ -857,7 +858,9 @@ box2d<double> postgis_datasource::envelope() const
}
else
{
std::clog << boost::format("Postgis Plugin: warning: could not determine extent from query: %s\n") % s.str() << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << boost::format("Mapnik LOG> postgis_datasource: Could not determine extent from query: %s") % s.str();
#endif
}
}
rs->close();
@ -990,20 +993,3 @@ boost::optional<mapnik::datasource::geometry_t> postgis_datasource::get_geometry
return result;
}
postgis_datasource::~postgis_datasource()
{
if (is_bound_ && ! persist_connection_)
{
ConnectionManager* mgr = ConnectionManager::instance();
shared_ptr< Pool<Connection,ConnectionCreator> > pool = mgr->getPool(creator_.id());
if (pool)
{
shared_ptr<Connection> conn = pool->borrowObject();
if (conn)
{
conn->close();
}
}
}
}

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

@ -20,8 +20,6 @@
*
*****************************************************************************/
//$Id: postgis.hpp 44 2005-04-22 18:53:54Z pavlenko $
#ifndef POSTGIS_DATASOURCE_HPP
#define POSTGIS_DATASOURCE_HPP
@ -67,12 +65,11 @@ private:
std::string populate_tokens(const std::string& sql) const;
static std::string unquote(const std::string& sql);
boost::shared_ptr<IResultSet> get_resultset(boost::shared_ptr<Connection> const &conn, std::string const& sql) const;
postgis_datasource(const postgis_datasource&);
postgis_datasource& operator=(const postgis_datasource&);
static const std::string GEOMETRY_COLUMNS;
static const std::string SPATIAL_REF_SYS;
static const double FMAX;
const std::string uri_;
const std::string username_;
const std::string password_;
@ -100,4 +97,4 @@ private:
//bool show_queries_;
};
#endif //POSTGIS_DATASOURCE_HPP
#endif // POSTGIS_DATASOURCE_HPP

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

@ -26,6 +26,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/wkb.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/sql_utils.hpp>
@ -197,8 +198,8 @@ feature_ptr postgis_featureset::next()
default:
{
#ifdef MAPNIK_DEBUG
std::clog << "Postgis Plugin: uknown OID = " << oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "postgis_featureset: Uknown type_oid=" << oid;
#endif
break;
}

6
plugins/input/postgis/resultset.hpp
View file

@ -20,8 +20,8 @@
*
*****************************************************************************/
#ifndef RESULTSET_HPP
#define RESULTSET_HPP
#ifndef POSTGIS_RESULTSET_HPP
#define POSTGIS_RESULTSET_HPP
extern "C" {
#include "libpq-fe.h"
@ -187,4 +187,4 @@ private:
int *refCount_;
};
#endif //RESULTSET_HPP
#endif // POSTGIS_RESULTSET_HPP

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

@ -26,7 +26,9 @@
#include <boost/make_shared.hpp>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/image_reader.hpp>
#include <mapnik/boolean.hpp>
#include "raster_featureset.hpp"
#include "raster_info.hpp"
@ -46,12 +48,14 @@ using mapnik::image_reader;
DATASOURCE_PLUGIN(raster_datasource)
raster_datasource::raster_datasource(const parameters& params, bool bind)
: datasource(params),
desc_(*params.get<std::string>("type"), "utf-8"),
extent_initialized_(false)
: datasource(params),
desc_(*params.get<std::string>("type"), "utf-8"),
extent_initialized_(false)
{
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: Initializing..." << std::endl;
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: Initializing...";
#endif
boost::optional<std::string> file = params.get<std::string>("file");
@ -148,8 +152,8 @@ void raster_datasource::bind() const
}
}
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: RASTER SIZE(" << width_ << "," << height_ << ")" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: Raster size=" << width_ << "," << height_;
#endif
is_bound_ = true;
@ -195,14 +199,14 @@ featureset_ptr raster_datasource::features(query const& q) const
const int width = int(ext.maxx() + 0.5) - int(ext.minx() + 0.5);
const int height = int(ext.maxy() + 0.5) - int(ext.miny() + 0.5);
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: BOX SIZE(" << width << " " << height << ")" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: Box size=" << width << "," << height;
#endif
if (multi_tiles_)
{
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: MULTI-TILED policy" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: Multi-Tiled policy";
#endif
tiled_multi_file_policy policy(filename_, format_, tile_size_, extent_, q.get_bbox(), width_, height_, tile_stride_);
@ -211,8 +215,8 @@ featureset_ptr raster_datasource::features(query const& q) const
}
else if (width * height > 512*512)
{
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: TILED policy" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: Tiled policy";
#endif
tiled_file_policy policy(filename_, format_, 256, extent_, q.get_bbox(), width_, height_);
@ -221,8 +225,8 @@ featureset_ptr raster_datasource::features(query const& q) const
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: SINGLE FILE" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: Single file";
#endif
raster_info info(filename_, format_, extent_, width_, height_);
@ -234,8 +238,8 @@ featureset_ptr raster_datasource::features(query const& q) const
featureset_ptr raster_datasource::features_at_point(coord2d const&) const
{
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: feature_at_point not supported for raster.input" << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "raster_datasource: feature_at_point not supported";
#endif
return featureset_ptr();

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

@ -40,7 +40,9 @@ public:
mapnik::box2d<double> envelope() const;
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_;
std::string filename_;
@ -52,9 +54,6 @@ private:
unsigned tile_stride_;
mutable unsigned width_;
mutable unsigned height_;
//no copying
raster_datasource(const raster_datasource&);
raster_datasource& operator=(const raster_datasource&);
};
#endif // RASTER_DATASOURCE_HPP

7
plugins/input/raster/raster_featureset.cpp
View file

@ -21,6 +21,7 @@
*****************************************************************************/
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/image_reader.hpp>
#include <mapnik/image_util.hpp>
#include <mapnik/feature_factory.hpp>
@ -69,9 +70,9 @@ feature_ptr raster_featureset<LookupPolicy>::next()
{
std::auto_ptr<image_reader> reader(mapnik::get_image_reader(curIter_->file(),curIter_->format()));
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: READER = " << curIter_->format() << " " << curIter_->file()
<< " size(" << curIter_->width() << "," << curIter_->height() << ")" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "raster_featureset: Reader=" << curIter_->format() << "," << curIter_->file()
<< ",size(" << curIter_->width() << "," << curIter_->height() << ")";
#endif
if (reader.get())

21
plugins/input/raster/raster_featureset.hpp
View file

@ -26,6 +26,9 @@
#include "raster_datasource.hpp"
#include "raster_info.hpp"
// mapnik
#include <mapnik/debug.hpp>
// stl
#include <vector>
@ -137,8 +140,8 @@ public:
double pixel_x = extent.width() / double(width);
double pixel_y = extent.height() / double(height);
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: PIXEL SIZE("<< pixel_x << "," << pixel_y << ")" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "tiled_file_policy: Raster Plugin PIXEL SIZE("<< pixel_x << "," << pixel_y << ")";
#endif
box2d<double> e = bbox.intersect(extent);
@ -160,8 +163,9 @@ public:
}
}
}
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: INFO SIZE=" << infos_.size() << " " << file << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "tiled_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file;
#endif
}
@ -223,8 +227,8 @@ public:
double pixel_x = extent.width() / double(width);
double pixel_y = extent.height() / double(height);
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: PIXEL SIZE("<< pixel_x << "," << pixel_y << ")" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "tiled_multi_file_policy: Raster Plugin PIXEL SIZE(" << pixel_x << "," << pixel_y << ")";
#endif
// intersection of query with extent => new query
@ -256,8 +260,9 @@ public:
}
}
}
#ifdef MAPNIK_DEBUG
std::clog << "Raster Plugin: INFO SIZE=" << infos_.size() << " " << file_pattern << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "tiled_multi_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file_pattern;
#endif
}

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

@ -29,6 +29,7 @@
#include <boost/make_shared.hpp>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp>
@ -45,7 +46,6 @@ using mapnik::layer_descriptor;
using mapnik::datasource_exception;
/*
* Opens a GDALDataset and returns a pointer to it.
* Caller is responsible for calling GDALClose on it
@ -74,8 +74,10 @@ rasterlite_datasource::rasterlite_datasource(parameters const& params, bool bind
: datasource(params),
desc_(*params.get<std::string>("type"),"utf-8")
{
#ifdef MAPNIK_DEBUG
std::clog << "Rasterlite Plugin: Initializing..." << std::endl;
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "rasterlite_datasource: Initializing...";
#endif
boost::optional<std::string> file = params.get<std::string>("file");
@ -118,40 +120,43 @@ void rasterlite_datasource::bind() const
extent_.init(x0,y0,x1,y1);
#ifdef MAPNIK_DEBUG
int srid, auth_srid;
const char *auth_name;
const char *ref_sys_name;
const char *proj4text;
int tile_count;
double pixel_x_size, pixel_y_size;
int levels = rasterliteGetLevels (dataset);
if (rasterliteGetSrid(dataset, &srid, &auth_name, &auth_srid, &ref_sys_name, &proj4text) != RASTERLITE_OK)
#ifdef MAPNIK_LOG
if (log_enabled_)
{
std::string error (rasterliteGetLastError(dataset));
int srid, auth_srid;
const char *auth_name;
const char *ref_sys_name;
const char *proj4text;
rasterliteClose (dataset);
int tile_count;
double pixel_x_size, pixel_y_size;
int levels = rasterliteGetLevels (dataset);
throw datasource_exception(error);
}
std::clog << "Rasterlite Plugin: Data Source=" << rasterliteGetTablePrefix(dataset) << std::endl;
std::clog << "Rasterlite Plugin: SRID=" << srid << std::endl;
std::clog << "Rasterlite Plugin: Authority=" << auth_name << std::endl;
std::clog << "Rasterlite Plugin: AuthSRID=" << auth_srid << std::endl;
std::clog << "Rasterlite Plugin: RefSys Name=" << ref_sys_name << std::endl;
std::clog << "Rasterlite Plugin: Proj4Text=" << proj4text << std::endl;
std::clog << "Rasterlite Plugin: Extent(" << x0 << "," << y0 << " " << x1 << "," << y1 << ")" << std::endl;
std::clog << "Rasterlite Plugin: Levels=" << levels << std::endl;
for (int i = 0; i < levels; i++)
{
if (rasterliteGetResolution(dataset, i, &pixel_x_size, &pixel_y_size, &tile_count) == RASTERLITE_OK)
if (rasterliteGetSrid(dataset, &srid, &auth_name, &auth_srid, &ref_sys_name, &proj4text) != RASTERLITE_OK)
{
std::clog << "Rasterlite Plugin: Level=" << i
<< " x=" << pixel_x_size << " y=" << pixel_y_size << " tiles=" << tile_count << std::endl;
std::string error (rasterliteGetLastError(dataset));
rasterliteClose (dataset);
throw datasource_exception(error);
}
mapnik::log() << "rasterlite_datasource: Data Source=" << rasterliteGetTablePrefix(dataset);
mapnik::log() << "rasterlite_datasource: SRID=" << srid;
mapnik::log() << "rasterlite_datasource: Authority=" << auth_name;
mapnik::log() << "rasterlite_datasource: AuthSRID=" << auth_srid;
mapnik::log() << "rasterlite_datasource: RefSys Name=" << ref_sys_name;
mapnik::log() << "rasterlite_datasource: Proj4Text=" << proj4text;
mapnik::log() << "rasterlite_datasource: Extent=" << x0 << "," << y0 << " " << x1 << "," << y1 << ")";
mapnik::log() << "rasterlite_datasource: Levels=" << levels;
for (int i = 0; i < levels; i++)
{
if (rasterliteGetResolution(dataset, i, &pixel_x_size, &pixel_y_size, &tile_count) == RASTERLITE_OK)
{
mapnik::log() << "rasterlite_datasource: Level=" << i
<< " x=" << pixel_x_size << " y=" << pixel_y_size << " tiles=" << tile_count;
}
}
}
#endif

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

@ -46,7 +46,8 @@ public:
void bind() const;
private:
inline void* open_dataset() const;
void* open_dataset() const;
mutable mapnik::box2d<double> extent_;
std::string dataset_name_;
std::string table_name_;

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

@ -23,6 +23,7 @@
#include "rasterlite_featureset.hpp"
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/image_util.hpp>
#include <mapnik/feature_factory.hpp>
@ -53,8 +54,8 @@ rasterlite_featureset::rasterlite_featureset(void* dataset, rasterlite_query q)
rasterlite_featureset::~rasterlite_featureset()
{
#ifdef MAPNIK_DEBUG
std::clog << "Rasterlite Plugin: closing dataset" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "rasterlite_featureset: Closing";
#endif
rasterliteClose(dataset_);
@ -86,8 +87,8 @@ feature_ptr rasterlite_featureset::next()
feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
{
#ifdef MAPNIK_DEBUG
std::clog << "Rasterlite Plugin: get_feature" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "rasterlite_featureset: Running get_feature";
#endif
feature_ptr feature(feature_factory::create(ctx_,1));
@ -104,14 +105,13 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
const double pixel_size = (intersect.width() >= intersect.height()) ?
(intersect.width() / (double) width) : (intersect.height() / (double) height);
#ifdef MAPNIK_DEBUG
std::clog << "Rasterlite Plugin: Raster extent=" << raster_extent << std::endl;
std::clog << "Rasterlite Plugin: View extent=" << q.get_bbox() << std::endl;
std::clog << "Rasterlite Plugin: Intersect extent=" << intersect << std::endl;
std::clog << "Rasterlite Plugin: Query resolution="
<< boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution()) << std::endl;
std::clog << "Rasterlite Plugin: Size=" << width << " " << height << std::endl;
std::clog << "Rasterlite Plugin: Pixel Size=" << pixel_size << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "rasterlite_featureset: Raster extent=" << raster_extent;
mapnik::log() << "rasterlite_featureset: View extent=" << q.get_bbox();
mapnik::log() << "rasterlite_featureset: Intersect extent=" << intersect;
mapnik::log() << "rasterlite_featureset: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution());
mapnik::log() << "rasterlite_featureset: Size=" << width << " " << height;
mapnik::log() << "rasterlite_featureset: Pixel Size=" << pixel_size;
#endif
if (width > 0 && height > 0)
@ -145,15 +145,13 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
free (raster);
#ifdef MAPNIK_DEBUG
std::clog << "Rasterlite Plugin: done" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "rasterlite_featureset: Done";
#endif
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "Rasterlite Plugin: error=" << rasterliteGetLastError (dataset_) << std::endl;
#endif
std::cerr << "Rasterlite Plugin: Error " << rasterliteGetLastError (dataset_) << std::endl;
}
}

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

@ -20,8 +20,9 @@
*
*****************************************************************************/
// mapnik
#include <mapnik/geom_util.hpp>
#include "shape_datasource.hpp"
#include "shape_featureset.hpp"
#include "shape_index_featureset.hpp"
// boost
#include <boost/version.hpp>
@ -30,15 +31,20 @@
#include <boost/filesystem/operations.hpp>
#include <boost/make_shared.hpp>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/global.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/util/conversions.hpp>
#include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp>
// stl
#include <iostream>
#include <fstream>
#include <stdexcept>
#include "shape_datasource.hpp"
#include "shape_featureset.hpp"
#include "shape_index_featureset.hpp"
DATASOURCE_PLUGIN(shape_datasource)
using mapnik::String;
@ -57,6 +63,8 @@ shape_datasource::shape_datasource(const parameters &params, bool bind)
row_limit_(*params_.get<int>("row_limit",0)),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
boost::optional<std::string> file = params.get<std::string>("file");
if (!file) throw datasource_exception("Shape Plugin: missing <file> parameter");
@ -78,6 +86,10 @@ 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");
@ -96,6 +108,10 @@ void shape_datasource::bind() const
try
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "shape_datasource::bind(get_column_description)");
#endif
boost::shared_ptr<shape_io> shape_ref = boost::make_shared<shape_io>(shape_name_);
init(*shape_ref);
for (int i=0;i<shape_ref->dbf().num_fields();++i)
@ -126,11 +142,11 @@ void shape_datasource::bind() const
break;
}
default:
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
// I - long
// G - ole
// + - autoincrement
std::clog << "Shape Plugin: unknown type " << fd.type_ << std::endl;
if (log_enabled_) mapnik::log() << "shape_datasource: Unknown type=" << fd.type_;
#endif
break;
}
@ -143,17 +159,17 @@ void shape_datasource::bind() const
}
catch (const datasource_exception& ex)
{
std::clog << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
std::cerr << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
throw;
}
catch (const std::exception& ex)
{
std::clog << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
std::cerr << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
throw;
}
catch (...) // exception: pipe_select_interrupter: Too many open files
{
std::clog << "Shape Plugin: error processing field attributes" << std::endl;
std::cerr << "Shape Plugin: error processing field attributes" << std::endl;
throw;
}
@ -162,8 +178,12 @@ void shape_datasource::bind() const
shape_datasource::~shape_datasource() {}
void shape_datasource::init(shape_io& shape) const
void shape_datasource::init(shape_io& shape) const
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::init");
#endif
//first read header from *.shp
int file_code=shape.shp().read_xdr_integer();
if (file_code!=9994)
@ -188,14 +208,17 @@ void shape_datasource::init(shape_io& shape) const
shape.shp().read_envelope(extent_);
#ifdef MAPNIK_DEBUG
double zmin = shape.shp().read_double();
double zmax = shape.shp().read_double();
double mmin = shape.shp().read_double();
double mmax = shape.shp().read_double();
#ifdef MAPNIK_LOG
if (log_enabled_)
{
double zmin = shape.shp().read_double();
double zmax = shape.shp().read_double();
double mmin = shape.shp().read_double();
double mmax = shape.shp().read_double();
std::clog << "Shape Plugin: Z min/max " << zmin << "," << zmax << std::endl;
std::clog << "Shape Plugin: M min/max " << mmin << "," << mmax << "\n";
mapnik::log() << "shape_datasource: Z min/max=" << zmin << "," << zmax;
mapnik::log() << "shape_datasource: M min/max=" << mmin << "," << mmax;
}
#else
shape.shp().skip(4*8);
#endif
@ -213,13 +236,19 @@ void shape_datasource::init(shape_io& shape) const
//}
//else
//{
// std::clog << "### Notice: no .index file found for " + shape_name_ + ".shp, use the 'shapeindex' program to build an index for faster rendering\n";
// #ifdef MAPNIK_LOG
// mapnik::log() << "shape_datasource: No .index file found for "
// << shape_name_ << ".shp, use the 'shapeindex' program to build an index for faster rendering";
// #endif
//}
#ifdef MAPNIK_DEBUG
std::clog << "Shape Plugin: extent=" << extent_ << std::endl;
std::clog << "Shape Plugin: file_length=" << file_length_ << std::endl;
std::clog << "Shape Plugin: shape_type=" << shape_type_ << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "shape_datasource: Extent=" << extent_;
mapnik::log() << "shape_datasource: File length=" << file_length_;
mapnik::log() << "shape_datasource: Shape type=" << shape_type_;
}
#endif
}
@ -244,6 +273,10 @@ 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
filter_in_box filter(q.get_bbox());
if (indexed_)
{
@ -272,6 +305,10 @@ featureset_ptr shape_datasource::features_at_point(coord2d const& pt) const
{
if (!is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::features_at_point");
#endif
filter_at_point filter(pt);
// collect all attribute names
std::vector<attribute_descriptor> const& desc_vector = desc_.get_descriptors();
@ -317,6 +354,10 @@ box2d<double> shape_datasource::envelope() const
boost::optional<mapnik::datasource::geometry_t> shape_datasource::get_geometry_type() const
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "shape_datasource::get_geometry_type");
#endif
boost::optional<mapnik::datasource::geometry_t> result;
switch (shape_type_)
{

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

@ -44,7 +44,6 @@ class shape_datasource : public datasource
public:
shape_datasource(const parameters &params, bool bind=true);
virtual ~shape_datasource();
datasource::datasource_t type() const;
static std::string name();
featureset_ptr features(const query& q) const;
@ -53,11 +52,10 @@ public:
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
layer_descriptor get_descriptor() const;
void bind() const;
private:
shape_datasource(const shape_datasource&);
shape_datasource& operator=(const shape_datasource&);
void init(shape_io& shape) const;
private:
datasource::datasource_t type_;
std::string shape_name_;
mutable boost::shared_ptr<shape_io> shape_;

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

@ -24,6 +24,7 @@
#include <iostream>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/feature_factory.hpp>
#include "shape_featureset.hpp"
@ -145,8 +146,8 @@ feature_ptr shape_featureset<filterT>::next()
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "Shape Plugin: total shapes read=" << count_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "shape_featureset: Total shapes read=" << count_;
#endif
return feature_ptr();
}
@ -247,7 +248,7 @@ feature_ptr shape_featureset<filterT>::next()
}
catch (...)
{
std::clog << "Shape Plugin: error processing attributes " << std::endl;
std::cerr << "Shape Plugin: error processing attributes " << std::endl;
}
}
@ -255,8 +256,8 @@ feature_ptr shape_featureset<filterT>::next()
}
else
{
#ifdef MAPNIK_DEBUG
std::clog << "Shape Plugin: total shapes read=" << count_ << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "shape_featureset: Total shapes read=" << count_;
#endif
return feature_ptr();
}

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

@ -24,6 +24,7 @@
#include <fstream>
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/feature_factory.hpp>
// boost
@ -66,8 +67,8 @@ shape_index_featureset<filterT>::shape_index_featureset(filterT const& filter,
std::sort(ids_.begin(), ids_.end());
#ifdef MAPNIK_DEBUG
std::clog << "Shape Plugin: query size=" << ids_.size() << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "shape_index_featureset: Query size=" << ids_.size();
#endif
itr_ = ids_.begin();
@ -202,8 +203,8 @@ feature_ptr shape_index_featureset<filterT>::next()
else
{
#ifdef MAPNIK_DEBUG
std::clog << "Shape Plugin: " << count_ << " features" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "shape_index_featureset: " << count_ << " features";
#endif
return feature_ptr();
}

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

@ -23,6 +23,7 @@
#include "shape_io.hpp"
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
// boost
@ -57,8 +58,8 @@ shape_io::shape_io(const std::string& shape_name, bool open_index)
}
catch (...)
{
#ifdef MAPNIK_DEBUG
std::clog << "Shape Plugin: warning - could not open index: '" + shape_name + INDEX + "'" << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "shape_io: Could not open index=" << shape_name << INDEX;
#endif
}
}

13
plugins/input/sqlite/sqlite_connection.hpp
View file

@ -29,7 +29,7 @@
// mapnik
#include <mapnik/datasource.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/timer.hpp>
// boost
#include <boost/shared_ptr.hpp>
@ -120,6 +120,9 @@ public:
boost::shared_ptr<sqlite_resultset> execute_query(const std::string& sql)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, std::string("sqlite_resultset::execute_query ") + sql);
#endif
sqlite3_stmt* stmt = 0;
const int rc = sqlite3_prepare_v2 (db_, sql.c_str(), -1, &stmt, 0);
@ -133,6 +136,10 @@ public:
void execute(const std::string& sql)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, std::string("sqlite_resultset::execute ") + sql);
#endif
const int rc = sqlite3_exec(db_, sql.c_str(), 0, 0, 0);
if (rc != SQLITE_OK)
{
@ -142,6 +149,10 @@ public:
int execute_with_code(const std::string& sql)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, std::string("sqlite_resultset::execute_with_code ") + sql);
#endif
const int rc = sqlite3_exec(db_, sql.c_str(), 0, 0, 0);
return rc;
}

81
plugins/input/sqlite/sqlite_datasource.cpp
View file

@ -26,9 +26,11 @@
#include "sqlite_utils.hpp"
// mapnik
#include <mapnik/debug.hpp>
#include <mapnik/boolean.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/util/geometry_to_ds_type.hpp>
#include <mapnik/timer.hpp>
#include <mapnik/wkb.hpp>
// boost
@ -51,23 +53,25 @@ using mapnik::parameters;
DATASOURCE_PLUGIN(sqlite_datasource)
sqlite_datasource::sqlite_datasource(parameters const& params, bool bind)
: datasource(params),
extent_(),
extent_initialized_(false),
type_(datasource::Vector),
table_(*params_.get<std::string>("table", "")),
fields_(*params_.get<std::string>("fields", "*")),
metadata_(*params_.get<std::string>("metadata", "")),
geometry_table_(*params_.get<std::string>("geometry_table", "")),
geometry_field_(*params_.get<std::string>("geometry_field", "")),
index_table_(*params_.get<std::string>("index_table", "")),
key_field_(*params_.get<std::string>("key_field", "")),
row_offset_(*params_.get<int>("row_offset", 0)),
row_limit_(*params_.get<int>("row_limit", 0)),
intersects_token_("!intersects!"),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
format_(mapnik::wkbAuto)
: datasource(params),
extent_(),
extent_initialized_(false),
type_(datasource::Vector),
table_(*params_.get<std::string>("table", "")),
fields_(*params_.get<std::string>("fields", "*")),
metadata_(*params_.get<std::string>("metadata", "")),
geometry_table_(*params_.get<std::string>("geometry_table", "")),
geometry_field_(*params_.get<std::string>("geometry_field", "")),
index_table_(*params_.get<std::string>("index_table", "")),
key_field_(*params_.get<std::string>("key_field", "")),
row_offset_(*params_.get<int>("row_offset", 0)),
row_limit_(*params_.get<int>("row_limit", 0)),
intersects_token_("!intersects!"),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
format_(mapnik::wkbAuto)
{
log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
/* TODO
- throw if no primary key but spatial index is present?
- remove auto-indexing
@ -87,6 +91,10 @@ void sqlite_datasource::bind() const
{
if (is_bound_) return;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::bind");
#endif
boost::optional<std::string> file = params_.get<std::string>("file");
if (! file) throw datasource_exception("Sqlite Plugin: missing <file> parameter");
@ -209,8 +217,8 @@ void sqlite_datasource::bind() const
for (std::vector<std::string>::const_iterator iter = init_statements_.begin();
iter != init_statements_.end(); ++iter)
{
#ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: Execute init sql: " << *iter << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "sqlite_datasource: Execute init sql=" << *iter;
#endif
dataset_->execute(*iter);
}
@ -283,6 +291,10 @@ void sqlite_datasource::bind() const
has_spatial_index_ = false;
if (use_spatial_index_)
{
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats2__(std::clog, "sqlite_datasource::bind(use_spatial_index)");
#endif
if (boost::filesystem::exists(index_db))
{
dataset_->execute("attach database '" + index_db + "' as " + index_table_);
@ -315,8 +327,6 @@ void sqlite_datasource::bind() const
dataset_->execute("attach database '" + index_db + "' as " + index_table_);
}
}
*/
boost::shared_ptr<sqlite_resultset> rs = dataset_->execute_query(query.str());
if (sqlite_utils::create_spatial_index(index_db,index_table_,rs))
@ -343,7 +353,6 @@ void sqlite_datasource::bind() const
if (! extent_initialized_)
{
// TODO - clean this up - reducing arguments
std::string query = populate_tokens(table_);
if (!sqlite_utils::detect_extent(dataset_,
@ -487,8 +496,12 @@ box2d<double> sqlite_datasource::envelope() const
boost::optional<mapnik::datasource::geometry_t> sqlite_datasource::get_geometry_type() const
{
if (! is_bound_) bind();
boost::optional<mapnik::datasource::geometry_t> result;
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::get_geometry_type");
#endif
boost::optional<mapnik::datasource::geometry_t> result;
if (dataset_)
{
// finally, get geometry type by querying first feature
@ -542,6 +555,10 @@ featureset_ptr sqlite_datasource::features(query const& q) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::features");
#endif
if (dataset_)
{
mapnik::box2d<double> const& e = q.get_bbox();
@ -579,7 +596,8 @@ featureset_ptr sqlite_datasource::features(query const& q) const
key_field_,
index_table_,
geometry_table_,
intersects_token_); }
intersects_token_);
}
else
{
query = populate_tokens(table_);
@ -597,9 +615,12 @@ featureset_ptr sqlite_datasource::features(query const& q) const
s << " OFFSET " << row_offset_;
}
#ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: table: " << table_ << "\n\n";
std::clog << "Sqlite Plugin: query: " << s.str() << "\n\n";
#ifdef MAPNIK_LOG
if (log_enabled_)
{
mapnik::log() << "sqlite_datasource: Table=" << table_;
mapnik::log() << "sqlite_datasource: Query=" << s.str();
}
#endif
boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
@ -618,6 +639,10 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
{
if (! is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::features_at_point");
#endif
if (dataset_)
{
// TODO - need tolerance
@ -678,8 +703,8 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
s << " OFFSET " << row_offset_;
}
#ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: " << s.str() << std::endl;
#ifdef MAPNIK_LOG
if (log_enabled_) mapnik::log() << "sqlite_datasource: " << s.str();
#endif
boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));

10
plugins/input/sqlite/sqlite_datasource.hpp
View file

@ -52,11 +52,14 @@ public:
void bind() const;
private:
// Fill init_statements with any statements
// needed to attach auxillary databases
void parse_attachdb(std::string const& attachdb) const;
std::string populate_tokens(const std::string& sql) const;
// FIXME: remove mutable qualifier from data members
// by factoring out bind() logic out from
// datasource impl !!!
mutable mapnik::box2d<double> extent_;
mutable bool extent_initialized_;
mapnik::datasource::datasource_t type_;
@ -79,11 +82,6 @@ private:
mutable bool has_spatial_index_;
mutable bool using_subquery_;
mutable std::vector<std::string> init_statements_;
// Fill init_statements with any statements
// needed to attach auxillary databases
void parse_attachdb(std::string const& attachdb) const;
std::string populate_tokens(const std::string& sql) const;
};
#endif // MAPNIK_SQLITE_DATASOURCE_HPP

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

@ -22,6 +22,7 @@
// mapnik
#include <mapnik/global.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp>
@ -124,9 +125,8 @@ feature_ptr sqlite_featureset::next()
break;
default:
#ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: field " << fld_name_str
<< " unhandled type_oid=" << type_oid << std::endl;
#ifdef MAPNIK_LOG
mapnik::log() << "sqlite_featureset: Field=" << fld_name_str << " unhandled type_oid=" << type_oid;
#endif
break;
}

30
src/agg/agg_renderer.cpp
View file

@ -76,7 +76,7 @@
#include <boost/math/special_functions/round.hpp>
// stl
#ifdef MAPNIK_DEBUG
#ifdef MAPNIK_LOG
#include <iostream>
#endif
@ -174,8 +174,9 @@ void agg_renderer<T>::setup(Map const &m)
}
}
}
#ifdef MAPNIK_DEBUG
std::clog << "scale=" << m.scale() << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "agg_renderer: Scale=" << m.scale();
#endif
}
@ -185,9 +186,8 @@ agg_renderer<T>::~agg_renderer() {}
template <typename T>
void agg_renderer<T>::start_map_processing(Map const& map)
{
#ifdef MAPNIK_DEBUG
std::clog << "start map processing bbox="
<< map.get_current_extent() << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "agg_renderer: Start map processing bbox=" << map.get_current_extent();
#endif
ras_ptr->clip_box(0,0,width_,height_);
}
@ -195,18 +195,18 @@ void agg_renderer<T>::start_map_processing(Map const& map)
template <typename T>
void agg_renderer<T>::end_map_processing(Map const& )
{
#ifdef MAPNIK_DEBUG
std::clog << "end map processing\n";
#ifdef MAPNIK_LOG
mapnik::log() << "agg_renderer: End map processing";
#endif
}
template <typename T>
void agg_renderer<T>::start_layer_processing(layer const& lay, box2d<double> const& query_extent)
{
#ifdef MAPNIK_DEBUG
std::clog << "start layer processing : " << lay.name() << "\n";
std::clog << "datasource = " << lay.datasource().get() << "\n";
std::clog << "query_extent = " << query_extent << "\n";
#ifdef MAPNIK_LOG
mapnik::log() << "agg_renderer: Start processing layer=" << lay.name();
mapnik::log() << "agg_renderer: -- datasource=" << lay.datasource().get();
mapnik::log() << "agg_renderer: -- query_extent=" << query_extent;
#endif
if (lay.clear_label_cache())
{
@ -218,8 +218,8 @@ void agg_renderer<T>::start_layer_processing(layer const& lay, box2d<double> con
template <typename T>
void agg_renderer<T>::end_layer_processing(layer const&)
{
#ifdef MAPNIK_DEBUG
std::clog << "end layer processing\n";
#ifdef MAPNIK_LOG
mapnik::log() << "agg_renderer: End layer processing";
#endif
}
@ -258,8 +258,6 @@ void agg_renderer<T>::render_marker(pixel_position const& pos, marker const& mar
(*marker.get_vector_data())->attributes());
svg_renderer.render(*ras_ptr, sl, renb, mtx, opacity, bbox);
}
else
{

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