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

package/dist/utils/tool/ImgPosUtils.js

@@ -1 +1,58 @@
-"use strict";class ImgPosUtils{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,g={x:h.width/2,y:h.height/2},f={x:(i+s/2)*l,y:(o+e/2)*l};return{currentPos:{x:g.x-f.x,y:g.y-f.y},innerZoom:l}}return!1}}module.exports=ImgPosUtils;
+'use strict';
+
+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;
+  }
+}
+
+module.exports = ImgPosUtils;

package/dist/utils/tool/LineToolUtils.js

@@ -1 +1,261 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var tool=require("../../constant/tool.js"),polygonTool=require("./polygonTool.js"),PolygonUtils=require("./PolygonUtils.js"),MathUtils=require("../MathUtils.js"),__defProp=Object.defineProperty,__defProps=Object.defineProperties,__getOwnPropDescs=Object.getOwnPropertyDescriptors,__getOwnPropSymbols=Object.getOwnPropertySymbols,__hasOwnProp=Object.prototype.hasOwnProperty,__propIsEnum=Object.prototype.propertyIsEnumerable,__defNormalProp=(t,n,e)=>n in t?__defProp(t,n,{enumerable:!0,configurable:!0,writable:!0,value:e}):t[n]=e,__spreadValues=(t,n)=>{for(var e in n||(n={}))__hasOwnProp.call(n,e)&&__defNormalProp(t,e,n[e]);if(__getOwnPropSymbols)for(var e of __getOwnPropSymbols(n))__propIsEnum.call(n,e)&&__defNormalProp(t,e,n[e]);return t},__spreadProps=(t,n)=>__defProps(t,__getOwnPropDescs(n));exports.EStatus=void 0,function(t){t[t.Create=0]="Create",t[t.Active=1]="Active",t[t.Edit=1]="Edit",t[t.None=2]="None"}(exports.EStatus||(exports.EStatus={})),exports.EColor=void 0,function(t){t.ActiveArea="#B3B8FF"}(exports.EColor||(exports.EColor={}));const SEGMENT_NUMBER=16,POINT_RADIUS=3,_LineToolUtils=class{static isInLine(t,n,e,i=3){const{length:r}=MathUtils.default.getFootOfPerpendicular(t,n,e);return r<i}};let LineToolUtils=_LineToolUtils;LineToolUtils.setSpecialEdgeStyle=t=>{t.lineCap="butt",t.setLineDash([10,10])},LineToolUtils.setReferenceCtx=t=>{t.lineCap="butt",t.setLineDash([6])},LineToolUtils.calcOptimalIntersection=(t,n,e,i,r)=>{let a,p=Infinity,c;if(t.find((u,o)=>{if(o===0)return;const s=_LineToolUtils.isInLine(n.pointA,u,t[o-1]),l=_LineToolUtils.isInLine(n.pointB,u,t[o-1]);return s&&l}))return{point:e};if(t.forEach((u,o)=>{if(o===0)return;const s={pointA:t[o-1],pointB:u},l=_LineToolUtils.lineIntersection(n,s);if(l&&n){const{onLine2:g,onLine1:y,x:d,y:v}=l,h=_LineToolUtils.calcDistance(e,l);if(_LineToolUtils.isOnLine(n.pointB.x,n.pointB.y,u.x,u.y,t[o-1].x,t[o-1].y)){if(_LineToolUtils.calcDistance(e,l)<i/r){const x=n.pointB,{footPoint:O,length:_}=MathUtils.default.getFootOfPerpendicular(x,s.pointA,s.pointB,!0);if(_!==void 0){const A=_LineToolUtils.calcDistance(s.pointA,O),E=_LineToolUtils.calcDistance(s.pointB,O);c={point:O,minDistance:_},_===Infinity&&(c.point=A>E?s.pointB:s.pointA)}}return}h<p&&g&&y&&(p=h,a={x:d,y:v})}}),a)return{point:a,minDistance:p};if(c)return c},LineToolUtils.lineIntersection=(t,n)=>{let e=!1,i=!1;const r=_LineToolUtils.getAxisDiff(t),a=_LineToolUtils.getAxisDiff(n),p=a.y*r.x-a.x*r.y;if(p===0)return!1;let c=t.pointA.y-n.pointA.y,f=t.pointA.x-n.pointA.x;const u=(n.pointB.x-n.pointA.x)*c-(n.pointB.y-n.pointA.y)*f,o=(t.pointB.x-t.pointA.x)*c-(t.pointB.y-t.pointA.y)*f;c=u/p,f=o/p,c>0&&c<1&&(e=!0),f>0&&f<1&&(i=!0);const s=t.pointA.x+c*(t.pointB.x-t.pointA.x),l=t.pointA.y+c*(t.pointB.y-t.pointA.y);return{x:s,y:l,onLine1:e,onLine2:i}},LineToolUtils.getAxisDiff=t=>({x:t.pointB.x-t.pointA.x,y:t.pointB.y-t.pointA.y}),LineToolUtils.calcDistance=(t,n)=>Math.sqrt(Math.pow(Math.abs(t.x-n.x),2)+Math.pow(Math.abs(t.y-n.y),2)),LineToolUtils.drawCurveLine=(t,n,e,i=!0,r=!1,a)=>{const p=polygonTool.createSmoothCurvePointsFromPointList(n,SEGMENT_NUMBER);t.save(),t.lineCap="round",t.lineJoin="round",t.strokeStyle=e.color,i&&(t.lineWidth=e.lineWidth),r&&_LineToolUtils.setReferenceCtx(t),n.forEach((c,f)=>{const u=c==null?void 0:c.specialEdge,o=p.splice(0,SEGMENT_NUMBER+1);t.save(),t.beginPath(),a===f&&(t.lineWidth=4),o.forEach(({x:s,y:l},g)=>{const y=g>0?"lineTo":"moveTo";u&&_LineToolUtils.setSpecialEdgeStyle(t),t[y](s,l)}),t.stroke(),t.restore()}),t.restore()},LineToolUtils.calcTwoPointDistance=(t,n)=>Math.sqrt(Math.pow(t.x-n.x,2)+Math.pow(t.y-n.y,2)),LineToolUtils.pointOverTarget=(t,n,e,i,r,a,p,c,f,u)=>{const o=t;if(!n)return t;if(e===tool.EToolName.Polygon){const s=_LineToolUtils.getPolygonPointList(i,r);if(s.length===0||PolygonUtils.isInPolygon(t,s))return o;const g=s.concat(s[0]).map(P=>f(P)),y=f(n),d=f(t),v={pointA:y,pointB:d},h=_LineToolUtils.calcOptimalIntersection(g,v,y,p,c);if(h){const P=u(h==null?void 0:h.point);o.x=P.x,o.y=P.y}else return n;return o}if(e===tool.EToolName.Rect){const{x:s,y:l,width:g,height:y}=i;return o.x=MathUtils.default.withinRange(o.x,[s,s+g]),o.y=MathUtils.default.withinRange(o.y,[l,l+y]),o}return o.x=MathUtils.default.withinRange(o.x,[0,a.width]),o.y=MathUtils.default.withinRange(o.y,[0,a.height]),o},LineToolUtils.getPolygonPointList=(t,n)=>{const{pointList:e}=t,{lineType:i}=n;return i===tool.ELineTypes.Line?e:PolygonUtils.createSmoothCurvePoints(e.reduce((r,a)=>[...r,a.x,a.y],[]),.5,!0,20)},LineToolUtils.isOnLine=(t,n,e,i,r,a)=>Math.abs((c=>(i-n)/(e-t)*(c-t)+n)(r)-a)<1e-6&&r>=t&&r<=e,LineToolUtils.inArea=({top:t,left:n,right:e,bottom:i},{x:r,y:a})=>a>=t&&a<=i&&r>=n&&r<=e,LineToolUtils.getVHPoint=(t,n,e,i)=>{const r=_LineToolUtils.getAngle(t,e);return Math.abs(r)<45?__spreadProps(__spreadValues({},n),{y:i.y}):__spreadProps(__spreadValues({},n),{x:i.x})},LineToolUtils.getAngle=(t,n)=>{const e=n.x-t.x,i=n.y-t.y;return 360*Math.atan(i/e)/(2*Math.PI)},exports.POINT_RADIUS=POINT_RADIUS,exports.SEGMENT_NUMBER=SEGMENT_NUMBER,exports.default=LineToolUtils;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tool = require('../../constant/tool.js');
+var polygonTool = require('./polygonTool.js');
+var PolygonUtils = require('./PolygonUtils.js');
+var MathUtils = require('../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));
+exports.EStatus = void 0;
+(function(EStatus2) {
+  EStatus2[EStatus2["Create"] = 0] = "Create";
+  EStatus2[EStatus2["Active"] = 1] = "Active";
+  EStatus2[EStatus2["Edit"] = 1] = "Edit";
+  EStatus2[EStatus2["None"] = 2] = "None";
+})(exports.EStatus || (exports.EStatus = {}));
+exports.EColor = void 0;
+(function(EColor2) {
+  EColor2["ActiveArea"] = "#B3B8FF";
+})(exports.EColor || (exports.EColor = {}));
+const SEGMENT_NUMBER = 16;
+const POINT_RADIUS = 3;
+const _LineToolUtils = class {
+  static isInLine(checkPoint, point1, point2, scope = 3) {
+    const {length} = MathUtils["default"].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["default"].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 = polygonTool.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 === tool.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 === tool.EToolName.Rect) {
+    const {x, y, width, height} = dependData;
+    absAxis.x = MathUtils["default"].withinRange(absAxis.x, [x, x + width]);
+    absAxis.y = MathUtils["default"].withinRange(absAxis.y, [y, y + height]);
+    return absAxis;
+  }
+  absAxis.x = MathUtils["default"].withinRange(absAxis.x, [0, imageSize.width]);
+  absAxis.y = MathUtils["default"].withinRange(absAxis.y, [0, imageSize.height]);
+  return absAxis;
+};
+LineToolUtils.getPolygonPointList = (dependData, dependConfig) => {
+  const {pointList} = dependData;
+  const {lineType} = dependConfig;
+  return lineType === tool.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);
+};
+
+exports.POINT_RADIUS = POINT_RADIUS;
+exports.SEGMENT_NUMBER = SEGMENT_NUMBER;
+exports["default"] = LineToolUtils;

package/dist/utils/tool/MarkerUtils.js

@@ -1 +1,56 @@
-"use strict";var _=require("lodash"),AttributeUtils=require("./AttributeUtils.js");class MarkerUtils{static getMarkerShowText(t,r=[]){return AttributeUtils.default.getAttributeShowText(t,r)}}MarkerUtils.getAuxiliaryLineByMarkerList=(u,t)=>{var r;const s=_.cloneDeep(u),l=[];let e=s.shift();for(;e;)(r=e.target)==null||r.forEach(a=>{const i=s.find(n=>n.value===a);i&&(e==null?void 0:e[t])&&l.push({start:e[t],end:i[t]})}),e=s.shift();return l},MarkerUtils.getAuxiliaryLineCoord=(u,t)=>{const r=[];return u.forEach(s=>{const{start:l,end:e}=s,a=t.find(n=>n.label===l);if(!a)return;const i=t.find(n=>n.label===e);!i||r.push({start:{x:a.x,y:a.y},end:{x:i.x,y:i.y}})}),r},module.exports=MarkerUtils;
+'use strict';
+
+var _ = require('lodash');
+var AttributeUtils = require('./AttributeUtils.js');
+
+class MarkerUtils {
+  static getMarkerShowText(marker, markerList = []) {
+    return AttributeUtils["default"].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;
+};
+
+module.exports = MarkerUtils;