csyjk 1.1.1 → 1.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/metadata/MetaModel.js

@@ -0,0 +1,145 @@
+/**
+ * @desc Metadata corresponding to an {@link Entity} that represents a model.
+ *
+ * An {@link Entity} represents a model when {@link Entity#isModel} is ````true````
+ *
+ * A MetaModel corresponds to an {@link Entity} by having the same {@link MetaModel#id} as the {@link Entity#id}.
+ *
+ * A MetaModel is created by {@link MetaScene#createMetaModel} and belongs to a {@link MetaScene}.
+ *
+ * Each MetaModel is registered by {@link MetaModel#id} in {@link MetaScene#metaModels}.
+ *
+ * A {@link MetaModel} represents its object structure with a tree of {@link MetaObject}s, with {@link MetaModel#rootMetaObject} referencing the root {@link MetaObject}.
+ *
+ * @class MetaModel
+ */
+class MetaModel {
+
+    /**
+     * @private
+     */
+    constructor(metaScene, id, projectId, revisionId, author, createdAt, creatingApplication, schema, rootMetaObject) {
+
+        /**
+         * Globally-unique ID.
+         *
+         * MetaModels are registered by ID in {@link MetaScene#metaModels}.
+         *
+         * When this MetaModel corresponds to an {@link Entity} then this ID will match the {@link Entity#id}.
+         *
+         * @property id
+         * @type {String|Number}
+         */
+        this.id = id;
+
+        /**
+         * The project ID
+         * @property projectId
+         * @type {String|Number}
+         */
+        this.projectId = projectId;
+
+        /**
+         * The revision ID, if available.
+         *
+         * Will be undefined if not available.
+         *
+         * @property revisionId
+         * @type {String|Number}
+         */
+        this.revisionId = revisionId;
+
+        /**
+         * The model author, if available.
+         *
+         * Will be undefined if not available.
+         *
+         * @property author
+         * @type {String}
+         */
+        this.author = author;
+
+        /**
+         * The date the model was created, if available.
+         *
+         * Will be undefined if not available.
+         *
+         * @property createdAt
+         * @type {String}
+         */
+        this.createdAt = createdAt;
+
+        /**
+         * The application that created the model, if available.
+         *
+         * Will be undefined if not available.
+         *
+         * @property creatingApplication
+         * @type {String}
+         */
+        this.creatingApplication = creatingApplication;
+
+        /**
+         * The model schema version, if available.
+         *
+         * Will be undefined if not available.
+         *
+         * @property schema
+         * @type {String}
+         */
+        this.schema = schema;
+
+        /**
+         * Metadata on the {@link Scene}.
+         *
+         * @property metaScene
+         * @type {MetaScene}
+         */
+        this.metaScene = metaScene;
+
+        /**
+         * The root {@link MetaObject} in this MetaModel's composition structure hierarchy.
+         *
+         * @property rootMetaObject
+         * @type {MetaObject}
+         */
+        this.rootMetaObject = rootMetaObject;
+    }
+
+    getJSON() {
+
+        var metaObjects = [];
+
+        function visit(metaObject) {
+            var metaObjectCfg = {
+                id: metaObject.id,
+                extId: metaObject.extId,
+                type: metaObject.type,
+                name: metaObject.name
+            };
+            if (metaObject.parent) {
+                metaObjectCfg.parent = metaObject.parent.id;
+            }
+            metaObjects.push(metaObjectCfg);
+            var children = metaObject.children;
+            if (children) {
+                for (var i = 0, len = children.length; i < len; i++) {
+                    visit(children[i]);
+                }
+            }
+        }
+
+        visit(this.rootMetaObject);
+
+        var json = {
+            id: this.id,
+            projectId: this.projectId,
+            revisionId: this.revisionId,
+            metaObjects: metaObjects
+        };
+        return json;
+    }
+}
+
+
+export {MetaModel};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/metadata/MetaObject.js

@@ -0,0 +1,215 @@
+/**
+ * @desc Metadata corresponding to an {@link Entity} that represents an object.
+ *
+ * An {@link Entity} represents an object when {@link Entity#isObject} is ````true````
+ *
+ * A MetaObject corresponds to an {@link Entity} by having the same {@link MetaObject#id} as the {@link Entity#id}.
+ *
+ * A MetaObject is created within {@link MetaScene#createMetaModel} and belongs to a {@link MetaModel}.
+ *
+ * Each MetaObject is registered by {@link MetaObject#id} in {@link MetaScene#metaObjects}.
+ *
+ * A {@link MetaModel} represents its object structure with a tree of MetaObjects, with {@link MetaModel#rootMetaObject} referencing
+ * the root MetaObject.
+ *
+ * @class MetaObject
+ */
+class MetaObject {
+
+    constructor(metaModel, id, originalSystemId, name, type, properties, parent, children, external) {
+
+        /**
+         * Model metadata.
+         *
+         * @property metaModel
+         * @type {MetaModel}
+         */
+        this.metaModel = metaModel;
+
+        /**
+         * Globally-unique ID.
+         *
+         * MetaObject instances are registered by this ID in {@link MetaScene#metaObjects}.
+         *
+         * @property id
+         * @type {String|Number}
+         */
+        this.id = id;
+
+        /**
+         * ID of the corresponding object within the originating system, if any.
+         *
+         * @type {String}
+         * @abstract
+         */
+        this.originalSystemId = originalSystemId;
+
+        /**
+         * Human-readable name.
+         *
+         * @property name
+         * @type {String}
+         */
+        this.name = name;
+
+        /**
+         * Type - often an IFC product type.
+         *
+         * @property type
+         * @type {String}
+         */
+        this.type = type;
+
+        if (properties) {
+
+            /**
+             * Arbitrary metadata properties.
+             *
+             * Undefined when no metadata properties are represented.
+             *
+             * @property properties
+             * @type {*}
+             */
+            this.properties = properties;
+        }
+
+        if (parent !== undefined && parent !== null) {
+
+            /**
+             * The parent MetaObject within the structure hierarchy.
+             *
+             * Undefined when this is the root of its structure.
+             *
+             * @property parent
+             * @type {MetaObject}
+             */
+            this.parent = parent;
+        }
+
+        if (children !== undefined && children !== null) {
+
+            /**
+             * Child ObjectMeta instances within the structure hierarchy.
+             *
+             * Undefined when there are no children.
+             *
+             * @property children
+             * @type {Array}
+             */
+            this.children = children;
+        }
+
+        if (external !== undefined && external !== null) {
+
+            /**
+             * External application-specific metadata
+             *
+             * Undefined when there are is no external application-specific metadata.
+             *
+             * @property external
+             * @type {*}
+             */
+            this.external = external;
+        }
+    }
+
+    /**
+     * Gets the {@link MetaObject#id}s of the {@link MetaObject}s within the subtree.
+     *
+     * @returns {String[]} Array of {@link MetaObject#id}s.
+     */
+    getObjectIDsInSubtree() {
+        const objectIds = [];
+
+        function visit(metaObject) {
+            if (!metaObject) {
+                return;
+            }
+            objectIds.push(metaObject.id);
+            const children = metaObject.children;
+            if (children) {
+                for (var i = 0, len = children.length; i < len; i++) {
+                    visit(children[i]);
+                }
+            }
+        }
+
+        visit(this);
+        return objectIds;
+    }
+
+
+    /**
+     * Iterates over the {@link MetaObject}s within the subtree.
+     *
+     * @param {Function} callback Callback fired at each {@link MetaObject}.
+     */
+    withMetaObjectsInSubtree(callback) {
+
+        function visit(metaObject) {
+            if (!metaObject) {
+                return;
+            }
+            callback(metaObject);
+            const children = metaObject.children;
+            if (children) {
+                for (var i = 0, len = children.length; i < len; i++) {
+                    visit(children[i]);
+                }
+            }
+        }
+
+        visit(this);
+    }
+
+    /**
+     * Gets the {@link MetaObject#id}s of the {@link MetaObject}s within the subtree that have the given {@link MetaObject#type}s.
+     *
+     * @param {String[]} types {@link MetaObject#type} values.
+     * @returns {String[]} Array of {@link MetaObject#id}s.
+     */
+    getObjectIDsInSubtreeByType(types) {
+        const mask = {};
+        for (var i = 0, len = types.length; i < len; i++) {
+            mask[types[i]] = types[i];
+        }
+        const objectIds = [];
+
+        function visit(metaObject) {
+            if (!metaObject) {
+                return;
+            }
+            if (mask[metaObject.type]) {
+                objectIds.push(metaObject.id);
+            }
+            const children = metaObject.children;
+            if (children) {
+                for (var i = 0, len = children.length; i < len; i++) {
+                    visit(children[i]);
+                }
+            }
+        }
+
+        visit(this);
+        return objectIds;
+    }
+
+    /**
+     * Returns properties of this MeteObject as JSON.
+     *
+     * @returns {{id: (String|Number), type: String, name: String, parent: (String|Number|Undefined)}}
+     */
+    getJSON() {
+        var json = {
+            id: this.id,
+            type: this.type,
+            name: this.name
+        };
+        if (this.parent) {
+            json.parent = this.parent.id
+        }
+        return json;
+    }
+}
+
+export {MetaObject};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/metadata/MetaScene.js

@@ -0,0 +1,311 @@
+import {MetaModel} from "./MetaModel.js";
+import {MetaObject} from "./MetaObject.js";
+import {math} from "../scene/math/math.js";
+
+/**
+ * @desc Metadata corresponding to a {@link Scene}.
+ *
+ * * Located in {@link Viewer#metaScene}.
+ * * Contains {@link MetaModel}s and {@link MetaObject}s.
+ * * [Scene Graphs user guide](https://github.com/yjkkit/yjkkit-sdk/wiki/Scene-Graphs)
+ * * [Scene graph example with metadata](http://yjkkit.github.io/yjkkit-sdk/examples/#sceneRepresentation_SceneGraph_metadata)
+ */
+class MetaScene {
+
+    /**
+     * @private
+     */
+    constructor(viewer, scene) {
+
+        /**
+         * The {@link Viewer}.
+         * @property viewer
+         * @type {Viewer}
+         */
+        this.viewer = viewer;
+
+        /**
+         * The {@link Scene}.
+         * @property scene
+         * @type {Scene}
+         */
+        this.scene = scene;
+
+        /**
+         * The {@link MetaModel}s belonging to this MetaScene, each mapped to its {@link MetaModel#modelId}.
+         *
+         * @type {{String:MetaModel}}
+         */
+        this.metaModels = {};
+
+        /**
+         * The {@link MetaObject}s belonging to this MetaScene, each mapped to its {@link MetaObject#id}.
+         *
+         * @type {{String:MetaObject}}
+         */
+        this.metaObjects = {};
+
+        /**
+         * The {@link MetaObject}s belonging to this MetaScene, each mapped to its {@link MetaObject#type}.
+         *
+         * @type {{String:MetaObject}}
+         */
+        this.metaObjectsByType = {};
+
+        /**
+         * Tracks number of MetaObjects of each type.
+         * @private
+         */
+        this._typeCounts = {};
+
+        /**
+         * Subscriptions to events sent with {@link fire}.
+         * @private
+         */
+        this._eventSubs = {};
+    }
+
+    /**
+     * Subscribes to an event fired at this Viewer.
+     *
+     * @param {String} event The event
+     * @param {Function} callback Callback fired on the event
+     */
+    on(event, callback) {
+        let subs = this._eventSubs[event];
+        if (!subs) {
+            subs = [];
+            this._eventSubs[event] = subs;
+        }
+        subs.push(callback);
+    }
+
+    /**
+     * Fires an event at this Viewer.
+     *
+     * @param {String} event Event name
+     * @param {Object} value Event parameters
+     */
+    fire(event, value) {
+        const subs = this._eventSubs[event];
+        if (subs) {
+            for (let i = 0, len = subs.length; i < len; i++) {
+                subs[i](value);
+            }
+        }
+    }
+
+    /**
+     * Unsubscribes from an event fired at this Viewer.
+     * @param event
+     */
+    off(event) { // TODO
+
+    }
+
+    /**
+     * Creates a {@link MetaModel} in this MetaScene.
+     *
+     * @param {String} modelId ID for the new {@link MetaModel}, which will have {@link MetaModel#id} set to this value.
+     * @param {Object} metaModelData Data for the {@link MetaModel}.
+     * @param {Object} [options] Options for creating the {@link MetaModel}.
+     * @param {Object} [options.includeTypes] When provided, only create {@link MetaObject}s with types in this list.
+     * @param {Object} [options.excludeTypes] When provided, never create {@link MetaObject}s with types in this list.
+     * @param {Boolean} [options.globalizeObjectIds=false] Whether to globalize each {@link MetaObject#id}. Set this ````true```` when you need to load multiple instances of the same meta model, to avoid ID clashes between the meta objects in the different instances.
+     * @returns {MetaModel} The new MetaModel.
+     */
+    createMetaModel(modelId, metaModelData, options = {}) {
+
+        const projectId = metaModelData.projectId || "none";
+        const revisionId = metaModelData.revisionId || "none";
+        const newObjects = metaModelData.metaObjects;
+        const author = metaModelData.author;
+        const createdAt = metaModelData.createdAt;
+        const creatingApplication = metaModelData.creatingApplication;
+        const schema = metaModelData.schema;
+
+        var includeTypes;
+        // if (options.includeTypes) {
+        //     includeTypes = {};
+        //     for (let i = 0, len = options.includeTypes.length; i < len; i++) {
+        //         includeTypes[options.includeTypes[i]] = true;
+        //     }
+        // }
+        //
+        var excludeTypes;
+        // if (options.excludeTypes) {
+        //     excludeTypes = {};
+        //     for (let i = 0, len = options.excludeTypes.length; i < len; i++) {
+        //         includeTypes[options.excludeTypes[i]] = true;
+        //     }
+        // }
+
+        const metaModel = new MetaModel(this, modelId, projectId, revisionId, author, createdAt, creatingApplication, schema, null);
+
+        this.metaModels[modelId] = metaModel;
+
+        for (let i = 0, len = newObjects.length; i < len; i++) {
+            const newObject = newObjects[i];
+            const type = newObject.type;
+            if (excludeTypes && excludeTypes[type]) {
+                continue;
+            }
+            if (includeTypes && !includeTypes[type]) {
+                continue;
+            }
+            const objectId = options.globalizeObjectIds ? math.globalizeObjectId(modelId, newObject.id) : newObject.id;
+            const originalSystemId = newObject.id;
+            const name = newObject.name;
+            const properties = newObject.properties;
+            const parent = null;
+            const children = null;
+            const external = newObject.external;
+            const metaObject = new MetaObject(metaModel, objectId, originalSystemId, name, type, properties, parent, children, external);
+            this.metaObjects[objectId] = metaObject;
+            (this.metaObjectsByType[type] || (this.metaObjectsByType[type] = {}))[objectId] = metaObject;
+            if (this._typeCounts[type] === undefined) {
+                this._typeCounts[type] = 1;
+            } else {
+                this._typeCounts[type]++;
+            }
+        }
+
+        for (let i = 0, len = newObjects.length; i < len; i++) {
+            const newObject = newObjects[i];
+            const objectId = options.globalizeObjectIds ? math.globalizeObjectId(modelId, newObject.id) : newObject.id;
+            const metaObject = this.metaObjects[objectId];
+            if (!metaObject) {
+                continue;
+            }
+            if (newObject.parent === undefined || newObject.parent === null) {
+                metaModel.rootMetaObject = metaObject;
+            } else if (newObject.parent) {
+                const parentId = options.globalizeObjectIds ? math.globalizeObjectId(modelId, newObject.parent) : newObject.parent;
+                let parentMetaObject = this.metaObjects[parentId];
+                if (parentMetaObject) {
+                    metaObject.parent = parentMetaObject;
+                    parentMetaObject.children = parentMetaObject.children || [];
+                    parentMetaObject.children.push(metaObject);
+                }
+            }
+        }
+
+        this.fire("metaModelCreated", modelId);
+        return metaModel;
+    }
+
+    /**
+     * Removes a {@link MetaModel} from this MetaScene.
+     *
+     * Fires a "metaModelDestroyed" event with the value of the {@link MetaModel#id}.
+     *
+     * @param {String} id ID of the target {@link MetaModel}.
+     */
+    destroyMetaModel(id) {
+        const metaModel = this.metaModels[id];
+        if (!metaModel) {
+            return;
+        }
+        this._removeMetaModel(metaModel);
+        this.fire("metaModelDestroyed", id);
+    }
+
+    _removeMetaModel(metaModel) {
+        const metaObjects = this.metaObjects;
+        const metaObjectsByType = this.metaObjectsByType;
+        let visit = (metaObject) => {
+            delete metaObjects[metaObject.id];
+            const types = metaObjectsByType[metaObject.type];
+            if (types && types[metaObject.id]) {
+                delete types[metaObject.id];
+                if (--this._typeCounts[metaObject.type] === 0) {
+                    delete this._typeCounts[metaObject.type];
+                    delete metaObjectsByType[metaObject.type];
+                }
+            }
+            const children = metaObject.children;
+            if (children) {
+                for (let i = 0, len = children.length; i < len; i++) {
+                    const childMetaObject = children[i];
+                    visit(childMetaObject);
+                }
+            }
+        };
+        visit(metaModel.rootMetaObject);
+        delete this.metaModels[metaModel.id];
+    }
+
+    /**
+     * Gets the {@link MetaObject#id}s of the {@link MetaObject}s that have the given {@link MetaObject#type}.
+     *
+     * @param {String} type The type.
+     * @returns {String[]} Array of {@link MetaObject#id}s.
+     */
+    getObjectIDsByType(type) {
+        const metaObjects = this.metaObjectsByType[type];
+        return metaObjects ? Object.keys(metaObjects) : [];
+    }
+
+    /**
+     * Gets the {@link MetaObject#id}s of the {@link MetaObject}s within the given subtree.
+     *
+     * @param {String} id  ID of the root {@link MetaObject} of the given subtree.
+     * @param {String[]} [includeTypes] Optional list of types to include.
+     * @param {String[]} [excludeTypes] Optional list of types to exclude.
+     * @returns {String[]} Array of {@link MetaObject#id}s.
+     */
+    getObjectIDsInSubtree(id, includeTypes, excludeTypes) {
+        const list = [];
+        const metaObject = this.metaObjects[id];
+        const includeMask = (includeTypes && includeTypes.length > 0) ? arrayToMap(includeTypes) : null;
+        const excludeMask = (excludeTypes && excludeTypes.length > 0) ? arrayToMap(excludeTypes) : null;
+
+        function visit(metaObject) {
+            if (!metaObject) {
+                return;
+            }
+            var include = true;
+            if (excludeMask && excludeMask[metaObject.type]) {
+                include = false;
+            } else if (includeMask && (!includeMask[metaObject.type])) {
+                include = false;
+            }
+            if (include) {
+                list.push(metaObject.id);
+            }
+            const children = metaObject.children;
+            if (children) {
+                for (var i = 0, len = children.length; i < len; i++) {
+                    visit(children[i]);
+                }
+            }
+        }
+
+        visit(metaObject);
+        return list;
+    }
+
+    /**
+     * Iterates over the {@link MetaObject}s within the subtree.
+     *
+     * @param {String} id ID of root {@link MetaObject}.
+     * @param {Function} callback Callback fired at each {@link MetaObject}.
+     */
+    withMetaObjectsInSubtree(id, callback) {
+        const metaObject = this.metaObjects[id];
+        if (!metaObject) {
+            return;
+        }
+        metaObject.withMetaObjectsInSubtree(callback);
+    }
+}
+
+function arrayToMap(array) {
+    const map = {};
+    for (var i = 0, len = array.length; i < len; i++) {
+        map[array[i]] = true;
+    }
+    return map;
+}
+
+export {MetaScene};