712 lines
28 KiB
Python
Executable file
712 lines
28 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
#
|
|
# https://git.kabelsalat.ch/s3lph/erfamap
|
|
|
|
import os
|
|
import urllib.request
|
|
import urllib.parse
|
|
import json
|
|
import base64
|
|
import sys
|
|
import argparse
|
|
import shutil
|
|
import random
|
|
|
|
from lxml import etree
|
|
import pyproj
|
|
from geopy import Nominatim
|
|
import tqdm
|
|
import cairosvg
|
|
from PIL import Image, ImageFont
|
|
from PIL.ImageDraw import ImageDraw
|
|
|
|
|
|
USER_AGENT = 'Erfamap/v0.1 (https://git.kabelsalat.ch/s3lph/erfamap)'
|
|
|
|
|
|
class CachePaths:
|
|
|
|
def __init__(self, path: str):
|
|
if os.path.exists(path) and not os.path.isdir(path):
|
|
raise AttributeError(f'Path exists but is not a directory: {path}')
|
|
os.makedirs(path, exist_ok=True)
|
|
self.shapes_states = os.path.join(path, 'shapes_states')
|
|
self.shapes_countries = os.path.join(path, 'shapes_countries')
|
|
self.shapes_filtered = os.path.join(path, 'shapes_filtered')
|
|
self.erfa_info = os.path.join(path, 'erfa-info.json')
|
|
self.chaostreff_info = os.path.join(path, 'chaostreff-info.json')
|
|
|
|
|
|
ERFA_URL = 'https://doku.ccc.de/Spezial:Semantische_Suche/format%3Djson/limit%3D50/link%3Dall/headers%3Dshow/searchlabel%3DJSON/class%3Dsortable-20wikitable-20smwtable/sort%3D/order%3Dasc/offset%3D0/-5B-5BKategorie:Erfa-2DKreise-5D-5D-20-5B-5BChaostreff-2DActive::wahr-5D-5D/-3FChaostreff-2DCity/-3FChaostreff-2DPhysical-2DAddress/-3FChaostreff-2DPhysical-2DHousenumber/-3FChaostreff-2DPhysical-2DPostcode/-3FChaostreff-2DPhysical-2DCity/-3FChaostreff-2DCountry/mainlabel%3D/prettyprint%3Dtrue/unescape%3Dtrue'
|
|
|
|
CHAOSTREFF_URL = 'https://doku.ccc.de/Spezial:Semantische_Suche/format%3Djson/limit%3D50/link%3Dall/headers%3Dshow/searchlabel%3DJSON/class%3Dsortable-20wikitable-20smwtable/sort%3D/order%3Dasc/offset%3D0/-5B-5BKategorie:Chaostreffs-5D-5D-20-5B-5BChaostreff-2DActive::wahr-5D-5D/-3FChaostreff-2DCity/-3FChaostreff-2DPhysical-2DAddress/-3FChaostreff-2DPhysical-2DHousenumber/-3FChaostreff-2DPhysical-2DPostcode/-3FChaostreff-2DPhysical-2DCity/-3FChaostreff-2DCountry/mainlabel%3D/prettyprint%3Dtrue/unescape%3Dtrue'
|
|
|
|
|
|
def sparql_query(query):
|
|
headers = {
|
|
'Content-Type': 'application/x-www-form-urlencoded',
|
|
'User-Agent': USER_AGENT,
|
|
'Accept': 'application/sparql-results+json',
|
|
}
|
|
body = urllib.parse.urlencode({'query': query}).encode()
|
|
req = urllib.request.Request('https://query.wikidata.org/sparql', headers=headers, data=body)
|
|
with urllib.request.urlopen(req) as resp:
|
|
resultset = json.load(resp)
|
|
results = {}
|
|
for r in resultset.get('results', {}).get('bindings'):
|
|
basename = None
|
|
url = None
|
|
for k, v in r.items():
|
|
if k == 'item':
|
|
basename = os.path.basename(v['value'])
|
|
elif k == 'map':
|
|
url = v['value']
|
|
results[basename] = url
|
|
return results
|
|
|
|
|
|
def fetch_geoshapes(target, shape_urls):
|
|
os.makedirs(target, exist_ok=True)
|
|
candidates = {}
|
|
keep = {}
|
|
for item, url in tqdm.tqdm(shape_urls.items()):
|
|
try:
|
|
with urllib.request.urlopen(url) as resp:
|
|
shape = json.load(resp)
|
|
if not shape.get('license', 'proprietary').startswith('CC0-'):
|
|
# Only include public domain data
|
|
continue
|
|
candidates.setdefault(item, []).append(shape)
|
|
except urllib.error.HTTPError as e:
|
|
print(e)
|
|
for item, ican in candidates.items():
|
|
# Prefer zoom level 4
|
|
keep[item] = min(ican, key=lambda x: abs(4-x.get('zoom', 1000)))
|
|
for item, shape in keep.items():
|
|
with open(os.path.join(target, item + '.json'), 'w') as f:
|
|
json.dump(shape, f)
|
|
|
|
|
|
def fetch_wikidata_states(target):
|
|
shape_urls = sparql_query('''
|
|
|
|
PREFIX wd: <http://www.wikidata.org/entity/>
|
|
PREFIX wdt: <http://www.wikidata.org/prop/direct/>
|
|
|
|
SELECT DISTINCT ?item ?map WHERE {
|
|
# ?item is instance of federal state of germany and has geoshape ?map
|
|
?item wdt:P31 wd:Q1221156;
|
|
wdt:P3896 ?map
|
|
}
|
|
''')
|
|
print('Retrieving state border shapes')
|
|
fetch_geoshapes(target, shape_urls)
|
|
|
|
|
|
def fetch_wikidata_countries(target):
|
|
shape_urls = sparql_query('''
|
|
|
|
PREFIX wd: <http://www.wikidata.org/entity/>
|
|
PREFIX wdt: <http://www.wikidata.org/prop/direct/>
|
|
PREFIX p: <http://www.wikidata.org/prop/>
|
|
PREFIX ps: <http://www.wikidata.org/prop/statement/>
|
|
PREFIX wikibase: <http://wikiba.se/ontology#>
|
|
|
|
SELECT DISTINCT ?item ?map WHERE {
|
|
# ?item is instance of sovereign state, transitively part of europe and has geoshape ?map
|
|
# ?item is instance of country or sovereign state
|
|
?item wdt:P31 ?stateclass.
|
|
# ?item is transitively part of Europe (Contintent) or EEA
|
|
?item wdt:P361+ ?euroclass.
|
|
# ?item has geoshape ?map (including all non-deprecated results)
|
|
?item p:P3896 ?st.
|
|
?st ps:P3896 ?map;
|
|
MINUS { ?st wikibase:rank wikibase:DeprecatedRank }
|
|
FILTER (?stateclass = wd:Q6256 || ?stateclass = wd:Q3624078).
|
|
FILTER (?euroclass = wd:Q46 || ?euroclass = wd:Q8932).
|
|
}
|
|
''')
|
|
print('Retrieving country border shapes')
|
|
fetch_geoshapes(target, shape_urls)
|
|
|
|
|
|
def filter_boundingbox(source, target, bbox):
|
|
files = os.listdir(source)
|
|
os.makedirs(target, exist_ok=True)
|
|
print('Filtering countries outside the bounding box')
|
|
for f in tqdm.tqdm(files):
|
|
if not f.endswith('.json') or 'Q183.json' in f:
|
|
continue
|
|
path = os.path.join(source, f)
|
|
with open(path, 'r') as sf:
|
|
shapedata = sf.read()
|
|
shape = json.loads(shapedata)
|
|
keep = False
|
|
geo = shape['data']['features'][0]['geometry']
|
|
if geo['type'] == 'Polygon':
|
|
geo['coordinates'] = [geo['coordinates']]
|
|
for poly in geo['coordinates']:
|
|
for point in poly[0]:
|
|
if point[0] >= bbox[0][0] and point[1] >= bbox[0][1] \
|
|
and point[0] <= bbox[1][0] and point[1] <= bbox[1][1]:
|
|
keep = True
|
|
break
|
|
if keep:
|
|
break
|
|
if keep:
|
|
with open(os.path.join(target, f), 'w') as sf:
|
|
sf.write(shapedata)
|
|
|
|
|
|
def address_lookup(name, erfa):
|
|
locator = Nominatim(user_agent=USER_AGENT)
|
|
number = erfa['Chaostreff-Physical-Housenumber']
|
|
street = erfa['Chaostreff-Physical-Address']
|
|
zipcode = erfa['Chaostreff-Physical-Postcode']
|
|
acity = erfa['Chaostreff-Physical-City']
|
|
city = erfa['Chaostreff-City'][0]
|
|
country = erfa['Chaostreff-Country'][0]
|
|
|
|
formats = [
|
|
# Muttenz, Schweiz
|
|
f'{city}, {country}'
|
|
]
|
|
if zipcode and acity:
|
|
# 4132 Muttenz, Schweiz
|
|
formats.insert(0, f'{zipcode[0]} {acity[0]}, {country}')
|
|
if zipcode and acity and number and street:
|
|
# Birsfelderstrasse 6, 4132 Muttenz, Schweiz
|
|
formats.insert(0, f'{street[0]} {number[0]}, {zipcode[0]} {acity[0]}, {country}')
|
|
|
|
for fmt in formats:
|
|
response = locator.geocode(fmt)
|
|
if response is not None:
|
|
return response.longitude, response.latitude
|
|
|
|
print(f'No location found for {name}, tried the following address formats:')
|
|
for fmt in formats:
|
|
print(f' {fmt}')
|
|
return None
|
|
|
|
|
|
def fetch_erfas(target, url):
|
|
userpw = os.getenv('DOKU_CCC_DE_BASICAUTH')
|
|
if userpw is None:
|
|
print('Please set environment variable DOKU_CCC_DE_BASICAUTH=username:password')
|
|
exit(1)
|
|
auth = base64.b64encode(userpw.encode()).decode()
|
|
erfas = {}
|
|
req = urllib.request.Request(url, headers={'Authorization': f'Basic {auth}'})
|
|
with urllib.request.urlopen(req) as resp:
|
|
erfadata = json.loads(resp.read().decode())
|
|
print('Looking up addresses')
|
|
for name, erfa in tqdm.tqdm(erfadata['results'].items()):
|
|
location = address_lookup(name, erfa['printouts'])
|
|
if location is None:
|
|
print(f'WARNING: No location for {name}')
|
|
city = erfa['printouts']['Chaostreff-City'][0]
|
|
erfas[city] = location
|
|
with open(target, 'w') as f:
|
|
json.dump(erfas, f)
|
|
|
|
|
|
def compute_bbox(ns):
|
|
if ns.bbox is not None:
|
|
return [
|
|
(min(ns.bbox[0], ns.bbox[2]), min(ns.bbox[1], ns.bbox[3])),
|
|
(max(ns.bbox[0], ns.bbox[2]), max(ns.bbox[1], ns.bbox[3]))
|
|
]
|
|
|
|
print('Computing map bounding box')
|
|
bounds = []
|
|
for path in tqdm.tqdm([ns.cache_directory.erfa_info, ns.cache_directory.chaostreff_info]):
|
|
with open(path, 'r') as f:
|
|
erfadata = json.load(f)
|
|
for lon, lat in erfadata.values():
|
|
if len(bounds) == 0:
|
|
bounds.append(lon)
|
|
bounds.append(lat)
|
|
bounds.append(lon)
|
|
bounds.append(lat)
|
|
else:
|
|
bounds[0] = min(bounds[0], lon)
|
|
bounds[1] = min(bounds[1], lat)
|
|
bounds[2] = max(bounds[2], lon)
|
|
bounds[3] = max(bounds[3], lat)
|
|
return [
|
|
(bounds[0] - ns.bbox_margin, bounds[1] - ns.bbox_margin),
|
|
(bounds[2] + ns.bbox_margin, bounds[3] + ns.bbox_margin)
|
|
]
|
|
|
|
|
|
class BoundingBox:
|
|
|
|
def __init__(self, left, top, right=None, bottom=None, *, width=None, height=None, meta=None, base_weight=0):
|
|
self.left = left
|
|
self.top = top
|
|
self.right = right if width is None else left + width
|
|
self.bottom = bottom if height is None else top + height
|
|
self.meta = meta
|
|
self.base_weight = base_weight
|
|
self.finished = False
|
|
|
|
def __contains__(self, other):
|
|
if isinstance(other, BoundingBox):
|
|
if other.right < self.left or other.left > self.right:
|
|
return False
|
|
if other.bottom < self.top or other.top > self.bottom:
|
|
return False
|
|
return True
|
|
elif isinstance(other, tuple) or isinstance(other, list):
|
|
if len(other) != 2:
|
|
raise TypeError()
|
|
if self.left > other[0] or self.right < other[0]:
|
|
return False
|
|
if self.top > other[1] or self.bottom < other[1]:
|
|
return False
|
|
return True
|
|
raise TypeError()
|
|
|
|
def __add__(self, other):
|
|
if not isinstance(other, tuple) and not isinstance(other, list):
|
|
raise TypeError()
|
|
return BoundingBox(self.left + other[0], self.top + other[1],
|
|
self.right + other[0], self.bottom + other[1],
|
|
width=None, height=None, meta=self.meta, base_weight=self.base_weight)
|
|
|
|
def __iadd__(self, other):
|
|
if not isinstance(other, tuple) and not isinstance(other, list):
|
|
raise TypeError()
|
|
self.left += other[0]
|
|
self.top += other[1]
|
|
self.right += other[0]
|
|
self.bottom += other[1]
|
|
return self
|
|
|
|
def __sub__(self, other):
|
|
if not isinstance(other, tuple) and not isinstance(other, list):
|
|
raise TypeError()
|
|
return BoundingBox(self.left - other[0], self.top - other[1],
|
|
self.right - other[0], self.bottom - other[1],
|
|
width=None, height=None, meta=self.meta, base_weight=self.base_weight)
|
|
|
|
def __isub__(self, other):
|
|
if not isinstance(other, tuple) and not isinstance(other, list):
|
|
raise TypeError()
|
|
self.left -= other[0]
|
|
self.top -= other[1]
|
|
self.right -= other[0]
|
|
self.bottom -= other[1]
|
|
self._weight = None
|
|
return self
|
|
|
|
@property
|
|
def width(self):
|
|
return self.right - self.left
|
|
|
|
@property
|
|
def height(self):
|
|
return self.bottom - self.top
|
|
|
|
@property
|
|
def center(self):
|
|
return (self.left + self.width/2, self.top + self.height/2)
|
|
|
|
def distance2(self, other):
|
|
c1 = self.center
|
|
c2 = other.center
|
|
return (c1[0] - c2[0])**2 + (c1[1] - c2[1])**2
|
|
|
|
def with_margin(self, margin):
|
|
return BoundingBox(self.left - margin, self.top - margin,
|
|
self.right + margin, self.bottom + margin,
|
|
width=None, height=None, meta=self.meta, base_weight=self.base_weight)
|
|
|
|
def chebyshev_distance(self, other):
|
|
if other in self:
|
|
return 0
|
|
if isinstance(other, BoundingBox):
|
|
if other.left < self.left < other.right or other.left < self.right < other.right:
|
|
dh = 0
|
|
else:
|
|
dh = min(abs(self.left - other.right), abs(self.right - other.left))
|
|
if other.top < self.top < other.bottom or other.top < self.bottom < other.bottom:
|
|
dv = 0
|
|
else:
|
|
dv = min(abs(self.top - other.bottom), abs(self.bottom - other.top))
|
|
return max(dh, dv)
|
|
elif isinstance(other, tuple) or isinstance(other, list):
|
|
if self.left < other[0] < self.right:
|
|
dh = 0
|
|
else:
|
|
dh = min(abs(self.left - other[0]), abs(self.right - other[0]))
|
|
if self.top < other[1] < self.bottom:
|
|
dv = 0
|
|
else:
|
|
dv = min(abs(self.top - other[1]), abs(self.bottom - other[1]))
|
|
return max(dh, dv)
|
|
else:
|
|
raise TypeError()
|
|
|
|
def compute_weight(self, other, erfas, chaostreffs, pdist, ns):
|
|
w = 0
|
|
swm = self.with_margin(pdist)
|
|
swe = self.with_margin(ns.dotsize_erfa)
|
|
swc = self.with_margin(ns.dotsize_treff)
|
|
swme = swm.with_margin(ns.dotsize_erfa)
|
|
swmc = swm.with_margin(ns.dotsize_treff)
|
|
# I hope these weights are somewhat reasonably balanced...
|
|
for o in other:
|
|
if o.meta['city'] == self.meta['city']:
|
|
continue
|
|
if o in self:
|
|
if o.finished:
|
|
w += 1000
|
|
else:
|
|
w += 50
|
|
else:
|
|
w += max(pdist*2 - swc.chebyshev_distance(o), 0)
|
|
continue
|
|
if o in swm:
|
|
if o.finished:
|
|
w += 3
|
|
else:
|
|
w += 1
|
|
for city, location in erfas.items():
|
|
if city == self.meta['city']:
|
|
continue
|
|
if location in swe:
|
|
w += 1000
|
|
else:
|
|
w += max(pdist*2 - swe.chebyshev_distance(location), 0)
|
|
for city, location in chaostreffs.items():
|
|
if city == self.meta['city']:
|
|
continue
|
|
if location in swc:
|
|
w += 1000
|
|
else:
|
|
w += max(pdist*2 - swc.chebyshev_distance(location), 0)
|
|
self._weight = w
|
|
|
|
@property
|
|
def weight(self):
|
|
return self._weight + self.base_weight
|
|
|
|
@property
|
|
def is_optimal(self):
|
|
return self._weight == 0
|
|
|
|
def __str__(self):
|
|
return f'(({int(self.left)}, {int(self.top)}, {int(self.right)}, {int(self.bottom)}), weight={self.weight})'
|
|
|
|
|
|
def optimize_text_layout(ns, erfas, chaostreffs, size, svg):
|
|
font = ImageFont.truetype(ns.font, ns.font_size)
|
|
pil = ImageDraw(Image.new('P', (1, 1)))
|
|
xheight = -pil.textbbox((0,0), 'x', font=font, anchor='ls')[1]
|
|
capheight = -pil.textbbox((0,0), 'A', font=font, anchor='ls')[1]
|
|
voffset = - capheight / 2
|
|
|
|
candidates = {}
|
|
for city, location in erfas.items():
|
|
text = city
|
|
erfax, erfay = location
|
|
for rfrom, to in ns.rename:
|
|
if rfrom == city:
|
|
text = to
|
|
break
|
|
|
|
meta = {'city': city, 'text': text, 'baseline': capheight}
|
|
textbox = pil.textbbox((0, 0), text, font=font, anchor='ls') # left, baseline at 0,0
|
|
mw, mh = textbox[2] - textbox[0], textbox[3] - textbox[1]
|
|
rbox = BoundingBox(erfax + ns.font_distance, erfay + voffset, width=mw, height=mh, meta=meta)
|
|
lbox = BoundingBox(erfax - ns.font_distance - mw, erfay + voffset, width=mw, height=mh, meta=meta)
|
|
if erfax > 0.8 * size[0]:
|
|
rbox.base_weight += 0.001
|
|
else:
|
|
lbox.base_weight += 0.001
|
|
candidates[city] = [lbox, rbox]
|
|
for i in range(-2, 3):
|
|
if i == 0:
|
|
continue
|
|
candidates[city].append(lbox + (0, ns.dotsize_erfa*i))
|
|
candidates[city].append(rbox + (0, ns.dotsize_erfa*i))
|
|
candidates[city].extend([
|
|
BoundingBox(erfax - mw/2, erfay - ns.font_distance - mh, width=mw, height=mh, meta=meta, base_weight=0.001),
|
|
BoundingBox(erfax - mw/2, erfay + ns.font_distance, width=mw, height=mh, meta=meta, base_weight=0.001),
|
|
BoundingBox(erfax - ns.dotsize_erfa, erfay - ns.font_distance - mh, width=mw, height=mh, meta=meta, base_weight=0.002),
|
|
BoundingBox(erfax - ns.dotsize_erfa, erfay + ns.font_distance, width=mw, height=mh, meta=meta, base_weight=0.003),
|
|
BoundingBox(erfax + ns.dotsize_erfa - mw, erfay - ns.font_distance - mh, width=mw, height=mh, meta=meta, base_weight=0.001),
|
|
BoundingBox(erfax + ns.dotsize_erfa - mw, erfay + ns.font_distance, width=mw, height=mh, meta=meta, base_weight=0.001),
|
|
])
|
|
rbox.base_weight -= 0.003
|
|
lbox.base_weight -= 0.003
|
|
|
|
if ns.debug:
|
|
for c in candidates[city]:
|
|
di = etree.Element('rect', x=str(c.left), y=str(c.top + capheight - xheight), width=str(c.width), height=str(xheight))
|
|
di.set('class', 'debugright')
|
|
dr = etree.Element('rect', x=str(c.left), y=str(c.top), width=str(c.width), height=str(c.height))
|
|
dr.set('class', 'debugleft')
|
|
svg.append(di)
|
|
svg.append(dr)
|
|
|
|
|
|
unfinished = {c for c in erfas.keys()}
|
|
finished = {}
|
|
|
|
with tqdm.tqdm(total=len(erfas)) as progress:
|
|
while len(unfinished) > 0:
|
|
progress.update(len(erfas) - len(unfinished))
|
|
|
|
all_boxes = set(finished.values())
|
|
unfinished_boxes = set()
|
|
for city in unfinished:
|
|
all_boxes.update(candidates[city])
|
|
unfinished_boxes.update(candidates[city])
|
|
for box in all_boxes:
|
|
box.compute_weight(all_boxes, erfas, chaostreffs, pdist=max(ns.font_distance, xheight), ns=ns)
|
|
|
|
# Get candidate with the least number of optimal solutions > 0
|
|
optcity = min(unfinished, key=lambda city: len([1 for box in candidates[city] if box.is_optimal]) or float('inf'))
|
|
optboxes = [box for box in candidates[optcity] if box.is_optimal]
|
|
if len(optboxes) > 0:
|
|
finished[optcity] = min(optboxes, key=lambda box: box.weight)
|
|
finished[optcity].finished = True
|
|
unfinished.discard(optcity)
|
|
continue
|
|
|
|
# If no candidate with at least one optimal solution is left, go by global minimum
|
|
minbox = min(unfinished_boxes, key=lambda box: box.weight)
|
|
mincity = minbox.meta['city']
|
|
finished[mincity] = minbox
|
|
minbox.finished = True
|
|
unfinished.discard(mincity)
|
|
|
|
# Iteratively improve the layout
|
|
for i in tqdm.tqdm(range(len(finished))):
|
|
changed = False
|
|
order = list(finished.keys())
|
|
random.shuffle(order)
|
|
for city in order:
|
|
all_boxes = set(finished.values())
|
|
for box in candidates[city]:
|
|
box.compute_weight(all_boxes, erfas, chaostreffs, pdist=max(ns.font_distance, xheight), ns=ns)
|
|
minbox = min(candidates[city], key=lambda box: box.weight)
|
|
if minbox is not finished[city]:
|
|
changed = True
|
|
finished[city] = minbox
|
|
minbox.finished = True
|
|
if not changed:
|
|
# Nothing changed in this iteration - no need to retry
|
|
break
|
|
|
|
return finished
|
|
|
|
|
|
def create_svg(ns, bbox):
|
|
print('Creating SVG image')
|
|
|
|
# Convert from WGS84 lon, lat to chosen projection
|
|
transformer = pyproj.Transformer.from_crs('epsg:4326', ns.projection)
|
|
scalex = ns.scale_x
|
|
scaley = ns.scale_y
|
|
blt = transformer.transform(*bbox[0])
|
|
trt = transformer.transform(*bbox[1])
|
|
trans_bounding_box = [
|
|
(scalex*blt[0], scaley*trt[1]),
|
|
(scalex*trt[0], scaley*blt[1])
|
|
]
|
|
origin = trans_bounding_box[0]
|
|
svg_box = (trans_bounding_box[1][0] - origin[0], origin[1] - trans_bounding_box[1][1])
|
|
|
|
shapes_states = []
|
|
files = os.listdir(ns.cache_directory.shapes_states)
|
|
for f in files:
|
|
if not f.endswith('.json'):
|
|
continue
|
|
path = os.path.join(ns.cache_directory.shapes_states, f)
|
|
with open(path, 'r') as sf:
|
|
shapedata = sf.read()
|
|
shape = json.loads(shapedata)
|
|
name = shape['description']['en']
|
|
geo = shape['data']['features'][0]['geometry']
|
|
if geo['type'] == 'Polygon':
|
|
geo['coordinates'] = [geo['coordinates']]
|
|
for poly in geo['coordinates']:
|
|
ts = []
|
|
for x, y in poly[0]:
|
|
xt, yt = transformer.transform(x, y)
|
|
ts.append((xt*scalex - origin[0], origin[1] - yt*scaley))
|
|
shapes_states.append((name, ts))
|
|
|
|
shapes_countries = []
|
|
files = os.listdir(ns.cache_directory.shapes_filtered)
|
|
for f in files:
|
|
if not f.endswith('.json'):
|
|
continue
|
|
path = os.path.join(ns.cache_directory.shapes_filtered, f)
|
|
with open(path, 'r') as sf:
|
|
shapedata = sf.read()
|
|
shape = json.loads(shapedata)
|
|
name = shape['description']['en']
|
|
geo = shape['data']['features'][0]['geometry']
|
|
if geo['type'] == 'Polygon':
|
|
geo['coordinates'] = [geo['coordinates']]
|
|
for poly in geo['coordinates']:
|
|
ts = []
|
|
for x, y in poly[0]:
|
|
xt, yt = transformer.transform(x, y)
|
|
ts.append((xt*scalex - origin[0], origin[1] - yt*scaley))
|
|
shapes_countries.append((name, ts))
|
|
|
|
erfas = {}
|
|
with open(ns.cache_directory.erfa_info, 'r') as f:
|
|
ctdata = json.load(f)
|
|
for city, location in ctdata.items():
|
|
if location is None:
|
|
continue
|
|
xt, yt = transformer.transform(*location)
|
|
erfas[city] = (xt*scalex - origin[0], origin[1] - yt*scaley)
|
|
|
|
chaostreffs = {}
|
|
with open(ns.cache_directory.chaostreff_info, 'r') as f:
|
|
ctdata = json.load(f)
|
|
for city, location in ctdata.items():
|
|
if location is None:
|
|
continue
|
|
if city in erfas:
|
|
# There is an edge case where when a space changed states between Erfa and Chaostreff, the
|
|
# Semantic MediaWiki engine returns this space as both an Erfa and a Chaostreff, resulting
|
|
# in glitches in the rendering. As a workaround, here we simply assume that it's an Erfa.
|
|
continue
|
|
xt, yt = transformer.transform(*location)
|
|
chaostreffs[city] = (xt*scalex - origin[0], origin[1] - yt*scaley)
|
|
|
|
|
|
rectbox = [0, 0, svg_box[0], svg_box[1]]
|
|
for name, shape in shapes_states + shapes_countries:
|
|
for lon, lat in shape:
|
|
rectbox[0] = min(lon, rectbox[0])
|
|
rectbox[1] = min(lat, rectbox[1])
|
|
rectbox[2] = max(lon, rectbox[2])
|
|
rectbox[3] = max(lat, rectbox[3])
|
|
|
|
|
|
svg = etree.Element('svg',
|
|
xmlns='http://www.w3.org/2000/svg',
|
|
viewBox=f'0 0 {svg_box[0]} {svg_box[1]}',
|
|
width=str(svg_box[0]), height=str(svg_box[1]))
|
|
|
|
defs = etree.Element('defs')
|
|
style = etree.Element('style', type='text/css')
|
|
style.text = f'@import url({ns.stylesheet})'
|
|
defs.append(style)
|
|
svg.append(defs)
|
|
|
|
bg = etree.Element('rect',
|
|
id='background',
|
|
x=str(rectbox[0]),
|
|
y=str(rectbox[1]),
|
|
width=str(rectbox[3]-rectbox[1]),
|
|
height=str(rectbox[2]-rectbox[0]))
|
|
bg.set('class', 'background')
|
|
svg.append(bg)
|
|
|
|
for name, shape in shapes_countries:
|
|
points = ' '.join([f'{lon},{lat}' for lon, lat in shape])
|
|
poly = etree.Element('polygon', points=points)
|
|
poly.set('class', 'country')
|
|
poly.set('data-country', name)
|
|
svg.append(poly)
|
|
|
|
# Render shortest shapes last s.t. Berlin, Hamburg and Bremen are rendered on top of their surrounding states
|
|
for name, shape in sorted(shapes_states, key=lambda x: -sum(len(s) for s in x[1])):
|
|
points = ' '.join([f'{lon},{lat}' for lon, lat in shape])
|
|
poly = etree.Element('polygon', points=points)
|
|
poly.set('class', 'state')
|
|
poly.set('data-state', name)
|
|
svg.append(poly)
|
|
|
|
for city, location in erfas.items():
|
|
circle = etree.Element('circle', cx=str(location[0]), cy=str(location[1]), r=str(ns.dotsize_erfa))
|
|
circle.set('class', 'erfa')
|
|
circle.set('data-erfa', city)
|
|
svg.append(circle)
|
|
|
|
for city, location in chaostreffs.items():
|
|
circle = etree.Element('circle', cx=str(location[0]), cy=str(location[1]), r=str(ns.dotsize_treff))
|
|
circle.set('class', 'chaostreff')
|
|
circle.set('data-chaostreff', city)
|
|
svg.append(circle)
|
|
|
|
|
|
print('Layouting labels')
|
|
texts = optimize_text_layout(ns, erfas, chaostreffs, (int(svg_box[0]), int(svg_box[1])), svg)
|
|
for city, box in texts.items():
|
|
text = etree.Element('text', x=str(box.left), y=str(box.top + box.meta['baseline']))
|
|
text.set('class', 'erfalabel')
|
|
text.set('data-erfa', city)
|
|
text.text = box.meta['text']
|
|
svg.append(text)
|
|
|
|
print('Done, writing SVG')
|
|
with open('map.svg', 'wb') as mapfile:
|
|
root = etree.ElementTree(svg)
|
|
root.write(mapfile)
|
|
|
|
print('Done, writing PNG')
|
|
cairosvg.svg2png(url='map.svg', write_to='map.png')
|
|
print('Done')
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(sys.argv[0])
|
|
ap.add_argument('--cache-directory', type=CachePaths, default='cache', help='Path to the cache directory')
|
|
ap.add_argument('--update-borders', action='store_true', default=False, help='Update country borders from Wikidata')
|
|
ap.add_argument('--update-erfalist', action='store_true', default=False, help='Update Erfa/Chaostreff list from doku.ccc.de')
|
|
ap.add_argument('--bbox', type=float, nargs=4, metavar=('LON', 'LAT', 'LON', 'LAT') ,default=None, help='Override map bounding box')
|
|
ap.add_argument('--bbox-margin', type=float, default=0.3, help='Margin around the inferred bounding box. Ignored with --bbox')
|
|
ap.add_argument('--stylesheet', type=str, default='style/erfamap.css', help='Stylesheet for the generated SVG')
|
|
ap.add_argument('--font', type=str, default='style/concertone-regular.ttf', help='Name of the font used in the stylesheet.')
|
|
ap.add_argument('--font-size', type=int, default=45, help='Size of the font used in the stylesheet.')
|
|
ap.add_argument('--font-distance', type=int, default=18, help='Distance of labels from their dots center')
|
|
ap.add_argument('--dotsize-erfa', type=float, default=13, help='Radius of Erfa dots')
|
|
ap.add_argument('--dotsize-treff', type=float, default=8, help='Radius of Chaostreff dots')
|
|
ap.add_argument('--rename', type=str, action='append', nargs=2, metavar=('FROM', 'TO'), default=[], help='Rename a city with an overly long name (e.g. "Rothenburg ob der Tauber" to "Rothenburg")')
|
|
ap.add_argument('--projection', type=str, default='epsg:4258', help='Map projection to convert the WGS84 coordinates to')
|
|
ap.add_argument('--scale-x', type=float, default=130, help='X axis scale to apply after projecting')
|
|
ap.add_argument('--scale-y', type=float, default=200, help='Y axis scale to apply after projecting')
|
|
ap.add_argument('--debug', action='store_true', default=False, help='Add debug information to the produced SVG')
|
|
|
|
ns = ap.parse_args(sys.argv[1:])
|
|
|
|
if ns.update_borders or not os.path.isdir(ns.cache_directory.shapes_countries):
|
|
if os.path.isdir(ns.cache_directory.shapes_countries):
|
|
shutil.rmtree(ns.cache_directory.shapes_countries)
|
|
fetch_wikidata_countries(target=ns.cache_directory.shapes_countries)
|
|
|
|
if ns.update_borders or not os.path.isdir(ns.cache_directory.shapes_states):
|
|
if os.path.isdir(ns.cache_directory.shapes_states):
|
|
shutil.rmtree(ns.cache_directory.shapes_states)
|
|
fetch_wikidata_states(target=ns.cache_directory.shapes_states)
|
|
|
|
if ns.update_erfalist or not os.path.isfile(ns.cache_directory.erfa_info):
|
|
if os.path.exists(ns.cache_directory.erfa_info):
|
|
os.unlink(ns.cache_directory.erfa_info)
|
|
fetch_erfas(target=ns.cache_directory.erfa_info, url=ERFA_URL)
|
|
|
|
if ns.update_erfalist or not os.path.isfile(ns.cache_directory.chaostreff_info):
|
|
if os.path.exists(ns.cache_directory.chaostreff_info):
|
|
os.unlink(ns.cache_directory.chaostreff_info)
|
|
fetch_erfas(target=ns.cache_directory.chaostreff_info, url=CHAOSTREFF_URL)
|
|
|
|
bbox = compute_bbox(ns)
|
|
|
|
filter_boundingbox(ns.cache_directory.shapes_countries, ns.cache_directory.shapes_filtered, bbox)
|
|
|
|
create_svg(ns, bbox)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|