Showing posts with label rgl. Show all posts
Showing posts with label rgl. Show all posts

Thursday, November 21, 2024

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"))

  1. 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)

)

  1. 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")

  1. 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}")

  1. Render the animation in your RStudio viewer:

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

  1. 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

  1. 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")

  )

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

plotly_animation


Sunday, November 17, 2024

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)
)
  1. 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. 

Saturday, November 16, 2024

Day 6: 30-days to learn rgl, plotly, and gganimate - Create an interactive 3D plot with rgl that uses various viewpoints or angles to simulate rotation

rglWebGL


Step 1: Install and Load the rgl Package

Ensure that you have the rgl package installed and loaded in your R environment.

# Install rgl if not already installed
if (!require("rgl")) install.packages("rgl")
 
# Load the rgl package
library(rgl)

Step 2: Prepare a Dataset

For demonstration purposes, create or use a sample 3D dataset (e.g., random points in 3D space).

# Sample dataset with random 3D points
set.seed(123)
n <- 100
x <- rnorm(n)
y <- rnorm(n)
z <- rnorm(n)
colors <- rainbow(n)

Step 3: Create a Basic 3D Plot

Use plot3d() to create a basic 3D scatter plot.

# Create a 3D scatter plot
plot3d(x, y, z, col = colors, size = 5, type = 's', xlab = "X-axis", ylab = "Y-axis", zlab = "Z-axis")

Step 4: Enhance the Plot with Customization

Add customizations like grid lines, labels, and lighting for better visualization.

# Add grid lines
grid3d("x")
grid3d("y")
grid3d("z")
 
# Enhance lighting
light3d(specular = "white")

Step 5: Set Up Rotation Parameters

Define a sequence of angles to rotate the plot and simulate a continuous rotation.

# Define rotation parameters
angles <- seq(0, 360, by = 5) # 5-degree increments

Step 6: Rotate the Plot Programmatically

Use a loop to rotate the plot around a specific axis (e.g., the z-axis).

# Rotate around the z-axis
for (angle in angles) {
  view3d(theta = angle, phi = 30) # Rotate theta; phi is the vertical angle
  Sys.sleep(0.1)                 # Pause for 0.1 seconds for smooth transition
}

Step 7: Export the Visualization

Save the interactive 3D plot as an HTML widget or image file for sharing or further use.

# Save as an interactive HTML file
rglwidget() %>% htmlwidgets::saveWidget("3D_plot_rotation.html")
 
# Save as a static image (PNG)
rgl.snapshot("3D_plot_rotation.png")

Step 8: Test and Adjust

  • Experiment with different rotation axes (x, y, or z) by modifying view3d() parameters.
  • Adjust the speed of rotation using Sys.sleep().

Outcome

By the end of this exercise, you will have an interactive 3D plot that smoothly rotates, providing a dynamic visualization of the data. You can integrate this plot with tools like plotly or embed it into web presentations for a polished output.