tesseract::STATS Class Reference

#include <statistc.h>

Public Member Functions
	STATS (int32_t min_bucket_value, int32_t max_bucket_value)
	STATS ()=default
	~STATS ()
bool	set_range (int32_t min_bucket_value, int32_t max_bucket_value)
void	clear ()
void	add (int32_t value, int32_t count)
int32_t	mode () const
double	mean () const
double	sd () const
double	ile (double frac) const
int32_t	min_bucket () const
int32_t	max_bucket () const
double	median () const
int32_t	pile_count (int32_t value) const
int32_t	get_total () const
bool	local_min (int32_t x) const
void	smooth (int32_t factor)
int32_t	cluster (float lower, float upper, float multiple, int32_t max_clusters, STATS *clusters)
int	top_n_modes (int max_modes, std::vector< KDPairInc< float, int > > &modes) const
void	print () const
void	print_summary () const
void	plot (ScrollView *window, float xorigin, float yorigin, float xscale, float yscale, ScrollView::Color colour) const
void	plotline (ScrollView *window, float xorigin, float yorigin, float xscale, float yscale, ScrollView::Color colour) const

Detailed Description

Definition at line 30 of file statistc.h.

Constructor & Destructor Documentation

STATS() [1/2]

tesseract::STATS::STATS	(	int32_t	min_bucket_value,
		int32_t	max_bucket_value
	)

Definition at line 43 of file statistc.cpp.

                                                               {
  if (max_bucket_value < min_bucket_value) {
    min_bucket_value = 0;
    max_bucket_value = 1;
  }
  rangemin_ = min_bucket_value; // setup
  rangemax_ = max_bucket_value;
  buckets_ = new int32_t[1 + rangemax_ - rangemin_];
  clear();
}

STATS() [2/2]

tesseract::STATS::STATS ( )

default

~STATS()

tesseract::STATS::~STATS

(

)

Definition at line 90 of file statistc.cpp.

              {
  delete[] buckets_;
}

Member Function Documentation

add()

void tesseract::STATS::add	(	int32_t	value,
		int32_t	count
	)

Definition at line 99 of file statistc.cpp.

                                            {
  if (buckets_ != nullptr) {
    value = ClipToRange(value, rangemin_, rangemax_);
    buckets_[value - rangemin_] += count;
    total_count_ += count; // keep count of total
  }
}

clear()

void tesseract::STATS::clear

(

)

Definition at line 78 of file statistc.cpp.

                  { // clear out buckets
  total_count_ = 0;
  if (buckets_ != nullptr) {
    memset(buckets_, 0, (1 + rangemax_ - rangemin_) * sizeof(buckets_[0]));
  }
}

cluster()

int32_t tesseract::STATS::cluster	(	float	lower,
		float	upper,
		float	multiple,
		int32_t	max_clusters,
		STATS *	clusters
	)

Definition at line 334 of file statistc.cpp.

                                        {    // array of clusters
  bool new_cluster;                          // added one
  float *centres;                            // cluster centres
  int32_t entry;                             // bucket index
  int32_t cluster;                           // cluster index
  int32_t best_cluster;                      // one to assign to
  int32_t new_centre = 0;                    // residual mode
  int32_t new_mode;                          // pile count of new_centre
  int32_t count;                             // pile to place
  float dist;                                // from cluster
  float min_dist;                            // from best_cluster
  int32_t cluster_count;                     // no of clusters
 
  if (buckets_ == nullptr || max_clusters < 1) {
    return 0;
  }
  centres = new float[max_clusters + 1];
  for (cluster_count = 1;
       cluster_count <= max_clusters && clusters[cluster_count].buckets_ != nullptr &&
       clusters[cluster_count].total_count_ > 0;
       cluster_count++) {
    centres[cluster_count] = static_cast<float>(clusters[cluster_count].ile(0.5));
    new_centre = clusters[cluster_count].mode();
    for (entry = new_centre - 1; centres[cluster_count] - entry < lower && entry >= rangemin_ &&
                                 pile_count(entry) <= pile_count(entry + 1);
         entry--) {
      count = pile_count(entry) - clusters[0].pile_count(entry);
      if (count > 0) {
        clusters[cluster_count].add(entry, count);
        clusters[0].add(entry, count);
      }
    }
    for (entry = new_centre + 1; entry - centres[cluster_count] < lower && entry <= rangemax_ &&
                                 pile_count(entry) <= pile_count(entry - 1);
         entry++) {
      count = pile_count(entry) - clusters[0].pile_count(entry);
      if (count > 0) {
        clusters[cluster_count].add(entry, count);
        clusters[0].add(entry, count);
      }
    }
  }
  cluster_count--;
 
  if (cluster_count == 0) {
    clusters[0].set_range(rangemin_, rangemax_);
  }
  do {
    new_cluster = false;
    new_mode = 0;
    for (entry = 0; entry <= rangemax_ - rangemin_; entry++) {
      count = buckets_[entry] - clusters[0].buckets_[entry];
      // remaining pile
      if (count > 0) { // any to handle
        min_dist = static_cast<float>(INT32_MAX);
        best_cluster = 0;
        for (cluster = 1; cluster <= cluster_count; cluster++) {
          dist = entry + rangemin_ - centres[cluster];
          // find distance
          if (dist < 0) {
            dist = -dist;
          }
          if (dist < min_dist) {
            min_dist = dist; // find least
            best_cluster = cluster;
          }
        }
        if (min_dist > upper // far enough for new
            && (best_cluster == 0 || entry + rangemin_ > centres[best_cluster] * multiple ||
                entry + rangemin_ < centres[best_cluster] / multiple)) {
          if (count > new_mode) {
            new_mode = count;
            new_centre = entry + rangemin_;
          }
        }
      }
    }
    // need new and room
    if (new_mode > 0 && cluster_count < max_clusters) {
      cluster_count++;
      new_cluster = true;
      if (!clusters[cluster_count].set_range(rangemin_, rangemax_)) {
        delete[] centres;
        return 0;
      }
      centres[cluster_count] = static_cast<float>(new_centre);
      clusters[cluster_count].add(new_centre, new_mode);
      clusters[0].add(new_centre, new_mode);
      for (entry = new_centre - 1; centres[cluster_count] - entry < lower && entry >= rangemin_ &&
                                   pile_count(entry) <= pile_count(entry + 1);
           entry--) {
        count = pile_count(entry) - clusters[0].pile_count(entry);
        if (count > 0) {
          clusters[cluster_count].add(entry, count);
          clusters[0].add(entry, count);
        }
      }
      for (entry = new_centre + 1; entry - centres[cluster_count] < lower && entry <= rangemax_ &&
                                   pile_count(entry) <= pile_count(entry - 1);
           entry++) {
        count = pile_count(entry) - clusters[0].pile_count(entry);
        if (count > 0) {
          clusters[cluster_count].add(entry, count);
          clusters[0].add(entry, count);
        }
      }
      centres[cluster_count] = static_cast<float>(clusters[cluster_count].ile(0.5));
    }
  } while (new_cluster && cluster_count < max_clusters);
  delete[] centres;
  return cluster_count;
}

get_total()

int32_t tesseract::STATS::get_total ( ) const

inline

Definition at line 85 of file statistc.h.

                            {
    return total_count_; // total of all piles
  }

ile()

double tesseract::STATS::ile

(

double

frac

)

const

Definition at line 172 of file statistc.cpp.

                                   {
  if (buckets_ == nullptr || total_count_ == 0) {
    return static_cast<double>(rangemin_);
  }
#if 0
  // TODO(rays) The existing code doesn't seem to be doing the right thing
  // with target a double but this substitute crashes the code that uses it.
  // Investigate and fix properly.
  int target = IntCastRounded(frac * total_count_);
  target = ClipToRange(target, 1, total_count_);
#else
  double target = frac * total_count_;
  target = ClipToRange(target, 1.0, static_cast<double>(total_count_));
#endif
  int sum = 0;
  int index = 0;
  for (index = 0; index <= rangemax_ - rangemin_ && sum < target; sum += buckets_[index++]) {
    ;
  }
  if (index > 0) {
    ASSERT_HOST(buckets_[index - 1] > 0);
    return rangemin_ + index - static_cast<double>(sum - target) / buckets_[index - 1];
  } else {
    return static_cast<double>(rangemin_);
  }
}

local_min()

bool tesseract::STATS::local_min

(

int32_t

x

)

const

Definition at line 268 of file statistc.cpp.

                                     {
  if (buckets_ == nullptr) {
    return false;
  }
  x = ClipToRange(x, rangemin_, rangemax_) - rangemin_;
  if (buckets_[x] == 0) {
    return true;
  }
  int32_t index; // table index
  for (index = x - 1; index >= 0 && buckets_[index] == buckets_[x]; --index) {
    ;
  }
  if (index >= 0 && buckets_[index] < buckets_[x]) {
    return false;
  }
  for (index = x + 1; index <= rangemax_ - rangemin_ && buckets_[index] == buckets_[x]; ++index) {
    ;
  }
  if (index <= rangemax_ - rangemin_ && buckets_[index] < buckets_[x]) {
    return false;
  } else {
    return true;
  }
}

max_bucket()

int32_t tesseract::STATS::max_bucket

(

)

const

Definition at line 221 of file statistc.cpp.

                                { // Find max
  if (buckets_ == nullptr || total_count_ == 0) {
    return rangemin_;
  }
  int32_t max;
  for (max = rangemax_ - rangemin_; max > 0 && buckets_[max] == 0; max--) {
    ;
  }
  return rangemin_ + max;
}

mean()

double tesseract::STATS::mean

(

)

const

Definition at line 132 of file statistc.cpp.

                         { // get mean of samples
  if (buckets_ == nullptr || total_count_ <= 0) {
    return static_cast<double>(rangemin_);
  }
  int64_t sum = 0;
  for (int index = rangemax_ - rangemin_; index >= 0; --index) {
    sum += static_cast<int64_t>(index) * buckets_[index];
  }
  return static_cast<double>(sum) / total_count_ + rangemin_;
}

median()

double tesseract::STATS::median

(

)

const

Definition at line 241 of file statistc.cpp.

                           { // get median
  if (buckets_ == nullptr) {
    return static_cast<double>(rangemin_);
  }
  double median = ile(0.5);
  int median_pile = static_cast<int>(floor(median));
  if ((total_count_ > 1) && (pile_count(median_pile) == 0)) {
    int32_t min_pile;
    int32_t max_pile;
    /* Find preceding non zero pile */
    for (min_pile = median_pile; pile_count(min_pile) == 0; min_pile--) {
      ;
    }
    /* Find following non zero pile */
    for (max_pile = median_pile; pile_count(max_pile) == 0; max_pile++) {
      ;
    }
    median = (min_pile + max_pile) / 2.0;
  }
  return median;
}

min_bucket()

int32_t tesseract::STATS::min_bucket

(

)

const

Definition at line 204 of file statistc.cpp.

                                { // Find min
  if (buckets_ == nullptr || total_count_ == 0) {
    return rangemin_;
  }
  int32_t min = 0;
  for (min = 0; (min <= rangemax_ - rangemin_) && (buckets_[min] == 0); min++) {
    ;
  }
  return rangemin_ + min;
}

mode()

int32_t tesseract::STATS::mode

(

)

const

Definition at line 112 of file statistc.cpp.

                          { // get mode of samples
  if (buckets_ == nullptr) {
    return rangemin_;
  }
  int32_t max = buckets_[0]; // max cell count
  int32_t maxindex = 0;      // index of max
  for (int index = rangemax_ - rangemin_; index > 0; --index) {
    if (buckets_[index] > max) {
      max = buckets_[index]; // find biggest
      maxindex = index;
    }
  }
  return maxindex + rangemin_; // index of biggest
}

pile_count()

int32_t tesseract::STATS::pile_count ( int32_t  value ) const

inline

Definition at line 72 of file statistc.h.

                                          {
    if (buckets_ == nullptr) {
      return 0;
    }
    if (value <= rangemin_) {
      return buckets_[0];
    }
    if (value >= rangemax_) {
      return buckets_[rangemax_ - rangemin_];
    }
    return buckets_[value - rangemin_];
  }

plot()

void tesseract::STATS::plot	(	ScrollView *	window,
		float	xorigin,
		float	yorigin,
		float	xscale,
		float	yscale,
		ScrollView::Color	colour
	)		const

Definition at line 596 of file statistc.cpp.

                                               { // colour to draw in
  if (buckets_ == nullptr) {
    return;
  }
  window->Pen(colour);
 
  for (int index = 0; index <= rangemax_ - rangemin_; index++) {
    window->Rectangle(xorigin + xscale * index, yorigin, xorigin + xscale * (index + 1),
                      yorigin + yscale * buckets_[index]);
  }
}

plotline()

void tesseract::STATS::plotline	(	ScrollView *	window,
		float	xorigin,
		float	yorigin,
		float	xscale,
		float	yscale,
		ScrollView::Color	colour
	)		const

Definition at line 621 of file statistc.cpp.

                                                   { // colour to draw in
  if (buckets_ == nullptr) {
    return;
  }
  window->Pen(colour);
  window->SetCursor(xorigin, yorigin + yscale * buckets_[0]);
  for (int index = 0; index <= rangemax_ - rangemin_; index++) {
    window->DrawTo(xorigin + xscale * index, yorigin + yscale * buckets_[index]);
  }
}

print()

void tesseract::STATS::print

(

)

const

Definition at line 547 of file statistc.cpp.

                        {
  if (buckets_ == nullptr) {
    return;
  }
  int32_t min = min_bucket() - rangemin_;
  int32_t max = max_bucket() - rangemin_;
 
  int num_printed = 0;
  for (int index = min; index <= max; index++) {
    if (buckets_[index] != 0) {
      tprintf("%4d:%-3d ", rangemin_ + index, buckets_[index]);
      if (++num_printed % 8 == 0) {
        tprintf("\n");
      }
    }
  }
  tprintf("\n");
  print_summary();
}

print_summary()

void tesseract::STATS::print_summary

(

)

const

Definition at line 572 of file statistc.cpp.

                                {
  if (buckets_ == nullptr) {
    return;
  }
  int32_t min = min_bucket();
  int32_t max = max_bucket();
  tprintf("Total count=%d\n", total_count_);
  tprintf("Min=%.2f Really=%d\n", ile(0.0), min);
  tprintf("Lower quartile=%.2f\n", ile(0.25));
  tprintf("Median=%.2f, ile(0.5)=%.2f\n", median(), ile(0.5));
  tprintf("Upper quartile=%.2f\n", ile(0.75));
  tprintf("Max=%.2f Really=%d\n", ile(1.0), max);
  tprintf("Range=%d\n", max + 1 - min);
  tprintf("Mean= %.2f\n", mean());
  tprintf("SD= %.2f\n", sd());
}

sd()

double tesseract::STATS::sd

(

)

const

Definition at line 148 of file statistc.cpp.

                       { // standard deviation
  if (buckets_ == nullptr || total_count_ <= 0) {
    return 0.0;
  }
  int64_t sum = 0;
  double sqsum = 0.0;
  for (int index = rangemax_ - rangemin_; index >= 0; --index) {
    sum += static_cast<int64_t>(index) * buckets_[index];
    sqsum += static_cast<double>(index) * index * buckets_[index];
  }
  double variance = static_cast<double>(sum) / total_count_;
  variance = sqsum / total_count_ - variance * variance;
  if (variance > 0.0) {
    return sqrt(variance);
  }
  return 0.0;
}

set_range()

bool tesseract::STATS::set_range	(	int32_t	min_bucket_value,
		int32_t	max_bucket_value
	)

Definition at line 59 of file statistc.cpp.

                                                                        {
  if (max_bucket_value < min_bucket_value) {
    return false;
  }
  if (rangemax_ - rangemin_ != max_bucket_value - min_bucket_value) {
    delete[] buckets_;
    buckets_ = new int32_t[1 + max_bucket_value - min_bucket_value];
  }
  rangemin_ = min_bucket_value; // setup
  rangemax_ = max_bucket_value;
  clear(); // zero it
  return true;
}

smooth()

void tesseract::STATS::smooth

(

int32_t

factor

)

Definition at line 301 of file statistc.cpp.

                                 {
  if (buckets_ == nullptr || factor < 2) {
    return;
  }
  STATS result(rangemin_, rangemax_);
  int entrycount = 1 + rangemax_ - rangemin_;
  for (int entry = 0; entry < entrycount; entry++) {
    // centre weight
    int count = buckets_[entry] * factor;
    for (int offset = 1; offset < factor; offset++) {
      if (entry - offset >= 0) {
        count += buckets_[entry - offset] * (factor - offset);
      }
      if (entry + offset < entrycount) {
        count += buckets_[entry + offset] * (factor - offset);
      }
    }
    result.add(entry + rangemin_, count);
  }
  total_count_ = result.total_count_;
  memcpy(buckets_, result.buckets_, entrycount * sizeof(buckets_[0]));
}

top_n_modes()

int tesseract::STATS::top_n_modes	(	int	max_modes,
		std::vector< KDPairInc< float, int > > &	modes
	)		const

Definition at line 480 of file statistc.cpp.

                                                                                   {
  if (max_modes <= 0) {
    return 0;
  }
  int src_count = 1 + rangemax_ - rangemin_;
  // Used copies the counts in buckets_ as they get used.
  STATS used(rangemin_, rangemax_);
  modes.clear();
  // Total count of the smallest peak found so far.
  int least_count = 1;
  // Mode that is used as a seed for each peak
  int max_count = 0;
  do {
    // Find an unused mode.
    max_count = 0;
    int max_index = 0;
    for (int src_index = 0; src_index < src_count; src_index++) {
      int pile_count = buckets_[src_index] - used.buckets_[src_index];
      if (pile_count > max_count) {
        max_count = pile_count;
        max_index = src_index;
      }
    }
    if (max_count > 0) {
      // Copy the bucket count to used so it doesn't get found again.
      used.buckets_[max_index] = max_count;
      // Get the entire peak.
      double total_value = max_index * max_count;
      int total_count = max_count;
      int prev_pile = max_count;
      for (int offset = 1; max_index + offset < src_count; ++offset) {
        if (!GatherPeak(max_index + offset, buckets_, used.buckets_, &prev_pile, &total_count,
                        &total_value)) {
          break;
        }
      }
      prev_pile = buckets_[max_index];
      for (int offset = 1; max_index - offset >= 0; ++offset) {
        if (!GatherPeak(max_index - offset, buckets_, used.buckets_, &prev_pile, &total_count,
                        &total_value)) {
          break;
        }
      }
      if (total_count > least_count || modes.size() < static_cast<size_t>(max_modes)) {
        // We definitely want this mode, so if we have enough discard the least.
        if (modes.size() == static_cast<size_t>(max_modes)) {
          modes.resize(max_modes - 1);
        }
        size_t target_index = 0;
        // Linear search for the target insertion point.
        while (target_index < modes.size() && modes[target_index].data() >= total_count) {
          ++target_index;
        }
        auto peak_mean = static_cast<float>(total_value / total_count + rangemin_);
        modes.insert(modes.begin() + target_index, KDPairInc<float, int>(peak_mean, total_count));
        least_count = modes.back().data();
      }
    }
  } while (max_count > 0);
  return modes.size();
}

---

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

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