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 11: 30-days to learn rgl, plotly, and gganimate - Learn How to Save rgl 3D Frames and Stitch Them Into an Animation With gganimate

 

Step 1: Set Up the Environment

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

install.packages(c("rgl", "gganimate", "magick"))

The magick package will handle image processing for stitching frames.

2.     Load the Libraries
Load the necessary libraries:

library(rgl)

library(magick)

library(gganimate)

---

Step 2: Create an rgl 3D Plot

1.     Generate Data for 3D Visualization
Create a 3D dataset for plotting:

set.seed(123)

x <- rnorm(100)

y <- rnorm(100)

z <- rnorm(100)

colors <- rainbow(100)

# Create a 3D scatter plot

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

2.     Set Up Rotation or Camera Movements
Define the rotation sequence or camera viewpoints:

n_frames <- 36  # Number of frames

angles <- seq(0, 360, length.out = n_frames)

---

Step 3: Save rgl Frames

1.     Create a Temporary Directory for Frames
Create a directory to save the images:

dir.create("rgl_frames")

2.     Save Each Frame
Loop through the angles and save an image for each:

for (i in seq_along(angles)) {

    rgl.viewpoint(theta = angles[i], phi = 30, fov = 60)

    snapshot3d(sprintf("rgl_frames/frame_%03d.png", i))

}

---

Step 4: Combine Frames Into an Animation

1.     Use magick to Stitch Images
Load and combine the images:

frames <- list.files("rgl_frames", full.names = TRUE, pattern = "png")

animation <- image_read(frames) %>%

             image_animate(fps = 10)  # Set frames per second

2.     Save the Animation
Save the animation as a GIF:

image_write(animation, "rgl_animation.gif")

---

Step 5: (Optional) Combine With gganimate

1.     Create a Data Frame for gganimate
If you want to integrate gganimate, create a dataset representing each frame's data:

animation_data <- data.frame(

    x = rep(x, n_frames),

    y = rep(y, n_frames),

    z = rep(z, n_frames),

    frame = rep(1:n_frames, each = length(x))

)

2.     Visualize With ggplot2 and gganimate
Use ggplot2 to create a dynamic scatter plot:

library(ggplot2)

ggplot(animation_data, aes(x = x, y = y, color = z, frame = frame)) +

    geom_point() +

    transition_manual(frame) +

    theme_minimal()

---

Step 6: Clean Up

1.     Remove Temporary Files
Delete the directory containing frames:

unlink("rgl_frames", recursive = TRUE)

2.     Review the Final Animation
Check the GIF and tweak the settings (e.g., angles, FPS) if needed.

Prices of 5 marla plots in some of the well-known areas in and near Islamabad, Pakistan

 

(Source: Pixabay)

There are different societies in Islamabad and Rawalpindi, Pakistan. It needs to be considered that if someone wants to make big investments, they have to listen about mature housing societies. Nevertheless, considering prices of different societies, in the Blue World City, which is the last housing city, if we go through the motorway side, the cost of a 5 marla plot is in the range of 15 to 18 lacs. In the Silver City Housing society, the cost of a 5 marla plot is in the range of 20 lacs to 24 lacs. In the Capital Smart City, the price is in the range of 30 lacs to 34 lacs. In the Faisal Town Phase II, prices are in the range of 22 lacs to 25 lacs. In the Top City, prices are in the range of 62 lacs to 80 lacs. In the Faisal Town Phase I, prices are in the range of 90 lacs to 1 crore. In the I-14 sector, prices are in the range of 1.25 crores; in I-15, prices are in the range of 70 lacs, and in I-16, prices are in the range of 85 lacs. In the G15 sector, prices of 7 marla plots are in the range of 1.75 crores. In G-13 and G-14, prices of 5 marla plots are in the range of 2.25 crores to 2.50 crores. In the Park View City, prices are in the range of 50 lacs to 65 lacs and above 1 crore. In Bahria Enclave, prices are in the range of 65 lacs to 95 lacs. In D-12, costliest plots are available that are in the range of 3 crores to 3.5 crores.

These properties have no installment plans.

Source:

Gondal Group of Marketing Islamabad - Top 10 Best Housing Societies in Islamabad | 5 Marla Possession Plot Price Comparison in Islamabad - https://www.youtube.com/watch?v=tktrkw5uvP0

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