def run_force_test(double_r,steps):
time_logo=0
Data.PEOPLE_FORCE=50
Data.FX_S_SIGMA_2=double_r
Data.FX_S_R = 2 * np.sqrt(Data.FX_S_SIGMA_2)
Data.FX_S_P = 2 * Data.FX_S_SIGMA_2
allPeople = InitPeolple.creatPeople() # 产生随机行人
# allPeople=InitPeolple.creatAppointPeo()#产生指定行人
# allPeople=InitPeolple.creatAreaPeople()
# print(len(allPeople))
# allWall = InitPeolple.creatWall() # 创建墙壁
# allExit = InitPeolple.creatExit() # 创建出口
# DrawFirst.drawPeople(allPeople)
while Data.flag:#循环开始
for p in allPeople:#遍历行人
Income.outDirection(p, allPeople)#计算收益
direction = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]#获取方向
Rule.chickOverAround(p, allPeople)#检测是否到达出口
Rule.PeopleMove(p, direction)#行人移动
# DrawFirst.drawPeople(allPeople)
time_logo = time_logo + 1
# print(time_logo,"\033[4;32;40mxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\033[0m")
if len(allPeople)==0:
Data.flag=False
allData=[]
allData.append(double_r)
allData.append(steps)
allData.append(time_logo)
return allData
def run_view():
evac_time = 0 #疏散时间
Data.FX_R = 6
Data.FX_P = math.pow(6, 2) / 2
result_speed = []
allPeople = InitPeolple.creatPeople()
DrawFirst.drawPeople(allPeople)
while Data.flag: #循环开始
move_on = 0
move_all = 0
for p in allPeople: #遍历行人
Income.outDirection(p, allPeople) #计算收益
direction = max(p.allInComeBySort.items(),
key=lambda x: x[1])[0] #获取方向
if direction != 5:
move_on = move_on + 1
move_all = move_all + 1
Rule.PeopleMove(p, direction) # 行人移动
Rule.chickOverAround(p, allPeople) #检测是否到达出口
DrawFirst.drawPeople(allPeople)
speed = move_on / move_all
result_speed.append(speed)
evac_time = evac_time + 1 #疏散时间+1
if evac_time == 15:
Data.flag = False
print('当前时间步：', evac_time)
print(result_speed)
def run_f():
allPeople = InitPeople.creatAppointPeo()
while Data.flag:
for p in allPeople:
direction = 6
Rule.PeopleMove(p, direction)
DrawFirst.drawPeople(allPeople)
def run_view():
plt.figure(figsize=(6, 6))
evacuation_time = 0 # 疏散时间步 计时器
time_after_step = -5 # 获取行人前5个时间步的方向
allPeople = InitialPedestrian.creatPeople()
# allPeople = InitialPedestrian.creatAppointPeo() # 初始化行人--初始化指定行人 便于调试
DrawFirst.draw_main(allPeople) # 绘制行人和地图
while Data.FLAG: # 循环标识符
for p in allPeople: # 遍历每个行人
Rule.chickInExit(p, allPeople)
direcetion = InCome.addAllIncome(p, allPeople) # 计算每个行人的移动方向
p.after_direction = direcetion
Rule.PeopleMove(p, allPeople, direcetion) # 行人移动
p.position_dic.append([p.x, p.y]) # 将行人所有位置存入列表
if time_after_step > 0:
p.position_dic.pop(0)
DrawFirst.draw_main(allPeople) # 更新图像
'''程序终止检测'''
if len(allPeople) == 0: # 如果行人都出去了
Data.FLAG = False # 更改循环标识符
# if evacuation_time > 5:
# Data.FLAG = False
evacuation_time += 1 # 疏散时间步 计时器+1
time_after_step += 1
# print('当前时间步:', evacuation_time) # 输出信息
# plt.close()
print(evacuation_time)
def run_view():
'''此方法为单步运行测试方法，带图像显示'''
time_logo = 0
# allPeople = InitPeolple.creatPeople() # 产生随机行人
# allPeople=InitPeolple.creatPeople_force_normal()
# allPeople=InitPeolple.creatPeople_force_fix()
allPeople = InitPeolple.creatPeople_force_random()
# allPeople=InitPeolple.creatAppointPeo()#产生指定行人
# allPeople=InitPeolple.creatAreaPeople()
# print(len(allPeople))
# allWall = InitPeolple.creatWall() # 创建墙壁
# allExit = InitPeolple.creatExit() # 创建出口
DrawFirst.drawPeople(allPeople)
while Data.flag: #循环开始
if Data.FX_S_R < 21:
count_R_O_V(time_logo)
for p in allPeople: #遍历行人
Income.outDirection(p, allPeople) #计算收益
direction = max(p.allInComeBySort.items(),
key=lambda x: x[1])[0] #获取方向
Rule.chickOverAround(p, allPeople) #检测是否到达出口
Rule.PeopleMove(p, direction) #行人移动
DrawFirst.drawPeople(allPeople)
time_logo = time_logo + 1
print(
time_logo,
"\033[4;32;40mxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\033[0m"
)
def run_view():
'''此方法为单步运行测试方法，带图像显示'''
time_logo=0
Data.FX_R = 8
Data.FX_P = math.pow(Data.FX_R, 2) / 2
Data.FX_S_V = 0
Data.FX_S_R = 15
# allPeople = InitPeolple.creatPeople() # 产生随机行人
# allPeople=InitPeolple.creatPeople_force_normal()
allPeople=InitPeolple.creatPeople_force_fix()
# allPeople=InitPeolple.creatPeople_force_random()
# allPeople=InitPeolple.creatAppointPeo()#产生指定行人
# allPeople=InitPeolple.creatAreaPeople()
# print(len(allPeople))
# allWall = InitPeolple.creatWall() # 创建墙壁
# allExit = InitPeolple.creatExit() # 创建出口
DrawFirst.drawPeople(allPeople)
# time.sleep(100)
result_time=[]
result_rote=[]
result_all=[]
while Data.flag:#循环开始
if Data.FX_S_R<21:
count_R_O_V()
for p in allPeople:#遍历行人
Income.outDirection(p, allPeople)#计算收益
direction = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]#获取方向
Rule.chickOverAround(p, allPeople)#检测是否到达出口
Rule.PeopleMove(p, direction)#行人移动
a_p=0
b_p = 0
for p in allPeople:
if Data.FX_R**2<((p.x-Data.FX_M)**2 +(p.x-Data.FX_M)**2)<Data.FX_S_R**2:
a_p=a_p+1
if p.isInGrend==2:
b_p=b_p+1
result_time.append(time_logo)
if a_p==0:
result_rote.append(0)
else:
result_rote.append(b_p/a_p)
DrawFirst.drawPeople(allPeople)
time_logo = time_logo + 1
# print(time_logo,"\033[4;32;40mxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\033[0m")
# if time_logo==15:
# Data.flag=False
print(time_logo)
result_all.append(result_time)
result_all.append(result_rote)
print(result_all)
def run_insert(case_s, density, radius, radius_ob, radius_v, force, force_type,
peo_view, steps):
'''此方法为运行方法，带参数接受和返回，不带图像显示'''
Data.flag = True
time_logo = 0
if case_s == 0: #危险源位置设置
Data.FX_N = 19
elif case_s == 1:
Data.FX_N = 15
elif case_s == 2:
Data.FX_N = 10
elif case_s == 3:
Data.FX_N = 5
elif case_s == 4:
Data.FX_N = 2
Data.PEOPLE_DENSYTY = density
Data.PEOPLE_NUMBER = Data.count_PEOPLE_NUMBER(density)
Data.FX_SIGMA_2 = radius # 危险源大小
Data.FX_R = Data.count_FX_R(radius) # 影响范围半径
Data.FX_P = Data.count_FX_P(radius) # 系数 p越大 高斯函数的圆形越大
Data.FX_S_SIGMA_2 = radius_ob
Data.FX_S_R = Data.count_FX_S_R(radius_ob)
Data.FX_S_P = Data.count_FX_S_P(radius_ob)
Data.FX_S_V = radius_v
Data.PEOPLE_FORCE = force
if force_type == 0: # fix
allPeople = InitPeolple.creatPeople_force_fix()
else: #random
allPeople = InitPeolple.creatPeople_force_random()
Data.PEOPLE_FAN_R = peo_view
while Data.flag: #循环开始
if Data.FX_S_R < 21:
count_R_O_V(time_logo)
for p in allPeople: #遍历行人
Income.outDirection(p, allPeople) #计算收益
direction = max(p.allInComeBySort.items(),
key=lambda x: x[1])[0] #获取方向
Rule.chickOverAround(p, allPeople) #检测是否到达出口
Rule.PeopleMove(p, direction) #行人移动
if len(allPeople) == 0:
Data.flag = False
time_logo = time_logo + 1
# print(time_logo)
# print("\033[4;32;40mxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\033[0m")
return time_logo
def run_insert(par_density,par_case,par_r_c,par_r_o,par_v,par_force):
'''此方法为运行方法，带参数接受和返回，不带图像显示'''
Data.flag=True
time_logo=0
if par_case==1:#危险源位置设置
Data.FX_N=19
elif par_case==2:
Data.FX_N = 15
elif par_case==3:
Data.FX_N = 10
Data.PEOPLE_DENSYTY=par_density
Data.PEOPLE_NUMBER=int(Data.ROOM_N * Data.ROOM_M * par_density)
Data.FX_R =par_r_c # 影响范围半径
Data.FX_P = math.pow(par_r_c, 2) / 2 # 系数 p越大 高斯函数的圆形越大
Data.FX_S_R=par_r_o
Data.FX_S_P=math.pow(par_r_o, 2) / 2
Data.FX_S_V=par_v
Data.PEOPLE_FORCE=par_force
allPeople = InitPeolple.creatPeople_force_fix()
result_time = []
result_rote = []
result_all = []
while Data.flag:#循环开始
if Data.FX_S_R<21:
count_R_O_V()
for p in allPeople:#遍历行人
Income.outDirection(p, allPeople)#计算收益
direction = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]#获取方向
Rule.chickOverAround(p, allPeople)#检测是否到达出口
Rule.PeopleMove(p, direction)#行人移动
if len(allPeople)==0:
Data.flag=False
a_p = 0
b_p = 0
for p in allPeople:
if Data.FX_R ** 2 < ((p.x - Data.FX_M) ** 2 + (p.x - Data.FX_M) ** 2) < Data.FX_S_R ** 2:
a_p = a_p + 1
if p.isInGrend == 2:
b_p = b_p + 1
result_time.append(time_logo)
if a_p == 0:
result_rote.append(0)
else:
result_rote.append(b_p / a_p)
time_logo = time_logo + 1
result_all.append(result_time)
result_all.append(result_rote)
return result_all
def run_insert(par_case, par_density, par_radius):
Data.flag = True
evac_time = 0 #疏散时间
if par_case == 1:
Data.FX_N = 19
elif par_case == 2:
Data.FX_N = 15
else:
Data.FX_N = 10
Data.PEOPLE_DENSYTY = par_density
Data.PEOPLE_NUMBER = int(Data.ROOM_N * Data.ROOM_M * par_density)
Data.FX_R = par_radius
Data.FX_P = math.pow(par_radius, 2) / 2
result_all = []
result_speed = []
result_time = []
allPeople = InitPeolple.creatPeople()
while Data.flag: #循环开始
move_on = 0
move_all = 0
for p in allPeople: #遍历行人
Income.outDirection(p, allPeople) #计算收益
direction = max(p.allInComeBySort.items(),
key=lambda x: x[1])[0] #获取方向
if direction != 5:
move_on = move_on + 1
move_all = move_all + 1
Rule.PeopleMove(p, direction) # 行人移动
Rule.chickOverAround(p, allPeople) #检测是否到达出口
if len(allPeople) == 0:
Data.flag = False
speed = move_on / move_all
result_speed.append(speed)
result_time.append(evac_time, )
evac_time = evac_time + 1 #疏散时间+1
result_all.append(result_time)
result_all.append(result_speed)
return result_all
def run_insert_old(case_s,P,R,steps):
resultData=[]#返回总列表
if case_s==0:#危险源位置设置
Data.FX_N=19
elif case_s==1:
Data.FX_N = 15
elif case_s==2:
Data.FX_N = 10
elif case_s==3:
Data.FX_N = 5
elif case_s==4:
Data.FX_N = 2
Data.PEOPLE_DENSYTY=P#行人密度
Data.PEOPLE_NUMBER=int(Data.ROOM_N*Data.ROOM_M*Data.PEOPLE_DENSYTY)#行人数量
Data.FX_SIGMA_2=R#危险源大小
Data.FX_R = 2 * np.sqrt(Data.FX_SIGMA_2) # 影响范围半径
Data.FX_P = 2 * Data.FX_SIGMA_2 # 系数 p越大 高斯函数的圆形越大
# init = InitPeolple.InitPeople()#实例化 产生行人类
# draw = DrawFirst.draw()#实例化 画图类
# income = Income.outDirection()
allPeople = InitPeolple.creatPeople()#产生随机行人
# allPeople=init.creatAppointPeo()#产生指定行人
allWall = InitPeolple.creatWall()#创建墙壁
allExit = InitPeolple.creatExit()#创建出口
T=[]#疏散时间
S=[]#剩余行人
V=[]#行人速度
Q=[]#出口流量
Q.append(0)#将出口流量[0]设为0 Q列表少一个数
evac_time = 0#疏散时间
while Data.flag:#循环开始
move_on_num = 0#本次时间步移动的行人
move_off_num = 0#本次时间步静止的行人
vector = 0#本次时间步行人速度
for p in allPeople:#遍历行人
Income.outDirection(p, allPeople)#计算收益
direction = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]#获取方向
if direction==5:#如果行人静止
move_off_num=move_off_num+1#计数器+1
else:
move_on_num=move_on_num+1#计数器+1
Rule.chickOverAround(p, allPeople)#检测是否到达出口
Rule.PeopleMove(p, direction)#行人移动
# draw.drawPeople(allPeople)#绘制行人
# print(evac_time,"---",len(allPeople),"---",move_on_num/len(allPeople))
if len(allPeople)==0:#如果行人全部疏散完毕
vector=1#速度设为1
Data.flag=False#循环标志--停止
else:
vector=move_on_num/len(allPeople)#行人速度=移动的行人/总行人
if vector>1:#如果行人速度>1
vector=1.0#设置为1
T.append(evac_time)#将疏散时间添加到T
S.append(len(allPeople))#将剩余行人添加到S
V.append(vector)#将行人速度添加到V
evac_time=evac_time+1#疏散时间+1
for i in range(len(S) - 1):#遍历行人
quar = S[i] - S[i + 1]#出口流量=上一步的行人总数-下一步的行人总数
Q.append(quar)#将出口流量添加到Q
'''将各种参数添加到返回列表'''
resultData.append(case_s)
resultData.append(P)
resultData.append(R)
resultData.append(steps)
resultData.append(T)
resultData.append(S)
resultData.append(V)
resultData.append(Q)
return resultData
def run_f(case_s, location):
'''此方法为运行方法，带相关参数的接受和返回'''
'-----------------------初始设置(行人、静态场)-----------------------------'
allPeople = InitPeople.creatAppointPeo() #初始化行人
# allPeople=InitPeople.creatOnePeople()
allTable = InitPeople.creatTable() #初始化障碍物
if case_s == 0:
Data.STATIC_FIELD = Data.STATIC_FIELD1() # 静态场的植入
elif case_s == 1:
Data.STATIC_FIELD = Data.STATIC_FIELD2() # 静态场的植入
'-------------------------------------------------------------------------'
# resultData=[] #返回总列表
# T=[] #时间
# V=[] #速度
# Q=[] #出口流量
# S=[] #行人速度
# Q.append(0)
evac_time = 0 #疏散时间
while Data.flag: #循环开始
# locomotive_num=0#本次时间步移动的人
# static_num=0 #本次时间步静止的人
# vector=0 #本次时间步行人速度
random.shuffle(allPeople)
for p in allPeople:
d = 0
# if p.dbg==1:
# d = Rule.bottomMove2(p, d, allPeople)
# else:
if location == 0:
InCome.PeopleInCome(p, allPeople, allTable)
d = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]
elif location == 1:
if p.y < 22:
d = Rule.bottomMove(p, d, allPeople)
else:
InCome.PeopleInCome(p, allPeople, allTable)
d = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]
# if d==5:
# static_num=static_num+1
# else:
# locomotive_num=locomotive_num+1
# if Rule.checkoutPeople(p):
'--------------------------------行人移动规则---------------------------------------'
Rule.peopleGatherMove(p, d, allPeople) # 挤压
Rule.peopleScatterMove(p, d, allPeople) #挤压消除
Rule.PeopleMove(p, d) #普通
Rule.checkoutPeople(p, allPeople) #移出系统
# direction = max(p.allIncomeBySort.items(), key=lambda x: x[1])[0]
# Rule.checkoutPeople(p,allPeople)
# direction=8
# Rule.PeopleMove(p,direction)
# print(p.allIncomeBySort)
# print(qq)
evac_time = evac_time + 1 # 疏散时间更新
'---------------------------图像和即时数据-----------------------------------'
DrawFirst.drawPeople(allPeople, allTable)
print(len(allPeople))
if len(allPeople) == 0:
# vector=1
Data.flag = False
# else:
# vector=locomotive_num/len(allPeople)
# if vector>1:
# vector=1.0
#
# T.append(evac_time)#将疏散时间添加到T
# S.append(len(allPeople))#将剩余行人添加到S
# V.append(vector)#将行人速度添加到V
# for i in range(len(S) - 1):#遍历行人
# quar = S[i] - S[i + 1]#出口流量=上一步的行人总数-下一步的行人总数
# Q.append(quar)#将出口流量添加到Q
'''将各种参数返回列表'''
return evac_time
allWall = init.creatWall()
allExit = init.creatExit()
# while Data.flag:
# for p in allPeople:
# income.outDirection(p,allPeople)
# direction=max(p.allInComeBySort.items(),key=lambda x:x[1])[0]
# print('direction ==',direction)
while Data.flag:
for p in allPeople:
income.outDirection(p, allPeople)
direction = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]
Rule.chickOverAround(p, allPeople)
Rule.PeopleMove(p, direction)
# print(p.grendIncome)
# print(p.isInGrend)
print(p.allInComeBySort)
draw.DrawPeople(allPeople)
# for p in allPeople:
# defineDirection.countDefine(p)
# isCrash.isNextNull(p, allPeople)
# print(p.nextNull)
# move.moveRight(p)
# # if not p.type:
# plt.figure(figsize=(10,6))
# while Data.flag:
# for p in allPeople:
# defineDirection.countDefine(p)
import Data, InitPeolple, DrawFirst, Rule, Income
import matplotlib.pyplot as plt
import matplotlib.animation
import numpy as np
import time
init = InitPeolple.InitPeople()
draw = DrawFirst.draw()
move = Rule.PeopleMove()
income = Income.outDirection()
# allPeople=init.creatPeople()
allPeople = init.creatAppointPeo()
allWall = init.creatWall()
allExit = init.creatExit()
# while Data.flag:
for p in allPeople:
income.outDirection(p, allPeople)
direction = max(p.allInComeBySort.items(), key=lambda x: x[1])[0]
print('direction ==', direction)
# for p in allPeople:
# defineDirection.countDefine(p)
# isCrash.isNextNull(p, allPeople)
# print(p.nextNull)
# move.moveRight(p)
# # if not p.type:
# plt.figure(figsize=(10,6))
# while Data.flag:
# for p in allPeople:
# defineDirection.countDefine(p)
