import throttle from "lodash/throttle";
|
import { destroy, detach, flow, getEnv, getParent, getRoot, isAlive, onSnapshot, types } from "mobx-state-tree";
|
import { ff } from "@humansignal/core";
|
import { errorBuilder } from "../../core/DataValidator/ConfigValidator";
|
import { guidGenerator } from "../../core/Helpers";
|
import { Hotkey } from "../../core/Hotkey";
|
import TimeTraveller from "../../core/TimeTraveller";
|
import Tree, { TRAVERSE_STOP } from "../../core/Tree";
|
import Types from "../../core/Types";
|
import Area from "../../regions/Area";
|
import Result from "../../regions/Result";
|
import Utils from "../../utils";
|
import {
|
FF_DEV_1284,
|
FF_DEV_3391,
|
FF_LLM_EPIC,
|
FF_LSDV_3009,
|
FF_LSDV_4583,
|
FF_REVIEWER_FLOW,
|
isFF,
|
} from "../../utils/feature-flags";
|
import { delay, isDefined } from "../../utils/utilities";
|
import { CommentStore } from "../Comment/CommentStore";
|
import RegionStore from "../RegionStore";
|
import RelationStore from "../RelationStore";
|
import { UserExtended } from "../UserStore";
|
import { LinkingModes } from "./LinkingModes";
|
|
const hotkeys = Hotkey("Annotations", "Annotations");
|
|
/**
|
* Omit value fields from the object.
|
*
|
* This should fix a problem with wrong region type detection caused by overlapping fields from a result and from an area.
|
* The current problem is related to the text field of richtext region that could appear in the result for the textarea as well.
|
* As these fields have the same name and different types it could make the region to be detected as a classification region instead of richtext,
|
* and we may miss its displaying.
|
*
|
* For now, it is mostly related to the rich text region with per region textareas.
|
* The problem may appear when we get wrong order of results for deserialization.
|
* The other reason may be the omitted main result (We declare that all the data that we need to restore the main region is also contained in the per-region results).
|
* @example Wrong order:
|
* [{
|
* "id": "id_1",
|
* "from_name": "comment",
|
* "to_name": "text",
|
* "type": "textarea",
|
* "value": {
|
* "start": 0,
|
* "end": 11,
|
* "text": ["A comment for the region],
|
* },
|
* },
|
* {
|
* "id": "id_1",
|
* "from_name": "labels",
|
* "to_name": "text",
|
* "type": "labels",
|
* "value": {
|
* "start": 0,
|
* "end": 11,
|
* "labels": ["Label 1"],
|
* "text": "Just a text",
|
* },
|
* }]
|
*
|
* @example Omitted main result:
|
* [{
|
* "id": "only_per_region_textarea",
|
* "from_name": "comment",
|
* "to_name": "text",
|
* "type": "textarea",
|
* "value": {
|
* "start": 0,
|
* "end": 11,
|
* "labels": ["Label 1"],
|
* "text": ["A comment for the region"],
|
* },
|
* }]
|
*
|
* @param value {Object} object to fix
|
* @returns {Object} new object without value fields
|
*/
|
const omitValueFields = ff.isActive(ff.FF_CUSTOM_TAGS)
|
? (value) => {
|
// @todo describe that we only omit `text` from TextArea
|
if (Array.isArray(value.text)) {
|
const { text: _, ...newValue } = value;
|
return newValue;
|
}
|
|
return value;
|
}
|
: (value) => {
|
const newValue = { ...value };
|
Result.properties.value.propertyNames.forEach((propName) => {
|
delete newValue[propName];
|
});
|
return newValue;
|
};
|
|
const TrackedState = types.model("TrackedState", {
|
areas: types.map(Area),
|
relationStore: types.optional(RelationStore, {}),
|
});
|
|
// Create a union type that can handle both user references and frozen user objects
|
const UserOrReference = types.union({
|
dispatcher: (snapshot) => {
|
// If it's a number, it's a reference to a user ID
|
if (typeof snapshot === "number") {
|
return types.safeReference(UserExtended);
|
}
|
// If it's a full user object, store it as frozen to avoid duplicate instances
|
if (snapshot && typeof snapshot === "object" && (snapshot.firstName || snapshot.email || snapshot.username)) {
|
return types.frozen();
|
}
|
// Default to reference for any other case
|
return types.safeReference(UserExtended);
|
},
|
cases: {
|
frozen: types.frozen(),
|
reference: types.safeReference(UserExtended),
|
},
|
});
|
|
const _Annotation = types
|
.model("AnnotationBase", {
|
id: types.identifier,
|
// @todo this value used `guidGenerator(5)` as default value before
|
// @todo but it calculates once, so all the annotations have the same pk
|
// @todo why don't use only `id`?
|
// @todo reverted back to wrong type; maybe it breaks all the deserialisation
|
pk: types.maybeNull(types.string),
|
|
selected: types.optional(types.boolean, false),
|
type: types.enumeration(["annotation", "prediction", "history"]),
|
|
createdDate: types.optional(types.string, Utils.UDate.currentISODate()),
|
createdAgo: types.maybeNull(types.string),
|
createdBy: types.optional(types.string, "Admin"),
|
user: types.optional(types.maybeNull(UserOrReference), null),
|
score: types.maybeNull(types.number),
|
|
parent_prediction: types.maybeNull(types.integer),
|
parent_annotation: types.maybeNull(types.integer),
|
last_annotation_history: types.maybeNull(types.integer),
|
|
comment_count: types.maybeNull(types.integer),
|
unresolved_comment_count: types.maybeNull(types.integer),
|
|
loadedDate: types.optional(types.Date, () => new Date()),
|
leadTime: types.maybeNull(types.number),
|
|
// @todo use types.Date
|
draftSaved: types.maybe(types.string),
|
|
// created by user during this session
|
userGenerate: types.optional(types.boolean, true),
|
sentUserGenerate: types.optional(types.boolean, false),
|
localUpdate: types.optional(types.boolean, false),
|
|
ground_truth: types.optional(types.boolean, false),
|
skipped: false,
|
|
// This field stores all data that affects undo/redo history
|
// It should contain real objects to be able to work with them through snapshots
|
// Annotation will use getters to get them at the top level
|
// This data is never redefined directly, it's empty at the start
|
trackedState: types.optional(TrackedState, {}),
|
history: types.optional(TimeTraveller, { targetPath: "../trackedState" }),
|
|
dragMode: types.optional(types.boolean, false),
|
|
editable: types.optional(types.boolean, true),
|
readonly: types.optional(types.boolean, false),
|
|
suggestions: types.map(Area),
|
|
regionStore: types.optional(RegionStore, {
|
regions: [],
|
}),
|
|
isDrawing: types.optional(types.boolean, false),
|
|
commentStore: types.optional(CommentStore, {
|
comments: [],
|
}),
|
|
...(isFF(FF_DEV_3391) ? { root: Types.allModelsTypes() } : {}),
|
})
|
.views((self) => ({
|
get areas() {
|
return self.trackedState.areas;
|
},
|
get relationStore() {
|
return self.trackedState.relationStore;
|
},
|
}))
|
.preProcessSnapshot((sn) => {
|
// sn.draft = Boolean(sn.draft);
|
const user = sn.user ?? sn.completed_by ?? undefined;
|
let root;
|
|
const updateIds = (item) => {
|
const children = item.children?.map(updateIds);
|
const imageEntities = item.imageEntities?.map(updateIds);
|
let updatedItem = item;
|
|
if (children) updatedItem = { ...updatedItem, children };
|
if (imageEntities) updatedItem = { ...updatedItem, imageEntities };
|
if (updatedItem.id) updatedItem = { ...updatedItem, id: `${updatedItem.name ?? updatedItem.id}@${sn.id}` };
|
// @todo fallback for tags with name as id:
|
// if (item.name) item = { ...item, name: item.name + "@" + sn.id };
|
// @todo soon no such tags should left
|
|
return updatedItem;
|
};
|
|
if (isFF(FF_DEV_3391)) {
|
root = updateIds(sn.root.toJSON());
|
}
|
|
const getCreatedBy = (snapshot) => {
|
if (snapshot.type === "prediction") {
|
const modelVersion = snapshot.model_version?.trim() ?? "";
|
return modelVersion || "Admin";
|
}
|
|
return snapshot.createdBy ?? "Admin";
|
};
|
|
const getCreatedAt = (snapshot) => {
|
return snapshot.draft_created_at ?? snapshot.created_at ?? snapshot.createdDate;
|
};
|
|
return {
|
...sn,
|
...(isFF(FF_DEV_3391) ? { root } : {}),
|
user,
|
editable: sn.editable ?? sn.type === "annotation",
|
createdBy: getCreatedBy(sn),
|
createdDate: getCreatedAt(sn),
|
ground_truth: sn.honeypot ?? sn.ground_truth ?? false,
|
skipped: sn.skipped || sn.was_cancelled,
|
acceptedState: sn.accepted_state ?? sn.acceptedState ?? null,
|
};
|
})
|
.views((self) =>
|
isFF(FF_DEV_3391)
|
? {}
|
: {
|
get root() {
|
return self.list.root;
|
},
|
|
get names() {
|
return self.list.names;
|
},
|
|
get toNames() {
|
return self.list.toNames;
|
},
|
},
|
)
|
.views((self) => ({
|
get store() {
|
return getRoot(self);
|
},
|
|
get list() {
|
return getParent(self, 2);
|
},
|
|
get objects() {
|
// Without correct validation toname may be null for control tags so we need to check isObjectTag instead of it
|
return Array.from(self.names.values()).filter((tag) => tag.isObjectTag);
|
},
|
|
get regions() {
|
return Array.from(self.areas.values());
|
},
|
|
get lastSelectedRegion() {
|
return self.selectedRegions[self.selectedRegions.length - 1];
|
},
|
|
get results() {
|
const results = [];
|
|
if (isAlive(self)) self.areas.forEach((a) => a.results.forEach((r) => results.push(r)));
|
return results;
|
},
|
|
get serialized() {
|
// Dirty hack to force MST track changes
|
self.areas.toJSON();
|
|
return self.results
|
.map((r) => r.serialize())
|
.filter(Boolean)
|
.concat(self.relationStore.serialize());
|
},
|
|
get serializedSelection() {
|
// Dirty hack to force MST track changes
|
self.areas.toJSON();
|
|
const selectedResults = [];
|
|
self.areas.forEach((a) => {
|
if (!a.inSelection) return;
|
a.results.forEach((r) => {
|
selectedResults.push(r);
|
});
|
});
|
|
return selectedResults.map((r) => r.serialize()).filter(Boolean);
|
},
|
|
get highlightedNode() {
|
return self.regionStore.selection.highlighted;
|
},
|
|
get hasSelection() {
|
return self.regionStore.hasSelection;
|
},
|
get selectionSize() {
|
return self.regionStore.selection.size;
|
},
|
|
get selectedRegions() {
|
return Array.from(self.regionStore.selection.selected.values());
|
},
|
|
get selectedDrawingRegions() {
|
return Array.from(self.regionStore.selection.drawingSelected.values());
|
},
|
|
// existing annotation which can be updated
|
get exists() {
|
const dataExists = (self.userGenerate && self.sentUserGenerate) || isDefined(self.versions.result);
|
const pkExists = isDefined(self.pk);
|
|
return dataExists && pkExists;
|
},
|
|
get hasSuggestionsSupport() {
|
return self.objects.some((obj) => {
|
return obj.supportSuggestions;
|
});
|
},
|
|
get isNonEditableDraft() {
|
const isKnownUsers = !!self.user && !!self.store.user;
|
// If we do not know what user created draft
|
// and who we are, then, we shouldn't prevent the ability to edit annotation
|
// because we can't predict is it our draft or not.
|
// It most probably could be relevant for standalone `lsf`
|
if (!isKnownUsers) return false;
|
|
// If there is no `pk` than there is no annotation in DataBase
|
const isDraft = self.pk === null;
|
const isNonEditable = self.user.id !== self.store.user.id;
|
return isDraft && isNonEditable;
|
},
|
|
isReadOnly() {
|
return self.isNonEditableDraft || self.readonly || !self.editable;
|
},
|
}))
|
.volatile(() => ({
|
hidden: false,
|
draftId: 0,
|
draftSelected: false,
|
autosaveDelay: 5000,
|
isDraftSaving: false,
|
// This flag indicates that we are accepting suggestions right now (an accepting is started and not finished yet)
|
isSuggestionsAccepting: false,
|
submissionStarted: 0,
|
versions: {},
|
resultSnapshot: "",
|
}))
|
.volatile(() =>
|
isFF(FF_DEV_3391)
|
? {
|
names: new Map(),
|
toNames: new Map(),
|
ids: new Map(),
|
}
|
: {},
|
)
|
.views((self) => ({
|
// experiment to display review buttons in Quick View
|
get canBeReviewed() {
|
const store = self.store;
|
|
return (
|
isFF(FF_REVIEWER_FLOW) &&
|
// not a current user — we can only review others' annotations
|
self.user?.email &&
|
store.user?.email !== self.user?.email &&
|
// we have this only in LSE
|
getEnv(self).events.hasEvent("acceptAnnotation") &&
|
// Quick View — we don't have View All in Label Stream
|
store.hasInterface("annotations:view-all") &&
|
// skipped annotations can't be reviewed
|
!self.skipped &&
|
// annotation was submitted already
|
!isNaN(self.pk)
|
);
|
},
|
}))
|
.actions((self) => ({
|
reinitHistory(force = true) {
|
self.history.reinit(force);
|
self.autosave?.cancel();
|
if (self.type === "annotation") self.setInitialValues();
|
},
|
|
setEditable(val) {
|
self.editable = val;
|
},
|
|
setReadonly(val) {
|
self.readonly = val;
|
},
|
|
setIsDrawing(isDrawing) {
|
self.isDrawing = isDrawing;
|
},
|
|
setUnresolvedCommentCount(val) {
|
self.unresolved_comment_count = val;
|
},
|
|
setCommentCount(val) {
|
self.comment_count = val;
|
},
|
|
setGroundTruth(value, ivokeEvent = true) {
|
const root = getRoot(self);
|
|
if (root && root !== self && ivokeEvent) {
|
const as = root.annotationStore;
|
const assignGroundTruths = (p) => {
|
if (self !== p) p.setGroundTruth(false, false);
|
};
|
|
as.predictions.forEach(assignGroundTruths);
|
as.annotations.forEach(assignGroundTruths);
|
}
|
|
self.ground_truth = value;
|
|
if (ivokeEvent) {
|
getEnv(self).events.invoke("groundTruth", self.store, self, value);
|
}
|
},
|
|
sendUserGenerate() {
|
self.sentUserGenerate = true;
|
},
|
|
setLocalUpdate(value) {
|
self.localUpdate = value;
|
},
|
|
setDragMode(val) {
|
self.dragMode = val;
|
},
|
|
updatePersonalKey(value) {
|
self.pk = value;
|
getRoot(self).addAnnotationToTaskHistory?.(self.pk);
|
},
|
|
toggleVisibility(visible) {
|
self.hidden = visible === undefined ? !self.hidden : !visible;
|
},
|
|
setHighlightedNode() {
|
// moved to selectArea and others
|
},
|
|
selectArea(area) {
|
if (self.highlightedNode === area) return;
|
// if (current) current.setSelected(false);
|
self.regionStore.highlight(area);
|
// area.setSelected(true);
|
},
|
|
toggleRegionSelection(area, isSelected) {
|
self.regionStore.toggleSelection(area, isSelected);
|
},
|
|
selectAreas(areas) {
|
self.unselectAreas();
|
self.extendSelectionWith(areas);
|
},
|
|
extendSelectionWith(areas) {
|
for (const area of Array.isArray(areas) ? areas : [areas]) {
|
self.regionStore.toggleSelection(area, true);
|
}
|
},
|
|
unselectArea(area) {
|
if (self.highlightedNode !== area) return;
|
// area.setSelected(false);
|
self.regionStore.toggleSelection(area, false);
|
},
|
|
unselectAreas() {
|
if (!self.selectionSize) return;
|
self.regionStore.clearSelection();
|
},
|
|
lockSelectedRegions() {
|
for (const region of self.selectedRegions) {
|
region.setLocked(!region.locked);
|
}
|
},
|
|
hideSelectedRegions() {
|
for (const region of self.selectedRegions) {
|
region.toggleHidden();
|
}
|
},
|
|
deleteSelectedRegions() {
|
for (const region of self.selectedRegions) {
|
region.deleteRegion();
|
}
|
},
|
|
unselectStates() {
|
self.names.forEach((tag) => tag.unselectAll?.());
|
},
|
|
/**
|
* @param {boolean} tryToKeepStates don't unselect labels if such setting is enabled
|
*/
|
unselectAll(tryToKeepStates = false) {
|
const keepStates = tryToKeepStates && self.store.settings.continuousLabeling;
|
|
self.unselectAreas();
|
if (!keepStates) self.unselectStates();
|
},
|
|
removeArea(area) {
|
destroy(area);
|
},
|
|
deleteAllRegions({ deleteReadOnly = false } = {}) {
|
let regions = Array.from(self.areas.values());
|
|
// remove everything unconditionally
|
if (deleteReadOnly) {
|
self.unselectAll(true);
|
self.setIsDrawing(false);
|
self.relationStore.deleteAllRelations();
|
|
for (const r of regions) {
|
r.destroyRegion?.();
|
destroy(r);
|
}
|
|
self.updateObjects();
|
|
return;
|
}
|
|
if (deleteReadOnly === false) regions = regions.filter((r) => r.readonly === false);
|
|
for (const r of regions) {
|
r.deleteRegion();
|
}
|
self.updateObjects();
|
},
|
|
addRegion(reg) {
|
self.regionStore.unselectAll(true);
|
|
if (self.isLinkingMode) {
|
self.addLinkedRegion(reg);
|
self.stopLinkingMode();
|
}
|
},
|
|
validate() {
|
let ok = true;
|
|
self.traverseTree((node) => {
|
ok = node.validate?.();
|
if (ok === false) {
|
return TRAVERSE_STOP;
|
}
|
});
|
|
// should be true or false
|
return ok ?? true;
|
},
|
|
traverseTree(cb) {
|
return Tree.traverseTree(self.root, cb);
|
},
|
|
/**
|
*
|
*/
|
beforeSend() {
|
self.traverseTree((node) => {
|
node?.beforeSend?.();
|
});
|
|
self.stopLinkingMode();
|
self.unselectAll();
|
},
|
|
/**
|
* Delete region
|
* @param {*} region
|
*/
|
deleteRegion(region) {
|
if (region.isReadOnly()) return;
|
|
const { regions } = self.regionStore;
|
// move all children into the parent region of the given one
|
const children = regions.filter((r) => r.parentID === region.id);
|
|
if (children) {
|
for (const r of children) {
|
r.setParentID(region.parentID);
|
}
|
}
|
|
if (!region.classification) getEnv(self).events.invoke("entityDelete", region);
|
|
self.relationStore.deleteNodeRelation(region);
|
|
if (region.type === "polygonregion" || region.type === "vectorregion") {
|
detach(region);
|
}
|
|
destroy(region);
|
|
// If the annotation was in a drawing state and the user deletes it, we need to reset the drawing state
|
// to avoid the user being stuck in a drawing state
|
self.setIsDrawing(false);
|
},
|
|
deleteArea(area) {
|
destroy(area);
|
},
|
|
undo() {
|
const { history, regionStore } = self;
|
|
if (history?.canUndo) {
|
let stopDrawingAfterNextUndo = false;
|
const selectedIds = regionStore.selectedIds;
|
const currentRegion = regionStore.findRegion(
|
selectedIds[selectedIds.length - 1] ?? regionStore.regions[regionStore.regions.length - 1]?.id,
|
);
|
|
if (currentRegion?.type === "polygonregion") {
|
const points = currentRegion?.points?.length ?? 0;
|
|
stopDrawingAfterNextUndo = points <= 1;
|
} else if (currentRegion?.type === "vectorregion") {
|
const vertices = currentRegion?.vertices?.length ?? 0;
|
|
stopDrawingAfterNextUndo = vertices <= 1;
|
}
|
|
history.undo();
|
regionStore.selectRegionsByIds(selectedIds);
|
|
if (stopDrawingAfterNextUndo) {
|
currentRegion.setDrawing(false);
|
self.setIsDrawing(false);
|
}
|
}
|
},
|
|
redo() {
|
const { history, regionStore } = self;
|
|
if (history?.canRedo) {
|
const selectedIds = regionStore.selectedIds;
|
|
history.redo();
|
regionStore.selectRegionsByIds(selectedIds);
|
}
|
},
|
|
/**
|
* update some fragile parts after snapshot manipulations (undo/redo)
|
*
|
* @param {boolean} [force=true] force update will unselect all regions
|
*/
|
updateObjects(force = true) {
|
// Some async or lazy mode operations (ie. Images lazy load) need to reinitHistory without removing state selections
|
if (force) self.unselectAll();
|
|
self.names.forEach((tag) => tag.needsUpdate?.());
|
self.updateAppearenceFromState();
|
const areas = Array.from(self.areas.values());
|
// It should find just one unfinished region, but just in case we work with array
|
const filtered = areas.filter((area) => area.isDrawing);
|
|
// Update UI to reflect the state of an unfinished region in case if it exists
|
if (filtered.length) self.regionStore.selection._updateResultsFromRegions(filtered);
|
},
|
updateAppearenceFromState() {
|
self.areas.forEach((area) => area.updateAppearenceFromState?.());
|
},
|
|
setInitialValues() {
|
// <Label selected="true"/>
|
self.names.forEach((tag) => {
|
if (tag.type.endsWith("labels")) {
|
// @todo check for choice="multiple" and multiple preselected labels
|
const preselected = tag.children?.find((label) => label.initiallySelected);
|
|
if (preselected) preselected.setSelected(true);
|
}
|
});
|
|
// @todo deal with `defaultValue`s
|
},
|
|
setDefaultValues() {
|
self.names.forEach((tag) => {
|
if (["choices", "taxonomy"].includes(tag?.type) && tag.preselectedValues?.length) {
|
// <Choice selected="true"/>
|
self.createResult({}, { [tag?.type]: tag.preselectedValues }, tag, tag.toname);
|
}
|
});
|
},
|
|
addVersions(versions) {
|
self.versions = { ...self.versions, ...versions };
|
if (versions.draft) self.setDraftSelected();
|
},
|
|
toggleDraft(explicitValue) {
|
const isDraft = self.draftSelected;
|
const shouldSelectDraft = explicitValue ?? !isDraft;
|
|
// if explicitValue already achieved
|
if (shouldSelectDraft === isDraft) return;
|
// if there are no draft to switch to
|
if (shouldSelectDraft && !self.versions.draft) return;
|
|
// if there were some changes waiting they'll be saved
|
self.autosave.flush();
|
self.pauseAutosave();
|
|
// reinit annotation from required state
|
self.deleteAllRegions({ deleteReadOnly: true });
|
if (shouldSelectDraft) {
|
self.deserializeResults(self.versions.draft);
|
} else {
|
self.deserializeResults(self.versions.result);
|
}
|
self.draftSelected = shouldSelectDraft;
|
|
// reinit objects
|
self.updateObjects();
|
self.startAutosave();
|
},
|
|
startAutosave: flow(function* () {
|
if (!getEnv(self).events.hasEvent("submitDraft")) return;
|
// view all must never trigger autosave
|
if (self.isReadOnly()) return;
|
|
// some async tasks should be performed after deserialization
|
// so start autosave on next tick
|
yield delay(0);
|
|
if (self.autosave) {
|
self.autosave.cancel();
|
self.autosave.paused = false;
|
return;
|
}
|
|
// mobx will modify methods, so add it directly to have cancel() method
|
self.autosave = throttle(
|
() => {
|
// if autosave is paused, do nothing
|
if (self.autosave.paused) return;
|
|
self.saveDraft();
|
},
|
self.autosaveDelay,
|
{ leading: false },
|
);
|
|
onSnapshot(self.areas, self.autosave);
|
}),
|
|
async saveDraft(params) {
|
// There is no draft to save as it was already saved as an annotation
|
if (self.submissionStarted) return;
|
// if this is now a history item or prediction don't save it
|
if (!self.editable) return;
|
|
const result = self.serializeAnnotation({ fast: true });
|
// if this is new annotation and no regions added yet
|
|
if (!isFF(FF_LSDV_3009) && !self.pk && !result.length) return;
|
|
self.setDraftSelected();
|
self.versions.draft = result;
|
self.setDraftSaving(true);
|
return self.store.submitDraft(self, params).then((res) => {
|
self.onDraftSaved(res);
|
|
return res;
|
});
|
},
|
|
submissionInProgress() {
|
self.submissionStarted = Date.now();
|
},
|
|
saveDraftImmediately() {
|
if (self.autosave) self.autosave.flush();
|
},
|
|
async saveDraftImmediatelyWithResults(params) {
|
// There is no draft to save as it was already saved as an annotation
|
if (self.submissionStarted || self.isDraftSaving) return {};
|
self.setDraftSaving(true);
|
const res = await self.saveDraft(params);
|
|
return res;
|
},
|
|
pauseAutosave() {
|
if (!self.autosave) return;
|
self.autosave.paused = true;
|
self.autosave.cancel();
|
},
|
|
beforeDestroy() {
|
self.autosave?.cancel?.();
|
},
|
|
setDraftId(id) {
|
self.draftId = id;
|
},
|
|
setDraftSelected(selected = true) {
|
self.draftSelected = selected;
|
},
|
|
onDraftSaved() {
|
self.setDraftSaved(Utils.UDate.currentISODate());
|
self.setDraftSaving(false);
|
},
|
|
dropDraft() {
|
if (!self.autosave) return;
|
self.autosave.cancel();
|
self.draftId = 0;
|
self.draftSelected = false;
|
self.draftSaved = undefined;
|
self.versions.draft = undefined;
|
},
|
|
setDraftSaving(saving = false) {
|
self.isDraftSaving = saving;
|
},
|
|
setDraftSaved(date) {
|
self.draftSaved = date;
|
},
|
|
afterAttach() {
|
self.traverseTree((node) => {
|
// called when the annotation is attached to the main store,
|
// at this point the whole tree is available. This method
|
// may come handy when you have a tag that acts or depends
|
// on other elements in the tree.
|
if (node.annotationAttached) node.annotationAttached();
|
});
|
|
self.history.onUpdate(self.updateObjects);
|
self.startAutosave();
|
},
|
|
afterCreate() {
|
if (isFF(FF_DEV_3391)) {
|
const { names, toNames } = Tree.extractNames(self.root);
|
|
names.forEach((tag, name) => self.names.set(name, tag));
|
toNames.forEach((tags, name) => self.toNames.set(name, tags));
|
|
Tree.traverseTree(self.root, (node) => {
|
const id = node.id ?? node.name;
|
|
if (id) {
|
self.ids.set(Tree.cleanUpId(id), node);
|
}
|
|
if (self.store.task && node.updateValue) node.updateValue(self.store);
|
});
|
}
|
|
if (self.userGenerate && !self.sentUserGenerate) {
|
self.loadedDate = new Date();
|
}
|
},
|
|
setupHotKeys() {
|
hotkeys.unbindAll();
|
|
let audiosNum = 0;
|
let audioNode = null;
|
const mod = "shift+space";
|
let comb = mod;
|
|
// [TODO] we need to traverse this two times, fix
|
// Hotkeys setup
|
self.traverseTree((node) => {
|
if (node && node.onHotKey && node.hotkey) {
|
hotkeys.addKey(node.hotkey, node.onHotKey, undefined, node.hotkeyScope);
|
}
|
});
|
|
self.traverseTree((node) => {
|
// add Space hotkey for playbacks of audio, there might be
|
// multiple audios on the screen
|
if (node && !node.hotkey && (node.type === "audio" || node.type === "audioplus")) {
|
if (audiosNum > 0) comb = `${mod}+${audiosNum + 1}`;
|
else audioNode = node;
|
|
node.hotkey = comb;
|
hotkeys.addKey(comb, node.onHotKey, "Play an audio", Hotkey.ALL_SCOPES);
|
|
audiosNum++;
|
}
|
});
|
|
self.traverseTree((node) => {
|
/**
|
* Hotkey for controls
|
*/
|
if (node && node.onHotKey && !node.hotkey) {
|
const comb = hotkeys.makeComb();
|
|
if (!comb) return;
|
|
node.hotkey = comb;
|
hotkeys.addKey(node.hotkey, node.onHotKey);
|
}
|
});
|
|
if (audioNode && audiosNum > 1) {
|
audioNode.hotkey = `${mod}+1`;
|
hotkeys.addKey(audioNode.hotkey, audioNode.onHotKey);
|
hotkeys.removeKey(mod);
|
}
|
|
// prevent spacebar from scrolling
|
// document.onkeypress = function(e) {
|
// e = e || window.event;
|
|
// var charCode = e.keyCode || e.which;
|
// if (charCode === 32) {
|
// e.preventDefault();
|
// return false;
|
// }
|
// };
|
|
const { enableHotkeys } = self.store.settings;
|
Hotkey.setScope(enableHotkeys ? Hotkey.DEFAULT_SCOPE : "__none__");
|
},
|
|
createResult(areaValue, resultValue, control, object, skipAfrerCreate = false, additionalStates = []) {
|
// Without correct validation object may be null, but it it shouldn't be so in results - so we should find any
|
if (!object && control.type === "textarea") {
|
object = self.objects[0];
|
}
|
const objectTag = self.names.get(object.name ?? object);
|
|
const result = {
|
from_name: self.names.get(control.name),
|
// @todo should stick to area
|
to_name: objectTag,
|
type: control.resultType,
|
value: resultValue,
|
readonly: self.readonly,
|
};
|
|
const areaRaw = {
|
id: guidGenerator(),
|
object: objectTag,
|
// data for Model instance
|
...areaValue,
|
// for Model detection
|
value: areaValue,
|
results: [result],
|
};
|
|
// TODO: MST is crashing if we don't validate areas?, this problem isn't
|
// happening locally. So to reproduce you have to test in production or environment
|
const area = self?.areas?.put(areaRaw);
|
|
objectTag?.afterResultCreated?.(area);
|
|
if (!area) return;
|
|
if (ff.isActive(ff.FF_MULTIPLE_LABELS_REGIONS)) {
|
// Add additional states before any deselection happens
|
additionalStates.forEach((state) => {
|
area.setValue(state);
|
});
|
}
|
|
// This is added mostly for the reason of updating indexes in labels
|
// for the elements (like highlights in text) that won't be dynamically changed
|
// but are dependent on the whole region list values
|
self.updateAppearenceFromState();
|
|
if (!area.classification) getEnv(self).events.invoke("entityCreate", area);
|
if (!skipAfrerCreate) self.afterCreateResult(area, control);
|
|
return area;
|
},
|
|
afterCreateResult(area, control) {
|
if (self.store.settings.selectAfterCreate) {
|
if (!area.classification) {
|
// some regions might need some actions right after creation (i.e. text)
|
// and some may be already deleted (i.e. bboxes)
|
setTimeout(() => isAlive(area) && self.selectArea(area));
|
}
|
} else {
|
// unselect labeling tools after use, but consider "keep labels selected" settings
|
if (control.isLabeling) self.unselectAll(true);
|
}
|
},
|
|
appendResults(results) {
|
if (!self.editable || self.readonly) return;
|
|
const regionIdMap = {};
|
const prevSize = self.regionStore.regions.length;
|
|
// Generate new ids to prevent collisions
|
for (const result of results) {
|
const regionId = result.id;
|
|
if (!regionIdMap[regionId]) {
|
regionIdMap[regionId] = guidGenerator();
|
}
|
result.id = regionIdMap[regionId];
|
}
|
|
self.deserializeResults(results);
|
self.updateObjects();
|
return self.regionStore.regions.slice(prevSize);
|
},
|
|
serializeAnnotation(options) {
|
// return self.serialized;
|
|
document.body.style.cursor = "wait";
|
|
const result = self.results
|
.map((r) => r.serialize(options))
|
.filter(Boolean)
|
.concat(self.relationStore.serialize(options));
|
|
document.body.style.cursor = "default";
|
|
return result;
|
},
|
|
// Some annotations may be created with wrong assumptions
|
// And this problems are fixable, so better to fix them on start
|
fixBrokenAnnotation(json) {
|
return (json ?? []).reduce((res, objRaw) => {
|
if (!objRaw) return res;
|
|
const obj = structuredClone(objRaw) ?? {};
|
|
if (obj.type === "relation") {
|
res.push(objRaw);
|
return res;
|
}
|
|
if (obj.type === "htmllabels") obj.type = "hypertextlabels";
|
if (obj.normalization) obj.meta = { ...obj.meta, text: [obj.normalization] };
|
const tagNames = self.names;
|
|
// Clear non-existent labels
|
if (obj.type.endsWith("labels")) {
|
const keys = Object.keys(obj.value);
|
|
for (const key of keys) {
|
if (key.endsWith("labels")) {
|
// detect most relevant label tags if that one from from_name is missing
|
// can be useful for predictions in old format with config in new format:
|
// Rectangle + Labels -> RectangleLabels
|
if (!tagNames.has(obj.from_name) || (!obj.value[key].length && !tagNames.get(obj.from_name).allowempty)) {
|
delete obj.value[key];
|
if (tagNames.has(obj.to_name)) {
|
// Redirect references to existent tool
|
const targetObject = tagNames.get(obj.to_name);
|
// @todo Video tag returns only `*labels` so maybe we have to add this check here
|
const states = self.toNames.get(targetObject.name);
|
|
if (states?.length) {
|
const altToolsControllerType = obj.type.replace(/labels$/, "");
|
const sameLabelsType = obj.type;
|
const simpleLabelsType = "labels";
|
|
for (const altType of [altToolsControllerType, sameLabelsType, simpleLabelsType]) {
|
const state = states.find((state) => state.type === altType);
|
|
if (state) {
|
obj.type = altType;
|
obj.from_name = state.name;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
if (tagNames.has(obj.from_name) && tagNames.has(obj.to_name)) {
|
res.push(obj);
|
}
|
|
// Insert image dimensions from result
|
(() => {
|
if (!isDefined(obj.original_width)) return;
|
if (!tagNames.has(obj.to_name)) return;
|
|
const tag = tagNames.get(obj.to_name);
|
|
if (tag.type !== "image") return;
|
|
const imageEntity = tag.findImageEntity(obj.item_index ?? 0);
|
|
if (!imageEntity || imageEntity.imageLoaded) return;
|
|
imageEntity.setNaturalWidth(obj.original_width);
|
imageEntity.setNaturalHeight(obj.original_height);
|
})();
|
|
return res;
|
}, []);
|
},
|
|
setSuggestions(rawSuggestions) {
|
const { history } = self;
|
|
self.suggestions.clear();
|
|
if (!rawSuggestions) return;
|
self.deserializeResults(rawSuggestions, {
|
suggestions: true,
|
});
|
|
self.isSuggestionsAccepting = true;
|
if (getRoot(self).autoAcceptSuggestions) {
|
if (isFF(FF_DEV_1284)) {
|
self.history.setReplaceNextUndoState(true);
|
}
|
self.acceptAllSuggestions();
|
} else {
|
self.suggestions.forEach((suggestion) => {
|
// regions that can't be accepted in usual way, should be auto-accepted;
|
const supportSuggestions = suggestion.supportSuggestions;
|
|
// If we cannot display suggestions on object/control then just accept them
|
if (!supportSuggestions) {
|
self.acceptSuggestion(suggestion.id);
|
if (isFF(FF_DEV_1284)) {
|
// This is necessary to prevent the occurrence of new steps in the history after updating objects at the end of current method
|
history.setReplaceNextUndoState(true);
|
}
|
}
|
});
|
}
|
self.isSuggestionsAccepting = false;
|
|
if (!isFF(FF_DEV_1284)) {
|
history.freeze("richtext:suggestions");
|
}
|
self.names.forEach((tag) => tag.needsUpdate?.({ suggestions: true }));
|
if (!isFF(FF_DEV_1284)) {
|
history.setReplaceNextUndoState(true);
|
history.unfreeze("richtext:suggestions");
|
}
|
},
|
|
cleanClassificationAreas() {
|
const classificationAreasByControlName = {};
|
const duplicateAreaIds = [];
|
|
self.areas.forEach((a) => {
|
const controlName = a.results[0].from_name.name;
|
// May be null but null is also valid key in this case
|
const itemIndex = a.item_index;
|
|
if (a.classification) {
|
if (classificationAreasByControlName[controlName]?.[itemIndex]) {
|
duplicateAreaIds.push(classificationAreasByControlName[controlName][itemIndex]);
|
}
|
classificationAreasByControlName[controlName] = classificationAreasByControlName[controlName] || {};
|
classificationAreasByControlName[controlName][itemIndex] = a.id;
|
}
|
});
|
for (const id of duplicateAreaIds) {
|
self.areas.delete(id);
|
}
|
},
|
|
/**
|
* Deserialize results
|
* @param {string | Array<any>} json Input results
|
* @param {{
|
* suggestions: boolean
|
* }} options Deserialization options
|
*/
|
deserializeResults(json, { suggestions = false, hidden = false } = {}) {
|
try {
|
const objAnnotation = self.prepareAnnotation(json);
|
const areas = suggestions ? self.suggestions : self.areas;
|
|
self._initialAnnotationObj = objAnnotation;
|
|
for (const obj of objAnnotation) {
|
self.deserializeSingleResult(
|
obj,
|
(id) => areas.get(id),
|
(snapshot) => areas.put(snapshot),
|
);
|
}
|
|
// It's not necessary, but it's calmer with this
|
self.cleanClassificationAreas();
|
|
if (!hidden) {
|
for (const r of self.results) {
|
if (r.area.classification) {
|
r.from_name.updateFromResult?.(r.mainValue);
|
}
|
}
|
}
|
|
for (const obj of objAnnotation) {
|
if (obj.type === "relation") {
|
self.relationStore.deserializeRelation(
|
`${obj.from_id}#${self.id}`,
|
`${obj.to_id}#${self.id}`,
|
obj.direction,
|
obj.labels,
|
);
|
}
|
}
|
} catch (e) {
|
console.error(e);
|
self.list.addErrors([errorBuilder.generalError(e)]);
|
}
|
},
|
|
deserializeAnnotation(...args) {
|
console.warn("deserializeAnnotation() is deprecated. Use deserializeResults() instead");
|
return self.deserializeResults(...args);
|
},
|
|
prepareAnnotation(rawAnnotation) {
|
let objAnnotation = rawAnnotation;
|
|
if (typeof objAnnotation !== "object") {
|
objAnnotation = JSON.parse(objAnnotation);
|
}
|
|
objAnnotation = self.fixBrokenAnnotation(objAnnotation ?? []);
|
|
return objAnnotation;
|
},
|
|
deserializeSingleResult(obj, getArea, createArea) {
|
if (obj.type !== "relation") {
|
const { id, value: rawValue, type, ...data } = obj;
|
let { from_name, to_name } = data;
|
|
const object = self.names.get(data.to_name) ?? {};
|
const tagType = object.type;
|
|
// avoid duplicates of the same areas in different annotations/predictions
|
const areaId = `${id || guidGenerator()}#${self.id}`;
|
const resultId = `${data.from_name}@${areaId}`;
|
const value = self.prepareValue(rawValue, tagType);
|
|
if (isFF(FF_DEV_3391)) {
|
to_name = `${to_name}@${self.id}`;
|
from_name = `${from_name}@${self.id}`;
|
}
|
|
let area = getArea(areaId);
|
|
if (!area) {
|
const areaSnapshot = {
|
id: areaId,
|
object: to_name,
|
...data,
|
// We need to omit value properties due to there may be conflicting property types, for example a text.
|
// if we don't it can create a classification instead of proper area
|
/** @see `omitValueFields` */
|
...omitValueFields(value),
|
value,
|
};
|
|
area = createArea(areaSnapshot);
|
|
if (isFF(FF_LSDV_4583)) {
|
// store copy of the original result inside the area
|
// useful when you need to serialize a result without
|
// updating it from current/actual data
|
// For safety reasons this object is always readonly
|
Object.defineProperty(area, "_rawResult", {
|
value: Object.freeze(structuredClone(obj)),
|
});
|
}
|
}
|
|
const newResult = { ...data, id: resultId, type, value, from_name, to_name };
|
|
area.addResult(newResult);
|
// apply additional data, that were skipped in favour of region type detection
|
area.applyAdditionalDataFromResult?.(newResult);
|
|
// if there is merged result with region data and type and also with the labels
|
// and object allows such merge — create new result with these labels
|
if (!type.endsWith("labels") && value.labels && object.mergeLabelsAndResults) {
|
const labels = value.labels;
|
const controls = self.toNames.get(object.name).filter((s) => s.type.endsWith("labels"));
|
const labelControl = controls.find((control) => control?.findLabel(labels[0]));
|
|
if (labelControl) {
|
area.setValue(labelControl);
|
area.results.find((r) => r.type.endsWith("labels"))?.setValue(labels);
|
}
|
}
|
}
|
},
|
|
prepareValue(value, type) {
|
switch (type) {
|
case "text":
|
case "hypertext":
|
case "richtext": {
|
const hasStartEnd = isDefined(value.start) && isDefined(value.end);
|
const lacksOffsets = !isDefined(value.startOffset) && !isDefined(value.endOffset);
|
|
// @todo move this Text regions offsets transform to RichTextRegion
|
if (hasStartEnd && lacksOffsets) {
|
return Object.assign({}, value, {
|
start: "",
|
end: "",
|
startOffset: Number(value.start),
|
endOffset: Number(value.end),
|
isText: true,
|
});
|
}
|
break;
|
}
|
default:
|
return value;
|
}
|
|
return value;
|
},
|
|
acceptAllSuggestions() {
|
for (const id of self.suggestions.keys()) {
|
self.acceptSuggestion(id);
|
}
|
self.deleteAllDynamicregions(isFF(FF_DEV_1284));
|
},
|
|
rejectAllSuggestions() {
|
for (const id of self.suggestions.keys()) {
|
self.suggestions.delete(id);
|
}
|
self.deleteAllDynamicregions(isFF(FF_DEV_1284));
|
},
|
|
deleteAllDynamicregions(silent = false) {
|
for (const r of self.regions) {
|
if (r.dynamic) {
|
if (silent) {
|
// dirty hack to prevent sending regionFinishedDrawing notification
|
r.setDrawing(true);
|
}
|
r.deleteRegion();
|
}
|
}
|
},
|
|
acceptSuggestion(id) {
|
const item = self.suggestions.get(id);
|
let itemId = id;
|
const isGlobalClassification = item.classification;
|
|
// this piece of code prevents from creating duplicated global classifications
|
if (isFF(FF_LLM_EPIC)) {
|
if (isGlobalClassification) {
|
const itemResult = item.results[0];
|
const areasIterator = self.areas.values();
|
|
for (const area of areasIterator) {
|
const areaResult = area.results[0];
|
const isFound =
|
areaResult.from_name === itemResult.from_name &&
|
areaResult.to_name === itemResult.to_name &&
|
areaResult.item_index === itemResult.item_index;
|
|
if (isFound) {
|
itemId = area.id;
|
break;
|
}
|
}
|
} else {
|
// @todo: there is a strange behaviour that should be documented somewhere
|
// On serialization we use area id as result id to save it somewhere
|
// and on deserialization we use result id as area id
|
// but when we use suggestions we should keep in mind that we need to do it manually or use serialized data instead
|
// or we can get weird regions duplication in some cases
|
const area = self.areas.get(item.cleanId);
|
|
if (area) {
|
itemId = area.id;
|
}
|
}
|
}
|
|
self.areas.set(itemId, {
|
...item.toJSON(),
|
id: itemId,
|
fromSuggestion: true,
|
});
|
const area = self.areas.get(itemId);
|
const activeStates = area.object.activeStates();
|
|
for (const state of activeStates) {
|
area.setValue(state);
|
}
|
self.suggestions.delete(id);
|
},
|
|
rejectSuggestion(id) {
|
self.suggestions.delete(id);
|
},
|
|
resetReady() {
|
self.objects.forEach((object) => object.setReady?.(false));
|
self.areas.forEach((area) => area.setReady?.(false));
|
},
|
}));
|
|
export const Annotation = types.compose("Annotation", LinkingModes, _Annotation);
|
