classify/outfeat.cpp

Go to the documentation of this file.

/* =================
 Include Files and Type Defines
 ==================== */
#include "outfeat.h"
#include "mfoutline.h"
#include "variables.h"
#include "sigmenu.h"

#include "ocrfeatures.h"         //Debug
#include <stdio.h>               //Debug
#include "efio.h"                //Debug
#ifdef TEXT_VERBOSE
#include    "callcpp.h"
#endif
//#include "christydbg.h"

/* =================
 Private Function Prototypes
 ==================== */
/*
#if defined(__STDC__) || defined(__cplusplus)
# define _ARGS(s) s
#else
# define _ARGS(s) ()
#endif*/

/* /users/danj/wiseowl/src/danj/microfeatures/outfeat.c
void AddOutlineFeatureToSet
  _ARGS((FPOINT *Start,
  FPOINT *End,
  FEATURE_SET FeatureSet));

void ConvertToOutlineFeatures
  _ARGS((MFOUTLINE Outline,
  FEATURE_SET FeatureSet));

void NormalizeOutlineX
  _ARGS((FEATURE_SET FeatureSet));

#undef _ARGS
*/
/* =================
 Global Data Definitions and Declarations
 ==================== */
/* =================
              Public Code
 ==================== */
/* =============================== */
FEATURE_SET ExtractOutlineFeatures(TBLOB *Blob, LINE_STATS *LineStats) { 
  LIST Outlines;
  LIST RemainingOutlines;
  MFOUTLINE Outline;
  FEATURE_SET FeatureSet;
  FLOAT32 XScale, YScale;

#ifdef TEXT_VERBOSE
  // gets a 'o', see ccmain/tesseractmain.dox
  cprintf("o");
#endif
  FeatureSet = NewFeatureSet (MAX_OUTLINE_FEATURES);
  if (Blob == NULL)
    return (FeatureSet);

  Outlines = ConvertBlob (Blob);

  NormalizeOutlines(Outlines, LineStats, &XScale, &YScale); 
  RemainingOutlines = Outlines;
  iterate(RemainingOutlines) { 
    Outline = (MFOUTLINE) first (RemainingOutlines);
    /*---------Debug--------------------------------------------------*
    OFile = fopen ("f:/ims/debug/ofOutline.logCPP", "r");
    if (OFile == NULL)
    {
      OFile = Efopen ("f:/ims/debug/ofOutline.logCPP", "w");
      WriteOutline(OFile, Outline);
    }
    else
    {
      fclose (OFile);
      OFile = Efopen ("f:/ims/debug/ofOutline.logCPP", "a");
    }
    WriteOutline(OFile, Outline);
    fclose (OFile);
    *--------------------------------------------------------------------*/
    ConvertToOutlineFeatures(Outline, FeatureSet); 
  }
  if (NormMethod == baseline)
    NormalizeOutlineX(FeatureSet); 
  /*---------Debug--------------------------------------------------*
  File = fopen ("f:/ims/debug/ofFeatSet.logCPP", "r");
  if (File == NULL)
  {
    File = Efopen ("f:/ims/debug/ofFeatSet.logCPP", "w");
    WriteFeatureSet(File, FeatureSet);
  }
  else
  {
    fclose (File);
    File = Efopen ("f:/ims/debug/ofFeatSet.logCPP", "a");
  }
  WriteFeatureSet(File, FeatureSet);
  fclose (File);
  *--------------------------------------------------------------------*/
  FreeOutlines(Outlines); 
  return (FeatureSet);
}                                /* ExtractOutlineFeatures */


/* =============================== */
void InitOutlineFXVars() { 
                                 //once contained a dummy
}                                /* InitOutlineFXVars */


/* =================
     Private Code
 ==================== */
/* =============================== */
void AddOutlineFeatureToSet(FPOINT *Start,
                            FPOINT *End,
                            FEATURE_SET FeatureSet) {
  FEATURE Feature;

  Feature = NewFeature (&OutlineFeatDesc);
  ParamOf (Feature, OutlineFeatDir) = NormalizedAngleFrom (Start, End, 1.0);
  ParamOf (Feature, OutlineFeatX) = AverageOf (Xof (*Start), Xof (*End));
  ParamOf (Feature, OutlineFeatY) = AverageOf (Yof (*Start), Yof (*End));
  ParamOf (Feature, OutlineFeatLength) = DistanceBetween (*Start, *End);
  AddFeature(FeatureSet, Feature); 

}                                /* AddOutlineFeatureToSet */


/* =============================== */
void ConvertToOutlineFeatures(MFOUTLINE Outline, FEATURE_SET FeatureSet) { 
  MFOUTLINE Next;
  MFOUTLINE First;
  FPOINT FeatureStart;
  FPOINT FeatureEnd;

  if (DegenerateOutline (Outline))
    return;

  First = Outline;
  Next = First;
  do {
    CopyPoint (PositionOf (PointAt (Next)), FeatureStart);
    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 (IsVisible (PointAt (Next))) {
      CopyPoint (PositionOf (PointAt (Next)), FeatureEnd);
      AddOutlineFeatureToSet(&FeatureStart, &FeatureEnd, FeatureSet); 
    }
  }
  while (Next != First);
}                                /* ConvertToOutlineFeatures */


/* =============================== */
void NormalizeOutlineX(FEATURE_SET FeatureSet) { 
  int i;
  FEATURE Feature;
  FLOAT32 Length;
  FLOAT32 TotalX = 0.0;
  FLOAT32 TotalWeight = 0.0;
  FLOAT32 Origin;

  if (NumFeaturesIn (FeatureSet) <= 0)
    return;

  for (i = 0; i < NumFeaturesIn (FeatureSet); i++) {
    Feature = FeatureIn (FeatureSet, i);
    Length = ParamOf (Feature, OutlineFeatLength);
    TotalX += ParamOf (Feature, OutlineFeatX) * Length;
    TotalWeight += Length;
  }
  Origin = TotalX / TotalWeight;

  for (i = 0; i < NumFeaturesIn (FeatureSet); i++) {
    Feature = FeatureIn (FeatureSet, i);
    ParamOf (Feature, OutlineFeatX) -= Origin;
  }
}                                /* NormalizeOutlineX */

---