Remove empty masks

cvat-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvat-core",
-  "version": "14.0.1",
+  "version": "14.1.0",
   "type": "module",
   "description": "Part of Computer Vision Tool which presents an interface for client-side integration",
   "main": "src/api.ts",

cvat-core/src/annotations-collection.ts

@@ -1006,6 +1006,12 @@ export default class Collection {
                     );
                 }
 
+                if (state.shapeType === 'mask' && state.points.length < 6) {
+                    throw new ArgumentError(
+                        'Could not create empty mask',
+                    );
+                }
+
                 if (state.objectType === 'shape') {
                     constructed.shapes.push({
                         attributes,
@@ -1095,27 +1101,46 @@ export default class Collection {
         // eslint-disable-next-line no-unsanitized/method
         const imported = this.import(constructed);
         const importedArray = imported.tags.concat(imported.tracks).concat(imported.shapes);
+        const additionalUndo = [];
+        const additionalRedo = [];
+        const additionalClientIDs = [];
         for (const object of importedArray) {
-            if (object.shapeType === ShapeType.MASK && config.removeUnderlyingMaskPixels) {
-                (object as MaskShape).removeUnderlyingPixels(object.frame);
+            if (object.shapeType === ShapeType.MASK && config.removeUnderlyingMaskPixels.enabled) {
+                const {
+                    clientIDs,
+                    undo: undoWithRemoveIncorrectMasks,
+                    redo: redoWithRemoveIncorrectMasks,
+                } = (object as MaskShape).removeUnderlyingPixels(object.frame);
+                additionalUndo.push(undoWithRemoveIncorrectMasks);
+                additionalRedo.push(redoWithRemoveIncorrectMasks);
+                additionalClientIDs.push(clientIDs);
             }
         }
-
+        if (config.removeUnderlyingMaskPixels.enabled && additionalClientIDs.length !== 0) {
+            config.removeUnderlyingMaskPixels?.onEmptyMaskOccurrence();
+        }
         if (objectStates.length) {
             this.history.do(
                 HistoryActions.CREATED_OBJECTS,
                 () => {
                     importedArray.forEach((object) => {
                         object.removed = true;
                     });
+                    additionalUndo.forEach((undo) => {
+                        undo();
+                    });
                 },
                 () => {
                     importedArray.forEach((object) => {
                         object.removed = false;
                         object.serverID = undefined;
                     });
+
+                    additionalRedo.forEach((redo) => {
+                        redo();
+                    });
                 },
-                importedArray.map((object) => object.clientID),
+                [...importedArray.map((object) => object.clientID), ...additionalClientIDs.flat()],
                 objectStates[0].frame,
             );
         }

cvat-core/src/annotations-objects.ts

@@ -7,7 +7,9 @@ import { omit } from 'lodash';
 import config from './config';
 import ObjectState, { SerializedData } from './object-state';
 import { checkObjectType, clamp } from './common';
-import { DataError, ArgumentError, ScriptingError } from './exceptions';
+import {
+    DataError, ArgumentError, ScriptingError,
+} from './exceptions';
 import { Label } from './labels';
 import {
     colors, Source, ShapeType, ObjectType, HistoryActions, DimensionType, JobType,
@@ -2157,6 +2159,9 @@ export class MaskShape extends Shape {
 
     protected validateStateBeforeSave(data: ObjectState, updated: ObjectState['updateFlags'], frame?: number): number[] {
         Annotation.prototype.validateStateBeforeSave.call(this, data, updated);
+        if (data.points.length < 6) {
+            throw new ArgumentError('Could not save empty mask');
+        }
         if (updated.points) {
             const { width, height } = this.frameMeta[frame];
             return cropMask(data.points, width, height);
@@ -2165,7 +2170,7 @@ export class MaskShape extends Shape {
         return [];
     }
 
-    public removeUnderlyingPixels(frame: number): void {
+    public removeUnderlyingPixels(frame: number): { clientIDs: number[], undo: Function, redo: Function } {
         if (frame !== this.frame) {
             throw new ArgumentError(
                 `Wrong "frame" attribute: is not equal to the shape frame (${frame} vs ${this.frame})`,
@@ -2206,10 +2211,36 @@ export class MaskShape extends Shape {
             }
         }
 
+        const incorrectMasks = [];
         for (const object of Object.values(updatedObjects)) {
-            object.points = mask2Rle(masks[object.clientID]);
+            const points = mask2Rle(masks[object.clientID]);
+            if (points.length < 2) {
+                incorrectMasks.push(object);
+                object.removed = true;
+            } else {
+                object.points = points;
+            }
             object.updated = Date.now();
         }
+
+        const undo = (): void => {
+            for (const object of incorrectMasks) {
+                object.removed = false;
+                object.updated = Date.now();
+            }
+        };
+        const redo = (): void => {
+            for (const object of incorrectMasks) {
+                object.removed = true;
+                object.updated = Date.now();
+            }
+        };
+
+        return {
+            clientIDs: incorrectMasks.map((object: MaskShape) => object.clientID),
+            undo,
+            redo,
+        };
     }
 
     protected savePoints(maskPoints: number[], frame: number): void {
@@ -2246,15 +2277,31 @@ export class MaskShape extends Shape {
             this.updated = Date.now();
         };
 
-        this.history.do(
-            HistoryActions.CHANGED_POINTS,
-            undo, redo, [this.clientID], frame,
-        );
-
         redo();
-
-        if (config.removeUnderlyingMaskPixels) {
-            this.removeUnderlyingPixels(frame);
+        if (config.removeUnderlyingMaskPixels.enabled) {
+            const {
+                clientIDs,
+                undo: undoWithRemoveIncorrectMasks,
+                redo: redoWithRemoveIncorrectMasks,
+            } = this.removeUnderlyingPixels(frame);
+            config.removeUnderlyingMaskPixels?.onEmptyMaskOccurrence();
+            this.history.do(
+                HistoryActions.CHANGED_POINTS,
+                () => {
+                    undoWithRemoveIncorrectMasks();
+                    undo();
+                },
+                () => {
+                    redoWithRemoveIncorrectMasks();
+                    redo();
+                },
+                [this.clientID, ...clientIDs], frame,
+            );
+        } else {
+            this.history.do(
+                HistoryActions.CHANGED_POINTS,
+                undo, redo, [this.clientID], frame,
+            );
         }
     }
 

cvat-core/src/api.ts

@@ -262,11 +262,16 @@ function build(): CVATCore {
             set uploadChunkSize(value) {
                 config.uploadChunkSize = value;
             },
-            get removeUnderlyingMaskPixels(): boolean {
-                return config.removeUnderlyingMaskPixels;
-            },
-            set removeUnderlyingMaskPixels(value: boolean) {
-                config.removeUnderlyingMaskPixels = value;
+            removeUnderlyingMaskPixels: {
+                get enabled() {
+                    return config.removeUnderlyingMaskPixels.enabled;
+                },
+                set enabled(value: boolean) {
+                    config.removeUnderlyingMaskPixels.enabled = value;
+                },
+                set onEmptyMaskOccurrence(value: () => void) {
+                    config.removeUnderlyingMaskPixels.onEmptyMaskOccurrence = value;
+                },
             },
             get onOrganizationChange(): (orgId: number) => void {
                 return config.onOrganizationChange;

cvat-core/src/config.ts

@@ -11,7 +11,10 @@ const config = {
     },
     origin: '',
     uploadChunkSize: 100,
-    removeUnderlyingMaskPixels: false,
+    removeUnderlyingMaskPixels: {
+        enabled: false,
+        onEmptyMaskOccurrence: null,
+    },
     onOrganizationChange: null,
     globalObjectsCounter: 0,
 };

cvat-core/src/index.ts

@@ -146,7 +146,10 @@ export default interface CVATCore {
         backendAPI: typeof config.backendAPI;
         origin: typeof config.origin;
         uploadChunkSize: typeof config.uploadChunkSize;
-        removeUnderlyingMaskPixels: typeof config.removeUnderlyingMaskPixels;
+        removeUnderlyingMaskPixels: {
+            enabled: boolean;
+            onEmptyMaskOccurrence: () => void | null;
+        };
         onOrganizationChange: typeof config.onOrganizationChange;
         globalObjectsCounter: typeof config.globalObjectsCounter;
     },

cvat-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvat-ui",
-  "version": "1.61.0",
+  "version": "1.61.1",
   "description": "CVAT single-page application",
   "main": "src/index.tsx",
   "scripts": {

cvat-ui/src/components/annotation-page/canvas/views/canvas2d/brush-tools.tsx

@@ -11,6 +11,7 @@ import Button from 'antd/lib/button';
 import Icon, { VerticalAlignBottomOutlined } from '@ant-design/icons';
 import InputNumber from 'antd/lib/input-number';
 import Select from 'antd/lib/select';
+import notification from 'antd/lib/notification';
 
 import { filterApplicableForType } from 'utils/filter-applicable-labels';
 import { getCore, Label, LabelType } from 'cvat-core-wrapper';
@@ -62,9 +63,16 @@ function BrushTools(): React.ReactPortal | null {
         DraggableArea,
     );
 
+    getCore().config.removeUnderlyingMaskPixels.onEmptyMaskOccurrence = () => {
+        notification.warning({
+            message: 'As a result of removing the underlying pixels, some masks became empty and were subsequently deleted.',
+            className: 'cvat-empty-masks-notification',
+        });
+    };
+
     useEffect(() => {
         const label = labels.find((_label: any) => _label.id === defaultLabelID);
-        getCore().config.removeUnderlyingMaskPixels = removeUnderlyingPixels;
+        getCore().config.removeUnderlyingMaskPixels.enabled = removeUnderlyingPixels;
         if (visible && label && canvasInstance instanceof Canvas) {
             const onUpdateConfiguration = ({ brushTool }: any): void => {
                 if (brushTool?.size) {