160 lines
5.9 KiB
JavaScript
160 lines
5.9 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _lodash = require("lodash");
|
|
|
|
var _logger = _interopRequireDefault(require("./util/logger"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
var _default = function _default(parseResult) {
|
|
var blocksByName = parseResult.blocks.reduce(function (acc, b) {
|
|
acc[b.name] = b;
|
|
return acc;
|
|
}, {});
|
|
|
|
var gatherEntities = function gatherEntities(entities, transforms) {
|
|
var current = [];
|
|
entities.forEach(function (e) {
|
|
if (e.type === 'INSERT') {
|
|
var _ret = function () {
|
|
var _insert$rowCount, _insert$columnCount, _insert$rowSpacing, _insert$columnSpacing, _insert$rotation;
|
|
|
|
var insert = e;
|
|
var block = blocksByName[insert.block];
|
|
|
|
if (!block) {
|
|
_logger["default"].error('no block found for insert. block:', insert.block);
|
|
|
|
return {
|
|
v: void 0
|
|
};
|
|
}
|
|
|
|
var rowCount = (_insert$rowCount = insert.rowCount) !== null && _insert$rowCount !== void 0 ? _insert$rowCount : 1;
|
|
var columnCount = (_insert$columnCount = insert.columnCount) !== null && _insert$columnCount !== void 0 ? _insert$columnCount : 1;
|
|
var rowSpacing = (_insert$rowSpacing = insert.rowSpacing) !== null && _insert$rowSpacing !== void 0 ? _insert$rowSpacing : 0;
|
|
var columnSpacing = (_insert$columnSpacing = insert.columnSpacing) !== null && _insert$columnSpacing !== void 0 ? _insert$columnSpacing : 0;
|
|
var rotation = (_insert$rotation = insert.rotation) !== null && _insert$rotation !== void 0 ? _insert$rotation : 0; // It appears that the rectangular array is affected by rotation, but NOT by scale.
|
|
|
|
var rowVec, colVec;
|
|
|
|
if (rowCount > 1 || columnCount > 1) {
|
|
var cos = Math.cos(rotation * Math.PI / 180);
|
|
var sin = Math.sin(rotation * Math.PI / 180);
|
|
rowVec = {
|
|
x: -sin * rowSpacing,
|
|
y: cos * rowSpacing
|
|
};
|
|
colVec = {
|
|
x: cos * columnSpacing,
|
|
y: sin * columnSpacing
|
|
};
|
|
} else {
|
|
rowVec = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
colVec = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
} // For rectangular arrays, add the block entities for each location in the array
|
|
|
|
|
|
for (var r = 0; r < rowCount; r++) {
|
|
for (var c = 0; c < columnCount; c++) {
|
|
// Adjust insert transform by row and column for rectangular arrays
|
|
var t = {
|
|
x: insert.x + rowVec.x * r + colVec.x * c,
|
|
y: insert.y + rowVec.y * r + colVec.y * c,
|
|
scaleX: insert.scaleX,
|
|
scaleY: insert.scaleY,
|
|
scaleZ: insert.scaleZ,
|
|
extrusionX: insert.extrusionX,
|
|
extrusionY: insert.extrusionY,
|
|
extrusionZ: insert.extrusionZ,
|
|
rotation: insert.rotation
|
|
}; // Add the insert transform and recursively add entities
|
|
|
|
var transforms2 = transforms.slice(0);
|
|
transforms2.push(t); // Use the insert layer
|
|
|
|
var blockEntities = block.entities.map(function (be) {
|
|
var be2 = (0, _lodash.cloneDeep)(be);
|
|
be2.layer = insert.layer; // https://github.com/bjnortier/dxf/issues/52
|
|
// See Issue 52. If we don't modify the
|
|
// entity coordinates here it creates an issue with the
|
|
// transformation matrices (which are only applied AFTER
|
|
// block insertion modifications has been applied).
|
|
|
|
switch (be2.type) {
|
|
case 'LINE':
|
|
{
|
|
be2.start.x -= block.x;
|
|
be2.start.y -= block.y;
|
|
be2.end.x -= block.x;
|
|
be2.end.y -= block.y;
|
|
break;
|
|
}
|
|
|
|
case 'LWPOLYLINE':
|
|
case 'POLYLINE':
|
|
{
|
|
be2.vertices.forEach(function (v) {
|
|
v.x -= block.x;
|
|
v.y -= block.y;
|
|
});
|
|
break;
|
|
}
|
|
|
|
case 'CIRCLE':
|
|
case 'ELLIPSE':
|
|
case 'ARC':
|
|
{
|
|
be2.x -= block.x;
|
|
be2.y -= block.y;
|
|
break;
|
|
}
|
|
|
|
case 'SPLINE':
|
|
{
|
|
be2.controlPoints.forEach(function (cp) {
|
|
cp.x -= block.x;
|
|
cp.y -= block.y;
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
return be2;
|
|
});
|
|
current = current.concat(gatherEntities(blockEntities, transforms2));
|
|
}
|
|
}
|
|
}();
|
|
|
|
if (_typeof(_ret) === "object") return _ret.v;
|
|
} else {
|
|
// Top-level entity. Clone and add the transforms
|
|
// The transforms are reversed so they occur in
|
|
// order of application - i.e. the transform of the
|
|
// top-level insert is applied last
|
|
var e2 = (0, _lodash.cloneDeep)(e);
|
|
e2.transforms = transforms.slice().reverse();
|
|
current.push(e2);
|
|
}
|
|
});
|
|
return current;
|
|
};
|
|
|
|
return gatherEntities(parseResult.entities, []);
|
|
};
|
|
|
|
exports["default"] = _default; |