@searpent/react-image-annotate 2.0.77 → 2.0.78

package/Annotator/reducers/general-reducer.js

@@ -0,0 +1,1430 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread";
+import { moveRegion } from "../../ImageCanvas/region-tools.js";
+import { getIn, setIn, updateIn } from "seamless-immutable";
+import moment from "moment";
+import isEqual from "lodash/isEqual";
+import uniq from "lodash/uniq";
+import getActiveImage from "./get-active-image";
+import { saveToHistory } from "./history-handler.js";
+import colors from "../../colors";
+import fixTwisted from "./fix-twisted";
+import convertExpandingLineToPolygon from "./convert-expanding-line-to-polygon";
+import clamp from "clamp";
+import getLandmarksWithTransform from "../../utils/get-landmarks-with-transform";
+import setInLocalStorage from "../../utils/set-in-local-storage";
+import onlyUnique from "../../utils/filter-only-unique";
+import nextGroupId from "../../utils/next-group-id";
+import defaultLockedUntil from "../../utils/default-locked-until";
+
+var getRandomId = function getRandomId() {
+  return Math.random().toString().split(".")[1];
+};
+
+export default (function (state, action) {
+  if (state.allowedArea && state.selectedTool !== "modify-allowed-area" && ["MOUSE_DOWN", "MOUSE_UP", "MOUSE_MOVE"].includes(action.type)) {
+    var aa = state.allowedArea;
+    action.x = clamp(action.x, aa.x, aa.x + aa.w);
+    action.y = clamp(action.y, aa.y, aa.y + aa.h);
+  }
+
+  if (action.type === "ON_CLS_ADDED" && action.cls && action.cls !== "") {
+    var oldRegionClsList = state.regionClsList;
+
+    var newState = _objectSpread({}, state, {
+      regionClsList: oldRegionClsList.concat(action.cls)
+    });
+
+    return newState;
+  } // Throttle certain actions
+
+
+  if (action.type === "MOUSE_MOVE") {
+    if (Date.now() - (state.lastMouseMoveCall || 0) < 16) return state;
+    state = setIn(state, ["lastMouseMoveCall"], Date.now());
+  }
+
+  if (!action.type.includes("MOUSE")) {
+    state = setIn(state, ["lastAction"], action);
+  }
+
+  var _getActiveImage = getActiveImage(state),
+      currentImageIndex = _getActiveImage.currentImageIndex,
+      pathToActiveImage = _getActiveImage.pathToActiveImage,
+      activeImage = _getActiveImage.activeImage;
+
+  var getRegionIndex = function getRegionIndex(region) {
+    var regionId = typeof region === "string" || typeof region === "number" ? region : region.id;
+    if (!activeImage) return null;
+    var regionIndex = (activeImage.regions || []).findIndex(function (r) {
+      return r.id === regionId;
+    });
+    return regionIndex === -1 ? null : regionIndex;
+  };
+
+  var getRegion = function getRegion(regionId) {
+    if (!activeImage) return null;
+    var regionIndex = getRegionIndex(regionId);
+    if (regionIndex === null) return [null, null];
+    var region = activeImage.regions[regionIndex];
+    return [region, regionIndex];
+  };
+
+  var modifyRegion = function modifyRegion(regionId, obj) {
+    var _getRegion = getRegion(regionId),
+        _getRegion2 = _slicedToArray(_getRegion, 2),
+        region = _getRegion2[0],
+        regionIndex = _getRegion2[1];
+
+    if (!region) return state;
+
+    if (obj !== null) {
+      return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", regionIndex]), _objectSpread({}, region, obj));
+    } else {
+      // delete region
+      var regions = activeImage.regions;
+      return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), (regions || []).filter(function (r) {
+        return r.id !== region.id;
+      }));
+    }
+  };
+
+  var unselectRegions = function unselectRegions(state) {
+    if (!activeImage) return state;
+    return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), (activeImage.regions || []).map(function (r) {
+      return _objectSpread({}, r, {
+        highlighted: false
+      });
+    }));
+  };
+
+  var closeEditors = function closeEditors(state) {
+    if (currentImageIndex === null) return state;
+    return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), (activeImage.regions || []).map(function (r) {
+      return _objectSpread({}, r, {
+        editingLabels: false
+      });
+    }));
+  };
+
+  var addSaveableAction = function addSaveableAction(state, action) {
+    if (currentImageIndex === null) return state;
+    return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["saveableActions"]), [].concat(_toConsumableArray(activeImage.saveableActions || []), [action]));
+  };
+
+  var setNewImage = function setNewImage(img, index) {
+    var _ref = typeof img === "object" ? img : {
+      src: img
+    },
+        src = _ref.src,
+        frameTime = _ref.frameTime;
+
+    state = setIn(state, ["previouslySelectedImage"], state.selectedImage);
+    return setIn(setIn(state, ["selectedImage"], index), ["selectedImageFrameTime"], frameTime);
+  };
+
+  switch (action.type) {
+    case "@@INIT":
+      {
+        return state;
+      }
+
+    case "SELECT_IMAGE":
+      {
+        return setNewImage(action.image, action.imageIndex);
+      }
+
+    case "SELECT_CLASSIFICATION":
+      {
+        var _state$images$state$s;
+
+        // if there is selected region, set its cls
+        var selectedRegionId = (_state$images$state$s = state.images[state.selectedImage].regions.find(function (r) {
+          return r.highlighted === true;
+        })) === null || _state$images$state$s === void 0 ? void 0 : _state$images$state$s.id;
+
+        if (selectedRegionId) {
+          var newRegions = activeImage.regions.map(function (r) {
+            if (r.id === selectedRegionId) {
+              return _objectSpread({}, r, {
+                cls: action.cls
+              });
+            } else {
+              return r;
+            }
+          });
+          state = setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), newRegions);
+        }
+
+        state = addSaveableAction(state, "SELECT_CLASSIFICATION");
+        return setIn(state, ["selectedCls"], action.cls);
+      }
+
+    case "CHANGE_REGION":
+      {
+        var regionIndex = getRegionIndex(action.region);
+        if (regionIndex === null) return state;
+        var oldRegion = activeImage.regions[regionIndex];
+
+        if (oldRegion.cls !== action.region.cls) {
+          state = saveToHistory(state, "Change Region Classification");
+          var clsIndex = state.regionClsList.indexOf(action.region.cls);
+
+          if (clsIndex !== -1) {
+            state = setIn(state, ["selectedCls"], action.region.cls);
+            action.region.color = colors[clsIndex % colors.length];
+          }
+        }
+
+        if (!isEqual(oldRegion.tags, action.region.tags)) {
+          state = saveToHistory(state, "Change Region Tags");
+        }
+
+        if (!isEqual(oldRegion.comment, action.region.comment)) {
+          state = saveToHistory(state, "Change Region Comment");
+        }
+
+        state = addSaveableAction(state, "CHANGE_REGION");
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", regionIndex]), action.region);
+      }
+
+    case "CHANGE_IMAGE":
+      {
+        if (!activeImage) return state;
+        var delta = action.delta;
+
+        for (var _i = 0, _Object$keys = Object.keys(delta); _i < _Object$keys.length; _i++) {
+          var key = _Object$keys[_i];
+          if (key === "cls") saveToHistory(state, "Change Image Class");
+          if (key === "tags") saveToHistory(state, "Change Image Tags");
+          state = setIn(state, [].concat(_toConsumableArray(pathToActiveImage), [key]), delta[key]);
+        }
+
+        return state;
+      }
+
+    case "SELECT_REGION":
+      {
+        var region = action.region;
+
+        var _regionIndex = getRegionIndex(action.region);
+
+        if (_regionIndex === null) return state;
+
+        var regions = _toConsumableArray(activeImage.regions || []).map(function (r) {
+          return _objectSpread({}, r, {
+            highlighted: r.id === region.id,
+            groupHighlighted: r.groupId && r.groupId === region.groupId ? true : false,
+            editingLabels: region.ctrlKey ? r.id === region.id : false
+          });
+        });
+
+        var selectedGroupIds = regions.filter(function (i) {
+          return i.highlighted;
+        }).map(function (r) {
+          return r.groupId || '';
+        }).filter(onlyUnique);
+
+        if (selectedGroupIds.length === 1) {
+          state = setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["selectedGroupId"]), selectedGroupIds[0]);
+        }
+
+        if (selectedGroupIds.length === 0) {
+          state = setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["selectedGroupId"]), null);
+        }
+
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), regions);
+      }
+
+    case "BEGIN_MOVE_POINT":
+      {
+        state = closeEditors(state);
+        return setIn(state, ["mode"], {
+          mode: "MOVE_REGION",
+          regionId: action.point.id
+        });
+      }
+
+    case "BEGIN_BOX_TRANSFORM":
+      {
+        var box = action.box,
+            directions = action.directions;
+        state = closeEditors(state);
+
+        if (directions[0] === 0 && directions[1] === 0) {
+          return setIn(state, ["mode"], {
+            mode: "MOVE_REGION",
+            regionId: box.id
+          });
+        } else {
+          return setIn(state, ["mode"], {
+            mode: "RESIZE_BOX",
+            regionId: box.id,
+            freedom: directions,
+            original: {
+              x: box.x,
+              y: box.y,
+              w: box.w,
+              h: box.h
+            }
+          });
+        }
+      }
+
+    case "BEGIN_MOVE_POLYGON_POINT":
+      {
+        var polygon = action.polygon,
+            pointIndex = action.pointIndex;
+        state = closeEditors(state);
+
+        if (state.mode && state.mode.mode === "DRAW_POLYGON" && pointIndex === 0) {
+          return setIn(modifyRegion(polygon, {
+            points: polygon.points.slice(0, -1),
+            open: false
+          }), ["mode"], null);
+        } else {
+          state = saveToHistory(state, "Move Polygon Point");
+        }
+
+        return setIn(state, ["mode"], {
+          mode: "MOVE_POLYGON_POINT",
+          regionId: polygon.id,
+          pointIndex: pointIndex
+        });
+      }
+
+    case "BEGIN_MOVE_KEYPOINT":
+      {
+        var _region = action.region,
+            keypointId = action.keypointId;
+        state = closeEditors(state);
+        state = saveToHistory(state, "Move Keypoint");
+        return setIn(state, ["mode"], {
+          mode: "MOVE_KEYPOINT",
+          regionId: _region.id,
+          keypointId: keypointId
+        });
+      }
+
+    case "ADD_POLYGON_POINT":
+      {
+        var _polygon = action.polygon,
+            point = action.point,
+            _pointIndex = action.pointIndex;
+
+        var _regionIndex2 = getRegionIndex(_polygon);
+
+        if (_regionIndex2 === null) return state;
+
+        var points = _toConsumableArray(_polygon.points);
+
+        points.splice(_pointIndex, 0, point);
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex2]), _objectSpread({}, _polygon, {
+          points: points
+        }));
+      }
+
+    case "MOUSE_MOVE":
+      {
+        var x = action.x,
+            y = action.y;
+        if (!state.mode) return state;
+        if (!activeImage) return state;
+        var _state = state,
+            mouseDownAt = _state.mouseDownAt;
+
+        switch (state.mode.mode) {
+          case "MOVE_POLYGON_POINT":
+            {
+              var _state$mode = state.mode,
+                  _pointIndex2 = _state$mode.pointIndex,
+                  regionId = _state$mode.regionId;
+
+              var _regionIndex3 = getRegionIndex(regionId);
+
+              if (_regionIndex3 === null) return state;
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex3, "points", _pointIndex2]), [x, y]);
+            }
+
+          case "MOVE_KEYPOINT":
+            {
+              var _state$mode2 = state.mode,
+                  _keypointId = _state$mode2.keypointId,
+                  _regionId = _state$mode2.regionId;
+
+              var _getRegion3 = getRegion(_regionId),
+                  _getRegion4 = _slicedToArray(_getRegion3, 2),
+                  _region2 = _getRegion4[0],
+                  _regionIndex4 = _getRegion4[1];
+
+              if (_regionIndex4 === null) return state;
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex4, "points", _keypointId]), _objectSpread({}, _region2.points[_keypointId], {
+                x: x,
+                y: y
+              }));
+            }
+
+          case "MOVE_REGION":
+            {
+              var _regionId2 = state.mode.regionId;
+
+              if (_regionId2 === "$$allowed_area") {
+                var _state2 = state,
+                    _state2$allowedArea = _state2.allowedArea,
+                    w = _state2$allowedArea.w,
+                    h = _state2$allowedArea.h;
+                return setIn(state, ["allowedArea"], {
+                  x: x - w / 2,
+                  y: y - h / 2,
+                  w: w,
+                  h: h
+                });
+              }
+
+              var _regionIndex5 = getRegionIndex(_regionId2);
+
+              if (_regionIndex5 === null) return state;
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex5]), moveRegion(activeImage.regions[_regionIndex5], x, y));
+            }
+
+          case "RESIZE_BOX":
+            {
+              var _state$mode3 = state.mode,
+                  _regionId3 = _state$mode3.regionId,
+                  _state$mode3$freedom = _slicedToArray(_state$mode3.freedom, 2),
+                  xFree = _state$mode3$freedom[0],
+                  yFree = _state$mode3$freedom[1],
+                  _state$mode3$original = _state$mode3.original,
+                  ox = _state$mode3$original.x,
+                  oy = _state$mode3$original.y,
+                  ow = _state$mode3$original.w,
+                  oh = _state$mode3$original.h;
+
+              var dx = xFree === 0 ? ox : xFree === -1 ? Math.min(ox + ow, x) : ox;
+              var dw = xFree === 0 ? ow : xFree === -1 ? ow + (ox - dx) : Math.max(0, ow + (x - ox - ow));
+              var dy = yFree === 0 ? oy : yFree === -1 ? Math.min(oy + oh, y) : oy;
+              var dh = yFree === 0 ? oh : yFree === -1 ? oh + (oy - dy) : Math.max(0, oh + (y - oy - oh)); // determine if we should switch the freedom
+
+              if (dw <= 0.001) {
+                state = setIn(state, ["mode", "freedom"], [xFree * -1, yFree]);
+              }
+
+              if (dh <= 0.001) {
+                state = setIn(state, ["mode", "freedom"], [xFree, yFree * -1]);
+              }
+
+              if (_regionId3 === "$$allowed_area") {
+                return setIn(state, ["allowedArea"], {
+                  x: dx,
+                  w: dw,
+                  y: dy,
+                  h: dh
+                });
+              }
+
+              var _regionIndex6 = getRegionIndex(_regionId3);
+
+              if (_regionIndex6 === null) return state;
+              var _box = activeImage.regions[_regionIndex6];
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex6]), _objectSpread({}, _box, {
+                x: dx,
+                w: dw,
+                y: dy,
+                h: dh
+              }));
+            }
+
+          case "RESIZE_KEYPOINTS":
+            {
+              var _state$mode4 = state.mode,
+                  _regionId4 = _state$mode4.regionId,
+                  landmarks = _state$mode4.landmarks,
+                  centerX = _state$mode4.centerX,
+                  centerY = _state$mode4.centerY;
+              var distFromCenter = Math.sqrt(Math.pow(centerX - x, 2) + Math.pow(centerY - y, 2));
+              var scale = distFromCenter / 0.15;
+              return modifyRegion(_regionId4, {
+                points: getLandmarksWithTransform({
+                  landmarks: landmarks,
+                  center: {
+                    x: centerX,
+                    y: centerY
+                  },
+                  scale: scale
+                })
+              });
+            }
+
+          case "DRAW_POLYGON":
+            {
+              var _regionId5 = state.mode.regionId;
+
+              var _getRegion5 = getRegion(_regionId5),
+                  _getRegion6 = _slicedToArray(_getRegion5, 2),
+                  _region3 = _getRegion6[0],
+                  _regionIndex7 = _getRegion6[1];
+
+              if (!_region3) return setIn(state, ["mode"], null);
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex7, "points", _region3.points.length - 1]), [x, y]);
+            }
+
+          case "DRAW_LINE":
+            {
+              var _regionId6 = state.mode.regionId;
+
+              var _getRegion7 = getRegion(_regionId6),
+                  _getRegion8 = _slicedToArray(_getRegion7, 2),
+                  _region4 = _getRegion8[0],
+                  _regionIndex8 = _getRegion8[1];
+
+              if (!_region4) return setIn(state, ["mode"], null);
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex8]), _objectSpread({}, _region4, {
+                x2: x,
+                y2: y
+              }));
+            }
+
+          case "DRAW_EXPANDING_LINE":
+            {
+              var _regionId7 = state.mode.regionId;
+
+              var _getRegion9 = getRegion(_regionId7),
+                  _getRegion10 = _slicedToArray(_getRegion9, 2),
+                  expandingLine = _getRegion10[0],
+                  _regionIndex9 = _getRegion10[1];
+
+              if (!expandingLine) return state;
+              var isMouseDown = Boolean(state.mouseDownAt);
+
+              if (isMouseDown) {
+                // If the mouse is down, set width/angle
+                var lastPoint = expandingLine.points.slice(-1)[0];
+                var mouseDistFromLastPoint = Math.sqrt(Math.pow(lastPoint.x - x, 2) + Math.pow(lastPoint.y - y, 2));
+                if (mouseDistFromLastPoint < 0.002 && !lastPoint.width) return state;
+
+                var _newState = setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex9, "points"]), expandingLine.points.slice(0, -1).concat([_objectSpread({}, lastPoint, {
+                  width: mouseDistFromLastPoint * 2,
+                  angle: Math.atan2(lastPoint.x - x, lastPoint.y - y)
+                })]));
+
+                return _newState;
+              } else {
+                // If mouse is up, move the next candidate point
+                return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex9]), _objectSpread({}, expandingLine, {
+                  candidatePoint: {
+                    x: x,
+                    y: y
+                  }
+                }));
+              }
+
+              return state;
+            }
+
+          case "SET_EXPANDING_LINE_WIDTH":
+            {
+              var _regionId8 = state.mode.regionId;
+
+              var _getRegion11 = getRegion(_regionId8),
+                  _getRegion12 = _slicedToArray(_getRegion11, 2),
+                  _expandingLine = _getRegion12[0],
+                  _regionIndex10 = _getRegion12[1];
+
+              if (!_expandingLine) return state;
+
+              var _lastPoint = _expandingLine.points.slice(-1)[0];
+
+              var _state3 = state,
+                  _mouseDownAt = _state3.mouseDownAt;
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex10, "expandingWidth"]), Math.sqrt(Math.pow(_lastPoint.x - x, 2) + Math.pow(_lastPoint.y - y, 2)));
+            }
+
+          default:
+            return state;
+        }
+      }
+
+    case "MOUSE_DOWN":
+      {
+        var _state$regionClsList;
+
+        if (!activeImage) return state;
+        var _x = action.x,
+            _y = action.y;
+        state = setIn(state, ["mouseDownAt"], {
+          x: _x,
+          y: _y
+        });
+
+        if (state.mode) {
+          switch (state.mode.mode) {
+            case "DRAW_POLYGON":
+              {
+                var _getRegion13 = getRegion(state.mode.regionId),
+                    _getRegion14 = _slicedToArray(_getRegion13, 2),
+                    _polygon2 = _getRegion14[0],
+                    _regionIndex11 = _getRegion14[1];
+
+                if (!_polygon2) break;
+                return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex11]), _objectSpread({}, _polygon2, {
+                  points: _polygon2.points.concat([[_x, _y]])
+                }));
+              }
+
+            case "DRAW_LINE":
+              {
+                var _getRegion15 = getRegion(state.mode.regionId),
+                    _getRegion16 = _slicedToArray(_getRegion15, 2),
+                    line = _getRegion16[0],
+                    _regionIndex12 = _getRegion16[1];
+
+                if (!line) break;
+                setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex12]), _objectSpread({}, line, {
+                  x2: _x,
+                  y2: _y
+                }));
+                return setIn(state, ["mode"], null);
+              }
+
+            case "DRAW_EXPANDING_LINE":
+              {
+                var _getRegion17 = getRegion(state.mode.regionId),
+                    _getRegion18 = _slicedToArray(_getRegion17, 2),
+                    _expandingLine2 = _getRegion18[0],
+                    _regionIndex13 = _getRegion18[1];
+
+                if (!_expandingLine2) break;
+
+                var _lastPoint2 = _expandingLine2.points.slice(-1)[0];
+
+                if (_expandingLine2.points.length > 1 && Math.sqrt(Math.pow(_lastPoint2.x - _x, 2) + Math.pow(_lastPoint2.y - _y, 2)) < 0.002) {
+                  if (!_lastPoint2.width) {
+                    return setIn(state, ["mode"], {
+                      mode: "SET_EXPANDING_LINE_WIDTH",
+                      regionId: state.mode.regionId
+                    });
+                  } else {
+                    return state.setIn([].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex13]), convertExpandingLineToPolygon(_expandingLine2)).setIn(["mode"], null);
+                  }
+                } // Create new point
+
+
+                return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex13, "points"]), _expandingLine2.points.concat([{
+                  x: _x,
+                  y: _y,
+                  angle: null,
+                  width: null
+                }]));
+              }
+
+            case "SET_EXPANDING_LINE_WIDTH":
+              {
+                var _getRegion19 = getRegion(state.mode.regionId),
+                    _getRegion20 = _slicedToArray(_getRegion19, 2),
+                    _expandingLine3 = _getRegion20[0],
+                    _regionIndex14 = _getRegion20[1];
+
+                if (!_expandingLine3) break;
+                var expandingWidth = _expandingLine3.expandingWidth;
+                return state.setIn([].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex14]), convertExpandingLineToPolygon(_objectSpread({}, _expandingLine3, {
+                  points: _expandingLine3.points.map(function (p) {
+                    return p.width ? p : _objectSpread({}, p, {
+                      width: expandingWidth
+                    });
+                  }),
+                  expandingWidth: undefined
+                }))).setIn(["mode"], null);
+              }
+
+            default:
+              break;
+          }
+        }
+
+        var newRegion;
+        var defaultRegionCls = state.selectedCls || ((_state$regionClsList = state.regionClsList) === null || _state$regionClsList === void 0 ? void 0 : _state$regionClsList[0]),
+            defaultRegionColor = "#ff0000";
+
+        var _clsIndex = (state.regionClsList || []).indexOf(defaultRegionCls);
+
+        if (_clsIndex !== -1) {
+          defaultRegionColor = colors[_clsIndex % colors.length];
+        }
+
+        switch (state.selectedTool) {
+          case "create-point":
+            {
+              state = saveToHistory(state, "Create Point");
+              newRegion = {
+                type: "point",
+                x: _x,
+                y: _y,
+                highlighted: true,
+                editingLabels: true,
+                color: defaultRegionColor,
+                id: getRandomId(),
+                cls: defaultRegionCls
+              };
+              break;
+            }
+
+          case "create-box":
+            {
+              var _state4, _state4$images$state$, _state4$images$state$2, _state4$images$state$3;
+
+              var groupId = (_state4 = state) === null || _state4 === void 0 ? void 0 : (_state4$images$state$ = _state4.images[state.selectedImage]) === null || _state4$images$state$ === void 0 ? void 0 : (_state4$images$state$2 = _state4$images$state$.regions) === null || _state4$images$state$2 === void 0 ? void 0 : (_state4$images$state$3 = _state4$images$state$2.find(function (r) {
+                return r.highlighted === true;
+              })) === null || _state4$images$state$3 === void 0 ? void 0 : _state4$images$state$3.groupId;
+              var groupSelected = true;
+
+              if (groupId === undefined) {
+                groupId = nextGroupId();
+                groupSelected = false;
+              }
+
+              state = saveToHistory(state, "Create Box");
+              newRegion = {
+                type: "box",
+                x: _x,
+                y: _y,
+                w: 0,
+                h: 0,
+                highlighted: true,
+                editingLabels: false,
+                color: defaultRegionColor,
+                cls: defaultRegionCls,
+                id: getRandomId(),
+                groupHighlighted: true,
+                groupId: groupId
+              };
+              state = setIn(state, ["mode"], {
+                mode: "RESIZE_BOX",
+                editLabelEditorAfter: !groupSelected,
+                regionId: newRegion.id,
+                freedom: [1, 1],
+                original: {
+                  x: _x,
+                  y: _y,
+                  w: newRegion.w,
+                  h: newRegion.h
+                },
+                isNew: true
+              });
+              break;
+            }
+
+          case "create-polygon":
+            {
+              if (state.mode && state.mode.mode === "DRAW_POLYGON") break;
+              state = saveToHistory(state, "Create Polygon");
+              newRegion = {
+                type: "polygon",
+                points: [[_x, _y], [_x, _y]],
+                open: true,
+                highlighted: true,
+                color: defaultRegionColor,
+                cls: defaultRegionCls,
+                id: getRandomId()
+              };
+              state = setIn(state, ["mode"], {
+                mode: "DRAW_POLYGON",
+                regionId: newRegion.id
+              });
+              break;
+            }
+
+          case "create-expanding-line":
+            {
+              state = saveToHistory(state, "Create Expanding Line");
+              newRegion = {
+                type: "expanding-line",
+                unfinished: true,
+                points: [{
+                  x: _x,
+                  y: _y,
+                  angle: null,
+                  width: null
+                }],
+                open: true,
+                highlighted: true,
+                color: defaultRegionColor,
+                cls: defaultRegionCls,
+                id: getRandomId()
+              };
+              state = setIn(state, ["mode"], {
+                mode: "DRAW_EXPANDING_LINE",
+                regionId: newRegion.id
+              });
+              break;
+            }
+
+          case "create-line":
+            {
+              if (state.mode && state.mode.mode === "DRAW_LINE") break;
+              state = saveToHistory(state, "Create Line");
+              newRegion = {
+                type: "line",
+                x1: _x,
+                y1: _y,
+                x2: _x,
+                y2: _y,
+                highlighted: true,
+                editingLabels: false,
+                color: defaultRegionColor,
+                cls: defaultRegionCls,
+                id: getRandomId()
+              };
+              state = setIn(state, ["mode"], {
+                mode: "DRAW_LINE",
+                regionId: newRegion.id
+              });
+              break;
+            }
+
+          case "create-keypoints":
+            {
+              state = saveToHistory(state, "Create Keypoints");
+
+              var _ref2 = Object.entries(state.keypointDefinitions),
+                  _ref3 = _slicedToArray(_ref2, 1),
+                  _ref3$ = _slicedToArray(_ref3[0], 2),
+                  keypointsDefinitionId = _ref3$[0],
+                  _ref3$$ = _ref3$[1],
+                  _landmarks = _ref3$$.landmarks,
+                  connections = _ref3$$.connections;
+
+              newRegion = {
+                type: "keypoints",
+                keypointsDefinitionId: keypointsDefinitionId,
+                points: getLandmarksWithTransform({
+                  landmarks: _landmarks,
+                  center: {
+                    x: _x,
+                    y: _y
+                  },
+                  scale: 1
+                }),
+                highlighted: true,
+                editingLabels: false,
+                id: getRandomId()
+              };
+              state = setIn(state, ["mode"], {
+                mode: "RESIZE_KEYPOINTS",
+                landmarks: _landmarks,
+                centerX: _x,
+                centerY: _y,
+                regionId: newRegion.id,
+                isNew: true
+              });
+              break;
+            }
+
+          default:
+            break;
+        }
+
+        var _regions = _toConsumableArray(getIn(state, pathToActiveImage).regions || []).map(function (r) {
+          return setIn(r, ["editingLabels"], false).setIn(["highlighted"], false).setIn([state.selectedTool === 'create-box' ? undefined : 'groupHighlighted'], false);
+        }).concat(newRegion ? [newRegion] : []);
+
+        state = setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["selectedGroupId"]), null);
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), _regions);
+      }
+
+    case "MOUSE_UP":
+      {
+        var _x2 = action.x,
+            _y2 = action.y;
+
+        var _state5 = state,
+            _state5$mouseDownAt = _state5.mouseDownAt,
+            _mouseDownAt2 = _state5$mouseDownAt === void 0 ? {
+          x: _x2,
+          y: _y2
+        } : _state5$mouseDownAt;
+
+        if (!state.mode) return state;
+        state = setIn(state, ["mouseDownAt"], null);
+
+        switch (state.mode.mode) {
+          case "RESIZE_BOX":
+            {
+              state = setIn(state, ["selectedTool"], 'select');
+
+              if (state.mode.isNew) {
+                if (Math.abs(state.mode.original.x - _x2) < 0.002 || Math.abs(state.mode.original.y - _y2) < 0.002) {
+                  state = addSaveableAction(state, "MOUSE_UP_RESIZE_BOX");
+                  return setIn(modifyRegion(state.mode.regionId, null), ["mode"], null);
+                }
+              }
+
+              if (state.mode.editLabelEditorAfter) {
+                state = addSaveableAction(state, "MOUSE_UP_RESIZE_BOX");
+                return _objectSpread({}, modifyRegion(state.mode.regionId, {
+                  editingLabels: true
+                }), {
+                  mode: null
+                });
+              }
+            }
+
+          case "MOVE_REGION":
+          case "RESIZE_KEYPOINTS":
+          case "MOVE_POLYGON_POINT":
+            {
+              state = addSaveableAction(state, "MOUSE_UP_MOVE_REGION");
+              return _objectSpread({}, state, {
+                mode: null
+              });
+            }
+
+          case "MOVE_KEYPOINT":
+            {
+              return _objectSpread({}, state, {
+                mode: null
+              });
+            }
+
+          case "CREATE_POINT_LINE":
+            {
+              return state;
+            }
+
+          case "DRAW_EXPANDING_LINE":
+            {
+              var _getRegion21 = getRegion(state.mode.regionId),
+                  _getRegion22 = _slicedToArray(_getRegion21, 2),
+                  _expandingLine4 = _getRegion22[0],
+                  _regionIndex15 = _getRegion22[1];
+
+              if (!_expandingLine4) return state;
+              var newExpandingLine = _expandingLine4;
+
+              var _lastPoint3 = _expandingLine4.points.length !== 0 ? _expandingLine4.points.slice(-1)[0] : _mouseDownAt2;
+
+              var jointStart;
+
+              if (_expandingLine4.points.length > 1) {
+                jointStart = _expandingLine4.points.slice(-2)[0];
+              } else {
+                jointStart = _lastPoint3;
+              }
+
+              var _mouseDistFromLastPoint = Math.sqrt(Math.pow(_lastPoint3.x - _x2, 2) + Math.pow(_lastPoint3.y - _y2, 2));
+
+              if (_mouseDistFromLastPoint > 0.002) {
+                // The user is drawing has drawn the width for the last point
+                var newPoints = _toConsumableArray(_expandingLine4.points);
+
+                for (var i = 0; i < newPoints.length - 1; i++) {
+                  if (newPoints[i].width) continue;
+                  newPoints[i] = _objectSpread({}, newPoints[i], {
+                    width: _lastPoint3.width
+                  });
+                }
+
+                newExpandingLine = setIn(_expandingLine4, ["points"], fixTwisted(newPoints));
+              } else {
+                return state;
+              }
+
+              return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex15]), newExpandingLine);
+            }
+
+          default:
+            return state;
+        }
+      }
+
+    case "OPEN_REGION_EDITOR":
+      {
+        var _region5 = action.region;
+
+        var _regionIndex16 = getRegionIndex(action.region);
+
+        if (_regionIndex16 === null) return state;
+
+        var _newRegions = setIn(activeImage.regions.map(function (r) {
+          return _objectSpread({}, r, {
+            highlighted: false,
+            editingLabels: false
+          });
+        }), [_regionIndex16], _objectSpread({}, (activeImage.regions || [])[_regionIndex16], {
+          highlighted: true,
+          editingLabels: true
+        }));
+
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), _newRegions);
+      }
+
+    case "CLOSE_REGION_EDITOR":
+      {
+        var _region6 = action.region;
+
+        var _regionIndex17 = getRegionIndex(action.region);
+
+        if (_regionIndex17 === null) return state;
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions", _regionIndex17]), _objectSpread({}, (activeImage.regions || [])[_regionIndex17], {
+          editingLabels: false
+        }));
+      }
+
+    case "DELETE_REGION":
+      {
+        var _regionIndex18 = getRegionIndex(action.region);
+
+        if (_regionIndex18 === null) return state;
+        state = saveToHistory(state, "Delete region");
+        state = addSaveableAction(state, "DELETE_REGION");
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), (activeImage.regions || []).filter(function (r) {
+          return r.id !== action.region.id;
+        }));
+      }
+
+    case "DELETE_GROUP":
+      {
+        var _groupId = action.groupId;
+        if (_groupId === null || _groupId === undefined) return state;
+        state = saveToHistory(state, "Delete group");
+        state = addSaveableAction(state, "DELETE_GROUP");
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), (activeImage.regions || []).filter(function (r) {
+          return r.groupId !== _groupId;
+        }));
+      }
+
+    case "DELETE_SELECTED_REGION":
+      {
+        state = saveToHistory(state, "Delete selected region");
+        state = addSaveableAction(state, "DELETE_SELECTED_REGION");
+        return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), (activeImage.regions || []).filter(function (r) {
+          return !r.highlighted;
+        }));
+      }
+
+    case "HEADER_BUTTON_CLICKED":
+      {
+        var buttonName = action.buttonName.toLowerCase();
+
+        switch (buttonName) {
+          case "prev":
+            {
+              if (currentImageIndex === null) return state;
+              if (currentImageIndex === 0) return state;
+              return setNewImage(state.images[currentImageIndex - 1], currentImageIndex - 1);
+            }
+
+          case "next":
+            {
+              if (currentImageIndex === null) return state;
+              if (currentImageIndex === state.images.length - 1) return state;
+              return setNewImage(state.images[currentImageIndex + 1], currentImageIndex + 1);
+            }
+
+          case "clone":
+            {
+              if (currentImageIndex === null) return state;
+              if (currentImageIndex === state.images.length - 1) return state;
+              return setIn(setNewImage(state.images[currentImageIndex + 1], currentImageIndex + 1), ["images", currentImageIndex + 1, "regions"], activeImage.regions);
+            }
+
+          case "settings":
+            {
+              return setIn(state, ["settingsOpen"], !state.settingsOpen);
+            }
+
+          case "help":
+            {
+              return state;
+            }
+
+          case "fullscreen":
+            {
+              return setIn(state, ["fullScreen"], true);
+            }
+
+          case "exit fullscreen":
+          case "window":
+            {
+              return setIn(state, ["fullScreen"], false);
+            }
+
+          case "hotkeys":
+            {
+              return state;
+            }
+
+          case "exit":
+          case "done":
+            {
+              return state;
+            }
+
+          default:
+            return state;
+        }
+      }
+
+    case "SELECT_TOOL":
+      {
+        if (action.selectedTool === "show-tags") {
+          setInLocalStorage("showTags", !state.showTags);
+          return setIn(state, ["showTags"], !state.showTags);
+        } else if (action.selectedTool === "show-mask") {
+          return setIn(state, ["showMask"], !state.showMask);
+        }
+
+        if (action.selectedTool === "modify-allowed-area" && !state.allowedArea) {
+          state = setIn(state, ["allowedArea"], {
+            x: 0,
+            y: 0,
+            w: 1,
+            h: 1
+          });
+        }
+
+        state = setIn(state, ["mode"], null);
+        return setIn(state, ["selectedTool"], action.selectedTool);
+      }
+
+    case "CANCEL":
+      {
+        var _state6 = state,
+            mode = _state6.mode;
+
+        if (mode) {
+          switch (mode.mode) {
+            case "DRAW_EXPANDING_LINE":
+            case "SET_EXPANDING_LINE_WIDTH":
+            case "DRAW_POLYGON":
+              {
+                var _regionId9 = mode.regionId;
+                return modifyRegion(_regionId9, null);
+              }
+
+            case "MOVE_POLYGON_POINT":
+            case "RESIZE_BOX":
+            case "MOVE_REGION":
+              {
+                return setIn(state, ["mode"], null);
+              }
+
+            default:
+              return state;
+          }
+        } // Close any open boxes
+
+
+        var _regions2 = activeImage.regions;
+
+        if (_regions2 && _regions2.some(function (r) {
+          return r.editingLabels;
+        })) {
+          return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), _regions2.map(function (r) {
+            return _objectSpread({}, r, {
+              editingLabels: false
+            });
+          }));
+        } else if (_regions2) {
+          return setIn(state, [].concat(_toConsumableArray(pathToActiveImage), ["regions"]), _regions2.map(function (r) {
+            return _objectSpread({}, r, {
+              highlighted: false
+            });
+          }));
+        }
+
+        break;
+      }
+
+    case "UPDATE_REGIONS":
+      {
+        var imageIndex = action.imageIndex,
+            _newRegions2 = action.regions;
+        var updatedRegions = state.images[imageIndex].regions.map(function (r) {
+          var updatedRegion = _newRegions2.find(function (i) {
+            return i.id === r.id;
+          });
+
+          if (!updatedRegion) {
+            return r;
+          }
+
+          return _objectSpread({}, r, {
+            cls: updatedRegion.cls,
+            text: updatedRegion.text
+          });
+        }); // TODO: add mutation of order and deletion of regions - SI-1967
+
+        state = addSaveableAction(state, "UPDATE_REGIONS");
+        return setIn(state, ["images", imageIndex, "regions"], updatedRegions);
+      }
+
+    case "IMAGES_UPDATED":
+      {
+        var updatedAt = action.updatedAt;
+        return setIn(state, ["imagesUpdatedAt"], updatedAt);
+      }
+
+    case "IMAGES_SAVED":
+      {
+        var savedAt = action.savedAt;
+        return setIn(state, ["imagesSavedAt"], savedAt);
+      }
+
+    case "IMAGES_RECALCULATED":
+      {
+        var recalculatedAt = action.recalculatedAt;
+        return setIn(state, ["imagesSavedAt"], recalculatedAt);
+      }
+
+    case "UPDATE_METADATA":
+      {
+        var name = action.name,
+            value = action.value,
+            _imageIndex = action.imageIndex,
+            _groupId2 = action.groupId,
+            metadataId = action.metadataId;
+
+        if (isNaN(_imageIndex)) {
+          var _state$albumMetadata;
+
+          // update global/album metadata
+          var metadataIndex = (_state$albumMetadata = state.albumMetadata) === null || _state$albumMetadata === void 0 ? void 0 : _state$albumMetadata.findIndex(function (mt) {
+            return mt.key === name;
+          });
+
+          if (metadataIndex < 0) {
+            console.error("can't find metadata by key \"".concat(name, "\""));
+            return state;
+          }
+
+          state = addSaveableAction(state, "UPDATE_ALBUM_METADATA");
+          return setIn(state, ["albumMetadata", metadataIndex], {
+            key: name,
+            value: value
+          });
+        } else {
+          var _state$images$_imageI3, _state$images$_imageI4;
+
+          // update metadata of article
+          if (_groupId2) {
+            var _state$images$_imageI, _state$images$_imageI2;
+
+            var articleMetadataRegionIdx = (_state$images$_imageI = state.images[_imageIndex]) === null || _state$images$_imageI === void 0 ? void 0 : _state$images$_imageI.regions.findIndex(function (r) {
+              return r.cls === 'metadata' && r.groupId === _groupId2;
+            });
+
+            if (articleMetadataRegionIdx < 0) {
+              console.error("can't find article metadata for goupId \"".concat(_groupId2, "\""));
+              return state;
+            }
+
+            var articleRegionToUpdate = (_state$images$_imageI2 = state.images[_imageIndex]) === null || _state$images$_imageI2 === void 0 ? void 0 : _state$images$_imageI2.regions[articleMetadataRegionIdx];
+            var articleMetadata = JSON.parse(articleRegionToUpdate.text);
+            var toBeUpdatedMetadataIdx = articleMetadata.findIndex(function (i) {
+              return i.metadataId === metadataId;
+            });
+
+            if (toBeUpdatedMetadataIdx < 0) {
+              console.error("can't find metadata field in article metadata for key \"".concat(name, "\""));
+              return state;
+            }
+
+            articleMetadata[toBeUpdatedMetadataIdx].value = value;
+            state = addSaveableAction(state, "UPDATE_METADATA");
+            return setIn(state, ["images", _imageIndex, "regions", articleMetadataRegionIdx], _objectSpread({}, articleRegionToUpdate, {
+              text: JSON.stringify(articleMetadata)
+            }));
+          } // update metadata of image
+
+
+          var _metadataIndex = (_state$images$_imageI3 = state.images[_imageIndex]) === null || _state$images$_imageI3 === void 0 ? void 0 : (_state$images$_imageI4 = _state$images$_imageI3.metadata) === null || _state$images$_imageI4 === void 0 ? void 0 : _state$images$_imageI4.findIndex(function (mt) {
+            return mt.key === name;
+          });
+
+          if (_metadataIndex < 0) {
+            console.error("can't find photo metadata by key \"".concat(name, "\""));
+            return state;
+          }
+
+          state = addSaveableAction(state, "UPDATE_METADATA");
+          return setIn(state, ["images", _imageIndex, "metadata", _metadataIndex], {
+            key: name,
+            value: value
+          });
+        }
+      }
+
+    case "ADD_GROUP":
+      {
+        // FIXME: remove this branch
+        return state; // const { group } = action;
+        // const newAllowedGroups = []
+        // return setIn(
+        //   state,
+        //   ["allowedGroups"],
+        //   newAllowedGroups
+        // )
+      }
+
+    case "SAVE_IMAGE":
+      {
+        var image = action.image,
+            triggerRecalc = action.triggerRecalc,
+            toSaveMetadata = action.toSaveMetadata;
+        return setIn(state, ["toSaveImage"], {
+          image: image,
+          triggerRecalc: triggerRecalc,
+          toSaveMetadata: toSaveMetadata
+        });
+      }
+
+    case "RECALC_CLICKED":
+      {
+        var imageId = action.imageId;
+        var imageIdx = state.images.findIndex(function (i) {
+          return i.id === imageId;
+        });
+
+        if (imageIdx < 0) {
+          throw new Error("failed to find index of image with id ".concat(imageId));
+        }
+
+        var _image = _objectSpread({}, state.images[imageIdx]);
+
+        return setIn(state, ["toSaveImage"], {
+          image: _image,
+          triggerRecalc: true,
+          toSaveMetadata: []
+        });
+      }
+
+    case "IMAGE_UPDATE_INIT":
+      {
+        var _imageId = action.imageId;
+
+        var _imageIdx = state.images.findIndex(function (i) {
+          return i.id === _imageId;
+        });
+
+        if (_imageIdx < 0) {
+          throw new Error("failed to find index of image with id ".concat(_imageId));
+        }
+
+        state = setIn(state, ["toSaveImage"], null);
+        return setIn(state, ["images", _imageIdx], _objectSpread({}, state.images[_imageIdx], {
+          lockedUntil: defaultLockedUntil(),
+          syncError: null,
+          saveableActions: []
+        }));
+      }
+
+    case "IMAGE_UPDATE_SUCCESS":
+      {
+        var _imageId2 = action.imageId,
+            lockedUntil = action.lockedUntil;
+
+        var _imageIdx2 = state.images.findIndex(function (i) {
+          return i.id === _imageId2;
+        });
+
+        if (_imageIdx2 < 0) {
+          throw new Error("failed to find index of image with id ".concat(_imageId2));
+        } // if there is lockedUntil set, it means we need to poll for updated
+
+
+        if (lockedUntil) {
+          state = setIn(state, ["toPollImages"], uniq([].concat(_toConsumableArray(state.toPollImages), [_imageId2])));
+        }
+
+        return setIn(state, ["images", _imageIdx2], _objectSpread({}, state.images[_imageIdx2], {
+          lockedUntil: lockedUntil,
+          syncError: null
+        }));
+      }
+
+    case "IMAGE_UPDATE_FAIL":
+      {
+        var _imageId3 = action.imageId,
+            error = action.error;
+
+        var _imageIdx3 = state.images.findIndex(function (i) {
+          return i.id === _imageId3;
+        });
+
+        if (_imageIdx3 < 0) {
+          throw new Error("failed to find index of image with id ".concat(_imageId3));
+        }
+
+        return setIn(state, ["images", _imageIdx3], _objectSpread({}, state.images[_imageIdx3], {
+          lockedUntil: null,
+          syncError: error
+        }));
+      }
+
+    case "IMAGE_POLL_INIT":
+      {
+        var imageIds = action.imageIds;
+        return setIn(state, ["toPollImages"], state.toPollImages.filter(function (i) {
+          return !imageIds.includes(i);
+        }));
+      }
+
+    case "IMAGE_POLL_SUCCESS":
+      {
+        var _image2 = action.image;
+
+        var _imageIdx4 = state.images.findIndex(function (i) {
+          return i.id === _image2.id;
+        });
+
+        if (_imageIdx4 < 0) {
+          throw new Error("failed to find index of image with id ".concat(_image2.id));
+        }
+
+        return setIn(state, ["images", _imageIdx4], _objectSpread({}, state.images[_imageIdx4], {
+          lockedUntil: null,
+          syncError: null
+        }, _image2));
+      }
+
+    case "IMAGE_POLL_TIMEOUT":
+      {
+        var _imageId4 = action.imageId;
+
+        var _imageIdx5 = state.images.findIndex(function (i) {
+          return i.id === _imageId4;
+        });
+
+        if (_imageIdx5 < 0) {
+          throw new Error("failed to find index of image with id ".concat(_imageId4));
+        }
+
+        return setIn(state, ["images", _imageIdx5], _objectSpread({}, state.images[_imageIdx5], {
+          lockedUntil: null,
+          syncError: new Error("polling timeout")
+        }));
+      }
+
+    case "ZOOM_RESET":
+      {
+        if (state.selectedImage === undefined || state.selectedImage === null) {
+          return state;
+        }
+
+        var deselectedRegions = state.images[state.selectedImage].regions.map(function (i) {
+          return _objectSpread({}, i, {
+            highlighted: false,
+            groupHighlighted: false
+          });
+        });
+        state = setIn(state, ["selectedGroupId"], null);
+        return setIn(state, ["images", state.selectedImage, "regions"], deselectedRegions);
+      }
+
+    default:
+      break;
+  }
+
+  return state;
+});