improc.c

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

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

/*************************  iAverage      ********************************/
/*  To get the average of a 2_dimension integer array    */
/*  from (YStart,XStart) with (row,col)                  */
float 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;
  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)));
}

/*****************************  iDeviation   **************************/
/*  To get the deviation of a 2_dimension integer array  */
float iDeviation(int **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)));
}

/*****************************  ucProbability  *************************/
/*  To get the pobability of a 2_dimension character array  */
/*  NOT USED  */
/*
void ucProbability(unsigned char **a,int row,int col,float *d,int margin)
{
  register i,j;
  int start_i,end_i,start_j,end_j;
  float 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 = (float)(row-margin*2)*(float)(col-margin*2);
  for(i=0;i<256;i++) d[i] /= total;
}
*/

/******************************   fMax2d  ****************************/
/*  To get the maximum and the minimum of a 2_dimension float array  */
float fMax2d(float **a,int row,int col,int margin,float *minp)
{
  register int i,j;
  int start_i,end_i,start_j,end_j;
  float 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  *********************************/
float fGetSquareSum(float **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);
}

/************************  fGetZSquareSum  *********************************/
float fGetZSquareSum(float **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);
}

/****************************   fAverage  *******************************/
/*  To get the average of a 2_dimension float array  */
float fAverage(float **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-margin*2)*(float)(col-margin*2)));
}

/*****************************  fDeviation   ****************************/
/*  To get the deviation of a 2_dimension float array  */
float fDeviation(float **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 += a[i][j] * a[i][j];

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

/*************************  fProbability   ****************************/
/*  To get the pobability of a 2_dimension float array  */
/*  Seldom Used  */
void fProbability(float **a,int row,int col,float *d,float min,float ratio,
                  int margin)
{
  register i,j;
  int start_i,end_i,start_j,end_j;
  float 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)(ratio*(a[i][j]-min))] += 1.0;

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


void Sobel(unsigned char **a,int YStart,int XStart,int row,int col,float **e,
           float **d,int SobelMode)
{
  register int i,j;
  int row2,col2,sum1,sum2;
  double x,y;

  row2 = row-2;
  col2 = col-2;
  for(i=YStart+1;i<=YStart+row2;i++)
    for(j=XStart+1;j<=XStart+col2;j++) {
      sum1 = (int)a[i+1][j-1]+2*(int)a[i+1][j]+(int)a[i+1][j+1];
      sum2 = (int)a[i-1][j-1]+2*(int)a[i-1][j]+(int)a[i-1][j+1];
      y=(double)(sum1-sum2);
      sum1 = (int)a[i-1][j+1]+2*(int)a[i][j+1]+(int)a[i+1][j+1];
      sum2 = (int)a[i-1][j-1]+2*(int)a[i][j-1]+(int)a[i+1][j-1];
      x = (double)(sum1-sum2);

      /* get the magnitude of the grade image */
      e[i-YStart][j-XStart] = (float)sqrt(x*x+y*y);

      /* get the direction of the grade image */
      if (SobelMode==GETDIRECTION)
      {
        float pid = 180.0/3.14;

        if ((x==0.0) && (y==0.0))
          d[i-YStart][j-XStart] = 720.0;
        else
          d[i-YStart][j-XStart] = (float)atan2(y,x)*pid;
      }
    }
}


/**************************  NORMALIZEGRAYLEVEL  ***********************/
/* Normalize the graylevel of image Image                              */
/* Normalize definition is :                                           */
/*   Image[i][j] = (Image[i][j]-IMin)/(IMax-IMin)*(Max-Min)+Min        */
float **NormalizeGraylevel(unsigned char **Image,int Row,int Col,int Min,int Max)
{
  int   i,j,IMax,IMin;
  float **NormalizedImage;

  NormalizedImage = (float **)fspace_2d(Row,Col,sizeof(float));

  IMax = ucMax2d(Image,Row,Col,0,&IMin);

  for(i=0;i<Row;i++)
    for(j=0;j<Col;j++)
      NormalizedImage[i][j] = (float)(Image[i][j]-IMin) / (IMax-IMin) * (Max-Min) + Min;

  return(NormalizedImage);
}

/**************************  NORMALIZEFLOAT  ***************************/
/* Normalize the float array                                           */
/* Normalize definition is :                                           */
/*   Image[i][j] = (Float[i][j]-IMin)/(IMax-IMin)*(Max-Min)+Min        */
unsigned char **NormalizeFloat(float **Float,int Row,int Col,int Min,int Max,
                               int Margin)
{
  int           i,j;
  unsigned char **NormalizedImage;
  float         FMax,FMin;

  NormalizedImage = (unsigned char **)fspace_2d(Row,Col,sizeof(unsigned char));

  FMax = fMax2d(Float,Row,Col,Margin,&FMin);

  for(i=Margin;i<Row-Margin;i++)
    for(j=Margin;j<Col-Margin;j++)
      NormalizedImage[i][j] =(unsigned char) ( (Float[i][j]-FMin) / (FMax-FMin) * (Max-Min) + Min );

  return(NormalizedImage);
}

/***********************  CONTRASTENHANCEMENT  ***************************/
/*  Non linear contrast enhancement                                      */
unsigned char **ContrastEnhancement(unsigned char **Image,int Row,int Col,
                                    int Eb)
{
  unsigned char **EnhancementImage;
  int           i,j,Tem;

  EnhancementImage = (unsigned char **)fspace_2d(Row,Col,sizeof(unsigned char));

  for(i=0;i<Row;i++)
    for(j=0;j<Col;j++)
    {
      Tem = Image[i][j] - Eb;

      if (Tem<0)
        EnhancementImage[i][j] = 0;
      else if (Tem<15)
        EnhancementImage[i][j] = Tem * Tem;
      else
        EnhancementImage[i][j] = 255;
    }

  return(EnhancementImage);
}

/****************************  GRAYTRANS  ********************************/
/*  Get non linear graylevel transform palette                           */
void GrayTrans(int *GrayTransMask,unsigned char *Palette,int Current,
               int Lower,int Upper)
{
  int           i;

  for(i=Lower;i<=Current;i++)
    Palette[i] = (float)(i - Lower)
                   * (GrayTransMask[Current] - GrayTransMask[Lower])
                   / (Current - Lower)
                   + GrayTransMask[Lower] + 0.5;
  for(i=Current;i<=Upper;i++)
    Palette[i] = (float)(i - Current)
                   * (GrayTransMask[Upper] - GrayTransMask[Current])
                   / (Upper - Current)
                   + GrayTransMask[Current] + 0.5;
}