tesseract::ResultIteratorTest Class Reference

Inheritance diagram for tesseract::ResultIteratorTest:

Protected Member Functions
std::string	TestDataNameToPath (const std::string &name)
std::string	TessdataPath ()
std::string	OutputNameToPath (const std::string &name)
	ResultIteratorTest ()
	~ResultIteratorTest () override=default
void	SetImage (const char *filename)
void	VerifyRebuild (int max_diff, PageIteratorLevel level, PageIterator *it)
void	VerifyIteratorText (const std::string &truth, PageIteratorLevel level, ResultIterator *it)
void	VerifyRebuilds (int block_limit, int para_limit, int line_limit, int word_limit, int symbol_limit, PageIterator *it, PageIteratorLevel maxlevel=tesseract::RIL_SYMBOL)
void	VerifyAllText (const std::string &truth, ResultIterator *it)
void	ExpectTextlineReadingOrder (bool in_ltr_context, const StrongScriptDirection *word_dirs, int num_words, int *expected_reading_order, int num_reading_order_entries) const
void	VerifySaneTextlineOrder (bool in_ltr_context, const StrongScriptDirection *word_dirs, int num_words) const
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	SetUp ()
virtual void	TearDown ()

Protected Attributes
Image	src_pix_
std::string	ocr_text_
tesseract::TessBaseAPI	api_

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 17 of file resultiterator_test.cc.

Constructor & Destructor Documentation

ResultIteratorTest()

tesseract::ResultIteratorTest::ResultIteratorTest ( )

inlineprotected

Definition at line 30 of file resultiterator_test.cc.

                       {
    src_pix_ = nullptr;
  }

~ResultIteratorTest()

tesseract::ResultIteratorTest::~ResultIteratorTest ( )

overrideprotecteddefault

Member Function Documentation

ExpectTextlineReadingOrder()

void tesseract::ResultIteratorTest::ExpectTextlineReadingOrder ( bool  in_ltr_context, const StrongScriptDirection *  word_dirs, int  num_words, int *  expected_reading_order, int  num_reading_order_entries  ) const

inlineprotected

Definition at line 156 of file resultiterator_test.cc.

                                                                       {
    std::vector<StrongScriptDirection> gv_word_dirs;
    for (int i = 0; i < num_words; i++) {
      gv_word_dirs.push_back(word_dirs[i]);
    }
 
    std::vector<int> calculated_order;
    ResultIterator::CalculateTextlineOrder(in_ltr_context, gv_word_dirs, &calculated_order);
    // STL vector can be used with EXPECT_EQ, so convert...
    std::vector<int> correct_order(expected_reading_order,
                                   expected_reading_order + num_reading_order_entries);
    EXPECT_EQ(correct_order, calculated_order);
  }

OutputNameToPath()

std::string tesseract::ResultIteratorTest::OutputNameToPath ( const std::string &  name )

inlineprotected

Definition at line 25 of file resultiterator_test.cc.

                                                    {
    file::MakeTmpdir();
    return file::JoinPath(FLAGS_test_tmpdir, name);
  }

SetImage()

void tesseract::ResultIteratorTest::SetImage ( const char *  filename )

inlineprotected

Definition at line 35 of file resultiterator_test.cc.

                                      {
    src_pix_ = pixRead(TestDataNameToPath(filename).c_str());
    api_.Init(TessdataPath().c_str(), "eng", tesseract::OEM_TESSERACT_ONLY);
    //    if (!FLAGS_tess_config.empty())
    //      api_.ReadConfigFile(FLAGS_tess_config.c_str());
    api_.SetPageSegMode(tesseract::PSM_AUTO);
    api_.SetImage(src_pix_);
    src_pix_.destroy();
    src_pix_ = api_.GetInputImage();
  }

TessdataPath()

std::string tesseract::ResultIteratorTest::TessdataPath ( )

inlineprotected

Definition at line 22 of file resultiterator_test.cc.

                           {
    return file::JoinPath(TESSDATA_DIR, "");
  }

TestDataNameToPath()

std::string tesseract::ResultIteratorTest::TestDataNameToPath ( const std::string &  name )

inlineprotected

Definition at line 19 of file resultiterator_test.cc.

                                                      {
    return file::JoinPath(TESTING_DIR, name);
  }

VerifyAllText()

void tesseract::ResultIteratorTest::VerifyAllText ( const std::string &  truth, ResultIterator *  it  )

inlineprotected

Definition at line 143 of file resultiterator_test.cc.

                                                                 {
    VerifyIteratorText(truth, tesseract::RIL_BLOCK, it);
    VerifyIteratorText(truth, tesseract::RIL_PARA, it);
    VerifyIteratorText(truth, tesseract::RIL_TEXTLINE, it);
    VerifyIteratorText(truth, tesseract::RIL_WORD, it);
    VerifyIteratorText(truth, tesseract::RIL_SYMBOL, it);
  }

VerifyIteratorText()

void tesseract::ResultIteratorTest::VerifyIteratorText ( const std::string &  truth, PageIteratorLevel  level, ResultIterator *  it  )

inlineprotected

Definition at line 108 of file resultiterator_test.cc.

                                                                                               {
    LOG(INFO) << "Text Test Level " << level << "\n";
    it->Begin();
    std::string result;
    do {
      char *text = it->GetUTF8Text(level);
      result += text;
      delete[] text;
      if ((level == tesseract::RIL_WORD || level == tesseract::RIL_SYMBOL) &&
          it->IsAtFinalElement(tesseract::RIL_WORD, level)) {
        if (it->IsAtFinalElement(tesseract::RIL_TEXTLINE, level)) {
          result += '\n';
        } else {
          result += ' ';
        }
        if (it->IsAtFinalElement(tesseract::RIL_PARA, level) &&
            !(it->IsAtFinalElement(tesseract::RIL_BLOCK, level))) {
          result += '\n';
        }
      }
    } while (it->Next(level));
    EXPECT_STREQ(truth.c_str(), result.c_str()) << "Rebuild failed at Text Level " << level;
  }

VerifyRebuild()

void tesseract::ResultIteratorTest::VerifyRebuild ( int  max_diff, PageIteratorLevel  level, PageIterator *  it  )

inlineprotected

Definition at line 49 of file resultiterator_test.cc.

                                                                              {
    it->Begin();
    int width = pixGetWidth(src_pix_);
    int height = pixGetHeight(src_pix_);
    int depth = pixGetDepth(src_pix_);
    Image pix = pixCreate(width, height, depth);
    EXPECT_TRUE(depth == 1 || depth == 8);
    if (depth == 8) {
      pixSetAll(pix);
    }
    do {
      int left, top, right, bottom;
      PageIteratorLevel im_level = level;
      // If the return is false, it is a non-text block so get the block image.
      if (!it->BoundingBox(level, &left, &top, &right, &bottom)) {
        im_level = tesseract::RIL_BLOCK;
        EXPECT_TRUE(it->BoundingBox(im_level, &left, &top, &right, &bottom));
      }
      LOG(INFO) << "BBox: [L:" << left << ", T:" << top << ", R:" << right << ", B:" << bottom
                << "]"
                << "\n";
      Image block_pix;
      if (depth == 1) {
        block_pix = it->GetBinaryImage(im_level);
        pixRasterop(pix, left, top, right - left, bottom - top, PIX_SRC ^ PIX_DST, block_pix, 0, 0);
      } else {
        block_pix = it->GetImage(im_level, 2, src_pix_, &left, &top);
        pixRasterop(pix, left, top, pixGetWidth(block_pix), pixGetHeight(block_pix),
                    PIX_SRC & PIX_DST, block_pix, 0, 0);
      }
      CHECK(block_pix != nullptr);
      block_pix.destroy();
    } while (it->Next(level));
    //    if (base::GetFlag(FLAGS_v) >= 1)
    //      pixWrite(OutputNameToPath("rebuilt.png").c_str(), pix, IFF_PNG);
    pixRasterop(pix, 0, 0, width, height, PIX_SRC ^ PIX_DST, src_pix_, 0, 0);
    if (depth == 8) {
      Image binary_pix = pixThresholdToBinary(pix, 128);
      pix.destroy();
      pixInvert(binary_pix, binary_pix);
      pix = binary_pix;
    }
    //    if (base::GetFlag(FLAGS_v) >= 1)
    //      pixWrite(OutputNameToPath("rebuiltxor.png").c_str(), pix, IFF_PNG);
    l_int32 pixcount;
    pixCountPixels(pix, &pixcount, nullptr);
    if (pixcount > max_diff) {
      std::string outfile = OutputNameToPath("failedxor.png");
      LOG(INFO) << "outfile = " << outfile << "\n";
      pixWrite(outfile.c_str(), pix, IFF_PNG);
    }
    pix.destroy();
    LOG(INFO) << "At level " << level << ": pix diff = " << pixcount << "\n";
    EXPECT_LE(pixcount, max_diff);
    //    if (base::GetFlag(FLAGS_v) > 1) CHECK_LE(pixcount, max_diff);
  }

VerifyRebuilds()

void tesseract::ResultIteratorTest::VerifyRebuilds ( int  block_limit, int  para_limit, int  line_limit, int  word_limit, int  symbol_limit, PageIterator *  it, PageIteratorLevel  maxlevel = tesseract::RIL_SYMBOL  )

inlineprotected

Definition at line 132 of file resultiterator_test.cc.

                                                                                                          {
    VerifyRebuild(block_limit, tesseract::RIL_BLOCK, it);
    VerifyRebuild(para_limit, tesseract::RIL_PARA, it);
    VerifyRebuild(line_limit, tesseract::RIL_TEXTLINE, it);
    VerifyRebuild(word_limit, tesseract::RIL_WORD, it);
    if (maxlevel == tesseract::RIL_SYMBOL) {
      VerifyRebuild(symbol_limit, maxlevel, it);
    }
  }

VerifySaneTextlineOrder()

void tesseract::ResultIteratorTest::VerifySaneTextlineOrder ( bool  in_ltr_context, const StrongScriptDirection *  word_dirs, int  num_words  ) const

inlineprotected

Definition at line 176 of file resultiterator_test.cc.

                                                    {
    std::vector<StrongScriptDirection> gv_word_dirs;
    for (int i = 0; i < num_words; i++) {
      gv_word_dirs.push_back(word_dirs[i]);
    }
 
    std::vector<int> output;
    ResultIterator::CalculateTextlineOrder(in_ltr_context, gv_word_dirs, &output);
    ASSERT_GE(output.size(), num_words);
    std::vector<int> output_copy(output);
    std::sort(output_copy.begin(), output_copy.end());
    bool sane = true;
    unsigned j = 0;
    while (j < output_copy.size() && output_copy[j] < 0) {
      j++;
    }
    for (int i = 0; i < num_words; i++, j++) {
      if (output_copy[j] != i) {
        sane = false;
        break;
      }
    }
    if (j != output_copy.size()) {
      sane = false;
    }
    if (!sane) {
      std::vector<int> empty;
      EXPECT_EQ(output, empty) << " permutation of 0.." << num_words - 1 << " not found in "
                               << (in_ltr_context ? "ltr" : "rtl") << " context.";
    }
  }

Member Data Documentation

api_

tesseract::TessBaseAPI tesseract::ResultIteratorTest::api_

protected

Definition at line 212 of file resultiterator_test.cc.

ocr_text_

std::string tesseract::ResultIteratorTest::ocr_text_

protected

Definition at line 211 of file resultiterator_test.cc.

src_pix_

Image tesseract::ResultIteratorTest::src_pix_

protected

Definition at line 210 of file resultiterator_test.cc.

---

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

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