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("Libs/LibConfigMaoDir", "r")
libOritentacaoLadoDireito = open("Libs/LibOrientacaoDir", "r")
libPoseMaoEsquerda = open("Libs/LibConfigMaoEsq", "r")
libOritentacaoLadoEsquerdo = open("Libs/LibOrientacaoEsq", "r")
libPontoArticulacaoEsquerda = open("Libs/LibPontoArticulacaoEsq", "r")
listaPoseMaoDireita = libPoseMaoDireita.readlines();
listalibOritentacaoLadoDireito = libOritentacaoLadoDireito.readlines();
libPontoArticulacaoDireita = open("Libs/LibPontoArticulacaoDir", "r")
listalibPontoArticulacaoDireita = libPontoArticulacaoDireita.readlines();
listaPoseMaoEsquerda = libPoseMaoEsquerda.readlines();
listalibOritentacaoLadoEsquerdo  = libOritentacaoLadoEsquerdo.readlines();
listalibPontoArticulacaoEsquerda = libPontoArticulacaoEsquerda.readlines();
libExpressaoFacial = open("Libs/LibExpressaoFacial", "r")
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("Circular")
act.setActive(armadura)

configDir = parametrosDireita[0]
oriDir = parametrosDireita[1]
tamanho_raio = parametrosDireita[2]
raio = substr(tamanho_raio, 0, len(tamanho_raio) - 1)
if (raio == 'Grande'):
	r = 1
elif (raio == 'Medio'):
	r = 0.6
else:
	r = 0.3
	
print "RaioDir"
print r

sentido_movimento = parametrosDireita[3]
flag_rep = parametrosDireita[4]
paral_perp = parametrosDireita[5]
sincronismo = parametrosDireita[6]
ponto_articulacao_dir = parametrosDireita[7]
nomeVideo = parametrosDireita[8]

print "########################PARAMETROS#########################";
print "DIREITA";
print parametrosDireita
print "###########################################################";

config_mao_direita = substr(configDir, 0, len(configDir) - 1)
orientacao_direita = substr(oriDir, 0, len(oriDir) - 1)
sentido_movimento_dir = substr(sentido_movimento, 0, len(sentido_movimento) - 1)
flag_repeticao = substr(flag_rep, 0, len(flag_rep) - 1)
paralelo_perpendicular = substr(paral_perp, 0, len(paral_perp) - 1)
sincronismo_dir = substr(sincronismo, 0, len(sincronismo) - 1)
ponto_articulacao_direita = substr(ponto_articulacao_dir, 0, len(ponto_articulacao_dir) - 1)

#Configuracao de mao
for i in range(0 , len(listaPoseMaoDireita), 1):
	if (listaPoseMaoDireita[i].split()):
		if (listaPoseMaoDireita[i].split()[0] == config_mao_direita): 
			for k in range(i , i+15, 1): #varrendo todos os ossos da mao
				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, 1, 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, 1, Object.Pose.ROT)
#Define a orientacao da mao direita incial
for i in range(0 , len(listalibOritentacaoLadoDireito), 1):
		if (listalibOritentacaoLadoDireito[i].split()):
			if (listalibOritentacaoLadoDireito[i].split()[0] == orientacao_direita):	
				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, 1, 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, 1, Object.Pose.ROT)

#Ponto de articulacao da mao direita
for i in range(0 , len(listalibPontoArticulacaoDireita), 1):
		if (listalibPontoArticulacaoDireita[i].split()): #Split em cada linha			
	  		if (listalibPontoArticulacaoDireita[i].split()[0] == ponto_articulacao_direita):
				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, 1, 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, 1, Object.Pose.ROT)
	        				
#Configurando expressão facial inicial do sinal:  NEUTRA
for i in range(0 , len(listaExpressaoFacial), 1):
		if (listaExpressaoFacial[i].split()): #Split em cada linha			
	  		if (listaExpressaoFacial[i].split()[0] == "Exp_9"): #Expressao facial neutra
	  			#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, 1, 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, 1, Object.Pose.ROT)	        			

temp = parametrosEsquerda[0]
temporario = substr(temp, 0, len(temp) - 1)

print "########################PARAMETROS#########################";
print "ESQUERDA";
print parametrosEsquerda
print "###########################################################";

if(temporario != 'Nenhum'):	
	print "[142]parametrosEsq[0] != Nenhum"
	configEsq = parametrosEsquerda[0]
	oriEsq = parametrosEsquerda[1]
	
	tamanho_raio1 = parametrosEsquerda[2]
	raio1 = substr(tamanho_raio1, 0, len(tamanho_raio1) - 1)
	if (raio1 == 'Grande'):
		r1 = 1
	elif (raio1 == 'Medio'):
		r1 = 0.6
	else:
		r1 = 0.3
		
	print "RaioEsq"
	print r1		
	
	sentido_movimento1 = parametrosEsquerda[3]
	flag_rep1 = parametrosEsquerda[4]
	paral_perp1 = parametrosEsquerda[5]
	sincronismo1 = parametrosEsquerda[6]
	ponto_articulacao_esq = parametrosEsquerda[7]
	exp_facial = parametrosEsquerda[8]
	
	config_mao_esquerda = substr(configEsq, 0, len(configEsq) - 1)
	orientacao_esquerda = substr(oriEsq, 0, len(oriEsq) - 1)
	sentido_movimento_esq = substr(sentido_movimento1, 0, len(sentido_movimento1) - 1)
	flag_repeticao1 = substr(flag_rep1, 0, len(flag_rep1) - 1)
	paralelo_perpendicular1 = substr(paral_perp1, 0, len(paral_perp1) - 1)
	sincronismo_esq = substr(sincronismo1, 0, len(sincronismo1) - 1)
	ponto_articulacao_esquerda = substr(ponto_articulacao_esq, 0, len(ponto_articulacao_esq) - 1)
	expressao_facial = substr(exp_facial, 0, len(exp_facial) - 1)

	#Config da mao esquerda
	for i in range(0 , len(listaPoseMaoEsquerda), 1):
		if (listaPoseMaoEsquerda[i].split()):			
			if (listaPoseMaoEsquerda[i].split()[0] == config_mao_esquerda): 
				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, 1, 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)
	#Orientacao da mao esquerda
	for i in range(0 , len(listalibOritentacaoLadoEsquerdo), 1):
		if (listalibOritentacaoLadoEsquerdo[i].split()):
			if (listalibOritentacaoLadoEsquerdo[i].split()[0] == orientacao_esquerda):	
				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, 1, 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, 1, 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] == ponto_articulacao_esquerda):
				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, 1, 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, 1, Object.Pose.ROT)
	        			
	        			
xp = poseb.loc.x
yp = poseb.loc.y
zp = poseb.loc.z

xp1 = poseb1.loc.x
yp1 = poseb1.loc.y
zp1 = poseb1.loc.z

if(temporario != 'Nenhum'): #EXISTE MOVIMENTO COM A MAO ESQUERDA
	if(sincronismo_dir == sincronismo_esq == "sincrono"):
		if(paralelo_perpendicular == "paralelo"): 
			if(sentido_movimento_dir == "horario"): 
				frame = 1
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30	
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):		
					frame = 45
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp, yp + r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp - r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb.loc[:] = xp + r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)			
			else: #Horario
				frame = 1
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp , yp + r , zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):
					frame = 45
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp , yp + r , zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp + r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70	
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80	
					poseb.loc[:] = xp - r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
		else: #movimento perpendicular ao corpo
			if(sentido_movimento_dir == "horario"): 
				frame = 1
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp , yp + (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp, yp , zp + r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp , yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp  - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30	
				poseb.loc[:] = xp, yp, zp - r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):		
					frame = 45
					poseb.loc[:] = xp, yp  + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp, yp , zp + r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp  + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb.loc[:] = xp, yp, zp - r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb.loc[:] = xp, yp + r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)			
			else:
				frame = 1
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp , yp , zp + r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb.loc[:] = xp, yp, zp - r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):
					frame = 45
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp , yp , zp + r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp, yp + r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70	
					poseb.loc[:] = xp, yp, zp - r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80	
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
		if(paralelo_perpendicular1 == "paralelo"): 
			if(sentido_movimento_esq == "horario"): 	
				frame = 1
				poseb1.loc[:] = xp1 + r1, yp1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb1.loc[:] = xp1, yp1 + r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1 - r1, yp1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1, yp1 - r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1 + r1, yp1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 45
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb1.loc[:] = xp1, yp1 + r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1 - r1, yp1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb1.loc[:] = xp1, yp1 - r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb1.loc[:] = xp1 + r1, yp1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
			else:
				frame = 1
				poseb1.loc[:] = xp1 - r1, yp1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb1.loc[:] = xp1 , yp1 + r1 , zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1 + r1, yp1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1, yp1 - r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1 - r1, yp1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 45
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb1.loc[:] = xp1 , yp1 + r1 , zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1 + r1, yp1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70	
					poseb1.loc[:] = xp1, yp1 - r1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80	
					poseb1.loc[:] = xp1 - r1, yp1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
		else: #movimento perpendicular ao corpo
			if(sentido_movimento_esq == "horario"): 	
				frame = 1
				poseb1.loc[:] = xp1, yp1 + r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb1.loc[:] = xp1, yp1, zp + r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1, yp1 - r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1, yp1, zp - r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1, yp1 + r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 45
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb1.loc[:] = xp1, yp1, zp + r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1, yp1 - r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb1.loc[:] = xp1, yp1, zp - r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb1.loc[:] = xp1, yp1 + r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
			else: #movimento horario
				frame = 1
				poseb1.loc[:] = xp1, yp1 - r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb1.loc[:] = xp1 , yp1 , zp + r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1, yp1 + r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1, yp1, zp1 - r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1, yp1 - r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 45
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb1.loc[:] = xp1 , yp1 , zp1 + r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1, yp1 + r1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70	
					poseb1.loc[:] = xp1, yp1, zp1 - r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80	
					poseb1.loc[:] = xp1, yp1 - r1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
	else: # assincrono
		if(paralelo_perpendicular == "paralelo"): 
			if(sentido_movimento_dir == "horario"): 
				frame = 1
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30	
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):		
					frame = 45
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp, yp + r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp - r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb.loc[:] = xp + r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)			
			else:
				frame = 1
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp , yp + r , zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):
					frame = 45
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp , yp + r , zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp + r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70	
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80	
					poseb.loc[:] = xp - r, yp, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
		else: #movimento perpendicular ao corpo
			if(sentido_movimento_dir == "horario"): 
				frame = 1
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp , yp + (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp, yp , zp + r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp , yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp  - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30	
				poseb.loc[:] = xp, yp, zp - r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):		
					frame = 45
					poseb.loc[:] = xp, yp  + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp, yp , zp + r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp  + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb.loc[:] = xp, yp, zp - r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb.loc[:] = xp, yp + r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)			
			else:
				frame = 1
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 5
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 10
				poseb.loc[:] = xp , yp , zp + r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb.loc[:] = xp, yp, zp - r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao == "com-repeticao"):
					frame = 45
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 50
					poseb.loc[:] = xp , yp , zp + r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 55
					poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb.loc[:] = xp, yp + r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70	
					poseb.loc[:] = xp, yp, zp - r
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
					poseb.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80	
					poseb.loc[:] = xp, yp - r, zp
					poseb.insertKey(armadura, frame, Object.Pose.LOC)
		if(paralelo_perpendicular1 == "paralelo"): 
			if(sentido_movimento_esq == "horario"): 	
				frame = 10
				poseb1.loc[:] = xp1 + r1, yp1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1, yp1 + r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1 - r1, yp1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1, yp1 - r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 45
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb1.loc[:] = xp1 + r1, yp1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 55
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1, yp1 + r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 65	
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 70	
					poseb1.loc[:] = xp1 - r1, yp1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 80
					poseb1.loc[:] = xp1, yp1 - r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 85
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 90	
					poseb1.loc[:] = xp1 + r1, yp1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
			else:
				frame = 10
				poseb1.loc[:] = xp1 - r1, yp1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1 , yp1 + r1 , zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1 + r1, yp1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1, yp1 - r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 45
				poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb1.loc[:] = xp1 - r1, yp1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 55
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1 , yp1 + r1 , zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 + (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb1.loc[:] = xp1 + r1, yp1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb1.loc[:] = xp1 + (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80	
					poseb1.loc[:] = xp1, yp1 - r1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 85	
					poseb1.loc[:] = xp1 - (r1 * math.sqrt(2) / 2), yp1 - (r1 * math.sqrt(2) / 2), zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 90	
					poseb1.loc[:] = xp1 - r1, yp1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
		else: #movimento perpendicular ao corpo
			if(sentido_movimento_esq == "horario"): 	
				frame = 10
				poseb1.loc[:] = xp1, yp1 + r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1, yp1, zp + r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1, yp1 - r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1, yp1, zp - r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 45
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb1.loc[:] = xp1, yp1 + r1, zp
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 55
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1, yp1, zp + r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb1.loc[:] = xp1, yp1 - r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 75
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80
					poseb1.loc[:] = xp1, yp1, zp - r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 85
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 90
					poseb1.loc[:] = xp1, yp1 + r1, zp
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
			else:
				frame = 10
				poseb1.loc[:] = xp1, yp1 - r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 15
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 20
				poseb1.loc[:] = xp1 , yp1 , zp + r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 25
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 30
				poseb1.loc[:] = xp1, yp1 + r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 35
				poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 40
				poseb1.loc[:] = xp1, yp1, zp1 - r1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 45
				poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb1.loc[:] = xp1, yp1 - r1, zp1
				poseb1.insertKey(armadura, frame, Object.Pose.LOC)
				if(flag_repeticao1 == "com-repeticao"):
					frame = 55
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 60
					poseb1.loc[:] = xp1 , yp1 , zp1 + r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 65
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 + (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 70
					poseb1.loc[:] = xp1, yp1 + r1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 75	
					poseb1.loc[:] = xp1, yp1 + (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)
					frame = 80	
					poseb1.loc[:] = xp1, yp1, zp1 - r1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 85	
					poseb1.loc[:] = xp1, yp1 - (r1 * math.sqrt(2) / 2), zp1 - (r1 * math.sqrt(2) / 2)
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)	
					frame = 90	
					poseb1.loc[:] = xp1, yp1 - r1, zp1
					poseb1.insertKey(armadura, frame, Object.Pose.LOC)

	#MOVIMENTO COM AS DUAS MAOS
	#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] == expressao_facial):
	  			#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, frame/2, 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, frame/2, Object.Pose.ROT)
	        			
#MOVIMENTO APENAS COM A MAO DIREITA
else: 
	print 'MAO ESQUERDA NAO POSSUI MOVIMENTO. SINAL APENAS COM A MAO DOMINANTE!!!!';
	if(paralelo_perpendicular == "paralelo"): 
		if(sentido_movimento_dir == "horario"): 
			frame = 1
			poseb.loc[:] = xp + r, yp, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 5
			poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 10
			poseb.loc[:] = xp, yp + r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 15
			poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 20
			poseb.loc[:] = xp - r, yp, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 25
			poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 30	
			poseb.loc[:] = xp, yp - r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 35
			poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 40
			poseb.loc[:] = xp + r, yp, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			if(flag_repeticao == "com-repeticao"):		
				frame = 45
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 55
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 60
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 65
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 70
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 75
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 80
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)			
		else: #Horario
			frame = 1
			poseb.loc[:] = xp - r, yp, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 5
			poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 10
			poseb.loc[:] = xp , yp + r , zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 15
			poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 20
			poseb.loc[:] = xp + r, yp, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 25
			poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 30
			poseb.loc[:] = xp, yp - r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 35
			poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 40
			poseb.loc[:] = xp - r, yp, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			if(flag_repeticao == "com-repeticao"):
				frame = 45
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb.loc[:] = xp , yp + r , zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 55
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp + (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 60
				poseb.loc[:] = xp + r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)	
				frame = 65	
				poseb.loc[:] = xp + (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 70	
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)	
				frame = 75	
				poseb.loc[:] = xp - (r * math.sqrt(2) / 2), yp - (r * math.sqrt(2) / 2), zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)	
				frame = 80	
				poseb.loc[:] = xp - r, yp, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
	else: #movimento perpendicular ao corpo
		if(sentido_movimento_dir == "horario"): 
			frame = 1
			poseb.loc[:] = xp, yp + r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 5
			poseb.loc[:] = xp , yp + (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 10
			poseb.loc[:] = xp, yp , zp + r
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 15
			poseb.loc[:] = xp , yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 20
			poseb.loc[:] = xp , yp - r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 25
			poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp  - (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 30	
			poseb.loc[:] = xp, yp, zp - r
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 35
			poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 40
			poseb.loc[:] = xp, yp + r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			if(flag_repeticao == "com-repeticao"):		
				frame = 45
				poseb.loc[:] = xp, yp  + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb.loc[:] = xp, yp , zp + r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 55
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp  + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 60
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 65
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 70
				poseb.loc[:] = xp, yp, zp - r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 75
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 80
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)			
		else: # Horario
			frame = 1
			poseb.loc[:] = xp, yp - r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 5
			poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2) , zp + (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 10
			poseb.loc[:] = xp , yp , zp + r
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 15
			poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 20
			poseb.loc[:] = xp, yp + r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 25
			poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 30
			poseb.loc[:] = xp, yp, zp - r
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 35
			poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			frame = 40
			poseb.loc[:] = xp, yp - r, zp
			poseb.insertKey(armadura, frame, Object.Pose.LOC)
			if(flag_repeticao == "com-repeticao"):
				frame = 45
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 50
				poseb.loc[:] = xp , yp , zp + r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 55
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp + (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 60
				poseb.loc[:] = xp, yp + r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)	
				frame = 65	
				poseb.loc[:] = xp, yp + (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
				frame = 70	
				poseb.loc[:] = xp, yp, zp - r
				poseb.insertKey(armadura, frame, Object.Pose.LOC)	
				frame = 75	
				poseb.loc[:] = xp, yp - (r * math.sqrt(2) / 2), zp - (r * math.sqrt(2) / 2)
				poseb.insertKey(armadura, frame, Object.Pose.LOC)	
				frame = 80	
				poseb.loc[:] = xp, yp - r, zp
				poseb.insertKey(armadura, frame, Object.Pose.LOC)
					
	exp_facial = parametrosEsquerda[1]
	expressao_facial = substr(exp_facial, 0, len(exp_facial) - 1)
	#print "Mov left HAND = "
	#print var_temp
	print expressao_facial;	
	#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] == expressao_facial):
	  			#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, frame/2, 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, frame/2, Object.Pose.ROT)
			
nomeVideoTemp = substr(nomeVideo, 0, len(nomeVideo) - 1)
print nomeVideoTemp

	
cena = Blender.Scene.GetCurrent()
cont = cena.getRenderingContext()
cont.renderPath = "//"+nomeVideoTemp+"_"
cont.sFrame = 1
cont.eFrame = frame
cont.renderAnim()

sub.Popen("ffmpeg -i "+ nomeVideoTemp+ "*.avi -y -b 800 -r 25 -f flv -vcodec flv -acodec mp3 -ab 128 -ar 44100 "+ nomeVideoTemp+".flv",shell=True,stdout=sub.PIPE).stdout.readlines()

#temp = commands.getoutput('ls $HOME/Projetos/ProjetoLibras/server/ScriptsPython | grep convertido')

temp1 = commands.getoutput('ls $HOME/Projetos/ProjetoLibras/server/ScriptsPython | grep '+nomeVideoTemp + '*.avi')
videoAVIrenomeado = nomeVideoTemp + '.avi';
os.rename(temp1,  videoAVIrenomeado);

#nomeVideoConvertido = substr(nomeVideo, 0, len(nomeVideo) - 1)
#nomeDoSinal =  nomeVideo + '.flv';
#os.rename(temp,  nomeDoSinal);

Blender.Quit()