improc.cpp

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

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

#include "common.h"
#include "basic.h"
#include "improc.h"



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

unsigned char **Median(unsigned char **Image,int YStart,
			           int XStart,int Row,int Col,int MaskSize)
{
  int 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,
			 int IRow, int ICol, int MRow, int MCol,
			 int YCenter, int XCenter)
{
  unsigned char **Result;
  int 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,
			int IRow, int ICol, int MRow, int MCol,
			int YCenter, int XCenter)
{
  unsigned char **Result;
  int 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, int YStart, int XStart, 
			  int Row, int Col)
{
    int 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  *********************************/
double ucGetSquareSum(unsigned char **Image,int YStart,int XStart,int Row,
                     int Col)
{
  int   i,j;
  double SquareSum = 0.0;

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

  return(SquareSum);
}

/************************  ucGetZSquareSum  *********************************/
double ucGetZSquareSum(unsigned char **Image,int YStart,int XStart,int Row,
                      int Col,double ImageAve)
{
  int   i,j;
  double 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)                  */
double 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;
  double 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/((double)(row-2*margin)*(col-2*margin)));
}

/*****************************  ucDeviation   **************************/
/*  To get the deviation of a 2_dimension character array  */
double ucDeviation(unsigned char **a,int YStart,int XStart,int row,int col,
                  double 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((double)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  *********************************/
double iGetSquareSum(int **Image,int YStart,int XStart,int Row,int Col)
{
  int   i,j;
  double SquareSum = 0.0;

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

  return(SquareSum);
}

/************************  iGetZSquareSum  *********************************/
double iGetZSquareSum(int **Image,int YStart,int XStart,int Row,int Col,double ImageAve)
{
  int   i,j;
  double 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);
}

/*************************  iAverage      ********************************/
/*  To get the average of a 2_dimension integer array    */
/*  from (YStart,XStart) with (row,col)                  */
double iAverage(int **a,int YStart,int XStart,int row,int col,int margin)
{
  register int i,j;
  int start_i,end_i,start_j,end_j;
  double 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/((double)(row-2*margin)*(col-2*margin)));
}

/*****************************  iDeviation   **************************/
/*  To get the deviation of a 2_dimension integer array  */
double iDeviation(int **a,int YStart,int XStart,int row,int col,double 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((double)sqrt((square_sum-size*average*average)/(size-1.0)));
}

/*****************************  ucProbability  *************************/
/*  To get the pobability of a 2_dimension character array  */
/*  NOT USED  */
/*
void ucProbability(unsigned char **a,int row,int col,double *d,int margin)
{
  register i,j;
  int start_i,end_i,start_j,end_j;
  double total;

  start_i = start_j = margin;
  end_i = row - margin;
  end_j = col - margin;

  for(i=0;i<256;i++) d[i] = 0.0;

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

  total = (double)(row-margin*2)*(double)(col-margin*2);
  for(i=0;i<256;i++) d[i] /= total;
}
*/

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

  start_i = start_j = margin;
  end_i = row - margin;
  end_j = col - margin;
  max = 0;
  min = 1024*1024*2+1;

  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);
}

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

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

  return(SquareSum);
}

/************************  fGetZSquareSum  *********************************/
double fGetZSquareSum(double **Image,int YStart,int XStart,int Row,int Col,
                     double ImageAve)
{
  int   i,j;
  double 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);
}

/****************************   fAverage  *******************************/
/*  To get the average of a 2_dimension double array  */
double fAverage(double **a,int YStart,int XStart,int row,int col,int margin)
{
  register int i,j;
  int start_i,end_i,start_j,end_j;
  double 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/((double)(row-margin*2)*(double)(col-margin*2)));
}

/*****************************  fDeviation   ****************************/
/*  To get the deviation of a 2_dimension double array  */
double fDeviation(double **a,int YStart,int XStart,int row,int col,
                 double 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 += a[i][j] * a[i][j];

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

/*************************  fProbability   ****************************/
/*  To get the pobability of a 2_dimension double array  */
/*  Seldom Used  */
void fProbability(double **a,int row,int col,double *d,double min,double ratio,
                  int margin)
{
  register i,j;
  int start_i,end_i,start_j,end_j;
  double total;