wordrec/pieces.cpp File Reference

#include "pieces.h"
#include "plotseg.h"
#include "hideedge.h"
#include "wordclass.h"
#include "freelist.h"
#include "blobs.h"
#include "matchtab.h"

Go to the source code of this file.

Defines

• #define get_bounds_entry(array, index, top_left, bot_right)

  Get the value of the entry in an array of bounds elements.
  

• #define set_bounds_entry(array, index, top_left, bot_right)

  Set the value of the entry in an array of bounds elements.
  

Functions

• void bounds_of_piece (BOUNDS_LIST bounds, INT16 start, INT16 end, TPOINT *extreme_tl, TPOINT *extreme_br)

  Find the bounds of the piece that will be created by joining the requested collection of pieces together.
  

• void break_pieces (TBLOB *blobs, SEAMS seams, INT16 start, INT16 end)

  Break up the blobs in this chain so that they are all independent.
  

• CHOICES classify_piece (TBLOB *pieces, SEAMS seams, INT16 start, INT16 end, INT32 fx, STATE *this_state, STATE *best_state, INT32 pass, INT32 blob_index)

  Create a larger piece from a collection of smaller ones.
  

• CHOICES get_piece_rating (MATRIX ratings, TBLOB *blobs, SEAMS seams, INT16 start, INT16 end, INT32 fx, STATE *this_state, STATE *best_state, INT32 pass, INT32 blob_index)

  Check to see if this piece has already been classified.
  

• void hide_edge_pair (EDGEPT *pt1, EDGEPT *pt2)

  Change the edge points that are referenced by this seam to make them hidden edges.
  

• void hide_seam (SEAM *seam)

  Change the edge points that are referenced by this seam to make them hidden edges.
  

• void join_pieces (TBLOB *piece_blobs, SEAMS seams, INT16 start, INT16 end)

  Join a group of base level pieces into a single blob that can then be classified.
  

• BOUNDS_LIST record_blob_bounds (TBLOB *blobs)

  Set up and initialize an array that holds the bounds of a set of blobs.
  

• MATRIX record_piece_ratings (TBLOB *blobs)

  Save the choices for all the pieces that have been classified into a matrix that can be used to look them up later.
  

• void reveal_edge_pair (EDGEPT *pt1, EDGEPT *pt2)

  Change the edge points that are referenced by this seam to make them hidden edges.
  

• void reveal_seam (SEAM *seam)

  Change the edge points that are referenced by this seam to make them hidden edges.
  

---

Define Documentation

#define get_bounds_entry	(	array,
		index,
		top_left,
		bot_right		)

Value:

((top_left)  = (array)[index].topleft,                  \
(bot_right) = (array)[index].botright)                 \

Get the value of the entry in an array of bounds elements.

Definition at line 47 of file pieces.cpp.

Referenced by bounds_of_piece().

#define set_bounds_entry	(	array,
		index,
		top_left,
		bot_right		)

Value:

((array)[index].topleft  = (top_left),                  \
(array)[index].botright = (bot_right))                 \

Set the value of the entry in an array of bounds elements.

Definition at line 38 of file pieces.cpp.

Referenced by record_blob_bounds().

---

Function Documentation

void bounds_of_piece	(	BOUNDS_LIST	bounds,
		INT16	start,
		INT16	end,
		TPOINT *	extreme_tl,
		TPOINT *	extreme_br
	)

Find the bounds of the piece that will be created by joining the requested collection of pieces together.

Definition at line 224 of file pieces.cpp.

References get_bounds_entry, max, min, TPOINT::x, and TPOINT::y.

Referenced by record_piece_ratings().

                                         {
  TPOINT topleft;
  TPOINT botright;
  INT16 x;

  get_bounds_entry(bounds, start, *extreme_tl, *extreme_br); 

  for (x = start + 1; x <= end; x++) {
    get_bounds_entry(bounds, x, topleft, botright); 

    extreme_tl->x = min (topleft.x, extreme_tl->x);
    extreme_tl->y = max (topleft.y, extreme_tl->y);
    extreme_br->x = max (botright.x, extreme_br->x);
    extreme_br->y = min (botright.y, extreme_br->y);
  }
}

void break_pieces	(	TBLOB *	blobs,
		SEAMS	seams,
		INT16	start,
		INT16	end
	)

Break up the blobs in this chain so that they are all independent.

This operation should undo the affect of join_pieces.

Definition at line 61 of file pieces.cpp.

References array_value, blobstruct::next, olinestruct::next, NULL, blobstruct::outlines, and reveal_seam().

Referenced by classify_piece().

                                                                     { 
  TESSLINE *outline = blobs->outlines;
  TBLOB *next_blob;
  INT16 x;

  for (x = start; x < end; x++)
    reveal_seam ((SEAM *) array_value (seams, x));

  next_blob = blobs->next;

  while (outline && next_blob) {
    if (outline->next == next_blob->outlines) {
      outline->next = NULL;
      outline = next_blob->outlines;
      next_blob = next_blob->next;
    }
    else {
      outline = outline->next;
    }
  }
}

CHOICES classify_piece	(	TBLOB *	pieces,
		SEAMS	seams,
		INT16	start,
		INT16	end,
		INT32	fx,
		STATE *	this_state,
		STATE *	best_state,
		INT32	pass,
		INT32	blob_index
	)

Create a larger piece from a collection of smaller ones.

Classify it and return the results. Take the large piece apart to leave the collection of small pieces unmodified.

Definition at line 253 of file pieces.cpp.

References array_count, bin_to_chunks(), break_pieces(), classify_blob(), display_segmentation(), display_segmentations, join_pieces(), memfree(), blobstruct::next, NULL, segm_window, set_n_ones(), White, and window_wait().

Referenced by get_piece_rating().

                                         {
  STATE current_state;
  CHOICES choices;
  TBLOB *pblob;
  TBLOB *blob;
  TBLOB *nblob;
  INT16 x;
  SEARCH_STATE chunk_groups;

  set_n_ones (&current_state, array_count (seams));

  join_pieces(pieces, seams, start, end); 
  for (blob = pieces, pblob = NULL, x = 0; x < start; x++) {
    pblob = blob;
    blob = blob->next;
  }
  for (nblob = blob->next; x < end; x++)
    nblob = nblob->next;
  choices = classify_blob (pblob, blob, nblob, NULL, fx, "pieces:", White,
    this_state, best_state, pass, blob_index);

  break_pieces(blob, seams, start, end); 
#ifndef GRAPHICS_DISABLED
  if (display_segmentations > 2) {
    chunk_groups = bin_to_chunks (&current_state, array_count (seams));
    display_segmentation(pieces, chunk_groups); 
    window_wait(segm_window); 
    memfree(chunk_groups); 
  }
#endif

  return (choices);
}

CHOICES get_piece_rating	(	MATRIX	ratings,
		TBLOB *	blobs,
		SEAMS	seams,
		INT16	start,
		INT16	end,
		INT32	fx,
		STATE *	this_state,
		STATE *	best_state,
		INT32	pass,
		INT32	blob_index
	)

Check to see if this piece has already been classified.

If it has return that rating. Otherwise build the piece from the smaller pieces, classify it, store the rating for later, and take the piece apart again.

Definition at line 304 of file pieces.cpp.

References classify_piece(), matrix_get, matrix_put, NOT_CLASSIFIED, and ratings.

Referenced by evaluate_chunks().

                                           {
  CHOICES choices;

  choices = matrix_get (ratings, start, end);
  if (choices == NOT_CLASSIFIED) {
    choices =
      classify_piece(blobs,
                     seams,
                     start,
                     end,
                     fx,
                     this_state,
                     best_state,
                     pass,
                     blob_index);
    matrix_put(ratings, start, end, choices); 
  }
  return (choices);
}

void hide_edge_pair	(	EDGEPT *	pt1,
		EDGEPT *	pt2
	)

Change the edge points that are referenced by this seam to make them hidden edges.

Definition at line 142 of file pieces.cpp.

References exact_point, hide_edge, and edgeptstruct::next.

Referenced by hide_seam().

                                              { 
  EDGEPT *edgept;

  edgept = pt1;
  do {
    hide_edge(edgept); 
    edgept = edgept->next;
  }
  while (!exact_point (edgept, pt2) && edgept != pt1);
  if (edgept == pt1) {
    /*              cprintf("Hid entire outline at (%d,%d)!!\n",
       edgept->pos.x,edgept->pos.y);                                */
  }
  edgept = pt2;
  do {
    hide_edge(edgept); 
    edgept = edgept->next;
  }
  while (!exact_point (edgept, pt1) && edgept != pt2);
  if (edgept == pt2) {
    /*              cprintf("Hid entire outline at (%d,%d)!!\n",
       edgept->pos.x,edgept->pos.y);                                */
  }
}

void hide_seam

(

SEAM *

seam

)

Change the edge points that are referenced by this seam to make them hidden edges.

Definition at line 122 of file pieces.cpp.

References hide_edge_pair(), NULL, split_record::point1, split_record::point2, seam_record::split1, seam_record::split2, and seam_record::split3.

Referenced by join_pieces().

                           { 
  if (seam == NULL || seam->split1 == NULL)
    return;
  hide_edge_pair (seam->split1->point1, seam->split1->point2);

  if (seam->split2 == NULL)
    return;
  hide_edge_pair (seam->split2->point1, seam->split2->point2);

  if (seam->split3 == NULL)
    return;
  hide_edge_pair (seam->split3->point1, seam->split3->point2);
}

void join_pieces	(	TBLOB *	piece_blobs,
		SEAMS	seams,
		INT16	start,
		INT16	end
	)

Join a group of base level pieces into a single blob that can then be classified.

Definition at line 89 of file pieces.cpp.

References array_value, hide_seam(), blobstruct::next, olinestruct::next, blobstruct::outlines, seam_record::widthn, and seam_record::widthp.

Referenced by classify_piece(), and rebuild_current_state().

                                                                          { 
  TBLOB *next_blob;
  TBLOB *blob;
  INT16 x;
  TESSLINE *outline;
  SEAM *seam;

  for (x = 0, blob = piece_blobs; x < start; x++)
    blob = blob->next;
  next_blob = blob->next;
  outline = blob->outlines;
  if (!outline)
    return;

  while (x < end) {
    seam = (SEAM *) array_value (seams, x);
    if (x - seam->widthn >= start && x + seam->widthp < end)
      hide_seam(seam); 
    while (outline->next)
      outline = outline->next;
    outline->next = next_blob->outlines;
    next_blob = next_blob->next;

    x++;
  }
}

BOUNDS_LIST record_blob_bounds

(

TBLOB *

blobs

)

Set up and initialize an array that holds the bounds of a set of blobs.

Definition at line 339 of file pieces.cpp.

References blob_bounding_box(), count_blobs(), iterate_blobs, memalloc(), and set_bounds_entry.

Referenced by record_piece_ratings().

                                             { 
  TBLOB *blob;
  BOUNDS_LIST bounds;
  TPOINT topleft;
  TPOINT botright;
  INT16 x = 0;

  bounds = (BOUNDS_LIST) memalloc (count_blobs (blobs) * sizeof (BOUNDS));

  iterate_blobs(blob, blobs) { 
    blob_bounding_box(blob, &topleft, &botright); 
    set_bounds_entry(bounds, x, topleft, botright); 
    x++;
  }
  return (bounds);
}

MATRIX record_piece_ratings

(

TBLOB *

blobs

)

Save the choices for all the pieces that have been classified into a matrix that can be used to look them up later.

A two dimensional matrix is created. The indices correspond to the starting and ending initial piece number.

Definition at line 365 of file pieces.cpp.

References bounds_of_piece(), count_blobs(), create_matrix(), get_match_by_bounds(), matrix_put, memfree(), NIL, ratings, and record_blob_bounds().

Referenced by word_associator().

                                          { 
  BOUNDS_LIST bounds;
  INT16 num_blobs;
  INT16 x;
  INT16 y;
  TPOINT tp_topleft;
  TPOINT tp_botright;
  unsigned int topleft;
  unsigned int botright;
  MATRIX ratings;
  CHOICES choices;

  bounds = record_blob_bounds (blobs);
  num_blobs = count_blobs (blobs);
  ratings = create_matrix (num_blobs);

  for (x = 0; x < num_blobs; x++) {
    for (y = x; y < num_blobs; y++) {
      bounds_of_piece(bounds, x, y, &tp_topleft, &tp_botright); 
      topleft = *(unsigned int *) &tp_topleft;
      botright = *(unsigned int *) &tp_botright;
      choices = get_match_by_bounds (topleft, botright);
      if (choices != NIL) {
        matrix_put(ratings, x, y, choices); 
      }
    }
  }
  memfree(bounds); 
  return (ratings);
}

void reveal_edge_pair	(	EDGEPT *	pt1,
		EDGEPT *	pt2
	)

Change the edge points that are referenced by this seam to make them hidden edges.

Definition at line 193 of file pieces.cpp.

References exact_point, edgeptstruct::next, and reveal_edge.

Referenced by reveal_seam().

                                                { 
  EDGEPT *edgept;

  edgept = pt1;
  do {
    reveal_edge(edgept); 
    edgept = edgept->next;
  }
  while (!exact_point (edgept, pt2) && edgept != pt1);
  if (edgept == pt1) {
    /*              cprintf("Hid entire outline at (%d,%d)!!\n",
       edgept->pos.x,edgept->pos.y);                                */
  }
  edgept = pt2;
  do {
    reveal_edge(edgept); 
    edgept = edgept->next;
  }
  while (!exact_point (edgept, pt1) && edgept != pt2);
  if (edgept == pt2) {
    /*              cprintf("Hid entire outline at (%d,%d)!!\n",
       edgept->pos.x,edgept->pos.y);                                */
  }
}

void reveal_seam

(

SEAM *

seam

)

Change the edge points that are referenced by this seam to make them hidden edges.

Definition at line 173 of file pieces.cpp.

References NULL, split_record::point1, split_record::point2, reveal_edge_pair(), seam_record::split1, seam_record::split2, and seam_record::split3.

Referenced by break_pieces().

                             { 
  if (seam == NULL || seam->split1 == NULL)
    return;
  reveal_edge_pair (seam->split1->point1, seam->split1->point2);

  if (seam->split2 == NULL)
    return;
  reveal_edge_pair (seam->split2->point1, seam->split2->point2);

  if (seam->split3 == NULL)
    return;
  reveal_edge_pair (seam->split3->point1, seam->split3->point2);
}

---