geovisio 2.9.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

geovisio/utils/sequences.py

@@ -55,7 +55,7 @@ class Collections:
     """
 
     collections: List[Dict[Any, Any]] = field(default_factory=lambda: [])
-    # Bounds of the field used by the first field of the `ORDER BY` (usefull especially for pagination)
+    # Bounds of the field used by the first field of the `ORDER BY` (useful especially for pagination)
     query_bounds: Optional[Bounds] = None
 
 
@@ -157,23 +157,24 @@ def get_collections(request: CollectionsRequest) -> Collections:
                 s.min_picture_ts AS mints,
                 s.max_picture_ts AS maxts,
                 s.nb_pictures AS nbpic,
+                s.upload_set_id,
                 {status},
                 s.computed_capture_date AS datetime,
                 s.user_agent,
                 ROUND(ST_Length(s.geom::geography)) / 1000 AS length_km,
                 s.computed_h_pixel_density,
                 s.computed_gps_accuracy,
-                t.semantics
+                COALESCE(seq_sem.semantics, '[]'::json) AS semantics
             FROM sequences s
             LEFT JOIN accounts on s.account_id = accounts.id
             LEFT JOIN (
-                    SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
-                        'key', key,
-                        'value', value
-                    )) ORDER BY key, value) AS semantics
-                    FROM sequences_semantics
-                    GROUP BY sequence_id
-                ) t ON t.sequence_id = s.id
+                SELECT sequence_id, json_agg(json_strip_nulls(json_build_object(
+                    'key', key,
+                    'value', value
+                )) ORDER BY key, value) AS semantics
+                FROM sequences_semantics
+                GROUP BY sequence_id
+            ) seq_sem ON seq_sem.sequence_id = s.id
             WHERE {filter}
             ORDER BY {order1}
             LIMIT {limit}
@@ -427,7 +428,7 @@ def sort_collection(db, collectionId: UUID, sortby: CollectionSort):
     """
     Sort a collection by a given parameter
 
-    Note: the transaction is not commited at the end, you need to commit it or use an autocommit connection
+    Note: the transaction is not committed at the end, you need to commit it or use an autocommit connection
     """
 
     # Remove existing order, and keep list of pictures IDs
@@ -519,8 +520,8 @@ def update_headings(
     db,
     sequenceId: UUID,
     editingAccount: Optional[UUID] = None,
-    relativeHeading: int = 0,
-    updateOnlyMissing: bool = True,
+    relativeHeading: Optional[int] = None,
+    updateOnlyMissing: Optional[bool] = None,
 ):
     """Defines pictures heading according to sequence path.
     Database is not committed in this function, to make entry definitively stored
@@ -532,27 +533,42 @@ def update_headings(
             Database connection
     sequenceId : uuid
             The sequence's uuid, as stored in the database
-    relativeHeading : int
+    relativeHeading : Optional[int]
             Camera relative orientation compared to path, in degrees clockwise.
             Example: 0° = looking forward, 90° = looking to right, 180° = looking backward, -90° = looking left.
-    updateOnlyMissing : bool
+            If not provided, will first use the relative_heading stored in the sequence's metadata, then the relative_heading of its upload_set (if if none is set, default to 0).
+    updateOnlyMissing : Optional[bool]
             If true, doesn't change existing heading values in database
+            if not provided, we check if some relative heading has been set (either in the sequence or in its upload_set), and if so, we recompute all
     """
-
     db.execute(
         SQL(
-            """
-		WITH h AS (
+            """WITH
+        relative_heading AS (
+            SELECT COALESCE(
+                    %(relativeHeading)s, 
+                    (SELECT (metadata->>'relative_heading')::int FROM sequences WHERE id = %(seq)s),
+                    (SELECT upload_sets.relative_heading FROM sequences JOIN upload_sets ON sequences.upload_set_id = upload_sets.id WHERE sequences.id = %(seq)s),
+                    0
+            ) AS heading,
+            COALESCE(
+                %(update_only_missing)s,
+                (SELECT metadata->'relative_heading' IS NULL FROM sequences WHERE id = %(seq)s and metadata ? 'relative_heading'),
+                (SELECT upload_sets.relative_heading IS NULL FROM sequences JOIN upload_sets ON sequences.upload_set_id = upload_sets.id WHERE sequences.id = %(seq)s)
+            ) AS update_only_missing
+        )
+        , h AS (
 			SELECT
 				p.id,
                 p.heading AS old_heading,
 				CASE
 					WHEN LEAD(sp.rank) OVER othpics IS NULL AND LAG(sp.rank) OVER othpics IS NULL
-						THEN NULL
+                        -- if there is a single picture, we take the relative heading directly
+						THEN (SELECT heading FROM relative_heading)
 					WHEN LEAD(sp.rank) OVER othpics IS NULL
-						THEN (360 + FLOOR(DEGREES(ST_Azimuth(LAG(p.geom) OVER othpics, p.geom)))::int + (%(diff)s %% 360)) %% 360
+						THEN (360 + FLOOR(DEGREES(ST_Azimuth(LAG(p.geom) OVER othpics, p.geom)))::int + ((SELECT heading FROM relative_heading) %% 360)) %% 360
 					ELSE
-						(360 + FLOOR(DEGREES(ST_Azimuth(p.geom, LEAD(p.geom) OVER othpics)))::int + (%(diff)s %% 360)) %% 360
+						(360 + FLOOR(DEGREES(ST_Azimuth(p.geom, LEAD(p.geom) OVER othpics)))::int + ((SELECT heading FROM relative_heading) %% 360)) %% 360
 				END AS heading
 			FROM pictures p
 			JOIN sequences_pictures sp ON sp.pic_id = p.id AND sp.seq_id = %(seq)s
@@ -561,13 +577,15 @@ def update_headings(
 		UPDATE pictures p
 		SET heading = h.heading, heading_computed = true {editing_account}
 		FROM h
-		WHERE h.id = p.id {update_missing}
+		WHERE h.id = p.id AND (
+            (SELECT NOT update_only_missing FROM relative_heading) 
+            OR (p.heading IS NULL OR p.heading = 0 OR p.heading_computed) -- # lots of camera have heading set to 0 for unset heading, so we recompute the heading when it's 0 too, even if this could be a valid value
+        )
 		"""
         ).format(
-            update_missing=SQL(" AND (p.heading IS NULL OR p.heading = 0 OR p.heading_computed)") if updateOnlyMissing else SQL(""),
             editing_account=SQL(", last_account_to_edit = %(account)s") if editingAccount is not None else SQL(""),
-        ),  # lots of camera have heading set to 0 for unset heading, so we recompute the heading when it's 0 too, even if this could be a valid value
-        {"seq": sequenceId, "diff": relativeHeading, "account": editingAccount},
+        ),
+        {"seq": sequenceId, "relativeHeading": relativeHeading, "account": editingAccount, "update_only_missing": updateOnlyMissing},
     )
 
 
@@ -593,14 +611,13 @@ def finalize(cursor, seqId: UUID, logger: logging.Logger = logging.getLogger()):
         span.set_data("sequence_id", seqId)
         logger.debug(f"Finalizing sequence {seqId}")
 
-        with utils.time.log_elapsed(f"Finalizing sequence {seqId}"):
-            # Complete missing headings in pictures
-            update_headings(cursor, seqId)
+        # Complete missing headings in pictures
+        update_headings(cursor, seqId)
 
-            # Change sequence database status in DB
-            # Also generates data in computed columns
-            cursor.execute(
-                """WITH
+        # Change sequence database status in DB
+        # Also generates data in computed columns
+        cursor.execute(
+            """WITH
 aggregated_pictures AS (
 SELECT
     sp.seq_id, 
@@ -629,10 +646,10 @@ computed_gps_accuracy = gpsacc
 FROM aggregated_pictures
 WHERE id = %(seq)s
             """,
-                {"seq": seqId},
-            )
+            {"seq": seqId},
+        )
 
-            logger.info(f"Sequence {seqId} is ready")
+        logger.info(f"Sequence {seqId} is ready")
 
 
 def update_pictures_grid() -> Optional[datetime.datetime]: