Gt matrix

], [ , ]]) 30 31 Using arrays wisely Array operations are implemented in C or FortranOptimised algorithms - i.e. fast! Python loops (i.e. for i in a:…) are much slower Prefer array operations over loops, especially when speed important Also produces shorter code, often more readable 32 Numpy – arrays, matricesFor two dimensional arrays NumPy defined a special matrix class in module matrix. Objects are created either with matrix() or mat() or converted from an array with method asmatrix(). >>> import numpy >>> m = numpy.mat([[1,2],[3,4]]) or >>> a = numpy.array([[1,2],[3,4]]) >>> m = numpy.mat(a) >>> m = numpy.asmatrix(a) Note that the statement m = mat(a) creates a copy of array 'a'. Changing values in 'a' will not affect 'm'. On the other hand, method m = asmatrix(a) returns a new reference to the same data. Changing values in 'a' will affect matrix 'm'. 32 33 Numpy – matrices Array and matrix operations may be quite different!>>> a = array([[1,2],[3,4]]) >>> m = mat(a) # convert 2-d array to matrix >>> m = matrix([[1, 2], [3, 4]]) >>> a[0] # result is 1-dimensional array([1, 2]) >>> m[0] # result is 2-dimensional matrix([[1, 2]]) >>> a*a # element-by-element multiplication array([[ 1, 4], [ 9, 16]]) >>> m*m # (algebraic) matrix multiplication matrix([[ 7, 10], [15, 22]]) >>> a**3 # element-wise power array([[ 1, 8], [27, 64]]) >>> m**3 # matrix multiplication m*m*m matrix([[ 37, 54], [ 81, 118]]) >>> m.T # transpose of the matrix matrix([[1, 3], [2, 4]]) >>> m.H # conjugate transpose (differs from .T for complex matrices) >>> m.I # inverse matrix matrix([[-2. , 1. ], [ 1.5, -0.5]]) 33 34 Numpy – matrices Operator *, dot(), and multiply():For array, '*' means element-wise multiplication, and the dot() function is used for matrix multiplication. For matrix, '*'means matrix

-3., 12.], [ -5., 18.]]) >>> 35 36 Numpy – array mathematics>>> A = np.array([[n+m*10 for n in range(5)] for m in range(5)]) >>> v1 = arange(0, 5) >>> A array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]]) >>> v1 array([0, 1, 2, 3, 4]) >>> np.dot(A,A) array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]]) >>> >>> np.dot(A,v1) array([ 30, 130, 230, 330, 430]) >>> np.dot(v1,v1) 30 Alternatively, we can cast the array objects to the type matrix. This changes the behavior of the standard arithmetic operators +, -, * to use matrix algebra. >>> M = np.matrix(A) >>> v = np.matrix(v1).T >>> v matrix([[0], [1], [2], [3], [4]]) >>> M*v matrix([[ 30], [130], [230], [330], [430]]) >>> v.T * v # inner product matrix([[30]]) # standard matrix algebra applies >>> v + M*v [131], [232], [333], [434]]) 36 37 Introduction to languageEnd

Multiplication, and the multiply() function is used for element-wise multiplication. Handling of vectors (rank-1 arrays) For array, the vector shapes 1xN, Nx1, and N are all different things. Operations like A[:,1] return a rank-1 array of shape N, not a rank-2 of shape Nx1. Transpose on a rank-1 array does nothing. For matrix, rank-1 arrays are always upgraded to 1xN or Nx1 matrices (row or column vectors). A[:,1] returns a rank-2 matrix of shape Nx1. Handling of higher-rank arrays (rank > 2) array objects can have rank > 2. matrix objects always have exactly rank 2. Convenience attributes array has a .T attribute, which returns the transpose of the data. matrix also has .H, .I, and .A attributes, which return the conjugate transpose, inverse, and asarray() of the matrix, respectively. Convenience constructor The array constructor takes (nested) Python sequences as initializers. As in array([[1,2,3],[4,5,6]]). The matrix constructor additionally takes a convenient string initializer. As in matrix("[1 2 3; 4 5 6]") 34 35 Numpy – array mathematics>>> a = np.array([1,2,3], float) >>> b = np.array([5,2,6], float) >>> a + b array([6., 4., 9.]) >>> a – b array([-4., 0., -3.]) >>> a * b array([5., 4., 18.]) >>> b / a array([5., 1., 2.]) >>> a % b array([1., 0., 3.]) >>> b**a array([5., 4., 216.]) >>> a = np.array([[1, 2], [3, 4], [5, 6]], float) >>> b = np.array([-1, 3], float) >>> a array([[ 1., 2.], [ 3., 4.], [ 5., 6.]]) >>> b array([-1., 3.]) array([[ 0., 5.], [ 2., 7.], [ 4., 9.]]) >>> a = np.array([[1, 2], [3, 4], [5, 6]], float) >>> b = np.array([-1, 3], float) >>> a * a array([[ 1., 4.], [ 9., 16.], [ 25., 36.]]) >>> b * b array([ 1., 9.]) >>> a * b array([[ -1., 6.], [

Function on a node. The nodeToSnap parameter is optional. If it's not specified, or is None, we use the result of nuke.thisNode() instead. The node must have an Enumeration_Knob called "snapFunc" which selects the snapping function to call. ''' if nodeToSnap is None: nodeToSnap = nuke.thisNode() # Make sure that the nodeToSnap has a snapFunc knob if "snapFunc" not in nodeToSnap.knobs(): # TODO: warn the user that we can't snap this node. return snapFunc = dict(snapFuncs)[nodeToSnap['snapFunc'].value()] snapFunc(nodeToSnap)[docs]def radians(vector) -> list: return [math.radians(x) for x in vector][docs]def degrees(vector) -> list: return [math.degrees(x) for x in vector][docs]def scalingMatrix(scalings) -> _nukemath.Matrix4: ''' Generates a scaling matrix from the input vector. @type scalings: _nukemath.Vector3 @param scalings: Vector that will be used generate the scaling matrix. @return: The scaling matrix. ''' m = _nukemath.Matrix4() m.makeIdentity() m.scaling(scalings[0], scalings[1], scalings[2]) return m[docs]def translateMatrix(translations) -> _nukemath.Matrix4: ''' Generates a translation matrix from the input vector. @type translations: _nukemath.Vector3 @param translations: Vector that will be used generate the translation matrix. @return: The translate matrix. ''' m = _nukemath.Matrix4() m.makeIdentity() m.translation(translations[0], translations[1], translations[2]) return m[docs]def rotateMatrixXYZ(rotations) -> _nukemath.Matrix4: ''' Generates a rotation XYZ matrix from the input vector. @type rotations: _nukemath.Vector3 @param rotations: Vector that will be used generate the rotate matrix. @return: The rotate matrix. ''' m = _nukemath.Matrix4() m.makeIdentity() m.rotateZ(rotations[2]) m.rotateY(rotations[1]) m.rotateX(rotations[0]) return m[docs]def rotateMatrixZXY(rotations) -> _nukemath.Matrix4: ''' Generates a rotation ZXY matrix from the input vector. @type rotations: _nukemath.Vector3 @param rotations: Vector that will be used generate the rotate matrix. @return: The rotate matrix. ''' m = _nukemath.Matrix4() m.makeIdentity() m.rotateY(rotations[1]) m.rotateX(rotations[0]) m.rotateZ(rotations[2]) return m[docs]def transformMatrix(nodeToSnap) -> _nukemath.Matrix4: ''' Generates the transformation matrix for a given node based on its knob values. @type nodeToSnap: nuke.Node @param nodeToSnap: Node from which the data will be extracted to generate its transformation matrix. @return: The matrix containg all node transformations. ''' T = translateMatrix(nodeToSnap['translate'].getValue()) R = rotateMatrixZXY(radians(nodeToSnap['rotate'].getValue())) S = scalingMatrix(nodeToSnap['scaling'].getValue()) pT = translateMatrix(nodeToSnap['pivot_translate'].getValue()) pR = rotateMatrixXYZ(radians(nodeToSnap['pivot_rotate'].getValue())) pTi = pT.inverse() pRi = pR.inverse() return pT * pR * T * R * S * pRi * pTi[docs]def translateRotatePivot(nodeToSnap, translate, rotate) -> tuple: ''' Pivot translation and rotation must keep the object stationary and in order to do that compensation values must be placed in the geometry translate and rotate. @type nodeToSnap: nuke.Node @param nodeToSnap: Node to translate and rotate @type translate: _nukemath.Vector3 @param translate: Target position for the pivot point. @type rotate: _nukemath.Vector3 @param rotate: Target rotation for the pivot point. @return: A tuple with the new geometry translation and rotation respectively (_nukemath.Vector3, _nukemath.Vector3). ''' pT = translateMatrix(translate) pTi = pT.inverse() pR = rotateMatrixXYZ(rotate) pRi = pR.inverse() S = scalingMatrix(nodeToSnap['scaling'].getValue()) Si = S.inverse() M = transformMatrix(nodeToSnap) compensatedM = pRi * pTi * M * pT * pR * Si geoTranslate = compensatedM.translation() geoRotate = degrees(compensatedM.rotationsZXY()) return (geoTranslate, geoRotate)

Getting StartedHere we learn how to render a grid in 3D, and enable multi-sample anti-aliasing (MSAA).SetupFirst create a new project using the instructions from the earlier lessons: Using DeviceResources andAdding the DirectX Tool Kit which we will use for this lesson.BackgroundIn addition to the Direct3D objects we used in Simple rendering, this tutorial makes use of 3D transformations using the SimpleMath library.Drawing a gridIn the Game.h file, add the following variables to the bottom of the Game class's private declarations (right after the m_graphicsMemory variable you already added as part of setup): m_effect;std::unique_ptr> m_batch;DirectX::SimpleMath::Matrix m_world;DirectX::SimpleMath::Matrix m_view;DirectX::SimpleMath::Matrix m_proj;">std::unique_ptr m_effect;std::unique_ptr> m_batch;DirectX::SimpleMath::Matrix m_world;DirectX::SimpleMath::Matrix m_view;DirectX::SimpleMath::Matrix m_proj;In Game.cpp, add to the TODO of CreateDeviceDependentResources after where you have created m_graphicsMemory:>(device);RenderTargetState rtState(m_deviceResources->GetBackBufferFormat(), m_deviceResources->GetDepthBufferFormat());EffectPipelineStateDescription pd( &VertexPositionColor::InputLayout, CommonStates::Opaque, CommonStates::DepthDefault, CommonStates::CullNone, rtState, D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE);m_effect = std::make_unique(device, EffectFlags::VertexColor, pd);m_world = Matrix::Identity;">m_batch = std::make_unique>(device);RenderTargetState rtState(m_deviceResources->GetBackBufferFormat(), m_deviceResources->GetDepthBufferFormat());EffectPipelineStateDescription pd( &VertexPositionColor::InputLayout, CommonStates::Opaque, CommonStates::DepthDefault, CommonStates::CullNone, rtState, D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE);m_effect = std::make_unique(device, EffectFlags::VertexColor, pd);m_world = Matrix::Identity;We are specifying an effect using lines, not the default which is triangles. More details on this, see the technical note below.In Game.cpp, add to the TODO of CreateWindowSizeDependentResources:GetOutputSize();m_view = Matrix::CreateLookAt(Vector3(2.f, 2.f, 2.f), Vector3::Zero, Vector3::UnitY);m_proj = Matrix::CreatePerspectiveFieldOfView(XM_PI / 4.f, float(size.right) / float(size.bottom), 0.1f, 10.f);m_effect->SetView(m_view);m_effect->SetProjection(m_proj);">auto size = m_deviceResources->GetOutputSize();m_view = Matrix::CreateLookAt(Vector3(2.f, 2.f, 2.f), Vector3::Zero, Vector3::UnitY);m_proj = Matrix::CreatePerspectiveFieldOfView(XM_PI / 4.f, float(size.right) / float(size.bottom), 0.1f, 10.f);m_effect->SetView(m_view);m_effect->SetProjection(m_proj);In Game.cpp, add to the TODO of OnDeviceLost where you added m_graphicsMemory.reset():m_effect.reset();m_batch.reset();In Game.cpp, add to the TODO of Render:SetWorld(m_world);m_effect->Apply(commandList);m_batch->Begin(commandList);Vector3 xaxis(2.f, 0.f, 0.f);Vector3 yaxis(0.f, 0.f, 2.f);Vector3 origin = Vector3::Zero;constexpr size_t divisions = 20;for (size_t i = 0; i DrawLine(v1, v2);}for (size_t i = 0; i DrawLine(v1, v2);}m_batch->End();">m_effect->SetWorld(m_world);m_effect->Apply(commandList);m_batch->Begin(commandList);Vector3 xaxis(2.f, 0.f, 0.f);Vector3 yaxis(0.f, 0.f, 2.f);Vector3 origin = Vector3::Zero;constexpr size_t divisions = 20;for (size_t i = 0; i float fPercent = float(i) / float(divisions); fPercent = (fPercent * 2.0f) - 1.0f; Vector3 scale = xaxis * fPercent + origin; VertexPositionColor v1(scale - yaxis, Colors::White); VertexPositionColor v2(scale + yaxis, Colors::White); m_batch->DrawLine(v1, v2);}for (size_t i = 0; i float fPercent = float(i) / float(divisions); fPercent = (fPercent * 2.0f) - 1.0f; Vector3 scale = yaxis * fPercent + origin; VertexPositionColor v1(scale - xaxis, Colors::White); VertexPositionColor v2(scale + xaxis, Colors::White); m_batch->DrawLine(v1, v2);}m_batch->End();Build and run to see a 3D grid.Technical notes: Because of the design of the Direct3D 12 pipeline state object (PSO), you'll note that you can't mix the drawing of points, lines, and triangles/quads with the same effect. Each effect is created for one of those basic primitives, meaning you need more than one pipeline state object to draw them all. Be sure to End the batch before applying a new PSO to ensure all pending draws are submitted with the proper active PSO.Anti-aliasingTaking a closer look at the grid in the previous screenshot, you can see the lines are a little thin and jagged in places. To make