#include <validate_indic.h>

Inheritance diagram for tesseract::ValidateIndic:

Public Member Functions
	ValidateIndic (ViramaScript script, bool report_errors)

	~ValidateIndic () override=default

Public Member Functions inherited from tesseract::Validator
virtual	~Validator ()

Protected Member Functions
bool	ConsumeGraphemeIfValid () override

Validator::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)

virtual bool	ConsumeGraphemeIfValid ()=0

void	ComputeClassCodes (const std::vector< char32 > &text)

virtual CharClass	UnicodeToCharClass (char32 ch) const =0

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 class	CharClass { kConsonant = 'C' , kVowel = 'V' , kVirama = 'H' , kMatra = 'M' , kMatraPiece = 'P' , kVowelModifier = 'D' , kZeroWidthNonJoiner = 'z' , kZeroWidthJoiner = 'Z' , kVedicMark = 'v' , kNukta = 'N' , kRobat = 'R' , kOther = 'O' , kWhitespace = ' ' , 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 10 of file validate_indic.h.

Constructor & Destructor Documentation

◆ ValidateIndic()

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

inline

Definition at line 12 of file validate_indic.h.

12: Validator(script, report_errors) {}

tesseract::Validator::Validator

Validator(ViramaScript script, bool report_errors)

Definition: validator.h:137

◆ ~ValidateIndic()

tesseract::ValidateIndic::~ValidateIndic ( )

overridedefault

Member Function Documentation

◆ ConsumeGraphemeIfValid()

bool tesseract::ValidateIndic::ConsumeGraphemeIfValid ( )

overrideprotectedvirtual

Implements tesseract::Validator.

Definition at line 18 of file validate_indic.cpp.

                                           {
  switch (codes_[codes_used_].first) {
    case CharClass::kConsonant:
      return ConsumeConsonantHeadIfValid() && ConsumeConsonantTailIfValid();
    case CharClass::kVowel:
    case CharClass::kVedicMark:
      return ConsumeVowelIfValid();
    case CharClass::kZeroWidthJoiner:
    case CharClass::kZeroWidthNonJoiner:
      // Apart from within an aksara, joiners are silently dropped.
      if (report_errors_) {
        tprintf("Dropping isolated joiner: 0x%x\n", codes_[codes_used_].second);
      }
      ++codes_used_;
      return true;
    case CharClass::kOther:
      UseMultiCode(1);
      return true;
    default:
      if (report_errors_) {
        tprintf("Invalid start of grapheme sequence:%c=0x%x\n",
                static_cast<int>(codes_[codes_used_].first),
                codes_[codes_used_].second);
      }
      return false;
  }
}

◆ UnicodeToCharClass()

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

overrideprotectedvirtual

Implements tesseract::Validator.

Definition at line 46 of file validate_indic.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 base = static_cast<char32>(script_);
  int off = ch - base;
  // Anything in another code block is other.
  if (off < 0 || off >= kIndicCodePageSize) {
    return CharClass::kOther;
  }
  // Exception for Tamil. The aytham character is considered a letter.
  if (script_ == ViramaScript::kTamil && off == 0x03) {
    return CharClass::kVowel;
  }
  if (off < 0x4) {
    return CharClass::kVowelModifier;
  }
  if (script_ == ViramaScript::kSinhala) {
    // Sinhala is an exception.
    if (off <= 0x19) {
      return CharClass::kVowel;
    }
    if (off <= 0x49) {
      return CharClass::kConsonant;
    }
    if (off == 0x4a) {
      return CharClass::kVirama;
    }
    if (off <= 0x5f) {
      return CharClass::kMatra;
    }
  } else {
    if (off <= 0x14 || off == 0x50) {
      return CharClass::kVowel;
    }
    if (off <= 0x3b || (0x58 <= off && off <= 0x5f)) {
      return CharClass::kConsonant;
    }
    // Sinhala doesn't have Nukta or Avagraha.
    if (off == 0x3c) {
      return CharClass::kNukta;
    }
    if (off == 0x3d) {
      return CharClass::kVowel; // avagraha
    }
    if (off <= 0x4c || (0x51 <= off && off <= 0x54)) {
      return CharClass::kMatra;
    }
    if (0x55 <= off && off <= 0x57) {
      return CharClass::kMatraPiece;
    }
    if (off == 0x4d) {
      return CharClass::kVirama;
    }
  }
  if (off == 0x60 || off == 0x61) {
    return CharClass::kVowel;
  }
  if (off == 0x62 || off == 0x63) {
    return CharClass::kMatra;
  }
  // Danda and digits up to 6f are OK as other.
  // 70-7f are script-specific.
  // 0BF0-0BF2 are Tamil numbers 10, 100 and 1000; treat as other.
  if (script_ == ViramaScript::kTamil && (0x70 <= off && off <= 0x72)) {
    return CharClass::kOther;
  }
  // 0BF3-0BFA are other Tamil symbols.
  if (script_ == ViramaScript::kTamil && (0x73 <= off && off <= 0x7A)) {
    return CharClass::kOther;
  }
  if (script_ == ViramaScript::kBengali && (off == 0x70 || off == 0x71)) {
    return CharClass::kConsonant;
  }
  if (script_ == ViramaScript::kGurmukhi && (off == 0x72 || off == 0x73)) {
    return CharClass::kConsonant;
  }
  if (script_ == ViramaScript::kSinhala && off == 0x70) {
    return CharClass::kConsonant;
  }
  if (script_ == ViramaScript::kDevanagari && off == 0x70) {
    return CharClass::kOther;
  }
  if (0x70 <= off && off <= 0x73) {
    return CharClass::kVowelModifier;
  }
  // Non Indic, Digits, Measures, danda, etc.
  return CharClass::kOther;
}

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

/media/home/debian/src/github/tesseract-ocr/tesseract/src/training/unicharset/validate_indic.h
/media/home/debian/src/github/tesseract-ocr/tesseract/src/training/unicharset/validate_indic.cpp

Public Member Functions

Protected Member Functions