用python计算10x10数据各项指标

import os  
import matplotlib.pyplot as plt  
import numpy as np  
import tensorflow as tf
from scipy.stats import wilcoxon
from scipy.stats import kruskal
from scipy.stats import mannwhitneyu
from scipy.stats import f_oneway
from scipy.stats import ttest_rel
from scipy.stats import ttest_ind
from scipy.stats import chi2_contingency
from scipy.stats import kendalltau  
from scipy.stats import shapiro
from six.moves import xrange  
import math
np.set_printoptions(suppress=True)
np.set_printoptions(threshold=np.inf) #输出全部矩阵不带省略号

def select_axis(data):
      gen_data = []
      for i in range(len(data)):
          threshold = 0.97
          zhu_x = []
          zhu_y = []
          for j in range(len(data[i][0])):
            if data[i][0][j] < threshold and data[i][3][j] < threshold:
              zhu_x.append(data[i][0][j])
              zhu_y.append(data[i][3][j])
              
          zuo_x = []
          zuo_y = []
          for j in range(len(data[i][1])):
            if data[i][1][j] < threshold and data[i][4][j] < threshold:
              zuo_x.append(data[i][1][j])
              zuo_y.append(data[i][4][j])
          
          you_x = []
          you_y = []
          for j in range(len(data[i][2])):
            if data[i][2][j] < threshold and data[i][5][j] < threshold:
              you_x.append(data[i][2][j])
              you_y.append(data[i][5][j])
          zhu_diam = [data[i][6][0]]
          zuo_diam = [data[i][7][0]]
          you_diam = [data[i][8][0]]
          
          if len(zhu_x) == len(zhu_y) and len(zuo_x) == len(zuo_y) and len(you_x) == len(you_y):
            #将每个分支第一个点，取平均，分别再赋给第一个坐标
            mean_x_0 = (zhu_x[0] + zuo_x[0] + you_x[0]) / 3
            mean_y_0 = (zhu_y[0] + zuo_y[0] + you_y[0]) / 3
            zhu_x[0] = mean_x_0
            zuo_x[0] = mean_x_0
            you_x[0] = mean_x_0 
            zhu_y[0] = mean_y_0
            zuo_y[0] = mean_y_0
            you_y[0] = mean_y_0
            zhu_xy = zhu_x + zhu_y
            zuo_xy = zuo_x + zuo_y
            you_xy = you_x + you_y
            
            zhu = zhu_xy + zhu_diam
            zuo = zuo_xy + zuo_diam
            you = you_xy + you_diam
            fencha = [zhu] + [zuo] + [you]
            gen_data.append(fencha)
      return gen_data
    
ori_data = np.load('data/data_10x10.npy')
gen_data = np.load('data/data_10x10.npy')
ori_data = ori_data[0:3000,:,:] #选择保存多少数据
gen_data = gen_data[3000:6000,:,:] #选择保存多少数据
ori_data = ori_data.reshape(-1,10,10)
gen_data = gen_data.reshape(-1,10,10)
ori_axis = select_axis(ori_data)
gen_axis = select_axis(gen_data)
####################################################
#绘图，观察是否正确
# gen = ori_axis
# for i in range(len(gen)):
#     zhu = gen[i][0]
#     zuo = gen[i][1]
#     you = gen[i][2]
#     zhu_diam = [zhu[-1]]
#     zuo_diam = [zuo[-1]]
#     you_diam = [you[-1]]
#     zhu_x = zhu[0:len(zhu)//2]
#     zuo_x = zuo[0:len(zuo)//2]
#     you_x = you[0:len(you)//2]
#     zhu_y = zhu[len(zhu)//2:(len(zhu)-1)]
#     zuo_y = zuo[len(zuo)//2:(len(zuo)-1)]
#     you_y = you[len(you)//2:(len(you)-1)]
#     plt.plot(zhu_x, zhu_y, color="red")
#     plt.plot(zuo_x, zuo_y, color="green")
#     plt.plot(you_x, you_y, color="blue")
#     plt.xlim(0,1)
#     plt.ylim(0,1)
#     plt.show()
##################################################
#距离计算公式
def get_len(x1,x2,y1,y2):
    diff_x = (x1-x2)**2
    diff_y = (y1-y2)**2
    length = np.sqrt(diff_x+diff_y)
    return length
  
#余弦定理计算角度公式
def cal_angle(a,b,c):
    cos_angle = (a**2+b**2-c**2)/(2*a*b)
    angle = np.arccos(cos_angle)
    angle = angle*180/np.pi
    return angle
  
#计算端点长度
def get_duandian_len(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y):
    #主分支头尾坐标
    zhu_x_tou = zhu_x[0]
    zhu_y_tou = zhu_y[0]
    zhu_x_wei = zhu_x[-1]
    zhu_y_wei = zhu_y[-1]
    #左分支头尾坐标
    zuo_x_tou = zuo_x[0]
    zuo_y_tou = zuo_y[0]
    zuo_x_wei = zuo_x[-1]
    zuo_y_wei = zuo_y[-1]
    #右分支头尾坐标
    you_x_tou = you_x[0]
    you_y_tou = you_y[0]
    you_x_wei = you_x[-1]
    you_y_wei = you_y[-1]
    #主分支端点长
    zhu_duan_len = get_len(zhu_x_tou,zhu_x_wei,zhu_y_tou,zhu_y_wei)
    #左分支端点长
    zuo_duan_len = get_len(zuo_x_tou,zuo_x_wei,zuo_y_tou,zuo_y_wei)
    #右分支端点长
    you_duan_len = get_len(you_x_tou,you_x_wei,you_y_tou,you_y_wei)
    return zhu_duan_len,zuo_duan_len,you_duan_len
  
#计算分支总长度
def get_total_len(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y):
    zhu_lin_list = []
    zuo_lin_list = []
    you_lin_list = []
    for i in range(1,len(zhu_x)):
        #相邻点大小相差1e-5可以认为他们是插入点，距离为0
        zhu_lin_len = get_len(zhu_x[i-1],zhu_x[i],zhu_y[i-1],zhu_y[i])
        zhu_lin_list.append(zhu_lin_len)
    for i in range(1,len(zuo_x)):
        zuo_lin_len = get_len(zuo_x[i-1],zuo_x[i],zuo_y[i-1],zuo_y[i])
        zuo_lin_list.append(zuo_lin_len)
    for i in range(1, len(you_x)):
        you_lin_len = get_len(you_x[i-1],you_x[i],you_y[i-1],you_y[i])
        you_lin_list.append(you_lin_len)
    zhu_total_len = 0
    for file in zhu_lin_list:
        zhu_total_len += file
    zuo_total_len = 0
    for file in zuo_lin_list:
        zuo_total_len += file
    you_total_len = 0
    for file in you_lin_list:
        you_total_len += file
    return zhu_total_len,zuo_total_len,you_total_len
# #############################################################
# #测试函数正确性
# zhu_x = [0,1,2,3,3,3,3,3] #理论上端点长5，总长度7,本身是一个两条直角边为3，4的直角三角形
# zhu_y = [0,0,0,0,1,2,3,4]
# zhu_duan_len,zuo_duan_len,you_duan_len = get_duandian_len(zhu_x,zhu_y,zhu_x,zhu_y,zhu_x,zhu_y)
# zhu_total_len,zuo_total_len,you_total_len = get_total_len(zhu_x,zhu_y,zhu_x,zhu_y,zhu_x,zhu_y)
# print(zhu_duan_len,zuo_total_len)
# print(zhu_total_len,zuo_total_len)
# ################################################################
#计算卷曲度
def get_juanqu(zhu_duan_len,zuo_duan_len,you_duan_len,zhu_total_len,zuo_total_len,you_total_len):
    zhu_juanqu = zhu_total_len / zhu_duan_len
    zuo_juanqu = zuo_total_len / zuo_duan_len
    you_juanqu = you_total_len / you_duan_len
    return zhu_juanqu,zuo_juanqu,you_juanqu
 
#计算角度
def get_angle(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y):
    #主分支上两个尾部点
    zhu_x_a = zhu_x[0]
    zhu_y_a = zhu_y[0]
    zhu_x_b = zhu_x[1]
    zhu_y_b = zhu_y[1]
    #左分支上两个头部点
    zuo_x_a = zuo_x[0]
    zuo_y_a = zuo_y[0]
    zuo_x_b = zuo_x[1]
    zuo_y_b = zuo_y[1]
    #右分支上两个头部点
    you_x_a = you_x[0]
    you_y_a = you_y[0]
    you_x_b = you_x[1]
    you_y_b = you_y[1]
    #zhu_x_a,zuo_x_a,you_x_a应该相等
    #每个端点两点长度
    zhu_ab_len = get_len(zhu_x_b,zhu_x_a,zhu_y_b,zhu_y_a)
    zuo_ab_len = get_len(zuo_x_a,zuo_x_b,zuo_y_a,zuo_y_b)
    you_ab_len = get_len(you_x_a,you_x_b,you_y_a,you_y_b)
    zhu_zuo_len = get_len(zhu_x_b,zuo_x_b,zhu_y_b,zuo_y_b)
    zhu_you_len = get_len(zhu_x_b,you_x_b,zhu_y_b,you_y_b)
    zuo_you_len = get_len(zuo_x_b,you_x_b,zuo_y_b,you_y_b)
    if zhu_ab_len > 0 and zuo_ab_len > 0 and you_ab_len > 0 and zhu_zuo_len > 0 and zhu_you_len > 0 and zuo_you_len > 0 :
      zhu_zuo_angle = cal_angle(zhu_ab_len,zuo_ab_len,zhu_zuo_len)
      zhu_you_angle = cal_angle(zhu_ab_len,you_ab_len,zhu_you_len)
      zuo_you_angle = cal_angle(zuo_ab_len,you_ab_len,zuo_you_len)
      zong_angle = zhu_zuo_angle + zhu_you_angle + zuo_you_angle
      return zhu_zuo_angle,zhu_you_angle,zuo_you_angle,zong_angle
    else:
      return 0
   
#计算主分支与左右分支的长度比
def get_ratio(zhu_total_len,zuo_total_len,you_total_len):
    zhu_zuo_ratio = zhu_total_len / zuo_total_len
    zhu_you_ratio = zhu_total_len / you_total_len
    return zhu_zuo_ratio,zhu_you_ratio
 
def calculate(data):
#     data = data.reshape(-1,3,60)
#     data = data[:,:,0:60]
    zhu_diam_list = []
    zuo_diam_list = []
    you_diam_list = []
    zhu_duan_len_list = []
    zuo_duan_len_list = []
    you_duan_len_list = []
    zhu_total_len_list = []
    zuo_total_len_list = []
    you_total_len_list = []
    zhu_zuo_ratio_list = []
    zhu_you_ratio_list = []
    zhu_juanqu_list = []
    zuo_juanqu_list  = []
    you_juanqu_list = []
    zhu_zuo_angle_list = []
    zhu_you_angle_list = []
    zuo_you_angle_list = []
    zong_angle_list = []
    for i in range(0,len(data)):
        zhu = data[i][0]
        zuo = data[i][1]
        you = data[i][2]
        zhu_diam = [zhu[-1]]
        zuo_diam = [zuo[-1]]
        you_diam = [you[-1]]
        zhu_x = zhu[0:len(zhu)//2]
        zuo_x = zuo[0:len(zuo)//2]
        you_x = you[0:len(you)//2]
        zhu_y = zhu[len(zhu)//2:(len(zhu)-1)]
        zuo_y = zuo[len(zuo)//2:(len(zuo)-1)]
        you_y = you[len(you)//2:(len(you)-1)]
        #计算每个分支管径
        zhu_diam_list.append(zhu_diam[0])
        zuo_diam_list.append(zuo_diam[0])
        you_diam_list.append(you_diam[0])
        #计算每个分叉分支端点长度
        zhu_duan_len,zuo_duan_len,you_duan_len = get_duandian_len(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y)
        zhu_duan_len_list.append(zhu_duan_len)
        zuo_duan_len_list.append(zuo_duan_len)
        you_duan_len_list.append(you_duan_len)
        #计算每个分叉分支总长度
        zhu_total_len,zuo_total_len,you_total_len = get_total_len(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y)
        zhu_total_len_list.append(zhu_total_len)
        zuo_total_len_list.append(zuo_total_len)
        you_total_len_list.append(you_total_len)
        #计算主分支与左右分支长度比
        zhu_zuo_ratio,zhu_you_ratio = get_ratio(zhu_total_len,zuo_total_len,you_total_len)
        zhu_zuo_ratio_list.append(zhu_zuo_ratio)
        zhu_you_ratio_list.append(zhu_you_ratio)
        #计算每个分叉分支卷曲度
        zhu_juanqu,zuo_juanqu,you_juanqu = get_juanqu(zhu_duan_len,zuo_duan_len,you_duan_len,zhu_total_len,zuo_total_len,you_total_len)
        zhu_juanqu_list.append(zhu_juanqu)
        zuo_juanqu_list.append(zuo_juanqu)
        you_juanqu_list.append(you_juanqu)
        #计算每个分叉分支角度
        zeros = get_angle(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y)
        if zeros == 0:
          continue
        else:
          zhu_zuo_angle,zhu_you_angle,zuo_you_angle,zong_angle= get_angle(zhu_x,zhu_y,zuo_x,zuo_y,you_x,you_y)
          # 如果是空跳出本次循环
          if math.isnan(zong_angle):
            continue
          else:
            zhu_zuo_angle_list.append(zhu_zuo_angle)
            zhu_you_angle_list.append(zhu_you_angle)
            zuo_you_angle_list.append(zuo_you_angle)
            zong_angle_list.append(zong_angle)
    diam_list = zhu_diam_list + zuo_diam_list + you_diam_list
    duan_len_list = zhu_duan_len_list + zuo_duan_len_list + you_duan_len_list
    total_len_list = zhu_total_len_list + zuo_total_len_list + you_total_len_list
    juanqu_list = zhu_juanqu_list + zuo_juanqu_list + you_juanqu_list
    angle_list = zhu_zuo_angle_list + zhu_you_angle_list + zuo_you_angle_list
    return diam_list, duan_len_list, total_len_list, juanqu_list, angle_list
  
#得到原始数据和生成数据的各项指标列表,由于zong_angle为nan时,有跳出循环的操作，可能导致angle_list长度不同，这对于后面计算各项检验有影响，需要处理这个角度，其他都没事
ori_diam_list, ori_duan_len_list, ori_total_len_list, ori_juanqu_list, ori_angle_list = calculate(ori_axis)
gen_diam_list, gen_duan_len_list, gen_total_len_list, gen_juanqu_list, gen_angle_list = calculate(gen_axis)

##############################################################################
# print(len(ori_diam_list),len(gen_diam_list))
# print(len(ori_duan_len_list),len(gen_duan_len_list))
# print(len(ori_juanqu_list),len(gen_juanqu_list))
# print(len(ori_angle_list),len(gen_angle_list))
###############################################################################

def calculate_param(data_diam_list, data_duan_len_list, data_total_len_list, data_juanqu_list, data_angle_list):
    #计算各项指标平均值
    data_diam_list_mean = np.mean(data_diam_list)
    data_duan_len_list_mean = np.mean(data_duan_len_list)
    data_total_len_list_mean = np.mean(data_total_len_list)
    data_juanqu_list_mean = np.mean(data_juanqu_list)
    data_angle_list_mean =  np.mean(data_angle_list)
    #计算各项指标方差
    data_diam_list_var = np.var(data_diam_list)
    data_duan_len_list_var = np.var(data_duan_len_list)
    data_total_len_list_var = np.var(data_total_len_list)
    data_juanqu_list_var = np.var(data_juanqu_list)
    data_angle_list_var =  np.var(data_angle_list)
    #计算各项指标标准差
    data_diam_list_std = np.std(data_diam_list,ddof=1)
    data_duan_len_list_std = np.std(data_duan_len_list,ddof=1)
    data_total_len_list_std = np.std(data_total_len_list,ddof=1)
    data_juanqu_list_std = np.std(data_juanqu_list,ddof=1)
    data_angle_list_std =  np.std(data_angle_list,ddof=1)
       
    return data_diam_list_mean,data_duan_len_list_mean,data_total_len_list_mean,data_juanqu_list_mean,data_angle_list_mean,data_diam_list_var,data_duan_len_list_var,data_total_len_list_var,data_juanqu_list_var,data_angle_list_var,data_diam_list_std,data_duan_len_list_std,data_total_len_list_std,data_juanqu_list_std,data_angle_list_std
def culculate_diam_list(ori_diam_list,gen_diam_list):
    # 计算管径是否符合
    # 正态性检验
    ori_diam_zt_stat,ori_diam_zt_p = shapiro(ori_diam_list)
    gen_diam_zt_stat,gen_diam_zt_p = shapiro(gen_diam_list)
    # T检验
    ttest_diam_stat,ttest_diam_p = ttest_ind(ori_diam_list,gen_diam_list)
    # 曼-惠特尼U检验
    man_diam_stat, man_diam_p = mannwhitneyu(ori_diam_list,gen_diam_list)
    # 威尔科克森符号秩检验
    wil_diam_stat, wil_diam_p = wilcoxon(ori_diam_list,gen_diam_list)
    return ori_diam_zt_stat,ori_diam_zt_p,gen_diam_zt_stat,gen_diam_zt_p,ttest_diam_stat,ttest_diam_p,man_diam_stat, man_diam_p,wil_diam_stat, wil_diam_p
       
def calculate_duan_len_test(ori_duan_len_list,gen_duan_len_list):
    #计算端点长度是否符合
    #正态性检验
    ori_duan_len_zt_stat,ori_duan_len_zt_p = shapiro(ori_duan_len_list)
    gen_duan_len_zt_stat,gen_duan_len_zt_p = shapiro(gen_duan_len_list)
    #T检验
    ttest_duan_len_stat,ttest_duan_len_p = ttest_ind(ori_duan_len_list,gen_duan_len_list)
    #曼-惠特尼U检验
    man_duan_len_stat,man_duan_len_p = mannwhitneyu(ori_duan_len_list,gen_duan_len_list)
    #威尔科克森符号秩检验
    wil_duan_len_stat,wil_duan_len_p = wilcoxon(ori_duan_len_list,gen_duan_len_list)
    return ori_duan_len_zt_stat,ori_duan_len_zt_p,gen_duan_len_zt_stat,gen_duan_len_zt_p,ttest_duan_len_stat,ttest_duan_len_p,man_duan_len_stat,man_duan_len_p,wil_duan_len_stat,wil_duan_len_p
       
def calculate_total_len_test(ori_total_len_list,gen_total_len_list):
    #计算总长度长度是否符合
    #正态性检验
    ori_total_len_zt_stat,ori_total_len_zt_p = shapiro(ori_total_len_list)
    gen_total_len_zt_stat,gen_total_len_zt_p = shapiro(gen_total_len_list)
    #T检验
    ttest_total_len_stat,ttest_total_len_p = ttest_ind(ori_total_len_list,gen_total_len_list)
    #曼-惠特尼U检验
    man_total_len_stat,man_total_len_p = mannwhitneyu(ori_total_len_list,gen_total_len_list)
    #威尔科克森符号秩检验
    wil_total_len_stat,wil_total_len_p = wilcoxon(ori_total_len_list,gen_total_len_list)
    return ori_total_len_zt_stat,ori_total_len_zt_p,gen_total_len_zt_stat,gen_total_len_zt_p,ttest_total_len_stat,ttest_total_len_p,man_total_len_stat,man_total_len_p,wil_total_len_stat,wil_total_len_p
   
   
def calculate_juanqu_test(ori_juanqu_list,gen_juanqu_list):
    #计算卷曲度是否符合
    #正态性检验
    ori_juanqu_zt_stat,ori_juanqu_zt_p = shapiro(ori_juanqu_list)
    gen_juanqu_zt_stat,gen_juanqu_zt_p = shapiro(gen_juanqu_list)
    #T检验
    ttest_juanqu_stat,ttest_juanqu_p = ttest_ind(ori_juanqu_list,gen_juanqu_list)
    #曼-惠特尼U检验
    man_juanqu_stat,man_juanqu_p = mannwhitneyu(ori_juanqu_list,gen_juanqu_list)
    #威尔科克森符号秩检验
    wil_juanqu_stat,wil_juanqu_p = wilcoxon(ori_juanqu_list,gen_juanqu_list)
    return ori_juanqu_zt_stat,ori_juanqu_zt_p,gen_juanqu_zt_stat,gen_juanqu_zt_p,ttest_juanqu_stat,ttest_juanqu_p,man_juanqu_stat,man_juanqu_p,wil_juanqu_stat,wil_juanqu_p
   
   
def calculate_angle_test(ori_angle_list,gen_angle_list):
    # 使他们长度相等
    ori_angle_list_len = len(ori_angle_list)
    gen_angle_list_len = len(gen_angle_list)
    if ori_angle_list_len >= gen_angle_list_len:
      ori_angle_list = ori_angle_list[0:gen_angle_list_len]
    else:
      gen_angle_list = gen_angle_list[0:ori_angle_list_len]
    #计算角度是否符合
    #正态性检验
    ori_angle_zt_stat,ori_angle_zt_p = shapiro(ori_angle_list)
    gen_angle_zt_stat,gen_angle_zt_p = shapiro(gen_angle_list)
    #T检验
    ttest_angle_stat,ttest_angle_p = ttest_ind(ori_angle_list,gen_angle_list)
    #曼-惠特尼U检验
    man_angle_stat,man_angle_p = mannwhitneyu(ori_angle_list,gen_angle_list)
    #威尔科克森符号秩检验
    wil_angle_stat,wil_angle_p = wilcoxon(ori_angle_list,gen_angle_list)
    return ori_angle_zt_stat,ori_angle_zt_p,gen_angle_zt_stat,gen_angle_zt_p,ttest_angle_stat,ttest_angle_p,man_angle_stat,man_angle_p,wil_angle_stat,wil_angle_p 
       
       
#计算原始数据与生成数据各项指标的平均值，方差，标准差
ori_diam_list_mean,ori_duan_len_list_mean,ori_total_len_list_mean,ori_juanqu_list_mean,ori_angle_list_mean,ori_diam_list_var,ori_duan_len_list_var,ori_total_len_list_var,ori_juanqu_list_var,ori_angle_list_var,ori_diam_list_std,ori_duan_len_list_std,ori_total_len_list_std,ori_juanqu_list_std,ori_angle_list_std = calculate_param(ori_diam_list,ori_duan_len_list,ori_total_len_list,ori_juanqu_list,ori_angle_list)
gen_diam_list_mean,gen_duan_len_list_mean,gen_total_len_list_mean,gen_juanqu_list_mean,gen_angle_list_mean,gen_diam_list_var,gen_duan_len_list_var,gen_total_len_list_var,gen_juanqu_list_var,gen_angle_list_var,gen_diam_list_std,gen_duan_len_list_std,gen_total_len_list_std,gen_juanqu_list_std,gen_angle_list_std = calculate_param(gen_diam_list,gen_duan_len_list,gen_total_len_list,gen_juanqu_list,gen_angle_list)
print("----------管径----------")
print("原始数据平均值:%f" % ori_diam_list_mean,"生成数据平均值:%f" % gen_diam_list_mean)
print("原始数据方差:%f" % ori_diam_list_var,"生成数据方差:%f" % gen_diam_list_var)
print("原始数据标准差:%f" % ori_diam_list_std,"生成数据标准差:%f" % gen_diam_list_std)
print("\n")
print("----------端点长度----------")
print("原始数据平均值:%f" % ori_duan_len_list_mean,"生成数据平均值:%f" % gen_duan_len_list_mean)
print("原始数据方差:%f" % ori_duan_len_list_var,"生成数据方差:%f" % gen_duan_len_list_var)
print("原始数据标准差:%f" % ori_duan_len_list_std,"生成数据标准差:%f" % gen_duan_len_list_std)
print("\n")
print("----------总长度----------")
print("原始数据平均值:%f" % ori_total_len_list_mean,"生成数据平均值:%f" % gen_total_len_list_mean)
print("原始数据方差:%f" % ori_total_len_list_var,"生成数据方差:%f" % gen_total_len_list_var)
print("原始数据标准差:%f" % ori_total_len_list_std,"生成数据标准差:%f" % gen_total_len_list_std)
print("\n")
print("----------卷曲度----------")
print("原始数据平均值:%f" % ori_juanqu_list_mean,"生成数据平均值:%f" % gen_juanqu_list_mean)
print("原始数据方差:%f" % ori_juanqu_list_var,"生成数据标准差:%f" % gen_juanqu_list_var)
print("原始数据标准差:%f" % ori_juanqu_list_std,"生成数据标准差:%f" % gen_juanqu_list_std)
print("\n")
print("----------角度----------")
print("原始数据平均值:%f" % ori_angle_list_mean,"生成数据平均值:%f" % gen_angle_list_mean)
print("原始数据方差:%f" % ori_angle_list_var,"生成数据方差:%f" % gen_angle_list_var)
print("原始数据标准差:%f" % ori_angle_list_std,"生成数据标准差:%f" % gen_angle_list_std)
  
print("\n\n")
# 计算原始数据与生成数据是否符合各项统计性检验
# 各项指标正态性检验都不符合, 这里不再打印
ori_diam_zt_stat,ori_diam_zt_p,gen_diam_zt_stat,gen_diam_zt_p,ttest_diam_stat,ttest_diam_p,man_diam_stat, man_diam_p,wil_diam_stat, wil_diam_p = culculate_diam_list(ori_diam_list,gen_diam_list)
print("----------管径统计性检验----------")
# print("原始数据正态性检验:%f" % ori_diam_zt_p,"生成数据正态性检验:%f" % gen_diam_zt_p)
print("T检验:%f" % ttest_diam_p)
print("曼-惠特尼U检验:%f" % man_diam_p)
print("威尔科克森符号秩检验:%f" % wil_diam_p)
print("\n")
ori_duan_len_zt_stat,ori_duan_len_zt_p,gen_duan_len_zt_stat,gen_duan_len_zt_p,ttest_duan_len_stat,ttest_duan_len_p,man_duan_len_stat,man_duan_len_p,wil_duan_len_stat,wil_duan_len_p = calculate_duan_len_test(ori_duan_len_list,gen_duan_len_list)
print("----------端点长度统计性检验----------")
# print("原始数据正态性检验:%f" % ori_duan_len_zt_p,"生成数据正态性检验:%f" % gen_duan_len_zt_p)
print("T检验:%f" % ttest_duan_len_p)
print("曼-惠特尼U检验:%f" % man_duan_len_p)
print("威尔科克森符号秩检验:%f" % wil_duan_len_p)
print("\n")
ori_total_len_zt_stat,ori_total_len_zt_p,gen_total_len_zt_stat,gen_total_len_zt_p,ttest_total_len_stat,ttest_total_len_p,man_total_len_stat,man_total_len_p,wil_total_len_stat,wil_total_len_p = calculate_total_len_test(ori_total_len_list,gen_total_len_list)
print("----------总长度统计性检验----------")
# print("原始数据正态性检验:%f" % ori_total_len_zt_p,"生成数据正态性检验:%f" % gen_total_len_zt_p)
print("T检验:%f" % ttest_total_len_p)
print("曼-惠特尼U检验:%f" % man_total_len_p)
print("威尔科克森符号秩检验:%f" % wil_total_len_p)
print("\n")
ori_juanqu_zt_stat,ori_juanqu_zt_p,gen_juanqu_zt_stat,gen_juanqu_zt_p,ttest_juanqu_stat,ttest_juanqu_p,man_juanqu_stat,man_juanqu_p,wil_juanqu_stat,wil_juanqu_p = calculate_juanqu_test(ori_juanqu_list,gen_juanqu_list)
print("----------卷曲度统计性检验----------")
# print("原始数据正态性检验:%f" % ori_juanqu_zt_p,"生成数据正态性检验:%f" % gen_juanqu_zt_p)
print("T检验:%f" % ttest_juanqu_p)
print("曼-惠特尼U检验:%f" % man_juanqu_p)
print("威尔科克森符号秩检验:%f" % wil_juanqu_p)
print("\n")
ori_angle_zt_stat,ori_angle_zt_p,gen_angle_zt_stat,gen_angle_zt_p,ttest_angle_stat,ttest_angle_p,man_angle_stat,man_angle_p,wil_angle_stat,wil_angle_p = calculate_angle_test(ori_angle_list,gen_angle_list)
print("----------角度统计性检验----------")
# print("原始数据正态性检验:%f" % ori_angle_zt_p,"生成数据正态性检验:%f" % gen_angle_zt_p)
print("T检验:%f" % ttest_angle_p)
print("曼-惠特尼U检验:%f" % man_angle_p)
print("威尔科克森符号秩检验:%f" % wil_angle_p)