tesseract  4.1.1
blobs.h
Go to the documentation of this file.
1 /* -*-C-*-
2  ********************************************************************************
3  *
4  * File: blobs.h
5  * Description: Blob definition
6  * Author: Mark Seaman, OCR Technology
7  *
8  * (c) Copyright 1989, Hewlett-Packard Company.
9  ** Licensed under the Apache License, Version 2.0 (the "License");
10  ** you may not use this file except in compliance with the License.
11  ** You may obtain a copy of the License at
12  ** http://www.apache.org/licenses/LICENSE-2.0
13  ** Unless required by applicable law or agreed to in writing, software
14  ** distributed under the License is distributed on an "AS IS" BASIS,
15  ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  ** See the License for the specific language governing permissions and
17  ** limitations under the License.
18  *
19  *********************************************************************************/
20 
21 #ifndef BLOBS_H
22 #define BLOBS_H
23 
24 /*----------------------------------------------------------------------
25  I n c l u d e s
26 ----------------------------------------------------------------------*/
27 #include <cstdint> // for int16_t
28 #include <cstring> // for memcpy, memset
29 #include "clst.h" // for CLIST_ITERATOR, CLISTIZEH
30 #include "genericvector.h" // for GenericVector
31 #include "normalis.h" // for DENORM
32 #include "points.h" // for FCOORD, ICOORD
33 #include "publictypes.h" // for OcrEngineMode
34 #include "rect.h" // for TBOX
35 #include "scrollview.h" // for ScrollView, ScrollView::Color
36 
37 class BLOCK;
38 class C_BLOB;
39 class C_OUTLINE;
40 class LLSQ;
41 class ROW;
42 class WERD;
43 
44 struct Pix;
45 
46 /*----------------------------------------------------------------------
47  T y p e s
48 ----------------------------------------------------------------------*/
49 #define EDGEPTFLAGS 4 /*concavity,length etc. */
50 
51 struct TPOINT {
52  TPOINT(): x(0), y(0) {}
53  TPOINT(int16_t vx, int16_t vy) : x(vx), y(vy) {}
54  TPOINT(const ICOORD &ic) : x(ic.x()), y(ic.y()) {}
55 
56  void operator+=(const TPOINT& other) {
57  x += other.x;
58  y += other.y;
59  }
60  void operator/=(int divisor) {
61  x /= divisor;
62  y /= divisor;
63  }
64  bool operator==(const TPOINT& other) const {
65  return x == other.x && y == other.y;
66  }
67  // Returns true when the two line segments cross each other.
68  // (Moved from outlines.cpp).
69  static bool IsCrossed(const TPOINT& a0, const TPOINT& a1, const TPOINT& b0,
70  const TPOINT& b1);
71 
72  // Assign the difference from point p1 to point p2.
73  void diff(const TPOINT& p1, const TPOINT& p2) {
74  x = p1.x - p2.x;
75  y = p1.y - p2.y;
76  }
77 
78  // Return cross product.
79  int cross(const TPOINT& other) const {
80  return x * other.y - y * other.x;
81  }
82 
83  // Return scalar or dot product.
84  int dot(const TPOINT& other) const {
85  return x * other.x + y * other.y;
86  }
87 
88  // Calculate length of vector.
89  int length() const {
90  return x * x + y * y;
91  }
92 
93  int16_t x; // absolute x coord.
94  int16_t y; // absolute y coord.
95 };
96 
97 using VECTOR = TPOINT; // structure for coordinates.
98 
99 struct EDGEPT {
101  : next(nullptr), prev(nullptr), src_outline(nullptr), start_step(0), step_count(0) {
102  memset(flags, 0, EDGEPTFLAGS * sizeof(flags[0]));
103  }
104  EDGEPT(const EDGEPT& src) : next(nullptr), prev(nullptr) {
105  CopyFrom(src);
106  }
107  EDGEPT& operator=(const EDGEPT& src) {
108  CopyFrom(src);
109  return *this;
110  }
111  // Copies the data elements, but leaves the pointers untouched.
112  void CopyFrom(const EDGEPT& src) {
113  pos = src.pos;
114  vec = src.vec;
115  memcpy(flags, src.flags, EDGEPTFLAGS * sizeof(flags[0]));
116  src_outline = src.src_outline;
117  start_step = src.start_step;
118  step_count = src.step_count;
119  }
120  // Returns the squared distance between the points, with the x-component
121  // weighted by x_factor.
122  int WeightedDistance(const EDGEPT& other, int x_factor) const {
123  int x_dist = pos.x - other.pos.x;
124  int y_dist = pos.y - other.pos.y;
125  return x_dist * x_dist * x_factor + y_dist * y_dist;
126  }
127  // Returns true if the positions are equal.
128  bool EqualPos(const EDGEPT& other) const { return pos == other.pos; }
129  // Returns the bounding box of the outline segment from *this to *end.
130  // Ignores hidden edge flags.
131  TBOX SegmentBox(const EDGEPT* end) const {
132  TBOX box(pos.x, pos.y, pos.x, pos.y);
133  const EDGEPT* pt = this;
134  do {
135  pt = pt->next;
136  if (pt->pos.x < box.left()) box.set_left(pt->pos.x);
137  if (pt->pos.x > box.right()) box.set_right(pt->pos.x);
138  if (pt->pos.y < box.bottom()) box.set_bottom(pt->pos.y);
139  if (pt->pos.y > box.top()) box.set_top(pt->pos.y);
140  } while (pt != end && pt != this);
141  return box;
142  }
143  // Returns the area of the outline segment from *this to *end.
144  // Ignores hidden edge flags.
145  int SegmentArea(const EDGEPT* end) const {
146  int area = 0;
147  const EDGEPT* pt = this->next;
148  do {
149  TPOINT origin_vec(pt->pos.x - pos.x, pt->pos.y - pos.y);
150  area += origin_vec.cross(pt->vec);
151  pt = pt->next;
152  } while (pt != end && pt != this);
153  return area;
154  }
155  // Returns true if the number of points in the outline segment from *this to
156  // *end is less that min_points and false if we get back to *this first.
157  // Ignores hidden edge flags.
158  bool ShortNonCircularSegment(int min_points, const EDGEPT* end) const {
159  int count = 0;
160  const EDGEPT* pt = this;
161  do {
162  if (pt == end) return true;
163  pt = pt->next;
164  ++count;
165  } while (pt != this && count <= min_points);
166  return false;
167  }
168 
169  // Accessors to hide or reveal a cut edge from feature extractors.
170  void Hide() {
171  flags[0] = true;
172  }
173  void Reveal() {
174  flags[0] = false;
175  }
176  bool IsHidden() const {
177  return flags[0] != 0;
178  }
179  void MarkChop() {
180  flags[2] = true;
181  }
182  bool IsChopPt() const {
183  return flags[2] != 0;
184  }
185 
186  TPOINT pos; // position
187  VECTOR vec; // vector to next point
188  // TODO(rays) Remove flags and replace with
189  // is_hidden, runlength, dir, and fixed. The only use
190  // of the flags other than is_hidden is in polyaprx.cpp.
191  char flags[EDGEPTFLAGS]; // concavity, length etc
192  EDGEPT* next; // anticlockwise element
193  EDGEPT* prev; // clockwise element
194  C_OUTLINE* src_outline; // Outline it came from.
195  // The following fields are not used if src_outline is nullptr.
196  int start_step; // Location of pos in src_outline.
197  int step_count; // Number of steps used (may wrap around).
198 };
199 
200 // For use in chop and findseam to keep a list of which EDGEPTs were inserted.
202 
203 struct TESSLINE {
204  TESSLINE() : is_hole(false), loop(nullptr), next(nullptr) {}
205  TESSLINE(const TESSLINE& src) : loop(nullptr), next(nullptr) {
206  CopyFrom(src);
207  }
209  Clear();
210  }
211  TESSLINE& operator=(const TESSLINE& src) {
212  CopyFrom(src);
213  return *this;
214  }
215  // Consume the circular list of EDGEPTs to make a TESSLINE.
216  static TESSLINE* BuildFromOutlineList(EDGEPT* outline);
217  // Copies the data and the outline, but leaves next untouched.
218  void CopyFrom(const TESSLINE& src);
219  // Deletes owned data.
220  void Clear();
221  // Normalize in-place using the DENORM.
222  void Normalize(const DENORM& denorm);
223  // Rotates by the given rotation in place.
224  void Rotate(const FCOORD rotation);
225  // Moves by the given vec in place.
226  void Move(const ICOORD vec);
227  // Scales by the given factor in place.
228  void Scale(float factor);
229  // Sets up the start and vec members of the loop from the pos members.
230  void SetupFromPos();
231  // Recomputes the bounding box from the points in the loop.
232  void ComputeBoundingBox();
233  // Computes the min and max cross product of the outline points with the
234  // given vec and returns the results in min_xp and max_xp. Geometrically
235  // this is the left and right edge of the outline perpendicular to the
236  // given direction, but to get the distance units correct, you would
237  // have to divide by the modulus of vec.
238  void MinMaxCrossProduct(const TPOINT vec, int* min_xp, int* max_xp) const;
239 
240  TBOX bounding_box() const;
241  // Returns true if *this and other have equal bounding boxes.
242  bool SameBox(const TESSLINE& other) const {
243  return topleft == other.topleft && botright == other.botright;
244  }
245  // Returns true if the given line segment crosses any outline of this blob.
246  bool SegmentCrosses(const TPOINT& pt1, const TPOINT& pt2) const {
247  if (Contains(pt1) && Contains(pt2)) {
248  EDGEPT* pt = loop;
249  do {
250  if (TPOINT::IsCrossed(pt1, pt2, pt->pos, pt->next->pos)) return true;
251  pt = pt->next;
252  } while (pt != loop);
253  }
254  return false;
255  }
256  // Returns true if the point is contained within the outline box.
257  bool Contains(const TPOINT& pt) const {
258  return topleft.x <= pt.x && pt.x <= botright.x &&
259  botright.y <= pt.y && pt.y <= topleft.y;
260  }
261 
262  #ifndef GRAPHICS_DISABLED
263  void plot(ScrollView* window, ScrollView::Color color,
264  ScrollView::Color child_color);
265  #endif // GRAPHICS_DISABLED
266 
267  // Returns the first outline point that has a different src_outline to its
268  // predecessor, or, if all the same, the lowest indexed point.
269  EDGEPT* FindBestStartPt() const;
270 
271 
272  int BBArea() const {
273  return (botright.x - topleft.x) * (topleft.y - botright.y);
274  }
275 
276  TPOINT topleft; // Top left of loop.
277  TPOINT botright; // Bottom right of loop.
278  TPOINT start; // Start of loop.
279  bool is_hole; // True if this is a hole/child outline.
280  EDGEPT *loop; // Edgeloop.
281  TESSLINE *next; // Next outline in blob.
282 }; // Outline structure.
283 
284 struct TBLOB {
285  TBLOB() : outlines(nullptr) {}
286  TBLOB(const TBLOB& src) : outlines(nullptr) {
287  CopyFrom(src);
288  }
289  ~TBLOB() {
290  Clear();
291  }
292  TBLOB& operator=(const TBLOB& src) {
293  CopyFrom(src);
294  return *this;
295  }
296  // Factory to build a TBLOB from a C_BLOB with polygonal approximation along
297  // the way. If allow_detailed_fx is true, the EDGEPTs in the returned TBLOB
298  // contain pointers to the input C_OUTLINEs that enable higher-resolution
299  // feature extraction that does not use the polygonal approximation.
300  static TBLOB* PolygonalCopy(bool allow_detailed_fx, C_BLOB* src);
301  // Factory builds a blob with no outlines, but copies the other member data.
302  static TBLOB* ShallowCopy(const TBLOB& src);
303  // Normalizes the blob for classification only if needed.
304  // (Normally this means a non-zero classify rotation.)
305  // If no Normalization is needed, then nullptr is returned, and the input blob
306  // can be used directly. Otherwise a new TBLOB is returned which must be
307  // deleted after use.
309 
310  // Copies the data and the outlines, but leaves next untouched.
311  void CopyFrom(const TBLOB& src);
312  // Deletes owned data.
313  void Clear();
314  // Sets up the built-in DENORM and normalizes the blob in-place.
315  // For parameters see DENORM::SetupNormalization, plus the inverse flag for
316  // this blob and the Pix for the full image.
317  void Normalize(const BLOCK* block,
318  const FCOORD* rotation,
319  const DENORM* predecessor,
320  float x_origin, float y_origin,
321  float x_scale, float y_scale,
322  float final_xshift, float final_yshift,
323  bool inverse, Pix* pix);
324  // Rotates by the given rotation in place.
325  void Rotate(const FCOORD rotation);
326  // Moves by the given vec in place.
327  void Move(const ICOORD vec);
328  // Scales by the given factor in place.
329  void Scale(float factor);
330  // Recomputes the bounding boxes of the outlines.
331  void ComputeBoundingBoxes();
332 
333  // Returns the number of outlines.
334  int NumOutlines() const;
335 
336  TBOX bounding_box() const;
337 
338  // Returns true if the given line segment crosses any outline of this blob.
339  bool SegmentCrossesOutline(const TPOINT& pt1, const TPOINT& pt2) const {
340  for (const TESSLINE* outline = outlines; outline != nullptr;
341  outline = outline->next) {
342  if (outline->SegmentCrosses(pt1, pt2)) return true;
343  }
344  return false;
345  }
346  // Returns true if the point is contained within any of the outline boxes.
347  bool Contains(const TPOINT& pt) const {
348  for (const TESSLINE* outline = outlines; outline != nullptr;
349  outline = outline->next) {
350  if (outline->Contains(pt)) return true;
351  }
352  return false;
353  }
354 
355  // Finds and deletes any duplicate outlines in this blob, without deleting
356  // their EDGEPTs.
358 
359  // Swaps the outlines of *this and next if needed to keep the centers in
360  // increasing x.
361  void CorrectBlobOrder(TBLOB* next);
362 
363  const DENORM& denorm() const {
364  return denorm_;
365  }
366 
367  #ifndef GRAPHICS_DISABLED
368  void plot(ScrollView* window, ScrollView::Color color,
369  ScrollView::Color child_color);
370  #endif // GRAPHICS_DISABLED
371 
372  int BBArea() const {
373  int total_area = 0;
374  for (TESSLINE* outline = outlines; outline != nullptr; outline = outline->next)
375  total_area += outline->BBArea();
376  return total_area;
377  }
378 
379  // Computes the center of mass and second moments for the old baseline and
380  // 2nd moment normalizations. Returns the outline length.
381  // The input denorm should be the normalizations that have been applied from
382  // the image to the current state of this TBLOB.
383  int ComputeMoments(FCOORD* center, FCOORD* second_moments) const;
384  // Computes the precise bounding box of the coords that are generated by
385  // GetEdgeCoords. This may be different from the bounding box of the polygon.
386  void GetPreciseBoundingBox(TBOX* precise_box) const;
387  // Adds edges to the given vectors.
388  // For all the edge steps in all the outlines, or polygonal approximation
389  // where there are no edge steps, collects the steps into x_coords/y_coords.
390  // x_coords is a collection of the x-coords of vertical edges for each
391  // y-coord starting at box.bottom().
392  // y_coords is a collection of the y-coords of horizontal edges for each
393  // x-coord starting at box.left().
394  // Eg x_coords[0] is a collection of the x-coords of edges at y=bottom.
395  // Eg x_coords[1] is a collection of the x-coords of edges at y=bottom + 1.
396  void GetEdgeCoords(const TBOX& box,
397  GenericVector<GenericVector<int> >* x_coords,
398  GenericVector<GenericVector<int> >* y_coords) const;
399 
400  TESSLINE *outlines; // List of outlines in blob.
401 
402  private: // TODO(rays) Someday the data members will be private too.
403  // For all the edge steps in all the outlines, or polygonal approximation
404  // where there are no edge steps, collects the steps into the bounding_box,
405  // llsq and/or the x_coords/y_coords. Both are used in different kinds of
406  // normalization.
407  // For a description of x_coords, y_coords, see GetEdgeCoords above.
408  void CollectEdges(const TBOX& box,
409  TBOX* bounding_box, LLSQ* llsq,
410  GenericVector<GenericVector<int> >* x_coords,
411  GenericVector<GenericVector<int> >* y_coords) const;
412 
413  private:
414  // DENORM indicating the transformations that this blob has undergone so far.
415  DENORM denorm_;
416 }; // Blob structure.
417 
418 struct TWERD {
419  TWERD() : latin_script(false) {}
420  TWERD(const TWERD& src) {
421  CopyFrom(src);
422  }
423  ~TWERD() {
424  Clear();
425  }
426  TWERD& operator=(const TWERD& src) {
427  CopyFrom(src);
428  return *this;
429  }
430  // Factory to build a TWERD from a (C_BLOB) WERD, with polygonal
431  // approximation along the way.
432  static TWERD* PolygonalCopy(bool allow_detailed_fx, WERD* src);
433  // Baseline normalizes the blobs in-place, recording the normalization in the
434  // DENORMs in the blobs.
435  void BLNormalize(const BLOCK* block, const ROW* row, Pix* pix, bool inverse,
436  float x_height, float baseline_shift, bool numeric_mode,
438  const TBOX* norm_box,
439  DENORM* word_denorm);
440  // Copies the data and the blobs, but leaves next untouched.
441  void CopyFrom(const TWERD& src);
442  // Deletes owned data.
443  void Clear();
444  // Recomputes the bounding boxes of the blobs.
445  void ComputeBoundingBoxes();
446 
447  // Returns the number of blobs in the word.
448  int NumBlobs() const {
449  return blobs.size();
450  }
451  TBOX bounding_box() const;
452 
453  // Merges the blobs from start to end, not including end, and deletes
454  // the blobs between start and end.
455  void MergeBlobs(int start, int end);
456 
457  void plot(ScrollView* window);
458 
459  GenericVector<TBLOB*> blobs; // Blobs in word.
460  bool latin_script; // This word is in a latin-based script.
461 };
462 
463 /*----------------------------------------------------------------------
464  F u n c t i o n s
465 ----------------------------------------------------------------------*/
466 // TODO(rays) Make divisible_blob and divide_blobs members of TBLOB.
467 bool divisible_blob(TBLOB *blob, bool italic_blob, TPOINT* location);
468 
469 void divide_blobs(TBLOB *blob, TBLOB *other_blob, bool italic_blob,
470  const TPOINT& location);
471 
472 #endif
CLISTIZEH(STRING) CLISTIZE(STRING) namespace tesseract
Definition: reject.cpp:51
void divide_blobs(TBLOB *blob, TBLOB *other_blob, bool italic_blob, const TPOINT &location)
Definition: blobs.cpp:962
bool divisible_blob(TBLOB *blob, bool italic_blob, TPOINT *location)
Definition: blobs.cpp:913
#define EDGEPTFLAGS
Definition: blobs.h:49
int count(LIST var_list)
Definition: oldlist.cpp:95
void Normalize(float *Values)
int size() const
Definition: genericvector.h:72
Definition: blobs.h:51
int16_t x
Definition: blobs.h:93
void operator/=(int divisor)
Definition: blobs.h:60
void operator+=(const TPOINT &other)
Definition: blobs.h:56
void diff(const TPOINT &p1, const TPOINT &p2)
Definition: blobs.h:73
int16_t y
Definition: blobs.h:94
int dot(const TPOINT &other) const
Definition: blobs.h:84
int length() const
Definition: blobs.h:89
TPOINT(int16_t vx, int16_t vy)
Definition: blobs.h:53
TPOINT(const ICOORD &ic)
Definition: blobs.h:54
bool operator==(const TPOINT &other) const
Definition: blobs.h:64
static bool IsCrossed(const TPOINT &a0, const TPOINT &a1, const TPOINT &b0, const TPOINT &b1)
Definition: blobs.cpp:66
int cross(const TPOINT &other) const
Definition: blobs.h:79
TPOINT()
Definition: blobs.h:52
Definition: blobs.h:99
bool ShortNonCircularSegment(int min_points, const EDGEPT *end) const
Definition: blobs.h:158
EDGEPT(const EDGEPT &src)
Definition: blobs.h:104
int start_step
Definition: blobs.h:196
void Hide()
Definition: blobs.h:170
EDGEPT * next
Definition: blobs.h:192
EDGEPT & operator=(const EDGEPT &src)
Definition: blobs.h:107
int step_count
Definition: blobs.h:197
TBOX SegmentBox(const EDGEPT *end) const
Definition: blobs.h:131
void Reveal()
Definition: blobs.h:173
int SegmentArea(const EDGEPT *end) const
Definition: blobs.h:145
C_OUTLINE * src_outline
Definition: blobs.h:194
bool IsHidden() const
Definition: blobs.h:176
VECTOR vec
Definition: blobs.h:187
void CopyFrom(const EDGEPT &src)
Definition: blobs.h:112
char flags[EDGEPTFLAGS]
Definition: blobs.h:191
EDGEPT * prev
Definition: blobs.h:193
int WeightedDistance(const EDGEPT &other, int x_factor) const
Definition: blobs.h:122
bool EqualPos(const EDGEPT &other) const
Definition: blobs.h:128
EDGEPT()
Definition: blobs.h:100
void MarkChop()
Definition: blobs.h:179
bool IsChopPt() const
Definition: blobs.h:182
TPOINT pos
Definition: blobs.h:186
EDGEPT * loop
Definition: blobs.h:280
~TESSLINE()
Definition: blobs.h:208
TESSLINE * next
Definition: blobs.h:281
TPOINT topleft
Definition: blobs.h:276
TESSLINE & operator=(const TESSLINE &src)
Definition: blobs.h:211
TESSLINE(const TESSLINE &src)
Definition: blobs.h:205
int BBArea() const
Definition: blobs.h:272
bool Contains(const TPOINT &pt) const
Definition: blobs.h:257
TESSLINE()
Definition: blobs.h:204
TPOINT start
Definition: blobs.h:278
TPOINT botright
Definition: blobs.h:277
bool is_hole
Definition: blobs.h:279
bool SameBox(const TESSLINE &other) const
Definition: blobs.h:242
bool SegmentCrosses(const TPOINT &pt1, const TPOINT &pt2) const
Definition: blobs.h:246
Definition: blobs.h:284
bool Contains(const TPOINT &pt) const
Definition: blobs.h:347
void CorrectBlobOrder(TBLOB *next)
Definition: blobs.cpp:501
void Move(const ICOORD vec)
Definition: blobs.cpp:430
void Clear()
Definition: blobs.cpp:386
TESSLINE * outlines
Definition: blobs.h:400
int BBArea() const
Definition: blobs.h:372
TBOX bounding_box() const
Definition: blobs.cpp:468
void GetEdgeCoords(const TBOX &box, GenericVector< GenericVector< int > > *x_coords, GenericVector< GenericVector< int > > *y_coords) const
Definition: blobs.cpp:557
int ComputeMoments(FCOORD *center, FCOORD *second_moments) const
Definition: blobs.cpp:522
void Rotate(const FCOORD rotation)
Definition: blobs.cpp:422
void Normalize(const BLOCK *block, const FCOORD *rotation, const DENORM *predecessor, float x_origin, float y_origin, float x_scale, float y_scale, float final_xshift, float final_yshift, bool inverse, Pix *pix)
Definition: blobs.cpp:397
~TBLOB()
Definition: blobs.h:289
const DENORM & denorm() const
Definition: blobs.h:363
void EliminateDuplicateOutlines()
Definition: blobs.cpp:480
void ComputeBoundingBoxes()
Definition: blobs.cpp:446
void CopyFrom(const TBLOB &src)
Definition: blobs.cpp:370
static TBLOB * PolygonalCopy(bool allow_detailed_fx, C_BLOB *src)
Definition: blobs.cpp:327
void GetPreciseBoundingBox(TBOX *precise_box) const
Definition: blobs.cpp:541
TBLOB * ClassifyNormalizeIfNeeded() const
Definition: blobs.cpp:346
static TBLOB * ShallowCopy(const TBLOB &src)
Definition: blobs.cpp:335
bool SegmentCrossesOutline(const TPOINT &pt1, const TPOINT &pt2) const
Definition: blobs.h:339
void Scale(float factor)
Definition: blobs.cpp:438
TBLOB()
Definition: blobs.h:285
int NumOutlines() const
Definition: blobs.cpp:454
void plot(ScrollView *window, ScrollView::Color color, ScrollView::Color child_color)
Definition: blobs.cpp:510
TBLOB(const TBLOB &src)
Definition: blobs.h:286
TBLOB & operator=(const TBLOB &src)
Definition: blobs.h:292
Definition: blobs.h:418
void MergeBlobs(int start, int end)
Definition: blobs.cpp:872
TWERD()
Definition: blobs.h:419
int NumBlobs() const
Definition: blobs.h:448
TWERD(const TWERD &src)
Definition: blobs.h:420
void BLNormalize(const BLOCK *block, const ROW *row, Pix *pix, bool inverse, float x_height, float baseline_shift, bool numeric_mode, tesseract::OcrEngineMode hint, const TBOX *norm_box, DENORM *word_denorm)
Definition: blobs.cpp:790
~TWERD()
Definition: blobs.h:423
bool latin_script
Definition: blobs.h:460
GenericVector< TBLOB * > blobs
Definition: blobs.h:459
void CopyFrom(const TWERD &src)
Definition: blobs.cpp:839
TWERD & operator=(const TWERD &src)
Definition: blobs.h:426
void Clear()
Definition: blobs.cpp:849
void ComputeBoundingBoxes()
Definition: blobs.cpp:855
TBOX bounding_box() const
Definition: blobs.cpp:861
static TWERD * PolygonalCopy(bool allow_detailed_fx, WERD *src)
Definition: blobs.cpp:776
void plot(ScrollView *window)
Definition: blobs.cpp:897
Definition: linlsq.h:28
Definition: ocrblock.h:31
Definition: ocrrow.h:37
integer coordinate
Definition: points.h:32
Definition: points.h:189
Definition: rect.h:34
void set_right(int x)
Definition: rect.h:82
int16_t top() const
Definition: rect.h:58
void set_bottom(int y)
Definition: rect.h:68
void set_top(int y)
Definition: rect.h:61
int16_t left() const
Definition: rect.h:72
int16_t bottom() const
Definition: rect.h:65
void set_left(int x)
Definition: rect.h:75
int16_t right() const
Definition: rect.h:79
Definition: werd.h:56