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 5: 30-days to learn rgl, plotly, and gganimate - Practice rgl customization (lighting, colors, sizes) and apply labels and text to 3D points

Step 1: Create a Basic 3D Plot

We'll begin by creating a simple 3D scatter plot to serve as our canvas for customization.

# Load the rgl package

library(rgl)

# Sample data for 3D scatter plot

set.seed(123)

x <- rnorm(10)

y <- rnorm(10)

z <- rnorm(10)

# Basic 3D scatter plot

plot3d(x, y, z, type = "s", col = "blue", size = 2)

This creates a simple 3D scatter plot with blue points.

Step 2: Customize Point Colors, Sizes, and Shapes

Adjusting colors, point sizes, and shapes can make the plot more visually informative.

# Customizing colors, sizes, and shapes

point_colors <- rainbow(length(x))  # Assign each point a different color

plot3d(x, y, z, col = point_colors, size = 5, type = "s")  # Increased size

In this example:

• Each point gets a unique color.
• size controls the size of the points (default is smaller; try 5 for larger points).
• type = "s" sets the points as spheres.

Step 3: Add Lighting Effects

Lighting can add depth and realism to your plot.

# Adding lighting effects

open3d()  # Open a new rgl window

plot3d(x, y, z, col = point_colors, size = 5, type = "s")

# Adjust lighting - you can experiment with these settings

rgl.light(ambient = "#FFFFFF", specular = "#BBBBBB", diffuse = "#888888", x = 1, y = 1, z = 1)

Lighting parameters:

• ambient: Light that scatters evenly.
• specular: Shiny highlights on objects.
• diffuse: Light scattered by the surface.

Experiment with these values to get the desired effect.

Step 4: Customize Camera Angles and Views

You can set the viewing angle to emphasize specific points or sections.

# Adjust camera angle

rgl.viewpoint(theta = 30, phi = 30, fov = 60)

Parameters:

• theta and phi: Control the angles from which the plot is viewed.
• fov: Field of view; increasing it creates a wide-angle view, while lowering it zooms in.

Step 5: Add Labels and Text to 3D Points

Labels help make your data points identifiable, enhancing interpretability.

# Adding labels to each point

text3d(x, y, z, texts = paste("Pt", 1:10), col = "black", cex = 0.8)

Explanation:

• text3d: Adds text at each point’s location.
• texts: Vector of labels for each point.
• col and cex: Customize text color and size.

Step 6: Experiment with Size and Color Gradients

You can set sizes and colors based on data values to make plots more meaningful.

# Adjust point sizes and color gradient based on z-values

size_values <- rescale(z, to = c(3, 10))  # Scale sizes between 3 and 10

color_gradient <- heat.colors(length(z))

plot3d(x, y, z, col = color_gradient, size = size_values, type = "s")

Step 7: Adding Legends for Better Interpretation (Optional)

Legends help viewers interpret what different colors or sizes represent.

# Add a simple legend to the plot

legend3d("topright", legend = c("Low", "Medium", "High"), pch = 16, col = c("blue", "green", "red"), cex = 1.2)

Step 8: Save the Interactive 3D Plot (Optional)

To save your 3D plot as an HTML file for interactive viewing:

# Save as HTML file for interactive use

rglwidget() %>% htmlwidgets::saveWidget("3Dplot.html")

This file can then be shared or viewed interactively in a browser.

Summary

Today, you customized an rgl 3D plot by:

• Adjusting lighting, colors, sizes, and shapes.
• Adding text labels to 3D points for better interpretation.
• Experimenting with camera angles and views.

Day 4: 30-days to learn rgl, plotly, and gganimate - Installing rgl and Creating Basic 3D Plots

Step 1: Install and Load rgl

1.     Install the rgl package (if you haven’t already):

install.packages("rgl")

2.     Load the rgl library:

library(rgl)

Step 2: Create a Basic 3D Scatter Plot using plot3d

1.     Generate sample data for plotting:

set.seed(123)

x <- rnorm(100)

y <- rnorm(100)

z <- rnorm(100)

2.     Create a 3D scatter plot using plot3d:

plot3d(x, y, z, col = "blue", size = 5, type = "s")

• col: Set the color of the points.
• size: Control the point size.
• type: "s" represents spheres. You can also try other types, like "p" for points.

The plot should now open in an interactive window, allowing you to view your data in 3D.

Step 3: Create a 3D Scatter Plot using scatter3d

1.     Install and load the car package to access the scatter3d function:

install.packages("car")

library(car)

2.     Use scatter3d for a quick 3D scatter plot:

scatter3d(x, y, z, surface = FALSE, fit = "linear")

• surface: Set to FALSE if you don't want a regression surface (3D plane).
• fit: Set to "linear" for a linear fit (you can also use other fits if you like).

Step 4: Exploring Basic Camera Rotations and Zoom Functions

rgl provides several functions to interactively control the camera's view, allowing you to rotate, zoom, and pan.

1.     Rotate the Camera:

• The rgl.viewpoint() function allows you to set the camera angle. Try the following command:

rgl.viewpoint(theta = 45, phi = 30)

• theta: Controls rotation around the z-axis.
• phi: Controls the vertical rotation.

2.     Zoom In and Out:

• Adjust the zoom level using the zoom parameter in rgl.viewpoint:

rgl.viewpoint(theta = 45, phi = 30, zoom = 0.7)

• A zoom value less than 1 will zoom out, while a value greater than 1 will zoom in.

3.     Play Around with Different Viewpoints:

• Experiment with theta, phi, and zoom to see how they change your perspective. Here are a few examples:

# Top-down view

rgl.viewpoint(theta = 90, phi = 90, zoom = 0.5)

# Side view

rgl.viewpoint(theta = 0, phi = 0, zoom = 0.8)

# Rotate incrementally

for (angle in seq(0, 360, by = 10)) {

  rgl.viewpoint(theta = angle, phi = 30)

  Sys.sleep(0.1)

}

Step 5: Practice and Experiment

Explore rgl further by experimenting with different colors, sizes, and types of points in plot3d, or by adjusting the viewpoint using theta and phi in rgl.viewpoint.