Android Development notes -- matrix transformation

 

I. first introduce the Scale Control

Scale is scaling. We call setscale, prescale, and postscale of Matrix. Actually, it is implemented by modifying mscale_x and mscale_y.

The following is a simple example.

2. Public ClassMatrixtestactivityExtendsActivity {
4. Private IntScreenwidth;
6. Private IntScreenheight;
8. Private IntBitmapwidth;
10. Private IntBitmapheight;
12. Private FloatBasescale;
14. Private FloatOriginalscale;
18. @ Override
20. Public VoidOncreate (bundle savedinstancestate ){
22. Super. Oncreate (savedinstancestate );
24. Setcontentview (R. layout. Main );
26. // Obtain the screen width and height
28. Screenwidth = getwindow (). getwindowmanager (). getdefadisplay display (). getwidth ();
30. Screenheight = getwindow (). getwindowmanager (). getdefadisplay display (). getheight ();
32. // Load the imageview and obtain the image information
34. FinalImageview = (imageview) findviewbyid (R. Id. imgview );
36. FinalBitmap bitmap = bitmapfactory. decoderesource (getresources (), R. drawable. );
38. Bitmapwidth = bitmap. getwidth ();
40. Bitmapheight = bitmap. getheight ();
44. // Calculate the zoom ratio, because if the image size exceeds the screen size, it will be automatically matched to the screen size for display.
46. // Then, we do not know the width and height of the image displayed on the screen. Therefore, we need to calculate the zoom ratio of all the images displayed first,
48. // Calculate the actual width and height of the image display, and then perform the next step of scaling.
50. // Otherwise, it will lead to reduced or Amplified effects, or memory leakage, etc.
52. FloatScalex = screenwidth /(Float) Bitmapwidth;
54. FloatScaley = screenheight /(Float) Bitmapheight;
56. Basescale = math. Min (scalex, scaley );// Obtain the largest scaling ratio, that is, the one in scalex and scaley.
58. Originalscale = basescale;
62. FinalMatrix matrix =NewMatrix ();
64. Matrix. setscale (originalscale, originalscale );
66. // The difference between setscale and prescale and postscale will be discussed later
68. // Matrix. prescale (originalscale, originalscale );
70. // Matrix. postscale (originalscale, originalscale );
72. Bitmap bitmap2 = bitmap
74. . Createbitmap (bitmap,0,0, Bitmapwidth, bitmapheight, matrix,False);
76. Imageview. setimagebitmap (bitmap2 );
80. FinalButton scale_btn = (button) findviewbyid (R. Id. scale_btn );
82. FinalEdittext scale_text = (edittext) findviewbyid (R. Id. scale_editview );
84. Scale_btn.setonclicklistener (NewView. onclicklistener (){
86. Public VoidOnclick (view v ){
88. String scalestr = scale_text.gettext (). tostring ();
90. If(Scalestr =Null|"". Equals (scalestr ))
92. Return;
94. FloatScale =0. 0f;
96. Try{
98. Scale = float. parsefloat (scalestr );
100. }Catch(Numberformatexception e ){
102. Return;
104. }
106. Matrix. Reset ();
108. Originalscale = scale * originalscale;// View
110. If(Originalscale <0.05){
112. Originalscale =0. 05f;
114. }
116. If(Originalscale> basescale ){
118. Originalscale = basescale;
120. }
122. Matrix. setscale (originalscale, originalscale );
124. Bitmap bitmapchange = bitmap. createbitmap (bitmap,0,0, Bitmapwidth, bitmapheight,
126. Matrix,False);
128. Imageview. setimagebitmap (bitmapchange );
130. }
132. });
134. }
136. }

It can be found that for the scale setting, matrix provides different methods in 3 to set.

Setscale, prescale, and postscale.

What are the differences between the three methods? See the following.

 

Ii. Differences between set..., pre..., post...

1. setscale (sx, Sy): First, it sets the Matrix to a diagonal matrix, that is, it is equivalent to calling the reset () method, then, set mscale_x and mscale_y of the Matrix to SX and SY values.

2. prescale (sx, Sy). Instead of resetting the matrix, it is directly combined (multiplied) with the mscale_x and mscale_y values before the matrix, M' = m * s (sx, sy ).

3. postscale (sx, Sy). Instead of resetting the matrix, it is directly combined (multiplied) with the mscale_x and mscale_y values before the matrix, M' = S (sx, SY) * m.

Prescale and post are both combined with the previous matrix. What is the difference between them?

Let's take a few examples to test the differences between pre... and post:

Set a matrix as follows:

1. execution sequence of pre...

2. Matrix matrix =NewMatrix ();
4. Float[] Points =New Float[] {10. 0f,10. 0f };
8. Matrix. prescale (2. 0f,3. 0f );//
10. Matrix. pretranslate (8. 0f,7. 0f );//
12. Matrix. mappoints (points );
14. Log. I ("Test", Points [0] +"");
16. Log. I ("Test", Points [1] +"");

The result is the coordinate (36.0, 51.0)

It can be concluded that the order of transformation is to execute pretranslate (8.0f, 7.0f) first, and execute prescale (2.0f, 3.0f) in the execution ). This is why some people say that pre... is backward-growing, that is, in the setting of a matrix,

All pre... is executed backwards.

 

2. execution sequence of post...

2. Matrix matrix =NewMatrix ();
4. Float[] Points =New Float[] {10. 0f,10. 0f };
8. Matrix. postscale (2. 0f,3. 0f );//
10. Matrix. posttranslate (8. 0f,7. 0f );//
12. Matrix. mappoints (points );
14. Log. I ("Test", Points [0] +"");
16. Log. I ("Test", Points [1] +"");

The result is the coordinate (28.0, 37.0)

It can be concluded that the order of transformation is to first execute postscale (2.0f, 3.0f) and then execute posttranslate (8.0f, 7.0f ). This is why some people refer to post... as a forward growth, that is, all post... is executed along the forward in a matrix setting.

 

3. execution sequence when pre and post Alternate

2. Matrix matrix =NewMatrix ();
4. Float[] Points =New Float[] {10. 0f,10. 0f };
8. Matrix. postscale (2. 0f,3. 0f );
10. Matrix. prerotate (90);
12. Matrix. mappoints (points );
14. Log. I ("Test", Points [0] +"");
16. Log. I ("Test", Points [1] +"");

The result is the coordinate of (-20.0, 30.0)

Change the order of pre... and post.

2. Matrix matrix =NewMatrix ();
4. Float[] Points =New Float[] {10. 0f,10. 0f };
8. Matrix. prerotate (90);
10. Matrix. postscale (2. 0f,3. 0f );
12. Matrix. mappoints (points );
14. Log. I ("Test", Points [0] +"");
16. Log. I ("Test", Points [1] +"");

The result is that the coordinate is still (-20.0, 30.0)

It can be seen that pre is always executed first. See the following:

2. Matrix matrix =NewMatrix ();
4. Float[] Points =New Float[] {10. 0f,10. 0f };
8. Matrix. postscale (2. 0f,3. 0f );// Step 2
10. Matrix. prerotate (90);// Step 2
12. Matrix. posttranslate (8. 0f,7. 0f );// Step 2
14. Matrix. prescale (1. 5f,2. 5f );// Step 2
16. Matrix. mappoints (points );
18. Log. I ("Test", Points [0] +"");
20. Log. I ("Test", Points [1] +"");

The result is that the coordinate is still (-42.0, 52.0)
After the previous conclusions and calculations, we can find that the execution sequence is 4----2----1---3.

 

In the following example, the setscale section is added.Code:

2. Matrix matrix =NewMatrix ();
4. Float[] Points =New Float[] {10. 0f,10. 0f };
8. Matrix. postscale (2. 0f,3. 0f );// Step 2
10. Matrix. prerotate (90);// Step 2
12. Matrix. setscale (1. 4f,2. 6f );// Step 2
14. Matrix. posttranslate (8. 0f,7. 0f );// Step 2
16. Matrix. prescale (1. 5f,2. 5f );// Step 2
18. Matrix. mappoints (points );
20. Log. I ("Test", Points [0] +"");
22. Log. I ("Test", Points [1] +"");

The result is that the coordinate is still (29.0, 72.0)
After calculation, we can find that steps 3rd and 2 before step 1 setscale are useless, and are directly covered by Step 2 setscale and executed from step 3.

The sequence is 2---1----3----5----4. Because 2 and 1 are overwritten, there is no effect. It is equivalent to directly executing 3-----5----4.

 

conclusion: Finally, we can draw a conclusion that in all the settings before the matrix transformation, we should first check whether there is setscale. If so, we will jump directly to the setscale step to start the transformation, then execute all the following pre... change, and execute all post ..... Therefore, when setting matrix transformations, you must pay attention to the order. Different sequences have different results.