text2image.cpp File Reference

#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "allheaders.h"
#include "boxchar.h"
#include "commandlineflags.h"
#include "degradeimage.h"
#include "errcode.h"
#include "fileio.h"
#include "helpers.h"
#include "normstrngs.h"
#include "stringrenderer.h"
#include "tlog.h"
#include "unicharset.h"
#include "util.h"

Go to the source code of this file.

Classes
struct	tesseract::SpacingProperties

Namespaces
	tesseract

Functions
	STRING_PARAM_FLAG (text, "", "File name of text input to process")
	STRING_PARAM_FLAG (outputbase, "", "Basename for output image/box file")
	BOOL_PARAM_FLAG (degrade_image, true, "Degrade rendered image with speckle noise, dilation/erosion " "and rotation")
	BOOL_PARAM_FLAG (rotate_image, true, "Rotate the image in a random way.")
	INT_PARAM_FLAG (exposure, 0, "Exposure level in photocopier")
	INT_PARAM_FLAG (resolution, 300, "Pixels per inch")
	INT_PARAM_FLAG (xsize, 3600, "Width of output image")
	INT_PARAM_FLAG (ysize, 4800, "Height of output image")
	INT_PARAM_FLAG (margin, 100, "Margin round edges of image")
	INT_PARAM_FLAG (ptsize, 12, "Size of printed text")
	DOUBLE_PARAM_FLAG (char_spacing, 0, "Inter-character space in ems")
	DOUBLE_PARAM_FLAG (underline_start_prob, 0, "Fraction of words to underline (value in [0,1])")
	DOUBLE_PARAM_FLAG (underline_continuation_prob, 0, "Fraction of words to underline (value in [0,1])")
	INT_PARAM_FLAG (leading, 12, "Inter-line space (in pixels)")
	STRING_PARAM_FLAG (writing_mode, "horizontal", "Specify one of the following writing" " modes.\ " 'horizontal' :Render regular horizontal text.(default)\" " 'vertical' :Render vertical text. Glyph orientation is" " selected by Pango.\" " 'vertical-upright' :Render vertical text. Glyph " " orientation is set to be upright.")
	INT_PARAM_FLAG (box_padding, 0, "Padding around produced bounding boxes")
	BOOL_PARAM_FLAG (strip_unrenderable_words, true, "Remove unrenderable words from source text")
	STRING_PARAM_FLAG (font, "Arial", "Font description name to use")
	BOOL_PARAM_FLAG (ligatures, false, "Rebuild and render ligatures")
	BOOL_PARAM_FLAG (find_fonts, false, "Search for all fonts that can render the text")
	BOOL_PARAM_FLAG (render_per_font, true, "If find_fonts==true, render each font to its own image. " "Image filenames are of the form output_name.font_name.tif")
	DOUBLE_PARAM_FLAG (min_coverage, 1.0, "If find_fonts==true, the minimum coverage the font has of " "the characters in the text file to include it, between " "0 and 1.")
	BOOL_PARAM_FLAG (list_available_fonts, false, "List available fonts and quit.")
	BOOL_PARAM_FLAG (render_ngrams, false, "Put each space-separated entity from the" " input file into one bounding box. The ngrams in the input" " file will be randomly permuted before rendering (so that" " there is sufficient variety of characters on each line).")
	BOOL_PARAM_FLAG (output_word_boxes, false, "Output word bounding boxes instead of character boxes. " "This is used for Cube training, and implied by " "--render_ngrams.")
	STRING_PARAM_FLAG (unicharset_file, "", "File with characters in the unicharset. If --render_ngrams" " is true and --unicharset_file is specified, ngrams with" " characters that are not in unicharset will be omitted")
	BOOL_PARAM_FLAG (bidirectional_rotation, false, "Rotate the generated characters both ways.")
	BOOL_PARAM_FLAG (only_extract_font_properties, false, "Assumes that the input file contains a list of ngrams. Renders" " each ngram, extracts spacing properties and records them in" " output_base/[font_name].fontinfo file.")
	BOOL_PARAM_FLAG (output_individual_glyph_images, false, "If true also outputs individual character images")
	INT_PARAM_FLAG (glyph_resized_size, 0, "Each glyph is square with this side length in pixels")
	INT_PARAM_FLAG (glyph_num_border_pixels_to_pad, 0, "Final_size=glyph_resized_size+2*glyph_num_border_pixels_to_pad")
void	tesseract::ExtractFontProperties (const string &utf8_text, StringRenderer *render, const string &output_base)
bool	tesseract::MakeIndividualGlyphs (Pix *pix, const std::vector< BoxChar *> &vbox, const int input_tiff_page)
int	main (int argc, char **argv)

Variables
const int	kRandomSeed = 0x18273645

Function Documentation

BOOL_PARAM_FLAG() [1/12]

BOOL_PARAM_FLAG	(	degrade_image	,
		true	,
		"Degrade rendered image with speckle	noise,
		dilation/erosion " "and rotation"
	)

BOOL_PARAM_FLAG() [2/12]

BOOL_PARAM_FLAG	(	rotate_image	,
		true	,
		"Rotate the image in a random way."
	)

BOOL_PARAM_FLAG() [3/12]

BOOL_PARAM_FLAG	(	strip_unrenderable_words	,
		true	,
		"Remove unrenderable words from source text"
	)

BOOL_PARAM_FLAG() [4/12]

BOOL_PARAM_FLAG	(	ligatures	,
		false	,
		"Rebuild and render ligatures"
	)

BOOL_PARAM_FLAG() [5/12]

BOOL_PARAM_FLAG	(	find_fonts	,
		false	,
		"Search for all fonts that can render the text"
	)

BOOL_PARAM_FLAG() [6/12]

BOOL_PARAM_FLAG	(	render_per_font	,
		true	,
		"If	find_fonts = =true,
		render each font to its own image. " "Image filenames are of the form output_name.font_name.tif"
	)

BOOL_PARAM_FLAG() [7/12]

BOOL_PARAM_FLAG	(	list_available_fonts	,
		false	,
		"List available fonts and quit."
	)

BOOL_PARAM_FLAG() [8/12]

BOOL_PARAM_FLAG	(	render_ngrams	,
		false	,
		"Put each space-separated entity from the" " input file into one bounding box. The ngrams in the input" " file will be randomly permuted before rendering (so that" " there is sufficient variety of characters on each line)."
	)

BOOL_PARAM_FLAG() [9/12]

BOOL_PARAM_FLAG	(	output_word_boxes	,
		false	,
		"Output word bounding boxes instead of character boxes. " "This is used for Cube	training,
		and implied by " "--render_ngrams."
	)

BOOL_PARAM_FLAG() [10/12]

BOOL_PARAM_FLAG	(	bidirectional_rotation	,
		false	,
		"Rotate the generated characters both ways."
	)

BOOL_PARAM_FLAG() [11/12]

BOOL_PARAM_FLAG	(	only_extract_font_properties	,
		false	,
		"Assumes that the input file contains a list of ngrams. Renders" " each	ngram,
		extracts spacing properties and records them in" " output_base/.fontinfo file."	[font_name]
	)

BOOL_PARAM_FLAG() [12/12]

BOOL_PARAM_FLAG	(	output_individual_glyph_images	,
		false	,
		"If true also outputs individual character images"
	)

DOUBLE_PARAM_FLAG() [1/4]

DOUBLE_PARAM_FLAG	(	char_spacing	,
		0	,
		"Inter-character space in ems"
	)

DOUBLE_PARAM_FLAG() [2/4]

DOUBLE_PARAM_FLAG	(	underline_start_prob	,
		0	,
		"Fraction of words to underline (value in [0,1])"
	)

DOUBLE_PARAM_FLAG() [3/4]

DOUBLE_PARAM_FLAG	(	underline_continuation_prob	,
		0	,
		"Fraction of words to underline (value in [0,1])"
	)

DOUBLE_PARAM_FLAG() [4/4]

DOUBLE_PARAM_FLAG	(	min_coverage	,
		1.	0,
		"If	find_fonts = =true,
		the minimum coverage the font has of " "the characters in the text file to include	it,
		between " "0 and 1."
	)

INT_PARAM_FLAG() [1/10]

INT_PARAM_FLAG	(	exposure	,
		0	,
		"Exposure level in photocopier"
	)

INT_PARAM_FLAG() [2/10]

INT_PARAM_FLAG	(	resolution	,
		300	,
		"Pixels per inch"
	)

INT_PARAM_FLAG() [3/10]

INT_PARAM_FLAG	(	xsize	,
		3600	,
		"Width of output image"
	)

INT_PARAM_FLAG() [4/10]

INT_PARAM_FLAG	(	ysize	,
		4800	,
		"Height of output image"
	)

INT_PARAM_FLAG() [5/10]

INT_PARAM_FLAG	(	margin	,
		100	,
		"Margin round edges of image"
	)

INT_PARAM_FLAG() [6/10]

INT_PARAM_FLAG	(	ptsize	,
		12	,
		"Size of printed text"
	)

INT_PARAM_FLAG() [7/10]

INT_PARAM_FLAG	(	leading	,
		12	,
		"Inter-line space (in pixels)"
	)

INT_PARAM_FLAG() [8/10]

INT_PARAM_FLAG	(	box_padding	,
		0	,
		"Padding around produced bounding boxes"
	)

INT_PARAM_FLAG() [9/10]

INT_PARAM_FLAG	(	glyph_resized_size	,
		0	,
		"Each glyph is square with this side length in pixels"
	)

INT_PARAM_FLAG() [10/10]

INT_PARAM_FLAG	(	glyph_num_border_pixels_to_pad	,
		0
	)

main()

int main	(	int	argc,
		char **	argv
	)

This program reads in a text file consisting of feature samples from a training page in the following format:

   FontName UTF8-char-str xmin ymin xmax ymax page-number
    NumberOfFeatureTypes(N)
      FeatureTypeName1 NumberOfFeatures(M)
         Feature1
         ...
         FeatureM
      FeatureTypeName2 NumberOfFeatures(M)
         Feature1
         ...
         FeatureM
      ...
      FeatureTypeNameN NumberOfFeatures(M)
         Feature1
         ...
         FeatureM
   FontName CharName ...

The result of this program is a binary inttemp file used by the OCR engine.

Parameters

argc	number of command line arguments
argv	array of command line arguments

Returns

none

Note

Exceptions: none

History: Fri Aug 18 08:56:17 1989, DSJ, Created.

History: Mon May 18 1998, Christy Russson, Revistion started.

Definition at line 418 of file text2image.cpp.

                                {
  tesseract::ParseCommandLineFlags(argv[0], &argc, &argv, true);

  if (FLAGS_list_available_fonts) {
    const std::vector<string>& all_fonts = FontUtils::ListAvailableFonts();
    for (unsigned int i = 0; i < all_fonts.size(); ++i) {
      printf("%3u: %s\n", i, all_fonts[i].c_str());
      ASSERT_HOST_MSG(FontUtils::IsAvailableFont(all_fonts[i].c_str()),
                      "Font %s is unrecognized.\n", all_fonts[i].c_str());
    }
    return EXIT_SUCCESS;
  }

  // Check validity of input flags.
  if (FLAGS_text.empty()) {
    tprintf("'--text' option is missing!\n");
    exit(1);
  }
  if (FLAGS_outputbase.empty()) {
    tprintf("'--outputbase' option is missing!\n");
    exit(1);
  }
  if (!FLAGS_unicharset_file.empty() && FLAGS_render_ngrams) {
    tprintf("Use '--unicharset_file' only if '--render_ngrams' is set.\n");
    exit(1);
  }

  if (!FLAGS_find_fonts && !FontUtils::IsAvailableFont(FLAGS_font.c_str())) {
    string pango_name;
    if (!FontUtils::IsAvailableFont(FLAGS_font.c_str(), &pango_name)) {
      tprintf("Could not find font named %s.\n", FLAGS_font.c_str());
      if (!pango_name.empty()) {
        tprintf("Pango suggested font %s.\n", pango_name.c_str());
      }
      tprintf("Please correct --font arg.\n");
      exit(1);
    }
  }

  if (FLAGS_render_ngrams)
    FLAGS_output_word_boxes = true;

  char font_desc_name[1024];
  snprintf(font_desc_name, 1024, "%s %d", FLAGS_font.c_str(),
           static_cast<int>(FLAGS_ptsize));
  StringRenderer render(font_desc_name, FLAGS_xsize, FLAGS_ysize);
  render.set_add_ligatures(FLAGS_ligatures);
  render.set_leading(FLAGS_leading);
  render.set_resolution(FLAGS_resolution);
  render.set_char_spacing(FLAGS_char_spacing * FLAGS_ptsize);
  render.set_h_margin(FLAGS_margin);
  render.set_v_margin(FLAGS_margin);
  render.set_output_word_boxes(FLAGS_output_word_boxes);
  render.set_box_padding(FLAGS_box_padding);
  render.set_strip_unrenderable_words(FLAGS_strip_unrenderable_words);
  render.set_underline_start_prob(FLAGS_underline_start_prob);
  render.set_underline_continuation_prob(FLAGS_underline_continuation_prob);

  // Set text rendering orientation and their forms.
  if (FLAGS_writing_mode == "horizontal") {
    // Render regular horizontal text (default).
    render.set_vertical_text(false);
    render.set_gravity_hint_strong(false);
    render.set_render_fullwidth_latin(false);
  } else if (FLAGS_writing_mode == "vertical") {
    // Render vertical text. Glyph orientation is selected by Pango.
    render.set_vertical_text(true);
    render.set_gravity_hint_strong(false);
    render.set_render_fullwidth_latin(false);
  } else if (FLAGS_writing_mode == "vertical-upright") {
    // Render vertical text. Glyph orientation is set to be upright.
    // Also Basic Latin characters are converted to their fullwidth forms
    // on rendering, since fullwidth Latin characters are well designed to fit
    // vertical text lines, while .box files store halfwidth Basic Latin
    // unichars.
    render.set_vertical_text(true);
    render.set_gravity_hint_strong(true);
    render.set_render_fullwidth_latin(true);
  } else {
    tprintf("Invalid writing mode: %s\n", FLAGS_writing_mode.c_str());
    exit(1);
  }

  string src_utf8;
  // This c_str is NOT redundant!
  if (!File::ReadFileToString(FLAGS_text.c_str(), &src_utf8)) {
    tprintf("Failed to read file: %s\n", FLAGS_text.c_str());
    exit(1);
  }

  // Remove the unicode mark if present.
  if (strncmp(src_utf8.c_str(), "\xef\xbb\xbf", 3) == 0) {
    src_utf8.erase(0, 3);
  }
  tlog(1, "Render string of size %d\n", src_utf8.length());

  if (FLAGS_render_ngrams || FLAGS_only_extract_font_properties) {
    // Try to preserve behavior of old text2image by expanding inter-word
    // spaces by a factor of 4.
    const string kSeparator = FLAGS_render_ngrams ? "    " : " ";
    // Also restrict the number of characters per line to try and avoid
    // line-breaking in the middle of words like "-A", "R$" etc. which are
    // otherwise allowed by the standard unicode line-breaking rules.
    const unsigned int kCharsPerLine = (FLAGS_ptsize > 20) ? 50 : 100;
    string rand_utf8;
    UNICHARSET unicharset;
    if (FLAGS_render_ngrams && !FLAGS_unicharset_file.empty() &&
        !unicharset.load_from_file(FLAGS_unicharset_file.c_str())) {
      tprintf("Failed to load unicharset from file %s\n",
              FLAGS_unicharset_file.c_str());
      exit(1);
    }

    // If we are rendering ngrams that will be OCRed later, shuffle them so that
    // tesseract does not have difficulties finding correct baseline, word
    // spaces, etc.
    const char *str8 = src_utf8.c_str();
    int len = src_utf8.length();
    int step;
    std::vector<std::pair<int, int> > offsets;
    int offset = SpanUTF8Whitespace(str8);
    while (offset < len) {
      step = SpanUTF8NotWhitespace(str8 + offset);
      offsets.push_back(std::make_pair(offset, step));
      offset += step;
      offset += SpanUTF8Whitespace(str8 + offset);
    }
    if (FLAGS_render_ngrams)
      std::random_shuffle(offsets.begin(), offsets.end());

    for (size_t i = 0, line = 1; i < offsets.size(); ++i) {
      const char *curr_pos = str8 + offsets[i].first;
      int ngram_len = offsets[i].second;
      // Skip words that contain characters not in found in unicharset.
      if (!FLAGS_unicharset_file.empty() &&
          !unicharset.encodable_string(curr_pos, nullptr)) {
        continue;
      }
      rand_utf8.append(curr_pos, ngram_len);
      if (rand_utf8.length() > line * kCharsPerLine) {
        rand_utf8.append(" \n");
        ++line;
        if (line & 0x1) rand_utf8.append(kSeparator);
      } else {
        rand_utf8.append(kSeparator);
      }
    }
    tlog(1, "Rendered ngram string of size %d\n", rand_utf8.length());
    src_utf8.swap(rand_utf8);
  }
  if (FLAGS_only_extract_font_properties) {
    tprintf("Extracting font properties only\n");
    ExtractFontProperties(src_utf8, &render, FLAGS_outputbase.c_str());
    tprintf("Done!\n");
    return 0;
  }

  int im = 0;
  std::vector<float> page_rotation;
  const char* to_render_utf8 = src_utf8.c_str();

  tesseract::TRand randomizer;
  randomizer.set_seed(kRandomSeed);
  std::vector<string> font_names;
  // We use a two pass mechanism to rotate images in both direction.
  // The first pass(0) will rotate the images in random directions and
  // the second pass(1) will mirror those rotations.
  int num_pass = FLAGS_bidirectional_rotation ? 2 : 1;
  for (int pass = 0; pass < num_pass; ++pass) {
    int page_num = 0;
    string font_used;
    for (size_t offset = 0; offset < strlen(to_render_utf8); ++im, ++page_num) {
      tlog(1, "Starting page %d\n", im);
      Pix* pix = nullptr;
      if (FLAGS_find_fonts) {
        offset += render.RenderAllFontsToImage(FLAGS_min_coverage,
                                               to_render_utf8 + offset,
                                               strlen(to_render_utf8 + offset),
                                               &font_used, &pix);
      } else {
        offset += render.RenderToImage(to_render_utf8 + offset,
                                       strlen(to_render_utf8 + offset), &pix);
      }
      if (pix != nullptr) {
        float rotation = 0;
        if (pass == 1) {
          // Pass 2, do mirror rotation.
          rotation = -1 * page_rotation[page_num];
        }
        if (FLAGS_degrade_image) {
          pix = DegradeImage(pix, FLAGS_exposure, &randomizer,
                             FLAGS_rotate_image ? &rotation : nullptr);
        }
        render.RotatePageBoxes(rotation);

        if (pass == 0) {
          // Pass 1, rotate randomly and store the rotation..
          page_rotation.push_back(rotation);
        }

        Pix* gray_pix = pixConvertTo8(pix, false);
        pixDestroy(&pix);
        Pix* binary = pixThresholdToBinary(gray_pix, 128);
        pixDestroy(&gray_pix);
        char tiff_name[1024];
        if (FLAGS_find_fonts) {
          if (FLAGS_render_per_font) {
            string fontname_for_file = tesseract::StringReplace(
                font_used, " ", "_");
            snprintf(tiff_name, 1024, "%s.%s.tif", FLAGS_outputbase.c_str(),
                     fontname_for_file.c_str());
            pixWriteTiff(tiff_name, binary, IFF_TIFF_G4, "w");
            tprintf("Rendered page %d to file %s\n", im, tiff_name);
          } else {
            font_names.push_back(font_used);
          }
        } else {
          snprintf(tiff_name, 1024, "%s.tif", FLAGS_outputbase.c_str());
          pixWriteTiff(tiff_name, binary, IFF_TIFF_G4, im == 0 ? "w" : "a");
          tprintf("Rendered page %d to file %s\n", im, tiff_name);
        }
        // Make individual glyphs
        if (FLAGS_output_individual_glyph_images) {
          if (!MakeIndividualGlyphs(binary, render.GetBoxes(), im)) {
            tprintf("ERROR: Individual glyphs not saved\n");
          }
        }
        pixDestroy(&binary);
      }
      if (FLAGS_find_fonts && offset != 0) {
        // We just want a list of names, or some sample images so we don't need
        // to render more than the first page of the text.
        break;
      }
    }
  }
  if (!FLAGS_find_fonts) {
    string box_name = FLAGS_outputbase.c_str();
    box_name += ".box";
    render.WriteAllBoxes(box_name);
  } else if (!FLAGS_render_per_font && !font_names.empty()) {
    string filename = FLAGS_outputbase.c_str();
    filename += ".fontlist.txt";
    FILE* fp = fopen(filename.c_str(), "wb");
    if (fp == nullptr) {
      tprintf("Failed to create output font list %s\n", filename.c_str());
    } else {
      for (size_t i = 0; i < font_names.size(); ++i) {
        fprintf(fp, "%s\n", font_names[i].c_str());
      }
      fclose(fp);
    }
  }

  return 0;
}

STRING_PARAM_FLAG() [1/5]

STRING_PARAM_FLAG	(	text	,
		""	,
		"File name of text input to process"
	)

STRING_PARAM_FLAG() [2/5]

STRING_PARAM_FLAG	(	outputbase	,
		""	,
		"Basename for output image/box file"
	)

STRING_PARAM_FLAG() [3/5]

STRING_PARAM_FLAG	(	writing_mode	,
		"horizontal"	,
		"Specify one of the following writing" " modes.\ 'horizontal' :Render regular horizontal text.(default)\ " 'vertical' :Render vertical text. Glyph orientation is" " selected by Pango.\" " 'vertical-upright' :Render vertical text. Glyph " " orientation is set to be upright."
	)

STRING_PARAM_FLAG() [4/5]

STRING_PARAM_FLAG	(	font	,
		"Arial"	,
		"Font description name to use"
	)

STRING_PARAM_FLAG() [5/5]

STRING_PARAM_FLAG	(	unicharset_file	,
		""	,
		"File with characters in the unicharset. If --render_ngrams" " is true and --unicharset_file is	specified,
		ngrams with" " characters that are not in unicharset will be omitted"
	)

Variable Documentation

kRandomSeed

const int kRandomSeed = 0x18273645

Definition at line 60 of file text2image.cpp.