tesseract::FeatureChebyshev Class Reference

#include <feature_chebyshev.h>

Inheritance diagram for tesseract::FeatureChebyshev:

Public Member Functions
	FeatureChebyshev (TuningParams *params)
virtual	~FeatureChebyshev ()
virtual CharSamp *	ComputeFeatureBitmap (CharSamp *samp)
virtual bool	ComputeFeatures (CharSamp *samp, float *features)
virtual int	FeatureCnt ()
Public Member Functions inherited from tesseract::FeatureBase
	FeatureBase (TuningParams *params)
virtual	~FeatureBase ()

Protected Member Functions
void	ChebyshevCoefficients (const vector< float > &input, int coeff_cnt, float *coeff)
bool	ComputeChebyshevCoefficients (CharSamp *samp, float *features)

Static Protected Attributes
static const int	kChebychevCoefficientCnt = 40

Additional Inherited Members
Protected Attributes inherited from tesseract::FeatureBase
TuningParams *	params_

Detailed Description

Definition at line 33 of file feature_chebyshev.h.

Constructor & Destructor Documentation

FeatureChebyshev()

tesseract::FeatureChebyshev::FeatureChebyshev ( TuningParams *  params )

explicit

Definition at line 34 of file feature_chebyshev.cpp.

    : FeatureBase(params) {
}

~FeatureChebyshev()

tesseract::FeatureChebyshev::~FeatureChebyshev ( )

virtual

Definition at line 38 of file feature_chebyshev.cpp.

                                    {
}

Member Function Documentation

ChebyshevCoefficients()

void tesseract::FeatureChebyshev::ChebyshevCoefficients ( const vector< float > &  input, int  coeff_cnt, float *  coeff  )

protected

Definition at line 48 of file feature_chebyshev.cpp.

                                                                          {
  // re-sample function
  int input_range = (input.size() - 1);
  vector<float> resamp(coeff_cnt);
  for (int samp_idx = 0; samp_idx < coeff_cnt; samp_idx++) {
    // compute sampling position
    float samp_pos = input_range *
                     (1 + cos(M_PI * (samp_idx + 0.5) / coeff_cnt)) / 2;
    // interpolate
    int samp_start = static_cast<int>(samp_pos);
    int samp_end = static_cast<int>(samp_pos + 0.5);
    float func_delta = input[samp_end] - input[samp_start];
    resamp[samp_idx] = input[samp_start] +
                       ((samp_pos - samp_start) * func_delta);
  }
  // compute the coefficients
  float normalizer = 2.0 / coeff_cnt;
  for (int coeff_idx = 0; coeff_idx < coeff_cnt; coeff_idx++, coeff++) {
    double sum = 0.0;
    for (int samp_idx = 0; samp_idx < coeff_cnt; samp_idx++) {
        sum += resamp[samp_idx] * cos(M_PI * coeff_idx * (samp_idx + 0.5) /
                                      coeff_cnt);
    }
    (*coeff) = (normalizer * sum);
  }
}

ComputeChebyshevCoefficients()

bool tesseract::FeatureChebyshev::ComputeChebyshevCoefficients ( CharSamp *  samp, float *  features  )

protected

Definition at line 82 of file feature_chebyshev.cpp.

                                                                     {
  if (char_samp->NormBottom() <= 0) {
    return false;
  }
  unsigned char *raw_data = char_samp->RawData();
  int stride = char_samp->Stride();
  // compute the height of the word
  int word_hgt = (255 * (char_samp->Top() + char_samp->Height()) /
                  char_samp->NormBottom());
  // compute left & right profiles
  vector<float> left_profile(word_hgt, 0.0);
  vector<float> right_profile(word_hgt, 0.0);
  unsigned char *line_data = raw_data;
  for (int y = 0; y < char_samp->Height(); y++, line_data += stride) {
    int min_x = char_samp->Width();
    int max_x = -1;
    for (int x = 0; x < char_samp->Width(); x++) {
      if (line_data[x] == 0) {
        UpdateRange(x, &min_x, &max_x);
      }
    }
    left_profile[char_samp->Top() + y] =
        1.0 * (min_x == char_samp->Width() ? 0 : (min_x + 1)) /
        char_samp->Width();
    right_profile[char_samp->Top() + y] =
        1.0 * (max_x == -1 ? 0 : char_samp->Width() - max_x) /
        char_samp->Width();
  }

  // compute top and bottom profiles
  vector<float> top_profile(char_samp->Width(), 0);
  vector<float> bottom_profile(char_samp->Width(), 0);
  for (int x = 0; x < char_samp->Width(); x++) {
    int min_y = word_hgt;
    int max_y = -1;
    line_data = raw_data;
    for (int y = 0; y < char_samp->Height(); y++, line_data += stride) {
      if (line_data[x] == 0) {
        UpdateRange(y + char_samp->Top(), &min_y, &max_y);
      }
    }
    top_profile[x] = 1.0 * (min_y == word_hgt ? 0 : (min_y + 1)) / word_hgt;
    bottom_profile[x] = 1.0 * (max_y == -1 ? 0 : (word_hgt - max_y)) / word_hgt;
  }

  // compute the chebyshev coefficients of each profile
  ChebyshevCoefficients(left_profile, kChebychevCoefficientCnt, features);
  ChebyshevCoefficients(top_profile, kChebychevCoefficientCnt,
                        features + kChebychevCoefficientCnt);
  ChebyshevCoefficients(right_profile, kChebychevCoefficientCnt,
                        features + (2 * kChebychevCoefficientCnt));
  ChebyshevCoefficients(bottom_profile, kChebychevCoefficientCnt,
                        features + (3 * kChebychevCoefficientCnt));
  return true;
}

ComputeFeatureBitmap()

CharSamp * tesseract::FeatureChebyshev::ComputeFeatureBitmap ( CharSamp *  samp )

virtual

Implements tesseract::FeatureBase.

Definition at line 43 of file feature_chebyshev.cpp.

                                                                    {
  return char_samp;
}

ComputeFeatures()

bool tesseract::FeatureChebyshev::ComputeFeatures ( CharSamp *  samp, float *  features  )

virtual

Implements tesseract::FeatureBase.

Definition at line 77 of file feature_chebyshev.cpp.

                                                                           {
  return ComputeChebyshevCoefficients(char_samp, features);
}

FeatureCnt()

virtual int tesseract::FeatureChebyshev::FeatureCnt ( )

inlinevirtual

Implements tesseract::FeatureBase.

Definition at line 43 of file feature_chebyshev.h.

                           {
    return (4 * kChebychevCoefficientCnt);
  }

Member Data Documentation

kChebychevCoefficientCnt

const int tesseract::FeatureChebyshev::kChebychevCoefficientCnt = 40

staticprotected

Definition at line 48 of file feature_chebyshev.h.

---

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

• cube/feature_chebyshev.h
• cube/feature_chebyshev.cpp