@inweb/viewer-three 26.5.0 → 26.5.2

package/dist/plugins/loaders/IFCXLoader.module.js

@@ -0,0 +1,726 @@
+import { Loader, GLTFLoadingManager, loaders } from "@inweb/viewer-three";
+
+import { Box3, Vector3, Group, Matrix4, Scene, PerspectiveCamera, BufferGeometry, BufferAttribute, MeshBasicMaterial, Mesh, LineBasicMaterial, Line, Color, Loader as Loader$1, FileLoader } from "three";
+
+const THREE = {
+    Box3: Box3,
+    BufferAttribute: BufferAttribute,
+    BufferGeometry: BufferGeometry,
+    Color: Color,
+    Group: Group,
+    Line: Line,
+    LineBasicMaterial: LineBasicMaterial,
+    Matrix4: Matrix4,
+    Mesh: Mesh,
+    MeshBasicMaterial: MeshBasicMaterial,
+    PerspectiveCamera: PerspectiveCamera,
+    Scene: Scene,
+    Vector3: Vector3
+};
+
+function getChildByName(root, childName, skip = 0) {
+    let fragments = childName.replace(/^<\/|^\/|>$/g, "").split("/");
+    for (let i = 0; i < skip; ++i) {
+        fragments.shift();
+    }
+    let start = root;
+    while (fragments.length && start && start.children) {
+        let f = fragments.shift();
+        start = start.children.find((i => i.name.split("/").reverse()[0] === f));
+    }
+    if (fragments.length == 0) {
+        return start;
+    }
+}
+
+function GetNode(node, path) {
+    if (path === "") return node;
+    let parts = path.split("/");
+    let child = node.children.get(parts[0]);
+    if (child) {
+        if (parts.length === 1) {
+            return child;
+        }
+        return GetNode(child, GetTail(path));
+    } else {
+        return null;
+    }
+}
+
+function GetHead(path) {
+    return path.split("/")[0];
+}
+
+function GetTail(path) {
+    let parts = path.split("/");
+    parts.shift();
+    return parts.join("/");
+}
+
+function MakeNode(node) {
+    return {
+        node: node,
+        children: new Map,
+        attributes: new Map
+    };
+}
+
+function ConvertToCompositionNode(path, inputNodes) {
+    let compositionNode = {
+        path: path,
+        children: {},
+        inherits: {},
+        attributes: {}
+    };
+    inputNodes.forEach((node => {
+        Object.keys(node.children).forEach((childName => {
+            compositionNode.children[childName] = node.children[childName];
+        }));
+        Object.keys(node.inherits).forEach((inheritName => {
+            let ih = node.inherits[inheritName];
+            if (ih === null) {
+                delete compositionNode.inherits[inheritName];
+            } else {
+                compositionNode.inherits[inheritName] = ih;
+            }
+        }));
+        Object.keys(node.attributes).forEach((attrName => {
+            compositionNode.attributes[attrName] = node.attributes[attrName];
+        }));
+    }));
+    return compositionNode;
+}
+
+function MMSet(map, key, value) {
+    if (map.has(key)) {
+        map.get(key)?.push(value);
+    } else {
+        map.set(key, [ value ]);
+    }
+}
+
+function FindRootsOrCycles(nodes) {
+    let dependencies = new Map;
+    let dependents = new Map;
+    nodes.forEach(((node, path) => {
+        Object.keys(node.inherits).forEach((inheritName => {
+            MMSet(dependencies, path, node.inherits[inheritName]);
+            MMSet(dependents, node.inherits[inheritName], path);
+        }));
+        Object.keys(node.children).forEach((childName => {
+            MMSet(dependencies, path, node.children[childName]);
+            MMSet(dependents, node.children[childName], path);
+        }));
+    }));
+    let paths = [ ...nodes.keys() ];
+    let perm = {};
+    let temp = {};
+    function visit(path) {
+        if (perm[path]) return;
+        if (temp[path]) throw new Error(`CYCLE!`);
+        temp[path] = true;
+        let deps = dependencies.get(path);
+        if (deps) {
+            deps.forEach((dep => visit(dep)));
+        }
+        perm[path] = true;
+    }
+    let roots = new Set;
+    try {
+        paths.forEach((path => {
+            if (!dependents.has(path) && path.indexOf("/") === -1) {
+                roots.add(path);
+            }
+            visit(path);
+        }));
+    } catch {
+        return null;
+    }
+    return roots;
+}
+
+function ConvertNodes(input) {
+    let compositionNodes = new Map;
+    for (let [path, inputNodes] of input) {
+        compositionNodes.set(path, ConvertToCompositionNode(path, inputNodes));
+    }
+    return compositionNodes;
+}
+
+var CycleError = class extends Error {};
+
+function ExpandFirstRootInInput(nodes) {
+    let roots = FindRootsOrCycles(nodes);
+    if (!roots) {
+        throw new CycleError;
+    }
+    return ExpandNewNode([ ...roots.values() ][0], nodes);
+}
+
+function CreateArtificialRoot(nodes) {
+    let roots = FindRootsOrCycles(nodes);
+    if (!roots) {
+        throw new CycleError;
+    }
+    let pseudoRoot = {
+        node: "",
+        attributes: new Map,
+        children: new Map
+    };
+    roots.forEach((root => {
+        pseudoRoot.children.set(root, ExpandNewNode(root, nodes));
+    }));
+    return pseudoRoot;
+}
+
+function ExpandNewNode(node, nodes) {
+    return ExpandNode(node, MakeNode(node), nodes);
+}
+
+function ExpandNode(path, node, nodes) {
+    let input = nodes.get(path);
+    if (input) {
+        AddDataFromInput(input, node, nodes);
+    }
+    node.children.forEach(((child, name) => {
+        ExpandNode(`${path}/${name}`, child, nodes);
+    }));
+    return node;
+}
+
+function AddDataFromInput(input, node, nodes) {
+    Object.values(input.inherits).forEach((inherit => {
+        let classNode = ExpandNewNode(GetHead(inherit), nodes);
+        let subnode = GetNode(classNode, GetTail(inherit));
+        if (!subnode) throw new Error(`Unknown node ${inherit}`);
+        subnode.children.forEach(((child, childName) => {
+            node.children.set(childName, child);
+        }));
+        for (let [attrID, attr] of subnode.attributes) {
+            node.attributes.set(attrID, attr);
+        }
+    }));
+    Object.entries(input.children).forEach((([childName, child]) => {
+        if (child !== null) {
+            let classNode = ExpandNewNode(GetHead(child), nodes);
+            let subnode = GetNode(classNode, GetTail(child));
+            if (!subnode) throw new Error(`Unknown node ${child}`);
+            node.children.set(childName, subnode);
+        } else {
+            node.children.delete(childName);
+        }
+    }));
+    Object.entries(input.attributes).forEach((([attrID, attr]) => {
+        node.attributes.set(attrID, attr);
+    }));
+}
+
+function MMSet2(map, key, value) {
+    if (map.has(key)) {
+        map.get(key)?.push(value);
+    } else {
+        map.set(key, [ value ]);
+    }
+}
+
+function ToInputNodes(data) {
+    let inputNodes = new Map;
+    data.forEach((ifcxNode => {
+        let node = {
+            path: ifcxNode.identifier,
+            children: ifcxNode.children ? ifcxNode.children : {},
+            inherits: ifcxNode.inherits ? ifcxNode.inherits : {},
+            attributes: ifcxNode.attributes ? ifcxNode.attributes : {}
+        };
+        MMSet2(inputNodes, node.path, node);
+    }));
+    return inputNodes;
+}
+
+var SchemaValidationError = class extends Error {};
+
+function ValidateAttributeValue(desc, value, path, schemas) {
+    if (desc.inherits) {
+        desc.inherits.forEach((inheritedSchemaID => {
+            let inheritedSchema = schemas[inheritedSchemaID];
+            if (!inheritedSchema) {
+                throw new SchemaValidationError(`Unknown inherited schema id "${desc.inherits}"`);
+            }
+            ValidateAttributeValue(inheritedSchema.value, value, path, schemas);
+        }));
+    }
+    if (desc.dataType === "Boolean") {
+        if (typeof value !== "boolean") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type boolean`);
+        }
+    } else if (desc.dataType === "String") {
+        if (typeof value !== "string") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type string`);
+        }
+    } else if (desc.dataType === "DateTime") {
+        if (typeof value !== "string") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type date`);
+        }
+    } else if (desc.dataType === "Enum") {
+        if (typeof value !== "string") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type string`);
+        }
+        let found = desc.enumRestrictions.options.filter((option => option === value)).length === 1;
+        if (!found) {
+            throw new SchemaValidationError(`Expected "${value}" to be one of [${desc.enumRestrictions.options.join(",")}]`);
+        }
+    } else if (desc.dataType === "Integer") {
+        if (typeof value !== "number") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type int`);
+        }
+    } else if (desc.dataType === "Real") {
+        if (typeof value !== "number") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type real`);
+        }
+    } else if (desc.dataType === "Relation") {
+        if (typeof value !== "string") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type string`);
+        }
+    } else if (desc.dataType === "Object") {
+        if (typeof value !== "object") {
+            throw new SchemaValidationError(`Expected "${value}" to be of type object`);
+        }
+        if (desc.objectRestrictions) {
+            Object.keys(desc.objectRestrictions.values).forEach((key => {
+                if (!Object.hasOwn(value, key)) {
+                    throw new SchemaValidationError(`Expected "${value}" to have key ${key}`);
+                }
+                ValidateAttributeValue(desc.objectRestrictions.values[key], value[key], path + "." + key, schemas);
+            }));
+        }
+    } else if (desc.dataType === "Array") {
+        if (!Array.isArray(value)) {
+            throw new SchemaValidationError(`Expected "${value}" to be of type array`);
+        }
+        value.forEach((entry => {
+            ValidateAttributeValue(desc.arrayRestrictions.value, entry, path + ".<array>.", schemas);
+        }));
+    } else {
+        throw new SchemaValidationError(`Unexpected datatype ${desc.dataType}`);
+    }
+}
+
+function Validate(schemas, inputNodes) {
+    inputNodes.forEach((node => {
+        Object.keys(node.attributes).forEach((schemaID => {
+            if (!schemas[schemaID]) {
+                throw new SchemaValidationError(`Missing schema "${schemaID}" referenced by ["${node.path}"].attributes`);
+            }
+            let schema = schemas[schemaID];
+            let value = node.attributes[schemaID];
+            try {
+                ValidateAttributeValue(schema.value, value, "", schemas);
+            } catch (e) {
+                if (e instanceof SchemaValidationError) {
+                    throw new SchemaValidationError(`Error validating ["${node.path}"].attributes["${schemaID}"]: ${e.message}`);
+                } else {
+                    throw e;
+                }
+            }
+        }));
+    }));
+}
+
+function LoadIfcxFile(file, checkSchemas = true, createArtificialRoot = false) {
+    let inputNodes = ToInputNodes(file.data);
+    let compositionNodes = ConvertNodes(inputNodes);
+    try {
+        if (checkSchemas) {
+            Validate(file.schemas, compositionNodes);
+        }
+    } catch (e) {
+        throw e;
+    }
+    if (createArtificialRoot) {
+        return CreateArtificialRoot(compositionNodes);
+    } else {
+        return ExpandFirstRootInInput(compositionNodes);
+    }
+}
+
+function Federate(files) {
+    let result = {
+        header: files[0].header,
+        schemas: {},
+        data: []
+    };
+    files.forEach((file => {
+        Object.keys(file.schemas).forEach((schemaID => result.schemas[schemaID] = file.schemas[schemaID]));
+    }));
+    files.forEach((file => {
+        file.data.forEach((node => result.data.push(node)));
+    }));
+    return Prune(result);
+}
+
+function Collapse(nodes, deleteEmpty = false) {
+    let result = {
+        path: nodes[0].path,
+        children: {},
+        inherits: {},
+        attributes: {}
+    };
+    nodes.forEach((node => {
+        Object.keys(node.children).forEach((name => {
+            result.children[name] = node.children[name];
+        }));
+        Object.keys(node.inherits).forEach((name => {
+            result.inherits[name] = node.inherits[name];
+        }));
+        Object.keys(node.attributes).forEach((name => {
+            result.attributes[name] = node.attributes[name];
+        }));
+    }));
+    if (deleteEmpty) {
+        let empty = true;
+        Object.keys(result.children).forEach((name => {
+            if (result.children[name] !== null) empty = false;
+        }));
+        Object.keys(result.inherits).forEach((name => {
+            if (result.inherits[name] !== null) empty = false;
+        }));
+        Object.keys(result.attributes).forEach((name => {
+            if (result.attributes[name] !== null) empty = false;
+        }));
+        if (empty) return null;
+    }
+    return result;
+}
+
+function Prune(file, deleteEmpty = false) {
+    let result = {
+        header: file.header,
+        schemas: file.schemas,
+        data: []
+    };
+    let inputNodes = ToInputNodes(file.data);
+    inputNodes.forEach((nodes => {
+        let collapsed = Collapse(nodes, deleteEmpty);
+        if (collapsed) result.data.push({
+            identifier: collapsed.path,
+            children: collapsed.children,
+            inherits: collapsed.inherits,
+            attributes: collapsed.attributes
+        });
+    }));
+    return result;
+}
+
+function TreeNodeToComposedObject(path, node, schemas) {
+    let co = {
+        name: path,
+        attributes: {},
+        children: []
+    };
+    node.children.forEach(((childNode, childName) => {
+        co.children?.push(TreeNodeToComposedObject(`${path}/${childName}`, childNode, schemas));
+    }));
+    node.attributes.forEach(((attr, attrName) => {
+        if (attr && typeof attr === "object" && !Array.isArray(attr)) {
+            Object.keys(attr).forEach((compname => {
+                co.attributes[`${attrName}::${compname}`] = attr[compname];
+            }));
+        } else {
+            let schema = schemas[attrName];
+            if (schema && schema.value.quantityKind) {
+                let postfix = "";
+                let quantityKind = schema.value.quantityKind;
+                if (quantityKind === "Length") {
+                    postfix = "m";
+                } else if (quantityKind === "Volume") {
+                    postfix = "m" + String.fromCodePoint(179);
+                }
+                co.attributes[attrName] = `${attr} ${postfix}`;
+            } else {
+                co.attributes[attrName] = attr;
+            }
+        }
+    }));
+    if (Object.keys(co.attributes).length === 0) delete co.attributes;
+    return co;
+}
+
+function compose3(files) {
+    let federated = Federate(files);
+    let tree = LoadIfcxFile(federated, true, true);
+    return TreeNodeToComposedObject("", tree, federated.schemas);
+}
+
+var scene;
+
+var camera;
+
+var datas = [];
+
+var autoCamera = true;
+
+function init() {
+    scene = new THREE.Scene;
+    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, .1, 100);
+    camera.up.set(0, 0, 1);
+    camera.position.set(50, 50, 50);
+    camera.lookAt(0, 0, 0);
+    scene.add(camera);
+    return scene;
+}
+
+function HasAttr(node, attrName) {
+    if (!node || !node.attributes) return false;
+    return !!node.attributes[attrName];
+}
+
+function FindChildWithAttr(node, attrName) {
+    if (!node || !node.children) return undefined;
+    for (let i = 0; i < node.children.length; i++) {
+        if (HasAttr(node.children[i], attrName)) {
+            return node.children[i];
+        }
+    }
+    return undefined;
+}
+
+function createMaterialFromParent(parent, root) {
+    let reference = parent.attributes["usd::usdshade::materialbindingapi::material::binding"];
+    let material = {
+        color: new THREE.Color(.6, .6, .6),
+        transparent: false,
+        opacity: 1
+    };
+    if (reference) {
+        const materialNode = getChildByName(root, reference.ref);
+        let shader = FindChildWithAttr(materialNode, "usd::materials::inputs::diffuseColor");
+        if (shader) {
+            let color = shader?.attributes["usd::materials::inputs::diffuseColor"];
+            material.color = new THREE.Color(...color);
+            if (shader?.attributes["usd::materials::inputs::opacity"]) {
+                material.transparent = true;
+                material.opacity = shader.attributes["usd::materials::inputs::opacity"];
+            }
+        }
+    }
+    return material;
+}
+
+function createCurveFromJson(node, parent, root) {
+    let points = new Float32Array(node.attributes["usd::usdgeom::basiscurves::points"].flat());
+    const geometry = new THREE.BufferGeometry;
+    geometry.setAttribute("position", new THREE.BufferAttribute(points, 3));
+    const material = createMaterialFromParent(parent, root);
+    let lineMaterial = new THREE.LineBasicMaterial({
+        ...material
+    });
+    lineMaterial.color.multiplyScalar(.8);
+    return new THREE.Line(geometry, lineMaterial);
+}
+
+function createMeshFromJson(node, parent, root) {
+    let points = new Float32Array(node.attributes["usd::usdgeom::mesh::points"].flat());
+    let indices = new Uint16Array(node.attributes["usd::usdgeom::mesh::faceVertexIndices"]);
+    const geometry = new THREE.BufferGeometry;
+    geometry.setAttribute("position", new THREE.BufferAttribute(points, 3));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    geometry.computeVertexNormals();
+    const material = createMaterialFromParent(parent, root);
+    let meshMaterial = new THREE.MeshBasicMaterial({
+        ...material
+    });
+    return new THREE.Mesh(geometry, meshMaterial);
+}
+
+function traverseTree(node, parent, root, parentNode = undefined) {
+    let elem = new THREE.Group;
+    if (HasAttr(node, "usd::usdgeom::visibility::visibility")) {
+        if (node.attributes["usd::usdgeom::visibility::visibility"] === "invisible") {
+            return;
+        }
+    } else if (HasAttr(node, "usd::usdgeom::mesh::points")) {
+        elem = createMeshFromJson(node, parentNode, root);
+    } else if (HasAttr(node, "usd::usdgeom::basiscurves::points")) {
+        elem = createCurveFromJson(node, parentNode, root);
+    }
+    parent.add(elem);
+    if (node !== root) {
+        elem.matrixAutoUpdate = false;
+        let matrixNode = node.attributes && node.attributes["usd::xformop::transform"] ? node.attributes["usd::xformop::transform"].flat() : null;
+        if (matrixNode) {
+            let matrix = new THREE.Matrix4;
+            matrix.set(...matrixNode);
+            matrix.transpose();
+            elem.matrix = matrix;
+        }
+    }
+    (node.children || []).forEach((child => traverseTree(child, elem || parent, root, node)));
+}
+
+function composeAndRender() {
+    if (scene) {
+        scene.children = [];
+    }
+    if (datas.length === 0) {
+        return;
+    }
+    let tree = null;
+    let dataArray = datas.map((arr => arr[1]));
+    tree = compose3(dataArray);
+    if (!tree) {
+        console.error("No result from composition");
+        return;
+    }
+    traverseTree(tree, scene || init(), tree);
+    if (autoCamera) {
+        const boundingBox = new THREE.Box3;
+        boundingBox.setFromObject(scene);
+        if (!boundingBox.isEmpty()) {
+            let avg = boundingBox.min.clone().add(boundingBox.max).multiplyScalar(.5);
+            let ext = boundingBox.max.clone().sub(boundingBox.min).length();
+            camera.position.copy(avg.clone().add(new THREE.Vector3(1, 1, 1).normalize().multiplyScalar(ext)));
+            camera.far = ext * 3;
+            camera.updateProjectionMatrix();
+            autoCamera = false;
+        }
+    }
+}
+
+function parse(m, name) {
+    datas.push([ name, m ]);
+    composeAndRender();
+    return scene;
+}
+
+function clear() {
+    scene = undefined;
+    datas.length = 0;
+    autoCamera = true;
+}
+
+class IFCXModelLoader extends Loader {
+    constructor(viewer) {
+        super();
+        this.viewer = viewer;
+    }
+    isSupport(file) {
+        return typeof file === "object" && typeof file.type === "string" && typeof file.download === "function" && /.ifcx$/i.test(file.type);
+    }
+    async load(model) {
+        const progress = progress => {
+            this.viewer.emitEvent({
+                type: "geometryprogress",
+                data: progress,
+                file: model
+            });
+        };
+        const arrayBuffer = await model.download(progress, this.abortController.signal);
+        if (!this.viewer.scene) return this;
+        const textDecoder = new TextDecoder;
+        const json = JSON.parse(textDecoder.decode(arrayBuffer));
+        const scene = parse(json);
+        clear();
+        let handle = 0;
+        scene.traverse((object => {
+            object.userData = {
+                handle: handle,
+                ...object.userData
+            };
+            handle++;
+        }));
+        this.viewer.scene.add(scene);
+        this.viewer.models.push(scene);
+        this.viewer.syncOptions();
+        this.viewer.syncOverlay();
+        this.viewer.update();
+        this.viewer.emitEvent({
+            type: "databasechunk",
+            data: scene,
+            file: model
+        });
+        return this;
+    }
+}
+
+class IFCXLoader extends Loader$1 {
+    load(url, onLoad, onProgress, onError) {
+        const manager = this.manager;
+        manager.itemStart(url);
+        const _onLoad = scene => {
+            onLoad(scene);
+            manager.itemEnd(url);
+        };
+        const _onError = e => {
+            if (onError) onError(e); else console.error(e);
+            manager.itemError(url);
+            manager.itemEnd(url);
+        };
+        const loader = new FileLoader(this.manager);
+        loader.setPath(this.path);
+        loader.setResponseType("json");
+        loader.setRequestHeader(this.requestHeader);
+        loader.setWithCredentials(this.withCredentials);
+        loader.load(url, (json => this.parse(json, _onLoad, _onError)), onProgress, onError);
+    }
+    parse(json, onLoad, onError) {
+        try {
+            onLoad(parse(json));
+        } catch (e) {
+            onError(e);
+        } finally {
+            clear();
+        }
+    }
+}
+
+class IFCXFileLoader extends Loader {
+    constructor(viewer) {
+        super();
+        this.viewer = viewer;
+    }
+    isSupport(file, format) {
+        return (typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) && /(ifcx)$/i.test(format);
+    }
+    async load(file, format, params) {
+        const manager = new GLTFLoadingManager(file, params);
+        const loader = new IFCXLoader(manager);
+        loader.setPath(manager.path);
+        loader.setCrossOrigin(params.crossOrigin || loader.crossOrigin);
+        loader.setWithCredentials(params.withCredentials || loader.withCredentials);
+        const progress = event => {
+            const {lengthComputable: lengthComputable, loaded: loaded, total: total} = event;
+            const progress = lengthComputable ? loaded / total : 1;
+            this.viewer.emitEvent({
+                type: "geometryprogress",
+                data: progress,
+                file: file
+            });
+        };
+        const scene = await loader.loadAsync(manager.fileURL, progress);
+        if (!this.viewer.scene) return this;
+        let handle = 0;
+        scene.traverse((object => {
+            object.userData = {
+                handle: handle,
+                ...object.userData
+            };
+            handle++;
+        }));
+        this.viewer.scene.add(scene);
+        this.viewer.models.push(scene);
+        this.viewer.syncOptions();
+        this.viewer.syncOverlay();
+        this.viewer.update();
+        this.viewer.emitEvent({
+            type: "databasechunk",
+            data: scene,
+            file: file
+        });
+        return this;
+    }
+}
+
+loaders.registerLoader("ifcx", (viewer => new IFCXModelLoader(viewer)));
+
+loaders.registerLoader("ifcx-file", (viewer => new IFCXFileLoader(viewer)));
+//# sourceMappingURL=IFCXLoader.module.js.map