您的位置:时时app平台注册网站 > web前端 > Android笔记——Matrix【彩世界网址】

Android笔记——Matrix【彩世界网址】

2019-11-02 08:53

 

1.   

       在书中,小编为我们封装了风度翩翩套用于转移的矩阵对象:Matrix4对象。它满含以下三种艺术:

 

 

matrix.setRotate(45f);

  1. Matrix4.setIdentity(): 将Matrix4实例化为单位矩阵
  2. Matrix4.setTranslate(x,y,z): 将Matrix4实例设置为平移转换矩阵,在x轴平移间距为x,在y轴平移间距为y,在z轴平移间隔为z;

  3. Matrix4.setScale(x,y,z): 将Matrix4实例设置为缩放转换矩阵,缩放因子分别为x,y,z;

  4. Matrix4.setRotate(angle,x,y,z): 将Matrix4实例设置为旋调换换矩阵,角度为angle,旋转轴为(x,y,z);
  5. Matrix4.translate(x,y,z): 将Matrix4实例本身乘以两个平移转变矩阵;
  6. Matrix4.rototate(angle,x,y,z): 将Matrix4实例本人乘以三个旋转换换矩阵;
  7. Matrix4.scale(x,y,z): 将Matrix4实例自己乘以叁个缩放转变矩阵;
  8. Matrix4.set(m): 将Matrix4设置为m;
  9. Matrix4.elements: 类型化数组富含了Matrix4实例的矩阵成分;

    var modelMatrix = new Matrix4(); modelMatrix.setRotate(ANGLE,0,0,1); modelMatrix.translate(Tx,0,0);

    ... ...

    gl.uniformMatrix4fv(u_ModelMatrix,false,modelMatrix.elements);

同理,对于垂直错切,能够有:

 

彩世界网址 1

 

  1 <pre name="code" class="java">package com.pat.testtransformmatrix;  
  2   
  3 import android.app.Activity;  
  4 import android.content.Context;  
  5 import android.graphics.Bitmap;  
  6 import android.graphics.BitmapFactory;  
  7 import android.graphics.Canvas;  
  8 import android.graphics.Matrix;  
  9 import android.os.Bundle;  
 10 import android.util.Log;  
 11 import android.view.MotionEvent;  
 12 import android.view.View;  
 13 import android.view.Window;  
 14 import android.view.WindowManager;  
 15 import android.view.View.OnTouchListener;  
 16 import android.widget.ImageView;  
 17   
 18 public class TestTransformMatrixActivity extends Activity  
 19 implements  
 20 OnTouchListener  
 21 {  
 22     private TransformMatrixView view;  
 23     @Override  
 24     public void onCreate(Bundle savedInstanceState)  
 25     {  
 26         super.onCreate(savedInstanceState);  
 27         requestWindowFeature(Window.FEATURE_NO_TITLE);  
 28         this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);  
 29   
 30         view = new TransformMatrixView(this);  
 31         view.setScaleType(ImageView.ScaleType.MATRIX);  
 32         view.setOnTouchListener(this);  
 33           
 34         setContentView(view);  
 35     }  
 36       
 37     class TransformMatrixView extends ImageView  
 38     {  
 39         private Bitmap bitmap;  
 40         private Matrix matrix;  
 41         public TransformMatrixView(Context context)  
 42         {  
 43             super(context);  
 44             bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sophie);  
 45             matrix = new Matrix();  
 46         }  
 47   
 48         @Override  
 49         protected void onDraw(Canvas canvas)  
 50         {  
 51             // 画出原图像  
 52             canvas.drawBitmap(bitmap, 0, 0, null);  
 53             // 画出变换后的图像  
 54             canvas.drawBitmap(bitmap, matrix, null);  
 55             super.onDraw(canvas);  
 56         }  
 57   
 58         @Override  
 59         public void setImageMatrix(Matrix matrix)  
 60         {  
 61             this.matrix.set(matrix);  
 62             super.setImageMatrix(matrix);  
 63         }  
 64           
 65         public Bitmap getImageBitmap()  
 66         {  
 67             return bitmap;  
 68         }  
 69     }  
 70   
 71     public boolean onTouch(View v, MotionEvent e)  
 72     {  
 73         if(e.getAction() == MotionEvent.ACTION_UP)  
 74         {  
 75             Matrix matrix = new Matrix();  
 76             // 输出图像的宽度和高度(162 x 251)  
 77             Log.e("TestTransformMatrixActivity", "image size: width x height = "    view.getImageBitmap().getWidth()   " x "   view.getImageBitmap().getHeight());  
 78             // 1. 平移  
 79             matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());  
 80             // 在x方向平移view.getImageBitmap().getWidth(),在y轴方向view.getImageBitmap().getHeight()  
 81             view.setImageMatrix(matrix);  
 82               
 83             // 下面的代码是为了查看matrix中的元素  
 84             float[] matrixValues = new float[9];  
 85             matrix.getValues(matrixValues);  
 86             for(int i = 0; i < 3;   i)  
 87             {  
 88                 String temp = new String();  
 89                 for(int j = 0; j < 3;   j)  
 90                 {  
 91                     temp  = matrixValues[3 * i   j ]   "t";  
 92                 }  
 93                 Log.e("TestTransformMatrixActivity", temp);  
 94             }  
 95               
 96   
 97 //          // 2. 旋转(围绕图像的中心点)  
 98 //          matrix.setRotate(45f, view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);  
 99 //            
100 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠  
101 //          matrix.postTranslate(view.getImageBitmap().getWidth() * 1.5f, 0f);  
102 //          view.setImageMatrix(matrix);  
103 //  
104 //          // 下面的代码是为了查看matrix中的元素  
105 //          float[] matrixValues = new float[9];  
106 //          matrix.getValues(matrixValues);  
107 //          for(int i = 0; i < 3;   i)  
108 //          {  
109 //              String temp = new String();  
110 //              for(int j = 0; j < 3;   j)  
111 //              {  
112 //                  temp  = matrixValues[3 * i   j ]   "t";  
113 //              }  
114 //              Log.e("TestTransformMatrixActivity", temp);  
115 //          }  
116               
117               
118 //          // 3. 旋转(围绕坐标原点)   平移(效果同2)  
119 //          matrix.setRotate(45f);  
120 //          matrix.preTranslate(-1f * view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight() / 2f);  
121 //          matrix.postTranslate((float)view.getImageBitmap().getWidth() / 2f, (float)view.getImageBitmap().getHeight() / 2f);  
122 //            
123 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠  
124 //          matrix.postTranslate((float)view.getImageBitmap().getWidth() * 1.5f, 0f);  
125 //          view.setImageMatrix(matrix);  
126 //            
127 //          // 下面的代码是为了查看matrix中的元素  
128 //          float[] matrixValues = new float[9];  
129 //          matrix.getValues(matrixValues);  
130 //          for(int i = 0; i < 3;   i)  
131 //          {  
132 //              String temp = new String();  
133 //              for(int j = 0; j < 3;   j)  
134 //              {  
135 //                  temp  = matrixValues[3 * i   j ]   "t";  
136 //              }  
137 //              Log.e("TestTransformMatrixActivity", temp);  
138 //          }             
139               
140 //          // 4. 缩放  
141 //          matrix.setScale(2f, 2f);  
142 //          // 下面的代码是为了查看matrix中的元素  
143 //          float[] matrixValues = new float[9];  
144 //          matrix.getValues(matrixValues);  
145 //          for(int i = 0; i < 3;   i)  
146 //          {  
147 //              String temp = new String();  
148 //              for(int j = 0; j < 3;   j)  
149 //              {  
150 //                  temp  = matrixValues[3 * i   j ]   "t";  
151 //              }  
152 //              Log.e("TestTransformMatrixActivity", temp);  
153 //          }  
154 //            
155 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠  
156 //          matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());  
157 //          view.setImageMatrix(matrix);  
158 //            
159 //          // 下面的代码是为了查看matrix中的元素  
160 //          matrixValues = new float[9];  
161 //          matrix.getValues(matrixValues);  
162 //          for(int i = 0; i < 3;   i)  
163 //          {  
164 //              String temp = new String();  
165 //              for(int j = 0; j < 3;   j)  
166 //              {  
167 //                  temp  = matrixValues[3 * i   j ]   "t";  
168 //              }  
169 //              Log.e("TestTransformMatrixActivity", temp);  
170 //          }  
171   
172               
173 //          // 5. 错切 - 水平  
174 //          matrix.setSkew(0.5f, 0f);  
175 //          // 下面的代码是为了查看matrix中的元素  
176 //          float[] matrixValues = new float[9];  
177 //          matrix.getValues(matrixValues);  
178 //          for(int i = 0; i < 3;   i)  
179 //          {  
180 //              String temp = new String();  
181 //              for(int j = 0; j < 3;   j)  
182 //              {  
183 //                  temp  = matrixValues[3 * i   j ]   "t";  
184 //              }  
185 //              Log.e("TestTransformMatrixActivity", temp);  
186 //          }  
187 //            
188 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠           
189 //          matrix.postTranslate(view.getImageBitmap().getWidth(), 0f);  
190 //          view.setImageMatrix(matrix);  
191 //            
192 //          // 下面的代码是为了查看matrix中的元素  
193 //          matrixValues = new float[9];  
194 //          matrix.getValues(matrixValues);  
195 //          for(int i = 0; i < 3;   i)  
196 //          {  
197 //              String temp = new String();  
198 //              for(int j = 0; j < 3;   j)  
199 //              {  
200 //                  temp  = matrixValues[3 * i   j ]   "t";  
201 //              }  
202 //              Log.e("TestTransformMatrixActivity", temp);  
203 //          }  
204               
205 //          // 6. 错切 - 垂直  
206 //          matrix.setSkew(0f, 0.5f);  
207 //          // 下面的代码是为了查看matrix中的元素  
208 //          float[] matrixValues = new float[9];  
209 //          matrix.getValues(matrixValues);  
210 //          for(int i = 0; i < 3;   i)  
211 //          {  
212 //              String temp = new String();  
213 //              for(int j = 0; j < 3;   j)  
214 //              {  
215 //                  temp  = matrixValues[3 * i   j ]   "t";  
216 //              }  
217 //              Log.e("TestTransformMatrixActivity", temp);  
218 //          }  
219 //            
220 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠               
221 //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());  
222 //          view.setImageMatrix(matrix);  
223 //            
224 //          // 下面的代码是为了查看matrix中的元素  
225 //          matrixValues = new float[9];  
226 //          matrix.getValues(matrixValues);  
227 //          for(int i = 0; i < 3;   i)  
228 //          {  
229 //              String temp = new String();  
230 //              for(int j = 0; j < 3;   j)  
231 //              {  
232 //                  temp  = matrixValues[3 * i   j ]   "t";  
233 //              }  
234 //              Log.e("TestTransformMatrixActivity", temp);  
235 //          }             
236               
237 //          7. 错切 - 水平   垂直  
238 //          matrix.setSkew(0.5f, 0.5f);  
239 //          // 下面的代码是为了查看matrix中的元素  
240 //          float[] matrixValues = new float[9];  
241 //          matrix.getValues(matrixValues);  
242 //          for(int i = 0; i < 3;   i)  
243 //          {  
244 //              String temp = new String();  
245 //              for(int j = 0; j < 3;   j)  
246 //              {  
247 //                  temp  = matrixValues[3 * i   j ]   "t";  
248 //              }  
249 //              Log.e("TestTransformMatrixActivity", temp);  
250 //          }  
251 //            
252 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠               
253 //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());  
254 //          view.setImageMatrix(matrix);  
255 //            
256 //          // 下面的代码是为了查看matrix中的元素  
257 //          matrixValues = new float[9];  
258 //          matrix.getValues(matrixValues);  
259 //          for(int i = 0; i < 3;   i)  
260 //          {  
261 //              String temp = new String();  
262 //              for(int j = 0; j < 3;   j)  
263 //              {  
264 //                  temp  = matrixValues[3 * i   j ]   "t";  
265 //              }  
266 //              Log.e("TestTransformMatrixActivity", temp);  
267 //          }  
268               
269 //          // 8. 对称 (水平对称)  
270 //          float matrix_values[] = {1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f};  
271 //          matrix.setValues(matrix_values);  
272 //          // 下面的代码是为了查看matrix中的元素  
273 //          float[] matrixValues = new float[9];  
274 //          matrix.getValues(matrixValues);  
275 //          for(int i = 0; i < 3;   i)  
276 //          {  
277 //              String temp = new String();  
278 //              for(int j = 0; j < 3;   j)  
279 //              {  
280 //                  temp  = matrixValues[3 * i   j ]   "t";  
281 //              }  
282 //              Log.e("TestTransformMatrixActivity", temp);  
283 //          }  
284 //            
285 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠   
286 //          matrix.postTranslate(0f, view.getImageBitmap().getHeight() * 2f);  
287 //          view.setImageMatrix(matrix);  
288 //            
289 //          // 下面的代码是为了查看matrix中的元素  
290 //          matrixValues = new float[9];  
291 //          matrix.getValues(matrixValues);  
292 //          for(int i = 0; i < 3;   i)  
293 //          {  
294 //              String temp = new String();  
295 //              for(int j = 0; j < 3;   j)  
296 //              {  
297 //                  temp  = matrixValues[3 * i   j ]   "t";  
298 //              }  
299 //              Log.e("TestTransformMatrixActivity", temp);  
300 //          }             
301               
302 //          // 9. 对称 - 垂直  
303 //          float matrix_values[] = {-1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f};  
304 //          matrix.setValues(matrix_values);  
305 //          // 下面的代码是为了查看matrix中的元素  
306 //          float[] matrixValues = new float[9];  
307 //          matrix.getValues(matrixValues);  
308 //          for(int i = 0; i < 3;   i)  
309 //          {  
310 //              String temp = new String();  
311 //              for(int j = 0; j < 3;   j)  
312 //              {  
313 //                  temp  = matrixValues[3 * i   j ]   "t";  
314 //              }  
315 //              Log.e("TestTransformMatrixActivity", temp);  
316 //          }     
317 //            
318 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠   
319 //          matrix.postTranslate(view.getImageBitmap().getWidth() * 2f, 0f);  
320 //          view.setImageMatrix(matrix);  
321 //            
322 //          // 下面的代码是为了查看matrix中的元素  
323 //          matrixValues = new float[9];  
324 //          matrix.getValues(matrixValues);  
325 //          for(int i = 0; i < 3;   i)  
326 //          {  
327 //              String temp = new String();  
328 //              for(int j = 0; j < 3;   j)  
329 //              {  
330 //                  temp  = matrixValues[3 * i   j ]   "t";  
331 //              }  
332 //              Log.e("TestTransformMatrixActivity", temp);  
333 //          }  
334   
335               
336 //          // 10. 对称(对称轴为直线y = x)  
337 //          float matrix_values[] = {0f, -1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f};  
338 //          matrix.setValues(matrix_values);  
339 //          // 下面的代码是为了查看matrix中的元素  
340 //          float[] matrixValues = new float[9];  
341 //          matrix.getValues(matrixValues);  
342 //          for(int i = 0; i < 3;   i)  
343 //          {  
344 //              String temp = new String();  
345 //              for(int j = 0; j < 3;   j)  
346 //              {  
347 //                  temp  = matrixValues[3 * i   j ]   "t";  
348 //              }  
349 //              Log.e("TestTransformMatrixActivity", temp);  
350 //          }  
351 //            
352 //          // 做下面的平移变换,纯粹是为了让变换后的图像和原图像不重叠               
353 //          matrix.postTranslate(view.getImageBitmap().getHeight()   view.getImageBitmap().getWidth(),   
354 //                  view.getImageBitmap().getHeight()   view.getImageBitmap().getWidth());  
355 //          view.setImageMatrix(matrix);  
356 //            
357 //          // 下面的代码是为了查看matrix中的元素  
358 //          matrixValues = new float[9];  
359 //          matrix.getValues(matrixValues);  
360 //          for(int i = 0; i < 3;   i)  
361 //          {  
362 //              String temp = new String();  
363 //              for(int j = 0; j < 3;   j)  
364 //              {  
365 //                  temp  = matrixValues[3 * i   j ]   "t";  
366 //              }  
367 //              Log.e("TestTransformMatrixActivity", temp);  
368 //          }  
369               
370             view.invalidate();  
371         }  
372         return true;  
373     }  
374 }  

     下一周天继续立异第五章。

除平移转换(Translate)外,旋调换换(Rotate)、缩放转变(Scale)和错切转变(Skew)都能够围绕叁个中坚点来开展,借使不点名,在默许情状下是围绕(0, 0)来扩充对应的转移的。

var g_last = Date.now();
function animate(angle) {
  // Calculate the elapsed time
  var now = Date.now();
  var elapsed = now - g_last;
  g_last = now;
  // Update the current rotation angle (adjusted by the elapsed time)
  var newAngle = angle   ANGLE_STEP * (elapsed / 1000.0);
  return newAngle %= 360;
}

 

         Example2: 动画

彩世界网址 2

      ** Example1: 复合转换
**

里头首个矩阵,其实是下边多少个矩阵相乘的结果:

 requestAnimationFrame(func): 哀告浏览器在几这段日子某时刻回调函数func以成就重绘。我们应该在回调函数最终重复发起该央求。

彩世界网址 3

是因为浏览器试行Tick()的岁月是不可控的,大家供给让三角匀速的旋转,那么就必要调整时间:

彩世界网址 4

二、正文

彩世界网址 5

var tick = function() {
    currentAngle = animate(currentAngle);  // Update the rotation angle
    draw(gl, n, currentAngle, modelMatrix, u_ModelMatrix);   // Draw the triangle
    requestAnimationFrame(tick, canvas); // Request that the browser calls tick
};
tick();

彩世界网址 6

      几眼下继续第四章的读书内容,开端读书复合转换的学识。

从字面上明白,矩阵中的MSCALE用于拍卖缩放转变,MSKEW用于拍卖错切转换,MTRANS用于拍卖平移转变,MPE牧马人SP用于拍卖透视调换。实际中本来不能够完全依照字面上的传教去领略Matrix。同一时间,在Android的文档中,未看见用Matrix举办透视转换的有关注脚,所以本文也不商讨那下边的标题。

一、前言

彩世界网址 7 

三、结尾

世家能够相比第一片段中的“五、对称转变”和“生龙活虎、平移调换”的相关说法,自行验证结果。

 

风流倜傥经对称轴是x轴,难么,

  彩世界网址 8是将坐标原点移动到点彩世界网址 9后,彩世界网址 10 的新坐标。

彩世界网址 11

matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);

缩放转换比较好精晓,就相当少说了。

很显然,

除却上面讲到的4中着力转移外,事实上,我们还能运用Matrix,进行对称转变。所谓对称转变,就是透过变化后的图像和原图疑似关于某些对称轴是对称的。譬喻,某点彩世界网址 12 经过对称调换后猎取彩世界网址 13

用矩阵表示正是:

彩世界网址 14

matrix.postTranslate((float)view.getImageBitmap().getWidth()/ 2f, (float)view.getImageBitmap().getHeight() / 2f)对应的矩阵是:

彩世界网址 15

内部,前者是底下五个矩阵相乘的结果:

要是用矩阵,就足以代表为:

彩世界网址 16

 

 

等价于

彩世界网址 17

matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f *view.getImageBitmap().getHeight() / 2f);

彩世界网址 18

彩世界网址 19

越左近原图像中像素的矩阵,越先乘,越远隔原图像中像素的矩阵,越后乘。事实上,图像管理时,矩阵的运算是从侧边往侧面方向进行演算的。那就形成了越在左侧的矩阵(右乘),越先运算(先乘),反之亦然。

那么,

Matrix的对图像的拍卖可分为四类基本转移:

 

彩世界网址 20

彩世界网址 21

Matrix的数学原理

用矩阵表示就是:

在第一片段中讲到的各样图像调换的印证代码如下,一共列出了10种景况。假诺要注解个中的某生龙活虎种情状,只需将相应的代码反注释就能够。试验中用到的图片:

10.   对称转换(对称轴为直线y = x)

鉴于是preTranslate,是先乘,也正是右乘,即它应当出今后matrix.setRotate(45f)所对应矩阵的侧边。

Scale                  缩放调换

5.     错切转变(水平错切)

五、 对称转变

彩世界网址 22 

举个例子下图,各点的y坐标保持不改变,但其x坐标则按百分比产生了活动。这种场馆将水平错切。

matrix.setRotate(45f);

彩世界网址 23 

代码所出口的三个矩阵分别是:

万风流洒脱有贰个点彩世界网址 24 ,相对坐标原点顺时针旋转彩世界网址 25后的情事,同一时候假使P点离坐标原点的离开为r,如下图:

在数学上严苛的错切调换正是下边那样的。在Android中除了有地点聊起的气象外,还足以并且进行水平、垂直错切,那么方式上正是:

反对上来说,三个点是不设有何缩放调换的,但挂念到具备图像都以由点组成,因而,借使图像在x轴和y轴方向分别放大k1k2倍的话,那么图像中的全部一点的x坐标和y坐标均会分别放大k1k2倍,即

Translate           平移调换

假诺有贰个点的坐标是彩世界网址 26 ,将其移动到彩世界网址 27 ,再假定在x轴和y轴方向运动的尺寸分别为:

 

那和底下那些矩阵(围绕图像中央顺时针旋转45度)其实是风华正茂致的:

用矩阵表示就是:

2.     

 

关于对称轴为y = kx y = kx b的情况,相仿要求思虑那方面包车型客车主题材料。

set用于安装Matrix中的值。

彩世界网址 28

彩世界网址 29

彩世界网址 30

彩世界网址 31

彩世界网址 32

 

 

其尺寸为162 x 251。

 彩世界网址 33

 

常常来讲图所示:

十分轻巧可解得:

代码所出口的三个矩阵分别是:

本来,在实际上中,如若首先钦命了八个matrix,举例大家先setRotate(彩世界网址 34),即内定了地点转变矩阵中,中间的可怜矩阵,那么继续的矩阵到底是pre如故post运算,都以绝对那些当中矩阵来说的。

彩世界网址 35

代码所出口的五个矩阵分别是:

遵照第一片段中“二、旋转换换”里面关于围绕某点旋转的解说,简单精通:

彩世界网址 36

 

pre是先乘,因为矩阵的乘法不满意交流律,由此先乘、后乘一定要严加不同。先乘相当于矩阵运算中的右乘。

 

彩世界网址 37 

彩世界网址 38

优秀地,如若对称轴是y = kx,如下图:

彩世界网址 39

这两条语句综合效应的结果。依照第一片段中“二、旋转换换”里面关于围绕某点旋转的公式,

转自:

彩世界网址 40

假定用矩阵来代表的话,就能够写成:

世家能够对照第大器晚成有的中的“三、缩放转换”和“黄金时代、平移转换”说法,自行验证结果。

彩世界网址 41 

彩世界网址 42

当中,首个矩阵其实是底下三个矩阵相乘的结果:

对应的矩阵正是:

matrix.postTranslate(view.getImageBitmap().getWidth()* 1.5f, 0f);

彩世界网址 43

彩世界网址 44

彩世界网址 45

所以综合起来,

此番是因为是postTranslate,是后乘,也正是左乘,即它应有出现在matrix.setRotate(45f)所对应矩阵的左侧。

彩世界网址 46

 

彩世界网址 47

3.     旋转(围绕坐标原点旋转,在抬高三遍活动,效果同2)

 

故此,围绕某一点展开旋调换换,能够分为3个步骤,即首先将坐标原点移至该点,然后围绕新的坐标原点进行旋调换换,再然后将坐标原点移回到原本的坐标原点。

彩世界网址 48

急需非常注意:在骨子里编程中,大家精晓显示屏的y坐标的正向和数学中y坐标的正向刚巧是倒转的,所以在数学上y = x和屏幕上的y = -x才是的确的同贰个东西,反之亦然。也正是说,假使要使图片在显示屏上看起来像根据数学意义上y = x对称,那么需利用这种转移:

彩世界网址 49

错切调换(skew)在数学上又称作Shear mapping(可译为“剪切转换”)大概Transvection(缩并),它是意气风发种相比较特出的线性别变化换。错切调换的职能就是让全数一点的x坐标(或者y坐标)保持不改变,而相应的y坐标(或者x坐标)则按百分比暴发位移,且活动的轻重和该点到x轴(或y轴)的垂直间距成正比。错切转变,属于等面积调换,即一个形态在错切调换的光景,其面积是特别的。

彩世界网址 50

彩世界网址 51

彩世界网址 52 

matrix.postTranslate((float)view.getImageBitmap().getWidth()/ 2f, (float)view.getImageBitmap().getHeight() / 2f);

三、 缩放调换

世家能够对照第一片段中的“四、错切转变”和“后生可畏、平移调换”的相关说法,自行验证结果。

世家能够对照第风流倜傥部分中的“五、对称转变”和“生机勃勃、平移调换”的相干说法,自行验证结果。

简易知道:

 

彩世界网址 53

而matrix.postTranslate(view.getImageBitmap().getWidth()* 1.5f, 0f);的意味就是在上述矩阵的左侧再乘以上面包车型地铁矩阵:

彩世界网址 54

是将上一步调换后的彩世界网址 55,围绕新的坐标原点顺时针旋转彩世界网址 56 。

matrix.postTranslate((float)view.getImageBitmap().getWidth()/ 2f, (float)view.getImageBitmap().getHeight() / 2f);

彩世界网址 57

大家可以对照第意气风发某个中的“四、错切调换”和“风姿浪漫、平移转换”的有关说法,自行验证结果。

 

上面大家来看看多种转移的切实情状。由于具有的图形都以有一些组成,因而我们只须要考查一个点有关转变就可以。

彩世界网址 58

彩世界网址 59

于是它实在就是:

代码所出口的几个各矩阵分别是:

彩世界网址 60

假设对称轴是y轴,那么,

代码所出口的八个矩阵分别是:

用矩阵表示正是:

 

在Android中,假如你用Matrix举办过图像管理,那么鲜明知道Matrix这些类。Android中的Matrix是多个3 x 3的矩阵,其内容如下:

 

6.     错切转换(垂直错切)

鉴于矩阵的乘法运算不满足调换律,大家在日前已经数十次聊到先乘、后乘的主题素材,即先乘正是矩阵运算中右乘,后乘正是矩阵运算中的左乘。其实先乘、后乘的概念是对准转变操作的日子顺序来讲的,左乘、右乘是本着矩阵运算的左右义务来说的。以第生龙活虎局地“二、旋调换换”中围绕某点旋转的景观为例:

matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);

它其实是

我们能够对照第大器晚成有个别中的“四、错切转变”和“后生可畏、平移调换”的连带说法,自行验证结果。

k = 0时,即y = 0,也便是对称轴为x轴的景观;当k趋于无穷大时,即x = 0,也正是对称轴为y轴的事态;当k =1时,即y = x,也正是对称轴为y = x的情况;当k = -1时,即y = -x,相当于对称轴为y = -x的动静。轻巧验证,那和我们日前聊到的4中具体情形是相吻合的。

3.     

在那之中,前面一个是底下三个矩阵相乘的结果:

彩世界网址 61

Skew                  错切转换

用矩阵表示正是:

其尺寸为162 x 251。

世家可以对照第大器晚成部分中的“五、对称调换”和“黄金时代、平移转变”的相干说法,自行验证结果。

8.     对称转变(水平对称)

彩世界网址 62

所发出的退换矩阵便是:

matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight()/ 2f)对应的矩阵是:

其间,第贰个矩阵其实是底下七个矩阵相乘的结果:

彩世界网址 63

一直以来的道理,假诺对称轴是y = -x,那么用矩阵表示就是:

上边给出上述代码中,各样变换的切实结果及其对应的连带转变矩阵

 

代码所出口的多个矩阵分别是:

彩世界网址 64

彩世界网址 65

2.1    围绕坐标原点旋转:

能够形成:

9.     对称变换(垂直对称)

那么,

其次部分 代码验证

有关post是左乘那或多或少,咱们在前头的申辩部分已经聊起过,后边大家还也许会特地探究这几个标题。

彩世界网址 66

Rotate                旋调换换

 

下图各点的x坐标保持不改变,但其y坐标则按比例发生了运动。这种情景叫垂直错切。

 

因此上一步旋调换换后,再将坐标原点移回到原来的坐标原点。

彩世界网址 67

出来计算上的精度基值误差,大家可以见到我们总计出来的结果,和程序直接出口的结果是同意气风发的。

彩世界网址 68

彩世界网址 69

内部matrix.setRotate(45f)对应的矩阵是:

比较轻巧能够解得:

 

post是后乘,因为矩阵的乘法不满足交换律,因而先乘、后乘应当要严苛区分。后乘约等于矩阵运算中的左乘。

那么,

matrix.setRotate(45f,view.getImageBitmap().getWidth() / 2f, view.getImageBitmap().getHeight() / 2f);

要是四个点彩世界网址 70经过错切转变后拿走彩世界网址 71,对于水平错切来讲,应该犹如下事关:

之所以,此处调换后的图像和第22中学纠正后的图像时相像的。

 

本着每一个调换,Android提供了pre、set和post三种操作办法。此中

二、 旋调换换

彩世界网址 72

输出的结果:

11.   关于先乘和后乘的标题

 

万风姿罗曼蒂克对称轴是y = x,如图:

要使图片在显示屏上看起来像依照数学意义上y = -x对称,那么需选取这种转移:
彩世界网址 73 

扩充到3 x 3的矩阵就是上面那样的款型:

彩世界网址 74 

 

彩世界网址 75

出口的结果:

彩世界网址 76 

用矩阵表示就是:

其间,后面一个是上边八个矩阵相乘的结果:

2.     旋转(围绕图像的中央点)

彩世界网址 77

4.     缩放转变

程序所出口的八个矩阵分别是:

7.     错切调换(水平 垂直错切)

四、 错切转变

 

matrix.preTranslate(-1f* view.getImageBitmap().getWidth() / 2f, -1f *view.getImageBitmap().getHeight() / 2f);

 

请对照第生龙活虎部分中的“一、平移转变”所讲的动静,考察上述矩阵的不易。

彩世界网址 78

彩世界网址 79

1.     平移

彩世界网址 80

彩世界网址 81

彩世界网址 82

举例是围绕有些点彩世界网址 83顺时针旋转彩世界网址 84,那么可以用矩阵表示为:

假使对称轴是y = kx b那样的情景,只需求在上头的根底上加码三遍平移转换即可,即先将坐标原点移动到(0, b),然后做地点的有关y = kx的裁长补短转变,再然后将坐标原点移回到原本的坐标原点就能够。用矩阵表示大约是那般的:

彩世界网址 85

黄金时代、 平移调换

2.2    围绕有些点旋转

彩世界网址 86

彩世界网址 87 

彩世界网址 88

彩世界网址 89 

 

里头,前面一个是上面五个矩阵相乘的结果:

彩世界网址 90

本文由时时app平台注册网站发布于web前端,转载请注明出处:Android笔记——Matrix【彩世界网址】

关键词: