Merge pull request #3045 from biswajit-k/taginfo

[nominatim.git] / nominatim / api / reverse.py

diff --git a/nominatim/api/reverse.py b/nominatim/api/reverse.py
index eadb63fb9886c4ba9dcde427291b031397623423..10c97cad221702e513d175c339bf9db46e73a148 100644 (file)
--- a/nominatim/api/reverse.py
+++ b/nominatim/api/reverse.py
@@ -7,7 +7,7 @@
 """
 Implementation of reverse geocoding.
 """
 """
 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
 
 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.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
 
 
 # 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
 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)
     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,
 
     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.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'))
 
                      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')
 
 
                    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,
 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.
     """
 
         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.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.
         """
 
     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.
         """
 
 
     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:
 
 
     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:
         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 = []
 
             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'))
             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'))
             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'))
             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)
             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'),
 
         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.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)
 
                 .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),
 
         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.postcode, inner.c.country_code,

-                        inner.c.linegeo.ST_LineInterpolatePoint(inner.c.position).label('centroid'),

                         inner.c.distance)
 
                         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,
 
         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'),
                                             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)\
                   .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,
 
         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_housenumber(inner),

+                        _interpolated_position(inner),

                         inner.c.postcode,
                         inner.c.postcode,

-                        inner.c.linegeo.ST_LineInterpolatePoint(inner.c.position).label('centroid'),

                         inner.c.distance)
 
                         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()
 
 
 
         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')
         """ 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)
         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,
         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
 
                 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')
                     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:
                     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
 
             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:
                                                                  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]:
 
 
     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)\
                   .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))\
 
         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)\
                                 .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)\
 
             touter = self.conn.t.placex.alias('outer')
             sql = _select_from_placex(inner)\


@@ -391,7 +438,7 @@ class ReverseGeocoder:
         return row
 
 
         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')
         """ 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
 
         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')
         """ 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)\
                       .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()
 
 
             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.
         """
 
 
     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)
 
 
 
         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:
 
         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:
         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
 
         return result