精华内容
下载资源
问答
  • 2.编写代码,实现二维向量和三维向量的运算: 1)遵循软件开发标准,程序分文件书写; 2)可以进行向量的加减和比较运算(重载+,-,=和==运算符)。 3)分别用静态链接和共享链接的方式测试向量的使用。 3.创建包含二维...
  • C#封装的三维向量

    2016-05-31 12:24:05
    C#封装的三维向量,代码封装性还是比较不错的
  • 编写代码,实现二维向量和三维向量的运算: 1) 遵循软件开发标准,程序分文件书写; 2) 可以进行向量的加减和比较运算(重载+,-,=和==运算符)。 3) 分别用静态链接和共享链接的方式测试向量的使用。 3. 创建包含...
  • (1)网上参考的三维向量类 /*-------------------------------------------------- * 类名称:三维向量类-Vector.h * 类作用:用于三维空间中向量常见的数学运算. * 创建人:Edited by huangwang * 创建...

    (1)网上参考的三维向量类

     

    /*--------------------------------------------------
     * 类名称:三维向量类-Vector.h
     * 类作用:用于三维空间中向量常见的数学运算.
     * 创建人:Edited by huangwang
     * 创建时间:2017年6月19日
     *--------------------------------------------------*/
    #ifndef __VECTOR_H__
    #define __VECTOR_H__
    
    #include <math.h>
    
    template <class T>
    struct Vector3
    {
      // 创建一个三维向量向量
      Vector3 (T x_=0, T y_=0, T z_=0) : x(x_), y(y_), z(z_) {}
    
      // 设置三维向量三个方向上的坐标
      void set (T x_, T y_, T z_) { x=x_; y=y_; z=z_; }
    
      // 三维向量归一化
      Vector3	normalize() const { return((*this) / norm()); }
      double norm        () const { return sqrt(normSquared()); }
      T      normSquared () const { return x*x+y*y+z*z; }
    
      // BOOL型操作运算符
      bool operator == (const Vector3& v) const { return x==v.x && y==v.y && z==v.z; }
      bool operator != (const Vector3& v) const { return x!=v.x || y!=v.y || z!=v.z; }
    
      // 常见的运算符
      Vector3  operator +  (const Vector3 &v) const { return Vector3(x+v.x, y+v.y, z+v.z); }
      Vector3& operator += (const Vector3 &v)       { x+=v.x; y+=v.y; z+=v.z; return *this; }
      Vector3  operator -  () const                 { return Vector3(-x, -y, -z); }
      Vector3  operator -  (const Vector3 &v) const { return Vector3(x-v.x, y-v.y, z-v.z); }
      Vector3& operator -= (const Vector3 &v)       { x-=v.x; y-=v.y; z-=v.z; return *this; }
      Vector3  operator *  (T s) const              { return Vector3(x*s, y*s, z*s); }
      Vector3& operator *= (float s)                { x*=s; y*=s; z*=s; return *this; }
      Vector3  operator /  (float s) const          { ASSERT(s); return (*this)* (1/s); }
      Vector3& operator /= (float s)                { ASSERT(s); return (*this)*=(1/s); }
    
      // 三维向量坐标
      T x, y, z;
    };
    
    
    template <class T> inline
    //三维向量点积
    T Dot (const Vector3<T>& l, const Vector3<T>& r)
    {
      return l.x*r.x + l.y*r.y + l.z*r.z;
    }
    
    // 三维向量叉积
    template <class T> inline
    Vector3<T> Cross (const Vector3<T>& l, const Vector3<T>& r)
    {
      return Vector3<T>(
        l.y*r.z - l.z*r.y,
        l.z*r.x - l.x*r.z,
        l.x*r.y - l.y*r.x );
    }
    
    // 三维向量混合积
    template <class T> inline
    T BlendProduct (const Vector3<T>& l, const Vector3<T>& m, const Vector3<T>& r)
    {
      return Dot(Cross(l, m), r);
    }
    
    //各种三维向量类型的定义
    typedef Vector3<char>   Vector3c;
    typedef Vector3<int>    Vector3i;
    typedef Vector3<float>  Vector3f;
    typedef Vector3<double> Vector3d;
    
    #endif
    

     

    (2)自己封装的三维向量类Vector3D

     

    .h

     

    //#pragma once
    /*------Vector3D---------------------------------------------
    类作用:三维向量类,提供向量的基本运算
    作者:HuangWang
    日期:2017年11月22日
    -------------------------------------------------------------*/
    #ifndef VECTOR3D_H
    #define VECTOR3D_H
    
    #include <math.h>  
    
    class Vector3D
    {
    public:
    	Vector3D();//默认的构造函数
    	Vector3D(const double p);//将向量的三个分量都初始化为一个数
    	Vector3D(const double v[]);//以一个double型的数值初始化三维向量
    	Vector3D(const double x_,const double y_,const double z_);//以三个double型数值初始化向量三个分量
    	Vector3D(const My3DPoint &p);//用My3DPoint构造三维向量
    //	Vector3D(const My3DPointWithNormalvector &p);//用My3DPointWithNormalvector初始化三维向量
    	Vector3D(const Vector3D &a); //复制构造函数
    	~Vector3D(void);//析构函数
    	void SetVector3D(const double tempx,const double tempy,const double tempz);//设置三维向量三个方向上的坐标
    	double DotProduct(const Vector3D &other)const;//三维向量点积  
    	void CrossProduct(const Vector3D & l, const Vector3D & r);//三维向量叉积
    	Vector3D CrossProduct(const Vector3D &v)const;//三维向量叉积
    	double magnitude()const;//三个向量分量的平方和的根
    	double magnitudeSquared()const;//三个向量分量的平方和
    	void normalize();//向量归一化
    	double Distance (const Vector3D &a,const Vector3D &b);//两个向量之间的距离
    	double Distance	(const Vector3D &v)const;//两个向量之间的距离
    	void SetZero();//置为0向量
    	void Vector3DMax(const Vector3D &v);//将当前向量与v的xyz分量比较得到较大分量
    	void Vector3DMin(const Vector3D &v);//将当前向量与v的xyz分量比较得到较小分量
    	void  setNegative(const Vector3D &v);//将形参向量v取负赋值给当前向量
    	void  setNegative();//将当前向量取负
    	void  add(const Vector3D & a, const Vector3D & b);//将当前向量设置为a和b向量的和
    	void subtract(const Vector3D &a, const Vector3D &b);//将当前向量设置为a和b向量的差
    	void multiply(double s,  const Vector3D & a);//将当前向量设置为数字s与向量a的数乘
    	void  arrayMultiply(const Vector3D &a, const Vector3D &b);//将当前向量设置为向量a与向量b各个分量的乘积
    
    
    	// BOOL型操作运算符 
    	bool operator == (const Vector3D& v) const //判断两个向量是否相等
    	{ 
    		return x==v.x && y==v.y && z==v.z;
    	}  
    	bool operator != (const Vector3D& v) const //判断两个向量是否不相等
    	{ 
    		return x!=v.x || y!=v.y || z!=v.z;
    	}  
    	// 常见的运算符 
    	Vector3D& operator = (const Vector3D &v) //赋值运算
    	{
    		x=v.x;
    		y=v.y;
    		z=v.z;
    		return *this;
    	}
    	Vector3D  operator +  (const Vector3D &v) const//两个向量相加
    	{
    		return Vector3D(x+v.x, y+v.y, z+v.z); 
    	}  
    	Vector3D& operator += (const Vector3D &v) //两个向量相加
    	{ 
    		x+=v.x; y+=v.y; z+=v.z; 
    		return *this;
    	}  
    	Vector3D  operator -  () const //向量取反
    	{ 
    		return Vector3D(-x, -y, -z);
    	}  
    	Vector3D  operator -(const Vector3D &v) const //两个向量相减
    	{
    		return Vector3D(x-v.x, y-v.y, z-v.z);
    	}  
    	Vector3D& operator -= (const Vector3D &v)  //两个向量相减  
    	{ 
    		x-=v.x; y-=v.y; z-=v.z; 
    		return *this;
    	}  
    	Vector3D  operator *  (const double s) const  //向量数乘 
    	{
    		return Vector3D(x*s, y*s, z*s);
    	}  
    	Vector3D& operator *= (const double s)     //向量数乘   
    	{ 
    		x*=s; y*=s; z*=s;
    		return *this; 
    	}  
    	Vector3D  operator /  (const double s) const  //向量除以一个数
    	{ 
    		ASSERT(s);
    		return (*this)* (1/s); 
    	}  
    	Vector3D& operator /= (const double s)   //向量除以一个数
    	{ 
    		ASSERT(s); return (*this)*=(1/s);
    	}  
    	bool operator< (const Vector3D&v) const
    	{
    		if( x < v.x)	return true;
    		if( x > v.x)	return false;
    		if( y < v.y)	return true;
    		if( y > v.y)	return false;
    		if( z < v.z)	return true;
    		if( z > v.z)	return false;
    		return false;
    	}
    public:
    	double x,y,z;//xyz三个分量的大小
    };  
    
    inline Vector3D operator *(const double s,const Vector3D &v)//内联函数  向量前乘一个数
    {
    	return Vector3D(s*v.x,s*v.y,s*v.z);
    }
    #endif
    
    

     

     

     


    .cpp

     

     

     

     

    #include "StdAfx.h"
    #include "Vector3D.h"
    
    //默认构造函数
    Vector3D::Vector3D()
    {
    	
    }
    
    //将向量的三个分量都初始化为一个数
    Vector3D::Vector3D(const double p)
    {
    	x=p;
    	y=p;
    	z=p;
    }
    
    //用一个double型的数组初始化三维向量
    Vector3D::Vector3D(const double v[]):x(v[0]),y(v[1]),z(v[2])
    {
    
    }
    //三个double型的数值分别初始化x,y,z三个分量
    Vector3D::Vector3D(const double x_,const double y_,const double z_):x(x_),y(y_),z(z_)
    {
    
    }
    //复制构造函数
    Vector3D::Vector3D(const Vector3D &a){
    	x=a.x;
    	y=a.y;
    	z=a.z;
    }
    //以My3DPoint结构体作为参数构造向量
    Vector3D::Vector3D(const My3DPoint &p)
    {
    	x=p.X;
    	y=p.Y;
    	z=p.Z;
    }
    
    以My3DPointWithNormalvector结构体作为参数构造向量
    //Vector3D::Vector3D(const My3DPointWithNormalvector &p)
    //{
    //	x=p.zuobiao.X;
    //	y=p.zuobiao.Y;
    //	z=p.zuobiao.Z;
    //}
    
    //默认析构函数
    Vector3D::~Vector3D(void)
    {
    
    }
    
    //设置向量的XYZ坐标
    void Vector3D::SetVector3D(const double tempx,const double tempy,const double tempz)
    {
    	x=tempx;
    	y=tempy;
    	z=tempz;
    }
    
    //两向量的点积
    double Vector3D::DotProduct(const Vector3D &other)const
    {
    	return x*other.x + y*other.y + z*other.z;
    }
    
    //两向量的叉积
    void Vector3D::CrossProduct(const Vector3D & l, const Vector3D & r)
    {
    	double a = (l.y * r.z) - (l.z * r.y);
    	double b = (l.z * r.x) - (l.x * r.z);
    	double c = (l.x * r.y) - (l.y * r.x);
    
    	x = a;
    	y = b;
    	z = c;
    }
    Vector3D Vector3D::CrossProduct(const Vector3D &v)const
    {
    	Vector3D temp;
    	temp.CrossProduct(*this,v);
    	return temp;
    }
    
    //三个向量分量平方和的根
    double Vector3D::magnitude()const
    {
    	return sqrt(x * x + y * y + z * z);
    }
    
    //三个向量分量的平方和
    double Vector3D::magnitudeSquared()const
    {
    	return x * x + y * y + z * z;
    }
    //向量标准化
    void Vector3D::normalize()
    {
    	double m = magnitude();
    	if (m)
    	{
    		const double il =  double(1.0) / m;
    		x *= il;
    		y *= il;
    		z *= il;
    	}
    }
    
    //两个向量之间的距离
    double Vector3D::Distance (const Vector3D &a,const Vector3D &b)
    {
    	double dx = a.x - b.x;
    	double dy = a.y - b.y;
    	double dz = a.z - b.z;
    	return sqrt(dx * dx + dy * dy + dz * dz);
    }
    
    double Vector3D::Distance(const Vector3D &v)const
    {
    	Vector3D tempObject;
    	double dis;
    	dis=tempObject.Distance(*this,v);
    	return dis;
    }
    
    //将三维向量置为0向量
    void  Vector3D::SetZero()
    {
    	x=0;
    	y=0;
    	z=0;
    }
    
    //将当前向量与v的XYZ分量相比,得到较大的xyz分量
    void Vector3D::Vector3DMax(const Vector3D &v)
    {
    	x=x>v.x?x:v.x;
    	y=y>v.y?y:v.y;
    	z=z>v.z?z:v.z;
    }
    
    //将当前向量与v的XYZ分量相比,得到较大的xyz分量
    void Vector3D::Vector3DMin(const Vector3D &v)
    {
    	x=x<v.x?x:v.x;
    	y=y<v.y?y:v.y;
    	z=z<v.z?z:v.z;
    }
    
    //将形参向量v取负赋值给当前向量
    void  Vector3D::setNegative(const Vector3D &v)
    {
    	x = -v.x;
    	y = -v.y;
    	z = -v.z;
    }
    //将当前向量取负
    void  Vector3D::setNegative()
    {
    	x = -x;
    	y = -y;
    	z = -z;
    }
    //将当前向量设置为a和b向量的和
    void  Vector3D::add(const Vector3D & a, const Vector3D & b)
    {
    	x = a.x + b.x;
    	y = a.y + b.y;
    	z = a.z + b.z;
    }
    
    //将当前向量设置为a和b向量的差
    void Vector3D::subtract(const Vector3D &a, const Vector3D &b)
    {
    	x = a.x - b.x;
    	y = a.y - b.y;
    	z = a.z - b.z;
    }
    
    //将当前向量设置为数字s与向量a的数乘
    void Vector3D::multiply(double s,  const Vector3D & a)
    {
    	x = a.x * s;
    	y = a.y * s;
    	z = a.z * s;
    }
    
    //将当前向量设置为向量a与向量b各个分量的乘积
    void  Vector3D::arrayMultiply(const Vector3D &a, const Vector3D &b)
    {
    	x = a.x * b.x;
    	y = a.y * b.y;
    	z = a.z * b.y;
    }

     

     

     


    (3) 自己封装的二维向量类Vector2D

     

     

     

    .h

     

    //#pragma once
    /*------Vector2D---------------------------------------------
    类作用:二维向量类,提供向量的基本运算
    作者:HuangWang
    日期:2017年11月22日
    -------------------------------------------------------------*/
    #ifndef VECTOR2D_H
    #define VECTOR2D_H
    
    #include <math.h>  
    
    class Vector2D
    {
    public:
    	Vector2D();
    	Vector2D(const double p);//将向量的两个分量都初始化为一个数
    	Vector2D(const double v[]);//以一个double型的数组初始化二维向量
    	Vector2D(const double x_,const double y_);//分别以X方向的数和Y方向的数创建一个的向量
    	Vector2D(const My2DPoint &p);//用My2DPoint构造二维向量
    	Vector2D(const Vector2D &a); //复制构造函数
    	~Vector2D(void);//析构函数
    	void SetVector2D(const double tempx,const double tempy);//设置二维向量两个方向上的坐标
    	double DotProduct(const Vector2D &other)const;//二维向量点积  
    	double CrossProduct(const Vector2D &v)const;//二维向量叉积
    	double magnitude()const;//两个向量分量的平方和的根
    	double magnitudeSquared()const;//两个个向量分量的平方和
    	void normalize();//向量归一化
    	double Distance (const Vector2D &a,const Vector2D &b);//两个向量之间的距离
    	double Distance	(const Vector2D &v)const;//两个向量之间的距离
    	void SetZero();//置为0向量
    	void Vector2DMax(const Vector2D &v);//将当前向量与v的xy分量比较得到较大分量
    	void Vector2DMin(const Vector2D &v);//将当前向量与v的xy分量比较得到较小分量
    	void  setNegative(const Vector2D &v);//将形参向量v取负赋值给当前向量
    	void  setNegative();//将当前向量取负
    	void  add(const Vector2D & a, const Vector2D & b);//将当前向量设置为a和b向量的和
    	void subtract(const Vector2D &a, const Vector2D &b);//将当前向量设置为a和b向量的差
    	void multiply(double s,  const Vector2D & a);//将当前向量设置为数字s与向量a的数乘
    	void  arrayMultiply(const Vector2D &a, const Vector2D &b);//将当前向量设置为向量a与向量b各个分量的乘积
    
    
    	// BOOL型操作运算符 
    	bool operator == (const Vector2D& v) const //判断两个向量是否相等
    	{ 
    		return x==v.x && y==v.y;
    	}  
    	bool operator != (const Vector2D& v) const //判断两个向量是否不相等
    	{ 
    		return x!=v.x || y!=v.y;
    	}  
    	// 常见的运算符  
    	Vector2D& operator = (const Vector2D &v) //赋值运算
    	{
    		x=v.x;
    		y=v.y;
    		return *this;
    	}
    	Vector2D  operator +  (const Vector2D &v) const//两个向量相加
    	{
    		return Vector2D(x+v.x, y+v.y); 
    	}  
    	Vector2D& operator += (const Vector2D &v) //两个向量相加
    	{ 
    		x+=v.x; y+=v.y; 
    		return *this;
    	}  
    	Vector2D  operator -  () const //向量取负
    	{ 
    		return Vector2D(-x, -y);
    	}  
    	Vector2D  operator -(const Vector2D &v) const //两个向量相减
    	{
    		return Vector2D(x-v.x, y-v.y);
    	}  
    	Vector2D& operator -= (const Vector2D &v)  //两个向量相减  
    	{ 
    		x-=v.x; y-=v.y; 
    		return *this;
    	}  
    	Vector2D  operator *  (const double s) const  //向量数乘 后乘一个数
    	{
    		return Vector2D(x*s, y*s);
    	}  
    
    	Vector2D& operator *= (const double s)     //向量数乘  后乘一个数
    	{ 
    		x*=s; y*=s;
    		return *this; 
    	}  
    	Vector2D  operator /  (const double s) const  //向量除以一个数
    	{ 
    		ASSERT(s);
    		return (*this)* (1/s); 
    	}  
    	Vector2D& operator /= (const double s)   //向量除以一个数
    	{ 
    		ASSERT(s); return (*this)*=(1/s);
    	}  
    	bool operator< (const Vector2D&v) const
    	{
    		if( x < v.x)	return true;
    		if( x > v.x)	return false;
    		if( y < v.y)	return true;
    		if( y > v.y)	return false;
    		return false;
    	}
    public:
    	double x,y;//xy两个分量的大小
    };  
    
    inline Vector2D operator *(const double s,const Vector2D &v)//内联函数  向量前乘一个数
    {
    	return Vector2D(s*v.x,s*v.y);
    }
    #endif
    
    

     

     

     


    .cpp

     

     

     

     

    #include "StdAfx.h"
    #include "Vector2D.h"
    
    //默认构造函数
    Vector2D::Vector2D()
    {
    
    }
    
    //将向量的两个分量都初始化为一个数
    Vector2D::Vector2D(const double p)
    {
    	x=p;
    	y=p;
    }
    //以一个double型的数组初始化二维向量
    Vector2D::Vector2D(const double v[]):x(v[0]),y(v[1])
    {
    
    }
    //分别以两个double型的数值初始化向量的两个分量
    Vector2D::Vector2D(const double x_,const double y_):x(x_),y(y_)
    {
    
    }
    //复制构造函数
    Vector2D::Vector2D(const Vector2D &a){
    	x=a.x;
    	y=a.y;
    }
    //以My2DPoint结构体作为参数构造向量
    Vector2D::Vector2D(const My2DPoint &p)
    {
    	x=p.X;
    	y=p.Y;
    }
    
    //默认析构函数
    Vector2D::~Vector2D(void)
    {
    
    }
    
    //设置向量的XYZ坐标
    void Vector2D::SetVector2D(const double tempx,const double tempy)
    {
    	x=tempx;
    	y=tempy;
    }
    
    //两向量的点积
    double Vector2D::DotProduct(const Vector2D &other)const
    {
    	return x*other.x + y*other.y;
    }
    
    
    double Vector2D::CrossProduct(const Vector2D &v)const
    {
    	return x*v.y-y*v.x;
    }
    
    //三个向量分量平方和的根
    double Vector2D::magnitude()const
    {
    	return sqrt(x * x + y * y);
    }
    
    //三个向量分量的平方和
    double Vector2D::magnitudeSquared()const
    {
    	return x * x + y * y;
    }
    //向量标准化
    void Vector2D::normalize()
    {
    	double m = magnitude();
    	if (m)
    	{
    		const double il =  double(1.0) / m;
    		x *= il;
    		y *= il;
    	}
    }
    
    //两个向量之间的距离
    double Vector2D::Distance (const Vector2D &a,const Vector2D &b)
    {
    	double dx = a.x - b.x;
    	double dy = a.y - b.y;
    	return sqrt(dx * dx + dy * dy );
    }
    
    double Vector2D::Distance(const Vector2D &v)const
    {
    	Vector2D tempObject;
    	double dis;
    	dis=tempObject.Distance(*this,v);
    	return dis;
    }
    
    //将三维向量置为0向量
    void  Vector2D::SetZero()
    {
    	x=0;
    	y=0;
    }
    
    //将当前向量与v的XY分量相比,得到较大的xy分量
    void Vector2D::Vector2DMax(const Vector2D &v)
    {
    	x=x>v.x?x:v.x;
    	y=y>v.y?y:v.y;
    }
    
    //将当前向量与v的XY分量相比,得到较小的xy分量
    void Vector2D::Vector2DMin(const Vector2D &v)
    {
    	x=x<v.x?x:v.x;
    	y=y<v.y?y:v.y;
    }
    
    //将形参向量v取负赋值给当前向量
    void  Vector2D::setNegative(const Vector2D &v)
    {
    	x = -v.x;
    	y = -v.y;
    }
    //将当前向量取负
    void  Vector2D::setNegative()
    {
    	x = -x;
    	y = -y;
    }
    //将当前向量设置为a和b向量的和
    void  Vector2D::add(const Vector2D & a, const Vector2D & b)
    {
    	x = a.x + b.x;
    	y = a.y + b.y;
    }
    
    //将当前向量设置为a和b向量的差
    void Vector2D::subtract(const Vector2D &a, const Vector2D &b)
    {
    	x = a.x - b.x;
    	y = a.y - b.y;
    }
    
    //将当前向量设置为数字s与向量a的数乘
    void Vector2D::multiply(double s,  const Vector2D & a)
    {
    	x = a.x * s;
    	y = a.y * s;
    }
    
    //将当前向量设置为向量a与向量b各个分量的乘积
    void  Vector2D::arrayMultiply(const Vector2D &a, const Vector2D &b)
    {
    	x = a.x * b.x;
    	y = a.y * b.y;
    }

    如果您觉得这篇博文有用,请访问我的个人站:http://www.stubbornhuang.com,更多博文干货等着您。

     

     

     

     

     

     

    展开全文
  • 2. 编写代码,实现二维向量和三维向量的运算: 1) 遵循软件开发标准,程序分文件书写; 2) 可以进行向量的加减和比较运算(重载+,-,=和==运算符)。 3) 分别用静态链接和共享链接的方式测试向量的使用。 3. 创建包含...
  • 利用克莱姆法则实现三维空间中平面的法向量计算 取平面上三点分别为: P1(x1y1z1) P2(x2y2z2) P3(x3y3z3)求解设法向量(dxdydz)
  • 用matlab绘制二维或者三维向量直线(带箭头)
  • 使用C++开发的一个三维空间向量的实现,支持基础的加、减、叉乘、点乘运算可以计算模长、向量夹角等,已经满足笔者的需求。 理论基础:https://go.lucoder.com/fwlink/?linkid=8
  • 3D三维向量单位化、正规化、标准化推导及代码实现 可以用来法向量等向量的单位

    3D三维向量的单位化、正规化、标准化推导及代码实现


    可以用来法向量等向量的单位化


    展开全文
  • 在Python脚本语言中如何实现三维向量的加减,点乘,叉乘的运算呢? 本例子将给大家介绍在类中调用函数的方法解决这个问题
  • 三维向量叉乘推导

    万次阅读 2013-05-09 00:49:00
    三维向量叉乘推导 一直以来,我都记不住向量叉乘的结果,每次都要查询。其根本原因在于,我没有去研究过叉乘是如何推导出来的。于是,这次想彻底解决一下。首先要感谢维基百科,它已经把所有问题都...

    三维向量叉乘推导

    一直以来,我都记不住向量叉乘的结果,每次都要查询。其根本原因在于,我没有去研究过叉乘是如何推导出来的。于是,这次想彻底解决一下。首先要感谢维基百科,它已经把所有问题都描述清楚了。

    http://en.wikipedia.org/wiki/Cross_product

     

    而下面的文字,只是我的读书笔记,以加深自己的印象。

     

    首先我们知道 ,对于向量u和v, u x v的结果,是得到一个既垂直于u又垂直于v的向量,假设记作n.

    则有下面公式

    n = u x v;

    而n的方向,是由右手法则决定的。 即伸出右手,四个手指方向从u绕到v. 此时,大姆指的方向,就是n的方向。 我们通常叫做右向量。

    引用一下维基百科的图来说明问题,有兴趣的兄弟可以照图比划一下。 (注:图中向量是用的a x b来表示)

    image

     

    有了上面的知识,我们继续向下看。

    我们假设向量 u,v,n分别用三个标量来表示。即

    u = (Xu,Yu,Zu)

    v = (Xv,Yv,Zv)

    n = (Xn,Yn,Zn)

    则,它们的关系为

    Xn = Yu*Zv – Zu*Yv;

    Yn = Zu*Xv – Xu*Zv;

    Zn = Xu*Yv – Yu*Xv;

    即 n = (Yu*Zv – Zu*Yv,Zu*Xv – Xu*Zv,Xu*Yv – Yu*Xv);

    而为了验证n与u和v的垂直性,可以使用点乘进行

    点乘法则比这个简单多了, u*v = (Xu*Xv + Yu*Yv + Zu*Zv) = dotUV;

    如果两个向量垂直,则dotUV = 0;

    代入验证一把

    u*n = (Xu*(Yu*Zv – Zu*Yv) + Yu*(Zu*Xv – Xu*Zv) + Zu*(Xu*Yv – Yu*Xv));

          = Xu*Yu*Zv – Xu*Zu*Yv + Yu*Zu*Xv – Yu*Xu*Zv + Zu*Xu*Yv – Zu*Yu*Xv;

    把正负号的因式仔细比对一下,发现刚好可以低消。 结果为0.

    v*n 同理可证。

    于是,也验证了n与u,v垂直的特性。

     

     

    如果只是为了应用的话,走到这一步就可以停下了。后面的知识,只是为了满足一下好奇心。

    那我们就来看看,这个结论是怎么来的呢? 我们接着来推导。

    为了更好地推导,我们需要加入三个轴对齐的单位向量。

    i,j,k.

    i,j,k满足以下特点

    i = j x k; j = k x i; k = i x j;

    k x j = –i; i x k = –j; j x i = –k;

    i x i = j x j = k x k = 0; (0是指0向量)

    由此可知,i,j,k是三个相互垂直的向量。它们刚好可以构成一个坐标系。

    这三个向量的特例就是 i = (1,0,0) j = (0,1,0) k = (0,0,1)。

     

    好,那对于处于i,j,k构成的坐标系中的向量u,v我们可以如下表示

    u = Xu*i + Yu*j + Zu*k;

    v = Xv*i + Yv*j + Zv*k;

     

    那么 u x v = (Xu*i + Yu*j + Zu*k) x (Xv*i + Yv*j + Zv*k)

                   = Xu*Xv*(ixi) + Xu*Yv*(i x j) + Xu*Zv*(i x k) + Yu*Xv*(j x i) + Yu*Yv*(j x j) + Yu*Zv*(j x k) + Zu*Xv*( k x i ) + Zu*Yv(k x j) + Zu*Zv(k x k)

    由于上面的i,j,k三个向量的特点,所以,最后的结果可以简化为

    u x v = (Yu*Zv – Zu*Yv)*i + (Zu*Xv – Xu*Zv)j + (Xu*Yv – Yu*Xv)k;

    于是,在i,j,k构成的坐标系中。集就是上面的结果。

    当i = (1,0,0) j = (0,1,0) k = (0,0,1)时,我们通常省略i,j,k的写法。最终也就得到了我们的右向量。

     

    叉乘的意义

      叉乘表示垂直于uxv的右向量。

    使用的地方

      可以通过叉乘,修正向量关系,从而构建坐标系。 常见的有 摄相机矩阵和TBN空间转换矩阵的构建。

     

     

    叉乘的矩阵表示法。

     

    很多书上,包括 3D游戏大师编程技巧 上面,都是用的矩阵表示法来说明叉乘。

    如下。

    image

    它对应的矩阵表示法为

    image

    求其代数余子式,可以表示为如下

    image

    有了这个,那我们合并公因式i,j,k,则可以得到矩阵表示法

    image

     

    到此,叉乘的内容基本OK了。 值得说明的是,如果对方程组表示成矩阵不熟悉,就会感到不习惯,但是如果多多练习,我想应该是会习惯成自然吧。。。

    posted @ 2013-05-09 00:49 麒麟子(Alex) 阅读( ...) 评论( ...) 编辑 收藏
    展开全文
  • Vector3 三维向量

    千次阅读 2016-10-15 11:09:28
    Vector3 三维向量 Struct Representation of 3D vectors and points. 表示3D的向量和点。 This structure is used throughout Unity to pass 3D positions and directions around. It also contains ...

    Vector3 三维向量

    Struct

    Representation of 3D vectors and points.

    表示3D的向量和点。

    This structure is used throughout Unity to pass 3D positions and directions around. It also contains functions for doing common vector operations.

    这个结构用于在Unity传递3D位置和方向。它也包含做些普通向量运算的函数。

    Besides the functions listed below, other classes can be used to manipulate vectors and points as well. For example the Quaternion and the Matrix4x4 classes are useful for rotating or transforming vectors and points.

    除了下面列出的函数,其他类用于处理向量和点。例如QuaternionMatrix4x4类用于旋转或变换向量和点。

    Variables变量

    • x
      X component of the vector.
      向量的X组件。
    • y
      Y component of the vector.
      向量的Y组件。
    • z
      Z component of the vector.
      向量的Z组件。
    • Access the x, y, z components using [0], [1], [2] respectively.
      使用[0], [1], [2]分别访问组件x, y, z组件。简单来说就是用索引号代替x, y, z组件。
    • Returns this vector with a magnitude of 1 (Read Only).
      返回向量的长度为1(只读)。
    • Returns the length of this vector (Read Only).
      返回向量的长度(只读)。
    • Returns the squared length of this vector (Read Only).
      返回这个向量的长度的平方(只读)。

    Constructors构造器

    • Creates a new vector with given x, y, z components.
      创建一个新的具有给定x, y, z组件的向量。

    Functions函数

    • Multiplies every component of this vector by the same component of scale.
      由缩放的相同的组件对应乘以这个矢量的每个组件。
    • Makes this vector have a magnitude of 1.
      使向量的长度为1。
    • Returns a nicely formatted string for this vector.
      返回此向量格式化的字符串。

    Class Variables类变量

    Class Functions类函数

    • Linearly interpolates between two vectors.
      两个向量之间的线性插值。
    • Spherically interpolates between two vectors.
      球形插值在两个向量之间。
    • Makes vectors normalized and orthogonal to each other.
      使向量规范化并且彼此相互垂直。
    • Moves a point current towards target.
      当前的地点移向目标。
    • Rotates a vector current towards target.
      当前的向量转向目标。
    • Gradually changes a vector towards a desired goal over time.
      随着时间的推移,逐渐改变一个向量朝向预期的目标。
    • Multiplies two vectors component-wise.
      两个矢量组件对应相乘。
    • Cross Product of two vectors.
      两个向量的交叉乘积。返回lhs x rhs
    • Reflects the vector along the normal.
      沿着法线反射向量。
    • Dot
      Dot Product of two vectors.
      两个向量的点乘积。
    • Projects a vector onto another vector.
      投影一个向量到另一个向量。
    • Returns the angle in degrees between from and to.
      由from和to两者返回一个角度。
    • Returns the distance between a and b.
      返回a和b之间的距离。
    • Returns a copy of vector with its magnitude clamped to maxLength.
      返回向量的长度,最大不超过maxLength所指示的长度。
    • Min
      Returns a vector that is made from the smallest components of two vectors.
      返回一个由两个向量的最小组件组成的向量。
    • Max
      Returns a vector that is made from the largest components of two vectors.
      返回一个由两个向量的最大组件组成的向量。
    • Adds two vectors.
      两个向量相加。
    • Subtracts one vector from another.
      一个向量减另一个向量。
    • Multiplies a vector by a number.
      由一个数乘以一个向量。
    • Divides a vector by a number.
      由一个数除一个向量。也就是a/b。
    • Returns true if the vectors are equal.
      如果两个向量相等,返回真。
    • Returns true if vectors different.
      如果向量不同返回真。
    展开全文
  • 三维向量场图绘制

    千次阅读 2018-12-12 20:16:55
    %例三:三维向量场图绘制 %本例是绘制三维参数曲线的很好的例子 vz = 10; % Velocity a = -32; % Acceleration t = 0:.1:pi/2; x = 2*cos(t);y = 3*sin(t); z = vz*t + 1/2*a*t.^2; plot3...
  • 演示了Python创建类的方法,定义了基本的四则运算函数,并利用unittest单元测试模块进行验证。
  • 四元数与三维向量相乘运算法则

    千次阅读 2020-09-04 10:15:57
    四元数与三维向量相乘运算法则 参考网站: https://www.cnblogs.com/jeason1997/p/9822353.html 四元数和向量相乘可以表示这个向量按照这个四元数进行旋转之后得到的新的向量。 例如:向量 c(0,0,10) 绕着Y轴旋转90...
  • 这是一个非常简单的程序,它实现了罗德里格斯的旋转公式。 输入是要绕指定轴旋转指定角度的三维向量或行向量的数组。 输出是与输入数组具有相同维度的旋转向量数组。
  • 3D数学 自定义三维向量类进行运算

    千次阅读 2015-07-15 19:33:31
    3D数学 自定义向量类进行运算设计一个3维向量类,可以实现如下运算: 零向量 负向量 向量大小、长度、模 标量与向量的乘除法 单位向量 向量的加法和减法 距离公式 向量点乘 向量叉乘 由于原理很简单,所以不解释,...
  • Meshlab是一个强大的三维模型处理的软件,在三维点云的处理方面也十分强大,不仅仅可以用三维点云重构出三维模型,还可以计算出三维点云每个点的法向量,这在逆向工程和基于三维点云的隐式曲面重建中非常有用。...
  • Vector - 三维向量

    千次阅读 2016-12-26 20:55:21
    Vector中封装的属性Vector常用的方法代码实例using UnityEngine;...public class Test : MonoBehaviour { // Vector3 就是一个类,表示向量向量既有大小又有方向的量 void Start () { Vector3 v = new Vector3();
  • 三维向量

    千次阅读 2011-01-10 15:19:00
    介绍了一个自定义向量
  • 一个简单的三维向量

    千次阅读 2010-11-30 23:26:00
    《3D数学基础:图形与游戏开发》中的一个三维向量类,自己做了一些小修改。
  • 向量的叉乘即3D中任意两个三维向量的叉乘(向量积)推导及代码实现
  • 求两个三维向量的夹角(带正负)

    千次阅读 2020-08-04 16:08:37
    1、数学上,两个三维向量是没有正负的。但是从公垂线的角度来看,可以有方向性。参考如下: 三维空间中两个向量会有一条公垂线(向量叉乘可以求得),以公垂线为轴,将第二个向量旋转一个角度,使其与第一个向量平行.这个...
  • 实现三维向量之间的加法与减法

    千次阅读 2020-06-07 16:52:58
    实现三维向量之间的加法与减法的功能。 ####相关知识 在 Python 面向对象编程中,类的特殊方法在形式上是前后各有 2 个下划线,作用是实现与某个运算符或内置函数的对应关系。例如,如果某个类实现了__len__()这个...
  • 两个三维向量的夹角计算

    万次阅读 2018-05-29 15:47:33
    两个向量的夹角计算公式:θ=acos(v1⋅v2/||v1||||v2||)需要注意的θ的范围再0~pi之间,怎么解决0~2pi的问题呢?这里就需要用到向量的叉乘,根据叉乘后的向量与屏幕方向来确定角度是否超过180°。代码如下:float ...
  • 计算几何,三维向量的旋转

    万次阅读 2012-07-14 09:53:54
    二来是对于三维向量绕任意轴的旋转之前我都是用结论的,今天因为做计算机图形学的作业去推导了一下,发现计算量相当大,算了我一个早上,故特以此日志留念。 言归正传,首先我们讨论二维向量的旋转。 对于一个向量...
  • 在三维空间中,两个向量的乘积(向量积,外积,乘积,区别于两个向量的数乘:内积,点积)表示两个向量的...1)3个或者N>3个三维向量相乘如何定义?A×B×C×D....因为A×B是有定义的,A×B是向量,那么只要继续乘就可
  • c++实现三维向量的操作

    千次阅读 2017-05-22 21:57:44
    实现一个三维矢量库,要求 1 计算矢量的模长,夹角,内积和外积 2比较矢量的大小,重载==、!=、&gt;=、&lt;=、&lt;、&gt; 3实现矢量与数值的加减乘除 4实现矢量之间的加减 5包含拷贝构造函数和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 166,520
精华内容 66,608
关键字:

三维向量的单位向量