#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 void	GetAllRenderableCharacters (std::vector< bool > *unichar_bitmap)

static void	GetAllRenderableCharacters (const std::vector< std::string > &font_names, std::vector< bool > *unichar_bitmap)

static void	GetAllRenderableCharacters (const std::string &font_name, std::vector< bool > *unichar_bitmap)

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 146 of file pango_font_info.h.

Member Function Documentation

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 694 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 (unsigned i = 0; i < font_names.size(); ++i) {
     std::vector<bool> ch_flags;
     int raw_score = 0;
     int ok_chars = FontScore(ch_map, font_names[i], &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;
 }

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 658 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 (std::unordered_map<char32, int64_t>::const_iterator it = ch_map.begin();
        it != ch_map.end(); ++it) {
     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;
 }

void tesseract::FontUtils::GetAllRenderableCharacters ( std::vector< bool > * unichar_bitmap )

static

Definition at line 613 of file pango_font_info.cpp.

                                                                           {
   const std::vector<std::string>& all_fonts = ListAvailableFonts();
   return GetAllRenderableCharacters(all_fonts, unichar_bitmap);
 }

void tesseract::FontUtils::GetAllRenderableCharacters	(	const std::vector< std::string > &	font_names,
		std::vector< bool > *	unichar_bitmap
	)

static

Definition at line 633 of file pango_font_info.cpp.

                                                                             {
   // Form the union of coverage maps from the fonts
   PangoCoverage* all_coverage = pango_coverage_new();
   tlog(1, "Processing %u fonts\n", static_cast<unsigned>(fonts.size()));
   for (unsigned i = 0; i < fonts.size(); ++i) {
     PangoFontInfo font_info(fonts[i]);
     PangoFont* font = font_info.ToPangoFont();
     if (font != nullptr) {
       // Font found.
       PangoCoverage* coverage = pango_font_get_coverage(font, nullptr);
       // Mark off characters that any font can render.
       pango_coverage_max(all_coverage, coverage);
       pango_coverage_unref(coverage);
       g_object_unref(font);
     }
   }
   CharCoverageMapToBitmap(all_coverage, unichar_bitmap);
   pango_coverage_unref(all_coverage);
 }

void tesseract::FontUtils::GetAllRenderableCharacters	(	const std::string &	font_name,
		std::vector< bool > *	unichar_bitmap
	)

static

Definition at line 619 of file pango_font_info.cpp.

                                                                             {
   PangoFontInfo font_info(font_name);
   PangoFont* font = font_info.ToPangoFont();
   if (font != nullptr) {
     // Font found.
     PangoCoverage* coverage = pango_font_get_coverage(font, nullptr);
     CharCoverageMapToBitmap(coverage, unichar_bitmap);
     pango_coverage_unref(coverage);
     g_object_unref(font);
   }
 }

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

inlinestatic

Definition at line 150 of file pango_font_info.h.

                                                      {
     return IsAvailableFont(font_desc, nullptr);
   }

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

static

Definition at line 489 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);
     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);
   return equal;
 }

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

static

Definition at line 550 of file pango_font_info.cpp.

                                                           {
   if (!available_fonts_.empty()) {
     return available_fonts_;
   }
 #ifdef GOOGLE_TESSERACT
   if (FLAGS_use_only_legacy_fonts) {
     // Restrict view to list of fonts in legacy_fonts.h
     tprintf("Using list of legacy fonts only\n");
     const int kNumFontLists = 4;
     for (int i = 0; i < kNumFontLists; ++i) {
       for (int j = 0; kFontlists[i][j] != nullptr; ++j) {
         available_fonts_.push_back(kFontlists[i][j]);
       }
     }
     return available_fonts_;
   }
 #endif
 
   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);
       if (IsAvailableFont(desc_str)) {
         available_fonts_.push_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_;
 }

void tesseract::FontUtils::PangoFontTypeInfo ( )

static

Definition at line 790 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("Can not create pango cairo font map!\n");
   }
 }

void tesseract::FontUtils::ReInit ( )

static

Definition at line 786 of file pango_font_info.cpp.

786 { available_fonts_.clear(); }

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 757 of file pango_font_info.cpp.

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

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 764 of file pango_font_info.cpp.

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

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

src/training/pango_font_info.h
src/training/pango_font_info.cpp

Static Public Member Functions

Detailed Description

Member Function Documentation