Beispiel #1
0
    def test_calc_relative_position01(self):
        motion = VmdReader(
            "D:/MMD/MikuMikuDance_v926x64/UserFile/Motion/ダンス_1人/ドラマツルギー motion 配布用 moka/ドラマツルギー_0-500.vmd"
        ).read_data()
        model = PmxReader(
            "D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式デフォ服ミク_ver1.1 金子卵黄/Tda式初音ミク_デフォ服ver.pmx"
        ).read_data()

        # --------------
        links = model.create_link_2_top_one("グルーブ")

        # ---------
        trans_vs = MServiceUtils.calc_relative_position(
            model, links, motion, 407)
        self.assertEqual(4, len(trans_vs))

        # SIZING_ROOT_BONE
        self.assertAlmostEqual(trans_vs[0].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].z(), 0, delta=0.1)

        # 全ての親
        self.assertAlmostEqual(trans_vs[1].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].z(), 0, delta=0.1)

        # センター
        self.assertAlmostEqual(trans_vs[2].x(),
                               3.30 + links.get("センター").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].y(),
                               0.00 + links.get("センター").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].z(),
                               -0.15 + links.get("センター").position.z(),
                               delta=0.1)

        # グルーブ
        self.assertAlmostEqual(trans_vs[3].x(),
                               0 + links.get("グルーブ").position.x() -
                               links.get("センター").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].y(),
                               -4.40 + links.get("グルーブ").position.y() -
                               links.get("センター").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].z(),
                               0 + links.get("グルーブ").position.z() -
                               links.get("センター").position.z(),
                               delta=0.1)

        # ---------
        trans_vs = MServiceUtils.calc_relative_position(
            model, links, motion, 420)
        self.assertEqual(4, len(trans_vs))

        # SIZING_ROOT_BONE
        self.assertAlmostEqual(trans_vs[0].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].z(), 0, delta=0.1)

        # 全ての親
        self.assertAlmostEqual(trans_vs[1].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].z(), 0, delta=0.1)

        # センター
        self.assertAlmostEqual(trans_vs[2].x(),
                               3.21 + links.get("センター").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].y(),
                               0.00 + links.get("センター").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].z(),
                               2.77 + links.get("センター").position.z(),
                               delta=0.1)

        # グルーブ
        self.assertAlmostEqual(trans_vs[3].x(),
                               0 + links.get("グルーブ").position.x() -
                               links.get("センター").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].y(),
                               -0.22 + links.get("グルーブ").position.y() -
                               links.get("センター").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].z(),
                               0 + links.get("グルーブ").position.z() -
                               links.get("センター").position.z(),
                               delta=0.1)

        # --------------
        links = model.create_link_2_top_one("右足IK")

        # ---------
        trans_vs = MServiceUtils.calc_relative_position(
            model, links, motion, 415)
        self.assertEqual(4, len(trans_vs))

        # SIZING_ROOT_BONE
        self.assertAlmostEqual(trans_vs[0].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].z(), 0, delta=0.1)

        # 全ての親
        self.assertAlmostEqual(trans_vs[1].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].z(), 0, delta=0.1)

        # 右足IK親
        self.assertAlmostEqual(trans_vs[2].x(),
                               0 + links.get("右足IK親").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].y(),
                               0 + links.get("右足IK親").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].z(),
                               0 + links.get("右足IK親").position.z(),
                               delta=0.1)

        # 右足IK
        self.assertAlmostEqual(trans_vs[3].x(),
                               2.43 + links.get("右足IK").position.x() -
                               links.get("右足IK親").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].y(),
                               0.00 + links.get("右足IK").position.y() -
                               links.get("右足IK親").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].z(),
                               1.52 + links.get("右足IK").position.z() -
                               links.get("右足IK親").position.z(),
                               delta=0.1)

        # ---------
        trans_vs = MServiceUtils.calc_relative_position(
            model, links, motion, 418)
        self.assertEqual(4, len(trans_vs))

        # SIZING_ROOT_BONE
        self.assertAlmostEqual(trans_vs[0].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[0].z(), 0, delta=0.1)

        # 全ての親
        self.assertAlmostEqual(trans_vs[1].x(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].y(), 0, delta=0.1)
        self.assertAlmostEqual(trans_vs[1].z(), 0, delta=0.1)

        # 右足IK親
        self.assertAlmostEqual(trans_vs[2].x(),
                               0 + links.get("右足IK親").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].y(),
                               0 + links.get("右足IK親").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[2].z(),
                               0 + links.get("右足IK親").position.z(),
                               delta=0.1)

        # 右足IK
        self.assertAlmostEqual(trans_vs[3].x(),
                               2.92 + links.get("右足IK").position.x() -
                               links.get("右足IK親").position.x(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].y(),
                               4.17 + links.get("右足IK").position.y() -
                               links.get("右足IK親").position.y(),
                               delta=0.1)
        self.assertAlmostEqual(trans_vs[3].z(),
                               2.45 + links.get("右足IK").position.z() -
                               links.get("右足IK親").position.z(),
                               delta=0.1)
Beispiel #2
0
    def test_calc_global_pos01(self):
        motion = VmdReader(
            "D:/MMD/MikuMikuDance_v926x64/UserFile/Motion/ダンス_1人/ドラマツルギー motion 配布用 moka/ドラマツルギー_0-500.vmd"
        ).read_data()
        model = PmxReader(
            "D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式デフォ服ミク_ver1.1 金子卵黄/Tda式初音ミク_デフォ服ver.pmx"
        ).read_data()

        # --------------
        links = model.create_link_2_top_one("グルーブ")

        # ---------
        pos_dic = MServiceUtils.calc_global_pos(model, links, motion, 420)
        self.assertEqual(4, len(pos_dic.keys()))

        # SIZING_ROOT_BONE
        print(pos_dic["SIZING_ROOT_BONE"])
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].x(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].z(), 0, delta=0.1)

        # 全ての親
        print(pos_dic["全ての親"])
        self.assertAlmostEqual(pos_dic["全ての親"].x(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["全ての親"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["全ての親"].z(), 0, delta=0.1)

        # センター
        print(pos_dic["センター"])
        self.assertAlmostEqual(pos_dic["センター"].x(), 3.2, delta=0.1)
        self.assertAlmostEqual(pos_dic["センター"].y(), 8.4, delta=0.1)
        self.assertAlmostEqual(pos_dic["センター"].z(), 2.7, delta=0.1)

        # グルーブ
        print(pos_dic["グルーブ"])
        self.assertAlmostEqual(pos_dic["グルーブ"].x(), 3.2, delta=0.1)
        self.assertAlmostEqual(pos_dic["グルーブ"].y(), 8.4, delta=0.1)
        self.assertAlmostEqual(pos_dic["グルーブ"].z(), 2.7, delta=0.1)

        # --------------
        links = model.create_link_2_top_one("左足IK")

        # ---------
        pos_dic = MServiceUtils.calc_global_pos(model, links, motion, 420)
        self.assertEqual(4, len(pos_dic.keys()))

        # SIZING_ROOT_BONE
        print(pos_dic["SIZING_ROOT_BONE"])
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].x(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].z(), 0, delta=0.1)

        # 全ての親
        print(pos_dic["全ての親"])
        self.assertAlmostEqual(pos_dic["全ての親"].x(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["全ての親"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["全ての親"].z(), 0, delta=0.1)

        # 左足IK親
        print(pos_dic["左足IK親"])
        self.assertAlmostEqual(pos_dic["左足IK親"].x(), 1.0, delta=0.1)
        self.assertAlmostEqual(pos_dic["左足IK親"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["左足IK親"].z(), 0.7, delta=0.1)

        # 右足IK親
        print(pos_dic["左足IK"])
        self.assertAlmostEqual(pos_dic["左足IK"].x(), 3.5, delta=0.1)
        self.assertAlmostEqual(pos_dic["左足IK"].y(), 3.9, delta=0.1)
        self.assertAlmostEqual(pos_dic["左足IK"].z(), 2.1, delta=0.1)

        # --------------
        links = model.create_link_2_top_one("右手首")

        # ---------
        pos_dic = MServiceUtils.calc_global_pos(model, links, motion, 420)
        # self.assertEqual(17, len(pos_dic.keys()))

        # SIZING_ROOT_BONE
        print(pos_dic["SIZING_ROOT_BONE"])
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].x(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["SIZING_ROOT_BONE"].z(), 0, delta=0.1)

        # 全ての親
        print(pos_dic["全ての親"])
        self.assertAlmostEqual(pos_dic["全ての親"].x(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["全ての親"].y(), 0, delta=0.1)
        self.assertAlmostEqual(pos_dic["全ての親"].z(), 0, delta=0.1)

        # センター
        print(pos_dic["センター"])
        self.assertAlmostEqual(pos_dic["センター"].x(), 3.2, delta=0.1)
        self.assertAlmostEqual(pos_dic["センター"].y(), 8.4, delta=0.1)
        self.assertAlmostEqual(pos_dic["センター"].z(), 2.7, delta=0.1)

        # グルーブ
        print(pos_dic["グルーブ"])
        self.assertAlmostEqual(pos_dic["グルーブ"].x(), 3.2, delta=0.1)
        self.assertAlmostEqual(pos_dic["グルーブ"].y(), 8.4, delta=0.1)
        self.assertAlmostEqual(pos_dic["グルーブ"].z(), 2.7, delta=0.1)

        # 腰
        self.assertAlmostEqual(pos_dic["腰"].x(), 3.2, delta=0.1)
        self.assertAlmostEqual(pos_dic["腰"].y(), 12.1, delta=0.1)
        self.assertAlmostEqual(pos_dic["腰"].z(), 3.0, delta=0.1)

        # 上半身
        self.assertAlmostEqual(pos_dic["上半身"].x(), 3.2, delta=0.1)
        self.assertAlmostEqual(pos_dic["上半身"].y(), 13.0, delta=0.1)
        self.assertAlmostEqual(pos_dic["上半身"].z(), 2.2, delta=0.1)

        # 上半身2
        self.assertAlmostEqual(pos_dic["上半身2"].x(), 3.25, delta=0.1)
        self.assertAlmostEqual(pos_dic["上半身2"].y(), 14.0, delta=0.1)
        self.assertAlmostEqual(pos_dic["上半身2"].z(), 2.25, delta=0.1)

        # 右肩P
        self.assertAlmostEqual(pos_dic["右肩P"].x(), 3.03, delta=0.1)
        self.assertAlmostEqual(pos_dic["右肩P"].y(), 16.26, delta=0.1)
        self.assertAlmostEqual(pos_dic["右肩P"].z(), 2.28, delta=0.1)

        # 右肩
        self.assertAlmostEqual(pos_dic["右肩"].x(), 3.03, delta=0.1)
        self.assertAlmostEqual(pos_dic["右肩"].y(), 16.26, delta=0.1)
        self.assertAlmostEqual(pos_dic["右肩"].z(), 2.28, delta=0.1)

        # # 右肩C
        # self.assertAlmostEqual(pos_dic["右肩C"].x(), 3.03, delta=0.1)
        # self.assertAlmostEqual(pos_dic["右肩C"].y(), 16.26, delta=0.1)
        # self.assertAlmostEqual(pos_dic["右肩C"].z(), 2.28, delta=0.1)

        # 右腕
        self.assertAlmostEqual(pos_dic["右腕"].x(), 2.15, delta=0.1)
        self.assertAlmostEqual(pos_dic["右腕"].y(), 16.32, delta=0.1)
        self.assertAlmostEqual(pos_dic["右腕"].z(), 2.39, delta=0.1)

        # 右腕捩
        self.assertAlmostEqual(pos_dic["右腕捩"].x(), 0.66, delta=0.1)
        self.assertAlmostEqual(pos_dic["右腕捩"].y(), 15.64, delta=0.1)
        self.assertAlmostEqual(pos_dic["右腕捩"].z(), 2.19, delta=0.1)

        # 右ひじ
        self.assertAlmostEqual(pos_dic["右ひじ"].x(), -0.31, delta=0.1)
        self.assertAlmostEqual(pos_dic["右ひじ"].y(), 15.17, delta=0.1)
        self.assertAlmostEqual(pos_dic["右ひじ"].z(), 2.03, delta=0.1)

        # 右手捩
        self.assertAlmostEqual(pos_dic["右手捩"].x(), 0.21, delta=0.1)
        self.assertAlmostEqual(pos_dic["右手捩"].y(), 14.36, delta=0.1)
        self.assertAlmostEqual(pos_dic["右手捩"].z(), 0.95, delta=0.1)

        # 右手首
        self.assertAlmostEqual(pos_dic["右手首"].x(), 0.56, delta=0.1)
        self.assertAlmostEqual(pos_dic["右手首"].y(), 13.83, delta=0.1)
        self.assertAlmostEqual(pos_dic["右手首"].z(), 0.23, delta=0.1)
Beispiel #3
0
    def test_calc_relative_rotation01(self):
        motion = VmdReader(
            "D:/MMD/MikuMikuDance_v926x64/UserFile/Motion/ダンス_1人/ドラマツルギー motion 配布用 moka/ドラマツルギー_0-500.vmd"
        ).read_data()
        model = PmxReader(
            "D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式デフォ服ミク_ver1.1 金子卵黄/Tda式初音ミク_デフォ服ver.pmx"
        ).read_data()

        # --------------
        links = model.create_link_2_top_one("右手首")

        # ---------
        add_qs = MServiceUtils.calc_relative_rotation(model, links, motion,
                                                      414)

        # SIZING_ROOT_BONE
        self.assertAlmostEqual(add_qs[0].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[0].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[0].toEulerAngles4MMD().z(), 0, delta=0.1)

        # 全ての親
        self.assertAlmostEqual(add_qs[1].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[1].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[1].toEulerAngles4MMD().z(), 0, delta=0.1)

        # センター
        self.assertAlmostEqual(add_qs[2].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[2].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[2].toEulerAngles4MMD().z(), 0, delta=0.1)

        # グルーブ
        self.assertAlmostEqual(add_qs[3].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[3].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[3].toEulerAngles4MMD().z(), 0, delta=0.1)

        # 腰
        self.assertAlmostEqual(add_qs[4].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[4].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[4].toEulerAngles4MMD().z(), 0, delta=0.1)

        # 上半身
        self.assertAlmostEqual(add_qs[5].toEulerAngles4MMD().x(),
                               -13.2,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[5].toEulerAngles4MMD().y(),
                               -5.0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[5].toEulerAngles4MMD().z(),
                               1.1,
                               delta=0.1)

        # 上半身2
        self.assertAlmostEqual(add_qs[6].toEulerAngles4MMD().x(),
                               -9.1,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[6].toEulerAngles4MMD().y(),
                               -7.1,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[6].toEulerAngles4MMD().z(),
                               3.7,
                               delta=0.1)

        # 首根元
        self.assertAlmostEqual(add_qs[7].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[7].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[7].toEulerAngles4MMD().z(), 0, delta=0.1)

        # 右肩P
        self.assertAlmostEqual(add_qs[8].toEulerAngles4MMD().x(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[8].toEulerAngles4MMD().y(), 0, delta=0.1)
        self.assertAlmostEqual(add_qs[8].toEulerAngles4MMD().z(), 0, delta=0.1)

        # 右肩
        self.assertAlmostEqual(add_qs[9].toEulerAngles4MMD().x(),
                               -1.7,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[9].toEulerAngles4MMD().y(),
                               14.4,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[9].toEulerAngles4MMD().z(),
                               13.5,
                               delta=0.1)

        # 右肩C
        self.assertAlmostEqual(add_qs[10].toEulerAngles4MMD().x(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[10].toEulerAngles4MMD().y(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[10].toEulerAngles4MMD().z(),
                               0,
                               delta=0.1)

        # 右腕
        self.assertAlmostEqual(add_qs[11].toEulerAngles4MMD().x(),
                               -5.0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[11].toEulerAngles4MMD().y(),
                               58.9,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[11].toEulerAngles4MMD().z(),
                               11.5,
                               delta=0.1)

        # 右腕捩
        self.assertAlmostEqual(add_qs[12].toEulerAngles4MMD().x(),
                               -0.1,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[12].toEulerAngles4MMD().y(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[12].toEulerAngles4MMD().z(),
                               0,
                               delta=0.1)

        # 右ひじ
        self.assertAlmostEqual(add_qs[13].toEulerAngles4MMD().x(),
                               30.6,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[13].toEulerAngles4MMD().y(),
                               48.3,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[13].toEulerAngles4MMD().z(),
                               14.0,
                               delta=0.1)

        # 右ひじ下(スルー)
        self.assertAlmostEqual(add_qs[14].toEulerAngles4MMD().x(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[14].toEulerAngles4MMD().y(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[14].toEulerAngles4MMD().z(),
                               0,
                               delta=0.1)

        # 右手捩
        self.assertAlmostEqual(add_qs[15].toEulerAngles4MMD().x(),
                               -7.1,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[15].toEulerAngles4MMD().y(),
                               5.4,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[15].toEulerAngles4MMD().z(),
                               -0.2,
                               delta=0.1)

        # 右手首
        self.assertAlmostEqual(add_qs[16].toEulerAngles4MMD().x(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[16].toEulerAngles4MMD().y(),
                               0,
                               delta=0.1)
        self.assertAlmostEqual(add_qs[16].toEulerAngles4MMD().z(),
                               -37.8,
                               delta=0.1)