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

package/es/utils/tool/PolygonUtils.js

@@ -1 +1,458 @@
-import{polygon as S,difference as _,union as j}from"@turf/turf";import{ERotateDirection as B}from"../../constant/annotation.js";import F from"./CommonToolUtils.js";import{ELineTypes as y,SEGMENT_NUMBER as M}from"../../constant/tool.js";import D from"./AxisUtils.js";import C from"../MathUtils.js";import z from"./LineToolUtils.js";var N=Object.defineProperty,b=Object.getOwnPropertySymbols,R=Object.prototype.hasOwnProperty,T=Object.prototype.propertyIsEnumerable,O=(p,t,e)=>t in p?N(p,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):p[t]=e,A=(p,t)=>{for(var e in t||(t={}))R.call(t,e)&&O(p,e,t[e]);if(b)for(var e of b(t))T.call(t,e)&&O(p,e,t[e]);return p};class g{static getHoverPolygonID(t,e,n=3,i=y.Line){let r="",l=Infinity;const o=D.axisArea(t,n);return e.forEach(s=>{s.pointList&&o.forEach(c=>{const u=this.calcPolygonSize(s.pointList);this.isInPolygon(c,s.pointList,i)&&u<l&&(r=s.id,l=u)})}),r}static calcPolygonSize(t=[]){if((t==null?void 0:t.length)<=2)return 0;const e=t.length,n=t.reduce((i,r,l,o)=>{const s=o[(l+1)%e];return i+r.x*s.y-s.x*r.y},0);return Math.abs(n)/2}static isInPolygon(t,e,n=y.Line){let i=0,r,l,o,s;e=[...e],n===y.Curve&&(e=this.createSmoothCurvePoints(e.reduce((u,h)=>[...u,h.x,h.y],[]),.5,!0,20)),[o]=e;const c=e.length;for(r=1;r<=c;r++)s=e[r%c],t.x>Math.min(o.x,s.x)&&t.x<=Math.max(o.x,s.x)&&t.y<=Math.max(o.y,s.y)&&o.x!==s.x&&(l=(t.x-o.x)*(s.y-o.y)/(s.x-o.x)+o.y,(o.y===s.y||t.y<=l)&&i++),o=s;return i%2!=0}static createSmoothCurvePointsFromPointList(t,e=M){return this.createSmoothCurvePoints(t.reduce((i,r)=>[...i,r.x,r.y],[]),.5,!1,e).map((i,r)=>{var l;const o=r/(M+1),s=Math.floor(o),c=(l=t[s])!=null?l:{};return A(s===o?A({},c):{specialEdge:c.specialEdge},i)})}static createSmoothCurvePoints(t,e=.5,n=!1,i=M){if(t.length<4)return t;const r=[],l=t.slice(0);let o,s,c,u,h,m,v,L,P,E,a,d,f;for(n?(l.unshift(t[t.length-1]),l.unshift(t[t.length-2]),l.unshift(t[t.length-1]),l.unshift(t[t.length-2]),l.push(t[0]),l.push(t[1])):(l.unshift(t[1]),l.unshift(t[0]),l.push(t[t.length-2]),l.push(t[t.length-1])),f=2;f<l.length-4;f+=2)for(c=(l[f+2]-l[f-2])*e,u=(l[f+4]-l[f-0])*e,h=(l[f+3]-l[f-1])*e,m=(l[f+5]-l[f+1])*e,d=0;d<=i;d++)a=d/i,v=2*Math.pow(a,3)-3*Math.pow(a,2)+1,L=-(2*Math.pow(a,3))+3*Math.pow(a,2),P=Math.pow(a,3)-2*Math.pow(a,2)+a,E=Math.pow(a,3)-Math.pow(a,2),o=v*l[f]+L*l[f+2]+P*c+E*u,s=v*l[f+1]+L*l[f+3]+P*h+E*m,r.push(o),r.push(s);const I=[];for(let x=0;x<r.length-1;x+=2)I.push({x:r[x],y:r[x+1]});if(n)for(let x=0;x<i+1;x++){const w=I.shift();I.push(w)}return I}static getPolygonByID(t,e){return t.find(n=>n.id===e)}static getPolygonByIDs(t,e){if(e&&(e==null?void 0:e.length)>0)return t.filter(n=>e.includes(n.id))}static getHoverEdgeIndex(t,e,n=y.Line,i=3){let r=[...e];n===y.Curve?r=this.createSmoothCurvePoints(e.reduce((s,c)=>[...s,c.x,c.y],[]),.5,!0,M):n===y.Line&&r.push(r[0]);let l=-1,o=i;for(let s=0;s<r.length-1;s++){const{length:c}=C.getFootOfPerpendicular(t,r[s],r[s+1]);c<o&&(l=s,o=c)}return l===-1?-1:n===y.Curve?Math.floor(l/M):l}static getClosestPoint(t,e,n=y.Line,i=3,r){var l;let o=!1;const s=(l=r==null?void 0:r.isClose)!=null?l:!0;let c="",u=-1,h=Infinity,m=t;const v=20;let L=!1;return e.forEach(P=>{if(!L&&!!P.pointList)switch(n){case y.Line:F.findAllLine(P.pointList,s).forEach((a,d)=>{if(L)return;let{length:f,footPoint:I}=C.getFootOfPerpendicular(t,a.point1,a.point2);const x=C.getLineLength(a.point1,t),w=C.getLineLength(a.point2,t);x<i*2&&(I=a.point1,f=x,L=!0),w<i*2&&(I=a.point2,f=w,L=!0),f<h&&f<i&&(c=P.id,u=d,h=f,m=I,o=!0)});break;case y.Curve:{const E=this.createSmoothCurvePoints(P.pointList.reduce((a,d)=>[...a,d.x,d.y],[]),.5,s,v);for(let a=0;a<E.length-1;a++){const{length:d,footPoint:f}=C.getFootOfPerpendicular(t,E[a],E[a+1]);d<h&&d<i&&(c=P.id,u=Math.floor(a/(v+1)),h=d,m=f,o=!0)}}break}}),{dropFoot:m,closestEdgeIndex:u,closestPolygonID:c,hasClosed:o}}static isPointListInPolygon(t,e,n=y.Line){return t.every(i=>this.isInPolygon(i,e,n))}static isPointListOutSidePolygon(t,e,n=y.Line){return t.some(i=>!this.isInPolygon(i,e,n))}static getPolygonArea(t){let e=0;for(let n=0,i=t.length;n<i;n++){const r=t[n].x,l=t[n===t.length-1?0:n+1].y,o=t[n===t.length-1?0:n+1].x,s=t[n].y;e+=r*l*.5,e-=o*s*.5}return Math.abs(e)}static updatePolygonByRotate(t,e=1,n){let i=1;return t===B.Anticlockwise&&(i=-1),i*=e,C.rotateRectPointList(i,n)}static deletePolygonLastPoint(t,e,n,i){return n===i.length-1?t:[...t,{x:e[0],y:e[1]}]}static concatBeginAndEnd(t){return t.length<1?t:[...t,t[0]]}static segmentPolygonByPolygon(t,e){var n,i;try{let r=S([[...g.concatBeginAndEnd(t.map(o=>[o.x,o.y]))]]);return e.forEach(o=>{const s=S([[...g.concatBeginAndEnd(o.pointList.map(u=>[u.x,u.y]))]]),c=_(r,s);c&&(r=c)}),((i=(n=r==null?void 0:r.geometry)==null?void 0:n.coordinates.map(o=>{var s;return((s=r==null?void 0:r.geometry)==null?void 0:s.type)==="MultiPolygon"?o[0].reduce(g.deletePolygonLastPoint,[]):o.reduce(g.deletePolygonLastPoint,[])}))!=null?i:[]).reduce((o,s)=>{const c=s.length,u=s.filter((h,m)=>{const v=(m+1)%c;return!D.getIsInScope(h,s[v],1)});return u.length<3?o:[...o,u]},[])}catch(r){console.error(r)}}static getPolygonPointList(t,e){const n=e.find(i=>i.id===t);return n&&n.pointList&&n.pointList.length>0?n.pointList:[]}static getWrapPolygonIndex(t,e){return e.findIndex(n=>g.isPointListInPolygon(t,n.pointList))}static clipPolygonFromWrapPolygon(t,e){const n=g.isPolygonClosewise(e),i=g.isPolygonClosewise(t),r=g.getClosePointDistanceFromPolygon(t[0],e),l=e[r];let o=[...e.slice(0,r),l,...t,t[0],...e.slice(r,e.length)];return n===i&&(o=[...e.slice(0,r),l,t[0],...t.reverse(),...e.slice(r,e.length)]),o}static isPolygonClosewise(t){const e=t.length;let n,i,r,l=0,o;if(e<3)return 0;for(n=0;n<e;n++)i=(n+1)%e,r=(n+2)%e,o=(t[i].x-t[n].x)*(t[r].y-t[i].y),o-=(t[i].y-t[n].y)*(t[r].x-t[i].x),o<0?l--:o>0&&l++;return l>0?1:l<0?-1:0}static getClosePointDistanceFromPolygon(t,e){let n=Number.MAX_SAFE_INTEGER,i=-1;return e.forEach((r,l)=>{const o=z.calcDistance(t,r);o<n&&(n=o,i=l)}),i}static combinePolygonWithPolygon(t,e){var n,i;try{const r=S([[...g.concatBeginAndEnd(t.pointList.map(u=>[u.x,u.y]))]]),l=S([[...g.concatBeginAndEnd(e.pointList.map(u=>[u.x,u.y]))]]),o=j(r,l),s=[],c=t;if(((i=(n=o==null?void 0:o.geometry)==null?void 0:n.coordinates)==null?void 0:i.length)===1){s.push(e.id);const u=o==null?void 0:o.geometry.coordinates.map(h=>{var m;return((m=o==null?void 0:o.geometry)==null?void 0:m.type)==="MultiPolygon"?h[0].reduce(g.deletePolygonLastPoint,[]):h.reduce(g.deletePolygonLastPoint,[])})[0];c.pointList=u}return{newPolygon:c,unionList:s}}catch(r){console.error(r)}}}export{g as default};
+import { polygon, difference, union } from '@turf/turf';
+import { ERotateDirection } from '../../constant/annotation.js';
+import CommonToolUtils from './CommonToolUtils.js';
+import { ELineTypes, SEGMENT_NUMBER } from '../../constant/tool.js';
+import AxisUtils from './AxisUtils.js';
+import MathUtils from '../MathUtils.js';
+import LineToolUtils from './LineToolUtils.js';
+
+var __defProp = Object.defineProperty;
+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;
+};
+class PolygonUtils {
+  static getHoverPolygonID(checkPoint, polygonPoints, scope = 3, lineType = ELineTypes.Line) {
+    let hoverPolygonID = "";
+    let minSize = Infinity;
+    const axisList = AxisUtils.axisArea(checkPoint, scope);
+    polygonPoints.forEach((p) => {
+      if (p.pointList) {
+        axisList.forEach((v) => {
+          const size = this.calcPolygonSize(p.pointList);
+          if (this.isInPolygon(v, p.pointList, lineType) && size < minSize) {
+            hoverPolygonID = p.id;
+            minSize = size;
+          }
+        });
+      }
+    });
+    return hoverPolygonID;
+  }
+  static calcPolygonSize(pointList = []) {
+    if ((pointList == null ? void 0 : pointList.length) <= 2) {
+      return 0;
+    }
+    const len = pointList.length;
+    const size = pointList.reduce((acc, cur, index, src) => {
+      const nextVal = src[(index + 1) % len];
+      return acc + cur.x * nextVal.y - nextVal.x * cur.y;
+    }, 0);
+    return Math.abs(size) / 2;
+  }
+  static isInPolygon(checkPoint, polygonPoints, lineType = ELineTypes.Line) {
+    let counter = 0;
+    let i;
+    let xinters;
+    let p1;
+    let p2;
+    polygonPoints = [...polygonPoints];
+    if (lineType === ELineTypes.Curve) {
+      polygonPoints = this.createSmoothCurvePoints(polygonPoints.reduce((acc, cur) => {
+        return [...acc, cur.x, cur.y];
+      }, []), 0.5, true, 20);
+    }
+    [p1] = polygonPoints;
+    const pointCount = polygonPoints.length;
+    for (i = 1; i <= pointCount; i++) {
+      p2 = polygonPoints[i % pointCount];
+      if (checkPoint.x > Math.min(p1.x, p2.x) && checkPoint.x <= Math.max(p1.x, p2.x)) {
+        if (checkPoint.y <= Math.max(p1.y, p2.y)) {
+          if (p1.x !== p2.x) {
+            xinters = (checkPoint.x - p1.x) * (p2.y - p1.y) / (p2.x - p1.x) + p1.y;
+            if (p1.y === p2.y || checkPoint.y <= xinters) {
+              counter++;
+            }
+          }
+        }
+      }
+      p1 = p2;
+    }
+    if (counter % 2 === 0) {
+      return false;
+    }
+    return true;
+  }
+  static createSmoothCurvePointsFromPointList(pointList, numberOfSegments = SEGMENT_NUMBER) {
+    const newPoints = this.createSmoothCurvePoints(pointList.reduce((acc, cur) => {
+      return [...acc, cur.x, cur.y];
+    }, []), 0.5, false, numberOfSegments);
+    return newPoints.map((p, i) => {
+      var _a;
+      const pos = i / (SEGMENT_NUMBER + 1);
+      const v = Math.floor(pos);
+      const data = (_a = pointList[v]) != null ? _a : {};
+      if (v === pos) {
+        return __spreadValues(__spreadValues({}, data), p);
+      }
+      return __spreadValues({
+        specialEdge: data.specialEdge
+      }, p);
+    });
+  }
+  static createSmoothCurvePoints(points, tension = 0.5, closed = false, numberOfSegments = SEGMENT_NUMBER) {
+    if (points.length < 4) {
+      return points;
+    }
+    const result = [];
+    const ps = points.slice(0);
+    let x;
+    let y;
+    let t1x;
+    let t2x;
+    let t1y;
+    let t2y;
+    let c1;
+    let c2;
+    let c3;
+    let c4;
+    let st;
+    let t;
+    let i;
+    if (closed) {
+      ps.unshift(points[points.length - 1]);
+      ps.unshift(points[points.length - 2]);
+      ps.unshift(points[points.length - 1]);
+      ps.unshift(points[points.length - 2]);
+      ps.push(points[0]);
+      ps.push(points[1]);
+    } else {
+      ps.unshift(points[1]);
+      ps.unshift(points[0]);
+      ps.push(points[points.length - 2]);
+      ps.push(points[points.length - 1]);
+    }
+    for (i = 2; i < ps.length - 4; i += 2) {
+      t1x = (ps[i + 2] - ps[i - 2]) * tension;
+      t2x = (ps[i + 4] - ps[i - 0]) * tension;
+      t1y = (ps[i + 3] - ps[i - 1]) * tension;
+      t2y = (ps[i + 5] - ps[i + 1]) * tension;
+      for (t = 0; t <= numberOfSegments; t++) {
+        st = t / numberOfSegments;
+        c1 = 2 * Math.pow(st, 3) - 3 * Math.pow(st, 2) + 1;
+        c2 = -(2 * Math.pow(st, 3)) + 3 * Math.pow(st, 2);
+        c3 = Math.pow(st, 3) - 2 * Math.pow(st, 2) + st;
+        c4 = Math.pow(st, 3) - Math.pow(st, 2);
+        x = c1 * ps[i] + c2 * ps[i + 2] + c3 * t1x + c4 * t2x;
+        y = c1 * ps[i + 1] + c2 * ps[i + 3] + c3 * t1y + c4 * t2y;
+        result.push(x);
+        result.push(y);
+      }
+    }
+    const formatResult = [];
+    for (let j = 0; j < result.length - 1; j += 2) {
+      formatResult.push({
+        x: result[j],
+        y: result[j + 1]
+      });
+    }
+    if (closed) {
+      for (let m = 0; m < numberOfSegments + 1; m++) {
+        const d = formatResult.shift();
+        formatResult.push(d);
+      }
+    }
+    return formatResult;
+  }
+  static getPolygonByID(polygonList, id) {
+    return polygonList.find((p) => p.id === id);
+  }
+  static getPolygonByIDs(polygonList, ids) {
+    if (ids && (ids == null ? void 0 : ids.length) > 0) {
+      return polygonList.filter((p) => ids.includes(p.id));
+    }
+  }
+  static getHoverEdgeIndex(checkPoint, pointList, lineType = ELineTypes.Line, scope = 3) {
+    let points = [...pointList];
+    if (lineType === ELineTypes.Curve) {
+      points = this.createSmoothCurvePoints(pointList.reduce((acc, cur) => {
+        return [...acc, cur.x, cur.y];
+      }, []), 0.5, true, SEGMENT_NUMBER);
+    } else if (lineType === ELineTypes.Line) {
+      points.push(points[0]);
+    }
+    let edgeIndex = -1;
+    let minLength = scope;
+    for (let i = 0; i < points.length - 1; i++) {
+      const {length} = MathUtils.getFootOfPerpendicular(checkPoint, points[i], points[i + 1]);
+      if (length < minLength) {
+        edgeIndex = i;
+        minLength = length;
+      }
+    }
+    if (edgeIndex === -1) {
+      return -1;
+    }
+    if (lineType === ELineTypes.Curve) {
+      return Math.floor(edgeIndex / SEGMENT_NUMBER);
+    }
+    return edgeIndex;
+  }
+  static getClosestPoint(coordinate, polygonList, lineType = ELineTypes.Line, range = 3, option) {
+    var _a;
+    let hasClosed = false;
+    const isClose = (_a = option == null ? void 0 : option.isClose) != null ? _a : true;
+    let closestPolygonID = "";
+    let closestEdgeIndex = -1;
+    let min = Infinity;
+    let dropFoot = coordinate;
+    const numberOfSegments = 20;
+    let isCloseNode = false;
+    polygonList.forEach((v) => {
+      if (isCloseNode) {
+        return;
+      }
+      if (!v.pointList) {
+        return;
+      }
+      switch (lineType) {
+        case ELineTypes.Line:
+          {
+            const allLine = CommonToolUtils.findAllLine(v.pointList, isClose);
+            allLine.forEach((line, lineIndex) => {
+              if (isCloseNode) {
+                return;
+              }
+              let {length, footPoint} = MathUtils.getFootOfPerpendicular(coordinate, line.point1, line.point2);
+              const twoPointDistance1 = MathUtils.getLineLength(line.point1, coordinate);
+              const twoPointDistance2 = MathUtils.getLineLength(line.point2, coordinate);
+              if (twoPointDistance1 < range * 2) {
+                footPoint = line.point1;
+                length = twoPointDistance1;
+                isCloseNode = true;
+              }
+              if (twoPointDistance2 < range * 2) {
+                footPoint = line.point2;
+                length = twoPointDistance2;
+                isCloseNode = true;
+              }
+              if (length < min && length < range) {
+                closestPolygonID = v.id;
+                closestEdgeIndex = lineIndex;
+                min = length;
+                dropFoot = footPoint;
+                hasClosed = true;
+              }
+            });
+          }
+          break;
+        case ELineTypes.Curve:
+          {
+            const points = this.createSmoothCurvePoints(v.pointList.reduce((acc, cur) => {
+              return [...acc, cur.x, cur.y];
+            }, []), 0.5, isClose, numberOfSegments);
+            for (let i = 0; i < points.length - 1; i++) {
+              const {length, footPoint} = MathUtils.getFootOfPerpendicular(coordinate, points[i], points[i + 1]);
+              if (length < min && length < range) {
+                closestPolygonID = v.id;
+                closestEdgeIndex = Math.floor(i / (numberOfSegments + 1));
+                min = length;
+                dropFoot = footPoint;
+                hasClosed = true;
+              }
+            }
+          }
+          break;
+      }
+    });
+    return {dropFoot, closestEdgeIndex, closestPolygonID, hasClosed};
+  }
+  static isPointListInPolygon(pointList, polygonPoints, lineType = ELineTypes.Line) {
+    return pointList.every((v) => this.isInPolygon(v, polygonPoints, lineType));
+  }
+  static isPointListOutSidePolygon(pointList, polygonPoints, lineType = ELineTypes.Line) {
+    return pointList.some((v) => !this.isInPolygon(v, polygonPoints, lineType));
+  }
+  static getPolygonArea(pointList) {
+    let total = 0;
+    for (let i = 0, l = pointList.length; i < l; i++) {
+      const addX = pointList[i].x;
+      const addY = pointList[i === pointList.length - 1 ? 0 : i + 1].y;
+      const subX = pointList[i === pointList.length - 1 ? 0 : i + 1].x;
+      const subY = pointList[i].y;
+      total += addX * addY * 0.5;
+      total -= subX * subY * 0.5;
+    }
+    return Math.abs(total);
+  }
+  static updatePolygonByRotate(direction, angle = 1, pointList) {
+    let rotate = 1;
+    if (direction === ERotateDirection.Anticlockwise) {
+      rotate = -1;
+    }
+    rotate *= angle;
+    return MathUtils.rotateRectPointList(rotate, pointList);
+  }
+  static deletePolygonLastPoint(acc, cur, index, array) {
+    if (index === array.length - 1) {
+      return acc;
+    }
+    return [
+      ...acc,
+      {
+        x: cur[0],
+        y: cur[1]
+      }
+    ];
+  }
+  static concatBeginAndEnd(array) {
+    if (array.length < 1) {
+      return array;
+    }
+    return [...array, array[0]];
+  }
+  static segmentPolygonByPolygon(pointList, polygonList) {
+    var _a, _b;
+    try {
+      let selectedPolygon = polygon([[...PolygonUtils.concatBeginAndEnd(pointList.map((v) => [v.x, v.y]))]]);
+      polygonList.forEach((v) => {
+        const backgroundPolygon = polygon([[...PolygonUtils.concatBeginAndEnd(v.pointList.map((p) => [p.x, p.y]))]]);
+        const diff = difference(selectedPolygon, backgroundPolygon);
+        if (diff) {
+          selectedPolygon = diff;
+        }
+      });
+      const resultList = (_b = (_a = selectedPolygon == null ? void 0 : selectedPolygon.geometry) == null ? void 0 : _a.coordinates.map((p) => {
+        var _a2;
+        if (((_a2 = selectedPolygon == null ? void 0 : selectedPolygon.geometry) == null ? void 0 : _a2.type) === "MultiPolygon") {
+          return p[0].reduce(PolygonUtils.deletePolygonLastPoint, []);
+        }
+        return p.reduce(PolygonUtils.deletePolygonLastPoint, []);
+      })) != null ? _b : [];
+      return resultList.reduce((acc, pointLists) => {
+        const len = pointLists.length;
+        const newPointList = pointLists.filter((point, i) => {
+          const nextIndex = (i + 1) % len;
+          if (AxisUtils.getIsInScope(point, pointLists[nextIndex], 1)) {
+            return false;
+          }
+          return true;
+        });
+        if (newPointList.length < 3) {
+          return acc;
+        }
+        return [...acc, newPointList];
+      }, []);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  static getPolygonPointList(selectedPolygonID, polygonList) {
+    const p = polygonList.find((v) => v.id === selectedPolygonID);
+    if (p && p.pointList && p.pointList.length > 0) {
+      return p.pointList;
+    }
+    return [];
+  }
+  static getWrapPolygonIndex(pointList, polygonList) {
+    return polygonList.findIndex((p) => PolygonUtils.isPointListInPolygon(pointList, p.pointList));
+  }
+  static clipPolygonFromWrapPolygon(pointList, wrapPointList) {
+    const wrapDirection = PolygonUtils.isPolygonClosewise(wrapPointList);
+    const selectedDirection = PolygonUtils.isPolygonClosewise(pointList);
+    const linkIndex = PolygonUtils.getClosePointDistanceFromPolygon(pointList[0], wrapPointList);
+    const linkPoint = wrapPointList[linkIndex];
+    let newPointList = [
+      ...wrapPointList.slice(0, linkIndex),
+      linkPoint,
+      ...pointList,
+      pointList[0],
+      ...wrapPointList.slice(linkIndex, wrapPointList.length)
+    ];
+    if (wrapDirection === selectedDirection) {
+      newPointList = [
+        ...wrapPointList.slice(0, linkIndex),
+        linkPoint,
+        pointList[0],
+        ...pointList.reverse(),
+        ...wrapPointList.slice(linkIndex, wrapPointList.length)
+      ];
+    }
+    return newPointList;
+  }
+  static isPolygonClosewise(p) {
+    const n = p.length;
+    let i;
+    let j;
+    let k;
+    let count = 0;
+    let z;
+    if (n < 3) {
+      return 0;
+    }
+    for (i = 0; i < n; i++) {
+      j = (i + 1) % n;
+      k = (i + 2) % n;
+      z = (p[j].x - p[i].x) * (p[k].y - p[j].y);
+      z -= (p[j].y - p[i].y) * (p[k].x - p[j].x);
+      if (z < 0) {
+        count--;
+      } else if (z > 0) {
+        count++;
+      }
+    }
+    if (count > 0) {
+      return 1;
+    }
+    if (count < 0) {
+      return -1;
+    }
+    return 0;
+  }
+  static getClosePointDistanceFromPolygon(point, pointList) {
+    let minLen = Number.MAX_SAFE_INTEGER;
+    let index = -1;
+    pointList.forEach((p, i) => {
+      const distance = LineToolUtils.calcDistance(point, p);
+      if (distance < minLen) {
+        minLen = distance;
+        index = i;
+      }
+    });
+    return index;
+  }
+  static combinePolygonWithPolygon(selectedPolygon, combinedPolygon) {
+    var _a, _b;
+    try {
+      const turfSelectedPolygon = polygon([
+        [...PolygonUtils.concatBeginAndEnd(selectedPolygon.pointList.map((v) => [v.x, v.y]))]
+      ]);
+      const turfCombinedPolygon = polygon([
+        [...PolygonUtils.concatBeginAndEnd(combinedPolygon.pointList.map((v) => [v.x, v.y]))]
+      ]);
+      const unionPolygon = union(turfSelectedPolygon, turfCombinedPolygon);
+      const unionList = [];
+      const newPolygon = selectedPolygon;
+      if (((_b = (_a = unionPolygon == null ? void 0 : unionPolygon.geometry) == null ? void 0 : _a.coordinates) == null ? void 0 : _b.length) === 1) {
+        unionList.push(combinedPolygon.id);
+        const pointList = unionPolygon == null ? void 0 : unionPolygon.geometry.coordinates.map((p) => {
+          var _a2;
+          if (((_a2 = unionPolygon == null ? void 0 : unionPolygon.geometry) == null ? void 0 : _a2.type) === "MultiPolygon") {
+            return p[0].reduce(PolygonUtils.deletePolygonLastPoint, []);
+          }
+          return p.reduce(PolygonUtils.deletePolygonLastPoint, []);
+        })[0];
+        newPolygon.pointList = pointList;
+      }
+      return {
+        newPolygon,
+        unionList
+      };
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+
+export { PolygonUtils as default };

package/es/utils/tool/RectUtils.js

@@ -1 +1,153 @@
-import p from"./AxisUtils.js";import f from"./CommonToolUtils.js";import{isInPolygon as d}from"./polygonTool.js";var P=Object.defineProperty,_=Object.defineProperties,w=Object.getOwnPropertyDescriptors,u=Object.getOwnPropertySymbols,O=Object.prototype.hasOwnProperty,R=Object.prototype.propertyIsEnumerable,x=(a,t,e)=>t in a?P(a,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):a[t]=e,h=(a,t)=>{for(var e in t||(t={}))O.call(t,e)&&x(a,e,t[e]);if(u)for(var e of u(t))R.call(t,e)&&x(a,e,t[e]);return a},l=(a,t)=>_(a,w(t));class v{static composeResult(t,e,r,n,s){try{const i=JSON.parse(t),o=f.getCurrentStepInfo(e,n),{dataSourceStep:y}=o,g=`step_${o.step}`;if(Object.assign(i,s),i[g]){const c=i[g];return c.result?(c.result=r,JSON.stringify(i)):JSON.stringify(l(h({},i),{[g]:l(h({},i[g]),{result:r})}))}return JSON.stringify(l(h({},i),{[g]:{dataSourceStep:y,toolName:o.tool,result:r}}))}catch(i){return t}}static changeCoordinateByRotate(t,e,r){const{x:n,y:s,width:i,height:o}=t,y=p.changeCoordinateByRotate({x:n,y:s},e,r);switch(e%360){case 90:return l(h({},t),{x:y.x-o,y:y.y,width:o,height:i});case 180:return l(h({},t),{x:y.x-i,y:y.y-o});case 270:return l(h({},t),{x:y.x,y:y.y-i,width:o,height:i});default:return t}}static translateRect2Points(t){const{x:e,y:r,width:n,height:s}=t;return[{x:e,y:r},{x:e+n,y:r},{x:e+n,y:r+s},{x:e,y:r+s}]}static translatePoints2Rect(t,e){if(t.length!==4)return;const{x:r,y:n}=t[0],s=t[1].x-t[0].x,i=t[2].y-t[1].y;return l(h({},e),{x:r,y:n,width:s,height:i})}static getRectPointList(t,e=1){return[{x:t.x*e,y:t.y*e},{x:(t.x+t.width)*e,y:t.y*e},{x:(t.x+t.width)*e,y:(t.y+t.height)*e},{x:t.x*e,y:(t.y+t.height)*e}]}static getRectEdgeList(t,e=1){const r=this.getRectPointList(t,e),n=r.length;return r.map((s,i)=>({begin:s,end:r[(i+1)%n]}))}static isInRect(t,e,r=0,n=1){return t.x>=e.x*n-r&&t.x<=(e.x+e.width)*n+r&&t.y>=e.y*n-r&&t.y<=(e.y+e.height)*n+r}static getRectUnderZoom(t,e=1){const{x:r,y:n,width:s,height:i}=t;return l(h({},t),{x:r*e,y:n*e,width:s*e,height:i*e})}static isRectNotInPolygon(t,e){return this.getRectPointList(t).some(n=>!d(n,e))}}export{v as default};
+import AxisUtils from './AxisUtils.js';
+import CommonToolUtils from './CommonToolUtils.js';
+import { isInPolygon } from './polygonTool.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));
+class RectUtils {
+  static composeResult(result, currentStep, resultList, stepList, basicImgInfo) {
+    try {
+      const data = JSON.parse(result);
+      const currentStepInfo = CommonToolUtils.getCurrentStepInfo(currentStep, stepList);
+      const {dataSourceStep} = currentStepInfo;
+      const stepName = `step_${currentStepInfo.step}`;
+      Object.assign(data, basicImgInfo);
+      if (data[stepName]) {
+        const info = data[stepName];
+        if (info.result) {
+          info.result = resultList;
+          return JSON.stringify(data);
+        }
+        return JSON.stringify(__spreadProps(__spreadValues({}, data), {
+          [stepName]: __spreadProps(__spreadValues({}, data[stepName]), {
+            result: resultList
+          })
+        }));
+      }
+      return JSON.stringify(__spreadProps(__spreadValues({}, data), {
+        [stepName]: {
+          dataSourceStep,
+          toolName: currentStepInfo.tool,
+          result: resultList
+        }
+      }));
+    } catch (e) {
+      return result;
+    }
+  }
+  static changeCoordinateByRotate(rect, rotate, imgSize) {
+    const {x, y, width, height} = rect;
+    const leftTopCoordinate = AxisUtils.changeCoordinateByRotate({x, y}, rotate, imgSize);
+    switch (rotate % 360) {
+      case 90:
+        return __spreadProps(__spreadValues({}, rect), {
+          x: leftTopCoordinate.x - height,
+          y: leftTopCoordinate.y,
+          width: height,
+          height: width
+        });
+      case 180:
+        return __spreadProps(__spreadValues({}, rect), {
+          x: leftTopCoordinate.x - width,
+          y: leftTopCoordinate.y - height
+        });
+      case 270:
+        return __spreadProps(__spreadValues({}, rect), {
+          x: leftTopCoordinate.x,
+          y: leftTopCoordinate.y - width,
+          width: height,
+          height: width
+        });
+      default:
+        return rect;
+    }
+  }
+  static translateRect2Points(rect) {
+    const {x, y, width, height} = rect;
+    return [
+      {
+        x,
+        y
+      },
+      {
+        x: x + width,
+        y
+      },
+      {
+        x: x + width,
+        y: y + height
+      },
+      {
+        x,
+        y: y + height
+      }
+    ];
+  }
+  static translatePoints2Rect(points, basicRect) {
+    if (points.length !== 4) {
+      return;
+    }
+    const {x, y} = points[0];
+    const width = points[1].x - points[0].x;
+    const height = points[2].y - points[1].y;
+    return __spreadProps(__spreadValues({}, basicRect), {
+      x,
+      y,
+      width,
+      height
+    });
+  }
+  static getRectPointList(rect, zoom = 1) {
+    return [
+      {x: rect.x * zoom, y: rect.y * zoom},
+      {x: (rect.x + rect.width) * zoom, y: rect.y * zoom},
+      {x: (rect.x + rect.width) * zoom, y: (rect.y + rect.height) * zoom},
+      {x: rect.x * zoom, y: (rect.y + rect.height) * zoom}
+    ];
+  }
+  static getRectEdgeList(rect, zoom = 1) {
+    const pointList = this.getRectPointList(rect, zoom);
+    const len = pointList.length;
+    return pointList.map((v, i) => {
+      return {
+        begin: v,
+        end: pointList[(i + 1) % len]
+      };
+    });
+  }
+  static isInRect(coordinate, rect, scope = 0, zoom = 1) {
+    return coordinate.x >= rect.x * zoom - scope && coordinate.x <= (rect.x + rect.width) * zoom + scope && coordinate.y >= rect.y * zoom - scope && coordinate.y <= (rect.y + rect.height) * zoom + scope;
+  }
+  static getRectUnderZoom(rect, zoom = 1) {
+    const {x, y, width, height} = rect;
+    return __spreadProps(__spreadValues({}, rect), {
+      x: x * zoom,
+      y: y * zoom,
+      width: width * zoom,
+      height: height * zoom
+    });
+  }
+  static isRectNotInPolygon(rect, polygonPointList) {
+    const rectPointList = this.getRectPointList(rect);
+    return rectPointList.some((p) => !isInPolygon(p, polygonPointList));
+  }
+}
+
+export { RectUtils as default };