Fix skeleton tracks

.github/workflows/helm.yml

@@ -82,4 +82,4 @@ jobs:
       # They are still tested without Helm
       run: |
         kubectl cp tests/mounted_file_share/images $(kubectl get pods -l component=server -o jsonpath='{.items[0].metadata.name}'):/home/django/share
-        pytest --timeout 30 --platform=kube -m "not with_external_services" tests/python
+        pytest --timeout 30 --platform=kube -m "not with_external_services" tests/python --log-cli-level DEBUG

CHANGELOG.md

@@ -27,6 +27,7 @@ without use_cache option (<https://github.com/opencv/cvat/pull/6074>)
 
 ### Fixed
 - Skeletons dumping on created tasks/projects (<https://github.com/opencv/cvat/pull/6157>)
+- Fix saving annotations for skeleton tracks (<https://github.com/opencv/cvat/pull/6075>)
 
 ### Security
 - TDB

cvat/apps/dataset_manager/task.py

@@ -3,21 +3,23 @@
 #
 # SPDX-License-Identifier: MIT
 
+import os
 from collections import OrderedDict
+from copy import deepcopy
 from enum import Enum
-import os
 from tempfile import TemporaryDirectory
 
 from django.db import transaction
 from django.db.models.query import Prefetch
 from django.utils import timezone
+from rest_framework.exceptions import ValidationError
 
 from cvat.apps.engine import models, serializers
 from cvat.apps.engine.plugins import plugin_decorator
 from cvat.apps.profiler import silk_profile
 
 from .annotation import AnnotationIR, AnnotationManager
-from .bindings import TaskData, JobData
+from .bindings import JobData, TaskData
 from .formats.registry import make_exporter, make_importer
 from .util import bulk_create
 
@@ -115,47 +117,108 @@ def __init__(self, pk, is_prefetched=False):
     def reset(self):
         self.ir_data.reset()
 
+    def _validate_attribute_for_existence(self, db_attr_val, label_id, attr_type):
+        if db_attr_val.spec_id not in self.db_attributes[label_id][attr_type]:
+            raise ValidationError("spec_id `{}` is invalid".format(db_attr_val.spec_id))
+
+    def _validate_label_for_existence(self, label_id):
+        if label_id not in self.db_labels:
+            raise ValidationError("label_id `{}` is invalid".format(label_id))
+
+    def _add_missing_shape(self, track, first_shape):
+        if first_shape["type"] == "skeleton":
+            # in case with skeleton track we always expect to see one shape in track
+            first_shape["frame"] = track["frame"]
+        else:
+            missing_shape = deepcopy(first_shape)
+            missing_shape["frame"] = track["frame"]
+            missing_shape["outside"] = True
+            track["shapes"].append(missing_shape)
+
+    def _correct_frame_of_tracked_shapes(self, track):
+        shapes = sorted(track["shapes"], key=lambda a: a["frame"])
+        first_shape = shapes[0] if shapes else None
+
+        if first_shape and track["frame"] < first_shape["frame"]:
+            self._add_missing_shape(track, first_shape)
+        elif first_shape and first_shape["frame"] < track["frame"]:
+            track["frame"] = first_shape["frame"]
+
+    def _sync_frames(self, tracks, parent_track):
+        if not tracks:
+            return
+
+        min_frame = tracks[0]["frame"]
+
+        for track in tracks:
+            if parent_track and parent_track.frame < track["frame"]:
+                track["frame"] = parent_track.frame
+
+            # track and its first shape must have the same frame
+            self._correct_frame_of_tracked_shapes(track)
+
+            if track["frame"] < min_frame:
+                min_frame = track["frame"]
+
+        if not parent_track:
+            return
+
+        if min_frame < parent_track.frame:
+            # parent track cannot have a frame greater than the frame of the child track
+            parent_tracked_shape = parent_track.trackedshape_set.first()
+            parent_track.frame = min_frame
+            parent_tracked_shape.frame = min_frame
+
+            parent_tracked_shape.save()
+            parent_track.save()
+
+            for track in tracks:
+                if parent_track.frame < track["frame"]:
+                    track["frame"] = parent_track.frame
+
+                    self._correct_frame_of_tracked_shapes(track)
+
     def _save_tracks_to_db(self, tracks):
 
         def create_tracks(tracks, parent_track=None):
             db_tracks = []
-            db_track_attrvals = []
+            db_track_attr_vals = []
             db_shapes = []
-            db_shape_attrvals = []
+            db_shape_attr_vals = []
+
+            self._sync_frames(tracks, parent_track)
 
             for track in tracks:
                 track_attributes = track.pop("attributes", [])
                 shapes = track.pop("shapes")
                 elements = track.pop("elements", [])
                 db_track = models.LabeledTrack(job=self.db_job, parent=parent_track, **track)
-                if db_track.label_id not in self.db_labels:
-                    raise AttributeError("label_id `{}` is invalid".format(db_track.label_id))
+
+                self._validate_label_for_existence(db_track.label_id)
 
                 for attr in track_attributes:
-                    db_attrval = models.LabeledTrackAttributeVal(**attr)
-                    if db_attrval.spec_id not in self.db_attributes[db_track.label_id]["immutable"]:
-                        raise AttributeError("spec_id `{}` is invalid".format(db_attrval.spec_id))
-                    db_attrval.track_id = len(db_tracks)
-                    db_track_attrvals.append(db_attrval)
+                    db_attr_val = models.LabeledTrackAttributeVal(**attr, track_id=len(db_tracks))
+
+                    self._validate_attribute_for_existence(db_attr_val, db_track.label_id, "immutable")
 
-                for shape in shapes:
+                    db_track_attr_vals.append(db_attr_val)
+
+                for shape_idx, shape in enumerate(shapes):
                     shape_attributes = shape.pop("attributes", [])
-                    # FIXME: need to clamp points (be sure that all of them inside the image)
-                    # Should we check here or implement a validator?
-                    db_shape = models.TrackedShape(**shape)
-                    db_shape.track_id = len(db_tracks)
+                    db_shape = models.TrackedShape(**shape, track_id=len(db_tracks))
 
                     for attr in shape_attributes:
-                        db_attrval = models.TrackedShapeAttributeVal(**attr)
-                        if db_attrval.spec_id not in self.db_attributes[db_track.label_id]["mutable"]:
-                            raise AttributeError("spec_id `{}` is invalid".format(db_attrval.spec_id))
-                        db_attrval.shape_id = len(db_shapes)
-                        db_shape_attrvals.append(db_attrval)
+                        db_attr_val = models.TrackedShapeAttributeVal(**attr, shape_id=len(db_shapes))
+
+                        self._validate_attribute_for_existence(db_attr_val, db_track.label_id, "mutable")
+
+                        db_shape_attr_vals.append(db_attr_val)
 
                     db_shapes.append(db_shape)
                     shape["attributes"] = shape_attributes
 
                 db_tracks.append(db_track)
+
                 track["attributes"] = track_attributes
                 track["shapes"] = shapes
                 if elements or parent_track is None:
@@ -167,11 +230,12 @@ def create_tracks(tracks, parent_track=None):
                 flt_param={"job_id": self.db_job.id}
             )
 
-            for db_attrval in db_track_attrvals:
-                db_attrval.track_id = db_tracks[db_attrval.track_id].id
+            for db_attr_val in db_track_attr_vals:
+                db_attr_val.track_id = db_tracks[db_attr_val.track_id].id
+
             bulk_create(
                 db_model=models.LabeledTrackAttributeVal,
-                objects=db_track_attrvals,
+                objects=db_track_attr_vals,
                 flt_param={}
             )
 
@@ -184,12 +248,12 @@ def create_tracks(tracks, parent_track=None):
                 flt_param={"track__job_id": self.db_job.id}
             )
 
-            for db_attrval in db_shape_attrvals:
-                db_attrval.shape_id = db_shapes[db_attrval.shape_id].id
+            for db_attr_val in db_shape_attr_vals:
+                db_attr_val.shape_id = db_shapes[db_attr_val.shape_id].id
 
             bulk_create(
                 db_model=models.TrackedShapeAttributeVal,
-                objects=db_shape_attrvals,
+                objects=db_shape_attr_vals,
                 flt_param={}
             )
 
@@ -208,24 +272,23 @@ def create_tracks(tracks, parent_track=None):
     def _save_shapes_to_db(self, shapes):
         def create_shapes(shapes, parent_shape=None):
             db_shapes = []
-            db_attrvals = []
+            db_attr_vals = []
 
             for shape in shapes:
                 attributes = shape.pop("attributes", [])
                 shape_elements = shape.pop("elements", [])
                 # FIXME: need to clamp points (be sure that all of them inside the image)
                 # Should we check here or implement a validator?
                 db_shape = models.LabeledShape(job=self.db_job, parent=parent_shape, **shape)
-                if db_shape.label_id not in self.db_labels:
-                    raise AttributeError("label_id `{}` is invalid".format(db_shape.label_id))
+
+                self._validate_label_for_existence(db_shape.label_id)
 
                 for attr in attributes:
-                    db_attrval = models.LabeledShapeAttributeVal(**attr)
-                    if db_attrval.spec_id not in self.db_attributes[db_shape.label_id]["all"]:
-                        raise AttributeError("spec_id `{}` is invalid".format(db_attrval.spec_id))
+                    db_attr_val = models.LabeledShapeAttributeVal(**attr, shape_id=len(db_shapes))
 
-                    db_attrval.shape_id = len(db_shapes)
-                    db_attrvals.append(db_attrval)
+                    self._validate_attribute_for_existence(db_attr_val, db_shape.label_id, "all")
+
+                    db_attr_vals.append(db_attr_val)
 
                 db_shapes.append(db_shape)
                 shape["attributes"] = attributes
@@ -238,12 +301,12 @@ def create_shapes(shapes, parent_shape=None):
                 flt_param={"job_id": self.db_job.id}
             )
 
-            for db_attrval in db_attrvals:
-                db_attrval.shape_id = db_shapes[db_attrval.shape_id].id
+            for db_attr_val in db_attr_vals:
+                db_attr_val.shape_id = db_shapes[db_attr_val.shape_id].id
 
             bulk_create(
                 db_model=models.LabeledShapeAttributeVal,
-                objects=db_attrvals,
+                objects=db_attr_vals,
                 flt_param={}
             )
 
@@ -257,20 +320,21 @@ def create_shapes(shapes, parent_shape=None):
 
     def _save_tags_to_db(self, tags):
         db_tags = []
-        db_attrvals = []
+        db_attr_vals = []
 
         for tag in tags:
             attributes = tag.pop("attributes", [])
             db_tag = models.LabeledImage(job=self.db_job, **tag)
-            if db_tag.label_id not in self.db_labels:
-                raise AttributeError("label_id `{}` is invalid".format(db_tag.label_id))
+
+            self._validate_label_for_existence(db_tag.label_id)
 
             for attr in attributes:
-                db_attrval = models.LabeledImageAttributeVal(**attr)
-                if db_attrval.spec_id not in self.db_attributes[db_tag.label_id]["all"]:
-                    raise AttributeError("spec_id `{}` is invalid".format(db_attrval.spec_id))
-                db_attrval.tag_id = len(db_tags)
-                db_attrvals.append(db_attrval)
+                db_attr_val = models.LabeledImageAttributeVal(**attr)
+
+                self._validate_attribute_for_existence(db_attr_val, db_tag.label_id, "all")
+
+                db_attr_val.tag_id = len(db_tags)
+                db_attr_vals.append(db_attr_val)
 
             db_tags.append(db_tag)
             tag["attributes"] = attributes
@@ -281,12 +345,12 @@ def _save_tags_to_db(self, tags):
             flt_param={"job_id": self.db_job.id}
         )
 
-        for db_attrval in db_attrvals:
-            db_attrval.image_id = db_tags[db_attrval.tag_id].id
+        for db_attr_val in db_attr_vals:
+            db_attr_val.image_id = db_tags[db_attr_val.tag_id].id
 
         bulk_create(
             db_model=models.LabeledImageAttributeVal,
-            objects=db_attrvals,
+            objects=db_attr_vals,
             flt_param={}
         )
 

cvat/apps/engine/tests/test_rest_api.py

@@ -4538,7 +4538,7 @@ def _run_api_v2_jobs_id_annotations(self, owner, assignee, annotator):
                     ]
                 },
                 {
-                    "frame": 1,
+                    "frame": 2,
                     "label_id": task["labels"][1]["id"],
                     "group": None,
                     "source": "manual",