1796 lines
50 KiB
C
1796 lines
50 KiB
C
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
|
|
//
|
|
// 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
|