mergenf.cpp File Reference

#include <algorithm>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include "cluster.h"
#include "clusttool.h"
#include "featdefs.h"
#include "intproto.h"
#include "mergenf.h"
#include "ocrfeatures.h"
#include "oldlist.h"
#include "params.h"
#include "protos.h"

Go to the source code of this file.

Macros
#define	_USE_MATH_DEFINES

Functions
float	CompareProtos (PROTO_STRUCT *p1, PROTO_STRUCT *p2)
void	ComputeMergedProto (PROTO_STRUCT *p1, PROTO_STRUCT *p2, float w1, float w2, PROTO_STRUCT *MergedProto)
int	FindClosestExistingProto (CLASS_TYPE Class, int NumMerged[], PROTOTYPE *Prototype)
void	MakeNewFromOld (PROTO_STRUCT *New, PROTOTYPE *Old)
SubfeatureEvidence
Compare a feature to a prototype. Print the result.
float	SubfeatureEvidence (FEATURE Feature, PROTO_STRUCT *Proto)
EvidenceOf
Return the new type of evidence number corresponding to this distance value. This number is no longer based on the chi squared approximation. The equation that represents the transform is: 1 / (1 + (sim / midpoint) ^ curl)
double	EvidenceOf (double Similarity)
bool	DummyFastMatch (FEATURE Feature, PROTO_STRUCT *Proto)
void	ComputePaddedBoundingBox (PROTO_STRUCT *Proto, float TangentPad, float OrthogonalPad, FRECT *BoundingBox)
bool	PointInside (FRECT *Rectangle, float X, float Y)

Macro Definition Documentation

_USE_MATH_DEFINES

#define _USE_MATH_DEFINES

Definition at line 18 of file mergenf.cpp.

Function Documentation

CompareProtos()

float CompareProtos	(	PROTO_STRUCT *	p1,
		PROTO_STRUCT *	p2
	)

Compare protos p1 and p2 and return an estimate of the worst evidence rating that will result for any part of p1 that is compared to p2. In other words, if p1 were broken into pico-features and each pico-feature was matched to p2, what is the worst evidence rating that will be achieved for any pico-feature.

Parameters

p1,p2

protos to be compared

Globals: none

Returns

Worst possible result when matching p1 to p2.

Definition at line 66 of file mergenf.cpp.

                                                        {
  float WorstEvidence = WORST_EVIDENCE;
  float Evidence;
  float Angle, Length;
 
  /* if p1 and p2 are not close in length, don't let them match */
  Length = std::fabs(p1->Length - p2->Length);
  if (Length > MAX_LENGTH_MISMATCH) {
    return (0.0);
  }
 
  /* create a dummy pico-feature to be used for comparisons */
  auto Feature = new FEATURE_STRUCT(&PicoFeatDesc);
  Feature->Params[PicoFeatDir] = p1->Angle;
 
  /* convert angle to radians */
  Angle = p1->Angle * 2.0 * M_PI;
 
  /* find distance from center of p1 to 1/2 picofeat from end */
  Length = p1->Length / 2.0 - GetPicoFeatureLength() / 2.0;
  if (Length < 0) {
    Length = 0;
  }
 
  /* set the dummy pico-feature at one end of p1 and match it to p2 */
  Feature->Params[PicoFeatX] = p1->X + std::cos(Angle) * Length;
  Feature->Params[PicoFeatY] = p1->Y + std::sin(Angle) * Length;
  if (DummyFastMatch(Feature, p2)) {
    Evidence = SubfeatureEvidence(Feature, p2);
    if (Evidence < WorstEvidence) {
      WorstEvidence = Evidence;
    }
  } else {
    delete Feature;
    return 0.0;
  }
 
  /* set the dummy pico-feature at the other end of p1 and match it to p2 */
  Feature->Params[PicoFeatX] = p1->X - std::cos(Angle) * Length;
  Feature->Params[PicoFeatY] = p1->Y - std::sin(Angle) * Length;
  if (DummyFastMatch(Feature, p2)) {
    Evidence = SubfeatureEvidence(Feature, p2);
    if (Evidence < WorstEvidence) {
      WorstEvidence = Evidence;
    }
  } else {
    delete Feature;
    return 0.0;
  }
 
  delete Feature;
  return (WorstEvidence);
 
} /* CompareProtos */

ComputeMergedProto()

void ComputeMergedProto	(	PROTO_STRUCT *	p1,
		PROTO_STRUCT *	p2,
		float	w1,
		float	w2,
		PROTO_STRUCT *	MergedProto
	)

This routine computes a proto which is the weighted average of protos p1 and p2. The new proto is returned in MergedProto.

Parameters

p1,p2	protos to be merged
w1,w2	weight of each proto
MergedProto	place to put resulting merged proto

Definition at line 130 of file mergenf.cpp.

                                                                                                           {
  float TotalWeight;
 
  TotalWeight = w1 + w2;
  w1 /= TotalWeight;
  w2 /= TotalWeight;
 
  MergedProto->X = p1->X * w1 + p2->X * w2;
  MergedProto->Y = p1->Y * w1 + p2->Y * w2;
  MergedProto->Length = p1->Length * w1 + p2->Length * w2;
  MergedProto->Angle = p1->Angle * w1 + p2->Angle * w2;
  FillABC(MergedProto);
} /* ComputeMergedProto */

ComputePaddedBoundingBox()

void ComputePaddedBoundingBox	(	PROTO_STRUCT *	Proto,
		float	TangentPad,
		float	OrthogonalPad,
		FRECT *	BoundingBox
	)

This routine computes a bounding box that encloses the specified proto along with some padding. The amount of padding is specified as separate distances in the tangential and orthogonal directions.

Parameters

	Proto	proto to compute bounding box for
	TangentPad	amount of pad to add in direction of segment
	OrthogonalPad	amount of pad to add orthogonal to segment
[out]	BoundingBox	place to put results

Definition at line 295 of file mergenf.cpp.

                                                  {
  float Length = Proto->Length / 2.0 + TangentPad;
  float Angle = Proto->Angle * 2.0 * M_PI;
  float CosOfAngle = fabs(std::cos(Angle));
  float SinOfAngle = fabs(std::sin(Angle));
 
  float Pad = std::max(CosOfAngle * Length, SinOfAngle * OrthogonalPad);
  BoundingBox->MinX = Proto->X - Pad;
  BoundingBox->MaxX = Proto->X + Pad;
 
  Pad = std::max(SinOfAngle * Length, CosOfAngle * OrthogonalPad);
  BoundingBox->MinY = Proto->Y - Pad;
  BoundingBox->MaxY = Proto->Y + Pad;
 
} /* ComputePaddedBoundingBox */

DummyFastMatch()

bool DummyFastMatch	(	FEATURE	Feature,
		PROTO_STRUCT *	Proto
	)

This routine returns true if Feature would be matched by a fast match table built from Proto.

Parameters

Feature	feature to be "fast matched" to proto
Proto	proto being "fast matched" against

Globals:

• training_tangent_bbox_pad bounding box pad tangent to proto
• training_orthogonal_bbox_pad bounding box pad orthogonal to proto

Returns

true if feature could match Proto.

Definition at line 263 of file mergenf.cpp.

                                                          {
  FRECT BoundingBox;
  float MaxAngleError;
  float AngleError;
 
  MaxAngleError = training_angle_pad / 360.0;
  AngleError = std::fabs(Proto->Angle - Feature->Params[PicoFeatDir]);
  if (AngleError > 0.5) {
    AngleError = 1.0 - AngleError;
  }
 
  if (AngleError > MaxAngleError) {
    return false;
  }
 
  ComputePaddedBoundingBox(Proto, training_tangent_bbox_pad * GetPicoFeatureLength(),
                           training_orthogonal_bbox_pad * GetPicoFeatureLength(), &BoundingBox);
 
  return PointInside(&BoundingBox, Feature->Params[PicoFeatX], Feature->Params[PicoFeatY]);
} /* DummyFastMatch */

EvidenceOf()

double EvidenceOf

(

double

Similarity

)

Definition at line 236 of file mergenf.cpp.

                                     {
  Similarity /= training_similarity_midpoint;
 
  if (training_similarity_curl == 3) {
    Similarity = Similarity * Similarity * Similarity;
  } else if (training_similarity_curl == 2) {
    Similarity = Similarity * Similarity;
  } else {
    Similarity = pow(Similarity, training_similarity_curl);
  }
 
  return (1.0 / (1.0 + Similarity));
}

FindClosestExistingProto()

int FindClosestExistingProto	(	CLASS_TYPE	Class,
		int	NumMerged[],
		PROTOTYPE *	Prototype
	)

This routine searches through all of the prototypes in Class and returns the id of the proto which would provide the best approximation of Prototype. If no close approximation can be found, NO_PROTO is returned.

Parameters

Class	class to search for matching old proto in
NumMerged	# of protos merged into each proto of Class
Prototype	new proto to find match for

Globals: none

Returns

Id of closest proto in Class or NO_PROTO.

Definition at line 158 of file mergenf.cpp.

                                                                                      {
  PROTO_STRUCT NewProto;
  PROTO_STRUCT MergedProto;
  int Pid;
  PROTO_STRUCT *Proto;
  int BestProto;
  float BestMatch;
  float Match, OldMatch, NewMatch;
 
  MakeNewFromOld(&NewProto, Prototype);
 
  BestProto = NO_PROTO;
  BestMatch = WORST_MATCH_ALLOWED;
  for (Pid = 0; Pid < Class->NumProtos; Pid++) {
    Proto = ProtoIn(Class, Pid);
    ComputeMergedProto(Proto, &NewProto, static_cast<float>(NumMerged[Pid]), 1.0, &MergedProto);
    OldMatch = CompareProtos(Proto, &MergedProto);
    NewMatch = CompareProtos(&NewProto, &MergedProto);
    Match = std::min(OldMatch, NewMatch);
    if (Match > BestMatch) {
      BestProto = Pid;
      BestMatch = Match;
    }
  }
  return BestProto;
} /* FindClosestExistingProto */

MakeNewFromOld()

void MakeNewFromOld	(	PROTO_STRUCT *	New,
		PROTOTYPE *	Old
	)

This fills in the fields of the New proto based on the fields of the Old proto.

Parameters

New	new proto to be filled in
Old	old proto to be converted

Globals: none

Definition at line 194 of file mergenf.cpp.

                                                       {
  New->X = CenterX(Old->Mean);
  New->Y = CenterY(Old->Mean);
  New->Length = LengthOf(Old->Mean);
  New->Angle = OrientationOf(Old->Mean);
  FillABC(New);
} /* MakeNewFromOld */

PointInside()

bool PointInside	(	FRECT *	Rectangle,
		float	X,
		float	Y
	)

Return true if point (X,Y) is inside of Rectangle.

Globals: none

Returns

true if point (X,Y) is inside of Rectangle.

Definition at line 319 of file mergenf.cpp.

                                                     {
  return (X >= Rectangle->MinX) && (X <= Rectangle->MaxX) && (Y >= Rectangle->MinY) &&
         (Y <= Rectangle->MaxY);
} /* PointInside */

SubfeatureEvidence()

float SubfeatureEvidence	(	FEATURE	Feature,
		PROTO_STRUCT *	Proto
	)

Definition at line 209 of file mergenf.cpp.

                                                               {
  float Distance;
  float Dangle;
 
  Dangle = Proto->Angle - Feature->Params[PicoFeatDir];
  if (Dangle < -0.5) {
    Dangle += 1.0;
  }
  if (Dangle > 0.5) {
    Dangle -= 1.0;
  }
  Dangle *= training_angle_match_scale;
 
  Distance =
      Proto->A * Feature->Params[PicoFeatX] + Proto->B * Feature->Params[PicoFeatY] + Proto->C;
 
  return (EvidenceOf(Distance * Distance + Dangle * Dangle));
}