start

Pitch3D.py

@@ -0,0 +1,369 @@
+
+# import numpy as np
+# import streamlit as st
+# import plotly.express as px
+# import plotly.graph_objects as go
+# import pandas as pd
+
+# # Soccer field dimensions (in meters)
+# WIDTH = 80  # Width of the field
+# LENGTH = 120  # Length of the field
+# GOAL_HEIGHT = 2.44  # Standard goal height
+# PENALTY_AREA_WIDTH = 40.3
+# PENALTY_AREA_DEPTH = 16.5
+# GOAL_AREA_WIDTH = 18.32
+# GOAL_AREA_DEPTH = 5.5
+# GOAL_WIDTH = 7.32  # Standard width of a soccer goal
+
+# def create_field_df():
+#     """Create dataframes for different parts of the soccer field."""
+#     field_perimeter_bounds = [[0, 0, 0], [WIDTH, 0, 0], [WIDTH, LENGTH, 0], [0, LENGTH, 0], [0, 0, 0]]
+#     field_df = pd.DataFrame(field_perimeter_bounds, columns=['x', 'y', 'z'])
+#     field_df['line_group'] = 'field_perimeter'
+#     field_df['color'] = 'field'
+
+#     half_field_bounds = [[0, LENGTH / 2, 0], [WIDTH, LENGTH / 2, 0]]
+#     half_df = pd.DataFrame(half_field_bounds, columns=['x', 'y', 'z'])
+#     half_df['line_group'] = 'half_field'
+#     half_df['color'] = 'field'
+
+#     left_penalty_df = create_rectangle_df((WIDTH - PENALTY_AREA_WIDTH) / 2, 0, PENALTY_AREA_WIDTH, PENALTY_AREA_DEPTH, 'left_penalty_area')
+#     right_penalty_df = create_rectangle_df((WIDTH - PENALTY_AREA_WIDTH) / 2, LENGTH - PENALTY_AREA_DEPTH, PENALTY_AREA_WIDTH, PENALTY_AREA_DEPTH, 'right_penalty_area')
+#     left_goal_df = create_rectangle_df((WIDTH - GOAL_AREA_WIDTH) / 2, 0, GOAL_AREA_WIDTH, GOAL_AREA_DEPTH, 'left_goal_area')
+#     right_goal_df = create_rectangle_df((WIDTH - GOAL_AREA_WIDTH) / 2, LENGTH - GOAL_AREA_DEPTH, GOAL_AREA_WIDTH, GOAL_AREA_DEPTH, 'right_goal_area')
+
+#     return pd.concat([field_df, half_df, left_penalty_df, right_penalty_df, left_goal_df, right_goal_df])
+
+# def create_rectangle_df(start_x, start_y, width, height, line_group):
+#     """Create a dataframe representing a rectangle on the field."""
+#     rectangle_bounds = [
+#         [start_x, start_y, 0],
+#         [start_x + width, start_y, 0],
+#         [start_x + width, start_y + height, 0],
+#         [start_x, start_y + height, 0],
+#         [start_x, start_y, 0]
+#     ]
+#     df = pd.DataFrame(rectangle_bounds, columns=['x', 'y', 'z'])
+#     df['line_group'] = line_group
+#     df['color'] = 'field'
+#     return df
+
+# def create_center_circle():
+#     """Create a 3D line trace for the center circle."""
+#     theta = np.linspace(0, 2 * np.pi, 100)
+#     x = [(WIDTH / 2) + (9.15 * np.cos(t)) for t in theta]
+#     y = [(LENGTH / 2) + (9.15 * np.sin(t)) for t in theta]
+#     z = [0] * 100
+#     return go.Scatter3d(x=x, y=y, z=z, mode='lines', line=dict(color='white', width=2))
+
+# def create_goalposts():
+#     """Create goalpost lines for both ends of the field."""
+#     goalposts = []
+
+#     goalposts.extend([
+#         go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) - (GOAL_WIDTH / 2)], y=[LENGTH, LENGTH], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+#         go.Scatter3d(x=[(WIDTH / 2) + (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[LENGTH, LENGTH], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+#         go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[LENGTH, LENGTH], z=[GOAL_HEIGHT, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4))
+#     ])
+
+#     goalposts.extend([
+#         go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) - (GOAL_WIDTH / 2)], y=[0, 0], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+#         go.Scatter3d(x=[(WIDTH / 2) + (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[0, 0], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+#         go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[0, 0], z=[GOAL_HEIGHT, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4))
+#     ])
+
+#     return goalposts
+
+# def generate_trajectory(start_point, end_point, peak_height=10, num_coords=100, trajectory_type='parabolic'):
+#     """Generate a trajectory (parabolic or linear) between start and end points."""
+#     shot_start_x, shot_start_y, start_z = start_point
+#     hoop_x, hoop_y, end_z = end_point
+
+#     if trajectory_type == 'parabolic':
+#         distance_x = hoop_x - shot_start_x
+#         a = -4 * peak_height / (distance_x ** 2)
+
+#         shot_path_coords = []
+#         for index, x in enumerate(np.linspace(shot_start_x, hoop_x, num_coords + 1)):
+#             z = a * (x - (shot_start_x + hoop_x) / 2) ** 2 + peak_height
+#             y = shot_start_y + (hoop_y - shot_start_y) * (index / num_coords)
+#             shot_path_coords.append([x, y, z])
+
+#         shot_path_coords[0][2] = start_z  # Ensure start z is as specified
+#         shot_path_coords[-1][2] = end_z  # Ensure end z is as specified
+
+#     elif trajectory_type == 'linear':
+#         shot_path_coords = []
+#         for index, x in enumerate(np.linspace(shot_start_x, hoop_x, num_coords + 1)):
+#             y = shot_start_y + (hoop_y - shot_start_y) * (index / num_coords)
+#             z = start_z + (end_z - start_z) * (index / num_coords)
+#             shot_path_coords.append([x, y, z])
+
+#     return pd.DataFrame(shot_path_coords, columns=['x', 'y', 'z'])
+
+# def plot_trajectories(fig, start_points, end_points, trajectory_type='parabolic', peak_height=10, num_coords=100):
+#     """Plot multiple trajectories on the field."""
+#     for start_point, end_point in zip(start_points, end_points):
+#         trajectory_df = generate_trajectory(start_point, end_point, peak_height, num_coords, trajectory_type)
+#         fig.add_trace(go.Scatter3d(
+#             y=trajectory_df['x'],
+#             x=trajectory_df['y'],
+#             z=trajectory_df['z'],
+#             mode='lines',
+#             line=dict(color='red', width=4)
+#         ))
+#         fig.add_trace(go.Scatter3d(
+#             y=[trajectory_df['x'].iloc[0], trajectory_df['x'].iloc[-1]],
+#             x=[trajectory_df['y'].iloc[0], trajectory_df['y'].iloc[-1]],
+#             z=[trajectory_df['z'].iloc[0], trajectory_df['z'].iloc[-1]],
+#             mode='markers',
+#             marker=dict(size=3, color='red')
+#         ))
+
+# def create_soccer_field_plot():
+#     """Create a 3D soccer field plot with trajectories."""
+#     field_df = create_field_df()
+
+#     fig = px.line_3d(
+#         data_frame=field_df, x='x', y='y', z='z', line_group='line_group', color='color',
+#         color_discrete_map={'field': '#FFFFFF'}
+#     )
+
+#     fig.add_trace(go.Mesh3d(
+#         x=[0, WIDTH, WIDTH, 0],
+#         y=[0, 0, LENGTH, LENGTH],
+#         z=[0, 0, 0, 0],
+#         color='rgb(0, 128, 0)',
+#         opacity=0.5
+#     ))
+
+#     fig.add_trace(create_center_circle())
+#     for goalpost in create_goalposts():
+#         fig.add_trace(goalpost)
+
+#     max_dimension = max(WIDTH, LENGTH, GOAL_HEIGHT)
+#     fig.update_layout(
+#         scene=dict(
+#             aspectmode="manual",
+#             aspectratio=dict(x=1, y=1, z=0.125),
+#             xaxis=dict(
+#                 range=[-10, max_dimension + 10],
+#                 visible=False
+#             ),
+#             yaxis=dict(
+#                 range=[-10, max_dimension + 10],
+#                 visible=False
+#             ),
+#             zaxis=dict(
+#                 range=[0, 15],
+#                 visible=False
+#             ),
+#             camera=dict(
+#                 eye=dict(x=0.34, y=0, z=0.45)
+#             ),
+#         ),
+#         paper_bgcolor='rgba(0,0,0,0)',
+#         plot_bgcolor='rgba(0,0,0,0)',
+#         showlegend=False,
+#     )
+
+#     return fig
+
+# def main_3D_pitch(start_points, end_points, trajectory_type='linear'):
+#     st.title("3D Soccer Field Trajectory Visualization")
+
+#     fig = create_soccer_field_plot()
+
+#     plot_trajectories(fig, start_points, end_points, trajectory_type=trajectory_type, peak_height=5, num_coords=100)
+
+#     st.plotly_chart(fig)
+import numpy as np
+import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+
+# Soccer field dimensions (in meters)
+WIDTH = 80  # Width of the field
+LENGTH = 120  # Length of the field
+GOAL_HEIGHT = 2.44  # Standard goal height
+PENALTY_AREA_WIDTH = 40.3
+PENALTY_AREA_DEPTH = 16.5
+GOAL_AREA_WIDTH = 18.32
+GOAL_AREA_DEPTH = 5.5
+GOAL_WIDTH = 7.32  # Standard width of a soccer goal
+
+def create_field_df():
+    """Create dataframes for different parts of the soccer field."""
+    field_perimeter_bounds = [[0, 0, 0], [WIDTH, 0, 0], [WIDTH, LENGTH, 0], [0, LENGTH, 0], [0, 0, 0]]
+    field_df = pd.DataFrame(field_perimeter_bounds, columns=['x', 'y', 'z'])
+    field_df['line_group'] = 'field_perimeter'
+    field_df['color'] = 'field'
+
+    half_field_bounds = [[0, LENGTH / 2, 0], [WIDTH, LENGTH / 2, 0]]
+    half_df = pd.DataFrame(half_field_bounds, columns=['x', 'y', 'z'])
+    half_df['line_group'] = 'half_field'
+    half_df['color'] = 'field'
+
+    left_penalty_df = create_rectangle_df((WIDTH - PENALTY_AREA_WIDTH) / 2, 0, PENALTY_AREA_WIDTH, PENALTY_AREA_DEPTH, 'left_penalty_area')
+    right_penalty_df = create_rectangle_df((WIDTH - PENALTY_AREA_WIDTH) / 2, LENGTH - PENALTY_AREA_DEPTH, PENALTY_AREA_WIDTH, PENALTY_AREA_DEPTH, 'right_penalty_area')
+    left_goal_df = create_rectangle_df((WIDTH - GOAL_AREA_WIDTH) / 2, 0, GOAL_AREA_WIDTH, GOAL_AREA_DEPTH, 'left_goal_area')
+    right_goal_df = create_rectangle_df((WIDTH - GOAL_AREA_WIDTH) / 2, LENGTH - GOAL_AREA_DEPTH, GOAL_AREA_WIDTH, GOAL_AREA_DEPTH, 'right_goal_area')
+
+    return pd.concat([field_df, half_df, left_penalty_df, right_penalty_df, left_goal_df, right_goal_df])
+
+def create_rectangle_df(start_x, start_y, width, height, line_group):
+    """Create a dataframe representing a rectangle on the field."""
+    rectangle_bounds = [
+        [start_x, start_y, 0],
+        [start_x + width, start_y, 0],
+        [start_x + width, start_y + height, 0],
+        [start_x, start_y + height, 0],
+        [start_x, start_y, 0]
+    ]
+    df = pd.DataFrame(rectangle_bounds, columns=['x', 'y', 'z'])
+    df['line_group'] = line_group
+    df['color'] = 'field'
+    return df
+
+def create_center_circle():
+    """Create a 3D line trace for the center circle."""
+    theta = np.linspace(0, 2 * np.pi, 100)
+    x = [(WIDTH / 2) + (9.15 * np.cos(t)) for t in theta]
+    y = [(LENGTH / 2) + (9.15 * np.sin(t)) for t in theta]
+    z = [0] * 100
+    return go.Scatter3d(x=x, y=y, z=z, mode='lines', line=dict(color='white', width=2))
+
+def create_goalposts():
+    """Create goalpost lines for both ends of the field."""
+    goalposts = []
+
+    goalposts.extend([
+        go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) - (GOAL_WIDTH / 2)], y=[LENGTH, LENGTH], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+        go.Scatter3d(x=[(WIDTH / 2) + (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[LENGTH, LENGTH], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+        go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[LENGTH, LENGTH], z=[GOAL_HEIGHT, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4))
+    ])
+
+    goalposts.extend([
+        go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) - (GOAL_WIDTH / 2)], y=[0, 0], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+        go.Scatter3d(x=[(WIDTH / 2) + (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[0, 0], z=[0, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4)),
+        go.Scatter3d(x=[(WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2)], y=[0, 0], z=[GOAL_HEIGHT, GOAL_HEIGHT], mode='lines', line=dict(color='black', width=4))
+    ])
+
+    return goalposts
+
+def create_goal_net(start_x, end_x, start_y, end_y, height, width):
+    """Create a 3D mesh for the goal net."""
+    x = [start_x, end_x, end_x, start_x, start_x]
+    y = [start_y, start_y, end_y, end_y, start_y]
+    z = [height, height, height, height, height]
+    return go.Mesh3d(x=x, y=y, z=z, opacity=0.1, color='blue')
+
+def generate_trajectory(start_point, end_point, peak_height=10, num_coords=100, trajectory_type='parabolic'):
+    """Generate a trajectory (parabolic or linear) between start and end points."""
+    shot_start_x, shot_start_y, start_z = start_point
+    hoop_x, hoop_y, end_z = end_point
+
+    if trajectory_type == 'parabolic':
+        distance_x = hoop_x - shot_start_x
+        a = -4 * peak_height / (distance_x ** 2)
+
+        shot_path_coords = []
+        for index, x in enumerate(np.linspace(shot_start_x, hoop_x, num_coords + 1)):
+            z = a * (x - (shot_start_x + hoop_x) / 2) ** 2 + peak_height
+            y = shot_start_y + (hoop_y - shot_start_y) * (index / num_coords)
+            shot_path_coords.append([x, y, z])
+
+        shot_path_coords[0][2] = start_z  # Ensure start z is as specified
+        shot_path_coords[-1][2] = end_z  # Ensure end z is as specified
+
+    elif trajectory_type == 'linear':
+        shot_path_coords = []
+        for index, x in enumerate(np.linspace(shot_start_x, hoop_x, num_coords + 1)):
+            y = shot_start_y + (hoop_y - shot_start_y) * (index / num_coords)
+            z = start_z + (end_z - start_z) * (index / num_coords)
+            shot_path_coords.append([x, y, z])
+
+    return pd.DataFrame(shot_path_coords, columns=['x', 'y', 'z'])
+
+def plot_trajectories(fig, start_points, end_points, trajectory_type='parabolic', peak_height=10, num_coords=100):
+    """Plot multiple trajectories on the field."""
+    for start_point, end_point in zip(start_points, end_points):
+        trajectory_df = generate_trajectory(start_point, end_point, peak_height, num_coords, trajectory_type)
+        fig.add_trace(go.Scatter3d(
+            y=trajectory_df['x'],
+            x=trajectory_df['y'],
+            z=trajectory_df['z'],
+            mode='lines',
+            line=dict(color='red', width=4)
+        ))
+        fig.add_trace(go.Scatter3d(
+            y=[trajectory_df['x'].iloc[0], trajectory_df['x'].iloc[-1]],
+            x=[trajectory_df['y'].iloc[0], trajectory_df['y'].iloc[-1]],
+            z=[trajectory_df['z'].iloc[0], trajectory_df['z'].iloc[-1]],
+            mode='markers',
+            marker=dict(size=3, color='red')
+        ))
+
+def create_soccer_field_plot():
+    """Create a 3D soccer field plot with trajectories."""
+    field_df = create_field_df()
+
+    fig = px.line_3d(
+        data_frame=field_df, x='x', y='y', z='z', line_group='line_group', color='color',
+        color_discrete_map={'field': '#FFFFFF'}
+    )
+
+    fig.add_trace(go.Mesh3d(
+        x=[0, WIDTH, WIDTH, 0],
+        y=[0, 0, LENGTH, LENGTH],
+        z=[0, 0, 0, 0],
+        color='rgb(0, 128, 0)',
+        opacity=0.5
+    ))
+
+    fig.add_trace(create_center_circle())
+    for goalpost in create_goalposts():
+        fig.add_trace(goalpost)
+
+    # # Add goal nets
+    # fig.add_trace(create_goal_net((WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2), 0, -GOAL_HEIGHT, GOAL_HEIGHT, GOAL_WIDTH))
+    # fig.add_trace(create_goal_net((WIDTH / 2) - (GOAL_WIDTH / 2), (WIDTH / 2) + (GOAL_WIDTH / 2), LENGTH, LENGTH + GOAL_HEIGHT, GOAL_HEIGHT, GOAL_WIDTH))
+
+    max_dimension = max(WIDTH, LENGTH, GOAL_HEIGHT)
+    fig.update_layout(
+        scene=dict(
+            aspectmode="manual",
+            aspectratio=dict(x=1, y=1, z=0.125),
+            xaxis=dict(
+                range=[-10, max_dimension + 10],
+                visible=False
+            ),
+            yaxis=dict(
+                range=[-10, max_dimension + 10],
+                visible=False
+            ),
+            zaxis=dict(
+                range=[0, 15],
+                visible=False
+            ),
+            camera=dict(
+                eye=dict(x=0.34, y=0, z=0.45)
+            ),
+        ),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        showlegend=False,
+    )
+
+    return fig
+
+def main_3D_pitch(start_points, end_points, trajectory_type='linear'):
+    st.title("3D Soccer Field Trajectory Visualization")
+
+    fig = create_soccer_field_plot()
+
+    plot_trajectories(fig, start_points, end_points, trajectory_type=trajectory_type, peak_height=5, num_coords=100)
+
+    st.plotly_chart(fig)
+

app.py

@@ -0,0 +1,266 @@
+import streamlit as st
+import pandas as pd
+from statsbombpy import sb
+import config_location_player as clp
+import functions
+import Pitch3D
+import json
+from stats_manager import StatsManager
+
+st.set_page_config(layout="wide")
+
+st.markdown(
+    """
+    <style>
+    .centered-image {
+        display: block;
+        margin-left: auto;
+        margin-right: auto;
+        width: 20%; /* Adjust this percentage to resize the image */
+    }
+    .ban-image {
+        display: block;
+        margin-left: 0;
+        margin-right: 0;
+        width: 100%; /* Adjust this percentage to resize the image */
+        height: 50%; /* Adjust this percentage to resize the image */
+    }
+    .banner-image {
+        background-image: url('https://statsbomb.com/wp-content/uploads/2023/03/IconLockup_MediaPack-min.png');
+        background-size: cover;
+        background-position: center;
+        height: 300px; /* Adjust the height to your preference */
+        width: 100%;
+        margin: 0 auto;
+        margin-bottom: 100px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+st.markdown('<div class="banner-image"></div>', unsafe_allow_html=True)
+
+
+# st.markdown(
+#     '<img src="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRsmWldT7_OE2kDhbehYcuTNHzItGFbeH5igw&s" class="centered-image"> <br> <br> <br>',
+#     unsafe_allow_html=True
+# )
+
+
+
+#PARTIE 1 : MATCH CHOOSEN
+col1, col2 = st.columns([1, 3])
+with col1:
+
+    competition = sb.competitions()
+
+    #Gender Choice
+    # on = st.toggle("Men" if st.session_state.get('competition_gender', 'women') == 'women' else "Women")
+    # competition_gender = 'men' if on else 'women'
+    # st.session_state.competition_gender = competition_gender
+    competition_gender = "male"
+    competition_gender_df = competition[competition['competition_gender']==competition_gender]
+
+
+
+    #Competition Choice
+    competitions = competition_gender_df['competition_name'].unique()
+    selected_competition = st.selectbox(
+        "Choose your competition",
+        competitions,
+    )
+    selected_competition_df = competition_gender_df[competition_gender_df['competition_name']==selected_competition]
+
+
+
+
+
+    #Season Choice
+    seasons = selected_competition_df['season_name'].unique()
+    selected_season = st.selectbox(
+        "Choose your season",
+        seasons,
+    )
+
+    competition_id = selected_competition_df[selected_competition_df['season_name']==selected_season]['competition_id'].iloc[0]
+    season_id = selected_competition_df[selected_competition_df['season_name']==selected_season]['season_id'].iloc[0]
+    matches = sb.matches(competition_id=competition_id, season_id=season_id)
+
+
+    #Season Choice
+    # teams = selected_competition_df[['home_team','away_team']].unique()
+    teams = pd.concat([matches['away_team'], matches['home_team']]).unique()
+    selected_team = st.selectbox(
+        "Choose your team",
+        teams,
+    )
+    one_team_matches = matches[(matches['home_team'] == selected_team) | (matches['away_team'] == selected_team)]
+    # matches = one_team_matches['match_id']
+    matches = one_team_matches['match_date']
+
+    selected_match = st.selectbox(
+        "Choose your match",
+        matches,
+    )
+    selected_one_team_matches = one_team_matches[one_team_matches['match_date']==selected_match]
+    match_id = selected_one_team_matches['match_id'].iloc[0]
+
+    home_team = selected_one_team_matches['home_team'].iloc[0]
+    home_score = selected_one_team_matches['home_score'].iloc[0]
+    home_color = "#0B8494"
+
+    away_team = selected_one_team_matches['away_team'].iloc[0]
+    away_score = selected_one_team_matches['away_score'].iloc[0]
+    away_color = "#F05A7E" 
+
+    home_lineups = sb.lineups(match_id=match_id)[home_team]
+    away_lineups = sb.lineups(match_id=match_id)[away_team]
+
+    events = sb.events(match_id=match_id)
+    home_tactic_formation = events['tactics'].iloc[0]['formation']
+    away_tactic_formation = events['tactics'].iloc[1]['formation']
+
+
+
+
+
+
+
+#PARTIE 2 : DASHBOARD
+with col2:
+
+    # st.write(events.filter(regex='^bad_behaviour_card|^team$'))
+
+    # Créer un gestionnaire de statistiques
+    stats_manager = StatsManager(events)
+
+    # Appel des fonctions via le gestionnaire
+    home_possession, away_possession = stats_manager.get_possession()
+    home_xg, away_xg = stats_manager.get_total_xg()
+    home_shots, away_shots = stats_manager.get_total_shots()
+    home_off_target, away_off_target = stats_manager.get_total_shots_off_target()
+    home_on_target, away_on_target = stats_manager.get_total_shots_on_target()
+    home_passes, away_passes = stats_manager.get_total_passes()
+    home_successful_passes, away_successful_passes = stats_manager.get_successful_passes()
+    home_corners, away_corners = stats_manager.get_total_corners()
+    home_fouls, away_fouls = stats_manager.get_total_fouls()
+    home_yellow_cards, away_yellow_cards = stats_manager.get_total_yellow_cards()
+    home_red_cards, away_red_cards = stats_manager.get_total_red_cards()
+
+    # Créer la liste des scores, en excluant ceux qui ne peuvent pas être calculés
+    categories_scores = [
+        {"catégorie": "Possession de balle (%)", "Home Team": home_possession, "Away Team": away_possession},
+        {"catégorie": "xG (Buts attendus)", "Home Team": home_xg, "Away Team": away_xg},
+        {"catégorie": "Tirs", "Home Team": home_shots, "Away Team": away_shots},
+        {"catégorie": "Tirs cadrés", "Home Team": home_on_target, "Away Team": away_on_target},
+        {"catégorie": "Tirs non cadrés", "Home Team": home_off_target, "Away Team": away_off_target},
+        {"catégorie": "Passes", "Home Team": home_passes, "Away Team": away_passes},
+        {"catégorie": "Passes réussies", "Home Team": home_successful_passes, "Away Team": away_successful_passes},
+        {"catégorie": "Corners", "Home Team": home_corners, "Away Team": away_corners},
+        {"catégorie": "Fautes", "Home Team": home_fouls, "Away Team": away_fouls},
+        {"catégorie": "Cartons Jaunes", "Home Team": home_yellow_cards, "Away Team": away_yellow_cards},
+        {"catégorie": "Cartons Rouges", "Home Team": home_red_cards, "Away Team": away_red_cards},
+    ]
+
+    # Filtrer les catégories valides
+    categories_scores = [entry for entry in categories_scores if entry is not None]
+
+    # Extraire les catégories et scores
+    categories = [entry['catégorie'] for entry in categories_scores]
+    home_scores = [entry['Home Team'] for entry in categories_scores]
+    away_scores = [entry['Away Team'] for entry in categories_scores]
+
+    # Afficher le graphique
+    functions.display_normalized_scores(home_scores, away_scores, categories, home_color=home_color, away_color=away_color)
+
+
+
+    # st.image('img/logo_stade.png', width=200)  
+    pitch_color='#d2d2d2',
+    st.markdown(
+        f"""
+        <div style='text-align: center;'>
+            <span style='color: {home_color}; margin-right: 30px;'>{home_team} {home_score}</span>
+            <span style='margin-right: 30px;'>-</span>
+            <span style='color: {away_color};'>{away_score} {away_team}</span>
+        </div>
+        <div style='text-align: center;'>
+            <span style='color: {pitch_color}; margin-right: 30px;'>{home_tactic_formation}</span>
+            <span style='margin-right: 30px;'> </span>
+            <span style='color: {pitch_color};'>{away_tactic_formation}</span>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+
+    col21, col22 = st.columns([1,1])
+
+    position_id_to_coordinates_home = clp.initial_player_position_allpitch_home
+    position_id_to_coordinates_away = clp.initial_player_position_allpitch_away
+    # functions.display_player_names_and_positions_twoTeam(home_lineups, away_lineups, position_id_to_coordinates_home, position_id_to_coordinates_away)
+    
+    with open('data/club.json', encoding='utf-8') as f:
+        images_data = json.load(f) 
+
+    # Integrate club logo
+    home_team_image = functions.get_best_match_image(home_team, images_data)
+    away_team_image = functions.get_best_match_image(away_team, images_data)
+
+
+    with col21:
+
+        # if home_team_image:
+        #     st.image(home_team_image)
+
+        functions.display_player_names_and_positions_oneTeam(home_lineups, position_id_to_coordinates_home, home_color)
+
+        st.markdown(
+            f"""
+            <div style='text-align: center;'>
+                <span style='color: {home_color}; margin-right: 30px;'>{selected_one_team_matches['home_managers'].iloc[0]}</span>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )     
+
+    with col22:
+
+        # if away_team_image:
+        #     st.image(away_team_image)
+
+        functions.display_player_names_and_positions_oneTeam(away_lineups, position_id_to_coordinates_away,away_color)
+   
+        st.markdown(
+            f"""
+            <div style='text-align: center;'>
+                <span style='color: {away_color}; margin-right: 30px;'>{selected_one_team_matches['away_managers'].iloc[0]}</span>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )        
+
+
+
+
+
+
+
+def ensure_3d_coordinates(coord):
+    if len(coord) == 2:
+        return coord + [0]
+    return coord
+
+shot_events = events.filter(regex='^(shot|location|team)').dropna(how='all')
+shot_events_location = shot_events[shot_events['shot_end_location'].notna()]
+
+shot_events_location['location'] = shot_events_location['location'].apply(ensure_3d_coordinates)
+shot_events_location['shot_end_location'] = shot_events_location['shot_end_location'].apply(ensure_3d_coordinates)
+
+start_points = shot_events_location['location'].tolist()
+end_points = shot_events_location['shot_end_location'].tolist()
+
+st.write(shot_events_location)
+
+Pitch3D.main_3D_pitch(start_points,end_points)

config_location_player.py

@@ -0,0 +1,77 @@
+
+pitch_width = 120
+pitch_height = 80
+nb_line = 7
+space_line = (pitch_width/2)/7
+x_line1 = 5
+
+x_lines = [x_line1 + i * space_line for i in range(7)]
+initial_player_position_middlepitch_home = {
+    1: (x_lines[0], 40),
+    2: (x_lines[1], 70),
+    3: (x_lines[1], 55),
+    4: (x_lines[1], 40),
+    5: (x_lines[1], 25),
+    6: (x_lines[1], 10),
+    7: (x_lines[2], 70),
+    8: (x_lines[2], 10),
+    9: (x_lines[2], 55),
+    10: (x_lines[2], 40),
+    11: (x_lines[2], 25),
+    12: (x_lines[3], 70),
+    13: (x_lines[3], 55),
+    14: (x_lines[3], 40),
+    15: (x_lines[3], 25),
+    16: (x_lines[3], 10),
+    17: (x_lines[4], 70),
+    18: (x_lines[4], 55),
+    19: (x_lines[4], 40),
+    20: (x_lines[4], 25),
+    21: (x_lines[4], 10),
+    22: (x_lines[6], 55),
+    23: (x_lines[6], 40),
+    24: (x_lines[6], 25),
+    25: (x_lines[5], 40)
+}
+
+initial_player_position_middlepitch_away = {
+    position_id: (pitch_width - x, y)
+    for position_id, (x, y) in initial_player_position_middlepitch_home.items()
+}
+
+ 
+
+space_line = (pitch_width*0.8)/7
+x_lines = [x_line1 + i * space_line for i in range(7)]
+initial_player_position_allpitch_home = {
+    1: (x_lines[0], 40),
+    2: (x_lines[1], 70),
+    3: (x_lines[1], 55),
+    4: (x_lines[1], 40),
+    5: (x_lines[1], 25),
+    6: (x_lines[1], 10),
+    7: (x_lines[2], 70),
+    8: (x_lines[2], 10),
+    9: (x_lines[2], 55),
+    10: (x_lines[2], 40),
+    11: (x_lines[2], 25),
+    12: (x_lines[3], 70),
+    13: (x_lines[3], 55),
+    14: (x_lines[3], 40),
+    15: (x_lines[3], 25),
+    16: (x_lines[3], 10),
+    17: (x_lines[4], 70),
+    18: (x_lines[4], 55),
+    19: (x_lines[4], 40),
+    20: (x_lines[4], 25),
+    21: (x_lines[4], 10),
+    22: (x_lines[6], 55),
+    23: (x_lines[6], 40),
+    24: (x_lines[6], 25),
+    25: (x_lines[5], 40)
+}
+
+initial_player_position_allpitch_away = {
+    position_id: (pitch_width - x, y)
+    for position_id, (x, y) in initial_player_position_allpitch_home.items()
+}

functions.py

@@ -0,0 +1,689 @@
+from mplsoccer import Pitch
+import streamlit as st
+import requests
+from bs4 import BeautifulSoup
+from fuzzywuzzy import fuzz, process
+import plotly.express as px 
+import numpy as np
+import matplotlib.pyplot as plt
+import streamlit as st
+
+def display_player_names_and_positions_middlePitch(home_lineups, away_lineups, position_id_to_coordinates_home, position_id_to_coordinates_away):
+    # Dictionaries to store coordinates and player names for both home and away teams
+    coordinates_dict_home = {}
+    player_names_dict_home = {}
+    coordinates_dict_away = {}
+    player_names_dict_away = {}
+
+    # Process home team lineup
+    for index, row in home_lineups.iterrows():
+        player_name = row['player_name']
+        position_info = row['positions'][0] if row['positions'] else {}
+        position_id = position_info.get('position_id', 'Unknown')
+
+        if position_id in position_id_to_coordinates_home:
+            coordinates_dict_home[position_id] = position_id_to_coordinates_home[position_id]
+            player_names_dict_home[position_id] = player_name
+
+    # Process away team lineup
+    for index, row in away_lineups.iterrows():
+        player_name = row['player_name']
+        position_info = row['positions'][0] if row['positions'] else {}
+        position_id = position_info.get('position_id', 'Unknown')
+
+        if position_id in position_id_to_coordinates_away:
+            coordinates_dict_away[position_id] = position_id_to_coordinates_away[position_id]
+            player_names_dict_away[position_id] = player_name
+
+    # Plotting the pitch
+    pitch = Pitch(
+        # pitch_color='#1f77b4', 
+        pitch_color='#d2d2d2', 
+        line_color='white', 
+        stripe=False, 
+        pitch_type='statsbomb'
+    )
+
+    fig, ax = pitch.draw()
+
+    # Plotting home team positions
+    if coordinates_dict_home:
+        x_coords_home, y_coords_home = zip(*coordinates_dict_home.values())
+        ax.scatter(x_coords_home, y_coords_home, color='red', s=300, edgecolors='white', zorder=3)
+
+        for position_id, (x, y) in coordinates_dict_home.items():
+            name = player_names_dict_home.get(position_id, "Unknown")
+            ax.text(x, y - 4, f'{name.split()[-1]}', color='black', ha='center', va='center', fontsize=12, zorder=6)
+
+    # Plotting away team positions
+    if coordinates_dict_away:
+        x_coords_away, y_coords_away = zip(*coordinates_dict_away.values())
+        ax.scatter(x_coords_away, y_coords_away, color='blue', s=300, edgecolors='white', zorder=3)
+
+        for position_id, (x, y) in coordinates_dict_away.items():
+            name = player_names_dict_away.get(position_id, "Unknown")
+            ax.text(x, y - 4, f'{name.split()[-1]}', color='black', ha='center', va='center', fontsize=12, zorder=6)
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+
+
+def display_player_names_and_positions_twoTeam(home_lineups, away_lineups, position_id_to_coordinates_home, position_id_to_coordinates_away):
+    # Dictionaries to store coordinates and player names for both home and away teams
+    coordinates_dict_home = {}
+    player_names_dict_home = {}
+    coordinates_dict_away = {}
+    player_names_dict_away = {}
+
+    # Process home team lineup
+    for index, row in home_lineups.iterrows():
+        player_name = row['player_name']
+        position_info = row['positions'][0] if row['positions'] else {}
+        position_id = position_info.get('position_id', 'Unknown')
+
+        if position_id in position_id_to_coordinates_home:
+            coordinates_dict_home[position_id] = position_id_to_coordinates_home[position_id]
+            player_names_dict_home[position_id] = player_name
+
+    # Process away team lineup
+    for index, row in away_lineups.iterrows():
+        player_name = row['player_name']
+        position_info = row['positions'][0] if row['positions'] else {}
+        position_id = position_info.get('position_id', 'Unknown')
+
+        if position_id in position_id_to_coordinates_away:
+            coordinates_dict_away[position_id] = position_id_to_coordinates_away[position_id]
+            player_names_dict_away[position_id] = player_name
+
+    # Plotting the pitch
+    pitch = Pitch(
+        # pitch_color='#1f77b4', 
+        pitch_color='#d2d2d2', 
+        line_color='white', 
+        stripe=False, 
+        pitch_type='statsbomb'
+    )
+
+    fig, ax = pitch.draw()
+
+    # Plotting home team positions
+    if coordinates_dict_home:
+        x_coords_home, y_coords_home = zip(*coordinates_dict_home.values())
+        ax.scatter(x_coords_home, y_coords_home, color='red', s=300, edgecolors='white', zorder=3)
+
+        for position_id, (x, y) in coordinates_dict_home.items():
+            name = player_names_dict_home.get(position_id, "Unknown")
+            ax.text(x, y - 4, f'{name.split()[-1]}', color='black', ha='center', va='center', fontsize=12, zorder=6)
+
+    # Plotting away team positions
+    if coordinates_dict_away:
+        x_coords_away, y_coords_away = zip(*coordinates_dict_away.values())
+        ax.scatter(x_coords_away, y_coords_away, color='blue', s=300, edgecolors='white', zorder=3)
+
+        for position_id, (x, y) in coordinates_dict_away.items():
+            name = player_names_dict_away.get(position_id, "Unknown")
+            ax.text(x, y - 4, f'{name.split()[-1]}', color='black', ha='center', va='center', fontsize=12, zorder=6)
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+
+
+
+
+
+
+def display_player_names_and_positions_oneTeam(home_lineups, position_id_to_coordinates_home,color):
+    # Dictionaries to store coordinates and player names for the home team
+    coordinates_dict_home = {}
+    player_names_dict_home = {}
+
+    # Process home team lineup
+    for index, row in home_lineups.iterrows():
+        player_name = row['player_name']
+        position_info = row['positions'][0] if row['positions'] else {}
+        position_id = position_info.get('position_id', 'Unknown')
+
+        if position_id in position_id_to_coordinates_home:
+            coordinates_dict_home[position_id] = position_id_to_coordinates_home[position_id]
+            player_names_dict_home[position_id] = player_name
+
+    # Plotting the pitch
+    pitch = Pitch(
+        pitch_color='#d2d2d2',
+        line_color='white',
+        stripe=False,
+        pitch_type='statsbomb'
+    )
+
+    fig, ax = pitch.draw()
+
+    # Plotting home team positions
+    if coordinates_dict_home:
+        x_coords_home, y_coords_home = zip(*coordinates_dict_home.values())
+        ax.scatter(x_coords_home, y_coords_home, color=color, s=300, edgecolors='white', zorder=3)
+
+        for position_id, (x, y) in coordinates_dict_home.items():
+            name = player_names_dict_home.get(position_id, "Unknown")
+            ax.text(x, y - 4, f'{name.split()[-1]}', color='black', ha='center', va='center', fontsize=12, zorder=6)
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+
+
+
+# Function to find the best image match based on the team name
+def get_best_match_image(team_name, images_data):
+    image_names = [image['image_name'] for image in images_data]
+    best_match, match_score = process.extractOne(team_name, image_names, scorer=fuzz.token_sort_ratio)
+    if match_score > 70:  # Adjust the threshold as needed
+        for image in images_data:
+            if image['image_name'] == best_match:
+                return image['image_link']
+    return None
+
+
+
+
+
+
+
+
+
+
+
+
+
+class StadiumImageFetcher:
+    def __init__(self):
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+        }
+
+    def get_stadium_image_url(self, stadium_name):
+        # Formulate the Google Image search URL
+        query = stadium_name.replace(' ', '+')
+        url = f"https://www.google.com/search?hl=en&tbm=isch&q={query}"
+        
+        # Send the request
+        response = requests.get(url, headers=self.headers)
+        
+        # Parse the HTML content using BeautifulSoup
+        soup = BeautifulSoup(response.text, 'lxml')
+        
+        # Find the first image result
+        images = soup.find_all('img')
+        
+        if images and len(images) > 1:  # The first image might be the Google logo, so skip it
+            return images[1]['src']
+        else:
+            return None
+
+    def display_stadium(self):
+        st.title("Stadium Image Display")
+
+        # Input the stadium name
+        stadium_name = st.text_input("Enter the stadium name:")
+        
+        if stadium_name:
+            # Get the image URL
+            image_url = self.get_stadium_image_url(stadium_name)
+            
+            if image_url:
+                st.image(image_url, caption=f'{stadium_name} Stadium')
+            else:
+                st.write("Image not found.")
+
+def main_stadium():
+    stadium = StadiumImageFetcher()
+    stadium.display_stadium()
+
+
+
+
+def box_plot_pass(events,team):
+
+    event_filterTeam = events[events['team']==team]
+    event_pass = event_filterTeam.filter(regex='^(pass)', axis=1).dropna(how='all')
+    event_pass_length = event_pass['pass_length']
+
+    fig = px.box(event_pass_length, y=event_pass_length, labels={'y':'Pass Length'}, title=f'{team} Distribution of Pass Length')
+    fig.update_layout(width=300, height=600)  # 200 pixels de largeur, 400 pixels de hauteur
+
+    # Afficher le graphique dans Streamlit
+    st.plotly_chart(fig)
+
+
+
+
+
+
+
+
+
+
+
+
+# def get_possession(events):
+#     """
+#     Extracts and normalizes the possession counts for the two teams from the events DataFrame.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame containing an events column 'possession_team'.
+
+#     Returns:
+#     - home_team_possession (float): Normalized possession percentage for the home team, rounded to one decimal place.
+#     - away_team_possession (float): Normalized possession percentage for the away team, rounded to one decimal place.
+#     """
+#     # Get possession counts
+#     possession_counts = events['possession_team'].value_counts()
+    
+#     # Get the top two possession teams
+#     home_team_possession, away_team_possession = possession_counts.iloc[0], possession_counts.iloc[1]
+    
+#     # Calculate total possession
+#     total_possession = home_team_possession + away_team_possession
+    
+#     # Normalize possession and round to one decimal place
+#     home_team_possession = round((home_team_possession / total_possession) * 100, 1)
+#     away_team_possession = round((away_team_possession / total_possession) * 100, 1)
+    
+#     return home_team_possession, away_team_possession
+
+
+
+# def get_total_xg(events):
+#     """
+#     Calcule la somme totale des xG (expected goals) par équipe et retourne les valeurs arrondies à 2 décimales.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'shot_statsbomb_xg' et 'team'.
+
+#     Returns:
+#     - home_xg (float): Somme totale des xG pour l'équipe à domicile, arrondie à 2 décimales.
+#     - away_xg (float): Somme totale des xG pour l'équipe à l'extérieur, arrondie à 2 décimales.
+#     """
+#     # Filtrer les colonnes et supprimer les lignes où 'shot_statsbomb_xg' est NaN
+#     data = events.filter(regex='^shot_statsbomb_xg|^team$').dropna(subset=['shot_statsbomb_xg'])
+    
+#     # Grouper par 'team' et calculer la somme des xG
+#     data = data.groupby('team')['shot_statsbomb_xg'].sum()
+    
+#     # Arrondir les résultats à 2 décimales
+#     home_xg, away_xg = round(data.iloc[0], 2), round(data.iloc[1], 2)
+    
+#     return home_xg, away_xg
+
+# def get_total_shots(events):
+#     """
+#     Calcule le nombre total de tirs (shots) par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'shot_statsbomb_xg' et 'team'.
+
+#     Returns:
+#     - home_shots (int): Nombre total de tirs pour l'équipe à domicile.
+#     - away_shots (int): Nombre total de tirs pour l'équipe à l'extérieur.
+#     """
+#     # Filtrer les colonnes et supprimer les lignes où 'shot_statsbomb_xg' est NaN
+#     data = events.filter(regex='^shot_statsbomb_xg|^team$').dropna(subset=['shot_statsbomb_xg'])
+    
+#     # Grouper par 'team' et compter le nombre de tirs
+#     shot_counts = data.groupby('team').count()['shot_statsbomb_xg']
+    
+#     # Retourner les comptes pour les deux équipes
+#     home_shots, away_shots = shot_counts.iloc[0], shot_counts.iloc[1]
+    
+#     return home_shots, away_shots
+
+
+# def get_total_shots_off_target(events):
+#     """
+#     Calcule le nombre total de tirs non cadrés (off target) par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'shot_outcome' et 'team'.
+
+#     Returns:
+#     - home_off_target (int): Nombre total de tirs non cadrés pour l'équipe à domicile.
+#     - away_off_target (int): Nombre total de tirs non cadrés pour l'équipe à l'extérieur.
+#     """
+#     # Define outcomes that indicate a shot was off target
+#     off_target_outcomes = ['Off T', 'Blocked', 'Missed']
+    
+#     # Filter the events DataFrame for shots off target
+#     data = events[events['shot_outcome'].isin(off_target_outcomes)]
+    
+#     # Group by 'team' and count the number of off-target shots
+#     off_target_counts = data.groupby('team').size()
+    
+#     # Return the counts for the two teams
+#     home_off_target, away_off_target = off_target_counts.iloc[0], off_target_counts.iloc[1]
+    
+#     return home_off_target, away_off_target
+
+
+# def get_total_shots_on_target(events):
+#     """
+#     Calcule le nombre total de tirs cadrés (on target) par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'shot_outcome' et 'team'.
+
+#     Returns:
+#     - home_on_target (int): Nombre total de tirs cadrés pour l'équipe à domicile.
+#     - away_on_target (int): Nombre total de tirs cadrés pour l'équipe à l'extérieur.
+#     """
+#     # Define outcomes that indicate a shot was on target
+#     on_target_outcomes = ['Goal', 'Saved', 'Saved To Post', 'Shot Saved Off Target']
+    
+#     # Filter the events DataFrame for shots on target
+#     data = events[events['shot_outcome'].isin(on_target_outcomes)]
+    
+#     # Group by 'team' and count the number of on-target shots
+#     on_target_counts = data.groupby('team').size()
+    
+#     # Return the counts for the two teams
+#     home_on_target, away_on_target = on_target_counts.iloc[0], on_target_counts.iloc[1]
+    
+#     return home_on_target, away_on_target
+
+
+
+# def get_total_passes(events):
+#     """
+#     Calcule le nombre total de passes par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'pass_outcome' et 'team'.
+
+#     Returns:
+#     - home_passes (int): Nombre total de passes pour l'équipe à domicile.
+#     - away_passes (int): Nombre total de passes pour l'équipe à l'extérieur.
+#     """
+#     # Filtrer les colonnes 'pass_outcome' et 'team', puis grouper par équipe et compter le nombre de passes
+#     pass_counts = events.filter(regex='^pass_end_location|^team$').groupby('team').count()['pass_end_location']
+    
+#     # Retourner les comptes pour les deux équipes
+#     home_passes, away_passes = pass_counts.iloc[0], pass_counts.iloc[1]
+    
+#     return home_passes, away_passes
+
+# def get_successful_passes(events):
+#     """
+#     Calculates the total number of successful passes for home and away teams.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame containing the columns for all passes and pass outcomes.
+
+#     Returns:
+#     - home_successful_passes (int): Successful passes for the home team.
+#     - away_successful_passes (int): Successful passes for the away team.
+#     """
+#     # Get the total passes using the get_total_passes function
+#     home_passes, away_passes = get_total_passes(events)
+    
+#     # Identify unsuccessful passes based on 'type' or another column indicating unsuccessful outcomes
+#     unsuccessful_passes = events.filter(regex='^pass_outcome|^team$').groupby('team').count().reset_index()['pass_outcome']
+    
+#     # Calculate successful passes by subtracting unsuccessful passes from total passes
+#     home_unsuccessful_passes = unsuccessful_passes.iloc[0]
+#     away_unsuccessful_passes = unsuccessful_passes.iloc[1]
+    
+#     home_successful_passes = home_passes - home_unsuccessful_passes
+#     away_successful_passes = away_passes - away_unsuccessful_passes
+    
+#     return home_successful_passes, away_successful_passes
+
+# def get_total_corners(events):
+#     """
+#     Calcule le nombre total de corners par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'pass_type' et 'team'.
+
+#     Returns:
+#     - home_corners (int): Nombre total de corners pour l'équipe à domicile.
+#     - away_corners (int): Nombre total de corners pour l'équipe à l'extérieur.
+#     """
+#     # Filtrer les colonnes 'pass_type' et 'team', puis grouper par équipe et compter le nombre de corners
+#     corner_counts = events.filter(regex='^pass_type|^team$').query('pass_type == "Corner"').groupby('team').count()['pass_type']
+    
+#     # Extract the team names from the events DataFrame
+#     teams = events['team'].unique()
+    
+#     # Handle cases where a team might not have any corners
+#     home_corners = corner_counts.get(teams[0], 0)
+#     away_corners = corner_counts.get(teams[1], 0)
+    
+#     return home_corners, away_corners
+
+
+
+# def get_total_fouls(events):
+#     """
+#     Calcule le nombre total de fautes par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'team' et 'type'.
+
+#     Returns:
+#     - home_fouls (int): Nombre total de fautes pour l'équipe à domicile.
+#     - away_fouls (int): Nombre total de fautes pour l'équipe à l'extérieur.
+#     """
+#     fouls = events[events['type'] == 'Foul Committed']
+#     foul_counts = fouls.groupby('team').size()
+#     home_fouls, away_fouls = foul_counts.iloc[0], foul_counts.iloc[1]
+    
+#     return home_fouls, away_fouls
+
+
+
+# def get_total_yellow_cards(events):
+#     """
+#     Calcule le nombre total de cartons jaunes par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'bad_behaviour_card' et 'team'.
+
+#     Returns:
+#     - home_yellow_cards (int): Nombre total de cartons jaunes pour l'équipe à domicile.
+#     - away_yellow_cards (int): Nombre total de cartons jaunes pour l'équipe à l'extérieur.
+#     """
+#     # Filtrer les colonnes 'bad_behaviour_card' et 'team', puis grouper par équipe et compter le nombre de cartons jaunes
+#     yellow_card_counts = events.filter(regex='^bad_behaviour_card|^team$').query('bad_behaviour_card == "Yellow Card"').groupby('team').count()['bad_behaviour_card']
+    
+#     # Extraire les noms des équipes de l'événement DataFrame
+#     teams = events['team'].unique()
+    
+#     # Gérer les cas où une équipe pourrait ne pas avoir de cartons jaunes
+#     home_yellow_cards = yellow_card_counts.get(teams[0], 0)
+#     away_yellow_cards = yellow_card_counts.get(teams[1], 0)
+    
+#     return home_yellow_cards, away_yellow_cards
+
+# def get_total_red_cards(events):
+#     """
+#     Calcule le nombre total de cartons rouges par équipe.
+
+#     Parameters:
+#     - events (pd.DataFrame): DataFrame contenant les colonnes 'bad_behaviour_card' et 'team'.
+
+#     Returns:
+#     - home_red_cards (int): Nombre total de cartons rouges pour l'équipe à domicile.
+#     - away_red_cards (int): Nombre total de cartons rouges pour l'équipe à l'extérieur.
+#     """
+#     # Filtrer les colonnes 'bad_behaviour_card' et 'team', puis grouper par équipe et compter le nombre de cartons rouges
+#     red_card_counts = events.filter(regex='^bad_behaviour_card|^team$').query('bad_behaviour_card == "Red Card"').groupby('team').count()['bad_behaviour_card']
+    
+#     # Extraire les noms des équipes de l'événement DataFrame
+#     teams = events['team'].unique()
+    
+#     # Gérer les cas où une équipe pourrait ne pas avoir de cartons rouges
+#     home_red_cards = red_card_counts.get(teams[0], 0)
+#     away_red_cards = red_card_counts.get(teams[1], 0)
+    
+#     return home_red_cards, away_red_cards
+
+
+
+
+# def display_normalized_scores(home_scores, away_scores, categories, home_color='blue', away_color='green', background_color='lightgray', bar_height=0.8, spacing_factor=2.5):
+#     """
+#     Displays a horizontal bar chart with normalized scores for home and away teams.
+
+#     Parameters:
+#     - home_scores: List of scores for the home team.
+#     - away_scores: List of scores for the away team.
+#     - categories: List of category names for each score.
+#     - home_color: Color of the bars representing the home team.
+#     - away_color: Color of the bars representing the away team.
+#     - background_color: Color of the background rectangles.
+#     - bar_height: Height of the bars and background rectangles.
+#     - spacing_factor: Factor to adjust the spacing between bars.
+#     """
+
+#     # Internal container size variables
+#     container_width = '50%'  # Adjust width as needed
+#     container_height = 'auto'  # Adjust height as needed
+
+#     # Normalizing the scores
+#     home_normalized = []
+#     away_normalized = []
+#     for home, away in zip(home_scores, away_scores):
+#         total = home + away
+#         if total != 0:
+#             home_normalized.append((home / total) * 100)
+#             away_normalized.append((away / total) * 100)
+#         else:
+#             home_normalized.append(0)
+#             away_normalized.append(0)
+
+#     # Augmenting the spacing between the bars by multiplying y_pos by a factor
+#     y_pos = np.arange(len(categories)) * spacing_factor
+
+#     # Plot
+#     fig, ax = plt.subplots(figsize=(10, 8))
+
+#     # Adding light gray backgrounds for each category with the same height as the bars
+#     for i in range(len(categories)):
+#         ax.add_patch(plt.Rectangle((-100, y_pos[i] - bar_height / 2), 200, bar_height, color=background_color, alpha=0.3, linewidth=0))
+
+#     # Plotting normalized scores for both teams
+#     ax.barh(y_pos, home_normalized, height=bar_height, color=home_color, align='center', label='Home Team')
+#     ax.barh(y_pos, [-score for score in away_normalized], height=bar_height, color=away_color, align='center', label='Away Team')
+
+#     # Positioning the category names above the bars to avoid overlap
+#     for i in range(len(categories)):
+#         ax.text(0, y_pos[i] + bar_height / 2 + 0.1, categories[i], ha='center', va='bottom', fontsize=10)
+
+#     # Adding non-normalized values to the end of the bars
+#     for i in range(len(categories)):
+#         ax.text(home_normalized[i] / 2, y_pos[i], f'{home_scores[i]}', va='center', color='white', fontweight='bold')
+#         ax.text(-away_normalized[i] / 2, y_pos[i], f'{away_scores[i]}', va='center', color='white', fontweight='bold')
+
+#     # Adjusting the axis limits
+#     ax.set_xlim(-100, 100)
+#     ax.set_ylim(-1, max(y_pos) + spacing_factor)
+
+#     # Hiding the spines
+#     for spine in ax.spines.values():
+#         spine.set_visible(False)
+
+#     # Removing y-ticks and x-ticks
+#     ax.set_yticks([])
+#     ax.set_xticks([])
+
+#     # Custom HTML/CSS to control the size of the container
+#     st.markdown(
+#         f"""
+#         <style>
+#         .resizable-graph-container {{
+#             width: {container_width}; /* Adjust the width as needed */
+#             height: {container_height}; /* Adjust the height as needed */
+#             padding: 10px;
+#             overflow: auto; /* Handle overflow if the graph is larger than the container */
+#         }}
+#         </style>
+#         <div class="resizable-graph-container">
+#         """,
+#         unsafe_allow_html=True
+#     )
+
+#     # Displaying the plot in Streamlit
+#     st.pyplot(fig)
+
+#     # Closing the custom container
+#     st.markdown('</div>', unsafe_allow_html=True)
+
+
+def display_normalized_scores(home_scores, away_scores, categories, home_color='blue', away_color='green', background_color='lightgray', bar_height=0.8, spacing_factor=2.5):
+    """
+    Displays a horizontal bar chart with normalized scores for home and away teams.
+
+    Parameters:
+    - home_scores: List of scores for the home team.
+    - away_scores: List of scores for the away team.
+    - categories: List of category names for each score.
+    - home_color: Color of the bars representing the home team.
+    - away_color: Color of the bars representing the away team.
+    - background_color: Color of the background rectangles.
+    - bar_height: Height of the bars and background rectangles.
+    - spacing_factor: Factor to adjust the spacing between bars.
+    """
+
+    # Normalizing the scores
+    home_normalized = []
+    away_normalized = []
+    for home, away in zip(home_scores, away_scores):
+        # Remplacer les None par 0 pour éviter les erreurs
+        home = 0 if home is None else home
+        away = 0 if away is None else away
+        
+        total = home + away
+        if total != 0:
+            home_normalized.append((home / total) * 100)
+            away_normalized.append((away / total) * 100)
+        else:
+            home_normalized.append(0)
+            away_normalized.append(0)
+
+    # Augmenting the spacing between the bars by multiplying y_pos by a factor
+    y_pos = np.arange(len(categories)) * spacing_factor
+
+    # Plot
+    fig, ax = plt.subplots(figsize=(10, 8))
+
+    # Adding light gray backgrounds for each category with the same height as the bars
+    for i in range(len(categories)):
+        ax.add_patch(plt.Rectangle((-100, y_pos[i] - bar_height / 2), 200, bar_height, color=background_color, alpha=0.3, linewidth=0))
+
+    # Plotting normalized scores for both teams
+    ax.barh(y_pos, home_normalized, height=bar_height, color=home_color, align='center', label='Home Team')
+    ax.barh(y_pos, [-score for score in away_normalized], height=bar_height, color=away_color, align='center', label='Away Team')
+
+    # Positioning the category names above the bars to avoid overlap
+    for i in range(len(categories)):
+        ax.text(0, y_pos[i] + bar_height / 2 + 0.1, categories[i], ha='center', va='bottom', fontsize=10)
+
+    # Adding non-normalized values to the end of the bars
+    for i in range(len(categories)):
+        ax.text(home_normalized[i] / 2, y_pos[i], f'{home_scores[i]}', va='center', color='white', fontweight='bold')
+        ax.text(-away_normalized[i] / 2, y_pos[i], f'{away_scores[i]}', va='center', color='white', fontweight='bold')
+
+    # Adjusting the axis limits
+    ax.set_xlim(-100, 100)
+    ax.set_ylim(-1, max(y_pos) + spacing_factor)
+
+    # Hiding the spines
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+
+    # Removing y-ticks and x-ticks
+    ax.set_yticks([])
+    ax.set_xticks([])
+
+    # Displaying the plot in Streamlit
+    st.pyplot(fig)

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+pandas
+plotly
+requests
+statsbombpy
+mplsoccer
+matplotlib

stats_manager.py

@@ -0,0 +1,154 @@
+import pandas as pd
+
+def check_columns(df, required_columns):
+    """
+    Vérifie si les colonnes requises sont présentes dans le DataFrame.
+    
+    Parameters:
+    - df (pd.DataFrame): Le DataFrame à vérifier.
+    - required_columns (list): Liste des noms de colonnes requis.
+
+    Returns:
+    - bool: True si toutes les colonnes sont présentes, sinon False.
+    """
+    return all(column in df.columns for column in required_columns)
+
+class StatsManager:
+    def __init__(self, events):
+        self.events = events
+
+    def calculate_stat(self, required_columns, func):
+        """
+        Vérifie si les colonnes nécessaires sont présentes, puis applique la fonction de calcul si elles sont présentes.
+        
+        Parameters:
+        - required_columns (list): Liste des colonnes requises.
+        - func (callable): Fonction à appliquer si les colonnes sont présentes.
+        
+        Returns:
+        - tuple: Les résultats de la fonction si les colonnes sont présentes, sinon (None, None).
+        """
+        if check_columns(self.events, required_columns):
+            return func(self.events)
+        else:
+            return None, None
+
+    def get_possession(self):
+        return self.calculate_stat(['possession_team'], self._calculate_possession)
+
+    def _calculate_possession(self, events):
+        possession_counts = events['possession_team'].value_counts()
+        if len(possession_counts) < 2:
+            return None, None
+        total_possession = possession_counts.iloc[0] + possession_counts.iloc[1]
+        home_possession = round((possession_counts.iloc[0] / total_possession) * 100, 1)
+        away_possession = round((possession_counts.iloc[1] / total_possession) * 100, 1)
+        return home_possession, away_possession
+
+    def get_total_xg(self):
+        return self.calculate_stat(['shot_statsbomb_xg', 'team'], self._calculate_total_xg)
+
+    def _calculate_total_xg(self, events):
+        data = events[['shot_statsbomb_xg', 'team']].dropna(subset=['shot_statsbomb_xg'])
+        if data.empty:
+            return None, None
+        data = data.groupby('team')['shot_statsbomb_xg'].sum()
+        if len(data) < 2:
+            return None, None
+        return round(data.iloc[0], 2), round(data.iloc[1], 2)
+
+    def get_total_shots(self):
+        return self.calculate_stat(['shot_statsbomb_xg', 'team'], self._calculate_total_shots)
+
+    def _calculate_total_shots(self, events):
+        data = events[['shot_statsbomb_xg', 'team']].dropna(subset=['shot_statsbomb_xg'])
+        if data.empty:
+            return None, None
+        shot_counts = data.groupby('team').count()['shot_statsbomb_xg']
+        if len(shot_counts) < 2:
+            return None, None
+        return shot_counts.iloc[0], shot_counts.iloc[1]
+
+    def get_total_shots_off_target(self):
+        return self.calculate_stat(['shot_outcome', 'team'], self._calculate_total_shots_off_target)
+
+    def _calculate_total_shots_off_target(self, events):
+        off_target_outcomes = ['Off T', 'Blocked', 'Missed']
+        data = events[events['shot_outcome'].isin(off_target_outcomes)]
+        if data.empty:
+            return None, None
+        off_target_counts = data.groupby('team').size()
+        if len(off_target_counts) < 2:
+            return None, None
+        return off_target_counts.iloc[0], off_target_counts.iloc[1]
+
+    def get_total_shots_on_target(self):
+        return self.calculate_stat(['shot_outcome', 'team'], self._calculate_total_shots_on_target)
+
+    def _calculate_total_shots_on_target(self, events):
+        on_target_outcomes = ['Goal', 'Saved', 'Saved To Post', 'Shot Saved Off Target']
+        data = events[events['shot_outcome'].isin(on_target_outcomes)]
+        if data.empty:
+            return None, None
+        on_target_counts = data.groupby('team').size()
+        if len(on_target_counts) < 2:
+            return None, None
+        return on_target_counts.iloc[0], on_target_counts.iloc[1]
+
+    def get_total_passes(self):
+        return self.calculate_stat(['pass_end_location', 'team'], self._calculate_total_passes)
+
+    def _calculate_total_passes(self, events):
+        pass_counts = events.filter(regex='^pass_end_location|^team$').groupby('team').count()['pass_end_location']
+        if len(pass_counts) < 2:
+            return None, None
+        return pass_counts.iloc[0], pass_counts.iloc[1]
+
+    def get_successful_passes(self):
+        return self.calculate_stat(['pass_outcome', 'team'], self._calculate_successful_passes)
+
+    def _calculate_successful_passes(self, events):
+        home_passes, away_passes = self.get_total_passes()
+        unsuccessful_passes = events.filter(regex='^pass_outcome|^team$').groupby('team').count().reset_index()['pass_outcome']
+        if len(unsuccessful_passes) < 2:
+            return None, None
+        home_unsuccessful_passes = unsuccessful_passes.iloc[0]
+        away_unsuccessful_passes = unsuccessful_passes.iloc[1]
+        return home_passes - home_unsuccessful_passes, away_passes - away_unsuccessful_passes
+
+    def get_total_corners(self):
+        return self.calculate_stat(['pass_type', 'team'], self._calculate_total_corners)
+
+    def _calculate_total_corners(self, events):
+        corner_counts = events.filter(regex='^pass_type|^team$').query('pass_type == "Corner"').groupby('team').count()['pass_type']
+        if len(corner_counts) < 2:
+            return None, None
+        return corner_counts.iloc[0], corner_counts.iloc[1]
+
+    def get_total_fouls(self):
+        return self.calculate_stat(['type', 'team'], self._calculate_total_fouls)
+
+    def _calculate_total_fouls(self, events):
+        fouls = events[events['type'] == 'Foul Committed']
+        foul_counts = fouls.groupby('team').size()
+        if len(foul_counts) < 2:
+            return None, None
+        return foul_counts.iloc[0], foul_counts.iloc[1]
+
+    def get_total_yellow_cards(self):
+        return self.calculate_stat(['bad_behaviour_card', 'team'], self._calculate_total_yellow_cards)
+
+    def _calculate_total_yellow_cards(self, events):
+        yellow_card_counts = events.filter(regex='^bad_behaviour_card|^team$').query('bad_behaviour_card == "Yellow Card"').groupby('team').count()['bad_behaviour_card']
+        if len(yellow_card_counts) < 2:
+            return None, None
+        return yellow_card_counts.iloc[0], yellow_card_counts.iloc[1]
+
+    def get_total_red_cards(self):
+        return self.calculate_stat(['bad_behaviour_card', 'team'], self._calculate_total_red_cards)
+
+    def _calculate_total_red_cards(self, events):
+        red_card_counts = events.filter(regex='^bad_behaviour_card|^team$').query('bad_behaviour_card == "Red Card"').groupby('team').count()['bad_behaviour_card']
+        if len(red_card_counts) < 2:
+            return None, None
+        return red_card_counts.iloc[0], red_card_counts.iloc[1]