ccstruct/blobbox.cpp File Reference

#include "mfcpch.h"
#include "blobbox.h"

Go to the source code of this file.

Defines

• #define EXTERN
• #define PROJECTION_MARGIN   10

Functions

• BOX box_next (BLOBNBOX_IT *it)

  Get bounding box.
  

• BOX box_next_pre_chopped (BLOBNBOX_IT *it)

  Get bounding box.
  

• static void clear_blobnboxes (BLOBNBOX_LIST *boxes)
• C_BLOB * crotate_cblob (C_BLOB *blob, FCOORD rotation)

  Rotate the copy by the given vector and return a C_BLOB.
  

• ELISTIZE (BLOBNBOX) ELIST2IZE(TO_ROW) ELISTIZE(TO_BLOCK) void BLOBNBOX

  Merge this blob with the given blob, which should be after this.
  

• void find_blob_limits (PBLOB *blob, float leftx, float rightx, FCOORD rotation, float &ymin, float &ymax)

  Scan the outlines of the blob to locate the y min and max between the given x limits.
  

• void find_cblob_hlimits (C_BLOB *blob, float bottomy, float topy, float &xmin, float &xmax)

  Scan the outlines of the cblob to locate the x min and max between the given y limits.
  

• void find_cblob_limits (C_BLOB *blob, float leftx, float rightx, FCOORD rotation, float &ymin, float &ymax)

  Scan the outlines of the cblob to locate the y min and max between the given x limits.
  

• void find_cblob_vlimits (C_BLOB *blob, float leftx, float rightx, float &ymin, float &ymax)

  Scan the outlines of the cblob to locate the y min and max between the given x limits.
  

• PBLOB * rotate_blob (PBLOB *blob, FCOORD rotation)

  Poly copy the blob and rotate the copy by the given vector.
  

• PBLOB * rotate_cblob (C_BLOB *blob, float xheight, FCOORD rotation)

  Poly copy the blob and rotate the copy by the given vector.
  

• void vertical_blob_projection (PBLOB *blob, STATS *stats)

  Project outlines.
  

• void vertical_cblob_projection (C_BLOB *blob, STATS *stats)

  Project Outlines.
  

• void vertical_coutline_projection (C_OUTLINE *outline, STATS *stats)

  Project Outlines.
  

• void vertical_outline_projection (OUTLINE *outline, STATS *stats)

  Project Outlines.
  

---

Define Documentation

#define EXTERN

Definition at line 24 of file blobbox.cpp.

#define PROJECTION_MARGIN   10

Note:

File: blobbox.cpp (Formerly blobnbox.c)
Code for the textord blob class.

Author:

Ray Smith

Date:

Thu Jul 30 09:08:51 BST 1992

 * (C) Copyright 1992, Hewlett-Packard Ltd.
 ** 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.

Definition at line 23 of file blobbox.cpp.

Referenced by TO_ROW::compute_vertical_projection().

---

Function Documentation

BOX box_next

(

BLOBNBOX_IT *

it

)

Get bounding box.

Compute the bounding box of this blob with merging of x overlaps but no pre-chopping. Then move the iterator on to the start of the next blob.

Definition at line 379 of file blobbox.cpp.

References NULL.

Referenced by block_spacing_stats(), check_pitch_sync(), check_pitch_sync2(), compute_pitch_sd(), compute_pitch_sd2(), GAPMAP::GAPMAP(), isolated_row_stats(), make_illegal_segment(), peek_at_next_gap(), plot_fp_cells(), plot_fp_cells2(), plot_row_cells(), print_pitch_sd(), and row_spacing_stats().

              {
  BLOBNBOX *blob;                //current blob
  BOX result;                    //total box

  blob = it->data ();
  result = blob->bounding_box ();
  do {
    it->forward ();
    blob = it->data ();
    if (blob->blob () == NULL && blob->cblob () == NULL)
                                 //was pre-chopped
      result += blob->bounding_box ();
  }
                                 //until next real blob
  while (blob->blob () == NULL && blob->cblob () == NULL || blob->joined_to_prev ());
  return result;
}

BOX box_next_pre_chopped

(

BLOBNBOX_IT *

it

)

Get bounding box.

Compute the bounding box of this blob with merging of x overlaps but WITH pre-chopping. Then move the iterator on to the start of the next pre-chopped blob.

Definition at line 407 of file blobbox.cpp.

Referenced by block_spacing_stats(), get_blob_coords(), isolated_row_stats(), linear_spline_baseline(), row_spacing_stats(), and segment_baseline().

                          {
  BLOBNBOX *blob;                //current blob
  BOX result;                    //total box

  blob = it->data ();
  result = blob->bounding_box ();
  do {
    it->forward ();
    blob = it->data ();
  }
                                 //until next real blob
  while (blob->joined_to_prev ());
  return result;
}

static void clear_blobnboxes

(

BLOBNBOX_LIST *

boxes

)

[static]

Definition at line 715 of file blobbox.cpp.

References NULL.

                                                   {
  BLOBNBOX_IT it = boxes;
  // A BLOBNBOX generally doesn't own its blobs, so if they do, you
  // have to delete them explicitly.
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    BLOBNBOX* box = it.data();
    if (box->blob() != NULL)
      delete box->blob();
    if (box->cblob() != NULL)
      delete box->cblob();
  }
}

C_BLOB* crotate_cblob	(	C_BLOB *	blob,
		FCOORD	rotation
	)

Rotate the copy by the given vector and return a C_BLOB.

Definition at line 356 of file blobbox.cpp.

References C_BLOB::out_list(), and rotation.

Referenced by separate_underlines().

                       {
  C_OUTLINE_LIST out_list;       //output outlines
                                 //input outlines
  C_OUTLINE_IT in_it = blob->out_list ();
                                 //output outlines
  C_OUTLINE_IT out_it = &out_list;

  for (in_it.mark_cycle_pt (); !in_it.cycled_list (); in_it.forward ()) {
    out_it.add_after_then_move (new C_OUTLINE (in_it.data (), rotation));
  }
  return new C_BLOB (&out_list);
}

ELISTIZE

(

BLOBNBOX

)

Merge this blob with the given blob, which should be after this.

Definition at line 34 of file blobbox.cpp.

References TRUE.

                      {
  box += nextblob->box;          //merge boxes
  nextblob->joined = TRUE;
}

void find_blob_limits	(	PBLOB *	blob,
		float	leftx,
		float	rightx,
		FCOORD	rotation,
		float &	ymin,
		float &	ymax
	)

Scan the outlines of the blob to locate the y min and max between the given x limits.

Definition at line 121 of file blobbox.cpp.

References MAX_INT32, PBLOB::out_list(), rotation, and POLYPT::vec.

Referenced by reduced_box_for_blob().

                                   {
  float testy;                   //y intercept
  FCOORD pos;                    //rotated
  FCOORD vec;
  POLYPT *polypt;                //current point
                                 //outlines
  OUTLINE_IT out_it = blob->out_list ();
  POLYPT_IT poly_it;             //outline pts

  ymin = (float) MAX_INT32;
  ymax = (float) -MAX_INT32;
  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
                                 //get points
    poly_it.set_to_list (out_it.data ()->polypts ());
    for (poly_it.mark_cycle_pt (); !poly_it.cycled_list ();
    poly_it.forward ()) {
      polypt = poly_it.data ();
      pos = polypt->pos;
      pos.rotate (rotation);
      vec = polypt->vec;
      vec.rotate (rotation);
      if (pos.x () < leftx && pos.x () + vec.x () > leftx
      || pos.x () > leftx && pos.x () + vec.x () < leftx) {
        testy = pos.y () + vec.y () * (leftx - pos.x ()) / vec.x ();
        //intercept of boundary
        if (testy < ymin)
          ymin = testy;
        if (testy > ymax)
          ymax = testy;
      }
      if (pos.x () >= leftx && pos.x () <= rightx) {
        if (pos.y () > ymax)
          ymax = pos.y ();
        if (pos.y () < ymin)
          ymin = pos.y ();
      }
      if (pos.x () > rightx && pos.x () + vec.x () < rightx
      || pos.x () < rightx && pos.x () + vec.x () > rightx) {
        testy = pos.y () + vec.y () * (rightx - pos.x ()) / vec.x ();
        //intercept of boundary
        if (testy < ymin)
          ymin = testy;
        if (testy > ymax)
          ymax = testy;
      }
    }
  }
}

void find_cblob_hlimits	(	C_BLOB *	blob,
		float	bottomy,
		float	topy,
		float &	xmin,
		float &	xmax
	)

Scan the outlines of the cblob to locate the x min and max between the given y limits.

Definition at line 258 of file blobbox.cpp.

References MAX_INT32, C_BLOB::out_list(), and ICOORD::y().

Referenced by reduced_box_for_blob().

                                     {
  INT16 stepindex;               //current point
  ICOORD pos;                    //current coords
  ICOORD vec;                    //rotated step
  C_OUTLINE *outline;            //current outline
                                 //outlines
  C_OUTLINE_IT out_it = blob->out_list ();

  xmin = (float) MAX_INT32;
  xmax = (float) -MAX_INT32;
  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    outline = out_it.data ();
    pos = outline->start_pos (); //get coords
    for (stepindex = 0; stepindex < outline->pathlength (); stepindex++) {
                                 //inside
      if (pos.y () >= bottomy && pos.y () <= topy) {
        if (pos.x () > xmax)
          xmax = pos.x ();
        if (pos.x () < xmin)
          xmin = pos.x ();
      }
      vec = outline->step (stepindex);
      pos += vec;                //move to next
    }
  }
}

void find_cblob_limits	(	C_BLOB *	blob,
		float	leftx,
		float	rightx,
		FCOORD	rotation,
		float &	ymin,
		float &	ymax
	)

Scan the outlines of the cblob to locate the y min and max between the given x limits.

Definition at line 181 of file blobbox.cpp.

References MAX_INT32, C_BLOB::out_list(), ICOORD::rotate(), rotation, and ICOORD::y().

                                    {
  INT16 stepindex;               //current point
  ICOORD pos;                    //current coords
  ICOORD vec;                    //rotated step
  C_OUTLINE *outline;            //current outline
                                 //outlines
  C_OUTLINE_IT out_it = blob->out_list ();

  ymin = (float) MAX_INT32;
  ymax = (float) -MAX_INT32;
  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    outline = out_it.data ();
    pos = outline->start_pos (); //get coords
    pos.rotate (rotation);
    for (stepindex = 0; stepindex < outline->pathlength (); stepindex++) {
                                 //inside
      if (pos.x () >= leftx && pos.x () <= rightx) {
        if (pos.y () > ymax)
          ymax = pos.y ();
        if (pos.y () < ymin)
          ymin = pos.y ();
      }
      vec = outline->step (stepindex);
      vec.rotate (rotation);
      pos += vec;                //move to next
    }
  }
}

void find_cblob_vlimits	(	C_BLOB *	blob,
		float	leftx,
		float	rightx,
		float &	ymin,
		float &	ymax
	)

Scan the outlines of the cblob to locate the y min and max between the given x limits.

Definition at line 221 of file blobbox.cpp.

References MAX_INT32, C_BLOB::out_list(), and ICOORD::y().

                                     {
  INT16 stepindex;               //current point
  ICOORD pos;                    //current coords
  ICOORD vec;                    //rotated step
  C_OUTLINE *outline;            //current outline
                                 //outlines
  C_OUTLINE_IT out_it = blob->out_list ();

  ymin = (float) MAX_INT32;
  ymax = (float) -MAX_INT32;
  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    outline = out_it.data ();
    pos = outline->start_pos (); //get coords
    for (stepindex = 0; stepindex < outline->pathlength (); stepindex++) {
                                 //inside
      if (pos.x () >= leftx && pos.x () <= rightx) {
        if (pos.y () > ymax)
          ymax = pos.y ();
        if (pos.y () < ymin)
          ymin = pos.y ();
      }
      vec = outline->step (stepindex);
      pos += vec;                //move to next
    }
  }
}

PBLOB* rotate_blob	(	PBLOB *	blob,
		FCOORD	rotation
	)

Poly copy the blob and rotate the copy by the given vector.

Definition at line 294 of file blobbox.cpp.

References PBLOB::out_list(), rotation, and POLYPT::vec.

Referenced by separate_underlines().

                    {
  PBLOB *copy;                   //copy of blob
  POLYPT *polypt;                //current point
  OUTLINE_IT out_it;
  POLYPT_IT poly_it;             //outline pts

  copy = new PBLOB;
  *copy = *blob;                 //deep copy
  out_it.set_to_list (copy->out_list ());
  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
                                 //get points
    poly_it.set_to_list (out_it.data ()->polypts ());
    for (poly_it.mark_cycle_pt (); !poly_it.cycled_list ();
    poly_it.forward ()) {
      polypt = poly_it.data ();
                                 //rotate it
      polypt->pos.rotate (rotation);
      polypt->vec.rotate (rotation);
    }
    out_it.data ()->compute_bb ();
  }
  return copy;
}

PBLOB* rotate_cblob	(	C_BLOB *	blob,
		float	xheight,
		FCOORD	rotation
	)

Poly copy the blob and rotate the copy by the given vector.

Definition at line 325 of file blobbox.cpp.

References PBLOB::out_list(), rotation, and POLYPT::vec.

Referenced by separate_underlines().

                     {
  PBLOB *copy;                   //copy of blob
  POLYPT *polypt;                //current point
  OUTLINE_IT out_it;
  POLYPT_IT poly_it;             //outline pts

  copy = new PBLOB (blob, xheight);
  out_it.set_to_list (copy->out_list ());
  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
                                 //get points
    poly_it.set_to_list (out_it.data ()->polypts ());
    for (poly_it.mark_cycle_pt (); !poly_it.cycled_list ();
    poly_it.forward ()) {
      polypt = poly_it.data ();
                                 //rotate it
      polypt->pos.rotate (rotation);
      polypt->vec.rotate (rotation);
    }
    out_it.data ()->compute_bb ();
  }
  return copy;
}

void vertical_blob_projection	(	PBLOB *	blob,
		STATS *	stats
	)

Project outlines.

Compute the vertical projection of a blob from its outlines and add to the given STATS.

Definition at line 544 of file blobbox.cpp.

References PBLOB::out_list(), and vertical_outline_projection().

Referenced by TO_ROW::compute_vertical_projection().

                               {
                                 //outlines of blob
  OUTLINE_IT out_it = blob->out_list ();

  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    vertical_outline_projection (out_it.data (), stats);
  }
}

void vertical_cblob_projection	(	C_BLOB *	blob,
		STATS *	stats
	)

Project Outlines.

Compute the vertical projection of a cblob from its outlines and add to the given STATS.

Definition at line 650 of file blobbox.cpp.

References C_BLOB::out_list(), and vertical_coutline_projection().

Referenced by TO_ROW::compute_vertical_projection().

                                {
                                 //outlines of blob
  C_OUTLINE_IT out_it = blob->out_list ();

  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    vertical_coutline_projection (out_it.data (), stats);
  }
}

void vertical_coutline_projection	(	C_OUTLINE *	outline,
		STATS *	stats
	)

Project Outlines.

Compute the vertical projection of a outline from its outlines and add to the given STATS.

Definition at line 669 of file blobbox.cpp.

References STATS::add(), vertical_coutline_projection(), and ICOORD::y().

Referenced by vertical_cblob_projection(), and vertical_coutline_projection().

                                   {
  ICOORD pos;                    //current point
  ICOORD step;                   //edge step
  INT32 length;                  //of outline
  INT16 stepindex;               //current step
  C_OUTLINE_IT out_it = outline->child ();

  pos = outline->start_pos ();
  length = outline->pathlength ();
  for (stepindex = 0; stepindex < length; stepindex++) {
    step = outline->step (stepindex);
    if (step.x () > 0) {
      if (pitsync_projection_fix)
        stats->add (pos.x (), -pos.y ());
      else
        stats->add (pos.x (), pos.y ());
    }
    else if (step.x () < 0) {
      if (pitsync_projection_fix)
        stats->add (pos.x () - 1, pos.y ());
      else
        stats->add (pos.x () - 1, -pos.y ());
    }
    pos += step;
  }

  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    vertical_coutline_projection (out_it.data (), stats);
  }
}

void vertical_outline_projection	(	OUTLINE *	outline,
		STATS *	stats
	)

Project Outlines.

Compute the vertical projection of a outline from its outlines and add to the given STATS.

Definition at line 563 of file blobbox.cpp.

References STATS::add(), f, POLYPT::vec, and vertical_outline_projection().

Referenced by vertical_blob_projection(), and vertical_outline_projection().

                                  {
  POLYPT *polypt;                //current point
  INT32 xcoord;                  //current pixel coord
  float end_x;                   //end of vec
  POLYPT_IT poly_it = outline->polypts ();
  OUTLINE_IT out_it = outline->child ();
  float ymean;                   //amount to add
  float width;                   //amount of x

  for (poly_it.mark_cycle_pt (); !poly_it.cycled_list (); poly_it.forward ()) {
    polypt = poly_it.data ();
    end_x = polypt->pos.x () + polypt->vec.x ();
    if (polypt->vec.x () > 0) {
      for (xcoord = (INT32) floor (polypt->pos.x ());
      xcoord < end_x; xcoord++) {
        if (polypt->pos.x () < xcoord) {
          width = (float) xcoord;
          ymean =
            polypt->vec.y () * (xcoord -
            polypt->pos.x ()) / polypt->vec.x () +
            polypt->pos.y ();
        }
        else {
          width = polypt->pos.x ();
          ymean = polypt->pos.y ();
        }
        if (end_x > xcoord + 1) {
          width -= xcoord + 1;
          ymean +=
            polypt->vec.y () * (xcoord + 1 -
            polypt->pos.x ()) / polypt->vec.x () +
            polypt->pos.y ();
        }
        else {
          width -= end_x;
          ymean += polypt->pos.y () + polypt->vec.y ();
        }
        ymean = ymean * width / 2;
        stats->add (xcoord, (INT32) floor (ymean + 0.5));
      }
    }
    else if (polypt->vec.x () < 0) {
      for (xcoord = (INT32) floor (end_x);
      xcoord < polypt->pos.x (); xcoord++) {
        if (polypt->pos.x () > xcoord + 1) {
          width = xcoord + 1.0f;
          ymean =
            polypt->vec.y () * (xcoord + 1 -
            polypt->pos.x ()) / polypt->vec.x () +
            polypt->pos.y ();
        }
        else {
          width = polypt->pos.x ();
          ymean = polypt->pos.y ();
        }
        if (end_x < xcoord) {
          width -= xcoord;
          ymean +=
            polypt->vec.y () * (xcoord -
            polypt->pos.x ()) / polypt->vec.x () +
            polypt->pos.y ();
        }
        else {
          width -= end_x;
          ymean += polypt->pos.y () + polypt->vec.y ();
        }
        ymean = ymean * width / 2;
        stats->add (xcoord, (INT32) floor (ymean + 0.5));
      }
    }
  }

  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
    vertical_outline_projection (out_it.data (), stats);
  }
}

---