kitchen-simulator 5.0.0-test.4 → 5.0.0-test.5

package/src/utils/geometry.js

@@ -1,2572 +0,0 @@
-/** @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}
- */
-import { toFixedFloat, fAbs } from './math.js';
-import {
-  BASE_CABINET_LAYOUTPOS,
-  EPSILON,
-  LINE_THICKNESS,
-  MEPSILON,
-  OVERLAP_INCLUDED,
-  OVERLAP_LINK,
-  OVERLAP_NONE,
-  OVERLAP_SAME,
-  OVERLAP_SOME,
-  WALL_CABINET_LAYOUTPOS,
-  UNIT_ANGLE,
-  MIN_ANGLE_DISALLOW_DRAW_WALL
-} from '../constants';
-import convert from 'convert-units';
-import * as Three from 'three';
-import { returnReplaceableDeepSearchType } from '../components/viewer2d/utils.js';
-import { isEmpty } from './helper.js';
-import { MathUtils } from './export.js';
-
-export function compareVertices(v0, v1) {
-  return v0.x === v1.x ? v0.y - v1.y : v0.x - v1.x;
-}
-
-export function minVertex(v0, v1) {
-  return compareVertices(v0, v1) > 0 ? v1 : v0;
-}
-
-export function maxVertex(v0, v1) {
-  return compareVertices(v0, v1) > 0 ? v0 : v1;
-}
-
-export function orderVertices(vertices) {
-  return vertices.sort(compareVertices);
-}
-
-export function pointsDistance(x0, y0, x1, y1) {
-  let diff_x = x0 - x1;
-  let diff_y = y0 - y1;
-
-  return Math.sqrt(diff_x * diff_x + diff_y * diff_y);
-}
-
-export function verticesDistance(v1, v2) {
-  let { x: x0, y: y0 } = v1;
-  let { x: x1, y: y1 } = v2;
-
-  return pointsDistance(x0, y0, x1, y1);
-}
-
-export function horizontalLine(y) {
-  return { a: 0, b: 1, c: -y };
-}
-
-export const almostEqual = (x, y) => Math.abs(x - y) < EPSILON;
-
-export function verticalLine(x) {
-  return { a: 1, b: 0, c: -x };
-}
-
-export function upcrossLine(x, y) {
-  return { a: 1, b: 1, c: -x - y };
-}
-
-export function downcrossLine(x, y) {
-  return { a: 1, b: -1, c: -x + y };
-}
-
-export 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
-  };
-}
-
-export function getNormaline(x1, y1, x2, y2) {
-  let 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
-      )
-  };
-}
-
-export function distancePointFromLine(a, b, c, x, y) {
-  //https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
-  return fAbs(a * x + b * y + c) / Math.sqrt(a * a + b * b);
-}
-
-export function closestPointFromLine(a, b, c, x, y) {
-  //https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
-  let 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
- */
-export function twoLinesIntersection(a, b, c, j, k, l) {
-  let angularCoefficientsDiff = b * j - a * k;
-
-  if (angularCoefficientsDiff === 0) return undefined; //no intersection
-
-  let y = (a * l - c * j) / angularCoefficientsDiff;
-  let x = (c * k - b * l) / angularCoefficientsDiff;
-  return { x, y };
-}
-
-export function twoLineSegmentsIntersection(p1, p2, p3, p4) {
-  //https://github.com/psalaets/line-intersect/blob/master/lib/check-intersection.js
-
-  let { x: x1, y: y1 } = p1;
-  let { x: x2, y: y2 } = p2;
-  let { x: x3, y: y3 } = p3;
-  let { x: x4, y: y4 } = p4;
-
-  let denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
-  let numA = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
-  let numB = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
-
-  if (fAbs(denom) <= EPSILON) {
-    if (fAbs(numA) <= EPSILON && fAbs(numB) <= EPSILON) {
-      let comparator = (pa, pb) => (pa.x === pb.x ? pa.y - pb.y : pa.x - pb.x);
-      let line0 = [p1, p2].sort(comparator);
-      let line1 = [p3.toJS(), p4.toJS()].sort(comparator);
-
-      let [lineSX, lineDX] = [line0, line1].sort((lineA, lineB) =>
-        comparator(lineA[0], lineB[0])
-      );
-
-      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' };
-  }
-
-  let uA = numA / denom;
-  let uB = numB / denom;
-
-  if (
-    uA >= 0 - EPSILON &&
-    uA <= 1 + EPSILON &&
-    uB >= 0 - EPSILON &&
-    uB <= 1 + EPSILON
-  ) {
-    let point = {
-      x: x1 + uA * (x2 - x1),
-      y: y1 + uA * (y2 - y1)
-    };
-    return { type: 'intersecting', point };
-  }
-
-  return { type: 'none' };
-}
-
-export function distancePointFromLineSegment(v1, v2, xp, yp) {
-  //http://stackoverflow.com/a/6853926/1398836
-  let { x: x1, y: y1 } = v1;
-  let { x: x2, y: y2 } = v2;
-
-  let A = xp - x1;
-  let B = yp - y1;
-  let C = x2 - x1;
-  let D = y2 - y1;
-
-  let dot = A * C + B * D;
-  let len_sq = C * C + D * D;
-  let param = -1;
-  if (len_sq != 0)
-    //in case of 0 length line
-    param = dot / len_sq;
-
-  let 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;
-  }
-
-  let dx = xp - xx;
-  let 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
- */
-export function isPointOnLineSegment(
-  x1,
-  y1,
-  x2,
-  y2,
-  xp,
-  yp,
-  maxDistance = EPSILON
-) {
-  return (
-    distancePointFromLineSegment({ x: x1, y: y1 }, { x: x2, y: y2 }, xp, yp) <=
-    maxDistance
-  );
-}
-
-export function closestPointFromLineSegment(x1, y1, x2, y2, xp, yp) {
-  if (x1 === x2) return { x: x1, y: yp };
-  if (y1 === y2) return { x: xp, y: y1 };
-
-  let m = (y2 - y1) / (x2 - x1);
-  let q = y1 - m * x1;
-
-  let mi = -1 / m;
-  let qi = yp - mi * xp;
-
-  let x = (qi - q) / (m - mi);
-  let y = m * x + q;
-
-  return { x, y };
-}
-
-export function pointPositionOnLineSegment(x1, y1, x2, y2, xp, yp) {
-  let length = pointsDistance(x1, y1, x2, y2);
-  let distance = pointsDistance(x1, y1, xp, yp);
-
-  let offset = distance / length;
-  /*
-  if (x1 > x2) offset = 1 - offset;
-  if (y1 > y2) offset = 1 - offset;
-  */
-  return offset;
-}
-
-export function mapRange(value, low1, high1, low2, high2) {
-  return low2 + ((high2 - low2) * (value - low1)) / (high1 - low1);
-}
-
-export function angleBetweenTwoPointsAndOrigin(x1, y1, x2, y2) {
-  return (-Math.atan2(y1 - y2, x2 - x1) * 180) / Math.PI;
-}
-
-export function angleBetweenTwoPoints(x1, y1, x2, y2) {
-  return Math.atan2(y2 - y1, x2 - x1);
-}
-
-export function angleBetweenTwoLines(line, drawingLine, vertices) {
-  const points = [];
-
-  // safety guards
-  const lv = Array.isArray(line?.vertices) ? line.vertices : [];
-  const dv = Array.isArray(drawingLine?.vertices) ? drawingLine.vertices : [];
-
-  // 1) push common vertices (in order of line.vertices)
-  for (const vt of lv) {
-    if (dv.includes(vt) && !points.includes(vt)) points.push(vt);
-  }
-
-  // 2) push remaining vertices from line.vertices
-  for (const vt of lv) {
-    if (!points.includes(vt)) points.push(vt);
-  }
-
-  // 3) push remaining vertices from drawingLine.vertices
-  for (const vt of dv) {
-    if (!points.includes(vt)) points.push(vt);
-  }
-
-  // If no points at all, nothing to compute — return 0 (safe fallback)
-  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]);
-
-  const [c, p1, p2] = points.slice(0, 3).map(idx => {
-    const v = vertices?.[idx];
-    return v ? new Three.Vector2(v.x, v.y) : new Three.Vector2(0, 0);
-  });
-
-  const vec1 = p1.clone().sub(c).normalize();
-  const vec2 = p2.clone().sub(c).normalize();
-
-  return Math.floor(
-    (vec1.angle() * 180) / Math.PI - (vec2.angle() * 180) / Math.PI + 0.5
-  );
-}
-
-export const getRelatedLines = (
-  tlines,
-  drawingLine,
-  vertices,
-  lines,
-  exceptLineId = null
-) => {
-  if (!drawingLine?.vertices || !Array.isArray(drawingLine.vertices)) return;
-
-  const seen = new Set();
-
-  for (const vIdx of drawingLine.vertices) {
-    const vertex = vertices?.[vIdx];
-    if (!vertex?.lines) continue;
-
-    for (const lineId of vertex.lines) {
-      if (
-        lineId !== drawingLine.id &&
-        lineId !== exceptLineId &&
-        !isEmpty(lines?.[lineId]) &&
-        !seen.has(lineId)
-      ) {
-        seen.add(lineId);
-        tlines.push(lines[lineId]);
-      }
-    }
-  }
-};
-
-export function snapAngleByUnit(
-  lineAngle,
-  vertices,
-  drawingLine,
-  x,
-  y,
-  dragVertexId
-) {
-  let tx, ty;
-  let absAngle = Math.abs(lineAngle);
-  // angle snapping as a value of UNIT_ANGLE
-  let rest = absAngle % UNIT_ANGLE;
-  let missAngle = UNIT_ANGLE - rest;
-  // the origin point of rotation(snapping)
-  let originVerId = drawingLine.vertices.findIndex(
-    vertice => vertice !== dragVertexId
-  );
-  originVerId =
-    originVerId < 0
-      ? drawingLine.vertices[0]
-      : drawingLine.vertices[originVerId];
-
-  let ox = vertices[originVerId].x;
-  let oy = vertices[originVerId].y;
-  // check whether the line is snapped to before point.
-  if (rest <= UNIT_ANGLE / 2) {
-    // determine the direction of rotation.
-    rest = lineAngle > 0 ? 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 > UNIT_ANGLE / 2) {
-    // determine the direction of rotation.
-    missAngle = lineAngle > 0 ? -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;
-  }
-  let resPoint = {
-    x: tx,
-    y: ty
-  };
-  return resPoint;
-}
-
-export function absAngleBetweenTwoPoints(x1, y1, x2, y2) {
-  return Math.atan2(y2 - y1, Math.abs(x2 - x1));
-}
-
-export function samePoints({ x: x1, y: y1 }, { x: x2, y: y2 }) {
-  return fAbs(x1 - x2) <= EPSILON && fAbs(y1 - y2) <= EPSILON;
-}
-
-export function sameDistances(dis1, dis2) {
-  return fAbs(dis1 - dis2) <= EPSILON;
-}
-
-export function sameMPoints({ x: x1, y: y1 }, { x: x2, y: y2 }) {
-  return fAbs(x1 - x2) <= MEPSILON && fAbs(y1 - y2) <= MEPSILON;
-}
-
-export function sameMDistances(dis1, dis2) {
-  return fAbs(dis1 - dis2) <= MEPSILON;
-}
-
-export function isPointInRect(rect, point) {
-  let result = true;
-  for (let i = 0; i < rect.length; i++) {
-    let pos1 = rect[i];
-    let 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}
- */
-export function extendLine(x1, y1, x2, y2, newDistance, precision = 6) {
-  let rad = angleBetweenTwoPoints(x1, y1, x2, y2);
-
-  return {
-    x: toFixedFloat(x1 + Math.cos(rad) * newDistance, precision),
-    y: toFixedFloat(y1 + Math.sin(rad) * newDistance, precision)
-  };
-}
-
-export function roundVertex(vertex, precision = 6) {
-  vertex.set('x', toFixedFloat(vertex.get('x'), precision));
-  vertex.set('y', toFixedFloat(vertex.get('y'), precision));
-
-  return vertex;
-}
-
-//https://github.com/MartyWallace/PolyK
-export function ContainsPoint(polygon, pointX, pointY) {
-  let n = polygon.length >> 1;
-  let ax, lup;
-  let ay = polygon[2 * n - 3] - pointY;
-  let bx = polygon[2 * n - 2] - pointX;
-  let by = polygon[2 * n - 1] - pointY;
-
-  if (bx === 0 && by === 0) return false; // point on edge
-
-  // let lup = by > ay;
-  for (let 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;
-  }
-
-  let depth = 0;
-  for (let 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;
-
-    let 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;
-}
-
-export function cosWithThreshold(alpha, threshold) {
-  let cos = Math.cos(alpha);
-  return cos < threshold ? 0 : cos;
-}
-
-export function sinWithThreshold(alpha, threshold) {
-  let sin = Math.sin(alpha);
-  return sin < threshold ? 0 : sin;
-}
-
-export function midPoint(x1, y1, x2, y2) {
-  return { x: (x1 + x2) / 2, y: (y1 + y2) / 2 };
-}
-
-export function verticesMidPoint(verticesArray) {
-  let res = verticesArray.reduce(
-    (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 };
-}
-
-export function rotatePointAroundPoint(px, py, ox, oy, theta) {
-  let thetaRad = (theta * Math.PI) / 180;
-
-  let cos = Math.cos(thetaRad);
-  let sin = Math.sin(thetaRad);
-
-  let deltaX = px - ox;
-  let 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, y };
-}
-
-function itemrectInfo(x, y, rotRad, size, layoutpos, is_corner) {
-  return { pos: { x, y }, rotRad, size, layoutpos, is_corner };
-}
-
-export function getCalcRectFromItem(item) {
-  let itemInfo;
-  if (item === undefined) itemInfo = [];
-  else itemInfo = item.item;
-  let x = item.pos.x;
-  let y = item.pos.y;
-  let rotRad = item.rotRad;
-  let w = item.size && item.size.width / 2;
-  let h = item.size && item.size.height / 2;
-  let mx = x - w * Math.cos(rotRad);
-  let my = y - w * Math.sin(rotRad);
-  let x0 = mx + h * Math.sin(rotRad);
-  let y0 = my - h * Math.cos(rotRad);
-  let x3 = mx * 2 - x0;
-  let y3 = my * 2 - y0;
-  let x1 = x * 2 - x3;
-  let y1 = y * 2 - y3;
-  let x2 = x * 2 - x0;
-  let y2 = y * 2 - y0;
-
-  return {
-    rect: [point(x0, y0), point(x1, y1), point(x2, y2), point(x3, y3)],
-    pos: point(x, y),
-    rotRad,
-    size: item.size,
-    layoutpos: item.layoutpos,
-    is_corner: item.is_corner,
-    itemInfo: itemInfo
-  };
-}
-
-export function getCalcRectFromItem3D(item) {
-  let itemInfo;
-  if (item === undefined) itemInfo = [];
-  else itemInfo = item.item;
-  let x = item.pos.x;
-  let y = item.pos.y;
-  let rotRad = item.rotRad;
-  let w = item.size.width / 2;
-  let h = item.size.depth / 2;
-  let mx = x - w * Math.cos(rotRad);
-  let my = y - w * Math.sin(rotRad);
-  let x0 = mx + h * Math.sin(rotRad);
-  let y0 = my - h * Math.cos(rotRad);
-  let x3 = mx * 2 - x0;
-  let y3 = my * 2 - y0;
-  let x1 = x * 2 - x3;
-  let y1 = y * 2 - y3;
-  let x2 = x * 2 - x0;
-  let y2 = y * 2 - y0;
-
-  return {
-    rect: [point(x0, y0), point(x1, y1), point(x2, y2), point(x3, y3)],
-    pos: point(x, y),
-    rotRad,
-    size: item.size,
-    layoutpos: item.layoutpos,
-    is_corner: item.is_corner,
-    itemInfo: itemInfo
-  };
-}
-
-export function getAllItems(scene, catalog, allLineRects) {
-  let layerID = scene.selectedLayer;
-  let layer = scene.layers.get(layerID);
-
-  let curiteminfo;
-  let iteminfo = [];
-  let otherItems = [];
-
-  let selectedItem;
-  let currentItem;
-
-  if (layer.selected.items.size > 0) {
-    selectedItem = layer.getIn(['items', layer.selected.items.get(0)]);
-    let catid = selectedItem.type;
-    let cat = catalog.elements[catid];
-    if (!cat) cat = catalog.elements[returnReplaceableDeepSearchType(catid)];
-    currentItem = {
-      selectedItem,
-      cat
-    };
-  }
-
-  layer.items.forEach(item => {
-    let val = {
-      pos: { x: item.x, y: item.y },
-      rotRad: (item.rotation / 180) * Math.PI
-    };
-    let catid = item.type;
-    let cat = catalog.elements[catid];
-
-    if (!cat) {
-      cat = catalog.elements[returnReplaceableDeepSearchType(catid)];
-    }
-
-    let sizeinfo = [];
-    let 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 = {
-      ...sizeinfo,
-      layoutpos: cat && cat.info.layoutpos,
-      is_corner: cat && cat.info.is_corner
-    };
-
-    width = convert(sizeinfo.width).from(sizeinfo.widthUnit).to(scene.unit);
-    height = convert(sizeinfo.depth).from(sizeinfo.depthUnit).to(scene.unit);
-    depth = convert(sizeinfo.height).from(sizeinfo.heightUnit).to(scene.unit);
-
-    val.size = { width, height, depth };
-    val.layoutpos = sizeinfo.layoutpos;
-    val.is_corner = sizeinfo.is_corner;
-    val.doorStyle = item.doorStyle;
-    val.item = item;
-
-    let otherItem = {
-      item,
-      cat
-    };
-
-    if (!needSnap(currentItem, otherItem)) {
-      return;
-    }
-
-    if (item.selected) {
-      curiteminfo = getCalcRectFromItem(val);
-    } else {
-      let calcrect = getCalcRectFromItem(val);
-      calcrect.isSnappedLine = isSnappedLine(calcrect, allLineRects);
-      iteminfo.push(calcrect);
-      otherItems.push(otherItem);
-    }
-  });
-  return { cur: curiteminfo, others: iteminfo, currentItem, otherItems };
-}
-
-export function getAllItemSpecified(scene, catalog, filter) {
-  const layerID = scene?.selectedLayer;
-  const layer = scene?.layers?.get?.(layerID);
-  if (!layer || !layer.items) return { cur: null, others: [] };
-
-  let curiteminfo;
-  const iteminfo = [];
-
-  layer.items.forEach(item => {
-    if (!item) return;
-
-    const val = {
-      pos: { x: item.x, y: item.y },
-      rotRad: (item.rotation / 180) * Math.PI
-    };
-
-    const cat = item.type ? findCatalogElement(catalog, item.type) : null;
-    const info = cat?.info;
-
-    const props = item.properties;
-    const getSize = key => {
-      const length = props?.getIn?.([key, '_length']);
-      return length != null ? convert(length).from('in').to(scene.unit) : 0;
-    };
-
-    val.size = {
-      width: getSize('width'),
-      height: getSize('height'),
-      depth: getSize('depth')
-    };
-
-    val.item = item;
-
-    if (info) {
-      val.layoutpos = info.layoutpos;
-      val.is_corner = info.is_corner;
-    }
-
-    // Filter check
-    if (Array.isArray(filter)) {
-      if (info && !filter.includes(info.layoutpos)) return;
-    } else if (
-      info &&
-      (info.layoutpos !== filter ||
-        (cat?.type === 'appliance' &&
-          ['Cook Top', 'Microwave'].includes(cat?.obj?.category)))
-    ) {
-      return;
-    }
-
-    // Current vs others
-    const rect = getCalcRectFromItem3D(val);
-    if (item.selected) {
-      curiteminfo = rect;
-    } else {
-      iteminfo.push(rect);
-    }
-  });
-
-  return { cur: curiteminfo, others: iteminfo };
-}
-
-export function findCatalogElement(catalog, elementName) {
-  if (!elementName || !catalog) return null;
-
-  const variants = [elementName, elementName.toLowerCase()];
-  const deepVariants = variants
-    .map(v => returnReplaceableDeepSearchType(v))
-    .filter(Boolean);
-
-  const allCandidates = [...variants, ...deepVariants];
-
-  const 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;
-  };
-
-  for (const name of allCandidates) {
-    const cat = getElement(name);
-    if (cat) return cat;
-  }
-
-  return null;
-}
-
-export function isSnappedLine(calcrect, allLineRects) {
-  if (allLineRects === undefined) return false;
-
-  let r2 = calcrect.rect[2];
-  let r3 = calcrect.rect[3];
-  let result = allLineRects.some(linerect => {
-    let l2 = linerect.rect[2];
-    let l3 = linerect.rect[3];
-    let delta =
-      verticesDistance(l2, r3) +
-      verticesDistance(r3, r2) +
-      verticesDistance(r2, l3) -
-      verticesDistance(l3, l2);
-    if (delta < 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 < EPSILON;
-    }
-  });
-  return result;
-}
-
-export function isSnappedSideLine(calcrect, allLineRects) {
-  if (allLineRects === undefined) return 0;
-  let r2 = calcrect.rect[1];
-  let r3 = calcrect.rect[2];
-  let result = allLineRects.some(linerect => {
-    let l2 = linerect.rect[2];
-    let l3 = linerect.rect[3];
-    let delta =
-      verticesDistance(l2, r3) +
-      verticesDistance(r3, r2) +
-      verticesDistance(r2, l3) -
-      verticesDistance(l3, l2);
-    return delta < EPSILON;
-  });
-  return result;
-}
-
-/** Calculate candidate positions */
-export function getAllItemSnap(allItemRects) {
-  let allItemSnap = [];
-
-  let cur = allItemRects.cur;
-
-  // For development
-  let { otherItems, currentItem } = allItemRects;
-
-  allItemRects.others.forEach((rect, index) => {
-    let cw = cur && cur.size.width / 2;
-    let ch = cur && cur.size.height / 2;
-    let cos = Math.cos(rect.rotRad);
-    let sin = Math.sin(rect.rotRad);
-    let ox0 = cw * cos - ch * sin; // (cw, ch) rot
-    let oy0 = cw * sin + ch * cos;
-    let ox1 = -cw * cos - ch * sin; // (-cw, ch) rot
-    let oy1 = -cw * sin + ch * cos;
-    let ox2 = ch * sin - cw * cos;
-    let oy2 = -ch * cos - cw * sin;
-    let ox3 = ch * sin + cw * cos;
-    let oy3 = -ch * cos + cw * sin;
-    let nrot = rect.rotRad + Math.PI;
-    if (nrot >= Math.PI) nrot -= Math.PI * 2;
-    let snap1 = itemrectInfo(
-      rect.rect[2].x + ox3,
-      rect.rect[2].y + oy3,
-      rect.rotRad,
-      cur && cur.size,
-      rect.layoutpos,
-      rect.is_corner
-    );
-    let snap2 = itemrectInfo(
-      rect.rect[3].x + ox2,
-      rect.rect[3].y + oy2,
-      rect.rotRad,
-      cur && cur.size,
-      rect.layoutpos,
-      rect.is_corner
-    );
-    let snap3 = itemrectInfo(
-      rect.rect[2].x + ox1,
-      rect.rect[2].y + oy1,
-      nrot,
-      cur && cur.size,
-      rect.layoutpos,
-      rect.is_corner
-    );
-    let snap4 = itemrectInfo(
-      rect.rect[3].x + ox0,
-      rect.rect[3].y + oy0,
-      nrot,
-      cur && cur.size,
-      rect.layoutpos,
-      rect.is_corner
-    );
-
-    const sizeinfo =
-      otherItems[index].cat && otherItems[index].cat.info.sizeinfo;
-    if (sizeinfo) {
-      const { leftBlindLength, rightBlindLength } = sizeinfo;
-
-      if (leftBlindLength > 0) {
-        let vx = leftBlindLength - ch;
-        let vy = cw;
-        let dx = vx * cos + vy * sin;
-        let dy = vx * sin - vy * cos;
-        let 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) {
-        let vx = ch - rightBlindLength;
-        let vy = cw;
-        let dx = vx * cos + vy * sin;
-        let dy = vx * sin - vy * cos;
-        let 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) {
-      let nrot = rect.rotRad + (Math.PI * 3) / 2;
-      if (nrot >= Math.PI) nrot -= Math.PI * 2;
-      let 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;
-}
-
-export function getAllArea(layer) {
-  let allAreaLines = [];
-  let allLines = [];
-  let verticesArray = [];
-  let vertexID_to_verticesArrayIndex = {};
-
-  layer.vertices.forEach(vertex => {
-    let verticesCount = verticesArray.push([vertex.x, vertex.y]);
-    let latestVertexIndex = verticesCount - 1;
-    vertexID_to_verticesArrayIndex[vertex.id] = latestVertexIndex;
-  });
-
-  layer.areas.forEach(area => {
-    allAreaLines.push(area.vertices);
-  });
-
-  allAreaLines.forEach(area => {
-    let pt = [];
-    area.forEach(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 */
-export function getAllLines(layer) {
-  let allAreaLines = getAllAreaLines(layer);
-
-  let allLines = [];
-  //let allNonAreaLines = [];
-  let thick = LINE_THICKNESS / 2;
-  layer.lines.forEach(line => {
-    let i = containLine(allAreaLines, line);
-    // let thick = line.properties.getIn(['thickness', 'length']);
-    if (i < 0) {
-      let vertices = line.vertices.toJS();
-      let 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;
-      let addIdx = allLines.length;
-      let flag = 0;
-      allLines.forEach((element, idx) => {
-        if (flag == 0) {
-          let el = element[0];
-          let 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) {
-            let 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
-          ) {
-            let tmp = vertices[0];
-            vertices[0] = vertices[1];
-            vertices[1] = tmp;
-            addIdx = idx;
-            flag = 1;
-          }
-        }
-      });
-      allLines.splice(addIdx, 0, [vertices, thick]);
-    } else {
-      allLines.push([allAreaLines[i], thick]);
-    }
-  });
-
-  return allLines;
-}
-
-/** Get lines that wraps the area */
-export function getAllAreaLines(layer) {
-  let areainfo = [];
-  layer.areas.forEach(area => {
-    let 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;
-}
-
-export function containLine(lines, line) {
-  // lines: [array]
-  let sz = lines.length;
-  for (var i = 0; i < sz; i++) {
-    let 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;
-}
-
-export function buildRectFromLines(layer, lines) {
-  let rect = [];
-
-  lines.forEach(line => {
-    let vxys = []; // 0: x0, 1: y0, 2: x1, 3: y1
-    line[0].forEach(vertex => {
-      let vert = layer.vertices.get(vertex);
-      vxys.push(vert.x);
-      vxys.push(vert.y);
-    });
-    let thick = line[1];
-    let x0 = vxys[0];
-    let y0 = vxys[1];
-    let x1 = vxys[2];
-    let y1 = vxys[3];
-    rect.push(getCalcRectFromLine(x0, y0, x1, y1, thick, layer));
-  });
-  return rect;
-}
-
-export function getRelatedVertices(x0, y0, x1, y1, layer) {
-  let verticesArray = [];
-  let mapVertIDtoIndex = {};
-
-  layer.vertices.forEach(vertex => {
-    let verticesCount = verticesArray.push([vertex.x, vertex.y]);
-    let latestVertexIndex = verticesCount - 1;
-    mapVertIDtoIndex[vertex.id] = latestVertexIndex;
-  });
-
-  let relVerts = [];
-  layer.lines.some(line => {
-    let vertID0 = line.vertices.get(0);
-    let vertID1 = line.vertices.get(1);
-
-    let pt0 = {
-      x: verticesArray[mapVertIDtoIndex[vertID0]][0],
-      y: verticesArray[mapVertIDtoIndex[vertID0]][1]
-    };
-    let pt1 = {
-      x: verticesArray[mapVertIDtoIndex[vertID1]][0],
-      y: verticesArray[mapVertIDtoIndex[vertID1]][1]
-    };
-
-    if (
-      (Math.abs(pt0.x - x0) < EPSILON &&
-        Math.abs(pt0.y - y0) < EPSILON &&
-        Math.abs(pt1.x - x1) < EPSILON &&
-        Math.abs(pt1.y - y1) < EPSILON) ||
-      (Math.abs(pt0.x - x1) < EPSILON &&
-        Math.abs(pt0.y - y1) < EPSILON &&
-        Math.abs(pt1.x - x0) < EPSILON &&
-        Math.abs(pt1.y - y0) < EPSILON)
-    ) {
-      if (line.relatedVertices.size == 2) {
-        let relPt0 = point(x0, y0);
-        let relPt1 = point(x1, y1);
-
-        line.relatedVertices.forEach((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;
-}
-
-export function getCalcRectFromLine(x0, y0, x1, y1, thick, layer) {
-  // get line from vertex coordinate
-  let relVerts = getRelatedVertices(x0, y0, x1, y1, layer);
-
-  let dx = x1 - x0;
-  let dy = y1 - y0;
-  let dl = Math.sqrt(dx * dx + dy * dy);
-  let ox = (-dy / dl) * thick;
-  let oy = (dx / dl) * thick;
-  let rot = Math.atan2(dy, dx);
-  if (relVerts.length == 2) {
-    let vN = point(ox, oy);
-    let vR = point(relVerts[0].x - x0, relVerts[0].y - y0);
-    if (dotprod(vN, vR) < 0) {
-      ox = -ox;
-      oy = -oy;
-    } else {
-      rot += Math.PI;
-    }
-  } else {
-    let pt0 = point(x0 + ox, y0 + oy);
-    let pt1 = point(x1 + ox, y1 + oy);
-    let ptC = point((pt0.x + pt1.x) / 2, (pt0.y + pt1.y) / 2);
-
-    let allArea = getAllArea(layer);
-    if (isPointInArea(allArea, ptC)) {
-      // try make rect under line
-      let _pt0 = point(x0 - ox, y0 - oy);
-      let _pt1 = point(x1 - ox, y1 - oy);
-      let _ptC = point((_pt0.x + _pt1.x) / 2, (_pt0.y + _pt1.y) / 2);
-
-      if (!isPointInArea(allArea, _ptC)) {
-        // only under rect is not included in area, make rect under line
-        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 }
-  };
-}
-
-export function getAllLineSnap(allLineRects, curItemRect) {
-  let allLineSnap = [];
-  let cur = curItemRect;
-  if (cur === undefined || cur === null) return;
-  else
-    allLineRects.forEach(rect => {
-      let cw = cur.size.width / 2;
-      let ch = cur.size.height / 2;
-      let cos = Math.cos(rect.rotRad);
-      let sin = Math.sin(rect.rotRad);
-      let ox0 = cw * cos - ch * sin; // (cw, ch) rot
-      let oy0 = cw * sin + ch * cos;
-      let ox1 = -cw * cos - ch * sin; // (-cw, ch) rot
-      let oy1 = -cw * sin + ch * cos;
-      let nrot = rect.rotRad + Math.PI;
-      if (nrot >= Math.PI) nrot -= Math.PI * 2;
-      let thick = rect.size.height;
-
-      let snap3 = itemInfo(
-        rect.rect[2].x + ox1,
-        rect.rect[2].y + oy1,
-        nrot,
-        cur.size
-      );
-      let 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;
-}
-
-export function validateSnaps(allSnaps, allRects) {
-  let validSnaps = [];
-  if (allSnaps !== undefined && allSnaps !== null && allSnaps.length > 0)
-    allSnaps.forEach(snap => {
-      if (validSnap(snap, allRects)) {
-        validSnaps.push(snap);
-      }
-    });
-  return validSnaps;
-}
-
-export function validateLineSnaps(
-  allSnaps,
-  allItemSnap,
-  allLineSnap,
-  allItemRects,
-  allLineRects,
-  allRects
-) {
-  let validSnaps = [];
-  allSnaps.forEach(snap => {
-    if (validSnap(snap, allRects)) {
-      validSnaps.push(snap);
-    } else {
-      allItemSnap.forEach(snap => {
-        validSnaps.push(snap);
-      });
-      allLineSnap.forEach(snap => {
-        validSnaps.push(snap);
-      });
-    }
-  });
-  return validSnaps;
-}
-
-export function validSnap(snap, rects) {
-  let snaprect = getCalcRectFromItem(snap);
-  return rects.every(rect => {
-    return !intersectRect(rect.rect, snaprect.rect);
-  });
-}
-
-export function itemInfo(x, y, rotRad, size) {
-  return { pos: { x, y }, rotRad, size };
-}
-
-export function intersectRect(rect1, rect2) {
-  let ret = false;
-  rect1 = shrinkRect(rect1);
-  rect2 = shrinkRect(rect2);
-
-  ret = ret || getInterSect(rect1, rect2);
-
-  ret =
-    ret ||
-    rect1.some(pt => {
-      return containPointInRect(pt, rect2);
-    });
-  ret =
-    ret ||
-    rect2.some(pt => {
-      return containPointInRect(pt, rect1);
-    });
-  return ret;
-}
-
-export function containPointInRect(point, rect) {
-  // true: contain, false: not contain
-  for (let i = 0; i < rect.length; i++) {
-    let ni = (i + 1) % rect.length;
-    if (crossprod(diff(point, rect[i]), diff(rect[i], rect[ni])) < 0) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function diff(v0, v1) {
-  return { x: v0.x - v1.x, y: v0.y - v1.y };
-}
-
-export function crossprod(v0, v1) {
-  return v0.x * v1.y - v0.y * v1.x;
-}
-
-export function shrinkRect(rect) {
-  let v02x = rect[2].x - rect[0].x;
-  let v02y = rect[2].y - rect[0].y;
-  let d02 = Math.sqrt(v02x * v02x + v02y * v02y);
-  let o02x = (v02x / d02) * 0.1;
-  let o02y = (v02y / d02) * 0.1;
-
-  let v13x = rect[3].x - rect[1].x;
-  let v13y = rect[3].y - rect[1].y;
-  let d13 = Math.sqrt(v02x * v02x + v02y * v02y);
-  let o13x = (v13x / d13) * 0.1;
-  let 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)
-  ];
-}
-
-export function getInterSect(shape1, shape2) {
-  // return result of intersect of two shape
-  let count = 0;
-  for (let i = 0; i < shape1.length; i++) {
-    let sl1 = { x: shape1[i].x, y: shape1[i].y };
-    let sl2 = {
-      x: shape1[(i + 1) % shape1.length].x,
-      y: shape1[(i + 1) % shape1.length].y
-    };
-    for (let j = 0; j < shape2.length; j++) {
-      let el1 = { x: shape2[j].x, y: shape2[j].y };
-      let el2 = {
-        x: shape2[(j + 1) % shape2.length].x,
-        y: shape2[(j + 1) % shape2.length].y
-      };
-      let 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;
-}
-
-export function getLineInterSect(s1x, s1y, e1x, e1y, s2x, s2y, e2x, e2y) {
-  let ax = s1x;
-  let ay = s1y;
-  let bx = e1x - s1x;
-  let by = e1y - s1y;
-  let cx = s2x;
-  let cy = s2y;
-  let dx = e2x - s2x;
-  let dy = e2y - s2y;
-
-  if (Math.abs(bx * dy - by * dx) < 0.00000001) {
-    if (Math.abs((cx - ax) * by - (cy - ay) * bx) < 0.00000001) {
-      let maxX = ax;
-      let minX = ax;
-      let maxY = ay;
-      let 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;
-      let len = Math.sqrt(
-        (maxX - minX) * (maxX - minX) + (maxY - minY) * (maxY - minY)
-      );
-      let len1 = Math.sqrt(bx * bx + by * by);
-      let len2 = Math.sqrt(dx * dx + dy * dy);
-      if (len < len1 + len2) {
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      return false;
-    }
-  } else {
-    let t = (dx * (ay - cy) + dy * (cx - ax)) / (bx * dy - by * dx);
-    let u = (bx * (cy - ay) + by * (ax - cx)) / (dx * by - dy * bx);
-    let ret = u < 1 && u > 0 && t > 0 && t < 1;
-    return ret;
-  }
-}
-
-export function isPointInArea(allArea, pt) {
-  let x = pt.x;
-  let y = pt.y;
-
-  let result = false;
-  result = allArea.some(area => {
-    let sum = 0,
-      alpha = 0;
-    for (let i = 0; i < area.length; i++) {
-      let x0 = area[i].x;
-      let y0 = area[i].y;
-      let x1 = area[(i + 1) % area.length].x;
-      let y1 = area[(i + 1) % area.length].y;
-
-      let v0 = { x: x0 - x, y: y0 - y };
-      let v1 = { x: x1 - x, y: y1 - y };
-
-      if (Math.abs(v0.x) < EPSILON && Math.abs(v0.y) < EPSILON)
-        // check if pt is area point
-        return true;
-
-      // check if pt is in area line
-      let lineLen = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
-      let v0Len = Math.sqrt(v0.x * v0.x + v0.y * v0.y);
-      let vPt = { x: -v0.x / v0Len, y: -v0.y / v0Len };
-      let xE = x0 + vPt.x * lineLen;
-      let yE = y0 + vPt.y * lineLen;
-
-      if (
-        v0Len <= lineLen &&
-        Math.abs(xE - x1) < EPSILON &&
-        Math.abs(yE - y1) < 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) < EPSILON) return true;
-  });
-
-  return result;
-}
-
-export function calcSnap(
-  allItemRect,
-  allItemSnap,
-  allLineRects,
-  allLineSnap,
-  allRect,
-  x,
-  y,
-  allAreaLines
-) {
-  return calcSnap2(
-    allItemRect,
-    allItemSnap,
-    allLineRects,
-    allLineSnap,
-    allRect,
-    x,
-    y,
-    allAreaLines
-  );
-}
-
-export function calcCreateSnap(
-  allItemRect,
-  allItemSnap,
-  allLineRects,
-  allLineSnap,
-  allRect,
-  x,
-  y,
-  polygonPoint
-) {
-  // Validate required input and guard against missing `.cur`
-  if (!allItemRect || !allItemRect.cur) return;
-
-  const cur = allItemRect.cur; // safe alias
-  let cx = x;
-  let cy = y;
-  let ndist = 5000;
-  let rotRad = cur.rotRad;
-
-  // Get candidate snaps and validate them as before
-  let allCurSnap = getAllCurSnap(allLineRects, x, y, cur);
-  allCurSnap = validateLineSnaps(
-    allCurSnap,
-    allItemSnap,
-    allLineSnap,
-    allItemRect,
-    allLineRects,
-    allRect
-  );
-
-  let getSnap = false;
-  const snapdist = [];
-
-  // Build distances for snaps that lie inside polygonPoint (if any)
-  if (Array.isArray(allCurSnap)) {
-    allCurSnap.forEach(snap => {
-      if (!snap || !snap.pos) return;
-      const inside = ContainsPoint(polygonPoint, snap.pos.x, snap.pos.y);
-      if (inside) {
-        const dx = snap.pos.x - x;
-        const dy = snap.pos.y - y;
-        snapdist.push(dx * dx + dy * dy);
-      }
-    });
-  }
-
-  // Find minimum distance (Infinity if none)
-  const edist = snapdist.length ? Math.min(...snapdist) : Infinity;
-
-  // Choose the snap with distance === edist
-  if (Array.isArray(allCurSnap)) {
-    allCurSnap.forEach(snap => {
-      if (!snap || !snap.pos) return;
-      const dx = snap.pos.x - x;
-      const dy = snap.pos.y - y;
-      const dist = dx * dx + dy * dy;
-      if (dist === edist) {
-        ndist = dist;
-        cx = snap.pos.x;
-        cy = snap.pos.y;
-        rotRad = snap.rotRad ?? rotRad; // nullish coalescing
-        getSnap = true;
-      }
-    });
-  }
-
-  const crot = (rotRad / Math.PI) * 180;
-  return { cx, cy, crot, rotRad };
-}
-
-////////////
-export function calcSnap1(
-  allItemRect,
-  allItemSnap,
-  allLineRects,
-  allLineSnap,
-  allRect,
-  x,
-  y
-) {
-  let cx = allItemRect.cur.pos.x;
-  let cy = allItemRect.cur.pos.y;
-  let nx = x;
-  let ny = y;
-  let cursize = allItemRect.cur.size;
-  let ndist = cursize.width * cursize.width + cursize.height * cursize.height;
-  ndist = ndist / 4;
-  let rotRad = allItemRect.cur.rotRad;
-
-  let allCurSnap = getAllCurSnap(allLineRects, x, y, allItemRect.cur);
-  allCurSnap = validateSnaps(allCurSnap, allRect);
-
-  let getSnap = false;
-  allCurSnap.forEach(snap => {
-    let 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(snap => {
-      let 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;
-      }
-    });
-  }
-
-  let rot = (rotRad / Math.PI) * 180;
-  let ret = { nx, ny, rot, rotRad };
-  return ret;
-}
-
-////////////
-export function calcSnap2(
-  allItemRect,
-  allItemSnap,
-  allLineRects,
-  allLineSnap,
-  allRect,
-  x,
-  y,
-  allArea
-) {
-  let nx = x;
-  let ny = y;
-  let ndist = 20;
-  let rotRad = allItemRect.cur && allItemRect.cur.rotRad;
-  let 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;
-  let curitem = getCalcRectFromItem(val);
-  let allCurSnap = [];
-  //if (!val.is_corner) {
-  allCurSnap = getAllCurSnap(allLineRects, x, y, allItemRect.cur);
-  allCurSnap = validateSnaps(allCurSnap, allRect);
-  //}
-  let getSnap = false;
-  let snapdist = [];
-  //console.log("allItemSnap",  allItemSnap.filter(e => e.isSnappedLine))
-  //console.log("~~~~start~~~~");
-  allItemSnap
-    .filter(e => e.isSnappedLine)
-    .forEach(snap => {
-      let 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(snap => {
-      let 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(others => intersectRect(others.rect, curitem.rect))
-    ) {
-      let edist = Math.min.apply(null, snapdist);
-      allCurSnap.forEach(snap => {
-        let 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) {
-      let nearRect = null;
-      let minDist = Infinity;
-      allLineRects.forEach(rect => {
-        let e = rect.rectEnd[0];
-        e = clone_point(e);
-        e.x -= curitem.pos.x;
-        e.y -= curitem.pos.y;
-        let nRot = rect.rotRad + Math.PI / 2;
-        let dist = Math.abs(e.x * Math.cos(nRot) + e.y * Math.sin(nRot));
-        if (minDist > dist) {
-          minDist = dist;
-          nearRect = rect;
-        }
-      });
-
-      let containrect = nearRect && intersectRect(nearRect.rect, curitem.rect);
-      if (containrect) {
-        let filter_func = snap => {
-          let diff = Math.abs(snap.rotRad - nearRect.rotRad - Math.PI);
-          return diff == 0 || diff == 2 * Math.PI;
-        };
-        let tempSnap = allLineSnap.filter(filter_func);
-        tempSnap = tempSnap.concat(
-          allLineSnap.filter(snap => !filter_func(snap))
-        );
-        tempSnap.some(snap => {
-          let 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(others =>
-        intersectRect(others.rect, curitem.rect)
-      )
-    ) {
-      getSnap = false;
-    }
-
-    if (!getSnap) {
-      let snapdist = [];
-      allItemSnap.forEach(snap => {
-        let 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(others =>
-          intersectRect(others.rect, curitem.rect)
-        )
-      ) {
-        let edist = Math.min.apply(null, snapdist);
-        allItemSnap.forEach(snap => {
-          let 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')) {
-          let intersects = allItemRect.others.filter(others =>
-            intersectRect(others.rect, curitem.rect)
-          );
-          intersects.forEach(rect => {
-            if (isPointInArea(allArea, rect.itemInfo) || !allArea.length)
-              if (rect.itemInfo.layoutpos.includes(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')
-        ) {
-          let intersects = allItemRect.others.filter(others =>
-            intersectRect(others.rect, curitem.rect)
-          );
-          intersects.forEach(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;
-              }
-          });
-        }
-      }
-    }
-  }
-  let 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')
-  ) {
-    let offset3inch = convert(3).from('in').to('cm');
-    let 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);
-      }
-    }
-    let t_val = {
-      pos: { x: tx, y: ty },
-      rotRad,
-      size: allItemRect.cur.size,
-      layoutpos: allItemRect.cur.layoutpos,
-      is_corner: allItemRect.cur.is_corner
-    };
-    let isItemRectSect = validInterSect(allItemRect.others, t_val);
-    let isWallRectSect = validInterSect(allLineRects, t_val);
-    if (isItemRectSect && isWallRectSect) {
-      nx = tx;
-      ny = ty;
-    }
-  }
-
-  return { nx, ny, rot, rotRad };
-}
-
-////////////
-export 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;
-  let nx = x;
-  let ny = y;
-  let ndist = 20;
-  let rotRad = allItemRect.cur.rotRad;
-  let 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;
-  let curitem = getCalcRectFromItem3D(val);
-  let allCurSnap = getAllCurSnap(allLineRects, x, y, allItemRect.cur);
-  allCurSnap = validateSnaps(allCurSnap, allRect);
-  let getSnap = false;
-  let snapdist = [];
-  allCurSnap.forEach(snap => {
-    let 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(others => {
-        let containrect = intersectRect(others.rect, curitem.rect);
-        if (containrect) {
-          let edist = Math.min.apply(null, snapdist);
-          allCurSnap.forEach(snap => {
-            let 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(others => {
-      let containrect = intersectRect(others.rect, curitem.rect);
-      if (containrect) {
-        allLineSnap.forEach(snap => {
-          let 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(others => {
-    if (
-      !(others.layoutpos === 'base' && allItemRect.cur.layoutpos === 'wall') ||
-      !(others.layoutpos === 'wall' && allItemRect.cur.layoutpos === 'base')
-    ) {
-      let containrect = intersectRect(others.rect, curitem.rect);
-      if (containrect) {
-        getSnap = false;
-      }
-    }
-  });
-  if (!getSnap) {
-    let snapdist = [];
-    allItemSnap.forEach(snap => {
-      let 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;
-      } else {
-        allItemRect.others.forEach(others => {
-          if (
-            !(
-              others.layoutpos === 'base' &&
-              allItemRect.cur.layoutpos === 'wall'
-            ) ||
-            !(
-              others.layoutpos === 'wall' &&
-              allItemRect.cur.layoutpos === 'base'
-            )
-          ) {
-            let containrect = intersectRect(others.rect, curitem.rect);
-            if (containrect) {
-              let edist = Math.min.apply(null, snapdist);
-              allItemSnap.forEach(snap => {
-                let 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;
-                }
-              });
-            }
-          }
-        });
-      }
-    });
-  }
-
-  let rot = (rotRad / Math.PI) * 180;
-  return { nx, ny, rot, rotRad };
-}
-
-export function getAllCurSnap(allLineRects, x, y, curItemRect) {
-  if (!curItemRect) return;
-  let allCurSnap = [];
-  let thick = LINE_THICKNESS / 2;
-
-  allLineRects.forEach(linerect => {
-    //allLineRects:left, right, top, bottom line
-    let p0 = clone_point(linerect.rect[2]); //point 2(x, y) inside of line
-    let p1 = clone_point(linerect.rect[3]); //point 3(x, y) inside of line
-    let q = point(x, y); // point of item
-    let cos = Math.cos(linerect.rotRad);
-    let 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;
-    let n = point(-sin, cos);
-    let v3to0 = {
-      x: linerect.rect[0].x - p1.x,
-      y: linerect.rect[0].y - p1.y
-    };
-    let fDot = dotprod(n, v3to0);
-    if (fDot > 0) {
-      // normal vector is crossing the wall
-      n.x = -n.x;
-      n.y = -n.y;
-    }
-    let dist = dotprod(diff(p1, q), n);
-    let h = point(q.x + dist * n.x, q.y + dist * n.y);
-    let nrot = linerect.rotRad + Math.PI;
-    if (nrot >= Math.PI) nrot -= Math.PI * 2;
-
-    let 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;
-}
-
-export function clone_point(pt) {
-  return point(pt.x, pt.y);
-}
-
-export function dotprod(v0, v1) {
-  return v0.x * v1.x + v0.y * v1.y;
-}
-
-//////////
-export function validInterSect(rect, val) {
-  let curitem = getCalcRectFromItem(val);
-  let datas = [];
-  rect.forEach(line => {
-    datas.push(line);
-  });
-  for (let i = 0; i < datas.length; i++) {
-    let data = datas[i];
-    let containrect = intersectRect(data.rect, curitem.rect);
-    if (containrect) {
-      return false;
-    }
-  }
-  return true;
-}
-
-let lineRect = layer => {
-  let areainfo = [];
-  layer.areas.forEach(area => {
-    let sz = area.vertices.size;
-    for (var i = 0; i < sz; i++) {
-      areainfo.push(area.vertices.get(i));
-    }
-  });
-  let rect = [];
-  areainfo.forEach(area => {
-    let vert = layer.vertices.get(area);
-    rect.push(vert.x, vert.y);
-  });
-  return rect;
-};
-
-export function getAllHoleRect(scene, val) {
-  let layerID = scene.selectedLayer;
-  let layer = scene.layers.get(layerID);
-  let 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 };
-  }
-
-  let holes = [];
-  let itemRect = getCalcRectFromItem(val);
-  layer.lines.forEach(line => {
-    line.holes.forEach(holeID => {
-      let hole = layer.holes.get(holeID);
-      holes.push(hole);
-    });
-  });
-  let i = 0;
-  for (; i < holes.length; i++) {
-    let twidth = holes[i].properties.getIn(['width', 'length']);
-    let theight = holes[i].properties.getIn(['thickness', 'length']) + 1;
-    let tdepth = holes[i].properties.getIn(['altitude', 'length']);
-    //let trot = holes[i].rotation;
-    let verticeIDs = scene.getIn([
-      'layers',
-      layerID,
-      'lines',
-      holes[i].line,
-      'vertices'
-    ])._tail.array;
-    let vertice0 = scene.getIn(['layers', layerID, 'vertices', verticeIDs[0]]);
-    let vertice1 = scene.getIn(['layers', layerID, 'vertices', verticeIDs[1]]);
-    let point0 = { x: vertice0.x, y: vertice0.y };
-    let point1 = { x: vertice1.x, y: vertice1.y };
-    let rotation = Math.atan2(point1.y - point0.y, point1.x - point0.x);
-
-    let rectInfo = getCalcRectFromLine(
-      point0.x,
-      point0.y,
-      point1.x,
-      point1.y,
-      LINE_THICKNESS,
-      layer
-    );
-    let vN = point(
-      rectInfo.rect[0].x - rectInfo.rect[3].x,
-      rectInfo.rect[0].y - rectInfo.rect[3].y
-    );
-    let lenN = Math.sqrt(vN.x * vN.x + vN.y * vN.y);
-    vN.x /= lenN;
-    vN.y /= lenN;
-
-    let hx = holes[i].x;
-    let hy = holes[i].y;
-
-    hx += (theight / 2) * vN.x;
-    hy += (theight / 2) * vN.y;
-
-    let tval = { pos: { x: hx, y: hy }, rotRad: rotation };
-    tval.size = { width: twidth, height: theight };
-    let hole_rect = getCalcRectFromItem(tval);
-    if (intersectRect(itemRect.rect, hole_rect.rect)) {
-      if (
-        tdepth > itemRect.size.depth &&
-        itemRect.layoutpos !== WALL_CABINET_LAYOUTPOS
-      ) {
-        let dist = itemRect.size.height / 2 + theight / 2;
-        let snap = [];
-        let p0 = {
-          x: hx + dist * Math.cos(rotation + Math.PI / 2),
-          y: hy + dist * Math.sin(rotation + Math.PI / 2)
-        };
-        let p1 = {
-          x: hx - dist * Math.cos(rotation + Math.PI / 2),
-          y: hy - dist * Math.sin(rotation + Math.PI / 2)
-        };
-        let allArea = getAllArea(layer);
-        if (isPointInArea(allArea, p0)) {
-          snap.push(p0);
-        }
-        if (isPointInArea(allArea, p1)) {
-          snap.push(p1);
-        }
-        return { isSect: true, snap };
-      } else return { isSect: false, snap: null };
-    }
-  }
-  return { isSect: true, snap: null };
-}
-
-export function getHoleItems(layer) {
-  let holeItems = [];
-  layer.holes.map(hole => {
-    let width = hole.properties.getIn(['width', 'length']);
-    let altitude = hole.properties.getIn(['altitude', 'length']);
-    holeItems.push({ x: hole.x, y: hole.y, width, altitude });
-  });
-  return holeItems;
-}
-
-export function needSnap(curItem, othItem) {
-  let blSnap = false;
-  if (curItem == undefined || curItem == null) return false;
-  let altitude = curItem.selectedItem.properties.get('altitude');
-  let heightFromFloor = convert(altitude.get('_length'))
-    .from(altitude.get('_unit'))
-    .to('in');
-  let height = curItem.cat.info.sizeinfo.height;
-  let currentItem = {
-    heightFromFloor,
-    height
-  };
-  altitude = othItem.item.properties.get('altitude');
-  heightFromFloor = convert(altitude.get('_length'))
-    .from(altitude.get('_unit'))
-    .to('in');
-  height = othItem.cat && othItem.cat.info.sizeinfo.height;
-  let otherItem = {
-    heightFromFloor,
-    height
-  };
-  let curFloor = currentItem.heightFromFloor;
-  let otherFloor = otherItem.heightFromFloor;
-  let 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;
-}
-
-export function isFrontWall(v0, v1) {
-  let { x: x1, y: y1 } = v0;
-  let { x: x2, y: y2 } = v1;
-  let alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
-  return (
-    (almostEqual(y1, y2) && x1 < x2) ||
-    (-Math.PI / 2 < alpha && alpha < Math.PI / 2)
-  );
-}
-
-export function isBackWall(v0, v1) {
-  let { x: x1, y: y1 } = v0;
-  let { x: x2, y: y2 } = v1;
-  let alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
-  return (
-    (almostEqual(y1, y2) && x1 > x2) ||
-    -Math.PI / 2 > alpha ||
-    alpha > Math.PI / 2
-  );
-}
-
-export function isLeftWall(v0, v1) {
-  let { x: x1, y: y1 } = v0;
-  let { x: x2, y: y2 } = v1;
-  let alpha = angleBetweenTwoPoints(x1, y1, x2, y2);
-  return (almostEqual(x1, x2) && y1 < y2) || (Math.PI > alpha && alpha > 0);
-}
-
-export function isRightWall(v0, v1) {
-  let { x: x1, y: y1 } = v0;
-  let { x: x2, y: y2 } = v1;
-  let 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 /////////////
-
- */
-export function relationshipOfTwoOverlappedLines(srcLine, destLine) {
-  const INFINITY = 1000000;
-  // geometric equation of srcLine
-  const dx1 = MathUtils.toFixedFloat(srcLine.x2 - srcLine.x1, 2);
-  const dy1 = MathUtils.toFixedFloat(srcLine.y2 - srcLine.y1, 2);
-  const a1 = dx1 === 0 ? INFINITY : MathUtils.toFixedFloat(dy1 / dx1, 2);
-  const b1 =
-    a1 === INFINITY
-      ? MathUtils.toFixedFloat(srcLine.x1, 2)
-      : MathUtils.toFixedFloat(srcLine.y1 - a1 * srcLine.x1, 2);
-  // geometric equation of destLine
-  const dx2 = MathUtils.toFixedFloat(destLine.x2 - destLine.x1, 2);
-  const dy2 = MathUtils.toFixedFloat(destLine.y2 - destLine.y1, 2);
-  const a2 = dx2 === 0 ? INFINITY : MathUtils.toFixedFloat(dy2 / dx2, 2);
-  const b2 =
-    a2 === INFINITY
-      ? MathUtils.toFixedFloat(destLine.x1, 2)
-      : MathUtils.toFixedFloat(destLine.y1 - a2 * destLine.x1, 2);
-
-  if (MathUtils.fAbs(a1) - MathUtils.fAbs(a2) !== 0)
-    // two lines are not parallel
-    return { result: OVERLAP_NONE };
-  if (b1 !== b2)
-    // two lines are parallel but not overlap
-    return { result: OVERLAP_NONE };
-
-  // parametric equation of destLine
-  const sk1 =
-    dx1 === 0
-      ? INFINITY
-      : MathUtils.toFixedFloat(
-          MathUtils.toFixedFloat(destLine.x1 - srcLine.x1, 2) / dx1,
-          2
-        );
-  const sk2 =
-    dy1 === 0
-      ? INFINITY
-      : MathUtils.toFixedFloat(
-          MathUtils.toFixedFloat(destLine.y1 - srcLine.y1, 2) / dy1,
-          2
-        );
-  const ek1 =
-    dx1 === 0
-      ? INFINITY
-      : MathUtils.toFixedFloat(
-          MathUtils.toFixedFloat(destLine.x2 - srcLine.x1, 2) / dx1,
-          2
-        );
-  const ek2 =
-    dy1 === 0
-      ? INFINITY
-      : MathUtils.toFixedFloat(
-          MathUtils.toFixedFloat(destLine.y2 - srcLine.y1, 2) / dy1,
-          2
-        );
-
-  if (
-    sk1 !== INFINITY &&
-    sk2 !== INFINITY &&
-    ek1 !== INFINITY &&
-    ek2 !== INFINITY &&
-    (sk1 !== sk2 || ek1 !== ek2)
-  )
-    // destLine does not overlap with srcLine
-    return { result: OVERLAP_NONE };
-
-  // parameter of destLine on the start and end points
-  const sk = Math.min(sk1, sk2);
-  const 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: OVERLAP_NONE };
-  if ((sk === 0 && ek === 1) || (sk === 1 && ek === 0))
-    // same lines
-    return { result: OVERLAP_SAME };
-  if ((sk <= 0 && ek >= 1) || (sk >= 1 && ek <= 0))
-    // destLine includes srcLine
-    return { result: OVERLAP_INCLUDED };
-  if (
-    (sk === 0 && ek < 0) ||
-    (sk === 1 && ek > 1) ||
-    (ek === 0 && sk < 0) ||
-    (ek === 1 && sk > 1)
-  ) {
-    // linked with one common point
-    let 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: OVERLAP_LINK, linkedLine };
-  }
-
-  let trimmedSegment1 = null;
-  let trimmedSegment2 = null;
-  const ret = { result: OVERLAP_SOME, trimmedSegs: [] };
-  if (0 <= sk && sk <= 1 && 0 <= ek && ek <= 1) {
-    // srcLine includes destLine
-    if (sk < ek) {
-      // srcS  destS     destE   srcE
-      //  |------|---------|-------|
-      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
-      //  |------|---------|-------|
-      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;
-}