ControlNetwork/Back/GC/GCcompute.py

import os
import sqlite3
import math

from PySide6.QtWidgets import QMessageBox


def calculate_absolute_height_differences(db_path, file_name, field_name):
    """
    从数据库指定表中读取所有记录的字段，并计算其绝对值。
    """
    abs_values = []
    with sqlite3.connect(db_path) as conn:
        cursor = conn.cursor()
        query = f"SELECT {field_name} FROM GC_Input_Point WHERE TableName = ?"
        cursor.execute(query, (file_name,))
        for row in cursor.fetchall():
            # 检查是否为 None，如果是，则停止读取
            if row[0] is None:
                continue  # 停止读取
            else:
                abs_value = abs(row[0])
                abs_values.append(abs_value)
    return abs_values


# 获取上期稳定测段
def get_last_stable_section(values):
    last_stable_section = sum(values)
    return last_stable_section


# 获取本期稳定测段
def get_current_stable_section(abs_new_hdiffs, length_of_last_section):
    current_stable_section = sum(abs_new_hdiffs[:length_of_last_section])
    return current_stable_section


# 获取较差
def calculate_differences(abs_last_hdiffs, abs_new_hdiffs):
    differences = [(last - new) * 1000 for last, new in zip(abs_last_hdiffs, abs_new_hdiffs[:len(abs_last_hdiffs)])]
    return differences


# 稳定测段的较差
def calculate_stable_differences(last_stable_section, current_stable_section):
    stable_differences = (current_stable_section - last_stable_section) * 1000
    return stable_differences


# 获取限值 total=True获取总路线长的限值 total=False获取单个测量点的限值 默认为False
def calculate_limits(db_path, file_name, total=False):
    try:
        with sqlite3.connect(db_path) as conn:
            cursor = conn.cursor()
            query_last_rlen = "SELECT Last_RLen FROM GC_Input_Point WHERE TableName = ?"
            query_new_rlen = "SELECT New_RLen FROM GC_Input_Point WHERE TableName = ?"
            cursor.execute(query_last_rlen, (file_name,))
            last_rlens = []
            for row in cursor.fetchall():
                if row[0] is None:
                    continue
                last_rlens.append(row[0])
            cursor.execute(query_new_rlen, (file_name,))
            new_rlens = []
            for row in cursor.fetchall():
                if row[0] is None:
                    continue
                new_rlens.append(row[0])
            if not total:
                # 计算单个测量点的限值
                limit_values = []
                for last_rlen, new_rlen in zip(last_rlens, new_rlens):
                    if last_rlen is None:
                        break
                    calculated_value = 2 * math.sqrt(last_rlen + new_rlen)
                    if calculated_value < 0.47:
                        limit_values.append(0.47)
                    else:
                        limit_values.append(calculated_value)
                return limit_values
            else:
                # 计算总路线长的限值
                total_last_rlen = sum([rlen for rlen in last_rlens if rlen is not None])
                total_new_rlen = sum(new_rlens[:len(last_rlens)])
                calculated_value = 2 * math.sqrt(total_last_rlen + total_new_rlen)
                if calculated_value < 0.47:
                    total_limit = 0.47
                else:
                    total_limit = calculated_value
                return total_limit
    except sqlite3.Error as e:
        print(f"Database error: {e}")
        return []


# 高程较差的变形判定  变形的位置存储为 "变形"，未变形的位置存储为 None
def detect_deformation(differences, limit_values):
    deformation_results = [None] * len(differences)
    for i, diff in enumerate(differences):
        if abs(diff) > limit_values[i]:
            deformation_results[i] = "变形"
    return deformation_results


# 第一次稳定分析
def calculate_corrected_old_height_difference(abs_last_hdiffs, transformation_point):
    # 上期改正高差
    corrected_sum = 0.0
    for i, value in enumerate(abs_last_hdiffs):
        if transformation_point[i] != "变形":
            corrected_sum += value
    return corrected_sum


def calculate_corrected_new_height_difference(abs_new_hdiffs, transformation_point, abs_last_hdiffs):
    # 本期改正高差
    n = len(abs_last_hdiffs)  # 使用 abs_last_hdiffs 的长度作为限制
    corrected_sum = 0.0
    for i in range(n):
        if transformation_point[i] != "变形":
            corrected_sum += abs_new_hdiffs[i]
    return corrected_sum


def calculate_corrected_height_differences(abs_new_hdiffs, corrected_sum_last, corrected_sum_new):
    # 改正高差绝对值
    n = len(abs_new_hdiffs)
    corrected_height_differences = []
    for i in range(n):
        corrected_value = abs_new_hdiffs[i] * (corrected_sum_last / corrected_sum_new)
        corrected_height_differences.append(corrected_value)
    return corrected_height_differences


def detect_corrected_deformation(corrected_height_differences, abs_last_hdiffs, limit_values):
    # 变形判定
    deformation_results = [None] * len(corrected_height_differences)
    for i in range(min(len(corrected_height_differences), len(limit_values))):
        difference = abs((corrected_height_differences[i] - abs_last_hdiffs[i]) * 1000)
        if difference > limit_values[i]:
            deformation_results[i] = "变形"
    # 对于超出部分，直接设置为 None
    for i in range(len(limit_values), len(corrected_height_differences)):
        deformation_results[i] = None
    return deformation_results


# 计算修正系数并更新数据库
def update_correction_factor(db_path, file_name, corrected_sum_last_5, corrected_sum_new_5):
    correction_factor = corrected_sum_last_5 / corrected_sum_new_5
    # 更新数据库中的修正系数
    with sqlite3.connect(db_path) as conn:
        cursor = conn.cursor()
        update_query = "UPDATE GC_Input_Param SET Correct_Factor = ? WHERE TableName = ?"
        cursor.execute(update_query, (correction_factor, file_name))
        conn.commit()


# 从数据库中获取 New_HDiff 字段的数据
def get_new_hdiffs(db_path, file_name):
    new_hdiffs = []
    with sqlite3.connect(db_path) as conn:
        cursor = conn.cursor()
        query = "SELECT New_HDiff FROM GC_Input_Point WHERE TableName = ?"
        cursor.execute(query, (file_name,))
        for row in cursor.fetchall():
            if row[0] is None:
                continue
            else:
                new_hdiffs.append(row[0])
    return new_hdiffs


def get_old_hdiffs(db_path, file_name):
    old_hdiffs = []
    with sqlite3.connect(db_path) as conn:
        cursor = conn.cursor()
        query = "SELECT Last_HDiff FROM GC_Input_Point WHERE TableName = ?"
        cursor.execute(query, (file_name,))
        for row in cursor.fetchall():
            if row[0] is None:
                continue
            else:
                old_hdiffs.append(row[0])
    return old_hdiffs


# 计算修正高差
def calculate_corrected_height_differences_with_sin(new_hdiffs, corrected_height_differences_5):
    corrected_height_differences_with_sin = []
    for new_hdiff, corrected_diff in zip(new_hdiffs, corrected_height_differences_5):
        corrected_diff_with_sin = math.copysign(1, new_hdiff) * corrected_diff
        corrected_height_differences_with_sin.append(corrected_diff_with_sin)
    return corrected_height_differences_with_sin


# 计算修正数
def calculate_correction_numbers(result_height_differences, new_hdiffs):
    correction_numbers = [(rhd - nh) * 1000 for rhd, nh in zip(result_height_differences, new_hdiffs)]
    return correction_numbers


# 计算期间差异
def calculate_period_differences(old_hdiffs, result_height_differences):
    period_differences = []
    for old_hdiff, result_diff in zip(old_hdiffs, result_height_differences):
        if (old_hdiff >= 0 and result_diff >= 0) or (old_hdiff < 0 and result_diff < 0):
            diff = (old_hdiff - result_diff) * 1000
        else:
            diff = (-old_hdiff - result_diff) * 1000
        period_differences.append(diff)
    return period_differences


# 插入数据到Outpoint数据库
def insert_records_to_output_table(db_path, file_name, dis_ass, new_hdiff, correction_numbers, period_differences):
    with sqlite3.connect(db_path) as conn:
        cursor = conn.cursor()
        # 查询 GC_Input_Point 表中的数据
        query = """
            SELECT New_ID, New_ResultName, New_SPName, New_EPName, New_RLen, TableName
            FROM GC_Input_Point
            WHERE TableName = ?
        """
        cursor.execute(query, (file_name,))
        records = cursor.fetchall()
        # 检查是否存在相同的 TableName
        check_query = """
            SELECT COUNT(*)
            FROM GC_Output_Point
            WHERE TableName = ?
        """
        cursor.execute(check_query, (file_name,))
        count = cursor.fetchone()[0]
        # 获取最长数组的长度
        max_length = max(len(dis_ass), len(new_hdiff), len(correction_numbers), len(period_differences))
        # 填充缺失值
        dis_ass = dis_ass + [None] * (max_length - len(dis_ass))
        new_hdiff = new_hdiff + [None] * (max_length - len(new_hdiff))
        correction_numbers = correction_numbers + [None] * (max_length - len(correction_numbers))
        period_differences = period_differences + [None] * (max_length - len(period_differences))
        if count > 0:
            # 更新操作
            update_query = """
                UPDATE GC_Output_Point
                SET Dis_Ass = ?, New_HDiff = ?, Correct_Factor = ?, Period_Diff = ?
                WHERE New_ID = ? AND TableName = ?
            """
            updated_records = []
            for record, deformation_result, height_difference, correction, period_diff in zip(records, dis_ass,
                                                                                              new_hdiff,
                                                                                              correction_numbers,
                                                                                              period_differences):
                updated_record = [deformation_result, height_difference, correction, period_diff, record[0], file_name]
                updated_records.append(updated_record)
            cursor.executemany(update_query, updated_records)
        else:
            # 插入操作
            insert_query = """
                INSERT INTO GC_Output_Point (New_ID, New_ResultName, New_SPName, New_EPName, New_RLen, TableName, Dis_Ass, New_HDiff, Correct_Factor, Period_Diff)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """
            updated_records = []
            for record, deformation_result, height_difference, correction, period_diff in zip(records, dis_ass,
                                                                                              new_hdiff,
                                                                                              correction_numbers,
                                                                                              period_differences):
                updated_record = list(record) + [deformation_result, height_difference, correction, period_diff]
                updated_records.append(updated_record)
            cursor.executemany(insert_query, updated_records)
        conn.commit()


def main_function(file_path, db_path):
    try:
        # 获取文件名
        file_name = os.path.basename(file_path)
        file_name_utf8 = file_name.encode('utf-8')

        # 处理查询结果
        abs_last_hdiffs = calculate_absolute_height_differences(db_path, file_name_utf8, "Last_HDiff")
        abs_new_hdiffs = calculate_absolute_height_differences(db_path, file_name_utf8, "New_HDiff")

        # 计算较差
        differences = calculate_differences(abs_last_hdiffs, abs_new_hdiffs)

        # 计算限值
        limit_values = calculate_limits(db_path, file_name_utf8)

        # 高程较差的变形判定
        deformation_results = detect_deformation(differences, limit_values)

        # 第一次稳定分析
        corrected_sum_last_1 = calculate_corrected_old_height_difference(abs_last_hdiffs, deformation_results)  # 上期改正高差
        corrected_sum_new_1 = calculate_corrected_new_height_difference(abs_new_hdiffs, deformation_results,
                                                                        abs_last_hdiffs)  # 本期改正高差
        corrected_height_differences_1 = calculate_corrected_height_differences(abs_new_hdiffs, corrected_sum_last_1,
                                                                                corrected_sum_new_1)  # 改正高差绝对值
        first_deformation_results = detect_corrected_deformation(corrected_height_differences_1, abs_last_hdiffs,
                                                                 limit_values)  # 第一次稳定分析的变形判定

        # 第二次稳定分析
        corrected_sum_last_2 = calculate_corrected_old_height_difference(abs_last_hdiffs, first_deformation_results)
        corrected_sum_new_2 = calculate_corrected_new_height_difference(abs_new_hdiffs, first_deformation_results,
                                                                        abs_last_hdiffs)
        corrected_height_differences_2 = calculate_corrected_height_differences(abs_new_hdiffs, corrected_sum_last_2,
                                                                                corrected_sum_new_2)
        second_deformation_results = detect_corrected_deformation(corrected_height_differences_2, abs_last_hdiffs,
                                                                  limit_values)

        # 第三次稳定分析
        corrected_sum_last_3 = calculate_corrected_old_height_difference(abs_last_hdiffs, second_deformation_results)
        corrected_sum_new_3 = calculate_corrected_new_height_difference(abs_new_hdiffs, second_deformation_results,
                                                                        abs_last_hdiffs)
        corrected_height_differences_3 = calculate_corrected_height_differences(abs_new_hdiffs, corrected_sum_last_3,
                                                                                corrected_sum_new_3)
        third_deformation_results = detect_corrected_deformation(corrected_height_differences_3, abs_last_hdiffs,
                                                                 limit_values)

        # 第四次稳定分析
        corrected_sum_last_4 = calculate_corrected_old_height_difference(abs_last_hdiffs, third_deformation_results)
        corrected_sum_new_4 = calculate_corrected_new_height_difference(abs_new_hdiffs, third_deformation_results,
                                                                        abs_last_hdiffs)
        corrected_height_differences_4 = calculate_corrected_height_differences(abs_new_hdiffs, corrected_sum_last_4,
                                                                                corrected_sum_new_4)
        fourth_deformation_results = detect_corrected_deformation(corrected_height_differences_4, abs_last_hdiffs,
                                                                  limit_values)

        # 第五次稳定分析
        corrected_sum_last_5 = calculate_corrected_old_height_difference(abs_last_hdiffs, fourth_deformation_results)
        corrected_sum_new_5 = calculate_corrected_new_height_difference(abs_new_hdiffs, fourth_deformation_results,
                                                                        abs_last_hdiffs)
        corrected_height_differences_5 = calculate_corrected_height_differences(abs_new_hdiffs, corrected_sum_last_5,
                                                                                corrected_sum_new_5)
        fifth_deformation_results = detect_corrected_deformation(corrected_height_differences_5, abs_last_hdiffs,
                                                                 limit_values)  # 第五次稳定分析的变形判定

        # 更新数据库中的修正系数
        update_correction_factor(db_path, file_name_utf8, corrected_sum_last_5, corrected_sum_new_5)

        # 成果的高差
        new_hdiffs = get_new_hdiffs(db_path, file_name_utf8)
        old_hdiffs = get_old_hdiffs(db_path, file_name_utf8)
        result_height_differences = calculate_corrected_height_differences_with_sin(new_hdiffs,
                                                                                    corrected_height_differences_5)  # 结果高差

        # 修正数
        correction_numbers = calculate_correction_numbers(result_height_differences, new_hdiffs)

        # 计算期间差异
        period_differences = calculate_period_differences(old_hdiffs, result_height_differences)

        # 插入数据到Outpoint数据库表
        insert_records_to_output_table(db_path, file_name_utf8, fifth_deformation_results, result_height_differences,
                                       correction_numbers, period_differences)

        QMessageBox.information(None, "提示", f"文件 '{file_name}' 计算成功！")

    except Exception as e:
        QMessageBox.critical(None, "错误", f"文件 '{file_name}' 计算失败！错误信息: {str(e)}")