improc.c

图像处理软件,功能比较基础

#include <math.h>
#include <stdlib.h>
#include <search.h>

#include "imgproc.h"



static int SortFunction(const unsigned char *p1,const unsigned char *p2)
{
  return(*p1 - *p2);
};

unsigned char **Median(unsigned char **Image,short YStart,
			           short XStart,short Row,short Col,short MaskSize)
{
  short i,j,k,l;
  unsigned char **TemImage,*TemArr;

  TemImage = (unsigned char **)fspace_2d(Row,Col,sizeof(unsigned char));
  TemArr   = (unsigned char *)fspace_1d(MaskSize*MaskSize,sizeof(unsigned char));

  for(i=YStart;i<YStart+MaskSize/2;i++)
    for(j=XStart;j<XStart+Col;j++)
      TemImage[i-YStart][j-XStart] = Image[i][j];

  for(i=YStart+Row-MaskSize/2;i<YStart+Row;i++)
    for(j=XStart;j<XStart+Col;j++)
     TemImage[i-YStart][j-XStart] = Image[i][j];

  for(j=XStart;j<XStart+MaskSize/2;j++)
    for(i=YStart;i<YStart+Row;i++)
      TemImage[i-YStart][j-XStart] = Image[i][j];

  for(j=XStart+Col-MaskSize/2;j<XStart+Col;j++)
    for(i=YStart;i<YStart+Row;i++)
      TemImage[i-YStart][j-XStart] = Image[i][j];

  for(i=YStart;i<YStart+Row-MaskSize/2*2;i++)
    for(j=XStart;j<XStart+Col-MaskSize/2*2;j++)
    {
      for(k=i;k<i+MaskSize;k++)
	for(l=j;l<j+MaskSize;l++)
	  TemArr[(k-i)*MaskSize+(l-j)] = Image[k][l];

//      qsort((void *)TemArr,MaskSize*MaskSize,sizeof(unsigned char),
//	        SortFunction);

      TemImage[i-YStart+MaskSize/2][j-XStart+MaskSize/2] = TemArr[MaskSize*MaskSize/2];
    }

  free(TemArr);

  return(TemImage);
}


unsigned char **Dilation(unsigned char **Image, unsigned char **Model,
			 short IRow, short ICol, short MRow, short MCol,
			 short YCenter, short XCenter)
{
  unsigned char **Result;
  short i,j,k,l;

  Result = (unsigned char **)fspace_2d(IRow,ICol,sizeof(unsigned char));

  for(i=0;i<IRow;i++)
  {
    if ((i-YCenter<0)||(i-YCenter+MRow>=IRow))  continue;

    for(j=0;j<ICol;j++)
    {
      if ((j-XCenter<0)||(j-XCenter+MCol>=ICol))  continue;

      if (Image[i][j]==255)
	for(k=0;k<MRow;k++)
	  for(l=0;l<MCol;l++)
	    if (Model[k][l]==255) Result[i-YCenter+k][j-XCenter+l] = 255;
    }
  }

  return(Result);
}

unsigned char **Erosion(unsigned char **Image, unsigned char **Model,
			short IRow, short ICol, short MRow, short MCol,
			short YCenter, short XCenter)
{
  unsigned char **Result;
  short i,j,k,l,eros_flag;

  Result = (unsigned char **)fspace_2d(IRow,ICol,sizeof(unsigned char));

  for(i=0;i<IRow;i++)
  {
    if ((i-YCenter<0)||(i-YCenter+MRow>=IRow))  continue;

    for(j=0;j<ICol;j++)
    {
      if ((j-XCenter<0)||(j-XCenter+MCol>=ICol))  continue;

      eros_flag = 0;

	for(k=0;(k<MRow)&&(!eros_flag);k++)
	  for(l=0;(l<MCol)&&(!eros_flag);l++)
	    if ((Model[k][l]==255)&&(Image[i-YCenter+k][j-XCenter+l]==0))
	      eros_flag = 1;

	if (!eros_flag) Result[i][j] = 255;
    }
  }

  return(Result);
}

double Entropy(unsigned char** InImg, short YStart, short XStart, 
			  short Row, short Col)
{
    short m,n;
    double LocalEntropy;
    static long int     Hist[256];

	for(m=0;m<256;m++)  Hist[m] = 0;

	for(m=YStart;m<YStart+Row;m++)
	for(n=XStart;n<XStart+Col;n++)
	  Hist[InImg[m][n]]++;

	LocalEntropy = 0.0;
	for(m=0;m<256;m++)
	  if (Hist[m]!=0)
	    LocalEntropy -= (double)Hist[m] / Row / Col
			      * (double)log((double)Hist[m] / Row / Col);
	return(LocalEntropy);
}



/************************  ImageFold  *****************************/
unsigned char **ImageFold(unsigned char **Image,int Row,int Col,int Margin)
{
  unsigned char **FoldedImage;
  int           i,j;

  FoldedImage = (unsigned char **)fspace_2d(Row+2*Margin,Col+2*Margin,
                                            sizeof(unsigned char));

  for(i=0;i<Row;i++)
    for(j=0;j<Col;j++)
      FoldedImage[i+Margin][j+Margin] = Image[i][j];

  for(i=Margin;i<Col+Margin;i++)
    for(j=0;j<Margin;j++)
    {
      FoldedImage[Margin-j-1][i]   = FoldedImage[Margin+j][i];
      FoldedImage[Row+Margin+j][i] = FoldedImage[Row+Margin-j-1][i];
    }
  for(i=0;i<Row+2*Margin;i++)
    for(j=0;j<Margin;j++)
    {
      FoldedImage[i][Margin-j-1]   = FoldedImage[i][Margin+j];
      FoldedImage[i][Col+Margin+j] = FoldedImage[i][Col+Margin-j-1];
    }

  return(FoldedImage);
}

/***************************  iMax1d  *****************************/
/*  To get the maximum of a 1_dimension integer array  */
/*  NOT USED  */
/*
int ucMax1d(unsigned char *a,int col,int margin)
{
  register int i;
  int max = a[1];

  for(i=1;i<col-1;i++)
    if (max<a[i]) max = a[i];
  if (margin==0) {
    if (max<a[0]) max = a[0];
    if (max<a[col-1]) max = a[col-1];
  }
  return(max);
}
*/

/***************************  ucMax2d    ******************************/
/*  To get the maximum and the minimum of a 2_dimension character array  */
int ucMax2d(unsigned char **a,int row,int col,int margin,int *minp)
{
  register int i,j;
  int          max,min,start_i,end_i,start_j,end_j;

  max = min = a[1][1];
  start_i = start_j = margin;
  end_i = row - margin;
  end_j = col - margin;

  for(i=start_i;i<end_i;i++)
    for(j=start_j;j<end_j;j++) {
      if (max<a[i][j])
        max = a[i][j];
      else if (min>a[i][j]) min = a[i][j];
    }

  *minp = min;
  return(max);
}

/************************  ucGetSquareSum  *********************************/
float ucGetSquareSum(unsigned char **Image,int YStart,int XStart,int Row,
                     int Col)
{
  int   i,j;
  float SquareSum = 0.0;

  for(i=YStart;i<Row+YStart;i++)
    for(j=XStart;j<Col+XStart;j++)
      SquareSum += (float)Image[i][j] * Image[i][j];

  return(SquareSum);
}

/************************  ucGetZSquareSum  *********************************/
float ucGetZSquareSum(unsigned char **Image,int YStart,int XStart,int Row,
                      int Col,float ImageAve)
{
  int   i,j;
  float ZSquareSum = 0.0;

  for(i=YStart;i<Row+YStart;i++)
    for(j=XStart;j<Col+XStart;j++)
      ZSquareSum += (Image[i][j] - ImageAve) * (Image[i][j] - ImageAve);

  return(ZSquareSum);
}

/*************************  ucAverage      ********************************/
/*  To get the average of a 2_dimension character array  */
/*  from (YStart,XStart) with (row,col)                  */
float ucAverage(unsigned char **a,int YStart,int XStart,int row,int col,
                int margin)
{
  register int i,j;
  int start_i,end_i,start_j,end_j;
  float sum = 0.0;

  start_i = YStart + margin;
  start_j = XStart + margin;
  end_i   = row + YStart - margin;
  end_j   = col + XStart - margin;

  for(i=start_i;i<end_i;i++)
    for(j=start_j;j<end_j;j++)
      sum += a[i][j];

  return(sum/((float)(row-2*margin)*(col-2*margin)));
}

/*****************************  ucDeviation   **************************/
/*  To get the deviation of a 2_dimension character array  */
float ucDeviation(unsigned char **a,int YStart,int XStart,int row,int col,
                  float average,int margin)
{
  register int i,j;
  int start_i,end_i,start_j,end_j;
  long size = (long)(row - margin * 2) * (col - margin * 2);
  double square_sum = 0.0;

  start_i = YStart + margin;
  start_j = XStart + margin;
  end_i   = row + YStart - margin;
  end_j   = col + XStart - margin;

  for(i=start_i;i<end_i;i++)
    for(j=start_j;j<end_j;j++)
      square_sum += (double)a[i][j] * a[i][j];

  return((float)sqrt((square_sum-size*average*average)/(size-1.0)));
}

/*  To get the maximum and the minimum of a 2_dimension integer array  */
int iMax2d(int **a,int row,int col,int margin,int *minp)
{
  register int i,j;
  int          max,min,start_i,end_i,start_j,end_j;

  max = min = a[1][1];
  start_i = start_j = margin;
  end_i = row - margin;
  end_j = col - margin;

  for(i=start_i;i<end_i;i++)
    for(j=start_j;j<end_j;j++) {
      if (max<a[i][j])
        max = a[i][j];
      else if (min>a[i][j]) min = a[i][j];
    }

  *minp = min;
  return(max);
}

/************************  iGetSquareSum  *********************************/
float iGetSquareSum(int **Image,int YStart,int XStart,int Row,int Col)
{
  int   i,j;
  float SquareSum = 0.0;

  for(i=YStart;i<Row+YStart;i++)
    for(j=XStart;j<Col+XStart;j++)
      SquareSum += (float)Image[i][j] * Image[i][j];

  return(SquareSum);
}

/************************  iGetZSquareSum  *********************************/
float iGetZSquareSum(int **Image,int YStart,int XStart,int Row,int Col,float ImageAve)
{