Cuboid annotation

cvat/apps/annotation/cvat.py

@@ -119,6 +119,11 @@ def open_points(self, points):
             self.xmlgen.startElement("points", points)
             self._level += 1
 
+        def open_cuboid(self, cuboid):
+            self._indent()
+            self.xmlgen.startElement("cuboid", cuboid)
+            self._level += 1
+
         def add_attribute(self, attribute):
             self._indent()
             self.xmlgen.startElement("attribute", {"name": attribute["name"]})
@@ -145,6 +150,11 @@ def close_points(self):
             self._indent()
             self.xmlgen.endElement("points")
 
+        def close_cuboid(self):
+            self._level -= 1
+            self._indent()
+            self.xmlgen.endElement("cuboid")
+
         def close_image(self):
             self._level -= 1
             self._indent()
@@ -191,6 +201,25 @@ def dump_as_cvat_annotation(file_object, annotations):
                     ("xbr", "{:.2f}".format(shape.points[2])),
                     ("ybr", "{:.2f}".format(shape.points[3]))
                 ]))
+            elif shape.type == "cuboid":
+                dump_data.update(OrderedDict([
+                    ("xtl1", "{:.2f}".format(shape.points[0])),
+                    ("ytl1", "{:.2f}".format(shape.points[1])),
+                    ("xbl1", "{:.2f}".format(shape.points[2])),
+                    ("ybl1", "{:.2f}".format(shape.points[3])),
+                    ("xtr1", "{:.2f}".format(shape.points[4])),
+                    ("ytr1", "{:.2f}".format(shape.points[5])),
+                    ("xbr1", "{:.2f}".format(shape.points[6])),
+                    ("ybr1", "{:.2f}".format(shape.points[7])),
+                    ("xtl2", "{:.2f}".format(shape.points[8])),
+                    ("ytl2", "{:.2f}".format(shape.points[9])),
+                    ("xbl2", "{:.2f}".format(shape.points[10])),
+                    ("ybl2", "{:.2f}".format(shape.points[11])),
+                    ("xtr2", "{:.2f}".format(shape.points[12])),
+                    ("ytr2", "{:.2f}".format(shape.points[13])),
+                    ("xbr2", "{:.2f}".format(shape.points[14])),
+                    ("ybr2", "{:.2f}".format(shape.points[15]))
+                ]))
             else:
                 dump_data.update(OrderedDict([
                     ("points", ';'.join((
@@ -206,6 +235,7 @@ def dump_as_cvat_annotation(file_object, annotations):
             if shape.group:
                 dump_data['group_id'] = str(shape.group)
 
+
             if shape.type == "rectangle":
                 dumper.open_box(dump_data)
             elif shape.type == "polygon":
@@ -214,6 +244,8 @@ def dump_as_cvat_annotation(file_object, annotations):
                 dumper.open_polyline(dump_data)
             elif shape.type == "points":
                 dumper.open_points(dump_data)
+            elif shape.type == "cuboid":
+                dumper.open_cuboid(dump_data)
             else:
                 raise NotImplementedError("unknown shape type")
 
@@ -231,6 +263,8 @@ def dump_as_cvat_annotation(file_object, annotations):
                 dumper.close_polyline()
             elif shape.type == "points":
                 dumper.close_points()
+            elif shape.type == "cuboid":
+                dumper.close_cuboid()
             else:
                 raise NotImplementedError("unknown shape type")
 
@@ -268,6 +302,25 @@ def dump_track(idx, track):
                     ("xbr", "{:.2f}".format(shape.points[2])),
                     ("ybr", "{:.2f}".format(shape.points[3])),
                 ]))
+            elif shape.type == "cuboid":
+                dump_data.update(OrderedDict([
+                    ("xtl1", "{:.2f}".format(shape.points[0])),
+                    ("ytl1", "{:.2f}".format(shape.points[1])),
+                    ("xbl1", "{:.2f}".format(shape.points[2])),
+                    ("ybl1", "{:.2f}".format(shape.points[3])),
+                    ("xtr1", "{:.2f}".format(shape.points[4])),
+                    ("ytr1", "{:.2f}".format(shape.points[5])),
+                    ("xbr1", "{:.2f}".format(shape.points[6])),
+                    ("ybr1", "{:.2f}".format(shape.points[7])),
+                    ("xtl2", "{:.2f}".format(shape.points[8])),
+                    ("ytl2", "{:.2f}".format(shape.points[9])),
+                    ("xbl2", "{:.2f}".format(shape.points[10])),
+                    ("ybl2", "{:.2f}".format(shape.points[11])),
+                    ("xtr2", "{:.2f}".format(shape.points[12])),
+                    ("ytr2", "{:.2f}".format(shape.points[13])),
+                    ("xbr2", "{:.2f}".format(shape.points[14])),
+                    ("ybr2", "{:.2f}".format(shape.points[15]))
+                ]))
             else:
                 dump_data.update(OrderedDict([
                     ("points", ';'.join(['{:.2f},{:.2f}'.format(x, y)
@@ -285,6 +338,8 @@ def dump_track(idx, track):
                 dumper.open_polyline(dump_data)
             elif shape.type == "points":
                 dumper.open_points(dump_data)
+            elif shape.type == "cuboid":
+                dumper.open_cuboid(dump_data)
             else:
                 raise NotImplementedError("unknown shape type")
 
@@ -302,6 +357,8 @@ def dump_track(idx, track):
                 dumper.close_polyline()
             elif shape.type == "points":
                 dumper.close_points()
+            elif shape.type == "cuboid":
+                dumper.close_cuboid()
             else:
                 raise NotImplementedError("unknown shape type")
         dumper.close_track()
@@ -347,7 +404,7 @@ def load(file_object, annotations):
     context = iter(context)
     ev, _ = next(context)
 
-    supported_shapes = ('box', 'polygon', 'polyline', 'points')
+    supported_shapes = ('box', 'polygon', 'polyline', 'points', 'cuboid')
 
     track = None
     shape = None
@@ -393,6 +450,24 @@ def load(file_object, annotations):
                     shape['points'].append(el.attrib['ytl'])
                     shape['points'].append(el.attrib['xbr'])
                     shape['points'].append(el.attrib['ybr'])
+                elif el.tag == 'cuboid':
+                    shape['points'].append(el.attrib['xtl1'])
+                    shape['points'].append(el.attrib['ytl1'])
+                    shape['points'].append(el.attrib['xbl1'])
+                    shape['points'].append(el.attrib['ybl1'])
+                    shape['points'].append(el.attrib['xtr1'])
+                    shape['points'].append(el.attrib['ytr1'])
+                    shape['points'].append(el.attrib['xbr1'])
+                    shape['points'].append(el.attrib['ybr1'])
+
+                    shape['points'].append(el.attrib['xtl2'])
+                    shape['points'].append(el.attrib['ytl2'])
+                    shape['points'].append(el.attrib['xbl2'])
+                    shape['points'].append(el.attrib['ybl2'])
+                    shape['points'].append(el.attrib['xtr2'])
+                    shape['points'].append(el.attrib['ytr2'])
+                    shape['points'].append(el.attrib['xbr2'])
+                    shape['points'].append(el.attrib['ybr2'])
                 else:
                     for pair in el.attrib['points'].split(';'):
                         shape['points'].extend(map(float, pair.split(',')))

cvat/apps/dextr_segmentation/static/dextr_segmentation/js/enginePlugin.js

@@ -55,7 +55,7 @@ window.addEventListener('DOMContentLoaded', () => {
                 get: () => instance._defaultType,
                 set: (type) => {
                     if (!['box', 'box_by_4_points', 'points', 'polygon',
-                        'polyline', 'auto_segmentation'].includes(type)) {
+                        'polyline', 'auto_segmentation', 'cuboid'].includes(type)) {
                         throw Error(`Unknown shape type found ${type}`);
                     }
                     instance._defaultType = type;

cvat/apps/engine/models.py

@@ -249,6 +249,7 @@ class ShapeType(str, Enum):
     POLYGON = 'polygon'     # (x0, y0, ..., xn, yn)
     POLYLINE = 'polyline'   # (x0, y0, ..., xn, yn)
     POINTS = 'points'       # (x0, y0, ..., xn, yn)
+    CUBOID = 'cuboid'
 
     @classmethod
     def choices(self):

cvat/apps/engine/serializers.py

@@ -373,7 +373,7 @@ class ShapeSerializer(serializers.Serializer):
     occluded = serializers.BooleanField()
     z_order = serializers.IntegerField(default=0)
     points = serializers.ListField(
-        child=serializers.FloatField(min_value=0),
+        child=serializers.FloatField(),
         allow_empty=False,
     )
 

cvat/apps/engine/static/engine/js/annotationParser.js

@@ -29,10 +29,10 @@ class AnnotationParser {
         const imWidth = this._im_meta[frame].width;
         const imHeight = this._im_meta[frame].height;
 
-        let xtl = +box.getAttribute('xtl');
-        let ytl = +box.getAttribute('ytl');
-        let xbr = +box.getAttribute('xbr');
-        let ybr = +box.getAttribute('ybr');
+        const xtl = +box.getAttribute("xtl");
+        const ytl = +box.getAttribute("ytl");
+        const xbr = +box.getAttribute("xbr");
+        const ybr = +box.getAttribute("ybr");
 
         if (xtl < 0 || ytl < 0 || xbr < 0 || ybr < 0
             || xtl > imWidth || ytl > imHeight || xbr > imWidth || ybr > imHeight) {
@@ -155,6 +155,7 @@ class AnnotationParser {
             polygons: [],
             polylines: [],
             points: [],
+            cuboids: [],
         };
 
         const tracks = xml.getElementsByTagName('track');
@@ -163,12 +164,14 @@ class AnnotationParser {
             polygon: this._getShapeFromPath('polygon', tracks),
             polyline: this._getShapeFromPath('polyline', tracks),
             points: this._getShapeFromPath('points', tracks),
+            cuboid: this._getShapeFromPath('cuboid', tracks),
         };
         const shapeTarget = {
             box: 'boxes',
             polygon: 'polygons',
             polyline: 'polylines',
             points: 'points',
+            cuboid: 'cuboids',
         };
 
         const images = xml.getElementsByTagName('image');
@@ -194,6 +197,10 @@ class AnnotationParser {
                 points.setAttribute('frame', frame);
                 parsed.points.push(points);
             }
+            for (const cuboid of image.getElementsByTagName('cuboid')) {
+                cuboid.setAttribute('frame', frame);
+                parsed.cuboid.push(cuboid);
+            }
         }
 
         for (const shapeType in parsed) {
@@ -224,6 +231,18 @@ class AnnotationParser {
                             occluded,
                             points,
                         });
+                    } else if (shapeType === 'cuboid') {
+                        const [points, occluded, zOrder] = this._getPolyPosition(shape, frame);
+                        data[shapeTarget[shapeType]].push({
+                            label_id: labelId,
+                            group: +group,
+                            attributes: attributeList,
+                            type: 'cuboid',
+                            z_order: zOrder,
+                            frame,
+                            occluded,
+                            points,
+                        });
                     } else {
                         const [points, occluded, zOrder] = this._getPolyPosition(shape, frame);
                         data[shapeTarget[shapeType]].push({

cvat/apps/engine/static/engine/js/annotationSaver.js

@@ -1,3 +1,9 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
 /* exported buildAnnotationSaver */
 
 /* global

cvat/apps/engine/static/engine/js/annotationUI.js

@@ -295,6 +295,8 @@ function setupMenu(job, task, shapeCollectionModel,
                     <td> ${byLabelsStat[labelId].polylines.interpolation} </td>
                     <td> ${byLabelsStat[labelId].points.annotation} </td>
                     <td> ${byLabelsStat[labelId].points.interpolation} </td>
+                    <td> ${byLabelsStat[labelId].cuboids.annotation} </td>
+                    <td> ${byLabelsStat[labelId].cuboids.interpolation} </td>
                     <td> ${byLabelsStat[labelId].manually} </td>
                     <td> ${byLabelsStat[labelId].interpolated} </td>
                     <td class="semiBold"> ${byLabelsStat[labelId].total} </td>
@@ -312,6 +314,8 @@ function setupMenu(job, task, shapeCollectionModel,
                 <td> ${totalStat.polylines.interpolation} </td>
                 <td> ${totalStat.points.annotation} </td>
                 <td> ${totalStat.points.interpolation} </td>
+                <td> ${totalStat.cuboids.annotation} </td>
+                <td> ${totalStat.cuboids.interpolation} </td>
                 <td> ${totalStat.manually} </td>
                 <td> ${totalStat.interpolated} </td>
                 <td> ${totalStat.total} </td>
@@ -670,13 +674,15 @@ function buildAnnotationUI(jobData, taskData, imageMetaData, annotationData, ann
         'track count': totalStat.boxes.annotation + totalStat.boxes.interpolation
             + totalStat.polygons.annotation + totalStat.polygons.interpolation
             + totalStat.polylines.annotation + totalStat.polylines.interpolation
-            + totalStat.points.annotation + totalStat.points.interpolation,
+            + totalStat.points.annotation + totalStat.points.interpolation
+            + totalStat.cuboids.annotation + totalStat.cuboids.interpolation,
         'frame count': window.cvat.player.frames.stop - window.cvat.player.frames.start + 1,
         'object count': totalStat.total,
         'box count': totalStat.boxes.annotation + totalStat.boxes.interpolation,
         'polygon count': totalStat.polygons.annotation + totalStat.polygons.interpolation,
         'polyline count': totalStat.polylines.annotation + totalStat.polylines.interpolation,
         'points count': totalStat.points.annotation + totalStat.points.interpolation,
+        'cuboid count': totalStat.cuboids.annotation + totalStat.cuboids.interpolation,
     });
     loadJobEvent.close();