3D數學矩陣和線性變換之切變

阿新 • • 發佈：2018-12-30

矩陣和線性變換之切變

1. 什麼是切變？

我們來看一幅圖片。下面的圖片，隨著y增大，x的偏移會越來越大。這種型別的變換就叫切換。我們可以得到下圖的公式x’ = x + sy。該公式轉換成矩陣就得到了切變矩陣。

2. 切變效果的矩陣是怎樣的？

在3D中，同樣的道理，有如下右邊三個矩陣，分別是隨著z增大，x和y發生切變。隨著y增大，x和z發生切變。隨著z增大，x和y發生切變。

3. 切變矩陣示例程式碼

void Matrix3X3::setShear(E_Axis axis, float s, float t)
{
    switch(axis)
    {
    case 
 Axis_x:
        {
            m11 = 1;    m12 = s;    m13 = t;
            m21 = 0;    m22 = 1;    m23 = 0;
            m31 = 0;    m32 = 0;    m33 = 1;
            break;
        }
    case Axis_y:
        {
            m11 = 1;    m12 = 0;    m13 = 0;
            m21 = s;    m22 = 1;    m23 = t;
            m31 = 0 
;    m32 = 0;    m33 = 1;
            break;
        }
    case  Axis_z:
        {
            m11 = 1;    m12 = 0;    m13 = 0;
            m21 = 0;    m22 = 1;    m23 = 0;
            m31 = s;    m32 = t;    m33 = 1;
            break;
        }
    }
}

4. 切變矩陣程式完整示例程式碼

//MathUtil.h

#pragma once

#include <math.h> 


enum E_Axis{Axis_x,Axis_y,Axis_z};
const float Pi = 3.14159f;

//Vector3.h

#pragma once

class Vector3{
public:
    Vector3();
    Vector3(float X,float Y,float Z);

    //變為零向量
    void Zero();
    //求負向量
    Vector3 operator-() const;
    //求向量大小（長度或模）
    float Length() const;
    //標準化該向量
    void Normal();
    //向量的加法
    Vector3 operator+(Vector3 &rhs) const;
    Vector3& operator+=(Vector3 &rhs);
    //向量的減法
    Vector3 operator-(Vector3 &rhs) const;
    Vector3& operator-=(Vector3 &rhs);
    //向量乘標量
    Vector3 operator*(float scalar);
    //向量乘等於標量
    Vector3& operator*=(float scalar);
    //向量除以等於標量
    Vector3& operator/=(float scalar);
    //向量除以標量
    Vector3 operator/(float scalar);
    //距離公式
    float Distance(Vector3 &vec) const;
    //向量點乘
    float operator*(Vector3 &rhs) const;
    //向量叉積
    Vector3 CrossProduct(Vector3& vec) const;


public:
    float x,y,z;

};



//標量乘向量
Vector3 operator*(float scalar, Vector3& vec);

//Vector3.cpp

#include "Vector3.h"
#include <cmath>

Vector3::Vector3():x(0.0),y(0.0),z(0.0)
{

}

Vector3::Vector3(float X,float Y,float Z):x(X),y(Y),z(Z)
{

}

void Vector3::Zero()
{
    x = y = z = 0;
}

Vector3 Vector3::operator-() const
{
    return Vector3(-x,-y,-z);
}

float Vector3::Length() const
{
    return sqrt(x*x+y*y+z*z);
}

Vector3 Vector3::operator*(float scalar)
{
    return Vector3(this->x * scalar, this->y * scalar, this->z * scalar);
}

Vector3& Vector3::operator*=(float scalar)
{
    return *this = *this * scalar;
}

Vector3& Vector3::operator/=(float scalar)
{
    return *this = *this / scalar;
}

Vector3 operator*(float scalar, Vector3& vec)
{
    return vec*scalar;
}

Vector3 Vector3::operator/(float scalar)
{
    float temp = 1/ scalar;
    return *this * temp;
}

void Vector3::Normal()
{
    //計算機計算乘法的速度比除法快
    float temp = 1 / Length();
    x *= temp;
    y *= temp;
    z *= temp;
}

Vector3 Vector3::operator+(Vector3& rhs) const
{
    return Vector3(x+rhs.x,y+rhs.y,z+rhs.z);
}

Vector3& Vector3::operator+=(Vector3& rhs)
{
    *this = *this + rhs;
    return *this;
}

Vector3 Vector3::operator-(Vector3& rhs) const
{
    return Vector3(x-rhs.x,y-rhs.y,z-rhs.z);
}

Vector3& Vector3::operator-=(Vector3& rhs)
{
    *this = *this - rhs;
    return *this;
}

float Vector3::Distance(Vector3& vec) const
{
    return (*this - vec).Length();
}

float Vector3::operator*(Vector3& rhs) const
{
    return this->x * rhs.x + this->y * rhs.y + this->z * rhs.z;
}

Vector3 Vector3::CrossProduct(Vector3& vec) const
{
    return Vector3(this->y * vec.z - this->z * vec.y,
        this->z * vec.x - this->x * vec.z,
        this->x * vec.y - this->y * vec.x);
}

//Matrix3X3.h

#pragma once
#include "MathUtil.h"
#include "Vector3.h"


class Matrix3X3
{
public:
    //矩陣相乘
    Matrix3X3 operator*(Matrix3X3& rhs);
    //矩陣乘等矩陣
    Matrix3X3& operator*=(Matrix3X3& rhs);
    void setRotate(E_Axis axis,float theta);
    void setScale(Vector3 &vec);
    void setOrthProject(Vector3 &vec);
    void setReflect(E_Axis axis);
    void setReflect(Vector3 &vec);
    void setShear(E_Axis axis, float s, float t);
public:
    float m11,m12,m13;
    float m21,m22,m23;
    float m31,m32,m33;
};

//向量乘以矩陣
Vector3 operator*(Vector3& vec,Matrix3X3& mat);
//向量乘等矩陣
Vector3& operator*=(Vector3& vec,Matrix3X3& mat);

//Matrix3X3.cpp

#include "Matrix3X3.h"
#include <assert.h>

Matrix3X3 Matrix3X3::operator*(Matrix3X3& rhs)
{
    Matrix3X3 tempMat;
    tempMat.m11 = this->m11 * rhs.m11 + this->m12 * rhs.m21 + this->m13 * rhs.m31;
    tempMat.m12 = this->m11 * rhs.m12 + this->m12 * rhs.m22 + this->m13 * rhs.m32;
    tempMat.m13 = this->m11 * rhs.m13 + this->m12 * rhs.m23 + this->m13 * rhs.m33;

    tempMat.m21 = this->m21 * rhs.m11 + this->m22 * rhs.m21 + this->m23 * rhs.m31;
    tempMat.m22 = this->m21 * rhs.m12 + this->m22 * rhs.m22 + this->m23 * rhs.m32;
    tempMat.m23 = this->m21 * rhs.m13 + this->m22 * rhs.m23 + this->m23 * rhs.m33;

    tempMat.m31 = this->m31 * rhs.m11 + this->m32 * rhs.m21 + this->m33 * rhs.m31;
    tempMat.m32 = this->m31 * rhs.m12 + this->m32 * rhs.m22 + this->m33 * rhs.m32;
    tempMat.m33 = this->m31 * rhs.m13 + this->m32 * rhs.m23 + this->m33 * rhs.m33;

    return tempMat;
}

Matrix3X3& Matrix3X3::operator*=(Matrix3X3& rhs)
{
    *this = *this * rhs;
    return *this;
}

Vector3 operator*(Vector3& vec,Matrix3X3& mat)
{
    Vector3 tempVec;
    tempVec.x = vec.x * mat.m11 + vec.y * mat.m21 + vec.z * mat.m31;
    tempVec.y = vec.x * mat.m12 + vec.y * mat.m22 + vec.z * mat.m32;
    tempVec.z = vec.x * mat.m13 + vec.y * mat.m23 + vec.z * mat.m33;
    return tempVec;
}

Vector3& operator*=(Vector3& vec,Matrix3X3& mat)
{
    vec = vec * mat;
    return vec;
}

void Matrix3X3::setRotate(E_Axis axis,float theta)
{
    float sinValue,cosValue;
    sinValue = sin(theta);
    cosValue = cos(theta);

    switch(axis)
    {
    case Axis_x:
        {
            m11 = 1;    m12 = 0;            m13 = 0;
            m21 = 0;    m22 = cosValue;     m23 = sinValue;
            m31 = 0;    m32 = -sinValue;    m33 = cosValue;
            break;
        }
    case Axis_y:
        {
            m11 = cosValue; m12 = 0;    m13 = -sinValue;
            m21 = 0;        m22 = 1;    m23 = 0;
            m31 = sinValue; m32 = 0;    m33 = cosValue;
            break;
        }
    case Axis_z:
        {
            m11 = cosValue;     m12 = sinValue; m13 = 0;
            m21 = -sinValue;    m22 = cosValue; m23 = 0;
            m31 = 0;            m32 = 0;        m33 = 1;
            break;
        }
    default:
        assert(false);
    }


}

void Matrix3X3::setScale(Vector3& vec)
{
    m11 = vec.x;    m12 = 0;        m13 = 0;
    m21 = 0;        m22 = vec.y;    m23 = 0;
    m31 = 0;        m32 = 0;        m33 = vec.z;
}

void Matrix3X3::setOrthProject(Vector3 &vec)
{
    assert(fabs(vec*vec) - 1 < 0.01f);
    m11 = 1 - vec.x*vec.x;
    m12 = m21 = -vec.x * vec.y;
    m13 = m31 = -vec.x * vec.z;

    m22 = 1 - vec.y * vec.y;
    m23 = m32 = -vec.y * vec.z;

    m33 = 1 -  vec.z * vec.z;

}

void Matrix3X3::setReflect(E_Axis axis)
{
    switch(axis)
    {
    case Axis_x:
        {
            m11 = -1; m12 = 0; m13 = 0;
            m21 = 0; m22 = 1; m23 = 0;
            m31 = 0; m32 = 0; m33 = 1;
            break;
        }
    case Axis_y:
        {
            m11 = 1; m12 = 0; m13 = 0;
            m21 = 0; m22 = -1; m23 = 0;
            m31 = 0; m32 = 0; m33 = 1;
            break;
        }
    case Axis_z:
        {
            m11 = 1; m12 = 0; m13 = 0;
            m21 = 0; m22 = 1; m23 = 0;
            m31 = 0; m32 = 0; m33 = -1;
            break;
        }
    }
}

void Matrix3X3::setReflect(Vector3 &vec)
{
    assert(fabs(vec*vec) - 1 < 0.01f);

    m11 = 1 - 2 * vec.x * vec.x;
    m12 = m21 = - 2 * vec.x * vec.y;
    m13 = m13 = -2 * vec.x * vec.z;
    m22 = 1 - 2 * vec.y * vec.y;
    m23 = m32 = -2 * vec.y * vec.z;
    m33 = 1 - 2 * vec.z * vec.z;
}

void Matrix3X3::setShear(E_Axis axis, float s, float t)
{
    switch(axis)
    {
    case Axis_x:
        {
            m11 = 1;    m12 = s;    m13 = t;
            m21 = 0;    m22 = 1;    m23 = 0;
            m31 = 0;    m32 = 0;    m33 = 1;
            break;
        }
    case Axis_y:
        {
            m11 = 1;    m12 = 0;    m13 = 0;
            m21 = s;    m22 = 1;    m23 = t;
            m31 = 0;    m32 = 0;    m33 = 1;
            break;
        }
    case  Axis_z:
        {
            m11 = 1;    m12 = 0;    m13 = 0;
            m21 = 0;    m22 = 1;    m23 = 0;
            m31 = s;    m32 = t;    m33 = 1;
            break;
        }
    }
}


#include <iostream>
#include "Vector3.h"
#include "Matrix3X3.h"

using namespace std;

float ToZero(float num)
{
    return (abs(num) < 0.0001 ? 0 : num);
}

void print_v(Vector3 v)
{
    cout << "[ " << ToZero(v.x) << ", " 
        << ToZero(v.y) << ", " 
        << ToZero(v.z) << " ]" << endl;
    cout << endl;
}

void print_m(Matrix3X3 m)
{
    cout << m.m11 << "\t" << m.m12 << "\t" << m.m13 << endl;
    cout << m.m21 << "\t" << m.m22 << "\t" << m.m23 << endl;
    cout << m.m31 << "\t" << m.m32 << "\t" << m.m33 << endl;
    cout << endl;
}

int main()
{
    Vector3 a(10,20,30),b;
    Matrix3X3 M;
    M.setShear(Axis_x,1,2);
    print_m(M);

    print_v(a);
    b = a * M;
    print_v(b);

    system("pause");
    return 0;
}

5. 程式執行結果

1       1       2
0       1       0
0       0       1

[ 10, 20, 30 ]

[ 10, 30, 50 ]

3D數學矩陣和線性變換之切變

矩陣和線性變換之切變 1. 什麼是切變？我們來看一幅圖片。下面的圖片，隨著y增大，x的偏移會越來越大。這種型別的變換就叫切換。我們可以得到下圖的公式x’ = x + sy。該公式轉換成矩陣就得到了切變矩陣。 2. 切變效果的矩陣是

3D數學 ---- 矩陣和線性變換（1）

包含平移的線性變換稱作仿射變換，3D中的仿射變換不能用 3 x 3 矩陣表達，必須使用4 x 4矩陣。一般來說，變換物體相當於以相反的量變換描述這個物體的座標系。當有多個變換時，則需要以相反的順序變換相反的量。例如，將物體順時針旋轉20度，擴大200%，等價於將座標系縮小2

3D數學 ---- 矩陣和線性變換

一般來說，方陣能描述任意線性變換。線性變換保留了直線和平行線，但原點沒有移動。線性變換保留直線的同時，其他的幾何性質如長度、角度、面積和體積可能被變換改變了。從非技術意義上說，線性變換可能“拉伸”座標系，但不會“彎曲”或“卷折”座標系。矩陣是怎樣變換向量的向量在幾何上能被解釋成一系列與軸平行的位

[3D數學]矩陣 2017.8.16

旋轉矩陣我們進行位移組合向量 bsp 一個物體 <1>有時候我們想對整個物體做一定量旋轉，其實可以直接對物體坐標系進行相反量的旋轉比如：現在想對一個物體順時針旋轉20度，再擴大200%，，既可以對這個物體的坐標系先縮小200%，再逆時

03 矩陣與線性變換

1.線性變換的實質就是一個名字叫的好聽點的函式 2.為啥叫變換而不叫函式呢？變換有運動之意。 3.變換與網格線 (1)線性變換說明:白色網格線是原始的網格線，藍色的網格線是變換後的網格線。 (2)不知該怎麼稱呼的變換，反正不是線性變換

矩陣與線性變換

本文可以說是該系列最重要、最核心的文章。你對線性代數的一切困惑，根源就在於沒有真正理解矩陣到底是什麼。讀完咪博士的這篇文章，你一定會有一種醍醐灌頂、豁然開朗的感覺！咱們先來說說啥叫變換。本質上，變換就是函式。例如，你輸入一個向量 [57]，經過某個變換（即

3D數學矩陣乘法程式設計

矩陣乘法程式設計設計一個3x3矩陣類，實現如下功能： 3x3矩陣矩陣與矩陣的乘法向量與矩陣的乘法具體的數學知識就不詳述了，直接貼程式碼。這裡利用到上一篇3D數學向量運算的程式碼。 /

線性代數的本質與幾何意義 03. 矩陣與線性變換 (3blue1brown 咪博士圖文註解版)

首先，恭喜你讀到了咪博士的這篇文章。本文可以說是該系列最重要、最核心的文章。你對線性代數的一切困惑，根源就在於沒有真正理解矩陣到底是什麼。讀完咪博士的這篇文章，你一定會有一種醍醐灌頂、豁然開朗的感覺！咱們先來說說啥叫變換。本質上，變換就是函式。例如，你輸入一個向量 [

3D數學--矩陣知識

本帖最後由 hunter_wwq 於 2013-7-24 14:04 編輯開此貼是貼出自己在學如題所示知識點時所做的筆記，旨在跟我一樣菜的小朋友們共同學習探討一下這方面的知識，當然，絕對絕對歡迎大牛們來指點指教一下！！！這是筆記附件：下面也貼出筆記的內容，圖片和格式之類的我就不意義複製貼上過來了，太

機器學習筆記（二）矩陣和線性代數例：用Python實現SVD分解進行圖片壓縮

線性代數基本只要是理工科，都是必修的一門課。當時學習的時候總是有一個疑惑，這個東西到底是幹嘛用的？為什麼數學家發明出這麼一套方法呢，感覺除了解方程沒發現有什麼大用啊！但隨著學習的深入，慢慢發現矩陣的應

3D數學--矩陣彙總

在unity中矩陣的定義和使用在Unity中我們都是使用4*4的矩陣 ,通過 Matrix4x4.SetRow 和Matrix4x4.SetCoiumn來設定4*4矩陣的某行和某列,通過 Matrix4x4.GetRow 和Matrix4x4.GetCoiu

3d數學基礎-映象矩陣和切變矩陣-用C++程式碼實現

#include <iostream.h> #include <math.h> #include <assert.h> const float kPi = 3.1415926f; const float k2Pi = kPi*2.0f;

線性代數之——矩陣乘法和逆矩陣

1. 矩陣乘法如果矩陣 \(B\) 的列為 \(b_1, b_2, b_3\)，那麼 \(EB\) 的列就是 \(Eb_1, Eb_2, Eb_3\)。 \[\boldsymbol{EB = E[b_1 \quad b_2 \quad b_3] = [Eb_1 \quad Eb_2 \quad Eb_3

線性代數之——正交矩陣和 Gram-Schmidt 正交化

這部分我們有兩個目標。一是瞭解正交性是怎麼讓 \(\hat x\) 、\(p\) 、\(P\) 的計算變得簡單的，這種情況下，\(A^TA\) 將會是一個對角矩陣。二是學會怎麼從原始向量中構建出正交向量。 1. 標準正交基向量 \(q_1, \cdots, q_n\) 是標準正交的，如果它們滿

線性代數之——克拉默法則、逆矩陣和體積

1. 克拉默法則這部分我們通過代數方法來求解 \(Ax=b\)。用 \(x\) 替換單位矩陣的第一列，然後再乘以 \(A\)，我們得到一個第一列為 \(b\) 的矩陣，而其餘列則是從矩陣 \(A\) 中對應列直接拷貝過來的。利用行列式的乘法法則，我們有 \[|A|(x_1)=|B_1|\]

Machine Learning之高等數學篇(九)☞《矩陣的初等變換》

上一節呢，我們學習了《行列式與方陣》，這次我們續接上一節的內容，來學習下《矩陣的初等變換》一、（引例）矩陣的初等變換二、矩陣的初等變換三、用矩陣的初等變換解方程組（1）：四、行階梯形矩陣，標準形、及相關定理。

機器學習數學心法之線性變換

機器學習的各種演算法推導中, 矩陣推導形式顯得比較簡單. 那我們該如何理解矩陣呢? 以線性變換的角度看待矩陣, 將會發現我們能看的更深一點. 矩陣與線性變換若一個變換 \(L\) 滿足以下兩條性質 \[ \begin{align*} L(\vec v+ \vec w) &

3D數學之矩陣的各種求逆

經過三天的準備終於把矩陣的各種求逆方法以及程式碼完成了。心裡有點小激動，come on，來吧，點燃你的心中的那團火，跟著遊戲音樂的律動一起跟我走入神祕的3D世界。下面介紹三種方法： 1.用伴隨矩陣求逆 2.用高斯－約當消元法求逆 3.用LU分解求逆（聽別人說效率最高）

Unity3d修煉之路：遊戲開發中，3d數學知識的練習【1】（不斷更新.......）

turn tor rdo pre 長度 scrip 縮放 unity3d float #pragma strict public var m_pA : Vector3 = new Vector3(2.0f, 4.0f, 0.0f); public var m_pB :

【3D計算機圖形學】變換矩陣、歐拉角、四元數

遭遇 unit 額外 star 應該 detail 導致 print uic 【3D計算機圖形學】變換矩陣、歐拉角、四元數旋轉矩陣、歐拉角、四元數主要用於：向量的旋轉、坐標系之間的轉換、角位移計算、方位的平滑插值計算。一、變換矩陣：首先要區分旋轉矩陣和變換矩陣：

3D數學 矩陣和線性變換之切變

矩陣和線性變換之切變

1. 什麼是切變？

2. 切變效果的矩陣是怎樣的？

3. 切變矩陣示例程式碼

4. 切變矩陣程式完整示例程式碼

5. 程式執行結果

相關推薦

3D數學矩陣和線性變換之切變