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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 交通/航空行业 > 查看源码
ImageProcessing.cpp
资源名称：vehiclehsv.rar　[点击查看]
上传用户：cjd055
上传日期：2013-04-01
资源大小：608k
文件大小：41k
源码类别：

交通/航空行业

开发平台：

Visual C++

ImageProcessing.cpp：源码内容
  1. #include <stdafx.h>
  2. #include <windows.h>
  3. #include <math.h>
  4. #include <malloc.h>
  5. #include "resource.h"
  6. #include "BmpTest.h"
  7. #include "BmpTestDoc.h"
  8. /********************************************************************   *
  9. *                                                                       *
  10. * ro_angle:rotated angle                                                *
  11. * size :the size of the rotated bitmap                                  *
  12. * pav_cent:the rotate centre                                                                      *
  13. *   **********************************************************************/                                                                  
  14.                                                                   
  15. extern void Sh_Rotate(CBmpTestDoc* pDoc,double ro_angle,double size,POINT *pav_cent) 
  16. {
  17. BYTE *lp=pDoc->m_Dib.m_Buffer,*ltemp;
  18. int  m,n;    
  19.     unsigned int  a,b,d,j,k,stand=150,Height,Width,BPL,i;
  20.     DWORD    shift,y_value;
  21.     DWORD    large;
  22.     double   rotate,x_value,sinth,costh;
  23.     m=pav_cent->x;
  24.     n=pav_cent->y; 
  25. sinth=sin(-ro_angle);
  26. Height=(int) pDoc->m_Dib.Height;
  27. Width=(int) pDoc->m_Dib.Width;
  28.     BPL=(int) pDoc->m_Dib.Bpl;
  29. costh=cos(-ro_angle);
  30. //loritemp 是本地的图像副本总指针，ltemp指向数据区，biSize是BITMAPINFORHEADER的大小为40
  31. ltemp=new BYTE[9600];
  32.     //initioalize the new field orign lpbi->biSizeImage
  33.     for(j=0;j<9600;j++)
  34. *(ltemp+j)=0; 
  35.    //if it is the bmppoint then enlage
  36.     for(k=0;k<Height;k++)
  37.     {
  38.     for(i=0;i<=(int)(Width/8);i++)
  39.     { 
  40.      if((i+1)*8<Width)
  41.        d=8;
  42.      else
  43.        d=(unsigned)(Width-i*8);
  44.       a=128;
  45.      if(d!=0)
  46.      {
  47.      for(j=0;j<d;j++)
  48.      {
  49.    //if the bit is equal to 0 it is background
  50. if((*(lp+(LONG)i+(LONG)k*BPL) & a) ==0)
  51.       a=a>>1;
  52. else
  53. {
  54. //i is the x coordinate so it is byte
  55.       x_value=(float)8*i+(float)j;
  56.       rotate=(x_value -m)*(costh)-(sinth) *((float)k-n);
  57.      rotate*=(double)110.0/size;  
  58.      rotate+=(double)160.0;
  59.       large=(int)(rotate/8);
  60.       shift=(int)rotate-large*8;
  61. b=128;
  62. //shift>=0 it is in the next store,本身他已处于下一单元（i 从零开始）        
  63.       y_value=(LONG)(((x_value -m)*sinth+costh*((float)k-n))
  64.         *110.0/size +(float)120 )*(LONG)(40);
  65.       large +=y_value;
  66.       b=b>>shift;
  67.       if(large < (9600-1))
  68.       *(ltemp+large)|= b;
  69.       a=a>>1;
  70. }
  71.  }
  72.      }    
  73.     }
  74.      }
  75.  // If the driver did not fill in the biSizeImage field, make one up 
  76.      pDoc->m_Dib.Width=320;
  77.      pDoc->m_Dib.Height=300;
  78.      pDoc->m_Dib.Resize(9600);
  79.  for(j=0;j<9600;j++)
  80.  {
  81.  *(pDoc->m_Dib.m_Buffer+j)=*(ltemp+j);
  82.  *(pDoc->m_Dib.m_Buffer1+j)=*(ltemp+j);
  83.  }
  84.    if(lp)
  85.  {
  86. delete [] lp;
  87. lp=0;
  88.  }
  89.    if(ltemp)
  90.  {
  91. delete [] ltemp;
  92. ltemp=0;
  93.  }
  94. }
  95.   
  97. /**************************************************************************
  98. *  n                                      *
  99. *  gcc:the gravity contour centre of the bitmap                            *
  100. ***************************************************************************/
  101. extern BOOL  GCC(CBmpTestDoc* pDoc,double *n,POINT *gcc)
  102. {
  103. //1:xnear 2:xfarer 3:ynear 4:yfarer
  104. BYTE *lp=pDoc->m_Dib.m_Buffer;
  105.    char name1[2]="1",name2[2]="2",name3[2]="3",name4[2]="4";
  106.     int i,k,tempx,xImagecon[2000],BPL,black,white,Height,Width;
  107.     unsigned int a=1,d,j,maxx,minx;
  108.     DWORD  x=0,y=0,centx=0,centy=0,counts=0;//counts represents the conunt of the contour
  109.     //cent represent the center_mass while av_cent represent the average center
  110.     DISTANCE   xdis[50];
  111.     PDISTANCE     pdis;
  112.     //let x repreterative the near  and y represertive the far 
  113. POINT Imagecon[100],min,max,last,cent,av_cent,*pcent,*pav_cent;
  114. //float distwo;
  115. BOOL maxfind=FALSE,minfind=FALSE,begin=TRUE,equal1,equal2,equal3;
  116. double l,dis,midx,midy,d_centx,d_centy;
  117. Height=(int) pDoc->m_Dib.Height;
  118. Width=(int) pDoc->m_Dib.Width;
  119. BPL=(int) pDoc->m_Dib.Bpl;
  120.     pcent=&cent;
  121.     pav_cent=&av_cent;
  122.     pdis=xdis;
  123.     for(i=0;i<50;i++)
  124.     (pdis+i)->number=0;    
  125.     for(i=0;i<2000;i++)
  126.     xImagecon[i]=0;
  127.     for(i=0;i<100;i++)
  128.     {
  129.     Imagecon[i].x=0;
  130. Imagecon[i].y=0;
  131.     }
  132.     for(k=0;k<Height;k++)
  133. {
  134.       for(i=0;i<=(int)((Width)/8);i++)
  135.   {  
  136.           a=255;
  137.   if(((*(lp+i+k*BPL)) & a) ==0)
  138.  continue; 
  139.       if((i+1)*8<(Width))
  140.        d=8;
  141.       else
  142.        d=(unsigned)((Width)-i*8);
  143.       a=128;
  144.       if(d!=0)
  145.   {
  146.      for(j=0;j<d;j++)
  147.      {
  149. //if the bit is equal to 0 it is background
  150.         if(((*(lp+i+k*BPL)) & a) ==0)
  151.       { y++;
  152.        a=a>>1;}
  153.         else
  154. {   x++;
  155.                         a=a>>1;
  156.     centx=(WORD)i*8+j+centx;
  157.     centy=(WORD)k+centy;
  158.  //分别求出从两个方向的投影点的轮廓
  159.  //从x方向求 k为其 坐标
  160. if(xImagecon[k] ==0)
  161. xImagecon[k] =i*8+j;    
  162. xImagecon[500+k] =max(xImagecon[500+k],i*8+(int)j);    
  163. xImagecon[k] =min(xImagecon[k],i*8+(int)j);
  164.  //从y方向求tempx为其坐标 
  165. tempx=i*8+j;
  166. if(xImagecon[1000+tempx]==0) 
  167. xImagecon[1000+tempx] =k;    
  168.             xImagecon[1500+tempx] =max(xImagecon[1500+tempx],k);
  169. xImagecon[1000+tempx] =min(xImagecon[1000+tempx],k);    
  170. }
  171.          }
  172.      }    
  173.     }
  174.     }                     
  175.  
  176.  //图的直方图
  177.     black=y;
  178.     white=x;
  179.  //求重心
  180. d_centx=((double)centx/x);
  181. d_centy=((double) centy/x);
  182.     for(k=0;k<4;k++)
  183.     {
  184.     max.x=0;
  185. max.y=0;
  186. min.x=0;
  187. min.y=0;
  188. j=0;
  189. maxx=0;
  190. begin=TRUE;
  191. maxfind=FALSE;
  192. minfind=FALSE;
  193.     for(i=1;i<500;i++)
  194.     {
  195.     //i  值为其 y方向的值 xImagecon 存的是X方向的最近和最远
  196.     if(xImagecon[k*500+i] !=0) 
  197.     {
  198.       if(max.x==0) 
  199.       {
  200.        max.x=xImagecon[k*500+i];
  201. //the first point is a contour point
  202.       if(j==0)
  203. {   j++;
  204. if(k<2)
  205. {
  206. Imagecon[k*20+j].x=max.x;
  207. Imagecon[k*20+j].y=i; 
  208. j++;
  209. }
  210.      else
  211.      {
  212. Imagecon[k*20+j].y=max.x;
  213. Imagecon[k*20+j].x=i; 
  214. j++;
  215.      }
  216. }
  217. }
  218.         if(min.x==0)     min.x=xImagecon[k*500+i];
  219. if(!minfind || begin)
  220. {
  221.      if(min.x>=xImagecon[k*500+i])  
  222.      {
  223.      min.x=xImagecon[k*500+i];
  224.      min.y=i;
  225.  minx=0;
  226.  }
  227.             else
  228.             {
  229.             minx++; 
  230.            if((minx>=2) && (min.x<=xImagecon[k*500+i]-2) && (min.x<=max.x+2))
  231.            {
  232.            minfind=TRUE;
  233.            begin=FALSE;
  234.            }
  235.             }
  236.             }
  237.     if(!maxfind || begin)
  238. {
  239.      if(max.x<=xImagecon[k*500+i])
  240.      {
  241.      max.x=xImagecon[k*500+i];
  242.      max.y=i; 
  243.          maxx=0;
  244.   }
  245.   else  
  246.   {
  247.      maxx++;
  248. if((maxx>=2) && (max.x>=xImagecon[k*500+i]+2) && (max.x>=min.x+2))
  249. {
  250. maxfind=TRUE;
  251. begin=FALSE;
  252. minfind=FALSE;
  253. }
  254.    }
  255. } 
  256.         last.x=xImagecon[k*500+i];
  257.     last.y=i;
  258.   if((maxfind && (maxx>=2)) || (minfind && (minx>=2)))
  259.   {
  260.   if(minfind)
  261. {
  262.      if(k==0)
  263.      {
  264.      Imagecon[k*20+j].x=min.x;
  265.      Imagecon[k*20+j].y=min.y; 
  266.      j++;
  267.      }
  268.       if(k==2)
  269.      {
  270.      Imagecon[k*20+j].y=min.x;
  271.      Imagecon[k*20+j].x=min.y; 
  272.                      j++;
  273.  }
  274.      max.x=min.x;
  275.      max.y=min.y;
  276.                  maxfind=FALSE;     
  277.                }
  278.    if(maxfind)
  279.    {
  280.      if(k==1)
  281.      {
  282.      Imagecon[k*20+j].x=max.x;
  283.      Imagecon[k*20+j].y=max.y; 
  284.      j++;
  285.      }
  286.    if(k==3)
  287.  {
  288.      Imagecon[k*20+j].y=max.x;
  289.      Imagecon[k*20+j].x=max.y; 
  290.      j++;
  291.  }
  292.  min.x=max.x;
  293.  min.y=max.y;
  294.      }
  295.      *(lp+Imagecon[k*20+j-1].x/8+Imagecon[k*20+j-1].y * BPL/4) ^ 255;
  296.      *(lp+Imagecon[k*20+j-1].x/8+Imagecon[k*20+j-1].y * BPL/4) ^ 255;
  297.      minx=0;     
  298.      maxx=0;
  299.      }
  300.     } 
  301.   }
  302.   Imagecon[k*20].x=j;
  303.   if(k<2)
  304.   {
  305.   Imagecon[k*20+j].x=last.x;
  306.   Imagecon[k*20+j].y=last.y;
  307.   }
  308.   else
  309.   {
  310.   Imagecon[k*20+j].x=last.y;
  311.   Imagecon[k*20+j].y=last.x;
  312.   }
  313. }  
  315. //去掉相同点
  316. for(i=0;i<4;i++)
  317. {
  318.     k=Imagecon[20*i].x;
  319. Imagecon[20*i].x=0;
  320. pav_cent->x =Imagecon[20*i+1].x;
  321. pav_cent->y =Imagecon[20*i+1].y;
  322. last.x=Imagecon[20*i+k].x;
  323. last.y=Imagecon[20*i+k].y;
  324. for(j=0;j<40;j++)
  325. {
  326. if((i==0) && (Imagecon[40+20*(int)(j/20)+2].x<=pav_cent->x) && (Imagecon[40+j].y==pav_cent->y) )
  327. equal1=TRUE;
  328. else
  329.           equal1=FALSE;
  330.         if((i==2) && (Imagecon[20*(int)(j/20)+2].y<=pav_cent->y) && (Imagecon[j].x==pav_cent->x) )           
  331. equal2=TRUE;
  332. else
  333.           equal2=FALSE;
  334.         tempx=40*(1-(int)(i/2))+j;
  335.     if((Imagecon[tempx].x==pav_cent->x) && (Imagecon[tempx].y==pav_cent->y))
  336.  equal3=TRUE;
  337. else
  338.    equal3=FALSE;
  339.     if(equal3 || equal1|| equal2)
  340. {                              
  341.  Imagecon[20*i+1].x=0;
  342.  Imagecon[20*i+1].y=0;
  343. }
  344.       if  ((i==0) && (Imagecon[40+20*(int)(j/20)+2].x<=last.x) && 
  345.    (Imagecon[40+j].y==last.y))
  346. equal1=TRUE;
  347. else
  348.            equal1=FALSE;
  350. if((i==2) &&(Imagecon[20*(int)(j/20)+2].y<=last.y) && (Imagecon[j].x==last.x))
  351.  equal2=TRUE;
  352. else 
  353.  equal2=FALSE;
  354.   tempx=40*(1-i/2)+j;
  355. if((Imagecon[tempx].x==last.x) && (Imagecon[tempx].y==last.y))  
  356.    equal3=TRUE;
  357. else
  358.  equal3=FALSE;
  359. if(equal3 || equal1 ||  equal2) 
  360. {
  361.  Imagecon[20*i+k].x=0;
  362.  Imagecon[20*i+k].y=0;
  363.  }
  364.        }
  365.     }
  366. //caculate the GCC  
  367. for(j=0;j<20;j++)
  368. {
  369.  last.x=Imagecon[20+j].x;
  370.  last.y=Imagecon[20+j].y;
  371.  Imagecon[20+j].x=Imagecon[60+j].x;
  372.  Imagecon[20+j].y=Imagecon[60+j].y;
  373.  Imagecon[60+j].x=last.x;
  374.  Imagecon[60+j].y=last.y;
  375. }                                          
  376. l=0.;
  377.     midx=0;
  378.     midy=0;
  379.     max.x=0;
  380.     max.y=0;
  381. for(i=0;i<80;i++)
  382. {
  383. if(Imagecon[i].x !=0)
  384. {
  385. min.x=Imagecon[i].x;
  386. min.y=Imagecon[i].y; 
  387. if(max.x==0)
  388. {
  389. //max store the initional value
  390. max.x=min.x;
  391. max.y=min.y;
  392. }
  393. j=i+1;
  394. while((Imagecon[j].x==0) && (j<80))
  395. j++;
  396. if((j>40) && (i<40))
  397. {
  399. // pav_cent store the end of the y direction maxmun value
  400. pav_cent->x=min.x;
  401. pav_cent->y=min.y;
  402. min.x=max.x;
  403. min.y=max.y; 
  404. }           
  405. last.x=Imagecon[j].x;
  406. last.y=Imagecon[j].y;
  407. if(j==80) 
  408. {
  409.   last.x=pav_cent->x;
  410.   last.y=pav_cent->y;
  411. }
  412. dis=sqrt((double)(min.x-last.x)*(min.x -last.x)+
  413. (double)(min.y-last.y)*(min.y-last.y));
  414. midx =(double)(min.x+last.x)/2 *dis +midx;
  415. midy =(double)(min.y+last.y)/2 *dis +midy;
  416. l+=dis;
  417. i=j-1;
  418. }
  420. }
  421.     midx=midx/l;
  422.     midy=midy/l;
  423.     gcc->x=(int)midx;
  424.     gcc->y=(int)midy;         
  425.     l=0;
  426. for(i=0;i<80;i++)
  427. {
  428. if(Imagecon[i].x !=0)
  429. {
  430. dis=(Imagecon[i].x-midx)*(Imagecon[i].x-midx)+(Imagecon[i].y-midy)*(Imagecon[i].y-midy);
  431. dis=sqrt(dis);
  432. l=max(dis,l);
  433.         }
  434. }
  435.     *n=l;
  436. return TRUE;
  437. }                          
  440. /***************************************************************************
  441. *  pAnew_mom:the query bitmap's moments                          *
  442. *  n:the size of the bitmap                                       *
  443. *  protate :the rotated angle           
  444. * the moment name of the calculation below is the same as the maths define *
  445. ***************************************************************************/
  446. extern BOOL  Contour(CBmpTestDoc* pDoc,double *pAnew_mon,BOOL bmoment,double n,double *protate)
  447. {
  449. //1:xnear 2:xfarer 3:ynear 4:yfarer
  450. BYTE *lp=pDoc->m_Dib.m_Buffer;
  451.    char Outtext[300]="",ext1[15]="mom.txt",filename1[30];
  452.     int  i,k,tempx,black,white,BPL,Height,Width;
  453.     unsigned int a=1,d,j;
  454.     DWORD  x=0,y=0,centx=0,centy=0,counts=0;//counts represents the conunt of the contour
  455.     //cent represent the center_mass while av_cent represent the average center
  456.     DISTANCE   xdis[50];
  457.     PDISTANCE     pdis; 
  458.     //let x repreterative the near  and y represertive the far 
  459. bool maxfind=false,minfind=false,begin=true;
  460. double  l,mid,d_centx,d_centy,A1,A2,A3,A4,A5,A6,A7,N,coefient,
  461.       u02,u20,u03,u30,u11,u21,u12,a1,a2,a3,a4,a5,a6,a7,
  462. m01,m02,m03,m20,m30,m11,m21,m12;
  463. FILE *ffp;
  464. Height=(int) pDoc->m_Dib.Height;
  465. Width=(int) pDoc->m_Dib.Width;
  466.     BPL=(int) pDoc->m_Dib.Bpl;
  467. pdis=xdis; 
  468.     N=n;
  469.     for(i=0;i<50;i++)
  470.     (pdis+i)->number=0;    
  471.     u02=0;u03=0;u20=0;
  472. //求直方图
  473.     for(k=0;k<(Height);k++)
  474.     {
  475.     for(i=0;i<=Width/8;i++)
  476.     {  
  477.        a=255;
  478.    if(((int)*(lp+i+k*BPL) & a) ==0)
  479.    continue; 
  480.            if((i+1)*8<Width)
  481.          d=8;
  482.    else
  483.       d=(unsigned)(Width-i*8);
  484.    a=128;
  485.    if(d!=0)
  486.    {
  487.       for(j=0;j<d;j++)
  488.   {
  489. //if the bit is equal to 0 it is background
  490.      if(((int)*(lp+i+k*BPL) & a) ==0)
  491.  {   
  492.  y++;
  493.        a=a>>1;
  494.  }
  495.      else
  496.  {  
  497.  x++;
  498.                     a=a>>1;
  499.             centx=(WORD)i*8+j+centx;
  500.     centy=(WORD)k+centy;
  501.  }
  502.       }
  503.     }    
  504.     }
  505.     }                     
  506. //图的面积=x+y
  507.     black=y;
  508.     white=x; 
  509. //求重心
  510.     d_centx=((double)centx/x);
  511. d_centy=((double) centy/x);
  512. //归一化系数    
  513.     coefient=(double)x*x;  
  514.     A7=sqrt((double)x);
  515. //A7=sqrt(a1); 
  516.     mid=coefient*A7;
  517.     u11=0;u02=0;u03=0;u20=0;u30=0;u12=0;u21=0; 
  518.     m11=0;m01=0;m02=0;m03=0;m20=0;m30=0;m12=0;m21=0;
  519. A1=0.;A2=0.;A3=0.;A4=0.;A5=0.;A6=0.;A7=0.;
  520.     for(k=0;k<Height;k++)
  521.     {
  522.     for(i=0;i<=(int)Width/8;i++)
  523.     {  
  524.        a=255;
  525.    if((((int)*(lp+i+k*BPL)) & a)==0)
  526.    continue; 
  527.         if((i+1)*8<Width)
  528.        d=8;
  529.    else
  530.       d=(unsigned)(Width-i*8);
  531.    a=128;
  532.    if(d!=0)
  533.    {
  534.      for(j=0;j<d;j++)
  535.      {
  537. //if the bit is equal to 0 it is background
  538.      if((((int)*(lp+i+k*BPL)) & a) ==0)
  539.        a=a>>1;
  540.      else
  541.      { 
  542. a=a>>1;           
  543. tempx=i*8+j;
  544. a1=((double)k-d_centy)*((double)k-d_centy);
  545. u02+=a1;
  546. a2=a1*(k- d_centy);
  547. u03+=a2;
  548. a3=(tempx- d_centx)*(tempx-d_centx);
  549. u20+=a3;
  550. u30+=a3*(tempx- d_centx); 
  551. a4=(tempx-d_centx)*(k-d_centy);
  552. u11+=a4;
  553. a5=a4*(tempx-d_centx);
  554. u21+=a5;
  555. a6=a4*(k-d_centy);
  556. u12+=a6;  
  557. }
  558. }
  559. }    
  560. }   
  561. //to calculate the scale transform    
  562. a3=u02/coefient;
  563. A1=A1+a3;
  564. u02=0.; 
  565. a3=u20/coefient;
  566. A2=A2+a3;
  567. u20=0.;
  568. a3=u11/coefient;
  569. A3=a3+A3;
  570. u11=0.;
  571. a3=u03/mid;
  572. A4=A4+a3;
  573. u03=0.;
  574. a3=u30/mid;
  575. A5=A5+a3;
  576. u30=0.;
  577. a3=u21/mid;
  578. A6=A6+a3;
  579. u21=0.;
  580. a3=u12/mid;
  581. A7=A7+a3;
  582. u12=0.;
  583. }                     
  584.     u02=A1;
  585.     u20=A2;
  586.     u11=A3;
  587.     u03=A4;
  588.     u30=A5;
  589.     u21=A6;
  590.     u12=A7;   
  591.   
  592.   
  593.  //rotated invariant moment 
  594.     a1=u02+u20; 
  595.     a2=(u20-u02)*(u20-u02)+u11*u11*4;
  596.     a3=(u30- u12*3)*(u30-u12*3)+(u21*3-u03)*(u21*3-u03);
  597.     a4=(u30+u12)*(u30+u12)+(u03+u21)*(u03+u21);
  598.     a5=(u30-u12*3)*(u30+u12)*((u30+u12)*(u30+u12)-(u21+u03)*(u21+u03)*3)
  599.      +(u21*3-u03)*(u21+u03)*((u30+u12)*(u30+u12)*3-(u21+u03)*(u21+u03));
  600.     a6=(u20-u02)*((u30+u12)*(u30+u12)-(u21+u03)*(u21+u03))
  601.      +u11*(u30+u12)*(u21+u03)*4;
  602.       
  603.     a7=(u21*3-u03)*(u30+u12)*((u30+u12)*(u30+u12)-(u21+u03)*(u21+u03)*3)
  604.      -(u30-u12*3)*(u21+u03)*((u30+u12)*(u30+u12)*3 -(u21+u03)*(u21+u03));
  605. //calculate the rotate angle 
  606.     u11=2*u11; 
  607.     u12=u20-u02;
  608. l=atan2( u11, u12 );
  609. *protate=l/2;
  610. *pAnew_mon=(double)n;                                                  
  611. //to store the moment 
  612. A1=a1;
  613. *(++pAnew_mon)=A1;
  614. A2=a2;       
  615. *(++pAnew_mon)=A2;
  616. A3=a3; 
  617. *(++pAnew_mon)=A3;
  618. A4=a4;           
  619. *(++pAnew_mon)=A4;
  620. A5=a5;
  621. *(++pAnew_mon)=A5;
  622. A6=a6;           
  623. *(++pAnew_mon)=A6;
  624. A7=a7;           
  625. *(++pAnew_mon)=A7;
  626.     if(bmoment)
  627.     {
  628.         wsprintf(filename1,"%s",(LPSTR)ext1); 
  629. if((ffp=fopen(filename1,"ab"))==NULL)
  630. {
  631. return false;
  632. }
  633. sprintf(Outtext,"rn %-20s%-7ld%-25le%-25le%-25le%-25le%-25le%-25le%-25le%-25le",
  634.   pDoc->m_Dib.arcFileName,white,n,A1,A2,A3,A4,A5,A6,A7);                 
  635. fprintf (ffp,"%s",Outtext);
  636.         fclose(ffp);                     
  637.      } 
  638.      return true;
  639. }                          
  641. void HorzMirror(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  642. {
  643. int x,y;
  644. int nByteWidth=nWidth*3;
  645. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  646. for(y=0;y<nHeight;y++)
  647. {
  648. for(x=0;x<nWidth;x++)
  649. {
  650. lpOutput[x*3+y*nByteWidth]=lpInput[(nWidth-1-x)*3+y*nByteWidth];
  651. lpOutput[x*3+1+y*nByteWidth]=lpInput[(nWidth-1-x)*3+1+y*nByteWidth];
  652. lpOutput[x*3+2+y*nByteWidth]=lpInput[(nWidth-1-x)*3+2+y*nByteWidth];
  653. }
  654. Progress(y);
  655. }
  656. }
  658. void VertMirror(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  659. {
  660. int x,y;
  661. int nByteWidth=nWidth*3;
  662. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  663. for(y=0;y<nHeight;y++)
  664. {
  665. for(x=0;x<nByteWidth;x++)
  666. {
  667. lpOutput[x+y*nByteWidth]=lpInput[x+(nHeight-y-1)*nByteWidth];
  668. }
  669. Progress(y);
  670. }
  671. }
  673. void CornerMirror(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  674. {
  675. int x,y;
  676. int nByteWidth=nWidth*3;
  677. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  678. for(y=0;y<nHeight;y++)
  679. {
  680. for(x=0;x<nWidth;x++)
  681. {
  682. lpOutput[x*3+y*nByteWidth]=lpInput[(nWidth-1-x)*3+(nHeight-y-1)*nByteWidth];
  683. lpOutput[x*3+1+y*nByteWidth]=lpInput[(nWidth-1-x)*3+1+(nHeight-y-1)*nByteWidth];
  684. lpOutput[x*3+2+y*nByteWidth]=lpInput[(nWidth-1-x)*3+2+(nHeight-y-1)*nByteWidth];
  685. }
  686. Progress(y);
  687. }
  688. }
  690. #define Point(x,y) lpPoints[(x)+(y)*nWidth]
  691. #define Point1(x,y) lpPoints1[(x)+(y)*nWidth]
  693. void GetPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
  694. {
  695. int x,y,p;
  696. int nByteWidth=nWidth*3;
  697. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  698. for(y=0;y<nHeight;y++)
  699. {
  700. for(x=0;x<nWidth;x++)
  701. {
  702. p=x*3+y*nByteWidth;
  703. lpPoints[x+y*nWidth]=(BYTE)(0.299*(float)lpBits[p+2]+0.587*(float)lpBits[p+1]+0.114*(float)lpBits[p]+0.1);
  704. }
  705. }
  706. }
  708. void PutPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
  709. {
  710. int nByteWidth=nWidth*3;
  711. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  712. int x,y,p,p1;
  713. for(y=0;y<nHeight;y++)
  714. {
  715. for(x=0;x<nWidth;x++)
  716. {
  717. p=x*3+y*nByteWidth;
  718. p1=x+y*nWidth;
  719. lpBits[p]=lpPoints[p1];
  720. lpBits[p+1]=lpPoints[p1];
  721. lpBits[p+2]=lpPoints[p1];
  722. }
  723. }
  724. }
  726. void HistogramEq1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput)
  727. {
  728. int x,y;
  729. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  730. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  733. int r[256],s[256];
  734. ZeroMemory(r,1024);
  735. ZeroMemory(s,1024);
  736. for(y=0;y<nHeight;y++){
  737. for(x=0;x<nWidth;x++){
  738. r[Point(x,y)]++;
  739. }
  740. }
  741. s[0]=r[0];
  742. for(y=1;y<256;y++)
  743. {
  744. s[y]=s[y-1];
  745. s[y]+=r[y];
  746. }
  747. for(y=0;y<nHeight;y++){
  748. for(x=0;x<nWidth;x++){
  749. Point(x,y)=s[Point(x,y)]*255/nWidth/nHeight;
  750. }
  751. }
  753. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  754. delete lpPoints;
  755. }
  757. //3x3中值滤波
  758. void Med1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  759. {
  760. int x,y;
  762. int nByteWidth=nWidth*3;
  763. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  764. BYTE p[9],s;
  765. int i,j;
  766. for(y=1;y<nHeight-1;y++)
  767. {
  768. for(x=3;x<nWidth*3-3;x++)
  769. {
  770. p[0]=lpInput[x-3+(y-1)*nByteWidth];
  771. p[1]=lpInput[x+(y-1)*nByteWidth];
  772. p[2]=lpInput[x+3+(y-1)*nByteWidth];
  773. p[3]=lpInput[x-3+y*nByteWidth];
  774. p[4]=lpInput[x+y*nByteWidth];
  775. p[5]=lpInput[x+3+y*nByteWidth];
  776. p[6]=lpInput[x-3+(y+1)*nByteWidth];
  777. p[7]=lpInput[x+(y+1)*nByteWidth];
  778. p[8]=lpInput[x+3+(y+1)*nByteWidth];
  779. for(j=0;j<5;j++)
  780. {
  781. for(i=j+1;i<9;i++)
  782. {
  783. if (p[j]>p[i])
  784. {
  785. s=p[j];
  786. p[j]=p[i];
  787. p[i]=s;
  788. }
  789. }
  790. }
  791. lpOutput[x+y*nByteWidth]=p[4];
  792. }
  793. Progress(y);
  794. }
  795. }
  797. void Mean1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  798. {
  799. int x,y,x1,y1,p;
  800. // BYTE *lpPoints=new BYTE[nWidth*nHeight];
  801. // GetPoints(nWidth,nHeight,lpInput,lpPoints);
  803. int sr,sg,sb;
  804. int nByteWidth=nWidth*3;
  805. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  806. for(y=1;y<nHeight-1;y++)
  807. {
  808. for(x=1;x<nWidth-1;x++)
  809. {
  810. p=x*3+y*nByteWidth;
  811. sb=0;
  812. sg=0;
  813. sr=0;
  814. for(y1=-1;y1<=1;y1++)
  815. for(x1=-1;x1<=1;x1++)
  816. {
  817. sb+=lpInput[(y+y1)*nByteWidth+(x+x1)*3];
  818. sg+=lpInput[(y+y1)*nByteWidth+(x+x1)*3+1];
  819. sr+=lpInput[(y+y1)*nByteWidth+(x+x1)*3+2];
  820. }
  821. lpOutput[p+2]=sr/9;
  822. lpOutput[p+1]=sg/9;
  823. lpOutput[p]=sb/9;
  824. }
  825. Progress(y);
  826. }
  827. // PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  828. // delete lpPoints;
  829. }
  832. #define pi (double)3.14159265359
  834. /*复数定义*/
  835. typedef struct
  836. {
  837. double re;
  838. double im;
  839. }COMPLEX;
  841. /*复数加运算*/
  842. COMPLEX Add(COMPLEX c1, COMPLEX c2)
  843. {
  844. COMPLEX c;
  845. c.re=c1.re+c2.re;
  846. c.im=c1.im+c2.im;
  847. return c;
  848. }
  850. /*复数减运算*/
  851. COMPLEX Sub(COMPLEX c1, COMPLEX c2)
  852. {
  853. COMPLEX c;
  854. c.re=c1.re-c2.re;
  855. c.im=c1.im-c2.im;
  856. return c;
  857. }
  859. /*复数乘运算*/
  860. COMPLEX Mul(COMPLEX c1, COMPLEX c2)
  861. {
  862. COMPLEX c;
  863. c.re=c1.re*c2.re-c1.im*c2.im;
  864. c.im=c1.re*c2.im+c2.re*c1.im;
  865. return c;
  866. }
  868. /*快速付里哀变换
  869. TD为时域值,FD为频域值,power为2的幂数*/
  870. void FFT(COMPLEX * TD, COMPLEX * FD, int power)
  871. {
  872. int count;
  873. int i,j,k,bfsize,p;
  874. double angle;
  875. COMPLEX *W,*X1,*X2,*X;
  877. /*计算付里哀变换点数*/
  878. count=1<<power;
  879. /*分配运算所需存储器*/
  880. W=(COMPLEX *)malloc(sizeof(COMPLEX)*count/2);
  881. X1=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  882. X2=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  883. /*计算加权系数*/
  884. for(i=0;i<count/2;i++)
  885. {
  886. angle=-i*pi*2/count;
  887. W[i].re=cos(angle);
  888. W[i].im=sin(angle);
  889. }
  890. /*将时域点写入存储器*/
  891. memcpy(X1,TD,sizeof(COMPLEX)*count);
  892. /*蝶形运算*/
  893. for(k=0;k<power;k++)
  894. {
  895. for(j=0;j<1<<k;j++)
  896. {
  897. bfsize=1<<(power-k);
  898. for(i=0;i<bfsize/2;i++)
  899. {
  900. p=j*bfsize;
  901. X2[i+p]=Add(X1[i+p],X1[i+p+bfsize/2]);
  902. X2[i+p+bfsize/2]=Mul(Sub(X1[i+p],X1[i+p+bfsize/2]),W[i*(1<<k)]);
  903. }
  904. }
  905. X=X1;
  906. X1=X2;
  907. X2=X;
  908. }
  909. /*重新排序*/
  910. for(j=0;j<count;j++)
  911. {
  912. p=0;
  913. for(i=0;i<power;i++)
  914. {
  915. if (j&(1<<i)) p+=1<<(power-i-1);
  916. }
  917. FD[j]=X1[p];
  918. }
  919. /*释放存储器*/
  920. free(W);
  921. free(X1);
  922. free(X2);
  923. }
  924. extern void str(int quotient,char addr[15])
  925. {
  926. int remainder,i,j,k;
  927. char  s1[15];
  928. i=0;
  929. do 
  930. {
  931. remainder=quotient%10;
  932. quotient=quotient/10;
  933. remainder=remainder+48;
  934.         s1[i]=(char) remainder;
  935. i++;
  936. } while(quotient!=0);
  937.     j=0;
  938. for(k=i-1;k>=0;k--)
  939. {
  940. addr[j]=s1[k];
  941. j++;
  942. }
  943. addr[j]=(char) '';
  944.     return;
  945. }
  947. /*快速离散余弦变换,利用快速付里哀变换
  948. f为时域值,F为变换域值,power为2的幂数*/
  949. void DCT(double *f, double *F, int power)
  950. {
  951. int i,count;
  952. COMPLEX *X;
  953. double s;
  955. /*计算离散余弦变换点数*/
  956. count=1<<power;
  957. /*分配运算所需存储器*/
  958. X=(COMPLEX *)malloc(sizeof(COMPLEX)*count*2);
  959. /*延拓*/
  960. memset(X,0,sizeof(COMPLEX)*count*2);
  961. /*将时域点写入存储器*/
  962. for(i=0;i<count;i++)
  963. {
  964. X[i].re=f[i];
  965. }
  966. /*调用快速付里哀变换*/
  967. FFT(X,X,power+1);
  968. /*调整系数*/
  969. s=1/sqrt(count);
  970. F[0]=X[0].re*s;
  971. s*=sqrt(2);
  972. for(i=1;i<count;i++)
  973. {
  974. F[i]=(X[i].re*cos(i*pi/(count*2))+X[i].im*sin(i*pi/(count*2)))*s;
  975. }
  976. /*释放存储器*/
  977. free(X);
  978. }
  980. /*快速沃尔什-哈达玛变换
  981. f为时域值,F为变换域值,power为2的幂数*/
  982. void WALh(double *f, double *W, int power)
  983. {
  984. int count;
  985. int i,j,k,bfsize,p;
  986. double *X1,*X2,*X;
  988. /*计算快速沃尔什变换点数*/
  989. count=1<<power;
  990. /*分配运算所需存储器*/
  991. X1=(double *)malloc(sizeof(double)*count);
  992. X2=(double *)malloc(sizeof(double)*count);
  993. /*将时域点写入存储器*/
  994. memcpy(X1,f,sizeof(double)*count);
  995. /*蝶形运算*/
  996. for(k=0;k<power;k++)
  997. {
  998. for(j=0;j<1<<k;j++)
  999. {
  1000. bfsize=1<<(power-k);
  1001. for(i=0;i<bfsize/2;i++)
  1002. {
  1003. p=j*bfsize;
  1004. X2[i+p]=X1[i+p]+X1[i+p+bfsize/2];
  1005. X2[i+p+bfsize/2]=X1[i+p]-X1[i+p+bfsize/2];
  1006. }
  1007. }
  1008. X=X1;
  1009. X1=X2;
  1010. X2=X;
  1011. }
  1012. /*调整系数*/
  1013. // for(i=0;i<count;i++)
  1014. // {
  1015. // W[i]=X1[i]/count;
  1016. // }
  1017. for(j=0;j<count;j++)
  1018. {
  1019. p=0;
  1020. for(i=0;i<power;i++)
  1021. {
  1022. if (j&(1<<i)) p+=1<<(power-i-1);
  1023. }
  1024. W[j]=X1[p]/count;
  1025. }
  1026. /*释放存储器*/
  1027. free(X1);
  1028. free(X2);
  1029. }
  1032. void Fourier1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1033. {
  1034. int w=1,h=1,wp=0,hp=0;
  1035. while(w*2<=nWidth)
  1036. {
  1037. w*=2;
  1038. wp++;
  1039. }
  1040. while(h*2<=nHeight)
  1041. {
  1042. h*=2;
  1043. hp++;
  1044. }
  1045. int x,y;
  1046. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1047. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1049. COMPLEX *TD=new COMPLEX[w*h];
  1050. COMPLEX *FD=new COMPLEX[w*h];
  1052. for(y=0;y<h;y++)
  1053. {
  1054. for(x=0;x<w;x++)
  1055. {
  1056. TD[x+w*y].re=Point(x,y);
  1057. TD[x+w*y].im=0;
  1058. }
  1059. }
  1061. for(y=0;y<h;y++)
  1062. {
  1063. FFT(&TD[w*y],&FD[w*y],wp);
  1064. // Progress(y*nHeight/2/h);
  1065. }
  1066. for(y=0;y<h;y++)
  1067. {
  1068. for(x=0;x<w;x++)
  1069. {
  1070. TD[y+h*x]=FD[x+w*y];
  1071. // TD[x+w*y]=FD[x*h+y];
  1072. }
  1073. }
  1074. for(x=0;x<w;x++)
  1075. {
  1076. FFT(&TD[x*h],&FD[x*h],hp);
  1077. Progress(x*nHeight/2/w+nHeight/2);
  1078. }
  1080. memset(lpPoints,0,nWidth*nHeight);
  1081. double m;
  1082. for(y=0;y<h;y++)
  1083. {
  1084. for(x=0;x<w;x++)
  1085. {
  1086. m=sqrt(FD[x*h+y].re*FD[x*h+y].re+FD[x*h+y].im*FD[x*h+y].im)/100;
  1087. if (m>255) m=255;
  1088. Point((x<w/2?x+w/2:x-w/2),nHeight-1-(y<h/2?y+h/2:y-h/2))=(BYTE)(m);
  1089. }
  1090. }
  1091. delete TD;
  1092. delete FD;
  1093. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  1094. delete lpPoints;
  1095. }
  1097. void Walsh1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1098. {
  1099. int w=1,h=1,wp=0,hp=0;
  1100. while(w*2<=nWidth)
  1101. {
  1102. w*=2;
  1103. wp++;
  1104. }
  1105. while(h*2<=nHeight)
  1106. {
  1107. h*=2;
  1108. hp++;
  1109. }
  1110. int x,y;
  1111. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1112. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1114. double *f=new double[w*h];
  1115. double *W=new double[w*h];
  1117. for(y=0;y<h;y++)
  1118. {
  1119. for(x=0;x<w;x++)
  1120. {
  1121. f[x+y*w]=Point(x,y);
  1122. }
  1123. }
  1125. for(y=0;y<h;y++)
  1126. {
  1127. WALh(f+w*y,W+w*y,wp);
  1128. Progress(y*nHeight/2/h);
  1129. }
  1130. for(y=0;y<h;y++)
  1131. {
  1132. for(x=0;x<w;x++)
  1133. {
  1134. f[x*h+y]=W[x+w*y];
  1135. }
  1136. }
  1137. for(x=0;x<w;x++)
  1138. {
  1139. WALh(f+x*h,W+x*h,hp);
  1140. // Progress(x*nHeight/2/w+nHeight/2);
  1141. }
  1142. double a;
  1143. memset(lpPoints,0,nWidth*nHeight);
  1145. for(y=0;y<h;y++)
  1146. {
  1147. for(x=0;x<w;x++)
  1148. {
  1149. a=fabs(W[x*h+y]*1000);
  1150. if (a>255) a=255;
  1151. Point(x,nHeight-y-1)=(BYTE)a;
  1152. }
  1153. }
  1154. delete f;
  1155. delete W;
  1156. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  1157. delete lpPoints;
  1158. }
  1160. void Dct1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1161. {
  1162. int w=1,h=1,wp=0,hp=0;
  1163. while(w*2<=nWidth)
  1164. {
  1165. w*=2;
  1166. wp++;
  1167. }
  1168. while(h*2<=nHeight)
  1169. {
  1170. h*=2;
  1171. hp++;
  1172. }
  1173. int x,y;
  1174. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1175. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1177. double *f=new double[w*h];
  1178. double *W=new double[w*h];
  1180. for(y=0;y<h;y++)
  1181. {
  1182. for(x=0;x<w;x++)
  1183. {
  1184. f[x+y*w]=Point(x,y);
  1185. }
  1186. }
  1188. for(y=0;y<h;y++)
  1189. {
  1190. DCT(&f[w*y],&W[w*y],wp);
  1191. // Progress(y*nHeight/2/h);
  1192. }
  1193. for(y=0;y<h;y++)
  1194. {
  1195. for(x=0;x<w;x++)
  1196. {
  1197. f[x*h+y]=W[x+w*y];
  1198. }
  1199. }
  1200. for(x=0;x<w;x++)
  1201. {
  1202. DCT(&f[x*h],&W[x*h],hp);
  1203. Progress(x*nHeight/2/w+nHeight/2);
  1204. }
  1205. double a;
  1206. memset(lpPoints,0,nWidth*nHeight);
  1208. for(y=0;y<h;y++)
  1209. {
  1210. for(x=0;x<w;x++)
  1211. {
  1212. a=fabs(W[x*h+y]);
  1213. if (a>255) a=255;
  1214. Point(x,nHeight-y-1)=(BYTE)(a);
  1215. }
  1216. }
  1217. delete f;
  1218. delete W;
  1219. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  1220. delete lpPoints;
  1221. }
  1223. int Conv2(int nWidth,int nHeight,BYTE *lpOutput,BYTE *lpInput,double mask[],int windowX,int windowY);
  1224. int Laplacian(int nWidth,int nHeight,BYTE *lpOutput,double *lpInput);
  1225. int Zerocross(int nWidth,int nHeight,BYTE *lpOutput,double *lpInput,double thresh);
  1226. int LoG(int nWidth,int nHeight,BYTE *lpOutput,BYTE *lpInput,double thresh,double sigma);
  1228. #define In(x,y) lpInput[(x)+(y)*nWidth]
  1229. #define Out(x,y) lpOutput[(x)+(y)*nWidth]
  1230. #define Mediate(x,y) lpMediate[(x)+(y)*nWidth]
  1232. #include "NumberDlg.h"
  1233. double GetNumber(const char *prompt,double number,double max)
  1234. {
  1235. CNumberDlg dlg;
  1236. dlg.m_Prompt=prompt;
  1237. dlg.m_Number=number;
  1238. dlg.DoModal();
  1239. if (dlg.m_Number>max) dlg.m_Number=max;
  1240. return dlg.m_Number;
  1241. }  
  1243. void Gauss1(int nWidth,int nHeight,BYTE *lpIn,BYTE *lpOut,void (* Progress)(int Pos))
  1244. {
  1245. double sigma=GetNumber("输入高斯模糊半径:",1,10);
  1246. int x,y,xx,xk,yk;
  1247. BYTE *lpInput=new BYTE[nWidth*nHeight];
  1248. BYTE *lpOutput=new BYTE[nWidth*nHeight];
  1249. GetPoints(nWidth,nHeight,lpIn,lpInput);
  1251. int radius,window; //window of the converlutin kernel(window=2*radius+1)
  1252. double dev_inv=0.5/(sigma*sigma);  //1/(2*sigma^2)
  1253. radius = (int)ceil(3*sigma);
  1254. window = radius*2+1;
  1255. //fast algorithm
  1256. memcpy(lpOutput,lpInput,nWidth*nHeight);
  1257. double* lpMediate=new double[nWidth*nHeight];
  1259. double* mask=new double[window];
  1260. double sum=0;
  1261. double temp;
  1262. double weight;//sum of weight of mask at edge of the image
  1263. //generate mask
  1264. for(x=0;x<radius;x++)
  1265. {
  1266. xx=(x-radius)*(x-radius);
  1267. mask[x]=exp(-xx*dev_inv);
  1268. mask[window-1-x]=mask[x];
  1269. sum+=2*mask[x];
  1270. }
  1271. mask[radius]=1;
  1272. sum+=1;
  1273. for(x=0;x<window;x++)
  1274. {
  1275. mask[x]/=sum;
  1276. }
  1277. //row process
  1278. for(y=0;y<nHeight;y++)
  1279. {
  1280. for(x=radius;x<nWidth-radius;x++)
  1281. {
  1282. temp=0;
  1283. for(xk=-radius;xk<radius+1;xk++)
  1284. temp+=In(x+xk,y)*mask[xk+radius];
  1285. Mediate(x,y)=temp;
  1286. }
  1287. for(x=0;x<radius;x++)
  1288. {
  1289. temp=0;
  1290. weight=0;
  1291. for(xk=-x;xk<radius+1;xk++)
  1292. {
  1293. temp+=In(x+xk,y)*mask[xk+radius];
  1294. weight+=mask[xk+radius];
  1295. }
  1296. Mediate(x,y)=temp/weight;
  1297. }
  1298. for(x=nWidth-radius;x<nWidth;x++)
  1299. {
  1300. temp=0;
  1301. weight=0;
  1302. for(xk=-radius;xk<nWidth-x;xk++)
  1303. {
  1304. temp+=In(x+xk,y)*mask[xk+radius];
  1305. weight+=mask[xk+radius];
  1306. }
  1307. Mediate(x,y)=temp/weight;
  1308. }
  1309. Progress(y/2);
  1310. }
  1311. //column process
  1312. double* Column = new double[nHeight];
  1313. for(x=0;x<nWidth;x++)
  1314. {
  1315. for(y=radius;y<nHeight-radius;y++)
  1316. {
  1317. temp=0;
  1318. for(yk=-radius;yk<radius+1;yk++)
  1319. temp+=Mediate(x,y+yk)*mask[yk+radius];
  1320. Column[y]=temp;
  1321. }
  1322. for(y=0;y<radius;y++)
  1323. {
  1324. temp=0;
  1325. weight=0;
  1326. for(yk=-y;yk<radius+1;yk++)
  1327. {
  1328. temp+=Mediate(x,y+yk)*mask[yk+radius];
  1329. weight+=mask[yk+radius];
  1330. }
  1331. Column[y]=temp/weight;
  1332. }
  1333.         for(y=nHeight-radius;y<nHeight;y++)
  1334. {
  1335. temp=0;
  1336. weight=0;
  1337. for(yk=-radius;yk<nHeight-y;yk++)
  1338. {
  1339. temp+=Mediate(x,y+yk)*mask[yk+radius];
  1340. weight+=mask[yk+radius];
  1341. }
  1342. Column[y]=temp/weight;
  1343. }
  1345. for(y=0;y<nHeight;y++)
  1346. {
  1347. Out(x,y)=(int)Column[y];
  1348. }
  1349. Progress(nHeight/2+x*nHeight/2/nWidth);
  1350. }
  1351. delete []Column;
  1352. delete []mask;
  1353. //    Laplacian(nWidth,nHeight,lpOutput,lpMediate);
  1354. delete []lpMediate;
  1355. //general method(hide)
  1356. PutPoints(nWidth,nHeight,lpOut,lpOutput);
  1357. delete lpInput;
  1358. delete lpOutput;
  1359. }
  1361. int Conv2(int nWidth,int nHeight,double *lpOutput,BYTE *lpInput,double mask[],int windowX,int windowY)
  1362. {
  1363. int x,y,xk,yk;
  1364. int radiusX=windowX/2;
  1365. int radiusY=windowY/2;
  1366. double temp;
  1367.     for(y=radiusY;y<nHeight-radiusY;y++)
  1368. {
  1369. for(x=radiusX;x<nWidth-radiusX;x++)
  1370. {
  1371. temp=0;
  1372. for(xk=-radiusX;xk<radiusX+1;xk++)
  1373. for(yk=-radiusY;yk<radiusY+1;yk++)
  1374. temp+=In(x+xk,y+yk)*mask[xk+radiusX+(yk+radiusY)*windowX];
  1375. Out(x,y)=temp;
  1376. }
  1377. }    
  1378. return 0;
  1379. }
  1381. int Zerocross(int nWidth,int nHeight,BYTE *lpOutput,double *lpInput,double thresh)
  1382. {
  1383. int x,y;
  1384. //zerocross cal
  1385. for(y=1;y<nHeight-1;y++)
  1386. {
  1387. for(x=1;x<nWidth-1;x++)
  1388. {
  1389. if(In(x,y)<0 && In(x+1,y)>0 &&
  1390. fabs(In(x,y)-In(x+1,y))>thresh)
  1391. {
  1392. Out(x,y)=255;
  1393. }
  1394. else if(In(x-1,y)>0 && In(x,y)<0 &&
  1395. fabs(In(x-1,y)-In(x,y))>thresh)
  1396. {
  1397. Out(x,y)=255;
  1398. }
  1399. else if(In(x,y)<0 && In(x,y+1)>0 &&
  1400. fabs(In(x,y)-In(x,y+1))>thresh)
  1401. {
  1402. Out(x,y)=255;
  1403. }
  1404. else if(In(x,y-1)>0 && In(x,y)<0 &&
  1405. fabs(In(x,y)-In(x,y-1))>thresh)
  1406. {
  1407. Out(x,y)=255;
  1408. }
  1409. /* if((In(x,y)<0 && In(x+1,y)>0)||
  1410.    (In(x,y)<0 && In(x,y+1)>0)||
  1411.    (In(x,y)>0 && In(x+1,y)<0)||
  1412.    (In(x,y)>0 && In(x,y+1)<0))
  1413. {
  1414. Out(x,y)=255;
  1415. }
  1416. */ else if(In(x,y)==0)
  1417. {
  1418. if(In(x-1,y)<0 && In(x+1,y)>0 &&
  1419.    fabs(In(x-1,y)-In(x+1,y))>2*thresh)
  1420. {
  1421. Out(x,y)=255;
  1422. }
  1423.     else if(In(x-1,y)>0 && In(x+1,y)<0 &&
  1424.     fabs(In(x-1,y)-In(x+1,y))>2*thresh)
  1425. {
  1426.     Out(x,y)=255;
  1427. }
  1428.     else if(In(x,y-1)>0 && In(x,y+1)<0 &&
  1429.      fabs(In(x,y-1)-In(x,y+1))>2*thresh)
  1430. {
  1431.     Out(x,y)=255;
  1432. }
  1433.     else if(In(x,y+1)>0 && In(x,y-1)<0 &&
  1434.     fabs(In(x,y+1)-In(x,y-1))>2*thresh)
  1435. {
  1436.     Out(x,y)=255;
  1437. }
  1438. else 
  1439. {
  1440.     Out(x,y)=0;
  1441. }
  1442. }
  1443. else 
  1444. {
  1445. Out(x,y)=0;
  1446. }
  1447. }
  1448. }
  1449. return 0;
  1450. }
  1452. void LoG(int nWidth,int nHeight,BYTE *lpIn,BYTE *lpOut,void (* Progress)(int Pos))
  1453. {
  1455. BYTE *lpInput=new BYTE[nWidth*nHeight];
  1456. BYTE *lpOutput=new BYTE[nWidth*nHeight];
  1457. GetPoints(nWidth,nHeight,lpIn,lpInput);
  1458. double thresh=0,sigma=1;
  1460.     int x,y,xx,yy;
  1461. int radius,window; //window of the converlutin kernel(window=2*radius+1)
  1462. double dev_inv=0.5/(sigma*sigma);  //1/(2*sigma^2)
  1463. radius = (int)ceil(3*sigma);
  1464. window = radius*2+1;
  1465.     //generate mask of convolution (matlab code)
  1466. //std2 = std*std;
  1467.     //h1 = exp(-(x.*x + y.*y)/(2*std2));
  1468.     
  1469. double* mask = new double [window*window];
  1470. double sum=0;
  1471. double std2=2*sigma*sigma;
  1472.     for(y=0;y<radius;y++)
  1473. {
  1474. for(x=0;x<radius;x++)
  1475. {
  1476. yy=(y-radius)*(y-radius);
  1477. xx=(x-radius)*(x-radius);
  1478. mask[x+y*window]=exp(-(xx+yy)*dev_inv);
  1479. // mask[window-1-x+y*window]=mask[x+y*window];
  1480. // mask[window-1-x+(window-1-y)*window]=mask[x+y*window];
  1481. // mask[x+(window-1-y)*window]=mask[x+y*window];
  1482. sum=sum+4*mask[x+y*window];
  1483. }
  1484. }
  1485. x=radius;
  1486. for(y=0;y<radius;y++)
  1487. {
  1488. yy=(y-radius)*(y-radius);
  1489. mask[x+y*window]=exp(-yy*dev_inv);
  1490. // mask[x+(window-1-y)*window]=mask[x+y*window];
  1491. sum=sum+2*mask[x+y*window];
  1492. }
  1493. y=radius;
  1494. for(x=0;x<radius;x++)
  1495. {
  1496. xx=(x-radius)*(x-radius);
  1497. mask[x+y*window]=exp(-xx*dev_inv);
  1498. // mask[window-1-x+y*window]=mask[x+y*window];
  1499. sum=sum+2*mask[x+y*window];
  1500. }
  1501. mask[radius+radius*window]=1;
  1502. sum=sum+mask[radius+radius*window];
  1503. //h = h1.*(x.*x + y.*y - 2*std2)/(2*pi*(std^6));
  1504. double denominator=2*3.14159265*pow(sigma,6)*sum;
  1505. sum=0;
  1506. for(x=0;x<radius;x++)
  1507. {
  1508. for(y=0;y<radius;y++)
  1509. {
  1510. yy=(y-radius)*(y-radius);
  1511. xx=(x-radius)*(x-radius);
  1512. mask[x+y*window]=mask[x+y*window]*(xx+yy-2*std2)/denominator;
  1513. // mask[window-1-x+y*window]=mask[x+y*window];
  1514. // mask[window-1-x+(window-1-y)*window]=mask[x+y*window];
  1515. // mask[x+(window-1-y)*window]=mask[x+y*window];
  1516. sum=sum+4*mask[x+y*window];
  1517. }
  1518. }
  1519. x=radius;
  1520. for(y=0;y<radius;y++)
  1521. {
  1522. yy=(y-radius)*(y-radius);
  1523. mask[x+y*window]=mask[x+y*window]*(yy-2*std2)/denominator;
  1524. // mask[x+(window-1-y)*window]=mask[x+y*window];
  1525. sum=sum+2*mask[x+y*window];
  1526. }
  1527. y=radius;
  1528. for(x=0;x<radius;x++)
  1529. {
  1530. xx=(x-radius)*(x-radius);
  1531. mask[x+y*window]=mask[x+y*window]*(xx-2*std2)/denominator;
  1532. // mask[window-1-x+y*window]=mask[x+y*window];
  1533. sum=sum+2*mask[x+y*window];
  1534. }
  1535. mask[radius+radius*window]=mask[radius+radius*window]*(-2*std2)/denominator;
  1536. sum=sum+mask[radius+radius*window];
  1537. //h = h - sum(h(:))/prod(size(h)); % make the filter sum to zero
  1538. double average=sum/(window*window);
  1539. for(x=0;x<radius;x++)
  1540. {
  1541. for(y=0;y<radius;y++)
  1542. {
  1543. mask[x+y*window]=mask[x+y*window]-average;
  1544. mask[window-1-x+y*window]=mask[x+y*window];
  1545. mask[window-1-x+(window-1-y)*window]=mask[x+y*window];
  1546. mask[x+(window-1-y)*window]=mask[x+y*window];
  1547. }
  1548. }
  1549. x=radius;
  1550. for(y=0;y<radius;y++)
  1551. {
  1552. mask[x+y*window]=mask[x+y*window]-average;
  1553. mask[x+(window-1-y)*window]=mask[x+y*window];
  1554. }
  1555. y=radius;
  1556. for(x=0;x<radius;x++)
  1557. {
  1558. mask[x+y*window]=mask[x+y*window]-average;
  1559. mask[window-1-x+y*window]=mask[x+y*window];
  1560. }
  1561. mask[radius+radius*window]=mask[radius+radius*window]-average;
  1563.     double* lpMediate = new double[nWidth*nHeight];
  1564. //2D convolution
  1565. if(Conv2(nWidth,nHeight,lpMediate,lpInput,mask,window,window))
  1566. {
  1567. TRACE("error in Conv2");
  1568. return;
  1569. };
  1570. //calcaulate the thresh for default
  1571. //  thresh = .75*mean2(abs(b(rr,cc)));
  1572. sum = 0;
  1573.     for(y=radius;y<nHeight-radius;y++)
  1574. {
  1575. for(x=radius;x<nWidth-radius;x++)
  1576. {
  1577. sum = sum + fabs(Mediate(x,y));
  1578. }
  1579. }
  1580. thresh=0.5*sum/((nWidth-2*radius)*(nHeight-2*radius));
  1581. //zerocross cal
  1582.     if(Zerocross(nWidth,nHeight,lpOutput,lpMediate,thresh))
  1583. {
  1584. TRACE("error in Zerocross");
  1585. return;
  1586. }
  1587. delete mask;
  1588. PutPoints(nWidth,nHeight,lpOut,lpOutput);
  1589. delete lpInput;
  1590. delete lpOutput;
  1591. }
  1593. void BiValue1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput)
  1594. {
  1595. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1596. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1597. double t=GetNumber("请输入阈值",128,255);
  1598. BYTE threshold=(BYTE)t;
  1599. int x,y;
  1600. for(y=0;y<nHeight;y++)
  1601. {
  1602. for(x=0;x<nWidth;x++)
  1603. {
  1604. if (Point(x,y)>threshold) Point(x,y)=255;
  1605. else Point(x,y)=0;
  1606. }
  1607. }
  1609. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  1610. delete lpPoints;
  1611. }
  1613. void Sobel(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1614. {
  1615. int x,y,x1,y1,i;
  1616. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1617. BYTE *lpPoints1=new BYTE[nWidth*nHeight];
  1618. memset(lpPoints1,0,nWidth*nHeight);
  1619. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1621. int d,max;
  1622. static s[8][9]={
  1623. {-1,-2,-1,0,0,0,1,2,1},
  1624. {0,-1,-2,1,0,-1,2,1,0},
  1625. {1,0,-1,2,0,-2,1,0,-1},
  1626. {2,1,0,1,0,-1,0,-1,-2},
  1627. {1,2,1,0,0,0,-1,-2,-1},
  1628. {0,1,2,-1,0,1,-2,-1,0},
  1629. {-1,0,1,-2,0,2,-1,0,1},
  1630. {-2,-1,0,-1,0,1,0,1,2}
  1631. };
  1632. for(y=1;y<nHeight-1;y++)
  1633. {
  1634. for(x=1;x<nWidth-1;x++)
  1635. {
  1636. max=0;
  1637. for(i=0;i<8;i++)
  1638. {
  1639. d=0;
  1640. for(y1=0;y1<3;y1++)
  1641. for(x1=0;x1<3;x1++)
  1642. {
  1643. d+=s[i][x1+y1*3]*Point(x+x1-1,y+y1-1);
  1644. }
  1645. if (d>max) max=d;
  1646. }
  1647. if (max>255) max=255;
  1648. Point1(x,y)=(BYTE)max;
  1649. }
  1650. Progress(y);
  1651. }
  1652. PutPoints(nWidth,nHeight,lpOutput,lpPoints1);
  1653. delete lpPoints;
  1654. delete lpPoints1;
  1655. }
  1657. void Prewitte(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1658. {
  1659. int x,y,x1,y1,i;
  1660. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1661. BYTE *lpPoints1=new BYTE[nWidth*nHeight];
  1662. memset(lpPoints1,0,nWidth*nHeight);
  1663. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1665. int d,max;
  1666. static s[8][9]={
  1667. {-1,-1,-1,0,0,0,1,1,1},
  1668. {0,-1,-1,1,0,-1,1,1,0},
  1669. {1,0,-1,1,0,-1,1,0,-1},
  1670. {1,1,0,1,0,-1,0,-1,-1},
  1671. {1,1,1,0,0,0,-1,-1,-1},
  1672. {0,1,1,-1,0,1,-1,-1,0},
  1673. {-1,0,1,-1,0,1,-1,0,1},
  1674. {-1,-1,0,-1,0,1,0,1,1}
  1675. };
  1676. for(y=1;y<nHeight-1;y++)
  1677. {
  1678. for(x=1;x<nWidth-1;x++)
  1679. {
  1680. max=0;
  1681. for(i=0;i<8;i++)
  1682. {
  1683. d=0;
  1684. for(y1=0;y1<3;y1++)
  1685. for(x1=0;x1<3;x1++)
  1686. {
  1687. d+=s[i][x1+y1*3]*Point(x+x1-1,y+y1-1);
  1688. }
  1689. if (d>max) max=d;
  1690. }
  1691. if (max>255) max=255;
  1692. Point1(x,y)=(BYTE)max;
  1693. }
  1694. Progress(y);
  1695. }
  1696. PutPoints(nWidth,nHeight,lpOutput,lpPoints1);
  1697. delete lpPoints;
  1698. delete lpPoints1;
  1699. }
  1701. void Roberts(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1702. {
  1703. int x,y;
  1704. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1705. BYTE *lpPoints1=new BYTE[nWidth*nHeight];
  1706. memset(lpPoints1,0,nWidth*nHeight);
  1707. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1709. int d;
  1710. for(y=0;y<nHeight-1;y++)
  1711. {
  1712. for(x=0;x<nWidth-1;x++)
  1713. {
  1714. d=2*(abs(Point(x,y)-Point(x+1,y+1))+abs(Point(x+1,y)-Point(x,y+1)));
  1715. if (d>255) d=255;
  1716. Point1(x,y)=(BYTE)d;
  1717. }
  1718. Progress(y);
  1719. }
  1720. PutPoints(nWidth,nHeight,lpOutput,lpPoints1);
  1721. delete lpPoints;
  1722. delete lpPoints1;
  1723. }
  1725. void PseudoColor1(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1726. {
  1727. int x,y;
  1728. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1729. int nByteWidth=nWidth*3;
  1730. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  1731. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1732. BYTE b,R,G,B;
  1733. for(y=0;y<nHeight;y++)
  1734. {
  1735. for(x=0;x<nWidth;x++)
  1736. {
  1737. b=Point(x,y);
  1738. if (b<64)
  1739. {
  1740. B=255;
  1741. G=4*b;
  1742. R=0;
  1743. }
  1744. else if (b<128)
  1745. {
  1746. B=(127-b)*4;
  1747. G=255;
  1748. R=0;
  1749. }
  1750. else if (b<192)
  1751. {
  1752. B=0;
  1753. G=255;
  1754. R=(b-128)*4;
  1755. }
  1756. else
  1757. {
  1758. B=0;
  1759. G=(255-b)*4;
  1760. R=255;
  1761. }
  1763. lpOutput[x*3+nByteWidth*y]=B;
  1764. lpOutput[x*3+1+nByteWidth*y]=G;
  1765. lpOutput[x*3+2+nByteWidth*y]=R;
  1766. }
  1767. Progress(y);
  1768. }
  1769. delete lpPoints;
  1770. }
  1772. BYTE psf2(BYTE x)
  1773. {
  1774. double x1=x;
  1775. return (BYTE)((5-x1/42.5)*x1);
  1776. }
  1778. void PseudoColor2(int nWidth,int nHeight,BYTE *lpInput,BYTE *lpOutput,void (* Progress)(int Pos))
  1779. {
  1780. int x,y;
  1781. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1782. int nByteWidth=nWidth*3;
  1783. if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  1784. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  1785. BYTE b,R,G,B;
  1786. for(y=0;y<nHeight;y++)
  1787. {
  1788. for(x=0;x<nWidth;x++)
  1789. {
  1790. b=Point(x,y);
  1791. if (b<85)
  1792. {
  1793. B=psf2(84-b);
  1794. G=psf2(b);
  1795. R=0;
  1796. }
  1797. else if (b<170)
  1798. {
  1799. B=0;
  1800. G=psf2(169-b);
  1801. R=psf2(b-85);
  1802. }
  1803. else
  1804. {
  1805. B=psf2(b-170);
  1806. G=0;
  1807. R=psf2(255-b);
  1808. }
  1810. lpOutput[x*3+nByteWidth*y]=B;
  1811. lpOutput[x*3+1+nByteWidth*y]=G;
  1812. lpOutput[x*3+2+nByteWidth*y]=R;
  1813. }
  1814. Progress(y);
  1815. }
  1816. delete lpPoints;
  1817. }