tesseract::PangoFontInfo Class Reference

#include <pango_font_info.h>

Public Types
enum	FontTypeEnum { UNKNOWN, SERIF, SANS_SERIF, DECORATIVE }

Public Member Functions
	PangoFontInfo ()
	~PangoFontInfo ()
	PangoFontInfo (const std::string &name)
bool	ParseFontDescriptionName (const std::string &name)
bool	CoversUTF8Text (const char *utf8_text, int byte_length) const
int	DropUncoveredChars (std::string *utf8_text) const
bool	CanRenderString (const char *utf8_word, int len, std::vector< std::string > *graphemes) const
bool	CanRenderString (const char *utf8_word, int len) const
bool	GetSpacingProperties (const std::string &utf8_char, int *x_bearing, int *x_advance) const
std::string	DescriptionName () const
const std::string &	family_name () const
int	font_size () const
FontTypeEnum	font_type () const
int	resolution () const
void	set_resolution (const int resolution)

Static Public Member Functions
static void	SoftInitFontConfig ()
static void	HardInitFontConfig (const std::string &fonts_dir, const std::string &cache_dir)

Friends
class	FontUtils

Detailed Description

Definition at line 39 of file pango_font_info.h.

Member Enumeration Documentation

FontTypeEnum

enum tesseract::PangoFontInfo::FontTypeEnum

Enumerator
UNKNOWN
SERIF
SANS_SERIF
DECORATIVE

Definition at line 41 of file pango_font_info.h.

       :
  enum FontTypeEnum {
    UNKNOWN,
    SERIF,
    SANS_SERIF,
    DECORATIVE,

Constructor & Destructor Documentation

PangoFontInfo() [1/2]

tesseract::PangoFontInfo::PangoFontInfo

(

)

Definition at line 74 of file pango_font_info.cpp.

    : desc_(nullptr), resolution_(kDefaultResolution) {
  Clear();

~PangoFontInfo()

tesseract::PangoFontInfo::~PangoFontInfo

(

)

Definition at line 97 of file pango_font_info.cpp.

PangoFontInfo() [2/2]

tesseract::PangoFontInfo::PangoFontInfo ( const std::string &  name )

explicit

Definition at line 79 of file pango_font_info.cpp.

    : desc_(nullptr), resolution_(kDefaultResolution) {
  if (!ParseFontDescriptionName(desc)) {
    tprintf("ERROR: Could not parse %s\n", desc.c_str());
    Clear();
  }

Member Function Documentation

CanRenderString() [1/2]

bool tesseract::PangoFontInfo::CanRenderString	(	const char *	utf8_word,
		int	len
	)		const

Definition at line 354 of file pango_font_info.cpp.

                                                                        {
  std::vector<std::string> graphemes;
  return CanRenderString(utf8_word, len, &graphemes);

CanRenderString() [2/2]

bool tesseract::PangoFontInfo::CanRenderString	(	const char *	utf8_word,
		int	len,
		std::vector< std::string > *	graphemes
	)		const

Definition at line 359 of file pango_font_info.cpp.

                                                                           {
  if (graphemes) graphemes->clear();
  // We check for font coverage of the text first, as otherwise Pango could
  // (undesirably) fall back to another font that does have the required
  // coverage.
  if (!CoversUTF8Text(utf8_word, len)) {
    return false;
  }
  // U+25CC dotted circle character that often (but not always) gets rendered
  // when there is an illegal grapheme sequence.
  const char32 kDottedCircleGlyph = 9676;
  bool bad_glyph = false;
  PangoFontMap* font_map = pango_cairo_font_map_get_default();
  PangoContext* context = pango_context_new();
  pango_context_set_font_map(context, font_map);
  PangoLayout* layout;
  {
    // Pango is not releasing the cached layout.
    DISABLE_HEAP_LEAK_CHECK;
    layout = pango_layout_new(context);
  }
  if (desc_) {
    pango_layout_set_font_description(layout, desc_);
  } else {
    PangoFontDescription *desc = pango_font_description_from_string(
        DescriptionName().c_str());
    pango_layout_set_font_description(layout, desc);
    pango_font_description_free(desc);
  }
  pango_layout_set_text(layout, utf8_word, len);
  PangoLayoutIter* run_iter = nullptr;
  { // Fontconfig caches some information here that is not freed before exit.
    DISABLE_HEAP_LEAK_CHECK;
    run_iter = pango_layout_get_iter(layout);
  }
  do {
    PangoLayoutRun* run = pango_layout_iter_get_run_readonly(run_iter);
    if (!run) {
      tlog(2, "Found end of line nullptr run marker\n");
      continue;
    }
    PangoGlyph dotted_circle_glyph;
    PangoFont* font = run->item->analysis.font;
 
#ifdef _WIN32
    PangoGlyphString* glyphs = pango_glyph_string_new();
    const char s[] = "\xc2\xa7";
    pango_shape(s, strlen(s), &(run->item->analysis), glyphs);
    dotted_circle_glyph = glyphs->glyphs[0].glyph;
#else  // TODO: Do we need separate solution for non win build?
    dotted_circle_glyph = pango_fc_font_get_glyph(
        reinterpret_cast<PangoFcFont*>(font), kDottedCircleGlyph);
#endif
 
    if (TLOG_IS_ON(2)) {
      PangoFontDescription* desc = pango_font_describe(font);
      char* desc_str = pango_font_description_to_string(desc);
      tlog(2, "Desc of font in run: %s\n", desc_str);
      g_free(desc_str);
      pango_font_description_free(desc);
    }
 
    PangoGlyphItemIter cluster_iter;
    gboolean have_cluster;
    for (have_cluster = pango_glyph_item_iter_init_start(&cluster_iter,
                                                         run, utf8_word);
         have_cluster && !bad_glyph;
         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;
      int start_glyph_index = cluster_iter.start_glyph;
      int end_glyph_index = cluster_iter.end_glyph;
      std::string cluster_text = std::string(utf8_word + start_byte_index,
                                             end_byte_index - start_byte_index);
      if (graphemes) graphemes->push_back(cluster_text);
      if (IsUTF8Whitespace(cluster_text.c_str())) {
        tlog(2, "Skipping whitespace\n");
        continue;
      }
      if (TLOG_IS_ON(2)) {
        printf("start_byte=%d end_byte=%d start_glyph=%d end_glyph=%d ",
               start_byte_index, end_byte_index,
               start_glyph_index, end_glyph_index);
      }
      for (int i = start_glyph_index,
               step = (end_glyph_index > start_glyph_index) ? 1 : -1;
           !bad_glyph && i != end_glyph_index; i+= step) {
        const bool unknown_glyph =
            (cluster_iter.glyph_item->glyphs->glyphs[i].glyph &
             PANGO_GLYPH_UNKNOWN_FLAG);
        const bool illegal_glyph =
            (cluster_iter.glyph_item->glyphs->glyphs[i].glyph ==
             dotted_circle_glyph);
        bad_glyph = unknown_glyph || illegal_glyph;
        if (TLOG_IS_ON(2)) {
          printf("(%d=%d)", cluster_iter.glyph_item->glyphs->glyphs[i].glyph,
                 bad_glyph ? 1 : 0);
        }
      }
      if (TLOG_IS_ON(2)) {
        printf("  '%s'\n", cluster_text.c_str());
      }
      if (bad_glyph)
        tlog(1, "Found illegal glyph!\n");
    }
#ifdef _WIN32
    pango_glyph_string_free(glyphs);
#endif
  } while (!bad_glyph && pango_layout_iter_next_run(run_iter));
 
  pango_layout_iter_free(run_iter);
  g_object_unref(context);
  g_object_unref(layout);
  if (bad_glyph && graphemes) graphemes->clear();
  return !bad_glyph;

CoversUTF8Text()

bool tesseract::PangoFontInfo::CoversUTF8Text	(	const char *	utf8_text,
		int	byte_length
	)		const

Definition at line 216 of file pango_font_info.cpp.

                                                                               {
  PangoFont* font = ToPangoFont();
  if (font == nullptr) {
    // Font not found.
    return false;
  }
  PangoCoverage* coverage = pango_font_get_coverage(font, nullptr);
  for (UNICHAR::const_iterator it = UNICHAR::begin(utf8_text, byte_length);
       it != UNICHAR::end(utf8_text, byte_length);
       ++it) {
    if (IsWhitespace(*it) || pango_is_zero_width(*it))
      continue;
    if (pango_coverage_get(coverage, *it) != PANGO_COVERAGE_EXACT) {
      char tmp[5];
      int len = it.get_utf8(tmp);
      tmp[len] = '\0';
      tlog(2, "'%s' (U+%x) not covered by font\n", tmp, *it);
      pango_coverage_unref(coverage);
      g_object_unref(font);
      return false;
    }
  }
  pango_coverage_unref(coverage);
  g_object_unref(font);
  return true;

DescriptionName()

std::string tesseract::PangoFontInfo::DescriptionName

(

)

const

Definition at line 99 of file pango_font_info.cpp.

                                               {
  if (!desc_) return "";
  char* desc_str = pango_font_description_to_string(desc_);
  std::string desc_name(desc_str);
  g_free(desc_str);
  return desc_name;

DropUncoveredChars()

int tesseract::PangoFontInfo::DropUncoveredChars

(

std::string *

utf8_text

)

const

Definition at line 265 of file pango_font_info.cpp.

                                                                {
  int num_dropped_chars = 0;
  PangoFont* font = ToPangoFont();
  if (font == nullptr) {
    // Font not found, drop all characters.
    num_dropped_chars = utf8_text->length();
    utf8_text->resize(0);
    return num_dropped_chars;
  }
  PangoCoverage* coverage = pango_font_get_coverage(font, nullptr);
  // Maintain two iterators that point into the string. For space efficiency, we
  // will repeatedly copy one covered UTF8 character from one to the other, and
  // at the end resize the string to the right length.
  char* out = const_cast<char*>(utf8_text->c_str());
  const UNICHAR::const_iterator it_begin =
      UNICHAR::begin(utf8_text->c_str(), utf8_text->length());
  const UNICHAR::const_iterator it_end =
      UNICHAR::end(utf8_text->c_str(), utf8_text->length());
  for (UNICHAR::const_iterator it = it_begin; it != it_end;) {
    // Skip bad utf-8.
    if (!it.is_legal()) {
      ++it;  // One suitable error message will still be issued.
      continue;
    }
    int unicode = *it;
    int utf8_len = it.utf8_len();
    const char* utf8_char = it.utf8_data();
    // Move it forward before the data gets modified.
    ++it;
    if (!IsWhitespace(unicode) && !pango_is_zero_width(unicode) &&
        pango_coverage_get(coverage, unicode) != PANGO_COVERAGE_EXACT) {
      if (TLOG_IS_ON(2)) {
        UNICHAR unichar(unicode);
        char* str = unichar.utf8_str();
        tlog(2, "'%s' (U+%x) not covered by font\n", str, unicode);
        delete[] str;
      }
      ++num_dropped_chars;
      continue;
    }
    my_strnmove(out, utf8_char, utf8_len);
    out += utf8_len;
  }
  pango_coverage_unref(coverage);
  g_object_unref(font);
  utf8_text->resize(out - utf8_text->c_str());
  return num_dropped_chars;

family_name()

const std::string& tesseract::PangoFontInfo::family_name ( ) const

inline

Definition at line 100 of file pango_font_info.h.

font_size()

int tesseract::PangoFontInfo::font_size ( ) const

inline

Definition at line 102 of file pango_font_info.h.

{ return font_size_; }

font_type()

FontTypeEnum tesseract::PangoFontInfo::font_type ( ) const

inline

Definition at line 103 of file pango_font_info.h.

{ return font_size_; }

GetSpacingProperties()

bool tesseract::PangoFontInfo::GetSpacingProperties	(	const std::string &	utf8_char,
		int *	x_bearing,
		int *	x_advance
	)		const

Definition at line 314 of file pango_font_info.cpp.

                                                                               {
  // Convert to equivalent PangoFont structure
  PangoFont* font = ToPangoFont();
  // Find the glyph index in the font for the supplied utf8 character.
  int total_advance = 0;
  int min_bearing = 0;
  // Handle multi-unicode strings by reporting the left-most position of the
  // x-bearing, and right-most position of the x-advance if the string were to
  // be rendered.
  const UNICHAR::const_iterator it_begin = UNICHAR::begin(utf8_char.c_str(),
                                                          utf8_char.length());
  const UNICHAR::const_iterator it_end = UNICHAR::end(utf8_char.c_str(),
                                                      utf8_char.length());
  for (UNICHAR::const_iterator it = it_begin; it != it_end; ++it) {
    PangoGlyph glyph_index = pango_fc_font_get_glyph(
        reinterpret_cast<PangoFcFont*>(font), *it);
    if (!glyph_index) {
      // Glyph for given unicode character doesn't exist in font.
      g_object_unref(font);
      return false;
    }
    // Find the ink glyph extents for the glyph
    PangoRectangle ink_rect, logical_rect;
    pango_font_get_glyph_extents(font, glyph_index, &ink_rect, &logical_rect);
    pango_extents_to_pixels(&ink_rect, nullptr);
    pango_extents_to_pixels(&logical_rect, nullptr);
 
    int bearing = total_advance + PANGO_LBEARING(ink_rect);
    if (it == it_begin || bearing < min_bearing) {
      min_bearing = bearing;
    }
    total_advance += PANGO_RBEARING(logical_rect);
  }
  *x_bearing = min_bearing;
  *x_advance = total_advance;
  g_object_unref(font);
  return true;

HardInitFontConfig()

void tesseract::PangoFontInfo::HardInitFontConfig ( const std::string &  fonts_dir, const std::string &  cache_dir  )

static

Definition at line 121 of file pango_font_info.cpp.

                                                                   {
  if (!cache_dir_.empty()) {
    File::DeleteMatchingFiles(
        File::JoinPath(cache_dir_.c_str(), "*cache-?").c_str());
  }
  const int MAX_FONTCONF_FILESIZE = 1024;
  char fonts_conf_template[MAX_FONTCONF_FILESIZE];
  cache_dir_ = cache_dir;
  fonts_dir_ = fonts_dir;
  snprintf(fonts_conf_template, MAX_FONTCONF_FILESIZE,
           "<?xml version=\"1.0\"?>\n"
           "<!DOCTYPE fontconfig SYSTEM \"fonts.dtd\">\n"
           "<fontconfig>\n"
           "<dir>%s</dir>\n"
           "<cachedir>%s</cachedir>\n"
           "<config></config>\n"
           "</fontconfig>",
           fonts_dir.c_str(), cache_dir_.c_str());
  std::string fonts_conf_file = File::JoinPath(cache_dir_.c_str(), "fonts.conf");
  File::WriteStringToFileOrDie(fonts_conf_template, fonts_conf_file);
#ifdef _WIN32
  std::string env("FONTCONFIG_PATH=");
  env.append(cache_dir_.c_str());
  _putenv(env.c_str());
  _putenv("LANG=en_US.utf8");
#else
  setenv("FONTCONFIG_PATH", cache_dir_.c_str(), true);
  // Fix the locale so that the reported font names are consistent.
  setenv("LANG", "en_US.utf8", true);
#endif  // _WIN32
 
  if (FcInitReinitialize() != FcTrue) {
    tprintf("FcInitiReinitialize failed!!\n");
  }
  FontUtils::ReInit();
  // Clear Pango's font cache too.
  pango_cairo_font_map_set_default(nullptr);

ParseFontDescriptionName()

bool tesseract::PangoFontInfo::ParseFontDescriptionName

(

const std::string &

name

)

Definition at line 191 of file pango_font_info.cpp.

                                                                  {
  PangoFontDescription *desc = pango_font_description_from_string(name.c_str());
  bool success = ParseFontDescription(desc);
  pango_font_description_free(desc);
  return success;

resolution()

int tesseract::PangoFontInfo::resolution ( ) const

inline

Definition at line 105 of file pango_font_info.h.

{ return resolution_; }

set_resolution()

void tesseract::PangoFontInfo::set_resolution ( const int  resolution )

inline

Definition at line 106 of file pango_font_info.h.

                         { return resolution_; }
  void set_resolution(const int resolution) {
    resolution_ = resolution;

SoftInitFontConfig()

void tesseract::PangoFontInfo::SoftInitFontConfig ( )

static

Definition at line 111 of file pango_font_info.cpp.

                                       {
  if (fonts_dir_.empty()) {
    HardInitFontConfig(FLAGS_fonts_dir.c_str(),
                       FLAGS_fontconfig_tmpdir.c_str());
  }

Friends And Related Function Documentation

FontUtils

friend class FontUtils

friend

Definition at line 111 of file pango_font_info.h.

---

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

• /tesseract/src/training/pango_font_info.h
• /tesseract/src/training/pango_font_info.cpp