import { getParent, getRoot, getSnapshot, types } from "mobx-state-tree";
|
import { ff } from "@humansignal/core";
|
import { guidGenerator } from "../core/Helpers";
|
import Registry from "../core/Registry";
|
import Tree from "../core/Tree";
|
import { AnnotationMixin } from "../mixins/AnnotationMixin";
|
import { isDefined } from "../utils/utilities";
|
import { FF_LSDV_4583, isFF } from "../utils/feature-flags";
|
|
const resultTypes = [
|
"labels",
|
"hypertextlabels",
|
"paragraphlabels",
|
"rectangle",
|
"keypoint",
|
"polygon",
|
"brush",
|
"bitmask",
|
"ellipse",
|
"magicwand",
|
"rectanglelabels",
|
"keypointlabels",
|
"polygonlabels",
|
"vector",
|
"vectorlabels",
|
"brushlabels",
|
"bitmasklabels",
|
"ellipselabels",
|
"timeserieslabels",
|
"timelinelabels",
|
"choices",
|
"datetime",
|
"number",
|
"taxonomy",
|
"textarea",
|
"rating",
|
"pairwise",
|
"videorectangle",
|
"ranker",
|
"custominterface",
|
];
|
|
const resultValues = {
|
ranker: types.union(types.array(types.string), types.frozen(), types.null),
|
datetime: types.maybe(types.string),
|
number: types.maybe(types.number),
|
rating: types.maybe(types.number),
|
item_index: types.maybeNull(types.number),
|
text: types.maybe(types.union(types.string, types.array(types.string))),
|
choices: types.maybe(types.array(types.union(types.string, types.array(types.string)))),
|
// pairwise
|
selected: types.maybe(types.enumeration(["left", "right"])),
|
// @todo all other *labels
|
labels: types.maybe(types.array(types.string)),
|
htmllabels: types.maybe(types.array(types.string)),
|
hypertextlabels: types.maybe(types.array(types.string)),
|
paragraphlabels: types.maybe(types.array(types.string)),
|
rectanglelabels: types.maybe(types.array(types.string)),
|
keypointlabels: types.maybe(types.array(types.string)),
|
polygonlabels: types.maybe(types.array(types.string)),
|
vectorlabels: types.maybe(types.array(types.string)),
|
ellipselabels: types.maybe(types.array(types.string)),
|
brushlabels: types.maybe(types.array(types.string)),
|
timeserieslabels: types.maybe(types.array(types.string)),
|
timelinelabels: types.maybe(types.array(types.string)), // new one
|
bitmasklabels: types.maybe(types.array(types.string)),
|
taxonomy: types.frozen(), // array of arrays of strings
|
sequence: types.frozen(),
|
custom: types.maybe(types.frozen()), // for CustomInterface regions
|
};
|
|
const Result = types
|
.model("Result", {
|
id: types.optional(types.identifier, guidGenerator),
|
// pid: types.optional(types.string, guidGenerator),
|
|
score: types.maybeNull(types.number),
|
// @todo to readonly mixin
|
readonly: types.optional(types.boolean, false),
|
|
// @why?
|
// hidden: types.optional(types.boolean, false),
|
|
// @todo to mixins
|
// selected: types.optional(types.boolean, false),
|
// highlighted: types.optional(types.boolean, false),
|
|
// @todo pid?
|
// parentID: types.optional(types.string, ""),
|
|
// KonvaRegion, TextRegion, HyperTextRegion, AudioRegion)),
|
// optional for classifications
|
// labeling/control tag
|
from_name: types.late(() => types.reference(types.union(...Registry.modelsArr()))),
|
// object tag
|
to_name: types.late(() => types.reference(types.union(...Registry.objectTypes()))),
|
// @todo some general type, maybe just a `string`
|
type: ff.isActive(ff.FF_CUSTOM_TAGS)
|
? types.late(() =>
|
types.enumeration([
|
...resultTypes,
|
...Registry.customTags.filter((t) => t.resultName).map((t) => t.resultName),
|
]),
|
)
|
: types.enumeration([...resultTypes]),
|
// @todo much better to have just a value, not a hash with empty fields
|
value: ff.isActive(ff.FF_CUSTOM_TAGS)
|
? types.late(() =>
|
types.model({
|
...resultValues,
|
...Object.fromEntries(
|
Registry.customTags.filter((t) => t.resultName).map((t) => [t.resultName, types.maybe(t.result)]),
|
),
|
}),
|
)
|
: types.model({
|
...resultValues,
|
}),
|
// info about object and region
|
meta: types.frozen(),
|
})
|
.views((self) => ({
|
get perRegionStates() {
|
const states = self.states;
|
|
return states && states.filter((s) => s.perregion === true);
|
},
|
|
get store() {
|
return getRoot(self);
|
},
|
|
get area() {
|
return getParent(self, 2);
|
},
|
|
get mainValue() {
|
return self.value[self.from_name.valueType];
|
},
|
|
mergeMainValue(value) {
|
value = value?.toJSON ? value.toJSON() : value;
|
const mainValue = self.mainValue?.toJSON?.() ? self.mainValue?.toJSON?.() : self.mainValue;
|
|
if (typeof value !== typeof mainValue) return null;
|
if (self.type.endsWith("labels")) {
|
return value.filter((x) => mainValue.includes(x));
|
}
|
return value === mainValue ? value : null;
|
},
|
|
get hasValue() {
|
const value = self.mainValue;
|
|
if (!isDefined(value)) return false;
|
if (Array.isArray(value)) return value.length > 0;
|
return true;
|
},
|
|
get editable() {
|
throw new Error("Not implemented");
|
},
|
|
isReadOnly() {
|
return self.readonly || self.area.isReadOnly();
|
},
|
|
isSelfReadOnly() {
|
return self.readonly;
|
},
|
|
getSelectedString(joinstr = " ") {
|
return self.mainValue?.join(joinstr) || "";
|
},
|
|
// @todo check all usages of selectedLabels:
|
// — check usages of non-array values (like `if selectedValues ...`)
|
// - check empty labels, they should be returned as an array
|
get selectedLabels() {
|
if (self.mainValue?.length === 0 && self.from_name.allowempty) {
|
return self.from_name.findLabel(null);
|
}
|
return self.mainValue?.map((value) => self.from_name.findLabel(value)).filter(Boolean) ?? [];
|
},
|
|
/**
|
* Checks perRegion and Visibility params
|
*/
|
get canBeSubmitted() {
|
const control = self.from_name;
|
|
// Find the first node moving up in the tree with the given visibleWhen value
|
function findParentWithVisibleWhen(control, visibleWhen) {
|
let currentControl = control;
|
|
while (currentControl) {
|
if (currentControl.visiblewhen === visibleWhen) return currentControl;
|
|
try {
|
currentControl = getParent(currentControl);
|
if (!currentControl) break;
|
} catch {
|
break;
|
}
|
}
|
|
return null;
|
}
|
|
if (control.perregion) {
|
const label = control.whenlabelvalue;
|
|
if (label && !self.area.hasLabel(label)) return false;
|
}
|
|
// picks leaf's (last item in a path) value for Taxonomy or usual Choice value for Choices
|
const innerResults = (r) => r.map((s) => (Array.isArray(s) ? s.at(-1) : s));
|
|
const isChoiceSelected = () => {
|
const tagName = control.whentagname;
|
const choiceValues = control.whenchoicevalue?.split(",") ?? null;
|
const results = self.annotation.results.filter((r) => ["choices", "taxonomy"].includes(r.type) && r !== self);
|
|
if (tagName) {
|
const result = results.find((r) => {
|
if (r.from_name.name !== tagName) return false;
|
// for perRegion choices we should check that they are in the same area
|
return !r.from_name.perregion || r.area === self.area;
|
});
|
|
if (!result) return false;
|
if (
|
choiceValues &&
|
!choiceValues.some((v) =>
|
innerResults(result.mainValue).some((vv) => result.from_name.selectedChoicesMatch(v, vv)),
|
)
|
)
|
return false;
|
} else {
|
if (!results.length) return false;
|
// if no given choice value is selected in any choice result
|
if (
|
choiceValues &&
|
!results.some((r) =>
|
choiceValues.some((v) => innerResults(r.mainValue).some((vv) => r.from_name.selectedChoicesMatch(v, vv))),
|
)
|
)
|
return false;
|
}
|
return true;
|
};
|
|
// When perregion is used, we must ignore the visibility of the components and focus only on the selection
|
if (control.perregion && control.visiblewhen === "choice-selected") {
|
return isChoiceSelected();
|
}
|
|
if (control.visiblewhen === "choice-unselected") {
|
return !isChoiceSelected();
|
}
|
|
// We need to check if there is any node up in the tree with visibility restrictions so we can determine
|
// if the element is selected considering its own visibility
|
if (!control.perregion && findParentWithVisibleWhen(control, "choice-selected")) {
|
return control.isVisible === false ? false : isChoiceSelected();
|
}
|
|
return true;
|
},
|
|
get tag() {
|
const value = self.mainValue;
|
|
if (!value || !value.length) return null;
|
if (!self.from_name.findLabel) return null;
|
return self.from_name.findLabel(value[0]);
|
},
|
|
get style() {
|
if (!self.tag) return null;
|
const fillcolor = self.tag.background || self.tag.parent?.fillcolor;
|
|
if (!fillcolor) return null;
|
const strokecolor = self.tag.background || self.tag.parent.strokecolor;
|
const { strokewidth, fillopacity, opacity } = self.tag.parent;
|
|
return { strokecolor, strokewidth, fillcolor, fillopacity, opacity };
|
},
|
|
get emptyStyle() {
|
const emptyLabel = self.from_name.emptyLabel;
|
|
if (!emptyLabel) return null;
|
const fillcolor = emptyLabel.background || emptyLabel.parent.fillcolor;
|
|
if (!fillcolor) return null;
|
const strokecolor = emptyLabel.background || emptyLabel.parent.strokecolor;
|
const { strokewidth, fillopacity, opacity } = emptyLabel.parent;
|
|
return { strokecolor, strokewidth, fillcolor, fillopacity, opacity };
|
},
|
|
get controlStyle() {
|
if (!self.from_name) return null;
|
|
const { fillcolor, strokecolor, strokewidth, fillopacity, opacity } = self.from_name;
|
|
return { strokecolor, strokewidth, fillcolor, fillopacity, opacity };
|
},
|
|
/**
|
* This name historically is used for the region elements for getting their bboxes.
|
* Now we need it for a result also.
|
* Let's say "Region" here means just an area on the screen.
|
* So that it's an element through which we can get the bbox for an area where classification takes place.
|
*/
|
getRegionElement() {
|
return self.from_name?.getRegionElement?.();
|
},
|
}))
|
.volatile(() => ({
|
pid: "",
|
selected: false,
|
// highlighted: types.optional(types.boolean, false),
|
}))
|
.actions((self) => ({
|
setValue(value) {
|
self.value[self.from_name.valueType] = value;
|
},
|
|
afterCreate() {
|
self.pid = self.id;
|
},
|
|
afterAttach() {
|
// const tag = self.from_name;
|
// update state of classification tags
|
// @todo unify this with `selectArea`
|
},
|
|
setParentID(id) {
|
self.parentID = id;
|
},
|
|
setMetaValue(key, value) {
|
self.meta = { ...self.meta, [key]: value };
|
},
|
|
// 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(options) {
|
const sn = getSnapshot(self);
|
const { type, score, value, meta } = sn;
|
const { valueType } = self.from_name;
|
const data = self.area ? self.area.serialize(options) : {};
|
// cut off annotation id
|
const id = self.area?.cleanId;
|
const from_name = Tree.cleanUpId(sn.from_name);
|
const to_name = Tree.cleanUpId(sn.to_name);
|
|
if (!data) return null;
|
if (!self.canBeSubmitted) return null;
|
|
if (!isDefined(data.value)) data.value = {};
|
// with `mergeLabelsAndResults` control uses only one result even with external `Labels`
|
if (self.to_name.mergeLabelsAndResults) {
|
// we are in labeling result, so skipping it, labels will be added to the main result
|
if (type === "labels") return null;
|
// add labels to the main result, not nested ones
|
// if this is specialized labels, then labels will be already part of it, so skipping it
|
if (!type.endsWith("labels") && self.area?.labels?.length && !self.from_name.perregion) {
|
data.value.labels = self.area.labels;
|
}
|
}
|
|
if (meta || (self.area.meta && Object.keys(self.area.meta).length)) {
|
// `meta` is used for lead_time which is stored in one result, while area's `meta` is used for meta text,
|
// and this text is duplicated in every connected result, so we should prefer area's `meta` for actual value.
|
data.meta = { ...meta, ...self.area.meta };
|
}
|
|
if (self.area.parentID) {
|
data.parentID = self.area.parentID.replace(/#.*/, "");
|
}
|
|
Object.assign(data, { id, from_name, to_name, type, origin: self.area.origin });
|
|
if (isDefined(value[valueType])) {
|
Object.assign(data.value, { [valueType]: value[valueType] });
|
}
|
|
if (typeof score === "number") data.score = score;
|
|
if (self.isSelfReadOnly()) data.readonly = true;
|
|
if (isFF(FF_LSDV_4583) && isDefined(self.area.item_index)) {
|
data.item_index = self.area.item_index;
|
}
|
|
return data;
|
},
|
|
setHighlight(val) {
|
self._highlighted = val;
|
},
|
|
toggleHighlight() {
|
self.setHighlight(!self._highlighted);
|
},
|
|
toggleHidden() {
|
self.hidden = !self.hidden;
|
},
|
}));
|
|
export default types.compose("Result", Result, AnnotationMixin);
|
