请求将两类R脚本转换为Shiny应用：存CSV绘图及多交互流程脚本

Hey there! Converting your two types of R scripts into Shiny apps is totally doable—let’s tackle each case with concrete, working examples so you can adapt them to your specific code.

This is the straightforward one: we’ll build a Shiny app that lets users upload data (or use sample data), generate a plot, and download the processed data as a CSV.

UI Setup #

The UI will include core elements to support the workflow:

• A file input to load user data
• An action button to trigger processing and plot generation
• A plot display area
• A download button to save the final CSV

library(shiny)
library(ggplot2)

ui <- fluidPage(
  titlePanel("Basic CSV & Plot Shiny App"),
  sidebarLayout(
    sidebarPanel(
      # File input for user's CSV
      fileInput("upload_data", "Upload your CSV file", accept = ".csv"),
      # Button to start processing
      actionButton("run_process", "Generate Plot & Prepare CSV"),
      br(), br(),
      # Download button for processed CSV
      downloadButton("download_csv", "Save Processed CSV")
    ),
    mainPanel(
      # Plot output container
      plotOutput("data_plot")
    )
  )
)

Server Logic #

We’ll use reactiveValues to store processed data so it’s accessible across both plotting and download functions. This ensures consistency between the plot and the saved CSV.

server <- function(input, output, session) {
  # Store processed data across reactive contexts
  rv <- reactiveValues(processed_data = NULL)
  
  # Trigger processing when the button is clicked
  observeEvent(input$run_process, {
    # Load data: use uploaded file or fallback to sample mtcars
    if (!is.null(input$upload_data)) {
      rv$processed_data <- read.csv(input$upload_data$datapath)
    } else {
      rv$processed_data <- mtcars
      message("Using sample mtcars data since no file was uploaded")
    }
    
    # Add your custom data processing here (e.g., filtering, transformations)
    # rv$processed_data <- rv$processed_data %>% dplyr::filter(mpg > 20)
  })
  
  # Render the plot using your custom logic
  output$data_plot <- renderPlot({
    req(rv$processed_data) # Wait until data is available
    
    # Replace this with your existing plotting code
    ggplot(rv$processed_data, aes(x = wt, y = mpg)) +
      geom_point(color = "navy", size = 2) +
      labs(title = "Vehicle Weight vs. Fuel Efficiency", 
           x = "Weight (1000 lbs)", 
           y = "Miles per Gallon") +
      theme_minimal()
  })
  
  # Handle CSV download
  output$download_csv <- downloadHandler(
    filename = function() {
      paste0("processed_data_", Sys.Date(), ".csv")
    },
    content = function(file) {
      req(rv$processed_data)
      # Replace with your custom write.csv logic (e.g., exclude columns, add metadata)
      write.csv(rv$processed_data, file, row.names = FALSE)
    }
  )
}

# Run the app
shinyApp(ui, server)

Quick Tips #

• Swap the sample plot code with your existing R script’s plotting logic
• Add any data cleaning/transformations inside the observeEvent(input$run_process) block
• Use req() to ensure Shiny doesn’t try to render elements before data is ready

This case requires managing a sequential workflow: load special format file → background processing → collect user input → save editable CSV → re-upload edited CSV → final processing & plots. We’ll use reactiveValues to track state across steps and conditional UI to guide users through the process.

For this example, we’ll assume your "special format" is an Excel file (replace read_excel with your package’s parsing function, e.g., haven::read_sav() for SPSS files or raster::raster() for GIS data).

UI Setup #

We’ll use conditionalPanel to show/hide elements based on the current workflow step:

library(shiny)
library(readxl)
library(ggplot2)
library(dplyr)

ui <- fluidPage(
  titlePanel("Complex Multi-Step Shiny App"),
  sidebarLayout(
    sidebarPanel(
      # Step 1: Upload special format file
      conditionalPanel(
        condition = "input.step == 1",
        fileInput("special_file", "Upload Special Format File", accept = ".xlsx"),
        actionButton("step1_next", "Process Data & Move to Next Step")
      ),
      
      # Step 2: Collect user input & manage editable CSV
      conditionalPanel(
        condition = "input.step == 2",
        numericInput("user_threshold", "Enter Threshold Value", min = 0, max = 100, value = 50),
        actionButton("generate_editable", "Generate CSV for Editing"),
        downloadButton("download_editable", "Download CSV to Edit"),
        br(), br(),
        p("*Edit the CSV (fill in empty columns) then upload it below*"),
        fileInput("edited_csv", "Upload Edited CSV"),
        actionButton("step2_next", "Continue to Final Processing")
      ),
      
      # Step 3: Final processing & results
      conditionalPanel(
        condition = "input.step == 3",
        actionButton("run_final", "Run Final Analysis"),
        downloadButton("download_final", "Save Final Results")
      )
    ),
    mainPanel(
      # Hidden input to track current step
      hidden(radioButtons("step", "Current Step", choices = c(1,2,3), selected = 1)),
      # Plot outputs for intermediate and final results
      plotOutput("intermediate_plot"),
      plotOutput("final_plot")
    )
  )
)

Server Logic #

We’ll use reactiveValues to store all intermediate data, and update the hidden step input to navigate between workflow stages.

server <- function(input, output, session) {
  # Store all intermediate data
  rv <- reactiveValues(
    raw_special = NULL,
    processed_step1 = NULL,
    user_input = NULL,
    editable_data = NULL,
    edited_data = NULL,
    final_results = NULL
  )
  
  # Step 1: Process special format file
  observeEvent(input$step1_next, {
    req(input$special_file)
    
    # Replace with your special file parsing code
    rv$raw_special <- read_excel(input$special_file$datapath)
    
    # Add your backend processing logic here
    rv$processed_step1 <- rv$raw_special %>%
      mutate(log_value = log(measurement_column)) # Example transformation
    
    # Move to step 2
    updateRadioButtons(session, "step", selected = 2)
  })
  
  # Step 2: Generate editable CSV with empty columns for user input
  observeEvent(input$generate_editable, {
    req(rv$processed_step1, input$user_threshold)
    rv$user_input <- input$user_threshold
    
    # Create CSV with empty columns for user to fill
    rv$editable_data <- rv$processed_step1 %>%
      mutate(
        user_note = NA_character_, # Columns for user to edit
        verified = NA_logical_
      )
  })
  
  # Download editable CSV
  output$download_editable <- downloadHandler(
    filename = function() {
      paste0("editable_data_", Sys.Date(), ".csv")
    },
    content = function(file) {
      req(rv$editable_data)
      write.csv(rv$editable_data, file, row.names = FALSE)
    }
  )
  
  # Step 2: Upload edited CSV and move to step 3
  observeEvent(input$step2_next, {
    req(input$edited_csv)
    rv$edited_data <- read.csv(input$edited_csv$datapath)
    
    # Move to step 3
    updateRadioButtons(session, "step", selected = 3)
  })
  
  # Step 3: Final processing and plots
  observeEvent(input$run_final, {
    req(rv$edited_data, rv$user_input)
    
    # Add your final processing logic here
    rv$final_results <- rv$edited_data %>%
      filter(log_value > rv$user_input) %>%
      mutate(final_score = log_value * ifelse(verified, 1.5, 1))
    
    # Render intermediate plot (from step 1 processing)
    output$intermediate_plot <- renderPlot({
      ggplot(rv$processed_step1, aes(x = log_value)) +
        geom_histogram(fill = "teal", alpha = 0.7) +
        labs(title = "Intermediate Processed Data")
    })
    
    # Render final plot
    output$final_plot <- renderPlot({
      ggplot(rv$final_results, aes(x = final_score, y = user_note)) +
        geom_point(color = "darkred", size = 3) +
        labs(title = "Final Analysis Results", 
             subtitle = paste("Using Threshold:", rv$user_input))
    })
  })
  
  # Download final results
  output$download_final <- downloadHandler(
    filename = function() {
      paste0("final_results_", Sys.Date(), ".csv")
    },
    content = function(file) {
      req(rv$final_results)
      write.csv(rv$final_results, file, row.names = FALSE)
    }
  )
}

# Run the app
shinyApp(ui, server)

Key Notes #

• Special file parsing: Replace read_excel with your package’s function for your specific file format
• Workflow customization: Update the processing steps (mutations, filters) to match your existing script
• State management: reactiveValues is critical here to keep data accessible across all workflow steps
• Conditional UI: conditionalPanel ensures users only see elements relevant to their current stage, reducing confusion

内容的提问来源于stack exchange，提问作者Mohammad