geovisio 2.7.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

geovisio/web/map.py

@@ -5,11 +5,12 @@ import io
 from typing import Optional, Dict, Any, Tuple, List, Union
 from uuid import UUID
 from flask import Blueprint, current_app, send_file, request, jsonify, url_for
-from flask_babel import gettext as _
+from flask_babel import gettext as _, get_locale
 from geovisio.utils import auth, db
 from geovisio.utils.auth import Account
 from geovisio.web import params
 from geovisio.web.utils import user_dependant_response
+from geovisio.web.configuration import _get_translated
 from geovisio import errors
 from psycopg import sql
 
@@ -32,7 +33,9 @@ def get_style_json(forUser: Optional[Union[UUID, str]] = None):
     tilesUrl = tilesUrl.replace("11111111", "{x}").replace("22222222", "{y}").replace("33333333", "{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
+    sequenceOpacity = (
+        ["interpolate", ["linear"], ["zoom"], ZOOM_GRID_SEQUENCES + 0.25, 0, ZOOM_GRID_SEQUENCES + 1, 1] if forUser is None else 1
+    )
 
     layers = [
         {
@@ -69,35 +72,74 @@ def get_style_json(forUser: Optional[Union[UUID, str]] = None):
         layers.append(
             {
                 "id": f"{sourceId}_grid",
-                "type": "fill",
+                "type": "circle",
                 "source": sourceId,
                 "source-layer": "grid",
+                "layout": {
+                    "circle-sort-key": ["get", "coef"],
+                },
                 "paint": {
-                    "fill-color": ["interpolate", ["linear"], ["get", "coef"], 0, "#FFCC80", 0.5, "#E65100", 1, "#BF360C"],
-                    "fill-opacity": [
+                    "circle-radius": [
                         "interpolate",
                         ["linear"],
                         ["zoom"],
-                        0,
                         1,
+                        # The match get coef rule allows to hide circle if coef is set to 0
+                        ["match", ["get", "coef"], 0, 0, 1],
                         ZOOM_GRID_SEQUENCES - 2,
-                        1,
+                        ["match", ["get", "coef"], 0, 0, 6],
+                        ZOOM_GRID_SEQUENCES - 1,
+                        ["match", ["get", "coef"], 0, 0, 2.5],
                         ZOOM_GRID_SEQUENCES,
-                        0.8,
-                        ZOOM_GRID_SEQUENCES + 0.5,
+                        ["match", ["get", "coef"], 0, 0, 4],
+                        ZOOM_GRID_SEQUENCES + 1,
+                        ["match", ["get", "coef"], 0, 0, 7],
+                    ],
+                    "circle-color": ["interpolate", ["linear"], ["get", "coef"], 0, "#FFA726", 0.5, "#E65100", 1, "#3E2723"],
+                    "circle-opacity": [
+                        "interpolate",
+                        ["linear"],
+                        ["zoom"],
+                        ZOOM_GRID_SEQUENCES - 2,
+                        0.5,
+                        ZOOM_GRID_SEQUENCES - 1,
+                        1,
+                        ZOOM_GRID_SEQUENCES + 0.75,
+                        1,
+                        ZOOM_GRID_SEQUENCES + 1,
                         0,
                     ],
                 },
             }
         )
 
+    apiSum = current_app.config["API_SUMMARY"]
+    userLang = get_locale().language
+
     style = {
         "version": 8,
-        "name": "GeoVisio Vector Tiles",
+        "name": _get_translated(apiSum.name, userLang)["label"],
+        "metadata": {
+            "panoramax:fields": {
+                "sequences": ["id", "account_id", "model", "type", "date", "gps_accuracy", "h_pixel_density"],
+                "pictures": ["id", "account_id", "ts", "heading", "sequences", "type", "model", "gps_accuracy", "h_pixel_density"],
+            }
+        },
         "sources": {sourceId: {"type": "vector", "tiles": [tilesUrl], "minzoom": 0, "maxzoom": ZOOM_PICTURES}},
         "layers": layers,
     }
 
+    if forUser is None:
+        style["metadata"]["panoramax:fields"]["grid"] = [
+            "id",
+            "nb_pictures",
+            "nb_360_pictures",
+            "nb_flat_pictures",
+            "coef",
+            "coef_360_pictures",
+            "coef_flat_pictures",
+        ]
+
     return jsonify(style)
 
 
@@ -173,34 +215,44 @@ def getStyle():
 def getTile(z: int, x: int, y: int, format: str):
     """Get pictures and sequences as vector tiles
 
-    Vector tiles contains different layers based on zoom level : sequences, pictures or grid.
+    Vector tiles contains different layers based on zoom level : grid, sequences or pictures.
+
+    Layer "grid":
+      - Available on zoom levels 0 to 7 (excluded)
+      - Available properties:
+        - id
+        - nb_pictures
+        - nb_360_pictures (number of 360° pictures)
+        - nb_flat_pictures (number of flat pictures)
+        - coef (value from 0 to 1, relative quantity of available pictures)
+        - coef_360_pictures (value from 0 to 1, relative quantity of available 360° pictures)
+        - coef_flat_pictures (value from 0 to 1, relative quantity of available flat pictures)
 
     Layer "sequences":
-      - Available on zoom levels >= 6
+      - Available on zoom levels >= 7 (and simplified version on zoom >= 6 and < 7)
       - Available properties:
         - id (sequence ID)
         - account_id
         - model (camera make and model)
         - type (flat or equirectangular)
         - date (capture date, as YYYY-MM-DD)
+        - gps_accuracy (95% confidence interval of GPS position precision, in meters)
+        - h_pixel_density (number of pixels on horizon per field of view degree)
 
     Layer "pictures":
-      - Available on zoom levels >= 13
+      - Available on zoom levels >= 15
       - Available properties:
         - id (picture ID)
         - account_id
         - ts (picture date/time)
         - heading (picture heading in degrees)
-            - sequences (list of sequences ID this pictures belongs to)
         - type (flat or equirectangular)
+        - hidden (picture visibility, true or false)
         - 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)
+        - gps_accuracy (95% confidence interval of GPS position precision, in meters)
+        - h_pixel_density (number of pixels on horizon per field of view degree)
+        - sequences (list of sequences ID this pictures belongs to)
+        - first_sequence (sequence ID, first from the list)
 
     ---
     tags:
@@ -210,7 +262,7 @@ def getTile(z: int, x: int, y: int, format: str):
     parameters:
         - name: z
           in: path
-          description: Zoom level (6 to 14)
+          description: Zoom level (6 to 15)
           required: true
           schema:
             type: number
@@ -294,16 +346,30 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
     #
 
     grid_fields = [
-        sql.SQL("ST_AsMVTGeom(ST_Transform(geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
+        sql.SQL("ST_AsMVTGeom(ST_Transform(ST_Centroid(geom), 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
         sql.SQL("id"),
         sql.SQL("nb_pictures"),
+        sql.SQL("nb_360_pictures"),
+        sql.SQL("nb_pictures - nb_360_pictures AS nb_flat_pictures"),
         sql.SQL(
-            """
-            ((CASE WHEN nb_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid)
+            """((CASE WHEN nb_pictures = 0 THEN 0 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
-            """
+            END) * 10)::int / 10::float AS coef"""
+        ),
+        sql.SQL(
+            """((CASE WHEN nb_360_pictures = 0 THEN 0
+                WHEN nb_360_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) from pictures_grid)
+                THEN nb_360_pictures::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) from pictures_grid) * 0.5
+                ELSE 0.5 + nb_360_pictures::float / (SELECT MAX(nb_360_pictures) FROM pictures_grid) * 0.5
+            END) * 10)::int / 10::float AS coef_360_pictures"""
+        ),
+        sql.SQL(
+            """((CASE WHEN (nb_pictures - nb_360_pictures) = 0 THEN 0 
+                WHEN (nb_pictures - nb_360_pictures) <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) from pictures_grid)
+                    THEN (nb_pictures - nb_360_pictures)::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) from pictures_grid) * 0.5
+                ELSE 0.5 + (nb_pictures - nb_360_pictures)::float / (SELECT MAX((nb_pictures - nb_360_pictures)) FROM pictures_grid) * 0.5
+            END) * 10)::int / 10::float AS coef_flat_pictures"""
         ),
     ]
     sequences_fields = [
@@ -322,6 +388,8 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
                 sql.SQL("computed_model AS model"),
                 sql.SQL("computed_type AS type"),
                 sql.SQL("computed_capture_date AS date"),
+                sql.SQL("computed_gps_accuracy AS gps_accuracy"),
+                sql.SQL("computed_h_pixel_density AS h_pixel_density"),
             ]
         )
 
@@ -351,15 +419,18 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
                     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
+                    TRIM(CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')) AS model,
+                    gps_accuracy_m AS gps_accuracy,
+                    h_pixel_density,
+                    array_to_json(ARRAY_AGG(sp.seq_id)) AS sequences,
+                    MIN(sp.seq_id::varchar) AS first_sequence
                 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
+                GROUP BY 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
                 ) mvtgeompics
             ) mvtpictures
             """
@@ -468,7 +539,34 @@ def getUserStyle(userId: UUID):
 @user_dependant_response(True)
 def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
     """Get pictures and sequences as vector tiles for a specific user.
-    This tile will contain the same layers as the generic tiles (from `/map/z/x/y.format` route), but with sequences properties on all levels
+
+    Vector tiles contains different layers based on zoom level : sequences, lowzoom_360pictures or pictures.
+
+    Layer "sequences":
+      - Available on all zoom levels
+      - Available properties:
+        - id (sequence ID)
+        - account_id
+        - model (camera make and model)
+        - type (flat or equirectangular)
+        - date (capture date, as YYYY-MM-DD)
+        - gps_accuracy (95% confidence interval of GPS position precision, in meters)
+        - h_pixel_density (number of pixels on horizon per field of view degree)
+
+    Layer "pictures":
+      - Available on zoom levels >= 15
+      - Available properties:
+        - id (picture ID)
+        - account_id
+        - ts (picture date/time)
+        - heading (picture heading in degrees)
+        - type (flat or equirectangular)
+        - hidden (picture visibility, true or false)
+        - model (camera make and model)
+        - gps_accuracy (95% confidence interval of GPS position precision, in meters)
+        - h_pixel_density (number of pixels on horizon per field of view degree)
+        - sequences (list of sequences ID this pictures belongs to)
+        - first_sequence (sequence ID, first from the list)
 
     ---
     tags:

geovisio/web/pages.py

@@ -0,0 +1,240 @@
+from flask import current_app, request, url_for, Blueprint
+from pydantic import BaseModel, ConfigDict
+from enum import Enum
+from typing import List
+from geovisio.utils import db, auth
+from geovisio.utils.link import Link, make_link
+from geovisio.errors import InvalidAPIUsage
+from flask_babel import gettext as _
+from psycopg.sql import SQL
+
+bp = Blueprint("pages", __name__, url_prefix="/api")
+
+
+class PageName(Enum):
+    end_user_license_agreement = "end-user-license-agreement"
+    terms_of_service = "terms-of-service"
+    end_user_license_agreement_summary = "end-user-license-agreement-summary"
+
+
+class PageLanguage(BaseModel):
+    """A specific language for the page"""
+
+    language: str
+    """The language (as ISO 639-2 code)"""
+
+    links: List[Link]
+    """Link to page content"""
+
+
+class PageSummary(BaseModel):
+    """Page summary"""
+
+    name: PageName
+    """Page name"""
+    languages: List[PageLanguage]
+    """Available translations"""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+
+def check_page_name(v: str) -> PageName:
+    try:
+        return PageName(v)
+    except ValueError:
+        raise InvalidAPIUsage(_("Page name is not recognized"), status_code=400)
+
+
+@bp.route("/pages/<page>", methods=["GET"])
+def getPageLanguages(page):
+    """List available languages for a single page
+    ---
+    tags:
+        - Configuration
+    parameters:
+        - name: page
+          in: path
+          description: Page name
+          required: true
+          schema:
+            $ref: '#/components/schemas/GeoVisioPageName'
+    responses:
+        200:
+            description: the languages list
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioPageSummary'
+    """
+
+    name = check_page_name(page)
+    langs = [d[0] for d in db.fetchall(current_app, SQL("SELECT lang FROM pages WHERE name = %(name)s"), {"name": name.value})]
+
+    # If page doesn't exist yet, send empty list of languages
+    if langs is None or len(langs) == 0:
+        langs = []
+
+    summary = PageSummary(
+        name=name,
+        languages=[PageLanguage(language=l, links=[make_link(rel="self", route="pages.getPage", page=name.value, lang=l)]) for l in langs],
+    )
+
+    return (
+        summary.model_dump_json(exclude_none=True),
+        200,
+        {
+            "Content-Type": "application/json",
+        },
+    )
+
+
+@bp.route("/pages/<page>/<lang>", methods=["GET"])
+def getPage(page, lang):
+    """Get page HTML content for a certain language
+    ---
+    tags:
+        - Configuration
+    parameters:
+        - name: page
+          in: path
+          description: Page name
+          required: true
+          schema:
+            $ref: '#/components/schemas/GeoVisioPageName'
+        - name: lang
+          in: path
+          description: Language ISO 639-2 code
+          required: true
+          schema:
+            type: string
+    responses:
+        200:
+            description: the HTML content for this page
+            content:
+                text/html:
+                    schema:
+                        type: string
+    """
+
+    page = check_page_name(page)
+    page_content = db.fetchone(
+        current_app,
+        SQL("SELECT content FROM pages WHERE name = %(name)s AND lang = %(lang)s"),
+        {"name": page.value, "lang": lang},
+    )
+
+    if page_content is None:
+        raise InvalidAPIUsage(_("Page not available in language %(l)s", l=lang), status_code=404)
+
+    return (
+        page_content[0],
+        200,
+        {
+            "Content-Type": "text/html",
+        },
+    )
+
+
+@bp.route("/pages/<page>/<lang>", methods=["POST", "PUT"])
+@auth.login_required()
+def postPage(page, lang, account):
+    """Save HTML content for a certain language of a page.
+
+    This call is only available for account with admin role.
+    ---
+    tags:
+        - Configuration
+    parameters:
+        - name: page
+          in: path
+          description: Page name
+          required: true
+          schema:
+            $ref: '#/components/schemas/GeoVisioPageName'
+        - name: lang
+          in: path
+          description: Language ISO 639-2 code
+          required: true
+          schema:
+            type: string
+    security:
+        - bearerToken: []
+        - cookieAuth: []
+    requestBody:
+        content:
+            text/html:
+                schema:
+                    type: string
+    responses:
+        200:
+            description: Successfully saved
+    """
+
+    name = check_page_name(page)
+
+    if not account.can_edit_pages():
+        raise InvalidAPIUsage(_("You must be logged-in as admin to edit pages"), 403)
+    if request.content_type != "text/html":
+        raise InvalidAPIUsage(_("Page content must be HTML (with " "Content-Type: text/html" " header set)"), 400)
+
+    with db.execute(
+        current_app,
+        SQL(
+            """
+INSERT INTO pages (name, lang, content)
+VALUES (%(name)s, %(lang)s, %(content)s)
+ON CONFLICT (name, lang) DO UPDATE SET content=EXCLUDED.content
+        """
+        ),
+        {"name": name.value, "lang": lang, "content": request.get_data(as_text=True)},
+    ) as res:
+        if not res.rowcount:
+            raise InvalidAPIUsage(_("Could not update page content"), 500)
+
+    return "", 200
+
+
+@bp.route("/pages/<page>/<lang>", methods=["DELETE"])
+@auth.login_required()
+def deletePage(page, lang, account):
+    """Delete HTML content for a certain language of a page.
+
+    This call is only available for account with admin role.
+    ---
+    tags:
+        - Configuration
+    parameters:
+        - name: page
+          in: path
+          description: Page name
+          required: true
+          schema:
+            $ref: '#/components/schemas/GeoVisioPageName'
+        - name: lang
+          in: path
+          description: Language ISO 639-2 code
+          required: true
+          schema:
+            type: string
+    security:
+        - bearerToken: []
+        - cookieAuth: []
+    responses:
+        200:
+            description: Successfully deleted
+    """
+
+    name = check_page_name(page)
+
+    if not account.can_edit_pages():
+        raise InvalidAPIUsage(_("You must be logged-in as admin to edit pages"), 403)
+
+    with db.execute(
+        current_app, SQL("DELETE FROM pages WHERE name = %(name)s AND lang = %(lang)s"), {"name": name.value, "lang": lang}
+    ) as res:
+        if res.rowcount == 0:
+            raise InvalidAPIUsage(_("Page not available in language %(l)s", l=lang), status_code=404)
+        elif not res.rowcount:
+            raise InvalidAPIUsage(_("Could not delete page content"), 500)
+
+    return "", 200

geovisio/web/params.py

@@ -358,6 +358,23 @@ def parse_filter(value: Optional[str]) -> Optional[sql.SQL]:
         return None
 
 
+def parse_picture_heading(heading: Optional[str]) -> Optional[int]:
+    if heading is None:
+        return None
+    try:
+        heading = int(heading)
+        if heading < 0 or heading > 360:
+            raise ValueError()
+        return heading
+    except ValueError:
+        raise errors.InvalidAPIUsage(
+            _(
+                "Heading is not valid, should be an integer in degrees from 0° to 360°. North is 0°, East = 90°, South = 180° and West = 270°."
+            ),
+            status_code=400,
+        )
+
+
 class _FilterAstUpdated(Evaluator):
     """
     We alter the parsed AST in order to always query for 'hidden' pictures when we query for 'deleted' ones