Upload 5 files

Dockerfile

@@ -1,14 +1,42 @@
-FROM rocker/r-base:latest
+FROM rocker/shiny-verse:latest
 
 WORKDIR /code
 
+# Install stable packages from CRAN
 RUN install2.r --error \
+    ggExtra \
     shiny \
+    plotly \
+    bslib \
+    DT \
+    rsconnect \
+    baseballr \
     dplyr \
+    tidyverse \
+    rvest \
     ggplot2 \
-    readr \
-    ggExtra
-    
+    janitor \
+    ggthemes \
+    ggpubr \
+    jsonlite \
+    utils \
+    grid \
+    gridExtra \
+    png \
+    xgboost \
+    httr \
+    jpeg \
+    zoo \
+    gtable \
+    lightgbm
+
+
+# Install development packages from GitHub
+RUN installGithub.r \
+    rstudio/bslib \
+    rstudio/httpuv \
+    rstudio/gridlayout
+
 COPY . .
 
 CMD ["R", "--quiet", "-e", "shiny::runApp(host='0.0.0.0', port=7860)"]

TimStuff2 (1).model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1737b5f802e144b8e3e09ea35be21870bad9aec236a6ee4f8aaebfca641879c3
+size 1708451

app.R

@@ -1,58 +1,1063 @@
 library(shiny)
+library(plotly)
+library(gridlayout)
 library(bslib)
+library(DT)
+library(rsconnect)
+library(baseballr)
 library(dplyr)
+library(tidyverse)
+library(rvest)
 library(ggplot2)
+library(janitor)
+library(ggthemes)
+library(ggpubr)
+library(jsonlite)
+library(utils)
+library(grid)
+library(gridExtra)
+library(png)
+library(lightgbm)
+library(httr)
+library(jpeg)
+library(zoo)
+library(gtable)
 
-df <- readr::read_csv("penguins.csv")
-# Find subset of columns that are suitable for scatter plot
-df_num <- df |> select(where(is.numeric), -Year)
-
-ui <- page_sidebar(
-  theme = bs_theme(bootswatch = "minty"),
-  title = "Penguins explorer",
-  sidebar = sidebar(
-    varSelectInput("xvar", "X variable", df_num, selected = "Bill Length (mm)"),
-    varSelectInput("yvar", "Y variable", df_num, selected = "Bill Depth (mm)"),
-    checkboxGroupInput("species", "Filter by species",
-      choices = unique(df$Species), selected = unique(df$Species)
+options(shiny.maxRequestSize = 10000000 * 1024^2)
+pdf(file = NULL)
+Sys.setenv(TZ='EST')
+
+download_private_csv <- function(repo_id, filename) {
+  url <- paste0("https://huggingface.co/datasets/", repo_id, "/resolve/main/", filename)
+  
+  response <- GET(url, 
+                  add_headers(Authorization = paste("Bearer", Sys.getenv("HF_TOKEN"))))
+  
+  if (status_code(response) == 200) {
+    content <- content(response, "text")
+    con <- textConnection(content)
+    data <- read.csv(con)
+    close(con)
+    return(data)
+  } else {
+    stop("Failed to download dataset")
+  }
+}
+
+# Usage
+t <- download_private_csv("TimStats/Passwords", "demo.csv")
+pass <- t[1,1]
+
+#model <- xgb.load('TimStuff2.model')
+
+# Helper functions
+download_and_process_image <- function(url) {
+  tryCatch({
+    response <- GET(url)
+    content_type <- http_type(response)
+    
+    if (content_type %in% c("image/png", "image/jpeg")) {
+      temp_file <- tempfile(fileext = ifelse(content_type == "image/png", ".png", ".jpg"))
+      writeBin(content(response, "raw"), temp_file)
+      
+      if (content_type == "image/png") {
+        img <- readPNG(temp_file)
+      } else {
+        img <- readJPEG(temp_file)
+      }
+      
+      return(list(img = img, type = content_type))
+    } else {
+      warning(paste("Unsupported image type:", content_type))
+      return(NULL)
+    }
+  }, error = function(e) {
+    warning(paste("Error processing image:", e$message))
+    return(NULL)
+  })
+}
+
+is_barrel <- function(df) {
+  df$barrel <- with(df, ifelse(hit_angle <= 50 & hit_speed >= 97 & hit_speed * 1.5 - 
+                                 hit_angle >= 117 & hit_speed + hit_angle >= 123, 1, 0))
+  return(df)
+}
+
+VAA <- function(milbtotal){
+  milbtotal <- milbtotal %>%
+    mutate(VAA = -atan((vz0+(az*(-sqrt((vy0*vy0)-(2*ay*(y0-(17/12))))-vy0)/
+                               ay))/(-sqrt((vy0*vy0)-(2*ay*(y0-(17/12))))))*(180/pi))
+} 
+
+pitcher_summary <- function(tmilb){
+  tmilb %>%
+    select(Batter,Pitcher,PlayResult,PitchCall,TaggedPitchType,RelSpeed,SpinRate,
+           Extension,PlateLocSide,PlateLocHeight,RelSide,RelHeight,ax0,ay0,az0,vx0,
+           vz0,vy0,pfxx,pfxz,InducedVertBreak,HorzBreak,SpinAxis,PitcherThrows,BatterSide,PitchofPA,VertApprAngle) %>%
+    rename(
+      "Batter Name" = Batter, "Pitcher Name" = Pitcher, result = PlayResult,
+      description = PitchCall, pitch_name = TaggedPitchType, start_speed = RelSpeed,
+      spin_rate = SpinRate, extension = Extension, px = PlateLocSide, pz = PlateLocHeight,
+      x0 = RelSide, z0 = RelHeight, ax = ax0, ay = ay0, az = az0, vx0 = vx0,
+      vz0 = vz0, vy0 = vy0, pfxX = pfxx, pfxZ = pfxz, IVB = InducedVertBreak,
+      HB = HorzBreak, spinDirection = SpinAxis, phand = PitcherThrows, bhand = BatterSide, PitchNum = PitchofPA, VAA = VertApprAngle
+    ) %>%
+    mutate(
+      is_strike_swinging = ifelse(description == "StrikeSwinging", TRUE, FALSE),
+      phand = ifelse(phand == "Right", "R", "L"),
+      bhand = ifelse(bhand == "Right", "R", "L")
+    )
+}
+
+break_plot <- function(game){
+  game <- game %>% mutate(
+    pitch_name = case_when(
+      pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+      pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+      pitch_name %in% c("ChangeUp") ~ "Changeup",
+      pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+      pitch_name %in% c("CutFastBall") ~ "Cutter",
+      TRUE ~ pitch_name
+    ))
+  pitch_colors <- c(
+    "Four-Seam"= "#FF4136", "Sinker"= "#FF851B", "Cutter"= "#FFDC00",
+    "Changeup"= "#2ECC40", "Slider"= "#0074D9", "Sweeper"= "#ED68ED",
+    "Curveball"= "#B10DC9", "Splitter"= "#01FF70", "Knuckle Curve"= "#85144b",
+    "Slurve"= "#3D9970", "Knuckle Ball"= "#39CCCC", "Two-Seam Fastball"= "#F012BE",
+    "Eephus"= "#AAAAAA", "Fastball"= "#7FDBFF", "Slow Curve"= "#DDDDDD",
+    "Screwball"= "#FF69B4"
+  )
+  ggplot(game, aes(x = HB, y = IVB, color = pitch_name)) +
+    geom_point(size = 2) +
+    geom_vline(xintercept = 0, color = "lightblue", linewidth = 1, linetype = 4) +
+    geom_hline(yintercept = 0, color = "lightblue", linewidth = 1, linetype = 4) +
+    scale_color_manual(values = pitch_colors) +
+    labs(x = "Horizontal Break (in)", y = "Induced Vertical Break (in)", 
+         title = "Pitch Movement") +
+    xlim(-25, 25) + ylim(-25, 25) + theme_minimal() +
+    theme(
+      legend.position = "bottom",
+      plot.title = element_text(hjust = 0.5, face = "bold"),
+      panel.grid.minor = element_line(color = "gray", size = 0.25, linetype = 1),
+      aspect.ratio = 1
+    ) +
+    guides(color = guide_legend(title = "Pitch Type", nrow = 1))
+}
+
+pitch_plot <- function(game, title) {
+  game <- game %>% mutate(
+    pitch_name = case_when(
+      pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+      pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+      pitch_name %in% c("ChangeUp") ~ "Changeup",
+      pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+      pitch_name %in% c("CutFastBall") ~ "Cutter",
+      TRUE ~ pitch_name
+    ))
+  pitch_colors <- c(
+    "Four-Seam"= "#FF4136", "Sinker"= "#FF851B", "Cutter"= "#FFDC00",
+    "Changeup"= "#2ECC40", "Slider"= "#0074D9", "Sweeper"= "#ED68ED",
+    "Curveball"= "#B10DC9", "Splitter"= "#01FF70", "Knuckle Curve"= "#85144b",
+    "Slurve"= "#3D9970", "Knuckle Ball"= "#39CCCC", "Two-Seam Fastball"= "#F012BE",
+    "Eephus"= "#AAAAAA", "Fastball"= "#7FDBFF", "Slow Curve"= "#DDDDDD",
+    "Screwball"= "#FF69B4"
+  )
+  ggplot(game, aes(x = px, y = pz, color = pitch_name)) +
+    geom_point(size = 3.5) +
+    geom_segment(aes(x = -0.71, xend = 0.71, y = 1.5, yend = 1.5)) +
+    geom_segment(aes(x = -0.71, xend = 0.71, y = 3.6, yend = 3.6)) +
+    geom_segment(aes(x = 0.71, xend = 0.71, y = 1.5, yend = 3.6)) +
+    geom_segment(aes(x = -0.71, xend = -0.71, y = 1.5, yend = 3.6)) +
+    scale_color_manual(values = pitch_colors) +
+    labs(x = NULL, y = NULL, title = title) +
+    xlim(-3, 3) + ylim(0.2, 4) + coord_fixed(ratio = 1) + theme_minimal() +
+    theme(
+      legend.position = "bottom",
+      plot.title = element_text(hjust = 0.5, face = "bold"),
+      axis.text = element_blank(),
+      axis.ticks = element_blank()
+    ) +
+    guides(color = guide_legend(title = "Pitch Type", nrow = 1))
+}
+
+left_batter <- png::readPNG("left_batter.png")
+right_batter <- png::readPNG("right_batter.png")
+
+pitch_plot_split <- function(game, title) {
+  game_lhb <- game %>% filter(bhand == "L") %>% mutate(
+    pitch_name = case_when(
+      pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+      pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+      pitch_name %in% c("ChangeUp") ~ "Changeup",
+      pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+      pitch_name %in% c("CutFastBall") ~ "Cutter",
+      TRUE ~ pitch_name
+    ))
+  game_rhb <- game %>% filter(bhand == "R") %>% mutate(
+    pitch_name = case_when(
+      pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+      pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+      pitch_name %in% c("ChangeUp") ~ "Changeup",
+      pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+      pitch_name %in% c("CutFastBall") ~ "Cutter",
+      TRUE ~ pitch_name
+    ))
+  
+  # Define home plate coordinates (adjusted position)
+  home_plate <- data.frame(
+    x = c(0.6, -0.6, -0.7083, 0, 0.7083),  # Keep x-coordinates
+    y = c(0.5, 0.5, 0.25, 0, 0.25)  # Adjust y-coordinates to put point at 0
+  )
+  
+  pitch_colors <- c(
+    "Four-Seam"= "#FF4136", "Sinker"= "#FF851B", "Cutter"= "#FFDC00",
+    "Changeup"= "#2ECC40", "Slider"= "#0074D9", "Sweeper"= "#ED68ED",
+    "Curveball"= "#B10DC9", "Splitter"= "#01FF70", "Knuckle Curve"= "#85144b",
+    "Slurve"= "#3D9970", "Knuckle Ball"= "#39CCCC", "Two-Seam Fastball"= "#F012BE",
+    "Eephus"= "#AAAAAA", "Fastball"= "#7FDBFF", "Slow Curve"= "#DDDDDD",
+    "Screwball"= "#FF69B4"
+  )  
+  
+  # Create left-handed batter plot
+  plot_lhb <- ggplot(game_lhb, aes(x = -px, y = pz, color = pitch_name)) +
+    # Add home plate first (so it appears under the points)
+    geom_polygon(data = home_plate, aes(x = x, y = y), 
+                 fill = "white", color = "black", inherit.aes = FALSE) +
+    # Add batter image (now using left_batter on right side)
+    annotation_custom(rasterGrob(left_batter, 
+                                 width = unit(.75, "npc"),
+                                 height = unit(1.5, "npc")),
+                      xmin = .7, xmax = 3.2,
+                      ymin = 1, ymax = 5) +
+    geom_point(size = 3) +
+    geom_segment(aes(x = -0.71, xend = 0.71, y = 1.5, yend = 1.5)) +
+    geom_segment(aes(x = -0.71, xend = 0.71, y = 3.6, yend = 3.6)) +
+    geom_segment(aes(x = 0.71, xend = 0.71, y = 1.5, yend = 3.6)) +
+    geom_segment(aes(x = -0.71, xend = -0.71, y = 1.5, yend = 3.6)) +
+    scale_color_manual(values = pitch_colors) +
+    labs(x = NULL, y = NULL, title = "LHB") +
+    xlim(-3, 3) +
+    ylim(0, 5) +
+    coord_fixed(ratio = 1) +
+    theme_void() +
+    theme(
+      legend.position = "none",
+      plot.title = element_text(hjust = 0.5, face = "bold"),
+      axis.text = element_blank(),
+      axis.ticks = element_blank()
+    )
+  
+  # Create right-handed batter plot
+  plot_rhb <- ggplot(game_rhb, aes(x = -px, y = pz, color = pitch_name)) +
+    # Add home plate first
+    geom_polygon(data = home_plate, aes(x = x, y = y), 
+                 fill = "white", color = "black", inherit.aes = FALSE) +
+    # Add batter image (now using right_batter on left side)
+    annotation_custom(rasterGrob(right_batter, 
+                                 width = unit(.75, "npc"),
+                                 height = unit(1.5, "npc")),
+                      xmin = -3, xmax = -0.5,
+                      ymin = 1, ymax = 5) +
+    geom_point(size = 3) +
+    geom_segment(aes(x = -0.71, xend = 0.71, y = 1.5, yend = 1.5)) +
+    geom_segment(aes(x = -0.71, xend = 0.71, y = 3.6, yend = 3.6)) +
+    geom_segment(aes(x = 0.71, xend = 0.71, y = 1.5, yend = 3.6)) +
+    geom_segment(aes(x = -0.71, xend = -0.71, y = 1.5, yend = 3.6)) +
+    scale_color_manual(values = pitch_colors) +
+    labs(x = NULL, y = NULL, title = "RHB") +
+    xlim(-3, 3) +
+    ylim(0, 5) +
+    coord_fixed(ratio = 1) +
+    theme_void() +
+    theme(
+      legend.position = "none",
+      plot.title = element_text(hjust = 0.5, face = "bold"),
+      axis.text = element_blank(),
+      axis.ticks = element_blank()
+    )
+  
+  return(list(lhb = plot_lhb, rhb = plot_rhb))
+}
+
+calculate_VAA <- function(vz0, ay, az, vy0, y0) {
+  -atan((vz0+(az*(-sqrt((vy0*vy0)-(2*ay*(y0-(17/12))))-vy0)/
+                ay))/(-sqrt((vy0*vy0)-(2*ay*(y0-(17/12))))))*(180/pi)
+}
+
+calculate_EAA <- function(extension) {
+  extension / 6.3
+}
+
+calculate_SADiff <- function(pfxX, pfxZ, spinDirection) {
+  inSA <- atan2(pfxZ, pfxX) * 180/pi + 90
+  inSA <- ifelse(inSA < 0, inSA + 360, inSA)
+  SADiff <- spinDirection - inSA
+  SADiff <- ifelse(SADiff > 180, SADiff - 360, SADiff)
+  SADiff <- ifelse(SADiff < -180, SADiff + 360, SADiff)
+  return(SADiff)
+}
+
+scale_TimStuff <- function(raw_score, model_mean, model_sd) {
+  scaled_score <- (raw_score - model_mean) / model_sd
+  result <- 100 - (scaled_score * 10)
+  return(result)
+}
+
+transform_statcast_data <- function(df, 
+                                    release_extension_col = "extension",
+                                    vx0_col = "vx0", 
+                                    vy0_col = "vy0", 
+                                    vz0_col = "vz0",
+                                    ax_col = "ax", 
+                                    ay_col = "ay", 
+                                    az_col = "az",
+                                    arm_angle_col = NULL,
+                                    p_throws_col = NULL) {
+  
+  # Constants
+  MOUND_DISTANCE <- 60.5
+  STATCAST_INITIAL_MEASUREMENT <- 50.0
+  Z_CONSTANT <- 32.174
+  HOME_PLATE_HEIGHT <- 17/12  # Convert 17 inches to feet
+  print("etds")
+  # Compute release position
+  df$release_pos_y <- MOUND_DISTANCE - df[[release_extension_col]]
+  print("etds1")
+  # Compute release time
+  df$release_time <- (-df[[vy0_col]] - 
+                        sqrt((df[[vy0_col]]^2) - 
+                               (2 * df[[ay_col]] * (STATCAST_INITIAL_MEASUREMENT - df$release_pos_y)))) / df[[ay_col]]
+  print("etds23")
+  # Compute release velocities
+  df$vxR <- df[[vx0_col]] + (df[[ax_col]] * df$release_time)
+  df$vyR <- df[[vy0_col]] + (df[[ay_col]] * df$release_time)
+  df$vzR <- df[[vz0_col]] + (df[[az_col]] * df$release_time)
+  print("etds2")
+  # Compute time to home plate
+  df$tf <- (-df$vyR - sqrt(df$vyR^2 - 2 * df[[ay_col]] * (df$release_pos_y - HOME_PLATE_HEIGHT))) / df[[ay_col]]
+  print("etds3")
+  # Compute average velocities
+  df$vxbar <- (2 * df$vxR + df[[ax_col]] * df$tf) / 2
+  df$vybar <- (2 * df$vyR + df[[ay_col]] * df$tf) / 2
+  df$vzbar <- (2 * df$vzR + df[[az_col]] * df$tf) / 2
+  
+  # Compute average velocity magnitude
+  df$vbar <- sqrt(df$vxbar^2 + df$vybar^2 + df$vzbar^2)
+  print("etds4")
+  # Compute drag acceleration
+  df$adrag <- -(df[[ax_col]] * df$vxbar + 
+                  df[[ay_col]] * df$vybar + 
+                  (df[[az_col]] + Z_CONSTANT) * df$vzbar) / df$vbar
+  
+  # Compute Magnus force components
+  df$amagx <- df[[ax_col]] + df$adrag * df$vxbar / df$vbar
+  df$amagy <- df[[ay_col]] + df$adrag * df$vybar / df$vbar
+  df$amagz <- df[[az_col]] + df$adrag * df$vzbar / df$vbar + Z_CONSTANT
+  
+  # Compute Magnus force magnitude
+  df$amag <- sqrt(df$amagx^2 + df$amagy^2 + df$amagz^2)
+  
+  # Original transformation calculations
+  df$v_mag <- sqrt(df$vxR^2 + df$vyR^2 + df$vzR^2)
+  
+  # Compute tangential unit vectors
+  df$tang_x <- df$vxR / df$v_mag
+  df$tang_y <- df$vyR / df$v_mag
+  df$tang_z <- df$vzR / df$v_mag
+  print("etds5")
+  # Handle arm angle and handedness
+  if (!is.null(arm_angle_col)) {
+    df$handedness_factor <- ifelse(df[[p_throws_col]] == "R", 1, -1)
+    df$temp_x <- cos(df[[arm_angle_col]]) * df$handedness_factor
+    df$temp_y <- 0
+    df$temp_z <- sin(df[[arm_angle_col]])
+  } else {
+    df$temp_x <- 0
+    df$temp_y <- rep(0, nrow(df))
+    df$temp_z <- 1
+  }
+  
+  # Compute horizontal vector
+  df$horz_x <- df$temp_y * df$tang_z - df$temp_z * df$tang_y
+  df$horz_y <- df$temp_z * df$tang_x - df$temp_x * df$tang_z
+  df$horz_z <- df$temp_x * df$tang_y - df$temp_y * df$tang_x
+  print("etds6")
+  # Normalize horizontal vector
+  df$horz_mag <- sqrt(df$horz_x^2 + df$horz_y^2 + df$horz_z^2)
+  df$horz_x <- df$horz_x / df$horz_mag
+  df$horz_y <- df$horz_y / df$horz_mag
+  df$horz_z <- df$horz_z / df$horz_mag
+  
+  # Compute vertical vector
+  df$vert_x <- df$tang_y * df$horz_z - df$tang_z * df$horz_y
+  df$vert_y <- df$tang_z * df$horz_x - df$tang_x * df$horz_z
+  df$vert_z <- df$tang_x * df$horz_y - df$tang_y * df$horz_x
+  print("etds7")
+  # Project accelerations
+  df$a_tang <- df[[ax_col]] * df$tang_x + df[[ay_col]] * df$tang_y + df[[az_col]] * df$tang_z
+  df$a_horz <- df[[ax_col]] * df$horz_x + df[[ay_col]] * df$horz_y + df[[az_col]] * df$horz_z
+  df$a_vert <- df[[ax_col]] * df$vert_x + df[[ay_col]] * df$vert_y + df[[az_col]] * df$vert_z
+  print("ets")
+  # Clean up intermediate columns
+  intermediate_cols <- c("temp_x", "temp_y", "temp_z", "handedness_factor",
+                         "horz_mag", "horz_x", "horz_y", "horz_z",
+                         "vert_x", "vert_y", "vert_z",
+                         "tang_x", "tang_y", "tang_z")
+  df <- df[, !names(df) %in% intermediate_cols]
+  
+  return(df)
+}
+
+calculatetimstuffall <- function(game) {
+  #game <- transform_statcast_data(game) %>% mutate(SADiff = calculate_SADiff(pfxx, pfxz, SpinAxis))
+  
+  # Filter and handle fastball calculations with error checking
+  # Get primary pitch info directly within the function
+  primary_pitch1 <- game %>% 
+    filter(pitch_name == "Sinker" | pitch_name == "Fastball" | pitch_name == "Cutter" | 
+             pitch_name == "FourSeamFastBall" | pitch_name == "OneSeamFastBall" | pitch_name == "TwoSeamFastBall") %>% 
+    group_by(`Pitcher Name`) %>% 
+    count(pitch_name) %>% 
+    summarise(max = max(n))
+  
+  primary_pitch2 <- game %>% 
+    filter(pitch_name == "Sinker" | pitch_name == "Fastball" | pitch_name == "Cutter" | 
+             pitch_name == "FourSeamFastBall" | pitch_name == "OneSeamFastBall" | pitch_name == "TwoSeamFastBall") %>% 
+    group_by(`Pitcher Name`, pitch_name) %>% 
+    count(pitch_name)
+  
+  primary_pitch <- left_join(primary_pitch1, primary_pitch2, by = c('Pitcher Name')) %>% 
+    filter(max == n) %>% 
+    select(`Pitcher Name`, pitch_name) %>% 
+    filter(pitch_name != "Undefined" & pitch_name != "Other") %>% 
+    mutate(Primary = pitch_name) %>% 
+    select(-pitch_name)
+  
+  game <- left_join(game, primary_pitch, by = c('Pitcher Name'))
+  
+  # Calculate primary pitch averages
+  primary_avgs <- game %>% 
+    filter(pitch_name == Primary) %>% 
+    group_by(`Pitcher Name`) %>% 
+    summarise(
+      Primary_Velo = mean(start_speed, na.rm = TRUE),
+      Primary_IVB = mean(IVB, na.rm = TRUE),
+      Primary_HB = mean(HB, na.rm = TRUE)
+    )
+  
+  # Join averages and calculate differences
+  game <- game %>%
+    left_join(primary_avgs, by = c('Pitcher Name')) %>%
+    mutate(
+      velo_diff = round(ifelse(is.na(Primary_Velo), 0, start_speed - Primary_Velo), 1),
+      IVB_diff = round(ifelse(is.na(Primary_IVB), 0, IVB - Primary_IVB), 1),
+      HB_diff = round(ifelse(is.na(Primary_HB), 0, 
+                             ifelse(phand == "Left", -HB - Primary_HB, HB - Primary_HB)), 1)
+    )
+  print(colSums(is.na(game)))
+  feature_vars <- c("start_speed", "IVB", "HB", "spin_rate",
+                    "z0", "x0", "extension", "velo_diff", "IVB_diff", "HB_diff")
+  complete_rows <- complete.cases(game[, feature_vars])
+  game_complete <- game[complete_rows, ]
+  game_na <- game[!complete_rows, ]
+  game_na <- if(any(!complete_rows)) {
+    na_rows <- game[!complete_rows, ]
+    na_rows$TimStuff <- NA
+    na_rows
+  } else {
+    # Create empty data frame with same structure plus TimStuff
+    empty_df <- game_complete[0, ]  # Get structure from game_complete
+    empty_df$TimStuff <- numeric()  # Add empty TimStuff column
+    empty_df
+  }  
+  
+  # Round the features to 1 decimal point
+  game_complete$start_speed <- round(game_complete$start_speed, 1)
+  game_complete$IVB <- round(game_complete$IVB, 1)
+  game_complete$HB <- abs(round(game_complete$HB, 1))
+  game_complete$spin_rate <- round(game_complete$spin_rate, 1)
+  game_complete$z0 <- round(game_complete$z0, 1)
+  game_complete$x0 <- abs(round(game_complete$x0, 1))
+  game_complete$extension <- round(game_complete$extension, 1)
+  game_complete$velo_diff <- round(game_complete$velo_diff, 1)
+  game_complete$IVB_diff <- round(game_complete$IVB_diff, 1)
+  game_complete$HB_diff <- round(game_complete$HB_diff, 1)
+  
+  # Split right-handed and left-handed pitchers
+  rhp <- game_complete %>% filter(phand == "R")
+  lhp <- game_complete %>% filter(phand == "L")
+  
+  # Process right-handed pitchers by pitch type
+  if(nrow(rhp) > 0) {
+    # Split by pitch type
+    rhp_ff <- rhp %>% filter(pitch_name %in% c("Fastball","FourSeamFastBall"))
+    rhp_si <- rhp %>% filter(pitch_name %in% c("OneSeamFastBall","Sinker","TwoSeamFastBall"))
+    rhp_ct <- rhp %>% filter(pitch_name == "Cutter")
+    rhp_sl <- rhp %>% filter(pitch_name %in% c("Slider","Sweeper"))
+    rhp_cb <- rhp %>% filter(pitch_name == "Curveball")
+    rhp_ch_spl <- rhp %>% filter(pitch_name %in% c("Changeup", "ChangeUp","Splitter","Knuckleball"))
+    
+    # Apply models for each pitch type with appropriate scaling
+    if(nrow(rhp_ff) > 0) {
+      rhp_ff$TimStuff <- scale_TimStuff(
+        predict(FF_model, as.matrix(cbind(
+          rhp_ff$start_speed, rhp_ff$IVB, rhp_ff$HB, 
+          rhp_ff$z0, rhp_ff$x0, rhp_ff$extension))), 
+        0.07666808, 0.02507584)
+    }
+    
+    if(nrow(rhp_si) > 0) {
+      rhp_si$TimStuff <- scale_TimStuff(
+        predict(SI_model, as.matrix(cbind(
+          rhp_si$start_speed, rhp_si$IVB, rhp_si$HB, 
+          rhp_si$z0, rhp_si$x0, rhp_si$extension))), 
+        0.09427338, 0.01524531)
+    }
+    
+    if(nrow(rhp_ct) > 0) {
+      rhp_ct$TimStuff <- scale_TimStuff(
+        predict(CT_model, as.matrix(cbind(
+          rhp_ct$start_speed, rhp_ct$IVB, rhp_ct$HB, 
+          rhp_ct$z0, rhp_ct$x0, rhp_ct$extension))), 
+        0.01484248, 0.0001241943)
+    }
+    
+    if(nrow(rhp_sl) > 0) {
+      rhp_sl$TimStuff <- scale_TimStuff(
+        predict(SL_model, as.matrix(cbind(
+          rhp_sl$start_speed, rhp_sl$IVB, rhp_sl$HB, 
+          rhp_sl$spin_rate, rhp_sl$z0, rhp_sl$x0, rhp_sl$extension))), 
+        0.06669426, 0.01006894)
+    }
+    
+    if(nrow(rhp_cb) > 0) {
+      rhp_cb$TimStuff <- scale_TimStuff(
+        predict(CB_model, as.matrix(cbind(
+          rhp_cb$start_speed, rhp_cb$IVB, rhp_cb$HB, 
+          rhp_cb$spin_rate, rhp_cb$z0, rhp_cb$x0, rhp_cb$extension))), 
+        0.07480712, 0.01038754)
+    }
+    
+    if(nrow(rhp_ch_spl) > 0) {
+      rhp_ch_spl$TimStuff <- scale_TimStuff(
+        predict(CH_SPL_model, as.matrix(cbind(
+          rhp_ch_spl$start_speed, rhp_ch_spl$IVB, rhp_ch_spl$HB, 
+          rhp_ch_spl$z0, rhp_ch_spl$x0, rhp_ch_spl$extension, 
+          rhp_ch_spl$velo_diff, rhp_ch_spl$IVB_diff, rhp_ch_spl$HB_diff))), 
+        0.09255855, 0.01739746)
+    }
+    
+    # Combine all RHP pitch types
+    rhp <- rbind(rhp_ff, rhp_si, rhp_ct, rhp_sl, rhp_cb, rhp_ch_spl)
+    print("Rhp")
+    print(rhp)
+  }
+  
+  # Process left-handed pitchers by pitch type
+  if(nrow(lhp) > 0) {
+    # Split by pitch type
+    lhp_ff <- lhp %>% filter(pitch_name %in% c("Fastball","FourSeamFastBall"))
+    lhp_si <- lhp %>% filter(pitch_name %in% c("OneSeamFastBall","Sinker","TwoSeamFastBall"))
+    lhp_ct <- lhp %>% filter(pitch_name == "Cutter")
+    lhp_sl <- lhp %>% filter(pitch_name %in% c("Slider","Sweeper"))
+    lhp_cb <- lhp %>% filter(pitch_name == "Curveball")
+    lhp_ch_spl <- lhp %>% filter(pitch_name %in% c("Changeup", "ChangeUp","Splitter","Knuckleball"))
+    
+    # Apply models for each pitch type with appropriate scaling
+    if(nrow(lhp_ff) > 0) {
+      lhp_ff$TimStuff <- scale_TimStuff(
+        predict(FF_model, as.matrix(cbind(
+          lhp_ff$start_speed, lhp_ff$IVB, lhp_ff$HB, 
+          lhp_ff$z0, lhp_ff$x0, lhp_ff$extension))), 
+        0.07666808, 0.02507584)
+    }
+    
+    if(nrow(lhp_si) > 0) {
+      lhp_si$TimStuff <- scale_TimStuff(
+        predict(SI_model, as.matrix(cbind(
+          lhp_si$start_speed, lhp_si$IVB, lhp_si$HB, 
+          lhp_si$z0, lhp_si$x0, lhp_si$extension))), 
+        0.09427338, 0.01524531)
+    }
+    
+    if(nrow(lhp_ct) > 0) {
+      lhp_ct$TimStuff <- scale_TimStuff(
+        predict(CT_model, as.matrix(cbind(
+          lhp_ct$start_speed, lhp_ct$IVB, lhp_ct$HB, 
+          lhp_ct$z0, lhp_ct$x0, lhp_ct$extension))), 
+        0.01484248, 0.0001241943)
+    }
+    
+    if(nrow(lhp_sl) > 0) {
+      lhp_sl$TimStuff <- scale_TimStuff(
+        predict(SL_model, as.matrix(cbind(
+          lhp_sl$start_speed, lhp_sl$IVB, lhp_sl$HB, 
+          lhp_sl$spin_rate, lhp_sl$z0, lhp_sl$x0, lhp_sl$extension))), 
+        0.06669426, 0.01006894)
+    }
+    
+    if(nrow(lhp_cb) > 0) {
+      lhp_cb$TimStuff <- scale_TimStuff(
+        predict(CB_model, as.matrix(cbind(
+          lhp_cb$start_speed, lhp_cb$IVB, lhp_cb$HB, 
+          lhp_cb$spin_rate, lhp_cb$z0, lhp_cb$x0, lhp_cb$extension))), 
+        0.07480712, 0.01038754)
+    }
+    
+    if(nrow(lhp_ch_spl) > 0) {
+      lhp_ch_spl$TimStuff <- scale_TimStuff(
+        predict(CH_SPL_model, as.matrix(cbind(
+          lhp_ch_spl$start_speed, lhp_ch_spl$IVB, lhp_ch_spl$HB, 
+          lhp_ch_spl$z0, lhp_ch_spl$x0, lhp_ch_spl$extension, 
+          lhp_ch_spl$velo_diff, lhp_ch_spl$IVB_diff, lhp_ch_spl$HB_diff))), 
+        0.09255855, 0.01739746)
+    }
+    
+    # Combine all LHP pitch types
+    lhp <- rbind(lhp_ff, lhp_si, lhp_ct, lhp_sl, lhp_cb, lhp_ch_spl)
+  }
+  
+  # Combine all processed data
+  game_complete <- rbind(rhp, lhp, game_na)
+  
+  return(game_complete)
+}
+summary_table <- function(game) {
+  game <- calculatetimstuffall(game)
+  
+  if("TimStuff" %in% colnames(game)) {
+    game <- game %>%
+      mutate(TimStuff = ifelse(TimStuff < 50, NA, TimStuff))
+  }
+  
+  # Calculate main summary
+  main_summary <- game %>%
+    mutate(
+      team_fielding_id = ifelse(description %in% c("StrikeCalled", "StrikeSwinging"), 1, 0),
+      swing = ifelse(description %in% c("FoulBall", "StrikeSwinging", "InPlay","FoulBallNotFieldable"), 1, 0),
+      is_strike_swinging = as.integer(is_strike_swinging),
+      pitch_name = case_when(
+        pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+        pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+        pitch_name %in% c("ChangeUp") ~ "Changeup",
+        pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+        pitch_name %in% c("CutFastBall") ~ "Cutter",
+        TRUE ~ pitch_name
+      ),
+      Pitch = pitch_name,
+      FPS = case_when(description %in% c("StrikeCalled","StrikeSwinging","FoulBallNotFieldable","FoulBall","InPlay") ~ TRUE, TRUE ~ FALSE),
+    ) %>%
+    group_by(Pitch) %>%
+    summarize(
+      Pitches = n(),
+      'Pitch%' = round(n() / nrow(game) * 100, 1),
+      "FP Strike%" = round(mean(FPS[PitchNum == 1], na.rm = TRUE) * 100, 1),
+      'Avg. Velo' = round(mean(start_speed, na.rm = TRUE), 1),
+      'Top Velo' = round(max(start_speed, na.rm = TRUE), 1),  # Add Top Velo
+      'Spin Rate' = round(mean(spin_rate, na.rm = TRUE), 0),
+      'Extension' = round(mean(extension, na.rm = TRUE), 1),
+      'IVB' = round(mean(IVB, na.rm = TRUE), 1),
+      'HB' = round(mean(HB, na.rm = TRUE), 1),
+      'RelH' = round(mean(z0, na.rm = TRUE), digits = 1),
+      'RelS' = round(mean(x0, na.rm = TRUE), digits = 1),
+      'VAA' = round(mean(VAA, na.rm = TRUE), 1),
+      'CSW%' = round(sum(team_fielding_id, na.rm = TRUE) / sum(!is.na(team_fielding_id)) * 100, 1),
+      'Whiff%' = round(sum(is_strike_swinging, na.rm = TRUE) / sum(swing, na.rm = TRUE) * 100, 1),
+      'Stuff+' = if("TimStuff" %in% colnames(game)) round(mean(TimStuff, na.rm = TRUE), 0) else NA
+    ) %>%
+    arrange(-Pitches)
+  
+  # Calculate totals
+  total_row <- game %>%
+    mutate(
+      team_fielding_id = ifelse(description %in% c("StrikeCalled", "StrikeSwinging"), 1, 0),
+      swing = ifelse(description %in% c("FoulBall", "StrikeSwinging", "InPlay","FoulBallNotFieldable"), 1, 0),
+      is_strike_swinging = as.integer(is_strike_swinging),
+      FPS = case_when(description %in% c("StrikeCalled","StrikeSwinging","FoulBallNotFieldable","FoulBall") ~ TRUE, TRUE ~ FALSE)
+    ) %>%
+    summarize(
+      Pitch = "Total",
+      Pitches = n(),
+      'Pitch%' = 100,
+      "FP Strike%" = round(mean(FPS[PitchNum == 1], na.rm = TRUE) * 100, 1),
+      'Avg. Velo' = NA_real_,
+      'Top Velo' = round(max(start_speed, na.rm = TRUE), 1),  # Add overall top velo
+      'Spin Rate' = NA_real_,
+      'Extension' = round(mean(extension, na.rm = TRUE), 1),
+      'IVB' = NA_real_,
+      'HB' = NA_real_,
+      'RelH' = round(mean(z0, na.rm = TRUE), digits = 1),
+      'RelS' = round(mean(x0, na.rm = TRUE), digits = 1),
+      'VAA' = round(mean(VAA, na.rm = TRUE), 1),
+      'CSW%' = round(sum(team_fielding_id, na.rm = TRUE) / sum(!is.na(team_fielding_id)) * 100, 1),
+      'Whiff%' = round(sum(is_strike_swinging, na.rm = TRUE) / sum(swing, na.rm = TRUE) * 100, 1),
+      'Stuff+' = if("TimStuff" %in% colnames(game)) round(mean(TimStuff, na.rm = TRUE), 0) else NA
+    )
+  
+  # Combine main summary with total row
+  combined_summary <- bind_rows(main_summary, total_row) %>%
+    rename(
+      "Type" = Pitch, "#" = Pitches, "Velo" = `Avg. Velo`,
+      "Top" = `Top Velo`,  # Rename Top Velo to shorter column name
+      "Spin" = `Spin Rate`, "Ext" = Extension, "Usage%" = `Pitch%`
+    ) %>%
+    mutate(
+      "Usage%" = paste0(`Usage%`, "%"),
+      "Spin" = ifelse(Type == "Total", "-", format(round(as.numeric(Spin)), big.mark = ",")),
+      "Velo" = ifelse(Type == "Total", "-", as.character(Velo)),
+      "IVB" = ifelse(Type == "Total", "-", as.character(IVB)),
+      "HB" = ifelse(Type == "Total", "-", as.character(HB)),
+      `CSW%` = paste0(`CSW%`, "%"),
+      `Whiff%` = paste0(`Whiff%`, "%"),
+      `FP Strike%` = paste0(`FP Strike%`, "%")
+    )
+  
+  return(combined_summary)
+}
+
+FF_model <- readRDS("FF_model.rds")
+SI_model <- readRDS("SI_model.rds")
+CT_model <- readRDS("CT_model.rds")
+SL_model <- readRDS("SL_model.rds")
+CB_model <- readRDS("CB_model.rds")
+CH_SPL_model <- readRDS("CH_SPL_model.rds")
+
+team_data <- read.csv("teampic.csv") %>%
+  select(newestTeamName, newestTeamId) %>%
+  arrange(newestTeamName)  # Sort alphabetically
+
+# Modify the UI
+ui <- fluidPage(
+  titlePanel("Trackman Summary Card Demo"),
+  sidebarLayout(
+    sidebarPanel(
+      width = 3,
+      fileInput("incsv", "Input File", accept = c(".csv"), multiple = FALSE),
+      actionButton("update", "Load Pitchers", icon("magnifying-glass"),
+                   class = "btn-primary btn-block"),
+      selectizeInput("pitcher", "Pitcher Name:", NULL),
+      selectizeInput("teamName", "Team:", 
+                     choices = c("Default" = "default", setNames(team_data$newestTeamId, team_data$newestTeamName)),
+                     selected = "default"),
+      numericInput("rollnum", "Rolling Pitch #", c("1")),
+      textInput("pass", "Password"),
+      actionButton("update1", "Make Card", icon("plus"),
+                   class = "btn-success btn-block"),
+      downloadButton("downloadPlot", "Download Card", class = "btn-info btn-block")
     ),
-    hr(), # Add a horizontal rule
-    checkboxInput("by_species", "Show species", TRUE),
-    checkboxInput("show_margins", "Show marginal plots", TRUE),
-    checkboxInput("smooth", "Add smoother"),
-  ),
-  plotOutput("scatter")
+    mainPanel(
+      div(style = "width: 1000px; height: 1000px; overflow: auto;",
+          plotOutput("combinedPlot", width = "100%", height = "100%")
+      )
+    )
+  )
 )
 
+# Server Definition
 server <- function(input, output, session) {
-  subsetted <- reactive({
-    req(input$species)
-    df |> filter(Species %in% input$species)
+  
+  game_data <- reactiveVal()
+  
+  observeEvent(input$update, {
+    req(input$incsv)
+    df <- read.csv(input$incsv$datapath)
+    pname <- pitcher_summary(df)
+    game_data(pname)
+    if(nrow(pname) == 0) {
+      showNotification("No pitchers found for the selected game.", type = "warning")
+    } else {
+      updateSelectizeInput(session, "pitcher", "Pitcher:", choices = unique(pname$`Pitcher Name`))
+      game_data(pname)
+    }
   })
-
-  output$scatter <- renderPlot(
-    {
-      p <- ggplot(subsetted(), aes(!!input$xvar, !!input$yvar)) +
-        theme_light() +
-        list(
-          theme(legend.position = "bottom"),
-          if (input$by_species) aes(color = Species),
-          geom_point(),
-          if (input$smooth) geom_smooth()
+  
+  rolling_timstuff <- reactive({
+    req(input$update1, game_data())
+    game <- game_data() %>% filter(`Pitcher Name` == input$pitcher)# %>%
+    #   mutate(
+    #    pitch_name = case_when(
+    #        pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+    #        pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+    #        pitch_name %in% c("ChangeUp") ~ "Changeup",
+    #        pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+    #       pitch_name %in% c("CutFastBall") ~ "Cutter",
+    #        TRUE ~ pitch_name
+    #      ))
+    game <- calculatetimstuffall(game)
+    print("Test")
+    print(game)
+    print(nrow(game))
+    #names(game)
+    game <- game %>%
+      mutate(TimStuff = ifelse(TimStuff < 40, NA, TimStuff))
+    
+    custom_rollmean <- function(x, k) {
+      n <- length(x)
+      result <- numeric(n)
+      
+      for (i in 1:n) {
+        if (i < k) {
+          # For the first k-1 points, use a window size of 1 (i.e., the point itself)
+          result[i] <- x[i]
+        } else {
+          # For k and onwards, use the specified rolling window
+          window <- x[(i-k+1):i]
+          result[i] <- mean(window, na.rm = TRUE)
+        }
+      }
+      
+      return(result)
+    }
+    
+    result <- game %>%
+      group_by(pitch_name) %>%
+      mutate(
+        TimStuff = as.numeric(TimStuff),
+        rolling_timstuff = custom_rollmean(TimStuff, k = input$rollnum),
+        pitch_number = row_number()
+      ) %>%
+      ungroup()
+    
+    return(result)
+  })
+  
+  combinedPlot <- reactiveVal()
+  
+  observeEvent(input$update1,{
+    if(input$pass == pass){
+      req(game_data())
+      game <- game_data() %>% filter(`Pitcher Name` == input$pitcher)
+      
+      if(nrow(game) == 0) {
+        showNotification("No data available for the selected pitcher.", type = "warning")
+        return()
+      }
+      get_logo <- function() {
+        if (input$teamName != "default") {
+          # Try to get team logo using the selected team ID
+          logo_url <- paste0("https://static.trumedianetworks.com/images/ncaabaseball/teams/", input$teamName, ".png")
+          img_result <- download_and_process_image(logo_url)
+          
+          if (!is.null(img_result)) {
+            return(rasterGrob(img_result$img, interpolate = TRUE))
+          }
+        }
+        
+        # Fallback to default logo
+        default_url <- "https://pbs.twimg.com/profile_images/1754697221595910144/xziLC-5v_400x400.jpg"
+        img_result <- download_and_process_image(default_url)
+        
+        if (!is.null(img_result)) {
+          return(rasterGrob(img_result$img, interpolate = TRUE))
+        } else {
+          return(textGrob("Image not available", gp = gpar(col = "red", fontsize = 20)))
+        }
+      }
+      
+      # Get the logo once and use it twice
+      logo_grob <- get_logo()
+      
+      break_plot <- break_plot(game) + theme(legend.position = "none")
+      pitch_plots <- pitch_plot_split(game)
+      
+      table_data <- summary_table(game)
+      num_rows <- nrow(table_data)
+      
+      print(table_data)  
+      table_plot <- tableGrob(table_data, rows = NULL, theme = ttheme_minimal(
+        core = list(fg_params = list(hjust = 0.5, x = 0.5), bg_params = list(fill = "white")),
+        colhead = list(fg_params = list(hjust = 0.5, x = 0.5, fontface = "bold"), bg_params = list(fill = "#f0f0f0")),
+        rowhead = list(fg_params = list(hjust = 0.5, x = 0.5), bg_params = list(fill = "white"))
+      ))
+      
+      total_height <- unit(1, "npc")
+      row_height <- total_height / (num_rows + 1)
+      table_plot$heights <- unit(rep(row_height, num_rows + 1), "npc")
+      
+      table_plot$widths <- unit(c(
+        0.07,  # Type
+        0.04,  # #
+        0.08,  # Usage%
+        0.08,  # FP Strike%
+        0.05,  # Velo
+        0.05,  # Top
+        0.08,  # Spin
+        0.05,  # Ext
+        0.05,  # IVB
+        0.05,  # HB
+        0.04,  # RelH
+        0.04,  # RelS
+        0.06,  # VAA
+        0.06,  # CSW%
+        0.06,  # Whiff%
+        0.06   # Stuff+
+      ), "npc")
+      
+      for(i in seq(2, nrow(table_plot), 2)) {
+        table_plot$grobs[[i]]$gp$fill <- "#f9f9f9"
+      }
+      
+      milb_url <- "https://x.com/TimStats/photo"
+      mlb_url <- "https://pbs.twimg.com/profile_images/1754697221595910144/xziLC-5v_400x400.jpg"
+      img_result <- download_and_process_image(mlb_url)
+      if (is.null(img_result)) {
+        img_result <- download_and_process_image(milb_url)
+      }
+      
+      img_grob <- if (!is.null(img_result)) {
+        rasterGrob(img_result$img, interpolate = TRUE)
+      } else {
+        textGrob("Image not available", gp = gpar(col = "red", fontsize = 20))
+      }
+      
+      pitch_colors <- c(
+        "Four-Seam"= "#FF4136", "Sinker"= "#FF851B", "Cutter"= "#FFDC00",
+        "Changeup"= "#2ECC40", "Slider"= "#0074D9", "Sweeper"= "#ED68ED",
+        "Curveball"= "#B10DC9", "Splitter"= "#01FF70", "Knuckle Curve"= "#85144b",
+        "Slurve"= "#3D9970", "Knuckle Ball"= "#39CCCC", "Two-Seam Fastball"= "#F012BE",
+        "Eephus"= "#AAAAAA", "Fastball"= "#7FDBFF", "Slow Curve"= "#DDDDDD",
+        "Screwball"= "#FF69B4"
+      )
+      
+      # Create the rolling TimStuff+ graph
+      rolling_data <- rolling_timstuff() %>%
+        mutate(
+          pitch_name = case_when(
+            pitch_name %in% c("Fastball", "FourSeamFastBall") ~ "Four-Seam",
+            pitch_name %in% c("TwoSeamFastBall", "OneSeamFastBall", "Sinker") ~ "Sinker",
+            pitch_name %in% c("ChangeUp") ~ "Changeup",
+            pitch_name %in% c("KnuckleCurve") ~ "Knuckle Curve",
+            pitch_name %in% c("CutFastBall") ~ "Cutter",
+            TRUE ~ pitch_name
+          ))
+      timstuff_plot <- ggplot(rolling_data, aes(x = pitch_number, y = rolling_timstuff, color = pitch_name)) +
+        geom_line(size = 1, na.rm = TRUE) +
+        geom_point(size = 1, na.rm = TRUE) +
+        scale_color_manual(values = pitch_colors) +
+        theme_minimal() +
+        labs(title = paste0(input$rollnum,"-Pitch Rolling Stuff+"),
+             x = "Pitch Number", y = "Stuff+") +
+        scale_y_continuous(limits = c(70, 130), na.value = NA) +
+        scale_x_continuous(breaks = seq(input$rollnum, max(rolling_data$pitch_number, na.rm = TRUE), by = input$rollnum), limits = c(input$rollnum, NA)) +
+        theme(
+          plot.title = element_text(hjust = 0.5, face = "bold"),
+          legend.position = "none",
+          panel.grid.major.x = element_line(color = "gray", size = 0.5)
         )
-
-      if (input$show_margins) {
-        margin_type <- if (input$by_species) "density" else "histogram"
-        p <- p |> ggExtra::ggMarginal(
-          type = margin_type, margins = "both",
-          size = 8, groupColour = input$by_species, groupFill = input$by_species
+      
+      # If there's no valid data, display a message
+      if(all(is.na(rolling_data$rolling_timstuff))) {
+        timstuff_plot <- ggplot() + 
+          theme_void() +
+          labs(title = "Insufficient data for Stuff+ calculation") +
+          theme(
+            plot.title = element_text(hjust = 0.5, face = "bold")
+          )
+      }
+      
+      title_text <- textGrob(
+        paste(input$pitcher, input$title, "Summary Card by @TimStats"),
+        gp = gpar(fontsize = 16, fontface = "bold")
+      )
+      
+      data_source_text <- textGrob(
+        " ",
+        gp = gpar(fontsize = 8),
+        x = unit(1, "npc") - unit(2, "mm"),
+        y = unit(2, "mm"),
+        just = c("right", "bottom")
+      )
+      
+      legend <- if(nrow(rolling_data) > 0) {
+        get_legend(
+          ggplot(rolling_data, aes(x = pitch_number, y = rolling_timstuff, color = pitch_name)) +
+            geom_point(size = 5) +
+            scale_color_manual(values = pitch_colors) +
+            theme(legend.position = "bottom",
+                  legend.title = element_blank(),
+                  text = element_text(size = 12.5),
+                  legend.box = "horizontal" ) +
+            guides(color = guide_legend(nrow = 1))
         )
+      } else {
+        ggplotGrob(ggplot() + theme_void())
       }
-
-      p
-    },
-    res = 100
-  )
+      
+      # Combine all plots
+      combined <- grid.arrange(
+        # Row 1: Title and Player Image
+        arrangeGrob(
+          img_grob,
+          title_text,
+          logo_grob,
+          ncol = 3,
+          widths = c(1, 2, 1)
+        ),
+        
+        # Row 2: Rolling TimStuff+ graph and boxscore
+        arrangeGrob(
+          timstuff_plot,
+          break_plot,
+          ncol = 2,
+          widths = c(2,1)
+        ),
+        
+        # Row 3: Three plots in a row
+        arrangeGrob(
+          pitch_plots$lhb,
+          pitch_plots$rhb,
+          ncol = 2,
+          widths = c(1,1)
+        ),
+        
+        # Row 4: Legend
+        legend,
+        
+        # Row 5: Pitch summary table
+        table_plot,
+        
+        # Layout parameters
+        nrow = 5,
+        heights = c(0.8, 1.2, 1.2, 0.2, 1)
+      )
+      grid.arrange(
+        gtable_add_padding(
+          combined,
+          padding = unit(c(20, 20, 20, 20), "points")  # top, right, bottom, left margins
+        )
+      ) 
+      combinedPlot(combined)
+      
+      output$combinedPlot <- renderPlot({
+        grid.draw(combinedPlot())
+      }, width = 1200, height = 1200)
+      
+      output$combinedPlot <- renderPlot({
+        grid.draw(combinedPlot())
+      }, width = 1000, height = 1000)  # Modified to be square
+      
+      # Update the download handler dimensions
+      output$downloadPlot <- downloadHandler(
+        filename = function() {
+          paste("baseball_card_", Sys.Date(), ".png", sep = "")
+        },
+        content = function(file) {
+          ggsave(file, plot = combinedPlot(), width = 15, height = 15, dpi = 300, units = "in")  # Modified to be square
+        }
+      )
+    }
+    else{
+      failplot <- ggplot() +
+        annotate("text", x = 0.5, y = 0.5, label = "Incorrect Password", 
+                 size = 10, color = "red") +
+        theme_void() +
+        theme(plot.background = element_rect(fill = "white", color = NA))
+      output$combinedPlot <- renderPlot({
+        failplot
+      })
+    }
+  })
 }
 
-shinyApp(ui, server)
+# Run the application
+shinyApp(ui = ui, server = server)