public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
bool result = true;
foreach (var point in points)
{
// TODO: We need to check the unit type (i.e. sec, min,...) and compare accordingly
if (_data.Unit.StartsWith("msec"))
{
if (point.Age.TotalMilliseconds <= _data.Value)
result = false;
}
else if (_data.Unit.StartsWith("sec"))
{
if (point.Age.TotalSeconds <= _data.Value)
result = false;
}
else
{
throw new LanguageSyntaxErrorException("Invalid unit for \"TouchTime\" primitive condition!");
}
}
if (result)
sets.Add(new ValidSetOfTouchPoints(points));
return sets;
}
/// <summary>
/// Adds the items from the specified collection into existing collection
/// </summary>
/// <param name="self"></param>
/// <param name="itemsToAdd"></param>
public static void Add(this ValidSetOfPointsCollection self, ValidSetOfPointsCollection itemsToAdd)
{
foreach (ValidSetOfTouchPoints item in itemsToAdd)
{
self.Add(item);
}
}
/// <summary>
/// Only checks if system has the number of history data as mentioned
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
//Algo: For each point, we need to check if a point has n more touch points in the history.
//For example, for a point p1 in points collections, we need to check if there is another point
//p2 where p2.endTime is less than p1.start time. In the same way, is there any p3... and go on
//upto nth level where n = _data.TouchCount
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints();
// Check if enough history data is recorded
if (TouchHistoryTracker.Count >= _data.TouchCount)
{
foreach (var point in points)
{
DateTime earliestValidTime = GetEarliestValidTime(point);
Rect location = RuleValidationHelper.GetBoundingBox(point);
if (RuleValidationHelper.HasPreviousTouchPoints(location, point, _data.TouchCount, earliestValidTime))
set.Add(point);
}
}
if (set.Count > 0)
sets.Add(set);
return sets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection list = new ValidSetOfPointsCollection();
foreach (ValidSetOfTouchPoints set in sets)
{
ValidSetOfPointsCollection tmpList = Validate(set);
list.AddRange(tmpList);
}
return list;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection result = new ValidSetOfPointsCollection();
foreach (var item in sets)
{
ValidSetOfPointsCollection list = Validate(item);
foreach (var set in list)
{
result.Add(set);
}
}
return result;
}
public static ValidSetOfPointsCollection ForEachSet(this ValidSetOfPointsCollection self, Validate validateMethod)
{
ValidSetOfPointsCollection validSets = new ValidSetOfPointsCollection();
foreach (var item in self)
{
ValidSetOfPointsCollection list = validateMethod(item);
foreach (var set in list)
{
validSets.Add(set);
}
}
return validSets;
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection list = new ValidSetOfPointsCollection();
foreach (TouchPoint2 point in points)
{
if (point.Tag != null)
{
if (point.Tag == _data.Value)
list.Add(new ValidSetOfTouchPoints(points));
}
}
return list;
}
public ValidSetOfPointsCollection Validate(System.Collections.Generic.List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints();
foreach (var point in points)
{
if (IsEnclosedAreaWithinRange(point.Stroke.StylusPoints))
set.Add(point);
}
if (set.Count > 0)
sets.Add(set);
return sets;
}
public static void Add(string gestureName, int blockNo, ValidSetOfPointsCollection data, string blockName)
{
List<ValidateBlockResult> previous = Get(gestureName, blockNo);
if (previous.Count >= 1)
{
Remove(previous[0]);
}
var item = new ValidateBlockResult()
{
Data = data,
GestureName = gestureName,
ValidateBlockNo = blockNo,
ValidateBlockName = blockName
};
_cache.Add(item);
}
public ValidSetOfPointsCollection Validate(System.Collections.Generic.List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
if (points.Count > 0)
{
Rect parent = points[0].Stroke.GetBounds();
for (int i = 1; i < points.Count; i++)
{
Rect rect = points[i].Stroke.GetBounds();
parent.Union(rect);
}
if (parent.Height >= _data.MinHeight && parent.Height <= _data.MaxHeight
&& parent.Width >= _data.MinWidth && parent.Width <= _data.MaxWidth)
{
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints(points);
sets.Add(set);
}
}
return sets;
}
public ValidSetOfPointsCollection Validate(System.Collections.Generic.List<TouchPoint2> points)
{
bool result = true;
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
if (points.Count > 1)
{
UIElement source = points[0].Source;
for (int i = 1; i < points.Count; i++)
{
if (source != points[i].Source)
{
result = false;
break;
}
}
}
if (result)
sets.Add(new ValidSetOfTouchPoints(points));
return sets;
}
private ValidSetOfPointsCollection IsValid(List<TouchPoint2> points)
{
bool result = true;
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
if (points.Count > 0)
{
//double minX = int.MinValue, minY = int.MinValue, maxX = int.MaxValue, maxY = int.MaxValue;
Rect area = new Rect(points[0].Position, new Size(0, 0));
// Calculate the bounding box that covers all points
foreach (var point in points)
{
if (_data.HistoryLevel > 0)
{
Rect location = RuleValidationHelper.GetBoundingBox(point);
List<TouchPoint2> selectedPoints = new List<TouchPoint2>();
result = RuleValidationHelper.HasPreviousTouchPoints(location, point, _data.HistoryLevel, point.StartTime.AddSeconds(-_data.HistoryTimeLine), selectedPoints);
if (result) // Has required number of previous touch points in selected location
{
foreach (var p in selectedPoints)
{
area.Union(p.Position);
}
}
else
{
break;
}
}
area.Union(point.Position);
}
// TODO: We need to implement circular area too
if (result && area.Height <= _data.Height && area.Width <= _data.Width)
{
sets.Add(new ValidSetOfTouchPoints(points));
}
}
return sets;
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
ValidSetOfTouchPoints list = new ValidSetOfTouchPoints();
List<Queue<int>> PointList = new List<Queue<int>>();
Queue<int> AddQueue;
foreach (var point in points)
{
int length = point.Stroke.StylusPoints.Count;
bool continuous = true;
int step = 1;
AddQueue = new Queue<int>();
for (int i = 0; i < length - step; i = i + step)
{
var p1 = point.Stroke.StylusPoints[i];
var p2 = point.Stroke.StylusPoints[i + step];
double slope = TrigonometricCalculationHelper.GetSlopeBetweenPoints(p1, p2);
String stringSlope = TouchPointExtensions.SlopeToDirection(slope);
double dist = TrigonometricCalculationHelper.GetDistanceBetweenPoints(p1, p2);
if (dist == 0)
{
continue;
}
if (stringSlope.Equals(_data.Values))
{
if (!continuous)
{
continuous = true;
PointList.Add(AddQueue);
AddQueue = new Queue<int>();
}
AddQueue.Enqueue(i);
}
else
{
continuous = false;
}
}
if (AddQueue.Count > 0)
{
PointList.Add(AddQueue);
}
//Add seperate points for each queue made
foreach (var queue in PointList)
{
TouchPoint2 p = point.GetEmptyCopy();
while (queue.Count > 0)
{
int i = queue.Dequeue();
StylusPoint newPoint = point.Stroke.StylusPoints[i];
p.Stroke.StylusPoints.Add(newPoint);
}
if (p.Stroke.StylusPoints.Count > 1)
{
list.Add(p);
}
}
}
if (list.Count > 0)
{
sets.Add(new ValidSetOfTouchPoints(points));
// sets.Add(list);
}
return sets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
return sets.ForEachSet(Validate);
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection list = new ValidSetOfPointsCollection();
foreach (TouchPoint2 point in points)
{
if (!point.isFinger && point.Snapshot!= null && point.Tag == null)
{
string _type = string.Empty;
string _side = string.Empty;
ImageHelper.getHandType(out _type, out _side, point);
if (_type == "" && _side == "")
continue;
if (_data.Type == string.Empty && _data.Side == string.Empty)
{
list.Add(new ValidSetOfTouchPoints(points));
continue;
}
if (_data.Side != string.Empty)
{
if (_type == _data.Type && _data.Side == _side)
list.Add(new ValidSetOfTouchPoints(points));
}
else // checks only the type
{
if (_type == _data.Type)
list.Add(new ValidSetOfTouchPoints(points));
}
}
}
return list;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
List<ValidateBlockResult> firstBlockResults = PartiallyEvaluatedGestures.Get(sets.ExpectedGestureName, _data.Gesture1);
List<ValidateBlockResult> secBlockResults = PartiallyEvaluatedGestures.Get(sets.ExpectedGestureName, _data.Gesture2);
if (firstBlockResults.Count == 0 || secBlockResults.Count == 0)
return new ValidSetOfPointsCollection();
TouchPoint2 point1 = firstBlockResults[0].Data[0][0];
TouchPoint2 point2 = secBlockResults[0].Data[0][0];
if (_data.Position == TouchRelativePosition.LEFT)
if (point1.Position.X < point2.Position.X)
return sets;
if (_data.Position == TouchRelativePosition.RIGHT)
if (point1.Position.X > point2.Position.X)
return sets;
return new ValidSetOfPointsCollection();
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
if (IsValid(points))
{
sets.Add(new ValidSetOfTouchPoints(points));
}
return sets;
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection ret = new ValidSetOfPointsCollection();
foreach (var point in points)
{
if (!point.isFinger)
{
continue;
}
bool singlePoint = TrigonometricCalculationHelper.isASinglePoint(point);
if (singlePoint)
{
continue;
} // A point can't be a closed loop
ValidSetOfTouchPoints tps = null;
if (_data.Values.Equals(CIRCLE))
{
tps = ValidateCircle(point);
}
else if (_data.Values.Equals(BOX))
{
tps = ValidateBox(point);
}
else if (_data.Values.Equals(CHECK))
{
tps = ValidateCheck(point);
}
else if (_data.Values.Equals(LINE))
{
tps = ValidateLine(point);
}
if ((tps != null) && (tps.Count > 0))
{
ret.Add(tps);
}
}
return ret;
}
public ValidSetOfPointsCollection Validate(System.Collections.Generic.List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints();
foreach (var point in points)
{
if (IsClosedLoop(point))
set.Add(point);
}
if (set.Count > 0)
sets.Add(set);
return sets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfTouchPoints points, string gestureName)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints();
double length = 0;
// the length can be calculated for a single touch path. So, we check each
// touchPoint individually
foreach (var point in points)
{
bool singlePoint = TrigonometricCalculationHelper.isASinglePoint(point);
if (singlePoint)
{
continue;
} // A point can't be a closed loop
if (checkForVariable(point, gestureName))
{
set.Add(point);
}
else
{
length = TrigonometricCalculationHelper.CalculatePathLength(point);
if (length >= _data.Min && length <= _data.Max)
{
set.Add(point);
}
}
}
if (set.Count > 0)
{
sets.Add(set);
}
return sets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection validSets = new ValidSetOfPointsCollection();
foreach (var item in sets)
{
// Because we know it will return only one item in the list
var results = Validate(item);
if (results.Count > 0)
validSets.Add(results[0]);
}
return validSets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
//TODO: move this code block to base class or extension methods. its common in many validators
ValidSetOfPointsCollection validSets = new ValidSetOfPointsCollection();
foreach (var set in sets)
{
var list = Validate(set);
foreach (var item in list)
{
validSets.Add(item);
}
}
return validSets;
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection list = new ValidSetOfPointsCollection();
if (_data.Type == TouchLimitType.FixedValue)
{
List<TouchPoint2> analyze = PointTranslator.removeHandRedundancy(points);
if (analyze.Count == _data.Min)
{
list.Add(new ValidSetOfTouchPoints(analyze));
}
else if (analyze.Count > _data.Min)
{
// Generate possible valid combinitions
Combinations c = new Combinations(analyze.ToArray(), _data.Min);
while (c.MoveNext())
{
TouchPoint2[] arr = c.Current as TouchPoint2[];
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints(arr);
list.Add(set);
}
}
}
else if (_data.Type == TouchLimitType.Range)
{
if (points.Count == _data.Min)
{
list.Add(new ValidSetOfTouchPoints(points));
}
else if (points.Count > _data.Min && points.Count <= _data.Max)
{
// All possible combinitions of size between min & max-1
for (int size = _data.Min; size < points.Count; size++)
{
// Generate possible valid combinitions
Combinations c = new Combinations(points.ToArray(), size);
while (c.MoveNext())
{
TouchPoint2[] arr = c.Current as TouchPoint2[];
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints(arr);
list.Add(set);
}
}
}
}
return list;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection validSets = new ValidSetOfPointsCollection();
if (sets != null)
{
foreach (var set in sets)
{
ValidSetOfPointsCollection list = Validate(set);
foreach (var item in list)
{
validSets.Add(item);
}
}
}
return validSets;
}
public ValidSetOfPointsCollection Validate(List<TouchPoint2> points)
{
ValidSetOfPointsCollection sets = new ValidSetOfPointsCollection();
bool result = false;
if (points == null)
{
return sets;
}
if (points.Count > 2)
{
// Assumption: If there are more that 2 points, then each point should
// match the condition with another point in at least one condition
Dictionary<TouchPoint2, bool> resultSet = new Dictionary<TouchPoint2, bool>(points.Count);
Combinations combinationGen = new Combinations(points.ToArray(), 2);
while (combinationGen.MoveNext())
{
TouchPoint2[] arr = combinationGen.Current as TouchPoint2[];
if (IsValid(arr))
{
// First item of the combinition set
if (!resultSet.ContainsKey(arr[0]))
resultSet.Add(arr[0], true);
// Second item of the combinition set
if (!resultSet.ContainsKey(arr[1]))
resultSet.Add(arr[1], true);
if (resultSet.Count == points.Count)
{
// All points have been validated at least once
result = true;
break;
}
}
}
}
else if (points.Count == 2)
{
result = IsValid(points.ToArray());
}
if (result)
{
ValidSetOfTouchPoints set = new ValidSetOfTouchPoints(points);
sets.Add(set);
}
return sets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
Console.WriteLine("AngleName:" + sets.ExpectedGestureName);
List<ValidateBlockResult> firstBlockResults = PartiallyEvaluatedGestures.Get(sets.ExpectedGestureName, _data.Gesture1);
List<ValidateBlockResult> secBlockResults = PartiallyEvaluatedGestures.Get(sets.ExpectedGestureName, _data.Gesture2);
if (firstBlockResults.Count == 0 || secBlockResults.Count == 0)
return new ValidSetOfPointsCollection();
ValidSetOfPointsCollection step1 = firstBlockResults[0].Data;
ValidSetOfTouchPoints line1 = ValidateLine(step1[0][0]);
if (line1.Count > 0)
{
ValidSetOfPointsCollection step2 = secBlockResults[0].Data;
ValidSetOfTouchPoints line2 = ValidateLine(step2[0][0]);
if (line2.Count == 0)
{
return new ValidSetOfPointsCollection();
}
var stylusPoints1 = TrigonometricCalculationHelper.removeRedundancy(line1[0].Stroke.StylusPoints);
var stylusPoints2 = TrigonometricCalculationHelper.removeRedundancy(line2[0].Stroke.StylusPoints);
if (stylusPoints2.Count == 0)
{
return new ValidSetOfPointsCollection();
}
// Considering that they are two lines, the angle will only be checked if their edges are nearby
if (!linesTouch(stylusPoints1, stylusPoints2))
{
return new ValidSetOfPointsCollection();
}
// Calculate slope of each line represented by the two sets of touch points
// as the final of a line is usually fuzzy, get the middle points(1/4,3/4), that have a more fixed pattern
int avg1 = stylusPoints1.Count;
int avg2 = stylusPoints2.Count;
double set1Angle = TrigonometricCalculationHelper.GetSlopeBetweenPoints(stylusPoints1[avg1 / 4], stylusPoints1[avg1 * 3 / 4]);
double set2Angle = TrigonometricCalculationHelper.GetSlopeBetweenPoints(stylusPoints2[avg2 / 4], stylusPoints2[avg2 * 3 / 4]);
double angularDiff = (set1Angle - set2Angle) * 180 / 3.14;
if (angularDiff < 0)
angularDiff = 180 + angularDiff;
if (angularDiff > 180)
angularDiff = angularDiff - 180;
double angleValueMin = _data.Min;
double angleValueMax = _data.Max;
if (Math.Abs(angularDiff) > angleValueMin && Math.Abs(angularDiff) < angleValueMax)
{
return sets;
}
else
{
angularDiff = Math.Abs(angularDiff) - 180;
if (Math.Abs(angularDiff) > angleValueMin && Math.Abs(angularDiff) < angleValueMax)
{
return sets;
}
}
}
return new ValidSetOfPointsCollection();
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
var result = false;
var firstBlockResults = PartiallyEvaluatedGestures.Get(sets.ExpectedGestureName, _data.Gesture1);
var secBlockResults = PartiallyEvaluatedGestures.Get(sets.ExpectedGestureName, _data.Gesture2);
foreach (var firstBlockResult in firstBlockResults)
{
foreach (var secBlockResult in secBlockResults)
{
if (Validate(firstBlockResult, secBlockResult))
{
result = true;
// TODO:???
firstBlockResult.AssociatedResults.Add(secBlockResult.Id);
secBlockResult.AssociatedResults.Add(firstBlockResult.Id);
break;
}
}
}
if (result)
return sets;
else
return new ValidSetOfPointsCollection();
}
/// <summary>
/// Only checks if system has the number of history data as mentioned
/// </summary>
/// <param name="sets"></param>
/// <returns></returns>
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection validSets = new ValidSetOfPointsCollection();
foreach (var set in sets)
{
ValidSetOfPointsCollection results = Validate(set);
foreach (var result in results)
{
validSets.Add(result);
}
}
return validSets;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection list = new ValidSetOfPointsCollection();
foreach (var item in sets)
{
var tlist = Validate(item);
list.AddRange(tlist);
}
return list;
}
public ValidSetOfPointsCollection Validate(ValidSetOfPointsCollection sets)
{
ValidSetOfPointsCollection validSets = new ValidSetOfPointsCollection();
//_data.currentMin = CalculatePathLength(validSets.);
foreach (var item in sets)
{
ValidSetOfPointsCollection list = Validate(item,sets.ExpectedGestureName);
foreach (var set in list)
{
validSets.Add(set);
}
}
return validSets;
}
