qtmodel 2.4.2__tar.gz → 2.5.0__tar.gz

{qtmodel-2.4.2/src/qtmodel.egg-info → qtmodel-2.5.0}/PKG-INFO

@@ -1,14 +1,40 @@
 Metadata-Version: 2.4
 Name: qtmodel
-Version: 2.4.2
+Version: 2.5.0
 Summary: qtmodel package
 Author: Your Name
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: psutil>=5.9
 
-> 最新qtmodel版本 2.4.2 - 2026-07-17 
+> 最新qtmodel版本 2.5.0 - 2026-07-18
 > pip install --upgrade qtmodel -i https://pypi.org/simple
-- 增加检算荷载API
+- 增加纯 Python 本地截面特性求解：面积、形心、Iy/Iz/Iyz、内外周长、
+  包围框、四个控制点、组合截面换算特性和线宽截面特性。
+
+## 本地截面特性计算
+
+本地求解不要求打开桥通，不发送 HTTP 请求。所有坐标和厚度单位为 m，
+面积单位为 m²，惯性矩单位为 m⁴。
+
+```Python
+from qtmodel import mdb
+
+result = mdb.get_parameter_section_property_local(
+    sec_type="矩形",
+    sec_info={"W": 2.0, "H": 1.0},
+)
+print(result.property.Ax, result.property.Iy, result.bounding_box.to_dict())
+
+line_result = mdb.get_section_property_local(
+    sec_type="自定义线宽截面",
+    sec_lines=[[0, 0, 2, 0, 0.02]],
+)
+```
+
+当前本地求解器仅填写可由二维几何严格积分的字段。``Ix``、``Ay``、``Az``、
+剪心和静矩保持为零，完整截面求解仍使用 ``odb.get_section_property``。
 # 建模操作 
 ##  节点操作
 ### generate_curve_node_data

qtmodel-2.4.2/PKG-INFO → qtmodel-2.5.0/README.md

@@ -1,14 +1,30 @@
-Metadata-Version: 2.4
-Name: qtmodel
-Version: 2.4.2
-Summary: qtmodel package
-Author: Your Name
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-> 最新qtmodel版本 2.4.2 - 2026-07-17 
-> pip install --upgrade qtmodel -i https://pypi.org/simple
-- 增加检算荷载API
+> 最新qtmodel版本 2.5.0 - 2026-07-18
+> pip install --upgrade qtmodel -i https://pypi.org/simple
+- 增加纯 Python 本地截面特性求解：面积、形心、Iy/Iz/Iyz、内外周长、
+  包围框、四个控制点、组合截面换算特性和线宽截面特性。
+
+## 本地截面特性计算
+
+本地求解不要求打开桥通，不发送 HTTP 请求。所有坐标和厚度单位为 m，
+面积单位为 m²，惯性矩单位为 m⁴。
+
+```Python
+from qtmodel import mdb
+
+result = mdb.get_parameter_section_property_local(
+    sec_type="矩形",
+    sec_info={"W": 2.0, "H": 1.0},
+)
+print(result.property.Ax, result.property.Iy, result.bounding_box.to_dict())
+
+line_result = mdb.get_section_property_local(
+    sec_type="自定义线宽截面",
+    sec_lines=[[0, 0, 2, 0, 0.02]],
+)
+```
+
+当前本地求解器仅填写可由二维几何严格积分的字段。``Ix``、``Ay``、``Az``、
+剪心和静矩保持为零，完整截面求解仍使用 ``odb.get_section_property``。
 # 建模操作 
 ##  节点操作
 ### generate_curve_node_data

{qtmodel-2.4.2 → qtmodel-2.5.0}/pyproject.toml

@@ -4,11 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qtmodel"
-version = "2.4.2"
+version = "2.5.0"
 description = "qtmodel package"
 readme = "README.md"
 requires-python = ">=3.9"
-authors = [{name = "Your Name"}]
+authors = [{name = "Your Name"}]
+dependencies = [
+    "requests>=2.28",
+    "psutil>=5.9",
+]
 
 [tool.setuptools]
 package-dir = {"" = "src"}

{qtmodel-2.4.2 → qtmodel-2.5.0}/src/qtmodel/__init__.py

@@ -3,6 +3,13 @@ from .cdb import cdb, Cdb
 from .core.qt_server import QtServer
 from .core.section_db import SectionDB, SectionParameter, SectionProperty, SectionSchema
 from .core.section_geometry import SectionGeometryDB
+from .core.section_property_solver import (
+    SectionBoundingBox,
+    SectionControlPoint,
+    SectionPartProperty,
+    SectionPropertyResult,
+    SectionPropertySolver,
+)
 from .core.section_shape import (
     SectionLine,
     SectionLoopSegment,
@@ -19,6 +26,8 @@ __all__ = [
     "Bridge", "bridge", "Cdb", "cdb", "Mdb", "mdb", "Odb", "odb",
     "SectionDB", "SectionParameter", "SectionProperty", "SectionSchema",
     "SectionGeometryDB",
+    "SectionBoundingBox", "SectionControlPoint", "SectionPartProperty",
+    "SectionPropertyResult", "SectionPropertySolver",
     "SectionPoint", "SectionLoopSegment", "SectionLine", "SectionShapePart",
     "SectionShape",
 ]

{qtmodel-2.4.2 → qtmodel-2.5.0}/src/qtmodel/core/__init__.py

@@ -1,5 +1,12 @@
 from .section_db import SectionDB, SectionParameter, SectionProperty, SectionSchema
 from .section_geometry import SectionGeometryDB
+from .section_property_solver import (
+    SectionBoundingBox,
+    SectionControlPoint,
+    SectionPartProperty,
+    SectionPropertyResult,
+    SectionPropertySolver,
+)
 from .section_shape import (
     SectionLine,
     SectionLoopSegment,
@@ -11,6 +18,8 @@ from .section_shape import (
 __all__ = [
     "SectionDB", "SectionParameter", "SectionProperty", "SectionSchema",
     "SectionGeometryDB",
+    "SectionBoundingBox", "SectionControlPoint", "SectionPartProperty",
+    "SectionPropertyResult", "SectionPropertySolver",
     "SectionPoint", "SectionLoopSegment", "SectionLine", "SectionShapePart",
     "SectionShape",
 ]

{qtmodel-2.4.2 → qtmodel-2.5.0}/src/qtmodel/core/qt_server.py

@@ -7,7 +7,7 @@ import requests
 
 class QtServer:
     URL: str = "http://localhost:55125/pythonForQt/"
-    QT_VERSION: str = "2.4.2"
+    QT_VERSION: str = "2.5.0"
     _session = requests.Session()
     _lock = threading.Lock()
 

qtmodel-2.5.0/src/qtmodel/core/section_property_solver.py

@@ -0,0 +1,539 @@
+# -*- coding: utf-8 -*-
+"""纯 Python 截面几何特性求解器。
+
+本模块只计算能够由二维几何直接、确定地积分得到的截面特性，不连接桥通，
+也不调用 ``SECPROCAL.exe``。坐标约定与 :mod:`qtmodel.core.section_shape`
+一致：形状中的 ``x`` 对应截面局部 ``Y``，``y`` 对应截面局部 ``Z``。
+
+当前严格支持：
+
+* 实体线圈（包括孔洞）的面积、形心、Iy、Iz、Iyz 和周长；
+* 带厚度中心线的薄壁矩形条带面积、形心和惯性矩；
+* 组合截面的等效面积、形心和惯性矩；
+* 包围框以及左上、右上、右下、左下四个控制点。
+
+``Ix``、``Ay``、``Az``、剪心、静矩等需要截面求解内核或额外工程假设的
+字段保持为零，调用方可据此区分本地几何结果与桥通完整求解结果。
+"""
+
+from dataclasses import dataclass
+from math import hypot, isfinite
+from typing import Any, Dict, Iterable, Mapping, Optional, Sequence, Tuple, Union
+
+from .section_db import SectionProperty
+from .section_shape import (
+    SectionLine,
+    SectionLoopSegment,
+    SectionPoint,
+    SectionShape,
+    SectionShapePart,
+)
+
+
+_EPSILON = 1.0e-14
+
+
+@dataclass(frozen=True)
+class SectionBoundingBox:
+    """截面轴对齐包围框，坐标单位为 m。"""
+
+    min_y: float
+    min_z: float
+    max_y: float
+    max_z: float
+
+    @property
+    def width(self) -> float:
+        return self.max_y - self.min_y
+
+    @property
+    def height(self) -> float:
+        return self.max_z - self.min_z
+
+    def to_dict(self) -> Dict[str, float]:
+        return {
+            "min_y": self.min_y,
+            "min_z": self.min_z,
+            "max_y": self.max_y,
+            "max_z": self.max_z,
+            "width": self.width,
+            "height": self.height,
+        }
+
+
+@dataclass(frozen=True)
+class SectionControlPoint:
+    """相对换算截面形心的控制点坐标，单位为 m。"""
+
+    name: str
+    y: float
+    z: float
+
+    def to_dict(self) -> Dict[str, Union[str, float]]:
+        return {"name": self.name, "y": self.y, "z": self.z}
+
+
+@dataclass(frozen=True)
+class SectionPartProperty:
+    """组合截面中一个几何部件的未换算特性。"""
+
+    role: str
+    index: int
+    material_factor: float
+    property: SectionProperty
+    bounding_box: SectionBoundingBox
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "role": self.role,
+            "index": self.index,
+            "material_factor": self.material_factor,
+            "property": self.property.to_dict(),
+            "bounding_box": self.bounding_box.to_dict(),
+        }
+
+
+@dataclass(frozen=True)
+class SectionPropertyResult:
+    """本地截面特性及其可核验的几何上下文。"""
+
+    property: SectionProperty
+    bounding_box: SectionBoundingBox
+    control_points: Tuple[SectionControlPoint, ...]
+    parts: Tuple[SectionPartProperty, ...]
+    transformed: bool = False
+    reference_role: Optional[str] = None
+    elastic_modulus_ratio: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "property": self.property.to_dict(),
+            "bounding_box": self.bounding_box.to_dict(),
+            "control_points": [point.to_dict() for point in self.control_points],
+            "parts": [part.to_dict() for part in self.parts],
+            "transformed": self.transformed,
+            "reference_role": self.reference_role,
+            "elastic_modulus_ratio": self.elastic_modulus_ratio,
+            "units": {
+                "length": "m",
+                "area": "m²",
+                "inertia": "m⁴",
+            },
+            "calculated_fields": [
+                "Ax", "Iy", "Iz", "Iyz", "Cyp", "Cym", "Czp", "Czm",
+                "PeriO", "PeriI", "CentY", "CentZ", "Y1", "Z1", "Y2",
+                "Z2", "Y3", "Z3", "Y4", "Z4",
+            ],
+            "not_calculated_fields": [
+                "Ay", "Az", "Ix", "ShearCenterY", "ShearCenterZ",
+                "Hys", "Hzs", "Sys", "Szs",
+            ],
+            "assumptions": [
+                "各实体线圈分段互不重叠，孔洞位于所属外轮廓内部",
+                "圆弧特性基于 SectionShape 中已经离散后的多边形积分",
+                "线宽按中心线矩形条带叠加，交点重叠面积不做布尔扣除",
+                "Iyz 采用面积乘积惯性矩积分 ∫Y·Z·dA 的符号约定",
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class _Moments:
+    area: float
+    first_y: float
+    first_z: float
+    iy_origin: float
+    iz_origin: float
+    iyz_origin: float
+    perimeter_outer: float
+    perimeter_inner: float
+    points: Tuple[Tuple[float, float], ...]
+
+    def scaled(self, factor: float) -> "_Moments":
+        return _Moments(
+            area=self.area * factor,
+            first_y=self.first_y * factor,
+            first_z=self.first_z * factor,
+            iy_origin=self.iy_origin * factor,
+            iz_origin=self.iz_origin * factor,
+            iyz_origin=self.iyz_origin * factor,
+            perimeter_outer=self.perimeter_outer,
+            perimeter_inner=self.perimeter_inner,
+            points=self.points,
+        )
+
+
+def _clean(value: float) -> float:
+    return 0.0 if abs(value) <= _EPSILON else value
+
+
+def _ensure_finite(values: Iterable[float], description: str) -> None:
+    if not all(isfinite(value) for value in values):
+        raise ValueError(f"{description} 包含 NaN 或无穷大")
+
+
+def _perimeter(points: Sequence[Tuple[float, float]]) -> float:
+    return sum(
+        hypot(
+            points[(index + 1) % len(points)][0] - point[0],
+            points[(index + 1) % len(points)][1] - point[1],
+        )
+        for index, point in enumerate(points)
+    )
+
+
+def _polygon_moments(
+        raw_points: Sequence[SectionPoint],
+        sign: float,
+        description: str,
+) -> _Moments:
+    points = tuple((float(point.x), float(point.y)) for point in raw_points)
+    if len(points) > 1 and points[0] == points[-1]:
+        points = points[:-1]
+    if len(points) < 3:
+        raise ValueError(f"{description} 至少需要3个不同的点")
+    _ensure_finite((value for point in points for value in point), description)
+
+    twice_area = 0.0
+    first_y_numerator = 0.0
+    first_z_numerator = 0.0
+    iy_origin_numerator = 0.0
+    iz_origin_numerator = 0.0
+    iyz_origin_numerator = 0.0
+    for index, (y1, z1) in enumerate(points):
+        y2, z2 = points[(index + 1) % len(points)]
+        cross = y1 * z2 - y2 * z1
+        twice_area += cross
+        first_y_numerator += (y1 + y2) * cross
+        first_z_numerator += (z1 + z2) * cross
+        iy_origin_numerator += (z1 * z1 + z1 * z2 + z2 * z2) * cross
+        iz_origin_numerator += (y1 * y1 + y1 * y2 + y2 * y2) * cross
+        iyz_origin_numerator += (
+            2.0 * y1 * z1 + y1 * z2 + y2 * z1 + 2.0 * y2 * z2
+        ) * cross
+
+    signed_area = twice_area / 2.0
+    if abs(signed_area) <= _EPSILON:
+        raise ValueError(f"{description} 面积为零或点全部共线")
+
+    # 输入轮廓的顺逆时针方向不参与实体/孔洞语义。main_loop 永远为正，
+    # sub_loops 永远为负，从而兼容历史几何生成器中不同的轮廓方向。
+    orientation = 1.0 if signed_area > 0 else -1.0
+    multiplier = sign * orientation
+    return _Moments(
+        area=signed_area * multiplier,
+        first_y=(first_y_numerator / 6.0) * multiplier,
+        first_z=(first_z_numerator / 6.0) * multiplier,
+        iy_origin=(iy_origin_numerator / 12.0) * multiplier,
+        iz_origin=(iz_origin_numerator / 12.0) * multiplier,
+        iyz_origin=(iyz_origin_numerator / 24.0) * multiplier,
+        perimeter_outer=_perimeter(points) if sign > 0 else 0.0,
+        perimeter_inner=_perimeter(points) if sign < 0 else 0.0,
+        points=points if sign > 0 else (),
+    )
+
+
+def _add_moments(items: Iterable[_Moments]) -> _Moments:
+    values = tuple(items)
+    if not values:
+        raise ValueError("截面中没有可计算的实体线圈或线宽")
+    return _Moments(
+        area=sum(item.area for item in values),
+        first_y=sum(item.first_y for item in values),
+        first_z=sum(item.first_z for item in values),
+        iy_origin=sum(item.iy_origin for item in values),
+        iz_origin=sum(item.iz_origin for item in values),
+        iyz_origin=sum(item.iyz_origin for item in values),
+        perimeter_outer=sum(item.perimeter_outer for item in values),
+        perimeter_inner=sum(item.perimeter_inner for item in values),
+        points=tuple(point for item in values for point in item.points),
+    )
+
+
+def _loop_segment_moments(segment: SectionLoopSegment, index: int) -> _Moments:
+    values = [
+        _polygon_moments(segment.main_loop, 1.0, f"第{index + 1}个实体外轮廓")
+    ]
+    values.extend(
+        _polygon_moments(loop, -1.0, f"第{index + 1}个实体的第{hole_index + 1}个孔洞")
+        for hole_index, loop in enumerate(segment.sub_loops)
+    )
+    result = _add_moments(values)
+    if result.area <= _EPSILON:
+        raise ValueError(f"第{index + 1}个实体扣除孔洞后的面积必须大于0")
+    return result
+
+
+def _line_moments(line: SectionLine, index: int) -> _Moments:
+    y1, z1, y2, z2, thickness = (
+        float(line.x1), float(line.y1), float(line.x2), float(line.y2),
+        float(line.thickness),
+    )
+    _ensure_finite((y1, z1, y2, z2, thickness), f"第{index + 1}条线宽")
+    length = hypot(y2 - y1, z2 - z1)
+    if length <= _EPSILON:
+        raise ValueError(f"第{index + 1}条线宽的长度必须大于0")
+    if thickness <= 0.0:
+        raise ValueError(f"第{index + 1}条线宽的厚度必须大于0")
+
+    uy, uz = (y2 - y1) / length, (z2 - z1) / length
+    normal_y, normal_z = -uz, uy
+    half_t = thickness / 2.0
+    corners = (
+        (y1 + normal_y * half_t, z1 + normal_z * half_t),
+        (y2 + normal_y * half_t, z2 + normal_z * half_t),
+        (y2 - normal_y * half_t, z2 - normal_z * half_t),
+        (y1 - normal_y * half_t, z1 - normal_z * half_t),
+    )
+    area = length * thickness
+    cent_y, cent_z = (y1 + y2) / 2.0, (z1 + z2) / 2.0
+
+    along = thickness * length ** 3 / 12.0
+    across = length * thickness ** 3 / 12.0
+    iy_centroid = along * uz ** 2 + across * uy ** 2
+    iz_centroid = along * uy ** 2 + across * uz ** 2
+    iyz_centroid = (along - across) * uy * uz
+    return _Moments(
+        area=area,
+        first_y=area * cent_y,
+        first_z=area * cent_z,
+        iy_origin=iy_centroid + area * cent_z ** 2,
+        iz_origin=iz_centroid + area * cent_y ** 2,
+        iyz_origin=iyz_centroid + area * cent_y * cent_z,
+        # 薄壁中心线按条带叠加，交点不做布尔合并；因此不报告可能误导的周长。
+        perimeter_outer=0.0,
+        perimeter_inner=0.0,
+        points=corners,
+    )
+
+
+def _part_moments(part: SectionShapePart) -> _Moments:
+    if part.shape_type == "loops" or part.loop_segments:
+        return _add_moments(
+            _loop_segment_moments(segment, index)
+            for index, segment in enumerate(part.loop_segments)
+        )
+    if part.shape_type == "lines" or part.lines:
+        return _add_moments(
+            _line_moments(line, index) for index, line in enumerate(part.lines)
+        )
+    raise ValueError(f"部件 {part.role!r} 没有可计算的线圈或线宽")
+
+
+def _bounding_box(points: Sequence[Tuple[float, float]]) -> SectionBoundingBox:
+    if not points:
+        raise ValueError("无法从空几何计算包围框")
+    ys = [point[0] for point in points]
+    zs = [point[1] for point in points]
+    return SectionBoundingBox(min(ys), min(zs), max(ys), max(zs))
+
+
+def _quadrant_point(
+        points: Sequence[Tuple[float, float]],
+        cent_y: float,
+        cent_z: float,
+        quadrant: str,
+) -> Tuple[float, float]:
+    if quadrant == "left_top":
+        candidates = [point for point in points if point[0] < cent_y and point[1] > cent_z]
+        fallback = [point for point in points if point[0] <= cent_y and point[1] >= cent_z]
+        key = lambda point: (point[1], -point[0])
+    elif quadrant == "right_top":
+        candidates = [point for point in points if point[0] > cent_y and point[1] > cent_z]
+        fallback = [point for point in points if point[0] >= cent_y and point[1] >= cent_z]
+        key = lambda point: (point[1], point[0])
+    elif quadrant == "right_bottom":
+        candidates = [point for point in points if point[0] > cent_y and point[1] < cent_z]
+        fallback = [point for point in points if point[0] >= cent_y and point[1] <= cent_z]
+        key = lambda point: (-point[1], point[0])
+    else:
+        candidates = [point for point in points if point[0] < cent_y and point[1] < cent_z]
+        fallback = [point for point in points if point[0] <= cent_y and point[1] <= cent_z]
+        key = lambda point: (-point[1], -point[0])
+    return max(candidates or fallback or list(points), key=key)
+
+
+def _control_points(
+        points: Sequence[Tuple[float, float]], cent_y: float, cent_z: float,
+) -> Tuple[SectionControlPoint, ...]:
+    definitions = (
+        ("左上", "left_top"),
+        ("右上", "right_top"),
+        ("右下", "right_bottom"),
+        ("左下", "left_bottom"),
+    )
+    return tuple(
+        SectionControlPoint(name, point[0] - cent_y, point[1] - cent_z)
+        for name, quadrant in definitions
+        for point in (_quadrant_point(points, cent_y, cent_z, quadrant),)
+    )
+
+
+def _property_from_moments(
+        moments: _Moments,
+        points: Sequence[Tuple[float, float]],
+) -> Tuple[SectionProperty, SectionBoundingBox, Tuple[SectionControlPoint, ...]]:
+    if moments.area <= _EPSILON:
+        raise ValueError("截面换算面积必须大于0")
+    cent_y = moments.first_y / moments.area
+    cent_z = moments.first_z / moments.area
+    iy = moments.iy_origin - moments.area * cent_z ** 2
+    iz = moments.iz_origin - moments.area * cent_y ** 2
+    iyz = moments.iyz_origin - moments.area * cent_y * cent_z
+    bounds = _bounding_box(points)
+    controls = _control_points(points, cent_y, cent_z)
+    prop = SectionProperty(
+        Ax=_clean(moments.area),
+        Iy=_clean(iy),
+        Iz=_clean(iz),
+        Iyz=_clean(iyz),
+        Cyp=_clean(bounds.max_y - cent_y),
+        Cym=_clean(cent_y - bounds.min_y),
+        Czp=_clean(bounds.max_z - cent_z),
+        Czm=_clean(cent_z - bounds.min_z),
+        PeriO=_clean(moments.perimeter_outer),
+        PeriI=_clean(moments.perimeter_inner),
+        CentY=_clean(cent_y),
+        CentZ=_clean(cent_z),
+        Y1=_clean(controls[0].y),
+        Z1=_clean(controls[0].z),
+        Y2=_clean(controls[1].y),
+        Z2=_clean(controls[1].z),
+        Y3=_clean(controls[2].y),
+        Z3=_clean(controls[2].z),
+        Y4=_clean(controls[3].y),
+        Z4=_clean(controls[3].z),
+    )
+    return prop, bounds, controls
+
+
+class SectionPropertySolver:
+    """对 :class:`SectionShape` 执行无外部依赖的几何积分。"""
+
+    @staticmethod
+    def calculate(
+            shape: Union[SectionShape, Mapping[str, Any]],
+            elastic_modulus_ratio: Optional[float] = None,
+            reference_role: str = "main",
+            material_factors: Optional[Mapping[str, float]] = None,
+    ) -> SectionProperty:
+        """返回与桥通字段兼容的 ``SectionProperty``。
+
+        ``elastic_modulus_ratio`` 表示主材/辅材弹性模量比。以主材为换算基准时
+        辅材系数为 ``1 / ratio``；以辅材为基准时主材系数为 ``ratio``。
+        ``material_factors`` 可为任意 role 显式指定换算系数，优先级更高。
+        """
+        return SectionPropertySolver.calculate_detailed(
+            shape,
+            elastic_modulus_ratio=elastic_modulus_ratio,
+            reference_role=reference_role,
+            material_factors=material_factors,
+        ).property
+
+    @staticmethod
+    def calculate_detailed(
+            shape: Union[SectionShape, Mapping[str, Any]],
+            elastic_modulus_ratio: Optional[float] = None,
+            reference_role: str = "main",
+            material_factors: Optional[Mapping[str, float]] = None,
+    ) -> SectionPropertyResult:
+        if isinstance(shape, Mapping) and not isinstance(shape, SectionShape):
+            shape = SectionShape.from_dict(shape)
+        if not isinstance(shape, SectionShape):
+            raise TypeError("shape 必须是 SectionShape 或可转换为 SectionShape 的字典")
+        if shape.is_tapered:
+            if not shape.begin_parts or not shape.end_parts:
+                raise ValueError("变截面必须同时包含 begin_parts 和 end_parts")
+            begin_shape = SectionShape(
+                index=shape.index,
+                name=shape.name,
+                sec_type=shape.sec_type,
+                shape_type="composite" if len(shape.begin_parts) > 1 else shape.begin_parts[0].shape_type,
+                parts=shape.begin_parts,
+            )
+            end_shape = SectionShape(
+                index=shape.index,
+                name=shape.name,
+                sec_type=shape.sec_type,
+                shape_type="composite" if len(shape.end_parts) > 1 else shape.end_parts[0].shape_type,
+                parts=shape.end_parts,
+            )
+            begin = SectionPropertySolver.calculate_detailed(
+                begin_shape, elastic_modulus_ratio, reference_role, material_factors
+            )
+            end = SectionPropertySolver.calculate_detailed(
+                end_shape, elastic_modulus_ratio, reference_role, material_factors
+            )
+            all_points = tuple(
+                (point.property.CentY + control.y, point.property.CentZ + control.z)
+                for point in (begin, end)
+                for control in point.control_points
+            )
+            return SectionPropertyResult(
+                property=SectionProperty(sec_begin=begin.property, sec_end=end.property),
+                bounding_box=_bounding_box(all_points),
+                control_points=begin.control_points,
+                parts=begin.parts + end.parts,
+                transformed=begin.transformed or end.transformed,
+                reference_role=reference_role,
+                elastic_modulus_ratio=elastic_modulus_ratio,
+            )
+        if not shape.parts:
+            raise ValueError("特性截面没有几何数据，无法进行本地几何积分")
+        if elastic_modulus_ratio is not None and elastic_modulus_ratio <= 0.0:
+            raise ValueError("elastic_modulus_ratio 必须大于0")
+        if reference_role not in ("main", "secondary"):
+            raise ValueError("reference_role 必须为 'main' 或 'secondary'")
+
+        factors: Dict[str, float] = {}
+        if material_factors is not None:
+            factors = {str(key): float(value) for key, value in material_factors.items()}
+            if any(value <= 0.0 or not isfinite(value) for value in factors.values()):
+                raise ValueError("material_factors 中的换算系数必须是大于0的有限数")
+        elif elastic_modulus_ratio is not None:
+            if reference_role == "main":
+                factors = {"main": 1.0, "secondary": 1.0 / elastic_modulus_ratio}
+            else:
+                factors = {"main": elastic_modulus_ratio, "secondary": 1.0}
+
+        raw_parts = tuple((part, _part_moments(part)) for part in shape.parts)
+        weighted_parts = tuple(
+            moments.scaled(factors.get(part.role, 1.0))
+            for part, moments in raw_parts
+        )
+        total = _add_moments(weighted_parts)
+        all_points = tuple(point for _part, moments in raw_parts for point in moments.points)
+        prop, bounds, controls = _property_from_moments(total, all_points)
+
+        part_results = []
+        for part, moments in raw_parts:
+            part_property, part_bounds, _part_controls = _property_from_moments(
+                moments, moments.points
+            )
+            part_results.append(SectionPartProperty(
+                role=part.role,
+                index=part.index,
+                material_factor=factors.get(part.role, 1.0),
+                property=part_property,
+                bounding_box=part_bounds,
+            ))
+
+        transformed = any(abs(factors.get(part.role, 1.0) - 1.0) > _EPSILON for part, _ in raw_parts)
+        return SectionPropertyResult(
+            property=prop,
+            bounding_box=bounds,
+            control_points=controls,
+            parts=tuple(part_results),
+            transformed=transformed,
+            reference_role=reference_role if transformed else None,
+            elastic_modulus_ratio=elastic_modulus_ratio if transformed else None,
+        )
+
+
+__all__ = [
+    "SectionBoundingBox",
+    "SectionControlPoint",
+    "SectionPartProperty",
+    "SectionPropertyResult",
+    "SectionPropertySolver",
+]

{qtmodel-2.4.2 → qtmodel-2.5.0}/src/qtmodel/mdb/mdb_section.py

@@ -4,6 +4,7 @@ from qtmodel.core.data_helper import QtDataHelper
 from qtmodel.core.qt_server import QtServer
 from qtmodel.core.section_db import SectionDB
 from qtmodel.core.section_geometry import SectionGeometryDB
+from qtmodel.core.section_property_solver import SectionPropertyResult, SectionPropertySolver
 from qtmodel.core.section_shape import SectionShape
 
 
@@ -75,6 +76,71 @@ class MdbSection:
             box_height=section_kwargs.get("box_height", 2),
         )
 
+    @staticmethod
+    def get_parameter_section_property_local(
+            sec_type: str,
+            sec_info: Mapping[str, Any],
+            mat_combine: list[float] = None,
+            reference_role: str = "main",
+            name: str = "",
+    ) -> SectionPropertyResult:
+        """在本地计算参数化截面的可严格验证几何特性。
+
+        本方法不会连接桥通或修改当前模型。当前计算面积、形心、Iy、Iz、
+        Iyz、内外轮廓周长、包围框和四个控制点；组合截面按
+        ``mat_combine[0]``（主材/辅材弹性模量比）进行换算。
+
+        Args:
+            sec_type: 参数化截面类型。
+            sec_info: 有含义的参数字典，坐标和厚度单位为 m。
+            mat_combine: 组合材料参数，可选；第一项为主材/辅材弹模比。
+            reference_role: 换算基准，``main`` 或 ``secondary``。
+            name: 临时截面名称。
+
+        Returns:
+            包含 ``SectionProperty``、包围框、控制点及各部件特性的详细结果。
+        """
+        if mat_combine is not None and len(mat_combine) != 5:
+            raise ValueError("mat_combine 必须包含5个组合材料参数")
+        shape = MdbSection.get_parameter_section_shape(
+            sec_type=sec_type,
+            sec_info=sec_info,
+            mat_combine=mat_combine,
+            name=name,
+        )
+        return SectionPropertySolver.calculate_detailed(
+            shape,
+            elastic_modulus_ratio=(float(mat_combine[0]) if mat_combine else None),
+            reference_role=reference_role,
+        )
+
+    @staticmethod
+    def get_section_property_local(
+            sec_type: str,
+            sec_info: Union[list[float], Mapping[str, Any]] = None,
+            mat_combine: list[float] = None,
+            reference_role: str = "main",
+            **shape_options: Any,
+    ) -> SectionPropertyResult:
+        """按 ``get_section_shape`` 的参数本地计算截面几何特性。
+
+        自定义线圈可在 ``shape_options`` 中传 ``loop_segments``，自定义线宽
+        可传 ``sec_lines``。多条线宽按矩形条带叠加，交点不进行布尔去重。
+        """
+        if mat_combine is not None and len(mat_combine) != 5:
+            raise ValueError("mat_combine 必须包含5个组合材料参数")
+        shape = MdbSection.get_section_shape(
+            sec_type=sec_type,
+            sec_info=sec_info,
+            mat_combine=mat_combine,
+            **shape_options,
+        )
+        return SectionPropertySolver.calculate_detailed(
+            shape,
+            elastic_modulus_ratio=(float(mat_combine[0]) if mat_combine else None),
+            reference_role=reference_role,
+        )
+
     @staticmethod
     def get_section_shape(
             sec_type: str,

qtmodel-2.4.2/README.md → qtmodel-2.5.0/src/qtmodel.egg-info/PKG-INFO

@@ -1,6 +1,40 @@
-> 最新qtmodel版本 2.4.2 - 2026-07-17 
+Metadata-Version: 2.4
+Name: qtmodel
+Version: 2.5.0
+Summary: qtmodel package
+Author: Your Name
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: psutil>=5.9
+
+> 最新qtmodel版本 2.5.0 - 2026-07-18
 > pip install --upgrade qtmodel -i https://pypi.org/simple
-- 增加检算荷载API
+- 增加纯 Python 本地截面特性求解：面积、形心、Iy/Iz/Iyz、内外周长、
+  包围框、四个控制点、组合截面换算特性和线宽截面特性。
+
+## 本地截面特性计算
+
+本地求解不要求打开桥通，不发送 HTTP 请求。所有坐标和厚度单位为 m，
+面积单位为 m²，惯性矩单位为 m⁴。
+
+```Python
+from qtmodel import mdb
+
+result = mdb.get_parameter_section_property_local(
+    sec_type="矩形",
+    sec_info={"W": 2.0, "H": 1.0},
+)
+print(result.property.Ax, result.property.Iy, result.bounding_box.to_dict())
+
+line_result = mdb.get_section_property_local(
+    sec_type="自定义线宽截面",
+    sec_lines=[[0, 0, 2, 0, 0.02]],
+)
+```
+
+当前本地求解器仅填写可由二维几何严格积分的字段。``Ix``、``Ay``、``Az``、
+剪心和静矩保持为零，完整截面求解仍使用 ``odb.get_section_property``。
 # 建模操作 
 ##  节点操作
 ### generate_curve_node_data

{qtmodel-2.4.2 → qtmodel-2.5.0}/src/qtmodel.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/qtmodel/bridge.py
 src/qtmodel.egg-info/PKG-INFO
 src/qtmodel.egg-info/SOURCES.txt
 src/qtmodel.egg-info/dependency_links.txt
+src/qtmodel.egg-info/requires.txt
 src/qtmodel.egg-info/top_level.txt
 src/qtmodel/cdb/__init__.py
 src/qtmodel/cdb/cdb_anti_overturn_check.py
@@ -19,6 +20,7 @@ src/qtmodel/core/qt_server.py
 src/qtmodel/core/result_db.py
 src/qtmodel/core/section_db.py
 src/qtmodel/core/section_geometry.py
+src/qtmodel/core/section_property_solver.py
 src/qtmodel/core/section_shape.py
 src/qtmodel/mdb/__init__.py
 src/qtmodel/mdb/mdb_analysis_setting.py
@@ -48,4 +50,5 @@ src/qtmodel/odb/odb_result_plot.py
 src/qtmodel/odb/odb_view.py
 tests/test_section_db.py
 tests/test_section_geometry.py
+tests/test_section_property_solver.py
 tests/test_section_shape.py

qtmodel-2.5.0/src/qtmodel.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.28
+psutil>=5.9

qtmodel-2.5.0/tests/test_section_property_solver.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+import importlib
+from pathlib import Path
+import sys
+import types
+import unittest
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1] / "src" / "qtmodel"
+if "qtmodel" not in sys.modules:
+    package = types.ModuleType("qtmodel")
+    package.__path__ = [str(PACKAGE_ROOT)]
+    sys.modules["qtmodel"] = package
+
+CORE = importlib.import_module("qtmodel.core")
+SectionGeometryDB = CORE.SectionGeometryDB
+SectionPropertySolver = CORE.SectionPropertySolver
+
+
+class SectionPropertySolverTests(unittest.TestCase):
+    def assertAlmostRelative(self, actual, expected, places=12):
+        self.assertAlmostEqual(actual, expected, places=places)
+
+    def test_rectangle_has_exact_analytical_properties(self):
+        shape = SectionGeometryDB.generate("矩形", [2.0, 1.0])
+        result = SectionPropertySolver.calculate_detailed(shape)
+        prop = result.property
+
+        self.assertAlmostRelative(prop.Ax, 2.0)
+        self.assertAlmostRelative(prop.CentY, 1.0)
+        self.assertAlmostRelative(prop.CentZ, 0.5)
+        self.assertAlmostRelative(prop.Iy, 2.0 / 12.0)
+        self.assertAlmostRelative(prop.Iz, 8.0 / 12.0)
+        self.assertAlmostRelative(prop.Iyz, 0.0)
+        self.assertAlmostRelative(prop.PeriO, 6.0)
+        self.assertAlmostRelative(prop.PeriI, 0.0)
+        self.assertEqual(
+            [(point.y, point.z) for point in result.control_points],
+            [(-1.0, 0.5), (1.0, 0.5), (1.0, -0.5), (-1.0, -0.5)],
+        )
+        self.assertEqual(result.bounding_box.to_dict(), {
+            "min_y": 0.0,
+            "min_z": 0.0,
+            "max_y": 2.0,
+            "max_z": 1.0,
+            "width": 2.0,
+            "height": 1.0,
+        })
+
+    def test_hole_orientation_does_not_change_subtraction(self):
+        shape = SectionGeometryDB.generate(
+            "自定义线圈截面",
+            loop_segments=[{
+                "main": [[0, 0], [4, 0], [4, 2], [0, 2]],
+                # 故意与外圈同为逆时针，求解器仍必须把它识别为孔洞。
+                "sub1": [[1, 0.5], [3, 0.5], [3, 1.5], [1, 1.5]],
+            }],
+        )
+        prop = SectionPropertySolver.calculate(shape)
+
+        self.assertAlmostRelative(prop.Ax, 6.0)
+        self.assertAlmostRelative(prop.CentY, 2.0)
+        self.assertAlmostRelative(prop.CentZ, 1.0)
+        self.assertAlmostRelative(prop.Iy, 2.5)
+        self.assertAlmostRelative(prop.Iz, 10.0)
+        self.assertAlmostRelative(prop.PeriO, 12.0)
+        self.assertAlmostRelative(prop.PeriI, 6.0)
+
+    def test_product_of_inertia_is_translation_invariant_about_centroid(self):
+        base = SectionGeometryDB.generate(
+            "自定义线圈截面",
+            loop_segments=[{"main": [[0, 0], [2, 0], [0, 1]]}],
+        )
+        moved = SectionGeometryDB.generate(
+            "自定义线圈截面",
+            loop_segments=[{"main": [[10, -7], [12, -7], [10, -6]]}],
+        )
+        first = SectionPropertySolver.calculate(base)
+        second = SectionPropertySolver.calculate(moved)
+        self.assertAlmostRelative(first.Iy, second.Iy)
+        self.assertAlmostRelative(first.Iz, second.Iz)
+        self.assertAlmostRelative(first.Iyz, second.Iyz)
+
+    def test_composite_section_uses_modular_ratio(self):
+        shape = SectionGeometryDB.generate(
+            "自定义组合截面",
+            loop_segments=[{"main": [[0, 0], [2, 0], [2, 1], [0, 1]]}],
+            secondary_loop_segments=[{
+                "main": [[0, 1], [2, 1], [2, 2], [0, 2]],
+            }],
+        )
+        result = SectionPropertySolver.calculate_detailed(
+            shape,
+            elastic_modulus_ratio=2.0,
+            reference_role="main",
+        )
+        prop = result.property
+
+        self.assertTrue(result.transformed)
+        self.assertAlmostRelative(prop.Ax, 3.0)
+        self.assertAlmostRelative(prop.CentY, 1.0)
+        self.assertAlmostRelative(prop.CentZ, 5.0 / 6.0)
+        self.assertAlmostRelative(prop.Iy, 11.0 / 12.0)
+        self.assertAlmostRelative(prop.Iz, 1.0)
+        self.assertEqual(
+            [part.material_factor for part in result.parts], [1.0, 0.5]
+        )
+
+    def test_line_width_uses_exact_oriented_rectangle_formula(self):
+        shape = SectionGeometryDB.generate(
+            "自定义线宽截面",
+            sec_lines=[[0, 0, 2, 0, 0.02]],
+        )
+        result = SectionPropertySolver.calculate_detailed(shape)
+        prop = result.property
+
+        self.assertAlmostRelative(prop.Ax, 0.04)
+        self.assertAlmostRelative(prop.CentY, 1.0)
+        self.assertAlmostRelative(prop.CentZ, 0.0)
+        self.assertAlmostRelative(prop.Iy, 2.0 * 0.02 ** 3 / 12.0)
+        self.assertAlmostRelative(prop.Iz, 0.02 * 2.0 ** 3 / 12.0)
+        self.assertAlmostRelative(prop.Iyz, 0.0)
+        self.assertAlmostRelative(result.bounding_box.min_z, -0.01)
+        self.assertAlmostRelative(result.bounding_box.max_z, 0.01)
+        self.assertEqual(prop.PeriO, 0.0)
+        self.assertEqual(prop.PeriI, 0.0)
+
+    def test_invalid_geometry_is_rejected(self):
+        shape = SectionGeometryDB.generate(
+            "自定义线宽截面",
+            sec_lines=[[0, 0, 0, 0, 0.02]],
+        )
+        with self.assertRaisesRegex(ValueError, "长度必须大于0"):
+            SectionPropertySolver.calculate(shape)
+
+    def test_detailed_result_is_json_serializable_data(self):
+        shape = SectionGeometryDB.generate("矩形", [2.0, 1.0])
+        data = SectionPropertySolver.calculate_detailed(shape).to_dict()
+        self.assertEqual(data["units"]["area"], "m²")
+        self.assertIn("Iy", data["calculated_fields"])
+        self.assertIn("Ix", data["not_calculated_fields"])
+
+
+if __name__ == "__main__":
+    unittest.main()