feat(geoapi): add label parameter to get_feature_tile_url for polygon layers

Author: majkshkurti

apps/geoapi/src/geoapi/routers/tiles.py

@@ -56,6 +56,7 @@ async def get_tile(
     cql_filter: CqlFilterDep = None,
     bbox: BBoxDep = None,
     limit: int = Query(default=None, ge=1, le=100000, description="Max features"),
+    label: bool = Query(default=False, description="Merge polygon label anchor points into tile response"),
 ) -> Response:
     """Get a vector tile for the specified collection and tile coordinates."""
     request_id = str(uuid.uuid4())[:8]
@@ -78,6 +79,7 @@ async def get_tile(
                 z=z,
                 x=x,
                 y=y,
+                label=label,
             )
             if result is not None:
                 tile_data, is_gzip, source = result
@@ -120,6 +122,7 @@ async def get_tile(
             z=z,
             x=x,
             y=y,
+            label=label,
         )
         if result is not None:
             tile_data, is_gzip, source = result

apps/geoapi/src/geoapi/services/tile_service.py

@@ -485,6 +485,7 @@ async def get_tile_from_pmtiles_only(
         z: int,
         x: int,
         y: int,
+        label: bool = False,
     ) -> Optional[tuple[bytes, bool, str]]:
         """Get tile directly from PMTiles without metadata lookup.
 
@@ -495,14 +496,15 @@ async def get_tile_from_pmtiles_only(
             z: Zoom level
             x: Tile X coordinate
             y: Tile Y coordinate
+            label: If True, serve anchor PMTiles (polygon label points) instead of main tiles
 
         Returns:
             Tuple of (tile_data, is_gzip, source) or None if PMTiles not available
         """
         if not self._pmtiles_exists(layer_info):
             return None
 
-        result = await self._get_tile_from_pmtiles(layer_info, z, x, y)
+        result = await self._get_tile_from_pmtiles(layer_info, z, x, y, label=label)
         if result is None:
             return None
 
@@ -540,6 +542,7 @@ async def get_tile_from_pmtiles_by_layer_id(
         z: int,
         x: int,
         y: int,
+        label: bool = False,
     ) -> Optional[tuple[bytes, bool, str]]:
         """Get tile directly from PMTiles using only layer_id (no schema lookup).
 
@@ -551,20 +554,24 @@ async def get_tile_from_pmtiles_by_layer_id(
             z: Zoom level
             x: Tile X coordinate
             y: Tile Y coordinate
+            label: If True, serve anchor PMTiles (polygon label points) instead of main tiles
 
         Returns:
             Tuple of (tile_data, is_gzip, source) or None if PMTiles not available
         """
         start_time = time.monotonic()
 
+        # Anchor tiles are cached under a separate key to avoid collision
+        cache_layer_id = layer_id + "_anchor" if label else layer_id
+
         # Check Redis cache first (fast path for distributed deployments)
-        cached = get_cached_tile(layer_id, z, x, y)
+        cached = get_cached_tile(cache_layer_id, z, x, y)
         if cached is not None:
             tile_data, is_gzip = cached
             elapsed_ms = (time.monotonic() - start_time) * 1000
             logger.debug(
                 "Redis cache hit for %s tile %d/%d/%d: %d bytes (%.1fms)",
-                layer_id[:8],
+                cache_layer_id[:8],
                 z,
                 x,
                 y,
@@ -595,14 +602,15 @@ async def get_tile_from_pmtiles_by_layer_id(
 
         tile_data, is_gzip = result
 
-        # Step 3: For polygon layers, also read from anchor PMTiles and concatenate
-        tile_data, is_gzip = await self._concat_anchor_tile(
-            pmtiles_path, z, x, y, tile_data, is_gzip
-        )
+        # Step 3: When label=True, merge anchor tile (polygon label points)
+        if label:
+            tile_data, is_gzip = await self._merge_anchor_tile(
+                pmtiles_path, z, x, y, tile_data, is_gzip
+            )
 
         # Cache in Redis for other pods
         if tile_data:
-            cache_tile(layer_id, z, x, y, tile_data, is_gzip)
+            cache_tile(cache_layer_id, z, x, y, tile_data, is_gzip)
 
         logger.info(
             "PMTiles %s tile %d/%d/%d: %d bytes (%.1fms)",
@@ -769,7 +777,7 @@ def _read_tile() -> (
         return result
 
     async def _get_tile_from_pmtiles(
-        self, layer_info: LayerInfo, z: int, x: int, y: int
+        self, layer_info: LayerInfo, z: int, x: int, y: int, label: bool = False
     ) -> Optional[tuple[bytes, bool]]:
         """Get tile data from PMTiles file using pmtiles library.
 
@@ -784,6 +792,7 @@ async def _get_tile_from_pmtiles(
             z: Zoom level
             x: Tile X coordinate
             y: Tile Y coordinate
+            label: If True, serve anchor PMTiles (polygon label points) instead of main tiles
 
         Returns:
             Tuple of (tile_data, is_gzip_compressed) or None if tile not found
@@ -907,14 +916,17 @@ def _read_tile() -> (
             else:
                 result = b"", False
 
-        # Concatenate anchor tile for polygon layers (separate anchor PMTiles)
         tile_data, is_gzip = result
-        tile_data, is_gzip = await self._concat_anchor_tile(
-            pmtiles_path, z, x, y, tile_data, is_gzip
-        )
+
+        # Merge anchor tile when labels are requested
+        if label:
+            tile_data, is_gzip = await self._merge_anchor_tile(
+                pmtiles_path, z, x, y, tile_data, is_gzip
+            )
+
         return tile_data, is_gzip
 
-    async def _concat_anchor_tile(
+    async def _merge_anchor_tile(
         self,
         pmtiles_path: Path,
         z: int,
@@ -923,11 +935,10 @@ async def _concat_anchor_tile(
         tile_data: bytes,
         is_gzip: bool,
     ) -> tuple[bytes, bool]:
-        """Concatenate anchor tile data for polygon layers.
+        """Merge anchor tile data into the main tile for polygon label support.
 
-        Checks if a separate anchor PMTiles file exists (containing label
-        anchor points from --convert-polygons-to-label-points). If so, reads
-        the anchor tile and concatenates the raw MVT bytes with the main tile.
+        Reads the anchor PMTiles file (label points from --convert-polygons-to-label-points)
+        and concatenates the raw MVT bytes with the main tile. Only called when label=True.
 
         Args:
             pmtiles_path: Path to the main PMTiles file
@@ -936,28 +947,25 @@ async def _concat_anchor_tile(
             is_gzip: Whether tile_data is gzip compressed
 
         Returns:
-            Tuple of (concatenated_tile_data, is_gzip)
+            Tuple of (merged_tile_data, is_gzip)
         """
         if not tile_data:
             return tile_data, is_gzip
 
-        # Derive anchor path: t_{layer_id}.pmtiles -> t_{layer_id}_anchor.pmtiles
         anchor_path = pmtiles_path.with_name(pmtiles_path.stem + "_anchor.pmtiles")
         if not anchor_path.exists():
             return tile_data, is_gzip
 
-        # Read anchor tile (has its own variable-depth pyramid + overzoom)
         anchor_result = await self._get_tile_from_pmtiles_path(anchor_path, z, x, y)
         if not anchor_result or not anchor_result[0]:
             return tile_data, is_gzip
 
         anchor_data, anchor_is_gzip = anchor_result
 
-        # Decompress both if needed — MVT concatenation requires raw protobuf
+        # MVT concatenation requires raw protobuf bytes
         main_bytes = gzip.decompress(tile_data) if is_gzip else tile_data
         anchor_bytes = gzip.decompress(anchor_data) if anchor_is_gzip else anchor_data
 
-        # MVT is protobuf — multiple layers can be concatenated at the byte level
         return main_bytes + anchor_bytes, False
 
     async def _overzoom_tile(

apps/web/components/map/Layers.tsx

@@ -108,14 +108,18 @@ const Layers = (props: LayersProps) => {
     return extendedFilter;
   };
 
-  const getFeatureTileUrl = (layer: ProjectLayer | Layer) => {
+  const getFeatureTileUrl = (layer: ProjectLayer | Layer, label = false) => {
     const extendedQuery = getLayerQueryFilter(layer);
-    let query = "";
+    const params = new URLSearchParams();
 
     if (extendedQuery && Object.keys(extendedQuery).length > 0) {
-      query = `?filter=${encodeURIComponent(JSON.stringify(extendedQuery))}`;
+      params.set("filter", JSON.stringify(extendedQuery));
+    }
+    if (label) {
+      params.set("label", "true");
     }
 
+    const query = params.size > 0 ? `?${params.toString()}` : "";
     const layerId = layer["layer_id"] || layer["id"];
     return `${GEOAPI_BASE_URL}/collections/${layerId}/tiles/WebMercatorQuad/{z}/{x}/{y}${query}`;
   };
@@ -215,8 +219,16 @@ const Layers = (props: LayersProps) => {
                 );
                 const mapLabelFilter = getMapLayerFilter(labelFilter);
 
+                const needsLabel =
+                  layer.feature_layer_geometry_type === "polygon" &&
+                  !!(layer.properties as FeatureLayerProperties)?.text_label;
+
                 return (
-                  <Source key={layer.id} type="vector" tiles={[getFeatureTileUrl(layer)]} maxzoom={14}>
+                  <Source
+                    key={layer.id}
+                    type="vector"
+                    tiles={[getFeatureTileUrl(layer, needsLabel)]}
+                    maxzoom={14}>
                     {!layer.properties?.["custom_marker"] && (
                       <MapLayer
                         key={getLayerKey(layer)}