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

package/dist/utils/tool/CuboidUtils.js

@@ -1 +1,704 @@
-"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;
+'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;