精华内容
下载资源
问答
  • 2021-06-14 10:57:19

    设计(头文件)

    // by Alexander Ezharjan
    #pragma once
    
    #include <windows.h>
    #include "Vector.h"
    #include<iostream>
    
    namespace RenderEngine {
    
    	float RadToDegree(const float& rad);
    	float DegreeToRad(const float& degree);
    
    
    	template<int nrows, int ncols> struct mat;
    
    
    	class Matrix3f
    	{
    	public:
    		Matrix3f() { Init(); };
    		~Matrix3f() {};
    		void Init() { ZeroMemory(&this->matrix, sizeof(this->matrix)); }
    		Matrix3f operator *(const Matrix3f& right) const;
    		Vector3 operator *(const Vector3& right) const;
    		// 单位矩阵
    		static Matrix3f getIdentityMatrix();
    		// 绕任意轴旋转的矩阵,顺时针
    		static Matrix3f getRotationMatrix(const Vector3& axis, float theta);
    		// 根据四元数获取旋转矩阵
    		static Matrix3f getRotationMatrixFromQuaternion(const Vector4& quaternion);
    
    		float matrix[3][3];
    	};
    
    
    
    	class Matrix4f
    	{
    	public:
    		Matrix4f() { Init(); }
    		Matrix4f(const Matrix3f& matrix3f);
    		~Matrix4f() {};
    		void Init() { ZeroMemory(&this->matrix, sizeof(this->matrix)); }
    		bool operator ==(const Matrix4f& right) const;
    		bool operator ==(const float right) const;
    		template<typename T>
    		bool operator !=(const T& right) const ;
    		Matrix4f operator =(const Matrix4f& right);
    		Matrix4f operator *(const Matrix4f& right) const;
    		Matrix4f operator /(const float right) const;
    		Vector4 operator *(const Vector4& right);
    		// 获取转置矩阵
    		static Matrix4f getTransposeMatrix(const Matrix4f& matrixToGetTranspose);
    		// 获取逆矩阵(使用伴随矩阵的方法)
    		static Matrix4f getMatrixInvert(const Matrix4f& matrixToBeInverted);
    		// 获取伴随矩阵
    		static Matrix4f getAdjugate(const Matrix4f matrixToGetAdjoint);
    		// 获取逆矩阵的转置
    		static Matrix4f getInvertTranspose(const Matrix4f m4f);
    		// 单位矩阵
    		static Matrix4f getIdentityMatrix();
    		// 平移变换矩阵
    		static 	Matrix4f getTranslateMatrix(const float& x, const float& y, const float& z);
    		// 缩放变换矩阵
    		static Matrix4f getScaleMatrix(const float& x, const float& y, const float& z);
    		static Matrix4f getScaleMatrix(const Matrix4f& matrixToScale, const float scaleFactor);
    		// 绕X轴的旋转矩阵,形参为角度,顺时针
    		static Matrix4f getRotateXMatrix(const float& thetaX);
    		// 绕Y轴的旋转矩阵,形参为角度,顺时针
    		static Matrix4f getRotateYMatrix(const float& thetaY);
    		// 绕Z轴的旋转矩阵,形参为角度,顺时针
    		static Matrix4f getRotateZMatrix(const float& thetaZ);
    		// 绕任意轴旋转的矩阵,顺时针;因为要检测旋转轴是单位特征,如果不是单位向量则要归一化
    		static Matrix4f getRotationMatrix(Vector3& axisToRotateAround, float theta);
    		// 获取透视投影矩阵
    		static Matrix4f getPerspectiveMatrix(float fovYOZ, float aspectRatio, float zNear, float zFar);
    		// 获取正交投影矩阵(Left-hand Coordinate)
    		static Matrix4f getOrthographicMatrix(const float left, const float right, const float top, const float bottom, float zNear, float zFar);
    		// 获取正交投影矩阵的逆矩阵 ---> 获取其转置矩阵即可
    		static Matrix4f getMatrixInvertForOrthogonal(const Matrix4f& orthographicMatrix);
    		// 建立并获取一个左手坐标系的相机变换(视角)矩阵
    		static Matrix4f getLookAtMatrixForLeftHandCoordinate(Vector3* eyePos, const Vector3* lookAt, const Vector3* up, Vector3& newCameraUpAxis);
    		static Matrix4f getLookAtMatrixForLeftHandCoordinate(Vector3& eyePos, const Vector3& lookAt, const Vector3& up);
    		// 获取视口矩阵,视口变换矩阵的TopLeftX=0,TopLeftY=0,MaxDepth=1.0,MinDepth=0.0
    		static Matrix4f  MatrixViewPort(const float& screenWidth, const float& screenHeight, const float& maxDepth, const float& minDepth, const float& topLeftX, const float& topLeftY);
    		// 在点上执行矩阵变换
    		void ApplyTransformToRelevantMatrix(Vector4& point, const Matrix4f& transformMatrix);
    
    
    		float matrix[4][4];
    	};
    
    	inline std::ostream& operator <<(std::ostream& os, const Matrix4f m4f) {
    		for (int i = 0; i < 4; i++) {
    			for (int j = 0; j < 4; j++) {
    				os << m4f.matrix[i][j] << " \t";
    			}
    			os << std::endl;
    		}
    		return os;
    	}
    	inline std::ostream& operator <<(std::ostream& os, const Matrix3f m3f) {
    		for (int i = 0; i < 3; i++) {
    			for (int j = 0; j < 3; j++) {
    				os << m3f.matrix[i][j] << " \t";
    			}
    			os << std::endl;
    		}
    		return os;
    	}
    }
    



    具体实现(C++文件)

    
    // by Alexander Ezharjan
    #include <math.h>
    #include "Matrix.h"
    #include "Math.h"
    
    
    namespace RenderEngine {
    
    
    	/************************************************************************/
    	/* Matrix3f                                                             */
    	/************************************************************************/
    
    	Matrix3f Matrix3f::operator *(const Matrix3f& right) const {
    		Matrix3f result;
    		for (int i = 0; i < 3; ++i)
    		{
    			for (int j = 0; j < 3; ++j)
    			{
    				result.matrix[i][j] = this->matrix[i][0] * right.matrix[0][j]
    					+ this->matrix[i][1] * right.matrix[1][j]
    					+ this->matrix[i][2] * right.matrix[2][j];
    			}
    		}
    		return result;
    	}
    
    	Vector3 Matrix3f::operator*(const Vector3 & right) const
    	{
    		Vector3 result(
    			this->matrix[0][0] * right.getX() + this->matrix[1][0] * right.getY() + this->matrix[2][0] * right.getZ(),
    			this->matrix[0][1] * right.getX() + this->matrix[1][1] * right.getY() + this->matrix[2][1] * right.getZ(),
    			this->matrix[0][2] * right.getX() + this->matrix[1][2] * right.getY() + this->matrix[2][2] * right.getZ()
    		);
    		return result;
    	}
    
    	Matrix3f Matrix3f::getIdentityMatrix()
    	{
    		Matrix3f identityMatrix;
    
    		identityMatrix.matrix[0][0] = 1.0f;
    		identityMatrix.matrix[1][1] = 1.0f;
    		identityMatrix.matrix[2][2] = 1.0f;
    
    		return identityMatrix;
    	}
    
    	Matrix3f Matrix3f::getRotationMatrix(const Vector3 & axis, float theta)
    	{
    		theta = RadToDegree(theta);
    
    		float cosA = cos(theta);
    		float sinA = sin(theta);
    
    		// Axis must be a unit vector
    		if ((pow(axis.getX(), 2) + pow(axis.getY(), 2) + pow(axis.getZ(), 2)) == 1)
    		{
    			return Matrix3f::getIdentityMatrix();
    		}
    
    		float nx = axis.getX();
    		float ny = axis.getY();
    		float nz = axis.getZ();
    
    		float _cosA = 1 - cosA;
    		float nx_cosA = nx * _cosA;
    		float nz_cosA = nz * _cosA;
    		float nxnx_cosA = nx * nx_cosA;
    		float nxny_cosA = ny * nx_cosA;
    		float nxnz_cosA = nz * nx_cosA;
    		float nyny_cosA = ny * ny*_cosA;
    		float nynz_cosA = ny * nz_cosA;
    		float nznz_cosA = nz * nz_cosA;
    		float nxsinA = nx * sinA;
    		float nzsinA = nz * sinA;
    		float nysinA = ny * sinA;
    
    		Matrix3f rotationMatrx;
    		rotationMatrx.matrix[0][0] = nxnx_cosA + cosA;
    		rotationMatrx.matrix[0][1] = nxny_cosA + nzsinA;
    		rotationMatrx.matrix[0][2] = nxnz_cosA - nysinA;
    		rotationMatrx.matrix[1][0] = nxny_cosA - nzsinA;
    		rotationMatrx.matrix[1][1] = nyny_cosA + cosA;
    		rotationMatrx.matrix[1][2] = nynz_cosA + nxsinA;
    		rotationMatrx.matrix[2][0] = nxnz_cosA + nysinA;
    		rotationMatrx.matrix[2][1] = nynz_cosA - nxsinA;
    		rotationMatrx.matrix[2][2] = nznz_cosA + cosA;
    		return rotationMatrx;
    	}
    
    	Matrix3f Matrix3f::getRotationMatrixFromQuaternion(const Vector4 & quaternion)
    	{
    		Matrix3f result;
    
    		float n, s;
    		float xs, ys, zs;
    		float wx, wy, wz;
    		float xx, xy, xz;
    		float yy, yz, zz;
    
    		n = powf(quaternion.getX(), 2) + powf(quaternion.getY(), 2) + powf(quaternion.getZ(), 2) + powf(quaternion.getW(), 2);
    		s = (n > 0.f) ? (2.f / n) : 0.f;
    
    		xs = quaternion.getX() * s;  ys = quaternion.getY() * s;  zs = quaternion.getZ() * s;
    		wx = quaternion.getW() * xs; wy = quaternion.getW() * ys; wz = quaternion.getW() * zs;
    
    		xx = quaternion.getX()* xs; xy = quaternion.getX()* ys; xz = quaternion.getX()* zs;
    		yy = quaternion.getY() * ys; yz = quaternion.getY() * zs; zz = quaternion.getZ() * zs;
    
    		result.matrix[0][0] = 1.0f - (yy + zz);
    		result.matrix[0][1] = xy - wz;
    		result.matrix[0][2] = xz + wy;
    		result.matrix[1][0] = xy + wz;
    		result.matrix[1][1] = 1.0f - (xx + zz);
    		result.matrix[1][2] = yz - wx;
    		result.matrix[2][0] = xz - wy;
    		result.matrix[2][1] = yz + wx;
    		result.matrix[2][2] = 1.0f - (xx + yy);
    
    		return result;
    	}
    
    
    
    
    
    	/************************************************************************/
    	/* Matrix4f                                                             */
    	/************************************************************************/
    
    	Matrix4f::Matrix4f(const Matrix3f& matrix3f)
    	{
    		Init();
    		for (int i = 0; i < 3; i++)
    		{
    			for (int j = 0; j < 3; j++)
    			{
    				this->matrix[i][j] = matrix3f.matrix[i][j];
    			}
    		}
    		this->matrix[3][3] = 1.f;
    	}
    
    	bool Matrix4f::operator==(const Matrix4f & right) const
    	{
    		int counter = 0;
    		for (size_t i = 0; i < 4; i++)
    		{
    			for (size_t j = 0; j < 4; j++)
    			{
    				if (this->matrix[i][j] - right.matrix[i][j] == 0.f)
    				{
    					counter++;
    				}
    			}
    		}
    		if (counter != 16) return false;
    		else return true;
    	}
    
    	template<typename T>
    	bool Matrix4f::operator!=(const T& right) const
    	{
    		return ((*this == right) ? false : true);
    	}
    
    	bool Matrix4f::operator==(const float right) const
    	{
    		int counter = 0;
    		for (size_t i = 0; i < 4; i++)
    		{
    			for (size_t j = 0; j < 4; j++)
    			{
    				if (this->matrix[i][j] - right == 0.f)
    				{
    					counter++;
    				}
    			}
    		}
    		if (counter != 16) return false;
    		else return true;
    	}
    
    	Matrix4f Matrix4f::operator=(const Matrix4f & right)
    	{
    		if (this->matrix == right.matrix)
    		{
    			return *this;
    		}
    		if (this->matrix != NULL)
    		{
    			ZeroMemory(&this->matrix, sizeof(this->matrix));
    		}
    		if (this != &right)
    		{
    			for (size_t i = 0; i < 4; i++)
    			{
    				for (size_t j = 0; j < 4; j++)
    				{
    					this->matrix[i][j] = right.matrix[i][j];
    				}
    			}
    		}
    		return *this;
    	}
    
    	Matrix4f Matrix4f::operator*(const Matrix4f & right) const
    	{
    		Matrix4f result;
    		for (int i = 0; i < 4; ++i)
    		{
    			for (int j = 0; j < 4; ++j)
    			{
    				result.matrix[i][j] = this->matrix[i][0] * right.matrix[0][j]
    					+ this->matrix[i][1] * right.matrix[1][j]
    					+ this->matrix[i][2] * right.matrix[2][j]
    					+ this->matrix[i][3] * right.matrix[3][j];
    			}
    		}
    		return result;
    	}
    
    	Matrix4f Matrix4f::operator/(const float k) const
    	{
    		Matrix4f result;
    		float oneOver = 1.f / k;
    		for (int i = 0; i < 4; ++i)
    			for (int j = 0; j < 4; ++j)
    				result.matrix[i][j] = this->matrix[i][j] * oneOver;
    		return result;
    	}
    
    	Vector4 Matrix4f::operator*(const Vector4 & right)
    	{
    		Vector4 result(
    			this->matrix[0][0] * right.getX() + this->matrix[1][0] * right.getY() + this->matrix[2][0] * right.getZ() + this->matrix[3][0] * right.getW(),
    			this->matrix[0][1] * right.getX() + this->matrix[1][1] * right.getY() + this->matrix[2][1] * right.getZ() + this->matrix[3][1] * right.getW(),
    			this->matrix[0][2] * right.getX() + this->matrix[1][2] * right.getY() + this->matrix[2][2] * right.getZ() + this->matrix[3][2] * right.getW(),
    			this->matrix[0][3] * right.getX() + this->matrix[1][3] * right.getY() + this->matrix[2][3] * right.getZ() + this->matrix[3][3] * right.getW()
    		);
    		return result;
    	}
    
    	Matrix4f Matrix4f::getTransposeMatrix(const Matrix4f & matrixToGetTranspose)
    	{
    		Matrix4f result;
    
    		for (int i = 0; i < 4; i++) {
    			for (int j = 0; j < 4; j++) {
    				result.matrix[j][i] = matrixToGetTranspose.matrix[i][j];
    			}
    		}
    
    		return result;
    	}
    
    	Matrix4f Matrix4f::getMatrixInvert(const Matrix4f & matrixToBeInverted)
    	{
    		Matrix4f invertTranspose = getInvertTranspose(matrixToBeInverted);
    		return getTransposeMatrix(invertTranspose);
    	}
    
    	Matrix4f Matrix4f::getAdjugate(const Matrix4f matrixToGetAdjoint)
    	{
    		return Matrix4f();
    	}
    
    	// function from glm 
    	Matrix4f Matrix4f::getInvertTranspose(const Matrix4f m4f)
    	{
    		float subfactor00 = m4f.matrix[2][2] * m4f.matrix[3][3] - m4f.matrix[3][2] * m4f.matrix[2][3];
    		float subfactor01 = m4f.matrix[2][1] * m4f.matrix[3][3] - m4f.matrix[3][1] * m4f.matrix[2][3];
    		float subfactor02 = m4f.matrix[2][1] * m4f.matrix[3][2] - m4f.matrix[3][1] * m4f.matrix[2][2];
    		float subfactor03 = m4f.matrix[2][0] * m4f.matrix[3][3] - m4f.matrix[3][0] * m4f.matrix[2][3];
    		float subfactor04 = m4f.matrix[2][0] * m4f.matrix[3][2] - m4f.matrix[3][0] * m4f.matrix[2][2];
    		float subfactor05 = m4f.matrix[2][0] * m4f.matrix[3][1] - m4f.matrix[3][0] * m4f.matrix[2][1];
    		float subfactor06 = m4f.matrix[1][2] * m4f.matrix[3][3] - m4f.matrix[3][2] * m4f.matrix[1][3];
    		float subfactor07 = m4f.matrix[1][1] * m4f.matrix[3][3] - m4f.matrix[3][1] * m4f.matrix[1][3];
    		float subfactor08 = m4f.matrix[1][1] * m4f.matrix[3][2] - m4f.matrix[3][1] * m4f.matrix[1][2];
    		float subfactor09 = m4f.matrix[1][0] * m4f.matrix[3][3] - m4f.matrix[3][0] * m4f.matrix[1][3];
    		float subfactor10 = m4f.matrix[1][0] * m4f.matrix[3][2] - m4f.matrix[3][0] * m4f.matrix[1][2];
    		float subfactor11 = m4f.matrix[1][0] * m4f.matrix[3][1] - m4f.matrix[3][0] * m4f.matrix[1][1];
    		float subfactor12 = m4f.matrix[1][2] * m4f.matrix[2][3] - m4f.matrix[2][2] * m4f.matrix[1][3];
    		float subfactor13 = m4f.matrix[1][1] * m4f.matrix[2][3] - m4f.matrix[2][1] * m4f.matrix[1][3];
    		float subfactor14 = m4f.matrix[1][1] * m4f.matrix[2][2] - m4f.matrix[2][1] * m4f.matrix[1][2];
    		float subfactor15 = m4f.matrix[1][0] * m4f.matrix[2][3] - m4f.matrix[2][0] * m4f.matrix[1][3];
    		float subfactor16 = m4f.matrix[1][0] * m4f.matrix[2][2] - m4f.matrix[2][0] * m4f.matrix[1][2];
    		float subfactor17 = m4f.matrix[1][0] * m4f.matrix[2][1] - m4f.matrix[2][0] * m4f.matrix[1][1];
    
    		Matrix4f inversed;
    
    		inversed.matrix[0][0] = +(m4f.matrix[1][1] * subfactor00 - m4f.matrix[1][2] * subfactor01 + m4f.matrix[1][3] * subfactor02);
    		inversed.matrix[0][1] = -(m4f.matrix[1][0] * subfactor00 - m4f.matrix[1][2] * subfactor03 + m4f.matrix[1][3] * subfactor04);
    		inversed.matrix[0][2] = +(m4f.matrix[1][0] * subfactor01 - m4f.matrix[1][1] * subfactor03 + m4f.matrix[1][3] * subfactor05);
    		inversed.matrix[0][3] = -(m4f.matrix[1][0] * subfactor02 - m4f.matrix[1][1] * subfactor04 + m4f.matrix[1][2] * subfactor05);
    
    		inversed.matrix[1][0] = -(m4f.matrix[0][1] * subfactor00 - m4f.matrix[0][2] * subfactor01 + m4f.matrix[0][3] * subfactor02);
    		inversed.matrix[1][1] = +(m4f.matrix[0][0] * subfactor00 - m4f.matrix[0][2] * subfactor03 + m4f.matrix[0][3] * subfactor04);
    		inversed.matrix[1][2] = -(m4f.matrix[0][0] * subfactor01 - m4f.matrix[0][1] * subfactor03 + m4f.matrix[0][3] * subfactor05);
    		inversed.matrix[1][3] = +(m4f.matrix[0][0] * subfactor02 - m4f.matrix[0][1] * subfactor04 + m4f.matrix[0][2] * subfactor05);
    
    		inversed.matrix[2][0] = +(m4f.matrix[0][1] * subfactor06 - m4f.matrix[0][2] * subfactor07 + m4f.matrix[0][3] * subfactor08);
    		inversed.matrix[2][1] = -(m4f.matrix[0][0] * subfactor06 - m4f.matrix[0][2] * subfactor09 + m4f.matrix[0][3] * subfactor10);
    		inversed.matrix[2][2] = +(m4f.matrix[0][0] * subfactor07 - m4f.matrix[0][1] * subfactor09 + m4f.matrix[0][3] * subfactor11);
    		inversed.matrix[2][3] = -(m4f.matrix[0][0] * subfactor08 - m4f.matrix[0][1] * subfactor10 + m4f.matrix[0][2] * subfactor11);
    
    		inversed.matrix[3][0] = -(m4f.matrix[0][1] * subfactor12 - m4f.matrix[0][2] * subfactor13 + m4f.matrix[0][3] * subfactor14);
    		inversed.matrix[3][1] = +(m4f.matrix[0][0] * subfactor12 - m4f.matrix[0][2] * subfactor15 + m4f.matrix[0][3] * subfactor16);
    		inversed.matrix[3][2] = -(m4f.matrix[0][0] * subfactor13 - m4f.matrix[0][1] * subfactor15 + m4f.matrix[0][3] * subfactor17);
    		inversed.matrix[3][3] = +(m4f.matrix[0][0] * subfactor14 - m4f.matrix[0][1] * subfactor16 + m4f.matrix[0][2] * subfactor17);
    
    		float determinant =
    			+m4f.matrix[0][0] * inversed.matrix[0][0]
    			+ m4f.matrix[0][1] * inversed.matrix[0][1]
    			+ m4f.matrix[0][2] * inversed.matrix[0][2]
    			+ m4f.matrix[0][3] * inversed.matrix[0][3];
    
    		inversed = inversed / determinant;
    
    		return inversed;
    	}
    
    	Matrix4f Matrix4f::getIdentityMatrix()
    	{
    		Matrix4f identityMatrix;
    
    		identityMatrix.matrix[0][0] = 1.0f;
    		identityMatrix.matrix[1][1] = 1.0f;
    		identityMatrix.matrix[2][2] = 1.0f;
    		identityMatrix.matrix[3][3] = 1.0f;
    
    		return identityMatrix;
    	}
    
    	Matrix4f Matrix4f::getTranslateMatrix(const float& x, const float& y, const float& z)
    	{
    		Matrix4f translationMatrix;
    
    		translationMatrix.matrix[0][0] = 1.0f;
    		translationMatrix.matrix[1][1] = 1.0f;
    		translationMatrix.matrix[2][2] = 1.0f;
    		translationMatrix.matrix[3][3] = 1.0f;
    
    		translationMatrix.matrix[3][0] = x;
    		translationMatrix.matrix[3][1] = y;
    		translationMatrix.matrix[3][2] = z;
    
    		return translationMatrix;
    	}
    
    	Matrix4f Matrix4f::getScaleMatrix(const float& x, const float& y, const float& z)
    	{
    		Matrix4f scaleMatrix;
    
    		scaleMatrix.matrix[0][0] = x;
    		scaleMatrix.matrix[1][1] = y;
    		scaleMatrix.matrix[2][2] = z;
    		scaleMatrix.matrix[3][3] = 1.0f;
    
    		return  scaleMatrix;
    	}
    
    	Matrix4f Matrix4f::getScaleMatrix(const Matrix4f & matrixToScale, const float scaleFactor)
    	{
    		Matrix4f result;
    
    		for (int i = 0; i < 4; i++) {
    			for (int j = 0; j < 4; j++)
    				result.matrix[i][j] = matrixToScale.matrix[i][j] * scaleFactor;
    		}
    
    		return result;
    	}
    
    	Matrix4f 	Matrix4f::getRotateXMatrix(const float& thetaX)
    	{
    		Matrix4f rotateXMatirx;
    
    		float angle = RadToDegree(thetaX);
    
    		rotateXMatirx.matrix[0][0] = 1.0f;
    		rotateXMatirx.matrix[3][3] = 1.0f;
    
    		float cosine = (float)cos(angle);
    		float sine = (float)sin(angle);
    		rotateXMatirx.matrix[1][1] = cosine;
    		rotateXMatirx.matrix[2][2] = cosine;
    		rotateXMatirx.matrix[1][2] = sine;
    		rotateXMatirx.matrix[2][1] = -sine;
    
    		return rotateXMatirx;
    	}
    
    	Matrix4f 	Matrix4f::getRotateYMatrix(const float& thetaY)
    	{
    		Matrix4f rotateYMatrix;
    
    		float angle = RadToDegree(thetaY);
    
    		rotateYMatrix.matrix[1][1] = 1.0f;
    		rotateYMatrix.matrix[3][3] = 1.0f;
    
    		float cosine = (float)cos(angle);
    		float sine = (float)sin(angle);
    		rotateYMatrix.matrix[0][0] = cosine;
    		rotateYMatrix.matrix[2][2] = cosine;
    		rotateYMatrix.matrix[0][2] = -sine;
    		rotateYMatrix.matrix[2][0] = sine;
    
    		return rotateYMatrix;
    	}
    
    	Matrix4f Matrix4f::getRotateZMatrix(const float& thetaZ)
    	{
    		Matrix4f rotateZMatrix;
    
    		rotateZMatrix.matrix[2][2] = 1.0f;
    		rotateZMatrix.matrix[3][3] = 1.0f;
    
    		float angle = RadToDegree(thetaZ);
    
    		float cosine = (float)cos(angle);
    		float sine = (float)sin(angle);
    		rotateZMatrix.matrix[0][0] = cosine;
    		rotateZMatrix.matrix[1][1] = cosine;
    		rotateZMatrix.matrix[0][1] = sine;
    		rotateZMatrix.matrix[1][0] = -sine;
    
    		return rotateZMatrix;
    	}
    
    	Matrix4f Matrix4f::getRotationMatrix(Vector3& axisToRotateAround, float theta)
    	{
    		theta = DegreeToRad(theta);
    
    		float cosA = cos(theta);
    		float sinA = sin(theta);
    
    		// Axis must be a unit vector
    		float checker = (powf(axisToRotateAround.getX(), 2) + powf(axisToRotateAround.getY(), 2) + powf(axisToRotateAround.getZ(), 2));
    		if (checker != 1) axisToRotateAround.Normalize();
    
    
    		float nx = axisToRotateAround.getX();
    		float ny = axisToRotateAround.getY();
    		float nz = axisToRotateAround.getZ();
    
    		float _cosA = 1 - cosA;
    		float nx_cosA = nx * _cosA;
    		float nz_cosA = nz * _cosA;
    		float nxnx_cosA = nx * nx_cosA;
    		float nxny_cosA = ny * nx_cosA;
    		float nxnz_cosA = nz * nx_cosA;
    		float nyny_cosA = ny * ny*_cosA;
    		float nynz_cosA = ny * nz_cosA;
    		float nznz_cosA = nz * nz_cosA;
    		float nxsinA = nx * sinA;
    		float nzsinA = nz * sinA;
    		float nysinA = ny * sinA;
    
    		Matrix4f rotationMatrx;
    		rotationMatrx.matrix[0][0] = nxnx_cosA + cosA;
    		rotationMatrx.matrix[0][1] = nxny_cosA + nzsinA;
    		rotationMatrx.matrix[0][2] = nxnz_cosA - nysinA;
    		rotationMatrx.matrix[0][3] = 0;
    		rotationMatrx.matrix[1][0] = nxny_cosA - nzsinA;
    		rotationMatrx.matrix[1][1] = nyny_cosA + cosA;
    		rotationMatrx.matrix[1][2] = nynz_cosA + nxsinA;
    		rotationMatrx.matrix[1][3] = 0;
    		rotationMatrx.matrix[2][0] = nxnz_cosA + nysinA;
    		rotationMatrx.matrix[2][1] = nynz_cosA - nxsinA;
    		rotationMatrx.matrix[2][2] = nznz_cosA + cosA;
    		rotationMatrx.matrix[2][3] = 0;
    		rotationMatrx.matrix[3][0] = 0;
    		rotationMatrx.matrix[3][1] = 0;
    		rotationMatrx.matrix[3][2] = 0;
    		rotationMatrx.matrix[3][3] = 1;
    
    		return rotationMatrx;
    
    
    		/************************************************************************/
    		/* In another way which results in the same effect.						*/
    		/************************************************************************/
    		/*
    		// STL uses rad for ratation unit
    		theta = DegreeToRad(theta);
    
    		// Axis must be a unit vector
    		float checker = (powf(axisToRotateAround.getX(), 2) + powf(axisToRotateAround.getY(), 2) + powf(axisToRotateAround.getZ(), 2));
    		if (checker != 1) if (checker != 1) VectorNormalize(axisToRotateAround);
    
    		Matrix4f rotationMatrix;
    		float qsin = (float)sin(theta / 2);
    		float qcos = (float)cos(theta / 2);
    		Vector4 vec(axisToRotateAround.getX(),axisToRotateAround.getY(),axisToRotateAround.getZ(),1.0f);
    		float w = qcos;
    		VectorNormalize(vec);
    		float x = vec.x * qsin;
    		float y = vec.y * qsin;
    		float z = vec.z * qsin;
    		ZeroMemory(&rotationMatrix.matrix, sizeof(rotationMatrix.matrix));
    		rotationMatrix.matrix[0][0] = 1 - 2 * y * y - 2 * z * z;
    		rotationMatrix.matrix[1][0] = 2 * x * y - 2 * w * z;
    		rotationMatrix.matrix[2][0] = 2 * x * z + 2 * w * y;
    		rotationMatrix.matrix[0][1] = 2 * x * y + 2 * w * z;
    		rotationMatrix.matrix[1][1] = 1 - 2 * x * x - 2 * z * z;
    		rotationMatrix.matrix[2][1] = 2 * y * z - 2 * w * x;
    		rotationMatrix.matrix[0][2] = 2 * x * z - 2 * w * y;
    		rotationMatrix.matrix[1][2] = 2 * y * z - 2 * w * x;
    		rotationMatrix.matrix[2][2] = 1 - 2 * x * x - 2 * y * y;
    		rotationMatrix.matrix[3][3] = 1.f;
    		return rotationMatrix;
    		*/
    	}
    
    	Matrix4f Matrix4f::getPerspectiveMatrix(float fovYOZ, float aspectRatio, float zNear, float zFar)
    	{
    		fovYOZ = DegreeToRad(fovYOZ);
    
    		float focalLength = 1.f / tanf(fovYOZ / 2);
    
    		Matrix4f perspectiveMatrix;
    
    		perspectiveMatrix.matrix[0][0] = focalLength / aspectRatio;
    		perspectiveMatrix.matrix[1][1] = focalLength;
    		perspectiveMatrix.matrix[2][2] = zFar / (zFar - zNear); // in left hand coordinate
    		perspectiveMatrix.matrix[3][2] = -(zFar * zNear) / (zFar - zNear);
    		perspectiveMatrix.matrix[2][3] = 1.f; // in left hand coordinate
    
    		return perspectiveMatrix;
    
    	}
    
    	Matrix4f Matrix4f::getOrthographicMatrix(const float conusLeft, const float conusRight, const float conusBottom, const float conusTop, float zNear, float zFar)
    	{
    		Matrix4f orthographicMatrix;
    
    		/// make z range : [0,1], left hand coordinate
    		orthographicMatrix.matrix[0][0] = 2.f / (conusRight - conusLeft);
    		orthographicMatrix.matrix[1][1] = 2.f / (conusTop - conusBottom);
    		orthographicMatrix.matrix[2][2] = 1.f / (zFar - zNear); // in left hand coordinate
    		orthographicMatrix.matrix[3][0] = -(conusRight + conusLeft) / (conusRight - conusLeft);
    		orthographicMatrix.matrix[3][1] = -(conusTop + conusBottom) / (conusTop - conusBottom);
    		orthographicMatrix.matrix[3][2] = -zNear / (zFar - zNear);
    		orthographicMatrix.matrix[3][3] = 1.f;
    
    
    		return orthographicMatrix;
    	}
    
    	Matrix4f Matrix4f::getMatrixInvertForOrthogonal(const Matrix4f & orthographicMatrix)
    	{
    		return getTransposeMatrix(orthographicMatrix);
    	}
    
    	Matrix4f Matrix4f::getLookAtMatrixForLeftHandCoordinate(Vector3 * eyePos, const Vector3 * lookAt, const Vector3 * up, Vector3 & newCameraUpAxis)
    	{
    		Vector3 zAxis = *lookAt - *eyePos;
    		zAxis.Normalize();
    		Vector3 xAxis = *up ^ zAxis;
    		xAxis.Normalize();
    		Vector3 yAxis = zAxis ^ xAxis;
    		newCameraUpAxis = yAxis; // store the last upaxis for updating camera position
    
    		Matrix4f result;
    
    		/// when(major==raw) => do: below
    		result.matrix[0][0] = xAxis.getX();
    		result.matrix[0][1] = yAxis.getX();
    		result.matrix[0][2] = zAxis.getX();
    		result.matrix[0][3] = 0;
    		result.matrix[1][0] = xAxis.getY();
    		result.matrix[1][1] = yAxis.getY();
    		result.matrix[1][2] = zAxis.getY();
    		result.matrix[1][3] = 0;
    		result.matrix[2][0] = xAxis.getZ();
    		result.matrix[2][1] = yAxis.getZ();
    		result.matrix[2][2] = zAxis.getZ();
    		result.matrix[2][3] = 0;
    		result.matrix[3][0] = -(xAxis * (*eyePos));
    		result.matrix[3][1] = -(yAxis * (*eyePos));
    		result.matrix[3][2] = -(zAxis * (*eyePos));
    		result.matrix[3][3] = 1;
    
    		/*
    		Matrix-Structure(
    				xaxis.x,			yaxis.x,			zaxis.x,			0,
    				xaxis.y,			yaxis.y,			zaxis.y,			0,
    				xaxis.z,			yaxis.z,			zaxis.z,			0,
    				-xaxis.Dot(eyePos), -yaxis.Dot(eyePos), -zaxis.Dot(eyePos), 1
    		);*/
    		return result;
    	}
    
    	Matrix4f Matrix4f::getLookAtMatrixForLeftHandCoordinate(Vector3& eyePos, const Vector3& lookAt, const Vector3& up)
    	{
    		Vector3 xAxis, yAxis, zAxis;
    
    		zAxis = lookAt - eyePos;
    		zAxis.Normalize();
    
    		xAxis = up ^ zAxis;
    		xAxis.Normalize();
    
    		yAxis = zAxis ^ xAxis;
    
    
    		Matrix4f result;
    
    		result.matrix[0][0] = xAxis.getX();
    		result.matrix[1][0] = xAxis.getY();
    		result.matrix[2][0] = xAxis.getZ();
    		result.matrix[3][0] = -(xAxis * eyePos);
    
    		result.matrix[0][1] = yAxis.getX();
    		result.matrix[1][1] = yAxis.getY();
    		result.matrix[2][1] = yAxis.getZ();
    		result.matrix[3][1] = -(yAxis * eyePos);
    
    		result.matrix[0][2] = zAxis.getX();
    		result.matrix[1][2] = zAxis.getY();
    		result.matrix[2][2] = zAxis.getZ();
    		result.matrix[3][2] = -(zAxis* eyePos);
    
    		result.matrix[3][3] = 1.f;
    
    		return result;
    	}
    
    	Matrix4f Matrix4f::MatrixViewPort(const float & screenWidth, const float & screenHeight, const float & maxDepth, const float & minDepth, const float & topLeftX, const float & topLeftY)
    	{
    		Matrix4f viewportMatrix;
    
    		viewportMatrix.matrix[0][0] = screenWidth / 2.0f;
    		viewportMatrix.matrix[1][1] = -screenHeight / 2.0f;
    		viewportMatrix.matrix[2][2] = maxDepth - minDepth;
    		viewportMatrix.matrix[3][0] = topLeftX + screenWidth / 2.0f;
    		viewportMatrix.matrix[3][1] = topLeftY + screenHeight / 2.0f;
    		viewportMatrix.matrix[3][2] = minDepth;
    		viewportMatrix.matrix[3][3] = 1.0f;
    
    		return viewportMatrix;
    	}
    
    	void Matrix4f::ApplyTransformToRelevantMatrix(Vector4 & point, const Matrix4f & relevantMatrix)
    	{
    		// store the point first
    		float x = point.getX();
    		float y = point.getY();
    		float z = point.getZ();
    		float w = point.getW();
    		point.setX(x * relevantMatrix.matrix[0][0] + y * relevantMatrix.matrix[1][0] + z * relevantMatrix.matrix[2][0] + w * relevantMatrix.matrix[3][0]);
    		point.setY(x * relevantMatrix.matrix[0][1] + y * relevantMatrix.matrix[1][1] + z * relevantMatrix.matrix[2][1] + w * relevantMatrix.matrix[3][1]);
    		point.setZ(x * relevantMatrix.matrix[0][2] + y * relevantMatrix.matrix[1][2] + z * relevantMatrix.matrix[2][2] + w * relevantMatrix.matrix[3][2]);
    		point.setW(x * relevantMatrix.matrix[0][3] + y * relevantMatrix.matrix[1][3] + z * relevantMatrix.matrix[2][3] + w * relevantMatrix.matrix[3][3]);
    	}
    }
    
    




    作者:艾孜尔江·艾尔斯兰
    更多相关内容
  • LabelMatrix_v2018.zip

    2020-11-12 12:49:05
    8.1版本,标签软件.
  • Label Matrix 5.0+序列号

    2018-07-16 14:56:02
    label matrix5.0版本,包含安装文件以及注册序列号,经典稳定版本
  • LABEL MATRIX 7 破解文件

    2018-11-10 15:48:55
    LABEL MATRIX 7 破解文件
  • DataLogic Matrix300N 中文彩页,中文说明书,宣传彩页
  • 资源包含有DLL、LIB、H文件可根据需求程序调用函数接口来使用动态库其功能点有两个: ...识别Data-Matrix格式的二维码 —— Data_Matrix(IplImage *Image, char *Information); 版权望断所有,下载请私用!
  • Matrix Algebra Useful for Statistics,2ed Matrix Algebra Useful for Statistics,2ed Matrix Algebra Useful for Statistics,2ed Matrix Algebra Useful for Statistics,2ed Matrix Algebra Useful for Statistics...
  • VC代码 matrix (实用代码源).rarVC代码 matrix (实用代码源).rarVC代码 matrix (实用代码源).rarVC代码 matrix (实用代码源).rarVC代码 matrix (实用代码源).rarVC代码 matrix (实用代码源).rarVC代码 matrix (实用...
  • 矩阵分析Matrix Analysis中文版 Roger A. Horn Charles R. Johnson
  • Label Matrix8.10和注册机 第一部分

    热门讨论 2015-01-03 08:45:37
    里面有三个文件Label Matrix8 10版本程序 注册机 安装说明文件 自己也在用 这是第一部分 请在我的资源里面继续下载第二部分 Label Matrix8 10和注册机 第二部分 即可解压
  • State Estimation for Robotics A Matrix Lie Group Approach
  • Matlab code for computing and visualization: Confusion Matrix, Precision/Recall, ROC, Accuracy, F-Measure etc. for Classification. Matlab通过分类的label计算混淆矩阵Confusion Matrix并且显示的函数只要...
  • labelmatrix crack8.1(8.6可用).rar

    热门讨论 2013-07-16 17:09:30
    labelmatrix crack8.1(8.6可用).rar labelmatrix 8.6.exe 破解补丁。 安装labelmatrix 8.6完成后,将crack文件夹内所有文件复印到安装目录。注意:请先备份一下原文件。 如需要连数据库功能,可以在破解前添加...
  • 一、Android Matrix 矩阵

    千次阅读 2022-03-20 21:44:30
    大学学的线性代数和矩阵基本忘记的差不多了,理解起矩阵Matrix着实有点费劲,记了一次笔记还把左乘右乘记错了。 1.1 使用场景 项目中会使用到矩阵的场景: 背景图片,指定位置为中心点的缩放,图片平移,图片旋转。...

    一、Android矩阵

    大学学的线性代数和矩阵基本忘记的差不多了,理解起矩阵Matrix着实有点费劲,记了一次笔记还把左乘右乘记错了。

    1.1 使用场景

    项目中会使用到矩阵的场景:

    1. 背景图片,指定位置为中心点的缩放,图片平移,图片旋转。
    2. opengles 中GLSurfaceView所承载的内容需要缩放,平移变换。是内容变换不是窗口glViewport 变换

    【注意】:这里提到了两种场景就对应了两种坐标体系,2种矩阵

    • 图片场景的矩阵,也就是 android.graphics.Matrix 后文用Android Matrix表示,是 2维坐标,3*3 矩阵。
    • opengles 矩阵 android.opengl.Matrix 后文用opengles 矩阵,后文用opengles Matrix 表示,是 4*4 矩阵。
    • android里也有 44矩阵 android.renderscript.Matrix4f 这个是矩阵和 android.opengl.Matrix 矩阵是能对的上的,都是3维坐标, 44矩阵。后文用 Matrix4f 表示。之所以引入这个是这个类有些方法比opengles Matrix 类的方法使用起来会更简单点。不用该矩阵其实也问题不大

    二、 Android Matrix

    2.1、元素表达

    3*3矩阵,没个元素表达的意思:
    在这里插入图片描述

    • MTRANS_X、MTRANS_Y 同时控制着 Translate (平移)
    • MSCALE_X、MSCALE_Y 同时控制着 Scale (缩放)
    • MSCALE_X、MSKEW_X、MSCALE_Y、MSKEW_Y 同时控制着 Rotate (旋转)
    • MSKEW_X、MSKEW_Y 同时控制着 Skew (倾斜,扭曲)

    【注】:项目中没有使用Skew和Rotate不详细讨论

    2.2、 set post pre

    这里强调这三个函数是因为很容易歧义,但是实际使用中最常用绕不开就是这几个简单操作。Translate ,Scale ,Skew 都有这三个函数,以平移为例:

    1. m.setTranslate 直接设置位移量,m的其它参数变为单位矩阵的初始量。不涉及乘法
    2. m.postTranslate m左乘一个位移矩阵
    3. m.preTranslate m右乘一个位移矩阵

    因为存在post 和pre ,就要区分这两个函数的区别,就容易逻辑开叉到底,post和pre哪个是左乘,哪个是右乘。什么场合用post,什么场合用pre。

    重学了一遍线性代数里矩阵的一些知识,越学越懵,也读了不少blog,有些说post 是左乘,有些说post是右乘,我的笔记里第一次也是记post为右乘。虽然 也有看post函数的注释,但是理解上还是出现了偏差:
    1、官方注释

       /**
         * Postconcats the matrix with the specified translation. M' = T(dx, dy) * M
         */
        public boolean postTranslate(float dx, float dy) {
            nPostTranslate(native_instance, dx, dy);
            return true;
        }
    

    2、识记理解
    这里:M’ = T(dx, dy) * M 其中:M是原矩阵,T是位移阵可以理解为目标变换。目标变换在左边就是左乘。目标变换在右边就是右乘。

    • post 是左乘
    • pref 是右乘

    3、post VS pref
    关于左乘右乘区别说的比较好的有2个观点:
    https://www.zhihu.com/question/263660493
    空间中的向量用列向量表示。

    1. 左乘是行变换,右乘是列变换。矩阵左乘列向量就是把它在空间当中做变换。
    2. 在固定坐标系里,用左乘。在非固定坐标系用右乘。Android是固定坐标系。

    小结:
    1、Android的Matrix 的几何变换可以都用post来计算,因为Android是固定坐标系空间变换用post左乘来来做是符合逻辑的。同一组计算变换里一会用post一会用pre逻辑容易乱,需要改变顺序的时候可以拿两个矩阵通过写A.postConcat(B) 或者B.postConcat(A)来修改。

    2、android.renderscript.Matrix4f ,android.opengl.Matrix这两个4*4矩阵是能对应的起来的。这两个矩阵类里是不存在post和pref一说,里面的变换都是左乘 post的方式。所以理解起来反而更简单。so,我认为android Matrix都用post来更好理解

    三、android Matrix 实际使用

    场景一:指定点的放大,缩小。
    opengles 的矩阵在这里不详述,因为它的坐标系和坐标比例计算方式都不一样。opengles 坐标依赖顶点坐标和[-1,1]范围计算。后面再写一篇介绍。

    1、可以直接用指定点放大缩小函数

    m.setScale(scale, scale, cx, cy)
    

    2、使用平移和缩放(android.opengl.Matrix和Matrix4f 都没有上一种方法)
    T(cx,cy)*S(s,s)*T(-cx,-cy)*m
    因为android的坐标0,0是左上角,如果是opengles 移动的点第一次变换就不是m.postTranslate(-cx, -cy)

    // android matrix
    //平移原点到目标点
    m.postTranslate(-cx, -cy)
    m.postScale(scale, scale)
    m.postTranslate(cx, cy)
    
    

    opengl es的矩阵

    //opengles matrix
    Matrix4f matrix4f = new Matrix4f();
    matrix4f.loadTranslate(x, y, 0);
    matrix4f.scale(scaleX,scaleX,1);
    //满足结合率,所以可以先算变换矩阵
    matrix4f.translate(-x,-y,0);
    current.multiply(matrix4f);
    

    3、先缩放再平移
    这边的1相关是推导出来的公式

    m.postScale(scale, scale)
    m.postTranslate(-(scale-1)*cx,-(scale-1)*cy)
    

    4、推导的一些公式
    指定点放大缩小:位移,中心点,倍数之间最后效果的时候关系
    cx,cy:定点x,定点y
    dx:平移
    s:缩放倍数
    dx = -(s-1)*cx = (1-s)*cx
    cx = dx/(1-s)
    同理
    cy = dy/(1-s)

    【注】:同样适用于

    • android.renderscript.Matrix4f
    • android.opengl.Matrix
    展开全文
  • Label Matrix v8.70破解文件

    热门讨论 2013-08-13 10:41:14
    将文件先解压缩,然后复制到 Label Matrix v8.60或v8.70安装的程序目录下,并且替换,就可以破解了
  • Android-使用Matrix对Bitmap进行处理

    热门讨论 2014-04-27 20:41:37
    Android-使用Matrix对Bitmap进行处理
  • 里面包含QRcode,PDF417国家标准以及Datamatrix的ISO标准(英文版)。
  • 二维坐标轴旋转公式推导 ... 设点M在原坐标系中的坐标为(x,y),对应向量的模为r,幅角为α.将坐标轴绕坐标原点,按照逆时针方向旋转角θ形成新坐标系,点M在新坐标系中的坐标为(如...Matrix4x4矩阵 https://www.cnblogs

    二维坐标轴旋转公式推导

    https://www.cnblogs.com/fangsmile/p/8622421.html
    在这里插入图片描述

    设点M在原坐标系中的坐标为(x,y),对应向量的模为r,幅角为α.将坐标轴绕坐标原点,按照逆时针方向旋转角θ形成新坐标系,点M在新坐标系中的坐标为(如图2-4),则
    在这里插入图片描述

    由此得到坐标轴的旋转的坐标变换公式
    在这里插入图片描述

    矩阵旋转公式推导

    https://www.cnblogs.com/wywnet/p/3585075.html
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    Matrix4x4矩阵

    https://www.cnblogs.com/jiahuafu/p/5981578.html
    矩阵也是3D图形学一个重要的概念,在D3D里用的很平凡,但是U3D里好像都已经封装到各个Object上去了,所以很容易忽视掉,但不能忽视它的存在。在3D世界里,每个物体均有自身的世界矩阵,摄像机有摄像机矩阵,投影场景有projection矩阵,对顶点、向量、物体实施各种平移、旋转、缩放都是通过矩阵来完成的。计算机3D物体的标准4×4矩阵是这样定义的:(表示不出来矩阵大括号,请读者就当左4行的[和右4行的]当成一对大括号)
    Transform:
    这个就是U3D所封装的矩阵运算了,用于缩放,平移,还有定位(这个囧,他把矩阵给放这用了,所有物体都可以用transform类型来存放)。Transform所实现的功能不过就是物体矩阵的运算罢了,具体如下:

    Matrix4x4中,是按列优先填充的。m12就是第一行二列,下标从0开始
    //
    // 摘要:
    // A standard 4x4 transformation matrix.
    [DefaultMember(“Item”)]
    [NativeClass(“Matrix4x4f”)]
    [NativeHeader(“Runtime/Math/MathScripting.h”)]
    [NativeType(Header = “Runtime/Math/Matrix4x4.h”)]
    [RequiredByNativeCode(Optional = true, GenerateProxy = true)]
    [ThreadAndSerializationSafe]
    public struct Matrix4x4 : IEquatable
    {
    [NativeName(“m_Data[0]”)]
    public float m00;
    [NativeName(“m_Data[15]”)]
    public float m33;
    [NativeName(“m_Data[14]”)]
    public float m23;
    [NativeName(“m_Data[13]”)]
    public float m13;
    [NativeName(“m_Data[12]”)]
    public float m03;

    在这里插入图片描述

    Matrix4x4.identity 单位矩阵
    这个矩阵在使用的时不会影响任何东西。它的主对角线上全是1,其他位置全是0。

    矩阵旋转

    public static void Matrix4x4_Rotation(this Transform transform, SelfAxle axle, float angle)
        {
            Matrix4x4 ori = Matrix4x4.zero;
            ori.SetTRS(transform.position, transform.rotation, Vector3.one);
    
            matrix = Matrix4x4.identity;
    
            if (axle == SelfAxle.X)
            {
                matrix.m11 = Mathf.Cos(angle * Mathf.Deg2Rad);
                matrix.m12 = -Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m21 = Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m22 = Mathf.Cos(angle * Mathf.Deg2Rad);
    
            }
            else if (axle == SelfAxle.Y)
            {
                matrix.m00 = Mathf.Cos(angle * Mathf.Deg2Rad);
                matrix.m02 = Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m20 = -Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m22 = Mathf.Cos(angle * Mathf.Deg2Rad);
            }
            else
            {
                matrix.m00 = Mathf.Cos(angle * Mathf.Deg2Rad);
                matrix.m01 = -Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m10 = Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m11 = Mathf.Cos(angle * Mathf.Deg2Rad);
            }
    
    
            matrix = matrix * ori;
            transform.rotation = matrix.GetRotation();
        }
        
            public static Quaternion GetRotation(this Matrix4x4 matrix4X4)
        {
            float qw = Mathf.Sqrt(1f + matrix4X4.m00 + matrix4X4.m11 + matrix4X4.m22) / 2;
            float w = 4 * qw;
            float qx = (matrix4X4.m21 - matrix4X4.m12) / w;
            float qy = (matrix4X4.m02 - matrix4X4.m20) / w;
            float qz = (matrix4X4.m10 - matrix4X4.m01) / w;
            return new Quaternion(qx, qy, qz, qw);
        }
        
        //如何使用
        transform.Matrix4x4_Rotation(SelfAxle.X, 46f);
    

    源码

    https://github.com/luoyikun/UnityForTest
    MatrixTest场景

    展开全文
  • Intel(R) Matrix Storage Console(中文版)

    热门讨论 2012-05-16 08:47:33
    您可以从以下两种模式检视 Intel(R) Matrix Storage Console:「基本模式」和「进阶模式」。「基本模式」是一种简单的模式,以状态讯息和图示的形式显示装置资讯。在异常的情况下,例如硬碟遗失或硬碟发生故障时,「...
  • Matrix

    千次阅读 2016-10-03 14:44:57
    初识Matrix第一次见到Matrix是在图片缩放的时候,Matrix(矩阵),在网上搜索一番,觉得还是直接写下记录一下方便以后复习翻阅public class MyView extends View {Bitmap mBitmap;public MyView(Context context) { ...

    初识Matrix

    第一次见到Matrix是在图片缩放的时候,Matrix(矩阵),在网上搜索一番,觉得还是直接写下记录一下方便以后复习翻阅

    public class MyView extends View {
    
    Bitmap mBitmap;
    
    public MyView(Context context) {
        super(context);
    }
    
    public MyView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
    
    public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
    
    public Bitmap getBitmap() {
        return mBitmap;
    }
    
    public void setBitmap(Bitmap bitmap) {
        mBitmap = bitmap;
    }
    
    public boolean isEmpty() {
        return mBitmap == null;
    }
    
    @Override
    protected void onDraw(Canvas canvas) {
    
        if (mBitmap != null) {
            Matrix matrix = new Matrix();
            canvas.drawBitmap(mBitmap, matrix, null);
        }
    }
    }  
    

    xml布局

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context="com.example.jinxiong.matric.MainActivity">
    
       <com.example.jinxiong.matric.MyView
    
           android:layout_width="match_parent"
           android:layout_height="match_parent"
           android:id="@+id/myImageView"
           />
    </RelativeLayout>  
    

    Activity

    public class MainActivity extends AppCompatActivity {
    
    ImageLoader mImageLoader;
    MyView mImageView;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ImageLoaderConfiguration imageLoaderConfiguration = ImageLoaderConfiguration.createDefault(this);
        ImageLoader.getInstance().init(imageLoaderConfiguration);
    
        mImageLoader = ImageLoader.getInstance();
        mImageView = (MyView) this.findViewById(R.id.myImageView);
    
        Bitmap bitmap = mImageLoader.loadImageSync("drawable://" + R.drawable.test);
        mImageView.setBitmap(bitmap);
    
    }
    }
    


    可以看到这张图片是大于手机屏幕的,需要对图片进行缩小,那么就要使用到Matrix了

     @Override
        protected void onDraw(Canvas canvas) {
        if (mBitmap != null) {
            Matrix matrix = new Matrix();
            matrix.setScale(0.5f, 0.5f);
            canvas.drawBitmap(mBitmap, matrix, null);
        }
    }  
    

    那么就可以看到
    这里写图片描述
    那么Matrix那么厉害,他究竟是什么?

    走进Matrix

    matrix就是矩阵的意思,
    这里写图片描述
    正常我们通过

    Matrix matrix = new Matrix();  
    

    创建的矩阵式单位矩阵:
    这里写图片描述
    我们可以通过

    matrix.toShortString()  
    

    打印出来

    [1.0, 0.0, 0.0][0.0, 1.0, 0.0][0.0, 0.0, 1.0]  
    

    我认为Matrix最重要的就是实现变换,基本的变换有四种
    1. 缩放
    2. 错切
    3. 平移
    4. 旋转
    参数控制:
    这里写图片描述

    缩放

    在初次创建Matrix 对象的时候,Matrix的缩放两个参数都是1,表示按原本尺寸显示,

    matrix.setScale();
    matrix.postScale();
    matrix.preScale();
    

    有这三个方法,参数都是一样,先说下两个参数的情况
    这里写图片描述
    setScale 就是在你原有的矩阵中 插入两个值,一个是1行2列 ,一个是2行1列中的值
    而preScale 就是矩阵的乘,把原有的矩阵放在乘的左边,目标矩阵放在右边(因为矩阵的左乘和右乘是不一样的),
    这里写图片描述
    左边的第一行与右边的第一列的值相乘相加后变成结果矩阵的第一行第一列的值,左边第一行与右边第二列的值相乘相加结果变成借股票矩阵的第一行第二列的值,左边的第一行和右边的第三列相乘相加的值变为结果矩阵的第一行第三列的值,以此类推

    而postScale 也是这样,只不过把源矩阵和目标矩阵的位置交换,那么结果自然是不一样的了

    而当它为四个参数的时候

    public void setScale(float sx, float sy, float px, float py) {
        native_setScale(native_instance, sx, sy, px, py);
    }
    

    后面两个新参数就是缩放中心的坐标,如果使用两位参数的setScale的话,默认的缩放中心坐标就是(0,0)

    @Override
    protected void onDraw(Canvas canvas) {
    
        if (mBitmap != null) {
            Matrix matrix = new Matrix();
            matrix.setScale(0.5f, 0.5f, mBitmap.getWidth() / 2, mBitmap.getHeight() / 2);
            canvas.drawBitmap(mBitmap, matrix, null);
        }
    
    } 
    

    将刚刚那张图片以图片中心为缩放中心缩小一半,
    这里写图片描述
    对于这三种方法设置图片的缩放,对于set方法,是直接将值付给相应的矩阵的位置的值,对源矩阵来说,改变的只是那两个缩放的值,但是对于pre 和 post的话,因为涉及到矩阵的乘法,还是会对源矩阵一些本来的值会造成影响,可能这并不是你想要的,至于什么时候使用哪一种,具体还是看自己想要怎么样

    错切

    错切也有三个方法和两种参数格式,跟scale 是一样的,这里就以setSkew为例子

    matrix.setSkew(0.5f,0f);
    

    这里写图片描述

    matrix.setSkew(0f,0.5f);
    

    这里写图片描述

    matrix.setSkew(0.5f,0.5f);
    

    这里写图片描述

    matrix.setSkew(0.5f, 0.5f, mBitmap.getWidth() / 2, mBitmap.getHeight() / 2);   
    

    这里写图片描述

    旋转

    旋转也是对应着三个方法

    matrix.setRotate(45);   
    

    这里写图片描述原点为中心旋转45度

    matrix.setRotate(180, mBitmap.getWidth() / 2, mBitmap.getHeight() / 2);  
    

    这里写图片描述图片中心为中心,180度

    平移

    这个也是很简单的方法

    matrix.setTranslate(0,200);  
    

    这里写图片描述
    这里的translation 和 view.setTranslation 相似,但是移动 的偏移量是不同的位置
    这里写图片描述

    setPolyToPoly

    这里写图片描述
    这个特效怎么实现尼 ,答案就是setPolyToPoly

    @Override
    protected void onDraw(Canvas canvas) {
    
        if (mBitmap != null) {
            Matrix matrix = new Matrix();
    
            float[] src = new float[]{
                    0,0,
                    mBitmap.getWidth(),0,
                    mBitmap.getWidth(),mBitmap.getHeight(),
                    0,mBitmap.getHeight()
            };
    
            float[] dst = new float[]{
                    0, 0,
                    mBitmap.getWidth()/2, 100,
                    mBitmap.getWidth()/2, mBitmap.getHeight() - 100,
                    0, mBitmap.getHeight()
            };
    
            matrix.setPolyToPoly(src, 0, dst, 0, 4);
    
            canvas.drawBitmap(mBitmap, matrix, null);
        }
    
    } 
    

    poly就是多边形的意思,

    /**
     * Set the matrix such that the specified src points would map to the
     * specified dst points. The "points" are represented as an array of floats,
     * order [x0, y0, x1, y1, ...], where each "point" is 2 float values.
     *
     * @param src   The array of src [x,y] pairs (points)
     * @param srcIndex Index of the first pair of src values
     * @param dst   The array of dst [x,y] pairs (points)
     * @param dstIndex Index of the first pair of dst values
     * @param pointCount The number of pairs/points to be used. Must be [0..4]
     * @return true if the matrix was set to the specified transformation
     */
    public boolean setPolyToPoly(float[] src, int srcIndex,
                                 float[] dst, int dstIndex,
                                 int pointCount)  
    

    src:代表的是一个坐标数组,这个多边形的点的坐标,srcIndex代表的是从前面的数组哪一个下标开始,而
    dst就是你想要变成的多边形的坐标数组,

    setRectToRect

    这里写图片描述
    也是使用一个源矩形和目标矩形进行变换,这是使图片居中(感觉微信的图片是不是这样实现尼?)

    @Override
    protected void onDraw(Canvas canvas) {
    
        if (mBitmap != null) {
            Matrix matrix = new Matrix();
    
            RectF src = new RectF(0, 0, mBitmap.getWidth(), mBitmap.getHeight());
            RectF dst = new RectF(0, 0, getWidth(), getHeight());
    
            matrix.setRectToRect(src, dst, Matrix.ScaleToFit.CENTER);
    
            canvas.drawBitmap(mBitmap, matrix, null);
        }
    
    }
    } 
    

    最后

    基本的使用就是这样 ,更多详细可以看着个大神blog
    http://www.gcssloop.com/customview/Matrix_Basic
    http://www.gcssloop.com/customview/Matrix_Method

    展开全文
  • Android 图形处理 —— Matrix 原理剖析

    千次阅读 2022-03-25 10:20:52
    介绍了 Matrix 图形变换的原理,关于平移、缩放、旋转、错切的计算原理,学生时期学习的线性代数和三角函数终于派上用场了...
  • 和矩阵相关的头文件matrix.h

    热门讨论 2012-12-17 14:23:31
    调试C++程序时,提示not such file"matrix.h"时,只需要在头文件中新建一个matrix.h文件,将本文档中的内容复制过去即可
  • 矩阵运算库 C语言 (Matrix_hub)

    千次阅读 2020-02-12 16:51:11
    Matrix_hub ======================================= 矩阵运算库--C语言 --------------------------------------- ##The lib of Matrix operation for C language. (矩阵运算库--C语言) Author: Amoiensis Email...
  • R语言 Matrix的使用

    万次阅读 多人点赞 2020-03-24 22:25:31
    R中有5种基本数据结构,分别是向量(vector)、矩阵(matrix)、数组(array)、数据框(data frame)和列表(list)。它们的结构如下图: 注意:其中向量、矩阵和数组中的数据类型必须是相同的;而数据框和列表中的数据类型...
  • $ g++ -I /usr/local/include/eigen3 matrix_initial1.cpp -o matrix_initial1 $ $ ./matrix_initial1 vec1 = 1 2 3 vec2 = 1 4 9 16 joined = 1 2 3 1 4 9 16 ----------------------- Here is the initialed ...
  • Android Matrix 超级详解

    千次阅读 2018-02-26 22:40:40
    以下转自: http://www.gcssloop.com/customview/Matrix_Method http://www.gcssloop.com/customview/Matrix_Basic这应该是目前最详细的一篇讲解Matrix的中文文章了,在上一篇文章Matrix原理中,我们对Matrix做了...
  • opencv的Mat与Eigen的Matrix相互转换

    千次阅读 2020-10-15 15:38:34
    1 opencv的Mat与Eigen的Matrix相互转换 1.1 Eigen 转 cv::Mat 1.2 cv::Mat 转 Eigen 1.3 float 与 double 互转 2 SE(3):把cv的旋转矩阵转换为Eigen中旋转矩阵的赋值 1 opencv的Mat与Eigen的Matrix相互转换 ...
  • Matrix factorization techniques for recommender systems 数据采集文档
  • python函数之csr_matrix

    千次阅读 2022-03-22 16:36:58
    csr_matrix表示逐行(注意csr的r,row)压缩矩阵,类似地,也有个函数csc_matrix(c:column)表示逐列压缩。 形式:csr_matrix( (data, indices, indptr), shape=(x,y) ) shape就是压缩后的矩阵地形状,x行y列; ...
  • Matrix Maker Manual Chinese S78AU S60CU 说明

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 478,129
精华内容 191,251
关键字:

Matrix