API reference

Generated from the docstrings. Guides with examples: Python, GIS and web.

Package `ulg`#

class `Catalog`#

Catalog(palette: 'Palette', elements: 'dict[str, dict]', crosswalks: 'dict[str, dict]', settings: 'dict | None' = None, theme: 'dict | None' = None)

All elements of one theme plus the crosswalks from external classifications.

class `CatalogError`#

CatalogError

Unknown element, colour token or scheme.

class `Element`#

Element(id: 'str', group: 'str', geometry: 'tuple[str, ...]', label: 'dict[str, str]', description: 'dict[str, str]', z: 'int', fill: 'str | None', outline: 'str | None', fill_opacity: 'float', outline_width: 'float | None', outline_dash: 'tuple | None', textures: 'tuple[dict, ...]', wash: 'bool', line: 'dict | None', symbol: 'dict | None', border: 'dict | None', attributes: 'dict[str, Any]', codes: 'dict[str, tuple[str, ...]]', aliases: 'tuple[str, ...]', raw: 'dict' = <factory>) -> None

One thing that can be drawn on a map, with its style and its standard codes.

class `Palette`#

Palette(data: 'dict')

Named colours, addressed as family.step (for example grass.300).

class `Feature`#

Feature(geometry: 'BaseGeometry', element: 'str', props: 'dict' = <factory>) -> None

Feature(geometry: 'BaseGeometry', element: 'str', props: 'dict' = <factory>)

class `Options`#

Options(seed: 'int' = 0, handdrawn: 'float' = 1.0, outline_width: 'float' = 0.18, outline_wobble: 'float' = 0.09, textures: 'bool' = True, wash: 'bool' = True, lod: 'int | None' = None, min_texture_area: 'float' = 3.0, fallback: 'str | None' = 'unknown', outline_contrast: 'float | None' = None, ink_contrast: 'float | None' = None, symbol_scale: 'float' = 1.0) -> None

How to draw. All lengths are paper millimetres.

`ulg.load`#

ulg.load(theme: 'str' = 'mellow') -> 'Catalog'

Load the built-in catalog, optionally in another theme (ulg.themes() lists them).

Cached; the result must be treated as read-only.

`ulg.themes`#

ulg.themes() -> 'dict[str, str]'

Available themes: name -> title.

`ulg.element`#

ulg.element(element_id: 'str') -> 'Element'

The catalog entry for an element id (raises with suggestions if it does not exist).

`ulg.find`#

ulg.find(text: 'str', n: 'int' = 5) -> 'list[Element]'

Search elements by id, English or German name, or alias; best match first.

`ulg.color`#

ulg.color(ref: 'str') -> 'str'

Hex colour of a palette token ("grass.300") or of an element's fill ("lawn").

`ulg.fills`#

ulg.fills(geometry: 'str | None' = None) -> 'dict[str, str]'

element id -> fill colour for flat styling in any tool (gdf.element.map(ulg.fills())).

`ulg.ramp`#

ulg.ramp(name: 'str', n: 'int | None' = None) -> 'list[str]'

A mellow sequential or diverging colour ramp for analysis layers (heat, cool, vitality ...).

`ulg.categories`#

ulg.categories(name: 'str') -> 'list[dict]'

Class list of a categorical palette (klimatop, utci, pet) with labels, limits and colours.

`ulg.category_of`#

ulg.category_of(name: 'str', value: 'float') -> 'dict'

The class of a numeric value in a banded category set, e.g. category_of("utci", 34.2).

`ulg.style_function`#

ulg.style_function(field: 'str' = 'element', weight: 'float' = 0.8, fill_opacity: 'float' = 1.0)

A style callback for Leaflet-style APIs (folium.GeoJson(data, style_function=ulg.style_function())).

`ulg.classify`#

ulg.classify(records: 'Any', scheme_name: 'str', column: 'str | None' = None, *, catalog: 'Catalog | None' = None, default: 'str | None' = 'unknown') -> 'list[str | None]'

Element ids for many records at once.

records may be a (Geo)DataFrame, a list of dicts (e.g. OSM tags or GeoJSON properties) or a list of plain codes. With column only that column is used, as the scheme's code; otherwise every attribute of a record takes part in matching, with the scheme's field aliases applied (Objektart -> objart).

`ulg.codes_for`#

ulg.codes_for(element: 'str', catalog: 'Catalog | None' = None) -> 'dict[str, list[dict]]'

All external classes that map onto an element, per scheme (the reverse lookup).

`ulg.explain`#

ulg.explain(scheme_name: 'str', code: 'Any' = None, *, catalog: 'Catalog | None' = None, **attrs: 'Any') -> 'dict | None'

The full crosswalk entry that resolve would use (name, fit, official colour, notes).

`ulg.official_colors`#

ulg.official_colors(scheme_name: 'str', catalog: 'Catalog | None' = None) -> 'dict[str, str]'

code -> hex of a scheme's official legend, for maps that must use the prescribed colours.

`ulg.resolve`#

ulg.resolve(scheme_name: 'str', code: 'Any' = None, *, catalog: 'Catalog | None' = None, default: 'str | None' = None, **attrs: 'Any') -> 'str | None'

Element id for a class of an external scheme.

resolve("clc", 141), resolve("alkis", objart=43001, vegetationsmerkmal=1020), resolve("osm", natural="wetland", wetland="reedbed").

`ulg.scheme`#

ulg.scheme(name: 'str', catalog: 'Catalog | None' = None) -> 'Scheme'

`ulg.schemes`#

ulg.schemes(catalog: 'Catalog | None' = None) -> 'dict[str, Scheme]'

`ulg.flatten`#

ulg.flatten(data: 'Any', by: 'str' = 'element', *, catalog: 'Catalog | None' = None)

Resolve overlaps the way the map draws them, so that ground cover tiles the site.

OpenStreetMap and many sketch datasets stack areas (a park polygon under grass, a pond and paths). Area statistics need a planar partition instead. flatten cuts every ground feature by the ground features drawn above it (catalog z-order; at equal z the later feature is on top), turns centre lines of roads and paths into areas at their width, and passes points, roofs and overlays through unchanged.

>>> ulg.indicators(ulg.flatten(osm_gdf))

Returns a GeoDataFrame (in a metric CRS) for a GeoDataFrame, otherwise a list of Features.

`ulg.indicators`#

ulg.indicators(data: 'Any', by: 'str' = 'element', *, plot_area: 'float | None' = None, catalog: 'Catalog | None' = None, trees: 'bool' = True) -> 'dict'

Area-weighted indicators of a classified site plan.

data GeoDataFrame / GeoJSON / (geometry, element) pairs in a metric CRS. plot_area area of the plot in m² (default: the summed ground cover). trees count point trees as canopy using their crown diameter.

Returns shares in 0–1 and coverage values that say for how much of the area a coefficient was known. bff follows the Berlin rule: ground factors plus the credits of roof greening, divided by the plot area.

`ulg.root_protection_zone`#

ulg.root_protection_zone(data: 'Any', *, crown_field: 'str | None' = None, columnar_field: 'str | None' = None, default_crown_m: 'float' = 6.0, extra_m: 'float' = 1.5, columnar_extra_m: 'float' = 5.0)

Root protection zones after DIN 18920 / R SBB: crown drip line + 1.50 m (columnar trees + 5.00 m).

Points are treated as crowns with the diameter from crown_field (or the usual field names); polygons as crown outlines. Returns a GeoDataFrame for a GeoDataFrame input, otherwise a list of polygons. Also adds the minimum distance for excavations, 4 x stem circumference but at least 2.50 m (DIN 18920:2014-07, 4.10; the wording of the 2026-06 edition was not verified), when a girth or stem diameter is known. The girth is used as recorded: German tree surveys measure it at 1.00 m, OpenStreetMap's circumference at 1.30 m.

`ulg.legend_handles`#

ulg.legend_handles(elements: 'Iterable[str | Element] | None' = None, *, lang: 'str' = 'en', catalog: 'Catalog | None' = None) -> 'list'

Proxy artists for ax.legend(handles=...) (flat colours; Matplotlib legends cannot hold textures).

`ulg.legend_svg`#

ulg.legend_svg(elements: 'Iterable[str | Element] | None' = None, *, lang: 'str' = 'en', title: 'str | None' = None, columns: 'int' = 1, lod: 'int' = 2, catalog: 'Catalog | None' = None, background: 'str | None' = None, col_width: 'float' = 52.0, credit: 'bool' = False) -> 'Svg'

A stand-alone legend as SVG.

Legends go into your layouts, so they carry nothing extra by default; credit=True adds the small UrbanSens mark below the legend (see :mod:ulg.brand).

`ulg.plot`#

ulg.plot(data: 'Any', by: 'str' = 'element', *, ax=None, scale: 'float | None' = None, width: 'float | None' = None, extent: 'tuple | None' = None, background: 'str | None' = 'auto', catalog: 'Catalog | None' = None, theme: 'str | None' = None, mapping: 'dict | None' = None, lod: 'int | None' = None, seed: 'int' = 0, handdrawn: 'float | None' = None, options: 'Options | None' = None, zorder: 'float' = 1.0, dpi: 'int' = 150)

Draw features in the house style with Matplotlib and return the Axes.

Without ax a figure is created whose size follows from scale (or width in mm), so that one paper millimetre is one millimetre. With an existing ax the current layout of that axes decides the scale; draw other layers on top afterwards as usual.

`ulg.render_svg`#

ulg.render_svg(data: 'Any', by: 'str' = 'element', *, scale: 'float | None' = None, width: 'float | None' = None, extent: 'tuple | None' = None, margin: 'float' = 0.0, background: 'str | None' = 'auto', path: 'str | Path | None' = None, catalog: 'Catalog | None' = None, theme: 'str | None' = None, mapping: 'dict | None' = None, lod: 'int | None' = None, seed: 'int' = 0, handdrawn: 'float | None' = None, options: 'Options | None' = None, title: 'str | None' = None) -> 'Svg'

Draw features in the house style and return the SVG page.

data GeoDataFrame, GeoJSON FeatureCollection, or (geometry, element_id) pairs, in a projected CRS with metres as unit. by column / property holding the element id; mapping translates other values. scale map scale denominator (500 for 1:500). The page size follows from the extent. width alternatively the page width in mm; the scale follows. Default 180 mm. lod level of detail 0-3; by default chosen from the scale. theme "mellow" (default) or an official theme: "planzv", "alkis", "basemap", "bfn", "osm", "mono" (see ulg.themes()).

`ulg.lod_for_scale`#

ulg.lod_for_scale(scale: 'float') -> 'int'

Level of detail for a map scale denominator (1:500 -> 3, 1:5000 -> 1).

`ulg.lod_for_zoom`#

ulg.lod_for_zoom(zoom: 'float', latitude: 'float' = 50.0) -> 'int'

Level of detail for a web-map zoom level (256 px tiles, 96 dpi).

`ulg.style_sheet`#

ulg.style_sheet(path=None, **kw)

The one-page overview of the style as SVG (see :mod:ulg.sheet).

`ulg.catalog_sheet`#

ulg.catalog_sheet(path=None, **kw)

All elements with swatch, id and names as SVG (see :mod:ulg.sheet).

`ulg.credit_line`#

ulg.credit_line(lang: 'str' = 'en', *, version: 'bool' = True) -> 'str'

The line to put into a map caption, a legend or a list of sources.

'Style: UrbanSens Ecological Vector Style (ulg 0.1.0) · urbansens.de'; lang="de" starts with Kartenstil.

Crosswalk helpers `ulg.crosswalk`#

`ulg.crosswalk.coverage`#

ulg.crosswalk.coverage(catalog: 'Catalog | None' = None) -> 'dict[str, dict]'

How well each scheme is covered: entries per fit grade, and elements reached.

`ulg.crosswalk.validate`#

ulg.crosswalk.validate(catalog: 'Catalog | None' = None) -> 'list[str]'

Problems in the crosswalk files: unknown elements, bad colours, duplicate keys, missing fields.

Legibility `ulg.check`#

`ulg.check.report`#

ulg.check.report(catalog: 'Catalog | None' = None) -> 'dict'

`ulg.check.format_report`#

ulg.check.format_report(rep: 'dict') -> 'str'

`ulg.check.close_pairs`#

ulg.check.close_pairs(catalog: 'Catalog | None' = None, threshold: 'float' = 10.0, cvd: 'str | None' = None) -> 'list[dict]'

Pairs of land-cover elements whose fills are closer than threshold (CIEDE2000).

`ulg.check.mark_contrast`#

ulg.check.mark_contrast(catalog: 'Catalog | None' = None) -> 'list[dict]'

WCAG contrast of each texture mark against its fill (marks below about 1.15 start to vanish in print).

`ulg.check.land_cover`#

ulg.check.land_cover(catalog: 'Catalog | None' = None) -> 'list[Element]'

Polygon elements that tile the ground and can meet each other on a map.

Demo data `ulg.datasets`#

`ulg.datasets.demo_park`#

ulg.datasets.demo_park(seed: 'int' = 6, origin: 'tuple[float, float]' = (583600.0, 5509300.0)) -> 'list[dict]'

Features of the demo quarter as dicts: {"geometry", "element", "layer", ...}.

layer is landcover, trees or lines inside the park, context around it.

`ulg.datasets.demo_park_places`#

ulg.datasets.demo_park_places(seed: 'int' = 6, origin: 'tuple[float, float]' = (583600.0, 5509300.0)) -> 'dict[str, tuple[float, float]]'

Named spots of the demo quarter in the coordinates of :func:demo_park (pond, plaza, playground ...).

`ulg.datasets.demo_park_gdf`#

ulg.datasets.demo_park_gdf(seed: 'int' = 6)

The demo quarter as a GeoDataFrame (requires geopandas).

QGIS `ulg.export.qgis`#

`ulg.export.qgis.export_qgis`#

ulg.export.qgis.export_qgis(directory, *, lod: 'int | str' = 2, lang: 'str' = 'en', handdrawn: 'bool | None' = None, theme: 'str' = 'mellow', catalog: 'Catalog | None' = None) -> 'list[Path]'

Everything QGIS needs, in one folder. theme picks the colour theme (see ulg.themes()).

`ulg.export.qgis.layer_style`#

ulg.export.qgis.layer_style(path, geometry: 'str' = 'polygon', *, field: 'str' = 'element', elements=None, lod: 'int | str' = 2, lang: 'str' = 'en', tile: 'float' = 32.0, handdrawn: 'bool' = False, catalog: 'Catalog | None' = None) -> 'Path'

Write a QGIS layer style (.qml) that draws every catalog element of one geometry type.

Load it in QGIS via Layer Properties > Style > Load Style. The layer needs an attribute field holding element ids. With lod="auto" a rule-based renderer switches the level of detail with the map scale.

`ulg.export.qgis.style_library`#

ulg.export.qgis.style_library(path, *, lod: 'int' = 2, tile: 'float' = 32.0, lang: 'str' = 'en', catalog: 'Catalog | None' = None) -> 'Path'

Write a symbol library (.xml) for Settings > Style Manager > Import.

Every element becomes a named symbol tagged with its group; the palette families become colour ramps.

`ulg.export.qgis.palette_gpl`#

ulg.export.qgis.palette_gpl(path, *, catalog: 'Catalog | None' = None, elements: 'bool' = True) -> 'Path'

Write a GIMP palette (.gpl): importable as a colour scheme in QGIS, Inkscape, GIMP and Krita.

`ulg.export.qgis.symbol_for`#

ulg.export.qgis.symbol_for(el: 'Element', name: 'str | None' = None, *, lod: 'int' = 2, tile: 'float' = 32.0, kind: 'str | None' = None, size_field: 'str' = 'crown_diameter', handdrawn: 'bool' = False) -> 'str | None'

<symbol> XML for an element; kind picks fill, line or marker if the element allows several.

`ulg.export.qgis.strip_symbol`#

ulg.export.qgis.strip_symbol(el: 'Element', name: 'str', catalog: 'Catalog', *, lod: 'int' = 2, tile: 'float' = 32.0) -> 'str | None'

Line symbol that draws a centre line as the element's area, buffered to its width in map units.

`ulg.export.qgis.width_expression`#

ulg.export.qgis.width_expression(el: 'Element', catalog: 'Catalog') -> 'str'

QGIS expression for the width in metres of a centre line drawn as an area (see centreline_area).

Web `ulg.export.web`#

`ulg.export.web.export_web`#

ulg.export.web.export_web(directory, *, lod: 'int' = 2, latitude: 'float' = 50.0, sprite: 'bool' = True, catalog: 'Catalog | None' = None) -> 'list[Path]'

Everything a web app needs: tokens, catalog, SVG patterns and MapLibre assets.

`ulg.export.web.to_geojson`#

ulg.export.web.to_geojson(data, path=None, *, columns: 'list[str] | None' = None, area_field: 'str' = 'area_m2') -> 'dict'

GeoJSON for web maps (RFC 7946, WGS 84) from a GeoDataFrame in any CRS.

Adds area_field (m², computed in a metric CRS) to every area, which the MapLibre layers use to draw smaller areas above larger ones. columns limits the properties that are written (the element column and sizes, for example).

`ulg.export.web.maplibre_layers`#

ulg.export.web.maplibre_layers(source: 'str' = 'ulg', *, source_layer: 'str | None' = None, field: 'str' = 'element', latitude: 'float' = 50.0, pattern_minzoom: 'float' = 15.5, prefix: 'str' = 'ulg-', size_field: 'str' = 'crown_diameter', crown_px: 'int' = 64, area_field: 'str' = 'area_m2', catalog: 'Catalog | None' = None) -> 'list[dict]'

Style layers for a MapLibre GL / Mapbox GL style: fills, patterns, outlines, strips, lines, tree crowns.

Append them to the layers of your style and point sprite at the files from :func:maplibre_sprite. Features need the element id in field; an area_field (added by :func:to_geojson) lets smaller areas draw on top of larger ones of the same z, as in the Python renderer. Roads and paths given as centre lines are drawn as strips of their real width (width, lanes, highway or the element default).

`ulg.export.web.maplibre_sprite`#

ulg.export.web.maplibre_sprite(directory, *, name: 'str' = 'ulg-sprite', px: 'int' = 128, icon_px: 'int' = 24, crown_px: 'int' = 64, lod: 'int' = 2, elements=None, prefix: 'str' = 'ulg-', catalog: 'Catalog | None' = None) -> 'list[Path]'

Write <name>.png/.json and <name>@2x.png/.json: one pattern tile per area element (ulg-<id>; opaque with the fill painted in, transparent for overlays), one icon per pictogram (ulg-icon-<id>, icon_px wide) and one crown per tree or shrub element (ulg-crown-<id>, crown_px wide, scaled to the real crown diameter by the layers of :func:maplibre_layers).

`ulg.export.web.pattern_files`#

ulg.export.web.pattern_files(directory, *, lod: 'int' = 2, size: 'float' = 32.0, background: 'bool' = True, elements=None, catalog: 'Catalog | None' = None) -> 'list[Path]'

One seamless SVG tile per textured polygon element (<id>.svg).

`ulg.export.web.patterns_svg`#

ulg.export.web.patterns_svg(path=None, *, lod: 'int' = 2, size: 'float' = 32.0, elements=None, prefix: 'str' = 'ulg-', catalog: 'Catalog | None' = None) -> 'str'

An SVG holding <pattern id="ulg-lawn"> for every textured element.

Inline it once in a page; then any SVG shape (Leaflet's SVG renderer, D3, hand-written SVG) can use fill="url(#ulg-lawn)". Pattern units are CSS pixels, so the marks have the same physical size as in print.

OGC SLD `ulg.export.sld`#

`ulg.export.sld.export_sld`#

ulg.export.sld.export_sld(directory, **kw) -> 'list[Path]'

`ulg.export.sld.sld`#

ulg.export.sld.sld(path, geometry: 'str' = 'polygon', *, field: 'str' = 'element', lang: 'str' = 'en', elements=None, patterns: 'bool' = True, lod: 'int' = 2, layer_name: 'str' = 'ulg', catalog: 'Catalog | None' = None) -> 'Path'

Write one SLD per geometry type. Pattern tiles go to patterns/ next to the file.

Design tokens `ulg.export.tokens`#

`ulg.export.tokens.css`#

ulg.export.tokens.css(path=None, *, catalog: 'Catalog | None' = None, selector: 'str' = ':root') -> 'str'

CSS custom properties: --ulg-grass-300 for palette colours, --ulg-lawn-fill etc. for elements.

`ulg.export.tokens.dtcg`#

ulg.export.tokens.dtcg(path=None, *, catalog: 'Catalog | None' = None) -> 'dict'

Design Tokens Community Group format (.tokens.json): primitives plus element aliases.

Reads into Style Dictionary, Tokens Studio, Figma variables importers and similar tools. Element colours are aliases ({palette.grass.300}) so a palette change propagates.

`ulg.export.tokens.tokens_json`#

ulg.export.tokens.tokens_json(path=None, *, catalog: 'Catalog | None' = None) -> 'dict'

Flat, tool-agnostic JSON: palette tokens and the resolved colours of every element.

`ulg.export.tokens.catalog_json`#

ulg.export.tokens.catalog_json(path=None, *, catalog: 'Catalog | None' = None) -> 'dict'

The complete resolved catalog in one file: the contract for non-Python apps and AI agents.

Command line `ulg`#

Also available as python -m ulg.

`ulg`#

usage: ulg [-h] [--version]
           {list,show,find,schemes,resolve,themes,categories,indicators,render,sheet,export,check,agent}
           ...

Urban Landscape Graphics - UrbanSens Ecological Vector Style

positional arguments:
  {list,show,find,schemes,resolve,themes,categories,indicators,render,sheet,export,check,agent}
    list                list catalog elements
    show                everything about one element: colours, textures,
                        standard codes
    find                search elements by English or German name, alias or id
    schemes             list the classification schemes with a crosswalk
    resolve             element for a class of a scheme, e.g. `ulg resolve osm
                        landuse=grass`
    themes              list the colour themes (house style and official
                        conventions)
    categories          class palettes for analysis maps: klimatop, utci, pet
    indicators          sealing, BFF, runoff, albedo, green-space and canopy
                        shares of a site
    render              draw a vector file (GeoPackage, GeoJSON, Shapefile
                        ...) to SVG
    sheet               generate the style sheet (or the full catalog sheet)
                        as SVG
    export              write style files for other platforms
    check               legibility report: colour distances, colour-vision
                        deficiencies, mark contrast
    agent               guide for AI coding agents; `ulg agent install` adds
                        the skill to a project

options:
  -h, --help            show this help message and exit
  --version             show program's version number and exit

`ulg list`#

usage: ulg list [-h] [--json] [--lang {en,de}] [--group GROUP]
                [--geometry {polygon,line,point}]

options:
  -h, --help            show this help message and exit
  --json                machine-readable output
  --lang {en,de}
  --group GROUP         only groups starting with this (e.g. vegetation,
                        surface)
  --geometry {polygon,line,point}

`ulg show`#

usage: ulg show [-h] [--json] [--lang {en,de}] id

positional arguments:
  id

options:
  -h, --help      show this help message and exit
  --json          machine-readable output
  --lang {en,de}

`ulg find`#

usage: ulg find [-h] [--json] [--lang {en,de}] [-n N] text [text ...]

positional arguments:
  text

options:
  -h, --help      show this help message and exit
  --json          machine-readable output
  --lang {en,de}
  -n N

`ulg schemes`#

usage: ulg schemes [-h] [--json] [--lang {en,de}]

options:
  -h, --help      show this help message and exit
  --json          machine-readable output
  --lang {en,de}

`ulg resolve`#

usage: ulg resolve [-h] [--json] [--lang {en,de}] scheme query [query ...]

positional arguments:
  scheme
  query           a code, or key=value pairs

options:
  -h, --help      show this help message and exit
  --json          machine-readable output
  --lang {en,de}

`ulg themes`#

usage: ulg themes [-h] [--json] [--lang {en,de}]

options:
  -h, --help      show this help message and exit
  --json          machine-readable output
  --lang {en,de}

`ulg categories`#

usage: ulg categories [-h] [--json] [--lang {en,de}] {klimatop,utci,pet}

positional arguments:
  {klimatop,utci,pet}

options:
  -h, --help           show this help message and exit
  --json               machine-readable output
  --lang {en,de}

`ulg indicators`#

usage: ulg indicators [-h] [--json] [--lang {en,de}] [--layer LAYER] [--by BY]
                      [--scheme SCHEME] [--plot-area PLOT_AREA] [--flatten]
                      input

positional arguments:
  input

options:
  -h, --help            show this help message and exit
  --json                machine-readable output
  --lang {en,de}
  --layer LAYER
  --by BY
  --scheme SCHEME       classify with a crosswalk first (osm, alkis, clc, ...)
  --plot-area PLOT_AREA
                        plot area in m2 (default: mapped ground cover)
  --flatten             resolve overlapping areas first (needed for
                        OpenStreetMap and other stacked data)

`ulg render`#

usage: ulg render [-h] [--json] [--lang {en,de}] [-o OUTPUT] [--layer LAYER]
                  [--by BY] [--scheme SCHEME] [--scale SCALE] [--width WIDTH]
                  [--lod {0,1,2,3}] [--seed SEED] [--handdrawn HANDDRAWN]
                  [--theme THEME] [--png] [--dpi DPI]
                  input

positional arguments:
  input

options:
  -h, --help            show this help message and exit
  --json                machine-readable output
  --lang {en,de}
  -o OUTPUT, --output OUTPUT
  --layer LAYER
  --by BY               attribute with the element id (or the scheme's code)
  --scheme SCHEME       classify with a crosswalk first (osm, alkis, clc, ...)
  --scale SCALE         scale denominator, e.g. 500
  --width WIDTH         page width in mm (if no scale is given)
  --lod {0,1,2,3}
  --seed SEED
  --handdrawn HANDDRAWN
                        0 exact ... 1 house style ... 2 sketchy
  --theme THEME         mellow, planzv, alkis, basemap, bfn, osm, mono
  --png
  --dpi DPI

`ulg sheet`#

usage: ulg sheet [-h] [--json] [--lang {en,de}] [-o OUTPUT] [--catalog]
                 [--no-credit] [--theme THEME] [--png] [--dpi DPI]

options:
  -h, --help            show this help message and exit
  --json                machine-readable output
  --lang {en,de}
  -o OUTPUT, --output OUTPUT
  --catalog             all elements instead of the overview
  --no-credit           leave the small UrbanSens mark off the sheet
  --theme THEME
  --png
  --dpi DPI

`ulg export`#

usage: ulg export [-h] [--json] [--lang {en,de}] [--lod {0,1,2,3,auto}]
                  [--theme THEME]
                  {qgis,web,sld,tokens,all} directory

positional arguments:
  {qgis,web,sld,tokens,all}
  directory

options:
  -h, --help            show this help message and exit
  --json                machine-readable output
  --lang {en,de}
  --lod {0,1,2,3,auto}
  --theme THEME

`ulg check`#

usage: ulg check [-h] [--json] [--lang {en,de}]

options:
  -h, --help      show this help message and exit
  --json          machine-readable output
  --lang {en,de}

`ulg agent`#

usage: ulg agent [-h] [--json] [--lang {en,de}] [--dir DIR] [--claude]
                 [--agents]
                 [{guide,install}]

positional arguments:
  {guide,install}

options:
  -h, --help       show this help message and exit
  --json           machine-readable output
  --lang {en,de}
  --dir DIR        project folder for `install`
  --claude         install into .claude/skills (default)
  --agents         install into .agents/skills (cross-agent convention)

Package ulg#

class Catalog#

class CatalogError#

class Element#

class Palette#

class Feature#

class Options#

ulg.load#

ulg.themes#

ulg.element#

ulg.find#

ulg.color#

ulg.fills#

ulg.ramp#

ulg.categories#

ulg.category_of#

ulg.style_function#

ulg.classify#

ulg.codes_for#

ulg.explain#

ulg.official_colors#

ulg.resolve#

ulg.scheme#

ulg.schemes#

ulg.flatten#

ulg.indicators#

ulg.root_protection_zone#

ulg.legend_handles#

ulg.legend_svg#

ulg.plot#

ulg.render_svg#

ulg.lod_for_scale#

ulg.lod_for_zoom#

ulg.style_sheet#

ulg.catalog_sheet#

ulg.credit_line#

Crosswalk helpers ulg.crosswalk#

ulg.crosswalk.coverage#

ulg.crosswalk.validate#

Legibility ulg.check#

ulg.check.report#

ulg.check.format_report#

ulg.check.close_pairs#

ulg.check.mark_contrast#

ulg.check.land_cover#

Demo data ulg.datasets#

ulg.datasets.demo_park#

ulg.datasets.demo_park_places#

ulg.datasets.demo_park_gdf#

QGIS ulg.export.qgis#

ulg.export.qgis.export_qgis#

ulg.export.qgis.layer_style#

ulg.export.qgis.style_library#

ulg.export.qgis.palette_gpl#

ulg.export.qgis.symbol_for#

ulg.export.qgis.strip_symbol#

ulg.export.qgis.width_expression#

Web ulg.export.web#

ulg.export.web.export_web#

ulg.export.web.to_geojson#

ulg.export.web.maplibre_layers#

ulg.export.web.maplibre_sprite#

ulg.export.web.pattern_files#

ulg.export.web.patterns_svg#

OGC SLD ulg.export.sld#

ulg.export.sld.export_sld#

ulg.export.sld.sld#

Design tokens ulg.export.tokens#

ulg.export.tokens.css#

ulg.export.tokens.dtcg#

ulg.export.tokens.tokens_json#

ulg.export.tokens.catalog_json#

Command line ulg#

ulg#

ulg list#

ulg show#

ulg find#

ulg schemes#

ulg resolve#