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

package/es/utils/tool/CuboidUtils.js

@@ -1 +1,680 @@
-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};
+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 };