gs-json
Version:
gs-JSON is a domain agnostic unifying 3D file format for geometric and semantic modelling (hence the 'gs').
549 lines (490 loc) • 18.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Model = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _kernel = require("./kernel");
var _enums = require("./enums");
var _attrib_entattrib = require("./attrib_entattrib");
var _attrib_topoattrib = require("./attrib_topoattrib");
var _groups = require("./groups");
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* Model Class
*/
var Model = exports.Model = function () {
/**
* Creates a new model.
* @param
* @return
*/
function Model(data) {
_classCallCheck(this, Model);
this._kernel = new _kernel.Kernel(this, data);
}
// Geom ---------------------------------------------------------------------------------------
/**
* Get the geom objct from the model.
* @return
*/
_createClass(Model, [{
key: "getGeom",
value: function getGeom() {
return this._kernel.getGeom();
}
// Attributes ---------------------------------------------------------------------------------
/**
* Find all attributes in the model for a geom_type.
* @param
* @return
*/
}, {
key: "findAttribs",
value: function findAttribs(geom_type) {
var attribs_data = this._kernel.modelFindAttribs(geom_type);
switch (geom_type) {
case _enums.EGeomType.points:
case _enums.EGeomType.objs:
var ent_attribs = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = attribs_data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var data = _step.value;
ent_attribs.push(new _attrib_entattrib.EntAttrib(this._kernel, data.name, geom_type));
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return ent_attribs;
default:
// topo attribs
var topo_attribs = [];
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = attribs_data[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _data = _step2.value;
topo_attribs.push(new _attrib_topoattrib.TopoAttrib(this._kernel, _data.name, geom_type));
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return topo_attribs;
}
}
/**
* Returns all attributes in the model. A nested array is return containing
* an array of entity attributes, and
* an array of topo attributes
* @param
* @return
*/
}, {
key: "getAllAttribs",
value: function getAllAttribs() {
return [this.getAllEntAttribs(), this.getAllTopoAttribs()];
}
/**
* Returns one entity attribute in the model, or null if it does not exist.
* @param
* @return
*/
}, {
key: "getEntAttrib",
value: function getEntAttrib(name, geom_type) {
if (geom_type !== _enums.EGeomType.points && geom_type !== _enums.EGeomType.objs) {
return null;
}
if (this._kernel.modelHasAttrib(name, geom_type)) {
return new _attrib_entattrib.EntAttrib(this._kernel, name, geom_type);
}
return null;
}
/**
* Returns all entity attributes in the model.
* @param
* @return
*/
}, {
key: "getAllEntAttribs",
value: function getAllEntAttribs() {
var ent_attribs = [];
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = this._kernel.modelGetAllEntAttribs()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var attrib_data = _step3.value;
var geom_type = _enums.mapStringToGeomType.get(attrib_data.geom_type);
ent_attribs.push(new _attrib_entattrib.EntAttrib(this._kernel, attrib_data.name, geom_type));
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return ent_attribs;
}
/**
* Add a new entity attribute to the model.
* If the attribute already exists, then return the existing attribute.
* @param
* @return
*/
}, {
key: "addEntAttrib",
value: function addEntAttrib(name, geom_type, data_type) {
name = name.replace(/\s/g, "_");
if (geom_type !== _enums.EGeomType.points && geom_type !== _enums.EGeomType.objs) {
return null;
}
this._kernel.modelAddAttrib(name, geom_type, data_type);
return this.getEntAttrib(name, geom_type);
}
/**
* Returns one entity attribute in the model, or null if it does not exist.
* @param
* @return
*/
}, {
key: "getTopoAttrib",
value: function getTopoAttrib(name, geom_type) {
if (geom_type === _enums.EGeomType.points || geom_type === _enums.EGeomType.objs) {
return null;
}
if (this._kernel.modelHasAttrib(name, geom_type)) {
return new _attrib_topoattrib.TopoAttrib(this._kernel, name, geom_type);
}
return null;
}
/**
* Returns all topo attributes in the model.
* @param
* @return
*/
}, {
key: "getAllTopoAttribs",
value: function getAllTopoAttribs() {
var topo_attribs = [];
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 = this._kernel.modelGetAllTopoAttribs()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var attrib_data = _step4.value;
var geom_type = _enums.mapStringToGeomType.get(attrib_data.geom_type);
topo_attribs.push(new _attrib_topoattrib.TopoAttrib(this._kernel, attrib_data.name, geom_type));
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
return topo_attribs;
}
/**
* Add a new topo attribute to the model.
* If the attribute already exists, then return the existing attribute.
* @param
* @return
*/
}, {
key: "addTopoAttrib",
value: function addTopoAttrib(name, geom_type, data_type) {
name = name.replace(/\s/g, "_");
if (geom_type === _enums.EGeomType.points || geom_type === _enums.EGeomType.objs) {
return null;
}
this._kernel.modelAddAttrib(name, geom_type, data_type);
return this.getTopoAttrib(name, geom_type);
}
/**
* Delete an attribute from the model. Return ture if successful, false otherwise.
* @param
* @return
*/
}, {
key: "delAttrib",
value: function delAttrib(attrib) {
return this._kernel.modelDelAttrib(attrib.getName(), attrib.getGeomType());
}
/**
* Checks if the model has an attribute.
* @param
* @return
*/
}, {
key: "hasAttrib",
value: function hasAttrib(attrib) {
return this._kernel.modelHasAttrib(attrib.getName(), attrib.getGeomType());
}
/**
* Rename an attribute.
* @param
* @return
*/
}, {
key: "setAttribName",
value: function setAttribName(attrib, new_name) {
return this._kernel.attribSetName(attrib.getName(), new_name, attrib.getGeomType());
}
// Groups -------------------------------------------------------------------------------------
/**
* Get all the groups in a model.
* @param
* @return
*/
}, {
key: "getAllGroups",
value: function getAllGroups() {
var _this = this;
var groups_data = this._kernel.modelGetAllGroups();
return groups_data.map(function (v) {
return new _groups.Group(_this._kernel, v.name);
});
}
/**
* Get one group from the model.
* @param
* @return
*/
}, {
key: "getGroup",
value: function getGroup(name) {
var data = this._kernel.modelGetGroup(name);
if (data === undefined) {
return null;
}
return new _groups.Group(this._kernel, data.name);
}
/**
* Add a group to the model.
* If the parent name is given and does not exist, then an error will be thrown.
* @param
* @return
*/
}, {
key: "addGroup",
value: function addGroup(name, parent) {
if (parent !== undefined) {
this._kernel.modelAddGroup(name, parent.getName());
} else {
this._kernel.modelAddGroup(name);
}
return this.getGroup(name);
}
/**
* Delete a group i the model. Returns true if successful.
* @param
* @return
*/
}, {
key: "delGroup",
value: function delGroup(group) {
return this._kernel.modelDelGroup(group.getName());
}
/**
* Checks if the group exists in the model.
* @param
* @return
*/
}, {
key: "hasGroup",
value: function hasGroup(group) {
return this._kernel.modelHasGroup(group.getName());
}
/**
* Renames the group.
* @param
* @return
*/
}, {
key: "setGroupName",
value: function setGroupName(group, new_name) {
return this._kernel.groupSetName(group.getName(), new_name);
}
// Model --------------------------------------------------------------------------------------
/**
* Removes empty elements in sparse arrays.
* @param
* @return
*/
}, {
key: "purge",
value: function purge() {
this._kernel.modelPurge();
}
/**
* Run some checks
* @param
* @return
*/
}, {
key: "validate",
value: function validate() {
return this._kernel.modelValidate();
}
/**
* Save the model as file
* @param
* @return
*/
}, {
key: "toJSON",
value: function toJSON() {
return this._kernel.modelToJSON();
}
/**
* Save the model as file
* @param
* @return
*/
}, {
key: "toString",
value: function toString() {
var rep = "";
rep += "Num Points:" + this.getGeom().numPoints() + "\n";
rep += "Num Objects:" + this.getGeom().numObjs() + "\n";
var _iteratorNormalCompletion5 = true;
var _didIteratorError5 = false;
var _iteratorError5 = undefined;
try {
for (var _iterator5 = this.getGeom().getAllObjs()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
var obj = _step5.value;
rep += " " + obj.toString() + "\n";
}
} catch (err) {
_didIteratorError5 = true;
_iteratorError5 = err;
} finally {
try {
if (!_iteratorNormalCompletion5 && _iterator5.return) {
_iterator5.return();
}
} finally {
if (_didIteratorError5) {
throw _iteratorError5;
}
}
}
var attribs = this.getAllAttribs();
rep += "Num Entity Attribs:" + attribs[0].length + "\n";
var _iteratorNormalCompletion6 = true;
var _didIteratorError6 = false;
var _iteratorError6 = undefined;
try {
for (var _iterator6 = attribs[0][Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
var attrib = _step6.value;
rep += " " + attrib.toString() + "\n";
}
} catch (err) {
_didIteratorError6 = true;
_iteratorError6 = err;
} finally {
try {
if (!_iteratorNormalCompletion6 && _iterator6.return) {
_iterator6.return();
}
} finally {
if (_didIteratorError6) {
throw _iteratorError6;
}
}
}
rep += "Num Topo Attribs:" + attribs[1].length + "\n";
var _iteratorNormalCompletion7 = true;
var _didIteratorError7 = false;
var _iteratorError7 = undefined;
try {
for (var _iterator7 = attribs[1][Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
var _attrib = _step7.value;
rep += " " + _attrib.toString() + "\n";
}
} catch (err) {
_didIteratorError7 = true;
_iteratorError7 = err;
} finally {
try {
if (!_iteratorNormalCompletion7 && _iterator7.return) {
_iterator7.return();
}
} finally {
if (_didIteratorError7) {
throw _iteratorError7;
}
}
}
var groups = this.getAllGroups();
rep += "Num Groups:" + groups.length + "\n";
var _iteratorNormalCompletion8 = true;
var _didIteratorError8 = false;
var _iteratorError8 = undefined;
try {
for (var _iterator8 = groups[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
var group = _step8.value;
rep += " " + group.toString() + "\n";
}
} catch (err) {
_didIteratorError8 = true;
_iteratorError8 = err;
} finally {
try {
if (!_iteratorNormalCompletion8 && _iterator8.return) {
_iterator8.return();
}
} finally {
if (_didIteratorError8) {
throw _iteratorError8;
}
}
}
return rep;
}
}]);
return Model;
}();
//# sourceMappingURL=model.js.map