from utils02 import *
import Blender
from Blender import*
from Blender.Scene import Render
import math
import os
import commands
import subprocess as sub
import sys
def substr(str,origem, tamanho):
return str[origem:tamanho+origem]
paramDir = sys.argv[5]
paramEsq = sys.argv[6]
libPoseMaoDireita = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibConfigMaoDir", "r")
libOritentacaoLadoDireito = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibOrientacaoDir", "r")
libPoseMaoEsquerda = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibConfigMaoEsq", "r")
libOritentacaoLadoEsquerdo = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibOrientacaoEsq", "r")
libPontoArticulacaoEsquerda = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibPontoArticulacaoEsq", "r")
listaPoseMaoDireita = libPoseMaoDireita.readlines();
listalibOritentacaoLadoDireito = libOritentacaoLadoDireito.readlines();
libPontoArticulacaoDireita = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibPontoArticulacaoDir", "r")
listalibPontoArticulacaoDireita = libPontoArticulacaoDireita.readlines();
listaPoseMaoEsquerda = libPoseMaoEsquerda.readlines();
listalibOritentacaoLadoEsquerdo = libOritentacaoLadoEsquerdo.readlines();
listalibPontoArticulacaoEsquerda = libPontoArticulacaoEsquerda.readlines();
libExpressaoFacial = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibExpressaoFacial", "r")
libPosePadrao = open("/usr/share/WikiLIBRAS/server/ScriptsPython/Libs/LibPosePadrao", "r")
listaPosePadrao = libPosePadrao.readlines();
listaExpressaoFacial = libExpressaoFacial.readlines();
armadura = Blender.Object.Get('Armature.001');
pose = armadura.getPose()
arquivoDireita = open(paramDir, "r")
parametrosDireita = arquivoDireita.readlines();
arquivoEsquerda = open(paramEsq, "r")
parametrosEsquerda = arquivoEsquerda.readlines();
poseb = pose.bones['ik_FK.R']
poseb1 = pose.bones['ik_FK.L']
act = Armature.NLA.NewAction("SemiCircular")
act.setActive(armadura)
print "############ CONFIGURACOES DA MAO DIREITA ############"
configDir = parametrosDireita[0]
configDir = configDir[:-1]
print configDir
oriDir = parametrosDireita[1]
oriDir = oriDir[:-1]
print oriDir
paDir = parametrosDireita[2]
paDir = paDir[:-1]
print paDir
tamanhoRaio = parametrosDireita[3]
tamanhoRaio = tamanhoRaio[:-1]
print tamanhoRaio
if (tamanhoRaio == 'Grande') or (tamanhoRaio == 'grande'):
r = 1
elif (tamanhoRaio == 'Medio') or (tamanhoRaio == 'medio'):
r = 0.6
else:
r = 0.3
sentidoMovimentoDir = parametrosDireita[4]
sentidoMovimentoDir = sentidoMovimentoDir[:-1]
print sentidoMovimentoDir
orientacaoMovimentoDir = parametrosDireita[5]
orientacaoMovimentoDir = orientacaoMovimentoDir[:-1]
print orientacaoMovimentoDir
direcaoDir = parametrosDireita[6] #Orientacao do Movimento. Paralelo ou Perpendicular ao corpo
direcaoDir = direcaoDir[:-1]
print direcaoDir
flagRepDir = parametrosDireita[7]
flagRepDir = flagRepDir[:-1]
print flagRepDir
if(flagRepDir == "com-repeticao"):
tipoRepDir = parametrosDireita[8] #Avançar ou Retroceder da mão
tipoRepDir = tipoRepDir[:-1]
print tipoRepDir
maoUtil = parametrosDireita[9]
maoUtil = maoUtil[:-1]
print maoUtil
if (maoUtil == 'uma'):
nomeSinal = parametrosDireita[10]
nomeSinal = nomeSinal[:-1]
print nomeSinal
else: #maoUtil == duas
sincFlag = parametrosDireita[10]
sincFlag = sincFlag[:-1]
nomeSinal = parametrosDireita[11]
nomeSinal = nomeSinal[:-1]
print sincFlag
print nomeSinal
else: # sem repeticao
maoUtil = parametrosDireita[8]
maoUtil = maoUtil[:-1]
print maoUtil
if (maoUtil == 'uma'):
nomeSinal = parametrosDireita[9]
nomeSinal = nomeSinal[:-1]
print nomeSinal
else: #maoUtil == duas
sincFlag = parametrosDireita[9]
sincFlag = sincFlag[:-1]
nomeSinal = parametrosDireita[10]
nomeSinal = nomeSinal[:-1]
print sincFlag
print nomeSinal
print "########################PARAMETROS#########################";
print "DIREITA";
print parametrosDireita
print "###########################################################";
xml_sinal = open("/var/www/WikiLibras/StatusXML/status" + nomeSinal + ".xml", "w")
xml_sinal.write("\n")
xml_sinal.write("false\n")
xml_sinal.close();
posePadrao = ["Pose_1", "Pose_2"]
for h in range(0, 2, 1):
#Pose Padrao inicial
print "Pose Padrão Inicial: " + str(posePadrao[h])
for i in range(0 , len(listaPosePadrao), 1):
if (listaPosePadrao[i].split()):
if (listaPosePadrao[i].split()[0] == posePadrao[h]):
for k in range(i , i+ int(listaPosePadrao[i].split()[-1]), 1):
bone = pose.bones[listaPosePadrao[k+1].split()[0]]
bone.loc[:] = float(listaPosePadrao[k+1].split()[2]), float(listaPosePadrao[k+1].split()[3]), float(listaPosePadrao[k+1].split()[4])
bone.insertKey(armadura, 0, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPosePadrao[k+1].split()[6]), float(listaPosePadrao[k+1].split()[7]), float(listaPosePadrao[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 0, Object.Pose.ROT)
#Configuracao de mao direita
for i in range(0 , len(listaPoseMaoDireita), 1):
if (listaPoseMaoDireita[i].split()):
if (listaPoseMaoDireita[i].split()[0] == configDir):
for k in range(i , i+15, 1):
bone = pose.bones[listaPoseMaoDireita[k+1].split()[0]]
bone.loc[:] = float(listaPoseMaoDireita[k+1].split()[2]), float(listaPoseMaoDireita[k+1].split()[3]), float(listaPoseMaoDireita[k+1].split()[4])
bone.insertKey(armadura, 15, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPoseMaoDireita[k+1].split()[6]), float(listaPoseMaoDireita[k+1].split()[7]), float(listaPoseMaoDireita[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 15, Object.Pose.ROT)
#Configuracao de mao direita
for i in range(0 , len(listaPoseMaoDireita), 1):
if (listaPoseMaoDireita[i].split()):
if (listaPoseMaoDireita[i].split()[0] == configDir):
for k in range(i , i+15, 1):
bone = pose.bones[listaPoseMaoDireita[k+1].split()[0]]
bone.loc[:] = float(listaPoseMaoDireita[k+1].split()[2]), float(listaPoseMaoDireita[k+1].split()[3]), float(listaPoseMaoDireita[k+1].split()[4])
bone.insertKey(armadura, 18, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPoseMaoDireita[k+1].split()[6]), float(listaPoseMaoDireita[k+1].split()[7]), float(listaPoseMaoDireita[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 18, Object.Pose.ROT)
#Define a orientacao da mao direita
for i in range(0 , len(listalibOritentacaoLadoDireito), 1):
if (listalibOritentacaoLadoDireito[i].split()):
if (listalibOritentacaoLadoDireito[i].split()[0] == oriDir):
for k in range(i , i+2, 1):
bone = pose.bones[listalibOritentacaoLadoDireito[k+1].split()[0]]
bone.loc[:] = float(listalibOritentacaoLadoDireito[k+1].split()[2]), float(listalibOritentacaoLadoDireito[k+1].split()[3]), float(listalibOritentacaoLadoDireito[k+1].split()[4])
bone.insertKey(armadura, 15, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibOritentacaoLadoDireito[k+1].split()[6]), float(listalibOritentacaoLadoDireito[k+1].split()[7]), float(listalibOritentacaoLadoDireito[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 15, Object.Pose.ROT)
#Define a orientacao da mao direita
for i in range(0 , len(listalibOritentacaoLadoDireito), 1):
if (listalibOritentacaoLadoDireito[i].split()):
if (listalibOritentacaoLadoDireito[i].split()[0] == oriDir):
for k in range(i , i+2, 1):
bone = pose.bones[listalibOritentacaoLadoDireito[k+1].split()[0]]
bone.loc[:] = float(listalibOritentacaoLadoDireito[k+1].split()[2]), float(listalibOritentacaoLadoDireito[k+1].split()[3]), float(listalibOritentacaoLadoDireito[k+1].split()[4])
bone.insertKey(armadura, 18, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibOritentacaoLadoDireito[k+1].split()[6]), float(listalibOritentacaoLadoDireito[k+1].split()[7]), float(listalibOritentacaoLadoDireito[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 18, Object.Pose.ROT)
#Ponto de articulacao da mao direita
for i in range(0 , len(listalibPontoArticulacaoDireita), 1):
if (listalibPontoArticulacaoDireita[i].split()):
if (listalibPontoArticulacaoDireita[i].split()[0] == paDir):
for k in range(i , i+2, 1):
bone = pose.bones[listalibPontoArticulacaoDireita[k+1].split()[0]]
bone.loc[:] = float(listalibPontoArticulacaoDireita[k+1].split()[2]), float(listalibPontoArticulacaoDireita[k+1].split()[3]), float(listalibPontoArticulacaoDireita[k+1].split()[4])
bone.insertKey(armadura, 15, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibPontoArticulacaoDireita[k+1].split()[6]), float(listalibPontoArticulacaoDireita[k+1].split()[7]), float(listalibPontoArticulacaoDireita[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 15, Object.Pose.ROT)
#Ponto de articulacao da mao direita
for i in range(0 , len(listalibPontoArticulacaoDireita), 1):
if (listalibPontoArticulacaoDireita[i].split()):
if (listalibPontoArticulacaoDireita[i].split()[0] == paDir):
for k in range(i , i+2, 1):
bone = pose.bones[listalibPontoArticulacaoDireita[k+1].split()[0]]
bone.loc[:] = float(listalibPontoArticulacaoDireita[k+1].split()[2]), float(listalibPontoArticulacaoDireita[k+1].split()[3]), float(listalibPontoArticulacaoDireita[k+1].split()[4])
bone.insertKey(armadura, 18, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibPontoArticulacaoDireita[k+1].split()[6]), float(listalibPontoArticulacaoDireita[k+1].split()[7]), float(listalibPontoArticulacaoDireita[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 18, Object.Pose.ROT)
xp = poseb.loc.x
yp = poseb.loc.y
zp = poseb.loc.z
frame = 0;
frameEsq = 0;
if(orientacaoMovimentoDir == "para-frente"):
print "para-frente"
if(sentidoMovimentoDir == "horario"):
if(direcaoDir == "para-direita"):
print "para-direita"
frame = 18
poseb.loc[:] = xp - r , yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else:
xp = poseb.loc.x + r
yp = poseb.loc.y
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else:#Direção = para-esquerda
print "para esquerda"
frame = 18
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x - r
yp = poseb.loc.y
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else:#Sentido Anti-Horario
print "sentido anti-horario. linha 362"
if(direcaoDir == "para-direita"): #para direita
print "Para direita. linha 364"
frame = 18
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp , yp - r , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
print "anti horario, para direita, com repeticao, RETROCEDER."
frame = 43
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp - r , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
print "anti horario, para direita, com repeticao, AVANCAR."
xp = poseb.loc.x + r
yp = poseb.loc.y
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2) , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp- (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp + r, yp , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(direcaoDir == "para-esquerda"): #para direita
print "Para ESQUERDA. Linha 417"
frame = 18
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp , yp + r , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
print "anti horario, para direita, com repeticao, RETROCEDER."
frame = 43
poseb.loc[:] = xp + r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp + r , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(tipoRepDir == "avancar"): #avancar
print "anti horario, para direita, com repeticao, AVANCAR."
xp = poseb.loc.x - r
yp = poseb.loc.y
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp + r, yp , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp + (r * math.sqrt(2) / 2) , yp + (r * math.sqrt(2) / 2) , zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp - r, yp, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
elif(orientacaoMovimentoDir == "para-dentro"):
if(sentidoMovimentoDir == "horario"):
if(direcaoDir == "para-frente"):
frame = 18
poseb.loc[:] = xp, yp , zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp , yp, zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp, yp , zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp , yp, zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y
zp = poseb.loc.z + r
frame = 43
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp, zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
#direção direita = para trás e horario
elif(direcaoDir == "para-tras"):
frame = 18
poseb.loc[:] = xp, yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp, yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y
zp = poseb.loc.z - r
frame = 43
poseb.loc[:] = xp, yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
elif(direcaoDir == "para-cima"):
frame = 18
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y + r
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
# direcao dir = para baixo
else:
frame = 18
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp , yp + (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp , yp + (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y - r
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp , yp + (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp , yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
#sentido movimento direita anti-horario
else:
if(direcaoDir == "para-frente"):
frame = 18
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 43
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 48
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 68
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 73
poseb.loc[:] = xp , yp , zp + r
frame = 78
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y
zp = poseb.loc.z + r
frame = 48
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 68
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 73
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
elif(direcaoDir == "para-tras"):
frame = 18
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 43
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 48
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 68
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 73
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y
zp = poseb.loc.z - r
frame = 48
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 68
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 73
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
elif(direcaoDir == "para-cima"):
frame = 18
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y + r
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp , yp , zp + r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
#direcao direita = para baixo
else:
frame = 18
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 23
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 28
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 33
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 38
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
if(flagRepDir == "com-repeticao"):
if(tipoRepDir == "retroceder"):
frame = 43
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
else: #avancar
xp = poseb.loc.x
yp = poseb.loc.y - r
zp = poseb.loc.z
frame = 43
poseb.loc[:] = xp, yp + r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 48
poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 53
poseb.loc[:] = xp, yp, zp - r
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 58
poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
poseb.insertKey(armadura, frame, Object.Pose.LOC)
frame = 63
poseb.loc[:] = xp, yp - r, zp
poseb.insertKey(armadura, frame, Object.Pose.LOC)
#Orientação para-cima
else:
print "Orientação para Cima em desenvolvimento...";
#--------------------------------------------------------------------------------------------------
#Configurando os keyframes do lado esquerdo
if (maoUtil == 'duas'):
print "############ CONFIGURACOES DA MAO ESQUERDA ############"
configEsq = parametrosEsquerda[0]
configEsq = configEsq[:-1]
print configEsq
oriEsq = parametrosEsquerda[1]
oriEsq = oriEsq[:-1]
print oriEsq
paEsq = parametrosEsquerda[2]
paEsq = paEsq[:-1]
print paEsq
tamanhoRaioEsq = parametrosEsquerda[3]
tamanhoRaioEsq = tamanhoRaioEsq[:-1]
print tamanhoRaioEsq
if (tamanhoRaioEsq == 'Grande') or (tamanhoRaioEsq == 'grande'):
r1 = 1
elif (tamanhoRaioEsq == 'Medio') or (tamanhoRaioEsq == 'medio'):
r1 = 0.6
else:
r1 = 0.3
sentidoMovimentoEsq = parametrosEsquerda[4]
sentidoMovimentoEsq = sentidoMovimentoEsq[:-1]
print sentidoMovimentoEsq
orientacaoMovimentoEsq = parametrosEsquerda[5]
orientacaoMovimentoEsq = orientacaoMovimentoEsq[:-1]
print orientacaoMovimentoEsq
direcaoEsq = parametrosEsquerda[6]
direcaoEsq = direcaoEsq[:-1]
print direcaoEsq
flagRepEsq = parametrosEsquerda[7]
flagRepEsq = flagRepEsq[:-1]
print flagRepEsq
expFacial = parametrosEsquerda[8]
expFacial = expFacial[:-1]
print expFacial
#Config da mao esquerda
for i in range(0 , len(listaPoseMaoEsquerda), 1):
if (listaPoseMaoEsquerda[i].split()):
if (listaPoseMaoEsquerda[i].split()[0] == configEsq):
for k in range(i , i+15, 1): #varrendo todos os ossos da mao
bone = pose.bones[listaPoseMaoEsquerda[k+1].split()[0]]
bone.loc[:] = float(listaPoseMaoEsquerda[k+1].split()[2]), float(listaPoseMaoEsquerda[k+1].split()[3]), float(listaPoseMaoEsquerda[k+1].split()[4])
bone.insertKey(armadura, 15, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPoseMaoEsquerda[k+1].split()[6]), float(listaPoseMaoEsquerda[k+1].split()[7]), float(listaPoseMaoEsquerda[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 1, Object.Pose.ROT)
#Config da mao esquerda
for i in range(0 , len(listaPoseMaoEsquerda), 1):
if (listaPoseMaoEsquerda[i].split()):
if (listaPoseMaoEsquerda[i].split()[0] == configEsq):
for k in range(i , i+15, 1): #varrendo todos os ossos da mao
bone = pose.bones[listaPoseMaoEsquerda[k+1].split()[0]]
bone.loc[:] = float(listaPoseMaoEsquerda[k+1].split()[2]), float(listaPoseMaoEsquerda[k+1].split()[3]), float(listaPoseMaoEsquerda[k+1].split()[4])
bone.insertKey(armadura, 18, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPoseMaoEsquerda[k+1].split()[6]), float(listaPoseMaoEsquerda[k+1].split()[7]), float(listaPoseMaoEsquerda[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 18, Object.Pose.ROT)
#Orientacao da mao esquerda
for i in range(0 , len(listalibOritentacaoLadoEsquerdo), 1):
if (listalibOritentacaoLadoEsquerdo[i].split()):
if (listalibOritentacaoLadoEsquerdo[i].split()[0] == oriEsq):
for k in range(i , i+2, 1):
bone = pose.bones[listalibOritentacaoLadoEsquerdo[k+1].split()[0]]
bone.loc[:] = float(listalibOritentacaoLadoEsquerdo[k+1].split()[2]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[3]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[4])
bone.insertKey(armadura, 15, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibOritentacaoLadoEsquerdo[k+1].split()[6]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[7]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 15, Object.Pose.ROT)
#Orientacao da mao esquerda
for i in range(0 , len(listalibOritentacaoLadoEsquerdo), 1):
if (listalibOritentacaoLadoEsquerdo[i].split()):
if (listalibOritentacaoLadoEsquerdo[i].split()[0] == oriEsq):
for k in range(i , i+2, 1):
bone = pose.bones[listalibOritentacaoLadoEsquerdo[k+1].split()[0]]
bone.loc[:] = float(listalibOritentacaoLadoEsquerdo[k+1].split()[2]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[3]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[4])
bone.insertKey(armadura, 18, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibOritentacaoLadoEsquerdo[k+1].split()[6]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[7]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 18, Object.Pose.ROT)
#Ponto de articulacao da mao esquerda
for i in range(0 , len(listalibPontoArticulacaoEsquerda), 1):
if (listalibPontoArticulacaoEsquerda[i].split()):
if (listalibPontoArticulacaoEsquerda[i].split()[0] == paEsq):
for k in range(i , i+2, 1):
bone = pose.bones[listalibPontoArticulacaoEsquerda[k+1].split()[0]]
bone.loc[:] = float(listalibPontoArticulacaoEsquerda[k+1].split()[2]), float(listalibPontoArticulacaoEsquerda[k+1].split()[3]), float(listalibPontoArticulacaoEsquerda[k+1].split()[4])
bone.insertKey(armadura, 15, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibPontoArticulacaoEsquerda[k+1].split()[6]), float(listalibPontoArticulacaoEsquerda[k+1].split()[7]), float(listalibPontoArticulacaoEsquerda[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 15, Object.Pose.ROT)
#Ponto de articulacao da mao esquerda
for i in range(0 , len(listalibPontoArticulacaoEsquerda), 1):
if (listalibPontoArticulacaoEsquerda[i].split()):
if (listalibPontoArticulacaoEsquerda[i].split()[0] == paEsq):
for k in range(i , i+2, 1):
bone = pose.bones[listalibPontoArticulacaoEsquerda[k+1].split()[0]]
bone.loc[:] = float(listalibPontoArticulacaoEsquerda[k+1].split()[2]), float(listalibPontoArticulacaoEsquerda[k+1].split()[3]), float(listalibPontoArticulacaoEsquerda[k+1].split()[4])
bone.insertKey(armadura, 18, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibPontoArticulacaoEsquerda[k+1].split()[6]), float(listalibPontoArticulacaoEsquerda[k+1].split()[7]), float(listalibPontoArticulacaoEsquerda[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 18, Object.Pose.ROT)
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z
#Verificação sincronismo entre as maos
if(sincFlag == 'sincrono'):
assincronismo = 0
print "MOV SINCRONOOOO"
else:
assincronismo = 1
print "MOV ASSINCRONOOOO"
frameEsq = 0
if(orientacaoMovimentoEsq == "para-frente"):
if(sentidoMovimentoEsq == "horario"):
if(direcaoEsq == "para-direita"):
frameEsq = 18
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frame, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1+ r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x - r1
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #(direcao_esquerda == "para-esquerda"):
frameEsq = 18
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x + r1
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
#sentido esquerda anti-horario
else:
if(direcaoEsq == "para-direita"):
frameEsq = 18
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + r1 , zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + r1 , zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x + r1
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + r1 , zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #(direcao_esquerda == "para-esquerda"):
frameEsq = 18
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1 , zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1 , zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x - r1
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 + r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1 , zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 - r1, yp1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
elif(orientacaoMovimentoEsq == "para-dentro"):
if(sentidoMovimentoEsq == "horario"):
if(direcaoEsq == "para-frente"):
frameEsq = 18
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 68 +10*assincronismo
poseb1.loc[:] = xp1 , yp1 + (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 73 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 78 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z + r1
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 68 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1+ (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 73 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 78 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
elif(direcaoEsq == "para-tras"):
frameEsq = 18
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z - r1
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
elif(direcaoEsq == "para-cima"):
frameEsq = 18
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y + r1
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #if(direcao_esquerda == "para-baixo"):
frameEsq = 19
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y - r1
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 + (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
#sentido esquerda anti-horario
else:
if(direcaoEsq == "para-frente"):
frameEsq = 18
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 68 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 73 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 78 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z + r1
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 68 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 73 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
elif(direcaoEsq == "para-tras"):
frameEsq = 18
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 68 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 73 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z - r1
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 68 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 73 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
elif(direcaoEsq == "para-cima"):
frameEsq = 18
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y + r1
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2) , zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1 , yp1 , zp1 + r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #if(direcao_esquerda == "para-baixo"):
frameEsq = 18
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 23 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 28 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 33 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 38 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
if(flagRepEsq == "com-repeticao"):
if(tipoRepEsq == "retroceder"):
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
else: #avancar
xp1 = poseb1.loc.x
yp1 = poseb1.loc.y - r1
zp1 = poseb1.loc.z
frameEsq = 43 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 48 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1- (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 53 + 10*assincronismo
poseb1.loc[:] = xp1, yp1, zp1 - r1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 58 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
frameEsq = 63 + 10*assincronismo
poseb1.loc[:] = xp1, yp1 - r1, zp1
poseb1.insertKey(armadura, frameEsq, Object.Pose.LOC)
#Orientacao esquerda para cima
else:
print "Em desenvolvimento ...";
else:
expFacial = parametrosEsquerda[1]
expFacial = expFacial[:-1]
print expFacial
print "Frame Dir = " + str(frame);
print "Frame Esq = " + str(frameEsq);
endFrame = 0;
if(frame > frameEsq):
endFrame = frame;
else:
endFrame = frameEsq;
print "End Frame = " + str(endFrame);
#Define a orientacao da mao direita
for i in range(0 , len(listalibOritentacaoLadoDireito), 1):
if (listalibOritentacaoLadoDireito[i].split()):
if (listalibOritentacaoLadoDireito[i].split()[0] == oriDir):
for k in range(i , i+2, 1):
bone = pose.bones[listalibOritentacaoLadoDireito[k+1].split()[0]]
bone.loc[:] = float(listalibOritentacaoLadoDireito[k+1].split()[2]), float(listalibOritentacaoLadoDireito[k+1].split()[3]), float(listalibOritentacaoLadoDireito[k+1].split()[4])
bone.insertKey(armadura, endFrame, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibOritentacaoLadoDireito[k+1].split()[6]), float(listalibOritentacaoLadoDireito[k+1].split()[7]), float(listalibOritentacaoLadoDireito[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, endFrame, Object.Pose.ROT)
#Configuracao de mao direita
for i in range(0 , len(listaPoseMaoDireita), 1):
if (listaPoseMaoDireita[i].split()):
if (listaPoseMaoDireita[i].split()[0] == configDir):
for k in range(i , i+15, 1):
bone = pose.bones[listaPoseMaoDireita[k+1].split()[0]]
bone.loc[:] = float(listaPoseMaoDireita[k+1].split()[2]), float(listaPoseMaoDireita[k+1].split()[3]), float(listaPoseMaoDireita[k+1].split()[4])
bone.insertKey(armadura, endFrame, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPoseMaoDireita[k+1].split()[6]), float(listaPoseMaoDireita[k+1].split()[7]), float(listaPoseMaoDireita[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, endFrame, Object.Pose.ROT)
if(maoUtil == 'duas'):
#Orientacao da mao esquerda
for i in range(0 , len(listalibOritentacaoLadoEsquerdo), 1):
if (listalibOritentacaoLadoEsquerdo[i].split()):
if (listalibOritentacaoLadoEsquerdo[i].split()[0] == oriEsq):
for k in range(i , i+2, 1):
bone = pose.bones[listalibOritentacaoLadoEsquerdo[k+1].split()[0]]
bone.loc[:] = float(listalibOritentacaoLadoEsquerdo[k+1].split()[2]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[3]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[4])
bone.insertKey(armadura, endFrame, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listalibOritentacaoLadoEsquerdo[k+1].split()[6]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[7]), float(listalibOritentacaoLadoEsquerdo[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, endFrame, Object.Pose.ROT)
#Config da mao esquerda
for i in range(0 , len(listaPoseMaoEsquerda), 1):
if (listaPoseMaoEsquerda[i].split()):
if (listaPoseMaoEsquerda[i].split()[0] == configEsq):
for k in range(i , i+15, 1): #varrendo todos os ossos da mao
bone = pose.bones[listaPoseMaoEsquerda[k+1].split()[0]]
bone.loc[:] = float(listaPoseMaoEsquerda[k+1].split()[2]), float(listaPoseMaoEsquerda[k+1].split()[3]), float(listaPoseMaoEsquerda[k+1].split()[4])
bone.insertKey(armadura, endFrame, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPoseMaoEsquerda[k+1].split()[6]), float(listaPoseMaoEsquerda[k+1].split()[7]), float(listaPoseMaoEsquerda[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, endFrame, Object.Pose.ROT)
fixRots(0)
fixRots(1)
expressaoFacial = ["Exp_9", expFacial, "Exp_9"]
for h in range(0, 3, 1):
#Configurando expressão facial do sinal escolhida
for i in range(0 , len(listaExpressaoFacial), 1):
if (listaExpressaoFacial[i].split()): #Split em cada linha
if (listaExpressaoFacial[i].split()[0] == expressaoFacial[h]):
#print listaExpressaoFacial[i].split()[0];
for k in range(i , i+int(listaExpressaoFacial[i].split()[-1]), 1):
bone = pose.bones[listaExpressaoFacial[k+1].split()[0]]
#print bone;
bone.loc[:] = float(listaExpressaoFacial[k+1].split()[2]), float(listaExpressaoFacial[k+1].split()[3]), float(listaExpressaoFacial[k+1].split()[4])
bone.insertKey(armadura, h*(endFrame/2) + 1 + h*3, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaExpressaoFacial[k+1].split()[6]), float(listaExpressaoFacial[k+1].split()[7]), float(listaExpressaoFacial[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, h*(endFrame/2) + 1, Object.Pose.ROT)
fixRots(0)
fixRots(1)
# Key Frames Pose Padrão Inicial e Final ----------------------------------------------------------------
poseInicial = ["Pose_1", "Pose_2"]
for u in range(0, 2, 1 ):
for i in range(0 , len(listaPosePadrao), 1):
if (listaPosePadrao[i].split()):
if (listaPosePadrao[i].split()[0] == poseInicial[u]):
for k in range(i , i+ int(listaPosePadrao[i].split()[-1]), 1):
bone = pose.bones[listaPosePadrao[k+1].split()[0]]
bone.loc[:] = float(listaPosePadrao[k+1].split()[2]), float(listaPosePadrao[k+1].split()[3]), float(listaPosePadrao[k+1].split()[4])
bone.insertKey(armadura, 1, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPosePadrao[k+1].split()[6]), float(listaPosePadrao[k+1].split()[7]), float(listaPosePadrao[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, 1, Object.Pose.ROT)
bone = pose.bones[listaPosePadrao[k+1].split()[0]]
bone.loc[:] = float(listaPosePadrao[k+1].split()[2]), float(listaPosePadrao[k+1].split()[3]), float(listaPosePadrao[k+1].split()[4])
bone.insertKey(armadura, endFrame + 20, Object.Pose.LOC)
euler = bone.quat.toEuler()
euler[:] = float(listaPosePadrao[k+1].split()[6]), float(listaPosePadrao[k+1].split()[7]), float(listaPosePadrao[k+1].split()[8])
bone.quat = euler.toQuat()
bone.insertKey(armadura, endFrame + 20, Object.Pose.ROT)
'''
nomeVideoTemp = substr(nomeVideo, 0, len(nomeVideo) - 1)
print nomeVideoTemp
'''
cena = Blender.Scene.GetCurrent()
cont = cena.getRenderingContext()
cont.renderPath = "//"+nomeSinal+"_"
cont.sFrame = 1
cont.eFrame = endFrame + 30
cont.renderAnim()
print "Removendo ParamDir e ParamEsq da pasta ScriptsPython"
sub.call(["rm", "/usr/share/WikiLIBRAS/server/ScriptsPython/"+nomeSinal+"Dir", "/usr/share/WikiLIBRAS/server/ScriptsPython/"+nomeSinal+"Esq"])
print
print"Convertendo AVI em FLV usando ffmpeg"
num = endFrame + 30
if(num > 100):
s = "0" + str(num);
else:
s = "00" + str(num);
print nomeSinal+"_0001_"+s+".avi";
sub.call(["/usr/bin/ffmpeg", "-i", "/usr/share/WikiLIBRAS/server/ScriptsPython/"+nomeSinal+"_0001_"+s+".avi", "-b", "2028k", "-s", "640x480", "-r", "30", "-acodec", "copy", nomeSinal+".flv"])
sub.call(["mv", "/usr/share/WikiLIBRAS/server/ScriptsPython/"+nomeSinal+"_0001_"+s+".avi", nomeSinal+".avi"])
sub.call(["mv", "/usr/share/WikiLIBRAS/server/ScriptsPython/"+nomeSinal+".flv", "/var/www/WikiLibras/Videos/"])
sub.call(["mv", "/usr/share/WikiLIBRAS/server/ScriptsPython/"+nomeSinal+".avi", "/var/www/WikiLibras/Videos/"])
xml_sinal = open("/var/www/WikiLibras/StatusXML/status" + nomeSinal + ".xml", "w")
xml_sinal.write("\n")
xml_sinal.write("true\n")
xml_sinal.close();
Blender.Quit()
'''
sub.Popen("ffmpeg -i "+ nomeSinal+ "*.avi -b 2028k -s 640x480 -r 30 -acodec copy "+ nomeSinal+".flv",shell=True,stdout=sub.PIPE).stdout.readlines()
temp1 = commands.getoutput('ls /usr/share/WikiLIBRAS/server/ScriptsPython | grep '+nomeSinal + '*.avi')
videoAVIrenomeado = nomeSinal + '.avi';
os.rename(temp1, videoAVIrenomeado);
xml_sinal = open("/var/www/StatusXML/status" + nomeSinal + ".xml", "w")
xml_sinal.write("\n")
xml_sinal.write("true\n")
xml_sinal.close();
sub.Popen("sudo rm "+nomeSinal+"Dir " + nomeSinal + "Esq " + nomeSinal + ".xml", shell=True,stdout=sub.PIPE).stdout.readlines()
sub.Popen("sudo mv "+nomeSinal+".avi " + nomeSinal + ".flv " + "/srv/www/Videos/", shell=True,stdout=sub.PIPE).stdout.readlines()
#Blender.Save("qualquerCoisa.blend", 1);
Blender.Quit()
'''