Adiciona parâmetro -noaudio ao controller, atualiza movimento senoidal, remove funções não usadas

André Araújo
1 parent e313bcb0
Showing 5 changed files with 133 additions and 127 deletions Show diff stats
Makefile
controller.py
libras.py
moves.py
util.py
@@ -26,12 +26,12 @@ JSON_CIRCULAR = \
             "mao_direita": { \
                 "circular": { \
                     "plano": "esquerda-cima", \
+                    "sentido_inverso": false, \
                     "raio": "pequeno", \
                     "velocidade": "normal", \
                     "lado_oposto": false, \
-                    "sentido_inverso": false, \
                     "articulacao": 80, \
-                    "configuracao": 15, \
+                    "configuracao": 19, \
                     "orientacao": 18 \
                 } \
             } \
@@ -172,11 +172,11 @@ JSON_HELICOIDAL = \
             "mao_esquerda": {}, \
             "mao_direita": { \
                 "helicoidal": { \
-                    "plano": "esquerda-cima", \
-                    "raio": "pequeno", \
+                    "plano": "frente-esquerda", \
+                    "sentido_inverso": false, \
+                    "raio": "grande", \
                     "velocidade": "normal", \
                     "lado_oposto": false, \
-                    "sentido_inverso": true, \
                     "articulacao": 79, \
                     "configuracao": 0, \
                     "orientacao": 64 \
@@ -241,12 +241,12 @@ JSON_SEMICIRCULAR = \
             "mao_direita": { \
                 "semicircular": { \
                     "plano": "esquerda-cima", \
+                    "sentido_inverso": false, \
                     "raio": "pequeno", \
                     "velocidade": "normal", \
                     "lado_oposto": false, \
-                    "sentido_inverso": false, \
                     "articulacao": 80, \
-                    "configuracao": 15, \
+                    "configuracao": 19, \
                     "orientacao": 18 \
                 } \
             } \
@@ -264,12 +264,13 @@ JSON_SENOIDAL = \
             "facial": {}, \
             "mao_esquerda": {}, \
             "mao_direita": { \
-                "circular": { \
-                    "plano": "esquerda-cima", \
-                    "raio": "pequeno", \
+                "senoidal": { \
+                    "direcao": "esquerda", \
+                    "direcao_oposta": true, \
+                    "plano_deslocamento": "cima-baixo", \
+                    "distancia": "normal", \
                     "velocidade": "normal", \
-                    "lado_oposto": false, \
-                    "sentido_inverso": false, \
+                    "tamanho_onda": "normal", \
                     "articulacao": 79, \
                     "configuracao": 0, \
                     "orientacao": 64 \
@@ -15,8 +15,8 @@ result = 0
 try:
     # para gravar logs do blender, usar codigo abaixo
-    # result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '--', sys.argv[1]], stdout = open('bpy.log', 'w'))
-    result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '--', sys.argv[1]])
+    # result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '-noaudio', '--', sys.argv[1]], stdout = open('bpy.log', 'w'))
+    result = subprocess.call(['blender', '-b', blend_path, '-P', main_path, '-noaudio', '--', sys.argv[1]])
 except:
     result = pyutil.print_stack_trace()
@@ -21,22 +21,6 @@ import moves
 import pyutil
 import decode
-def insert_keyframe_pose_default(current_frame = 0, pose_bones = bpy.context.object.pose.bones, types_keyframe = ["location", "rotation_quaternion"]):
-    for obj in (pose_bones):
-        obj.bone.select = True
-        for type_keyframe in types_keyframe:
-            util.keyframe_insert(obj, type_keyframe, current_frame, False)
-        obj.bone.select = False
-    return
-
-def pose_default(current_frame = 0, frame_jump = 0, actions = bpy.data.actions):
-    for action in actions:
-        if (action.use_fake_user):
-            bpy.context.object.pose_library = action
-            bpy.ops.poselib.apply_pose(pose_index = 0)
-            insert_keyframe_pose_default(current_frame)
-    return current_frame + frame_jump
-
 def main():
     util.set_pose_mode()
     util.delete_all_keyframes()
@@ -44,18 +28,15 @@ def main():
     bpy.context.scene.animation_data_create()
     try:
-        js_input = json.loads(sys.argv[6])
+        js_input = json.loads(sys.argv[7])
         js_movimentos = js_input["movimentos"]
         frame_jump = util.dict_interpolation[js_input["interpolacao"]]
-        endFrame = pose_default(0, frame_jump)
+        endFrame = util.pose_default(0, frame_jump)
         timeline_facial = 0
         timeline_mao_esquerda = 0
         timeline_mao_direita = 0
-        # setar pose padrao inicial em todos os bones ("location" e "rotation_quaternion")
-        endFrame += pose_default(util.dict_interpolation["inicial"])
-
         for i in range(0, len(js_movimentos)):
             timeline_facial = endFrame
             timeline_mao_esquerda = endFrame
@@ -100,18 +81,17 @@ def main():
             endFrame += frame_jump
         # setar pose padrao final em todos os bones (location e rotation)
-        endFrame = pose_default(endFrame, frame_jump)
-        endFrame += util.dict_interpolation["final"]
+        endFrame = util.pose_default(endFrame, frame_jump)
         sinal = str(js_input["sinal"])
         user_id = str(js_input["userId"])
         directory = os.path.join(getcwd, "users", user_id)
         # exporta .blend
-        util.export_blend(directory, sinal + ".blend", 0, 0, endFrame)
+        # util.export_blend(directory, sinal + ".blend", 0, 0, endFrame)
         # exporta .json
-        util.export_json(js_input, directory, sinal + ".json")
+        # util.export_json(js_input, directory, sinal + ".json")
         # exporta .mp4
         util.render_sign(user_id, sinal, endFrame)
@@ -168,7 +168,8 @@ def alisar_diagonal(boneIK, to_right, repetition, initialFrame = 18, frameJump =
 # Obs.: A velocidade do movimento vai ser a relacao entre tamanho do raio e o periodo
 #       quanto maior o periodo mais keyframes
 #       quanto menor o raio mais rapido
-# exemplos:
+
+# circular:
 # raio: "pequeno" raio = 0.5, velocidade: "rapido" periodo = 25
 # raio: "pequeno" raio = 0.5, velocidade: "normal" periodo = 35
 # raio: "pequeno" raio = 0.5, velocidade: "lento" periodo = 45
@@ -189,27 +190,28 @@ def circular(js_movement, current_frame, frame_jump, is_right_hand, is_semicircu
         "normal": 45,
         "rapido": 35
     }
-    ray = dict_ray[js_movement["raio"]]
-    period = dict_period[js_movement["velocidade"]]
-    opposite_side = js_movement["lado_oposto"]
-    reverse_way = js_movement["sentido_inverso"]
+    dict_calc = {
+        "pequeno": -10,
+        "normal": 0,
+        "grande": 10
+    }
+    dict_axis = {
+        "frente-esquerda": [2, 0, 1],
+        "frente-cima": [2, 1, 0],
+        "esquerda-cima": [0, 1, 2]
+    }
     actions = util.right_hand_actions if (is_right_hand) else util.left_hand_actions
-    hand_param = read_hand_param(js_movement)
     bones = util.right_bones_conf if (is_right_hand) else util.left_bones_conf
+    hand_param = read_hand_param(js_movement)
     ik = bpy.context.object.pose.bones["ik_FK.R" if (is_right_hand) else "ik_FK.L"]
-    if (js_movement["velocidade"] == "lento"):
-        period += 10
-    elif (js_movement["velocidade"] == "rapido"):
-        period -= 10
-    if (js_movement["plano"] == "frente-esquerda"):
-        x, y = 2, 0
-    elif (js_movement["plano"] == "frente-cima"):
-        x, y = 2, 1
-    else:
-        x, y = 0, 1
+    opposite_side = js_movement["lado_oposto"]
+    period = dict_period[js_movement["velocidade"]] + dict_calc[js_movement["raio"]]
+    ray = dict_ray[js_movement["raio"]]
+    reverse_way = js_movement["sentido_inverso"]
+    x = dict_axis[js_movement["plano"]][0]
+    y = dict_axis[js_movement["plano"]][1]
+    #z = dict_axis[js_movement["plano"]][2]
     k = round(period / 2) if (opposite_side) else 0
-    x %= 3
-    y %= 3
     if (reverse_way):
         tmp = x
         x = y
@@ -217,9 +219,7 @@ def circular(js_movement, current_frame, frame_jump, is_right_hand, is_semicircu
     util.setPose(actions, hand_param, [current_frame], bones, False)
     util.keyframe_insert(bones, "location", current_frame, False, False)
     ik_loc = [ik.location[0], ik.location[1], ik.location[2]]
-    limit = period + k - 1
-    if (is_semicircular):
-        limit = round(period / 2) + k
+    limit = round(period / 2) + k if (is_semicircular) else period + k
     for i in range(k, limit + 1):
         bpy.context.object.pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
         bpy.ops.poselib.apply_pose(pose_index = hand_param[0])
@@ -228,43 +228,59 @@ def circular(js_movement, current_frame, frame_jump, is_right_hand, is_semicircu
         util.keyframe_insert(bones, "rotation_quaternion", current_frame, False)
         ik.location[x] = ik_loc[x] + (ray * math.cos(i / period * (2 * math.pi)))
         ik.location[y] = ik_loc[y] + (ray * math.sin(i / period * (2 * math.pi)))
-        util.keyframe_insert(ik, "location", current_frame)
+        util.keyframe_insert(ik, "location", current_frame, False)
         util.keyframe_insert(ik, "rotation_quaternion", current_frame, False)
         current_frame += 1
-    return current_frame
+    return current_frame + frame_jump
+
+# 'lado_oposto'     true inverte o sentido do vetor direcional
+# 'sentido_inverso' true inverte o sentido do plano
+# helicoidal
+# raio: "pequeno" raio = 0.2, velocidade: "rapido" periodo = 25
+# raio: "pequeno" raio = 0.2, velocidade: "normal" periodo = 35
+# raio: "pequeno" raio = 0.2, velocidade: "lento" periodo = 45
+# raio: "normal" raio = 0.6, velocidade: "rapido" periodo = 35
+# raio: "normal" raio = 0.6, velocidade: "normal" periodo = 45
+# raio: "normal" raio = 0.6, velocidade: "lento" periodo = 55
+# raio: "grande" raio = 0.8, velocidade: "rapido" periodo = 45
+# raio: "grande" raio = 0.8, velocidade: "normal" periodo = 55
+# raio: "grande" raio = 0.8, velocidade: "lento" periodo = 65
 def helicoidal(js_movement, current_frame, frame_jump, is_right_hand):
     dict_ray = {
-        "pequeno": 0.5,
-        "normal": 1.0,
-        "grande": 1.5
+        "pequeno": 0.2,
+        "normal": 0.6,
+        "grande": 0.8
     }
     dict_period = {
         "lento": 55,
         "normal": 45,
         "rapido": 35
     }
-    ray = dict_ray[js_movement["raio"]]
-    period = dict_period[js_movement["velocidade"]]
-    opposite_side = js_movement["lado_oposto"]
-    reverse_way = js_movement["sentido_inverso"]
+    dict_calc = {
+        "pequeno": -10,
+        "normal": 0,
+        "grande": 10
+    }
+    dict_axis = {
+        "frente-esquerda": [2, 0, 1],
+        "frente-cima": [2, 1, 0],
+        "esquerda-cima": [0, 1, 2]
+    }
     actions = util.right_hand_actions if (is_right_hand) else util.left_hand_actions
-    hand_param = read_hand_param(js_movement)
     bones = util.right_bones_conf if (is_right_hand) else util.left_bones_conf
+    hand_param = read_hand_param(js_movement)
     ik = bpy.context.object.pose.bones["ik_FK.R" if (is_right_hand) else "ik_FK.L"]
-    if (js_movement["velocidade"] == "lento"):
-        period += 10
-    elif (js_movement["velocidade"] == "rapido"):
-        period -= 10
-    if (js_movement["plano"] == "frente-esquerda"):
-        x, y, z = 2, 0, 1
-    elif (js_movement["plano"] == "frente-cima"):
-        x, y, z = 2, 1, 0
-    else:
-        x, y, z = 0, 1, 2
-    k = round(period / 2) if (opposite_side) else 0
-    x %= 3
-    y %= 3
+    opposite_side = js_movement["lado_oposto"]
+    period = dict_period[js_movement["velocidade"]] + dict_calc[js_movement["raio"]]
+    ray = dict_ray[js_movement["raio"]]
+    reverse_way = js_movement["sentido_inverso"]
+    # print('raio: "%s" raio = %.1f, velocidade: "%s" periodo = %d' % (js_movement["raio"], ray, js_movement["velocidade"], period))
+    x = dict_axis[js_movement["plano"]][0]
+    y = dict_axis[js_movement["plano"]][1]
+    z = dict_axis[js_movement["plano"]][2]
+    # print("x = %.1f y = %.1f z = %.1f" % (x, y, z))
+    k = 0
     if (reverse_way):
         tmp = x
         x = y
@@ -272,7 +288,7 @@ def helicoidal(js_movement, current_frame, frame_jump, is_right_hand):
     util.setPose(actions, hand_param, [current_frame], bones, False)
     util.keyframe_insert(bones, "location", current_frame, False, False)
     ik_loc = [ik.location[0], ik.location[1], ik.location[2]]
-    limit = period + k - 1
+    limit = period + k
     for i in range(k, 2 * (limit + 1)):
         bpy.context.object.pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
         bpy.ops.poselib.apply_pose(pose_index = hand_param[0])
@@ -281,11 +297,14 @@ def helicoidal(js_movement, current_frame, frame_jump, is_right_hand):
         util.keyframe_insert(bones, "rotation_quaternion", current_frame, False)
         ik.location[x] = ik_loc[x] + (ray * math.cos(i / period * (2 * math.pi)))
         ik.location[y] = ik_loc[y] + (ray * math.sin(i / period * (2 * math.pi)))
-        ik.location[z] = ik_loc[z] + (i / period) - ray
-        util.keyframe_insert(ik, "location", current_frame)
+        distance_inc = (i / period) - ray
+        if (opposite_side):
+            distance_inc = -distance_inc
+        ik.location[z] = ik_loc[z] + distance_inc
+        util.keyframe_insert(ik, "location", current_frame, False)
         util.keyframe_insert(ik, "rotation_quaternion", current_frame, False)
         current_frame += 1
-    return current_frame
+    return current_frame + frame_jump
 def pontual(js_movement, current_frame, frame_jump, is_right_hand):
     hand_param = read_hand_param(js_movement)
@@ -315,55 +334,59 @@ def semicircular(js_movement, current_frame, frame_jump, is_right_hand):
     return circular(js_movement, current_frame, frame_jump, is_right_hand, True)
 def senoidal(js_movement, current_frame, frame_jump, is_right_hand):
-    dict_ray = {
-        "pequeno": 0.5,
-        "normal": 1.0,
-        "grande": 1.5
+    dict_wave = {
+        "pequeno": 0.1,
+        "normal": 0.2,
+        "grande": 0.3
     }
-    dict_period = {
-        "lento": 55,
-        "normal": 45,
-        "rapido": 35
+    dict_distance_inc = {
+        "pequeno": 0.005,
+        "normal": 0.010,
+        "grande": 0.015
     }
-    ray = dict_ray[js_movement["raio"]]
-    period = dict_period[js_movement["velocidade"]]
-    opposite_side = js_movement["lado_oposto"]
-    reverse_way = js_movement["sentido_inverso"]
+    dict_speed = {
+        "rapido": 2,
+        "normal": 3,
+        "lento": 4
+    }
+    dict_axis = {
+        "esquerda": {
+            "frente-tras": [0, 2, 1],
+            "cima-baixo": [0, 1, 2]
+        },
+        "cima": {
+            "frente-tras": [1, 2, 0],
+            "esquerda-direita": [1, 0, 2]
+        },
+        "frente": {
+            "esquerda-direita": [2, 0, 1],
+            "cima-baixo": [2, 1, 0]
+        }
+    }
+    axis_dir = dict_axis[js_movement["direcao"]][js_movement["plano_deslocamento"]][0]
+    axis_sin = dict_axis[js_movement["direcao"]][js_movement["plano_deslocamento"]][1]
+    reverse_way = js_movement["direcao_oposta"]
+    distance_inc = dict_distance_inc[js_movement["distancia"]]
+    # TODO adaptar velocidade
+    # speed = dict_speed[js_movement["velocidade"]]
+    wave_len = dict_wave[js_movement["tamanho_onda"]]
     actions = util.right_hand_actions if (is_right_hand) else util.left_hand_actions
-    hand_param = read_hand_param(js_movement)
     bones = util.right_bones_conf if (is_right_hand) else util.left_bones_conf
+    hand_param = read_hand_param(js_movement)
     ik = bpy.context.object.pose.bones["ik_FK.R" if (is_right_hand) else "ik_FK.L"]
-    if (js_movement["velocidade"] == "lento"):
-        period += 10
-    elif (js_movement["velocidade"] == "rapido"):
-        period -= 10
-    if (js_movement["plano"] == "frente-esquerda"):
-        x, y, z = 2, 0, 1
-    elif (js_movement["plano"] == "frente-cima"):
-        x, y, z = 2, 1, 0
-    else:
-        x, y, z = 0, 1, 2
-    k = round(period / 2) if (opposite_side) else 0
-    x %= 3
-    y %= 3
-    if (reverse_way):
-        tmp = x
-        x = y
-        y = tmp
     util.setPose(actions, hand_param, [current_frame], bones, False)
     util.keyframe_insert(bones, "location", current_frame, False, False)
     ik_loc = [ik.location[0], ik.location[1], ik.location[2]]
-    limit = period + k - 1
-    for i in range(k, 2 * (limit + 1)):
-        bpy.context.object.pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
+    pose_library = bpy.data.actions[util.conf_direita_id if (is_right_hand) else util.conf_esquerda_id]
+    for i in range(0, 100):
+        bpy.context.object.pose_library = pose_library
         bpy.ops.poselib.apply_pose(pose_index = hand_param[0])
         bpy.context.object.pose_library = None
         util.keyframe_insert(bones, "location", current_frame, False)
         util.keyframe_insert(bones, "rotation_quaternion", current_frame, False)
-        ik.location[x] = ik_loc[x] + (ray * math.cos(i / period * (2 * math.pi)))
-        ik.location[y] = ik_loc[y] + (ray )#* math.sin(i / period * (2 * math.pi)))
-        #ik.location[z] = ik_loc[z] + (i / period) - ray
-        util.keyframe_insert(ik, "location", current_frame)
+        ik.location[axis_dir] += -distance_inc if (reverse_way) else distance_inc
+        ik.location[axis_sin] = ik_loc[axis_sin] + math.sin(i * wave_len)
+        util.keyframe_insert(ik, "location", current_frame, False)
         util.keyframe_insert(ik, "rotation_quaternion", current_frame, False)
         current_frame += 1
-    return current_frame
 \ No newline at end of file
+    return current_frame + frame_jump
@@ -22,11 +22,9 @@ dict_bones = {
 }
 dict_interpolation = {
-    "inicial": 20,
     "lento": 15,
     "normal": 10,
     "rapido": 5,
-    "final": 20
 }
 # Movimento coçar - Índices de poses
@@ -60,6 +58,10 @@ left_bones_conf = dict_bones[conf_esquerda_id] + dict_bones[pa_esquerda_id] + di
 last_keyframe_dict = {}
+def pose_default(current_frame, frame_jump):
+    setPose(all_actions, [0, 0, 0, 0, 0, 0, 0], [current_frame], all_bones, False)
+    return current_frame + frame_jump
+
 def select_bones(bones = bpy.context.object.pose.bones):
     if (isinstance(bones, int) or isinstance(bones, str)):
         bpy.context.object.pose.bones[bones].bone.select = True