Plot interactivity

[AnttiRask]

@spsanderson, I had some spare time today to just have fun without any expectations, and this is what I started experimenting with:

That's me using ggiraph on top of the basic visualization.

• tooltip doesn't work properly yet, but you get the idea from the image
• it's cool (at least to me) how the hover effect highlights the same walk number on all of the plots
• you can easily zoom in on any of the plots using the mouse pointer to draw a rectangle (see the image below)

You can also easily download the png to your computer by just clicking the download icon. This is what the output looks like:

Now, for comparison, I will next try and see what the same would look like using ggplotly. But if you have any requirements or wishes that you would like to see in the interactive version(s), let me know and I'll see what I can do!

[AnttiRask]

And I got the tooltip to work as I wanted! Granted, I had to add points in addition to the line graph to get that done. Maybe there is a more straightforward way to do it, but I don't think it's that bad of a compromise either way.

By the way, here's the code so far:

visualize_walks_interactive <- function(.data, .alpha = 0.7) {
    
    # Retrieve the attributes of the data
    atb <- attributes(.data)
    
    # Function to generate a plot for a given variable
    generate_plot <- function(y_var) {
        
        # Convert y_label to a pretty format if it's not "y"
        y_label_pretty <- ifelse(y_var == "y", "y", convert_snake_to_title_case(y_var))
        
        # Create the tooltip text in a new column
        .data <- .data |>
            dplyr::mutate(
                .tooltip = paste0(
                    "walk_number: ", walk_number, " | ",
                    "x: ", x, " | ",
                    y_var, ": ", round(get(y_var), digits = 3)
                )
            )
        
        # Create a ggplot object
        p <- ggplot2::ggplot(
            .data,
            ggplot2::aes(
                x       = x,
                y       = get(y_var),
                color   = walk_number,
                group   = walk_number,
                data_id = walk_number,
                tooltip = .tooltip
            )
        ) +
            # Plot lines with some transparency
            ggiraph::geom_line_interactive(alpha = .alpha) +
            ggiraph::geom_point_interactive(
                alpha = .alpha,
                size  = 0.1
            ) +
            # Use a minimal theme
            ggplot2::theme_minimal() +
            # Remove the legend
            ggplot2::theme(legend.position = "none") +
            # Set the labels for the plot
            ggplot2::labs(title = y_label_pretty, x = "Step", y = NULL)
        
        return(p)
    }
    
    # Identify variables to plot, excluding 'walk_number' and 'x'
    plot_vars <- setdiff(atb$names, c("walk_number", "x"))
    
    # Generate a list of plots for each variable
    plots <- lapply(plot_vars, generate_plot)
    
    # Generate a subtitle for the combined plot based on the function name
    .subtitle <- paste0("Function: ", ifelse(atb$fns == "rw30", "rw30", convert_snake_to_title_case(atb$fns)))
    
    # Generate the plot caption dynamically based on attributes
    .caption <- generate_caption(atb)
    
    # Define annotations for the combined plot
    plot_annotations <- patchwork::plot_annotation(
        title    = paste0(atb$num_walks, " Random Walks"),
        subtitle = .subtitle,
        caption  = .caption
    )
    
    # Define plot options for ggiraph
    plot_options <- list(
        ggiraph::opts_hover(css = "stroke:black;stroke-width:2pt;"),
        ggiraph::opts_hover_inv(css = "opacity:0.4;"),
        ggiraph::opts_toolbar(position = "bottom"),
        ggiraph::opts_tooltip(
            offx           = 200,
            offy           = 5,
            use_cursor_pos = FALSE,
            opacity        = 0.7
        ),
        ggiraph::opts_zoom(max = 5)
    )
    
    # Combine plots using patchwork or return a single plot
    combined_plot <- if (length(plots) > 1) {
        ggiraph::girafe(
            ggobj   = patchwork::wrap_plots(plots) + plot_annotations,
            options = plot_options
        )
    } else {
        ggiraph::girafe(
            ggobj   = plots[[1]] + plot_annotations,
            options = plot_options 
        )
    }
    
    # Return the final combined plot
    return(combined_plot)
}

Had to use dplyr to add the tooltip column. Other than that (and ggiraph, obviously), I managed to do everything with base R. It's actually a fun exercise for me because I am a (known) tidyverse fanboy!

[AnttiRask]

When it comes to plotly, the biggest downside is that it's not compatible with the patchwork package. There is a subplot() function within plotly, but I'm not yet convinced that it will work as well. Here's what it looks like out of the box:

I will give it a fair chance, though! Meaning that I will spend more time with it and try to tweak everything to make it prettier. We shall see!

[spsanderson]

I would say because plotly and patchwork are not compatible then use ggiraph Very cool by the way.

@AnttiRask I would also keep this function as maybe internal or add the code to visualize_walks() so that we can have .interactive as a parameter. I also envision having a parameter like .pluck or type so that someone does not have to write:

random_normal_walk() |>
  visualize_walks() |>
  purrr::pluck(1)

Bur rather something like:

random_normal_walk() |>
  visualize_walks(.interactive = TRUE, .pluck = 2)

thoughts?

I am going to make an issue for this for the 0.2.0 release as I think we are good to go for a 0.1.0 right now. I like where you are going with this.

[AnttiRask]

Good ideas both of them! Was going to ask which way to go and this makes sense.

Also, I'm happy with ggiraph and prefer it to plotly also because of aesthetic reasons.

I'll continue tinkering!

[spsanderson]

Excellent. Also in the next release 0.2.0 I am going to change the way parameters are stored in the attributes, right now they are like .mu = .mu etc, I am going to create a list in the attributes like:

> param_list <- list(.mu = 0, .sd = 1)
> param_list
$.mu
[1] 0

$.sd
[1] 1

> unlist(param_list)
.mu .sd 
  0   1 

attr(df, "param_grid") <- param_list

> paste0(names(param_list)," = ", unlist(param_list))
[1] ".mu = 0" ".sd = 1"

This way you don't have to pick and choose the parameters of the function being passed, rather you can just expand out param_list

This will probably end up needing it's own extractor but I'm not sure at this point yet so don't code anything for it.

[spsanderson]

I am closing this discussion as you have already added interactivity. I am implementing dimensions 1 and 2 into the development branch. This will mean an update to visualize walks.