mfoutline.h File Reference

#include "blobs.h"
#include "fpoint.h"
#include "oldlist.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
using	MFOUTLINE = LIST

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

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

---

Macros

Definition at line 62 of file mfoutline.h.

#define ClearMark

(

P

)

((P)->ExtremityMark = false)

Definition at line 74 of file mfoutline.h.

#define DegenerateOutline

(

O

)

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

Definition at line 68 of file mfoutline.h.

#define MakeOutlineCircular

(

O

)

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

Definition at line 71 of file mfoutline.h.

#define MarkPoint

(

P

)

((P)->ExtremityMark = true)

Definition at line 75 of file mfoutline.h.

#define MF_SCALE_FACTOR   (NORMAL_X_HEIGHT / kBlnXHeight)

Definition at line 65 of file mfoutline.h.

#define NextPointAfter

(

E

)

(list_rest(E))

Definition at line 70 of file mfoutline.h.

#define NORMAL_BASELINE   (0.0)

Definition at line 30 of file mfoutline.h.

#define NORMAL_X_HEIGHT   (0.5)

---

Include Files and Type Defines

Definition at line 29 of file mfoutline.h.

#define PointAt

(

O

)

((MFEDGEPT*)first_node(O))

Definition at line 69 of file mfoutline.h.

Typedef Documentation

using MFOUTLINE = LIST

Definition at line 32 of file mfoutline.h.

Enumeration Type Documentation

enum DIRECTION

Enumerator
north
south
east
west
northeast
northwest
southeast
southwest

Definition at line 34 of file mfoutline.h.

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

enum NORM_METHOD

Enumerator
baseline
character

Definition at line 57 of file mfoutline.h.

{ baseline, character } NORM_METHOD;

enum OUTLINETYPE

Enumerator
outer
hole

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

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

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

void ComputeBlobCenter	(	TBLOB *	Blob,
		TPOINT *	BlobCenter
	)

---

Public Function Prototypes

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

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

LIST ConvertBlob

(

TBLOB *

blob

)

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

Definition at line 37 of file mfoutline.cpp.

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

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

void FilterEdgeNoise	(	MFOUTLINE	Outline,
		float	NoiseSegmentLength
	)

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

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

Definition at line 146 of file mfoutline.cpp.

                              {  //MFOUTLINE                             Outline)
  MFOUTLINE Start;
  auto Outline = static_cast<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 */

void FreeOutlines

(

LIST

Outlines

)

Release all memory consumed by the specified list of outlines.

Parameters

Outlines

list of mf-outlines to be freed

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

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

                         {
  return reinterpret_cast<MFEDGEPT *>(malloc(sizeof(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

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

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 220 of file mfoutline.cpp.

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

  return (EdgePoint);

}                                /* NextExtremity */

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

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