watercolourmap 0.1.0__tar.gz

watercolourmap-0.1.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Eriola Trungu Impersimi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The fonts in src/watercolourmap/fonts are third-party and keep their own
+licences: Lora (SIL Open Font License 1.1, see Lora-OFL.txt) and FreeSerif
+(GNU GPL with font exception, see FreeSerif-LICENSE.txt).

watercolourmap-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: watercolourmap
+Version: 0.1.0
+Summary: Watercolour maps in Python, inspired by John Nelson's watercolour style for ArcGIS Pro
+Author: Eriola Trungu Impersimi
+License-Expression: MIT
+Project-URL: Homepage, https://etymo.co.uk/cartography/
+Keywords: cartography,maps,watercolour,watercolor,geopandas,land cover,urban atlas,copernicus
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: src/watercolourmap/fonts/FreeSerif-LICENSE.txt
+License-File: src/watercolourmap/fonts/Lora-OFL.txt
+Requires-Dist: geopandas>=1.0
+Requires-Dist: pyogrio>=0.9
+Requires-Dist: shapely>=2.0
+Requires-Dist: rasterio>=1.3
+Requires-Dist: scipy>=1.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: matplotlib>=3.8
+Dynamic: license-file
+
+# watercolourmap
+
+Watercolour maps in Python. Polygons are painted as soft washes on textured paper, with uneven pigment, darker edges and a thin line of bare paper between neighbouring shapes.
+
+It's inspired by John Nelson's [watercolour style for ArcGIS Pro](https://www.esri.com/arcgis-blog/products/arcgis-pro/mapping/steal-this-watercolor-style-for-pro-please), recreated in code so it works with any GeoDataFrame. You can see example prints at [etymo.co.uk/cartography](https://etymo.co.uk/cartography/).
+
+## Install
+
+```bash
+pip install watercolourmap
+```
+
+## Paint any polygons
+
+```python
+import geopandas as gpd
+import matplotlib.pyplot as plt
+from watercolourmap import paint_gdf, PAPER
+
+gdf = gpd.read_file("my_area.gpkg")
+gdf = gdf.to_crs(gdf.estimate_utm_crs())          # needs a CRS in metres
+
+img, extent = paint_gdf(
+    gdf, "landuse",
+    {"residential": "#c9a27e", "park": "#7a9a5a", "water": "#5f86b0"},
+)
+
+fig, ax = plt.subplots(figsize=(8, 8), facecolor=PAPER)
+ax.imshow(img, extent=extent)
+ax.set_axis_off()
+fig.savefig("map.png", dpi=300, facecolor=PAPER)
+```
+
+- Polygons whose value isn't in the colour dictionary are left as bare paper.
+- `pixel_size` sets the resolution in metres per pixel. By default the longer side is about 3,000 pixels.
+- `seed` changes the brushwork.
+
+## Print posters from Copernicus Urban Atlas
+
+The command line tool turns a [Copernicus Urban Atlas](https://land.copernicus.eu/en/products/urban-atlas) city file into a print-ready poster. You get a title, the painted map, a legend painted with the same brush, a scale bar and the data credit, saved as PDF and PNG.
+
+```bash
+# An irregular circle, 1.8 km radius, with place labels
+watercolourmap ELBASAN.fgb --center 20.097 41.106 --radius 1.8 \
+    --title "Elbasan Land Cover" \
+    --label "Kalaja|20.080|41.1125" --label "Lumi Shkumbin|20.0975|41.1006|-4" \
+    --paper A2 --out elbasan
+
+# A 12 km rectangle with a hand-torn edge, and the sea painted in
+watercolourmap ATHINA.fgb --center 23.688 37.958 --width 12 --sea \
+    --title "Athens Land Cover" --paper A2 --out athens
+```
+
+Run `watercolourmap --help` for every option: `--bbox` or `--clip` for other areas, `--signature` and `--website` to sign your map, and `--dpi 100` for quick drafts.
+
+Urban Atlas codes are grouped into seven classes: Blue, Green, Green-Grey and Grey Cover, Land Use Changing, Unknown and Other Natural. Roads and railways are left as bare paper. Urban Atlas maps land use rather than land cover, so some groupings are judgement calls. For example, marinas are coded as sports and leisure. You can see the full mapping in `urban_atlas_class()`.
+
+Keep the credit on your maps. The tool adds it by default: *Contains modified Copernicus Land Monitoring Service information (Urban Atlas 2021) © European Union*.
+
+## Building blocks
+
+| Function | What it does |
+|---|---|
+| `paint_gdf(gdf, column, colours)` | Paints any polygons and returns an image and its extent |
+| `poster(gdf, legend, out, ...)` | Lays out a full poster from polygons with integer classes |
+| `paint(classes, colours, pixel_size)` | Paints a raster of class ids |
+| `irregular_circle(gdf, centre, radius)` | Keeps whole parcels inside a circle, for a ragged, parcel-shaped edge |
+| `read_urban_atlas(path, bbox)` | Reads an Urban Atlas file and adds the legend class |
+| `IGNITION` | The default seven-class legend and colours |
+
+## Credits
+
+- **Watercolour style:** inspired by John Nelson (Esri).
+- **Legend:** from the University of Manchester IGNITION project land cover map.
+- **Fonts:** Lora (SIL Open Font License) and FreeSerif (GPL with font exception) are bundled.
+
+MIT licence © 2026 Eriola Trungu Impersimi

watercolourmap-0.1.0/README.md

@@ -0,0 +1,77 @@
+# watercolourmap
+
+Watercolour maps in Python. Polygons are painted as soft washes on textured paper, with uneven pigment, darker edges and a thin line of bare paper between neighbouring shapes.
+
+It's inspired by John Nelson's [watercolour style for ArcGIS Pro](https://www.esri.com/arcgis-blog/products/arcgis-pro/mapping/steal-this-watercolor-style-for-pro-please), recreated in code so it works with any GeoDataFrame. You can see example prints at [etymo.co.uk/cartography](https://etymo.co.uk/cartography/).
+
+## Install
+
+```bash
+pip install watercolourmap
+```
+
+## Paint any polygons
+
+```python
+import geopandas as gpd
+import matplotlib.pyplot as plt
+from watercolourmap import paint_gdf, PAPER
+
+gdf = gpd.read_file("my_area.gpkg")
+gdf = gdf.to_crs(gdf.estimate_utm_crs())          # needs a CRS in metres
+
+img, extent = paint_gdf(
+    gdf, "landuse",
+    {"residential": "#c9a27e", "park": "#7a9a5a", "water": "#5f86b0"},
+)
+
+fig, ax = plt.subplots(figsize=(8, 8), facecolor=PAPER)
+ax.imshow(img, extent=extent)
+ax.set_axis_off()
+fig.savefig("map.png", dpi=300, facecolor=PAPER)
+```
+
+- Polygons whose value isn't in the colour dictionary are left as bare paper.
+- `pixel_size` sets the resolution in metres per pixel. By default the longer side is about 3,000 pixels.
+- `seed` changes the brushwork.
+
+## Print posters from Copernicus Urban Atlas
+
+The command line tool turns a [Copernicus Urban Atlas](https://land.copernicus.eu/en/products/urban-atlas) city file into a print-ready poster. You get a title, the painted map, a legend painted with the same brush, a scale bar and the data credit, saved as PDF and PNG.
+
+```bash
+# An irregular circle, 1.8 km radius, with place labels
+watercolourmap ELBASAN.fgb --center 20.097 41.106 --radius 1.8 \
+    --title "Elbasan Land Cover" \
+    --label "Kalaja|20.080|41.1125" --label "Lumi Shkumbin|20.0975|41.1006|-4" \
+    --paper A2 --out elbasan
+
+# A 12 km rectangle with a hand-torn edge, and the sea painted in
+watercolourmap ATHINA.fgb --center 23.688 37.958 --width 12 --sea \
+    --title "Athens Land Cover" --paper A2 --out athens
+```
+
+Run `watercolourmap --help` for every option: `--bbox` or `--clip` for other areas, `--signature` and `--website` to sign your map, and `--dpi 100` for quick drafts.
+
+Urban Atlas codes are grouped into seven classes: Blue, Green, Green-Grey and Grey Cover, Land Use Changing, Unknown and Other Natural. Roads and railways are left as bare paper. Urban Atlas maps land use rather than land cover, so some groupings are judgement calls. For example, marinas are coded as sports and leisure. You can see the full mapping in `urban_atlas_class()`.
+
+Keep the credit on your maps. The tool adds it by default: *Contains modified Copernicus Land Monitoring Service information (Urban Atlas 2021) © European Union*.
+
+## Building blocks
+
+| Function | What it does |
+|---|---|
+| `paint_gdf(gdf, column, colours)` | Paints any polygons and returns an image and its extent |
+| `poster(gdf, legend, out, ...)` | Lays out a full poster from polygons with integer classes |
+| `paint(classes, colours, pixel_size)` | Paints a raster of class ids |
+| `irregular_circle(gdf, centre, radius)` | Keeps whole parcels inside a circle, for a ragged, parcel-shaped edge |
+| `read_urban_atlas(path, bbox)` | Reads an Urban Atlas file and adds the legend class |
+| `IGNITION` | The default seven-class legend and colours |
+
+## Credits
+
+- **Watercolour style:** inspired by John Nelson (Esri).
+- **Legend:** from the University of Manchester IGNITION project land cover map.
+- **Fonts:** Lora (SIL Open Font License) and FreeSerif (GPL with font exception) are bundled.
+
+MIT licence © 2026 Eriola Trungu Impersimi

watercolourmap-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "watercolourmap"
+version = "0.1.0"
+description = "Watercolour maps in Python, inspired by John Nelson's watercolour style for ArcGIS Pro"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Eriola Trungu Impersimi" }]
+license = "MIT"
+license-files = ["LICENSE", "src/watercolourmap/fonts/*.txt"]
+keywords = ["cartography", "maps", "watercolour", "watercolor", "geopandas", "land cover", "urban atlas", "copernicus"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: GIS",
+    "Topic :: Multimedia :: Graphics",
+    "Intended Audience :: Science/Research",
+]
+dependencies = [
+    "geopandas>=1.0",
+    "pyogrio>=0.9",
+    "shapely>=2.0",
+    "rasterio>=1.3",
+    "scipy>=1.11",
+    "numpy>=1.26",
+    "matplotlib>=3.8",
+]
+
+[project.urls]
+Homepage = "https://etymo.co.uk/cartography/"
+
+[project.scripts]
+watercolourmap = "watercolourmap.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+watercolourmap = ["fonts/*"]

watercolourmap-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

watercolourmap-0.1.0/src/watercolourmap/__init__.py

@@ -0,0 +1,23 @@
+"""watercolourmap: watercolour maps in Python, inspired by John Nelson's watercolour style for ArcGIS Pro.
+
+Quick use with any polygons:
+
+    import geopandas as gpd, matplotlib.pyplot as plt
+    from watercolourmap import paint_gdf
+
+    gdf = gpd.read_file("parks_and_water.gpkg")
+    gdf = gdf.to_crs(gdf.estimate_utm_crs())
+    img, extent = paint_gdf(gdf, "type", {"park": "#6b9954", "water": "#6b8cbd"})
+    plt.imshow(img, extent=extent); plt.axis("off"); plt.savefig("map.png", dpi=300)
+
+Print posters from Copernicus Urban Atlas files: see `watercolourmap --help`.
+"""
+from .brush import paint, swatch, deckle, PAPER
+from .legends import IGNITION, URBAN_ATLAS_CREDIT, urban_atlas_class, read_urban_atlas
+from .poster import paint_gdf, poster, map_box_aspect
+from .shapes import local_crs, irregular_circle, rectangle, wobbly_circle
+
+__version__ = "0.1.0"
+__all__ = ["paint", "swatch", "deckle", "PAPER", "IGNITION", "URBAN_ATLAS_CREDIT",
+           "urban_atlas_class", "read_urban_atlas", "paint_gdf", "poster", "map_box_aspect",
+           "local_crs", "irregular_circle", "rectangle", "wobbly_circle"]

watercolourmap-0.1.0/src/watercolourmap/brush.py

@@ -0,0 +1,92 @@
+"""The watercolour engine: turns a raster of class ids into a painted RGB image."""
+import numpy as np
+from scipy import ndimage as ndi
+
+PAPER = np.array([0.985, 0.972, 0.925], np.float32)
+EMPTY = 255  # class id for "no data": stays bare paper
+
+
+def fbm(shape, rng, scales=(160, 60, 22, 8), weights=(0.45, 0.3, 0.17, 0.08)):
+    """Smooth multi-octave noise in [0, 1], made at low resolution and upsampled."""
+    h, w = shape
+    out = np.zeros(shape, np.float32)
+    for s, wt in zip(scales, weights):
+        lh, lw = max(2, h // s + 2), max(2, w // s + 2)
+        n = rng.standard_normal((lh, lw)).astype(np.float32)
+        n = ndi.zoom(n, (h / lh * 1.0001, w / lw * 1.0001), order=3)[:h, :w]
+        out += wt * n
+    out -= out.min()
+    out /= max(out.max(), 1e-6)
+    return out
+
+
+def paint(classes, colours, pixel_size=2.5, seed=7, paper=PAPER):
+    """Paint a class raster as watercolour.
+
+    classes     2-D integer array of class ids (EMPTY = bare paper)
+    colours     {class_id: (r, g, b)} with values 0-1
+    pixel_size  ground size of a pixel in metres; effects are scaled to it so
+                the brush looks the same at any resolution
+    Returns an (h, w, 3) float array in 0-1.
+    """
+    rng = np.random.default_rng(seed)
+    h, w = classes.shape
+    k = max(1.0, 2.5 / pixel_size)
+
+    # paper with a faint fibre texture
+    fibre = fbm((h, w), rng, scales=(40, 6, 2), weights=(0.3, 0.4, 0.3))
+    img = np.empty((h, w, 3), np.float32)
+    img[:] = paper
+    img *= (0.985 + 0.03 * fibre)[..., None]
+
+    # one shared wobble field, so neighbouring washes keep their gaps consistent
+    dx = (fbm((h, w), rng, scales=(90, 30)) - 0.5) * 6 * k
+    dy = (fbm((h, w), rng, scales=(90, 30)) - 0.5) * 6 * k
+    yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
+    coords = np.array([yy + dy, xx + dx])
+    del yy, xx
+
+    for cid, col in colours.items():
+        m = (classes == cid).astype(np.float32)
+        if not m.any():
+            continue
+        m = ndi.map_coordinates(m, coords, order=1, mode="nearest")   # hand-drawn edge
+        m = ndi.gaussian_filter(m, 0.9 * k)
+        m = np.clip((m - 0.35) / 0.4, 0, 1)        # slight shrink: bare paper between parcels
+        edge = np.clip(m - ndi.gaussian_filter(m, 3.0 * k), 0, 1)   # pigment pooling at edges
+        wash = fbm((h, w), rng, scales=(220, 70, 18))                # uneven wash
+        gran = fbm((h, w), rng, scales=(5, 2), weights=(0.6, 0.4))  # granulation
+        alpha = np.clip(m * (0.50 + 0.38 * wash) * (0.88 + 0.24 * gran) + 1.6 * edge, 0, 0.97)
+        colv = np.asarray(col, np.float32)
+        img *= 1 - alpha[..., None] * (1 - colv)    # multiply glaze, like pigment on paper
+    return np.clip(img, 0, 1)
+
+
+def swatch(colour, seed=1, size=(40, 110)):
+    """A small painted rectangle in one colour, for legends."""
+    c = np.full(size, EMPTY, np.uint8)
+    c[6:size[0] - 6, 6:size[1] - 6] = 1
+    return paint(c, {1: colour}, pixel_size=2.0, seed=seed)
+
+
+def deckle(img, pixel_size, seed=3, paper=PAPER):
+    """Fade the outer edge of a rectangular painting into a torn, hand-painted edge."""
+    h, w = img.shape[:2]
+    rng = np.random.default_rng(seed)
+    d = np.minimum.outer(np.minimum(np.arange(h), np.arange(h)[::-1]),
+                         np.minimum(np.arange(w), np.arange(w)[::-1])).astype(np.float32)
+    k = max(1.0, 2.5 / pixel_size)
+    n = fbm((h, w), rng, scales=(120, 35, 10), weights=(0.5, 0.35, 0.15))
+    fe = np.clip((d - 28 * k * n) / (5 * k), 0, 1)[..., None]
+    return paper + (img - paper) * fe
+
+
+def fade_paper(img, classes, paper=PAPER):
+    """Fade the paper fibre out towards the frame where there is no paint."""
+    h, w = classes.shape
+    ramp = max(1, int(max(h, w) * 0.03))
+    fy = np.clip(np.minimum(np.arange(h), np.arange(h)[::-1]) / ramp, 0, 1)
+    fx = np.clip(np.minimum(np.arange(w), np.arange(w)[::-1]) / ramp, 0, 1)
+    f = np.minimum.outer(fy, fx)[..., None]
+    outside = (classes == EMPTY)[..., None]
+    return np.where(outside, paper + (img - paper) * f, img)

watercolourmap-0.1.0/src/watercolourmap/cli.py

@@ -0,0 +1,72 @@
+"""Command line: watercolour posters from Copernicus Urban Atlas files."""
+import argparse
+
+import geopandas as gpd
+from shapely.geometry import box
+
+from .legends import IGNITION, URBAN_ATLAS_CREDIT, read_urban_atlas
+from .poster import poster, map_box_aspect
+from .shapes import local_crs, irregular_circle, rectangle
+
+
+def parse_label(spec):
+    parts = spec.split("|")
+    return (parts[0], float(parts[1]), float(parts[2]), float(parts[3]) if len(parts) > 3 else 0)
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="watercolourmap",
+                                 description="Watercolour land cover poster from a Copernicus Urban Atlas file.")
+    ap.add_argument("data", help="Urban Atlas .fgb or .gpkg")
+    ap.add_argument("--layer")
+    where = ap.add_argument_group("area (pick one)")
+    where.add_argument("--center", nargs=2, type=float, metavar=("LON", "LAT"))
+    where.add_argument("--radius", type=float, help="with --center: irregular circle, km")
+    where.add_argument("--width", type=float, default=8, help="with --center: rectangle width, km")
+    where.add_argument("--bbox", nargs=4, type=float, metavar=("MINLON", "MINLAT", "MAXLON", "MAXLAT"))
+    where.add_argument("--clip", help="any polygon file")
+    ap.add_argument("--landscape", action="store_true")
+    ap.add_argument("--sea", action="store_true", help="paint everything outside the data as Blue Cover")
+    ap.add_argument("--label", action="append", default=[], metavar='"Name|lon|lat[|angle]"')
+    ap.add_argument("--title", default="Land Cover")
+    ap.add_argument("--subtitle", default="")
+    ap.add_argument("--signature", default="", help="e.g. your name or handle, top right")
+    ap.add_argument("--website", default="", help="small line under the signature")
+    ap.add_argument("--credit", default=URBAN_ATLAS_CREDIT)
+    ap.add_argument("--paper", default="A2", choices=["A1", "A2", "A3", "A4"])
+    ap.add_argument("--dpi", type=int, default=300)
+    ap.add_argument("--out", default="landcover")
+    a = ap.parse_args(argv)
+
+    bounds, landscape, torn = None, None, False
+    if a.center and a.radius:
+        crs, c = local_crs(*a.center)
+        R = a.radius * 1000
+        read = tuple(gpd.GeoSeries([c.buffer(R * 1.6)], crs=crs).to_crs(4326).total_bounds)
+        gdf = read_urban_atlas(a.data, read, a.layer).to_crs(crs)
+        gdf = irregular_circle(gdf, c, R)
+        landscape = False
+    elif a.center:
+        crs, c = local_crs(*a.center)
+        landscape = a.landscape
+        rect = rectangle(c, a.width * 1000, map_box_aspect(a.paper, landscape))
+        read = tuple(gpd.GeoSeries([rect], crs=crs).to_crs(4326).total_bounds)
+        gdf = gpd.clip(read_urban_atlas(a.data, read, a.layer).to_crs(crs), rect)
+        bounds, torn = rect.bounds, True
+    else:
+        gdf = read_urban_atlas(a.data, a.bbox, a.layer)
+        gdf = gdf.to_crs(gdf.estimate_utm_crs())
+        if a.clip:
+            gdf = gpd.clip(gdf, gpd.read_file(a.clip).to_crs(gdf.crs).union_all())
+        elif a.bbox:
+            gdf = gpd.clip(gdf, gpd.GeoSeries([box(*a.bbox)], crs=4326).to_crs(gdf.crs).union_all())
+    gdf = gdf[gdf.cls >= 0]   # class 0 (roads) is burnt in as bare paper, so --sea can't fill it
+
+    poster(gdf, IGNITION, a.out, bounds=bounds, paper=a.paper, landscape=landscape, dpi=a.dpi,
+           title=a.title, subtitle=a.subtitle, signature=a.signature, website=a.website,
+           credit=a.credit, labels=[parse_label(s) for s in a.label],
+           sea_class=1 if a.sea else None, torn_edge=torn)
+
+
+if __name__ == "__main__":
+    main()

watercolourmap-0.1.0/src/watercolourmap/fonts/FreeSerif-LICENSE.txt

@@ -0,0 +1,99 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: GNU FreeFont
+Upstream-Contact: Steve White <Stevan.White@gmail.com>
+Source: https://savannah.gnu.org/projects/freefont/
+
+Files: *
+Copyright: 2002-2012, GNU Freefont contributors
+  2009-2012, Steve White <Stevan.White@gmail.com>
+  2011, Emmanuel Vallois
+License: GPL-3+
+
+Files: */*.ttf */*.otf */*.woff
+Copyright: 2002-2012, GNU Freefont contributors
+License: GPL-3+ with Special Font Exception
+
+Files: debian/*
+Copyright: 2002-2003, Peter Hawkins <peterh@debian.org>
+  2004, Josh Triplett <josh.trip@verizon.net>
+  2004, Panayotis Katsaloulis <panayotis@panayotis.com>
+  2005-2006, Konstantinos Margaritis <markos@debian.org>
+  2006-2014, Christian Perrier <bubulle@debian.org>
+  2007-2011, Davide Viti <zinosat@tiscali.it>
+  2016-2023, Fabian Greffrath <fabian@debian.org>
+  2016, Adam Borowski <kilobyte@angband.pl>
+License: GPL-3+
+
+License: GPL-3+
+ GNU FreeFont is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 3 of the License, or (at your option)
+ any later version.
+ .
+ The fonts are distributed in the hope that they will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ for more details.
+ .
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ .
+ On Debian systems, the complete text of the GNU General
+ Public License version 3 can be found in "/usr/share/common-licenses/GPL-3".
+
+License: GPL-3+ with Special Font Exception
+ GNU FreeFont is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 3 of the License, or (at your option)
+ any later version.
+ .
+ The fonts are distributed in the hope that they will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ for more details.
+ .
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ .
+ * Regarding the use of built font files.
+ .
+ As a special exception, if you create a document which uses this font, and
+ embed this font or unaltered portions of this font into the document, this
+ font does not by itself cause the resulting document to be covered by the
+ GNU General Public License. This exception does not however invalidate any
+ other reasons why the document might be covered by the GNU General Public
+ License. If you modify this font, you may extend this exception to your
+ version of the font, but you are not obligated to do so.  If you do not
+ wish to do so, delete this exception statement from your version.
+ .
+ * Clarification of exception, regarding intended use of embedded fonts
+ .
+ The exception to the GNU General Public License for the GNU FreeFont
+ software exempts a user that embeds part or all of the GNU FreeFont software
+ in a document, as well as subsequent users and distributors of the document,
+ from complying with the GNU GPL under some circumstances.
+ .
+ Specifically, this exemption applies when the embedder has not modified
+ the GNU FreeFont software before embedding it. This is true even though
+ portions of the software become part of the document.
+ .
+ Therefore users of fonts released with this exception need not concern
+ themselves with the license terms to:
+ .
+    Create a printable file using the fonts.
+    - Publish such a file.
+    - Redistribute such a file.
+    - Publicly display such a file.
+    - Print such a file or display it on the screen.
+ .
+ However anyone distributing the font software as software separately from
+ the document, even if the way the font software was obtained was to extract
+ it from a document, would have to comply with the GNU GPL.
+ .
+ A modified version of the GNU FreeFont software must comply with the GNU GPL.
+ It may optionally carry the same exception as the GNU FreeFont software
+ itself, and we recommend releasing modified versions that way. If it does,
+ then users will likewise be permitted to embed the modified version in
+ documents and be exempt from the GNU GPL requirements on those documents.

watercolourmap-0.1.0/src/watercolourmap/fonts/Lora-OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2011 The Lora Project Authors (https://github.com/cyrealtype/Lora-Cyrillic), with Reserved Font Name "Lora".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

watercolourmap-0.1.0/src/watercolourmap/legends.py

@@ -0,0 +1,59 @@
+"""Legends: the IGNITION land cover palette and the Urban Atlas reclassification."""
+import re
+
+import geopandas as gpd
+import pyogrio
+from shapely.geometry import box
+
+# Muted watercolour pigments, close to the Gorton and Abbey Hey map (IGNITION legend)
+IGNITION = {
+    1: ("Blue Cover",        (0.42, 0.55, 0.74)),
+    2: ("Green Cover",       (0.42, 0.60, 0.33)),
+    3: ("Green-Grey Cover",  (0.55, 0.66, 0.66)),
+    4: ("Grey Cover",        (0.66, 0.70, 0.76)),
+    5: ("Land Use Changing", (0.80, 0.38, 0.38)),
+    6: ("Unknown",           (0.82, 0.63, 0.50)),
+    7: ("Other Natural",     (0.83, 0.77, 0.62)),
+}
+BARE = 0  # roads and rail: left as bare paper
+
+URBAN_ATLAS_CREDIT = ("Contains modified Copernicus Land Monitoring Service "
+                      "information (Urban Atlas 2021) © European Union")
+
+
+def urban_atlas_class(code):
+    """Copernicus Urban Atlas code -> IGNITION legend class id."""
+    c = int(code)
+    if c in (11100, 11210, 12100, 12300, 12400):      return 4   # grey
+    if c in (11220, 11230, 11240, 11300):             return 3   # green-grey
+    if c in (12210, 12220, 12230):                    return BARE
+    if c in (13100, 13300):                           return 5   # changing
+    if c == 13400:                                    return 6   # unknown / vacant
+    if c in (14100, 14110, 14120, 14130):             return 2   # urban green (2021 splits by access)
+    if c == 14200:                                    return 3   # sports and leisure, incl. marinas
+    if 31000 <= c <= 32000 or 40000 <= c < 50000:     return 2   # forest, grassland, wetland
+    if 20000 <= c < 30000:                            return 7   # agriculture
+    if c == 33000:                                    return 7   # bare ground, beaches
+    if c == 50000:                                    return 1   # water
+    return 6
+
+
+def read_urban_atlas(path, bbox=None, layer=None, verbose=True):
+    """Read an Urban Atlas file (gpkg or fgb) and add a 'cls' column with legend ids.
+
+    bbox  optional (minlon, minlat, maxlon, maxlat) to read only part of the city
+    """
+    layers = [l[0] for l in pyogrio.list_layers(path)]
+    if layer is None:
+        cand = [l for l in layers if not re.search(r"bound|core|fua_area", l, re.I)]
+        layer = (cand or layers)[0]
+    kw = {}
+    if bbox:
+        crs = pyogrio.read_info(path, layer=layer)["crs"]
+        kw["bbox"] = tuple(gpd.GeoSeries([box(*bbox)], crs=4326).to_crs(crs).total_bounds)
+    gdf = gpd.read_file(path, layer=layer, **kw)
+    codecol = next(c for c in gdf.columns if re.fullmatch(r"code_20\d\d", c, re.I))
+    gdf["cls"] = gdf[codecol].map(urban_atlas_class)
+    if verbose:
+        print(f"layer={layer} code column={codecol} features={len(gdf)}")
+    return gdf

watercolourmap-0.1.0/src/watercolourmap/poster.py

@@ -0,0 +1,203 @@
+"""Painting GeoDataFrames and laying out print-ready posters."""
+from pathlib import Path
+
+import numpy as np
+import geopandas as gpd
+from rasterio.features import rasterize
+from rasterio.transform import from_origin
+from shapely.geometry import Point
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as pe
+from matplotlib import font_manager as fm
+
+from .brush import PAPER, EMPTY, paint, swatch, deckle, fade_paper
+
+FONTS = Path(__file__).resolve().parent / "fonts"
+PAPER_SIZES = {"A1": (594, 841), "A2": (420, 594), "A3": (297, 420), "A4": (210, 297)}
+INK = (0.25, 0.25, 0.25)
+MAX_PIXELS = 60_000_000   # roughly 5 GB of working memory while painting
+
+
+def font(name="Lora-Italic-Variable.ttf"):
+    return fm.FontProperties(fname=str(FONTS / name))
+
+
+# ------------------------------------------------------------------ painting
+def rasterise(gdf, column, bounds, pixel_size):
+    """Burn polygons into a class raster. Larger polygons first, small ones on top."""
+    minx, miny, maxx, maxy = bounds
+    W = int(np.ceil((maxx - minx) / pixel_size))
+    H = int(np.ceil((maxy - miny) / pixel_size))
+    if W * H > MAX_PIXELS:
+        raise ValueError(
+            f"The map would be {W} x {H} pixels, too big to paint in memory. "
+            "Clip the data to a smaller area or use a larger pixel_size / lower dpi. "
+            "Is the data in a metric CRS (metres)?")
+    order = gdf.assign(_a=gdf.area).sort_values("_a", ascending=False)
+    return rasterize(((g, int(c)) for g, c in zip(order.geometry, order[column])),
+                     out_shape=(H, W), transform=from_origin(minx, maxy, pixel_size, pixel_size),
+                     fill=EMPTY, dtype="uint8")
+
+
+def paint_gdf(gdf, column, colours, pixel_size=None, bounds=None, seed=7):
+    """Paint any polygon GeoDataFrame as watercolour.
+
+    gdf         polygons in a metric CRS (use gdf.to_crs(gdf.estimate_utm_crs()))
+    column      column holding a category for each polygon
+    colours     {category: (r, g, b)} (0-1 floats or '#rrggbb' strings)
+    pixel_size  metres per pixel; default makes the longer side about 3000 px
+    Returns (image, extent) ready for ax.imshow(image, extent=extent).
+    """
+    # any category type -> small integer ids for the raster
+    cats = list(colours)
+    ids = {c: i + 1 for i, c in enumerate(cats)}
+    g = gdf[gdf[column].isin(ids)].assign(_id=lambda d: d[column].map(ids))
+    if g.empty:
+        raise ValueError(f"No polygons have a {column!r} value listed in colours")
+    bounds = bounds if bounds is not None else tuple(g.total_bounds)
+    if pixel_size is None:
+        pixel_size = max(bounds[2] - bounds[0], bounds[3] - bounds[1]) / 3000
+    ras = rasterise(g, "_id", bounds, pixel_size)
+    rgb = {ids[c]: matplotlib.colors.to_rgb(colours[c]) for c in cats}
+    img = fade_paper(paint(ras, rgb, pixel_size, seed), ras)
+    minx, miny, maxx, maxy = bounds
+    H, W = ras.shape
+    return img, (minx, minx + W * pixel_size, maxy - H * pixel_size, maxy)
+
+
+# ------------------------------------------------------------------ posters
+def _page(paper, landscape):
+    pw, ph = PAPER_SIZES[paper]
+    if landscape:
+        pw, ph = ph, pw
+    win, hin = pw / 25.4, ph / 25.4
+    base = 10.5 * np.sqrt((pw * ph) / (297 * 420))   # pt, scales with paper
+    m_in = min(win, hin) * 0.06
+    title_in = base * 4.2 / 72
+    panel_in = base * 15 / 72
+    gap = base * 1.6 / 72
+    if landscape:   # legend panel on the left
+        box_in = (m_in + panel_in, m_in, win - 2 * m_in - panel_in, hin - 2 * m_in - title_in - gap)
+    else:           # legend panel along the bottom
+        box_in = (m_in, m_in + panel_in * 0.75 + gap, win - 2 * m_in,
+                  hin - 2 * m_in - title_in - panel_in * 0.75 - 2 * gap)
+    return dict(win=win, hin=hin, base=base, m_in=m_in, panel_in=panel_in, box_in=box_in)
+
+
+def map_box_aspect(paper="A2", landscape=False):
+    """Height / width of the map area on a page, for shaping a rectangle to fill it."""
+    b = _page(paper, landscape)["box_in"]
+    return b[3] / b[2]
+
+
+def poster(gdf, legend, out, *, column="cls", bounds=None, paper="A2", landscape=None, dpi=300,
+           title="", subtitle="", signature="", website="", credit="", labels=(),
+           legend_title="Land Use Types", sea_class=None, torn_edge=False, seed=7,
+           formats=("pdf", "png")):
+    """Paint a poster: title, map, painted legend, scale bar and credits.
+
+    gdf        polygons in a metric CRS with an integer class column
+    legend     {class_id: (name, (r, g, b))}, in legend order
+    bounds     map extent (minx, miny, maxx, maxy); default is the data extent
+    landscape  None picks it from the shape of the area
+    labels     [(name, lon, lat, angle), ...] small italic place labels
+    sea_class  paint everything outside the data with this class (e.g. sea)
+    torn_edge  hand-torn edge for rectangular maps
+    """
+    minx, miny, maxx, maxy = bounds if bounds is not None else gdf.total_bounds
+    if landscape is None:
+        landscape = (maxx - minx) > (maxy - miny)
+    p = _page(paper, landscape)
+    win, hin, base, m_in, panel_in, box_in = (p[k] for k in ("win", "hin", "base", "m_in", "panel_in", "box_in"))
+    span = max((maxx - minx) / box_in[2], (maxy - miny) / box_in[3])  # metres per inch on paper
+    px = span / dpi
+    ras = rasterise(gdf, column, (minx, miny, maxx, maxy), px)
+    H, W = ras.shape
+    print(f"raster {W}x{H}px at {px:.2f} m/px, page {paper} {'landscape' if landscape else 'portrait'}")
+    if sea_class is not None:
+        ras[ras == EMPTY] = sea_class
+    img = paint(ras, {k: v[1] for k, v in legend.items()}, px, seed)
+    if torn_edge:
+        img = deckle(img, px)
+    img = fade_paper(img, ras)
+
+    f = font()
+    fig = plt.figure(figsize=(win, hin), dpi=dpi)
+    fig.patch.set_facecolor(PAPER)
+    X = lambda i: i / win
+    Y = lambda i: i / hin
+    mw, mh = (maxx - minx) / span, (maxy - miny) / span
+    ax = fig.add_axes([X(box_in[0] + (box_in[2] - mw) / 2), Y(box_in[1] + (box_in[3] - mh) / 2), X(mw), Y(mh)])
+    ax.imshow(img, extent=(minx, minx + W * px, maxy - H * px, maxy), interpolation="lanczos")
+    ax.set_xlim(minx, maxx); ax.set_ylim(miny, maxy)
+    ax.set_aspect("equal"); ax.axis("off")
+
+    for lab in labels:
+        name, lon, lat = lab[:3]
+        ang = lab[3] if len(lab) > 3 else 0
+        pt = gpd.GeoSeries([Point(lon, lat)], crs=4326).to_crs(gdf.crs).iloc[0]
+        ax.text(pt.x, pt.y, name, fontproperties=f, fontsize=base * 1.05, color=(0.22,) * 3,
+                ha="center", va="center", rotation=ang, rotation_mode="anchor",
+                path_effects=[pe.withStroke(linewidth=base * 0.35, foreground=(*PAPER, 0.75))])
+
+    if title:
+        fig.text(X(m_in), 1 - Y(m_in), title, fontproperties=f, fontsize=base * 2.6, color=INK, va="top")
+    if subtitle:   # Lora has no Greek glyphs: fall back to FreeSerif Italic
+        sf = f if all(ord(ch) < 0x370 for ch in subtitle) else font("FreeSerifItalic.ttf")
+        fig.text(X(m_in), 1 - Y(m_in + base * 3.3 / 72), subtitle, fontproperties=sf,
+                 fontsize=base * 1.05, color=(0.42,) * 3, va="top")
+
+    # legend, painted with the same brush
+    present = [c for c in legend if (ras == c).any()]
+    row = base * 2.0 / 72
+    lx = m_in
+    ly = (m_in + panel_in * 0.75 + len(present) * row) if landscape else box_in[1] - base * 2.6 / 72 - row
+    if legend_title:
+        fig.text(X(lx), Y(ly + row * 0.9), legend_title, fontproperties=f, fontsize=base * 1.15, color=INK)
+    per = int(np.ceil(len(present) / (1 if landscape else 2))) or 1
+    for i, cid in enumerate(present):
+        cx = lx + (i // per) * base * 13 / 72
+        y = ly - row * (i % per)
+        sw, sh = base * 2.2 / 72, base * 0.9 / 72
+        sax = fig.add_axes([X(cx), Y(y - sh / 2), X(sw), Y(sh)])
+        sax.imshow(swatch(legend[cid][1], cid), aspect="auto"); sax.axis("off")
+        fig.text(X(cx + sw + base * 0.6 / 72), Y(y), legend[cid][0], fontproperties=f,
+                 fontsize=base * 0.95, color=INK, va="center")
+
+    # scale bar, true to map scale
+    target = panel_in * 0.7 * span
+    total = 10 ** np.floor(np.log10(target))
+    for mult in (5, 2, 1):
+        if total * mult <= target:
+            total *= mult
+            break
+    bar_in = total / span
+    sy = (m_in + base * 2.2 / 72) if landscape else (m_in + base * 0.8 / 72)
+    sx = m_in if landscape else win - m_in - bar_in - base * 10 / 72
+    sbx = fig.add_axes([X(sx), Y(sy), X(bar_in), Y(base * 0.5 / 72)])
+    sbx.set_xlim(0, total); sbx.set_ylim(0, 1); sbx.axis("off")
+    sbx.plot([0, total], [0, 0], color=INK, lw=0.8, clip_on=False)
+    for t in np.linspace(0, total, 11):
+        sbx.plot([t, t], [0, 0.55 if t in (0, total / 2, total) else 0.3], color=INK, lw=0.6, clip_on=False)
+    unit = 1000 if total >= 1000 else 1
+    for t in (0, total / 2, total):
+        sbx.text(t, 1.0, f"{t / unit:g}" + ((" km" if unit == 1000 else " m") if t == total else ""),
+                 ha="center", va="bottom", fontsize=base * 0.75, color=INK, fontproperties=f)
+
+    if signature:
+        fig.text(1 - X(m_in), 1 - Y(m_in + base * 0.9 / 72), signature, ha="right", va="top",
+                 fontproperties=f, fontsize=base * 1.5, color=INK)
+    if website:
+        fig.text(1 - X(m_in), 1 - Y(m_in + base * 3.3 / 72), website, ha="right", va="top",
+                 fontproperties=f, fontsize=base * 0.8, color=(0.45,) * 3)
+    if credit:
+        fig.text(1 - X(m_in), Y(m_in * 0.55), credit, ha="right", fontsize=base * 0.6,
+                 color=(0.45,) * 3, fontproperties=f)
+
+    out = Path(out)
+    for ext in formats:
+        fig.savefig(out.with_suffix(f".{ext}"), dpi=dpi, facecolor=PAPER)
+    plt.close(fig)
+    print("saved", out)
+    return out

watercolourmap-0.1.0/src/watercolourmap/shapes.py

@@ -0,0 +1,41 @@
+"""Map shapes: irregular circles and page-filling rectangles."""
+import numpy as np
+import geopandas as gpd
+from shapely.geometry import Point, Polygon, box
+
+
+def local_crs(lon, lat):
+    """A metric (UTM) CRS for a point, and the point in that CRS."""
+    s = gpd.GeoSeries([Point(lon, lat)], crs=4326)
+    crs = s.estimate_utm_crs()
+    return crs, s.to_crs(crs).iloc[0]
+
+
+def wobbly_circle(centre, radius, seed=11, n=1440):
+    """A slightly irregular circle polygon around a projected point."""
+    rng = np.random.default_rng(seed)
+    t = np.linspace(0, 2 * np.pi, n, endpoint=False)
+    wob = sum(rng.uniform(0.008, 0.03) * np.sin(f * t + rng.uniform(0, 6.3)) for f in (3, 5, 8, 13, 21))
+    return Polygon([(centre.x + radius * (1 + w) * np.cos(q), centre.y + radius * (1 + w) * np.sin(q))
+                    for q, w in zip(t, wob)])
+
+
+def irregular_circle(gdf, centre, radius, seed=11):
+    """Keep whole parcels whose centre is within `radius` of `centre`.
+
+    This gives the ragged, parcel-shaped edge. Very large parcels (a river,
+    a forest, the road network) are trimmed with a wobbly circle so they
+    don't run off the page. gdf must be in a metric CRS.
+    """
+    inside = gdf.representative_point().distance(centre) <= radius
+    edge = wobbly_circle(centre, radius * 1.08, seed)
+    big = gdf.intersects(centre.buffer(radius)) & ~gdf.within(edge)
+    keep = gdf[inside | big].copy()
+    keep["geometry"] = keep.geometry.intersection(edge)
+    return keep[~keep.geometry.is_empty]
+
+
+def rectangle(centre, width, aspect):
+    """A rectangle `width` metres wide, height = width * aspect, around a projected point."""
+    hw, hh = width / 2, width * aspect / 2
+    return box(centre.x - hw, centre.y - hh, centre.x + hw, centre.y + hh)

watercolourmap-0.1.0/src/watercolourmap.egg-info/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: watercolourmap
+Version: 0.1.0
+Summary: Watercolour maps in Python, inspired by John Nelson's watercolour style for ArcGIS Pro
+Author: Eriola Trungu Impersimi
+License-Expression: MIT
+Project-URL: Homepage, https://etymo.co.uk/cartography/
+Keywords: cartography,maps,watercolour,watercolor,geopandas,land cover,urban atlas,copernicus
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: src/watercolourmap/fonts/FreeSerif-LICENSE.txt
+License-File: src/watercolourmap/fonts/Lora-OFL.txt
+Requires-Dist: geopandas>=1.0
+Requires-Dist: pyogrio>=0.9
+Requires-Dist: shapely>=2.0
+Requires-Dist: rasterio>=1.3
+Requires-Dist: scipy>=1.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: matplotlib>=3.8
+Dynamic: license-file
+
+# watercolourmap
+
+Watercolour maps in Python. Polygons are painted as soft washes on textured paper, with uneven pigment, darker edges and a thin line of bare paper between neighbouring shapes.
+
+It's inspired by John Nelson's [watercolour style for ArcGIS Pro](https://www.esri.com/arcgis-blog/products/arcgis-pro/mapping/steal-this-watercolor-style-for-pro-please), recreated in code so it works with any GeoDataFrame. You can see example prints at [etymo.co.uk/cartography](https://etymo.co.uk/cartography/).
+
+## Install
+
+```bash
+pip install watercolourmap
+```
+
+## Paint any polygons
+
+```python
+import geopandas as gpd
+import matplotlib.pyplot as plt
+from watercolourmap import paint_gdf, PAPER
+
+gdf = gpd.read_file("my_area.gpkg")
+gdf = gdf.to_crs(gdf.estimate_utm_crs())          # needs a CRS in metres
+
+img, extent = paint_gdf(
+    gdf, "landuse",
+    {"residential": "#c9a27e", "park": "#7a9a5a", "water": "#5f86b0"},
+)
+
+fig, ax = plt.subplots(figsize=(8, 8), facecolor=PAPER)
+ax.imshow(img, extent=extent)
+ax.set_axis_off()
+fig.savefig("map.png", dpi=300, facecolor=PAPER)
+```
+
+- Polygons whose value isn't in the colour dictionary are left as bare paper.
+- `pixel_size` sets the resolution in metres per pixel. By default the longer side is about 3,000 pixels.
+- `seed` changes the brushwork.
+
+## Print posters from Copernicus Urban Atlas
+
+The command line tool turns a [Copernicus Urban Atlas](https://land.copernicus.eu/en/products/urban-atlas) city file into a print-ready poster. You get a title, the painted map, a legend painted with the same brush, a scale bar and the data credit, saved as PDF and PNG.
+
+```bash
+# An irregular circle, 1.8 km radius, with place labels
+watercolourmap ELBASAN.fgb --center 20.097 41.106 --radius 1.8 \
+    --title "Elbasan Land Cover" \
+    --label "Kalaja|20.080|41.1125" --label "Lumi Shkumbin|20.0975|41.1006|-4" \
+    --paper A2 --out elbasan
+
+# A 12 km rectangle with a hand-torn edge, and the sea painted in
+watercolourmap ATHINA.fgb --center 23.688 37.958 --width 12 --sea \
+    --title "Athens Land Cover" --paper A2 --out athens
+```
+
+Run `watercolourmap --help` for every option: `--bbox` or `--clip` for other areas, `--signature` and `--website` to sign your map, and `--dpi 100` for quick drafts.
+
+Urban Atlas codes are grouped into seven classes: Blue, Green, Green-Grey and Grey Cover, Land Use Changing, Unknown and Other Natural. Roads and railways are left as bare paper. Urban Atlas maps land use rather than land cover, so some groupings are judgement calls. For example, marinas are coded as sports and leisure. You can see the full mapping in `urban_atlas_class()`.
+
+Keep the credit on your maps. The tool adds it by default: *Contains modified Copernicus Land Monitoring Service information (Urban Atlas 2021) © European Union*.
+
+## Building blocks
+
+| Function | What it does |
+|---|---|
+| `paint_gdf(gdf, column, colours)` | Paints any polygons and returns an image and its extent |
+| `poster(gdf, legend, out, ...)` | Lays out a full poster from polygons with integer classes |
+| `paint(classes, colours, pixel_size)` | Paints a raster of class ids |
+| `irregular_circle(gdf, centre, radius)` | Keeps whole parcels inside a circle, for a ragged, parcel-shaped edge |
+| `read_urban_atlas(path, bbox)` | Reads an Urban Atlas file and adds the legend class |
+| `IGNITION` | The default seven-class legend and colours |
+
+## Credits
+
+- **Watercolour style:** inspired by John Nelson (Esri).
+- **Legend:** from the University of Manchester IGNITION project land cover map.
+- **Fonts:** Lora (SIL Open Font License) and FreeSerif (GPL with font exception) are bundled.
+
+MIT licence © 2026 Eriola Trungu Impersimi

watercolourmap-0.1.0/src/watercolourmap.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/watercolourmap/__init__.py
+src/watercolourmap/brush.py
+src/watercolourmap/cli.py
+src/watercolourmap/legends.py
+src/watercolourmap/poster.py
+src/watercolourmap/shapes.py
+src/watercolourmap.egg-info/PKG-INFO
+src/watercolourmap.egg-info/SOURCES.txt
+src/watercolourmap.egg-info/dependency_links.txt
+src/watercolourmap.egg-info/entry_points.txt
+src/watercolourmap.egg-info/requires.txt
+src/watercolourmap.egg-info/top_level.txt
+src/watercolourmap/fonts/FreeSerif-LICENSE.txt
+src/watercolourmap/fonts/FreeSerifItalic.ttf
+src/watercolourmap/fonts/Lora-Italic-Variable.ttf
+src/watercolourmap/fonts/Lora-OFL.txt

watercolourmap-0.1.0/src/watercolourmap.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

watercolourmap-0.1.0/src/watercolourmap.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+watercolourmap = watercolourmap.cli:main

watercolourmap-0.1.0/src/watercolourmap.egg-info/requires.txt

@@ -0,0 +1,7 @@
+geopandas>=1.0
+pyogrio>=0.9
+shapely>=2.0
+rasterio>=1.3
+scipy>=1.11
+numpy>=1.26
+matplotlib>=3.8

watercolourmap-0.1.0/src/watercolourmap.egg-info/top_level.txt

@@ -0,0 +1 @@
+watercolourmap