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

Classes
struct	MFEDGEPT

Macros
#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, float NoiseSegmentLength)

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

void	FreeMFOutline (void *agr)

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)

Macro Definition Documentation

◆ AverageOf

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

Macros

Definition at line 61 of file mfoutline.h.

◆ ClearMark

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

Definition at line 73 of file mfoutline.h.

◆ DegenerateOutline

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

Definition at line 67 of file mfoutline.h.

◆ MakeOutlineCircular

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

Definition at line 70 of file mfoutline.h.

◆ MarkPoint

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

Definition at line 74 of file mfoutline.h.

◆ MF_SCALE_FACTOR

#define MF_SCALE_FACTOR (NORMAL_X_HEIGHT / kBlnXHeight)

Definition at line 64 of file mfoutline.h.

◆ NextPointAfter

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

Definition at line 69 of file mfoutline.h.

◆ NORMAL_BASELINE

#define NORMAL_BASELINE (0.0)

Definition at line 32 of file mfoutline.h.

◆ NORMAL_X_HEIGHT

#define NORMAL_X_HEIGHT (0.5)

Include Files and Type Defines

Definition at line 31 of file mfoutline.h.

◆ PointAt

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

Definition at line 68 of file mfoutline.h.

Typedef Documentation

◆ MFOUTLINE

typedef LIST MFOUTLINE

Definition at line 34 of file mfoutline.h.

Enumeration Type Documentation

◆ DIRECTION

enum DIRECTION

Enumerator
north
south
east
west
northeast
northwest
southeast
southwest

Definition at line 36 of file mfoutline.h.

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

◆ NORM_METHOD

enum NORM_METHOD

Enumerator
baseline
character

Definition at line 54 of file mfoutline.h.

              {
   baseline, character
 } NORM_METHOD;

◆ OUTLINETYPE

enum OUTLINETYPE

Enumerator
outer
hole

Definition at line 50 of file mfoutline.h.

              {
   outer, hole
 } OUTLINETYPE;

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 */

◆ ComputeBlobCenter()

void ComputeBlobCenter	(	TBLOB *	Blob,
		TPOINT *	BlobCenter
	)

Public Function Prototypes

◆ 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;
 }

◆ FilterEdgeNoise()

void FilterEdgeNoise	(	MFOUTLINE	Outline,
		float	NoiseSegmentLength
	)

◆ 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 */

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ AverageOf

Macros

◆ ClearMark

◆ DegenerateOutline

◆ MakeOutlineCircular

◆ MarkPoint

◆ MF_SCALE_FACTOR

◆ NextPointAfter

◆ NORMAL_BASELINE

◆ NORMAL_X_HEIGHT

Include Files and Type Defines

◆ PointAt

Typedef Documentation

◆ MFOUTLINE

Enumeration Type Documentation

◆ DIRECTION

◆ NORM_METHOD

◆ OUTLINETYPE

Function Documentation

◆ ChangeDirection()

◆ CharNormalizeOutline()

◆ ComputeBlobCenter()

Public Function Prototypes

◆ ComputeDirection()

◆ ConvertBlob()

◆ ConvertOutline()

◆ ConvertOutlines()

◆ FilterEdgeNoise()

◆ FindDirectionChanges()

◆ FreeMFOutline()

◆ FreeOutlines()

◆ MarkDirectionChanges()

◆ NewEdgePoint()

◆ NextDirectionChange()

◆ NextExtremity()

◆ NormalizeOutline()