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

geovisio/web/docs.py

@@ -120,6 +120,50 @@ API_CONFIG = {
             "STACItemSearchBody": {
                 "$ref": f"https://api.stacspec.org/v{utils.STAC_VERSION}/item-search/openapi.yaml#/components/schemas/searchBody"
             },
+            "MapLibreStyleJSON": {
+                "type": "object",
+                "description": """
+MapLibre Style JSON, see https://maplibre.org/maplibre-style-spec/ for reference.
+
+Source ID is either \"geovisio\" or \"geovisio_\{userId\}\".
+
+Layers ID are \"geovisio_grid\", \"geovisio_sequences\" and \"geovisio_pictures\", or with user UUID included (\"geovisio_\{userId\}_sequences\" and \"geovisio_\{userId\}_pictures\").
+
+Note that you may not rely only on these ID that could change through time.
+""",
+                "properties": {
+                    "version": {"type": "integer", "example": 8},
+                    "name": {"type": "string", "example": "GeoVisio Vector Tiles"},
+                    "sources": {
+                        "type": "object",
+                        "properties": {
+                            "geovisio": {
+                                "type": "object",
+                                "properties": {
+                                    "type": {"type": "string", "example": "vector"},
+                                    "minzoom": {"type": "integer", "example": "0"},
+                                    "maxzoom": {"type": "integer", "example": "15"},
+                                    "tiles": {"type": "array", "items": {"type": "string"}},
+                                },
+                            }
+                        },
+                    },
+                    "layers": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {"type": "string"},
+                                "source": {"type": "string"},
+                                "source-layer": {"type": "string"},
+                                "type": {"type": "string"},
+                                "paint": {"type": "object"},
+                                "layout": {"type": "object"},
+                            },
+                        },
+                    },
+                },
+            },
             "GeoVisioLanding": {
                 "allOf": [
                     {"$ref": "#/components/schemas/STACLanding"},
@@ -223,7 +267,14 @@ API_CONFIG = {
             "GeoVisioCollection": {
                 "allOf": [
                     {"$ref": "#/components/schemas/STACCollection"},
-                    {"type": "object", "properties": {"stats:items": {"$ref": "#/components/schemas/STACStatsForItems"}}},
+                    {
+                        "type": "object",
+                        "properties": {
+                            "stats:items": {"$ref": "#/components/schemas/STACStatsForItems"},
+                            "geovisio:status": {"$ref": "#/components/schemas/GeoVisioCollectionStatus"},
+                            "geovisio:sorted-by": {"$ref": "#/components/schemas/GeoVisioCollectionSortedBy"},
+                        },
+                    },
                 ]
             },
             "GeoVisioCollectionImportStatus": {
@@ -264,6 +315,26 @@ API_CONFIG = {
                         "type": "string",
                         "description": "The sequence title (publicly displayed)",
                     },
+                    "relative_heading": {
+                        "type": "number",
+                        "minimum": -180,
+                        "maximum": 180,
+                        "description": "The relative heading (in degrees), offset based on movement path (0° = looking forward, -90° = looking left, 90° = looking right). Headings are unchanged if this parameter is not set.",
+                    },
+                    "sortby": {
+                        "description": """
+Define the pictures sort order based on given property. Sort order is defined based on preceding '+' (asc) or '-' (desc).
+
+Available properties are:
+* `gpsdate`: sort by GPS datetime
+* `filedate`: sort by the camera-generated capture date. This is based on EXIF tags `Exif.Image.DateTimeOriginal`, `Exif.Photo.DateTimeOriginal`, `Exif.Image.DateTime` or `Xmp.GPano.SourceImageCreateTime` (in this order).
+* `filename`: sort by the original picture file name
+
+If unset, sort order is unchanged.
+""",
+                        "type": "string",
+                        "enum": ["+gpsdate", "-gpsdate", "+filedate", "-filedate", "+filename", "-filename"],
+                    },
                 },
             },
             "GeoVisioCollectionItems": {
@@ -285,6 +356,11 @@ API_CONFIG = {
                             "properties": {
                                 "type": "object",
                                 "properties": {
+                                    "datetimetz": {
+                                        "type": "string",
+                                        "format": "date-time",
+                                        "title": "Date & time with original timezone information",
+                                    },
                                     "geovisio:status": {"$ref": "#/components/schemas/GeoVisioItemStatus"},
                                     "geovisio:producer": {"type": "string"},
                                     "geovisio:image": {"type": "string", "format": "uri"},
@@ -357,6 +433,49 @@ API_CONFIG = {
                     },
                 },
             },
+            "GeoVisioItemSearchBody": {
+                "description": "The search criteria",
+                "type": "object",
+                "allOf": [
+                    {"$ref": "#/components/schemas/STACItemSearchBody"},
+                    {
+                        "type": "object",
+                        "properties": {
+                            "place_position": {
+                                "description": "Geographical coordinates (lon,lat) of a place you'd like to have pictures of. Returned pictures are either 360° or looking in direction of wanted place.",
+                                "type": "string",
+                                "pattern": "-?\d+\.\d+,-?\d+\.\d+",
+                            },
+                            "place_distance": {
+                                "description": "Distance range (in meters) to search pictures for a particular place (place_position). Default range is 3-15. Only used if place_position parameter is defined.",
+                                "type": "string",
+                                "pattern": "\d+-\d+",
+                            },
+                            "place_fov_tolerance": {
+                                "type": "integer",
+                                "minimum": 2,
+                                "maximum": 180,
+                                "description": """
+Tolerance on how much the place should be centered in nearby pictures:
+
+ * A lower value means place have to be at the very center of picture
+ * A higher value means place could be more in picture sides
+
+Value is expressed in degrees (from 2 to 180, defaults to 30°), and represents the acceptable field of view relative to picture heading. Only used if place_position parameter is defined.
+
+Example values are:
+
+ * <= 30° for place to be in the very center of picture
+ * 60° for place to be in recognizable human field of view
+ * 180° for place to be anywhere in a wide-angle picture
+
+Note that this parameter is not taken in account for 360° pictures, as by definition a nearby place would be theorically always visible in it.
+""",
+                            },
+                        },
+                    },
+                ],
+            },
             "GeoVisioPatchItem": {
                 "type": "object",
                 "properties": {
@@ -365,10 +484,29 @@ API_CONFIG = {
                         "description": "Should the picture be publicly visible ?",
                         "enum": ["true", "false", "null"],
                         "default": "null",
-                    }
+                    },
+                    "heading": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 360,
+                        "description": "The picture heading (in degrees). North is 0°, East = 90°, South = 180° and West = 270°.",
+                    },
                 },
             },
             "GeoVisioCollectionStatus": {"type": "string", "enum": ["ready", "broken", "preparing", "waiting-for-process"]},
+            "GeoVisioCollectionSortedBy": {
+                "description": """
+Define the pictures sort order of the sequence. Null by default, and can be set via the collection PATCH.
+Sort order is defined based on preceding '+' (asc) or '-' (desc).
+
+Available properties are:
+* `gpsdate`: sort by GPS datetime
+* `filedate`: sort by the camera-generated capture date. This is based on EXIF tags `Exif.Image.DateTimeOriginal`, `Exif.Photo.DateTimeOriginal`, `Exif.Image.DateTime` or `Xmp.GPano.SourceImageCreateTime` (in this order).
+* `filename`: sort by the original picture file name
+""",
+                "type": "string",
+                "enum": ["+gpsdate", "-gpsdate", "+filedate", "-filedate", "+filename", "-filename"],
+            },
             "GeoVisioItemStatus": {
                 "type": "string",
                 "enum": ["ready", "broken", "waiting-for-process"],
@@ -469,7 +607,7 @@ API_CONFIG = {
                     },
                 },
             },
-            "JWToken": {
+            "GeoVisioEncodedToken": {
                 "type": "object",
                 "properties": {
                     "id": {"type": "string"},
@@ -483,7 +621,7 @@ API_CONFIG = {
             },
             "JWTokenClaimable": {
                 "allOf": [
-                    {"$ref": "#/components/schemas/JWToken"},
+                    {"$ref": "#/components/schemas/GeoVisioEncodedToken"},
                     {
                         "type": "object",
                         "properties": {
@@ -561,6 +699,42 @@ Usage doc can be found here: https://docs.geoserver.org/2.23.x/en/user/tutorials
                 "required": False,
                 "schema": {"type": "string"},
             },
+            "GeoVisio_place_position": {
+                "name": "place_position",
+                "in": "query",
+                "required": False,
+                "description": "Geographical coordinates (lon,lat) of a place you'd like to have pictures of. Returned pictures are either 360° or looking in direction of wanted place.",
+                "schema": {"type": "string", "pattern": "-?\d+\.\d+,-?\d+\.\d+"},
+            },
+            "GeoVisio_place_distance": {
+                "name": "place_distance",
+                "in": "query",
+                "required": False,
+                "description": "Distance range (in meters) to search pictures for a particular place (place_position). Default range is 3-15. Only used if place_position parameter is defined.",
+                "schema": {"type": "string", "pattern": "\d+-\d+", "default": "3-15"},
+            },
+            "GeoVisio_place_fov_tolerance": {
+                "name": "place_fov_tolerance",
+                "in": "query",
+                "description": """
+Tolerance on how much the place should be centered in nearby pictures:
+
+ * A lower value means place have to be at the very center of picture
+ * A higher value means place could be more in picture sides
+
+Value is expressed in degrees (from 2 to 180, defaults to 30°), and represents the acceptable field of view relative to picture heading. Only used if place_position parameter is defined.
+
+Example values are:
+
+ * <= 30° for place to be in the very center of picture
+ * 60° for place to be in recognizable human field of view
+ * 180° for place to be anywhere in a wide-angle picture
+
+Note that this parameter is not taken in account for 360° pictures, as by definition a nearby place would be theorically always visible in it.
+""",
+                "required": False,
+                "schema": {"type": "integer", "minimum": 2, "maximum": 180, "default": 30},
+            },
             "OGC_sortby": {
                 "name": "sortby",
                 "in": "query",

geovisio/web/items.py

@@ -1,8 +1,6 @@
-import io
 import json
 import logging
 import os
-import re
 from typing import Dict, Optional, Any
 from urllib.parse import unquote
 from psycopg.types.json import Jsonb
@@ -10,6 +8,7 @@ from werkzeug.datastructures import MultiDict
 from uuid import UUID
 from geovisio import errors, utils
 from geovisio.utils import auth
+from geovisio.utils.pictures import cleanupExif
 from geovisio.web.params import (
     as_latitude,
     as_longitude,
@@ -18,17 +17,19 @@ from geovisio.web.params import (
     parse_datetime_interval,
     parse_bbox,
     parse_list,
+    parse_lonlat,
+    parse_distance_range,
 )
 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,
@@ -41,9 +42,6 @@ from geovisio.workers import runner_pictures
 
 bp = Blueprint("stac_items", __name__, url_prefix="/api")
 
-RGX_BINARY_KEY = re.compile(".+\..+\.0x[0-f]+")
-RGX_BINARY_VAL = re.compile("(\d{1,3} ){20,}\d{1,3}")  # At least 21 blocks of 1-3 digits values
-
 
 def dbPictureToStacItem(seqId, dbPic):
     """Transforms a picture extracted from database into a STAC Item
@@ -52,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
@@ -82,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(),
@@ -235,30 +238,6 @@ def dbPictureToStacItem(seqId, dbPic):
     return item
 
 
-def cleanupExif(exif: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
-    """Removes things from EXIF dictionnary that should not land in STAC responses
-    >>> cleanupExif({'A': 'B', 'Exif.Sony.0x0102': 'Blablabla'})
-    {'A': 'B'}
-    >>> cleanupExif({'A': 'B', 'Exif.Photo.MakerNote': 'Blablabla'})
-    {'A': 'B'}
-    >>> cleanupExif({'A': 'B', 'Exif.Sony.Whatever': '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21'})
-    {'A': 'B'}
-    >>> cleanupExif({'A': 'B', 'Exif.Sony.Whatever': '1 2 3 4 5'})
-    {'A': 'B', 'Exif.Sony.Whatever': '1 2 3 4 5'}
-    """
-
-    if exif is None:
-        return None
-
-    cleanExif = {}
-
-    for k, v in exif.items():
-        if not (k in ["Exif.Photo.MakerNote"] or RGX_BINARY_KEY.match(k) or RGX_BINARY_VAL.match(v)):
-            cleanExif[k] = v
-
-    return cleanExif
-
-
 def get_first_rank_of_page(rankToHave: int, limit: Optional[int]) -> int:
     """if there is a limit, we try to emulate a page, so we'll return the nth page that should contain this picture
     Note: the ranks starts from 1
@@ -715,13 +694,16 @@ def searchItems():
             - $ref: '#/components/parameters/STAC_limit'
             - $ref: '#/components/parameters/STAC_ids'
             - $ref: '#/components/parameters/STAC_collectionsArray'
+            - $ref: '#/components/parameters/GeoVisio_place_position'
+            - $ref: '#/components/parameters/GeoVisio_place_distance'
+            - $ref: '#/components/parameters/GeoVisio_place_fov_tolerance'
     post:
         requestBody:
             required: true
             content:
               application/json:
                 schema:
-                  $ref: '#/components/schemas/STACItemSearchBody'
+                  $ref: '#/components/schemas/GeoVisioItemSearchBody'
     responses:
         200:
             $ref: '#/components/responses/STAC_search'
@@ -732,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("")
 
     #
@@ -779,6 +760,52 @@ def searchItems():
         sqlWhere.append(SQL("p.ts <= %(maxts)s::timestamp with time zone"))
         sqlParams["maxts"] = max_dt
 
+    # Place position & distance
+    place_pos = parse_lonlat(args.getlist("place_position"), "place_position")
+    if place_pos is not None:
+        sqlParams["placex"] = place_pos[0]
+        sqlParams["placey"] = place_pos[1]
+
+        # Filter to keep pictures in acceptable distance range to POI
+        place_dist = parse_distance_range(args.get("place_distance"), "place_distance") or [3, 15]
+        sqlParams["placedmin"] = place_dist[0]
+        sqlParams["placedmax"] = place_dist[1]
+
+        sqlWhere.append(
+            SQL(
+                """
+                ST_Intersects(
+                    p.geom,
+                    ST_Difference(
+                    ST_Buffer(ST_Point(%(placex)s, %(placey)s)::geography, %(placedmax)s)::geometry,
+                        ST_Buffer(ST_Point(%(placex)s, %(placey)s)::geography, %(placedmin)s)::geometry
+                    )
+                )
+                """
+            )
+        )
+
+        # Compute acceptable field of view
+        place_fov_tolerance = args.get("place_fov_tolerance", type=int, default=30)
+        if place_fov_tolerance < 2 or place_fov_tolerance > 180:
+            raise errors.InvalidAPIUsage(
+                "Parameter place_fov_tolerance must be either empty or a number between 2 and 180", status_code=400
+            )
+        else:
+            sqlParams["placefov"] = place_fov_tolerance / 2
+
+        sqlWhere.append(
+            SQL(
+                """(
+                p.metadata->>'type' = 'equirectangular'
+                OR ST_Azimuth(p.geom, ST_Point(%(placex)s, %(placey)s, 4326)) BETWEEN radians(p.heading - %(placefov)s) AND radians(p.heading + %(placefov)s)
+            )"""
+            )
+        )
+
+        # Sort pictures by nearest to POI
+        order_by = SQL("ORDER BY p.geom <-> ST_Point(%(placex)s, %(placey)s, 4326)")
+
     # Intersects
     if args.get("intersects") is not None:
         try:
@@ -836,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
@@ -876,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]
@@ -1085,25 +1112,37 @@ def patchCollectionItem(collectionId, itemId, account):
     # Parse received parameters
     metadata = {}
     content_type = (request.headers.get("Content-Type") or "").split(";")[0]
-    if request.is_json:
-        metadata["visible"] = request.json.get("visible")
-    elif content_type in ["multipart/form-data", "application/x-www-form-urlencoded"]:
-        metadata["visible"] = request.form.get("visible")
-
-    # Check if visibility param is valid
-    if metadata.get("visible") is None:
-        # /!\ As visible is the only editable thing for now, we can return if it's null
-        # The line below may be removed when other parameters will be available for patching
-        # Otherwise, you might want to do: visible = None
-        return getCollectionItem(collectionId, itemId)
+    for param in ["visible", "heading"]:
+        if request.is_json and request.json:
+            metadata[param] = request.json.get(param)
+        elif content_type in ["multipart/form-data", "application/x-www-form-urlencoded"]:
+            metadata[param] = request.form.get(param)
+
+    visible = metadata.get("visible")
+    if visible is not None:
+        if visible not in ["true", "false"]:
+            raise errors.InvalidAPIUsage("Picture visibility parameter (visible) should be either unset, true or false", status_code=400)
+        visible = visible == "true"
+
+    # Check if heading is valid
+    heading = metadata.get("heading")
+    if heading is not None:
+        try:
+            heading = int(heading)
+            if heading < 0 or heading > 360:
+                raise ValueError()
+        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,
+            )
 
-    elif metadata.get("visible") in ["true", "false"]:
-        visible = metadata.get("visible") == "true"
-    else:
-        raise errors.InvalidAPIUsage("Picture visibility parameter (visible) should be either unset, true or false", status_code=400)
+    # If no parameter is set
+    if {visible, heading} == {None}:
+        return getCollectionItem(collectionId, itemId)
 
     # Check if picture exists and if given account is authorized to edit
-    with psycopg.connect(current_app.config["DB_URL"]) as conn:
+    with psycopg.connect(current_app.config["DB_URL"], row_factory=dict_row) as conn:
         with conn.cursor() as cursor:
             pic = cursor.execute("SELECT status, account_id FROM pictures WHERE id = %s", [itemId]).fetchone()
 
@@ -1112,34 +1151,50 @@ def patchCollectionItem(collectionId, itemId, account):
                 raise errors.InvalidAPIUsage(f"Picture {itemId} wasn't found in database", status_code=404)
 
             # Account associated to picture doesn't match current user
-            if account is not None and account.id != str(pic[1]):
+            if account is not None and account.id != str(pic["account_id"]):
                 raise errors.InvalidAPIUsage("You're not authorized to edit this picture", status_code=403)
 
+            sqlUpdates = []
+            sqlParams = {"id": itemId, "account": account.id}
+
             # Let's edit this picture
-            oldStatus = pic[0]
-            newStatus = None
+            oldStatus = pic["status"]
+            if oldStatus not in ["ready", "hidden"]:
+                # Picture is in a preparing/broken/... state so no edit possible
+                raise errors.InvalidAPIUsage(
+                    f"Picture {itemId} is in {oldStatus} state, its visibility can't be changed for now", status_code=400
+                )
 
+            newStatus = None
             if visible is not None:
-                if visible is True and oldStatus == "hidden":
-                    newStatus = "ready"
-                elif visible is False and oldStatus == "ready":
-                    newStatus = "hidden"
-                elif (visible is True and oldStatus == "ready") or (visible is False and oldStatus == "hidden"):
-                    newStatus = oldStatus
-
-                    # /!\ As visible is the only editable thing for now, we can return if it's unchanged
-                    # The line below may be removed when other parameters will be available for patching
-                    return getCollectionItem(collectionId, itemId)
-
-                else:
-                    # Picture is in a preparing/broken/... state so no edit possible
-                    raise errors.InvalidAPIUsage(
-                        f"Picture {itemId} is in {oldStatus} state, its visibility can't be changed for now", status_code=400
-                    )
-
-            if newStatus:
-                cursor.execute("UPDATE pictures SET status = %s WHERE id = %s", [newStatus, itemId])
-                conn.commit()
+                newStatus = "ready" if visible is True else "hidden"
+                if newStatus != oldStatus:
+                    sqlUpdates.append(SQL("status = %(status)s"))
+                    sqlParams["status"] = newStatus
+
+            if heading is not None:
+                sqlUpdates.extend([SQL("heading = %(heading)s"), SQL("heading_computed = false")])
+                sqlParams["heading"] = heading
+
+            if not sqlUpdates:
+                # Nothing to change, we can return the item
+                return getCollectionItem(collectionId, itemId)
+
+            # Note: we set the field `last_account_to_edit` to track who changed the collection last (later we'll make it possible for everybody to edit some collection fields)
+            # setting this field will trigger the history tracking of the collection (using postgres trigger)
+            sqlUpdates.append(SQL("last_account_to_edit = %(account)s"))
+
+            cursor.execute(
+                SQL(
+                    """
+                    UPDATE pictures
+                    SET {updates}
+                    WHERE id = %(id)s
+                    """
+                ).format(updates=SQL(", ").join(sqlUpdates)),
+                sqlParams,
+            )
+            conn.commit()
 
             # Redirect response to a classic GET
             return getCollectionItem(collectionId, itemId)