- build now osm plugin automatic if libxml2 is used
- moved osm/Makefile to osm/Makefile.example because if name collision
-> better move the example to another directory later
- optional CAIRO support
- changed libxml2 switch comment
transcode strings in filter expressions (default to utf8 input)
-- we can use map definition *.xml to define encoding
-- and in case of Python from
# -*- coding: utf-8 -*-
utf8 encoded filters are working now.
Add new find_point_placements to cover the gap left.
Change shield symbolizer to use find_point_placements.
Results are the same as before, but with much less duplicate code.
Slightly changes the result of max_char_angle_delta as now character angles aren't strict against the line angles.
Example screenshots on mailing list! :)
Spacing and no spacing line rendering are done by the same function.
Code is cleaner, performance should be equal or improved.
Text displacement is "Different", better in some cases and worse in others, I can revert it if wanted.
Old non spacing code is not yet removed as it is used by ShieldSymbolizer which I haven't investigated yet.
Individual character placement still has issues, that is my next task to fix!
1. The first allows the user to add a <FileSource
name="foo">/home/bar/baz/</FileSource> to the beginning of the file
and then in any of the symbolisers you can say:
<FooSymboliser base="foo" name="bridge">
It it will refer to the file /home/bar/baz/bridge.
2. The second allows you to create Datasource templates at the top
level, which can be used later in the actual layers like so:
<Map>
<Datasource name="db">
<Paramaeter name="host">/tmp</Parameter>
</Datasource>
<Layer name="lay">
<Datasource base="db">
<Parameter name="table">points</Parameter>
</Datasource>
</Layer>
</Map>
And the host parameter will be used in the layer.
3. The third adds the "base" parameter to the raster and shape input
plugins. All it does is specify a path to prefix to the filename prior
to using it. Together with the above feature it allows things like:
<Map>
<Datasource name="shapes">
<Paramaeter name="base">/home/foo/shapes</Parameter>
</Datasource>
<Layer name="lay">
<Datasource base="shapes">
<Parameter name="file">places</Parameter>
</Datasource>
</Layer>
</Map>
And it will use the shapefile /home/foo/shapes/places
Example:
>>> from mapnik import *
>>> im = Image(200,200)
>> save_to_file('test.png',im) # Guess image type from file extension
>> save_to_file('test.png,'jpeg',im) # Explicitly save as JPEG
2. PostGIS plug-in - optional 'multiple_geometries' parameter to control how Multi* geometries built.
3. MarkersSymbolizer (work in progress) to render vector shapes (markers) alonh a path with collision detection.
- libxml2 support
- strict error handling while parsing XML map files
- implemented save_map()
- removed some duplicate defaults
- all symbolizers with icons share a common base class now
(FIXME : label_spacing is still, too slow!!)
2. Re-use some agg objects.
3. placement_finder cleanups!
4. Added support for 'building_symbolizer' - extruded polygons
+ raster and gdal input isn't tested. Not working currently...
+ *-input.so plugins created. Change loader in source or link plugin to correct place
+ use pkg-config uninstalled feature
-> define project root to PKG_CONFIG_PATH to use mapnik without installation
+ added various library checks
+ don't install fonts
+ don't use included AGG
-> check for a installed libagg
+ Added Makefile for c++ demo
+ don't build any python wrapper stuff
-> this follows if all other building works
+ added Anjuta file
-> not needed to build anything, but helps much if you use Anjuta
Shield symbolizer is now a subclass of text symbolizer.
Some small improvements to text rendering.
Fixed up placement finder for horizontal placement.
Cleaned up placement finder.
2. Pass resolution to bbox query
3. Use variant<int,double,string> as parameter value e.g in Python:
ds = Raster(file="/path/to/file",lox = 12312.4,.....)
Added extractor facility to work with mapnik::parameter (C++):
mapnik::parameters params;
params["parameter0"] = 123.456;
params["parameter1"] = "123.456"; // initialize with string extract double later
boost::optional<double> val0 = params.get<double>("parameter0");
if (val0)
{
std::cout << *val0;
}
// with default value. NOTE: there is no 'parameter2' in params
boost::optional<double> val2 = params.get<double>("parameter2",654.321);
std::cout << * val2;
//
4. Added Gdal factory method in __init__.py
ds = Gdal(file="/tmp/file.tiff")
>>> for f in m.query_point([ layer.name for layer in m.layers ].index('world'),51,0):
... print f
...
feature (
f_code:FA001
fac_id:193
id:3147
na2:UK
na3:E
nam:ENGLAND
tile_id:10
)
>>>
fs = m.query_map_point(x,y) # Map (screen) coordinates
for feature in fs:
print feature
TODO: provide interface to feature in Python, at the moment only __str__ implemented which dumps attributes
fixed 'for' loops to work correctly when geom->num_points() < 2
always use prefix increment even for built-in types (good practice!)
e.g ++i
2. agg_renderer.cpp
check for number points in geometries when
applying text/shield_symbolizer.
to be rendered. This allows for a large extent (larger than can be
rendered into a single image in memory) to be rendered out as tiles.
Since the full extent is used for the placement calculations text
crossing tile boundaries will be consistent.
This method is a little inefficient when a large number of labels need
placed, an improved method would be to cache these placements between
tiles, but the attached is a start.
c++ users should simple call the render method with a start X and Y
coordinate specified,
for (int TileX = 0;TileX < 5;++TileX)
{
for(int TileY = 0;TileY < 5; ++TileY)
{
int TileSize=250;
int StartX = TileX*TileSize;
int StartY = TileY*TileSize;
Image32 buf(TileSize,TileSize);
agg_renderer<Image32> ren(m,buf,StartX,StartY);
ren.apply();
char name[324];
sprintf(name,"tile_%d_%d.png",TileX,TileY);
ImageUtils::save_to_file(name,"png",buf);
}
}
python users should call render_tile_to_file
for y in range(tile_count_y):
for x in range(tile_count_x):
if not os.path.exists("tiles/%d/%d/" % (map_scale, y)):
os.makedirs("tiles/%d/%d/" % (map_scale, y))
render_tile_to_file(m, x*tile_size, y*tile_size, tile_size, tile_size,
'tiles/%d/%d/%d.png' % (map_scale,y,x), 'png')
bool hit_test(double x, double y, double tol);
2. added image_view(unsigned x, unsigned y, unsigned width, unsigned height)
allowing to select region from image data e.g (in Python):
im = Image(2048,2048)
view = im.view(0,0,256,256)
save_to_file(filename,type, view)
3. changed envelope method to return vy value in datasource classes
4. features_at_point impl for shape and postgis plug-ins
angle changes too much between characters it finds an alternate
placement), this is specified in the max_char_angle_delta property in
radians (feel free to change it to degrees).
It also improves the text placement around corners trying to minimise
the distance between the center of the character and the line on each
side. This is the major portion of the patch.
rendering them as labels when using the text or shield symbolisers
(blame my horrible datasets)
* correctly recognise the Postgis "text" data type (it was in
postgisfs.cpp just not postgis.cpp) - my initial workaround to the
above was "SELECT trim(from label) AS label ..." which failed
miserably because it returned a text data type.
Thanks to Robert Coup for the patch!
Map and Layer objects both have a new parameter 'srs', initialized to "+proj=latlong +datum=WGS84" by default.
Basic usage (Python):
p = Projection("+proj=merc +datum=WGS84")
point = p.forward(Coord(-2,51))
...
2.reflected arithmetic operators for Envelope/Coord into Python
3.altered return policies for python objects
4.modified build system to require proj4 lib and headers
