分段OTSU处理图像数据

/*===================================================================================

function:  OTSU_Algorithm

input   :  image data

output  :  threshold value

return  :  void

====================================================================================*/

void OTSU_Algorithm()//OTSU algorithm

{

    INT16  i;

 INT16  j;

 INT16  NUM=4;  //block num 4*4

 INT16  h=g_ImgHeight/NUM;

    INT16  w=g_ImgWidth/NUM;

 INT16  h_src=g_ImgHeight/NUM;

    INT16  w_src=g_ImgWidth/NUM;

 INT32  GrayHistogram[256];//program start

    BYTE   *src=g_pImg;

 INT16  nPixel;

 INT16  m=0,n=0;

 float  u0,u1;

 float  w0,w1;

 int    nCount0;

 int    nT,nBestT;

 float  fVaria,fMaxVaria = 0;

 int    nSum=h*w;

 INT16  ww=g_ImgWidth- w*(NUM-1); //edge's block  width

 INT16  hh=g_ImgHeight-h*(NUM-1); //edge's block  height

 INT16  ii=0,jj=0;

 for(m=0;m<NUM;m++)

 {

   for(n=0;n<NUM;n++)

   {

         if(3==m&&3!=n)

         {

            w=ww;

      h=h_src;

         }else if(3!=m&&3==n)

         {

             h=hh;

    w=w_src;

         }else if(3==m&&3==n)

         {

            w=ww;

      h=hh;

         }else{

            w=w_src;

      h=h_src;

         }

   for(int i=0;i<256;i++)//initialization

   {

       GrayHistogram[i]=0;

      }

   for(i=0;i<h;i++)//core step

   {

      for(j=0;j<w;j++)

       {

          ii=i+m*h_src;

       jj=j+n*w_src;

          nPixel=src[ii*g_ImgWidth+jj]; //statistics point

       GrayHistogram[nPixel]++;

       }

   }

   for(nT=0;nT<256;nT++)//core part

   {

      //compute C0 part

      u0 = 0;

      nCount0=0;

      for(i=0;i<=nT;i++)

       {

          u0+=i*GrayHistogram[i]; //compute average

       nCount0+=GrayHistogram[i];

       }

      u0 /=nCount0;

      w0 =(float)nCount0*1.0/nSum;

      //compute C1 part

      u1 = 0;

      for(i=nT+1;i<256;i++)

      {

        u1+=i*GrayHistogram[i]; //compute average

      }

      w1 = 1-w0;

      //compute variance

      fVaria =w0*w1*(u0-u1)*(u0-u1);

      if(fVaria>fMaxVaria)

      {

           fMaxVaria=fVaria;

     nBestT   =nT;

         }

    }

     for(i=0;i<h;i++)//core step

   {

      for(j=0;j<w;j++)

       {

          ii=i+m*h_src;

       jj=j+n*w_src;

          nPixel=src[ii*g_ImgWidth+jj]; //statistics point

          if(nPixel<nBestT)

          {

             src[ii*g_ImgWidth+jj]=0;

          }else{

             src[ii*g_ImgWidth+jj]=255;

          }

       GrayHistogram[nPixel]++;

       }

   }

     fMaxVaria=0;

     nBestT=0;

    }

 }

}

 

 

/*===================================================================================

function:  Seed_S_Find

input   :  image data,seed point

output  :  image

return  :  void

====================================================================================*/

struct stCardRectangle Seed_S_Find(BYTE *src,BYTE *Middle_Img,INT16 x,INT16 y)

{

 INT16 Step_Path=20; 

 INT16 x0=0,y0=0,x1=0,y1=0,xx=0,yy=0;

 INT16 i,j,num;

 BOOL  No_Seed=FALSE,Top=TRUE,Down=TRUE,Left=TRUE,Right=TRUE;

 BYTE  Seed_Value=src[y*g_ImgWidth+x],Seed_New;//seed point value

 //Current_Line

 //1、right search

 for(i=x;i<(x+Step_Path);i++)

 {

  if(i<g_ImgWidth)

  {

   Seed_New=src[y*g_ImgWidth+i];

   if(ABS((Seed_New-Seed_Value))<4)

   {

    Middle_Ims[y*g_ImgWidth+i]=255;

    x1=i;

   }else{

    break;

   }

  }else{

   x1=g_ImgWidth-1;

   break;

  }

 }

 //2、left search

 for(i=x;i>=(x-Step_Path);i--)

 {

  if(i>=0)

  {

   Seed_New=src[y*g_ImgWidth+i];

   if(ABS((Seed_New-Seed_Value))<4)

   {

    Middle_Ims[y*g_ImgWidth+i]=255;

    x0=i;

   }else{

    break;

   }

  }else{

   x0=0;

   break;

  }

 }

 y0=y;

 y1=y;

 xx=0;

 yy=0;

 for(num=1;num<Step_Path;num++)

 {

  //1、top

  yy=0;

  if(FALSE!=Top)

  {

   if((y-num)<0)

   {

    y0=0;

    Top=FALSE;

   }

   for(i=x-num;i<=x+num;i++)

   {

    if(i>=0&&i<g_ImgWidth)

    {

     Seed_New=src[(y-num)*g_ImgWidth+i];

     if(ABS((Seed_New-Seed_Value))<4)

     {

      Middle_Ims[(y-num)*g_ImgWidth+i]=255;

      yy+=1;

     }

    }

   }

   if(yy>1)

   {

    yy=0;

    y0=y-num;

   }else{

    Top=FALSE;

    yy=0; 

   }

  }

  //2、down

  yy=0;

  if(FALSE!=Down)

  {

   if((y+num)>(g_ImgHeight-1))

   {

    y1=g_ImgHeight-1;

    Down=FALSE;

   }

   for(i=x-num;i<=x+num;i++)

   {

    if(i>=0&&i<g_ImgWidth)

    {

     Seed_New=src[(y+num)*g_ImgWidth+i];

     if(ABS((Seed_New-Seed_Value))<4)

     {

      Middle_Ims[(y+num)*g_ImgWidth+i]=255;

      yy+=1;

     }

    }

   }

   if(yy>1)

   {

    yy=0;

    y1=y+num;

   }else{

    yy=0;

    Down=FALSE;    

   }

  }

  //3、left

  xx=0;

  if(FALSE!=Left)

  {

   if((x-num)<0)

   {

    x0=0;

    Left=FALSE;

   }

   for(i=y-num;i<=(y+num);i++)

   {

    if(i>=0&&i<g_ImgHeight)

    {

     Seed_New=src[i*g_ImgWidth+x-num];

     if(ABS((Seed_New-Seed_Value))<4)

     {

      Middle_Ims[i*g_ImgWidth+x-num]=255;

      xx+=1;

     }

    }

   }

   if(xx>1)

   {

    xx=0;

    if(x0>(x+num))

    {

     x0=x+num;

    }

   }else{

    xx=0;

    Left=FALSE;    

   }

  }

  //4、right

  xx=0;

  if(FALSE!=Right)

  {

   if((x+num)>(g_ImgWidth-1))

   {

    x1=g_ImgWidth-1;

    Right=FALSE;

   }

   for(i=y-num;i<=y+num;i++)

   {

    if(i>=0&&i<g_ImgHeight)

    {

     Seed_New=src[i*g_ImgWidth+x+num];

     if(ABS((Seed_New-Seed_Value))<4)

     {

      Middle_Ims[i*g_ImgWidth+x+num]=255;

      xx+=1;

     }

    }

   }

   if(xx>1)

   {

    xx=0;

    if(x1<(x+num))

    {

     x1=x+num;

    }

   }else{

    xx=0;

    Right=FALSE;    

   }

  }

 }

 struct stCardRectangle re;

 re.x0=x0;

 re.y0=y0;

 re.x1=x1;

 re.y1=y1;

 return re;

}

 

 

/*===================================================================

function:  Card_S_Sobel

input   :  Parameter rows is height,Parameter cols is width

output  :  Result Image

====================================================================*/

void Card_S_Sobel(BYTE *in,INT16 rows,INT16 cols,BYTE *out)

{

    INT32 i=0;

    INT16 H, O, V, Or;

    INT16 i00, i01,i02;

    INT16 i10, i12;

    INT16 i20, i21, i22;

    INT16 w = cols;

    for (i = 0; i < cols*(rows-2) - 2; i++)

    {

        i00=*(in+i);    

        i01=*(in+i +1);  

        i02=*(in+i +2);

        i10=*(in+i+w);         

        i12=*(in+i+w+2);

        i20=*(in+i+w+w); 

        i21=*(in+i+w+w+1); 

        i22=*(in+i+w+w+2);

        H = - i00 - 2*i01 - i02 +

            + i20 + 2*i21 + i22;

        V = - i00 + i02

            - 2*i10 + 2*i12

            - i20 + i22;

        O =(ABS(H)>ABS(V))?ABS(H):ABS(V);

        if(O>206)

        {

            *(out+i)=255;

        }else{

            *(out+i)=0;

        }

    }

}