tesseract::TrainingSample Class Reference

#include <trainingsample.h>

Inheritance diagram for tesseract::TrainingSample:

Public Member Functions
	TrainingSample ()
	~TrainingSample ()
FEATURE_STRUCT *	GetCNFeature () const
TrainingSample *	RandomizedCopy (int index) const
TrainingSample *	Copy () const
bool	Serialize (FILE *fp) const
bool	DeSerialize (bool swap, FILE *fp)
void	ExtractCharDesc (int feature_type, int micro_type, int cn_type, int geo_type, CHAR_DESC_STRUCT *char_desc)
void	IndexFeatures (const IntFeatureSpace &feature_space)
Image	RenderToPix (const UNICHARSET *unicharset) const
void	DisplayFeatures (ScrollView::Color color, ScrollView *window) const
Image	GetSamplePix (int padding, Image page_pix) const
UNICHAR_ID	class_id () const
void	set_class_id (int id)
int	font_id () const
void	set_font_id (int id)
int	page_num () const
void	set_page_num (int page)
const TBOX &	bounding_box () const
void	set_bounding_box (const TBOX &box)
uint32_t	num_features () const
const INT_FEATURE_STRUCT *	features () const
uint32_t	num_micro_features () const
const MicroFeature *	micro_features () const
int	outline_length () const
float	cn_feature (int index) const
int	geo_feature (int index) const
double	weight () const
void	set_weight (double value)
double	max_dist () const
void	set_max_dist (double value)
int	sample_index () const
void	set_sample_index (int value)
bool	features_are_mapped () const
const std::vector< int > &	mapped_features () const
const std::vector< int > &	indexed_features () const
bool	is_error () const
void	set_is_error (bool value)
Public Member Functions inherited from tesseract::ELIST_LINK
	ELIST_LINK ()
	ELIST_LINK (const ELIST_LINK &)
void	operator= (const ELIST_LINK &)

Static Public Member Functions
static TrainingSample *	CopyFromFeatures (const INT_FX_RESULT_STRUCT &fx_info, const TBOX &bounding_box, const INT_FEATURE_STRUCT *features, int num_features)
static TrainingSample *	DeSerializeCreate (bool swap, FILE *fp)

Public Attributes
std::vector< int >	mapped_features_
bool	features_are_indexed_
bool	features_are_mapped_

Detailed Description

Definition at line 54 of file trainingsample.h.

Constructor & Destructor Documentation

TrainingSample()

tesseract::TrainingSample::TrainingSample ( )

inline

Definition at line 56 of file trainingsample.h.

      : class_id_(INVALID_UNICHAR_ID)
      , font_id_(0)
      , page_num_(0)
      , num_features_(0)
      , num_micro_features_(0)
      , outline_length_(0)
      , features_(nullptr)
      , micro_features_(nullptr)
      , weight_(1.0)
      , max_dist_(0.0)
      , sample_index_(0)
      , features_are_indexed_(false)
      , features_are_mapped_(false)
      , is_error_(false) {}

~TrainingSample()

tesseract::TrainingSample::~TrainingSample

(

)

Definition at line 42 of file trainingsample.cpp.

                                {
  delete[] features_;
  delete[] micro_features_;
}

Member Function Documentation

bounding_box()

const TBOX & tesseract::TrainingSample::bounding_box ( ) const

inline

Definition at line 137 of file trainingsample.h.

                                   {
    return bounding_box_;
  }

class_id()

UNICHAR_ID tesseract::TrainingSample::class_id ( ) const

inline

Definition at line 119 of file trainingsample.h.

                              {
    return class_id_;
  }

cn_feature()

float tesseract::TrainingSample::cn_feature ( int  index ) const

inline

Definition at line 158 of file trainingsample.h.

                                    {
    return cn_feature_[index];
  }

Copy()

TrainingSample * tesseract::TrainingSample::Copy

(

)

const

Definition at line 213 of file trainingsample.cpp.

                                           {
  auto *sample = new TrainingSample;
  sample->class_id_ = class_id_;
  sample->font_id_ = font_id_;
  sample->weight_ = weight_;
  sample->sample_index_ = sample_index_;
  sample->num_features_ = num_features_;
  if (num_features_ > 0) {
    sample->features_ = new INT_FEATURE_STRUCT[num_features_];
    memcpy(sample->features_, features_, num_features_ * sizeof(features_[0]));
  }
  sample->num_micro_features_ = num_micro_features_;
  if (num_micro_features_ > 0) {
    sample->micro_features_ = new MicroFeature[num_micro_features_];
    memcpy(sample->micro_features_, micro_features_,
           num_micro_features_ * sizeof(micro_features_[0]));
  }
  memcpy(sample->cn_feature_, cn_feature_, sizeof(*cn_feature_) * kNumCNParams);
  memcpy(sample->geo_feature_, geo_feature_, sizeof(*geo_feature_) * GeoCount);
  return sample;
}

CopyFromFeatures()

TrainingSample * tesseract::TrainingSample::CopyFromFeatures ( const INT_FX_RESULT_STRUCT &  fx_info, const TBOX &  bounding_box, const INT_FEATURE_STRUCT *  features, int  num_features  )

static

Definition at line 158 of file trainingsample.cpp.

                                                                   {
  auto *sample = new TrainingSample;
  sample->num_features_ = num_features;
  sample->features_ = new INT_FEATURE_STRUCT[num_features];
  sample->outline_length_ = fx_info.Length;
  memcpy(sample->features_, features, num_features * sizeof(features[0]));
  sample->geo_feature_[GeoBottom] = bounding_box.bottom();
  sample->geo_feature_[GeoTop] = bounding_box.top();
  sample->geo_feature_[GeoWidth] = bounding_box.width();
 
  // Generate the cn_feature_ from the fx_info.
  sample->cn_feature_[CharNormY] = MF_SCALE_FACTOR * (fx_info.Ymean - kBlnBaselineOffset);
  sample->cn_feature_[CharNormLength] = MF_SCALE_FACTOR * fx_info.Length / LENGTH_COMPRESSION;
  sample->cn_feature_[CharNormRx] = MF_SCALE_FACTOR * fx_info.Rx;
  sample->cn_feature_[CharNormRy] = MF_SCALE_FACTOR * fx_info.Ry;
 
  sample->features_are_indexed_ = false;
  sample->features_are_mapped_ = false;
  return sample;
}

DeSerialize()

bool tesseract::TrainingSample::DeSerialize	(	bool	swap,
		FILE *	fp
	)

Definition at line 102 of file trainingsample.cpp.

                                                    {
  if (fread(&class_id_, sizeof(class_id_), 1, fp) != 1) {
    return false;
  }
  if (fread(&font_id_, sizeof(font_id_), 1, fp) != 1) {
    return false;
  }
  if (fread(&page_num_, sizeof(page_num_), 1, fp) != 1) {
    return false;
  }
  if (!bounding_box_.DeSerialize(swap, fp)) {
    return false;
  }
  if (fread(&num_features_, sizeof(num_features_), 1, fp) != 1) {
    return false;
  }
  if (fread(&num_micro_features_, sizeof(num_micro_features_), 1, fp) != 1) {
    return false;
  }
  if (fread(&outline_length_, sizeof(outline_length_), 1, fp) != 1) {
    return false;
  }
  if (swap) {
    ReverseN(&class_id_, sizeof(class_id_));
    ReverseN(&num_features_, sizeof(num_features_));
    ReverseN(&num_micro_features_, sizeof(num_micro_features_));
    ReverseN(&outline_length_, sizeof(outline_length_));
  }
  // Arbitrarily limit the number of elements to protect against bad data.
  if (num_features_ > UINT16_MAX) {
    return false;
  }
  if (num_micro_features_ > UINT16_MAX) {
    return false;
  }
  delete[] features_;
  features_ = new INT_FEATURE_STRUCT[num_features_];
  if (fread(features_, sizeof(*features_), num_features_, fp) != num_features_) {
    return false;
  }
  delete[] micro_features_;
  micro_features_ = new MicroFeature[num_micro_features_];
  if (fread(micro_features_, sizeof(*micro_features_), num_micro_features_, fp) !=
      num_micro_features_) {
    return false;
  }
  if (fread(cn_feature_, sizeof(*cn_feature_), kNumCNParams, fp) != kNumCNParams) {
    return false;
  }
  if (fread(geo_feature_, sizeof(*geo_feature_), GeoCount, fp) != GeoCount) {
    return false;
  }
  return true;
}

DeSerializeCreate()

TrainingSample * tesseract::TrainingSample::DeSerializeCreate ( bool  swap, FILE *  fp  )

static

Definition at line 91 of file trainingsample.cpp.

                                                                     {
  auto *sample = new TrainingSample;
  if (sample->DeSerialize(swap, fp)) {
    return sample;
  }
  delete sample;
  return nullptr;
}

DisplayFeatures()

void tesseract::TrainingSample::DisplayFeatures	(	ScrollView::Color	color,
		ScrollView *	window
	)		const

Definition at line 330 of file trainingsample.cpp.

                                                                                    {
  for (uint32_t f = 0; f < num_features_; ++f) {
    RenderIntFeature(window, &features_[f], color);
  }
}

ExtractCharDesc()

void tesseract::TrainingSample::ExtractCharDesc	(	int	feature_type,
		int	micro_type,
		int	cn_type,
		int	geo_type,
		CHAR_DESC_STRUCT *	char_desc
	)

Definition at line 236 of file trainingsample.cpp.

                                                                                {
  // Extract the INT features.
  delete[] features_;
  FEATURE_SET_STRUCT *char_features = char_desc->FeatureSets[int_feature_type];
  if (char_features == nullptr) {
    tprintf("Error: no features to train on of type %s\n", kIntFeatureType);
    num_features_ = 0;
    features_ = nullptr;
  } else {
    num_features_ = char_features->NumFeatures;
    features_ = new INT_FEATURE_STRUCT[num_features_];
    for (uint32_t f = 0; f < num_features_; ++f) {
      features_[f].X = static_cast<uint8_t>(char_features->Features[f]->Params[IntX]);
      features_[f].Y = static_cast<uint8_t>(char_features->Features[f]->Params[IntY]);
      features_[f].Theta = static_cast<uint8_t>(char_features->Features[f]->Params[IntDir]);
      features_[f].CP_misses = 0;
    }
  }
  // Extract the Micro features.
  delete[] micro_features_;
  char_features = char_desc->FeatureSets[micro_type];
  if (char_features == nullptr) {
    tprintf("Error: no features to train on of type %s\n", kMicroFeatureType);
    num_micro_features_ = 0;
    micro_features_ = nullptr;
  } else {
    num_micro_features_ = char_features->NumFeatures;
    micro_features_ = new MicroFeature[num_micro_features_];
    for (uint32_t f = 0; f < num_micro_features_; ++f) {
      for (int d = 0; d < (int)MicroFeatureParameter::MFCount; ++d) {
        micro_features_[f][d] = char_features->Features[f]->Params[d];
      }
    }
  }
  // Extract the CN feature.
  char_features = char_desc->FeatureSets[cn_type];
  if (char_features == nullptr) {
    tprintf("Error: no CN feature to train on.\n");
  } else {
    ASSERT_HOST(char_features->NumFeatures == 1);
    cn_feature_[CharNormY] = char_features->Features[0]->Params[CharNormY];
    cn_feature_[CharNormLength] = char_features->Features[0]->Params[CharNormLength];
    cn_feature_[CharNormRx] = char_features->Features[0]->Params[CharNormRx];
    cn_feature_[CharNormRy] = char_features->Features[0]->Params[CharNormRy];
  }
  // Extract the Geo feature.
  char_features = char_desc->FeatureSets[geo_type];
  if (char_features == nullptr) {
    tprintf("Error: no Geo feature to train on.\n");
  } else {
    ASSERT_HOST(char_features->NumFeatures == 1);
    geo_feature_[GeoBottom] = char_features->Features[0]->Params[GeoBottom];
    geo_feature_[GeoTop] = char_features->Features[0]->Params[GeoTop];
    geo_feature_[GeoWidth] = char_features->Features[0]->Params[GeoWidth];
  }
  features_are_indexed_ = false;
  features_are_mapped_ = false;
}

features()

const INT_FEATURE_STRUCT * tesseract::TrainingSample::features ( ) const

inline

Definition at line 146 of file trainingsample.h.

                                             {
    return features_;
  }

features_are_mapped()

bool tesseract::TrainingSample::features_are_mapped ( ) const

inline

Definition at line 182 of file trainingsample.h.

                                   {
    return features_are_mapped_;
  }

font_id()

int tesseract::TrainingSample::font_id ( ) const

inline

Definition at line 125 of file trainingsample.h.

                      {
    return font_id_;
  }

geo_feature()

int tesseract::TrainingSample::geo_feature ( int  index ) const

inline

Definition at line 161 of file trainingsample.h.

                                   {
    return geo_feature_[index];
  }

GetCNFeature()

FEATURE_STRUCT * tesseract::TrainingSample::GetCNFeature

(

)

const

Definition at line 183 of file trainingsample.cpp.

                                                   {
  auto feature = new FEATURE_STRUCT(&CharNormDesc);
  for (int i = 0; i < kNumCNParams; ++i) {
    feature->Params[i] = cn_feature_[i];
  }
  return feature;
}

GetSamplePix()

Image tesseract::TrainingSample::GetSamplePix	(	int	padding,
		Image	page_pix
	)		const

Definition at line 342 of file trainingsample.cpp.

                                                                    {
  if (page_pix == nullptr) {
    return nullptr;
  }
  int page_width = pixGetWidth(page_pix);
  int page_height = pixGetHeight(page_pix);
  TBOX padded_box = bounding_box();
  padded_box.pad(padding, padding);
  // Clip the padded_box to the limits of the page
  TBOX page_box(0, 0, page_width, page_height);
  padded_box &= page_box;
  Box *box =
      boxCreate(page_box.left(), page_height - page_box.top(), page_box.width(), page_box.height());
  Image sample_pix = pixClipRectangle(page_pix, box, nullptr);
  boxDestroy(&box);
  return sample_pix;
}

indexed_features()

const std::vector< int > & tesseract::TrainingSample::indexed_features ( ) const

inline

Definition at line 189 of file trainingsample.h.

                                                 {
    ASSERT_HOST(features_are_indexed_);
    return mapped_features_;
  }

IndexFeatures()

void tesseract::TrainingSample::IndexFeatures

(

const IntFeatureSpace &

feature_space

)

Definition at line 298 of file trainingsample.cpp.

                                                                       {
  std::vector<int> indexed_features;
  feature_space.IndexAndSortFeatures(features_, num_features_, &mapped_features_);
  features_are_indexed_ = true;
  features_are_mapped_ = false;
}

is_error()

bool tesseract::TrainingSample::is_error ( ) const

inline

Definition at line 193 of file trainingsample.h.

                        {
    return is_error_;
  }

mapped_features()

const std::vector< int > & tesseract::TrainingSample::mapped_features ( ) const

inline

Definition at line 185 of file trainingsample.h.

                                                {
    ASSERT_HOST(features_are_mapped_);
    return mapped_features_;
  }

max_dist()

double tesseract::TrainingSample::max_dist ( ) const

inline

Definition at line 170 of file trainingsample.h.

                          {
    return max_dist_;
  }

micro_features()

const MicroFeature * tesseract::TrainingSample::micro_features ( ) const

inline

Definition at line 152 of file trainingsample.h.

                                             {
    return micro_features_;
  }

num_features()

uint32_t tesseract::TrainingSample::num_features ( ) const

inline

Definition at line 143 of file trainingsample.h.

                                {
    return num_features_;
  }

num_micro_features()

uint32_t tesseract::TrainingSample::num_micro_features ( ) const

inline

Definition at line 149 of file trainingsample.h.

                                      {
    return num_micro_features_;
  }

outline_length()

int tesseract::TrainingSample::outline_length ( ) const

inline

Definition at line 155 of file trainingsample.h.

                             {
    return outline_length_;
  }

page_num()

int tesseract::TrainingSample::page_num ( ) const

inline

Definition at line 131 of file trainingsample.h.

                       {
    return page_num_;
  }

RandomizedCopy()

TrainingSample * tesseract::TrainingSample::RandomizedCopy

(

int

index

)

const

Definition at line 194 of file trainingsample.cpp.

                                                              {
  TrainingSample *sample = Copy();
  if (index >= 0 && index < kSampleRandomSize) {
    ++index; // Remove the first combination.
    const int yshift = kYShiftValues[index / kSampleScaleSize];
    double scaling = kScaleValues[index % kSampleScaleSize];
    for (uint32_t i = 0; i < num_features_; ++i) {
      double result = (features_[i].X - kRandomizingCenter) * scaling;
      result += kRandomizingCenter;
      sample->features_[i].X = ClipToRange<int>(result + 0.5, 0, UINT8_MAX);
      result = (features_[i].Y - kRandomizingCenter) * scaling;
      result += kRandomizingCenter + yshift;
      sample->features_[i].Y = ClipToRange<int>(result + 0.5, 0, UINT8_MAX);
    }
  }
  return sample;
}

RenderToPix()

Image tesseract::TrainingSample::RenderToPix

(

const UNICHARSET *

unicharset

)

const

Definition at line 306 of file trainingsample.cpp.

                                                                    {
  Image pix = pixCreate(kIntFeatureExtent, kIntFeatureExtent, 1);
  for (uint32_t f = 0; f < num_features_; ++f) {
    int start_x = features_[f].X;
    int start_y = kIntFeatureExtent - features_[f].Y;
    double dx = cos((features_[f].Theta / 256.0) * 2.0 * M_PI - M_PI);
    double dy = -sin((features_[f].Theta / 256.0) * 2.0 * M_PI - M_PI);
    for (int i = 0; i <= 5; ++i) {
      int x = static_cast<int>(start_x + dx * i);
      int y = static_cast<int>(start_y + dy * i);
      if (x >= 0 && x < 256 && y >= 0 && y < 256) {
        pixSetPixel(pix, x, y, 1);
      }
    }
  }
  if (unicharset != nullptr) {
    pixSetText(pix, unicharset->id_to_unichar(class_id_));
  }
  return pix;
}

sample_index()

int tesseract::TrainingSample::sample_index ( ) const

inline

Definition at line 176 of file trainingsample.h.

                           {
    return sample_index_;
  }

Serialize()

bool tesseract::TrainingSample::Serialize

(

FILE *

fp

)

const

Definition at line 51 of file trainingsample.cpp.

                                             {
  if (fwrite(&class_id_, sizeof(class_id_), 1, fp) != 1) {
    return false;
  }
  if (fwrite(&font_id_, sizeof(font_id_), 1, fp) != 1) {
    return false;
  }
  if (fwrite(&page_num_, sizeof(page_num_), 1, fp) != 1) {
    return false;
  }
  if (!bounding_box_.Serialize(fp)) {
    return false;
  }
  if (fwrite(&num_features_, sizeof(num_features_), 1, fp) != 1) {
    return false;
  }
  if (fwrite(&num_micro_features_, sizeof(num_micro_features_), 1, fp) != 1) {
    return false;
  }
  if (fwrite(&outline_length_, sizeof(outline_length_), 1, fp) != 1) {
    return false;
  }
  if (fwrite(features_, sizeof(*features_), num_features_, fp) != num_features_) {
    return false;
  }
  if (fwrite(micro_features_, sizeof(*micro_features_), num_micro_features_, fp) !=
      num_micro_features_) {
    return false;
  }
  if (fwrite(cn_feature_, sizeof(*cn_feature_), kNumCNParams, fp) != kNumCNParams) {
    return false;
  }
  if (fwrite(geo_feature_, sizeof(*geo_feature_), GeoCount, fp) != GeoCount) {
    return false;
  }
  return true;
}

set_bounding_box()

void tesseract::TrainingSample::set_bounding_box ( const TBOX &  box )

inline

Definition at line 140 of file trainingsample.h.

                                         {
    bounding_box_ = box;
  }

set_class_id()

void tesseract::TrainingSample::set_class_id ( int  id )

inline

Definition at line 122 of file trainingsample.h.

                            {
    class_id_ = id;
  }

set_font_id()

void tesseract::TrainingSample::set_font_id ( int  id )

inline

Definition at line 128 of file trainingsample.h.

                           {
    font_id_ = id;
  }

set_is_error()

void tesseract::TrainingSample::set_is_error ( bool  value )

inline

Definition at line 196 of file trainingsample.h.

                                {
    is_error_ = value;
  }

set_max_dist()

void tesseract::TrainingSample::set_max_dist ( double  value )

inline

Definition at line 173 of file trainingsample.h.

                                  {
    max_dist_ = value;
  }

set_page_num()

void tesseract::TrainingSample::set_page_num ( int  page )

inline

Definition at line 134 of file trainingsample.h.

                              {
    page_num_ = page;
  }

set_sample_index()

void tesseract::TrainingSample::set_sample_index ( int  value )

inline

Definition at line 179 of file trainingsample.h.

                                   {
    sample_index_ = value;
  }

set_weight()

void tesseract::TrainingSample::set_weight ( double  value )

inline

Definition at line 167 of file trainingsample.h.

                                {
    weight_ = value;
  }

weight()

double tesseract::TrainingSample::weight ( ) const

inline

Definition at line 164 of file trainingsample.h.

                        {
    return weight_;
  }

Member Data Documentation

features_are_indexed_

bool tesseract::TrainingSample::features_are_indexed_

Definition at line 244 of file trainingsample.h.

features_are_mapped_

bool tesseract::TrainingSample::features_are_mapped_

Definition at line 245 of file trainingsample.h.

mapped_features_

std::vector<int> tesseract::TrainingSample::mapped_features_

Definition at line 243 of file trainingsample.h.

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/trainingsample.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/trainingsample.cpp