Fixed propagate in ground truth tasks with sparsed frames

changelog.d/20241016_133802_sekachev.bs_fixed_propagation.md

@@ -0,0 +1,4 @@
+### Fixed
+
+- Propagation creates copies on non-existing frames in a ground truth job
+  (<https://github.com/cvat-ai/cvat/pull/8550>)

cvat-core/src/annotations-actions.ts

@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { omit, throttle } from 'lodash';
+import { omit, range, throttle } from 'lodash';
 import { ArgumentError } from './exceptions';
 import { SerializedCollection, SerializedShape } from './server-response-types';
 import { Job, Task } from './session';
@@ -107,13 +107,15 @@ class PropagateShapes extends BaseSingleFrameAction {
     }
 
     public async run(
-        instance,
+        instance: Job | Task,
         { collection: { shapes }, frameData: { number } },
     ): Promise<SingleFrameActionOutput> {
         if (number === this.#targetFrame) {
             return { collection: { shapes } };
         }
-        const propagatedShapes = propagateShapes<SerializedShape>(shapes, number, this.#targetFrame);
+
+        const frameNumbers = instance instanceof Job ? await instance.frames.frameNumbers() : range(0, instance.size);
+        const propagatedShapes = propagateShapes<SerializedShape>(shapes, number, this.#targetFrame, frameNumbers);
         return { collection: { shapes: [...shapes, ...propagatedShapes] } };
     }
 

cvat-core/src/frames.ts

@@ -211,6 +211,11 @@ export class FramesMetaData {
         return Math.floor(this.getFrameIndex(dataFrameNumber) / this.chunkSize);
     }
 
+    getSegmentFrameNumbers(jobStartFrame: number): number[] {
+        const frames = this.getDataFrameNumbers();
+        return frames.map((frame) => this.getJobRelativeFrameNumber(frame) + jobStartFrame);
+    }
+
     getDataFrameNumbers(): number[] {
         if (this.includedFrames) {
             return [...this.includedFrames];
@@ -348,9 +353,7 @@ Object.defineProperty(FrameData.prototype.data, 'implementation', {
             const requestId = +_.uniqueId();
             const requestedDataFrameNumber = meta.getDataFrameNumber(this.number - jobStartFrame);
             const chunkIndex = meta.getFrameChunkIndex(requestedDataFrameNumber);
-            const segmentFrameNumbers = meta.getDataFrameNumbers().map((dataFrameNumber: number) => (
-                meta.getJobRelativeFrameNumber(dataFrameNumber) + jobStartFrame
-            ));
+            const segmentFrameNumbers = meta.getSegmentFrameNumbers(jobStartFrame);
             const frame = provider.frame(this.number);
 
             function findTheNextNotDecodedChunk(currentFrameIndex: number): number | null {
@@ -889,9 +892,7 @@ export function getJobFrameNumbers(jobID: number): number[] {
     }
 
     const { meta, jobStartFrame } = frameDataCache[jobID];
-    return meta.getDataFrameNumbers().map((dataFrameNumber: number): number => (
-        meta.getJobRelativeFrameNumber(dataFrameNumber) + jobStartFrame
-    ));
+    return meta.getSegmentFrameNumbers(jobStartFrame);
 }
 
 export function clear(jobID: number): void {

cvat-core/src/object-utils.ts

@@ -360,7 +360,7 @@ export function rle2Mask(rle: number[], width: number, height: number): number[]
 }
 
 export function propagateShapes<T extends SerializedShape | ObjectState>(
-    shapes: T[], from: number, to: number,
+    shapes: T[], from: number, to: number, frameNumbers: number[],
 ): T[] {
     const getCopy = (shape: T): SerializedShape | SerializedData => {
         if (shape instanceof ObjectState) {
@@ -397,9 +397,18 @@ export function propagateShapes<T extends SerializedShape | ObjectState>(
         };
     };
 
+    const targetFrameNumbers = frameNumbers.filter(
+        (frameNumber: number) => frameNumber >= Math.min(from, to) &&
+            frameNumber <= Math.max(from, to) &&
+            frameNumber !== from,
+    );
+
     const states: T[] = [];
-    const sign = Math.sign(to - from);
-    for (let frame = from + sign; sign > 0 ? frame <= to : frame >= to; frame += sign) {
+    for (const frame of targetFrameNumbers) {
+        if (frame === from) {
+            continue;
+        }
+
         for (const shape of shapes) {
             const copy = getCopy(shape);
 

cvat-core/src/session-implementation.ts

@@ -879,6 +879,14 @@ export function implementTask(Task: typeof TaskClass): typeof TaskClass {
         },
     });
 
+    Object.defineProperty(Task.prototype.frames.frameNumbers, 'implementation', {
+        value: function includedFramesImplementation(
+            this: TaskClass,
+        ): ReturnType<typeof TaskClass.prototype.frames.frameNumbers> {
+            throw new Error('Not implemented for Task');
+        },
+    });
+
     Object.defineProperty(Task.prototype.frames.preview, 'implementation', {
         value: function previewImplementation(
             this: TaskClass,

cvat-core/src/session.ts

@@ -373,8 +373,8 @@ export class Session {
     };
 
     public actions: {
-        undo: (count: number) => Promise<number[]>;
-        redo: (count: number) => Promise<number[]>;
+        undo: (count?: number) => Promise<number[]>;
+        redo: (count?: number) => Promise<number[]>;
         freeze: (frozen: boolean) => Promise<void>;
         clear: () => Promise<void>;
         get: () => Promise<{ undo: [HistoryActions, number][], redo: [HistoryActions, number][] }>;
@@ -403,8 +403,8 @@ export class Session {
     public logger: {
         log: (
             scope: Parameters<typeof logger.log>[0],
-            payload: Parameters<typeof logger.log>[1],
-            wait: Parameters<typeof logger.log>[2],
+            payload?: Parameters<typeof logger.log>[1],
+            wait?: Parameters<typeof logger.log>[2],
         ) => ReturnType<typeof logger.log>;
     };
 

cvat-ui/src/actions/annotation-actions.ts

@@ -452,6 +452,7 @@ export function propagateObjectAsync(from: number, to: number): ThunkAction {
         const {
             job: {
                 instance: sessionInstance,
+                frameNumbers,
             },
             annotations: {
                 activatedStateID,
@@ -465,12 +466,17 @@ export function propagateObjectAsync(from: number, to: number): ThunkAction {
                 throw new Error('There is not an activated object state to be propagated');
             }
 
-            await sessionInstance.logger.log(EventScope.propagateObject, { count: Math.abs(to - from) });
-            const states = cvat.utils.propagateShapes<ObjectState>([objectState], from, to);
+            if (!sessionInstance) {
+                throw new Error('SessionInstance is not defined, propagation is not possible');
+            }
 
-            await sessionInstance.annotations.put(states);
-            const history = await sessionInstance.actions.get();
+            const states = cvat.utils.propagateShapes<ObjectState>([objectState], from, to, frameNumbers);
+            if (states.length) {
+                await sessionInstance.logger.log(EventScope.propagateObject, { count: states.length });
+                await sessionInstance.annotations.put(states);
+            }
 
+            const history = await sessionInstance.actions.get();
             dispatch({
                 type: AnnotationActionTypes.PROPAGATE_OBJECT_SUCCESS,
                 payload: { history },
@@ -596,10 +602,10 @@ export function confirmCanvasReadyAsync(): ThunkAction {
     return async (dispatch: ThunkDispatch, getState: () => CombinedState): Promise<void> => {
         try {
             const state: CombinedState = getState();
-            const { instance: job } = state.annotation.job;
+            const job = state.annotation.job.instance as Job;
+            const includedFrames = state.annotation.job.frameNumbers;
             const { changeFrameEvent } = state.annotation.player.frame;
             const chunks = await job.frames.cachedChunks() as number[];
-            const includedFrames = await job.frames.frameNumbers() as number[];
             const { frameCount, dataChunkSize } = job;
 
             const ranges = chunks.map((chunk) => (
@@ -916,7 +922,6 @@ export function getJobAsync({
                 }
             }
 
-            const jobMeta = await cvat.frames.getMeta('job', job.id);
             // frame query parameter does not work for GT job
             const frameNumber = Number.isInteger(initialFrame) && gtJob?.id !== job.id ?
                 initialFrame as number :
@@ -925,6 +930,8 @@ export function getJobAsync({
                 )) || job.startFrame;
 
             const frameData = await job.frames.get(frameNumber);
+            const jobMeta = await cvat.frames.getMeta('job', job.id);
+            const frameNumbers = await job.frames.frameNumbers();
             try {
                 // call first getting of frame data before rendering interface
                 // to load and decode first chunk
@@ -962,6 +969,7 @@ export function getJobAsync({
                 payload: {
                     openTime,
                     job,
+                    frameNumbers,
                     jobMeta,
                     queryParameters,
                     groundTruthInstance: gtJob || null,

cvat-ui/src/components/annotation-page/standard-workspace/propagate-confirm.tsx

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT
 
 import React, { useEffect, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
+import { shallowEqual, useDispatch, useSelector } from 'react-redux';
 import Modal from 'antd/lib/modal';
 import InputNumber from 'antd/lib/input-number';
 import Text from 'antd/lib/typography/Text';
@@ -23,12 +23,19 @@ export enum PropagateDirection {
 
 function PropagateConfirmComponent(): JSX.Element {
     const dispatch = useDispatch();
-    const visible = useSelector((state: CombinedState) => state.annotation.propagate.visible);
-    const frameNumber = useSelector((state: CombinedState) => state.annotation.player.frame.number);
-    const startFrame = useSelector((state: CombinedState) => state.annotation.job.instance.startFrame);
-    const stopFrame = useSelector((state: CombinedState) => state.annotation.job.instance.stopFrame);
-    const [targetFrame, setTargetFrame] = useState<number>(frameNumber);
+    const {
+        visible,
+        frameNumber,
+        frameNumbers,
+    } = useSelector((state: CombinedState) => ({
+        visible: state.annotation.propagate.visible,
+        frameNumber: state.annotation.player.frame.number,
+        frameNumbers: state.annotation.job.frameNumbers,
+    }), shallowEqual);
 
+    const [targetFrame, setTargetFrame] = useState<number>(frameNumber);
+    const startFrame = frameNumbers[0];
+    const stopFrame = frameNumbers[frameNumbers.length - 1];
     const propagateFrames = Math.abs(targetFrame - frameNumber);
     const propagateDirection = targetFrame >= frameNumber ? PropagateDirection.FORWARD : PropagateDirection.BACKWARD;
 
@@ -93,9 +100,9 @@ function PropagateConfirmComponent(): JSX.Element {
                             size='small'
                             min={0}
                             value={propagateFrames}
-                            onChange={(value: number) => {
-                                if (typeof value !== 'undefined') {
-                                    updateTargetFrame(propagateDirection, +value);
+                            onChange={(value: number | null) => {
+                                if (typeof value === 'number') {
+                                    updateTargetFrame(propagateDirection, value);
                                 }
                             }}
                         />
@@ -115,7 +122,7 @@ function PropagateConfirmComponent(): JSX.Element {
                                 [frameNumber]: 'FROM',
                                 [targetFrame]: 'TO',
                             } : undefined}
-                            onChange={([value1, value2]: [number, number]) => {
+                            onChange={([value1, value2]: number[]) => {
                                 const value = value1 === frameNumber || value1 === targetFrame ? value2 : value1;
                                 if (value < frameNumber) {
                                     setTargetFrame(clamp(value, startFrame, frameNumber));
@@ -133,8 +140,8 @@ function PropagateConfirmComponent(): JSX.Element {
                             min={startFrame}
                             max={stopFrame}
                             value={targetFrame}
-                            onChange={(value: number) => {
-                                if (typeof value !== 'undefined') {
+                            onChange={(value: number | null) => {
+                                if (typeof value === 'number') {
                                     if (value > frameNumber) {
                                         setTargetFrame(clamp(+value, frameNumber, stopFrame));
                                     } else if (value < frameNumber) {

cvat-ui/src/reducers/annotation-reducer.ts

@@ -67,6 +67,7 @@ const defaultState: AnnotationState = {
             groundTruthJobFramesMeta: null,
             groundTruthInstance: null,
         },
+        frameNumbers: [],
         instance: null,
         meta: null,
         attributes: {},
@@ -165,6 +166,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 job,
                 jobMeta,
                 openTime,
+                frameNumbers,
                 frameNumber: number,
                 frameFilename: filename,
                 relatedFiles,
@@ -209,6 +211,7 @@ export default (state = defaultState, action: AnyAction): AnnotationState => {
                 job: {
                     ...state.job,
                     openTime,
+                    frameNumbers,
                     fetching: false,
                     instance: job,
                     meta: jobMeta,

cvat-ui/src/reducers/index.ts

@@ -731,6 +731,7 @@ export interface AnnotationState {
         requestedId: number | null;
         meta: FramesMetaData | null;
         instance: Job | null | undefined;
+        frameNumbers: number[];
         queryParameters: {
             initialOpenGuide: boolean;
             defaultLabel: string | null;