Player Comparison Visualizations

Player Comparison Charts in Baseball Analytics

Player comparison visualizations are essential tools in baseball analytics, enabling scouts, front office executives, coaches, and fans to evaluate players across multiple dimensions simultaneously. Effective comparison charts transform complex statistical data into intuitive visual formats that reveal patterns, similarities, and differentiating factors between players. From radar charts displaying multi-dimensional skill profiles to career trajectory plots showing development over time, these visualizations provide the analytical foundation for player evaluation, contract negotiations, trade decisions, and roster construction.

Understanding Player Comparison Visualizations

Player comparison charts serve multiple critical functions in baseball analytics. They enable rapid identification of players with similar skill sets for scouting and player acquisition, facilitate era-adjusted comparisons accounting for different offensive environments, support contract valuation by contextualizing performance against comparable players, and communicate complex analytical insights to non-technical stakeholders through intuitive visual formats.

The challenge in player comparison lies in baseball's multidimensional nature. A complete hitter evaluation requires assessing power, contact ability, plate discipline, speed, defensive value, and baserunning. Pitchers must be evaluated on velocity, command, pitch mix, deception, and durability. Single-number metrics like WAR provide overall value assessments but obscure the component skills that drive performance. Effective comparison visualizations decompose total value into constituent elements while maintaining interpretability.

Modern player comparison leverages advanced tracking data from Statcast and analytical frameworks that isolate skill from context. Exit velocity and launch angle data enable skill-based comparisons divorced from ballpark effects and defensive positioning. Percentile rankings normalize performance across eras and league contexts. Similarity scores using machine learning algorithms identify comparable players based on multidimensional performance profiles rather than superficial statistical matches.

Key Visualization Types

• Radar/Spider Charts: Display 5-8 key metrics as spokes radiating from a center point, with player values plotted along each spoke to create a distinctive shape representing their skill profile. Ideal for comparing overall profiles at a glance.
• Percentile Rank Charts: Show where players rank relative to league averages across multiple statistics, typically using bar charts with color coding. Percentiles normalize for league context and era effects.
• Rolling Averages: Plot performance metrics over time using moving averages to smooth short-term variance and reveal underlying trends. Essential for identifying breakouts, declines, and consistency patterns.
• Career Trajectory Plots: Map key metrics like WAR or wRC+ across player ages to compare development curves, peak periods, and career arcs. Crucial for projecting future performance.
• Scatter Plot Comparisons: Position players on two-dimensional charts using key metrics (e.g., exit velocity vs. launch angle, K% vs. BB%) to identify clusters and outliers.
• Heat Maps: Visualize batted ball distributions, pitch locations, or zone profiles using color intensity to show concentrations. Effective for comparing spray charts or swing zones.
• Side-by-Side Tables: Present comprehensive statistics in adjacent columns for detailed numeric comparison, often color-coded to highlight advantages.
• Similar Players Analysis: Use statistical distance metrics to identify the most comparable players from history, providing context for expectations and player archetypes.

Statistical Foundations

Types of Player Comparison Visualizations

1. Radar Charts (Spider Charts)

Radar charts display multiple variables on axes radiating from a central point, creating a polygon that represents a player's multidimensional profile. Each spoke represents a different metric (typically 5-8 variables), and the distance from center indicates performance level. The resulting shape provides an intuitive visual signature for each player.

Best Practices:

• Use 5-8 metrics maximum to avoid cluttered visualizations
• Normalize all metrics to the same scale (e.g., 0-100 percentile or z-scores)
• Arrange metrics thoughtfully - related skills should be adjacent
• Use consistent scales across comparisons for valid interpretation
• Include league average as a reference overlay

Applications: Scout reports, player cards, free agent evaluation, trade analysis, lineup construction showing complementary skills.

2. Percentile Rank Charts

Percentile rankings show where a player stands relative to all other players in the league for each statistical category. Values above the 50th percentile indicate above-average performance, while values in the 90th+ percentile represent elite performance. This format effectively communicates relative standing across multiple dimensions.

Advantages:

• Era-neutral comparisons - percentiles work across different offensive environments
• Intuitive interpretation - 75th percentile clearly means "better than 75% of players"
• Color coding enables quick identification of strengths and weaknesses
• Resistant to outliers and scale differences across metrics

3. Rolling Averages and Performance Curves

Rolling averages smooth game-to-game variance by calculating metrics over sliding windows (typically 10-50 plate appearances or batters faced). This technique reveals genuine trends and hot/cold streaks while filtering statistical noise inherent in small samples.

Window Selection:

• 10 games: Captures recent form but still noisy
• 20 games: Balances responsiveness with stability
• 50 games: Represents underlying skill level with minimal noise
• Season-to-date: Shows cumulative performance trajectory

4. Career Trajectory Comparisons

Career trajectory plots map key performance metrics (WAR, wRC+, ERA+, FIP) against player age, revealing development patterns, peak periods, and decline phases. Comparing trajectories between players provides context for projecting future performance and identifying career stages.

Age Curve Analysis: Most position players peak around ages 26-29, while pitchers often peak earlier (25-28). Comparing a young player's trajectory to similar players' historical curves provides projection frameworks.

5. Similar Players Analysis

Statistical similarity scores identify players with comparable profiles by calculating distance metrics across multiple performance dimensions. The most similar players provide historical comparables for projection systems and contextualize expectations.

Methodology:

• Select relevant statistics based on player type and analysis purpose
• Normalize statistics to account for era and playing time differences
• Calculate distance metrics (Euclidean, Manhattan, or cosine similarity)
• Weight statistics by importance (e.g., WAR more than batting average)
• Consider age and experience in similarity calculations

Era-Adjusted Comparisons

Baseball's offensive environment has varied dramatically across eras, from the dead-ball era through the steroid era to modern high-strikeout baseball. Valid cross-era comparisons require adjustments for league context:

• League-Adjusted Stats: wRC+, OPS+, ERA+ express performance relative to league average (100) and park-adjusted
• Percentile Rankings: Show where player ranked within their era rather than absolute numbers
• Context-Normalized Rates: K%, BB%, ISO compare favorably across eras with minimal adjustment
• WAR Frameworks: Already era-adjusted by comparing to replacement level within specific season contexts

Python Implementation - Radar Charts

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pybaseball import batting_stats, playerid_lookup
from math import pi

def create_radar_chart(player_stats_dict, metrics, title="Player Comparison"):
    """
    Create a radar chart comparing multiple players across selected metrics.

    Parameters:
    player_stats_dict: Dictionary with player names as keys and stat dictionaries as values
    metrics: List of metric names to display on radar chart
    title: Chart title

    Returns:
    matplotlib figure object
    """
    # Number of variables
    num_vars = len(metrics)

    # Compute angle for each axis
    angles = [n / float(num_vars) * 2 * pi for n in range(num_vars)]
    angles += angles[:1]  # Complete the circle

    # Initialize plot
    fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(projection='polar'))

    # Define colors for each player
    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd']

    # Plot each player
    for idx, (player_name, stats) in enumerate(player_stats_dict.items()):
        values = [stats.get(metric, 0) for metric in metrics]
        values += values[:1]  # Complete the circle

        ax.plot(angles, values, 'o-', linewidth=2, label=player_name,
                color=colors[idx % len(colors)])
        ax.fill(angles, values, alpha=0.15, color=colors[idx % len(colors)])

    # Set axis labels
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(metrics, size=12)

    # Set y-axis limits and labels
    ax.set_ylim(0, 100)
    ax.set_yticks([20, 40, 60, 80, 100])
    ax.set_yticklabels(['20', '40', '60', '80', '100'], size=10)
    ax.set_rlabel_position(0)

    # Add gridlines
    ax.grid(True, linestyle='--', alpha=0.7)

    # Add legend and title
    plt.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1), fontsize=11)
    plt.title(title, size=16, fontweight='bold', pad=20)

    return fig

def get_percentile_stats(year=2023, min_pa=200):
    """
    Fetch batting statistics and calculate percentile rankings.

    Parameters:
    year: Season to analyze
    min_pa: Minimum plate appearances to qualify

    Returns:
    DataFrame with percentile-ranked statistics
    """
    # Fetch season data
    data = batting_stats(year)

    # Filter to qualified batters
    qualified = data[data['PA'] >= min_pa].copy()

    # Calculate percentiles for key metrics
    metrics_to_rank = ['wRC+', 'K%', 'BB%', 'ISO', 'Barrel%', 'HardHit%', 'Sprint Speed', 'WAR']

    for metric in metrics_to_rank:
        if metric in qualified.columns:
            # For K%, lower is better - invert percentile
            if metric == 'K%':
                qualified[f'{metric}_percentile'] = 100 - qualified[metric].rank(pct=True) * 100
            else:
                qualified[f'{metric}_percentile'] = qualified[metric].rank(pct=True) * 100

    return qualified

def compare_players_radar(player_names, year=2023):
    """
    Compare multiple players using radar chart visualization.

    Parameters:
    player_names: List of player names (Last, First format)
    year: Season to analyze

    Returns:
    Radar chart figure
    """
    # Get percentile data
    percentile_data = get_percentile_stats(year)

    # Define metrics for comparison
    comparison_metrics = [
        'wRC+_percentile',
        'BB%_percentile',
        'K%_percentile',
        'ISO_percentile',
        'Barrel%_percentile',
        'HardHit%_percentile',
        'Sprint Speed_percentile',
        'WAR_percentile'
    ]

    # Clean metric names for display
    display_names = [
        'Hitting', 'Walks', 'Contact', 'Power',
        'Barrels', 'Hard Hit', 'Speed', 'Overall Value'
    ]

    # Extract player data
    player_data = {}
    for name in player_names:
        player_row = percentile_data[percentile_data['Name'].str.contains(name, case=False, na=False)]
        if not player_row.empty:
            player_stats = {}
            for metric, display_name in zip(comparison_metrics, display_names):
                if metric in player_row.columns:
                    player_stats[display_name] = player_row[metric].values[0]
                else:
                    player_stats[display_name] = 50  # Default to median
            player_data[name] = player_stats

    # Create radar chart
    if player_data:
        fig = create_radar_chart(
            player_data,
            display_names,
            title=f"Player Comparison - {year} Season (Percentile Rankings)"
        )
        return fig
    else:
        print("No players found with provided names")
        return None

# Example Usage
if __name__ == "__main__":
    # Compare elite hitters from 2023
    players = ['Acuna', 'Betts', 'Judge']

    radar_fig = compare_players_radar(players, year=2023)

    if radar_fig:
        plt.savefig('player_comparison_radar.png', dpi=300, bbox_inches='tight')
        plt.show()

    print("Radar chart created successfully!")

Python Implementation - Percentile Comparison Charts

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from pybaseball import batting_stats

def create_percentile_bars(player_names, year=2023, min_pa=200):
    """
    Create horizontal bar charts showing percentile rankings for multiple players.

    Parameters:
    player_names: List of player names to compare
    year: Season to analyze
    min_pa: Minimum plate appearances

    Returns:
    matplotlib figure
    """
    # Get season data
    data = batting_stats(year)
    qualified = data[data['PA'] >= min_pa].copy()

    # Define metrics to display
    metrics = {
        'wRC+': 'Offensive Production',
        'BB%': 'Walk Rate',
        'K%': 'Strikeout Rate',
        'ISO': 'Power',
        'Barrel%': 'Barrel Rate',
        'HardHit%': 'Hard Hit Rate',
        'Sprint Speed': 'Sprint Speed',
        'WAR': 'Total Value'
    }

    # Calculate percentiles
    percentile_df_list = []

    for name in player_names:
        player_row = qualified[qualified['Name'].str.contains(name, case=False, na=False)]

        if not player_row.empty:
            player_percentiles = {'Player': name}

            for metric, display_name in metrics.items():
                if metric in qualified.columns:
                    value = player_row[metric].values[0]
                    # K% is inverse - lower is better
                    if metric == 'K%':
                        percentile = (qualified[metric] > value).sum() / len(qualified) * 100
                    else:
                        percentile = (qualified[metric] <= value).sum() / len(qualified) * 100

                    player_percentiles[display_name] = percentile

            percentile_df_list.append(player_percentiles)

    if not percentile_df_list:
        print("No players found")
        return None

    # Create DataFrame
    percentile_df = pd.DataFrame(percentile_df_list)
    percentile_df.set_index('Player', inplace=True)

    # Create visualization
    fig, ax = plt.subplots(figsize=(12, len(player_names) * 2 + 2))

    # Plot horizontal bars
    y_pos = np.arange(len(metrics)) * (len(player_names) + 1)
    bar_height = 0.8

    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd']

    for idx, player in enumerate(percentile_df.index):
        offset = idx * bar_height
        values = percentile_df.loc[player].values

        # Color bars based on percentile
        bar_colors = []
        for val in values:
            if val >= 90:
                bar_colors.append('#2ca02c')  # Elite - Green
            elif val >= 75:
                bar_colors.append('#7fbf7f')  # Above Average - Light Green
            elif val >= 50:
                bar_colors.append('#ffcc00')  # Average - Yellow
            elif val >= 25:
                bar_colors.append('#ff9933')  # Below Average - Orange
            else:
                bar_colors.append('#d62728')  # Poor - Red

        bars = ax.barh(y_pos + offset, values, bar_height,
                       color=bar_colors, label=player, alpha=0.8)

        # Add value labels
        for bar, val in zip(bars, values):
            width = bar.get_width()
            ax.text(width + 1, bar.get_y() + bar.get_height()/2,
                   f'{val:.0f}', ha='left', va='center', fontsize=9)

    # Formatting
    ax.set_yticks(y_pos + bar_height * (len(player_names) - 1) / 2)
    ax.set_yticklabels(list(metrics.values()))
    ax.set_xlabel('Percentile Ranking', fontsize=12, fontweight='bold')
    ax.set_xlim(0, 105)
    ax.set_title(f'Player Percentile Comparison - {year} Season',
                fontsize=14, fontweight='bold', pad=20)

    # Add reference lines
    ax.axvline(50, color='gray', linestyle='--', linewidth=1, alpha=0.5, label='League Average')
    ax.axvline(75, color='green', linestyle='--', linewidth=1, alpha=0.3)
    ax.axvline(90, color='darkgreen', linestyle='--', linewidth=1, alpha=0.3)

    # Legend
    ax.legend(loc='lower right', fontsize=10)

    # Grid
    ax.grid(axis='x', alpha=0.3, linestyle=':')

    plt.tight_layout()
    return fig

# Example Usage
players_to_compare = ['Acuna', 'Betts', 'Freeman']
percentile_fig = create_percentile_bars(players_to_compare, year=2023)

if percentile_fig:
    plt.savefig('percentile_comparison.png', dpi=300, bbox_inches='tight')
    plt.show()

Python Implementation - Career WAR Trajectories

from pybaseball import playerid_lookup, batting_stats_range
import matplotlib.pyplot as plt
import pandas as pd

def plot_career_war_trajectory(player_names, start_year=2010, end_year=2023):
    """
    Plot career WAR trajectories for multiple players by age.

    Parameters:
    player_names: List of tuples (Last, First)
    start_year: Starting year for data
    end_year: Ending year for data

    Returns:
    matplotlib figure
    """
    fig, ax = plt.subplots(figsize=(14, 8))

    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b']

    for idx, (last_name, first_name) in enumerate(player_names):
        # Look up player ID
        player_lookup = playerid_lookup(last_name, first_name)

        if player_lookup.empty:
            print(f"Player {first_name} {last_name} not found")
            continue

        # Get birth year to calculate ages
        birth_year = player_lookup.iloc[0]['mlb_played_first']

        # Fetch career data
        try:
            career_data = []
            for year in range(start_year, end_year + 1):
                year_data = batting_stats(year)
                player_year = year_data[
                    (year_data['Name'].str.contains(last_name, case=False, na=False)) &
                    (year_data['Name'].str.contains(first_name, case=False, na=False))
                ]

                if not player_year.empty:
                    war_value = player_year['WAR'].values[0]
                    # Approximate age (would need birth date for exact age)
                    age = year - birth_year + 25  # Rough approximation
                    career_data.append({'Age': age, 'WAR': war_value, 'Year': year})

            if career_data:
                career_df = pd.DataFrame(career_data)

                # Plot career trajectory
                ax.plot(career_df['Age'], career_df['WAR'],
                       marker='o', linewidth=2.5, markersize=8,
                       color=colors[idx % len(colors)],
                       label=f'{first_name} {last_name}')

                # Add peak season annotation
                peak_season = career_df.loc[career_df['WAR'].idxmax()]
                ax.annotate(f'{peak_season["WAR"]:.1f} WAR\n({int(peak_season["Year"])})'  ,
                           xy=(peak_season['Age'], peak_season['WAR']),
                           xytext=(10, 10), textcoords='offset points',
                           fontsize=9, alpha=0.8,
                           bbox=dict(boxstyle='round,pad=0.5', facecolor=colors[idx % len(colors)], alpha=0.3))

        except Exception as e:
            print(f"Error processing {first_name} {last_name}: {str(e)}")
            continue

    # Formatting
    ax.set_xlabel('Age', fontsize=13, fontweight='bold')
    ax.set_ylabel('WAR (Wins Above Replacement)', fontsize=13, fontweight='bold')
    ax.set_title('Career WAR Trajectory Comparison', fontsize=15, fontweight='bold', pad=20)
    ax.grid(True, alpha=0.3, linestyle='--')
    ax.legend(fontsize=11, loc='best')

    # Add average peak age reference
    ax.axvline(27, color='gray', linestyle=':', linewidth=2, alpha=0.5, label='Typical Peak Age')

    plt.tight_layout()
    return fig

# Example Usage
players = [
    ('Trout', 'Mike'),
    ('Betts', 'Mookie'),
    ('Judge', 'Aaron'),
    ('Acuna', 'Ronald')
]

trajectory_fig = plot_career_war_trajectory(players, start_year=2015, end_year=2023)
plt.savefig('career_war_trajectories.png', dpi=300, bbox_inches='tight')
plt.show()

Python Implementation - Similar Players Algorithm

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.metrics.pairwise import euclidean_distances
from pybaseball import batting_stats

def find_similar_players(target_player_name, year=2023, min_pa=200, n_similar=10):
    """
    Find statistically similar players using multi-dimensional distance metrics.

    Parameters:
    target_player_name: Name of player to find comparables for
    year: Season to analyze
    min_pa: Minimum plate appearances
    n_similar: Number of similar players to return

    Returns:
    DataFrame with similar players and similarity scores
    """
    # Fetch season data
    data = batting_stats(year)
    qualified = data[data['PA'] >= min_pa].copy()

    # Define comparison metrics
    comparison_metrics = [
        'wRC+', 'BB%', 'K%', 'ISO', 'BABIP',
        'Barrel%', 'HardHit%', 'Sprint Speed', 'WAR'
    ]

    # Filter to available metrics
    available_metrics = [m for m in comparison_metrics if m in qualified.columns]

    # Find target player
    target = qualified[qualified['Name'].str.contains(target_player_name, case=False, na=False)]

    if target.empty:
        print(f"Player {target_player_name} not found")
        return None

    target_idx = target.index[0]

    # Prepare data for comparison
    comparison_data = qualified[available_metrics].fillna(qualified[available_metrics].median())

    # Standardize metrics (z-score normalization)
    scaler = StandardScaler()
    scaled_data = scaler.fit_transform(comparison_data)

    # Calculate Euclidean distances from target player
    target_scaled = scaled_data[qualified.index == target_idx]
    distances = euclidean_distances(target_scaled, scaled_data)[0]

    # Add distances to dataframe
    qualified['similarity_distance'] = distances

    # Convert distance to similarity score (0-100, where 100 is identical)
    max_dist = qualified['similarity_distance'].max()
    qualified['similarity_score'] = 100 * (1 - qualified['similarity_distance'] / max_dist)

    # Get most similar players (excluding target)
    similar_players = qualified[qualified.index != target_idx].nsmallest(n_similar, 'similarity_distance')

    # Select relevant columns
    result_columns = ['Name', 'Team', 'Age', 'PA', 'similarity_score'] + available_metrics
    result = similar_players[result_columns].copy()

    # Add target player at top
    target_result = target[result_columns].copy()
    target_result['similarity_score'] = 100.0  # Perfect match to self

    final_result = pd.concat([target_result, result], ignore_index=True)

    return final_result

def visualize_similar_players(target_player_name, year=2023, n_similar=5):
    """
    Create visualization showing similar players with key stat comparison.

    Parameters:
    target_player_name: Player to find comparables for
    year: Season to analyze
    n_similar: Number of similar players to show

    Returns:
    matplotlib figure
    """
    similar_df = find_similar_players(target_player_name, year, n_similar=n_similar)

    if similar_df is None:
        return None

    # Create comparison visualization
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))

    # Left plot: Similarity scores
    players = similar_df['Name'].values
    scores = similar_df['similarity_score'].values

    colors = ['#d62728' if i == 0 else '#1f77b4' for i in range(len(players))]

    bars = ax1.barh(range(len(players)), scores, color=colors, alpha=0.7)
    ax1.set_yticks(range(len(players)))
    ax1.set_yticklabels(players, fontsize=11)
    ax1.set_xlabel('Similarity Score', fontsize=12, fontweight='bold')
    ax1.set_title('Most Similar Players', fontsize=13, fontweight='bold')
    ax1.set_xlim(0, 105)
    ax1.grid(axis='x', alpha=0.3)

    # Add value labels
    for bar, score in zip(bars, scores):
        width = bar.get_width()
        ax1.text(width - 3, bar.get_y() + bar.get_height()/2,
                f'{score:.1f}', ha='right', va='center',
                color='white', fontweight='bold', fontsize=10)

    # Right plot: Key stats comparison
    key_stats = ['wRC+', 'ISO', 'BB%', 'K%', 'WAR']
    available_stats = [s for s in key_stats if s in similar_df.columns]

    x = np.arange(len(available_stats))
    width = 0.15

    for i, player in enumerate(players[:6]):  # Show top 6 including target
        values = similar_df.iloc[i][available_stats].values
        offset = (i - 2.5) * width
        ax2.bar(x + offset, values, width, label=player, alpha=0.8)

    ax2.set_xlabel('Statistic', fontsize=12, fontweight='bold')
    ax2.set_ylabel('Value', fontsize=12, fontweight='bold')
    ax2.set_title('Key Statistics Comparison', fontsize=13, fontweight='bold')
    ax2.set_xticks(x)
    ax2.set_xticklabels(available_stats)
    ax2.legend(fontsize=9, loc='best')
    ax2.grid(axis='y', alpha=0.3)

    plt.tight_layout()
    return fig

# Example Usage
target = 'Acuna'
similar_fig = visualize_similar_players(target, year=2023, n_similar=8)

if similar_fig:
    plt.savefig('similar_players_analysis.png', dpi=300, bbox_inches='tight')
    plt.show()

# Print similar players table
similar_players_df = find_similar_players(target, year=2023, n_similar=10)
if similar_players_df is not None:
    print(f"\nMost Similar Players to {target} (2023):")
    print(similar_players_df.to_string(index=False))

R Implementation - Radar Charts with ggplot2

library(tidyverse)
library(baseballr)
library(fmsb)  # For radar charts
library(scales)

# Create radar chart using ggplot2
create_radar_chart_ggplot <- function(player_data, metrics, title = "Player Comparison") {
  # Prepare data for radar chart
  # Add max/min rows for scaling
  max_values <- rep(100, length(metrics))
  min_values <- rep(0, length(metrics))

  # Combine with player data
  chart_data <- rbind(max_values, min_values, player_data[, metrics])
  colnames(chart_data) <- metrics

  # Create radar chart using fmsb
  radarchart(
    chart_data,
    axistype = 1,
    pcol = c("#1f77b4", "#ff7f0e", "#2ca02c", "#d62728"),
    pfcol = alpha(c("#1f77b4", "#ff7f0e", "#2ca02c", "#d62728"), 0.2),
    plwd = 3,
    plty = 1,
    cglcol = "grey",
    cglty = 1,
    axislabcol = "black",
    caxislabels = seq(0, 100, 25),
    cglwd = 0.8,
    vlcex = 1.1,
    title = title
  )

  # Add legend
  legend(
    x = "topright",
    legend = rownames(player_data),
    col = c("#1f77b4", "#ff7f0e", "#2ca02c", "#d62728"),
    lty = 1,
    lwd = 3,
    cex = 0.9,
    bty = "n"
  )
}

# Get percentile rankings for players
get_player_percentiles <- function(year = 2023, min_pa = 200) {
  # Fetch batting data
  batting_data <- fg_batter_leaders(startseason = year, endseason = year)

  # Filter to qualified batters
  qualified <- batting_data %>%
    filter(PA >= min_pa)

  # Calculate percentiles for key metrics
  qualified <- qualified %>%
    mutate(
      wRC_plus_pct = percent_rank(wRC.) * 100,
      BB_pct_rank = percent_rank(`BB%`) * 100,
      K_pct_rank = (1 - percent_rank(`K%`)) * 100,  # Inverted
      ISO_pct = percent_rank(ISO) * 100,
      Barrel_pct_rank = percent_rank(`Barrel%`) * 100,
      HardHit_pct_rank = percent_rank(`HardHit%`) * 100,
      Speed_pct = percent_rank(`Sprint Speed`) * 100,
      WAR_pct = percent_rank(WAR) * 100
    )

  return(qualified)
}

# Compare specific players
compare_players_radar_r <- function(player_names, year = 2023) {
  # Get percentile data
  percentile_data <- get_player_percentiles(year)

  # Extract data for specified players
  player_stats <- percentile_data %>%
    filter(str_detect(Name, paste(player_names, collapse = "|"))) %>%
    select(
      Name,
      wRC_plus_pct, BB_pct_rank, K_pct_rank, ISO_pct,
      Barrel_pct_rank, HardHit_pct_rank, Speed_pct, WAR_pct
    )

  # Prepare for radar chart
  rownames(player_stats) <- player_stats$Name
  player_stats <- player_stats %>% select(-Name)

  # Rename columns for display
  colnames(player_stats) <- c(
    "Hitting", "Walks", "Contact", "Power",
    "Barrels", "Hard Hit", "Speed", "Overall"
  )

  # Create radar chart
  create_radar_chart_ggplot(
    player_stats,
    colnames(player_stats),
    title = sprintf("Player Comparison - %d Season (Percentiles)", year)
  )
}

# Example Usage
players_to_compare <- c("Acuna", "Betts", "Judge")
compare_players_radar_r(players_to_compare, year = 2023)

R Implementation - Career Trajectory Analysis

library(tidyverse)
library(Lahman)
library(ggplot2)

# Plot career WAR trajectories
plot_career_trajectories <- function(player_ids, player_names) {
  # Fetch career data from Lahman database
  career_data <- Batting %>%
    filter(playerID %in% player_ids) %>%
    left_join(People %>% select(playerID, birthYear), by = "playerID") %>%
    mutate(Age = yearID - birthYear) %>%
    group_by(playerID, yearID, Age) %>%
    summarise(
      G = sum(G),
      PA = sum(AB + BB + HBP + SF + SH),
      .groups = "drop"
    )

  # Calculate WAR approximation (simplified for demonstration)
  # In practice, would join with actual WAR data
  career_data <- career_data %>%
    mutate(
      WAR_approx = (PA / 600) * 2.5  # Simplified approximation
    )

  # Add player names
  career_data$PlayerName <- player_names[match(career_data$playerID, player_ids)]

  # Create trajectory plot
  ggplot(career_data, aes(x = Age, y = WAR_approx, color = PlayerName, group = PlayerName)) +
    geom_line(size = 1.5, alpha = 0.8) +
    geom_point(size = 3, alpha = 0.7) +
    geom_smooth(se = FALSE, linetype = "dashed", size = 0.8, alpha = 0.5) +
    scale_color_brewer(palette = "Set1") +
    labs(
      title = "Career WAR Trajectory Comparison",
      subtitle = "Comparing player development curves by age",
      x = "Age",
      y = "WAR (Wins Above Replacement)",
      color = "Player"
    ) +
    theme_minimal(base_size = 13) +
    theme(
      plot.title = element_text(hjust = 0.5, face = "bold", size = 16),
      plot.subtitle = element_text(hjust = 0.5, size = 12),
      legend.position = "right",
      panel.grid.major = element_line(color = "gray90"),
      panel.grid.minor = element_line(color = "gray95")
    ) +
    annotate(
      "rect",
      xmin = 26, xmax = 30,
      ymin = -Inf, ymax = Inf,
      alpha = 0.1, fill = "gold"
    ) +
    annotate(
      "text",
      x = 28, y = max(career_data$WAR_approx, na.rm = TRUE),
      label = "Typical Peak Years",
      size = 3.5, color = "gray30", fontface = "italic"
    )
}

# Example with actual player IDs (would need to look these up)
# player_ids <- c("troutmi01", "bettsmoo01", "judgaa01")
# player_names <- c("Mike Trout", "Mookie Betts", "Aaron Judge")
# plot_career_trajectories(player_ids, player_names)

R Implementation - Similar Players Analysis

library(tidyverse)
library(baseballr)

# Find similar players using statistical distance
find_similar_players_r <- function(target_player_name, year = 2023, min_pa = 200, n_similar = 10) {
  # Fetch season data
  batting_data <- fg_batter_leaders(startseason = year, endseason = year)

  # Filter to qualified batters
  qualified <- batting_data %>%
    filter(PA >= min_pa)

  # Find target player
  target <- qualified %>%
    filter(str_detect(Name, target_player_name))

  if (nrow(target) == 0) {
    stop(sprintf("Player %s not found", target_player_name))
  }

  # Define comparison metrics
  comparison_metrics <- c("wRC.", "BB%", "K%", "ISO", "BABIP", "Barrel%", "HardHit%", "WAR")

  # Prepare comparison data (standardize)
  comparison_data <- qualified %>%
    select(all_of(comparison_metrics)) %>%
    mutate(across(everything(), ~replace_na(.x, median(.x, na.rm = TRUE))))

  # Standardize metrics (z-scores)
  comparison_scaled <- scale(comparison_data)

  # Calculate Euclidean distances from target
  target_idx <- which(str_detect(qualified$Name, target_player_name))[1]
  target_scaled <- comparison_scaled[target_idx, ]

  # Calculate distances
  distances <- sqrt(rowSums((sweep(comparison_scaled, 2, target_scaled))^2))

  # Add to dataframe
  qualified$similarity_distance <- distances
  qualified$similarity_score <- 100 * (1 - distances / max(distances))

  # Get most similar players
  similar_players <- qualified %>%
    filter(Name != target$Name[1]) %>%
    arrange(similarity_distance) %>%
    head(n_similar) %>%
    select(Name, Team, Age, PA, similarity_score, all_of(comparison_metrics))

  # Add target player at top
  target_result <- target %>%
    mutate(similarity_score = 100.0) %>%
    select(Name, Team, Age, PA, similarity_score, all_of(comparison_metrics))

  result <- bind_rows(target_result, similar_players)

  return(result)
}

# Visualize similar players
visualize_similar_players_r <- function(target_player_name, year = 2023, n_similar = 8) {
  similar_df <- find_similar_players_r(target_player_name, year, n_similar = n_similar)

  # Create visualization
  p1 <- ggplot(similar_df, aes(x = reorder(Name, similarity_score), y = similarity_score)) +
    geom_col(aes(fill = Name == similar_df$Name[1]), alpha = 0.8, show.legend = FALSE) +
    scale_fill_manual(values = c("TRUE" = "#d62728", "FALSE" = "#1f77b4")) +
    coord_flip() +
    labs(
      title = sprintf("Most Similar Players to %s (%d)", target_player_name, year),
      x = NULL,
      y = "Similarity Score"
    ) +
    theme_minimal() +
    theme(
      plot.title = element_text(hjust = 0.5, face = "bold", size = 14),
      axis.text = element_text(size = 11)
    )

  print(p1)
  return(similar_df)
}

# Example Usage
similar_players <- visualize_similar_players_r("Acuna", year = 2023, n_similar = 10)
print(similar_players)

Interactive Visualization Options

Modern baseball analytics increasingly leverages interactive visualizations that enable dynamic exploration of player comparisons:

Plotly for Interactive Python Charts

import plotly.graph_objects as go
from pybaseball import batting_stats

def create_interactive_radar(player_names, year=2023):
    """Create interactive radar chart using Plotly"""
    data = batting_stats(year)

    fig = go.Figure()

    metrics = ['wRC+', 'BB%', 'K%', 'ISO', 'Barrel%', 'HardHit%']

    for player_name in player_names:
        player_data = data[data['Name'].str.contains(player_name, case=False)]
        if not player_data.empty:
            values = [player_data[m].values[0] for m in metrics]

            fig.add_trace(go.Scatterpolar(
                r=values,
                theta=metrics,
                fill='toself',
                name=player_name
            ))

    fig.update_layout(
        polar=dict(
            radialaxis=dict(visible=True, range=[0, 100])
        ),
        showlegend=True,
        title="Interactive Player Comparison"
    )

    return fig

# Create and display
interactive_fig = create_interactive_radar(['Acuna', 'Betts', 'Judge'], 2023)
interactive_fig.show()
# Save as HTML
interactive_fig.write_html('interactive_player_comparison.html')

Real-World Applications

Major League Baseball teams use player comparison visualizations extensively in their decision-making processes:

Tampa Bay Rays: The Rays created an internal comparison tool that generates radar charts and percentile rankings for every player in their organization and throughout MLB. When evaluating trade targets, they instantly generate comparison visualizations against their current roster to identify complementary skills and upgrade opportunities. Their similarity algorithm helped identify Blake Snell as an undervalued prospect with a similar profile to peak Cole Hamels.

Los Angeles Dodgers: The Dodgers employ interactive dashboards built with Plotly and Dash that allow scouts and executives to dynamically compare players by adjusting which metrics appear in visualizations. Their system automatically identifies similar players from history and projects career trajectories by comparing current players to historical comparables at the same age. This approach helped them identify Mookie Betts as a historically elite talent worth a massive trade package and contract.

Houston Astros: The Astros use career trajectory comparisons to inform contract extension decisions. By comparing a player's current age-performance curve to similar historical players, they project future value and identify optimal contract timing. Their analysis showed that Alex Bregman's trajectory matched elite third basemen who remained productive into their mid-30s, influencing their extension strategy.

Best Practices for Player Comparisons

• Use percentile rankings rather than raw stats for era-neutral comparisons
• Include both rate stats (per 600 PA) and counting stats to account for playing time
• Weight recent performance more heavily than distant history using weighted averages
• Account for ballpark factors when comparing players from extreme environments
• Consider defensive value and baserunning in overall player evaluations
• Use confidence intervals when comparing players with different sample sizes
• Adjust for age when projecting future performance from historical comparables
• Include both offensive and defensive metrics for position players
• Normalize for league context (pitcher-friendly vs. hitter-friendly eras)
• Test statistical significance of differences before drawing strong conclusions

Key Takeaways

• Player comparison visualizations transform multidimensional statistical data into intuitive formats that reveal patterns and enable rapid evaluation across multiple performance dimensions simultaneously.
• Radar charts provide excellent profile comparisons showing overall shape of player skills, while percentile rankings enable era-adjusted evaluations that work across different offensive environments and time periods.
• Career trajectory analysis comparing players by age reveals development patterns and peak periods, providing critical context for projecting future performance and identifying optimal contract timing.
• Similar player algorithms using multidimensional distance metrics identify historical comparables that provide frameworks for expectations and valuation, helping teams contextualize current performance.
• Python and R both offer robust tools for creating player comparison visualizations, with Python excelling in interactive dashboards (Plotly) and R providing publication-quality static graphics (ggplot2).
• Effective player comparisons require thoughtful metric selection, appropriate normalization (percentiles, z-scores, or era adjustments), and consideration of context including ballpark factors, league environment, and sample size.
• Interactive visualizations using tools like Plotly and Shiny enable dynamic exploration where users can adjust parameters, toggle metrics, and drill into detailed statistics beyond what static charts provide.
• MLB teams use these comparison techniques extensively for player acquisition, contract negotiations, roster construction, and internal development tracking throughout their organizations.