tesseract: tesseract::CharSamp Class Reference

#include <char_samp.h>

Inheritance diagram for tesseract::CharSamp:

Public Member Functions
	CharSamp ()

	CharSamp (int wid, int hgt)

	CharSamp (int left, int top, int wid, int hgt)

	~CharSamp ()

unsigned short	Left () const

unsigned short	Right () const

unsigned short	Top () const

unsigned short	Bottom () const

unsigned short	Page () const

unsigned short	NormTop () const

unsigned short	NormBottom () const

unsigned short	NormAspectRatio () const

unsigned short	FirstChar () const

unsigned short	LastChar () const

char_32	Label () const

char_32 *	StrLabel () const

string	stringLabel () const

void	SetLeft (unsigned short left)

void	SetTop (unsigned short top)

void	SetPage (unsigned short page)

void	SetLabel (char_32 label)

void	SetLabel (const char_32 *label32)

void	SetLabel (string str)

void	SetNormTop (unsigned short norm_top)

void	SetNormBottom (unsigned short norm_bottom)

void	SetNormAspectRatio (unsigned short norm_aspect_ratio)

void	SetFirstChar (unsigned short first_char)

void	SetLastChar (unsigned short last_char)

bool	Save2CharDumpFile (FILE *fp) const

CharSamp *	Crop ()

ConComp **	Segment (int *seg_cnt, bool right_2_left, int max_hist_wnd, int min_con_comp_size) const

CharSamp *	Scale (int wid, int hgt, bool isotropic=true)

CharSamp *	Clone () const

bool	ComputeFeatures (int conv_grid_size, float *features)

int	LabelLen () const

Public Member Functions inherited from tesseract::Bmp8
	Bmp8 (unsigned short wid, unsigned short hgt)

	~Bmp8 ()

bool	Clear ()

unsigned short	Width () const

unsigned short	Stride () const

unsigned short	Height () const

unsigned char *	RawData () const

bool	ScaleFrom (Bmp8 *bmp, bool isotropic=true)

bool	Deslant ()

bool	HorizontalDeslant (double *deslant_angle)

bool	IsIdentical (Bmp8 *pBmp) const

ConComp **	FindConComps (int *concomp_cnt, int min_size) const

float	ForegroundRatio () const

float	MeanHorizontalHistogramEntropy () const

int *	HorizontalHistogram () const

Static Public Member Functions
static CharSamp *	FromCharDumpFile (CachedFile *fp)

static CharSamp *	FromCharDumpFile (FILE *fp)

static CharSamp *	FromCharDumpFile (unsigned char **raw_data)

static CharSamp *	FromRawData (int left, int top, int wid, int hgt, unsigned char *data)

static CharSamp *	FromConComps (ConComp *concomp_array, int strt_concomp, int seg_flags_size, int seg_flags, bool left_most, bool right_most, int word_hgt)

static int	AuxFeatureCnt ()

static int	LabelLen (const char_32 *label32)

Static Public Member Functions inherited from tesseract::Bmp8
static Bmp8 *	FromCharDumpFile (CachedFile *fp)

static Bmp8 *	FromCharDumpFile (FILE *fp)

Additional Inherited Members
Protected Member Functions inherited from tesseract::Bmp8
bool	LoadFromCharDumpFile (CachedFile *fp)

bool	LoadFromCharDumpFile (FILE *fp)

bool	LoadFromCharDumpFile (unsigned char **raw_data)

bool	LoadFromRawData (unsigned char *data)

bool	SaveBmp2CharDumpFile (FILE *fp) const

bool	IsBlankColumn (int x) const

bool	IsBlankRow (int y) const

void	Crop (int xst_src, int yst_src, int wid, int hgt)

void	Copy (int x, int y, int wid, int hgt, Bmp8 *bmp_dest) const

Protected Attributes inherited from tesseract::Bmp8
unsigned short	wid_

unsigned short	hgt_

unsigned char **	line_buff_

Static Protected Attributes inherited from tesseract::Bmp8
static const int	kConCompAllocChunk = 16

static const int	kDeslantAngleCount

Detailed Description

Definition at line 39 of file char_samp.h.

Constructor & Destructor Documentation

◆ CharSamp() [1/3]

tesseract::CharSamp::CharSamp ( )

Definition at line 29 of file char_samp.cpp.

     : Bmp8(0, 0) {
   left_ = 0;
   top_ = 0;
   label32_ = NULL;
   page_ = -1;
 }

◆ CharSamp() [2/3]

tesseract::CharSamp::CharSamp	(	int	wid,
		int	hgt
	)

Definition at line 37 of file char_samp.cpp.

     : Bmp8(wid, hgt) {
   left_ = 0;
   top_ = 0;
   label32_ = NULL;
   page_ = -1;
 }

◆ CharSamp() [3/3]

tesseract::CharSamp::CharSamp	(	int	left,
		int	top,
		int	wid,
		int	hgt
	)

Definition at line 45 of file char_samp.cpp.

     : Bmp8(wid, hgt)
     , left_(left)
     , top_(top) {
   label32_ = NULL;
   page_ = -1;
 }

◆ ~CharSamp()

tesseract::CharSamp::~CharSamp ( )

Definition at line 53 of file char_samp.cpp.

                     {
   if (label32_ != NULL) {
     delete []label32_;
     label32_ = NULL;
   }
 }

Member Function Documentation

◆ AuxFeatureCnt()

static int tesseract::CharSamp::AuxFeatureCnt ( )

inlinestatic

Definition at line 130 of file char_samp.h.

130 { return (5); }

◆ Bottom()

unsigned short tesseract::CharSamp::Bottom ( ) const

inline

Definition at line 49 of file char_samp.h.

49 { return top_ + hgt_; }

tesseract::Bmp8::hgt_

unsigned short hgt_

Definition: bmp_8.h:96

◆ Clone()

CharSamp * tesseract::CharSamp::Clone ( ) const

Definition at line 542 of file char_samp.cpp.

                                 {
   // create the cropped char samp
   CharSamp *samp = new CharSamp(left_, top_, wid_, hgt_);
   samp->SetLabel(label32_);
   samp->SetFirstChar(first_char_);
   samp->SetLastChar(last_char_);
   samp->SetNormTop(norm_top_);
   samp->SetNormBottom(norm_bottom_);
   samp->SetNormAspectRatio(norm_aspect_ratio_);
   // copy the bitmap to the cropped img
   Copy(0, 0, wid_, hgt_, samp);
   return samp;
 }

◆ ComputeFeatures()

bool tesseract::CharSamp::ComputeFeatures	(	int	conv_grid_size,
		float *	features
	)

Definition at line 617 of file char_samp.cpp.

                                                                   {
   // Create a scaled BMP
   CharSamp *scaled_bmp = Scale(conv_grid_size, conv_grid_size);
   if (!scaled_bmp) {
     return false;
   }
   // prepare input
   unsigned char *buff = scaled_bmp->RawData();
   // bitmap features
   int input;
   int bmp_size = conv_grid_size * conv_grid_size;
   for (input = 0; input < bmp_size; input++) {
     features[input] = 255.0f - (1.0f * buff[input]);
   }
   // word context features
   features[input++] = FirstChar();
   features[input++] = LastChar();
   features[input++] = NormTop();
   features[input++] = NormBottom();
   features[input++] = NormAspectRatio();
   delete scaled_bmp;
   return true;
 }

◆ Crop()

CharSamp * tesseract::CharSamp::Crop ( )

Definition at line 338 of file char_samp.cpp.

                          {
   // get the dimesions of the cropped img
   int cropped_left = 0;
   int cropped_top = 0;
   int cropped_wid = wid_;
   int cropped_hgt = hgt_;
   Bmp8::Crop(&cropped_left, &cropped_top,
              &cropped_wid, &cropped_hgt);
 
   if (cropped_wid == 0 || cropped_hgt == 0) {
     return NULL;
   }
   // create the cropped char samp
   CharSamp *cropped_samp = new CharSamp(left_ + cropped_left,
                                         top_ + cropped_top,
                                         cropped_wid, cropped_hgt);
   cropped_samp->SetLabel(label32_);
   cropped_samp->SetFirstChar(first_char_);
   cropped_samp->SetLastChar(last_char_);
   // the following 3 fields may/should be reset by the calling function
   // using context information, i.e., location of character box
   // w.r.t. the word bounding box
   cropped_samp->SetNormAspectRatio(255 *
                                    cropped_wid / (cropped_wid + cropped_hgt));
   cropped_samp->SetNormTop(0);
   cropped_samp->SetNormBottom(255);
 
   // copy the bitmap to the cropped img
   Copy(cropped_left, cropped_top, cropped_wid, cropped_hgt, cropped_samp);
   return cropped_samp;
 }

◆ FirstChar()

unsigned short tesseract::CharSamp::FirstChar ( ) const

inline

Definition at line 54 of file char_samp.h.

54 { return first_char_; }

◆ FromCharDumpFile() [1/3]

CharSamp * tesseract::CharSamp::FromCharDumpFile ( CachedFile * fp )

static

Definition at line 82 of file char_samp.cpp.

                                                    {
   unsigned short left;
   unsigned short top;
   unsigned short page;
   unsigned short first_char;
   unsigned short last_char;
   unsigned short norm_top;
   unsigned short norm_bottom;
   unsigned short norm_aspect_ratio;
   unsigned int val32;
 
   char_32 *label32;
 
   // read and check 32 bit marker
   if (fp->Read(&val32, sizeof(val32)) != sizeof(val32)) {
     return NULL;
   }
   if (val32 != 0xabd0fefe) {
     return NULL;
   }
   // read label length,
   if (fp->Read(&val32, sizeof(val32)) != sizeof(val32)) {
     return NULL;
   }
   // the label is not null terminated in the file
   if (val32 > 0 && val32 < MAX_UINT32) {
     label32 = new char_32[val32 + 1];
     // read label
     if (fp->Read(label32, val32 * sizeof(*label32)) !=
         (val32 * sizeof(*label32))) {
       delete [] label32;
       return NULL;
     }
     // null terminate
     label32[val32] = 0;
   } else {
     label32 = NULL;
   }
   // read coordinates
   if (fp->Read(&page, sizeof(page)) != sizeof(page)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&left, sizeof(left)) != sizeof(left)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&top, sizeof(top)) != sizeof(top)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&first_char, sizeof(first_char)) != sizeof(first_char)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&last_char, sizeof(last_char)) != sizeof(last_char)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&norm_top, sizeof(norm_top)) != sizeof(norm_top)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&norm_bottom, sizeof(norm_bottom)) != sizeof(norm_bottom)) {
     delete [] label32;
     return NULL;
   }
   if (fp->Read(&norm_aspect_ratio, sizeof(norm_aspect_ratio)) !=
       sizeof(norm_aspect_ratio)) {
     delete [] label32;
     return NULL;
   }
   // create the object
   CharSamp *char_samp = new CharSamp();
   // init
   char_samp->label32_ = label32;
   char_samp->page_ = page;
   char_samp->left_ = left;
   char_samp->top_ = top;
   char_samp->first_char_ = first_char;
   char_samp->last_char_ = last_char;
   char_samp->norm_top_ = norm_top;
   char_samp->norm_bottom_ = norm_bottom;
   char_samp->norm_aspect_ratio_ = norm_aspect_ratio;
   // load the Bmp8 part
   if (char_samp->LoadFromCharDumpFile(fp) == false) {
     delete char_samp;
     return NULL;
   }
   return char_samp;
 }

◆ FromCharDumpFile() [2/3]

CharSamp * tesseract::CharSamp::FromCharDumpFile ( FILE * fp )

static

Definition at line 175 of file char_samp.cpp.

                                              {
   unsigned short left;
   unsigned short top;
   unsigned short page;
   unsigned short first_char;
   unsigned short last_char;
   unsigned short norm_top;
   unsigned short norm_bottom;
   unsigned short norm_aspect_ratio;
   unsigned int val32;
   char_32 *label32;
 
   // read and check 32 bit marker
   if (fread(&val32, 1, sizeof(val32), fp) != sizeof(val32)) {
     return NULL;
   }
   if (val32 != 0xabd0fefe) {
     return NULL;
   }
   // read label length,
   if (fread(&val32, 1, sizeof(val32), fp) != sizeof(val32)) {
     return NULL;
   }
   // the label is not null terminated in the file
   if (val32 > 0 && val32 < MAX_UINT32) {
     label32 = new char_32[val32 + 1];
     // read label
     if (fread(label32, 1, val32 * sizeof(*label32), fp) !=
         (val32 * sizeof(*label32))) {
       delete [] label32;
       return NULL;
     }
     // null terminate
     label32[val32] = 0;
   } else {
     label32 = NULL;
   }
   // read coordinates
   if (fread(&page, 1, sizeof(page), fp) != sizeof(page) ||
       fread(&left, 1, sizeof(left), fp) != sizeof(left) ||
       fread(&top, 1, sizeof(top), fp) != sizeof(top) ||
       fread(&first_char, 1, sizeof(first_char), fp) != sizeof(first_char) ||
       fread(&last_char, 1, sizeof(last_char), fp) != sizeof(last_char) ||
       fread(&norm_top, 1, sizeof(norm_top), fp) != sizeof(norm_top) ||
       fread(&norm_bottom, 1, sizeof(norm_bottom), fp) != sizeof(norm_bottom) ||
       fread(&norm_aspect_ratio, 1, sizeof(norm_aspect_ratio), fp) !=
           sizeof(norm_aspect_ratio)) {
     delete [] label32;
     return NULL;
   }
   // create the object
   CharSamp *char_samp = new CharSamp();
   // init
   char_samp->label32_ = label32;
   char_samp->page_ = page;
   char_samp->left_ = left;
   char_samp->top_ = top;
   char_samp->first_char_ = first_char;
   char_samp->last_char_ = last_char;
   char_samp->norm_top_ = norm_top;
   char_samp->norm_bottom_ = norm_bottom;
   char_samp->norm_aspect_ratio_ = norm_aspect_ratio;
   // load the Bmp8 part
   if (char_samp->LoadFromCharDumpFile(fp) == false) {
     delete char_samp;  // It owns label32.
     return NULL;
   }
   return char_samp;
 }

◆ FromCharDumpFile() [3/3]

CharSamp * tesseract::CharSamp::FromCharDumpFile ( unsigned char ** raw_data )

static

Definition at line 557 of file char_samp.cpp.

                                                                  {
   unsigned int val32;
   char_32 *label32;
   unsigned char *raw_data = *raw_data_ptr;
 
   // read and check 32 bit marker
   memcpy(&val32, raw_data, sizeof(val32));
   raw_data += sizeof(val32);
   if (val32 != 0xabd0fefe) {
     return NULL;
   }
   // read label length,
   memcpy(&val32, raw_data, sizeof(val32));
   raw_data += sizeof(val32);
   // the label is not null terminated in the file
   if (val32 > 0 && val32 < MAX_UINT32) {
     label32 = new char_32[val32 + 1];
     // read label
     memcpy(label32, raw_data, val32 * sizeof(*label32));
     raw_data += (val32 * sizeof(*label32));
     // null terminate
     label32[val32] = 0;
   } else {
     label32 = NULL;
   }
 
   // create the object
   CharSamp *char_samp = new CharSamp();
 
   // read coordinates
   char_samp->label32_ = label32;
   memcpy(&char_samp->page_, raw_data, sizeof(char_samp->page_));
   raw_data += sizeof(char_samp->page_);
   memcpy(&char_samp->left_, raw_data, sizeof(char_samp->left_));
   raw_data += sizeof(char_samp->left_);
   memcpy(&char_samp->top_, raw_data, sizeof(char_samp->top_));
   raw_data += sizeof(char_samp->top_);
   memcpy(&char_samp->first_char_, raw_data, sizeof(char_samp->first_char_));
   raw_data += sizeof(char_samp->first_char_);
   memcpy(&char_samp->last_char_, raw_data, sizeof(char_samp->last_char_));
   raw_data += sizeof(char_samp->last_char_);
   memcpy(&char_samp->norm_top_, raw_data, sizeof(char_samp->norm_top_));
   raw_data += sizeof(char_samp->norm_top_);
   memcpy(&char_samp->norm_bottom_, raw_data, sizeof(char_samp->norm_bottom_));
   raw_data += sizeof(char_samp->norm_bottom_);
   memcpy(&char_samp->norm_aspect_ratio_, raw_data,
          sizeof(char_samp->norm_aspect_ratio_));
   raw_data += sizeof(char_samp->norm_aspect_ratio_);
 
   // load the Bmp8 part
   if (char_samp->LoadFromCharDumpFile(&raw_data) == false) {
     delete char_samp;
     return NULL;
   }
 
   (*raw_data_ptr) = raw_data;
   return char_samp;
 }

◆ FromConComps()

CharSamp * tesseract::CharSamp::FromConComps	(	ConComp **	concomp_array,
		int	strt_concomp,
		int	seg_flags_size,
		int *	seg_flags,
		bool *	left_most,
		bool *	right_most,
		int	word_hgt
	)

static

Definition at line 439 of file char_samp.cpp.

                                                {
   int concomp;
   int end_concomp;
   int concomp_cnt = 0;
   end_concomp = strt_concomp + seg_flags_size;
   // determine ID range
   bool once = false;
   int min_id = -1;
   int max_id = -1;
   for (concomp = strt_concomp; concomp < end_concomp; concomp++) {
     if (!seg_flags || seg_flags[concomp - strt_concomp] != 0) {
       if (!once) {
         min_id = concomp_array[concomp]->ID();
         max_id = concomp_array[concomp]->ID();
         once = true;
       } else {
         UpdateRange(concomp_array[concomp]->ID(), &min_id, &max_id);
       }
       concomp_cnt++;
     }
   }
   if (concomp_cnt < 1 || !once || min_id == -1 || max_id == -1) {
     return NULL;
   }
   // alloc memo for computing leftmost and right most attributes
   int id_cnt = max_id - min_id + 1;
   bool *id_exist = new bool[id_cnt];
   bool *left_most_exist = new bool[id_cnt];
   bool *right_most_exist = new bool[id_cnt];
   memset(id_exist, 0, id_cnt * sizeof(*id_exist));
   memset(left_most_exist, 0, id_cnt * sizeof(*left_most_exist));
   memset(right_most_exist, 0, id_cnt * sizeof(*right_most_exist));
   // find the dimensions of the charsamp
   once = false;
   int left = -1;
   int right = -1;
   int top = -1;
   int bottom = -1;
   int unq_ids = 0;
   int unq_left_most = 0;
   int unq_right_most = 0;
   for (concomp = strt_concomp; concomp < end_concomp; concomp++) {
     if (!seg_flags || seg_flags[concomp - strt_concomp] != 0) {
       if (!once) {
         left = concomp_array[concomp]->Left();
         right = concomp_array[concomp]->Right();
         top = concomp_array[concomp]->Top();
         bottom = concomp_array[concomp]->Bottom();
         once = true;
       } else {
         UpdateRange(concomp_array[concomp]->Left(),
                     concomp_array[concomp]->Right(), &left, &right);
         UpdateRange(concomp_array[concomp]->Top(),
                     concomp_array[concomp]->Bottom(), &top, &bottom);
       }
       // count unq ids, unq left most and right mosts ids
       int concomp_id = concomp_array[concomp]->ID() - min_id;
       if (!id_exist[concomp_id]) {
         id_exist[concomp_id] = true;
         unq_ids++;
       }
       if (concomp_array[concomp]->LeftMost()) {
         if (left_most_exist[concomp_id] == false) {
           left_most_exist[concomp_id] = true;
           unq_left_most++;
         }
       }
       if (concomp_array[concomp]->RightMost()) {
         if (right_most_exist[concomp_id] == false) {
           right_most_exist[concomp_id] = true;
           unq_right_most++;
         }
       }
     }
   }
   delete []id_exist;
   delete []left_most_exist;
   delete []right_most_exist;
   if (!once || left == -1 || top == -1 || right == -1 || bottom == -1) {
     return NULL;
   }
   (*left_most) = (unq_left_most >= unq_ids);
   (*right_most) = (unq_right_most >= unq_ids);
   // create the char sample object
   CharSamp *samp = new CharSamp(left, top, right - left + 1, bottom - top + 1);
 
   // set the foreground pixels
   for (concomp = strt_concomp; concomp < end_concomp; concomp++) {
     if (!seg_flags || seg_flags[concomp - strt_concomp] != 0) {
       ConCompPt *pt_ptr = concomp_array[concomp]->Head();
       while (pt_ptr) {
         samp->line_buff_[pt_ptr->y() - top][pt_ptr->x() - left] = 0;
         pt_ptr = pt_ptr->Next();
       }
     }
   }
   return samp;
 }

◆ FromRawData()

CharSamp * tesseract::CharSamp::FromRawData	(	int	left,
		int	top,
		int	wid,
		int	hgt,
		unsigned char *	data
	)

static

Definition at line 266 of file char_samp.cpp.

                                                      {
   // create the object
   CharSamp *char_samp = new CharSamp(left, top, wid, hgt);
   if (char_samp->LoadFromRawData(data) == false) {
     delete char_samp;
     return NULL;
   }
   return char_samp;
 }

◆ Label()

char_32 tesseract::CharSamp::Label ( ) const

inline

Definition at line 56 of file char_samp.h.

                         {
     if (label32_ == NULL || LabelLen() != 1) {
       return 0;
     }
     return label32_[0];
   }

◆ LabelLen() [1/2]

int tesseract::CharSamp::LabelLen ( ) const

inline

Definition at line 132 of file char_samp.h.

132 { return LabelLen(label32_); }

tesseract::CharSamp::LabelLen

int LabelLen() const

Definition: char_samp.h:132

◆ LabelLen() [2/2]

static int tesseract::CharSamp::LabelLen ( const char_32 * label32 )

inlinestatic

Definition at line 133 of file char_samp.h.

                                               {
     if (label32 == NULL) {
       return 0;
     }
     int len = 0;
     while (label32[++len] != 0);
     return len;
   }

◆ LastChar()

unsigned short tesseract::CharSamp::LastChar ( ) const

inline

Definition at line 55 of file char_samp.h.

55 { return last_char_; }

◆ Left()

unsigned short tesseract::CharSamp::Left ( ) const

inline

Definition at line 46 of file char_samp.h.

46 { return left_; }

◆ NormAspectRatio()

unsigned short tesseract::CharSamp::NormAspectRatio ( ) const

inline

Definition at line 53 of file char_samp.h.

53 { return norm_aspect_ratio_; }

◆ NormBottom()

unsigned short tesseract::CharSamp::NormBottom ( ) const

inline

Definition at line 52 of file char_samp.h.

52 { return norm_bottom_; }

◆ NormTop()

unsigned short tesseract::CharSamp::NormTop ( ) const

inline

Definition at line 51 of file char_samp.h.

51 { return norm_top_; }

◆ Page()

unsigned short tesseract::CharSamp::Page ( ) const

inline

Definition at line 50 of file char_samp.h.

50 { return page_; }

◆ Right()

unsigned short tesseract::CharSamp::Right ( ) const

inline

Definition at line 47 of file char_samp.h.

47 { return left_ + wid_; }

tesseract::Bmp8::wid_

unsigned short wid_

Definition: bmp_8.h:95

◆ Save2CharDumpFile()

bool tesseract::CharSamp::Save2CharDumpFile ( FILE * fp ) const

Definition at line 278 of file char_samp.cpp.

                                                {
   unsigned int val32;
   // write and check 32 bit marker
   val32 = 0xabd0fefe;
   if (fwrite(&val32, 1, sizeof(val32), fp) != sizeof(val32)) {
     return false;
   }
   // write label length
   val32 = (label32_ == NULL) ? 0 : LabelLen(label32_);
   if (fwrite(&val32, 1, sizeof(val32), fp) != sizeof(val32)) {
     return false;
   }
   // write label
   if (label32_ != NULL) {
     if (fwrite(label32_, 1, val32 * sizeof(*label32_), fp) !=
         (val32 * sizeof(*label32_))) {
       return false;
     }
   }
   // write coordinates
   if (fwrite(&page_, 1, sizeof(page_), fp) != sizeof(page_)) {
     return false;
   }
   if (fwrite(&left_, 1, sizeof(left_), fp) != sizeof(left_)) {
     return false;
   }
   if (fwrite(&top_, 1, sizeof(top_), fp) != sizeof(top_)) {
     return false;
   }
   if (fwrite(&first_char_, 1, sizeof(first_char_), fp) !=
       sizeof(first_char_)) {
     return false;
   }
   if (fwrite(&last_char_, 1, sizeof(last_char_), fp) != sizeof(last_char_)) {
     return false;
   }
   if (fwrite(&norm_top_, 1, sizeof(norm_top_), fp) != sizeof(norm_top_)) {
     return false;
   }
   if (fwrite(&norm_bottom_, 1, sizeof(norm_bottom_), fp) !=
       sizeof(norm_bottom_)) {
     return false;
   }
   if (fwrite(&norm_aspect_ratio_, 1, sizeof(norm_aspect_ratio_), fp) !=
       sizeof(norm_aspect_ratio_)) {
     return false;
   }
   if (SaveBmp2CharDumpFile(fp) == false) {
     return false;
   }
   return true;
 }

◆ Scale()

CharSamp * tesseract::CharSamp::Scale	(	int	wid,
		int	hgt,
		bool	isotropic = `true`
	)

Definition at line 247 of file char_samp.cpp.

                                                           {
   CharSamp *scaled_samp = new CharSamp(wid, hgt);
   if (scaled_samp->ScaleFrom(this, isotropic) == false) {
     delete scaled_samp;
     return NULL;
   }
   scaled_samp->left_ = left_;
   scaled_samp->top_ = top_;
   scaled_samp->page_ = page_;
   scaled_samp->SetLabel(label32_);
   scaled_samp->first_char_ = first_char_;
   scaled_samp->last_char_ = last_char_;
   scaled_samp->norm_top_ = norm_top_;
   scaled_samp->norm_bottom_ = norm_bottom_;
   scaled_samp->norm_aspect_ratio_ = norm_aspect_ratio_;
   return scaled_samp;
 }

◆ Segment()

ConComp ** tesseract::CharSamp::Segment	(	int *	seg_cnt,
		bool	right_2_left,
		int	max_hist_wnd,
		int	min_con_comp_size
	)		const

Definition at line 372 of file char_samp.cpp.

                                                                            {
   // init
   (*segment_cnt) = 0;
   int concomp_cnt = 0;
   int seg_cnt = 0;
   // find the concomps of the image
   ConComp **concomp_array = FindConComps(&concomp_cnt, min_con_comp_size);
   if (concomp_cnt <= 0 || !concomp_array) {
     if (concomp_array)
       delete []concomp_array;
     return NULL;
   }
   ConComp **seg_array = NULL;
   // segment each concomp further using vertical histogram
   for (int concomp = 0; concomp < concomp_cnt; concomp++) {
     int concomp_seg_cnt = 0;
     // segment the concomp
     ConComp **concomp_seg_array = NULL;
     ConComp **concomp_alloc_seg =
         concomp_array[concomp]->Segment(max_hist_wnd, &concomp_seg_cnt);
     // no segments, add the whole concomp
     if (concomp_alloc_seg == NULL) {
       concomp_seg_cnt = 1;
       concomp_seg_array = concomp_array + concomp;
     } else {
       // delete the original concomp, we no longer need it
       concomp_seg_array = concomp_alloc_seg;
       delete concomp_array[concomp];
     }
     // add the resulting segments
     for (int seg_idx = 0; seg_idx < concomp_seg_cnt; seg_idx++) {
       // too small of a segment: ignore
       if (concomp_seg_array[seg_idx]->Width() < 2 &&
           concomp_seg_array[seg_idx]->Height() < 2) {
         delete concomp_seg_array[seg_idx];
       } else {
         // add the new segment
         // extend the segment array
         if ((seg_cnt % kConCompAllocChunk) == 0) {
           ConComp **temp_segm_array =
               new ConComp *[seg_cnt + kConCompAllocChunk];
           if (seg_cnt > 0) {
             memcpy(temp_segm_array, seg_array, seg_cnt * sizeof(*seg_array));
             delete []seg_array;
           }
           seg_array = temp_segm_array;
         }
         seg_array[seg_cnt++] = concomp_seg_array[seg_idx];
       }
     }  // segment
     if (concomp_alloc_seg != NULL) {
       delete []concomp_alloc_seg;
     }
   }  // concomp
   delete []concomp_array;
 
   // sort the concomps from Left2Right or Right2Left, based on the reading order
   if (seg_cnt > 0 && seg_array != NULL) {
     qsort(seg_array, seg_cnt, sizeof(*seg_array), right_2_left ?
         ConComp::Right2LeftComparer : ConComp::Left2RightComparer);
   }
   (*segment_cnt) = seg_cnt;
   return seg_array;
 }

◆ SetFirstChar()

void tesseract::CharSamp::SetFirstChar ( unsigned short first_char )

inline

Definition at line 96 of file char_samp.h.

                                                {
     first_char_ = first_char;
   }

◆ SetLabel() [1/3]

void tesseract::CharSamp::SetLabel ( char_32 label )

inline

Definition at line 68 of file char_samp.h.

                                {
     delete []label32_;
     label32_ = new char_32[2];
     label32_[0] = label;
     label32_[1] = 0;
   }

◆ SetLabel() [2/3]

void tesseract::CharSamp::SetLabel ( const char_32 * label32 )

inline

Definition at line 74 of file char_samp.h.

                                         {
     delete []label32_;
     label32_ = NULL;
     if (label32 != NULL) {
       // remove any byte order marks if any
       if (label32[0] == 0xfeff) {
         label32++;
       }
       int len = LabelLen(label32);
       label32_ = new char_32[len + 1];
       memcpy(label32_, label32, len * sizeof(*label32));
       label32_[len] = 0;
     }
   }

◆ SetLabel() [3/3]

void tesseract::CharSamp::SetLabel ( string str )

Definition at line 71 of file char_samp.cpp.

                                   {
   if (label32_ != NULL) {
     delete []label32_;
     label32_ = NULL;
   }
   string_32 str32;
   CubeUtils::UTF8ToUTF32(str.c_str(), &str32);
   SetLabel(reinterpret_cast<const char_32 *>(str32.c_str()));
 }

◆ SetLastChar()

void tesseract::CharSamp::SetLastChar ( unsigned short last_char )

inline

Definition at line 99 of file char_samp.h.

                                              {
     last_char_ = last_char;
   }

◆ SetLeft()

void tesseract::CharSamp::SetLeft ( unsigned short left )

inline

Definition at line 65 of file char_samp.h.

65 { left_ = left; }

◆ SetNormAspectRatio()

void tesseract::CharSamp::SetNormAspectRatio ( unsigned short norm_aspect_ratio )

inline

Definition at line 93 of file char_samp.h.

                                                             {
     norm_aspect_ratio_ = norm_aspect_ratio;
   }

◆ SetNormBottom()

void tesseract::CharSamp::SetNormBottom ( unsigned short norm_bottom )

inline

Definition at line 90 of file char_samp.h.

                                                  {
     norm_bottom_ = norm_bottom;
   }

◆ SetNormTop()

void tesseract::CharSamp::SetNormTop ( unsigned short norm_top )

inline

Definition at line 89 of file char_samp.h.

89 { norm_top_ = norm_top; }

◆ SetPage()

void tesseract::CharSamp::SetPage ( unsigned short page )

inline

Definition at line 67 of file char_samp.h.

67 { page_ = page; }

◆ SetTop()

void tesseract::CharSamp::SetTop ( unsigned short top )

inline

Definition at line 66 of file char_samp.h.

66 { top_ = top; }

◆ stringLabel()

string tesseract::CharSamp::stringLabel ( ) const

Definition at line 61 of file char_samp.cpp.

                                    {
   string str = "";
   if (label32_ != NULL) {
     string_32 str32(label32_);
     CubeUtils::UTF32ToUTF8(str32.c_str(), &str);
   }
   return str;
 }

◆ StrLabel()

char_32* tesseract::CharSamp::StrLabel ( ) const

inline

Definition at line 62 of file char_samp.h.

62 { return label32_; }

◆ Top()

unsigned short tesseract::CharSamp::Top ( ) const

inline

Definition at line 48 of file char_samp.h.

48 { return top_; }

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

cube/char_samp.h
cube/char_samp.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CharSamp() [1/3]

◆ CharSamp() [2/3]

◆ CharSamp() [3/3]

◆ ~CharSamp()

Member Function Documentation

◆ AuxFeatureCnt()

◆ Bottom()

◆ Clone()

◆ ComputeFeatures()

◆ Crop()

◆ FirstChar()

◆ FromCharDumpFile() [1/3]

◆ FromCharDumpFile() [2/3]

◆ FromCharDumpFile() [3/3]

◆ FromConComps()

◆ FromRawData()

◆ Label()

◆ LabelLen() [1/2]

◆ LabelLen() [2/2]

◆ LastChar()

◆ Left()

◆ NormAspectRatio()

◆ NormBottom()

◆ NormTop()

◆ Page()

◆ Right()

◆ Save2CharDumpFile()

◆ Scale()

◆ Segment()

◆ SetFirstChar()

◆ SetLabel() [1/3]

◆ SetLabel() [2/3]

◆ SetLabel() [3/3]

◆ SetLastChar()

◆ SetLeft()

◆ SetNormAspectRatio()

◆ SetNormBottom()

◆ SetNormTop()

◆ SetPage()

◆ SetTop()

◆ stringLabel()

◆ StrLabel()

◆ Top()