civil-tools-v 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

CivilTools/DXFGenerator/DetailDXF.py

@@ -0,0 +1,324 @@
+from typing import List
+from .BasicDXF import BasicDXF
+from .DrawingAttribs import (
+    DrawingAttribs,
+    PolylineAttribs,
+    TextAttribs,
+    TextEntityAlignment,
+)
+from .LayerManager import DefaultLayers, CADColor
+from CivilTools.Const import Concrete, ConcreteLevel, Steel, SteelLevel
+
+
+class DetailDXF(BasicDXF):
+    def __init__(self):
+        super().__init__()
+
+
+default_floor_height_table_attribs = {
+    "column_con_level": None,
+    "column_steel_level": None,
+    "beam_con_level": None,
+    "beam_steel_level": None,
+}
+
+
+class FloorInformation:
+    def __init__(
+        self,
+        name: str,
+        archi_elevation: float,
+        plaster_thickness: float = 200,
+        beam_slab_con_mat: ConcreteLevel = Concrete.C35,
+        wall_con_mat: ConcreteLevel = Concrete.C60,
+        column_con_mat: ConcreteLevel = Concrete.C50,
+        brace_con_mat: ConcreteLevel = Concrete.C50,
+        beam_steel_mat: SteelLevel = Steel.HRB300,
+        column_steel_mat: SteelLevel = Steel.Q355,
+        brace_steel_mat: SteelLevel = Steel.Q355,
+    ):
+        if plaster_thickness < 0:
+            raise ValueError("Plaster value should be non-negitive.")
+        self.floor_name = name
+        self.__struct_elevation = archi_elevation - plaster_thickness
+        self.__archi_elevation = archi_elevation
+
+        self.beam_slab_con_mat = beam_slab_con_mat
+        self.wall_con_mat = wall_con_mat
+        self.column_con_mat = column_con_mat
+        self.brace_con_mat = brace_con_mat
+
+        self.beam_steel_mat = beam_steel_mat
+        self.column_steel_mat = column_steel_mat
+        self.brace_steel_mat = brace_steel_mat
+        self.is_embedded = False
+
+    def get_attribute_by_name(self, attrib_name: str):
+        if "楼层号" in attrib_name:
+            return self.floor_name
+        if "建筑" in attrib_name and "标高" in attrib_name:
+            return self.archi_elevation
+        if "结构" in attrib_name and "标高" in attrib_name:
+            return self.struct_elevation
+        if "柱" in attrib_name:
+            return self.column_con_mat.name
+        if "墙" in attrib_name:
+            return self.wall_con_mat.name
+        if "板" in attrib_name:
+            return self.beam_slab_con_mat.name
+
+    @property
+    def struct_elevation(self):
+        if self.__struct_elevation == 0:
+            return "±0.000"
+        return f"{self.__struct_elevation/1000:.3f}"
+
+    @property
+    def archi_elevation(self):
+        if self.__archi_elevation == 0:
+            return "±0.000"
+        return f"{self.__archi_elevation/1000:.3f}"
+
+
+class FloorHeightTableDXF(BasicDXF):
+    def __prepare(self):
+        useful_layers = [DefaultLayers.TEXT, DefaultLayers.SYMBOL]
+        self.init_layers(useful_layers)
+
+    def __init__(
+        self,
+        above_floor_num: int,
+        under_floor_num: int,
+        base_elevation: float,
+        font_size: float = 300,
+    ):
+        super().__init__()
+        self.__prepare()
+        self.__above_floor_num = above_floor_num
+        self.__under_floor_num = under_floor_num
+        self.__base_elevation = base_elevation
+        self.floor_num = above_floor_num + under_floor_num
+        self.floors = self.__create_floors()
+        self.__font_size = font_size
+        self.__table_title = None
+        self.has_embeded_floor = False
+        self.embeded_floor = None
+        self.insert_point = [0, 0]
+
+        for key, value in default_floor_height_table_attribs.items():
+            setattr(self, key, value)
+
+    def __create_floors(self) -> List[FloorInformation]:
+        result = []
+        for i in range(self.__above_floor_num):
+            temp_floor = FloorInformation(f"F{i+1}", self.__base_elevation + 3500 * i)
+            result.append(temp_floor)
+        for i in range(self.__under_floor_num):
+            temp_floor = FloorInformation(
+                f"B{i+1}", self.__base_elevation - 3500 * (i + 1)
+            )
+            result.insert(0, temp_floor)
+        return result
+
+    def export_dxf(self, path):
+        self._remove_all_entities()
+        self.__draw_table_title()
+        self.__analysis_table_columns()
+        self.__draw_table_grid()
+        self.__draw_table_column_title()
+        self.__draw_context()
+        self.__draw_supplement_info()
+        self._save(path)
+
+    def set_table_title(self, title: str):
+        self.__table_title = title
+
+    def set_font_size(self, font_size: float):
+        self.__font_size = font_size
+
+    def set_embeding_floor(self, floor_name: str | None):
+        """Use None to reset embeded floor."""
+        if floor_name == None:
+            self.has_embeded_floor = False
+            self.embeded_floor = None
+            return
+        for floor in self.floors:
+            if floor.floor_name == floor_name:
+                floor.is_embedded = True
+                self.has_embeded_floor = True
+                self.embeded_floor = floor
+                return
+        raise ValueError(f"No floor named as {floor_name}")
+
+    def __analysis_table_columns(self):
+        self.__columns = []
+        self.__column_widths = []
+
+        self.__columns.append("当前层")
+        self.__column_widths.append(3)
+
+        self.__columns.append("建筑楼层号")
+        self.__column_widths.append(5)
+
+        self.__columns.append("建筑标高(m)")
+        self.__column_widths.append(6)
+
+        self.__columns.append("结构标高(m)")
+        self.__column_widths.append(6)
+
+        self.__first_part_column_num = len(self.__columns)
+
+        self.__columns.append("结构柱")
+        self.__column_widths.append(3)
+
+        self.__columns.append("剪力墙")
+        self.__column_widths.append(3)
+
+        self.__columns.append("梁/板")
+        self.__column_widths.append(3)
+
+    def __draw_table_title(self):
+        if self.__table_title == None:
+            return
+        text_attrib = TextAttribs(
+            DefaultLayers.TEXT.name,
+            text_height=self.__font_size,
+            text_align=TextEntityAlignment.MIDDLE_LEFT,
+        )
+        self._add_text(
+            self.__table_title,
+            [self.insert_point[0], self.insert_point[1] + self.__font_size * 1.5],
+            text_attrib,
+        )
+
+    def __draw_table_grid(self):
+        first_part_column_num = self.__first_part_column_num
+        start_x = self.insert_point[0]
+        start_y = self.insert_point[1]
+        font_factor = self.__font_size
+
+        total_width = font_factor * sum(self.__column_widths)
+        first_part_width = font_factor * sum(
+            self.__column_widths[:first_part_column_num]
+        )
+
+        total_height = font_factor * 2 * (self.floor_num + 2)
+        grid_draw_attrib = PolylineAttribs(DefaultLayers.SYMBOL.name)
+        for i in range(self.floor_num + 3):
+            if i == 1:
+                self._add_horizental_line(
+                    start_x + first_part_width,
+                    start_y,
+                    total_width - first_part_width,
+                    grid_draw_attrib,
+                )
+            else:
+                self._add_horizental_line(
+                    start_x, start_y, total_width, grid_draw_attrib
+                )
+            start_y -= font_factor * 2
+            if (
+                i - 2 >= 0
+                and i - 2 < self.floor_num
+                and self.floors[::-1][i - 2].is_embedded
+            ):
+                self._add_horizental_line(
+                    start_x, start_y + font_factor * 0.2, total_width, grid_draw_attrib
+                )
+        start_y = 0
+        for i in range(len(self.__columns) + 1):
+            if i <= first_part_column_num or i == len(self.__columns):
+                self._add_vertical_line(
+                    start_x, start_y, -total_height, grid_draw_attrib
+                )
+            else:
+                self._add_vertical_line(
+                    start_x,
+                    start_y - font_factor * 2,
+                    -total_height + font_factor * 2,
+                    grid_draw_attrib,
+                )
+            if i == len(self.__columns):
+                continue
+            start_x += font_factor * self.__column_widths[i]
+
+    def __draw_table_column_title(self):
+        font_factor = self.__font_size
+        start_x = self.insert_point[0]
+        start_y = self.insert_point[1]
+
+        table_column_title_attrib = TextAttribs(
+            DefaultLayers.TEXT.name,
+            text_height=font_factor,
+            text_align=TextEntityAlignment.MIDDLE_CENTER,
+        )
+
+        for i in range(len(self.__columns)):
+            temp_string = self.__columns[i]
+            temp_x = (
+                sum(self.__column_widths[: i + 1]) - self.__column_widths[i] / 2
+            ) * font_factor
+            temp_y = (
+                -font_factor * 2
+                if i < self.__first_part_column_num
+                else -font_factor * 3
+            )
+            self._add_text(
+                temp_string,
+                [start_x + temp_x, start_y + temp_y],
+                table_column_title_attrib,
+            )
+        temp_x = (
+            (
+                sum(self.__column_widths)
+                + sum(self.__column_widths[: self.__first_part_column_num])
+            )
+            / 2.0
+            * font_factor
+        )
+        temp_y = -font_factor * 1
+        self._add_text("混凝土结构", [temp_x, temp_y], table_column_title_attrib)
+
+    def __draw_context(self):
+        font_factor = self.__font_size
+
+        start_x = self.insert_point[0]
+        start_y = self.insert_point[1] - font_factor * 4
+        for i in range(len(self.floors)):
+            temp_floor = self.floors[::-1][i]
+            for j in range(1, len(self.__columns)):
+                temp_insert_point = [
+                    start_x + font_factor * (sum(self.__column_widths[: j + 1]) - 0.5),
+                    start_y - font_factor * (2 * i + 1),
+                ]
+                temp_string = temp_floor.get_attribute_by_name(self.__columns[j])
+                self._add_text(
+                    temp_string,
+                    temp_insert_point,
+                    TextAttribs(
+                        DefaultLayers.TEXT.name,
+                        color_index=CADColor.Yellow.value,
+                        text_height=font_factor,
+                        text_align=TextEntityAlignment.MIDDLE_RIGHT,
+                    ),
+                )
+
+    def __draw_supplement_info(self):
+        if not self.has_embeded_floor:
+            return
+        font_factor = self.__font_size
+        temp_x = self.insert_point[0]
+        temp_y = self.insert_point[1] - font_factor * (self.floor_num + 2.5) * 2
+        table_supplement_info_attrib = TextAttribs(
+            DefaultLayers.TEXT.name,
+            text_height=font_factor,
+            text_align=TextEntityAlignment.MIDDLE_LEFT,
+        )
+        self._add_text(
+            f"上部嵌固层：{self.embeded_floor.floor_name}，标高：{self.embeded_floor.struct_elevation}。",
+            [temp_x, temp_y],
+            table_supplement_info_attrib,
+        )
+
+    def __draw_embeding_dimension(self):
+        return NotImplemented

CivilTools/DXFGenerator/DrawingAttribs.py

@@ -0,0 +1,45 @@
+from ezdxf.enums import TextEntityAlignment
+from CivilTools.Const import CADConst
+
+
+class DrawingAttribs:
+    """这是一个基础的属性，包含图层、颜色等所有人都有的信息"""
+
+    def __init__(
+        self,
+        layer: str,
+        color_index: int = CADConst.BY_LAYER,
+    ):
+        self.layer = layer
+        self.color_index = color_index
+
+
+class PolylineAttribs(DrawingAttribs):
+    """Polyline对象的属性，包括是否封闭等"""
+
+    def __init__(
+        self,
+        layer,
+        color_index: int = CADConst.BY_LAYER,
+        close: bool = False,
+        constant_width: float = 0,
+    ):
+        super().__init__(layer, color_index)
+        self.close = close
+        self.constant_width = constant_width
+        """全局宽度"""
+
+
+class TextAttribs(DrawingAttribs):
+    def __init__(
+        self,
+        layer,
+        color_index: int = CADConst.BY_LAYER,
+        text_height: float = 300,
+        text_width_factor: float = 0.7,
+        text_align: TextEntityAlignment = TextEntityAlignment.MIDDLE_CENTER,
+    ):
+        super().__init__(layer, color_index)
+        self.text_height = text_height
+        self.text_width_factor = text_width_factor
+        self.text_align = text_align

CivilTools/DXFGenerator/LayerManager.py

@@ -0,0 +1,37 @@
+from enum import Enum
+
+
+class CADColor(Enum):
+    Red = 1
+    Yellow = 2
+    Green = 3
+    Cyan = 4
+    Blue = 5
+    Magenta = 6
+    White = 7
+    Gray = 8
+    LightGray = 9
+
+
+class CADLineType(Enum):
+    Continuous = 1
+    DASHED = 2
+    CENTER = 3
+    DASHDOT = 4
+
+
+class CADLayer:
+    def __init__(
+        self,
+        name: str,
+        color: CADColor,
+        line_type: CADLineType = CADLineType.Continuous,
+    ):
+        self.name = name
+        self.color = color
+        self.line_type = line_type
+
+
+class DefaultLayers:
+    TEXT = CADLayer("0S-TEXT", CADColor.Cyan)
+    SYMBOL = CADLayer("0S-SYMB", CADColor.Red)

CivilTools/DXFGenerator/__init__.py

@@ -0,0 +1,3 @@
+from .BasicDXF import BasicDXF, DrawingAttribs
+from .LayerManager import CADColor,CADLayer,CADLineType
+from .DetailDXF import FloorHeightTableDXF

CivilTools/FigureGenerator/BasicPNGPlotter.py

@@ -1,43 +1,46 @@
 from PIL import Image, ImageDraw
 import warnings
 
+
 class BasicPNGPlotter:
-    def __init__(self, width, height, bg = (0,0,0,0)):
+    def __init__(self, width, height, bg=(0, 0, 0, 0)):
         self.width = width
         self.height = height
-        self.image = Image.new('RGBA', (width, height), bg)
+        self.image = Image.new("RGBA", (width, height), bg)
         self.draw = ImageDraw.Draw(self.image)
-        
-    def draw_horizental_line(self,s_x,s_y,length,color = "black",line_width = 2):
+
+    def draw_horizental_line(self, s_x, s_y, length, color="black", line_width=2):
         """画一段水平线，length为长度，正代表向右"""
-        self.draw_line(s_x,s_y,s_x + length, s_y,color,line_width)
-        
-    def draw_vertical_line(self,s_x,s_y,length,color = "black",line_width = 2):
+        self.draw_line(s_x, s_y, s_x + length, s_y, color, line_width)
+
+    def draw_vertical_line(self, s_x, s_y, length, color="black", line_width=2):
         """画一段竖直线，length为长度，正代表向下"""
-        self.draw_line(s_x,s_y,s_x + length, s_y,color,line_width)
-    
-    def draw_rectangle(self,s_x, s_y, rec_width, rec_height,color = "black",line_width = 2):
+        self.draw_line(s_x, s_y, s_x + length, s_y, color, line_width)
+
+    def draw_rectangle(
+        self, s_x, s_y, rec_width, rec_height, color="black", line_width=2
+    ):
         """画一个矩形，左上角点为s_x,s_y，width正代表向右，height正代表向下"""
-        self.draw_horizental_line(s_x,s_y,rec_width,color,line_width)
-        self.draw_horizental_line(s_x,s_y + rec_height,rec_width,color,line_width)
-        self.draw_vertical_line(s_x,s_y,rec_height,color,line_width)
-        self.draw_vertical_line(s_x + rec_width,s_y,rec_height,color,line_width)
-    
-    def draw_line(self,s_x,s_y,e_x,e_y,color = "black",width = 2):
-        if s_x<0 or s_x > self.width or s_y <0 or s_y> self.height:
+        self.draw_horizental_line(s_x, s_y, rec_width, color, line_width)
+        self.draw_horizental_line(s_x, s_y + rec_height, rec_width, color, line_width)
+        self.draw_vertical_line(s_x, s_y, rec_height, color, line_width)
+        self.draw_vertical_line(s_x + rec_width, s_y, rec_height, color, line_width)
+
+    def draw_line(self, s_x, s_y, e_x, e_y, color="black", width=2):
+        if s_x < 0 or s_x > self.width or s_y < 0 or s_y > self.height:
             warnings.warn("Start point is out of figure.")
-        if e_x<0 or e_x > self.width or e_y <0 or e_y> self.height:
+        if e_x < 0 or e_x > self.width or e_y < 0 or e_y > self.height:
             warnings.warn("End point is out of figure.")
-        self.draw.line((s_x,s_y,e_x,e_y), fill=color, width=width)
-    
+        self.draw.line((s_x, s_y, e_x, e_y), fill=color, width=width)
+
     def draw_png(self):
-        self.draw.line((0, 0, 500, 500), fill='black', width=2)
+        self.draw.line((0, 0, 500, 500), fill="black", width=2)
 
-    def save(self,path):
-        self.image.save(path, 'PNG')
+    def save(self, path):
+        self.image.save(path, "PNG")
 
 
 if __name__ == "__main__":
-    p = BasicPNGPlotter(1500,800)
+    p = BasicPNGPlotter(1500, 800)
     p.draw_png()
-    p.save("testfiles/output.png")
+    p.save("testfiles/output.png")

CivilTools/FigureGenerator/BasicPltPlotter.py

@@ -1,3 +1,117 @@
+from typing import List
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+import io
+import numpy as np
+
+plt.rcParams["font.sans-serif"] = ["SimHei"]  # 用来正常显示中文标签
+plt.rcParams["axes.unicode_minus"] = False
+plt.rcParams["font.size"] = 14
+
+
+def GetTicks(n_max=1):
+    if n_max == 0:
+        n_max = 100
+    m = int(np.log10(n_max))
+    if m <= 0 and n_max <= 1:
+        m -= 1
+    p = n_max / (10**m)
+    if p <= 2.2:
+        result = [i * 1 * 10**m for i in range(3)]
+    elif p <= 3.5:
+        result = [i * 2 * 10**m for i in range(3)]
+    elif p <= 5:
+        result = [i * 2.5 * 10**m for i in range(3)]
+    elif p <= 6.9:
+        result = [i * 3 * 10**m for i in range(4)]
+    elif p <= 8:
+        result = [i * 2 * 10**m for i in range(5)]
+    else:
+        result = [i * 2 * 10**m for i in range(6)]
+    return result
+
 
 class BasicPltPlotter:
-    pass
+    def __init__(self, fig_num: int = 1, fig_size=(10, 10)):
+        self.fig, _axes = plt.subplots(1, fig_num, figsize=fig_size)
+        if fig_num == 1:
+            self.axes = [_axes]
+        else:
+            self.axes = _axes
+        self.fig.patch.set_facecolor("none")
+        for ax in self.axes:
+            ax.patch.set_facecolor("none")
+        self.axes: List[Axes]
+        self.__remove_border()
+
+    def __remove_border(self):
+        for ax in self.axes:
+            ax.spines["right"].set_color("none")
+            ax.spines["top"].set_color("none")
+
+    def save_to_stream(self):
+        # 将图片保存到内存中的 BytesIO 对象
+        img_buffer = io.BytesIO()
+        self.fig.savefig(img_buffer, format="png", dpi=150)  # 保存为 PNG 格式
+        plt.close()  # 关闭图形，释放内存
+        # 将指针重置到流的开头，以便后续读取
+        img_buffer.seek(0)
+        return img_buffer
+
+
+class SeismicPlotter(BasicPltPlotter):
+    def __init__(self, fig_num=2, floor_num: int = 8):
+        if fig_num != 1 and fig_num != 2:
+            raise ValueError("Only 1 or 2 is accepted for fig_num.")
+        if fig_num == 1:
+            fig_size = (3, 5)
+        else:
+            fig_size = (6, 5)
+        super().__init__(fig_num, fig_size)
+        self.kwargs_x = {
+            "label": "X",
+            "ls": "-",
+            "color": "k",
+            "marker": "o",
+            "ms": 3,
+        }
+        self.kwargs_y = {
+            "label": "X",
+            "ls": "-",
+            "color": "r",
+            "marker": "o",
+            "ms": 3,
+        }
+        self.floor_num = floor_num
+        self.y_label = "层号"
+        self._y_values = [i + 1 for i in range(self.floor_num)]
+        self._y_major_ticks = self.__create_y_ticks()
+        self._y_minor_ticks = [i + 1 for i in range(self.floor_num)]
+        self._ax1_x = [i for i in range(self.floor_num)]
+        self._ax1_y = [i * 0.5 for i in range(self.floor_num)]
+        self._ax2_x = [i for i in range(self.floor_num)]
+        self._ax2_y = [i * 0.5 for i in range(self.floor_num)]
+
+    def test_plot(self):
+        self.__plot()
+
+    def __plot(self):
+        self.axes[0].plot(self._ax1_x, self._y_values, **self.kwargs_x)
+        self.axes[0].plot(self._ax1_y, self._y_values, **self.kwargs_y)
+        self.axes[1].plot(self._ax2_x, self._y_values, **self.kwargs_x)
+        self.axes[1].plot(self._ax2_y, self._y_values, **self.kwargs_y)
+
+    def __create_y_ticks(self):
+        floor_num = self.floor_num
+        return range(0, int(floor_num) + 1, int(floor_num // 5) + 1)
+
+    def _validate_list_length(self, data_list, name):
+        """
+        验证列表长度是否与楼层数相等
+        :param data_list: 待验证的列表
+        :param name: 列表的名称，用于异常信息
+        """
+        if len(data_list) != self.floor_num:
+            raise ValueError(
+                f"Length of {name} is not equal to floor number: {self.floor_num}!"
+            )

CivilTools/FigureGenerator/SeismicReport/ShearMassRatio.py

@@ -0,0 +1,73 @@
+from ..BasicPltPlotter import SeismicPlotter, GetTicks
+from typing import List
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class ShearMassRatioPlotter(SeismicPlotter):
+    def __init__(self, fig_num=2, floor_num=8):
+        super().__init__(fig_num, floor_num)
+        self.__limit = None
+        self.type = "剪重比"
+
+    def set_data(self, shear_x: List[float], shear_y: List[float], mass: List[float]):
+        if len(shear_x) != self.floor_num:
+            raise ValueError(
+                f"Lenght of shear_x is not equal to floor number: {self.floor_num}!"
+            )
+        if len(shear_y) != self.floor_num:
+            raise ValueError(
+                f"Lenght of shear_y is not equal to floor number: {self.floor_num}!"
+            )
+        if len(mass) != self.floor_num:
+            raise ValueError(
+                f"Lenght of mass is not equal to floor number: {self.floor_num}!"
+            )
+
+        self._ax1_x = np.array(shear_x) / np.array(mass)
+        self._ax2_x = np.array(shear_y) / np.array(mass)
+
+    def set_limit(self, limit: float):
+        self.__limit = limit
+
+    def plot(self):
+        if self.__limit:
+            self.__plot_limit()
+        kwargs_x = self.kwargs_x.copy()
+        kwargs_x["label"] = "X"
+        kwargs_y = self.kwargs_x.copy()
+        kwargs_y["label"] = "Y"
+        self.axes[0].plot(self._ax1_x, self._y_values, **kwargs_x)
+        self.axes[1].plot(self._ax2_x, self._y_values, **kwargs_y)
+        self.__adjust_lim()
+        self.__add_titles()
+
+    def __plot_limit(self):
+        limitation = self.__limit
+        for ax in self.axes:
+            ax.vlines(
+                x=limitation,
+                ymin=0,
+                ymax=self.floor_num,
+                color="r",
+                linewidth=3,
+                ls="--",
+                label=f"限值{limitation*100:.1f}%",
+            )
+
+    def __adjust_lim(self):
+        xmaxs = [self._ax1_x.max(), self._ax2_x.max()]
+        for i in range(2):
+            self.axes[i].set_xlim(left=0, right=xmaxs[i] * 1.2)
+            self.axes[i].set_yticks(self._y_major_ticks)
+            self.axes[i].set_yticks(self._y_minor_ticks, minor=True)
+            x_ticks = GetTicks(xmaxs[i])
+            self.axes[i].set_xticks(x_ticks)
+            self.axes[i].set_xticklabels([f"{i*100:.1f}%" for i in x_ticks])
+
+    def __add_titles(self):
+        self.axes[0].set_ylabel(self.y_label)
+        self.axes[0].set_xlabel(f"X小震下{self.type}")
+        self.axes[1].set_xlabel(f"Y小震下{self.type}")
+        self.axes[0].legend(framealpha=0, fontsize=12, loc=4)
+        self.axes[1].legend(framealpha=0, fontsize=12, loc=4)