Paquete R para análisis y visualización de datos de captura de movimiento

Question

Soy un novato en R, me encanta, pero estoy sorprendido por la falta total de paquetes sólidos para analizar datos de captura de movimiento.

El archivo de captura de movimiento más simple es sólo una mesa enorme con 'XYZ' coordenadas de cada punto unido a un sujeto grabado, y por cada fotograma capturado. Sé que puedo encontrar métodos y funciones individuales en R para realizar operaciones complejas (como el análisis de componentes principales) o puedo trazar series de tiempo para todos los puntos. Pero cuando busco ejemplos que también me eduquen estadísticamente sobre el análisis del movimiento humano y proporcionen una buena caja de herramientas para la representación visual de los datos, R resulta ser un desierto frío. Por otro lado, MATLAB tiene Motion capture toolbox y MoCap Toolbox y especialmente este último tiene opciones bastante buenas para trazar y analizar las capturas. Pero seamos honestos - MATLAB tiene motor bastante feo visualización en comparación con R.

Algunas solicitudes específicas de paquete de captura R movimiento incluirían:

• lectura, edición, visualización y transformar los datos mocap
• cinética y análisis cinemático
• tiempo-serie y análisis de componentes principales
• datos Animating

¿Me falta algo aquí (en mi Google) o realmente no hay paquetes de mocap para R? ¿Alguien ha intentado jugar con datos de captura de movimiento en R? ¿Puedes darme algunas indicaciones?

Answer 1

A juzgar por una búsqueda rápida en RSEEK, no es un paquete de captura de movimiento disponible para R. Parece que tendrá que encontrar equivalentes para cada función. Los más generales deberían ser bastante fáciles de encontrar (interpolación, subconjunto, transformación/proyección, análisis de series de tiempo, pca, análisis matricial, etc.) y es probable que el propio proceso de escribir sus propias funciones personalizadas para cosas específicas como estimar la energía cinética instantánea la mejor manera de aprender!

Puede encontrar plyr útil para poner los datos en forma y el paquete animation para visualizar el movimiento.

Answer 2

Tenga una mirada en mi paquete, el paquete de mocap: https://github.com/gsimchoni/mocap

Está lejos de ser perfecto, pero es un comienzo, probando actualmente en archivos/AMC CMU Graphics Lab Motion Capture Database ASF.

Y here es un blog con algunos detalles más.

Answer 3

que utiliza el paquete rgl para crear una animación a partir de un conjunto de datos de movimiento gesto. Aunque no es un paquete hecho específicamente para datos de gestos, puede trabajar con él.

En el siguiente ejemplo, tenemos datos de gestos para 8 puntos en la parte superior del cuerpo: columna, centro del hombro, cabeza, hombro izquierdo, muñeca izquierda, hombro derecho y muñeca derecha. El sujeto tiene sus manos hacia abajo y su brazo derecho está haciendo un movimiento hacia arriba.

que limita el conjunto de datos de 6 observaciones en tiempo (segundos, si se quiere), porque de lo contrario sería llegar a grandes como para publicar aquí.

Cada línea del conjunto de datos original corresponde a una observación de tiempo, y las coordenadas de cada punto del cuerpo se definen en conjuntos de 4 (cada cuatro columnas es un punto del cuerpo). Entonces, en cada línea, tenemos "x", "y", "z", "br" para el lomo, luego "x", "y", "z", "br" para el centro del hombro, etc. . El "br" es siempre 1, para separar las tres coordenadas (x, y, z) de cada parte del cuerpo.

Aquí es el original (restringida) conjunto de datos:

DATA.time.obs<-rbind(c(-0.06431,0.101546,2.990067,1,-0.091378,0.165703,3.029513,1,-0.090019,0.518603,3.022399,1,-0.042211,0.687271,2.987086,1,-0.231384,0.419869,2.953286,1,-0.299824,0.173991,2.882627,1,0.063367,0.399478,3.136306,1,0.134907,0.176191,3.159998,1), 
       c(-0.067185,0.102249,2.990185,1,-0.095083,0.166589,3.028688,1,-0.093098,0.519146,3.019775,1,-0.043808,0.687041,2.987671,1,-0.234622,0.417481,2.94581,1,-0.300324,0.169313,2.869782,1,0.056816,0.398384,3.135578,1,0.134536,0.180875,3.162843,1), 
       c(-0.069282,0.102964,2.989943,1,-0.098594,0.167465,3.027638,1,-0.097184,0.52169,3.019556,1,-0.046626,0.695406,2.989244,1,-0.23478,0.417057,2.943475,1,-0.300101,0.168628,2.860515,1,0.053793,0.395444,3.143226,1,0.134175,0.182816,3.172053,1), 
       c(-0.070924,0.102948,2.989369,1,-0.101156,0.167554,3.026474,1,-0.100244,0.522901,3.018919,1,-0.049834,0.696996,2.987933,1,-0.235301,0.416329,2.939331,1,-0.301339,0.170203,2.85497,1,0.04762,0.390872,3.142792,1,0.14041,0.186844,3.182172,1), 
       c(-0.071973,0.103372,2.988788,1,-0.103215,0.16776,3.025409,1,-0.102334,0.52281,3.019341,1,-0.051298,0.697003,2.991192,1,-0.235497,0.414859,2.935161,1,-0.297678,0.15788,2.833734,1,0.045973,0.386249,3.147609,1,0.14408,0.1916,3.204443,1), 
       c(-0.073223,0.104598,2.988132,1,-0.106597,0.168971,3.022554,1,-0.106778,0.522688,3.015138,1,-0.051867,0.697781,2.990767,1,-0.236137,0.414773,2.931317,1,-0.297552,0.153462,2.827027,1,0.039316,0.39146,3.166831,1,0.175061,0.214336,3.207459,1)) 

Para cada punto de tiempo, podemos crear una matriz donde cada fila será un punto de cuerpo, y las columnas se las coordenadas:

# Single time point for analysis 
time.point<-1 
# Number of coordinates 
coordinates<-4 
# Number of body points 
body.points<-dim(DATA.time.obs)[2]/coordinates 

# Total time of gesture 
total.time<-dim(DATA.time.obs)[1] 

# Transform data for a single time. observation into a matrix 
DATA.matrix<-matrix(DATA.time.obs[1,],c(body.points,coordinates),byrow = TRUE) 
colnames(DATA.matrix)<-c("x","y","z","br") 
rownames(DATA.matrix)<-c("hip_center","spine","shoulder_center","head", 
         "left_shoulder","left_wrist","right_shoulder", 
         "right_wrist") 

por lo tanto, tenemos, en cada punto de tiempo, una matriz de esta manera:

     x  y  z br 
hip_center  -0.064310 0.101546 2.990067 1 
spine   -0.091378 0.165703 3.029513 1 
shoulder_center -0.090019 0.518603 3.022399 1 
head   -0.042211 0.687271 2.987086 1 
left_shoulder -0.231384 0.419869 2.953286 1 
left_wrist  -0.299824 0.173991 2.882627 1 
right_shoulder 0.063367 0.399478 3.136306 1 
right_wrist  0.134907 0.176191 3.159998 1 

Y ahora nos e rgl para trazar los datos de esta matriz:

#install.packages("rgl") 
library(rgl) 

# INITIAL PLOT 

x<-unlist(DATA.matrix[,1]) 
y<-unlist(DATA.matrix[,2]) 
z<-unlist(DATA.matrix[,3]) 

# OPEN A BLANK 3D PLOT AND SET INITIAL NEUTRAL VIEWPOINT 
open3d() 
rgl.viewpoint(userMatrix=rotationMatrix(0,0,0,0)) 

# SET FIGURE POSITION 
# This is variable. It will depend on your dataset 
# I've found that for this specific dataset a rotation 
# of -0.7*pi on the Y axis works 

# You can also plot and select the best view with 
# your mouse. This selected view will be passed on 
# to the animation. 
U <- par3d("userMatrix") 
par3d(userMatrix = rotate3d(U, -0.7*pi, 0,1,0)) 

# PLOT POINTS 
points3d(x=x,y=y,z=z,size=6,col="blue") 
text3d(x=x,y=y,z=z,texts=1:8,adj=c(-0.1,1.5),cex=0.8) 

# You can also plot each body point name. 
# This might be helpful when you don't know the 
# initial orientation of your plot 

# text3d(x=x,y=y,z=z,texts=rownames(DATA.matrix), 
#  cex=0.6,adj=c(-0.1,1.5)) 

# Based on the plotted figure, connect the line segments 
CONNECTOR<-c(1,2,2,3,3,4,3,5,3,7,5,6,7,8) 
segments3d(x=x[CONNECTOR],y=y[CONNECTOR],z=z[CONNECTOR],col="red") 

Entonces, tenemos esto:

Para crear una animación, podemos poner todo esto en una función y utilizar lapply.

movement.points<-function(DATA,time.point,CONNECTOR,body.points,coordinates){ 

    DATA.time<-DATA[time.point,] 

    DATA.time<-matrix(DATA.time,c(body.points,coordinates),byrow = TRUE) 

    x<-unlist(DATA.time[,1]) 
    y<-unlist(DATA.time[,2]) 
    z<-unlist(DATA.time[,3]) 

    # I used next3d instead of open3d because now I want R to plot 
    # several plots on top of our original, creating the animation 

    next3d(reuse=FALSE) 
    points3d(x=x,y=y,z=z,size=6,col="blue") 
    segments3d(x=c(x,x[CONNECTOR]),y=c(y,y[CONNECTOR]),z=c(z,z[CONNECTOR]),col="red") 
# You can control the "velocity" of the animation by changing the 
# parameter below. Smaller = faster 
    Sys.sleep(0.5) 
} 

Sé que esta solución no es elegante, pero funciona.