X-Git-Url: https://git.openstreetmap.org./nominatim.git/blobdiff_plain/55277738d437363079bec3d0623cbf44d92a00aa..1177b30a60f67034c252503c11e1ab5088f7b807:/nominatim/api/reverse.py diff --git a/nominatim/api/reverse.py b/nominatim/api/reverse.py index eadb63fb..10c97cad 100644 --- a/nominatim/api/reverse.py +++ b/nominatim/api/reverse.py @@ -7,7 +7,7 @@ """ Implementation of reverse geocoding. """ -from typing import Optional, List +from typing import Optional, List, Callable, Type, Tuple import sqlalchemy as sa from geoalchemy2 import WKTElement @@ -16,20 +16,29 @@ from nominatim.typing import SaColumn, SaSelect, SaFromClause, SaLabel, SaRow from nominatim.api.connection import SearchConnection import nominatim.api.results as nres from nominatim.api.logging import log -from nominatim.api.types import AnyPoint, DataLayer, LookupDetails, GeometryFormat +from nominatim.api.types import AnyPoint, DataLayer, ReverseDetails, GeometryFormat, Bbox # In SQLAlchemy expression which compare with NULL need to be expressed with # the equal sign. # pylint: disable=singleton-comparison +RowFunc = Callable[[Optional[SaRow], Type[nres.ReverseResult]], Optional[nres.ReverseResult]] + def _select_from_placex(t: SaFromClause, wkt: Optional[str] = None) -> SaSelect: """ Create a select statement with the columns relevant for reverse results. """ if wkt is None: distance = t.c.distance + centroid = t.c.centroid else: distance = t.c.geometry.ST_Distance(wkt) + centroid = sa.case( + (t.c.geometry.ST_GeometryType().in_(('ST_LineString', + 'ST_MultiLineString')), + t.c.geometry.ST_ClosestPoint(wkt)), + else_=t.c.centroid).label('centroid') + return sa.select(t.c.place_id, t.c.osm_type, t.c.osm_id, t.c.name, t.c.class_, t.c.type, @@ -37,7 +46,7 @@ def _select_from_placex(t: SaFromClause, wkt: Optional[str] = None) -> SaSelect: t.c.housenumber, t.c.postcode, t.c.country_code, t.c.importance, t.c.wikipedia, t.c.parent_place_id, t.c.rank_address, t.c.rank_search, - t.c.centroid, + centroid, distance.label('distance'), t.c.geometry.ST_Expand(0).label('bbox')) @@ -49,6 +58,22 @@ def _interpolated_housenumber(table: SaFromClause) -> SaLabel: sa.Integer).label('housenumber') +def _interpolated_position(table: SaFromClause) -> SaLabel: + fac = sa.cast(table.c.step, sa.Float) / (table.c.endnumber - table.c.startnumber) + rounded_pos = sa.func.round(table.c.position / fac) * fac + return sa.case( + (table.c.endnumber == table.c.startnumber, table.c.linegeo.ST_Centroid()), + else_=table.c.linegeo.ST_LineInterpolatePoint(rounded_pos)).label('centroid') + + +def _locate_interpolation(table: SaFromClause, wkt: WKTElement) -> SaLabel: + """ Given a position, locate the closest point on the line. + """ + return sa.case((table.c.linegeo.ST_GeometryType() == 'ST_LineString', + sa.func.ST_LineLocatePoint(table.c.linegeo, wkt)), + else_=0).label('position') + + def _is_address_point(table: SaFromClause) -> SaColumn: return sa.and_(table.c.rank_address == 30, sa.or_(table.c.housenumber != None, @@ -62,23 +87,34 @@ class ReverseGeocoder: coordinate. """ - def __init__(self, conn: SearchConnection, max_rank: int, layer: DataLayer, - details: LookupDetails) -> None: + def __init__(self, conn: SearchConnection, params: ReverseDetails) -> None: self.conn = conn - self.max_rank = max_rank - self.layer = layer - self.details = details + self.params = params + + + @property + def max_rank(self) -> int: + """ Return the maximum configured rank. + """ + return self.params.max_rank + + + def has_geometries(self) -> bool: + """ Check if any geometries are requested. + """ + return bool(self.params.geometry_output) + def layer_enabled(self, *layer: DataLayer) -> bool: """ Return true when any of the given layer types are requested. """ - return any(self.layer & l for l in layer) + return any(self.params.layers & l for l in layer) def layer_disabled(self, *layer: DataLayer) -> bool: """ Return true when none of the given layer types is requested. """ - return not any(self.layer & l for l in layer) + return not any(self.params.layers & l for l in layer) def has_feature_layers(self) -> bool: @@ -87,21 +123,21 @@ class ReverseGeocoder: return self.layer_enabled(DataLayer.RAILWAY, DataLayer.MANMADE, DataLayer.NATURAL) def _add_geometry_columns(self, sql: SaSelect, col: SaColumn) -> SaSelect: - if not self.details.geometry_output: + if not self.has_geometries(): return sql out = [] - if self.details.geometry_simplification > 0.0: - col = col.ST_SimplifyPreserveTopology(self.details.geometry_simplification) + if self.params.geometry_simplification > 0.0: + col = col.ST_SimplifyPreserveTopology(self.params.geometry_simplification) - if self.details.geometry_output & GeometryFormat.GEOJSON: + if self.params.geometry_output & GeometryFormat.GEOJSON: out.append(col.ST_AsGeoJSON().label('geometry_geojson')) - if self.details.geometry_output & GeometryFormat.TEXT: + if self.params.geometry_output & GeometryFormat.TEXT: out.append(col.ST_AsText().label('geometry_text')) - if self.details.geometry_output & GeometryFormat.KML: + if self.params.geometry_output & GeometryFormat.KML: out.append(col.ST_AsKML().label('geometry_kml')) - if self.details.geometry_output & GeometryFormat.SVG: + if self.params.geometry_output & GeometryFormat.SVG: out.append(col.ST_AsSVG().label('geometry_svg')) return sql.add_columns(*out) @@ -190,66 +226,71 @@ class ReverseGeocoder: sql = sa.select(t, t.c.linegeo.ST_Distance(wkt).label('distance'), - t.c.linegeo.ST_LineLocatePoint(wkt).label('position'))\ + _locate_interpolation(t, wkt))\ .where(t.c.linegeo.ST_DWithin(wkt, distance))\ + .where(t.c.startnumber != None)\ .order_by('distance')\ .limit(1) if parent_place_id is not None: sql = sql.where(t.c.parent_place_id == parent_place_id) - inner = sql.subquery() + inner = sql.subquery('ipol') sql = sa.select(inner.c.place_id, inner.c.osm_id, inner.c.parent_place_id, inner.c.address, _interpolated_housenumber(inner), + _interpolated_position(inner), inner.c.postcode, inner.c.country_code, - inner.c.linegeo.ST_LineInterpolatePoint(inner.c.position).label('centroid'), inner.c.distance) - if self.details.geometry_output: - sub = sql.subquery() - sql = self._add_geometry_columns(sql, sub.c.centroid) + if self.has_geometries(): + sub = sql.subquery('geom') + sql = self._add_geometry_columns(sa.select(sub), sub.c.centroid) return (await self.conn.execute(sql)).one_or_none() async def _find_tiger_number_for_street(self, parent_place_id: int, + parent_type: str, parent_id: int, wkt: WKTElement) -> Optional[SaRow]: t = self.conn.t.tiger inner = sa.select(t, t.c.linegeo.ST_Distance(wkt).label('distance'), - sa.func.ST_LineLocatePoint(t.c.linegeo, wkt).label('position'))\ + _locate_interpolation(t, wkt))\ .where(t.c.linegeo.ST_DWithin(wkt, 0.001))\ .where(t.c.parent_place_id == parent_place_id)\ .order_by('distance')\ .limit(1)\ - .subquery() + .subquery('tiger') sql = sa.select(inner.c.place_id, inner.c.parent_place_id, + sa.literal(parent_type).label('osm_type'), + sa.literal(parent_id).label('osm_id'), _interpolated_housenumber(inner), + _interpolated_position(inner), inner.c.postcode, - inner.c.linegeo.ST_LineInterpolatePoint(inner.c.position).label('centroid'), inner.c.distance) - if self.details.geometry_output: - sub = sql.subquery() - sql = self._add_geometry_columns(sql, sub.c.centroid) + if self.has_geometries(): + sub = sql.subquery('geom') + sql = self._add_geometry_columns(sa.select(sub), sub.c.centroid) return (await self.conn.execute(sql)).one_or_none() - async def lookup_street_poi(self, wkt: WKTElement) -> Optional[nres.ReverseResult]: + async def lookup_street_poi(self, + wkt: WKTElement) -> Tuple[Optional[SaRow], RowFunc]: """ Find a street or POI/address for the given WKT point. """ log().section('Reverse lookup on street/address level') - result = None distance = 0.006 parent_place_id = None row = await self._find_closest_street_or_poi(wkt, distance) + row_func: RowFunc = nres.create_from_placex_row log().var_dump('Result (street/building)', row) # If the closest result was a street, but an address was requested, @@ -266,14 +307,19 @@ class ReverseGeocoder: if addr_row is not None: row = addr_row + row_func = nres.create_from_placex_row distance = addr_row.distance elif row.country_code == 'us' and parent_place_id is not None: log().comment('Find TIGER housenumber for street') - addr_row = await self._find_tiger_number_for_street(parent_place_id, wkt) + addr_row = await self._find_tiger_number_for_street(parent_place_id, + row.osm_type, + row.osm_id, + wkt) log().var_dump('Result (street Tiger housenumber)', addr_row) if addr_row is not None: - result = nres.create_from_tiger_row(addr_row, nres.ReverseResult) + row = addr_row + row_func = nres.create_from_tiger_row else: distance = row.distance @@ -285,9 +331,10 @@ class ReverseGeocoder: wkt, distance) log().var_dump('Result (street interpolation)', addr_row) if addr_row is not None: - result = nres.create_from_osmline_row(addr_row, nres.ReverseResult) + row = addr_row + row_func = nres.create_from_osmline_row - return result or nres.create_from_placex_row(row, nres.ReverseResult) + return row, row_func async def _lookup_area_address(self, wkt: WKTElement) -> Optional[SaRow]: @@ -309,7 +356,7 @@ class ReverseGeocoder: .where(t.c.type != 'postcode')\ .order_by(sa.desc(t.c.rank_search))\ .limit(50)\ - .subquery() + .subquery('area') sql = _select_from_placex(inner)\ .where(inner.c.geometry.ST_Contains(wkt))\ @@ -338,7 +385,7 @@ class ReverseGeocoder: .intersects(wkt))\ .order_by(sa.desc(t.c.rank_search))\ .limit(50)\ - .subquery() + .subquery('places') touter = self.conn.t.placex.alias('outer') sql = _select_from_placex(inner)\ @@ -391,7 +438,7 @@ class ReverseGeocoder: return row - async def lookup_area(self, wkt: WKTElement) -> Optional[nres.ReverseResult]: + async def lookup_area(self, wkt: WKTElement) -> Optional[SaRow]: """ Lookup large areas for the given WKT point. """ log().section('Reverse lookup by larger area features') @@ -406,10 +453,10 @@ class ReverseGeocoder: else: other_row = None - return nres.create_from_placex_row(_get_closest(address_row, other_row), nres.ReverseResult) + return _get_closest(address_row, other_row) - async def lookup_country(self, wkt: WKTElement) -> Optional[nres.ReverseResult]: + async def lookup_country(self, wkt: WKTElement) -> Optional[SaRow]: """ Lookup the country for the given WKT point. """ log().section('Reverse lookup by country code') @@ -464,35 +511,43 @@ class ReverseGeocoder: .where(t.c.rank_address == 4)\ .where(t.c.rank_search == 4)\ .where(t.c.linked_place_id == None)\ - .order_by('distance') + .order_by('distance')\ + .limit(1) sql = self._add_geometry_columns(sql, t.c.geometry) address_row = (await self.conn.execute(sql)).one_or_none() - return nres.create_from_placex_row(address_row, nres.ReverseResult) + return address_row async def lookup(self, coord: AnyPoint) -> Optional[nres.ReverseResult]: """ Look up a single coordinate. Returns the place information, if a place was found near the coordinates or None otherwise. """ - log().function('reverse_lookup', - coord=coord, max_rank=self.max_rank, - layer=self.layer, details=self.details) + log().function('reverse_lookup', coord=coord, params=self.params) wkt = WKTElement(f'POINT({coord[0]} {coord[1]})', srid=4326) - result: Optional[nres.ReverseResult] = None + row: Optional[SaRow] = None + row_func: RowFunc = nres.create_from_placex_row if self.max_rank >= 26: - result = await self.lookup_street_poi(wkt) - if result is None and self.max_rank > 4: - result = await self.lookup_area(wkt) - if result is None and self.layer_enabled(DataLayer.ADDRESS): - result = await self.lookup_country(wkt) + row, tmp_row_func = await self.lookup_street_poi(wkt) + if row is not None: + row_func = tmp_row_func + if row is None and self.max_rank > 4: + row = await self.lookup_area(wkt) + if row is None and self.layer_enabled(DataLayer.ADDRESS): + row = await self.lookup_country(wkt) + + result = row_func(row, nres.ReverseResult) if result is not None: - await nres.add_result_details(self.conn, result, self.details) + assert row is not None + result.distance = row.distance + if hasattr(row, 'bbox'): + result.bbox = Bbox.from_wkb(row.bbox.data) + await nres.add_result_details(self.conn, [result], self.params) return result