SPLIT Struct Reference

#include <split.h>

Public Member Functions
	SPLIT ()
	SPLIT (EDGEPT *pt1, EDGEPT *pt2)
TBOX	bounding_box () const
TBOX	Box12 () const
TBOX	Box21 () const
void	Hide () const
void	Reveal () const
bool	UsesPoint (const EDGEPT *point) const
bool	SharesPosition (const SPLIT &other) const
bool	ContainedByBlob (const TBLOB &blob) const
bool	ContainedByOutline (const TESSLINE &outline) const
float	FullPriority (int xmin, int xmax, double overlap_knob, int centered_maxwidth, double center_knob, double width_change_knob) const
bool	IsHealthy (const TBLOB &blob, int min_points, int min_area) const
bool	IsLittleChunk (int min_points, int min_area) const
void	Print () const
void	Mark (ScrollView *window) const
void	SplitOutlineList (TESSLINE *outlines) const
void	SplitOutline () const
void	UnsplitOutlineList (TBLOB *blob) const
void	UnsplitOutlines () const

Public Attributes
EDGEPT *	point1
EDGEPT *	point2

Detailed Description

Definition at line 34 of file split.h.

Constructor & Destructor Documentation

SPLIT() [1/2]

SPLIT::SPLIT ( )

inline

Definition at line 35 of file split.h.

{

SPLIT() [2/2]

SPLIT::SPLIT ( EDGEPT *  pt1, EDGEPT *  pt2  )

inline

Definition at line 36 of file split.h.

: point1(nullptr), point2(nullptr) {}

Member Function Documentation

bounding_box()

TBOX SPLIT::bounding_box

(

)

const

Definition at line 42 of file split.cpp.

                               {
  return TBOX(
      std::min(point1->pos.x, point2->pos.x), std::min(point1->pos.y, point2->pos.y),
      std::max(point1->pos.x, point2->pos.x), std::max(point1->pos.y, point2->pos.y));

Box12()

TBOX SPLIT::Box12 ( ) const

inline

Definition at line 41 of file split.h.

{ return point1->SegmentBox(point2); }

Box21()

TBOX SPLIT::Box21 ( ) const

inline

Definition at line 43 of file split.h.

{ return point2->SegmentBox(point1); }

ContainedByBlob()

bool SPLIT::ContainedByBlob ( const TBLOB &  blob ) const

inline

Definition at line 62 of file split.h.

                                                {
    return blob.Contains(point1->pos) && blob.Contains(point2->pos);

ContainedByOutline()

bool SPLIT::ContainedByOutline ( const TESSLINE &  outline ) const

inline

Definition at line 66 of file split.h.

                                                         {
    return outline.Contains(point1->pos) && outline.Contains(point2->pos);

FullPriority()

float SPLIT::FullPriority	(	int	xmin,
		int	xmax,
		double	overlap_knob,
		int	centered_maxwidth,
		double	center_knob,
		double	width_change_knob
	)		const

Definition at line 79 of file split.cpp.

                                                          {
  TBOX box1 = Box12();
  TBOX box2 = Box21();
  int min_left = std::min(box1.left(), box2.left());
  int max_right = std::max(box1.right(), box2.right());
  if (xmin < min_left && xmax > max_right) return kBadPriority;
 
  float grade = 0.0f;
  // grade_overlap.
  int width1 = box1.width();
  int width2 = box2.width();
  int min_width = std::min(width1, width2);
  int overlap = -box1.x_gap(box2);
  if (overlap == min_width) {
    grade += 100.0f;  // Total overlap.
  } else {
    if (2 * overlap > min_width) overlap += 2 * overlap - min_width;
    if (overlap > 0) grade += overlap_knob * overlap;
  }
  // grade_center_of_blob.
  if (width1 <= centered_maxwidth || width2 <= centered_maxwidth) {
    grade += std::min(static_cast<double>(kCenterGradeCap), center_knob * abs(width1 - width2));
  }
  // grade_width_change.
  float width_change_grade = 20 - (max_right - min_left - std::max(width1, width2));
  if (width_change_grade > 0.0f)
    grade += width_change_grade * width_change_knob;
  return grade;

Hide()

void SPLIT::Hide

(

)

const

Definition at line 49 of file split.cpp.

                       {
  EDGEPT* edgept = point1;
  do {
    edgept->Hide();
    edgept = edgept->next;
  } while (!edgept->EqualPos(*point2) && edgept != point1);
  edgept = point2;
  do {
    edgept->Hide();
    edgept = edgept->next;
  } while (!edgept->EqualPos(*point1) && edgept != point2);

IsHealthy()

bool SPLIT::IsHealthy	(	const TBLOB &	blob,
		int	min_points,
		int	min_area
	)		const

Definition at line 113 of file split.cpp.

                                                                           {
  return !IsLittleChunk(min_points, min_area) &&
         !blob.SegmentCrossesOutline(point1->pos, point2->pos);

IsLittleChunk()

bool SPLIT::IsLittleChunk	(	int	min_points,
		int	min_area
	)		const

Definition at line 120 of file split.cpp.

                                                            {
  if (point1->ShortNonCircularSegment(min_points, point2) &&
      point1->SegmentArea(point2) < min_area) {
    return true;
  }
  if (point2->ShortNonCircularSegment(min_points, point1) &&
      point2->SegmentArea(point1) < min_area) {
    return true;
  }
  return false;

Mark()

void SPLIT::Mark

(

ScrollView *

window

)

const

Definition at line 221 of file split.cpp.

                                         {

Print()

void SPLIT::Print

(

)

const

Definition at line 214 of file split.cpp.

Reveal()

void SPLIT::Reveal

(

)

const

Definition at line 63 of file split.cpp.

                         {
  EDGEPT* edgept = point1;
  do {
    edgept->Reveal();
    edgept = edgept->next;
  } while (!edgept->EqualPos(*point2) && edgept != point1);
  edgept = point2;
  do {
    edgept->Reveal();
    edgept = edgept->next;
  } while (!edgept->EqualPos(*point1) && edgept != point2);

SharesPosition()

bool SPLIT::SharesPosition ( const SPLIT &  other ) const

inline

Definition at line 57 of file split.h.

                                                {
    return point1->EqualPos(*other.point1) || point1->EqualPos(*other.point2) ||
           point2->EqualPos(*other.point1) || point2->EqualPos(*other.point2);

SplitOutline()

void SPLIT::SplitOutline

(

)

const

Definition at line 249 of file split.cpp.

                               {
  EDGEPT* temp2 = point2->next;
  EDGEPT* temp1 = point1->next;
  /* Create two new points */
  EDGEPT* new_point1 = make_edgept(point1->pos.x, point1->pos.y, temp1, point2);
  EDGEPT* new_point2 = make_edgept(point2->pos.x, point2->pos.y, temp2, point1);
  // point1 and 2 are now cross-over points, so they must have nullptr
  // src_outlines and give their src_outline information their new
  // replacements.
  new_point1->src_outline = point1->src_outline;
  new_point1->start_step = point1->start_step;
  new_point1->step_count = point1->step_count;
  new_point2->src_outline = point2->src_outline;
  new_point2->start_step = point2->start_step;
  new_point2->step_count = point2->step_count;
  point1->src_outline = nullptr;
  point1->start_step = 0;
  point1->step_count = 0;

SplitOutlineList()

void SPLIT::SplitOutlineList

(

TESSLINE *

outlines

)

const

Definition at line 230 of file split.cpp.

                                                     {
  SplitOutline();
  while (outlines->next != nullptr) outlines = outlines->next;
 
  outlines->next = new TESSLINE;
  outlines->next->loop = point1;
  outlines->next->ComputeBoundingBox();
 
  outlines = outlines->next;
 
  outlines->next = new TESSLINE;
  outlines->next->loop = point2;

UnsplitOutlineList()

void SPLIT::UnsplitOutlineList

(

TBLOB *

blob

)

const

Definition at line 274 of file split.cpp.

                                                {
  /* Modify edge points */
  UnsplitOutlines();
 
  auto* outline1 = new TESSLINE;
  outline1->next = blob->outlines;
  blob->outlines = outline1;
  outline1->loop = point1;
 
  auto* outline2 = new TESSLINE;

UnsplitOutlines()

void SPLIT::UnsplitOutlines

(

)

const

Definition at line 290 of file split.cpp.

                                  {
  EDGEPT* tmp1 = point1->next;
  EDGEPT* tmp2 = point2->next;
 
  tmp1->next->prev = point2;
  tmp2->next->prev = point1;
 
  // tmp2 is coincident with point1. point1 takes tmp2's place as tmp2 is
  // deleted.
  point1->next = tmp2->next;
  point1->src_outline = tmp2->src_outline;
  point1->start_step = tmp2->start_step;
  point1->step_count = tmp2->step_count;
  // Likewise point2 takes tmp1's place.
  point2->next = tmp1->next;
  point2->src_outline = tmp1->src_outline;
  point2->start_step = tmp1->start_step;
  point2->step_count = tmp1->step_count;
 
  delete tmp1;
  delete tmp2;
 
  point1->vec.x = point1->next->pos.x - point1->pos.x;
  point1->vec.y = point1->next->pos.y - point1->pos.y;

UsesPoint()

bool SPLIT::UsesPoint ( const EDGEPT *  point ) const

inline

Definition at line 53 of file split.h.

                                            {
    return point1 == point || point2 == point;

Member Data Documentation

point1

EDGEPT* SPLIT::point1

Definition at line 100 of file split.h.

point2

EDGEPT* SPLIT::point2

Definition at line 101 of file split.h.

---

The documentation for this struct was generated from the following files:

• /tesseract/src/ccstruct/split.h
• /tesseract/src/ccstruct/split.cpp