public IClassificationResult Classify(IList <Frame> frames, IDictionary <int, IList <Sample> > trajectories)
{
IClassificationResult result = null;
if (trajectories.Count == 0)
{
return(null);
}
else
{
//if (result == null)
//{
// result = RecognizeSemiPinchGesture(inputData);
//}
if (result == null)
{
result = RecognizeBlurryPinchGesture(frames);
}
if (result == null)
{
result = RecognizeBlurryLineGesture(frames);
}
if (result == null)
{
result = RecognizeBlurryCircleGesture(frames);
}
if (result == null)
{
result = RecognizeXFingerDragging(frames, 3);
}
}
return(result);
}
/// <summary>
/// Recognizes the gesture.
/// </summary>
/// <param name="sender">The sender.</param>
private void recognizeGesture(IBrailleIOAdapter sender)
{
IClassificationResult gesture = null;
if (sender != null)
{
if (sender == brailleDisAdapter && brailleDisGestureRecognizer != null)
{
gesture = brailleDisGestureRecognizer.FinishEvaluation();
}
else if (sender == showOffAdapter && showOffGestureRecognizer != null)
{
gesture = showOffGestureRecognizer.FinishEvaluation();
}
}
//TODO: do whatever you want with this gesture result
if (Monitor != null)
{
if (gesture != null)
{
Monitor.SetStatusText("GESTURE form '" + sender + "' :" + gesture.ToString());
}
else
{
Monitor.SetStatusText("No gesture recognized");
}
}
}
/// <summary>
/// Classifies the specified input data.
/// </summary>
/// <param name="inputData">The input data.</param>
/// <returns>a classification result containing name and parameter of the recognized gesture if
/// recognition succeeds, null otherwise.</returns>
public IClassificationResult Classify(TrackedGesture inputData)
{
IClassificationResult result = null;
//RecognizePinchGesture(inputData);
if (inputData.Count == 0)
{
return(result);
}
//if (result == null)
//{
// result = RecognizeSemiPinchGesture(inputData);
//}
if (result == null)
{
result = RecognizeBlurryPinchGesture(inputData);
}
if (result == null)
{
result = RecognizeBlurryLineGesture(inputData);
}
if (result == null)
{
result = RecognizeBlurryCircleGesture(inputData);
}
if (result == null)
{
result = RecognizeXFingerDragging(inputData.FrameList, 3);
}
System.Diagnostics.Debug.WriteLine("recognized: " + (result == null ? "nothing" :
result.ToString()));
return(result);
}
private IClassificationResult RecognizeBlurryLineGesture(IList <Frame> frames)
{
if (!CheckTokenCriterion(frames, 1))
{
return(null);
}
Vertex startPoint, endPoint;
int startPointIndex = FindFirstFrameIndexWithCorrectCount(frames, 1, true);
int endPointIndex = FindFirstFrameIndexWithCorrectCount(frames, 1, false);
Touch t = frames[startPointIndex][0];
startPoint = new Vertex(t.X, t.Y);
int maxDistantBlobFrameIndex;
//search endpoint es point with max distance from start point
//accounts for misleading data and offers robust identification of lines with disadvantage of
//more wrong positive classifications
int maxDistantBlobIndex = GetBlobMaxDistantFromPointIndex(frames, startPoint, out maxDistantBlobFrameIndex);
if (startPointIndex == -1 || endPointIndex == -1 ||
startPointIndex == endPointIndex || maxDistantBlobFrameIndex == -1)
{
return(null);
}
t = frames[endPointIndex][0];
endPoint = new Vertex(t.X, t.Y);
IClassificationResult result = null;
if (CheckMaxDistanceFromLineKriterion(frames, startPoint, endPoint, MAXDISTFROMLINE) &&
MetricDistances.EuclideanDistance(startPoint, endPoint) > MINLINELENGTH)
{
//return RecognizeDirectionalLine(startPoint, endPoint);
result = new ClassificationResult(
"line",
0.9,
new Sample[] {
new Sample(DateTime.Now, startPoint),
new Sample(DateTime.Now, endPoint)
},
new Dictionary <String, Object>()
{
{ "FirstTouch", startPoint },
{ "LastTouch", endPoint },
{ "angle", GetAngle(startPoint, endPoint) }
});
}
return(result);
}
public virtual IClassificationResult FinishEvaluation(bool clear)
{
IClassificationResult classificationResult = null;
if (blobTracker != null)
{
TrackedGesture trackedGesture = blobTracker.TrackedBlobs;
RecognitionMode = false;
if (blobTracker.Trajectories.Count > 0)
{
Console.WriteLine("Gesture trajectories to evaluate:" + blobTracker.Trajectories.Count);
List <IClassificationResult> oldResults = new List <IClassificationResult>();
// foreach (IClassify classifier in classifiers){
for (int i = 0; i < classifiers.Count; i++)
{
IClassify classifier = classifiers[i];
if (classifier != null)
{
classificationResult = classifier.Classify(blobTracker.FrameList, blobTracker.Trajectories);
if (classificationResult != null)
{
if (classificationResult.Probability > ProbabilityThreshold)
{
break;
}
else
{
oldResults.Add(classificationResult);
}
}
}
}
// no result was taken directly, so find the first one with the highest probability
if (oldResults != null && oldResults.Count > 0)
{
foreach (var result in oldResults)
{
if (classificationResult == null || result.Probability > classificationResult.Probability)
{
classificationResult = result;
}
}
}
}
if (clear)
{
blobTracker.InitiateTracking();
}
}
return(classificationResult);
}
// stop sending touch values to the gesture recognizer and return the Point where the user tapped, if applicable
public Point FinishGestureDetection()
{
interpretGesture = false; // stop receiving gestures on the device
Point pointToSelect = new Point(-1, -1); // initialize the point to be returned
IClassificationResult gesture = gestureRecognizer.FinishEvaluation(); // interpret the gestures given to the device
// if the user tapped the device in a specified location, return that location - otherwise return (-1,-1)
if (gesture != null)
{
pointToSelect = new Point(Convert.ToInt32(gesture.NodeParameters[0].X), Convert.ToInt32(gesture.NodeParameters[0].Y));
}
return(pointToSelect);
}
private IClassificationResult RecognizeBlurryLineGesture(TrackedGesture inputData)
{
if (!CheckTokenCriterion(inputData.FrameList, 1))
{
return(null);
}
Vertex startPoint, endPoint;
int startPointIndex = FindFirstFrameIndexWithCorrectCount(inputData.FrameList, 1, true);
int endPointIndex = FindFirstFrameIndexWithCorrectCount(inputData.FrameList, 1, false);
Touch t = inputData.FrameList[startPointIndex][0];
startPoint = new Vertex(t.x, t.y);
int maxDistantBlobFrameIndex;
//search endpoint es point with max distance from start point
//accounts for misleading data and offers robust identification of lines with disadvantage of
//more wrong positive classifications
int maxDistantBlobIndex = GetBlobMaxDistantFromPointIndex(inputData.FrameList, startPoint, out maxDistantBlobFrameIndex);
if (startPointIndex == -1 || endPointIndex == -1 ||
startPointIndex == endPointIndex || maxDistantBlobFrameIndex == -1)
{
return(null);
}
t = inputData.FrameList[endPointIndex][0];
endPoint = new Vertex(t.x, t.y);
IClassificationResult result = null;
if (CheckMaxDistanceFromLineKriterion(inputData.FrameList, startPoint, endPoint, MAXDISTFROMLINE) &&
MetricDistances.EuclideanDistance(startPoint, endPoint) > MINLINELENGTH)
{
//return RecognizeDirectionalLine(startPoint, endPoint);
result = new ClassificationResult("line", 100.0, new Sample[] { new Sample(DateTime.Now, startPoint), new Sample(DateTime.Now, endPoint) },
new KeyValuePair <String, double>("angle", GetAngle(startPoint, endPoint)));
}
return(result);
}
public IClassificationResult FinishEvaluation()
{
TrackedGesture trackedGesture = blobTracker.TrackedBlobs;
IClassificationResult classificationResult = null;
RecognitionMode = false;
foreach (IClassify classifier in classifiers)
{
classificationResult = classifier.Classify(trackedGesture);
if (classificationResult != null)
{
blobTracker.InitiateTracking();
return(classificationResult);
}
}
blobTracker.InitiateTracking();
return(classificationResult);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
if (expression is FlatAddExpression fa)
{
IExpression a = null;
IExpression b = null;
IExpression c = null;
List <IExpression> ca = new List <IExpression>();
for (int i = 0; i < fa.Expressions.Count; i++)
{
var kv = fa.Expressions.ElementAt(i);
var deg = kv.Value[0].DimensionKey.Value;
var key = kv.Value[0].DimensionKey.Key;
var expr = kv.Value[0];
if (deg.ToNumber() == 2 && key == variable)
{
if (expr is VariableExpression)
{
a = new ComplexExpression(expr.Count);
}
else if (expr is IFunctionExpression)
{
a = new ComplexExpression(expr.Count);
}
else
{
var tmp = (FlatExpression)expr.Clone();
tmp.Remove(variable, 2);
a = tmp;
}
}
else if (deg.ToNumber() == 1 && key == variable)
{
if (expr is VariableExpression)
{
b = new ComplexExpression(expr.Count);
}
else if (expr is IFunctionExpression)
{
b = new ComplexExpression(expr.Count);
}
else
{
var tmp = (FlatExpression)expr.Clone();
tmp.Remove(variable, 2);
b = tmp;
}
}
else
{
ca.Add(kv.Value[0]);
}
}
if (ca.Count > 1)
{
c = new FlatAddExpression();
var ct = (FlatAddExpression)c;
foreach (var ci in ca)
{
ct.Add(ci);
}
}
else if (ca.Count == 1)
{
c = ca[0];
}
if (a != null && c != null)
{
var delta = this.Delta(a, b, c);
var ds = new BinaryExpression(delta, Enums.Operators.OperatorTypes.Power, new NumberExpression(new Fraction(1, 2)));
var dsqrt = ds.Execute();
var r1 = X1X2(b, dsqrt, a, true);
var r2 = X1X2(b, dsqrt, a, false);
res.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(classification.SearchResult[variable].Item1, new List <IExpression>()
{
r1.Execute()
}));
res.Solutions[variable].Item2.Add(r2.Execute());
}
}
return(res);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
List <IExpression> al = new List <IExpression>();
List <IExpression> bl = new List <IExpression>();
List <IExpression> cl = new List <IExpression>();
if (expression is FlatAddExpression fa)
{
foreach (var kv in fa.Expressions)
{
var expr = kv.Value[0];
if (expr is IFunctionExpression)
{
if (expr is CosExpression)
{
al.Add(expr);
}
else if (expr is SinExpression)
{
al.Add(expr);
}
else if (expr is TanExpression)
{
al.Add(expr);
}
else if (expr is CotExpression)
{
al.Add(expr);
}
else
{
bl.Add(expr);
}
}
else if (expr is FlatExpression fe)
{
if (fe.Expressions.Any(e => e.Key == variable))
{
bl.Add(expr);
}
else
{
cl.Add(expr);
}
}
else if (expr.DimensionKey.Key == variable)
{
bl.Add(expr);
}
else
{
cl.Add(expr);
}
}
if (bl.Count > 0)
{
//General way of solving
}
if (al.Count > 1)
{
//General way of solving ?
}
if (al.Count == 1)
{
var expr = (IFunctionExpression)al[0];
if (expr.InverseFunction != 0)
{
var arg = new FlatAddExpression();
foreach (var e in cl)
{
arg.Add(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, e).Execute());
}
arg.Execute();
var sol = Functions.Get(expr.InverseFunction.ToString(), arg).Execute();
var solFor = expr.Argument.DimensionKey.Key;
res.Solutions.Add(solFor, new Tuple <IExpression, List <IExpression> >(expr.Argument, new List <IExpression>()
{
sol
}));
}
else
{
//No inverse function => Numeric solution ?
}
}
}
return(res);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
IExpression a = null;
IExpression b = null;
List <IExpression> ba = new List <IExpression>();
if (expression is FlatAddExpression fa)
{
foreach (var expr in fa.Expressions)
{
if (expr.Value[0] is FlatExpression fe)
{
if (fe.Expressions.Any(e => e.Key == variable))
{
if (expr.Value[0] is VariableExpression)
{
a = new ComplexExpression(expr.Value[0].Count);
}
else
{
var tmp = (FlatExpression)expr.Value[0].Clone();
tmp.Remove(variable, 1);
a = tmp;
}
}
}
else if (expr.Key == variable)
{
if (expr.Value[0] is VariableExpression)
{
a = new ComplexExpression(expr.Value[0].Count);
}
else
{
var tmp = (FlatExpression)expr.Value[0].Clone();
tmp.Remove(variable, 1);
a = tmp;
}
}
else
{
ba.Add(expr.Value[0]);
}
}
if (ba.Count > 1)
{
b = new FlatAddExpression();
var ct = (FlatAddExpression)b;
foreach (var ci in ba)
{
ct.Add(ci);
}
}
else if (ba.Count == 1)
{
b = ba[0];
}
var sol = new BinaryExpression(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, b), Enums.Operators.OperatorTypes.Divide, a).Execute();
res.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(classification.SearchResult[variable].Item1, new List <IExpression>()
{
sol
}));
}
return(res);
}
private void fireClassifiedGestureEvent(IClassificationResult result, BrailleIODevice device, List<BrailleIO_DeviceButton> releasedKeys, List<String> releasedGenKeys, List<BrailleIO_DeviceButton> pressedKeys, List<String> pressedGenKeys)
{
if (result != null)
{
System.Diagnostics.Debug.WriteLine("gesture recognized: " + result);
Logger.Instance.Log(LogPriority.DEBUG, this, "[GESTURE] result " + result);
fireGestureEvent(device, releasedKeys, releasedGenKeys, pressedKeys, pressedGenKeys, result);
}
}
