Day 12 and Last Day: 30-days to learn rgl, plotly, and gganimate - Create a Time-Based 3D Animation Using rgl and gganimate

 

N.B.: This is the last of learning a combination of rgl, plotly, and gganimate, as it becomes difficult to combine all these at this time.  

Step 1: Install Required Packages

Before starting, ensure the following packages are installed:

install.packages(c("rgl", "ggplot2", "gganimate", "ggimage"))

---

Step 2: Generate 3D Frames Using rgl

1.     Setup the Environment: Create a 3D scatter plot that rotates over time.

library(rgl)

# Create a 3D scatter plot

n <- 100  # Number of points

x <- rnorm(n)

y <- rnorm(n)

z <- rnorm(n)

col <- rainbow(n)

open3d()  # Initialize the 3D plot

plot3d(x, y, z, col = col, size = 5)

2.     Rotate and Save Frames: Capture frames by rotating the plot over time and saving each frame as an image.

frames_dir <- "frames"

dir.create(frames_dir, showWarnings = FALSE)  # Create a directory for frames

# Generate and save frames

for (i in 1:100) {

    view3d(userMatrix = rotationMatrix(pi * i / 50, 0, 1, 0))  # Rotate around Y-axis

    snapshot3d(file.path(frames_dir, paste0("frame_", sprintf("%03d", i), ".png")))

}

---

Step 3: Animate Frames Using gganimate

1.     Prepare Frame Data: Load the saved frames and prepare a data frame for animation.

library(ggplot2)

library(gganimate)

library(ggimage)

# List saved frames

frame_paths <- list.files(frames_dir, full.names = TRUE)

# Create a data frame

frame_df <- data.frame(

    frame = frame_paths,

    time = 1:length(frame_paths),  # Time points for animation

    x = 0,  # Placeholder for x-coordinate

    y = 0   # Placeholder for y-coordinate

)

2.     Build the Animation: Use gganimate to create the animation from the frames.

animation <- ggplot(frame_df, aes(x = x, y = y, image = frame)) +

    geom_image(size = 1) +              # Add images to the plot

    transition_time(time) +            # Transition over the time variable

    enter_fade() +                     # Fade-in effect

    exit_fade() +                      # Fade-out effect

    theme_void()                       # Remove unnecessary plot elements

3.     Save the Animation: Export the animation as a GIF.

anim_save("3d_time_animation.gif", animation)

---

Step 4: Review and Debug

• Check the saved animation in your working directory (3d_time_animation.gif).
• If the animation doesn’t look smooth, adjust the number of frames or transition settings.

---

Key Notes

1. Custom Rotation: You can modify the view3d() function to rotate around different axes or add zoom effects.
2. Image Quality: Ensure the rgl frames are saved with high resolution for better animation quality.
3. Animation Effects: Experiment with different gganimate effects like ease_aes() or transitions (transition_states()).

Day 10: 30-days to learn rgl, plotly, and gganimate - Create an Animated Scatter Plot with gganimate and Enhance it with Plotly Hover Details

 

Step 1: Install and Load Required Libraries

Ensure you have all the necessary libraries installed. Use the following code:

# Install required packages

install.packages(c("ggplot2", "gganimate", "plotly"))

# Load the libraries

library(ggplot2)

library(gganimate)

library(plotly)

---

Step 2: Prepare the Dataset

Use a time-series dataset or create a sample dataset for the scatter plot. For this example:

# Create a sample dataset

set.seed(123)

data <- data.frame(

  Time = rep(1:10, each = 10),

  X = runif(100, min = 1, max = 100),

  Y = runif(100, min = 1, max = 100),

  Category = rep(letters[1:10], times = 10)

)

---

Step 3: Create the Static ggplot

Set up the scatter plot with ggplot2:

# Create the base plot

static_plot <- ggplot(data, aes(x = X, y = Y, color = Category, frame = Time)) +

  geom_point(size = 3) +

  labs(title = "Scatter Plot Over Time", x = "X-Axis", y = "Y-Axis") +

  theme_minimal()

---

Step 4: Animate the Plot with gganimate

Use transition_time to animate the plot over the Time variable:

# Animate the scatter plot

animated_plot <- static_plot +

  transition_time(Time) +

  labs(subtitle = 'Time: {frame_time}')

# Render the animation (optional, for preview)

animate(animated_plot, nframes = 100, fps = 10)

---

Step 5: Export Animation Frames

Save animation frames for converting to Plotly:

# Save each frame

animation_frames <- animate(animated_plot, renderer = file_renderer(dir = "frames", overwrite = TRUE))

---

Step 6: Convert ggplot to Plotly for Interactivity

Add Plotly's hover functionality to the ggplot-based animation:

# Convert the static ggplot to a plotly object

plotly_plot <- ggplotly(static_plot, tooltip = c("Category", "X", "Y"))

# Add animation controls

plotly_plot <- plotly_plot %>%

  animation_opts(frame = 1000, redraw = TRUE) %>%

  animation_slider(currentvalue = list(prefix = "Time: "))

---

Step 7: Combine gganimate and Plotly

Overlay gganimate animations on the interactive Plotly scatter plot:

# Generate the final interactive plot

final_plot <- plot_ly(

  data = data,

  x = ~X,

  y = ~Y,

  color = ~Category,

  frame = ~Time,

  text = ~paste("Category:", Category, "<br>X:", round(X, 2), "<br>Y:", round(Y, 2)),

  hoverinfo = "text",

  type = 'scatter',

  mode = 'markers'

) %>%

  layout(

    title = "Interactive Scatter Plot with Animation",

    xaxis = list(title = "X-Axis"),

    yaxis = list(title = "Y-Axis")

  )

---

Step 8: Preview and Save

Render and view the interactive plot:

# Render the interactive animated plot

final_plot

# Save the plot as an HTML file

htmlwidgets::saveWidget(final_plot, "animated_scatter_plot.html")

Day 9: 30-days to learn rgl, plotly, and gganimate - Practice Using Plotly's Interactivity Features with gganimate-Based Animations

Step 1: Load Necessary Libraries

Ensure you have the required packages installed. Use the following code to load them:

# Install required packages if not already installed

install.packages(c("gganimate", "plotly", "ggplot2", "dplyr"))

# Load libraries

library(gganimate)

library(plotly)

library(ggplot2)

library(dplyr)

---

Step 2: Prepare the Dataset

Use a dataset with temporal and categorical components. Here, we'll use the built-in gapminder dataset (install gapminder package if needed).

# Install gapminder if not installed

install.packages("gapminder")

library(gapminder)

# Filter dataset for simplicity

data <- gapminder %>% filter(year %in% c(2002, 2007))

---

Step 3: Create an Animated Plot with gganimate

Generate a simple animated scatter plot showing the relationship between GDP per capita and life expectancy.

# Create the base plot

p <- ggplot(data, aes(x = gdpPercap, y = lifeExp, size = pop, color = continent)) +

  geom_point(alpha = 0.7) +

  scale_x_log10() + # Log scale for GDP

  labs(title = "Year: {frame_time}", x = "GDP per Capita", y = "Life Expectancy") +

  theme_minimal() +

  transition_time(year) +

  ease_aes('linear')

# Animate the plot

animated_plot <- animate(p, nframes = 100, fps = 20, renderer = gifski_renderer())

---

Step 4: Convert the Animation to Plotly

Extract individual frames from the animation and wrap them into a plotly interactive visualization.

# Convert animation frames to a data frame for Plotly

frame_data <- data %>%

  mutate(frame = as.factor(year))

# Create an interactive plot using plotly

interactive_plot <- plot_ly(

  data = frame_data,

  x = ~gdpPercap,

  y = ~lifeExp,

  size = ~pop,

  color = ~continent,

  frame = ~frame,

  text = ~paste("Country:", country, "<br>Life Expectancy:", lifeExp, "<br>GDP per Capita:", gdpPercap),

  hoverinfo = "text",

  type = 'scatter',

  mode = 'markers',

  marker = list(opacity = 0.7)

)

interactive_plot <- interactive_plot %>%

  layout(

    title = "Interactive Animation: Life Expectancy vs GDP",

    xaxis = list(title = "GDP per Capita (Log Scale)", type = "log"),

    yaxis = list(title = "Life Expectancy")

  )

---

Step 5: Add Zoom and Pan Interactivity

Enable zoom and pan features to enhance the user experience.

interactive_plot <- interactive_plot %>%

  layout(dragmode = "zoom") %>%

  config(scrollZoom = TRUE)

# View the interactive plot

interactive_plot

Day 8: 30-days to learn rgl, plotly, and gganimate - Creating Animated Plots with gganimate and Exporting Frames to Plotly

 

Step 1: Set Up Your Environment

1. Install Required Packages: Ensure you have the following libraries installed:

install.packages(c("gganimate", "ggplot2", "plotly"))

2. Load Libraries:

library(gganimate)

library(ggplot2)

library(plotly)

---

Step 2: Prepare Your Dataset

1. Use a time-based dataset or create one for practice. For example:

data <- data.frame(

  year = rep(2000:2010, each = 3),

  category = rep(c("A", "B", "C"), times = 11),

  value = runif(33, 10, 100)

)

2. Preview your dataset:

head(data)

---

Step 3: Create a Static ggplot

1. Start by plotting the data without animation:

p <- ggplot(data, aes(x = year, y = value, color = category)) +

  geom_line(aes(group = category)) +

  theme_minimal() +

  labs(title = "Value Trends Over Time", x = "Year", y = "Value")

2. Print the plot to ensure correctness:

print(p)

---

Step 4: Animate the Plot with gganimate

1. Add animation to visualize trends over time:

animated_plot <- p +

  transition_time(year) +

  ease_aes('linear') +

  labs(subtitle = "Year: {frame_time}")

2. Render the animation in your RStudio viewer:

animate(animated_plot, nframes = 100, fps = 10)

3. Save the animation as a GIF (optional):

anim_save("animated_plot.gif", animation = animated_plot)

Step 5: Export Frames to Plotly

Here’s a corrected version of how to export frames to Plotly:

---

1. Add a Frame Column: Add a frame column to the dataset for use in plot_ly():

data$frame <- data$year

2. Create a Plotly Animation: Use plot_ly() to build the animated visualization. Explicitly set the trace type to "scatter" and specify the mode:

plotly_animation <- plot_ly(

  data = data,

  x = ~year,

  y = ~value,

  color = ~category,

  frame = ~frame,

  type = "scatter",

  mode = "lines+markers"

) %>%

  layout(

    title = "Interactive Animation with Plotly",

    xaxis = list(title = "Year"),

    yaxis = list(title = "Value")

  )

3. Render the Plotly Animation: Display the interactive animated plot:

plotly_animation

Day 7: 30-days to learn rgl, plotly, and gganimate - Combining gganimate and Plotly for added interactivity

 

Step 1: Install Required Libraries

Ensure you have the necessary libraries installed and loaded:

install.packages("ggplot2")

install.packages("gganimate")

install.packages("plotly")

library(ggplot2)

library(gganimate)

library(plotly)

---

Step 2: Create an Animated Plot with gganimate

We’ll first create a simple animated scatter plot showing the movement of points over time.

1. Prepare the Data:

# Sample data for animation

set.seed(42)

data <- data.frame(

  x = rnorm(50),

  y = rnorm(50),

  time = rep(1:5, each = 10),

  group = rep(letters[1:10], times = 5)

)

2. Create the Animated Plot:

# Animated scatter plot with gganimate

p <- ggplot(data, aes(x = x, y = y, color = group)) +

  geom_point(size = 4) +

  labs(title = 'Time: {frame_time}', x = 'X-Axis', y = 'Y-Axis') +

  transition_time(time) +

  ease_aes('linear')

# Save the animation

anim <- animate(p, nframes = 100, fps = 10, renderer = gifski_renderer())

---

Step 3: Export Animation Frames

Convert the gganimate frames into individual images that can be used in plotly.

1. Save Frames:

anim_save("gganimate_frames.gif", animation = anim)

Alternatively, save the individual frames as PNG files:

frame_images <- animate(p, nframes = 100, fps = 10, renderer = file_renderer(dir = "frames", prefix = "frame", overwrite = TRUE))

---

Step 4: Integrate with plotly for Interactivity

1. Load Images into plotly: Use plotly to create an interactive slider for the frames.

library(magick)

# Load the GIF

frames_gif <- image_read("gganimate_frames.gif")

# Extract individual frames

frames_list <- lapply(seq_len(length(frames_gif)), function(i) {
  frame <- image_write(frames_gif[i], format = "png") # Convert frame to PNG format
  list(source = base64enc::dataURI(frame, mime = "image/png")) # Encode as Base64 URI
})

# Create the interactive plot

# Create the interactive plot using plotly
plotly_animation <- plot_ly() %>%
  layout(
    sliders = list(list(
      steps = lapply(seq_along(frames_list), function(i) {
        list(
          method = "restyle",
          args = list("images[0].source", frames_list[[i]]$source),
          label = paste("Frame", i)
        )
      })
    ))
  )

# Add the initial image
plotly_animation <- plotly_animation %>%
  add_image(
    source = frames_list[[1]]$source,
    x = 0, y = 0,
    xanchor = "center", yanchor = "middle"
  )

---

Step 5: Test the Integration

1. Run the above code to see your animated and interactive plot in the RStudio Viewer or browser.
2. Experiment with the hover, zoom, and pan features provided by plotly.

---

Step 6: Reflect and Experiment

• Experiment with more complex gganimate animations, such as using transition_states() or view_follow().
• Add custom interactivity in plotly, such as hover text and annotations.

N.B: The code may have some errors. 

Day 3: 30-days to learn rgl, plotly, and gganimate - Dive into 3D plotting with plotly, exploring 3D scatter and surface plots, and customizing axes and color scales

Step 1: Set Up for 3D Plotting

1.     Load plotly: Make sure plotly is loaded in your R environment.

library(plotly)

2.     Create Sample Data: Let’s create sample data for our 3D scatter plot and surface plot.

# Data for 3D Scatter Plot

x_scatter <- rnorm(50)

y_scatter <- rnorm(50)

z_scatter <- rnorm(50)

# Data for 3D Surface Plot

x_surface <- seq(-10, 10, length.out = 50)

y_surface <- seq(-10, 10, length.out = 50)

z_surface <- outer(x_surface, y_surface, function(x, y) sin(sqrt(x^2 + y^2)))

---

Step 2: Create a 3D Scatter Plot

1.     Basic 3D Scatter Plot: Use plot_ly() with type = 'scatter3d' to create a basic 3D scatter plot.

scatter3d_plot <- plot_ly(x = ~x_scatter, y = ~y_scatter, z = ~z_scatter, 

                          type = 'scatter3d', mode = 'markers')

scatter3d_plot

• Explanation:
• x = ~x_scatter, y = ~y_scatter, and z = ~z_scatter: Set the x, y, and z coordinates.
• type = 'scatter3d': Specifies a 3D scatter plot.
• mode = 'markers': Displays only markers (points) in 3D space.

2.     Customize Marker Colors and Sizes:

scatter3d_plot <- plot_ly(x = ~x_scatter, y = ~y_scatter, z = ~z_scatter, 

                          type = 'scatter3d', mode = 'markers',

                          marker = list(size = 5, color = ~z_scatter, colorscale = 'Viridis'))

scatter3d_plot

• Explanation:
• size = 5: Adjusts the size of the markers.
• color = ~z_scatter: Colors markers based on their z values.
• colorscale = 'Viridis': Applies a color scale to the z values.

---

Step 3: Create a 3D Surface Plot

1.     Basic 3D Surface Plot: Use plot_ly() with type = 'surface' to create a basic 3D surface plot.

surface_plot <- plot_ly(z = ~z_surface, x = ~x_surface, y = ~y_surface, type = 'surface')

surface_plot

• Explanation:
• z = ~z_surface: Sets the height values of the surface.
• x = ~x_surface and y = ~y_surface: Sets the x and y coordinates for the surface plot.
• type = 'surface': Specifies a 3D surface plot.

2.     Customize the Surface Plot with a Color Scale:

surface_plot <- plot_ly(z = ~z_surface, x = ~x_surface, y = ~y_surface, 

                        type = 'surface', colorscale = 'Viridis')

surface_plot

• Explanation:
• colorscale = 'Viridis': Adds a Viridis color scale, enhancing the visualization of depth.

---

Step 4: Customize Axes

You can adjust the axis properties to improve the plot’s readability and style.

1.     Customize 3D Scatter Plot Axes:

scatter3d_plot <- scatter3d_plot %>%

  layout(scene = list(xaxis = list(title = "X Axis", backgroundcolor = "lightgrey", gridcolor = "white"),

                      yaxis = list(title = "Y Axis", backgroundcolor = "lightgrey", gridcolor = "white"),

                      zaxis = list(title = "Z Axis", backgroundcolor = "lightgrey", gridcolor = "white")))

scatter3d_plot

• Explanation:
• scene: Defines 3D plot layout options, including xaxis, yaxis, and zaxis.
• title: Sets custom titles for each axis.
• backgroundcolor and gridcolor: Adjust axis background and grid colors.

2.     Customize 3D Surface Plot Axes:

surface_plot <- surface_plot %>%

  layout(scene = list(xaxis = list(title = "X Axis", color = "blue"),

                      yaxis = list(title = "Y Axis", color = "green"),

                      zaxis = list(title = "Z Axis", color = "red")))

surface_plot

---

Step 5: Experiment with Different Color Scales

plotly provides several color scales. Try using different ones to see their effects on your plot.

1.     Apply Different Color Scales to the 3D Scatter Plot:

scatter3d_plot <- plot_ly(x = ~x_scatter, y = ~y_scatter, z = ~z_scatter, 

                          type = 'scatter3d', mode = 'markers',

                          marker = list(size = 5, color = ~z_scatter, colorscale = 'Cividis'))

scatter3d_plot

2.     Apply Different Color Scales to the 3D Surface Plot:

surface_plot <- plot_ly(z = ~z_surface, x = ~x_surface, y = ~y_surface, 

                        type = 'surface', colorscale = 'Electric')

surface_plot

• Other Color Scales:
• Try color scales like Jet, Bluered, RdBu, YlGnBu, Greens, and Portland to see different effects.

---

Step 6: Combine All Customizations

Let’s bring everything together to create a polished 3D scatter and 3D surface plot.

Final 3D Scatter Plot with Customizations

final_scatter3d <- plot_ly(x = ~x_scatter, y = ~y_scatter, z = ~z_scatter, 

                           type = 'scatter3d', mode = 'markers',

                           marker = list(size = 5, color = ~z_scatter, colorscale = 'Viridis')) %>%

  layout(scene = list(xaxis = list(title = "X Axis", backgroundcolor = "lightgrey", gridcolor = "white"),

                      yaxis = list(title = "Y Axis", backgroundcolor = "lightgrey", gridcolor = "white"),

                      zaxis = list(title = "Z Axis", backgroundcolor = "lightgrey", gridcolor = "white")))

final_scatter3d

Final 3D Surface Plot with Customizations

final_surface_plot <- plot_ly(z = ~z_surface, x = ~x_surface, y = ~y_surface, 

                              type = 'surface', colorscale = 'Electric') %>%

  layout(scene = list(xaxis = list(title = "X Axis", color = "blue"),

                      yaxis = list(title = "Y Axis", color = "green"),

                      zaxis = list(title = "Z Axis", color = "red")))

final_surface_plot

---

Summary

Today, you:

• Learned to create 3D scatter and surface plots using plotly.
• Customized marker colors and sizes for 3D scatter plots.
• Applied color scales to enhance visual appeal.
• Customized axes in 3D space, including titles, colors, and backgrounds.

Next, you’ll build on this knowledge by diving into more complex plot customizations and interactive features to make the plots even more informative.