示例#1
0
    def prepare_curve_morph(self, morph_name: str):
        try:
            logger.copy(self.options)

            logger.info("【スムージング1回目】%s 開始", morph_name)

            # 全キーフレを取得
            fnos = self.options.motion.get_morph_fnos(morph_name)
            logger.debug("get_morph_fnos morph_name: %s, fnos: %s", morph_name, fnos)

            m_values = []
            
            for fno in fnos:
                mf = self.options.motion.calc_mf(morph_name, fno)
                m_values.append(mf.ratio)
            
            m_all_values = MBezierUtils.calc_value_from_catmullrom(morph_name, fnos, m_values)
            
            logger.debug("get_morph_fnos morph_name: %s, m_all_values: %s", morph_name, m_all_values[:10])

            # カトマル曲線で生成した値を全打ち
            for fno, mr in enumerate(m_all_values):
                mf = VmdMorphFrame(fno)
                mf.set_name(morph_name)

                if math.isnan(mr) or math.isinf(mr):
                    logger.debug("** mr: (%s)%s", fno, mr)
                
                mf.ratio = mr
                self.options.motion.regist_mf(mf, morph_name, fno)
                
            logger.info("【スムージング1回目】%s 終了", morph_name)

            return True
        except SizingException as se:
            logger.error("スムージング処理が処理できないデータで終了しました。\n\n%s", se.message)
            return False
        except Exception as e:
            logger.error("スムージング処理が意図せぬエラーで終了しました。", e)
            return False
示例#2
0
    def prepare_curve(self, bone_name: str):
        try:
            logger.copy(self.options)

            logger.info("【スムージング1回目】%s 開始", bone_name)

            # 全キーフレを取得
            fnos = self.options.motion.get_bone_fnos(bone_name, is_read=True)

            rx_values = []
            ry_values = []
            rz_values = []
            mx_values = []
            my_values = []
            mz_values = []
            
            for fno in fnos:
                bf = self.options.motion.calc_bf(bone_name, fno)
                
                if self.options.model.bones[bone_name].getRotatable():
                    euler = bf.rotation.toEulerAngles()
                    rx_values.append(euler.x())
                    ry_values.append(euler.y())
                    rz_values.append(euler.z())
                
                if self.options.model.bones[bone_name].getTranslatable():
                    mx_values.append(bf.position.x())
                    my_values.append(bf.position.y())
                    mz_values.append(bf.position.z())
            
            if self.options.model.bones[bone_name].getRotatable():
                rx_all_values = MBezierUtils.calc_value_from_catmullrom(bone_name, fnos, rx_values)
                logger.info("【スムージング1回目】%s - 回転X 終了", bone_name)

                ry_all_values = MBezierUtils.calc_value_from_catmullrom(bone_name, fnos, ry_values)
                logger.info("【スムージング1回目】%s - 回転Y 終了", bone_name)

                rz_all_values = MBezierUtils.calc_value_from_catmullrom(bone_name, fnos, rz_values)
                logger.info("【スムージング1回目】%s - 回転Z 終了", bone_name)
            else:
                if len(fnos) > 0:
                    rx_all_values = np.zeros(fnos[-1] + 1)
                    ry_all_values = np.zeros(fnos[-1] + 1)
                    rz_all_values = np.zeros(fnos[-1] + 1)
                else:
                    rx_all_values = [0]
                    ry_all_values = [0]
                    rz_all_values = [0]

            if self.options.model.bones[bone_name].getTranslatable():
                mx_all_values = MBezierUtils.calc_value_from_catmullrom(bone_name, fnos, mx_values)
                logger.info("【スムージング1回目】%s - 移動X 終了", bone_name)

                my_all_values = MBezierUtils.calc_value_from_catmullrom(bone_name, fnos, my_values)
                logger.info("【スムージング1回目】%s - 移動Y 終了", bone_name)

                mz_all_values = MBezierUtils.calc_value_from_catmullrom(bone_name, fnos, mz_values)
                logger.info("【スムージング1回目】%s - 移動Z 終了", bone_name)
            else:
                if len(fnos) > 0:
                    mx_all_values = np.zeros(fnos[-1] + 1)
                    my_all_values = np.zeros(fnos[-1] + 1)
                    mz_all_values = np.zeros(fnos[-1] + 1)
                else:
                    mx_all_values = [0]
                    my_all_values = [0]
                    mz_all_values = [0]

            # カトマル曲線で生成した値を全打ち
            for fno, (rx, ry, rz, mx, my, mz) in enumerate(zip(rx_all_values, ry_all_values, rz_all_values, mx_all_values, my_all_values, mz_all_values)):
                bf = self.options.motion.calc_bf(bone_name, fno)
                bf.rotation = MQuaternion.fromEulerAngles(rx, ry, rz)
                bf.position = MVector3D(mx, my, mz)
                self.options.motion.regist_bf(bf, bone_name, fno)
                
            logger.info("【スムージング1回目】%s 終了", bone_name)

            return True
        except SizingException as se:
            logger.error("スムージング処理が処理できないデータで終了しました。\n\n%s", se.message)
            return False
        except Exception as e:
            logger.error("スムージング処理が意図せぬエラーで終了しました。", e)
            return False