transsimision_line_section/PWFile.py

import math
import os.path
from collections import OrderedDict
import re
import attrs
import pandas as pd
import xlwings as xw
from Apyautocad import Apyautocad, APoint
import os
import numpy as np
from time import sleep
from attrs import define
from typing import List
import error
from array import array


def get_layer_if_not_exist_create_it(doc, layer_name):
    layers = doc.Layers
    for foo in range(layers.Count):
        layer = layers.Item(foo)
        if layer.Name == layer_name:
            return layer
    return layers.Add(layer_name)


@define
class SEntry:
    tower_name: str = ""
    tower_height: float = 0
    tower_type: str = ""
    mileage_in_s: int = 0
    back_k: float = 0  # 杆塔后侧的k值
    forth_k: float = 0  # 杆塔前侧的k值
    altitude_off: float = 0  # 中心桩高差
    foundation_low: float = 0  # 基降
    fitting: str = ""  # 金具
    is_tension_tower: bool = False  # 是否为耐张塔
    back_representive_span: float = 0  # 后侧代表档距
    forth_representive_span: float = 0  # 前侧代表档距


class SFile:
    def __init__(self) -> None:
        self.tower_dic = None

    def open(self, s_file_path):
        self.tower_dic = OrderedDict()
        tower_dic = self.tower_dic
        with open(s_file_path, encoding="gbk") as s_file_obj:
            new_k = 0
            new_reprtv_span = 0
            last_k = -1
            last_reprtv_span = -1
            last_tower_name = ""
            for line in s_file_obj:
                norm_line = line.strip()
                if norm_line == "":
                    continue
                if "首端转角号" in norm_line:
                    new_k = float(norm_line.split(":")[-1].replace("E", "e"))  # 模板系数
                    new_reprtv_span = float(
                        re.findall(r"代表档距 : {2}(\d+) {3}模板系数", norm_line)[0]
                    )  # 代表档距
                    continue
                if "塔号" in norm_line:
                    # next_is_tension_tower=True
                    if last_tower_name != "":
                        tower_dic[last_tower_name].is_tension_tower = True
                    continue
                norm_entry = re.sub(r"\s+", ",", norm_line)
                sep_entry = norm_entry.split(",")
                tower_name = sep_entry[0]
                if tower_name in tower_dic:
                    tower_dic[tower_name].forth_k = new_k  # 更新耐张塔前侧k值。
                    tower_dic[
                        tower_name
                    ].forth_representive_span = new_reprtv_span  # 更新耐张塔前侧代表档距。
                    last_k = tower_dic[tower_name].forth_k
                    last_reprtv_span = tower_dic[tower_name].forth_representive_span
                    continue
                s_entry = SEntry()
                s_entry.tower_name = tower_name
                last_tower_name = tower_name
                s_entry.tower_type = sep_entry[6]
                s_entry.tower_height = float(sep_entry[7])
                s_entry.mileage_in_s = float(sep_entry[1])
                s_entry.back_k = last_k
                s_entry.back_representive_span = last_reprtv_span
                s_entry.forth_k = new_k
                s_entry.forth_representive_span = new_reprtv_span
                s_entry.altitude_off = float(sep_entry[3])
                s_entry.foundation_low = float(sep_entry[4])
                s_entry.fitting = sep_entry[8]
                last_k = s_entry.forth_k
                last_reprtv_span = s_entry.forth_representive_span
                tower_dic[tower_name] = s_entry
        tower_dic[list(tower_dic.keys())[-1]].forth_k = -1
        tower_dic[list(tower_dic.keys())[0]].is_tension_tower = True
        tower_dic[list(tower_dic.keys())[-1]].is_tension_tower = True


@define
class Fitting:  # 金具
    fitting_length_dic = {}

    def __init__(self, fitting_file_path):
        content = []
        with open(fitting_file_path) as fitting_file:
            for line in fitting_file:
                norm_line = line.strip()
                if norm_line == "":
                    continue
                norm_entry = re.sub("\s+", ",", norm_line)
                content.append(norm_entry.split(","))
        ite = iter(content[7:])
        for fit in ite:  # 跳过前面7行
            fit_name = fit[0]
            fit_parameter = next(ite)
            self.fitting_length_dic[fit_name] = float(fit_parameter[2]) / 1000


@define
class ColorEnume:
    wire_color_rgb = [122, 219, 245]
    tree_color_rgb = [240, 226, 81]
    ground_color_rgb = [82, 79, 254]
    span_text_color_rgb = [140, 245, 236]
    representive_span_text_color_rgb = [255, 172, 75]


# 读取Z文件，找到Z断面第一个点的坐标
def plane_z_origin(z_file_path):
    with open(z_file_path) as zfile:
        content = zfile.read()
        norm_content = re.sub("\s+", ",", content)
        sep = norm_content.split(",")
        return np.array([float(sep[0]), float(sep[1])])


def deduce_zfile_from_cad_path(cad_file_path):
    dwg_file_name = os.path.split(cad_file_path)
    dwg_prefix = dwg_file_name[1].split(".")[0]
    return os.path.join(dwg_file_name[0], f"Z{dwg_prefix}")


def deduce_fit_db_from_cad_path(cad_file_path):
    dwg_file_name = os.path.split(cad_file_path)
    dwg_prefix = dwg_file_name[1].split(".")[0]
    return os.path.join(dwg_file_name[0], "Fit.db")


def curve_fun(x, span, k, gaocha):  # 弧垂公式
    return x * gaocha / span - x * (span - x) * k


def np2d_to_array(np2d):  # 把2维numpy数组转换成cad可以用的数组
    t = np.hstack((np2d, np.zeros((np2d.shape[0], 1)))).reshape(1, np2d.shape[0] * 3)
    return t[0]


@define
class StringImpactExcel:
    def read(self, wb, gaocha, span, tension):
        pos代表档距 = "F13"
        pos档距 = "L13"
        pos高差 = "R13"
        pos张力 = "AB18"
        pos总串长 = "C8"
        sheet = wb.sheets["模板"]
        sheet.range(pos高差).value = gaocha
        sheet.range(pos档距).value = span
        sheet.range(pos张力).value = tension
        string_length = sheet.range(pos总串长).value
        x = np.linspace(string_length, span, int(span / 5), endpoint=True)
        x[0] = sheet.range("E23").value
        x[1] = sheet.range("E24").value
        sheet.range(f"E25:E{25+len(x)-3}").value = x[2:].reshape(len(x[2:]), 1)
        y = (
            np.array(sheet.range(f"V23:V{23+len(x)-1}").value) / 2
        )  # 表格是乘以了2的，为了和x保持一致，没有乘比例。
        return (x, y)


def set_true_color(object, r_or_rgb_list, g=0, b=0):
    true_color = object.TrueColor
    if type(r_or_rgb_list) == List or type(r_or_rgb_list) == list:
        true_color.SetRGB(*r_or_rgb_list)
    else:
        true_color.SetRGB(r_or_rgb_list, g, b)
    object.TrueColor = true_color


@define
class StringImpactExcelRecord:
    from_tower_name: str = ""
    fo_tower_name: str = ""
    representive_span: float = 0  # 代表档距
    span: float = 0
    tension: float = 0
    gaocha: float = 0


@define
class StringImpactPlate:
    _dwg_file_path: str
    _s_file_path: str
    _draw_start_tower_name: str
    _continouse_tension_excel: str
    _string_impact_curve_excel: str
    _cad: None
    excel_record_list: List = []  # 记录对excel的操作

    def _find_target_tower_index(self, start_tower_name: str, tower_dict):
        # 从 start_tower_name开始，寻找一个耐张段
        index = []
        tower_key_list = list(tower_dict.keys())
        index.append(tower_key_list.index(start_tower_name))
        can_start_find = False
        for tower_key in tower_key_list:
            tower_info = tower_dict[tower_key]
            if tower_info.tower_name == start_tower_name:
                can_start_find = True
                continue
            if can_start_find and tower_info.is_tension_tower == True:
                found_tower_name = tower_info.tower_name
                index.append(tower_key_list.index(found_tower_name))
                break
        return index

    def _plot(self, cad, plot_x, plot_y):
        custom_layer = get_layer_if_not_exist_create_it(cad.doc, "123custom_layer")
        plot_vector = np2d_to_array(np.hstack((plot_x, plot_y)))
        added_curve = cad.model.AddPolyLine(plot_vector)
        added_curve.Layer = custom_layer.Name
        set_true_color(added_curve, *ColorEnume.wire_color_rgb)
        # TODO 应该读规程的
        plot_ground_y = plot_y - 16 * 2
        plot_ground_vector = np2d_to_array(np.hstack((plot_x, plot_ground_y)))
        added_ground_curve = cad.model.AddPolyLine(plot_ground_vector)
        added_ground_curve.Layer = custom_layer.Name
        set_true_color(added_ground_curve, *ColorEnume.ground_color_rgb)
        plot_tree_y = plot_y - 13.5 * 2
        plot_tree_vector = np2d_to_array(np.hstack((plot_x, plot_tree_y)))
        added_tree_curve = cad.model.AddPolyLine(plot_tree_vector)
        added_tree_curve.Layer = custom_layer.Name
        set_true_color(added_tree_curve, *ColorEnume.tree_color_rgb)

    def _draw_action(self, excel_app, cad):
        # TODO 计算代表档距
        s_file = SFile()
        s_file.open(self._s_file_path)
        tower_dict = s_file.tower_dic
        tower_key_list = list(tower_dict.keys())
        draw_tower_index = self._find_target_tower_index(
            self._draw_start_tower_name, tower_dict
        )
        fitting_file_path = deduce_fit_db_from_cad_path(self._dwg_file_path)
        fitting = Fitting(fitting_file_path)
        z_file_path = deduce_zfile_from_cad_path(self._dwg_file_path)
        plate_origin = plane_z_origin(z_file_path)
        continouse_wb = excel_app.books.open(self._continouse_tension_excel)
        continouse_sheet = continouse_wb.sheets["模板"]
        wb_string_impact = excel_app.books.open(self._string_impact_curve_excel)
        stringImpactExcel = StringImpactExcel()
        sleep(1)
        draw_first_tower_key = tower_key_list[draw_tower_index[0]]
        first_tower_info: SEntry = tower_dict[draw_first_tower_key]
        forth_reprtv_span = first_tower_info.forth_representive_span
        continouse_sheet.range("B69").value = forth_reprtv_span
        high_temperature_tension = continouse_sheet.range("L69").value
        if first_tower_info.is_tension_tower:
            forth_tower_info: SEntry = tower_dict[
                tower_key_list[draw_tower_index[0] + 1]
            ]
            if forth_tower_info.is_tension_tower:
                forth_tower_fitting_length = 0
            else:
                forth_tower_fitting_length = fitting.fitting_length_dic[
                    forth_tower_info.fitting
                ]
            gaocha_of_first_tower = (
                (
                    forth_tower_info.tower_height
                    - forth_tower_info.foundation_low
                    - forth_tower_fitting_length
                )
                - (first_tower_info.tower_height - first_tower_info.foundation_low)
                + forth_tower_info.altitude_off
            )
            span_of_first_tower = (
                forth_tower_info.mileage_in_s - first_tower_info.mileage_in_s
            )
            (x, y) = stringImpactExcel.read(
                wb_string_impact,
                gaocha_of_first_tower,
                span_of_first_tower,
                high_temperature_tension,
            )
            # TODO: 没有考虑断面中间有耐张塔的情况
            plot_x = (plate_origin[0] + x / 5).reshape(len(x), 1)
            plot_y = (
                plate_origin[1]
                + (first_tower_info.tower_height - first_tower_info.foundation_low + y)
                * 2
            ).reshape(len(x), 1)
            self._plot(cad, plot_x, plot_y)
            # 记录
            record = StringImpactExcelRecord()
            record.from_tower_name = first_tower_info.tower_name
            record.fo_tower_name = forth_tower_info.tower_name
            record.span = span_of_first_tower
            record.representive_span = first_tower_info.forth_representive_span
            record.gaocha = gaocha_of_first_tower
            record.tension = high_temperature_tension
            self.excel_record_list.append(record)
        # 画右侧耐张塔的弧垂
        draw_last_tower_key = tower_key_list[draw_tower_index[-1]]
        last_tower_info: SEntry = tower_dict[draw_last_tower_key]  # 最后一个塔位
        if last_tower_info.is_tension_tower:
            back_reprtv_span = last_tower_info.back_representive_span
            back_tower_info: SEntry = tower_dict[
                tower_key_list[draw_tower_index[-1] - 1]
            ]
            if back_tower_info.is_tension_tower:
                back_tower_fitting_length = 0
            else:
                back_tower_fitting_length = fitting.fitting_length_dic[
                    back_tower_info.fitting
                ]
            gaocha_of_last_tower = (
                (
                    back_tower_info.tower_height
                    - back_tower_info.foundation_low
                    - back_tower_fitting_length
                )
                - (last_tower_info.tower_height - last_tower_info.foundation_low)
                - last_tower_info.altitude_off
            )
            span_of_last_tower = (
                last_tower_info.mileage_in_s - back_tower_info.mileage_in_s
            )
            (x, y) = stringImpactExcel.read(
                wb_string_impact,
                gaocha_of_last_tower,
                span_of_last_tower,
                high_temperature_tension,
            )
            plot_last_tower_x = (
                plate_origin[0]
                + (
                    tower_dict[tower_key_list[draw_tower_index[-1]]].mileage_in_s
                    - tower_dict[tower_key_list[draw_tower_index[0]]].mileage_in_s
                )
                / 5
                - x / 5  # 从右往左画
            ).reshape(len(x), 1)
            accumulate_altitude_off = np.sum(
                [
                    tower_dict[tower_key_list[bar]].altitude_off
                    for bar in range(draw_tower_index[0] + 1, draw_tower_index[-1] + 1)
                ]
            )
            plot_last_tower_y = (
                plate_origin[1]
                + accumulate_altitude_off * 2
                + (last_tower_info.tower_height - last_tower_info.foundation_low + y)
                * 2
            ).reshape(len(x), 1)
            plot_last_tower_vector = np2d_to_array(
                np.hstack((plot_last_tower_x, plot_last_tower_y))
            )
            self._plot(cad, plot_last_tower_x, plot_last_tower_y)

    def draw(self):
        if self._cad:
            with xw.App(visible=False) as excel_app:
                self._draw_action(excel_app, self._cad)
        else:
            with xw.App(visible=False) as excel_app, Apyautocad(
                create_if_not_exists=True, visible=True, auto_close=True
            ) as cad:
                cad.app.Documents.Open(self._dwg_file_path)
                self._draw_action(excel_app, cad)

    def saveAs(self, save_to):
        self._cad.SaveAs(save_to)


@define
class ContinuousPlate:
    _dwg_file_path: str
    _s_file_path: str
    _from_tower_name: str
    _end_tower_name: str
    cad: object = None

    def draw(self):
        s_file = SFile()
        s_file_path = self._s_file_path
        s_file.open(s_file_path)
        dwg_file_path = self._dwg_file_path
        with Apyautocad(
            create_if_not_exists=True, visible=True, auto_close=False
        ) as cad:
            self.cad = cad
            doc = cad.app.Documents.Open(dwg_file_path)
            sleep(1)
            custom_layer = get_layer_if_not_exist_create_it(doc, "123custom_layer")
            tower_dict = s_file.tower_dic
            z_file_path = deduce_zfile_from_cad_path(dwg_file_path)
            z_point = plane_z_origin(z_file_path)
            fitting_file_path = deduce_fit_db_from_cad_path(dwg_file_path)
            fitting = Fitting(fitting_file_path)
            fitting_length_dict = fitting.fitting_length_dic
            first_tower_point = z_point
            last_tower_info = None  # 上一个塔位信息
            accu_mileage = 0  # 累计档距
            accu_altitude_off = 0  # 累计高差
            is_first_tower = True
            can_start_draw = -1
            start_tower_name = self._from_tower_name
            tower_key_list = list(tower_dict.keys())
            draw_count_limit = (
                tower_key_list.index(self._end_tower_name)
                - tower_key_list.index(self._from_tower_name)
                + 1
            )
            draw_count = 0
            for tower in tower_dict:
                tower_info = tower_dict[tower]
                if tower_info.tower_name == start_tower_name:
                    can_start_draw = 0
                elif can_start_draw != 0:
                    continue
                if not last_tower_info:
                    last_tower_info = tower_info
                if draw_count > draw_count_limit - 1:
                    break
                foundation_low = tower_info.foundation_low
                accu_mileage = (
                    accu_mileage
                    + tower_info.mileage_in_s
                    - last_tower_info.mileage_in_s
                )
                if draw_count == draw_count_limit - 1:
                    # 画代表档距
                    represented_span_text = f"{tower_info.back_representive_span:.0f}"
                    represented_span_text_point = np.array(
                        [(accu_mileage / 2) / 5 + 50, 1]
                    )
                    added_represented_span_text = cad.model.AddText(
                        represented_span_text,
                        APoint(*represented_span_text_point.tolist()),
                        3,
                    )
                    set_true_color(
                        added_represented_span_text,
                        ColorEnume.representive_span_text_color_rgb,
                    )
                    added_represented_span_text.Layer = custom_layer.Name
                if is_first_tower:  # 是否是开始画的第一个塔。
                    accu_altitude_off = 0
                else:
                    accu_altitude_off = (
                        accu_altitude_off + tower_info.altitude_off
                    )  # 中心桩高程
                np_tower_start = first_tower_point + np.array(
                    [
                        accu_mileage / 5,
                        (accu_altitude_off - foundation_low) * 2,
                    ]
                )
                tower_height = tower_info.tower_height
                if tower_info.is_tension_tower:
                    np_tower_end = first_tower_point + np.array(
                        [
                            accu_mileage / 5,
                            (accu_altitude_off + tower_height - foundation_low) * 2,
                        ]
                    )
                else:
                    np_tower_end = first_tower_point + np.array(
                        [
                            accu_mileage / 5,
                            (
                                accu_altitude_off
                                + tower_height
                                - foundation_low
                                - fitting_length_dict[tower_info.fitting]
                                + 3
                            )
                            * 2,
                        ]
                    )  # 直线塔杆高只比悬垂挂点高3米
                # 画杆高
                tower_pole = cad.model.AddPolyLine(
                    np2d_to_array(np.vstack((np_tower_start, np_tower_end)))
                )
                tower_pole.Layer = custom_layer.Name
                tower_pole.SetWidth(0, 0.8, 0.8)
                set_true_color(tower_pole, 0, 255, 255)
                # 画塔名和呼高
                added_tower_name = cad.model.AddText(
                    f"{tower_info.tower_name}",
                    APoint(*(np_tower_end + np.array([-5, 13])).tolist()),
                    5,
                )
                added_tower_name.Layer = custom_layer.Name
                if (
                    abs(math.floor(tower_info.tower_height) - tower_info.tower_height)
                    < 0.1
                ):  # 考虑了半米呼高的情况
                    draw_tower_height_str = f"{tower_info.tower_height:.0f}"
                else:
                    draw_tower_height_str = f"{tower_info.tower_height:.1f}"
                added_hugao = cad.model.AddText(
                    f"{tower_info.tower_type}-{draw_tower_height_str}",
                    APoint(*(np_tower_end + np.array([-5, 5])).tolist()),
                    5,
                )
                added_hugao.Layer = custom_layer.Name
                draw_count += 1
                # 画弧垂
                if not is_first_tower:  # 从第二基塔开始画
                    draw_k = tower_info.back_k
                    span = tower_info.mileage_in_s - last_tower_info.mileage_in_s
                    last_tower_fiting = last_tower_info.fitting
                    last_tower_fitting_length = fitting_length_dict[last_tower_fiting]
                    if last_tower_info.is_tension_tower:
                        last_tower_fitting_length = 0
                    tower_fitting = tower_info.fitting
                    tower_fitting_length = fitting_length_dict[tower_fitting]
                    if tower_info.is_tension_tower:
                        tower_fitting_length = 0
                    last_tower_height = last_tower_info.tower_height
                    last_foundation_low = last_tower_info.foundation_low
                    # 挂点高差
                    fiting_altitude_off = (
                        tower_info.altitude_off
                        + (tower_height - foundation_low - tower_fitting_length)
                        - (
                            last_tower_height
                            - last_foundation_low
                            - last_tower_fitting_length
                        )
                    )  # 前侧高为正
                    # 画导线弧垂
                    x = np.linspace(0, span, int(span), endpoint=True)
                    curve = curve_fun(x, span, draw_k, fiting_altitude_off)
                    draw_curve_x = (first_tower_point[0]) + (
                        x + accu_mileage - span
                    ) / 5
                    draw_curve_y = (
                        first_tower_point[1]
                        + (
                            +curve
                            + accu_altitude_off
                            - tower_info.altitude_off
                            - last_tower_info.foundation_low
                            + last_tower_info.tower_height
                            - last_tower_fitting_length
                        )
                        * 2
                    )
                    draw_curve_x = draw_curve_x.reshape(len(draw_curve_x), 1)
                    draw_curve_y = draw_curve_y.reshape(len(draw_curve_y), 1)
                    # TODO 应该读规程的
                    draw_ground_curve_y = draw_curve_y - 16 * 2  # 切地线
                    draw_tree_curve_y = draw_curve_y - 13.5 * 2  # 切树线
                    draw_point = np.hstack(
                        (draw_curve_x, draw_curve_y, np.zeros((len(draw_curve_x), 1)))
                    )
                    draw_ground_curve_point = np.hstack(
                        (
                            draw_curve_x,
                            draw_ground_curve_y,
                            np.zeros((len(draw_curve_x), 1)),
                        )
                    )
                    draw_tree_curve_point = np.hstack(
                        (
                            draw_curve_x,
                            draw_tree_curve_y,
                            np.zeros((len(draw_curve_x), 1)),
                        )
                    )
                    added_curve = cad.model.AddPolyLine(
                        draw_point.reshape(1, draw_curve_x.shape[0] * 3)[0]
                    )
                    added_curve.Layer = custom_layer.Name
                    set_true_color(added_curve, *ColorEnume.wire_color_rgb)
                    added_ground_curve = cad.model.AddPolyLine(
                        draw_ground_curve_point.reshape(
                            1, draw_ground_curve_y.shape[0] * 3
                        )[0]
                    )
                    added_ground_curve.Layer = custom_layer.Name
                    set_true_color(added_ground_curve, *ColorEnume.ground_color_rgb)
                    added_tree_curve = cad.model.AddPolyLine(
                        draw_tree_curve_point.reshape(
                            1, draw_tree_curve_y.shape[0] * 3
                        )[0]
                    )
                    added_tree_curve.Layer = custom_layer.Name
                    set_true_color(added_tree_curve, *ColorEnume.tree_color_rgb)
                    # 画档距
                    span_text_insert_point = np.array(
                        [(accu_mileage - span / 2) / 5 + 50, 6]
                    )
                    added_span_text = cad.model.AddText(
                        f"{span:.0f}", APoint(*span_text_insert_point.tolist()), 3
                    )
                    # 画档距分割线
                    add_span_splitter = cad.model.AddPolyLine(
                        array(
                            "d",
                            [
                                (accu_mileage ) / 5 + 50,
                                5,
                                0,
                                (accu_mileage ) / 5 + 50,
                                10,
                                0,
                            ],
                        )
                    )
                    add_span_splitter.Layer = custom_layer.Name
                    set_true_color(added_span_text, *ColorEnume.span_text_color_rgb)
                    added_span_text.Layer = custom_layer.Name
                is_first_tower = False
                last_tower_info = tower_info

    def saveAs(self, save_to):
        cad = self.cad
        doc = cad.doc
        doc.SaveAs(save_to)


@define
class ControlFile:
    _z_excel_file_path: str = attrs.field(init=True, kw_only=False)
    _z_file_path: str = ""
    _dwg_file_path: str = ""
    _from_tower_name: str = ""
    _end_tower_name: str = ""
    _consider_string_weight: bool = False
    _excel_string_weight_path: str = ""
    _excel_continuous_path: str = ""
    _s_file_path: str = ""
    _dir_prefix: str = ""
    _z_file_name: str = ""
    _close_cad_document: bool = attrs.field(init=True, kw_only=False, default=True)

    def __attrs_post_init__(self):
        z_excel_file_path = self._z_excel_file_path
        excel_pf = pd.read_excel(z_excel_file_path)
        pf_dict = excel_pf.to_dict("records")[0]
        z_excel_path = os.path.split(z_excel_file_path)
        self._z_file_name = pf_dict["Z文件"]
        dir_prefix = z_excel_path[0]
        self._dir_prefix = dir_prefix
        self._from_tower_name = pf_dict["起始塔号"]
        self._end_tower_name = pf_dict["终止塔号"]
        if pf_dict["是否考虑耐张串影响"] == "是":
            self._consider_string_weight = True
        self._excel_string_weight_path = pf_dict["计算耐张串影响用表格"]
        self._excel_continuous_path = pf_dict["计算连续档用表格"]
        self._z_file_path = os.path.join(dir_prefix, pf_dict["Z文件"])
        self._dwg_file_path = os.path.join(dir_prefix, pf_dict["DWG文件"])
        self._s_file_path = os.path.join(dir_prefix, pf_dict["S文件"])

    def get_zt_dwg_file_path(self):  # 获得生成的dwg文件名路径
        return os.path.join(self._dir_prefix, "ZT" + self._z_file_name + ".dwg")

    def draw(self):
        if not os.path.exists(self._dwg_file_path):
            raise error.DWGFileNotExistError(self._dwg_file_path)
        continuous_plate = ContinuousPlate(
            self._dwg_file_path,
            self._s_file_path,
            self._from_tower_name,
            self._end_tower_name,
        )
        continuous_plate.draw()
        string_impact_plate = StringImpactPlate(
            self._dwg_file_path,
            self._s_file_path,
            self._from_tower_name,
            self._excel_continuous_path,
            self._excel_string_weight_path,
            continuous_plate.cad,
        )
        string_impact_plate.draw()
        cad = continuous_plate.cad
        cad.doc.SaveAs(self.get_zt_dwg_file_path())
        cad.doc.Utility.Prompt("断面已生成。\n")
        # # 画完后再打开
        # cad = None
        # continousePlate = None
        # with Apyautocad(
        #     create_if_not_exists=True, visible=True, auto_close=False
        # ) as cad:
        #     cad.app.Documents.Open(self.get_zt_dwg_file_path())
        if self._close_cad_document:
            cad.doc.Close(False)