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

package/dist/utils/tool/PolygonUtils.js

@@ -1 +1,460 @@
-"use strict";var turf=require("@turf/turf"),annotation=require("../../constant/annotation.js"),CommonToolUtils=require("./CommonToolUtils.js"),tool=require("../../constant/tool.js"),AxisUtils=require("./AxisUtils.js"),MathUtils=require("../MathUtils.js"),LineToolUtils=require("./LineToolUtils.js"),__defProp=Object.defineProperty,__getOwnPropSymbols=Object.getOwnPropertySymbols,__hasOwnProp=Object.prototype.hasOwnProperty,__propIsEnum=Object.prototype.propertyIsEnumerable,__defNormalProp=(L,e,t)=>e in L?__defProp(L,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):L[e]=t,__spreadValues=(L,e)=>{for(var t in e||(e={}))__hasOwnProp.call(e,t)&&__defNormalProp(L,t,e[t]);if(__getOwnPropSymbols)for(var t of __getOwnPropSymbols(e))__propIsEnum.call(e,t)&&__defNormalProp(L,t,e[t]);return L};class PolygonUtils{static getHoverPolygonID(e,t,n=3,i=tool.ELineTypes.Line){let r="",l=Infinity;const o=AxisUtils.default.axisArea(e,n);return t.forEach(s=>{s.pointList&&o.forEach(u=>{const a=this.calcPolygonSize(s.pointList);this.isInPolygon(u,s.pointList,i)&&a<l&&(r=s.id,l=a)})}),r}static calcPolygonSize(e=[]){if((e==null?void 0:e.length)<=2)return 0;const t=e.length,n=e.reduce((i,r,l,o)=>{const s=o[(l+1)%t];return i+r.x*s.y-s.x*r.y},0);return Math.abs(n)/2}static isInPolygon(e,t,n=tool.ELineTypes.Line){let i=0,r,l,o,s;t=[...t],n===tool.ELineTypes.Curve&&(t=this.createSmoothCurvePoints(t.reduce((a,d)=>[...a,d.x,d.y],[]),.5,!0,20)),[o]=t;const u=t.length;for(r=1;r<=u;r++)s=t[r%u],e.x>Math.min(o.x,s.x)&&e.x<=Math.max(o.x,s.x)&&e.y<=Math.max(o.y,s.y)&&o.x!==s.x&&(l=(e.x-o.x)*(s.y-o.y)/(s.x-o.x)+o.y,(o.y===s.y||e.y<=l)&&i++),o=s;return i%2!=0}static createSmoothCurvePointsFromPointList(e,t=tool.SEGMENT_NUMBER){return this.createSmoothCurvePoints(e.reduce((i,r)=>[...i,r.x,r.y],[]),.5,!1,t).map((i,r)=>{var l;const o=r/(tool.SEGMENT_NUMBER+1),s=Math.floor(o),u=(l=e[s])!=null?l:{};return __spreadValues(s===o?__spreadValues({},u):{specialEdge:u.specialEdge},i)})}static createSmoothCurvePoints(e,t=.5,n=!1,i=tool.SEGMENT_NUMBER){if(e.length<4)return e;const r=[],l=e.slice(0);let o,s,u,a,d,h,P,E,x,m,c,g,f;for(n?(l.unshift(e[e.length-1]),l.unshift(e[e.length-2]),l.unshift(e[e.length-1]),l.unshift(e[e.length-2]),l.push(e[0]),l.push(e[1])):(l.unshift(e[1]),l.unshift(e[0]),l.push(e[e.length-2]),l.push(e[e.length-1])),f=2;f<l.length-4;f+=2)for(u=(l[f+2]-l[f-2])*t,a=(l[f+4]-l[f-0])*t,d=(l[f+3]-l[f-1])*t,h=(l[f+5]-l[f+1])*t,g=0;g<=i;g++)c=g/i,P=2*Math.pow(c,3)-3*Math.pow(c,2)+1,E=-(2*Math.pow(c,3))+3*Math.pow(c,2),x=Math.pow(c,3)-2*Math.pow(c,2)+c,m=Math.pow(c,3)-Math.pow(c,2),o=P*l[f]+E*l[f+2]+x*u+m*a,s=P*l[f+1]+E*l[f+3]+x*d+m*h,r.push(o),r.push(s);const v=[];for(let y=0;y<r.length-1;y+=2)v.push({x:r[y],y:r[y+1]});if(n)for(let y=0;y<i+1;y++){const p=v.shift();v.push(p)}return v}static getPolygonByID(e,t){return e.find(n=>n.id===t)}static getPolygonByIDs(e,t){if(t&&(t==null?void 0:t.length)>0)return e.filter(n=>t.includes(n.id))}static getHoverEdgeIndex(e,t,n=tool.ELineTypes.Line,i=3){let r=[...t];n===tool.ELineTypes.Curve?r=this.createSmoothCurvePoints(t.reduce((s,u)=>[...s,u.x,u.y],[]),.5,!0,tool.SEGMENT_NUMBER):n===tool.ELineTypes.Line&&r.push(r[0]);let l=-1,o=i;for(let s=0;s<r.length-1;s++){const{length:u}=MathUtils.default.getFootOfPerpendicular(e,r[s],r[s+1]);u<o&&(l=s,o=u)}return l===-1?-1:n===tool.ELineTypes.Curve?Math.floor(l/tool.SEGMENT_NUMBER):l}static getClosestPoint(e,t,n=tool.ELineTypes.Line,i=3,r){var l;let o=!1;const s=(l=r==null?void 0:r.isClose)!=null?l:!0;let u="",a=-1,d=Infinity,h=e;const P=20;let E=!1;return t.forEach(x=>{if(!E&&!!x.pointList)switch(n){case tool.ELineTypes.Line:CommonToolUtils.findAllLine(x.pointList,s).forEach((c,g)=>{if(E)return;let{length:f,footPoint:v}=MathUtils.default.getFootOfPerpendicular(e,c.point1,c.point2);const y=MathUtils.default.getLineLength(c.point1,e),p=MathUtils.default.getLineLength(c.point2,e);y<i*2&&(v=c.point1,f=y,E=!0),p<i*2&&(v=c.point2,f=p,E=!0),f<d&&f<i&&(u=x.id,a=g,d=f,h=v,o=!0)});break;case tool.ELineTypes.Curve:{const m=this.createSmoothCurvePoints(x.pointList.reduce((c,g)=>[...c,g.x,g.y],[]),.5,s,P);for(let c=0;c<m.length-1;c++){const{length:g,footPoint:f}=MathUtils.default.getFootOfPerpendicular(e,m[c],m[c+1]);g<d&&g<i&&(u=x.id,a=Math.floor(c/(P+1)),d=g,h=f,o=!0)}}break}}),{dropFoot:h,closestEdgeIndex:a,closestPolygonID:u,hasClosed:o}}static isPointListInPolygon(e,t,n=tool.ELineTypes.Line){return e.every(i=>this.isInPolygon(i,t,n))}static isPointListOutSidePolygon(e,t,n=tool.ELineTypes.Line){return e.some(i=>!this.isInPolygon(i,t,n))}static getPolygonArea(e){let t=0;for(let n=0,i=e.length;n<i;n++){const r=e[n].x,l=e[n===e.length-1?0:n+1].y,o=e[n===e.length-1?0:n+1].x,s=e[n].y;t+=r*l*.5,t-=o*s*.5}return Math.abs(t)}static updatePolygonByRotate(e,t=1,n){let i=1;return e===annotation.ERotateDirection.Anticlockwise&&(i=-1),i*=t,MathUtils.default.rotateRectPointList(i,n)}static deletePolygonLastPoint(e,t,n,i){return n===i.length-1?e:[...e,{x:t[0],y:t[1]}]}static concatBeginAndEnd(e){return e.length<1?e:[...e,e[0]]}static segmentPolygonByPolygon(e,t){var n,i;try{let r=turf.polygon([[...PolygonUtils.concatBeginAndEnd(e.map(o=>[o.x,o.y]))]]);return t.forEach(o=>{const s=turf.polygon([[...PolygonUtils.concatBeginAndEnd(o.pointList.map(a=>[a.x,a.y]))]]),u=turf.difference(r,s);u&&(r=u)}),((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(PolygonUtils.deletePolygonLastPoint,[]):o.reduce(PolygonUtils.deletePolygonLastPoint,[])}))!=null?i:[]).reduce((o,s)=>{const u=s.length,a=s.filter((d,h)=>{const P=(h+1)%u;return!AxisUtils.default.getIsInScope(d,s[P],1)});return a.length<3?o:[...o,a]},[])}catch(r){console.error(r)}}static getPolygonPointList(e,t){const n=t.find(i=>i.id===e);return n&&n.pointList&&n.pointList.length>0?n.pointList:[]}static getWrapPolygonIndex(e,t){return t.findIndex(n=>PolygonUtils.isPointListInPolygon(e,n.pointList))}static clipPolygonFromWrapPolygon(e,t){const n=PolygonUtils.isPolygonClosewise(t),i=PolygonUtils.isPolygonClosewise(e),r=PolygonUtils.getClosePointDistanceFromPolygon(e[0],t),l=t[r];let o=[...t.slice(0,r),l,...e,e[0],...t.slice(r,t.length)];return n===i&&(o=[...t.slice(0,r),l,e[0],...e.reverse(),...t.slice(r,t.length)]),o}static isPolygonClosewise(e){const t=e.length;let n,i,r,l=0,o;if(t<3)return 0;for(n=0;n<t;n++)i=(n+1)%t,r=(n+2)%t,o=(e[i].x-e[n].x)*(e[r].y-e[i].y),o-=(e[i].y-e[n].y)*(e[r].x-e[i].x),o<0?l--:o>0&&l++;return l>0?1:l<0?-1:0}static getClosePointDistanceFromPolygon(e,t){let n=Number.MAX_SAFE_INTEGER,i=-1;return t.forEach((r,l)=>{const o=LineToolUtils.default.calcDistance(e,r);o<n&&(n=o,i=l)}),i}static combinePolygonWithPolygon(e,t){var n,i;try{const r=turf.polygon([[...PolygonUtils.concatBeginAndEnd(e.pointList.map(a=>[a.x,a.y]))]]),l=turf.polygon([[...PolygonUtils.concatBeginAndEnd(t.pointList.map(a=>[a.x,a.y]))]]),o=turf.union(r,l),s=[],u=e;if(((i=(n=o==null?void 0:o.geometry)==null?void 0:n.coordinates)==null?void 0:i.length)===1){s.push(t.id);const a=o==null?void 0:o.geometry.coordinates.map(d=>{var h;return((h=o==null?void 0:o.geometry)==null?void 0:h.type)==="MultiPolygon"?d[0].reduce(PolygonUtils.deletePolygonLastPoint,[]):d.reduce(PolygonUtils.deletePolygonLastPoint,[])})[0];u.pointList=a}return{newPolygon:u,unionList:s}}catch(r){console.error(r)}}}module.exports=PolygonUtils;
+'use strict';
+
+var turf = require('@turf/turf');
+var annotation = require('../../constant/annotation.js');
+var CommonToolUtils = require('./CommonToolUtils.js');
+var tool = require('../../constant/tool.js');
+var AxisUtils = require('./AxisUtils.js');
+var MathUtils = require('../MathUtils.js');
+var LineToolUtils = require('./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 = tool.ELineTypes.Line) {
+    let hoverPolygonID = "";
+    let minSize = Infinity;
+    const axisList = AxisUtils["default"].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 = tool.ELineTypes.Line) {
+    let counter = 0;
+    let i;
+    let xinters;
+    let p1;
+    let p2;
+    polygonPoints = [...polygonPoints];
+    if (lineType === tool.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 = tool.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 / (tool.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 = tool.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 = tool.ELineTypes.Line, scope = 3) {
+    let points = [...pointList];
+    if (lineType === tool.ELineTypes.Curve) {
+      points = this.createSmoothCurvePoints(pointList.reduce((acc, cur) => {
+        return [...acc, cur.x, cur.y];
+      }, []), 0.5, true, tool.SEGMENT_NUMBER);
+    } else if (lineType === tool.ELineTypes.Line) {
+      points.push(points[0]);
+    }
+    let edgeIndex = -1;
+    let minLength = scope;
+    for (let i = 0; i < points.length - 1; i++) {
+      const {length} = MathUtils["default"].getFootOfPerpendicular(checkPoint, points[i], points[i + 1]);
+      if (length < minLength) {
+        edgeIndex = i;
+        minLength = length;
+      }
+    }
+    if (edgeIndex === -1) {
+      return -1;
+    }
+    if (lineType === tool.ELineTypes.Curve) {
+      return Math.floor(edgeIndex / tool.SEGMENT_NUMBER);
+    }
+    return edgeIndex;
+  }
+  static getClosestPoint(coordinate, polygonList, lineType = tool.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 tool.ELineTypes.Line:
+          {
+            const allLine = CommonToolUtils.findAllLine(v.pointList, isClose);
+            allLine.forEach((line, lineIndex) => {
+              if (isCloseNode) {
+                return;
+              }
+              let {length, footPoint} = MathUtils["default"].getFootOfPerpendicular(coordinate, line.point1, line.point2);
+              const twoPointDistance1 = MathUtils["default"].getLineLength(line.point1, coordinate);
+              const twoPointDistance2 = MathUtils["default"].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 tool.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["default"].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 = tool.ELineTypes.Line) {
+    return pointList.every((v) => this.isInPolygon(v, polygonPoints, lineType));
+  }
+  static isPointListOutSidePolygon(pointList, polygonPoints, lineType = tool.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 === annotation.ERotateDirection.Anticlockwise) {
+      rotate = -1;
+    }
+    rotate *= angle;
+    return MathUtils["default"].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 = turf.polygon([[...PolygonUtils.concatBeginAndEnd(pointList.map((v) => [v.x, v.y]))]]);
+      polygonList.forEach((v) => {
+        const backgroundPolygon = turf.polygon([[...PolygonUtils.concatBeginAndEnd(v.pointList.map((p) => [p.x, p.y]))]]);
+        const diff = turf.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["default"].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["default"].calcDistance(point, p);
+      if (distance < minLen) {
+        minLen = distance;
+        index = i;
+      }
+    });
+    return index;
+  }
+  static combinePolygonWithPolygon(selectedPolygon, combinedPolygon) {
+    var _a, _b;
+    try {
+      const turfSelectedPolygon = turf.polygon([
+        [...PolygonUtils.concatBeginAndEnd(selectedPolygon.pointList.map((v) => [v.x, v.y]))]
+      ]);
+      const turfCombinedPolygon = turf.polygon([
+        [...PolygonUtils.concatBeginAndEnd(combinedPolygon.pointList.map((v) => [v.x, v.y]))]
+      ]);
+      const unionPolygon = turf.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);
+    }
+  }
+}
+
+module.exports = PolygonUtils;

package/dist/utils/tool/RectUtils.js

@@ -1 +1,155 @@
-"use strict";var AxisUtils=require("./AxisUtils.js"),CommonToolUtils=require("./CommonToolUtils.js"),polygonTool=require("./polygonTool.js"),__defProp=Object.defineProperty,__defProps=Object.defineProperties,__getOwnPropDescs=Object.getOwnPropertyDescriptors,__getOwnPropSymbols=Object.getOwnPropertySymbols,__hasOwnProp=Object.prototype.hasOwnProperty,__propIsEnum=Object.prototype.propertyIsEnumerable,__defNormalProp=(a,t,e)=>t in a?__defProp(a,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):a[t]=e,__spreadValues=(a,t)=>{for(var e in t||(t={}))__hasOwnProp.call(t,e)&&__defNormalProp(a,e,t[e]);if(__getOwnPropSymbols)for(var e of __getOwnPropSymbols(t))__propIsEnum.call(t,e)&&__defNormalProp(a,e,t[e]);return a},__spreadProps=(a,t)=>__defProps(a,__getOwnPropDescs(t));class RectUtils{static composeResult(t,e,r,n,i){try{const s=JSON.parse(t),o=CommonToolUtils.getCurrentStepInfo(e,n),{dataSourceStep:y}=o,h=`step_${o.step}`;if(Object.assign(s,i),s[h]){const l=s[h];return l.result?(l.result=r,JSON.stringify(s)):JSON.stringify(__spreadProps(__spreadValues({},s),{[h]:__spreadProps(__spreadValues({},s[h]),{result:r})}))}return JSON.stringify(__spreadProps(__spreadValues({},s),{[h]:{dataSourceStep:y,toolName:o.tool,result:r}}))}catch(s){return t}}static changeCoordinateByRotate(t,e,r){const{x:n,y:i,width:s,height:o}=t,y=AxisUtils.default.changeCoordinateByRotate({x:n,y:i},e,r);switch(e%360){case 90:return __spreadProps(__spreadValues({},t),{x:y.x-o,y:y.y,width:o,height:s});case 180:return __spreadProps(__spreadValues({},t),{x:y.x-s,y:y.y-o});case 270:return __spreadProps(__spreadValues({},t),{x:y.x,y:y.y-s,width:o,height:s});default:return t}}static translateRect2Points(t){const{x:e,y:r,width:n,height:i}=t;return[{x:e,y:r},{x:e+n,y:r},{x:e+n,y:r+i},{x:e,y:r+i}]}static translatePoints2Rect(t,e){if(t.length!==4)return;const{x:r,y:n}=t[0],i=t[1].x-t[0].x,s=t[2].y-t[1].y;return __spreadProps(__spreadValues({},e),{x:r,y:n,width:i,height:s})}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((i,s)=>({begin:i,end:r[(s+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:i,height:s}=t;return __spreadProps(__spreadValues({},t),{x:r*e,y:n*e,width:i*e,height:s*e})}static isRectNotInPolygon(t,e){return this.getRectPointList(t).some(n=>!polygonTool.isInPolygon(n,e))}}module.exports=RectUtils;
+'use strict';
+
+var AxisUtils = require('./AxisUtils.js');
+var CommonToolUtils = require('./CommonToolUtils.js');
+var polygonTool = require('./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["default"].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) => !polygonTool.isInPolygon(p, polygonPointList));
+  }
+}
+
+module.exports = RectUtils;