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

package/es/utils/tool/CuboidUtils.js

@@ -1,680 +1 @@
-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 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 === 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
-    };
-  }
-  return getNewPlainPoints(payload);
-}
-function getCuboidDragMove({
-  offset,
-  cuboid,
-  dragTarget,
-  positions
-}) {
-  switch (dragTarget) {
-    case EDragTarget.Cuboid: {
-      const newCuboidPoints = moveCuboidByCuboid({offset, cuboid});
-      return __spreadValues(__spreadValues({}, cuboid), newCuboidPoints);
-    }
-    case EDragTarget.Line: {
-      const newCuboidPoints = moveCuboidByLine({offset, cuboid, positions});
-      return __spreadValues(__spreadValues({}, cuboid), newCuboidPoints);
-    }
-    case 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 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 };
+import{cloneDeep as D}from"lodash";import{ECuboidPlain as a,ECuboidPosition as p,ECuboidDirection as B,EDragTarget as L,DIAGONAL_POINT as U,ECuboidLineDirection as P,CUBOID_ROW as X,CUBOID_COLUMN as Y}from"../../constant/annotation.js";import v from"./AxisUtils.js";import G from"../VectorUtils.js";import _ from"./LineToolUtils.js";var V=Object.defineProperty,z=Object.defineProperties,Q=Object.getOwnPropertyDescriptors,I=Object.getOwnPropertySymbols,q=Object.prototype.hasOwnProperty,J=Object.prototype.propertyIsEnumerable,S=(n,t,i)=>t in n?V(n,t,{enumerable:!0,configurable:!0,writable:!0,value:i}):n[t]=i,f=(n,t)=>{for(var i in t||(t={}))q.call(t,i)&&S(n,i,t[i]);if(I)for(var i of I(t))J.call(t,i)&&S(n,i,t[i]);return n},w=(n,t)=>z(n,Q(t));function m({tr:n,tl:t,br:i}){return{width:Math.abs(n.x-t.x),height:Math.abs(i.y-n.y),centerPoints:{x:(t.x+i.x)/2,y:(t.y+i.y)/2}}}function x({frontPoints:n,backPoints:t}){const{width:i,height:e,centerPoints:r}=m(n),{width:o,height:s,centerPoints:l}=m(t);return{frontCenter:r,backCenter:l,frontWidth:i,frontHeight:e,backWidth:o,backHeight:s,isLeftSide:l.x<r.x}}function k(n,t){return{tl:{x:Math.min(n.x,t.x),y:Math.min(n.y,t.y)},tr:{x:Math.max(n.x,t.x),y:Math.min(n.y,t.y)},bl:{x:Math.min(n.x,t.x),y:Math.max(n.y,t.y)},br:{x:Math.max(n.x,t.x),y:Math.max(n.y,t.y)}}}function F(n){const t=Object.values(n).reduce((o,s)=>s.x<o?s.x:o,Number.MAX_SAFE_INTEGER),i=Object.values(n).reduce((o,s)=>s.x>o?s.x:o,0),e=Object.values(n).reduce((o,s)=>s.y<o?s.y:o,Number.MAX_SAFE_INTEGER),r=Object.values(n).reduce((o,s)=>s.y>o?s.y:o,0);return{tl:{x:t,y:e},tr:{x:i,y:e},bl:{x:t,y:r},br:{x:i,y:r}}}function N(n){const[t,i]=n;if(X[t.position]===i.position)return P.Row;if(Y[t.position]===i.position)return P.Column}function M({coord:n,points:t}){const{width:i,height:e}=m(t);return{br:n,tr:{x:n.x,y:n.y-e},tl:{x:n.x-i,y:n.y-e},bl:{x:n.x-i,y:n.y}}}function j({coord:n,points:t}){const{width:i,height:e}=m(t);return{bl:n,tr:{x:n.x+i,y:n.y-e},tl:{x:n.x,y:n.y-e},br:{x:n.x+i,y:n.y}}}function H({frontPoints:n,backPoints:t}){const{isLeftSide:i}=x({frontPoints:n,backPoints:t});return i?{top:{p1:n.tl,p2:t.tl},bottom:{p1:n.bl,p2:t.bl}}:{top:{p1:n.tr,p2:t.tr},bottom:{p1:n.br,p2:t.br}}}function R({frontPoints:n,backPoints:t}){const{isLeftSide:i}=x({frontPoints:n,backPoints:t});let e=f({},t);const r=H({frontPoints:n,backPoints:t}),o=_.lineIntersection({pointA:r.bottom.p1,pointB:r.bottom.p2},{pointA:r.top.p1,pointB:r.top.p2});if(i){const s=_.lineIntersection({pointA:t.bl,pointB:t.br},{pointA:n.br,pointB:o});s&&(e=w(f({},t),{br:s,tr:{x:s.x,y:t.tl.y}}))}else{const s=_.lineIntersection({pointA:t.bl,pointB:t.br},{pointA:n.bl,pointB:o});s&&(e=w(f({},t),{bl:s,tl:{x:s.x,y:t.tr.y}}))}return{backPoints:e}}function T({frontPoints:n,backPoints:t}){const{isLeftSide:i,frontHeight:e,backHeight:r}=x({frontPoints:n,backPoints:t});let o=f({},t);return i?o=j({coord:t.bl,points:n}):o=M({coord:t.br,points:n}),e>r&&(o=R({frontPoints:n,backPoints:t}).backPoints),{frontPoints:n,backPoints:o}}function A({frontPoints:n,backPoints:t}){const{isLeftSide:i,frontHeight:e,backHeight:r,frontWidth:o,backWidth:s}=x({frontPoints:n,backPoints:t});let l=f({},n),c=t;return i||s>o?l=j({coord:n.bl,points:t}):l=M({coord:n.br,points:t}),e>r&&(l.tl.y=n.tl.y,l.tr.y=n.tr.y,c=R({backPoints:t,frontPoints:n}).backPoints),o>=s&&Object.keys(l).forEach(u=>{l[u].x=n[u].x}),{frontPoints:l,backPoints:c}}function K({frontPoints:n,backPoints:t}){return[{p1:n.bl,p2:t.bl},{p1:n.tl,p2:t.tl},{p1:n.tr,p2:t.tr},{p1:n.br,p2:t.br}]}function Z(n){const{frontPoints:t,backPoints:i}=n,{isLeftSide:e}=x(n),r=[{p1:t.tl,p2:t.tr,positions:[{plain:a.Front,position:p.TL},{plain:a.Front,position:p.TR}]},{p1:t.tr,p2:t.br,plain:a.Front,positions:[{plain:a.Front,position:p.TR},{plain:a.Front,position:p.BR}]},{p1:t.br,p2:t.bl,plain:a.Front,positions:[{plain:a.Front,position:p.BR},{plain:a.Front,position:p.BL}]},{p1:t.bl,p2:t.tl,plain:a.Front,positions:[{plain:a.Front,position:p.BL},{plain:a.Front,position:p.TL}]}];return e?[...r,{p1:i.tl,p2:i.bl,positions:[{plain:a.Back,position:p.TL},{plain:a.Back,position:p.BL}]}]:[...r,{p1:i.tr,p2:i.br,positions:[{plain:a.Back,position:p.TR},{plain:a.Back,position:p.BR}]}]}function $(n){const{backPoints:t}=n,{isLeftSide:i}=x(n),e=Object.entries(n.frontPoints).map(([r,o])=>({positions:[{plain:a.Front,position:r}],point:o}));return i?[{point:t.tl,positions:[{position:p.TL,plain:a.Back}]},{point:t.bl,positions:[{position:p.BL,plain:a.Back}]},...e]:[{point:t.tr,positions:[{position:p.TR,plain:a.Back}]},{point:t.br,positions:[{position:p.BR,plain:a.Back}]},...e]}function tt(n){const{frontPoints:t,backPoints:i}=n,{backCenter:e,frontCenter:r,frontHeight:o,frontWidth:s,backHeight:l,backWidth:c,isLeftSide:u}=x(n),h=Math.abs(s-c),y=Math.abs(o-l),g=Math.abs(r.x-e.x),O=Math.abs(r.y-e.y),d=g>h,b=O>y;return d||b?b&&!d?[t.tl,i.tl,i.tr,t.tr,t.br,t.bl]:d&&!b?u?[t.tl,t.tr,t.br,t.bl,i.bl,i.tl]:[t.tl,t.tr,i.tr,i.br,t.br,t.bl]:d&&b?u?[i.tl,i.tr,t.tr,t.br,t.bl,i.bl]:[t.tl,i.tl,i.tr,i.br,t.br,t.bl]:[]:[t.tl,t.tr,t.br,t.bl]}function W({offset:n,frontPoints:t,backPoints:i,positions:e}){let r=D(t),o=D(i);if((e==null?void 0:e.length)===2){const s=e.every(b=>b.plain===a.Front),l=!s,c=N([e[0],e[1]]),u=c===P.Row,h=c===P.Column;let y=n;u&&(y={x:0,y:n.y}),h&&(y={y:0,x:n.x}),s&&(e==null||e.forEach(({position:b})=>{const C=r,E=C[b];C[b]={x:E.x+y.x,y:E.y+y.y}}),r=F(r),o=F(o)),l&&Object.keys(o).forEach(b=>{o[b]={x:o[b].x+y.x,y:o[b].y+y.y}});const g=s?T:A,{frontPoints:O,backPoints:d}=g({frontPoints:r,backPoints:o});r=O,o=d}return{frontPoints:r,backPoints:o}}function nt({offset:n,cuboid:t}){const{frontPoints:i,backPoints:e}=t,r=Object.entries(i).reduce((s,[l,c])=>w(f({},s),{[l]:{x:c.x+n.x,y:c.y+n.y}}),{}),o=Object.entries(e).reduce((s,[l,c])=>w(f({},s),{[l]:{x:c.x+n.x,y:c.y+n.y}}),{});return{frontPoints:r,backPoints:o}}function it({offset:n,cuboid:t,positions:i}){const{frontPoints:e,backPoints:r}=t;return W({offset:n,frontPoints:e,backPoints:r,positions:i})}function et({offset:n,cuboid:t,positions:i}){if(!(i==null?void 0:i[0]))return;const{frontPoints:e,backPoints:r}=t,o=i[0],s=o.plain===a.Front,l=s?e:r;let c=l[o.position];const u=l[U[o.position]];if(!c||!u)return;c=G.add(c,n);const h=k(c,u),y=s?T:A;let g={frontPoints:e,backPoints:h};return s&&(g={frontPoints:h,backPoints:r}),y(g)}function ot({offset:n,cuboid:t,dragTarget:i,positions:e}){switch(i){case L.Cuboid:{const r=nt({offset:n,cuboid:t});return f(f({},t),r)}case L.Line:{const r=it({offset:n,cuboid:t,positions:e});return f(f({},t),r)}case L.Point:{const r=et({cuboid:t,offset:n,positions:e});if(r)return f(f({},t),r);break}default:{console.error("No DragTarget");break}}}function rt({direction:n,frontPoints:t,backPoints:i}){if(n&&t&&i){let e=t;switch(n){case B.Back:e=i;break;case B.Left:e={bl:i.bl,br:t.bl,tl:i.tl,tr:t.tl};break;case B.Right:e={bl:i.br,br:t.br,tl:i.tr,tr:t.tr};break;case B.Top:e={bl:i.tl,br:t.tl,tl:i.tr,tr:t.tr};break;default:e=t;break}return v.transformPlain2PointList(e)}}function st({cuboid:n,currentPos:t,zoom:i}){const{frontPoints:e}=n,r={width:40,height:74},o={x:(e.bl.x+e.tl.x)/2,y:(e.bl.y+e.tl.y)/2},s=r.width+10,l=r.height/2,c={x:o.x,y:o.y},u=v.getOffsetCoordinate(c,t,i);return{left:u.x-s,top:u.y-l}}function lt({cuboid:n,currentPos:t,zoom:i,leftOffset:e=16,topOffset:r=2}){const{frontPoints:o}=n,s={x:o.bl.x,y:o.bl.y},l=v.getOffsetCoordinate(s,t,i);return{left:l.x+e,top:l.y+r}}function at({cuboid:n,config:t}){const{minHeight:i,minWidth:e}=t,{width:r,height:o}=m(n.frontPoints);return r>=e&&o>=i}export{T as getBackPointsByFrontPoints,K as getCuboidAllSideLine,x as getCuboidBasicInfo,ot as getCuboidDragMove,tt as getCuboidHoverRange,H as getCuboidShowingSideLine,lt as getCuboidTextAttributeOffset,A as getFrontPointsByBackPoints,Z as getHighlightLines,$ as getHighlightPoints,F as getMaxExternalQuadrilateral,W as getNewPointsAfterOffset,k as getPlainPointsByDiagonalPoints,m as getPlanePointsBasicInfo,rt as getPointListsByDirection,j as getPointsByBottomLeftPoint,M as getPointsByBottomRightPoint,R as getPointsByIntersection,st as getToggleDirectionButtonOffset,at as isCuboidWithInLimits,N as judgeCuboidLineIsRowOrColumn};