tesseract::WERD Class Reference

#include <werd.h>

Inheritance diagram for tesseract::WERD:

Public Member Functions
	WERD ()=default
	WERD (C_BLOB_LIST *blob_list, uint8_t blanks, const char *text)
	WERD (C_BLOB_LIST *blob_list, WERD *clone)
WERD *	ConstructFromSingleBlob (bool bol, bool eol, C_BLOB *blob)
	~WERD ()=default
WERD &	operator= (const WERD &source)
WERD *	ConstructWerdWithNewBlobs (C_BLOB_LIST *all_blobs, C_BLOB_LIST *orphan_blobs)
C_BLOB_LIST *	rej_cblob_list ()
C_BLOB_LIST *	cblob_list ()
uint8_t	space () const
void	set_blanks (uint8_t new_blanks)
int	script_id () const
void	set_script_id (int id)
TBOX	bounding_box () const
TBOX	restricted_bounding_box (bool upper_dots, bool lower_dots) const
TBOX	true_bounding_box () const
const char *	text () const
void	set_text (const char *new_text)
bool	flag (WERD_FLAGS mask) const
void	set_flag (WERD_FLAGS mask, bool value)
bool	display_flag (uint8_t flag) const
void	set_display_flag (uint8_t flag, bool value)
WERD *	shallow_copy ()
void	move (const ICOORD vec)
void	join_on (WERD *other)
void	copy_on (WERD *other)
void	print () const
void	plot (ScrollView *window, ScrollView::Color colour)
void	plot (ScrollView *window)
void	plot_rej_blobs (ScrollView *window)
void	CleanNoise (float size_threshold)
void	GetNoiseOutlines (std::vector< C_OUTLINE * > *outlines)
bool	AddSelectedOutlines (const std::vector< bool > &wanted, const std::vector< C_BLOB * > &target_blobs, const std::vector< C_OUTLINE * > &outlines, bool *make_next_word_fuzzy)
Public Member Functions inherited from tesseract::ELIST2_LINK
	ELIST2_LINK ()
	ELIST2_LINK (const ELIST2_LINK &)=delete
void	operator= (const ELIST2_LINK &)

Static Public Member Functions
static ScrollView::Color	NextColor (ScrollView::Color colour)

Detailed Description

Definition at line 58 of file werd.h.

Constructor & Destructor Documentation

WERD() [1/3]

tesseract::WERD::WERD ( )

default

WERD() [2/3]

tesseract::WERD::WERD	(	C_BLOB_LIST *	blob_list,
		uint8_t	blank_count,
		const char *	text
	)

WERD::WERD

Constructor to build a WERD from a list of C_BLOBs. blob_list The C_BLOBs (in word order) are not copied; we take its elements and put them in our lists. blank_count blanks in front of the word text correct text, outlives this WERD

Definition at line 45 of file werd.cpp.

    : blanks(blank_count), flags(0), script_id_(0), correct(text ? text : "") {
  C_BLOB_IT start_it = &cblobs;
  C_BLOB_IT rej_cblob_it = &rej_cblobs;
  C_OUTLINE_IT c_outline_it;
  int16_t inverted_vote = 0;
  int16_t non_inverted_vote = 0;
 
  // Move blob_list's elements into cblobs.
  start_it.add_list_after(blob_list);
 
  /*
  Set white on black flag for the WERD, moving any duff blobs onto the
  rej_cblobs list.
  First, walk the cblobs checking the inverse flag for each outline of each
  cblob. If a cblob has inconsistent flag settings for its different
  outlines, move the blob to the reject list. Otherwise, increment the
  appropriate w-on-b or b-on-w vote for the word.
 
  Now set the inversion flag for the WERD by maximum vote.
 
  Walk the blobs again, moving any blob whose inversion flag does not agree
  with the concencus onto the reject list.
*/
  start_it.set_to_list(&cblobs);
  if (start_it.empty()) {
    return;
  }
  for (start_it.mark_cycle_pt(); !start_it.cycled_list(); start_it.forward()) {
    bool reject_blob = false;
    bool blob_inverted;
 
    c_outline_it.set_to_list(start_it.data()->out_list());
    blob_inverted = c_outline_it.data()->flag(COUT_INVERSE);
    for (c_outline_it.mark_cycle_pt(); !c_outline_it.cycled_list() && !reject_blob;
         c_outline_it.forward()) {
      reject_blob = c_outline_it.data()->flag(COUT_INVERSE) != blob_inverted;
    }
    if (reject_blob) {
      rej_cblob_it.add_after_then_move(start_it.extract());
    } else {
      if (blob_inverted) {
        inverted_vote++;
      } else {
        non_inverted_vote++;
      }
    }
  }
 
  flags.set(W_INVERSE, (inverted_vote > non_inverted_vote));
 
  start_it.set_to_list(&cblobs);
  if (start_it.empty()) {
    return;
  }
  for (start_it.mark_cycle_pt(); !start_it.cycled_list(); start_it.forward()) {
    c_outline_it.set_to_list(start_it.data()->out_list());
    if (c_outline_it.data()->flag(COUT_INVERSE) != flags[W_INVERSE]) {
      rej_cblob_it.add_after_then_move(start_it.extract());
    }
  }
}

WERD() [3/3]

tesseract::WERD::WERD	(	C_BLOB_LIST *	blob_list,
		WERD *	clone
	)

WERD::WERD

Constructor to build a WERD from a list of C_BLOBs. The C_BLOBs are not copied so the source list is emptied.

Parameters

blob_list	In word order
clone	Source of flags

Definition at line 115 of file werd.cpp.

    : flags(clone->flags), script_id_(clone->script_id_), correct(clone->correct) {
  C_BLOB_IT start_it = blob_list; // iterator
  C_BLOB_IT end_it = blob_list;   // another
 
  while (!end_it.at_last()) {
    end_it.forward(); // move to last
  }
  cblobs.assign_to_sublist(&start_it, &end_it);
  // move to our list
  blanks = clone->blanks;
  //      fprintf(stderr,"Wrong constructor!!!!\n");
}

~WERD()

tesseract::WERD::~WERD ( )

default

Member Function Documentation

AddSelectedOutlines()

bool tesseract::WERD::AddSelectedOutlines	(	const std::vector< bool > &	wanted,
		const std::vector< C_BLOB * > &	target_blobs,
		const std::vector< C_OUTLINE * > &	outlines,
		bool *	make_next_word_fuzzy
	)

Definition at line 526 of file werd.cpp.

                                                           {
  bool outline_added_to_start = false;
  if (make_next_word_fuzzy != nullptr) {
    *make_next_word_fuzzy = false;
  }
  C_BLOB_IT rej_it(&rej_cblobs);
  for (unsigned i = 0; i < outlines.size(); ++i) {
    C_OUTLINE *outline = outlines[i];
    if (outline == nullptr) {
      continue; // Already used it.
    }
    if (wanted[i]) {
      C_BLOB *target_blob = target_blobs[i];
      TBOX noise_box = outline->bounding_box();
      if (target_blob == nullptr) {
        target_blob = new C_BLOB(outline);
        // Need to find the insertion point.
        C_BLOB_IT blob_it(&cblobs);
        for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
          C_BLOB *blob = blob_it.data();
          TBOX blob_box = blob->bounding_box();
          if (blob_box.left() > noise_box.left()) {
            if (blob_it.at_first() && !flag(W_FUZZY_SP) && !flag(W_FUZZY_NON)) {
              // We might want to join this word to its predecessor.
              outline_added_to_start = true;
            }
            blob_it.add_before_stay_put(target_blob);
            break;
          }
        }
        if (blob_it.cycled_list()) {
          blob_it.add_to_end(target_blob);
          if (make_next_word_fuzzy != nullptr) {
            *make_next_word_fuzzy = true;
          }
        }
        // Add all consecutive wanted, but null-blob outlines to same blob.
        C_OUTLINE_IT ol_it(target_blob->out_list());
        while (i + 1 < outlines.size() && wanted[i + 1] && target_blobs[i + 1] == nullptr) {
          ++i;
          ol_it.add_to_end(outlines[i]);
        }
      } else {
        // Insert outline into this blob.
        C_OUTLINE_IT ol_it(target_blob->out_list());
        ol_it.add_to_end(outline);
      }
    } else {
      // Put back on noise list.
      rej_it.add_to_end(new C_BLOB(outline));
    }
  }
  return outline_added_to_start;
}

bounding_box()

TBOX tesseract::WERD::bounding_box

(

)

const

WERD::bounding_box

Return the bounding box of the WERD. This is quite a mess to compute! ORIGINALLY, REJECT CBLOBS WERE EXCLUDED, however, this led to bugs when the words on the row were re-sorted. The original words were built with reject blobs included. The FUZZY SPACE flags were set accordingly. If ALL the blobs in a word are rejected the BB for the word is nullptr, causing the sort to screw up, leading to the erroneous possibility of the first word in a row being marked as FUZZY space.

Definition at line 155 of file werd.cpp.

                              {
  return restricted_bounding_box(true, true);
}

cblob_list()

C_BLOB_LIST * tesseract::WERD::cblob_list ( )

inline

Definition at line 96 of file werd.h.

                            { // get compact blobs
    return &cblobs;
  }

CleanNoise()

void tesseract::WERD::CleanNoise

(

float

size_threshold

)

Definition at line 483 of file werd.cpp.

                                          {
  C_BLOB_IT blob_it(&cblobs);
  C_BLOB_IT rej_it(&rej_cblobs);
  for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
    C_BLOB *blob = blob_it.data();
    C_OUTLINE_IT ol_it(blob->out_list());
    for (ol_it.mark_cycle_pt(); !ol_it.cycled_list(); ol_it.forward()) {
      C_OUTLINE *outline = ol_it.data();
      TBOX ol_box = outline->bounding_box();
      int ol_size = ol_box.width() > ol_box.height() ? ol_box.width() : ol_box.height();
      if (ol_size < size_threshold) {
        // This outline is too small. Move it to a separate blob in the
        // reject blobs list.
        auto *rej_blob = new C_BLOB(ol_it.extract());
        rej_it.add_after_then_move(rej_blob);
      }
    }
    if (blob->out_list()->empty()) {
      delete blob_it.extract();
    }
  }
}

ConstructFromSingleBlob()

WERD * tesseract::WERD::ConstructFromSingleBlob	(	bool	bol,
		bool	eol,
		C_BLOB *	blob
	)

Definition at line 132 of file werd.cpp.

                                                                    {
  C_BLOB_LIST temp_blobs;
  C_BLOB_IT temp_it(&temp_blobs);
  temp_it.add_after_then_move(blob);
  WERD *blob_word = new WERD(&temp_blobs, this);
  blob_word->set_flag(W_BOL, bol);
  blob_word->set_flag(W_EOL, eol);
  return blob_word;
}

ConstructWerdWithNewBlobs()

WERD * tesseract::WERD::ConstructWerdWithNewBlobs	(	C_BLOB_LIST *	all_blobs,
		C_BLOB_LIST *	orphan_blobs
	)

WERD::ConstructWerdWithNewBlobs()

This method returns a new werd constructed using the blobs in the input all_blobs list, which correspond to the blobs in this werd object. The blobs used to construct the new word are consumed and removed from the input all_blobs list. Returns nullptr if the word couldn't be constructed. Returns original blobs for which no matches were found in the output list orphan_blobs (appends).

Definition at line 395 of file werd.cpp.

                                                                                       {
  C_BLOB_LIST current_blob_list;
  C_BLOB_IT werd_blobs_it(&current_blob_list);
  // Add the word's c_blobs.
  werd_blobs_it.add_list_after(cblob_list());
 
  // New blob list. These contain the blobs which will form the new word.
  C_BLOB_LIST new_werd_blobs;
  C_BLOB_IT new_blobs_it(&new_werd_blobs);
 
  // not_found_blobs contains the list of current word's blobs for which a
  // corresponding blob wasn't found in the input all_blobs list.
  C_BLOB_LIST not_found_blobs;
  C_BLOB_IT not_found_it(&not_found_blobs);
  not_found_it.move_to_last();
 
  werd_blobs_it.move_to_first();
  for (werd_blobs_it.mark_cycle_pt(); !werd_blobs_it.cycled_list(); werd_blobs_it.forward()) {
    C_BLOB *werd_blob = werd_blobs_it.extract();
    TBOX werd_blob_box = werd_blob->bounding_box();
    bool found = false;
    // Now find the corresponding blob for this blob in the all_blobs
    // list. For now, follow the inefficient method of pairwise
    // comparisons. Ideally, one can pre-bucket the blobs by row.
    C_BLOB_IT all_blobs_it(all_blobs);
    for (all_blobs_it.mark_cycle_pt(); !all_blobs_it.cycled_list(); all_blobs_it.forward()) {
      C_BLOB *a_blob = all_blobs_it.data();
      // Compute the overlap of the two blobs. If major, a_blob should
      // be added to the new blobs list.
      TBOX a_blob_box = a_blob->bounding_box();
      if (a_blob_box.null_box()) {
        tprintf("Bounding box couldn't be ascertained\n");
      }
      if (werd_blob_box.contains(a_blob_box) || werd_blob_box.major_overlap(a_blob_box)) {
        // Old blobs are from minimal splits, therefore are expected to be
        // bigger. The new small blobs should cover a significant portion.
        // This is it.
        all_blobs_it.extract();
        new_blobs_it.add_after_then_move(a_blob);
        found = true;
      }
    }
    if (!found) {
      not_found_it.add_after_then_move(werd_blob);
    } else {
      delete werd_blob;
    }
  }
  // Iterate over all not found blobs. Some of them may be due to
  // under-segmentation (which is OK, since the corresponding blob is already
  // in the list in that case.
  not_found_it.move_to_first();
  for (not_found_it.mark_cycle_pt(); !not_found_it.cycled_list(); not_found_it.forward()) {
    C_BLOB *not_found = not_found_it.data();
    TBOX not_found_box = not_found->bounding_box();
    C_BLOB_IT existing_blobs_it(new_blobs_it);
    for (existing_blobs_it.mark_cycle_pt(); !existing_blobs_it.cycled_list();
         existing_blobs_it.forward()) {
      C_BLOB *a_blob = existing_blobs_it.data();
      TBOX a_blob_box = a_blob->bounding_box();
      if ((not_found_box.major_overlap(a_blob_box) || a_blob_box.major_overlap(not_found_box)) &&
          not_found_box.y_overlap_fraction(a_blob_box) > 0.8) {
        // Already taken care of.
        delete not_found_it.extract();
        break;
      }
    }
  }
  if (orphan_blobs) {
    C_BLOB_IT orphan_blobs_it(orphan_blobs);
    orphan_blobs_it.move_to_last();
    orphan_blobs_it.add_list_after(&not_found_blobs);
  }
 
  // New blobs are ready. Create a new werd object with these.
  WERD *new_werd = nullptr;
  if (!new_werd_blobs.empty()) {
    new_werd = new WERD(&new_werd_blobs, this);
  } else {
    // Add the blobs back to this word so that it can be reused.
    C_BLOB_IT this_list_it(cblob_list());
    this_list_it.add_list_after(&not_found_blobs);
  }
  return new_werd;
}

copy_on()

void tesseract::WERD::copy_on

(

WERD *

other

)

WERD::copy_on

Copy blobs from other word onto this one.

Definition at line 230 of file werd.cpp.

                              {
  bool reversed = other->bounding_box().left() < bounding_box().left();
  C_BLOB_IT c_blob_it(&cblobs);
  C_BLOB_LIST c_blobs;
 
  c_blobs.deep_copy(&other->cblobs, &C_BLOB::deep_copy);
  if (reversed) {
    c_blob_it.add_list_before(&c_blobs);
  } else {
    c_blob_it.move_to_last();
    c_blob_it.add_list_after(&c_blobs);
  }
  if (!other->rej_cblobs.empty()) {
    C_BLOB_IT rej_c_blob_it(&rej_cblobs);
    C_BLOB_LIST new_rej_c_blobs;
 
    new_rej_c_blobs.deep_copy(&other->rej_cblobs, &C_BLOB::deep_copy);
    if (reversed) {
      rej_c_blob_it.add_list_before(&new_rej_c_blobs);
    } else {
      rej_c_blob_it.move_to_last();
      rej_c_blob_it.add_list_after(&new_rej_c_blobs);
    }
  }
}

display_flag()

bool tesseract::WERD::display_flag ( uint8_t  flag ) const

inline

Definition at line 135 of file werd.h.

                                        {
    return disp_flags[flag];
  }

flag()

bool tesseract::WERD::flag ( WERD_FLAGS  mask ) const

inline

Definition at line 128 of file werd.h.

                                   {
    return flags[mask];
  }

GetNoiseOutlines()

void tesseract::WERD::GetNoiseOutlines

(

std::vector< C_OUTLINE * > *

outlines

)

Definition at line 508 of file werd.cpp.

                                                            {
  C_BLOB_IT rej_it(&rej_cblobs);
  for (rej_it.mark_cycle_pt(); !rej_it.empty(); rej_it.forward()) {
    C_BLOB *blob = rej_it.extract();
    C_OUTLINE_IT ol_it(blob->out_list());
    outlines->push_back(ol_it.extract());
    delete blob;
  }
}

join_on()

void tesseract::WERD::join_on

(

WERD *

other

)

WERD::join_on

Join other word onto this one. Delete the old word.

Definition at line 208 of file werd.cpp.

                              {
  C_BLOB_IT blob_it(&cblobs);
  C_BLOB_IT src_it(&other->cblobs);
  C_BLOB_IT rej_cblob_it(&rej_cblobs);
  C_BLOB_IT src_rej_it(&other->rej_cblobs);
 
  while (!src_it.empty()) {
    blob_it.add_to_end(src_it.extract());
    src_it.forward();
  }
  while (!src_rej_it.empty()) {
    rej_cblob_it.add_to_end(src_rej_it.extract());
    src_rej_it.forward();
  }
}

move()

void tesseract::WERD::move

(

const ICOORD

vec

)

WERD::move

Reposition WERD by vector NOTE!! REJECT CBLOBS ARE NOT MOVED

Definition at line 194 of file werd.cpp.

                                {
  C_BLOB_IT cblob_it(&cblobs); // cblob iterator
 
  for (cblob_it.mark_cycle_pt(); !cblob_it.cycled_list(); cblob_it.forward()) {
    cblob_it.data()->move(vec);
  }
}

NextColor()

ScrollView::Color tesseract::WERD::NextColor ( ScrollView::Color  colour )

static

Definition at line 298 of file werd.cpp.

                                                      {
  auto next = static_cast<ScrollView::Color>(colour + 1);
  if (next >= LAST_COLOUR || next < FIRST_COLOUR) {
    next = FIRST_COLOUR;
  }
  return next;
}

operator=()

WERD & tesseract::WERD::operator=

(

const WERD &

source

)

WERD::operator=

Assign a word, DEEP copying the blob list

Definition at line 357 of file werd.cpp.

                                        {
  this->ELIST2_LINK::operator=(source);
  blanks = source.blanks;
  flags = source.flags;
  script_id_ = source.script_id_;
  correct = source.correct;
  cblobs.clear();
  cblobs.deep_copy(&source.cblobs, &C_BLOB::deep_copy);
  rej_cblobs.clear();
  rej_cblobs.deep_copy(&source.rej_cblobs, &C_BLOB::deep_copy);
  return *this;
}

plot() [1/2]

void tesseract::WERD::plot

(

ScrollView *

window

)

WERD::plot

Draw the WERD in rainbow colours in window.

Definition at line 312 of file werd.cpp.

                                  {
  ScrollView::Color colour = FIRST_COLOUR;
  C_BLOB_IT it = &cblobs;
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    it.data()->plot(window, colour, CHILD_COLOUR);
    colour = NextColor(colour);
  }
  plot_rej_blobs(window);
}

plot() [2/2]

void tesseract::WERD::plot	(	ScrollView *	window,
		ScrollView::Color	colour
	)

WERD::plot

Draw the WERD in the given colour.

Definition at line 289 of file werd.cpp.

                                                          {
  C_BLOB_IT it = &cblobs;
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    it.data()->plot(window, colour, colour);
  }
  plot_rej_blobs(window);
}

plot_rej_blobs()

void tesseract::WERD::plot_rej_blobs

(

ScrollView *

window

)

WERD::plot_rej_blobs

Draw the WERD rejected blobs in window - ALWAYS GREY

Definition at line 328 of file werd.cpp.

                                            {
  C_BLOB_IT it = &rej_cblobs;
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    it.data()->plot(window, ScrollView::GREY, ScrollView::GREY);
  }
}

print()

void tesseract::WERD::print

(

)

const

WERD::print

Display members

Definition at line 262 of file werd.cpp.

                       {
  tprintf("Blanks= %d\n", blanks);
  bounding_box().print();
  tprintf("Flags = %lu = 0%lo\n", flags.to_ulong(), flags.to_ulong());
  tprintf("   W_SEGMENTED = %s\n", flags[W_SEGMENTED] ? "TRUE" : "FALSE");
  tprintf("   W_ITALIC = %s\n", flags[W_ITALIC] ? "TRUE" : "FALSE");
  tprintf("   W_BOL = %s\n", flags[W_BOL] ? "TRUE" : "FALSE");
  tprintf("   W_EOL = %s\n", flags[W_EOL] ? "TRUE" : "FALSE");
  tprintf("   W_NORMALIZED = %s\n", flags[W_NORMALIZED] ? "TRUE" : "FALSE");
  tprintf("   W_SCRIPT_HAS_XHEIGHT = %s\n", flags[W_SCRIPT_HAS_XHEIGHT] ? "TRUE" : "FALSE");
  tprintf("   W_SCRIPT_IS_LATIN = %s\n", flags[W_SCRIPT_IS_LATIN] ? "TRUE" : "FALSE");
  tprintf("   W_DONT_CHOP = %s\n", flags[W_DONT_CHOP] ? "TRUE" : "FALSE");
  tprintf("   W_REP_CHAR = %s\n", flags[W_REP_CHAR] ? "TRUE" : "FALSE");
  tprintf("   W_FUZZY_SP = %s\n", flags[W_FUZZY_SP] ? "TRUE" : "FALSE");
  tprintf("   W_FUZZY_NON = %s\n", flags[W_FUZZY_NON] ? "TRUE" : "FALSE");
  tprintf("Correct= %s\n", correct.c_str());
  tprintf("Rejected cblob count = %d\n", rej_cblobs.length());
  tprintf("Script = %d\n", script_id_);
}

rej_cblob_list()

C_BLOB_LIST * tesseract::WERD::rej_cblob_list ( )

inline

Definition at line 91 of file werd.h.

                                { // compact format
    return &rej_cblobs;
  }

restricted_bounding_box()

TBOX tesseract::WERD::restricted_bounding_box	(	bool	upper_dots,
		bool	lower_dots
	)		const

Definition at line 161 of file werd.cpp.

                                                                         {
  TBOX box = true_bounding_box();
  int bottom = box.bottom();
  int top = box.top();
  // This is a read-only iteration of the rejected blobs.
  C_BLOB_IT it(const_cast<C_BLOB_LIST *>(&rej_cblobs));
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    TBOX dot_box = it.data()->bounding_box();
    if ((upper_dots || dot_box.bottom() <= top) && (lower_dots || dot_box.top() >= bottom)) {
      box += dot_box;
    }
  }
  return box;
}

script_id()

int tesseract::WERD::script_id ( ) const

inline

Definition at line 106 of file werd.h.

                        {
    return script_id_;
  }

set_blanks()

void tesseract::WERD::set_blanks ( uint8_t  new_blanks )

inline

Definition at line 103 of file werd.h.

                                      {
    blanks = new_blanks;
  }

set_display_flag()

void tesseract::WERD::set_display_flag ( uint8_t  flag, bool  value  )

inline

Definition at line 138 of file werd.h.

                                                  {
    disp_flags.set(flag, value);
  }

set_flag()

void tesseract::WERD::set_flag ( WERD_FLAGS  mask, bool  value  )

inline

Definition at line 131 of file werd.h.

                                             {
    flags.set(mask, value);
  }

set_script_id()

void tesseract::WERD::set_script_id ( int  id )

inline

Definition at line 109 of file werd.h.

                             {
    script_id_ = id;
  }

set_text()

void tesseract::WERD::set_text ( const char *  new_text )

inline

Definition at line 124 of file werd.h.

                                      {
    correct = new_text;
  }

shallow_copy()

WERD * tesseract::WERD::shallow_copy

(

)

WERD::shallow_copy()

Make a shallow copy of a word

Definition at line 342 of file werd.cpp.

                         {
  WERD *new_word = new WERD;
 
  new_word->blanks = blanks;
  new_word->flags = flags;
  new_word->correct = correct;
  return new_word;
}

space()

uint8_t tesseract::WERD::space ( ) const

inline

Definition at line 100 of file werd.h.

                        { // access function
    return blanks;
  }

text()

const char * tesseract::WERD::text ( ) const

inline

Definition at line 121 of file werd.h.

                           {
    return correct.c_str();
  }

true_bounding_box()

TBOX tesseract::WERD::true_bounding_box

(

)

const

Definition at line 177 of file werd.cpp.

                                   {
  TBOX box; // box being built
  // This is a read-only iteration of the good blobs.
  C_BLOB_IT it(const_cast<C_BLOB_LIST *>(&cblobs));
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    box += it.data()->bounding_box();
  }
  return box;
}

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/werd.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/werd.cpp