Capítulo 20

1
VRML 2.0 con Java CAPÍTULO 20
Crear un Avatar
Contenido CAPÍTULO 20
• El cuerpo humano
2
• Creación de humanoides Animación

• Aumentar los humanoides Archivo
• Las solicitudes de una norma humanoide
• El futuro
El cuerpo humano
El cuerpo humano se compone de una estructura del esqueleto, un conjunto de

órganos internos, el tejido muscular, y la piel. Hay un gran número de uniones
en el esqueleto, lo que resulta en un número correspondientemente grande de
3
grados de libertad.
Afortunadamente, no tenemos a todos los modelo de la complejidad del cuerpo

humano con el fin de lograr una apariencia de realismo. En este capítulo vamos
a crear un sencillo esqueleto de formas geométricas en la que pueden
asociarse a definir la forma del cuerpo. Vamos a seguir el número de
articulaciones a un nivel razonable, y vamos a evitar por completo los
problemas de la piel, los músculos, y tendones.
Vamos a simplificar aún más nuestra tarea por tratar el cuerpo humano como
una simple transformación de la jerarquía, con un nodo de transformación para
cada conjunto. Por ejemplo, el hombro izquierdo, sería un nodo de
transformación, el otro codo izquierdo, y así sucesivamente. Animación de
nuestro avatar, por lo tanto, consisten en modificar los valores de la rotación
de los campos de transformación de los nodos, generalmente mediante el uso
de un nodo OrientationInterpolator.
Dado que el tiempo quiere crear más de un avatar, es importante que

adoptemos un conjunto de convenios para la forma en que el avatar se basa.
Como siempre, comenzamos por las normas existentes en busca de que
podemos simplemente adoptar, en lugar de inventar una nueva. Si bien no
existe una norma oficial, sin embargo, hay un grupo que está trabajando en la
definición de una: la de VRML humanoide Animación Grupo de Trabajo
(http://ece.uwaterloo.ca/ h-anim ~ /). Sus primeros trabajos se discutió en el
capítulo 9, cuando hablamos de normas avatar.
El diseño de los humanoides
De acuerdo con las directrices presentadas por el Grupo de Trabajo de

Animación humanoide, vamos a construir nuestro avatar humanoides en
posición de pie, mirando en la dirección z + con + X a la izquierda y + y hacia
arriba. Las armas estarán a sus lados, con las palmas hacia el interior se
enfrentan, y sus pies serán de aproximadamente hombro-anchura aparte. El
origen de los humanoides del sistema de coordenadas será el punto medio
entre los pies, los pies y será en y = 0.
Nuestra estructura esquelética se basa vagamente en la estructura propuesta

por el estándar MPEG-4 Natural Sintético-Híbrido Codificación Iniciativa. MPEG-
4 está diseñado para proporcionar eficientes representaciones de figuras
humanoides, tanto en términos de gran escala y los movimientos del cuerpo en
términos de las expresiones faciales sincronizadas con el habla.
No vamos a utilizar todas las articulaciones identificados en MPEG-4, en

4
particular, vamos a dejar de lado los detalles de los pies, los dedos de las
manos, y algunas de las articulaciones del hombro, como la clavícula. Figura
20-1 muestra un diagrama sencillo de nuestro humanoide.
Figura 20.1 El diseño básico de nuestro avatar humanoide
Ahora que tenemos nuestra base de diseño en su sitio, es tiempo de comenzar

el modelado en VRML.
Modelar el humanoide
Como se describe anteriormente, los humanoides se basa en una

transformación de la jerarquía. La transformación se nodos anidados, es decir,
que habrá de transformación en los nodos de los niños sobre el terreno de los
demás nodos de transformación. Dado que será la construcción de nuestro
modelo "en su lugar," la transformación de los nodos de las articulaciones no
tiene ninguna necesidad de traducciones, escalado, rotación o, los campos
serán establecidos a sus valores predeterminados. El único campo que
transforma el conjunto hará uso de centro es, que especifica el centro de
rotación para el conjunto y todos sus hijos. Tenga en cuenta que debido a que
no hay traducciones, las rotaciones, o escalas, el centro de campo siempre
expresar la ubicación de los conjuntos en el modelo de centro de coordenadas,
no en relación con la matriz de transformación del sistema de coordenadas.
Una vez que hemos construido nuestra transformación jerarquía, hay que
adjuntar a los nodos de forma que a fin de dar a algunos segmentos del cuerpo
representación visible. En lugar de crear un complejo de superficie poligonal
para nuestros humanoide, lo que exigiría que usamos algún tipo de modelado
5
3-D paquete, vamos a utilizar primitivas geométricas (esferas y cilindros) para

representar a los diferentes segmentos corporales. Habrá una esfera roja en
cada junta, y una botella verde que representan a cada segmento (por
ejemplo, una parte superior del brazo, el muslo, la mano, o con el pie).
Debido a que está utilizando primitivas, en lugar de IndexedFaceSets,

tendremos que los rodean con otros nodos de transformación en la posición
correctamente. Si tuviéramos el humanoide modelado directamente a través
de los polígonos, no habría necesidad de ningún adicional Transforma.
Un Consejo de Administración-Segmento PROTO
Vamos a empezar por la definición de un PROTO para un segmento de cuerpo:
# VRML V2.0 utf8
PROTO Segmento [
campo SFVec3f loc 0 0 0
campo SFFloat longitud 0,1
SFVec3f campo desplazamiento 0 0,05 0
campo SFRotation pudrición 0 0 1 0
]
{
Transformar {
traducción se loc
los niños [
Forma {
geometría Esfera 0,05) (radio
apariencia apariencia {
material Material {
diffuseColor 1 0 0
}
}
}
Transformar {
La rotación es la putrefacción
traducción es el desplazamiento
los niños [
Forma {
geometría cilindro (
radio de 0.025
la altura es la longitud
)
6
apariencia apariencia (
material Material (
diffuseColor 0 1 0
)
)
)
]
)
]
)
)
La loc campo especifica la ubicación de la articulación propiamente dicha, que

es donde la Esfera nodo se posicionará. La longitud de campo indica el tiempo
que el segmento es-en otras palabras, la longitud de la botella. El
desplazamiento es necesario para cambiar el cilindro en relación con la Esfera;
por defecto, el cilindro se centrará en el centro de la Esfera, que normalmente
no es lo que queremos. Ten en cuenta que podría haber creado un pequeño
script para nuestro PROTO que crearía el desplazamiento sobre la base de la
longitud y la orientación de la articulación, pero es probable que no vale la
pena el esfuerzo. Por último, la putrefacción de campo nos dice cómo está
orientada al segmento. El valor por omisión es vertical (la orientación natural
de la botella), sino que en ocasiones se utiliza para crear segmentos
horizontales, tales como los hombros o caderas.
La posición exterior de transformación del segmento. Tiene dos hijos: la Esfera

de nodo, que es la representación visual del conjunto, y una de transformación,
que gira y desplaza el cilindro, según sea necesario.
Este PROTO será muy útil cuando tenemos en torno a la creación de los
distintos segmentos corporales. También ayudará a reducir nuestro tamaño de
archivo, ya que no tendrá que repetir la Esfera, Cilindro, de transformación, y
los nodos aspecto una y otra vez.
Uso de la PROTO
El archivo que describe la totalidad del humanoide es muy grande y no muy

interesante de ver. Se puede encontrar en el CD-ROM como stickman.wrl.
Sin embargo, vale la pena echar un vistazo en una pequeña sección del archivo
para ver cómo es creado y cómo nuestro segmento PROTO se utiliza:
DEF l_shoulder transformación (

centro 0,4 1,4 0
7
los niños [
Segmento (# parte superior del brazo izquierdo
loc 0,4 1,4 0
longitud 0,3
desplazamiento 0 -0,15 0
)
DEF l_elbow transformación (
centro 0,4 1,1 0
los niños [
Segmento (# antebrazo izquierdo
loc 0,4 1,1 0
longitud 0,3
)
DEF l_wrist transformación (
centro 0,4 0,8 0
los niños [
Segmento (# izquierda
loc 0,4 0,8 0
Longitud 0,15
)
]
)
]
)
]
)
Esta sección del código describe el brazo izquierdo de nuestro humanoide.

Cada asociación conjunta especifica Transformar un centro de rotación
mediante el centro de campo.
Cada conjunto es una transformación específica DEF asignado un nombre, a fin

de que sea fácil acceder a los conjuntos más tarde. El hombro izquierdo en sí
se llama l_shoulder; el codo izquierdo se llama l_elbow, y la muñeca izquierda
se llama l_wrist. Transformar la muñeca izquierda figura en el codo izquierdo de
transformación, que figura en el hombro izquierdo de transformación. Aunque
no se muestra aquí, el hombro izquierdo de transformación sería de
transformación que figuran dentro de otro nodo, y así sucesivamente a través
de la jerarquía del organismo. La raíz de todo el cuerpo será la pelvis, como se
muestra en la Figura 20.2.
8
Figura 20.2 La jerarquía de nuestra humanoide del cuerpo
Desde la Transforms está anidada, los cambios se propagan a una a las otras.
Rotación de la l_elbow conjunto se desplazará no sólo el antebrazo, pero el
conjunto de la muñeca y la mano también. Rotación de la l_shoulder conjunta
se moverá la parte superior del brazo, codo, antebrazo, muñeca y mano.
Transformar el hombro izquierdo, tiene dos hijos: el codo izquierdo de

transformación, como se ha descrito anteriormente, y un segmento de la
izquierda la parte superior del brazo. El segmento se encuentra en el centro
común, y la longitud del segmento es el desplazamiento al centro de la
próxima en el conjunto de la jerarquía, que en este caso es de 0,3 metros o 30
centímetros (1 pie). El desplazamiento sobre el terreno ha ay valor de -0,15
metros, que se desliza el Cilindro nodo a mitad de camino en su longitud de
manera que un extremo se encuentra en el centro de la Esfera nodo. Este
mismo patrón se repite en el antebrazo izquierdo y la mano izquierda.
Figura 20.3 muestra el humanoide completado, con un nodo de Esfera por su

cabeza y un cono para darle un pico birdlike de su nariz.
Figura 20.3 La completado humanoide
Observe que la columna tiene un número de segmentos. Estos no son

estrictamente necesarios, sino que nos permite imitar con mayor precisión el
movimiento del cuerpo humano real, que tiene muchos más segmentos de la
columna vertebral y, por tanto, un mayor grado de flexibilidad.
La creación de humanoides Animación
Ahora que hemos construido nuestra base humanoide, es el momento para

9
empezar a hacer que se mueva. La idea básica es la rotación de diferentes

articulaciones utilizando OrientationInterpolators por TimeSensors.
A Simple-asintiendo con la cabeza Jefe Animación
Por ejemplo, si queríamos guiño a la cabeza de arriba a abajo, se puede

producir algo como esto:
# VRML V2.0 utf8
DEF TS TimeSensor (bucle TRUE)
DEF INTER OrientationInterpolator (

tecla [0 0,25 0,75 1,0]
keyValue [1 0 0 0, 1 0 0 0,7805, 1 0 0 -0,7804, 1 0 0 0]
)
VÍA TS.fraction_changed A INTER.set_fraction

VÍA INTER.value_changed A v8.set_rotation
TimeSensor El campo tiene su bucle establecido en TRUE, lo que significa que

nuestro comportamiento se ejecutará asintiendo con la cabeza continuamente.
Asignamos el TimeSensor un nombre, ya que estaremos VÍA-ción de él más
adelante.
El OrientationInterpolator es también el nombre, ya que va a enviar y recibir

eventos. Definimos cuatro puestos clave: Nivel de la cabeza, la cabeza
inclinada 45 grados hacia abajo (mirando hacia el piso), la cabeza inclinada
hasta 45 grados (mirando hacia el techo), y el nivel de nuevo. Desde la cabeza
asintiendo con la cabeza de animación empieza y termina con la cabeza, el
bucle será perfecta. Si no tienen ese nivel final de entrada a la cabeza de
nuevo, habría una discontinuidad brusca después de cada ciclo de animación.
Los cuatro valores son keyValue especificado como rotaciones alrededor del eje
x. Una rotación de 45 grados es de aproximadamente 0,7854 radianes.
Observe que los valores clave no son uniformemente espaciadas. La primera es

cuando la cabeza es, el segundo es un cuarto de ciclo más tarde, cuando la
cabeza es todo el camino hacia abajo. La siguiente posición debería ser el nivel
de nuevo, ya que la cabeza debe pasar a través de una rotación de cero en su
camino a buscar. Sin embargo, en lugar de añadir otro elemento clave, se
puede omitir el paso de tiempo. El resultado es el mismo: la cabeza se mueve a
una velocidad constante.
10
Estamos VÍA fraction_changed el eventOut del TimeSensor nombre en el TS de

la set_fraction eventIn llamado OrientationInterpolator INTER. Como el
TimeSensor rampas hasta la salida de 0,0 a 1,0, el OrientationInterpolator
generará un conjunto de valores interpolados. Estos serán enviados a partir de
la OrientationInterpolator de eventOut value_changed, que se encaminan hacia
el ámbito de la set_rotation Transformar nodo correspondiente al cuello
conjunta (v8, el octavo conjunto de la columna vertebral).
Este archivo se expresa la animación en VRML, pero no puede ser utilizado por
sí mismo, dado que tiene una ruta a una parte específica del cuerpo. Para
hacer uso de esta animación, simplemente añadir a la humanoide archivo, de
la siguiente manera:
copia stickman.wrl + nodding.wrl nodman.wrl
en DOS, o
gato stickman.wrl nodding.wrl> nodman.wrl
en Unix. El archivo resultante nodman.wrl puede ser cargada en cualquier

navegador de VRML para poder ver la animación asintiendo con la cabeza-
hombre.
Esta es la razón por la que necesitábamos para elegir los nombres DEF muy
específicos para cada conjunto, tenemos que ser capaces de añadir rutas a
ellos. Si creamos otro humanoide con la misma estructura común, seremos
capaces de usar la misma animación que se muestra arriba a la cabeza guiño,
simplemente porque se utilizó el mismo conjunto de nombres. Podríamos
empezar a construir las bibliotecas independientes de humanoides y
animaciones de fotogramas clave, lo que podría ser mezclado y combinado a
voluntad. Esto nos da una tremenda flexibilidad, ya que cada nueva animación
puede ser utilizado de inmediato por todos los humanoides, y cada nuevo
humanoide puede utilizar inmediatamente todas las animaciones.
Tenga en cuenta que no todas las animaciones pueden ser utilizados sin
problemas en todos los humanoides. En algunos casos (como agacharse o
profunda rodilla se dobla), es necesario conocer la duración de los diversos
sectores a fin de evitar el aumento de los pies hasta el suelo o hundimiento por
debajo de él. Más adelante en este capítulo vamos a discutir cómo hacer frente
a este requisito.
Generación de la Interpolators
Aunque simples animaciones pueden ser creadas por la mano, las cosas se
vuelven muy complejas muy rápidamente cuando se está tratando de
11
coordinar las múltiples acciones conjuntas. Idealmente, nos gustaría una

manera más conveniente de la edición de animaciones que simplemente
disparando hasta un editor de texto y jugar con el código de VRML
directamente.
Nuestra solución es crear un sencillo lenguaje de script, que es más

conveniente para editar y que podría adaptarse para su utilización en un
sistema interactivo de la animación de fotogramas clave. Debido a que la
sintaxis del lenguaje de script es mucho más sencillo que el de VRML, será más
fácil de analizar y de carga.
Vamos a implementar una aplicación Java que lee el lenguaje de scripting de

VRML 2.0 y genera la producción. El resultado de VRML se puede añadir en el
archivo de humanoides como se describe más arriba para añadir animación a
la misma.
Nuestro Idioma Animación
El lenguaje nos creación es muy simple. Está orientado a la línea, y cada línea
comenzará con una directiva de algún tipo. Líneas en blanco y las líneas que
comienzan con # se ignoran.
Existen cuatro directivas: animales, lazo, común, y el marco. Debería haber

sólo una única declaración de animales, lo que da el nombre de la animación,
de la siguiente manera:
anim nombre
Debe haber un lazo en la mayoría de declaración. Si la actualidad, hará que el

bucle de animación continua, si no, la animación se ejecute sólo una vez y
luego se detiene.
La directiva conjunta identifica un conjunto por su nombre, como sigue:
conjunta jointname
No todos los conjuntos en el cuerpo debe tener una directiva común, pero debe
haber una directiva conjunta para cada conjunto que se utiliza en la animación.
El orden de los conjuntos de directivas es importante, desde el primer llamado
conjunto común será el número 0, la segunda será conjunta número 1, y el
tercero será conjunta número 2, y así sucesivamente.
Habrá una directiva marco para cada fotograma clave en la animación. La

directiva marco tiene un único número de punto flotante como parámetro, que
especifica qué parte del camino a través de la animación de este marco se
12
produce en:
marco fracción
La fracción debe estar en el rango de 0.0 a 1.0, y cada cuadro debe tener una
mayor fracción de valor que los marcos que lo preceden.
Cada directiva marco será seguido por cero o más especificadores de

orientación común, que tienen el siguiente formato:
jointNumber x y z una
donde el jointNumber es un índice en el conjunto de las articulaciones, tal

como se especifica por el conjunto de directivas anteriores, y xyza son los
cuatro componentes de un estilo de VRML SFRotation. Por ejemplo:
5 0 1 0 0,7854
conjunta significa que el número 5 (la mencionada por la sexta directiva

conjunta en el expediente) sería girar alrededor del eje y (0 1 0) 45 grados
(0.7854 radianes) en este marco.
He aquí un típico archivo de animación:
# Arm-agitando animación
# Creado por Bernie Roehl, marzo de 1997
animales de prueba
bucle
# Articulaciones
conjunta l_elbow
conjunta l_shoulder
# Marcos
cuadro 0.0
00010
10010
marco de 0,50
0 0 0 1 1,5708
1 0 0 1 1,5708
13
marco de 1,00
00010
10010
# Eso es todo, amigos!
Esta animación hace que el brazo izquierdo alrededor de la onda. La animación

se llama la prueba, y los bucles continuamente. Utiliza dos articulaciones:
l_shoulder y l_elbow, el hombro y el codo izquierdo, respectivamente. Se
compone de tres cuadros: La primera tendría lugar en el 0% de la forma a
través de la animación, la segunda en el 50%, y la tercera en el 100%. En cada
fotograma clave, las armas estarán en una orientación diferente en torno al eje
z (0 0 1).
La aplicación ANIMGEN
Nuestro generador de animación, que nos llame ANIMGEN, será muy simple.
Tendremos una clase para representar un conjunto, una clase para representar
un marco, una clase para representar los valores, y una subclase de la clase a
la que representan los valores de rotación. Esta estructura nos permitirá añadir
más tipos de datos, como los colores y las traducciones y otras cosas, más
adelante.
Las Clases
Conjunto de clases será el más simple. Por ahora, simplemente sigue la pista
del nombre del conjunto:
(Conjunto de clase
String name;
public String getName () (return nombre;)
público mixto (String nam) (name = nam;)
public String toString () (return nombre;)
)
Puede preguntarse por qué necesitamos una clase separada sólo para este.
Bueno, nosotros no la-por ahora. Pero algún día nos lo desea, puede añadir
más información para cada conjunto, momento en el que estaremos
encantados que resumieron las articulaciones en una clase por sí mismos.
El Marco de clase no es mucho más compleja:

14
clase Marco (
tiempo de flotación;
Valor [] valores;
Marco público (String inputLine, int nvalues) (
tiempo = Float.valueOf (inputLine). floatValue ();
valores = new Valor [nvalues];
)
flotador público getTime () (return tiempo;)
Valor público getValue (int n) (return valores [n];)
public void SetValue (int n, valor val) (valores [n] = val;)
)
El Marco de clase sigue la pista de la época (en realidad, la fracción) en el

fotograma clave que se produce, junto con una matriz de valores para ese
fotograma clave. Los métodos de acceso directo. El constructor tiene una línea
de entrada, que analiza para encontrar el valor de la fracción. También crea la
matriz de valores, el segundo parámetro al constructor es el número de valores
que tiene que asignar, que es el número de articulaciones que se han definido
utilizando conjuntos directivas. Tenga en cuenta que tenemos un método para
establecer un determinado valor en el conjunto; lo que se utiliza más tarde,
cuando al analizar el archivo.
El valor de clase es sólo una superclase para sus distintas subclases. La única
subclase en este momento es RotationValue:
Valor clase (
)
clase de valor se extiende RotationValue (

flotar x, y, z, una;
público RotationValue (StringTokenizer tokens) (
x = Float.valueOf (tokens.nextToken ()). floatValue ();
y = Float.valueOf (tokens.nextToken ()). floatValue ();
z = Float.valueOf (tokens.nextToken ()). floatValue ();
a = Float.valueOf (tokens.nextToken ()). floatValue ();
)
public String toString () (return x + "" + y + "" + z + "" + a;)
)
El constructor toma RotationValue un StringTokenizer y tira de la x, y, z, y

valores de ángulo de la misma. A continuación, establece en sus variables de
instancia. El único otro método es necesario toString (), que se utilizará para
emitir el VRML SFRotation valores más adelante.
El principal de
15
La línea principal de nuestra aplicación es que una gran parte del trabajo está
hecho. Vamos a mantener una cadena alrededor del nombre de la animación,
que obtiene el conjunto de animales directiva. También se mantendrá en torno
a un booleano que indique si el bucle de animación o no, que recibe el conjunto
de la directiva de bucle.
Vamos a mantener un vector de las articulaciones y un vector de Marcos, que

nos incorporaremos a como nos encontramos con las directivas y el marco
común. Al crear un nuevo Común, pasamos el resto de la línea de entrada (la
parte después de la directiva conjunta) para el Conjunto de constructor. Al
crear un nuevo marco, haremos lo mismo, sino que también pasar el número
de elementos en el vector de Juntas:
/ / Generar animaciones en VRML desde la simple archivo de entrada
/ / Escrito por Bernie Roehl, marzo de 1997
importación java.io. *;
importación java.util .*;
clase pública animgen (

public static void main (String [] args) (
Animname cadena = null;
Marco currframe = null;
Articulaciones vector = new Vector ();
Marcos vector = new Vector ();
boolean loop = false;
try (
D flujo de entrada;
if (args.length == 1)
d = new FileInputStream (args [0]);
algo más
d = System.in;
DataInputStream entrada = new DataInputStream (d);
Cadena de la línea;
while ((= línea input.readLine ())! = null) (
if (line.length () == 0)
continuar;
else if (line.startsWith ("#"))
continuar; / / ignorar líneas de comentarios
else if (line.startsWith ( "animales"))
animname = line.substring (5);
else if (line.startsWith ( "loop"))
16
loop = true;
else if (line.startsWith ( "conjunto"))
joints.addElement (
Conjunto de nuevo (line.substring (6)));
else if (line.startsWith ( "marco"))
frames.addElement (
currframe = new Frame (
line.substring (6), joints.size ()));
else (
StringTokenizer tokens =
StringTokenizer nuevo (línea);
int jointNumber =
Integer.parseInt (tokens.nextToken ());
currframe.setValue (
jointNumber, nuevos RotationValue (fichas));
)
)
)
catch (IOException e) (System.err.println (e);)
vrmldump (animname, bucle, juntas, marcos);
)
Recuerde que el analizador de longitud cero ignora las líneas de entrada y las
líneas que comienzan con #.
Las líneas que contengan los valores de cada uno de las articulaciones son
analizados usando un StringTokenizer. La primera muestra se toma como el
número de conjuntos, y la tokenizer que contiene el resto de las fichas es
pasado al constructor RotationValue.
Una vez que el archivo ha sido analizado, el vrmldump () método es llamado a

la realidad emiten código VRML para la animación.
El vrmldump () Método
El vrmldump () método hace el trabajo de convertir los datos en nuestra

animación VRML. Comienza por una emisora de cabecera VRML. A pesar de
que el archivo de salida contiene un fragmento de código en lugar de un
mundo VRML, el encabezado todavía permiten otras aplicaciones (y los seres
humanos) reconocer qué tipo de archivos es más rápido.
El siguiente paso es emitir el TimeSensor nodo. Ya que puede llegar a querer

tener múltiples animaciones en el mismo archivo, es importante que el
TimeSensor nodos tienen nombres únicos que permiten el acceso de forma
independiente. Vamos a generar un nombre para el TimeSensor tomando el
17
nombre de la animación y la adición de un sufijo de TS en el extremo de la

misma:
static void vrmldump (String animname, boolean loop,

Vector de las articulaciones, los marcos de vectores) (
System.out.println ( "# VRML V2.0 utf8 \ n");
System.out.print ( "DEF" + + animname "TS TimeSensor (");
si (bucle) System.out.print ( "TRUE bucle");
System.out.println ( ") \ n");
Si el bucle se fija booleano, que añadir un bucle a la TimeSensor TRUE. De lo

contrario dejarlo en su valor por defecto de FALSE.
Después viene la verdadera sustancia de la salida de código. Vamos a través

de una enumeración de las articulaciones, lo que genera un
OrientationInterpolator para cada uno. Todos los interpolators puede DEF
comparten el mismo nombre, ya que el único lugar que recibirá el nombre a
que se refiere está en una ruta que va inmediatamente a continuación del
mismo interpolador:
Enumeración en joints.elements = ();

Enumeración fen;
for (int jointnum = 0; en.hasMoreElements ();
jointnum + +) (
J = Conjunto (Joint) en.nextElement ();
System.out.println (
"DEF rotInter OrientationInterpolator (");
System.out.print ( "\ tkey [");
fen = frames.elements ();
while (fen.hasMoreElements ()) (
F = marco (Frame) fen.nextElement ();
if (f.getValue (jointnum)! = null)
System.out.print ( "" + f.getTime ());
)
System.out.println ( "]");
System.out.print ( "\ tkeyValue [");
fen = frames.elements ();
while (fen.hasMoreElements ()) (
F = marco (Frame) fen.nextElement ();
V = valor f.getValue (jointnum);
if (v! = null)
System.out.print ( "" + v);
)
18
System.out.println ( "]");
System.out.println ("}");
System.out.println ( "RUTA" + animname
+ "TS.fraction_changed A rotInter.set_fraction");
System.out.println ( "RUTA rotInter.value_changed A"
J.getName + () + ". Set_rotation");
System.out.println ();
)
)
Para cada conjunto, vamos por todos los fotogramas clave y emiten con un
valor del tiempo y un marco keyvalue correspondiente al valor que para los
conjuntos de serie. En los dos fotogramas clave y la llave de salida, estamos
cuidado para saltar las entradas que son nulas, ya que las correspondientes
juntas no tienen explícita los valores clave para marcos.
Para cada conjunto, también emiten un par de VÍA declaraciones, a fin de tener
la TimeSensor del fraction_changed producción y adjuntarlo a la set_fraction
interpolador de entrada, y un interpolador para tomar la salida de la
fraction_changed y adjuntarlo a la unión del set_rotation entrada.
Correr la aplicación ANIMGEN
Ejecutamos nuestra aplicación en contra de nuestra ANIMGEN anterior archivo

de entrada, de la siguiente manera:
java animgen <test.ani> test.wrl
El archivo de salida resultante tiene este aspecto:
# VRML V2.0 utf8
DEF testTS TimeSensor (bucle TRUE)
DEF rotInter OrientationInterpolator (

tecla [0 0,25 0,5]
keyValue [0 0 1 0 0 0 1 1.5708 0 0 1 0]
)
VÍA testTS.fraction_changed A rotInter.set_fraction
VÍA rotInter.value_changed A l_elbow.set_rotation
DEF rotInter OrientationInterpolator (

tecla [0 0,25 0,5]
19
keyValue [0 0 1 0 0 0 1 1.5708 0 0 1 0]
)
VÍA testTS.fraction_changed A rotInter.set_fraction
VÍA rotInter.value_changed A l_shoulder.set_rotation
Este archivo se adjunta en el archivo de humanoides como se describe

anteriormente, y la consiguiente animación produce el movimiento del brazo
que queremos. Figura 20-4 muestra una sola imagen resultante de la secuencia
de animación. Cualquier número de articulaciones pueden, por supuesto,
animada simultáneamente.
Figura 20.4 El movimiento del brazo en curso

Desarrollos futuros
ANIMGEN El código está diseñado para que pueda constituir la base de un

verdadero sistema de animación de fotogramas clave. La idea es crear un
applet que se comunica con un navegador de VRML a través de la interfaz
externa de autoría (o quizás a través de comandos de nodos implementado en
Java) y permite al usuario interactivamente posición individuales juntas
utilizando SphereSensors enviarse a Transforma. El applet se externo capaz de
leer la posición de cada una de las articulaciones y generar un archivo de
fotogramas clave de la forma descrita anteriormente.
Aumentar la humanoide Archivo
Hasta el momento, el archivo que contiene nuestro humanoide sólo tiene la

jerarquía de la transformación en él. Puede ser conveniente agregar
información adicional para diversas aplicaciones para su uso.
HumanoidInfo
Podemos definir un nodo para almacenar información acerca de nuestros

humanoide. Por ejemplo, tal vez deseen incluir información de autor y los
derechos de autor para nuestros humanoide. También es posible que desee
almacenar información acerca de las longitudes de los segmentos, a fin de
permitir la aplicación de comandos de nodos (por ejemplo) de flexión de la
rodilla-que el comportamiento descrito anteriormente. Podemos almacenar los
diámetros y otras dimensiones del cuerpo, de modo que la ropa puede ser
diseñado y adjunto. Es posible que desee guardar la masa de cada segmento,
para modelar la dinámica del cuerpo. También es posible que desee guardar los
límites y la fuerza conjunta de la información para simulaciones más
20
complejas.
Todos estos tipos de información pueden ser almacenados como un conjunto

de etiquetas o el valor de pares en el ámbito de la información un nodo
WorldInfo. Nosotros le daremos el nombre de nodo de una DEF HumanoidInfo
para que sea fácil de encontrar:
DEF HumanoidInfo WorldInfo (

info [
"los derechos de autor = Bernie Roehl, marzo de 1997"
"authorEmail = broehl@ece.uwaterloo.ca"
"headDiameter = 0.1"
"totalMass = 90"
... Etc ...
]
)
El conjunto de etiqueta / valor pares puede ser fácilmente ampliado.
Articulaciones
Habrá algunos casos en que no queremos utilizar rutas estáticas. Es

posible que desee cargar dinámicamente el humanoide y nodos de
acceso a la transformación directa. Para ello, crearemos un PROTO
Juntas y un ejemplo de que PROTO:
PROTO Articulaciones [
exposedField MFString nombres []
exposedField MFNode articulaciones []
]
(
(Grupo)
)
(DEF Articulaciones Articulaciones

nombres [ "l_shoulder", "l_elbow", "l_wrist" ...]
articulaciones [l_shoulder USO, USO l_elbow, USO l_wrist ...]
)
Este nodo proporciona un mapeo entre una cadena que el nombre

común y una real referencia a la articulación. La aplicación puede leer el
nodo Juntas para descubrir cuántas son las articulaciones en el
humanoide y lo que están llamados, así como obtener una referencia a
21
cada una de las articulaciones por su nombre.
Esta técnica tiene varias ventajas. No sólo permite a las aplicaciones

acceder a las articulaciones dinámicamente, sino que también da al
diseñador del humanoide la opción de añadir otros partes del cuerpo,
como una cola prensil, simplemente mediante la adición de entradas
adicionales en el nodo de Juntas.
Las solicitudes de una norma humanoide
Hay una serie de maneras un humanoide pueda utilizarse. El ejemplo

que estudió anteriormente en este capítulo, de añadir una única
animación a un humanoide, es el caso más simple.
Concurrente de múltiples animaciones y secuencias disparada
Podemos agregar fácilmente al igual que múltiples concurrentes

animaciones, simplemente añadiendo todos ellos en el final del archivo.
Tendríamos que tener cuidado de que no hay dos animaciones intentado
mover el mismo conjunto al mismo tiempo, pero muchos de los
comportamientos (como caminar, saludando, y la cabeza asintiendo con
la cabeza) podrían combinarse de esta manera. Podríamos añadir
también VRML el que activan sensores TimeSensors para ejecutar las
animaciones.
Datos y comprimido Animación Cinemática Inversa
De pasar de la utilización de interpolators, podemos impulsar la

transformación nodos directamente de un Script. Esto nos permitirá
almacenar nuestros datos en una animación de forma comprimida, con
carga a través de una URL especificada en el nodo de secuencias de
comandos. Esto reduciría el tamaño del archivo, el tiempo de descarga y
requisitos de memoria. Esa compresión es importante, ya que los datos
de animación puede ser muy grande. El archivo comprimido de
animación puede ser generado directamente desde el formato de
animación que hemos creado en este capítulo.
También podemos utilizar un sistema de cinemática inversa para

conducir nuestro avatar, utilizando la información sobre longitudes de
segmento (y posiblemente de masas, centros de gravedad, y otra
información) de la HumanoidInfo nodo.
Rendimiento Animación
También se puede manejar el humanoide directamente de un sistema de

animación de rendimiento, a veces se denomina un sistema de captura
de movimiento. En tal configuración, los movimientos de un mundo real
del usuario se utilizan las extremidades para controlar el movimiento de
las extremidades de los miembros de nuestra humanoide. Del mismo
modo, se podría utilizar un formato MPEG-4 de flujo de datos para operar
22
nuestro humanoide.
Las expresiones faciales
Otra área a explorar en el futuro es el uso de expresiones faciales. El

formato MPEG-4 SNHC iniciativa está trabajando en la definición de
parámetros para las acciones faciales y la codificación de ellos en un
flujo de bits. Por que la decodificación de bits, y que sirva para mover los
vértices de la cara, que podría crear las expresiones faciales de nuestra
humanoide avatares.
Los detalles de cómo se llevaría a cabo aún no se han determinado.

Ciertamente, la geometría facial se almacena como un IndexedFaceSet,
y el vértice en lugares sería un nodo de coordenadas. Que podría ser
cambiado por un CoordinateInterpolator o modificados directamente por
una secuencia de comandos utilizando el formato MPEG-4 de flujo de
datos como entrada.
En realidad, las posibilidades son infinitas.

El futuro
Finalmente, podemos esperar a tener la vida humanoide avatares que se

mueven la forma de moverse. Ellos tienen rostros humanos textura
mapeados en ellos, y tendrá las expresiones faciales de la emoción y los
labios sincronizados con el habla. La tecnología básica es aquí, ¿qué se
necesita en este momento son las normas.
Si estás interesado en hacer el seguimiento de los trabajos de

normalización en esta área, visite el VRML humanoide Animación Grupo
de Trabajo (http://ece.uwaterloo.ca/ ~ h-anim).

Capítulo 20

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Capítulo 20

Diunggah oleh

Hak Cipta:

Format Tersedia

1

VRML 2.0 con Java CAPÍTULO 20

VRML 2.0 con Java CAPÍTULO 20

• Creación de humanoides Animación

El cuerpo humano se compone de una estructura del esqueleto, un conjunto de

VRML 2.0 con Java CAPÍTULO 20

Afortunadamente, no tenemos a todos los modelo de la complejidad del cuerpo

Dado que el tiempo quiere crear más de un avatar, es importante que

El diseño de los humanoides

De acuerdo con las directrices presentadas por el Grupo de Trabajo de

Nuestra estructura esquelética se basa vagamente en la estructura propuesta

No vamos a utilizar todas las articulaciones identificados en MPEG-4, en

VRML 2.0 con Java CAPÍTULO 20

Figura 20.1 El diseño básico de nuestro avatar humanoide

Ahora que tenemos nuestra base de diseño en su sitio, es tiempo de comenzar

Como se describe anteriormente, los humanoides se basa en una

VRML 2.0 con Java CAPÍTULO 20

3-D paquete, vamos a utilizar primitivas geométricas (esferas y cilindros) para

Debido a que está utilizando primitivas, en lugar de IndexedFaceSets,

Un Consejo de Administración-Segmento PROTO

Vamos a empezar por la definición de un PROTO para un segmento de cuerpo:

# VRML V2.0 utf8

VRML 2.0 con Java CAPÍTULO 20

La loc campo especifica la ubicación de la articulación propiamente dicha, que

La posición exterior de transformación del segmento. Tiene dos hijos: la Esfera

El archivo que describe la totalidad del humanoide es muy grande y no muy

DEF l_shoulder transformación (

VRML 2.0 con Java CAPÍTULO 20

Esta sección del código describe el brazo izquierdo de nuestro humanoide.

Cada conjunto es una transformación específica DEF asignado un nombre, a fin

VRML 2.0 con Java CAPÍTULO 20

Figura 20.2 La jerarquía de nuestra humanoide del cuerpo

Transformar el hombro izquierdo, tiene dos hijos: el codo izquierdo de

Figura 20.3 muestra el humanoide completado, con un nodo de Esfera por su

Figura 20.3 La completado humanoide

Observe que la columna tiene un número de segmentos. Estos no son

Ahora que hemos construido nuestra base humanoide, es el momento para

VRML 2.0 con Java CAPÍTULO 20

empezar a hacer que se mueva. La idea básica es la rotación de diferentes

Por ejemplo, si queríamos guiño a la cabeza de arriba a abajo, se puede

# VRML V2.0 utf8

DEF TS TimeSensor (bucle TRUE)

DEF INTER OrientationInterpolator (

VÍA TS.fraction_changed A INTER.set_fraction

TimeSensor El campo tiene su bucle establecido en TRUE, lo que significa que

El OrientationInterpolator es también el nombre, ya que va a enviar y recibir

Observe que los valores clave no son uniformemente espaciadas. La primera es

VRML 2.0 con Java CAPÍTULO 20

Estamos VÍA fraction_changed el eventOut del TimeSensor nombre en el TS de

copia stickman.wrl + nodding.wrl nodman.wrl

gato stickman.wrl nodding.wrl> nodman.wrl

en Unix. El archivo resultante nodman.wrl puede ser cargada en cualquier

VRML 2.0 con Java CAPÍTULO 20

coordinar las múltiples acciones conjuntas. Idealmente, nos gustaría una

Nuestra solución es crear un sencillo lenguaje de script, que es más

Vamos a implementar una aplicación Java que lee el lenguaje de scripting de

Existen cuatro directivas: animales, lazo, común, y el marco. Debería haber

Debe haber un lazo en la mayoría de declaración. Si la actualidad, hará que el

La directiva conjunta identifica un conjunto por su nombre, como sigue:

Habrá una directiva marco para cada fotograma clave en la animación. La

VRML 2.0 con Java CAPÍTULO 20

Cada directiva marco será seguido por cero o más especificadores de

donde el jointNumber es un índice en el conjunto de las articulaciones, tal