tesseract  4.00.00dev
PAGE_RES_IT Class Reference

#include <pageres.h>

Public Member Functions

 PAGE_RES_IT ()
 
 PAGE_RES_IT (PAGE_RES *the_page_res)
 
bool operator== (const PAGE_RES_IT &other) const
 
bool operator!= (const PAGE_RES_IT &other) const
 
int cmp (const PAGE_RES_IT &other) const
 
WERD_RESrestart_page ()
 
WERD_RESrestart_page_with_empties ()
 
WERD_RESstart_page (bool empty_ok)
 
WERD_RESrestart_row ()
 
WERD_RESInsertSimpleCloneWord (const WERD_RES &clone_res, WERD *new_word)
 
void ReplaceCurrentWord (tesseract::PointerVector< WERD_RES > *words)
 
void DeleteCurrentWord ()
 
void MakeCurrentWordFuzzy ()
 
WERD_RESforward ()
 
WERD_RESforward_with_empties ()
 
WERD_RESforward_paragraph ()
 
WERD_RESforward_block ()
 
WERD_RESprev_word () const
 
ROW_RESprev_row () const
 
BLOCK_RESprev_block () const
 
WERD_RESword () const
 
ROW_RESrow () const
 
BLOCK_RESblock () const
 
WERD_RESnext_word () const
 
ROW_RESnext_row () const
 
BLOCK_RESnext_block () const
 
void rej_stat_word ()
 
void ResetWordIterator ()
 

Public Attributes

PAGE_RESpage_res
 

Detailed Description

Definition at line 659 of file pageres.h.

Constructor & Destructor Documentation

◆ PAGE_RES_IT() [1/2]

PAGE_RES_IT::PAGE_RES_IT ( )
inline

Definition at line 663 of file pageres.h.

663  {
664  } // empty contructor

◆ PAGE_RES_IT() [2/2]

PAGE_RES_IT::PAGE_RES_IT ( PAGE_RES the_page_res)
inline

Definition at line 666 of file pageres.h.

666  { // page result
667  page_res = the_page_res;
668  restart_page(); // ready to scan
669  }
WERD_RES * restart_page()
Definition: pageres.h:686
PAGE_RES * page_res
Definition: pageres.h:661

Member Function Documentation

◆ block()

BLOCK_RES* PAGE_RES_IT::block ( ) const
inline

Definition at line 745 of file pageres.h.

745  { // block of cur. word
746  return block_res;
747  }

◆ cmp()

int PAGE_RES_IT::cmp ( const PAGE_RES_IT other) const

Definition at line 1195 of file pageres.cpp.

1195  {
1196  ASSERT_HOST(page_res == other.page_res);
1197  if (other.block_res == NULL) {
1198  // other points to the end of the page.
1199  if (block_res == NULL)
1200  return 0;
1201  return -1;
1202  }
1203  if (block_res == NULL) {
1204  return 1; // we point to the end of the page.
1205  }
1206  if (block_res == other.block_res) {
1207  if (other.row_res == NULL || row_res == NULL) {
1208  // this should only happen if we hit an image block.
1209  return 0;
1210  }
1211  if (row_res == other.row_res) {
1212  // we point to the same block and row.
1213  ASSERT_HOST(other.word_res != NULL && word_res != NULL);
1214  if (word_res == other.word_res) {
1215  // we point to the same word!
1216  return 0;
1217  }
1218 
1219  WERD_RES_IT word_res_it(&row_res->word_res_list);
1220  for (word_res_it.mark_cycle_pt(); !word_res_it.cycled_list();
1221  word_res_it.forward()) {
1222  if (word_res_it.data() == word_res) {
1223  return -1;
1224  } else if (word_res_it.data() == other.word_res) {
1225  return 1;
1226  }
1227  }
1228  ASSERT_HOST("Error: Incomparable PAGE_RES_ITs" == NULL);
1229  }
1230 
1231  // we both point to the same block, but different rows.
1232  ROW_RES_IT row_res_it(&block_res->row_res_list);
1233  for (row_res_it.mark_cycle_pt(); !row_res_it.cycled_list();
1234  row_res_it.forward()) {
1235  if (row_res_it.data() == row_res) {
1236  return -1;
1237  } else if (row_res_it.data() == other.row_res) {
1238  return 1;
1239  }
1240  }
1241  ASSERT_HOST("Error: Incomparable PAGE_RES_ITs" == NULL);
1242  }
1243 
1244  // We point to different blocks.
1245  BLOCK_RES_IT block_res_it(&page_res->block_res_list);
1246  for (block_res_it.mark_cycle_pt();
1247  !block_res_it.cycled_list(); block_res_it.forward()) {
1248  if (block_res_it.data() == block_res) {
1249  return -1;
1250  } else if (block_res_it.data() == other.block_res) {
1251  return 1;
1252  }
1253  }
1254  // Shouldn't happen...
1255  ASSERT_HOST("Error: Incomparable PAGE_RES_ITs" == NULL);
1256  return 0;
1257 }
ROW_RES_LIST row_res_list
Definition: pageres.h:110
BLOCK_RES_LIST block_res_list
Definition: pageres.h:62
#define ASSERT_HOST(x)
Definition: errcode.h:84
PAGE_RES * page_res
Definition: pageres.h:661
WERD_RES_LIST word_res_list
Definition: pageres.h:131

◆ DeleteCurrentWord()

void PAGE_RES_IT::DeleteCurrentWord ( )

Definition at line 1444 of file pageres.cpp.

1444  {
1445  // Check that this word is as we expect. part_of_combos are NEVER iterated
1446  // by the normal iterator, so we should never be trying to delete them.
1447  ASSERT_HOST(!word_res->part_of_combo);
1448  if (!word_res->combination) {
1449  // Combinations own their own word, so we won't find the word on the
1450  // row's word_list, but it is legitimate to try to delete them.
1451  // Delete word from the ROW when not a combination.
1452  WERD_IT w_it(row()->row->word_list());
1453  for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
1454  if (w_it.data() == word_res->word) {
1455  break;
1456  }
1457  }
1458  ASSERT_HOST(!w_it.cycled_list());
1459  delete w_it.extract();
1460  }
1461  // Remove the WERD_RES for the new_word.
1462  // Remove the WORD_RES from the ROW_RES.
1463  WERD_RES_IT wr_it(&row()->word_res_list);
1464  for (wr_it.mark_cycle_pt(); !wr_it.cycled_list(); wr_it.forward()) {
1465  if (wr_it.data() == word_res) {
1466  word_res = NULL;
1467  break;
1468  }
1469  }
1470  ASSERT_HOST(!wr_it.cycled_list());
1471  delete wr_it.extract();
1473 }
ROW_RES * row() const
Definition: pageres.h:742
#define ASSERT_HOST(x)
Definition: errcode.h:84
BOOL8 combination
Definition: pageres.h:318
BOOL8 part_of_combo
Definition: pageres.h:319
void ResetWordIterator()
Definition: pageres.cpp:1527
WERD * word
Definition: pageres.h:175

◆ forward()

WERD_RES* PAGE_RES_IT::forward ( )
inline

Definition at line 719 of file pageres.h.

719  { // Get next word.
720  return internal_forward(false, false);
721  }

◆ forward_block()

WERD_RES * PAGE_RES_IT::forward_block ( )

Definition at line 1661 of file pageres.cpp.

1661  {
1662  while (block_res == next_block_res) {
1663  internal_forward(false, true);
1664  }
1665  return internal_forward(false, true);
1666 }

◆ forward_paragraph()

WERD_RES * PAGE_RES_IT::forward_paragraph ( )

Definition at line 1646 of file pageres.cpp.

1646  {
1647  while (block_res == next_block_res &&
1648  (next_row_res != NULL && next_row_res->row != NULL &&
1649  row_res->row->para() == next_row_res->row->para())) {
1650  internal_forward(false, true);
1651  }
1652  return internal_forward(false, true);
1653 }
ROW * row
Definition: pageres.h:127
PARA * para() const
Definition: ocrrow.h:115

◆ forward_with_empties()

WERD_RES* PAGE_RES_IT::forward_with_empties ( )
inline

Definition at line 723 of file pageres.h.

723  {
724  return internal_forward(false, true);
725  }

◆ InsertSimpleCloneWord()

WERD_RES * PAGE_RES_IT::InsertSimpleCloneWord ( const WERD_RES clone_res,
WERD new_word 
)

Definition at line 1263 of file pageres.cpp.

1264  {
1265  // Make a WERD_RES for the new_word.
1266  WERD_RES* new_res = new WERD_RES(new_word);
1267  new_res->CopySimpleFields(clone_res);
1268  new_res->combination = true;
1269  // Insert into the appropriate place in the ROW_RES.
1270  WERD_RES_IT wr_it(&row()->word_res_list);
1271  for (wr_it.mark_cycle_pt(); !wr_it.cycled_list(); wr_it.forward()) {
1272  WERD_RES* word = wr_it.data();
1273  if (word == word_res)
1274  break;
1275  }
1276  ASSERT_HOST(!wr_it.cycled_list());
1277  wr_it.add_before_then_move(new_res);
1278  if (wr_it.at_first()) {
1279  // This is the new first word, so reset the member iterator so it
1280  // detects the cycled_list state correctly.
1282  }
1283  return new_res;
1284 }
ROW_RES * row() const
Definition: pageres.h:742
#define ASSERT_HOST(x)
Definition: errcode.h:84
BOOL8 combination
Definition: pageres.h:318
void ResetWordIterator()
Definition: pageres.cpp:1527
WERD_RES * word() const
Definition: pageres.h:739
void CopySimpleFields(const WERD_RES &source)
Definition: pageres.cpp:241

◆ MakeCurrentWordFuzzy()

void PAGE_RES_IT::MakeCurrentWordFuzzy ( )

Definition at line 1477 of file pageres.cpp.

1477  {
1478  WERD* real_word = word_res->word;
1479  if (!real_word->flag(W_FUZZY_SP) && !real_word->flag(W_FUZZY_NON)) {
1480  real_word->set_flag(W_FUZZY_SP, true);
1481  if (word_res->combination) {
1482  // The next word should be the corresponding part of combo, but we have
1483  // already stepped past it, so find it by search.
1484  WERD_RES_IT wr_it(&row()->word_res_list);
1485  for (wr_it.mark_cycle_pt();
1486  !wr_it.cycled_list() && wr_it.data() != word_res; wr_it.forward()) {
1487  }
1488  wr_it.forward();
1489  ASSERT_HOST(wr_it.data()->part_of_combo);
1490  real_word = wr_it.data()->word;
1491  ASSERT_HOST(!real_word->flag(W_FUZZY_SP) &&
1492  !real_word->flag(W_FUZZY_NON));
1493  real_word->set_flag(W_FUZZY_SP, true);
1494  }
1495  }
1496 }
void set_flag(WERD_FLAGS mask, BOOL8 value)
Definition: werd.h:129
ROW_RES * row() const
Definition: pageres.h:742
#define ASSERT_HOST(x)
Definition: errcode.h:84
BOOL8 flag(WERD_FLAGS mask) const
Definition: werd.h:128
BOOL8 combination
Definition: pageres.h:318
WERD * word
Definition: pageres.h:175
Definition: werd.h:60

◆ next_block()

BLOCK_RES* PAGE_RES_IT::next_block ( ) const
inline

Definition at line 754 of file pageres.h.

754  { // block of next word
755  return next_block_res;
756  }

◆ next_row()

ROW_RES* PAGE_RES_IT::next_row ( ) const
inline

Definition at line 751 of file pageres.h.

751  { // row of next word
752  return next_row_res;
753  }

◆ next_word()

WERD_RES* PAGE_RES_IT::next_word ( ) const
inline

Definition at line 748 of file pageres.h.

748  { // next word
749  return next_word_res;
750  }

◆ operator!=()

bool PAGE_RES_IT::operator!= ( const PAGE_RES_IT other) const
inline

Definition at line 678 of file pageres.h.

678 {return !(*this == other); }

◆ operator==()

bool PAGE_RES_IT::operator== ( const PAGE_RES_IT other) const
inline

Definition at line 673 of file pageres.h.

673  {
674  return word_res == other.word_res && row_res == other.row_res &&
675  block_res == other.block_res;
676  }

◆ prev_block()

BLOCK_RES* PAGE_RES_IT::prev_block ( ) const
inline

Definition at line 736 of file pageres.h.

736  { // block of prev word
737  return prev_block_res;
738  }

◆ prev_row()

ROW_RES* PAGE_RES_IT::prev_row ( ) const
inline

Definition at line 733 of file pageres.h.

733  { // row of prev word
734  return prev_row_res;
735  }

◆ prev_word()

WERD_RES* PAGE_RES_IT::prev_word ( ) const
inline

Definition at line 730 of file pageres.h.

730  { // previous word
731  return prev_word_res;
732  }

◆ rej_stat_word()

void PAGE_RES_IT::rej_stat_word ( )

Definition at line 1668 of file pageres.cpp.

1668  {
1669  inT16 chars_in_word;
1670  inT16 rejects_in_word = 0;
1671 
1672  chars_in_word = word_res->reject_map.length ();
1673  page_res->char_count += chars_in_word;
1674  block_res->char_count += chars_in_word;
1675  row_res->char_count += chars_in_word;
1676 
1677  rejects_in_word = word_res->reject_map.reject_count ();
1678 
1679  page_res->rej_count += rejects_in_word;
1680  block_res->rej_count += rejects_in_word;
1681  row_res->rej_count += rejects_in_word;
1682  if (chars_in_word == rejects_in_word)
1683  row_res->whole_word_rej_count += rejects_in_word;
1684 }
inT32 rej_count
Definition: pageres.h:129
inT32 char_count
Definition: pageres.h:60
inT32 rej_count
Definition: pageres.h:61
int16_t inT16
Definition: host.h:36
inT32 length() const
Definition: rejctmap.h:235
inT32 whole_word_rej_count
Definition: pageres.h:130
PAGE_RES * page_res
Definition: pageres.h:661
inT16 reject_count()
Definition: rejctmap.h:241
inT32 rej_count
Definition: pageres.h:101
inT32 char_count
Definition: pageres.h:128
inT32 char_count
Definition: pageres.h:100
REJMAP reject_map
Definition: pageres.h:271

◆ ReplaceCurrentWord()

void PAGE_RES_IT::ReplaceCurrentWord ( tesseract::PointerVector< WERD_RES > *  words)

Definition at line 1316 of file pageres.cpp.

1317  {
1318  if (words->empty()) {
1320  return;
1321  }
1322  WERD_RES* input_word = word();
1323  // Set the BOL/EOL flags on the words from the input word.
1324  if (input_word->word->flag(W_BOL)) {
1325  (*words)[0]->word->set_flag(W_BOL, true);
1326  } else {
1327  (*words)[0]->word->set_blanks(1);
1328  }
1329  words->back()->word->set_flag(W_EOL, input_word->word->flag(W_EOL));
1330 
1331  // Move the blobs from the input word to the new set of words.
1332  // If the input word_res is a combination, then the replacements will also be
1333  // combinations, and will own their own words. If the input word_res is not a
1334  // combination, then the final replacements will not be either, (although it
1335  // is allowed for the input words to be combinations) and their words
1336  // will get put on the row list. This maintains the ownership rules.
1337  WERD_IT w_it(row()->row->word_list());
1338  if (!input_word->combination) {
1339  for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
1340  WERD* word = w_it.data();
1341  if (word == input_word->word)
1342  break;
1343  }
1344  // w_it is now set to the input_word's word.
1345  ASSERT_HOST(!w_it.cycled_list());
1346  }
1347  // Insert into the appropriate place in the ROW_RES.
1348  WERD_RES_IT wr_it(&row()->word_res_list);
1349  for (wr_it.mark_cycle_pt(); !wr_it.cycled_list(); wr_it.forward()) {
1350  WERD_RES* word = wr_it.data();
1351  if (word == input_word)
1352  break;
1353  }
1354  ASSERT_HOST(!wr_it.cycled_list());
1355  // Since we only have an estimate of the bounds between blobs, use the blob
1356  // x-middle as the determiner of where to put the blobs
1357  C_BLOB_IT src_b_it(input_word->word->cblob_list());
1358  src_b_it.sort(&C_BLOB::SortByXMiddle);
1359  C_BLOB_IT rej_b_it(input_word->word->rej_cblob_list());
1360  rej_b_it.sort(&C_BLOB::SortByXMiddle);
1361  for (int w = 0; w < words->size(); ++w) {
1362  WERD_RES* word_w = (*words)[w];
1363  // Compute blob boundaries.
1364  GenericVector<int> blob_ends;
1365  C_BLOB_LIST* next_word_blobs =
1366  w + 1 < words->size() ? (*words)[w + 1]->word->cblob_list() : NULL;
1367  ComputeBlobEnds(*word_w, next_word_blobs, &blob_ends);
1368  // Delete the fake blobs on the current word.
1369  word_w->word->cblob_list()->clear();
1370  C_BLOB_IT dest_it(word_w->word->cblob_list());
1371  // Build the box word as we move the blobs.
1372  tesseract::BoxWord* box_word = new tesseract::BoxWord;
1373  for (int i = 0; i < blob_ends.size(); ++i) {
1374  int end_x = blob_ends[i];
1375  TBOX blob_box;
1376  // Add the blobs up to end_x.
1377  while (!src_b_it.empty() &&
1378  src_b_it.data()->bounding_box().x_middle() < end_x) {
1379  blob_box += src_b_it.data()->bounding_box();
1380  dest_it.add_after_then_move(src_b_it.extract());
1381  src_b_it.forward();
1382  }
1383  while (!rej_b_it.empty() &&
1384  rej_b_it.data()->bounding_box().x_middle() < end_x) {
1385  blob_box += rej_b_it.data()->bounding_box();
1386  dest_it.add_after_then_move(rej_b_it.extract());
1387  rej_b_it.forward();
1388  }
1389  // Clip to the previously computed bounds. Although imperfectly accurate,
1390  // it is good enough, and much more complicated to determine where else
1391  // to clip.
1392  if (i > 0 && blob_box.left() < blob_ends[i - 1])
1393  blob_box.set_left(blob_ends[i - 1]);
1394  if (blob_box.right() > end_x)
1395  blob_box.set_right(end_x);
1396  box_word->InsertBox(i, blob_box);
1397  }
1398  // Fix empty boxes. If a very joined blob sits over multiple characters,
1399  // then we will have some empty boxes from using the middle, so look for
1400  // overlaps.
1401  for (int i = 0; i < box_word->length(); ++i) {
1402  TBOX box = box_word->BlobBox(i);
1403  if (box.null_box()) {
1404  // Nothing has its middle in the bounds of this blob, so use anything
1405  // that overlaps.
1406  for (dest_it.mark_cycle_pt(); !dest_it.cycled_list();
1407  dest_it.forward()) {
1408  TBOX blob_box = dest_it.data()->bounding_box();
1409  if (blob_box.left() < blob_ends[i] &&
1410  (i == 0 || blob_box.right() >= blob_ends[i - 1])) {
1411  if (i > 0 && blob_box.left() < blob_ends[i - 1])
1412  blob_box.set_left(blob_ends[i - 1]);
1413  if (blob_box.right() > blob_ends[i])
1414  blob_box.set_right(blob_ends[i]);
1415  box_word->ChangeBox(i, blob_box);
1416  break;
1417  }
1418  }
1419  }
1420  }
1421  delete word_w->box_word;
1422  word_w->box_word = box_word;
1423  if (!input_word->combination) {
1424  // Insert word_w->word into the ROW. It doesn't own its word, so the
1425  // ROW needs to own it.
1426  w_it.add_before_stay_put(word_w->word);
1427  word_w->combination = false;
1428  }
1429  (*words)[w] = NULL; // We are taking ownership.
1430  wr_it.add_before_stay_put(word_w);
1431  }
1432  // We have taken ownership of the words.
1433  words->clear();
1434  // Delete the current word, which has been replaced. We could just call
1435  // DeleteCurrentWord, but that would iterate both lists again, and we know
1436  // we are already in the right place.
1437  if (!input_word->combination)
1438  delete w_it.extract();
1439  delete wr_it.extract();
1441 }
Definition: werd.h:36
bool empty() const
Definition: genericvector.h:90
int size() const
Definition: genericvector.h:72
tesseract::BoxWord * box_word
Definition: pageres.h:250
ROW_RES * row() const
Definition: pageres.h:742
#define ASSERT_HOST(x)
Definition: errcode.h:84
BOOL8 flag(WERD_FLAGS mask) const
Definition: werd.h:128
inT16 left() const
Definition: rect.h:68
static int SortByXMiddle(const void *v1, const void *v2)
Definition: stepblob.h:119
BOOL8 combination
Definition: pageres.h:318
bool null_box() const
Definition: rect.h:46
void DeleteCurrentWord()
Definition: pageres.cpp:1444
Definition: werd.h:35
void ResetWordIterator()
Definition: pageres.cpp:1527
Definition: rect.h:30
T & back() const
C_BLOB_LIST * cblob_list()
Definition: werd.h:100
WERD * word
Definition: pageres.h:175
inT16 right() const
Definition: rect.h:75
void set_right(int x)
Definition: rect.h:78
void set_left(int x)
Definition: rect.h:71
C_BLOB_LIST * rej_cblob_list()
Definition: werd.h:95
WERD_RES * word() const
Definition: pageres.h:739
Definition: werd.h:60

◆ ResetWordIterator()

void PAGE_RES_IT::ResetWordIterator ( )

Definition at line 1527 of file pageres.cpp.

1527  {
1528  if (row_res == next_row_res) {
1529  // Reset the member iterator so it can move forward and detect the
1530  // cycled_list state correctly.
1531  word_res_it.move_to_first();
1532  for (word_res_it.mark_cycle_pt();
1533  !word_res_it.cycled_list() && word_res_it.data() != next_word_res;
1534  word_res_it.forward()) {
1535  if (!word_res_it.data()->part_of_combo) {
1536  if (prev_row_res == row_res) prev_word_res = word_res;
1537  word_res = word_res_it.data();
1538  }
1539  }
1540  ASSERT_HOST(!word_res_it.cycled_list());
1541  word_res_it.forward();
1542  } else {
1543  // word_res_it is OK, but reset word_res and prev_word_res if needed.
1544  WERD_RES_IT wr_it(&row_res->word_res_list);
1545  for (wr_it.mark_cycle_pt(); !wr_it.cycled_list(); wr_it.forward()) {
1546  if (!wr_it.data()->part_of_combo) {
1547  if (prev_row_res == row_res) prev_word_res = word_res;
1548  word_res = wr_it.data();
1549  }
1550  }
1551  }
1552 }
#define ASSERT_HOST(x)
Definition: errcode.h:84
WERD_RES_LIST word_res_list
Definition: pageres.h:131

◆ restart_page()

WERD_RES* PAGE_RES_IT::restart_page ( )
inline

Definition at line 686 of file pageres.h.

686  {
687  return start_page(false); // Skip empty blocks.
688  }
WERD_RES * start_page(bool empty_ok)
Definition: pageres.cpp:1504

◆ restart_page_with_empties()

WERD_RES* PAGE_RES_IT::restart_page_with_empties ( )
inline

Definition at line 689 of file pageres.h.

689  {
690  return start_page(true); // Allow empty blocks.
691  }
WERD_RES * start_page(bool empty_ok)
Definition: pageres.cpp:1504

◆ restart_row()

WERD_RES * PAGE_RES_IT::restart_row ( )

Definition at line 1631 of file pageres.cpp.

1631  {
1632  ROW_RES *row = this->row();
1633  if (!row) return NULL;
1634  for (restart_page(); this->row() != row; forward()) {
1635  // pass
1636  }
1637  return word();
1638 }
ROW_RES * row() const
Definition: pageres.h:742
WERD_RES * restart_page()
Definition: pageres.h:686
WERD_RES * forward()
Definition: pageres.h:719
WERD_RES * word() const
Definition: pageres.h:739

◆ row()

ROW_RES* PAGE_RES_IT::row ( ) const
inline

Definition at line 742 of file pageres.h.

742  { // row of current word
743  return row_res;
744  }

◆ start_page()

WERD_RES * PAGE_RES_IT::start_page ( bool  empty_ok)

Definition at line 1504 of file pageres.cpp.

1504  {
1505  block_res_it.set_to_list(&page_res->block_res_list);
1506  block_res_it.mark_cycle_pt();
1507  prev_block_res = NULL;
1508  prev_row_res = NULL;
1509  prev_word_res = NULL;
1510  block_res = NULL;
1511  row_res = NULL;
1512  word_res = NULL;
1513  next_block_res = NULL;
1514  next_row_res = NULL;
1515  next_word_res = NULL;
1516  internal_forward(true, empty_ok);
1517  return internal_forward(false, empty_ok);
1518 }
BLOCK_RES_LIST block_res_list
Definition: pageres.h:62
PAGE_RES * page_res
Definition: pageres.h:661

◆ word()

WERD_RES* PAGE_RES_IT::word ( ) const
inline

Definition at line 739 of file pageres.h.

739  { // current word
740  return word_res;
741  }

Member Data Documentation

◆ page_res

PAGE_RES* PAGE_RES_IT::page_res

Definition at line 661 of file pageres.h.


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