// Code for Sole shape match function
#include <limits.h>
#include <stdio.h>
#include "common.h"
#include "cheby.h"
#include "cowmath.h"
#include "math16.h"
#include "volcanop.h"
#include "runNet.h"
#include "nnet.h"
GLYPH * GlyphFromStrokes(UINT cStrokes, STROKE *pStrokes);
RECT GetGuideDrawnBox(HWXGUIDE *guide, int iBox);
#define ABS(x) (((x) > 0) ? (x) : -(x))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define SIGN(x) ((x) > 0 ? 1 : ((x) < 0 ? -1 : 0))
#define PEN_UP_VALUE LSHFT(-1)
#define PEN_DOWN_VALUE LSHFT(1)
#define XCHB 10
#define YCHB 10
#define ZCHB 10
#define MAXTMP 3
// assumption: GRIDSIZE <= 256 //This is beacuse the pointers to the mapped values are defined as Byte pointers
#define GRIDSIZE 32
typedef struct
{
int *xy; //Stores the sampled XY points
int *z; //Stores the z points--values are either PEN_UP or PEN_DOWN
int cPoint;//Stores the number of points that are there
int cPointMax; //Stores the max number of points that can be allocated
int iStepSize; //Stores the length of the step size--at present this is taken to be 1.5 % of the guide size
int iStepSizeSqr; //Stroes the square of the step size
} POINTINFO;
//This macro is used for seeing if two points are neighbours to one another--ie the distance between them <=1
#define Neighbor(a, b) ((a)-(b) < 2 && (b)-(a) < 2)
static int
solve2(int m[][(IMAXCHB+1)/2], int c[], int n)
{
int i, j, k, t, tmp;
for (i=0; i<n; ++i)
{
t = m[i][i];
// punt:
if (t == 0)
{
memset(c, 0, n*sizeof(*c));
return 0;
}
for (j=0; j<n; ++j)
m[i][j] = Div16(m[i][j], t);
c[i] = Div16(c[i], t);
for (k=i+1; k<n; ++k)
{
t = m[k][i];
for (j=0; j<n; ++j)
{
Mul16(t, m[i][j], tmp)
m[k][j] -= tmp;
}
Mul16(t, c[i], tmp)
c[k] -= tmp;
}
}
for (i=(n-1); i>=0; --i)
{
for (k=i-1; k>=0; --k)
{
t = m[k][i];
for (j=0; j<n; ++j)
{
Mul16(t, m[i][j], tmp)
m[k][j] -= tmp;
}
Mul16(t, c[i], tmp)
c[k] -= tmp;
}
}
return 1;
}
static int
solve(int m[IMAXCHB][IMAXCHB], int *c, int n)
{
int i, j, i2, j2;
int mEven[((IMAXCHB+1))/2][((IMAXCHB+1)/2)];
int mOdd[(IMAXCHB/2)][((IMAXCHB+1)/2)]; // # of cols is bigger than needed so that solve2() works
int cEven[((IMAXCHB+1)/2)];
int cOdd[(IMAXCHB/2)];
for (i = 0, i2 = 0; i2 < n; ++i, i2 += 2)
{
for (j = 0, j2 = 0; j2 < n; ++j, j2 += 2)
{
mEven[i][j] = m[i2][j2];
}
cEven[i] = c[i2];
}
for (i = 0, i2 = 1; i2 < n; ++i, i2 += 2)
{
for (j = 0, j2 = 1; j2 < n; ++j, j2 += 2)
{
mOdd[i][j] = m[i2][j2];
}
cOdd[i] = c[i2];
}
if (!solve2(mEven, cEven, (n+1)/2)) return 0;
if (!solve2(mOdd, cOdd, n/2)) return 0;
for (i = 0, i2 = 0; i2 < n; ++i, i2 += 2)
{
c[i2] = cEven[i];
}
for (i = 0, i2 = 1; i2 < n; ++i, i2 += 2)
{
c[i2] = cOdd[i];
}
return 1;
}
// Assumptions:
// c has size atleast cfeats
// cfeats is at most IMAXCHB
// c is uninitialized
int LSCheby(int* y, int n, int *c, int cfeats)
{
int i, j, t, x, dx, n2, nMin;
int meanGuess, tmp;
int T[IMAXCHB], m[IMAXCHB][IMAXCHB];
if (cfeats > IMAXCHB || cfeats <= 0)
return 0;
memset(c, 0, cfeats*sizeof(*c));
n2 = n+n;
nMin = cfeats + 2;
if (n < nMin && n > 4)
{
cfeats = n - 2;
nMin = cfeats + 2;
}
if (n < nMin) // approximate the stroke by a straight line
{
*c++ = (y[0] + y[n2-2]) >> 1;
*c = (y[n2-2] - y[0]) >> 1;
return 2;
}
memset(T, 0, sizeof(T));
memset(m, 0, sizeof(m));
meanGuess = y[0];
x = LSHFT(-1);
dx = LSHFT(2)/(n-1);
for (t = 0; t < n2; t += 2)
{
T[0] = LSHFT(1);
T[1] = x;
for (i = 2; i < cfeats; ++i)
{
Mul16(x, T[i-1], tmp)
T[i] = (tmp<<1) - T[i-2];
}
for (i = 0; i < cfeats; ++i)
{
for (j = 0; j < cfeats; ++j)
{
Mul16(T[i], T[j], tmp)
m[i][j] += tmp;
}
Mul16(T[i], y[t] - meanGuess, tmp)
c[i] += tmp;
//c[i] += T[i]*(y[t] - meanGuess);
}
x += dx;
}
if (!solve(m, c, cfeats))
return 0;
c[0] += meanGuess;
return cfeats;
}
int ISqrt(int x)
{
int n, lastN;
if (x <= 0)
return 0;
if (x==1)
return 1;
n = x >> 1;
do
{
lastN = n;
n = (n + x/n) >> 1;
}
while (n < lastN);
return n;
}
/******************************Public*Routine******************************\
* YDeviation
*
* Function to compute average deviation of the y values in a sequence of
* strokes (frames).
* This is not exactly standard deviation. But it is a lot cheaper and
* close enough. (See analysis and comments in Numerical Recipes in C).
*
* History:
* 02-Sep-1999 -by- Angshuman Guha aguha
* Wrote it.
\**************************************************************************/
int YDeviation(GLYPH *pGlyph)
{
int count, ymin, sum, ymean;
GLYPH *glyph;
FRAME *frame;
if (pGlyph && pGlyph->frame && RgrawxyFRAME(pGlyph->frame))
{
ymin = RgrawxyFRAME(pGlyph->frame)->y;
count = 0;
sum = 0;
}
else
return 1;
// find min and mean in one scan
for (glyph=pGlyph; glyph; glyph=glyph->next)
{
XY *xy;
int cxy;
frame = glyph->frame;
xy = RgrawxyFRAME(frame);
cxy = CrawxyFRAME(frame);
for (; cxy; xy++, cxy--)
{
int y;
y = xy->y;
if (y < ymin)
{
sum += count*(ymin - y);
ymin = y;
}
sum += y - ymin;
count++;
}
}
ASSERT(count > 0);
ymean = sum/count + ymin;
// find average deviation
sum = 0;
for (glyph=pGlyph; glyph; glyph=glyph->next)
{
XY *xy;
int cxy;
frame = glyph->frame;
xy = RgrawxyFRAME(frame);
cxy = CrawxyFRAME(frame);
for (; cxy; xy++, cxy--)
{
int diff;
diff = xy->y - ymean;
if (diff < 0)
sum -= diff;
else
sum += diff;
}
}
sum = sum/count;
if (sum < 1)
sum = 1;
return sum;
}
/******************************Private*Routine******************************\
* AddPoint
*
* Given a new point and a sequence of points so far, zero or more points
* are added at the end of the sequence. The points are effectively resampled
* at a pre-computed interval (a distance of pPointinfo->iStepSize between
* successive points). This function also effectively does a linear interpolation
* of a pen-upstroke between the last point of a pen-down stroke and the first
* point of the next pen-down stroke.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
Explanation of parameters
pPointInfo--The pointer to the Point Info structure--The points are added to the xy array of this structure
x--The x coordinate of the point to be added
y--The y coordinate of the point to be added
bFirstPointOfStroke--If true indicates that this is the first point of the stroke
Else it it not the first point
* Wrote this comment.Addtional comments added by Mango
\**************************************************************************/
BOOL AddPoint(POINTINFO *pPointinfo, int x, int y, int bFirstPointOfStroke)
{
int dx, dy, dist2, dist;
int bChangeLastPoint, x0, y0, zval;
int *pTemp;
if (!pPointinfo->cPoint)
{
pPointinfo->xy[0] = x;
pPointinfo->xy[1] = y;
pPointinfo->z[0] = PEN_DOWN_VALUE;
pPointinfo->cPoint = 1;
return TRUE;
}
bChangeLastPoint = 0;
x0 = pPointinfo->xy[2*pPointinfo->cPoint-2];
y0 = pPointinfo->xy[2*pPointinfo->cPoint-1];
zval = bFirstPointOfStroke ? PEN_UP_VALUE : PEN_DOWN_VALUE;
for (;;)
{
dx = x - x0;
dy = y - y0;
dist2 = dx*dx + dy*dy;
if (dist2 < pPointinfo->iStepSizeSqr)
break;
// add a point at given step size
dist = ISqrt(dist2);
x0 += pPointinfo->iStepSize*dx/dist;
y0 += pPointinfo->iStepSize*dy/dist;
// a minimum iStepSize of 2 and the fact that ((float)dx/dist)^2 + ((float)dy/dist)^2 = 1 guarantees that
// the previous two assignments change atleast one of x0 and y0 i.e. its not an infinite loop
if (pPointinfo->cPoint == pPointinfo->cPointMax)
{
// need more space
// hopefully we don't come here too often
pPointinfo->cPointMax *= 2;
pTemp = (int *) ExternRealloc(pPointinfo->xy, 2*pPointinfo->cPointMax*sizeof(int));
if (!pTemp)
{
return FALSE;
}
pPointinfo->xy = pTemp;
pTemp = (int *) ExternRealloc(pPointinfo->z, 2*pPointinfo->cPointMax*sizeof(int));
if (!pTemp)
{
return FALSE;
}
pPointinfo->z = pTemp;
}
pPointinfo->xy[2*pPointinfo->cPoint] = x0;
pPointinfo->xy[2*pPointinfo->cPoint+1] = y0;
pPointinfo->z[2*pPointinfo->cPoint] = zval;
pPointinfo->cPoint++;
bChangeLastPoint = bFirstPointOfStroke;
}
// if we have interpolated from the last point of a stroke to the first point of another
if (bChangeLastPoint)
{
ASSERT(pPointinfo->z[2*pPointinfo->cPoint - 2] == PEN_UP_VALUE);
pPointinfo->z[2*pPointinfo->cPoint - 2] = PEN_DOWN_VALUE;
}
// this last "if" could be changed to a test on bFirstPointOfStroke and the assert can be removed
return TRUE;
}
/******************************Private*Routine******************************\
* AddGuideFeatures
*
* Given a piece of ink in a box, compute five features related to the size
* and position of ink in the box.
* The five features are:-
* //First feature--Top of the ink relative to the guide box height
* //Second feature--Width of the ink relative to the guide box width
* //Third feature--Bottom of the ink relative to the guide box height
* //Fourth feature--The width of the ink relative to the sum of its width and height
* //Fifth feature--the iYMean value relative to the guide box height
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote this comment.
\**************************************************************************/
int AddGuideFeatures(RECT *pGuide, RECT *pRect, int iYMean, unsigned short *rgFeat)
{
// get normalized ink size/position (box is 1000x1000 with top-left at 0,0)
DRECTS drcs;
RECT inkRect = *pRect;
int x;
//The x coordinate of the top left corner of the current box(note--you are adding the cxBase Value)
drcs.x = pGuide->left;
//The y coordinate of the top left corner of the current box
drcs.y = pGuide->top;
//This gives us the width of the current guide box
drcs.w = pGuide->right - pGuide->left;
//This gives us the height of the current guide box
drcs.h = pGuide->bottom - pGuide->top;
// Translate, convert to delta form
//Stores the relative position w.rt. the top left of the guide box
inkRect.left -= drcs.x;
inkRect.top -= drcs.y;
//Stores the width of the ink
inkRect.right -= (drcs.x + inkRect.left);
//Stores the height of the ink
inkRect.bottom -= (drcs.y + inkRect.top);
//Converts the yMean wrt a form relative to the top of the guide box
iYMean -= drcs.y;
// Scale. We do isotropic scaling and center the shorter dimension.
//Y Mean as a fraction of the guide box size
iYMean = ((1000 * iYMean) / drcs.h);
//Sees where the top of the ink is relative to the guide box height
drcs.y = ((1000 * inkRect.top) / drcs.h);
//The width of the ink relative to the guide box width
drcs.w = ((1000 * inkRect.right) / drcs.h);
//The height of the ink relative to the guide box height
drcs.h = ((1000 * inkRect.bottom) / drcs.h);
//Why would any of these conditions happen
if (drcs.y < 0)
drcs.y = 0;
else if (drcs.y > 1000)
drcs.y = 1000;
if (drcs.w < 0)
drcs.w = 0;
else if (drcs.w > 1000)
drcs.w = 1000;
if (drcs.h < 0)
drcs.h = 0;
else if (drcs.h > 1000)
drcs.h = 1000;
// 4 guide features
//First feature--Top of the ink relative to the guide box height
x = drcs.y;
x = LSHFT(x)/1000;
if (x >= 0x10000)
x = 0xFFFF;
*rgFeat++ = (unsigned short)x;
//Second feature--Width of the ink relative to the guide box width
x = drcs.w;
x = LSHFT(x)/1000;
if (x >= 0x10000)
x = 0xFFFF;
*rgFeat++ = (unsigned short)x;
//Third feature--Bottom of the ink relative to the guide box height
x = drcs.h;
x = LSHFT(x)/1000;
if (x >= 0x10000)
x = 0xFFFF;
*rgFeat++ = (unsigned short)x;
//Fourth feature--The width of the ink relative to the sum of its width and height
if (drcs.w <= 0)
x = 0;
else
{
x = drcs.w;
x = LSHFT(x)/(drcs.w+drcs.h);
if (x >= 0x10000)
x = 0xFFFF;
}
*rgFeat++ = (unsigned short)x;
//Fifth feature--the iYMean value relative to the guide box height
// one more guide feature: y-CG
if (iYMean < 0)
iYMean = 0;
else if (iYMean > 1000)
iYMean = 1000;
x = iYMean;
x = LSHFT(x)/1000;
if (x >= 0x10000)
x = 0xFFFF;
*rgFeat = (unsigned short)x;
return 5;
}
/******************************Private*Routine******************************\
* SmoothPoints
*
* Given an array of points and a destination array, this function fills the
* destination array a smoothed version of the raw points. Smoothing is
* done by local averaging ona window of 5 points with weights 1/8 1/4 1/4 1/4 1/8.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote this comment.
\**************************************************************************/
void SmoothPoints(XY *rgSrc, XY *rgDst, int cXY)
{
int i,j;
for (i=0; i<cXY; i++)
{
j = cXY - i - 1;
if (i < j)
j = i;
switch (j)
{
case 0:
case 1:
*rgDst = *rgSrc;
break;
//+4 is added here so that rounding off takes place rather than truncation
default:
rgDst->x = (int)((
(rgSrc-2)->x +
((rgSrc-1)->x <<1) +
(rgSrc->x <<1) +
((rgSrc+1)->x <<1) +
(rgSrc+2)->x +
4
) >> 3);
rgDst->y = (int)((
(rgSrc-2)->y +
((rgSrc-1)->y <<1) +
(rgSrc->y <<1) +
((rgSrc+1)->y <<1) +
(rgSrc+2)->y +
4
) >> 3);
break;
}
rgSrc++;
rgDst++;
}
}
/******************************Private*Routine******************************\
* ComputeCurvedness
*
* Given a stroke, computes three curvature features--namely
*--The sum of the modular change in angle with respect to + and - for the angles
*--The total curviness of the stoke--just directly measure the change in angles.
*--The maximum change in angle that occurs in that stroke in one sampling distance
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote this comment.
\**************************************************************************/
void ComputeCurvedness(XY *rgXY, int cXY, int iStepSizeSqr, int *pSum1, int *pSum2, int *pMaxAngle)
{
int sum1, sum2;
int x, y;
XY *rgxy, *rgxySave;
int ang, lastAng, diff, dx, dy;
if (cXY <= 2)
{
*pSum1 = *pSum2 = 0;
return;
}
// smooth points
rgxySave = rgxy = (XY *) ExternAlloc(cXY*sizeof(XY));
if (!rgxy)
{
*pSum1 = *pSum2 = 0;
return;
}
SmoothPoints(rgXY, rgxy, cXY);
sum1 = sum2 = 0;
x = rgxy->x;
y = rgxy->y;
rgxy++;
cXY--;
// find first angle
while (cXY)
{
dy = rgxy->y - y;
dx = rgxy->x - x;
if (dx*dx+dy*dy >= iStepSizeSqr)
{
//Function from common/mathx--returns the integer approx in degrees
lastAng = Arctan2(dy, dx);
cXY--;
x = rgxy->x;
y = rgxy->y;
rgxy++;
break;
}
cXY--;
rgxy++;
}
// now find difference of every subsequent angle with its previous angle
while (cXY)
{
dy = rgxy->y - y;
dx = rgxy->x - x;
if (dx*dx+dy*dy >= iStepSizeSqr)
{
ang = Arctan2(dy, dx);
ANGLEDIFF(lastAng, ang, diff)
sum1 += diff;
if (diff < 0)
diff = -diff;
sum2 += diff;
lastAng = ang;
x = rgxy->x;
y = rgxy->y;
if (diff > *pMaxAngle)
*pMaxAngle = diff;
}
cXY--;
rgxy++;
}
// clean up
ExternFree(rgxySave);
*pSum1 = sum1;
*pSum2 = sum2;
}
/******************************Private*Routine******************************\
* AddCurveFeatures
*
* Given an ink (one or more strokes), computes three curvature features.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote this comment.
\**************************************************************************/
int AddCurveFeatures(GLYPH *pGlyph, int iStepSizeSqr, unsigned short *rgFeat)
{
GLYPH *glyph;
FRAME *frame;
int cXY;
XY *rgXY;
int sum1=0, sum2=0, ang1, ang2, maxAngle=0;
for (glyph=pGlyph; glyph; glyph=glyph->next)
{
frame = glyph->frame;
if (!IsVisibleFRAME(frame))
continue;
rgXY = RgrawxyFRAME(frame);
cXY = CrawxyFRAME(frame);
ASSERT(cXY > 0);
//For each frame compute the curvedness
ComputeCurvedness(rgXY, cXY, iStepSizeSqr, &ang1, &ang2, &maxAngle);
//sum1 represents the sum of the modular change in angle(with respect to + and - for the angles
sum1 += ang1;
//sum2 represent the total curviness of the stoke--just directly measures the change in angles.
sum2 += ang2;
}
// based on emperical obsevations, truncate sum1 between -1000 to 1000
// and sum2 between 0 and 1200
// (this results in no truncation in more than 99% cases)
if (sum1 < -1000)
sum1 = -1000;
else if (sum1 > 1000)
sum1 = 1000;
if (sum2 < 0)
sum2 = 0;
else if (sum2 > 1200)
sum2 = 1200;
sum1 += 1000; // now between 0 and 2000
sum1 = LSHFT(sum1)/2000;
if (sum1 > 0xFFFF)
sum1 = 0xFFFF;
sum2 = LSHFT(sum2)/1200;
if (sum2 > 0xFFFF)
sum2 = 0xFFFF;
// maxAngle should be between 0 and 180
if (maxAngle < 0)
maxAngle = 0;
else if (maxAngle > 180)
maxAngle = 180;
maxAngle = LSHFT(maxAngle)/180;
if (maxAngle > 0xFFFF)
maxAngle = 0xFFFF;
*rgFeat++ = (unsigned short) sum1;
*rgFeat++ = (unsigned short) sum2;
*rgFeat = (unsigned short) maxAngle;
return 3;
}
/******************************Private*Routine******************************\
* AddStrokeCountFeature
*
* Defines a single feature derived from stroke count of a char.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote this comment.
\**************************************************************************/
int AddStrokeCountFeature(int cStroke, unsigned short *rgFeat)
{
int tmp = LSHFT(cStroke-1)/cStroke;
*rgFeat++ = (unsigned short)tmp;
return 1;
}
/******************************Private*Routine******************************\
* DoOneContour
*
* Once a contour has been found (defined by a sequence of values, X-values
* for left- or right-contour, Y-values for top- or bottom-contour), this function
* is called to fit a Chebychev polynomial to the contour generating 9 new
* features.
*
* The arg "contour" is of length GRIDSIZE. The output features are filled in
* the arg rgFeat and the count of features generated is returned.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote it.
\**************************************************************************/
int DoOneContour(int *contour, unsigned short *rgFeat)
{
int rgX[2*GRIDSIZE], *pX; //The rgX array is of 2*GRIDSIZE because the Chebyshev function takes alternate array values
int chby[10];
int norm = 0;
int dT, i;
// copy points into required format
pX = rgX;
for (i=0; i<GRIDSIZE; i++)
{
int x;
x = 2 * (*contour++);
//We are now LSHFTing--this is the first place where the 16.16 format surfaces
//Why do we have to make the value between -1 and +1 ?
*pX++ = LSHFT(x-GRIDSIZE)/(GRIDSIZE); // values are in the range -1 to +1
pX++;
}
// fit a chebychev polynomial
if (!LSCheby(rgX, GRIDSIZE, chby, 10))
{
ASSERT(0);
return 0;
}
// find rms of coefficients
//dT and norm are both in 16.16 notation
for (i = 0; i < 10; ++i)
{
Mul16(chby[i], chby[i], dT)
norm += dT;
}
norm = ISqrt(norm) << 8;
if (norm < LSHFT(1))
norm = LSHFT(1);//The normalization value should at least be 1
// normalize coeffcients
for (i = 0; i < 10; i++)
{
//Why this LSHFT(1) ??
dT = Div16(chby[i], norm) + LSHFT(1);
//Why this ??
dT >>= 1;
if (dT >= 0x10000)
dT = 0xFFFF; //Fill it with 1's for the lower 16 bits
else if (dT < 0)
dT = 0;
//Does converting to an unsigned short always take the lowest 16 bits ??
*rgFeat++ = (unsigned short)dT;
}
return 10;
}
/******************************Private*Routine******************************\
* MakeLine
*
* Given a point in the GRIDSIZE x GRIDSIZE grid (bitmap) and given the
* sequence of points so far, this function adds one or more points in a
* straight line joining the last point and the given point.
*
* Returns the number of points added.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote it.
* 06-Oct-1997 -by- Angshuman Guha aguha
* Fixed a bug.
\**************************************************************************/
int MakeLine(BYTE x, BYTE y, BYTE *pX, BYTE *pY, int space)
{
BYTE midx, midy;
int ts1,ts2;
int c, c2;
if (space <= 0)
{
return 0;
}
ASSERT(x != *pX || y != *pY);
if (Neighbor(*pX, x) && Neighbor(*pY, y))
{
ASSERT(x >= 0);
ASSERT(x < GRIDSIZE);
ASSERT(y >= 0);
ASSERT(y < GRIDSIZE);
*++pX = x;
*++pY = y;
return 1;
}
ts1=(*pX+x)/2;
ts2=(*pY+y)/2;
midx = (BYTE) ts1;
midy = (BYTE) ts2;
c = MakeLine(midx, midy, pX, pY, space);
if (!c)
return 0;
c2 = MakeLine(x, y, pX+c, pY+c, space-c);
if (!c2)
return 0;
return c + c2;
}
/******************************Private*Routine******************************\
* AddContourFeatures
*
* Given a sequence of already-resampled points (pen-down strokes joined by
* intervening pen-up strokes) and the bounding rect for the ink, this function
* computes some contour features, fills up rgFeat with the features and
* returns the count of features computed.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote it.
* 06-Oct-1997 -by- Angshuman Guha aguha
* Fixed a bug. Added Realloc for rgMappedX and rgMappedY.
Comments added by Mango
The idea of this function is to first map the points that we have to 2 GRIDSIZE*GRIDSIZE bitmap.
Once the bitmap is made we use the contour features.
Explanation of the arguments to the function
pointinfo--Contains the strructure from which the points will be taken
pRect--pointer to the bounding rectangle of the original ink
rgFeat--This contains the finalk contour features
\**************************************************************************/
int AddContourFeatures(POINTINFO *pointinfo, RECT *pRect, unsigned short *rgFeat)
{
//BYTE rgGrid[GRIDSIZE][GRIDSIZE];
int xMin = pRect->left; //Stores the minimum value of x
int yMin = pRect->top; //Stores the minimum value of y
int xRange = pRect->right - xMin; //Stores the width of the bounding rectangle
int yRange = pRect->bottom - yMin; //Stores the height of the bounding rectangle
int range, xOrigin, yOrigin;//Range stores the greated of the xRange and yRange
int iPoint, *xy, *z, i, cMapped, cMappedMax; //cMapped stores the number of points that have been mapped. cMappedMAx--the max number of points that could be mapped
BYTE *pMappedX, *pMappedY, *rgMappedX, *rgMappedY;//Since we are using BYTE * here,we are assuming that GRIDSIZE <256--a byte size
int rgMaxX[GRIDSIZE], rgMinY[GRIDSIZE], rgMaxY[GRIDSIZE], lastz; //GRIDSIZE=32
int lastx, lasty;
int iRetValue;
BYTE *pbTmpX = NULL, *pbTmpY = NULL;
ASSERT(xRange > 0);
ASSERT(yRange > 0);
//We want to map the points to a GRIDSIZE*GRIDSIZE bitmap--but at the same time we want to preserve the aspect ratio
//It xRange >yRange,then the xValues will span the whole of the bit map
//The y values will not span the entire bit map--but will simply be centered on the bit map.This helps to preserve the aspect ratio
if (xRange > yRange)
{
range = xRange;
xOrigin = 0;
yOrigin = (GRIDSIZE - GRIDSIZE*(yRange-1)/range) / 2;
}
else if (yRange > 1)
{ //In this case the y will span the entire grid map.xOrigin is scaled according to the earlier comment
range = yRange;
xOrigin = (GRIDSIZE - GRIDSIZE*(xRange-1)/range) / 2;
yOrigin = 0;
}
else // xRange == yRange == 1
{ //In this case the Ink will be centered
range = 1;
xOrigin = GRIDSIZE/2;
yOrigin = GRIDSIZE/2;
}
// make list of grid points which will make up the binary pixel map--we will map only the pen down points
//Initialize the pointers to the raw points
xy = pointinfo->xy;
z = pointinfo->z;
//In case there is a continuation of a line,then the bit map should not have any vacant spaces in the grid
//connecting the points of the line.Hence we add extra space by 2*GRIDSIZE in case we need to connect the points
//cMappedMax represents the maximum number of points that will be mapped
cMappedMax = 2*(pointinfo->cPoint+GRIDSIZE);
rgMappedX = (BYTE *) ExternAlloc(cMappedMax*sizeof(BYTE));
rgMappedY = (BYTE *) ExternAlloc(cMappedMax*sizeof(BYTE));
if (!rgMappedX || !rgMappedY)
{
//Allocatation failed.FLEE !!
ASSERT(0);
iRetValue = 0;
goto cleanup;
}
cMapped = 0; //This contains the total number of points that have been mapped
//The pointer to which it has been initialized is one less than the actual start.
//Hence need to use an increment operator prior to using the first time.
//After that the pointer always points to the last value that was allocated
pMappedX = rgMappedX - 1;
pMappedY = rgMappedY - 1;
lastz = PEN_UP_VALUE;
for (iPoint=0; iPoint<pointinfo->cPoint; iPoint++)
{
int xRaw, yRaw, x, y, zRaw;
// get point
xRaw = *xy++;
yRaw = *xy++;
zRaw = *z++;
z++;
if (zRaw > 0) // pen-down point
{
// map x to grid
x = xOrigin + GRIDSIZE*(xRaw - xMin)/range;
ASSERT(x >= 0);
ASSERT(x < GRIDSIZE);
// map y to grid
y = yOrigin + GRIDSIZE*(yRaw - yMin)/range;
ASSERT(y >= 0);
ASSERT(y < GRIDSIZE);
// save this point in the list
if (lastz < 0)
{
if (cMapped==cMappedMax)
{ //If the max space has already been used up then we ned to realloc.
cMappedMax *= 2;
pbTmpX = ExternRealloc(rgMappedX, cMappedMax*sizeof(BYTE));
if (!pbTmpX)
{
ASSERT(0);
iRetValue = 0;
goto cleanup;
}
rgMappedX = pbTmpX;
pMappedX = rgMappedX - 1 + cMapped;
pbTmpY = ExternRealloc(rgMappedY, cMappedMax*sizeof(BYTE));
if (!pbTmpY)
{
ASSERT(0);
iRetValue = 0;
goto cleanup;
}
rgMappedY = pbTmpY;
pMappedY = rgMappedY - 1 + cMapped;
}
// first point of a stroke
*++pMappedX = (BYTE)x;
*++pMappedY = (BYTE)y;
cMapped++;
}
else if (x != *pMappedX || y != *pMappedY)
{
// next unique mapped point
//i contains the count of the number of points that have been added thru MakeLine
ASSERT(*pMappedX < GRIDSIZE);
ASSERT(*pMappedY <GRIDSIZE);
ASSERT(*pMappedX >=0);
ASSERT(*pMappedY >=0);
while (!(i = MakeLine((BYTE)x, (BYTE)y, pMappedX, pMappedY, cMappedMax - cMapped)))
{
// these reallocs happen on 0.4% of the samples of gtrain02.ste (1860 of 443292 samples)
cMappedMax *= 2;
pbTmpX = ExternRealloc(rgMappedX, cMappedMax*sizeof(BYTE));
if (!pbTmpX)
{
ASSERT(0);
iRetValue = 0;
goto cleanup;
}
rgMappedX = pbTmpX;
pMappedX = rgMappedX - 1 + cMapped;
pbTmpY = ExternRealloc(rgMappedY, cMappedMax*sizeof(BYTE));
if (!pbTmpY)
{
ASSERT(0);
iRetValue = 0;
goto cleanup;
}
rgMappedY = pbTmpY;
pMappedY = rgMappedY - 1 + cMapped;
}
//Increment the count of mapped points by the number of points that have been added.
cMapped += i;
ASSERT(cMapped <=cMappedMax);
//Increment the pointers accordingly
pMappedX += i;
pMappedY += i;
}
} // if zRaw > 0
lastz = zRaw;
} // for iPoint=0
// now dump the mapped point list into the grid, deleting redundant points along the way
//memset(rgGrid, 0, sizeof(rgGrid));
for (i=0; i<GRIDSIZE; i++)
{
rgMaxX[i] = -1;
rgMinY[i] = GRIDSIZE;
rgMaxY[i] = -1;
}
pMappedX = rgMappedX;
pMappedY = rgMappedY;
for (iPoint=0; iPoint<cMapped; iPoint++)
{
int x, y;
x = *pMappedX++;
y = *pMappedY++;
if (iPoint > 0 && iPoint < cMapped-1)
{
int nextx = *pMappedX;
int nexty = *pMappedY;
if (Neighbor(lastx, nextx) &&
Neighbor(lasty, nexty) &&
lastx != nextx &&
lasty != nexty)
continue;
}
lastx = x;
lasty = y;
//rgGrid[x][y]=1;
ASSERT(x >= 0);
ASSERT(x < GRIDSIZE);
ASSERT(y >= 0);
ASSERT(y < GRIDSIZE);
if (x > rgMaxX[y])
rgMaxX[y] = x;
if (y < rgMinY[x])
rgMinY[x] = y;
if (y > rgMaxY[x])
rgMaxY[x] = y;
}
// now Chebychev'ize the three contours
// right contour
rgFeat += DoOneContour(rgMaxX, rgFeat);
// top contour
rgFeat += DoOneContour(rgMinY, rgFeat);
// bottom contour
rgFeat += DoOneContour(rgMaxY, rgFeat);
iRetValue = 30;
cleanup: // Clean up temp space
if (rgMappedX)
ExternFree(rgMappedX);
if (rgMappedY)
ExternFree(rgMappedY);
return iRetValue;
}
/******************************Private*Routine******************************\
* NormalizeCheby
*
* Routine to normalize the three (x, y and z) Chebychev polynomials.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Wrote this comment.
\**************************************************************************/
void NormalizeCheby(int *chbyX, int *chbyY, int *chbyZ, unsigned short *rgFeat)
{
int norm = 0;
int dT;
int cFeat = 0, i;
//The norm is applied both to x and y prior to dividing,so that the relative sizes of x and y can be kept intact
//
for (i = 1; i < XCHB; ++i) // 1st X coeff skipped
{
Mul16(chbyX[i], chbyX[i], dT)
norm += dT;
}
for (i = 1; i < YCHB; ++i) // 1st Y coeff skipped
{
Mul16(chbyY[i], chbyY[i], dT)
norm += dT;
}
norm = ISqrt(norm) << 8;
if (norm < LSHFT(1))
norm = LSHFT(1);
for (i=1; i<XCHB; i++)
{
dT = Div16(chbyX[i], norm) + LSHFT(1); // now between 0 and 2
dT >>= 1; // now between 0 and 1
if (dT >= 0x10000)
dT = 0xFFFF;
else if (dT < 0)
dT = 0;
rgFeat[cFeat++] = (unsigned short)dT;
}
for (i=1; i<YCHB; i++)
{
dT = Div16(chbyY[i], norm) + LSHFT(1);
dT >>= 1;
if (dT >= 0x10000)
dT = 0xFFFF;
else if (dT < 0)
dT = 0;
rgFeat[cFeat++] = (unsigned short)dT;
}
// Z
norm = 0;
for (i = 0; i < 8; ++i)
{
Mul16(chbyZ[i], chbyZ[i], dT)
norm += dT;
}
norm = ISqrt(norm) << 8;
if (norm < LSHFT(1))
norm = LSHFT(1);
for (i = 0; i < 8; i++)
{
dT = Div16(chbyZ[i], norm) + LSHFT(1);
dT >>= 1;
if (dT >= 0x10000)
dT = 0xFFFF;
else if (dT < 0)
dT = 0;
rgFeat[cFeat++] = (unsigned short)dT;
}
ASSERT(cFeat == 26);
}
/******************************Public*Routine******************************\
* SoleFeaturize
*
* The top-level routine for featurizing ink for a char.
*
* History:
* 26-Sep-1997 -by- Angshuman Guha aguha
* Modified it.
\**************************************************************************/
BOOL SoleFeaturize(GLYPH *pGlyph, RECT *pGuide, unsigned short *rgFeat)
{
int cStroke, iStroke;
int iPoint;
int sumX, sumY, sum;
double totvar;
int var;
int isumX, isumY;//These store the mean values of x and y
int chbyX[IMAXCHB], chbyY[IMAXCHB], chbyZ[IMAXCHB];
int retVal = 1;
XY *rgXY, lastXY;
int cXY, iXY, dx, dy, t;
GLYPH *glyph;
FRAME *frame;
int ydev; //Stores the ydev value used for storing the step size
POINTINFO pointinfo;
RECT rect;
// compute cStroke
for (cStroke=0, glyph=pGlyph; glyph; glyph=glyph->next)
{
frame = glyph->frame;
if (!IsVisibleFRAME(frame))
continue;
cXY = CrawxyFRAME(frame);
ASSERT(cXY > 0);
cStroke++;
}
if (cStroke < 1)
return 0;
// compute step size--originally this was done using the box height
// pointinfo.iStepSize = pGuide->cyBox*3/200; // 1.5% of box height
ydev= YDeviation(pGlyph);
if (ydev < 1)
ydev = 1; // a "-" or a "."
//The step size is computed from the ydev value
pointinfo.iStepSize = ydev/5;
if (pointinfo.iStepSize < 2)
pointinfo.iStepSize = 2;
pointinfo.iStepSizeSqr = pointinfo.iStepSize * pointinfo.iStepSize;
// estimate total count of points
pointinfo.cPointMax = 1; // make sure it does not end up being zero
for (iStroke=0, glyph=pGlyph; glyph; glyph=glyph->next)
{
frame = glyph->frame;
if (!IsVisibleFRAME(frame))
continue;
rgXY = RgrawxyFRAME(frame);
cXY = CrawxyFRAME(frame);
ASSERT(cXY > 0);
sum = 0;
for (iXY=1; iXY<cXY; iXY++)
{
dx = rgXY[iXY].x - rgXY[iXY-1].x;
if (dx < 0)
dx = -dx;
dy = rgXY[iXY].y - rgXY[iXY-1].y;
if (dy < 0)
dy = -dy;
if (dx > dy)
sum += dx;
else
sum += dy;
}
//The sum that we are computing here is an underestimate--we are only taking the max on |x| or |y|.The distance will
// be more
pointinfo.cPointMax += sum/pointinfo.iStepSize;
// if not first stroke simulate pen-up stroke
if (iStroke)
{
dx = lastXY.x - rgXY->x;
dy = lastXY.y - rgXY->y;
t = ISqrt(dx*dx + dy*dy)/pointinfo.iStepSize;
if (t >= 2)
pointinfo.cPointMax += t-1;
}
lastXY = rgXY[cXY-1];
iStroke++;
}
//Since we have computed an underestimate multiply by two
pointinfo.cPointMax *= 2;
// allocate space
pointinfo.xy = (int *) ExternAlloc(2*pointinfo.cPointMax*sizeof(int));
if (!pointinfo.xy)
return 0;
//The array size for z is double of what actually needs to be allocated because-
//--the chebyshev function expects the array to be spaced in this manner
//--indexing is easier in the functions--can exactly mirror what you do for the x and y
pointinfo.z = (int *) ExternAlloc(2*pointinfo.cPointMax*sizeof(int));
if (!pointinfo.z)
{
ExternFree(pointinfo.xy);
return 0;
}
// join all strokes into one stream
pointinfo.cPoint = 0;
for (glyph=pGlyph; glyph; glyph=glyph->next)
{
frame = glyph->frame;
if (!IsVisibleFRAME(frame))
continue;
rgXY = RgrawxyFRAME(frame);
cXY = CrawxyFRAME(frame);
for (iXY = 0; iXY < cXY; iXY++)
if (!AddPoint(&pointinfo, rgXY[iXY].x, rgXY[iXY].y, !iXY))
{
retVal = 0;
goto freeReturn;
}
}
// contour features (computed from resampled raw points)
GetRectGLYPH(pGlyph, &rect);
//PLEASE NOTE--rgFeat is unsigned short.Its value comes from the lower 16 bits of the 16.16 format that had been defined earlier.
rgFeat += AddContourFeatures(&pointinfo, &rect, rgFeat);
//IS there any reason why the mean and the variance has been subtracted only AFTER the contour features ??Maybe because there we are dumping to a bit map ??
// compute X-mean and Y-mean
sumX = sumY = 0;
for (iPoint=0; iPoint<2*pointinfo.cPoint; iPoint+=2)
{
sumX += pointinfo.xy[iPoint] - rect.left;
sumY += pointinfo.xy[iPoint+1] - rect.top;
}
//isumX and isumY represent the mean values of the x and y coordinates.
isumX = (sumX / pointinfo.cPoint) + rect.left;
isumY = (sumY / pointinfo.cPoint) + rect.top;
// shift points by means
for (iPoint=0; iPoint<2*pointinfo.cPoint; iPoint+=2)
{
pointinfo.xy[iPoint] -= isumX;
pointinfo.xy[iPoint+1] -= isumY;
}
// compute variance
totvar = 0;
for (iPoint=0; iPoint<2*pointinfo.cPoint; iPoint++)
{
totvar += (double) pointinfo.xy[iPoint] * (double) pointinfo.xy[iPoint];
}
var = (int) sqrt(totvar/pointinfo.cPoint);
if (var < 1)
var = 1;
// scale points by standard deviation
// From this point on,the pointinfo values are in 16.16
//IMPORTTANT NOTE---THE pointinfo array is not directly used after this point
//If it is,you will have to use 16.16 arithmetic
for (iPoint=0; iPoint<2*pointinfo.cPoint; iPoint++)
{
pointinfo.xy[iPoint] = LSHFT(pointinfo.xy[iPoint])/var;
}
//Basically,since we effectively have a normal distribution(hopefully)most of the values will be between +-3.
// chebychev'ize!
if (!LSCheby(pointinfo.xy, pointinfo.cPoint, chbyX, XCHB))
{
retVal = 0;
goto freeReturn;
}
if (!LSCheby(pointinfo.xy+1, pointinfo.cPoint, chbyY, YCHB))
{
retVal = 0;
goto freeReturn;
}
if (!LSCheby(pointinfo.z, pointinfo.cPoint, chbyZ, ZCHB))
{
retVal = 0;
goto freeReturn;
}
NormalizeCheby(chbyX, chbyY, chbyZ, rgFeat);
rgFeat += 26;
// stroke count feature--1 feature is added
rgFeat += AddStrokeCountFeature(cStroke, rgFeat);
// guide features
//The rect had been comptured prior to scaling the points --by mean and standard deviation
//isumY represents the mean Y value
//We add 5 guide features
rgFeat += AddGuideFeatures(pGuide, &rect, isumY, rgFeat);
// curved-ness features
//Note the original glyph is being passed here
//Why not simply use the sampled points ??
rgFeat += AddCurveFeatures(pGlyph, pointinfo.iStepSizeSqr, rgFeat);
freeReturn:
ExternFree(pointinfo.xy);
ExternFree(pointinfo.z);
return retVal;
}
/*
void DumpFeatures (unsigned short *pFeat)
{
static int c = 0;
static FILE *fp = NULL;
int i, cMap;
if (!fp)
{
fp = fopen ("feat.dmp", "wt");
if (!fp)
return;
}
cMap = sizeof (s_aaMap) / sizeof (s_aaMap[0]);
for (i = 0; i < cMap; i++)
{
if (s_aaMap[i] == s_wch)
break;
}
if (i == cMap)
return;
fprintf (fp, "%d\t", i + 1);
for (i = 0; i < 65; i++)
{
fprintf (fp, "%d%c",
pFeat[i],
i == 64 ? '\n' : ' ');
}
fflush (fp);
c++;
}
*/
#pragma optimize("",off)
int SoleNN(SOLE_LOAD_INFO *pSole, int cStrk, unsigned short *pFeat, ALT_LIST *pAlt)
{
RREAL *pNetMem, *pNetOut;
int iWinner, cOut;
int i, j, k;
int *pIndex;
wchar_t *pwchMap;
pAlt->cAlt = -1;
if (cStrk == 1)
{
pNetMem = ExternAlloc(pSole->iNet1Size * sizeof (*pNetMem));
if (!pNetMem)
return -1;
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
pNetMem[i] = pFeat[i];
}
pNetOut = runLocalConnectNet(&pSole->net1, pNetMem, &iWinner, &cOut);
pwchMap = pSole->pMap1;
}
else
{
pNetMem = ExternAlloc(pSole->iNet2Size * sizeof (*pNetMem));
if (!pNetMem)
return -1;
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
pNetMem[i] = pFeat[i];
}
pNetOut = runLocalConnectNet(&pSole->net2, pNetMem, &iWinner, &cOut);
pwchMap = pSole->pMap2;
}
pIndex = ExternAlloc(sizeof(int) * cOut);
if (pIndex == NULL)
{
ExternFree(pNetMem);
return -1;
}
for (i = 0; i < cOut; i++)
{
pIndex[i] = i;
}
for (i = 0; i < MAX_ALT_LIST; i++)
{
for (j = i + 1; j < cOut; j++)
{
if (pNetOut[pIndex[i]] < pNetOut[pIndex[j]])
{
k = pIndex[i];
pIndex[i] = pIndex[j];
pIndex[j] = k;
}
}
if (pNetOut[pIndex[i]] == 0)
{
break;
}
pAlt->awchList[i] = pwchMap[pIndex[i]];
pAlt->aeScore[i] = (float) pNetOut[pIndex[i]] / (float) SOFT_MAX_UNITY;
}
//DumpFeatures (pFeat);
// If the following line is compiled with optimization turned on,
// the VS6 compiler goes into an infinite loop.
pAlt->cAlt = i;
ExternFree(pIndex);
ExternFree(pNetMem);
return pAlt->cAlt;
}
#pragma optimize("",on)
int SoleMatch(SOLE_LOAD_INFO *pSole,
ALT_LIST *pAlt, int cAlt, GLYPH *pGlyph, RECT *pGuide, CHARSET *pCS, LOCRUN_INFO * pLocRunInfo)
{
int cStrk;
unsigned short aiSoleFeat[SOLE_NUM_FEATURES];
cStrk = CframeGLYPH (pGlyph);
if (SoleFeaturize(pGlyph, pGuide, aiSoleFeat) != 1)
{
return -1;
}
return SoleNN (pSole, cStrk, aiSoleFeat, pAlt);
}
static void AddChar(wchar_t *pwchTop1, float *pflTop1, ALT_LIST *pAltList, wchar_t dch, float flProb,
LOCRUN_INFO *pLocRunInfo, CHARSET *pCS)
{
int j;
for (j = 0; j < (int) pAltList->cAlt; j++)
{
if (pAltList->awchList[j] == dch)
{
pAltList->aeScore[j] = flProb;
}
}
if (flProb > 0)
{
// Check whether the character (or folding set) passes the filter,
// if so see if it is the new top 1.
if (IsAllowedChar(pLocRunInfo, pCS, dch))
{
if (*pwchTop1 == 0xFFFE || flProb > *pflTop1)
{
*pflTop1 = flProb;
*pwchTop1 = dch;
}
}
}
}
int SoleMatchRescore(SOLE_LOAD_INFO *pSole,
wchar_t *pwchTop1, float *pflTop1,
ALT_LIST *pAltList, int cAlt, GLYPH *pGlyph, RECT *pGuide,
CHARSET *pCharSet, LOCRUN_INFO *pLocRunInfo)
{
int i;
int cStrk;
RREAL *pNetMem, *pNetOut;
int iWinner, cOut;
int j;
wchar_t *pwchMap;
unsigned short aiSoleFeat[SOLE_NUM_FEATURES];
// First set all the scores to zero. This is because some code points Fugu
// supports may not be supported by Sole. This implicitly says Sole gives
// them a score of zero.
for (j = 0; j < (int) pAltList->cAlt; j++)
{
pAltList->aeScore[j] = 0;
}
*pflTop1 = 0;
*pwchTop1 = 0xFFFE;
cStrk = CframeGLYPH (pGlyph);
if (SoleFeaturize (pGlyph, pGuide, aiSoleFeat) != 1)
{
return pAltList->cAlt;
}
if (cStrk == 1)
{
pNetMem = ExternAlloc(pSole->iNet1Size * sizeof (*pNetMem));
if (!pNetMem)
return -1;
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
pNetMem[i] = aiSoleFeat[i];
}
pNetOut = runLocalConnectNet(&pSole->net1, pNetMem, &iWinner, &cOut);
pwchMap = pSole->pMap1;
}
else
{
pNetMem = ExternAlloc(pSole->iNet2Size * sizeof (*pNetMem));
if (!pNetMem)
return -1;
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
pNetMem[i] = aiSoleFeat[i];
}
pNetOut = runLocalConnectNet(&pSole->net2, pNetMem, &iWinner, &cOut);
pwchMap = pSole->pMap2;
}
// This is the version for Fugu trained on dense codes, which will usually be
// what we use. Loops over the outputs
for (i = 0; i < cOut; i++)
{
wchar_t fdch = pwchMap[i];
float flProb = (float) pNetOut[i] / (float) SOFT_MAX_UNITY;
#if 1
AddChar(pwchTop1, pflTop1, pAltList, fdch, flProb, pLocRunInfo, pCharSet);
#else
if (LocRunIsFoldedCode(pLocRunInfo, fdch))
{
// If it is a folded code, look up the folding set
wchar_t *pFoldingSet = LocRunFolded2FoldingSet(pLocRunInfo, fdch);
// Run through the folding set, adding non-NUL items to the output list
// (until the output list is full)
for (j = 0; j < LOCRUN_FOLD_MAX_ALTERNATES && pFoldingSet[j] != 0; j++)
{
AddChar(pwchTop1, pflTop1, pAltList, pFoldingSet[j], flProb, pLocRunInfo, pCharSet);
}
}
else
{
AddChar(pwchTop1, pflTop1, pAltList, fdch, flProb, pLocRunInfo, pCharSet);
}
#endif
}
ExternFree(pNetMem);
return pAltList->cAlt;
}
BOOL SoleLoadPointer(SOLE_LOAD_INFO *pSole, LOCRUN_INFO *pLocRunInfo)
{
NNET_HEADER *pHeader;
NNET_SPACE_HEADER *apSpcHeader[2];
pHeader = (NNET_HEADER *) pSole->info.pbMapping;
// check version and signature
ASSERT (pHeader->dwFileType == SOLE_FILE_TYPE);
ASSERT (pHeader->iFileVer >= SOLE_OLD_FILE_VERSION);
ASSERT (pHeader->iMinCodeVer <= SOLE_CUR_FILE_VERSION);
ASSERT ( !memcmp ( pHeader->adwSignature,
g_locRunInfo.adwSignature,
sizeof (pHeader->adwSignature)
)
);
if (pHeader->dwFileType != SOLE_FILE_TYPE ||
pHeader->adwSignature[0] != pLocRunInfo->adwSignature[0] ||
pHeader->adwSignature[1] != pLocRunInfo->adwSignature[1] ||
pHeader->adwSignature[2] != pLocRunInfo->adwSignature[2] ||
pHeader->iFileVer < SOLE_OLD_FILE_VERSION ||
pHeader->iMinCodeVer > SOLE_CUR_FILE_VERSION)
{
return FALSE;
}
// # of spaces has to be two
ASSERT (pHeader->cSpace == 2);
apSpcHeader[0] =
(NNET_SPACE_HEADER *) (pSole->info.pbMapping + sizeof (NNET_HEADER));
apSpcHeader[1] =
(NNET_SPACE_HEADER *) ( pSole->info.pbMapping + sizeof (NNET_HEADER) +
sizeof (NNET_SPACE_HEADER));
if (restoreLocalConnectNet ( pSole->info.pbMapping + apSpcHeader[0]->iDataOffset,
0,
&pSole->net1
) == NULL
)
{
return FALSE;
}
if (restoreLocalConnectNet ( pSole->info.pbMapping + apSpcHeader[1]->iDataOffset,
0,
&pSole->net2
) == NULL
)
{
return FALSE;
}
pSole->iNet1Size =
getRunTimeNetMemoryRequirements(pSole->info.pbMapping + apSpcHeader[0]->iDataOffset);
pSole->iNet2Size =
getRunTimeNetMemoryRequirements(pSole->info.pbMapping + apSpcHeader[1]->iDataOffset);
pSole->pMap1 = (wchar_t *) (pSole->info.pbMapping + apSpcHeader[0]->iMapOffset);
pSole->pMap2 = (wchar_t *) (pSole->info.pbMapping + apSpcHeader[1]->iMapOffset);
return TRUE;
}
BOOL SoleLoadRes(SOLE_LOAD_INFO *pSole, HINSTANCE hInst, int nResID, int nType, LOCRUN_INFO *pLocRunInfo)
{
if (DoLoadResource(&pSole->info, hInst, nResID, nType) == NULL)
{
return FALSE;
}
return SoleLoadPointer(pSole, pLocRunInfo);
}
BOOL SoleLoadFile(SOLE_LOAD_INFO *pSole, wchar_t *wszRecogDir, LOCRUN_INFO *pLocRunInfo)
{
wchar_t wszName[MAX_PATH];
FormatPath(wszName, wszRecogDir, NULL, NULL, NULL, L"sole.bin");
if (DoOpenFile(&pSole->info, wszName) == NULL)
{
return FALSE;
}
return SoleLoadPointer(pSole, pLocRunInfo);
}
BOOL SoleUnloadFile(SOLE_LOAD_INFO *pSole)
{
return DoCloseFile(&pSole->info);
}
#if 0
BOOL SoleReject (int cStrk, wchar_t wchDense)
{
RREAL *pNetMem, *pNetOut;
int iWinner, cOut;
int i;
if (cStrk == 1)
{
pNetMem = _alloca(s_iSoleRejNetSize1 * sizeof (*pNetMem));
if (!pNetMem)
return FALSE;
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
pNetMem[i] = s_aSoleFeat[i];
}
pNetOut = runLocalConnectNet(&s_SoleRejNet1, pNetMem, &iWinner, &cOut);
ASSERT (cOut == SOLE_OUT_1);
return s_aaMap[0][iWinner] != LocRunDense2Unicode (&g_locRunInfo, wchDense);
}
else
{
pNetMem = _alloca(s_iSoleRejNetSize2 * sizeof (*pNetMem));
if (!pNetMem)
return FALSE;
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
pNetMem[i] = s_aSoleFeat[i];
}
pNetOut = runLocalConnectNet(&s_SoleRejNet2, pNetMem, &iWinner, &cOut);
ASSERT (cOut == SOLE_OUT_2);
return s_aaMap[1][iWinner] != LocRunDense2Unicode (&g_locRunInfo, wchDense);
}
}
extern wchar_t s_wch;
void SaveRecoInfo (wchar_t wch)
{
static FILE *fp = NULL;
if (!fp)
{
fp = fopen ("recores.txt", "wt");
if (!fp)
return;
}
fprintf (fp, "%d\n", wch == s_wch);
fflush (fp);
}
#define JAWS_ALT 10
int GetCharID (int cStrk, wchar_t wch)
{
int i, cClass;
cClass = (cStrk == 1 ? SOLE_OUT_1 : SOLE_OUT_2);
for (i = 0; i < cClass; i++)
{
if (s_aaMap[cStrk - 1][i] == wch)
return i;
}
return -1;
}
void SaveJAWSInfo (LATTICE *pLat)
{
static FILE *fpDisagree1 = NULL, *fpDisagree2 = NULL,
*fpSole1 = NULL, *fpSole2 = NULL;
FILE *fp, *fpSole;
int i, iWinningCand, iSoleBest, cAlt, j, cProbAlt, cStrk, cSoleOut, iClass;
LATTICE_ALT_LIST *pAlt;
int aSoleCost[JAWS_ALT];
wchar_t wch;
RECOG_ALT aProbAlt[JAWS_ALT];
BOXINFO box;
RECT bbox;
RECT rGuide;
GLYPH *pGlyph;
if (!pLat->fUseGuide)
return;
if (!fpDisagree1)
{
fpDisagree1 = fopen ("jawsdis1.txt", "wt");
if (!fpDisagree1)
return;
}
if (!fpDisagree2)
{
fpDisagree2 = fopen ("jawsdis2.txt", "wt");
if (!fpDisagree2)
return;
}
if (!fpSole1)
{
fpSole1 = fopen ("sole1.txt", "wt");
if (!fpSole1)
return;
}
if (!fpSole2)
{
fpSole2 = fopen ("sole2.txt", "wt");
if (!fpSole2)
return;
}
// find out if the right answer is in the list
iWinningCand =
iSoleBest = -1;
pAlt = pLat->pAltList + pLat->nStrokes - 1;
cAlt = pAlt->nUsed;
// This is a temporary call to get probs directly, until we have Hawk.
cProbAlt = GetProbsTsunami(pLat->nStrokes, pAlt, JAWS_ALT, aProbAlt);
// Convert strokes to GLYPHs and FRAMEs so that we can call the
// old code.
pGlyph = GlyphFromStrokes(pLat->nStrokes, pLat->pStroke);
if (!pGlyph)
{
return;
}
cStrk = pLat->nStrokes;
// Get the bounding box for the character
GetRectGLYPH(pGlyph, &bbox);
// Free the glyph structure.
DestroyFramesGLYPH(pGlyph);
DestroyGLYPH(pGlyph);
rGuide = GetGuideDrawnBox(&pLat->guide, pLat->pStroke[pLat->nStrokes - 1].iBox);
// Build up a BOXINFO structure from the guide, for use in the baseline/height scoring
box.size = rGuide.bottom - rGuide.top;
box.baseline = rGuide.bottom;
box.xheight = box.size / 2;
box.midline = box.baseline - box.xheight;
cSoleOut = (cStrk == 1 ? SOLE_OUT_1 : SOLE_OUT_2);
for (i = 0; i < cAlt && i < JAWS_ALT; i++)
{
wch = LocRunDense2Unicode(&g_locRunInfo, pAlt->alts[i].wChar);
if (wch == s_wch)
{
iWinningCand = i;
}
// sole cost
for (j = 0; j < cSoleOut; j++)
{
if (s_aaMap[cStrk -1][j] == wch)
{
break;
}
}
if (j == cSoleOut)
{
aSoleCost[i] = 0xFFFF;
}
else
{
aSoleCost[i] = (0xFFFF * s_aSoleOut[j]) / SOFT_MAX_UNITY;
aSoleCost[i] = 0xFFFF - aSoleCost[i];
}
if (iSoleBest == -1 || aSoleCost[iSoleBest] > aSoleCost[i])
{
iSoleBest = i;
}
}
for (i = cAlt; i < JAWS_ALT; i++)
{
aSoleCost[i] = 0xFFFF;
}
if (iWinningCand == -1)
return;
if (cStrk == 1)
{
fpSole = fpSole1;
}
else
{
fpSole = fpSole2;
}
// do not run if sole and otter agree
if (!SoleReject (cStrk, pAlt->alts[0].wChar))
{
return;
}
else
{
if (cStrk == 1)
{
fp = fpDisagree1;
}
else
{
fp = fpDisagree2;
}
}
fprintf (fp, "{ ");
// write the alternate features
for (i = 0; i < cAlt && i < JAWS_ALT; i++)
{
int iOttCost, iUni;
float fCost;
wch = LocRunDense2Unicode(&g_locRunInfo, pAlt->alts[i].wChar);
// otter cost
iOttCost = min (0xFFFF, (int)(-pAlt->alts[i].logProbPath * 1000));
fprintf (fp, "%d ", iOttCost);
// sole cost
fprintf (fp, "%d ", aSoleCost[i]);
// unigram cost
iUni = (int)(-255 * 100 * UnigramCost(&g_unigramInfo, pAlt->alts[i].wChar));
iUni = min (0xFFFF, iUni);
fprintf (fp, "%d ", iUni);
// baseline trans cost
fCost = BaselineTransitionCost(0, bbox, &box, pAlt->alts[i].wChar, bbox, &box);
fprintf (fp, "%d ", min (0xFFFF, (int) (-100000.0 * fCost)));
// base line cost
fCost = BaselineBoxCost(pAlt->alts[i].wChar, bbox, &box);
fprintf (fp, "%d ", min (0xFFFF, (int) (-100000.0 * fCost)));
// height trans cost
fCost = HeightTransitionCost(0, bbox, &box, pAlt->alts[i].wChar, bbox, &box);
fprintf (fp, "%d ", min (0xFFFF, (int) (-100000.0 * fCost)));
// height cost
fCost = HeightBoxCost(pAlt->alts[i].wChar, bbox, &box);
fprintf (fp, "%d ", min (0xFFFF, (int) (-100000.0 * fCost)));
// describe the codepoint
// is it a digit
if (wch >= L'0' && wch <= '9')
{
fprintf (fp, "65535 ");
}
else
{
fprintf (fp, "0 ");
}
// is alpha
if ((wch >= L'a' && wch <= 'z') || (wch >= L'A' && wch <= 'Z'))
{
fprintf (fp, "65535 ");
}
else
{
fprintf (fp, "0 ");
}
// is punct
if (iswpunct (wch))
{
fprintf (fp, "65535 ");
}
else
{
fprintf (fp, "0 ");
}
// is hiragana
if (wch >= 0x3040 && wch <= 0x309f)
{
fprintf (fp, "65535 ");
}
else
{
fprintf (fp, "0 ");
}
// is katakana
if (wch >= 0x30a0 && wch <= 0x30ff)
{
fprintf (fp, "65535 ");
}
else
{
fprintf (fp, "0 ");
}
// is kanji
if (wch >= 0x3190 && wch <= 0xabff)
{
fprintf (fp, "65535 ");
}
else
{
fprintf (fp, "0 ");
}
}
// the rest of the candidates
for (i = cAlt; i < JAWS_ALT; i++)
{
// otter cost
fprintf (fp, "%d ", 0xFFFF);
// sole cost
fprintf (fp, "%d ", 0xFFFF);
// unigram cost
fprintf (fp, "%d ", 0xFFFF);
// baseline trans cost
fprintf (fp, "%d ", 0xFFFF);
// baseline cost
fprintf (fp, "%d ", 0xFFFF);
// height trans cost
fprintf (fp, "%d ", 0xFFFF);
// height cost
fprintf (fp, "%d ", 0xFFFF);
// describe the codepoint
// digit
fprintf (fp, "0 ");
// is alpha
fprintf (fp, "0 ");
// is punct
fprintf (fp, "0 ");
// is hiragana
fprintf (fp, "0 ");
// is katakana
fprintf (fp, "0 ");
// is kanji
fprintf (fp, "0 ");
}
// write sole features for fpSole
if (iWinningCand != 0)
{
iClass = GetCharID (cStrk, s_wch);
if (iClass >= 0)
{
fprintf (fpSole, "{ ");
for (i = 0; i < SOLE_NUM_FEATURES; i++)
{
fprintf (fpSole, "%d ", s_aSoleFeat[i]);
}
fprintf (fpSole, "} { %d }\n", iClass);
fflush (fpSole);
}
}
fprintf (fp, "} { %d }\n", iWinningCand);
fflush (fp);
fflush (fpSole);
}
void RunJaws (LATTICE *pLat, HWXRESULTS *rgRes)
{
int i, iSoleBest, cAlt, j, cFeat, k, iWinningCand, iOttBest;
LATTICE_ALT_LIST *pAlt;
int aSoleCost[JAWS_ALT], aIdx[JAWS_ALT], iWinner, cOut, cStrk, cSoleOut;
wchar_t wch, awch[JAWS_ALT];
RREAL *pJawsNetMem, *pJawsNetOut;
float fCost;
BOXINFO box;
RECT bbox;
RECT rGuide;
GLYPH *pGlyph;
pJawsNetMem = _alloca(s_iJawsNetSize * sizeof (*pJawsNetMem));
if (!pJawsNetMem)
return;
// featurize for JAWS
iOttBest =
iWinningCand =
iSoleBest = -1;
pAlt = pLat->pAltList + pLat->nStrokes - 1;
cAlt = pAlt->nUsed;
// Convert strokes to GLYPHs and FRAMEs so that we can call the
// old code.
pGlyph = GlyphFromStrokes(pLat->nStrokes, pLat->pStroke);
if (!pGlyph)
{
return;
}
cStrk = CframeGLYPH (pGlyph);
// do not run if sole/reject and otter agree
if (!SoleReject (cStrk, pAlt->alts[0].wChar))
return;
// Get the bounding box for the character
GetRectGLYPH(pGlyph, &bbox);
// Free the glyph structure.
DestroyFramesGLYPH(pGlyph);
DestroyGLYPH(pGlyph);
rGuide = GetGuideDrawnBox(&pLat->guide, pLat->pStroke[pLat->nStrokes - 1].iBox);
// Build up a BOXINFO structure from the guide, for use in the baseline/height scoring
box.size = rGuide.bottom - rGuide.top;
box.baseline = rGuide.bottom;
box.xheight = box.size / 2;
box.midline = box.baseline - box.xheight;
cSoleOut = (cStrk == 1 ? SOLE_OUT_1 : SOLE_OUT_2);
for (i = 0; i < cAlt && i < JAWS_ALT; i++)
{
wch = LocRunDense2Unicode(&g_locRunInfo, pAlt->alts[i].wChar);
if (wch == s_wch)
{
iWinningCand = i;
}
// sole cost
for (j = 0; j < cSoleOut; j++)
{
if (s_aaMap[cStrk - 1][j] == wch)
{
break;
}
}
if (j == cSoleOut)
{
aSoleCost[i] = 0xFFFF;
}
else
{
aSoleCost[i] = (0xFFFF * s_aSoleOut[j]) / SOFT_MAX_UNITY;
aSoleCost[i] = 0xFFFF - aSoleCost[i];
}
if (iSoleBest == -1 || aSoleCost[iSoleBest] > aSoleCost[i])
{
iSoleBest = i;
}
if (iOttBest == -1 || pAlt->alts[iOttBest].logProbPath < pAlt->alts[i].logProbPath)
{
iOttBest = i;
}
}
for (i = cAlt; i < JAWS_ALT; i++)
{
aSoleCost[i] = 0xFFFF;
}
// for all candidates
cFeat = 0;
for (i = 0; i < cAlt && i < JAWS_ALT; i++)
{
int iOttCost, iUni;
wch = LocRunDense2Unicode(&g_locRunInfo, pAlt->alts[i].wChar);
// otter cost
iOttCost = min (0xFFFF, (int)(-pAlt->alts[i].logProb * 1000));
pJawsNetMem[cFeat++] = iOttCost;
// sole cost
pJawsNetMem[cFeat++] = aSoleCost[i];
// unigram cost
iUni = (int)(-255 * 100 * UnigramCost(&g_unigramInfo, pAlt->alts[i].wChar));
pJawsNetMem[cFeat++] = iUni;
// baseline trans cost
fCost = BaselineTransitionCost(0, bbox, &box, pAlt->alts[i].wChar, bbox, &box);
pJawsNetMem[cFeat++] = min (0xFFFF, (int) (-100000.0 * fCost));
// base line cost
fCost = BaselineBoxCost(pAlt->alts[i].wChar, bbox, &box);
pJawsNetMem[cFeat++] = min (0xFFFF, (int) (-100000.0 * fCost));
// height trans cost
fCost = HeightTransitionCost(0, bbox, &box, pAlt->alts[i].wChar, bbox, &box);
pJawsNetMem[cFeat++] = min (0xFFFF, (int) (-100000.0 * fCost));
// height cost
fCost = HeightBoxCost(pAlt->alts[i].wChar, bbox, &box);
pJawsNetMem[cFeat++] = min (0xFFFF, (int) (-100000.0 * fCost));
// describe the codepoint
// digit
if (wch >= L'0' && wch <= '9')
{
pJawsNetMem[cFeat++] = 65535;
}
else
{
pJawsNetMem[cFeat++] = 0;
}
// is alpha
if ((wch >= L'a' && wch <= 'z') || (wch >= L'A' && wch <= 'Z'))
{
pJawsNetMem[cFeat++] = 65535;
}
else
{
pJawsNetMem[cFeat++] = 0;
}
// is punct
if (iswpunct (wch))
{
pJawsNetMem[cFeat++] = 65535;
}
else
{
pJawsNetMem[cFeat++] = 0;
}
// is hiragana
if (wch >= 0x3040 && wch <= 0x309f)
{
pJawsNetMem[cFeat++] = 65535;
}
else
{
pJawsNetMem[cFeat++] = 0;
}
// is katakana
if (wch >= 0x30a0 && wch <= 0x30ff)
{
pJawsNetMem[cFeat++] = 65535;
}
else
{
pJawsNetMem[cFeat++] = 0;
}
// is kanji
if (wch >= 0x3190 && wch <= 0xabff)
{
pJawsNetMem[cFeat++] = 65535;
}
else
{
pJawsNetMem[cFeat++] = 0;
}
}
// the rest of the candidates
for (i = cAlt; i < JAWS_ALT; i++)
{
// otter cost
pJawsNetMem[cFeat++] = 65535;
// sole cost
pJawsNetMem[cFeat++] = 65535;
// unigram cost
pJawsNetMem[cFeat++] = 65535;
// baseline trans cost
pJawsNetMem[cFeat++] = 65535;
// baseline cost
pJawsNetMem[cFeat++] = 65535;
// height trans cost
pJawsNetMem[cFeat++] = 65535;
// height cost
pJawsNetMem[cFeat++] = 65535;
// describe the codepoint
// digit
pJawsNetMem[cFeat++] = 0;
// is alpha
pJawsNetMem[cFeat++] = 0;
// is punct
pJawsNetMem[cFeat++] = 0;
// is hiragana
pJawsNetMem[cFeat++] = 0;
// is katakana
pJawsNetMem[cFeat++] = 0;
// is kanji
pJawsNetMem[cFeat++] = 0;
}
// call the JAWS net
pJawsNetOut = runLocalConnectNet(&s_JawsNet, pJawsNetMem, &iWinner, &cOut);
ASSERT (cOut == JAWS_ALT);
// index the result
for (i = 0; i < JAWS_ALT; i++)
{
aIdx[i] = i;
}
for (i = 0; i < JAWS_ALT; i++)
{
for (j = i + 1; j < JAWS_ALT; j++)
{
if (pJawsNetOut[aIdx[i]] < pJawsNetOut[aIdx[j]])
{
k = aIdx[i];
aIdx[i] = aIdx[j];
aIdx[j] = k;
}
}
awch[i] = pAlt->alts[aIdx[i]].wChar;
}
for (i = 0; i < cAlt && i < JAWS_ALT; i++)
{
rgRes->rgChar[i] = LocRunDense2Unicode(&g_locRunInfo, awch[i]);
}
}
#endif
#if 0
LOCAL_NET *LoadNet(void *pData, int *piNetSize, LOCAL_NET *pNet)
{
if ( !pData || !(pNet = restoreLocalConnectNet(pData, 0, pNet)) )
{
return NULL;
}
(*piNetSize) = getRunTimeNetMemoryRequirements(pData);
if ((*piNetSize) <= 0)
{
return NULL;
}
return pNet;
}
BOOL LoadSoleFromFile(wchar_t *pwszPath)
{
BYTE *pData;
wchar_t aPath[128];
HANDLE hFile, hMap;
// Generate path to file. By passing in name as "locale" we can get FormatPath
// to do what we want.
wsprintf (aPath, L"%s\\sole1.bin", pwszPath);
// Try to open the file.
hFile = CreateMappingCall (aPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// Create a mapping handle
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMap == NULL)
{
return FALSE;
}
// Map the entire file starting at the first byte
pData = (void *) MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (pData == NULL)
{
return FALSE;
}
// Sole net
if (!LoadNet(pData, &s_iSoleNetSize1, &s_SoleNet1))
{
return FALSE;
}
// Generate path to file. By passing in name as "locale" we can get FormatPath
// to do what we want.
wsprintf (aPath, L"%s\\sole2.bin", pwszPath);
// Try to open the file.
hFile = CreateMappingCall (aPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// Create a mapping handle
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMap == NULL)
{
return FALSE;
}
// Map the entire file starting at the first byte
pData = (void *) MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (pData == NULL)
{
return FALSE;
}
// Sole net
if (!LoadNet(pData, &s_iSoleNetSize2, &s_SoleNet2))
{
return FALSE;
}
// Generate path to file. By passing in name as "locale" we can get FormatPath
// to do what we want.
wsprintf (aPath, L"%s\\solerej1.bin", pwszPath);
// Try to open the file.
hFile = CreateMappingCall (aPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// Create a mapping handle
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMap == NULL)
{
return FALSE;
}
// Map the entire file starting at the first byte
pData = (void *) MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (pData == NULL)
{
return FALSE;
}
// Sole net
if (!LoadNet(pData, &s_iSoleRejNetSize1, &s_SoleRejNet1))
{
return FALSE;
}
// Generate path to file. By passing in name as "locale" we can get FormatPath
// to do what we want.
wsprintf (aPath, L"%s\\solerej2.bin", pwszPath);
// Try to open the file.
hFile = CreateMappingCall (aPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// Create a mapping handle
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMap == NULL)
{
return FALSE;
}
// Map the entire file starting at the first byte
pData = (void *) MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (pData == NULL)
{
return FALSE;
}
// Sole net
if (!LoadNet(pData, &s_iSoleRejNetSize2, &s_SoleRejNet2))
{
return FALSE;
}
return TRUE;
}
#endif
#if 0
BOOL LoadJawsFromFile(wchar_t *pwszPath)
{
BYTE *pData;
wchar_t aPath[128];
HANDLE hFile, hMap;
// Generate path to file. By passing in name as "locale" we can get FormatPath
// to do what we want.
wsprintf (aPath, L"%s\\jaws.bin", pwszPath);
// Try to open the file.
hFile = CreateMappingCall (aPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// Create a mapping handle
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMap == NULL)
{
return FALSE;
}
// Map the entire file starting at the first byte
pData = (void *) MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (pData == NULL)
{
return FALSE;
}
// Jaws net
if (!LoadNet(pData, &s_iJawsNetSize, &s_JawsNet))
{
return FALSE;
}
return TRUE;
}
#endif