outfeat.h File Reference

#include "ocrfeatures.h"
#include "fpoint.h"
#include "mfoutline.h"

Go to the source code of this file.

Macros
#define	MAX_OUTLINE_FEATURES   (100)

Enumerations
enum	OUTLINE_FEAT_PARAM_NAME { OutlineFeatX, OutlineFeatY, OutlineFeatLength, OutlineFeatDir }

Functions
void	AddOutlineFeatureToSet (FPOINT *Start, FPOINT *End, FEATURE_SET FeatureSet)
void	ConvertToOutlineFeatures (MFOUTLINE Outline, FEATURE_SET FeatureSet)
void	NormalizeOutlineX (FEATURE_SET FeatureSet)

Macro Definition Documentation

MAX_OUTLINE_FEATURES

#define MAX_OUTLINE_FEATURES   (100)

Definition at line 34 of file outfeat.h.

Enumeration Type Documentation

OUTLINE_FEAT_PARAM_NAME

enum OUTLINE_FEAT_PARAM_NAME

---

Include Files and Type Defines

Enumerator
OutlineFeatX
OutlineFeatY
OutlineFeatLength
OutlineFeatDir

Definition at line 27 of file outfeat.h.

             {
  OutlineFeatX,
  OutlineFeatY,
  OutlineFeatLength,
  OutlineFeatDir

Function Documentation

AddOutlineFeatureToSet()

void AddOutlineFeatureToSet	(	FPOINT *	Start,
		FPOINT *	End,
		FEATURE_SET	FeatureSet
	)

This routine computes the midpoint between Start and End to obtain the x,y position of the outline-feature. It also computes the direction from Start to End as the direction of the outline-feature and the distance from Start to End as the length of the outline-feature. This feature is then inserted into the next feature slot in FeatureSet.

Parameters

Start	starting point of outline-feature
End	ending point of outline-feature
FeatureSet	set to add outline-feature to

Definition at line 82 of file outfeat.cpp.

                                                    {
  FEATURE Feature;
 
  Feature = NewFeature(&OutlineFeatDesc);
  Feature->Params[OutlineFeatDir] = NormalizedAngleFrom(Start, End, 1.0);
  Feature->Params[OutlineFeatX] = AverageOf(Start->x, End->x);
  Feature->Params[OutlineFeatY] = AverageOf(Start->y, End->y);
  Feature->Params[OutlineFeatLength] = DistanceBetween(*Start, *End);
  AddFeature(FeatureSet, Feature);
 

ConvertToOutlineFeatures()

void ConvertToOutlineFeatures	(	MFOUTLINE	Outline,
		FEATURE_SET	FeatureSet
	)

This routine steps converts each section in the specified outline to a feature described by its x,y position, length and angle. Results are returned in FeatureSet.

Parameters

Outline	outline to extract outline-features from
FeatureSet	set of features to add outline-features to

Definition at line 106 of file outfeat.cpp.

                                                                         {
  MFOUTLINE Next;
  MFOUTLINE First;
  FPOINT FeatureStart;
  FPOINT FeatureEnd;
 
  if (DegenerateOutline (Outline))
    return;
 
  First = Outline;
  Next = First;
  do {
    FeatureStart = PointAt(Next)->Point;
    Next = NextPointAfter(Next);
 
    /* note that an edge is hidden if the ending point of the edge is
       marked as hidden.  This situation happens because the order of
       the outlines is reversed when they are converted from the old
       format.  In the old format, a hidden edge is marked by the
       starting point for that edge. */
    if (!PointAt(Next)->Hidden) {
      FeatureEnd = PointAt(Next)->Point;
      AddOutlineFeatureToSet(&FeatureStart, &FeatureEnd, FeatureSet);
    }
  }
  while (Next != First);

NormalizeOutlineX()

void NormalizeOutlineX

(

FEATURE_SET

FeatureSet

)

This routine computes the weighted average x position over all of the outline-features in FeatureSet and then renormalizes the outline-features to force this average to be the x origin (i.e. x=0). FeatureSet is changed.

Parameters

FeatureSet

outline-features to be normalized

Definition at line 144 of file outfeat.cpp.

                                               {
  int i;
  FEATURE Feature;
  float Length;
  float TotalX = 0.0;
  float TotalWeight = 0.0;
  float Origin;
 
  if (FeatureSet->NumFeatures <= 0)
    return;
 
  for (i = 0; i < FeatureSet->NumFeatures; i++) {
    Feature = FeatureSet->Features[i];
    Length = Feature->Params[OutlineFeatLength];
    TotalX += Feature->Params[OutlineFeatX] * Length;
    TotalWeight += Length;
  }
  Origin = TotalX / TotalWeight;
 
  for (i = 0; i < FeatureSet->NumFeatures; i++) {
    Feature = FeatureSet->Features[i];
    Feature->Params[OutlineFeatX] -= Origin;
  }