@labelbee/lb-annotation 1.14.0-alpha.3 → 1.14.0-alpha.6

package/dist/utils/tool/CuboidUtils.js

@@ -1,704 +1 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _ = require('lodash');
-var annotation = require('../../constant/annotation.js');
-var AxisUtils = require('./AxisUtils.js');
-var VectorUtils = require('../VectorUtils.js');
-var LineToolUtils = require('./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 (annotation.CUBOID_ROW[firstPosition.position] === secondPosition.position) {
-    return annotation.ECuboidLineDirection.Row;
-  }
-  if (annotation.CUBOID_COLUMN[firstPosition.position] === secondPosition.position) {
-    return annotation.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["default"].lineIntersection({pointA: sideLine.bottom.p1, pointB: sideLine.bottom.p2}, {pointA: sideLine.top.p1, pointB: sideLine.top.p2});
-  if (isLeftSide) {
-    const newBRPoint = LineToolUtils["default"].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["default"].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: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.TL
-        },
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.TR
-        }
-      ]
-    },
-    {
-      p1: frontPoints.tr,
-      p2: frontPoints.br,
-      plain: annotation.ECuboidPlain.Front,
-      positions: [
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.TR
-        },
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.BR
-        }
-      ]
-    },
-    {
-      p1: frontPoints.br,
-      p2: frontPoints.bl,
-      plain: annotation.ECuboidPlain.Front,
-      positions: [
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.BR
-        },
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.BL
-        }
-      ]
-    },
-    {
-      p1: frontPoints.bl,
-      p2: frontPoints.tl,
-      plain: annotation.ECuboidPlain.Front,
-      positions: [
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.BL
-        },
-        {
-          plain: annotation.ECuboidPlain.Front,
-          position: annotation.ECuboidPosition.TL
-        }
-      ]
-    }
-  ];
-  if (isLeftSide) {
-    return [
-      ...frontLine,
-      {
-        p1: backPoints.tl,
-        p2: backPoints.bl,
-        positions: [
-          {
-            plain: annotation.ECuboidPlain.Back,
-            position: annotation.ECuboidPosition.TL
-          },
-          {
-            plain: annotation.ECuboidPlain.Back,
-            position: annotation.ECuboidPosition.BL
-          }
-        ]
-      }
-    ];
-  }
-  return [
-    ...frontLine,
-    {
-      p1: backPoints.tr,
-      p2: backPoints.br,
-      positions: [
-        {
-          plain: annotation.ECuboidPlain.Back,
-          position: annotation.ECuboidPosition.TR
-        },
-        {
-          plain: annotation.ECuboidPlain.Back,
-          position: annotation.ECuboidPosition.BR
-        }
-      ]
-    }
-  ];
-}
-function getHighlightPoints(cuboid) {
-  const {backPoints} = cuboid;
-  const {isLeftSide} = getCuboidBasicInfo(cuboid);
-  const frontPointsData = Object.entries(cuboid.frontPoints).map(([position, point]) => ({
-    positions: [
-      {
-        plain: annotation.ECuboidPlain.Front,
-        position
-      }
-    ],
-    point
-  }));
-  if (isLeftSide) {
-    return [
-      {point: backPoints.tl, positions: [{position: annotation.ECuboidPosition.TL, plain: annotation.ECuboidPlain.Back}]},
-      {point: backPoints.bl, positions: [{position: annotation.ECuboidPosition.BL, plain: annotation.ECuboidPlain.Back}]},
-      ...frontPointsData
-    ];
-  }
-  return [
-    {point: backPoints.tr, positions: [{position: annotation.ECuboidPosition.TR, plain: annotation.ECuboidPlain.Back}]},
-    {point: backPoints.br, positions: [{position: annotation.ECuboidPosition.BR, plain: annotation.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 === annotation.ECuboidPlain.Front);
-    const isBackPlain = !isFrontPlain;
-    const lineDirection = judgeCuboidLineIsRowOrColumn([positions[0], positions[1]]);
-    const forbidX = lineDirection === annotation.ECuboidLineDirection.Row;
-    const forbidY = lineDirection === annotation.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 moveCuboidByCuboid({offset, cuboid}) {
-  const {frontPoints, backPoints} = 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 {
-    frontPoints: newFrontPoints,
-    backPoints: newBackPoints
-  };
-}
-function moveCuboidByLine({
-  offset,
-  cuboid,
-  positions
-}) {
-  const {frontPoints, backPoints} = cuboid;
-  return getNewPointsAfterOffset({
-    offset,
-    frontPoints,
-    backPoints,
-    positions
-  });
-}
-function moveCuboidByPoints({
-  offset,
-  cuboid,
-  positions
-}) {
-  if (!(positions == null ? void 0 : positions[0])) {
-    return;
-  }
-  const {frontPoints, backPoints} = cuboid;
-  const pointPosition = positions[0];
-  const isFrontPlain = pointPosition.plain === annotation.ECuboidPlain.Front;
-  const movePoints = isFrontPlain ? frontPoints : backPoints;
-  let movePoint = movePoints[pointPosition.position];
-  const diagonalPoint = movePoints[annotation.DIAGONAL_POINT[pointPosition.position]];
-  if (!movePoint || !diagonalPoint) {
-    return;
-  }
-  movePoint = VectorUtils.add(movePoint, offset);
-  const newPlainsPoints = getPlainPointsByDiagonalPoints(movePoint, diagonalPoint);
-  const getNewPlainPoints = isFrontPlain ? getBackPointsByFrontPoints : getFrontPointsByBackPoints;
-  let payload = {
-    frontPoints,
-    backPoints: newPlainsPoints
-  };
-  if (isFrontPlain) {
-    payload = {
-      frontPoints: newPlainsPoints,
-      backPoints
-    };
-  }
-  return getNewPlainPoints(payload);
-}
-function getCuboidDragMove({
-  offset,
-  cuboid,
-  dragTarget,
-  positions
-}) {
-  switch (dragTarget) {
-    case annotation.EDragTarget.Cuboid: {
-      const newCuboidPoints = moveCuboidByCuboid({offset, cuboid});
-      return __spreadValues(__spreadValues({}, cuboid), newCuboidPoints);
-    }
-    case annotation.EDragTarget.Line: {
-      const newCuboidPoints = moveCuboidByLine({offset, cuboid, positions});
-      return __spreadValues(__spreadValues({}, cuboid), newCuboidPoints);
-    }
-    case annotation.EDragTarget.Point: {
-      const newCuboidPoints = moveCuboidByPoints({cuboid, offset, positions});
-      if (newCuboidPoints) {
-        return __spreadValues(__spreadValues({}, cuboid), newCuboidPoints);
-      }
-      break;
-    }
-    default: {
-      console.error("No DragTarget");
-      break;
-    }
-  }
-}
-function getPointListsByDirection({
-  direction,
-  frontPoints,
-  backPoints
-}) {
-  if (direction && frontPoints && backPoints) {
-    let points = frontPoints;
-    switch (direction) {
-      case annotation.ECuboidDirection.Back:
-        points = backPoints;
-        break;
-      case annotation.ECuboidDirection.Left:
-        points = {
-          bl: backPoints.bl,
-          br: frontPoints.bl,
-          tl: backPoints.tl,
-          tr: frontPoints.tl
-        };
-        break;
-      case annotation.ECuboidDirection.Right:
-        points = {
-          bl: backPoints.br,
-          br: frontPoints.br,
-          tl: backPoints.tr,
-          tr: frontPoints.tr
-        };
-        break;
-      case annotation.ECuboidDirection.Top:
-        points = {
-          bl: backPoints.tl,
-          br: frontPoints.tl,
-          tl: backPoints.tr,
-          tr: frontPoints.tr
-        };
-        break;
-      default:
-        points = frontPoints;
-        break;
-    }
-    return AxisUtils["default"].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["default"].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["default"].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;
-}
-
-exports.getBackPointsByFrontPoints = getBackPointsByFrontPoints;
-exports.getCuboidAllSideLine = getCuboidAllSideLine;
-exports.getCuboidBasicInfo = getCuboidBasicInfo;
-exports.getCuboidDragMove = getCuboidDragMove;
-exports.getCuboidHoverRange = getCuboidHoverRange;
-exports.getCuboidShowingSideLine = getCuboidShowingSideLine;
-exports.getCuboidTextAttributeOffset = getCuboidTextAttributeOffset;
-exports.getFrontPointsByBackPoints = getFrontPointsByBackPoints;
-exports.getHighlightLines = getHighlightLines;
-exports.getHighlightPoints = getHighlightPoints;
-exports.getMaxExternalQuadrilateral = getMaxExternalQuadrilateral;
-exports.getNewPointsAfterOffset = getNewPointsAfterOffset;
-exports.getPlainPointsByDiagonalPoints = getPlainPointsByDiagonalPoints;
-exports.getPlanePointsBasicInfo = getPlanePointsBasicInfo;
-exports.getPointListsByDirection = getPointListsByDirection;
-exports.getPointsByBottomLeftPoint = getPointsByBottomLeftPoint;
-exports.getPointsByBottomRightPoint = getPointsByBottomRightPoint;
-exports.getPointsByIntersection = getPointsByIntersection;
-exports.getToggleDirectionButtonOffset = getToggleDirectionButtonOffset;
-exports.isCuboidWithInLimits = isCuboidWithInLimits;
-exports.judgeCuboidLineIsRowOrColumn = judgeCuboidLineIsRowOrColumn;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var _=require("lodash"),annotation=require("../../constant/annotation.js"),AxisUtils=require("./AxisUtils.js"),VectorUtils=require("../VectorUtils.js"),LineToolUtils=require("./LineToolUtils.js"),__defProp=Object.defineProperty,__defProps=Object.defineProperties,__getOwnPropDescs=Object.getOwnPropertyDescriptors,__getOwnPropSymbols=Object.getOwnPropertySymbols,__hasOwnProp=Object.prototype.hasOwnProperty,__propIsEnum=Object.prototype.propertyIsEnumerable,__defNormalProp=(i,t,n)=>t in i?__defProp(i,t,{enumerable:!0,configurable:!0,writable:!0,value:n}):i[t]=n,__spreadValues=(i,t)=>{for(var n in t||(t={}))__hasOwnProp.call(t,n)&&__defNormalProp(i,n,t[n]);if(__getOwnPropSymbols)for(var n of __getOwnPropSymbols(t))__propIsEnum.call(t,n)&&__defNormalProp(i,n,t[n]);return i},__spreadProps=(i,t)=>__defProps(i,__getOwnPropDescs(t));function getPlanePointsBasicInfo({tr:i,tl:t,br:n}){return{width:Math.abs(i.x-t.x),height:Math.abs(n.y-i.y),centerPoints:{x:(t.x+n.x)/2,y:(t.y+n.y)/2}}}function getCuboidBasicInfo({frontPoints:i,backPoints:t}){const{width:n,height:o,centerPoints:r}=getPlanePointsBasicInfo(i),{width:e,height:s,centerPoints:l}=getPlanePointsBasicInfo(t);return{frontCenter:r,backCenter:l,frontWidth:n,frontHeight:o,backWidth:e,backHeight:s,isLeftSide:l.x<r.x}}function getPlainPointsByDiagonalPoints(i,t){return{tl:{x:Math.min(i.x,t.x),y:Math.min(i.y,t.y)},tr:{x:Math.max(i.x,t.x),y:Math.min(i.y,t.y)},bl:{x:Math.min(i.x,t.x),y:Math.max(i.y,t.y)},br:{x:Math.max(i.x,t.x),y:Math.max(i.y,t.y)}}}function getMaxExternalQuadrilateral(i){const t=Object.values(i).reduce((e,s)=>s.x<e?s.x:e,Number.MAX_SAFE_INTEGER),n=Object.values(i).reduce((e,s)=>s.x>e?s.x:e,0),o=Object.values(i).reduce((e,s)=>s.y<e?s.y:e,Number.MAX_SAFE_INTEGER),r=Object.values(i).reduce((e,s)=>s.y>e?s.y:e,0);return{tl:{x:t,y:o},tr:{x:n,y:o},bl:{x:t,y:r},br:{x:n,y:r}}}function judgeCuboidLineIsRowOrColumn(i){const[t,n]=i;if(annotation.CUBOID_ROW[t.position]===n.position)return annotation.ECuboidLineDirection.Row;if(annotation.CUBOID_COLUMN[t.position]===n.position)return annotation.ECuboidLineDirection.Column}function getPointsByBottomRightPoint({coord:i,points:t}){const{width:n,height:o}=getPlanePointsBasicInfo(t);return{br:i,tr:{x:i.x,y:i.y-o},tl:{x:i.x-n,y:i.y-o},bl:{x:i.x-n,y:i.y}}}function getPointsByBottomLeftPoint({coord:i,points:t}){const{width:n,height:o}=getPlanePointsBasicInfo(t);return{bl:i,tr:{x:i.x+n,y:i.y-o},tl:{x:i.x,y:i.y-o},br:{x:i.x+n,y:i.y}}}function getCuboidShowingSideLine({frontPoints:i,backPoints:t}){const{isLeftSide:n}=getCuboidBasicInfo({frontPoints:i,backPoints:t});return n?{top:{p1:i.tl,p2:t.tl},bottom:{p1:i.bl,p2:t.bl}}:{top:{p1:i.tr,p2:t.tr},bottom:{p1:i.br,p2:t.br}}}function getPointsByIntersection({frontPoints:i,backPoints:t}){const{isLeftSide:n}=getCuboidBasicInfo({frontPoints:i,backPoints:t});let o=__spreadValues({},t);const r=getCuboidShowingSideLine({frontPoints:i,backPoints:t}),e=LineToolUtils.default.lineIntersection({pointA:r.bottom.p1,pointB:r.bottom.p2},{pointA:r.top.p1,pointB:r.top.p2});if(n){const s=LineToolUtils.default.lineIntersection({pointA:t.bl,pointB:t.br},{pointA:i.br,pointB:e});s&&(o=__spreadProps(__spreadValues({},t),{br:s,tr:{x:s.x,y:t.tl.y}}))}else{const s=LineToolUtils.default.lineIntersection({pointA:t.bl,pointB:t.br},{pointA:i.bl,pointB:e});s&&(o=__spreadProps(__spreadValues({},t),{bl:s,tl:{x:s.x,y:t.tr.y}}))}return{backPoints:o}}function getBackPointsByFrontPoints({frontPoints:i,backPoints:t}){const{isLeftSide:n,frontHeight:o,backHeight:r}=getCuboidBasicInfo({frontPoints:i,backPoints:t});let e=__spreadValues({},t);return n?e=getPointsByBottomLeftPoint({coord:t.bl,points:i}):e=getPointsByBottomRightPoint({coord:t.br,points:i}),o>r&&(e=getPointsByIntersection({frontPoints:i,backPoints:t}).backPoints),{frontPoints:i,backPoints:e}}function getFrontPointsByBackPoints({frontPoints:i,backPoints:t}){const{isLeftSide:n,frontHeight:o,backHeight:r,frontWidth:e,backWidth:s}=getCuboidBasicInfo({frontPoints:i,backPoints:t});let l=__spreadValues({},i),a=t;return n||s>e?l=getPointsByBottomLeftPoint({coord:i.bl,points:t}):l=getPointsByBottomRightPoint({coord:i.br,points:t}),o>r&&(l.tl.y=i.tl.y,l.tr.y=i.tr.y,a=getPointsByIntersection({backPoints:t,frontPoints:i}).backPoints),e>=s&&Object.keys(l).forEach(u=>{l[u].x=i[u].x}),{frontPoints:l,backPoints:a}}function getCuboidAllSideLine({frontPoints:i,backPoints:t}){return[{p1:i.bl,p2:t.bl},{p1:i.tl,p2:t.tl},{p1:i.tr,p2:t.tr},{p1:i.br,p2:t.br}]}function getHighlightLines(i){const{frontPoints:t,backPoints:n}=i,{isLeftSide:o}=getCuboidBasicInfo(i),r=[{p1:t.tl,p2:t.tr,positions:[{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.TL},{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.TR}]},{p1:t.tr,p2:t.br,plain:annotation.ECuboidPlain.Front,positions:[{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.TR},{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.BR}]},{p1:t.br,p2:t.bl,plain:annotation.ECuboidPlain.Front,positions:[{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.BR},{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.BL}]},{p1:t.bl,p2:t.tl,plain:annotation.ECuboidPlain.Front,positions:[{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.BL},{plain:annotation.ECuboidPlain.Front,position:annotation.ECuboidPosition.TL}]}];return o?[...r,{p1:n.tl,p2:n.bl,positions:[{plain:annotation.ECuboidPlain.Back,position:annotation.ECuboidPosition.TL},{plain:annotation.ECuboidPlain.Back,position:annotation.ECuboidPosition.BL}]}]:[...r,{p1:n.tr,p2:n.br,positions:[{plain:annotation.ECuboidPlain.Back,position:annotation.ECuboidPosition.TR},{plain:annotation.ECuboidPlain.Back,position:annotation.ECuboidPosition.BR}]}]}function getHighlightPoints(i){const{backPoints:t}=i,{isLeftSide:n}=getCuboidBasicInfo(i),o=Object.entries(i.frontPoints).map(([r,e])=>({positions:[{plain:annotation.ECuboidPlain.Front,position:r}],point:e}));return n?[{point:t.tl,positions:[{position:annotation.ECuboidPosition.TL,plain:annotation.ECuboidPlain.Back}]},{point:t.bl,positions:[{position:annotation.ECuboidPosition.BL,plain:annotation.ECuboidPlain.Back}]},...o]:[{point:t.tr,positions:[{position:annotation.ECuboidPosition.TR,plain:annotation.ECuboidPlain.Back}]},{point:t.br,positions:[{position:annotation.ECuboidPosition.BR,plain:annotation.ECuboidPlain.Back}]},...o]}function getCuboidHoverRange(i){const{frontPoints:t,backPoints:n}=i,{backCenter:o,frontCenter:r,frontHeight:e,frontWidth:s,backHeight:l,backWidth:a,isLeftSide:u}=getCuboidBasicInfo(i),p=Math.abs(s-a),c=Math.abs(e-l),d=Math.abs(r.x-o.x),x=Math.abs(r.y-o.y),f=d>p,b=x>c;return f||b?b&&!f?[t.tl,n.tl,n.tr,t.tr,t.br,t.bl]:f&&!b?u?[t.tl,t.tr,t.br,t.bl,n.bl,n.tl]:[t.tl,t.tr,n.tr,n.br,t.br,t.bl]:f&&b?u?[n.tl,n.tr,t.tr,t.br,t.bl,n.bl]:[t.tl,n.tl,n.tr,n.br,t.br,t.bl]:[]:[t.tl,t.tr,t.br,t.bl]}function getNewPointsAfterOffset({offset:i,frontPoints:t,backPoints:n,positions:o}){let r=_.cloneDeep(t),e=_.cloneDeep(n);if((o==null?void 0:o.length)===2){const s=o.every(b=>b.plain===annotation.ECuboidPlain.Front),l=!s,a=judgeCuboidLineIsRowOrColumn([o[0],o[1]]),u=a===annotation.ECuboidLineDirection.Row,p=a===annotation.ECuboidLineDirection.Column;let c=i;u&&(c={x:0,y:i.y}),p&&(c={y:0,x:i.x}),s&&(o==null||o.forEach(({position:b})=>{const g=r,y=g[b];g[b]={x:y.x+c.x,y:y.y+c.y}}),r=getMaxExternalQuadrilateral(r),e=getMaxExternalQuadrilateral(e)),l&&Object.keys(e).forEach(b=>{e[b]={x:e[b].x+c.x,y:e[b].y+c.y}});const d=s?getBackPointsByFrontPoints:getFrontPointsByBackPoints,{frontPoints:x,backPoints:f}=d({frontPoints:r,backPoints:e});r=x,e=f}return{frontPoints:r,backPoints:e}}function moveCuboidByCuboid({offset:i,cuboid:t}){const{frontPoints:n,backPoints:o}=t,r=Object.entries(n).reduce((s,[l,a])=>__spreadProps(__spreadValues({},s),{[l]:{x:a.x+i.x,y:a.y+i.y}}),{}),e=Object.entries(o).reduce((s,[l,a])=>__spreadProps(__spreadValues({},s),{[l]:{x:a.x+i.x,y:a.y+i.y}}),{});return{frontPoints:r,backPoints:e}}function moveCuboidByLine({offset:i,cuboid:t,positions:n}){const{frontPoints:o,backPoints:r}=t;return getNewPointsAfterOffset({offset:i,frontPoints:o,backPoints:r,positions:n})}function moveCuboidByPoints({offset:i,cuboid:t,positions:n}){if(!(n==null?void 0:n[0]))return;const{frontPoints:o,backPoints:r}=t,e=n[0],s=e.plain===annotation.ECuboidPlain.Front,l=s?o:r;let a=l[e.position];const u=l[annotation.DIAGONAL_POINT[e.position]];if(!a||!u)return;a=VectorUtils.add(a,i);const p=getPlainPointsByDiagonalPoints(a,u),c=s?getBackPointsByFrontPoints:getFrontPointsByBackPoints;let d={frontPoints:o,backPoints:p};return s&&(d={frontPoints:p,backPoints:r}),c(d)}function getCuboidDragMove({offset:i,cuboid:t,dragTarget:n,positions:o}){switch(n){case annotation.EDragTarget.Cuboid:{const r=moveCuboidByCuboid({offset:i,cuboid:t});return __spreadValues(__spreadValues({},t),r)}case annotation.EDragTarget.Line:{const r=moveCuboidByLine({offset:i,cuboid:t,positions:o});return __spreadValues(__spreadValues({},t),r)}case annotation.EDragTarget.Point:{const r=moveCuboidByPoints({cuboid:t,offset:i,positions:o});if(r)return __spreadValues(__spreadValues({},t),r);break}default:{console.error("No DragTarget");break}}}function getPointListsByDirection({direction:i,frontPoints:t,backPoints:n}){if(i&&t&&n){let o=t;switch(i){case annotation.ECuboidDirection.Back:o=n;break;case annotation.ECuboidDirection.Left:o={bl:n.bl,br:t.bl,tl:n.tl,tr:t.tl};break;case annotation.ECuboidDirection.Right:o={bl:n.br,br:t.br,tl:n.tr,tr:t.tr};break;case annotation.ECuboidDirection.Top:o={bl:n.tl,br:t.tl,tl:n.tr,tr:t.tr};break;default:o=t;break}return AxisUtils.default.transformPlain2PointList(o)}}function getToggleDirectionButtonOffset({cuboid:i,currentPos:t,zoom:n}){const{frontPoints:o}=i,r={width:40,height:74},e={x:(o.bl.x+o.tl.x)/2,y:(o.bl.y+o.tl.y)/2},s=r.width+10,l=r.height/2,a={x:e.x,y:e.y},u=AxisUtils.default.getOffsetCoordinate(a,t,n);return{left:u.x-s,top:u.y-l}}function getCuboidTextAttributeOffset({cuboid:i,currentPos:t,zoom:n,leftOffset:o=16,topOffset:r=2}){const{frontPoints:e}=i,s={x:e.bl.x,y:e.bl.y},l=AxisUtils.default.getOffsetCoordinate(s,t,n);return{left:l.x+o,top:l.y+r}}function isCuboidWithInLimits({cuboid:i,config:t}){const{minHeight:n,minWidth:o}=t,{width:r,height:e}=getPlanePointsBasicInfo(i.frontPoints);return r>=o&&e>=n}exports.getBackPointsByFrontPoints=getBackPointsByFrontPoints,exports.getCuboidAllSideLine=getCuboidAllSideLine,exports.getCuboidBasicInfo=getCuboidBasicInfo,exports.getCuboidDragMove=getCuboidDragMove,exports.getCuboidHoverRange=getCuboidHoverRange,exports.getCuboidShowingSideLine=getCuboidShowingSideLine,exports.getCuboidTextAttributeOffset=getCuboidTextAttributeOffset,exports.getFrontPointsByBackPoints=getFrontPointsByBackPoints,exports.getHighlightLines=getHighlightLines,exports.getHighlightPoints=getHighlightPoints,exports.getMaxExternalQuadrilateral=getMaxExternalQuadrilateral,exports.getNewPointsAfterOffset=getNewPointsAfterOffset,exports.getPlainPointsByDiagonalPoints=getPlainPointsByDiagonalPoints,exports.getPlanePointsBasicInfo=getPlanePointsBasicInfo,exports.getPointListsByDirection=getPointListsByDirection,exports.getPointsByBottomLeftPoint=getPointsByBottomLeftPoint,exports.getPointsByBottomRightPoint=getPointsByBottomRightPoint,exports.getPointsByIntersection=getPointsByIntersection,exports.getToggleDirectionButtonOffset=getToggleDirectionButtonOffset,exports.isCuboidWithInLimits=isCuboidWithInLimits,exports.judgeCuboidLineIsRowOrColumn=judgeCuboidLineIsRowOrColumn;