// Stroke-level recognition score.
private double scoreTree(ParseTreeNode p)
{
// weighted harmonic mean
/*
* List< SymbolTreeNode > all_children = new List< SymbolTreeNode >();
* p.PopulateChildrenLexerResults( all_children );
* int totalStrokes = 0;
* double harmonicSum = 0;
* foreach ( SymbolTreeNode stn in all_children ) {
* totalStrokes += stn.symbolData.segment.strokes.Count;
* harmonicSum += stn.symbolData.segment.strokes.Count / ( stn.symbolData.segment.classification[ 0 ].probability );
* }
* return totalStrokes / harmonicSum;
*/
if (p is SymbolTreeNode)
{
SymbolTreeNode s = (SymbolTreeNode)p;
return(s.symbolData.segment.strokes.Count * s.symbolData.segment.classification[0].probability);
}
double sum = 0.0;
foreach (ParseTreeNode child in p.children)
{
sum += scoreTree(child);
}
return(sum);
}
// Attach nested region to the child.
// **Need to be careful to set attributes correctly here.
public ParseState AddNestedRegion(RelationTreeNode relationNode, SymbolTreeNode snode)
{
// Create new child node. *Maintain previous node (depth-first
// parse).
ParseState newState = new ParseState();
// Attributes..
newState.rootNode = relationNode;
newState.numberStrokes = relationNode.lbt.strokes.Count; // Only need to consume strokes in this sub-region.
newState.completesParse = false; // This branch cannot be the final NT for a rule.
// Wipe out candidate and previous symbols.
newState.candidateSymbols = null;
newState.previous = new PreviousSymbol();
newState.previous.symbol = new LexerResult();
newState.previous.regionsOptional = true;
/*if (relationNode.lbt.strokes == null)
* Console.WriteLine("RELATION NODE LBT: NULL!!");
* else
* Console.WriteLine("RELATION NODE LBT: {0} strokes", relationNode.lbt.strokes.Count);
*/
newState.previous.symbol.lbt = relationNode.lbt;
// COMPLETING PARSE?
//newState.completesParse = previous.parent.
// Attach region to parent node.
previous.parent.children.Add(relationNode);
return(newState);
}
public override ParseTreeNode clone()
{
// Node labels and stoke data will be fixed for a given node (ref. only), but children will
// differ for different parse trees (new copy).
LexerResult resultCopy = (LexerResult)symbolData.Clone();
SymbolTreeNode nodeCopy = new SymbolTreeNode(resultCopy);
nodeCopy.strokes = strokes;
nodeCopy.lbt = null;
if (lbt != null)
{
nodeCopy.lbt = new LBT(lbt); // copy lbt
}
if (children != null)
{
foreach (ParseTreeNode child in children)
{
nodeCopy.children.Add(child.clone());
}
}
nodeCopy.symbolData = symbolData;
return(nodeCopy);
}
// include generated mathml from right nodes to siblings to their left (because of mrow)
virtual public string ChildMathML(string right)
{
if (this is RelationTreeNode || this is SymbolTreeNode)
{
throw new Exception("Child classes must re-implement this method");
}
if (this.children.Count > 0 && (this.children[0] is RelationTreeNode || this.children[0] is SymbolTreeNode))
{
string this_symbol = null;
if (this.children.Count == 2)
{
// one relation
string relationship = (this.children[1] as RelationTreeNode).relationType;
switch (relationship)
{
// sqrt
case "CONTAINS":
this_symbol = String.Format("<msqrt>{0}</msqrt>", this.children[1].ChildMathML(null));
break;
// supersscript
case "SUPER":
this_symbol = String.Format("<msup>{0}{1}</msup>", this.children[0].ChildMathML(null), this.children[1].ChildMathML(null));
break;
// subscript
case "SUBSC":
this_symbol = String.Format("<msub>{0}{1}</msub>", this.children[0].ChildMathML(null), this.children[1].ChildMathML(null));
break;
}
}
else if (this.children.Count == 3)
{
// frac/sum/etc.
string above = null, below = null, this_sym = null;
bool is_frac = false;
foreach (ParseTreeNode ptn in this.children)
{
if (ptn is RelationTreeNode)
{
RelationTreeNode rtn = null;
rtn = ptn as RelationTreeNode;
if (rtn.relationType == "ABOVE")
{
above = rtn.ChildMathML(null);
}
if (rtn.relationType == "BELOW")
{
below = rtn.ChildMathML(null);
}
}
else if (ptn is SymbolTreeNode)
{
SymbolTreeNode stn = ptn as SymbolTreeNode;
this_sym = stn.ChildMathML(null);
if (stn.nodeType.Equals("-"))
{
is_frac = true;
}
}
}
if (is_frac)
{
this_symbol = String.Format("<mfrac>{0}{1}</mfrac>", above, below);
}
else
{
this_symbol = String.Format("<msubsup>{0}{1}{2}</msubsup>", this_sym, below, above);
}
}
else
{
for (int k = this.children.Count - 1; k >= 0; k--)
{
right = this.children[k].ChildMathML(right);
}
}
if (right == null)
{
return(this_symbol);
}
if (this_symbol == null)
{
return(right);
}
// something to our right
return(String.Format("<mrow>{0}{1}</mrow>", this_symbol, right));
}
else
{
for (int k = this.children.Count - 1; k >= 0; k--)
{
right = this.children[k].ChildMathML(right);
}
return(right);
}
}