tesseract::TextlineProjectionTest Class Reference

Inheritance diagram for tesseract::TextlineProjectionTest:

Protected Member Functions
std::string	OutputNameToPath (const std::string &name)
	TextlineProjectionTest ()
	~TextlineProjectionTest () override
void	SetImage (const char *filename)
void	SetupProjection ()
void	EvaluateBox (const TBOX &box, bool greater_or_equal, int target_value, const char *text, const char *message)
void	EvaluateDistance (const TBOX &box, const TBOX &true_box, const TBOX &false_box, const char *text, const char *message)
void	VerifyBoxes (const char *imagefile, int line_height)
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	SetUp ()
virtual void	TearDown ()

Protected Attributes
Image	src_pix_
Image	bin_pix_
BLOCK_LIST	blocks_
std::string	ocr_text_
tesseract::TessBaseAPI	api_
std::unique_ptr< Tesseract >	tesseract_
ColumnFinder *	finder_
const DENORM *	denorm_
const TextlineProjection *	projection_

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 33 of file textlineprojection_test.cc.

Constructor & Destructor Documentation

TextlineProjectionTest()

tesseract::TextlineProjectionTest::TextlineProjectionTest ( )

inlineprotected

Definition at line 40 of file textlineprojection_test.cc.

                           {
    src_pix_ = nullptr;
    bin_pix_ = nullptr;
    finder_ = nullptr;
    denorm_ = nullptr;
    projection_ = nullptr;
  }

~TextlineProjectionTest()

tesseract::TextlineProjectionTest::~TextlineProjectionTest ( )

inlineoverrideprotected

Definition at line 47 of file textlineprojection_test.cc.

                                     {
    src_pix_.destroy();
    bin_pix_.destroy();
    delete finder_;
  }

Member Function Documentation

EvaluateBox()

void tesseract::TextlineProjectionTest::EvaluateBox ( const TBOX &  box, bool  greater_or_equal, int  target_value, const char *  text, const char *  message  )

inlineprotected

Definition at line 112 of file textlineprojection_test.cc.

                                        {
    int value = projection_->EvaluateBox(box, denorm_, false);
    if (greater_or_equal != (value > target_value)) {
      LOG(INFO) << "EvaluateBox too " << (greater_or_equal ? "low" : "high")
        << ":" << value << " vs " << target_value << " for " << message << " word '" << text << "' at:";
      box.print();
      value = projection_->EvaluateBox(box, denorm_, true);
    } else {
      LOG(INFO) << "EvaluateBox OK(" << value << ") for " << message << " word '" << text << "'";
    }
    if (greater_or_equal) {
      EXPECT_GE(value, target_value);
    } else {
      EXPECT_LT(value, target_value);
    }
  }

EvaluateDistance()

void tesseract::TextlineProjectionTest::EvaluateDistance ( const TBOX &  box, const TBOX &  true_box, const TBOX &  false_box, const char *  text, const char *  message  )

inlineprotected

Definition at line 132 of file textlineprojection_test.cc.

                                                               {
    int true_dist = projection_->DistanceOfBoxFromBox(box, true_box, true, denorm_, false);
    int false_dist = projection_->DistanceOfBoxFromBox(box, false_box, true, denorm_, false);
    if (false_dist <= true_dist) {
      LOG(INFO) << "Distance wrong:" << false_dist << " vs " << true_dist
        << " for " << message << " word '" << text << "' at:";
      true_box.print();
      projection_->DistanceOfBoxFromBox(box, true_box, true, denorm_, true);
      projection_->DistanceOfBoxFromBox(box, false_box, true, denorm_, true);
    } else {
      LOG(INFO) << "Distance OK(" << false_dist << " vs " << true_dist
        << ") for " << message << " word '" << text << "'";
    }
  }

OutputNameToPath()

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

inlineprotected

Definition at line 35 of file textlineprojection_test.cc.

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

SetImage()

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

inlineprotected

Definition at line 53 of file textlineprojection_test.cc.

                                      {
    src_pix_.destroy();
    src_pix_ = pixRead(file::JoinPath(TESTING_DIR, filename).c_str());
    api_.Init(TESSDATA_DIR, "eng", tesseract::OEM_TESSERACT_ONLY);
    api_.SetPageSegMode(tesseract::PSM_AUTO_OSD);
    api_.SetImage(src_pix_);
  }

SetupProjection()

void tesseract::TextlineProjectionTest::SetupProjection ( )

inlineprotected

Definition at line 68 of file textlineprojection_test.cc.

                         {
    tesseract::TessdataManager mgr;
    auto osd_tess = std::make_unique<Tesseract>();
    OSResults osr;
    EXPECT_EQ(osd_tess->init_tesseract(TESSDATA_DIR, "", "osd", tesseract::OEM_TESSERACT_ONLY,
                                       nullptr, 0, nullptr, nullptr, false, &mgr),
              0);
    tesseract_ = std::make_unique<Tesseract>();
    EXPECT_EQ(tesseract_->init_tesseract(TESSDATA_DIR, "", "eng", tesseract::OEM_TESSERACT_ONLY,
                                         nullptr, 0, nullptr, nullptr, false, &mgr),
              0);
    bin_pix_ = api_.GetThresholdedImage();
    *tesseract_->mutable_pix_binary() = bin_pix_.clone();
    osd_tess->set_source_resolution(api_.tesseract()->source_resolution());
    tesseract_->set_source_resolution(api_.tesseract()->source_resolution());
    int width = pixGetWidth(bin_pix_);
    int height = pixGetHeight(bin_pix_);
    // First make a single block covering the whole image.
    auto *block = new BLOCK("", true, 0, 0, 0, 0, width, height);
    block->set_right_to_left(false);
    BLOCK_LIST src_blocks;
    BLOCK_IT block_it(&src_blocks);
    block_it.add_to_end(block);
    Image photomask_pix = nullptr;
    // The blocks made by the ColumnFinder. Moved to blocks before return.
    BLOCK_LIST found_blocks;
    TO_BLOCK_LIST temp_blocks;
    finder_ =
        tesseract_->SetupPageSegAndDetectOrientation(tesseract::PSM_AUTO_OSD, &src_blocks, osd_tess.get(),
                                                     &osr, &temp_blocks, &photomask_pix, nullptr);
    TO_BLOCK_IT to_block_it(&temp_blocks);
    TO_BLOCK *to_block = to_block_it.data();
    denorm_ = finder_->denorm();
    TO_BLOCK_LIST to_blocks;
    BLOBNBOX_LIST diacritic_blobs;
    EXPECT_GE(finder_->FindBlocks(tesseract::PSM_AUTO, nullptr, 1, to_block, photomask_pix, nullptr,
                                  nullptr, nullptr, &found_blocks, &diacritic_blobs, &to_blocks),
              0);
    projection_ = finder_->projection();
    photomask_pix.destroy();
  }

VerifyBoxes()

void tesseract::TextlineProjectionTest::VerifyBoxes ( const char *  imagefile, int  line_height  )

inlineprotected

Definition at line 150 of file textlineprojection_test.cc.

                                                           {
    SetImage(imagefile);
    api_.Recognize(nullptr);
    SetupProjection();
    MutableIterator *it = api_.GetMutableIterator();
    do {
      char *text = it->GetUTF8Text(tesseract::RIL_WORD);
      const PAGE_RES_IT *pr_it = it->PageResIt();
      WERD_RES *word = pr_it->word();
      // The word_box refers to the internal, possibly rotated, coords.
      TBOX word_box = word->word->bounding_box();
      bool small_word = word_box.height() * 1.5 < line_height;
      bool tall_word = word_box.height() * 1.125 > line_height;
      // We pad small and tall words differently because ascenders and
      // descenders affect the position and size of the upper/lower boxes.
      int padding;
      if (small_word) {
        padding = word_box.height();
      } else if (tall_word) {
        padding = word_box.height() / 3;
      } else {
        padding = word_box.height() / 2;
      }
      // Test that the word box gets a good score.
      EvaluateBox(word_box, true, kMinStrongTextValue, text, "Real Word");
 
      // Now test a displaced box, both above and below the word.
      TBOX upper_box(word_box);
      upper_box.set_bottom(word_box.top());
      upper_box.set_top(word_box.top() + padding);
      EvaluateBox(upper_box, false, kMinStrongTextValue, text, "Upper Word");
      EvaluateBox(upper_box, true, -1, text, "Upper Word not vertical");
      TBOX lower_box = word_box;
      lower_box.set_top(word_box.bottom());
      lower_box.set_bottom(word_box.bottom() - padding);
      if (tall_word) {
        lower_box.move(ICOORD(0, padding / 2));
      }
      EvaluateBox(lower_box, false, kMinStrongTextValue, text, "Lower Word");
      EvaluateBox(lower_box, true, -1, text, "Lower Word not vertical");
 
      // Since some words have no text below and some words have no text above
      // check that at least one of the boxes satisfies BoxOutOfTextline.
      bool upper_or_lower_out_of_textline =
          projection_->BoxOutOfHTextline(upper_box, denorm_, false) ||
          projection_->BoxOutOfHTextline(lower_box, denorm_, false);
      if (!upper_or_lower_out_of_textline) {
        projection_->BoxOutOfHTextline(upper_box, denorm_, true);
        projection_->BoxOutOfHTextline(lower_box, denorm_, true);
      }
      EXPECT_TRUE(upper_or_lower_out_of_textline);
 
      // Now test DistanceOfBoxFromBox by faking a challenger word, and asking
      // that each pad box be nearer to its true textline than the
      // challenger. Due to the tight spacing of latin text, getting
      // the right position and size of these test boxes is quite fiddly.
      padding = line_height / 4;
      upper_box.set_top(upper_box.bottom() + padding);
      TBOX target_box(word_box);
      if (!small_word) {
        upper_box.move(ICOORD(0, -padding * 3 / 2));
      }
      target_box.set_top(upper_box.bottom());
      TBOX upper_challenger(upper_box);
      upper_challenger.set_bottom(upper_box.top());
      upper_challenger.set_top(upper_box.top() + word_box.height());
      EvaluateDistance(upper_box, target_box, upper_challenger, text, "Upper Word");
      if (tall_word) {
        lower_box.move(ICOORD(0, padding / 2));
      }
      lower_box.set_bottom(lower_box.top() - padding);
      target_box = word_box;
      target_box.set_bottom(lower_box.top());
      TBOX lower_challenger(lower_box);
      lower_challenger.set_top(lower_box.bottom());
      lower_challenger.set_bottom(lower_box.bottom() - word_box.height());
      EvaluateDistance(lower_box, target_box, lower_challenger, text, "Lower Word");
 
      delete[] text;
    } while (it->Next(tesseract::RIL_WORD));
    delete it;
  }

Member Data Documentation

api_

tesseract::TessBaseAPI tesseract::TextlineProjectionTest::api_

protected

Definition at line 237 of file textlineprojection_test.cc.

bin_pix_

Image tesseract::TextlineProjectionTest::bin_pix_

protected

Definition at line 234 of file textlineprojection_test.cc.

blocks_

BLOCK_LIST tesseract::TextlineProjectionTest::blocks_

protected

Definition at line 235 of file textlineprojection_test.cc.

denorm_

const DENORM* tesseract::TextlineProjectionTest::denorm_

protected

Definition at line 240 of file textlineprojection_test.cc.

finder_

ColumnFinder* tesseract::TextlineProjectionTest::finder_

protected

Definition at line 239 of file textlineprojection_test.cc.

ocr_text_

std::string tesseract::TextlineProjectionTest::ocr_text_

protected

Definition at line 236 of file textlineprojection_test.cc.

projection_

const TextlineProjection* tesseract::TextlineProjectionTest::projection_

protected

Definition at line 241 of file textlineprojection_test.cc.

src_pix_

Image tesseract::TextlineProjectionTest::src_pix_

protected

Definition at line 233 of file textlineprojection_test.cc.

tesseract_

std::unique_ptr<Tesseract> tesseract::TextlineProjectionTest::tesseract_

protected

Definition at line 238 of file textlineprojection_test.cc.

---

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

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