tesseract::ValidateKhmer Class Reference

#include <validate_khmer.h>

Inheritance diagram for tesseract::ValidateKhmer:

Public Member Functions
	ValidateKhmer (ViramaScript script, bool report_errors)
	~ValidateKhmer ()
Public Member Functions inherited from tesseract::Validator
virtual	~Validator ()

Protected Member Functions
bool	ConsumeGraphemeIfValid () override
CharClass	UnicodeToCharClass (char32 ch) const override
Protected Member Functions inherited from tesseract::Validator
	Validator (ViramaScript script, bool report_errors)
bool	ValidateCleanAndSegmentInternal (GraphemeNormMode g_mode, const std::vector< char32 > &src, std::vector< std::vector< char32 >> *dest)
void	MoveResultsToDest (GraphemeNormMode g_mode, std::vector< std::vector< char32 >> *dest)
bool	IsSubscriptScript () const
bool	CodeOnlyToOutput ()
void	MultiCodePart (unsigned length)
bool	UseMultiCode (unsigned length)
void	ComputeClassCodes (const std::vector< char32 > &text)
void	Clear ()

Additional Inherited Members
Static Public Member Functions inherited from tesseract::Validator
static bool	ValidateCleanAndSegment (GraphemeNormMode g_mode, bool report_errors, const std::vector< char32 > &src, std::vector< std::vector< char32 >> *dest)
static bool	IsZeroWidthMark (char32 ch)
Static Public Attributes inherited from tesseract::Validator
static const char32	kZeroWidthSpace = 0x200B
static const char32	kZeroWidthNonJoiner = 0x200C
static const char32	kZeroWidthJoiner = 0x200D
static const char32	kLeftToRightMark = 0x200E
static const char32	kRightToLeftMark = 0x200F
static const char32	kInvalid = 0xfffd
Protected Types inherited from tesseract::Validator
enum	CharClass {   CharClass::kConsonant = 'C', CharClass::kVowel = 'V', CharClass::kVirama = 'H', CharClass::kMatra = 'M',   CharClass::kMatraPiece = 'P', CharClass::kVowelModifier = 'D', CharClass::kZeroWidthNonJoiner = 'z', CharClass::kZeroWidthJoiner = 'Z',   CharClass::kVedicMark = 'v', CharClass::kNukta = 'N', CharClass::kRobat = 'R', CharClass::kOther = 'O',   CharClass::kWhitespace = ' ', CharClass::kCombiner = 'c' }
using	IndicPair = std::pair< CharClass, char32 >
Static Protected Member Functions inherited from tesseract::Validator
static std::unique_ptr< Validator >	ScriptValidator (ViramaScript script, bool report_errors)
static ViramaScript	MostFrequentViramaScript (const std::vector< char32 > &utf32)
static bool	IsVirama (char32 unicode)
static bool	IsVedicAccent (char32 unicode)
Protected Attributes inherited from tesseract::Validator
ViramaScript	script_
std::vector< IndicPair >	codes_
std::vector< std::vector< char32 > >	parts_
std::vector< char32 >	output_
unsigned	codes_used_
unsigned	output_used_
bool	report_errors_
Static Protected Attributes inherited from tesseract::Validator
static const int	kIndicCodePageSize = 128
static const char32	kMinIndicUnicode = 0x900
static const char32	kMaxSinhalaUnicode = 0xdff
static const char32	kMaxViramaScriptUnicode = 0x17ff
static const char32	kSinhalaVirama = 0xdca
static const char32	kMyanmarVirama = 0x1039
static const char32	kKhmerVirama = 0x17d2
static const char32	kJavaneseVirama = 0xa9c0
static const char32	kMaxJavaneseUnicode = 0xa9df

Detailed Description

Definition at line 9 of file validate_khmer.h.

Constructor & Destructor Documentation

ValidateKhmer()

tesseract::ValidateKhmer::ValidateKhmer ( ViramaScript  script, bool  report_errors  )

inline

Definition at line 11 of file validate_khmer.h.

      : Validator(script, report_errors) {}

~ValidateKhmer()

tesseract::ValidateKhmer::~ValidateKhmer ( )

inline

Definition at line 13 of file validate_khmer.h.

{}

Member Function Documentation

ConsumeGraphemeIfValid()

bool tesseract::ValidateKhmer::ConsumeGraphemeIfValid ( )

overrideprotectedvirtual

Implements tesseract::Validator.

Definition at line 20 of file validate_khmer.cpp.

                                           {
  const unsigned num_codes = codes_.size();
  if (codes_used_ == num_codes) return false;
  if (codes_[codes_used_].first == CharClass::kOther) {
    UseMultiCode(1);
    return true;
  }
  if (codes_[codes_used_].first != CharClass::kConsonant) {
    if (report_errors_) {
      tprintf("Invalid start of Khmer syllable:0x%x\n",
              codes_[codes_used_].second);
    }
    return false;
  }
  if (UseMultiCode(1)) return true;
  if (codes_[codes_used_].first == CharClass::kRobat ||
      codes_[codes_used_].first == CharClass::kNukta) {
    if (UseMultiCode(1)) return true;
  }
  while (codes_used_ + 1 < num_codes &&
         codes_[codes_used_].first == CharClass::kVirama &&
         codes_[codes_used_ + 1].first == CharClass::kConsonant) {
    ASSERT_HOST(!CodeOnlyToOutput());
    if (UseMultiCode(2)) return true;
    if (codes_[codes_used_].first == CharClass::kRobat) {
      if (UseMultiCode(1)) return true;
    }
  }
  unsigned num_matra_parts = 0;
  if (codes_[codes_used_].second == kZeroWidthJoiner ||
      codes_[codes_used_].second == kZeroWidthNonJoiner) {
    if (CodeOnlyToOutput()) {
      if (report_errors_) {
        tprintf("Unterminated joiner: 0x%x\n", output_.back());
      }
      return false;
    }
    ++num_matra_parts;
  }
  // Not quite as shown by the BNF, the matra piece is allowed as a matra on its
  // own or as an addition to other matras.
  if (codes_[codes_used_].first == CharClass::kMatra ||
      codes_[codes_used_].first == CharClass::kMatraPiece) {
    ++num_matra_parts;
    if (UseMultiCode(num_matra_parts)) return true;
  } else if (num_matra_parts) {
    if (report_errors_) {
      tprintf("Joiner with non-dependent vowel after it!:0x%x 0x%x\n",
              output_.back(), codes_[codes_used_].second);
    }
    return false;
  }
  if (codes_[codes_used_].first == CharClass::kMatraPiece &&
      codes_[codes_used_ - 1].first != CharClass::kMatraPiece) {
    if (UseMultiCode(1)) return true;
  }
  if (codes_[codes_used_].first == CharClass::kVowelModifier) {
    if (UseMultiCode(1)) return true;
  }
  if (codes_used_ + 1 < num_codes &&
      codes_[codes_used_].first == CharClass::kVirama &&
      codes_[codes_used_ + 1].first == CharClass::kConsonant) {
    ASSERT_HOST(!CodeOnlyToOutput());
    if (UseMultiCode(2)) return true;
  }
  return true;
}

UnicodeToCharClass()

Validator::CharClass tesseract::ValidateKhmer::UnicodeToCharClass ( char32  ch ) const

overrideprotectedvirtual

Implements tesseract::Validator.

Definition at line 88 of file validate_khmer.cpp.

                                                                    {
  if (IsVedicAccent(ch)) return CharClass::kVedicMark;
  if (ch == kZeroWidthNonJoiner) return CharClass::kZeroWidthNonJoiner;
  if (ch == kZeroWidthJoiner) return CharClass::kZeroWidthJoiner;
  // Offset from the start of the relevant unicode code block aka code page.
  int off = ch - static_cast<char32>(script_);
  // Anything in another code block is other.
  if (off < 0 || off >= kIndicCodePageSize) return CharClass::kOther;
  if (off <= 0x33) return CharClass::kConsonant;
  if (off <= 0x45) return CharClass::kMatra;
  if (off == 0x46) return CharClass::kMatraPiece;
  if (off == 0x4c) return CharClass::kRobat;
  if (off == 0x49 || off == 0x4a) return CharClass::kNukta;
  if (off <= 0x51) return CharClass::kVowelModifier;
  if (off == 0x52) return CharClass::kVirama;
  return CharClass::kOther;
}

---

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

• /tesseract/src/training/validate_khmer.h
• /tesseract/src/training/validate_khmer.cpp