## 2.4 图像调整
### 2.4.1 图像的缩放
#### 2.4.1.1 图像缩放算法浅析
图像缩放算法有很多种，这里参考网友"lantianyu520"所著的"图像缩放算法"。
原理浅析
要理解这个图像缩放算法的原理，最重要的是需要理解：对于图像上的每一个像素点，它缩放前后，相对于整个图像的比例应该是一样的。
比如：
以一个长度和宽度分别为200，100的长方形为例，将其放大两倍，那么缩放后的长度和宽度为400，200。
为方便理解，我们建立一个笛卡尔坐标系，把这个长方形左下角的顶点放到坐标(0,0)位置，四个点的坐标分别为：(0,0),(0,100),(200,0),(200,100)。
假设此时对长方形中的坐标点(40,50)，它的x坐标相对于长的比值是40/200=0.2，y坐标相对于宽的比值是50/100=0.5，那么该点的变换后的坐标Dx,Dy则应满足：Dx/400 = 5;Dy/200 = 0.5，这样，缩放后的坐标就可以算出来了。
根据上面的分析，设缩放前的像素点坐标为(Sx,Sy)，对应的缩放后的像素点坐标为(Dx,Dy)，缩放前的图像长宽分别为Sw,Sh，缩放后的图像长宽分别为Dw,Dh，则有：
Sx/Dx = Sw/Dw，Sy/Dy = Sh/Dh
故有Sx = Dx * Sw/Dw，Sy = Dy * Sh/Dh，
#### 2.4.1.2源码编写：图像缩放算法
有了这个上面两条等式后，图像缩放算法的代码就好理解了。
下面的函数实现了基于上述原理实现的图像缩放算法：
```c
代码清单2.4
1. /**********************************************************************
2. * 函数名称： PicZoom
3. * 功能描述： 近邻取样插值方法缩放图片
4. * 注意该函数会分配内存来存放缩放后的图片,用完后要用free函数释放掉
5. * "近邻取样插值"的原理请参考网友"lantianyu520"所著的"图像缩放算法"
6. * 输入参数： ptPicData - 内含缩放前后的图像数据
7. * fSize - 缩放倍数
8. * 输出参数： ptPicData->pucZoomData,内含缩放后的数据
9. * 返 回 值： 0 - 成功, 其他值 - 失败
10. ***********************************************************************/
11. int PicZoom(PT_PictureData ptPicData,float fSize)
12. {
13. ptPicData->iZoomWidth = ptPicData->iWidth * fSize;
14. ptPicData->iZoomHeight= ptPicData->iHeight* fSize;
15. unsigned long* pdwSrcXTable;
16. unsigned long x;
17. unsigned long y;
18. unsigned long dwSrcY;
19. unsigned char *pucDest;
20. unsigned char *pucSrc;
21. unsigned long dwPixelBytes = ptPicData->iBpp/8;
22. ptPicData->pucZoomData= malloc(sizeof(unsigned char) * ptPicData->iZoomWidth*ptPicData->iZoomHeight*ptPicData->iBpp/8);
23. pdwSrcXTable = malloc(sizeof(unsigned long) * ptPicData->iZoomWidth);
24. if (NULL == pdwSrcXTable){
25. printf("malloc error!\n");
26. return -1;
27. }
28.
29. /* 这几个for循环的本质是Sx = Dx * Sw/Dw，Sy = Dy * Sh/Dh*/
30. for (x = 0; x < ptPicData->iZoomWidth; x++){//生成表 pdwSrcXTable
31. /* 第一个for循环对应x方向的坐标
32. * pdwSrcXTable[x] 对应Sx,
33. * x 对应Dx,
34. * ptPicData->iWidth 对应Sw
35. * ptPicData->iZoomWidth 对应 Dw*/
36. pdwSrcXTable[x]=(x*ptPicData->iWidth/ptPicData->iZoomWidth);
37. }
38.
39. for (y = 0; y < ptPicData->iZoomHeight; y++){
40. /* 第2个循环对应y方向的坐标
41. * dwSrcY 对应Sy,
42. * y 对应Dy,
43. * ptPicData->iHeight 对应Sh
44. * ptPicData->iZoomHeight 对应 Dh*/
45. dwSrcY = (y * ptPicData->iHeight / ptPicData->iZoomHeight);
46. /* 根据这些可算得各像素点的RGB数据存放的地址 */
47. pucDest = ptPicData->pucZoomData + y*ptPicData->iZoomWidth*3;
48. pucSrc = ptPicData->pucRgbData + dwSrcY*ptPicData->iWidth*3;
49.
50. /* 最后拷贝数据 */
51. for (x = 0; x <ptPicData->iZoomWidth; x++){
52. memcpy(pucDest+x*dwPixelBytes, pucSrc+pdwSrcXTable[x]*dwPixelBytes, dwPixelBytes);
53. }
54. }
55.
56. free(pdwSrcXTable);
57. return 0;
58. }
```
### 2.4.2 图像的旋转
#### 2.4.2.1 图像旋转算法浅析
这里的图像旋转算法原理参考网友"落叶的思维"所著的"图像旋转算法与实现"
原理浅析
这个旋转算法的原理的关键点有两个：
1. 原图像是以图像的左下角为原点建立笛卡尔坐标系的，而旋转一般是以图像的中心作为旋转点旋转的。
因此为了便于转换，我们先约定两个坐标系，一个是以图像左下角为原点建立的坐标系，称为坐标系A，这也是原图像的坐标系。一个是以图像中心为原点建立的坐标系，称为坐标系B。
由此，可以知道这个旋转算法的步骤：先将坐标系A下的坐标转换为坐标系B下的坐标，然后在坐标系B下进行图像的旋转。
在坐标系B下，我们假设点（x0，y0）距离原点的距离为r，点与原点之间的连线与x轴的夹角为b，旋转的角度为a，旋转后的点为（x1，y1）, 如下图所示。
那么有以下结论：
x0=rcosb；y0=rsinb
x1 = rcos(b-a) = rcosbcosa+rsinbsina=x0cosa+y0sina；
y1=rsin(b-a)=rsinbcosa-rcosbsina=-x0sina+y0cosa；
最后，由于我们显示图像的RGB数据还是要在坐标系A下获取的，我们最后只需要将坐标系B下的x1,y1转换回坐标系A下的坐标就可以了。
旋转后的图像的长和宽会发生变化，因此要计算新图像的长和宽。
由几何关系可知，新图像的长和宽分别是旋转后，对角坐标相见后的最大值
#### 2.4.2.2 源码编写：图像旋转算法
```c
代码清单2.5
1. #define PI 3.1415926535
2. //角度到弧度转化
3. #define RADIAN(angle) ((angle)*PI/180.0)
4.
5.
6.
7.
8.
9. typedef struct ConcernCoor {
10. int iLTx;// left top x
11. int iLTy;//left top y
12. int iLBx;//left bottom x
13. int iLBy;//left bottom y
14. int iRTx;//right top x
15. int iRTy;//right top y
16. int iRBx;// right bottom x
17. int iRBy;// right bottom y
18. }T_ConcernCoor, *PT_ConcernCoor;
19.
20.
21. /**********************************************************************
22. * 函数名称： max
23. * 功能描述：比较两个参数，返回较大值
24. * 输入参数：x，y均为int型
25. * 输出参数： 无
26. * 返 回 值： x，y中的较大值
27. ***********************************************************************/
28. static int max(int x,int y){
29. return x>y?x:y;
30. }
31. /**********************************************************************
32. * 函数名称： PicRotate
33. * 功能描述： 旋转图片
34. * 注意该函数会分配内存来存放缩放后的图片,用完后要用free函数释放掉
35. * 参考网友"落叶的思维"所著的"图像旋转算法与实现"
36. * 输入参数： ptPicData - 内含图片的象素数据
37. * fAngle - 旋转角度，0<=angle<=360
38. * 输出参数： ptPicData->pucRotateData,内含旋转后的rgb数据
39. * 返 回 值： 0 - 成功, 其他值 - 失败
40. ***********************************************************************/
41. int PicRotate(PT_PictureData ptPicData,float fAngle)
42. {
43. int i ,j;
44. T_ConcernCoor tConCor,tRonCor;
45. //原图像每一行去除偏移量的字节数
46. //int iSrcLineSize = bitCount * srcW / 8;
47. int iSrcLineSize = ptPicData->iBpp* ptPicData->iZoomWidth / 8;
48. int iDesLineSize;
49. int iX;//旋转后的x坐标
50. int iY; //旋转后的y坐标
51.
52. /* 将坐标系A下的坐标转换为坐标系B下的坐标,
53. * 用于计算旋转后的图像的宽和高
54. * tConCor用于存放坐标系B下旋转前的坐标
55. * tRonCor用于存放坐标系B下旋转后的坐标*/
56. tConCor.iLTx = -ptPicData->iZoomWidth/2; tConCor.iLTy = ptPicData->iZoomHeight/2;
57. tConCor.iRTx = ptPicData->iZoomWidth/2; tConCor.iRTy = ptPicData->iZoomHeight/2;
58. tConCor.iLBx = -ptPicData->iZoomWidth/2;tConCor.iLBy = -ptPicData->iZoomHeight/2;
59. tConCor.iRBx = ptPicData->iZoomWidth/2;tConCor.iRBy = -ptPicData->iZoomHeight/2;
60.
61.
62. /* 计算坐标系B下旋转后的坐标 */
63. double sina = sin(RADIAN(fAngle));
64. double cosa = cos(RADIAN(fAngle));
65. tRonCor.iLTx =tConCor.iLTx * cosa + tConCor.iLTy * sina;
66. tRonCor.iLTy = -tConCor.iLTx * sina + tConCor.iLTy * cosa;
67. tRonCor.iRTx =tConCor.iRTx * cosa + tConCor.iRTy * sina;
68. tRonCor.iRTy = -tConCor.iRTx * sina + tConCor.iRTy * cosa;
69. tRonCor.iLBx = tConCor.iLBx * cosa + tConCor.iLBy * sina;
70. tRonCor.iLBy = -tConCor.iLBx * sina + tConCor.iLBy * cosa;
71. tRonCor.iRBx = tConCor.iRBx * cosa + tConCor.iRBy * sina;
72. tRonCor.iRBy = -tConCor.iRBx * sina + tConCor.iRBy * cosa;
73.
74.
75. /* 计算旋转后图像宽和高 */
76. ptPicData->iRotateWidth = max(abs(tRonCor.iRBx - tRonCor.iLTx),abs(tRonCor.iRTx - tRonCor.iLBx));
77. ptPicData->iRotateHeight = max(abs(tRonCor.iRBy - tRonCor.iLTy),abs(tRonCor.iRTy - tRonCor.iLBy));
78.
79. /* 像素信息要保证3字节对齐，否则数据有可能出错*/
80. iDesLineSize = ((ptPicData->iRotateWidth* ptPicData->iBpp+ 23) / 24) * 3 ;
81. /* 分配旋转后的空间，注意这里要用旋转后的宽和高 */
82. ptPicData->pucRotateData = malloc(iDesLineSize * ptPicData->iRotateHeight);
83. if(NULL == ptPicData->pucRotateData){
84. printf("malloc error\n");
85. return -1;
86. }
87.
88. /* 通过新图像的坐标，计算对应的原图像的坐标*
89. * i,j坐标就是对应的坐标系B下的x1,y1*/
90. for (i = 0; i < ptPicData->iRotateHeight; i++){
91. for (j = 0; j < ptPicData->iRotateWidth; j++){
92. /* 坐标系B下的x,y1坐标，经过逆运算转换得到iX,iY,这两个值对应x0,y0 */
93. iX = (j - ptPicData->iRotateWidth / 2)*cos(RADIAN(360 - fAngle)) + (-i + ptPicData->iRotateHeight / 2)*sin(RADIAN(360 - fAngle));
94. iY = -(j - ptPicData->iRotateWidth / 2)*sin(RADIAN(360 - fAngle)) + (-i + ptPicData->iRotateHeight / 2)*cos(RADIAN(360 - fAngle));
95. /*如果这个坐标不在原图像内，则不赋值*/
96. if (iX > ptPicData->iZoomWidth / 2 || iX < -ptPicData->iZoomWidth / 2 || iY > ptPicData->iZoomHeight / 2 || iY < -ptPicData->iZoomHeight / 2){
97. continue;
98. }
99. /* 再将坐标系B下的x0,y0坐标，转换为坐标系A下的坐标 */
100. int iXN = iX + ptPicData->iZoomWidth / 2;
101. int iYN = abs(iY - ptPicData->iZoomHeight / 2);
102. /* 值拷贝*/
103. memcpy(&ptPicData->pucRotateData[i * iDesLineSize + j * 3],&ptPicData->pucZoomData[iYN * iSrcLineSize + iXN * 3],3);
104. }
105. }
106. return 0;
107. }
```
|
|
楼主
标题置顶
标题高亮
