tesseract::SEAM Class Reference

#include <seam.h>

Public Member Functions
	SEAM (float priority, const TPOINT &location)
	SEAM (float priority, const TPOINT &location, const SPLIT &split)
float	priority () const
void	set_priority (float priority)
bool	HasAnySplits () const
TBOX	bounding_box () const
bool	CombineableWith (const SEAM &other, int max_x_dist, float max_total_priority) const
void	CombineWith (const SEAM &other)
bool	ContainedByBlob (const TBLOB &blob) const
bool	UsesPoint (const EDGEPT *point) const
bool	SharesPosition (const SEAM &other) const
bool	OverlappingSplits (const SEAM &other) const
void	Finalize ()
bool	IsHealthy (const TBLOB &blob, int min_points, int min_area) const
bool	PrepareToInsertSeam (const std::vector< SEAM * > &seams, const std::vector< TBLOB * > &blobs, int insert_index, bool modify)
bool	FindBlobWidth (const std::vector< TBLOB * > &blobs, int index, bool modify)
void	ApplySeam (bool italic_blob, TBLOB *blob, TBLOB *other_blob) const
void	UndoSeam (TBLOB *blob, TBLOB *other_blob) const
void	Print (const char *label) const
void	Mark (ScrollView *window) const
void	Hide () const
void	Reveal () const
float	FullPriority (int xmin, int xmax, double overlap_knob, int centered_maxwidth, double center_knob, double width_change_knob) const

Static Public Member Functions
static void	PrintSeams (const char *label, const std::vector< SEAM * > &seams)
static void	BreakPieces (const std::vector< SEAM * > &seams, const std::vector< TBLOB * > &blobs, int first, int last)
static void	JoinPieces (const std::vector< SEAM * > &seams, const std::vector< TBLOB * > &blobs, int first, int last)

Detailed Description

Definition at line 33 of file seam.h.

Constructor & Destructor Documentation

SEAM() [1/2]

tesseract::SEAM::SEAM ( float  priority, const TPOINT &  location  )

inline

Definition at line 36 of file seam.h.

      : priority_(priority), location_(location), num_splits_(0) {}

SEAM() [2/2]

tesseract::SEAM::SEAM ( float  priority, const TPOINT &  location, const SPLIT &  split  )

inline

Definition at line 39 of file seam.h.

      : priority_(priority), location_(location), num_splits_(1) {
    splits_[0] = split;
  }

Member Function Documentation

ApplySeam()

void tesseract::SEAM::ApplySeam	(	bool	italic_blob,
		TBLOB *	blob,
		TBLOB *	other_blob
	)		const

Definition at line 106 of file seam.cpp.

                                                                           {
  for (int s = 0; s < num_splits_; ++s) {
    splits_[s].SplitOutlineList(blob->outlines);
  }
  blob->ComputeBoundingBoxes();
 
  divide_blobs(blob, other_blob, italic_blob, location_);
 
  blob->EliminateDuplicateOutlines();
  other_blob->EliminateDuplicateOutlines();
 
  blob->CorrectBlobOrder(other_blob);
}

bounding_box()

TBOX tesseract::SEAM::bounding_box

(

)

const

Definition at line 33 of file seam.cpp.

                              {
  TBOX box(location_.x, location_.y, location_.x, location_.y);
  for (int s = 0; s < num_splits_; ++s) {
    box += splits_[s].bounding_box();
  }
  return box;
}

BreakPieces()

void tesseract::SEAM::BreakPieces ( const std::vector< SEAM * > &  seams, const std::vector< TBLOB * > &  blobs, int  first, int  last  )

static

Definition at line 181 of file seam.cpp.

                                            {
  for (int x = first; x < last; ++x) {
    seams[x]->Reveal();
  }
 
  TESSLINE *outline = blobs[first]->outlines;
  int next_blob = first + 1;
 
  while (outline != nullptr && next_blob <= last) {
    if (outline->next == blobs[next_blob]->outlines) {
      outline->next = nullptr;
      outline = blobs[next_blob]->outlines;
      ++next_blob;
    } else {
      outline = outline->next;
    }
  }
}

CombineableWith()

bool tesseract::SEAM::CombineableWith ( const SEAM &  other, int  max_x_dist, float  max_total_priority  ) const

inline

Definition at line 60 of file seam.h.

                                                                                          {
    int dist = location_.x - other.location_.x;
    return -max_x_dist < dist && dist < max_x_dist &&
           num_splits_ + other.num_splits_ <= kMaxNumSplits &&
           priority_ + other.priority_ < max_total_priority && !OverlappingSplits(other) &&
           !SharesPosition(other);
  }

CombineWith()

void tesseract::SEAM::CombineWith ( const SEAM &  other )

inline

Definition at line 69 of file seam.h.

                                      {
    priority_ += other.priority_;
    location_ += other.location_;
    location_ /= 2;
 
    for (uint8_t s = 0; s < other.num_splits_ && num_splits_ < kMaxNumSplits; ++s) {
      splits_[num_splits_++] = other.splits_[s];
    }
  }

ContainedByBlob()

bool tesseract::SEAM::ContainedByBlob ( const TBLOB &  blob ) const

inline

Definition at line 80 of file seam.h.

                                                {
    for (int s = 0; s < num_splits_; ++s) {
      if (!splits_[s].ContainedByBlob(blob)) {
        return false;
      }
    }
    return true;
  }

Finalize()

void tesseract::SEAM::Finalize ( )

inline

Definition at line 126 of file seam.h.

                  {
    for (int s = 0; s < num_splits_; ++s) {
      splits_[s].point1->MarkChop();
      splits_[s].point2->MarkChop();
    }
  }

FindBlobWidth()

bool tesseract::SEAM::FindBlobWidth	(	const std::vector< TBLOB * > &	blobs,
		int	index,
		bool	modify
	)

Definition at line 74 of file seam.cpp.

                                                                                {
  int num_found = 0;
  if (modify) {
    widthp_ = 0;
    widthn_ = 0;
  }
  for (int s = 0; s < num_splits_; ++s) {
    const SPLIT &split = splits_[s];
    bool found_split = split.ContainedByBlob(*blobs[index]);
    // Look right.
    for (unsigned b = index + 1; !found_split && b < blobs.size(); ++b) {
      found_split = split.ContainedByBlob(*blobs[b]);
      if (found_split && b - index > widthp_ && modify) {
        widthp_ = b - index;
      }
    }
    // Look left.
    for (int b = index - 1; !found_split && b >= 0; --b) {
      found_split = split.ContainedByBlob(*blobs[b]);
      if (found_split && index - b > widthn_ && modify) {
        widthn_ = index - b;
      }
    }
    if (found_split) {
      ++num_found;
    }
  }
  return num_found == num_splits_;
}

FullPriority()

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

Definition at line 238 of file seam.cpp.

                                                                             {
  if (num_splits_ == 0) {
    return 0.0f;
  }
  for (int s = 1; s < num_splits_; ++s) {
    splits_[s].SplitOutline();
  }
  float full_priority =
      priority_ + splits_[0].FullPriority(xmin, xmax, overlap_knob, centered_maxwidth, center_knob,
                                          width_change_knob);
  for (int s = num_splits_ - 1; s >= 1; --s) {
    splits_[s].UnsplitOutlines();
  }
  return full_priority;
}

HasAnySplits()

bool tesseract::SEAM::HasAnySplits ( ) const

inline

Definition at line 52 of file seam.h.

                            {
    return num_splits_ > 0;
  }

Hide()

void tesseract::SEAM::Hide

(

)

const

Definition at line 224 of file seam.cpp.

                      {
  for (int s = 0; s < num_splits_; ++s) {
    splits_[s].Hide();
  }
}

IsHealthy()

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

Definition at line 44 of file seam.cpp.

                                                                          {
  // TODO(rays) Try testing all the splits. Duplicating original code for now,
  // which tested only the first.
  return num_splits_ == 0 || splits_[0].IsHealthy(blob, min_points, min_area);
}

JoinPieces()

void tesseract::SEAM::JoinPieces ( const std::vector< SEAM * > &  seams, const std::vector< TBLOB * > &  blobs, int  first, int  last  )

static

Definition at line 204 of file seam.cpp.

                                           {
  TESSLINE *outline = blobs[first]->outlines;
  if (!outline) {
    return;
  }
 
  for (int x = first; x < last; ++x) {
    SEAM *seam = seams[x];
    if (x - seam->widthn_ >= first && x + seam->widthp_ < last) {
      seam->Hide();
    }
    while (outline->next) {
      outline = outline->next;
    }
    outline->next = blobs[x + 1]->outlines;
  }
}

Mark()

void tesseract::SEAM::Mark

(

ScrollView *

window

)

const

Definition at line 171 of file seam.cpp.

                                        {
  for (int s = 0; s < num_splits_; ++s) {
    splits_[s].Mark(window);
  }
}

OverlappingSplits()

bool tesseract::SEAM::OverlappingSplits ( const SEAM &  other ) const

inline

Definition at line 111 of file seam.h.

                                                  {
    for (int s = 0; s < num_splits_; ++s) {
      TBOX split1_box = splits_[s].bounding_box();
      for (int t = 0; t < other.num_splits_; ++t) {
        TBOX split2_box = other.splits_[t].bounding_box();
        if (split1_box.y_overlap(split2_box)) {
          return true;
        }
      }
    }
    return false;
  }

PrepareToInsertSeam()

bool tesseract::SEAM::PrepareToInsertSeam	(	const std::vector< SEAM * > &	seams,
		const std::vector< TBLOB * > &	blobs,
		int	insert_index,
		bool	modify
	)

Definition at line 54 of file seam.cpp.

                                                                                               {
  for (int s = 0; s < insert_index; ++s) {
    if (!seams[s]->FindBlobWidth(blobs, s, modify)) {
      return false;
    }
  }
  if (!FindBlobWidth(blobs, insert_index, modify)) {
    return false;
  }
  for (unsigned s = insert_index; s < seams.size(); ++s) {
    if (!seams[s]->FindBlobWidth(blobs, s + 1, modify)) {
      return false;
    }
  }
  return true;
}

Print()

void tesseract::SEAM::Print

(

const char *

label

)

const

Definition at line 144 of file seam.cpp.

                                        {
  tprintf("%s", label);
  tprintf(" %6.2f @ (%d,%d), p=%u, n=%u ", priority_, location_.x, location_.y, widthp_, widthn_);
  for (int s = 0; s < num_splits_; ++s) {
    splits_[s].Print();
    if (s + 1 < num_splits_) {
      tprintf(",   ");
    }
  }
  tprintf("\n");
}

PrintSeams()

void tesseract::SEAM::PrintSeams ( const char *  label, const std::vector< SEAM * > &  seams  )

static

Definition at line 158 of file seam.cpp.

                                                                       {
  if (!seams.empty()) {
    tprintf("%s\n", label);
    for (unsigned x = 0; x < seams.size(); ++x) {
      tprintf("%2u:   ", x);
      seams[x]->Print("");
    }
    tprintf("\n");
  }
}

priority()

float tesseract::SEAM::priority ( ) const

inline

Definition at line 46 of file seam.h.

                         {
    return priority_;
  }

Reveal()

void tesseract::SEAM::Reveal

(

)

const

Definition at line 231 of file seam.cpp.

                        {
  for (int s = 0; s < num_splits_; ++s) {
    splits_[s].Reveal();
  }
}

set_priority()

void tesseract::SEAM::set_priority ( float  priority )

inline

Definition at line 49 of file seam.h.

                                    {
    priority_ = priority;
  }

SharesPosition()

bool tesseract::SEAM::SharesPosition ( const SEAM &  other ) const

inline

Definition at line 100 of file seam.h.

                                               {
    for (int s = 0; s < num_splits_; ++s) {
      for (int t = 0; t < other.num_splits_; ++t) {
        if (splits_[s].SharesPosition(other.splits_[t])) {
          return true;
        }
      }
    }
    return false;
  }

UndoSeam()

void tesseract::SEAM::UndoSeam	(	TBLOB *	blob,
		TBLOB *	other_blob
	)		const

Definition at line 122 of file seam.cpp.

                                                        {
  if (blob->outlines == nullptr) {
    blob->outlines = other_blob->outlines;
    other_blob->outlines = nullptr;
  }
 
  TESSLINE *outline = blob->outlines;
  while (outline->next) {
    outline = outline->next;
  }
  outline->next = other_blob->outlines;
  other_blob->outlines = nullptr;
  delete other_blob;
 
  for (int s = 0; s < num_splits_; ++s) {
    splits_[s].UnsplitOutlineList(blob);
  }
  blob->ComputeBoundingBoxes();
  blob->EliminateDuplicateOutlines();
}

UsesPoint()

bool tesseract::SEAM::UsesPoint ( const EDGEPT *  point ) const

inline

Definition at line 91 of file seam.h.

                                            {
    for (int s = 0; s < num_splits_; ++s) {
      if (splits_[s].UsesPoint(point)) {
        return true;
      }
    }
    return false;
  }

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/seam.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/seam.cpp