/// <summary>
/// 识别
/// </summary>
/// <param name="strokes">笔迹集合</param>
/// <returns>候选词数组</returns>
public string[] Recognize(StrokeCollection strokes)
{
if (strokes == null || strokes.Count == 0)
{
return(Params.EmptyAlternates);
}
var stroke = GetCombinedStore(strokes);
var analyzer = new InkAnalyzer();
analyzer.AddStroke(stroke, Params.SimplifiedChineseLanguageId);
analyzer.SetStrokeType(stroke, StrokeType.Writing);
var status = analyzer.Analyze();
if (status.Successful)
{
var result = analyzer.GetAlternates()
.OfType <AnalysisAlternate>()
.Select(x => x.RecognizedString)
.ToArray();
analyzer.Dispose();
return(result);
}
analyzer.Dispose();
return(Params.EmptyAlternates);
}
/// <summary>
/// 识别（将多个笔画集合成一起识别，提高单字的识别率）
/// </summary>
/// <param name="strokes">笔迹集合</param>
/// <returns>候选词数组</returns>
public string[] Recognize(StrokeCollection strokes)
{
if (strokes == null || strokes.Count == 0)
{
return(null);
}
var stroke = GetCombinedStore(strokes);
var analyzer = new InkAnalyzer();
analyzer.AddStroke(stroke, 0x0804);
analyzer.SetStrokeType(stroke, StrokeType.Writing);
var status = analyzer.Analyze();
if (status.Successful)
{
return(analyzer.GetAlternates()
.OfType <AnalysisAlternate>()
.Select(x => x.RecognizedString)
.ToArray());
}
analyzer.Dispose();
return(null);
}
private void theInkCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e)
{
var stroke = GetCombinedStore(this.theInkCanvas.Strokes);
InkAnalyzer theInkAnalyzer = new InkAnalyzer();
//theInkAnalyzer.AddStrokes(this.theInkCanvas.Strokes, 0x0804);
//theInkAnalyzer.SetStrokesType(this.theInkCanvas.Strokes, StrokeType.Writing);
theInkAnalyzer.AddStroke(stroke, 0x0804);
theInkAnalyzer.SetStrokeType(stroke, StrokeType.Writing);
AnalysisStatus status = theInkAnalyzer.Analyze();
if (status.Successful)
{
List <StrokeWord> slist = new List <StrokeWord>();
//textBox1.Text = theInkAnalyzer.GetRecognizedString();
for (int i = 0; i < theInkAnalyzer.GetAlternates().Count; i++)
{
StrokeWord sw = new StrokeWord();
sw.StrokeName = theInkAnalyzer.GetAlternates()[i].RecognizedString;
slist.Add(sw);
}
this.StrokeWordList = new List <StrokeWord>();
this.StrokeWordList = slist;
}
else
{
MessageBox.Show("识别失败");
}
}
/// <summary>
/// 识别
/// </summary>
/// <param name="strokes">笔迹集合</param>
/// <returns>候选词数组</returns>
public string[] Recognize(StrokeCollection strokes)
{
if (strokes == null || strokes.Count == 0)
{
return(Constants.EmptyAlternates);
}
var analyzer = new InkAnalyzer();
analyzer.AddStrokes(strokes, Constants.ChsLanguageId);
analyzer.SetStrokesType(strokes, StrokeType.Writing);
var status = analyzer.Analyze();
if (status.Successful)
{
return(analyzer.GetAlternates()
.OfType <AnalysisAlternate>()
.Select(x => x.RecognizedString)
.ToArray());
}
analyzer.Dispose();
return(Constants.EmptyAlternates);
}
private void InkCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e)
{
InkAnalyzer analyser = new InkAnalyzer();
analyser.AddStrokes(_inkCanvas.Strokes);
analyser.Analyze();
_inkResults.Text = analyser.GetRecognizedString();
e.Handled = false;
}
private void InsertButton_Click(object sender, RoutedEventArgs e)
{
InkAnalyzer inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(insertionBox.InkCanvas.Strokes);
inkAnalyzer.Analyze();
InkUtils.MergeParagraphs(inkAnalyzer);
insertReflow.process(inkAnalyzer);
insertionBox.Visibility = Visibility.Collapsed;
inserter.insertStrokes(this.inkAnalyzer, MainInkCanvas, insertionBox.InkCanvas);
}
private void TabControlSelectedIndexChanged(object sender, EventArgs e)
{
if (this.tabControl.SelectedIndex == 1)
{
// Analyze the strokes that have been added to the InkAnalyzer.
analyzer.Analyze();
// Populate the TextBoxes with the results of the analysis.
this.UpdateTextBoxes();
}
}
// IACore,IAWinFx
// C:\Program Files\Reference Assemblies\Microsoft\Tablet PC\v1.7
// IALoader
// C:\Program Files\Microsoft SDKs\Windows\v6.1\Bin
// それぞれのライブラリは「Windows SDK for Windows Server 2008 and .NET Framework 3.5」で取得できる
// http://www.microsoft.com/en-us/download/confirmation.aspx?id=11310
private string InkAnalyze(InkCanvas canvas)
{
InkAnalyzer theInkAnalyzer = new InkAnalyzer();
// キャンバスに描かれた文字を認識するためにアナライザにストロークをセット
theInkAnalyzer.AddStrokes(canvas.Strokes);
theInkAnalyzer.SetStrokesType(canvas.Strokes, StrokeType.Writing);
// 文字を解析
theInkAnalyzer.Analyze();
// 文字を解析した結果の第1候補を返す
return(theInkAnalyzer.GetRecognizedString());
}
static public bool IsChar(this Stroq stroke, string charset)
{
System.Windows.Ink.InkAnalyzer ia = new InkAnalyzer();
ia.AddStroke(stroke.BackingStroke);
//AnalysisHintNode node = ia.CreateAnalysisHint();
//node.Factoid = "IS_ONECHAR";
//node.CoerceToFactoid = true;
//node.Location.MakeInfinite();
AnalysisStatus astat = ia.Analyze();
string reco = ia.GetRecognizedString();
Console.WriteLine("Recognized:<" + reco + ">");
if (astat.Successful && reco != "Other")
{
return(charset.Contains(reco[0]));
}
return(false);
}
private static bool strokeIsHorizontalLine(Stroke stroke)
{
InkAnalyzer temp = new InkAnalyzer();
temp.AddStroke(stroke);
temp.Analyze();
ContextNode node = temp.RootNode.SubNodes[0];
if (node is InkDrawingNode)
{
InkDrawingNode drawing = node as InkDrawingNode;
PointCollection boundingBox = drawing.GetRotatedBoundingBox();
double d1 = distSquared(boundingBox[0], boundingBox[1]);
double d2 = distSquared(boundingBox[1], boundingBox[2]);
return((d2 > 0 && d1 / d2 > 10 * 10 && d1 > 100 && Math.Abs(slope(boundingBox[0], boundingBox[1])) < 0.5) ||
(d1 > 0 && d2 / d1 > 10 * 10 && d2 > 100 && Math.Abs(slope(boundingBox[1], boundingBox[2])) < 0.5));
}
return(false);
}
public String Recognize([FromBody] Results.Stroke stroke)
{
var strokePointsData = JsonConvert.DeserializeObject<dynamic>(stroke.Json);
var strokeCollection = GetStrokeCollectionFromPoints(strokePointsData);
var inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(strokeCollection);
var analysisStatus = inkAnalyzer.Analyze();
if (analysisStatus.Successful)
{
var recognizedString = inkAnalyzer.GetRecognizedString();
return recognizedString;
}
else
return "Data not recognized";
}
public HttpResponseMessage<String> Recognize(string strokes)
{
var strokePointsData = JsonConvert.DeserializeObject<dynamic>(strokes);
var strokeCollection = GetStrokeCollectionFromPoints(strokePointsData);
var inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(strokeCollection);
var analysisStatus = inkAnalyzer.Analyze();
if (analysisStatus.Successful)
{
var recognizedString = inkAnalyzer.GetRecognizedString();
return new HttpResponseMessage<string>(recognizedString);
}
else
return new HttpResponseMessage<string>("Data not recognized");
}
public HttpResponseMessage <String> Recognize(string strokes)
{
var strokePointsData = JsonConvert.DeserializeObject <dynamic>(strokes);
var strokeCollection = GetStrokeCollectionFromPoints(strokePointsData);
var inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(strokeCollection);
var analysisStatus = inkAnalyzer.Analyze();
if (analysisStatus.Successful)
{
var recognizedString = inkAnalyzer.GetRecognizedString();
return(new HttpResponseMessage <string>(recognizedString));
}
else
{
return(new HttpResponseMessage <string>("Data not recognized"));
}
}
private void btnAnalyze_Click(object sender, RoutedEventArgs e)
{
InkAnalyzer theInkAnalyzer = new InkAnalyzer();
// キャンバスに描かれた文字を認識するためにアナライザにストロークをセット
theInkAnalyzer.AddStrokes(InkCanvas1.Strokes);
theInkAnalyzer.SetStrokesType(InkCanvas1.Strokes, StrokeType.Writing);
// 文字を解析
theInkAnalyzer.Analyze();
// 文字を解析した結果の第1候補を表示する
MessageBox.Show(theInkAnalyzer.GetRecognizedString());
// その他の候補を表示する
AnalysisAlternateCollection alternates = theInkAnalyzer.GetAlternates();
foreach (var alternate in alternates)
{
MessageBox.Show(alternate.RecognizedString);
}
}
public String Recognize([FromBody] Results.Stroke stroke)
{
var strokePointsData = JsonConvert.DeserializeObject <dynamic>(stroke.Json);
var strokeCollection = GetStrokeCollectionFromPoints(strokePointsData);
var inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(strokeCollection);
var analysisStatus = inkAnalyzer.Analyze();
if (analysisStatus.Successful)
{
var recognizedString = inkAnalyzer.GetRecognizedString();
return(recognizedString);
}
else
{
return("Data not recognized");
}
}
/// <summary>
/// Analyze a new stroke.
/// </summary>
/// <param name="stroke"></param>
/// <returns>true if the stroke was recognized as belonging to a graph (and so should be excluded from InkAnalyzer)</returns>
public bool newStroke(Stroke stroke)
{
if (strokes.ContainsKey(stroke))
{
// already have it!
return(true);
}
foreach (Graph g in graphs)
{
if (g.containsStroke(stroke) && g.takeStroke(stroke))
{
strokes.Add(stroke, g);
return(true);
}
}
Stroke copy = stroke.Clone();
analyzer.AddStroke(copy);
analyzer.Analyze();
StrokeCollection sc = new StrokeCollection(new Stroke[] { copy });
ContextNodeCollection ctxNodes = analyzer.FindInkLeafNodes(sc);
foreach (ContextNode ctxNode in ctxNodes)
{
if (ctxNode is InkDrawingNode && (ctxNode as InkDrawingNode).GetShapeName() == "Rectangle")
{
Graph g = new XYGraph(this, stroke);
graphs.Add(g);
strokes.Add(stroke, g);
analyzer.RemoveStroke(copy);
return(true);
}
}
analyzer.RemoveStroke(copy);
return(false);
}
public MyInkAnalyzer(StrokeCollection strokeCollection)
{
if (strokeCollection.Count > 0)
{
_strokeCollection = strokeCollection;
analyze = new InkAnalyzer();
//2052：简体中文 1033：英语
analyze.AddStrokes(strokeCollection, GlobalValues.InkAnalyzerLanguageId);
//analyze.BackgroundAnalyze();
AnalysisStatus status = analyze.Analyze();
if (status.Successful)
{
analyzeResults = analyze.GetRecognizedString();
}
else
{
analyzeResults = "Recognition Failed";
}
analyze.RemoveStrokes(_strokeCollection);
}
}
private static bool strokeIsHorizontalLine(Stroke stroke)
{
InkAnalyzer temp = new InkAnalyzer();
temp.AddStroke(stroke);
temp.Analyze();
ContextNode node = temp.RootNode.SubNodes[0];
if (node is InkDrawingNode)
{
InkDrawingNode drawing = node as InkDrawingNode;
PointCollection boundingBox = drawing.GetRotatedBoundingBox();
double d1 = distSquared(boundingBox[0], boundingBox[1]);
double d2 = distSquared(boundingBox[1], boundingBox[2]);
return (d2 > 0 && d1 / d2 > 10 * 10 && d1 > 100 && Math.Abs(slope(boundingBox[0], boundingBox[1])) < 0.5)
|| (d1 > 0 && d2 / d1 > 10 * 10 && d2 > 100 && Math.Abs(slope(boundingBox[1], boundingBox[2])) < 0.5);
}
return false;
}
public void Populate(ICollection <Recognition> recogs, StroqCollection stroqs)
{
alternateRec = recogs.Count == 1 ? recogs.Single() : null;
if (alternateRec != null && !stroqs.All((s) => alternateRec.strokes.Contains(_mrec.Sim[s])))
{
alternateRec = null;
}
altstroqsRec = stroqs;
altrecogsRec = recogs;
_menuShell.Items.Clear();
MenuItem mi;
bool needseparator = false;
if (recogs.Count == 1)
{
/* regular alternates*/
Recognition rr = recogs.Single();
for (int i = 0; i < rr.alts.Length; i++)
{
string label;
char c = rr.alts[i].Character;
if (c != 0)
{
label = c.ToString();
}
else
{
label = rr.alts[i].Word;
if (label == null)
{
label = rr.alts[i].ToString();
label = label.Substring(1, label.Length - 2);
}
}
mi = new MenuItem();
mi.Header = label;
if (c != 0)
{
mi.ToolTip = Unicode.NameOf(c);
mi.FontFamily = new FontFamily(starPadSDK.MathExpr.ExprWPF.EDrawingContext.FontFamilyURIBase,
starPadSDK.MathExpr.ExprWPF.EDrawingContext.FontFamilyURIRel);
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'α' && c <= 'ω') || c == Unicode.G.GREEK_PHI_SYMBOL)
{
mi.FontStyle = FontStyles.Italic;
}
}
else
{
mi.ToolTip = label;
}
mi.Tag = i;
mi.Click += ChooseAlternate;
mi.PreviewMouseDown += mi_MouseDown;
mi.PreviewMouseUp += mi_MouseUp;
if (i == 0)
{
mi.AllowDrop = true;
mi.DragEnter += mi_DragCheck;
mi.DragOver += mi_DragCheck;
mi.Drop += mi_Drop;
}
if (rr.curalt == i)
{
mi.IsChecked = true;
}
_menuShell.Items.Add(mi);
}
needseparator = true;
}
if (stroqs.Count > 1 && stroqs.Count != recogs.Count /* FIXME: if a stroke has no recog, this won't work */)
{
/* option to split apart and recognize each stroke separately */
if (needseparator)
{
_menuShell.Items.Add(new Separator());
needseparator = false;
}
string label = "";
foreach (Stroq s1 in stroqs)
{
Recognition r = _mrec.Charreco.Classify(_mrec.Sim[s1], true);
if (r == null)
{
continue;
}
string l;
char c = r.alt.Character;
if (c != 0)
{
l = c.ToString();
}
else
{
l = r.alt.Word;
if (l == null)
{
l = r.alt.ToString();
l = l.Substring(1, l.Length - 2);
}
}
label += l;
}
mi = new MenuItem();
mi.Header = label;
mi.ToolTip = "split combined symbol into separate symbols";
mi.Tag = -1;
mi.Click += ChooseAlternate;
_menuShell.Items.Add(mi);
needseparator = true;
}
if (stroqs.Count > 0)
{
/* Interpret everything as a single word */
if (needseparator)
{
_menuShell.Items.Add(new Separator());
needseparator = false;
}
InkAnalyzer ia = new InkAnalyzer();
AnalysisHintNode ahn = ia.CreateAnalysisHint();
ahn.WordMode = true;
ahn.Location.MakeInfinite();
foreach (Stroq s in stroqs)
{
ia.AddStroke(s.BackingStroke);
}
AnalysisStatus stat = ia.Analyze();
if (stat.Successful)
{
AnalysisAlternateCollection aac = ia.GetAlternates();
for (int i = 0; i < aac.Count; i++)
{
if (aac[i].AlternateNodes.Count > 1 || !(aac[i].AlternateNodes[0] is InkWordNode))
{
continue;
}
mi = new MenuItem();
mi.Header = aac[i].RecognizedString;
mi.ToolTip = "interpret all selected strokes as a single character or word: alternate " + (i + 1);
mi.Tag = aac[i];
mi.Click += ChooseAlternate;
if (alternateRec != null)
{
mi.PreviewMouseDown += mi_MouseDown;
mi.PreviewMouseUp += mi_MouseUp;
}
if (aac[i].RecognizedString.Length == 1)
{
char c = aac[i].RecognizedString[0];
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'α' && c <= 'ω'))
{
mi.FontStyle = FontStyles.Italic;
}
mi.ToolTip = (string)mi.ToolTip + " (" + Unicode.NameOf(c) + ")";
}
_menuShell.Items.Add(mi);
}
}
}
_menuShell.InvalidateMeasure(); // odd that I need this
}
///Draw handwritings
//private void DrawHandwriting(Skeleton skeleton, DrawingContext drawingContext)
//{
// Joint handRightJoint = skeleton.Joints[JointType.HandRight];
// Point handRightPoint = SkeletonPointToScreen(handRightJoint.Position);
// Joint handLeftJoint = skeleton.Joints[JointType.HandLeft];
// Point handLeftPoint = SkeletonPointToScreen(handLeftJoint.Position);
// if (handLeftPoint.Y < handRightPoint.Y)
// {
// if (!handwritings.Points.Contains(handRightPoint))
// {
// handwritings.Points.Add(handRightPoint);
// }
// for (int i = 0; i < handwritings.Points.Count - 1; i++)
// {
// drawingContext.DrawLine(new Pen(Brushes.Yellow, 3), handwritings.Points[i], handwritings.Points[i + 1]);
// }
// }
// else
// handwritings.Points.Clear(); // To clear the old painting
// if (handwritings.Points.Count > 0)
// {
// StylusPointCollection spc = new StylusPointCollection();
// for (int i = 0; i < handwritings.Points.Count; i++)
// {
// spc.Add(new StylusPoint(handwritings.Points[i].X, handwritings.Points[i].Y));
// }
// Stroke s = new Stroke(spc);
// StrokeCollection sc = new StrokeCollection(new Stroke[] { s });
// InkAnalyzer inkAnalyzer = new InkAnalyzer();
// inkAnalyzer.AddStrokes(sc);
// AnalysisStatus status = inkAnalyzer.Analyze();
// if (status.Successful)
// {
// textBlockResult.Text = inkAnalyzer.GetRecognizedString();
// sc.Clear();
// }
// }
//}
private void DrawColorfulHandwriting(Skeleton skeleton, DrawingContext drawingContext)
{
Joint handRightJoint = skeleton.Joints[JointType.HandRight];
Point handRightPoint = SkeletonPointToScreen(handRightJoint.Position);
Joint handLeftJoint = skeleton.Joints[JointType.HandLeft];
Point handLeftPoint = SkeletonPointToScreen(handLeftJoint.Position);
int depth = SkeletonDepthToScreen(handRightJoint.Position);
//SolidColorBrush brush = new SolidColorBrush();
int fontsize;
if (depth < 1500)
{
//brush = Brushes.White;
fontsize = 36;
}
else if (depth < 2000)
{
//brush = Brushes.Pink;
fontsize = 56;
}
else
{
//brush = Brushes.Red;
fontsize = 72;
}
if (handLeftPoint.Y < handRightPoint.Y)
{
if (!handwritings.Points.Contains(handRightPoint))
{
handwritings.Points.Add(handRightPoint);
}
for (int i = 0; i < handwritings.Points.Count - 1; i++)
{
drawingContext.DrawLine(new Pen(brush, 3), handwritings.Points[i], handwritings.Points[i + 1]);
}
//StartSineWave(depth);
}
else
{
StopSineWave();
handwritings.Points.Clear(); // To clear the old painting
}
if (handwritings.Points.Count > 0)
{
StylusPointCollection spc = new StylusPointCollection();
for (int i = 0; i < handwritings.Points.Count; i++)
{
spc.Add(new StylusPoint(handwritings.Points[i].X, handwritings.Points[i].Y));
}
Stroke s = new Stroke(spc);
StrokeCollection sc = new StrokeCollection(new Stroke[] { s });
InkAnalyzer inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(sc);
AnalysisStatus status = inkAnalyzer.Analyze();
if (status.Successful)
{
textBlockResult.Text = inkAnalyzer.GetRecognizedString();
textBlockResult.FontSize = fontsize;
sc.Clear();
}
}
}
private void OCRText(int mode = 0)
{
StrokeCollection sc;
switch (mode)
{
case 0:
sc = OCRCanvas.Strokes;
break;
case 1:
sc = TegakiCanvas.GetSelectedStrokes();
break;
default:
return;
}
ia = new InkAnalyzer();
if (sc.Count == 0)
{
return;
}
CustomRecognizerNode node;
double x, y;
int height;
getStrokeZahyo(sc, out x, out y, out height);
// キャンバスに描かれた文字を認識するためにアナライザにストロークをセット
if (EngineList.SelectedItem != null)
{
node = ia.CreateCustomRecognizer((Guid)EngineList.SelectedValue);
ia.AddStrokesToCustomRecognizer(sc, node);
}
else
{
ia.AddStrokes(sc);
}
ia.SetStrokesType(sc, StrokeType.Writing);
// 文字を解析
ia.Analyze();
//罫線にピタッとなるようにする
y = ((int)((y + lineMargine / 2) / lineMargine) * lineMargine) + 1 * (int)((y + lineMargine / 2) / lineMargine);
height = (int)((height + lineMargine / 2) / lineMargine) * lineMargine;
if (height >= 8)
{
TextBlock tb = new TextBlock()
{
Text = ia.GetRecognizedString(), FontSize = height - 8, VerticalAlignment = System.Windows.VerticalAlignment.Top, LineStackingStrategy = LineStackingStrategy.BlockLineHeight, LineHeight = height
};
//noteRoot.Children.Add(tb);
TegakiCanvas.Children.Add(tb);
InkCanvas.SetLeft(tb, x);
InkCanvas.SetTop(tb, y);
}
//textBox1.Text += ia.GetRecognizedString();
switch (mode)
{
case 0:
OCRCanvas.Strokes.Clear();
break;
case 1:
foreach (Stroke s in sc)
{
TegakiCanvas.Strokes.Remove(s);
}
break;
}
/*
* // その他の候補を表示する
* AnalysisAlternateCollection alternates = theInkAnalyzer.GetAlternates();
* foreach (var alternate in alternates)
* MessageBox.Show(alternate.RecognizedString);
*/
}
// IACore,IAWinFx
// C:\Program Files\Reference Assemblies\Microsoft\Tablet PC\v1.7
// IALoader
// C:\Program Files\Microsoft SDKs\Windows\v6.1\Bin
// それぞれのライブラリは「Windows SDK for Windows Server 2008 and .NET Framework 3.5」で取得できる
// http://www.microsoft.com/en-us/download/confirmation.aspx?id=11310
private string InkAnalyze( InkCanvas canvas )
{
InkAnalyzer theInkAnalyzer = new InkAnalyzer();
// キャンバスに描かれた文字を認識するためにアナライザにストロークをセット
theInkAnalyzer.AddStrokes( canvas.Strokes );
theInkAnalyzer.SetStrokesType( canvas.Strokes, StrokeType.Writing );
// 文字を解析
theInkAnalyzer.Analyze();
// 文字を解析した結果の第1候補を返す
return theInkAnalyzer.GetRecognizedString();
}
private void InsertButton_Click(object sender, RoutedEventArgs e)
{
InkAnalyzer inkAnalyzer = new InkAnalyzer();
inkAnalyzer.AddStrokes(insertionBox.InkCanvas.Strokes);
inkAnalyzer.Analyze();
InkUtils.MergeParagraphs(inkAnalyzer);
insertReflow.process(inkAnalyzer);
insertionBox.Visibility = Visibility.Collapsed;
inserter.insertStrokes(this.inkAnalyzer, MainInkCanvas, insertionBox.InkCanvas);
}
