public override void FlickOccured(object sender, System.EventArgs e)
{
bool cast = twoFingerFlickGesture.ScreenFlickVector.x > 0f;
if (cast && !recognized)
{
recognized = true;
PDollarGestureRecognizer.Gesture candidate = new PDollarGestureRecognizer.Gesture(points.ToArray());
Result gestureResult = PointCloudRecognizer.Classify(candidate, trainingSet.ToArray());
if (gestureResult.Score > runeSuccessScore)
{
RuneSuccess(gestureResult);
}
else
{
RuneFailure();
}
}
else if (!cast)
{
RuneFailure();
}
}
void Update()
{
//if (Input.GetMouseButtonDown(1))
// rX = Input.mousePosition.x;
//if (Input.GetMouseButtonUp(1))
//{
// if (Input.mousePosition.x > rX)
// {
// recognized = true;
// PDollarGestureRecognizer.Gesture candidate = new PDollarGestureRecognizer.Gesture(points.ToArray());
// Result gestureResult = PointCloudRecognizer.Classify(candidate, trainingSet.ToArray());
// if (gestureResult.Score > runeSuccessScore)
// RuneSuccess(gestureResult);
// else
// RuneFailure();
// }
// else
// {
// RuneFailure();
// }
//}
if (Input.GetKeyDown(KeyCode.C))
{
if (!recognized)
{
recognized = true;
PDollarGestureRecognizer.Gesture candidate = new PDollarGestureRecognizer.Gesture(points.ToArray());
Result gestureResult = PointCloudRecognizer.Classify(candidate, trainingSet.ToArray());
if (gestureResult.Score > runeSuccessScore)
{
RuneSuccess(gestureResult);
}
else
{
RuneFailure();
}
}
}
else if (Input.GetKeyDown(KeyCode.X))
{
RuneFailure();
}
}
public void RenderGesture(Gesture nextGesture)
{
if (currentGestureLineRenderer != null) Destroy(currentGestureLineRenderer.gameObject);
currentGestureLineRenderer = Instantiate(gestureOnScreenPrefab).GetComponent<LineRenderer>();
Vector3[] rendererPoints = nextGesture.Points
.Select(gesturePoint => new Vector3(gesturePoint.X, -gesturePoint.Y, 0))
.ToArray();
currentGestureLineRenderer.SetVertexCount(rendererPoints.Length);
currentGestureLineRenderer.SetPositions(rendererPoints);
StartCoroutine("TransformGesture");
}
/// <summary>
/// Main function of the $P recognizer.
/// Classifies a candidate gesture against a set of training samples.
/// Returns the class of the closest neighbor in the training set.
/// </summary>
/// <param name="candidate"></param>
/// <param name="trainingSet"></param>
/// <returns></returns>
public static string Classify(Gesture candidate, Gesture[] trainingSet)
{
float minDistance = float.MaxValue;
string gestureClass = "";
foreach (Gesture template in trainingSet)
{
float dist = GreedyCloudMatch(candidate.Points, template.Points);
if (dist < minDistance)
{
minDistance = dist;
gestureClass = template.Name;
}
}
return gestureClass;
}
/// <summary>
/// Main function of the $P recognizer.
/// Classifies a candidate gesture against a set of training samples.
/// Returns the class of the closest neighbor in the training set.
/// </summary>
/// <param name="candidate"></param>
/// <param name="trainingSet"></param>
/// <returns></returns>
public static Result Classify(Gesture candidate, Gesture[] trainingSet)
{
float minDistance = float.MaxValue;
string gestureClass = "";
foreach (Gesture template in trainingSet)
{
float dist = GreedyCloudMatch(candidate.Points, template.Points);
if (dist < minDistance)
{
minDistance = dist;
gestureClass = template.Name;
}
}
return gestureClass == "" ? new Result() {GestureClass = "No match", Score = 0.0f} : new Result() {GestureClass = gestureClass, Score = Mathf.Max((minDistance - 2.0f) / -2.0f, 0.0f)};
}
/// <summary>
/// Main function of the $P recognizer.
/// Classifies a candidate gesture against a set of training samples.
/// Returns the class of the closest neighbor in the training set.
/// </summary>
/// <param name="candidate"></param>
/// <param name="trainingSet"></param>
/// <returns></returns>
public static string Classify(Gesture candidate, Gesture[] trainingSet)
{
float minDistance = float.MaxValue;
string gestureClass = "";
//float sum = 0f;
foreach (Gesture template in trainingSet)
{
float dist = GreedyCloudMatch(candidate.Points, template.Points);
//sum += dist;
if (dist < minDistance)
{
minDistance = dist;
gestureClass = template.Name;
}
}
//probability = 1f - ( minDistance / sum); //TODO: give some better notion of confidence
return gestureClass;
}
public void CompareShapes()
{
Gesture candidate = new Gesture(drawingBoard.DrawingPoints.ToArray());
Result gestureResult = PointCloudRecognizer.Classify(candidate, new[] { curGesture });
string statusString = "Shapes match on " + (int) (gestureResult.Score * 100) + " %." + Environment.NewLine;
if (gestureResult.Score < RecognitionThreshold)
{
recognitionStatus = RecognitionStatus.Fail;
statusString += "Threshold is " + (int)(RecognitionThreshold * 100) + " %. Try again";
drawingBoard.CleanDrawingArea();
}
else
{
recognitionStatus = RecognitionStatus.Recognized;
statusString += "You got it.";
GestureRecognized();
}
statusText.text = statusString;
}
public void InputGesture(NetworkMessage msg)
{
string name = msg.reader.ReadString();
int length = msg.reader.ReadInt32();
Point[] points = new Point[length];
for (int a = 0; a < length; a++)
{
Vector2 v = msg.reader.ReadVector2();
points [a] = new Point(v.x, v.y, msg.reader.ReadInt32());
}
PDollarGestureRecognizer.Gesture candidate = new PDollarGestureRecognizer.Gesture(points);
Result gestureResult = PointCloudRecognizer.Classify(candidate, trainingSet);
if (inputGesture.ContainsKey(name))
{
inputGesture [name] = gestureResult;
}
else
{
inputGesture.Add(name, gestureResult);
}
}
private void Update()
{
if (Input.GetMouseButtonDown(1))
{
ClearGfxs();
List <Point> myPoints = new List <Point> ();
int strokeId = 0;
foreach (Gesture.Stroke stroke in mySave.GestureSets[curGestureGroupIndex].repetitions[curGestureIndex].strokes)
{
foreach (Gesture.Point point in stroke.points)
{
myPoints.Add(new Point(point.x, point.y, strokeId));
}
strokeId++;
}
PDollarGestureRecognizer.Gesture myGesture = new PDollarGestureRecognizer.Gesture(myPoints.ToArray());
foreach (Point point in myGesture.Points)
{
GameObject p = Instantiate(pointPrefab, transform);
p.transform.position = new Vector3(point.X, point.Y, 0);
}
}
if (Input.GetMouseButtonDown(0))
{
ScreenCapture.CaptureScreenshot("Shape " + capIndex.ToString() + ".png");
capIndex++;
}
if (Input.mouseScrollDelta.y != 0)
{
ChangeGesture((int)Input.mouseScrollDelta.y);
}
}
private void PickAnotherRandomGesture()
{
Gesture prevGesture = curGesture;
do curGesture = gestures[Random.Range(0, gestures.Count)];
while (curGesture == prevGesture);
}
void Update()
{
if (myBt.GetButtonDown)
{
holdTime += Time.deltaTime;
down = true;
tapped = true;
held = false;
holdTime = 0;
doubleTap = false;
DragDeltaInches = Vector2.zero;
DragDeltaPixels = Vector2.zero;
AbsoluteDragDeltaInches = 0;
AbsoluteDragDeltaPixels = 0;
MeanDragSpeedPixels = 0;
MeanDragSpeedInches = 0;
DragSpeedPixels = 0;
DragSpeedInches = 0;
if (timeSinceLastDownToNextDown < 0.2f)
{
doubleTapHold = true;
}
timeSinceLastDownToNextDown = 0;
++strokeId;
vertexCount = 0;
result = EmptyResult;
}
else if (myBt.GetButton)
{
holdTime += Time.deltaTime;
if (holdTime > 0.3f)
{
held = true;
}
DragDeltaPixels += curDelta;
AbsoluteDragDeltaPixels += curDelta.magnitude;
MeanDragSpeedPixels = AbsoluteDragDeltaPixels / holdTime;
DragSpeedPixels = curDelta.magnitude / Time.deltaTime;
DragDeltaInches = DragDeltaPixels / Screen.dpi;
AbsoluteDragDeltaInches = AbsoluteDragDeltaPixels / Screen.dpi;
MeanDragSpeedInches = MeanDragSpeedPixels / Screen.dpi;
DragSpeedInches = DragSpeedPixels / Screen.dpi;
}
else if (myBt.GetButtonUp)
{
if (points.Count < 2)
{
//tap
if (timeSinceLastDownToNextUp < 0.3f)
{
doubleTap = true;
}
}
else if (points.Count == 2)
{
//swipe
}
else
{
PDollarGestureRecognizer.Gesture candidate = new PDollarGestureRecognizer.Gesture(points.ToArray());
Result gestureResult = PointCloudRecognizer.Classify(candidate, trainingSet);
if (gestureResult.GestureClass == "Tap")
{
//tap
if (timeSinceLastDownToNextUp < 0.3f)
{
doubleTap = true;
}
}
else if (gestureResult.GestureClass == "Swipe")
{
//swipe
}
else
{
//send points
}
}
doubleTapHold = false;
timeSinceLastDownToNextUp = holdTime;
timeSinceLastDownToNextUp = holdTime;
holdTime = 0;
held = false;
points.Clear();
//lineRenderer.SetVertexCount (0);
}
else
{
doubleTap = false;
}
curDelta = Vector2.zero;
}
/// <summary>
/// Main function of the $P recognizer.
/// Classifies a candidate gesture against a set of training samples.
/// Returns the class of the closest neighbor in the training set.
/// </summary>
/// <param name="candidate"></param>
/// <param name="trainingSet"></param>
/// <returns></returns>
public static string Classify(Gesture candidate, Gesture[] trainingSet)
{
float minDistance = float.MaxValue;
string gestureClass = "";
//Debug.Log (candidate.Points [1]);
foreach (Gesture template in trainingSet)
{
//Debug.Log ("Gesture = "+template.Name+" _ Candidate Length: "+candidate.Points.Length);
float dist = GreedyCloudMatch(candidate.Points, template.Points);
if (dist < minDistance)
{
minDistance = dist;
gestureClass = template.Name;
Debug.Log (gestureClass+" "+minDistance);
}
}
return gestureClass;
}
