#include <trainingsampleset.h>

Public Member Functions
	TrainingSampleSet (const FontInfoTable &fontinfo_table)

	~TrainingSampleSet ()

bool	Serialize (FILE *fp) const

bool	DeSerialize (bool swap, FILE *fp)

int	num_samples () const

int	num_raw_samples () const

int	NumFonts () const

const UNICHARSET &	unicharset () const

int	charsetsize () const

const FontInfoTable &	fontinfo_table () const

void	LoadUnicharset (const char *filename)

int	AddSample (const char unichar, TrainingSample sample)

void	AddSample (int unichar_id, TrainingSample *sample)

int	NumClassSamples (int font_id, int class_id, bool randomize) const

const TrainingSample *	GetSample (int index) const

const TrainingSample *	GetSample (int font_id, int class_id, int index) const

TrainingSample *	MutableSample (int font_id, int class_id, int index)

std::string	SampleToString (const TrainingSample &sample) const

const BitVector &	GetCloudFeatures (int font_id, int class_id) const

const std::vector< int > &	GetCanonicalFeatures (int font_id, int class_id) const

float	UnicharDistance (const UnicharAndFonts &uf1, const UnicharAndFonts &uf2, bool matched_fonts, const IntFeatureMap &feature_map)

float	ClusterDistance (int font_id1, int class_id1, int font_id2, int class_id2, const IntFeatureMap &feature_map)

float	ComputeClusterDistance (int font_id1, int class_id1, int font_id2, int class_id2, const IntFeatureMap &feature_map) const

int	ReliablySeparable (int font_id1, int class_id1, int font_id2, int class_id2, const IntFeatureMap &feature_map, bool thorough) const

int	GlobalSampleIndex (int font_id, int class_id, int index) const

const TrainingSample *	GetCanonicalSample (int font_id, int class_id) const

float	GetCanonicalDist (int font_id, int class_id) const

TrainingSample *	mutable_sample (int index)

TrainingSample *	extract_sample (int index)

void	IndexFeatures (const IntFeatureSpace &feature_space)

void	KillSample (TrainingSample *sample)

void	DeleteDeadSamples ()

void	OrganizeByFontAndClass ()

void	SetupFontIdMap ()

void	ComputeCanonicalSamples (const IntFeatureMap &map, bool debug)

void	ReplicateAndRandomizeSamples ()

void	ComputeCanonicalFeatures ()

void	ComputeCloudFeatures (int feature_space_size)

void	AddAllFontsForClass (int class_id, Shape *shape) const

void	DisplaySamplesWithFeature (int f_index, const Shape &shape, const IntFeatureSpace &feature_space, ScrollView::Color color, ScrollView *window) const

Detailed Description

Definition at line 41 of file trainingsampleset.h.

Constructor & Destructor Documentation

◆ TrainingSampleSet()

tesseract::TrainingSampleSet::TrainingSampleSet ( const FontInfoTable & fontinfo_table )

explicit

Definition at line 86 of file trainingsampleset.cpp.

    : num_raw_samples_(0)
    , unicharset_size_(0)
    , font_class_array_(nullptr)
    , fontinfo_table_(font_table) {}

◆ ~TrainingSampleSet()

tesseract::TrainingSampleSet::~TrainingSampleSet ( )

Definition at line 92 of file trainingsampleset.cpp.

                                      {
  for (auto sample : samples_) {
    delete sample;
  }
  delete font_class_array_;
}

Member Function Documentation

◆ AddAllFontsForClass()

void tesseract::TrainingSampleSet::AddAllFontsForClass	(	int	class_id,
		Shape *	shape
	)		const

Definition at line 781 of file trainingsampleset.cpp.

                                                                            {
  for (int f = 0; f < font_id_map_.CompactSize(); ++f) {
    const int font_id = font_id_map_.CompactToSparse(f);
    shape->AddToShape(class_id, font_id);
  }
}

◆ AddSample() [1/2]

int tesseract::TrainingSampleSet::AddSample	(	const char *	unichar,
		TrainingSample *	sample
	)

Definition at line 170 of file trainingsampleset.cpp.

                                                                            {
  if (!unicharset_.contains_unichar(unichar)) {
    unicharset_.unichar_insert(unichar);
    if (unicharset_.size() > MAX_NUM_CLASSES) {
      tprintf(
          "Error: Size of unicharset in TrainingSampleSet::AddSample is "
          "greater than MAX_NUM_CLASSES\n");
      return -1;
    }
  }
  UNICHAR_ID char_id = unicharset_.unichar_to_id(unichar);
  AddSample(char_id, sample);
  return char_id;
}

◆ AddSample() [2/2]

void tesseract::TrainingSampleSet::AddSample	(	int	unichar_id,
		TrainingSample *	sample
	)

Definition at line 187 of file trainingsampleset.cpp.

                                                                        {
  sample->set_class_id(unichar_id);
  samples_.push_back(sample);
  num_raw_samples_ = samples_.size();
  unicharset_size_ = unicharset_.size();
}

◆ charsetsize()

int tesseract::TrainingSampleSet::charsetsize ( ) const

inline

Definition at line 65 of file trainingsampleset.h.

                          {
    return unicharset_size_;
  }

◆ ClusterDistance()

float tesseract::TrainingSampleSet::ClusterDistance	(	int	font_id1,
		int	class_id1,
		int	font_id2,
		int	class_id2,
		const IntFeatureMap &	feature_map
	)

Definition at line 337 of file trainingsampleset.cpp.

                                                                           {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_index1 = font_id_map_.SparseToCompact(font_id1);
  int font_index2 = font_id_map_.SparseToCompact(font_id2);
  if (font_index1 < 0 || font_index2 < 0) {
    return 0.0f;
  }
  FontClassInfo &fc_info = (*font_class_array_)(font_index1, class_id1);
  if (font_id1 == font_id2) {
    // Special case cache for speed.
    if (fc_info.unichar_distance_cache.empty()) {
      fc_info.unichar_distance_cache.resize(unicharset_size_, -1.0f);
    }
    if (fc_info.unichar_distance_cache[class_id2] < 0) {
      // Distance has to be calculated.
      float result = ComputeClusterDistance(font_id1, class_id1, font_id2, class_id2, feature_map);
      fc_info.unichar_distance_cache[class_id2] = result;
      // Copy to the symmetric cache entry.
      FontClassInfo &fc_info2 = (*font_class_array_)(font_index2, class_id2);
      if (fc_info2.unichar_distance_cache.empty()) {
        fc_info2.unichar_distance_cache.resize(unicharset_size_, -1.0f);
      }
      fc_info2.unichar_distance_cache[class_id1] = result;
    }
    return fc_info.unichar_distance_cache[class_id2];
  } else if (class_id1 == class_id2) {
    // Another special-case cache for equal class-id.
    if (fc_info.font_distance_cache.empty()) {
      fc_info.font_distance_cache.resize(font_id_map_.CompactSize(), -1.0f);
    }
    if (fc_info.font_distance_cache[font_index2] < 0) {
      // Distance has to be calculated.
      float result = ComputeClusterDistance(font_id1, class_id1, font_id2, class_id2, feature_map);
      fc_info.font_distance_cache[font_index2] = result;
      // Copy to the symmetric cache entry.
      FontClassInfo &fc_info2 = (*font_class_array_)(font_index2, class_id2);
      if (fc_info2.font_distance_cache.empty()) {
        fc_info2.font_distance_cache.resize(font_id_map_.CompactSize(), -1.0f);
      }
      fc_info2.font_distance_cache[font_index1] = result;
    }
    return fc_info.font_distance_cache[font_index2];
  }
  // Both font and class are different. Linear search for class_id2/font_id2
  // in what is a hopefully short list of distances.
  size_t cache_index = 0;
  while (cache_index < fc_info.distance_cache.size() &&
         (fc_info.distance_cache[cache_index].unichar_id != class_id2 ||
          fc_info.distance_cache[cache_index].font_id != font_id2)) {
    ++cache_index;
  }
  if (cache_index == fc_info.distance_cache.size()) {
    // Distance has to be calculated.
    float result = ComputeClusterDistance(font_id1, class_id1, font_id2, class_id2, feature_map);
    FontClassDistance fc_dist = {class_id2, font_id2, result};
    fc_info.distance_cache.push_back(fc_dist);
    // Copy to the symmetric cache entry. We know it isn't there already, as
    // we always copy to the symmetric entry.
    FontClassInfo &fc_info2 = (*font_class_array_)(font_index2, class_id2);
    fc_dist.unichar_id = class_id1;
    fc_dist.font_id = font_id1;
    fc_info2.distance_cache.push_back(fc_dist);
  }
  return fc_info.distance_cache[cache_index].distance;
}

◆ ComputeCanonicalFeatures()

void tesseract::TrainingSampleSet::ComputeCanonicalFeatures ( )

Definition at line 738 of file trainingsampleset.cpp.

                                                 {
  ASSERT_HOST(font_class_array_ != nullptr);
  const int font_size = font_id_map_.CompactSize();
  for (int font_index = 0; font_index < font_size; ++font_index) {
    const int font_id = font_id_map_.CompactToSparse(font_index);
    for (int c = 0; c < unicharset_size_; ++c) {
      int num_samples = NumClassSamples(font_id, c, false);
      if (num_samples == 0) {
        continue;
      }
      const TrainingSample *sample = GetCanonicalSample(font_id, c);
      FontClassInfo &fcinfo = (*font_class_array_)(font_index, c);
      fcinfo.canonical_features = sample->indexed_features();
    }
  }
}

◆ ComputeCanonicalSamples()

void tesseract::TrainingSampleSet::ComputeCanonicalSamples	(	const IntFeatureMap &	map,
		bool	debug
	)

Definition at line 611 of file trainingsampleset.cpp.

                                                                                    {
  ASSERT_HOST(font_class_array_ != nullptr);
  IntFeatureDist f_table;
  if (debug) {
    tprintf("feature table size %d\n", map.sparse_size());
  }
  f_table.Init(&map);
  int worst_s1 = 0;
  int worst_s2 = 0;
  double global_worst_dist = 0.0;
  // Compute distances independently for each font and char index.
  int font_size = font_id_map_.CompactSize();
  for (int font_index = 0; font_index < font_size; ++font_index) {
    int font_id = font_id_map_.CompactToSparse(font_index);
    for (int c = 0; c < unicharset_size_; ++c) {
      int samples_found = 0;
      FontClassInfo &fcinfo = (*font_class_array_)(font_index, c);
      if (fcinfo.samples.empty() || (kTestChar >= 0 && c != kTestChar)) {
        fcinfo.canonical_sample = -1;
        fcinfo.canonical_dist = 0.0f;
        if (debug) {
          tprintf("Skipping class %d\n", c);
        }
        continue;
      }
      // The canonical sample will be the one with the min_max_dist, which
      // is the sample with the lowest maximum distance to all other samples.
      double min_max_dist = 2.0;
      // We keep track of the farthest apart pair (max_s1, max_s2) which
      // are max_max_dist apart, so we can see how bad the variability is.
      double max_max_dist = 0.0;
      int max_s1 = 0;
      int max_s2 = 0;
      fcinfo.canonical_sample = fcinfo.samples[0];
      fcinfo.canonical_dist = 0.0f;
      for (auto s1 : fcinfo.samples) {
        const std::vector<int> &features1 = samples_[s1]->indexed_features();
        f_table.Set(features1, features1.size(), true);
        double max_dist = 0.0;
        // Run the full squared-order search for similar samples. It is still
        // reasonably fast because f_table.FeatureDistance is fast, but we
        // may have to reconsider if we start playing with too many samples
        // of a single char/font.
        for (int s2 : fcinfo.samples) {
          if (samples_[s2]->class_id() != c || samples_[s2]->font_id() != font_id || s2 == s1) {
            continue;
          }
          std::vector<int> features2 = samples_[s2]->indexed_features();
          double dist = f_table.FeatureDistance(features2);
          if (dist > max_dist) {
            max_dist = dist;
            if (dist > max_max_dist) {
              max_max_dist = dist;
              max_s1 = s1;
              max_s2 = s2;
            }
          }
        }
        // Using Set(..., false) is far faster than re initializing, due to
        // the sparseness of the feature space.
        f_table.Set(features1, features1.size(), false);
        samples_[s1]->set_max_dist(max_dist);
        ++samples_found;
        if (max_dist < min_max_dist) {
          fcinfo.canonical_sample = s1;
          fcinfo.canonical_dist = max_dist;
        }
        UpdateRange(max_dist, &min_max_dist, &max_max_dist);
      }
      if (max_max_dist > global_worst_dist) {
        // Keep a record of the worst pair over all characters/fonts too.
        global_worst_dist = max_max_dist;
        worst_s1 = max_s1;
        worst_s2 = max_s2;
      }
      if (debug) {
        tprintf(
            "Found %d samples of class %d=%s, font %d, "
            "dist range [%g, %g], worst pair= %s, %s\n",
            samples_found, c, unicharset_.debug_str(c).c_str(), font_index, min_max_dist,
            max_max_dist, SampleToString(*samples_[max_s1]).c_str(),
            SampleToString(*samples_[max_s2]).c_str());
      }
    }
  }
  if (debug) {
    tprintf("Global worst dist = %g, between sample %d and %d\n", global_worst_dist, worst_s1,
            worst_s2);
  }
}

◆ ComputeCloudFeatures()

void tesseract::TrainingSampleSet::ComputeCloudFeatures ( int feature_space_size )

Definition at line 757 of file trainingsampleset.cpp.

                                                                   {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_size = font_id_map_.CompactSize();
  for (int font_index = 0; font_index < font_size; ++font_index) {
    int font_id = font_id_map_.CompactToSparse(font_index);
    for (int c = 0; c < unicharset_size_; ++c) {
      int num_samples = NumClassSamples(font_id, c, false);
      if (num_samples == 0) {
        continue;
      }
      FontClassInfo &fcinfo = (*font_class_array_)(font_index, c);
      fcinfo.cloud_features.Init(feature_space_size);
      for (int s = 0; s < num_samples; ++s) {
        const TrainingSample *sample = GetSample(font_id, c, s);
        const std::vector<int> &sample_features = sample->indexed_features();
        for (int sample_feature : sample_features) {
          fcinfo.cloud_features.SetBit(sample_feature);
        }
      }
    }
  }
}

◆ ComputeClusterDistance()

float tesseract::TrainingSampleSet::ComputeClusterDistance	(	int	font_id1,
		int	class_id1,
		int	font_id2,
		int	class_id2,
		const IntFeatureMap &	feature_map
	)		const

Definition at line 405 of file trainingsampleset.cpp.

                                                                                        {
  int dist = ReliablySeparable(font_id1, class_id1, font_id2, class_id2, feature_map, false);
  dist += ReliablySeparable(font_id2, class_id2, font_id1, class_id1, feature_map, false);
  int denominator = GetCanonicalFeatures(font_id1, class_id1).size();
  denominator += GetCanonicalFeatures(font_id2, class_id2).size();
  return static_cast<float>(dist) / denominator;
}

◆ DeleteDeadSamples()

void tesseract::TrainingSampleSet::DeleteDeadSamples ( )

Definition at line 540 of file trainingsampleset.cpp.

                                          {
  using namespace std::placeholders; // for _1
  for (auto &&it = samples_.begin(); it < samples_.end();) {
    if (*it == nullptr || (*it)->class_id() < 0) {
      samples_.erase(it);
      delete *it;
    } else {
      ++it;
    }
  }
  num_raw_samples_ = samples_.size();
  // Samples must be re-organized now we have deleted a few.
}

◆ DeSerialize()

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

Definition at line 124 of file trainingsampleset.cpp.

                                                       {
  if (!tesseract::DeSerialize(swap, fp, samples_)) {
    return false;
  }
  num_raw_samples_ = samples_.size();
  if (!unicharset_.load_from_file(fp)) {
    return false;
  }
  if (!font_id_map_.DeSerialize(swap, fp)) {
    return false;
  }
  delete font_class_array_;
  font_class_array_ = nullptr;
  int8_t not_null;
  if (fread(&not_null, sizeof(not_null), 1, fp) != 1) {
    return false;
  }
  if (not_null) {
    FontClassInfo empty;
    font_class_array_ = new GENERIC_2D_ARRAY<FontClassInfo>(1, 1, empty);
    if (!font_class_array_->DeSerializeClasses(swap, fp)) {
      return false;
    }
  }
  unicharset_size_ = unicharset_.size();
  return true;
}

◆ DisplaySamplesWithFeature()

void tesseract::TrainingSampleSet::DisplaySamplesWithFeature	(	int	f_index,
		const Shape &	shape,
		const IntFeatureSpace &	feature_space,
		ScrollView::Color	color,
		ScrollView *	window
	)		const

Definition at line 792 of file trainingsampleset.cpp.

                                                                            {
  for (int s = 0; s < num_raw_samples(); ++s) {
    const TrainingSample *sample = GetSample(s);
    if (shape.ContainsUnichar(sample->class_id())) {
      std::vector<int> indexed_features;
      space.IndexAndSortFeatures(sample->features(), sample->num_features(), &indexed_features);
      for (int indexed_feature : indexed_features) {
        if (indexed_feature == f_index) {
          sample->DisplayFeatures(color, window);
        }
      }
    }
  }
}

◆ extract_sample()

TrainingSample * tesseract::TrainingSampleSet::extract_sample ( int index )

inline

Definition at line 157 of file trainingsampleset.h.

                                            {
    TrainingSample *sample = samples_[index];
    samples_[index] = nullptr;
    return sample;
  }

◆ fontinfo_table()

const FontInfoTable & tesseract::TrainingSampleSet::fontinfo_table ( ) const

inline

Definition at line 68 of file trainingsampleset.h.

                                              {
    return fontinfo_table_;
  }

◆ GetCanonicalDist()

float tesseract::TrainingSampleSet::GetCanonicalDist	(	int	font_id,
		int	class_id
	)		const

Definition at line 513 of file trainingsampleset.cpp.

                                                                         {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_index = font_id_map_.SparseToCompact(font_id);
  if (font_index < 0) {
    return 0.0f;
  }
  if ((*font_class_array_)(font_index, class_id).canonical_sample >= 0) {
    return (*font_class_array_)(font_index, class_id).canonical_dist;
  } else {
    return 0.0f;
  }
}

◆ GetCanonicalFeatures()

const std::vector< int > & tesseract::TrainingSampleSet::GetCanonicalFeatures	(	int	font_id,
		int	class_id
	)		const

Definition at line 263 of file trainingsampleset.cpp.

                                                                                             {
  int font_index = font_id_map_.SparseToCompact(font_id);
  ASSERT_HOST(font_index >= 0);
  return (*font_class_array_)(font_index, class_id).canonical_features;
}

◆ GetCanonicalSample()

const TrainingSample * tesseract::TrainingSampleSet::GetCanonicalSample	(	int	font_id,
		int	class_id
	)		const

Definition at line 501 of file trainingsampleset.cpp.

                                                                                           {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_index = font_id_map_.SparseToCompact(font_id);
  if (font_index < 0) {
    return nullptr;
  }
  const int sample_index = (*font_class_array_)(font_index, class_id).canonical_sample;
  return sample_index >= 0 ? samples_[sample_index] : nullptr;
}

◆ GetCloudFeatures()

const BitVector & tesseract::TrainingSampleSet::GetCloudFeatures	(	int	font_id,
		int	class_id
	)		const

Definition at line 256 of file trainingsampleset.cpp.

                                                                                    {
  int font_index = font_id_map_.SparseToCompact(font_id);
  ASSERT_HOST(font_index >= 0);
  return (*font_class_array_)(font_index, class_id).cloud_features;
}

◆ GetSample() [1/2]

const TrainingSample * tesseract::TrainingSampleSet::GetSample	(	int	font_id,
		int	class_id,
		int	index
	)		const

Definition at line 223 of file trainingsampleset.cpp.

                                                                                             {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_index = font_id_map_.SparseToCompact(font_id);
  if (font_index < 0) {
    return nullptr;
  }
  int sample_index = (*font_class_array_)(font_index, class_id).samples[index];
  return samples_[sample_index];
}

◆ GetSample() [2/2]

const TrainingSample * tesseract::TrainingSampleSet::GetSample ( int index ) const

Definition at line 217 of file trainingsampleset.cpp.

                                                                  {
  return samples_[index];
}

◆ GlobalSampleIndex()

int tesseract::TrainingSampleSet::GlobalSampleIndex	(	int	font_id,
		int	class_id,
		int	index
	)		const

Definition at line 490 of file trainingsampleset.cpp.

                                                                                   {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_index = font_id_map_.SparseToCompact(font_id);
  if (font_index < 0) {
    return -1;
  }
  return (*font_class_array_)(font_index, class_id).samples[index];
}

◆ IndexFeatures()

void tesseract::TrainingSampleSet::IndexFeatures ( const IntFeatureSpace & feature_space )

Definition at line 527 of file trainingsampleset.cpp.

                                                                          {
  for (auto &sample : samples_) {
    sample->IndexFeatures(feature_space);
  }
}

◆ KillSample()

void tesseract::TrainingSampleSet::KillSample ( TrainingSample * sample )

Definition at line 535 of file trainingsampleset.cpp.

                                                         {
  sample->set_sample_index(-1);
}

◆ LoadUnicharset()

void tesseract::TrainingSampleSet::LoadUnicharset ( const char * filename )

Definition at line 153 of file trainingsampleset.cpp.

                                                           {
  if (!unicharset_.load_from_file(filename)) {
    tprintf(
        "Failed to load unicharset from file %s\n"
        "Building unicharset from scratch...\n",
        filename);
    unicharset_.clear();
    // Add special characters as they were removed by the clear.
    UNICHARSET empty;
    unicharset_.AppendOtherUnicharset(empty);
  }
  unicharset_size_ = unicharset_.size();
}

◆ mutable_sample()

TrainingSample * tesseract::TrainingSampleSet::mutable_sample ( int index )

inline

Definition at line 153 of file trainingsampleset.h.

                                            {
    return samples_[index];
  }

◆ MutableSample()

TrainingSample * tesseract::TrainingSampleSet::MutableSample	(	int	font_id,
		int	class_id,
		int	index
	)

Definition at line 235 of file trainingsampleset.cpp.

                                                                                     {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_index = font_id_map_.SparseToCompact(font_id);
  if (font_index < 0) {
    return nullptr;
  }
  int sample_index = (*font_class_array_)(font_index, class_id).samples[index];
  return samples_[sample_index];
}

◆ num_raw_samples()

int tesseract::TrainingSampleSet::num_raw_samples ( ) const

inline

Definition at line 56 of file trainingsampleset.h.

                              {
    return num_raw_samples_;
  }

◆ num_samples()

int tesseract::TrainingSampleSet::num_samples ( ) const

inline

Definition at line 53 of file trainingsampleset.h.

                          {
    return samples_.size();
  }

◆ NumClassSamples()

int tesseract::TrainingSampleSet::NumClassSamples	(	int	font_id,
		int	class_id,
		bool	randomize
	)		const

Definition at line 198 of file trainingsampleset.cpp.

                                                                                      {
  ASSERT_HOST(font_class_array_ != nullptr);
  if (font_id < 0 || class_id < 0 || font_id >= font_id_map_.SparseSize() ||
      class_id >= unicharset_size_) {
    // There are no samples because the font or class doesn't exist.
    return 0;
  }
  int font_index = font_id_map_.SparseToCompact(font_id);
  if (font_index < 0) {
    return 0; // The font has no samples.
  }
  if (randomize) {
    return (*font_class_array_)(font_index, class_id).samples.size();
  } else {
    return (*font_class_array_)(font_index, class_id).num_raw_samples;
  }
}

◆ NumFonts()

int tesseract::TrainingSampleSet::NumFonts ( ) const

inline

Definition at line 59 of file trainingsampleset.h.

                       {
    return font_id_map_.SparseSize();
  }

◆ OrganizeByFontAndClass()

void tesseract::TrainingSampleSet::OrganizeByFontAndClass ( )

Definition at line 555 of file trainingsampleset.cpp.

                                               {
  // Font indexes are sparse, so we used a map to compact them, so we can
  // have an efficient 2-d array of fonts and character classes.
  SetupFontIdMap();
  int compact_font_size = font_id_map_.CompactSize();
  // Get a 2-d array of generic vectors.
  delete font_class_array_;
  FontClassInfo empty;
  font_class_array_ =
      new GENERIC_2D_ARRAY<FontClassInfo>(compact_font_size, unicharset_size_, empty);
  for (size_t s = 0; s < samples_.size(); ++s) {
    int font_id = samples_[s]->font_id();
    int class_id = samples_[s]->class_id();
    if (font_id < 0 || font_id >= font_id_map_.SparseSize()) {
      tprintf("Font id = %d/%d, class id = %d/%d on sample %zu\n", font_id,
              font_id_map_.SparseSize(), class_id, unicharset_size_, s);
    }
    ASSERT_HOST(font_id >= 0 && font_id < font_id_map_.SparseSize());
    ASSERT_HOST(class_id >= 0 && class_id < unicharset_size_);
    int font_index = font_id_map_.SparseToCompact(font_id);
    (*font_class_array_)(font_index, class_id).samples.push_back(s);
  }
  // Set the num_raw_samples member of the FontClassInfo, to set the boundary
  // between the raw samples and the replicated ones.
  for (int f = 0; f < compact_font_size; ++f) {
    for (int c = 0; c < unicharset_size_; ++c) {
      (*font_class_array_)(f, c).num_raw_samples = (*font_class_array_)(f, c).samples.size();
    }
  }
  // This is the global number of samples and also marks the boundary between
  // real and replicated samples.
  num_raw_samples_ = samples_.size();
}

◆ ReliablySeparable()

int tesseract::TrainingSampleSet::ReliablySeparable	(	int	font_id1,
		int	class_id1,
		int	font_id2,
		int	class_id2,
		const IntFeatureMap &	feature_map,
		bool	thorough
	)		const

Definition at line 451 of file trainingsampleset.cpp.

                                                                                                {
  int result = 0;
  const TrainingSample *sample2 = GetCanonicalSample(font_id2, class_id2);
  if (sample2 == nullptr) {
    return 0; // There are no canonical features.
  }
  const std::vector<int> &canonical2 = GetCanonicalFeatures(font_id2, class_id2);
  const BitVector &cloud1 = GetCloudFeatures(font_id1, class_id1);
  if (cloud1.empty()) {
    return canonical2.size(); // There are no cloud features.
  }
 
  // Find a canonical2 feature that is not in cloud1.
  for (int feature : canonical2) {
    if (cloud1[feature]) {
      continue;
    }
    // Gather the near neighbours of f.
    std::vector<int> good_features;
    AddNearFeatures(feature_map, feature, 1, &good_features);
    // Check that none of the good_features are in the cloud.
    bool found = false;
    for (auto good_f : good_features) {
      if (cloud1[good_f]) {
        found = true;
        break;
      }
    }
    if (found) {
      continue; // Found one in the cloud.
    }
    ++result;
  }
  return result;
}

◆ ReplicateAndRandomizeSamples()

void tesseract::TrainingSampleSet::ReplicateAndRandomizeSamples ( )

Definition at line 707 of file trainingsampleset.cpp.

                                                     {
  ASSERT_HOST(font_class_array_ != nullptr);
  int font_size = font_id_map_.CompactSize();
  for (int font_index = 0; font_index < font_size; ++font_index) {
    for (int c = 0; c < unicharset_size_; ++c) {
      FontClassInfo &fcinfo = (*font_class_array_)(font_index, c);
      int sample_count = fcinfo.samples.size();
      int min_samples = 2 * std::max(kSampleRandomSize, sample_count);
      if (sample_count > 0 && sample_count < min_samples) {
        int base_count = sample_count;
        for (int base_index = 0; sample_count < min_samples; ++sample_count) {
          int src_index = fcinfo.samples[base_index++];
          if (base_index >= base_count) {
            base_index = 0;
          }
          TrainingSample *sample =
              samples_[src_index]->RandomizedCopy(sample_count % kSampleRandomSize);
          int sample_index = samples_.size();
          sample->set_sample_index(sample_index);
          samples_.push_back(sample);
          fcinfo.samples.push_back(sample_index);
        }
      }
    }
  }
}

◆ SampleToString()

std::string tesseract::TrainingSampleSet::SampleToString ( const TrainingSample & sample ) const

Definition at line 247 of file trainingsampleset.cpp.

                                                                              {
  std::string boxfile_str;
  MakeBoxFileStr(unicharset_.id_to_unichar(sample.class_id()), sample.bounding_box(),
                 sample.page_num(), boxfile_str);
  return std::string(fontinfo_table_.at(sample.font_id()).name) + " " + boxfile_str;
}

◆ Serialize()

bool tesseract::TrainingSampleSet::Serialize ( FILE * fp ) const

Definition at line 100 of file trainingsampleset.cpp.

                                                {
  if (!tesseract::Serialize(fp, samples_)) {
    return false;
  }
  if (!unicharset_.save_to_file(fp)) {
    return false;
  }
  if (!font_id_map_.Serialize(fp)) {
    return false;
  }
  int8_t not_null = font_class_array_ != nullptr;
  if (fwrite(&not_null, sizeof(not_null), 1, fp) != 1) {
    return false;
  }
  if (not_null) {
    if (!font_class_array_->SerializeClasses(fp)) {
      return false;
    }
  }
  return true;
}

◆ SetupFontIdMap()

void tesseract::TrainingSampleSet::SetupFontIdMap ( )

Definition at line 591 of file trainingsampleset.cpp.

                                       {
  // Number of samples for each font_id.
  std::vector<int> font_counts;
  for (auto &sample : samples_) {
    const int font_id = sample->font_id();
    while (font_id >= font_counts.size()) {
      font_counts.push_back(0);
    }
    ++font_counts[font_id];
  }
  font_id_map_.Init(font_counts.size(), false);
  for (size_t f = 0; f < font_counts.size(); ++f) {
    font_id_map_.SetMap(f, font_counts[f] > 0);
  }
  font_id_map_.Setup();
}

◆ UnicharDistance()

float tesseract::TrainingSampleSet::UnicharDistance	(	const UnicharAndFonts &	uf1,
		const UnicharAndFonts &	uf2,
		bool	matched_fonts,
		const IntFeatureMap &	feature_map
	)

Definition at line 273 of file trainingsampleset.cpp.

                                                                                               {
  int num_fonts1 = uf1.font_ids.size();
  int c1 = uf1.unichar_id;
  int num_fonts2 = uf2.font_ids.size();
  int c2 = uf2.unichar_id;
  double dist_sum = 0.0;
  int dist_count = 0;
  const bool debug = false;
  if (matched_fonts) {
    // Compute distances only where fonts match.
    for (int i = 0; i < num_fonts1; ++i) {
      int f1 = uf1.font_ids[i];
      for (int j = 0; j < num_fonts2; ++j) {
        int f2 = uf2.font_ids[j];
        if (f1 == f2) {
          dist_sum += ClusterDistance(f1, c1, f2, c2, feature_map);
          ++dist_count;
        }
      }
    }
  } else if (num_fonts1 * num_fonts2 <= kSquareLimit) {
    // Small enough sets to compute all the distances.
    for (int i = 0; i < num_fonts1; ++i) {
      int f1 = uf1.font_ids[i];
      for (int j = 0; j < num_fonts2; ++j) {
        int f2 = uf2.font_ids[j];
        dist_sum += ClusterDistance(f1, c1, f2, c2, feature_map);
        if (debug) {
          tprintf("Cluster dist %d %d %d %d = %g\n", f1, c1, f2, c2,
                  ClusterDistance(f1, c1, f2, c2, feature_map));
        }
        ++dist_count;
      }
    }
  } else {
    // Subsample distances, using the largest set once, and stepping through
    // the smaller set so as to ensure that all the pairs are different.
    int increment = kPrime1 != num_fonts2 ? kPrime1 : kPrime2;
    int index = 0;
    int num_samples = std::max(num_fonts1, num_fonts2);
    for (int i = 0; i < num_samples; ++i, index += increment) {
      int f1 = uf1.font_ids[i % num_fonts1];
      int f2 = uf2.font_ids[index % num_fonts2];
      if (debug) {
        tprintf("Cluster dist %d %d %d %d = %g\n", f1, c1, f2, c2,
                ClusterDistance(f1, c1, f2, c2, feature_map));
      }
      dist_sum += ClusterDistance(f1, c1, f2, c2, feature_map);
      ++dist_count;
    }
  }
  if (dist_count == 0) {
    if (matched_fonts) {
      return UnicharDistance(uf1, uf2, false, feature_map);
    }
    return 0.0f;
  }
  return dist_sum / dist_count;
}

◆ unicharset()

const UNICHARSET & tesseract::TrainingSampleSet::unicharset ( ) const

inline

Definition at line 62 of file trainingsampleset.h.

                                       {
    return unicharset_;
  }

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

/media/home/debian/src/github/tesseract-ocr/tesseract/src/training/common/trainingsampleset.h
/media/home/debian/src/github/tesseract-ocr/tesseract/src/training/common/trainingsampleset.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ TrainingSampleSet()

◆ ~TrainingSampleSet()

Member Function Documentation

◆ AddAllFontsForClass()

◆ AddSample() [1/2]

◆ AddSample() [2/2]

◆ charsetsize()

◆ ClusterDistance()

◆ ComputeCanonicalFeatures()

◆ ComputeCanonicalSamples()

◆ ComputeCloudFeatures()

◆ ComputeClusterDistance()

◆ DeleteDeadSamples()

◆ DeSerialize()

◆ DisplaySamplesWithFeature()

◆ extract_sample()

◆ fontinfo_table()

◆ GetCanonicalDist()

◆ GetCanonicalFeatures()

◆ GetCanonicalSample()

◆ GetCloudFeatures()

◆ GetSample() [1/2]

◆ GetSample() [2/2]

◆ GlobalSampleIndex()

◆ IndexFeatures()

◆ KillSample()

◆ LoadUnicharset()

◆ mutable_sample()

◆ MutableSample()

◆ num_raw_samples()

◆ num_samples()

◆ NumClassSamples()

◆ NumFonts()

◆ OrganizeByFontAndClass()

◆ ReliablySeparable()

◆ ReplicateAndRandomizeSamples()

◆ SampleToString()

◆ Serialize()

◆ SetupFontIdMap()

◆ UnicharDistance()

◆ unicharset()