stbkit 0.1.0a9.dev1__py3-none-any.whl

stbkit/tools/_internal/utils/node_utils.py

@@ -0,0 +1,50 @@
+# 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 typing import Protocol
+
+from stbkit.core.data_model import (
+    stb_v2_0_0,
+    stb_v2_0_1,
+    stb_v2_0_2,
+    stb_v2_1_0,
+    stb_v2_1_1,
+)
+from stbkit.core.data_model.common import StBridgeRoot
+from stbkit.core.stb_exceptions import (
+    ReferenceElementNotFoundError,
+    UnsupportedStbVersionError,
+)
+
+from ..vectors import Vector3d
+
+
+class HasXyz(Protocol):
+    @property
+    def x(self) -> float: ...
+    @property
+    def y(self) -> float: ...
+    @property
+    def z(self) -> float: ...
+
+
+def get_node_coordinate(stb: StBridgeRoot, id: int) -> Vector3d:
+    if not isinstance(
+        stb,
+        (
+            stb_v2_0_0.StBridge,
+            stb_v2_0_1.StBridge,
+            stb_v2_0_2.StBridge,
+            stb_v2_1_0.StBridge,
+            stb_v2_1_1.StBridge,
+        ),
+    ):
+        raise UnsupportedStbVersionError(stb.version)
+
+    for node in stb.stb_model.stb_nodes.stb_node:
+        if node.id == id:
+            return Vector3d.from_stb_node(node)
+    raise ReferenceElementNotFoundError(f"StbNode id={id}が見つかりません")

stbkit/tools/_internal/utils/unit_utils.py

@@ -0,0 +1,23 @@
+# 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 math
+
+
+def mm_to_m(value: float) -> float:
+    return value / 1000.0
+
+
+def m_to_mm(value: float) -> float:
+    return value * 1000.0
+
+
+def radian_to_degree(value: float) -> float:
+    return math.degrees(value)
+
+
+def degree_to_radian(value: float) -> float:
+    return math.radians(value)

stbkit/tools/_internal/vectors.py

@@ -0,0 +1,222 @@
+# 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 __future__ import annotations
+
+import math
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass
+from math import sqrt
+from typing import TYPE_CHECKING, overload
+
+from stbkit.core.stb_exceptions import SchemaError
+
+from .utils.unit_utils import degree_to_radian, mm_to_m
+
+if TYPE_CHECKING:
+    from .utils.node_utils import HasXyz
+
+
+@dataclass(frozen=True, slots=True)
+class Vector2d(Sequence[float]):
+    x: float = 0.0
+    y: float = 0.0
+
+    def mm_to_m(self) -> Vector2d:
+        return Vector2d(mm_to_m(self.x), mm_to_m(self.y))
+
+    def to_vector3d(self, z: float = 0.0) -> Vector3d:
+        return Vector3d(self.x, self.y, z)
+
+    @overload
+    def __getitem__(self, index: int) -> float: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence[float]: ...
+
+    def __getitem__(self, index: int | slice) -> float | Sequence[float]:
+        if isinstance(index, int):
+            if index == 0:
+                return self.x
+            elif index == 1:
+                return self.y
+            else:
+                raise IndexError("インデックスは0から1の範囲で指定してください")
+        elif isinstance(index, slice):
+            # スライスの場合はリストで返す
+            return [self.x, self.y][index]
+        else:
+            raise TypeError("インデックスは整数またはスライスで指定してください")
+
+    def __len__(self) -> int:
+        return 2
+
+    def __add__(self, other: Vector2d) -> Vector2d:
+        return Vector2d(self.x + other.x, self.y + other.y)
+
+    def __sub__(self, other: Vector2d) -> Vector2d:
+        return Vector2d(self.x - other.x, self.y - other.y)
+
+    def __neg__(self) -> Vector2d:
+        return Vector2d(-self.x, -self.y)
+
+    def __iter__(self) -> Iterator[float]:
+        yield self.x
+        yield self.y
+
+    def clone(self) -> Vector2d:
+        return Vector2d(self.x, self.y)
+
+    def distance_to(self, other: Vector2d) -> float:
+        return math.hypot(other.y - self.y, other.x - self.x)
+
+    def rotate(self, angle_degree: float) -> Vector2d:
+        if angle_degree == 0.0:
+            return self.clone()
+        theta: float = degree_to_radian(angle_degree)
+        cos_theta: float = math.cos(theta)
+        sin_theta: float = math.sin(theta)
+        x_new: float = cos_theta * self.x - sin_theta * self.y
+        y_new: float = sin_theta * self.x + cos_theta * self.y
+        return Vector2d(x_new, y_new)
+
+    @staticmethod
+    def zero() -> Vector2d:
+        return Vector2d(0.0, 0.0)
+
+
+@dataclass(frozen=True, slots=True)
+class Vector3d(Sequence[float]):
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+
+    def __add__(self, other: Vector3d) -> Vector3d:
+        return Vector3d(self.x + other.x, self.y + other.y, self.z + other.z)
+
+    @overload
+    def __getitem__(self, index: int) -> float: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence[float]: ...
+
+    def __getitem__(self, index: int | slice) -> float | Sequence[float]:
+        if isinstance(index, int):
+            if index == 0:
+                return self.x
+            elif index == 1:
+                return self.y
+            elif index == 2:
+                return self.z
+            else:
+                raise IndexError("インデックスは0から2の範囲で指定してください")
+        elif isinstance(index, slice):
+            # スライスの場合はリストで返す
+            return [self.x, self.y, self.z][index]
+        else:
+            raise TypeError("インデックスは整数またはスライスで指定してください")
+
+    def __len__(self) -> int:
+        return 3
+
+    def __rmul__(self, other: float) -> Vector3d:
+        return Vector3d(other * self.x, other * self.y, other * self.z)
+
+    def __sub__(self, other: Vector3d) -> Vector3d:
+        return Vector3d(self.x - other.x, self.y - other.y, self.z - other.z)
+
+    def __neg__(self) -> Vector3d:
+        return Vector3d(-self.x, -self.y, -self.z)
+
+    def clone(self) -> Vector3d:
+        return Vector3d(self.x, self.y, self.z)
+
+    def cross(self, other: Vector3d) -> Vector3d:
+        return Vector3d(
+            self.y * other.z - self.z * other.y,
+            self.z * other.x - self.x * other.z,
+            self.x * other.y - self.y * other.x,
+        )
+
+    def distance_to(self, other: Vector3d) -> float:
+        return sqrt(
+            (self.x - other.x) ** 2 + (self.y - other.y) ** 2 + (self.z - other.z) ** 2
+        )
+
+    def dot(self, other: Vector3d) -> float:
+        return self.x * other.x + self.y * other.y + self.z * other.z
+
+    def length(self) -> float:
+        return sqrt(self.x**2 + self.y**2 + self.z**2)
+
+    def mm_to_m(self) -> Vector3d:
+        return mm_to_m(1.0) * self
+
+    def normalize(self) -> Vector3d:
+        length = self.length()
+        if length == 0:
+            raise ValueError("零ベクトルは正規化できません")
+        return Vector3d(self.x / length, self.y / length, self.z / length)
+
+    def perpendicular_vector_on_plane(self, def_plane_vec: Vector3d) -> Vector3d:
+        # vec1 を正規化
+        vec1_normalized: Vector3d = self.normalize()
+
+        # vec2 の vec1 への射影を計算
+        projection_length: float = def_plane_vec.dot(vec1_normalized)
+        projection_vector: Vector3d = projection_length * vec1_normalized
+
+        # vec2 から射影ベクトルを引いて、vec1 に垂直なベクトルを得る
+        result: Vector3d = def_plane_vec - projection_vector
+        result = result.normalize()
+        return result
+
+    def rotate_around_axis(self, angle_degree: float, axis_vec: Vector3d) -> Vector3d:
+        if angle_degree == 0.0:
+            return self.clone()
+        theta = degree_to_radian(angle_degree)
+        a: Vector3d = axis_vec.normalize()
+        vec1: Vector3d = math.cos(theta) * self
+        vec2: Vector3d = (1.0 - math.cos(theta)) * (self.dot(a)) * a
+        vec3: Vector3d = math.sin(theta) * a.cross(self)
+        return vec1 + vec2 + vec3
+
+    def to_tuple(self) -> tuple[float, float, float]:
+        return (self.x, self.y, self.z)
+
+    @staticmethod
+    def from_collection(
+        collection: Sequence[float],
+    ) -> Vector3d:
+        if len(collection) != 3:
+            raise ValueError("3次元のコレクションとしてください")
+        return Vector3d(x=collection[0], y=collection[1], z=collection[2])
+
+    @staticmethod
+    def from_stb_node(
+        stb_node: HasXyz,
+    ) -> Vector3d:
+        if stb_node.x is None or stb_node.y is None or stb_node.z is None:
+            raise SchemaError(
+                f"{stb_node._name_for_logger()} x,y,zの値が設定されていません"
+            )
+        return Vector3d(stb_node.x, stb_node.y, stb_node.z)
+
+    @staticmethod
+    def unit_x() -> Vector3d:
+        return Vector3d(1.0, 0.0, 0.0)
+
+    @staticmethod
+    def unit_y() -> Vector3d:
+        return Vector3d(0.0, 1.0, 0.0)
+
+    @staticmethod
+    def unit_z() -> Vector3d:
+        return Vector3d(0.0, 0.0, 1.0)
+
+    @staticmethod
+    def zero() -> Vector3d:
+        return Vector3d(0.0, 0.0, 0.0)

stbkit/tools/converters/__init__.py

@@ -0,0 +1,39 @@
+# 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 logging import Logger
+from typing import TYPE_CHECKING
+
+from stbkit.core.data_model.common import StBridgeRoot
+from stbkit.core.stb_reporting import Reporter, get_reporter
+
+if TYPE_CHECKING:
+    import ifcopenshell.file
+
+
+def to_ifc(
+    stb: StBridgeRoot, *, logger: Logger | None = None, reporter: Reporter | None = None
+) -> "ifcopenshell.file":
+    """ST-BridgeをIFCへ変換します。
+
+    この関数を利用するためにはifcopenshellが必要です。
+
+    Args:
+        stb: ST-Bridgeモデル
+        logger: 出力用のLogger。
+        reporter: 出力用のReporter。
+
+    Returns:
+        ifcopenshell.file: 生成されたIFCモデル
+    """
+    from .._internal.data_model.ifc_data.entity_data import IfcModel
+    from ..upgrade import upgrade_to_latest
+    from ._internal.stb_to_ifc_data._stb_to_ifc_data import stb_to_ifc_data
+
+    reporter = get_reporter(logger, reporter)
+    stb = upgrade_to_latest(stb, reporter=reporter)
+    ifc_model: IfcModel = stb_to_ifc_data(stb, reporter=reporter)
+    return ifc_model.to_ifc(reporter=reporter)

stbkit/tools/converters/_internal/__init__.py

@@ -0,0 +1,5 @@
+# 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/.

stbkit/tools/converters/_internal/building_geometry_to_ply_text.py

@@ -0,0 +1,32 @@
+# 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 ..._internal.data_model.building_geometry import BuildingGeometry
+
+
+def building_geometry_to_ply_text(geom: BuildingGeometry) -> str:
+    result: list[str] = []
+    result.append("ply")
+    result.append("format ascii 1.0")
+    result.append(f"element vertex {geom.mesh.vertex_count}")
+    result.append("property float x")
+    result.append("property float y")
+    result.append("property float z")
+    result.append(f"element face {geom.mesh.face_count}")
+    result.append("property list uchar int vertex_index")
+    result.append("end_header")
+    positions = geom.mesh.positions
+    for i in range(geom.mesh.vertex_count):
+        result.append(
+            f"{round(positions[i * 3], 5)} {round(positions[i * 3 + 1], 5)} {round(positions[i * 3 + 2], 5)}"
+        )
+
+    face_offsets = geom.mesh.face_offsets
+    for i in range(geom.mesh.face_count):
+        face = geom.mesh.face_vertex_indices[face_offsets[i] : face_offsets[i + 1]]
+        result.append(f"{len(face)} {' '.join(map(str, face))}")
+
+    return "\n".join(result)

stbkit/tools/converters/_internal/coord_converter.py

@@ -0,0 +1,151 @@
+# 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 stbkit.core.stb_exceptions import (
+    ZeroLengthMemberError,
+)
+
+from ..._internal.data_model.element_data import ElementType
+from ..._internal.matrix import RotationMatrix
+from ..._internal.vectors import Vector3d
+
+
+def rotation_matrix(
+    point: Vector3d, vx: Vector3d, vy: Vector3d, vz: Vector3d
+) -> RotationMatrix:
+    return RotationMatrix(point, vx, vy, vz)
+
+
+def rotation_matrix_by_element_type(
+    point_start: Vector3d, point_end: Vector3d, angle: float, element_type: ElementType
+) -> RotationMatrix:
+    match element_type:
+        case (
+            ElementType.GIRDER
+            | ElementType.BEAM
+            | ElementType.BRACE
+            | ElementType.STRIP_FOOTING
+            | ElementType.PARAPET
+        ):
+            return rotation_matrix_beam(point_start, point_end, angle)
+        case (
+            ElementType.COLUMN
+            | ElementType.POST
+            | ElementType.FOOTING
+            | ElementType.PILE
+            | ElementType.FOUNDATION_COLUMN
+        ):
+            return rotation_matrix_column(point_start, point_end, angle)
+        case _:
+            raise NotImplementedError(f"要素タイプ{element_type}の回転行列は未実装です")
+
+
+def axis_vector_by_element_type(
+    point_start: Vector3d, point_end: Vector3d, angle: float, element_type: ElementType
+) -> tuple[Vector3d, Vector3d, Vector3d]:
+    match element_type:
+        case (
+            ElementType.GIRDER
+            | ElementType.BEAM
+            | ElementType.BRACE
+            | ElementType.STRIP_FOOTING
+            | ElementType.PARAPET
+        ):
+            return axis_vector_beam(point_start, point_end, angle)
+        case (
+            ElementType.COLUMN
+            | ElementType.POST
+            | ElementType.FOOTING
+            | ElementType.PILE
+            | ElementType.FOUNDATION_COLUMN
+        ):
+            return axis_vector_column(point_start, point_end, angle)
+        case _:
+            raise NotImplementedError(
+                f"要素タイプ{element_type}の軸ベクトルは未実装です"
+            )
+
+
+def axis_vector_beam(
+    point_start: Vector3d, point_end: Vector3d, angle: float
+) -> tuple[Vector3d, Vector3d, Vector3d]:
+    vx: Vector3d = (point_end - point_start).normalize()
+    pv: Vector3d = vx.perpendicular_vector_on_plane(Vector3d.unit_z())
+    vz: Vector3d = pv.rotate_around_axis(angle, vx).normalize()
+    vy: Vector3d = vz.cross(vx)
+    return (vx, vy, vz)
+
+
+def rotation_matrix_beam(
+    point_start: Vector3d,
+    point_end: Vector3d,
+    angle: float,
+) -> RotationMatrix:
+    (vx, vy, vz) = axis_vector_beam(point_start, point_end, angle)
+    return rotation_matrix(point_start, vy, vz, vx)
+
+
+def axis_vector_column(
+    point_start: Vector3d, point_end: Vector3d, angle: float
+) -> tuple[Vector3d, Vector3d, Vector3d]:
+    vx: Vector3d = point_end - point_start
+    if vx.length() == 0:
+        raise ZeroLengthMemberError("柱の始点と終点が同じ位置です")
+    vx = vx.normalize()
+    pv: Vector3d = vx.perpendicular_vector_on_plane(Vector3d.unit_x())
+    vy: Vector3d = pv.rotate_around_axis(angle, vx).normalize()
+    vz: Vector3d = vx.cross(vy)
+    return (vx, vy, vz)
+
+
+def rotation_matrix_column(
+    point_start: Vector3d,
+    point_end: Vector3d,
+    angle: float,
+) -> RotationMatrix:
+    (vx, vy, vz) = axis_vector_column(point_start, point_end, angle)
+    return rotation_matrix(point_start, vy, vz, vx)
+
+
+def axis_vector_plate(
+    points: list[Vector3d],
+) -> tuple[Vector3d, Vector3d, Vector3d]:
+    if len(points) < 3:
+        raise AssertionError("pointsの数が3以下です")
+    vx: Vector3d = (points[1] - points[0]).normalize()
+    vy: Vector3d = vx.perpendicular_vector_on_plane(points[-1] - points[0]).normalize()
+    vz = vx.cross(vy)
+    return (vx, vy, vz)
+
+
+def rotation_matrix_plate(points: list[Vector3d]) -> RotationMatrix:
+    vx, vy, vz = axis_vector_plate(points)
+    return rotation_matrix(points[0], vx, vy, vz)
+
+
+def to_plate_element_coord(points: list[Vector3d]) -> list[Vector3d]:
+    matrix = rotation_matrix_plate(points)
+    return [matrix.to_local_point(point) for point in points]
+
+
+def to_global_coord_plate(
+    points: list[Vector3d], out_points: list[Vector3d]
+) -> list[Vector3d]:
+    matrix = rotation_matrix_plate(out_points)
+    return [matrix.to_global_point(point) for point in points]
+
+
+def to_global_coord(
+    points: list[Vector3d],
+    point_start: Vector3d,
+    point_end: Vector3d,
+    angle: float,
+    element_type: ElementType,
+) -> list[Vector3d]:
+    matrix = rotation_matrix_by_element_type(
+        point_start, point_end, angle, element_type
+    )
+    return [matrix.to_global_point(point) for point in points]