geovisio 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

geovisio/web/items.py

@@ -23,13 +23,13 @@ from geovisio.web.params import (
 from geovisio.utils.fields import Bounds
 
 import psycopg
-from datetime import datetime
 from psycopg.rows import dict_row
 from psycopg.sql import SQL
 from geovisio.web.utils import (
     accountIdOrDefault,
     cleanNoneInList,
     dbTsToStac,
+    dbTsToStacTZ,
     get_license_link,
     get_root_link,
     removeNoneInDict,
@@ -50,7 +50,7 @@ def dbPictureToStacItem(seqId, dbPic):
     ----------
     seqId : uuid
         Associated sequence ID
-    dbSeq : dict
+    dbPic : dict
         A row from pictures table in database (with id, geojson, ts, heading, cols, rows, width, height, prevpic, nextpic, prevpicgeojson, nextpicgeojson, exif fields)
 
     Returns
@@ -80,33 +80,38 @@ def dbPictureToStacItem(seqId, dbPic):
                     ),
                 ]
             ),
-            "properties": {
-                "datetime": dbTsToStac(dbPic["ts"]),
-                "created": dbTsToStac(dbPic["inserted_at"]),
-                # TODO : add "updated" TS for last edit time of metadata
-                "license": current_app.config["API_PICTURES_LICENSE_SPDX_ID"],
-                "view:azimuth": dbPic["heading"],
-                "pers:interior_orientation": (
-                    removeNoneInDict(
-                        {
-                            "camera_manufacturer": dbPic["metadata"].get("make"),
-                            "camera_model": dbPic["metadata"].get("model"),
-                            "focal_length": dbPic["metadata"].get("focal_length"),
-                            "field_of_view": dbPic["metadata"].get("field_of_view"),
-                        }
-                    )
-                    if "metadata" in dbPic
-                    and any(True for f in dbPic["metadata"] if f in ["make", "model", "focal_length", "field_of_view"])
-                    else {}
-                ),
-                "geovisio:status": dbPic.get("status"),
-                "geovisio:producer": dbPic["account_name"],
-                "original_file:size": dbPic["metadata"].get("originalFileSize"),
-                "original_file:name": dbPic["metadata"].get("originalFileName"),
-                "geovisio:image": _getHDJpgPictureURL(dbPic["id"], dbPic.get("status")),
-                "geovisio:thumbnail": _getThumbJpgPictureURL(dbPic["id"], dbPic.get("status")),
-                "exif": removeNoneInDict(cleanupExif(dbPic["exif"])),
-            },
+            "properties": removeNoneInDict(
+                {
+                    "datetime": dbTsToStac(dbPic["ts"]),
+                    "datetimetz": dbTsToStacTZ(dbPic["ts"], dbPic["metadata"].get("tz")),
+                    "created": dbTsToStac(dbPic["inserted_at"]),
+                    # TODO : add "updated" TS for last edit time of metadata
+                    "license": current_app.config["API_PICTURES_LICENSE_SPDX_ID"],
+                    "view:azimuth": dbPic["heading"],
+                    "pers:interior_orientation": (
+                        removeNoneInDict(
+                            {
+                                "camera_manufacturer": dbPic["metadata"].get("make"),
+                                "camera_model": dbPic["metadata"].get("model"),
+                                "focal_length": dbPic["metadata"].get("focal_length"),
+                                "field_of_view": dbPic["metadata"].get("field_of_view"),
+                            }
+                        )
+                        if "metadata" in dbPic
+                        and any(True for f in dbPic["metadata"] if f in ["make", "model", "focal_length", "field_of_view"])
+                        else {}
+                    ),
+                    "pers:pitch": dbPic["metadata"].get("pitch"),
+                    "pers:roll": dbPic["metadata"].get("roll"),
+                    "geovisio:status": dbPic.get("status"),
+                    "geovisio:producer": dbPic["account_name"],
+                    "original_file:size": dbPic["metadata"].get("originalFileSize"),
+                    "original_file:name": dbPic["metadata"].get("originalFileName"),
+                    "geovisio:image": _getHDJpgPictureURL(dbPic["id"], dbPic.get("status")),
+                    "geovisio:thumbnail": _getThumbJpgPictureURL(dbPic["id"], dbPic.get("status")),
+                    "exif": removeNoneInDict(cleanupExif(dbPic["exif"])),
+                }
+            ),
             "links": cleanNoneInList(
                 [
                     get_root_link(),
@@ -709,7 +714,6 @@ def searchItems():
     sqlWhere = [SQL("(p.status = 'ready' OR p.account_id = %(account)s)"), SQL("(is_sequence_visible_by_user(s, %(account)s))")]
     sqlParams: Dict[str, Any] = {"account": accountId}
     sqlSubQueryWhere = [SQL("(p.status = 'ready' OR p.account_id = %(account)s)")]
-
     order_by = SQL("")
 
     #
@@ -859,25 +863,24 @@ def searchItems():
     #
     # Database query
     #
-
     with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row, options="-c statement_timeout=30000") as conn:
         with conn.cursor() as cursor:
             query = SQL(
                 """
-            SELECT * FROM (
-				SELECT
-					p.id, p.ts, p.heading, p.metadata, p.inserted_at,
-					ST_AsGeoJSON(p.geom)::json AS geojson,
-					sp.seq_id, sp.rank AS rank,
-					accounts.name AS account_name, p.exif
-				FROM pictures p
-				LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
-				LEFT JOIN sequences s ON s.id = sp.seq_id
-				LEFT JOIN accounts ON p.account_id = accounts.id
-				WHERE {sqlWhere}
-				{orderBy}
-				LIMIT %(limit)s
-    ) pic
+SELECT * FROM (
+    SELECT
+        p.id, p.ts, p.heading, p.metadata, p.inserted_at,
+        ST_AsGeoJSON(p.geom)::json AS geojson,
+        sp.seq_id, sp.rank AS rank,
+        accounts.name AS account_name, p.exif
+    FROM pictures p
+    LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
+    LEFT JOIN sequences s ON s.id = sp.seq_id
+    LEFT JOIN accounts ON p.account_id = accounts.id
+    WHERE {sqlWhere}
+    {orderBy}
+    LIMIT %(limit)s
+) pic
 LEFT JOIN LATERAL (
     SELECT
     p.id AS prevpic, ST_AsGeoJSON(p.geom)::json AS prevpicgeojson
@@ -899,6 +902,7 @@ LEFT JOIN LATERAL (
 ;
 			"""
             ).format(sqlWhere=SQL(" AND ").join(sqlWhere), sqlSubQueryWhere=SQL(" AND ").join(sqlSubQueryWhere), orderBy=order_by)
+
             records = cursor.execute(query, sqlParams)
 
             items = [dbPictureToStacItem(str(dbPic["seq_id"]), dbPic) for dbPic in records]

geovisio/web/map.py

@@ -3,9 +3,9 @@
 
 import psycopg
 import io
-from typing import Optional, Dict, Any, Tuple, List
+from typing import Optional, Dict, Any, Tuple, List, Union
 from uuid import UUID
-from flask import Blueprint, current_app, send_file, request
+from flask import Blueprint, current_app, send_file, request, jsonify, url_for
 from geovisio.utils import auth
 from geovisio.utils.auth import Account
 from geovisio.web import params
@@ -15,6 +15,91 @@ from psycopg import sql
 
 bp = Blueprint("map", __name__, url_prefix="/api")
 
+ZOOM_GRID_SEQUENCES = 6
+ZOOM_PICTURES = 15
+
+
+def get_style_json(forUser: Optional[Union[UUID, str]] = None):
+    # Get correct vector tiles URL
+    tilesUrl = url_for("map.getTile", x="111", y="222", z="333", format="mvt", _external=True)
+    sourceId = "geovisio"
+    if forUser == "me":
+        tilesUrl = url_for("map.getMyTile", x="111", y="222", z="333", format="mvt", _external=True)
+        sourceId = "geovisio_me"
+    elif forUser is not None:
+        tilesUrl = url_for("map.getUserTile", userId=forUser, x="111", y="222", z="333", format="mvt", _external=True)
+        sourceId = f"geovisio_{str(forUser)}"
+    tilesUrl = tilesUrl.replace("111", "{x}").replace("222", "{y}").replace("333", "{z}")
+
+    # Display sequence on all zooms if user tiles, after grid on general tiles
+    sequenceOpacity = ["interpolate", ["linear"], ["zoom"], ZOOM_GRID_SEQUENCES, 0, ZOOM_GRID_SEQUENCES + 1, 1] if forUser is None else 1
+
+    layers = [
+        {
+            "id": f"{sourceId}_sequences",
+            "type": "line",
+            "source": sourceId,
+            "source-layer": "sequences",
+            "paint": {
+                "line-color": "#FF6F00",
+                "line-width": ["interpolate", ["linear"], ["zoom"], 0, 0.5, 10, 2, 14, 4, 16, 5, 22, 3],
+                "line-opacity": sequenceOpacity,
+            },
+            "layout": {
+                "line-cap": "square",
+            },
+        },
+        {
+            "id": f"{sourceId}_pictures",
+            "type": "circle",
+            "source": sourceId,
+            "source-layer": "pictures",
+            "paint": {
+                "circle-color": "#FF6F00",
+                "circle-radius": ["interpolate", ["linear"], ["zoom"], ZOOM_PICTURES, 4.5, 17, 8, 22, 12],
+                "circle-opacity": ["interpolate", ["linear"], ["zoom"], ZOOM_PICTURES, 0, ZOOM_PICTURES + 1, 1],
+                "circle-stroke-color": "#ffffff",
+                "circle-stroke-width": ["interpolate", ["linear"], ["zoom"], 17, 0, 20, 2],
+            },
+        },
+    ]
+
+    # Grid layer of general tiles
+    if forUser is None:
+        layers.append(
+            {
+                "id": f"{sourceId}_grid",
+                "type": "fill",
+                "source": sourceId,
+                "source-layer": "grid",
+                "paint": {
+                    "fill-color": ["interpolate-hcl", ["linear"], ["get", "coef"], 0, "#FFCC80", 0.5, "#E65100", 1, "#BF360C"],
+                    "fill-opacity": [
+                        "interpolate",
+                        ["linear"],
+                        ["zoom"],
+                        0,
+                        1,
+                        ZOOM_GRID_SEQUENCES - 2,
+                        1,
+                        ZOOM_GRID_SEQUENCES,
+                        0.8,
+                        ZOOM_GRID_SEQUENCES + 0.5,
+                        0,
+                    ],
+                },
+            }
+        )
+
+    style = {
+        "version": 8,
+        "name": "GeoVisio Vector Tiles",
+        "sources": {sourceId: {"type": "vector", "tiles": [tilesUrl], "minzoom": 0, "maxzoom": ZOOM_PICTURES}},
+        "layers": layers,
+    }
+
+    return jsonify(style)
+
 
 def checkTileValidity(z, x, y, format):
     """Check if tile parameters are valid
@@ -63,18 +148,38 @@ def _getTile(z: int, x: int, y: int, format: str, onlyForUser: Optional[UUID] =
             return send_file(io.BytesIO(res), mimetype="application/vnd.mapbox-vector-tile")
 
 
+@bp.route("/map/style.json")
+@user_dependant_response(False)
+def getStyle():
+    """Get vector tiles style.
+
+    This style file follows MapLibre Style Spec : https://maplibre.org/maplibre-style-spec/
+
+    ---
+    tags:
+        - Map
+    responses:
+        200:
+            description: Vector tiles style JSON
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/MapLibreStyleJSON'
+    """
+    return get_style_json()
+
+
 @bp.route("/map/<int:z>/<int:x>/<int:y>.<format>")
 @user_dependant_response(False)
 def getTile(z: int, x: int, y: int, format: str):
     """Get pictures and sequences as vector tiles
 
-    Vector tiles contains possibly two layers : sequences and pictures.
+    Vector tiles contains different layers based on zoom level : sequences, pictures or grid.
 
     Layer "sequences":
-      - Available on all zoom levels
-      - Available properties (all levels)
+      - Available on zoom levels >= 6
+      - Available properties:
         - id (sequence ID)
-      - Other properties (available on zoom levels >= 13)
         - account_id
         - model (camera make and model)
         - type (flat or equirectangular)
@@ -90,6 +195,14 @@ def getTile(z: int, x: int, y: int, format: str):
             - sequences (list of sequences ID this pictures belongs to)
         - type (flat or equirectangular)
         - model (camera make and model)
+
+    Layer "grid":
+      - Available on zoom levels 0 to 5 (included)
+      - Available properties:
+        - id
+        - nb_pictures
+        - coef (value from 0 to 1, relative quantity of available pictures)
+
     ---
     tags:
         - Map
@@ -135,27 +248,24 @@ def getTile(z: int, x: int, y: int, format: str):
 def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_filter: Optional[sql.SQL]) -> Tuple[sql.Composed, Dict]:
     """Returns appropriate SQL query according to given zoom"""
 
-    sequences_filter: List[sql.Composable] = [sql.SQL("s.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)")]
-    pictures_filter: List[sql.Composable] = [sql.SQL("p.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)")]
     params: Dict[str, Any] = {"x": x, "y": y, "z": z}
 
-    account = auth.get_current_account()
-    accountId = account.id if account is not None else None
-    # we never want to display deleted sequences on the map
-    sequences_filter.append(sql.SQL("s.status != 'deleted'"))
-    pictures_filter.append(sql.SQL("p.status != 'waiting-for-delete'"))
-
-    if onlyForUser:
-        sequences_filter.append(sql.SQL("s.account_id = %(account)s"))
-        pictures_filter.append(sql.SQL("p.account_id = %(account)s"))
-        params["account"] = onlyForUser
+    #############################################################
+    # SQL Filters
+    #
 
-    # we want to show only 'ready' collection to the general users
-    if not onlyForUser or accountId != str(onlyForUser):
-        sequences_filter.append(sql.SQL("s.status = 'ready'"))
-        pictures_filter.append(sql.SQL("p.status = 'ready'"))
-        pictures_filter.append(sql.SQL("s.status = 'ready'"))
+    # Basic filters
+    grid_filter: List[sql.Composable] = [sql.SQL("g.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)")]
+    sequences_filter: List[sql.Composable] = [
+        sql.SQL("s.status != 'deleted'"),  # we never want to display deleted sequences on the map
+        sql.SQL("s.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)"),
+    ]
+    pictures_filter: List[sql.Composable] = [
+        sql.SQL("p.status != 'waiting-for-delete'"),  # we never want to display deleted pictures on the map
+        sql.SQL("p.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)"),
+    ]
 
+    # Supplementary filters
     if additional_filter:
         sequences_filter.append(additional_filter)
         filter_str = additional_filter.as_string(None)
@@ -166,16 +276,46 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
             pic_additional_filter = sql.SQL(pic_additional_filter_str)  # type: ignore
             pictures_filter.append(sql.SQL("(") + sql.SQL(" OR ").join([pic_additional_filter, additional_filter]) + sql.SQL(")"))
 
+    # Per-user filters
+    if onlyForUser:
+        sequences_filter.append(sql.SQL("s.account_id = %(account)s"))
+        pictures_filter.append(sql.SQL("p.account_id = %(account)s"))
+        params["account"] = onlyForUser
+
+    # Not logged-in requests -> only show "ready" pics/sequences
+    account = auth.get_current_account()
+    accountId = account.id if account is not None else None
+    if not onlyForUser or accountId != str(onlyForUser):
+        sequences_filter.append(sql.SQL("s.status = 'ready'"))
+        pictures_filter.append(sql.SQL("p.status = 'ready'"))
+        pictures_filter.append(sql.SQL("s.status = 'ready'"))
+
+    #############################################################
+    # SQL Result columns/fields
+    #
+
+    grid_fields = [
+        sql.SQL("ST_AsMVTGeom(ST_Transform(geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
+        sql.SQL("id"),
+        sql.SQL("nb_pictures"),
+        sql.SQL(
+            """
+            ((CASE WHEN nb_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid)
+                THEN nb_pictures::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid) * 0.5
+                ELSE 0.5 + nb_pictures::float / (SELECT MAX(nb_pictures) FROM pictures_grid) * 0.5
+            END) * 10)::int / 10::float AS coef
+            """
+        ),
+    ]
     sequences_fields = [
         sql.SQL("ST_AsMVTGeom(ST_Transform(geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
         sql.SQL("id"),
     ]
     simplified_sequence_fields = [
-        sql.SQL("ST_Simplify(geom, 0.01) AS geom"),
-        sql.SQL("id"),
-        sql.SQL("status"),
+        sql.SQL("ST_AsMVTGeom(ST_Transform(ST_Simplify(geom, 0.01), 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
     ]
-    if z >= 7 or onlyForUser:
+
+    if z >= ZOOM_GRID_SEQUENCES or onlyForUser:
         sequences_fields.extend(
             [
                 sql.SQL("account_id"),
@@ -185,91 +325,146 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
                 sql.SQL("computed_capture_date AS date"),
             ]
         )
-        simplified_sequence_fields.extend(
-            [
-                sql.SQL("account_id"),
-                sql.SQL("computed_model"),
-                sql.SQL("computed_type"),
-                sql.SQL("computed_capture_date"),
-            ]
-        )
-    if z >= 15:
+
+    #############################################################
+    # SQL Full requests
+    #
+
+    # Full pictures + sequences (z15+)
+    if z >= ZOOM_PICTURES:
         query = sql.SQL(
             """
-SELECT mvtsequences.mvt || mvtpictures.mvt
-FROM (
-    SELECT ST_AsMVT(mvtgeomseqs.*, 'sequences') AS mvt
-    FROM (
-	SELECT
-	    {sequences_fields}
-	FROM sequences s
-	WHERE
-	    {sequences_filter}
-    ) mvtgeomseqs
-) mvtsequences,
-(
-    SELECT ST_AsMVT(mvtgeompics.*, 'pictures') AS mvt
-    FROM (
-	SELECT
-	    ST_AsMVTGeom(ST_Transform(p.geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom,
-	    p.id, p.ts, p.heading, p.account_id,
-	    NULLIF(p.status != 'ready' OR s.status != 'ready', FALSE) AS hidden,
-	    array_to_json(ARRAY_AGG(sp.seq_id)) AS sequences,
-        p.metadata->>'type' AS type,
-        TRIM(CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')) AS model
-	FROM pictures p
-	LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
-	LEFT JOIN sequences s ON s.id = sp.seq_id
-	WHERE
-	    {pictures_filter} 
-	GROUP BY 1, 2, 3, 4, 5, 6
-    ) mvtgeompics
-) mvtpictures
-"""
+            SELECT mvtsequences.mvt || mvtpictures.mvt
+            FROM (
+                SELECT ST_AsMVT(mvtgeomseqs.*, 'sequences') AS mvt
+                FROM (
+                SELECT
+                    {sequences_fields}
+                FROM sequences s
+                WHERE
+                    {sequences_filter}
+                ) mvtgeomseqs
+            ) mvtsequences,
+            (
+                SELECT ST_AsMVT(mvtgeompics.*, 'pictures') AS mvt
+                FROM (
+                SELECT
+                    ST_AsMVTGeom(ST_Transform(p.geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom,
+                    p.id, p.ts, p.heading, p.account_id,
+                    NULLIF(p.status != 'ready' OR s.status != 'ready', FALSE) AS hidden,
+                    array_to_json(ARRAY_AGG(sp.seq_id)) AS sequences,
+                    p.metadata->>'type' AS type,
+                    TRIM(CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')) AS model
+                FROM pictures p
+                LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
+                LEFT JOIN sequences s ON s.id = sp.seq_id
+                WHERE
+                    {pictures_filter} 
+                GROUP BY 1, 2, 3, 4, 5, 6
+                ) mvtgeompics
+            ) mvtpictures
+            """
         ).format(
             sequences_filter=sql.SQL(" AND ").join(sequences_filter),
             pictures_filter=sql.SQL(" AND ").join(pictures_filter),
             sequences_fields=sql.SQL(", ").join(sequences_fields),
         )
 
-    elif z >= 7:
+    # Full sequences (z7-14.9 and z0-14.9 for specific users)
+    elif z >= ZOOM_GRID_SEQUENCES + 1 or onlyForUser:
         query = sql.SQL(
             """
-SELECT ST_AsMVT(mvtsequences.*, 'sequences') AS mvt
-FROM (
-    SELECT
-	    {sequences_fields}
-    FROM sequences s
-    WHERE
-        {sequences_filter}
-) mvtsequences
-"""
+            SELECT ST_AsMVT(mvtsequences.*, 'sequences') AS mvt
+            FROM (
+                SELECT
+                    {sequences_fields}
+                FROM sequences s
+                WHERE
+                    {sequences_filter}
+            ) mvtsequences
+            """
         ).format(sequences_filter=sql.SQL(" AND ").join(sequences_filter), sequences_fields=sql.SQL(", ").join(sequences_fields))
-    else:
+
+    # Sequences + grid (z6-6.9)
+    elif z >= ZOOM_GRID_SEQUENCES:
         query = sql.SQL(
             """
-SELECT ST_AsMVT(mvtsequences.*, 'sequences') AS mvt
-FROM (
-    SELECT
-	    {sequences_fields}
-    FROM (
-        SELECT {simplified_sequence_fields}
-        FROM sequences s
-        WHERE
-            {sequences_filter}
-    ) s
-    WHERE geom IS NOT NULL
-) mvtsequences
-"""
+            SELECT mvtsequences.mvt || mvtgrid.mvt
+            FROM (
+                SELECT ST_AsMVT(mvtgeomseqs.*, 'sequences') AS mvt
+                FROM (
+                    SELECT
+                        {simplified_sequence_fields}
+                    FROM sequences s
+                    WHERE
+                        {sequences_filter}
+                ) mvtgeomseqs
+            ) mvtsequences,
+            (
+                SELECT ST_AsMVT(mvtgeomgrid.*, 'grid') AS mvt
+                FROM (
+                    SELECT
+                        {grid_fields}
+                    FROM pictures_grid g
+                    WHERE {grid_filter}
+                ) mvtgeomgrid
+            ) mvtgrid
+            """
         ).format(
             sequences_filter=sql.SQL(" AND ").join(sequences_filter),
-            sequences_fields=sql.SQL(", ").join(sequences_fields),
             simplified_sequence_fields=sql.SQL(", ").join(simplified_sequence_fields),
+            grid_filter=sql.SQL(" AND ").join(grid_filter),
+            grid_fields=sql.SQL(", ").join(grid_fields),
+        )
+
+    # Grid overview (all users + z0-5.9)
+    else:
+        query = sql.SQL(
+            """
+            SELECT ST_AsMVT(mvtgrid.*, 'grid') AS mvt
+            FROM (
+                SELECT
+                    {grid_fields}
+                FROM pictures_grid g
+                WHERE {grid_filter}
+            ) mvtgrid
+            """
+        ).format(
+            grid_filter=sql.SQL(" AND ").join(grid_filter),
+            grid_fields=sql.SQL(", ").join(grid_fields),
         )
 
     return query, params
 
 
+@bp.route("/users/<uuid:userId>/map/style.json")
+@user_dependant_response(False)
+def getUserStyle(userId: UUID):
+    """Get vector tiles style for a single user.
+
+    This style file follows MapLibre Style Spec : https://maplibre.org/maplibre-style-spec/
+
+    ---
+    tags:
+        - Map
+    parameters:
+        - name: userId
+          in: path
+          description: User ID
+          required: true
+          schema:
+            type: string
+    responses:
+        200:
+            description: Vector tiles style JSON
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/MapLibreStyleJSON'
+    """
+    return get_style_json(forUser=userId)
+
+
 @bp.route("/users/<uuid:userId>/map/<int:z>/<int:x>/<int:y>.<format>")
 def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
     """Get pictures and sequences as vector tiles for a specific user.
@@ -327,6 +522,27 @@ def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
     return _getTile(z, x, y, format, onlyForUser=userId, filter=filter)
 
 
+@bp.route("/users/me/map/style.json")
+@auth.login_required_with_redirect()
+def getMyStyle(account: Account):
+    """Get vector tiles style.
+
+    This style file follows MapLibre Style Spec : https://maplibre.org/maplibre-style-spec/
+
+    ---
+    tags:
+        - Map
+    responses:
+        200:
+            description: Vector tiles style JSON
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/MapLibreStyleJSON'
+    """
+    return get_style_json(forUser="me")
+
+
 @bp.route("/users/me/map/<int:z>/<int:x>/<int:y>.<format>")
 @auth.login_required_with_redirect()
 def getMyTile(account: Account, z: int, x: int, y: int, format: str):

geovisio/web/stac.py

@@ -119,6 +119,7 @@ def getLanding():
                 .replace("333", "{z}")
                 .replace("bob", "{userId}")
             )
+            userStyleUrl = url_for("map.getUserStyle", userId="bob", _external=True).replace("bob", "{userId}")
 
             if "stac_extensions" not in catalog:
                 catalog["stac_extensions"] = []
@@ -143,12 +144,24 @@ def getLanding():
                         "href": mapUrl,
                         "title": "Pictures and sequences vector tiles",
                     },
+                    {
+                        "rel": "xyz-style",
+                        "type": "application/json",
+                        "href": url_for("map.getStyle", _external=True),
+                        "title": "MapLibre Style JSON",
+                    },
                     {
                         "rel": "user-xyz",
                         "type": "application/vnd.mapbox-vector-tile",
                         "href": userMapUrl,
                         "title": "Pictures and sequences vector tiles for a given user",
                     },
+                    {
+                        "rel": "user-xyz-style",
+                        "type": "application/json",
+                        "href": userStyleUrl,
+                        "title": "MapLibre Style JSON",
+                    },
                     {
                         "rel": "collection-preview",
                         "type": "image/jpeg",