tesseract 4.1.1
Loading...
Searching...
No Matches
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 GenericVector< SEAM * > &seams, const GenericVector< TBLOB * > &blobs, int insert_index, bool modify)
 
bool FindBlobWidth (const GenericVector< 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 GenericVector< SEAM * > &seams)
 
static void BreakPieces (const GenericVector< SEAM * > &seams, const GenericVector< TBLOB * > &blobs, int first, int last)
 
static void JoinPieces (const GenericVector< SEAM * > &seams, const GenericVector< TBLOB * > &blobs, int first, int last)
 

Detailed Description

Definition at line 38 of file seam.h.

Constructor & Destructor Documentation

◆ SEAM() [1/2]

SEAM::SEAM ( float  priority,
const TPOINT location 
)
inline

Definition at line 41 of file seam.h.

42 : priority_(priority),
43 location_(location),
44 widthp_(0),
45 widthn_(0),
46 num_splits_(0) {}
float priority() const
Definition: seam.h:59

◆ SEAM() [2/2]

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

Definition at line 48 of file seam.h.

49 : priority_(priority),
50 location_(location),
51 widthp_(0),
52 widthn_(0),
53 num_splits_(1) {
54 splits_[0] = split;
55 }

Member Function Documentation

◆ ApplySeam()

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

Definition at line 118 of file seam.cpp.

118 {
119 for (int s = 0; s < num_splits_; ++s) {
120 splits_[s].SplitOutlineList(blob->outlines);
121 }
122 blob->ComputeBoundingBoxes();
123
124 divide_blobs(blob, other_blob, italic_blob, location_);
125
127 other_blob->EliminateDuplicateOutlines();
128
129 blob->CorrectBlobOrder(other_blob);
130}
void divide_blobs(TBLOB *blob, TBLOB *other_blob, bool italic_blob, const TPOINT &location)
Definition: blobs.cpp:962
void CorrectBlobOrder(TBLOB *next)
Definition: blobs.cpp:501
TESSLINE * outlines
Definition: blobs.h:400
void EliminateDuplicateOutlines()
Definition: blobs.cpp:480
void ComputeBoundingBoxes()
Definition: blobs.cpp:446
void SplitOutlineList(TESSLINE *outlines) const
Definition: split.cpp:235

◆ bounding_box()

TBOX SEAM::bounding_box ( ) const

Definition at line 31 of file seam.cpp.

31 {
32 TBOX box(location_.x, location_.y, location_.x, location_.y);
33 for (int s = 0; s < num_splits_; ++s) {
34 box += splits_[s].bounding_box();
35 }
36 return box;
37}
int16_t x
Definition: blobs.h:93
int16_t y
Definition: blobs.h:94
Definition: rect.h:34
TBOX bounding_box() const
Definition: split.cpp:44

◆ BreakPieces()

void SEAM::BreakPieces ( const GenericVector< SEAM * > &  seams,
const GenericVector< TBLOB * > &  blobs,
int  first,
int  last 
)
static

Definition at line 188 of file seam.cpp.

190 {
191 for (int x = first; x < last; ++x) seams[x]->Reveal();
192
193 TESSLINE* outline = blobs[first]->outlines;
194 int next_blob = first + 1;
195
196 while (outline != nullptr && next_blob <= last) {
197 if (outline->next == blobs[next_blob]->outlines) {
198 outline->next = nullptr;
199 outline = blobs[next_blob]->outlines;
200 ++next_blob;
201 } else {
202 outline = outline->next;
203 }
204 }
205}
LIST last(LIST var_list)
Definition: oldlist.cpp:190
TESSLINE * next
Definition: blobs.h:281
void Reveal() const
Definition: seam.cpp:232

◆ CombineableWith()

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

Definition at line 40 of file seam.cpp.

41 {
42 int dist = location_.x - other.location_.x;
43 if (-max_x_dist < dist && dist < max_x_dist &&
44 num_splits_ + other.num_splits_ <= kMaxNumSplits &&
45 priority_ + other.priority_ < max_total_priority &&
46 !OverlappingSplits(other) && !SharesPosition(other)) {
47 return true;
48 } else {
49 return false;
50 }
51}
bool SharesPosition(const SEAM &other) const
Definition: seam.h:89
bool OverlappingSplits(const SEAM &other) const
Definition: seam.h:97

◆ CombineWith()

void SEAM::CombineWith ( const SEAM other)

Definition at line 54 of file seam.cpp.

54 {
55 priority_ += other.priority_;
56 location_ += other.location_;
57 location_ /= 2;
58
59 for (uint8_t s = 0; s < other.num_splits_ && num_splits_ < kMaxNumSplits; ++s)
60 splits_[num_splits_++] = other.splits_[s];
61}

◆ ContainedByBlob()

bool SEAM::ContainedByBlob ( const TBLOB blob) const
inline

Definition at line 73 of file seam.h.

73 {
74 for (int s = 0; s < num_splits_; ++s) {
75 if (!splits_[s].ContainedByBlob(blob)) return false;
76 }
77 return true;
78 }
bool ContainedByBlob(const TBLOB &blob) const
Definition: seam.h:73

◆ Finalize()

void SEAM::Finalize ( )
inline

Definition at line 110 of file seam.h.

110 {
111 for (int s = 0; s < num_splits_; ++s) {
112 splits_[s].point1->MarkChop();
113 splits_[s].point2->MarkChop();
114 }
115 }
void MarkChop()
Definition: blobs.h:179
EDGEPT * point1
Definition: split.h:103
EDGEPT * point2
Definition: split.h:104

◆ FindBlobWidth()

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

Definition at line 91 of file seam.cpp.

92 {
93 int num_found = 0;
94 if (modify) {
95 widthp_ = 0;
96 widthn_ = 0;
97 }
98 for (int s = 0; s < num_splits_; ++s) {
99 const SPLIT& split = splits_[s];
100 bool found_split = split.ContainedByBlob(*blobs[index]);
101 // Look right.
102 for (int b = index + 1; !found_split && b < blobs.size(); ++b) {
103 found_split = split.ContainedByBlob(*blobs[b]);
104 if (found_split && b - index > widthp_ && modify) widthp_ = b - index;
105 }
106 // Look left.
107 for (int b = index - 1; !found_split && b >= 0; --b) {
108 found_split = split.ContainedByBlob(*blobs[b]);
109 if (found_split && index - b > widthn_ && modify) widthn_ = index - b;
110 }
111 if (found_split) ++num_found;
112 }
113 return num_found == num_splits_;
114}
int size() const
Definition: genericvector.h:72
Definition: split.h:37
bool ContainedByBlob(const TBLOB &blob) const
Definition: split.h:65

◆ FullPriority()

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

Definition at line 239 of file seam.cpp.

241 {
242 if (num_splits_ == 0) return 0.0f;
243 for (int s = 1; s < num_splits_; ++s) {
244 splits_[s].SplitOutline();
245 }
246 float full_priority =
247 priority_ +
248 splits_[0].FullPriority(xmin, xmax, overlap_knob, centered_maxwidth,
249 center_knob, width_change_knob);
250 for (int s = num_splits_ - 1; s >= 1; --s) {
251 splits_[s].UnsplitOutlines();
252 }
253 return full_priority;
254}
float FullPriority(int xmin, int xmax, double overlap_knob, int centered_maxwidth, double center_knob, double width_change_knob) const
Definition: split.cpp:81
void SplitOutline() const
Definition: split.cpp:254
void UnsplitOutlines() const
Definition: split.cpp:295

◆ HasAnySplits()

bool SEAM::HasAnySplits ( ) const
inline

Definition at line 61 of file seam.h.

61{ return num_splits_ > 0; }

◆ Hide()

void SEAM::Hide ( ) const

Definition at line 225 of file seam.cpp.

225 {
226 for (int s = 0; s < num_splits_; ++s) {
227 splits_[s].Hide();
228 }
229}
void Hide() const
Definition: split.cpp:51

◆ IsHealthy()

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

Definition at line 66 of file seam.cpp.

66 {
67 // TODO(rays) Try testing all the splits. Duplicating original code for now,
68 // which tested only the first.
69 return num_splits_ == 0 || splits_[0].IsHealthy(blob, min_points, min_area);
70}
bool IsHealthy(const TBLOB &blob, int min_points, int min_area) const
Definition: split.cpp:115

◆ JoinPieces()

void SEAM::JoinPieces ( const GenericVector< SEAM * > &  seams,
const GenericVector< TBLOB * > &  blobs,
int  first,
int  last 
)
static

Definition at line 210 of file seam.cpp.

211 {
212 TESSLINE* outline = blobs[first]->outlines;
213 if (!outline)
214 return;
215
216 for (int x = first; x < last; ++x) {
217 SEAM *seam = seams[x];
218 if (x - seam->widthn_ >= first && x + seam->widthp_ < last) seam->Hide();
219 while (outline->next) outline = outline->next;
220 outline->next = blobs[x + 1]->outlines;
221 }
222}
Definition: seam.h:38
void Hide() const
Definition: seam.cpp:225

◆ Mark()

void SEAM::Mark ( ScrollView window) const

Definition at line 180 of file seam.cpp.

180 {
181 for (int s = 0; s < num_splits_; ++s) splits_[s].Mark(window);
182}
void Mark(ScrollView *window) const
Definition: seam.cpp:180

◆ OverlappingSplits()

bool SEAM::OverlappingSplits ( const SEAM other) const
inline

Definition at line 97 of file seam.h.

97 {
98 for (int s = 0; s < num_splits_; ++s) {
99 TBOX split1_box = splits_[s].bounding_box();
100 for (int t = 0; t < other.num_splits_; ++t) {
101 TBOX split2_box = other.splits_[t].bounding_box();
102 if (split1_box.y_overlap(split2_box)) return true;
103 }
104 }
105 return false;
106 }
bool y_overlap(const TBOX &box) const
Definition: rect.h:428

◆ PrepareToInsertSeam()

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

Definition at line 76 of file seam.cpp.

78 {
79 for (int s = 0; s < insert_index; ++s) {
80 if (!seams[s]->FindBlobWidth(blobs, s, modify)) return false;
81 }
82 if (!FindBlobWidth(blobs, insert_index, modify)) return false;
83 for (int s = insert_index; s < seams.size(); ++s) {
84 if (!seams[s]->FindBlobWidth(blobs, s + 1, modify)) return false;
85 }
86 return true;
87}
bool FindBlobWidth(const GenericVector< TBLOB * > &blobs, int index, bool modify)
Definition: seam.cpp:91

◆ Print()

void SEAM::Print ( const char *  label) const

Definition at line 154 of file seam.cpp.

154 {
155 tprintf(label);
156 tprintf(" %6.2f @ (%d,%d), p=%d, n=%d ", priority_, location_.x, location_.y,
157 widthp_, widthn_);
158 for (int s = 0; s < num_splits_; ++s) {
159 splits_[s].Print();
160 if (s + 1 < num_splits_) tprintf(", ");
161 }
162 tprintf("\n");
163}
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
void Print() const
Definition: split.cpp:219

◆ PrintSeams()

void SEAM::PrintSeams ( const char *  label,
const GenericVector< SEAM * > &  seams 
)
static

Definition at line 167 of file seam.cpp.

167 {
168 if (!seams.empty()) {
169 tprintf("%s\n", label);
170 for (int x = 0; x < seams.size(); ++x) {
171 tprintf("%2d: ", x);
172 seams[x]->Print("");
173 }
174 tprintf("\n");
175 }
176}
bool empty() const
Definition: genericvector.h:91

◆ priority()

float SEAM::priority ( ) const
inline

Definition at line 59 of file seam.h.

59{ return priority_; }

◆ Reveal()

void SEAM::Reveal ( ) const

Definition at line 232 of file seam.cpp.

232 {
233 for (int s = 0; s < num_splits_; ++s) {
234 splits_[s].Reveal();
235 }
236}
void Reveal() const
Definition: split.cpp:65

◆ set_priority()

void SEAM::set_priority ( float  priority)
inline

Definition at line 60 of file seam.h.

60{ priority_ = priority; }

◆ SharesPosition()

bool SEAM::SharesPosition ( const SEAM other) const
inline

Definition at line 89 of file seam.h.

89 {
90 for (int s = 0; s < num_splits_; ++s) {
91 for (int t = 0; t < other.num_splits_; ++t)
92 if (splits_[s].SharesPosition(other.splits_[t])) return true;
93 }
94 return false;
95 }

◆ UndoSeam()

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

Definition at line 134 of file seam.cpp.

134 {
135 if (blob->outlines == nullptr) {
136 blob->outlines = other_blob->outlines;
137 other_blob->outlines = nullptr;
138 }
139
140 TESSLINE* outline = blob->outlines;
141 while (outline->next) outline = outline->next;
142 outline->next = other_blob->outlines;
143 other_blob->outlines = nullptr;
144 delete other_blob;
145
146 for (int s = 0; s < num_splits_; ++s) {
147 splits_[s].UnsplitOutlineList(blob);
148 }
149 blob->ComputeBoundingBoxes();
151}
void UnsplitOutlineList(TBLOB *blob) const
Definition: split.cpp:279

◆ UsesPoint()

bool SEAM::UsesPoint ( const EDGEPT point) const
inline

Definition at line 82 of file seam.h.

82 {
83 for (int s = 0; s < num_splits_; ++s) {
84 if (splits_[s].UsesPoint(point)) return true;
85 }
86 return false;
87 }
bool UsesPoint(const EDGEPT *point) const
Definition: seam.h:82

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