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

package/es/utils/tool/ImgPosUtils.js

@@ -1 +1,56 @@
-class x{static getInitImgPos(n,t,h=0,c=1,r=!1){(h===90||h===270)&&(t={width:t.height,height:t.width});const d=n.width*c/t.width,i=n.height*c/t.height;let o=r?1:Math.min(d,i);const e={x:(n.width-t.width*o)/2,y:(n.height-t.height*o)/2},s=t.width*o,w=t.height*o;return r&&(o=1),{zoom:o,currentPos:e,imgInfo:{width:s,height:w}}}static getBasicRecPos(n,t,h,c=.9,r=1,d=!1){if(t&&n){const{x:i,y:o,height:e,width:s}=t;let w=h.height/e;s/e>h.width/h.height&&(w=h.width/s);const l=d?1:w*c*r,f={x:h.width/2,y:h.height/2},g={x:(i+s/2)*l,y:(o+e/2)*l};return{currentPos:{x:f.x-g.x,y:f.y-g.y},innerZoom:l}}return!1}}export{x as default};
+class ImgPosUtils {
+  static getInitImgPos(canvasSize, imgSize, rotate = 0, zoomRatio = 1, isOriginalSize = false) {
+    if (rotate === 90 || rotate === 270) {
+      imgSize = {
+        width: imgSize.height,
+        height: imgSize.width
+      };
+    }
+    const wScale = canvasSize.width * zoomRatio / imgSize.width;
+    const hScale = canvasSize.height * zoomRatio / imgSize.height;
+    let scale = isOriginalSize ? 1 : Math.min(wScale, hScale);
+    const currentPos = {
+      x: (canvasSize.width - imgSize.width * scale) / 2,
+      y: (canvasSize.height - imgSize.height * scale) / 2
+    };
+    const width = imgSize.width * scale;
+    const height = imgSize.height * scale;
+    if (isOriginalSize) {
+      scale = 1;
+    }
+    return {
+      zoom: scale,
+      currentPos,
+      imgInfo: {width, height}
+    };
+  }
+  static getBasicRecPos(imgNode, basicRect, size, shrinkRatio = 0.9, zoomRatio = 1, isOriginalSize = false) {
+    if (basicRect && imgNode) {
+      const {x, y, height, width} = basicRect;
+      let initZoom = size.height / height;
+      if (width / height > size.width / size.height) {
+        initZoom = size.width / width;
+      }
+      const zoom = isOriginalSize ? 1 : initZoom * shrinkRatio * zoomRatio;
+      const viewCenter = {
+        x: size.width / 2,
+        y: size.height / 2
+      };
+      const imgCenter = {
+        x: (x + width / 2) * zoom,
+        y: (y + height / 2) * zoom
+      };
+      const currentPos = {
+        x: viewCenter.x - imgCenter.x,
+        y: viewCenter.y - imgCenter.y
+      };
+      return {
+        currentPos,
+        innerZoom: zoom
+      };
+    }
+    return false;
+  }
+}
+
+export { ImgPosUtils as default };

package/es/utils/tool/LineToolUtils.js

@@ -1 +1,255 @@
-import{EToolName as B,ELineTypes as R}from"../../constant/tool.js";import{createSmoothCurvePointsFromPointList as N}from"./polygonTool.js";import M from"./PolygonUtils.js";import O from"../MathUtils.js";var F=Object.defineProperty,S=Object.defineProperties,W=Object.getOwnPropertyDescriptors,b=Object.getOwnPropertySymbols,q=Object.prototype.hasOwnProperty,V=Object.prototype.propertyIsEnumerable,E=(t,n,o)=>n in t?F(t,n,{enumerable:!0,configurable:!0,writable:!0,value:o}):t[n]=o,x=(t,n)=>{for(var o in n||(n={}))q.call(n,o)&&E(t,o,n[o]);if(b)for(var o of b(n))V.call(n,o)&&E(t,o,n[o]);return t},C=(t,n)=>S(t,W(n)),D;(function(t){t[t.Create=0]="Create",t[t.Active=1]="Active",t[t.Edit=1]="Edit",t[t.None=2]="None"})(D||(D={}));var I;(function(t){t.ActiveArea="#B3B8FF"})(I||(I={}));const L=16,G=3,f=class{static isInLine(t,n,o,i=3){const{length:r}=O.getFootOfPerpendicular(t,n,o);return r<i}};let p=f;p.setSpecialEdgeStyle=t=>{t.lineCap="butt",t.setLineDash([10,10])},p.setReferenceCtx=t=>{t.lineCap="butt",t.setLineDash([6])},p.calcOptimalIntersection=(t,n,o,i,r)=>{let c,y=Infinity,a;if(t.find((g,e)=>{if(e===0)return;const s=f.isInLine(n.pointA,g,t[e-1]),l=f.isInLine(n.pointB,g,t[e-1]);return s&&l}))return{point:o};if(t.forEach((g,e)=>{if(e===0)return;const s={pointA:t[e-1],pointB:g},l=f.lineIntersection(n,s);if(l&&n){const{onLine2:P,onLine1:h,x:m,y:_}=l,v=f.calcDistance(o,l);if(f.isOnLine(n.pointB.x,n.pointB.y,g.x,g.y,t[e-1].x,t[e-1].y)){if(f.calcDistance(o,l)<i/r){const T=n.pointB,{footPoint:A,length:w}=O.getFootOfPerpendicular(T,s.pointA,s.pointB,!0);if(w!==void 0){const j=f.calcDistance(s.pointA,A),U=f.calcDistance(s.pointB,A);a={point:A,minDistance:w},w===Infinity&&(a.point=j>U?s.pointB:s.pointA)}}return}v<y&&P&&h&&(y=v,c={x:m,y:_})}}),c)return{point:c,minDistance:y};if(a)return a},p.lineIntersection=(t,n)=>{let o=!1,i=!1;const r=f.getAxisDiff(t),c=f.getAxisDiff(n),y=c.y*r.x-c.x*r.y;if(y===0)return!1;let a=t.pointA.y-n.pointA.y,u=t.pointA.x-n.pointA.x;const g=(n.pointB.x-n.pointA.x)*a-(n.pointB.y-n.pointA.y)*u,e=(t.pointB.x-t.pointA.x)*a-(t.pointB.y-t.pointA.y)*u;a=g/y,u=e/y,a>0&&a<1&&(o=!0),u>0&&u<1&&(i=!0);const s=t.pointA.x+a*(t.pointB.x-t.pointA.x),l=t.pointA.y+a*(t.pointB.y-t.pointA.y);return{x:s,y:l,onLine1:o,onLine2:i}},p.getAxisDiff=t=>({x:t.pointB.x-t.pointA.x,y:t.pointB.y-t.pointA.y}),p.calcDistance=(t,n)=>Math.sqrt(Math.pow(Math.abs(t.x-n.x),2)+Math.pow(Math.abs(t.y-n.y),2)),p.drawCurveLine=(t,n,o,i=!0,r=!1,c)=>{const y=N(n,L);t.save(),t.lineCap="round",t.lineJoin="round",t.strokeStyle=o.color,i&&(t.lineWidth=o.lineWidth),r&&f.setReferenceCtx(t),n.forEach((a,u)=>{const g=a==null?void 0:a.specialEdge,e=y.splice(0,L+1);t.save(),t.beginPath(),c===u&&(t.lineWidth=4),e.forEach(({x:s,y:l},P)=>{const h=P>0?"lineTo":"moveTo";g&&f.setSpecialEdgeStyle(t),t[h](s,l)}),t.stroke(),t.restore()}),t.restore()},p.calcTwoPointDistance=(t,n)=>Math.sqrt(Math.pow(t.x-n.x,2)+Math.pow(t.y-n.y,2)),p.pointOverTarget=(t,n,o,i,r,c,y,a,u,g)=>{const e=t;if(!n)return t;if(o===B.Polygon){const s=f.getPolygonPointList(i,r);if(s.length===0||M.isInPolygon(t,s))return e;const P=s.concat(s[0]).map(d=>u(d)),h=u(n),m=u(t),_={pointA:h,pointB:m},v=f.calcOptimalIntersection(P,_,h,y,a);if(v){const d=g(v==null?void 0:v.point);e.x=d.x,e.y=d.y}else return n;return e}if(o===B.Rect){const{x:s,y:l,width:P,height:h}=i;return e.x=O.withinRange(e.x,[s,s+P]),e.y=O.withinRange(e.y,[l,l+h]),e}return e.x=O.withinRange(e.x,[0,c.width]),e.y=O.withinRange(e.y,[0,c.height]),e},p.getPolygonPointList=(t,n)=>{const{pointList:o}=t,{lineType:i}=n;return i===R.Line?o:M.createSmoothCurvePoints(o.reduce((r,c)=>[...r,c.x,c.y],[]),.5,!0,20)},p.isOnLine=(t,n,o,i,r,c)=>Math.abs((a=>(i-n)/(o-t)*(a-t)+n)(r)-c)<1e-6&&r>=t&&r<=o,p.inArea=({top:t,left:n,right:o,bottom:i},{x:r,y:c})=>c>=t&&c<=i&&r>=n&&r<=o,p.getVHPoint=(t,n,o,i)=>{const r=f.getAngle(t,o);return Math.abs(r)<45?C(x({},n),{y:i.y}):C(x({},n),{x:i.x})},p.getAngle=(t,n)=>{const o=n.x-t.x,i=n.y-t.y;return 360*Math.atan(i/o)/(2*Math.PI)};export{I as EColor,D as EStatus,G as POINT_RADIUS,L as SEGMENT_NUMBER,p as default};
+import { EToolName, ELineTypes } from '../../constant/tool.js';
+import { createSmoothCurvePointsFromPointList } from './polygonTool.js';
+import PolygonUtils from './PolygonUtils.js';
+import MathUtils from '../MathUtils.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));
+var EStatus;
+(function(EStatus2) {
+  EStatus2[EStatus2["Create"] = 0] = "Create";
+  EStatus2[EStatus2["Active"] = 1] = "Active";
+  EStatus2[EStatus2["Edit"] = 1] = "Edit";
+  EStatus2[EStatus2["None"] = 2] = "None";
+})(EStatus || (EStatus = {}));
+var EColor;
+(function(EColor2) {
+  EColor2["ActiveArea"] = "#B3B8FF";
+})(EColor || (EColor = {}));
+const SEGMENT_NUMBER = 16;
+const POINT_RADIUS = 3;
+const _LineToolUtils = class {
+  static isInLine(checkPoint, point1, point2, scope = 3) {
+    const {length} = MathUtils.getFootOfPerpendicular(checkPoint, point1, point2);
+    if (length < scope) {
+      return true;
+    }
+    return false;
+  }
+};
+let LineToolUtils = _LineToolUtils;
+LineToolUtils.setSpecialEdgeStyle = (ctx) => {
+  ctx.lineCap = "butt";
+  ctx.setLineDash([10, 10]);
+};
+LineToolUtils.setReferenceCtx = (ctx) => {
+  ctx.lineCap = "butt";
+  ctx.setLineDash([6]);
+};
+LineToolUtils.calcOptimalIntersection = (pointList, matchLine, matchPoint, pointRadius, zoom) => {
+  let optimalIntersection;
+  let minDistance = Infinity;
+  let scopeIntersection;
+  const matchLineOnExistLine = pointList.find((p, index) => {
+    if (index === 0) {
+      return;
+    }
+    const pointAOnLine = _LineToolUtils.isInLine(matchLine.pointA, p, pointList[index - 1]);
+    const pointBOnLine = _LineToolUtils.isInLine(matchLine.pointB, p, pointList[index - 1]);
+    return pointAOnLine && pointBOnLine;
+  });
+  if (matchLineOnExistLine) {
+    return {point: matchPoint};
+  }
+  pointList.forEach((point, index) => {
+    if (index === 0) {
+      return;
+    }
+    const line2 = {
+      pointA: pointList[index - 1],
+      pointB: point
+    };
+    const intersection = _LineToolUtils.lineIntersection(matchLine, line2);
+    if (intersection && matchLine) {
+      const {onLine2, onLine1, x, y} = intersection;
+      const distance = _LineToolUtils.calcDistance(matchPoint, intersection);
+      const matchPointInLine = _LineToolUtils.isOnLine(matchLine.pointB.x, matchLine.pointB.y, point.x, point.y, pointList[index - 1].x, pointList[index - 1].y);
+      if (matchPointInLine) {
+        const intersectionDistance = _LineToolUtils.calcDistance(matchPoint, intersection);
+        if (intersectionDistance < pointRadius / zoom) {
+          const cPoint = matchLine.pointB;
+          const {footPoint, length} = MathUtils.getFootOfPerpendicular(cPoint, line2.pointA, line2.pointB, true);
+          if (length !== void 0) {
+            const distPointA = _LineToolUtils.calcDistance(line2.pointA, footPoint);
+            const distPointB = _LineToolUtils.calcDistance(line2.pointB, footPoint);
+            scopeIntersection = {
+              point: footPoint,
+              minDistance: length
+            };
+            if (length === Infinity) {
+              scopeIntersection.point = distPointA > distPointB ? line2.pointB : line2.pointA;
+            }
+          }
+        }
+        return;
+      }
+      if (distance < minDistance && onLine2 && onLine1) {
+        minDistance = distance;
+        optimalIntersection = {
+          x,
+          y
+        };
+      }
+    }
+  });
+  if (optimalIntersection) {
+    return {point: optimalIntersection, minDistance};
+  }
+  if (scopeIntersection) {
+    return scopeIntersection;
+  }
+  return void 0;
+};
+LineToolUtils.lineIntersection = (lineA, lineB) => {
+  let onLine1 = false;
+  let onLine2 = false;
+  const lineADiff = _LineToolUtils.getAxisDiff(lineA);
+  const lineBDiff = _LineToolUtils.getAxisDiff(lineB);
+  const denominator = lineBDiff.y * lineADiff.x - lineBDiff.x * lineADiff.y;
+  if (denominator === 0) {
+    return false;
+  }
+  let a = lineA.pointA.y - lineB.pointA.y;
+  let b = lineA.pointA.x - lineB.pointA.x;
+  const numerator1 = (lineB.pointB.x - lineB.pointA.x) * a - (lineB.pointB.y - lineB.pointA.y) * b;
+  const numerator2 = (lineA.pointB.x - lineA.pointA.x) * a - (lineA.pointB.y - lineA.pointA.y) * b;
+  a = numerator1 / denominator;
+  b = numerator2 / denominator;
+  if (a > 0 && a < 1) {
+    onLine1 = true;
+  }
+  if (b > 0 && b < 1) {
+    onLine2 = true;
+  }
+  const x = lineA.pointA.x + a * (lineA.pointB.x - lineA.pointA.x);
+  const y = lineA.pointA.y + a * (lineA.pointB.y - lineA.pointA.y);
+  return {x, y, onLine1, onLine2};
+};
+LineToolUtils.getAxisDiff = (line) => {
+  return {
+    x: line.pointB.x - line.pointA.x,
+    y: line.pointB.y - line.pointA.y
+  };
+};
+LineToolUtils.calcDistance = (point1, point2) => {
+  return Math.sqrt(Math.pow(Math.abs(point1.x - point2.x), 2) + Math.pow(Math.abs(point1.y - point2.y), 2));
+};
+LineToolUtils.drawCurveLine = (ctx, points, config, applyLineWidth = true, isReference = false, hoverEdgeIndex) => {
+  const pointList = createSmoothCurvePointsFromPointList(points, SEGMENT_NUMBER);
+  ctx.save();
+  ctx.lineCap = "round";
+  ctx.lineJoin = "round";
+  ctx.strokeStyle = config.color;
+  if (applyLineWidth) {
+    ctx.lineWidth = config.lineWidth;
+  }
+  if (isReference) {
+    _LineToolUtils.setReferenceCtx(ctx);
+  }
+  points.forEach((point, index) => {
+    const specialEdge = point == null ? void 0 : point.specialEdge;
+    const curveLinePoints = pointList.splice(0, SEGMENT_NUMBER + 1);
+    ctx.save();
+    ctx.beginPath();
+    if (hoverEdgeIndex === index) {
+      ctx.lineWidth = 4;
+    }
+    curveLinePoints.forEach(({x, y}, pointIndex) => {
+      const fn = pointIndex > 0 ? "lineTo" : "moveTo";
+      if (specialEdge) {
+        _LineToolUtils.setSpecialEdgeStyle(ctx);
+      }
+      ctx[fn](x, y);
+    });
+    ctx.stroke();
+    ctx.restore();
+  });
+  ctx.restore();
+};
+LineToolUtils.calcTwoPointDistance = (pointA, pointB) => Math.sqrt(Math.pow(pointA.x - pointB.x, 2) + Math.pow(pointA.y - pointB.y, 2));
+LineToolUtils.pointOverTarget = (axis, preAxis, dependToolName, dependData, dependConfig, imageSize, pointRadius, zoom, getRenderAxis, getAbsAxis) => {
+  const absAxis = axis;
+  if (!preAxis) {
+    return axis;
+  }
+  if (dependToolName === EToolName.Polygon) {
+    const polygonPointList = _LineToolUtils.getPolygonPointList(dependData, dependConfig);
+    if (polygonPointList.length === 0) {
+      return absAxis;
+    }
+    const inPolygon = PolygonUtils.isInPolygon(axis, polygonPointList);
+    if (inPolygon) {
+      return absAxis;
+    }
+    const pointList = polygonPointList.concat(polygonPointList[0]).map((i) => getRenderAxis(i));
+    const pointA = getRenderAxis(preAxis);
+    const pointB = getRenderAxis(axis);
+    const line1 = {
+      pointA,
+      pointB
+    };
+    const intersection = _LineToolUtils.calcOptimalIntersection(pointList, line1, pointA, pointRadius, zoom);
+    if (intersection) {
+      const intersectionAbsAxis = getAbsAxis(intersection == null ? void 0 : intersection.point);
+      absAxis.x = intersectionAbsAxis.x;
+      absAxis.y = intersectionAbsAxis.y;
+    } else {
+      return preAxis;
+    }
+    return absAxis;
+  }
+  if (dependToolName === EToolName.Rect) {
+    const {x, y, width, height} = dependData;
+    absAxis.x = MathUtils.withinRange(absAxis.x, [x, x + width]);
+    absAxis.y = MathUtils.withinRange(absAxis.y, [y, y + height]);
+    return absAxis;
+  }
+  absAxis.x = MathUtils.withinRange(absAxis.x, [0, imageSize.width]);
+  absAxis.y = MathUtils.withinRange(absAxis.y, [0, imageSize.height]);
+  return absAxis;
+};
+LineToolUtils.getPolygonPointList = (dependData, dependConfig) => {
+  const {pointList} = dependData;
+  const {lineType} = dependConfig;
+  return lineType === ELineTypes.Line ? pointList : PolygonUtils.createSmoothCurvePoints(pointList.reduce((acc, cur) => {
+    return [...acc, cur.x, cur.y];
+  }, []), 0.5, true, 20);
+};
+LineToolUtils.isOnLine = (x, y, endX, endY, px, py) => {
+  const f = (someX) => {
+    return (endY - y) / (endX - x) * (someX - x) + y;
+  };
+  return Math.abs(f(px) - py) < 1e-6 && px >= x && px <= endX;
+};
+LineToolUtils.inArea = ({top, left, right, bottom}, {x, y}) => y >= top && y <= bottom && x >= left && x <= right;
+LineToolUtils.getVHPoint = (lastPoint, nextPoint, absNextPoint, renderLastPoint) => {
+  const angle = _LineToolUtils.getAngle(lastPoint, absNextPoint);
+  if (Math.abs(angle) < 45) {
+    return __spreadProps(__spreadValues({}, nextPoint), {y: renderLastPoint.y});
+  }
+  return __spreadProps(__spreadValues({}, nextPoint), {x: renderLastPoint.x});
+};
+LineToolUtils.getAngle = (startPoint, endPoint) => {
+  const diffX = endPoint.x - startPoint.x;
+  const diffY = endPoint.y - startPoint.y;
+  return 360 * Math.atan(diffY / diffX) / (2 * Math.PI);
+};
+
+export { EColor, EStatus, POINT_RADIUS, SEGMENT_NUMBER, LineToolUtils as default };

package/es/utils/tool/MarkerUtils.js

@@ -1 +1,54 @@
-import{cloneDeep as c}from"lodash";import f from"./AttributeUtils.js";class u{static getMarkerShowText(t,r=[]){return f.getAttributeShowText(t,r)}}u.getAuxiliaryLineByMarkerList=(o,t)=>{var r;const s=c(o),l=[];let e=s.shift();for(;e;)(r=e.target)==null||r.forEach(n=>{const i=s.find(a=>a.value===n);i&&(e==null?void 0:e[t])&&l.push({start:e[t],end:i[t]})}),e=s.shift();return l},u.getAuxiliaryLineCoord=(o,t)=>{const r=[];return o.forEach(s=>{const{start:l,end:e}=s,n=t.find(a=>a.label===l);if(!n)return;const i=t.find(a=>a.label===e);!i||r.push({start:{x:n.x,y:n.y},end:{x:i.x,y:i.y}})}),r};export{u as default};
+import { cloneDeep } from 'lodash';
+import AttributeUtils from './AttributeUtils.js';
+
+class MarkerUtils {
+  static getMarkerShowText(marker, markerList = []) {
+    return AttributeUtils.getAttributeShowText(marker, markerList);
+  }
+}
+MarkerUtils.getAuxiliaryLineByMarkerList = (markerList, attr) => {
+  var _a;
+  const queue = cloneDeep(markerList);
+  const auxiliaryLines = [];
+  let currentNode = queue.shift();
+  while (currentNode) {
+    (_a = currentNode.target) == null ? void 0 : _a.forEach((element) => {
+      const targetMarkerListItem = queue.find((i) => i.value === element);
+      if (targetMarkerListItem && (currentNode == null ? void 0 : currentNode[attr])) {
+        auxiliaryLines.push({
+          start: currentNode[attr],
+          end: targetMarkerListItem[attr]
+        });
+      }
+    });
+    currentNode = queue.shift();
+  }
+  return auxiliaryLines;
+};
+MarkerUtils.getAuxiliaryLineCoord = (auxiliaryLines, pointList) => {
+  const result = [];
+  auxiliaryLines.forEach((line) => {
+    const {start, end} = line;
+    const startPoint = pointList.find((item) => item.label === start);
+    if (!startPoint) {
+      return;
+    }
+    const targetPoint = pointList.find((item) => item.label === end);
+    if (!targetPoint) {
+      return;
+    }
+    result.push({
+      start: {
+        x: startPoint.x,
+        y: startPoint.y
+      },
+      end: {
+        x: targetPoint.x,
+        y: targetPoint.y
+      }
+    });
+  });
+  return result;
+};
+
+export { MarkerUtils as default };