Skip to content

A python module to create static map images with markers, geodesic lines, etc.

License

Notifications You must be signed in to change notification settings

lowtower/py-staticmaps

 
 

Repository files navigation

CI PyPI Package Format License MIT

py-staticmaps

A python module to create static map images (PNG, SVG) with markers, geodesic lines, etc.

Features

  • Map objects: pin-style markers, image (PNG) markers, polylines, polygons, (geodesic) circles
  • Automatic computation of best center + zoom from the added map objects
  • Several pre-configured map tile providers
  • Proper tile provider attributions display
  • On-disc caching of map tile images for faster drawing and reduced load on the tile servers
  • Non-anti-aliased drawing via PILLOW
  • Anti-aliased drawing via pycairo (optional; only if pycairo is installed properly)
  • SVG creation via svgwrite
  • optional tightening of the map to object or custom boundaries
    • SVG only
    • tiles are being "cropped" to given boundaries
    • might lead to reduction of image quality

Installation

SVG + non-anti-aliased PNG version

pip install py-staticmaps

SVG + anti-aliased PNG version (via Cairo)

pip install py-staticmaps[cairo]

py-staticmaps uses pycairo for creating anti-aliased raster-graphics, so make sure libcairo2 is installed on your system (on Ubuntu just install the libcairo2-dev package, i.e. sudo apt install libcairo2-dev).

Examples

Note: PNG support (e.g. context.render_cairo(...)) is only available if the pycairo module is installed.

Markers and Geodesic Lines

import staticmaps

context = staticmaps.Context()
context.set_tile_provider(staticmaps.tile_provider_StamenToner)

frankfurt = staticmaps.create_latlng(50.110644, 8.682092)
newyork = staticmaps.create_latlng(40.712728, -74.006015)

context.add_object(staticmaps.Line([frankfurt, newyork], color=staticmaps.BLUE, width=4))
context.add_object(staticmaps.Marker(frankfurt, color=staticmaps.GREEN, size=12))
context.add_object(staticmaps.Marker(newyork, color=staticmaps.RED, size=12))

# render non-anti-aliased png
image = context.render_pillow(800, 500)
image.save("frankfurt_newyork.pillow.png")

# render anti-aliased png (this only works if pycairo is installed)
if staticmaps.cairo_is_supported():
    image = context.render_cairo(800, 500)
    image.write_to_png("frankfurt_newyork.cairo.png")

# render svg
svg_image = context.render_svg(800, 500)
with open("frankfurt_newyork.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

# render svg - tight boundaries
context.set_tighten_to_bounds(True)
svg_image = context.render_svg(800, 500)
with open("frankfurt_newyork.tight.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

context2 = staticmaps.Context()
context2.set_tile_provider(staticmaps.tile_provider_StamenToner)
context2.add_object(staticmaps.Bounds([frankfurt, newyork]))

# render svg
svg_image = context2.render_svg(800, 500)
with open("frankfurt_newyork.bounds.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

# render svg - tight boundaries
context2.set_tighten_to_bounds(True)
svg_image = context2.render_svg(800, 500)
with open("frankfurt_newyork.bounds.tight.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

Cairo example

frankfurt_newyork

SVG example

frankfurt_newyork_svg

SVG tight example

frankfurt_newyork_svg_tight

SVG custom bounds example

frankfurt_newyork_bounds_svg

SVG custom bounds tight example

frankfurt_newyork_bounds_svg_tight

Transparent Polygons

import staticmaps

context = staticmaps.Context()
context.set_tile_provider(staticmaps.tile_provider_OSM)

freiburg_polygon = [
    (47.96881, 7.79045),
    (47.96866, 7.78610),
    (47.97134, 7.77874),
    ...
]

context.add_object(
    staticmaps.Area(
        [staticmaps.create_latlng(lat, lng) for lat, lng in freiburg_polygon],
        fill_color=staticmaps.parse_color("#00FF003F"),
        width=2,
        color=staticmaps.BLUE,
    )
)

# render non-anti-aliased png
image = context.render_pillow(800, 500)
image.save("freiburg_area.pillow.png")

# render anti-aliased png (this only works if pycairo is installed)
image = context.render_cairo(800, 500)
image.write_to_png("freiburg_area.cairo.png")

# render svg
svg_image = context.render_svg(800, 500)
with open("freiburg_area.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

Cairo example

freiburg_area

SVG tight example

freiburg_area_svg_tight

Drawing a GPX Track + Image Marker (PNG)

import sys

import gpxpy
import staticmaps

context = staticmaps.Context()
context.set_tile_provider(staticmaps.tile_provider_ArcGISWorldImagery)

with open(sys.argv[1], "r") as file:
    gpx = gpxpy.parse(file)

for track in gpx.tracks:
    for segment in track.segments:
        line = [staticmaps.create_latlng(p.latitude, p.longitude) for p in segment.points]
        context.add_object(staticmaps.Line(line))

for p in gpx.walk(only_points=True):
    pos = staticmaps.create_latlng(p.latitude, p.longitude)
    marker = staticmaps.ImageMarker(pos, "start.png", origin_x=27, origin_y=35)
    context.add_object(marker)
    break

# render png via pillow
image = context.render_pillow(800, 500)
image.save("draw_gpx.pillow.png")

# render png via cairo
if staticmaps.cairo_is_supported():
    image = context.render_cairo(800, 500)
    image.write_to_png("draw_gpx.cairo.png")

# render svg
svg_image = context.render_svg(800, 500)
with open("draw_gpx.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

# render svg - tight boundaries
context.set_tighten_to_bounds(True)
svg_image = context.render_svg(800, 500)
with open("draw_gpx.tight.svg", "w", encoding="utf-8") as f:
    svg_image.write(f, pretty=True)

Cairo example

draw_gpx

SVG tight example

draw_gpx_svg_tight

US State Capitals

import json
import requests
import staticmaps

context = staticmaps.Context()
context.set_tile_provider(staticmaps.tile_provider_OSM)

URL = (
    "https://gist.githubusercontent.com/jpriebe/d62a45e29f24e843c974/"
    "raw/b1d3066d245e742018bce56e41788ac7afa60e29/us_state_capitals.json"
)
response = requests.get(URL)
for _, data in json.loads(response.text).items():
    capital = staticmaps.create_latlng(float(data["lat"]), float(data["long"]))
    context.add_object(staticmaps.Marker(capital, size=5))

# render non-anti-aliased png
image = context.render_pillow(800, 500)
image.save("us_capitals.pillow.png")

# render anti-aliased png (this only works if pycairo is installed)
image = context.render_cairo(800, 500)
image.write_to_png("us_capitals.cairo.png")

Cairo example

us_capitals

SVG tight example

us_capitals_svg_tight

Geodesic Circles

import staticmaps

context = staticmaps.Context()
context.set_tile_provider(staticmaps.tile_provider_StamenToner)

center1 = staticmaps.create_latlng(66, 0)
center2 = staticmaps.create_latlng(0, 0)

context.add_object(staticmaps.Circle(center1, 2000, fill_color=staticmaps.TRANSPARENT, color=staticmaps.RED, width=2))
context.add_object(staticmaps.Circle(center2, 2000, fill_color=staticmaps.TRANSPARENT, color=staticmaps.GREEN, width=2))
context.add_object(staticmaps.Marker(center1, color=staticmaps.RED))
context.add_object(staticmaps.Marker(center2, color=staticmaps.GREEN))

# render non-anti-aliased png
image = context.render_pillow(800, 500)
image.save("geodesic_circles.pillow.png")

# render anti-aliased png (this only works if pycairo is installed)
image = context.render_cairo(800, 600)
image.write_to_png("geodesic_circles.cairo.png")

Cairo example

geodesic_circles

Pillow example

geodesic_circles_pillow

SVG example

geodesic_circles_svg

SVG tight example

geodesic_circles_svg_tight

Other Examples

Please take a look at the command line program which uses the staticmaps package: staticmaps/cli.py

Dependencies

py-staticmaps uses

  • PILLOW for rendering raster-graphics
  • pycairo for rendering antialiased raster-graphics (optional!)
  • svgwrite for writing SVG files
  • s2sphere for geo coordinates handling
  • geographiclib for geodesic computations
  • appdirs for finding the user's default cache directory
  • requests for downloading tile files

License

MIT © 2020-2021 Florian Pigorsch

About

A python module to create static map images with markers, geodesic lines, etc.

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages

  • Python 96.7%
  • Makefile 3.3%