骨骼姿态转换，bvh文件读取，姿态转换展示

于 2018-12-02 15:37:02 发布
阅读量2.9k 收藏 16
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_32563489/article/details/84716203
版权
本文详细介绍了如何处理Bvh文件，包括读取文件内容，进行骨骼姿态转换，并展示转换结果。通过理解Bvh格式，可以实现对3D人物动作的数据操作，为虚拟现实、游戏开发等领域提供关键技术支持。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//-----------------------------------------------------
//@title                       HBone.h
//@writer                      Xu Linlin
//@createdate                  2017-12-26
//@function                    声明Bone类
//-----------------------------------------------------
#ifndef  HBONE_H
#define  HBONE_H

#include  "stdio.h"
#include  "HMatrix.h"
using  namespace  std;

class  HBone
{
public:
	HBone(); //默认构造函数1
	HBone(const  HBone  &bo);                 //构造函数2
	HBone  & operator = (const HBone &bo);	 //构造函数3
	void  setNumber(const int &i);          //设置节点号
	int   getNumber();                  //获得节点号
	void  setOffset(HVector  off);    //设置offset
	void  getOffset(HVector  &off);  //获得offset
	void  setRotation(HVector  rot);  //设置原始Rotaion
	void  getRotation(HVector  &rot); //获得原始Rotaion
	void  setBrother(const int & bro);        //设置兄弟节点
	void  setFirstChild(const int & firch);   //设置第一个子节点 
	int   getBrother();                 //获得兄弟节点
	int   getFirstChild();              //获得第一个子节点
	~HBone(){}

private:
	int     m_Number;
	float   m_Offset[3];
	float   m_Rotation[3];
	int     m_Brother;
	int     m_FirstChild;
};

#endif


//-----------------------------------------------------
//@title                       HBone.cpp
//@writer                      Xu Linlin
//@createdate                  2017-12-26
//@function                    定义Bone类
//-----------------------------------------------------
#include  "HBone.h"

HBone::HBone():m_Number(-1),m_Brother(-1), m_FirstChild(-1) //默认构造函数
{
	m_Offset[0] = m_Offset[1] = m_Offset[2] = 0.0;
    m_Rotation[0] = m_Rotation[1] = m_Rotation[2] = 0.0;
}
//构造函数
HBone::HBone(const  HBone  &bo)
{ 
	//name = bo.name;
	m_Number = bo.m_Number;
	for(int i=0; i<3; i++)
		{
			m_Offset[i] = bo.m_Offset[i];		
		    m_Rotation[i] = bo.m_Rotation[i];
		}
	m_Brother = bo.m_Brother;
	m_FirstChild = bo.m_FirstChild;
}
//重载等于运算符
HBone & HBone::operator= (const HBone &bo)
{
	if(this != &bo)
	{
		m_Number =bo.m_Number;
        for(int i=0; i<3; i++)
		{
			m_Offset[i] = bo.m_Offset[i];		
		    m_Rotation[i] = bo.m_Rotation[i];
		}
		m_Brother = bo.m_Brother;
		m_FirstChild = bo.m_FirstChild;
	}
	return  *this;
}
//设置节点号
void  HBone::setNumber(const int &i)
{
	m_Number = i;
}
//获得节点号
int  HBone::getNumber()
{
	return  m_Number;
}
//设置兄弟节点
void HBone::setBrother(const int & bro)
{
	m_Brother = bro; 
}
//设置第一个子节点 
void HBone::setFirstChild(const int & firch)
{
	m_FirstChild = firch;
}
//获得兄弟节点
int  HBone::getBrother()
{
	return  m_Brother;
}
//获得第一个子节点
int  HBone::getFirstChild()
{
	return  m_FirstChild;
}
//设置offset
void  HBone::setOffset(HVector  off)
{
	m_Offset[0] = off.getMemberValue(0);
	m_Offset[1] = off.getMemberValue(1);
	m_Offset[2] = off.getMemberValue(2);
}
//获得offset
void  HBone::getOffset(HVector  &off)
{
	off.setMemberValue(0, m_Offset[0]);
	off.setMemberValue(1, m_Offset[1]);
	off.setMemberValue(2, m_Offset[2]);
}
//设置原始Rotaion
void  HBone::setRotation(HVector  rot)
{
	m_Rotation[0] = rot.getMemberValue(0);
	m_Rotation[1] = rot.getMemberValue(1);
	m_Rotation[2] = rot.getMemberValue(2);
}
//获得原始Rotaion
void  HBone::getRotation(HVector  &rot)
{
	rot.setMemberValue(0, m_Rotation[0]);
	rot.setMemberValue(1, m_Rotation[1]);
	rot.setMemberValue(2, m_Rotation[2]);	
}



//-----------------------------------------------------
//@title                       HMmatrix.h
//@writer                      Xu Linlin
//@createdate                  2017-12-28
//@function                    声明一些矩阵计算函数
//-----------------------------------------------------
#ifndef __HMATRIX_H__
#define __HMATRIX_H__

#include  "math.h"
#include  <assert.h>
#include  <string>
#define  N   4
#define  EPS  1.0E-9
#define  PI   3.14159
using namespace  std;
class  HMatrix;
class  HVector//向量类,可以表示角度
{
public:
	HVector(); //默认构造函数1
	HVector(const  HVector  &vector);   //构造函数2	
	HVector(const float &vec_x, const float &vec_y, const float &vec_z);   //构造函数3
	//设置三个值
	void   setValue(const float &vec_x, const float &vec_y, const float &vec_z);
	//等于一个向量
	HVector  &operator= (const HVector &vector);
	//加等一个向量
	HVector  &operator+= (const HVector &vector);
	//减等一个向量
	HVector  &operator-= (const HVector &vector);
	//乘等一个向量
	HVector  &operator*= (const HVector &vector);
	//乘等一个数
    HVector  &operator*= (const float &coe);
	//加一个向量
	HVector  operator+ (const HVector &vector);
	//减一个向量
	HVector  operator- (const HVector &vector);
	//乘一个向量
	HVector  operator* (const HVector &vector);
	//乘一个数
    HVector  operator* (const float &coe);
	//获得向量的转换角度	
	void  getVectorRotation(HVector &angle);
	//点坐标乘矩阵后得到新的点坐标，保存在ver中
	void   multiplyMatrix(HMatrix  m);
	//使向量旋转
	void   rotateVector(HVector  rot);
    //返回向量中某元素
	float  getMember(const int &i);
	//设置某元素值
	void   setMember(const int &i, const float &value);
private:
	float  m_Vector[3];
};

class  HMatrix
{
public:
	HMatrix(); //默认构造函数1
	HMatrix(const  HMatrix  &matrix);   //构造函数2	
	//初始化矩阵为单位矩阵
	void  initIdentity();
	//等于一个矩阵
	HMatrix  &operator= (const HMatrix &pMatrix);
	//加等一个矩阵
	HMatrix  &operator+= (const HMatrix &pMatrix);
	//减等一个矩阵
	HMatrix  &operator-= (const HMatrix &pMatrix);
	//乘等一个矩阵
	HMatrix  &operator*= (const HMatrix &pMatrix);
	//乘等一个数
	HMatrix  &operator*= (const float &coe);
	//加一个矩阵
	HMatrix  operator+ (const HMatrix &pMatrix);
	//减一个矩阵
	HMatrix  operator- (const HMatrix &pMatrix);
	//乘一个矩阵
	HMatrix  operator* (const HMatrix &pMatrix);
	//乘一个数
	HMatrix  operator* (const float &coe);
	//获得offset组成的矩阵           
	void  getOffsetMatrix(HVector  pOffset);
	//获得rotation组成的矩阵，flag是标志位（0，1，2分别表示x，y，z），angle是转换角度
	void  getRotationMatrix(int  flag, float angle);
	//获得经过offset转化后的矩阵
	void  multiplyOffset(HVector  pOffset);
	//获得经过rotation转化后的矩阵,flag是标志位（0，1，2分别表示x，y，z），angle是转换角度
	void  multiplyRotation(int flag, float angle);
	void  multiplyRotation(HVector  pAngle, int m_RotateOrder);
	//求矩阵的逆矩阵，保存在pInverse中
	void  inverseMatrix(HMatrix  &pInverse);
	//返回矩阵中某元素
	float getMember(const int &i, const int &j);
	~HMatrix(){}	

private:
	float   m_Matrix[N][N];
	void    swapRow(HMatrix   &pMatrix, int i, int j);
	void    scaleRow(HMatrix   &pMatrix, int i, float coef);
	void    addRowToAnother(HMatrix   &pMatrix, int i, int j, float coef);
};

#endif



//-----------------------------------------------------
//@title                       HMatrix.cpp
//@writer                      Xu Linlin
//@createdate                  2017-12-28
//@function                    声明一些矩阵计算函数
//-----------------------------------------------------
#include  "hmatrix.h"

HMatrix::HMatrix() //默认构造函数1
{
	for(int i=0; i<N; i++)
		for(int j=0; j<N; j++)
			m_Matrix[i][j] = 0.0;
}
HMatrix::HMatrix(const  HMatrix  &matrix)   //构造函数2
{
	for(int i=0; i<N; i++)
		for(int j=0; j<N; j++)
			m_Matrix[i][j] = matrix.m_Matrix[i][j];
}
//初始化矩阵为单位矩阵
void  HMatrix::initIdentity()
{
	for(int i=0; i<N; i++)
		for(int j=0; j<N; j++)
		{		
			if(i == j)
				m_Matrix[i][j] = 1.0;	
			else
				m_Matrix[i][j] = 0.0;		
		}		
}
//等于一个矩阵
HMatrix  &HMatrix::operator= (const HMatrix &pMatrix)
{
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m_Matrix[i][j] = pMatrix.m_Matrix[i][j];
	return  *this;
}
//加一个矩阵
HMatrix  &HMatrix::operator+= (const HMatrix &pMatrix)
{
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m_Matrix[i][j] += pMatrix.m_Matrix[i][j];
	return  *this;
}
//减一个矩阵
HMatrix  &HMatrix::operator-= (const HMatrix &pMatrix)
{
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m_Matrix[i][j] -= pMatrix.m_Matrix[i][j];
	return  *this;
}
//乘等一个矩阵
HMatrix  &HMatrix::operator*= (const HMatrix &pMatrix)
{
	HMatrix  pM;
	for(int i=0; i<N; i++)
		for(int j=0; j<N; j++)
		{
			pM.m_Matrix[i][j] = 0.0;
			for(int k=0; k<N; k++)
				pM.m_Matrix[i][j] += m_Matrix[i][k] * pMatrix.m_Matrix[k][j];			
		}
	for(int i=0; i<N; i++)
		for(int j=0; j<N; j++)		
			m_Matrix[i][j] = pM.m_Matrix[i][j];
	return  *this;
}
//乘一个数
HMatrix  &HMatrix::operator*= (const float &coe)
{
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m_Matrix[i][j] *= coe;
	return  *this;
}
//加一个矩阵
HMatrix  HMatrix::operator+ (const HMatrix &pMatrix)
{
	HMatrix  m;
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m.m_Matrix[i][j] = m_Matrix[i][j] + pMatrix.m_Matrix[i][j];
	return  m;
}
//减一个矩阵
HMatrix  HMatrix::operator- (const HMatrix &pMatrix)
{
	HMatrix  m;
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m.m_Matrix[i][j] = m_Matrix[i][j] - pMatrix.m_Matrix[i][j];
	return  m;
}
//乘一个矩阵
HMatrix HMatrix::operator* (const HMatrix &pMatrix)
{
	HMatrix  m;
	for(int i=0; i<N; i++)
		for(int j=0; j<N; j++)
		{
			m.m_Matrix[i][j] = 0.0;
			for(int k=0; k<N; k++)
				m.m_Matrix[i][j] += m_Matrix[i][k] * pMatrix.m_Matrix[k][j];			
		}
	return  m;
}
//乘一个数
HMatrix  HMatrix::operator* (const float &coe)
{
	HMatrix  m;
	for(int i=0; i<N; i++)
		for(int  j=0; j<N; j++)
			m.m_Matrix[i][j] = m_Matrix[i][j] * coe;
	return  m;
}
//获得offset组成的矩阵（pMatrix必须为4阶方阵）           
void  HMatrix::getOffsetMatrix(HVector  p
最低0.47元/天 解锁文章
qq_1769172560
关注
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值