kitchen-simulator 11.0.0-react.18 → 11.0.0

package/lib/utils/geometry.js

@@ -0,0 +1,3230 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContainsPoint = ContainsPoint;
+exports._twoLineSegmentsIntersection = _twoLineSegmentsIntersection;
+exports.absAngleBetweenTwoPoints = absAngleBetweenTwoPoints;
+exports.almostEqual = void 0;
+exports.angleBetweenTwoLines = angleBetweenTwoLines;
+exports.angleBetweenTwoPoints = angleBetweenTwoPoints;
+exports.angleBetweenTwoPointsAndOrigin = angleBetweenTwoPointsAndOrigin;
+exports.buildRectFromLines = buildRectFromLines;
+exports.calcCreateSnap = calcCreateSnap;
+exports.calcDistancesFromHoleToNearestOneOrWall = calcDistancesFromHoleToNearestOneOrWall;
+exports.calcDistancesFromItemToWalls = calcDistancesFromItemToWalls;
+exports.calcSnap = calcSnap;
+exports.calcSnap1 = calcSnap1;
+exports.calcSnap2 = calcSnap2;
+exports.calcSnap3 = calcSnap3;
+exports.clone_point = clone_point;
+exports.closestPointFromLine = closestPointFromLine;
+exports.closestPointFromLineSegment = closestPointFromLineSegment;
+exports.compareVertices = compareVertices;
+exports.containLine = containLine;
+exports.containPointInRect = containPointInRect;
+exports.cosWithThreshold = cosWithThreshold;
+exports.crossprod = crossprod;
+exports.diff = diff;
+exports.distancePointFromLine = distancePointFromLine;
+exports.distancePointFromLineSegment = distancePointFromLineSegment;
+exports.dotprod = dotprod;
+exports.downcrossLine = downcrossLine;
+exports.extendLine = extendLine;
+exports.findCatalogElement = findCatalogElement;
+exports.getAllArea = getAllArea;
+exports.getAllAreaLines = getAllAreaLines;
+exports.getAllCurSnap = getAllCurSnap;
+exports.getAllHoleRect = getAllHoleRect;
+exports.getAllItemSnap = getAllItemSnap;
+exports.getAllItemSpecified = getAllItemSpecified;
+exports.getAllItems = getAllItems;
+exports.getAllLineSnap = getAllLineSnap;
+exports.getAllLines = getAllLines;
+exports.getCalcRectFromItem = getCalcRectFromItem;
+exports.getCalcRectFromItem3D = getCalcRectFromItem3D;
+exports.getCalcRectFromLine = getCalcRectFromLine;
+exports.getCentroidOfPolygon = getCentroidOfPolygon;
+exports.getHoleItems = getHoleItems;
+exports.getInterSect = getInterSect;
+exports.getLineInterSect = getLineInterSect;
+exports.getLineSnapPointsOfItem = getLineSnapPointsOfItem;
+exports.getNormaline = getNormaline;
+exports.getPoylgonPoints = getPoylgonPoints;
+exports.getRelatedLines = void 0;
+exports.getRelatedVertices = getRelatedVertices;
+exports.getSnappedWallLines = getSnappedWallLines;
+exports.horizontalLine = horizontalLine;
+exports.intersectRect = intersectRect;
+exports.isBackWall = isBackWall;
+exports.isFrontWall = isFrontWall;
+exports.isLeftWall = isLeftWall;
+exports.isOverlappedTwoItemsOnOneLine = isOverlappedTwoItemsOnOneLine;
+exports.isPointInArea = isPointInArea;
+exports.isPointInRect = isPointInRect;
+exports.isPointOnLineSegment = isPointOnLineSegment;
+exports.isRightWall = isRightWall;
+exports.isSnappedLine = isSnappedLine;
+exports.isSnappedSideLine = isSnappedSideLine;
+exports.itemInfo = itemInfo;
+exports.linePassingThroughTwoPoints = linePassingThroughTwoPoints;
+exports.mapRange = mapRange;
+exports.maxVertex = maxVertex;
+exports.midPoint = midPoint;
+exports.minVertex = minVertex;
+exports.needSnap = needSnap;
+exports.orderVertices = orderVertices;
+exports.pointPositionOnLineSegment = pointPositionOnLineSegment;
+exports.pointsDistance = pointsDistance;
+exports.relationshipOfTwoOverlappedLines = relationshipOfTwoOverlappedLines;
+exports.relationshipOfTwoOverlappedLines1 = relationshipOfTwoOverlappedLines1;
+exports.relationshipOfTwoOverlappedLines2 = relationshipOfTwoOverlappedLines2;
+exports.rotatePointAroundPoint = rotatePointAroundPoint;
+exports.roundVertex = roundVertex;
+exports.sameDistances = sameDistances;
+exports.sameMDistances = sameMDistances;
+exports.sameMPoints = sameMPoints;
+exports.samePoints = samePoints;
+exports.shrinkRect = shrinkRect;
+exports.sinWithThreshold = sinWithThreshold;
+exports.snapAngleByUnit = snapAngleByUnit;
+exports.twoLineSegmentsIntersection = twoLineSegmentsIntersection;
+exports.twoLinesIntersection = twoLinesIntersection;
+exports.upcrossLine = upcrossLine;
+exports.validInterSect = validInterSect;
+exports.validRect = validRect;
+exports.validSnap = validSnap;
+exports.validateLineSnaps = validateLineSnaps;
+exports.validateSnaps = validateSnaps;
+exports.verticalLine = verticalLine;
+exports.verticesDistance = verticesDistance;
+exports.verticesMidPoint = verticesMidPoint;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _math = require("./math.js");
+var _constants = require("../constants");
+var _convertUnitsLite = require("./convert-units-lite");
+var Three = _interopRequireWildcard(require("three"));
+var _utils = require("../components/viewer2d/utils.js");
+var _helper = require("./helper.js");
+var _export = require("./export.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /** @description Determines the distance between two points
+ *  @param {number} x0 Vertex 0 x
+ *  @param {number} y0 Vertex 0 y
+ *  @param {number} x1 Vertex 1 x
+ *  @param {number} y1 Vertex 1 y
+ *  @return {number}
+ */
+function compareVertices(v0, v1) {
+  return v0.x === v1.x ? v0.y - v1.y : v0.x - v1.x;
+}
+function minVertex(v0, v1) {
+  return compareVertices(v0, v1) > 0 ? v1 : v0;
+}
+function maxVertex(v0, v1) {
+  return compareVertices(v0, v1) > 0 ? v0 : v1;
+}
+function orderVertices(vertices) {
+  return vertices.sort(compareVertices);
+}
+function pointsDistance(x0, y0, x1, y1) {
+  var diff_x = x0 - x1;
+  var diff_y = y0 - y1;
+  return Math.sqrt(diff_x * diff_x + diff_y * diff_y);
+}
+function verticesDistance(v1, v2) {
+  var x0 = v1.x,
+    y0 = v1.y;
+  var x1 = v2.x,
+    y1 = v2.y;
+  return pointsDistance(x0, y0, x1, y1);
+}
+function horizontalLine(y) {
+  return {
+    a: 0,
+    b: 1,
+    c: -y
+  };
+}
+var almostEqual = exports.almostEqual = function almostEqual(x, y) {
+  return Math.abs(x - y) < _constants.EPSILON;
+};
+function verticalLine(x) {
+  return {
+    a: 1,
+    b: 0,
+    c: -x
+  };
+}
+function upcrossLine(x, y) {
+  return {
+    a: 1,
+    b: 1,
+    c: -x - y
+  };
+}
+function downcrossLine(x, y) {
+  return {
+    a: 1,
+    b: -1,
+    c: -x + y
+  };
+}
+function linePassingThroughTwoPoints(x1, y1, x2, y2) {
+  if (x1 === x2 && y1 == y2) throw new Error('Geometry error');
+  //if (x1 === x2) return verticalLine(x1);
+  //if (y1 === y2) return horizontalLine(y1);
+
+  return {
+    a: y1 - y2,
+    b: x2 - x1,
+    c: y2 * x1 - x2 * y1
+  };
+}
+function getNormaline(x1, y1, x2, y2) {
+  var lineFunction = linePassingThroughTwoPoints(x1, y1, x2, y2);
+  return {
+    x: lineFunction.a / Math.sqrt(lineFunction.a * lineFunction.a + lineFunction.b * lineFunction.b),
+    y: lineFunction.b / Math.sqrt(lineFunction.a * lineFunction.a + lineFunction.b * lineFunction.b)
+  };
+}
+function distancePointFromLine(a, b, c, x, y) {
+  //https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
+  return (0, _math.fAbs)(a * x + b * y + c) / Math.sqrt(a * a + b * b);
+}
+function closestPointFromLine(a, b, c, x, y) {
+  //https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
+  var denom = a * a + b * b;
+  return {
+    x: (b * (b * x - a * y) - a * c) / denom,
+    y: (a * -b * x + a * y - b * c) / denom
+  };
+}
+
+/** @description Get point of intersection between two lines using ax+by+c line's equation
+ *  @param {number} a x coefficent of first line
+ *  @param {number} b y coefficent of first line
+ *  @param {number} c costant of first line
+ *  @param {number} j x coefficent of second line
+ *  @param {number} k y coefficent of second line
+ *  @param {number} l costant of second line
+ *  @return {object} {x,y} point's coordinates
+ */
+function twoLinesIntersection(a, b, c, j, k, l) {
+  var angularCoefficientsDiff = b * j - a * k;
+  if (angularCoefficientsDiff === 0) return undefined; //no intersection
+
+  var y = (a * l - c * j) / angularCoefficientsDiff;
+  var x = (c * k - b * l) / angularCoefficientsDiff;
+  return {
+    x: x,
+    y: y
+  };
+}
+function twoLineSegmentsIntersection(p1, p2, p3, p4) {
+  return _twoLineSegmentsIntersection(p1, p2, p3.toJS(), p4.toJS());
+}
+function _twoLineSegmentsIntersection(p1, p2, p3, p4) {
+  //https://github.com/psalaets/line-intersect/blob/master/lib/check-intersection.js
+
+  var x1 = p1.x,
+    y1 = p1.y;
+  var x2 = p2.x,
+    y2 = p2.y;
+  var x3 = p3.x,
+    y3 = p3.y;
+  var x4 = p4.x,
+    y4 = p4.y;
+  var denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+  var numA = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+  var numB = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+  if ((0, _math.fAbs)(denom) <= _constants.EPSILON) {
+    if ((0, _math.fAbs)(numA) <= _constants.EPSILON && (0, _math.fAbs)(numB) <= _constants.EPSILON) {
+      var comparator = function comparator(pa, pb) {
+        return pa.x === pb.x ? pa.y - pb.y : pa.x - pb.x;
+      };
+      var line0 = [p1, p2].sort(comparator);
+      var line1 = [p3, p4].sort(comparator);
+      var _sort = [line0, line1].sort(function (lineA, lineB) {
+          return comparator(lineA[0], lineB[0]);
+        }),
+        _sort2 = (0, _slicedToArray2["default"])(_sort, 2),
+        lineSX = _sort2[0],
+        lineDX = _sort2[1];
+      comparator(lineSX[1], lineDX[0]) < 0 ? 'colinear' : 'none';
+      if (lineSX[1].x === lineDX[0].x) {
+        return {
+          type: lineDX[0].y <= lineSX[1].y ? 'colinear' : 'none'
+        };
+      } else {
+        return {
+          type: lineDX[0].x <= lineSX[1].x ? 'colinear' : 'none'
+        };
+      }
+    }
+    return {
+      type: 'parallel'
+    };
+  }
+  var uA = numA / denom;
+  var uB = numB / denom;
+  if (uA >= 0 - _constants.EPSILON && uA <= 1 + _constants.EPSILON && uB >= 0 - _constants.EPSILON && uB <= 1 + _constants.EPSILON) {
+    var _point = {
+      x: x1 + uA * (x2 - x1),
+      y: y1 + uA * (y2 - y1)
+    };
+    return {
+      type: 'intersecting',
+      point: _point
+    };
+  }
+  return {
+    type: 'none'
+  };
+}
+function distancePointFromLineSegment(v1, v2, xp, yp) {
+  //http://stackoverflow.com/a/6853926/1398836
+  var x1 = v1.x,
+    y1 = v1.y;
+  var x2 = v2.x,
+    y2 = v2.y;
+  var A = xp - x1;
+  var B = yp - y1;
+  var C = x2 - x1;
+  var D = y2 - y1;
+  var dot = A * C + B * D;
+  var len_sq = C * C + D * D;
+  var param = -1;
+  if (len_sq != 0)
+    //in case of 0 length line
+    param = dot / len_sq;
+  var xx, yy;
+  if (param < 0) {
+    xx = x1;
+    yy = y1;
+  } else if (param > 1) {
+    xx = x2;
+    yy = y2;
+  } else {
+    xx = x1 + param * C;
+    yy = y1 + param * D;
+  }
+  var dx = xp - xx;
+  var dy = yp - yy;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ *
+ * @param x1 {number} x for first vertex of the segment
+ * @param y1 {number} y for first vertex of the segment
+ * @param x2 {number} x for second vertex of the segment
+ * @param y2 {number} y for second vertex of the segment
+ * @param xp {number} x for point we want to verify
+ * @param yp {number} y for point we want to verify
+ * @param maxDistance {number} the epsilon value used for comparisons
+ * @returns {boolean} true if the point lies on the line segment false otherwise
+ */
+function isPointOnLineSegment(x1, y1, x2, y2, xp, yp) {
+  var maxDistance = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : _constants.EPSILON;
+  return distancePointFromLineSegment({
+    x: x1,
+    y: y1
+  }, {
+    x: x2,
+    y: y2
+  }, xp, yp) <= maxDistance;
+}
+function closestPointFromLineSegment(x1, y1, x2, y2, xp, yp) {
+  if (x1 === x2) return {
+    x: x1,
+    y: yp
+  };
+  if (y1 === y2) return {
+    x: xp,
+    y: y1
+  };
+  var m = (y2 - y1) / (x2 - x1);
+  var q = y1 - m * x1;
+  var mi = -1 / m;
+  var qi = yp - mi * xp;
+  var x = (qi - q) / (m - mi);
+  var y = m * x + q;
+  return {
+    x: x,
+    y: y
+  };
+}
+function pointPositionOnLineSegment(x1, y1, x2, y2, xp, yp) {
+  var length = pointsDistance(x1, y1, x2, y2);
+  var distance = pointsDistance(x1, y1, xp, yp);
+  var offset = distance / length;
+  /*
+  if (x1 > x2) offset = 1 - offset;
+  if (y1 > y2) offset = 1 - offset;
+  */
+  return offset;
+}
+function mapRange(value, low1, high1, low2, high2) {
+  return low2 + (high2 - low2) * (value - low1) / (high1 - low1);
+}
+function angleBetweenTwoPointsAndOrigin(x1, y1, x2, y2) {
+  return -Math.atan2(y1 - y2, x2 - x1) * 180 / Math.PI;
+}
+function angleBetweenTwoPoints(x1, y1, x2, y2) {
+  return Math.atan2(y2 - y1, x2 - x1);
+}
+function angleBetweenTwoLines(line, drawingLine, vertices) {
+  var points = [];
+
+  // safety guards
+  var lv = Array.isArray(line === null || line === void 0 ? void 0 : line.vertices) ? line.vertices : [];
+  var dv = Array.isArray(drawingLine === null || drawingLine === void 0 ? void 0 : drawingLine.vertices) ? drawingLine.vertices : [];
+
+  // 1) push common vertices (in order of line.vertices)
+  var _iterator = _createForOfIteratorHelper(lv),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var vt = _step.value;
+      if (dv.includes(vt) && !points.includes(vt)) points.push(vt);
+    }
+
+    // 2) push remaining vertices from line.vertices
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var _iterator2 = _createForOfIteratorHelper(lv),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _vt = _step2.value;
+      if (!points.includes(_vt)) points.push(_vt);
+    }
+
+    // 3) push remaining vertices from drawingLine.vertices
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var _iterator3 = _createForOfIteratorHelper(dv),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _vt2 = _step3.value;
+      if (!points.includes(_vt2)) points.push(_vt2);
+    }
+
+    // If no points at all, nothing to compute — return 0 (safe fallback)
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (points.length === 0) return 0;
+
+  // Ensure we have at least 3 entries (same behaviour as original)
+  while (points.length < 3) points.push(points[points.length - 1]);
+  var _points$slice$map = points.slice(0, 3).map(function (idx) {
+      var v = vertices === null || vertices === void 0 ? void 0 : vertices[idx];
+      return v ? new Three.Vector2(v.x, v.y) : new Three.Vector2(0, 0);
+    }),
+    _points$slice$map2 = (0, _slicedToArray2["default"])(_points$slice$map, 3),
+    c = _points$slice$map2[0],
+    p1 = _points$slice$map2[1],
+    p2 = _points$slice$map2[2];
+  var vec1 = p1.clone().sub(c).normalize();
+  var vec2 = p2.clone().sub(c).normalize();
+  return Math.floor(vec1.angle() * 180 / Math.PI - vec2.angle() * 180 / Math.PI + 0.5);
+}
+var getRelatedLines = exports.getRelatedLines = function getRelatedLines(tlines, drawingLine, vertices, lines) {
+  var exceptLineId = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+  if (!(drawingLine !== null && drawingLine !== void 0 && drawingLine.vertices) || !Array.isArray(drawingLine.vertices)) return;
+  var seen = new Set();
+  var _iterator4 = _createForOfIteratorHelper(drawingLine.vertices),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var vIdx = _step4.value;
+      var vertex = vertices === null || vertices === void 0 ? void 0 : vertices[vIdx];
+      if (!(vertex !== null && vertex !== void 0 && vertex.lines)) continue;
+      var _iterator5 = _createForOfIteratorHelper(vertex.lines),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var lineId = _step5.value;
+          if (lineId !== drawingLine.id && lineId !== exceptLineId && !(0, _helper.isEmpty)(lines === null || lines === void 0 ? void 0 : lines[lineId]) && !seen.has(lineId)) {
+            seen.add(lineId);
+            tlines.push(lines[lineId]);
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+};
+function snapAngleByUnit(lineAngle, vertices, drawingLine, x, y, dragVertexId) {
+  var tx, ty;
+  var absAngle = Math.abs(lineAngle);
+  // angle snapping as a value of UNIT_ANGLE
+  var rest = absAngle % _constants.UNIT_ANGLE;
+  var missAngle = _constants.UNIT_ANGLE - rest;
+  var isSingleLine = !drawingLine.vertices.some(function (vetID) {
+    return vertices[vetID].lines.some(function (lineID) {
+      return lineID !== drawingLine.id;
+    });
+  });
+  // the origin point of rotation(snapping)
+  var originVerIndex = drawingLine.vertices.findIndex(function (vertice) {
+    return vertice !== dragVertexId;
+  });
+  var originVerId = originVerIndex < 0 ? drawingLine.vertices[0] : drawingLine.vertices[originVerIndex];
+  var ox = vertices[originVerId].x;
+  var oy = vertices[originVerId].y;
+  // check whether the line is snapped to before point.
+  if (rest <= _constants.UNIT_ANGLE / 2) {
+    // determine the direction of rotation.
+    rest = lineAngle > 0 ? rest : -rest;
+    rest = isSingleLine ? -rest : rest;
+    // rotate the current point to last point around the first point of drawing line.
+    tx = rotatePointAroundPoint(x, y, ox, oy, rest).x;
+    ty = rotatePointAroundPoint(x, y, ox, oy, rest).y;
+  }
+  // check whether the line is snapped to next new point.
+  else if (rest > _constants.UNIT_ANGLE / 2) {
+    // determine the direction of rotation.
+    missAngle = lineAngle > 0 ? -missAngle : missAngle;
+    missAngle = isSingleLine ? -missAngle : missAngle;
+    // rotate the current point to last point around the first point of drawing line.
+    tx = rotatePointAroundPoint(x, y, ox, oy, missAngle).x;
+    ty = rotatePointAroundPoint(x, y, ox, oy, missAngle).y;
+  }
+  var resPoint = {
+    x: tx,
+    y: ty
+  };
+  return resPoint;
+}
+function absAngleBetweenTwoPoints(x1, y1, x2, y2) {
+  return Math.atan2(y2 - y1, Math.abs(x2 - x1));
+}
+function samePoints(_ref, _ref2) {
+  var x1 = _ref.x,
+    y1 = _ref.y;
+  var x2 = _ref2.x,
+    y2 = _ref2.y;
+  return (0, _math.fAbs)(x1 - x2) <= _constants.EPSILON && (0, _math.fAbs)(y1 - y2) <= _constants.EPSILON;
+}
+function sameDistances(dis1, dis2) {
+  return (0, _math.fAbs)(dis1 - dis2) <= _constants.EPSILON;
+}
+function sameMPoints(_ref3, _ref4) {
+  var x1 = _ref3.x,
+    y1 = _ref3.y;
+  var x2 = _ref4.x,
+    y2 = _ref4.y;
+  return (0, _math.fAbs)(x1 - x2) <= _constants.MEPSILON && (0, _math.fAbs)(y1 - y2) <= _constants.MEPSILON;
+}
+function sameMDistances(dis1, dis2) {
+  return (0, _math.fAbs)(dis1 - dis2) <= _constants.MEPSILON;
+}
+function isPointInRect(rect, point) {
+  var result = true;
+  for (var i = 0; i < rect.length; i++) {
+    var pos1 = rect[i];
+    var pos2 = rect[(i + 1) % rect.length];
+    if (isPointOnLineSegment(pos1.x, pos1.y, pos2.x, pos2.y, point.x, point.y)) {
+      result = false;
+    }
+  }
+  return result;
+}
+
+/** @description Extend line based on coordinates and new line length
+ *  @param {number} x1 Vertex 1 x
+ *  @param {number} y1 Vertex 1 y
+ *  @param {number} x2 Vertex 2 x
+ *  @param {number} y2 Vertex 2 y
+ *  @param {number} newDistance New line length
+ *  @return {object}
+ */
+function extendLine(x1, y1, x2, y2, newDistance) {
+  var precision = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 6;
+  var rad = angleBetweenTwoPoints(x1, y1, x2, y2);
+  return {
+    x: (0, _math.toFixedFloat)(x1 + Math.cos(rad) * newDistance, precision),
+    y: (0, _math.toFixedFloat)(y1 + Math.sin(rad) * newDistance, precision)
+  };
+}
+function roundVertex(vertex) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;
+  vertex.set('x', (0, _math.toFixedFloat)(vertex.get('x'), precision));
+  vertex.set('y', (0, _math.toFixedFloat)(vertex.get('y'), precision));
+  return vertex;
+}
+
+//https://github.com/MartyWallace/PolyK
+function ContainsPoint(polygon, pointX, pointY) {
+  var n = polygon.length >> 1;
+  var ax, lup;
+  var ay = polygon[2 * n - 3] - pointY;
+  var bx = polygon[2 * n - 2] - pointX;
+  var by = polygon[2 * n - 1] - pointY;
+  if (bx === 0 && by === 0) return false; // point on edge
+
+  // let lup = by > ay;
+  for (var ii = 0; ii < n; ii++) {
+    ax = bx;
+    ay = by;
+    bx = polygon[2 * ii] - pointX;
+    by = polygon[2 * ii + 1] - pointY;
+    if (bx === 0 && by === 0) return false; // point on edge
+    if (ay === by) continue;
+    lup = by > ay;
+  }
+  var depth = 0;
+  for (var i = 0; i < n; i++) {
+    ax = bx;
+    ay = by;
+    bx = polygon[2 * i] - pointX;
+    by = polygon[2 * i + 1] - pointY;
+    if (ay < 0 && by < 0) continue; // both 'up' or both 'down'
+    if (ay > 0 && by > 0) continue; // both 'up' or both 'down'
+    if (ax < 0 && bx < 0) continue; // both points on the left
+
+    if (ay === by && Math.min(ax, bx) < 0) return true;
+    if (ay === by) continue;
+    var lx = ax + (bx - ax) * -ay / (by - ay);
+    if (lx === 0) return false; // point on edge
+    if (lx > 0) depth++;
+    if (ay === 0 && lup && by > ay) depth--; // hit vertex, both up
+    if (ay === 0 && !lup && by < ay) depth--; // hit vertex, both down
+    lup = by > ay;
+  }
+  return (depth & 1) === 1;
+}
+function cosWithThreshold(alpha, threshold) {
+  var cos = Math.cos(alpha);
+  return cos < threshold ? 0 : cos;
+}
+function sinWithThreshold(alpha, threshold) {
+  var sin = Math.sin(alpha);
+  return sin < threshold ? 0 : sin;
+}
+function midPoint(x1, y1, x2, y2) {
+  return {
+    x: (x1 + x2) / 2,
+    y: (y1 + y2) / 2
+  };
+}
+function verticesMidPoint(verticesArray) {
+  var res = verticesArray.reduce(function (incr, vertex) {
+    return {
+      x: incr.x + vertex.x,
+      y: incr.y + vertex.y
+    };
+  }, {
+    x: 0,
+    y: 0
+  });
+  return {
+    x: res.x / verticesArray.length,
+    y: res.y / verticesArray.length
+  };
+}
+function rotatePointAroundPoint(px, py, ox, oy, theta) {
+  var thetaRad = theta * Math.PI / 180;
+  var cos = Math.cos(thetaRad);
+  var sin = Math.sin(thetaRad);
+  var deltaX = px - ox;
+  var deltaY = py - oy;
+  return {
+    x: cos * deltaX - sin * deltaY + ox,
+    y: sin * deltaX + cos * deltaY + oy
+  };
+}
+
+// point: x,y
+// itemrectInfo: pos(x,y),rotRad,size,layoutpos,is_corner
+// calcRect: rect(point[4]),pos(x,y),rotRad,size,layoutpos,is_corner
+
+function point(x, y) {
+  return {
+    x: x,
+    y: y
+  };
+}
+function itemrectInfo(x, y, rotRad, size, layoutpos, is_corner) {
+  return {
+    pos: {
+      x: x,
+      y: y
+    },
+    rotRad: rotRad,
+    size: size,
+    layoutpos: layoutpos,
+    is_corner: is_corner
+  };
+}
+function getCalcRectFromItem(item) {
+  var itemInfo;
+  if (item === undefined) itemInfo = [];else itemInfo = item.item;
+  var x = item.pos.x;
+  var y = item.pos.y;
+  var rotRad = item.rotRad;
+  var w = item.size && item.size.width / 2;
+  var h = item.size && item.size.height / 2;
+  var mx = x - w * Math.cos(rotRad);
+  var my = y - w * Math.sin(rotRad);
+  var x0 = mx + h * Math.sin(rotRad);
+  var y0 = my - h * Math.cos(rotRad);
+  var x3 = mx * 2 - x0;
+  var y3 = my * 2 - y0;
+  var x1 = x * 2 - x3;
+  var y1 = y * 2 - y3;
+  var x2 = x * 2 - x0;
+  var y2 = y * 2 - y0;
+  return {
+    rect: [point(x0, y0), point(x1, y1), point(x2, y2), point(x3, y3)],
+    pos: point(x, y),
+    rotRad: rotRad,
+    size: item.size,
+    layoutpos: item.layoutpos,
+    is_corner: item.is_corner,
+    itemInfo: itemInfo
+  };
+}
+function getCalcRectFromItem3D(item) {
+  var itemInfo;
+  if (item === undefined) itemInfo = [];else itemInfo = item.item;
+  var x = item.pos.x;
+  var y = item.pos.y;
+  var rotRad = item.rotRad;
+  var w = item.size.width / 2;
+  var h = item.size.depth / 2;
+  var mx = x - w * Math.cos(rotRad);
+  var my = y - w * Math.sin(rotRad);
+  var x0 = mx + h * Math.sin(rotRad);
+  var y0 = my - h * Math.cos(rotRad);
+  var x3 = mx * 2 - x0;
+  var y3 = my * 2 - y0;
+  var x1 = x * 2 - x3;
+  var y1 = y * 2 - y3;
+  var x2 = x * 2 - x0;
+  var y2 = y * 2 - y0;
+  return {
+    rect: [point(x0, y0), point(x1, y1), point(x2, y2), point(x3, y3)],
+    pos: point(x, y),
+    rotRad: rotRad,
+    size: item.size,
+    layoutpos: item.layoutpos,
+    is_corner: item.is_corner,
+    itemInfo: itemInfo
+  };
+}
+function getAllItems(scene, catalog, allLineRects) {
+  var layerID = scene.selectedLayer;
+  var layer = scene.layers.get(layerID);
+  var curiteminfo;
+  var iteminfo = [];
+  var otherItems = [];
+  var selectedItem;
+  var currentItem;
+  if (layer.selected.items.size > 0) {
+    selectedItem = layer.getIn(['items', layer.selected.items.get(0)]);
+    var catid = selectedItem.type;
+    var cat = catalog.elements[catid];
+    if (!cat) cat = catalog.elements[(0, _utils.returnReplaceableDeepSearchType)(catid)];
+    currentItem = {
+      selectedItem: selectedItem,
+      cat: cat
+    };
+  }
+  layer.items.forEach(function (item) {
+    var val = {
+      pos: {
+        x: item.x,
+        y: item.y
+      },
+      rotRad: item.rotation / 180 * Math.PI
+    };
+    var catid = item.type;
+    var cat = catalog.elements[catid];
+    if (!cat) {
+      cat = catalog.elements[(0, _utils.returnReplaceableDeepSearchType)(catid)];
+    }
+    var sizeinfo = [];
+    var width, height, depth;
+    sizeinfo = {
+      width: item.properties.get('width').get('_length'),
+      height: item.properties.get('height').get('_length'),
+      depth: item.properties.get('depth').get('_length'),
+      widthUnit: item.properties.get('width').get('_unit'),
+      heightUnit: item.properties.get('height').get('_unit'),
+      depthUnit: item.properties.get('depth').get('_unit')
+    };
+    sizeinfo = _objectSpread(_objectSpread({}, sizeinfo), {}, {
+      layoutpos: cat && cat.info.layoutpos,
+      is_corner: cat && cat.info.is_corner
+    });
+    width = (0, _convertUnitsLite.convert)(sizeinfo.width).from(sizeinfo.widthUnit).to(scene.unit);
+    height = (0, _convertUnitsLite.convert)(sizeinfo.depth).from(sizeinfo.depthUnit).to(scene.unit);
+    depth = (0, _convertUnitsLite.convert)(sizeinfo.height).from(sizeinfo.heightUnit).to(scene.unit);
+    val.size = {
+      width: width,
+      height: height,
+      depth: depth
+    };
+    val.layoutpos = sizeinfo.layoutpos;
+    val.is_corner = sizeinfo.is_corner;
+    val.doorStyle = item.doorStyle;
+    val.item = item;
+    var otherItem = {
+      item: item,
+      cat: cat
+    };
+    if (!needSnap(currentItem, otherItem)) {
+      return;
+    }
+    if (item.selected) {
+      curiteminfo = getCalcRectFromItem(val);
+    } else {
+      var calcrect = getCalcRectFromItem(val);
+      calcrect.isSnappedLine = isSnappedLine(calcrect, allLineRects);
+      iteminfo.push(calcrect);
+      otherItems.push(otherItem);
+    }
+  });
+  return {
+    cur: curiteminfo,
+    others: iteminfo,
+    currentItem: currentItem,
+    otherItems: otherItems
+  };
+}
+function getAllItemSpecified(scene, catalog, filter) {
+  var _scene$layers, _scene$layers$get;
+  var snappedLineRect = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  var layerID = scene === null || scene === void 0 ? void 0 : scene.selectedLayer;
+  var layer = scene === null || scene === void 0 || (_scene$layers = scene.layers) === null || _scene$layers === void 0 || (_scene$layers$get = _scene$layers.get) === null || _scene$layers$get === void 0 ? void 0 : _scene$layers$get.call(_scene$layers, layerID);
+  if (!layer || !layer.items) return {
+    cur: null,
+    others: []
+  };
+  var curiteminfo;
+  var iteminfo = [];
+  layer.items.forEach(function (item) {
+    var _cat$obj;
+    if (!item) return;
+    var val = {
+      pos: {
+        x: item.x,
+        y: item.y
+      },
+      rotRad: item.rotation / 180 * Math.PI
+    };
+    var cat = item.type ? findCatalogElement(catalog, item.type) : null;
+    val.layoutpos = item.layoutpos;
+    val.is_corner = item.is_corner;
+    var props = item.properties;
+    var getSize = function getSize(key) {
+      var _props$getIn, _props$getIn2, _props$getIn3;
+      var length = props === null || props === void 0 || (_props$getIn = props.getIn) === null || _props$getIn === void 0 ? void 0 : _props$getIn.call(props, [key, '_length']);
+      return length != null ? (0, _convertUnitsLite.convert)(length).from((_props$getIn2 = props === null || props === void 0 || (_props$getIn3 = props.getIn) === null || _props$getIn3 === void 0 ? void 0 : _props$getIn3.call(props, [key, '_unit'])) !== null && _props$getIn2 !== void 0 ? _props$getIn2 : 'in').to(scene.unit) : 0;
+    };
+    val.size = {
+      width: getSize('width'),
+      height: getSize('height'),
+      depth: getSize('depth')
+    };
+    val.item = item;
+
+    // Filter check
+    if (Array.isArray(filter)) {
+      if (!val.layoutpos || !filter.includes(val.layoutpos)) return;
+    } else if (val.layoutpos !== filter || (0, _helper.isEmpty)(cat) || (cat === null || cat === void 0 ? void 0 : cat.type) === 'appliance' && ['Cook Top', 'Microwave'].includes(cat === null || cat === void 0 || (_cat$obj = cat.obj) === null || _cat$obj === void 0 ? void 0 : _cat$obj.category)) {
+      return;
+    }
+
+    // Current vs others
+    var rect = getCalcRectFromItem3D(val);
+
+    // check current item is snapped to the [snappedLineRect]
+    if (!(0, _helper.isEmpty)(snappedLineRect)) {
+      var isSnapped = false;
+      var overlapList = [_constants.OVERLAP_INCLUDED, _constants.OVERLAP_SAME, _constants.OVERLAP_SOME];
+      for (var i = 0; i < (rect === null || rect === void 0 || (_rect$rect = rect.rect) === null || _rect$rect === void 0 ? void 0 : _rect$rect.length); i++) {
+        var _rect$rect;
+        if (isSnapped) break;
+        var curItemPt = rect.rect[i];
+        var nextItemPt = i === rect.rect.length - 1 ? rect.rect[0] : rect.rect[i + 1];
+        var srcLine = {
+          x1: curItemPt.x,
+          y1: curItemPt.y,
+          x2: nextItemPt.x,
+          y2: nextItemPt.y
+        };
+        for (var j = 0; j < (snappedLineRect === null || snappedLineRect === void 0 ? void 0 : snappedLineRect.length); j++) {
+          var curLineRectPt = snappedLineRect[j];
+          var nextLineRectPt = j === snappedLineRect.length - 1 ? snappedLineRect[0] : snappedLineRect[j + 1];
+          var destLine = {
+            x1: curLineRectPt.x,
+            y1: curLineRectPt.y,
+            x2: nextLineRectPt.x,
+            y2: nextLineRectPt.y
+          };
+          if (overlapList.includes(relationshipOfTwoOverlappedLines(srcLine, destLine).result)) {
+            isSnapped = true;
+            break;
+          }
+        }
+      }
+      if (!isSnapped) return;
+    }
+    if (item.selected) {
+      curiteminfo = rect;
+    } else {
+      iteminfo.push(rect);
+    }
+  });
+  return {
+    cur: curiteminfo,
+    others: iteminfo
+  };
+}
+function findCatalogElement(catalog, elementName) {
+  if (!elementName || !catalog) return null;
+  var variants = [elementName, elementName.toLowerCase()];
+  var deepVariants = variants.map(function (v) {
+    return (0, _utils.returnReplaceableDeepSearchType)(v);
+  }).filter(Boolean);
+  var allCandidates = [].concat(variants, (0, _toConsumableArray2["default"])(deepVariants));
+  var getElement = function getElement(catid) {
+    if (!catid) return null;
+
+    // Immutable.js Map
+    if (typeof catalog.getIn === 'function') {
+      return catalog.getIn(['elements', catid]);
+    }
+
+    // Plain JS object
+    if (catalog.elements && catalog.elements[catid]) {
+      return catalog.elements[catid];
+    }
+    return null;
+  };
+  var _iterator6 = _createForOfIteratorHelper(allCandidates),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var name = _step6.value;
+      var cat = getElement(name);
+      if (cat) return cat;
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return null;
+}
+function isSnappedLine(calcrect, allLineRects) {
+  if (allLineRects === undefined) return false;
+  var r2 = calcrect.rect[2];
+  var r3 = calcrect.rect[3];
+  var result = allLineRects.some(function (linerect) {
+    var l2 = linerect.rect[2];
+    var l3 = linerect.rect[3];
+    var delta = verticesDistance(l2, r3) + verticesDistance(r3, r2) + verticesDistance(r2, l3) - verticesDistance(l3, l2);
+    if (delta < _constants.EPSILON) {
+      return true;
+    } else {
+      l2 = linerect.rect[3];
+      l3 = linerect.rect[2];
+      delta = verticesDistance(l2, r3) + verticesDistance(r3, r2) + verticesDistance(r2, l3) - verticesDistance(l3, l2);
+      return delta < _constants.EPSILON;
+    }
+  });
+  return result;
+}
+function isSnappedSideLine(calcrect, allLineRects) {
+  if (allLineRects === undefined) return 0;
+  var r2 = calcrect.rect[1];
+  var r3 = calcrect.rect[2];
+  var result = allLineRects.some(function (linerect) {
+    var l2 = linerect.rect[2];
+    var l3 = linerect.rect[3];
+    var delta = verticesDistance(l2, r3) + verticesDistance(r3, r2) + verticesDistance(r2, l3) - verticesDistance(l3, l2);
+    return delta < _constants.EPSILON;
+  });
+  return result;
+}
+
+/** Calculate candidate positions */
+function getAllItemSnap(allItemRects) {
+  var allItemSnap = [];
+  var cur = allItemRects.cur;
+
+  // For development
+  var otherItems = allItemRects.otherItems,
+    currentItem = allItemRects.currentItem;
+  allItemRects.others.forEach(function (rect, index) {
+    var cw = cur && cur.size.width / 2;
+    var ch = cur && cur.size.height / 2;
+    var cos = Math.cos(rect.rotRad);
+    var sin = Math.sin(rect.rotRad);
+    var ox0 = cw * cos - ch * sin; // (cw, ch) rot
+    var oy0 = cw * sin + ch * cos;
+    var ox1 = -cw * cos - ch * sin; // (-cw, ch) rot
+    var oy1 = -cw * sin + ch * cos;
+    var ox2 = ch * sin - cw * cos;
+    var oy2 = -ch * cos - cw * sin;
+    var ox3 = ch * sin + cw * cos;
+    var oy3 = -ch * cos + cw * sin;
+    var nrot = rect.rotRad + Math.PI;
+    if (nrot >= Math.PI) nrot -= Math.PI * 2;
+    var snap1 = itemrectInfo(rect.rect[2].x + ox3, rect.rect[2].y + oy3, rect.rotRad, cur && cur.size, rect.layoutpos, rect.is_corner);
+    var snap2 = itemrectInfo(rect.rect[3].x + ox2, rect.rect[3].y + oy2, rect.rotRad, cur && cur.size, rect.layoutpos, rect.is_corner);
+    var snap3 = itemrectInfo(rect.rect[2].x + ox1, rect.rect[2].y + oy1, nrot, cur && cur.size, rect.layoutpos, rect.is_corner);
+    var snap4 = itemrectInfo(rect.rect[3].x + ox0, rect.rect[3].y + oy0, nrot, cur && cur.size, rect.layoutpos, rect.is_corner);
+    var sizeinfo = otherItems[index].cat && otherItems[index].cat.info.sizeinfo;
+    if (sizeinfo) {
+      var leftBlindLength = sizeinfo.leftBlindLength,
+        rightBlindLength = sizeinfo.rightBlindLength;
+      if (leftBlindLength > 0) {
+        var vx = leftBlindLength - ch;
+        var vy = cw;
+        var dx = vx * cos + vy * sin;
+        var dy = vx * sin - vy * cos;
+        var snap6 = itemrectInfo(rect.rect[0].x + dx, rect.rect[0].y + dy, rect.rotRad + Math.PI / 2, cur && cur.size, rect.layoutpos, rect.is_corner);
+        allItemSnap.push(snap6);
+      }
+      if (rightBlindLength > 0) {
+        var _vx = ch - rightBlindLength;
+        var _vy = cw;
+        var _dx = _vx * cos + _vy * sin;
+        var _dy = _vx * sin - _vy * cos;
+        var snap7 = itemrectInfo(rect.rect[1].x + _dx, rect.rect[1].y + _dy, rect.rotRad - Math.PI / 2, cur && cur.size, rect.layoutpos, rect.is_corner);
+        allItemSnap.push(snap7);
+      }
+    }
+    if (rect.isSnappedLine) {
+      snap1.isSnappedLine = true;
+      snap2.isSnappedLine = true;
+    }
+    if (rect.is_corner) {
+      var _nrot = rect.rotRad + Math.PI * 3 / 2;
+      if (_nrot >= Math.PI) _nrot -= Math.PI * 2;
+      var snap5 = itemrectInfo(rect.rect[1].x - oy1, rect.rect[1].y + ox1, _nrot, cur && cur.size, rect.layoutpos, rect.is_corner);
+      allItemSnap.push(snap2);
+      allItemSnap.push(snap5);
+    } else {
+      allItemSnap.push(snap1);
+      allItemSnap.push(snap2);
+      allItemSnap.push(snap3);
+      allItemSnap.push(snap4);
+    }
+  });
+  return allItemSnap;
+}
+function getAllArea(layer) {
+  var allAreaLines = [];
+  var allLines = [];
+  var verticesArray = [];
+  var vertexID_to_verticesArrayIndex = {};
+  layer.vertices.forEach(function (vertex) {
+    var verticesCount = verticesArray.push([vertex.x, vertex.y]);
+    var latestVertexIndex = verticesCount - 1;
+    vertexID_to_verticesArrayIndex[vertex.id] = latestVertexIndex;
+  });
+  layer.areas.forEach(function (area) {
+    allAreaLines.push(area.vertices);
+  });
+  allAreaLines.forEach(function (area) {
+    var pt = [];
+    area.forEach(function (element) {
+      pt.push({
+        x: verticesArray[vertexID_to_verticesArrayIndex[element]][0],
+        y: verticesArray[vertexID_to_verticesArrayIndex[element]][1]
+      });
+    });
+    allLines.push(pt);
+  });
+  return allLines;
+}
+
+/** Get all lines of the scene */
+function getAllLines(layer) {
+  var allArea = getAllArea(layer);
+  var allAreaLines = [];
+  var allVertices = layer.get('vertices').toJS();
+  layer.lines.forEach(function (tline) {
+    var line = tline.toJS();
+    if (isPointInArea(allArea, allVertices[line.vertices[0]]) || isPointInArea(allArea, allVertices[line.vertices[1]])) {
+      allAreaLines.push(line.vertices.reverse());
+    }
+  });
+  var allLines = [];
+  //let allNonAreaLines = [];
+  var thick = _constants.LINE_THICKNESS / 2;
+  layer.lines.forEach(function (line) {
+    var i = containLine(allAreaLines, line);
+    // let thick = line.properties.getIn(['thickness', 'length']);
+    if (i < 0) {
+      var vertices = line.vertices.toJS();
+      var tmp_vertices = {
+        x1: layer.vertices.get(vertices[0]).x,
+        y1: layer.vertices.get(vertices[0]).y,
+        x2: layer.vertices.get(vertices[1]).x,
+        y2: layer.vertices.get(vertices[1]).y
+      };
+      if (tmp_vertices.x1 == tmp_vertices.x2 && tmp_vertices.y1 == tmp_vertices.y2) return;
+      var addIdx = allLines.length;
+      var flag = 0;
+      allLines.forEach(function (element, idx) {
+        if (flag == 0) {
+          var el = element[0];
+          var tmp_el = {
+            x1: layer.vertices.get(el[0]).x,
+            y1: layer.vertices.get(el[0]).y,
+            x2: layer.vertices.get(el[1]).x,
+            y2: layer.vertices.get(el[1]).y
+          };
+          if (tmp_el.x1 == tmp_vertices.x1 && tmp_el.y1 == tmp_vertices.y1) {
+            var tmp = vertices[0];
+            vertices[0] = vertices[1];
+            vertices[1] = tmp;
+            addIdx = idx == 0 ? 0 : idx - 1;
+            flag = 1;
+          } else if (tmp_el.x2 == tmp_vertices.x1 && tmp_el.y2 == tmp_vertices.y1) {
+            addIdx = idx;
+            flag = 1;
+          } else if (tmp_el.x1 == tmp_vertices.x2 && tmp_el.y1 == tmp_vertices.y2) {
+            addIdx = idx == 0 ? 0 : idx - 1;
+            flag = 1;
+          } else if (tmp_el.x2 == tmp_vertices.x2 && tmp_el.y2 == tmp_vertices.y2) {
+            var _tmp = vertices[0];
+            vertices[0] = vertices[1];
+            vertices[1] = _tmp;
+            addIdx = idx;
+            flag = 1;
+          }
+        }
+      });
+      allLines.splice(addIdx, 0, [vertices, thick, line.id]);
+    } else {
+      allLines.push([allAreaLines[i], thick, line.id]);
+    }
+  });
+  return allLines;
+}
+
+/** Get lines that wraps the area */
+function getAllAreaLines(layer) {
+  var areainfo = [];
+  layer.areas.forEach(function (area) {
+    var sz = area.vertices.size;
+    for (var i = 0; i < sz; i++) {
+      areainfo.push([area.vertices.get(i), area.vertices.get((i + 1) % sz)]);
+    }
+  });
+  return areainfo;
+}
+function containLine(lines, line) {
+  // lines: [array]
+  var sz = lines.length;
+  for (var i = 0; i < sz; i++) {
+    var l = lines[i];
+    if (line.vertices.get(0) == l[0] && line.vertices.get(1) == l[1] || line.vertices.get(1) == l[0] && line.vertices.get(0) == l[1]) {
+      return i;
+    }
+  }
+  return -1;
+}
+function buildRectFromLines(layer, lines) {
+  var rect = [];
+  lines.forEach(function (line) {
+    var vxys = []; // 0: x0, 1: y0, 2: x1, 3: y1
+    line[0].forEach(function (vertex) {
+      var vert = layer.vertices.get(vertex);
+      vxys.push(vert.x);
+      vxys.push(vert.y);
+    });
+    var thick = line[1];
+    var x0 = vxys[0];
+    var y0 = vxys[1];
+    var x1 = vxys[2];
+    var y1 = vxys[3];
+    var rectLine = getCalcRectFromLine(x0, y0, x1, y1, thick, layer);
+    rectLine.lineId = line.length > 2 ? line[2] : null;
+    rect.push(rectLine);
+  });
+  return rect;
+}
+function getRelatedVertices(x0, y0, x1, y1, layer) {
+  var verticesArray = [];
+  var mapVertIDtoIndex = {};
+  layer.vertices.forEach(function (vertex) {
+    var verticesCount = verticesArray.push([vertex.x, vertex.y]);
+    var latestVertexIndex = verticesCount - 1;
+    mapVertIDtoIndex[vertex.id] = latestVertexIndex;
+  });
+  var relVerts = [];
+  layer.lines.some(function (line) {
+    var vertID0 = line.vertices.get(0);
+    var vertID1 = line.vertices.get(1);
+    var pt0 = {
+      x: verticesArray[mapVertIDtoIndex[vertID0]][0],
+      y: verticesArray[mapVertIDtoIndex[vertID0]][1]
+    };
+    var pt1 = {
+      x: verticesArray[mapVertIDtoIndex[vertID1]][0],
+      y: verticesArray[mapVertIDtoIndex[vertID1]][1]
+    };
+    if (Math.abs(pt0.x - x0) < _constants.EPSILON && Math.abs(pt0.y - y0) < _constants.EPSILON && Math.abs(pt1.x - x1) < _constants.EPSILON && Math.abs(pt1.y - y1) < _constants.EPSILON || Math.abs(pt0.x - x1) < _constants.EPSILON && Math.abs(pt0.y - y1) < _constants.EPSILON && Math.abs(pt1.x - x0) < _constants.EPSILON && Math.abs(pt1.y - y0) < _constants.EPSILON) {
+      if (line.relatedVertices.size == 2) {
+        var relPt0 = point(x0, y0);
+        var relPt1 = point(x1, y1);
+        line.relatedVertices.forEach(function (relatedVertice, index) {
+          if (relatedVertice.index == undefined) relatedVertice = relatedVertice.toJSON();
+          if (relatedVertice.index == 0) relPt0 = point(relatedVertice.point.x, relatedVertice.point.y);else relPt1 = point(relatedVertice.point.x, relatedVertice.point.y);
+        });
+        relVerts.push(relPt0);
+        relVerts.push(relPt1);
+      }
+      return true;
+    }
+  });
+  return relVerts;
+}
+function getCalcRectFromLine(x0, y0, x1, y1, thick, layer) {
+  // get line from vertex coordinate
+  var relVerts = getRelatedVertices(x0, y0, x1, y1, layer);
+  var dx = x1 - x0;
+  var dy = y1 - y0;
+  var dl = Math.sqrt(dx * dx + dy * dy);
+  var ox = -dy / dl * thick;
+  var oy = dx / dl * thick;
+  var rot = Math.atan2(dy, dx);
+  if (relVerts.length == 2) {
+    var vN = point(ox, oy);
+    var vR = point(relVerts[0].x - x0, relVerts[0].y - y0);
+    if (dotprod(vN, vR) < 0) {
+      ox = -ox;
+      oy = -oy;
+    } else {
+      rot += Math.PI;
+    }
+  } else {
+    ox = -ox;
+    oy = -oy;
+  }
+  return {
+    rectEnd: [point(x0 + ox / 2, y0 + oy / 2), point(x1 + ox / 2, y1 + oy / 2)],
+    rect: [point(x0 + ox, y0 + oy), point(x1 + ox, y1 + oy), point(x1, y1), point(x0, y0)],
+    pos: point((x0 + x1 + ox) / 2, (y0 + y1 + ox) / 2),
+    rotRad: rot,
+    size: {
+      width: dl,
+      height: thick / 2
+    }
+  };
+}
+function getAllLineSnap(allLineRects, curItemRect) {
+  var allLineSnap = [];
+  var cur = curItemRect;
+  if (cur === undefined || cur === null) return;else allLineRects.forEach(function (rect) {
+    var cw = cur.size.width / 2;
+    var ch = cur.size.height / 2;
+    var cos = Math.cos(rect.rotRad);
+    var sin = Math.sin(rect.rotRad);
+    var ox0 = cw * cos - ch * sin; // (cw, ch) rot
+    var oy0 = cw * sin + ch * cos;
+    var ox1 = -cw * cos - ch * sin; // (-cw, ch) rot
+    var oy1 = -cw * sin + ch * cos;
+    var nrot = rect.rotRad + Math.PI;
+    if (nrot >= Math.PI) nrot -= Math.PI * 2;
+    var thick = rect.size.height;
+    var snap3 = itemInfo(rect.rect[2].x + ox1, rect.rect[2].y + oy1, nrot, cur.size);
+    var snap4 = itemInfo(rect.rect[3].x + ox0, rect.rect[3].y + oy0, nrot, cur.size);
+    if (!cur.is_corner) {
+      allLineSnap.push(snap3);
+    }
+    allLineSnap.push(snap4);
+  });
+  return allLineSnap;
+}
+function validateSnaps(allSnaps, allRects) {
+  var validSnaps = [];
+  if (allSnaps !== undefined && allSnaps !== null && allSnaps.length > 0) allSnaps.forEach(function (snap) {
+    if (validSnap(snap, allRects)) {
+      validSnaps.push(snap);
+    }
+  });
+  return validSnaps;
+}
+function validateLineSnaps(allSnaps, allItemSnap, allLineSnap, allItemRects, allLineRects, allRects) {
+  var validSnaps = [];
+  var addFlag = true;
+  allSnaps.forEach(function (snap) {
+    if (validSnap(snap, allRects)) {
+      validSnaps.push(snap);
+    } else if (addFlag) {
+      allItemSnap.forEach(function (snap) {
+        validSnaps.push(snap);
+      });
+      allLineSnap.forEach(function (snap) {
+        validSnaps.push(snap);
+      });
+      addFlag = false;
+    }
+  });
+  return validSnaps;
+}
+function validSnap(snap, rects) {
+  var snaprect = getCalcRectFromItem(snap);
+  return rects.every(function (rect) {
+    return !intersectRect(rect.rect, snaprect.rect);
+  });
+}
+function itemInfo(x, y, rotRad, size) {
+  return {
+    pos: {
+      x: x,
+      y: y
+    },
+    rotRad: rotRad,
+    size: size
+  };
+}
+function intersectRect(rect1, rect2) {
+  var ret = false;
+  rect1 = shrinkRect(rect1);
+  rect2 = shrinkRect(rect2);
+  ret = ret || getInterSect(rect1, rect2);
+  ret = ret || rect1.some(function (pt) {
+    return containPointInRect(pt, rect2);
+  });
+  ret = ret || rect2.some(function (pt) {
+    return containPointInRect(pt, rect1);
+  });
+  return ret;
+}
+function containPointInRect(point, rect) {
+  // true: contain, false: not contain
+  for (var i = 0; i < rect.length; i++) {
+    var ni = (i + 1) % rect.length;
+    if (crossprod(diff(point, rect[i]), diff(rect[i], rect[ni])) < 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function diff(v0, v1) {
+  return {
+    x: v0.x - v1.x,
+    y: v0.y - v1.y
+  };
+}
+function crossprod(v0, v1) {
+  return v0.x * v1.y - v0.y * v1.x;
+}
+function shrinkRect(rect) {
+  var v02x = rect[2].x - rect[0].x;
+  var v02y = rect[2].y - rect[0].y;
+  var d02 = Math.sqrt(v02x * v02x + v02y * v02y);
+  var o02x = v02x / d02 * 0.1;
+  var o02y = v02y / d02 * 0.1;
+  var v13x = rect[3].x - rect[1].x;
+  var v13y = rect[3].y - rect[1].y;
+  var d13 = Math.sqrt(v02x * v02x + v02y * v02y);
+  var o13x = v13x / d13 * 0.1;
+  var o13y = v13y / d13 * 0.1;
+  return [point(rect[0].x + o02x, rect[0].y + o02y), point(rect[1].x + o13x, rect[1].y + o13y), point(rect[2].x - o02x, rect[2].y - o02y), point(rect[3].x - o13x, rect[3].y - o13y)];
+}
+function getInterSect(shape1, shape2) {
+  // return result of intersect of two shape
+  var count = 0;
+  for (var i = 0; i < shape1.length; i++) {
+    var sl1 = {
+      x: shape1[i].x,
+      y: shape1[i].y
+    };
+    var sl2 = {
+      x: shape1[(i + 1) % shape1.length].x,
+      y: shape1[(i + 1) % shape1.length].y
+    };
+    for (var j = 0; j < shape2.length; j++) {
+      var el1 = {
+        x: shape2[j].x,
+        y: shape2[j].y
+      };
+      var el2 = {
+        x: shape2[(j + 1) % shape2.length].x,
+        y: shape2[(j + 1) % shape2.length].y
+      };
+      var flag = getLineInterSect(sl1.x, sl1.y, sl2.x, sl2.y, el1.x, el1.y, el2.x, el2.y);
+      if (flag) {
+        count++;
+        if (count > 1) return true;
+      }
+    }
+  }
+  return false;
+}
+function getLineInterSect(s1x, s1y, e1x, e1y, s2x, s2y, e2x, e2y) {
+  var ax = s1x;
+  var ay = s1y;
+  var bx = e1x - s1x;
+  var by = e1y - s1y;
+  var cx = s2x;
+  var cy = s2y;
+  var dx = e2x - s2x;
+  var dy = e2y - s2y;
+  if (Math.abs(bx * dy - by * dx) < 0.00000001) {
+    if (Math.abs((cx - ax) * by - (cy - ay) * bx) < 0.00000001) {
+      var maxX = ax;
+      var minX = ax;
+      var maxY = ay;
+      var minY = ay;
+      if (maxX < e1x) maxX = e1x;
+      if (maxX < cx) maxX = cx;
+      if (maxX < e2x) maxX = e2x;
+      if (minX > e1x) minX = e1x;
+      if (minX > cx) minX = cx;
+      if (minX > e2x) minX = e2x;
+      if (maxY < e1y) maxY = e1y;
+      if (maxY < cy) maxY = cy;
+      if (maxY < e2y) maxY = e2y;
+      if (minY > e1y) minY = e1y;
+      if (minY > cy) minY = cy;
+      if (minY > e2y) minX = e2y;
+      var len = Math.sqrt((maxX - minX) * (maxX - minX) + (maxY - minY) * (maxY - minY));
+      var len1 = Math.sqrt(bx * bx + by * by);
+      var len2 = Math.sqrt(dx * dx + dy * dy);
+      if (len < len1 + len2) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } else {
+    var t = (dx * (ay - cy) + dy * (cx - ax)) / (bx * dy - by * dx);
+    var u = (bx * (cy - ay) + by * (ax - cx)) / (dx * by - dy * bx);
+    var ret = u < 1 && u > 0 && t > 0 && t < 1;
+    return ret;
+  }
+}
+function isPointInArea(allArea, pt) {
+  var x = pt.x;
+  var y = pt.y;
+  var result = false;
+  result = allArea.some(function (area) {
+    var sum = 0,
+      alpha = 0;
+    for (var i = 0; i < area.length; i++) {
+      var x0 = area[i].x;
+      var y0 = area[i].y;
+      var x1 = area[(i + 1) % area.length].x;
+      var y1 = area[(i + 1) % area.length].y;
+      var v0 = {
+        x: x0 - x,
+        y: y0 - y
+      };
+      var v1 = {
+        x: x1 - x,
+        y: y1 - y
+      };
+      if (Math.abs(v0.x) < _constants.EPSILON && Math.abs(v0.y) < _constants.EPSILON)
+        // check if pt is area point
+        return true;
+
+      // check if pt is in area line
+      var lineLen = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
+      var v0Len = Math.sqrt(v0.x * v0.x + v0.y * v0.y);
+      var vPt = {
+        x: -v0.x / v0Len,
+        y: -v0.y / v0Len
+      };
+      var xE = x0 + vPt.x * lineLen;
+      var yE = y0 + vPt.y * lineLen;
+      if (v0Len <= lineLen && Math.abs(xE - x1) < _constants.EPSILON && Math.abs(yE - y1) < _constants.EPSILON) return true;
+      alpha = Math.atan2(v0.x * v1.y - v1.x * v0.y, v0.x * v1.x + v0.y * v1.y);
+      sum += alpha;
+    }
+    if (Math.abs(Math.abs(sum) - Math.PI * 2) < _constants.EPSILON) return true;
+  });
+  return result;
+}
+function calcSnap(allItemRect, allItemSnap, allLineRects, allLineSnap, allRect, x, y, allAreaLines) {
+  return calcSnap2(allItemRect, allItemSnap, allLineRects, allLineSnap, allRect, x, y, allAreaLines);
+}
+function calcCreateSnap(allItemRect, allItemSnap, allLineRects, allLineSnap, allRect, x, y, polygonPoint) {
+  // Validate required input and guard against missing `.cur`
+  if (!allItemRect || !allItemRect.cur) return;
+  var cur = allItemRect.cur; // safe alias
+  var cx = x;
+  var cy = y;
+  var ndist = 5000;
+  var rotRad = cur.rotRad;
+
+  // Get candidate snaps and validate them as before
+  var allCurSnap = getAllCurSnap(allLineRects, x, y, cur);
+  allCurSnap = validateLineSnaps(allCurSnap, allItemSnap, allLineSnap, allItemRect, allLineRects, allRect);
+  var getSnap = false;
+  var snapdist = [];
+
+  // Build distances for snaps that lie inside polygonPoint (if any)
+  if (Array.isArray(allCurSnap)) {
+    allCurSnap.forEach(function (snap) {
+      if (!snap || !snap.pos) return;
+      var inside = ContainsPoint(polygonPoint, snap.pos.x, snap.pos.y);
+      if (inside) {
+        var dx = snap.pos.x - x;
+        var dy = snap.pos.y - y;
+        snapdist.push(dx * dx + dy * dy);
+      }
+    });
+  }
+
+  // Find minimum distance (Infinity if none)
+  var edist = snapdist.length ? Math.min.apply(Math, snapdist) : Infinity;
+
+  // Choose the snap with distance === edist
+  if (Array.isArray(allCurSnap)) {
+    allCurSnap.forEach(function (snap) {
+      if (!snap || !snap.pos) return;
+      var dx = snap.pos.x - x;
+      var dy = snap.pos.y - y;
+      var dist = dx * dx + dy * dy;
+      if (dist === edist) {
+        var _snap$rotRad;
+        ndist = dist;
+        cx = snap.pos.x;
+        cy = snap.pos.y;
+        rotRad = (_snap$rotRad = snap.rotRad) !== null && _snap$rotRad !== void 0 ? _snap$rotRad : rotRad; // nullish coalescing
+        getSnap = true;
+      }
+    });
+  }
+  var crot = rotRad / Math.PI * 180;
+  return {
+    cx: cx,
+    cy: cy,
+    crot: crot,
+    rotRad: rotRad
+  };
+}
+
+////////////
+function calcSnap1(allItemRect, allItemSnap, allLineRects, allLineSnap, allRect, x, y) {
+  var cx = allItemRect.cur.pos.x;
+  var cy = allItemRect.cur.pos.y;
+  var nx = x;
+  var ny = y;
+  var cursize = allItemRect.cur.size;
+  var ndist = cursize.width * cursize.width + cursize.height * cursize.height;
+  ndist = ndist / 4;
+  var rotRad = allItemRect.cur.rotRad;
+  var allCurSnap = getAllCurSnap(allLineRects, x, y, allItemRect.cur);
+  allCurSnap = validateSnaps(allCurSnap, allRect);
+  var getSnap = false;
+  allCurSnap.forEach(function (snap) {
+    var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+    if (dist < ndist) {
+      ndist = dist;
+      nx = snap.pos.x;
+      ny = snap.pos.y;
+      rotRad = snap.rotRad;
+      getSnap = true;
+    }
+  });
+  if (!getSnap) {
+    allLineSnap.concat(allItemSnap).forEach(function (snap) {
+      var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+      if (dist < ndist) {
+        ndist = dist;
+        nx = snap.pos.x;
+        ny = snap.pos.y;
+        rotRad = snap.rotRad;
+      }
+    });
+  }
+  var rot = rotRad / Math.PI * 180;
+  var ret = {
+    nx: nx,
+    ny: ny,
+    rot: rot,
+    rotRad: rotRad
+  };
+  return ret;
+}
+
+////////////
+function calcSnap2(allItemRect, allItemSnap, allLineRects, allLineSnap, allRect, x, y, allArea) {
+  var nx = x;
+  var ny = y;
+  var ndist = 20;
+  var rotRad = allItemRect.cur && allItemRect.cur.rotRad;
+  var val = {
+    pos: {
+      x: x,
+      y: y
+    },
+    rotRad: rotRad
+  };
+  val.size = allItemRect.cur && allItemRect.cur.size;
+  val.layoutpos = allItemRect.cur && allItemRect.cur.layoutpos;
+  val.is_corner = allItemRect.cur && allItemRect.cur.is_corner;
+  var curitem = getCalcRectFromItem(val);
+  var allCurSnap = [];
+  allCurSnap = getAllCurSnap(allLineRects, x, y, allItemRect.cur);
+  allCurSnap = validateSnaps(allCurSnap, allRect);
+  var getSnap = false;
+  var snapdist = [];
+  //console.log("allItemSnap",  allItemSnap.filter(e => e.isSnappedLine))
+  //console.log("~~~~start~~~~");
+  allItemSnap.filter(function (e) {
+    return e.isSnappedLine;
+  }).forEach(function (snap) {
+    var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+    snapdist.push(dist);
+    //console.log("dist", snap)
+    if (isPointInArea(allArea, snap.pos) || !allArea.length) if (dist < 100) {
+      ndist = dist;
+      nx = snap.pos.x;
+      ny = snap.pos.y;
+      rotRad = snap.rotRad;
+      getSnap = true;
+
+      //console.log("SUCCESS!!!!");
+    }
+  });
+  //console.log("====end====");
+  if (getSnap == false) {
+    allCurSnap.forEach(function (snap) {
+      var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+      snapdist.push(dist);
+      if (isPointInArea(allArea, snap.pos) || !allArea.length) if (dist < ndist) {
+        ndist = dist;
+        nx = snap.pos.x;
+        ny = snap.pos.y;
+        rotRad = snap.rotRad;
+        getSnap = true;
+        //console.log("SUCCE!!!!");
+      }
+    });
+    if (!getSnap && allLineRects.some(function (others) {
+      return intersectRect(others.rect, curitem.rect);
+    })) {
+      var edist = Math.min.apply(null, snapdist);
+      allCurSnap.forEach(function (snap) {
+        var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+        if (isPointInArea(allArea, snap.pos) || !allArea.length) if (dist === edist) {
+          ndist = dist;
+          nx = snap.pos.x;
+          ny = snap.pos.y;
+          rotRad = snap.rotRad;
+          getSnap = true;
+        }
+      });
+    }
+    if (getSnap === false) {
+      var nearRect = null;
+      var minDist = Infinity;
+      allLineRects.forEach(function (rect) {
+        var e = rect.rectEnd[0];
+        e = clone_point(e);
+        e.x -= curitem.pos.x;
+        e.y -= curitem.pos.y;
+        var nRot = rect.rotRad + Math.PI / 2;
+        var dist = Math.abs(e.x * Math.cos(nRot) + e.y * Math.sin(nRot));
+        if (minDist > dist) {
+          minDist = dist;
+          nearRect = rect;
+        }
+      });
+      var containrect = nearRect && intersectRect(nearRect.rect, curitem.rect);
+      if (containrect) {
+        var filter_func = function filter_func(snap) {
+          var diff = Math.abs(snap.rotRad - nearRect.rotRad - Math.PI);
+          return diff == 0 || diff == 2 * Math.PI;
+        };
+        var tempSnap = allLineSnap.filter(filter_func);
+        tempSnap = tempSnap.concat(allLineSnap.filter(function (snap) {
+          return !filter_func(snap);
+        }));
+        tempSnap.some(function (snap) {
+          var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+          if (isPointInArea(allArea, snap.pos) || !allArea.length) if (dist < 5000) {
+            nx = snap.pos.x;
+            ny = snap.pos.y;
+            rotRad = snap.rotRad;
+            getSnap = true;
+            return true;
+          }
+          return false;
+        });
+      }
+    }
+    if (allItemRect.others.some(function (others) {
+      return intersectRect(others.rect, curitem.rect);
+    })) {
+      getSnap = false;
+    }
+    if (!getSnap) {
+      var _snapdist = [];
+      allItemSnap.forEach(function (snap) {
+        var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+        _snapdist.push(dist);
+        if (isPointInArea(allArea, snap.pos) || !allArea.length) if (dist < ndist) {
+          ndist = dist;
+          nx = snap.pos.x;
+          ny = snap.pos.y;
+          rotRad = snap.rotRad;
+          getSnap = true;
+        }
+      });
+      if (!getSnap && allItemRect.others.some(function (others) {
+        return intersectRect(others.rect, curitem.rect);
+      })) {
+        var _edist = Math.min.apply(null, _snapdist);
+        allItemSnap.forEach(function (snap) {
+          var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+          if (isPointInArea(allArea, snap.pos) || !allArea.length) if (dist === _edist) {
+            ndist = dist;
+            nx = snap.pos.x;
+            ny = snap.pos.y;
+            rotRad = snap.rotRad;
+          }
+        });
+        if (allItemRect.cur.itemInfo.name.includes('Cook Top')) {
+          var intersects = allItemRect.others.filter(function (others) {
+            return intersectRect(others.rect, curitem.rect);
+          });
+          intersects.forEach(function (rect) {
+            if (isPointInArea(allArea, rect.itemInfo) || !allArea.length) if (rect.itemInfo.layoutpos.includes(_constants.BASE_CABINET_LAYOUTPOS)) {
+              nx = rect.itemInfo.x;
+              ny = rect.itemInfo.y;
+              rotRad = rect.itemInfo.rotation * Math.PI / 180;
+            }
+          });
+        }
+        if (allItemRect.cur.itemInfo.name.includes('Hood') || allItemRect.cur.itemInfo.name.includes('Range') || allItemRect.cur.itemInfo.name.includes('Cook Top')) {
+          var _intersects = allItemRect.others.filter(function (others) {
+            return intersectRect(others.rect, curitem.rect);
+          });
+          _intersects.forEach(function (rect) {
+            if (isPointInArea(allArea, rect.itemInfo) || !allArea.length) if (rect.itemInfo.name.includes('Hood') || rect.itemInfo.name.includes('Range') || rect.itemInfo.name.includes('Cook Top')) {
+              nx = rect.itemInfo.x;
+              ny = rect.itemInfo.y;
+              rotRad = rect.itemInfo.rotation * Math.PI / 180;
+            }
+          });
+        }
+      }
+    }
+  }
+  var rot = rotRad / Math.PI * 180;
+
+  //Check case.
+  //If item is 'blind base cabinet', it must be pulled from other 3".
+  if (allItemRect.cur && allItemRect.cur.itemInfo.sku_number.startsWith('BBC')) {
+    var offset3inch = (0, _convertUnitsLite.convert)(3).from('in').to('cm');
+    var tx = nx,
+      ty = ny;
+    if (allItemRect.cur && allItemRect.cur.itemInfo.sku_number.endsWith('-L')) {
+      if (rot == 0 || rot == -180) {
+        tx -= offset3inch * Math.cos(rotRad);
+      }
+      if (rot == 90 || rot == -90) {
+        ty -= offset3inch * Math.sin(rotRad);
+      }
+    }
+    if (allItemRect.cur && allItemRect.cur.itemInfo.sku_number.endsWith('-R')) {
+      if (rot == 0 || rot == -180) {
+        tx += offset3inch * Math.cos(rotRad);
+      }
+      if (rot == 90 || rot == -90) {
+        ty += offset3inch * Math.sin(rotRad);
+      }
+    }
+    var t_val = {
+      pos: {
+        x: tx,
+        y: ty
+      },
+      rotRad: rotRad,
+      size: allItemRect.cur.size,
+      layoutpos: allItemRect.cur.layoutpos,
+      is_corner: allItemRect.cur.is_corner
+    };
+    var isItemRectSect = validInterSect(allItemRect.others, t_val);
+    var isWallRectSect = validInterSect(allLineRects, t_val);
+    if (isItemRectSect && isWallRectSect) {
+      nx = tx;
+      ny = ty;
+    }
+  }
+  return {
+    nx: nx,
+    ny: ny,
+    rot: rot,
+    rotRad: rotRad
+  };
+}
+
+////////////
+function calcSnap3(allItemRect, allItemSnap, allLineRects, allLineSnap, allRect, x, y) {
+  // let layer = scene.layers.get(layerID);
+  // let cx = allItemRect.cur.pos.x;
+  // let cy = allItemRect.cur.pos.y;
+  var nx = x;
+  var ny = y;
+  var ndist = 20;
+  var rotRad = allItemRect.cur.rotRad;
+  var val = {
+    pos: {
+      x: x,
+      y: y
+    },
+    rotRad: rotRad
+  };
+  val.size = allItemRect.cur.size;
+  val.layoutpos = allItemRect.cur.layoutpos;
+  val.is_corner = allItemRect.cur.is_corner;
+  var curitem = getCalcRectFromItem3D(val);
+  var allCurSnap = getAllCurSnap(allLineRects, x, y, allItemRect.cur);
+  allCurSnap = validateSnaps(allCurSnap, allRect);
+  var getSnap = false;
+  var snapdist = [];
+  allCurSnap.forEach(function (snap) {
+    var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+    snapdist.push(dist);
+    if (dist < ndist) {
+      ndist = dist;
+      nx = snap.pos.x;
+      ny = snap.pos.y;
+      rotRad = snap.rotRad;
+      getSnap = true;
+    } else {
+      var i = 0;
+      allLineRects.forEach(function (others) {
+        var containrect = intersectRect(others.rect, curitem.rect);
+        if (containrect) {
+          var edist = Math.min.apply(null, snapdist);
+          allCurSnap.forEach(function (snap) {
+            var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+            if (dist === edist) {
+              ndist = dist;
+              nx = snap.pos.x;
+              ny = snap.pos.y;
+              rotRad = snap.rotRad;
+              getSnap = true;
+            }
+          });
+        }
+      });
+    }
+  });
+  if (getSnap === false) {
+    allLineRects.forEach(function (others) {
+      var containrect = intersectRect(others.rect, curitem.rect);
+      if (containrect) {
+        allLineSnap.forEach(function (snap) {
+          var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+          if (dist < 5000) {
+            nx = snap.pos.x;
+            ny = snap.pos.y;
+            rotRad = snap.rotRad;
+            getSnap = true;
+          }
+        });
+      }
+    });
+  }
+  allItemRect.others.forEach(function (others) {
+    if (!(others.layoutpos === 'base' && allItemRect.cur.layoutpos === 'wall') || !(others.layoutpos === 'wall' && allItemRect.cur.layoutpos === 'base')) {
+      var containrect = intersectRect(others.rect, curitem.rect);
+      if (containrect) {
+        getSnap = false;
+      }
+    }
+  });
+  if (!getSnap) {
+    var _snapdist2 = [];
+    allItemSnap.forEach(function (snap) {
+      var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+      _snapdist2.push(dist);
+      if (dist < ndist) {
+        ndist = dist;
+        nx = snap.pos.x;
+        ny = snap.pos.y;
+        rotRad = snap.rotRad;
+      } else {
+        allItemRect.others.forEach(function (others) {
+          if (!(others.layoutpos === 'base' && allItemRect.cur.layoutpos === 'wall') || !(others.layoutpos === 'wall' && allItemRect.cur.layoutpos === 'base')) {
+            var containrect = intersectRect(others.rect, curitem.rect);
+            if (containrect) {
+              var edist = Math.min.apply(null, _snapdist2);
+              allItemSnap.forEach(function (snap) {
+                var dist = (snap.pos.x - x) * (snap.pos.x - x) + (snap.pos.y - y) * (snap.pos.y - y);
+                if (dist === edist) {
+                  ndist = dist;
+                  nx = snap.pos.x;
+                  ny = snap.pos.y;
+                  rotRad = snap.rotRad;
+                }
+              });
+            }
+          }
+        });
+      }
+    });
+  }
+  var rot = rotRad / Math.PI * 180;
+  return {
+    nx: nx,
+    ny: ny,
+    rot: rot,
+    rotRad: rotRad
+  };
+}
+function getAllCurSnap(allLineRects, x, y, curItemRect) {
+  if (!curItemRect) return;
+  var allCurSnap = [];
+  var thick = _constants.LINE_THICKNESS / 2;
+  allLineRects.forEach(function (linerect) {
+    //allLineRects:left, right, top, bottom line
+    var p0 = clone_point(linerect.rect[2]); //point 2(x, y) inside of line
+    var p1 = clone_point(linerect.rect[3]); //point 3(x, y) inside of line
+    var q = point(x, y); // point of item
+    var cos = Math.cos(linerect.rotRad);
+    var sin = Math.sin(linerect.rotRad);
+    p0.x -= cos * curItemRect.size.width / 2;
+    p0.y -= sin * curItemRect.size.width / 2;
+    p1.x += cos * curItemRect.size.width / 2;
+    p1.y += sin * curItemRect.size.width / 2;
+    var n = point(-sin, cos);
+    var v3to0 = {
+      x: linerect.rect[0].x - p1.x,
+      y: linerect.rect[0].y - p1.y
+    };
+    var fDot = dotprod(n, v3to0);
+    if (fDot > 0) {
+      // normal vector is crossing the wall
+      n.x = -n.x;
+      n.y = -n.y;
+    }
+    var dist = dotprod(diff(p1, q), n);
+    var h = point(q.x + dist * n.x, q.y + dist * n.y);
+    var nrot = linerect.rotRad + Math.PI;
+    if (nrot >= Math.PI) nrot -= Math.PI * 2;
+    var o = itemrectInfo(h.x + n.x * (curItemRect && curItemRect.size.height / 2), h.y + n.y * (curItemRect && curItemRect.size.height / 2), nrot, curItemRect && curItemRect.size, curItemRect && curItemRect.layoutpos, curItemRect && curItemRect.is_corner);
+    allCurSnap.push(o);
+    nrot = nrot + Math.PI;
+    o = itemrectInfo(h.x - n.x * (curItemRect && curItemRect.size.height / 2 + thick), h.y - n.y * (curItemRect && curItemRect.size.height / 2 + thick), nrot, curItemRect && curItemRect.size, curItemRect && curItemRect.layoutpos, curItemRect && curItemRect.is_corner);
+    allCurSnap.push(o);
+  });
+  return allCurSnap;
+}
+function clone_point(pt) {
+  return point(pt.x, pt.y);
+}
+function dotprod(v0, v1) {
+  return v0.x * v1.x + v0.y * v1.y;
+}
+
+//////////
+function validInterSect(rect, val) {
+  var curitem = getCalcRectFromItem(val);
+  var datas = [];
+  rect.forEach(function (line) {
+    datas.push(line);
+  });
+  for (var i = 0; i < datas.length; i++) {
+    var data = datas[i];
+    var containrect = intersectRect(data.rect, curitem.rect);
+    if (containrect) {
+      return false;
+    }
+  }
+  return true;
+}
+var lineRect = function lineRect(layer) {
+  var areainfo = [];
+  layer.areas.forEach(function (area) {
+    var sz = area.vertices.size;
+    for (var i = 0; i < sz; i++) {
+      areainfo.push(area.vertices.get(i));
+    }
+  });
+  var rect = [];
+  areainfo.forEach(function (area) {
+    var vert = layer.vertices.get(area);
+    rect.push(vert.x, vert.y);
+  });
+  return rect;
+};
+function getAllHoleRect(scene, val) {
+  var layerID = scene.selectedLayer;
+  var layer = scene.layers.get(layerID);
+  var selectedItem = layer.getIn(['items', layer.selected.items.get(0)]);
+  if (selectedItem !== undefined) {
+    if (selectedItem.category != 'cabinet') {
+      // If selected Item type is not `cabinet` then do not snap at windows
+      return {
+        isSect: true,
+        snap: null
+      };
+    }
+  } else {
+    return {
+      isSect: false,
+      snap: null
+    };
+  }
+  var holes = [];
+  var itemRect = getCalcRectFromItem(val);
+  layer.lines.forEach(function (line) {
+    line.holes.forEach(function (holeID) {
+      var hole = layer.holes.get(holeID);
+      if (hole) holes.push(hole);
+    });
+  });
+  var i = 0;
+  for (; i < holes.length; i++) {
+    var twidth = holes[i].properties.getIn(['width', 'length']);
+    var theight = holes[i].properties.getIn(['thickness', 'length']) + 1;
+    var tdepth = holes[i].properties.getIn(['altitude', 'length']);
+    //let trot = holes[i].rotation;
+    var verticeIDs = scene.getIn(['layers', layerID, 'lines', holes[i].line, 'vertices'])._tail.array;
+    var vertice0 = scene.getIn(['layers', layerID, 'vertices', verticeIDs[0]]);
+    var vertice1 = scene.getIn(['layers', layerID, 'vertices', verticeIDs[1]]);
+    var point0 = {
+      x: vertice0.x,
+      y: vertice0.y
+    };
+    var point1 = {
+      x: vertice1.x,
+      y: vertice1.y
+    };
+    var rotation = Math.atan2(point1.y - point0.y, point1.x - point0.x);
+    var rectInfo = getCalcRectFromLine(point1.x, point1.y, point0.x, point0.y, _constants.LINE_THICKNESS, layer);
+    var vN = point(rectInfo.rect[0].x - rectInfo.rect[3].x, rectInfo.rect[0].y - rectInfo.rect[3].y);
+    var lenN = Math.sqrt(vN.x * vN.x + vN.y * vN.y);
+    vN.x /= lenN;
+    vN.y /= lenN;
+    var hx = holes[i].x;
+    var hy = holes[i].y;
+    hx += theight / 2 * vN.x;
+    hy += theight / 2 * vN.y;
+    var tval = {
+      pos: {
+        x: hx,
+        y: hy
+      },
+      rotRad: rotation
+    };
+    tval.size = {
+      width: twidth,
+      height: theight
+    };
+    var hole_rect = getCalcRectFromItem(tval);
+    if (intersectRect(itemRect.rect, hole_rect.rect)) {
+      if (tdepth > itemRect.size.depth && itemRect.layoutpos !== _constants.WALL_CABINET_LAYOUTPOS) {
+        var dist = itemRect.size.height / 2 + theight / 2;
+        var snap = [];
+        var p0 = {
+          x: hx + dist * Math.cos(rotation + Math.PI / 2),
+          y: hy + dist * Math.sin(rotation + Math.PI / 2)
+        };
+        var p1 = {
+          x: hx - dist * Math.cos(rotation + Math.PI / 2),
+          y: hy - dist * Math.sin(rotation + Math.PI / 2)
+        };
+        var allArea = getAllArea(layer);
+        if (isPointInArea(allArea, p0)) {
+          snap.push(p0);
+        }
+        if (isPointInArea(allArea, p1)) {
+          snap.push(p1);
+        }
+        return {
+          isSect: true,
+          snap: snap
+        };
+      } else return {
+        isSect: false,
+        snap: null
+      };
+    }
+  }
+  return {
+    isSect: true,
+    snap: null
+  };
+}
+function getHoleItems(layer) {
+  var holeItems = [];
+  layer.holes.map(function (hole) {
+    var width = hole.properties.getIn(['width', 'length']);
+    var altitude = hole.properties.getIn(['altitude', 'length']);
+    holeItems.push({
+      x: hole.x,
+      y: hole.y,
+      width: width,
+      altitude: altitude
+    });
+  });
+  return holeItems;
+}
+function needSnap(curItem, othItem) {
+  var blSnap = false;
+  if (curItem == undefined || curItem == null) return false;
+  var altitude = curItem.selectedItem.properties.get('altitude');
+  var heightFromFloor = (0, _convertUnitsLite.convert)(altitude.get('_length')).from(altitude.get('_unit')).to('in');
+  var height = curItem.cat.info.sizeinfo.height;
+  var currentItem = {
+    heightFromFloor: heightFromFloor,
+    height: height
+  };
+  altitude = othItem.item.properties.get('altitude');
+  heightFromFloor = (0, _convertUnitsLite.convert)(altitude.get('_length')).from(altitude.get('_unit')).to('in');
+  height = othItem.cat && othItem.cat.info.sizeinfo.height;
+  var otherItem = {
+    heightFromFloor: heightFromFloor,
+    height: height
+  };
+  var curFloor = currentItem.heightFromFloor;
+  var otherFloor = otherItem.heightFromFloor;
+  var delta;
+  curFloor > otherFloor ? delta = otherItem.height : delta = currentItem.height;
+  if (Math.abs(curFloor - otherFloor) < delta) blSnap = true;
+  if (curItem.cat.hasOwnProperty('long_name') || othItem.cat && othItem.cat.hasOwnProperty('long_name')) {
+    if (curItem.cat.long_name.includes('Hood') || othItem.cat && othItem.cat.long_name.includes('Hood')) blSnap = true;
+    if (curItem.cat.long_name.includes('Hood') && othItem.cat && othItem.cat.long_name.includes('Base Cabinet') || curItem.cat.long_name.includes('Base Cabinet') && othItem.cat && othItem.cat.long_name.includes('Hood')) blSnap = false;
+    if (curItem.cat.long_name.includes('Cook Top') && othItem.cat && othItem.cat.long_name.includes('Cabinet') || curItem.cat.long_name.includes('Cabinet') && othItem.cat && othItem.cat.long_name.includes('Cook Top')) blSnap = true;
+  }
+  return blSnap;
+}
+function isFrontWall(v0, v1) {
+  var x1 = v0.x,
+    y1 = v0.y;
+  var x2 = v1.x,
+    y2 = v1.y;
+  var alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
+  return almostEqual(y1, y2) && x1 < x2 || -Math.PI / 2 < alpha && alpha < Math.PI / 2;
+}
+function isBackWall(v0, v1) {
+  var x1 = v0.x,
+    y1 = v0.y;
+  var x2 = v1.x,
+    y2 = v1.y;
+  var alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
+  return almostEqual(y1, y2) && x1 > x2 || -Math.PI / 2 > alpha || alpha > Math.PI / 2;
+}
+function isLeftWall(v0, v1) {
+  var x1 = v0.x,
+    y1 = v0.y;
+  var x2 = v1.x,
+    y2 = v1.y;
+  var alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
+  return almostEqual(x1, x2) && y1 < y2 || Math.PI > alpha && alpha > 0;
+}
+function isRightWall(v0, v1) {
+  var x1 = v0.x,
+    y1 = v0.y;
+  var x2 = v1.x,
+    y2 = v1.y;
+  var alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
+  return almostEqual(x1, x2) && y1 > y2 || -Math.PI < alpha && alpha < 0;
+}
+
+/**
+ * Calculate the overlapping relationship of two lines
+ * @param {*} srcLine // source line
+ * @param {*} destLine // destination line
+ * @returns overlapping status (OVERLAP_NONE | OVERLAP_SAME | OVERLAP_LINK | OVERLAP_INCLUDED | OVERLAP_SOME) and line segments of srcLine which broken with destLine
+ * OVERLAP_NONE: two lines are not overlapped
+ * OVERLAP_SAME: the start point and endpoint of two lines are same
+ * OVERLAP_LINK: two lines are linked at the common point, so they can be merged to one line
+ * OVERLAP_INCLUDED: destLine includes srcLine
+ * OVERLAP_SOME: two lines are overlapped with some common range, then returns the trimmed segments of srcLine
+ *
+ *  //////// test - start /////////////
+    const p1 = { x1: 1413.1313131313132, y1: 1044.949494949495 };
+    const p2 = { x1: 1476.2626262626263, y1: 1108.0808080808079 };
+    const p3 = { x1: 1596.969696969697, y1: 1228.7878787878785 };
+    const p4 = { x1: 1664.1414141414139, y1: 1295.9595959595958 };
+    const tempRet = GeometryUtils.relationshipOfTwoOverlappedLines(
+      { x1: p3.x1, y1: p3.y1, x2: p1.x1, y2: p1.y1 },
+      { x1: p1.x1, y1: p1.y1, x2: p3.x1, y2: p3.y1 }
+    );
+    console.log(tempRet);
+    //////// test - end /////////////
+
+ */
+function relationshipOfTwoOverlappedLines(srcLine, destLine) {
+  // let res1 = relationshipOfTwoOverlappedLines1(srcLine, destLine);
+  var res2 = relationshipOfTwoOverlappedLines2(srcLine, destLine);
+  // if (res1.result !== 0 || res2.result !== 0) {
+  //   console.group(res1.result);
+  //   console.log(res1);
+  //   console.log(res2);
+  //   console.log(srcLine, destLine);
+  //   console.groupEnd();
+  // }
+  return res2;
+}
+function relationshipOfTwoOverlappedLines2(srcLine, destLine) {
+  var p1 = {
+    x: Math.round(srcLine.x1 * 100) / 100,
+    y: Math.round(srcLine.y1 * 100) / 100
+  };
+  var p2 = {
+    x: Math.round(srcLine.x2 * 100) / 100,
+    y: Math.round(srcLine.y2 * 100) / 100
+  };
+  var p3 = {
+    x: Math.round(destLine.x1 * 100) / 100,
+    y: Math.round(destLine.y1 * 100) / 100
+  };
+  var p4 = {
+    x: Math.round(destLine.x2 * 100) / 100,
+    y: Math.round(destLine.y2 * 100) / 100
+  };
+  var x1 = p1.x,
+    y1 = p1.y;
+  var x2 = p2.x,
+    y2 = p2.y;
+  var x3 = p3.x,
+    y3 = p3.y;
+  var x4 = p4.x,
+    y4 = p4.y;
+  var denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+  var numA = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+  var numB = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+  if ((0, _math.fAbs)(denom) <= _constants.EPSILON) {
+    if ((0, _math.fAbs)(numA) <= _constants.EPSILON && (0, _math.fAbs)(numB) <= _constants.EPSILON) {
+      var comparator = function comparator(pa, pb) {
+        return (0, _math.fAbs)(pa.x - pb.x) <= _constants.EPSILON ? pa.y - pb.y : pa.x - pb.x;
+      };
+      var line0 = [p1, p2].sort(comparator);
+      var line1 = [p3, p4].sort(comparator);
+      var _sort3 = [line0, line1].sort(function (lineA, lineB) {
+          return comparator(lineA[0], lineB[0]);
+        }),
+        _sort4 = (0, _slicedToArray2["default"])(_sort3, 2),
+        lineSX = _sort4[0],
+        lineDX = _sort4[1];
+      var isReversedSrcLineIdx = false;
+      if (lineSX[0].x === line0[0].x && lineSX[0].y === line0[0].y) isReversedSrcLineIdx = false; // SX=srcLine, DX=destLine
+      else if (lineSX[0].x === line1[0].x && lineSX[0].y === line1[0].y) isReversedSrcLineIdx = true; // DX=srcLine, SX=destLine
+
+      var compare0 = comparator(lineSX[0], lineDX[0]); // always <= 0
+      var compare1 = comparator(lineSX[1], lineDX[0]);
+      var compare2 = comparator(lineSX[1], lineDX[1]);
+      var sp = null,
+        ep = null;
+      if (_export.MathUtils.fAbs(compare1) < _constants.EPSILON) {
+        //       SX
+        //  |----------|
+        //                   DX
+        //             |------------|
+        // link : lineSX[0] - lineDX[1]
+        if (lineSX[0].x === p1.x && lineSX[0].y === p1.y || lineDX[1].x === p2.x && lineDX[1].y === p2.y) {
+          sp = {
+            x: lineSX[0].x,
+            y: lineSX[0].y
+          };
+          ep = {
+            x: lineDX[1].x,
+            y: lineDX[1].y
+          };
+        } else {
+          // srcLine Direction is reversed
+          sp = {
+            x: lineDX[1].x,
+            y: lineDX[1].y
+          };
+          ep = {
+            x: lineSX[0].x,
+            y: lineSX[0].y
+          };
+        }
+        return {
+          result: _constants.OVERLAP_LINK,
+          linkedLine: {
+            x1: sp.x,
+            y1: sp.y,
+            x2: ep.x,
+            y2: ep.y
+          }
+        };
+      } else if (compare1 < 0) {
+        //       SX
+        //  |----------|
+        //                     DX
+        //                |----------|
+        // none
+        return {
+          result: _constants.OVERLAP_NONE
+        };
+      } else if (_export.MathUtils.fAbs(compare0) < _constants.EPSILON && _export.MathUtils.fAbs(compare2) < _constants.EPSILON) {
+        //       SX
+        //  |----------|
+        //       DX
+        //  |----------|
+        return {
+          result: _constants.OVERLAP_SAME
+        };
+      } else if (_export.MathUtils.fAbs(compare0) < _constants.EPSILON) {
+        if (compare2 < 0 && isReversedSrcLineIdx) {
+          //       SX
+          //  |---------------|
+          //             DX
+          //  |-----------------------|
+          // DX includes SX, DX=srcLine, SX=destLine : sx1 - dx1
+          if (lineDX[1].x === p2.x && lineDX[1].y === p2.y) {
+            sp = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+            ep = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+          } else {
+            // srcLine Direction is reversed
+            sp = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+            ep = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+          }
+          return {
+            result: _constants.OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        } else if (compare2 > 0 && !isReversedSrcLineIdx) {
+          //             SX
+          //  |-----------------------|
+          //         DX
+          //  |---------------|
+          // SX includes DX, SX=srcLine, DX=destLine  : dx1 - sx1
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            sp = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+            ep = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+          } else {
+            // srcLine Direction is reversed
+            sp = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+            ep = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+          }
+          return {
+            result: _constants.OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        } else {
+          //       srcLine
+          //  |---------------|
+          //          destLine
+          //  |-----------------------|
+          // destLine includes srcLine
+          return {
+            result: _constants.OVERLAP_INCLUDED
+          };
+        }
+      } else if (_export.MathUtils.fAbs(compare2) < _constants.EPSILON) {
+        //             SX
+        //  |-----------------------|
+        //                DX
+        //       |------------------|
+        if (isReversedSrcLineIdx) {
+          // SX includes DX, DX=srcLine, SX=destLine
+          // destLine includes srcLine
+          return {
+            result: _constants.OVERLAP_INCLUDED
+          };
+        } else {
+          // SX includes DX, SX=srcLine, DX=destLine
+          // srcLine incluedes destLine : sx0 - dx0
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            sp = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+            ep = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+          } else {
+            // srcLine direction is reversed
+            sp = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+            ep = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+          }
+          return {
+            result: _constants.OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        }
+      } else if (compare0 < 0 && compare2 > 0) {
+        //             SX
+        //  |-----------------------|
+        //             DX
+        //     |----------------|
+        if (isReversedSrcLineIdx) {
+          // SX includes DX, DX=srcLine, SX=destLine
+          // destLine includes srcLine
+          return {
+            result: _constants.OVERLAP_INCLUDED
+          };
+        } else {
+          // SX includes DX, SX=srcLine, DX=destLine
+          // srcLine incluedes destLine : sx0 - dx0, dx1 - sx1
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            return {
+              result: _constants.OVERLAP_SOME,
+              trimmedSegs: [{
+                x1: lineSX[0].x,
+                y1: lineSX[0].y,
+                x2: lineDX[0].x,
+                y2: lineDX[0].y
+              }, {
+                x1: lineDX[1].x,
+                y1: lineDX[1].y,
+                x2: lineSX[1].x,
+                y2: lineSX[1].y
+              }]
+            };
+          } else {
+            // srcLine direction is reversed
+            return {
+              result: _constants.OVERLAP_SOME,
+              trimmedSegs: [{
+                x1: lineDX[0].x,
+                y1: lineDX[0].y,
+                x2: lineSX[0].x,
+                y2: lineSX[0].y
+              }, {
+                x1: lineSX[1].x,
+                y1: lineSX[1].y,
+                x2: lineDX[1].x,
+                y2: lineDX[1].y
+              }]
+            };
+          }
+        }
+      } else if (compare2 < 0) {
+        //             SX
+        //  |-----------------------|
+        //                   DX
+        //     |----------------------------|
+        // overlap some
+        if (isReversedSrcLineIdx) {
+          // DX=srcLine, SX=destLine
+          if (lineDX[1].x === p2.x && lineDX[1].y === p2.y) {
+            sp = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+            ep = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+          } else {
+            // srcLine direction is reversed
+            sp = {
+              x: lineDX[1].x,
+              y: lineDX[1].y
+            };
+            ep = {
+              x: lineSX[1].x,
+              y: lineSX[1].y
+            };
+          }
+          return {
+            result: _constants.OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        } else {
+          // SX=srcLine, DX=destLine
+          if (lineSX[1].x === p2.x && lineSX[1].y === p2.y) {
+            sp = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+            ep = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+          } else {
+            // srcLine direction is reversed
+            sp = {
+              x: lineDX[0].x,
+              y: lineDX[0].y
+            };
+            ep = {
+              x: lineSX[0].x,
+              y: lineSX[0].y
+            };
+          }
+          return {
+            result: _constants.OVERLAP_SOME,
+            trimmedSegs: [{
+              x1: sp.x,
+              y1: sp.y,
+              x2: ep.x,
+              y2: ep.y
+            }]
+          };
+        }
+      }
+    }
+  }
+  return {
+    result: _constants.OVERLAP_NONE
+  };
+}
+function relationshipOfTwoOverlappedLines1(srcLine, destLine) {
+  var INFINITY = 1000000;
+  var ZERO_DELTA = 0.01;
+  // geometric equation of srcLine
+  var dx1 = srcLine.x2 - srcLine.x1;
+  dx1 = _export.MathUtils.fAbs(dx1) < ZERO_DELTA ? 0 : dx1;
+  var dy1 = srcLine.y2 - srcLine.y1;
+  dy1 = _export.MathUtils.fAbs(dy1) < ZERO_DELTA ? 0 : dy1;
+  var a1 = dx1 === 0 ? INFINITY : dy1 / dx1;
+  var b1 = a1 === INFINITY ? srcLine.x1 : srcLine.y1 - a1 * srcLine.x1;
+  // geometric equation of destLine
+  var dx2 = destLine.x2 - destLine.x1;
+  dx2 = _export.MathUtils.fAbs(dx2) < ZERO_DELTA ? 0 : dx2;
+  var dy2 = destLine.y2 - destLine.y1;
+  dy2 = _export.MathUtils.fAbs(dy2) < ZERO_DELTA ? 0 : dy2;
+  var a2 = dx2 === 0 ? INFINITY : dy2 / dx2;
+  var b2 = a2 === INFINITY ? destLine.x1 : destLine.y1 - a2 * destLine.x1;
+  if (_export.MathUtils.fAbs(_export.MathUtils.fAbs(a1) - _export.MathUtils.fAbs(a2)) > ZERO_DELTA)
+    // two lines are not parallel
+    return {
+      result: _constants.OVERLAP_NONE
+    };
+  if (_export.MathUtils.fAbs(_export.MathUtils.fAbs(b1) - _export.MathUtils.fAbs(b2)) > ZERO_DELTA)
+    // two lines are parallel but not overlap
+    return {
+      result: _constants.OVERLAP_NONE
+    };
+
+  // parametric equation of destLine
+  var sk1 = dx1 === 0 ? INFINITY : _export.MathUtils.toFixedFloat((destLine.x1 - srcLine.x1) / dx1, 3);
+  var sk2 = dy1 === 0 ? INFINITY : _export.MathUtils.toFixedFloat((destLine.y1 - srcLine.y1) / dy1, 3);
+  var ek1 = dx1 === 0 ? INFINITY : _export.MathUtils.toFixedFloat((destLine.x2 - srcLine.x1) / dx1, 3);
+  var ek2 = dy1 === 0 ? INFINITY : _export.MathUtils.toFixedFloat((destLine.y2 - srcLine.y1) / dy1, 3);
+  if (sk1 !== INFINITY && sk2 !== INFINITY && ek1 !== INFINITY && ek2 !== INFINITY && (sk1 !== sk2 || ek1 !== ek2))
+    // destLine does not overlap with srcLine
+    return {
+      result: _constants.OVERLAP_NONE
+    };
+
+  // parameter of destLine on the start and end points
+  var sk = Math.min(sk1, sk2);
+  if (Math.abs(sk) < 0.05) sk = 0;else if (Math.abs(Math.abs(sk) - 1) < 0.05) sk = 1;
+  var ek = Math.abs(Math.min(ek1, ek2)) > 0.05 ? Math.min(ek1, ek2) : 0;
+  if (Math.abs(ek) < 0.05) ek = 0;else if (Math.abs(Math.abs(ek) - 1) < 0.05) ek = 1;
+  // let ek = Math.min(ek1, ek2);
+
+  // check the relationship between srcLine and destLine
+  if (sk < 0 && ek < 0 || sk > 1 && ek > 1)
+    // not overlap
+    return {
+      result: _constants.OVERLAP_NONE
+    };
+  if (sk === 0 && ek === 1 || sk === 1 && ek === 0)
+    // same lines
+    return {
+      result: _constants.OVERLAP_SAME
+    };
+  if (sk <= 0 && ek >= 1 || sk >= 1 && ek <= 0)
+    // destLine includes srcLine
+    return {
+      result: _constants.OVERLAP_INCLUDED
+    };
+  if (sk === 0 && ek < 0 || sk === 1 && ek > 1 || ek === 0 && sk < 0 || ek === 1 && sk > 1) {
+    // linked with one common point
+    var linkedLine;
+    if (sk === 0 && ek < 0) {
+      // destE  destS srcS      srcE
+      //  |----------|------------|
+      linkedLine = {
+        x1: destLine.x2,
+        y1: destLine.y2,
+        x2: srcLine.x2,
+        y2: srcLine.y2
+      };
+    } else if (sk === 1 && ek > 1) {
+      // srcS    srcE destS     destE
+      //  |----------|------------|
+      linkedLine = {
+        x1: srcLine.x1,
+        y1: srcLine.y1,
+        x2: destLine.x2,
+        y2: destLine.y2
+      };
+    } else if (ek === 0 && sk < 0) {
+      // destS  destE srcS      srcE
+      //  |----------|------------|
+      linkedLine = {
+        x1: destLine.x1,
+        y1: destLine.y1,
+        x2: srcLine.x2,
+        y2: srcLine.y2
+      };
+    } else if (ek === 1 && sk > 1) {
+      // srcS    srcE destE     destS
+      //  |----------|------------|
+      linkedLine = {
+        x1: srcLine.x1,
+        y1: srcLine.y1,
+        x2: destLine.x1,
+        y2: destLine.y1
+      };
+    }
+    return {
+      result: _constants.OVERLAP_LINK,
+      linkedLine: linkedLine
+    };
+  }
+  var trimmedSegment1 = null;
+  var trimmedSegment2 = null;
+  var ret = {
+    result: _constants.OVERLAP_SOME,
+    trimmedSegs: []
+  };
+  if (0 <= sk && sk <= 1 && 0 <= ek && ek <= 1) {
+    // srcLine includes destLine
+    if (sk < ek) {
+      // srcS  destS     destE   srcE
+      //  |------|---------|-------|
+      if (sk > 0) trimmedSegment1 = {
+        x1: srcLine.x1,
+        y1: srcLine.y1,
+        x2: destLine.x1,
+        y2: destLine.y1
+      };
+      if (ek < 1) trimmedSegment2 = {
+        x1: destLine.x2,
+        y1: destLine.y2,
+        x2: srcLine.x2,
+        y2: srcLine.y2
+      };
+    } else {
+      // srcS  destE     destS   srcE
+      //  |------|---------|-------|
+      if (ek > 0) trimmedSegment1 = {
+        x1: srcLine.x1,
+        y1: srcLine.y1,
+        x2: destLine.x2,
+        y2: destLine.y2
+      };
+      if (sk < 1) trimmedSegment2 = {
+        x1: destLine.x1,
+        y1: destLine.y1,
+        x2: srcLine.x2,
+        y2: srcLine.y2
+      };
+    }
+  } else {
+    // srcLine and destLine are overlapped with some range
+    if (sk < 0) {
+      // destS  srcS     destE   srcE
+      //  |------|---------|-------|
+      trimmedSegment1 = {
+        x1: destLine.x2,
+        y1: destLine.y2,
+        x2: srcLine.x2,
+        y2: srcLine.y2
+      };
+    } else if (ek < 0) {
+      // destE  srcS     destS   srcE
+      //  |------|---------|-------|
+      trimmedSegment1 = {
+        x1: destLine.x1,
+        y1: destLine.y1,
+        x2: srcLine.x2,
+        y2: srcLine.y2
+      };
+    } else if (sk > 1) {
+      // srcS  destE     srcE    destS
+      //  |------|---------|-------|
+      trimmedSegment1 = {
+        x1: srcLine.x1,
+        y1: srcLine.y1,
+        x2: destLine.x2,
+        y2: destLine.y2
+      };
+    } else if (ek > 1) {
+      // srcS  destS     srcE    destE
+      //  |------|---------|-------|
+      trimmedSegment1 = {
+        x1: srcLine.x1,
+        y1: srcLine.y1,
+        x2: destLine.x1,
+        y2: destLine.y1
+      };
+    }
+  }
+  if (trimmedSegment1 !== null) ret.trimmedSegs.push(trimmedSegment1);
+  if (trimmedSegment2 !== null) ret.trimmedSegs.push(trimmedSegment2);
+  return ret;
+}
+
+/**
+ *
+ * @param {Array} points points of polygon [[x0, y0], [x1, y1], ...]
+ * @returns {Array} { x, y } position of centroid
+ */
+function getCentroidOfPolygon(points) {
+  var centroid = points.reduce(function (x, y) {
+    return [x[0] + y[0] / points.length, x[1] + y[1] / points.length];
+  }, [0, 0]);
+  return {
+    x: centroid[0],
+    y: centroid[1]
+  };
+}
+
+/**
+ * Return the polygon points of room
+ * @param {Object} layer
+ * @returns {Array} polygon points [x0, y0, x1, y1, ... ]
+ */
+function getPoylgonPoints(layer) {
+  var _layer$areas;
+  var areainfo = [];
+  (_layer$areas = layer.areas) === null || _layer$areas === void 0 || _layer$areas.forEach(function (area) {
+    var _area$vertices;
+    var sz = (_area$vertices = area.vertices) === null || _area$vertices === void 0 ? void 0 : _area$vertices.size;
+    for (var i = 0; i < sz; i++) {
+      areainfo.push(area.vertices.get(i));
+    }
+  });
+  var rect = [];
+  areainfo.forEach(function (area) {
+    var _layer$vertices;
+    var vert = (_layer$vertices = layer.vertices) === null || _layer$vertices === void 0 ? void 0 : _layer$vertices.get(area);
+    rect.push(vert === null || vert === void 0 ? void 0 : vert.x, vert === null || vert === void 0 ? void 0 : vert.y);
+  });
+  return rect;
+}
+function validRect(itemRect, rects) {
+  var updatedItemRect = getCalcRectFromItem(itemRect);
+  return rects.every(function (rect) {
+    return !intersectRect(rect.rect, updatedItemRect.rect);
+  });
+}
+function getCalcRectFromItem2(itemInfo) {
+  var x = itemInfo.pos.x;
+  var y = itemInfo.pos.y;
+  var w = itemInfo.size.width / 2;
+  var h = itemInfo.size.height / 2;
+  var rotRad = itemInfo.rotRad;
+  var mx = x - w * Math.cos(rotRad);
+  var my = y - w * Math.sin(rotRad);
+  var m2x = x + w * Math.cos(rotRad);
+  var m2y = y + w * Math.sin(rotRad);
+  var m3x = x - h * Math.sin(rotRad);
+  var m3y = y + h * Math.cos(rotRad);
+  var m1x = x + h * Math.sin(rotRad);
+  var m1y = y - h * Math.cos(rotRad);
+  return {
+    rectCenterPoint: [[point(mx, my), 180], [point(m1x, m1y), -90], [point(m2x, m2y), 0], [point(m3x, m3y), 90]]
+  };
+}
+function getAllItems2(curItem, layer) {
+  var rectarray = [];
+  layer.items.forEach(function (item) {
+    var val = {
+      pos: {
+        x: item.x,
+        y: item.y
+      },
+      rotRad: item.rotation / 180 * Math.PI
+    };
+    var width = (0, _convertUnitsLite.convert)(item.properties.getIn(['width', '_length'])).from(curItem.get('properties').get('width').get('_unit')).to('cm');
+    var height = (0, _convertUnitsLite.convert)(item.properties.getIn(['depth', '_length'])).from(curItem.get('properties').get('depth').get('_unit')).to('cm');
+    val.size = {
+      width: width,
+      height: height
+    };
+    var curItemTall = (0, _convertUnitsLite.convert)(curItem.get('properties').get('height').get('_length')).from(curItem.get('properties').get('height').get('_unit')).to('cm');
+    var zMinCurItem = (0, _convertUnitsLite.convert)(curItem.get('properties').get('altitude').get('_length')).from(curItem.get('properties').get('altitude').get('_unit')).to('cm');
+    var zMaxCurItem = zMinCurItem + curItemTall;
+    if (curItem.get('id') !== item.id) {
+      var detectObjectsAtSameAltitudeFlag = false;
+      var itemTall = (0, _convertUnitsLite.convert)(item.properties.getIn(['height', '_length'])).from(item.get('properties').get('height').get('_unit')).to('cm');
+      var zMinItem = (0, _convertUnitsLite.convert)(item.properties.getIn(['altitude', '_length'])).from(item.get('properties').get('altitude').get('_unit')).to('cm');
+      var zMaxItem = zMinItem + itemTall;
+      if (zMinItem - zMinCurItem >= 0 && zMaxCurItem - zMinItem > _constants.EPSILON || zMinCurItem - zMinItem >= 0 && zMaxItem - zMinCurItem > _constants.EPSILON) detectObjectsAtSameAltitudeFlag = true;
+      if (detectObjectsAtSameAltitudeFlag) {
+        var x = val.pos.x;
+        var y = val.pos.y;
+        var rotRad = val.rotRad;
+        var w = val.size.width / 2;
+        var h = val.size.height / 2;
+        var mx = x - w * Math.cos(rotRad);
+        var my = y - w * Math.sin(rotRad);
+        var x0 = mx + h * Math.sin(rotRad);
+        var y0 = my - h * Math.cos(rotRad);
+        var x3 = mx * 2 - x0;
+        var y3 = my * 2 - y0;
+        var x1 = x * 2 - x3;
+        var y1 = y * 2 - y3;
+        var x2 = x * 2 - x0;
+        var y2 = y * 2 - y0;
+        rectarray.push({
+          rect: [point(x0, y0), point(x1, y1), point(x0, y0), point(x1, y1)]
+        });
+        rectarray.push({
+          rect: [point(x1, y1), point(x2, y2), point(x1, y1), point(x2, y2)]
+        });
+        rectarray.push({
+          rect: [point(x2, y2), point(x3, y3), point(x2, y2), point(x3, y3)]
+        });
+        rectarray.push({
+          rect: [point(x3, y3), point(x0, y0), point(x3, y3), point(x0, y0)]
+        });
+      }
+    }
+  });
+  return {
+    others: rectarray
+  };
+}
+function calcDistancesFromItemToWalls(curItem, layer) {
+  if ((0, _helper.isEmpty)(curItem)) return [];
+  var x = curItem.get('x');
+  var y = curItem.get('y');
+  var rotRad = curItem.get('rotation') / 180 * Math.PI;
+  var width, height;
+  if (curItem.get('properties').get('width') || curItem.get('properties').get('depth')) {
+    width = (0, _convertUnitsLite.convert)(curItem.get('properties').get('width').get('_length')).from(curItem.get('properties').get('width').get('_unit')).to('cm');
+    height = (0, _convertUnitsLite.convert)(curItem.get('properties').get('depth').get('_length')).from(curItem.get('properties').get('depth').get('_unit')).to('cm');
+  } else {
+    width = (0, _convertUnitsLite.convert)(curItem.info.sizeinfo.width).from('in').to('cm');
+    height = (0, _convertUnitsLite.convert)(curItem.info.sizeinfo.depth).from('in').to('cm');
+  }
+  var center_x = x; // middle of front line of cabinet rect
+  var center_y = y;
+  var PointArray = [];
+  var itemInfo = {
+    pos: {
+      x: x,
+      y: y
+    },
+    rotRad: rotRad
+  };
+  itemInfo.size = {
+    width: width,
+    height: height
+  };
+  var curiteminfo = getCalcRectFromItem2(itemInfo);
+  var allItemRect = getAllItems2(curItem, layer); // get all item edge rects
+  var allLines = getAllLines(layer); // get all wall lines
+  var allLineRects = buildRectFromLines(layer, allLines); // make line rects from wall lines
+  var allRect = allLineRects.concat(allItemRect.others); // item edges + wall lines
+  var _loop = function _loop(i) {
+    // [rectCenterPoint] has four middle points of cabinet rect edges
+    var centerpoint = curiteminfo.rectCenterPoint[i];
+    var comparelength = []; // distance array from rectCenterPoint[i] to other lines(walls, other cabinet rect edges)
+    var a;
+    var RectLineFuction = linePassingThroughTwoPoints(centerpoint[0].x, centerpoint[0].y, center_x, center_y); // normal line of cabinet rect edge
+
+    allRect.forEach(function (linerect) {
+      // calc distance to all other lines
+      var p0 = clone_point(linerect.rect[2]);
+      var p1 = clone_point(linerect.rect[3]);
+      var lineFunction = {}; // other line function
+      if (p0.x !== p1.x || p0.y !== p1.y) lineFunction = linePassingThroughTwoPoints(p0.x, p0.y, p1.x, p1.y);
+      // intersection between normal line and other line
+      var coordinatePoint = twoLinesIntersection(lineFunction.a, lineFunction.b, lineFunction.c, RectLineFuction.a, RectLineFuction.b, RectLineFuction.c);
+      if (coordinatePoint !== undefined) {
+        if (
+        // intersection point is on the other line
+        pointsDistance(p0.x, p0.y, p1.x, p1.y) > pointsDistance(p0.x, p0.y, coordinatePoint.x, coordinatePoint.y) && pointsDistance(p0.x, p0.y, p1.x, p1.y) > pointsDistance(p1.x, p1.y, coordinatePoint.x, coordinatePoint.y)) {
+          // check the intersection point is outside direction of edge
+          var isOutside = true;
+          for (var j = 0; j < curiteminfo.rectCenterPoint.length; j++) {
+            if (j === i) continue;
+            var otherCenterPoint = curiteminfo.rectCenterPoint[j];
+            if (isPointOnLineSegment(centerpoint[0].x, centerpoint[0].y, coordinatePoint.x, coordinatePoint.y, otherCenterPoint[0].x, otherCenterPoint[0].y)) isOutside = false;
+          }
+          if (isOutside && pointsDistance(coordinatePoint.x, coordinatePoint.y, center_x, center_y) > pointsDistance(centerpoint[0].x, centerpoint[0].y, coordinatePoint.x, coordinatePoint.y)) {
+            comparelength.push(pointsDistance(centerpoint[0].x, centerpoint[0].y, coordinatePoint.x, coordinatePoint.y));
+            a = Math.min.apply(null, comparelength);
+          }
+        }
+      }
+    });
+    PointArray.push([a, centerpoint[1]]);
+  };
+  for (var i = 0; i < curiteminfo.rectCenterPoint.length; i++) {
+    _loop(i);
+  }
+  PointArray.forEach(function (pointElement, index) {
+    if (pointElement[0] == undefined) PointArray[index][0] = 0;
+  });
+  var cnt = 0;
+  PointArray.forEach(function (pointElement) {
+    if (pointElement[0] == 0) cnt++;
+  });
+  if (cnt == 4 || cnt == 3) {
+    PointArray[0][0] = 100;
+    PointArray[1][0] = 100;
+  }
+  return {
+    PointArray: PointArray
+  };
+}
+function calcDistancesFromHoleToNearestOneOrWall(curHole, layer) {
+  var _layer$lines, _layer$vertices2, _line$vertices, _layer$vertices3, _line$vertices2, _curHole$properties$g, _curHole$properties, _line$get;
+  var distArray = {
+    distLeft: 0,
+    distRight: 0
+  };
+  if ((0, _helper.isEmpty)(curHole)) return distArray;
+  /***** calculate Left & Right distance from nearest hole ******/
+  // parent line of curHole
+  var line = (_layer$lines = layer.lines) === null || _layer$lines === void 0 ? void 0 : _layer$lines.get(curHole.line);
+  var v0 = (_layer$vertices2 = layer.vertices) === null || _layer$vertices2 === void 0 ? void 0 : _layer$vertices2.get(line === null || line === void 0 || (_line$vertices = line.vertices) === null || _line$vertices === void 0 ? void 0 : _line$vertices.get(0));
+  var v1 = (_layer$vertices3 = layer.vertices) === null || _layer$vertices3 === void 0 ? void 0 : _layer$vertices3.get(line === null || line === void 0 || (_line$vertices2 = line.vertices) === null || _line$vertices2 === void 0 ? void 0 : _line$vertices2.get(1));
+  var lineLength = pointsDistance(v0.x, v0.y, v1.x, v1.y);
+  if ((0, _helper.isEmpty)(line) || (0, _helper.isEmpty)(v0) || (0, _helper.isEmpty)(v1)) return distArray;
+  var angle = angleBetweenTwoPoints(v0.x, v0.y, v1.x, v1.y);
+
+  // start point and end point of current hole
+  var chw = (_curHole$properties$g = (_curHole$properties = curHole.properties) === null || _curHole$properties === void 0 || (_curHole$properties = _curHole$properties.get('width')) === null || _curHole$properties === void 0 ? void 0 : _curHole$properties.get('length')) !== null && _curHole$properties$g !== void 0 ? _curHole$properties$g : 0;
+  var chPt = {
+    x: v0.x + lineLength * curHole.offset * Math.cos(angle),
+    y: v0.y + lineLength * curHole.offset * Math.sin(angle)
+  };
+  var chsp = {
+    x: chPt.x - chw / 2 * Math.cos(angle),
+    y: chPt.y - chw / 2 * Math.sin(angle)
+  };
+  var chep = {
+    x: chPt.x + chw / 2 * Math.cos(angle),
+    y: chPt.y + chw / 2 * Math.sin(angle)
+  };
+  distArray.distLeft = pointsDistance(v0.x, v0.y, chsp.x, chsp.y);
+  distArray.distRight = pointsDistance(v1.x, v1.y, chep.x, chep.y);
+  (_line$get = line.get('holes')) === null || _line$get === void 0 || _line$get.forEach(function (hId) {
+    if (hId !== curHole.id) {
+      var _layer$holes, _hole$properties$get$, _hole$properties;
+      var hole = (_layer$holes = layer.holes) === null || _layer$holes === void 0 ? void 0 : _layer$holes.get(hId);
+      // start point and end point of other hole
+      var hw = (_hole$properties$get$ = (_hole$properties = hole.properties) === null || _hole$properties === void 0 || (_hole$properties = _hole$properties.get('width')) === null || _hole$properties === void 0 ? void 0 : _hole$properties.get('length')) !== null && _hole$properties$get$ !== void 0 ? _hole$properties$get$ : 0;
+      var hPt = {
+        x: v0.x + lineLength * hole.offset * Math.cos(angle),
+        y: v0.y + lineLength * hole.offset * Math.sin(angle)
+      };
+      var hsp = {
+        x: hPt.x - hw / 2 * Math.cos(angle),
+        y: hPt.y - hw / 2 * Math.sin(angle)
+      };
+      var hep = {
+        x: hPt.x + hw / 2 * Math.cos(angle),
+        y: hPt.y + hw / 2 * Math.sin(angle)
+      };
+      var relation = relationshipOfTwoOverlappedLines({
+        x1: chsp.x,
+        y1: chsp.y,
+        x2: chep.x,
+        y2: chep.y
+      }, {
+        x1: hsp.x,
+        y1: hsp.y,
+        x2: hep.x,
+        y2: hep.y
+      });
+      // two holes(current hole and other hole) are not overlaped, then get distance
+      if (relation.result === _constants.OVERLAP_NONE || relation.result === _constants.OVERLAP_LINK) {
+        if (hole.offset < curHole.offset)
+          // other hole is on the left side
+          distArray.distLeft = Math.min(distArray.distLeft, pointsDistance(chsp.x, chsp.y, hep.x, hep.y));
+          // other hole is on the right side
+        else distArray.distRight = Math.min(distArray.distRight, pointsDistance(chep.x, chep.y, hsp.x, hsp.y));
+      }
+    }
+  });
+  return distArray;
+}
+function getSnappedWallLines(item, layer, catalog) {
+  var _element;
+  var snappedWallLines = [];
+  if ((0, _helper.isEmpty)(item)) return snappedWallLines;
+  var vertexLines = getAllLines(layer);
+  var rectLines = buildRectFromLines(layer, vertexLines);
+  var outline = null;
+  var element = catalog.elements[item.get('type')];
+  if (!element) element = catalog.elements[(0, _utils.returnReplaceableDeepSearchType)(item.get('type'))];
+  var newWidth = item.properties.get('width').get('_length');
+  var wUnit = item.properties.get('width').get('_unit') || 'cm';
+  newWidth = (0, _convertUnitsLite.convert)(newWidth).from(wUnit).to('cm');
+  var newDepth = item.properties.get('depth').get('_length');
+  var hUnit = item.properties.get('depth').get('_unit') || 'cm';
+  newDepth = (0, _convertUnitsLite.convert)(newDepth).from(hUnit).to('cm');
+  var overlapList = [_constants.OVERLAP_INCLUDED, _constants.OVERLAP_SAME, _constants.OVERLAP_SOME];
+
+  // Get Outline Data of Selected Item
+  outline = (_element = element) === null || _element === void 0 || (_element = _element.info) === null || _element === void 0 ? void 0 : _element.outline;
+  if (outline) {
+    // Extract Points from `outline`
+    var outlinePaths = outline.paths;
+    var outlineWidth = outline.svgWidth;
+    var outlineHeight = outline.svgHeight;
+    var outlinePoints = []; // Hold Points Of SVG
+    var _iterator7 = _createForOfIteratorHelper(outlinePaths),
+      _step7;
+    try {
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        var path = _step7.value;
+        var _iterator8 = _createForOfIteratorHelper(path.subPaths),
+          _step8;
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var subPath = _step8.value;
+            outlinePoints = outlinePoints.concat(subPath.getPoints());
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+      }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
+    }
+    outline.reverse && outlinePoints.reverse();
+    for (var i = 0; i < outlinePoints.length - 1; i++) {
+      var v0 = rotatePointAroundPoint((outlinePoints[i].x / outlineWidth - 0.5) * newWidth + item.x, (outlinePoints[i].y / outlineHeight - 0.5) * newDepth + item.y, item.x, item.y, item.rotation + 90);
+      var v1 = rotatePointAroundPoint((outlinePoints[i + 1].x / outlineWidth - 0.5) * newWidth + item.x, (outlinePoints[i + 1].y / outlineHeight - 0.5) * newDepth + item.y, item.x, item.y, item.rotation + 90);
+      var srcLine = {
+        x1: v0.x,
+        y1: v0.y,
+        x2: v1.x,
+        y2: v1.y
+      };
+      var _loop2 = function _loop2(j) {
+        var destLine1 = {
+          x1: rectLines[j].rect[2].x,
+          y1: rectLines[j].rect[2].y,
+          x2: rectLines[j].rect[3].x,
+          y2: rectLines[j].rect[3].y
+        };
+        var destLine2 = {
+          x1: rectLines[j].rect[0].x,
+          y1: rectLines[j].rect[0].y,
+          x2: rectLines[j].rect[1].x,
+          y2: rectLines[j].rect[1].y
+        };
+        if (overlapList.includes(relationshipOfTwoOverlappedLines(srcLine, destLine1).result) || overlapList.includes(relationshipOfTwoOverlappedLines(srcLine, destLine2).result)) {
+          var idx = snappedWallLines.findIndex(function (v) {
+            return v.id === rectLines[j].lineId;
+          });
+          var snapSide = 'unknown';
+          if (idx < 0) snappedWallLines.push({
+            id: rectLines[j].lineId,
+            lineRect: rectLines[j].rect,
+            snapSide: snapSide
+          });else snappedWallLines[idx].snapSide = snapSide;
+        }
+      };
+      for (var j = 0; j < (rectLines === null || rectLines === void 0 ? void 0 : rectLines.length); j++) {
+        _loop2(j);
+      }
+    }
+  } else {
+    var pos = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+    for (var _i = 0; _i < 4; _i++) {
+      var _v = rotatePointAroundPoint(pos[_i][0] * newWidth / 2 + item.x, pos[_i][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation);
+      var _v2 = rotatePointAroundPoint(pos[(_i + 1) % 4][0] * newWidth / 2 + item.x, pos[(_i + 1) % 4][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation);
+      var _srcLine = {
+        x1: _v.x,
+        y1: _v.y,
+        x2: _v2.x,
+        y2: _v2.y
+      };
+      var _loop3 = function _loop3(_j) {
+        var destLine1 = {
+          x1: rectLines[_j].rect[2].x,
+          y1: rectLines[_j].rect[2].y,
+          x2: rectLines[_j].rect[3].x,
+          y2: rectLines[_j].rect[3].y
+        };
+        var destLine2 = {
+          x1: rectLines[_j].rect[0].x,
+          y1: rectLines[_j].rect[0].y,
+          x2: rectLines[_j].rect[1].x,
+          y2: rectLines[_j].rect[1].y
+        };
+        if (overlapList.includes(relationshipOfTwoOverlappedLines(_srcLine, destLine1).result) || overlapList.includes(relationshipOfTwoOverlappedLines(_srcLine, destLine2).result)) {
+          var idx = snappedWallLines.findIndex(function (v) {
+            return v.id === rectLines[_j].lineId;
+          });
+          var snapSide = _i === 0 || _i === 2 ? 'front' : 'side';
+          if (idx < 0) snappedWallLines.push({
+            id: rectLines[_j].lineId,
+            lineRect: rectLines[_j].rect,
+            snapSide: snapSide
+          });else snappedWallLines[idx].snapSide = snapSide;
+        }
+      };
+      for (var _j = 0; _j < (rectLines === null || rectLines === void 0 ? void 0 : rectLines.length); _j++) {
+        _loop3(_j);
+      }
+    }
+  }
+  return snappedWallLines;
+}
+function getLineSnapPointsOfItem(layer, curLine, item) {
+  var _layer$lines2, _layer$vertices4, _line$vertices3, _layer$vertices5, _line$vertices4;
+  //       V0
+  //       /|
+  //    D0 /|-----------|
+  //       /|           |
+  //       /|    Item   |    ====>   get D0, D1
+  //       /|           |
+  //    D1 /|-----------|
+  //       /|
+  // get v0, v1 of line
+  var line = (_layer$lines2 = layer.lines) === null || _layer$lines2 === void 0 ? void 0 : _layer$lines2.get(curLine === null || curLine === void 0 ? void 0 : curLine.id);
+  var v0 = (_layer$vertices4 = layer.vertices) === null || _layer$vertices4 === void 0 ? void 0 : _layer$vertices4.get(line === null || line === void 0 || (_line$vertices3 = line.vertices) === null || _line$vertices3 === void 0 ? void 0 : _line$vertices3.get(0));
+  var v1 = (_layer$vertices5 = layer.vertices) === null || _layer$vertices5 === void 0 ? void 0 : _layer$vertices5.get(line === null || line === void 0 || (_line$vertices4 = line.vertices) === null || _line$vertices4 === void 0 ? void 0 : _line$vertices4.get(1));
+  var pointGroup = [];
+  if ((0, _helper.isEmpty)(v0) || (0, _helper.isEmpty)(v1)) return pointGroup;
+  var itemRect = item === null || item === void 0 ? void 0 : item.rect;
+  if (!(0, _helper.isEmpty)(itemRect)) {
+    for (var i = 0; i < itemRect.length; i++) {
+      if (distancePointFromLineSegment(v0, v1, itemRect[i].x, itemRect[i].y) < _constants.EPSILON) {
+        pointGroup.push(itemRect[i]);
+      }
+    }
+  }
+  return pointGroup;
+}
+function isOverlappedTwoItemsOnOneLine(layer, curLine, srcItem, desItem) {
+  var _layer$lines3, _layer$vertices6, _line$vertices5, _layer$vertices7, _line$vertices6, _S, _S2, _S3, _S4;
+  if ((0, _helper.isEmpty)(layer) || (0, _helper.isEmpty)(curLine) || (0, _helper.isEmpty)(srcItem) || (0, _helper.isEmpty)(desItem) || (0, _helper.isEmpty)(desItem.D0) || (0, _helper.isEmpty)(desItem.D1)) return false;
+  // get v0, v1 of line
+  var line = (_layer$lines3 = layer.lines) === null || _layer$lines3 === void 0 ? void 0 : _layer$lines3.get(curLine === null || curLine === void 0 ? void 0 : curLine.id);
+  var v0 = (_layer$vertices6 = layer.vertices) === null || _layer$vertices6 === void 0 ? void 0 : _layer$vertices6.get(line === null || line === void 0 || (_line$vertices5 = line.vertices) === null || _line$vertices5 === void 0 ? void 0 : _line$vertices5.get(0));
+  var v1 = (_layer$vertices7 = layer.vertices) === null || _layer$vertices7 === void 0 ? void 0 : _layer$vertices7.get(line === null || line === void 0 || (_line$vertices6 = line.vertices) === null || _line$vertices6 === void 0 ? void 0 : _line$vertices6.get(1));
+  var S0,
+    S1,
+    D0 = desItem === null || desItem === void 0 ? void 0 : desItem.D0,
+    D1 = desItem === null || desItem === void 0 ? void 0 : desItem.D1;
+  if ((0, _helper.isEmpty)(v0) || (0, _helper.isEmpty)(v1)) return false;
+  // get distance from v0 to srcItem's S0, S1 and desItem(item or hole)'s D0, D1 are placed on line
+  var srcPoints = getLineSnapPointsOfItem(layer, curLine, srcItem);
+  if (srcPoints.length > 1) {
+    S0 = srcPoints[0];
+    S1 = srcPoints[1];
+  }
+  var disV0S0 = pointsDistance(v0.x, v0.y, (_S = S0) === null || _S === void 0 ? void 0 : _S.x, (_S2 = S0) === null || _S2 === void 0 ? void 0 : _S2.y);
+  var disV0S1 = pointsDistance(v0.x, v0.y, (_S3 = S1) === null || _S3 === void 0 ? void 0 : _S3.x, (_S4 = S1) === null || _S4 === void 0 ? void 0 : _S4.y);
+  var disV0D0 = pointsDistance(v0.x, v0.y, D0.x, D0.y);
+  var disV0D1 = pointsDistance(v0.x, v0.y, D1.x, D1.y);
+  // detect two items are overlapped
+  var maxDisV0S = Math.max(disV0S0, disV0S1);
+  var minDisV0S = Math.min(disV0S0, disV0S1);
+  var maxDisV0D = Math.max(disV0D0, disV0D1);
+  var minDisV0D = Math.min(disV0D0, disV0D1);
+  if (maxDisV0S > maxDisV0D && maxDisV0D - minDisV0S > _constants.EPSILON) {
+    //      d0     s0 d1  s1   ===>  maxDisV0S: v0s1, minDisV0S: v0s0, maxDisV0D: v0d1, minDisV0D: v0d0
+    //  v0 __________________________ v1
+    //      |      |  |   |
+    //      |      |  |   |
+    //      |__DI__|__|   |
+    //             |__SI__|
+    /////////////////////////////////////////
+    //      s0     d0     d1   s1  ===>  maxDisV0S: v0s1, minDisV0S: v0s0, maxDisV0D: v0d1, minDisV0D: v0d0
+    //  v0 __________________________ v1
+    //      |      |      |    |
+    //      |      |__DI__|    |
+    //      |_________SI_______|
+    return true;
+  } else if (minDisV0S < minDisV0D && maxDisV0S - minDisV0D > _constants.EPSILON) {
+    //      s0     d0 s1  d1   ===>  maxDisV0S: v0s1, minDisV0S: v0s0, maxDisV0D: v0d1, minDisV0D: v0d0
+    //  v0 __________________________ v1
+    //      |      |  |   |
+    //      |      |__DI__|
+    //      |__SI_____|
+    //
+    return true;
+  } else {
+    return false;
+  }
+}