def load(file_path):
idToPlayers = {}
pass_events = []
tree = ET.parse(file_path)
root = tree.getroot()
for child in root:
if child.tag == "Players":
for plyr in child:
player_id = plyr.attrib["id"]
player = PlayerBase([
plyr.attrib["type"],
player_id,
plyr.attrib["js"],
plyr.attrib["x"],
plyr.attrib["y"]])
player.speed = float(plyr.attrib["speed"])
player.direction = float(plyr.attrib["direction"])
idToPlayers[player_id] = player
elif child.tag == "Passes":
for pass_event in child:
pass_events.append(
PassEvent(
idToPlayers[pass_event.attrib["source_id"]],
idToPlayers[pass_event.attrib["target_id"]],
ReaderBase.divideIntoTeams(idToPlayers.values())
)
)
return idToPlayers.values(), pass_events
def __init__(self, ax, player, time, game_instances):
PlayerBase.__init__(self, player.raw_data)
self.time = time
self.game_instances = game_instances
self.ax =ax
self.player = player
self.draggable = DraggablePoint(ax.text(player.getX(), player.getY(), player.getJerseyNumber(),
horizontalalignment='center',
verticalalignment='center',
zorder=1,
color="w",
fontsize=VISUAL_PLAYER_JS_SIZE,
picker=True,
bbox=dict(
boxstyle="circle,pad=0.3",
fc=self.getObjectColor(),
ec=self.getObjectTypeColor(),
alpha=0.5,
linewidth=1
)
))
self.draggable.point.object_id = self.player.object_id
self.draggable.point.team_color = self.getObjectColor()
self.draggable.point.player_color = self.getObjectTypeColor()
self.direction_annotation = None
self.trail_annotation = None
self.speed = 0.0
self.direction = 0.0
self.acceleration = DEFAULT_ACCELERATION
def getTargetWithBestPositionsFor(self, temp_pass_event):
pass_target = temp_pass_event.getPassTarget()
best_positions = pass_target.get_position()
partial_range = 1
step = 0.25
best_effectiveness_score = -999999.9
for temp_position_x in range(pass_target.getX() - partial_range,
pass_target.getX() + partial_range, step):
pass_target.setX(temp_position_x)
for temp_position_y in range(pass_target.getY() - partial_range,
pass_target.getY() + partial_range,
step):
pass_target.setY(temp_position_y)
temp_effectiveness_score = self.pas.effectiveness(
temp_pass_event.getPassSource(), pass_target)
if temp_effectiveness_score > best_effectiveness_score:
best_effectiveness_score = temp_effectiveness_score
best_positions = temp_position_x, temp_position_y
target_with_best_positions = PlayerBase(
(pass_target.object_type,
pass_target.object_id, pass_target.jersey_number,
pass_target.getX(), pass_target.getY()))
target_with_best_positions.set_position(best_positions)
return target_with_best_positions
def eventDataParser(self, event_data):
line = event_data
team_name, js, event_id, event_name = line[3], int(line[4]), int(
line[5]), line[6]
player = PlayerBase((0, 0, js, 0, 0))
player.setTeamName(team_name)
return GameEvent(player, event_id, event_name)
def __init__(self, time, object_info):
PlayerBase.__init__(self, object_info)
self.coord_info = tree()
self.coord_info[time.half][time.milliseconds] = self.get_position()
self.ball_steal = 0
self.ball_lose = 0
self.ball_pass = 0
self.ball_ownership_time = 0
self.dominant_region = 0
self.total_area_for_dominant_regions = 0
self.total_number_of_instances = 0
def createFileAsXML(self):
root = ET.Element("data")
ET.SubElement(root, "TimeUnit").text = "millisecond"
q = self.game_instances.items()
halfs = range(1, q[-1][0][0] - q[0][0][0] + 2)
for temp_half in halfs:
range_index = 0 ###
half_root = ET.SubElement(root, "Half", number=str(temp_half))
position_data = ET.SubElement(half_root, "PositionData")
for game_instance in self.game_instances:
half, milliseconds = game_instance
game_instance = self.game_instances.get((half, milliseconds))
if half == temp_half:
if range_index == self.sample_size: ###
break ###
time_point = ET.SubElement(position_data, "TimePoint", val=str(milliseconds))
for player in game_instance.players:
player = PlayerBase(player)
ET.SubElement(
time_point, "Player",
type = str(player.object_type),
id = str(player.object_id),
js = str(player.jersey_number),
x = str(player.position_x),
y = str(player.position_y)
)
range_index += 1
range_index = 0 ###
evnt_data = ET.SubElement(half_root, "EventData")
for game_instance in self.game_instances:
half, milliseconds = game_instance
game_instance = self.game_instances.get((half, milliseconds))
if half == temp_half:
if game_instance.event:
if range_index == self.sample_size: ###
break ###
try:
ET.SubElement(
evnt_data, "Event",
time = str(milliseconds),
type_id = str(game_instance.event.event_id),
type = game_instance.event.event_name,
player_id = str(game_instance.event.player.object_id)
)
except:
pass
range_index += 1
tree = ET.ElementTree(root)
tree.write(os.path.join(DATA_BASE_DIR, 'output/sample_sentio_data.xml'))
def getGameEvents(self):
coordinate_data = self.getRawCoordinateData()
a = OrderedDict()
index = 0
while index < len(self.event_data) - 1:
line = self.event_data[index]
half, minute, second, team_name, js, event_id, event_name = int(line[0]), int(line[1]), int(line[2]), \
line[3], int(line[4]), int(line[5]), line[6]
current_player = PlayerBase((0, 0, js, 0, 0))
current_player.setTeamName(team_name)
current_teams = ReaderBase.divideIntoTeams(
coordinate_data.get((half, minute, second, 4)))
current_player = self.convertEventPlayerToCoordinatePlayer(
current_player, current_teams)
if (half, minute, second, 4) in a:
temp_game_event = a.get((half, minute, second, 4))
if temp_game_event.event_id != 1:
a[(half, minute, second,
4)] = GameEvent(current_player, event_id, event_name)
else:
a[(half, minute, second,
4)] = GameEvent(current_player, event_id, event_name)
if event_id == 1:
n_line = self.event_data[index + 1]
n_half, n_minute, n_second, n_team_name, n_js, n_event_id, n_event_name = \
int(n_line[0]), int(n_line[1]), int(n_line[2]), n_line[3], int(n_line[4]), int(n_line[5]), n_line[6]
if n_event_id == 1:
n_player = PlayerBase((0, 0, n_js, 0, 0))
n_player.setTeamName(n_team_name)
n_teams = ReaderBase.divideIntoTeams(
coordinate_data.get((n_half, n_minute, n_second, 4)))
n_player = self.convertEventPlayerToCoordinatePlayer(
n_player, n_teams)
n_game_event = GameEvent(n_player, n_event_id,
n_event_name)
if current_player is not None and n_player is not None:
current_player = ReaderBase.getPlayerIn(
current_player, n_teams)
n_game_event.setPassEvent(
PassEvent(current_player, n_player, n_teams))
a[(n_half, n_minute, n_second, 4)] = n_game_event
index += 1
return a
def detectGoalKeeperWithPositions(p1, teams):
if Analyze.isOpponentGoalKeeperLocationLeft(p1, teams):
goal_keeper_x = GOALPOST_MIN_X
else:
goal_keeper_x = GOALPOST_MAX_X
if p1.getY() < GOALPOST_MIN_Y: goal_keeper_y = GOALPOST_MIN_Y
elif p1.getY() > GOALPOST_MAX_Y: goal_keeper_y = GOALPOST_MAX_Y
else: goal_keeper_y = p1.getY()
goal_keeper = PlayerBase()
goal_keeper.set_position((goal_keeper_x, goal_keeper_y))
goal_keeper.setJerseyNumber("goal_keeper")
return goal_keeper
def parse(self):
tree = ET.parse(self.file_path)
root = tree.getroot()
mapping_index = 0
for child in root:
if child.tag == "Half":
temp_half = int(child.attrib["number"])
for grandchild in child:
if grandchild.tag == "PositionData":
for time_point in grandchild:
time_in_millisec = int(time_point.attrib["val"])
players = deque()
for plyr in time_point:
players.append(
PlayerBase([
plyr.attrib["type"], plyr.attrib["id"],
plyr.attrib["js"], plyr.attrib["x"],
plyr.attrib["y"]
]))
temp_time = Time(int(temp_half), time_in_millisec)
self.game_instances[temp_half][
time_in_millisec] = GameInstance(
temp_time, players)
self.slider_mapping[mapping_index] = temp_time
mapping_index += 1
elif grandchild.tag == "EventData":
index = 0
while index < len(grandchild) - 1:
c_event = grandchild[index]
c_time_in_millisec = int(c_event.attrib["time"])
try:
c_player_id = int(c_event.attrib["player_id"])
except:
c_player_id = None
c_event_type = c_event.attrib["type"]
c_event_id = int(c_event.attrib["type_id"])
temp_game_instance = self.game_instances[
temp_half][c_time_in_millisec]
teams = ReaderBase.divideIntoTeams(
temp_game_instance.players)
c_player = self.idToPlayer(c_player_id, teams)
c_temp_time = Time(int(temp_half),
c_time_in_millisec)
temp_game_instance.setEvent(
GameEvent(c_player, c_event_id, c_event_type,
c_temp_time))
if c_event_id == 1:
if index != 0:
p_event = grandchild[index - 1]
p_time_in_millisec = int(
p_event.attrib["time"])
p_event_type = p_event.attrib["type"]
p_event_id = int(p_event.attrib["type_id"])
try:
p_player_id = int(
p_event.attrib["player_id"])
except:
p_player_id = None
p_temp_game_instance = self.game_instances[
temp_half][p_time_in_millisec]
p_teams = ReaderBase.divideIntoTeams(
p_temp_game_instance.players)
p_player = self.idToPlayer(
p_player_id, p_teams)
p_temp_time = Time(int(temp_half),
p_time_in_millisec)
p_game_event = GameEvent(
p_player, p_event_id, p_event_type,
p_temp_time)
if p_event_id == 1:
p_player = self.idToPlayer(
p_player_id, teams)
if p_player is not None and c_player is not None:
temp_game_instance.event.setPassEvent(
PassEvent(
p_player, c_player, teams))
index += 1
self.game_instances = GameInstances(self.game_instances)
return self.game_instances, self.slider_mapping
def calculateDirection(self):
self.direction = \
PlayerBase.calculateDirectionFor(self.time, self.game_instances, visual=True, player_id=self.object_id)
return self.direction
def calculateSpeed(self):
self.speed = \
PlayerBase.calculateSpeedFor(self.time, self.game_instances, visual=True, player_id=self.object_id)
return self.speed
def calculateDirection(self, time):
return PlayerBase.calculateDirectionFor(time, self.coord_info, visual=False)
def calculateSpeed(self, time):
return PlayerBase.calculateSpeedFor(time, self.coord_info, visual=False)
def createFileAsJSON(self):
q = self.game_instances.items()
halfs = range(1, q[-1][0][0] - q[0][0][0] + 2)
with open(os.path.join(DATA_BASE_DIR, "output/sample_sentio_data.json"), "w") as outfile:
root = {"data":
{
"TimeUnit": "millisecond",
"Half": {}
}
}
for temp_half in halfs:
root["data"]["Half"][temp_half] = {}
position_data = []
range_index = 0 ###
for game_instance in self.game_instances:
half, milliseconds = game_instance
if half == temp_half:
if range_index == self.sample_size: ###
break ###
game_instance = self.game_instances.get((half, milliseconds))
temp_players = []
for player in game_instance.players:
player = PlayerBase(player)
player = {
"type": player.object_type,
"id": player.object_id,
"js": player.jersey_number,
"x": player.position_x,
"y": player.position_y
}
temp_players.append(player)
time_point = {
"val": milliseconds,
"players": temp_players
}
position_data.append(time_point)
range_index += 1 ###
root["data"]["Half"][temp_half]["PositionData"] = position_data
event_data = []
range_index = 0 ###
for game_instance in self.game_instances:
half, milliseconds = game_instance
if half == temp_half:
game_instance = self.game_instances.get((half, milliseconds))
if game_instance.event:
if range_index == self.sample_size: ###
break ###
try:
event = {
"time": milliseconds,
"type_id": game_instance.event.event_id,
"type": game_instance.event.event_name,
"player_id": game_instance.event.player.object_id
}
event_data.append(event)
except:
pass
range_index += 1 ###
root["data"]["Half"][temp_half]["EventData"] = event_data
json.dump(root, outfile)