segments.c

This is code tutorial for image processing include:histogram,sketon....

                        &stack_empty,
                        &pointer, pop_i,
                        pop_j, value,
                        &stack_file_in_use,
                        &first_call);
         }  /* ends while stack_empty == 0 */

         if(object_found == 1){
            object_found = 0;
            ++g_label;
         }  /* ends if object_found == 1 */

      }   /* ends loop over j */
   }  /* ends loop over i */

   printf("\nGROW> found %d objects", g_label);

} /* ends grow  */





   /********************************************
   *
   *  label_and_check_neighbors(...
   *
   *  This function labels a pixel with an object
   *  label and then checks the pixel's 8
   *  neighbors.  If any of the neigbors are
   *  set, then they are also labeled.
   *
   ***********************************************/

label_and_check_neighbor(binary_image, stack,
                         g_label, stack_empty,
                         pointer, r, e, value,
                         stack_file_in_use,
                         first_call)
int   e,
      *first_call,
      *pointer,
      r,
      *stack_empty,
      *stack_file_in_use;

short binary_image[ROWS][COLS],
      g_label,
      stack[STACK_SIZE][2],
      value;
{
   int already_labeled = 0,
       i, j;

   if (binary_image[r][e] == g_label)
      already_labeled = 1;

   binary_image[r][e] = g_label;

      /***************************************
      *
      *   Look at the 8 neighors of the
      *   point r,e.
      *
      *   Ensure the points you are checking
      *   are in the image, i.e. not less
      *   than zero and not greater than
      *   ROWS-1 or COLS-1.
      *
      ***************************************/

   for(i=(r-1); i<=(r+1); i++){
      for(j=(e-1); j<=(e+1); j++){

         if((i>=0)   &&
            (i<=ROWS-1)  &&
            (j>=0)   &&
            (j<=COLS-1)){

            if(binary_image[i][j] == value){
               *pointer           = *pointer + 1;
               stack[*pointer][0] = i; /* PUSH      */
               stack[*pointer][1] = j; /* OPERATION */
               *stack_empty       = 0;

               if(*pointer >= (STACK_SIZE -
                               STACK_FILE_LENGTH)){
                  push_data_onto_stack_file(stack,
                            pointer, first_call);
                  *stack_file_in_use = 1;
               }  /* ends if *pointer >=
                     STACK_SIZE - STACK_FILE_LENGTH*/

            }  /* end of if binary_image == value */
         }  /* end if i and j are on the image */
      }  /* ends loop over i rows           */
   }  /* ends loop over j columns        */
}  /* ends label_and_check_neighbors  */





   /****************************************
   *
   *   push_data_onto_stack_file(...
   *
   *   This function takes the stack array
   *   and pushes it onto the stack file.
   *
   *****************************************/

push_data_onto_stack_file(stack, pointer, first_call)
   int   *first_call, *pointer;
   short stack[STACK_SIZE][2];
{
   char  backup_file_name[MAX_NAME_LENGTH];
   FILE  *backup_file_pointer, *stack_file_pointer;
   int   diff, i;
   short holder[STACK_FILE_LENGTH][2];

   printf("\nSFO> Start of push_data_onto_stack ");

   diff = STACK_SIZE - STACK_FILE_LENGTH;

       /*******************************************
       *
       *   Copy the elements to be stored to the
       *   stack file into holder
       *
       ********************************************/

   for(i=0; i<STACK_FILE_LENGTH; i++){
      holder[i][0] = stack[i][0];
      holder[i][1] = stack[i][1];
   }

       /*******************************************
       *
       *   Move the elements of the stack down
       *
       *******************************************/

   for(i=0; i<diff; i++){
      stack[i][0] = stack[i + STACK_FILE_LENGTH][0];
      stack[i][1] = stack[i + STACK_FILE_LENGTH][1];
   }

       /*******************************************
       *
       *   Fill the top of the stack with zeros
       *
       *******************************************/

   for(i=diff; i<STACK_SIZE; i++){
      stack[i][0] = 0;
      stack[i][1] = 0;
   }

   *pointer = *pointer - STACK_FILE_LENGTH;

   /************************************************
   *
   *   Store the holder array into the stack file.
   *   Open the stack file for writing in binary
   *   mode. If the file does not exist it will be
   *   created. If the file does exist it will be
   *   over written.
   *
   *   PUSH - IF first_time == 1 then write to stack
   *          ELSE write to stack.bak
   *          append stack onto stack.bak
   *          copy stack.bak to stack
   *          this has the effect of writing
   *          to the beginning of the stack.
   *
   ************************************************/

   if(*first_call == 1){

      *first_call = *first_call + 1;
      if((stack_file_pointer = fopen(STACK_FILE,"wb"))
                                     == NULL)
         printf("\nSFO> Could not open stack file");
      else{
         /*printf("\n\nSFO> Writing to stack file");*/
         fwrite(holder, sizeof(holder),
                1, stack_file_pointer);
         fclose(stack_file_pointer);
      }  /*  ends else could not open stack_file  */

   }  /*  ends if *first_call == 1  */
   else{  /* else stack file has been used already  */
      strcpy(backup_file_name, STACK_FILE);
      strcat(backup_file_name, ".bak");
      if((backup_file_pointer =
          fopen(backup_file_name, "wb")) == NULL)
         printf("\nSFO> Could not open backup file");
      else{
         /*printf("\n\nSFO> Writing to backup file");*/
         fwrite(holder, sizeof(holder),
                1, backup_file_pointer);
         fclose(backup_file_pointer);
      }  /*  ends else could not open backup_file  */

      append_stack_files(backup_file_name,
                         STACK_FILE, holder);
      copy_stack_files(backup_file_name,
                       STACK_FILE, holder);

   }  /*  ends else first_call != 1  */

   printf("--- End of push_data_onto_stack");

}  /* ends push_data_onto_stack_file  */





   /****************************************
   *
   *   pop_data_off_of_stack_file(...
   *
   *   This function pops the stack array
   *   off of the stack file.
   *
   *****************************************/

pop_data_off_of_stack_file(stack, pointer,
                           stack_file_in_use)
   int   *pointer, *stack_file_in_use;
   short stack[STACK_SIZE][2];
{
   char  backup_file_name[MAX_NAME_LENGTH];
   FILE  *backup_file_pointer, *stack_file_pointer;
   int   i;
   long  write_counter;
   short holder[STACK_FILE_LENGTH][2],
         holder2[STACK_FILE_LENGTH][2];

       /*******************************************
       *
       *   POP - Read 1 time from stack
       *         Copy the remainder of stack to
       *            stack.bak
       *         Copy stack.bak to stack
       *         This has the effect of popping off
       *         of the stack.
       *
       *   Read the holder array from the stack file.
       *   Open the stack file for reading in binary
       *   mode.
       *
       *   If it requires more than one write to
       *   copy the remainder of stack to
       *   stack.bak then there is still data in the
       *   stack file so set stack_file_in_use = 1.
       *   Else set it to 0.
       *
       **********************************************/

   printf("\nSFO> Start of pop_data_off_of_stack ");
   write_counter = 0;

   strcpy(backup_file_name, STACK_FILE);
   strcat(backup_file_name, ".bak");

   if( (stack_file_pointer =
          fopen(STACK_FILE, "rb")) == NULL)
      printf("\nSFO> Could not open stack file");
   else{
      /*printf("\n\nSFO> Reading from stack file");*/
      fread(holder, sizeof(holder),
            1, stack_file_pointer);

      backup_file_pointer =
            fopen(backup_file_name, "wb");
      while( fread(holder2, sizeof(holder2),
                   1, stack_file_pointer) ){
         fwrite(holder2, sizeof(holder2),
                1, backup_file_pointer);
         ++write_counter;
      }  /* ends while reading  */
      if(write_counter > 0)
         *stack_file_in_use = 1;
      else
         *stack_file_in_use = 0;

      fclose(backup_file_pointer);
      fclose(stack_file_pointer);
   }  /* ends else could not open stack file  */

   copy_stack_files(backup_file_name,
                    STACK_FILE, holder2);

   for(i=0; i<STACK_FILE_LENGTH; i++){
      stack[i][0] = holder[i][0];
      stack[i][1] = holder[i][1];
   }

   *pointer = *pointer + STACK_FILE_LENGTH - 1;

   printf("--- End of pop_data_off_of_stack");
}  /* ends pop_data_off_of_stack_file  */





   /*********************************************
   *
   *   append_stack_files(...
   *
   *   Append the second file onto the end
   *   of the first.
   *
   ***********************************************/

append_stack_files(first_file, second_file, holder)
   char first_file[], second_file[];
   short holder[STACK_FILE_LENGTH][2];
{
   FILE  *first, *second;
   int   i;

   if((first = fopen(first_file, "r+b")) == NULL)
      printf("\n\nSFO> Cannot open file %s",
             first_file);

   if((second = fopen(second_file, "rb")) == NULL)
      printf("\n\nSFO> Cannot open file %s",
             second_file);

          /*****************************************
          *
          *  Seek to the end of the first file and
          *  to the beginning of the second file.
          *
          *******************************************/

   fseek(first, 0L, 2);
   fseek(second, 0L, 0);

   while(fread(holder, sizeof(holder), 1, second) ){
      fwrite(holder, sizeof(holder), 1, first);
   }  /* ends while reading  */

   fclose(first);
   fclose(second);

}  /*  ends append_stack_files  */





   /********************************************
   *
   *   copy_stack_files(...
   *
   *   Copy the first file to the second.
   *
   **********************************************/

copy_stack_files(first_file, second_file, holder)
   char first_file[], second_file[];
   short holder[STACK_FILE_LENGTH][2];
{
   FILE  *first, *second;
   int   i;

   if( (first = fopen(first_file, "rb")) == NULL)
      printf("\n\nSFO> Cannot open file %s",
             first_file);

   if( (second = fopen(second_file, "wb")) == NULL)
      printf("\n\nSFO> Cannot open file %s",
             second_file);

          /******************************************
          *
          *  Seek to the beginning of the first file.
          *
          *******************************************/

   fseek(first, 0L, 0);

   while( fread(holder, sizeof(holder), 1, first) ){
      fwrite(holder, sizeof(holder), 1, second);
   }  /* ends while reading  */

   fclose(first);
   fclose(second);

}  /*  ends copy_stack_files */




   /********************************************
   *
   *   find_peaks(...
   *
   *   This function looks through the histogram
   *   array and finds the two highest peaks.
   *   The peaks must be separated, cannot be
   *   next to each other, by a spacing defined
   *   in cips.h.
   *
   *   The peaks array holds the peak value
   *   in the first place and its location in
   *   the second place.
   *
   *********************************************/

find_peaks(histogram, peak1, peak2)
   unsigned long histogram[];
   int *peak1, *peak2;
{
   int distance[PEAKS], peaks[PEAKS][2];
   int i, j=0, max=0, max_place=0;

   for(i=0; i<PEAKS; i++){
      distance[i] =  0;
      peaks[i][0] = -1;
      peaks[i][1] = -1;
   }

   for(i=0; i<=GRAY_LEVELS; i++){
      max       = histogram[i];
      max_place = i;
      insert_into_peaks(peaks, max, max_place);
   }  /* ends loop over i */

   for(i=1; i<PEAKS; i++){
      distance[i] = peaks[0][1] - peaks[i][1];
      if(distance[i] < 0)
         distance[i] = distance[i]*(-1);
   }

   *peak1 = peaks[0][1];
   for(i=PEAKS-1; i>0; i--)