Update pages/2_Player_Comparison_Throw_Image.py

pages/2_Player_Comparison_Throw_Image.py

@@ -2,87 +2,55 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import cv2
+import joblib
 from PIL import Image
-import pickle
 import plotly.express as px
 
-# Load Haar Cascade for face detection
-face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-
-# Load model
+# Load models and data
 @st.cache_resource
 def load_model():
-    with open("final_model (2).pkl", "rb") as f:
-        return pickle.load(f)
+    return joblib.load("svc_face_classifier(1).pkl")
+
+@st.cache_resource
+def load_label_encoder():
+    return joblib.load("label_encoder.pkl")
 
-# Load player stats data
 @st.cache_data
 def load_data():
     return pd.read_csv("Final_Data.csv")
 
-# Find the image size (width x height) that gives the expected number of pixels
-def get_target_shape(expected_features):
-    for h in range(100, 200):
-        for w in range(100, 200):
-            if h * w == expected_features:
-                return (w, h)  # OpenCV uses (width, height)
-    return None
-
-# Predict player name from image
-def detect_and_predict_face(image_file, model):
-    import cv2
-    import numpy as np
-    from PIL import Image
-
-    # Load image and convert to grayscale
-    image = Image.open(image_file).convert("RGB")
-    img_np = np.array(image)
-    gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+# Haar Cascade
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
 
-    # Detect face
+# Detect + Predict
+def detect_and_predict_face(image_file, model, label_encoder):
+    image = Image.open(image_file).convert("RGB")
+    gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+
     if len(faces) == 0:
         return None, "⚠️ No face detected!"
 
-    # Crop face
     x, y, w, h = faces[0]
     face = gray[y:y+h, x:x+w]
+    resized = cv2.resize(face, (64, 64))
+    flattened = resized.flatten().reshape(1, -1)
 
-    # Resize to match training dimensions: 113x109
-    resized_face = cv2.resize(face, (113, 109))  # width x height = 12289
-    flattened = resized_face.flatten().reshape(1, -1)
-
-    # Ensure shape matches exactly
-    expected_features = 12289
-    if flattened.shape[1] > expected_features:
-        flattened = flattened[:, :expected_features]
-    elif flattened.shape[1] < expected_features:
-        padding = expected_features - flattened.shape[1]
-        flattened = np.pad(flattened, ((0, 0), (0, padding)), mode='constant')
-
-    # Predict
-    pred_name = model.predict(flattened)[0]
+    pred_label = model.predict(flattened)[0]
+    pred_name = label_encoder.inverse_transform([pred_label])[0]
     return pred_name, None
 
+# Player stat functions
+def get_player_details(df, name):
+    return df[df['Player'] == name].iloc[0]
 
-
-
-
-# Get player details from the dataset
-def get_player_details(df, player_name):
-    return df[df['Player'] == player_name].iloc[0]
-
-# Plotting functions
 def plot_matches_pie(player_data):
     matches_stats = {
         'Format': ['Test', 'ODI', 'T20', 'IPL'],
         'Matches': [player_data['Matches_Test'], player_data['Matches_ODI'], player_data['Matches_T20'], player_data['Matches_IPL']]
     }
-    df_matches = pd.DataFrame(matches_stats)
-    fig = px.pie(df_matches, names='Format', values='Matches',
-                 title=f"🏏 {player_data['Player']} - Matches Played 🎯",
-                 hover_data=['Matches'])
-    fig.update_traces(textinfo='percent+label')
+    fig = px.pie(pd.DataFrame(matches_stats), names='Format', values='Matches',
+                 title=f"🏏 {player_data['Player']} - Matches Played 🎯")
     st.plotly_chart(fig)
 
 def plot_batting_stats(player_data):
@@ -95,10 +63,10 @@ def plot_batting_stats(player_data):
         'Strike Rate': [player_data['batting_SR_Test'], player_data['batting_SR_ODI'], player_data['batting_SR_T20'], player_data['batting_SR_IPL']]
     }
     df = pd.DataFrame(stats)
-    st.plotly_chart(px.bar(df, x='Format', y='Runs', title=f"🏃‍♂️ {player_data['Player']} - Runs Scored 💯", color='Format', text='Runs'))
-    st.plotly_chart(px.bar(df, x='Format', y='Average', title=f"📊 {player_data['Player']} - Batting Average ⭐", color='Format', text='Average'))
-    st.plotly_chart(px.bar(df, x='Format', y='Sixes', title=f"🔥 {player_data['Player']} - Sixes 🚀", color='Format', text='Sixes'))
-    st.plotly_chart(px.bar(df, x='Format', y='Fours', title=f"🎯 {player_data['Player']} - Fours ⚡", color='Format', text='Fours'))
+    st.plotly_chart(px.bar(df, x='Format', y='Runs', title=f"🏃‍♂️ {player_data['Player']} - Runs Scored 💯", text='Runs'))
+    st.plotly_chart(px.bar(df, x='Format', y='Average', title=f"📊 {player_data['Player']} - Batting Average ⭐", text='Average'))
+    st.plotly_chart(px.bar(df, x='Format', y='Sixes', title=f"🔥 {player_data['Player']} - Sixes 🚀", text='Sixes'))
+    st.plotly_chart(px.bar(df, x='Format', y='Fours', title=f"🎯 {player_data['Player']} - Fours ⚡", text='Fours'))
     st.plotly_chart(px.line(df, x='Format', y='Strike Rate', title=f"⚡ {player_data['Player']} - Strike Rate 🎯", markers=True, text='Strike Rate'))
 
 def plot_bowling_stats(player_data):
@@ -110,56 +78,53 @@ def plot_bowling_stats(player_data):
         'Strike Rate': [player_data['bowling_Test_SR'], player_data['bowling_ODI_SR'], player_data['bowling_T20_SR'], player_data['bowling_IPL_SR']]
     }
     df = pd.DataFrame(stats)
-    st.plotly_chart(px.bar(df, x='Format', y='Wickets', title=f"🎳 {player_data['Player']} - Wickets Taken 🏆", color='Format', text='Wickets'))
-    st.plotly_chart(px.bar(df, x='Format', y='Average', title=f"📈 {player_data['Player']} - Bowling Average 🌟", color='Format', text='Average'))
+    st.plotly_chart(px.bar(df, x='Format', y='Wickets', title=f"🎳 {player_data['Player']} - Wickets Taken 🏆", text='Wickets'))
+    st.plotly_chart(px.bar(df, x='Format', y='Average', title=f"📈 {player_data['Player']} - Bowling Average 🌟", text='Average'))
     st.plotly_chart(px.line(df, x='Format', y='Economy', title=f"💰 {player_data['Player']} - Economy Rate 📉", markers=True, text='Economy'))
     st.plotly_chart(px.line(df, x='Format', y='Strike Rate', title=f"⚡ {player_data['Player']} - Bowling Strike Rate 🎯", markers=True, text='Strike Rate'))
 
-# MAIN APP
+# Main Streamlit App
 def main():
-    st.set_page_config(page_title="Player Face Recognition & Stats Comparison", page_icon="📸", layout="wide")
     st.title("📸 Upload Two Player Images to Compare Stats")
 
     model = load_model()
+    label_encoder = load_label_encoder()
     df = load_data()
 
-    img1 = st.file_uploader("Upload Image for Player 1", type=["jpg", "jpeg", "png"], key="img1")
-    img2 = st.file_uploader("Upload Image for Player 2", type=["jpg", "jpeg", "png"], key="img2")
+    col1, col2 = st.columns(2)
+    img1 = col1.file_uploader("Upload Image for Player 1", type=["jpg", "jpeg", "png"], key="img1")
+    img2 = col2.file_uploader("Upload Image for Player 2", type=["jpg", "jpeg", "png"], key="img2")
 
     if img1 and img2:
         with st.spinner("Detecting and predicting players..."):
-            pred1, error1 = detect_and_predict_face(img1, model)
-            pred2, error2 = detect_and_predict_face(img2, model)
+            pred1, err1 = detect_and_predict_face(img1, model, label_encoder)
+            pred2, err2 = detect_and_predict_face(img2, model, label_encoder)
 
-        if error1:
-            st.error(f"Player 1: {error1}")
-        if error2:
-            st.error(f"Player 2: {error2}")
+        if err1: st.error(f"Player 1: {err1}")
+        if err2: st.error(f"Player 2: {err2}")
 
-        if not error1 and not error2:
+        if not err1 and not err2:
             st.success(f"✅ Predicted Players: {pred1} vs {pred2}")
-
             try:
-                p1_data = get_player_details(df, pred1)
-                p2_data = get_player_details(df, pred2)
+                p1 = get_player_details(df, pred1)
+                p2 = get_player_details(df, pred2)
 
                 col1, col2 = st.columns(2)
 
                 with col1:
                     st.header(f"📌 {pred1}")
-                    plot_matches_pie(p1_data)
-                    plot_batting_stats(p1_data)
-                    plot_bowling_stats(p1_data)
+                    plot_matches_pie(p1)
+                    plot_batting_stats(p1)
+                    plot_bowling_stats(p1)
 
                 with col2:
                     st.header(f"📌 {pred2}")
-                    plot_matches_pie(p2_data)
-                    plot_batting_stats(p2_data)
-                    plot_bowling_stats(p2_data)
+                    plot_matches_pie(p2)
+                    plot_batting_stats(p2)
+                    plot_bowling_stats(p2)
 
             except Exception as e:
-                st.error(f"❌ Player stats not found: {e}")
+                st.error(f"⚠️ Player stats not found: {e}")
 
 if __name__ == "__main__":
     main()
-