Android中图像变换Matrix的原理应用，掌握了这些Android高级工程师必备知识

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. @Override

48. protected void onDraw(Canvas canvas)

49. {

50. // 画出原图像

51. canvas.drawBitmap(bitmap, 0, 0, null);

52. // 画出变换后的图像

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

54. super.onDraw(canvas);

55. }

56. @Override

57. public void setImageMatrix(Matrix matrix)

58. {

59. this.matrix.set(matrix);

60. super.setImageMatrix(matrix);

61. }

62. public Bitmap getImageBitmap()

63. {

64. return bitmap;

65. }

66. }

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

68. {

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

70. {

71. Matrix matrix = new Matrix();

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

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

74. // 1. 平移

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

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

77. view.setImageMatrix(matrix);

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

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

80. matrix.getValues(matrixValues);

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

82. {

83. String temp = new String();

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

85. {

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

87. }

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

89. }

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

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

92. //

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

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

95. //          view.setImageMatrix(matrix);

96. //

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

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

99. //          matrix.getValues(matrixValues);

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

101. //          {

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

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

104. //              {

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

106. //              }

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

108. //          }

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

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

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

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

113. //

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

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

116. //          view.setImageMatrix(matrix);

117. //

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

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

120. //          matrix.getValues(matrixValues);

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

122. //          {

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

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

125. //              {

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

127. //              }

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

129. //          }

130. //          // 4. 缩放

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

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

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

134. //          matrix.getValues(matrixValues);

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

136. //          {

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

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

139. //              {

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

141. //              }

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

143. //          }

144. //

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

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

147. //          view.setImageMatrix(matrix);

148. //

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

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

151. //          matrix.getValues(matrixValues);

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

153. //          {

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

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

156. //              {

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

158. //              }

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

160. //          }

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

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

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

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

165. //          matrix.getValues(matrixValues);

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

167. //          {

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

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

170. //              {

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

172. //              }

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

174. //          }

175. //

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

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

178. //          view.setImageMatrix(matrix);

179. //

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

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

182. //          matrix.getValues(matrixValues);

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

184. //          {

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

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

187. //              {

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

189. //              }

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

191. //          }

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

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

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

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

196. //          matrix.getValues(matrixValues);

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

198. //          {

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

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

201. //              {

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

203. //              }

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

205. //          }

206. //

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

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

209. //          view.setImageMatrix(matrix);

210. //

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

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

213. //          matrix.getValues(matrixValues);

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

215. //          {

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

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

218. //              {

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

220. //              }

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

222. //          }

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

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

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

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

227. //          matrix.getValues(matrixValues);

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

229. //          {

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

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

232. //              {

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

234. //              }

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

236. //          }

237. //

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

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

240. //          view.setImageMatrix(matrix);

241. //

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

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

244. //          matrix.getValues(matrixValues);

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

246. //          {

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

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

249. //              {

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

251. //              }

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

253. //          }

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

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

256. //          matrix.setValues(matrix_values);

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

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

259. //          matrix.getValues(matrixValues);

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

261. //          {

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

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

264. //              {

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

266. //              }

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

268. //          }

269. //

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

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

272. //          view.setImageMatrix(matrix);

273. //

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

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

276. //          matrix.getValues(matrixValues);

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

278. //          {

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

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

281. //              {

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

283. //              }

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

285. //          }

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

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

288. //          matrix.setValues(matrix_values);

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

290. //          float[] 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. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

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

304. //          view.setImageMatrix(matrix);

305. //

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

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

308. //          matrix.getValues(matrixValues);

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

310. //          {

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

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

313. //              {

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

315. //              }

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

317. //          }

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

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

320. //          matrix.setValues(matrix_values);

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

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

323. //          matrix.getValues(matrixValues);

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

325. //          {

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

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

328. //              {

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

330. //              }

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

332. //          }

333. //

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

335. //          matrix.postTranslate(view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth(),

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

337. //          view.setImageMatrix(matrix);

338. //

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

340. //          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. view.invalidate();

352. }

353. return true;

354. }

355. }
     

356. 
       

第三部分 应用

在这一部分，我们会将前面两部分所了解到的内容和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;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

尾声

如果你想成为一个优秀的 Android 开发人员，请集中精力，对基础和重要的事情做深度研究。

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。 整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

这里，笔者分享一份从架构哲学的层面来剖析的视频及资料给大家梳理了多年的架构经验，筹备近6个月最新录制的，相信这份视频能给你带来不一样的启发、收获。

Android进阶学习资料库

一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！

大厂面试真题

PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

《2019-2021字节跳动Android面试历年真题解析》

3663097)]
[外链图片转存中…(img-Wss08e3b-1711913663097)]
[外链图片转存中…(img-zS3w9o1F-1711913663097)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-lGR1ATM1-1711913663098)]

尾声

如果你想成为一个优秀的 Android 开发人员，请集中精力，对基础和重要的事情做深度研究。

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。 整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

这里，笔者分享一份从架构哲学的层面来剖析的视频及资料给大家梳理了多年的架构经验，筹备近6个月最新录制的，相信这份视频能给你带来不一样的启发、收获。

[外链图片转存中…(img-ZZH21Z1l-1711913663098)]

Android进阶学习资料库

一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！

[外链图片转存中…(img-xZRI6Xjv-1711913663098)]

大厂面试真题

PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

[外链图片转存中…(img-fZAVmLVp-1711913663098)]

《2019-2021字节跳动Android面试历年真题解析》

[外链图片转存中…(img-2fJ4PCca-1711913663099)]

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录