Modelagem de animação procedural para expressividade

Transcrição

Rogério Willians Chaves da Silva
Modelagem de animação procedural para expressividade facial
de Atores Digitais Autônomos
Joinville
2013
Relatório Final de Trabalho de Conclusão de Curso
(TCC) apresentado ao Curso de Graduação em
Ciência da Computação, da Universidade do Estado de Santa Catarina (UDESC), como requisito
parcial da disciplina de Trabalho de Conclusão de
Curso.
Orientador: Profo Rogério Eduardo da Silva
Joinville
2013
Relatório Final de Trabalho de Conclusão de Curso
(TCC) apresentado ao Curso de Ciência da Computação da UDESC, como requisito parcial para a
obtenção do grau de BACHAREL em Ciência da
Computação.
Aprovado em
BANCA EXAMINADORA
Profo Rogério Eduardo da Silva
Profo André Tavares da Silva
Profo Claudio Cesar de Sá
Resumo
Este trabalho apresenta um modelo para construção de animações procedurais
das faces de Atores Digitais Autônomos, cujo objetivo é animar a expressão de emoções,
visualização da fala, piscar de olhos e direcionamento de olhar para a face de personagens. A partir do embasamento teórico descrito neste trabalho, foi criado um modelo,
composto por 4 módulos. Estes módulos são responsáveis pela entrada de um arquivo
com a descrição de uma linha de tempo, tradução desta linha do tempo em uma linguagem de comandos de animação, nomeada BML, finalizando com interpretação e geração
da animação facial pela ferramenta de animação. A solução proposta por este modelo é
particularmente importante para o módulo de expressividade do projeto D.R.A.M.A.. A
implementação foi realizada como um plugin para Autodesk MayaTM , que lê um arquivo
de entrada e gera a animação facial. Como verificação, utilizou-se um experimento com
comandos de animação, considerando todas as funcionalidades desenvolvidas. O plugin
desenvolvido foi capaz de gerar resultados que condizem com o arquivo de entrada. Foi
observado que o modelo permite a adição de novas emoções e visemas, assim como a
execução em outros personagens.
Palavras-chave: atores digitais autônomos, expressão facial, animação procedural
Abstract
This paper presents a model for building procedural animation of Autonomous
Digital Actors faces, which goal is to animate emotions expressions, speech visualization,
eye blink and eye gaze for characters face. From the theoretical foundation described in
this paper, a model was created, composed of four modules. These modules are responsible
for the entry of a file with the description of a timeline, translation from this timeline into
an animation command language named BML, ending with interpretation and generation of
facial animation by the animation tool. The solution proposed by this model is particularly
important for the expressiveness module at D.R.A.M.A. project. The implementation was
performed as a plugin to Autodesk MayaTM , which reads an input file and generates facial
animation. As verification, an experiment was used with animation commands, consisting
of all the features developed. The developed plugin was capable of generating results that
are consistent with the input file. It was observed that the model allows the addition of
new emotions and visemes, as well executing into other characters.
Keywords: Autonomous Digital Actors, facial expression, procedural animation
Sumário
Lista de Tabelas
6
Lista de Figuras
8
Lista de Algoritmos
9
Lista de Abreviaturas
10
1 Introdução
11
2 Atores Digitais Autônomos
14
2.1
Narrativa Digital . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2
Humanos Virtuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3
Atores Virtuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4
Atores Digitais Autônomos . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5
Animação Procedural . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3 Animação Facial
19
3.1
Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2
Anatomia Facial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3
Técnicas de animação facial . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3.1
Manipulação Geométrica . . . . . . . . . . . . . . . . . . . . . . . . 25
3.3.2
Dirigida por desempenho . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4
Representação Visual da Fala . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.5
Direcionamento do Olhar . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.6
Piscar de olhos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.7
3.8
Representação Facial de Emoções . . . . . . . . . . . . . . . . . . . . . . . 37
3.7.1
Fisiologia das Emoções . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.7.2
Facial Action Coding System . . . . . . . . . . . . . . . . . . . . . 40
3.7.3
Emoções Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.7.4
Expressão Emocional Falsa . . . . . . . . . . . . . . . . . . . . . . . 54
3.7.5
Posicionamento da Cabeça . . . . . . . . . . . . . . . . . . . . . . . 55
Behavior Markup Language . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4 Modelo Proposto
59
4.1
Módulo de Entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2
Módulo de Tradução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.3
Módulo de Saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.4
Módulo de Animação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5 Desenvolvimento
72
5.1
Ferramentas utilizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.2
Refinamento do modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.3
Desenvolvimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.3.1
Banco de Emoções . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.3.2
Módulo de Entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.3.3
Módulo de Tradução . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.3.4
Módulo de Saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.3.5
Módulo de Animação . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6 Experimentação e Análise dos Resultados
89
6.1
Experimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.2
Análise dos Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.3
Validação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7 Conclusões
94
Referências Bibliográficas
96
A Apêndice
A.1 Arquivo de entrada utilizado para Experimentação
107
. . . . . . . . . . . . . 108
A.2 Código-fonte do plugin desenvolvido . . . . . . . . . . . . . . . . . . . . . . 113
Lista de Tabelas
3.1
Grupos de FAPs
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2
Visemas e respectivas representações visuais . . . . . . . . . . . . . . . . . 34
3.3
Unidades de Ação (Action Units - AU ) . . . . . . . . . . . . . . . . . . . . 42
3.4
Elementos de Comportamento BML . . . . . . . . . . . . . . . . . . . . . . 58
4.1
Comportamento: demonstrar emoção . . . . . . . . . . . . . . . . . . . . . 61
4.2
Comportamento: olhar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.3
Comportamento: falar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.4
Comportamento: piscar
4.5
Comportamento: mover a cabeça . . . . . . . . . . . . . . . . . . . . . . . 63
5.1
Valores extremos dos controladores por emoção . . . . . . . . . . . . . . . 79
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Lista de Figuras
1.1
Módulo de expressividade no projeto D.R.A.M.A. . . . . . . . . . . . . . . 13
3.1
Ossos do crânio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2
Músculos da face . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3
Músculos em ação na expressão facial . . . . . . . . . . . . . . . . . . . . . 23
3.4
Primeiros modelos de face desenvolvidos por Park . . . . . . . . . . . . . . 24
3.5
Face aprimorada por Parke utilizando técnicas de renderização . . . . . . . 24
3.6
Interpolação das poses A e B, gerando A+B . . . . . . . . . . . . . . . . . 26
3.7
Pontos característicos do MPEG-4 . . . . . . . . . . . . . . . . . . . . . . . 27
3.8
Marcadores na face de Tom Hanks para captura de movimentos . . . . . . 30
3.9
Animação baseada em desempenho em tempo real . . . . . . . . . . . . . . 31
3.10 Personagem renderizado em tempo real . . . . . . . . . . . . . . . . . . . . 32
3.11 Visemas da língua inglesa . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.12 Movimentos básicos da boca . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.13 Posições básicas das pálpebras . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.14 Partes do cérebro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.15 Unidades de ação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.16 Expressão facial da tristeza
. . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.17 Expressão facial da raiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.18 Expressão facial de medo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.19 Expressão facial da surpresa . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.20 Expressão facial da aversão . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.21 Expressão facial de desprezo . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.22 Expressão facial da felicidade . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.23 Exemplo de um bloco BML . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.24 Pontos de sincronização
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.25 Sincronização de gesto, movimento da cabeça e olhar direcionado . . . . . 57
4.1
Módulos do modelo proposto . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2
Taxonomia do módulo de entrada . . . . . . . . . . . . . . . . . . . . . . . 60
4.3
Gráfico de movimentação da boca . . . . . . . . . . . . . . . . . . . . . . . 66
4.4
Tira da Turma da Mônica para exemplificar o módulo de saída . . . . . . . 68
5.1
Modelo de Personagem Blake . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2
Controladores da face . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.3
Controladores customizados da face . . . . . . . . . . . . . . . . . . . . . . 75
5.4
Script Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.5
Emoções desenvolvidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.6
Intensidades da emoção Felicidade . . . . . . . . . . . . . . . . . . . . . . . 84
5.7
Trax Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.1
Ações de fala, olhar um objeto e demonstrar emoções . . . . . . . . . . . . 89
6.2
Movimentos com os olhos e com a cabeça . . . . . . . . . . . . . . . . . . . 90
6.3
Aceno e inclinação da cabeça, e piscar de olhos . . . . . . . . . . . . . . . . 90
6.4
Emoções e combinações
6.5
Pescoço contorcido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
A.1 Arquitetura do projeto D.R.A.M.A. . . . . . . . . . . . . . . . . . . . . . . 107
Lista de Algoritmos
4.1
Exemplo de arquivo XML de entrada . . . . . . . . . . . . . . . . . . . . . . 69
4.2
Exemplo de arquivo BML de saída . . . . . . . . . . . . . . . . . . . . . . . 70
5.1
Utilização da linguagem mel no código python . . . . . . . . . . . . . . . . 72
5.2
Exemplo de arquivo XML de entrada . . . . . . . . . . . . . . . . . . . . . . 80
5.3
Exemplo de arquivo BML de saída . . . . . . . . . . . . . . . . . . . . . . . 82
. . . . . . . . . . . . . 108
A.2 Código-fonte do plugin desenvolvido . . . . . . . . . . . . . . . . . . . . . . 113
10
Lista de Abreviaturas
ADA
Autonomous Digital Actor
AU
Action Units
BML
Behavior Markup Language
D.R.A.M.A.
Developing Rational Agents to Mimic Actors
FACS
Facial Action Coding System
FAP
Facial Animation Parameters
FDP
Face Definition Parameters
FFD
Free Form Deformation
FP
Feature Point
XML
eXtensible Markup Language
11
1 Introdução
A face é a primeira parte do corpo utilizada para reconhecimento e comunicação interpessoal (PARKE; WATERS, 2008). Desde os primeiros anos de vida, até a vida
adulta, a capacidade de interpretar e identificar as emoções pela expressão facial é aperfeiçoada. A quantidade de micro expressões e detalhes na expressão facial, torna a produção
de animações faciais um grande desafio (MARTINO, 2005).
Para animar fenômenos difíceis de especificar explicitamente, como a expressão
facial, pode-se utilizar técnicas de animação procedural (MAY et al., 1996). Esta técnica é
bem aproveitada quando é possível descrever a ação em forma de algoritmo (MAGNENATTHALMANN; THALMANN,
2004). O uso de animação procedural permite criar cenas mais
complexas a partir de poucos detalhes de descrição funcional (HOETZLEIN, 2011).
Em considerável parte dos sistemas de animação, a qualidade da animação
dos personagens 3D depende diretamente da equipe responsável por animar isoladamente
cada ação e movimento realizado. Personagens sintéticos podem ser utilizados como
alternativa a este processo de animação. Estes buscam simular com maior precisão um
ator humano, o qual se comporta de forma autônoma e inteligente em ambientes dinâmicos
a partir de um roteiro dado. Porém, em contraste ao avanço tecnológico da aparência e
das funcionalidades realistas dos personagens, a maior parte dos projetos de personagens
sintéticos apresenta pouca complexidade de comportamento (TORRES et al., 2002).
Personagens sintéticos tem grande utilidade em atuação de narrativas, construção de filmes de animação e desenvolvimento de jogos. Podem ser utilizados tanto em
sistemas de narrativa (story-based), onde o roteiro designa ações, locais e tempos, quanto
em sistemas baseados em personagem (character-based), onde o personagem tem maior
autonomia para selecionar suas ações e interagir com o mundo virtual (CAVAZZA et al.,
2002).
O processo de construir animação de personagens está se tornando cada vez
mais complexo, ao exigir grande quantidade de profissionais, com conhecimentos especializados, resultando em gastos demasiados. Uma provável alternativa para redução de custos
é a utilização de Atores Digitais Autônomos (ADA). Ao invés de animar o personagem
1 Introdução
12
separadamente para cada sequência de movimento, o animador tem a possibilidade de
utilizar softwares especializados, para treinar um ADA, capacitando-o de empregar movimentos, linguagem corporal, emoção e tomada de decisões (PERLIN; SEIDMAN, 2008).
Conforme Martino (2005), além da fala, a compreensão da mensagem depende
também da expressividade facial. Para simular a animação facial, é necessário considerar
os vários movimentos realizados por esta: posicionamento da cabeça (direção), articulação
da boca ao falar, representada por visemas (unidades básicas visuais da boca ao reproduzir
a fala), expressão de emoções (tristeza, alegria, raiva...) e fisiológicos (piscar dos olhos).
O objetivo deste trabalho é descrever um modelo para construção de animações
procedurais para Atores Digitais Autônomos. Os objetivos específicos são desenvolver
uma aplicação conforme o modelo proposto e criar animações procedurais com ADAs
para demonstração de resultado.
Para que sejam alcançados os objetivos deste trabalho, a metodologia escolhida
foi Design Based Research. Tal metodologia é utilizada quando um artefato do mundo
real necessita ser desenvolvido, dado um propósito definido. Deve-se então adquirir conhecimento deste artefato para cumprir o propósito, criar um design, desenvolver a partir
deste, fazer a verificação e análise dos resultados e, caso necessário, a partir da análise,
refinar o design e o desenvolvimento (BARAB; SQUIRE, 2004).
Este trabalho está inserido no projeto D.R.A.M.A. (Developing Rational
Agents to Mimic Actors), que tem como objetivo a pesquisa de personagens virtuais,
inspirados na atuação de atores reais, afim de aplicá-la no desenvolvimento de atores virtuais que possam atuar de forma autônoma (SILVA, 2012). A arquitetura completa do
projeto D.R.A.M.A pode ser vista na figura A.1 do apêndice. Este trabalho de conclusão
de curso contribui com um modelo implementado para a criação da animação procedural
de ADA, no escopo de expressividade facial, representação de emoções, movimentação da
cabeça , representação visual da fala, e direcionamento do olhar, representado na Figura
1.1.
1 Introdução
13
Figura 1.1: Módulo de expressividade no projeto D.R.A.M.A.
Fonte: Projeto D.R.A.M.A.
O resultado obtido pela implementação do modelo proposto foi um plugin
para a ferramenta Autodesk MayaTM . A entrada para este plugin é um arquivo XML, que
é interpretado, e uma animação facial é gerada a partir dos comandos presentes neste
arquivo. Para testes do modelo proposto, foi utilizado um arquivo de entrada, com todas
funcionalidades implementadas. Para verificação, foram analisados se os resultados são
coerentes com os comandos do arquivo de entrada.
Organização do Trabalho
Os fundamentos utilizados para o desenvolvimento do modelo são apresentados
no Capítulo 2 – Atores Digitais Autônomos e no Capítulo 3 – Animação Facial. Após, é
apresentado o Capítulo 4 - Modelo Proposto. A implementação do sistema é descrita no
Capítulo 5 - Desenvolvimento, e os resultados no Capítulo 6 - Experimentação e Análise
dos Resultados. O trabalho é finalizado pelo Capítulo 7 - Conclusões.
14
2 Atores Digitais Autônomos
Esta seção destina-se ao estudo de atores digitais autônomos. Inicialmente é
apresentada a narrativa digital, para entendimento do contexto de utilização de atores
digitais autônomos. A seguir, são apresentados os conceitos de humanos virtuais, atores
virtuais e atores digitais autônomos, de forma a distingui-los, apresentando qual melhor
se adapta à arquitetura do projeto D.R.A.M.A.. Por fim, é apresentado um estudo sobre
animação procedural.
2.1
Narrativa Digital
A indústria de entretenimento utiliza narrativas em diversas aplicações, como
treinamento, marketing, educação, simulação, cinema e jogos (EL-NASR; WEI, 2008). Segundo Louchart e Aylett (2007), no escopo da computação gráfica e inteligência artificial,
a narrativa se divide em dois grupos principais: narrativas baseadas em personagens e as
baseadas em enredo.
As narrativas baseadas em enredo seguem um roteiro, que designa a cada
ator as ações corretas a serem tomadas no local, ordem e tempo corretos. O personagem
somente tem autonomia em como expressar suas ações, já definidas (LOUCHART; AYLETT,
2007). Já em narrativas baseadas em personagens, não existe o conhecimento explícito do
roteiro. O personagem então é fortemente autônomo, selecionando suas ações, baseadas
na maneira em que este interage com o mundo virtual (CAVAZZA et al., 2002).
Torres et al. (2002) afirmam que, para ambos grupos de narrativas, personagens sintéticos tem grande utilidade para atuarem tanto na construção de filmes (narrativa
baseada em enredo) quanto no desenvolvimento de jogos (narrativa baseada em personagem). Tais personagens tem a utilidade de imitar o comportamento de um ator humano,
agindo de maneira inteligente em ambientes dinâmicos, tendo autonomia em suas ações
ou na forma de expressá-las, conforme a narrativa.
Spierling (2005) cita as duas vertentes da narração digital: linear e interativa.
As narrações lineares tem como base a tradicional forma de contar histórias em ordem
2.2 Humanos Virtuais
15
cronológica. A narrativa segue um roteiro, com início, clímax e fim, como utilizado em
vários filmes animados por computador. Em contraste, as narrações interativas permitem
que a audiência influencie e altere o rumo da história. São facilmente identificadas em
grande parte dos jogos de computadores, onde o jogador participa como o personagem da
história, fazendo escolhas que podem alterar o rumo da história.
Para este trabalho, a abordagem narrativa utilizada é baseada em enredo,
seguindo um roteiro fornecido para o sistema e linear, possuindo uma ordem cronológica.
Utiliza-se esta abordagem, pela necessidade de gerar uma animação de computador a
partir de um roteiro, presente no escopo do projeto D.R.A.M.A.. Nos próximos tópicos
são descritos os tipos de personagens sintéticos existentes, com intuito de definir o tipo
de personagem mais adequado no uso da narrativa.
2.2
Humanos Virtuais
“Humanos virtuais são modelos computacionais de pessoas, usados tanto
como substitutos para pessoas reais em avaliações ergonômicas de projetos baseados em computador, quanto para embutir, em tempo real, representações de
participantes reais em ambientes virtuais.” (TORRES et al., 2002)
Os humanos virtuais são utilizados quando deseja-se imitar o comportamento
de humanos reais. Suas principais aplicações atualmente são em jogos e animações de
computador (SEVIN; THALMANN, 2005).
Para medir a credibilidade de um humano virtual, é preciso que este se comporte de forma inteligente e autônoma, que perceba e esteja em sincronia com o ambiente
que o rodeia, que entenda e seja capaz de gerar diálogos e de reagir a mudanças, assim
como interagir com outros agentes (MAGNENAT-THALMANN; THALMANN, 2004).
Algumas dimensões podem ser consideradas para caracterizar o grau de similaridade a um humano real. Os modelos de humanos virtuais podem ter sua fisionomia
semelhante a um ser humano, assim como restrições funcionais de movimentos e ações,
imitando as limitações humanas. Podem ser capazes de comportar-se com autonomia
em suas ações, e executá-las de forma inteligente, tomando suas próprias decisões em
ambientes dinâmicos (BADLER, 1997).
2.3 Atores Virtuais
16
Conforme Magnenat-Thalmann e Thalmann (2004), a credibilidade do humano
virtual está em seu comportamento. Para que um nível satisfatório de credibilidade
seja atingido, o comportamento do humano virtual deve ser similar ao comportamento
humano, gerando assim, grande grau de complexidade. Elementos como tomadas de
decisões, comportamento social, percepção do ambiente e ainda aspecto gráfico realista
(pele, cabelo, roupa) são requisitos de humanos virtuais.
A arquitetura do projeto D.R.A.M.A. não se restringe ao uso de personagens
que imitam o ser humano, podendo ter diversos tipos de personagens fictícios e de movimentos exagerados. Desta maneira, o modelo aqui proposto de humanos virtuais não é o
mais adequado, pois o projeto não permite flexibilidade e autonomia na escolha das ações
do ator, o qual deve seguir um roteiro específico. É importante salientar que o projeto
tem a necessidade de personagens que sigam um roteiro, porém com autonomia na forma
de expressar as suas ações.
2.3
Atores Virtuais
Iurgel e Marcos (2007) definem atores virtuais como “uma analogia a um ator
real, o qual de forma autônoma, e pela sua interpretação independente da situação, pode
representar o seu papel de acordo com um roteiro dado, como parte de uma história.”.
Enquanto humanos virtuais são altamente autônomos, escolhendo suas ações
em resposta a percepção do mundo virtual, atores virtuais restringem-se à reprodução
da narrativa, executando ações particulares em uma ordem definida. Portanto, a autonomia de um ator virtual é menor que a autonomia de um humano virtual, sendo esta
utilizada principalmente para escolher a melhor forma de um ator expressar as suas ações
(LOUCHART; AYLETT, 2007).
A utilização de atores virtuais contribui na redução de custos de produção e
facilita o processo de criação. Assim como um ator humano, o ator virtual deve ser capaz
de seguir comandos abstratos de um diretor, por meio de um script, que irá orientá-lo
com ações a serem tomadas (IURGEL, 2008).
2.4 Atores Digitais Autônomos
2.4
17
Atores Digitais Autônomos
Um Ator Digital Autônomo (Autonomous Digital Actor - ADA) é um ator vir-
tual, treinado por ferramentas de software para criação de animações, capaz de “empregar
vários estilos de movimento, linguagem corporal, técnicas para transmitir emoções, realizar escolhas de atuação e outras habilidades gerais de desempenho.” traduzido de Perlin
e Seidman (2008).
Com estas propriedades, um ADA treinado pode ser dirigido por animadores
sem conhecimentos específicos, podendo o ADA possuir autonomia, humor, personalidade
e intenções, interativamente alterados pelo animador. Desta forma, não é mais necessário animar cada sequência de movimento realizada por um personagem separadamente
(PERLIN; SEIDMAN, 2008).
Iurgel et al. (2010) afirmam que, com esta abordagem, é capaz de acelerar
a criação de filmes de animação povoados com atores digitais autônomos. O animador
necessita menos esforço e tempo para criar uma animação, quando transfere para o personagem a responsabilidade de decidir grande parte do desempenho da atuação.
Thume e Silva (2012) propõem alguns requisitos para implementação de atores
digitais autônomos:
• Estado mental: estados internos do agente, como desejos, intenções e emoções;
• Percepção e Ação: percepção por sensores e atuação por atuadores;
• Autonomia: dispensa especificar cada passo da atuação;
• Aprendizagem: melhoria em atuações futuras;
• Memória: armazena dados para consultar posteriormente;
• Tomada de decisão: escolher a maneira de atuar;
• Planejamento: define os passos para alcançar um objetivo proposto.
Atores digitais autônomos são utilizados pelo projeto D.R.A.M.A.. Com a
flexibilidade e autonomia destes, é possível transferir ao personagem a responsabilidade
de decidir a melhor maneira de atuar, dentro das ações de um roteiro específico, fornecido
pelo animador. Desta forma, o animador irá assumir o papel de diretor.
2.5 Animação Procedural
2.5
18
Animação Procedural
A modelagem e geração de animações sofisticada para personagens, cenários
e objetos, tem tornado o processo de animação custoso e demorado. Com os avanços
da inteligência artificial e computação gráfica, procura-se criar personagens e animações
cada vez mais realistas. Para simplificar a necessidade de especificar detalhadamente uma
animação, é possível a utilização de técnicas procedurais (MAY et al., 1996).
O termo procedural, quando utilizado na Ciência da Computação, significa que
uma entidade é descrita por códigos de programa, e não simplesmente por estrutura da
dados (EBERT, 2003). A modelagem procedural permite gerar cenas e modelos geométricos
complexos a partir de uma especificação funcional compacta, sem que todos os elementos
e ações sejam detalhadamente especificados (HOETZLEIN, 2011).
A utilização de modelagem procedural na animação tem uma gama extensa de
aplicações. Nos primórdios do mapeamento de textura, diversos pesquisadores utilizaram
modelos sintéticos de textura para gerar imagens, ao invés de escanear ou pintar estas
imagens (EBERT, 2003). A modelagem procedural pode ser utilizada sempre que uma ação,
ou forma geométrica puder ser descrita em um algoritmo, autômato ou fórmula como,
por exemplo, o ciclo de um relógio ou a sequência de passos ao caminhar (MAGNENATTHALMANN; THALMANN,
2004).
Conforme May et al. (1996), inicialmente, esta técnica possuía seu principal
uso na criação de cenários, corpos elásticos, colisões e outros. Com o crescimento da
complexidade dos objetos, que se tornaram mais sofisticados, modelos de pessoas, animais
e objetos de menor porte, também tem utilizado tal técnica.
Um exemplo de animação procedural é a ação de pegar um objeto. Utilizando
uma ferramenta de software, um animador define, em linguagem de alto nível, que um
determinado personagem sentado pegue um objeto em uma mesa. A ferramenta calcula
os movimentos necessários para execução da tarefa. Caso o objeto esteja ao alcance do
personagem, a ação deste é somente esticar o braço. Caso não esteja ao alcance, há a
necessidade do personagem levantar-se e deslocar-se para mais próximo do objeto.
A utilização da técnica de animação procedural se aplica à proposta deste
trabalho, que tem como objetivo gerar uma animação facial, a partir do fornecimento de
uma emoção, ou uma fala de um personagem.
19
3 Animação Facial
Este capítulo introduz os principais conceitos da animação facial. Inicialmente
é apresentada a anatomia facial, para compreensão da ação muscular na realização de
expressões faciais. A seguir, são apresentadas as principais técnicas e abordagens da
animação facial.
A representação visual da fala, o direcionamento do olhar, o piscar de olhos
e a representação facial de emoções são também apresentados neste capítulo. A seção
3.8 trata a linguagem BML (Behavior Markup Language), que descreve o comportamento
humano, independentemente do método de animação utilizado. O conteúdo deste capítulo
é utilizado como base para a criação de um modelo de expressividade facial.
3.1
Introdução
A face é a primeira parte do corpo utilizada para reconhecimento e comunica-
ção interpessoal. Nas animações em três dimensões geradas por computador, a preocupação em comunicar-se corretamente utilizando a face, principalmente ao exibir emoções,
têm resultado no aumento dos estudos sobre animação facial (PARKE; WATERS, 2008).
O uso de computadores na animação facial já se estende a mais de 30 anos
(COSTA; CLUA, 2007). Porém, conforme Chung (2009), ainda existem algumas dificuldades encontradas para animar a face de um personagem, relacionadas a três problemas
principais:
1. O modelo de representação facial, pela dificuldade em modelar uma face com
geometria detalhada e real;
2. O controle das expressões faciais, por envolverem psicologia, fisiologia e interações entre os músculos para criação de animações reais;
3. A percepção dos espectadores, por serem bastantes sensíveis a detalhes das
expressões faciais, estando atentos e interpretando cada mudança da face.
3.2 Anatomia Facial
20
Parke e Waters (2008) afirmam que não é somente na indústria de animação
digital que a animação facial de personagens pode ser utilizada. Na indústria de jogos,
com o alto poder de processamento atual, expressões faciais e sincronização com a fala
podem ser executadas em tempo real. Na medicina, a animação facial pode ser utilizada
para simulação cirúrgica de tecido facial e planejamento cirúrgico. Em teleconferências
de vídeo, para auxiliar no processo do compressão de vídeo. E também pode ser utilizada
na robótica para simulação de expressões faciais.
Atualmente, os principais objetivos ao desenvolver sistemas para animação
facial, conforme Deng e Noh (2007), são criar animações realistas, não somente a nível
de semelhança ao mundo real, mas dando aparência de vida e perfeição nas expressões
e movimentos faciais dos personagens; animar em tempo real, facilitando a visualização
dos resultados; tornar o processo mais autônomo possível, diminuindo o processo manual
de animação; e criar sistemas que se adaptem facilmente a qualquer particularidade facial
do personagem.
Martino (2005) agrupa os movimentos reais da face em 5 categorias:
1. Articulatórios: movimentos articulatórios exibidos na face em sincronia com a
fala;
2. Emocionais: movimentos responsáveis por expressar as emoções (por exemplo,
alegria, tristeza, medo);
3. Conversacionais: movimentos que acompanham o discurso, enfatizando palavras
e auxiliando na transmissão da mensagem;
4. Fisiológicos: movimentos necessários fisiologicamente, como o piscar dos olhos;
5. Contorcidos: movimentos não usuais na face (caretas).
Este trabalho aborda os movimentos articulatórios, emocionais e fisiológicos.
3.2
Anatomia Facial
O crânio tem papel primordial na anatomia facial. Nele músculos e a pele
estão anexados. O crânio é quem molda o formato da face, e tem papel importante
3.2 Anatomia Facial
21
Figura 3.1: Ossos do crânio
Fonte: Adaptada de (PARKE; WATERS, 2008)
na proteção do cérebro. Dentre os ossos da cabeça (representados na Figura 3.1), a
mandíbula, responsável pelo abrir e fechar da boca, é o único osso articulado do crânio.
Já os dentes, encravados na mandíbula, são a única estrutura óssea visível. Os demais
ossos, são conectados por suturas rígidas, permitindo pouco movimento entre os ossos
(PARKE; WATERS, 2008).
Ping e Abdullah (2013) afirmam que os músculos faciais representados na
Figura 3.2), cuja função principal é coordenar as expressões faciais, estão em sua maioria
anexados a um osso em uma extremidade e, na outra extremidade, anexados à pele,
produzindo as expressões por meio de contrações que puxam a pele. (PARKE; WATERS,
2008) acrescentam que, além das expressões faciais, os músculos da face também são
responsáveis por mover a bochecha e os lábios na mastigação, por engolir, pela fala e
pelos movimentos das pálpebras.
Moore e Dalley (2006) agrupam os músculos da face de acordo com sua região
de atuação e funcionalidades:
• Músculos da testa: possuem a função de elevar as pálpebras e sobrancelhas, assim
como enrugar a testa (occipitofrontal);——————– ————————– ————
3.2 Anatomia Facial
22
Figura 3.2: Músculos da face
Fonte: Adaptada de (MOORE; DALLEY, 2006)
——————• Músculos da boca: são vários os músculos responsáveis por alterar o formato da
boca e dos lábios. O músculo orbicular é responsável pelo fechamento dos lábios
e contração destes. O músculo levantador do lábio superior eleva o nariz e o lábio
superior. O músculo bucinador é utilizado na mastigação para pressionar as bochechas contra os dentes e ao soprar, comprimindo as bochechas. O músculo abaixador
do ângulo da boca é o responsável por fazer o formato da boca de “U” invertido.
Os músculos zigomático maior e risório são utilizados para sorrir;
• Músculos dos olhos: são responsáveis por proteger o olho contra lesões e luz excessiva, pelo fechamento das pálpebras, realizado pelo músculo orbicular do olho.
Há também o músculo corrugador do supercílio que controla o movimento das sobrancelhas e o enrugamento da testa;
• Músculos do nariz: possuem a função de dilatar ou contrair a abertura nasal e
puxar a narina para baixo (músculo nasal), enrugar o dorso do nariz e franzir as
sobrancelhas (prócero) ;——————– ————————– ——————————-
3.3 Técnicas de animação facial
23
• Músculos da mandíbula: realizam a abertura (digástrico) e fechamento (masseter) da boca, mastigação e demais os movimentos para frente (pterigoideo) e para
trás (temporal);
• Músculos da língua: responsáveis pela fala e movimentos da língua. Os músculos extrínsecos (fora da língua) abaixam, retraem, elevam e puxam a língua para
cima, enquanto os intrínsecos (confinados à língua) enrolam, encurtam, engrossam,
achatam, alongam, estreitam e projetam a língua para frente ou para fora da boca;
• Músculos do pescoço: executam os movimentos de rotação da cabeça (platisma,
esternocleidomastoideo e trapézio).
As ações de alguns músculos da face podem ser vistas na Figura 3.3.
Figura 3.3: Músculos em ação na expressão facial
Fonte: Adaptada de (MOORE; DALLEY, 2006)
3.3
Técnicas de animação facial
Frederick Ira Parke foi o pioneiro da animação facial por computador, no ano
de 1971, com a criação da primeira face gerada por computador (representada na Figura
24
3.4), criada a partir de polígonos, possuindo somente a capacidade de fechar e abrir boca
e olhos (PARKE; WATERS, 2008).
Figura 3.4: Primeiros modelos de face desenvolvidos por Park
Fonte: Adaptada de (PARKE; WATERS, 2008)
Parke (1972), posteriormente, utilizou técnicas de renderização de Henri Gouraud, para criar uma face com maior perfeição (representada na Figura 3.5). Com essa
face, algumas animações faciais mais “realistas” foram produzidas, utilizando técnicas de
interpolação entre poses, que tem intuito de gerar quadros de transição entre diferentes
expressões faciais.
Figura 3.5: Face aprimorada por Parke utilizando técnicas de renderização
Fonte: Adaptada de (PARKE, 1972)
Conforme Parent (2001), a interpolação de valores é a base da maioria das
animações. A utilização de quadros-chave (key-frames) é comum entre os animadores
para definir uma sequência de acontecimentos de uma cena. Esses quadros-chave possuem
diversos quadros entre eles, que devem ser gerados, pelo processo chamado interpolação.
A interpolação pode ser tanto da posição do objeto, quanto de outros atributos, como a
transparência, ângulo, etc.
Em 1974, Parke também criou o primeiro modelo parametrizado da face, em
três dimensões (PARKE; WATERS, 2008). Com o uso das técnicas de interpolação e de
25
parametrização, Parke (1982) segmentou as animações faciais em duas abordagens distintas. A primeira abordagem utiliza interpolação de quadros-chave, onde o computador
gera imagens intermediárias entre posições distintas da face. A segunda, utiliza modelos
faciais parametrizados, onde o animador especifica valores para criar qualquer imagem da
face.
A técnica de quadros-chave tem melhor resultados para animações em duas
dimensões, utilizada geralmente em desenhos (cartoons) (MAGNENAT-THALMANN et al.,
1988). Parke (1972) pôde verificar a falta de eficiência desta técnica em modelos 3D,
devido à grande quantidade de quadros que deveriam ser gerados. Porém, a partir do
trabalho inicial de Parke, outros pesquisadores iniciaram estudos com o intuito de superar
as limitações dos trabalhos anteriores (COSTA; CLUA, 2007).
Platt e Badler (1981) criaram um modelo baseado em estrutura de pontos,
espalhados pela pele da face. Waters (1987) desenvolveu um modelo para criar animação
realista de expressões faciais, baseado na musculatura facial. Magnenat-Thalmann et al.
(1988) criaram um modelo para sincronização da fala e expressões, baseando-se na ação
dos pseudo-músculos da face (regiões visivelmente influenciadas pelos músculos).
Outros modelos para animação de expressões faciais e sincronização da fala
foram criados posteriormente, sempre melhorando os modelos anteriores, (WATERS, 1987)
(HILL et al., 1988), (LUCERO; MUNHALL, 1999). A seguir são apresentadas as principais
técnicas de animação facial, agrupadas conforme Chung (2009), em manipulações geométricas e dirigida por desempenho.
3.3.1
Manipulação Geométrica
Chung (2009) conceitua interpolação como um processo, onde valores são de-
finidos para produzir uma transição entre “vizinhos”. Esta técnica é frequentemente
utilizada na animação facial para especificar transições suaves entre expressões faciais
diferentes em um intervalo de tempo.
A interpolação de poses (blend shapes) utiliza quadros-chave, criando poses
intermediárias entre estes. Assim, é possível definir as modificações na face entre as poseschave, formando uma animação (COSTA; CLUA, 2007). Conforme Martino (2005), esta
técnica pode ser utilizada em mais de duas poses-chave simultaneamente, porém isso a
26
torna menos intuitiva, considerando que um ponto forte da interpolação é a simplicidade.
Conforme Deng e Noh (2007), quando existem 4 quadros-chave, é possível a
utilização de interpolação bilinear, para criar uma grande variedade de expressões faciais.
A interpolação pode ser geométrica, atualizando diretamente a posição dos vértices da
malha facial, ou paramétrica, utilizando funções que movem indiretamente os vértices.
Na Figura 3.6 é possível visualizar (na imagem do centro) um exemplo de interpolação
de formas, entre uma forma neutra (imagem à esquerda) e uma forma com a boca bem
aberta (imagem à direita).
Figura 3.6: Interpolação das poses A e B, gerando A+B
Fonte: Adaptada de (DENG; NOH, 2007)
A parametrização geométrica utiliza valores, passados por parâmetro, para
controlar os movimentos da face, por meio de transformações geométricas na face virtual
(COSTA; CLUA, 2007). Deng e Noh (2007) afirmam que algumas restrições da interpolação
podem ser superadas com o uso de parametrização. Quando bem implementada, permite
ao usuário especificar qualquer expressão facial, alterando o valor dos parâmetros, com
pouco custo computacional.
Conforme Martino (2005), a parametrização geométrica permite manipular
a face, por mecanismos geométricos, sem considerar os mecanismos biomecânicos e fisiológicos. Cada conjunto de parâmetros é responsável por realizar uma determinada
movimentação da face virtual. É possível utilizar esta técnica para controlar movimentos
específicos, movimentos articulatórios mais complexos e inclusive expressões de emoções.
Deng e Noh (2007) definem o padrão ISO MPEG-4 como um modelo bem
conceituado de parametrização geométrica. Este é um padrão baseado em objetos para
compressão de multimídia, que trata tanto de áudio e vídeo capturados no mundo real,
27
quanto animações virtuais.
No MPEG-4, a face é definida por 84 pontos característicos (Feature Point FP), representados na Figura 3.7. Possui parâmetros de definição da face (Face Definition
Parameters - FDP), responsáveis por definir a geometria da face. Possui também 68
parâmetros de animação da face (Facial Animation Parameters - FAP), responsáveis pela
movimentação de pontos ao longo do tempo, que definem a rotação da cabeça, posição
da mandíbula, etc. (PARENT, 2001).
Figura 3.7: Pontos característicos do MPEG-4
Fonte: Adaptada de (PARENT, 2001)
Os FAPs são categorizados em grupos. A maior parte pertence ao grupo de
baixo nível, sendo utilizados somente para definir o quanto um FP deve deslocar-se em
uma direção. Os demais parâmetros são de alto nível, responsáveis por expressões faciais
e visemas. Os grupos e as respectivas quantidades de FAPs estão representados na tabela
3.1.
Deng e Noh (2007) acrescentam que a limitação da parametrização está na
criação de movimentos, pois não há uma maneira prática de gerenciar os conflitos entre
parâmetros ou a mistura de expressões que utilizam os mesmos vértices. Portanto, os
28
Tabela 3.1: Grupos de FAPs
Grupo
Número de FAPs
Visemas e expressões
2
Lábios, queixo e mandíbula
26
Olhos (considerando também pupilas e pálpebras)
12
Sobrancelhas
8
Bochechas
4
Língua
5
Movimentos da cabeça
3
Nariz
4
Orelhas
4
Fonte: Adaptada de (DENG; NOH, 2007)
parâmetros devem ser modelados para afetar somente regiões faciais específicas, de forma
a não existir conflito.
A modelagem muscular baseada em física é dividida em duas categorias:
baseada em músculos, cujos parâmetros são os músculos e o tecido facial, buscando imitar
os músculos da face e as propriedades elásticas da pele humana; e baseada em pseudomúsculos, utilizando poucos parâmetros que deformam a malha do modelo, imitando a
ação muscular, considerando as restrições biomecânicas da face (COSTA; CLUA, 2007).
Como exemplo de modelagem pseudo-muscular, pode-se citar o modelo proposto por Kalra et al. (1992), que utiliza a técnica FFD (Free Form Deformation). Esta
técnica define vértices de controle que deformam a face virtual. Tais vértices são definidos a partir de regiões superficiais da face, as quais são influenciadas pelos principais
músculos.
Existem também vários modelos propostos baseados em músculos. Pode-se
citar o modelo criado por Lee et al. (1995), que imita profundamente a fisiologia e características do tecido facial e possui grande complexidade computacional. Neste modelo,
limitações de movimento foram utilizados, para impedir expressões impossíveis na face
real. As camadas do tecido facial, desde o osso até a pele, são representadas por três
camadas distintas, interligadas e com a utilização de forças elásticas. Tal abordagem pos-
29
sibilita a criação de rugas e dobras na pele. Parâmetros extras também estão disponíveis,
como as características de elasticidade do tecido, e espessura das camadas.
3.3.2
Dirigida por desempenho
O princípio da animação facial dirigida por desempenho é capturar movimentos
detalhados da face gerando, por meio destes, novos movimentos de acordo com a vontade
do animador. O objetivo desta técnica é diminuir a dificuldade em criar expressões faciais
complexas, aumentar a realidade das animações e reduzir o tempo e trabalho necessários
ao criar manualmente a animação. Existem várias abordagens de animação dirigida por
desempenho, sendo que a maioria se baseia em marcadores colocados na face de um ator
real , os quais geram dados das posições dos pontos (em duas ou três dimensões) no
decorrer do tempo, para captura de movimento (motion capture) (CHUNG, 2009).
Animações dirigidas por desempenho facilitam a captura de expressões faciais
complexas, gerando animações com maior realidade e detalhe. Várias animações atualmente utilizam esta técnica, permitindo que um ator virtual possa expressar naturalmente
suas emoções, pois imitam as expressões de um ator real.
Ping e Abdullah (2013) classificam as animações dirigidas por desempenho de
acordo com a tecnologia utilizada, podendo se basear no uso (ou ausência) de marcadores.
Marcadores são dispositivos de entrada, cujos dados são capturados por câmeras de vídeo,
sendo utilizados para capturar o movimento de um ator e transfere estes movimentos para
formato digital.
Williams (1990) foi quem introduziu o uso de marcadores e câmeras de vídeo,
para capturar os movimentos da face, utilizando a textura de uma única imagem estática
de uma face real, e rastreamento da posição dos pontos somente em duas dimensões.
Outros modelos surgiram para incrementar a técnica de marcadores, como (KOUADIO et
al.,
1998), que criou um sistema para animar personagens em tempo real, a partir de
expressões faciais pré-modeladas associados com os marcadores.
Alguns sistemas mais complicados e caros de desenvolver, que capturam dados
emitidos por marcadores, também tem sido utilizados na indústria de animação. Tais
sistemas utilizam várias câmeras de vídeo, que reconstroem a posição (em três dimensões)
dos marcadores da face e do corpo, para utilizar estes dados na criação de animações por
30
Figura 3.8: Marcadores na face de Tom Hanks para captura de movimentos
Fonte: Adaptada de (BREDOW et al., 2005).
computador (DENG; NOH, 2007).
Um exemplo de um sistema que utiliza esta tecnologia de marcadores pode
ser observado na animação The Polar Express da Warner Bros. Os movimentos da face
foram capturados por câmeras que recebem os sinais emitidos por aproximadamente 151
marcadores, com 2,4 milímetros de diâmetro, colocados na face de Tom Hanks (conforme
Figura 3.8). Utilizando esta técnica, Tom Hanks pôde interpretar a expressão facial e os
movimentos corporais simultaneamente de vários personagens (BREDOW et al., 2005).
Outras abordagens também foram desenvolvidas, sem o uso de marcadores,
com o uso de visão computacional. Inicialmente, havia a necessidade da utilização de
pinturas na face, de forma a realçar contornos da boca, olhos ou criação de alguns pontos
(CHUNG, 2009). Kass et al. (1988) foram os pioneiros, utilizando o sistema “snakes”
(cobras), assim nomeado, por se basear em linhas deformáveis. Tais linhas são geradas
a partir do contorno dos atributos da face analisando, com o menor esforço possível, as
cores e bordas da imagem de um rosto.
Outros trabalhos foram desenvolvidos a partir do modelo de snakes. Thalmann
et al. (1993) utilizaram tal modelo, junto com técnicas de processamento de imagens, para
adquirir, analisar os movimentos da face humana, gerando uma animação em tempo real.
Já no modelo de (GUENTER et al., 1998), são geradas animações realistas a partir de
31
movimentos retirados de vídeos previamente gravados, considerando a geometria tridimensional, cor e sombras da expressão facial. Outras técnicas que evitam a necessidade
de marcas intencionais no rosto também foram desenvolvidas, como o modelo de fluxo
óptico de (HORN; SCHUNCK, 1981) e o modelo de medições da correlação normalizada
espaço-temporal de (DARRELL; PENTLAND, 1993).
Weise et al. (2011) também desenvolveram uma técnica para controlar personagens virtuais, em tempo real, a partir da captura por imagem de vídeo, adquiridas pelo
Kinect da Microsoft, capaz de capturar imagens coloridas em duas dimensões e também
mapear a profundidade em três dimensões. Desta forma, o modelo considera tanto a
geometria quanto a textura da face. O resultado pode ser visto na imagem 3.9.
Figura 3.9: Animação baseada em desempenho em tempo real
Fonte: Adaptada de (WEISE et al., 2011).
R em parceria com o Instituto de Tecnologia Criativa do
Em 2013 a Nvidea,
sul da Califórnia, criou o sistema nomeado Face Works. Neste sistema, um ser humano é
fotografado dentro de uma esfera gigante, com 6500 lampadas, a partir de 253 posições
distintas, gerando um objeto 3D com detalhes profundos de geometria, textura, pele, e
com expressões faciais, que também são capturadas, sem a necessidade de marcadores ou
maquiagem e câmeras especiais. Conforme demonstrado na figura 3.10, após renderizado,
o objeto pode ser utilizado para gerar animação hiper-realista em tempo real, simulando
movimentos, fala e expressões faciais (HUANG, 2013).
3.4 Representação Visual da Fala
32
Figura 3.10: Personagem renderizado em tempo real
Fonte: Adaptada de (HUANG, 2013).
3.4
Representação Visual da Fala
A fala, juntamente com as expressões faciais, formam os principais elementos
de comunicação do ser humano. Permite os seres humanos de compartilharem seus pensamentos e interagirem uns com os outros. A fala pode ser decomposta em fonemas, os
quais são sons distintos, reproduzidos pela voz, para compor as palavras. Cada idioma
possui fonemas próprios (RODRIGUES et al., 2003).
Um fenômeno que torna a sincronização labial mais complexa é a coarticulação. Este fenômeno estabelece que o movimento dos lábios depende, além do
fonema a ser pronunciado, do fonema anterior e posterior a este (PING; ABDULLAH, 2013).
Deng e Noh (2007) definem duas abordagens principais de animação visual da
fala: baseada em dados e baseada em visemas. A abordagem baseada em dados utiliza
movimentos gravados anteriormente, geralmente de um ator real, para gerar animações.
A partir de uma base de gravação, para gerar animação das falas de personagens, há tanto
sistemas treinados utilizando inteligência artificial, para aprender a sintetizar os dados em
falas, quanto sistemas que somente reorganizam e processam os dados.
Visemas são as unidades básicas visíveis da boca, correspondentes a fonemas.
Nem todos fonemas possuem um visema equivalente distinto, pois há sons diferentes, re-
33
Figura 3.11: Visemas da língua inglesa
Fonte: Adaptada de (PARKE, 1972).
produzidos pela voz, que correspondem à mesma posição labial (PARKE, 1972). Alguns
visemas da língua inglesa estão ilustrados na Figura 3.11. Na abordagem baseada em visemas, além de mapear os visemas, o animador necessita criar as funções de co-articulação,
para sintetizar corretamente as falas (DENG; NOH, 2007).
Osipa (2010) simplificou a utilização de visemas. A técnica utilizada, descrita
nos próximos parágrafos, simplifica a representação facial da fala em dois movimentos
básicos: A boca aberta/fechada (open/closed) e a boca larga/estreita (wide/narrow),
ilustrados na Figura 3.12. Com a combinação destes movimentos, é possível criar a
impressão visual da fala.
Alguns formatos específicos podem ser tratados pontualmente, como a pose
de reprodução da letra F, onde o lábio inferior encosta na arcada superior de dentes,
ou L, onde a língua encosta no céu da boca. Utilizando os dois movimentos básicos
há a impressão de reprodução da letra F. O movimento específico da letra F pode ser
substituído por um formato de boca meio fechada. Na reprodução da animação, é difícil
notar a falta de um formato mais específico para poses mais complexas, geralmente só
sendo reparado se o vídeo for pausado no momento exato da reprodução do fonema.
34
Figura 3.12: Movimentos básicos da boca
Fonte: Adaptada de (OSIPA, 2010).
Alguns visemas são definidos, utilizando-se a técnica dos dois movimentos
básicos. Os visemas que estão representados na tabela 3.2, que foi desenvolvida utilizando
como base o estudo realizado por Osipa (2010), podem representar tanto formas absolutas
quanto relativas.
Tabela 3.2: Visemas e respectivas representações visuais
Fonte: Adaptada de (OSIPA, 2010)
Quando absolutas, tratam dos movimentos que se repetem sempre que um
mesmo visema é utilizado, como o caso de “B”, representado pelo fechamento da boca.
Quando relativas, se baseiam em outras formas em torno do visema, apenas alterando a
direção (intensidade) de abertura ou largura da boca, como o caso de "R, T e S".
3.5 Direcionamento do Olhar
3.5
35
Direcionamento do Olhar
A comunicação não verbal auxilia no entendimento da mensagem que um dis-
curso deseja transmitir, utilizando sinais como o tom de voz, gesticulação, direção do
olhar e expressões faciais. O direcionamento do olhar (eye gaze) tem papel importante
em uma conversação. Durante um tempo considerável em uma conversa, a atenção dos
olhares está voltada para a pessoa a quem se escuta ou a quem se direciona o discurso.
Os ouvintes tendem a olhar para quem está falando por maior tempo, levando em conta
o tempo que um orador olha para seus ouvintes (VERTEGAAL et al., 2001).
A direção de um olhar é determinada tanto pela orientação da face, quanto
pela orientação do olho. A face irá determinar uma posição global da direção do olhar,
enquanto o olho determina a direção local. Desta forma, se um objeto de interesse não
está no campo da visão de uma pessoa, ela deve virar o pescoço, para que seja capaz de
enxergar este objeto (ZHU; JI, 2004).
Conforme Kendon (1967), o direcionamento do olhar auxilia na concentração
da conversa, tendo o intuito de limitar a quantidade de informações recebidas pela visão.
Tem também papéis importantes na comunicação de emoções, regulagem do fluxo da
conversa e resposta (feedback) à outra pessoa. Há também a tendência de desviar o olhar
de uma pessoa quando inicia-se um diálogo com ela, para concentrar-se no que será falado.
Porém, quando o fim de uma fala está sendo alcançado, existe também a tendência de
olhar com mais frequência para o ouvinte, informando-o que está cessando a fala e que
ainda tem sua atenção.
Argyle (1976) estimou que, em uma conversa, existe troca de olhares durante
aproximadamente 60% do tempo, variando de acordo com o papel da pessoa (ouvinte, ou
orador), e de acordo com diferenças culturais e individuais, como a inibição, por exemplo.
Se a pessoa está falando, aproximadamente 41% do tempo será utilizando olhando para
outra pessoa e, quando ouvindo, 75% do tempo é utilizado.
Outras estimativas também foram realizadas por Argyle e Dean (1965). Existe
maior troca de olhares quando a conversa trata de assuntos não pessoais. Mulheres
utilizam mais contato com os olhos que os homens. Existe maior troca de olhares entre
pessoas que se gostam ou estão cooperando entre si, enquanto há menor troca se estas
pessoas estão competindo, ou caso haja tensão entre elas. A direção de um olhar, conforme
3.6 Piscar de olhos
36
Zhu e Ji (2004), também serve para indicar o interesse de uma pessoa, em um objeto ou
em outra pessoa.
3.6
Piscar de olhos
O piscar dos olhos é caracterizado pelo rápido fechamento e abertura das pál-
pebras (TRUTOIU et al., 2011). Bacher e Smotherman (2004) distinguiram o piscar de
olhos de acordo com sua duração, contexto e amplitude, categorizando-o em três tipos:
espontâneo, quando se trata de um movimento involuntário (como o piscar automático do
olho para hidratação); reflexivo, quando é causado por um impulso repentino (geralmente
como forma de defesa do organismo em resposta a detecção de algum perigo ao olho) e
voluntário, quando há a intenção de piscar o olho.
O piscar de olhos é composto tanto pelo abaixar das pálpebras superiores,
quanto da elevação das pálpebras inferiores, porém em proporções diferentes. As pálpebras superiores devem se mover quase inteiramente para baixo, enquanto as inferiores
elevam-se muito pouco (OSIPA, 2010).
O comportamento de um piscar, conforme Trutoiu et al. (2011), é assimétrico
durante o tempo. O primeiro momento, onde a pálpebra superior é abaixada (e a inferior
é levemente elevada), é curto e possui rápida aceleração e velocidade. Já o segundo
momento, onde os olhos são abertos pela elevação da pálpebra superior, tem maior duração
e desacelera lentamente.
Outras estimativas foram feitas a partir do comportamento do piscar de olhos.
Conforme Osipa (2010), o piscar dos olhos é utilizado também para informar, em um
diálogo, que uma sentença chegou ao fim e o orador está passando a vez para o ouvinte
falar. Também é utilizado durante transições entre expressões faciais diferentes. Uma
piscada demorada se encaixa bem à um grande exalar, dando a impressão de alívio.
Caffier et al. (2003) ainda associam a piscada longa, à presença de sonolência, assim como
o aumento da frequência do piscar de olhos.
Conforme Trutoiu et al. (2011), tanto a frequência, quanto a duração do piscar
estão associadas com estados emocionais, podendo inclusive demonstrar se uma pessoa
está, ou não, contando a verdade, ou mascarando emoções verdadeiras. Pessoas têm a
tendência de diminuir a frequência de piscar de olhos enquanto mentem, aumentando-a
3.7 Representação Facial de Emoções
37
após o término da mentira (LEAL; VRIJ, 2008).
Osipa (2010) utiliza 5 posições básicas das pálpebras, para representar o piscar
de olhos: fechadas, pálpebra superior para cima, pálpebra inferior para cima, pálpebra
superior para baixo e pálpebra inferior para baixo. Estas posições podem ser vistas, em
respectiva ordem, na Figura 3.13.
Figura 3.13: Posições básicas das pálpebras
Fonte: Adaptada de (OSIPA, 2010).
Trutoiu et al. (2011) afirmam que um piscar de olhos, quando representado
em uma animação de computador de 30 quadros por segundo, deve ter a duração de 7 a
13 quadros. Conforme (TAKASHIMA et al., 2008) a frequência do piscar de olhos, para dar
sensação de realismo, em um estado neutro de emoção, deve ser de aproximadamente 18
vezes por minuto, com intervalos não constantes. Durante ansiedade, stress, raiva, tensão
ou exaltação, a frequência de piscar é aumentada, enquanto em situações de atenção e
tranquilidade, a frequência diminui.
3.7
Representação Facial de Emoções
Psicólogos e neurologistas definem a emoção como uma série de mudanças
adaptativas em vários sistemas fisiológicos, em resposta a um estímulo (ADOLPHS, 2002).
Ekman (2007) acrescenta que as emoções determinam a qualidade de vida de um ser
humano. Emoções estão presentes em todos os relacionamentos vivenciados, alterando a
maneira de agir em cada situação. Para cada estímulo, existe uma emoção que apresenta
características únicas na fisionomia.
A emoção e as mudanças corporais decorrentes destas, são induzidas por ter-
38
minais de células nervosas, as quais são controladas por um sistema cerebral dedicado.
O sistema responde a estímulos de pensamentos, a respeito de uma entidade ou evento.
Desta forma, emoções combinam processos psicológicos e fisiológicos (DAMASIO, 1994).
Humanos utilizam fortemente expressões faciais para demonstrar o seu estado
emocional (POLLAK; SINHA, 2002). A natureza de uma expressão facial pode ser tanto uma
resposta à uma emoção sentida, quanto comunicação social. Na maior parte das situações,
estas naturezas ocorrem simultaneamente, em diferente intensidades, para formar uma
expressão facial (ADOLPHS, 2002).
3.7.1
Fisiologia das Emoções
“Quando nos encontramos no domínio de uma emoção, uma cascata de
mudanças ocorre em frações de segundos, sem a nossa escolha ou consciência
imediata: Os sinais emocionais no rosto e voz; as ações pré-definidas; ações
aprendidas; a atividade do sistema nervoso autônomo que regula nosso corpo;
os padrões regulatórios que continuamente modificam nosso comportamento;
a recuperação de memórias relevantes e expectativas e a maneira que interpretamos o que está acontecendo dentro de nós e no mundo.” traduzido de
(EKMAN, 2007)
Vários níveis do cérebro são atingidos pela organização neural das emoções
humanas. Nestes níveis existem aplicações para experiência e expressão de emoção, assim
como motivação efetiva de comportamento (TUCKER et al., 2000).
Os músculos faciais são controlados por dois sistemas distintos do cérebro. As
expressões voluntárias são controladas pelo sistema cortical, enquanto o sistema subcortical é responsável palas expressões que são geradas por emoções que estão sendo sentidas.
(RINN, 1984). Conforme Tucker et al. (2000), no sistema subcortical, subsistemas neurofisiológicos especializados controlam o processamento motor, autônomo e sensorial. Tais
subsistemas são coordenados pelas seguintes estruturas de maior nível que produzem estados emocionais:
• Subsistemas componentes do tronco encefálico: o tronco encefálico, ilustrado
na Figura 3.14, contém grupo de células que controlam alguns comportamentos
39
específicos. Dentro deles, podem-se citar expressões faciais, movimentos dos olhos
e locomoção e regulagem dos reflexos autônomos;
• Mecanismos integrantes do tronco encefálico: tais mecanismos possuem colunas de células responsáveis por comportamentos motivacionais específicos. Pode-se
citar o comportamento defensivo, que aumenta a frequência cardíaca e o fluxo sanguíneo para o rosto e membros, e diminui o sentimento de dor. Também há o
comportamento em resposta à dor profunda, que diminui a atividade motora, a
frequência cardíaca, a pressão sanguínea, e o sentimento de dor;
• Influências integrantes límbicas: o sistema límbico, ilustrado na Figura 3.14, é
responsável por providenciar controle de alto nível sobre o tronco encefálico. Tendências agressivas são reprimidas por esse sistema, auxiliando o comportamento
social, confiança e afeição. Também regulam o medo, quando há proximidade de
ameaça física e urgente, como a aproximação inesperada de um predador com pouco
tempo para reagir;
• Funções antecipatórias límbicas: baseando-se nas propriedades contextuais do
ambiente, tais funções são responsáveis por prover informação contextual ao cérebro,
antes deste enviar sinais para outros membros. Desta forma, não serão levados em
consideração somente objetos isolados para reagir a um estímulo.
Figura 3.14: Partes do cérebro
Fonte: Adaptada de (FISIOBLOG, 2012)
40
A hipótese de Marcadores Somáticos foi criada por Damasio (1994), onde o
termo marcador somático foi escolhido por se referenciar a uma sensação corporal (“soma”
significa corpo em grego) que “marca” uma imagem ou pressentimento. Os marcadores
somáticos têm o papel de auxiliar automaticamente na tomada de decisão, funcionando
como uma intuição e dando destaques positivos ou negativos à algumas opções, antes
mesmo que estas sejam raciocinadas (SCHNEIDER, 2004).
Damasio (1994) afirma que os marcadores somáticos, quando negativos, são
responsáveis por alertar possíveis resultados negativos de uma ação, induzindo o indivíduo a rejeitar certas escolhas e procurar outras alternativas, antes mesmo de analisar
as premissas. Quando positivos, os marcadores somáticos incentivam uma determinada
escolha.
As emoções básicas, disparadas por determinados estímulos, são a base de
aprendizado dos marcadores somáticos. Durante o processos de socialização e educação,
situações são associadas a sensações desagradáveis e agradáveis. Quando é necessário
fazer uma nova escolha, as emoções vividas são acessadas pela mente, influenciando na
decisão de acordo com a emoção sentida. Durante o decorrer da vida, escolhas que levem
a emoções negativas ou positivas, continuarão criando novas assimilações para o sistema
de marcadores somáticos.
A parte do cérebro responsável pela assimilação dos marcadores somáticos é o
córtex pré-frontal, ilustrado na Figura 3.14. Esta parte categoriza as reações do organismo
perante as situações vividas; recebe sinais de sensores responsáveis por formar imagens de
pensamentos e sinais de vários setores regulatórios do cérebro (responsáveis pela liberação
de hormônios); e está conectada diretamente à resposta química e motora do cérebro.
3.7.2
Facial Action Coding System
Em 1978, juntamente com sua equipe, Paul Ekman desenvolveu o sistema de
codificação da ação facial (Facial Action Coding System - FACS ). Tal sistema foi desenvolvido com o intuito de medir os movimentos musculares de cada expressão e detectar micro
expressões, com durações menores que um quinto de segundo. Utilizando este sistema,
Ekman pode distinguir mais de 55 mil expressões faciais (TERZOPOULOS; WATERS, 1990).
Os estímulos emocionais também puderam ser detalhadamente estudados, com melhorias
na análise das características de emoções exibidas nas expressões faciais (EKMAN, 2007).
41
Figura 3.15: Unidades de ação
Fonte: Adaptada de (EKMAN et al., 2002)
O objetivo principal de Ekman et al. (2002) era desenvolver um sistema compreensível que fosse capaz de distinguir todos movimentos faciais visíveis, resultantes da
ação muscular. Portanto, FACS lida somente com movimentos visíveis da face, não considerando mudanças invisíveis, de difícil distinção ou de movimentos involuntários. Seu
objetivo é descrever o movimento, sem interpretar seu significado (PARKE; WATERS, 2008).
Utilizando o conceito de que cada movimento facial é resultado da contração
de um ou mais músculos na face, a abordagem para o desenvolvimento do sistema foi
analisar anatomicamente as ações mínimas necessárias de cada movimento facial distinto
(EKMAN et al., 2002). Tais ações mínimas foram nomeadas de unidades de ação (Action
Units - AU ) e servem como base do sistema desenvolvido por Ekman. As unidades de
ação, combinadas ou não, são capazes de representar todas expressões faciais possíveis,
com respectivas intensidade, simetria e duração (OLIVEIRA, 2008).
Conforme Oliveira (2008), inicialmente FACS foi concebido com 44 unidades
de ação (representadas na tabela 3.3), divididas entre parte superior (sobrancelha, testa,
olhos, pálpebras) e inferior (boca, nariz, bochechas, queixo). Além destas, foram considerados outros movimentos, como mastigar, engolir, posicionamento da cabeça e olhos, etc.
(EKMAN et al., 2002). Alguns exemplos de representação facial das AUs são apresentados
na Figura 3.15.
As unidades de ação podem também variar em intensidade, definidas pelas
42
Tabela 3.3: Unidades de Ação (Action Units - AU )
AU Descrição
AU Descrição
1
Levantar interior da sobrancelha
23
Enrugar lábios
2
Levantar exterior da sobrancelha
24
Pressionar lábios
3
Apertar mandíbula
25
Separar lábios
4
Abaixar sobrancelha
26
Deixar cair o queixo
5
Levantar a pálpebra superior
27
Esticar a boca
6
Levantar a bochecha
28
Sugar os lábios
7
Apertar as pálpebras
29
Projetar mandíbula para frente
8
Direcionar um lábio ao outro
30
Projetar mandíbula na lateral
9
Enrugar o nariz
31
Projetar mandíbula para cima
10
Levantar o lábio superior
32
Morder o lábio
11
Afundar sulco labial
33
Inflar a bochecha com lábios abertos
12
Puxar canto dos lábios
34
Inflar a bochecha com lábios fechados
13
Arredondar a bochecha
35
Sugar a bochecha
14
Relaxar a Bochecha
36
Deixar a língua protuberante
15
Baixar canto dos
37
Esfregar os lábios
16
Baixar lábio inferior
38
Dilatar Narinas
17
Levantar o queixo
39
Comprimir narinas
18
Projetar lábios em forma de disco
40
Farejar com o nariz
19
Projetar língua para fora
41
Relaxar pálpebras
20
Esticar lábios
42
Juntar sobrancelhas
21
Enrijecer o pescoço
43
Fechar os olhos
22
Afunilar os lábios
44
Olhar vesgo
Fonte: Adaptada de (EKMAN et al., 2002)
43
letras do alfabeto A, B, C, D, E, representando respectivamente os níveis da intensidade:
somente traços; leve; acentuada; severa; extrema e máxima. Também podem ser combinadas, formando expressões faciais, que podem ser utilizadas para demonstrar emoções.
Para melhor estudo das expressões faciais, é realizado o processo de pontuação
(scoring) FACS. Tal processo é realizado tanto em imagens estáticas quanto em movimento, com intuito de medir a ação facial. A partir da medição é possível, por exemplo,
aprender todos os sinais faciais das emoções, quando verdadeiras ou falsas; verificar marcadores faciais que dão ênfase ao discurso; verificar as características visíveis da mentira
na face; etc.
FACS, apesar de não ter sido desenvolvido especificadamente para utilização
em animação por computador, tem auxiliado animadores em diversos sistemas, ao interpretarem e construírem expressões faciais realistas. Também pode ser utilizada na
modelagem, especificando os controles das possíveis ações da face virtual (PARKE; WATERS,
2008).
3.7.3
Emoções Básicas
A origem das emoções é tratada por duas principais perspectivas. Uma afirma
que as emoções são produto de seleção natural, tendo uma base biológica. Outra afirma
que emoções são aprendidas construídas socialmente, variando pelas diferentes culturas.
Ambas as perspectivas possuem evidências, e vários estudiosos acreditam que ambas estão
corretas. As emoções que tem base biológica são nomeadas como “básicas” por vários
autores (PRINZ, 2004).
Darwin (1872) foi um dos primeiros pesquisadores a afirmar que expressões
faciais de emoção partem de uma base biológica. Existem várias teorias a respeito de
emoções e suas formas de expressão na literatura, que afirmam que o ser humano é
provido de emoções básicas, não dependendo do aprendizado de como demonstrar estas
emoções por meio de observação ou outras maneiras. A seguir são citadas algumas dessas
teorias.
No núcleo biológico do sistema de emoção humano existem módulos de emoções
herdados, os quais são chamados por McDougall (1921) de instintos. Sua teoria afirma que
cada módulo de emoção básica é um programa de reação, que responde a uma informação
44
sensorial recebida. Quando um módulo é ativado psicologicamente, o corpo e a mente
disparam impulsos que seguem um padrão de comportamento, de forma que tais impulsos
é que fazem sentir e expressar emoções. McDougall propôs inicialmente as seguintes
emoções básicas: raiva, desgosto, exaltação, medo, fraqueza e admiração.
Arnold (1960) descreve emoção como uma tendência intuitivamente sentida a
partir de um estímulo ou impulso. Algumas emoções não são aprendidas, pois pertencem
à herança humana. Da mesma forma que uma pessoa nasce com a habilidade de ver
e sentir dor, também nasce com a capacidade de sentir e expressar emoções, como o
medo que é uma resposta automática a um estímulo negativo. As expressões emocionais
representadas na face geralmente são nativas e reconhecidas de forma intuitiva.
Ekman (2007) publicou em seu livro os resultados de um estudo, iniciado
em 1965, a respeito de demonstrações de expressões faciais em diferentes nações: Chile,
Argentina, Brasil, Japão, Estados Unidos e uma tribo isolada da Papua-Nova Guine.
Com este estudo, Ekman foi capaz de concluir que existem algumas expressões faciais que
são universais e biológicas, as quais ele chama de emoções básicas. Além destas, Ekman
confirma também a existência de expressões culturalmente variáveis, que são aprendidas
a partir de observação.
Para provar a existência de expressões faciais universais, alguns estudos com
pessoas cegas de nascença foram desenvolvidos. Tais estudos tiveram o intuito de demonstrar que as expressões básicas pertencem à biologia do ser humano, não sendo adquiridas
por observação.
Matsumoto e Willingham (2009) fotografaram a reação de atletas cegos de
nascença, ao receberem os resultados e medalhas nas paraolimpíadas de Atenas em 2004.
Maury-Rouan et al. (2005) realizaram um estudo em crianças cegas de nascença, observando a elevação das sobrancelhas enquanto discursavam ou enquanto demonstravam o
sentimento de surpresa. Galati et al. (2003) também realizaram estudo com crianças nascidas cegas, comparando suas expressões faciais de emoção com crianças que enxergavam.
O resultado obtido nos estudos dos autores citados foi: algumas expressões
faciais espontâneas em pessoas cegas de nascença, são as mesmas exibidas em pessoas que
enxergam normalmente, reforçando a existência de universalidade em expressões emocionais.
Paul Ekman (1992) utilizou nove características como critérios para distinguir
45
as emoções básicas:
1. Sinais universais distintos: expressões faciais são essenciais para distinguir as
emoções. Devem existir limites bem definidos entre diferentes emoções, resultando
em distinção quando tais emoções são exibidas por meio de expressões faciais;
2. Presença em outros primatas: conforme alguns estudos realizados, existem evidencias de similaridade nas expressões faciais de outros primatas para emoções de
medo, raiva, tristeza e felicidade, provando que a biologia tem papel essencial nestas
emoções (CHEVALIER-SKOLNIKOFF, 1973);
3. Fisiologia distintiva: existem padrões distintos de atividades do sistema nervoso
autônomo (ANS) para diferentes emoções, como raiva, medo, desgosto e tristeza
(LEVENSON et al., 1990);
4. Eventos universais antecedentes: elementos similares são encontrados em contextos onde cada emoção distinta ocorre. Como exemplo pode-se citar o medo que é
característico em contextos onde perigo de se ferir ou risco de morte são encontrados,
ou a tristeza no contexto da perda de um ente querido;
5. Coerência entre a resposta emocional: existem coerência e relações sistemáticas entre a resposta emocional e as expressões faciais para as diferentes emoções
básicas;
6. Breve início: emoções podem ocorrer antes que a pessoa esteja consciente que estas
aconteceram, assim como as expressões faciais podem começar em milissegundos
após um estímulo emocional;
7. Duração curta: a resposta de um estímulo emocional dura alguns segundos, ao
menos que este estímulo seja realizado novamente, estendendo a duração de uma
emoção. Deve-se, neste caso, distinguir emoção (estado, com curta duração) de
humor e personalidade, que possuem maior duração.
8. Avaliação automática: um mecanismo de avaliação automática deve existir para
decidir qual emoção será disparada a partir de um estímulo. Tal sistema de avaliação
deve acontecer com grande velocidade, considerando o curto intervalo entre um
estímulo e sua resposta emocional;
46
9. Ocorrência espontânea: uma pessoa não pode escolher qual emoção sentir, pois
as emoções são respostas automáticas e involuntárias a determinados estímulos.
As emoções básicas definias por Ekman (2007) são sete: tristeza, raiva, surpresa, medo, nojo, desprezo e felicidade. Cada emoção básica é uma família de emoções.
Pode-se utilizar como exemplo a raiva, que varia em intensidade (de um incômodo até
ódio) e tipo (irritante, ressentida, fria ou indigna).
Para o propósito deste trabalho, acredita-se que a teoria de emoções básicas é
adequada aos objetivos do projeto D.R.A.M.A. Utilizando o sistema FACS, que automatiza o processo de expressão facial, é possível mapear as emoções em comportamentos, por
intermédio de uma função. A partir das expressões faciais de emoções básicas, outras expressões podem ser facilmente originadas sem muitas modificações. Nos próximos tópicos,
são abordadas as características, demonstradas pela expressão facial, das emoções básicas
definias por Ekman (2007): tristeza, raiva, surpresa, medo, nojo, desprezo e felicidade.
Tristeza
A tristeza é uma emoção negativa, estimulada por perdas, fracassos, decepções e separações. Pode variar em intensidade, desde nostalgia e desencorajamento, até
desespero (SANTOS, 2009).
Geralmente, a tristeza motiva o ser humano a buscar ajuda e dividir o sentimento com os outros, procurando voltar ao estado anterior ao sentimento de tristeza
(SILVEIRA; MELO, 2010). Na fisiologia humana, a tristeza resulta em sentir o corpo e
coração pesados, também dando sensação de vazio e cansaço físico ou mental (QUEIROS,
1997).
As características visuais da face, ilustradas na Figura 3.16, geradas pela tristeza são:
47
Figura 3.16: Expressão facial da tristeza
Fonte: Adaptada de (KUMAR, 2009)
• Boca aberta quando tristeza é intensa (EKMAN, 2007) ou fechada quando é menos
intensa (SANTOS, 2009);
• Narinas contraídas com movimento descendente (SANTOS, 2009);
• Pálpebras superiores decaídas (SILVEIRA; MELO, 2010) e inferiores contraídas, com
olhar desfocado ou para baixo (EKMAN, 2009);
• Sobrancelhas decaídas e juntas (SANTOS, 2009);
• Lábios arqueados com cantos externos curvados para baixo (PIMENTEL et al., 2008).
Raiva
A raiva é uma emoção conflituosa, estimulada por comportamentos agressivos,
que acontecem na convivência social (SANTOS, 2009). Conforme Zimprich e Mascherek
(2012), a raiva possui diversas causas como: crenças diferentes, rejeição amorosa, agressão
física ou psicológica, etc. Possui um papel adaptativo, capacitando ao indivíduo a enfrentar perigos e desafios, podendo também conduzi-lo à agressão física ou verbal (QUEIROS,
1997).
A intensidade da raiva pode passar por vários estágios: aborrecimento, frustração, fúria, ódio, ameaça de perigo (EKMAN, 2007). Na fisiologia humana, a raiva resulta
48
no aumento da pressão sanguínea, vermelhidão da face, aumento dos batimentos cardíacos
e aumento da frequência de respiração (LARKIN; ZAYFERT, 2004).
As características visuais da face, ilustradas na Figura 3.17, geradas pela raiva
são:
Figura 3.17: Expressão facial da raiva
• Lábios inferiores e superiores pressionados com força um contra o outro (MARSH et
al.,
2005);
• Músculos da mandíbula enrijecidos ou mandíbula deslocada para frente (MCKAY et
al.,
2003);
• Partes internas das sobrancelhas apontando para baixo (em direção ao nariz) e
sobrancelhas juntas (SADR et al., 2003);
• Olhos com abertura estreita e pálpebras superiores empurrando as sobrancelhas
abaixadas (MATSUMOTO, 1989).
Medo
O medo é uma emoção disparada por situações interpretadas pelo cérebro
como ameaçadoras ou perigosas. Na fisiologia humana, o medo resulta no tremer do
corpo, aumento dos batimentos cardíacos e da frequência de respiração e rosto pálido,
podendo até causar desmaios (SILVEIRA; MELO, 2010).
49
Quando uma pessoa percebe perigo, o medo a faz reagir de diferentes formas:
congelar momentaneamente, esconder-se, fugir, ou enfrentar a ameaça. O medo pode ser
distinguido em três fatores: intensidade (nível de perigo da ameaça), tempo (próximo a
acontecer ou urgente) e reação (possibilidade de enfrentar a ameaça) (EKMAN, 2007).
As características visuais da face, ilustradas na Figura 3.18, geradas pelo medo
são:
Figura 3.18: Expressão facial de medo
• Olhos arregalados (MATSUMOTO, 1989);
• Sobrancelhas arqueadas, levantadas e juntas (SUSSKIND et al., 2008);
• Pálpebras superiores extremamente levantadas e inferiores tensas (MATSUMOTO,
1989);
• Boca aberta, puxando os lábios horizontalmente para trás. (MARSH et al., 2005).
Surpresa
A surpresa é uma emoção caracterizada pela ocorrência de uma situação súbita
e inesperada (SANTOS, 2009). Esta emoção é rápida e intensa, tendo a menor duração
entre as outras emoções. O sentimento de surpresa leva pouco tempo para passar, podendo
desencadear outra emoção, assim que o cérebro processa o que aconteceu. (EKMAN, 2007).
50
Na fisiologia humana, a surpresa é responsável por limpar o sistema nervoso
e pausar momentaneamente os processos cognitivos, para o cérebro processar e reagir
adequadamente à situação inesperada (QUEIROS, 1997).
As características visuais da face, ilustradas na Figura 3.19, geradas pela surpresa são:
Figura 3.19: Expressão facial da surpresa
• Sobrancelhas levantadas (JOOSTEN et al., 2012);
• Olhos bem abertos (SILVEIRA; MELO, 2010);
• Pálpebras levantadas (PIMENTEL et al., 2008);
• Queixo elevado (SANTOS, 2009);
• Boca aberta, com mandíbula caída (SILVEIRA; MELO, 2010).
Aversão
Aversão é uma emoção relacionada a preferencias pessoais, disparada por situações repulsivas para o organismo, muitas vezes expressada como se o indivíduo fosse
vomitar (SILVEIRA; MELO, 2010). Está ligada ao nível físico, quando rejeita-se algo contaminado, ao nível psicológico, quando rejeita-se aquilo que é desagradável, ou ao nível
moral, quando há rejeição social (SANTOS, 2009).
51
Aversão está ligada experiências que não agradam o ser humano. Por exemplo,
o paladar ao ingerir um alimento que não agrada, um som estridente um cheiro desagradável, aparência ou ação de uma pessoa, ou até a lembrança de qualquer um destes eventos
(EKMAN, 2007).
As características visuais da face, ilustradas na Figura 3.20, geradas pela aversão são:
Figura 3.20: Expressão facial da aversão
• Sobrancelhas com a parte interna apontando para baixo (SUSSKIND et al., 2008);
• Nariz com as “asas” levantadas e enrugado (EKMAN, 2007);
• Bochechas levantadas (SUSSKIND et al., 2008);
• Olhar longe ou distante (EKMAN, 2009);
• Boca com o formato da letra “U” invertido, com o lábio superior levantado o quanto
possível e o inferior também levantado e um pouco saliente (EKMAN, 2007).
Desprezo
Desprezo é uma emoção disparada quando um indivíduo sente-se mais forte,
superior, civilizado ou inteligente que outros. Pode ser sentida tanto por se achar superior
a alguém, quando por aqueles em uma posição subordinada, que se sentem melhores que
52
o seu superior (SANTOS, 2009). Um indivíduo pode também sentir desprezo a si próprio,
como arrependimento de um ato (QUEIROS, 1997).
Desprezo ocorre quando há aversão à uma pessoa ou sua atitude e há o sentimento moral de superioridade. Sua expressão facial é semelhante à de aversão, sendo
geralmente exibida somente em um lado da face (EKMAN, 2007).
As características visuais da face, ilustradas na Figura 3.21, geradas pelo desprezo são:
Figura 3.21: Expressão facial de desprezo
• Parte interna das sobrancelhas apontando para baixo (EKMAN, 2007);
• Queixo elevado (SANTOS, 2009);
• Bochecha levemente levantada (somente de um lado) (EKMAN, 2007);
• Levantamento unilateral do lábio superior, juntamente com o lábio inferior (ROSENBERG et al.,
1998).
Felicidade
A felicidade é uma emoção relacionada à sentimentos agradáveis como superação, satisfação de necessidades, sucesso, realização de desejos e competência, etc. Sua
53
característica principal é o sorriso (SILVEIRA; MELO, 2010), e pode ser gerada por diversas situações, como recordações, sucesso, visualização de imagens agradáveis, ao sentir-se
amado, etc. (SANTOS, 2009).
Na fisiologia humana, a felicidade resulta no aumento do ritmo cardíaco, irregularidade da respiração e atividade muscular na face (QUEIROS, 1997). É gerada pela
liberação de substâncias químicas, como dopamina e noradrenalina, e pode até proteger o
sistema imunológico quando presente, ou afetar a saúde física, quando ausente (SANTOS,
2009).
As características visuais da face, ilustradas na Figura 3.22, geradas pela felicidade são:
Figura 3.22: Expressão facial da felicidade
• Músculos dos olhos contraídos, principalmente na parte inferior (SILVEIRA; MELO,
2010);
• Cantos dos olhos franzidos (EKMAN, 2007);
• Boca aberta, com cantos puxados para trás e cima (SILVEIRA; MELO, 2010);
• Bochechas empurradas para cima (SILVEIRA; MELO, 2010);
• Sobrancelhas levemente rebaixadas (SILVEIRA; MELO, 2010);
• Olhos com brilho e semicerrados, com pálpebras inferiores para cima (SANTOS,
2009);
54
• Franzir horizontal de todo o rosto (SANTOS, 2009).
3.7.4
Expressão Emocional Falsa
As expressões emocionais falsas são produzidas por movimentos voluntário da
face. Quando uma expressão é verdadeira, os músculos da face são controlados de maneira
involuntária, sem a intenção ou raciocínio desta movimentação. Já nas expressões falsas,
existe a intenção de gerenciar a expressão, no esforço de enganar ao demonstrar a emoção
que está sendo sentida (EKMAN, 2009).
A alegria é uma das emoções exibidas desonestamente com maior frequência.
Enquanto no sorriso verdadeiro toda a face demonstra a alegria, no sorriso simulado há
menor brilho nos olhos, assimetria facial, e geralmente ocorre somente a nível da boca
(QUEIROS, 1997).
Quando um sorriso falso é bem treinado, pode apresentar rugas em volta do
rosto e bochechas levantadas (sinais de sorriso genuíno). Porém, quando a expressão é
autêntica, a parte que cobre o olho (localizada entre a sobrancelha e a pálpebra) move-se
para baixo e as extremidades das sobrancelhas levemente afundam (PEASE; PEASE, 2009).
Lovas (2009) categoriza as faces desonestas por quatro elementos: olhos, sobrancelhas, lábios e simetria:
• Olhos: quando estão olhando para uma direção, diferente da qual a face está direcionada, indica que alguma informação está sendo retida;
• Sobrancelhas: se uma sobrancelha está mais alta que a outra, indica que o indivíduo está crítico, julgando algo, ou achando-se superior;
• Lábios: caso estejam fechados e bem pressionados, indica que a pessoa está escondendo algo;
• Simetria: quando há assimetria exagerada, faltando harmonia na expressão, indica
que não é uma expressão emocional verdadeira.
No estudo de Ekman (2009) sobre as micro-expressões, foi possível perceber
que, em algumas expressões falsas, há sinais de outras emoções verdadeiras, que são involuntariamente exibidas com rapidez (durante um quinquagésimo de segundo). Alguns
55
músculos faciais (nomeados confiáveis) dificilmente são controlados voluntariamente, facilitando a detecção de expressões emocionais falsas, pela ausência de movimentos nestes
músculos.
Outras pistas de emoções falsas, além das já citadas, são listadas por Ekman
(2009). O constante piscar de olhos; o lacrimejar; a dilatação das pupilas; erros no tempo
de resposta e duração ao demonstrar uma emoção; vermelhidão ou branquidão da face,
são características que auxiliam a detectar informações ocultas, a tentativa de esconder
algo ou, simplesmente, a falsidade da emoção.
3.7.5
Posicionamento da Cabeça
O posicionamento da cabeça tem grande importância, servindo como comple-
mento da expressão facial. Dependendo do movimento da cabeça e sua frequência, o
sentido da emoção pode ser modificado. Pode-se citar de exemplo o sorriso que, acompanhado do balançar da cabeça, não significa necessariamente felicidade (ZHAO, 2012).
Algumas emoções demonstram também maior intensidade com o movimento da cabeça,
como a tristeza, quando a cabeça é inclinada sobre o peito (SILVEIRA; MELO, 2010).
Pease e Pease (2009) definem algumas posições e movimentos básicos da cabeça:
• Aceno com a cabeça: além de tradicionalmente representar que concorda com
uma afirmação, acenos lentos da cabeça representam o interesse no que se está
ouvindo, enquanto acenos rápidos representam o desejo de que a conversa termine,
ou que seja passada a vez de falar;
• Cabeça virando de um lado para outro: demonstra negação ou discórdia com
algo que está sendo falado ou perguntado;
• Cabeça para cima: significa que a pessoa se sente neutra em relação ao assunto
da conversa ou, quando levantada bem alto com o queixo para frente, representa
superioridade ou arrogância;
• Inclinação da cabeça: inclinar a cabeça para um lado significa submissão, dando
o parecer de pescoço vulnerável;
3.8 Behavior Markup Language
56
• Cabeça para baixo: cabeça para baixo revela atitudes negativas, como discordância, avaliação crítica, rejeição, agressividade ou tristeza;
• Encolher da cabeça: geralmente acompanhado do erguer dos ombros, é utilizado
tanto para situações com receio e medo, como forma de proteger o pescoço a danos,
quanto em contexto pessoal o profissional é utilizado para parecer menor, como
pedido de desculpa ou transmitir a intenção de não ofender alguém.
3.8
Behavior Markup Language
Behavior Markup Language - BML é uma linguagem baseada na eXtensible
Markup Language - XML e criada por Kopp et al. (2006), que descreve o comportamento
humano verbal e não verbal, de forma independente do método de realização da animação
utilizado. Pode ser incorporada em um documento XML, com a iniciação e término de
um bloco <bml> </bml>. Neste bloco, serão preenchidos os comportamentos que deverão
ser realizados por um personagem (VILHJALMSSON et al., 2007).
Cada comportamento possui parâmetros (gerais ou específicos de um comportamento) que terão valores atribuídos. A maior parte dos parâmetros são opcionais, e
devem possuir valores padrões que serão utilizados, quando houver ausência no preenchimento destes. Um exemplo simples de um bloco com comportamentos pode ser visto na
Figura 3.23, onde os comportamentos head e face recebem valores para os parâmetros id,
type e amount (KOPP et al., 2006).
Figura 3.23: Exemplo de um bloco BML
Fonte: Adaptada de (KOPP et al., 2006).
A sincronização de comportamentos é feita por dois tipos de parâmetros temporais. O primeiro tipo é um identificador (id) único de cada comportamento. É utilizado
para que outros comportamentos possam referenciar tal comportamento, com o intuito de
executarem simultaneamente. O segundo tipo é composto por pontos de sincronização,
que alinha as fases da realização de um comportamento (KOPP et al., 2006). Por exemplo,
57
um aperto de mão possui as fases de estender o braço, apertar a mão, levantar e abaixar
o braço, soltar a mão, e retornar a mão para uma posição.
Cada comportamento específico é dividido em sete pontos de sincronização:
Start, Ready, Stroke-start, Stroke, Stroke-end, Relax (traduzidos para Início, Prontidão,
Início do Golpe, Golpe, Fim do Golpe, Relaxamento e Fim), representados na Figura
3.24. Um comportamento não necessita ter todas os pontos definidos, como o caso do
comportamento olhar, que necessita somente dos pontos Ready e Relax. Comportamentos
podem ser sincronizados, alinhando algum ponto de sincronização de um comportamento
com o ponto de outro (VILHJALMSSON et al., 2007). .
Figura 3.24: Pontos de sincronização
Um exemplo de bloco BML com sincronização de comportamentos, retirado
de Kopp et al. (2006), pode ser visto na Figura 3.25. Neste exemplo, dado um gesto
(gesture) com identificador “g1”, a cabeça (head) do personagem irá iniciar a execução
do seu ponto de sincronização Stroke, assim que o gesto realizar esta mesma função (pelo
comando stroke=“g1:stroke”). O olhar direcionado (gaze) terá início juntamente com
o ponto de sincronização Ready do gesto (pelo comando start=“g1:ready”), e término
com o ponto de sincronização Relax do gesto (pelo comando end=“g1:relax”).
Figura 3.25: Sincronização de gesto, movimento da cabeça e olhar direcionado
58
Dentro dos blocos BML, ações são coordenadas para os seguintes elementos:
fala, gesto, olhar direcionado, cabeça, corpo, torso, face, pernas e lábios (VILHJALMSSON et
al., 2007).
o olhar direcionado e os movimentos da cabeça foram separados para permitir ao
personagem que seus olhos apontem para uma direção diferente da cabeça, caso assim for
preciso. Assim como o torso foi separado do corpo, para que movimentos mais específicos
da espinha e ombros possam ser independentes da postura corporal. Cada elemento
contém atributos de aparência visual e dinâmica de movimento de um comportamento.
Na tabela 3.4, podem ser observadas as descrições dos elementos faciais, que tem relação
com este trabalho.
Tabela 3.4: Elementos de Comportamento BML
Elemento BML
Descrição
Cabeça
Movimentos da cabeça, independentes dos olhos. —————–
——–
Tipos: acenando, sacudindo, orientada a um ângulo determinado.
<head>
Face
—————
Movimentos dos músculos faciais para formação de expressões. —-
<face>
Tipos: sobrancelha, pálpebras, movimentos expressivos da boca.
Olhar direcionado
Movimento coordenado dos olhos, nariz e direção da cabeça, indi-
<gaze>
cando onde o personagem está olhando.
Discurso
—-
nunciadas.
<speech>
Lábios
<lips>
Comportamento verbal, recebendo palavras que devem ser pro-
———
Controle do formato dos lábios, incluindo a visualização de fonemas.
Fonte: Adaptada de (KOPP et al., 2006)
59
4 Modelo Proposto
O modelo proposto, conforme os requisitos do projeto D.R.A.M.A., se baseia
em quatro módulos principais, representados na Figura 4.1. O primeiro módulo (de
entrada) utiliza um arquivo em formato XML, com atributos e valores genéricos, que serão
recebidos pelo sistema, com a descrição em alto nível do que deve ser feito pela animação
facial.
Posteriormente, no módulo de tradução, são aplicadas regras, que utilizam
bases de dados de visemas e emoções, para adaptar o arquivo de entrada, ao tipo de
arquivo utilizado pelo módulo de saída. O módulo de saída é composto por um arquivo
em formato BML, com comandos de mais baixo nível de abstração, que serão recebidos
pelo módulo de animação.
O módulo de animação é composto por um plugin para um software de animação (como o Autodesk MayaTM ou Blender), responsável por ler o arquivo BML e interpretálo, gerando então, a animação facial. A animação facial será realizada em um modelo de
face, o qual utiliza a estrutura de esqueleto para realização de movimentos e expressões
faciais. A definição de tempo de início e fim das ações é sempre dada em milissegundos.
Figura 4.1: Módulos do modelo proposto
Fonte: do autor
4.1
Módulo de Entrada
O módulo de entrada descreve a linguagem utilizada pelo sistema para receber
comandos de outros módulos do projeto D.R.A.M.A.. É utilizado um arquivo XML, com
comandos de alto nível de abstração, com o intuito de simplificar a entrada, tirando a
4.1 Módulo de Entrada
60
necessidade de detalhes específicos da animação facial. O módulo é iniciado por um bloco
de cena, dividido em blocos de ADAs, os quais possuem blocos de ações, com tempo de
início e fim. Dentro de cada ação são definidos os comportamentos e seus respectivos
atributos. A taxonomia do módulo de entrada pode ser vista na Figura 4.2.
Figura 4.2: Taxonomia do módulo de entrada
Fonte: do autor
Comportamento: demonstrar emoção
O comportamento “demonstrar emoção” tem o objetivo de demonstrar uma
emoção específica, ou uma mistura de emoções. A partir das emoções básicas, com
combinações, pode-se chegar a demonstrações de várias outras emoções mais específicas.
Por isso, dentro do comportamento emoção, os atributos tipo, intensidade podem se
repetir, quando deseja-se mesclar emoções.
61
Tabela 4.1: Comportamento: demonstrar emoção
Atributos
Descrição
Tipo
Define a emoção que deseja-se representar, podendo ser qualquer uma das
emoções básicas (tristeza, raiva, medo, surpresa, aversão, desprezo e felicidade).
Intensidade
É um número, de 0.0 a 1.0, variando apenas na primeira casa decimal, representando a intensidade da expressão desta emoção.
Início / Fim
Define o momento de início e fim da expressão desta emoção, dentro do
período da ação. Pode ser tanto um tempo específico dentro da ação, ou
igualar ao início ou fim da ação. Quando não definidos, são atribuídos automaticamente o início e fim da ação. Caso o fim da emoção seja antes do
término da ação, retorna-se para o estado neutro de emoção.
Fonte: do autor
Comportamento: olhar
O comportamento “olhar” é responsável por direcionar a visão do personagem
para um objeto ou coordenada. Caso não esteja no seu campo de visão, há a necessidade de
acrescentar a movimentação da cabeça para que o objeto em questão possa ser visualizado.
Tabela 4.2: Comportamento: olhar
Atributos
Descrição
Alvo
Posição a qual destina-se o olhar, podendo ser tanto uma coordenada espacial, quanto um objeto.
Velocidade
Indica a velocidade com que o personagem irá movimentar seus olhos até o
alvo. Os valores atribuídos podem ser baixa, média ou alta velocidade.
Início / Fim
Define o momento de início e fim do olhar, dentro do período da ação. Pode
ser tanto um tempo específico dentro da ação, quanto o início e fim da ação.
Quando não definidos, são atribuídos automaticamente o início e fim da ação.
Caso o fim do olhar seja antes do término da ação, retorna-se para a posição
anterior do olhar.
Fonte: do autor
62
Comportamento: falar
O comportamento “falar” é responsável por reproduzir visivelmente os formatos da boca ao falar o texto desejado. A reprodução é feita por visemas, que serão
traduzidos a partir das palavras. A tradução automática de palavras em visemas é uma
tarefa complexa, que será realizada em um trabalho futuro.
Tabela 4.3: Comportamento: falar
Atributos
Descrição
Frase
Define a frase que o personagem deverá reproduzir visualmente
Velocidade
Indica a velocidade com que o personagem irá realizar a fala. Os valores
atribuídos podem ser baixa, média ou alta velocidade.
Início
Indica o momento de início da fala, dentro do período da ação. Pode ser
tanto um tempo específico dentro da ação, quanto o início desta. Quando
não definido, é atribuído automaticamente o início da ação.
Fonte: do autor
Comportamento: piscar
O comportamento “piscar” tem objetivo de escolher momentos específicos para
piscar os olhos do personagem. O piscar natural dos olhos é gerado automaticamente,
após definidos estes momentos específicos de piscar. Leva-se em consideração as emoções
da ação para definir os momentos de piscadas naturais.
Tabela 4.4: Comportamento: piscar
Atributos
Descrição
Velocidade
Indica a velocidade com que o personagem irá realizar o piscar de olhos. Os
valores atribuídos podem ser baixa, média ou alta velocidade.
Início
Define o momento do piscar de olhos, dentro do período da ação.
Fonte: do autor
4.2 Módulo de Tradução
63
Comportamento: mover a cabeça
O comportamento “mover a cabeça” é responsável por direcionar a cabeça para
pontos específicos, e realizar ações como inclinar e acenar a cabeça.
Tabela 4.5: Comportamento: mover a cabeça
Atributos
Descrição
Ação
Indica o tipo de movimento que a cabeça está realizando. As ações possíveis
são: acenar, inclinar e olhar (direcionar a cabeça à um ponto).
Alvo
É a posição a qual deseja-se direcionar a cabeça, quando a ação é olhar. A
posição pode ser tanto uma coordenada especial, quanto um objeto.
Orientação
Define a orientação da ação realizada, para as ações acenar e inclinar.
Quando a ação é acenar, pode assumir valor positivo, quando o aceno é
na vertical e negativo, quando o aceno é na horizontal. Quando a ação é
inclinar, o tipo indica para qual lado é a inclinação, podendo ser para cima,
baixo, esquerda e direita. O angulo de inclinação é em relação à cabeça na
posição padrão, sem nenhum tipo de rotação, e não em relação à rotação
atual desta. Ao final da ação, a cabeça volta à inclinação original.
Vezes
Quando a ação é acenar, define a quantidade de vezes que a cabeça irá
acenar.
Ângulo
Atributo que deve ser utilizado somente quando a ação for inclinar. Indica
o grau de inclinação da cabeça.
Velocidade
Indica a velocidade que a ação escolhida será executada. Os valores atribuídos podem ser baixa, média ou alta velocidade.
Fonte: do autor
4.2
Módulo de Tradução
O módulo de tradução é composto por procedimentos. Procedimentos são fun-
ções, utilizadas para traduzir a entrada de alto nível, do módulo de entrada em comandos
de animação de baixo nível do módulo de saída, em função dos comportamentos e atributos sugeridos por este trabalho. Para isso, além das regras, são utilizadas as bases de
dados de visemas e emoções. Para cada ação e comportamento, um rótulo (id) é definido,
para que seja possível referenciar atributos de uma ação ou comportamento específico.
64
A base de dados de visemas possui os visemas e suas respectivas características
de representação na boca. A base de dados de emoções possui, inicialmente, as emoções
básicas, suas características e frequência de piscadas por minuto. Nesta base podem ser
adicionadas, em trabalhos futuras, outras emoções mais específicas com suas respectivas
características.
Procedimento: traduzir emoção
Este procedimento é responsável por traduzir os atributos do comportamento
“demonstrar emoção” em atributos do comportamento “emotion” no módulo de saída.
Para isso, é utilizada a base de dados de emoções, que contém as características específicas
de cada emoção. Desta forma, além de traduzir o atributo “intensidade” para o atributo
“intensity” do módulo de saída, a emoção é decomposta em movimentos de componentes
da face, utilizados para demonstrar emoções.
Os componentes da face foram definidos baseando-se nos principais músculos
da face. Os músculos são utilizados para movimentar diferentes partes do rosto, a fim
de formar uma expressão facial. A partir do estudo realizado de emoções básicas, foi
possível definir as características destas emoções e os componentes do rosto utilizados
para demonstrar estas emoções. Desta maneira, os movimentos destes componentes são
resultado da atuação de músculos que coordenam as expressões faciais.
Os componentes utilizados são: pálpebra superior (UpEyelids); pálpebra inferior (downEyelids); sobrancelha interna (inBrow); sobrancelha externa (outBrow); nariz (nose); narinas (noseWings); mandíbula (jaw); lábio superior (upLip); lábio inferior
(downLip); lábio canto esquerdo (leftLip); lábio canto direito (rightLip); queixo (chin);
bochecha direita (rightCheek); e bochecha esquerda (leftCheek). Estes componentes podem assumir os valores cima (up); baixo (down); direita (right); e esquerda (left). A
mandíbula ainda pode assumir os valores de frente (front) e trás (back).
Pode-se citar o exemplo da emoção raiva. Considera-se a intensidade do movimento igual à intensidade da emoção. Os componentes traduzidos seriam: lábios inferiores
para baixo, lábios superiores para cima, mandíbula para frente, sobrancelhas internas para
baixo e para esquerda (o movimento para esquerda junta as sobrancelhas, enquanto para
direita as separa), pálpebras superiores para cima, pálpebras inferiores para cima. Caso
haja mais de uma emoção, a mistura de emoções é realizada pela própria ferramenta de
65
animação.
Procedimento: traduzir cabeca
Este procedimento traduz os atributos do comportamento “mover a cabeça” em
atributos do comportamento “head” no módulo de saída. O atributo “ação” é traduzido
para “action” e pode assumir os valores acenar, inclinar e olhar, traduzidas respectivamente para “shake”, “tilt”, “look”. O atributo velocidade, que indica a velocidade de
execução da ação escolhida, é traduzido para “speed”, podendo assumir os valores “low,
medium, high”.
Quando o valor do atributo “ação” é olhar, pode-se definir o atributo “alvo”,
traduzido para “at”, utilizado para apontar o direcionamento da cabeça. Este atributo
pode ser sobrescrito, conforme descrito no procedimento traduzir olhar, caso deseje-se
olhar um objeto que não esteja no campo de visão. Quando o valor do atributo “ação”
é “acenar ou inclinar”, deve-se definir também o atributo tipo, traduzido para “type”,
que assume os valores “positive / negative” quando “acenar” e o lado de inclinação (“up,
down, left, right”), quando “inclinar”. Também é traduzido o atributo “ângulo” para
“angle”, quando “inclinar”.
Procedimento: traduzir olhar
Este procedimento traduz os atributos do comportamento “olhar” em atributos
do comportamento “gaze” no módulo de saída. O atributo “alvo” é traduzido para “at”,
mantendo o nome do objeto, ou a coordenada. O atributo velocidade e seus valores são
traduzidos para “speed” e seus respectivos valores. Também traduz os atributos “início”
e “fim”, acrescentando o rótulo da ação ou do comportamento, caso o tempo não seja
fornecido em milissegundos.
O procedimento traduzir olhar deve ser executada somente após a finalização
do procedimento traduzir cabeça. Desta forma, é possível verificar se o direcionamento da
cabeça permite que o objeto (ou coordenada) que deseja-se olhar, esteja dentro do campo
de visão dos olhos. Caso não esteja, o direcionamento da cabeça será sobrescrito (caso
tenha sido definido) por uma posição que permita o objeto de ser observado.
66
Procedimento: traduzir falar
Este procedimento tem o objetivo de traduzir os atributos do comportamento
“falar” em atributos do comportamento “speak” no módulo de saída. A entrada é uma
frase, a velocidade de reprodução e o início. Os atributos “velocidade “ e “início”, do
módulo de entrada, são respectivamente traduzidos para os atributos “velocity” e “start”
do módulo de saída.
Considerando que a tradução de palavras em visemas, assim como a definição
da duração de um visema e das pausas é uma tarefa complexa, esta tradução será realizada
em um trabalho futuro. Portanto, este procedimento tem por objetivo traduzir os visemas
já definidos em posições da boca. Para isso, a abordagem utilizada será similar ao sistema
de representação visual de Osipa (2010), representado na tabela 3.2 (página 34).
Cada visema tem uma respectiva representação visual. Esta representação
visual, neste trabalho, é descrita por um gráfico bidimensional, que considera o movimento
de abertura e fechamento da boca no eixo vertical, e o estreitamento ou alargamento no
eixo horizontal. Conforme gráfico representado na Figura 4.3, com escala de 1 a 5, com
os pontos neste gráfico é possível representar os movimentos que criam impressão visual
da fala.
Figura 4.3: Gráfico de movimentação da boca
Fonte: do autor
A abordagem utilizada facilita a criação de variabilidade na fala dos persona-
4.3 Módulo de Saída
67
gens. É possível escolher um valor aleatório, dentro de uma faixa de valores, em torno
do ponto que define o visema, ilustrado na Figura 4.3. Desta forma, sempre que um
visema se repetir, o personagem irá reproduzi-lo levemente diferente das vezes anteriores.
Os valores demonstrados na imagem 4.3, são dos visemas “OO” e “IH”, utilizados, por
exemplo, para reproduzir a palavra “oi”.
Portanto, além dos atributos “start” e “velocity”, são gerados duplas de atributos “viseme” e “duration”, onde o viseme é uma posição (x,y) referente ao gráfico de
movimentação da boca.
Procedimento: traduzir piscar
Este procedimento traduz os atributos do comportamento “piscar” em atributos do comportamento “blink” no módulo de saída. O atributo “velocidade” é traduzido
para o atributo “speed” e o atributo “início”, é traduzido para o atributo “start”. Inicialmente, o procedimento considera os momentos em que foram explicitamente definidos os
piscares de olhos, pelo comportamento piscar.
Posteriormente, o procedimento calcula os demais momentos em que o personagem deverá piscar os olhos, utilizando algumas regras. Primeiro, leva-se em consideração
a emoção que está sendo demonstrada na cena. Caso seja uma mistura de emoções,
considera-se a de maior intensidade. Na base de dados da emoção consta, em cada emoção, a quantidade de piscadas por minuto. É buscado então, na base de emoções, qual
é a taxa de piscadas por minuto desta emoção, para definir aleatoriamente os tempos de
piscar na ação.
4.3
Módulo de Saída
O módulo de saída é composto de um arquivo BML que, assim como no módulo
de entrada, é iniciado por um bloco cena (scene), dividido em blocos de ADAS, que
possuem blocos ações (actions), com tempo de início e fim, assim como um rótulo (id)
que possibilita referenciar a ação. O arquivo BML é gerado pelos procedimentos do módulo
de tradução, assim como descrito anteriormente. Considerando que os componentes do
arquivo de saída já foram explicados no módulo de tradução, para melhor entendimento
do módulo de saída, um exemplo de tradução é ilustrado e explicado, a partir de uma tira
68
da Turma da Mônica, apresentada na Figura 4.4.
Figura 4.4: Tira da Turma da Mônica para exemplificar o módulo de saída
Fonte: Souza (2013)
Exemplo de código de entrada
Neste exemplo, a cena possui duas ações (quadrinhos). a primeira cena, define que o personagem (Mônica) está com a cabeça inclinada para baixo, demonstrando
surpresa, olhando para o baixo e falando a frase “Ai um rato!”. Na segunda ação, o personagem olha para o rato, demonstrando aversão. Este comportamento citado é descrito
no arquivo de entrada a seguir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
69
<cena>
<ada nome=’monica’>
<acao nome=’acao1’ inicio=’0’ fim=’423’>
<cabea
acao=’inclinar’ tipo=’baixo’ angulo=’20’
velocidade=’alta’ inicio=’acao1’>
</cabeca>
<emocao tipo=’surpresa’ intensidade=’1.0’ ></emocao>
<olhar
alvo=’(1,5,6)’ velocidade=’alta’ inicio=’acao1’ fim=’acao1’>
</olhar>
<falar frase=’Ai um rato’ inicio=’acao1’ velocidade=’normal’></falar>
</acao>
<acao nome=’acao2’ inicio=’424’ fim=’976’>
<cabea
acao=’olhar’ alvo=’rato’ velocidade=’alta’ inicio=’acao2’>
</cabeca>
<emocao tipo=’averso’ intensidade=’0.8’ ></emocao>
<olhar
alvo=’rato’ velocidade=’alta’ inicio=’acao2’ fim=’acao2’>
</olhar>
</acao>
</ada>
</cena>
Algoritmo 4.1: Exemplo de arquivo XML de entrada
Exemplo de código de saída
O código a seguir, formatado conforme o módulo de saída, foi traduzido a
partir do código de entrada. Pode-se perceber que, além dos atributos que foram traduzidos diretamente, no bloco de emoção (emotion), a demonstração foi decomposta em
componentes da face e, no bloco de fala (speak), a frase falada foi decomposta em visemas.
Desta forma, um código BML com comandos de animação é gerado dentro do módulo de
saída.
4.4 Módulo de Animação
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
70
<scene>
<ada id=’monica’>
<action id=’a1’ start=’0’ end=’423’>
<head id=’h1’
acao=’tilt’ type=’down’ angle=’20’ speed=’high’ start=’a1.start’>
</head>
<emotion id=’e1’intensity=’1.0’
inBrow=’up’ outBrow=’up’
upEyelids=’up’ downEyelids=’down’
chin=’up’
jaw=’down’>
</emotion>
<gaze id=’g1’
at=’(1,5,6)’ speed=’high’ start=’a1.start’ end=’a1.end’>
</gaze>
<speak id=’s1’ start=’a1.start’
viseme=’(2,4)’
duration=’13’
viseme=’(3,1)’
duration=’12’
viseme=’(-2,-2)’ duration=’19’
viseme=’(2,3,)’ duration=’14’
viseme=’(-2,-1)’ duration=’10’>
</speak>
</action>
<action id=’a2’ start=’424’ end=’976’>
<head id=’h2’
action=’look’ at=’rato’ speed=’high’ start=’a2.start’>
</head>
<emotion id=’e2’ intensity=’0.8’
inBrow=’down’
nose=’up’ nosewings=’right’
cheeks=’up’
upLip=’up’>
</emotion>
<gaze id=’g2’
at=’rato’ speed=’high’ start=’a2.start’ fim=’a2.end’>
</gaze>
</action>
</ada>
</scene>
Algoritmo 4.2: Exemplo de arquivo BML de saída
4.4
Módulo de Animação
O módulo de animação é o módulo responsável por receber um arquivo do mó-
dulo de saída, com comandos de animação, e interpretar estes comandos. A partir desta
interpretação, é possível então, gerar uma animação. Para geração da animação, neste
trabalho foi definida a execução deste módulo em um programa de animação. A arquitetura do módulo de animação permite que haja a liberdade de escolher uma ferramenta
que melhor se adeque ao projeto. Desta forma, a partir de um arquivo de saída, é possível
4.4 Módulo de Animação
71
utilizar ferramentas diferentes para a interpretação dos comandos e criação da animação. A ferramenta escolhida para este trabalho é o software de animação 3D Autodesk
MayaTM . Sua licença é paga, porém possui versão gratuita para acadêmicos. Oferece um
conjunto completo de recursos para animação computadorizada 3D, modelagem, simulação, renderização e composição, sobre uma plataforma de produção com alta capacidade
de expansão (MAYA, 2013). Esta ferramenta foi escolhida por permitir a utilização de
animação procedural, onde é possível controlar o modelo do personagem por código de
programação.
72
5 Desenvolvimento
Neste capítulo é apresentado o desenvolvimento do modelo proposto no Capítulo 4. Primeiramente, são descritos o modelo de personagem, a ferramenta, e a linguagem
utilizada. Posteriormente, apresenta-se a implementação do sistema.
5.1
Ferramentas utilizadas
A ferramenta escolhida para este trabalho é o software de animação 3D Auto-
desk MayaTM 2014. A licença utilizada é a versão para acadêmicos que, apesar de gratuita,
é completa (AUTODESK, 2013). Esta ferramenta aceita scripts na linguagem python e mel
(Maya Embedded Language).
Linguagem
A linguagem utilizada na implementação do modelo foi python, juntamente
com as bibliotecas random, para geração de valores aleatórios na criação de variabilidade
das animações e ElementTree para manipulação de XML, ambas bibliotecas nativas. Esta
linguagem foi escolhida pela possibilidade de reaproveitamento do código para utilização
em outras ferramentas, como o Blender, que também utiliza scripts em python.
Apesar de grande parte dos comandos de animação da linguagem mel possuírem um comando respectivo em python, houve a necessidade de utilizar alguns comandos
mel dentro do script python. Para isto, é necessária a utilização do seguinte código fonte:
1
2
3
# Importa Biblioteca
import maya.mel as mel
selection = cmds.ls( sl=True )
4
5
6
# Executar comando mel
mel.eval( ’clipSchedule -name ’+ nome_clipe)
Algoritmo 5.1: Utilização da linguagem mel no código
python
5.1 Ferramentas utilizadas
73
Modelo de Personagem
O modelo de personagem escolhido foi o Blake, criado por Baskin (2013),
disponível no site creativecrash.com, representado na figura 5.1. Sua licença é gratuita
para uso não comercial. Este modelo já possui controladores da face e do corpo, sendo
também possível mudar algumas características da aparência, como cor dos olhos, cabelo
e roupa.
Figura 5.1: Modelo de Personagem Blake
Fonte: (BASKIN, 2013)
Cada controlador pode variar em valores de 0 a 1 nos eixos X e Y, onde cada
eixo controla diferentes ações da face. Os controladores da face, representados na figura
5.2 e utilizados para implementação do sistema foram:
• Mouth emotion: controla cantos da boca, fazendo o formato de U para cima ou
para baixo, podendo definir maior intensidade no lado esquerdo ou direito da face;
• Sync: controla a boca aberta/fechada e larga/estreita;
• Upper lip: controla movimentos diagonais e horizontais do lábio superior;
• Lower lip: controla movimentos diagonais e horizontais do lábio inferior;
• Brow emotion: controla a altura e o proximidade da parte interior das sobrancelhas, podendo definir maior intensidade no lado esquerdo ou direito da face;
• Eyebrows: controla altura da parte exterior das sobrancelhas, podendo definir
maior intensidade no lado esquerdo ou direito da face;
• Upper lids: controla movimentos das pálpebras superiores;
5.1 Ferramentas utilizadas
74
• Lower lids: controla movimentos das pálpebras inferiores;
• Sneer: controla contração/relaxamento do nariz, podendo definir maior intensidade
no lado esquerdo ou direito da face.
Figura 5.2: Controladores da face
Fonte: do autor
Para adaptar o modelo de personagem às necessidades do projeto, houve a necessidade de acrescentar controladores customizados em forma de constraints (restrições),
representados na figura 5.3. Uma constraint pode assumir diferentes tipos de controle,
como apontar, mirar, orientar e escala (respectivamente point, aim, orient e scale).
Em uma hierarquia, a constraint se torna pai do objeto que ela irá controlar.
Portanto, na criação de uma constraint que controla o alvo de um olho, seleciona-se
primeiramente o filho (olho) e posteriormente o objeto que será utilizado para controle
(podendo ser um círculo ou quadrado, por exemplo). Por fim, no menu constraint, dentro
do módulo de animação, é possível escolher o tipo de constraint desejada (aim, para este
exemplo).
Para criar somente a paternidade entre dois objetos, utiliza-se o menu edit,
no módulo de animação. Primeiramente é selecionado o filho e posteriormente o pai,
aplicando a opção parent do menu. Os controladores criados foram:
5.2 Refinamento do modelo
75
• Left Eye Control: constraint do tipo aim, controla o alvo para qual o olho esquerdo aponta;
• Right Eye Control: constraint do tipo aim, controla o alvo para qual o olho
direito aponta;
• Eye Target: pai dos controladres Left Eye e Right Eye, controlando ambos olhos
ao mesmo tempo;
• Head Target: pai do controlador Eye Target, e constraint do tipo aim para toda
a cabeça do personagem;
• Near Head: filho da cabeça do personagem, fica à frente da face como referência
para onde face está virada. É utilizado para realizar o movimento de inclinação da
cabeça.
Figura 5.3: Controladores customizados da face
Fonte: do autor
5.2
Refinamento do modelo
Durante a implementação do sistema, houve a necessidade de mudanças no
modelo proposto, a fim de aperfeiçoar o fluxo entre os módulos, ou contornar algumas
limitações da ferramenta utilizada.
5.2 Refinamento do modelo
76
A primeira decisão foi utilizar a técnica pose-to-pose para criação das emoções,
ao invés de fazer proceduralmente. A técnica pose-to-pose é utilizada quando poses são
criadas em forma de quadros-chave da animação.
O sistema foi inicialmente modelado para que no banco de emoções constasse
a emoção e suas características em forma de valores posteriormente aplicados em controladores. Considerando que, para gerar esses valores, é necessário criar uma pose, foi
preferível criar cada pose na ferramenta de animação e já nomeá-la como uma emoção.
Este procedimento dispensa o processo de criar uma pose, salvar seus atributos, e depois
carregá-los e criar novamente a mesma pose.
Portanto, o banco de emoções e de visemas são bancos de poses no Autodesk
MayaTM 2014. No modelo, isso implica em uma alteração no módulo de tradução. Ao invés
do arquivo bml possuir valores para cada componente da face, este possuirá somente o
nome da pose desejada. Os valores serão aplicados nos componentes na própria ferramenta
de animação, utilizando o banco de poses. Para criar uma pose utiliza-se o menu animate,
do módulo de animação da ferramenta. Após selecionar os componentes desejados, cria-se
a pose com a opção create pose.
As poses estão listadas na ferramenta de animação, acessando o menu window,
do módulo de animação, escolhendo a categoria general editors e a opção visor. Ao abrir
a janela do visor, na aba Character Poses, estarão listadas as poses e visemas criados,
com seus respectivos nomes.
Considerando a brevidade nas mudanças de emoção, foi decidido não mais
utilizar uma frequência específica de piscar de olhos para cada emoção, pois essa frequência
seria alterada constantemente, inclusive antes de um próximo piscar de olho. Foi preferível
utilizar valores aleatórios, dentro de uma faixa de tempo, para geração de momentos de
piscadas naturais do olho.
A verificação se o alvo está ou não no campo de visão do personagem, foi
transferida para o módulo de animação, pois somente na ferramenta que é possível fazer
essa verificação.
O tempo pode ser fornecido tanto por frames, quanto por segundos. Para
utilizar frames, adicionar somente o número no arquivo de entrada. para utilizar segundos,
deve ser adicionado o termo sec após o número de segundos.
5.3 Desenvolvimento
77
Cada comportamento do arquivo de entrada pode ser traduzido para mais de
um comportamento mais específico no arquivo de saída, pois podem ser referir a chamadas
diferente no módulo de animação. Por exemplo, o comportamento emoção. Quando é
escolhida somente uma emoção, é uma função que executa esse comando no módulo de
animação. Quando é mais do que uma emoção, outra função é utilizada. Essa verificação
da quantidade de emoções é feita no módulo de tradução, que irá tratar qual chamada
de função fazer, utilizando diferentes tags no arquivo de saída. O mesmo se aplica aos
movimentos da cabeça onde, para cada tipo de ação (acenar, inclinar ou olhar) há uma
tag diferente no arquivo de saída.
Inicialmente, para testar o funcionamento do sistema, foi criado um novo bloco
de fala para ser utilizado no arquivo de entrada e saída. Este bloco contém visemas e
o tempo de execuções do sistema, que são interpretados e executados no módulo de
animação. O bloco original da fala permanece conforme modelado. Conforme citado no
capítulo 4, a tarefa de traduzir uma frase em visemas e definir o tempo de reprodução e
duração será tratada em um trabalho futuro.
5.3
Desenvolvimento
A implementação deste trabalho de conclusão de curso foi dividida em etapas,
utilizando-se da abordagem bottom-up (iniciando no módulo de animação, finalizando com
o módulo de entrada). Esta abordagem foi utilizada, pois o foco do sistema é a animação,
possibilitando assim refinamento nos modelos de maior alto-nível de abstração, para se
adequarem as necessidades do módulo de animação.
A primeira etapa foi o desenvolvimento do banco de emoções. As etapas
subsequentes foram desenvolver os módulos de animação, saída, tradução e entrada, respectivamente. Ao término do desenvolvimento de cada módulo, os modelos eram revistos
para realização de refinamentos, caso necessário.
A própria ferramenta é responsável por interpretar o código python, por meio
do Script Editor, acessado pelo menu window, do módulo de animação, escolhendo ao
categoria general editors e a opção Script Editor, representado na figura 5.4.
5.3 Desenvolvimento
78
Figura 5.4: Script Editor
Fonte: do autor
Nas próximas seções, são detalhadas as implementações de cada módulo e da
criação do banco de emoções.
5.3.1
Banco de Emoções
Para o desenvolvimento do banco de emoções, foram utilizadas as emoções
detalhadas na seção 3.7.3 - Emoções básicas, definias por Ekman (2007): tristeza, raiva,
surpresa, medo, nojo, desprezo e felicidade. Inicialmente, somente as emoções descritas
neste trabalho (neutra, tristeza, raiva, medo, surpresa, aversão, desprezo e felicidade)
foram criadas. Demais emoções podem ser atingidas pela criação destas como poses
no banco de emoções, ou pela combinação de uma ou mais emoções e suas respectivas
intensidades.
Cada emoção foi criada em modo de pose na ferramenta. Uma pose é um
conjunto de valores atribuídos a controladores e salvos com um respectivo nome para
esta pose. Após possuir os valores definidos, cria-se a pose, selecionando os controladores
necessários e utilizando o menu animate, do módulo de animação, clicando ao quadrado
ao lado da opção create pose. Define-se um nome à pose desejada, e então a pose é criada
com o botão create pose. Os valores utilizados para criação das emoções estão listados na
5.3 Desenvolvimento
79
tabela 5.1.
Tabela 5.1: Valores extremos dos controladores por emoção
Controlador
Triste Raiva Medo Surpresa Aversão Desprezo Felicidade
Mouth Emotion X
0
0
0
0
0
1
0
Mouth Emotion Y
-1
0
0,3
0
-1
1
1
Sync X
0
0,5
-0,1
0
0
0
0
Sync Y
-0,5
0,6
-0,3
-1
0
0
-0,5
Sneer X
0
0
0
0
0
0
0
Sneer Y
1
1
0,5
0
1
1
0,5
Lower Lids X
0
0
0
0
0
0
0
Lower Lids Y
0,3
0,7
0
0
0
0,5
0,4
Upper Lids X
0
0
0
0
0
0
0
Upper Lids Y
0,7
0,6
0
0
0
0,5
0,4
Eye Brows X
0
0
0
0
0
0
0
Eye Brows Y
-1
0,2
1
1
0,3
0,2
-0,5
Brow Emotion X
1
1
1
0
0
0
0
Brow Emotion Y
0
-1
1
1
-1
-1
-0,5
Upper Lip X
0
0
0
0
0
1
0
Upper Lip Y
-0,9
1
0,8
1
1
0,5
0
Lower Lip X
0
0
0
0
0
1
0
Lower Lip Y
-0,2
0
0
0,5
0,3
0,6
-1
Fonte: do autor
As poses estão listadas na ferramenta de animação, acessando o menu window,
do módulo de animação, escolhendo ao categoria general editors e a opção visor, representado na figura 5.5. Ao abrir a janela do visor, na aba Character Poses, estarão listadas
as poses e visemas criados, com seus respectivos nomes. As poses podem ser aplicadas
clicando em cima do seu respectivo nome com o botão direito do mouse e indo até a opção
apply pose.
5.3 Desenvolvimento
80
Figura 5.5: Emoções desenvolvidas
Fonte: do autor
5.3.2
Módulo de Entrada
Este módulo é composto por um arquivo XML de entrada, que deverá ser no-
meado como: animation.xml, e possuir seu caminho definido no código fonte, na variável
global file_path. Este arquivo deve seguir o padrão modelado no capítulo 4.1. Exemplo
de arquivo de entrada:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<scene start="1" end="880">
<ator nome="brad">
<acao nome="acao1" inicio="1" fim="120">
<emocao inicio="acao1" fim="2">
<intensidade>1</intensidade>
<nome>Medo</nome>
</emocao>
<emocao inicio="101" fim="acao2">
<intensidade>0.1</intensidade>
<nome>Felicidade</nome>
<nome>Surpreso</nome>
</emocao>
<cabeca movimento="olhar" inicio="1" fim="30">
<alvo>0,25,15</alvo>
<velocidade>media</velocidade>
</cabeca>
<alvo>MetalFly_v1_0:MetalFly_global</alvo>
</cabeca>
<cabeca movimento="acenar" inicio="50">
<vezes>4</vezes>
<orientacao>positivo</orientacao>
</cabeca>
<cabeca movimento="inclinar" inicio="80" fim="120">
<orientacao>cima</orientacao>
<angulo>30</angulo>
<velocidade>baixa</velocidade>
</cabeca>
<piscar inicio="60" velocidade="baixa" />
5.3 Desenvolvimento
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
81
<falar>
<visema>
<tempo>220</tempo>
<x>0</x>
<y>0</y>
</visema>
<visema>
<tempo>225</tempo>
<banco>banco</banco>
<vis>visema_oo</vis>
</visema>
</falar>
</acao>
<acao nome="acao2" inicio="1" fim="102" />
</ator>
</scene>
Algoritmo 5.2: Exemplo de arquivo XML de entrada
5.3.3
Módulo de Tradução
Este módulo é responsável por interpretar o arquivo XML de entrada, e traduzi-
lo para um arquivo BML de saída. Este processo é feito lendo cada elemento (comando)
do arquivo de entrada, e processando-o por regras que resultarão em um novo elemento
equivalente a uma função do módulo de animação.
Emoções no arquivo de entrada são representadas em um elemento somente,
mesmo quando há combinação de emoções. No módulo de tradução é verificada a quantidade de emoções e, caso seja somente uma, é criado um elemento emotion. Caso haja
mais de uma, o elemento criado é emotion_blend. Em ambos casos, os demais atributos
são acrescentados ao elemento.
Os movimentos da cabeça no arquivo de entrada são também representados
em um elemento somente. o que difere um elemento de outro é o atributo movimento,
que indica se a ação é acenar, olhar ou inclinar. Para cada tipo de movimento, um novo
elemento é criado no arquivo de saída, com seus respectivos atributos acrescentados ao
elemento.
Os piscares de olhos automáticos também são definidos no módulo de Tradução. Após criar elementos para os piscares definidos explicitamente, a cena é percorrida
criando piscares em pontos aleatórios gerados dentro de um intervalo de 2 a 10 segundos.
5.3 Desenvolvimento
5.3.4
82
Módulo de Saída
Este módulo é composto por um arquivo BML de saída, gerado pelo módulo de
tradução. O arquivo é gerado no mesmo caminho do arquivo de entrada, com o nome
output.bml. Este arquivo segue o padrão modelado no capítulo 4.3.
Este arquivo não possui indentação, tendo somente uma linha, por uma limitação da biblioteca ElementTree. Porém, é possível utilizar ferramentas externas que
formatam XML, para formatar este arquivo, caso seja preciso para sua visualização e entendimento. Exemplo de arquivo de saída, gerado após processamento do arquivo de entrada
exibido no capítulo 5.3.2:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<scene end="880" start="1">
<ada id="brad">
<action end="120" id="acao1" start="1">
<emotion end="2" start="1">
<intensity>1</intensity>
<name>Medo</name>
</emotion>
<emotion_blend end="102" start="101">
<intensity>0.1</intensity>
<name>Felicidade</name>
<intensity>0.3</intensity>
<name>Surpreso</name>
</emotion_blend>
<head_coordinate end="30" start="1">
<coordinate>0,25,15</coordinate>
<speed>media</speed>
</head_coordinate>
<head_object end="60" start="25">
<target>MetalFly_v1_0:MetalFly_global</target>
</head_object>
<head_shake start="50">
<repete>4</repete>
<orientation>positivo</orientation>
<speed>media</speed>
</head_shake>
<head_tilt end="120" start="80">
<angle>30</angle>
<orientation>cima</orientation>
<speed>baixa</speed>
</head_tilt>
<speak>
<viseme>
<time>220</time>
<x>0</x>
<y>0</y>
</viseme>
<viseme>
<time>225</time>
<database>banco</database>
5.3 Desenvolvimento
41
42
43
44
45
46
47
48
49
50
51
52
83
</viseme>
</speak>
</action>
<blink speed="baixa" start="60" />
<action end="102" id="acao2" start="1" />
<blink speed="alta" start="224" />
</ada>
</scene>
Algoritmo 5.3: Exemplo de arquivo BML de saída
5.3.5
Módulo de Animação
O módulo de animação inicia com a abertura do arquivo bml. A interpretação
deste arquivo é realizada pela da biblioteca ElementTree, por possuir estrutura idêntica
a um xml. O módulo é composto por funções, responsáveis por ler os comandos e valores
do arquivo e traduzir em ações de animação. Após o término de cada função, é impresso
em um log, que fica registrado no script editor da ferramenta, que a função foi executada,
com seus respectivos parâmetros.
Função emotion
Função responsável por reproduzir emoções, quando somente uma emoção é
desejada. Recebe como parâmetros: início, fim, intensidade, emoção e personagem. As
emoções sempre começam 5 frames após o início e terminam 5 frames após o fim, possuindo
esse intervalo a mais, para realizar a transição entre emoções.
O primeiro passo é aplicar a emoção desejada no tempo inicial. São então
percorridos todos os controladores, declarados em uma lista, que manipulam as emoções,
aplicando a intensidade desejada para esta emoção.
A intensidade da emoção varia em uma casa decimal, de 0.0 a 1.0. A intensidade máxima (1.0) é a própria pose, conforme definida no banco de poses, enquanto a
intensidade mínima (0.0) é a pose neutra, conforme representado na figura 5.6. As demais
intensidades são calculadas utilizando o valor passado como parâmetro.
5.3 Desenvolvimento
84
Figura 5.6: Intensidades da emoção Felicidade
Fonte: do autor
Depois de calculada a intensidade da emoção, o quadro-chave é gravado. Para
que a emoção possa ser interpolada com outras emoções, é necessária a criação de um clipe.
Desta maneira, quando uma emoção possui um trecho em comum com outra emoção, esse
trecho será interpolado.
Primeiramente é definido um nome para este clipe. É então criada uma instância dele no agendador (schedule) do Trax Editor.
Trax Editor, referenciado na figura 5.7, é uma linha de tempo responsável por
manipular clipes, podendo alterar o tempo de início e duração destes.
Figura 5.7: Trax Editor
Fonte: do autor
Cada clipe possui um identificador (index) específico. Com este identificador
e o tempo de início e fim do clipe, os demais clipes são percorridos, buscando algum que
esteja dentro do intervalo do clipe que está sendo criado. Caso seja encontrado, é criada
a interpolação (blend) destes clipes, no período de tempo comum a ambos, realizando
assim, a transição entre as emoções.
5.3 Desenvolvimento
85
Função emotion blend
Possui funcionamento similar à função emotion. Por se tratar de mais de uma
emoção, a primeira emoção também tem sua pose, plicada no quadro inicial, com sua
respectiva intensidade. As demais emoções possuem poses e intensidades aplicadas nos
quadros subsequentes. Após aplicar todas as emoções, é realizado a interpolação (blend)
destas com a primeira emoção, e só então é gerado o clipe.
Função cabeça coordenada
Função responsável por reproduzir o movimento do olhar, movendo a cabeça,
ou os olhos, para uma coordenada específica. Recebe como parâmetros: início, fim, x, y,
z, velocidade e personagem. A velocidade, que pode ser baixa, média ou alta, define a
quantidade de quadros (pulo) necessária para levar a cabeça até a coordenada desejada.
Uma verificação inicial é realizada, para definir se o movimento do olhar será
da cabeça ou dos olhos. Inicialmente é realizado o movimento de um olho, verificando
pela rotação se o olho ainda está dentro do campo da visão do personagem. Se estiver, é
chamada a função olhos coordenada. Caso não esteja, é realizado o movimento da cabeça,
movendo a cabeça e os olhos para a coordenada desejada, definindo quadros-chave no início
(acrescido do pulo) e fim da ação.
Função cabeça objeto
Possui funcionamento similar à função cabeça coordenada. Ao invés de receber
uma coordenada, recebe um objeto por parâmetro. A cada quadro, busca a posição do
objeto e redefine o olhar para esta posição.
Função cabeça aceno
Função responsável por reproduzir o aceno da cabeça. Recebe como parâmetros: início, vezes, orientação, velocidade e personagem. A orientação do aceno define
se este é um aceno positivo (cabeça movimenta-se para baixo e para cima) ou negativo
(cabeça movimenta-se de um lado para o outro). O parâmetro vezes indica quantas vezes
a cabeça realiza o aceno.
5.3 Desenvolvimento
86
A velocidade do aceno pode ser baixa, média ou alta, resultando na alteração
nos intervalos de cada movimento do aceno. Após definida a velocidade e orientação,
a função realiza os movimentos da cabeça, repetindo-os a quantidade de vezes parametrizada. Os olhos se mantém no foco, enquanto somente a cabeça realiza o aceno. No
término do aceno, a cabeça retorna à posição inicial.
Função cabeça inclinada
Função responsável por reproduzir a inclinação da cabeça. Recebe como parâmetros: início, fim, orientação, angulo, velocidade e personagem. A orientação pode ser
para cima, baixo, direita e esquerda, indicando o sentido em que a cabeça deverá inclinar.
A velocidade pode ser baixa, média ou alta e o angulo, de 0 a 90, define a rotação da
cabeça.
Considerando que o controlador do alvo da cabeça realiza sua ação alterando
os valores de rotação desta, algumas dificuldades foram encontradas para definir a rotação
desejada da cabeça, pois o controlador do alvo sobrescreve o controlador da rotação da
cabeça.
Para contornar a situação descrita, a função busca a rotação atual da cabeça e
altera o valor do alvo da cabeça, na direção da orientação, até chegar ao ângulo solicitado,
aonde grava o quadro chave. No tempo final, a inclinação inicial é então restaurada.
Função olhos coordenada
Função responsável por reproduzir o movimento dos olhos em um olhar para
uma coordenada definida. Recebe como parâmetros: início, fim, x, y, z, velocidade e
personagem. A velocidade baixa, média, ou alta, define o intervalo aonde os olhos irão se
deslocar até a coordenada desejada. O alvo que controla os alvos é levado à coordenada,
e ao término da função, o alvo dos olhos volta a acompanhar o alvo da cabeça.
Função olhos objeto
Possui funcionamento similar à função olhos coordenada. Ao invés de receber
uma coordenada, recebe um objeto por parâmetro. A cada quadro, busca a posição do
objeto e redefine o alvo dos olhos para esta posição.
5.3 Desenvolvimento
87
Função piscar olhos
Função responsável por reproduzir o piscar de olhos. Recebe como parâmetros:
início, velocidade e personagem. A velocidade pode ser baixa, média ou alta. Inicialmente
a função busca a abertura atual, realiza o fechamento e abertura das pálpebras, com
intervalos que variam de acordo com a velocidade e por fim, volta à abertura inicial.
Função frase
Função responsável por reproduzir em um personagem um conjunto de visemas, em tempos específicos, recebidos por parâmetros. Os visemas e respectivos tempos
são tuplas passadas por parâmetro, em um vetor com tamanho variável.
Os visemas podem utilizar tanto o sistema do gráfico bidimensional (conforme
descrito no procedimento traduzir falar, no capítulo 4.2), quanto aqueles criados no banco
de visemas.
Após verificado o tipo de visema, são chamadas funções específicas (visema
banco ou visema coordenada) para criação do visema. Tendo todos visemas criados como
quadros chave, é então gerado um clipe responsável por reproduzir a frase por completo.
Função visema coordenada
Função responsável por reproduzir um visema passado no formato de coordenada. Recebe como parâmetros o tempo de reprodução, X, Y e personagem. Os visemas
possuem variabilidade, pois possuem seu X e Y somados a um valor aleatório, dentro de
um intervalo. O visema é aplicado no personagem e salvo como um quadro chave.
Função visema banco
Possui funcionamento similar à função visema coordenada. Ao invés de receber uma coordenada, recebe um visema do banco por parâmetro, que é aplicado no
personagem e salvo como um quadro chave.
5.3 Desenvolvimento
88
Função reseta
Função que recebe somente o personagem como parâmetro, sendo necessária
para redefinir as configurações do personagem, apagar quadros-chave e clipes criados,
aplicar a pose neutra e posicionar os alvos de cabeça e olhos em um mesmo ponto. Esta
função deve ser a primeira executada, para que cada vez que rodar o script, uma nova
animação seja gerada, sem haver vestígios de execuções anteriores.
89
6 Experimentação e Análise dos Resultados
Nesse capítulo são apresentados os experimentos realizados para validação dos
resultados, assim como a análise dos resultados para um caso para estudo.
6.1
Experimento
O experimento objetiva validar todas as funcionalidades desenvolvidas no sis-
tema. Tal experimento é composto por um arquivo de entrada (presente no apêndice),
criado para demonstrar todos os comportamentos implementados. Para demonstração
dos resultados obtidos, a seguir estão descritos os comportamentos presentes no arquivo,
assim como o processo de execução do arquivo no plugin desenvolvido para a ferramenta.
O arquivo de entrada criado inicia com a realização de uma fala, aonde o
personagem reproduz visualmente uma frase, ao mesmo tempo em que realiza um olhar,
acompanhando um objeto. Durante esta ação, o personagem passa da emoção neutra
para a emoção surpreso, na sequência raiva e por último, felicidade. No final, este volta
a olhar para o centro. O resultado pode ser visto na figura 6.1.
Figura 6.1: Ações de fala, olhar um objeto e demonstrar emoções
Fonte: do autor
Na sequência, são realizados alguns olhares, com diferentes velocidades. A
movimentação inicia com alvos próximos, para haver movimentação somente dos olhos.
Posteriormente, movimentos mais distantes e inclusive detrás do personagem, são execu-
6.1 Experimento
90
tados, havendo a necessidade de mover toda a cabeça. Resultado pode ser visto na figura
6.2.
Figura 6.2: Movimentos com os olhos e com a cabeça
Fonte: do autor
O próximo passo é a realização de acenos positivos e negativos com a cabeça,
com velocidades média e alta, respectivamente. Também é realizada a inclinação da
cabeça para frente e para trás. Na sequência foram definidos 2 momentos para cada tipo
de piscada (de velocidades baixa, média e alta). Resultado pode ser visto na figura 6.3.
Figura 6.3: Aceno e inclinação da cabeça, e piscar de olhos
Fonte: do autor
Por último, são reproduzidas todas as emoções presentes no banco (aversão,
desprezo, felicidade, medo, raiva, surpreso e triste) e a combinação das emoções, com suas
respectivas intensidades, medo e desprezo. Resultado pode ser visto na figura 6.4.
6.2 Análise dos Resultados
91
Figura 6.4: Emoções e combinações
Fonte: do autor
A animação possui a duração de 53 segundos, e sua geração levou 6 minutos
para ser concluída, desde a interpretação do arquivo de entrada, até a criação da animação.
Um arquivo de saída BML foi gerado, podendo ser aberto para validações.
6.2
Análise dos Resultados
O plugin criado foi capaz de interpretar corretamente o arquivo de entrada
fornecido, quando gerado de acordo com os padrões do modelo proposto. Este arquivo,
com alto-nível de abstração, foi convertido para comandos mais específicos, gerando corretamente um novo arquivo de saída, que foi interpretado corretamente pelo módulo de
animação.
Pela
visualização
da
animação,
disponível
em
http://www.youtube.com/watch?v=d7l3mDHi82Q, é possível visualizar que aproximadamente todos os requisitos foram cumpridos, conforme o modelo proposto. Alguns
requisitos que foram parcialmente alcançados, ou que necessitam de melhorias são:
• A inclinação da cabeça não é realizada para o lados esquerdo ou direito, somente
para cima e para baixo. Isto ocorre devido à necessidade de utilizar um controlador
de alvo da cabeça, para realizar sua inclinação, pois tal controlador é quem controla a rotação da cabeça, sobrescrevendo qualquer rotação realizada nesta. Porém,
utilizando este controlador, não é possível realizar a inclinação para os lados;
• Nos últimos quadros da transição entre uma emoção e outra, há movimentos bruscos
dos componentes da face, não ocorrendo suavemente, como deveria ser a transição.
6.3 Validação
92
Estas transições são geradas automaticamente pela ferramenta, quando é feita a
junção de dois clipes;
• A criação de uma animação leva aproximadamente 6 vezes o tempo de reprodução
desta, variando de acordo com o nível de detalhe, que faz necessários mais comandos. Para grandes animações, este tempo pode ser considerado demorado, mesmo
para um computador potente. Os testes foram realizados em uma máquina com proR
R
cessador Intel i7, com 8 Gb de memória RAM DDR3, e placa de vídeo GeForce GTX770. O gargalo está na criação de emoções e visemas, que requer criação de
clipes, os quais levam maior tempo para geração;
• Quando a cabeça se vira para o lado esquerdo do personagem, o pescoço deste fica
contorcido, conforme representado na figura 6.5. Isto ocorre devido o controlador
de alvo da cabeça manipular o controlador de rotação desta.
Figura 6.5: Pescoço contorcido
Fonte: do autor
6.3
Validação
Os requisitos utilizados para validação deste trabalho de conclusão de curso,
conforme caregorias definidas por (CARVALHO, 2012), foram:
6.3 Validação
93
• Análise de sucesso do conhecimento produzido:
Utilidade: o plugin desenvolvido mostrou-se útil na criação de animações faciais.
Apesar de necessitar de melhorias, para se apresentar utilizável em um contexto
real, já possui a base para criação de animações mais complexas.
Eficácia: com a análise dos resultados foi percebido que o modelo é capaz de
gerar resultados plausíveis. A sua implementação foi capaz de gerar animações
coerentes.
Eficiência: apesar do processo de geração da animação levar aproximadamente 6
vezes a duração da animação criada, ainda é relativamente mais rápido que a
geração manual da mesma animação.
• Generalização: o modelo criado permite a utilização dos seus conceitos, e inclusive
parte do código-fonte, na implementação de um plugin em outra ferramenta de
animação, alcançando assim a generalização.
• Inovação: esse trabalho apresenta um plugin para uma ferramenta de animação,
que gera animações faciais a partir de um arquivo XML de entrada.
94
7 Conclusões
Atores Digitais Autônomos, uma analogia a atores reais, utilizam a face como
parte do corpo de maior importância para reconhecimento e comunicação interpessoal. A
percepção dos espectadores é sensível a detalhes das expressões faciais tornando imprescindível, na animação por computador, comunicar-se corretamente utilizando a face. A
credibilidade na expressividade facial é alcançada, quando cada componente da animação
facial: representação da fala, direcionamento do olhar, piscar de olhos e representação
facial de emoções, dá aparência de vida e perfeição ao personagem.
A partir do estudo da anatomia facial, técnicas de animação e dos componentes citados, foi possível identificar os requisitos necessários para o desenvolvimento
do modelo de animação procedural para expressividade facial de atores virtuais. Neste
contexto, Behavior Markup Language surge como instrumento para descrever comportamentos verbais e não verbais da face, independentemente do método da realização da
animação utilizado.
Com base nos fundamentos teóricos, sugeriu-se um modelo computacional que
cria, a partir de um arquivo XML de alto-nível, um arquivo BML de saída, capaz de ser
interpretado por uma ferramenta de animação, para gerar a animação facial de ADAs.
A implementação deste modelo foi realizada na forma de um plugin para a
ferramenta de animação Autodesk MayaTM , utilizando a linguagem python. Um experimento, utilizando as funcionalidades desenvolvidas, foi realizado e mostrou-se adequado
aos requisitos modelados.
Um modelo de personagem com controladores já definidos foi utilizado, acrescentando novos controladores. Para criação de novos ADAS, o mesmo padrão de controladores deve ser seguido, com a mesma nomenclatura, para que haja compatibilidade com
a ferramenta.
Apesar da limitação inicial na quantidade de emoções e visemas, o sistema
pode ser facilmente estendido com a criação de novas emoções e visemas no banco, além
de possuir a capacidade de combinar emoções para geração de novas. Há ainda a necessidade de, em um trabalho futuro, desenvolver um módulo capaz de transformar frases em
7 Conclusões
95
visemas com tempos definidos para exibição, dentro de uma duração.
A animação gerada se mostrou fiel ao arquivo de entrada, reproduzindo corretamente os comandos de animação. Porém, para aprimorar a aparência de vida do
personagem ao espectador, sugere-se como trabalhos futuros:
• Criação de um algoritmo para transições mais suaves entre emoções, tirando da
ferramenta de animação esta responsabilidade, que têm feito movimentos bruscos
durante estas transições;
• Realização de um estudo mais aprofundado sobre foco de atenção visual, pois foi
percebido que a maior parte do tempo o olhar está estático, não dando a impressão
de vida ao personagem;
• Considerando que as emoções atuais são criadas a partir de poses da face do personagem, pode ser acrescentado um novo banco de emoções que variam de acordo
com o tempo, como uma gargalhada, por exemplo, que não pode ser representada
por somente uma pose;
• Testar o módulo de animação em outras ferramentas, buscando melhorar o desempenho do sistema, e uma ferramenta melhor preparada para utilização de scripts,
considerando que Autodesk MayaTM carece de recursos como debug;
• Modificação nos controladores do personagem, de maneira a resolver os problemas
do pescoço contorcido e a inclinação lateral da cabeça;
• Criação de um sistema dentro do módulo de Tradução, responsável por traduzir
frases em visemas, com tempos definidos para reprodução.
Referências Bibliográficas
ADOLPHS, R. Recognizing emotion from facial expressions: Psychological and
neurological mechanisms. Behavioral and Cognitive Neuroscience Reviews, v. 1, n. 1, p.
21–62, jan. 2002. ISSN 1534-5823, 1552-4159. Disponível em: <http://emotion.caltech.edu/papers/Adolphs2002Recognizing.pdf>.
ARGYLE, M. Gaze and Mutual Gaze. [S.l.]: Cambridge University Press, 1976. ISBN
0521208653.
ARGYLE, M.; DEAN, J. Eye-contact, distance and affiliation. Sociometry Journal,
v. 28, n. 3, p. 289–304, 1965. ISSN 00380431. Disponível em: <http://www.columbia.edu/˜rmk7/HC/HC Readings/Argyle.pdf>.
ARNOLD, M. B. Emotion and personality. Vol. I. Psychological aspects. Oxford,
England: Columbia Univer. Press, 1960.
AUTODESK. Maya Student Software. 2013. Disponível em: <http://www.autodesk.com/education/free-softwarel>.
BACHER, L. F.; SMOTHERMAN, W. P. Spontaneous eye blinking in human infants: a
review. In: Developmental psychobiology. [S.l.: s.n.], 2004. v. 44, n. 2, p. 95–102. ISSN
0012-1630. PMID: 14994260.
BADLER, N. Real-time virtual humans. In: The Fifth Pacific Conference on Computer
Graphics and Applications, 1997. Proceedings. [s.n.], 1997. p. 1–4. Disponível em:
<http://www.cis.upenn.edu/˜badler/papers/pg97.pdf>.
BARAB, S.; SQUIRE, K. Design-based research: Putting a stake in the ground. In:
Journal of the Learning Sciences. [S.l.: s.n.], 2004. v. 13, p. 1–13.
BASKIN, J. Blake Free character rig for Maya. 2013. Disponível em: <http://www.creativecrash.com/maya/downloads/character-rigs/c/blakel>.
BREDOW, R.; SCHAUB, D.; ENGLE, R.; KRAMER, D.; HASTINGS, A. From mocap
to movie: the making of the polar express. In: ACM SIGGRAPH 2005 Courses. New
REFERÊNCIAS BIBLIOGRÁFICAS
97
York, USA: ACM, 2005. (SIGGRAPH, ’05). Disponível em: <http://doi.acm.org/10.1145/1198555.1198705>.
CAFFIER, P. P.; ERDMANN, U.; ULLSPERGER, P. Experimental evaluation of
eye-blink parameters as a drowsiness measure. In: European journal of applied physiology.
[S.l.: s.n.], 2003. v. 89, n. 3-4, p. 319–325. ISSN 1439-6319. PMID: 12736840.
CARVALHO, J. A. Validation criteria for the outcomes of design research. In:
International Workshop on IT Artefact Design & Workpractice Intervention. [S.l.: s.n.],
2012.
CAVAZZA, M.; CHARLES, F.; MEAD, S. J. Interacting with virtual characters in
interactive storytelling. In: Proceedings of the first international joint conference on
Autonomous agents and multiagent systems: part 1. New York, USA: ACM, 2002.
(AAMAS, ’02), p. 318–325. ISBN 1-58113-480-0.
CHEVALIER-SKOLNIKOFF, S. Facial expression of emotion in hohhuman primates.
In: Darwin and Facial Expression: A Century of Research in Review. New York: ISHK,
1973. p. 11–83. ISBN 9781883536886.
CHUNG, S.-K. Facial animation: A survey based on artistic expression control. In:
Research Art Vol.2 No.1 (2009/04). [S.l.: s.n.], 2009. p. 131–162.
COSTA, A. M.; CLUA, E. W. G. C. Animação facial usando xna. In: Proceedings of the
2007 Brazilian Symposium on Games and Digital Entertainment. [S.l.]: IEEE Computer
Society, 2007.
DAMASIO, A. Descartes’ error: emotion, reason, and the human brain. New York: G.P.
Putnam, 1994. 124–205 p. (A Grosset/Putnam book). ISBN 9780399138942.
DARRELL, T.; PENTLAND, A. Space-time gestures. In: , 1993 IEEE, Computer
Society Conference on Computer Vision and Pattern Recognition, 1993. Proceedings
CVPR, ’93. [S.l.: s.n.], 1993. p. 335–340.
DARWIN, C. The Expression of the Emotions in Man and Animals. [S.l.]: J. Murray,
1872. 34–81 p.
DENG, Z.; NOH, J. Computer facial animation: A survey. In: DENG, Z.; NEUMANN,
U. (Ed.). Data-Driven 3D, Facial Animation. [S.l.]: Springer London, 2007. p. 1–28.
ISBN 978-1-84628-906-4, 978-1-84628-907-1.
98
EBERT, D. S. Texturing & Modeling: A Procedural Approach. [S.l.]: Morgan Kaufmann,
2003. ISBN 9781558608481.
EKMAN, P. An argument for basic emotions. Cognition & Emotion, v. 6, n. 3-4, p.
169–200, maio 1992.
EKMAN, P. Emotions Revealed, Second Edition: Recognizing Faces and Feelings to
Improve Communication and Emotional Life. 2. ed. [S.l.]: Holt Paperbacks, 2007. ISBN
0805083391.
EKMAN, P. Telling Lies: Clues to Deceit in the Marketplace, Politics, and Marriage.
Revised edition. [S.l.]: W. W. Norton & Company, 2009. ISBN 0393337456.
EKMAN, P.; FRIESEN, W. V.; HAGER, J. Facial Action Coding System (FACS):
Manual and Investigator’s Guide. [S.l.]: Consulting Psychologists Pr, 2002. ISBN
9993626619.
EL-NASR, M. S.; WEI, H. Exploring non-verbal behavior models for believable
characters. In: Proceedings of the 1st Joint International Conference on Interactive
Digital Storytelling: Interactive Storytelling. Berlin, Heidelberg: Springer-Verlag, 2008.
(ICIDS, ’08), p. 71–82. ISBN 978-3-540-89424-7.
FISIOBLOG. Tronco encefálico. 2012. Disponível em: <http://geafisioblog.blogspot.com.br/2012/07/tronco-encefalico.html>.
GALATI, D.; SINI, B.; SCHMIDT, S.; TINTI, C. Spontaneous facial expressions in
congenitally blind and sighted children aged 8-11. Journal of Visual Impairment &
Blindness, v. 97, n. 7, p. 418–28, 2003. ISSN 0145-482X.
GUENTER, B.; GRIMM, C.; WOOD, D.; MALVAR, H.; PIGHIN, F. Making faces.
In: Proceedings of the 25th annual conference on Computer graphics and interactive
techniques. New York, USA,: ACM, 1998. (SIGGRAPH, ’98), p. 55–66. ISBN
0-89791-999-8. Disponível em: <http://www.cse.wustl.edu/˜cmg/content/papers/sig1998mf/sig1998mf.pdf>.
HILL, D. R.; PEARCE, A.; WYVILL, B. Animating speech: an automated approach
using speech synthesised by rules. The Visual Computer, v. 3, n. 5, p. 277–289, mar.
1988. ISSN 0178-2789, 1432-2315.
99
HOETZLEIN, R. C. Imagination in Media Arts: Technological Constraints and Creative
Freedom. Tese (Doutorado) — University of Santa Barbara - California, fev. 2011.
HORN, B. K. P.; SCHUNCK, B. G. Determining optical flow. Cambridge, MA USA,
v. 17, p. 185–203, 1981.
HUANG, J.-H. Jen-Hsun Huang at GTC 2013. 2013. Disponível em: <http://blogs.nvidia.com/blog/2013/03/19/live-jen-hsun-huang-at-gtc-2013/>.
IURGEL, I. Virtual actor: Endowing virtual characters with a repertoire for acting. In:
SPIERLING, U.; SZILAS, N. (Ed.). Interactive Storytelling. Erfurt, Germany: Springer
Verlag, 2008. LNCS, 5334, p. 89–91.
IURGEL, I.; SILVA, R. da; SANTOS, M. dos. Towards virtual actors for acting
out stories. In: ZHANG, X.; ZHONG, S.; PAN, Z.; WONG, K.; YUN, R. (Ed.).
Entertainment for Education. Digital Techniques and Systems. [S.l.]: Springer Berlin
/ Heidelberg, 2010, (Lecture Notes in Computer Science, v. 6249). p. 570–581. ISBN
978-3-642-14532-2. 10.1007/978-3-642-14533-9_58.
IURGEL, I. A.; MARCOS, A. F. Employing personality-rich virtual persons—New,
tools required. Computers & Graphics, v. 31, n. 6, p. 827–836, dez. 2007. ISSN
0097-8493. Disponível em: <http://www.sciencedirect.com/science/article/pii/S0097849307001616>.
JOOSTEN, B.; POSTMA, E.; KRAHMER, E.; SWERS, M.; KIM, J. Automated
measurement of spontaneous surprise. In: Proceedings of Measuring Behavior 2012 : 8th
International Conference on Methods and Techniques in Behavioral Research. [S.l.]: The
Netherlands, Noldus Information Technology, 2012.
KALRA, P.; MANGILI, A.; THALMANN, N. M.; THALMANN, D. Simulation of facial
muscle actions based on rational free form deformations. In: Computer Graphics Forum,.
[S.l.: s.n.], 1992. v. 11, n. 3, p. 59–69. ISSN 0167-7055.
KASS, M.; WITKIN, A.; TERZOPOULOS, D. Snakes: Active contour models. In:
International Journal of Computer Vision. [s.n.], 1988. v. 1, n. 4, p. 321–331. ISSN
0920-5691, 1573-1405. Disponível em: <http://www.cs.ucla.edu/˜dt/papers/ijcv88/ijcv88.pdf>.
100
KENDON, A. Some functions of gaze-direction in social interaction. v. 26, n. 1, p. 22–63,
1967. ISSN 0001-6918.
KOPP, S. et al. Towards a common framework for multimodal generation: The behavior
markup language. In: Proceedings of the 6th international conference on Intelligent
Virtual Agents. Berlin, Heidelberg: Springer Berlin Heidelberg, 2006. p. 205–217. ISBN
978-3-540-37593-7, 978-3-540-37594-4.
KOUADIO, C.; POULIN, P.; LACHAPELLE, P. Real-time facial animation based upon
a bank of 3D, facial expressions. In: Computer Animation 98. Proceedings. Washington,
USA: IEEE, Computer Society, 1998. (CA, ’98), p. 128–136. ISBN 0-8186-8541-7.
Disponível em: <http://www.ligum.umontreal.ca/Kouadio-1998-RTFA/Kouadio-1998RTFA.pdf>.
KUMAR, A. Understanding Facial Expressions and Microexpressions. 2009. Disponível
em: <http://www.persuasive.net/it-is-written-all-over-your-face-understanding-facialexpressions>.
LARKIN, K. T.; ZAYFERT, C. Anger expression and essential hypertension: Behavioral
response to confrontation. Journal of Psychosomatic Research, v. 56, n. 1, p. 113 – 118,
2004. ISSN 0022-3999.
LEAL, S.; VRIJ, A. Blinking during and after lying. In: Journal of Nonverbal Behavior.
[s.n.], 2008. v. 32, n. 4, p. 187–194. ISSN 0191-5886, 1573-3653. Disponível em:
<http://link.springer.com/content/pdf/10.10072Fs10919-008-0051-0.pdf>.
LEE, Y.; TERZOPOULOS, D.; WATERS, K. Realistic modeling for facial animation.
In: Proceedings of the 22nd annual conference on Computer graphics and interactive
techniques. New York, USA: ACM, 1995. (SIGGRAPH, ’95), p. 55–62. ISBN
0-89791-701-4.
LEVENSON, R. W.; EKMAN, P.; FRIESEN, W. V. Voluntary facial action generates
emotion-specific autonomic nervous system activity. Psychophysiology, v. 27, n. 4, p.
363–384, jul. 1990. ISSN 0048-5772. PMID:, 2236440.
LOUCHART, S.; AYLETT, R. From synthetic characters to virtual actors. In: Artificial
Intelligence and Interactive Digital Entertainment Conference. [S.l.: s.n.], 2007. p. 88–93.
101
LOVAS, M. How to spot a dishonest face. 2009. Disponível em: <http://www.aboutpeople.com/wp-content/uploads/2012/03/Dishonest-Face.pdf>.
LUCERO, J. C.; MUNHALL, K. G. A model of facial biomechanics for speech
production. The Journal of the Acoustical Society of America, v. 106, p. 2834–2842, nov.
1999. ISSN 0001-4966.
MAGNENAT-THALMANN, N.; PRIMEAU, E.; THALMANN, D. Abstract muscle
action procedures for human face animation. The Visual Computer, v. 3, n. 5, p. 290–297,
mar. 1988. ISSN 0178-2789, 1432-2315.
MAGNENAT-THALMANN, N.; THALMANN, D. Handbook of virtual humans.
England: John Wiley & Sons Inc, 2004.
MARSH, A. A.; ADAMS, R. B.; KLECK, R. E. Why do fear and anger look the way
they do? form and social function in facial expressions. Personality and Social Psychology
Bulletin, v. 31, n. 1, p. 73–86, jan. 2005. ISSN 0146-1672, 1552-7433.
MARTINO, J. M. Animação facial sincronizada com a fala: visemas dependentes
do contexto fonetico para o portugues do Brasil. Disserta (Tese de Doutorado) —
Universidade Estadual de Campinas, jul. 2005.
MATSUMOTO, D. Face, culture, and judgments of anger and fear: Do the eyes have
it? Journal of Nonverbal Behavior, v. 13, n. 3, p. 171–188, set. 1989. ISSN 0191-5886,
1573-3653.
MATSUMOTO, D.; WILLINGHAM, B. Spontaneous facial expressions of emotion of
congenitally and noncongenitally blind individuals. Journal of personality and social
psychology, v. 96, n. 1, p. 1–10, jan. 2009. ISSN 0022-3514.
MAURY-ROUAN, C.; HIRST, D.; FARACO, M. Eyebrow raisings and vocal pitch
accent : the case of children blind from birth. 2009 IEEE 8TH INTERNATIONAL
CONFERENCE ON DEVELOPMENT AND LEARNING 1 Learning to Make Facial
Expressions, p. 1–7, 2005.
MAY, S. F.; CARLSON, W. E.; PHILLIPS, F.; SCHEEPERS. A language for
procedural modeling and animation. Ohio, USA, p. 1–11, december 1996. Disponível em:
<http://accad.osu.edu/˜smay/al.pdf>.
102
MAYA. Visão geral Autodesk Maya. 2013. Disponível em: <http://www.autodesk.com.br/products/autodesk-maya/overview>.
McDougall, W. An Introduction to Social Psychology. [S.l.]: J.W., Luce & Company,
1921.
MCKAY, M.; ROGERS, P. D.; MCKAY, J. When Anger Hurts: Quieting the Storm
Within, 2nd Edition. Second edition. [S.l.]: New Harbinger Publications, 2003. ISBN
1572243449.
MOORE, K. L.; DALLEY, A. F. Anatomia orientada para a clínica. 4. ed. [S.l.]:
Guanabara Koogan, 2006. ISBN 9788527716970.
OLIVEIRA, E. Captura de expressões faciais para identificação de emoções básicas em
humanos. Disserta (Bacharel) — Universidade do Vale do Rio dos Sinos, 2008.
OSIPA, J. Stop Staring: Facial Modeling and Animation Done Right. 3. ed. [S.l.]: John
Wiley & Sons, 2010. ISBN 9780470939611.
PARENT, R. Computer Animation: Algorithms and Techniques. [S.l.]: Morgan
Kaufmann, 2001. ISBN 9780080502502.
PARKE. Parameterized models for facial animation. Computer Graphics and
Applications, v. 2, n. 9, p. 61–68, nov 1982. ISSN 0272-1716.
PARKE, F. I. Computer generated animation of faces. 451 p. Disserta (Tese de Mestrado)
— Utah University, jun. 1972.
PARKE, F. I.; WATERS, K. Computer Facial Animation. 2. ed. [S.l.]: A K Peters/CRC,
Press, 2008. ISBN 1568814488.
PEASE, A.; PEASE, B. Linguagem Corporal – Porque é que os Homens Coçam as
Orelhas e As Mulheres Mexem na Aliança. 3a. ed. [S.l.]: Bizancio, 2009. 432 p. ISBN
972-53-0271-0.
PERLIN, K.; SEIDMAN, G. Autonomous digital actors. In: EGGES, A.; KAMPHUIS,
A.; OVERMARS, M. (Ed.). Motion in Games. [S.l.]: Springer Berlin / Heidelberg, 2008,
(Lecture Notes in Computer Science, v. 5277). p. 246–255. ISBN 978-3-540-89219-9.
103
PIMENTEL, R. C.; MAGALHãES, L. P.; MARTINO, J. M. d. Sistema de animação
facial biomecânica. Reverte - Revista de Estudos e Reflexões Tecnológicas da Faculdade
de Indaiatuba, v. 0, n. 6, dec 2008.
PING, H. Y.; ABDULLAH, L. N. Computer facial animation: A review. In: International
Journal of Computer Theory and Engineering. [S.l.: s.n.], 2013. v. 5, n. 4, p. 658–662.
PLATT, S. M.; BADLER, N. I. Animating facial expressions. SIGGRAPH, Comput.
Graph., v. 15, n. 3, p. 245–252, ago. 1981. ISSN 0097-8930.
POLLAK, S. D.; SINHA, P. Effects of early experience on children’s recognition of facial
displays of emotion. Developmental Psychology, v. 38, n. 5, p. 784–791, 2002. ISSN
1939-0599(Electronic);0012-1649(Print).
PRINZ, J. Which emotions are basic? In: Emotion, Evolution, and Rationality. [S.l.]:
Oxford University Press, 2004. p. 70–89. ISBN 9780198528975.
QUEIROS, C. Emoções e comportamento desviante: um estudo na perspectiva da
personalidade como sistema auto-organizador. Disserta (Doutorado) — Universidade do
Porto, 1997.
RINN, W. The neurophysiology of facial expression: A review of the neurological and
psychological mechanisms for producing facial expressions. In: Psychological Bulletin.
[S.l.: s.n.], 1984. v. 95, p. 52–77.
RODRIGUES, P. L.; FEIJO, B.; VELHO, L. : Expressive talking heads: uma ferramenta
de animação com fala e expressão facial sincronizadas para o desenvolvimento de
aplicações interativas. In: IX Simpósio Brasileiro de Sistemas Multimídia e Web. [s.n.],
2003. Disponível em: <http://www.telemidia.puc-rio.br/sites/telemidia.puc-rio.br/files/2003 11 lucena webmidia.pdf>.
ROSENBERG, E. L.; EKMAN, P.; BLUMENTHAL, J. A. Facial expression and the
affective component of cynical hostility in male coronary heart disease patients. Health
psychology: official journal of the Division of Health Psychology, American Psychological
Association, v. 17, n. 4, p. 376–380, jul. 1998. ISSN 0278-6133. PMID:, 9697948.
SADR, J.; JARUDI, I.; SINHA, P. The role of eyebrows in face recognition. Perception,
v. 32, n. 3, p. 285–293, 2003. ISSN 0301-0066. PMID:, 12729380.
104
SANTOS, C. S. V. Psicofisiologia das emoções básicas: estudo empírico com
toxicodependentes em tratamento. Disserta (Mestrado) — Universidade Fernando Pessoa,
2009.
SCHNEIDER, D. D. G. O desempenho de adultos jovens e idosos na tarefa do jogo : um
estudo sobre tomada de decisão. 2004.
SEVIN, E. de; THALMANN, D. A motivational model of action selection for virtual
humans. In: Proceedings of the Computer Graphics International 2005. Washington,
USA: IEEE, Computer Society, 2005. (CGI, ’05), p. 213–220. ISBN 0-7803-9330-9.
SILVA, R. E. d. D.r.a.m.a. - developing rational agents to mimic actors. In: SBC Proceedings of SBGames 2012. Joinville, Brasil: SBGames, 2012.
SILVEIRA, R. D.; MELO, W. V. Sintomas depressivos e o processamento emocional de
expressões faciais. Disserta (Graduação) — FACCAT, 2010. Disponível em: <https://psicologia.faccat.br/moodle/pluginfile.php/197/course/section/101/rafaela.pdf>.
SOUZA, M. Quadrinhos - Tira 331. 2013. Disponível em: <http://www.monica.com.br/cookpage/cookpage.cgi?!pag=comics/tirinhas/tira331>.
SPIERLING, U. Interactive digital storytelling: Towards a hybrid conceptual approach.
In: International DiGRA, Conference. [S.l.: s.n.], 2005.
SUSSKIND, J. M. et al. Expressing fear enhances sensory acquisition. Nature
Neuroscience, v. 11, n. 7, p. 843–850, jul. 2008. ISSN 1097-6256.
TAKASHIMA, K. et al. Effects of avatar’s blinking animation on person impressions.
In: Proceedings of graphics interface 2008. Toronto, Ont., Canada, Canada: Canadian
Information Processing Society, 2008. (GI ’08), p. 169–176. ISBN 978-1-56881-423-0.
Disponível em: <http://www-human.ist.osaka-u.ac.jp/CNSE/paper/GI08.pdf>.
TERZOPOULOS, D.; WATERS, K. Physically-based facial modelling, analysis, and
animation. In: Journal of Visualization and Computer Animation. [s.n.], 1990. v. 1, n. 2,
p. 73–80. ISSN 1099-1778. Disponível em: <http://www.csie.ntu.edu.tw/˜r96944046/paper/face/vca90.pdf>.
THALMANN, N. M.; CAZEDEVALS, A.; THALMANN, D. Modelling facial
communication between an animator and a synthetic actor in real time. In:
105
FALCIDIENO, D. B.; KUNII, P. D. T. L. (Ed.). Modeling in Computer Graphics.
Springer Berlin Heidelberg, 1993, (IFIP, Series on Computer Graphics). p. 387–396.
ISBN 978-3-642-78116-2, 978-3-642-78114-8. Disponível em: <http://infoscience.epfl.ch/record/102432/files/Magnenat Thalmann and al IFIP 93.pdf>.
THUME, G. S.; SILVA, R. E. d. An extended EBDI, model applied to autonomous
digital actors. In: XI, Brazilian Symposium on Games and Digital Entertainment.
Brasilia, DF, Brazil: [s.n.], 2012.
TORRES, J. A. R.; MACIEL, A.; NEDEL, L. P. Uma arquitetura para animação de
humanos virtuais com raciocínio cognitivo. p. 12, 2002.
TRUTOIU, L. C.; CARTER, E. J.; MATTHEWS, I.; HODGINS, J. K. Modeling and
animating eye blinks. In: ACM Transactions on Applied Perception 8. [s.n.], 2011. v. 8,
n. 3. ISSN 1544-3558. Disponível em: <http://drp.disneyresearch.com/projects/blinks/apgv tap trutoiu preprint.pdf>.
TUCKER, D. M.; DERRYBERRY, D.; LUU, P. Anatomy and physiology of human
emotion: Vertical integration of brainstem, limbic, and cortical systems. In: The
neuropsychology of emotion. New York, US: Oxford University Press, 2000, (Series in
affective science.). p. 56–79. ISBN 0-19-511464-7.
VERTEGAAL, R.; SLAGTER, R.; VEER, G. van der; NIJHOLT, A. Eye gaze patterns in
conversations: there is more to conversational agents than meets the eyes. In: Proceedings
of the SIGCHI, Conference on Human Factors in Computing Systems. New York, USA:
ACM, 2001. (CHI, ’01), p. 301–308. ISBN 1-58113-327-8. Disponível em: <http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.14.4868rep=rep1type=pdf>.
VILHJALMSSON, H. et al. The behavior markup language: Recent developments
and challenges. In: Proceedings of the 7th international conference on Intelligent
Virtual Agents. Berlin, Heidelberg: Springer-Verlag, 2007. (IVA, ’07), p. 99–111.
ISBN 978-3-540-74996-7. Disponível em: <http://www.dfki.de/˜kipp/public archive/BML IVA07 CameraReady.pdf>.
WATERS, K. A muscle model for animation three-dimensional facial expression.
SIGGRAPH, Comput. Graph., v. 21, n. 4, p. 17–24, ago. 1987. ISSN 0097-8930.
106
WEISE, T.; BOUAZIZ, S.; LI, H.; PAULY, M. Realtime performance-based facial
animation. In: ACM SIGGRAPH 2011 papers. New York, USA: ACM, 2011.
(SIGGRAPH, ’11), p. 77–87. ISBN 978-1-4503-0943-1. Disponível em: <lgg.epfl.ch/˜bouaziz/pdf/RPBFA SIGGRAPH2011.pdf>.
WILLIAMS, L. Performance-driven facial animation. In: SIGGRAPH 90 Proceedings of
the 17th annual conference on Computer graphics and interactive techniques. [S.l.: s.n.],
1990. v. 24, n. 4, p. 235–242. ISSN 0097-8930.
ZHAO, Y. Human Emotion Recognition from Body Language of the Head using Soft
Computing Techniques. Disserta (Doutorado) — University of Ottawa, 2012.
ZHU, Z.; JI, Q. Eye and gaze tracking for interactive graphic display. In: Machine Vision
and Applications. [s.n.], 2004. v. 15, n. 3, p. 139–148. ISSN 0932-8092. Disponível em:
<http://www.ecse.rpi.edu/homepages/qji/Papers/gaze.pdf>.
ZIMPRICH, D.; MASCHEREK, A. Anger expression in swiss adolescents: establishing
measurement invariance across gender in the AX, scales. Journal of adolescence, v. 35,
n. 4, p. 1013–1022, ago. 2012. ISSN 1095-9254. PMID:, 22410126.
107
A Apêndice
Figura A.1: Arquitetura do projeto D.R.A.M.A.
108
Fonte: Projeto D.R.A.M.A.
A.1
Arquivo de entrada utilizado para Experimentação
1
2
3
4
5
6
7
8
9
10
11
<ator nome="brad">
<acao nome="acao1" inicio="1" fim="120">
<falar>
<visema>
<tempo>1</tempo>
<x>0</x>
<y>0</y>
</visema>
<visema>
<tempo>9</tempo>
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
<x>0.4</x>
<y>-0.8</y>
</visema>
<visema>
<tempo>14</tempo>
<x>0.13</x>
<y>0.35</y>
</visema>
<visema>
<tempo>18</tempo>
<x>-0.6</x>
<y>-0.8</y>
</visema>
<visema>
<tempo>22</tempo>
<x>0.9</x>
<y>-0.8</y>
</visema>
<visema>
<tempo>26</tempo>
<x>0.3</x>
<y>0</y>
</visema>
<visema>
<tempo>29</tempo>
<x>-0.6</x>
<y>-0.7</y>
</visema>
<visema>
<tempo>32</tempo>
<x>0.4</x>
<y>0</y>
</visema>
<visema>
<tempo>38</tempo>
<banco>banco</banco>
</visema>
<visema>
<tempo>45</tempo>
<x>0.1</x>
<y>-0.2</y>
</visema>
<visema>
<tempo>52</tempo>
<x>-0.5</x>
<y>-0.9</y>
</visema>
<visema>
<tempo>60</tempo>
<x>0</x>
<y>0</y>
</visema>
</falar>
<orientacao>cima</orientacao>
<angulo>60</angulo>
109
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
<velocidade>alta</velocidade>
</cabeca>
<vezes>6</vezes>
<orientacao>negativo</orientacao>
</cabeca>
<orientacao>baixo</orientacao>
<angulo>30</angulo>
</cabeca>
<alvo>MetalFly_v1_0:MetalFly_global</alvo>
</cabeca>
<alvo>0,36.3,9</alvo>
</cabeca>
<alvo>-1,36,9</alvo>
</cabeca>
<alvo>-1.5,35.5,9</alvo>
</cabeca>
<alvo>-0.3,34,8</alvo>
</cabeca>
<alvo>6, 32, 6</alvo>
</cabeca>
<alvo>13, 38, -4</alvo>
</cabeca>
<alvo>-2, 38, 8</alvo>
</cabeca>
<alvo>0, 36, 9</alvo>
</cabeca>
<vezes>5</vezes>
<orientacao>positivo</orientacao>
</cabeca>
<piscar inicio="700" velocidade="media" />
<piscar inicio="750" velocidade="media" />
<piscar inicio="790" velocidade="alta" />
110
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
<piscar inicio="810" velocidade="alta" />
<emocao inicio="1" fim="39">
<nome>Neutra</nome>
</emocao>
</emocao>
<nome>Raiva</nome>
</emocao>
</emocao>
<nome>Neutra</nome>
</emocao>
<nome>Aversao</nome>
</emocao>
<nome>Desprezo</nome>
</emocao>
</emocao>
<nome>Medo</nome>
</emocao>
<nome>Raiva</nome>
</emocao>
</emocao>
<nome>Triste</nome>
</emocao>
<nome>Medo</nome>
<nome>Desprezo</nome>
</emocao>
</acao>
</ator>
111
183
</scene>
Algoritmo A.1: Arquivo de entrada utilizado para Experimentação
112
A.2 Código-fonte do plugin desenvolvido
A.2
1
2
3
4
5
6
7
8
113
Código-fonte do plugin desenvolvido
# Declaracoes
import random
import maya.cmds as cmds
import maya.mel as mel
import xml.etree.ElementTree as ET
from xml.etree.ElementTree import Element, SubElement
# Use mel language in python
selection = cmds.ls( sl=True )
9
10
11
# Define caminho dos arquivos de entrada e saida
FILE_PATH = ’E:/Dropbox/Dropbox/Drama/alunos/Rogerio Willians/TCC-II/’
12
13
14
15
16
# Carrega XML
tree = ET.parse(FILE_PATH + ’animation.xml’)
root = tree.getroot()
piscadas = []
17
18
19
20
21
22
’’’#-=-=-=-=-=-=-=-=-=-=#
////=-=-=-=-=-=-=-=-=-=-#
#### MODULO DE TRADUCAO #
////=-=-=-=-=-=-=-=-=-=-#
’’’#-=-=-=-=-=-=-=-=-=-=#
23
24
#--------------------------------------------------------------------------------------#
25
# Gera o BML
for ada in root.iter(’ator’):
piscadas[:] = []
#-----------#
# Cria ADAs #
#-----------#
nome = ada.attrib[’nome’]
sub_ada = SubElement(root, "ada", id=nome)
#------------#
# Cria Acoes #
#------------#
for acao in ada.iter(’acao’):
fim = acao.attrib[’fim’]
inicio = acao.attrib[’inicio’]
nome = acao.attrib[’nome’]
sub_acao = SubElement(sub_ada, "action", id=nome, start=inicio, end=fim)
#----------------------------#
# Cria Emocoes (uma ou mais) #
#----------------------------#
for emocao in acao.iter(’emocao’):
# Seta o tempo final, verificando se e’ tempo de uma acao
fim = emocao.attrib[’fim’]
if fim[:4] == ’acao’:
for f in ada.iter(’acao’):
if f.get(’nome’) == fim:
fim = f.get(’fim’)
# Seta o tempo inicial, verificando se e’ tempo de uma acao
inicio = emocao.attrib[’inicio’]
if inicio[:4] == ’acao’:
for ini in ada.iter(’acao’):
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
if ini.get(’nome’) == inicio:
inicio = ini.get(’inicio’)
# Busca a qtd de emocoes do cabeca
qtd = len(list(emocao.iter(’intensidade’)))
# Se tiver somente uma emocao, chama funcao emotion
if qtd == 1:
sub_emocao = SubElement(sub_acao, "emotion", start=inicio, end=fim)
for intensidade in emocao.iter(’intensidade’):
it = intensidade.text
for nome in emocao.iter(’nome’):
nm = nome.text
intensity = SubElement(sub_emocao, "intensity")
intensity.text = it
nome = SubElement(sub_emocao, "name")
nome.text = nm
# Se tiver mais de uma emocao, chama funcao emotion_blend
else:
sub_emocao = SubElement(sub_acao, "emotion_blend", start=inicio, end=
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
fim)
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
114
countA = 1
countB = 1
for intensidade in emocao.iter(’intensidade’):
it = intensidade.text
for nome in emocao.iter(’nome’):
if countA == countB:
nm = nome.text
intensity = SubElement(sub_emocao, "intensity")
intensity.text = it
nome = SubElement(sub_emocao, "name")
nome.text = nm
countB +=1
countA += 1
countB = 1
#---------------------------#
# Cria movimentos da cabeca #
#---------------------------#
for cabeca in acao.iter(’cabeca’):
if cabeca.attrib[’movimento’] != ’acenar’:
fim = cabeca.attrib[’fim’]
inicio = cabeca.attrib[’inicio’]
# Define tipo do movimento
if cabeca.attrib[’movimento’] == ’olhar’:
for alvo in cabeca.iter(’alvo’):
# Olhar coordenada
if alvo.text.find(’,’)!= -1:
sub_cabeca = SubElement(sub_acao, "head_coordinate", start=
inicio, end=fim)
115
xyz = alvo.text
for velocidade in cabeca.iter(’velocidade’):
velo = velocidade.text
coordinate = SubElement(sub_cabeca, "coordinate")
coordinate.text = xyz
speed = SubElement(sub_cabeca, "speed")
speed.text = velo
# Olhar Objeto
else:
sub_cabeca = SubElement(sub_acao, "head_object", start=inicio,
110
111
112
113
114
115
116
117
118
119
end=fim)
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
target = alvo.text
tg = SubElement(sub_cabeca, "target")
tg.text = target
# Acenar
if cabeca.attrib[’movimento’] == ’acenar’:
for vezes in cabeca.iter(’vezes’):
repeticoes = vezes.text
for orientacao in cabeca.iter(’orientacao’):
orient = orientacao.text
sub_cabeca = SubElement(sub_acao, "head_shake", start=inicio)
repete = SubElement(sub_cabeca, "repete")
repete.text = repeticoes
orientation = SubElement(sub_cabeca, "orientation")
orientation.text = orient
speed.text = velo
# Inclinar
if cabeca.attrib[’movimento’] == ’inclinar’:
for angulo in cabeca.iter(’angulo’):
ang = angulo.text
for orientacao in cabeca.iter(’orientacao’):
orient = orientacao.text
sub_cabeca = SubElement(sub_acao, "head_tilt", start=inicio, end=fim)
angle = SubElement(sub_cabeca, "angle")
angle.text = ang
orientation = SubElement(sub_cabeca, "orientation")
orientation.text = orient
speed.text = velo
#-------------------------#
# Cria movimentos do olho #
#-------------------------#
for olhos in acao.iter(’olhos’):
fim = olhos.attrib[’fim’]
inicio = olhos.attrib[’inicio’]
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
# Define se e’ coordenada ou objeto
for alvo in olhos.iter(’alvo’):
# Olhar coordenada
if alvo.text.find(’,’)!= -1:
sub_olhar = SubElement(sub_acao, "gaze_coordinate", start=inicio,
end=fim)
xyz = alvo.text
coordinate = SubElement(sub_olhar, "coordinate")
coordinate.text = xyz
speed = SubElement(sub_olhar, "speed")
speed.text = velo
# Olhar Objeto
else:
sub_olhar = SubElement(sub_acao, "gaze_object", start=inicio, end=
fim)
target = alvo.text
tg = SubElement(sub_olhar, "target")
tg.text = target
#-------#
# Frase #
#-------#
for frases in acao.iter(’falarfrase’):
frase = frases.attrib[’frase’]
start = frases.attrib[’inicio’]
duration = frases.attrib[’duracao’]
#-----------------------------------------------------------------#
#-----------------------------------------------------------------#
’’’
Aqui deve ser implementado o sistema de interpretacao que ira’
traduzir frases em visemas, aonde cada visema tera’ um tempo
definido para sua reproducao, e estara’ dentro de uma frase.
200
201
202
A entrada seria a frase em formato de string, o tempo de inicio
e a duracao da frase.
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
116
A saida devera’ seguir o padrao (podendo ser tanto uma coordenada
representando abertura/fechamento e larga/estreita, ou um visema
do banco de animacao):
<ada id="brad">
<action start="1" end="120" id="acao1">
<speak>
<viseme>
<time>220</time>
<x>0</x>
<y>0</y>
</viseme>
<viseme>
<time>225</time>
<database>banco</database>
</viseme>
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
</speak>
</action>
</ada>
</scene>
’’’
#-----------------------------------------------------------------#
#-----------------------------------------------------------------#
#-------#
# Falar #
#-------#
for falar in acao.iter(’falar’):
sub_frase = SubElement(sub_acao, "speak")
for visema in falar.iter(’visema’):
sub_visema = SubElement(sub_frase, "viseme")
for tempo in visema.iter(’tempo’):
time = tempo.text
tt = SubElement(sub_visema, "time")
tt.text = time
for xx in visema.iter(’x’):
x = xx.text
xxx = SubElement(sub_visema, "x")
xxx.text = x
for yy in visema.iter(’y’):
y = yy.text
yyy = SubElement(sub_visema, "y")
yyy.text = y
for banco in visema.iter(’banco’):
database = banco.text
dat = SubElement(sub_visema, "database")
dat.text = database
for vis in visema.iter(’vis’):
v = vis.text
vi = SubElement(sub_visema, "vis")
vi.text = v
#-----------------#
# Piscar de olhos #
#-----------------#
for piscar in acao.iter(’piscar’):
# Seta velocidade do piscar de olhos
velo = piscar.attrib[’velocidade’]
inicio = piscar.attrib[’inicio’]
piscadas.append(inicio)
sub_piscar = SubElement(sub_ada, "blink", start=inicio, speed=velo)
#-------------------------------#
# Cria demais piscadas de olhos #
#-------------------------------#
cena_fim = int(root.attrib[’end’])
atual = 0
while atual < cena_fim :
aux = random.randint(48, 240) # piscada aleatoria entre 2 e 10 segundos
atual += aux
ok = True
117
278
279
280
281
282
118
for piscada in piscadas:
if (atual -48) < int(piscada) < (atual + 48):
ok = False
if ok and atual < cena_fim:
sub_piscar = SubElement(sub_ada, "blink", start=str(atual), speed=’alta’)
283
284
285
286
# Remove os elementos do xml antigo
for ada in root.findall(’ator’):
root.remove(ada)
287
288
tree.write(FILE_PATH + ’output.bml’)
289
290
291
292
293
294
’’’#-=-=-=-=-=-=-=-=-=-=-#
////=-=-=-=-=-=-=-=-=-=-=#
#### FUNCOES DE ANIMACAO #
////=-=-=-=-=-=-=-=-=-=-=#
’’’#-=-=-=-=-=-=-=-=-=-=-#
295
296
297
298
# Abre arquivo BML
tree = ET.parse(FILE_PATH + ’output.bml’)
root = tree.getroot()
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
#--------#
# EMOCAO #
#--------#
def emotion(inicio, fim, intensidade, emocao, personagem):
# Lista de controladores do Personagem
controles_lista = [personagem+’:browEmotion_control’,personagem+’:eyebrows_control
’,personagem+’:upperLip_control’,personagem+’:lowerLip_control’,personagem+’:
mouthEmotion_control’,personagem+’:sync_control’,personagem+’:upperLids’,
personagem+’:lowerLids’,personagem+’:sneer_control’]
# Aumenta inicio e fim para criar as transicoes entre emocoes
fim += 5
if inicio > 5:
inicio -= 5
# Aplica a pose
for atual in range(inicio,fim+1):
cmds.currentTime(atual)
cmds.pose( personagem+’_face’, name=emocao, apply=True )
# Percorre os controladores, definindo a intensidade escolhida em cada um
for controle in controles_lista:
posX = cmds.getAttr(controle+’.translateX’)
posY = cmds.getAttr(controle+’.translateY’)
cmds.setAttr(controle+’.translateX’,posX*intensidade)
cmds.setAttr(controle+’.translateY’,posY*intensidade)
# Grava a pose na linha de tempo
cmds.setKeyframe( [personagem+’:browEmotion_control’
,personagem+’:eyebrows_control’
,personagem+’:upperLip_control’
,personagem+’:lowerLip_control’
,personagem+’:mouthEmotion_control’
,personagem+’:sync_control’
,personagem+’:upperLids’
,personagem+’:lowerLids’
,personagem+’:mouthLeftRight_control’
,personagem+’:jawLeftRight_control’
,personagem+’:jawInOut_control’
332
333
334
335
336
337
338
119
,personagem+’:sneer_control’]
,t=(atual,atual))
# Nomenclatura do clipe
qtd_clipes = 0
nome_clipes = cmds.clip( personagem+’_face’, query=True, n=True)
if nome_clipes > 0:
qtd_clipes = len(nome_clipes) # quantidade de clipes para nomenclatura
339
340
341
342
# Cria o clipe e NAO COLOCA NO SCHEDULE
nome_clipe = ’Emocao_clipe_’+ str(qtd_clipes)
cmds.clip( personagem+’_face’, startTime=inicio, endTime=fim, name=nome_clipe,
allAbsolute=True, sc=False )
343
344
345
346
# Usa o clipe (instancia no coloca no SCHEDULE)
scheduler_name = cmds.character( personagem+’_face’,query=True, sc=True ) # busca
nome do scheduler do personagem
cmds.clipSchedule( scheduler_name, instance=nome_clipe+’Source’, s=inicio,
allAbsolute=True)
347
348
349
# Pega o clip index do clipe atual
clip_index_atual = mel.eval( ’clipSchedule -name ’+ nome_clipe +’ -q -ci ’+
scheduler_name ) # linguagem mel
350
351
352
353
# Pega o tempo de inicio e fim do clipe atual
ci_atual_start = cmds.clipSchedule( scheduler_name, ci=clip_index_atual, query=
True, sourceStart=True)
ci_atual_end
= cmds.clipSchedule( scheduler_name, ci=clip_index_atual, query=
True, sourceEnd=True)
354
355
356
# Percorre por todos os dados dos clipes, procurando cenas que tenham pontos em
comum.
clip_indexes = cmds.clipSchedule( scheduler_name, query=True)
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
for clip_index in clip_indexes:
clip_argument = clip_index.split(’,’)
#print clip_argument[0] #-> clipName
#print clip_argument[1] #-> clipIndex
#print clip_argument[2] #-> clipStart
#print clip_argument[3] #-> clipSourceStart
#print clip_argument[4] #-> clipSourceEnd
#print clip_argument[5] #-> clipScale
#print clip_argument[6] #-> clipPreCycle
#print clip_argument[7] #-> clipPostCycle
#print clip_argument[8] #-> clipHold
if clip_argument[1] != str(clip_index_atual):
# Se o clipe verificado estiver entre o clip atual
if ci_atual_start <= float(clip_argument[3]) <= ci_atual_end or
ci_atual_start <= float(clip_argument[4]) <= ci_atual_end:
# Faz o blend das cenas.
cmds.clipSchedule( scheduler_name, b=(clip_index_atual,int(
clip_argument[1])))
374
375
376
377
#log
print ’--- Done Emotion( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(intensidade) +’,
’+ str(emocao) +’, ’+ str(personagem) +’)’
##------------------------------------------------------------------------------------------------
378
379
380
381
120
def emotion_blend(inicio, fim, personagem, values, *vartuple):
fim += 5
if inicio > 5:
inicio -= 5
382
383
384
385
#print values #-> primeiro valor da lista de tuplas com [intesidade, emocao]
#print var[0] #-> intesidade
#print var[1] #-> emocao
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
# Lista de controladores do Personagem
controles_lista = [personagem+’:browEmotion_control’,personagem+’:eyebrows_control
’,personagem+’:upperLip_control’,personagem+’:lowerLip_control’,personagem+’:
mouthEmotion_control’,personagem+’:sync_control’,personagem+’:upperLids’,
personagem+’:lowerLids’,personagem+’:sneer_control’]
# Aplica pose no inicio
cmds.currentTime(inicio)
cmds.pose( personagem+’_face’, name=values[1], apply=True )
cmds.setAttr(controle+’.translateX’,posX*values[0])
cmds.setAttr(controle+’.translateY’,posY*values[0])
,t=inicio)
atual = inicio
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
# percorre demais emocoes
for var in vartuple:
# Aplica pose um frame a frente
atual += 1
cmds.pose( personagem+’_face’, name=var[1], apply=True )
cmds.setAttr(controle+’.translateX’,posX*var[0])
cmds.setAttr(controle+’.translateY’,posY*var[0])
432
433
434
435
436
437
438
439
,t=atual)
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
# Faz o blend entre a posicao inicial e a posicao atual, no frame inicial
x_inicio = cmds.getAttr(controle+’.translateX’)
y_inicio = cmds.getAttr(controle+’.translateY’)
x_atual = cmds.getAttr(controle+’.translateX’)
y_atual = cmds.getAttr(controle+’.translateY’)
cmds.setAttr(controle+’.translateX’,(x_inicio+x_atual)/2)
cmds.setAttr(controle+’.translateY’,(y_inicio+y_atual)/2)
,t=inicio)
# Percorre todos os frames aplicando a pose
for momento in range(inicio+1, fim):
# Pega posicao do frame inicial
x_start = cmds.getAttr(controle+’.translateX’)
y_start = cmds.getAttr(controle+’.translateY’)
# Copia posicao para demais frames
cmds.currentTime(momento)
cmds.setAttr(controle+’.translateX’,x_start)
cmds.setAttr(controle+’.translateY’,y_start)
121
489
490
491
492
493
494
122
,t=momento)
qtd_clipes = 0
if nome_clipes > 0:
495
496
497
498
nome_clipe = ’Blend_clipe_’+ str(qtd_clipes)
499
500
501
502
allAbsolute=True)
503
504
505
# Pega o clip index do clipe atual
clip_index_atual = mel.eval( ’clipSchedule -name ’+ nome_clipe +’ -q -ci ’+
scheduler_name ) # linguagem mel
506
507
508
509
# Pega o tempo de inicio e fim do clipe atual
ci_atual_start = cmds.clipSchedule( scheduler_name, ci=clip_index_atual, query=
True, sourceStart=True)
ci_atual_end
= cmds.clipSchedule( scheduler_name, ci=clip_index_atual, query=
True, sourceEnd=True)
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
# Percorre por todos os dados dos clipes, procurando cenas que tenham pontos em
comum.
clip_indexes = cmds.clipSchedule( scheduler_name, query=True)
for clip_index in clip_indexes:
clip_argument = clip_index.split(’,’)
#print clip_argument[0] #-> clipName
#print clip_argument[1] #-> clipIndex
#print clip_argument[2] #-> clipStart
#print clip_argument[3] #-> clipSourceStart
#print clip_argument[4] #-> clipSourceEnd
#print clip_argument[5] #-> clipScale
#print clip_argument[6] #-> clipPreCycle
#print clip_argument[7] #-> clipPostCycle
#print clip_argument[8] #-> clipHold
if clip_argument[1] != str(clip_index_atual):
# Se o clipe verificado estiver entre o clip atual
if ci_atual_start <= float(clip_argument[3]) <= ci_atual_end or
ci_atual_start <= float(clip_argument[4]) <= ci_atual_end:
# Faz o blend das cenas.
cmds.clipSchedule( scheduler_name, b=(clip_index_atual,int(
clip_argument[1])))
#log
print ’--- Done emotion_blend( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(personagem)
+’)’
#------------------------#
# MOVIMENTACAO DA CABECA #
#------------------------#
def cabeca_coordenada(inicio, fim, x, y, z, velocidade, personagem):
if velocidade == ’baixa’:
536
537
538
539
540
541
542
543
544
545
546
547
548
549
123
pulo = 24
if velocidade == ’media’:
pulo = 12
if velocidade == ’alta’:
pulo = 5
inicio = inicio + pulo
# Pega a rotacao do olho
rX = cmds.getAttr(personagem+’:blake_rightEye’ +’.rotateX’)
rY = cmds.getAttr(personagem+’:blake_rightEye’ +’.rotateY’)
# vai um frame a frente e aplica movimento dos olhos, para verificar o
deslocamento
headX = cmds.getAttr(personagem+’:head_target’+’.translateX’)
headY = cmds.getAttr(personagem+’:head_target’+’.translateY’) + 1
headZ = cmds.getAttr(personagem+’:head_target’+’.translateZ’)
550
551
552
553
cmds.move (x,y,z, personagem+’:Eye_Target’)
new_rX = cmds.getAttr(personagem+’:blake_rightEye’ +’.rotateX’)
new_rY = cmds.getAttr(personagem+’:blake_rightEye’ +’.rotateY’)
554
555
556
557
558
559
# Verifica se esta dentro do campo de visao
deslocamento_rX = False
deslocamento_rY = False
#print ’new_rX = ’ + str(new_rX)
#print ’new_rY = ’ + str(new_rY)
560
561
562
563
564
if (-790 <= new_rX <= -710) or (-400 <= new_rX <= -345):
deslocamento_rX = True
if (-465 <= new_rY <= -420):
deslocamento_rY = True
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
# Verifica se o deslocamento esta’ dentro do campo aonde o olho alcanca
if deslocamento_rX == True and deslocamento_rY == True :
# Se for possivel somente mover os olhos, chamar olhos_coordenada
olhos_coordenada(inicio-pulo, fim, x, y, z, velocidade, personagem)
else:
# Se nao for possivel somente mover os olhos, move toda cabeca.
cmds.move (x,y,z, personagem+’:head_target’)
cmds.setKeyframe( personagem+’:head_target’, t=inicio)
cmds.currentTime(fim)
cmds.move (x,y,z, personagem+’:head_target’)
cmds.setKeyframe( personagem+’:head_target’, t=fim)
#log
print ’--- Done cabeca_coordenada( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(x) +’,
’+ str(y) +’, ’+ str(z) +’, ’+ str(velocidade) +’, ’ + str(personagem) +’)’
##---------------------------------------------------------------------------------------------##
def cabeca_objeto(inicio, fim, objeto, personagem):
for atual in range(inicio,fim+1):
# Pega posicao do objeto
X = cmds.getAttr(objeto+’.translateX’)
Y = cmds.getAttr(objeto+’.translateY’)
Z = cmds.getAttr(objeto+’.translateZ’)
# Define olhar para o objeto
cmds.move (X,Y,Z, personagem+’:head_target’)
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
# Seta keyframe
cmds.setKeyframe( personagem+’:head_target’, t=atual)
#log
print ’--- Done cabeca_objeto( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(objeto) +’,
’ + str(personagem) +’)’
##---------------------------------------------------------------------------------------------##
def cabeca_aceno(inicio, vezes, orientacao, velocidade, personagem):
pulo = 12
pulo = 8
pulo = 5
if orientacao == ’positivo’:
for vez in range(vezes):
cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio)
607
608
609
610
611
612
613
inicio += pulo/2
cmds.move (-5, personagem+’:head_target’, y=True, relative=True)
cmds.move ( 5, personagem+’:Eye_Target’, y=True, relative=True)
614
615
616
617
618
619
620
inicio += pulo
cmds.move ( 10, personagem+’:head_target’, y=True, relative=True)
cmds.move (-10, personagem+’:Eye_Target’, y=True, relative=True)
621
622
623
624
625
626
627
inicio += pulo/2
cmds.move (-5, personagem+’:head_target’, y=True, relative=True)
cmds.move ( 5, personagem+’:Eye_Target’, y=True, relative=True)
628
629
630
631
632
633
if orientacao == ’negativo’:
for vez in range(vezes):
634
635
636
637
638
639
640
inicio += pulo/2
cmds.move (-5, personagem+’:head_target’, x=True, relative=True)
cmds.move ( 5, personagem+’:Eye_Target’, x=True, relative=True)
641
642
643
644
124
inicio += pulo
cmds.move ( 10, personagem+’:head_target’, x=True, relative=True)
645
646
647
125
cmds.move (-10, personagem+’:Eye_Target’, x=True, relative=True)
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
inicio += pulo/2
cmds.move (-5, personagem+’:head_target’, x=True, relative=True)
cmds.move ( 5, personagem+’:Eye_Target’, x=True, relative=True)
#log
print ’--- Done cabeca_aceno( ’+str(inicio)+’, ’+ str(vezes) +’, ’+ str(orientacao
) +’, ’+ str(velocidade) +’, ’ + str(personagem) +’)’
##---------------------------------------------------------------------------------------------##
def cabeca_inclinada(inicio, fim, orientacao, angulo, velocidade, personagem):
# Marca o primeiro frame, para iniciar a inclinacao cabeca
cmds.setKeyframe( personagem+’:blake_headControl’, t=inicio)
# Define velocidade da inclinacao da cabeca
pulo = 12
pulo = 8
pulo = 5
if orientacao == ’cima’:
# cima Z de 0 a -90
angulo = angulo * (-1)
# inverte sinal do angulo, pois rotacao da cabeca
para tras e’ negativa
eixo = ’Z’
if orientacao == ’baixo’:
# baixo Z de 0 a 90
eixo = ’Z’
if orientacao == ’direita’: # direita Y de 0 a -90
angulo = angulo * (-1)
eixo = ’Y’
if orientacao == ’esquerda’: # esquerda Y de 0 a 90
eixo = ’Y’
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
# Inclina a cabeca conforme o tipo de orientacao
# Define rotacao atual
head_X = cmds.getAttr(personagem+’:head_target.translateX’)
head_Y = cmds.getAttr(personagem+’:head_target.translateY’)
head_Z = cmds.getAttr(personagem+’:head_target.translateZ’)
rotation = cmds.getAttr(personagem+’:blake_headControl.rotate’+eixo)
cmds.setKeyframe(personagem+’:blake_headControl’, t=inicio)
cmds.setKeyframe(personagem+’:head_target’, t=inicio)
# Coloca no frame que a cabeca estara’ inclinada e aplica a inclinacao
cmds.currentTime(inicio+pulo)
cmds.setAttr(personagem+’:blake_headControl.rotate’+eixo,angulo)
cmds.parent( personagem+’:near_head’, world=True)
X = cmds.getAttr(personagem+’:near_head.translateX’)
Y = cmds.getAttr(personagem+’:near_head.translateY’)
Z = cmds.getAttr(personagem+’:near_head.translateZ’)
cmds.parent( personagem+’:near_head’, personagem+’:blake_headControl’, absolute=
True )
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
126
cmds.setKeyframe(personagem+’:blake_headControl’, t=inicio+pulo)
cmds.setKeyframe(personagem+’:head_target’, t=inicio+pulo)
# Mantem a inclinacao ate pouco antes do fim
cmds.currentTime(fim-pulo)
cmds.setAttr(personagem+’:blake_headControl.rotate’+eixo,angulo)
cmds.setKeyframe( personagem+’:blake_headControl’, t=fim-pulo)
cmds.setKeyframe(personagem+’:head_target’, t=fim-pulo)
# Restaura a inclinacao inicial
cmds.setAttr(personagem+’:blake_headControl.rotate’+eixo,rotation)
cmds.move (head_X,head_Y,head_Z, personagem+’:head_target’)
cmds.setKeyframe(personagem+’:blake_headControl’, t=fim)
cmds.setKeyframe(personagem+’:head_target’,t=fim)
#log
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
print ’--- Done cabeca_inclinada( ’+str(inicio)+’, ’+str(fim)+’, ’+str(orientacao)
+’, ’+str(angulo)+’, ’+str(velocidade)+’, ’+str(personagem)+’)’
#----------#
# EYE GAZE #
#----------#
def olhos_coordenada(inicio, fim, x, y, z, velocidade, personagem):
pulo = 24
pulo = 12
pulo = 5
# Trava olhar aonde estava no frame inicio
# Pula frames para movimentacao dos olhos
inicio = inicio + pulo
# Vai para antes do fim para aplicar movimento final dos olhos
cmds.currentTime(fim-5)
cmds.setKeyframe( personagem+’:Eye_Target’, t=fim-5)
# Volta a acompanhar Head_Target
X = cmds.getAttr(personagem+’:head_target’+’.translateX’)
Y = cmds.getAttr(personagem+’:head_target’+’.translateY’) + 1
Z = cmds.getAttr(personagem+’:head_target’+’.translateZ’)
cmds.move (X,Y,Z, personagem+’:Eye_Target’)
cmds.setKeyframe( personagem+’:Eye_Target’, t=fim)
746
747
748
749
750
751
#log
print ’--- Done olhos_coordenada( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(x) +’,
’+ str(y) +’, ’+ str(z) +’, ’+ str(velocidade) +’, ’ + str(personagem) +’)’
##---------------------------------------------------------------------------------------------##
def olhos_objeto(inicio, fim, objeto, personagem):
# Trava olhar aonde estava no frame inicio
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
127
for atual in range(inicio+1,fim+1):
# Pega posicao do objeto
X = cmds.getAttr(objeto+’.translateX’)
Y = cmds.getAttr(objeto+’.translateY’)
Z = cmds.getAttr(objeto+’.translateZ’)
# Define olhar para o objeto
# Seta keyframe
cmds.setKeyframe( personagem+’:Eye_Target’, t=atual)
# Volta a acompanhar Head_Target
Y = cmds.getAttr(personagem+’:head_target’+’.translateY’) + 1
cmds.setKeyframe( personagem+’:Eye_Target’, t=fim)
#log
print ’--- Done olhos_objeto( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(objeto) +’,
’ + str(personagem) +’)’
#-----------------#
# PISCAR DE OLHOS #
#-----------------#
def piscar_olho(inicio, velocidade, personagem):
pulo = 40
pulo = 20
pulo = 3
ly = cmds.getAttr(personagem+’:lowerLids.translateY’, time=inicio+(2*pulo)+2 )
uy = cmds.getAttr(personagem+’:upperLids.translateY’, time=inicio+(2*pulo)+2 )
cmds.setKeyframe( [personagem+’:lowerLids.translateY’,personagem+’:upperLids.
translateY’] , t=inicio )
cmds.currentTime(inicio+pulo)
cmds.setAttr(personagem+’:lowerLids.translateY’,1)
cmds.setAttr(personagem+’:upperLids.translateY’,1)
translateY’] , t=inicio+pulo )
cmds.currentTime( inicio+(2*pulo))
cmds.setAttr(personagem+’:lowerLids.translateY’,ly)
cmds.setAttr(personagem+’:upperLids.translateY’,uy)
translateY’] , t=inicio+(2*pulo)+2 )
#log
print ’--- Done piscar_olho( ’+str(inicio)+’, ’+str(velocidade)+’, ’+str(
personagem)+’)’
#--------------------#
# MOVIMENTOS DA BOCA #
#--------------------#
def visema_coordenada(tempo, x, y, personagem):
x = float(x) + random.uniform(-0.02, 0.02) # visema com margem de variabilidade
y = float(y) + random.uniform(-0.02, 0.02) # visema com margem de variabilidade
cmds.currentTime(tempo)
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
cmds.setAttr(personagem+’:sync_control.translateX’,x)
cmds.setAttr(personagem+’:sync_control.translateY’,y)
cmds.setAttr(personagem+’:mouthEmotion_control.translateX’,0)
cmds.setAttr(personagem+’:mouthEmotion_control.translateY’,0)
cmds.setAttr(personagem+’:upperLip_control.translateX’,0)
cmds.setAttr(personagem+’:upperLip_control.translateY’,0)
cmds.setAttr(personagem+’:lowerLip_control.translateX’,0)
cmds.setAttr(personagem+’:lowerLip_control.translateY’,0)
cmds.setAttr(personagem+’:jawLeftRight_control.translateX’,0)
cmds.setAttr(personagem+’:mouthLeftRight_control.translateX’,0)
cmds.setAttr(personagem+’:jawInOut_control.translateX’,0)
cmds.setKeyframe( [personagem+’:mouthEmotion_control’
,personagem+’:jawInOut_control’]
,t=tempo)
#log
print ’--- Done visema_coordenada( ’+str(tempo)+’, ’+str(x)+’, ’+str(y)+’, ’+str(
personagem)+’)’
##---------------------------------------------------------------------------------------------##
def visema_banco(tempo, visema, personagem):
cmds.currentTime(tempo)
cmds.pose(personagem+’_face’, name=visema, apply=True)
cmds.setKeyframe( [personagem+’:mouthEmotion_control’
,personagem+’:jawInOut_control’]
,t=tempo)
#log
print ’--- Done visema_banco( ’+str(tempo)+’, ’+str(visema)+’, ’+str(personagem)
+’)’
##---------------------------------------------------------------------------------------------##
def frase(personagem, values, *vartuple):
#print values #-> primeiro valor da lista de tuplas com [Tempo, X, Y]
#print var[0] #-> tempo
#print var[1] #-> x ou a palavra ’banco’, quando se tratar de um visema do banco
#print var[2] #-> y ou o nome do visema no banco, quando x = ’banco’
inicio = values[0]
846
847
848
849
850
if values[1] == ’banco’:
visema_banco(values[0], values[2], personagem)
else:
visema_coordenada(values[0], values[1], values[2], personagem)
851
852
853
854
855
856
128
for var in vartuple : # demais valores da lista de tuplas com [Tempo, X, Y]
fim = var[0]
if var[1] == ’banco’:
visema_banco(var[0], var[2], personagem)
else:
857
129
visema_coordenada(var[0], var[1], var[2], personagem)
858
859
860
861
862
863
qtd_clipes = 0
if nome_clipes > 0:
864
865
866
867
nome_clipe = ’Frase_clipe_’+ str(qtd_clipes)
868
869
870
871
allAbsolute=True)
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
#log
print ’--- Done frase( ’+str(personagem)+’, ’+str(inicio)+’, ’+str(fim)+’)’
#----------------------------------------------------------#
# PREPARA O AMBIENTE, RESETANDO KEYFRAMES E CLIPES GERADOS #
#----------------------------------------------------------#
def reseta(personagem):
# Limpa os keyframes
x = cmds.playbackOptions( animationEndTime=True ,query=True)
cmds.select( personagem+’_face’ )
cmds.cutKey( time=(0,x) )
cmds.select( personagem+’:head_target’ )
cmds.select( personagem+’:Eye_Target’ )
cmds.select( personagem+’:blake_headControl’ )
cmds.select( personagem+’:lowerLids.translateY’ )
cmds.select( personagem+’:upperLids.translateY’ )
cmds.select( personagem+’:head_target’ )
cmds.select( personagem+’:near_head’ )
897
898
899
900
901
902
903
904
905
906
907
# Coloca eye e head target no mesmo ponto
cmds.move (0,35,9, personagem+’:head_target’)
cmds.setKeyframe( personagem+’:head_target’, t=1)
cmds.currentTime(1)
Y = cmds.getAttr(personagem+’:head_target’+’.translateY’)
Y += 1
cmds.setKeyframe( personagem+’:Eye_Target’, t=1)
908
909
910
# Aplica a pose NEUTRA no primeiro FRAME
cmds.currentTime(0)
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
cmds.pose( personagem+’_face’, name=’Neutra’, apply=True )
,personagem+’:sneer_control’
,personagem+’:blake_headControl’
,personagem+’:head_target’
,personagem+’:near_head’]
,t=0)
cmds.currentTime(1)
cmds.pose( personagem+’_face’, name=’Neutra’, apply=True )
,personagem+’:sneer_control’
,personagem+’:blake_headControl’
,personagem+’:head_target’
,personagem+’:near_head’]
,t=1)
940
941
942
943
944
945
946
947
948
949
950
951
952
953
# Limpa todos os clipes
todos_clipes = cmds.clip(personagem+’_face’, name=True, query=True)
if todos_clipes != None:
for cada in todos_clipes:
cmds.clip(personagem+’_face’, rm=True, name=cada)
# Correcao de um BUG
emotion(-3,-7,1,"Neutra","brad")
emotion(-1,-5,1,"Neutra","brad")
’’’#-=-=-=-=-=-=-=-=-=-=#
////=-=-=-=-=-=-=-=-=-=-#
#### MODULO DE ANIMACAO #
////=-=-=-=-=-=-=-=-=-=-#
’’’#-=-=-=-=-=-=-=-=-=-=#
954
955
956
# Lista de codigos, que forma o codigo fonte de chamadas de funcoes para animacao
codigoFonteAnimacao = []
957
958
959
960
961
962
# Tempo inicial e final da animacao
anim_start = root.attrib[’start’]
anim_end
= root.attrib[’end’]
cmds.playbackOptions( minTime=anim_start, maxTime=anim_end )
963
964
965
966
967
for ADA in root:
#-------------------------------------#
# define o ADA que esta’ sendo animado #
#-------------------------------------#
130
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
personagem = ADA.attrib[’id’]
#---------#
# emotion #
#---------#
for emot in ADA.iter(’emotion’):
# Tempo inicial
start = emot.attrib[’start’]
# Verifica se o tempo de inicio e’ o tempo de uma acao
if start[:4] == ’acao’:
for action in ADA.iter(’action’):
if action.get(’id’) == start:
start = acao.get(’start’)
# Tempo final
end = emot.attrib[’end’]
# Verifica se o tempo de fim e’ o tempo de uma acao
if end[:4] == ’acao’:
if action.get(’id’) == end:
end = action.get(’end’)
# Busca detalhes
funcao = ’emotion’
for intensity in emot.iter(’intensity’):
it = intensity.text
for name in emot.iter(’name’):
nm = name.text
chamaFuncao = funcao+’(’+start+’,’+end+’,’+it+’,’+’"’+nm+’"’+’,’+’"’+
personagem+’"’+’)’
codigoFonteAnimacao.append(chamaFuncao)
#---------------#
# emotion_blend #
#---------------#
for emot_blend in ADA.iter(’emotion_blend’):
# Tempo inicial
start = emot_blend.attrib[’start’]
# Tempo final
end = emot_blend.attrib[’end’]
# Busca detalhes
funcao = ’emotion_blend’
countA = 1
countB = 1
chamaFuncao = funcao+’(’+start+’,’+end+’,’+’"’+personagem+’"’
for intensity in emot_blend.iter(’intensity’):
it = intensity.text
chamaFuncao += ’,[’+it+’,’
for name in emot_blend.iter(’name’):
if countA == countB:
131
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
nm = name.text
chamaFuncao += ’"’+nm+’"’+’]’
countB +=1
countA += 1
countB = 1
chamaFuncao += ’)’
#----------------#
# head_coordinate #
#----------------#
for head_coordinate in ADA.iter(’head_coordinate’):
# Tempo inicial
start = head_coordinate.attrib[’start’]
# Tempo final
end = head_coordinate.attrib[’end’]
# Busca detalhes
funcao = ’cabeca_coordenada’
for coordinate in head_coordinate.iter(’coordinate’):
xyz = coordinate.text
for speed in head_coordinate.iter(’speed’):
velo = speed.text
chamaFuncao = funcao+’(’+start+’,’+end+’,’+xyz+’,’+’"’+velo+’"’+’,’+’"’+
#-------------#
# head_object #
#-------------#
for head_object in ADA.iter(’head_object’):
# Tempo inicial
start = head_object.attrib[’start’]
# Tempo final
end = head_object.attrib[’end’]
# Busca detalhes
funcao = ’cabeca_objeto’
for targets in head_object.iter(’target’):
target = targets.text
132
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
133
chamaFuncao = funcao+’(’+start+’,’+end+’,’+’"’+target+’"’+’,’+’"’+personagem
+’"’+’)’
#------------#
# head_shake #
#------------#
for head_shake in ADA.iter(’head_shake’):
# Tempo inicial
start = head_shake.attrib[’start’]
# Busca Detalhes
for repete in head_shake.iter(’repete’):
repeticoes = repete.text
for orientation in head_shake.iter(’orientation’):
orient = orientation.text
for speed in head_shake.iter(’speed’):
velo = speed.text
funcao = ’cabeca_aceno’
chamaFuncao = funcao+’(’+start+’,’+repeticoes+’,’+’"’+orient+’"’+’,’+’"’+velo
+’"’+’,’+’"’+personagem+’"’+’)’
#-----------#
# head_tilt #
#-----------#
for head_tilt in ADA.iter(’head_tilt’):
# Tempo inicial
start = head_tilt.attrib[’start’]
# Tempo final
end = head_tilt.attrib[’end’]
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
# Busca Detalhes
for ag in head_tilt.iter(’angle’):
angg = ag.text
for ori in head_tilt.iter(’orientation’):
orienta = ori.text
for sped in head_tilt.iter(’speed’):
vel = sped.text
funcao = ’cabeca_inclinada’
chamaFuncao = funcao+’(’+start+’,’+end+’,’+’"’+orienta+’"’+’,’+angg+’,’+’"’+
vel+’"’+’,’+’"’+personagem+’"’+’)’
#-----------------#
# gaze_coordinate #
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
134
#-----------------#
for gaze_coordinate in ADA.iter(’gaze_coordinate’):
# Tempo inicial
start = gaze_coordinate.attrib[’start’]
# Tempo final
end = gaze_coordinate.attrib[’end’]
# Busca detalhes
funcao = ’olhos_coordenada’
for coordinate in gaze_coordinate.iter(’coordinate’):
xyz = coordinate.text
for speed in gaze_coordinate.iter(’speed’):
velo = speed.text
chamaFuncao = funcao+’(’+start+’,’+end+’,’+xyz+’,’+’"’+velo+’"’+’,’+’"’+
#-------------#
# gaze_object #
#-------------#
for gaze_object in ADA.iter(’gaze_object’):
# Tempo inicial
start = gaze_object.attrib[’start’]
# Tempo final
end = gaze_object.attrib[’end’]
# Busca detalhes
funcao = ’olhos_objeto’
for targets in gaze_object.iter(’target’):
target = targets.text
chamaFuncao = funcao+’(’+start+’,’+end+’,’+’"’+target+’"’+’,’+’"’+personagem
+’"’+’)’
#-------#
# speak #
#-------#
for speak in ADA.iter(’speak’):
funcao = ’frase’
chamaFuncao = funcao+’(’+’"’+personagem+’"’
for viseme in speak.iter(’viseme’):
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
if viseme.find(’x’) != None:
chamaFuncao += ’,[’ + viseme.find(’time’).text +’,’+ viseme.find(’x’)
.text +’,’+ viseme.find(’y’).text + ’]’
else:
chamaFuncao += ’,[’ + viseme.find(’time’).text +’,’+’"’+viseme.find(’
database’).text +’"’+’,’+’"’+ viseme.find(’vis’).text +’"’+ ’]’
chamaFuncao += ’)’
#-----------------#
# Piscar de Olhos #
#-----------------#
for blink in ADA.iter(’blink’):
# Seta velocidade do piscar de olhos
velo = blink.attrib[’speed’]
# Tempo inicial
inicio = blink.attrib[’start’]
inicio = ini.get(’start’)
funcao = ’piscar_olho’
chamaFuncao = funcao+’(’+inicio+’,’+’"’+velo+’"’+’,’+’"’+personagem+’"’+’)’
1210
1211
1212
1213
1214
1215
’’’#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-#
////=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-#
#### Imprime e executa o codigo fonte #
////=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-#
’’’#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-#
1216
1217
1218
1219
1220
135
reseta(’brad’)
for code in codigoFonteAnimacao:
print code
exec code
1221
1222
Algoritmo A.2: Código-fonte do plugin desenvolvido

Modelagem de animação procedural para expressividade

Transcrição

Documentos relacionados

Biografia Alice Braga - Stratosfera Comunicação

MEU AMIGÃOZÃO NO MUNDO DA PÁSCOA • Data do evento: 18 a

FILME: “ASAS DO DESEJO” DE WIM WENDERS PLANOS GPG

06 - A personagem

Flyer - WEB

- WordPress.com

Curriculum

Apostila – Oficina Introdução a Animação 2D

TUMBA DE GLADIADOR É ENCONTRADA EM ROMA

samantha dalsoglio - Escola de Atores Wolfmaya