Modelagem de animação procedural para expressividade
Transcrição
Modelagem de animação procedural para expressividade
Rogério Willians Chaves da Silva Modelagem de animação procedural para expressividade facial de Atores Digitais Autônomos Joinville 2013 Rogério Willians Chaves da Silva Modelagem de animação procedural para expressividade facial de Atores Digitais Autônomos 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 Rogério Willians Chaves da Silva Modelagem de animação procedural para expressividade facial de Atores Digitais Autônomos 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 A.1 Arquivo de entrada utilizado para Experimentação . . . . . . . . . . . . . 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 3.3 Técnicas de animação facial 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 3.3 Técnicas de animação facial 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 3.3 Técnicas de animação facial 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, 3.3 Técnicas de animação facial 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 3.3 Técnicas de animação facial 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- 3.3 Técnicas de animação facial 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 3.3 Técnicas de animação facial 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 3.3 Técnicas de animação facial 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- 3.4 Representação Visual da Fala 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. 3.4 Representação Visual da Fala 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- 3.7 Representação Facial de Emoções 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 3.7 Representação Facial de Emoções 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) 3.7 Representação Facial de Emoções 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). 3.7 Representação Facial de Emoções 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 3.7 Representação Facial de Emoções 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) 3.7 Representação Facial de Emoções 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 3.7 Representação Facial de Emoções 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 3.7 Representação Facial de Emoções 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; 3.7 Representação Facial de Emoções 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: 3.7 Representação Facial de Emoções 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 3.7 Representação Facial de Emoções 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 Fonte: Adaptada de (KUMAR, 2009) • 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). 3.7 Representação Facial de Emoções 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 Fonte: Adaptada de (KUMAR, 2009) • 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). 3.7 Representação Facial de Emoções 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 Fonte: Adaptada de (KUMAR, 2009) • 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). 3.7 Representação Facial de Emoções 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 Fonte: Adaptada de (KUMAR, 2009) • 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 3.7 Representação Facial de Emoções 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 Fonte: Adaptada de (KUMAR, 2009) • 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 3.7 Representação Facial de Emoções 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 Fonte: Adaptada de (KUMAR, 2009) • 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); 3.7 Representação Facial de Emoções 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 3.7 Representação Facial de Emoções 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, 3.8 Behavior Markup Language 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 Fonte: Adaptada de (KOPP et al., 2006). 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 Fonte: Adaptada de (KOPP et al., 2006). 3.8 Behavior Markup Language 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. 4.1 Módulo de Entrada 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 4.1 Módulo de Entrada 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. 4.2 Módulo de Tradução 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 4.2 Módulo de Tradução 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. 4.2 Módulo de Tradução 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 4.3 Módulo de Saída 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. 4.3 Módulo de Saída 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> <intensidade>0.3</intensidade> <nome>Surpreso</nome> </emocao> <cabeca movimento="olhar" inicio="1" fim="30"> <alvo>0,25,15</alvo> <velocidade>media</velocidade> </cabeca> <cabeca movimento="olhar" inicio="25" fim="60"> <alvo>MetalFly_v1_0:MetalFly_global</alvo> </cabeca> <cabeca movimento="acenar" inicio="50"> <vezes>4</vezes> <orientacao>positivo</orientacao> <velocidade>media</velocidade> </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> <vis>visema_oo</vis> 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" /> <blink speed="alta" start="296" /> <blink speed="alta" start="449" /> <blink speed="alta" start="620" /> <blink speed="alta" start="800" /> </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. REFERÊNCIAS BIBLIOGRÁFICAS 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. REFERÊNCIAS BIBLIOGRÁFICAS 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>. REFERÊNCIAS BIBLIOGRÁFICAS 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. REFERÊNCIAS BIBLIOGRÁFICAS 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>. REFERÊNCIAS BIBLIOGRÁFICAS 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. REFERÊNCIAS BIBLIOGRÁFICAS 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. REFERÊNCIAS BIBLIOGRÁFICAS 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: REFERÊNCIAS BIBLIOGRÁFICAS 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. REFERÊNCIAS BIBLIOGRÁFICAS 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. A.1 Arquivo de entrada utilizado para Experimentação 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 <scene start="1" end="1260"> <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> A.1 Arquivo de entrada utilizado para Experimentação 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> <vis>visema_oo</vis> </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> <cabeca movimento="inclinar" inicio="481" fim="499"> <orientacao>cima</orientacao> <angulo>60</angulo> 109 A.1 Arquivo de entrada utilizado para Experimentação 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> <cabeca movimento="acenar" inicio="420"> <vezes>6</vezes> <orientacao>negativo</orientacao> <velocidade>alta</velocidade> </cabeca> <cabeca movimento="inclinar" inicio="501" fim="520"> <orientacao>baixo</orientacao> <angulo>30</angulo> <velocidade>media</velocidade> </cabeca> <cabeca movimento="olhar" inicio="1" fim="140"> <alvo>MetalFly_v1_0:MetalFly_global</alvo> </cabeca> <cabeca movimento="olhar" inicio="141" fim="160"> <alvo>0,36.3,9</alvo> <velocidade>media</velocidade> </cabeca> <cabeca movimento="olhar" inicio="161" fim="200"> <alvo>-1,36,9</alvo> <velocidade>baixa</velocidade> </cabeca> <cabeca movimento="olhar" inicio="201" fim="230"> <alvo>-1.5,35.5,9</alvo> <velocidade>media</velocidade> </cabeca> <cabeca movimento="olhar" inicio="231" fim="250"> <alvo>-0.3,34,8</alvo> <velocidade>alta</velocidade> </cabeca> <cabeca movimento="olhar" inicio="251" fim="270"> <alvo>6, 32, 6</alvo> <velocidade>baixa</velocidade> </cabeca> <cabeca movimento="olhar" inicio="271" fim="290"> <alvo>13, 38, -4</alvo> <velocidade>media</velocidade> </cabeca> <cabeca movimento="olhar" inicio="291" fim="310"> <alvo>-2, 38, 8</alvo> <velocidade>baixa</velocidade> </cabeca> <cabeca movimento="olhar" inicio="311" fim="330"> <alvo>0, 36, 9</alvo> <velocidade>alta</velocidade> </cabeca> <cabeca movimento="acenar" inicio="331"> <vezes>5</vezes> <orientacao>positivo</orientacao> <velocidade>media</velocidade> </cabeca> <piscar inicio="520" velocidade="baixa" /> <piscar inicio="620" velocidade="baixa" /> <piscar inicio="700" velocidade="media" /> <piscar inicio="750" velocidade="media" /> <piscar inicio="790" velocidade="alta" /> 110 A.1 Arquivo de entrada utilizado para Experimentação 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"> <intensidade>1</intensidade> <nome>Neutra</nome> </emocao> <emocao inicio="40" fim="80"> <intensidade>1</intensidade> <nome>Surpreso</nome> </emocao> <emocao inicio="81" fim="140"> <intensidade>0.8</intensidade> <nome>Raiva</nome> </emocao> <emocao inicio="141" fim="200"> <intensidade>0.8</intensidade> <nome>Felicidade</nome> </emocao> <emocao inicio="201" fim="250"> <intensidade>0.8</intensidade> <nome>Neutra</nome> </emocao> <emocao inicio="800" fim="850"> <intensidade>1</intensidade> <nome>Aversao</nome> </emocao> <emocao inicio="850" fim="900"> <intensidade>1</intensidade> <nome>Desprezo</nome> </emocao> <emocao inicio="900" fim="950"> <intensidade>1</intensidade> <nome>Felicidade</nome> </emocao> <emocao inicio="950" fim="1000"> <intensidade>1</intensidade> <nome>Medo</nome> </emocao> <emocao inicio="1000" fim="1050"> <intensidade>1</intensidade> <nome>Raiva</nome> </emocao> <emocao inicio="1050" fim="1100"> <intensidade>1</intensidade> <nome>Surpreso</nome> </emocao> <emocao inicio="1100" fim="1150"> <intensidade>1</intensidade> <nome>Triste</nome> </emocao> <emocao inicio="1200" fim="1250"> <intensidade>1</intensidade> <nome>Medo</nome> <intensidade>1</intensidade> <nome>Desprezo</nome> </emocao> </acao> </ator> 111 A.1 Arquivo de entrada utilizado para Experimentação 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 A.2 Código-fonte do plugin desenvolvido 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’): # Seta o tempo final, verificando se e’ tempo de uma acao if cabeca.attrib[’movimento’] != ’acenar’: fim = cabeca.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 = cabeca.attrib[’inicio’] if inicio[:4] == ’acao’: for ini in ada.iter(’acao’): if ini.get(’nome’) == inicio: inicio = ini.get(’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) A.2 Código-fonte do plugin desenvolvido 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 for velocidade in cabeca.iter(’velocidade’): velo = velocidade.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 = SubElement(sub_cabeca, "speed") 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 for velocidade in cabeca.iter(’velocidade’): velo = velocidade.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 = SubElement(sub_cabeca, "speed") speed.text = velo #-------------------------# # Cria movimentos do olho # #-------------------------# for olhos in acao.iter(’olhos’): # Seta o tempo final, verificando se e’ tempo de uma acao fim = olhos.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 = olhos.attrib[’inicio’] if inicio[:4] == ’acao’: A.2 Código-fonte do plugin desenvolvido 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 for ini in ada.iter(’acao’): if ini.get(’nome’) == inicio: inicio = ini.get(’inicio’) # 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 for velocidade in cabeca.iter(’velocidade’): velo = velocidade.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): <scene start="1" end="880"> <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> <vis>visema_oo</vis> </viseme> A.2 Código-fonte do plugin desenvolvido 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’] # Seta o tempo inicial, verificando se e’ tempo de uma acao inicio = piscar.attrib[’inicio’] if inicio[:4] == ’acao’: for ini in ada.iter(’acao’): if ini.get(’nome’) == inicio: inicio = ini.get(’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 A.2 Código-fonte do plugin desenvolvido 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’ A.2 Código-fonte do plugin desenvolvido 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) +’)’ ##------------------------------------------------------------------------------------------------ A.2 Código-fonte do plugin desenvolvido 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 ) # 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*values[0]) cmds.setAttr(controle+’.translateY’,posY*values[0]) # 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’ ,personagem+’:sneer_control’] ,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.currentTime(atual) cmds.pose( personagem+’_face’, name=var[1], 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*var[0]) cmds.setAttr(controle+’.translateY’,posY*var[0]) # Grava a pose na linha de tempo cmds.setKeyframe( [personagem+’:browEmotion_control’ ,personagem+’:eyebrows_control’ ,personagem+’:upperLip_control’ ,personagem+’:lowerLip_control’ ,personagem+’:mouthEmotion_control’ A.2 Código-fonte do plugin desenvolvido 432 433 434 435 436 437 438 439 ,personagem+’:sync_control’ ,personagem+’:upperLids’ ,personagem+’:lowerLids’ ,personagem+’:mouthLeftRight_control’ ,personagem+’:jawLeftRight_control’ ,personagem+’:jawInOut_control’ ,personagem+’:sneer_control’] ,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 cmds.currentTime(inicio) # Faz o blend entre a posicao inicial e a posicao atual, no frame inicial for controle in controles_lista: cmds.currentTime(inicio) x_inicio = cmds.getAttr(controle+’.translateX’) y_inicio = cmds.getAttr(controle+’.translateY’) cmds.currentTime(atual) x_atual = cmds.getAttr(controle+’.translateX’) y_atual = cmds.getAttr(controle+’.translateY’) cmds.currentTime(inicio) cmds.setAttr(controle+’.translateX’,(x_inicio+x_atual)/2) cmds.setAttr(controle+’.translateY’,(y_inicio+y_atual)/2) 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’ ,personagem+’:sneer_control’] ,t=inicio) # Percorre todos os frames aplicando a pose for momento in range(inicio+1, fim): for controle in controles_lista: # Pega posicao do frame inicial cmds.currentTime(inicio) 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) 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’ ,personagem+’:sneer_control’] 121 A.2 Código-fonte do plugin desenvolvido 489 490 491 492 493 494 122 ,t=momento) # 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 495 496 497 498 # Cria o clipe e NAO COLOCA NO SCHEDULE nome_clipe = ’Blend_clipe_’+ str(qtd_clipes) cmds.clip( personagem+’_face’, startTime=inicio, endTime=fim, name=nome_clipe, allAbsolute=True, sc=False ) 499 500 501 502 # 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) 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’: A.2 Código-fonte do plugin desenvolvido 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 cmds.currentTime(inicio) 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.currentTime(inicio) 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): cmds.currentTime(atual) # 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’) A.2 Código-fonte do plugin desenvolvido 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): if velocidade == ’baixa’: pulo = 12 if velocidade == ’media’: pulo = 8 if velocidade == ’alta’: pulo = 5 if orientacao == ’positivo’: for vez in range(vezes): cmds.currentTime(inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) 607 608 609 610 611 612 613 inicio += pulo/2 cmds.currentTime(inicio) cmds.move (-5, personagem+’:head_target’, y=True, relative=True) cmds.move ( 5, personagem+’:Eye_Target’, y=True, relative=True) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) 614 615 616 617 618 619 620 inicio += pulo cmds.currentTime(inicio) cmds.move ( 10, personagem+’:head_target’, y=True, relative=True) cmds.move (-10, personagem+’:Eye_Target’, y=True, relative=True) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) 621 622 623 624 625 626 627 inicio += pulo/2 cmds.currentTime(inicio) cmds.move (-5, personagem+’:head_target’, y=True, relative=True) cmds.move ( 5, personagem+’:Eye_Target’, y=True, relative=True) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) 628 629 630 631 632 633 if orientacao == ’negativo’: for vez in range(vezes): cmds.currentTime(inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) 634 635 636 637 638 639 640 inicio += pulo/2 cmds.currentTime(inicio) cmds.move (-5, personagem+’:head_target’, x=True, relative=True) cmds.move ( 5, personagem+’:Eye_Target’, x=True, relative=True) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) 641 642 643 644 124 inicio += pulo cmds.currentTime(inicio) cmds.move ( 10, personagem+’:head_target’, x=True, relative=True) A.2 Código-fonte do plugin desenvolvido 645 646 647 125 cmds.move (-10, personagem+’:Eye_Target’, x=True, relative=True) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) 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.currentTime(inicio) cmds.move (-5, personagem+’:head_target’, x=True, relative=True) cmds.move ( 5, personagem+’:Eye_Target’, x=True, relative=True) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) cmds.setKeyframe( personagem+’:head_target’, t=inicio) #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.currentTime(inicio) cmds.setKeyframe( personagem+’:blake_headControl’, t=inicio) # Define velocidade da inclinacao da cabeca if velocidade == ’baixa’: pulo = 12 if velocidade == ’media’: pulo = 8 if velocidade == ’alta’: 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 cmds.currentTime(inicio) 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 ) cmds.move (X,Y,Z, personagem+’:head_target’) A.2 Código-fonte do plugin desenvolvido 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.move (X,Y,Z, personagem+’:head_target’) cmds.setKeyframe( personagem+’:blake_headControl’, t=fim-pulo) cmds.setKeyframe(personagem+’:head_target’, t=fim-pulo) # Restaura a inclinacao inicial cmds.currentTime(fim) 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): if velocidade == ’baixa’: pulo = 24 if velocidade == ’media’: pulo = 12 if velocidade == ’alta’: pulo = 5 # Trava olhar aonde estava no frame inicio cmds.currentTime(inicio) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) # Pula frames para movimentacao dos olhos inicio = inicio + pulo cmds.currentTime(inicio) cmds.setKeyframe( personagem+’:head_target’, t=fim) cmds.move (x,y,z, personagem+’:Eye_Target’) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) # Vai para antes do fim para aplicar movimento final dos olhos cmds.currentTime(fim-5) cmds.move (x,y,z, personagem+’:Eye_Target’) cmds.setKeyframe( personagem+’:Eye_Target’, t=fim-5) # Volta a acompanhar Head_Target cmds.currentTime(fim) 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) cmds.setKeyframe( personagem+’:head_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 A.2 Código-fonte do plugin desenvolvido 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 cmds.currentTime(inicio) cmds.setKeyframe( personagem+’:Eye_Target’, t=inicio) for atual in range(inicio+1,fim+1): cmds.currentTime(atual) # 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+’:Eye_Target’) # Seta keyframe cmds.setKeyframe( personagem+’:Eye_Target’, t=atual) # Volta a acompanhar Head_Target cmds.currentTime(fim) 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) #log print ’--- Done olhos_objeto( ’+str(inicio)+’, ’+ str(fim) +’, ’+ str(objeto) +’, ’ + str(personagem) +’)’ #-----------------# # PISCAR DE OLHOS # #-----------------# def piscar_olho(inicio, velocidade, personagem): if velocidade == ’baixa’: pulo = 40 if velocidade == ’media’: pulo = 20 if velocidade == ’alta’: pulo = 3 cmds.currentTime(inicio) 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) cmds.setKeyframe( [personagem+’:lowerLids.translateY’,personagem+’:upperLids. translateY’] , t=inicio+pulo ) cmds.currentTime( inicio+(2*pulo)) cmds.setAttr(personagem+’:lowerLids.translateY’,ly) cmds.setAttr(personagem+’:upperLids.translateY’,uy) cmds.setKeyframe( [personagem+’:lowerLids.translateY’,personagem+’:upperLids. 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) A.2 Código-fonte do plugin desenvolvido 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+’:jawLeftRight_control’ ,personagem+’:mouthLeftRight_control’ ,personagem+’:sync_control’ ,personagem+’:upperLip_control’ ,personagem+’:lowerLip_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+’:jawLeftRight_control’ ,personagem+’:mouthLeftRight_control’ ,personagem+’:sync_control’ ,personagem+’:upperLip_control’ ,personagem+’:lowerLip_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: A.2 Código-fonte do plugin desenvolvido 857 129 visema_coordenada(var[0], var[1], var[2], personagem) 858 859 860 861 862 863 # 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 864 865 866 867 # Cria o clipe e NAO COLOCA NO SCHEDULE nome_clipe = ’Frase_clipe_’+ str(qtd_clipes) cmds.clip( personagem+’_face’, startTime=inicio, endTime=fim, name=nome_clipe, allAbsolute=True, sc=False ) 868 869 870 871 # 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) 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.cutKey( time=(0,x) ) cmds.select( personagem+’:Eye_Target’ ) cmds.cutKey( time=(0,x) ) cmds.select( personagem+’:blake_headControl’ ) cmds.cutKey( time=(0,x) ) cmds.select( personagem+’:lowerLids.translateY’ ) cmds.cutKey( time=(0,x) ) cmds.select( personagem+’:upperLids.translateY’ ) cmds.cutKey( time=(0,x) ) cmds.select( personagem+’:head_target’ ) cmds.cutKey( time=(0,x) ) cmds.select( personagem+’:near_head’ ) cmds.cutKey( time=(0,x) ) 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) X = cmds.getAttr(personagem+’:head_target’+’.translateX’) Y = cmds.getAttr(personagem+’:head_target’+’.translateY’) Z = cmds.getAttr(personagem+’:head_target’+’.translateZ’) Y += 1 cmds.move (X,Y,Z, personagem+’:Eye_Target’) cmds.setKeyframe( personagem+’:Eye_Target’, t=1) 908 909 910 # Aplica a pose NEUTRA no primeiro FRAME cmds.currentTime(0) A.2 Código-fonte do plugin desenvolvido 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 ) 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+’:sneer_control’ ,personagem+’:blake_headControl’ ,personagem+’:head_target’ ,personagem+’:near_head’] ,t=0) cmds.currentTime(1) cmds.pose( personagem+’_face’, name=’Neutra’, apply=True ) 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+’: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 A.2 Código-fonte do plugin desenvolvido 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’: for action in ADA.iter(’action’): 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) # Se tiver mais de uma emocao, chama funcao emotion_blend #---------------# # emotion_blend # #---------------# for emot_blend in ADA.iter(’emotion_blend’): # Tempo inicial start = emot_blend.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_blend.attrib[’end’] # Verifica se o tempo de fim e’ o tempo de uma acao if end[:4] == ’acao’: for action in ADA.iter(’action’): if action.get(’id’) == end: end = action.get(’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 A.2 Código-fonte do plugin desenvolvido 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 += ’)’ codigoFonteAnimacao.append(chamaFuncao) # Se tiver mais de uma emocao, chama funcao emotion_blend #----------------# # head_coordinate # #----------------# for head_coordinate in ADA.iter(’head_coordinate’): # Tempo inicial start = head_coordinate.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 = head_coordinate.attrib[’end’] # Verifica se o tempo de fim e’ o tempo de uma acao if end[:4] == ’acao’: for action in ADA.iter(’action’): if action.get(’id’) == end: end = action.get(’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+’"’+’,’+’"’+ personagem+’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) #-------------# # head_object # #-------------# for head_object in ADA.iter(’head_object’): # Tempo inicial start = head_object.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 = head_object.attrib[’end’] # Verifica se o tempo de fim e’ o tempo de uma acao if end[:4] == ’acao’: for action in ADA.iter(’action’): if action.get(’id’) == end: end = action.get(’end’) # Busca detalhes funcao = ’cabeca_objeto’ for targets in head_object.iter(’target’): target = targets.text 132 A.2 Código-fonte do plugin desenvolvido 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 +’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) #------------# # head_shake # #------------# for head_shake in ADA.iter(’head_shake’): # Tempo inicial start = head_shake.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’) # 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+’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) #-----------# # head_tilt # #-----------# for head_tilt in ADA.iter(’head_tilt’): # Tempo inicial start = head_tilt.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 = head_tilt.attrib[’end’] # Verifica se o tempo de fim e’ o tempo de uma acao if end[:4] == ’acao’: for action in ADA.iter(’action’): if action.get(’id’) == end: end = action.get(’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+’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) #-----------------# # gaze_coordinate # A.2 Código-fonte do plugin desenvolvido 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’] # 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 = gaze_coordinate.attrib[’end’] # Verifica se o tempo de fim e’ o tempo de uma acao if end[:4] == ’acao’: for action in ADA.iter(’action’): if action.get(’id’) == end: end = action.get(’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+’"’+’,’+’"’+ personagem+’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) #-------------# # gaze_object # #-------------# for gaze_object in ADA.iter(’gaze_object’): # Tempo inicial start = gaze_object.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 = gaze_object.attrib[’end’] # Verifica se o tempo de fim e’ o tempo de uma acao if end[:4] == ’acao’: for action in ADA.iter(’action’): if action.get(’id’) == end: end = action.get(’end’) # Busca detalhes funcao = ’olhos_objeto’ for targets in gaze_object.iter(’target’): target = targets.text chamaFuncao = funcao+’(’+start+’,’+end+’,’+’"’+target+’"’+’,’+’"’+personagem +’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) #-------# # speak # #-------# for speak in ADA.iter(’speak’): funcao = ’frase’ chamaFuncao = funcao+’(’+’"’+personagem+’"’ for viseme in speak.iter(’viseme’): A.2 Código-fonte do plugin desenvolvido 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 += ’)’ codigoFonteAnimacao.append(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’] if inicio[:4] == ’acao’: for ini in ada.iter(’acao’): if ini.get(’nome’) == inicio: inicio = ini.get(’start’) funcao = ’piscar_olho’ chamaFuncao = funcao+’(’+inicio+’,’+’"’+velo+’"’+’,’+’"’+personagem+’"’+’)’ codigoFonteAnimacao.append(chamaFuncao) 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