Showing posts with label statistics. Show all posts
Showing posts with label statistics. Show all posts

Wednesday, November 27, 2024

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

Monday, November 25, 2024

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

Sunday, November 24, 2024

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

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


Friday, November 15, 2024

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.

Thursday, November 14, 2024

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.

ERROR.TYPE function in Microsoft Excel