精华内容
下载资源
问答
  • 正交向量 正交矩阵
    千次阅读
    2017-11-12 22:36:10

    如何判断向量正交:

    内积:对应位置相乘再求和,是内积

    卷积:加上滑动窗口

    判断向量是否正交:

    两个向量正交:求其内积,看是否为0,若为零,则正交。

    在空间上向量垂直就正交。


    例子:a=(1,1,0),b=(1,-1,0) ,则内积(a,b)=1*1+1*(-1)+0*0=0,所以a,b正交。

    正交向量

    “正交向量”是一个数学术语,指点积为零的两个或多个向量

     换句话说, 两个向量正交意味着它们是相互垂直的。若向量α与β正交,则记为α⊥β

    如何求解正交矩阵:

    https://jingyan.baidu.com/article/9faa72318364a7473c28cbe9.html

    正交矩阵

    正交矩阵是实数特殊化的酉矩阵,因此总是正规矩阵。尽管我们在这里只考虑实数矩阵,这个定义可用于其元素来自任何域的矩阵。正交矩阵毕竟是从内积自然引出的,对于复数的矩阵这导致了归一要求。

    定义

      定义 1
      如果:AA'=E(E为单位矩阵,A'表示“矩阵A的转置矩阵”。)或A′A=E,则n阶实矩阵 A称为正交矩阵, 若A为正交阵,则满足以下条件:
      1) A 是正交矩阵
      2) AA′=E(E为单位矩阵)(#add它的转置矩阵是它的逆矩阵,这是很重要的)
      3) A′是正交矩阵
      4) A的各行是单位向量且两两正交
      5) A的各列是单位向量且两两正交
      6) (Ax,Ay)=(x,y) x,y∈R
       正交矩阵通常用字母Q表示。
      举例:A=[r11 r12 r13;r21 r22 r23;r31 r32 r33]
      则有:
    r11^2+r12^2+r13^2=r21^2+r22^2+r23^2=r31^2+r32^2+r33^2=1
    r11*r12+r21*r22+r31*r32=0等性质
     
      正交方阵是欧氏空间中标准正交基到标准正交基的过渡矩阵。
      在 矩阵论中, 实数 正交矩阵方块矩阵 Q,它的 转置矩阵是它的 逆矩阵:
      ,如果正交矩阵的 行列式为 +1,则我们称之为 特殊正交矩阵:

    概述

      要看出与内积的联系,考虑在  n 维实数 内积空间中的关于正交基写出的向量 vv 的长度的平方是 vv。如果矩阵形式为 Q v 的线性变换保持了向量长度,则
      所以有限维线性 等距同构,比如 旋转反射和它们的组合,都产生正交矩阵。反过来也成立: 正交矩阵蕴涵了正交变换。但是, 线性代数包括了在既不是有限维的也不是同样维度的空间之间的 正交变换,它们没有等价的正交矩阵。
      有多种原由使正交矩阵对理论和实践是重要的。 n× n 正交矩阵形成了一个 ,即指示为 O( n) 的 正交群,它和它的子群广泛的用在数学和物理科学中。例如,分子的 点群O(3) 的子群。因为浮点版本的正交矩阵有有利的性质,它们是字数值线性代数中很多算法比如 QR分解的关键,通过适当的规范化, 离散余弦变换 (用于 MP3 压缩)可用正交矩阵表示。

    例子

      下面是一些小正交矩阵的例子和可能的解释。
      恒等变换。 旋转 16.26°。 针对  x 轴反射。 旋转反演(rotoinversion): 轴 (0,-3/5,4/5),角度90°。 置换坐标轴。

    基本构造

    低维度

      最简单的正交矩阵是 1×1 矩阵 [1] 和 [−1],它们可分别解释为恒等和实数线针对原点的反射。
      如下形式的 2×2 矩阵
      它的正交性要求满足三个方程
      
    在考虑第一个方程时,不丢失一般性而设  p = cos θ,  q = sin θ;因此要么  t = − q, u = p 要么 t =  qu = − p。我们可以解释第一种情况为旋转 θ(θ = 0 是单位矩阵),第二个解释为针对在角 θ/2 的直线的反射。
      旋转 反射 在 45°的反射对换  x 和  y;它是 置换矩阵,在每列和每行带有一个单一的 1(其他都是 0):
      单位矩阵也是置换矩阵。
      反射是它自己的逆,这蕴涵了反射矩阵是 对称的(等于它的转置矩阵)也是正交的。两个旋转矩阵的积是一个旋转矩阵,两个反射矩阵的积也是旋转矩阵。

    更高维度

      不管维度,总是可能把正交矩阵按纯旋转与否来分类,但是对于 3×3 矩阵和更高维度矩阵要比反射复杂多了。例如,
      和 表示通过原点的 反演和关于 z 轴的旋转反演(逆时针旋转90°后针对 x- y平面反射,或逆时针旋转 270°后对原点反演)。
      旋转也变得更加复杂;它们不再由一个角来刻画,并可能影响多于一个平面子空间。尽管经常以一个轴和角来描述 3×3 旋转矩阵,在这个维度旋转轴的存在是偶然的性质而不适用于其他维度。
      但是,我们有了一般适用的基本建造板块如置换、反射、和旋转。

    基本变换

      最基本的置换是换位(transposition),通过交换单位矩阵的两行得到。任何  n× n 置换矩阵都可以构造为最多  n−1 次换位的积。 构造自非零向量  v 的 Householder反射为
      这里的分子是对称矩阵,而分母是  v 的平方量的一个数。这是在垂直于  v 的超平面上的反射(取负平行于 v 任何向量分量)。如果 v 是单位向量,则 Q =  I−2 vv 就足够了。Householder 反射典型的用于同时置零一列的较低部分。任何 n× n 正交矩阵都可以构造为最多 n 次这种反射的积。
      Givens旋转作用于由两个坐标轴所生成的二维(平面)子空间上,按选定角度旋转。它典型的用来置零一个单一的次对角线元素(subdiagonal entry)。任何 n× n 的旋转矩阵都可以构造为最多 n( n−1)/2 次这种旋转的积。在 3x3 矩阵的情况下,三个这种旋转就足够了;并且通过固定这个序列,我们可以用经常叫做 欧拉角的三个角来(尽管不唯一)描述所有 3×3 旋转矩阵。
      雅可比旋转有同 Givens 旋转一样的形式,但是被用做 相似变换,选择来置零 2×2 子矩阵的两个远离对角元素(off-diagonal entry)。

    性质

    矩阵性质

      实数方块矩阵是正交的,当且仅当它的列形成了带有普通欧几里得 点积欧几里得空间 R 的正交规范基,它为真当且仅当它的行形成 R 的正交基。假设带有正交(非正交规范)列的矩阵叫正交矩阵可能是诱人的,但是这种矩阵没有特殊价值而没有特殊名字;他们只是 MM = DD 是 对角矩阵
       任何正交矩阵的行列式是 +1 或 −1。这可从关于行列式的如下基本事实得出:
      反过来不是真的;有 +1 行列式不保证正交性,即使带有正交列,可由下列反例证实。
      对于置换矩阵,行列式是 +1 还是 −1 匹配置换是偶还是奇的 标志,行列式是行的交替函数。
       比行列式限制更强的是正交矩阵总可以是在复数上可对角化来展示特征值的完全的集合,它们全都必须有(复数)绝对值 1。

    群性质

       正交矩阵的逆是正交的,两个正交矩阵的积是正交的。事实上,所有  n× n 正交矩阵的集合满足群的所有公理。它是  n( n−1)/2 维的 紧致 李群,叫做正交群并指示为 O( n)。
      行列式为 +1 的正交矩阵形成了路径连通的子群指标为 2 的  O( n正规子群,叫做旋转的特殊正交群  SO( n)。 商群 O( n)/ SO( n) 同构于 O(1),带有依据行列式选择 [+1] 或 [−1] 的投影映射。带有行列式 −1 的正交矩阵不包括单位矩阵,所以不形成子群而只是 陪集;它也是(分离的)连通的。所以每个正交群被分为两个部分;因为投影映射 分裂O( n) 是  SO( n) 与  O(1)的 半直积。用实用术语说,一个相当的陈述是任何正交矩阵可以通过采用一个旋转矩阵并可能取负它的一列来生成,如我们在 2×2 矩阵中看到的。如果 n 是奇数,则半直积实际上是 直积,任何正交矩阵可以通过采用一个旋转矩阵并可能取负它的所有列来生成。
      现在考虑 ( n+1)×( n+1) 右底元素等于 1 的正交矩阵。最后一列(和最后一行)的余下元素必须是零,而任何两个这种矩阵的积有同样的形式。余下的矩阵是 n× n 正交矩阵;因此 O( n) 是 O( n+1) (和所有更高维群)的子群。
      因为 Householder 正交矩阵形式的基本反射可把任何正交矩阵简约成这种约束形式,一系列的这种反射可以把任何正交矩阵变回单位矩阵;因此正交群是反射群。最后一列可以被固定为任何单位向量,并且每种选择给出不同的 O( n) 在 O( n+1) 中的复本;以这种方式 O( n+1) 是在单位球 S 与纤维  O( n) 上的
      类似的, SO( n) 是  SO( n+1) 的子群;任何特定正交矩阵可以使用类似过程通过 Givens 平面旋转来生成。丛结构持续: SO( n) ↪ SO( n+1) → S。一个单一旋转可以在最后一列的第一行生成一个零,而 n−1 次旋转序列将置零 n× n 旋转矩阵的除了最后一列的最后一行的所有元素。因为平面是固定的,每次旋转只有一个自由度,就是它的角度。通过归纳, SO( n) 因此有
      自由度, O( n) 也是。
      置换矩阵简单一些;它们不形成李群,只是一个有限群, n! 次 对称群 Sn。通过同类的讨论, Sn 是 Sn+1 的子群。偶置换生成行列式 +1 的置换矩阵的子群, n!/2 次交错群。

    规范形式

      更广泛的说,任何正交矩阵的效果分离到在正交二维空间上的独立动作。就是说,如果  Q 是狭义正交的,则你可以找到(旋转)改变基的一个正交矩阵  P,把  Q 带回到分块对角形式:
      ( n 偶数), ( n 奇数)。 这里的矩阵  R1,..., Rk 是 2×2 旋转矩阵,而余下的元素是零。作为例外,一个旋转块可以是对角的, ± I。因此如果需要的话取负一列,并注意 2×2 反射可对角化为 +1 和 −1,任何正交矩阵可变为如下形式
      , 矩阵  R1,…, Rk 给出位于 复平面中单位圆上的特征值的共轭对;所以这个分解复合确定所有带有绝对值 1 的特征值。如果 n 是奇数,至少有一个实数特征值 +1 或 −1;对于 3×3 旋转,关联着 +1 的特征向量是旋转轴。

    数值线性代数

    利益

       数值分析自然的利用了正交矩阵的很多数值线性代数的性质。例如,经常需要计算空间的正交基,或基的正交变更;二者都采用了正交矩阵的形式。有行列式 ±1 和所有模为 1 的特征值是对数值稳定性非常有利的。 一个蕴涵是 条件数为 1 (这是极小的),所以在乘以正交矩阵的时候错误不放大。很多算法为此使用正交矩阵如 Householder反射和 Givens旋转。有帮助的不只是正交矩阵是可逆的,还有它的逆矩阵本质上是免花费的,只需要对换索引(下标)。
      置换是很多算法成功的根本,包括有局部定支点(partial pivoting)的运算繁重的 高斯消去法(这里的置换用来定支点)。但是它们很少明显作为矩阵出现;它们的特殊形式允许更有限的表示,比如 n 个索引的列表。
      同样的,使用 Householder 和 Givens 矩阵的算法典型的使用特殊方法的乘法和存储。例如,Givens 旋转只影响它所乘的矩阵的两行,替代完全的 n 次的 矩阵乘法为更有效的 n 次运算。在使用这些反射和旋转向矩阵介入零的时候,腾出的空间足够存储充足的数据来重生成这个变换。

    分解

      一些重要的 矩阵分解(Golub & Van Loan, 1996)涉及到了正交矩阵,包括:
      QR分解  M =  QRQ 正交, R 上三角。  奇异值分解  M =  UΣVU 和  V 正交, Σ 非负对角。 谱分解 S = QΛQ, S 对称, Q 正交, Λ 对角。 极分解  M = QS, Q 正交, S 对称非负确定。

    更多相关内容
  • 正交投影矩阵-原理及推导

    万次阅读 多人点赞 2019-02-15 15:51:42
    ...当中,P为投影矩阵,由P的表达式能够看出,它具有例如以下性质: 三维投影  三维投影,就是将一个向量投影到一个平面上。同上面一样,如果是将b向量投影到平面上的p向量,则有表达式:...

    来自:https://blog.csdn.net/tengweitw/article/details/41174555

    二维投影

    上图表示的是,向量b在向量a上的投影。显然有例如以下表达式:

    当中,P为投影矩阵,由P的表达式能够看出,它具有例如以下性质:


    三维投影

           三维投影,就是将一个向量投影到一个平面上。同上面一样,如果是将b向量投影到平面上的p向量,则有表达式:

    e是垂直与平面的向量。

     

    因为p向量在平面上。则p向量能够由该平面的2个线性无关向量(正如。在xy平面的不论什么向量都能够由x轴,y轴表示)表示:

     

    因为e垂直平面,则e向量垂直与平面中的随意向量。则有:

    将上式化简求得x:

    又由于p=Ax,Pb=p,则得到投影矩阵为:

    由P的表达式能够看出,它具有例如以下性质:

    上面的投影矩阵是通式。当投影在一维情况时,数值的逆是它的倒数,A即为直线上的随意一个向量a,投影矩阵为:


    实例说明:

     

    如上图,如果我们要将向量b投影到水平面上。其投影为p,a1,a2为水平面的两个线性无关向量,它们的參数分别为:

    那么A=[a1 a2]即:

    由上面我们求得的通式,可得投影矩阵P:

    知道投影矩阵P后。我们能够得到b在水平面上的投影p为:

     

    显然,p与我们图中所看到的的结果同样。这里我们是以三维情况进行举例的,更高维情况。我们无法用图像来描写叙述,可是通式也是成立的。

    展开全文
  • 本文介绍向量空间投影与投影矩阵,并阐述其作用

    1. 向量投影到一维空间(向量间投影)

    • 考察二维平面投影,如下将向量 b \pmb{b} bbb 投影到向量 a \pmb{a} aaa 方向,得到 a \pmb{a} aaa 的子空间中的向量 p \pmb{p} ppp,假设是 a \pmb{a} aaa x x x
      在这里插入图片描述

      如图可见 b − p \pmb{b-p} bpbpbp 可以衡量 a , b \pmb{a,b} a,ba,ba,b 间的误差,它与向量 a \pmb{a} aaa 正交,內积为 0,即有
             a ⊤ ( b − p ) = a ⊤ ( b − x a ) = 0 ⇒ x = a ⊤ b a ⊤ a ⇒ p = a x = a a ⊤ b a ⊤ a = ( a a ⊤ a ⊤ a ) b \begin{aligned} &\space\space\space\space\space\space\pmb{a^\top}(\pmb{b-p}) = \pmb{a^\top}(\pmb{b}-x\pmb{a}) = \pmb{0}\\ &\Rightarrow x = \frac{\pmb{a^\top b}}{\pmb{a^\top a}} \\ &\Rightarrow \pmb{p} = \pmb{a}x = \pmb{a} \frac{\pmb{a^\top b}}{\pmb{a^\top a}} = ( \frac{\pmb{aa^\top }}{\pmb{a^\top a}}) \pmb{b} \end{aligned}       aaa(bpbpbp)=aaa(bbbxaaa)=000x=aaaaaaabababppp=aaax=aaaaaaaaaababab=(aaaaaaaaaaaa)bbb 这时,我们把 a a ⊤ a ⊤ a \frac{\mathbf{aa^\top }}{\mathbf{a^\top a}} aaaa 称为 投影矩阵,记为 P \pmb{P} PPP,用它左乘原始向量 b \pmb{b} bbb 就得到投影向量 p \pmb{p} ppp,即 P b = p \pmb{Pb} = \pmb{p} PbPbPb=ppp

    • 两种特殊情况

      1. b \pmb{b} bbb a \pmb{a} aaa 平行,有 P b = b \pmb{Pb} = \pmb{b} PbPbPb=bbb
      2. b \pmb{b} bbb a \pmb{a} aaa 正交,有 P b = 0 \pmb{Pb} = \pmb{0} PbPbPb=000

      二维空间中,平行和正交于向量 a \pmb{a} aaa 的两个向量构成一组基,可以线性表出任意向量,投影本质就是保留平行部分而消除正交部分

    • 研究投影矩阵 P = a a ⊤ a ⊤ a \pmb{P}=\frac{\mathbf{aa^\top }}{\mathbf{a^\top a}} PPP=aaaa 性质

      1. 分子 a ⊤ a \mathbf{a^\top a} aa 是向量內积,是个常数,不管它
      2. 分子 a a ⊤ \mathbf{aa^\top } aa,这是个矩阵,显然有 rank ( A ) = 1 \text{rank}(\pmb{A})=1 rank(AAA)=1,其列空间就是 k a k\pmb{a} kaaa,因此用投影矩阵左乘向量会把向量变换到其列空间 k a k\pmb{a} kaaa 中,实现投影

        注:用矩阵左乘一个向量时,相当于对这个矩阵的列向量做线性组合,得到的向量位于矩阵的列空间中

      3. a a ⊤ \mathbf{aa^\top } aa 对称,所以 p \pmb{p} ppp 是对称矩阵, P = P ⊤ \pmb{P} = \pmb{P^\top} PPP=PPP
      4. 重复投影两次,结果不变,即有 P 2 = P \pmb{P}^2 = \pmb{P} PPP2=PPP

        这个也可以简单地展开计算验证

    • 另外提一句, 假设向量 a , b \pmb{a,b} a,ba,ba,b 夹角为 θ \theta θ,常见的向量内积 a ⊤ b = ∣ ∣ b ∣ ∣ ⋅ ∣ ∣ a ∣ ∣ ⋅ c o s ( θ ) \pmb{a}^\top \pmb{b} = ||b||·||a||·cos(\theta) aaabbb=bacos(θ) 计算的就是一个向量的模乘以另一个向量在此向量上投影的模长。如果把其中某一个向量的模长设为1(即变为单位向量),最后再乘以该向量,就得到投影向量,即
      a 投 影 到 单 位 向 量 b 为 : ( a ⊤ b ) b = ( b ⊤ a ) b = ∣ ∣ a ∣ ∣ c o s ( θ ) b , 其 中 ∣ ∣ b ∣ ∣ = 1 b 投 影 到 单 位 向 量 a 为 : ( a ⊤ b ) a = ( b ⊤ a ) a = ∣ ∣ b ∣ ∣ c o s ( θ ) a , 其 中 ∣ ∣ a ∣ ∣ = 1 \pmb{a}投影到单位向量 \pmb{b} 为: (\pmb{a}^\top \pmb{b})\pmb{b}=(\pmb{b}^\top \pmb{a})\pmb{b} = ||\pmb{a}||cos(\theta)\pmb{b},其中 ||\pmb{b}|| = 1\\ \pmb{b}投影到单位向量 \pmb{a} 为: (\pmb{a}^\top \pmb{b})\pmb{a}=(\pmb{b}^\top \pmb{a})\pmb{a}=||\pmb{b}||cos(\theta)\pmb{a},其中 ||\pmb{a}|| = 1 aaabbb(aaabbb)bbb=(bbbaaa)bbb=aaacos(θ)bbbbbb=1bbbaaa(aaabbb)aaa=(bbbaaa)aaa=bbbcos(θ)aaaaaa=1 当投影方向不是单位向量时,增加其模的倒数进行缩放,如上图中的 p = ∣ ∣ b ∣ ∣ c o s ( θ ) a ∣ ∣ a ∣ ∣ \pmb{p} = ||\pmb{b}||cos(\theta)\frac{\mathbf{a}}{||\mathbf{a}||} ppp=bbbcos(θ)aa

    2. 向量投影到多维空间

    2.1 计算方法

    • 完全和第 1 节中二维情况完全类似,现有矩阵 A \pmb{A} AAA,将向量 b \pmb{b} bbb 投影到 A \pmb{A} AAA 列向量 a 1 , a 2 , . . . , a n \pmb{a}_1,\pmb{a}_2,...,\pmb{a}_n aaa1,aaa2,...,aaan 张成的空间中得到 p \pmb{p} ppp。三维情况示意图如下 在这里插入图片描述
      可见这时仍有 e = b − p \pmb{e} = \pmb{b-p} eee=bpbpbp 可以衡量 b \pmb{b} bbb A \pmb{A} AAA 列空间间的误差,我们希望希望二者正交(也就是希望误差最小化),这意味着 b \pmb{b} bbb A \pmb{A} AAA 的所有列向量正交,內积均为 0;另一方面,这时 p \pmb{p} ppp A \pmb{A} AAA 列空间中,故能用 A \pmb{A} AAA 的列向量线性表示,设 p = A x ^ \pmb{p}=\pmb{A\hat{x}} ppp=Ax^Ax^Ax^,则有
           [ a 1 ⊤ a 2 ⊤ ⋮ a m ⊤ ] ( b − p ) = [ a 1 ⊤ a 2 ⊤ ⋮ a m ⊤ ] ( b − A x ^ ) = [ 0 0 ⋮ 0 ] ⇒ A ⊤ ( b − A x ^ ) = 0 ⇒ x ^ = ( A ⊤ A ) − 1 A ⊤ b ⇒ p = A x ^ = A ( A ⊤ A ) − 1 A ⊤ b \begin{aligned} &\space\space\space\space\begin{bmatrix} \pmb{a}_1^\top \\ \pmb{a}_2^\top \\ \vdots\\ \pmb{a}_m^\top \end{bmatrix} (\pmb{b-p}) = \begin{bmatrix} \pmb{a}_1^\top \\ \pmb{a}_2^\top \\ \vdots\\ \pmb{a}_m^\top \end{bmatrix} (\pmb{b}-\pmb{A}\pmb{\hat{x}}) = \begin{bmatrix} \pmb{0}\\ \pmb{0} \\ \vdots\\ \pmb{0} \end{bmatrix} \\ &\Rightarrow \pmb{A^\top}(\pmb{b-\pmb{A}\hat{x}}) = \pmb{0}\\ &\Rightarrow \pmb{\hat{x}} = (\pmb{A^\top A})^{-1}\pmb{A^\top b} \\ &\Rightarrow \pmb{p} = \pmb{A\hat{x}} = \pmb{A}(\pmb{A^\top A})^{-1}\pmb{A^\top b} \end{aligned}     aaa1aaa2aaam(bpbpbp)=aaa1aaa2aaam(bbbAAAx^x^x^)=000000000AAA(bAAAx^bAAAx^bAAAx^)=000x^x^x^=(AAAAAA)1AbAbAbppp=Ax^Ax^Ax^=AAA(AAAAAA)1AbAbAb 这时,我们把 A ( A ⊤ A ) − 1 A ⊤ \pmb{A}(\pmb{A^\top A})^{-1}\pmb{A^\top} AAA(AAAAAA)1AAA 称为 投影矩阵,记为 P \pmb{P} PPP,用它左乘原始向量 b \pmb{b} bbb 就得到投影向量 p \pmb{p} ppp,即 P b = p \pmb{Pb} = \pmb{p} PbPbPb=ppp

    • 两种特殊情况

      1. b ∈ C ( A ) \pmb{b} \in C(\pmb{A}) bbbC(AAA),有 P b = b \pmb{Pb} = \pmb{b} PbPbPb=bbb

        这时 b = A x \pmb{b} = \pmb{Ax} bbb=AxAxAx A \pmb{A} AAA 的线性组合,有 P b = A ( A ⊤ A ) − 1 A ⊤ A x = A x = b \pmb{Pb} = \pmb{A}(\pmb{A^\top A})^{-1}\pmb{A^\top Ax }= \pmb{Ax}=\pmb{b} PbPbPb=AAA(AAAAAA)1AAxAAxAAx=AxAxAx=bbb

      2. b ⊥ C ( A ) \pmb{b} \perp C(\pmb{A}) bbbC(AAA),即 b ∈ N ( A ⊤ ) \pmb{b} \in N(\pmb{A^\top}) bbbN(AAA),有 P b = 0 \pmb{Pb} = \pmb{0} PbPbPb=000

        这时 A ⊤ b = 0 \pmb{A^\top b} = \pmb{0} AbAbAb=000,有 P b = A ( A ⊤ A ) − 1 A ⊤ x = 0 \pmb{Pb} = \pmb{A}(\pmb{A^\top A})^{-1}\pmb{A^\top x }= \pmb{0} PbPbPb=AAA(AAAAAA)1AxAxAx=000

      m m m 维( A \pmb{A} AAA 列向量尺寸)空间可以分解为 C ( A ) C(\pmb{A}) C(AAA) N ( A ⊤ ) N(\pmb{A^\top}) N(AAA) 的正交直和,因此这两个空间的基放在一起就构成 m m m 维空间的一组基,可以线性表出任意向量,投影本质就是保留 C ( A ) C(\pmb{A}) C(AAA) 中部分而消除 N ( A ⊤ ) N(\pmb{A^\top}) N(AAA) 中部分,可以用子空间关系图如下表示
      在这里插入图片描述
      如图可见,除了上述投影 P b = p \pmb{Pb=p} Pb=pPb=pPb=p b \pmb{b} bbb 投影到 C ( A ) C(\pmb{A}) C(AAA) 中以外,还有另一个投影 ( I − P ) b = e (\pmb{I-P})\pmb{b} = \pmb{e} (IPIPIP)bbb=eee b \pmb{b} bbb 投影到 N ( A ⊤ ) N(\pmb{A^\top}) N(AAA) 中,可见 P \pmb{P} PPP 是投影矩阵时, I − P \pmb{I-P} IPIPIP 也是一个投影矩阵

    • 研究投影矩阵 P = A ( A ⊤ A ) − 1 A ⊤ \pmb{P}=\pmb{A}(\pmb{A^\top A})^{-1}\pmb{A^\top} PPP=AAA(AAAAAA)1AAA 性质

      1. A \pmb{A} AAA 非方阵时, A \pmb{A} AAA 列满秩 ⇔ A ⊤ A \Leftrightarrow \pmb{A^\top A} AAAAAA 可逆,
      2. A \pmb{A} AAA 是可逆方阵时,其中的括号可以打开,这时有 P = I \pmb{P}=\pmb{I} PPP=III,即投影矩阵做的是恒等映射。确实如此,因为 A \pmb{A} AAA 可逆,意味着列满秩,其列空间是整个 n n n 维空间,投影前后都在同一个空间中,那么恒等映射显然是误差最小的
      3. 简单计算即可得到 P \pmb{P} PPP 是对称矩阵,即有 P = P ⊤ \pmb{P} = \pmb{P^\top} PPP=PPP
      4. 重复投影两次,结果不变,即有 P 2 = P \pmb{P}^2 = \pmb{P} PPP2=PPP,也可从代数角度简单计算验证
      5. P \pmb{P} PPP 是投影矩阵时, I − P \pmb{I-P} IPIPIP 也是一个投影矩阵

    2.2 意义

    • 现实生活中常有这样的应用:根据一些测量值求解另一些值,比如根据卫星与几个基站的通讯延时测量其位置。这其实就是在解方程,通常一组观测值解出一个结果,为了提高准确性,通常会收集很多数据,这样就联立到得到方程组 A x = b \pmb{Ax} = \pmb{b} AxAxAx=bbb一般情况下样本量远大于未知数个数,即 A m × n \pmb{A}_{m\times n} AAAm×n m > > n m>>n m>>n,这样的超定方程很难有解析解,除非其中含有多达 m − n m-n mn 个无效约束,因为我们没法对非方阵的 A \pmb{A} AAA 求逆来得到 x = A − 1 b \pmb{x} = \pmb{A}^{-1}\pmb{b} xxx=AAA1bbb
    • 这时我们可以不断地去除方程,直到剩下的方程组有解为止,但这会造成数据浪费。另一种更好的方法是找一个和已知数据 “误差最小” 的解,设这个近似解为 x ^ \pmb{\hat{x}} x^x^x^,我们有
      A x ^ = p \pmb{A\hat{x}} = \pmb{p} Ax^Ax^Ax^=ppp 第 1 节中已分析过,我们这时是通过矩阵 A \pmb{A} AAA 左乘,把向量 x ^ \pmb{\hat{x}} x^x^x^ 变换到了 A \pmb{A} AAA 的列空间中得到 p \pmb{p} ppp,为了保证 “误差最小” ,这时 p \pmb{p} ppp 应当是 b \pmb{b} bbb A \pmb{A} AAA 列空间中的投影
    • 一句话说,可以利用空间投影估计无解线性方程组的最小误差解,基于这个原理可以得到最小二乘法
    展开全文
  • 向量 bbb 在子空间 aaa 上的投影向量 p=xap = xap=xa,则向量b 与 向量p 之间的最小误差 e=b−pe=b-pe=b−p与子空间aaa正交。 由正交的定义有: aT(b−p)=0→aT(b−xa)=0a^T(b-p)=0 \rightarrow a^T(b-xa)=0aT...
  • 主要内容:将公式计算得到的投影矩阵与从OpenGL中获得的投影矩阵进行比较,验证公式正确与否。注:1、OpenGL中矩阵以1维数组形式;2、OpenGL中矩阵以列为主序;3、OpenGL中矩阵乘法为矩阵乘以列向量,即如下形式:p2...

    主要内容:将公式计算得到的投影矩阵与从OpenGL中获得的投影矩阵进行比较,验证公式正确与否。

    注:

    1OpenGL中矩阵以1维数组形式;

    2OpenGL中矩阵以列为主序;

    3OpenGL中矩阵乘法为矩阵乘以列向量,即如下形式:

    p2 = M * p1

    其中p1、p2为列向量。

    投影参数:

    令left=13,right=24,bottom=5,top=18,zNear=7,zFar=15,

    fovy = 45aspect = 2

    分别调用以下四个函数:

    void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

    void gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);

    void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

    void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);

    比较OpenGL正交投影矩阵”以及“利用公式计算出的正交投影矩阵”:

    测试程序输出结果如下图所示,可以看到利用公式和从OpenGL中获得的矩阵一致:

    glOrthoMat:利用glGet函数从OpenGL获得的正交投影矩阵

    funOrthoMat:利用公式计算出的正交投影矩阵

    glProjMat:利用glGet函数从OpenGL获得的透视投影矩阵

    funProjMat:利用公式计算出的透视投影矩阵

     

    测试程序需要的glut库下载地址:https://download.csdn.net/download/u012633319/10379891

    测试程序下载地址:https://download.csdn.net/download/u012633319/10379989

    测试程序:(为方便理解,存在重复代码)

    #include <stdio.h>
    #include <math.h>
    #include <glut.h>
    
    // glut回调函数:窗口尺寸改变时调用,在此调用下面四个计算投影矩阵的函数
    void changeSize(int w, int h);
    // glut回调函数:每次绘制窗口调用,在此仅为程序完整性使用,无需注意
    void renderScene();
    
    // -----------------【四个计算投影矩阵的函数】-------------------------
    void glOrtho_Mat(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);  // 正交投影
    void gluOrtho2D_Mat(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);                              // 正交投影
    void glFrustum_Mat(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);// 透视投影
    void gluPerspective_Mat(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);                         // 透视投影
    
    // 程序入口
    int main(int argc, char** argv)
    {
        // --------------glut库函数设定部分-------------------
        glutInit(&argc, argv);                          // glut库初始化
        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);   // 设置显示模式:单缓冲区、rgba像素格式
        glutInitWindowSize(200, 200);                   // 设置窗口初始窗口尺寸:200 X 200
        glutCreateWindow("Calculate Projection Mat");   // 创建窗口,窗口标题:Calculate Projection Mat
        glutReshapeFunc(changeSize);                    // 设置窗口改变尺寸时的回调函数
        glutDisplayFunc(renderScene);                   // 设置窗口绘制的回调函数
    
        glutMainLoop();                                 // 开启消息循环,简单理解为显示窗口
    
        return 0;
    }
    
    // 窗口尺寸改变时的回调函数,在此调用四个计算投影矩阵的函数
    void changeSize(int w, int h)
    {
        // 用num标识计算次数
        static int num = 0;
        num += 1;
        printf("---------------------------【第%d次】-----------------------------\n", num);
    
        // 设置计算投影矩阵需要的几个参数
        static GLdouble left   = 13, right  = 24;
        static GLdouble bottom = 5,  top    = 18;
        static GLdouble zNear  = 7,  zFar   = 15;
        static GLdouble fovy   = 45, aspect = 2;
        left += 2, right += 2;
        bottom+=2, top +=2;
        zNear +=2, zFar +=2;
        fovy = (fovy+2)<180 ? (fovy+2) : fovy; // 当fovy等于180度时,相当于视野无限大
        aspect += 0.1;
    
        glOrtho_Mat(left, right, bottom, top, zNear, zFar);
        gluOrtho2D_Mat(left, right, bottom, top);
        glFrustum_Mat(left, right, bottom, top, zNear, zFar);
        gluPerspective_Mat(fovy, aspect, zNear, zFar);
    }
    // 绘制回调函数
    void renderScene()
    {
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        glFlush();
    }
    
    // gl的核心函数:glOrtho计算正交投影矩阵
    void glOrtho_Mat(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
    {
        glMatrixMode(GL_PROJECTION); // 设定矩阵模式
        glLoadIdentity();            // 使当前投影矩阵为单位矩阵,免受以前投影矩阵的影响
        glOrtho(left, right, bottom, top, zNear, zFar); // 调用glOrtho投影函数
        // 利用glGet函数获得OpenGL正交投影矩阵
        GLfloat glOrthoMat[16];
        glGetFloatv(GL_PROJECTION_MATRIX, glOrthoMat);
    
        // 利用正交投影矩阵公式计算正交投影矩阵
        GLfloat funOrthoMat[16];
        funOrthoMat[0]  =  2 / (right-left);
        funOrthoMat[1]  =  funOrthoMat[2] = funOrthoMat[3] = 0;
        funOrthoMat[5]  =  2 / (top-bottom);
        funOrthoMat[4]  =  funOrthoMat[6] = funOrthoMat[7] = 0;
        funOrthoMat[10] = -2 / (zFar-zNear);
        funOrthoMat[8] = funOrthoMat[9] = funOrthoMat[11] = 0;
        funOrthoMat[12] = -(right+left) / (right-left);
        funOrthoMat[13] = -(top+bottom) / (top-bottom);
        funOrthoMat[14] = -(zFar+zNear) / (zFar-zNear);
        funOrthoMat[15] = 1;
    
        // 控制台输出结果:比较“OpenGL正交投影矩阵”以及“利用公式计算出的正交投影矩阵”
        // “OpenGL正交投影矩阵”
        printf("glOrtho_Mat()-----------------------------\n");
        printf(" left \tright \tbottom \ttop \tzNear \tzFar\n");
        printf(" %.2f \t%.2f  \t%.2f   \t%.2f\t%.2f  \t%.2f\n", left, right, bottom, top, zNear, zFar);
        printf("\tglOrthoMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", glOrthoMat[i*4+j]);
            }
            printf("\n");
        }
        // “利用公式计算出的正交投影矩阵”
        printf("\tfunOrthoMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", funOrthoMat[i*4+j]);
            }
            printf("\n");
        }
    }
    // glu函数:gluOrtho2D计算正交投影矩阵,此时 zNear = -1, zFar = 1,相当于z方向已经规范化
    void gluOrtho2D_Mat(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)
    {
        // 设定矩阵模式
        glMatrixMode(GL_PROJECTION);
        // 使当前投影矩阵为单位矩阵,免受以前投影矩阵的影响
        glLoadIdentity();
        // 调用gluOrtho2D投影函数
        gluOrtho2D(left, right, bottom, top);
        // 利用glGet函数获得OpenGL正交投影矩阵
        GLfloat glOrthoMat[16];
        glGetFloatv(GL_PROJECTION_MATRIX, glOrthoMat);
    
        // 利用正交投影矩阵公式计算正交投影矩阵
        GLfloat funOrthoMat[16];
        funOrthoMat[0]  =  2 / (right-left);
        funOrthoMat[1]  =  funOrthoMat[2] = funOrthoMat[3] = 0;
        funOrthoMat[5]  =  2 / (top-bottom);
        funOrthoMat[4]  =  funOrthoMat[6] = funOrthoMat[7] = 0;
        funOrthoMat[10] = -1;
        funOrthoMat[8] = funOrthoMat[9] = funOrthoMat[11] = 0;
        funOrthoMat[12] = -(right+left) / (right-left);
        funOrthoMat[13] = -(top+bottom) / (top-bottom);
        funOrthoMat[14] = 0;
        funOrthoMat[15] = 1;
    
        // 控制台输出结果:比较“OpenGL正交投影矩阵”以及“利用公式计算出的正交投影矩阵”
        // “OpenGL正交投影矩阵”
        printf("glOrtho2D_Mat()-----------------------------\n");
        printf(" left \tright \tbottom \ttop\n");
        printf(" %.2f \t%.2f  \t%.2f   \t%.2f\n", left, right, bottom, top);
        printf("\tglOrthoMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", glOrthoMat[i*4+j]);
            }
            printf("\n");
        }
        // “利用公式计算出的正交投影矩阵”
        printf("\tfunOrthoMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", funOrthoMat[i*4+j]);
            }
            printf("\n");
        }
    }
    // gl的核心函数:glFrustum计算透视投影矩阵
    void glFrustum_Mat(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
    {   
        // 设定矩阵模式
        glMatrixMode(GL_PROJECTION);
        // 使当前投影矩阵为单位矩阵,免受以前投影矩阵的影响
        glLoadIdentity();
        // 调用glFrustum投影函数
        glFrustum(left, right, bottom, top, zNear, zFar);
        // 利用glGet函数获得OpenGL透视投影矩阵
        GLfloat glProjMat[16];
        glGetFloatv(GL_PROJECTION_MATRIX, glProjMat);
    
        // 利用透视投影矩阵公式计算正交投影矩阵
        GLfloat funProjMat[16];
        funProjMat[0]  =  2*zNear / (right-left);
        funProjMat[1]  =  funProjMat[2] = funProjMat[3] = 0;
        funProjMat[5]  =  2*zNear / (top-bottom);
        funProjMat[4]  =  funProjMat[6] = funProjMat[7] = 0;
        funProjMat[8]  = (right+left) / (right-left);
        funProjMat[9]  = (top+bottom) / (top-bottom);
        funProjMat[10] = -(zFar+zNear) / (zFar-zNear);
        funProjMat[11] = -1;
        funProjMat[12] = funProjMat[13] = funProjMat[15] = 0;
        funProjMat[14] = -2*zFar*zNear / (zFar-zNear);
    
        // 控制台输出结果:比较“OpenGL透视投影矩阵”以及“利用公式计算出的透视投影矩阵”
        // “OpenGL透视投影矩阵”
        printf("glFrustum_Mat()-----------------------------\n");
        printf(" left \tright \tbottom \ttop \tzNear \tzFar\n");
        printf(" %.2f \t%.2f  \t%.2f   \t%.2f\t%.2f  \t%.2f\n", left, right, bottom, top, zNear, zFar);
        printf("\tglProjMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", glProjMat[i*4+j]);
            }
            printf("\n");
        }
        // “利用公式计算出的透视投影矩阵”
        printf("\tfunProjMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", funProjMat[i*4+j]);
            }
            printf("\n");
        }
    }
    // glu函数:gluPerspective计算透视投影矩阵
    void gluPerspective_Mat(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
    {
        // 设定矩阵模式
        glMatrixMode(GL_PROJECTION);
        // 使当前投影矩阵为单位矩阵,免受以前投影矩阵的影响
        glLoadIdentity();
        // 调用gluPerspective投影函数
        gluPerspective(fovy, aspect, zNear, zFar);
        // 利用glGet函数获得OpenGL透视投影矩阵
        GLfloat glProjMat[16];
        glGetFloatv(GL_PROJECTION_MATRIX, glProjMat);
    
        // 利用透视投影矩阵公式计算正交投影矩阵
        GLfloat funProjMat[16];
        funProjMat[0]  =  2*zNear / (2*tan(fovy/2/180*3.1415926)*zNear*aspect);
        funProjMat[1]  =  funProjMat[2] = funProjMat[3] = 0;
        funProjMat[5]  =  2*zNear / (2*tan(fovy/2/180*3.1415926)*zNear);
        funProjMat[4]  =  funProjMat[6] = funProjMat[7] = 0;
        funProjMat[8]  = funProjMat[9]  = 0;
        funProjMat[10] = -(zFar+zNear) / (zFar-zNear);
        funProjMat[11] = -1;
        funProjMat[12] = funProjMat[13] = funProjMat[15] = 0;
        funProjMat[14] = -2*zFar*zNear / (zFar-zNear);
    
        // 控制台输出结果:比较“OpenGL透视投影矩阵”以及“利用公式计算出的透视投影矩阵”
        // “OpenGL透视投影矩阵”
        printf("gluPerspective_Mat()-----------------------------\n");
        printf(" fovy \taspect \tzNear \tzFar\n");
        printf(" %.2f \t%.2f   \t%.2f  \t%.2f\n", fovy, aspect, zNear, zFar);
        printf("\tglProjMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", glProjMat[i*4+j]);
            }
            printf("\n");
        }
        // “利用公式计算出的透视投影矩阵”
        printf("\tfunProjMat---------------------------\n");
        for(int i=0; i<4; i++)
        {
            printf("\t\t");
            for(int j=0; j<4; j++)
            {
                printf("%8.4f, ", funProjMat[i*4+j]);
            }
            printf("\n");
        }
    }
    

    展开全文
  • 正交基和标准正交基: 前言: 经过上一次线性代数学习之向量空间,维度,和四大子空间的学习,对于空间的概念已经有了非常深刻的认识了,而描述空间很重要的方式除了维度以外,那就是空间的基了,而如小标题所示...
  • 仔细观察一下这个表达式,我们不难得出向量内积与矩阵乘法之间的联系: 回顾了向量内积之后,我们就比较容易理解正交向量的定义了:若,则称与正交。 也就是说,与正交。 从这个定义出发,我们很容易得出:零...
  • 【线性代数】正交投影

    万次阅读 多人点赞 2014-11-16 18:07:28
    我们在初中就应该学过投影,那么什么是投影呢?形象点说,就是将你需要投影的东西上的每一点向你要投影的平面作垂线,垂线与平面的交点的集合就是你的投影。注意这里我们的投影是向量的...其中,P为投影矩阵,由P的表
  • 正交投影

    千次阅读 2017-07-22 12:41:37
    我们在初中就应该学过投影,那么什么是投影呢?形象点说,就是将你需要投影的东西上的每一点向你要投影的平面作垂线,垂线与平面的交点的集合就是你的投影。注意这里我们的投影是向量的...其中,P为投影矩阵,由P的表
  • 如图所示,我们通过2维来推导。 已知:向量V,投影到的平面n,n是单位向量。...我们通过矩阵的x基坐标求得x向量。 p = [1,0] p' = n * (p * n) = [nx*nx,ny*nx] 通过y 的基准坐标求的y向量 q = [0,1] q' ...
  • 一维空间的投影矩阵 先来看一维空间内向量的投影: 向量p是b在a上的投影,也称为b在a上的分量,可以用b乘以a方向的单位向量来计算,现在,我们打算尝试用更“贴近”线性代数的方式表达。 因为p趴在a上,所以p实际...
  • 二、正交投影矩阵正交投影矩阵的视锥体是一个长方体[l,r][b,t][f,n],我们要把这个长方体转换到一个正方体[-1,1][-1,1][-1,1]中,如图。 第一步平移,计算出长方体的中心点为[(l+r)/2,(b+t)/2,(f+n)/2],然后将中心...
  • 两个向量正交,就等价于上面的公式.也可以说,做一个x与y的点乘. 以下是证明 这里x的转置×y与y的转置×x是相同的,因为点乘是一个数,所以一个数的转置任然是这个数.所以从向量的勾股定理得出这个结论. 并且0向量与...
  • 对应两次变换的矩阵如下,这就是最终的正交投影矩阵 注意右边这个平移矩阵的记忆,比如(r+l)/2,结果是这个盒子中点的x坐标,如果这个坐标大于零,需要左移才能到原点;小于零,需要右移,所以才有前面的负号 4.3.2...
  • 得: 两个方程,两个未知量,可求得A与B的值 终于,所有求解工作完成,得到透视变正交矩阵 所以透视投影矩阵就等于正交投影矩阵乘以透视变正交矩阵 3、近平面的定义 定义近平面需要用到两个量,分别是fov(Field of ...
  • 示例 g = gsch(a) a := 是一个矩阵gramch(a) 创建 Gramschmidt 矩阵。 列是单位向量。 它使用两个子程序 proj.m 和 projv.m。 它们生成投影矩阵和投影向量分别
  • 【线性代数】——投影矩阵

    千次阅读 2020-12-25 11:30:50
    文章目录About 投影矩阵一维空间的投影矩阵投影矩阵的多维推广投影的物理意义信号处理中的正交投影技术 一维空间的投影矩阵   查看上图,ppp是bbb在aaa上的投影,可以发现,ppp和aaa是同向的,故可以表示为如下...
  • 矩阵论(七):投影矩阵

    万次阅读 多人点赞 2019-01-18 23:32:03
    投影矩阵 投影的定义 投影矩阵 求法 性质 投影矩阵的应用 从投影角度看广义逆 从投影角度看最小二乘 。。。 投影的定义 什么是投影?下图给出了投影的直观理解: 如图是在R3R^3R3空间中,一条直线lll与一...
  • 一.正交补与正交投影(10.3) 1.正交补 (1)概念: (2)性质: 2.正交投影 (1)概念: (2)判定: (3)最佳逼近元: 三.正交变换(10.4) 四.对称变换(10.4)
  • 也许有一个问题是正交矩阵是否可逆,但是正交矩阵符合可逆的定义,我们还找出了它的可逆矩阵,(如果这两个矩阵乘积为单位矩阵,并且是方阵,那么它们互为可逆),所以Q一定可逆,也就可以说明,正交向量一定线性无关....
  • 正交投影变换只需将相应的数据带入即可,定义正交变换矩阵 M o r t h M_{orth} Morth​如下: 3.2 透视投影变换(Perspective Projection Transformation) 透视投影就是最类似人眼所看东西的方式,遵循近大远小,如果...
  • unity里的正交投影和透视投影

    千次阅读 2018-12-18 16:44:17
    本文之前一直纠结的问题是unity里面的正交矩阵和透视矩阵中的z到底是映射到[-1,1]还是[0,1]区间。 经过验证之后,得出结论: unity里的正交和透视矩阵是将z映射到[-1,1]区间。 经过查询,知道了,opengl把z映射到...
  • 因为我这里的帖子基本上是写给自己回忆的,所以原理公式什么的就没写出来了,想了解的同学可以去看网易公开课的线性代数关于投影正交矩阵那几集 我这里给出来matlab代码,大家如果有题目要做,直接将相应的矩阵...
  • D3DXMatrixOrthoLH +正交投影矩阵

    千次阅读 2016-09-12 20:27:54
    6. D3DXMatrixOrthoLH +正交投影矩阵 #included3d9.h>#included3dx9.h>#pragma comment(lib, "d3d9.lib")#pragma comment(lib, "d3dx9.lib")#define WINDOW_CLASS "UGPDX"#define WINDOW_NAME
  • 想一下,在什么情况下可能需要将一个向量往一个子空间投影。在MIT的线代课程中,Gilbert教授给出了一种场景:即我们想要求解\(Ax=b\),但是\(b\)不在\(A\)的列空间中,此时我们希望在\(A\)的列空间中找一个离\(\...
  • OpenGL揭秘之推导正交投影变换

    千次阅读 2016-10-27 21:36:57
    在具体研究之前我觉得有必要把平面投影的分类简单介绍一下,目的是为了让大家有一个总体的认识,从而更好的理解这个知识体系。请看下图: ...平行投影可以分成侧投影和正交投影两种类型。这两种类
  • 正交投影与变换

    千次阅读 2017-12-24 21:47:49
    我的机器学习教程「美团」算法工程师带你入门机器学习 已经开始更新了,欢迎大家订阅~ 任何关于算法、编程、AI行业知识或博客内容的问题,可以随时扫码关注公众号「图灵的猫」,...在线性代数和泛函分析中,投影是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,229
精华内容 5,291
热门标签
关键字:

向量的正交投影矩阵