varias ¿Los gráficos 2D OpenGL de Performant en R para una visualización rápida de la imagen de trama utilizando los paquetes qtpaint(qt) o rdyncall(SDL/OpenGL)?



varias graficas en r ggplot (1)

Para un visor interactivo de Mandelbrot en tiempo real que estaba haciendo en R & Rcpp + OpenMP & Shiny, estoy buscando una forma eficaz de mostrar matrices de 1920x1080 como imágenes de mapa de bits con la esperanza de poder lograr ca. 5-10 fps (el cálculo de las propias imágenes de Mandelbrot ahora alcanza aproximadamente 20-30 fps en zooms moderados , y ciertamente el desplazamiento debería ser rápido). El uso de image() con la opción useRaster=TRUE , plot.raster o incluso grid.raster() todavía no lo corta, por lo que estoy buscando una opción más eficaz, idealmente utilizando la aceleración OpenGL.

Noté que hay paquetes qtutils y qtpaint http://finzi.psych.upenn.edu/R/library/qtutils/html/sceneDevice.html donde puede establecer el argumento opengl=TRUE y http://finzi.psych.upenn.edu/R/library/qtpaint/html/qplotView.html nuevo con el argumento opengl=TRUE y http://finzi.psych.upenn.edu/R/library/qtpaint/html/painting.html .

Y también noté que uno debería poder llamar a las funciones SDL y GL / OpenGL utilizando el paquete rdyncall (instale desde https://cran.r-project.org/src/contrib/Archive/rdyncall/ y SDL desde https://www.libsdl.org/download-1.2.php ) `, demos disponibles en https://cran.r-project.org/src/contrib/Archive/rdyncall/ , por ejemplo, http://hg.dyncall.org/pub/dyncall/bindings/file/87fd9f34eaa0/R/rdyncall/demo/randomfield.R ).

¿Estoy en lo cierto al decir que con estos paquetes uno debería poder mostrar un ráster de imágenes en 2D utilizando la aceleración de opengl ? Si es así, ¿alguien tiene alguna idea de cómo hacer esto (pregunto porque no soy un experto en qt o SDL / OpenGL )?

Algunos tiempos de opciones que no son OpenGL son demasiado lentos para mi aplicación:

# some example data & desired colour mapping of [0-1] ranged data matrix
library(RColorBrewer)
ncol=1080
cols=colorRampPalette(RColorBrewer::brewer.pal(11, "RdYlBu"))(ncol)
colfun=colorRamp(RColorBrewer::brewer.pal(11, "RdYlBu"))
col = rgb(colfun(seq(0,1, length.out = ncol)), max = 255)
mat=matrix(seq(1:1080)/1080,nrow=1920,ncol=1080,byrow=TRUE)
mat2rast = function(mat, col) {
  idx = findInterval(mat, seq(0, 1, length.out = length(col)))
  colors = col[idx]
  rastmat = t(matrix(colors, ncol = ncol(mat), nrow = nrow(mat), byrow = TRUE))
  class(rastmat) = "raster"
  return(rastmat)
}
system.time(mat2rast(mat, col)) # 0.24s

# plot.raster method - one of the best?
par(mar=c(0, 0, 0, 0))
system.time(plot(mat2rast(mat, col), asp=NA)) # 0.26s

# grid graphics - tie with plot.raster?
library(grid)
system.time(grid.raster(mat2rast(mat, col),interpolate=FALSE)) # 0.28s

# base R image()
par(mar=c(0, 0, 0, 0))
system.time(image(mat,axes=FALSE,useRaster=TRUE,col=cols)) # 0.74s # note Y is flipped to compared to 2 options above - but not so important as I can fill matrix the way I want

# magick - browser viewer, so no good....
# library(magick)
# image_read(mat2rast(mat, col))

# imager - doesn't plot in base R graphics device, so this one won't work together with Shiny
# If you wouldn't have to press ESC to return control to R this
# might have some potential though...
library(imager)
display(as.cimg(mat2rast(mat, col)))

# ggplot2 - just for the record...
df=expand.grid(y=1:1080,x=1:1920)
df$z=seq(1,1080)/1080
library(ggplot2)
system.time({q <- qplot(data=df,x=x,y=y,fill=z,geom="raster") + 
                scale_x_continuous(expand = c(0,0)) + 
                scale_y_continuous(expand = c(0,0)) +
                scale_fill_gradientn(colours = cols) + 
                theme_void() + theme(legend.position="none"); print(q)}) # 11s 

Según la introducción del paquete RGL , es:

un sistema de dispositivo de visualización para R, que utiliza OpenGL como backend de renderizado. Un dispositivo rgl en su núcleo es un motor 3D en tiempo real escrito en C ++. Proporciona una facilidad de navegación de punto de vista interactiva (mouse + rueda de apoyo) y una interfaz de programación R.

Dado que RGL es un motor 3D en tiempo real, espero que usar RGL para 2D te proporcione una visualización rápida.

Tenga en cuenta que este es un proyecto antiguo, por lo que no estoy seguro de que se ajuste a sus necesidades.

Puede echar un vistazo a este documento y ver algunas imágenes de resultados en esta galería.





sdl