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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
ImageObject.cpp
资源名称：LPR.rar　[点击查看]
上传用户：jjiangjuan
上传日期：2013-03-27
资源大小：59k
文件大小：24k
源码类别：

波变换

开发平台：

Visual C++

ImageObject.cpp：源码内容
  1. // ImageObject.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "LPR.h"
  6. #include "ImageObject.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  14. /////////////////////////////////////////////////////////////////////////////
  15. // CImageObject
  16. BYTE BMPRec[COL*ROW*3];
  17. BYTE GraftBuf[COL][ROW];
  18. int FINISHED[COL][ROW],Closed[COL][ROW],VetorRec[COL][ROW];
  20. CImageObject::CImageObject()
  21. {
  22. lpBuf=NULL;
  23. LPLocated = false;
  24. StrongStrech = false;
  25. }
  27. CImageObject::~CImageObject()
  28. {
  29. }
  32. BEGIN_MESSAGE_MAP(CImageObject, CStatic)
  33. //{{AFX_MSG_MAP(CImageObject)
  34. ON_WM_PAINT()
  35. //}}AFX_MSG_MAP
  36. END_MESSAGE_MAP()
  38. /////////////////////////////////////////////////////////////////////////////
  39. // CImageObject message handlers
  41. void CImageObject::OnPaint() 
  42. {
  43. CPaintDC dc(this); // device context for painting
  45. // TODO: Add your message handler code here
  47. // Do not call CStatic::OnPaint() for painting messages
  48. HDC hDC;
  49. hDC = dc.GetSafeHdc();
  50. if(lpBuf!=NULL&&LPLocated!=true)
  51. {
  53.     StretchDIBits(hDC,
  54.            0,
  55.    0,
  56.    bitmapinfoheader.biWidth,
  57.    bitmapinfoheader.biHeight,
  58.    0,
  59.    0,
  60.    bitmapinfoheader.biWidth,
  61.    bitmapinfoheader.biHeight,
  62.    lpBuf,
  63.    pbi,
  64.    DIB_RGB_COLORS,
  65.    SRCCOPY);
  66.   }
  67. else
  68. if(LPLocated==true)
  69. {
  70. StretchDIBits(hDC,
  71.            0,
  72.    0,
  73.    bitmapinfoheader.biWidth,
  74.    bitmapinfoheader.biHeight,
  75.    0,
  76.    0,
  77.    bitmapinfoheader.biWidth,
  78.    bitmapinfoheader.biHeight,
  79.    BMPRec,
  80.    pbi,
  81.    DIB_RGB_COLORS,
  82.    SRCCOPY);
  84. }
  85. }
  87. void CImageObject::LoadBmp()
  88. {
  89.    LPLocated=false;
  90.    CString strPath;
  91.    CFile file;
  92.    CFileDialog *openFile = new CFileDialog(TRUE,"bmp","*.bmp",NULL,"Bitmap Files(*.bmp)",NULL);
  93.    if(openFile->DoModal() == IDOK)
  94.    {
  95.     strPath = openFile->GetPathName();
  96.     if(file.Open(strPath,CFile::modeRead|CFile::shareDenyNone,NULL)==0)
  97.   {
  98.   AfxMessageBox("无法开文件！",MB_OK,0);
  99. return;
  100. }
  102.   file.Read(&bitmapfileheader,sizeof(bitmapfileheader));
  103.  
  104. file.Read(&bitmapinfoheader,sizeof(bitmapinfoheader));
  105.   numQuad=0;
  106.   if(bitmapinfoheader.biBitCount<24)
  107.   {
  108.   numQuad=1<<bitmapinfoheader.biBitCount;
  109.   }
  111.   pbi=(BITMAPINFO*) HeapAlloc(GetProcessHeap(),0,sizeof(BITMAPINFOHEADER)+numQuad*sizeof(RGBQUAD));
  112.   memcpy(pbi,&bitmapinfoheader,sizeof(bitmapinfoheader));
  113.   quad=(RGBQUAD*)((BYTE*)pbi+sizeof(BITMAPINFOHEADER));
  114.  
  115.   if(numQuad!=0)
  116.   {
  117.   file.Read(quad,sizeof(RGBQUAD)*numQuad);
  118.   }
  119.   bitmapinfoheader.biSizeImage=bitmapfileheader.bfSize-bitmapfileheader.bfOffBits;
  120.   lpBuf=(BYTE*)HeapAlloc(GetProcessHeap(),0,bitmapinfoheader.biSizeImage);
  121.  
  122.   file.Read(lpBuf,bitmapinfoheader.biSizeImage);
  123.         
  124.   file.Close();
  125.    }
  126.         Invalidate (FALSE);
  128. }
  130. void CImageObject::gray(BYTE lpData[COL][ROW])
  131. {
  132.     
  133. BYTE GrayLevel;
  134. int i,j,k;
  135. int w = bitmapinfoheader.biWidth;
  136. int h = bitmapinfoheader.biHeight;
  137.     for(i = 0; i < h ;i++)
  138. {
  140. for(j = 0; j < w;j++)
  141. {
  142. k = i*w+j;
  143. GrayLevel = BYTE(0.299*lpBuf[k*3] + 0.587*lpBuf[k*3+1] + 0.114 * lpBuf[k*3+2]);
  144.             BMPRec[k*3]=lpBuf[k*3];
  145.             BMPRec[k*3+1]=lpBuf[k*3+1];
  146. BMPRec[k*3+2]=lpBuf[k*3+2];
  147. lpBuf[k*3] = GrayLevel;
  148. lpBuf[k*3+1] = GrayLevel;
  149. lpBuf[k*3+2] = GrayLevel;
  150. lpData[i][j]=GrayLevel;
  151. GraftBuf[i][j] = GrayLevel;
  152.     
  153. }
  154. }
  155.    
  156. Invalidate(FALSE);
  158. }
  160. void CImageObject::InteEqualize(BYTE lpData[COL][ROW],int lCount[])
  161. {
  162. int lTemp, i, j;
  163. // 灰度映射表
  164. BYTE bMap[256];
  166. for(i = 0; i < 256; i++)
  167. {
  168. bMap[i] = 0;
  169. }
  171.     // 计算灰度映射表
  172. for (i = 0; i < 256; i++)
  173. {
  174. // 初始为0
  175. lTemp = 0;
  177. for (j = 0; j <= i ; j++)
  178. {
  179. lTemp += lCount[j];
  180. }
  182. // 计算对应的新灰度值
  183. bMap[i] = (BYTE) ((lTemp * 254+i) / COL / ROW);
  184. } 
  186. int w = bitmapinfoheader.biWidth;
  187. int h = bitmapinfoheader.biHeight;
  188. for(i = 0; i < h; i++)
  189. {
  190. for(j = 0; j < w; j++)
  191. {
  192.   GraftBuf[i][j] = bMap[GraftBuf[i][j]];
  193.   lpData[i][j] = GraftBuf[i][j];
  194. }
  195. }
  196. this->Graft2BmpData();
  197. Invalidate(FALSE);
  200. }
  202. void CImageObject::GetEdge()
  203. {
  204. int i,j;
  205. BYTE TempBuf[COL][ROW];
  208. for(j=1;j<ROW;j++)//changed
  209. {
  210. for(i=0;i<COL;i++)//changed
  211. {
  212.             TempBuf[i][j-1]=abs(GraftBuf[i][j]-GraftBuf[i][j-1]);//)<100)?2*abs(GraftBuf[i][j]-GraftBuf[i][j-1]):abs(GraftBuf[i][j]-GraftBuf[i][j-1]);
  214. if(TempBuf[i][j-1]<=20)
  215.                TempBuf[i][j-1]=0;
  216.           
  218.     if(j==ROW-1)
  219. TempBuf[i][j]=0;
  220. }
  221. }
  223. for(i=1;i<COL;i++)
  224.         for(j=0;j<ROW;j++)
  225. {
  226.             if(abs(GraftBuf[i][j]-GraftBuf[i-1][j])>=TempBuf[i-1][j])
  227.                   TempBuf[i-1][j]=abs(GraftBuf[i][j]-GraftBuf[i-1][j]);//(abs(GraftBuf[i][j]-GraftBuf[i-1][j])<100)?2*abs(GraftBuf[i][j]-GraftBuf[i-1][j]):abs(GraftBuf[i][j]-GraftBuf[i-1][j]);//+TempBuf[i-1][j]+50;
  229. if(i==COL-1)
  230. TempBuf[i][j]=0;
  232. GraftBuf[i-1][j]=TempBuf[i-1][j];
  233. }
  235. for(i=0;i<COL;i++)
  236. for(j=0;j<ROW;j++)
  237. Closed[i][j]=NOTSEARCH;
  239. this->Graft2BmpData();
  242. }
  244. void CImageObject::Graft2BmpData()
  245. {
  246.    int i,j,k;
  247.    int h = bitmapinfoheader.biHeight;
  248.    int w = bitmapinfoheader.biWidth;
  249.    for(i=0;i< h;i++)
  250.    {
  251.    
  252.    for(j=0;j< w;j++)
  253.    {
  254.    k = i*w+j;
  255.    lpBuf[k*3]=GraftBuf[i][j];
  256.            lpBuf[k*3+1]=GraftBuf[i][j];
  257.    lpBuf[k*3+2]=GraftBuf[i][j];
  258.    }
  259.    }
  260. }
  262. void CImageObject::DelNoise()
  263. {
  264.     int i,j;
  265.     int sum=0,num1=0;
  267. EdgeTest();
  269. for(j=0;j<ROW;j++)
  270. {
  271. for(i=0;i<COL;i++)
  272. {
  273. if(FINISHED[i][j]!=SEARCHED)
  274. {
  275. sum=0;
  276. FilterDirectionPix(Closed[i][j],i,j,sum);      
  277. }
  278. }
  279. }
  281. for(j=0;j<ROW;j++)
  282. for(i=0;i<COL;i++)
  283.   FINISHED[i][j]=NOTSEARCH;
  285. for(i=0;i<COL;i++)
  286. {
  287. for(j=0;j<ROW;j++)
  288. {
  289. if((Closed[i][j]==9||Closed[i][j]==10)&&GraftBuf[i][j]!=0)
  290. GraftBuf[i][j]=0;
  291. if(FINISHED[i][j]==NOTSEARCH)
  292. {
  293. sum=0;
  294. ResetNoise(Closed[i][j],i,j,sum);
  295. }  
  296. }
  297. }
  299. this->Graft2BmpData();
  300. Invalidate(FALSE);
  301. }
  303. void CImageObject::EdgeTest()
  304. {
  305. nDir=NODIRECT;
  306. int i,j;
  307. for(i=0;i<COL;i++)
  308. for(j=0;j<ROW;j++)
  309. {
  310. Closed[i][j]=NOTSEARCH;
  311. FINISHED[i][j]=NOTSEARCH;
  312. }
  314. for(i=1;i<COL-1;i++)
  315. for(j=1;j<ROW-1;j++)
  316. {
  317. if(GraftBuf[i][j]==0)
  318.                 Closed[i][j]=NODIRECT;
  319. if(GraftBuf[i][j]!=0 && Closed[i][j]==NOTSEARCH)
  320. {
  321. int zigzag=6;
  322.                 sort(i,j,NODIRECT,zigzag);   
  323.               if(Closed[i][j]==NODIRECT)
  324. GraftBuf[i][j]=0;
  325. }
  326.             VetorRec[i][j]=Closed[i][j];
  327. }
  329. }
  331. int CImageObject::sort(int i, int j, int direct, int &zigzag)
  332. {
  333. int x,y;
  334. x=j;
  335. y=i;
  336. Closed[i][j]=GetSimiUnSearchPix(x,y);
  337. ZigzagFilter(zigzag,direct,Closed[i][j],y,x);
  338. if(Closed[i][j]==NODIRECT||zigzag<=0)
  339. {
  340. ///////////GetSimiUnSearchPix
  341. if(zigzag<=0)
  342. {
  343. Closed[y][x]=NODIRECT;//degrade gradually
  344. GraftBuf[y][x]=0;
  345. }
  346.         return Closed[i][j];//graftbuf[i][j]可能不为0
  347. }
  348. if(GraftBuf[y][x]==0&&Closed[y][x]==NODIRECT)
  349. {
  350.         Closed[i][j]=NODIRECT;
  351. return Closed[i][j];
  352. }
  353. if(x==ROW-1||y==COL-1||x==0||y==0)
  354. return Closed[i][j];
  355. else{
  356. //{
  357. int TAG=sort(y,x,Closed[i][j],zigzag);
  358. if(TAG!=NODIRECT)
  359. {
  360. if(zigzag<=0)
  361. {//degrade gradually,compare 2 directions
  362. if(Closed[i][j]!=TAG)
  363. {
  364. GraftBuf[y][x]=0;
  365. Closed[y][x]=NODIRECT;
  366. return Closed[i][j];
  367. }
  368. else{
  369. return Closed[i][j];//a sequence of same directions but zigzag=0
  370. }
  372. }
  373. else{//degrade suddently,zigzag!=0
  374. return Closed[i][j];
  375. }
  376. }
  377. else
  378. {
  379.                 return Closed[i][j];
  380. }
  382. }
  384. }
  386. int CImageObject::GetSimiUnSearchPix(int &xPos, int &yPos)
  387. {
  388. int Simi=255,x,y;
  389. x=xPos;
  390. y=yPos;
  391.     for(int i=y-1;i<=y+1;i++)
  392. for(int j=x-1;j<=x+1;j++)
  393. {
  394. if(GraftBuf[i][j]==0)
  395. Closed[i][j]=NODIRECT;
  397. if((i!=y||j!=x)&&Closed[i][j]==NOTSEARCH)
  398. {
  399. if(Simi>abs(GraftBuf[y][x]-GraftBuf[i][j]))
  400. {
  401.                     Simi=abs(GraftBuf[y][x]-GraftBuf[i][j]);
  402. yPos=i;
  403. xPos=j;
  404. }                
  405. }
  406. }
  407.     return GetDirection(x,y,xPos,yPos);
  409. }
  411. void CImageObject::ZigzagFilter(int &zigzag, int direct0, int direct1, int i, int j)
  412. {
  413. switch(direct0)
  414. {
  415. case UP:switch (direct1)
  416. {
  417. case UP:zigzag++; return;
  418. case LEFT:
  419. case RIGHT:zigzag-=1;return;//zig-=2
  420. case UPRIGHT:
  421. case UPLEFT:return;
  422. default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  423. }
  425.     case UPRIGHT:switch (direct1)
  426.  {
  427.                case UP: 
  428.                case RIGHT: return;
  429.                case UPRIGHT:zigzag-=1;return;
  430.                default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  431.  }
  432. case UPLEFT:switch (direct1)
  433. {
  434.               case UP: 
  435.               case LEFT: return;
  436.               case UPLEFT:zigzag-=1;return;
  437.               default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  438. }
  439. case LEFT:switch (direct1)
  440.   {
  441. case LEFT: zigzag++; return;
  442. case UP:
  443. case DOWN:zigzag-=1;return;
  444. case DOWNLEFT:
  445. case UPLEFT:return;
  446. default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  447.   }
  448. case RIGHT:switch (direct1)
  449.    {
  450. case RIGHT:zigzag++; return;
  451. case UP:
  452. case DOWN:zigzag-=1;return;
  453. case DOWNRIGHT:
  454. case UPRIGHT:return;
  455. default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  456.    }
  457. case DOWN:switch (direct1)
  458.   {
  459. case DOWN:zigzag++; return;
  460. case LEFT:
  461. case RIGHT:zigzag-=1;return;
  462. case DOWNRIGHT:
  463. case DOWNLEFT:return;
  464. default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  465.   }
  466. case DOWNRIGHT:switch (direct1)
  467.    {
  468.                   case DOWN: 
  469.                   case RIGHT: return;
  470.                   case DOWNRIGHT:zigzag-=1;return;
  471.                   default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  472.    }
  473. case DOWNLEFT:switch (direct1)
  474.   {
  475.                 case DOWN: 
  476.                     case LEFT: return;
  477.     case DOWNLEFT:zigzag-=1;return;
  478.     default:GraftBuf[i][j]=0;Closed[i][j]=NODIRECT;return;
  479.   }
  480. default:return;
  481. }
  483. }
  485. void CImageObject::FilterDirectionPix(int direct, int i, int j, int &tol)
  486. {
  487.  int  nDir;
  488.      switch(direct)
  489.  {
  490.      case UP:nDir=GetVetor(i+1,j);   
  491.   if(nDir==direct)
  492.   {
  493.   tol++;
  494.   FilterDirectionPix(nDir,i+1,j,tol);
  495.   }
  497.      break;
  498.      case DOWN:nDir=GetVetor(i-1,j);
  499.  if(nDir==direct)
  500.  {
  501.  tol++;
  502.  FilterDirectionPix(nDir,i-1,j,tol);
  503.  }
  505.  break;
  506.  case LEFT:nDir=GetVetor(i,j-1);
  507.        if(nDir==direct)
  508.    {
  509.    tol++;
  510.    FilterDirectionPix(nDir,i,j-1,tol);
  511.    }
  513.  break;
  514.  case RIGHT:nDir=GetVetor(i,j+1);
  515.  if(nDir==direct)
  516.  {
  517.  tol++;
  518.  FilterDirectionPix(nDir,i,j+1,tol);
  519.  }
  521.  break;
  522.  case UPRIGHT:nDir=GetVetor(i+1,j+1);
  523.  if(nDir==direct)
  524.  {
  525.  tol++;
  526.  FilterDirectionPix(nDir,i+1,j+1,tol);
  527.  }
  529.  break;
  530.  case UPLEFT:nDir=GetVetor(i+1,j-1);
  531.  if(nDir==direct)
  532.  {
  533.  tol++;
  534.  FilterDirectionPix(nDir,i+1,j-1,tol);
  535.  }
  537.  break;
  538.  case DOWNRIGHT:nDir=GetVetor(i-1,j+1);
  539.  if(nDir==direct)
  540.  {
  541.  tol++;
  542.  FilterDirectionPix(nDir,i-1,j+1,tol);
  543.  }
  545.  break;
  546.  case DOWNLEFT:nDir=GetVetor(i-1,j-1);
  547.  if(nDir==direct)
  548.  {
  549.  tol++;
  550.  FilterDirectionPix(nDir,i-1,j-1,tol);
  551.  }
  552.  
  553.  break;
  555.  default:break;
  556.  }
  558.      FINISHED[i][j]=SEARCHED;
  559.  if(tol<5||tol>80)
  560.  {
  561.  GraftBuf[i][j]=0;
  562.  Closed[i][j]=NODIRECT;
  563.  }
  565.  return;
  567. }
  569. int CImageObject::GetVetor(int i, int j)
  570. {
  571.  return Closed[i][j];
  572. }
  574. void CImageObject::ResetNoise(int direct, int i, int j, int &tol)
  575. {
  576. switch(direct) {
  577.    case LEFT:   
  578.    if(GetVetor(i,j-1)==direct)
  579.    {
  580.    tol++;
  581.    if(j-1>0)
  582.    ResetNoise(Closed[i][j-1],i,j-1,tol);
  583.    }
  584.        break;
  585.    case RIGHT:
  586.    if(GetVetor(i,j+1)==direct)
  587.    {
  588.    tol++;
  589.    if(j+1<ROW)
  590.    ResetNoise(Closed[i][j+1],i,j+1,tol);
  591.    }
  592.        break;
  593.    default:break;
  594.    }
  595.    FINISHED[i][j]=SEARCHED;
  596.    if(tol>80)
  597.    {
  598.    GraftBuf[i][j]=0;
  599.    Closed[i][j]=NODIRECT;
  600.    }
  602.    return;
  604. }
  606. int CImageObject::GetDirection(unsigned int x0, unsigned int y0, unsigned int x1, unsigned int y1)
  607. {
  608. bool forward=(x1-x0)>0;
  609.     switch (forward)
  610. {
  611. case true:{
  612.           if((y1-y0)==0)
  613.   return RIGHT;
  614.   if((y1-y0)>0)
  615.   return UPRIGHT;
  616.   else
  617.   return DOWNRIGHT;
  618.   }
  620. case false:{
  621.           if((x1-x0)==0)
  622.   {
  623.   if((y1-y0)>0)
  624.   return UP;
  625.   if(y1-y0==0)
  626.   {
  627.  // GraftBuf[x0][y0]=0;
  628.   return NODIRECT;
  629.   }
  630.   else
  631.   return DOWN;   
  632.   }
  633.   if(y1-y0>0)
  634.   return UPLEFT;
  635.   if(y1-y0==0)
  636.   return LEFT;
  637.   if(y1-y0<0)
  638.   return DOWNLEFT;
  639.    }
  640. }
  642. }
  644. LPCandidate * CImageObject::GetLPPos()
  645. {
  646. int i,j,tolerance;
  647. plumb *cur,*p;
  648.    
  649. cur=&LPYBorder;
  650. for(j=0;j<ROW;j++)
  651. for(i=0;i<COL;i++)
  652. FINISHED[i][j]=NOTSEARCH;
  654. for(j=1;j<ROW;j++)
  655. for(i=1;i<COL;i++)
  656. {
  657. if((Closed[i][j]==UP||Closed[i][j]==DOWN)&&FINISHED[i][j]==NOTSEARCH)
  658. {
  659. int x=j,y=i;
  660. p=new plumb;
  661. p->direct=Closed[i][j];
  662. p->i0=i;
  663. p->j0=j;
  664. Cruiser(Closed[i][j],y,x);
  665. p->i1=y;
  666. p->j1=x;
  667. p->next=NULL;
  668. cur->next=p;
  669. cur=cur->next;
  670. }
  671. }
  673. cur=&LPXBorder;
  674. for(j=0;j<ROW;j++)
  675. for(i=0;i<COL;i++)
  676. FINISHED[i][j]=NOTSEARCH;
  679. for(i=1;i<COL;i++)
  680. for(j=1;j<ROW;j++)
  681. {
  682. if((Closed[i][j]==LEFT||Closed[i][j]==RIGHT)&&FINISHED[i][j]==NOTSEARCH)
  683. {
  684. int x=j,y=i;
  685. p=new plumb;
  686. p->direct=Closed[i][j];
  687. p->i0=i;
  688. p->j0=j;
  689. Cruiser(Closed[i][j],y,x);
  690. p->i1=y;
  691. p->j1=x;
  692. p->next=NULL;
  693. cur->next=p;
  694. cur=cur->next;
  695. }
  696. }
  698.    LPCandidate *pLP=&LPC;
  699.    p=LPYBorder.next;
  700.    while(p!=NULL)
  701.    {
  702.    plumb *cur=p->next;    
  703.    while(cur!=NULL)
  704.    {
  705.    if(abs(cur->j0-p->j0)>70&&abs(cur->j0-p->j0)<=150&&((p->i0>=cur->i0&&p->i0<=cur->i1)||(p->i1>=cur->i0&&p->i1<=cur->i1)))
  706.    {
  707.        LPCandidate * LPP=new LPCandidate;
  708.        plumb *ptr0=SelectEdge(p->j0,p->i0,cur->j0,cur->i0,DOWN);
  709.        LPP->x1=cur->j0;LPP->y1=ptr0->i0;
  710.        plumb *ptr1=SelectEdge(p->j0,p->i1,cur->j0,cur->i1,UP);
  711.        LPP->x0=p->j0;LPP->y0=ptr1->i0;
  712.                if(LPP->y0-LPP->y1<30&&LPP->y0-LPP->y1>15)
  713.    {
  714.    LPP->next=NULL;
  715.            pLP->next=LPP;
  716.        pLP=pLP->next;
  717.    }
  718.    else
  719.    {
  720.    delete LPP;
  721.    }
  722.    }
  723.    cur=cur->next;    
  724.    }
  725.    p=p->next;
  726.    }
  727.    /////纹理分析，叠加直方图均衡化图
  728.    double C=0,max=0;
  729.    P=NULL;
  730.    pLP=LPC.next;
  731.    if(pLP!=NULL)
  732.    while (pLP!=NULL) {
  733.    C=double(RAStat(pLP->x0,pLP->y0,pLP->x1,pLP->y1))/double(pLP->x1-pLP->x0);//double(pLP->x1-pLP->x0);
  734.    if((C>max||double(C/max)>0.9)&&double(pLP->x1-pLP->x0)/double(pLP->y0-pLP->y1)>3.2)//&&double(pLP->x1-pLP->x0)/double(pLP->y0-pLP->y1)<4)
  735.    {   
  736.    if(P!=NULL&&max>C)
  737.    {
  738.    if(abs(160-(pLP->x1+pLP->x0)/2)<abs(160-(P->x1+P->x0)/2))
  739.    {
  740.        max=C;
  741.            P=pLP;
  742.    }
  743.    }
  744.    else
  745.    {
  746.    max=C;
  747.    P=pLP;
  748.    }
  749.    }
  750.    pLP=pLP->next;
  751.    }
  752.   
  753.    if(P!=NULL)
  754.    {
  755.    LPLocated=true;
  756.    if(double(P->x1-P->x0)/double(P->y0-P->y1)>3.8)//扩充边界到上一边缘，修改LPLOCATE 结构
  757.    {
  758.    P->x0-=12;
  759.            P->x1+=6;
  760.    P->y0+=10;
  761.    P->y1-=10;
  762.    }
  763.    else
  764.    {
  765.    P->x0-=16;
  766.            P->x1+=10;
  767.    P->y0+=6;
  768.    P->y1-=6;
  769.    }
  770.        int k=0;
  773.    for(i=P->y1;i<=P->y0;i++)
  774.    {
  775.    BMPRec[i*ROW*3+P->x0*3]=0;
  776.    BMPRec[i*ROW*3+P->x0*3+1]=255;
  777.    BMPRec[i*ROW*3+P->x0*3+2]=0;
  778.    BMPRec[i*ROW*3+P->x1*3]=0;
  779.    BMPRec[i*ROW*3+P->x1*3+1]=255;
  780.    BMPRec[i*ROW*3+P->x1*3+2]=0;
  781.    
  782.    BMPRec[i*ROW*3+(P->x0-1)*3]=0;
  783.    BMPRec[i*ROW*3+(P->x0-1)*3+1]=255;
  784.    BMPRec[i*ROW*3+(P->x0-1)*3+2]=0;
  785.    BMPRec[i*ROW*3+(P->x1-1)*3]=0;
  786.    BMPRec[i*ROW*3+(P->x1-1)*3+1]=255;
  787.    BMPRec[i*ROW*3+(P->x1-1)*3+2]=0;
  789.    BMPRec[i*ROW*3+(P->x0+11)*3]=0;
  790.    BMPRec[i*ROW*3+(P->x0+1)*3+1]=255;
  791.    BMPRec[i*ROW*3+(P->x0+1)*3+2]=0;
  792.    BMPRec[i*ROW*3+(P->x1+1)*3]=0;
  793.    BMPRec[i*ROW*3+(P->x1+1)*3+1]=255;
  794.    BMPRec[i*ROW*3+(P->x1+1)*3+2]=0;
  795.    }
  796.    
  797.    for(j=P->x0;j<=P->x1;j++)
  798.    {
  799.    BMPRec[P->y0*ROW*3+j*3]=0;
  800.    BMPRec[P->y0*ROW*3+j*3+1]=255;
  801.    BMPRec[P->y0*ROW*3+j*3+2]=0;
  802.    BMPRec[P->y1*ROW*3+j*3]=0;
  803.    BMPRec[P->y1*ROW*3+j*3+1]=255;
  804.    BMPRec[P->y1*ROW*3+j*3+2]=0; 
  806.    BMPRec[(P->y1-1)*ROW*3+j*3]=0;
  807.    BMPRec[(P->y1-1)*ROW*3+j*3+1]=255;
  808.    BMPRec[(P->y1-1)*ROW*3+j*3+2]=0;
  809.    BMPRec[(P->y1-1)*ROW*3+j*3]=0;
  810.    BMPRec[(P->y1-1)*ROW*3+j*3+1]=255;
  811.    BMPRec[(P->y1-1)*ROW*3+j*3+2]=0; 
  813.    BMPRec[(P->y0+1)*ROW*3+j*3]=0;
  814.    BMPRec[(P->y0+1)*ROW*3+j*3+1]=255;
  815.    BMPRec[(P->y0+1)*ROW*3+j*3+2]=0;
  816.    BMPRec[(P->y0+1)*ROW*3+j*3]=0;
  817.    BMPRec[(P->y0+1)*ROW*3+j*3+1]=255;
  818.    BMPRec[(P->y0+1)*ROW*3+j*3+2]=0; 
  819.    }
  820.    }
  823.   if(!LPLocated)
  824.       Graft2BmpData();
  825.    else
  826.   Graft2BmpData(BMPRec);
  827.    Invalidate(FALSE);
  829.    return P;
  831. }
  833. void CImageObject::Cruiser(int direct, int &i, int &j)
  834. {
  835. int x=j,y=i;
  836. if(direct==DOWN||direct==UP)
  837. switch(direct) {
  838. case DOWN:
  839. if(GetVetor(i-1,j)==direct&&i-1>0)
  840. {
  841. i--;
  842.             Cruiser(DOWN,i,j);
  843. }
  844. break;
  845. case UP:
  846. if(GetVetor(i+1,j)==direct&&i+1<COL)
  847. {
  848. i++;
  849.             Cruiser(UP,i,j);
  850. }
  851. break;
  852. default:break;
  853. }
  854. else
  855. switch(direct) {
  856.     case LEFT:
  857. if(GetVetor(i,j-1)==direct&&j-1>0)
  858. {
  859. j--;
  860.             Cruiser(LEFT,i,j);
  861. }
  862. break;
  863.     case RIGHT:
  864. if(GetVetor(i,j+1)==direct&&j+1<ROW)
  865. {
  866. j++;
  867.             Cruiser(RIGHT,i,j);
  868. }
  869. break;
  870.     default:break;
  871. }
  873. FINISHED[y][x]=SEARCHED;
  875. return;
  877. }
  879. plumb * CImageObject::SelectEdge(int SX, int SY, int EX, int EY, int tag)
  880. {
  881. plumb *p=LPXBorder.next;
  882. struct plumb tmp;
  883. CDL.i0=0;
  884. CDL.i1=0;
  885. CDL.j0=0;
  886. CDL.j1=0;
  887. CDL.next=NULL;
  888. tmp=CDL;
  890. if(tag==DOWN)
  891.     {
  892. SY=(SY<EY)?SY:EY;
  893. while (p!=NULL) 
  894. {
  895.    if(p->i0>SY) 
  896.   break;
  897.    if((p->j1<=EX&&p->j0>SX)&&p->i0>tmp.i0)
  898.    {
  899.    tmp=*p;
  900.    p=p->next;
  901.    }
  902.    else
  903.   p=p->next;
  904. }
  906. CDL=tmp;
  907. return &CDL;
  908. }
  909. else
  910. {
  911. SY=(SY>EY)?SY:EY;
  912. while (p!=NULL) 
  913. {
  914. if(p->i0<SY)
  915. {
  916. p=p->next; 
  917. continue;
  918. }
  919. if(p->j1<=EX&&p->j0>SX)
  920. {
  921. tmp=*p;
  922. break;
  923. }
  924. else
  925. p=p->next;
  926. }
  928. CDL=tmp;
  929. return &CDL;
  931. }
  933. }
  935. int CImageObject::RAStat(int x0, int y0, int x1, int y1)
  936. {
  937. int nCount=0;
  938. int i,j;
  939. for(i=y1;i<=y0;i++)
  940. for(j=x0;j<=x1;j++)
  941. FINISHED[i][j]=NOTSEARCH;
  943. for(i=y1;i<y0;i++)
  944. for(j=x0;j<x1;j++)
  945. {
  946. if(VetorRec[i][j]==NODIRECT)
  947. {
  948. FINISHED[i][j]=SEARCHED;
  949. }
  950. else
  951. if(FINISHED[i][j]==NOTSEARCH)
  952. {
  953.                 RASearch(VetorRec[i][j],i,j,x0,y0,x1,y1,nCount);
  954. }
  955. }
  956. return nCount;
  958. }
  960. void CImageObject::Graft2BmpData(BYTE BMP[])
  961. {
  962.     int i,j,k;
  963. for(i=0;i<COL;i++)
  964. {
  966. for(j=0;j<ROW;j++)
  967. {
  968.             k = i*ROW+j;
  969. lpBuf[k*3]=BMP[k*3];
  970. lpBuf[k*3+1]=BMP[k*3+1];
  971. lpBuf[k*3+2]=BMP[k*3+2];
  972. }
  973. }
  976. }
  978. void CImageObject::RASearch(int direct, int i, int j, int x0, int y0, int x1, int y1, int &count)
  979. {
  980. switch(direct) {
  981. case UP:if(i+1<=y0)
  982. {
  983. FINISHED[i][j]=SEARCHED;
  984. if(VetorRec[i+1][j]==NODIRECT||FINISHED[i+1][j]==SEARCHED)
  985. return;
  986. if(VetorRec[i+1][j]==LEFT||VetorRec[i+1][j]==RIGHT||VetorRec[i+1][j]==UP)
  987. count+=5;//count++;
  988.                 RASearch(VetorRec[i+1][j],i+1,j,x0,y0,x1,y1,count);
  989. }
  990. break;
  991. case DOWN:if(i-1>=y1)
  992.   {
  993. FINISHED[i][j]=SEARCHED;
  994.     if(VetorRec[i-1][j]==NODIRECT||FINISHED[i-1][j]==SEARCHED)
  995.     return;
  996.     if(VetorRec[i-1][j]==LEFT||VetorRec[i-1][j]==RIGHT||VetorRec[i-1][j]==DOWN)
  997.     count+=5;
  998.     RASearch(VetorRec[i-1][j],i-1,j,x0,y0,x1,y1,count);
  999.   }
  1000. break;
  1001. case RIGHT:if(j+1<=x1)
  1002.    {
  1003.    FINISHED[i][j]=SEARCHED;
  1004.    if(VetorRec[i][j+1]==NODIRECT||FINISHED[i][j+1]==SEARCHED)
  1005.    return;
  1006.    if(VetorRec[i][j+1]==UP||VetorRec[i][j+1]==DOWN)
  1007.    count+=5;
  1008.    RASearch(VetorRec[i][j+1],i,j+1,x0,y0,x1,y1,count);
  1009.    }
  1010. break;
  1011. case LEFT:if(j-1>=x0)
  1012.   {
  1013.   FINISHED[i][j]=SEARCHED;
  1014.   if(VetorRec[i][j-1]==NODIRECT||FINISHED[i][j-1]==SEARCHED)
  1015.   return;
  1016.   if(VetorRec[i][j-1]==UP||VetorRec[i][j-1]==DOWN)
  1017.   count+=5;  
  1018.   RASearch(VetorRec[i][j-1],i,j-1,x0,y0,x1,y1,count);
  1019.   }
  1020. break;
  1021. case UPRIGHT:if(j+1<=x1&&i+1<=y0)
  1022.  {
  1023.  FINISHED[i][j]=SEARCHED;
  1024.  if(VetorRec[i+1][j+1]==NODIRECT||FINISHED[i+1][j+1]==SEARCHED)
  1025.  return;
  1026. //  if(VetorRec[i+1][j+1]==UPLEFT||VetorRec[i+1][j+1]==DOWNRIGHT||VetorRec[i+1][j+1]==UPRIGHT)
  1027. if(VetorRec[i+1][j+1]!=UPRIGHT)
  1028.    count+=3;
  1029.  RASearch(VetorRec[i+1][j+1],i+1,j+1,x0,y0,x1,y1,count);
  1030.  }
  1031. break;
  1032. case DOWNRIGHT:if(j+1<=x1&&i-1>=y1)
  1033.    {
  1034.    FINISHED[i][j]=SEARCHED;
  1035.    if(VetorRec[i-1][j+1]==NODIRECT||FINISHED[i-1][j+1]==SEARCHED)
  1036.    return;
  1037. //    if(VetorRec[i-1][j+1]==DOWNLEFT||VetorRec[i-1][j+1]==UPRIGHT)
  1038.                        if(VetorRec[i-1][j+1]!=DOWNRIGHT)
  1039.  count+=3;
  1040.    RASearch(VetorRec[i-1][j+1],i-1,j+1,x0,y0,x1,y1,count);
  1041.    }
  1042. break;
  1043. case UPLEFT:if(i+1<=y0&&j-1>=x0)
  1044. {
  1045. FINISHED[i][j]=SEARCHED;
  1046. if(VetorRec[i+1][j-1]==NODIRECT||FINISHED[i+1][j-1]==SEARCHED)
  1047. return;
  1048. // if(VetorRec[i+1][j-1]==UPRIGHT||VetorRec[i+1][j-1]==DOWNLEFT)
  1049.                     if(VetorRec[i+1][j-1]!=UPLEFT)
  1050.  count+=3;
  1051. RASearch(VetorRec[i+1][j-1],i+1,j-1,x0,y0,x1,y1,count);
  1052. }
  1053. break;
  1054. case DOWNLEFT:if(j-1>=x0&&i-1>=y1)
  1055.   {
  1056.   FINISHED[i][j]=SEARCHED;
  1057.   if(VetorRec[i-1][j-1]==NODIRECT||FINISHED[i-1][j-1]==SEARCHED)
  1058.   return;
  1059. //   if(VetorRec[i-1][j-1]==UPRIGHT||VetorRec[i-1][j-1]==DOWNRIGHT)
  1060.   if(VetorRec[i-1][j-1]!=DOWNLEFT)
  1061.  count+=3;
  1063.   RASearch(VetorRec[i-1][j-1],i-1,j-1,x0,y0,x1,y1,count);
  1064.   }
  1065. break;
  1066. default:break;
  1067. }
  1068.     return;
  1069. }
  1071. BITMAPINFO CImageObject::WriteDibFile(int Height, int Width, BYTE buf[])
  1072. {
  1073. ForLPR.bmiHeader.biBitCount=24;
  1074. ForLPR.bmiHeader.biHeight=Height;
  1075. ForLPR.bmiHeader.biWidth=Width;
  1076. ForLPR.bmiHeader.biClrUsed=0;
  1077. ForLPR.bmiHeader.biClrImportant=0;
  1078. ForLPR.bmiHeader.biSizeImage=Height*Width*3;
  1079. ForLPR.bmiHeader.biCompression=0;
  1080. ForLPR.bmiHeader.biPlanes=1;
  1081. ForLPR.bmiHeader.biXPelsPerMeter=3780;
  1082. ForLPR.bmiHeader.biYPelsPerMeter=3780;
  1083. ForLPR.bmiHeader.biSize=40;
  1084. ForLPR.bmiColors[0]=*quad;
  1085. int k=0;
  1086. for(int i=P->y1;i<=P->y0;i++)
  1087. {
  1088. for(int j=P->x0;j<=P->x1;j++)
  1089. {
  1090.  buf[k++]=BMPRec[i*ROW*3+j*3];
  1091.  buf[k++]=BMPRec[i*ROW*3+j*3+1];
  1092.  buf[k++]=BMPRec[i*ROW*3+j*3+2];
  1093. }
  1094. while((k*8)%32!=0)
  1095. buf[k++]=0;
  1096. }
  1097. return ForLPR;
  1099. }
  1101. void CImageObject::Binary(BITMAPINFO DIBINFO,BYTE buf[])
  1102. {
  1103. BYTE GrayLevel;
  1104. int i,j,k;
  1105. int w = DIBINFO.bmiHeader.biWidth;
  1106. int h = DIBINFO.bmiHeader.biHeight;
  1107.     for(i = 0; i < h ;i++)
  1108. {
  1110. for(j = 0; j < w;j++)
  1111. {
  1112. k = i*w+j;
  1113. GrayLevel = BYTE(0.299*buf[k*3] + 0.587*buf[k*3+1] + 0.114 * buf[k*3+2]);
  1114.             if(GrayLevel<120)
  1115. {
  1116. buf[k*3] = 0;
  1117.     buf[k*3+1] = 0;
  1118.     buf[k*3+2] = 0;
  1119. }
  1120. else 
  1121. {
  1122. buf[k*3] = 255;
  1123.                 buf[k*3+1] = 255;
  1124.     buf[k*3+2] = 255;
  1125. }
  1127.     
  1128. }
  1129. }
  1131. }