Listing 2 Two edge detectors, the variance and range operators

   /**************************************************
   *
   *   variance(...
   *
   *   This function replaces the pixel in the center
   *   of a 3x3 area with the square root of the
   *   sum of squares of the differences between
   *   the center pixel and its eight neighbors.
   *
   **************************************************/

variance(in_name, out_name, the_image, out_image,
        il, ie, ll, le, threshold, high)
   char   in_name[], out_name[];
   int    il, ie, ll, le, high, threshold;
   short  the_image[ROWS][COLS],
         out_image[ROWS][COLS];
{
   int a, b, diff, i, j, length,
       max, new_hi, new_low, width;
   long sum = 0;

   struct tiff_header_struct image_header;

   if(does_not_exist(out_name)){
      printf("\n\noutput file does not exist %s",
            out_name);
      read_tiff_header(in_name, &image_header);
      round_off_image_size(&image_header,
                        &length, &width);
      image_header.image_length = length*ROWS;
      image_header.image_width  = width*COLS;
      create_allocate_tiff_file(out_name, &image_header,
                            out_image);
   }  /* ends if doe_ not_exist */

   read_tiff_header(in_name, &image_header);

   new_hi  = 250;
   new_low = 16;
   if(image_header.bits_per_pixel == 4){
       new_hi  = 10;
       new_low = 3;
   }
   max = 255;
   if(image_header.bits_per_pixel == 4)
      max = 16;

   read_tiff_image(in_name, the_image, il, ie, ll, le);

   for(i=1; i<ROWS-1; i++){
      if( (i%10) == 0) printf("%3d", i);
      for(j=1; j<COLS-1; j++){
         sum = 0;
         for(a=-1; a<=1; a++){
             for(b=-1; b<=1; b++){
                if( a!=0 && b!=0){
                 diff = 0;
                 diff = the_image[i][j] -
                       the_image[i+a][j+b];
                 diff = diff*diff;
                 sum  = sum + diff;
                }
             }
         }
         sum = sqrt(sum);
         if(sum > max) sum = max;
         out_image[i][j] = sum;
      }  /* ends loop over j */
   }  /* ends loop over i */

      /* if desired, threshold the output image */
   if(threshold == 1){
      for(i=0; i<ROWS; i++){
         for(j=0; j<COLS; j++){
            if(out_image[i][j] > high){
                out_image[i][j] = new_hi;
            }
            else{
                out_image[i][j] = new_low;
            }
         }
      }
   }  /* ends if threshold == 1 */

   fix_edges(out_image, 1);
   write_array_into_tiff_image(out_name, out_image,
                          il, ie, ll, le);

} /* ends variance */

    /*******************************************
    *
    *   range(..
    *
    *   This edge detector performs the
    *   range operation.
    *   It replaces the pixel at the center of a
    *   3x3, 5x5, etc. area with the max - min
    *   for that area.
    *
    *******************************************/

range(in_name, out_name, the_image, out_image,
     il, ie, ll, le, size, threshold, high)
   char   in_name[], out_name[];
   int    il, ie, ll, le,
         high, threshold, size;
   short  the_image[ROWS][COLS],
         out_image[ROWS][COLS];

{
   int    a, b, count, i, j, k,
         new_hi, new_low, length,
         sd2, sd2p1, ss, width;
   short  *elements;
   struct tiff_header_struct image_header;

   sd2   = size/2;
   sd2p1 = sd2 + 1;

      /**********************************************
      *
      *   Allocate the elements array large enough
      *   to hold size*size shorts.
      *
      ***********************************************/

   ss       = size*size;
   elements = (short *) malloc(ss * sizeof(short));
   if(does_not_exist(out_name)){
      printf("\n\n output file does not exist %s",
            out_name);
      read_tiff_header(in_name, &image_header);
      round off_image_size(&image_header,
                        &length, &width);
      image_header.image_length = length*ROWS;
      image_header.image_width  = width*COLS;
      create_allocate_tiff_file(out_name,
                            &image_header,
                            out_image);
   }  /* ends if does_not_exist */

   read_tiff_image(in_name, the_image, il, ie, ll, le);

   new_hi  = 250;
   new_low = 16;
   if(image_header.bits_per_pixel == 4){
       new_hi  = 10;
       new_low = 3;
   }

      /***************************
      *
      *   Loop over image array
      *
      ****************************/

   printf("\n");
   for(i=sd2; i<ROWS-sd2; i++){
      if( (i%10) == 0) printf("%d ", i);
      for(j=sd2; j<COLS-sd2; j++){
         count = 0;
         for(a=-sd2; a<sd2p1; a++){
            for (b=-sd2; b<sd2p1; b++){
               elements[count] = the_image[i+a][j+b];
               count++;
            }
         }
         sort_elements(elements, &ss);
         out_image[i][j] = elements[ss-1]-elements[0];
      }  /* ends loop over j */
   }   /* ends loop over i */

     /* if desired, threshold the output image */
   if(threshold == 1){
      for(i=0; i<ROWS; i++){
         for(j=0; j<COLS; j++){
            if(out_image[i][j] > high){
                 out_image[i][j] = new_hi;
            }
            else{
                 out_image[i][j] = new_low;
            }
         }
      }
   }  /* ends if threshold == 1 */

   fix_edges(out_image, sd2);

   write_array_into_tiff_image(out_name, out_image,
                          il, ie, ll, le);

   free(elements);

}  /* ends range */

/* End of File */