import { getEnv, getParent, getRoot, getType, types } from "mobx-state-tree";
|
import { guidGenerator } from "../core/Helpers";
|
import { isDefined } from "../utils/utilities";
|
import { AnnotationMixin } from "./AnnotationMixin";
|
import { ReadOnlyRegionMixin } from "./ReadOnlyMixin";
|
import { RELATIVE_STAGE_HEIGHT, RELATIVE_STAGE_WIDTH } from "../components/ImageView/Image";
|
|
const RegionsMixin = types
|
.model({
|
// id: types.optional(types.identifier, guidGenerator),
|
pid: types.optional(types.string, guidGenerator),
|
|
score: types.maybeNull(types.number),
|
|
filtered: types.optional(types.boolean, false),
|
|
parentID: types.optional(types.string, ""),
|
|
fromSuggestion: false,
|
|
// Dynamic preannotations enabled
|
dynamic: false,
|
|
origin: types.optional(types.enumeration(["prediction", "prediction-changed", "manual"]), "manual"),
|
|
item_index: types.maybeNull(types.number),
|
})
|
.volatile(() => ({
|
// selected: false,
|
_highlighted: false,
|
hidden: false,
|
locked: false,
|
isDrawing: false,
|
perRegionFocusRequest: null,
|
shapeRef: null,
|
drawingTimeout: null,
|
hideable: true,
|
}))
|
.views((self) => ({
|
get perRegionStates() {
|
const states = self.states;
|
|
return states && states.filter((s) => s.perregion === true);
|
},
|
|
get store() {
|
return getRoot(self);
|
},
|
|
get parent() {
|
return getParent(self);
|
},
|
|
get editable() {
|
throw new Error("Not implemented");
|
},
|
|
get isCompleted() {
|
return !self.isDrawing;
|
},
|
|
get highlighted() {
|
return self._highlighted;
|
},
|
|
get inSelection() {
|
return self.annotation?.regionStore.isSelected(self);
|
},
|
|
get isReady() {
|
return true;
|
},
|
|
get currentImageEntity() {
|
return self.parent.findImageEntity(self.item_index ?? 0);
|
},
|
|
getConnectedDynamicRegions(excludeSelf) {
|
const { regions = [] } = getRoot(self).annotationStore?.selected || {};
|
const { type, labelName } = self;
|
|
const result = regions.filter((region) => {
|
if (excludeSelf && region === self) return false;
|
const canBePartOfNotification = self.supportSuggestions ? self.dynamic : true;
|
|
return (
|
canBePartOfNotification &&
|
region.type === type &&
|
region.labelName === labelName &&
|
region.results?.[0]?.to_name === self.results?.[0]?.to_name
|
);
|
});
|
|
return result;
|
},
|
|
// Indicates that it is not temporary region created just to display data like Textarea's one
|
// and is not a suggestion
|
get isRealRegion() {
|
return self.annotation?.areas?.has(self.id);
|
},
|
|
get shouldNotifyDrawingFinished() {
|
// extra calls on destroying will be skipped
|
// @see beforeDestroy action
|
if (!self.isRealRegion) return false;
|
if (self.annotation.isSuggestionsAccepting) return false;
|
// There are two modes:
|
// If object tag support suggestions - the region should be marked as a dynamic one to make notifications
|
// If object tag doesn't support suggestions - every region works as dynamic with auto suggestions
|
const canBeReasonOfNotification = self.supportSuggestions ? self.dynamic && !self.fromSuggestion : true;
|
|
const isSmartEnabled = self.results.some((r) => r.from_name.smartEnabled);
|
|
return isSmartEnabled && canBeReasonOfNotification;
|
},
|
}))
|
.actions((self) => {
|
return {
|
setParentID(id) {
|
self.parentID = id;
|
},
|
|
setDrawing(val) {
|
self.isDrawing = val;
|
},
|
|
setShapeRef(ref) {
|
if (!ref) return;
|
self.shapeRef = ref;
|
},
|
|
setItemIndex(index) {
|
if (!isDefined(index)) throw new Error("Index must be provided for", self);
|
self.item_index = index;
|
},
|
|
beforeDestroy() {
|
// beforeDestroy may be called by accident for Textarea and etc. as part of updateObjects action
|
// in that case the region already has no results
|
|
// The other bad behaviour is that beforeDestroy may be called on accepting suggestions 'cause they are deleting in that case
|
|
// So if you see this bad thing during debugging - now you know why
|
// and why we need this check
|
if (self.isRealRegion) {
|
return self.beforeDestroyArea();
|
}
|
},
|
|
beforeDestroyArea() {
|
self.notifyDrawingFinished({ destroy: true });
|
},
|
|
setLocked(locked) {
|
if (locked instanceof Function) {
|
self.locked = locked(self.locked);
|
} else {
|
self.locked = locked;
|
}
|
},
|
|
makeDynamic() {
|
self.dynamic = true;
|
},
|
|
// @todo this conversion methods should be removed after removing FF_DEV_3793
|
convertXToPerc(x) {
|
return (x * RELATIVE_STAGE_WIDTH) / self.currentImageEntity.stageWidth;
|
},
|
|
convertYToPerc(y) {
|
return (y * RELATIVE_STAGE_HEIGHT) / self.currentImageEntity.stageHeight;
|
},
|
|
convertHDimensionToPerc(hd) {
|
return (hd * (self.scaleX || 1) * RELATIVE_STAGE_WIDTH) / self.currentImageEntity.stageWidth;
|
},
|
|
convertVDimensionToPerc(vd) {
|
return (vd * (self.scaleY || 1) * RELATIVE_STAGE_HEIGHT) / self.currentImageEntity.stageHeight;
|
},
|
|
// update region appearence based on it's current states, for
|
// example bbox needs to update its colors when you change the
|
// label, becuase it takes color from the label
|
updateAppearenceFromState() {},
|
|
serialize() {
|
console.error("Region class needs to implement serialize");
|
},
|
|
/** @abstract */
|
selectRegion() {},
|
|
/** @abstract */
|
afterUnselectRegion() {},
|
|
onClickRegion(ev) {
|
const annotation = self.annotation;
|
|
if (!self.isReadOnly() && (self.isDrawing || annotation.isDrawing)) return;
|
|
if (!self.isReadOnly() && annotation.isLinkingMode) {
|
annotation.addLinkedRegion(self);
|
annotation.stopLinkingMode();
|
annotation.regionStore.unselectAll();
|
} else {
|
self._selectArea(ev?.ctrlKey || ev?.metaKey);
|
}
|
},
|
|
_selectArea(additiveMode = false) {
|
this.cancelPerRegionFocus();
|
const annotation = self.annotation;
|
|
if (additiveMode) {
|
annotation.toggleRegionSelection(self);
|
} else {
|
const wasNotSelected = !self.selected;
|
|
if (wasNotSelected) {
|
annotation.selectArea(self);
|
} else {
|
annotation.unselectAll();
|
}
|
}
|
},
|
|
requestPerRegionFocus() {
|
self.perRegionFocusRequest = Date.now();
|
},
|
|
cancelPerRegionFocus() {
|
self.perRegionFocusRequest = null;
|
},
|
|
setHighlight(val) {
|
self._highlighted = val;
|
},
|
|
toggleHighlight() {
|
self.setHighlight(!self._highlighted);
|
},
|
|
toggleFiltered(e) {
|
self.filtered = !self.filtered;
|
self.toggleHidden(e, true);
|
e && e.stopPropagation();
|
},
|
|
toggleHidden(e, isFiltered = false) {
|
if (!isFiltered) self.filtered = false;
|
self.hidden = !self.hidden;
|
e && e.stopPropagation();
|
},
|
|
updateOriginOnEdit() {
|
if (self.origin === "prediction") {
|
self.origin = "prediction-changed";
|
}
|
},
|
|
notifyDrawingFinished({ destroy = false } = {}) {
|
self.updateOriginOnEdit();
|
|
// everything below is related to dynamic preannotations
|
if (!self.shouldNotifyDrawingFinished) return;
|
|
clearTimeout(self.drawingTimeout);
|
|
if (self.isDrawing === false) {
|
const timeout = getType(self).name.match(/brush/i) ? 1200 : 0;
|
const env = getEnv(self);
|
|
self.drawingTimeout = setTimeout(() => {
|
const connectedRegions = self.getConnectedDynamicRegions(destroy);
|
|
env.events.invoke("regionFinishedDrawing", self, connectedRegions);
|
}, timeout);
|
}
|
},
|
};
|
});
|
|
export default types.compose(RegionsMixin, ReadOnlyRegionMixin, AnnotationMixin);
|
