|
|
# -*- encoding: utf-8 -*-
|
|
|
|
|
|
import math
|
|
|
import random
|
|
|
import pandas as pd
|
|
|
from collections import Counter
|
|
|
|
|
|
def _init():
|
|
|
global _global_dict
|
|
|
_global_dict={}
|
|
|
|
|
|
|
|
|
|
|
|
class Data():
|
|
|
def __init__(self, source :int, num: int):
|
|
|
self.source = source
|
|
|
# 数据来源
|
|
|
# 1随机 2黑龙江省 3辽宁省
|
|
|
# 默认为1
|
|
|
self.edgeinfo = 1
|
|
|
# 是否显示详情
|
|
|
# 1显示 0不显示
|
|
|
# 默认为1
|
|
|
self.heidata = pd.read_excel("hei/data.xlsx") # 黑龙江省各市信息
|
|
|
self.heitime = pd.read_excel("hei/time.xlsx") # 黑龙江省各市通行时间
|
|
|
self.heidis = pd.read_excel("hei/distance.xlsx") # 黑龙江省各市通行距离
|
|
|
self.liaodata = pd.read_excel("liao/data.xlsx") # 辽宁省各市信息
|
|
|
self.liaotime = pd.read_excel("liao/time.xlsx") # 辽宁省各市通行时间
|
|
|
self.liaodis = pd.read_excel("liao/distance.xlsx") # 辽宁省各市通行距离
|
|
|
if self.source == 1:
|
|
|
self.data(num)
|
|
|
elif self.source == 2:
|
|
|
self.HEI_data(num)
|
|
|
elif self.source == 3:
|
|
|
self.LIAO_data(num)
|
|
|
|
|
|
|
|
|
def get_liaotime(self, i, j):
|
|
|
# print(self.heidata.iloc[i, 0])
|
|
|
# print(self.heidata.iloc[j, 0])
|
|
|
# print(self.heitime.iloc[i, j + 1])
|
|
|
return math.floor(self.liaotime.iloc[i, j + 1])
|
|
|
|
|
|
def get_liaodis(self, i, j):
|
|
|
# print(self.heidata.iloc[i, 0])
|
|
|
# print(self.heidata.iloc[j, 0])
|
|
|
# print(self.heidis.iloc[i, j + 1])
|
|
|
return math.floor(self.liaodis.iloc[i, j + 1] / 1000)
|
|
|
|
|
|
def get_heitime(self, i, j):
|
|
|
# print(self.heidata.iloc[i, 0])
|
|
|
# print(self.heidata.iloc[j, 0])
|
|
|
# print(self.heitime.iloc[i, j + 1])
|
|
|
return math.floor(self.heitime.iloc[i, j + 1])
|
|
|
|
|
|
def get_heidis(self, i, j):
|
|
|
# print(self.heidata.iloc[i, 0])
|
|
|
# print(self.heidata.iloc[j, 0])
|
|
|
# print(self.heidis.iloc[i, j + 1])
|
|
|
return math.floor(self.heidis.iloc[i, j + 1] / 1000)
|
|
|
|
|
|
def data(self, num: int):
|
|
|
if num <= 0:
|
|
|
raise ValueError("num must be a positive integer")
|
|
|
self.edgeinfo = 1
|
|
|
# 是否显示详情
|
|
|
# 1显示 0不显示
|
|
|
# 默认为1
|
|
|
self.nodes_num = num # 节点个数
|
|
|
self.ang = 360 / self.nodes_num # 圆心顶点角度
|
|
|
self.R = 300 # 外接圆半径
|
|
|
self.bc = 2 * self.R * math.sin(math.pi / self.nodes_num) # 节点之间的正多边形距离
|
|
|
self.canvas_len = int(2 * self.R + 80) # 画布边长
|
|
|
self.center = (self.canvas_len // 2, self.canvas_len // 2) # 画布中心点坐标
|
|
|
self.coordinate = self.coord_creat() # 纯节点坐标
|
|
|
self.Nodes = self.nodes_creat() # 创建节点列表
|
|
|
self.Edges = self.edges_creat() # 创建第一条连接
|
|
|
self.edge_add(2) # 创建第2条连接
|
|
|
self.edge_add(3) # 创建第3条连接
|
|
|
|
|
|
def HEI_data(self, num: int):
|
|
|
self.edgeinfo = 1
|
|
|
# 是否显示详情
|
|
|
# 1显示 0不显示
|
|
|
# 默认为1
|
|
|
self.number = []
|
|
|
for i in range(13):
|
|
|
self.number.append(i)
|
|
|
self.name = random.sample(self.number, num)
|
|
|
self.nodes_num = num # 节点个数
|
|
|
self.ang = 360 / self.nodes_num # 圆心顶点角度
|
|
|
self.R = 300 # 外接圆半径
|
|
|
self.bc = 2 * self.R * math.sin(math.pi / self.nodes_num) # 节点之间的正多边形距离
|
|
|
self.canvas_len = int(2 * self.R + 80) # 画布边长
|
|
|
self.center = (self.canvas_len // 2, self.canvas_len // 2) # 画布中心点
|
|
|
self.coordinate = self.coord_creat() # 纯节点坐标
|
|
|
self.Nodes = self.JI_nodes_creat() # 节点列表
|
|
|
self.Edges = self.JI_edges_creat()
|
|
|
self.JI_edge_add(2)
|
|
|
self.JI_edge_add(3)
|
|
|
|
|
|
def LIAO_data(self, num: int):
|
|
|
self.edgeinfo = 1
|
|
|
# 是否显示详情
|
|
|
# 1显示 0不显示
|
|
|
# 默认为1
|
|
|
self.number = []
|
|
|
for i in range(13):
|
|
|
self.number.append(i)
|
|
|
self.name = random.sample(self.number, num)
|
|
|
self.nodes_num = num # 节点个数
|
|
|
self.ang = 360 / self.nodes_num # 圆心顶点角度
|
|
|
self.R = 300 # 外接圆半径
|
|
|
self.bc = 2 * self.R * math.sin(math.pi / self.nodes_num) # 节点之间的正多边形距离
|
|
|
self.canvas_len = int(2 * self.R + 80) # 画布边长
|
|
|
self.center = (self.canvas_len // 2, self.canvas_len // 2) # 画布中心点
|
|
|
self.coordinate = self.coord_creat() # 纯节点坐标
|
|
|
self.Nodes = self.LIAO_nodes_creat() # 节点列表
|
|
|
self.Edges = self.LIAO_edges_creat()
|
|
|
self.LIAO_edge_add(2)
|
|
|
self.LIAO_edge_add(3)
|
|
|
|
|
|
def LIAO_nodes_creat(self, n_sum=None):
|
|
|
"""Nodes[]={<节点对象编号，节点标签，节点类别，节点坐标, 是否为必经节点（默认必经）>}"""
|
|
|
if n_sum == None:
|
|
|
n_sum = self.nodes_num
|
|
|
nodes = []
|
|
|
miny = float("inf")
|
|
|
minx = float("inf")
|
|
|
maxx = 0
|
|
|
maxy = 0
|
|
|
|
|
|
for i in self.name:
|
|
|
maxx = max(maxx, self.liaodata.iloc[i, 2])
|
|
|
minx = min(minx, self.liaodata.iloc[i, 2])
|
|
|
maxy = max(maxy, self.liaodata.iloc[i, 1])
|
|
|
miny = min(miny, self.liaodata.iloc[i, 1])
|
|
|
lenx = maxx - minx
|
|
|
leny = maxy - miny
|
|
|
Ox = (maxx + minx) / 2
|
|
|
Oy = (maxy + miny) / 2
|
|
|
|
|
|
x0 = self.center[0]
|
|
|
y0 = self.center[1]
|
|
|
for i in range(n_sum):
|
|
|
ix = self.liaodata.iloc[self.name[i], 2]
|
|
|
iy = self.liaodata.iloc[self.name[i], 1]
|
|
|
x = int(((ix - Ox) / lenx) * 550)
|
|
|
y = -int(((iy - Oy) / leny) * 550)
|
|
|
|
|
|
name = self.liaodata.iloc[self.name[i], 0]
|
|
|
# name=''+str(i+1)
|
|
|
mark = 0
|
|
|
dominator = 1
|
|
|
nodes.append([i, name, mark, (x0+x, y0+y), dominator])
|
|
|
return nodes
|
|
|
|
|
|
def LIAO_edges_creat(self):
|
|
|
'''
|
|
|
路径创建
|
|
|
Edges[] = { < 连接对象编号，节点对象1编号，节点对象2编号，连接序号，连接是否可用，连接标签，连接的距离 / 成本，连接的时间 >}
|
|
|
'''
|
|
|
|
|
|
edges = [] # 所有链接集合
|
|
|
ser = 0 # 链接对象编号
|
|
|
nodes = self.Nodes.copy() # 复制节点对象
|
|
|
nodes1 = self.Nodes.copy() # 复制节点对象
|
|
|
|
|
|
for node in nodes: # 遍历节点对象
|
|
|
if node in nodes1: # 删除nodes1中当期遍历的节点信息
|
|
|
nodes1.remove(node)
|
|
|
for node1 in nodes1: # 遍历删除后的节点信息
|
|
|
# Edges[] = { < 连接序号，节点对象1编号，节点对象2编号，链接是否可用（序号大于1），连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
n1 = node[0] # 节点对象编号1
|
|
|
n2 = node1[0] # 节点对象编号2
|
|
|
seq = 1 # 链接序号
|
|
|
mark = False # 连接是否标记
|
|
|
tag = self.liaodis.iloc[self.name[n1], 0] + '-' + self.liaodis.iloc[self.name[n2], 0]
|
|
|
# tag = f"{n1+1}-{n2+1}" # 链接标签
|
|
|
dist_c = self.get_liaodis(n1, n2)
|
|
|
# dist_c = random.randint(30,120) # 距离成本
|
|
|
time_c = self.get_liaotime(n1, n2)
|
|
|
# time_c = random.randint(1,30) # 链接的时间
|
|
|
enable = 1 # 连接是否可用
|
|
|
edges.append([ser, n1, n2, enable, mark, tag, dist_c, time_c, seq])
|
|
|
ser += 1
|
|
|
return edges
|
|
|
|
|
|
def LIAO_edge_add(self, no):
|
|
|
nodes = self.Nodes.copy() # 复制节点对象
|
|
|
nodes1 = self.Nodes.copy() # 复制节点对象
|
|
|
for node in nodes: # 遍历节点对象
|
|
|
if node in nodes1: # 删除nodes1中当期遍历的节点信息
|
|
|
nodes1.remove(node)
|
|
|
|
|
|
for node1 in nodes1: # 遍历删除后的节点信息
|
|
|
# Edges[] = { < 连接序号，节点对象1编号，节点对象2编号，链接是否显示（序号大于1），连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
ser = len(self.Edges) # 链接序号
|
|
|
n1 = node[0] # 节点对象编号1
|
|
|
n2 = node1[0] # 节点对象编号2
|
|
|
show = 0
|
|
|
mark = False # 连接是否标记
|
|
|
tag = f"{self.liaodis.iloc[self.name[n1], 0]}-{self.liaodis.iloc[self.name[n2], 0]}-{no}" # 链接标签
|
|
|
# tag = f"{n1 + 1}-{n2 + 1}-{no}" # 链接标签
|
|
|
dist_c = self.get_liaodis(n1, n2)
|
|
|
# dist_c = random.randint(30,120) # 距离成本
|
|
|
time_c = self.get_liaotime(n1, n2)
|
|
|
# time_c = random.randint(1,30) # 链接的时间
|
|
|
seq = no # 连接序号
|
|
|
self.Edges.append([ser, n1, n2, show, mark, tag, dist_c, time_c, seq])
|
|
|
|
|
|
def JI_nodes_creat(self, n_sum=None):
|
|
|
"""Nodes[]={<节点对象编号，节点标签，节点类别，节点坐标, 是否为必经节点（默认必经）>>}"""
|
|
|
if n_sum == None:
|
|
|
n_sum = self.nodes_num
|
|
|
nodes = []
|
|
|
miny = float("inf")
|
|
|
minx = float("inf")
|
|
|
maxx = 0
|
|
|
maxy = 0
|
|
|
|
|
|
for i in self.name:
|
|
|
# print(i, self.heidis.iloc[i, 0])
|
|
|
# print(self.heidata.iloc[i, 0], self.heidata.iloc[i, 1], self.heidata.iloc[i, 2])
|
|
|
maxx = max(maxx, self.heidata.iloc[i, 2])
|
|
|
minx = min(minx, self.heidata.iloc[i, 2])
|
|
|
maxy = max(maxy, self.heidata.iloc[i, 1])
|
|
|
miny = min(miny, self.heidata.iloc[i, 1])
|
|
|
# print(maxx, maxy, minx, miny)
|
|
|
lenx = maxx - minx
|
|
|
leny = maxy - miny
|
|
|
Ox = (maxx + minx) / 2
|
|
|
Oy = (maxy + miny) / 2
|
|
|
|
|
|
R = self.R
|
|
|
x0 = self.center[0]
|
|
|
y0 = self.center[1]
|
|
|
for i in range(n_sum):
|
|
|
# rad = math.radians(i*self.ang)
|
|
|
# x = int(math.cos(rad)*R)
|
|
|
# y = int(math.sin(rad)*R)
|
|
|
ix = self.heidata.iloc[self.name[i], 2]
|
|
|
iy = self.heidata.iloc[self.name[i], 1]
|
|
|
# print(int(math.cos(rad)*R))
|
|
|
# print(((ix - Ox) / lenx) * 300)
|
|
|
x = int(((ix - Ox) / lenx) * 550)
|
|
|
y = -int(((iy - Oy) / leny) * 550)
|
|
|
name = self.heidata.iloc[self.name[i], 0]
|
|
|
# name=''+str(i+1)
|
|
|
mark = 0
|
|
|
dominator = 1
|
|
|
nodes.append([i, name, mark, (x0+x, y0+y), dominator])
|
|
|
return nodes
|
|
|
|
|
|
def JI_edges_creat(self):
|
|
|
'''
|
|
|
路径创建
|
|
|
Edges[] = { < 连接对象编号，节点对象1编号，节点对象2编号，连接序号，连接是否可用，连接标签，连接的距离 / 成本，连接的时间 >}
|
|
|
'''
|
|
|
|
|
|
edges = [] # 所有链接集合
|
|
|
ser = 0 # 链接对象编号
|
|
|
nodes = self.Nodes.copy() # 复制节点对象
|
|
|
nodes1 = self.Nodes.copy() # 复制节点对象
|
|
|
|
|
|
for node in nodes: # 遍历节点对象
|
|
|
if node in nodes1: # 删除nodes1中当期遍历的节点信息
|
|
|
nodes1.remove(node)
|
|
|
|
|
|
for node1 in nodes1: # 遍历删除后的节点信息
|
|
|
for i in range(random.randint(1,1)):
|
|
|
# Edges[] = { < 连接序号，节点对象1编号，节点对象2编号，链接是否可用（序号大于1），连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
|
|
|
n1 = node[0] # 节点对象编号1
|
|
|
n2 = node1[0] # 节点对象编号2
|
|
|
seq = 1 # 链接序号
|
|
|
mark = False # 连接是否标记
|
|
|
tag = self.heidis.iloc[self.name[n1], 0] + '-' + self.heidis.iloc[self.name[n2], 0]
|
|
|
# tag = f"{n1+1}-{n2+1}" # 链接标签
|
|
|
dist_c = self.get_heidis(n1, n2)
|
|
|
# dist_c = random.randint(30,120) # 距离成本
|
|
|
time_c = self.get_heitime(n1, n2)
|
|
|
# time_c = random.randint(1,30) # 链接的时间
|
|
|
enable = 1 # 连接是否可用
|
|
|
edges.append([ser, n1, n2, enable, mark, tag, dist_c, time_c, seq])
|
|
|
ser += 1
|
|
|
return edges
|
|
|
|
|
|
def JI_edge_add(self, no):
|
|
|
nodes = self.Nodes.copy() # 复制节点对象
|
|
|
nodes1 = self.Nodes.copy() # 复制节点对象
|
|
|
for node in nodes: # 遍历节点对象
|
|
|
if node in nodes1: # 删除nodes1中当期遍历的节点信息
|
|
|
nodes1.remove(node)
|
|
|
|
|
|
for node1 in nodes1: # 遍历删除后的节点信息
|
|
|
# Edges[] = { < 连接序号，节点对象1编号，节点对象2编号，链接是否显示（序号大于1），连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
ser = len(self.Edges) # 链接序号
|
|
|
n1 = node[0] # 节点对象编号1
|
|
|
n2 = node1[0] # 节点对象编号2
|
|
|
show = 0
|
|
|
mark = False # 连接是否标记
|
|
|
tag = f"{self.heidis.iloc[self.name[n1], 0]}-{self.heidis.iloc[self.name[n2], 0]}-{no}" # 链接标签
|
|
|
# tag = f"{n1 + 1}-{n2 + 1}-{no}" # 链接标签
|
|
|
dist_c = self.get_heidis(n1, n2)
|
|
|
# dist_c = random.randint(30,120) # 距离成本
|
|
|
time_c = self.get_heitime(n1, n2)
|
|
|
# time_c = random.randint(1,30) # 链接的时间
|
|
|
seq = no # 连接序号
|
|
|
self.Edges.append([ser, n1, n2, show, mark, tag, dist_c, time_c, seq])
|
|
|
|
|
|
|
|
|
def coord_creat(self):
|
|
|
'''返回每个节点的坐标'''
|
|
|
coordinate = []
|
|
|
x0 = self.center[0]
|
|
|
y0 = self.center[1]
|
|
|
for i in range(self.nodes_num):
|
|
|
rad = math.radians(i*self.ang)
|
|
|
x = int(math.cos(rad)*self.R)
|
|
|
y = int(math.sin(rad)*self.R)
|
|
|
coordinate.append((x0+x,y0+y))
|
|
|
return coordinate
|
|
|
|
|
|
def nodes_creat(self, n_sum= None):
|
|
|
"""Nodes[]={<节点对象编号，节点标签，节点类别，节点坐标, 是否为必经节点（默认必经）>}"""
|
|
|
if n_sum == None:
|
|
|
n_sum = self.nodes_num
|
|
|
nodes = []#初始化node表
|
|
|
# 设置画布中心点坐标x0,y0
|
|
|
x0 = self.center[0]
|
|
|
y0 = self.center[1]
|
|
|
for i in range(n_sum):# 通过几何运算得到多边形各个顶点坐标
|
|
|
rad = math.radians(i * self.ang)# 计算第i个点的弧度
|
|
|
x = int(math.cos(rad) * self.R)# 计算第i个顶点x坐标
|
|
|
y = int(math.sin(rad) * self.R)# 计算第i个顶点y坐标
|
|
|
name = '' + str(i + 1)# 给第i个顶点命名
|
|
|
mark = 0#节点为未标记
|
|
|
dominator = 1#设置为必经节点
|
|
|
nodes.append([i, name, mark, (x0 + x, y0 + y), dominator])#将当前节点加入node中
|
|
|
return nodes
|
|
|
|
|
|
|
|
|
def edges_creat(self):
|
|
|
'''
|
|
|
路径创建
|
|
|
Edges[] = { < 连接对象编号，节点对象1编号，节点对象2编号，连接是否存在，连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
'''
|
|
|
edges = [] # 初始化所有链接集合
|
|
|
ser = 0 # 初始化链接对象编号
|
|
|
nodes = self.Nodes.copy() # 复制节点对象
|
|
|
nodes1 = self.Nodes.copy() # 复制节点对象
|
|
|
for node in nodes: # 遍历节点对象
|
|
|
if node in nodes1: # 删除nodes1中当期遍历的节点信息
|
|
|
nodes1.remove(node)
|
|
|
for node1 in nodes1: # 遍历删除后的节点信息
|
|
|
# Edges[] = { < 连接序号，节点对象1编号，节点对象2编号，链接是否可用（序号大于1），连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
n1 = node[0] # 节点对象编号1
|
|
|
n2 = node1[0] # 节点对象编号2
|
|
|
seq = 1 # 链接序号
|
|
|
mark = False # 连接是否标记
|
|
|
tag = f"{n1+1}-{n2+1}" # 链接标签
|
|
|
dist_c = random.randint(10, 120) # 随机生成距离成本
|
|
|
time_c = random.randint(10, 120) # 随机生成链接的时间
|
|
|
enable = 1 # 连接是否可用
|
|
|
if dist_c >= 100 or time_c >= 100: # 设置某些节点为不显示
|
|
|
enable = 0
|
|
|
edges.append([ser, n1, n2, enable, mark, tag, dist_c, time_c, seq]) # 将连接加入到边的集合中
|
|
|
ser+=1# 计数加一
|
|
|
return edges
|
|
|
|
|
|
def node_count(self, node_num:tuple, node_co:list):
|
|
|
for node in node_num:
|
|
|
node_co.append(node)
|
|
|
|
|
|
|
|
|
def path_creat(self):
|
|
|
node_co = {} # 节点统计，
|
|
|
for node in self.Nodes:
|
|
|
node_co[node[0]] = 0
|
|
|
print(node_co)
|
|
|
|
|
|
for edge in self.Edges:
|
|
|
for num in node_co.keys():
|
|
|
if node_co[num] <=1:
|
|
|
if edge[1] == num or edge[2]== num:
|
|
|
node_co[num]+=1
|
|
|
print((edge[1],edge[2]))
|
|
|
print(node_co) # 每个节点出现的次数
|
|
|
|
|
|
def node_co(self,key): # 通过节点编号返回编号的坐标
|
|
|
"""通过节点编号返回编号的坐标"""
|
|
|
nodes = self.Nodes
|
|
|
for n in nodes:
|
|
|
if n[0] == key:
|
|
|
return n[3]
|
|
|
|
|
|
def edge_add(self, no):
|
|
|
nodes = self.Nodes.copy() # 复制节点对象
|
|
|
nodes1 = self.Nodes.copy() # 复制节点对象
|
|
|
for node in nodes: # 遍历节点对象
|
|
|
if node in nodes1: # 删除nodes1中当期遍历的节点信息
|
|
|
nodes1.remove(node)
|
|
|
|
|
|
for node1 in nodes1: # 遍历删除后的节点信息
|
|
|
# Edges[] = { < 连接序号，节点对象1编号，节点对象2编号，链接是否显示（序号大于1），连接是否标记，连接标签，连接的距离 / 成本，连接的时间，连接序号 >}
|
|
|
ser = len(self.Edges) # 链接序号
|
|
|
n1 = node[0] # 节点对象编号1
|
|
|
n2 = node1[0] # 节点对象编号2
|
|
|
show = 0
|
|
|
mark = False # 连接是否标记
|
|
|
tag = f"{n1 + 1}-{n2 + 1}-{no}" # 链接标签
|
|
|
dist_c = random.randint(30, 100) # 距离成本
|
|
|
time_c = random.randint(1, 30) # 链接的时间
|
|
|
enable = no # 连接是否可用
|
|
|
self.Edges.append([ser, n1, n2, show, mark, tag, dist_c, time_c, enable])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
|
|
d = Data(1, 5)
|
|
|
d.path_creat()
|
|
|
|
|
|
#print(d.Edges)
|
|
|
|
