/**********************************************************************************
* AUTHOR : Deepu V.
* DATE : 22-AUG-2005
* NAME : updateRecognitionResults
* DESCRIPTION : This function tries to update the
* : shape recognition choices with new shape recognition results
* ARGUMENTS : results - new results for updating the results
* RETURNS :
* NOTES :
* CHANGE HISTROY
* Author Date Description of
*************************************************************************************/
int BoxedFieldRecognizer::updateRecognitionResults(const vector<LTKShapeRecoResult>& results, LTKRecognitionContext& rc)
{
LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)
<<"Entering: BoxedFieldRecognizer::updateRecognitionResults"
<<endl;
multimap< float, pair<int,int>, greater<float> >backTrace;
//A multi map is used for finding best N paths
multimap< float, pair<int,int>, greater<float> >::iterator iter, iterend;
//Iterator for accessing elements of the map
pair<int,int> combination;
//Temporary variable that keeps a (int,int) pair
int wordResultIndex, shapeResultIndex;
//loop index variables
float wordConfidence, shapeConfidence;
//word level and shape level confidences
unsigned short newSymbol;
//temporary storage for shape recognizer id
float newConf; //temporary storage for shape recognizer confidence
vector<LTKWordRecoResult> newResultVector;
//new results after finding the best N paths
int numWordRecoResults = rc.getNumResults();
//number of word recognition results requested
int numShapeRecoResults = results.size();
//number of choices from the shape recognizer
vector<unsigned short>initVec;
//for initializing the trellis
//If there is no decoded results (First shape recognition in the word)
if(m_decodedResults.empty())
{
//Initializing the results vector
m_decodedResults.assign(numShapeRecoResults,LTKWordRecoResult());
//iterating through different word recognition choices
for(wordResultIndex = 0; (wordResultIndex<numShapeRecoResults); ++wordResultIndex)
{
//Retrieving the shape recognition choices
newSymbol = results.at(wordResultIndex).getShapeId();
newConf = results.at(wordResultIndex).getConfidence();
//updating the results
initVec.assign(1,newSymbol);
m_decodedResults.at(wordResultIndex).setWordRecoResult(initVec,newConf);
}
}
else
{
//initializing a temporary result vector
//newResultVector.assign(smallerResultNumber,LTKWordRecoResult());
//iterating through each word recognition result
for(wordResultIndex=0; wordResultIndex<m_decodedResults.size(); ++wordResultIndex)
{
wordConfidence = (m_decodedResults.at(wordResultIndex)).getResultConfidence();
//iterating through each shape recognition results
for(shapeResultIndex =0; shapeResultIndex<numShapeRecoResults; ++shapeResultIndex )
{
//adding total confidence to the map. so that later they
//can be retrieved in the sorted order
shapeConfidence = (results.at(shapeResultIndex)).getConfidence();
backTrace.insert( pair<float, pair<int,int> >( (shapeConfidence+wordConfidence),
pair<int,int>(wordResultIndex,shapeResultIndex)));
}
}
iterend = backTrace.end();
//iterating through the map to retrieve the largest confidences.
for(wordResultIndex = 0,iter = backTrace.begin(); (wordResultIndex<numWordRecoResults)&&(iter!= iterend); ++wordResultIndex,++iter)
{
//confidence
wordConfidence = (*iter).first;
//the combination that gave this
//confidence
combination = (*iter).second;
//copying the word reco result corresponding to
//the combination to new result vector
//newResultVector.at(wordResultIndex) = m_decodedResults.at(combination.first);
LTKWordRecoResult tempWordRecoResult = m_decodedResults.at(combination.first);
//retrieving the shape recognition result id
//and confidence corresponding to the combination
newSymbol = results.at(combination.second).getShapeId();
newConf = results.at(combination.second).getConfidence();
//updating the word reco result with new id and confidence
//newResultVector.at(wordResultIndex).updateWordRecoResult(newSymbol, newConf);
tempWordRecoResult.updateWordRecoResult(newSymbol,newConf);
newResultVector.push_back(tempWordRecoResult);
}
//assigning the newly created result vector
m_decodedResults = newResultVector;
}
LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)
<<"Exiting: BoxedFieldRecognizer::updateRecognitionResults"
<<endl;
return SUCCESS;
}
/**********************************************************************************
* AUTHOR : Deepu V.
* DATE : 22-AUG-2005
* NAME : recognize
* DESCRIPTION : This is the recognize call
* : The results of the recognition is set on the Recognition context
* : object. In case of BATCH_MODE recognition recognition of every
* : character is performed. otherwise the recognizer updates the outputs
* : with the recognized results
* ARGUMENTS : rc - The recognition context for the current recognition
* RETURNS : SUCCESS/FAILURE
* NOTES :
* CHANGE HISTROY
* Author Date Description of
*************************************************************************************/
int BoxedFieldRecognizer::recognize (LTKRecognitionContext& rc)
{
LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)
<<"Entering: BoxedFieldRecognizer::recognize"
<<endl;
string tempStr = REC_UNIT_INFO; //temp string required to pass the arguments to set/get Flags
int tempFlagValue = 0; //temp int to hold flag values
int errorCode = 0;
vector <LTKWordRecoResult>::iterator resultIter,resultEnd; //iterates through decoded recognition results
int numWordRecoResults ; //Number of results required by the application
int resultIndex ; //index to iterate through the results
vector<unsigned short> resultString; //result
float normConf; //normalized confidence
//Returning FAILURE if the recognition context
//is not segmented into characters
if((errorCode=rc.getFlag(tempStr,tempFlagValue))!=SUCCESS)
{
LOG(LTKLogger::LTK_LOGLEVEL_ERR)
<<"Error: BoxedFieldRecognizer::recognize"<<endl;
LTKReturnError(errorCode);
}
if( tempFlagValue != REC_UNIT_CHAR)
{
LOG(LTKLogger::LTK_LOGLEVEL_ERR)
<<"Error : "<< EINVALID_SEGMENT <<":"<< getErrorMessage(EINVALID_SEGMENT)
<<" BoxedFieldRecognizer::recognize" <<endl;
LTKReturnError(EINVALID_SEGMENT);
}
tempStr =REC_MODE;
if((errorCode=rc.getFlag(tempStr,tempFlagValue))!=SUCCESS)
{
LOG(LTKLogger::LTK_LOGLEVEL_ERR)
<<"Error: BoxedFieldRecognizer::recognize"<<endl;
LTKReturnError(errorCode);
}
if(tempFlagValue == REC_MODE_BATCH)
{
//clear all the recognizer state
clearRecognizerState();
recognizeTraces(rc);
}
else if (tempFlagValue == REC_MODE_STREAMING)
{
recognizeTraces(rc);
}
else
{
LOG(LTKLogger::LTK_LOGLEVEL_ERR)
<<"Error : "<< EINVALID_REC_MODE <<":"<< getErrorMessage(EINVALID_REC_MODE)
<<" BoxedFieldRecognizer::recognize" <<endl;
LTKReturnError(EINVALID_REC_MODE);
}
/* Now all the recognized results are in
* m_decodedResults.
*/
resultEnd = m_decodedResults.end();
for(resultIter = m_decodedResults.begin(); resultIter != resultEnd ; ++resultIter)
{
normConf = (*resultIter).getResultConfidence();
normConf /= ((*resultIter).getResultWord()).size();
(*resultIter).setResultConfidence(normConf);
}
//number of requested results
numWordRecoResults = rc.getNumResults();
//checking with existing recognition results' size
if(numWordRecoResults > m_decodedResults.size())
{
LOG(LTKLogger::LTK_LOGLEVEL_INFO)
<< "Don't have enough results to populate. Num of results available = "
<< m_decodedResults.size() <<", however, results asked for ="
<< numWordRecoResults <<endl;
}
resultEnd = m_decodedResults.end();
for(resultIndex =0,resultIter = m_decodedResults.begin();(resultIndex <numWordRecoResults)&&(resultIter != resultEnd); ++resultIndex,++resultIter)
{
//map the shape ids to unicode IDs
if((errorCode = LTKStrEncoding::shapeStrToUnicode(m_boxedShapeProject,(*resultIter).getResultWord(),resultString)) != SUCCESS)
{
LOG(LTKLogger::LTK_LOGLEVEL_ERR)
<<"Error: BoxedFieldRecognizer::recognize"<<endl;
LTKReturnError(errorCode);
}
//adding the recognition result to recognition context
rc.addRecognitionResult(LTKWordRecoResult(resultString,
(*resultIter).getResultConfidence()));
resultString.clear();
}
//clearing state of the recognizer
clearRecognizerState();
LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)
<<"Exiting: BoxedFieldRecognizer::recognize"
<<endl;
return SUCCESS;
}
