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

geovisio/translations/nl/LC_MESSAGES/messages.po

@@ -8,26 +8,29 @@ msgstr ""
 "Project-Id-Version: PROJECT VERSION\n"
 "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
 "POT-Creation-Date: 2024-07-10 14:10+0200\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: Automatically generated\n"
-"Language-Team: none\n"
+"PO-Revision-Date: 2024-11-14 23:10+0000\n"
+"Last-Translator: BrechtD <brecht.devriese92@gmail.com>\n"
+"Language-Team: Dutch <http://weblate.panoramax.xyz/projects/panoramax/api/nl/"
+">\n"
 "Language: nl\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=n != 1;\n"
+"X-Generator: Weblate 5.4.3\n"
 "Generated-By: Babel 2.15.0\n"
 
 #: geovisio/templates/main.html:45
 msgid "Simple 360° geolocated pictures hosting"
-msgstr ""
+msgstr "Eenvoudige hosting van 360°-geolokaliseerde foto's"
 
 #: geovisio/templates/main.html:47
 msgid "Full page version"
-msgstr ""
+msgstr "Volledige pagina"
 
 #: geovisio/templates/main.html:51
 msgid "Viewer"
-msgstr ""
+msgstr "Viewee"
 
 #: geovisio/templates/main.html:52
 msgid "Embed pre-configured viewer"
@@ -36,42 +39,43 @@ msgstr ""
 #: geovisio/templates/main.html:53
 msgid "Easiest way to have a working GeoVisio viewer on your website"
 msgstr ""
+"Gemakkelijkste manier om een GeoVisio viewer op uw webpagina te plaatsen"
 
 #: geovisio/templates/main.html:59
 msgid "Use JS library"
-msgstr ""
+msgstr "Gebruik JS bibliotheek"
 
 #: geovisio/templates/main.html:60
 msgid "A completely configurable viewer for your website"
-msgstr ""
+msgstr "Een compleet configureerbare viewer voor uw website"
 
 #: geovisio/templates/main.html:82
 msgid "Links"
-msgstr ""
+msgstr "Links"
 
 #: geovisio/templates/main.html:84
 msgid "Pictures viewer"
-msgstr ""
+msgstr "Foto viewer"
 
 #: geovisio/templates/main.html:86
 msgid "API docs"
-msgstr ""
+msgstr "API documentatie"
 
 #: geovisio/templates/main.html:88
 msgid "JS library docs"
-msgstr ""
+msgstr "JS bibliotheek documentatie"
 
 #: geovisio/templates/main.html:90
 msgid "Repositories"
-msgstr ""
+msgstr "Archief"
 
 #: geovisio/templates/viewer.html:22
 msgid "You need to enable JavaScript to run this app."
-msgstr ""
+msgstr "U moet JavaScript toestaan om deze te kunnen gebruiken."
 
 #: geovisio/utils/auth.py:164
 msgid "Authentication is mandatory"
-msgstr ""
+msgstr "Authenticatie is verplicht"
 
 #: geovisio/utils/auth.py:292
 msgid "Only Bearer token are supported"
@@ -134,7 +138,7 @@ msgstr ""
 
 #: geovisio/utils/upload_set.py:143 geovisio/web/params.py:359
 msgid "Unsupported filter parameter"
-msgstr ""
+msgstr "Filter parameter is niet ondersteund"
 
 #: geovisio/web/auth.py:62
 msgid "Impossible to finish authentication flow"
@@ -592,3 +596,7 @@ msgstr ""
 #: geovisio/web/utils.py:51
 msgid "No default account defined, please contact your instance administrator"
 msgstr ""
+
+#: geovisio/utils/excluded_areas.py:82
+msgid "Impossible to find excluded area"
+msgstr "Onmogelijk om uitgesloten gebied te vinden"

geovisio/utils/pictures.py

@@ -15,6 +15,7 @@ from fs.path import dirname
 from psycopg.errors import UniqueViolation, InvalidParameterValue
 from geovisio import utils, errors
 from geopic_tag_reader import reader
+import re
 
 log = logging.getLogger(__name__)
 
@@ -504,9 +505,10 @@ class InvalidMetadataValue(Exception):
 
 
 class MetadataReadingError(Exception):
-    def __init__(self, details):
+    def __init__(self, details, missing_mandatory_tags=[]):
         super().__init__()
         self.details = details
+        self.missing_mandatory_tags = missing_mandatory_tags
 
 
 def insertNewPictureInDatabase(
@@ -588,7 +590,7 @@ def insertNewPictureInDatabase(
         # Flat pictures = variable fov
         if metadata["type"] == "flat":
             make, model = metadata.get("make"), metadata.get("model")
-            if make is not None and model is not None:
+            if make is not None and model is not None and metadata["focal_length"] != 0:
                 db.execute("SET pg_trgm.similarity_threshold = 0.9")
                 db.execute(
                     """
@@ -630,31 +632,21 @@ def insertNewPictureInDatabase(
 # Note: we don't want to store and expose exif binary fields as they are difficult to use and take a lot of storage in the database (~20% for maker notes only)
 # This list has been queried from real data (cf [this comment](https://gitlab.com/panoramax/server/api/-/merge_requests/241#note_1790580636)).
 # Update this list (and do a sql migration) if new binary fields are added
+# Note that tags ending in ".0xXXXX" are automatically striped by a regex
 BLACK_LISTED_BINARY_EXIF_FIELDS = set(
     [
         "Exif.Photo.MakerNote",
-        "Exif.Photo.0xea1c",
-        "Exif.Image.0xea1c",
         "Exif.Canon.CameraInfo",
         "Exif.Image.PrintImageMatching",
-        "Exif.Image.0xc6d3",
         "Exif.Panasonic.FaceDetInfo",
         "Exif.Panasonic.DataDump",
-        "Exif.Image.0xc6d2",
         "Exif.Canon.CustomFunctions",
         "Exif.Canon.AFInfo",
-        "Exif.Canon.0x4011",
-        "Exif.Canon.0x4019",
         "Exif.Canon.ColorData",
         "Exif.Canon.DustRemovalData",
         "Exif.Canon.VignettingCorr",
         "Exif.Canon.AFInfo3",
-        "Exif.Canon.0x001f",
-        "Exif.Canon.0x0018",
         "Exif.Canon.ContrastInfo",
-        "Exif.Canon.0x002e",
-        "Exif.Canon.0x0022",
-        "Exif.Photo.0x9aaa",
     ]
 )
 
@@ -677,14 +669,15 @@ def readPictureMetadata(picture: bytes, lang: Optional[str] = "en") -> dict:
 
     try:
         metadata = asdict(reader.readPictureMetadata(picture, lang))
-    except Exception as e:
-        raise MetadataReadingError(details=str(e))
+    except reader.PartialExifException as e:
+        tags = [t for t in e.missing_mandatory_tags if t not in ("lon", "lat")]
+        if "lon" in e.missing_mandatory_tags or "lat" in e.missing_mandatory_tags:
+            tags.append("location")  # lat/lon is too much detail for missing metadatas, we replace those by 'location'
+        raise MetadataReadingError(details=str(e), missing_mandatory_tags=tags)
 
     # Cleanup raw EXIF tags to avoid SQL issues
     cleanedExif = {}
-    for k, v in metadata["exif"].items():
-        if k in BLACK_LISTED_BINARY_EXIF_FIELDS:
-            continue
+    for k, v in cleanupExif(metadata["exif"]).items():
         try:
             if isinstance(v, bytes):
                 try:
@@ -704,15 +697,20 @@ def readPictureMetadata(picture: bytes, lang: Optional[str] = "en") -> dict:
     return metadata
 
 
+EXIF_KEY_HEX_RGX = r"\.0x[0-9a-fA-F]+$"
+
+
 def cleanupExif(exif: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
-    """Removes binary fields from exif
+    """Removes binary or undocumented fields from EXIF tags
     >>> cleanupExif({'A': 'B', 'Exif.Canon.AFInfo': 'Blablabla'})
     {'A': 'B'}
     >>> cleanupExif({'A': 'B', 'Exif.Photo.MakerNote': 'Blablabla'})
     {'A': 'B'}
+    >>> cleanupExif({'A': 'B', 'Exif.Sony.0x1234': 'Blablabla'})
+    {'A': 'B'}
     """
 
     if exif is None:
         return None
 
-    return {k: v for k, v in exif.items() if k not in BLACK_LISTED_BINARY_EXIF_FIELDS}
+    return {k: v for k, v in exif.items() if not re.search(EXIF_KEY_HEX_RGX, k) and k not in BLACK_LISTED_BINARY_EXIF_FIELDS}

geovisio/utils/sequences.py

@@ -156,7 +156,9 @@ def get_collections(request: CollectionsRequest) -> Collections:
                 {status},
                 s.computed_capture_date AS datetime,
                 s.user_agent,
-                ROUND(ST_Length(s.geom::geography)) / 1000 AS length_km
+                ROUND(ST_Length(s.geom::geography)) / 1000 AS length_km,
+                s.computed_h_pixel_density,
+                s.computed_gps_accuracy
             FROM sequences s
             LEFT JOIN accounts on s.account_id = accounts.id
             WHERE {filter}
@@ -516,7 +518,9 @@ SELECT
     ARRAY_AGG(DISTINCT TRIM(
         CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')
     )) AS models,
-    ARRAY_AGG(DISTINCT p.metadata->>'type') AS types
+    ARRAY_AGG(DISTINCT p.metadata->>'type') AS types,
+    ARRAY_AGG(DISTINCT p.h_pixel_density) AS reshpd,
+    PERCENTILE_CONT(0.9) WITHIN GROUP(ORDER BY p.gps_accuracy_m) AS gpsacc
 FROM sequences_pictures sp
 JOIN pictures p ON sp.pic_id = p.id
 WHERE sp.seq_id = %(seq)s
@@ -529,7 +533,9 @@ geom = compute_sequence_geom(id),
 bbox = compute_sequence_bbox(id),
 computed_type = CASE WHEN array_length(types, 1) = 1 THEN types[1] ELSE NULL END,
 computed_model = CASE WHEN array_length(models, 1) = 1 THEN models[1] ELSE NULL END,
-computed_capture_date = day
+computed_capture_date = day,
+computed_h_pixel_density = CASE WHEN array_length(reshpd, 1) = 1 THEN reshpd[1] ELSE NULL END,
+computed_gps_accuracy = gpsacc
 FROM aggregated_pictures
 WHERE id = %(seq)s
             """,
@@ -595,19 +601,16 @@ def delete_collection(collectionId: UUID, account: Optional[Account]) -> int:
 
             logging.info(f"Asking for deletion of sequence {collectionId} and all its pictures")
 
-            # mark all the pictures as waiting for deletion for async removal as this can be quite long if the storage is slow if there are lots of pictures
+            # mark all the pictures as waiting for deletion for async removal as this can be quite long if the storage is slow and there are lots of pictures
             # Note: To avoid a deadlock if some workers are currently also working on those picture to prepare them,
             # the SQL queries are split in 2:
-            # - First a query to add the async deletion task to the queue.
-            # - Then a query changing the status of the picture to `waiting-for-delete`
+            # - First a query to remove jobs preparing those pictures
+            # - Then a query deleting those pictures from the database (and a trigger will add async deletion tasks to the queue)
             #
-            # The trick there is that there can only be one task for a given picture (either preparing or deleting it)
-            # And the first query do a `ON CONFLICT DO UPDATE` to change the remaining `prepare` task to `delete`.
-            # So at the end of this query, we know that there are no more workers working on those pictures, so we can change their status
-            # without fearing a deadlock.
-            nb_updated = cursor.execute(
-                """
-                WITH pic2rm AS (
+            # Since the workers lock their job_queue row when working, at the end of this query, we know that there are no more workers working on those pictures,
+            # so we can delete them without fearing a deadlock.
+            cursor.execute(
+                """WITH pic2rm AS (
                     SELECT pic_id FROM sequences_pictures WHERE seq_id = %(seq)s
                 ),
                 picWithoutOtherSeq AS (
@@ -615,19 +618,15 @@ def delete_collection(collectionId: UUID, account: Optional[Account]) -> int:
                     EXCEPT
                     SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
                 )
-                INSERT INTO job_queue(picture_id, task)
-                    SELECT pic_id, 'delete' FROM picWithoutOtherSeq
-                    ON CONFLICT (picture_id) DO UPDATE SET task = 'delete'
-            """,
+                DELETE FROM job_queue WHERE picture_id IN (SELECT pic_id FROM picWithoutOtherSeq)""",
                 {"seq": collectionId},
             ).rowcount
             # if there was a finalize task for this collection in the queue, we remove it, it's useless
             cursor.execute("""DELETE FROM job_queue WHERE sequence_id = %(seq)s""", {"seq": collectionId})
 
-            # after the task have been added to the queue, we mark all picture for deletion
-            cursor.execute(
-                """
-                WITH pic2rm AS (
+            # after the task have been added to the queue, delete the pictures, and db triggers will ensure the correct deletion jobs are added
+            nb_updated = cursor.execute(
+                """WITH pic2rm AS (
                     SELECT pic_id FROM sequences_pictures WHERE seq_id = %(seq)s
                 ),
                 picWithoutOtherSeq AS (
@@ -635,8 +634,7 @@ def delete_collection(collectionId: UUID, account: Optional[Account]) -> int:
                     EXCEPT
                     SELECT pic_id FROM sequences_pictures WHERE pic_id IN (SELECT pic_id FROM pic2rm) AND seq_id != %(seq)s
                 )
-                UPDATE pictures SET status = 'waiting-for-delete' WHERE id IN (SELECT pic_id FROM picWithoutOtherSeq)
-            """,
+                DELETE FROM pictures WHERE id IN (SELECT pic_id FROM picWithoutOtherSeq)""",
                 {"seq": collectionId},
             ).rowcount
 

geovisio/utils/upload_set.py

@@ -126,6 +126,23 @@ class FileRejectionStatus(Enum):
     """other_error means there was an error that is not related to the picture itself"""
 
 
+class FileRejectionDetails(BaseModel):
+
+    missing_fields: List[str]
+    """Mandatory metadata missing from the file. Metadata can be `datetime` or `location`."""
+
+
+class FileRejection(BaseModel):
+    """Details about a file rejection"""
+
+    reason: str
+    severity: FileRejectionStatusSeverity
+    message: Optional[str]
+    details: Optional[FileRejectionDetails]
+
+    model_config = ConfigDict(use_enum_values=True, use_attribute_docstrings=True)
+
+
 class UploadSetFile(BaseModel):
     """File uploaded in an UploadSet"""
 
@@ -136,6 +153,7 @@ class UploadSetFile(BaseModel):
     upload_set_id: UUID = Field(..., exclude=True)
     rejection_status: Optional[FileRejectionStatus] = Field(None, exclude=True)
     rejection_message: Optional[str] = Field(None, exclude=True)
+    rejection_details: Optional[Dict[str, Any]] = Field(None, exclude=True)
     file_type: Optional[FileType] = None
     size: Optional[int] = None
 
@@ -148,7 +166,7 @@ class UploadSetFile(BaseModel):
 
     @computed_field
     @property
-    def rejected(self) -> Optional[Dict[str, Any]]:
+    def rejected(self) -> Optional[FileRejection]:
         if self.rejection_status is None:
             return None
         msg = None
@@ -168,11 +186,7 @@ class UploadSetFile(BaseModel):
                 severity = FileRejectionStatusSeverity.error
         else:
             msg = self.rejection_message
-        return {
-            "reason": self.rejection_status,
-            "severity": severity,
-            "message": msg,
-        }
+        return FileRejection(reason=self.rejection_status, severity=severity, message=msg, details=self.rejection_details)
 
     @field_serializer("content_md5")
     def serialize_md5(self, md5: UUID, _info):
@@ -199,7 +213,7 @@ def get_simple_upload_set(id: UUID) -> Optional[UploadSet]:
     """Get the DB representation of an UploadSet, without associated collections and statuses"""
     u = db.fetchone(
         current_app,
-        SQL("SELECT * FROM upload_sets WHERE id = %(id)s AND not deleted"),
+        SQL("SELECT * FROM upload_sets WHERE id = %(id)s"),
         {"id": id},
         row_factory=class_row(UploadSet),
     )
@@ -310,7 +324,7 @@ SELECT u.*,
     ) AS associated_collections
 FROM upload_sets u
 LEFT JOIN upload_set_statuses us on us.upload_set_id = u.id
-WHERE u.id = %(id)s AND not deleted"""
+WHERE u.id = %(id)s"""
         ),
         {"id": id},
         row_factory=class_row(UploadSet),
@@ -384,7 +398,7 @@ def list_upload_sets(account_id: UUID, limit: int = 100, filter: Optional[str] =
                 WHERE p.upload_set_id = u.id
             ) AS nb_items
         FROM upload_sets u
-        WHERE account_id = %(account_id)s AND not deleted AND {filter}
+        WHERE account_id = %(account_id)s AND {filter}
         ORDER BY created_at ASC
         LIMIT %(limit)s
         """
@@ -490,16 +504,8 @@ WHERE p.upload_set_id = %(upload_set_id)s"""
                         "UPDATE files SET rejection_status = 'capture_duplicate' WHERE picture_id IN (select picture_id from tmp_duplicates)"
                     )
                 )
-                cursor.execute(
-                    SQL(
-                        """INSERT INTO job_queue (picture_id, task)
-SELECT picture_id, 'delete'
-FROM tmp_duplicates
-ON CONFLICT(picture_id) DO UPDATE SET task = 'delete'"""
-                    )
-                )
-
-                # ask for deletion of the pictures
+                # delete all pictures (the DB triggers will also add background jobs to delete the associated files)
+                cursor.execute(SQL("DELETE FROM pictures WHERE id IN (select picture_id FROM tmp_duplicates)"))
 
             for s in report.sequences:
                 existing_sequence = next(
@@ -557,21 +563,21 @@ def insertFileInDatabase(
     picture_id: Optional[UUID] = None,
     rejection_status: Optional[FileRejectionStatus] = None,
     rejection_message: Optional[str] = None,
+    rejection_details: Optional[Dict[str, Any]] = None,
 ) -> UploadSetFile:
     """Insert a file linked to an UploadSet into the database"""
 
     f = cursor.execute(
         SQL(
-            """
-    INSERT INTO files(
+            """INSERT INTO files(
         upload_set_id, picture_id, file_type, file_name,
-        size, content_md5, rejection_status, rejection_message)
+        size, content_md5, rejection_status, rejection_message, rejection_details)
     VALUES (
         %(upload_set_id)s, %(picture_id)s, %(type)s, %(file_name)s,
-        %(size)s, %(content_md5)s, %(rejection_status)s, %(rejection_message)s)
+        %(size)s, %(content_md5)s, %(rejection_status)s, %(rejection_message)s, %(rejection_details)s)
     ON CONFLICT (upload_set_id, file_name)
     DO UPDATE SET picture_id = %(picture_id)s, size = %(size)s, content_md5 = %(content_md5)s,
-        rejection_status = %(rejection_status)s, rejection_message = %(rejection_message)s
+        rejection_status = %(rejection_status)s, rejection_message = %(rejection_message)s, rejection_details = %(rejection_details)s
     RETURNING *
     """
         ),
@@ -584,6 +590,7 @@ def insertFileInDatabase(
             "content_md5": content_md5,
             "rejection_status": rejection_status,
             "rejection_message": rejection_message,
+            "rejection_details": Jsonb(rejection_details),
         },
     )
     return UploadSetFile(**f.fetchone())
@@ -602,6 +609,7 @@ def get_upload_set_files(upload_set_id: UUID) -> UploadSetFiles:
     content_md5, 
     rejection_status,
     rejection_message,
+    rejection_details,
     picture_id, 
     inserted_at
 FROM files
@@ -618,37 +626,17 @@ def delete(upload_set: UploadSet):
     """Delete an UploadSet"""
     logging.info(f"Asking for deletion of uploadset {upload_set.id}")
     with db.conn(current_app) as conn:
+        # clean job queue, to ensure no async runner are currently processing pictures/sequences/upload_sets
+        # Done outside the real deletion transaction to not trigger deadlock
+        conn.execute(SQL("DELETE FROM job_queue WHERE picture_id IN (SELECT id FROM pictures where upload_set_id = %s)"), [upload_set.id])
+        for c in upload_set.associated_collections:
+            conn.execute(SQL("DELETE FROM job_queue WHERE sequence_id = %s"), [c.id])
+
         with conn.transaction(), conn.cursor() as cursor:
             for c in upload_set.associated_collections:
                 # Mark all collections as deleted, but do not delete them
                 # Note: we do not use utils.sequences.delete_collection here, since we also want to remove the pictures not associated to any collection
-                cursor.execute(SQL("DELETE FROM job_queue WHERE sequence_id = %s"), [c.id])
                 cursor.execute(SQL("UPDATE sequences SET status = 'deleted' WHERE id = %s"), [c.id])
 
-            # check utils.sequences.delete_collection to see why picture removal is done in 2 steps
-            cursor.execute(
-                """
-INSERT INTO job_queue(picture_id, task)
-    SELECT id, 'delete'
-    FROM pictures
-    WHERE upload_set_id = %(upload_set_id)s
-ON CONFLICT (picture_id) DO UPDATE SET task = 'delete'""",
-                {"upload_set_id": upload_set.id},
-            )
-
-            # after the task have been added to the queue, we mark all picture for deletion
-            cursor.execute(
-                SQL(
-                    "UPDATE pictures SET status = 'waiting-for-delete' WHERE id IN (SELECT id FROM pictures WHERE upload_set_id = %(upload_set_id)s)"
-                ),
-                {"upload_set_id": upload_set.id},
-            )
-            # we insert the upload set deletion task in the queue after the rest, it will be done once all pictures are deleted
-            cursor.execute(
-                """INSERT INTO job_queue(upload_set_id, task) VALUES (%(upload_set_id)s, 'delete') 
-ON CONFLICT (upload_set_id) DO UPDATE SET task = 'delete'""",
-                {"upload_set_id": upload_set.id},
-            )
-
-            # and we mark it as deleted so it will disapear from the responses even if all the pictures are not yet deleted
-            cursor.execute("UPDATE upload_sets SET deleted = true WHERE id = %(upload_set_id)s", {"upload_set_id": upload_set.id})
+            # after the task have been added to the queue, we delete the upload set, and this will delete all pictures associated to it
+            cursor.execute(SQL("DELETE FROM upload_sets WHERE id = %(upload_set_id)s"), {"upload_set_id": upload_set.id})

geovisio/web/collections.py

@@ -82,7 +82,10 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
         {
             "type": "Collection",
             "stac_version": STAC_VERSION,
-            "stac_extensions": ["https://stac-extensions.github.io/stats/v0.2.0/schema.json"],  # For stats: fields
+            "stac_extensions": [
+                "https://stac-extensions.github.io/stats/v0.2.0/schema.json",  # For stats: fields
+                "https://stac.linz.govt.nz/v0.0.15/quality/schema.json",  # For quality: fields
+            ],
             "id": str(dbSeq["id"]),
             "title": str(dbSeq["name"]),
             "description": description,
@@ -96,6 +99,10 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
             "geovisio:sorted-by": dbSeq.get("current_sort"),
             "geovisio:upload-software": userAgentToClient(dbSeq.get("user_agent")).value,
             "geovisio:length_km": dbSeq.get("length_km"),
+            "quality:horizontal_accuracy": (
+                float("{:.1f}".format(dbSeq["computed_gps_accuracy"])) if dbSeq.get("computed_gps_accuracy") else None
+            ),
+            "quality:horizontal_accuracy_type": "95% confidence interval" if "computed_gps_accuracy" in dbSeq else None,
             "providers": [
                 {"name": dbSeq["account_name"], "roles": ["producer"], "id": str(dbSeq["account_id"])},
             ],
@@ -110,7 +117,14 @@ def dbSequenceToStacCollection(dbSeq, description="A sequence of geolocated pict
                     ]
                 },
             },
-            "summaries": cleanNoneInDict({"pers:interior_orientation": dbSeq.get("metas")}),
+            "summaries": cleanNoneInDict(
+                {
+                    "pers:interior_orientation": dbSeq.get("metas"),
+                    "panoramax:horizontal_pixel_density": (
+                        [dbSeq["computed_h_pixel_density"]] if "computed_h_pixel_density" in dbSeq else None
+                    ),
+                }
+            ),
             "stats:items": removeNoneInDict({"count": nb_pic}),
             "links": cleanNoneInList(
                 [
@@ -374,7 +388,9 @@ def getCollection(collectionId):
                 max_picture_ts AS maxts,
                 nb_pictures AS nbpic,
                 s.user_agent,
-                ROUND(ST_Length(s.geom::geography)) / 1000 as length_km
+                ROUND(ST_Length(s.geom::geography)) / 1000 as length_km,
+                s.computed_h_pixel_density,
+                s.computed_gps_accuracy
             FROM sequences s
             JOIN accounts ON s.account_id = accounts.id, (
                 SELECT

geovisio/web/docs.py

@@ -157,6 +157,15 @@ 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"},
+                    "metadata": {
+                        "type": "object",
+                        "properties": {
+                            "panoramax:fields": {
+                                "type": "object",
+                                "description": "Available properties per layer (layer: [field1, field2...])",
+                            }
+                        },
+                    },
                     "sources": {
                         "type": "object",
                         "properties": {
@@ -340,12 +349,28 @@ Note that you may not rely only on these ID that could change through time.
                             "geovisio:sorted-by": {"$ref": "#/components/schemas/GeoVisioCollectionSortedBy"},
                             "geovisio:upload-software": {"$ref": "#/components/schemas/GeoVisioCollectionUploadSoftware"},
                             "geovisio:length_km": {"$ref": "#/components/schemas/GeoVisioLengthKm"},
+                            "quality:horizontal_accuracy": {"type": "number", "title": "Estimated GPS position precision (in meters)"},
+                            "quality:horizontal_accuracy_type": {
+                                "type": "string",
+                                "title": "Estimation process for GPS precision",
+                                "example": "95% confidence interval",
+                            },
                             "providers": {
                                 "type": "array",
                                 "items": {
                                     "$ref": "#/components/schemas/GeoVisioProvider",
                                 },
                             },
+                            "summaries": {
+                                "type": "object",
+                                "properties": {
+                                    "panoramax:horizontal_pixel_density": {
+                                        "type": "array",
+                                        "title": "Number of pixels on horizon per field of view degree (as a list with a single value for STAC conformance)",
+                                        "items": {"type": "integer", "minimum": 0},
+                                    },
+                                },
+                            },
                         },
                     },
                 ]
@@ -440,6 +465,15 @@ If unset, sort order is unchanged.
                                     "geovisio:thumbnail": {"type": "string", "format": "uri"},
                                     "original_file:size": {"type": "integer", "minimum": 0, "title": "Size of the original file, in bytes"},
                                     "original_file:name": {"type": "string", "title": "Original file name"},
+                                    "panoramax:horizontal_pixel_density": {
+                                        "type": "integer",
+                                        "minimum": 0,
+                                        "title": "Number of pixels on horizon per field of view degree",
+                                    },
+                                    "quality:horizontal_accuracy": {
+                                        "type": "number",
+                                        "title": "Estimated GPS position precision (in meters)",
+                                    },
                                 },
                             }
                         },
@@ -485,7 +519,7 @@ If unset, sort order is unchanged.
                     },
                     "isBlurred": {
                         "type": "string",
-                        "description": "Is picture blurred",
+                        "description": "Is picture blurred. If set to 'true', the server will not apply the face blurring algorithm but will publish the image as it is",
                         "enum": ["true", "false", "null"],
                         "default": "false",
                     },