PointTrans.cpp
上传用户:alisonmail
上传日期:2013-02-28
资源大小:500k
文件大小:8k
源码类别:

图片显示

开发平台:

Visual C++

  1. /**************************************************************************
  2.  *  文件名:PointTrans.cpp
  3.  *
  4.  *  图像点运算API函数库:
  5.  *
  6.  *  LinerTrans() - 图像线性变换
  7.  * WindowTrans() - 图像窗口变换
  8.  *  GrayStretch() - 图像灰度拉伸
  9.  *  InteEqualize() -直方图均衡
  10.  *
  11.  *************************************************************************/
  12. #include "stdafx.h"
  13. #include "PointTrans.h"
  14. #include "DIBAPI.h"
  15. #include <math.h>
  16. #include <direct.h>
  17. /*************************************************************************
  18.  *
  19.  * 函数名称:
  20.  *   LinerTrans()
  21.  *
  22.  * 参数:
  23.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  24.  *   LONG  lWidth       - 源图像宽度(象素数)
  25.  *   LONG  lHeight      - 源图像高度(象素数)
  26.  *   FLOAT fA     - 线性变换的斜率
  27.  *   FLOAT fB           - 线性变换的截距
  28.  *
  29.  * 返回值:
  30.  *   BOOL               - 成功返回TRUE,否则返回FALSE。
  31.  *
  32.  * 说明:
  33.  *   该函数用来对图像进行灰度的线性变换操作。
  34.  *
  35.  ************************************************************************/
  36. BOOL WINAPI LinerTrans(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, FLOAT fA, FLOAT fB)
  37. {
  38. // 指向源图像的指针
  39. unsigned char* lpSrc;
  40. // 循环变量
  41. LONG i;
  42. LONG j;
  43. // 图像每行的字节数
  44. LONG lLineBytes;
  45. // 中间变量
  46. FLOAT fTemp;
  47. // 计算图像每行的字节数
  48. lLineBytes = WIDTHBYTES(lWidth * 8);
  49. // 每行
  50. for(i = 0; i < lHeight; i++)
  51. {
  52. // 每列
  53. for(j = 0; j < lWidth; j++)
  54. {
  55. // 指向DIB第i行,第j个象素的指针
  56. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  57. // 线性变换
  58. fTemp = fA * (*lpSrc) + fB;
  59. // 判断是否超出范围
  60. if (fTemp > 255)
  61. {
  62. // 直接赋值为255
  63. *lpSrc = 255;
  64. }
  65. else if (fTemp < 0)
  66. {
  67. // 直接赋值为0
  68. *lpSrc = 0;
  69. }
  70. else
  71. {
  72. // 四舍五入
  73. *lpSrc = (unsigned char) (fTemp + 0.5);
  74. }
  75. }
  76. }
  77. // 返回
  78. return TRUE;
  79. }
  80. /*************************************************************************
  81.  *
  82.  * 函数名称:
  83.  *   ThresholdTrans()
  84.  *
  85.  * 参数:
  86.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  87.  *   LONG  lWidth       - 源图像宽度(象素数)
  88.  *   LONG  lHeight      - 源图像高度(象素数)
  89.  *   BYTE  bThre     - 阈值
  90.  *
  91.  * 返回值:
  92.  *   BOOL               - 成功返回TRUE,否则返回FALSE。
  93.  *
  94.  * 说明:
  95.  *   该函数用来对图像进行阈值变换。对于灰度值小于阈值的象素直接设置
  96.  * 灰度值为0;灰度值大于阈值的象素直接设置为255。
  97.  *
  98.  ************************************************************************/
  99. BOOL WINAPI ThresholdTrans(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, BYTE bThre)
  100. {
  101. // 指向源图像的指针
  102. unsigned char* lpSrc;
  103. // 循环变量
  104. LONG i;
  105. LONG j;
  106. // 图像每行的字节数
  107. LONG lLineBytes;
  108. // 计算图像每行的字节数
  109. lLineBytes = WIDTHBYTES(lWidth * 8);
  110. // 每行
  111. for(i = 0; i < lHeight; i++)
  112. {
  113. // 每列
  114. for(j = 0; j < lWidth; j++)
  115. {
  116. // 指向DIB第i行,第j个象素的指针
  117. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  118. // 判断是否小于阈值
  119. if ((*lpSrc) < bThre)
  120. {
  121. // 直接赋值为0
  122. *lpSrc = 0;
  123. }
  124. else
  125. {
  126. // 直接赋值为255
  127. *lpSrc = 255;
  128. }
  129. }
  130. }
  131. // 返回
  132. return TRUE;
  133. }
  134. /*************************************************************************
  135.  *
  136.  * 函数名称:
  137.  *   WindowTrans()
  138.  *
  139.  * 参数:
  140.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  141.  *   LONG  lWidth       - 源图像宽度(象素数)
  142.  *   LONG  lHeight      - 源图像高度(象素数)
  143.  *   BYTE  bLow     - 窗口下限
  144.  *   BYTE  bUp          - 窗口上限
  145.  *
  146.  * 返回值:
  147.  *   BOOL               - 成功返回TRUE,否则返回FALSE。
  148.  *
  149.  * 说明:
  150.  *   该函数用来对图像进行窗口变换。只有在窗口范围内的灰度保持不变,
  151.  * 小于下限的象素直接设置灰度值为0;大于上限的象素直接设置灰度值为255。
  152.  *
  153.  ************************************************************************/
  154. BOOL WINAPI WindowTrans(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, BYTE bLow, BYTE bUp)
  155. {
  156. // 指向源图像的指针
  157. unsigned char* lpSrc;
  158. // 循环变量
  159. LONG i;
  160. LONG j;
  161. // 图像每行的字节数
  162. LONG lLineBytes;
  163. // 计算图像每行的字节数
  164. lLineBytes = WIDTHBYTES(lWidth * 8);
  165. // 每行
  166. for(i = 0; i < lHeight; i++)
  167. {
  168. // 每列
  169. for(j = 0; j < lWidth; j++)
  170. {
  171. // 指向DIB第i行,第j个象素的指针
  172. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  173. // 判断是否超出范围
  174. if ((*lpSrc) < bLow)
  175. {
  176. // 直接赋值为0
  177. *lpSrc = 0;
  178. }
  179. else if ((*lpSrc) > bUp)
  180. {
  181. // 直接赋值为255
  182. *lpSrc = 255;
  183. }
  184. }
  185. }
  186. // 返回
  187. return TRUE;
  188. }
  189. /*************************************************************************
  190.  *
  191.  * 函数名称:
  192.  *   GrayStretch()
  193.  *
  194.  * 参数:
  195.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  196.  *   LONG  lWidth       - 源图像宽度(象素数)
  197.  *   LONG  lHeight      - 源图像高度(象素数)
  198.  *   BYTE bX1 - 灰度拉伸第一个点的X坐标
  199.  *   BYTE bY1 - 灰度拉伸第一个点的Y坐标
  200.  *   BYTE bX2 - 灰度拉伸第二个点的X坐标
  201.  *   BYTE bY2 - 灰度拉伸第二个点的Y坐标
  202.  *
  203.  * 返回值:
  204.  *   BOOL               - 成功返回TRUE,否则返回FALSE。
  205.  *
  206.  * 说明:
  207.  *   该函数用来对图像进行灰度拉伸。
  208.  *
  209.  ************************************************************************/
  210. BOOL WINAPI GrayStretch(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, BYTE bX1, BYTE bY1, BYTE bX2, BYTE bY2)
  211. {
  212. // 指向源图像的指针
  213. unsigned char* lpSrc;
  214. // 循环变量
  215. LONG i;
  216. LONG j;
  217. // 灰度映射表
  218. BYTE bMap[256];
  219. // 图像每行的字节数
  220. LONG lLineBytes;
  221. // 计算图像每行的字节数
  222. lLineBytes = WIDTHBYTES(lWidth * 8);
  223. // 计算灰度映射表
  224. for (i = 0; i <= bX1; i++)
  225. {
  226. // 判断bX1是否大于0(防止分母为0)
  227. if (bX1 > 0)
  228. {
  229. // 线性变换
  230. bMap[i] = (BYTE) bY1 * i / bX1;
  231. }
  232. else
  233. {
  234. // 直接赋值为0
  235. bMap[i] = 0;
  236. }
  237. }
  238. for (; i <= bX2; i++)
  239. {
  240. // 判断bX1是否等于bX2(防止分母为0)
  241. if (bX2 != bX1)
  242. {
  243. // 线性变换
  244. bMap[i] = bY1 + (BYTE) ((bY2 - bY1) * (i - bX1) / (bX2 - bX1));
  245. }
  246. else
  247. {
  248. // 直接赋值为bY1
  249. bMap[i] = bY1;
  250. }
  251. }
  252. for (; i < 256; i++)
  253. {
  254. // 判断bX2是否等于255(防止分母为0)
  255. if (bX2 != 255)
  256. {
  257. // 线性变换
  258. bMap[i] = bY2 + (BYTE) ((255 - bY2) * (i - bX2) / (255 - bX2));
  259. }
  260. else
  261. {
  262. // 直接赋值为255
  263. bMap[i] = 255;
  264. }
  265. }
  266. // 每行
  267. for(i = 0; i < lHeight; i++)
  268. {
  269. // 每列
  270. for(j = 0; j < lWidth; j++)
  271. {
  272. // 指向DIB第i行,第j个象素的指针
  273. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  274. // 计算新的灰度值
  275. *lpSrc = bMap[*lpSrc];
  276. }
  277. }
  278. // 返回
  279. return TRUE;
  280. }
  281. /*************************************************************************
  282.  *
  283.  * 函数名称:
  284.  *   InteEqualize()
  285.  *
  286.  * 参数:
  287.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  288.  *   LONG  lWidth       - 源图像宽度(象素数)
  289.  *   LONG  lHeight      - 源图像高度(象素数)
  290.  *
  291.  * 返回值:
  292.  *   BOOL               - 成功返回TRUE,否则返回FALSE。
  293.  *
  294.  * 说明:
  295.  *   该函数用来对图像进行直方图均衡。
  296.  *
  297.  ************************************************************************/
  298. BOOL WINAPI InteEqualize(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  299. {
  300. // 指向源图像的指针
  301. unsigned char* lpSrc;
  302. // 临时变量
  303. LONG lTemp;
  304. // 循环变量
  305. LONG i;
  306. LONG j;
  307. // 灰度映射表
  308. BYTE bMap[256];
  309. // 灰度映射表
  310. LONG lCount[256];
  311. // 图像每行的字节数
  312. LONG lLineBytes;
  313. // 计算图像每行的字节数
  314. lLineBytes = WIDTHBYTES(lWidth * 8);
  315. // 重置计数为0
  316. for (i = 0; i < 256; i ++)
  317. {
  318. // 清零
  319. lCount[i] = 0;
  320. }
  321. // 计算各个灰度值的计数
  322. for (i = 0; i < lHeight; i ++)
  323. {
  324. for (j = 0; j < lWidth; j ++)
  325. {
  326. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * i + j;
  327. // 计数加1
  328. lCount[*(lpSrc)]++;
  329. }
  330. }
  331. // 计算灰度映射表
  332. for (i = 0; i < 256; i++)
  333. {
  334. // 初始为0
  335. lTemp = 0;
  336. for (j = 0; j <= i ; j++)
  337. {
  338. lTemp += lCount[j];
  339. }
  340. // 计算对应的新灰度值
  341. bMap[i] = (BYTE) (lTemp * 255 / lHeight / lWidth);
  342. }
  343. // 每行
  344. for(i = 0; i < lHeight; i++)
  345. {
  346. // 每列
  347. for(j = 0; j < lWidth; j++)
  348. {
  349. // 指向DIB第i行,第j个象素的指针
  350. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  351. // 计算新的灰度值
  352. *lpSrc = bMap[*lpSrc];
  353. }
  354. }
  355. // 返回
  356. return TRUE;
  357. }