tesseract::StringRenderer Class Reference

#include <stringrenderer.h>

Public Member Functions
	StringRenderer (const std::string &font_desc, int page_width, int page_height)
	~StringRenderer ()
int	RenderToImage (const char *text, int text_length, Pix **pix)
int	RenderToGrayscaleImage (const char *text, int text_length, Pix **pix)
int	RenderToBinaryImage (const char *text, int text_length, int threshold, Pix **pix)
int	RenderAllFontsToImage (double min_coverage, const char *text, int text_length, std::string *font_used, Pix **pix)
bool	set_font (const std::string &desc)
void	set_char_spacing (int char_spacing)
void	set_leading (int leading)
void	set_resolution (const int resolution)
void	set_vertical_text (bool vertical_text)
void	set_gravity_hint_strong (bool gravity_hint_strong)
void	set_render_fullwidth_latin (bool render_fullwidth_latin)
void	set_underline_start_prob (const double frac)
void	set_underline_continuation_prob (const double frac)
void	set_underline_style (const PangoUnderline style)
void	set_features (const char *features)
void	set_page (int page)
void	set_box_padding (int val)
void	set_drop_uncovered_chars (bool val)
void	set_strip_unrenderable_words (bool val)
void	set_output_word_boxes (bool val)
void	set_add_ligatures (bool add_ligatures)
void	set_pen_color (double r, double g, double b)
void	set_h_margin (const int h_margin)
void	set_v_margin (const int v_margin)
const PangoFontInfo &	font () const
int	h_margin () const
int	v_margin () const
const std::vector< BoxChar * > &	GetBoxes () const
Boxa *	GetPageBoxes () const
void	RotatePageBoxes (float rotation)
void	ClearBoxes ()
std::string	GetBoxesStr ()
void	WriteAllBoxes (const std::string &filename)
int	StripUnrenderableWords (std::string *utf8_text) const

Static Public Member Functions
static std::string	InsertWordJoiners (const std::string &text)
static std::string	ConvertBasicLatinToFullwidthLatin (const std::string &text)
static std::string	ConvertFullwidthLatinToBasicLatin (const std::string &text)

Protected Member Functions
void	InitPangoCairo ()
void	FreePangoCairo ()
void	SetLayoutProperties ()
void	SetWordUnderlineAttributes (const std::string &page_text)
void	ComputeClusterBoxes ()
void	CorrectBoxPositionsToLayout (std::vector< BoxChar *> *boxchars)
bool	GetClusterStrings (std::vector< std::string > *cluster_text)
int	FindFirstPageBreakOffset (const char *text, int text_length)

Protected Attributes
PangoFontInfo	font_
int	page_width_
int	page_height_
int	h_margin_
int	v_margin_
double	pen_color_ [3]
int	char_spacing_
int	leading_
int	resolution_
bool	vertical_text_
bool	gravity_hint_strong_
bool	render_fullwidth_latin_
double	underline_start_prob_
double	underline_continuation_prob_
PangoUnderline	underline_style_
char *	features_
bool	drop_uncovered_chars_
bool	strip_unrenderable_words_
bool	add_ligatures_
bool	output_word_boxes_
cairo_surface_t *	surface_
cairo_t *	cr_
PangoLayout *	layout_
int	start_box_
int	page_
std::vector< BoxChar * >	boxchars_
int	box_padding_
Boxa *	page_boxes_
std::unordered_map< char32, int64_t >	char_map_
int	total_chars_
unsigned int	font_index_
int	last_offset_

Detailed Description

Definition at line 52 of file stringrenderer.h.

Constructor & Destructor Documentation

StringRenderer()

tesseract::StringRenderer::StringRenderer	(	const std::string &	font_desc,
		int	page_width,
		int	page_height
	)

Definition at line 90 of file stringrenderer.cpp.

    : font_(font_desc),
      page_width_(page_width),
      page_height_(page_height),
      h_margin_(50),
      v_margin_(50),
      pen_color_{0.0, 0.0, 0.0},
      char_spacing_(0),
      leading_(0),
      vertical_text_(false),
      gravity_hint_strong_(false),
      render_fullwidth_latin_(false),
      underline_start_prob_(0),
      underline_continuation_prob_(0),
      underline_style_(PANGO_UNDERLINE_SINGLE),
      features_(nullptr),
      drop_uncovered_chars_(true),
      strip_unrenderable_words_(false),
      add_ligatures_(false),
      output_word_boxes_(false),
      surface_(nullptr),
      cr_(nullptr),
      layout_(nullptr),
      start_box_(0),
      page_(0),
      box_padding_(0),
      page_boxes_(nullptr),
      total_chars_(0),
      font_index_(0),
      last_offset_(0) {
  set_resolution(kDefaultOutputResolution);
  set_font(font_desc);
}

~StringRenderer()

tesseract::StringRenderer::~StringRenderer

(

)

Definition at line 144 of file stringrenderer.cpp.

                                {
  free(features_);
  ClearBoxes();
  FreePangoCairo();
}

Member Function Documentation

ClearBoxes()

void tesseract::StringRenderer::ClearBoxes

(

)

Definition at line 337 of file stringrenderer.cpp.

                                {
  for (size_t i = 0; i < boxchars_.size(); ++i) delete boxchars_[i];
  boxchars_.clear();
  boxaDestroy(&page_boxes_);
}

ComputeClusterBoxes()

void tesseract::StringRenderer::ComputeClusterBoxes ( )

protected

Definition at line 460 of file stringrenderer.cpp.

                                         {
  const char* text = pango_layout_get_text(layout_);
  PangoLayoutIter* cluster_iter = pango_layout_get_iter(layout_);

  // Do a first pass to store cluster start indexes.
  std::vector<int> cluster_start_indices;
  do {
    cluster_start_indices.push_back(pango_layout_iter_get_index(cluster_iter));
    tlog(3, "Added %d\n", cluster_start_indices.back());
  } while (pango_layout_iter_next_cluster(cluster_iter));
  pango_layout_iter_free(cluster_iter);
  cluster_start_indices.push_back(strlen(text));
  tlog(3, "Added last index %d\n", cluster_start_indices.back());
  // Sort the indices and create a map from start to end indices.
  std::sort(cluster_start_indices.begin(), cluster_start_indices.end());
  std::map<int, int> cluster_start_to_end_index;
  for (size_t i = 0; i + 1 < cluster_start_indices.size(); ++i) {
    cluster_start_to_end_index[cluster_start_indices[i]]
        = cluster_start_indices[i + 1];
  }

  // Iterate again to compute cluster boxes and their text with the obtained
  // cluster extent information.
  cluster_iter = pango_layout_get_iter(layout_);
  // Store BoxChars* sorted by their byte start positions
  std::map<int, BoxChar*> start_byte_to_box;
  do {
    PangoRectangle cluster_rect;
    pango_layout_iter_get_cluster_extents(cluster_iter, &cluster_rect, nullptr);
    pango_extents_to_pixels(&cluster_rect, nullptr);
    const int start_byte_index = pango_layout_iter_get_index(cluster_iter);
    const int end_byte_index = cluster_start_to_end_index[start_byte_index];
    std::string cluster_text = std::string(text + start_byte_index,
                                           end_byte_index - start_byte_index);
    if (!cluster_text.empty() && cluster_text[0] == '\n') {
      tlog(2, "Skipping newlines at start of text.\n");
      continue;
    }
    if (!cluster_rect.width || !cluster_rect.height ||
        IsUTF8Whitespace(cluster_text.c_str())) {
      tlog(2, "Skipping whitespace with boxdim (%d,%d) '%s'\n",
           cluster_rect.width, cluster_rect.height, cluster_text.c_str());
      BoxChar* boxchar = new BoxChar(" ", 1);
      boxchar->set_page(page_);
      start_byte_to_box[start_byte_index] = boxchar;
      continue;
    }
    // Prepare a boxchar for addition at this byte position.
    tlog(2, "[%d %d], %d, %d : start_byte=%d end_byte=%d : '%s'\n",
         cluster_rect.x, cluster_rect.y,
         cluster_rect.width, cluster_rect.height,
         start_byte_index, end_byte_index,
         cluster_text.c_str());
    ASSERT_HOST_MSG(cluster_rect.width,
                    "cluster_text:%s  start_byte_index:%d\n",
                    cluster_text.c_str(), start_byte_index);
    ASSERT_HOST_MSG(cluster_rect.height,
                    "cluster_text:%s  start_byte_index:%d\n",
                    cluster_text.c_str(), start_byte_index);
    if (box_padding_) {
      cluster_rect.x = std::max(0, cluster_rect.x - box_padding_);
      cluster_rect.width += 2 * box_padding_;
      cluster_rect.y = std::max(0, cluster_rect.y - box_padding_);
      cluster_rect.height += 2 * box_padding_;
    }
    if (add_ligatures_) {
      // Make sure the output box files have ligatured text in case the font
      // decided to use an unmapped glyph.
      cluster_text = LigatureTable::Get()->AddLigatures(cluster_text, nullptr);
    }
    BoxChar* boxchar = new BoxChar(cluster_text.c_str(), cluster_text.size());
    boxchar->set_page(page_);
    boxchar->AddBox(cluster_rect.x, cluster_rect.y,
                    cluster_rect.width, cluster_rect.height);
    start_byte_to_box[start_byte_index] = boxchar;
  } while (pango_layout_iter_next_cluster(cluster_iter));
  pango_layout_iter_free(cluster_iter);

  // There is a subtle bug in the cluster text reported by the PangoLayoutIter
  // on ligatured characters (eg. The word "Lam-Aliph" in arabic). To work
  // around this, we use text reported using the PangoGlyphIter which is
  // accurate.
  // TODO(ranjith): Revisit whether this is still needed in newer versions of
  // pango.
  std::vector<std::string> cluster_text;
  if (GetClusterStrings(&cluster_text)) {
    ASSERT_HOST(cluster_text.size() == start_byte_to_box.size());
    int ind = 0;
    for (std::map<int, BoxChar*>::iterator it = start_byte_to_box.begin();
         it != start_byte_to_box.end(); ++it, ++ind) {
      it->second->mutable_ch()->swap(cluster_text[ind]);
    }
  }

  // Append to the boxchars list in byte order.
  std::vector<BoxChar*> page_boxchars;
  page_boxchars.reserve(start_byte_to_box.size());
  std::string last_ch;
  for (std::map<int, BoxChar*>::const_iterator it = start_byte_to_box.begin();
       it != start_byte_to_box.end(); ++it) {
    if (it->second->ch() == kWordJoinerUTF8) {
      // Skip zero-width joiner characters (ZWJs) here.
      delete it->second;
    } else {
      page_boxchars.push_back(it->second);
    }
  }
  CorrectBoxPositionsToLayout(&page_boxchars);

  if (render_fullwidth_latin_) {
    for (std::map<int, BoxChar*>::iterator it = start_byte_to_box.begin();
         it != start_byte_to_box.end(); ++it) {
      // Convert fullwidth Latin characters to their halfwidth forms.
      std::string half(ConvertFullwidthLatinToBasicLatin(it->second->ch()));
      it->second->mutable_ch()->swap(half);
    }
  }

  // Merge the character boxes into word boxes if we are rendering n-grams.
  if (output_word_boxes_) {
    MergeBoxCharsToWords(&page_boxchars);
  }

  boxchars_.insert(boxchars_.end(), page_boxchars.begin(), page_boxchars.end());

  // Compute the page bounding box
  Box* page_box = nullptr;
  Boxa* all_boxes = nullptr;
  for (size_t i = 0; i < page_boxchars.size(); ++i) {
    if (page_boxchars[i]->box() == nullptr) continue;
    if (all_boxes == nullptr) all_boxes = boxaCreate(0);
    boxaAddBox(all_boxes, page_boxchars[i]->mutable_box(), L_CLONE);
  }
  if (all_boxes != nullptr) {
    boxaGetExtent(all_boxes, nullptr, nullptr, &page_box);
    boxaDestroy(&all_boxes);
    if (page_boxes_ == nullptr) page_boxes_ = boxaCreate(0);
    boxaAddBox(page_boxes_, page_box, L_INSERT);
  }
}

ConvertBasicLatinToFullwidthLatin()

std::string tesseract::StringRenderer::ConvertBasicLatinToFullwidthLatin ( const std::string &  text )

static

Definition at line 694 of file stringrenderer.cpp.

                                                                                {
  std::string full_str;
  const UNICHAR::const_iterator it_end = UNICHAR::end(str.c_str(),
                                                      str.length());
  for (UNICHAR::const_iterator it = UNICHAR::begin(str.c_str(), str.length());
       it != it_end; ++it) {
    // Convert printable and non-space 7-bit ASCII characters to
    // their fullwidth forms.
    if (IsInterchangeValid7BitAscii(*it) && isprint(*it) && !isspace(*it)) {
      // Convert by adding 0xFEE0 to the codepoint of 7-bit ASCII.
      char32 full_char = *it + 0xFEE0;
      full_str.append(EncodeAsUTF8(full_char));
    } else {
      full_str.append(it.utf8_data(), it.utf8_len());
    }
  }
  return full_str;
}

ConvertFullwidthLatinToBasicLatin()

std::string tesseract::StringRenderer::ConvertFullwidthLatinToBasicLatin ( const std::string &  text )

static

Definition at line 714 of file stringrenderer.cpp.

                                                                                {
  std::string half_str;
  UNICHAR::const_iterator it_end = UNICHAR::end(str.c_str(), str.length());
  for (UNICHAR::const_iterator it = UNICHAR::begin(str.c_str(), str.length());
       it != it_end; ++it) {
    char32 half_char = FullwidthToHalfwidth(*it);
    // Convert fullwidth Latin characters to their halfwidth forms
    // only if halfwidth forms are printable and non-space 7-bit ASCII.
    if (IsInterchangeValid7BitAscii(half_char) &&
        isprint(half_char) && !isspace(half_char)) {
      half_str.append(EncodeAsUTF8(half_char));
    } else {
      half_str.append(it.utf8_data(), it.utf8_len());
    }
  }
  return half_str;
}

CorrectBoxPositionsToLayout()

void tesseract::StringRenderer::CorrectBoxPositionsToLayout ( std::vector< BoxChar *> *  boxchars )

protected

Definition at line 602 of file stringrenderer.cpp.

                                   {
  if (vertical_text_) {
    const double rotation = - pango_gravity_to_rotation(
        pango_context_get_base_gravity(pango_layout_get_context(layout_)));
    BoxChar::TranslateBoxes(page_width_ - h_margin_, v_margin_, boxchars);
    BoxChar::RotateBoxes(rotation, page_width_ - h_margin_, v_margin_,
                         0, boxchars->size(), boxchars);
  } else {
    BoxChar::TranslateBoxes(h_margin_, v_margin_, boxchars);
  }
}

FindFirstPageBreakOffset()

int tesseract::StringRenderer::FindFirstPageBreakOffset ( const char *  text, int  text_length  )

protected

Definition at line 279 of file stringrenderer.cpp.

                                                              {
  if (!text_length) return 0;
  const int max_height = (page_height_ - 2 * v_margin_);
  const int max_width = (page_width_ - 2 * h_margin_);
  const int max_layout_height = vertical_text_ ? max_width : max_height;

  UNICHAR::const_iterator it = UNICHAR::begin(text, text_length);
  const UNICHAR::const_iterator it_end = UNICHAR::end(text, text_length);
  const int kMaxUnicodeBufLength = 15000;
  for (int i = 0; i < kMaxUnicodeBufLength && it != it_end; ++it, ++i);
  int buf_length = it.utf8_data() - text;
  tlog(1, "len = %d  buf_len = %d\n", text_length, buf_length);
  pango_layout_set_text(layout_, text, buf_length);

  PangoLayoutIter* line_iter = nullptr;
  { // Fontconfig caches some info here that is not freed before exit.
    DISABLE_HEAP_LEAK_CHECK;
    line_iter = pango_layout_get_iter(layout_);
  }
  bool first_page = true;
  int page_top = 0;
  int offset = buf_length;
  do {
    // Get bounding box of the current line
    PangoRectangle line_ink_rect;
    pango_layout_iter_get_line_extents(line_iter, &line_ink_rect, nullptr);
    pango_extents_to_pixels(&line_ink_rect, nullptr);
    PangoLayoutLine* line = pango_layout_iter_get_line_readonly(line_iter);
    if (first_page) {
      page_top = line_ink_rect.y;
      first_page = false;
    }
    int line_bottom = line_ink_rect.y + line_ink_rect.height;
    if (line_bottom - page_top > max_layout_height) {
      offset = line->start_index;
      tlog(1, "Found offset = %d\n", offset);
      break;
    }
  } while (pango_layout_iter_next_line(line_iter));
  pango_layout_iter_free(line_iter);
  return offset;
}

font()

const PangoFontInfo& tesseract::StringRenderer::font ( ) const

inline

Definition at line 133 of file stringrenderer.h.

                                    {
    return font_;
  }

FreePangoCairo()

void tesseract::StringRenderer::FreePangoCairo ( )

protected

Definition at line 218 of file stringrenderer.cpp.

                                    {
  if (layout_) {
    g_object_unref(layout_);
    layout_ = nullptr;
  }
  if (cr_) {
    cairo_destroy(cr_);
    cr_ = nullptr;
  }
  if (surface_) {
    cairo_surface_destroy(surface_);
    surface_ = nullptr;
  }
}

GetBoxes()

const std::vector< BoxChar * > & tesseract::StringRenderer::GetBoxes

(

)

const

Definition at line 323 of file stringrenderer.cpp.

                                                          {
    return boxchars_;
}

GetBoxesStr()

std::string tesseract::StringRenderer::GetBoxesStr

(

)

Definition at line 343 of file stringrenderer.cpp.

                                      {
  BoxChar::PrepareToWrite(&boxchars_);
  return BoxChar::GetTesseractBoxStr(page_height_, boxchars_);
}

GetClusterStrings()

bool tesseract::StringRenderer::GetClusterStrings ( std::vector< std::string > *  cluster_text )

protected

Definition at line 354 of file stringrenderer.cpp.

                                                                         {
  std::map<int, std::string> start_byte_to_text;
  PangoLayoutIter* run_iter = pango_layout_get_iter(layout_);
  const char* full_text = pango_layout_get_text(layout_);
  do {
    PangoLayoutRun* run = pango_layout_iter_get_run_readonly(run_iter);
    if (!run) {
      // End of line nullptr run marker
      tlog(2, "Found end of line marker\n");
      continue;
    }
    PangoGlyphItemIter cluster_iter;
    gboolean have_cluster;
    for (have_cluster = pango_glyph_item_iter_init_start(&cluster_iter,
                                                          run, full_text);
         have_cluster;
         have_cluster = pango_glyph_item_iter_next_cluster(&cluster_iter)) {
      const int start_byte_index = cluster_iter.start_index;
      const int end_byte_index = cluster_iter.end_index;
      std::string text = std::string(full_text + start_byte_index,
                                     end_byte_index - start_byte_index);
      if (IsUTF8Whitespace(text.c_str())) {
        tlog(2, "Found whitespace\n");
        text = " ";
      }
      tlog(2, "start_byte=%d end_byte=%d : '%s'\n", start_byte_index,
           end_byte_index, text.c_str());
      if (add_ligatures_) {
        // Make sure the output box files have ligatured text in case the font
        // decided to use an unmapped glyph.
        text = LigatureTable::Get()->AddLigatures(text, nullptr);
      }
      start_byte_to_text[start_byte_index] = text;
    }
  } while (pango_layout_iter_next_run(run_iter));
  pango_layout_iter_free(run_iter);

  cluster_text->clear();
  for (std::map<int, std::string>::const_iterator it = start_byte_to_text.begin();
       it != start_byte_to_text.end(); ++it) {
    cluster_text->push_back(it->second);
  }
  return !cluster_text->empty();
}

GetPageBoxes()

Boxa * tesseract::StringRenderer::GetPageBoxes

(

)

const

Definition at line 327 of file stringrenderer.cpp.

                                         {
    return page_boxes_;
}

h_margin()

int tesseract::StringRenderer::h_margin ( ) const

inline

Definition at line 136 of file stringrenderer.h.

{ return h_margin_; }

InitPangoCairo()

void tesseract::StringRenderer::InitPangoCairo ( )

protected

Definition at line 150 of file stringrenderer.cpp.

                                    {
  FreePangoCairo();
  surface_ = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, page_width_,
                                        page_height_);
  cr_ = cairo_create(surface_);
  {
    DISABLE_HEAP_LEAK_CHECK;
    layout_ = pango_cairo_create_layout(cr_);
  }

  if (vertical_text_) {
    PangoContext* context = pango_layout_get_context(layout_);
    pango_context_set_base_gravity(context, PANGO_GRAVITY_EAST);
    if (gravity_hint_strong_) {
      pango_context_set_gravity_hint(context, PANGO_GRAVITY_HINT_STRONG);
    }
    pango_layout_context_changed(layout_);
  }

  SetLayoutProperties();
}

InsertWordJoiners()

std::string tesseract::StringRenderer::InsertWordJoiners ( const std::string &  text )

static

Definition at line 671 of file stringrenderer.cpp.

                                                                 {
  std::string out_str;
  const UNICHAR::const_iterator it_end = UNICHAR::end(text.c_str(),
                                                      text.length());
  for (UNICHAR::const_iterator it = UNICHAR::begin(text.c_str(), text.length());
       it != it_end; ++it) {
    // Add the symbol to the output string.
    out_str.append(it.utf8_data(), it.utf8_len());
    // Check the next symbol.
    UNICHAR::const_iterator next_it = it;
    ++next_it;
    bool next_char_is_boundary = (next_it == it_end || *next_it == ' ');
    bool next_char_is_combiner = (next_it == it_end) ?
        false : IsCombiner(*next_it);
    if (*it != ' ' && *it != '\n' && !next_char_is_boundary &&
        !next_char_is_combiner) {
      out_str += kWordJoinerUTF8;
    }
  }
  return out_str;
}

RenderAllFontsToImage()

int tesseract::StringRenderer::RenderAllFontsToImage	(	double	min_coverage,
		const char *	text,
		int	text_length,
		std::string *	font_used,
		Pix **	pix
	)

Definition at line 834 of file stringrenderer.cpp.

                                                                             {
  *image = nullptr;
  // Select a suitable font to render the title with.
  const char kTitleTemplate[] = "%s : %d hits = %.2f%%, raw = %d = %.2f%%";
  std::string title_font;
  if (!FontUtils::SelectFont(kTitleTemplate, strlen(kTitleTemplate),
                             &title_font, nullptr)) {
    tprintf("WARNING: Could not find a font to render image title with!\n");
    title_font = "Arial";
  }
  title_font += " 8";
  tlog(1, "Selected title font: %s\n", title_font.c_str());
  if (font_used) font_used->clear();

  std::string orig_font = font_.DescriptionName();
  if (char_map_.empty()) {
    total_chars_ = 0;
    // Fill the hash table and use that for computing which fonts to use.
    for (UNICHAR::const_iterator it = UNICHAR::begin(text, text_length);
         it != UNICHAR::end(text, text_length); ++it) {
      ++total_chars_;
      ++char_map_[*it];
    }
    tprintf("Total chars = %d\n", total_chars_);
  }
  const std::vector<std::string>& all_fonts = FontUtils::ListAvailableFonts();

  for (size_t i = font_index_; i < all_fonts.size(); ++i) {
    ++font_index_;
    int raw_score = 0;
    int ok_chars =
        FontUtils::FontScore(char_map_, all_fonts[i], &raw_score, nullptr);
    if (ok_chars > 0 && ok_chars >= total_chars_ * min_coverage) {
      set_font(all_fonts[i]);
      int offset = RenderToBinaryImage(text, text_length, 128, image);
      ClearBoxes();  // Get rid of them as they are garbage.
      const int kMaxTitleLength = 1024;
      char title[kMaxTitleLength];
      snprintf(title, kMaxTitleLength, kTitleTemplate,
               all_fonts[i].c_str(), ok_chars,
               100.0 * ok_chars / total_chars_, raw_score,
               100.0 * raw_score / char_map_.size());
      tprintf("%s\n", title);
      // This is a good font! Store the offset to return once we've tried all
      // the fonts.
      if (offset) {
        last_offset_ = offset;
        if (font_used) *font_used = all_fonts[i];
      }
      // Add the font to the image.
      set_font(title_font);
      v_margin_ /= 8;
      Pix* title_image = nullptr;
      RenderToBinaryImage(title, strlen(title), 128, &title_image);
      pixOr(*image, *image, title_image);
      pixDestroy(&title_image);

      v_margin_ *= 8;
      set_font(orig_font);
      // We return the real offset only after cycling through the list of fonts.
      return 0;
    } else {
      tprintf("Font %s failed with %d hits = %.2f%%\n",
              all_fonts[i].c_str(), ok_chars, 100.0 * ok_chars / total_chars_);
    }
  }
  font_index_ = 0;
  char_map_.clear();
  return last_offset_ == 0 ? -1 : last_offset_;
}

RenderToBinaryImage()

int tesseract::StringRenderer::RenderToBinaryImage	(	const char *	text,
		int	text_length,
		int	threshold,
		Pix **	pix
	)

Definition at line 653 of file stringrenderer.cpp.

                                                                  {
  Pix* orig_pix = nullptr;
  int offset = RenderToImage(text, text_length, &orig_pix);
  if (orig_pix) {
    Pix* gray_pix = pixConvertTo8(orig_pix, false);
    pixDestroy(&orig_pix);
    *pix = pixThresholdToBinary(gray_pix, threshold);
    pixDestroy(&gray_pix);
  } else {
    *pix = orig_pix;
  }
  return offset;
}

RenderToGrayscaleImage()

int tesseract::StringRenderer::RenderToGrayscaleImage	(	const char *	text,
		int	text_length,
		Pix **	pix
	)

Definition at line 642 of file stringrenderer.cpp.

                                                      {
  Pix* orig_pix = nullptr;
  int offset = RenderToImage(text, text_length, &orig_pix);
  if (orig_pix) {
    *pix = pixConvertTo8(orig_pix, false);
    pixDestroy(&orig_pix);
  }
  return offset;
}

RenderToImage()

int tesseract::StringRenderer::RenderToImage	(	const char *	text,
		int	text_length,
		Pix **	pix
	)

Definition at line 733 of file stringrenderer.cpp.

                                             {
  if (pix && *pix) pixDestroy(pix);
  InitPangoCairo();

  const int page_offset = FindFirstPageBreakOffset(text, text_length);
  if (!page_offset) {
    return 0;
  }
  start_box_ = boxchars_.size();

  if (!vertical_text_) {
    // Translate by the specified margin
    cairo_translate(cr_, h_margin_, v_margin_);
  } else {
    // Vertical text rendering is achieved by a two-step process of first
    // performing regular horizontal layout with character orientation set to
    // EAST, and then translating and rotating the layout before rendering onto
    // the desired image surface. The settings required for the former step are
    // done within InitPangoCairo().
    //
    // Translate to the top-right margin of page
    cairo_translate(cr_, page_width_ - h_margin_, v_margin_);
    // Rotate the layout
    double rotation = - pango_gravity_to_rotation(
        pango_context_get_base_gravity(pango_layout_get_context(layout_)));
    tlog(2, "Rotating by %f radians\n", rotation);
    cairo_rotate(cr_, rotation);
    pango_cairo_update_layout(cr_, layout_);
  }
  std::string page_text(text, page_offset);
  if (render_fullwidth_latin_) {
    // Convert Basic Latin to their fullwidth forms.
    page_text = ConvertBasicLatinToFullwidthLatin(page_text);
  }
  if (strip_unrenderable_words_) {
    StripUnrenderableWords(&page_text);
  }
  if (drop_uncovered_chars_ &&
      !font_.CoversUTF8Text(page_text.c_str(), page_text.length())) {
    int num_dropped = font_.DropUncoveredChars(&page_text);
    if (num_dropped) {
      tprintf("WARNING: Dropped %d uncovered characters\n", num_dropped);
    }
  }
  if (add_ligatures_) {
    // Add ligatures wherever possible, including custom ligatures.
    page_text = LigatureTable::Get()->AddLigatures(page_text, &font_);
  }
  if (underline_start_prob_ > 0) {
    SetWordUnderlineAttributes(page_text);
  }

  pango_layout_set_text(layout_, page_text.c_str(), page_text.length());

  if (pix) {
    // Set a white background for the target image surface.
    cairo_set_source_rgb(cr_, 1.0, 1.0, 1.0);  // sets drawing colour to white
    // Fill the surface with the active colour (if you don't do this, you will
    // be given a surface with a transparent background to draw on)
    cairo_paint(cr_);
    // Set the ink color to black
    cairo_set_source_rgb(cr_, pen_color_[0], pen_color_[1], pen_color_[2]);
    // If the target surface or transformation properties of the cairo instance
    // have changed, update the pango layout to reflect this
    pango_cairo_update_layout(cr_, layout_);
    {
      DISABLE_HEAP_LEAK_CHECK;  // for Fontconfig
      // Draw the pango layout onto the cairo surface
      pango_cairo_show_layout(cr_, layout_);
    }
    *pix = CairoARGB32ToPixFormat(surface_);
  }
  ComputeClusterBoxes();
  FreePangoCairo();
  // Update internal state variables.
  ++page_;
  return page_offset;
}

RotatePageBoxes()

void tesseract::StringRenderer::RotatePageBoxes

(

float

rotation

)

Definition at line 331 of file stringrenderer.cpp.

                                                   {
  BoxChar::RotateBoxes(rotation, page_width_ / 2, page_height_ / 2,
                       start_box_, boxchars_.size(), &boxchars_);
}

set_add_ligatures()

void tesseract::StringRenderer::set_add_ligatures ( bool  add_ligatures )

inline

Definition at line 118 of file stringrenderer.h.

                                             {
    add_ligatures_ = add_ligatures;
  }

set_box_padding()

void tesseract::StringRenderer::set_box_padding ( int  val )

inline

Definition at line 103 of file stringrenderer.h.

                                {
    box_padding_ = val;
  }

set_char_spacing()

void tesseract::StringRenderer::set_char_spacing ( int  char_spacing )

inline

Definition at line 72 of file stringrenderer.h.

{ char_spacing_ = char_spacing; }

set_drop_uncovered_chars()

void tesseract::StringRenderer::set_drop_uncovered_chars ( bool  val )

inline

Definition at line 106 of file stringrenderer.h.

                                          {
    drop_uncovered_chars_ = val;
  }

set_features()

void tesseract::StringRenderer::set_features ( const char *  features )

inline

Definition at line 96 of file stringrenderer.h.

                                          {
    free(features_);
    features_ = strdup(features);
  }

set_font()

bool tesseract::StringRenderer::set_font

(

const std::string &

desc

)

Definition at line 125 of file stringrenderer.cpp.

                                                   {
  bool success = font_.ParseFontDescriptionName(desc);
  font_.set_resolution(resolution_);
  return success;
}

set_gravity_hint_strong()

void tesseract::StringRenderer::set_gravity_hint_strong ( bool  gravity_hint_strong )

inline

Definition at line 80 of file stringrenderer.h.

                                                         {
    gravity_hint_strong_ = gravity_hint_strong;
  }

set_h_margin()

void tesseract::StringRenderer::set_h_margin ( const int  h_margin )

inline

Definition at line 127 of file stringrenderer.h.

                                        {
    h_margin_ = h_margin;
  }

set_leading()

void tesseract::StringRenderer::set_leading ( int  leading )

inline

Definition at line 73 of file stringrenderer.h.

                                {
    leading_ = leading;
  }

set_output_word_boxes()

void tesseract::StringRenderer::set_output_word_boxes ( bool  val )

inline

Definition at line 112 of file stringrenderer.h.

                                       {
    output_word_boxes_ = val;
  }

set_page()

void tesseract::StringRenderer::set_page ( int  page )

inline

Definition at line 100 of file stringrenderer.h.

                          {
    page_ = page;
  }

set_pen_color()

void tesseract::StringRenderer::set_pen_color ( double  r, double  g, double  b  )

inline

Definition at line 122 of file stringrenderer.h.

                                                   {
    pen_color_[0] = r;
    pen_color_[1] = g;
    pen_color_[2] = b;
  }

set_render_fullwidth_latin()

void tesseract::StringRenderer::set_render_fullwidth_latin ( bool  render_fullwidth_latin )

inline

Definition at line 83 of file stringrenderer.h.

                                                               {
    render_fullwidth_latin_ = render_fullwidth_latin;
  }

set_resolution()

void tesseract::StringRenderer::set_resolution

(

const int

resolution

)

Definition at line 131 of file stringrenderer.cpp.

                                                        {
  resolution_ = resolution;
  font_.set_resolution(resolution);
}

set_strip_unrenderable_words()

void tesseract::StringRenderer::set_strip_unrenderable_words ( bool  val )

inline

Definition at line 109 of file stringrenderer.h.

                                              {
    strip_unrenderable_words_ = val;
  }

set_underline_continuation_prob()

void tesseract::StringRenderer::set_underline_continuation_prob

(

const double

frac

)

Definition at line 140 of file stringrenderer.cpp.

                                                                      {
  underline_continuation_prob_ = std::min(std::max(frac, 0.0), 1.0);
}

set_underline_start_prob()

void tesseract::StringRenderer::set_underline_start_prob

(

const double

frac

)

Definition at line 136 of file stringrenderer.cpp.

                                                               {
  underline_start_prob_ = std::min(std::max(frac, 0.0), 1.0);
}

set_underline_style()

void tesseract::StringRenderer::set_underline_style ( const PangoUnderline  style )

inline

Definition at line 93 of file stringrenderer.h.

                                                       {
    underline_style_ = style;
  }

set_v_margin()

void tesseract::StringRenderer::set_v_margin ( const int  v_margin )

inline

Definition at line 130 of file stringrenderer.h.

                                        {
    v_margin_ = v_margin;
  }

set_vertical_text()

void tesseract::StringRenderer::set_vertical_text ( bool  vertical_text )

inline

Definition at line 77 of file stringrenderer.h.

                                             {
    vertical_text_ = vertical_text;
  }

SetLayoutProperties()

void tesseract::StringRenderer::SetLayoutProperties ( )

protected

Definition at line 172 of file stringrenderer.cpp.

                                         {
  std::string font_desc = font_.DescriptionName();
  // Specify the font via a description name
  PangoFontDescription *desc =
      pango_font_description_from_string(font_desc.c_str());
  // Assign the font description to the layout
  pango_layout_set_font_description(layout_, desc);
  pango_font_description_free(desc);  // free the description
  pango_cairo_context_set_resolution(pango_layout_get_context(layout_),
                                     resolution_);

  int max_width = page_width_ - 2 * h_margin_;
  int max_height = page_height_ - 2 * v_margin_;
  tlog(3, "max_width = %d, max_height = %d\n", max_width, max_height);
  if (vertical_text_) {
    using std::swap;
    swap(max_width, max_height);
  }
  pango_layout_set_width(layout_, max_width * PANGO_SCALE);
  // Ultra-wide Thai strings need to wrap at char level.
  pango_layout_set_wrap(layout_, PANGO_WRAP_WORD_CHAR);

  // Adjust character spacing
  PangoAttrList* attr_list = pango_attr_list_new();
  if (char_spacing_) {
    PangoAttribute* spacing_attr =
        pango_attr_letter_spacing_new(char_spacing_ * PANGO_SCALE);
    spacing_attr->start_index = 0;
    spacing_attr->end_index = static_cast<guint>(-1);
    pango_attr_list_change(attr_list, spacing_attr);
  }
#if (PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 38)
  if (add_ligatures_) {
    set_features("liga, clig, dlig, hlig");
    PangoAttribute* feature_attr = pango_attr_font_features_new(features_);
    pango_attr_list_change(attr_list, feature_attr);
  }
#endif
  pango_layout_set_attributes(layout_, attr_list);
  pango_attr_list_unref(attr_list);
  // Adjust line spacing
  if (leading_) {
    pango_layout_set_spacing(layout_, leading_ * PANGO_SCALE);
  }
}

SetWordUnderlineAttributes()

void tesseract::StringRenderer::SetWordUnderlineAttributes ( const std::string &  page_text )

protected

Definition at line 233 of file stringrenderer.cpp.

                                                                          {
  if (underline_start_prob_ == 0) return;
  PangoAttrList* attr_list = pango_layout_get_attributes(layout_);

  const char* text = page_text.c_str();
  size_t offset = 0;
  TRand rand;
  bool started_underline = false;
  PangoAttribute* und_attr = nullptr;

  while (offset < page_text.length()) {
    offset += SpanUTF8Whitespace(text + offset);
    if (offset == page_text.length()) break;

    int word_start = offset;
    int word_len = SpanUTF8NotWhitespace(text + offset);
    offset += word_len;
    if (started_underline) {
      // Should we continue the underline to the next word?
      if (RandBool(underline_continuation_prob_, &rand)) {
        // Continue the current underline to this word.
        und_attr->end_index = word_start + word_len;
      } else {
        // Otherwise end the current underline attribute at the end of the
        // previous word.
        pango_attr_list_insert(attr_list, und_attr);
        started_underline = false;
        und_attr = nullptr;
      }
    }
    if (!started_underline && RandBool(underline_start_prob_, &rand)) {
      // Start a new underline attribute
      und_attr = pango_attr_underline_new(underline_style_);
      und_attr->start_index = word_start;
      und_attr->end_index = word_start + word_len;
      started_underline = true;
    }
  }
  // Finish the current underline attribute at the end of the page.
  if (started_underline) {
    und_attr->end_index = page_text.length();
    pango_attr_list_insert(attr_list, und_attr);
  }
}

StripUnrenderableWords()

int tesseract::StringRenderer::StripUnrenderableWords

(

std::string *

utf8_text

)

const

Definition at line 615 of file stringrenderer.cpp.

                                                                     {
  std::string output_text;
  const char* text = utf8_text->c_str();
  size_t offset = 0;
  int num_dropped = 0;
  while (offset < utf8_text->length()) {
    int space_len = SpanUTF8Whitespace(text + offset);
    output_text.append(text + offset, space_len);
    offset += space_len;
    if (offset == utf8_text->length()) break;

    int word_len = SpanUTF8NotWhitespace(text + offset);
    if (font_.CanRenderString(text + offset, word_len)) {
      output_text.append(text + offset, word_len);
    } else {
      ++num_dropped;
    }
    offset += word_len;
  }
  utf8_text->swap(output_text);

  if (num_dropped > 0) {
    tprintf("Stripped %d unrenderable words\n", num_dropped);
  }
  return num_dropped;
}

v_margin()

int tesseract::StringRenderer::v_margin ( ) const

inline

Definition at line 137 of file stringrenderer.h.

{ return v_margin_; }

WriteAllBoxes()

void tesseract::StringRenderer::WriteAllBoxes

(

const std::string &

filename

)

Definition at line 348 of file stringrenderer.cpp.

                                                            {
  BoxChar::PrepareToWrite(&boxchars_);
  BoxChar::WriteTesseractBoxFile(filename, page_height_, boxchars_);
}

Member Data Documentation

add_ligatures_

bool tesseract::StringRenderer::add_ligatures_

protected

Definition at line 198 of file stringrenderer.h.

box_padding_

int tesseract::StringRenderer::box_padding_

protected

Definition at line 211 of file stringrenderer.h.

boxchars_

std::vector<BoxChar*> tesseract::StringRenderer::boxchars_

protected

Definition at line 210 of file stringrenderer.h.

char_map_

std::unordered_map<char32, int64_t> tesseract::StringRenderer::char_map_

protected

Definition at line 216 of file stringrenderer.h.

char_spacing_

int tesseract::StringRenderer::char_spacing_

protected

Definition at line 186 of file stringrenderer.h.

cr_

cairo_t* tesseract::StringRenderer::cr_

protected

Definition at line 202 of file stringrenderer.h.

drop_uncovered_chars_

bool tesseract::StringRenderer::drop_uncovered_chars_

protected

Definition at line 196 of file stringrenderer.h.

features_

char* tesseract::StringRenderer::features_

protected

Definition at line 194 of file stringrenderer.h.

font_

PangoFontInfo tesseract::StringRenderer::font_

protected

Definition at line 181 of file stringrenderer.h.

font_index_

unsigned int tesseract::StringRenderer::font_index_

protected

Definition at line 218 of file stringrenderer.h.

gravity_hint_strong_

bool tesseract::StringRenderer::gravity_hint_strong_

protected

Definition at line 189 of file stringrenderer.h.

h_margin_

int tesseract::StringRenderer::h_margin_

protected

Definition at line 183 of file stringrenderer.h.

last_offset_

int tesseract::StringRenderer::last_offset_

protected

Definition at line 219 of file stringrenderer.h.

layout_

PangoLayout* tesseract::StringRenderer::layout_

protected

Definition at line 203 of file stringrenderer.h.

leading_

int tesseract::StringRenderer::leading_

protected

Definition at line 187 of file stringrenderer.h.

output_word_boxes_

bool tesseract::StringRenderer::output_word_boxes_

protected

Definition at line 199 of file stringrenderer.h.

page_

int tesseract::StringRenderer::page_

protected

Definition at line 207 of file stringrenderer.h.

page_boxes_

Boxa* tesseract::StringRenderer::page_boxes_

protected

Definition at line 213 of file stringrenderer.h.

page_height_

int tesseract::StringRenderer::page_height_

protected

Definition at line 183 of file stringrenderer.h.

page_width_

int tesseract::StringRenderer::page_width_

protected

Definition at line 183 of file stringrenderer.h.

pen_color_

double tesseract::StringRenderer::pen_color_[3]

protected

Definition at line 185 of file stringrenderer.h.

render_fullwidth_latin_

bool tesseract::StringRenderer::render_fullwidth_latin_

protected

Definition at line 190 of file stringrenderer.h.

resolution_

int tesseract::StringRenderer::resolution_

protected

Definition at line 187 of file stringrenderer.h.

start_box_

int tesseract::StringRenderer::start_box_

protected

Definition at line 206 of file stringrenderer.h.

strip_unrenderable_words_

bool tesseract::StringRenderer::strip_unrenderable_words_

protected

Definition at line 197 of file stringrenderer.h.

surface_

cairo_surface_t* tesseract::StringRenderer::surface_

protected

Definition at line 201 of file stringrenderer.h.

total_chars_

int tesseract::StringRenderer::total_chars_

protected

Definition at line 217 of file stringrenderer.h.

underline_continuation_prob_

double tesseract::StringRenderer::underline_continuation_prob_

protected

Definition at line 192 of file stringrenderer.h.

underline_start_prob_

double tesseract::StringRenderer::underline_start_prob_

protected

Definition at line 191 of file stringrenderer.h.

underline_style_

PangoUnderline tesseract::StringRenderer::underline_style_

protected

Definition at line 193 of file stringrenderer.h.

v_margin_

int tesseract::StringRenderer::v_margin_

protected

Definition at line 183 of file stringrenderer.h.

vertical_text_

bool tesseract::StringRenderer::vertical_text_

protected

Definition at line 188 of file stringrenderer.h.

---

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

• /usr/src/tesseract-ocr.master/src/training/stringrenderer.h
• /usr/src/tesseract-ocr.master/src/training/stringrenderer.cpp