tesseract::FontUtils Class Reference

#include <pango_font_info.h>

Static Public Member Functions
static bool	IsAvailableFont (const char *font_desc)
static bool	IsAvailableFont (const char *font_desc, std::string *best_match)
static const std::vector< std::string > &	ListAvailableFonts ()
static bool	SelectFont (const char *utf8_word, const int utf8_len, std::string *font_name, std::vector< std::string > *graphemes)
static bool	SelectFont (const char *utf8_word, const int utf8_len, const std::vector< std::string > &all_fonts, std::string *font_name, std::vector< std::string > *graphemes)
static std::string	BestFonts (const std::unordered_map< char32, int64_t > &ch_map, std::vector< std::pair< const char *, std::vector< bool > > > *font_flag)
static int	FontScore (const std::unordered_map< char32, int64_t > &ch_map, const std::string &fontname, int *raw_score, std::vector< bool > *ch_flags)
static void	ReInit ()
static void	PangoFontTypeInfo ()

Detailed Description

Definition at line 153 of file pango_font_info.h.

Member Function Documentation

BestFonts()

std::string tesseract::FontUtils::BestFonts ( const std::unordered_map< char32, int64_t > &  ch_map, std::vector< std::pair< const char *, std::vector< bool > > > *  font_flag  )

static

Definition at line 612 of file pango_font_info.cpp.

                                                                                           {
  const double kMinOKFraction = 0.99;
  // Weighted fraction of characters that must be renderable in a font to make
  // it OK even if the raw count is not good.
  const double kMinWeightedFraction = 0.99995;
 
  fonts->clear();
  std::vector<std::vector<bool>> font_flags;
  std::vector<int> font_scores;
  std::vector<int> raw_scores;
  int most_ok_chars = 0;
  int best_raw_score = 0;
  const std::vector<std::string> &font_names = FontUtils::ListAvailableFonts();
  for (const auto &font_name : font_names) {
    std::vector<bool> ch_flags;
    int raw_score = 0;
    int ok_chars = FontScore(ch_map, font_name, &raw_score, &ch_flags);
    most_ok_chars = std::max(ok_chars, most_ok_chars);
    best_raw_score = std::max(raw_score, best_raw_score);
 
    font_flags.push_back(ch_flags);
    font_scores.push_back(ok_chars);
    raw_scores.push_back(raw_score);
  }
 
  // Now select the fonts with a score above a threshold fraction
  // of both the raw and weighted best scores. To prevent bogus fonts being
  // selected for CJK, we require a high fraction (kMinOKFraction = 0.99) of
  // BOTH weighted and raw scores.
  // In low character-count scripts, the issue is more getting enough fonts,
  // when only 1 or 2 might have all those rare dingbats etc in them, so we
  // allow a font with a very high weighted (coverage) score
  // (kMinWeightedFraction = 0.99995) to be used even if its raw score is poor.
  int least_good_enough = static_cast<int>(most_ok_chars * kMinOKFraction);
  int least_raw_enough = static_cast<int>(best_raw_score * kMinOKFraction);
  int override_enough = static_cast<int>(most_ok_chars * kMinWeightedFraction);
 
  std::string font_list;
  for (unsigned i = 0; i < font_names.size(); ++i) {
    int score = font_scores[i];
    int raw_score = raw_scores[i];
    if ((score >= least_good_enough && raw_score >= least_raw_enough) || score >= override_enough) {
      fonts->push_back(std::make_pair(font_names[i].c_str(), font_flags[i]));
      tlog(1, "OK font %s = %.4f%%, raw = %d = %.2f%%\n", font_names[i].c_str(),
           100.0 * score / most_ok_chars, raw_score, 100.0 * raw_score / best_raw_score);
      font_list += font_names[i];
      font_list += "\n";
    } else if (score >= least_good_enough || raw_score >= least_raw_enough) {
      tlog(1, "Runner-up font %s = %.4f%%, raw = %d = %.2f%%\n", font_names[i].c_str(),
           100.0 * score / most_ok_chars, raw_score, 100.0 * raw_score / best_raw_score);
    }
  }
  return font_list;
}

FontScore()

int tesseract::FontUtils::FontScore ( const std::unordered_map< char32, int64_t > &  ch_map, const std::string &  fontname, int *  raw_score, std::vector< bool > *  ch_flags  )

static

Definition at line 577 of file pango_font_info.cpp.

                                                                                               {
  PangoFontInfo font_info;
  if (!font_info.ParseFontDescriptionName(fontname)) {
    tprintf("ERROR: Could not parse %s\n", fontname.c_str());
  }
  PangoFont *font = font_info.ToPangoFont();
  PangoCoverage *coverage = nullptr;
  if (font != nullptr) {
    coverage = pango_font_get_coverage(font, nullptr);
  }
  if (ch_flags) {
    ch_flags->clear();
    ch_flags->reserve(ch_map.size());
  }
  *raw_score = 0;
  int ok_chars = 0;
  for (auto &&it : ch_map) {
    bool covered =
        (coverage != nullptr) && (IsWhitespace(it.first) ||
                                  (pango_coverage_get(coverage, it.first) == PANGO_COVERAGE_EXACT));
    if (covered) {
      ++(*raw_score);
      ok_chars += it.second;
    }
    if (ch_flags) {
      ch_flags->push_back(covered);
    }
  }
  pango_coverage_unref(coverage);
  g_object_unref(font);
  return ok_chars;
}

IsAvailableFont() [1/2]

static bool tesseract::FontUtils::IsAvailableFont ( const char *  font_desc )

inlinestatic

Definition at line 157 of file pango_font_info.h.

                                                     {
    return IsAvailableFont(font_desc, nullptr);
  }

IsAvailableFont() [2/2]

bool tesseract::FontUtils::IsAvailableFont ( const char *  font_desc, std::string *  best_match  )

static

Definition at line 480 of file pango_font_info.cpp.

                                                                                   {
  std::string query_desc(input_query_desc);
  PangoFontDescription *desc = pango_font_description_from_string(query_desc.c_str());
  PangoFont *selected_font = nullptr;
  {
    PangoFontInfo::SoftInitFontConfig();
    PangoFontMap *font_map = pango_cairo_font_map_get_default();
    PangoContext *context = pango_context_new();
    pango_context_set_font_map(context, font_map);
    {
      DISABLE_HEAP_LEAK_CHECK;
      selected_font = pango_font_map_load_font(font_map, context, desc);
    }
    g_object_unref(context);
  }
  if (selected_font == nullptr) {
    pango_font_description_free(desc);
    tlog(4, "** Font '%s' failed to load from font map!\n", input_query_desc);
    return false;
  }
  PangoFontDescription *selected_desc = pango_font_describe(selected_font);
 
  bool equal = pango_font_description_equal(desc, selected_desc);
  tlog(3, "query weight = %d \t selected weight =%d\n", pango_font_description_get_weight(desc),
       pango_font_description_get_weight(selected_desc));
 
  char *selected_desc_str = pango_font_description_to_string(selected_desc);
  tlog(2, "query_desc: '%s' Selected: '%s'\n", query_desc.c_str(), selected_desc_str);
  if (!equal && best_match != nullptr) {
    *best_match = selected_desc_str;
    // Clip the ending ' 0' if there is one. It seems that, if there is no
    // point size on the end of the fontname, then Pango always appends ' 0'.
    int len = best_match->size();
    if (len > 2 && best_match->at(len - 1) == '0' && best_match->at(len - 2) == ' ') {
      *best_match = best_match->substr(0, len - 2);
    }
  }
  g_free(selected_desc_str);
  pango_font_description_free(selected_desc);
  g_object_unref(selected_font);
  pango_font_description_free(desc);
  if (!equal)
    tlog(4, "** Font '%s' failed pango_font_description_equal!\n", input_query_desc);
  return equal;
}

ListAvailableFonts()

const std::vector< std::string > & tesseract::FontUtils::ListAvailableFonts ( )

static

Definition at line 539 of file pango_font_info.cpp.

                                                          {
  if (!available_fonts_.empty()) {
    return available_fonts_;
  }
 
  PangoFontFamily **families = nullptr;
  int n_families = 0;
  ListFontFamilies(&families, &n_families);
  for (int i = 0; i < n_families; ++i) {
    const char *family_name = pango_font_family_get_name(families[i]);
    tlog(2, "Listing family %s\n", family_name);
    if (ShouldIgnoreFontFamilyName(family_name)) {
      continue;
    }
 
    int n_faces;
    PangoFontFace **faces = nullptr;
    pango_font_family_list_faces(families[i], &faces, &n_faces);
    for (int j = 0; j < n_faces; ++j) {
      PangoFontDescription *desc = pango_font_face_describe(faces[j]);
      char *desc_str = pango_font_description_to_string(desc);
      // "synthesized" font faces that are not truly loadable, so we skip it
      if (!pango_font_face_is_synthesized(faces[j]) && IsAvailableFont(desc_str)) {
        available_fonts_.emplace_back(desc_str);
      }
      pango_font_description_free(desc);
      g_free(desc_str);
    }
    g_free(faces);
  }
  g_free(families);
  std::sort(available_fonts_.begin(), available_fonts_.end());
  return available_fonts_;
}

PangoFontTypeInfo()

void tesseract::FontUtils::PangoFontTypeInfo ( )

static

Definition at line 710 of file pango_font_info.cpp.

                                  {
  PangoFontMap *font_map = pango_cairo_font_map_get_default();
  if (pango_cairo_font_map_get_font_type(reinterpret_cast<PangoCairoFontMap *>(font_map)) ==
      CAIRO_FONT_TYPE_TOY) {
    printf("Using CAIRO_FONT_TYPE_TOY.\n");
  } else if (pango_cairo_font_map_get_font_type(reinterpret_cast<PangoCairoFontMap *>(font_map)) ==
             CAIRO_FONT_TYPE_FT) {
    printf("Using CAIRO_FONT_TYPE_FT.\n");
  } else if (pango_cairo_font_map_get_font_type(reinterpret_cast<PangoCairoFontMap *>(font_map)) ==
             CAIRO_FONT_TYPE_WIN32) {
    printf("Using CAIRO_FONT_TYPE_WIN32.\n");
  } else if (pango_cairo_font_map_get_font_type(reinterpret_cast<PangoCairoFontMap *>(font_map)) ==
             CAIRO_FONT_TYPE_QUARTZ) {
    printf("Using CAIRO_FONT_TYPE_QUARTZ.\n");
  } else if (pango_cairo_font_map_get_font_type(reinterpret_cast<PangoCairoFontMap *>(font_map)) ==
             CAIRO_FONT_TYPE_USER) {
    printf("Using CAIRO_FONT_TYPE_USER.\n");
  } else if (!font_map) {
    printf("Cannot create pango cairo font map!\n");
  }
}

ReInit()

void tesseract::FontUtils::ReInit ( )

static

Definition at line 704 of file pango_font_info.cpp.

                       {
  available_fonts_.clear();
}

SelectFont() [1/2]

bool tesseract::FontUtils::SelectFont ( const char *  utf8_word, const int  utf8_len, const std::vector< std::string > &  all_fonts, std::string *  font_name, std::vector< std::string > *  graphemes  )

static

Definition at line 675 of file pango_font_info.cpp.

                                                            {
  if (font_name) {
    font_name->clear();
  }
  if (graphemes) {
    graphemes->clear();
  }
  for (const auto &all_font : all_fonts) {
    PangoFontInfo font;
    std::vector<std::string> found_graphemes;
    ASSERT_HOST_MSG(font.ParseFontDescriptionName(all_font), "Could not parse font desc name %s\n",
                    all_font.c_str());
    if (font.CanRenderString(utf8_word, utf8_len, &found_graphemes)) {
      if (graphemes) {
        graphemes->swap(found_graphemes);
      }
      if (font_name) {
        *font_name = all_font;
      }
      return true;
    }
  }
  return false;
}

SelectFont() [2/2]

bool tesseract::FontUtils::SelectFont ( const char *  utf8_word, const int  utf8_len, std::string *  font_name, std::vector< std::string > *  graphemes  )

static

Definition at line 669 of file pango_font_info.cpp.

                                                            {
  return SelectFont(utf8_word, utf8_len, ListAvailableFonts(), font_name, graphemes);
}

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/training/pango/pango_font_info.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/training/pango/pango_font_info.cpp