Tesseract  3.02
Public Member Functions
DENORM Class Reference

#include <normalis.h>

List of all members.

Public Member Functions

 DENORM ()
 DENORM (float x, float scaling, ROW *src)
 DENORM (float x, float scaling, double line_m, double line_c, inT16 seg_count, DENORM_SEG *seg_pts, BOOL8 using_row, ROW *src)
 DENORM (const DENORM &)
DENORM & operator= (const DENORM &)
 ~DENORM ()
void SetupBLNormalize (const BLOCK *block, const ROW *row, float x_height, const TBOX &word_box, int num_segs, const DENORM_SEG *segs)
void SetupNormalization (const BLOCK *block, const ROW *row, const FCOORD *rotation, const DENORM *predecessor, const DENORM_SEG *segs, int num_segs, float x_origin, float y_origin, float x_scale, float y_scale, float final_xshift, float final_yshift)
void LocalNormTransform (const TPOINT &pt, TPOINT *transformed) const
void LocalNormTransform (const FCOORD &pt, FCOORD *transformed) const
void NormTransform (const TPOINT &pt, TPOINT *transformed) const
void NormTransform (const FCOORD &pt, FCOORD *transformed) const
void LocalDenormTransform (const TPOINT &pt, TPOINT *original) const
void LocalDenormTransform (const FCOORD &pt, FCOORD *original) const
void DenormTransform (const TPOINT &pt, TPOINT *original) const
void DenormTransform (const FCOORD &pt, FCOORD *original) const
void LocalNormBlob (TBLOB *blob) const
bool XHeightRange (int unichar_id, const UNICHARSET &unicharset, const TBOX &bbox, inT16 *min_xht, inT16 *max_xht) const
Pix * pix () const
void set_pix (Pix *pix)
bool inverse () const
void set_inverse (bool value)
const DENORM * RootDenorm () const
const DENORM * predecessor () const
float x_scale () const
float y_scale () const
const ROW * row () const
void set_row (ROW *row)
const BLOCK * block () const
void set_block (const BLOCK *block)

Detailed Description

Definition at line 59 of file normalis.h.

Constructor & Destructor Documentation

DENORM::DENORM ( )

Definition at line 33 of file normalis.cpp.

               {
  Init();
}
DENORM::DENORM ( float  x,
float  scaling,
ROW *  src 
)

Definition at line 38 of file normalis.cpp.

                                               {
  Init();
  x_origin_ = x;              // just copy
  y_origin_ = 0.0f;
  x_scale_ = y_scale_ = scaling;
  row_ = src;
}
DENORM::DENORM ( float  x,
float  scaling,
double  line_m,
double  line_c,
inT16  seg_count,
DENORM_SEG *  seg_pts,
BOOL8  using_row,
ROW *  src 
)

Definition at line 46 of file normalis.cpp.

                         {
  Init();
  x_origin_ = x;                  // just copy
  y_origin_ = line_c;
  ASSERT_HOST(line_m == 0.0);
  x_scale_ = y_scale_ = scaling;
  SetSegments(seg_pts, seg_count);
}
DENORM::DENORM ( const DENORM &  src)

Definition at line 63 of file normalis.cpp.

                                {
  num_segs_ = 0;
  segs_ = NULL;
  rotation_ = NULL;
  *this = src;
}
DENORM::~DENORM ( )

Definition at line 92 of file normalis.cpp.

                {
  Clear();
}

Member Function Documentation

const BLOCK* DENORM::block ( ) const [inline]

Definition at line 276 of file normalis.h.

                             {
    return block_;
  }
void DENORM::DenormTransform ( const TPOINT &  pt,
TPOINT *  original 
) const

Definition at line 233 of file normalis.cpp.

                                                                     {
  FCOORD src_pt(pt.x, pt.y);
  FCOORD float_result;
  DenormTransform(src_pt, &float_result);
  original->x = IntCastRounded(float_result.x());
  original->y = IntCastRounded(float_result.y());
}
void DENORM::DenormTransform ( const FCOORD &  pt,
FCOORD *  original 
) const

Definition at line 240 of file normalis.cpp.

                                                                     {
  LocalDenormTransform(pt, original);
  if (predecessor_ != NULL) {
    predecessor_->DenormTransform(*original, original);
  } else if (block_ != NULL) {
    original->rotate(block_->re_rotation());
  }
}
bool DENORM::inverse ( ) const [inline]

Definition at line 249 of file normalis.h.

                       {
    return inverse_;
  }
void DENORM::LocalDenormTransform ( const TPOINT &  pt,
TPOINT *  original 
) const

Definition at line 210 of file normalis.cpp.

                                                                          {
  FCOORD src_pt(pt.x, pt.y);
  FCOORD float_result;
  LocalDenormTransform(src_pt, &float_result);
  original->x = IntCastRounded(float_result.x());
  original->y = IntCastRounded(float_result.y());
}
void DENORM::LocalDenormTransform ( const FCOORD &  pt,
FCOORD *  original 
) const

Definition at line 217 of file normalis.cpp.

                                                                          {
  FCOORD rotated(pt.x() - final_xshift_, pt.y() - final_yshift_);
  if (rotation_ != NULL) {
    FCOORD inverse_rotation(rotation_->x(), -rotation_->y());
    rotated.rotate(inverse_rotation);
  }
  original->set_x(rotated.x() / x_scale_ + x_origin_);
  float y_scale = y_scale_;
  if (num_segs_ > 0)
    y_scale = YScaleAtOrigX(original->x());
  original->set_y(rotated.y() / y_scale + YOriginAtOrigX(original->x()));
}
void DENORM::LocalNormBlob ( TBLOB *  blob) const

Definition at line 251 of file normalis.cpp.

                                            {
  TBOX blob_box = blob->bounding_box();
  float x_center = (blob_box.left() + blob_box.right()) / 2.0f;
  ICOORD translation(-IntCastRounded(x_origin_),
                     -IntCastRounded(YOriginAtOrigX(x_center)));
  blob->Move(translation);
  // Note that the old way of scaling only allowed for a single
  // scale factor.
  float scale = YScaleAtOrigX(x_center);
  if (scale != 1.0f)
    blob->Scale(scale);
  if (rotation_ != NULL)
    blob->Rotate(*rotation_);
  translation.set_x(IntCastRounded(final_xshift_));
  translation.set_y(IntCastRounded(final_yshift_));
  blob->Move(translation);
}
void DENORM::LocalNormTransform ( const TPOINT &  pt,
TPOINT *  transformed 
) const

Definition at line 170 of file normalis.cpp.

                                                                           {
  FCOORD src_pt(pt.x, pt.y);
  FCOORD float_result;
  LocalNormTransform(src_pt, &float_result);
  transformed->x = IntCastRounded(float_result.x());
  transformed->y = IntCastRounded(float_result.y());
}
void DENORM::LocalNormTransform ( const FCOORD &  pt,
FCOORD *  transformed 
) const

Definition at line 177 of file normalis.cpp.

                                                                           {
  FCOORD translated(pt.x() - x_origin_, pt.y() - YOriginAtOrigX(pt.x()));
  translated.set_x(translated.x() * x_scale_);
  translated.set_y(translated.y() * YScaleAtOrigX(pt.x()));
  if (rotation_ != NULL)
    translated.rotate(*rotation_);
  transformed->set_x(translated.x() + final_xshift_);
  transformed->set_y(translated.y() + final_yshift_);
}
void DENORM::NormTransform ( const TPOINT &  pt,
TPOINT *  transformed 
) const

Definition at line 190 of file normalis.cpp.

                                                                      {
  FCOORD src_pt(pt.x, pt.y);
  FCOORD float_result;
  NormTransform(src_pt, &float_result);
  transformed->x = IntCastRounded(float_result.x());
  transformed->y = IntCastRounded(float_result.y());
}
void DENORM::NormTransform ( const FCOORD &  pt,
FCOORD *  transformed 
) const

Definition at line 197 of file normalis.cpp.

                                                                      {
  FCOORD src_pt(pt);
  if (predecessor_ != NULL) {
    predecessor_->NormTransform(pt, &src_pt);
  } else if (block_ != NULL) {
    FCOORD fwd_rotation(block_->re_rotation().x(), -block_->re_rotation().y());
    src_pt.rotate(fwd_rotation);
  }
  LocalNormTransform(src_pt, transformed);
}
DENORM & DENORM::operator= ( const DENORM &  src)

Definition at line 71 of file normalis.cpp.

                                             {
  Clear();
  inverse_ = src.inverse_;
  pix_ = src.pix_;
  block_ = src.block_;
  row_ = src.row_;
  if (src.rotation_ == NULL)
    rotation_ = NULL;
  else
    rotation_ = new FCOORD(*src.rotation_);
  predecessor_ = src.predecessor_;
  SetSegments(src.segs_, src.num_segs_);
  x_origin_ = src.x_origin_;
  y_origin_ = src.y_origin_;
  x_scale_ = src.x_scale_;
  y_scale_ = src.y_scale_;
  final_xshift_ = src.final_xshift_;
  final_yshift_ = src.final_yshift_;
  return *this;
}
Pix* DENORM::pix ( ) const [inline]

Definition at line 243 of file normalis.h.

                   {
    return pix_;
  }
const DENORM* DENORM::predecessor ( ) const [inline]

Definition at line 260 of file normalis.h.

                                    {
    return predecessor_;
  }
const DENORM* DENORM::RootDenorm ( ) const [inline]

Definition at line 255 of file normalis.h.

                                   {
    if (predecessor_ != NULL)
      return predecessor_->RootDenorm();
    return this;
  }
const ROW* DENORM::row ( ) const [inline]

Definition at line 270 of file normalis.h.

                         {
    return row_;
  }
void DENORM::set_block ( const BLOCK *  block) [inline]

Definition at line 279 of file normalis.h.

                                     {
    block_ = block;
  }
void DENORM::set_inverse ( bool  value) [inline]

Definition at line 252 of file normalis.h.

                               {
    inverse_ = value;
  }
void DENORM::set_pix ( Pix *  pix) [inline]

Definition at line 246 of file normalis.h.

                         {
    pix_ = pix;
  }
void DENORM::set_row ( ROW *  row) [inline]

Definition at line 273 of file normalis.h.

                         {
    row_ = row;
  }
void DENORM::SetupBLNormalize ( const BLOCK *  block,
const ROW *  row,
float  x_height,
const TBOX &  word_box,
int  num_segs,
const DENORM_SEG *  segs 
)

Definition at line 99 of file normalis.cpp.

                                                                    {
  float scale = kBlnXHeight / x_height;
  float x_origin = (word_box.left() + word_box.right()) / 2.0f;
  float y_origin = 0.0f;
  if (num_segs == 0 && row == NULL) {
    y_origin = word_box.bottom();
  }
  SetupNormalization(block, row, NULL, NULL, segs, num_segs,
                     x_origin, y_origin, scale, scale,
                     0.0f, static_cast<float>(kBlnBaselineOffset));
}
void DENORM::SetupNormalization ( const BLOCK *  block,
const ROW *  row,
const FCOORD *  rotation,
const DENORM *  predecessor,
const DENORM_SEG *  segs,
int  num_segs,
float  x_origin,
float  y_origin,
float  x_scale,
float  y_scale,
float  final_xshift,
float  final_yshift 
)

Definition at line 143 of file normalis.cpp.

                                                                        {
  Clear();
  block_ = block;
  row_ = row;
  if (rotation == NULL)
    rotation_ = NULL;
  else
    rotation_ = new FCOORD(*rotation);
  predecessor_ = predecessor;
  SetSegments(segs, num_segs);
  x_origin_ = x_origin;
  y_origin_ = y_origin;
  x_scale_ = x_scale;
  y_scale_ = y_scale;
  final_xshift_ = final_xshift;
  final_yshift_ = final_yshift;
}
float DENORM::x_scale ( ) const [inline]

Definition at line 264 of file normalis.h.

                        {
    return x_scale_;
  }
bool DENORM::XHeightRange ( int  unichar_id,
const UNICHARSET &  unicharset,
const TBOX &  bbox,
inT16 *  min_xht,
inT16 *  max_xht 
) const

Definition at line 275 of file normalis.cpp.

                                                                {
  // Clip the top and bottom to the limit of normalized feature space.
  int top = ClipToRange<int>(bbox.top(), 0, kBlnCellHeight - 1);
  int bottom = ClipToRange<int>(bbox.bottom(), 0, kBlnCellHeight - 1);
  // A tolerance of yscale corresponds to 1 pixel in the image.
  double tolerance = y_scale();
  int min_bottom, max_bottom, min_top, max_top;
  unicharset.get_top_bottom(unichar_id, &min_bottom, &max_bottom,
                            &min_top, &max_top);
  // Default returns indicate a mis-fit.
  *min_xht = 0;
  *max_xht = 0;
  // Chars with a misfitting bottom might be sub/superscript/dropcap, or might
  // just be wrongly classified. Return an empty range so they have to be
  // good to be considered.
  if (bottom < min_bottom - tolerance || bottom > max_bottom + tolerance) {
    return false;
  }
  // To help very high cap/xheight ratio fonts accept the correct x-height,
  // and to allow the large caps in small caps to accept the xheight of the
  // small caps, add kBlnBaselineOffset to chars with a maximum max.
  if (max_top == kBlnCellHeight - 1)
    max_top += kBlnBaselineOffset;
  int height = top - kBlnBaselineOffset;
  double min_height = min_top - kBlnBaselineOffset - tolerance;
  double max_height = max_top - kBlnBaselineOffset + tolerance;
  if (min_height <= 0.0) {
    if (height <= 0 || max_height > 0)
      *max_xht = MAX_INT16;  // Anything will do.
  } else if (height > 0) {
    int result = IntCastRounded(height * kBlnXHeight / y_scale() / min_height);
    *max_xht = static_cast<inT16>(ClipToRange(result, 0, MAX_INT16));
  }
  if (max_height > 0.0 && height > 0) {
    int result = IntCastRounded(height * kBlnXHeight / y_scale() / max_height);
    *min_xht = static_cast<inT16>(ClipToRange(result, 0, MAX_INT16));
  }
  return true;
}
float DENORM::y_scale ( ) const [inline]

Definition at line 267 of file normalis.h.

                        {
    return y_scale_;
  }
The documentation for this class was generated from the following files: