def onCompute(self, event): Parameters.PASS_SOURCE_RADIUS = float(self.risk_parameter1.GetValue()) Parameters.PASS_TARGET_RADIUS_COEFFICIENT = float(self.risk_parameter2.GetValue()) Parameters.shooting_radius = float(self.risk_parameter3.GetValue()) teams = ReaderBase.divideIntoTeams(self.wx_gui.visual_idToPlayers.values()) self.wx_gui.pass_logger.pass_evaluate.teams = teams optimalShootingPointPrediction = OptimalShootingPointPrediction(teams) best_goal_position, scat_xr,scat_yr, s1x,s1y = optimalShootingPointPrediction.predict( self.convertVisualPlayerToPlayer(self.temp_ball_holder), self.wx_gui.pass_logger.pass_evaluate.goalChance, iterate=int(self.iteration_choice.GetValue()), stepSize=int(self.step_size_choice.GetValue())) x, y = best_goal_position self.ax.plot([x], [y], 'x', mew=3, ms=15, color="black") # self.ax.scatter(scat_xr,scat_yr,s=30,c='red',label = "Opponent Players") # self.ax.scatter(s1x,s1y,s=30,c='black',label = "ball owner") qwe, = self.ax.plot(s1x, s1y, linestyle="--", linewidth=2, color="black") self.canvas.draw() # current_pass_event = PassEvent(self.convertVisualPlayerToPlayer(self.pass_event.textcoords), # self.convertVisualPlayerToPlayer(self.pass_event.xycoords), # ReaderBase.divideIntoTeams(self.visual_idToPlayers.values(), # visual=True))
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 updatePositions(self, time): game_instance = self.sentio.game_instances.getGameInstance(time) if game_instance: for player in game_instance.players: if player.object_id in self.visual_idToPlayers: visual_player = self.visual_idToPlayers[player.object_id] if not visual_player.update_position(time): visual_player.remove() del self.visual_idToPlayers[player.object_id] else: visual_player = VisualPlayer(self.layouts.ax, player, time, self.sentio.game_instances) self.visual_idToPlayers[player.object_id] = visual_player for visual_player_id in self.visual_idToPlayers.keys(): if visual_player_id not in ReaderBase.mapIDToPlayers( game_instance.players): visual_player = self.visual_idToPlayers[visual_player_id] visual_player.remove() del self.visual_idToPlayers[visual_player_id] self.layouts.team_config_page.update( self.filterTeamPlayers(self.visual_idToPlayers)) return True else: return False
def OnCompute(self, event): self.analytics.clear() q = {} evaluate = Pass() for game_instance in self.match.sentio.game_instances.getAllInstances(): try: if game_instance.event and game_instance.event.isPassEvent(): if int(self.interval_min.GetValue()) <= game_instance.time.convertToTime().minute <= int(self.interval_max.GetValue()): pass_source = game_instance.event.pass_event.pass_source pass_target = game_instance.event.pass_event.pass_target evaluate.teams = ReaderBase.divideIntoTeams(game_instance.players) temp_effectiveness = evaluate.effectiveness_withComponents(pass_source, pass_target)[-1] if pass_source.jersey_number in q: q[pass_source.jersey_number].effectiveness_scores.append(temp_effectiveness) else: pass_source.effectiveness_scores = [temp_effectiveness] q[pass_source.jersey_number] = pass_source except AttributeError: print "event not found for game_instance" results = [] for team in self.getChosenTeams(q.values()): temp_results = [] temp_results.append((team.team_name, ("Effectiveness Score"))) for player in team.getTeamPlayers(): temp_results.append((player.jersey_number, (numpy.mean(player.effectiveness_scores)))) results.append(temp_results) results = self.formatInfoToDisplay(results) self.analytics.results = EventAnnotationManager.annotateAnalysisResults(self.canvas, self.ax, results)
def calculateDirectionFor(time, coord_info, visual=False, player_id=-1): positions = [] for temp_milliseconds in range(time.milliseconds, time.milliseconds+4, 2): if visual: game_instance = coord_info.getGameInstance(Time(time.half, temp_milliseconds)) if game_instance: idToPlayers = ReaderBase.mapIDToPlayers(game_instance.players) try: player = idToPlayers[player_id] temp_position = player.get_position() except: temp_position = None else: temp_position = None else: temp_position = coord_info[time.half][temp_milliseconds] if temp_position: positions.append(temp_position) if len(positions) != 2: return 0.0 x1, y1 = positions[0] x2, y2 = positions[1] dx=((x2-x1) if (x2-x1) != 0.0 else 0.01) Q = math.degrees(math.atan((y2-y1)/dx)) if Q < 0: Q = Q + 360.0 return float("{0:.2f}".format(Q))
def on_pick_event(self, event): if isinstance(event.artist, Text): if self.pass_source is not None: self.pass_target = event.artist if self.pass_source != self.pass_target: self.pass_event.xy = (.5,.5) self.pass_event.xycoords = self.pass_target current_pass_event = PassEvent(self.convertVisualPlayerToPlayer(self.pass_event.textcoords), self.convertVisualPlayerToPlayer(self.pass_event.xycoords), ReaderBase.divideIntoTeams(self.visual_idToPlayers.values(), visual=True)) if Parameters.IS_DEBUG_MODE_ON: self.risk_range.drawRangeFor(current_pass_event) self.pass_logger.displayDefinedPass(current_pass_event) if self.isHeatMapChosen(): self.drawHeatMapFor(current_pass_event) self.passes_defined.append(current_pass_event) self.manual_pass_event_annotations.append(self.pass_event) else: self.pass_target = None else: self.pass_source = event.artist xBall, yBall = (event.mouseevent.xdata, event.mouseevent.ydata) self.pass_event = self.ax.annotate('', xy=(xBall, yBall), xytext=(.5,.5), picker=True, textcoords=(self.pass_source), size=20, arrowprops=dict(patchA=self.pass_source.get_bbox_patch(), arrowstyle="fancy", fc="0.6", ec="none", connectionstyle="arc3")) self.figure.canvas.draw()
def computeDominantRegions(self, interval_min=0, interval_max=90, field="Whole Field"): game_stop_time_intervals = self.getGameStopTimeIntervals() voronoi = Voronoi() q = {} if interval_min != 0 or interval_max != 90: game_instances = self.sentio.game_instances.getInstancesByInterval(interval_min, interval_max) else: game_instances = self.sentio.game_instances.getAllInstances() for game_instance in game_instances: try: polygons = voronoi.computePolygons(game_instance.players) for index, player in enumerate(game_instance.players): polygon = polygons[index] # area_of_polygon = Voronoi.calculateArea(polygon) area_of_polygon = Voronoi.calculateAreaByField(polygon, field, game_instance.isHomeGoalKeeperLocationLeft()) if player.object_id in q: temp_player = q[player.object_id] temp_player.dominant_region += area_of_polygon temp_player.total_number_of_instances += 1 else: q[player.object_id] = Player(game_instance.time, player.raw_data) q[player.object_id].set_gameStopTimeInterval(game_stop_time_intervals) q[player.object_id].dominant_region = area_of_polygon q[player.object_id].total_number_of_instances = 1 q[player.object_id].total_area_for_dominant_regions = voronoi.calculateTotalAreaOfField() except: print "game instance is missing", game_instance self.teams = ReaderBase.idPlayersToTeamPlayers(q) return self.teams
def buildMatchObjects(self, interval_min=0, interval_max=90): game_stop_time_intervals = self.getGameStopTimeIntervals() q = {}, {}, {}, {} ## home_team, away_team, referees, unknowns if interval_min != 0 or interval_max != 90: game_instances = self.sentio.game_instances.getInstancesByInterval(interval_min, interval_max) else: game_instances = self.sentio.game_instances.getAllInstances() for game_instance in game_instances: try: teams = ReaderBase.divideIntoTeams(game_instance.players) for team_index, team in enumerate(teams.getTeams()): temp_team = q[team_index] for player in team.getTeamPlayers(): if player.jersey_number in temp_team: temp_player = temp_team[player.jersey_number] temp_player.appendNewCoordInfo(game_instance.time, player.get_position()) else: temp_team[player.jersey_number] = Player(game_instance.time, player.raw_data) temp_team[player.jersey_number].set_gameStopTimeInterval(game_stop_time_intervals) except: print "game instance is missing", game_instance home_team, away_team, referees, unknowns = q self.teams = Teams( Team(Parameters.HOME_TEAM_NAME, home_team), Team(Parameters.AWAY_TEAM_NAME, away_team), Team(Parameters.REFEREES_TEAM_NAME, referees), Team(Parameters.UNKNOWNS_TEAM_NAME, unknowns) )
def getRevisedCoordinateData(self): a = OrderedDict() for line in self.coordinate_data: half, minute, second, millisecond, coord_data = int(line[3]), int(line[4]), int(line[5]), int(line[2][-3]),\ [playerInfo.split(",") for playerInfo in line[6].split("+")[:-1]] a[(half, minute, second, millisecond)] = ReaderBase.divideIntoTeams(coord_data) return a
def getCombinedEventData(self): event_data = self.getEventData() coordinate_data = self.getRawCoordinateData() for time in event_data: current_event_data = event_data[time] current_teams = ReaderBase.divideIntoTeams(coordinate_data[time + (4, )]) current_event_data.player = self.convertEventPlayerToCoordinatePlayer( current_event_data.player, current_teams) return event_data
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 displayDefinedPasses(self): self.pass_logger.clear() for defined_pass in self.passes_defined: defined_pass.pass_source = self.convertVisualPlayerToPlayer( defined_pass.pass_source) defined_pass.pass_target = self.convertVisualPlayerToPlayer( defined_pass.pass_target) defined_pass.teams = ReaderBase.divideIntoTeams( self.visual_idToPlayers.values(), visual=True) self.pass_logger.displayDefinedPass(defined_pass)
def getChosenTeams(self, players): teams = ReaderBase.divideIntoTeams(players) if self.team_choice.GetValue() == "All Teams": teams = [teams.home_team, teams.away_team] elif self.team_choice.GetValue() == "Home Team": teams = [teams.home_team] elif self.team_choice.GetValue() == "Away Team": teams = [teams.away_team] else: print "chosen team is missing!!!" return teams
def draw_defencePositionTaking(self, definedPass, chosen_js, number_of_points=(105, 65)): teams = ReaderBase.divideIntoTeams(self.draggable_visual_teams, visual=True) if definedPass.pass_source.isHomeTeamPlayer(): opponent_team = teams.away_team else: opponent_team = teams.home_team p_chosen = opponent_team.getTeamPlayersWithJS().get(chosen_js) return self.evaluate(definedPass, p_chosen, number_of_points)
def evaluate(self, definedPass, p_accordingTo, resolution): p1 = definedPass.pass_source p2 = definedPass.pass_target x_coord = numpy.linspace(FOOTBALL_FIELD_MIN_X, FOOTBALL_FIELD_MAX_X, resolution[0]) y_coord = numpy.linspace(FOOTBALL_FIELD_MIN_Y, FOOTBALL_FIELD_MAX_Y, resolution[1]) self.effectivenessByComponent = { "overallRisk": [], "gain": [], "passAdvantage": [], "goalChance": [], "effectiveness": [] } self.pass_evaluate.teams = ReaderBase.divideIntoTeams( self.draggable_visual_teams.values(), visual=True) for y in y_coord: temp_overRisk, temp_gain, temp_passAdv, temp_goalChange, temp_effect = [], [], [], [], [] for x in x_coord: p_accordingTo.set_position((x, y)) if p_accordingTo.object_id == p1.object_id: currentEffectiveness_withComponents = self.pass_evaluate.effectiveness_withComponents( p_accordingTo, p2) elif p_accordingTo.object_id == p2.object_id: currentEffectiveness_withComponents = self.pass_evaluate.effectiveness_withComponents( p1, p_accordingTo) else: currentEffectiveness_withComponents = self.pass_evaluate.effectiveness_withComponents( p1, p2) self.effectivenessByPosition[( x, y)] = currentEffectiveness_withComponents for index, component in enumerate([ temp_overRisk, temp_gain, temp_passAdv, temp_goalChange, temp_effect ]): component.append( currentEffectiveness_withComponents[index]) # print x,y self.effectivenessByComponent["overallRisk"].append(temp_overRisk) self.effectivenessByComponent["gain"].append(temp_gain) self.effectivenessByComponent["passAdvantage"].append(temp_passAdv) self.effectivenessByComponent["goalChance"].append(temp_goalChange) self.effectivenessByComponent["effectiveness"].append(temp_effect) self.draw(self.effectivenessByComponent["overallRisk"])
def calculateSpeedFor(time, coord_info, visual=False, player_id=-1): pre_position = None speed = 0.0 for temp_milliseconds in range(time.milliseconds-8, time.milliseconds+2, 2): if visual: game_instance = coord_info.getGameInstance(Time(time.half, temp_milliseconds)) if game_instance: idToPlayers = ReaderBase.mapIDToPlayers(game_instance.players) try: player = idToPlayers[player_id] position = player.get_position() except: position = None else: position = None else: position = coord_info[time.half][temp_milliseconds] if pre_position and position: speed += math.sqrt(pow(position[0]-pre_position[0],2) + pow(position[1]-pre_position[1],2)) if position: ### needed to handle missing positions pre_position = position return float("{0:.2f}".format(speed))
def parse(self): with open(self.file_path) as data_file: data = json.load(data_file) mapping_index = 0 for temp_half in data["data"]["Half"]: positions_data = data["data"]["Half"][temp_half][ "PositionData"] for position_data in positions_data: time_in_millisec = position_data["val"] players = deque() for plyr in position_data["players"]: players.append([ plyr["type"], plyr["id"], plyr["js"], plyr["x"], plyr["y"] ]) temp_time = Time(int(temp_half), time_in_millisec) self.game_instances[int( temp_half)][time_in_millisec] = GameInstance( temp_time, players) self.slider_mapping[mapping_index] = temp_time mapping_index += 1 index = 0 events_data = data["data"]["Half"][temp_half]["EventData"] while index < len(events_data) - 1: c_event = events_data[index] c_time_in_millisec = int(c_event["time"]) c_player_id = int(c_event["player_id"]) c_event_type = c_event["type"] c_event_id = int(c_event["type_id"]) temp_game_instance = self.game_instances[int( temp_half)][c_time_in_millisec] teams = ReaderBase.divideIntoTeams( temp_game_instance.players) c_player = self.idToPlayer(c_player_id, teams) if temp_game_instance.event is not None: if c_event_id != 1: temp_game_instance.setEvent( GameEvent(c_player, c_event_id, c_event_type)) else: temp_game_instance.setEvent( GameEvent(c_player, c_event_id, c_event_type)) if c_event_id == 1: if index != 0: p_event = events_data[index - 1] p_time_in_millisec = int(p_event["time"]) p_event_type = p_event["type"] p_event_id = int(p_event["type_id"]) p_player_id = int(p_event["player_id"]) p_temp_game_instance = self.game_instances[int( 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_game_event = GameEvent(p_player, p_event_id, p_event_type) 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
__author__ = 'emrullah' reader = XMLreader(os.path.join(DATA_BASE_DIR, 'output/sentio_data_new.xml')) game_instances, slider_mapping = reader.parse() computation_times = [] evaluate = Pass() for game_instance in game_instances.getAllInstances(): if game_instance.event and game_instance.event.isPassEvent(): pass_event = game_instance.event.pass_event # if pass_event.isSuccessful(): # try: pass_source = pass_event.pass_source pass_target = pass_event.pass_target evaluate.teams = ReaderBase.divideIntoTeams(game_instance.players) start = time.time() evaluate.effectiveness_withComponents(pass_source, pass_target) temp_computation_time = time.time() - start # in sec computation_times.append(temp_computation_time) # except: # print "the algorithm is buggy" print max(computation_times), min(computation_times), "---" # bin1,bin2,bin3,bin4=[],[],[],[] # for pt in computation_times: # if pt < 0.004: bin1.append(pt) # elif 0.004 <pt< 0.005: bin2.append(pt) # elif 0.005 <pt< 0.006: bin3.append(pt) # else: bin4.append(pt) #
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 __init__(self, file_path): ReaderBase.__init__(self, file_path)
def isHomeGoalKeeperLocationLeft(self): teams = ReaderBase.divideIntoTeams(self.players) return teams.home_team.getGoalKeeper().getX( ) < teams.away_team.getGoalKeeper().getX()
def filterTeamPlayers(self, visual_idToPlayers): teams = ReaderBase.divideIntoVisualTeams(visual_idToPlayers.values()) team_players = teams.home_team.team_players team_players.update(teams.away_team.team_players) return team_players
def __init__(self, file_path): ReaderBase.__init__(self, file_path) self.coordinate_data = {} self.event_data = {}