Android中图像变换Matrix的原理应用，面试安卓系统架构

54. canvas.drawBitmap(bitmap, matrix, null);

55. super.onDraw(canvas);

56. }

57. @Override

58. public void setImageMatrix(Matrix matrix)

59. {

60. this.matrix.set(matrix);

61. super.setImageMatrix(matrix);

62. }

63. public Bitmap getImageBitmap()

64. {

65. return bitmap;

66. }

67. }

68. public boolean onTouch(View v, MotionEvent e)

69. {

70. if(e.getAction() == MotionEvent.ACTION_UP)

71. {

72. Matrix matrix = new Matrix();

73. // 输出图像的宽度和高度(162 x 251)

74. Log.e(“TestTransformMatrixActivity”, "image size: width x height = " +  view.getImageBitmap().getWidth() + " x " + view.getImageBitmap().getHeight());

75. // 1. 平移

76. matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());

77. // 在x方向平移view.getImageBitmap().getWidth()，在y轴方向view.getImageBitmap().getHeight()

78. view.setImageMatrix(matrix);

79. // 下面的代码是为了查看matrix中的元素

80. float[] matrixValues = new float[9];

81. matrix.getValues(matrixValues);

82. for(int i = 0; i < 3; ++i)

83. {

84. String temp = new String();

85. for(int j = 0; j < 3; ++j)

86. {

87. temp += matrixValues[3 * i + j ] + “t”;

88. }

89. Log.e(“TestTransformMatrixActivity”, temp);

90. }

91. //          // 2. 旋转(围绕图像的中心点)

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

93. //

94. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

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

96. //          view.setImageMatrix(matrix);

97. //

98. //          // 下面的代码是为了查看matrix中的元素

99. //          float[] matrixValues = new float[9];

100. //          matrix.getValues(matrixValues);

101. //          for(int i = 0; i < 3; ++i)

102. //          {

103. //              String temp = new String();

104. //              for(int j = 0; j < 3; ++j)

105. //              {

106. //                  temp += matrixValues[3 * i + j ] + “t”;

107. //              }

108. //              Log.e(“TestTransformMatrixActivity”, temp);

109. //          }

110. //          // 3. 旋转(围绕坐标原点) + 平移(效果同2)

111. //          matrix.setRotate(45f);

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

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

114. //

115. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

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

117. //          view.setImageMatrix(matrix);

118. //

119. //          // 下面的代码是为了查看matrix中的元素

120. //          float[] matrixValues = new float[9];

121. //          matrix.getValues(matrixValues);

122. //          for(int i = 0; i < 3; ++i)

123. //          {

124. //              String temp = new String();

125. //              for(int j = 0; j < 3; ++j)

126. //              {

127. //                  temp += matrixValues[3 * i + j ] + “t”;

128. //              }

129. //              Log.e(“TestTransformMatrixActivity”, temp);

130. //          }

131. //          // 4. 缩放

132. //          matrix.setScale(2f, 2f);

133. //          // 下面的代码是为了查看matrix中的元素

134. //          float[] matrixValues = new float[9];

135. //          matrix.getValues(matrixValues);

136. //          for(int i = 0; i < 3; ++i)

137. //          {

138. //              String temp = new String();

139. //              for(int j = 0; j < 3; ++j)

140. //              {

141. //                  temp += matrixValues[3 * i + j ] + “t”;

142. //              }

143. //              Log.e(“TestTransformMatrixActivity”, temp);

144. //          }

145. //

146. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

147. //          matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());

148. //          view.setImageMatrix(matrix);

149. //

150. //          // 下面的代码是为了查看matrix中的元素

151. //          matrixValues = new float[9];

152. //          matrix.getValues(matrixValues);

153. //          for(int i = 0; i < 3; ++i)

154. //          {

155. //              String temp = new String();

156. //              for(int j = 0; j < 3; ++j)

157. //              {

158. //                  temp += matrixValues[3 * i + j ] + “t”;

159. //              }

160. //              Log.e(“TestTransformMatrixActivity”, temp);

161. //          }

162. //          // 5. 错切 - 水平

163. //          matrix.setSkew(0.5f, 0f);

164. //          // 下面的代码是为了查看matrix中的元素

165. //          float[] matrixValues = new float[9];

166. //          matrix.getValues(matrixValues);

167. //          for(int i = 0; i < 3; ++i)

168. //          {

169. //              String temp = new String();

170. //              for(int j = 0; j < 3; ++j)

171. //              {

172. //                  temp += matrixValues[3 * i + j ] + “t”;

173. //              }

174. //              Log.e(“TestTransformMatrixActivity”, temp);

175. //          }

176. //

177. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

178. //          matrix.postTranslate(view.getImageBitmap().getWidth(), 0f);

179. //          view.setImageMatrix(matrix);

180. //

181. //          // 下面的代码是为了查看matrix中的元素

182. //          matrixValues = new float[9];

183. //          matrix.getValues(matrixValues);

184. //          for(int i = 0; i < 3; ++i)

185. //          {

186. //              String temp = new String();

187. //              for(int j = 0; j < 3; ++j)

188. //              {

189. //                  temp += matrixValues[3 * i + j ] + “t”;

190. //              }

191. //              Log.e(“TestTransformMatrixActivity”, temp);

192. //          }

193. //          // 6. 错切 - 垂直

194. //          matrix.setSkew(0f, 0.5f);

195. //          // 下面的代码是为了查看matrix中的元素

196. //          float[] matrixValues = new float[9];

197. //          matrix.getValues(matrixValues);

198. //          for(int i = 0; i < 3; ++i)

199. //          {

200. //              String temp = new String();

201. //              for(int j = 0; j < 3; ++j)

202. //              {

203. //                  temp += matrixValues[3 * i + j ] + “t”;

204. //              }

205. //              Log.e(“TestTransformMatrixActivity”, temp);

206. //          }

207. //

208. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

209. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());

210. //          view.setImageMatrix(matrix);

211. //

212. //          // 下面的代码是为了查看matrix中的元素

213. //          matrixValues = new float[9];

214. //          matrix.getValues(matrixValues);

215. //          for(int i = 0; i < 3; ++i)

216. //          {

217. //              String temp = new String();

218. //              for(int j = 0; j < 3; ++j)

219. //              {

220. //                  temp += matrixValues[3 * i + j ] + “t”;

221. //              }

222. //              Log.e(“TestTransformMatrixActivity”, temp);

223. //          }

224. //          7. 错切 - 水平 + 垂直

225. //          matrix.setSkew(0.5f, 0.5f);

226. //          // 下面的代码是为了查看matrix中的元素

227. //          float[] matrixValues = new float[9];

228. //          matrix.getValues(matrixValues);

229. //          for(int i = 0; i < 3; ++i)

230. //          {

231. //              String temp = new String();

232. //              for(int j = 0; j < 3; ++j)

233. //              {

234. //                  temp += matrixValues[3 * i + j ] + “t”;

235. //              }

236. //              Log.e(“TestTransformMatrixActivity”, temp);

237. //          }

238. //

239. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

240. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());

241. //          view.setImageMatrix(matrix);

242. //

243. //          // 下面的代码是为了查看matrix中的元素

244. //          matrixValues = new float[9];

245. //          matrix.getValues(matrixValues);

246. //          for(int i = 0; i < 3; ++i)

247. //          {

248. //              String temp = new String();

249. //              for(int j = 0; j < 3; ++j)

250. //              {

251. //                  temp += matrixValues[3 * i + j ] + “t”;

252. //              }

253. //              Log.e(“TestTransformMatrixActivity”, temp);

254. //          }

255. //          // 8. 对称 (水平对称)

256. //          float matrix_values[] = {1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f};

257. //          matrix.setValues(matrix_values);

258. //          // 下面的代码是为了查看matrix中的元素

259. //          float[] matrixValues = new float[9];

260. //          matrix.getValues(matrixValues);

261. //          for(int i = 0; i < 3; ++i)

262. //          {

263. //              String temp = new String();

264. //              for(int j = 0; j < 3; ++j)

265. //              {

266. //                  temp += matrixValues[3 * i + j ] + “t”;

267. //              }

268. //              Log.e(“TestTransformMatrixActivity”, temp);

269. //          }

270. //

271. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

272. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight() * 2f);

273. //          view.setImageMatrix(matrix);

274. //

275. //          // 下面的代码是为了查看matrix中的元素

276. //          matrixValues = new float[9];

277. //          matrix.getValues(matrixValues);

278. //          for(int i = 0; i < 3; ++i)

279. //          {

280. //              String temp = new String();

281. //              for(int j = 0; j < 3; ++j)

282. //              {

283. //                  temp += matrixValues[3 * i + j ] + “t”;

284. //              }

285. //              Log.e(“TestTransformMatrixActivity”, temp);

286. //          }

287. //          // 9. 对称 - 垂直

288. //          float matrix_values[] = {-1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f};

289. //          matrix.setValues(matrix_values);

290. //          // 下面的代码是为了查看matrix中的元素

291. //          float[] matrixValues = new float[9];

292. //          matrix.getValues(matrixValues);

293. //          for(int i = 0; i < 3; ++i)

294. //          {

295. //              String temp = new String();

296. //              for(int j = 0; j < 3; ++j)

297. //              {

298. //                  temp += matrixValues[3 * i + j ] + “t”;

299. //              }

300. //              Log.e(“TestTransformMatrixActivity”, temp);

301. //          }

302. //

303. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

304. //          matrix.postTranslate(view.getImageBitmap().getWidth() * 2f, 0f);

305. //          view.setImageMatrix(matrix);

306. //

307. //          // 下面的代码是为了查看matrix中的元素

308. //          matrixValues = new float[9];

309. //          matrix.getValues(matrixValues);

310. //          for(int i = 0; i < 3; ++i)

311. //          {

312. //              String temp = new String();

313. //              for(int j = 0; j < 3; ++j)

314. //              {

315. //                  temp += matrixValues[3 * i + j ] + “t”;

316. //              }

317. //              Log.e(“TestTransformMatrixActivity”, temp);

318. //          }

319. //          // 10. 对称(对称轴为直线y = x)

320. //          float matrix_values[] = {0f, -1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f};

321. //          matrix.setValues(matrix_values);

322. //          // 下面的代码是为了查看matrix中的元素

323. //          float[] 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. //          matrix.postTranslate(view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth(),

337. //                  view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth());

338. //          view.setImageMatrix(matrix);

339. //

340. //          // 下面的代码是为了查看matrix中的元素

341. //          matrixValues = new float[9];

342. //          matrix.getValues(matrixValues);

343. //          for(int i = 0; i < 3; ++i)

344. //          {

345. //              String temp = new String();

346. //              for(int j = 0; j < 3; ++j)

347. //              {

348. //                  temp += matrixValues[3 * i + j ] + “t”;

349. //              }

350. //              Log.e(“TestTransformMatrixActivity”, temp);

351. //          }

352. view.invalidate();

353. }

354. return true;

355. }

356. }
     

357. 
       

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

的，左乘、右乘是针对矩阵运算的左右位置而言的。以第一部分“二、旋转变换”中围绕某点旋转的情况为例：

第三部分 应用

在这一部分，我们会将前面两部分所了解到的内容和Android手势结合起来，利用各种不同的手势对图像进行平移、缩放和旋转，前面两项都是在实践中经常需要用到的功能，后一项据说苹果也是最近才加上的，而实际上在Android中，咱们通过自己的双手，也可以很轻松地实现之。

首先创建一个Android项目PatImageView，同时创建一个Activity：PatImageViewActivity。完成这一步后， 记得在AndroidManifest.xml中增加如下许可：

uses-permissionandroid:name=_“android.permission.VIBRATE”_/

因为我们将要通过短按还是长按，来确定将图片到底是缩放还是旋转。

现在来创建一个ImageView的派生类：PatImageView，其代码(PatImageView.java)如下(2011-11-22 revised)：

[java]  view plain copy

1. package com.pat.imageview;

2. import android.app.Service;

3. import android.content.Context;

4. import android.graphics.Matrix;

5. import android.graphics.PointF;

6. import android.os.Vibrator;

7. import android.util.FloatMath;

8. import android.view.GestureDetector;

9. import android.view.MotionEvent;

10. import android.view.View;

11. import android.widget.ImageView;

12. public class PatImageView extends ImageView

13. {

14. private Matrix matrix;

15. private Matrix savedMatrix;

16. private boolean long_touch = false;

17. private static int NONE = 0;

18. private static int DRAG = 1;    // 拖动

19. private static int ZOOM = 2;    // 缩放

20. private static int ROTA = 3;    // 旋转

21. private int mode = NONE;

22. private PointF startPoint;

23. private PointF middlePoint;

24. private float oldDistance;

25. private float oldAngle;

26. private Vibrator vibrator;

27. private GestureDetector gdetector;

28. public PatImageView(final Context context)

29. {

30. super(context);

31. matrix = new Matrix();

32. savedMatrix = new Matrix();

33. matrix.setTranslate(0f, 0f);

34. setScaleType(ScaleType.MATRIX);

35. setImageMatrix(matrix);

36. startPoint = new PointF();

37. middlePoint = new PointF();

38. oldDistance = 1f;

39. gdetector = new GestureDetector(context, new GestureDetector.OnGestureListener()

40. {

41. @Override

42. public boolean onSingleTapUp(MotionEvent e)

43. {

44. return true;

45. }

46. @Override

47. public void onShowPress(MotionEvent e)

48. {

49. }

50. @Override

51. public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)

52. {

53. return true;

54. }

55. @Override

56. public void onLongPress(MotionEvent e)

57. {

58. long_touch = true;

59. vibrator = (Vibrator) context.getSystemService(Service.VIBRATOR_SERVICE);

60. // 振动50ms，提示后续的操作将是旋转图片，而非缩放图片

61. vibrator.vibrate(50);

62. }

63. @Override

64. public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)

65. {

66. return true;

67. }

68. @Override

69. public boolean onDown(MotionEvent e)

70. {

71. return true;

72. }

73. });

74. setOnTouchListener(new OnTouchListener()

75. {

76. public boolean onTouch(View view, MotionEvent event)

77. {

78. switch(event.getAction() & MotionEvent.ACTION_MASK)

79. {

80. case MotionEvent.ACTION_DOWN:           // 第一个手指touch

81. savedMatrix.set(matrix);

82. startPoint.set(event.getX(), event.getY());

83. mode = DRAG;

84. long_touch = false;

85. break;

86. case MotionEvent.ACTION_POINTER_DOWN:   // 第二个手指touch

87. oldDistance = getDistance(event);   // 计算第二个手指touch时，两指之间的距离

88. oldAngle = getDegree(event);        // 计算第二个手指touch时，两指所形成的直线和x轴的角度

89. if(oldDistance > 10f)

90. {

91. savedMatrix.set(matrix);

92. middlePoint = midPoint(event);

93. if(!long_touch)

94. {

95. mode = ZOOM;

96. }

97. else

98. {

99. mode = ROTA;

100. }

101. }

102. break;

103. case MotionEvent.ACTION_UP:

104. mode = NONE;

105. break;

106. case MotionEvent.ACTION_POINTER_UP:

107. mode = NONE;

108. break;

109. case MotionEvent.ACTION_MOVE:

110. if(vibrator != null)    vibrator.cancel();

111. if(mode == DRAG)

112. {

113. matrix.set(savedMatrix);

114. matrix.postTranslate(event.getX() - startPoint.x, event.getY() - startPoint.y);

115. }

116. if(mode == ZOOM)

117. {

118. float newDistance = getDistance(event);

119. if(newDistance > 10f)

120. {

121. matrix.set(savedMatrix);

122. float scale = newDistance / oldDistance;

123. matrix.postScale(scale, scale, middlePoint.x, middlePoint.y);

124. }

125. }

126. if(mode == ROTA)

127. {

128. float newAngle = getDegree(event);

129. matrix.set(savedMatrix);

130. float degrees = newAngle - oldAngle;

131. matrix.postRotate(degrees, middlePoint.x, middlePoint.y);

132. }

133. break;

134. }

135. setImageMatrix(matrix);

136. invalidate();

137. gdetector.onTouchEvent(event);

138. return true;

139. }

140. });

141. }

142. // 计算两个手指之间的距离

143. private float getDistance(MotionEvent event)

144. {

145. float x = event.getX(0) - event.getX(1);

146. float y = event.getY(0) - event.getY(1);

147. return FloatMath.sqrt(x * x + y * y);

148. }

149. // 计算两个手指所形成的直线和x轴的角度

150. private float getDegree(MotionEvent event)

151. {

152. return (float)(Math.atan((event.getY(1) - event.getY(0)) / (event.getX(1) - event.getX(0))) * 180f);

153. }

154. // 计算两个手指之间，中间点的坐标

155. private PointF midPoint( MotionEvent event)

156. {

157. PointF point = new PointF();

158. float x = event.getX(0) + event.getX(1);

159. float y = event.getY(0) + event.getY(1);

160. point.set(x / 2, y / 2);

161. return point;

162. }

163. }

下面完善PatImageViewActivity.java的代码，使之如下：

[java]  view plain copy

1. package com.pat.imageview;

2. import android.app.Activity;

3. import android.graphics.Bitmap;

4. import android.graphics.BitmapFactory;

5. import android.os.Bundle;

6. import android.view.Window;

7. import android.view.WindowManager;

8. public class PatImageViewActivity extends Activity

9. {

10. @Override

11. public void onCreate(Bundle savedInstanceState)

12. {

13. super.onCreate(savedInstanceState);