开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
Motion.cpp
资源名称：Image_Processing.rar　[点击查看]
上传用户：wangchdtw
上传日期：2014-04-02
资源大小：329k
文件大小：11k
源码类别：

波变换

开发平台：

Visual C++

Motion.cpp：源码内容
  1. #include "GlobalApi.h"
  2. #include "stdafx.h"
  3. #include "cdib.h"
  4. #include "math.h"
  5. /*************************************************************************
  6.  *
  7.  * 函数名称：
  8.  *   GetFileName()
  9.  *
  10.  * 输入参数:
  11.  *   CString strFilePathName - 图象的文件名 
  12.  *   int nCurFrameNum - 当前帧的图象文件名
  13.  *
  14.  * 返回值:
  15.  *   CString - 返回给定帧数的图象文件名
  16.  *
  17.  * 说明:
  18.  *   该函数根据指定文件路径名和当前图象序列的帧数获取图象文件名
  19.  *   该函数中需要注意的是，只能读取0-999帧图象，图象为bmp格式，且按照
  20.  *   帧数数字进行存储，例如第一帧图象文件名为×××001.bmp，第33帧图象
  21.  *   的文件名为×××033.bmp。如果不是bmp文件，则返回"NULL"。
  22.  *
  23.  *************************************************************************
  24.  */
  25. CString GetFileName(CString strFilePathName, int nCurFrameNum)
  26. {
  27. //文件的路径名
  28. CString strTempFileName;
  30. int nNumPos=strFilePathName.Find(".");
  31. if(nNumPos==-1){
  32. AfxMessageBox("Please choose a bmp file");
  33. return "NULL";
  34. }
  36. //表示去掉了扩展名和数字标号的路径名，在这里，限定帧数为0～999，所以采用三位来表示
  37. CString strFileNameNoExtNoNum=strFilePathName.Left(nNumPos-3);
  39. //表示标号的字符串
  40. CString strTempNum;
  42. if(nCurFrameNum<10){
  43. strTempNum.Format("00%d",nCurFrameNum);
  44. }
  45. else {
  46. if(nCurFrameNum<100 &&nCurFrameNum>=10){
  47. strTempNum.Format("0%d",nCurFrameNum);
  48. }
  49. else{
  50. strTempNum.Format("%d",nCurFrameNum);
  51. }
  52. }
  54. // 得到图象文件名
  55. strTempFileName=strFileNameNoExtNoNum+strTempNum+".bmp";
  57. // 返回
  58. return strTempFileName;
  59. }
  61. /*************************************************************************
  62.  *
  63.  * 函数名称：
  64.  *   LoadDibSeq()
  65.  *
  66.  * 输入参数:
  67.  *   CString strFilePath - 第一帧图象的文件名 
  68.  *   int nCurFrameNum - 当前帧的图象文件名
  69.  *   int nTotalFrameNum - 进行检测的图象帧数
  70.  *   CDib* pDib - 指向返回CDib类的指针
  71.  *
  72.  * 返回值:
  73.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  74.  *
  75.  * 说明:
  76.  *   该函数根据指定文件路径名和当前图象序列的帧数读取图象数据道pDib中
  77.  *   该函数中需要注意的是，只能读取0-999帧图象，图象为bmp格式，且按照
  78.  *   帧数数字进行存储，例如第一帧图象文件名为×××001.bmp，第33帧图象
  79.  *   的文件名为×××033.bmp。
  80.  *
  81.  *************************************************************************
  82.  */
  83. BOOL LoadDibSeq(CString strFilePath, int nCurFrameNum, int nTotalFrameNum, CDib* pDib)
  84. {
  85. //一般来讲,程序在处理的过程中需要装载的帧号应该是由外界指定的
  86. //当指定的帧号不合法时,就装载当前帧作为默认值
  87. if (nCurFrameNum<1 || nCurFrameNum>nTotalFrameNum)
  88. {
  89. AfxMessageBox("Invalidate file frame number");
  90. return FALSE;
  91. }
  93. // 获得当前帧的图象文件名
  94. CString strTempFileName;
  95. strTempFileName=GetFileName(strFilePath,nCurFrameNum);
  97. CFile fileOpen=NULL;
  99. // 打开文件并读取
  100. fileOpen.Open(strTempFileName,CFile::modeRead);
  101. if(pDib->Read(&fileOpen)==FALSE){
  102. AfxMessageBox("can not open the file "+strTempFileName);
  103. return FALSE;
  104. }
  105. return TRUE;
  106. }
  109. /*************************************************************************
  110.  *
  111.  * 函数名称：
  112.  *   BinaFrameDiff()
  113.  *
  114.  * 输入参数:
  115.  *   unsigned char* pUnchImg1 - 图象的文件名 
  116.  *   unsigned char* pUnchImg2 - 当前帧的图象文件名
  117.  *   int nWidth
  118.  *   int nHeight
  119.  *   unsigned char* pUnchResult
  120.  *   int nThreshold
  121.  *
  122.  * 返回值:
  123.  *   CString - 返回给定帧数的图象文件名
  124.  *
  125.  * 说明:
  126.  *   该函数比较pUnchImg1和pUnchImg2两个区域中的内容,如果两个区域内     
  127.  *容的差值的绝对值比Threshold大,则将pUnchResult相应的元素设置为逻辑值1,
  128.  *用灰度255表示，否则为0，并用灰度0表示
  129.  *
  130.  *************************************************************************
  131.  */
  132. void BinaFrameDiff(unsigned char *pUnchImg1, unsigned char *pUnchImg2, 
  133.   int nWidth, int nHeight, unsigned char * pUnchResult,
  134.   int nThreshold)
  135. {
  136. int nTemp=0;
  137. for (int i=0;i<nHeight*nWidth;i++) {
  138. nTemp = abs(pUnchImg1[i] - pUnchImg2[i]);
  139. pUnchResult[i] = nTemp > nThreshold ? 255:0;
  140. } 
  141. return ;
  142. }
  144. /*************************************************************************
  145.  *
  146.  * 函数名称：
  147.  *   ErodeFrameDiff()
  148.  *
  149.  * 输入参数:
  150.  *   unsigned char* pUnchImg1 - 图象数据指针
  151.  *   int nWidth - 图象宽度
  152.  *   int nHeight - 图象高度
  153.  *   int nErodeHalfWin - 腐蚀窗口大小的一半
  154.  *   unsigned char* pUnchResult - 结果数据制止
  155.  *   int nThreshold - 阈值
  156.  *
  157.  * 返回值:
  158.  *   无
  159.  *
  160.  * 说明:
  161.  *   该函数进行腐蚀操作,形态学操作对pUnchImg中的每一点,计算这一点对应的
  162.  *窗口内的一些参数,然后根据参数结果给这个点设置相应的值. 功能上相当于广义滤波
  163.  *
  164.  *************************************************************************
  165.  */
  166. void ErodeFrameDiff(unsigned char *pUnchImg, int nWidth, int nHeight, int nErodeHalfWin, 
  167.   int nErodeThreshold, unsigned char *pUnchResult)
  168. {
  169. // 搜索整个图象，对图象进行腐蚀处理
  170. for (int i=nErodeHalfWin;i<nHeight-nErodeHalfWin;i++) {
  171. for (int j=nErodeHalfWin;j<nWidth-nErodeHalfWin;j++) {
  172. // 如果帧间的差不为0才进行处理
  173. if (pUnchImg[i*nWidth+j] != 0) 
  174. {
  175. int iPointCount = 0;
  177. // 根据此点的邻域判断此点是否需要删除
  178. for (int r=-nErodeHalfWin;r<=nErodeHalfWin;r++) {
  179. for (int c=-nErodeHalfWin;c<=nErodeHalfWin;c++) {
  180. if (pUnchImg[(i+r)*nWidth+j+c] != 0) {
  181. iPointCount++;
  182. }
  183. }
  184. }
  186. // 如果邻域中不为0的个数小于设定的阈值，则强行设置为0
  187. if (iPointCount < nErodeThreshold) {
  188. pUnchResult[i*nWidth+j] = 0;
  189. }
  190. else {
  191. pUnchResult[i*nWidth+j] = 255;
  192. }
  193. }
  194. else 
  195. {
  196. pUnchResult[i*nWidth+j] = 0;
  197. }
  198. }
  199. }
  200. return ;
  201. }
  203. /*************************************************************************
  204.  *
  205.  * 函数名称：
  206.  *   GetBackground()
  207.  *
  208.  * 输入参数:
  209.  *   CString strFilePath - 第一帧图象的文件名 
  210.  *   int nTotalFrameNum - 进行检测的图象帧数
  211.  *   int nImageWidth - 图象宽度
  212.  *   int nImageHeight - 图象高度
  213.  *   unsigned char * pUnchBackGround - 指向返回背景数据的指针
  214.  *
  215.  * 返回值:
  216.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  217.  *
  218.  * 说明:
  219.  *   该函数根据指定文件名的图象序列求取静止背景
  220.  *
  221.  *************************************************************************
  222.  */
  223. BOOL GetBackground(CString strFilePath, int nTotalFrameNum, int nImageWidth, 
  224.    int nImageHeight, unsigned char* pUnchBackGround)
  225. {
  226. // 如果此时背景已经生成,函数返回,不需要再一次计算
  227. /*if (pUnchBackGround!=NULL){
  228. return TRUE;
  229. }*/
  232. // pUnchTemp1和pUnchTemp2用来计算相邻两帧之间的帧差
  233. // 每次只要读入一帧即可,即:假设刚刚比较k-1和k帧,那么现在比较k和
  234. // k+1帧,那么k帧是不需要重新读入的
  235. unsigned char* pUnchTemp1;
  236. unsigned char* pUnchTemp2;
  238. pUnchTemp1 = new unsigned char[nImageWidth * nImageHeight * sizeof(unsigned char)];
  239. pUnchTemp2 = new unsigned char[nImageWidth * nImageHeight * sizeof(unsigned char)];
  241. // 临时存放图象数据的CDib指针
  242. CDib* pDibTemp;
  243. pDibTemp = new CDib;
  245. // 读出第一帧数据并放入pDibTemp
  246. pDibTemp->Empty();
  247. if(!LoadDibSeq(strFilePath,1,nTotalFrameNum,pDibTemp)){
  248. return FALSE;
  249. }
  251. // 然后将数据取出，存放在pUnchTemp1中
  252. memcpy(pUnchTemp2,pDibTemp->m_lpImage,nImageWidth*nImageHeight*sizeof(unsigned char));
  254. // pChResultAfterMor 是用来记录帧间变化的内存区域
  255. unsigned char * pUnchTrackBox = new unsigned char[(nTotalFrameNum)*
  256. nImageWidth*nImageHeight*sizeof(unsigned char)];
  258. unsigned int index = 0;
  260. // 帧间差的区域,二进制
  261. unsigned char *pUnchTemp3=new unsigned char[nImageWidth*nImageHeight*sizeof(unsigned char)];
  263. // 腐蚀之后的区域,二进制
  264. unsigned char * pUnchResultAfterMor = new unsigned char[nImageWidth*nImageHeight*sizeof(unsigned char)];
  266. // 对每一帧进行比较
  267. for (int i = 2; i<nTotalFrameNum-1; i++) {
  268. // 打开第i帧图象文件，并将图象存放在CDib对象pDibTemp中
  269. pDibTemp->Empty();
  270. if(!LoadDibSeq(strFilePath , i , nTotalFrameNum , pDibTemp)){
  271. return FALSE;
  272. }
  274. // 然后将数据取出，存放在pUnchTemp2中
  275. memcpy(pUnchTemp2,pDibTemp->m_lpImage,nImageWidth*nImageHeight);
  277. // 对图象帧差进行二值化处理，并将二值化后的图象存放在pUnchTemp3中
  278. BinaFrameDiff(pUnchTemp1,pUnchTemp2 ,nImageWidth,nImageHeight,pUnchTemp3,10);
  280. // 对二值化后的图象进行腐蚀处理，在这里对腐蚀窗口的大小设置为2，阈值为7
  281. ErodeFrameDiff(pUnchTemp3,nImageWidth,nImageHeight,2,7,pUnchResultAfterMor);
  283. // 将此二值化后的程序放入pUnchTrackBox的相应位置
  284. memcpy(pUnchTrackBox+index,pUnchResultAfterMor,sizeof(unsigned char)*nImageWidth*nImageHeight);
  286. // 计算图象数据在pUnchTrackBox中的偏移量
  287. index = index + nImageWidth*nImageHeight*sizeof(unsigned char);
  289. // 每做完两帧之间的比较,就使帧号下移一个,pUnchTemp1中是存k帧内容,pUnchTemp2帧是存k+1
  290. // 帧内容,所以,每次只要把pUnchTemp2中的内容给pTemp1,而pTemp2重新读入既可以了.
  291. unsigned char* pUnchTag = NULL;
  293. pUnchTag   = pUnchTemp1;
  294. pUnchTemp1 = pUnchTemp2;
  295. pUnchTemp2 = pUnchTag;
  296. }
  298. // 释放已分配内存
  299. delete []pUnchTemp1;
  300. pUnchTemp1 = NULL;
  301. delete []pUnchTemp2;
  302. pUnchTemp2 = NULL;
  303. delete []pUnchTemp3;
  304. pUnchTemp3 = NULL;
  305. delete []pUnchResultAfterMor;
  306. pUnchResultAfterMor=NULL;
  308. // 每一帧的大小
  309. int nFrameSize = nImageWidth * nImageHeight * sizeof(unsigned char);
  311. // 记录最大长度
  312. int * pnTrackSegLen = new int [nImageWidth*nImageHeight];
  314. // 记录最大长度中的中间帧标号
  315. int * pnTrackSegFrame = new int [nImageWidth*nImageHeight];
  317. // 对每一个象素点跟踪最大为0的长度，并将最大长度中的中间帧标号记录下来
  318. for (int y = 0; y<nImageHeight; y++) {
  319. for (int x = 0; x<nImageWidth; x++) {
  320. // 此象素在一帧那相对于该帧第一个元素的偏移量
  321. int offset = y * nImageWidth + x;
  323. // 初始化最大长度
  324. int largeLen = 0;
  325. int t = 1;
  327. // 连续为0的段的开始和结束帧标号
  328. int segStart,segEnd;
  330. // 跟踪长度
  331. int segLen;
  333. // 当前帧数
  334. int frameNum;
  336. segLen = 0;
  337. frameNum = 1;
  339. // 遍历整个序列，跟踪并记录此点连续为0的最大长度
  340. while (t < nTotalFrameNum - 1) {
  341. // 如果还没有到达序列结束并且此点的不为0，则继续到下一帧搜索
  342. while ((t < nTotalFrameNum -1) && (pUnchTrackBox[t*nFrameSize+offset] != 0))
  343. t++;
  345. //如果此时的t>= nTotalFrameNum - 1,则说明,已经遍历到最后一帧了
  346. if (t >= nTotalFrameNum - 1)
  347. break;
  349. // 此时应为此长度的开始
  350. segStart = t;
  352. while ((t < nTotalFrameNum - 1) && (pUnchTrackBox[t*nFrameSize+offset] == 0))
  353. t++;
  355. // 此长度的结束帧标号
  356. segEnd = t - 1;
  358. // 获得此连续为0的帧的长度
  359. segLen = segEnd +1 -segStart;
  361. // 判断是否为最大长度，是则进行替换
  362. if (segLen > largeLen) {
  363. largeLen = segLen;
  364. frameNum = (segEnd + segStart)/2;
  365. }
  366. } 
  368. pnTrackSegLen[offset] = largeLen;
  369. pnTrackSegFrame[offset] = frameNum;
  370. }
  371. }
  373. delete []pUnchTrackBox; pUnchTrackBox=NULL;
  375. // 因为对每个象素而言,背景可能出现在不同帧里,此时需要把所有帧调入内存
  376. unsigned char* pBuffer = new unsigned char[nTotalFrameNum*(nImageWidth*nImageHeight)];
  378. for (int k=1; k<nTotalFrameNum; k++) {
  379. pDibTemp->Empty();
  380. LoadDibSeq(strFilePath , k , nTotalFrameNum , pDibTemp);
  382. // 然后将数据取出，存放在pBuffer的相应位置中
  383. memcpy(pBuffer+k*nFrameSize,pDibTemp->m_lpImage,nImageWidth*nImageHeight);
  384. }
  386. // 遍历整个图象，设置背景数据
  387. for (y=0; y<nImageHeight; y++) {
  388. for (int x=0; x<nImageWidth; x++) {
  389. // 获得此象素点在一帧数据中的偏移量
  390. int k = y * nImageWidth + x;
  392. // 获得此象素点连续为0的最大长度的中间帧标号
  393. int nFrameMax = pnTrackSegFrame [k];
  395. // 设置具有最大长度的中间帧的数据为背景数据
  396. pUnchBackGround[k] = pBuffer[(nFrameMax*nFrameSize)+k];
  397. }
  398. }
  400. delete []pnTrackSegLen; 
  401. pnTrackSegLen=NULL;
  402. delete []pnTrackSegFrame;
  403. pnTrackSegFrame=NULL;
  404. delete []pBuffer; 
  405. pBuffer=NULL;
  407. ::SetCursor(::LoadCursor(NULL, IDC_ARROW));
  409. return TRUE;
  410. }