def getCollisions(self):
"""
Function to check if the kuche collides with one of the players or the boundaries
"""
new_pos = self.kuchen.get_pos()
self.kuchen_collision = "none"
if (self.status[0:2] == "P1"):
self.status, self.kuchen_collision = check_collision(
self.kuchen, self.player2, self.status)
elif (self.status[0:2] == "P2"):
self.status, self.kuchen_collision = check_collision(
self.kuchen, self.player1, self.status)
if self.status != "P1_Hit" and self.status != "P2_Hit":
self.status, self.kuchen_collision = check_collision_boundaries(
self.kuchen, 0, 0, self.MAX_X, self.MAX_Y, self.status)
else:
if (self.status == "P1_Hit"):
self.score = (self.score[0] + 1, self.score[1])
elif (self.status == "P2_Hit"):
self.score = (self.score[0], self.score[1] + 1)
if (self.status[2:] == "_Hit") or (self.status[2:] == "_Missed"):
#self.kuchen.load_image_play("kuchen_splash_down.png", -1)
self.manageKuchen()
self.txtStatus.set_value(self.status)
return new_pos
def getCollisions(self):
new_pos = self.kuchen.get_pos()
if (self.status[0:2] == "P1"):
self.status = check_collision(self.kuchen, self.player2,
self.status)
elif (self.status[0:2] == "P2"):
self.status = check_collision(self.kuchen, self.player1,
self.status)
if self.status != "P1_Hit" and self.status != "P2_Hit":
self.status = check_collision_boundaries(self.kuchen, 0, 0,
self.MAX_X, self.MAX_Y,
self.status)
return new_pos
def getCollisions(self):
new_pos = self.Kuchen.update()
if (self.gameStatus[0:2] == "P1"):
self.gameStatus = check_collision(self.Kuchen, self.Player2,
self.gameStatus)
elif (self.gameStatus[0:2] == "P2"):
self.gameStatus = check_collision(self.Kuchen, self.Player1,
self.gameStatus)
if self.gameStatus != "P1_Hit" and self.gameStatus != "P2_Hit":
self.gameStatus = check_collision_boundaries(
self.Kuchen, 0, 0, self.screen_width, self.screen_height,
self.gameStatus)
return new_pos
def update():
gfw.world.update()
generator.update()
# if not gfw.world.count_at(gfw.layer.enemy) == 0:
# for n in gfw.world.objects_at(gfw.layer.enemy):
# print(n)
collision.check_collision()
score.update()
#print(gfw.world.count_at(gfw.layer.enemy))
pattern.update()
stage_gen.update()
def update(self, dt, keys):
# update all monsters
for monster in self.monsters:
monster.update(dt, self.layer.tiles)
# update player
self.update_player(dt, keys)
# check if monsters collides with player
for monster in self.monsters:
if collision.check_collision(self.player, monster):
self.sm.change_state( states.GameoverState() )
return
# is level end reached?
if collision.check_collision(self.player, self.goal):
self.sm.change_state( game.LevelCompletedState() )
return
def check_collisions(source, objects):
# if bullet is active
if source.active:
# go through all monsters
for obj in objects:
# check if bullet hits active monster
if obj.active and collision.check_collision(source.sprite, obj):
# deactivate monster and bullet
obj.deactivate()
source.deactivate()
# massive explosion...
# explosion.create(obj.x, obj.y)
return
def update():
global state, score
if state != STATE_IN_GAME:
return
score += gfw.delta_time
gfw.world.update()
generator.update(score)
dead, full = check_collision()
if dead:
end_game()
if full:
score += 5
def display_map(self):
pos = self.p.get_positions()
sprite = self.p.get_animation("Down")
img = self.images.get("in_game")
p_health = self.p.get_player_info("Health")
max_health = self.p.get_player_info("MaxHealth")
pos, sprite = movement.check_movement(self)
pos = collision.check_collision(self, pos)
self.p.change_positions(pos[0], pos[1])
self.window.blit(img.get("map"), (0 - pos[0], 0 - pos[1]))
for i in self.mobs:
anim = i.get_animation("Down")
self.window.blit(anim[1], (i.pos[0] - pos[0], i.pos[1] - pos[1]))
self.window.blit(img.get("empty_bar"), (1110, 760), (0, 0, 100, 25))
self.window.blit(img.get("heal_bar"), (1110, 760),
(0, 0, floor(p_health / max_health * 100), 25))
self.window.blit(sprite[self.index_animation], (620, 400))
def resolve_collision(self, entity, elapsed_time):
neighbors = []
self.quadtree.retrieve(neighbors, entity)
for neighbor in neighbors:
if entity != neighbor:
mtv = collision.check_collision(entity, neighbor, self)
if mtv is not False:
if entity.move_component is not None:
entity.move_component.vel *= 0
entity.pos[0] -= mtv[0]
entity.pos[1] -= mtv[1]
if neighbor.move_component is not None:
neighbor.move_component.vel *= 0
neighbor.pos[0] += mtv[0]
neighbor.pos[1] += mtv[1]
def main():
desc = "Keras implementation of DCENet for trajectory prediction"
parser = argparse.ArgumentParser(description=desc)
parser.add_argument(
'--num_pred',
type=int,
default=25,
help='This is the number of predictions for each agent')
parser.add_argument('--obs_seq',
type=int,
default=8,
help='Number of time steps observed')
parser.add_argument('--enviro_pdim',
type=int,
default=[32, 32, 3],
help='The dimension of the environment after padding')
parser.add_argument('--pred_seq',
type=int,
default=12,
help='Number of time steps to be predicted')
parser.add_argument('--dist_thre',
type=float,
default=1.0,
help='The distance threhold for group detection')
parser.add_argument(
'--ratio',
type=float,
default=0.95,
help='The overlap ratio of coexisting for group detection')
parser.add_argument('--n_hidden',
type=int,
default=512,
help='This is the hidden size of the cvae')
parser.add_argument('--z_dim',
type=int,
default=2,
help='This is the size of the latent variable')
parser.add_argument(
'--encoder_dim',
type=int,
default=16,
help='This is the size of the encoder output dimension')
parser.add_argument('--z_decoder_dim',
type=int,
default=64,
help='This is the size of the decoder LSTM dimension')
parser.add_argument('--hidden_size',
type=int,
default=32,
help='The size of LSTM hidden state')
parser.add_argument('--batch_size',
type=int,
default=192,
help='Batch size') # 192
parser.add_argument('--o_drop',
type=float,
default=0.2,
help='The dropout rate for occupancy') # 0.2
parser.add_argument('--s_drop',
type=float,
default=0.1,
help='The dropout rate for trajectory sequence') # 0.1
parser.add_argument('--z_drop',
type=float,
default=0.15,
help='The dropout rate for z input') # 0.15
parser.add_argument('--beta', type=float, default=0.65,
help='Loss weight') # 0.75#0.65
parser.add_argument('--query_dim',
type=int,
default=4,
help='The dimension of the query')
parser.add_argument('--keyvalue_dim',
type=int,
default=4,
help='The dimension for key and value')
parser.add_argument('--train_mode',
type=bool,
default=True,
help='This is the training mode')
parser.add_argument('--train_set',
type=str,
choices=['Train'],
default='Train',
help='This is the directories for the training data')
parser.add_argument('--challenge_set',
type=str,
choices=['Test'],
default='Test',
help='This is the directories for the challenge data'
) # it is the online test set
parser.add_argument('--split',
type=float,
default=0.8,
help='the split rate for training and validation')
parser.add_argument('--lr', type=float, default=3e-5,
help='Learning rate') # 3-5
parser.add_argument('--aug_num',
type=int,
default=4,
help='Number of augmentations')
parser.add_argument('--epochs',
type=int,
default=100,
help='Number of batches')
parser.add_argument(
'--patience',
type=int,
default=5,
help='Maximum mumber of continuous epochs without converging')
parser.add_argument('--x_encoder_dim',
type=int,
default=64,
help='Mapping dimension of x_encoder')
parser.add_argument('--y_encoder_dim',
type=int,
default=64,
help='Mapping dimension of y_encoder')
parser.add_argument(
'--x_encoder_layers',
type=int,
default=3,
help='Number of transformer block layers for x_encoder')
parser.add_argument('--y_encoder_layers',
type=int,
default=3,
help='Number of transformer block layer for y_encoder')
parser.add_argument('--x_encoder_head',
type=int,
default=8,
help='Head number of x_encoder')
parser.add_argument('--y_encoder_head',
type=int,
default=8,
help='Head number of y_encoder')
parser.add_argument('--occu_encoder_x_dim',
type=int,
default=32,
help='Mapping dimension of the x occupancy encoder')
parser.add_argument('--occu_encoder_y_dim',
type=int,
default=32,
help='Mapping dimension of the y occupancy encoder')
parser.add_argument(
'--occu_encoder_x_layers',
type=int,
default=3,
help='Number of transformer block layers for x_encoder')
parser.add_argument('--occu_encoder_y_layers',
type=int,
default=3,
help='Number of transformer block layer for y_encoder')
parser.add_argument('--occu_encoder_x_head',
type=int,
default=2,
help='Head number of x_encoder')
parser.add_argument('--occu_encoder_y_head',
type=int,
default=2,
help='Head number of y_encoder')
parser.add_argument('--preprocess_data',
type=bool,
default=False,
help='Process and merge dataset')
args = parser.parse_args(sys.argv[1:])
# Make all the necessary folders
mak_dir()
# # specify the directory for training and challenge data
train_paths = sorted(
glob.glob("../WORLD H-H TRAJ/%s/**/*.txt" % (args.train_set)))
# # NOTE, here the challenge set is the "ONLINE" test set
# # This is different from the "OFFLINE" test set
# ToDo chenge this to make compatible with linus
challenge_paths = sorted(
glob.glob("../WORLD H-H TRAJ/%s/**/*.txt" % (args.challenge_set)))
# challenge_paths = sorted(glob.glob("../trajectories/%s/**/*.txt"%(args.challenge_set)))
# Process the data
for path in train_paths:
dataname = os.path.splitext(os.path.basename(path))[0]
if not os.path.exists("../processed_data/train/%s.npz" % dataname):
# preprocess_data(path, args.obs_seq+args.pred_seq-1, args.enviro_pdim, "train")
preprocess_data(seq_length=args.obs_seq + args.pred_seq - 1,
size=args.enviro_pdim,
dirname="train",
path=path,
aug_num=args.aug_num,
save=True)
for path in challenge_paths:
# dataname = path.split('\\')[-1].split('.')[0]
dataname = os.path.splitext(os.path.basename(path))[0]
if not os.path.exists("../processed_data/challenge/%s.npz" % dataname):
# preprocess_data(path, args.obs_seq-1, args.enviro_pdim, "challenge")
preprocess_data(seq_length=args.obs_seq - 1,
size=args.enviro_pdim,
dirname="challenge",
path=path,
save=True)
# Check the daatinfo for dataset partition
Datalist = datainfo()
# Datalist = datainfo(4)
# Define the callback and early stop
timestr = time.strftime("%Y%m%d-%H%M%S")
filepath = "../models/DCENet_%0.f_%s.hdf5" % (args.epochs, timestr)
## Eraly stop
# reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=100, mode='auto')
earlystop = EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=args.patience)
checkpoint = ModelCheckpoint(filepath,
monitor='val_loss',
verbose=0,
save_best_only=True,
mode='min')
callbacks_list = [earlystop, checkpoint]
# # Instantiate the model
DCENet = dcenet(args)
# Contruct the cave model
train = DCENet.training()
train.summary()
x_encoder = DCENet.X_encoder()
decoder = DCENet.Decoder()
# sys.exit()
# Start training phase
if args.train_mode:
if args.preprocess_data:
traindata_list = Datalist.train_data
else:
traindata_list = Datalist.train_merged
print("train data list", traindata_list)
# # NOTE: this is the "OFFLINE" test set. This is only used to plot if the prediction is feasible
# # This test set has nothing to do with the challenge data set ("ONLINE" test set)
testdata_list = Datalist.train_biwi
print("test data list", testdata_list)
# Get the data fro training and validation
np.random.seed(10)
offsets, traj_data, occupancy = loaddata(traindata_list,
args,
datatype="train")
train_val_split = np.random.rand(len(offsets)) < args.split
train_x = offsets[train_val_split, :args.obs_seq - 1, 4:6]
train_occu = occupancy[train_val_split, :args.obs_seq - 1,
..., :args.enviro_pdim[-1]]
train_y = offsets[train_val_split, args.obs_seq - 1:, 4:6]
train_y_occu = occupancy[train_val_split, args.obs_seq - 1:,
..., :args.enviro_pdim[-1]]
val_x = offsets[~train_val_split, :args.obs_seq - 1, 4:6]
val_occu = occupancy[~train_val_split, :args.obs_seq - 1,
..., :args.enviro_pdim[-1]]
val_y = offsets[~train_val_split, args.obs_seq - 1:, 4:6]
val_y_occu = occupancy[~train_val_split, args.obs_seq - 1:,
..., :args.enviro_pdim[-1]]
print(
"%.0f trajectories for training\n %.0f trajectories for valiadation"
% (train_x.shape[0], val_x.shape[0]))
test_offsets, test_trajs, test_occupancy = loaddata(testdata_list,
args,
datatype="test")
test_x = test_offsets[:, :args.obs_seq - 1, 4:6]
test_occu = test_occupancy[:, :args.obs_seq - 1,
..., :args.enviro_pdim[-1]]
last_obs_test = test_offsets[:, args.obs_seq - 2, 2:4]
y_truth = test_offsets[:, args.obs_seq - 1:, :4]
xy_truth = test_offsets[:, :, :4]
print("%.0f trajectories for testing" % (test_x.shape[0]))
print("Start training the model...")
# Retrain from last time
# train.load_weights("../models/best.hdf5")
train.fit(x=[train_occu, train_x, train_y_occu, train_y],
y=train_y,
shuffle=True,
epochs=args.epochs,
batch_size=args.batch_size,
verbose=1,
callbacks=callbacks_list,
validation_data=([val_occu, val_x, val_y_occu,
val_y], val_y))
train.load_weights(filepath)
# Start inference phase
# Retrieve the x_encoder and the decoder
x_encoder = DCENet.X_encoder()
decoder = DCENet.Decoder()
x_encoder.summary()
decoder.summary()
# get the x_encoded_dense as latent feature for prediction
x_latent = x_encoder.predict([test_occu, test_x],
batch_size=args.batch_size)
# x_latent = x_encoder.predict(test_x, batch_size=args.batch_size)
# Using x_latent and z as input of the decoder for generating future trajectories
print("Start predicting")
predictions = []
for i, x_ in enumerate(x_latent):
last_pos = last_obs_test[i]
x_ = np.reshape(x_, [1, -1])
for i in range(args.num_pred):
# sampling z from a normal distribution
z_sample = np.random.rand(1, args.z_dim)
y_p = decoder.predict(np.column_stack([z_sample, x_]))
y_p_ = np.concatenate(([last_pos], np.squeeze(y_p)), axis=0)
y_p_sum = np.cumsum(y_p_, axis=0)
predictions.append(y_p_sum[1:, :])
predictions = np.reshape(predictions,
[-1, args.num_pred, args.pred_seq, 2])
print('Predicting done!')
print(predictions.shape)
plot_pred(xy_truth, predictions)
# Get the errors for ADE, DEF, Hausdorff distance, speed deviation, heading error
print("\nEvaluation results @top%.0f" % args.num_pred)
errors = get_errors(y_truth, predictions)
check_collision(y_truth)
##
## Get the first time prediction by g
ranked_prediction = []
for prediction in predictions:
ranks = gauss_rank(prediction)
ranked_prediction.append(prediction[np.argmax(ranks)])
ranked_prediction = np.reshape(ranked_prediction,
[-1, 1, args.pred_seq, 2])
print("\nEvaluation results for most-likely predictions")
# ranked_errors = get_errors(y_truth, ranked_prediction)
else:
print('Run pretrained model')
train.load_weights("../models/best.hdf5")
challenge_list = Datalist.challenge_data
for challenge_dataname in challenge_list:
print(challenge_dataname, "\n")
challenge_offsets, challenge_trajs, challenge_occupancy = loaddata(
[challenge_dataname], args, datatype="challenge")
print(challenge_offsets.shape, challenge_trajs.shape,
challenge_occupancy.shape)
challenge_x = challenge_offsets[:, :args.obs_seq - 1, 4:6]
challenge_occu = challenge_occupancy[:, :args.obs_seq - 1,
..., :args.enviro_pdim[-1]]
last_obs_challenge = challenge_trajs[:, args.obs_seq - 1, 2:4]
print("%.0f trajectories for challenge" % (challenge_x.shape[0]))
# Start inference phase
# Retrieve the x_encoder and the decoder
x_encoder = DCENet.X_encoder()
decoder = DCENet.Decoder()
# get the x_encoded_dense as latent feature for prediction
x_latent = x_encoder.predict([challenge_occu, challenge_x],
batch_size=args.batch_size)
# Using x_latent and z as input of the decoder for generating future trajectories
print("Start predicting the challenge data")
challenge_predictions = []
for i, x_ in enumerate(x_latent):
last_pos = last_obs_challenge[i]
x_ = np.reshape(x_, [1, -1])
for i in range(args.num_pred):
# sampling z from a normal distribution
z_sample = np.random.rand(1, args.z_dim)
y_p = decoder.predict(np.column_stack([z_sample, x_]))
y_p_ = np.concatenate(([last_pos], np.squeeze(y_p)), axis=0)
y_p_sum = np.cumsum(y_p_, axis=0)
challenge_predictions.append(y_p_sum[1:, :])
challenge_predictions = np.reshape(
challenge_predictions, [-1, args.num_pred, args.pred_seq, 2])
print('Predicting done!')
print(challenge_predictions.shape)
##
## Get the first time prediction
challenge_ranked_prediction = []
for prediction in challenge_predictions:
ranks = gauss_rank(prediction)
challenge_ranked_prediction.append(prediction[np.argmax(ranks)])
challenge_ranked_prediction = np.reshape(challenge_ranked_prediction,
[-1, 1, args.pred_seq, 2])
challenge_pred_traj = writer.get_index(challenge_trajs,
challenge_predictions)
print("Collision in ranked prediction")
check_collision(np.squeeze(challenge_pred_traj))
writer.write_pred_txt(challenge_trajs, challenge_predictions,
challenge_dataname, "prediction")
def check_collision(self, objs):
for obj in objs:
if collision.check_collision(self, obj):
return True
return False
while not gameStatus == "Finished":
Kuchen_pos = Kuchen.get_pos()
screen.fill(0)
screen.blit(P1_sprite, P1_pos)
screen.blit(P2_sprite, P2_pos)
screen.blit(Kuchen_sprite, Kuchen_pos)
if (gameStatus[2:] == "_Ready"):
windTxt.draw(screen)
forceTxt.draw(screen)
angleTxt.draw(screen)
throwButton.draw(screen)
elif (gameStatus[2:] == "_Threw"):
Kuchen_pos = Kuchen.update()
if (gameStatus[0:2] == "P1"):
gameStatus = check_collision(Kuchen, Player2, gameStatus)
elif (gameStatus[0:2] == "P2"):
gameStatus = check_collision(Kuchen, Player1, gameStatus)
if gameStatus != "P1_Hit" and gameStatus != "P2_Hit":
gameStatus = check_collision_boundaries(Kuchen, 0, 0, MAX_X, MAX_Y, gameStatus)
elif (gameStatus[2:] == "_Missed"):
continueButton.draw(screen)
elif (gameStatus[2:] == "_Hit"):
if score_added == False:
if gameStatus[0:2] == "P1":
score_P1 += 1
elif gameStatus[0:2] == "P2":
score_P2 += 1
score_added = True
PxWinsTxt = Textbox(gameStatus[0:2] + " Wins!", (200, 50))
WinCounterTxt = Textbox(str(score_P1) + " : " + str(score_P2), (200, 150))
