image_functions.c

LastWave

  /* If n == 1 we are done ! */
  if (f1 == 1) {
    *pNthMoment = m;
    return(m);
  }
  
  /* Compute the Nth moment */
  mn = 0;
  for (i = 0;i<image->nrow*image->ncol;i++) {
    mn += pow(fabs(image->pixels[i]-m),f1);
  }
  mn /= image->nrow*image->ncol;
  *pNthMoment = mn;
  
  return(m);
}

/* Get Lp Norm */
LWFLOAT GetLpNormImage(IMAGE im, LWFLOAT p)
{
  int i;
  LWFLOAT lp;
       
  /* Compute the Lp Norm */
  lp = 0;
  for (i = 0;i<=im->nrow*im->ncol;i++) {
    lp += pow(fabs(im->pixels[i]),p);
  }
  lp = pow(lp,1.0/p);

  return(lp);
}
/*
 * Command for computing some statistical values of an image
 */
 
void C_StatsImage(char **argv)
{
  char *action;
  IMAGE image;
  LWFLOAT f,m,min,max,f1,p;
  int iMin,iMax,jMin,jMax;
  LISTV lv;
  int flagAbs,flagCentered;
  char opt;


  argv = ParseArgv(argv,tWORD,&action,-1);

  /* 'mean' action */
  if (!strcmp(action,"mean")) {
    argv = ParseArgv(argv,tIMAGEI,&image,0);
    GetNthMomentImage(image,1,&f,NO);
    SetResultFloat(f);
  }

  /* 'var' action */
  else if (!strcmp(action,"var")) {
    argv = ParseArgv(argv,tIMAGEI,&image,0);
    GetNthMomentImage(image,2,&f,YES);
    SetResultFloat(f);
  }

  /* 'skew' action */
  else if (!strcmp(action,"skew")) {
    argv = ParseArgv(argv,tIMAGEI,&image,0);
    GetNthMomentImage(image,3,&f,YES);
    SetResultFloat(f);
  }

  /* 'kurt' action */
  else if (!strcmp(action,"kurt")) {
    argv = ParseArgv(argv,tIMAGEI,&image,0);
    GetNthMomentImage(image,4,&f,YES);
    SetResultFloat(f);
  }

  /* 'nth' action */
  else if (!strcmp(action,"nth")) {
    argv = ParseArgv(argv,tIMAGEI,&image,tFLOAT,&f1,-1);
    flagAbs = NO;
    flagCentered = NO;
    while(opt = ParseOption(&argv)) { 
      switch(opt) {
        case 'a': flagAbs = YES; break;
        case 'C': flagCentered = YES; break;
        default: ErrorOption(opt);
      }
    }    
    NoMoreArgs(argv);
   if (!flagAbs) {
     if (f1 != (int) f1 || f1 < 0) Errorf("<n> should be a positive integer unless you set option '-a'");
     m = GetNthMomentImage(image,(int) f1,&f,flagCentered);
   }
   else m = GetAbsMomentImage(image,f1,&f,flagCentered);
   SetResultFloat(f);
  }
    
  /* 'minmax' action */
  else if (!strcmp(action,"minmax")) {
    argv = ParseArgv(argv,tIMAGEI,&image,0);
    MinMaxImage(image,&jMin,&iMin,&min,&jMax,&iMax,&max);
    lv = TNewListv();
    AppendInt2Listv(lv,iMin);
    AppendInt2Listv(lv,jMin);
    AppendInt2Listv(lv,iMax);
    AppendInt2Listv(lv,jMax);
    SetResultValue(lv);
  }

  /* 'lp' action */
  else if (!strcmp(action,"lp")) {
    argv = ParseArgv(argv,tIMAGEI,&image,tFLOAT,&p,0);
    f = GetLpNormImage(image,p);
    SetResultFloat(f);
  }
  
  /* 'print' action */
  else if (!strcmp(action,"print")) {
    argv = ParseArgv(argv,tIMAGEI,&image,0);
    m = GetLpNormImage(image,2);
    Printf("L2 norm   : %.8g\n",m);
    m = GetNthMomentImage(image,2,&f,YES);
    Printf("Mean      : %.8g\n",m);
    Printf("Variance  : %.8g\n",f);
    m = GetNthMomentImage(image,3,&f,YES);
    Printf("Skewness  : %.8g\n",f);
    m = GetNthMomentImage(image,4,&f,YES);
    Printf("Kurtosis  : %.8g\n",f);
    MinMaxImage(image,&jMin,&iMin,&min,&jMax,&iMax,&max);
    Printf("Minimum at %dx%d is %.8g\n",iMin,jMin,min); 
    Printf("Maximum at %dx%d is %.8g\n",iMax,jMax,max); 
  }

  else Errorf("Unknow action '%s'",action);    	
}




/*
 * Gets a horizontal or vertical cut of an image 
 */
void ImageGetCut ( IMAGE image,SIGNAL signal, char direction, int index)
{ 
  int i;
 
  if (direction=='H')
  {
    SizeSignal(signal,image->ncol,YSIG);
    for (i=0;i<image->ncol;i++)
     signal->Y[i] = image->pixels[image->ncol * index +i];    
    return;
  }    
    
  if (direction=='V')
  {
     SizeSignal(signal,image->nrow,YSIG);
     for (i=0;i<image->nrow;i++)
       signal->Y[i] = image->pixels[image->ncol * i +index];
    return;
  }    
  
  Errorf("ImageGetCut() : Bad direction '%c'",direction);
}


/*
 * Sets a horizontal or vertical cut of an image 
 */
void ImageSetCut (IMAGE image,SIGNAL signal, char direction, int index)
{ 
  int i;
 
  if (direction=='H')
  { 
    if (signal->size < image->ncol) Errorf("ImageSetCut() : Signal is too short");
    for (i=0;i<image->ncol;i++)
    image->pixels[image->ncol * index +i] =  signal->Y[i] ;
    return;
  }    

 
    
  if (direction=='V')
  {
    if (signal->size < image->nrow) Errorf("ImageSetCut() : Signal is too short");
    for (i=0;i<image->nrow;i++)
     image->pixels[image->ncol * i +index] = signal->Y[i]  ;

    return;
  }    
  
  Errorf("ImageSetCut() : Bad direction '%c'",direction);
}

/*
 * Compute the scalar product of 2 images 
 */
double ImageScalarProduct(IMAGE image1,IMAGE image2)
{
  int i;
  int nrow = image1->nrow;
  int ncol = image1->ncol;
  LWFLOAT *values_image1, *values_image2;
  double sum;

  if ((nrow != image2->nrow) || (ncol != image2->ncol)) 
     Errorf ( "ImageScalarProduct() : Size of images are not equal \n");

  values_image1 = image1->pixels;
  values_image2 = image2->pixels;
  sum = 0;
  for (i = 0; i < nrow * ncol; i++) 
    sum += values_image1[i] * values_image2[i];

  return(sum);
}


/*
 * Threshold an image 
 */
void ThreshImage(IMAGE input,IMAGE output,int flagint,int flagMin,LWFLOAT min,int flagMax,LWFLOAT max)
{ 
    int nrow,ncol;
    LWFLOAT minim=255.0;
     LWFLOAT maxim=0.0;
    LWFLOAT coef;
    int i,size;
    LWFLOAT *invalues;
    LWFLOAT *outvalues;
 
    nrow = input->nrow;
     ncol = input->ncol;
     size=nrow*ncol;
      invalues = input->pixels;
    
     if ((nrow != output->nrow) | (ncol != output->ncol)) SizeImage(output, ncol, nrow);
     outvalues = output->pixels;
  
     for(i=0;i<size;i++) {   
       coef=invalues[i];
       if(coef>maxim) maxim=coef;
 	   if(coef<minim) minim=coef;
     }
    

     
     if (flagint) {
      if (flagMin) minim = (LWFLOAT)((int) min);
      if (flagMax) maxim = (LWFLOAT)((int) max);    
       for(i=0;i<size;i++) { 
         coef=invalues[i];
         if(coef>maxim) coef=maxim;
	     if(coef<minim) coef= minim;
	     outvalues[i]=(LWFLOAT)((int)coef);
       }
     }
     else {
      if (flagMin) minim =  min;
      if (flagMax) maxim =  max;    
       for(i=0;i<size;i++) { 
         coef=invalues[i];
         if(coef>maxim) coef = maxim;
         if(coef<minim) coef = minim;
	     outvalues[i] = coef;
       }
     }
}


/* The correspnding command */
void C_ThreshImage(char ** argv)

{
    IMAGE image;
    LWFLOAT min;
    LWFLOAT max;
    char *arg1,*arg2;
     char opt;
    int flagint,flagMin,flagMax;

    argv= ParseArgv (argv,tIMAGEI,&image,-1);

   argv = ParseArgv(argv,tSTR,&arg1,tSTR,&arg2,-1);
   if (!strcmp(arg1,"*")) flagMin = NO;
     else {
       flagMin = YES;
       ParseFloat(arg1,&min);
     }
     if (!strcmp(arg2,"*")) flagMax = NO;
     else {
       flagMax = YES;
       ParseFloat(arg2,&max);
     }
 
   
   flagint = NO;
    while(opt = ParseOption(&argv)) { 
   switch(opt) {
   case 'i': 
     flagint = YES;
    break;
   default:
     ErrorOption(opt);
     }
    }
 NoMoreArgs(argv);

   if (flagMin == NO && flagMax == NO) Errorf("You have to specify either the Min or the Max");
  
  ThreshImage(image,image,flagint,flagMin,min,flagMax,max);
}



/* The image command */
void C_Image (char **argv)
{
  IMAGE image;
  int i,j;
  LWFLOAT min,max;  
  char * fieldName;

   argv = ParseArgv(argv,tSTR,&fieldName,-1);

  if (!strcmp(fieldName,"invert")) {
     argv = ParseArgv(argv,tIMAGE,&image);
     MinMaxImage(image,NULL,NULL,&min,NULL,NULL,&max);
     for(i=0; i < image->nrow; i++)
       for (j=0; j < image->ncol; j++)
      	  image->pixels[i * image->ncol + j] =max - image->pixels[i * image->ncol + j];
  } 
  
  else { 
    Errorf("Bad action '%s'\n",fieldName); 
  }
}