tesseract/wordrec/seam.cpp

/* -*-C-*-
 ********************************************************************************
 *
 * File:        seam.c  (Formerly seam.c)
 * Description:
 * Author:       Mark Seaman, OCR Technology
 * Created:      Fri Oct 16 14:37:00 1987
 * Modified:     Fri May 17 16:30:13 1991 (Mark Seaman) marks@hpgrlt
 * Language:     C
 * Package:      N/A
 * Status:       Reusable Software Component
 *
 * (c) Copyright 1987, Hewlett-Packard Company.
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 ** http://www.apache.org/licenses/LICENSE-2.0
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 *
 *********************************************************************************/
/*----------------------------------------------------------------------
              I n c l u d e s
----------------------------------------------------------------------*/
#include "seam.h"
#include "callcpp.h"
#include "structures.h"
#include "makechop.h"

#ifdef __UNIX__
#include <assert.h>
#endif

/*----------------------------------------------------------------------
              V a r i a b l e s
----------------------------------------------------------------------*/
#define NUM_STARTING_SEAMS  20

#define SEAMBLOCK 100            /* Cells per block */
makestructure (newseam, free_seam, printseam, SEAM,
freeseam, SEAMBLOCK, "SEAM", seamcount);

/*----------------------------------------------------------------------
        Public Function Code
----------------------------------------------------------------------*/
/**********************************************************************
 * point_in_split
 *
 * Check to see if either of these points are present in the current
 * split.  Return TRUE if one of them is.
 **********************************************************************/
bool point_in_split(SPLIT *split, EDGEPT *point1, EDGEPT *point2) {
  return ((split) ?
    ((exact_point (split->point1, point1) ||
    exact_point (split->point1, point2) ||
    exact_point (split->point2, point1) ||
    exact_point (split->point2, point2)) ? TRUE : FALSE) : FALSE);
}


/**********************************************************************
 * point_in_seam
 *
 * Check to see if either of these points are present in the current
 * seam.  Return TRUE if one of them is.
 **********************************************************************/
bool point_in_seam(SEAM *seam, SPLIT *split) {
  return (point_in_split (seam->split1, split->point1, split->point2) ||
    point_in_split (seam->split2, split->point1, split->point2) ||
    point_in_split (seam->split3, split->point1, split->point2));
}


/**********************************************************************
 * add_seam
 *
 * Add another seam to a collection of seams.
 **********************************************************************/
SEAMS add_seam(SEAMS seam_list, SEAM *seam) {
  return (array_push (seam_list, seam));
}


/**********************************************************************
 * combine_seam
 *
 * Combine two seam records into a single seam.  Move the split
 * references from the second seam to the first one.  The argument
 * convention is patterned after strcpy.
 **********************************************************************/
void combine_seams(SEAM *dest_seam, SEAM *source_seam) {
  dest_seam->priority += source_seam->priority;
  dest_seam->location += source_seam->location;
  dest_seam->location /= 2;

  if (source_seam->split1) {
    if (!dest_seam->split1)
      dest_seam->split1 = source_seam->split1;
    else if (!dest_seam->split2)
      dest_seam->split2 = source_seam->split1;
    else if (!dest_seam->split3)
      dest_seam->split3 = source_seam->split1;
    else
      cprintf ("combine_seam: Seam is too crowded, can't be combined !\n");
  }
  if (source_seam->split2) {
    if (!dest_seam->split2)
      dest_seam->split2 = source_seam->split2;
    else if (!dest_seam->split3)
      dest_seam->split3 = source_seam->split2;
    else
      cprintf ("combine_seam: Seam is too crowded, can't be combined !\n");
  }
  if (source_seam->split3) {
    if (!dest_seam->split3)
      dest_seam->split3 = source_seam->split3;
    else
      cprintf ("combine_seam: Seam is too crowded, can't be combined !\n");
  }
  free_seam(source_seam);
}


/**********************************************************************
 * delete_seam
 *
 * Free this seam record and the splits that are attached to it.
 **********************************************************************/
void delete_seam(void *arg) {  //SEAM  *seam)
  SEAM *seam = (SEAM *) arg;

  if (seam) {
    if (seam->split1)
      delete_split (seam->split1);
    if (seam->split2)
      delete_split (seam->split2);
    if (seam->split3)
      delete_split (seam->split3);
    free_seam(seam);
  }
}


/**********************************************************************
 * free_seam_list
 *
 * Free all the seams that have been allocated in this list.  Reclaim
 * the memory for each of the splits as well.
 **********************************************************************/
void free_seam_list(SEAMS seam_list) {
  int x;

  array_loop (seam_list, x) delete_seam (array_value (seam_list, x));
  array_free(seam_list);
}


/**********************************************************************
 * test_insert_seam
 *
 * Return true if insert_seam will succeed.
 **********************************************************************/
bool test_insert_seam(SEAMS seam_list,
                      int index,
                      TBLOB *left_blob,
                      TBLOB *first_blob) {
  SEAM *test_seam;
  TBLOB *blob;
  int test_index;
  int list_length;

  list_length = array_count (seam_list);
  for (test_index = 0, blob = first_blob->next;
  test_index < index; test_index++, blob = blob->next) {
    test_seam = (SEAM *) array_value (seam_list, test_index);
    if (test_index + test_seam->widthp < index &&
        test_seam->widthp + test_index == index - 1 &&
        account_splits_right(test_seam, blob) < 0)
      return false;
  }
  for (test_index = index, blob = left_blob->next;
  test_index < list_length; test_index++, blob = blob->next) {
    test_seam = (SEAM *) array_value (seam_list, test_index);
    if (test_index - test_seam->widthn >= index &&
        test_index - test_seam->widthn == index &&
        account_splits_left(test_seam, first_blob, blob) < 0)
      return false;
  }
  return true;
}

/**********************************************************************
 * insert_seam
 *
 * Add another seam to a collection of seams at a particular location
 * in the seam array.
 **********************************************************************/
SEAMS insert_seam(SEAMS seam_list,
                  int index,
                  SEAM *seam,
                  TBLOB *left_blob,
                  TBLOB *first_blob) {
  SEAM *test_seam;
  TBLOB *blob;
  int test_index;
  int list_length;

  list_length = array_count (seam_list);
  for (test_index = 0, blob = first_blob->next;
  test_index < index; test_index++, blob = blob->next) {
    test_seam = (SEAM *) array_value (seam_list, test_index);
    if (test_index + test_seam->widthp >= index) {
      test_seam->widthp++;       /*got in the way */
    }
    else if (test_seam->widthp + test_index == index - 1) {
      test_seam->widthp = account_splits_right(test_seam, blob);
      if (test_seam->widthp < 0) {
        cprintf ("Failed to find any right blob for a split!\n");
        print_seam("New dud seam", seam);
        print_seam("Failed seam", test_seam);
      }
    }
  }
  for (test_index = index, blob = left_blob->next;
  test_index < list_length; test_index++, blob = blob->next) {
    test_seam = (SEAM *) array_value (seam_list, test_index);
    if (test_index - test_seam->widthn < index) {
      test_seam->widthn++;       /*got in the way */
    }
    else if (test_index - test_seam->widthn == index) {
      test_seam->widthn = account_splits_left(test_seam, first_blob, blob);
      if (test_seam->widthn < 0) {
        cprintf ("Failed to find any left blob for a split!\n");
        print_seam("New dud seam", seam);
        print_seam("Failed seam", test_seam);
      }
    }
  }
  return (array_insert (seam_list, index, seam));
}


/**********************************************************************
 * account_splits_right
 *
 * Account for all the splits by looking to the right.
 * in the blob list.
 **********************************************************************/
int account_splits_right(SEAM *seam, TBLOB *blob) {
  inT8 found_em[3];
  inT8 width;

  found_em[0] = seam->split1 == NULL;
  found_em[1] = seam->split2 == NULL;
  found_em[2] = seam->split3 == NULL;
  if (found_em[0] && found_em[1] && found_em[2])
    return 0;
  width = 0;
  do {
    if (!found_em[0])
      found_em[0] = find_split_in_blob (seam->split1, blob);
    if (!found_em[1])
      found_em[1] = find_split_in_blob (seam->split2, blob);
    if (!found_em[2])
      found_em[2] = find_split_in_blob (seam->split3, blob);
    if (found_em[0] && found_em[1] && found_em[2]) {
      return width;
    }
    width++;
    blob = blob->next;
  }
  while (blob != NULL);
  return -1;
}


/**********************************************************************
 * account_splits_left
 *
 * Account for all the splits by looking to the left.
 * in the blob list.
 **********************************************************************/
int account_splits_left(SEAM *seam, TBLOB *blob, TBLOB *end_blob) {
  static inT32 depth = 0;
  static inT8 width;
  static inT8 found_em[3];

  if (blob != end_blob) {
    depth++;
    account_splits_left (seam, blob->next, end_blob);
    depth--;
  }
  else {
    found_em[0] = seam->split1 == NULL;
    found_em[1] = seam->split2 == NULL;
    found_em[2] = seam->split3 == NULL;
    width = 0;
  }
  if (!found_em[0])
    found_em[0] = find_split_in_blob (seam->split1, blob);
  if (!found_em[1])
    found_em[1] = find_split_in_blob (seam->split2, blob);
  if (!found_em[2])
    found_em[2] = find_split_in_blob (seam->split3, blob);
  if (!found_em[0] || !found_em[1] || !found_em[2]) {
    width++;
    if (depth == 0) {
      width = -1;
    }
  }
  return width;
}


/**********************************************************************
 * find_split_in_blob
 *
 * Return TRUE if the split is somewhere in this blob.
 **********************************************************************/
bool find_split_in_blob(SPLIT *split, TBLOB *blob) {
  TESSLINE *outline;

#if 0
  for (outline = blob->outlines; outline != NULL; outline = outline->next)
    if (is_split_outline (outline, split))
      return TRUE;
  return FALSE;
#endif
  for (outline = blob->outlines; outline != NULL; outline = outline->next)
    if (point_in_outline(split->point1, outline))
      break;
  if (outline == NULL)
    return FALSE;
  for (outline = blob->outlines; outline != NULL; outline = outline->next)
    if (point_in_outline(split->point2, outline))
      return TRUE;
  return FALSE;
}


/**********************************************************************
 * join_two_seams
 *
 * Merge these two seams into a new seam.  Duplicate the split records
 * in both of the input seams.  Return the resultant seam.
 **********************************************************************/
SEAM *join_two_seams(SEAM *seam1, SEAM *seam2) {
  SEAM *result = NULL;
  SEAM *temp;

  assert(seam1 &&seam2);

  if (((seam1->split3 == NULL && seam2->split2 == NULL) ||
    (seam1->split2 == NULL && seam2->split3 == NULL) ||
    seam1->split1 == NULL ||
  seam2->split1 == NULL) && (!shared_split_points (seam1, seam2))) {
    clone_seam(result, seam1);
    clone_seam(temp, seam2);
    combine_seams(result, temp);
  }
  return (result);
}


/**********************************************************************
 * new_seam
 *
 * Create a structure for a "seam" between two blobs.  This data
 * structure may actually hold up to three different splits.
 * Initailization of this record is done by this routine.
 **********************************************************************/
SEAM *new_seam(PRIORITY priority,
               int x_location,
               SPLIT *split1,
               SPLIT *split2,
               SPLIT *split3) {
  SEAM *seam;

  seam = newseam ();

  seam->priority = priority;
  seam->location = x_location;
  seam->widthp = 0;
  seam->widthn = 0;
  seam->split1 = split1;
  seam->split2 = split2;
  seam->split3 = split3;

  return (seam);
}


/**********************************************************************
 * new_seam_list
 *
 * Create a collection of seam records in an array.
 **********************************************************************/
SEAMS new_seam_list() {
  return (array_new (NUM_STARTING_SEAMS));
}


/**********************************************************************
 * print_seam
 *
 * Print a list of splits.  Show the coordinates of both points in
 * each split.
 **********************************************************************/
void print_seam(const char *label, SEAM *seam) {
  if (seam) {
    cprintf(label);
    cprintf (" %6.2f @ %5d, p=%d, n=%d ",
      seam->priority, seam->location, seam->widthp, seam->widthn);

    print_split (seam->split1);

    if (seam->split2) {
      cprintf (",   ");
      print_split (seam->split2);

      if (seam->split3) {
        cprintf (",   ");
        print_split (seam->split3);
      }
    }
    cprintf ("\n");
  }
}


/**********************************************************************
 * print_seams
 *
 * Print a list of splits.  Show the coordinates of both points in
 * each split.
 **********************************************************************/
void print_seams(const char *label, SEAMS seams) {
  int x;
  char number[CHARS_PER_LINE];

  if (seams) {
    cprintf ("%s\n", label);
    array_loop(seams, x) {
      sprintf (number, "%2d:   ", x);
      print_seam (number, (SEAM *) array_value (seams, x));
    }
    cprintf ("\n");
  }
}


/**********************************************************************
 * shared_split_points
 *
 * Check these two seams to make sure that neither of them have two
 * points in common. Return TRUE if any of the same points are present
 * in any of the splits of both seams.
 **********************************************************************/
int shared_split_points(SEAM *seam1, SEAM *seam2) {
  if (seam1 == NULL || seam2 == NULL)
    return (FALSE);

  if (seam2->split1 == NULL)
    return (FALSE);
  if (point_in_seam (seam1, seam2->split1))
    return (TRUE);

  if (seam2->split2 == NULL)
    return (FALSE);
  if (point_in_seam (seam1, seam2->split2))
    return (TRUE);

  if (seam2->split3 == NULL)
    return (FALSE);
  if (point_in_seam (seam1, seam2->split3))
    return (TRUE);

  return (FALSE);
}