mfoutline.h File Reference

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

Go to the source code of this file.

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, 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)

Macro Definition Documentation

AverageOf

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

---

Macros

Definition at line 60 of file mfoutline.h.

ClearMark

#define ClearMark

(

P

)

((P)->ExtremityMark = FALSE)

Definition at line 72 of file mfoutline.h.

DegenerateOutline

#define DegenerateOutline

(

O

)

(((O) == NIL_LIST) || ((O) == list_rest(O)))

Definition at line 66 of file mfoutline.h.

MakeOutlineCircular

#define MakeOutlineCircular

(

O

)

(set_rest (last (O), (O)))

Definition at line 69 of file mfoutline.h.

MarkPoint

#define MarkPoint

(

P

)

((P)->ExtremityMark = TRUE)

Definition at line 73 of file mfoutline.h.

MF_SCALE_FACTOR

#define MF_SCALE_FACTOR   (NORMAL_X_HEIGHT / kBlnXHeight)

Definition at line 63 of file mfoutline.h.

NextPointAfter

#define NextPointAfter

(

E

)

(list_rest (E))

Definition at line 68 of file mfoutline.h.

NORMAL_BASELINE

#define NORMAL_BASELINE   (0.0)

Definition at line 31 of file mfoutline.h.

NORMAL_X_HEIGHT

#define NORMAL_X_HEIGHT   (0.5)

---

Include Files and Type Defines

Definition at line 30 of file mfoutline.h.

PointAt

#define PointAt

(

O

)

((MFEDGEPT *) first_node (O))

Definition at line 67 of file mfoutline.h.

Typedef Documentation

MFOUTLINE

typedef LIST MFOUTLINE

Definition at line 33 of file mfoutline.h.

Enumeration Type Documentation

DIRECTION

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;

NORM_METHOD

enum NORM_METHOD

Enumerator
baseline
character

Definition at line 53 of file mfoutline.h.

             {
  baseline, character
} NORM_METHOD;

OUTLINETYPE

enum OUTLINETYPE

Enumerator
outer
hole

Definition at line 49 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

Exceptions: none

History: Fri May 4 10:42:04 1990, DSJ, Created.

Definition at line 338 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

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

ComputeBlobCenter()

void ComputeBlobCenter	(	TBLOB *	Blob,
		TPOINT *	BlobCenter
	)

---

Public Function Prototypes

ComputeDirection()

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

ConvertBlob()

LIST ConvertBlob

(

TBLOB *

blob

)

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

Definition at line 40 of file mfoutline.cpp.

                              {
  LIST outlines = NIL_LIST;
  return (blob == NULL)
      ? 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 50 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;
}

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

FilterEdgeNoise()

void FilterEdgeNoise	(	MFOUTLINE	Outline,
		FLOAT32	NoiseSegmentLength
	)

FindDirectionChanges()

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 121 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

Note

Exceptions: none

History: 7/27/89, DSJ, Created.

Definition at line 155 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(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

Note

Exceptions: none

History: Thu Dec 13 16:14:50 1990, DSJ, Created.

Definition at line 179 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

Exceptions: none

History: 6/29/90, DSJ, Created.

Definition at line 199 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 221 of file mfoutline.cpp.

                         {
  return (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

Exceptions: none

History: 7/25/89, DSJ, Created.

Definition at line 465 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);
}

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

Exceptions: none

History: 7/26/89, DSJ, Created.

Definition at line 239 of file mfoutline.cpp.

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

  return (EdgePoint);

}                                /* NextExtremity */

NormalizeOutline()

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