mirror of
https://github.com/enzet/map-machine.git
synced 2025-04-30 18:57:49 +02:00
406 lines
13 KiB
Python
406 lines
13 KiB
Python
"""
|
|
Röntgen drawing scheme.
|
|
"""
|
|
from dataclasses import dataclass
|
|
from enum import Enum
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional, Set, Tuple, Union
|
|
|
|
import yaml
|
|
from colour import Color
|
|
|
|
from roentgen.direction import DirectionSet
|
|
from roentgen.icon import (
|
|
DEFAULT_COLOR, DEFAULT_SHAPE_ID, Icon, IconSet, ShapeExtractor,
|
|
ShapeSpecification
|
|
)
|
|
from roentgen.text import Label, get_address, get_text
|
|
|
|
__author__ = "Sergey Vartanov"
|
|
__email__ = "me@enzet.ru"
|
|
|
|
|
|
@dataclass
|
|
class LineStyle:
|
|
"""
|
|
SVG line style and its priority.
|
|
"""
|
|
style: Dict[str, Union[int, float, str]]
|
|
priority: float = 0.0
|
|
|
|
|
|
class MatchingType(Enum):
|
|
"""
|
|
Description on how tag was matched.
|
|
"""
|
|
NOT_MATCHED = 0
|
|
MATCHED_BY_SET = 1
|
|
MATCHED_BY_WILDCARD = 2
|
|
MATCHED = 3
|
|
|
|
|
|
def is_matched_tag(
|
|
matcher_tag_key: str, matcher_tag_value: Union[str, list],
|
|
tags: Dict[str, str]
|
|
) -> MatchingType:
|
|
"""
|
|
Check whether element tags contradict tag matcher.
|
|
|
|
:param matcher_tag_key: tag key
|
|
:param matcher_tag_value: tag value, tag value list, or "*"
|
|
:param tags: element tags to check
|
|
"""
|
|
if matcher_tag_key in tags:
|
|
if matcher_tag_value == "*":
|
|
return MatchingType.MATCHED_BY_WILDCARD
|
|
if (
|
|
isinstance(matcher_tag_value, str) and
|
|
tags[matcher_tag_key] == matcher_tag_value
|
|
):
|
|
return MatchingType.MATCHED
|
|
if (
|
|
isinstance(matcher_tag_value, list) and
|
|
tags[matcher_tag_key] in matcher_tag_value
|
|
):
|
|
return MatchingType.MATCHED_BY_SET
|
|
return MatchingType.NOT_MATCHED
|
|
|
|
|
|
def is_matched(matcher: Dict[str, Any], tags: Dict[str, str]) -> bool:
|
|
"""
|
|
Check whether element tags matches tag matcher.
|
|
|
|
:param matcher: dictionary with tag keys and values, value lists, or "*"
|
|
:param tags: element tags to match
|
|
"""
|
|
matched: bool = True
|
|
|
|
for config_tag_key in matcher["tags"]:
|
|
config_tag_key: str
|
|
tag_matcher = matcher["tags"][config_tag_key]
|
|
if (
|
|
is_matched_tag(config_tag_key, tag_matcher, tags) ==
|
|
MatchingType.NOT_MATCHED
|
|
):
|
|
matched = False
|
|
break
|
|
|
|
if "no_tags" in matcher:
|
|
for config_tag_key in matcher["no_tags"]:
|
|
config_tag_key: str
|
|
tag_matcher = matcher["no_tags"][config_tag_key]
|
|
if (
|
|
is_matched_tag(config_tag_key, tag_matcher, tags) !=
|
|
MatchingType.NOT_MATCHED
|
|
):
|
|
matched = False
|
|
break
|
|
|
|
return matched
|
|
|
|
|
|
class Scheme:
|
|
"""
|
|
Map style.
|
|
|
|
Specifies map colors and rules to draw icons for OpenStreetMap tags.
|
|
"""
|
|
def __init__(self, file_name: Path):
|
|
"""
|
|
:param file_name: name of the scheme file with tags, colors, and tag key
|
|
specification
|
|
"""
|
|
with file_name.open() as input_file:
|
|
content: Dict[str, Any] = yaml.load(
|
|
input_file.read(), Loader=yaml.FullLoader)
|
|
|
|
self.icons: List[Dict[str, Any]] = content["node_icons"]
|
|
self.ways: List[Dict[str, Any]] = content["ways"]
|
|
|
|
self.colors: Dict[str, str] = content["colors"]
|
|
|
|
self.area_tags: List[Dict[str, str]] = content["area_tags"]
|
|
|
|
self.tags_to_write: List[str] = content["tags_to_write"]
|
|
self.prefix_to_write: List[str] = content["prefix_to_write"]
|
|
self.tags_to_skip: List[str] = content["tags_to_skip"]
|
|
self.prefix_to_skip: List[str] = content["prefix_to_skip"]
|
|
|
|
# Storage for created icon sets.
|
|
self.cache: Dict[str, Tuple[IconSet, int]] = {}
|
|
|
|
def get_color(self, color: str) -> Color:
|
|
"""
|
|
Return color if the color is in scheme, otherwise return default color.
|
|
|
|
:param color: input color string representation
|
|
:return: 6-digit color specification with "#"
|
|
"""
|
|
if color in self.colors:
|
|
return Color(self.colors[color])
|
|
if color.lower() in self.colors:
|
|
return Color(self.colors[color.lower()])
|
|
try:
|
|
return Color(color)
|
|
except ValueError:
|
|
return DEFAULT_COLOR
|
|
|
|
def is_no_drawable(self, key: str) -> bool:
|
|
"""
|
|
Return true if key is specified as no drawable (should not be
|
|
represented on the map as icon set or as text) by the scheme.
|
|
|
|
:param key: OpenStreetMap tag key
|
|
"""
|
|
if key in self.tags_to_write or key in self.tags_to_skip:
|
|
return True
|
|
for prefix in self.prefix_to_write + self.prefix_to_skip: # type: str
|
|
if key[:len(prefix) + 1] == f"{prefix}:":
|
|
return True
|
|
return False
|
|
|
|
def is_writable(self, key: str) -> bool:
|
|
"""
|
|
Return true if key is specified as writable (should be represented on
|
|
the map as text) by the scheme.
|
|
|
|
:param key: OpenStreetMap tag key
|
|
"""
|
|
if key in self.tags_to_skip:
|
|
return False
|
|
if key in self.tags_to_write:
|
|
return True
|
|
for prefix in self.prefix_to_write: # type: str
|
|
if key[:len(prefix) + 1] == f"{prefix}:":
|
|
return True
|
|
return False
|
|
|
|
def get_icon(
|
|
self,
|
|
icon_extractor: ShapeExtractor,
|
|
tags: Dict[str, Any],
|
|
for_: str = "node",
|
|
) -> Tuple[IconSet, int]:
|
|
"""
|
|
Construct icon set.
|
|
|
|
:param icon_extractor: extractor with icon specifications
|
|
:param tags: OpenStreetMap element tags dictionary
|
|
:param for_: target (node, way, area or relation)
|
|
:return (icon set, icon priority)
|
|
"""
|
|
tags_hash: str = (
|
|
",".join(tags.keys()) + ":" + ",".join(map(str, tags.values()))
|
|
)
|
|
if tags_hash in self.cache:
|
|
return self.cache[tags_hash]
|
|
|
|
main_icon: Optional[Icon] = None
|
|
extra_icons: List[Icon] = []
|
|
processed: Set[str] = set()
|
|
priority: int = 0
|
|
|
|
index: int = 0
|
|
|
|
for group in self.icons:
|
|
for matcher in group["tags"]:
|
|
matcher: Dict[str, Any]
|
|
matched: bool = is_matched(matcher, tags)
|
|
matcher_tags: Set[str] = matcher["tags"].keys()
|
|
if not matched:
|
|
continue
|
|
priority = len(self.icons) - index
|
|
if "draw" in matcher and not matcher["draw"]:
|
|
processed |= set(matcher_tags)
|
|
if "icon" in matcher:
|
|
main_icon = Icon([
|
|
ShapeSpecification.from_structure(x, icon_extractor, self)
|
|
for x in matcher["icon"]
|
|
])
|
|
processed |= set(matcher_tags)
|
|
if "over_icon" in matcher:
|
|
if main_icon:
|
|
main_icon.add_specifications([
|
|
ShapeSpecification.from_structure(
|
|
x, icon_extractor, self
|
|
)
|
|
for x in matcher["over_icon"]
|
|
])
|
|
for key in matcher_tags:
|
|
processed.add(key)
|
|
if "add_icon" in matcher:
|
|
extra_icons += [Icon([
|
|
ShapeSpecification.from_structure(
|
|
x, icon_extractor, self, Color("#888888")
|
|
)
|
|
for x in matcher["add_icon"]
|
|
])]
|
|
for key in matcher_tags:
|
|
processed.add(key)
|
|
if "color" in matcher:
|
|
assert False
|
|
if "set_main_color" in matcher:
|
|
main_icon.recolor(self.get_color(matcher["set_main_color"]))
|
|
|
|
index += 1
|
|
|
|
color: Optional[Color] = None
|
|
|
|
for tag_key in tags: # type: str
|
|
if (tag_key.endswith(":color") or
|
|
tag_key.endswith(":colour")):
|
|
color = self.get_color(tags[tag_key])
|
|
processed.add(tag_key)
|
|
|
|
for tag_key in tags: # type: str
|
|
if tag_key in ["color", "colour"]:
|
|
color = self.get_color(tags[tag_key])
|
|
processed.add(tag_key)
|
|
|
|
if main_icon and color:
|
|
main_icon.recolor(color)
|
|
|
|
keys_left = [
|
|
x for x in tags.keys()
|
|
if x not in processed and not self.is_no_drawable(x)
|
|
]
|
|
|
|
default_shape = icon_extractor.get_shape(DEFAULT_SHAPE_ID)
|
|
if not main_icon:
|
|
main_icon = Icon([ShapeSpecification(default_shape)])
|
|
|
|
returned: IconSet = IconSet(main_icon, extra_icons, processed)
|
|
self.cache[tags_hash] = returned, priority
|
|
|
|
if "direction" in tags:
|
|
if DirectionSet(tags["direction"]).is_right() is False:
|
|
for specification in main_icon.shape_specifications:
|
|
if specification.shape.is_right_directed:
|
|
specification.flip_horizontally = True
|
|
|
|
return returned, priority
|
|
|
|
def get_style(self, tags: Dict[str, Any], scale):
|
|
"""
|
|
Get line style based on tags and scale.
|
|
"""
|
|
line_styles = []
|
|
|
|
for element in self.ways: # type: Dict[str, Any]
|
|
priority = 0
|
|
matched: bool = is_matched(element, tags)
|
|
if not matched:
|
|
continue
|
|
style: Dict[str, Any] = {"fill": "none"}
|
|
if "priority" in element:
|
|
priority = element["priority"]
|
|
for key in element: # type: str
|
|
if key not in [
|
|
"tags", "no_tags", "priority", "level", "icon", "r", "r1",
|
|
"r2"
|
|
]:
|
|
value = element[key]
|
|
if isinstance(value, str) and value.endswith("_color"):
|
|
value = self.get_color(value)
|
|
style[key] = value
|
|
if "r" in element:
|
|
style["stroke-width"] = (element["r"] * scale)
|
|
if "r1" in element:
|
|
style["stroke-width"] = (element["r1"] * scale + 1)
|
|
if "r2" in element:
|
|
style["stroke-width"] = (element["r2"] * scale + 2)
|
|
|
|
line_styles.append(LineStyle(style, priority))
|
|
|
|
return line_styles
|
|
|
|
def construct_text(
|
|
self, tags: Dict[str, str], draw_captions: str
|
|
) -> List[Label]:
|
|
"""
|
|
Construct labels for not processed tags.
|
|
"""
|
|
texts: List[Label] = []
|
|
|
|
name = None
|
|
alt_name = None
|
|
if "name" in tags:
|
|
name = tags["name"]
|
|
tags.pop("name", None)
|
|
if "name:ru" in tags:
|
|
if not name:
|
|
name = tags["name:ru"]
|
|
tags.pop("name:ru", None)
|
|
tags.pop("name:ru", None)
|
|
if "name:en" in tags:
|
|
if not name:
|
|
name = tags["name:en"]
|
|
tags.pop("name:en", None)
|
|
tags.pop("name:en", None)
|
|
if "alt_name" in tags:
|
|
if alt_name:
|
|
alt_name += ", "
|
|
else:
|
|
alt_name = ""
|
|
alt_name += tags["alt_name"]
|
|
tags.pop("alt_name")
|
|
if "old_name" in tags:
|
|
if alt_name:
|
|
alt_name += ", "
|
|
else:
|
|
alt_name = ""
|
|
alt_name += "ex " + tags["old_name"]
|
|
|
|
address: List[str] = get_address(tags, draw_captions)
|
|
|
|
if name:
|
|
texts.append(Label(name, Color("black")))
|
|
if alt_name:
|
|
texts.append(Label(f"({alt_name})"))
|
|
if address:
|
|
texts.append(Label(", ".join(address)))
|
|
|
|
if draw_captions == "main":
|
|
return texts
|
|
|
|
texts += get_text(tags)
|
|
|
|
if "route_ref" in tags:
|
|
texts.append(Label(tags["route_ref"].replace(";", " ")))
|
|
tags.pop("route_ref", None)
|
|
if "cladr:code" in tags:
|
|
texts.append(Label(tags["cladr:code"], size=7))
|
|
tags.pop("cladr:code", None)
|
|
if "website" in tags:
|
|
link = tags["website"]
|
|
if link[:7] == "http://":
|
|
link = link[7:]
|
|
if link[:8] == "https://":
|
|
link = link[8:]
|
|
if link[:4] == "www.":
|
|
link = link[4:]
|
|
if link[-1] == "/":
|
|
link = link[:-1]
|
|
link = link[:25] + ("..." if len(tags["website"]) > 25 else "")
|
|
texts.append(Label(link, Color("#000088")))
|
|
tags.pop("website", None)
|
|
for key in ["phone"]:
|
|
if key in tags:
|
|
texts.append(Label(tags[key], Color("#444444")))
|
|
tags.pop(key)
|
|
if "height" in tags:
|
|
texts.append(Label(f"↕ {tags['height']} m"))
|
|
tags.pop("height")
|
|
for tag in tags:
|
|
if self.is_writable(tag):
|
|
texts.append(Label(tags[tag]))
|
|
return texts
|
|
|
|
def is_area(self, tags: Dict[str, str]) -> bool:
|
|
"""
|
|
Check whether way described by tags is area.
|
|
"""
|
|
for matcher in self.area_tags:
|
|
if is_matched(matcher, tags):
|
|
return True
|
|
return False
|