#include "blobs.h"
#include "host.h"
#include "oldlist.h"
#include "fpoint.h"
#include "params.h"

Classes
struct	MFEDGEPT
Defines
#define	NORMAL_X_HEIGHT (0.5)
#define	NORMAL_BASELINE (0.0)
#define	AverageOf(A, B) (((A) + (B)) / 2)
#define	MF_SCALE_FACTOR (NORMAL_X_HEIGHT / kBlnXHeight)
#define	DegenerateOutline(O) (((O) == NIL_LIST) \|\| ((O) == list_rest(O)))
#define	PointAt(O) ((MFEDGEPT *) first_node (O))
#define	NextPointAfter(E) (list_rest (E))
#define	MakeOutlineCircular(O) (set_rest (last (O), (O)))
#define	ClearMark(P) ((P)->ExtremityMark = FALSE)
#define	MarkPoint(P) ((P)->ExtremityMark = TRUE)
Typedefs
typedef LIST	MFOUTLINE
Enumerations
enum	DIRECTION { north, south, east, west, northeast, northwest, southeast, southwest }
enum	OUTLINETYPE { outer, hole }
enum	NORM_METHOD { baseline, character }
Functions
void	ComputeBlobCenter (TBLOB Blob, TPOINT BlobCenter)
LIST	ConvertBlob (TBLOB *Blob)
MFOUTLINE	ConvertOutline (TESSLINE *Outline)
LIST	ConvertOutlines (TESSLINE *Outline, LIST ConvertedOutlines, OUTLINETYPE OutlineType)
void	FilterEdgeNoise (MFOUTLINE Outline, FLOAT32 NoiseSegmentLength)
void	FindDirectionChanges (MFOUTLINE Outline, FLOAT32 MinSlope, FLOAT32 MaxSlope)
void	FreeMFOutline (void *agr)
void	FreeOutlines (LIST Outlines)
void	MarkDirectionChanges (MFOUTLINE Outline)
MFEDGEPT *	NewEdgePoint ()
MFOUTLINE	NextExtremity (MFOUTLINE EdgePoint)
void	NormalizeOutline (MFOUTLINE Outline, FLOAT32 XOrigin)
void	ChangeDirection (MFOUTLINE Start, MFOUTLINE End, DIRECTION Direction)
void	CharNormalizeOutline (MFOUTLINE Outline, const DENORM &cn_denorm)
void	ComputeDirection (MFEDGEPT Start, MFEDGEPT Finish, FLOAT32 MinSlope, FLOAT32 MaxSlope)
MFOUTLINE	NextDirectionChange (MFOUTLINE EdgePoint)

Define Documentation

#define AverageOf	(	A,
		B
	)	(((A) + (B)) / 2)

---------------------------------------------------------------------------- Macros ----------------------------------------------------------------------------

Definition at line 60 of file mfoutline.h.

#define ClearMark ( P ) ((P)->ExtremityMark = FALSE)

Definition at line 72 of file mfoutline.h.

#define DegenerateOutline ( O ) (((O) == NIL_LIST) || ((O) == list_rest(O)))

Definition at line 66 of file mfoutline.h.

#define MakeOutlineCircular ( O ) (set_rest (last (O), (O)))

Definition at line 69 of file mfoutline.h.

#define MarkPoint ( P ) ((P)->ExtremityMark = TRUE)

Definition at line 73 of file mfoutline.h.

#define MF_SCALE_FACTOR (NORMAL_X_HEIGHT / kBlnXHeight)

Definition at line 63 of file mfoutline.h.

#define NextPointAfter ( E ) (list_rest (E))

Definition at line 68 of file mfoutline.h.

#define NORMAL_BASELINE (0.0)

Definition at line 31 of file mfoutline.h.

#define NORMAL_X_HEIGHT (0.5)

---------------------------------------------------------------------------- Include Files and Type Defines ----------------------------------------------------------------------------

Definition at line 30 of file mfoutline.h.

#define PointAt ( O ) ((MFEDGEPT *) first_node (O))

Definition at line 67 of file mfoutline.h.

Typedef Documentation

typedef LIST MFOUTLINE

Definition at line 33 of file mfoutline.h.

Enumeration Type Documentation

enum DIRECTION

Enumerator:

north
south
east
west
northeast
northwest
southeast
southwest

Definition at line 35 of file mfoutline.h.

             {
  north, south, east, west, northeast, northwest, southeast, southwest
} DIRECTION;

enum NORM_METHOD

Enumerator:

baseline
character

Definition at line 53 of file mfoutline.h.

             {
  baseline, character
} NORM_METHOD;

enum OUTLINETYPE

Enumerator:

outer
hole

Definition at line 49 of file mfoutline.h.

             {
  outer, hole
} OUTLINETYPE;

Function Documentation

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; Exceptions: none; History: Fri May 4 10:42:04 1990, DSJ, Created.

Definition at line 337 of file mfoutline.cpp.

                                                                          {
  MFOUTLINE Current;

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

  PointAt (End)->PreviousDirection = Direction;

}                                /* ChangeDirection */

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; Exceptions: none; History: Fri Dec 14 10:27:11 1990, DSJ, Created.

Definition at line 359 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() - MAX_UINT8 / 2) * MF_SCALE_FACTOR;
    CurrentPoint->Point.y = (pos.y() - MAX_UINT8 / 2) * MF_SCALE_FACTOR;

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

}                                /* CharNormalizeOutline */

void ComputeBlobCenter	(	TBLOB *	Blob,
		TPOINT *	BlobCenter
	)

---------------------------------------------------------------------------- Public Function Prototypes ----------------------------------------------------------------------------

void ComputeDirection	(	MFEDGEPT *	Start,
		MFEDGEPT *	Finish,
		FLOAT32	MinSlope,
		FLOAT32	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; Exceptions: none; History: 7/25/89, DSJ, Created.

Definition at line 401 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 = -MAX_FLOAT32;
    Start->Direction = south;
  }
  else {
    Start->Slope = MAX_FLOAT32;
    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;
}

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 == NULL)
      ? NIL_LIST
      : ConvertOutlines(blob->outlines, outlines, outer);
}

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 == NULL || outline->loop == NULL)
    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 != NULL)
    MakeOutlineCircular(MFOutline);
  return MFOutline;
}

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 != NULL) {
    mf_outline = ConvertOutline(outline);
    if (mf_outline != NULL)
      mf_outlines = push(mf_outlines, mf_outline);
    outline = outline->next;
  }
  return mf_outlines;
}

void FilterEdgeNoise	(	MFOUTLINE	Outline,
		FLOAT32	NoiseSegmentLength
	)

void FindDirectionChanges	(	MFOUTLINE	Outline,
		FLOAT32	MinSlope,
		FLOAT32	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

Note:: Exceptions: none; History: 7/21/89, DSJ, Created.

Definition at line 120 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 */

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

Note:: Exceptions: none; History: 7/27/89, DSJ, Created.

Definition at line 154 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 != NULL) {
    free_struct (first_node (Start), sizeof (MFEDGEPT), "MFEDGEPT");
    Start = pop (Start);
  }

}                                /* FreeMFOutline */

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

Note:: Exceptions: none; History: Thu Dec 13 16:14:50 1990, DSJ, Created.

Definition at line 178 of file mfoutline.cpp.

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

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; Exceptions: none; History: 6/29/90, DSJ, Created.

Definition at line 198 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 */

MFEDGEPT* NewEdgePoint ( )

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

Definition at line 220 of file mfoutline.cpp.

                         {
  return ((MFEDGEPT *) alloc_struct(sizeof(MFEDGEPT), "MFEDGEPT"));
}

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; Exceptions: none; History: 7/25/89, DSJ, Created.

Definition at line 466 of file mfoutline.cpp.

                                                   {
  DIRECTION InitialDirection;

  InitialDirection = PointAt (EdgePoint)->Direction;

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

  return (EdgePoint);
}

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; Exceptions: none; History: 7/26/89, DSJ, Created.

Definition at line 238 of file mfoutline.cpp.

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

  return (EdgePoint);

}                                /* NextExtremity */

void NormalizeOutline	(	MFOUTLINE	Outline,
		FLOAT32	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; Exceptions: none; History: 8/2/89, DSJ, Created.

Definition at line 264 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 */

classify/mfoutline.h File Reference

Classes

Defines

Typedefs

Enumerations

Functions

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation