Use Leptonica API to access internals of Box

Signed-off-by: Stefan Weil <[email protected]>

src/training/pango/boxchar.cpp

@@ -84,8 +84,10 @@ void BoxChar::TranslateBoxes(int xshift, int yshift, std::vector<BoxChar *> *box
  for (auto &boxe : *boxes) {
  Box *box = boxe->box_;
  if (box != nullptr) {
- box->x += xshift;
- box->y += yshift;
+ int32_t box_x;
+ int32_t box_y;
+ boxGetGeometry(box, &box_x, &box_y, nullptr, nullptr);
+ boxSetGeometry(box, box_x + xshift, box_y + yshift, -1, -1);
  }
  }
 }
@@ -129,10 +131,18 @@ void BoxChar::InsertNewlines(bool rtl_rules, bool vertical_rules, std::vector<Bo
  continue;
  }
  if (prev_i != SIZE_MAX) {
+ int32_t box_x;
+ int32_t box_y;
+ boxGetGeometry(box, &box_x, &box_y, nullptr, nullptr);
  Box *prev_box = (*boxes)[prev_i]->box_;
- int shift = box->x - prev_box->x;
+ int32_t prev_box_x;
+ int32_t prev_box_y;
+ int32_t prev_box_w;
+ int32_t prev_box_h;
+ boxGetGeometry(prev_box, &prev_box_x, &prev_box_y, &prev_box_w, &prev_box_h);
+ int shift = box_x - prev_box_x;
  if (vertical_rules) {
- shift = box->y - prev_box->y;
+ shift = box_y - prev_box_y;
  } else if (rtl_rules) {
  shift = -shift;
  }
@@ -142,15 +152,15 @@ void BoxChar::InsertNewlines(bool rtl_rules, bool vertical_rules, std::vector<Bo
  // a box outside the image by making the width and height 1.
  int width = 1;
  int height = 1;
- int x = prev_box->x + prev_box->w;
- int y = prev_box->y;
+ int x = prev_box_x + prev_box_w;
+ int y = prev_box_y;
  if (vertical_rules) {
- x = prev_box->x;
- y = prev_box->y + prev_box->h;
+ x = prev_box_x;
+ y = prev_box_y + prev_box_h;
  } else if (rtl_rules) {
- x = prev_box->x - width;
+ x = prev_box_x - width;
  if (x < 0) {
- tprintf("prev x = %d, width=%d\n", prev_box->x, width);
+ tprintf("prev x = %d, width=%d\n", prev_box_x, width);
  x = 0;
  }
  }
@@ -184,36 +194,48 @@ void BoxChar::InsertSpaces(bool rtl_rules, bool vertical_rules, std::vector<BoxC
  if (box == nullptr) {
  Box *prev = (*boxes)[i - 1]->box_;
  Box *next = (*boxes)[i + 1]->box_;
+ int32_t prev_x;
+ int32_t prev_y;
+ int32_t prev_w;
+ int32_t prev_h;
+ int32_t next_x;
+ int32_t next_y;
+ int32_t next_w;
+ int32_t next_h;
  ASSERT_HOST(prev != nullptr && next != nullptr);
- int top = std::min(prev->y, next->y);
- int bottom = std::max(prev->y + prev->h, next->y + next->h);
- int left = prev->x + prev->w;
- int right = next->x;
+ boxGetGeometry(prev, &prev_x, &prev_y, &prev_w, &prev_h);
+ boxGetGeometry(next, &next_x, &next_y, &next_w, &next_h);
+ int top = std::min(prev_y, next_y);
+ int bottom = std::max(prev_y + prev_h, next_y + next_h);
+ int left = prev_x + prev_w;
+ int right = next_x;
  if (vertical_rules) {
- top = prev->y + prev->h;
- bottom = next->y;
- left = std::min(prev->x, next->x);
- right = std::max(prev->x + prev->w, next->x + next->w);
+ top = prev_y + prev_h;
+ bottom = next_y;
+ left = std::min(prev_x, next_x);
+ right = std::max(prev_x + prev_w, next_x + next_w);
  } else if (rtl_rules) {
  // With RTL we have to account for BiDi.
  // Right becomes the min left of all prior boxes back to the first
  // space or newline.
- right = prev->x;
- left = next->x + next->w;
+ right = prev_x;
+ left = next_x + next_w;
  for (int j = i - 2; j >= 0 && (*boxes)[j]->ch_ != " " && (*boxes)[j]->ch_ != "\t"; --j) {
  prev = (*boxes)[j]->box_;
  ASSERT_HOST(prev != nullptr);
- if (prev->x < right) {
- right = prev->x;
+ boxGetGeometry(prev, &prev_x, nullptr, nullptr, nullptr);
+ if (prev_x < right) {
+ right = prev_x;
  }
  }
  // Left becomes the max right of all next boxes forward to the first
  // space or newline.
  for (size_t j = i + 2;
  j < boxes->size() && (*boxes)[j]->box_ != nullptr && (*boxes)[j]->ch_ != "\t"; ++j) {
  next = (*boxes)[j]->box_;
- if (next->x + next->w > left) {
- left = next->x + next->w;
+ boxGetGeometry(next, &next_x, nullptr, &next_w, nullptr);
+ if (next_x + next_w > left) {
+ left = next_x + next_w;
  }
  }
  }
@@ -275,8 +297,14 @@ bool BoxChar::MostlyVertical(const std::vector<BoxChar *> &boxes) {
  for (size_t i = 1; i < boxes.size(); ++i) {
  if (boxes[i - 1]->box_ != nullptr && boxes[i]->box_ != nullptr &&
  boxes[i - 1]->page_ == boxes[i]->page_) {
- int dx = boxes[i]->box_->x - boxes[i - 1]->box_->x;
- int dy = boxes[i]->box_->y - boxes[i - 1]->box_->y;
+ int32_t x0;
+ int32_t y0;
+ boxGetGeometry(boxes[i]->box_, &x0, &y0, nullptr, nullptr);
+ int32_t x1;
+ int32_t y1;
+ boxGetGeometry(boxes[i - 1]->box_, &x1, &y1, nullptr, nullptr);
+ int dx = x0 - x1;
+ int dy = y0 - y1;
  if (abs(dx) > abs(dy) * kMinNewlineRatio || abs(dy) > abs(dx) * kMinNewlineRatio) {
  total_dx += dx * dx;
  total_dy += dy * dy;
@@ -337,8 +365,14 @@ std::string BoxChar::GetTesseractBoxStr(int height, const std::vector<BoxChar *>
  tprintf("Error: Call PrepareToWrite before WriteTesseractBoxFile!!\n");
  return "";
  }
- int nbytes = snprintf(buffer, kMaxLineLength, "%s %d %d %d %d %d\n", boxe->ch_.c_str(), box->x,
- height - box->y - box->h, box->x + box->w, height - box->y, boxe->page_);
+ int32_t box_x;
+ int32_t box_y;
+ int32_t box_w;
+ int32_t box_h;
+ boxGetGeometry(const_cast<Box *>(box), &box_x, &box_y, &box_w, &box_h);
+ int nbytes = snprintf(buffer, kMaxLineLength, "%s %d %d %d %d %d\n",
+ boxe->ch_.c_str(), box_x, height - box_y - box_h,
+ box_x + box_w, height - box_y, boxe->page_);
  output.append(buffer, nbytes);
  }
  return output;

src/training/pango/boxchar.h

@@ -26,9 +26,6 @@
 #include <vector>
 
 #include <allheaders.h> // for Leptonica API
-#if (LIBLEPT_MAJOR_VERSION == 1 && LIBLEPT_MINOR_VERSION >= 83) || LIBLEPT_MAJOR_VERSION > 1
-#include <pix_internal.h> // for fast access to Box geometry
-#endif
 #include <tesseract/export.h>
 
 namespace tesseract {
@@ -79,7 +76,11 @@ class BoxChar {
  if (other.box_ == nullptr) {
  return false;
  }
- return box_->x < other.box_->x;
+ int32_t box_x;
+ int32_t other_box_x;
+ boxGetGeometry(box_, &box_x, nullptr, nullptr, nullptr);
+ boxGetGeometry(other.box_, &other_box_x, nullptr, nullptr, nullptr);
+ return box_x < other_box_x;
  }
  // Increments *num_rtl and *num_ltr according to the directionality of
  // characters in the box.

src/training/pango/stringrenderer.cpp

@@ -428,15 +428,25 @@ static void MergeBoxCharsToWords(std::vector<BoxChar *> *boxchars) {
  BoxChar *last_boxchar = result.back();
  // Compute bounding box union
  const Box *box = boxchar->box();
+ int32_t box_x;
+ int32_t box_y;
+ int32_t box_w;
+ int32_t box_h;
+ boxGetGeometry(const_cast<Box *>(box), &box_x, &box_y, &box_w, &box_h);
  Box *last_box = last_boxchar->mutable_box();
- int left = std::min(last_box->x, box->x);
- int right = std::max(last_box->x + last_box->w, box->x + box->w);
- int top = std::min(last_box->y, box->y);
- int bottom = std::max(last_box->y + last_box->h, box->y + box->h);
+ int32_t last_box_x;
+ int32_t last_box_y;
+ int32_t last_box_w;
+ int32_t last_box_h;
+ boxGetGeometry(last_box, &last_box_x, &last_box_y, &last_box_w, &last_box_h);
+ int left = std::min(last_box_x, box_x);
+ int right = std::max(last_box_x + last_box_w, box_x + box_w);
+ int top = std::min(last_box_y, box_y);
+ int bottom = std::max(last_box_y + last_box_h, box_y + box_h);
  // Conclude that the word was broken to span multiple lines based on the
  // size of the merged bounding box in relation to those of the individual
  // characters seen so far.
- if (right - left > last_box->w + 5 * box->w) {
+ if (right - left > last_box_w + 5 * box_w) {
  tlog(1, "Found line break after '%s'", last_boxchar->ch().c_str());
  // Insert a fake interword space and start a new word with the current
  // boxchar.
@@ -447,10 +457,7 @@ static void MergeBoxCharsToWords(std::vector<BoxChar *> *boxchars) {
  }
  // Append to last word
  last_boxchar->mutable_ch()->append(boxchar->ch());
- last_box->x = left;
- last_box->w = right - left;
- last_box->y = top;
- last_box->h = bottom - top;
+ boxSetGeometry(last_box, left, top, right - left, bottom - top);
  delete boxchar;
  boxchar = nullptr;
  }

src/training/text2image.cpp

@@ -282,12 +282,18 @@ static void ExtractFontProperties(const std::string &utf8_text, StringRenderer *
  if (IsWhitespaceBox(boxes[b + 1])) {
  continue;
  }
- int xgap = (boxes[b + 1]->box()->x - (boxes[b]->box()->x + boxes[b]->box()->w));
+ int32_t box_x;
+ int32_t box_w;
+ boxGetGeometry(const_cast<Box *>(boxes[b]->box()), &box_x, nullptr, &box_w, nullptr);
+ int32_t box1_x;
+ int32_t box1_w;
+ boxGetGeometry(const_cast<Box *>(boxes[b + 1]->box()), &box1_x, nullptr, &box1_w, nullptr);
+ int xgap = (box1_x - (box_x + box_w));
  spacing_map_it0 = spacing_map.find(ch0);
  int ok_count = 0;
  if (spacing_map_it0 == spacing_map.end() &&
  render->font().GetSpacingProperties(ch0, &x_bearing, &x_advance)) {
- spacing_map[ch0] = SpacingProperties(x_bearing, x_advance - x_bearing - boxes[b]->box()->w);
+ spacing_map[ch0] = SpacingProperties(x_bearing, x_advance - x_bearing - box_w);
  spacing_map_it0 = spacing_map.find(ch0);
  ++ok_count;
  }
@@ -297,7 +303,7 @@ static void ExtractFontProperties(const std::string &utf8_text, StringRenderer *
  if (spacing_map_it1 == spacing_map.end() &&
  render->font().GetSpacingProperties(ch1, &x_bearing, &x_advance)) {
  spacing_map[ch1] =
- SpacingProperties(x_bearing, x_advance - x_bearing - boxes[b + 1]->box()->w);
+ SpacingProperties(x_bearing, x_advance - x_bearing - box1_w);
  spacing_map_it1 = spacing_map.find(ch1);
  ++ok_count;
  }
@@ -356,10 +362,11 @@ static bool MakeIndividualGlyphs(Image pix, const std::vector<BoxChar *> &vbox,
  if (!b) {
  continue;
  }
- const int x = b->x;
- const int y = b->y;
- const int w = b->w;
- const int h = b->h;
+ int32_t x;
+ int32_t y;
+ int32_t w;
+ int32_t h;
+ boxGetGeometry(b, &x, &y, &w, &h);
  // Check present tiff page (for multipage tiff)
  if (y < y_previous - pixGetHeight(pix) / 10) {
  tprintf("ERROR: Wrap-around encountered, at i=%d\n", i);