stbkit 0.1.0a9.dev1__py3-none-any.whl

stbkit/tools/_internal/optional_dependencies/ifc_exporter/ifc_profile_exporter.py

@@ -0,0 +1,267 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import ifcopenshell.util.shape_builder
+from ifcopenshell import entity_instance, file
+
+from ...data_model.ifc_data.entity_names import EntityName
+from ...data_model.shape_data import (
+    Shape,
+    ShapeArbitrary,
+    ShapeBox,
+    ShapeBuildBox,
+    ShapeChannel,
+    ShapeCircle,
+    ShapeH,
+    ShapeLipC,
+    ShapePipe,
+    ShapeRectangle,
+    ShapeT,
+)
+from ...utils.float_rounding import round_float, round_vector2d
+
+PROFILE_TYPE_AREA: str = "AREA"
+
+
+class IfcProfileExporter:
+    def __init__(
+        self,
+        model: file | None = None,
+        body: entity_instance | None = None,
+        *,
+        round_digits_mm: int | None = None,
+    ) -> None:
+        self._model: file | None = model
+        self._body: entity_instance | None = body
+        self._round_digits_mm: int | None = round_digits_mm
+
+    @property
+    def model(self) -> file:
+        if self._model is None:
+            raise AssertionError("modelが初期化されていません")
+        return self._model
+
+    @property
+    def body(self) -> entity_instance:
+        if self._body is None:
+            raise AssertionError("bodyが初期化されていません")
+        return self._body
+
+    @body.setter
+    def body(self, value: entity_instance) -> None:
+        self._body = value
+
+    def get_profile(self, shape: Shape) -> entity_instance:
+        """プロファイルを取得する
+
+        IFCに山形鋼のプロファイルは存在するが、
+        ST-Bridgeと基準軸方向が異なる。
+        そのため、プロファイルを使うと回転角がST-Bridgeと変わってしまい、対応がわかりにくくなるため、
+        山形鋼については任意形状(Arbitary)で設定する。
+        """
+        match shape:
+            case ShapeArbitrary():
+                return self.get_profile_arbitrary(shape)
+            case ShapeBox():
+                return self.get_profile_box(shape)
+            case ShapeBuildBox():
+                return self.get_profile_build_box(shape)
+            case ShapeChannel():
+                return self.get_profile_channel(shape)
+            case ShapeCircle():
+                return self.get_profile_circle(shape)
+            case ShapeH():
+                return self.get_profile_h(shape)
+            case ShapeLipC():
+                return self.get_profile_lip_c(shape)
+            case ShapePipe():
+                return self.get_profile_pipe(shape)
+            case ShapeRectangle():
+                return self.get_profile_rectangle(shape)
+            case ShapeT():
+                return self.get_profile_t(shape)
+            case _:
+                return self.get_profile_base(shape)
+
+    def get_profile_base(self, shape: Shape) -> entity_instance:
+        builder = ifcopenshell.util.shape_builder.ShapeBuilder(self.model)
+        outer_curve = builder.polyline(
+            [
+                round_vector2d(point, round_digits=self._round_digits_mm)
+                for point in shape.get_out_point2ds()
+            ],
+            closed=True,
+        )
+        in_point2ds = shape.get_in_point2ds()
+        inner_curves: list[entity_instance] = []
+        if in_point2ds:
+            inner_curve = builder.polyline(
+                [
+                    round_vector2d(point, round_digits=self._round_digits_mm)
+                    for point in in_point2ds
+                ],
+                closed=True,
+            )
+            inner_curves.append(inner_curve)
+        profile = builder.profile(
+            outer_curve, inner_curves=inner_curves, name="Arbitrary"
+        )
+        return profile
+
+    def get_profile_arbitrary(self, shape: ShapeArbitrary) -> entity_instance:
+        builder = ifcopenshell.util.shape_builder.ShapeBuilder(self.model)
+        outer_curve = builder.polyline(
+            [
+                round_vector2d(point, round_digits=self._round_digits_mm)
+                for point in shape.get_out_point2ds()
+            ],
+            closed=True,
+        )
+        inner_curves: list[entity_instance] = []
+        in_point_2ds = shape.in_points
+        if in_point_2ds:
+            for in_points in in_point_2ds:
+                inner_curve = builder.polyline(
+                    [
+                        round_vector2d(point, round_digits=self._round_digits_mm)
+                        for point in in_points
+                    ],
+                    closed=True,
+                )
+                inner_curves.append(inner_curve)
+        profile = builder.profile(
+            outer_curve, inner_curves=inner_curves, name="Arbitrary"
+        )
+        return profile
+
+    def get_profile_box(self, shape: ShapeBox) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_RECTANGLE_HOLLOW_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            XDim=round_float(shape.b, round_digits=self._round_digits_mm),
+            YDim=round_float(shape.a, round_digits=self._round_digits_mm),
+            WallThickness=round_float(shape.t, round_digits=self._round_digits_mm),
+            InnerFilletRadius=round_float(
+                max(0.0, shape.r - shape.t),
+                round_digits=self._round_digits_mm,
+            ),
+            OuterFilletRadius=round_float(
+                shape.r,
+                round_digits=self._round_digits_mm,
+            ),
+        )
+        return profile
+
+    def get_profile_build_box(self, shape: ShapeBuildBox) -> entity_instance:
+        if shape.t1 == shape.t2:
+            profile: entity_instance = self.model.create_entity(
+                EntityName.IFC_RECTANGLE_HOLLOW_PROFILE_DEF.value,
+                ProfileName=shape.name,
+                ProfileType=PROFILE_TYPE_AREA,
+                XDim=round_float(shape.b, round_digits=self._round_digits_mm),
+                YDim=round_float(shape.a, round_digits=self._round_digits_mm),
+                WallThickness=round_float(
+                    shape.t1,
+                    round_digits=self._round_digits_mm,
+                ),
+                InnerFilletRadius=0.0,
+                OuterFilletRadius=0.0,
+            )
+            return profile
+        else:
+            return self.get_profile_base(shape)
+
+    def get_profile_channel(self, shape: ShapeChannel) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_U_SHAPE_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            Depth=round_float(shape.a, round_digits=self._round_digits_mm),
+            FlangeWidth=round_float(shape.b, round_digits=self._round_digits_mm),
+            WebThickness=round_float(shape.t1, round_digits=self._round_digits_mm),
+            FlangeThickness=round_float(
+                shape.t2,
+                round_digits=self._round_digits_mm,
+            ),
+            FilletRadius=round_float(shape.r1, round_digits=self._round_digits_mm),
+            EdgeRadius=round_float(shape.r2, round_digits=self._round_digits_mm),
+            FlangeSlope=0,
+        )
+        return profile
+
+    def get_profile_circle(self, shape: ShapeCircle) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_CIRCLE_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            Radius=round_float(shape.d / 2.0, round_digits=self._round_digits_mm),
+        )
+        return profile
+
+    def get_profile_h(self, shape: ShapeH) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_I_SHAPE_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            OverallWidth=round_float(shape.b, round_digits=self._round_digits_mm),
+            OverallDepth=round_float(shape.a, round_digits=self._round_digits_mm),
+            WebThickness=round_float(shape.t1, round_digits=self._round_digits_mm),
+            FlangeThickness=round_float(
+                shape.t2,
+                round_digits=self._round_digits_mm,
+            ),
+            FilletRadius=round_float(shape.r, round_digits=self._round_digits_mm),
+        )
+        return profile
+
+    def get_profile_pipe(self, shape: ShapePipe) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_CIRCLE_HOLLOW_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            Radius=round_float(shape.d / 2.0, round_digits=self._round_digits_mm),
+            WallThickness=round_float(shape.t, round_digits=self._round_digits_mm),
+        )
+        return profile
+
+    def get_profile_rectangle(self, shape: ShapeRectangle) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_RECTANGLE_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            XDim=round_float(shape.width_x, round_digits=self._round_digits_mm),
+            YDim=round_float(shape.width_y, round_digits=self._round_digits_mm),
+        )
+        return profile
+
+    def get_profile_t(self, shape: ShapeT) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_T_SHAPE_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            Depth=round_float(shape.b, round_digits=self._round_digits_mm),
+            FlangeWidth=round_float(shape.a, round_digits=self._round_digits_mm),
+            WebThickness=round_float(shape.t1, round_digits=self._round_digits_mm),
+            FlangeThickness=round_float(
+                shape.t2,
+                round_digits=self._round_digits_mm,
+            ),
+            FilletRadius=round_float(shape.r, round_digits=self._round_digits_mm),
+        )
+        return profile
+
+    def get_profile_lip_c(self, shape: ShapeLipC) -> entity_instance:
+        profile: entity_instance = self.model.create_entity(
+            EntityName.IFC_C_SHAPE_PROFILE_DEF.value,
+            ProfileName=shape.name,
+            ProfileType=PROFILE_TYPE_AREA,
+            Depth=round_float(shape.h, round_digits=self._round_digits_mm),
+            Width=round_float(shape.a, round_digits=self._round_digits_mm),
+            WallThickness=round_float(shape.t, round_digits=self._round_digits_mm),
+            Girth=round_float(shape.c, round_digits=self._round_digits_mm),
+        )
+        return profile

stbkit/tools/_internal/optional_dependencies/ifc_exporter/ifc_representation_exporter.py

@@ -0,0 +1,178 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import ifcopenshell.api.geometry
+from ifcopenshell import entity_instance, file
+from ifcopenshell.util.shape_builder import SequenceOfVectors
+from stbkit.core.stb_reporting import Reporter
+
+from ....converters._internal import coord_converter
+from ....converters._internal.element_data_to_building_geometry import (
+    create_local_line_meshes,
+)
+from ...data_model.shape_data import (
+    ShapeArbitrary,
+    ShapePair,
+    ShapePosition,
+    ShapeRectangle,
+)
+from ...utils.float_rounding import round_float, round_vector2d, round_vector3d
+from ...utils.unit_utils import mm_to_m
+from ...vectors import Vector2d, Vector3d
+from .ifc_profile_exporter import IfcProfileExporter
+
+
+class IfcRepresentationExporter:
+    def __init__(
+        self,
+        model: file | None = None,
+        body: entity_instance | None = None,
+        *,
+        reporter: Reporter,
+        round_digits_mm: int | None = None,
+    ) -> None:
+        self._model: file | None = model
+        self._body: entity_instance | None = body
+        self._reporter: Reporter = reporter
+        self._round_digits_mm: int | None = round_digits_mm
+        self.profile_exporter: IfcProfileExporter = IfcProfileExporter(
+            model,
+            body,
+            round_digits_mm=round_digits_mm,
+        )
+
+    @property
+    def model(self) -> file:
+        if self._model is None:
+            raise AssertionError("modelが初期化されていません")
+        return self._model
+
+    @property
+    def body(self) -> entity_instance:
+        if self._body is None:
+            raise AssertionError("bodyが初期化されていません")
+        return self._body
+
+    @body.setter
+    def body(self, value: entity_instance) -> None:
+        self._body = value
+        self.profile_exporter.body = value
+
+    @classmethod
+    def is_extrusion(cls, shapes: list[ShapePair]) -> bool:
+        return (
+            len(shapes) == 1
+            and (shapes[0].end is None or shapes[0].end == shapes[0].start)
+            and shapes[0].start.rotate_degree is None
+        )
+
+    def get_line_representation(
+        self,
+        shapes: list[ShapePair],
+        axis_position: ShapePosition,
+        lengths: list[float],
+    ) -> entity_instance:
+        round_digits_m = (
+            None if self._round_digits_mm is None else self._round_digits_mm + 3
+        )
+        if not shapes:
+            raise AssertionError("形状が設定されていません")
+        if len(shapes) != len(lengths):
+            raise AssertionError("形状と長さの数が異なります")
+        if self.is_extrusion(shapes):
+            profile: entity_instance = self.profile_exporter.get_profile(
+                shapes[0].start
+            )
+            representation: entity_instance = (
+                ifcopenshell.api.geometry.add_profile_representation(
+                    self.model,
+                    context=self.body,
+                    profile=profile,
+                    depth=round_float(
+                        mm_to_m(lengths[0]),
+                        round_digits=round_digits_m,
+                    ),
+                )
+            )
+        else:
+            points_list: list[SequenceOfVectors] = []
+            faces_list: list[list[list[int]]] = []
+            for mesh in create_local_line_meshes(
+                shapes,
+                axis_position,
+                lengths,
+            ):
+                points_list.append(
+                    [
+                        round_vector3d(
+                            point.mm_to_m(),
+                            round_digits=round_digits_m,
+                        ).to_tuple()
+                        for point in mesh.vertices
+                    ]
+                )
+                faces_list.append([list(face) for face in mesh.faces])
+            representation = ifcopenshell.api.geometry.add_mesh_representation(
+                self.model, context=self.body, vertices=points_list, faces=faces_list
+            )
+        return representation
+
+    def get_line_unknown_representation(self, lengths: list[float]) -> entity_instance:
+        shape: ShapeRectangle = ShapeRectangle(name="unknown", width_x=10, width_y=10)
+        return self.get_line_representation(
+            shapes=[ShapePair(shape)],
+            axis_position=ShapePosition.CENTER_CENTER,
+            lengths=lengths,
+        )
+
+    def get_plate_representation(
+        self,
+        thickness: float | None,
+        opens: list[list[Vector2d]] | None,
+        points: list[Vector3d],
+    ) -> entity_instance:
+        if len(points) < 3:
+            raise AssertionError("外形の頂点数が足りません")
+        if thickness is None:
+            raise AssertionError("厚さが設定されていません")
+        round_digits_m = (
+            None if self._round_digits_mm is None else self._round_digits_mm + 3
+        )
+        shape: ShapeArbitrary = ShapeArbitrary()
+        shape.out_points.extend(
+            Vector2d(
+                rounded_point.x,
+                rounded_point.y,
+            )
+            for item in coord_converter.to_plate_element_coord(points)
+            for rounded_point in [
+                round_vector3d(item, round_digits=self._round_digits_mm)
+            ]
+        )
+        shape.in_points = (
+            [
+                [round_vector2d(p, round_digits=self._round_digits_mm) for p in open]
+                for open in opens
+            ]
+            if opens is not None
+            else []
+        )
+        profile = self.profile_exporter.get_profile(shape)
+        representation = ifcopenshell.api.geometry.add_profile_representation(
+            self.model,
+            context=self.body,
+            profile=profile,
+            depth=round_float(
+                mm_to_m(thickness),
+                round_digits=round_digits_m,
+            ),
+        )
+        return representation
+
+    def get_unknown_plate_representation(
+        self, points: list[Vector3d]
+    ) -> entity_instance:
+        return self.get_plate_representation(thickness=10, opens=None, points=points)

stbkit/tools/_internal/optional_dependencies/ifc_pipeline.py

@@ -0,0 +1,133 @@
+# Copyright 2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+from stbkit.api import stb_latest
+
+from ...converters._internal.pipeline.data import _DataFormat, _ObjectData
+from ...converters._internal.pipeline.ply_pipeline import _PlyData
+from ...converters._internal.pipeline.stb_pipeline_latest import StbLatestData
+from ...converters._internal.pipeline.step import (
+    _compose_steps,
+    _ExecutableStep,
+    _ExecutionContext,
+    _ExecutionResult,
+)
+from .ifc_common import ensure_ifcopenshell, raise_import_error
+
+if TYPE_CHECKING:
+    from ifcopenshell import file as IfcFile
+
+    from ..data_model.ifc_data.entity_data import IfcModel
+else:
+    type IfcFile = object
+    type IfcModel = object
+
+
+class IfcIntermediateData(_ObjectData[IfcModel]):
+    def __init__(self, value: IfcModel) -> None:
+        super().__init__(format=_DataFormat.IFC, value=value)
+
+
+class IfcData(_ObjectData[IfcFile]):
+    def __init__(self, value: IfcFile) -> None:
+        ensure_ifcopenshell()
+        super().__init__(format=_DataFormat.IFC, value=value)
+
+
+def open_ifc_data(path: Path) -> IfcData:
+    try:
+        import ifcopenshell
+
+        return IfcData(ifcopenshell.open(str(path)))
+    except ImportError as e:
+        raise_import_error(e)
+
+
+def loads_ifc_data(text: str) -> IfcData:
+    try:
+        import ifcopenshell
+
+        return IfcData(ifcopenshell.file.from_string(text))
+    except ImportError as e:
+        raise_import_error(e)
+
+
+class StbLatestToIfcIntermediateStep(
+    _ExecutableStep[StbLatestData, IfcIntermediateData]
+):
+    name = "STB -> IFC中間データ"
+
+    def execute(
+        self,
+        data: StbLatestData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[IfcIntermediateData]:
+        from ...converters._internal.stb_to_ifc_data import _stb_to_ifc_data
+
+        stb: stb_latest.StBridge = data.value
+        if not isinstance(stb, stb_latest.StBridge):
+            raise TypeError(f"ST-Bridgeデータではありません: {type(stb)}")
+        ifc_model: IfcModel = _stb_to_ifc_data.stb_to_ifc_data(
+            stb,
+            reporter=context.reporter,
+        )
+        return _ExecutionResult(output=IfcIntermediateData(ifc_model))
+
+
+class IfcModelToIfcDataStep(_ExecutableStep[IfcIntermediateData, IfcData]):
+    name = "IFC中間データ -> IFC"
+
+    def execute(
+        self,
+        data: IfcIntermediateData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[IfcData]:
+        from stbkit.core.stb_reporting import get_reporter
+
+        ensure_ifcopenshell()
+        from .ifc_exporter.ifc_entity_exporter import (
+            IfcEntityExporter,
+        )
+
+        reporter = context.reporter or get_reporter()
+        ifc_file = IfcEntityExporter.ifc_model_to_file(
+            data.value,
+            reporter=reporter,
+            round_digits=context.ifc_round_digits,
+            round_digits_mm=context.ifc_round_digits_mm,
+        )
+        return _ExecutionResult(output=IfcData(ifc_file))
+
+
+class IfcDataToPlyStep(_ExecutableStep[IfcData, _PlyData]):
+    name = "IFC -> PLY"
+
+    def execute(
+        self,
+        data: IfcData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[_PlyData]:
+        from .ifc_to_building_geometry import ifc_to_building_geometry
+
+        mesh_data = ifc_to_building_geometry(data.value)
+        return _ExecutionResult(output=_PlyData(mesh_data))
+
+
+def stb_latest_to_ifc_step() -> _ExecutableStep[StbLatestData, IfcData]:
+    step = _compose_steps(
+        "STB -> IFC",
+        (
+            StbLatestToIfcIntermediateStep(),
+            IfcModelToIfcDataStep(),
+        ),
+    )
+    return cast(_ExecutableStep[StbLatestData, IfcData], step)

stbkit/tools/_internal/optional_dependencies/ifc_to_building_geometry.py

@@ -0,0 +1,64 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from ..data_model.building_geometry import BuildingGeometry
+from ..utils.guid_utils import from_ifc_guid
+from .ifc_common import ensure_ifcopenshell
+
+if TYPE_CHECKING:
+    import ifcopenshell.file
+
+
+def ifc_to_building_geometry(ifc_file: "ifcopenshell.file") -> BuildingGeometry:
+    ensure_ifcopenshell()
+    import ifcopenshell
+    import ifcopenshell.geom
+    import ifcopenshell.util.shape
+    from ifcopenshell.ifcopenshell_wrapper import (
+        BRep,
+        Serialization,
+        Triangulation,
+    )
+
+    # ジオメトリの設定
+    settings = ifcopenshell.geom.settings()  # type: ignore
+    settings.set("use-world-coords", True)
+    building_geometry: BuildingGeometry = BuildingGeometry()
+
+    for element in ifc_file.by_type("IfcProduct"):
+        if element.is_a("IfcOpeningElement"):
+            continue
+        try:
+            shape = ifcopenshell.geom.create_shape(settings, element)
+        except RuntimeError:
+            continue
+        if not hasattr(shape, "geometry"):
+            continue
+        geometry = shape.geometry
+        vertices: list[Sequence[float]] = []
+
+        if isinstance(geometry, (BRep, Triangulation, Serialization)):
+            global_id: str | None = (
+                element.GlobalId if hasattr(element, "GlobalId") else None
+            )
+            guid: UUID | None = from_ifc_guid(global_id) if global_id else None
+            index: int = building_geometry.add_element(
+                guid=guid,
+                source_type=str(element.is_a()),
+                source_id=str(element.id()),
+                name=getattr(element, "Name", None),
+            )
+            vertices.extend(ifcopenshell.util.shape.get_vertices(geometry))  # type:ignore
+            tmp_faces: list[Sequence[int]] = [
+                item
+                for item in ifcopenshell.util.shape.get_faces(geometry)  # type: ignore
+            ]
+            building_geometry.add_element_mesh(index, vertices, tmp_faces)
+    return building_geometry