## UNITY_MATRIX_IT_MV[Matrix] (转载)-程序员宅基地

http://blog.csdn.net/cubesky/article/details/38664143

 UNITY_MATRIX_IT_MV float4x4 Inverse transpose of model * view matrix.

The transpose of World2Object is the transpose of the inverse of the Object2World matrix.

• MV transforms points from object to eye space
• IT_MV rotates normals from object to eye space

And similarly:

• Object2World transforms points from object to world space
• IT_Object2World (which, as you point out, is the transpose of World2Object) rotates normals from object to world space

If it is orthogonal, the upper-left 3x3 of Object2World will be equal to that of IT_Object2World, and so will also rotate normals from object to world space.

The gl_NormalMatrix is present in many vertex shaders. In here some light is shed on what is this matrix and what is it for. This section was inspired by the excellent book by Eric Lengyel “Mathematics for 3D Game Programming and Computer Graphics”.

Many computations are done in eye space. This has to do with the fact that lighting is commonly performed in this space, otherwise eye position dependent effects, such as specular lights would be harder to implement.

Hence we need a way to transform the normal into eye space. To transform a vertex to eye space we can write:

`	vertexEyeSpace = gl_ModelViewMatrix * gl_Vertex;`

So why can’t we just do the same with a normal vector? A normal is a vector of 3 floats and the modelview matrix is 4×4. Secondly, since the normal is a vector, we only want to transform its orientation. The region of the modelview matrix that contains the orientation is the top left 3×3 submatrix. So why not multiply the normal by this submatrix?

This could be easily achieved with the following code:

`	normalEyeSpace = vec3(gl_ModelViewMatrix * vec4(gl_Normal,0.0));`

So, gl_NormalMatrix is just a shortcut to simplify code writing or to optimize it? No, not really. The above line of code will work in some circumstances but not all.

Lets have a look at a potential problem: ;

In the above figure we see a triangle, with a normal and a tangent vectors. The following figure shows what happens when the modelview matrix contains a non-uniform scale. Note: if the scale was uniform, then the direction of the normal would have been preserved, The length would have been affected but this can be easily fixed with a normalization.

In the above figure the Modelview matrix was applied to all the vertices as well as to the normal and the result is clearly wrong: the transformed normal is no longer perpendicular to the surface.

We know that a vector can be expressed as the difference between two points. Considering the tangent vector, it can be computed as the difference between the two vertices of the triangle’s edge. If $P_1$ and $P_2$ are the vertices that define the edge we know that: $T = P_2 - P_1$

Considering that a vector can be written as a four component tuple with the last component set to zero, we can multiply both sides of the equality with the Modelview matrix $T * Modelview = (P_2-P_1)* Modelview$

This results in $T * Modelview = P_2 * Modelview - P_1 * Modelview$ $T' = P_2' - P_1'$

As $P_1'$ and $P_2'$ are the vertices of the transformed triangle, $T'$ remains tangent to the edge of the triangle. Hence, the Modelview preserves tangents, yet it does not preserve normals.

Considering the same approach used for vector T, we can find two points $Q_1$ and $Q_2$ such that $N = Q_2 - Q_1$

The main issue is that the a vector defined through the transformed points, $Q_2' - Q_1'$, does not necessarily remain normal, as shown in the figures above. The normal vector is not defined as a difference between two points, as the tangent vector, it is defined as a vector which is perpendicular to a surface.

So now we know that we can’t apply the Modelview in all cases to transform the normal vector. The question is then, what matrix should we apply?

Consider a 3×3 matrix G, and lets see how this matrix could be computed to properly transform the normal vectors.

We know that, prior to the matrix transformation T.N = 0, since the vectors are by definition perpendicular. We also know that after the transformation N’.T’ must remain equal to zero, since they must remain perpendicular to each other. T can be multiplied safely by the upper left 3×3 submatrix of the modelview (T is a vector, hence the w component is zero), let’s call this submatrix M.

Let’s assume that the matrix G is the correct matrix to transform the normal vector. T. Hence the following equation: $N' . T' = (GN) . (MT) = 0$

The dot product can be transformed into a product of vectors, therefore: $(GN).(MT) = (GN)^T * (MT)$

Note that the transpose of the first vector must be considered since this is required to multiply the vectors. We also know that the transpose of a multiplication is the multiplication of the transposes, hence: $(GN)^T (MT) = N^TG^TMT$

We started by stating that the dot product between N and T was zero, so if $G^TM = I$

then we have $N'.T' = N.T = 0$

Which is exactly what we want. So we can compute G based on M. $G^TM = I \Longleftrightarrow G = (M^{-1})^T$

Therefore the correct matrix to transform the normal is the transpose of the inverse of the M matrix. OpenGL computes this for us in the gl_NormalMatrix.

In the beginning of this section it was stated that using the Modelview matrix would work in some cases. Whenever the 3×3 upper left submatrix of the Modelview is orthogonal we have: $M^{-1} = M^T \Longrightarrow G = M$

This is because with an orthogonal matrix, the transpose is the same as the inverse. So what is an orthogonal matrix? An orthogonal matrix is a matrix where all columns/rows are unit length, and are mutually perpendicular. This implies that when two vectors are multiplied by such a matrix, the angle between them after transformation by an orthogonal matrix is the same as prior to that transformation. Simply put the transformation preserves the angle relation between vectors, hence transformed normals remain perpendicular to tangents! Furthermore it preserves the length of the vectors as well.

So when can we be sure that M is orthogonal? When we limit our geometric operations to rotations and translations, i.e. when in the OpenGL application we only use glRotate and glTranslate and not glScale. These operations guarantee that M is orthogonal. Note: gluLookAt also creates an orthogonal matrix!

http://www.lighthouse3d.com/tutorials/glsl-tutorial/the-normal-matrix/

http://www.cnblogs.com/kesalin/archive/2012/12/06/3D_math.html

### 摄像头硬件，软件，光学，控制，结构知识笔记一百问--------持续更新_安防摄像头一百问--------持续更新-程序员宅基地

camera概述_安防摄像头一百问--------持续更新

### PyQT5之QInputDialog(十四)_pyqt qinputdialog setstylesheet_伊伊_f的博客-程序员宅基地

import sysfrom PyQt5.QtWidgets import QApplication,QWidget,QInputDialog,QPushButton,QLineEdit,QFormLayoutclass inputDialogDemo(QWidget): def __init__(self): super(inputDialogDemo, self).__init__() #create buttons self.butto._pyqt qinputdialog setstylesheet

### MongoDB复制集全量同步改进_mongodb全量同步-程序员宅基地

MongoDB副本集数据同步方式intial sync，可以理解为全量同步。replication，追同步源的oplog，可以理解为增量同步。下面会详细介绍MongoDB数据同步的实现原理。initial syncSecondary节点当出现如下状况时，需要先进行全量同步。oplog为空。local.replset.minvalid集合里_initialSyncFlag..._mongodb全量同步

### python安装心得_python安装心得体会-程序员宅基地

python的安装，每个版本有每个版本所对应的工具库，为了使python能安装上对应的工具库，必须慎重考虑安装python的版本。1.python的版本有如下类别：2.7版本，3.4版本，3.5版本，3.6版本32位和64位在安装某一个工具库的时候一定要提前看那个工具库的适用版本，然后选择安装的python的版本。2.在同一个电脑上可以安装不同版本的python，注意事项如下：_python安装心得体会