@labelbee/lb-annotation 1.8.0 → 1.9.0-alpha.2

package/es/utils/tool/LineToolUtils.js

@@ -0,0 +1,255 @@
+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

@@ -0,0 +1,9 @@
+import AttributeUtils from './AttributeUtils.js';
+
+class MarkerUtils {
+  static getMarkerShowText(marker, markerList = []) {
+    return AttributeUtils.getAttributeShowText(marker, markerList);
+  }
+}
+
+export { MarkerUtils as default };