kitchen-simulator 5.10.2-react.18 → 5.10.4-react.18

package/es/utils/molding.js

@@ -0,0 +1,1347 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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) { _defineProperty(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; }
+import { BASE_CABINET_LAYOUTPOS, BOTTOM_MOLDING_LOCATION, EPSILON, ITEM_TYPE, MIDDLE_MOLDING_LOCATION, MOLDING_LOCATIONS, OVERLAP_INCLUDED, OVERLAP_LINK, OVERLAP_SAME, OVERLAP_SOME, TALL_CABINET_LAYOUTPOS, TOE_KICK_MOLDING, TOP_MOLDING_LOCATION, WALL_CABINET_LAYOUTPOS } from "../constants";
+import * as Three from 'three';
+import { convert } from "./convert-units-lite";
+import IDBroker from "./id-broker";
+import { getToeKickSKU, isEqualInstallationType, returnReplaceableDeepSearchType } from "../components/viewer2d/utils";
+import { GeometryUtils } from "./export";
+import { isEmpty } from "./helper";
+export function getItemRect(item) {
+  var x = item.x;
+  var y = item.y;
+  var rotRad = item.rotation / 180 * Math.PI;
+  var itemWidth = item.properties.get('width').get('_length');
+  var itemWidthUnit = item.properties.get('width').get('_unit') || 'cm';
+  itemWidth = convert(itemWidth / 2).from(itemWidthUnit).to('cm');
+  var itemDepth = item.properties.get('depth').get('_length');
+  var itemDepthUnit = item.properties.get('depth').get('_unit') || 'cm';
+  itemDepth = convert(itemDepth / 2).from(itemDepthUnit).to('cm');
+  var mx = x - itemWidth * Math.cos(rotRad);
+  var my = y - itemWidth * Math.sin(rotRad);
+  var x0 = mx + itemDepth * Math.sin(rotRad);
+  var y0 = my - itemDepth * 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: [{
+      x: x0,
+      y: y0
+    }, {
+      x: x1,
+      y: y1
+    }, {
+      x: x2,
+      y: y2
+    }, {
+      x: x3,
+      y: y3
+    }]
+  };
+}
+export function hasMoldingLayout(molding, layoutpos) {
+  var types = molding === null || molding === void 0 ? void 0 : molding.molding_type;
+  return (Array.isArray(types) || typeof types === 'string') && types.includes(layoutpos);
+}
+export function isEnableItemForMolding(layer, selItem) {
+  var molding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  var allLineRects = GeometryUtils.buildRectFromLines(layer, GeometryUtils.getAllLines(layer));
+  var result = !isEmpty(selItem) && selItem.category === 'cabinet' && (selItem.layoutpos === BASE_CABINET_LAYOUTPOS && !GeometryUtils.isSnappedLine(getItemRect(selItem), allLineRects) || (selItem.layoutpos === WALL_CABINET_LAYOUTPOS || selItem.layoutpos === TALL_CABINET_LAYOUTPOS) && GeometryUtils.isSnappedLine(getItemRect(selItem), allLineRects));
+
+  // check this item is enable for any molding
+  if (isEmpty(molding)) return result;
+  // check this item is enable for specified molding
+  else return result && hasMoldingLayout(molding, selItem.layoutpos);
+}
+export function isAttachedWall(layer, selItem) {
+  var allLineRects = GeometryUtils.buildRectFromLines(layer, GeometryUtils.getAllLines(layer));
+  return GeometryUtils.isSnappedLine(getItemRect(selItem), allLineRects);
+}
+
+/**
+ * Check two line segments are overlap. The direction of the two line segments must be opposite.
+ * s1       c2     s2          c1
+ * |--------|------|-----------|
+ * Decision Formular: L(s1,c1) + L(s2, c2) = L(s1, s2) + L(c1, c2)
+ * @param {*} selRectPos1
+ * @param {*} selRectPos2
+ * @param {*} curRectPos1
+ * @param {*} curRectPos2
+ * @returns L(s1,c1) + L(s2, c2) - L(s1, s2) - L(c1, c2)
+ */
+function getDelta(selRectPos1, selRectPos2, curRectPos1, curRectPos2) {
+  return (
+    // GeometryUtils.verticesDistance(curRectPos1, selRectPos2) +
+    // GeometryUtils.verticesDistance(selRectPos1, curRectPos2) -
+    // Math.abs(
+    //   GeometryUtils.verticesDistance(curRectPos2, curRectPos1) -
+    //     GeometryUtils.verticesDistance(selRectPos1, selRectPos2)
+    // )
+    Math.abs(GeometryUtils.verticesDistance(curRectPos1, selRectPos1) + GeometryUtils.verticesDistance(selRectPos2, curRectPos2) - GeometryUtils.verticesDistance(curRectPos2, curRectPos1) - GeometryUtils.verticesDistance(selRectPos1, selRectPos2))
+  );
+}
+export function isItemSnappedItem(selItem, curItem) {
+  var selRect = getItemRect(selItem).rect;
+  var curRect = getItemRect(curItem).rect;
+  var flag30 = getDelta(selRect[3], selRect[0], curRect[1], curRect[2]) < EPSILON;
+  var flag21 = getDelta(selRect[2], selRect[1], curRect[0], curRect[3]) < EPSILON;
+  var flag23 = getDelta(selRect[2], selRect[3], curRect[2], curRect[3]) < EPSILON;
+  var flag01 = getDelta(selRect[1], selRect[0], curRect[0], curRect[3]) < EPSILON;
+  var flag03 = getDelta(selRect[0], selRect[3], curRect[1], curRect[0]) < EPSILON;
+  return flag30 || flag21 || flag23 || flag01 || flag03;
+}
+export function isItemSnappedGroup(selItem, itemGroup) {
+  return itemGroup.some(function (curItem) {
+    return isItemSnappedItem(selItem, curItem);
+  });
+}
+export function sortItemsByDistance(items, selItem) {
+  items.sort(function (a, b) {
+    return GeometryUtils.pointsDistance(a.x, a.y, selItem.x, selItem.y) - GeometryUtils.pointsDistance(b.x, b.y, selItem.x, selItem.y);
+  });
+  return items;
+}
+export function isSameMoldingLayoutpos(curItem, item) {
+  return curItem.layoutpos === BASE_CABINET_LAYOUTPOS && curItem.layoutpos === item.layoutpos || [WALL_CABINET_LAYOUTPOS, TALL_CABINET_LAYOUTPOS].includes(curItem.layoutpos) && [WALL_CABINET_LAYOUTPOS, TALL_CABINET_LAYOUTPOS].includes(item.layoutpos);
+}
+export function isItemSameItemByLocation(item1, item2, location) {
+  var item1Altitude = item1.properties.get('altitude').get('_length');
+  var item1AltitudeUnit = item1.properties.get('altitude').get('_unit');
+  item1Altitude = convert(item1Altitude).from(item1AltitudeUnit).to('cm');
+  var item1Height = item1.properties.get('height').get('_length');
+  var item1HeightUnit = item1.properties.get('height').get('_unit');
+  item1Height = convert(item1Height).from(item1HeightUnit).to('cm');
+  var item2Altitude = item2.properties.get('altitude').get('_length');
+  var item2AltitudeUnit = item2.properties.get('altitude').get('_unit');
+  item2Altitude = convert(item2Altitude).from(item2AltitudeUnit).to('cm');
+  var item2Height = item2.properties.get('height').get('_length');
+  var item2HeightUnit = item2.properties.get('height').get('_unit');
+  item2Height = convert(item2Height).from(item2HeightUnit).to('cm');
+  var flag = false;
+  switch (location) {
+    case TOP_MOLDING_LOCATION:
+      if (GeometryUtils.sameDistances(item1Altitude + item1Height, item2Altitude + item2Height)) flag = true;
+      break;
+    case MIDDLE_MOLDING_LOCATION:
+      if (GeometryUtils.sameDistances(item1Altitude + item1Height / 2, item2Altitude + item2Height / 2)) flag = true;
+      break;
+    case BOTTOM_MOLDING_LOCATION:
+      if (GeometryUtils.sameDistances(item1Altitude, item2Altitude)) flag = true;
+      break;
+  }
+  return flag;
+}
+export function tryMergeMDItem(layer, selItem, curItem, itemGroup, molding) {
+  return isSameMoldingLayoutpos(selItem, curItem) && isEnableItemForMolding(layer, curItem, molding) && isItemSnappedGroup(curItem, itemGroup) && !itemGroup.some(function (item) {
+    return item.id === curItem.id;
+  }) && isItemSameItemByLocation(selItem, curItem, molding.location_type);
+}
+export function getItemGroupFromMolding(layer, curItem, molding) {
+  var selectedItem = layer.getIn(['items', layer.selected.toJS().items[0]]);
+  var itemGroup = [curItem];
+  var temp_layer_items = layer.items.toArray().filter(function (item) {
+    return item.category === 'cabinet' && item.id !== curItem.id && item.id !== (selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id);
+  });
+  temp_layer_items = sortItemsByDistance(temp_layer_items, curItem);
+  for (var idx = 0; idx < temp_layer_items.length; idx++) {
+    if (tryMergeMDItem(layer, curItem, temp_layer_items[idx], itemGroup, molding)) {
+      itemGroup.push(temp_layer_items[idx]);
+      idx = -1;
+    }
+  }
+  return itemGroup;
+}
+function tryMergeItemWithLocation(curItem, itemGroup, location) {
+  return itemGroup.some(function (item) {
+    return isItemSnappedItem(curItem, item) && isItemSameItemByLocation(curItem, item, location);
+  });
+}
+
+/**
+ * Make the molding group array with [items].
+ * @param {*} layer
+ * @param {*} items - Mergable snapped item group, if [items] is null then get all MG array of layer
+ * @returns MG array
+ */
+export function getAllMoldingGroups(layer) {
+  var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (items === null) items = layer.items.toArray();
+  var MGArray = [];
+  items.forEach(function (curItem) {
+    // let allLineRects = GeometryUtils.buildRectFromLines(
+    //   layer,
+    //   GeometryUtils.getAllLines(layer)
+    // );
+    // if (
+    //   (curItem.category === 'cabinet' &&
+    //     curItem.layoutpos === BASE_CABINET_LAYOUTPOS &&
+    //     !GeometryUtils.isSnappedLine(getItemRect(curItem), allLineRects)) ||
+    //   ((curItem.layoutpos === WALL_CABINET_LAYOUTPOS ||
+    //     curItem.layoutpos === TALL_CABINET_LAYOUTPOS) &&
+    //     GeometryUtils.isSnappedLine(getItemRect(curItem), allLineRects))
+    // ) {
+    if (curItem.category === 'cabinet') {
+      var temp_items = items.filter(function (it) {
+        return it.category === 'cabinet' && isSameMoldingLayoutpos(curItem, it) && it.id !== curItem.id;
+      });
+      temp_items = sortItemsByDistance(temp_items, curItem);
+      MOLDING_LOCATIONS.forEach(function (location) {
+        if (!MGArray.some(function (mg) {
+          return mg.items.some(function (it) {
+            return it.id === curItem.id;
+          }) && mg.location_type === location;
+        })) {
+          var itemGroup = [curItem];
+          var isChangedItemGroup = false;
+          do {
+            isChangedItemGroup = false;
+            var _loop = function _loop(idx) {
+              if (!itemGroup.some(function (it) {
+                return it.id === temp_items[idx].id;
+              }) && tryMergeItemWithLocation(temp_items[idx], itemGroup, location)) {
+                itemGroup.push(temp_items[idx]);
+                isChangedItemGroup = true;
+              }
+            };
+            for (var idx = 0; idx < temp_items.length; idx++) {
+              _loop(idx);
+            }
+          } while (isChangedItemGroup);
+          MGArray.push({
+            id: IDBroker.acquireID(),
+            items: itemGroup,
+            location_type: location,
+            molding: null,
+            lines: null,
+            pointGroups: null,
+            meshes: [],
+            rot: 0,
+            pos: 0
+          });
+        }
+      });
+    }
+    // }
+  });
+  return MGArray;
+}
+export function getLinesOfItem(item, allLineRects, catalog) {
+  var lines = [];
+  var outline = null;
+  var element = catalog.elements[item.get('type')];
+  if (!element) element = catalog.elements[returnReplaceableDeepSearchType(item.get('type'))];
+  // get edge lines
+  var newWidth = item.properties.get('width').get('_length');
+  var wUnit = item.properties.get('width').get('_unit') || 'cm';
+  newWidth = convert(newWidth).from(wUnit).to('cm');
+  var newDepth = item.properties.get('depth').get('_length');
+  var hUnit = item.properties.get('depth').get('_unit') || 'cm';
+  newDepth = convert(newDepth).from(hUnit).to('cm');
+  if (item) {
+    // Get Outline Data of Selected Item
+    outline = element.info.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 _iterator = _createForOfIteratorHelper(outlinePaths),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var path = _step.value;
+          var _iterator2 = _createForOfIteratorHelper(path.subPaths),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var subPath = _step2.value;
+              outlinePoints = outlinePoints.concat(subPath.getPoints());
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      outline.reverse && outlinePoints.reverse();
+      for (var i = 0; i < outlinePoints.length - 1; i++) {
+        lines.push([GeometryUtils.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), GeometryUtils.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), IDBroker.acquireID()]);
+      }
+    } else {
+      var pos = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+      for (var _i = 0; _i < 4; _i++) {
+        lines.push([GeometryUtils.rotatePointAroundPoint(pos[_i][0] * newWidth / 2 + item.x, pos[_i][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation), GeometryUtils.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), IDBroker.acquireID()]);
+      }
+    }
+  }
+  if (item.layoutpos !== BASE_CABINET_LAYOUTPOS) {
+    lines = lines.filter(function (line) {
+      return !GeometryUtils.isSnappedLine({
+        rect: [{
+          x: 0,
+          y: 0
+        }, {
+          x: 0,
+          y: 0
+        }, line[0], line[1]]
+      }, allLineRects);
+    });
+  }
+  return lines;
+}
+export function getLinesOfItem2(item, allLineRects, catalog) {
+  var _lines;
+  var lines = [];
+  var outline = null;
+  var element = catalog.elements[item.get('type')];
+  if (!element) element = catalog.elements[returnReplaceableDeepSearchType(item.get('type'))];
+  // get edge lines
+  var newWidth = item.properties.get('width').get('_length');
+  var wUnit = item.properties.get('width').get('_unit') || 'cm';
+  newWidth = convert(newWidth).from(wUnit).to('cm');
+  var newDepth = item.properties.get('depth').get('_length');
+  var hUnit = item.properties.get('depth').get('_unit') || 'cm';
+  newDepth = convert(newDepth).from(hUnit).to('cm');
+  if (item) {
+    var _element;
+    // Get Outline Data of Selected Item
+    outline = (_element = element) === null || _element === void 0 ? void 0 : _element.info.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 _iterator3 = _createForOfIteratorHelper(outlinePaths),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var path = _step3.value;
+          var _iterator4 = _createForOfIteratorHelper(path.subPaths),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var subPath = _step4.value;
+              outlinePoints = outlinePoints.concat(subPath.getPoints());
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      outline.reverse && outlinePoints.reverse();
+      for (var i = 0; i < outlinePoints.length - 1; i++) {
+        lines.push([GeometryUtils.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), GeometryUtils.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), IDBroker.acquireID()]);
+      }
+    } else {
+      var pos = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+      for (var _i2 = 0; _i2 < 4; _i2++) {
+        lines.push([GeometryUtils.rotatePointAroundPoint(pos[_i2][0] * newWidth / 2 + item.x, pos[_i2][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation), GeometryUtils.rotatePointAroundPoint(pos[(_i2 + 1) % 4][0] * newWidth / 2 + item.x, pos[(_i2 + 1) % 4][1] * newDepth / 2 + item.y, item.x, item.y, item.rotation), IDBroker.acquireID()]);
+      }
+    }
+  }
+  lines = (_lines = lines) === null || _lines === void 0 ? void 0 : _lines.filter(function (line) {
+    return !GeometryUtils.isSnappedLine({
+      rect: [{
+        x: 0,
+        y: 0
+      }, {
+        x: 0,
+        y: 0
+      }, line[0], line[1]]
+    }, allLineRects);
+  });
+  return lines;
+}
+function isParallelLines(line1, line2) {
+  var isParallel = false;
+  if (Math.abs(line1[0].y - line1[1].y) <= EPSILON && Math.abs(line2[0].y - line2[1].y) <= EPSILON) isParallel = true;
+  if (Math.abs(line1[0].x - line1[1].x) <= EPSILON && Math.abs(line2[0].x - line2[1].x) <= EPSILON) isParallel = true;
+  if (Math.abs((line1[0].x - line1[1].x) / (line1[0].y - line1[1].y) - (line2[0].x - line2[1].x) / (line2[0].y - line2[1].y)) <= EPSILON) isParallel = true;
+  if (isParallel) {
+    return true;
+  }
+  return false;
+}
+export function isLinesOverlapped(line1, line2) {
+  return isParallelLines(line1, line2) && line1.some(function (l1) {
+    return line2.some(function (l2) {
+      return GeometryUtils.samePoints(l1, l2);
+    });
+  });
+}
+export function mergeOverlappedLines(line1, line2) {
+  var line1_idx = 0,
+    line2_idx = 0;
+  line1.forEach(function (l1, idx1) {
+    if (idx1 !== line1.length - 1) {
+      line2.forEach(function (l2, idx2) {
+        if (idx2 !== line2.length - 1) {
+          if (GeometryUtils.samePoints(l1, l2)) {
+            line1_idx = idx1;
+            line2_idx = idx2;
+          }
+        }
+      });
+    }
+  });
+  //If line1 's end point and line2 's start point is same, two lines merge into a line with
+  //the line1's start point as the start point and line2's end point as the end point.
+  if (line1_idx === 1) {
+    return [line1[1 - line1_idx], line2[1 - line2_idx], IDBroker.acquireID()];
+  } else {
+    return [line2[1 - line2_idx], line1[1 - line1_idx], IDBroker.acquireID()];
+  }
+}
+
+/**
+ * Get the contour line array of moldingGroup items
+ * @param {*} moldingGroup
+ * @param {*} layer
+ * @param {*} catalog
+ * @returns contour line array of moldingGroup items
+ */
+export function getLinesFromItems2(moldingGroup, layer, catalog) {
+  // wall lines
+  var allLineRects = GeometryUtils.buildRectFromLines(layer, GeometryUtils.getAllLines(layer));
+  var MGlines = [];
+  var MGlinesOtherSnapped = [];
+  var items = _toConsumableArray(moldingGroup.items);
+  // The other item's lines (these items are snapped to the moldingGroup items)
+  var itemsOtherSnapped = layer.items.toArray().filter(function (item) {
+    if (items.some(function (it) {
+      return item.id === it.id;
+    })) return false;
+    if (isItemSnappedGroup(item, items)) {
+      var itemLines = getLinesOfItem(item, allLineRects, catalog);
+      var itemAltitude = item.properties.get('altitude').get('_length');
+      var itemAltitudeUnit = item.properties.get('altitude').get('_unit');
+      itemAltitude = convert(itemAltitude).from(itemAltitudeUnit).to('cm');
+      var itemHeight = item.properties.get('height').get('_length');
+      var itemHeightUnit = item.properties.get('height').get('_unit');
+      itemHeight = convert(itemHeight).from(itemHeightUnit).to('cm');
+      itemLines.forEach(function (line) {
+        line.push({
+          altitude: itemAltitude,
+          height: itemHeight
+        });
+      });
+      MGlinesOtherSnapped = [].concat(_toConsumableArray(MGlinesOtherSnapped), _toConsumableArray(itemLines));
+      return true;
+    } else return false;
+  });
+
+  // get all lines of moldingGroup items
+  items.forEach(function (item) {
+    var itemAltitude = item.properties.get('altitude').get('_length');
+    var itemAltitudeUnit = item.properties.get('altitude').get('_unit');
+    itemAltitude = convert(itemAltitude).from(itemAltitudeUnit).to('cm');
+    var itemHeight = item.properties.get('height').get('_length');
+    var itemHeightUnit = item.properties.get('height').get('_unit');
+    itemHeight = convert(itemHeight).from(itemHeightUnit).to('cm');
+    var itemLines = getLinesOfItem(item, allLineRects, catalog);
+
+    // remove the edge that overlapped with other snapped items
+    itemLines = itemLines.filter(function (itLine) {
+      var ret = true;
+      var srcLine = {
+        x1: itLine[0].x,
+        y1: itLine[0].y,
+        x2: itLine[1].x,
+        y2: itLine[1].y
+      };
+      for (var j = 0; j < MGlinesOtherSnapped.length; j++) {
+        var bCheck = false;
+        switch (moldingGroup.location_type) {
+          case TOP_MOLDING_LOCATION:
+            bCheck = MGlinesOtherSnapped[j][3].altitude + MGlinesOtherSnapped[j][3].height > itemAltitude + itemHeight;
+            break;
+          case MIDDLE_MOLDING_LOCATION:
+            bCheck = true;
+            break;
+          case BOTTOM_MOLDING_LOCATION:
+            bCheck = MGlinesOtherSnapped[j][3].altitude < itemAltitude;
+            break;
+        }
+        if (item.category !== 'cabinet' || ![BASE_CABINET_LAYOUTPOS, WALL_CABINET_LAYOUTPOS, TALL_CABINET_LAYOUTPOS].includes(item.layoutpos)) bCheck = true;
+        if (bCheck) {
+          var destLine = {
+            x1: MGlinesOtherSnapped[j][0].x,
+            y1: MGlinesOtherSnapped[j][0].y,
+            x2: MGlinesOtherSnapped[j][1].x,
+            y2: MGlinesOtherSnapped[j][1].y
+          };
+          var rst = GeometryUtils.relationshipOfTwoOverlappedLines(srcLine, destLine);
+          if (rst.result === OVERLAP_SAME || rst.result === OVERLAP_INCLUDED) {
+            ret = false;
+            break;
+          }
+        }
+      }
+      return ret;
+    });
+    MGlines = [].concat(_toConsumableArray(MGlines), _toConsumableArray(itemLines));
+  });
+
+  // Filtering overlapped edges and get contour edges
+  var removeLineIds = []; // remove the edge that fully overlapped to other edge
+  var newLines = []; // new countour edge segment that except the overlapped part
+  var _loop2 = function _loop2(i) {
+    var srcLine = {
+      x1: MGlines[i][0].x,
+      y1: MGlines[i][0].y,
+      x2: MGlines[i][1].x,
+      y2: MGlines[i][1].y
+    };
+    var _loop4 = function _loop4(j) {
+        if (i === j) return 0; // continue
+        var destLine = {
+          x1: MGlines[j][0].x,
+          y1: MGlines[j][0].y,
+          x2: MGlines[j][1].x,
+          y2: MGlines[j][1].y
+        };
+        var rst = GeometryUtils.relationshipOfTwoOverlappedLines(srcLine, destLine);
+        if (rst.result === OVERLAP_SAME || rst.result === OVERLAP_INCLUDED) {
+          removeLineIds.push(i);
+          return 1; // break
+        } else if (rst.result === OVERLAP_SOME) {
+          removeLineIds.push(i);
+          var lineSegs = getTrimmedContourLineSegs(rst.trimmedSegs, MGlines.filter(function (v, idx) {
+            return idx !== i && idx !== j;
+          }), 0);
+          if (lineSegs.length > 0) newLines = [].concat(_toConsumableArray(newLines), _toConsumableArray(lineSegs));
+          return 1; // break
+        }
+      },
+      _ret2;
+    for (var j = 0; j < MGlines.length; j++) {
+      _ret2 = _loop4(j);
+      if (_ret2 === 0) continue;
+      if (_ret2 === 1) break;
+    }
+  };
+  for (var i = 0; i < MGlines.length; i++) {
+    _loop2(i);
+  }
+  MGlines = MGlines.filter(function (line, idx) {
+    return !removeLineIds.some(function (id) {
+      return idx === id;
+    });
+  });
+  if (newLines.length > 0) MGlines = [].concat(_toConsumableArray(MGlines), _toConsumableArray(newLines));
+
+  // merge the collinear linked lines to one line
+  var newMGlines = [];
+  var filteredMGlines = MGlines;
+  var _loop3 = function _loop3(_i3) {
+      if (filteredMGlines.length < 1) return 0; // break
+      if (!filteredMGlines.some(function (v) {
+        return v[2] === MGlines[_i3][2];
+      })) return 1; // continue
+      var mergedResult = getMergedLine(MGlines[_i3], filteredMGlines, 0);
+      if (mergedResult) {
+        newMGlines.push(mergedResult.mergedLine);
+        filteredMGlines = mergedResult.filteredMGlines;
+      }
+    },
+    _ret;
+  for (var _i3 = 0; _i3 < MGlines.length; _i3++) {
+    _ret = _loop3(_i3);
+    if (_ret === 0) break;
+    if (_ret === 1) continue;
+  }
+  return newMGlines;
+}
+
+/**
+ * Get the line that colinear linked with [line], and merge them to a new line
+ * @param {*} line
+ * @param {*} MGlines
+ * @returns
+ *  - returns merged new line
+ *  - returns filtered new line group (remove linked line from [MGlines])
+ */
+function getMergedLine(line, MGlines, cnt) {
+  try {
+    cnt++;
+    if (cnt > 5000) {
+      console.log('getMergedLine has limited!');
+      return null;
+    }
+    var newMGlines = MGlines.filter(function (v) {
+      return line[2] !== v[2];
+    });
+    var mergeResult = {
+      mergedLine: line,
+      filteredMGlines: newMGlines
+    };
+    var srcLine = {
+      x1: line[0].x,
+      y1: line[0].y,
+      x2: line[1].x,
+      y2: line[1].y
+    };
+    var _loop5 = function _loop5(i) {
+      var destLine = {
+        x1: newMGlines[i][0].x,
+        y1: newMGlines[i][0].y,
+        x2: newMGlines[i][1].x,
+        y2: newMGlines[i][1].y
+      };
+      var rst = GeometryUtils.relationshipOfTwoOverlappedLines(srcLine, destLine);
+      if (rst.result === OVERLAP_LINK) {
+        var mergedLine = [{
+          x: rst.linkedLine.x1,
+          y: rst.linkedLine.y1
+        }, {
+          x: rst.linkedLine.x2,
+          y: rst.linkedLine.y2
+        }, IDBroker.acquireID()];
+        mergeResult = getMergedLine(mergedLine, newMGlines.filter(function (v, idx) {
+          return idx !== i;
+        }), cnt);
+      }
+    };
+    for (var i = 0; i < newMGlines.length; i++) {
+      _loop5(i);
+    }
+    return mergeResult;
+  } catch (e) {
+    console.log('getMergedLine catched :', e);
+    return null;
+  }
+}
+
+/**
+ * Get the contour line segments from [lineSegs]
+ * @param {*} lineSegs
+ * @param {*} otherLines
+ * @returns
+ */
+function getTrimmedContourLineSegs(lineSegs, otherLines, cnt) {
+  try {
+    cnt++;
+    if (cnt > 5000) {
+      console.log('getTrimmedContourLineSegs has limited!');
+      return [];
+    }
+    var returnSegs = [];
+    for (var i = 0; i < lineSegs.length; i++) {
+      var srcLine = {
+        x1: lineSegs[i].x1,
+        y1: lineSegs[i].y1,
+        x2: lineSegs[i].x2,
+        y2: lineSegs[i].y2
+      };
+      var bContourSeg = true;
+      var _loop6 = function _loop6(j) {
+          var _otherLines$j$0$x, _otherLines$j$, _otherLines$j$line$, _otherLines$j$0$y, _otherLines$j$2, _otherLines$j$line$2, _otherLines$j$1$x, _otherLines$j$3, _otherLines$j$line$3, _otherLines$j$1$y, _otherLines$j$4, _otherLines$j$line$4;
+          var destLine = {
+            x1: (_otherLines$j$0$x = (_otherLines$j$ = otherLines[j][0]) === null || _otherLines$j$ === void 0 ? void 0 : _otherLines$j$.x) !== null && _otherLines$j$0$x !== void 0 ? _otherLines$j$0$x : (_otherLines$j$line$ = otherLines[j].line[0]) === null || _otherLines$j$line$ === void 0 ? void 0 : _otherLines$j$line$.x,
+            y1: (_otherLines$j$0$y = (_otherLines$j$2 = otherLines[j][0]) === null || _otherLines$j$2 === void 0 ? void 0 : _otherLines$j$2.y) !== null && _otherLines$j$0$y !== void 0 ? _otherLines$j$0$y : (_otherLines$j$line$2 = otherLines[j].line[0]) === null || _otherLines$j$line$2 === void 0 ? void 0 : _otherLines$j$line$2.y,
+            x2: (_otherLines$j$1$x = (_otherLines$j$3 = otherLines[j][1]) === null || _otherLines$j$3 === void 0 ? void 0 : _otherLines$j$3.x) !== null && _otherLines$j$1$x !== void 0 ? _otherLines$j$1$x : (_otherLines$j$line$3 = otherLines[j].line[1]) === null || _otherLines$j$line$3 === void 0 ? void 0 : _otherLines$j$line$3.x,
+            y2: (_otherLines$j$1$y = (_otherLines$j$4 = otherLines[j][1]) === null || _otherLines$j$4 === void 0 ? void 0 : _otherLines$j$4.y) !== null && _otherLines$j$1$y !== void 0 ? _otherLines$j$1$y : (_otherLines$j$line$4 = otherLines[j].line[1]) === null || _otherLines$j$line$4 === void 0 ? void 0 : _otherLines$j$line$4.y
+          };
+          var rst = GeometryUtils.relationshipOfTwoOverlappedLines(srcLine, destLine);
+          if (rst.result == OVERLAP_SAME || rst.result == OVERLAP_INCLUDED) {
+            bContourSeg = false;
+            return 0; // break
+          } else if (rst.result == OVERLAP_SOME) {
+            var tLineSegs = getTrimmedContourLineSegs(rst.trimmedSegs, otherLines.filter(function (v, idx) {
+              return idx !== j;
+            }), cnt);
+            if (tLineSegs.length > 0) returnSegs = [].concat(_toConsumableArray(returnSegs), _toConsumableArray(tLineSegs));
+            bContourSeg = false;
+            return 0; // break
+          }
+        },
+        _ret3;
+      for (var j = 0; j < otherLines.length; j++) {
+        _ret3 = _loop6(j);
+        if (_ret3 === 0) break;
+      }
+      if (bContourSeg) returnSegs.push([{
+        x: lineSegs[i].x1,
+        y: lineSegs[i].y1
+      }, {
+        x: lineSegs[i].x2,
+        y: lineSegs[i].y2
+      }, IDBroker.acquireID()]);
+    }
+    return returnSegs;
+  } catch (e) {
+    console.log('getTrimmedContourLineSegs catched :', e);
+    return [];
+  }
+}
+export function getLinesFromItems(moldingGroup, layer, catalog) {
+  var allLineRects = GeometryUtils.buildRectFromLines(layer, GeometryUtils.getAllLines(layer));
+  var items = _toConsumableArray(moldingGroup.items);
+  var MGlines = getLinesOfItem(items[0], allLineRects, catalog);
+  items = sortItemsByDistance(items, items[0]);
+  var _loop7 = function _loop7() {
+    var itemLines = getLinesOfItem(items[i], allLineRects, catalog);
+    var temp_MGLines = [];
+    MGlines.forEach(function (line) {
+      var idx = itemLines.findIndex(function (itemLine) {
+        return isLinesOverlapped(line, itemLine);
+      });
+      var curItemLine = itemLines[idx];
+      if (idx > -1) {
+        if (!(GeometryUtils.samePoints(line[0], curItemLine[0]) && GeometryUtils.samePoints(line[1], curItemLine[1]) || GeometryUtils.samePoints(line[0], curItemLine[1]) && GeometryUtils.samePoints(line[1], curItemLine[0]))) {
+          var MGLine = mergeOverlappedLines(line, curItemLine);
+          temp_MGLines.push(MGLine);
+        }
+        itemLines.splice(idx, 1);
+      } else {
+        temp_MGLines.push(line);
+      }
+    });
+    itemLines.forEach(function (itemLine) {
+      return temp_MGLines.push(itemLine);
+    });
+    MGlines = [].concat(temp_MGLines);
+  };
+  for (var i = 1; i < items.length; i++) {
+    _loop7();
+  }
+  // return MGlines;
+  var snapped_other_items = layer.items.toArray().filter(function (item) {
+    if (items.some(function (it) {
+      return item.id === it.id;
+    })) return false;
+    return isItemSnappedGroup(item, items);
+  });
+  snapped_other_items.forEach(function (item) {
+    var itemAltitude = item.properties.get('altitude').get('_length');
+    var itemAltitudeUnit = item.properties.get('altitude').get('_unit');
+    itemAltitude = convert(itemAltitude).from(itemAltitudeUnit).to('cm');
+    var itemHeight = item.properties.get('height').get('_length');
+    var itemHeightUnit = item.properties.get('height').get('_unit');
+    itemHeight = convert(itemHeight).from(itemHeightUnit).to('cm');
+    var mgroupAltitude = items[0].properties.get('altitude').get('_length');
+    var mgroupAltitudeUnit = items[0].properties.get('altitude').get('_unit');
+    mgroupAltitude = convert(mgroupAltitude).from(mgroupAltitudeUnit).to('cm');
+    var mgroupHeight = items[0].properties.get('height').get('_length');
+    var mgroupHeightUnit = items[0].properties.get('height').get('_unit');
+    mgroupHeight = convert(mgroupHeight).from(mgroupHeightUnit).to('cm');
+    var flag = false;
+    switch (moldingGroup.location_type) {
+      case TOP_MOLDING_LOCATION:
+        flag = itemAltitude + itemHeight > mgroupAltitude + mgroupHeight;
+        break;
+      case MIDDLE_MOLDING_LOCATION:
+        flag = true;
+        break;
+      case BOTTOM_MOLDING_LOCATION:
+        flag = itemAltitude < mgroupAltitude;
+        break;
+    }
+    if (item.category !== 'cabinet' || ![BASE_CABINET_LAYOUTPOS, WALL_CABINET_LAYOUTPOS, TALL_CABINET_LAYOUTPOS].includes(item.layoutpos)) flag = true;
+    if (flag) {
+      var itemLines = getLinesOfItem(item, allLineRects, catalog);
+      var temp_MGLines = [];
+      MGlines.forEach(function (mgl) {
+        var idx = itemLines.findIndex(function (itl) {
+          return isLinesOverlapped(mgl, itl);
+        });
+        var curITL = itemLines[idx];
+        if (idx > -1) {
+          if (getDelta(mgl[0], mgl[1], curITL[1], curITL[0]) < EPSILON || getDelta(mgl[0], mgl[1], curITL[0], curITL[1]) < EPSILON) {
+            if (GeometryUtils.verticesDistance(mgl[0], mgl[1]) > GeometryUtils.verticesDistance(curITL[0], curITL[1])) {
+              var MGLine = mergeOverlappedLines(mgl, curITL);
+              temp_MGLines.push(MGLine);
+            }
+            itemLines.splice(idx, 1);
+          } else {
+            temp_MGLines.push(mgl);
+          }
+        } else {
+          temp_MGLines.push(mgl);
+        }
+      });
+      MGlines = [].concat(temp_MGLines);
+    }
+  });
+  return MGlines;
+}
+function getMDPoints(newMD) {
+  if (newMD.lines.length < 1) return _objectSpread(_objectSpread({}, newMD), {}, {
+    pointGroups: []
+  });
+  // let maxX = newMD.lines[0][0].x,
+  var maxX = newMD.lines[0][0].x,
+    minX = newMD.lines[0][0].x;
+  var maxY = newMD.lines[0][0].y,
+    minY = newMD.lines[0][0].y;
+  newMD.lines.forEach(function (line) {
+    if (line[0].x > maxX) {
+      maxX = line[0].x;
+    }
+    if (line[0].x < minX) {
+      minX = line[0].x;
+    }
+    if (line[1].x > maxX) {
+      maxX = line[1].x;
+    }
+    if (line[1].x < minX) {
+      minX = line[1].x;
+    }
+    if (line[0].y > maxY) {
+      maxY = line[0].y;
+    }
+    if (line[0].y < minY) {
+      minY = line[0].y;
+    }
+    if (line[1].y > maxY) {
+      maxY = line[1].y;
+    }
+    if (line[1].y < minY) {
+      minY = line[1].y;
+    }
+  });
+  var cPos = {
+    x: (maxX + minX) / 2,
+    y: (maxY + minY) / 2
+  };
+  var newSize = _objectSpread(_objectSpread({}, newMD.size), {}, {
+    width: maxX - minX,
+    depth: maxY - minY
+  });
+
+  // get vertex points
+  var MDlines = _toConsumableArray(newMD.lines);
+  var pointGroups = [[]];
+  var flag = 1;
+  var i = 0;
+  var _loop8 = function _loop8() {
+    if (pointGroups[i].length === 0) {
+      pointGroups[i].push(new Three.Vector2(MDlines[0][0].x - cPos.x, MDlines[0][0].y - cPos.y), new Three.Vector2(MDlines[0][1].x - cPos.x, MDlines[0][1].y - cPos.y));
+      MDlines.splice(0, 1);
+    } else {
+      if (flag) {
+        var lastPoint = pointGroups[i][pointGroups[i].length - 1];
+        var res = MDlines.findIndex(function (a) {
+          return GeometryUtils.samePoints({
+            x: a[0].x - cPos.x,
+            y: a[0].y - cPos.y
+          }, lastPoint) || GeometryUtils.samePoints({
+            x: a[1].x - cPos.x,
+            y: a[1].y - cPos.y
+          }, lastPoint);
+        });
+        if (res > -1) {
+          var newPos = {
+            x: MDlines[res][0].x - cPos.x,
+            y: MDlines[res][0].y - cPos.y
+          };
+          if (GeometryUtils.samePoints(newPos, lastPoint)) {
+            newPos = {
+              x: MDlines[res][1].x - cPos.x,
+              y: MDlines[res][1].y - cPos.y
+            };
+          }
+          pointGroups[i].push(new Three.Vector2(newPos.x, newPos.y));
+          MDlines.splice(res, 1);
+        } else {
+          flag = 0;
+        }
+      } else {
+        var firstPoint = pointGroups[i][0];
+        var _res = MDlines.findIndex(function (a) {
+          return GeometryUtils.samePoints({
+            x: a[0].x - cPos.x,
+            y: a[0].y - cPos.y
+          }, firstPoint) || GeometryUtils.samePoints({
+            x: a[1].x - cPos.x,
+            y: a[1].y - cPos.y
+          }, firstPoint);
+        });
+        if (_res > -1) {
+          var _newPos = {
+            x: MDlines[_res][0].x - cPos.x,
+            y: MDlines[_res][0].y - cPos.y
+          };
+          if (GeometryUtils.samePoints(_newPos, firstPoint)) {
+            _newPos = {
+              x: MDlines[_res][1].x - cPos.x,
+              y: MDlines[_res][1].y - cPos.y
+            };
+          }
+          pointGroups[i] = [new Three.Vector2(_newPos.x, _newPos.y)].concat(_toConsumableArray(pointGroups[i]));
+          MDlines.splice(_res, 1);
+        } else {
+          flag = 1;
+          i++;
+          if (MDlines.length !== 0) pointGroups.push([]);
+        }
+      }
+    }
+  };
+  while (MDlines.length !== 0) {
+    _loop8();
+  }
+  var z = newMD.items[0].properties.get('altitude').get('_length');
+  var zUnit = newMD.items[0].properties.get('altitude').get('_unit') || 'cm';
+  z = convert(z).from(zUnit).to('cm');
+  var height = newMD.items[0].properties.get('height').get('_length');
+  var heightUnit = newMD.items[0].properties.get('height').get('_unit') || 'cm';
+  height = convert(height).from(heightUnit).to('cm');
+  switch (newMD.location_type) {
+    case TOP_MOLDING_LOCATION:
+      z += height;
+      break;
+    case MIDDLE_MOLDING_LOCATION:
+      z += height / 2;
+      break;
+    case BOTTOM_MOLDING_LOCATION:
+      z += 0;
+      break;
+    default:
+      break;
+  }
+  return _objectSpread(_objectSpread({}, newMD), {}, {
+    pointGroups: pointGroups,
+    pos: _objectSpread(_objectSpread({}, cPos), {}, {
+      z: z
+    }),
+    size: newSize
+  });
+}
+export function createMonldingGroup(oldMG, layer, molding, catalog) {
+  var newMG = _objectSpread({}, oldMG);
+  newMG.molding = molding;
+  newMG.lines = getLinesFromItems2(oldMG, layer, catalog);
+  newMG.lines.reverse();
+  newMG = getMDPoints(newMG);
+  return newMG;
+}
+export function getMoldingDataOfScene2(layer, catalog, doorStyle) {
+  var _layer$items;
+  var moldingData = [];
+  var items = layer === null || layer === void 0 || (_layer$items = layer.items) === null || _layer$items === void 0 ? void 0 : _layer$items.toArray();
+  var allLineRects = GeometryUtils.buildRectFromLines(layer, GeometryUtils.getAllLines(layer));
+
+  // get all molding line segments
+  var moldingLines = [];
+  items === null || items === void 0 || items.forEach(function (item) {
+    if (item.category === ITEM_TYPE.CABINET) {
+      var _item$properties$get$, _item$properties$get$2, _item$properties$get$3, _item$molding;
+      var MGlines = getLinesOfItem2(item, allLineRects, catalog); // exclude overlayed to wall
+      // id & width
+      var parentId = item.id;
+      var inchWidth = convert(item.properties.get('width').get('_length')).from((_item$properties$get$ = item.properties.get('width').get('_unit')) !== null && _item$properties$get$ !== void 0 ? _item$properties$get$ : 'in').to('in');
+      // z position of molding line
+      var z = item.properties.get('altitude').get('_length');
+      var zUnit = (_item$properties$get$2 = item.properties.get('altitude').get('_unit')) !== null && _item$properties$get$2 !== void 0 ? _item$properties$get$2 : 'in';
+      z = convert(z).from(zUnit).to('cm');
+      var h = item.properties.get('height').get('_length');
+      var hUnit = (_item$properties$get$3 = item.properties.get('height').get('_unit')) !== null && _item$properties$get$3 !== void 0 ? _item$properties$get$3 : 'in';
+      h = convert(h).from(hUnit).to('cm');
+      if (!isEmpty(item.molding) && isEnableItemForMolding(layer, item)) {
+        // calc normal molding line
+        item === null || item === void 0 || item.molding.forEach(function (molding) {
+          var lineZ = z;
+          switch (molding.location_type) {
+            case TOP_MOLDING_LOCATION:
+              lineZ = z + h;
+              break;
+            case MIDDLE_MOLDING_LOCATION:
+              lineZ = z + h / 2;
+              break;
+          }
+          MGlines === null || MGlines === void 0 || MGlines.forEach(function (line) {
+            return moldingLines.push({
+              molding: _objectSpread({}, molding),
+              doorStyle: item.doorStyle.hasOwnProperty('id') ? item.doorStyle : !isEmpty(item.doorStyle) && item.doorStyle.toJS(),
+              line: line,
+              z: lineZ,
+              parentId: parentId,
+              inchWidth: inchWidth
+            });
+          });
+        });
+      } else if (
+      // calc toe kick molding line
+      item.layoutpos === BASE_CABINET_LAYOUTPOS && (isEmpty(item.molding) || ((_item$molding = item.molding) === null || _item$molding === void 0 ? void 0 : _item$molding.length) < 1 || !isEnableItemForMolding(layer, item))) {
+        var skuName = getToeKickSKU(item.doorStyle, catalog);
+        var thumbnail = skuName ? skuName : '';
+        MGlines === null || MGlines === void 0 || MGlines.forEach(function (line) {
+          return moldingLines.push({
+            molding: {
+              name: TOE_KICK_MOLDING,
+              sku: getToeKickSKU(item.doorStyle, catalog),
+              thumbnail: thumbnail,
+              category: 'molding',
+              type: 'cabinet'
+            },
+            doorStyle: item.doorStyle.hasOwnProperty('id') ? item.doorStyle : !isEmpty(item.doorStyle) && item.doorStyle.toJS(),
+            line: line,
+            z: z,
+            parentId: parentId,
+            inchWidth: inchWidth
+          });
+        });
+      }
+    }
+  });
+
+  // filter the real molding line segments
+  var removeLineIds = []; // remove the line that fully overlapped to other line
+  var newLines = []; // new countour line segment that except the overlapped part
+  var _loop9 = function _loop9(i) {
+    var srcLine = {
+      x1: moldingLines[i].line[0].x,
+      y1: moldingLines[i].line[0].y,
+      x2: moldingLines[i].line[1].x,
+      y2: moldingLines[i].line[1].y
+    };
+    var _loop1 = function _loop1(_j) {
+        if (i === _j) return 0; // continue
+        if (Math.abs(moldingLines[i].z - moldingLines[_j].z) > EPSILON) return 0; // continue
+        var destLine = {
+          x1: moldingLines[_j].line[0].x,
+          y1: moldingLines[_j].line[0].y,
+          x2: moldingLines[_j].line[1].x,
+          y2: moldingLines[_j].line[1].y
+        };
+        var rst = GeometryUtils.relationshipOfTwoOverlappedLines(srcLine, destLine);
+        if (rst.result === OVERLAP_SAME || rst.result === OVERLAP_INCLUDED) {
+          removeLineIds.push(i);
+          return 1; // break
+        } else if (rst.result === OVERLAP_SOME) {
+          removeLineIds.push(i);
+          var lineSegs = getTrimmedContourLineSegs(rst.trimmedSegs, moldingLines.filter(function (v, idx) {
+            return idx !== i && idx !== _j && Math.abs(v.z - moldingLines[i].z) < EPSILON;
+          }), 0);
+          if (lineSegs.length > 0) {
+            lineSegs.forEach(function (ls) {
+              return newLines.push({
+                molding: _objectSpread({}, moldingLines[i].molding),
+                doorStyle: moldingLines[i].doorStyle,
+                line: _toConsumableArray(ls),
+                z: moldingLines[i].z,
+                parentId: moldingLines[i].parentId,
+                inchWidth: moldingLines[i].inchWidth
+              });
+            });
+          }
+          return 1; // break
+        }
+      },
+      _ret4;
+    for (var _j = 0; _j < moldingLines.length; _j++) {
+      _ret4 = _loop1(_j);
+      if (_ret4 === 0) continue;
+      if (_ret4 === 1) break;
+    }
+  };
+  for (var i = 0; i < moldingLines.length; i++) {
+    _loop9(i);
+  }
+  moldingLines = moldingLines.filter(function (line, idx) {
+    return !removeLineIds.some(function (id) {
+      return idx === id;
+    });
+  });
+  if (newLines.length > 0) moldingLines = [].concat(_toConsumableArray(moldingLines), newLines);
+
+  // filter again for toe kick molding lines
+  // only remain one line per toe kick molding item
+  var duplicatedLineIdxs = [];
+  for (var _i4 = 0; _i4 < moldingLines.length; _i4++) {
+    var _iml$molding;
+    if (duplicatedLineIdxs.includes(_i4)) continue;
+    var iml = moldingLines[_i4];
+    if (((_iml$molding = iml.molding) === null || _iml$molding === void 0 ? void 0 : _iml$molding.name) !== TOE_KICK_MOLDING) continue;
+    for (var j = 0; j < moldingLines.length; j++) {
+      if (_i4 === j) continue;
+      var jml = moldingLines[j];
+      if (jml.parentId === iml.parentId) duplicatedLineIdxs.push(j);
+    }
+  }
+  moldingLines = moldingLines.filter(function (line, idx) {
+    return !duplicatedLineIdxs.some(function (id) {
+      return idx === id;
+    });
+  });
+  // console.log('moldingLines: ', moldingLines);
+
+  // make molding data with sorting molding & doorStyle
+  var _loop0 = function _loop0() {
+    var ml = moldingLines[k];
+    var mlLength = ml.molding.name === TOE_KICK_MOLDING ? ml.inchWidth : convert(GeometryUtils.verticesDistance(ml.line[0], ml.line[1])).from('cm').to('in');
+    var idx = moldingData.findIndex(function (v) {
+      var _ml$molding, _v$doorStyle, _ml$doorStyle;
+      return (v === null || v === void 0 ? void 0 : v.name) === ((_ml$molding = ml.molding) === null || _ml$molding === void 0 ? void 0 : _ml$molding.name) && ((_v$doorStyle = v.doorStyle) === null || _v$doorStyle === void 0 ? void 0 : _v$doorStyle.id) === ((_ml$doorStyle = ml.doorStyle) === null || _ml$doorStyle === void 0 ? void 0 : _ml$doorStyle.id);
+    });
+    if (idx < 0) moldingData.push(_objectSpread(_objectSpread({}, ml.molding), {}, {
+      doorStyle: ml.doorStyle,
+      totalLength: mlLength,
+      count: Math.ceil(mlLength * 1.1 / 96)
+    }));else {
+      moldingData[idx].totalLength += mlLength;
+      moldingData[idx].count = Math.ceil(moldingData[idx].totalLength * 1.1 / 96);
+    }
+  };
+  for (var k = 0; k < moldingLines.length; k++) {
+    _loop0();
+  }
+  // console.log('moldingData: ', moldingData);
+
+  return moldingData;
+}
+export function getMoldingDataOfScene(layer, catalog, doorStyle) {
+  var moldingData = [];
+  var items = layer.items.toArray();
+  var moldings = [];
+  // get all moldings info
+  items.forEach(function (itemCat) {
+    var _itemCat$molding;
+    itemCat === null || itemCat === void 0 || (_itemCat$molding = itemCat.molding) === null || _itemCat$molding === void 0 || _itemCat$molding.forEach(function (molding) {
+      if (!moldings.some(function (m) {
+        return m.name === molding.name;
+      })) moldings.push(molding);
+    });
+  });
+
+  // calc normal molding
+  moldings.forEach(function (molding) {
+    var itemGroups = [];
+    var temp_items = [];
+    items.forEach(function (item) {
+      if (item.molding.some(function (mol) {
+        return mol.itemID === molding.itemID;
+      }) && isEnableItemForMolding(layer, item)) {
+        temp_items.push(item);
+      }
+    });
+    if (temp_items.length) {
+      while (temp_items.length > 0) {
+        var itemGroup = [temp_items[0]];
+        var _loop10 = function _loop10(_idx) {
+          if (!itemGroup.some(function (it) {
+            return it.id === temp_items[_idx].id;
+          }) && isItemSnappedGroup(temp_items[_idx], itemGroup)) {
+            itemGroup.push(temp_items[_idx]);
+            _idx = 0;
+          }
+          idx = _idx;
+        };
+        for (var idx = 0; idx < temp_items.length; idx++) {
+          _loop10(idx);
+        }
+        itemGroup.forEach(function (item) {
+          var index = temp_items.findIndex(function (it) {
+            return it.id === item.id;
+          });
+          if (index > -1) {
+            temp_items.splice(index, 1);
+          }
+        });
+        itemGroups.push(itemGroup);
+      }
+      var molding_totalLength = 0;
+      itemGroups.forEach(function (itemgroup) {
+        var allLineRects = GeometryUtils.buildRectFromLines(layer, GeometryUtils.getAllLines(layer));
+        var items = _toConsumableArray(itemgroup);
+        var MGlines = getLinesOfItem(items[0], allLineRects, catalog);
+        items = sortItemsByDistance(items, items[0]);
+        var _loop11 = function _loop11() {
+          var itemLines = getLinesOfItem(items[i], allLineRects, catalog);
+          var temp_MGLines = [];
+          MGlines.forEach(function (line) {
+            var idx = itemLines.findIndex(function (itemLine) {
+              return isLinesOverlapped(line, itemLine);
+            });
+            var curItemLine = itemLines[idx];
+            if (idx > -1) {
+              if (!(GeometryUtils.samePoints(line[0], curItemLine[0]) && GeometryUtils.samePoints(line[1], curItemLine[1]) || GeometryUtils.samePoints(line[0], curItemLine[1]) && GeometryUtils.samePoints(line[1], curItemLine[0]))) {
+                var MGLine = mergeOverlappedLines(line, curItemLine);
+                temp_MGLines.push(MGLine);
+              }
+              itemLines.splice(idx, 1);
+            } else {
+              temp_MGLines.push(line);
+            }
+          });
+          itemLines.forEach(function (itemLine) {
+            return temp_MGLines.push(itemLine);
+          });
+          MGlines = [].concat(temp_MGLines);
+        };
+        for (var i = 1; i < items.length; i++) {
+          _loop11();
+        }
+        MGlines.forEach(function (line) {
+          molding_totalLength += GeometryUtils.verticesDistance(line[0], line[1]);
+        });
+      });
+      molding_totalLength = convert(molding_totalLength).from('cm').to('in');
+      moldingData.push(_objectSpread(_objectSpread({}, molding), {}, {
+        doorStyle: doorStyle,
+        count: Math.ceil(molding_totalLength * 1.1 / 96)
+      }));
+    }
+  });
+
+  // calc toe kick molding
+  var tmp = [];
+  items.forEach(function (item) {
+    if (item.category === 'cabinet' && !item.cabinet_category.toLowerCase().includes('microwave')) {
+      tmp.push(item);
+    }
+  });
+  var tmpMoldingData = [];
+  var toedoorStyles = [];
+  tmp.map(function (item) {
+    var _item$molding2;
+    if (item.layoutpos === BASE_CABINET_LAYOUTPOS && (isEmpty(item.molding) || ((_item$molding2 = item.molding) === null || _item$molding2 === void 0 ? void 0 : _item$molding2.length) < 1 || !isEnableItemForMolding(layer, item))) {
+      var w = item.properties.get('width').get('_length');
+      var wUnit = item.properties.get('width').get('_unit') || 'cm';
+      w = convert(w / 2).from(wUnit).to('cm');
+      var h = item.properties.get('depth').get('_length');
+      var hUnit = item.properties.get('depth').get('_unit') || 'cm';
+      h = convert(h / 2).from(hUnit).to('cm');
+      var outline = null;
+      var element = catalog.elements[item.get('type')];
+      if (!element) element = catalog.elements[returnReplaceableDeepSearchType(item.get('type'))];
+      outline = element.info.outline;
+      var len = 0;
+      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 _iterator5 = _createForOfIteratorHelper(outlinePaths),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var path = _step5.value;
+            var _iterator6 = _createForOfIteratorHelper(path.subPaths),
+              _step6;
+            try {
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                var subPath = _step6.value;
+                outlinePoints = outlinePoints.concat(subPath.getPoints());
+              }
+            } catch (err) {
+              _iterator6.e(err);
+            } finally {
+              _iterator6.f();
+            }
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        var maxX = outlinePoints[0].x,
+          minX = outlinePoints[0].x;
+        var maxY = outlinePoints[0].y,
+          minY = outlinePoints[0].y;
+        outlinePoints.forEach(function (point) {
+          if (point.x > maxX) {
+            maxX = point.x;
+          }
+          if (point.x < minX) {
+            minX = point.x;
+          }
+          if (point.y > maxY) {
+            maxY = point.y;
+          }
+          if (point.y < minY) {
+            minY = point.y;
+          }
+        });
+        outlinePoints.forEach(function (point) {
+          if (GeometryUtils.isPointInRect([{
+            x: minX,
+            y: minY
+          }, {
+            x: minX,
+            y: maxY
+          }, {
+            x: maxX,
+            y: maxY
+          }, {
+            x: maxX,
+            y: minY
+          }], point)) {
+            if (point.x > 10) len += (point.x / outlineWidth - 0.5) * w * 2 + h * 2 - (point.y / outlineHeight - 0.5) * h * 2;
+          }
+        });
+        len = convert(len).from('cm').to('in');
+      } else {
+        w = convert(w * 2).from('cm').to('in');
+        len += w;
+      }
+      var doorIndex = toedoorStyles.findIndex(function (a) {
+        var iDS = item === null || item === void 0 ? void 0 : item.doorStyle;
+        if (!iDS) return false;
+        if (!iDS.hasOwnProperty('id')) {
+          iDS = iDS.toJS();
+        }
+        return a.doorStyle.id === iDS.id && isEqualInstallationType(a.doorStyle, iDS);
+      });
+      if (doorIndex > -1) {
+        toedoorStyles[doorIndex].totalLength += len;
+      } else {
+        toedoorStyles.push({
+          doorStyle: item.doorStyle.hasOwnProperty('id') ? item.doorStyle : item.doorStyle && item.doorStyle.toJS(),
+          totalLength: len
+        });
+      }
+    }
+  });
+  toedoorStyles.forEach(function (doorStyle) {
+    var skuName = getToeKickSKU(doorStyle.doorStyle, catalog);
+    var thumbnail = skuName ? skuName : '';
+    // moldings.forEach(molding => {
+    //   if (
+    //     molding.name ===
+    //     getToeKickSKU(
+    //       doorStyle.doorStyle,
+    //       catalog,
+    //       true
+    //     )
+    //   )
+    //     thumbnail = molding.thumbnail;
+    // });
+
+    doorStyle.totalLength && tmpMoldingData.push({
+      name: TOE_KICK_MOLDING,
+      sku: getToeKickSKU(doorStyle.doorStyle, catalog),
+      thumbnail: thumbnail,
+      category: 'molding',
+      type: 'cabinet',
+      doorStyle: doorStyle.doorStyle,
+      count: Math.ceil(doorStyle.totalLength * 1.1 / 96)
+    });
+  });
+  if (tmpMoldingData.length > 0) moldingData = [].concat(_toConsumableArray(moldingData), tmpMoldingData);
+  return moldingData;
+}