gs-json
Version:
gs-JSON is a domain agnostic unifying 3D file format for geometric and semantic modelling (hence the 'gs').
537 lines (495 loc) • 20.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
exports.getPointsFromObjs = getPointsFromObjs;
exports.getDataFromAllFaces = getDataFromAllFaces;
exports.getDataFromAllWires = getDataFromAllWires;
exports.getDataFromAllEdges = getDataFromAllEdges;
exports.getDataFromAllVertices = getDataFromAllVertices;
exports.getDataAllOtherLines = getDataAllOtherLines;
exports.getDataFromAllPoints = getDataFromAllPoints;
var _three = require("three");
var three = _interopRequireWildcard(_three);
var _arr2 = require("../libs/arr/arr");
var arr = _interopRequireWildcard(_arr2);
var _threex = require("../libs/threex/threex");
var threex = _interopRequireWildcard(_threex);
var _circles = require("../libs/conics/circles");
var math_conics = _interopRequireWildcard(_circles);
var _triangulate = require("../libs/triangulate/triangulate");
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
/**
* Get the points for the obj
*/
function getPointsFromObjs(objs) {
var points_set = new Set();
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = objs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var obj = _step.value;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = obj.getPointsSet()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var point = _step2.value;
points_set.add(point);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var points = Array.from(points_set);
// create xyzs arr.Array
var xyzs = points.map(function (v) {
return v.getPosition();
});
// create map from point IDs to index number
var id_map = new Map();
points.forEach(function (point, i) {
return id_map.set(point.getID(), i);
});
// create a map from index to face path
return { xyzs: xyzs, id_map: id_map };
}
// FACES ====================================================================================================
/**
* Get mesh data from multiple objs.
*/
function getDataFromAllFaces(objs) {
// filter
var objs_filtered = objs.filter(function (obj) {
return obj.getObjType() === 200;
} /* polymesh */);
// get the points
var points = getPointsFromObjs(objs_filtered);
// create a map from index to face path
var reverse_map = new Map();
// get the faces
var faces = arr.Arr.flatten(objs_filtered.map(function (obj) {
return obj.getFaces();
}));
// create triangles data
var traingles = [];
var tri_count = 0;
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = faces[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var face = _step3.value;
var verts = face.getVertices();
var verts_indexes = verts.map(function (v) {
return points.id_map.get(v.getPoint().getID());
});
if (verts.length === 3) {
traingles.push(verts_indexes);
reverse_map.set(tri_count, face.getTopoPath());
tri_count++;
} else if (verts.length > 3) {
var verts_tri = (0, _triangulate.triangulate2D)(verts, verts_indexes);
traingles.push(verts_tri);
for (var i = 0; i < verts_tri.length - 2; i = i + 3) {
reverse_map.set(tri_count, face.getTopoPath());
tri_count++;
}
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return { xyzs_flat: arr.Arr.flatten(points.xyzs), indexes: arr.Arr.flatten(traingles), reverse_map: reverse_map };
}
// WIRES ====================================================================================================
/**
* Get line segments data from wires.
*/
function getDataFromAllWires(objs) {
// filter
var objs_filtered = objs.filter(function (obj) {
return obj.getObjType() === 200 /* polymesh */ || obj.getObjType() === 100;
} /* polyline */);
// get the wires
var wires = arr.Arr.flatten(objs_filtered.map(function (obj) {
return obj.getWires();
}));
if (wires.length === 0) {
return null;
}
var points = getPointsFromObjs(objs_filtered);
// create a map from index to wire path
var reverse_map = new Map();
// create line segments
var indexes = [];
var seg_count = 0;
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 = wires[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var wire = _step4.value;
var path = wire.getTopoPath();
var _iteratorNormalCompletion5 = true;
var _didIteratorError5 = false;
var _iteratorError5 = undefined;
try {
for (var _iterator5 = wire.getEdges()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
var edge = _step5.value;
var verts = edge.getVertices();
var verts_indexes = verts.map(function (v) {
return points.id_map.get(v.getPoint().getID());
});
indexes.push(verts_indexes);
reverse_map.set(seg_count, path);
seg_count++;
}
} catch (err) {
_didIteratorError5 = true;
_iteratorError5 = err;
} finally {
try {
if (!_iteratorNormalCompletion5 && _iterator5.return) {
_iterator5.return();
}
} finally {
if (_didIteratorError5) {
throw _iteratorError5;
}
}
}
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
return { xyzs_flat: arr.Arr.flatten(points.xyzs), indexes: arr.Arr.flatten(indexes), reverse_map: reverse_map };
}
// EDGES ====================================================================================================
/**
* Get line segment data from edges.
*/
function getDataFromAllEdges(objs) {
// filter
var objs_filtered = objs.filter(function (obj) {
return obj.getObjType() === 200 /* polymesh */ || obj.getObjType() === 100;
} /* polyline */);
// get the points
var edges = arr.Arr.flatten(objs_filtered.map(function (obj) {
return obj.getEdges();
}));
if (edges.length === 0) {
return null;
}
var points = getPointsFromObjs(objs_filtered);
// create a map from index to edge path
var reverse_map = new Map();
// create line segments
var indexes = [];
var _iteratorNormalCompletion6 = true;
var _didIteratorError6 = false;
var _iteratorError6 = undefined;
try {
for (var _iterator6 = edges.entries()[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
var _step6$value = _slicedToArray(_step6.value, 2),
i = _step6$value[0],
edge = _step6$value[1];
var verts = edge.getVertices();
var verts_indexes = verts.map(function (v) {
return points.id_map.get(v.getPoint().getID());
});
indexes.push(verts_indexes);
reverse_map.set(i, edge.getTopoPath());
}
} catch (err) {
_didIteratorError6 = true;
_iteratorError6 = err;
} finally {
try {
if (!_iteratorNormalCompletion6 && _iterator6.return) {
_iterator6.return();
}
} finally {
if (_didIteratorError6) {
throw _iteratorError6;
}
}
}
return { xyzs_flat: arr.Arr.flatten(points.xyzs), indexes: arr.Arr.flatten(indexes), reverse_map: reverse_map };
}
// VERTICES ====================================================================================================
/**
* Get vertex data.
*/
function getDataFromAllVertices(objs) {
// filter, no need
// get the points
var vertices = arr.Arr.flatten(objs.map(function (obj) {
return obj.getVertices();
}));
if (vertices.length === 0) {
return null;
}
var points = getPointsFromObjs(objs);
// create a map from index to vertex path
var reverse_map = new Map();
// create points
var indexes = [];
var _iteratorNormalCompletion7 = true;
var _didIteratorError7 = false;
var _iteratorError7 = undefined;
try {
for (var _iterator7 = vertices.entries()[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
var _step7$value = _slicedToArray(_step7.value, 2),
i = _step7$value[0],
vertex = _step7$value[1];
var vert_index = points.id_map.get(vertex.getPoint().getID());
indexes.push(vert_index);
reverse_map.set(i, vertex.getTopoPath());
}
// return the data
} catch (err) {
_didIteratorError7 = true;
_iteratorError7 = err;
} finally {
try {
if (!_iteratorNormalCompletion7 && _iterator7.return) {
_iterator7.return();
}
} finally {
if (_didIteratorError7) {
throw _iteratorError7;
}
}
}
return { xyzs_flat: arr.Arr.flatten(points.xyzs), indexes: indexes, reverse_map: reverse_map };
}
// OTHERS ====================================================================================================
/**
* Get vertex data.
*/
function getDataAllOtherLines(objs) {
// filter
//const objs_filtered: Array<gs.IRay|gs.IPlane|gs.ICircle> = objs.filter((obj) =>
var objs_filtered = objs.filter(function (obj) {
return obj.getObjType() === 1 /* ray */ || obj.getObjType() === 2 /* plane */ || obj.getObjType() === 3;
} /* circle */);
// create points
var indexes = [];
var xyzs = [];
var index_counter = 0;
var _iteratorNormalCompletion8 = true;
var _didIteratorError8 = false;
var _iteratorError8 = undefined;
try {
for (var _iterator8 = objs_filtered.entries()[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
var _step8$value = _slicedToArray(_step8.value, 2),
i = _step8$value[0],
obj = _step8$value[1];
switch (obj.getObjType()) {
case 1 /* ray */:
var ray = obj;
var ray_line = _renderRay(ray);
xyzs.push(ray_line);
indexes.push(index_counter);
index_counter++;
indexes.push(index_counter);
index_counter++;
break;
case 2 /* plane */:
var plane = obj;
var p_faces = _renderPlane(plane);
var _iteratorNormalCompletion9 = true;
var _didIteratorError9 = false;
var _iteratorError9 = undefined;
try {
for (var _iterator9 = p_faces[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
var face = _step9.value;
xyzs.push(face);
for (var j = 0; j < face.length - 1; j++) {
indexes.push(index_counter);
indexes.push(++index_counter);
}
index_counter++;
}
} catch (err) {
_didIteratorError9 = true;
_iteratorError9 = err;
} finally {
try {
if (!_iteratorNormalCompletion9 && _iterator9.return) {
_iterator9.return();
}
} finally {
if (_didIteratorError9) {
throw _iteratorError9;
}
}
}
break;
case 3 /* circle */:
var obj_render_xyzs = math_conics.getRenderXYZs(obj, 1);
xyzs.push(obj_render_xyzs);
for (var _j = 0; _j < obj_render_xyzs.length - 1; _j++) {
indexes.push(index_counter);
indexes.push(++index_counter);
}
index_counter++;
break;
default:
// code...
break;
}
}
// return the data
} catch (err) {
_didIteratorError8 = true;
_iteratorError8 = err;
} finally {
try {
if (!_iteratorNormalCompletion8 && _iterator8.return) {
_iterator8.return();
}
} finally {
if (_didIteratorError8) {
throw _iteratorError8;
}
}
}
var xyzs_flat = arr.Arr.flatten(xyzs);
return { xyzs_flat: xyzs_flat, indexes: indexes, reverse_map: null };
}
function _renderRay(ray) {
var r_origin = ray.getOrigin().getPosition();
var r_origin_vec = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(r_origin))))();
var r_dir = ray.getVector();
var r_dir_vec = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(r_dir))))();
r_dir_vec.setLength(100);
var r_end = threex.addVectors(r_origin_vec, r_dir_vec).toArray();
return [r_origin, r_end];
}
function _renderPlane(plane) {
var p_origin = plane.getOrigin().getPosition();
var p_origin_vec = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p_origin))))();
var p_axes = plane.getAxes();
var x_axis = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p_axes[0]))))();
x_axis.setLength(10);
var y_axis = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p_axes[1]))))();
y_axis.setLength(10);
var f1_1 = threex.addVectors(p_origin_vec, x_axis);
var f1_2 = threex.addVectors(f1_1, y_axis);
var f1_3 = threex.addVectors(p_origin_vec, y_axis);
var f1 = [p_origin_vec, f1_1, f1_2, f1_3].map(function (v) {
return v.toArray();
});
var f2_1 = threex.addVectors(p_origin_vec, y_axis);
var f2_2 = threex.subVectors(f2_1, x_axis);
var f2_3 = threex.subVectors(p_origin_vec, x_axis);
var f2 = [p_origin_vec, f2_1, f2_2, f2_3].map(function (v) {
return v.toArray();
});
var f3_1 = threex.subVectors(p_origin_vec, x_axis);
var f3_2 = threex.subVectors(f3_1, y_axis);
var f3_3 = threex.subVectors(p_origin_vec, y_axis);
var f3 = [p_origin_vec, f3_1, f3_2, f3_3].map(function (v) {
return v.toArray();
});
var f4_1 = threex.subVectors(p_origin_vec, y_axis);
var f4_2 = threex.addVectors(f4_1, x_axis);
var f4_3 = threex.addVectors(p_origin_vec, x_axis);
var f4 = [p_origin_vec, f4_1, f4_2, f4_3].map(function (v) {
return v.toArray();
});
var p_faces = [f1, f2, f3, f4];
return p_faces;
}
// POINTS ====================================================================================================
/**
* Get point data.
*/
function getDataFromAllPoints(points) {
// create a map from index to vertex path
var reverse_map = new Map();
// create points
var indexes = [];
var xyzs = [];
var _iteratorNormalCompletion10 = true;
var _didIteratorError10 = false;
var _iteratorError10 = undefined;
try {
for (var _iterator10 = points.entries()[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
var _step10$value = _slicedToArray(_step10.value, 2),
i = _step10$value[0],
point = _step10$value[1];
xyzs.push(point.getPosition());
indexes.push(i);
reverse_map.set(i, point.getID());
}
// return the data
} catch (err) {
_didIteratorError10 = true;
_iteratorError10 = err;
} finally {
try {
if (!_iteratorNormalCompletion10 && _iterator10.return) {
_iterator10.return();
}
} finally {
if (_didIteratorError10) {
throw _iteratorError10;
}
}
}
return { xyzs_flat: arr.Arr.flatten(xyzs), indexes: indexes, reverse_map: reverse_map };
}
//# sourceMappingURL=three_geom.js.map