Update app.R

app.R

@@ -2,9 +2,8 @@
 
 library(shiny)
 library(dplyr)
-library(plotly)
 library(fields)  # For image.plot in heatMap
-library(akima)   # For interpolation in heatMap
+library(akima)   # For interpolation
 
 # Load the data from sm.csv
 sm <- read.csv("sm.csv")
@@ -16,7 +15,7 @@ f2n <- function(x) as.numeric(as.character(x))
 sm$MaxImageDimsLeft <- unlist(lapply(strsplit(sm$MaxImageDims, split = "_"), function(x) sort(f2n(x))[1]))
 sm$MaxImageDimsRight <- unlist(lapply(strsplit(sm$MaxImageDims, split = "_"), function(x) sort(f2n(x))[2]))
 
-# Define the heatMap function (unchanged except for updated default color palette)
+# Heatmap function with optimal_point parameter
 heatMap <- function(x, y, z,
                     main = "",
                     N, yaxt = NULL,
@@ -40,7 +39,8 @@ heatMap <- function(x, y, z,
                     includeMarginals = FALSE,
                     marginalJitterSD_x = 0.01,
                     marginalJitterSD_y = 0.01,
-                    openBrowser = FALSE) {
+                    openBrowser = FALSE,
+                    optimal_point = NULL) {
   if (openBrowser) { browser() }
   s_ <- akima::interp(x = x, y = y, z = z,
                       xo = seq(min(x), max(x), length = N),
@@ -78,11 +78,16 @@ heatMap <- function(x, y, z,
     points(rep(xlim[1] * 1.1, length(x)),
            y + rnorm(length(y), sd = sd(y) * marginalJitterSD_y), pch = "-", col = "darkgray")
   }
+  
+  # Add green star at optimal point if provided
+  if (!is.null(optimal_point)) {
+    points(optimal_point$x, optimal_point$y, pch = 8, col = "green", cex = 3, lwd = 4)
+  }
 }
 
 # UI Definition
 ui <- fluidPage(
-  titlePanel("Multiscale Heatmap & Surface Explorer"),
+  titlePanel("Multiscale Heatmap Explorer"),
   sidebarLayout(
     sidebarPanel(
       selectInput("application", "Application",
@@ -91,27 +96,29 @@ ui <- fluidPage(
       selectInput("model", "Model",
                   choices = unique(sm$optimizeImageRep),
                   selected = "clip"),
-      # Removed "Perturb Center" input
       selectInput("metric", "Metric",
                   choices = c("AUTOC_rate_std_ratio_mean", "AUTOC_rate_mean", "AUTOC_rate_std_mean",
                               "AUTOC_rate_std_ratio_mean_pc", "AUTOC_rate_mean_pc", "AUTOC_rate_std_mean_pc",
                               "MeanVImportHalf1", "MeanVImportHalf2", "FracTopkHalf1", "RMSE"),
                   selected = "AUTOC_rate_std_ratio_mean"),
-      radioButtons("plotType", "Plot Type",
-                   choices = c("Heatmap", "Surface"),
-                   selected = "Heatmap")
+      checkboxInput("compareToBest", "Compare to best single scale", value = FALSE)
     ),
     mainPanel(
-      uiOutput("plotOutput")
+      plotOutput("heatmapPlot", height = "600px")
     )
   )
 )
 
 # Server Definition
 server <- function(input, output) {
+  # Function to determine whether to maximize or minimize the metric
+  get_better_direction <- function(metric) {
+    #if (grepl("std|RMSE", metric)) "min" else "max"
+    if (grepl(metric, pattern = "std_mean|RMSE")) "min" else "max"
+  }
+  
   # Reactive data processing
   filteredData <- reactive({
-    # Removed filtering by 'perturbCenter'
     df <- sm %>%
       filter(application == input$application,
              optimizeImageRep == input$model) %>%
@@ -122,26 +129,12 @@ server <- function(input, output) {
     df
   })
   
-  # Render the plot output dynamically
-  output$plotOutput <- renderUI({
-    data <- filteredData()
-    if (is.null(data)) {
-      return(tags$p("No data available for the selected filters."))
-    }
-    
-    if (input$plotType == "Heatmap") {
-      plotOutput("heatmapPlot", height = "600px")
-    } else {
-      plotlyOutput("surfacePlot", height = "600px")
-    }
-  })
-  
-  # Heatmap Output
-  output$heatmapPlot <- renderPlot({
+  # Reactive expression to compute interpolated data and optimal point
+  interpolated_data <- reactive({
     data <- filteredData()
     if (is.null(data)) return(NULL)
     
-    # Group data for heatmap
+    # Group data
     grouped_data <- data %>%
       group_by(MaxImageDimsLeft, MaxImageDimsRight) %>%
       summarise(
@@ -151,81 +144,115 @@ server <- function(input, output) {
         .groups = "drop"
       )
     
-    # Check for sufficient data points for interpolation
-    if (nrow(grouped_data) < 3) {
-      plot.new()
-      text(0.5, 0.5, "Insufficient data points for interpolation", cex = 1.5)
+    better_dir <- get_better_direction(input$metric)
+    single_scale_data <- grouped_data %>% filter(MaxImageDimsLeft == MaxImageDimsRight)
+    best_single_scale_metric <- if (nrow(single_scale_data) > 0) {
+      if (better_dir == "max") max(single_scale_data$mean_metric, na.rm = TRUE)
+      else min(single_scale_data$mean_metric, na.rm = TRUE)
+    } else NA
+    
+    grouped_data <- grouped_data %>%
+      mutate(improvement = if (better_dir == "max") {
+        mean_metric - best_single_scale_metric
+      } else {
+        best_single_scale_metric - mean_metric
+      })
+    
+    # Select z based on checkbox
+    z_to_interpolate <- if (input$compareToBest) grouped_data$improvement else grouped_data$mean_metric
+    x <- grouped_data$MaxImageDimsLeft
+    y <- grouped_data$MaxImageDimsRight
+    
+    # Check if interpolation is possible
+    if (length(unique(x)) < 2 || length(unique(y)) < 2 || nrow(grouped_data) < 3) {
+      return(NULL)
+    }
+    
+    # Compute interpolated grid
+    s_ <- akima::interp(x = x, 
+                        y = y, 
+                        z = z_to_interpolate,
+                        xo = seq(min(x), max(x), length = 50),
+                        yo = seq(min(y), max(y), length = 50),
+                        duplicate = "mean")
+  
+    # Find optimal point from interpolated grid
+    max_idx <- if (input$compareToBest || better_dir == "max") {
+      which.max(s_$z)
     } else {
-      x <- grouped_data$MaxImageDimsLeft
-      y <- grouped_data$MaxImageDimsRight
-      z <- grouped_data$mean_metric
-      
-      # Slightly more appealing color palette
-      customPalette <- colorRampPalette(c("blue", "white", "red"))(50)
-      
-      heatMap(x = x,
-              y = y,
-              z = z,
-              N = 50,
-              main = paste(input$application, "-", input$metric),
-              # More descriptive axis labels
-              xlab = "Maximum Image Dimensions (Left)",
-              ylab = "Maximum Image Dimensions (Right)",
-              useLog = "xy",
-              myCol = customPalette,
-              cex.lab = 1.4)
+      which.min(s_$z)
     }
+    
+    row_col <- arrayInd(max_idx, .dim = dim(s_$z))
+    optimal_x <- s_$x[row_col[1,1]]
+    optimal_y <- s_$y[row_col[1,2]]
+    optimal_z <- s_$z[row_col[1,1], row_col[1,2]]
+    
+    list(s_ = s_, 
+         optimal_point = list(x = optimal_x, 
+                              y = optimal_y, 
+                              z = optimal_z))
   })
   
-  # Surface Plot Output
-  output$surfacePlot <- renderPlotly({
-    data <- filteredData()
-    if (is.null(data)) return(NULL)
+  # Heatmap Output
+  output$heatmapPlot <- renderPlot({
+    interp_data <- interpolated_data()
+    if (is.null(interp_data)) {
+      plot.new()
+      text(0.5, 0.5, "Insufficient data for interpolation", cex = 1.5)
+      return(NULL)
+    }
     
-    # Group data for surface plot
+    data <- filteredData()
     grouped_data <- data %>%
       group_by(MaxImageDimsLeft, MaxImageDimsRight) %>%
       summarise(
         mean_metric = mean(as.numeric(get(input$metric)), na.rm = TRUE),
-        se_metric = sd(as.numeric(get(input$metric)), na.rm = TRUE) / sqrt(n()),
-        n = n(),
         .groups = "drop"
       )
     
-    # Create grid for surface plot
-    all_scales <- sort(unique(c(grouped_data$MaxImageDimsLeft, grouped_data$MaxImageDimsRight)))
-    z_matrix <- matrix(NA, nrow = length(all_scales), ncol = length(all_scales))
-    tooltip_matrix <- matrix("", nrow = length(all_scales), ncol = length(all_scales))
+    better_dir <- get_better_direction(input$metric)
+    single_scale_data <- grouped_data %>% filter(MaxImageDimsLeft == MaxImageDimsRight)
+    best_single_scale_metric <- if (nrow(single_scale_data) > 0) {
+      if (better_dir == "max") max(single_scale_data$mean_metric, na.rm = TRUE)
+      else min(single_scale_data$mean_metric, na.rm = TRUE)
+    } else NA
     
-    for (i in 1:nrow(grouped_data)) {
-      left_idx <- which(all_scales == grouped_data$MaxImageDimsLeft[i])
-      right_idx <- which(all_scales == grouped_data$MaxImageDimsRight[i])
-      z_matrix[left_idx, right_idx] <- grouped_data$mean_metric[i]
-      tooltip_matrix[left_idx, right_idx] <- sprintf("Mean: %.2f<br>SE: %.2f<br>n: %d",
-                                                     grouped_data$mean_metric[i],
-                                                     grouped_data$se_metric[i],
-                                                     grouped_data$n[i])
+    grouped_data <- grouped_data %>%
+      mutate(improvement = if (better_dir == "max") {
+        mean_metric - best_single_scale_metric
+      } else {
+        best_single_scale_metric - mean_metric
+      })
+    
+    x <- grouped_data$MaxImageDimsLeft
+    y <- grouped_data$MaxImageDimsRight
+    if (input$compareToBest) {
+      z <- grouped_data$improvement
+      main <- paste(input$application, "-", input$metric, "improvement over best single scale")
+      max_abs <- max(abs(z), na.rm = TRUE)
+      zlim <- if (!is.na(max_abs)) c(-max_abs, max_abs) else NULL
+    } else {
+      z <- grouped_data$mean_metric
+      main <- paste(input$application, "-", input$metric)
+      zlim <- range(z, na.rm = TRUE)  # Changed from zlim <- NULL
     }
     
-    # Render interactive 3D surface plot
-    plot_ly(
-      x = all_scales,
-      y = all_scales,
-      z = z_matrix,
-      type = "surface",
-      text = tooltip_matrix,
-      hoverinfo = "text"
-    ) %>%
-      layout(
-        title = paste("Surface Plot for", input$metric, "in", input$application),
-        scene = list(
-          xaxis = list(title = "Maximum Image Dimensions (Right)"),
-          yaxis = list(title = "Maximum Image Dimensions (Left)"),
-          zaxis = list(title = input$metric)
-        )
-      )
+    customPalette <- colorRampPalette(c("blue", "white", "red"))(50)
+    heatMap(x = x,
+            y = y,
+            z = z,
+            N = 50,
+            main = main,
+            xlab = "Image Dimension 1",
+            ylab = "Image Dimensions 2",
+            useLog = "xy",
+            myCol = customPalette,
+            cex.lab = 1.4,
+            zlim = zlim,
+            optimal_point = interp_data$optimal_point)
   })
 }
 
 # Run the Shiny App
-shinyApp(ui = ui, server = server)
+shinyApp(ui = ui, server = server)