mfoutline.cpp File Reference

#include "clusttool.h"
#include "emalloc.h"
#include "mfoutline.h"
#include "blobs.h"
#include "mfx.h"
#include "params.h"
#include "classify.h"
#include <cmath>
#include <cstdio>

Go to the source code of this file.

Namespaces
	tesseract

Functions
LIST	ConvertBlob (TBLOB *blob)
MFOUTLINE	ConvertOutline (TESSLINE *outline)
LIST	ConvertOutlines (TESSLINE *outline, LIST mf_outlines, OUTLINETYPE outline_type)
void	FindDirectionChanges (MFOUTLINE Outline, float MinSlope, float MaxSlope)
void	FreeMFOutline (void *arg)
void	FreeOutlines (LIST Outlines)
void	MarkDirectionChanges (MFOUTLINE Outline)
MFEDGEPT *	NewEdgePoint ()
MFOUTLINE	NextExtremity (MFOUTLINE EdgePoint)
void	NormalizeOutline (MFOUTLINE Outline, float XOrigin)
void	ChangeDirection (MFOUTLINE Start, MFOUTLINE End, DIRECTION Direction)
void	CharNormalizeOutline (MFOUTLINE Outline, const DENORM &cn_denorm)
void	ComputeDirection (MFEDGEPT *Start, MFEDGEPT *Finish, float MinSlope, float MaxSlope)
MFOUTLINE	NextDirectionChange (MFOUTLINE EdgePoint)

Function Documentation

ChangeDirection()

void ChangeDirection	(	MFOUTLINE	Start,
		MFOUTLINE	End,
		DIRECTION	Direction
	)

Change the direction of every vector in the specified outline segment to Direction. The segment to be changed starts at Start and ends at End. Note that the previous direction of End must also be changed to reflect the change in direction of the point before it.

Parameters

Start,End	defines segment of outline to be modified
Direction	new direction to assign to segment

Returns

none

Note

Globals: none

Definition at line 320 of file mfoutline.cpp.

                                                                          {
  MFOUTLINE Current;

  for (Current = Start; Current != End; Current = NextPointAfter (Current))
    PointAt (Current)->Direction = Direction;

  PointAt (End)->PreviousDirection = Direction;

}                                /* ChangeDirection */

CharNormalizeOutline()

void CharNormalizeOutline	(	MFOUTLINE	Outline,
		const DENORM &	cn_denorm
	)

This routine normalizes each point in Outline by translating it to the specified center and scaling it anisotropically according to the given scale factors.

Parameters

Outline	outline to be character normalized
cn_denorm

Returns

none

Note

Globals: none

Definition at line 339 of file mfoutline.cpp.

                                                                      {
  MFOUTLINE First, Current;
  MFEDGEPT *CurrentPoint;

  if (Outline == NIL_LIST)
    return;

  First = Outline;
  Current = First;
  do {
    CurrentPoint = PointAt(Current);
    FCOORD pos(CurrentPoint->Point.x, CurrentPoint->Point.y);
    cn_denorm.LocalNormTransform(pos, &pos);
    CurrentPoint->Point.x = (pos.x() - UINT8_MAX / 2) * MF_SCALE_FACTOR;
    CurrentPoint->Point.y = (pos.y() - UINT8_MAX / 2) * MF_SCALE_FACTOR;

    Current = NextPointAfter(Current);
  }
  while (Current != First);

}                                /* CharNormalizeOutline */

ComputeDirection()

void ComputeDirection	(	MFEDGEPT *	Start,
		MFEDGEPT *	Finish,
		float	MinSlope,
		float	MaxSlope
	)

This routine computes the slope from Start to Finish and and then computes the approximate direction of the line segment from Start to Finish. The direction is quantized into 8 buckets: N, S, E, W, NE, NW, SE, SW Both the slope and the direction are then stored into the appropriate fields of the Start edge point. The direction is also stored into the PreviousDirection field of the Finish edge point.

Parameters

Start	starting point to compute direction from
Finish	finishing point to compute direction to
MinSlope	slope below which lines are horizontal
MaxSlope	slope above which lines are vertical

Returns

none

Note

Globals: none

Definition at line 378 of file mfoutline.cpp.

                                      {
  FVECTOR Delta;

  Delta.x = Finish->Point.x - Start->Point.x;
  Delta.y = Finish->Point.y - Start->Point.y;
  if (Delta.x == 0) {
    if (Delta.y < 0) {
      Start->Slope = -FLT_MAX;
      Start->Direction = south;
    } else {
      Start->Slope = FLT_MAX;
      Start->Direction = north;
    }
  } else {
    Start->Slope = Delta.y / Delta.x;
    if (Delta.x > 0) {
      if (Delta.y > 0) {
        if (Start->Slope > MinSlope) {
          if (Start->Slope < MaxSlope) {
            Start->Direction = northeast;
          } else {
            Start->Direction = north;
          }
        } else {
          Start->Direction = east;
        }
      }
      else if (Start->Slope < -MinSlope) {
        if (Start->Slope > -MaxSlope) {
          Start->Direction = southeast;
        } else {
          Start->Direction = south;
        }
      } else {
        Start->Direction = east;
      }
    } else if (Delta.y > 0) {
      if (Start->Slope < -MinSlope) {
        if (Start->Slope > -MaxSlope) {
          Start->Direction = northwest;
        } else {
          Start->Direction = north;
        }
      } else {
        Start->Direction = west;
      }
    } else if (Start->Slope > MinSlope) {
      if (Start->Slope < MaxSlope) {
        Start->Direction = southwest;
      } else {
        Start->Direction = south;
      }
    } else {
      Start->Direction = west;
    }
  }
  Finish->PreviousDirection = Start->Direction;
}

ConvertBlob()

LIST ConvertBlob

(

TBLOB *

blob

)

Convert a blob into a list of MFOUTLINEs (float-based microfeature format).

Definition at line 39 of file mfoutline.cpp.

                              {
  LIST outlines = NIL_LIST;
  return (blob == nullptr)
      ? NIL_LIST
      : ConvertOutlines(blob->outlines, outlines, outer);
}

ConvertOutline()

MFOUTLINE ConvertOutline

(

TESSLINE *

outline

)

Convert a TESSLINE into the float-based MFOUTLINE micro-feature format.

Definition at line 49 of file mfoutline.cpp.

                                            {
  MFEDGEPT *NewPoint;
  MFOUTLINE MFOutline = NIL_LIST;
  EDGEPT *EdgePoint;
  EDGEPT *StartPoint;
  EDGEPT *NextPoint;

  if (outline == nullptr || outline->loop == nullptr)
    return MFOutline;

  StartPoint = outline->loop;
  EdgePoint = StartPoint;
  do {
    NextPoint = EdgePoint->next;

    /* filter out duplicate points */
    if (EdgePoint->pos.x != NextPoint->pos.x ||
        EdgePoint->pos.y != NextPoint->pos.y) {
      NewPoint = NewEdgePoint();
      ClearMark(NewPoint);
      NewPoint->Hidden = EdgePoint->IsHidden();
      NewPoint->Point.x = EdgePoint->pos.x;
      NewPoint->Point.y = EdgePoint->pos.y;
      MFOutline = push(MFOutline, NewPoint);
    }
    EdgePoint = NextPoint;
  } while (EdgePoint != StartPoint);

  if (MFOutline != nullptr)
    MakeOutlineCircular(MFOutline);
  return MFOutline;
}

ConvertOutlines()

LIST ConvertOutlines	(	TESSLINE *	outline,
		LIST	mf_outlines,
		OUTLINETYPE	outline_type
	)

Convert a tree of outlines to a list of MFOUTLINEs (lists of MFEDGEPTs).

Parameters

outline	first outline to be converted
mf_outlines	list to add converted outlines to
outline_type	are the outlines outer or holes?

Definition at line 91 of file mfoutline.cpp.

                                               {
  MFOUTLINE mf_outline;

  while (outline != nullptr) {
    mf_outline = ConvertOutline(outline);
    if (mf_outline != nullptr)
      mf_outlines = push(mf_outlines, mf_outline);
    outline = outline->next;
  }
  return mf_outlines;
}

FindDirectionChanges()

void FindDirectionChanges	(	MFOUTLINE	Outline,
		float	MinSlope,
		float	MaxSlope
	)

This routine searches through the specified outline, computes a slope for each vector in the outline, and marks each vector as having one of the following directions: N, S, E, W, NE, NW, SE, SW This information is then stored in the outline and the outline is returned.

Parameters

Outline	micro-feature outline to analyze
MinSlope	controls "snapping" of segments to horizontal
MaxSlope	controls "snapping" of segments to vertical

Returns

none

Definition at line 118 of file mfoutline.cpp.

                                          {
  MFEDGEPT *Current;
  MFEDGEPT *Last;
  MFOUTLINE EdgePoint;

  if (DegenerateOutline (Outline))
    return;

  Last = PointAt (Outline);
  Outline = NextPointAfter (Outline);
  EdgePoint = Outline;
  do {
    Current = PointAt (EdgePoint);
    ComputeDirection(Last, Current, MinSlope, MaxSlope);

    Last = Current;
    EdgePoint = NextPointAfter (EdgePoint);
  }
  while (EdgePoint != Outline);

}                                /* FindDirectionChanges */

FreeMFOutline()

void FreeMFOutline

(

void *

arg

)

This routine deallocates all of the memory consumed by a micro-feature outline.

Parameters

arg	micro-feature outline to be freed

Returns

none

Definition at line 150 of file mfoutline.cpp.

                              {  //MFOUTLINE                             Outline)
  MFOUTLINE Start;
  MFOUTLINE Outline = (MFOUTLINE) arg;

  /* break the circular outline so we can use std. techniques to deallocate */
  Start = list_rest (Outline);
  set_rest(Outline, NIL_LIST);
  while (Start != nullptr) {
    free(first_node(Start));
    Start = pop (Start);
  }

}                                /* FreeMFOutline */

FreeOutlines()

void FreeOutlines

(

LIST

Outlines

)

Release all memory consumed by the specified list of outlines.

Parameters

Outlines

list of mf-outlines to be freed

Returns

none

Definition at line 172 of file mfoutline.cpp.

                                 {
  destroy_nodes(Outlines, FreeMFOutline);
}                                /* FreeOutlines */

MarkDirectionChanges()

void MarkDirectionChanges

(

MFOUTLINE

Outline

)

This routine searches through the specified outline and finds the points at which the outline changes direction. These points are then marked as "extremities". This routine is used as an alternative to FindExtremities(). It forces the endpoints of the microfeatures to be at the direction changes rather than at the midpoint between direction changes.

Parameters

Outline

micro-feature outline to analyze

Returns

none

Note

Globals: none

Definition at line 190 of file mfoutline.cpp.

                                             {
  MFOUTLINE Current;
  MFOUTLINE Last;
  MFOUTLINE First;

  if (DegenerateOutline (Outline))
    return;

  First = NextDirectionChange (Outline);
  Last = First;
  do {
    Current = NextDirectionChange (Last);
    MarkPoint (PointAt (Current));
    Last = Current;
  }
  while (Last != First);

}                                /* MarkDirectionChanges */

NewEdgePoint()

MFEDGEPT* NewEdgePoint

(

)

Return a new edge point for a micro-feature outline.

Definition at line 212 of file mfoutline.cpp.

                         {
  return reinterpret_cast<MFEDGEPT *>(malloc(sizeof(MFEDGEPT)));
}

NextDirectionChange()

MFOUTLINE NextDirectionChange

(

MFOUTLINE

EdgePoint

)

This routine returns the next point in the micro-feature outline that has a direction different than EdgePoint. The routine assumes that the outline being searched is not a degenerate outline (i.e. it must have 2 or more edge points).

Parameters

EdgePoint

start search from this point

Returns

Point of next direction change in micro-feature outline.

Note

Globals: none

Definition at line 449 of file mfoutline.cpp.

                                                   {
  DIRECTION InitialDirection;

  InitialDirection = PointAt (EdgePoint)->Direction;

  MFOUTLINE next_pt = nullptr;
  do {
    EdgePoint = NextPointAfter(EdgePoint);
    next_pt = NextPointAfter(EdgePoint);
  } while (PointAt(EdgePoint)->Direction == InitialDirection &&
           !PointAt(EdgePoint)->Hidden &&
           next_pt != nullptr && !PointAt(next_pt)->Hidden);

  return (EdgePoint);
}

NextExtremity()

MFOUTLINE NextExtremity

(

MFOUTLINE

EdgePoint

)

This routine returns the next point in the micro-feature outline that is an extremity. The search starts after EdgePoint. The routine assumes that the outline being searched is not a degenerate outline (i.e. it must have 2 or more edge points).

Parameters

EdgePoint

start search from this point

Returns

Next extremity in the outline after EdgePoint.

Note

Globals: none

Definition at line 227 of file mfoutline.cpp.

                                             {
  EdgePoint = NextPointAfter(EdgePoint);
  while (!PointAt(EdgePoint)->ExtremityMark)
    EdgePoint = NextPointAfter(EdgePoint);

  return (EdgePoint);

}                                /* NextExtremity */

NormalizeOutline()

void NormalizeOutline	(	MFOUTLINE	Outline,
		float	XOrigin
	)

This routine normalizes the coordinates of the specified outline so that the outline is deskewed down to the baseline, translated so that x=0 is at XOrigin, and scaled so that the height of a character cell from descender to ascender is 1. Of this height, 0.25 is for the descender, 0.25 for the ascender, and 0.5 for the x-height. The y coordinate of the baseline is 0.

Parameters

Outline	outline to be normalized
XOrigin	x-origin of text

Returns

none

Note

Globals: none

Definition at line 251 of file mfoutline.cpp.

                                     {
  if (Outline == NIL_LIST)
    return;

  MFOUTLINE EdgePoint = Outline;
  do {
    MFEDGEPT *Current = PointAt(EdgePoint);
    Current->Point.y = MF_SCALE_FACTOR *
        (Current->Point.y - kBlnBaselineOffset);
    Current->Point.x = MF_SCALE_FACTOR * (Current->Point.x - XOrigin);
    EdgePoint = NextPointAfter(EdgePoint);
  } while (EdgePoint != Outline);
}                                /* NormalizeOutline */