Download as
Browse Code »

Commit e313bcb0251531f63b4c31711c70355bbafcbeea

Authored by André Araújo
1 parent 42f9b71d
Exists in master

Atualiza movimento Circular, Helicoidal, Facial

Showing 8 changed files with 505 additions and 470 deletions   Show diff stats
1 -JSON = $(JSON_RETILINEO) 1 +JSON = $(JSON_CIRCULAR)
2 2
3 # ---------------------------- 3 # ----------------------------
4 -# JSON = $(JSON_CIRCULAR)  
5 -# JSON = $(JSON_CONTATO_ALISAR)  
6 -# JSON = $(JSON_CONTATO_COCAR)  
7 -# JSON = $(JSON_CONTATO_TOCAR)  
8 -# JSON = $(JSON_CONTATO_RISCAR)  
9 -# JSON = $(JSON_FACIAL)  
10 -# JSON = $(JSON_HELICOIDAL)  
11 -# JSON = $(JSON_PONTUAL)  
12 -# JSON = $(JSON_RETILINEO)  
13 -# JSON = $(JSON_SEMI_CIRCULAR)  
14 -# JSON = $(JSON_SENOIDAL) 4 +# JSON = $(JSON_CIRCULAR) [OK]
  5 +# JSON = $(JSON_CONTATO_ALISAR) [--]
  6 +# JSON = $(JSON_CONTATO_COCAR) [--]
  7 +# JSON = $(JSON_CONTATO_TOCAR) [--]
  8 +# JSON = $(JSON_CONTATO_RISCAR) [--]
  9 +# JSON = $(JSON_FACIAL) [OK]
  10 +# JSON = $(JSON_HELICOIDAL) [OK]
  11 +# JSON = $(JSON_PONTUAL) [OK]
  12 +# JSON = $(JSON_RETILINEO) [OK]
  13 +# JSON = $(JSON_SEMICIRCULAR) [OK]
  14 +# JSON = $(JSON_SENOIDAL) [OK]
15 # ---------------------------- 15 # ----------------------------
16 16
17 JSON_CIRCULAR = \ 17 JSON_CIRCULAR = \
@@ -22,7 +22,8 @@ JSON_CIRCULAR = \ @@ -22,7 +22,8 @@ JSON_CIRCULAR = \
22 "movimentos": [ \ 22 "movimentos": [ \
23 { \ 23 { \
24 "facial": {}, \ 24 "facial": {}, \
25 - "mao_esquerda": { \ 25 + "mao_esquerda": {}, \
  26 + "mao_direita": { \
26 "circular": { \ 27 "circular": { \
27 "plano": "esquerda-cima", \ 28 "plano": "esquerda-cima", \
28 "raio": "pequeno", \ 29 "raio": "pequeno", \
@@ -30,11 +31,10 @@ JSON_CIRCULAR = \ @@ -30,11 +31,10 @@ JSON_CIRCULAR = \
30 "lado_oposto": false, \ 31 "lado_oposto": false, \
31 "sentido_inverso": false, \ 32 "sentido_inverso": false, \
32 "articulacao": 80, \ 33 "articulacao": 80, \
33 - "configuracao": 10, \  
34 - "orientacao": 20 \ 34 + "configuracao": 15, \
  35 + "orientacao": 18 \
35 } \ 36 } \
36 - }, \  
37 - "mao_direita": {} \ 37 + } \
38 } \ 38 } \
39 ] \ 39 ] \
40 }' 40 }'
@@ -47,7 +47,8 @@ JSON_CONTATO_ALISAR = \ @@ -47,7 +47,8 @@ JSON_CONTATO_ALISAR = \
47 "movimentos": [ \ 47 "movimentos": [ \
48 { \ 48 { \
49 "facial": {}, \ 49 "facial": {}, \
50 - "mao_direita": { \ 50 + "mao_direita": {}, \
  51 + "mao_esquerda": { \
51 "contato": { \ 52 "contato": { \
52 "movimento_orientacao": "paralelo", \ 53 "movimento_orientacao": "paralelo", \
53 "alisar": { \ 54 "alisar": { \
@@ -56,8 +57,7 @@ JSON_CONTATO_ALISAR = \ @@ -56,8 +57,7 @@ JSON_CONTATO_ALISAR = \
56 "orientacao": 11 \ 57 "orientacao": 11 \
57 } \ 58 } \
58 } \ 59 } \
59 - }, \  
60 - "mao_esquerda": {} \ 60 + } \
61 } \ 61 } \
62 ] \ 62 ] \
63 }' 63 }'
@@ -70,7 +70,8 @@ JSON_CONTATO_COCAR = \ @@ -70,7 +70,8 @@ JSON_CONTATO_COCAR = \
70 "movimentos": [ \ 70 "movimentos": [ \
71 { \ 71 { \
72 "facial": {}, \ 72 "facial": {}, \
73 - "mao_direita": { \ 73 + "mao_direita": {}, \
  74 + "mao_esquerda": { \
74 "contato": { \ 75 "contato": { \
75 "cocar": { \ 76 "cocar": { \
76 "articulacao": 71, \ 77 "articulacao": 71, \
@@ -78,8 +79,7 @@ JSON_CONTATO_COCAR = \ @@ -78,8 +79,7 @@ JSON_CONTATO_COCAR = \
78 "orientacao": 11 \ 79 "orientacao": 11 \
79 } \ 80 } \
80 } \ 81 } \
81 - }, \  
82 - "mao_esquerda": {} \ 82 + } \
83 } \ 83 } \
84 ] \ 84 ] \
85 }' 85 }'
@@ -92,7 +92,8 @@ JSON_CONTATO_TOCAR = \ @@ -92,7 +92,8 @@ JSON_CONTATO_TOCAR = \
92 "movimentos": [ \ 92 "movimentos": [ \
93 { \ 93 { \
94 "facial": {}, \ 94 "facial": {}, \
95 - "mao_direita": { \ 95 + "mao_direita": {}, \
  96 + "mao_esquerda": {}, \
96 "contato": { \ 97 "contato": { \
97 "tocar": { \ 98 "tocar": { \
98 "articulacao": 71, \ 99 "articulacao": 71, \
@@ -100,8 +101,7 @@ JSON_CONTATO_TOCAR = \ @@ -100,8 +101,7 @@ JSON_CONTATO_TOCAR = \
100 "orientacao": 11 \ 101 "orientacao": 11 \
101 } \ 102 } \
102 } \ 103 } \
103 - }, \  
104 - "mao_esquerda": {} \ 104 + } \
105 } \ 105 } \
106 ] \ 106 ] \
107 }' 107 }'
@@ -114,7 +114,8 @@ JSON_CONTATO_RISCAR = \ @@ -114,7 +114,8 @@ JSON_CONTATO_RISCAR = \
114 "movimentos": [ \ 114 "movimentos": [ \
115 { \ 115 { \
116 "facial": {}, \ 116 "facial": {}, \
117 - "mao_direita": { \ 117 + "mao_direita": {}, \
  118 + "mao_esquerda": { \
118 "contato": { \ 119 "contato": { \
119 "riscar": { \ 120 "riscar": { \
120 "articulacao": 71, \ 121 "articulacao": 71, \
@@ -122,8 +123,7 @@ JSON_CONTATO_RISCAR = \ @@ -122,8 +123,7 @@ JSON_CONTATO_RISCAR = \
122 "orientacao": 11 \ 123 "orientacao": 11 \
123 } \ 124 } \
124 } \ 125 } \
125 - }, \  
126 - "mao_esquerda": {} \ 126 + } \
127 } \ 127 } \
128 ] \ 128 ] \
129 }' 129 }'
@@ -135,22 +135,28 @@ JSON_FACIAL = \ @@ -135,22 +135,28 @@ JSON_FACIAL = \
135 "interpolacao": "normal", \ 135 "interpolacao": "normal", \
136 "movimentos": [ \ 136 "movimentos": [ \
137 { \ 137 { \
  138 + "mao_direita": {}, \
  139 + "mao_esquerda": {}, \
138 "facial": { \ 140 "facial": { \
139 "expressao": 10, \ 141 "expressao": 10, \
140 "transicao": "normal", \ 142 "transicao": "normal", \
141 "duracao": "normal" \ 143 "duracao": "normal" \
142 - }, \ 144 + } \
  145 + }, \
  146 + { \
143 "mao_direita": {}, \ 147 "mao_direita": {}, \
144 - "mao_esquerda": {} \ 148 + "mao_esquerda": {}, \
  149 + "facial": { \
  150 + } \
145 }, \ 151 }, \
146 { \ 152 { \
  153 + "mao_direita": {}, \
  154 + "mao_esquerda": {}, \
147 "facial": { \ 155 "facial": { \
148 "expressao": 11, \ 156 "expressao": 11, \
149 "transicao": "normal", \ 157 "transicao": "normal", \
150 "duracao": "normal" \ 158 "duracao": "normal" \
151 } \ 159 } \
152 - "mao_direita": {}, \  
153 - "mao_esquerda": {} \  
154 } \ 160 } \
155 ] \ 161 ] \
156 }' 162 }'
@@ -163,20 +169,21 @@ JSON_HELICOIDAL = \ @@ -163,20 +169,21 @@ JSON_HELICOIDAL = \
163 "movimentos": [ \ 169 "movimentos": [ \
164 { \ 170 { \
165 "facial": {}, \ 171 "facial": {}, \
166 - "mao_esquerda": { \ 172 + "mao_esquerda": {}, \
  173 + "mao_direita": { \
167 "helicoidal": { \ 174 "helicoidal": { \
168 "plano": "esquerda-cima", \ 175 "plano": "esquerda-cima", \
169 "raio": "pequeno", \ 176 "raio": "pequeno", \
170 "velocidade": "normal", \ 177 "velocidade": "normal", \
171 "lado_oposto": false, \ 178 "lado_oposto": false, \
172 - "sentido_inverso": false, \  
173 - "articulacao": 80, \  
174 - "configuracao": 10, \  
175 - "orientacao": 20 \ 179 + "sentido_inverso": true, \
  180 + "articulacao": 79, \
  181 + "configuracao": 0, \
  182 + "orientacao": 64 \
176 } \ 183 } \
177 - }, \  
178 - "mao_direita": {} \ 184 + } \
179 } \ 185 } \
  186 + ] \
180 }' 187 }'
181 188
182 JSON_PONTUAL = \ 189 JSON_PONTUAL = \
@@ -187,14 +194,13 @@ JSON_PONTUAL = \ @@ -187,14 +194,13 @@ JSON_PONTUAL = \
187 "movimentos": [ \ 194 "movimentos": [ \
188 { \ 195 { \
189 "facial": {}, \ 196 "facial": {}, \
190 - "mao_direita": { \ 197 + "mao_direita": {}, \
  198 + "mao_esquerda": { \
191 "pontual": { \ 199 "pontual": { \
192 "articulacao": 71, \ 200 "articulacao": 71, \
193 "configuracao": 19, \ 201 "configuracao": 19, \
194 "orientacao": 11 \ 202 "orientacao": 11 \
195 } \ 203 } \
196 - }, \  
197 - "mao_esquerda": { \  
198 } \ 204 } \
199 } \ 205 } \
200 ] \ 206 ] \
@@ -208,41 +214,42 @@ JSON_RETILINEO = \ @@ -208,41 +214,42 @@ JSON_RETILINEO = \
208 "movimentos": [ \ 214 "movimentos": [ \
209 { \ 215 { \
210 "facial": {}, \ 216 "facial": {}, \
211 - "mao_direita": { \ 217 + "mao_direita": {}, \
  218 + "mao_esquerda": { \
212 "retilineo": { \ 219 "retilineo": { \
213 "articulacao_inicial": 71, \ 220 "articulacao_inicial": 71, \
214 - "articulacao_final": 75, \  
215 - "configuracao": 19, \  
216 - "orientacao": 11 \ 221 + "configuracao_inicial": 19, \
  222 + "orientacao_inicial": 11, \
  223 + "articulacao_final": 78, \
  224 + "configuracao_final": 19, \
  225 + "orientacao_final": 11 \
217 } \ 226 } \
218 - }, \  
219 - "mao_esquerda": { \  
220 } \ 227 } \
221 } \ 228 } \
222 ] \ 229 ] \
223 }' 230 }'
224 231
225 -JSON_SEMI_CIRCULAR = \ 232 +JSON_SEMICIRCULAR = \
226 '{ \ 233 '{ \
227 "userId": "lavid", \ 234 "userId": "lavid", \
228 - "sinal": "modelo_semi_circular", \ 235 + "sinal": "modelo_semicircular", \
229 "interpolacao": "normal", \ 236 "interpolacao": "normal", \
230 "movimentos": [ \ 237 "movimentos": [ \
231 { \ 238 { \
232 "facial": {}, \ 239 "facial": {}, \
233 - "mao_esquerda": { \  
234 - "circular": { \ 240 + "mao_esquerda": {}, \
  241 + "mao_direita": { \
  242 + "semicircular": { \
235 "plano": "esquerda-cima", \ 243 "plano": "esquerda-cima", \
236 "raio": "pequeno", \ 244 "raio": "pequeno", \
237 "velocidade": "normal", \ 245 "velocidade": "normal", \
238 "lado_oposto": false, \ 246 "lado_oposto": false, \
239 "sentido_inverso": false, \ 247 "sentido_inverso": false, \
240 "articulacao": 80, \ 248 "articulacao": 80, \
241 - "configuracao": 10, \  
242 - "orientacao": 20 \ 249 + "configuracao": 15, \
  250 + "orientacao": 18 \
243 } \ 251 } \
244 - }, \  
245 - "mao_direita": {} \ 252 + } \
246 } \ 253 } \
247 ] \ 254 ] \
248 }' 255 }'
@@ -254,26 +261,22 @@ JSON_SENOIDAL = \ @@ -254,26 +261,22 @@ JSON_SENOIDAL = \
254 "interpolacao": "normal", \ 261 "interpolacao": "normal", \
255 "movimentos": [ \ 262 "movimentos": [ \
256 { \ 263 { \
257 - "facial": { \  
258 - "expressao": 10, \  
259 - "transicao": "normal", \  
260 - "duracao": "normal" \  
261 - }, \  
262 - "mao_esquerda": { \ 264 + "facial": {}, \
  265 + "mao_esquerda": {}, \
  266 + "mao_direita": { \
263 "circular": { \ 267 "circular": { \
264 "plano": "esquerda-cima", \ 268 "plano": "esquerda-cima", \
265 "raio": "pequeno", \ 269 "raio": "pequeno", \
266 "velocidade": "normal", \ 270 "velocidade": "normal", \
267 "lado_oposto": false, \ 271 "lado_oposto": false, \
268 "sentido_inverso": false, \ 272 "sentido_inverso": false, \
269 - "articulacao": 80, \  
270 - "configuracao": 10, \  
271 - "orientacao": 20 \ 273 + "articulacao": 79, \
  274 + "configuracao": 0, \
  275 + "orientacao": 64 \
272 } \ 276 } \
273 - }, \  
274 - "mao_direita": { \  
275 } \ 277 } \
276 } \ 278 } \
  279 + ] \
277 }' 280 }'
278 281
279 BLEND = avatar_cartoon_v2.74.blend 282 BLEND = avatar_cartoon_v2.74.blend
@@ -18,6 +18,6 @@ try: @@ -18,6 +18,6 @@ try:
18 # result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '--', sys.argv[1]], stdout = open('bpy.log', 'w')) 18 # result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '--', sys.argv[1]], stdout = open('bpy.log', 'w'))
19 result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '--', sys.argv[1]]) 19 result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '--', sys.argv[1]])
20 except: 20 except:
21 - result = pyutil.print_stack_trace(__file__) 21 + result = pyutil.print_stack_trace()
22 22
23 exit(result) 23 exit(result)
@@ -2,81 +2,33 @@ import bpy @@ -2,81 +2,33 @@ import bpy
2 import moves 2 import moves
3 import util 3 import util
4 4
5 -def circular_semicircular(js_movement, current_frame, frame_jump, is_right_hand, is_semicircular):  
6 - dict_ray = {  
7 - 'pequeno': 0.5,  
8 - 'normal': 1.0,  
9 - 'grande': 1.5  
10 - }  
11 - dict_period = {  
12 - 'lento': 55,  
13 - 'normal': 45,  
14 - 'rapido': 35  
15 - }  
16 - # decodificar valores  
17 - ray = dict_ray[js_movement['raio']]  
18 - period = dict_period[js_movement['velocidade']]  
19 - # diminuir a velocidade  
20 - if (js_movement['velocidade'] == 'lento'):  
21 - period += 10  
22 - # aumentar a velocidade  
23 - elif (js_movement['velocidade'] == 'rapido'):  
24 - period -= 10  
25 - # definir eixos do movimento  
26 - if (js_movement['plano'] == 'frente-esquerda'):  
27 - x, y = 2, 0  
28 - elif (js_movement['plano'] == 'frente-cima'):  
29 - x, y = 2, 1  
30 - else:  
31 - x, y = 0, 1  
32 - # mao usada (direita/esquerda)  
33 - if (is_right_hand):  
34 - ik = bpy.context.object.pose.bones['ik_FK.R']  
35 - else:  
36 - ik = bpy.context.object.pose.bones['ik_FK.L']  
37 - #current_frame = insert_keyframe_pose_default(current_frame, [ik], ['location'])  
38 - current_frame = moves.circular(ik, current_frame, ray, period, x, y, js_movement['lado_oposto'], js_movement['sentido_inverso'], is_semicircular)  
39 - return current_frame 5 +def facial(js_facial, current_frame, frame_jump):
  6 + return moves.facial(js_facial, current_frame, frame_jump)
40 7
41 def contato(js_movement, current_frame, frame_jump, is_right_hand): 8 def contato(js_movement, current_frame, frame_jump, is_right_hand):
42 sub_type = next(iter(js_movement.keys())) 9 sub_type = next(iter(js_movement.keys()))
43 mov_param = js_movement[sub_type] 10 mov_param = js_movement[sub_type]
44 action = util.right_hand_actions if is_right_hand else util.left_hand_actions 11 action = util.right_hand_actions if is_right_hand else util.left_hand_actions
45 bones = util.right_bones_conf if is_right_hand else util.left_bones_conf 12 bones = util.right_bones_conf if is_right_hand else util.left_bones_conf
46 - current_frame = current_frame + 2*frame_jump 13 + current_frame = current_frame + (2 * frame_jump)
47 return moves.contato(action, sub_type, mov_param, bones, is_right_hand, current_frame, frame_jump) 14 return moves.contato(action, sub_type, mov_param, bones, is_right_hand, current_frame, frame_jump)
48 15
49 -def helicoidal(js_movement, current_frame, frame_jump, is_right_hand):  
50 - return moves.helicoidal(js_movement, current_frame, frame_jump, is_right_hand)  
51 -  
52 -def pontual(js_movement, current_frame, frame_jump, is_right_hand):  
53 - return moves.pontual(js_movement, current_frame, frame_jump, is_right_hand)  
54 -  
55 -def retilineo(js_movement, current_frame, frame_jump, is_right_hand):  
56 - return moves.retilineo(js_movement, current_frame, frame_jump, is_right_hand)  
57 -  
58 -def semicircular(js_movement, current_frame, frame_jump, is_right_hand, is_semicircular):  
59 - return moves.semi_circular(js_movement, current_frame, frame_jump, is_right_hand)  
60 -  
61 -def senoidal(js_movement, current_frame, frame_jump, is_right_hand):  
62 - return moves.senoidal(js_movement, current_frame, frame_jump, is_right_hand)  
63 -  
64 def hand_mov(current_frame, frame_jump, js_mao, is_right_hand): 16 def hand_mov(current_frame, frame_jump, js_mao, is_right_hand):
65 if (js_mao == {}): 17 if (js_mao == {}):
66 - return current_frame 18 + return current_frame + (2 * frame_jump)
67 movement_name = next(iter(js_mao.keys())) 19 movement_name = next(iter(js_mao.keys()))
68 - if (movement_name == 'circular'):  
69 - current_frame = circular_semicircular(js_mao[movement_name], current_frame, frame_jump, is_right_hand, False)  
70 - elif (movement_name == 'semicircular'):  
71 - current_frame = circular_semicircular(js_mao[movement_name], current_frame, frame_jump, is_right_hand, True)  
72 - elif (movement_name == 'contato'): 20 + if (movement_name == "circular"):
  21 + current_frame = moves.circular(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
  22 + elif (movement_name == "semicircular"):
  23 + current_frame = moves.semicircular(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
  24 + elif (movement_name == "contato"):
73 current_frame = contato(js_mao[movement_name], current_frame, frame_jump, is_right_hand) 25 current_frame = contato(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
74 - elif (movement_name == 'helicoidal'):  
75 - current_frame = espiral(js_mao[movement_name], current_frame, frame_jump, is_right_hand)  
76 - elif (movement_name == 'pontual'):  
77 - current_frame = pontual(js_mao[movement_name], current_frame, frame_jump, is_right_hand)  
78 - elif (movement_name == 'retilineo'):  
79 - current_frame = retilineo(js_mao[movement_name], current_frame, frame_jump, is_right_hand)  
80 - elif (movement_name == 'senoidal'):  
81 - current_frame = senoidal(js_mao[movement_name], current_frame, frame_jump, is_right_hand) 26 + elif (movement_name == "helicoidal"):
  27 + current_frame = moves.helicoidal(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
  28 + elif (movement_name == "pontual"):
  29 + current_frame = moves.pontual(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
  30 + elif (movement_name == "retilineo"):
  31 + current_frame = moves.retilineo(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
  32 + elif (movement_name == "senoidal"):
  33 + current_frame = moves.senoidal(js_mao[movement_name], current_frame, frame_jump, is_right_hand)
82 return current_frame + frame_jump 34 return current_frame + frame_jump
facial.py
View file @42f9b71
@@ -1,113 +0,0 @@ @@ -1,113 +0,0 @@
1 -# -*- coding: UTF-8 -*-  
2 -  
3 -import bpy  
4 -import util  
5 -  
6 -# duracao na posicao selecionada  
7 -dict_duration = {  
8 - 'inicial': 10,  
9 - 'lento': 15,  
10 - 'normal': 10,  
11 - 'rapido': 5,  
12 - 'final': 10,  
13 -}  
14 -  
15 -# tempo de entrada e saida na posicao selecionada  
16 -dict_transition = {  
17 - 'inicial': 0,  
18 - 'lento': 15,  
19 - 'normal': 10,  
20 - 'rapido': 5  
21 -}  
22 -  
23 -# insere keyframes aos bones selecionados anteriormente e passados como parametro  
24 -def keyframe_insert(current_frame = 0, pose_bones = bpy.context.object.pose.bones, keyframe_types = ['location', 'rotation_quaternion']):  
25 - # verifica se existe apenas um bone  
26 - if (isinstance(pose_bones, int) or isinstance(pose_bones, str)):  
27 - # verifica se existe apenas um tipo de insercao de keyframe  
28 - if (isinstance(keyframe_types, str)):  
29 - bpy.context.object.pose.bones[pose_bones].keyframe_insert(index = -1, frame = current_frame, group = bpy.context.object.pose.bones[pose_bones].name, data_path = keyframe_types)  
30 - # verifica se existe mais de um tipo de insercao de keyframe  
31 - elif (isinstance(keyframe_types, list)):  
32 - for keyframe_type in keyframe_types:  
33 - bpy.context.object.pose.bones[bones].keyframe_insert(index = -1, frame = current_frame, group = bpy.context.object.pose.bones[pose_bones].name, data_path = keyframe_type)  
34 - # verifica se existe mais de um bone  
35 - elif (isinstance(pose_bones, list)):  
36 - for bone in pose_bones:  
37 - # verifica se existe apenas um tipo de insercao de keyframe  
38 - if (isinstance(keyframe_types, str)):  
39 - bpy.context.object.pose.bones[bone].keyframe_insert(index = -1, frame = current_frame, group = bpy.context.object.pose.bones[bone].name, data_path = keyframe_types)  
40 - # verifica se existe mais de um tipo de insercao de keyframe  
41 - elif (isinstance(keyframe_types, list)):  
42 - for keyframe_type in keyframe_types:  
43 - bpy.context.object.pose.bones[bone].keyframe_insert(index = -1, frame = current_frame, group = bpy.context.object.pose.bones[bone].name, data_path = keyframe_type)  
44 - return  
45 -  
46 -# aplica biblioteca(s) de pose(s) e seu respectivo indice  
47 -def apply_pose(index = 0, pose_library = list(bpy.data.actions)):  
48 - # verifica se deve aplicar apenas uma biblioteca  
49 - if (isinstance(pose_library, int) or isinstance(pose_library, str)):  
50 - # verifica biblioteca fake_user  
51 - if (bpy.data.actions[pose_library].use_fake_user):  
52 - bpy.context.object.pose_library = bpy.data.actions[pose_library]  
53 - bpy.ops.poselib.apply_pose(pose_index = index)  
54 - # verifica se deve aplicar mais de uma biblioteca  
55 - elif (isinstance(pose_library, list)):  
56 - for library in pose_library:  
57 - # verifica biblioteca fake_user  
58 - if (library.use_fake_user):  
59 - bpy.context.object.pose_library = library  
60 - bpy.ops.poselib.apply_pose(pose_index = index)  
61 - bpy.context.object.pose_library = None  
62 - return  
63 -  
64 -# consolida o movimento (faz insercao dos keyframes) e incrementa a timeline  
65 -def set_expression(timeline_facial, index, frame_duration = dict_duration['normal'], frame_transition = dict_transition['inicial']):  
66 - library_name = util.facial_expression_id  
67 - bones_facial = util.dict_bones[library_name]  
68 - util.select_bones(bones_facial)  
69 - # TODO separar bones 'location' e 'rotation_quaternion'  
70 - keyframe_insert(timeline_facial, bones_facial, ['location', 'rotation_quaternion'])  
71 - apply_pose(index, library_name)  
72 - timeline_facial += frame_transition  
73 - keyframe_insert(timeline_facial, bones_facial, ['location', 'rotation_quaternion'])  
74 - timeline_facial += frame_duration  
75 - keyframe_insert(timeline_facial, bones_facial, ['location', 'rotation_quaternion'])  
76 - timeline_facial += frame_transition  
77 - util.deselect_bones(bones_facial)  
78 - return timeline_facial  
79 -  
80 -# decodifica objeto JSON  
81 -def decode_expression(timeline_facial, js_facial, initial_interpolation = dict_duration['normal']):  
82 - global dict_duration  
83 - global dict_transition  
84 - index = js_facial['expressao']  
85 - frame_duration = dict_duration[js_facial['duracao']]  
86 - frame_transition = dict_transition[js_facial['transicao']]  
87 - # insere o primeiro keyframe  
88 - if (timeline_facial == 0):  
89 - timeline_facial = set_expression(timeline_facial, 0, initial_interpolation)  
90 - timeline_facial = set_expression(timeline_facial, index, frame_duration, frame_transition)  
91 - timeline_facial = set_expression(timeline_facial, 0, frame_duration)  
92 - return timeline_facial  
93 -  
94 -"""  
95 -# unit test  
96 -def main():  
97 - timeline_facial = 0  
98 - util.delete_all_keyframes()  
99 - expressoes = list(range(0, round(bpy.data.actions[util.facial_expression_id].frame_range[1]) + 1))  
100 - expressoes = [10, 11]  
101 - for i in expressoes:  
102 - js_facial = {  
103 - "expressao": i,  
104 - "transicao": "normal",  
105 - "duracao": "normal"  
106 - }  
107 - timeline_facial = decode_expression(timeline_facial, js_facial, dict_duration['inicial'])  
108 - bpy.context.scene.frame_end = timeline_facial + dict_duration['final']  
109 - bpy.ops.screen.animation_play(reverse = False)  
110 -  
111 -if __name__ == "__main__":  
112 - main()  
113 -"""  
114 \ No newline at end of file 0 \ No newline at end of file
@@ -4,6 +4,7 @@ @@ -4,6 +4,7 @@
4 import bpy 4 import bpy
5 5
6 # importa modulos do Python 6 # importa modulos do Python
  7 +import io
7 import json 8 import json
8 import sys 9 import sys
9 import os 10 import os
@@ -18,25 +19,15 @@ sys.path.insert(0, getcwd) @@ -18,25 +19,15 @@ sys.path.insert(0, getcwd)
18 import util 19 import util
19 import moves 20 import moves
20 import pyutil 21 import pyutil
21 -import facial  
22 import decode 22 import decode
23 23
24 -# intervalos de interpolacao dos keyframes  
25 -dict_interpolation = {  
26 - 'inicial': 20,  
27 - 'lento': 15,  
28 - 'normal': 10,  
29 - 'rapido': 5,  
30 - 'final': 20  
31 -}  
32 -  
33 -def insert_keyframe_pose_default(current_frame = 0, pose_bones = bpy.context.object.pose.bones, types_keyframe = ['location', 'rotation_quaternion']): 24 +def insert_keyframe_pose_default(current_frame = 0, pose_bones = bpy.context.object.pose.bones, types_keyframe = ["location", "rotation_quaternion"]):
34 for obj in (pose_bones): 25 for obj in (pose_bones):
35 obj.bone.select = True 26 obj.bone.select = True
36 for type_keyframe in types_keyframe: 27 for type_keyframe in types_keyframe:
37 util.keyframe_insert(obj, type_keyframe, current_frame, False) 28 util.keyframe_insert(obj, type_keyframe, current_frame, False)
38 obj.bone.select = False 29 obj.bone.select = False
39 - return current_frame 30 + return
40 31
41 def pose_default(current_frame = 0, frame_jump = 0, actions = bpy.data.actions): 32 def pose_default(current_frame = 0, frame_jump = 0, actions = bpy.data.actions):
42 for action in actions: 33 for action in actions:
@@ -54,55 +45,55 @@ def main(): @@ -54,55 +45,55 @@ def main():
54 45
55 try: 46 try:
56 js_input = json.loads(sys.argv[6]) 47 js_input = json.loads(sys.argv[6])
57 - js_movimentos = js_input['movimentos']  
58 - frame_jump = dict_interpolation[js_input['interpolacao']] 48 + js_movimentos = js_input["movimentos"]
  49 + frame_jump = util.dict_interpolation[js_input["interpolacao"]]
59 50
60 endFrame = pose_default(0, frame_jump) 51 endFrame = pose_default(0, frame_jump)
  52 + timeline_facial = 0
61 timeline_mao_esquerda = 0 53 timeline_mao_esquerda = 0
62 timeline_mao_direita = 0 54 timeline_mao_direita = 0
63 - timeline_facial = 0  
64 55
65 - # setar pose padrao inicial em todos os bones ('location' e 'rotation_quaternion')  
66 - endFrame += pose_default(dict_interpolation['inicial']) 56 + # setar pose padrao inicial em todos os bones ("location" e "rotation_quaternion")
  57 + endFrame += pose_default(util.dict_interpolation["inicial"])
67 58
68 for i in range(0, len(js_movimentos)): 59 for i in range(0, len(js_movimentos)):
  60 + timeline_facial = endFrame
69 timeline_mao_esquerda = endFrame 61 timeline_mao_esquerda = endFrame
70 timeline_mao_direita = endFrame 62 timeline_mao_direita = endFrame
71 63
72 # tenta decodificar objetos JSON 64 # tenta decodificar objetos JSON
73 try: 65 try:
74 - js_facial = js_movimentos[i]['facial'] 66 + js_facial = js_movimentos[i]["facial"]
75 except: 67 except:
76 js_facial = {} 68 js_facial = {}
77 try: 69 try:
78 - js_mao_esquerda = js_movimentos[i]['mao_esquerda'] 70 + js_mao_esquerda = js_movimentos[i]["mao_esquerda"]
79 except: 71 except:
80 js_mao_esquerda = {} 72 js_mao_esquerda = {}
81 try: 73 try:
82 - js_mao_direita = js_movimentos[i]['mao_direita'] 74 + js_mao_direita = js_movimentos[i]["mao_direita"]
83 except: 75 except:
84 js_mao_direita = {} 76 js_mao_direita = {}
85 77
86 # faz tratamento dos objetos 78 # faz tratamento dos objetos
87 if (js_facial == {}): 79 if (js_facial == {}):
88 - print("movimento [%d] Exp facial = <Vazio>" % (i))  
89 - timeline_facial = facial.set_expression(timeline_facial, 0) 80 + pyutil.log("movimento [%d] Exp facial = <Vazio>" % (i))
90 else: 81 else:
91 - print("movimento [%d] Exp facial = [%d]" % (i, js_facial["expressao"]))  
92 - timeline_facial = facial.decode_expression(timeline_facial, js_facial) 82 + pyutil.log("movimento [%d] Exp facial = [%d]" % (i, js_facial["expressao"]))
  83 + timeline_facial = decode.facial(js_facial, timeline_facial, frame_jump)
93 84
94 if (js_mao_esquerda == {}): 85 if (js_mao_esquerda == {}):
95 - print("movimento [%d] Mao Esquerda = <Vazio>" % (i)) 86 + pyutil.log("movimento [%d] Mao Esquerda = <Vazio>" % (i))
96 # TODO posicionar mao esquerda na lateral do corpo 87 # TODO posicionar mao esquerda na lateral do corpo
97 else: 88 else:
98 - print("movimento [%d] Mao Esquerda = [%s]" % (i, next(iter(js_mao_esquerda.keys())))) 89 + pyutil.log("movimento [%d] Mao Esquerda = [%s]" % (i, next(iter(js_mao_esquerda.keys()))))
99 timeline_mao_esquerda = decode.hand_mov(timeline_mao_esquerda, frame_jump, js_mao_esquerda, False) 90 timeline_mao_esquerda = decode.hand_mov(timeline_mao_esquerda, frame_jump, js_mao_esquerda, False)
100 91
101 if (js_mao_direita == {}): 92 if (js_mao_direita == {}):
102 - print("movimento [%d] Mao Direita = <Vazio>" % (i)) 93 + pyutil.log("movimento [%d] Mao Direita = <Vazio>" % (i))
103 # TODO posicionar mao direita na lateral do corpo 94 # TODO posicionar mao direita na lateral do corpo
104 else: 95 else:
105 - print("movimento [%d] Mao Direita = [%s]" % (i, next(iter(js_mao_direita.keys())))) 96 + pyutil.log("movimento [%d] Mao Direita = [%s]" % (i, next(iter(js_mao_direita.keys()))))
106 timeline_mao_direita = decode.hand_mov(timeline_mao_direita, frame_jump, js_mao_direita, True) 97 timeline_mao_direita = decode.hand_mov(timeline_mao_direita, frame_jump, js_mao_direita, True)
107 98
108 endFrame = max(timeline_facial, timeline_mao_esquerda, timeline_mao_direita) 99 endFrame = max(timeline_facial, timeline_mao_esquerda, timeline_mao_direita)
@@ -110,12 +101,23 @@ def main(): @@ -110,12 +101,23 @@ def main():
110 101
111 # setar pose padrao final em todos os bones (location e rotation) 102 # setar pose padrao final em todos os bones (location e rotation)
112 endFrame = pose_default(endFrame, frame_jump) 103 endFrame = pose_default(endFrame, frame_jump)
113 - endFrame += dict_interpolation['final'] 104 + endFrame += util.dict_interpolation["final"]
  105 +
  106 + sinal = str(js_input["sinal"])
  107 + user_id = str(js_input["userId"])
  108 + directory = os.path.join(getcwd, "users", user_id)
  109 +
  110 + # exporta .blend
  111 + util.export_blend(directory, sinal + ".blend", 0, 0, endFrame)
  112 +
  113 + # exporta .json
  114 + util.export_json(js_input, directory, sinal + ".json")
114 115
115 - util.render_sign(js_input["userId"], js_input["sinal"], endFrame) 116 + # exporta .mp4
  117 + util.render_sign(user_id, sinal, endFrame)
116 118
117 except: 119 except:
118 - pyutil.print_stack_trace(__file__) 120 + pyutil.print_stack_trace()
119 raise 121 raise
120 122
121 if __name__ == "__main__": 123 if __name__ == "__main__":
@@ -5,6 +5,51 @@ import math @@ -5,6 +5,51 @@ import math
5 import util 5 import util
6 import pyutil 6 import pyutil
7 7
  8 +def facial_insert_keyframe(current_frame):
  9 + bones_facial = util.dict_bones[util.facial_expression_id]
  10 + util.select_bones(bones_facial)
  11 + for bone in bones_facial:
  12 + for keyframe_type in ["location", "rotation_quaternion"]:
  13 + bpy.context.object.pose.bones[bone].keyframe_insert(index = -1, frame = current_frame, group = bpy.context.object.pose.bones[bone].name, data_path = keyframe_type)
  14 + util.deselect_bones(bones_facial)
  15 +
  16 +def facial_set_expression(timeline_facial, index, frame_duration, frame_transition):
  17 + facial_insert_keyframe(timeline_facial)
  18 + util.deselect_bones()
  19 + bpy.context.object.pose_library = bpy.data.actions[util.facial_expression_id]
  20 + bpy.ops.poselib.apply_pose(pose_index = index)
  21 + bpy.context.object.pose_library = None
  22 + timeline_facial += frame_transition
  23 + facial_insert_keyframe(timeline_facial)
  24 + timeline_facial += frame_duration
  25 + facial_insert_keyframe(timeline_facial)
  26 + timeline_facial += frame_transition
  27 + return timeline_facial
  28 +
  29 +def facial(js_facial, current_frame, frame_jump):
  30 + dict_duration = {
  31 + "inicial": 5,
  32 + "lento": 15,
  33 + "normal": 10,
  34 + "rapido": 5,
  35 + "final": 5,
  36 + }
  37 + dict_transition = {
  38 + "inicial": 0,
  39 + "lento": 15,
  40 + "normal": 10,
  41 + "rapido": 5,
  42 + "final": 0
  43 + }
  44 + index = js_facial["expressao"]
  45 + frame_duration = dict_duration[js_facial["duracao"]]
  46 + frame_transition = dict_transition[js_facial["transicao"]]
  47 + if (current_frame == 0):
  48 + current_frame = facial_set_expression(current_frame, 0, initial_interpolation, dict_transition["normal"])
  49 + current_frame = facial_set_expression(current_frame, index, frame_duration, frame_transition)
  50 + current_frame = facial_set_expression(current_frame, 0, frame_duration, dict_transition["normal"])
  51 + return current_frame
  52 +
8 def read_hand_param(mov_param): 53 def read_hand_param(mov_param):
9 conf_param = mov_param['configuracao'] if 'configuracao' in mov_param else 0 54 conf_param = mov_param['configuracao'] if 'configuracao' in mov_param else 0
10 artic_param = mov_param['articulacao'] if 'articulacao' in mov_param else 0 55 artic_param = mov_param['articulacao'] if 'articulacao' in mov_param else 0
@@ -26,13 +71,11 @@ def riscar(action, mov_param, bones, is_right_hand, initialFrame = 25, frameJump @@ -26,13 +71,11 @@ def riscar(action, mov_param, bones, is_right_hand, initialFrame = 25, frameJump
26 currentFrame = initialFrame 71 currentFrame = initialFrame
27 handParam = read_hand_param(mov_param) 72 handParam = read_hand_param(mov_param)
28 lado = "R" if is_right_hand else "L" 73 lado = "R" if is_right_hand else "L"
29 -  
30 bnAntBraco = bpy.context.object.pose.bones["BnAntBraco." + lado] 74 bnAntBraco = bpy.context.object.pose.bones["BnAntBraco." + lado]
31 currentFrame += frameJump 75 currentFrame += frameJump
32 util.apply_rotation(bnAntBraco, "Z", currentFrame, bnAntBracoDegree) 76 util.apply_rotation(bnAntBraco, "Z", currentFrame, bnAntBracoDegree)
33 currentFrame += frameJump 77 currentFrame += frameJump
34 util.apply_rotation(bnAntBraco, "Z", currentFrame, (-1)*(bnAntBracoDegree+1)) 78 util.apply_rotation(bnAntBraco, "Z", currentFrame, (-1)*(bnAntBracoDegree+1))
35 -  
36 currentFrame = initialFrame 79 currentFrame = initialFrame
37 util.setPose(action, handParam, [currentFrame], bones) 80 util.setPose(action, handParam, [currentFrame], bones)
38 bnMao = bpy.context.object.pose.bones["BnMao." + lado] 81 bnMao = bpy.context.object.pose.bones["BnMao." + lado]
@@ -51,7 +94,6 @@ def tocar(action, mov_param, bones, is_right_hand, initialFrame = 25, degree = 3 @@ -51,7 +94,6 @@ def tocar(action, mov_param, bones, is_right_hand, initialFrame = 25, degree = 3
51 handParam = read_hand_param(mov_param) 94 handParam = read_hand_param(mov_param)
52 util.setPose(action, handParam, [initialFrame], bones) 95 util.setPose(action, handParam, [initialFrame], bones)
53 pose = util.armature.pose.bones["ik_FK.R" if is_right_hand else "ik_FK.L"] 96 pose = util.armature.pose.bones["ik_FK.R" if is_right_hand else "ik_FK.L"]
54 -  
55 lado = "BnMao.R" if is_right_hand else "BnMao.L" 97 lado = "BnMao.R" if is_right_hand else "BnMao.L"
56 bnMao = bpy.context.object.pose.bones[lado] 98 bnMao = bpy.context.object.pose.bones[lado]
57 currentFrame += frameJump 99 currentFrame += frameJump
@@ -66,7 +108,6 @@ def cocar(action, mov_param, bones, initialFrame = 18, frameJump = 10): @@ -66,7 +108,6 @@ def cocar(action, mov_param, bones, initialFrame = 18, frameJump = 10):
66 currentFrame = initialFrame 108 currentFrame = initialFrame
67 pa_index = mov_param['articulacao'] if 'articulacao' in mov_param else 0 109 pa_index = mov_param['articulacao'] if 'articulacao' in mov_param else 0
68 repetition = mov_param['repeticoes'] if 'repeticoes' in mov_param else 2 110 repetition = mov_param['repeticoes'] if 'repeticoes' in mov_param else 2
69 -  
70 for i in range(0, repetition): 111 for i in range(0, repetition):
71 util.setPose(action, [util.cocar_mao_aberta_index, pa_index, util.cocar_orientation_index], [currentFrame], bones, False) 112 util.setPose(action, [util.cocar_mao_aberta_index, pa_index, util.cocar_orientation_index], [currentFrame], bones, False)
72 currentFrame += frameJump 113 currentFrame += frameJump
@@ -81,7 +122,6 @@ def alisar(action, mov_param, bones, is_right_hand, initialFrame = 18, frameJump @@ -81,7 +122,6 @@ def alisar(action, mov_param, bones, is_right_hand, initialFrame = 18, frameJump
81 handParam = read_hand_param(mov_param) 122 handParam = read_hand_param(mov_param)
82 util.setPose(action, handParam, [currentFrame], bones) 123 util.setPose(action, handParam, [currentFrame], bones)
83 boneIK = util.armature.pose.bones["ik_FK.R" if is_right_hand else "ik_FK.L"] 124 boneIK = util.armature.pose.bones["ik_FK.R" if is_right_hand else "ik_FK.L"]
84 -  
85 if (plane == "perpendicular"): 125 if (plane == "perpendicular"):
86 currentFrame = alisar_xy(boneIK, 1, repetition, currentFrame, frameJump, width) 126 currentFrame = alisar_xy(boneIK, 1, repetition, currentFrame, frameJump, width)
87 elif (plane == "paralelo"): 127 elif (plane == "paralelo"):
@@ -138,70 +178,192 @@ def alisar_diagonal(boneIK, to_right, repetition, initialFrame = 18, frameJump = @@ -138,70 +178,192 @@ def alisar_diagonal(boneIK, to_right, repetition, initialFrame = 18, frameJump =
138 # raio: "grande" raio = 1.5, velocidade: "rapido" periodo = 45 178 # raio: "grande" raio = 1.5, velocidade: "rapido" periodo = 45
139 # raio: "grande" raio = 1.5, velocidade: "normal" periodo = 55 179 # raio: "grande" raio = 1.5, velocidade: "normal" periodo = 55
140 # raio: "grande" raio = 1.5, velocidade: "lento" periodo = 65 180 # raio: "grande" raio = 1.5, velocidade: "lento" periodo = 65
141 -# @param obj: (objeto) bone, mesh, e.g.  
142 -# @param current_frame: (int) posicao onde o primeiro keyframe vai ser inserido  
143 -# @param raio: (int) raio da circunferencia  
144 -# @param periodo: (int) quantidade de keyframes necessarios para completar uma volta completa  
145 -# @param x: (int) in [0,1,2] define qual eixo vai variar no seno (0 = eixo X, 1 = eixo Y, 2 = eixo Z)  
146 -# @param y: (int) in [0,1,2] define qual eixo vai variar no cosseno (0 = eixo X, 1 = eixo Y, 2 = eixo Z)  
147 -# @param usar_lado_oposto: (bool) inverte o lado da primeira posicao (pode ser util em alguns casos para espelhar)  
148 -# @param usar_sentido_oposto (bool) inverte o sentido do movimento (horario para anti-horario)  
149 -def circular(obj, current_frame, raio, periodo, x = 0, y = 1, usar_lado_oposto = False, usar_sentido_oposto = False, meia_volta = False):  
150 - # limita inferiormente  
151 - if (periodo < 16):  
152 - periodo = 16  
153 - # limita superiormente  
154 - elif (periodo > 360):  
155 - periodo = 360  
156 - # muda lado inicial  
157 - if (usar_lado_oposto):  
158 - k = round(periodo / 2) 181 +def circular(js_movement, current_frame, frame_jump, is_right_hand, is_semicircular = False):
  182 + dict_ray = {
  183 + "pequeno": 0.5,
  184 + "normal": 1.0,
  185 + "grande": 1.5
  186 + }
  187 + dict_period = {
  188 + "lento": 55,
  189 + "normal": 45,
  190 + "rapido": 35
  191 + }
  192 + ray = dict_ray[js_movement["raio"]]
  193 + period = dict_period[js_movement["velocidade"]]
  194 + opposite_side = js_movement["lado_oposto"]
  195 + reverse_way = js_movement["sentido_inverso"]
  196 + actions = util.right_hand_actions if (is_right_hand) else util.left_hand_actions
  197 + hand_param = read_hand_param(js_movement)
  198 + bones = util.right_bones_conf if (is_right_hand) else util.left_bones_conf
  199 + ik = bpy.context.object.pose.bones["ik_FK.R" if (is_right_hand) else "ik_FK.L"]
  200 + if (js_movement["velocidade"] == "lento"):
  201 + period += 10
  202 + elif (js_movement["velocidade"] == "rapido"):
  203 + period -= 10
  204 + if (js_movement["plano"] == "frente-esquerda"):
  205 + x, y = 2, 0
  206 + elif (js_movement["plano"] == "frente-cima"):
  207 + x, y = 2, 1
  208 + else:
  209 + x, y = 0, 1
  210 + k = round(period / 2) if (opposite_side) else 0
  211 + x %= 3
  212 + y %= 3
  213 + if (reverse_way):
  214 + tmp = x
  215 + x = y
  216 + y = tmp
  217 + util.setPose(actions, hand_param, [current_frame], bones, False)
  218 + util.keyframe_insert(bones, "location", current_frame, False, False)
  219 + ik_loc = [ik.location[0], ik.location[1], ik.location[2]]
  220 + limit = period + k - 1
  221 + if (is_semicircular):
  222 + limit = round(period / 2) + k
  223 + for i in range(k, limit + 1):
  224 + bpy.context.object.pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
  225 + bpy.ops.poselib.apply_pose(pose_index = hand_param[0])
  226 + bpy.context.object.pose_library = None
  227 + util.keyframe_insert(bones, "location", current_frame, False)
  228 + util.keyframe_insert(bones, "rotation_quaternion", current_frame, False)
  229 + ik.location[x] = ik_loc[x] + (ray * math.cos(i / period * (2 * math.pi)))
  230 + ik.location[y] = ik_loc[y] + (ray * math.sin(i / period * (2 * math.pi)))
  231 + util.keyframe_insert(ik, "location", current_frame)
  232 + util.keyframe_insert(ik, "rotation_quaternion", current_frame, False)
  233 + current_frame += 1
  234 + return current_frame
  235 +
  236 +def helicoidal(js_movement, current_frame, frame_jump, is_right_hand):
  237 + dict_ray = {
  238 + "pequeno": 0.5,
  239 + "normal": 1.0,
  240 + "grande": 1.5
  241 + }
  242 + dict_period = {
  243 + "lento": 55,
  244 + "normal": 45,
  245 + "rapido": 35
  246 + }
  247 + ray = dict_ray[js_movement["raio"]]
  248 + period = dict_period[js_movement["velocidade"]]
  249 + opposite_side = js_movement["lado_oposto"]
  250 + reverse_way = js_movement["sentido_inverso"]
  251 + actions = util.right_hand_actions if (is_right_hand) else util.left_hand_actions
  252 + hand_param = read_hand_param(js_movement)
  253 + bones = util.right_bones_conf if (is_right_hand) else util.left_bones_conf
  254 + ik = bpy.context.object.pose.bones["ik_FK.R" if (is_right_hand) else "ik_FK.L"]
  255 + if (js_movement["velocidade"] == "lento"):
  256 + period += 10
  257 + elif (js_movement["velocidade"] == "rapido"):
  258 + period -= 10
  259 + if (js_movement["plano"] == "frente-esquerda"):
  260 + x, y, z = 2, 0, 1
  261 + elif (js_movement["plano"] == "frente-cima"):
  262 + x, y, z = 2, 1, 0
159 else: 263 else:
160 - k = 0  
161 - # evita estouro dos indices 264 + x, y, z = 0, 1, 2
  265 + k = round(period / 2) if (opposite_side) else 0
162 x %= 3 266 x %= 3
163 y %= 3 267 y %= 3
164 - # inverte direcao do movimento  
165 - if (usar_sentido_oposto): 268 + if (reverse_way):
166 tmp = x 269 tmp = x
167 x = y 270 x = y
168 y = tmp 271 y = tmp
169 - # copia posicao inicial para transladar  
170 - loc = [obj.location[0], obj.location[1], obj.location[2]]  
171 - # semi-circular  
172 - limite = periodo + k  
173 - if (meia_volta):  
174 - limite = round(limite / 2)  
175 - for i in range(k, limite + 1):  
176 - # reduz a quantidade de keyframes  
177 - if (current_frame % 2 == 0):  
178 - obj.location[x] = loc[x] + (raio * math.cos(i / periodo * (2 * math.pi)))  
179 - obj.location[y] = loc[y] + (raio * math.sin(i / periodo * (2 * math.pi)))  
180 - util.keyframe_insert(obj, 'location', current_frame) 272 + util.setPose(actions, hand_param, [current_frame], bones, False)
  273 + util.keyframe_insert(bones, "location", current_frame, False, False)
  274 + ik_loc = [ik.location[0], ik.location[1], ik.location[2]]
  275 + limit = period + k - 1
  276 + for i in range(k, 2 * (limit + 1)):
  277 + bpy.context.object.pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
  278 + bpy.ops.poselib.apply_pose(pose_index = hand_param[0])
  279 + bpy.context.object.pose_library = None
  280 + util.keyframe_insert(bones, "location", current_frame, False)
  281 + util.keyframe_insert(bones, "rotation_quaternion", current_frame, False)
  282 + ik.location[x] = ik_loc[x] + (ray * math.cos(i / period * (2 * math.pi)))
  283 + ik.location[y] = ik_loc[y] + (ray * math.sin(i / period * (2 * math.pi)))
  284 + ik.location[z] = ik_loc[z] + (i / period) - ray
  285 + util.keyframe_insert(ik, "location", current_frame)
  286 + util.keyframe_insert(ik, "rotation_quaternion", current_frame, False)
181 current_frame += 1 287 current_frame += 1
182 - util.keyframe_insert(obj, 'location', current_frame)  
183 - return periodo - 1 288 + return current_frame
184 289
185 def pontual(js_movement, current_frame, frame_jump, is_right_hand): 290 def pontual(js_movement, current_frame, frame_jump, is_right_hand):
186 hand_param = read_hand_param(js_movement) 291 hand_param = read_hand_param(js_movement)
187 bones = util.right_bones_conf if is_right_hand else util.left_bones_conf 292 bones = util.right_bones_conf if is_right_hand else util.left_bones_conf
188 hand_actions = util.right_hand_actions if is_right_hand else util.left_hand_actions 293 hand_actions = util.right_hand_actions if is_right_hand else util.left_hand_actions
189 - util.keyframe_insert(bones, 'location', current_frame) 294 + util.keyframe_insert(bones, "location", current_frame)
190 current_frame += frame_jump 295 current_frame += frame_jump
191 util.setPose(hand_actions, hand_param, [current_frame], bones) 296 util.setPose(hand_actions, hand_param, [current_frame], bones)
192 current_frame += frame_jump 297 current_frame += frame_jump
193 - util.keyframe_insert(bones, 'location', current_frame) 298 + util.keyframe_insert(bones, "location", current_frame)
194 return current_frame 299 return current_frame
195 300
196 def retilineo(js_movement, current_frame, frame_jump, is_right_hand): 301 def retilineo(js_movement, current_frame, frame_jump, is_right_hand):
197 - hand_param = [js_movement['configuracao'], js_movement['articulacao_inicial'], js_movement['orientacao']] 302 + hand_param = [js_movement["configuracao_inicial"], js_movement["articulacao_inicial"], js_movement["orientacao_inicial"]]
198 bones = util.right_bones_conf if is_right_hand else util.left_bones_conf 303 bones = util.right_bones_conf if is_right_hand else util.left_bones_conf
199 hand_actions = util.right_hand_actions if is_right_hand else util.left_hand_actions 304 hand_actions = util.right_hand_actions if is_right_hand else util.left_hand_actions
200 - util.keyframe_insert(bones, 'location', current_frame) 305 + util.keyframe_insert(bones, "location", current_frame)
201 current_frame += frame_jump 306 current_frame += frame_jump
202 util.setPose(hand_actions, hand_param, [current_frame], bones) 307 util.setPose(hand_actions, hand_param, [current_frame], bones)
203 - current_frame += 2* frame_jump  
204 - hand_param = [js_movement['configuracao'], js_movement['articulacao_final'], js_movement['orientacao']] 308 + current_frame += 2 * frame_jump
  309 + hand_param = [js_movement["configuracao_final"], js_movement["articulacao_final"], js_movement["orientacao_final"]]
205 util.setPose(hand_actions, hand_param, [current_frame], bones) 310 util.setPose(hand_actions, hand_param, [current_frame], bones)
206 - util.keyframe_insert(bones, 'location', current_frame) 311 + util.keyframe_insert(bones, "location", current_frame)
  312 + return current_frame
  313 +
  314 +def semicircular(js_movement, current_frame, frame_jump, is_right_hand):
  315 + return circular(js_movement, current_frame, frame_jump, is_right_hand, True)
  316 +
  317 +def senoidal(js_movement, current_frame, frame_jump, is_right_hand):
  318 + dict_ray = {
  319 + "pequeno": 0.5,
  320 + "normal": 1.0,
  321 + "grande": 1.5
  322 + }
  323 + dict_period = {
  324 + "lento": 55,
  325 + "normal": 45,
  326 + "rapido": 35
  327 + }
  328 + ray = dict_ray[js_movement["raio"]]
  329 + period = dict_period[js_movement["velocidade"]]
  330 + opposite_side = js_movement["lado_oposto"]
  331 + reverse_way = js_movement["sentido_inverso"]
  332 + actions = util.right_hand_actions if (is_right_hand) else util.left_hand_actions
  333 + hand_param = read_hand_param(js_movement)
  334 + bones = util.right_bones_conf if (is_right_hand) else util.left_bones_conf
  335 + ik = bpy.context.object.pose.bones["ik_FK.R" if (is_right_hand) else "ik_FK.L"]
  336 + if (js_movement["velocidade"] == "lento"):
  337 + period += 10
  338 + elif (js_movement["velocidade"] == "rapido"):
  339 + period -= 10
  340 + if (js_movement["plano"] == "frente-esquerda"):
  341 + x, y, z = 2, 0, 1
  342 + elif (js_movement["plano"] == "frente-cima"):
  343 + x, y, z = 2, 1, 0
  344 + else:
  345 + x, y, z = 0, 1, 2
  346 + k = round(period / 2) if (opposite_side) else 0
  347 + x %= 3
  348 + y %= 3
  349 + if (reverse_way):
  350 + tmp = x
  351 + x = y
  352 + y = tmp
  353 + util.setPose(actions, hand_param, [current_frame], bones, False)
  354 + util.keyframe_insert(bones, "location", current_frame, False, False)
  355 + ik_loc = [ik.location[0], ik.location[1], ik.location[2]]
  356 + limit = period + k - 1
  357 + for i in range(k, 2 * (limit + 1)):
  358 + bpy.context.object.pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
  359 + bpy.ops.poselib.apply_pose(pose_index = hand_param[0])
  360 + bpy.context.object.pose_library = None
  361 + util.keyframe_insert(bones, "location", current_frame, False)
  362 + util.keyframe_insert(bones, "rotation_quaternion", current_frame, False)
  363 + ik.location[x] = ik_loc[x] + (ray * math.cos(i / period * (2 * math.pi)))
  364 + ik.location[y] = ik_loc[y] + (ray )#* math.sin(i / period * (2 * math.pi)))
  365 + #ik.location[z] = ik_loc[z] + (i / period) - ray
  366 + util.keyframe_insert(ik, "location", current_frame)
  367 + util.keyframe_insert(ik, "rotation_quaternion", current_frame, False)
  368 + current_frame += 1
207 return current_frame 369 return current_frame
208 \ No newline at end of file 370 \ No newline at end of file
1 # -*- coding: UTF-8 -*- 1 # -*- coding: UTF-8 -*-
2 2
3 -# @def Função para obter data e hora atual do sistema  
4 -# @param string Formato de data e hora  
5 -# @return string Retorna data e hora do sistema no momento da chamada  
6 -def getTimeStamp(dtFrmt='%Y-%m-%d_%H.%M.%S.%f'):  
7 - from datetime import datetime  
8 - if (dtFrmt == '%Y-%m-%d_%H.%M.%S.%f'):  
9 - # [:-3] Remove 3 casas decimais dos milisegundos (ms)  
10 - return datetime.now().strftime(dtFrmt)[:-3] 3 +import datetime
  4 +import logging
  5 +import os
  6 +import shutil
  7 +import sys
  8 +
  9 +# @def funcao para obter data e hora atual do sistema
  10 +# @param string formato de data e hora
  11 +# @return string retorna data e hora do sistema no momento da chamada
  12 +def getTimeStamp(date_fmt = "%Y-%m-%d %H:%M:%S.%f"):
  13 + if ("%f" in date_fmt):
  14 + # [:-3] remove 3 casas decimais dos milisegundos (ms)
  15 + return datetime.datetime.now().strftime(date_fmt)[:-3]
11 else: 16 else:
12 - return datetime.now().strftime(dtFrmt)  
13 -  
14 -# @def Função para gravar log dos eventos em arquivo  
15 -# @param string Mensagem a ser salva  
16 -# @param int indice do tipo de log 1: Debug, 2: Info, 3: Warn, 4: Error, 5: Critical  
17 -# @param String Caminho completo do arquivo de logs  
18 -# @param String Formato de tempo utilizado  
19 -def log(logMsg="", logLevel=2, logFile="events.log", dtFrmt='%Y-%m-%d %H:%M:%S'):  
20 - import logging  
21 -  
22 - logLevelArray = ["", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL" ]  
23 - logLevel %= len(logLevelArray)  
24 - print("[%s] log %s: %s" % (getTimeStamp(), logLevelArray[logLevel], logMsg))  
25 -  
26 - #logFormat='[%(asctime)s.%(msecs).03d] %(levelname)s: <User: %(name)s> <Module: %(module)s> <Function: %(funcName)s>: %(message)s'  
27 - logFormat='[%(asctime)s.%(msecs).03d] %(levelname)s: %(message)s'  
28 -  
29 - if (logLevel == 1):  
30 - logging.basicConfig(filename=logFile, datefmt=dtFrmt, format=logFormat, level=logging.DEBUG)  
31 - logging.Formatter(fmt='%(asctime)s',datefmt='%Y/%m/%d,%H:%M:%S.%f')  
32 - logging.debug(logMsg)  
33 -  
34 - elif (logLevel == 2):  
35 - logging.basicConfig(filename=logFile, datefmt=dtFrmt, format=logFormat, level=logging.INFO)  
36 - logging.Formatter(fmt='%(asctime)s',datefmt='%Y/%m/%d,%H:%M:%S.%f')  
37 - logging.info(logMsg)  
38 -  
39 - elif (logLevel == 3):  
40 - logging.basicConfig(filename=logFile, datefmt=dtFrmt, format=logFormat, level=logging.WARN)  
41 - logging.Formatter(fmt='%(asctime)s',datefmt='%Y/%m/%d,%H:%M:%S.%f')  
42 - logging.warn(logMsg)  
43 -  
44 - elif (logLevel == 4):  
45 - logging.basicConfig(filename=logFile, datefmt=dtFrmt, format=logFormat, level=logging.ERROR)  
46 - logging.Formatter(fmt='%(asctime)s',datefmt='%Y/%m/%d,%H:%M:%S.%f')  
47 - logging.error(logMsg)  
48 -  
49 - elif (logLevel == 5):  
50 - logging.basicConfig(filename=logFile, datefmt=dtFrmt, format=logFormat, level=logging.CRITICAL)  
51 - logging.Formatter(fmt='%(asctime)s',datefmt='%Y/%m/%d,%H:%M:%S.%f')  
52 - logging.critical(logMsg)  
53 -  
54 -def test_log():  
55 - msg = " This is a message "  
56 - log(msg + "Debug", 1)  
57 - log(msg + "Info", 2)  
58 - log(msg + "Warn", 3)  
59 - log(msg + "Error", 4)  
60 - log(msg + "Critical", 5)  
61 -  
62 -# test_log()  
63 -  
64 -# @def Função para exibir exceção  
65 -# @param string deve ser passado: "__file__" para identificar em qual arquivo ocorreu a exceção  
66 -# @return int Retorna 1  
67 -def print_stack_trace(fromFile):  
68 - from sys import exc_info  
69 - from os.path import basename 17 + return datetime.datetime.now().strftime(date_fmt)
  18 +
  19 +# @def funcao para gravar log dos eventos em arquivo
  20 +# @param string mensagem a ser salva
  21 +# @param int indice do tipo de log 0: apenas print, 1: debug, 2: info, 3: warn, 4: error, 5: critical
  22 +# @param string caminho completo do arquivo de logs
  23 +# @param string formato de tempo utilizado
  24 +# @return none
  25 +def log(msg = "", log_level = 2, log_file = "events.log"):
  26 + dict_level = {
  27 + 0: ["Print", None, None],
  28 + 1: ["DEBUG", logging.DEBUG, logging.debug],
  29 + 2: ["INFO", logging.INFO, logging.info],
  30 + 3: ["WARNING", logging.WARN, logging.warn],
  31 + 4: ["ERROR", logging.ERROR, logging.error],
  32 + 5: ["CRITICAL", logging.CRITICAL, logging.critical]
  33 + }
  34 + # log_format = "[%(asctime)s.%(msecs).03d] %(levelname)s: <User: %(name)s> <Module: %(module)s> <Function: %(funcName)s>: %(message)s"
  35 + log_format = "[%(asctime)s.%(msecs).03d] %(levelname)s: %(message)s"
  36 + date_fmt = "%Y-%m-%d %H:%M:%S"
  37 + logging.basicConfig(filename = log_file, datefmt = date_fmt, format = log_format, level = dict_level[log_level][1])
  38 + logging.Formatter(fmt = "%(asctime)s", datefmt = date_fmt)
  39 + log_level %= len(dict_level)
  40 + write_mode = dict_level[log_level][2]
  41 + print("[%s] %s: %s" % (getTimeStamp(), dict_level[log_level][0], msg))
  42 + if (write_mode != None):
  43 + write_mode(msg)
  44 + return
  45 +
  46 +# @def funcao para exibir excecao
  47 +# @param string deve ser passado: "__file__" para identificar em qual modulo ocorreu a excecao
  48 +# @return int retorna 1
  49 +def print_stack_trace():
70 error = "\n File name: %s\n Function name: %s\n Line code: %s\n Type exception: %s\n Message: %s" % ( 50 error = "\n File name: %s\n Function name: %s\n Line code: %s\n Type exception: %s\n Message: %s" % (
71 - basename(fromFile), # basename(exc_info()[2].tb_frame.f_code.co_filename),  
72 - exc_info()[2].tb_frame.f_code.co_name,  
73 - exc_info()[2].tb_lineno,  
74 - exc_info()[0].__name__,  
75 - exc_info()[1] 51 + os.path.basename(sys.exc_info()[2].tb_frame.f_code.co_filename),
  52 + sys.exc_info()[2].tb_frame.f_code.co_name,
  53 + sys.exc_info()[2].tb_lineno,
  54 + sys.exc_info()[0].__name__,
  55 + sys.exc_info()[1]
76 ) 56 )
77 log(error, 4) 57 log(error, 4)
78 return 1 58 return 1
79 59
80 -# @def Função que verifica se um arquivo existe  
81 -# @param string filePath: Caminho do arquivo a ser checado  
82 -# @return bool Verdadeiro se o arquivo existir, Falso caso contrário  
83 -def file_exists(filePath):  
84 - from os.path import isfile, exists  
85 - if ((isfile(filePath) == 1) and (exists(filePath) == 1)): 60 +# @def funcao que verifica se um arquivo existe
  61 +# @param string caminho do arquivo a ser checado
  62 +# @return bool verdadeiro se o arquivo existir, falso caso contrario
  63 +def file_exists(file_path):
  64 + if ((os.path.isfile(file_path) == 1) and (os.path.exists(file_path) == 1)):
86 return True 65 return True
87 else: 66 else:
88 return False 67 return False
89 68
90 -# @def Função para renomear arquivo de video gerado pelo blender  
91 -# @see entrada: /temp/arquivo_video_0001-0250.mp4  
92 -# @see saida: /temp/arquivo_video.mp4  
93 -# @param string fileFullPath: Caminho do arquivo a ser renomeado  
94 -# @param bool useTimeStamp: Renomeia o arquivo de acordo com a data e hora do sistema  
95 -# @param bool overwrite: Sobreescreve o arquivo  
96 -# @return string Retorna o nome do arquivo renomeado  
97 -def file_rename(fileFullPath, useTimeStamp = False, overwrite = True):  
98 - from shutil import move  
99 - from os.path import abspath, basename, dirname, join, splitext  
100 - if (file_exists(fileFullPath) == False): 69 +# @def funcao para renomear arquivo de video gerado pelo blender
  70 +# entrada: /temp/arquivo_video_0001-0250.mp4
  71 +# saida: /temp/arquivo_video.mp4
  72 +# @param string caminho do arquivo a ser renomeado
  73 +# @param bool renomeia o arquivo de acordo com a data e hora do sistema
  74 +# @param bool sobreescreve o arquivo
  75 +# @return string retorna o nome do arquivo renomeado
  76 +def file_rename(file_full_path, use_time_stamp = False, overwrite = True):
  77 + if (file_exists(file_full_path) == False):
101 return "" 78 return ""
102 - filePath = dirname(abspath(fileFullPath))  
103 - filename = basename(splitext(fileFullPath)[0])  
104 - extension = splitext(fileFullPath)[1]  
105 - filenameInv = ""  
106 - isValidChar = False  
107 -  
108 - # Percorre o "filename" do final para o inicio copiando caracteres após o primeiro '_' encontrado 79 + file_path = os.path.dirname(os.path.abspath(file_full_path))
  80 + filename = os.path.basename(os.path.splitext(file_full_path)[0])
  81 + extension = os.path.splitext(file_full_path)[1]
  82 + filename_reversed = ""
  83 + valid_char = False
  84 + # percorre o "filename" do final para o inicio copiando caracteres apos o primeiro "_" encontrado
109 for char in reversed(filename): 85 for char in reversed(filename):
110 - if (isValidChar == True):  
111 - filenameInv += char  
112 - if (char == '_'):  
113 - isValidChar = True 86 + if (valid_char == True):
  87 + filename_reversed += char
  88 + if (char == "_"):
  89 + valid_char = True
114 try: 90 try:
115 -  
116 - # Inverte sequencia de caracteres que foi copiada  
117 - filenameInv = filenameInv[::-1]  
118 -  
119 - if (useTimeStamp == True):  
120 - # Recupera novo fullPath + nome do arquivo + data/hora + extensão  
121 - newFilename = join(filePath, "%s_%s%s" % (filenameInv, getTimeStamp(), extension)) 91 + # inverte sequencia de caracteres que foi copiada
  92 + filename_reversed = filename_reversed[::-1]
  93 + if (use_time_stamp == True):
  94 + # recupera novo file_full_path + nome do arquivo + data/hora + extensao
  95 + new_filename = os.path.join(file_path, "%s_%s%s" % (filename_reversed, getTimeStamp(), extension))
122 else: 96 else:
123 - # Recupera novo fullPath + nome do arquivo + extensão  
124 - newFilename = join(filePath, "%s%s" % (filenameInv, extension))  
125 -  
126 - # Enumera o nome do arquivo caso o parametro "overwrite" seja "False" e o arquivo já exista 97 + # recupera novo file_full_path + nome do arquivo + extensao
  98 + new_filename = os.path.join(file_path, "%s%s" % (filename_reversed, extension))
  99 + # Enumera o nome do arquivo caso o parametro "overwrite" seja "False" e o arquivo ja exista
127 if (overwrite == False): 100 if (overwrite == False):
128 count = 0 101 count = 0
129 - while (file_exists(newFilename) == True): 102 + while (file_exists(new_filename) == True):
130 count += 1 103 count += 1
131 - # newFilename = join(filePath, "%s_%i%s" % (filenameInv, count, extension))  
132 - newFilename = join(filePath, "%s_%0.4i%s" % (filenameInv, count, extension))  
133 -  
134 - log("Rename: '%s' to: '%s'" %(fileFullPath, newFilename))  
135 - move(fileFullPath, newFilename)  
136 - return newFilename  
137 -  
138 - except Exception as e:  
139 - printStackTrace(__file__) 104 + # new_filename = join(file_path, "%s_%i%s" % (filename_reversed, count, extension))
  105 + new_filename = os.path.join(file_path, "%s_%0.4i%s" % (filename_reversed, count, extension))
  106 + # log('rename: "%s" to: "%s"' %(file_full_path, new_filename))
  107 + shutil.move(file_full_path, new_filename)
  108 + return new_filename
  109 + except Exception:
  110 + print_stack_trace()
140 return "" 111 return ""
  112 +
  113 +"""
  114 +# unit test
  115 +def main():
  116 + msg = "This is a message of "
  117 + log(msg + "Print", 0)
  118 + log(msg + "Debug", 1)
  119 + log(msg + "Info", 2)
  120 + log(msg + "Warn", 3)
  121 + log(msg + "Error", 4)
  122 + log(msg + "Critical", 5)
  123 + filename = "sample_001-250.mp4"
  124 + video = open(filename, "w")
  125 + video.write
  126 + video.close
  127 + file_rename(filename)
  128 + return
  129 +
  130 +if __name__ == "__main__":
  131 + main()
  132 +"""
141 \ No newline at end of file 133 \ No newline at end of file
1 # -*- coding: UTF-8 -*- 1 # -*- coding: UTF-8 -*-
2 2
3 import bpy 3 import bpy
  4 +import copy
  5 +import json
4 import math 6 import math
5 import os 7 import os
6 -import sys  
7 -import copy  
8 import pyutil 8 import pyutil
  9 +import sys
9 from bmesh_collision import bmesh_check_intersect_objects 10 from bmesh_collision import bmesh_check_intersect_objects
10 11
11 armature = bpy.context.scene.objects.get('Armature.001') 12 armature = bpy.context.scene.objects.get('Armature.001')
@@ -20,15 +21,13 @@ dict_bones = { @@ -20,15 +21,13 @@ dict_bones = {
20 "07_facial": ['BnPescoco', 'BnCabeca', 'BnSobrancCentro.L', 'BnSobrancCentro.R', 'BnSobrancLateral.L', 'BnSobrancLateral.R', 'BnPalpebSuper.L', 'BnPalpebInfe.L', 'BnSobrancCentro', 'BnLabioCentroSuper', 'BnBochecha.L', 'BnBochecha.R', 'BnLabioCentroInfer', 'BnBocaCanto.L', 'BnBocaCanto.R', 'BnMandibula', 'BnLingua', 'BnLingua.003', 'BnLingua.001', 'BnLingua.002', 'BnPalpebSuper.R', 'BnPalpebInfe.R', 'BnOlhosMira', 'BnOlhoMira.L', 'BnOlhoMira.R', 'BnOlho.L', 'BnOlho.R'] 21 "07_facial": ['BnPescoco', 'BnCabeca', 'BnSobrancCentro.L', 'BnSobrancCentro.R', 'BnSobrancLateral.L', 'BnSobrancLateral.R', 'BnPalpebSuper.L', 'BnPalpebInfe.L', 'BnSobrancCentro', 'BnLabioCentroSuper', 'BnBochecha.L', 'BnBochecha.R', 'BnLabioCentroInfer', 'BnBocaCanto.L', 'BnBocaCanto.R', 'BnMandibula', 'BnLingua', 'BnLingua.003', 'BnLingua.001', 'BnLingua.002', 'BnPalpebSuper.R', 'BnPalpebInfe.R', 'BnOlhosMira', 'BnOlhoMira.L', 'BnOlhoMira.R', 'BnOlho.L', 'BnOlho.R']
21 } 22 }
22 23
23 -right_bones_conf = dict_bones["01_conf_direita"] + dict_bones["03_pa_direita"] + dict_bones["05_orient_direita"]  
24 -  
25 -left_bones_conf = dict_bones["02_conf_esquerda"] + dict_bones["04_pa_esquerda"] + dict_bones["06_orient_esquerda"]  
26 -  
27 -# Vetor com indices de cada bone do lado direito  
28 -#rightBonesConf = [1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66]  
29 -  
30 -# Vetor com indices de cada bone do lado esquerdo  
31 -#leftBonesConf = [0, 43, 44, 45, 46, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82] 24 +dict_interpolation = {
  25 + "inicial": 20,
  26 + "lento": 15,
  27 + "normal": 10,
  28 + "rapido": 5,
  29 + "final": 20
  30 +}
32 31
33 # Movimento coçar - Índices de poses 32 # Movimento coçar - Índices de poses
34 cocar_mao_aberta_index = 55 33 cocar_mao_aberta_index = 55
@@ -36,21 +35,29 @@ cocar_mao_fechada_index = 24 @@ -36,21 +35,29 @@ cocar_mao_fechada_index = 24
36 cocar_orientation_index = 11 35 cocar_orientation_index = 11
37 36
38 # Action expressão facial 37 # Action expressão facial
39 -facial_expression_id = '07_facial' 38 +facial_expression_id = "07_facial"
40 facial_expression_action = [facial_expression_id] 39 facial_expression_action = [facial_expression_id]
41 40
42 # Actions mão direita 41 # Actions mão direita
43 -conf_direita_id = '01_conf_direita'  
44 -pa_direita_id = '03_pa_direita'  
45 -orient_direita_id = '05_orient_direita' 42 +conf_direita_id = "01_conf_direita"
  43 +pa_direita_id = "03_pa_direita"
  44 +orient_direita_id = "05_orient_direita"
46 right_hand_actions = [conf_direita_id, pa_direita_id, orient_direita_id] 45 right_hand_actions = [conf_direita_id, pa_direita_id, orient_direita_id]
47 46
48 # Actions mão esquerda 47 # Actions mão esquerda
49 -conf_esquerda_id = '02_conf_esquerda'  
50 -pa_esquerda_id = '04_pa_esquerda'  
51 -orient_esquerda_id = '06_orient_esquerda' 48 +conf_esquerda_id = "02_conf_esquerda"
  49 +pa_esquerda_id = "04_pa_esquerda"
  50 +orient_esquerda_id = "06_orient_esquerda"
52 left_hand_actions = [conf_esquerda_id, pa_esquerda_id, orient_esquerda_id] 51 left_hand_actions = [conf_esquerda_id, pa_esquerda_id, orient_esquerda_id]
53 52
  53 +all_actions = [conf_direita_id, conf_esquerda_id, pa_direita_id, pa_esquerda_id, orient_direita_id, orient_esquerda_id, facial_expression_id]
  54 +
  55 +all_bones = dict_bones[conf_direita_id] + dict_bones[conf_esquerda_id] + dict_bones[pa_direita_id] + dict_bones[pa_esquerda_id] + dict_bones[orient_direita_id] + dict_bones[orient_esquerda_id] + dict_bones[facial_expression_id]
  56 +
  57 +right_bones_conf = dict_bones[conf_direita_id] + dict_bones[pa_direita_id] + dict_bones[orient_direita_id]
  58 +
  59 +left_bones_conf = dict_bones[conf_esquerda_id] + dict_bones[pa_esquerda_id] + dict_bones[orient_esquerda_id]
  60 +
54 last_keyframe_dict = {} 61 last_keyframe_dict = {}
55 62
56 def select_bones(bones = bpy.context.object.pose.bones): 63 def select_bones(bones = bpy.context.object.pose.bones):
@@ -86,7 +93,6 @@ def delete_all_keyframes(): @@ -86,7 +93,6 @@ def delete_all_keyframes():
86 obj.animation_data_clear() 93 obj.animation_data_clear()
87 return 94 return
88 95
89 -# Função responsável por selecionar as pose-libs e setar os frames  
90 def setPose(actions, parametesConf, positionFrames, bones, collisionFlag = True): 96 def setPose(actions, parametesConf, positionFrames, bones, collisionFlag = True):
91 for x in range(len(positionFrames)): 97 for x in range(len(positionFrames)):
92 for l in range(len(actions)): 98 for l in range(len(actions)):
@@ -110,7 +116,7 @@ def internal_keyframe_insert(bone, path, positionFrame, collisionFlag = True, ro @@ -110,7 +116,7 @@ def internal_keyframe_insert(bone, path, positionFrame, collisionFlag = True, ro
110 if ("ik_FK" in bone.name and bone.location.z < 1): 116 if ("ik_FK" in bone.name and bone.location.z < 1):
111 bone.location.z = 1 117 bone.location.z = 1
112 bone.bone.select = True 118 bone.bone.select = True
113 - bone.keyframe_insert(data_path = path, index = -1, frame = positionFrame) 119 + bone.keyframe_insert(data_path = path, index = -1, group = bone.name, frame = positionFrame)
114 bone.bone.select = False 120 bone.bone.select = False
115 keyframe_id = bone.name + "_" + path 121 keyframe_id = bone.name + "_" + path
116 last_keyframe = last_keyframe_dict[keyframe_id] if keyframe_id in last_keyframe_dict else 0 122 last_keyframe = last_keyframe_dict[keyframe_id] if keyframe_id in last_keyframe_dict else 0
@@ -184,7 +190,6 @@ def check_collision(objName, otherObjName, initFrame, endFrame): @@ -184,7 +190,6 @@ def check_collision(objName, otherObjName, initFrame, endFrame):
184 scene = bpy.context.scene 190 scene = bpy.context.scene
185 startFrame = initFrame + int(math.fabs((endFrame - initFrame)/2)) 191 startFrame = initFrame + int(math.fabs((endFrame - initFrame)/2))
186 collisionFrame = -1 192 collisionFrame = -1
187 -  
188 for i in range(startFrame, endFrame + 1, 1): 193 for i in range(startFrame, endFrame + 1, 1):
189 scene.frame_set(i) 194 scene.frame_set(i)
190 obj = scene.objects.get(objName) 195 obj = scene.objects.get(objName)
@@ -222,10 +227,9 @@ def configure_output(): @@ -222,10 +227,9 @@ def configure_output():
222 bpy.context.scene.render.tile_y = 240 227 bpy.context.scene.render.tile_y = 240
223 return 228 return
224 229
225 -def render_sign(user_id, nome_sinal = "sinal", frame_final = bpy.context.scene.frame_end): 230 +def render_sign(user_id = "", sinal = "", frame_final = bpy.context.scene.frame_end):
226 getcwd = os.path.dirname(os.path.abspath(__file__)) 231 getcwd = os.path.dirname(os.path.abspath(__file__))
227 - bpy.context.scene.render.filepath = getcwd + "/users/" + str(user_id) + "/"+ nome_sinal + "_"  
228 - bpy.ops.wm.save_as_mainfile(filepath=getcwd + "/users/" + str(user_id) + "/"+ nome_sinal + ".blend") 232 + bpy.context.scene.render.filepath = os.path.join(getcwd, "users", user_id, sinal + "_")
229 bpy.context.scene.frame_end = frame_final 233 bpy.context.scene.frame_end = frame_final
230 pyutil.log("Gerando Video... Frames: %i" % (frame_final)) 234 pyutil.log("Gerando Video... Frames: %i" % (frame_final))
231 bpy.ops.render.render(animation = True, write_still = False, layer = "", scene = "") 235 bpy.ops.render.render(animation = True, write_still = False, layer = "", scene = "")
@@ -233,6 +237,39 @@ def render_sign(user_id, nome_sinal = &quot;sinal&quot;, frame_final = bpy.context.scene.f @@ -233,6 +237,39 @@ def render_sign(user_id, nome_sinal = &quot;sinal&quot;, frame_final = bpy.context.scene.f
233 bpy.ops.wm.quit_blender() 237 bpy.ops.wm.quit_blender()
234 return 238 return
235 239
  240 +def make_dir(directory):
  241 + if not os.path.exists(directory):
  242 + os.makedirs(directory)
  243 + return True
  244 + return False
  245 +
  246 +def export_blend(directory, filename, frame_start, frame_current, frame_end):
  247 + tmp_frame_start = bpy.context.scene.frame_start
  248 + tmp_frame_current = bpy.context.scene.frame_current
  249 + tmp_frame_end = bpy.context.scene.frame_end
  250 + bpy.context.scene.frame_start = frame_start
  251 + bpy.context.scene.frame_current = frame_current
  252 + bpy.context.scene.frame_end = frame_end
  253 + make_dir(directory)
  254 + bpy.ops.wm.save_as_mainfile(filepath = os.path.join(directory, filename))
  255 + bpy.context.scene.frame_start = tmp_frame_start
  256 + bpy.context.scene.frame_current = tmp_frame_current
  257 + bpy.context.scene.frame_end = tmp_frame_end
  258 +
  259 +def export_json(obj, directory, filename, inline = True):
  260 + make_dir(directory)
  261 + fp = open(os.path.join(directory, filename), 'w', encoding = "utf-8")
  262 + fp.write(
  263 + json.dumps(
  264 + obj,
  265 + ensure_ascii = False,
  266 + indent = None if (inline) else 4,
  267 + separators = (",", ":") if (inline) else None
  268 + )
  269 + )
  270 + fp.close
  271 + return
  272 +
236 def validate_rotation(bone, endFrame, startFrame = 0): 273 def validate_rotation(bone, endFrame, startFrame = 0):
237 if (endFrame - startFrame == 1): 274 if (endFrame - startFrame == 1):
238 return True 275 return True