Reference

Render SVG

tile_renderer.render_svg.render_svg(components: list[Component], skin: Skin, zoom: int) → SVG

Render tiles

tile_renderer.render_tiles.render_tiles(components: list[Component], skin: Skin, zoom: int, max_zoom_range: int, tile_size: int, offset: Coord = Coord(0, 0), processes: int = 8, chunk_size: int = 8) → dict[TileCoord, bytes]

Utility classes

class tile_renderer.colour.Colour(h: float, s: float, l: float)

property b

brightened(by: float = 30.0) → Self

darkened(by: float = 30.0) → Self

classmethod from_hex(h: int | str)

classmethod from_rgb(r: float, g: float, b: float)

property g

h: float

l: float

property r

property rgb: tuple[float, float, float]

s: float

class tile_renderer.coord.Bounds(x_max: 'T', x_min: 'T', y_max: 'T', y_min: 'T')

x_max: T

x_min: T

y_max: T

y_min: T

class tile_renderer.coord.Coord(x: 'T', y: 'T')

property shapely: Point

to_float() → Coord[float]

to_int() → Coord[int]

class tile_renderer.coord.Line(coords: 'list[Coord[T]]')

property bounds: Bounds[float]

coords: list[Coord[T]]

dash(dash_length: float, shift: bool = False) → list[Line[float]] | None

classmethod decode(obj: list[tuple[T, T]]) → Self

encode() → list[tuple[T, T]]

parallel_offset(distance: float) → Self | Line[float]

property point_on_surface: Coord[float]

property shapely: LineString

property shapely_poly: Polygon | None

to_float() → Line[float]

to_int() → Line[int]

class tile_renderer.coord.TileCoord(z: 'int', x: 'int', y: 'int')

bounds(max_zoom_range: int) → Bounds[int]

x: int

y: int

z: int

class tile_renderer.coord.Vector(x: 'T', y: 'T')

as_tuple() → tuple[T, T]

classmethod decode(obj: tuple[T, T]) → Self

dot(other: Vector[int]) → int

dot(other: Vector[int] | Vector[float]) → float

dot(other: Vector[float]) → float

encode() → tuple[T, T]

perp() → Self

to_float() → Vector[float]

to_int() → Vector[int]

unit() → Vector[float]

x: T

y: T

Skin

class tile_renderer.skin.__init__.AreaBorderText(size: int | float, colour: Colour | None = None, offset: int | float = 0, *, zoom_multiplier: float = 1.5)

colour: Colour | None

encode() → _SerAreaBorderText

offset: int | float

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int)

size: int | float

class tile_renderer.skin.__init__.AreaCentreImage(image: bytes, extension: str, size: Vector[float] = [0.0, 0.0], offset: Vector[float] = [0.0, 0.0], *, zoom_multiplier: float = 1.5)

encode() → _SerAreaCentreImage

extension: str

image: bytes

offset: Vector[float]

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

size: Vector[float]

class tile_renderer.skin.__init__.AreaCentreText(size: int | float, colour: Colour | None = None, offset: Vector[float] = [0.0, 0.0], *, zoom_multiplier: float = 1.5)

colour: Colour | None

encode() → _SerAreaCentreText

offset: Vector[float]

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

size: int | float

class tile_renderer.skin.__init__.AreaFill(colour: Colour | None = None, outline: Colour | None = None, outline_width: int | float = 0, *, zoom_multiplier: float = 1.5)

colour: Colour | None

encode() → _SerAreaFill

outline: Colour | None

outline_width: int | float

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

class tile_renderer.skin.__init__.ComponentStyle(*, zoom_multiplier: float = 1.5)

encode() → Any

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

zoom_multiplier: float

class tile_renderer.skin.__init__.ComponentType(*, name: str, shape: ~typing.Literal['point', 'line', 'area'], styles: dict[str, list[~tile_renderer.skin.__init__.ComponentStyle]], tags: list[str] = <factory>)

encode() → _SerComponentType

get_styling_by_zoom(zoom: int) → list[ComponentStyle] | None

name: str

shape: Literal['point', 'line', 'area']

styles: dict[str, list[ComponentStyle]]

tags: list[str]

class tile_renderer.skin.__init__.LineBack(width: int | float, dash: list[int | float] | None = None, colour: Colour | None = None, unrounded: bool = False, *, zoom_multiplier: float = 1.5)

encode() → _SerLineBack

class tile_renderer.skin.__init__.LineFore(width: int | float, dash: list[int | float] | None = None, colour: Colour | None = None, unrounded: bool = False, *, zoom_multiplier: float = 1.5)

colour: Colour | None

dash: list[int | float] | None

encode() → _SerLineFore

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

unrounded: bool

width: int | float

class tile_renderer.skin.__init__.LineText(size: int | float, arrow_colour: Colour | None = None, colour: Colour | None = None, offset: int | float = 0, *, zoom_multiplier: float = 1.5)

arrow_colour: Colour | None

colour: Colour | None

encode() → _SerLineText

offset: int | float

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

size: int | float

class tile_renderer.skin.__init__.PointImage(image: bytes, extension: str, size: Vector[float] = [0.0, 0.0], offset: Vector[float] = [0.0, 0.0], *, zoom_multiplier: float = 1.5)

encode() → _SerPointImage

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

class tile_renderer.skin.__init__.PointSquare(size: int | float, width: int | float, colour: Colour | None = None, border_radius: int | float = 0, *, zoom_multiplier: float = 1.5)

border_radius: int | float

colour: Colour | None

encode() → _SerPointSquare

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

size: int | float

width: int | float

class tile_renderer.skin.__init__.PointText(size: int | float, anchor: Literal['start', 'middle', 'end'] = 'middle', colour: Colour | None = None, offset: Vector[float] = [0.0, 0.0], *, zoom_multiplier: float = 1.5)

anchor: Literal['start', 'middle', 'end']

colour: Colour | None

encode() → _SerPointText

offset: Vector[float]

render(component: Component, zoom: int, skin: Skin, lists: _Lists, i: int) → svg.Element

scale(zoom: int) → Self

size: int | float

class tile_renderer.skin.__init__.Skin(*, version: int = 2, name: str, types: list[ComponentType], font_files: list[tuple[str, bytes]], font_string: str = '', background: Colour = Colour(h=0.0, s=0.0, l=100.0), prune_small_text: float | None = None, licence: str = '')

background: Colour

classmethod default() → Skin

encode() → _SerSkin

font_files: list[tuple[str, bytes]]

font_string: str

classmethod from_file(file: Path) → Skin

classmethod from_json(file: Path) → Skin

classmethod from_msgpack(file: Path) → Skin

get_order(name: str) → int | None

get_type_by_name(name: str) → ComponentType | None

licence: str

name: str

prune_small_text: float | None

save_json(directory: Path) → None

save_msgpack(directory: Path) → None

types: list[ComponentType]

version: int

tile_renderer.skin.generate_default.get_url(url: str) → tuple[str, bytes]

tile_renderer.skin.generate_default.main()

PLA2 format (Components)

class tile_renderer.pla2.Component(namespace: str, id: str, display_name: str, description: str, type: str, layer: float, nodes: Line[int], tags: list[str], attrs: dict | None = None)

attrs: dict | None

description: str

display_name: str

encode() → _SerComponent

property fid: str

id: str

layer: float

namespace: str

nodes: Line[int]

tags: list[str]

tiles(zoom: int, max_zoom_range: int) → set[TileCoord]

type: str

class tile_renderer.pla2.Pla2File(namespace: str, components: list[Component])

components: list[Component]

classmethod from_file(file: Path) → Self

classmethod from_json(file: Path) → Self

classmethod from_msgpack(file: Path) → Self

property ids: list[str]

namespace: str

save_json(directory: Path) → None

save_msgpack(directory: Path) → None

Component to SVG

tile_renderer.component_to_svg.area_border_text_svg(s: AreaBorderText, component: Component, zoom: int, skin: Skin, lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.area_centre_image_svg(s: AreaCentreImage, component: Component, _zoom: int, _skin: Skin, _lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.area_centre_text_svg(s: AreaCentreText, component: Component, _zoom: int, skin: Skin, lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.area_fill_svg(s: AreaFill, component: Component, _zoom: int, _skin: Skin, _lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.line_back_fore_svg(s: LineBack | LineFore, component: Component, _zoom: int, _skin: Skin, lists: _Lists, i: int) → svg.Element

tile_renderer.component_to_svg.line_text_svg(s: LineText, component: Component, zoom: int, skin: Skin, lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.point_image_svg(s: PointImage, component: Component, _zoom: int, _skin: Skin, _lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.point_square_svg(s: PointSquare, component: Component, _zoom: int, _skin: Skin, _lists: _Lists, _i: int) → svg.Element

tile_renderer.component_to_svg.point_text_svg(s: PointText, component: Component, _zoom: int, skin: Skin, lists: _Lists, _i: int) → svg.Element

PLA1 to 2

tile_renderer.pla1to2.pla1to2(old_comps: dict, old_nodes: dict) → list[Pla2File]