@labelbee/lb-annotation 1.13.0-alpha.5 → 1.13.0-alpha.7

package/es/utils/tool/CuboidUtils.js

@@ -0,0 +1,663 @@
+import { cloneDeep } from 'lodash';
+import { ECuboidPlain, ECuboidPosition, ECuboidDirection, EDragTarget, DIAGONAL_POINT, ECuboidLineDirection, CUBOID_ROW, CUBOID_COLUMN } from '../../constant/annotation.js';
+import AxisUtils from './AxisUtils.js';
+import Vector from '../VectorUtils.js';
+import LineToolUtils from './LineToolUtils.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value}) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function getPlanePointsBasicInfo({tr, tl, br}) {
+  return {
+    width: Math.abs(tr.x - tl.x),
+    height: Math.abs(br.y - tr.y),
+    centerPoints: {
+      x: (tl.x + br.x) / 2,
+      y: (tl.y + br.y) / 2
+    }
+  };
+}
+function getCuboidBasicInfo({
+  frontPoints,
+  backPoints
+}) {
+  const {width: frontWidth, height: frontHeight, centerPoints: frontCenter} = getPlanePointsBasicInfo(frontPoints);
+  const {width: backWidth, height: backHeight, centerPoints: backCenter} = getPlanePointsBasicInfo(backPoints);
+  return {
+    frontCenter,
+    backCenter,
+    frontWidth,
+    frontHeight,
+    backWidth,
+    backHeight,
+    isLeftSide: backCenter.x < frontCenter.x
+  };
+}
+function getPlainPointsByDiagonalPoints(p1, p2) {
+  return {
+    tl: {
+      x: Math.min(p1.x, p2.x),
+      y: Math.min(p1.y, p2.y)
+    },
+    tr: {
+      x: Math.max(p1.x, p2.x),
+      y: Math.min(p1.y, p2.y)
+    },
+    bl: {
+      x: Math.min(p1.x, p2.x),
+      y: Math.max(p1.y, p2.y)
+    },
+    br: {
+      x: Math.max(p1.x, p2.x),
+      y: Math.max(p1.y, p2.y)
+    }
+  };
+}
+function getMaxExternalQuadrilateral(points) {
+  const minX = Object.values(points).reduce((acc, coord) => coord.x < acc ? coord.x : acc, Number.MAX_SAFE_INTEGER);
+  const maxX = Object.values(points).reduce((acc, coord) => coord.x > acc ? coord.x : acc, 0);
+  const minY = Object.values(points).reduce((acc, coord) => coord.y < acc ? coord.y : acc, Number.MAX_SAFE_INTEGER);
+  const maxY = Object.values(points).reduce((acc, coord) => coord.y > acc ? coord.y : acc, 0);
+  return {
+    tl: {
+      x: minX,
+      y: minY
+    },
+    tr: {
+      x: maxX,
+      y: minY
+    },
+    bl: {
+      x: minX,
+      y: maxY
+    },
+    br: {
+      x: maxX,
+      y: maxY
+    }
+  };
+}
+function judgeCuboidLineIsRowOrColumn(pointList) {
+  const [firstPosition, secondPosition] = pointList;
+  if (CUBOID_ROW[firstPosition.position] === secondPosition.position) {
+    return ECuboidLineDirection.Row;
+  }
+  if (CUBOID_COLUMN[firstPosition.position] === secondPosition.position) {
+    return ECuboidLineDirection.Column;
+  }
+}
+function getPointsByBottomRightPoint({
+  coord,
+  points
+}) {
+  const {width, height} = getPlanePointsBasicInfo(points);
+  return {
+    br: coord,
+    tr: {
+      x: coord.x,
+      y: coord.y - height
+    },
+    tl: {
+      x: coord.x - width,
+      y: coord.y - height
+    },
+    bl: {
+      x: coord.x - width,
+      y: coord.y
+    }
+  };
+}
+function getPointsByBottomLeftPoint({
+  coord,
+  points
+}) {
+  const {width, height} = getPlanePointsBasicInfo(points);
+  return {
+    bl: coord,
+    tr: {
+      x: coord.x + width,
+      y: coord.y - height
+    },
+    tl: {
+      x: coord.x,
+      y: coord.y - height
+    },
+    br: {
+      x: coord.x + width,
+      y: coord.y
+    }
+  };
+}
+function getCuboidShowingSideLine({
+  frontPoints,
+  backPoints
+}) {
+  const {isLeftSide} = getCuboidBasicInfo({frontPoints, backPoints});
+  if (isLeftSide) {
+    return {
+      top: {
+        p1: frontPoints.tl,
+        p2: backPoints.tl
+      },
+      bottom: {
+        p1: frontPoints.bl,
+        p2: backPoints.bl
+      }
+    };
+  }
+  return {
+    top: {
+      p1: frontPoints.tr,
+      p2: backPoints.tr
+    },
+    bottom: {
+      p1: frontPoints.br,
+      p2: backPoints.br
+    }
+  };
+}
+function getPointsByIntersection({
+  frontPoints,
+  backPoints
+}) {
+  const {isLeftSide} = getCuboidBasicInfo({frontPoints, backPoints});
+  let newBackPoints = __spreadValues({}, backPoints);
+  const sideLine = getCuboidShowingSideLine({frontPoints, backPoints});
+  const intersectionPoint = LineToolUtils.lineIntersection({pointA: sideLine.bottom.p1, pointB: sideLine.bottom.p2}, {pointA: sideLine.top.p1, pointB: sideLine.top.p2});
+  if (isLeftSide) {
+    const newBRPoint = LineToolUtils.lineIntersection({pointA: backPoints.bl, pointB: backPoints.br}, {pointA: frontPoints.br, pointB: intersectionPoint});
+    if (newBRPoint) {
+      newBackPoints = __spreadProps(__spreadValues({}, backPoints), {
+        br: newBRPoint,
+        tr: {
+          x: newBRPoint.x,
+          y: backPoints.tl.y
+        }
+      });
+    }
+  } else {
+    const newBLPoint = LineToolUtils.lineIntersection({pointA: backPoints.bl, pointB: backPoints.br}, {pointA: frontPoints.bl, pointB: intersectionPoint});
+    if (newBLPoint) {
+      newBackPoints = __spreadProps(__spreadValues({}, backPoints), {
+        bl: newBLPoint,
+        tl: {
+          x: newBLPoint.x,
+          y: backPoints.tr.y
+        }
+      });
+    }
+  }
+  return {
+    backPoints: newBackPoints
+  };
+}
+function getBackPointsByFrontPoints({
+  frontPoints,
+  backPoints
+}) {
+  const {isLeftSide, frontHeight, backHeight} = getCuboidBasicInfo({frontPoints, backPoints});
+  let newBackPoints = __spreadValues({}, backPoints);
+  if (isLeftSide) {
+    newBackPoints = getPointsByBottomLeftPoint({coord: backPoints.bl, points: frontPoints});
+  } else {
+    newBackPoints = getPointsByBottomRightPoint({coord: backPoints.br, points: frontPoints});
+  }
+  if (frontHeight > backHeight) {
+    newBackPoints = getPointsByIntersection({frontPoints, backPoints}).backPoints;
+  }
+  return {frontPoints, backPoints: newBackPoints};
+}
+function getFrontPointsByBackPoints({
+  frontPoints,
+  backPoints
+}) {
+  const {isLeftSide, frontHeight, backHeight, frontWidth, backWidth} = getCuboidBasicInfo({
+    frontPoints,
+    backPoints
+  });
+  let newFrontPoints = __spreadValues({}, frontPoints);
+  let newBackPoints = backPoints;
+  if (isLeftSide || backWidth > frontWidth) {
+    newFrontPoints = getPointsByBottomLeftPoint({coord: frontPoints.bl, points: backPoints});
+  } else {
+    newFrontPoints = getPointsByBottomRightPoint({coord: frontPoints.br, points: backPoints});
+  }
+  if (frontHeight > backHeight) {
+    newFrontPoints.tl.y = frontPoints.tl.y;
+    newFrontPoints.tr.y = frontPoints.tr.y;
+    newBackPoints = getPointsByIntersection({backPoints, frontPoints}).backPoints;
+  }
+  if (frontWidth >= backWidth) {
+    Object.keys(newFrontPoints).forEach((key) => {
+      newFrontPoints[key].x = frontPoints[key].x;
+    });
+  }
+  return {
+    frontPoints: newFrontPoints,
+    backPoints: newBackPoints
+  };
+}
+function getCuboidAllSideLine({frontPoints, backPoints}) {
+  return [
+    {
+      p1: frontPoints.bl,
+      p2: backPoints.bl
+    },
+    {
+      p1: frontPoints.tl,
+      p2: backPoints.tl
+    },
+    {
+      p1: frontPoints.tr,
+      p2: backPoints.tr
+    },
+    {
+      p1: frontPoints.br,
+      p2: backPoints.br
+    }
+  ];
+}
+function getHighlightLines(cuboid) {
+  const {frontPoints, backPoints} = cuboid;
+  const {isLeftSide} = getCuboidBasicInfo(cuboid);
+  const frontLine = [
+    {
+      p1: frontPoints.tl,
+      p2: frontPoints.tr,
+      positions: [
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.TL
+        },
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.TR
+        }
+      ]
+    },
+    {
+      p1: frontPoints.tr,
+      p2: frontPoints.br,
+      plain: ECuboidPlain.Front,
+      positions: [
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.TR
+        },
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.BR
+        }
+      ]
+    },
+    {
+      p1: frontPoints.br,
+      p2: frontPoints.bl,
+      plain: ECuboidPlain.Front,
+      positions: [
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.BR
+        },
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.BL
+        }
+      ]
+    },
+    {
+      p1: frontPoints.bl,
+      p2: frontPoints.tl,
+      plain: ECuboidPlain.Front,
+      positions: [
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.BL
+        },
+        {
+          plain: ECuboidPlain.Front,
+          position: ECuboidPosition.TL
+        }
+      ]
+    }
+  ];
+  if (isLeftSide) {
+    return [
+      ...frontLine,
+      {
+        p1: backPoints.tl,
+        p2: backPoints.bl,
+        positions: [
+          {
+            plain: ECuboidPlain.Back,
+            position: ECuboidPosition.TL
+          },
+          {
+            plain: ECuboidPlain.Back,
+            position: ECuboidPosition.BL
+          }
+        ]
+      }
+    ];
+  }
+  return [
+    ...frontLine,
+    {
+      p1: backPoints.tr,
+      p2: backPoints.br,
+      positions: [
+        {
+          plain: ECuboidPlain.Back,
+          position: ECuboidPosition.TR
+        },
+        {
+          plain: ECuboidPlain.Back,
+          position: ECuboidPosition.BR
+        }
+      ]
+    }
+  ];
+}
+function getHighlightPoints(cuboid) {
+  const {backPoints} = cuboid;
+  const {isLeftSide} = getCuboidBasicInfo(cuboid);
+  const frontPointsData = Object.entries(cuboid.frontPoints).map(([position, point]) => ({
+    positions: [
+      {
+        plain: ECuboidPlain.Front,
+        position
+      }
+    ],
+    point
+  }));
+  if (isLeftSide) {
+    return [
+      {point: backPoints.tl, positions: [{position: ECuboidPosition.TL, plain: ECuboidPlain.Back}]},
+      {point: backPoints.bl, positions: [{position: ECuboidPosition.BL, plain: ECuboidPlain.Back}]},
+      ...frontPointsData
+    ];
+  }
+  return [
+    {point: backPoints.tr, positions: [{position: ECuboidPosition.TR, plain: ECuboidPlain.Back}]},
+    {point: backPoints.br, positions: [{position: ECuboidPosition.BR, plain: ECuboidPlain.Back}]},
+    ...frontPointsData
+  ];
+}
+function getCuboidHoverRange(cuboid) {
+  const {frontPoints, backPoints} = cuboid;
+  const {backCenter, frontCenter, frontHeight, frontWidth, backHeight, backWidth, isLeftSide} = getCuboidBasicInfo(cuboid);
+  const diffWidth = Math.abs(frontWidth - backWidth);
+  const diffHeight = Math.abs(frontHeight - backHeight);
+  const diffCenterX = Math.abs(frontCenter.x - backCenter.x);
+  const diffCenterY = Math.abs(frontCenter.y - backCenter.y);
+  const isOverX = diffCenterX > diffWidth;
+  const isOverY = diffCenterY > diffHeight;
+  const isNested = !(isOverX || isOverY);
+  if (isNested) {
+    return [frontPoints.tl, frontPoints.tr, frontPoints.br, frontPoints.bl];
+  }
+  if (isOverY && !isOverX) {
+    return [frontPoints.tl, backPoints.tl, backPoints.tr, frontPoints.tr, frontPoints.br, frontPoints.bl];
+  }
+  if (isOverX && !isOverY) {
+    if (isLeftSide) {
+      return [frontPoints.tl, frontPoints.tr, frontPoints.br, frontPoints.bl, backPoints.bl, backPoints.tl];
+    }
+    return [frontPoints.tl, frontPoints.tr, backPoints.tr, backPoints.br, frontPoints.br, frontPoints.bl];
+  }
+  if (isOverX && isOverY) {
+    if (isLeftSide) {
+      return [backPoints.tl, backPoints.tr, frontPoints.tr, frontPoints.br, frontPoints.bl, backPoints.bl];
+    }
+    return [frontPoints.tl, backPoints.tl, backPoints.tr, backPoints.br, frontPoints.br, frontPoints.bl];
+  }
+  return [];
+}
+function getNewPointsAfterOffset({
+  offset,
+  frontPoints,
+  backPoints,
+  positions
+}) {
+  let newFrontPoints = cloneDeep(frontPoints);
+  let newBackPoints = cloneDeep(backPoints);
+  if ((positions == null ? void 0 : positions.length) === 2) {
+    const isFrontPlain = positions.every((v) => v.plain === ECuboidPlain.Front);
+    const isBackPlain = !isFrontPlain;
+    const lineDirection = judgeCuboidLineIsRowOrColumn([positions[0], positions[1]]);
+    const forbidX = lineDirection === ECuboidLineDirection.Row;
+    const forbidY = lineDirection === ECuboidLineDirection.Column;
+    let newOffset = offset;
+    if (forbidX) {
+      newOffset = {
+        x: 0,
+        y: offset.y
+      };
+    }
+    if (forbidY) {
+      newOffset = {
+        y: 0,
+        x: offset.x
+      };
+    }
+    if (isFrontPlain) {
+      positions == null ? void 0 : positions.forEach(({position}) => {
+        const points = newFrontPoints;
+        const movePoint = points[position];
+        points[position] = {
+          x: movePoint.x + newOffset.x,
+          y: movePoint.y + newOffset.y
+        };
+      });
+      newFrontPoints = getMaxExternalQuadrilateral(newFrontPoints);
+      newBackPoints = getMaxExternalQuadrilateral(newBackPoints);
+    }
+    if (isBackPlain) {
+      Object.keys(newBackPoints).forEach((key) => {
+        newBackPoints[key] = {
+          x: newBackPoints[key].x + newOffset.x,
+          y: newBackPoints[key].y + newOffset.y
+        };
+      });
+    }
+    const getNewPlainPoints = isFrontPlain ? getBackPointsByFrontPoints : getFrontPointsByBackPoints;
+    const {frontPoints: newFrontPoints2, backPoints: newBackPoints2} = getNewPlainPoints({
+      frontPoints: newFrontPoints,
+      backPoints: newBackPoints
+    });
+    newFrontPoints = newFrontPoints2;
+    newBackPoints = newBackPoints2;
+  }
+  return {
+    frontPoints: newFrontPoints,
+    backPoints: newBackPoints
+  };
+}
+function getCuboidDragMove({
+  offset,
+  cuboid,
+  dragTarget,
+  positions
+}) {
+  const {frontPoints, backPoints} = cuboid;
+  switch (dragTarget) {
+    case EDragTarget.Cuboid: {
+      const newFrontPoints = Object.entries(frontPoints).reduce((acc, [key, point]) => {
+        return __spreadProps(__spreadValues({}, acc), {
+          [key]: {
+            x: point.x + offset.x,
+            y: point.y + offset.y
+          }
+        });
+      }, {});
+      const newBackPoints = Object.entries(backPoints).reduce((acc, [key, point]) => {
+        return __spreadProps(__spreadValues({}, acc), {
+          [key]: {
+            x: point.x + offset.x,
+            y: point.y + offset.y
+          }
+        });
+      }, {});
+      return __spreadProps(__spreadValues({}, cuboid), {
+        frontPoints: newFrontPoints,
+        backPoints: newBackPoints
+      });
+    }
+    case EDragTarget.Line: {
+      const {frontPoints: newFrontPoints, backPoints: newBackPoints} = getNewPointsAfterOffset({
+        offset,
+        frontPoints,
+        backPoints,
+        positions
+      });
+      return __spreadProps(__spreadValues({}, cuboid), {
+        frontPoints: newFrontPoints,
+        backPoints: newBackPoints
+      });
+    }
+    case EDragTarget.Point: {
+      if (!(positions == null ? void 0 : positions[0])) {
+        return;
+      }
+      const pointPosition = positions[0];
+      const isFrontPlain = pointPosition.plain === ECuboidPlain.Front;
+      const movePoints = isFrontPlain ? frontPoints : backPoints;
+      let movePoint = movePoints[pointPosition.position];
+      const diagonalPoint = movePoints[DIAGONAL_POINT[pointPosition.position]];
+      if (!movePoint || !diagonalPoint) {
+        return;
+      }
+      movePoint = Vector.add(movePoint, offset);
+      const newPlainsPoints = getPlainPointsByDiagonalPoints(movePoint, diagonalPoint);
+      const getNewPlainPoints = isFrontPlain ? getBackPointsByFrontPoints : getFrontPointsByBackPoints;
+      let payload = {
+        frontPoints,
+        backPoints: newPlainsPoints
+      };
+      if (isFrontPlain) {
+        payload = {
+          frontPoints: newPlainsPoints,
+          backPoints
+        };
+      }
+      const {frontPoints: newFrontPoints, backPoints: newBackPoints} = getNewPlainPoints(payload);
+      return __spreadProps(__spreadValues({}, cuboid), {
+        frontPoints: newFrontPoints,
+        backPoints: newBackPoints
+      });
+    }
+    default: {
+      console.error("No DragTarget");
+      break;
+    }
+  }
+}
+function getPointListsByDirection({
+  direction,
+  frontPoints,
+  backPoints
+}) {
+  if (direction && frontPoints && backPoints) {
+    let points = frontPoints;
+    switch (direction) {
+      case ECuboidDirection.Back:
+        points = backPoints;
+        break;
+      case ECuboidDirection.Left:
+        points = {
+          bl: backPoints.bl,
+          br: frontPoints.bl,
+          tl: backPoints.tl,
+          tr: frontPoints.tl
+        };
+        break;
+      case ECuboidDirection.Right:
+        points = {
+          bl: backPoints.br,
+          br: frontPoints.br,
+          tl: backPoints.tr,
+          tr: frontPoints.tr
+        };
+        break;
+      case ECuboidDirection.Top:
+        points = {
+          bl: backPoints.tl,
+          br: frontPoints.tl,
+          tl: backPoints.tr,
+          tr: frontPoints.tr
+        };
+        break;
+      default:
+        points = frontPoints;
+        break;
+    }
+    return AxisUtils.transformPlain2PointList(points);
+  }
+}
+function getToggleDirectionButtonOffset({
+  cuboid,
+  currentPos,
+  zoom
+}) {
+  const {frontPoints} = cuboid;
+  const toggleSize = {
+    width: 40,
+    height: 74
+  };
+  const frontPointsCenter = {
+    x: (frontPoints.bl.x + frontPoints.tl.x) / 2,
+    y: (frontPoints.bl.y + frontPoints.tl.y) / 2
+  };
+  const leftOffset = toggleSize.width + 10;
+  const topOffset = toggleSize.height / 2;
+  const moveCoordinate = {
+    x: frontPointsCenter.x,
+    y: frontPointsCenter.y
+  };
+  const coordinate = AxisUtils.getOffsetCoordinate(moveCoordinate, currentPos, zoom);
+  return {
+    left: coordinate.x - leftOffset,
+    top: coordinate.y - topOffset
+  };
+}
+function getCuboidTextAttributeOffset({
+  cuboid,
+  currentPos,
+  zoom,
+  leftOffset = 16,
+  topOffset = 2
+}) {
+  const {frontPoints} = cuboid;
+  const moveCoordinate = {
+    x: frontPoints.bl.x,
+    y: frontPoints.bl.y
+  };
+  const coordinate = AxisUtils.getOffsetCoordinate(moveCoordinate, currentPos, zoom);
+  return {
+    left: coordinate.x + leftOffset,
+    top: coordinate.y + topOffset
+  };
+}
+function isCuboidWithInLimits({cuboid, config}) {
+  const {minHeight, minWidth} = config;
+  const {width, height} = getPlanePointsBasicInfo(cuboid.frontPoints);
+  return width >= minWidth && height >= minHeight;
+}
+
+export { getBackPointsByFrontPoints, getCuboidAllSideLine, getCuboidBasicInfo, getCuboidDragMove, getCuboidHoverRange, getCuboidShowingSideLine, getCuboidTextAttributeOffset, getFrontPointsByBackPoints, getHighlightLines, getHighlightPoints, getMaxExternalQuadrilateral, getNewPointsAfterOffset, getPlainPointsByDiagonalPoints, getPlanePointsBasicInfo, getPointListsByDirection, getPointsByBottomLeftPoint, getPointsByBottomRightPoint, getPointsByIntersection, getToggleDirectionButtonOffset, isCuboidWithInLimits, judgeCuboidLineIsRowOrColumn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labelbee/lb-annotation",
-  "version": "1.13.0-alpha.5",
+  "version": "1.13.0-alpha.7",
   "description": "Annotation tool collection",
   "keywords": [
     "annotation",
@@ -98,5 +98,5 @@
     "lodash": "^4.17.20",
     "three": ">=0.141.0"
   },
-  "gitHead": "4b65cf4fc97a570f3e73b7654450e334b8210a4e"
+  "gitHead": "95a39c945895bb420d8ab7485e7a49176dae2a76"
 }