拼接单个分叉

import tensorflow as tf
import scipy.io as sio
import numpy as np
from PIL import Image
import os 
import copy
import math
import matplotlib.pyplot as plt
np.set_printoptions(threshold=np.inf) #输出全部矩阵不带省略号
#######################################################################
data = np.load('data/class_data.npy')
print(data.shape)
# np.random.shuffle(data)
######################################################################
# 将数据与标签分离，并对标签进行one_hot编码
def input_data(finaldata):
  data = []
  label = []
  for i in range(len(finaldata)):
    data.append(finaldata[i][0])
    label.append(finaldata[i][1])
  data = np.array(data)
  data = data.reshape(-1,16,16,1)
  label = np.array(label)
  
  return data, label
###########################################################################
def manage_data(data):
      data = data.reshape(-1,16,16)
      manage_data = []
      data = data.tolist()
      for i in range(len(data)):
          zhu_x = data[i][4]
          zuo_x = data[i][5]
          you_x = data[i][6]
          zhu_y = data[i][7]
          zuo_y = data[i][8]
          you_y = data[i][9]
          zhu_diam = data[i][10]
          zuo_diam = data[i][11]
          you_diam = data[i][12]
          x0_mean = (zhu_x[0] + zuo_x[0] + you_x[0]) / 3.
          y0_mean = (zhu_y[0] + zuo_y[0] + you_y[0]) / 3.
          zhu_x[0] = x0_mean
          zuo_x[0] = x0_mean
          you_x[0] = x0_mean
          zhu_y[0] = y0_mean
          zuo_y[0] = y0_mean
          you_y[0] = y0_mean
          fencha = [zhu_x] + [zuo_x] + [you_x] + [zhu_y] + [zuo_y] + [you_y] + [zhu_diam] + [zuo_diam] + [you_diam] 
          manage_data.append(fencha)
      manage_data = np.array(manage_data)
      return manage_data
##############################################################################
# 训练集
data_train, label_train = input_data(data)
data = manage_data(data_train)
# data = data[0:10,:,:]
print(data.shape)
# 距离计算公式
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 get_diam(fencha):
  zhu_diam = fencha[6][0]
  zuo_diam = fencha[7][0]
  you_diam = fencha[8][0]
  return zhu_diam, zuo_diam, you_diam
# 计算端点长度
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)):
        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
# 计算卷曲度
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
#     print(zhu_total_len)
#     print(zhu_duan_len)
#     print(zhu_juanqu)
    return zhu_juanqu,zuo_juanqu,you_juanqu
def plt_fencha(data,label='red'):
  zhu_x = data[0]
  zuo_x = data[1]
  you_x = data[2]
  zhu_y = data[3]
  zuo_y = data[4]
  you_y = data[5]
  if label=='red':
    plt.plot(zhu_x,zhu_y,color='red',linewidth=3)
  if label=='blue':
    plt.plot(zhu_x,zhu_y,color='blue',linewidth=3)
  if label == 'green':
    plt.plot(zhu_x,zhu_y,color='green',linewidth=3)
  plt.plot(zuo_x,zuo_y,color='black',linewidth=3)
  plt.plot(you_x,you_y,color='black',linewidth=3)
  plt.xlim(-0.8,1.5)
  plt.ylim(-0.8,1.5)
  plt.xticks(np.arange(-0.8,1.5,0.2))
  plt.yticks(np.arange(-0.8,1.5,0.2))
  
# 去掉一个分叉的每个分支
def get_fencha(data):
  zhu_x = data[0]
  zuo_x = data[1]
  you_x = data[2]
  zhu_y = data[3]
  zuo_y = data[4]
  you_y = data[5]
  zhu_diam = [data[6]]
  zuo_diam = [data[7]]
  you_diam = [data[8]]
  return zhu_x,zuo_x,you_x,zhu_y,zuo_y,you_y,zhu_diam,zuo_diam,you_diam
segment = 'zhu' # 'zuo','you'
# 得到每个分叉结点坐标
def get_node(data,segment):
  if segment == 'zhu':
    nodeStartX = data[0][0]
    nodeEndX = data[0][-1]
    nodeStartY = data[3][0]
    nodeEndY = data[3][-1]
  if segment == 'zuo':
    nodeStartX = data[1][0]
    nodeEndX = data[1][-1]
    nodeStartY = data[4][0]
    nodeEndY = data[4][-1]
  if segment == 'you':
    nodeStartX = data[2][0]
    nodeEndX = data[2][-1]
    nodeStartY = data[5][0]
    nodeEndY = data[5][-1]
  return nodeStartX,nodeStartY,nodeEndX,nodeEndY
# 得到 第二个结点和倒数第二个结点
def get_other_node(data,segment):
  if segment == 'zhu':
    nodeStartX = data[0][0]
    nodeTwoX = data[0][1]
    nodeLastTwoX = data[0][-2]
    nodeStartY = data[3][0]
    nodeTwoY = data[3][1]
    nodeLastTwoY = data[3][-2]
  if segment == 'zuo':
    nodeStartX = data[1][0]
    nodeTwoX = data[1][1]
    nodeLastTwoX = data[1][-2]
    nodeStartY = data[4][0]
    nodeTwoY = data[4][1]
    nodeLastTwoY = data[4][-2]
  if segment == 'you':
    nodeStartX = data[2][0]
    nodeTwoX = data[2][1]
    nodeLastTwoX = data[2][-2]
    nodeStartY = data[5][0]
    nodeTwoY = data[5][1]
    nodeLastTwoY = data[5][-2]
  return nodeStartX,nodeStartY,nodeTwoX,nodeTwoY,nodeLastTwoX,nodeLastTwoY

# # 得到 第二个结点和倒数第二个结点
# def get_other_node(data,segment):
#   if segment == 'zhu':
#     nodeStartX = data[0][0]
#     nodeTwoX = data[0][2]
#     nodeLastTwoX = data[0][-3]
#     nodeStartY = data[3][0]
#     nodeTwoY = data[3][2]
#     nodeLastTwoY = data[3][-3]
#   if segment == 'zuo':
#     nodeStartX = data[1][0]
#     nodeTwoX = data[1][2]
#     nodeLastTwoX = data[1][-3]
#     nodeStartY = data[4][0]
#     nodeTwoY = data[4][2]
#     nodeLastTwoY = data[4][-3]
#   if segment == 'you':
#     nodeStartX = data[2][0]
#     nodeTwoX = data[2][2]
#     nodeLastTwoX = data[2][-3]
#     nodeStartY = data[5][0]
#     nodeTwoY = data[5][2]
#     nodeLastTwoY = data[5][-3]
#   return nodeStartX,nodeStartY,nodeTwoX,nodeTwoY,nodeLastTwoX,nodeLastTwoY
# 将两个分叉移动到结点相同位置
def remove_fencha(data1,data2,segment):
  #  以data1为固定分叉,data2往上拼接
  nodeStartX1,nodeStartY1, _, _ = get_node(data1,segment)
  _, _, nodeEndX2,nodeEndY2 = get_node(data2,segment)
  disc_x = nodeEndX2 - nodeStartX1
  disc_y = nodeEndY2 - nodeStartY1
  copyData2 = copy.deepcopy(data2)
  copyData2[0:3] = copyData2[0:3] - disc_x
  copyData2[3:6] = copyData2[3:6] - disc_y
  removeData = copyData2
  return removeData
# 拼接图像
sample = data[6]
# 计算结点与x正半轴夹角
def get_angles(startNodeX,startNodeY,endNodeX,endNodeY):
  # 以点startNodeX,startNodeY为原点不能随意反转他们的顺序
  if endNodeX>=startNodeX and endNodeY>=startNodeY:
    angle = math.degrees(np.arctan(abs(endNodeY-startNodeY)/abs(endNodeX-startNodeX)))
  if endNodeX<=startNodeX and endNodeY>=startNodeY:
    angle = math.degrees(np.arctan(abs(endNodeY-startNodeY)/abs(endNodeX-startNodeX)))
    angle = 180 - angle
  if endNodeX<=startNodeX and endNodeY<=startNodeY:
    angle = math.degrees(np.arctan(abs(endNodeY-startNodeY)/abs(endNodeX-startNodeX)))
    angle = 180 + angle
  if endNodeX>=startNodeX and endNodeY<=startNodeY:
    angle = math.degrees(np.arctan(abs(endNodeY-startNodeY)/abs(endNodeX-startNodeX)))
    angle = 360 - angle
  return angle

def get_disAngle(data1,data2,segment):
  # data2,往data1上拼,data1分支起点作为原点
  nodeStartX1,nodeStartY1,nodeEndX1,nodeEndY1 = get_node(data1,segment)
  nodeStartX2,nodeStartY2,nodeEndX2,nodeEndY2 = get_node(data2,segment)
  angle1 = get_angles(nodeStartX1,nodeStartY1,nodeEndX1,nodeEndY1)
  angle2 = get_angles(nodeEndX2,nodeEndY2,nodeStartX2,nodeStartY2)
  disAngle = angle2-angle1
  return disAngle
def get_otherDisAngle(data1,data2,segment):
  _,_,_,_,nodeLastTwoX1,nodeLastTwoY1 = get_other_node(data1,segment)
  nodeStartX2,nodeStartY2,nodeTwoX2,nodeTwoY2,_,_ = get_other_node(data2,segment)
  angle1 = get_angles(nodeStartX2,nodeStartY2,nodeLastTwoX1,nodeLastTwoY1)
  angle2 = get_angles(nodeStartX2,nodeStartY2,nodeTwoX2,nodeTwoY2)
#   print(angle1)
#   print(angle2)
  otherDisAngle = angle2 - angle1
  return otherDisAngle
# 绕pointx,pointy逆时针旋转
def Nrotate(angle,valuex,valuey,pointx,pointy):
  valuex = np.array(valuex)
  valuey = np.array(valuey)
  nRotatex = (valuex-pointx)*math.cos(angle) - (valuey-pointy)*math.sin(angle) + pointx
  nRotatey = (valuex-pointx)*math.sin(angle) + (valuey-pointy)*math.cos(angle) + pointy
  return nRotatex, nRotatey
# 绕pointx,pointy顺时针旋转
def Srotate(angle,valuex,valuey,pointx,pointy):
  valuex = np.array(valuex)
  valuey = np.array(valuey)
  sRotatex = (valuex-pointx)*math.cos(angle) + (valuey-pointy)*math.sin(angle) + pointx
  sRotatey = (valuey-pointy)*math.cos(angle) - (valuex-pointx)*math.sin(angle) + pointy
  return sRotatex,sRotatey

def concate(data1,data2,segment):
  _,_,nodeEndX1,nodeEndY1 = get_node(data1,segment)
  nodeStartX2,nodeStartY2,_,_, = get_node(data2,segment)
  concateData = copy.deepcopy(data2)
  disNodeX = nodeStartX2 - nodeEndX1
  disNodeY = nodeStartY2 - nodeEndY1
  concateData[0:3] = concateData[0:3] - disNodeX
  concateData[3:6] = concateData[3:6] - disNodeY
  
  return concateData
def replace(data1,data2,segment):  
  replaceData = copy.deepcopy(data2)
  if segment == 'zhu':
    replaceData[0] = data1[0][::-1]
    replaceData[3] = data1[3][::-1]
  if segment == 'zuo':
    replaceData[1] = data1[1][::-1]
    replaceData[4] = data1[4][::-1]
  if segment == 'you':
    replaceData[2] = data1[2][::-1]
    replaceData[5] = data1[5][::-1]
  return replaceData
  
  
def afterRotate(data1,data2,segment):
  # 移动分叉
  removeData = remove_fencha(data1, data2, segment)
  # 旋转分叉
  disAngle = get_disAngle(data1, removeData, segment)
  pointx = removeData[0][-1]
  pointy = removeData[3][-1]
  valuex = removeData[0:3]
  valuey = removeData[3:6]
  afterRotateData = copy.deepcopy(removeData)
  if disAngle<=0:
    rotatex,rotatey = Nrotate(math.radians(abs(disAngle)),valuex,valuey,pointx,pointy)
  else:
    rotatex,rotatey = Srotate(math.radians(abs(disAngle)),valuex,valuey,pointx,pointy)
  afterRotateData[0:3] = rotatex
  afterRotateData[3:6] = rotatey
  ######################################
  # 连接分叉 
  concateData = concate(data1,afterRotateData,segment)
  # 再次旋转分叉,使角度相等
  otherDisangle = get_otherDisAngle(data1, concateData, segment)
  print(otherDisangle)
  otherPointx = concateData[0][0]
  otherPointy = concateData[3][0]
  otherValuex = concateData[0:3]
  otherValuey = concateData[3:6]
  afterOtherRotateData = copy.deepcopy(concateData)
  if otherDisangle<=0:
    otherRotatex,otherRotatey = Nrotate(math.radians(abs(otherDisangle)),otherValuex,otherValuey,otherPointx,otherPointy)
  else:
    otherRotatex,otherRotatey = Srotate(math.radians(abs(otherDisangle)),otherValuex,otherValuey,otherPointx,otherPointy)
  afterOtherRotateData[0:3] = otherRotatex
  afterOtherRotateData[3:6] = otherRotatey
#   otherdisAngle = get_otherDisAngle(data1, afterOtherRotateData, segment)
#   print(otherdisAngle)
  ##############################################
  # 替换分支
  replaceData = replace(data1,afterOtherRotateData,segment)
  plt_fencha(data1,label='red')
#   plt_fencha(data2,label='blue')
#   plt_fencha(removeData,label='blue')
#   plt_fencha(afterRotateData,label='blue')
#   plt_fencha(concateData,label='blue')
#   plt_fencha(afterOtherRotateData,label='blue')
  plt_fencha(replaceData,label='blue')
  plt.show()

# afterRotate(data[7],data[8],segment)
for i in range(len(data)):
  print(i)
  afterRotate(data[i],data[i+1],segment)