able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/tpg/hwx/volcano/dll/charrec.c

1796 lines
50 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//
// Copyright (c) 2001 Microsoft Corporation. All rights reserved.
//
// Module:
// volcano/dll/CharRec.c
//
// Description:
// Main sequencing code to recognize one character ignoring
// size and position.
//
// Author:
// hrowley
//
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
#include "volcanop.h"
#include "frame.h"
#include "glyph.h"
#if defined(USE_HOUND) || defined(USE_ZILLAHOUND)
# include "math16.h"
# include "hound.h"
# include "zillatool.h"
#endif
#ifndef USE_OLD_DATABASES
# include "hawk.h"
#endif
#ifdef USE_RESOURCES
# include "res.h"
#endif
//#define OPTIMAL_OTTER_ZILLA
// Uncomment this to enable use of the old tsunami-style computation
// (using OtterMatch & ZillaMatch instead of OtterMatch2 & ZillaMatch2,
// and index the prob table by codepoint instead of prototype number).
//#define USE_OLD_DATABASES
/////////////////////////////////////////////////////////////////////////
// Hack code for probabilities, this will go away once Hawk works.
#include "probHack.h"
PROB_HEADER *g_pProbHeader = 0;
#define EntryPtr(i) \
(PROB_ENTRY *)(((BYTE *)g_pProbHeader) + g_pProbHeader->aEntryOffset[i])
#define AltPtr(i) \
(PROB_ALT *)(((BYTE *)g_pProbHeader) + g_pProbHeader->aAltOffset[i])
void ProbLoadPointer(void * pData)
{
BYTE *pScan = (BYTE *)pData;
g_pProbHeader = (PROB_HEADER *)pScan;
pScan += sizeof(PROB_HEADER);
}
#ifdef USE_RESOURCES
BOOL ProbLoadRes(
HINSTANCE hInst,
int resNumber,
int resType
) {
BYTE *pByte;
// Load the prob database
pByte = DoLoadResource(NULL, hInst, resNumber, resType);
if (!pByte) {
return FALSE;
}
ProbLoadPointer(pByte);
return TRUE;
}
#else
BOOL ProbLoadFile(wchar_t *pPath, LOAD_INFO *pInfo)
{
HANDLE hFile, hMap;
BYTE *pByte;
wchar_t aFile[128];
pInfo->hFile = INVALID_HANDLE_VALUE;
pInfo->hMap = INVALID_HANDLE_VALUE;
pInfo->pbMapping = INVALID_HANDLE_VALUE;
// Generate path to file.
FormatPath(aFile, pPath, (wchar_t *)0, (wchar_t *)0, (wchar_t *)0, L"prob.bin");
// Map the file
hFile = CreateMappingCall(
aFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hFile == INVALID_HANDLE_VALUE)
{
ASSERT(("Error in CreateMappingCall - prob", FALSE));
goto error1;
}
// Create a mapping handle
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMap == NULL)
{
ASSERT(("Error in CreateFileMapping - prob", FALSE));
goto error2;
}
// Map the entire file starting at the first byte
pByte = (LPBYTE) MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (pByte == NULL) {
ASSERT(("Error in MapViewOfFile - prob", FALSE));
goto error3;
}
// Extract info from mapped data.
ProbLoadPointer((void *)pByte);
// Save away the pointers so we can close up cleanly later
pInfo->hFile = hFile;
pInfo->hMap = hMap;
pInfo->pbMapping = pByte;
return TRUE;
// Error handling
error3:
CloseHandle(hMap);
hMap = INVALID_HANDLE_VALUE;
error2:
CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
error1:
return FALSE;
}
BOOL ProbUnLoadFile(LOAD_INFO *pInfo)
{
if (pInfo->hFile == INVALID_HANDLE_VALUE ||
pInfo->hMap == INVALID_HANDLE_VALUE ||
pInfo->pbMapping == INVALID_HANDLE_VALUE) {
return FALSE;
}
UnmapViewOfFile(pInfo->pbMapping);
CloseHandle(pInfo->hMap);
CloseHandle(pInfo->hFile);
pInfo->pbMapping = INVALID_HANDLE_VALUE;
pInfo->hMap = INVALID_HANDLE_VALUE;
pInfo->hFile = INVALID_HANDLE_VALUE;
return TRUE;
}
#endif
// Given an alt list with dense and possibly folded codes in it, run through it
// and expand the folded lists. The unfolded alt list is returned in place.
// This function assumes that the list begins with better alternates, as those
// later in the list will get dropped if we run out of space.
void UnfoldCodes(ALT_LIST *pAltList, CHARSET *cs)
{
int i, cOut=0;
ALT_LIST newAltList; // This will be where the new alt list is constructed.
// For each alternate in the input list and while we have space in the output list
for (i=0; i<(int)pAltList->cAlt && (int)cOut<MAX_ALT_LIST; i++) {
// Check if the alternate is a folded coded
if (LocRunIsFoldedCode(&g_locRunInfo,pAltList->awchList[i])) {
int kndex;
// If it is a folded code, look up the folding set
wchar_t *pFoldingSet = LocRunFolded2FoldingSet(&g_locRunInfo, pAltList->awchList[i]);
// Run through the folding set, adding non-NUL items to the output list
// (until the output list is full)
for (kndex = 0;
kndex < LOCRUN_FOLD_MAX_ALTERNATES && pFoldingSet[kndex] != 0 && (int)cOut<MAX_ALT_LIST;
kndex++) {
if (IsAllowedChar(&g_locRunInfo, cs, pFoldingSet[kndex]))
{
newAltList.awchList[cOut]=pFoldingSet[kndex];
newAltList.aeScore[cOut]=pAltList->aeScore[i];
cOut++;
#ifdef DISABLE_UNFOLDING
// If unfolding is disabled, then stop after producing one unfolded code.
// This way we don't push results later in the alt list out of the alt
// list, while still allowing the recognizer to return unicodes for each
// alternate.
break;
#endif
}
}
} else {
// Dense codes that are not folded get added directly
newAltList.awchList[cOut]=pAltList->awchList[i];
newAltList.aeScore[cOut]=pAltList->aeScore[i];
cOut++;
}
}
// Store the length of the output list
newAltList.cAlt=cOut;
// Copy the output list over the input.
*pAltList=newAltList;
}
#ifdef USE_OLD_DATABASES
// Used for WinCE
// Given a feature space (cFrame), an alt list, and a requested number of alts, this
// function returns a new alt list with probabilities for each alternate. It uses a
// fixed prob distribution.
int GetProbsTsunamiFixedTable(
int cFrame,
ALT_LIST *pAltList,
int maxAlts,
RECOG_ALT *pRAlts,
CHARSET *pCS
) {
int rank = 0;
FLOAT rankScore = pAltList->aeScore[0];
int cAlt;
int iDest = 0;
for (cAlt = 0; cAlt < (int) pAltList->cAlt && iDest < maxAlts; ++cAlt)
{
if (pAltList->aeScore[cAlt] != rankScore)
{
rank ++;
rankScore = pAltList->aeScore[cAlt];
}
if (IsAllowedChar(&g_locRunInfo, pCS, pAltList->awchList[cAlt]))
{
int count;
switch (rank) {
case 0:
count = 141125;
break;
case 1:
count = 6090;
break;
case 2:
count = 957;
break;
case 3:
count = 362;
break;
case 4:
count = 161;
break;
case 5:
count = 82;
break;
case 6:
count = 66;
break;
case 7:
count = 49;
break;
case 8:
count = 36;
break;
case 9:
count = 34;
break;
default:
count = 10;
break;
}
pRAlts[iDest].wch = pAltList->awchList[cAlt];
pRAlts[iDest].prob = 65535*(float)count/(float)149903;
iDest++;
}
}
return iDest;
}
// Desktop
// Given a feature space (cFrame), an alt list, and a requested number of alts, this
// function returns a new alt list with probabilities for each alternate. The version
// called GetProbs in this file does the lookup by prototype number, whereas this version
// does lookups by code point (like the code in Tsunami). Note that the alt list passed
// in will get modified.
int GetProbsTsunami(
int cFrame,
ALT_LIST *pAltList,
int maxAlts,
RECOG_ALT *pRAlts,
CHARSET *pCS
) {
unsigned int cAlt;
int ii;
int iDest = 0;
PROB_ENTRY *pEntries, *pEntriesStart, *pEntriesEnd;
PROB_ALT *pAlts, *pAltsStart, *pAltsEnd;
// If we didn't get any alternates, return an empty list.
if (pAltList->cAlt == 0) {
return 0;
}
// If the probability table was not loaded, just return the top one candidate.
// This is useful for training the prob table.
if (g_pProbHeader==NULL) {
pRAlts[0].wch=pAltList->awchList[0];
pRAlts[0].prob=MAX_PROB;
return 1;
}
// ASSERT(1 <= cFrame && cFrame < 30);
ASSERT(1 <= cFrame);
if (cFrame >= 30) {
// Can't handle this many strokes.
goto fakeIt;
}
// Hack for U+307A/U+30DA, which probably haven't had their probs set up right
/* if (LocRunDense2Unicode(&g_locRunInfo,pAltList->awchList[0])==0x307A ||
LocRunDense2Unicode(&g_locRunInfo,pAltList->awchList[0])==0x30DA) {
pRAlts[0].wch = LocRunUnicode2Dense(&g_locRunInfo,0x30DA);
pRAlts[0].prob = MAX_PROB;
pRAlts[1].wch = LocRunUnicode2Dense(&g_locRunInfo,0x307A);
pRAlts[1].prob = MAX_PROB;
return 2;
} */
pEntriesStart = EntryPtr(cFrame - 1);
pEntriesEnd = EntryPtr(cFrame);
pAltsStart = AltPtr(cFrame - 1);
pAltsEnd = AltPtr(cFrame);
// Scan until we find an alt that has a prob list.
// Normally we stop on the first one, but sometimes
// We had no train data to cause a prototype to come
// up top one.
for (cAlt = 0; cAlt < pAltList->cAlt; ++cAlt) {
// Get char to look up.
// wchar_t wch = LocRunDense2Unicode(&g_locRunInfo,pAltList->awchList[cAlt]);
wchar_t wch = pAltList->awchList[cAlt];
pAlts = pAltsStart;
for (pEntries = pEntriesStart; pEntries < pEntriesEnd; ++pEntries) {
if (pEntries->wch == wch) {
// copy results out.
for (ii = 0; ii < pEntries->cAlts && iDest < maxAlts; ++ii) {
if (IsAllowedChar(&g_locRunInfo, pCS, pAlts->wchAlt))
{
pRAlts[iDest].wch = pAlts->wchAlt;
pRAlts[iDest].prob = pAlts->prob;
iDest++;
}
++pAlts;
}
return iDest;
}
pAlts += pEntries->cAlts;
}
}
fakeIt:
// Fake something up.
pRAlts[0].wch = pAltList->awchList[0];
pRAlts[0].prob = MAX_PROB;
// fprintf(stderr,"Returning no alts\n");
// exit(1);
return 1;
}
#endif
// USE_OLD_DATABASES
// End of hacked Prob code.
////////////////////////////////////////////////////////////////////////
BOOL g_fUseJaws;
JAWS_LOAD_INFO g_JawsLoadInfo;
FUGU_LOAD_INFO g_FuguLoadInfo;
SOLE_LOAD_INFO g_SoleLoadInfo;
BOOL g_fUseZillaHound;
#ifdef USE_RESOURCES
#include "res.h"
// Code to load and initialize the databases used.
// They are loaded in this order: otter, zilla, crane/prob or hawk,
BOOL LoadCharRec(HINSTANCE hInstanceDll)
{
BOOL fError = FALSE;
if (JawsLoadRes(&g_JawsLoadInfo, hInstanceDll, RESID_JAWS, VOLCANO_RES))
{
// Now we need to load the databases that will be combined by this combiner
// Load the Fugu database
if (!fError && !FuguLoadRes(&g_FuguLoadInfo, hInstanceDll, RESID_FUGU, VOLCANO_RES, &g_locRunInfo))
{
fError = TRUE;
ASSERT(("Error in FuguLoadRes", FALSE));
}
// Load the Sole database
if (!fError && !SoleLoadRes(&g_SoleLoadInfo, hInstanceDll, RESID_SOLE, VOLCANO_RES, &g_locRunInfo))
{
fError = TRUE;
ASSERT(("Error loading sole", FALSE));
}
g_fUseJaws = TRUE;
}
else
{
// Load the Otter database
if (!fError && !OtterLoadRes(hInstanceDll, RESID_OTTER, VOLCANO_RES, &g_locRunInfo))
{
fError = TRUE;
ASSERT(("Error in OtterLoadRes", FALSE));
}
g_fUseJaws = FALSE;
}
#if defined(USE_ZILLA) || defined(USE_ZILLAHOUND)
// Load the Zilla database
if (!fError && !ZillaLoadResource(
hInstanceDll, RESID_ZILLA, VOLCANO_RES, RESID_COSTCALC,
VOLCANO_RES, RESID_GEOSTAT, VOLCANO_RES, &g_locRunInfo
)) {
fError = TRUE;
ASSERT(("Error in ZillaLoadResource", FALSE));
}
#endif
#if defined(USE_HOUND)
// Load the Hound database (Hound only, require it to load)
if (!fError && !HoundLoadRes(hInstanceDll, RESID_HOUND, VOLCANO_RES, &g_locRunInfo)) {
fError = TRUE;
ASSERT(("Error in HoundLoadRes", FALSE));
}
#endif
g_fUseZillaHound = FALSE;
#if defined(USE_ZILLAHOUND)
if (!fError) {
// Load the Hound & Hound-Zilla databases (This is optional).
if (HoundLoadRes(hInstanceDll, RESID_HOUND, VOLCANO_RES, &g_locRunInfo)) {
if (ZillaHoundLoadRes(hInstanceDll, RESID_ZILLA_HOUND, VOLCANO_RES)) {
g_fUseZillaHound = TRUE;
}
}
}
#endif
// Load the Hawk database.
#ifndef USE_OLD_DATABASES
if (!fError && !HawkLoadRes(
hInstanceDll, RESID_HAWK, VOLCANO_RES, &g_locRunInfo
)) {
fError = TRUE;
ASSERT(("Error in HawkLoadRes", FALSE));
}
#else
if (!fError && !CraneLoadRes(hInstanceDll,RESID_CRANE,VOLCANO_RES,&g_locRunInfo)) {
fError=TRUE;
ASSERT(("Error in CraneLoadRes", FALSE));
}
// Load hack probability code until we switch over to hawk.
// Use hawks resID so we don't have to create an extra one.
#if !defined(WINCE) && !defined(FAKE_WINCE)
if (!fError && !ProbLoadRes(
hInstanceDll, RESID_HAWK, VOLCANO_RES
)) {
// Failing to load this is no longer an error,
// just fall back on the WinCE method.
// fError = TRUE;
// ASSERT(("Error in ProbLoadRes", FALSE));
}
#endif
#endif
// Did everything load correctly?
if (fError) {
// JBENN: If the databases can ever be unloaded, this is
// a place the need to.
// JBENN: FIXME: Set correct error code base on what really went wrong.
SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
//SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
//SetLastError(ERROR_RESOURCE_TYPE_NOT_FOUND);
//SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
return TRUE;
}
// Code to unload the databases used.
BOOL
UnloadCharRec()
{
BOOL retVal;
retVal = TRUE;
// Free hound up.
# if defined(USE_HOUND)
if (!HoundUnLoadRes())
{
retVal = FALSE;
}
# endif
# if defined(USE_ZILLAHOUND)
if (g_fUseZillaHound && !HoundUnLoadRes())
{
retVal = FALSE;
}
# endif
if (!ZillaUnloadResource())
{
retVal = FALSE;
}
return retVal;
}
# else
// Global load information specific to loading from files.
#if defined(USE_OTTER) || defined(USE_OTTERFUGU)
OTTER_LOAD_INFO g_OtterLoadInfo;
#endif
#if defined(USE_HOUND) || defined(USE_ZILLAHOUND)
LOAD_INFO g_HoundLoadInfo;
#endif
#ifdef USE_OLD_DATABASES
LOAD_INFO g_ProbLoadInfo;
CRANE_LOAD_INFO g_CraneLoadInfo;
#else
LOAD_INFO g_HawkLoadInfo;
#endif
// Code to load and initialize the databases used.
BOOL LoadCharRec(wchar_t *pPath)
{
BOOL fError = FALSE;
if (JawsLoadFile(&g_JawsLoadInfo, pPath))
{
// Load the Fugu database
if (!fError && !FuguLoadFile(&g_FuguLoadInfo, pPath, &g_locRunInfo)) {
fError = TRUE;
ASSERT(("Error in FuguLoadFile", FALSE));
}
// Load the Sole database
if (!fError && !SoleLoadFile(&g_SoleLoadInfo, pPath, &g_locRunInfo)) {
fError = TRUE;
ASSERT(("Error in FuguLoadFile", FALSE));
}
g_fUseJaws = TRUE;
}
else
{
// Load the Otter database
if (!fError && !OtterLoadFile(&g_locRunInfo, &g_OtterLoadInfo, pPath)) {
fError = TRUE;
ASSERT(("Error in OtterLoadFile", FALSE));
}
g_fUseJaws = FALSE;
}
#if defined(USE_ZILLA) || defined(USE_ZILLAHOUND)
// Load the Zilla database
if (!fError && !ZillaLoadFile(&g_locRunInfo, pPath, TRUE)) {
fError = TRUE;
ASSERT(("Error in ZillaLoadFile", FALSE));
}
#endif
#if defined(USE_HOUND)
// Load the Hound database (Hound only, require it to load)
if (!fError && !HoundLoadFile(&g_locRunInfo, &g_HoundLoadInfo, pPath)) {
fError = TRUE;
ASSERT(("Error in HoundLoadFile", FALSE));
}
#endif
g_fUseZillaHound = FALSE;
#if defined(USE_ZILLAHOUND)
if (!fError) {
// Load the Hound & Hound-Zilla databases (This is optional).
if (HoundLoadFile(&g_locRunInfo, &g_HoundLoadInfo, pPath)) {
if (ZillaHoundLoadFile(pPath)) {
g_fUseZillaHound = TRUE;
}
else
{
# ifndef TRAIN_ZILLA_HOUND_COMBINER
HoundUnLoadFile(&g_HoundLoadInfo);
# endif
}
}
}
#endif
#ifndef USE_OLD_DATABASES
// Load the Hawk database.
if (!fError && !HawkLoadFile(&g_locRunInfo, &g_HawkLoadInfo, pPath)) {
fError = TRUE;
ASSERT(("Error in HawkLoadFile", FALSE));
}
#else
#if !defined(WINCE) && !defined(FAKE_WINCE)
// Load hack probability code until we switch over to hawk.
if (!fError && !ProbLoadFile(pPath, &g_ProbLoadInfo)) {
// Failing to load this is no longer an error,
// just fall back on the WinCE method.
// fError = TRUE;
// ASSERT(("Error in ProbLoadFile", FALSE));
}
#endif
if (!fError && !CraneLoadFile(&g_locRunInfo,&g_CraneLoadInfo, pPath)) {
fError = TRUE;
ASSERT(("Error in CraneLoadFile", FALSE));
}
#endif
// Did everything load correctly?
if (fError) {
// JBENN: If the databases can ever be unloaded, this is
// a place the need to.
// JBENN: FIXME: Set correct error code base on what really went wrong.
SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
//SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
//SetLastError(ERROR_RESOURCE_TYPE_NOT_FOUND);
//SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
return TRUE;
}
// Code to unload the databases used.
BOOL
UnloadCharRec()
{
BOOL ok = TRUE;
if (g_fUseJaws)
{
if (!SoleUnloadFile(&g_SoleLoadInfo)) ok = FALSE;
if (!FuguUnLoadFile(&g_FuguLoadInfo)) ok = FALSE;
if (!JawsUnloadFile(&g_JawsLoadInfo)) ok = FALSE;
}
else
{
if (!OtterUnLoadFile(&g_OtterLoadInfo)) ok = FALSE;
}
# if defined(USE_HOUND)
if (!HoundUnLoadFile(&g_HoundLoadInfo))
{
ok = FALSE;
}
# endif
# if defined(USE_ZILLAHOUND)
if (g_fUseZillaHound)
{
if (!ZillaHoundUnloadFile())
{
ok = FALSE;
}
if (!HoundUnLoadFile(&g_HoundLoadInfo))
{
ok = FALSE;
}
}
# endif
if (!ZillaUnLoadFile()) ok = FALSE;
# ifdef USE_OLD_DATABASES
if (!CraneUnLoadFile(&g_CraneLoadInfo)) ok = FALSE;
# if !defined(WINCE) && !defined(FAKE_WINCE)
if (g_pProbHeader != NULL && !ProbUnLoadFile(&g_ProbLoadInfo)) ok = FALSE;
# endif
# else // USE_OLD_DATABASES
if (!HawkUnLoadFile(&g_HawkLoadInfo)) ok = FALSE;
# endif // USE_OLD_DATABASES
return ok;
}
#endif
// Limit on strokes that can be processed by a recognizer. Since
// Zilla ignores anything beyond 29 strokes, it is safe to ignore
// any extra.
#define MAX_STOKES_PROCESS 30
POINT *DupPoints(POINT *pOldPoints, int nPoints);
GLYPH *GlyphFromStrokes(UINT cStrokes, STROKE *pStrokes);
#ifndef USE_RESOURCES
// Build a copy of the glyph structure.
GLYPH *CopyGlyph(GLYPH *pOldGlyph)
{
GLYPH *pGlyph = NULL, *pLastGlyph = NULL;
// Convert strokes to GLYPHs and FRAMEs so that we can call the
// old code.
while (pOldGlyph != NULL) {
GLYPH *pGlyphCur;
// Alloc glyph.
pGlyphCur = NewGLYPH();
if (!pGlyphCur) {
goto error;
}
// Add to list, and alloc frame
if (pLastGlyph != NULL) {
pLastGlyph->next = pGlyphCur;
pLastGlyph = pGlyphCur;
} else {
pGlyph = pGlyphCur;
pLastGlyph = pGlyphCur;
}
pGlyphCur->next = NULL;
pGlyphCur->frame = NewFRAME();
if (!pGlyphCur->frame) {
goto error;
}
// Fill in frame. We just fill in what we need, and ignore
// fields not used by Otter and Zilla, or are set by them.
pGlyphCur->frame->info.cPnt = pOldGlyph->frame->info.cPnt;
pGlyphCur->frame->info.wPdk = pOldGlyph->frame->info.wPdk;
pGlyphCur->frame->rgrawxy = DupPoints(pOldGlyph->frame->rgrawxy, pOldGlyph->frame->info.cPnt);
pGlyphCur->frame->rect = pOldGlyph->frame->rect;
pGlyphCur->frame->iframe = pOldGlyph->frame->iframe;
if (pGlyphCur->frame->rgrawxy == NULL) {
goto error;
}
pOldGlyph = pOldGlyph->next;
}
return pGlyph;
error:
// Cleanup glyphs on error.
if (pGlyph != NULL) {
DestroyFramesGLYPH(pGlyph);
DestroyGLYPH(pGlyph);
}
return NULL;
}
#endif // !USE_RESOURCES
#ifdef USE_OLD_DATABASES
/******************************Public*Routine******************************\
* AdHocRuleCost
*
* Because of character folding and the inability of the shape matchers
* to distinguish between a cluster a 1000 samples map to versus 1 point
* mapping to it we have a few hard rule we throw in to fix obvious
* problems.
*
* History:
* 11-Jul-1995 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
float AdHocRuleCost(int cStrokes, wchar_t dch, VOLCANO_WEIGHTS *pScores)
{
#ifdef DISABLE_HEURISTICS
return 0;
#else
wchar_t wch;
int cFrame;
// Get character and number of strokes. Note we need character in Unicode
// so that we can compare with constant character codes.
// ASSUMPTION: SYM_UNKNOWN should be the only sym if its present.
// So there aren't any alternatives that could get a "better" cost
// so it probably doesn't really matter what cost we return here
if (dch == SYM_UNKNOWN)
{
return 0;
}
wch = LocRunDense2Unicode(&g_locRunInfo, dch);
cFrame = cStrokes;
// Check for 0 (2 strokes), penalize all circle shapes
// except 0 when 2 strokes occur.
if (cFrame >= 2)
{
// 0x824f is the 0 that we don't want to penalize.
// All other circle shapes are penalized.
if ((wch == 0x006F) ||
(wch == 0x004F) ||
(wch == 0x00B0) ||
(wch == 0x3002) ||
(wch == 0x3007)
)
{
pScores->afl[VTUNE_ADHOC_CIRCLE] = -1;
return -g_vtuneInfo.pTune->weights.afl[VTUNE_ADHOC_CIRCLE];
}
}
// Check for 1 stroke lower-case i and j. No dot is a extra penalty.
if (cFrame == 1)
{
if ((wch == 0x0069) || (wch == 0x006A))
{
pScores->afl[VTUNE_ADHOC_IJ] = -1;
return -g_vtuneInfo.pTune->weights.afl[VTUNE_ADHOC_IJ];
}
}
return 0;
#endif
}
BOOL Afterburn(ALT_LIST *pAltList, GLYPH *pGlyph, CHARSET *cs, RECT *rGuide, RECT rc)
{
DRECTS drcs;
if (pGlyph==NULL || rGuide==NULL)
return FALSE;
// Scale and translate the guide box to compute the 'delta rectangle'
drcs.x = rGuide->left;
drcs.y = rGuide->top;
drcs.w = rGuide->right - rGuide->left;
drcs.h = rGuide->bottom - rGuide->top;
// Translate, convert to delta form
rc.left -= drcs.x;
rc.top -= drcs.y;
rc.right -= (drcs.x + rc.left);
rc.bottom -= (drcs.y + rc.top);
// Scale. We do isotropic scaling and center the shorter dimension.
if (drcs.w > drcs.h) {
drcs.x = ((1000 * rc.left) / drcs.w);
drcs.y = ((1000 * rc.top) / drcs.w) + ((drcs.w - drcs.h) / 2);
drcs.h = ((1000 * rc.bottom) / drcs.w);
drcs.w = ((1000 * rc.right) / drcs.w);
} else {
drcs.x = ((1000 * rc.left) / drcs.h) + ((drcs.h - drcs.w) / 2);
drcs.y = ((1000 * rc.top) / drcs.h);
drcs.w = ((1000 * rc.right) / drcs.h);
drcs.h = ((1000 * rc.bottom) / drcs.h);
}
#ifndef DISABLE_HEURISTICS
return CraneMatch(pAltList, MAX_ALT_LIST, pGlyph, cs, &drcs, 0, &g_locRunInfo);
#else
return FALSE;
#endif
}
// Hack to get around lack of data for training Crane
BOOL IsFaultyKana(wchar_t wch)
{
switch (wch) {
// case 0x3041:
case 0x3042:
// case 0x3043:
case 0x3044:
// case 0x3045:
case 0x3046:
// case 0x3047:
case 0x3048:
// case 0x3049:
case 0x304A:
// case 0x30E9:
return TRUE;
}
return FALSE;
}
#endif // USE_OLD_DATABASES
// Sort the alternate list.
// We do a bubble sort. The list is small and we can't use qsort because the data is stored in
// three parallel arrays.
void SortAltListAndTune(ALT_LIST *pAltList, VOLCANO_WEIGHTS *pTuneScore)
{
int pos1, pos2;
int limit1, limit2;
FLOAT * const peScore = pAltList->aeScore;
wchar_t * const pwchList = pAltList->awchList;
limit2 = pAltList->cAlt;
limit1 = limit2 - 1;
for (pos1 = 0; pos1 < limit1; ++pos1) {
for (pos2 = pos1 + 1; pos2 < limit2; ++pos2) {
// Are elements pos1 and pos2 out of order?
if (peScore[pos1] < peScore[pos2]) {
FLOAT eTemp;
wchar_t wchTemp;
VOLCANO_WEIGHTS weights;
// Swap scores and swap characters.
eTemp = peScore[pos1];
peScore[pos1] = peScore[pos2];
peScore[pos2] = eTemp;
wchTemp = pwchList[pos1];
pwchList[pos1] = pwchList[pos2];
pwchList[pos2] = wchTemp;
weights = pTuneScore[pos1];
pTuneScore[pos1]= pTuneScore[pos2];
pTuneScore[pos2]= weights;
}
}
}
}
// Call the core recognizer for the given character. Returned the
// number of alternates produced, or -1 if an error occurs.
int CoreRecognizeChar(
ALT_LIST *pAltList, // Alt list to be returned
int cAlt, // Max number of alternates
GLYPH **ppGlyph, // Character to recognize (which may be modified)
int nRealStrokes, // Real stroke count for abort processing
RECT *pGuideBox, // Guide box (for partial mode)
RECOG_SETTINGS *pRecogSettings, // Partial mode, other settings
CHARSET *pCS, // ALCs
int *piRecognizer, // Returns the VOLCANO_CONFIG_* constant for the recognizer used
int *piSpace) // The space number in that recognizer
{
int iRet = -1;
int iRecognizer = VOLCANO_CONFIG_NONE;
int nStrokes = CframeGLYPH(*ppGlyph);
if (nStrokes > VOLCANO_CONFIG_MAX_STROKE_COUNT) nStrokes = VOLCANO_CONFIG_MAX_STROKE_COUNT;
if (pRecogSettings->partialMode) nStrokes = 0;
iRecognizer = g_latticeConfigInfo.iRecognizers[nStrokes];
*piRecognizer = iRecognizer;
*piSpace = -1;
pAltList->cAlt = 0;
// Call the selected recognizer
switch (iRecognizer)
{
case VOLCANO_CONFIG_OTTER:
if (g_fUseJaws)
{
iRet = JawsMatch(&g_JawsLoadInfo, &g_FuguLoadInfo, &g_SoleLoadInfo,
pAltList, cAlt, *ppGlyph, pGuideBox, pCS, &g_locRunInfo);
*piSpace = nStrokes;
}
else
{
iRet = OtterMatch2(pAltList, cAlt, *ppGlyph, pCS, &g_locRunInfo, piSpace);
// Other experiments
// iRet = FuguMatch(&g_FuguLoadInfo.fugu, pAltList, cAlt, *ppGlyph, NULL /*pGuideBox*/, pCS, &g_locRunInfo);
// iRet = SoleMatch(pAltList, cAlt, *ppGlyph, pGuideBox, pCS, &g_locRunInfo);
// *piSpace = nStrokes;
}
break;
case VOLCANO_CONFIG_ZILLA:
iRet = ZillaMatch(pAltList, cAlt, ppGlyph, pCS, g_vtuneInfo.pTune->flZillaGeo,
(pRecogSettings->partialMode ? pRecogSettings->pAbort : NULL),
nRealStrokes, pRecogSettings->partialMode, pGuideBox);
// For Zilla, the space number is the feature count. To make them disjoint from the
// Otter spaces, add on the maximum number of Otter spaces.
*piSpace = CframeGLYPH(*ppGlyph) + OTTER_NUM_SPACES;
// Here you can change the iRecognizer that is returned to indicate that the Hound/Zilla
// combiner ran, instead of just Zilla alone. That way tuning will know to use a different
// weighting parameter.
break;
default:
// No recognizer available for this stroke count
iRet = -1;
break;
}
return iRet;
}
// Allocate a cache for the recognizer results.
void *AllocateRecognizerCache()
{
CACHE *pCache = (CACHE *) ExternAlloc(sizeof(CACHE));
if (pCache == NULL)
{
return NULL;
}
pCache->nStrokes = 0;
pCache->pStrokes = NULL;
return pCache;
}
// Free up a cache for the recognizer results.
void FreeRecognizerCache(void *pvCache)
{
CACHE *pCache = (CACHE *) pvCache;
CACHE_ENTRY *pEntry;
int iStroke;
if (pvCache == NULL)
{
return;
}
for (iStroke = 0; iStroke < pCache->nStrokes; iStroke++)
{
pEntry = pCache->pStrokes[iStroke];
while (pEntry != NULL)
{
CACHE_ENTRY *pNext = pEntry->pNext;
ExternFree(pEntry);
pEntry = pNext;
}
}
ExternFree(pCache->pStrokes);
ExternFree(pCache);
}
// Look for results for a given range of strokes, return the recognizer and its
// alternate list.
ALT_LIST *LookupRecognizerCache(void *pvCache, int iStroke, int nStrokes, int *piRecognizer)
{
CACHE *pCache = (CACHE *) pvCache;
CACHE_ENTRY *pEntry;
if (pCache == NULL || iStroke >= pCache->nStrokes)
{
return NULL;
}
// For the given ending stroke, look for a result for the right number of strokes
pEntry = pCache->pStrokes[iStroke];
while (pEntry != NULL && pEntry->nStrokes != nStrokes)
{
pEntry = pEntry->pNext;
}
// If not found, return nothing.
if (pEntry == NULL)
{
return NULL;
}
// Otherwise return the cached results.
*piRecognizer = pEntry->iRecognizer;
return &(pEntry->alts);
}
// Add the alternate list to the cache.
void AddRecognizerCache(void *pvCache, int iStroke, int nStrokes, int iRecognizer, ALT_LIST *pAlts)
{
CACHE *pCache = (CACHE *) pvCache;
CACHE_ENTRY *pEntry;
// If no cache, then exit
if (pCache == NULL)
{
return;
}
// If the cache is currently too small, then allocate more space for it.
if (iStroke >= pCache->nStrokes)
{
int i;
int nStrokesNew = max(10, (iStroke + 1) * 2);
CACHE_ENTRY **pStrokesNew = (CACHE_ENTRY **) ExternRealloc(pCache->pStrokes, sizeof(CACHE_ENTRY *) * nStrokesNew);
if (pStrokesNew == NULL)
{
// If the allocation failed, just continue with the current cache size
return;
}
// Initialize the memory
for (i = pCache->nStrokes; i < nStrokesNew; i++)
{
pStrokesNew[i] = NULL;
}
pCache->pStrokes = pStrokesNew;
pCache->nStrokes = nStrokesNew;
}
// If we got here, then add the entry to the cache
pEntry = (CACHE_ENTRY *) ExternAlloc(sizeof(CACHE_ENTRY));
if (pEntry == NULL)
{
return;
}
pEntry->nStrokes = nStrokes;
pEntry->iRecognizer = iRecognizer;
pEntry->alts = *pAlts;
pEntry->pNext = pCache->pStrokes[iStroke];
pCache->pStrokes[iStroke] = pEntry;
}
#ifdef USE_OLD_DATABASES
// This call is roughly the equivalent of the RecognizeChar call below, but instead of
// returning probabilities, it returns an alternate list with scores. It uses the old Tsunami
// recognition procedure, with otter and zilla returning code points, followed by adhoc rules,
// language model, baseline/height scores, and crane. The result of this is used by RecognizeChar
// to look up the old probability table.
INT RecognizeCharInsurance(
RECOG_SETTINGS *pRecogSettings,// In: Setting for recognizers.
UINT cStrokes, // In: Number of strokes to process.
UINT cRealStrokes, // In: Number of strokes before merging
STROKE *pStrokes, // In: Array of strokes to process.
FLOAT *pProbIsChar, // Out: probability of being valid char.
UINT maxAlts, // In: Size of alts array supplied.
RECOG_ALT *pProbAlts, // Out: alternate list matched with probabilities.
int *pnProbAlts,
RECOG_ALT *pScoreAlts, // Out: alternate list matched with scores
int *pnScoreAlts,
RECT *pGuideBox, // In: Guide box for this ink.
wchar_t dchContext, // In: Context
int *pSpace, // Out: Space number used for matching
VOLCANO_WEIGHTS *pTuneScore, // Out: score components
BOOL fStringMode, // In: Whether or not the recognizer is in string mode
BOOL fProbMode, // In: Whether the recognizer is in probability mode
void *pvCache, // In/Out: Pointer to cache, or NULL if not being used
int iStroke // In: Index of last stroke of character
) {
ALT_LIST *pCacheResult = NULL;
BOXINFO box;
RECT bbox;
int iAlt;
GLYPH *pGlyph;
ALT_LIST altList;
CHARSET charSet; // Mask used for core recognizers
CHARSET charSetMask; // Mask used for probability table lookup
BOOL fCraneBonus = FALSE;
int iRecognizer;
// Convert strokes to GLYPHs and FRAMEs so that we can call the
// old code.
pGlyph = GlyphFromStrokes(cStrokes, pStrokes);
if (!pGlyph)
{
return -1;
}
// Run otter or zilla as needed.
altList.cAlt = 0;
charSetMask.recmask = pRecogSettings->alcValid;
charSetMask.recmaskPriority = pRecogSettings->alcPriority;
charSetMask.pbAllowedChars = pRecogSettings->pbAllowedChars;
charSetMask.pbPriorityChars = pRecogSettings->pbPriorityChars;
if (fProbMode)
{
// In probability mode, don't mask off the core recognizers
charSet.recmask = 0xFFFFFFFF;
charSet.recmaskPriority = 0;
charSet.pbAllowedChars = NULL;
charSet.pbPriorityChars = NULL;
}
else
{
// In score mode, mask off the core recognizers
charSet = charSetMask;
}
// Get the bounding box for the character
GetRectGLYPH(pGlyph,&bbox);
// Try going to the cache
pCacheResult = LookupRecognizerCache(pvCache, iStroke, cStrokes, &iRecognizer);
if (pCacheResult != NULL)
{
// If it was the Zilla recognizer before, we need to run featurization because
// of its side-effect of fragmenting the strokes, which crane needs.
if (iRecognizer == VOLCANO_CONFIG_ZILLA)
{
BIGPRIM rgprim[CPRIMMAX];
BYTE aSampleVector[29 * 4];
ZillaFeaturize(&pGlyph, rgprim, aSampleVector);
}
altList = *pCacheResult;
}
else
{
// Invoke Otter or Zilla or any other recognizer that has been specified in the configuration
CoreRecognizeChar(&altList, MAX_ALT_LIST, &pGlyph, cRealStrokes, pGuideBox, pRecogSettings, &charSet, &iRecognizer, pSpace);
// Add it to the cache, since it isn't there already.
AddRecognizerCache(pvCache, iStroke, cStrokes, iRecognizer, &altList);
}
// If we're doing an experiment to simulate an optimal otter or zilla,
// replace the real alt list with a fake one.
#ifdef OPTIMAL_OTTER_ZILLA
{
wchar_t dch;
altList.cAlt = 1;
altList.aeScore[0] = 0;
{
FILE *f = fopen("c:/answer.txt", "r");
fscanf(f, "%hx", &(altList.awchList[0]));
fclose(f);
}
dch = LocRunUnicode2Dense(&g_locRunInfo, altList.awchList[0]);
if (dch != LOC_TRAIN_NO_DENSE_CODE) {
wchar_t fdch = LocRunDense2Folded(&g_locRunInfo, dch);
if (fdch != 0) dch = fdch;
altList.awchList[0] = dch;
} else {
altList.cAlt = 0;
}
}
#endif
// Get our rough approximation of the probability that this is
// actually a character. If zero alternates are returned, then
// set the space number to -1 as an error flag.
if (altList.cAlt == 0) {
*pSpace = -1;
*pProbIsChar = 0;
*pnProbAlts = 0;
*pnScoreAlts = 0;
goto cleanup;
}
// Unfold anything in the alt list which needs it.
UnfoldCodes(&altList, &charSet);
// If we couldn't load the probability table, then use the
// WinCE method to get probabilities.
if (g_pProbHeader == NULL)
{
*pnProbAlts = GetProbsTsunamiFixedTable(cStrokes, &altList, maxAlts, pProbAlts, &charSetMask);
}
// Apply crane, if we have a guide for it to use and we are not in partial mode
if (pRecogSettings->partialMode == HWX_PARTIAL_ALL && pGuideBox != NULL && altList.cAlt > 0) {
fCraneBonus = Afterburn(&altList, pGlyph, &charSet, pGuideBox, bbox);
// Hack to bypass crane if otter a troublesome kana character
if (IsFaultyKana(LocRunDense2Unicode(&g_locRunInfo,altList.awchList[0]))) {
fCraneBonus = FALSE;
}
}
// Save away the scores for the alternates, then apply the weight for the particular
// recognizer used. Then add in the crane bonus/penalty and the adhoc rules.
for (iAlt=0; iAlt<(int)altList.cAlt; iAlt++)
{
int iParam = (fStringMode ? VTUNE_STRING_CORE : VTUNE_CHAR_CORE) + iRecognizer;
pTuneScore[iAlt].afl[iParam] = altList.aeScore[iAlt];
altList.aeScore[iAlt] *= g_vtuneInfo.pTune->weights.afl[iParam];
// Crane is now implemented as a penalty rather than a bonus. This means
// all alternates after the first one get a penalty, and even the first one
// gets a penalty if no crane bonus is applied.
if (iAlt > 0 || !fCraneBonus)
{
iParam = fStringMode ? VTUNE_STRING_CRANE : VTUNE_CHAR_CRANE;
pTuneScore[iAlt].afl[iParam] = -1;
altList.aeScore[iAlt] -= g_vtuneInfo.pTune->weights.afl[iParam];
}
// Add adhoc penalties for the one stroke i and j and two stroke circle shapes
if (pRecogSettings->partialMode == HWX_PARTIAL_ALL)
{
altList.aeScore[iAlt] += AdHocRuleCost(cStrokes, altList.awchList[iAlt], pTuneScore + iAlt);
}
}
// Sort the alternates out.
SortAltListAndTune(&altList, pTuneScore);
// Copy the score-based alts to the output
for (iAlt = 0; iAlt < (int)altList.cAlt && iAlt < (int)maxAlts && iAlt < (int)MAX_ALT_LIST; ++iAlt)
{
pScoreAlts[iAlt].wch = altList.awchList[iAlt];
pScoreAlts[iAlt].prob = altList.aeScore[iAlt];
}
*pnScoreAlts = altList.cAlt;
// Re-score the alternates using the old weightings in the
// TTune structure, so that prob table lookup will be weighting
// independent.
for (iAlt = 0; iAlt < (int)altList.cAlt; ++iAlt)
{
altList.aeScore[iAlt] =
g_vtuneInfo.pTune->weights.afl[VTUNE_ADHOC_IJ] * pTuneScore[iAlt].afl[VTUNE_ADHOC_IJ] +
g_vtuneInfo.pTune->weights.afl[VTUNE_ADHOC_CIRCLE] * pTuneScore[iAlt].afl[VTUNE_ADHOC_CIRCLE] +
(cStrokes > 2 ? g_ttuneInfo.pTTuneCosts->ZillaChar.CARTAddWeight :
g_ttuneInfo.pTTuneCosts->OtterChar.CARTAddWeight)
* pTuneScore[iAlt].afl[fStringMode ? VTUNE_STRING_CRANE : VTUNE_CHAR_CRANE] +
pTuneScore[iAlt].afl[(fStringMode ? VTUNE_STRING_CORE : VTUNE_CHAR_CORE) + iRecognizer];
}
// Build up a BOXINFO structure from the guide, for use in the baseline/height scoring
if (pGuideBox!=NULL) {
box.size = pGuideBox->bottom - pGuideBox->top;
box.baseline = pGuideBox->bottom;
box.xheight = box.size / 2;
box.midline = box.baseline - box.xheight;
}
// For each alternate
for (iAlt=0; iAlt<(int)altList.cAlt; iAlt++) {
float cost;
// Apply baseline/height and language model unigram scores
if (cStrokes<3) {
if (pGuideBox!=NULL) {
cost = BaselineTransitionCost(0,bbox,&box,altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->OtterChar.BaseWeight;
altList.aeScore[iAlt] += cost;
cost = BaselineBoxCost(altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->OtterChar.BoxBaselineWeight;
altList.aeScore[iAlt] += cost;
cost = HeightTransitionCost(0,bbox,&box,altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->OtterChar.HeightWeight;
altList.aeScore[iAlt] += cost;
cost = HeightBoxCost(altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->OtterChar.BoxHeightWeight;
altList.aeScore[iAlt] += cost;
}
cost = UnigramCost(&g_unigramInfo,altList.awchList[iAlt])
* g_ttuneInfo.pTTuneCosts->OtterChar.UniWeight;
altList.aeScore[iAlt] += cost;
} else {
if (pGuideBox!=NULL) {
cost = BaselineTransitionCost(0,bbox,&box,altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->ZillaChar.BaseWeight;
altList.aeScore[iAlt] += cost;
cost = BaselineBoxCost(altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->ZillaChar.BoxBaselineWeight;
altList.aeScore[iAlt] += cost;
cost = HeightTransitionCost(0,bbox,&box,altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->ZillaChar.HeightWeight;
altList.aeScore[iAlt] += cost;
cost = HeightBoxCost(altList.awchList[iAlt],bbox,&box)
* g_ttuneInfo.pTTuneCosts->ZillaChar.BoxHeightWeight;
altList.aeScore[iAlt] += cost;
}
cost = UnigramCost(&g_unigramInfo,altList.awchList[iAlt])
* g_ttuneInfo.pTTuneCosts->ZillaChar.UniWeight;
altList.aeScore[iAlt] += cost;
// Zilla scores get fudged
altList.aeScore[iAlt] *= g_ttuneInfo.pTTuneCosts->ZillaStrFudge;
}
// If context was available for this character, then use the bigram/class bigram scores
if (dchContext != SYM_UNKNOWN && dchContext != 0) {
#if !defined(WINCE) && !defined(FAKE_WINCE)
cost = BigramTransitionCost(&g_locRunInfo,&g_bigramInfo,dchContext,altList.awchList[iAlt])
* g_ttuneInfo.pTTuneCosts->BiWeight;
altList.aeScore[iAlt] += cost;
#endif
cost = ClassBigramTransitionCost(&g_locRunInfo,&g_classBigramInfo,dchContext,altList.awchList[iAlt])
* g_ttuneInfo.pTTuneCosts->BiClassWeight;
altList.aeScore[iAlt] += cost;
}
}
// Sort the resulting alternates
SortAltList(&altList);
// This is a temporary call to get probs directly, until we have Hawk.
if (g_pProbHeader != NULL)
{
*pnProbAlts = GetProbsTsunami(cStrokes, &altList, maxAlts, pProbAlts, &charSetMask);
}
#if 0
{
FILE *f=fopen("c:/temp/prob.log","a+");
fprintf(f,"%04X %g -> %04X %g\n", altList.awchList[0], altList.aeScore[0],
pProbAlts[0].wch, pProbAlts[0].prob);
fclose(f);
}
#endif
//#define TEST_FOR_PATRICKH
#ifdef TEST_FOR_PATRICKH
{
int i;
for (i=0; i<*pnProbAlts && i<(int)altList.cAlt; i++)
pProbAlts[i].wch = altList.awchList[i];
*pnProbAlts = i;
}
#endif
cleanup:
// Free the glyph structure.
DestroyFramesGLYPH(pGlyph);
DestroyGLYPH(pGlyph);
return *pnProbAlts;
}
#else
// Version of Afterburn to call Hawk.
int Afterburn(
ALT_LIST *pAltList, // Input used to select correct CART tree
GLYPH *pGlyph,
CHARSET *cs,
RECT *rGuide,
int otterSpace,
UINT maxAlts, // Size of alts array supplied.
RECOG_ALT *pAlts // Out: alternate list matched.
) {
UINT ii;
UINT iDest;
// UINT jj, kk;
BASICINFO basicInfo;
FEATINFO featInfo;
HANDLE hCartTree;
QALT aQAlt[MAX_RECOG_ALTS];
UINT cQAlt;
#if 0
double aWeights[MAX_ALT_LIST];
double fSum;
double offset;
FILE *pFile;
#endif
RECT bbox;
DRECTS drcs;
if (pGlyph == NULL) {
return -1;
}
// Get the bounding box for the character
GetRectGLYPH(pGlyph, &bbox);
// Scale and translate the guide box to compute the 'delta rectangle'
if (rGuide == NULL) {
// No guide given, This is the current assumption.
drcs.x = 0;
drcs.y = 0;
drcs.w = 1000;
drcs.h = 1000;
} else {
// Actually got a guide, pass it on. Current code ignores the
// guide, but may add it back so don't lose code path.
drcs.x = rGuide->left;
drcs.y = rGuide->top;
drcs.w = rGuide->right - rGuide->left;
drcs.h = rGuide->bottom - rGuide->top;
}
// Translate, convert to delta form
bbox.left -= drcs.x;
bbox.top -= drcs.y;
bbox.right -= (drcs.x + bbox.left);
bbox.bottom -= (drcs.y + bbox.top);
// Scale. We do isotropic scaling and center the shorter dimension.
if (drcs.w > drcs.h) {
drcs.x = ((1000 * bbox.left) / drcs.w);
drcs.y = ((1000 * bbox.top) / drcs.w) + ((drcs.w - drcs.h) / 2);
drcs.h = ((1000 * bbox.bottom) / drcs.w);
drcs.w = ((1000 * bbox.right) / drcs.w);
} else {
drcs.x = ((1000 * bbox.left) / drcs.h) + ((drcs.h - drcs.w) / 2);
drcs.y = ((1000 * bbox.top) / drcs.h);
drcs.w = ((1000 * bbox.right) / drcs.h);
drcs.h = ((1000 * bbox.bottom) / drcs.h);
}
// Fill in basic info.
// basicInfo.cStrk -- Filed in by MakeFeatures.
basicInfo.cSpace = (short)otterSpace;
basicInfo.drcs = drcs;
// Fill in feature info.
if (!MakeFeatures(&basicInfo, &featInfo, pGlyph)) {
return -1;
}
#if 1
// Find cart tree
hCartTree = (HANDLE)0;
for (ii = 0; !hCartTree && ii < pAltList->cAlt; ++ii) {
hCartTree = HawkFindTree(basicInfo.cStrk, basicInfo.cSpace, pAltList->awchList[ii]);
}
if (!hCartTree) {
// No cart tree for anything in the alt list!?!?!
return -1;
}
// Do the match.
//HawkMatch(pAltList, MAX_ALT_LIST, pGlyph, cs, &drcs, eCARTWeight, &g_locRunInfo);
cQAlt = HawkMatch(&basicInfo, &featInfo, hCartTree, aQAlt);
// Copy out the alt list, applying the ALC
iDest = 0;
for (ii = 0; ii < cQAlt && iDest < maxAlts; ++ii)
{
if (IsAllowedChar(&g_locRunInfo, cs, aQAlt[ii].dch))
{
pAlts[iDest].wch = aQAlt[ii].dch;
pAlts[iDest].prob = aQAlt[ii].prob;
iDest++;
}
}
cQAlt = iDest;
#elif 0
// Select stroke dependent offset used to compute weights below.
switch (basicInfo.cStrk) {
case 1 : offset = .01; break;
case 2 : offset = .05; break;
default : offset = .05; break;
}
// Compute wighting to apply to each trees results.
fSum = 0.0;
for (ii = 0; ii < pAltList->cAlt; ++ii) {
double ratio;
ratio = offset / (offset + pAltList->aeScore[0] - pAltList->aeScore[ii]);
aWeights[ii] = ratio * ratio * ratio;
fSum += aWeights[ii];
}
// Normalize to sum to one.
for (ii = 0; ii < pAltList->cAlt; ++ii) {
aWeights[ii] /= fSum;
}
pFile = fopen("AltList.dump", "a");
fprintf(pFile, "Start Dump:\n");
// Find each cart tree and add results to list.
hCartTree = (HANDLE)0;
cQAlt = 0;
for (ii = 0; ii < pAltList->cAlt && cQAlt < maxAlts; ++ii) {
hCartTree = HawkFindTree(basicInfo.cStrk, basicInfo.cSpace, pAltList->awchList[ii]);
if (hCartTree) {
UINT cQAltNew;
SCORE penalty;
int skipped;
// Do the match.
cQAltNew = HawkMatch(&basicInfo, &featInfo, hCartTree, aQAlt);
// How much can we add?
if (cQAltNew > maxAlts - cQAlt) {
cQAltNew = maxAlts - cQAlt;
}
// Convert our weight (Probability) to a log prob.
penalty = ProbToScore(aWeights[ii]);
// Zilla overgenerates prototypes, so look for different top one from
// additional trees.
if (ii > 0 && basicInfo.cStrk >= 3 && aQAlt[0].dch == pAlts[0].wch) {
continue;
}
// Add to list.
skipped = 0;
for (jj = 0; jj < cQAltNew; ++jj) {
SCORE newScore;
// Check for duplicates in the alternate list. Each individual list has not
// dups, so we don't have to check them.
newScore = aQAlt[jj].prob + penalty;
fprintf(pFile, " %04X:%d->%d", LocRunDense2Unicode(&g_locRunInfo,aQAlt[jj].dch),aQAlt[jj].prob,newScore);
for (kk = 0; kk < cQAlt; ++kk) {
if (aQAlt[jj].dch == pAlts[kk].wch) {
ASSERT(pAlts[kk].prob == (float)(int)pAlts[kk].prob);
pAlts[kk].prob = ScoreAddProbs((SCORE)pAlts[kk].prob, newScore);
++skipped;
goto noAdd;
}
}
pAlts[jj - skipped + cQAlt].wch = aQAlt[jj].dch;
pAlts[jj - skipped + cQAlt].prob = (float)newScore;
noAdd: ;
}
fprintf(pFile, "\n");
cQAlt += cQAltNew - skipped;
}
}
for (kk = 0; kk < cQAlt; ++kk) {
fprintf(pFile, " %04X:%g", LocRunDense2Unicode(&g_locRunInfo,pAlts[kk].wch),pAlts[kk].prob);
}
fprintf(pFile, "\n");
fprintf(pFile, "End Dump\n");
fclose(pFile);
#else
// Select stroke dependent offset used to compute weights below.
switch (basicInfo.cStrk) {
case 1 : offset = 1.0; break;
case 2 : offset = 1.0; break;
default : offset = 1.0; break;
}
pFile = fopen("AltList.dump", "a");
fprintf(pFile, "Start Dump:\n");
// Find each cart tree and add results to list.
hCartTree = (HANDLE)0;
cQAlt = 0;
for (ii = 0; ii < pAltList->cAlt && cQAlt < maxAlts; ++ii) {
hCartTree = HawkFindTree(basicInfo.cStrk, basicInfo.cSpace, pAltList->awchList[ii]);
if (hCartTree) {
UINT cQAltNew;
SCORE penalty;
int skipped;
// Do the match.
cQAltNew = HawkMatch(&basicInfo, &featInfo, hCartTree, aQAlt);
// How much can we add?
if (cQAltNew > maxAlts - cQAlt) {
cQAltNew = maxAlts - cQAlt;
}
// Convert our weight (Probability) to a log prob.
penalty = (SCORE)((pAltList->aeScore[0] - pAltList->aeScore[ii]) * 2040);
// Zilla overgenerates prototypes, so look for different top one from
// additional trees.
if (ii > 0 && basicInfo.cStrk >= 3 && aQAlt[0].dch == pAlts[0].wch) {
continue;
}
// Add to list.
skipped = 0;
for (jj = 0; jj < cQAltNew; ++jj) {
SCORE newScore;
// Check for duplicates in the alternate list. Each individual list has not
// dups, so we don't have to check them.
newScore = aQAlt[jj].prob + penalty;
fprintf(pFile, " %04X:%d->%d", LocRunDense2Unicode(&g_locRunInfo,aQAlt[jj].dch),aQAlt[jj].prob,newScore);
for (kk = 0; kk < cQAlt; ++kk) {
if (aQAlt[jj].dch == pAlts[kk].wch) {
ASSERT(pAlts[kk].prob == (float)(int)pAlts[kk].prob);
pAlts[kk].prob = ScoreAddProbs((SCORE)pAlts[kk].prob, newScore);
++skipped;
goto noAdd;
}
}
pAlts[jj - skipped + cQAlt].wch = aQAlt[jj].dch;
pAlts[jj - skipped + cQAlt].prob = (float)newScore;
noAdd: ;
}
fprintf(pFile, "\n");
cQAlt += cQAltNew - skipped;
}
}
for (kk = 0; kk < cQAlt; ++kk) {
fprintf(pFile, " %04X:%g", LocRunDense2Unicode(&g_locRunInfo,pAlts[kk].wch),pAlts[kk].prob);
}
fprintf(pFile, "\n");
fprintf(pFile, "End Dump\n");
fclose(pFile);
#endif
FreeFeatures(&featInfo);
return cQAlt;
}
#endif
#ifndef USE_OLD_DATABASES
// Do the recognition.
INT
RecognizeChar(
RECOG_SETTINGS *pRecogSettings,// Setting for recognizers.
UINT cStrokes, // Number of strokes to process.
UINT cRealStrokes, // Number of strokes before merging
STROKE *pStrokes, // Array of strokes to process.
FLOAT *pProbIsChar, // Out: probability of being valid char.
UINT maxAlts, // Size of alts array supplied.
RECOG_ALT *pAlts, // Out: alternate list matched.
RECT *pGuideBox, // Guide box for this ink.
int *pCount
) {
INT cAlts;
GLYPH *pGlyph;
ALT_LIST altList;
CHARSET charSet;
int iRecognizer;
// Convert strokes to GLYPHs and FRAMEs so that we can call the
// old code.
pGlyph = GlyphFromStrokes(cStrokes, pStrokes);
if (!pGlyph) {
return -1;
}
// Run otter or zilla as needed.
// a possible optimization would be Switch to proto matching versions of match calls
altList.cAlt = 0;
charSet.recmask = 0xFFFFFFFF;
charSet.recmaskPriority = 0;
charSet.pbAllowedChars = NULL;
charSet.pbPriorityChars = NULL;
// Invoke Otter or Zilla or any other recognizer that has been specified in the configuration
CoreRecognizeChar(&altList, MAX_ALT_LIST, &pGlyph, cRealStrokes, pGuideBox, pRecogSettings, &charSet, &iRecognizer, pCount);
charSet.recmask = pRecogSettings->alcValid;
charSet.recmaskPriority = pRecogSettings->alcPriority;
charSet.pbAllowedChars = pRecogSettings->pbAllowedChars;
charSet.pbPriorityChars = pRecogSettings->pbPriorityChars;
if (pRecogSettings->partialMode != HWX_PARTIAL_ALL) {
unsigned int ii;
// Unfold anything in the alt list which needs it.
UnfoldCodes(&altList, &charSet);
// Copy over the alt list.
// Note that we don't have probabilities, and they don't
// really make sense anyway. However the code that
// follows will discard items with a prob of zero, so
// they should be set to something.
for (ii = 0; ii < maxAlts && ii < altList.cAlt; ++ii) {
pAlts[ii].wch = altList.awchList[ii];
pAlts[ii].prob = -altList.aeScore[ii];
}
// Free the glyph structure.
DestroyFramesGLYPH(pGlyph);
DestroyGLYPH(pGlyph);
return ii;
}
// Get our rough approximation of the probability that this is
// actually a character.
*pProbIsChar = altList.aeScore[0];
// Run Hawk.
#ifndef DISABLE_HEURISTICS
cAlts = Afterburn(&altList, pGlyph, &charSet, pGuideBox, *pCount, maxAlts, pAlts);
#else
{
unsigned int ii;
UnfoldCodes(&altList, &charSet);
for (ii = 0; ii < maxAlts && ii < altList.cAlt; ii++)
{
pAlts[ii].wch = altList.awchList[ii];
pAlts[ii].prob = -altList.aeScore[ii];
}
cAlts = ii;
}
#endif
// Free the glyph structure.
DestroyFramesGLYPH(pGlyph);
DestroyGLYPH(pGlyph);
return cAlts;
}
#endif
Reference in a new issue Copy permalink