IFCをglTFに変換する

def to_gltf(geometries, material_dict, filename='output.glb', export_line=False):
    nodes = []
    meshes = []
    bufferViews = []
    accessors = []
    materials = []
    byteOffset = 0
    binary_blobs = b''

    # エッジ出力しない
    if not export_line:
        geometries = [g for g in geometries if len(g['triangles']) > 0]


    # マテリアル
    for index, (material_id, ifc_material) in enumerate(material_dict.items()):
        color = ifc_material['color']
        name = ifc_material['name']
        ifc_material['index'] = index

        alphaMode = pygltflib.OPAQUE if color[-1] == 1 else pygltflib.BLEND
        materials.append(
            pygltflib.Material(
                pbrMetallicRoughness=pygltflib.PbrMetallicRoughness(
                    baseColorFactor=color,
                    # metallicFactor=0,
                    # roughnessFactor=1,
                ),
                alphaMode=alphaMode,
                name=name,
            )
        )

    # ジオメトリ
    for index, geometry in enumerate(geometries):
        points = geometry['vertices']
        lines = geometry.get('edges', [])
        triangles = geometry['triangles']
        name = geometry.get('name')
        material_name = geometry.get('material')
        material_index = material_dict[material_name]['index']

        # メッシュがなければエッジ
        if len(triangles) == 0:
            indices = lines
            mode = pygltflib.LINES
        else:
            indices = triangles
            mode = pygltflib.TRIANGLES

        # 型を指定する
        points = points.astype(np.float32)
        indices_max = indices.max()
        if indices_max <= np.iinfo(np.uint8).max:
            componentType = pygltflib.UNSIGNED_BYTE
            indices = indices.astype(np.uint8)
        elif indices_max <= np.iinfo(np.uint16).max:
            componentType = pygltflib.UNSIGNED_SHORT
            indices = indices.astype(np.uint16)
        else:
            componentType = pygltflib.UNSIGNED_INT
            indices = indices.astype(np.uint32)

        # バイナリに
        indices_binary_blob = indices.flatten().tobytes()
        points_binary_blob = points.tobytes()

        # ノード
        nodes.append(pygltflib.Node(mesh=index, name=name))

        # メッシュ
        meshes.append(pygltflib.Mesh(
            primitives=[
                pygltflib.Primitive(
                    attributes=pygltflib.Attributes(POSITION=1 + index * 2),
                    indices=index * 2,
                    material=material_index,
                    mode=mode
                )
            ]
        ))

        # bufferViews
        byteLength = len(indices_binary_blob) + len(points_binary_blob)
        bufferViews += [
            pygltflib.BufferView(
                buffer=0,
                byteOffset=byteOffset,
                byteLength=len(indices_binary_blob),
                target=pygltflib.ELEMENT_ARRAY_BUFFER,
            ),
            pygltflib.BufferView(
                buffer=0,
                byteOffset=byteOffset + len(indices_binary_blob),
                byteLength=len(points_binary_blob),
                target=pygltflib.ARRAY_BUFFER,
            ),
        ]
        byteOffset += byteLength

        # マテリアル
        alphaMode = pygltflib.OPAQUE if color[-1] == 1 else pygltflib.BLEND
        materials.append(
            pygltflib.Material(
                pbrMetallicRoughness=pygltflib.PbrMetallicRoughness(
                    baseColorFactor=color,
                    # metallicFactor=0,
                    # roughnessFactor=1,
                ),
                alphaMode=alphaMode,
                doubleSided=True,
            )
        )

        # accessors
        accessors += [
            pygltflib.Accessor(
                bufferView=index * 2,
                componentType=componentType,
                count=indices.size,
                type=pygltflib.SCALAR,
                max=[int(indices.max())],
                min=[int(indices.min())],
            ),
            pygltflib.Accessor(
                bufferView=index * 2 + 1,
                componentType=pygltflib.FLOAT,
                count=len(points),
                type=pygltflib.VEC3,
                max=points.max(axis=0).tolist(),
                min=points.min(axis=0).tolist(),
            ),
        ]

        binary_blobs += indices_binary_blob + points_binary_blob

    # gltf作成
    gltf = pygltflib.GLTF2(
        scene=0,
        scenes=[pygltflib.Scene(nodes=list(range(len(geometries))))],
        nodes=nodes,
        meshes=meshes,
        accessors=accessors,
        bufferViews=bufferViews,
        buffers=[
            pygltflib.Buffer(
                byteLength=len(binary_blobs)
            )
        ],
        materials=materials,
    )
    gltf.set_binary_blob(binary_blobs)

    # 保存
    gltf.save(filename)
    return gltf

import ifcopenshell
import ifcopenshell.geom
import numpy as np
from tqdm.auto import tqdm

ifc_file = ifcopenshell.open(r'C:\work\ifc\model\AC20-FZK-Haus.ifc')
settings = ifcopenshell.geom.settings()
settings.set(settings.USE_WORLD_COORDS, True)
settings.set(settings.INCLUDE_CURVES, True)
settings.set(settings.STRICT_TOLERANCE, True)
settings.set(settings.USE_ELEMENT_GUIDS, True)
settings.set(settings.APPLY_DEFAULT_MATERIALS, True)

geometries = []
material_dict ={}
for element in tqdm(ifc_file.by_type("IfcProduct")):
    if element.is_a("IfcOpeningElement") or element.is_a("IfcSpace"):
        continue
    if element.Representation is None:
        continue
    try:
        shape = ifcopenshell.geom.create_shape(settings, element)
    except Exception as e:
        print(element, e)

    matrix = shape.transformation.matrix.data
    faces = shape.geometry.faces
    edges = shape.geometry.edges
    verts = shape.geometry.verts
    materials = shape.geometry.materials
    material_ids = shape.geometry.material_ids
    edges = np.array(edges).reshape(-1, 2)

    # 奥行き-Zの右手系（gltf）
    vertices = np.array(verts).reshape(-1, 3)[:, [0, 2, 1]]
    vertices[:, 0] = -vertices[:, 0]
    triangles = np.array(faces).reshape(-1, 3)

    material_ids = np.array(material_ids)
    for mat_id, material in enumerate(materials):
        color = *material.diffuse, 1 - material.transparency
        material_dict[material.name] = dict(color=color, name=material.original_name())

        mat_edges = edges[material_ids == mat_id] if len(triangles) == 0 else edges
        mat_triangles = (
            triangles[material_ids == mat_id] if len(triangles) > 0 else triangles
        )
        geometries.append(
            dict(
                name=element.is_a(),
                vertices=vertices,
                triangles=mat_triangles,
                material=material.name,
                edges=mat_edges,
            )
        )

to_gltf(geometries, material_dict, 'model.glb')

from types import SimpleNamespace
from functools import partial
settings = ifcopenshell.geom.settings()
settings.set(settings.USE_WORLD_COORDS, True)
# settings.set(settings.INCLUDE_CURVES, True) # データによってはバグるときがある？
settings.set(settings.STRICT_TOLERANCE, True)
settings.set(settings.USE_ELEMENT_GUIDS, True)
settings.set(settings.APPLY_DEFAULT_MATERIALS, True)
ifc_create_shape = partial(ifcopenshell.geom.create_shape, settings=settings)

class IfcTreeStructure:
    def __init__(self, element, use_edge=False, include_space=False):
        self.num_meshes = 0
        self.num_nodes = 0
        self.use_edge = use_edge
        self.include_space = include_space
        self.material_dict = {}
        self.tree = self.create_node(element)

        self.explore_element(self.tree)

    def __repr__(self):
        return repr(self.tree)

    def create_node(self, element, level=0):
        node = TreeNode(element, level, self.num_nodes)
        self.num_nodes += 1
        return node

    def get_child_elements(self, element):
        # 子要素を探索する
        for relationship in getattr(element, "IsDecomposedBy", []):
            for related_element in relationship.RelatedObjects:
                yield related_element

        # 空間要素を探索する
        for relationship in getattr(element, "ContainsElements", []):
            for related_element in relationship.RelatedElements:
                yield related_element

    def explore_element(self, node, level=0):
        # ジオメトリを取得する
        if node.has_geometry:
            geometry = self.get_geometry(node.element)
            if len(geometry) == 0:
                # ジオメトリなし
                node.has_geometry = False
            elif len(geometry) == 1:
                # ジオメトリ一つ（通常ケース）
                node.geometry = geometry[0]
                node.mesh_index = self.num_meshes
                self.num_meshes += 1
            elif len(geometry) > 1:
                # ジオメトリ複数
                node.has_geometry = False
                for g in geometry:
                    child = self.create_node(node.element, level + 1)
                    node.children.append(child)
                    material_name = self.material_dict[g["material"]]["name"]
                    child.name = f"{node.name} | {material_name}"
                    child.geometry = g
                    child.mesh_index = self.num_meshes
                    self.num_meshes += 1
                return

        # 子要素を探索する
        for child_element in self.get_child_elements(node.element):
            child = self.create_node(child_element, level + 1)
            node.children.append(child)
            self.explore_element(child, level + 1)

    def get_geometry(self, element):
        if not self.include_space and element.is_a("IfcSpace"):
            return []

        try:
            shape = ifc_create_shape(inst=element)
        except Exception as e:
            print(element, e)
            return []

        matrix = shape.transformation.matrix.data
        faces = shape.geometry.faces
        edges = shape.geometry.edges
        verts = shape.geometry.verts
        materials = shape.geometry.materials
        material_ids = shape.geometry.material_ids
        edges = np.array(edges).reshape(-1, 2)

        if not self.use_edge and len(faces) == 0:
            return []

        # 奥行き-Zの右手系（gltf）
        vertices = np.array(verts).reshape(-1, 3)[:, [0, 2, 1]]
        vertices[:, 0] = -vertices[:, 0]
        triangles = np.array(faces).reshape(-1, 3)

        geometries = []
        material_ids = np.array(material_ids)
        for mat_id, material in enumerate(materials):
            color = *material.diffuse, 1 - material.transparency
            self.material_dict[material.name] = dict(
                color=color, name=material.original_name()
            )

            mat_edges = edges[material_ids == mat_id] if len(triangles) == 0 else edges
            mat_triangles = (
                triangles[material_ids == mat_id] if len(triangles) > 0 else triangles
            )
            geometries.append(
                dict(
                    name=element.is_a(),
                    vertices=vertices,
                    triangles=mat_triangles,
                    material=material.name,
                    edges=mat_edges,
                )
            )

        return geometries

class TreeNode:
    def __init__(self, element, level=0, node_index=0):
        self.element = element
        self.children = []
        self.name = f"{element.is_a()}"
        if element.Name is not None and element.Name != "":
            self.name += f" | {element.Name}"

        self.has_geometry = getattr(element, "Representation", None) is not None
        self.geometry = None

        self.mesh_index = None
        self.node_index = node_index
        self.level = level

    def __repr__(self):
        indent = "  " * self.level
        child = (
            f"".join([f"{child}" for child in self.children])
            if len(self.children) > 0
            else ""
        )
        return (
            f"{indent}- {self.element.is_a()} #{self.element.id()}: "
            f"{self.element.Name if hasattr(self.element, 'Name') else ''}\n"
            f"{child}"
        )

def create_gltf_mesh(geometry, material_dict, index, byteOffset):
    points = geometry["vertices"]
    lines = geometry.get("edges", [])
    triangles = geometry["triangles"]
    material_name = geometry.get("material")
    material_index = material_dict[material_name]["index"]

    # メッシュがなければエッジ
    if len(triangles) == 0:
        indices = lines
        mode = pygltflib.LINES
    else:
        indices = triangles
        mode = pygltflib.TRIANGLES

    # 型を指定する
    points = points.astype(np.float32)
    indices_max = indices.max()
    if indices_max <= np.iinfo(np.uint8).max:
        componentType = pygltflib.UNSIGNED_BYTE
        indices = indices.astype(np.uint8)
    elif indices_max <= np.iinfo(np.uint16).max:
        componentType = pygltflib.UNSIGNED_SHORT
        indices = indices.astype(np.uint16)
    else:
        componentType = pygltflib.UNSIGNED_INT
        indices = indices.astype(np.uint32)

    # バイナリに
    indices_binary_blob = indices.flatten().tobytes()
    points_binary_blob = points.tobytes()

    # メッシュ
    mesh = pygltflib.Mesh(
        primitives=[
            pygltflib.Primitive(
                attributes=pygltflib.Attributes(POSITION=1 + index * 2),
                indices=index * 2,
                material=material_index,
                mode=mode,
            )
        ]
    )

    # bufferViews
    byteLength = len(indices_binary_blob) + len(points_binary_blob)
    bufferViews = [
        pygltflib.BufferView(
            buffer=0,
            byteOffset=byteOffset,
            byteLength=len(indices_binary_blob),
            target=pygltflib.ELEMENT_ARRAY_BUFFER,
        ),
        pygltflib.BufferView(
            buffer=0,
            byteOffset=byteOffset + len(indices_binary_blob),
            byteLength=len(points_binary_blob),
            target=pygltflib.ARRAY_BUFFER,
        ),
    ]
    byteOffset += byteLength

    # accessors
    accessors = [
        pygltflib.Accessor(
            bufferView=index * 2,
            componentType=componentType,
            count=indices.size,
            type=pygltflib.SCALAR,
            max=[int(indices.max())],
            min=[int(indices.min())],
        ),
        pygltflib.Accessor(
            bufferView=index * 2 + 1,
            componentType=pygltflib.FLOAT,
            count=len(points),
            type=pygltflib.VEC3,
            max=points.max(axis=0).tolist(),
            min=points.min(axis=0).tolist(),
        ),
    ]

    binary_blobs = indices_binary_blob + points_binary_blob

    return mesh, bufferViews, accessors, binary_blobs


def to_gltf(mesh_tree, filename="output.glb"):
    # マテリアル
    materials = []
    for index, (_, material_data) in enumerate(mesh_tree.material_dict.items()):
        color = material_data["color"]
        name = material_data["name"]
        material_data["index"] = index

        alphaMode = pygltflib.OPAQUE if color[-1] == 1 else pygltflib.BLEND
        materials.append(
            pygltflib.Material(
                pbrMetallicRoughness=pygltflib.PbrMetallicRoughness(
                    baseColorFactor=color,
                    # metallicFactor=0,
                    # roughnessFactor=1,
                ),
                alphaMode=alphaMode,
                doubleSided=True,
                name=name,
            )
        )

    # ノードとメッシュ作成
    gltf_data = SimpleNamespace(
        nodes=[],
        meshes=[],
        bufferViews=[],
        accessors=[],
        byteOffset=0,
        binary_blobs=b"",
    )

    def create_gltf_node_mesh(node):
        gltf_data.nodes.append(
            pygltflib.Node(
                name=node.name,
                mesh=node.mesh_index,
                children=[child.node_index for child in node.children],
            )
        )

        if node.has_geometry:
            mesh, bufferView, accessor, binary_blob = create_gltf_mesh(
                node.geometry,
                mesh_tree.material_dict,
                node.mesh_index,
                gltf_data.byteOffset,
            )
            gltf_data.meshes.append(mesh)
            gltf_data.bufferViews.extend(bufferView)
            gltf_data.accessors.extend(accessor)
            gltf_data.binary_blobs += binary_blob
            gltf_data.byteOffset += len(binary_blob)

        for child in node.children:
            create_gltf_node_mesh(child)

    root_node = mesh_tree.tree
    create_gltf_node_mesh(root_node)

    # gltf作成
    gltf = pygltflib.GLTF2(
        scene=0,
        scenes=[pygltflib.Scene(nodes=[0])],
        nodes=gltf_data.nodes,
        meshes=gltf_data.meshes,
        accessors=gltf_data.accessors,
        bufferViews=gltf_data.bufferViews,
        buffers=[pygltflib.Buffer(byteLength=len(gltf_data.binary_blobs))],
        materials=materials,
    )
    gltf.set_binary_blob(gltf_data.binary_blobs)

    # 保存
    gltf.save(filename)
    return gltf