tesseract::RecodeBeamTest Class Reference

Inheritance diagram for tesseract::RecodeBeamTest:

Protected Member Functions
void	SetUp () override
	RecodeBeamTest ()
	~RecodeBeamTest () override
void	LoadUnicharset (const std::string &unicharset_name)
void	LoadDict (const std::string &lang)
void	ExpectCorrect (const GENERIC_2D_ARRAY< float > &output, const std::vector< int > &transcription)
void	ExpectCorrect (const GENERIC_2D_ARRAY< float > &output, const std::string &truth_utf8, Dict *dict, PointerVector< WERD_RES > *words)
GENERIC_2D_ARRAY< float >	GenerateRandomPaddedOutputs (const std::vector< int > &unichar_ids, int padding)
int	EncodeUTF8 (const char *utf8_str, float score, int start_t, TRand *random, GENERIC_2D_ARRAY< float > *outputs)
GENERIC_2D_ARRAY< float >	GenerateSyntheticOutputs (const char *chars1[], const float scores1[], const char *chars2[], const float scores2[], TRand *random)
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	SetUp ()
virtual void	TearDown ()

Protected Attributes
UnicharCompress	recoder_
int	unichar_null_char_ = 0
int	encoded_null_char_ = 0
CCUtil	ccutil_
Dict	lstm_dict_

Additional Inherited Members
Public Member Functions inherited from testing::Test
virtual	~Test ()
Static Public Member Functions inherited from testing::Test
static void	SetUpTestSuite ()
static void	TearDownTestSuite ()
static void	TearDownTestCase ()
static void	SetUpTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	IsSkipped ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)

Detailed Description

Definition at line 58 of file recodebeam_test.cc.

Constructor & Destructor Documentation

RecodeBeamTest()

tesseract::RecodeBeamTest::RecodeBeamTest ( )

inlineprotected

Definition at line 65 of file recodebeam_test.cc.

: lstm_dict_(&ccutil_) {}

~RecodeBeamTest()

tesseract::RecodeBeamTest::~RecodeBeamTest ( )

inlineoverrideprotected

Definition at line 66 of file recodebeam_test.cc.

                             {
    lstm_dict_.End();
  }

Member Function Documentation

EncodeUTF8()

int tesseract::RecodeBeamTest::EncodeUTF8 ( const char *  utf8_str, float  score, int  start_t, TRand *  random, GENERIC_2D_ARRAY< float > *  outputs  )

inlineprotected

Definition at line 244 of file recodebeam_test.cc.

                                                   {
    int t = start_t;
    std::vector<int> unichar_ids;
    EXPECT_TRUE(ccutil_.unicharset.encode_string(utf8_str, true, &unichar_ids, nullptr, nullptr));
    if (unichar_ids.empty() || utf8_str[0] == '\0') {
      unichar_ids.clear();
      unichar_ids.push_back(unichar_null_char_);
    }
    int num_ids = unichar_ids.size();
    for (int u = 0; u < num_ids; ++u) {
      RecodedCharID code;
      int len = recoder_.EncodeUnichar(unichar_ids[u], &code);
      EXPECT_NE(0, len);
      for (int i = 0; i < len; ++i) {
        // Apply the desired score.
        (*outputs)(t++, code(i)) = score;
        if (random != nullptr && t + (num_ids - u) * RecodedCharID::kMaxCodeLen < outputs->dim1()) {
          int dups = static_cast<int>(random->UnsignedRand(3.0));
          for (int d = 0; d < dups; ++d) {
            // Duplicate the desired score.
            (*outputs)(t++, code(i)) = score;
          }
        }
      }
      if (random != nullptr && t + (num_ids - u) * RecodedCharID::kMaxCodeLen < outputs->dim1()) {
        int dups = static_cast<int>(random->UnsignedRand(3.0));
        for (int d = 0; d < dups; ++d) {
          // Add a random number of nulls as well.
          (*outputs)(t++, encoded_null_char_) = score;
        }
      }
    }
    return t;
  }

ExpectCorrect() [1/2]

void tesseract::RecodeBeamTest::ExpectCorrect ( const GENERIC_2D_ARRAY< float > &  output, const std::string &  truth_utf8, Dict *  dict, PointerVector< WERD_RES > *  words  )

inlineprotected

Definition at line 115 of file recodebeam_test.cc.

                                                                 {
    RecodeBeamSearch beam_search(recoder_, encoded_null_char_, false, dict);
    beam_search.Decode(output, 3.5, -0.125, -25.0, nullptr);
    // Uncomment and/or change nullptr above to &ccutil_.unicharset to debug:
    // beam_search.DebugBeams(ccutil_.unicharset);
    std::vector<int> labels, xcoords;
    beam_search.ExtractBestPathAsLabels(&labels, &xcoords);
    LOG(INFO) << "Labels size = " << labels.size() << " coords " << xcoords.size() << "\n";
    // Now decode using recoder_.
    std::string decoded;
    int end = 1;
    for (unsigned start = 0; start < labels.size(); start = end) {
      RecodedCharID code;
      unsigned index = start;
      int uni_id = INVALID_UNICHAR_ID;
      do {
        code.Set(code.length(), labels[index++]);
        uni_id = recoder_.DecodeUnichar(code);
      } while (index < labels.size() && code.length() < RecodedCharID::kMaxCodeLen &&
               (uni_id == INVALID_UNICHAR_ID || !recoder_.IsValidFirstCode(labels[index])));
      EXPECT_NE(INVALID_UNICHAR_ID, uni_id) << "index=" << index << "/" << labels.size();
      // To the extent of truth_utf8, we expect decoded to match, but if
      // transcription is shorter, that is OK too, as we may just be testing
      // that we get a valid sequence when padded with random data.
      if (uni_id != unichar_null_char_ && decoded.size() < truth_utf8.size()) {
        decoded += ccutil_.unicharset.id_to_unichar(uni_id);
      }
      end = index;
    }
    EXPECT_EQ(truth_utf8, decoded);
 
    // Check that ExtractBestPathAsUnicharIds does the same thing.
    std::vector<int> unichar_ids;
    std::vector<float> certainties, ratings;
    beam_search.ExtractBestPathAsUnicharIds(false, &ccutil_.unicharset, &unichar_ids, &certainties,
                                            &ratings, &xcoords);
    std::string u_decoded;
    float total_rating = 0.0f;
    for (unsigned u = 0; u < unichar_ids.size(); ++u) {
      // To the extent of truth_utf8, we expect decoded to match, but if
      // transcription is shorter, that is OK too, as we may just be testing
      // that we get a valid sequence when padded with random data.
      if (u_decoded.size() < truth_utf8.size()) {
        const char *str = ccutil_.unicharset.id_to_unichar(unichar_ids[u]);
        total_rating += ratings[u];
        LOG(INFO) << u << ":u_id=" << unichar_ids[u] << "=" << str << ", c="
          << certainties[u] << ", r=" << ratings[u] << "r_sum="
          << total_rating << " @" << xcoords[u] << "\n";
        if (str[0] == ' ') {
          total_rating = 0.0f;
        }
        u_decoded += str;
      }
    }
    EXPECT_EQ(truth_utf8, u_decoded);
 
    // Check that ExtractBestPathAsWords does the same thing.
    TBOX line_box(0, 0, 100, 10);
    for (int i = 0; i < 2; ++i) {
      beam_search.ExtractBestPathAsWords(line_box, 1.0f, false, &ccutil_.unicharset, words);
      std::string w_decoded;
      for (int w = 0; w < words->size(); ++w) {
        const WERD_RES *word = (*words)[w];
        if (w_decoded.size() < truth_utf8.size()) {
          if (!w_decoded.empty() && word->word->space()) {
            w_decoded += " ";
          }
          w_decoded += word->best_choice->unichar_string().c_str();
        }
        LOG(INFO) << "Word:" << w << " = " << word->best_choice->unichar_string()
          << ", c=" << word->best_choice->certainty() << ", r=" << word->best_choice->rating()
          << ", perm=" << word->best_choice->permuter() << "\n";
      }
      std::string w_trunc(w_decoded.data(), truth_utf8.size());
      if (truth_utf8 != w_trunc) {
        tesseract::NormalizeUTF8String(
            tesseract::UnicodeNormMode::kNFKD, tesseract::OCRNorm::kNormalize,
            tesseract::GraphemeNorm::kNone, w_decoded.c_str(), &w_decoded);
        w_trunc.assign(w_decoded.data(), truth_utf8.size());
      }
      EXPECT_EQ(truth_utf8, w_trunc);
    }
  }

ExpectCorrect() [2/2]

void tesseract::RecodeBeamTest::ExpectCorrect ( const GENERIC_2D_ARRAY< float > &  output, const std::vector< int > &  transcription  )

inlineprotected

Definition at line 105 of file recodebeam_test.cc.

                                                          {
    // Get the utf8 string of the transcription.
    std::string truth_utf8;
    for (int i : transcription) {
      truth_utf8 += ccutil_.unicharset.id_to_unichar(i);
    }
    PointerVector<WERD_RES> words;
    ExpectCorrect(output, truth_utf8, nullptr, &words);
  }

GenerateRandomPaddedOutputs()

GENERIC_2D_ARRAY< float > tesseract::RecodeBeamTest::GenerateRandomPaddedOutputs ( const std::vector< int > &  unichar_ids, int  padding  )

inlineprotected

Definition at line 201 of file recodebeam_test.cc.

                                                                   {
    int width = unichar_ids.size() * 2 * RecodedCharID::kMaxCodeLen;
    int num_codes = recoder_.code_range();
    GENERIC_2D_ARRAY<float> outputs(width + padding, num_codes, 0.0f);
    // Fill with random data.
    TRand random;
    for (int t = 0; t < width; ++t) {
      for (int i = 0; i < num_codes; ++i) {
        outputs(t, i) = random.UnsignedRand(0.25);
      }
    }
    int t = 0;
    for (int unichar_id : unichar_ids) {
      RecodedCharID code;
      int len = recoder_.EncodeUnichar(unichar_id, &code);
      EXPECT_NE(0, len);
      for (int j = 0; j < len; ++j) {
        // Make the desired answer a clear winner.
        if (j > 0 && code(j) == code(j - 1)) {
          // We will collapse adjacent equal codes so put a null in between.
          outputs(t++, encoded_null_char_) = 1.0f;
        }
        outputs(t++, code(j)) = 1.0f;
      }
      // Put a 0 as a null char in between.
      outputs(t++, encoded_null_char_) = 1.0f;
    }
    // Normalize the probs.
    for (int t = 0; t < width; ++t) {
      double sum = 0.0;
      for (int i = 0; i < num_codes; ++i) {
        sum += outputs(t, i);
      }
      for (int i = 0; i < num_codes; ++i) {
        outputs(t, i) /= sum;
      }
    }
 
    return outputs;
  }

GenerateSyntheticOutputs()

GENERIC_2D_ARRAY< float > tesseract::RecodeBeamTest::GenerateSyntheticOutputs ( const char *  chars1[], const float  scores1[], const char *  chars2[], const float  scores2[], TRand *  random  )

inlineprotected

Definition at line 283 of file recodebeam_test.cc.

                                                                  {
    int width = 0;
    while (chars1[width] != nullptr) {
      ++width;
    }
    int padding = width * RecodedCharID::kMaxCodeLen;
    int num_codes = recoder_.code_range();
    GENERIC_2D_ARRAY<float> outputs(width + padding, num_codes, 0.0f);
    int t = 0;
    for (int i = 0; i < width; ++i) {
      // In case there is overlap in the codes between 1st and 2nd choice, it
      // is better to encode the 2nd choice first.
      int end_t2 = EncodeUTF8(chars2[i], scores2[i], t, random, &outputs);
      int end_t1 = EncodeUTF8(chars1[i], scores1[i], t, random, &outputs);
      // Advance t to the max end, setting everything else to the leftovers.
      int max_t = std::max(end_t1, end_t2);
      while (t < max_t) {
        double total_score = 0.0;
        for (int j = 0; j < num_codes; ++j) {
          total_score += outputs(t, j);
        }
        double null_remainder = (1.0 - total_score) / 2.0;
        double remainder = null_remainder / (num_codes - 2);
        if (outputs(t, encoded_null_char_) < null_remainder) {
          outputs(t, encoded_null_char_) += null_remainder;
        } else {
          remainder += remainder;
        }
        for (int j = 0; j < num_codes; ++j) {
          if (outputs(t, j) == 0.0f) {
            outputs(t, j) = remainder;
          }
        }
        ++t;
      }
    }
    // Fill the rest with null chars.
    while (t < width + padding) {
      outputs(t++, encoded_null_char_) = 1.0f;
    }
    return outputs;
  }

LoadDict()

void tesseract::RecodeBeamTest::LoadDict ( const std::string &  lang )

inlineprotected

Definition at line 94 of file recodebeam_test.cc.

                                       {
    std::string traineddata_name = lang + ".traineddata";
    std::string traineddata_file = file::JoinPath(TESTDATA_DIR, traineddata_name);
    lstm_dict_.SetupForLoad(nullptr);
    tesseract::TessdataManager mgr;
    mgr.Init(traineddata_file.c_str());
    lstm_dict_.LoadLSTM(lang.c_str(), &mgr);
    lstm_dict_.FinishLoad();
  }

LoadUnicharset()

void tesseract::RecodeBeamTest::LoadUnicharset ( const std::string &  unicharset_name )

inlineprotected

Definition at line 71 of file recodebeam_test.cc.

                                                        {
    std::string radical_stroke_file = file::JoinPath(LANGDATA_DIR, "radical-stroke.txt");
    std::string unicharset_file = file::JoinPath(TESTDATA_DIR, unicharset_name);
    std::string radical_data;
    CHECK_OK(file::GetContents(radical_stroke_file, &radical_data, file::Defaults()));
    CHECK(ccutil_.unicharset.load_from_file(unicharset_file.c_str()));
    unichar_null_char_ =
        ccutil_.unicharset.has_special_codes() ? UNICHAR_BROKEN : ccutil_.unicharset.size();
    std::string radical_str(radical_data.c_str());
    EXPECT_TRUE(recoder_.ComputeEncoding(ccutil_.unicharset, unichar_null_char_, &radical_str));
    RecodedCharID code;
    recoder_.EncodeUnichar(unichar_null_char_, &code);
    encoded_null_char_ = code(0);
    // Space should encode as itself.
    recoder_.EncodeUnichar(UNICHAR_SPACE, &code);
    EXPECT_EQ(UNICHAR_SPACE, code(0));
    std::string output_name = file::JoinPath(FLAGS_test_tmpdir, "testenc.txt");
    std::string encoding = recoder_.GetEncodingAsString(ccutil_.unicharset);
    std::string encoding_str(&encoding[0], encoding.size());
    CHECK_OK(file::SetContents(output_name, encoding_str, file::Defaults()));
    LOG(INFO) << "Wrote encoding to:" << output_name << "\n";
  }

SetUp()

void tesseract::RecodeBeamTest::SetUp ( )

inlineoverrideprotectedvirtual

Reimplemented from testing::Test.

Definition at line 60 of file recodebeam_test.cc.

                        {
    std::locale::global(std::locale(""));
    file::MakeTmpdir();
  }

Member Data Documentation

ccutil_

CCUtil tesseract::RecodeBeamTest::ccutil_

protected

Definition at line 330 of file recodebeam_test.cc.

encoded_null_char_

int tesseract::RecodeBeamTest::encoded_null_char_ = 0

protected

Definition at line 329 of file recodebeam_test.cc.

lstm_dict_

Dict tesseract::RecodeBeamTest::lstm_dict_

protected

Definition at line 331 of file recodebeam_test.cc.

recoder_

UnicharCompress tesseract::RecodeBeamTest::recoder_

protected

Definition at line 327 of file recodebeam_test.cc.

unichar_null_char_

int tesseract::RecodeBeamTest::unichar_null_char_ = 0

protected

Definition at line 328 of file recodebeam_test.cc.

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/unittest/recodebeam_test.cc