tesseract::RecodeBeamSearch Class Reference

#include <recodebeam.h>

Public Member Functions
	RecodeBeamSearch (const UnicharCompress &recoder, int null_char, bool simple_text, Dict *dict)
void	Decode (const NetworkIO &output, double dict_ratio, double cert_offset, double worst_dict_cert, const UNICHARSET *charset)
void	Decode (const GENERIC_2D_ARRAY< float > &output, double dict_ratio, double cert_offset, double worst_dict_cert, const UNICHARSET *charset)
void	ExtractBestPathAsLabels (GenericVector< int > *labels, GenericVector< int > *xcoords) const
void	ExtractBestPathAsUnicharIds (bool debug, const UNICHARSET *unicharset, GenericVector< int > *unichar_ids, GenericVector< float > *certs, GenericVector< float > *ratings, GenericVector< int > *xcoords) const
void	ExtractBestPathAsWords (const TBOX &line_box, float scale_factor, bool debug, const UNICHARSET *unicharset, PointerVector< WERD_RES > *words)
void	DebugBeams (const UNICHARSET &unicharset) const

Static Public Member Functions
static int	LengthFromBeamsIndex (int index)
static NodeContinuation	ContinuationFromBeamsIndex (int index)
static bool	IsDawgFromBeamsIndex (int index)
static int	BeamIndex (bool is_dawg, NodeContinuation cont, int length)

Static Public Attributes
static const float	kMinCertainty = -20.0f
static const int	kNumLengths = RecodedCharID::kMaxCodeLen + 1
static const int	kNumBeams = 2 * NC_COUNT * kNumLengths

Detailed Description

Definition at line 176 of file recodebeam.h.

Constructor & Destructor Documentation

RecodeBeamSearch()

tesseract::RecodeBeamSearch::RecodeBeamSearch	(	const UnicharCompress &	recoder,
		int	null_char,
		bool	simple_text,
		Dict *	dict
	)

Definition at line 62 of file recodebeam.cpp.

    : recoder_(recoder),
      beam_size_(0),
      top_code_(-1),
      second_code_(-1),
      dict_(dict),
      space_delimited_(true),
      is_simple_text_(simple_text),
      null_char_(null_char) {
  if (dict_ != NULL && !dict_->IsSpaceDelimitedLang()) space_delimited_ = false;
}

Member Function Documentation

BeamIndex()

static int tesseract::RecodeBeamSearch::BeamIndex ( bool  is_dawg, NodeContinuation  cont, int  length  )

inlinestatic

Definition at line 228 of file recodebeam.h.

                                                                        {
    return (is_dawg * NC_COUNT + cont) * kNumLengths + length;
  }

ContinuationFromBeamsIndex()

static NodeContinuation tesseract::RecodeBeamSearch::ContinuationFromBeamsIndex ( int  index )

inlinestatic

Definition at line 221 of file recodebeam.h.

                                                                {
    return static_cast<NodeContinuation>((index / kNumLengths) % NC_COUNT);
  }

DebugBeams()

void tesseract::RecodeBeamSearch::DebugBeams

(

const UNICHARSET &

unicharset

)

const

Definition at line 210 of file recodebeam.cpp.

                                                                    {
  for (int p = 0; p < beam_size_; ++p) {
    for (int d = 0; d < 2; ++d) {
      for (int c = 0; c < NC_COUNT; ++c) {
        NodeContinuation cont = static_cast<NodeContinuation>(c);
        int index = BeamIndex(d, cont, 0);
        if (beam_[p]->beams_[index].empty()) continue;
        // Print all the best scoring nodes for each unichar found.
        tprintf("Position %d: %s+%s beam\n", p, d ? "Dict" : "Non-Dict",
                kNodeContNames[c]);
        DebugBeamPos(unicharset, beam_[p]->beams_[index]);
      }
    }
  }
}

Decode() [1/2]

void tesseract::RecodeBeamSearch::Decode	(	const NetworkIO &	output,
		double	dict_ratio,
		double	cert_offset,
		double	worst_dict_cert,
		const UNICHARSET *	charset
	)

Definition at line 76 of file recodebeam.cpp.

                                                         {
  beam_size_ = 0;
  int width = output.Width();
  for (int t = 0; t < width; ++t) {
    ComputeTopN(output.f(t), output.NumFeatures(), kBeamWidths[0]);
    DecodeStep(output.f(t), t, dict_ratio, cert_offset, worst_dict_cert,
               charset);
  }
}

Decode() [2/2]

void tesseract::RecodeBeamSearch::Decode	(	const GENERIC_2D_ARRAY< float > &	output,
		double	dict_ratio,
		double	cert_offset,
		double	worst_dict_cert,
		const UNICHARSET *	charset
	)

Definition at line 87 of file recodebeam.cpp.

                                                         {
  beam_size_ = 0;
  int width = output.dim1();
  for (int t = 0; t < width; ++t) {
    ComputeTopN(output[t], output.dim2(), kBeamWidths[0]);
    DecodeStep(output[t], t, dict_ratio, cert_offset, worst_dict_cert, charset);
  }
}

ExtractBestPathAsLabels()

void tesseract::RecodeBeamSearch::ExtractBestPathAsLabels	(	GenericVector< int > *	labels,
		GenericVector< int > *	xcoords
	)		const

Definition at line 100 of file recodebeam.cpp.

                                                                   {
  labels->truncate(0);
  xcoords->truncate(0);
  GenericVector<const RecodeNode*> best_nodes;
  ExtractBestPaths(&best_nodes, NULL);
  // Now just run CTC on the best nodes.
  int t = 0;
  int width = best_nodes.size();
  while (t < width) {
    int label = best_nodes[t]->code;
    if (label != null_char_) {
      labels->push_back(label);
      xcoords->push_back(t);
    }
    while (++t < width && !is_simple_text_ && best_nodes[t]->code == label) {
    }
  }
  xcoords->push_back(width);
}

ExtractBestPathAsUnicharIds()

void tesseract::RecodeBeamSearch::ExtractBestPathAsUnicharIds	(	bool	debug,
		const UNICHARSET *	unicharset,
		GenericVector< int > *	unichar_ids,
		GenericVector< float > *	certs,
		GenericVector< float > *	ratings,
		GenericVector< int > *	xcoords
	)		const

Definition at line 123 of file recodebeam.cpp.

                                       {
  GenericVector<const RecodeNode*> best_nodes;
  ExtractBestPaths(&best_nodes, NULL);
  ExtractPathAsUnicharIds(best_nodes, unichar_ids, certs, ratings, xcoords);
  if (debug) {
    DebugPath(unicharset, best_nodes);
    DebugUnicharPath(unicharset, best_nodes, *unichar_ids, *certs, *ratings,
                     *xcoords);
  }
}

ExtractBestPathAsWords()

void tesseract::RecodeBeamSearch::ExtractBestPathAsWords	(	const TBOX &	line_box,
		float	scale_factor,
		bool	debug,
		const UNICHARSET *	unicharset,
		PointerVector< WERD_RES > *	words
	)

Definition at line 138 of file recodebeam.cpp.

                                                                              {
  words->truncate(0);
  GenericVector<int> unichar_ids;
  GenericVector<float> certs;
  GenericVector<float> ratings;
  GenericVector<int> xcoords;
  GenericVector<const RecodeNode*> best_nodes;
  GenericVector<const RecodeNode*> second_nodes;
  ExtractBestPaths(&best_nodes, &second_nodes);
  if (debug) {
    DebugPath(unicharset, best_nodes);
    ExtractPathAsUnicharIds(second_nodes, &unichar_ids, &certs, &ratings,
                            &xcoords);
    tprintf("\nSecond choice path:\n");
    DebugUnicharPath(unicharset, second_nodes, unichar_ids, certs, ratings,
                     xcoords);
  }
  ExtractPathAsUnicharIds(best_nodes, &unichar_ids, &certs, &ratings, &xcoords);
  int num_ids = unichar_ids.size();
  if (debug) {
    DebugUnicharPath(unicharset, best_nodes, unichar_ids, certs, ratings,
                     xcoords);
  }
  // Convert labels to unichar-ids.
  int word_end = 0;
  float prev_space_cert = 0.0f;
  for (int word_start = 0; word_start < num_ids; word_start = word_end) {
    for (word_end = word_start + 1; word_end < num_ids; ++word_end) {
      // A word is terminated when a space character or start_of_word flag is
      // hit. We also want to force a separate word for every non
      // space-delimited character when not in a dictionary context.
      if (unichar_ids[word_end] == UNICHAR_SPACE) break;
      int index = xcoords[word_end];
      if (best_nodes[index]->start_of_word) break;
      if (best_nodes[index]->permuter == TOP_CHOICE_PERM &&
          (!unicharset->IsSpaceDelimited(unichar_ids[word_end]) ||
           !unicharset->IsSpaceDelimited(unichar_ids[word_end - 1])))
        break;
    }
    float space_cert = 0.0f;
    if (word_end < num_ids && unichar_ids[word_end] == UNICHAR_SPACE)
      space_cert = certs[word_end];
    bool leading_space =
        word_start > 0 && unichar_ids[word_start - 1] == UNICHAR_SPACE;
    // Create a WERD_RES for the output word.
    WERD_RES* word_res = InitializeWord(
        leading_space, line_box, word_start, word_end,
        MIN(space_cert, prev_space_cert), unicharset, xcoords, scale_factor);
    for (int i = word_start; i < word_end; ++i) {
      BLOB_CHOICE_LIST* choices = new BLOB_CHOICE_LIST;
      BLOB_CHOICE_IT bc_it(choices);
      BLOB_CHOICE* choice = new BLOB_CHOICE(
          unichar_ids[i], ratings[i], certs[i], -1, 1.0f,
          static_cast<float>(MAX_INT16), 0.0f, BCC_STATIC_CLASSIFIER);
      int col = i - word_start;
      choice->set_matrix_cell(col, col);
      bc_it.add_after_then_move(choice);
      word_res->ratings->put(col, col, choices);
    }
    int index = xcoords[word_end - 1];
    word_res->FakeWordFromRatings(best_nodes[index]->permuter);
    words->push_back(word_res);
    prev_space_cert = space_cert;
    if (word_end < num_ids && unichar_ids[word_end] == UNICHAR_SPACE)
      ++word_end;
  }
}

IsDawgFromBeamsIndex()

static bool tesseract::RecodeBeamSearch::IsDawgFromBeamsIndex ( int  index )

inlinestatic

Definition at line 224 of file recodebeam.h.

                                              {
    return index / (kNumLengths * NC_COUNT) > 0;
  }

LengthFromBeamsIndex()

static int tesseract::RecodeBeamSearch::LengthFromBeamsIndex ( int  index )

inlinestatic

Definition at line 220 of file recodebeam.h.

{ return index % kNumLengths; }

Member Data Documentation

kMinCertainty

const float tesseract::RecodeBeamSearch::kMinCertainty = -20.0f

static

Definition at line 213 of file recodebeam.h.

kNumBeams

const int tesseract::RecodeBeamSearch::kNumBeams = 2 * NC_COUNT * kNumLengths

static

Definition at line 218 of file recodebeam.h.

kNumLengths

const int tesseract::RecodeBeamSearch::kNumLengths = RecodedCharID::kMaxCodeLen + 1

static

Definition at line 215 of file recodebeam.h.

---

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

• /home/stefan/src/github/tesseract-ocr/tesseract/lstm/recodebeam.h
• /home/stefan/src/github/tesseract-ocr/tesseract/lstm/recodebeam.cpp