Tesseract
3.02
Main Page
Related Pages
Modules
Namespaces
Classes
Files
File List
File Members
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Groups
Pages
blobs.h
Go to the documentation of this file.
1
/* -*-C-*-
2
********************************************************************************
3
*
4
* File: blobs.h (Formerly blobs.h)
5
* Description: Blob definition
6
* Author: Mark Seaman, OCR Technology
7
* Created: Fri Oct 27 15:39:52 1989
8
* Modified: Thu Mar 28 15:33:38 1991 (Mark Seaman) marks@hpgrlt
9
* Language: C
10
* Package: N/A
11
* Status: Experimental (Do Not Distribute)
12
*
13
* (c) Copyright 1989, Hewlett-Packard Company.
14
** Licensed under the Apache License, Version 2.0 (the "License");
15
** you may not use this file except in compliance with the License.
16
** You may obtain a copy of the License at
17
** http://www.apache.org/licenses/LICENSE-2.0
18
** Unless required by applicable law or agreed to in writing, software
19
** distributed under the License is distributed on an "AS IS" BASIS,
20
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21
** See the License for the specific language governing permissions and
22
** limitations under the License.
23
*
24
*********************************************************************************/
25
26
#ifndef BLOBS_H
27
#define BLOBS_H
28
29
/*----------------------------------------------------------------------
30
I n c l u d e s
31
----------------------------------------------------------------------*/
32
#include "
clst.h
"
33
#include "
rect.h
"
34
#include "
vecfuncs.h
"
35
36
class
BLOCK
;
37
class
C_BLOB
;
38
class
DENORM
;
39
class
ROW
;
40
class
WERD
;
41
42
/*----------------------------------------------------------------------
43
T y p e s
44
----------------------------------------------------------------------*/
45
#define EDGEPTFLAGS 4
/*concavity,length etc. */
46
47
typedef
struct
48
{
/* Widths of pieces */
49
int
num_chars
;
50
int
widths[1];
51
}
WIDTH_RECORD
;
52
53
struct
TPOINT
{
54
TPOINT
():
x
(0),
y
(0) {}
55
TPOINT
(
inT16
vx,
inT16
vy) :
x
(vx),
y
(vy) {}
56
TPOINT
(
const
ICOORD
&ic) :
x
(ic.
x
()),
y
(ic.
y
()) {}
57
58
void
operator+=
(
const
TPOINT
& other) {
59
x
+= other.
x
;
60
y
+= other.
y
;
61
}
62
void
operator/=
(
int
divisor) {
63
x
/= divisor;
64
y
/= divisor;
65
}
66
67
inT16
x
;
// absolute x coord.
68
inT16
y
;
// absolute y coord.
69
};
70
typedef
TPOINT
VECTOR
;
// structure for coordinates.
71
72
struct
EDGEPT
{
73
EDGEPT
() :
next
(
NULL
),
prev
(
NULL
) {
74
memset(
flags
, 0,
EDGEPTFLAGS
*
sizeof
(
flags
[0]));
75
}
76
EDGEPT
(
const
EDGEPT
& src) :
next
(
NULL
),
prev
(
NULL
) {
77
CopyFrom
(src);
78
}
79
EDGEPT
&
operator=
(
const
EDGEPT
& src) {
80
CopyFrom
(src);
81
return
*
this
;
82
}
83
// Copies the data elements, but leaves the pointers untouched.
84
void
CopyFrom
(
const
EDGEPT
& src) {
85
pos
= src.
pos
;
86
vec
= src.
vec
;
87
memcpy(
flags
, src.
flags
,
EDGEPTFLAGS
*
sizeof
(
flags
[0]));
88
}
89
// Accessors to hide or reveal a cut edge from feature extractors.
90
void
Hide
() {
91
flags
[0] =
true
;
92
}
93
void
Reveal
() {
94
flags
[0] =
false
;
95
}
96
bool
IsHidden
()
const
{
97
return
flags
[0] != 0;
98
}
99
100
TPOINT
pos
;
// position
101
VECTOR
vec
;
// vector to next point
102
// TODO(rays) Remove flags and replace with
103
// is_hidden, runlength, dir, and fixed. The only use
104
// of the flags other than is_hidden is in polyaprx.cpp.
105
char
flags
[
EDGEPTFLAGS
];
// concavity, length etc
106
EDGEPT
*
next
;
// anticlockwise element
107
EDGEPT
*
prev
;
// clockwise element
108
};
109
110
// For use in chop and findseam to keep a list of which EDGEPTs were inserted.
111
CLISTIZEH
(
EDGEPT
);
112
113
struct
TESSLINE
{
114
TESSLINE
() :
is_hole
(false),
loop
(
NULL
),
next
(
NULL
) {}
115
TESSLINE
(
const
TESSLINE
& src) :
loop
(
NULL
),
next
(
NULL
) {
116
CopyFrom
(src);
117
}
118
~TESSLINE
() {
119
Clear
();
120
}
121
TESSLINE
&
operator=
(
const
TESSLINE
& src) {
122
CopyFrom
(src);
123
return
*
this
;
124
}
125
// Consume the circular list of EDGEPTs to make a TESSLINE.
126
static
TESSLINE
*
BuildFromOutlineList
(
EDGEPT
* outline);
127
// Copies the data and the outline, but leaves next untouched.
128
void
CopyFrom
(
const
TESSLINE
& src);
129
// Deletes owned data.
130
void
Clear
();
131
// Normalize in-place using the DENORM.
132
void
Normalize
(
const
DENORM
& denorm);
133
// Rotates by the given rotation in place.
134
void
Rotate
(
const
FCOORD
rotation);
135
// Moves by the given vec in place.
136
void
Move
(
const
ICOORD
vec);
137
// Scales by the given factor in place.
138
void
Scale
(
float
factor);
139
// Sets up the start and vec members of the loop from the pos members.
140
void
SetupFromPos
();
141
// Recomputes the bounding box from the points in the loop.
142
void
ComputeBoundingBox
();
143
// Computes the min and max cross product of the outline points with the
144
// given vec and returns the results in min_xp and max_xp. Geometrically
145
// this is the left and right edge of the outline perpendicular to the
146
// given direction, but to get the distance units correct, you would
147
// have to divide by the modulus of vec.
148
void
MinMaxCrossProduct
(
const
TPOINT
vec,
int
* min_xp,
int
* max_xp)
const
;
149
150
TBOX
bounding_box
()
const
;
151
// Returns true if the point is contained within the outline box.
152
bool
Contains
(
const
TPOINT
& pt) {
153
return
topleft
.
x
<= pt.
x
&& pt.
x
<=
botright
.
x
&&
154
botright
.
y
<= pt.
y
&& pt.
y
<=
topleft
.
y
;
155
}
156
157
#ifndef GRAPHICS_DISABLED
158
void
plot
(
ScrollView
* window,
ScrollView::Color
color,
159
ScrollView::Color
child_color);
160
#endif // GRAPHICS_DISABLED
161
162
int
BBArea
()
const
{
163
return
(
botright
.
x
-
topleft
.
x
) * (
topleft
.
y
-
botright
.
y
);
164
}
165
166
TPOINT
topleft
;
// Top left of loop.
167
TPOINT
botright
;
// Bottom right of loop.
168
TPOINT
start
;
// Start of loop.
169
bool
is_hole
;
// True if this is a hole/child outline.
170
EDGEPT
*
loop
;
// Edgeloop.
171
TESSLINE
*
next
;
// Next outline in blob.
172
};
// Outline structure.
173
174
struct
TBLOB
{
175
TBLOB
() :
outlines
(
NULL
),
next
(
NULL
) {}
176
TBLOB
(
const
TBLOB
& src) :
outlines
(
NULL
),
next
(
NULL
) {
177
CopyFrom
(src);
178
}
179
~TBLOB
() {
180
Clear
();
181
}
182
TBLOB
&
operator=
(
const
TBLOB
& src) {
183
CopyFrom
(src);
184
return
*
this
;
185
}
186
// Factory to build a TBLOB from a C_BLOB with polygonal
187
// approximation along the way.
188
static
TBLOB
*
PolygonalCopy
(
C_BLOB
* src);
189
// Normalizes the blob for classification only if needed.
190
// (Normally this means a non-zero classify rotation.)
191
// If no Normalization is needed, then NULL is returned, and the denorm is
192
// unchanged. Otherwise a new TBLOB is returned and the denorm points to
193
// a new DENORM. In this case, both the TBLOB and DENORM must be deleted.
194
TBLOB
*
ClassifyNormalizeIfNeeded
(
const
DENORM
** denorm)
const
;
195
// Copies the data and the outlines, but leaves next untouched.
196
void
CopyFrom
(
const
TBLOB
& src);
197
// Deletes owned data.
198
void
Clear
();
199
// Normalize in-place using the DENORM.
200
void
Normalize
(
const
DENORM
& denorm);
201
// Rotates by the given rotation in place.
202
void
Rotate
(
const
FCOORD
rotation);
203
// Moves by the given vec in place.
204
void
Move
(
const
ICOORD
vec);
205
// Scales by the given factor in place.
206
void
Scale
(
float
factor);
207
// Recomputes the bounding boxes of the outlines.
208
void
ComputeBoundingBoxes
();
209
210
// Returns the number of outlines.
211
int
NumOutlines
()
const
;
212
213
TBOX
bounding_box
()
const
;
214
215
#ifndef GRAPHICS_DISABLED
216
void
plot
(
ScrollView
* window,
ScrollView::Color
color,
217
ScrollView::Color
child_color);
218
#endif // GRAPHICS_DISABLED
219
220
int
BBArea
()
const
{
221
int
total_area = 0;
222
for
(
TESSLINE
* outline =
outlines
; outline !=
NULL
; outline = outline->next)
223
total_area += outline->BBArea();
224
return
total_area;
225
}
226
227
TESSLINE
*
outlines
;
// List of outlines in blob.
228
TBLOB
*
next
;
// Next blob in block.
229
};
// Blob structure.
230
231
int
count_blobs
(
TBLOB
*blobs);
232
233
struct
TWERD
{
234
TWERD
() :
blobs
(
NULL
),
latin_script
(false),
next
(
NULL
) {}
235
TWERD
(
const
TWERD
& src) :
blobs
(
NULL
),
next
(
NULL
) {
236
CopyFrom
(src);
237
}
238
~TWERD
() {
239
Clear
();
240
}
241
TWERD
&
operator=
(
const
TWERD
& src) {
242
CopyFrom
(src);
243
return
*
this
;
244
}
245
// Factory to build a TWERD from a (C_BLOB) WERD, with polygonal
246
// approximation along the way.
247
static
TWERD
*
PolygonalCopy
(
WERD
* src);
248
// Setup for Baseline normalization, recording the normalization in the
249
// DENORM, but doesn't do any normalization.
250
void
SetupBLNormalize
(
const
BLOCK
* block,
const
ROW
* row,
251
float
x_height,
bool
numeric_mode,
252
DENORM
* denorm)
const
;
253
// Normalize in-place using the DENORM.
254
void
Normalize
(
const
DENORM
& denorm);
255
// Copies the data and the blobs, but leaves next untouched.
256
void
CopyFrom
(
const
TWERD
& src);
257
// Deletes owned data.
258
void
Clear
();
259
// Recomputes the bounding boxes of the blobs.
260
void
ComputeBoundingBoxes
();
261
262
// Returns the number of blobs in the word.
263
int
NumBlobs
()
const
{
264
return
count_blobs
(
blobs
);
265
}
266
TBOX
bounding_box
()
const
;
267
268
// Merges the blobs from start to end, not including end, and deletes
269
// the blobs between start and end.
270
void
MergeBlobs
(
int
start,
int
end);
271
272
void
plot
(
ScrollView
* window);
273
274
TBLOB
*
blobs
;
// blobs in word.
275
bool
latin_script
;
// This word is in a latin-based script.
276
TWERD
*
next
;
// next word.
277
};
278
279
/*----------------------------------------------------------------------
280
M a c r o s
281
----------------------------------------------------------------------*/
282
/**********************************************************************
283
* free_widths
284
*
285
* Free the memory taken up by a width array.
286
**********************************************************************/
287
#define free_widths(w) \
288
if (w) memfree (w)
289
290
/*----------------------------------------------------------------------
291
F u n c t i o n s
292
----------------------------------------------------------------------*/
293
// TODO(rays) This will become a member of TBLOB when TBLOB's definition
294
// moves to blobs.h
295
296
// Returns the center of blob's bounding box in origin.
297
void
blob_origin
(
TBLOB
*blob,
TPOINT
*origin);
298
299
/*blob to compute on */
300
WIDTH_RECORD
*
blobs_widths
(
TBLOB
*blobs);
301
302
bool
divisible_blob
(
TBLOB
*blob,
bool
italic_blob,
TPOINT
* location);
303
304
void
divide_blobs
(
TBLOB
*blob,
TBLOB
*other_blob,
bool
italic_blob,
305
const
TPOINT
& location);
306
307
#endif
mnt
data
src
tesseract-ocr
ccstruct
blobs.h
Generated on Thu Nov 1 2012 20:19:44 for Tesseract by
1.8.1