/// <summary>
/// Méthode pour gérer les mouvements reçu. Appelée 30 fois par seconde.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void gestureReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
using (VisualGestureBuilderFrame frame = e.FrameReference.AcquireFrame())
{
if (frame != null && frame.DiscreteGestureResults != null)
{
foreach (var result in frame.DiscreteGestureResults)
{
if (result.Key.Name == "GoRight2")
{
if (result.Value.Detected && lastDetected == false && this.slideShowEnabled)
{
//On lance la prochaine slide
this.Application.ActivePresentation.SlideShowWindow.View.Next();
lastDetected = true;
}
else if (lastDetected == true && result.Value.Detected == false)
{
lastDetected = false;
}
}
}
}
}
}
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
private void GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame()) {
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in _Source.Gestures)
{
if (gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (gesture.Name == "point_right")
{
GameObject.Find("CreateDiagram").GetComponent <HistogramTexture> ().setHeight(result.Confidence);
}
/*if (result.Confidence > 0.05) {
* // Fire Event
* if(OnGesture!=null){
* // Debug.Log("Detected Gesture " + gesture.Name + " with Confidence " + result.Confidence);
* // OnGesture(this,new KinectGestureEvent(gesture.Name, result.Confidence));
* }
* }*/
}
}
}
}
}
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
var discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.Name.Equals(this.GestureClapping) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
if (this.OnGestureDetected != null)
{
this.OnGestureDetected(this, new GestureEventArgs(true, result.Detected, result.Confidence, this.GestureClapping));
}
}
}
if (gesture.Name.Equals(this.GestureHandShake_Right) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
if (this.OnGestureDetected != null)
{
this.OnGestureDetected(this, new GestureEventArgs(true, result.Detected, result.Confidence, this.GestureHandShake_Right));
}
}
}
if (gesture.Name.Equals(this.GestureLeftRotation_Right) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
if (this.OnGestureDetected != null)
{
this.OnGestureDetected(this, new GestureEventArgs(true, result.Detected, result.Confidence, this.GestureHandShake_Right));
}
}
}
}
}
}
}
}
// **************************************************these are called every frame************************************************************
private void GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e) //for each GestureReader Event
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame()) {
if (frame != null)
{
IDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults; // get the discrete gesture results which arrived with the latest frame
// retrun Gesture check the unity gesture scripts
if (HashIdtb.ContainsKey(frame.TrackingId) && discreteResults != null && PlayerArgs.ContainsKey(frame.TrackingId))
{
Dictionary <VisualGestureBuilderFrameSource, VisualGestureBuilderFrameReader> thisGestureGroup = HashIdtb[frame.TrackingId] as Dictionary <VisualGestureBuilderFrameSource, VisualGestureBuilderFrameReader>;
foreach (var GestureGroup in thisGestureGroup) // we actually only have 1 group, should i use a struct or something else?
{
var thisSource = GestureGroup.Key;
foreach (Gesture gesture in thisSource.Gestures) //all the gesture in gesturedatabase
{
if (gesture.GestureType == GestureType.Discrete) //check the type
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (OnGestureData != null) //we emit event EVERY GESTURE RESULT
{
OnGestureData(this, new KinectGestureDataEvent(gesture.Name, result.Confidence, frame.TrackingId, PlayerArgs[frame.TrackingId]));
}
}
}
}
}
}
}
}
void reader_FrameArrived(VisualGestureBuilderFrameReader sender, VisualGestureBuilderFrameArrivedEventArgs args)
{
using (var frame = args.FrameReference.AcquireFrame())
{
if (frame != null && frame.DiscreteGestureResults != null)
{
var result = frame.DiscreteGestureResults[_salute];
if (result.Detected == true)
{
var progressResult = frame.ContinuousGestureResults[_saluteProgress];
Progress.Value = progressResult.Progress;
if (Progress.Value == 1)
{
done();
}
cntRsult += 0.05;
}
else
{
Progress.Value = 0.0;
}
icntR = (int)cntRsult / 5;
GestureText.Text = result.Detected ? "성공(동작 5초간 유지!)" : "동작을 수행하세요";
GestureText1.Text = icntR.ToString();
ConfidenceText.Text = result.Confidence.ToString();
}
}
}
// Handles gesture detection results arriving from the sensor for the associated body tracking Id
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame()) {
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.Name.Equals(this.gestureName) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
/**********************************************************************************************/
//Cuando el gesto es reconocido reproduce el sonido
this.ReproducirSonido(result.Detected, result.Confidence);
/**********************************************************************************************/
}
}
}
}
}
}
}
void _gestureFrameReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame()) {
if (frame != null && frame.DiscreteGestureResults != null)
{
DiscreteGestureResult result = null;
if (frame.DiscreteGestureResults.Count > 0)
{
result = frame.DiscreteGestureResults [_menu];
}
if (result == null | !menuGestureOk)
{
return;
}
if (result.Detected == true & buttonPushed < Time.time - 1f)
{
source.PlayOneShot(menuToggled, 0.5f);
menu.enabled = !menu.enabled; //hide show menu
buttonPushed = Time.time;
}
}
}
}
/// <summary>
/// Appelé 30 fois par seconde et gérant les frames de gestures
/// </summary>
private void gestureReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
using (VisualGestureBuilderFrame frame = e.FrameReference.AcquireFrame()) //Récupère la frame
{
if (frame != null) //Vérifie que celle-ci n'est pas nul.
{
if (frame.DiscreteGestureResults != null) //Vérifie qu'il y ai des résultats de type discret (booléen)
{
foreach (var discreteGesturePair in frame.DiscreteGestureResults) //Explore toute les gestures détectée
{
//L'arguments de l'évenement à envoyer
GestureDetectedEventArgs gestureArgs = new GestureDetectedEventArgs(discreteGesturePair.Key, discreteGesturePair.Value);
//Vérifie si l'image actuel correspond à un geste dans la base de donnée et envoie l'événement correspondant
if (discreteGesturePair.Value.FirstFrameDetected)
{
if (GestureFirstDetected != null)
{
GestureFirstDetected(this, gestureArgs);
}
}
if (discreteGesturePair.Value.Detected)
{
if (GestureDetected != null)
{
GestureDetected(this, gestureArgs);
}
}
}
}
}
}
}
void FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
if (canPose)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null && frame.DiscreteGestureResults != null)
{
DiscreteGestureResult result = null;
if (frame.DiscreteGestureResults.Count > 0) //if there is one or more potential gesture being detected by the kinect
{
for (int i = 0; i < gestures.Count; i++) //for each gesture in the database
{
result = frame.DiscreteGestureResults[gestures[i].gesture]; //get the result of gesture i
if (result.Detected == true) //if gesture i was detected
{
// gestures[i].trigger.Invoke();//call the unityevent attacked to the gesture
Model.SetActive(true);
Model.GetComponent <MeshFilter>().mesh = gestures[i].mesh;
StopCapture();
}
}
}
}
}
}
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// percorrer dicionario à procura do gesto discreto com maior confiança
// não gosto mas como escolher o melhor gesto?
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, ContinuousGestureResult> continuousResults = frame.ContinuousGestureResults;
if (discreteResults != null && !serverPipe.IsSpeakRunning)
{
string result = gFrameHandler.handleFrame(discreteResults);
if (result != null)
{
gestureSelection(result.Split('_')[0]);
Console.WriteLine("Result: " + result);
}
}
}
}
}
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id private
void GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in _Source.Gestures)
{
if (gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result.Confidence > 0.05)
{
// Fire Event
if (OnGesture != null)
{
Debug.Log("Detected Gesture " + gesture.Name + " with Confidence " + result.Confidence);
OnGesture(this, new KinectGestureEvent(gesture.Name, result.Confidence));
}
}
}
}
}
}
}
}
/// <summary>
/// Parse the Gesture that arrived and trigger the appropriate event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnGestureFrameArrived(object sender,
VisualGestureBuilderFrameArrivedEventArgs e)
{
using (var frame = e.FrameReference.AcquireFrame()) {
if (frame != null)
{
var result = frame.DiscreteGestureResults;
if (result != null)
{
if (result.ContainsKey(waveGesture))
{
var gesture = result[waveGesture];
if (gesture.Confidence > WAVE_CONFIDENCE)
{
Body b = getBodyByTrackingID(frame.TrackingId);
Application.Current.Dispatcher.Invoke(new Action(() => {
WaveGestureHandler handler = WaveGestureOccured;
handler?.Invoke(frame.TrackingId,
(b.Joints[JointType.HandRight].Position.Y >=
b.Joints[JointType.HandLeft].Position.Y));
}));
}
}
}
}
}
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
Parallel.ForEach(this.vgbFrameSource.Gestures, gesture =>
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result.Detected)
{
gestureActions[gesture.Name].Invoke();
}
else if (gesture.Name == "Block")
{
Release(NesButtons.Down);
}
});
}
}
}
}
private void Reader_GestureFrameArrived_Continuous(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the continuous gesture results which arrived with the latest frame
var continuousResults = frame.ContinuousGestureResults;
if (continuousResults != null)
{
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.Name.Equals(this.gestureName) && gesture.GestureType == GestureType.Continuous)
{
ContinuousGestureResult result = null;
continuousResults.TryGetValue(gesture, out result);
if (result != null)
{
if (this.OnGestureDetected != null)
{
this.OnGestureDetected(this, new GestureEventArgs(true, result.Progress <= 0.01, result.Progress));
}
}
}
}
}
}
}
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
_gestureName = null;
using (VisualGestureBuilderFrame frame = _vgbFrameReader.CalculateAndAcquireLatestFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in _vgbFrameSource.Gestures)
{
DiscreteGestureResult result;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
if (gesture.Name.Equals(_pickUp) && gesture.GestureType == GestureType.Discrete && result.Confidence > 0.05)
{
// update the GestureResultView object with new gesture result values
GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence, gesture.Name);
_gestureName = "PickUp";
}
else if (gesture.Name.Equals(_putDown) && gesture.GestureType == GestureType.Discrete && result.Confidence > 0.05)
{
// update the GestureResultView object with new gesture result values
GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence, gesture.Name);
_gestureName = "PutDown";
}
else if (gesture.Name.Equals(_openDoor) && gesture.GestureType == GestureType.Discrete && result.Confidence > 0.05)
{
// update the GestureResultView object with new gesture result values
GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence, gesture.Name);
_gestureName = "OpenDoor";
}
else if (gesture.Name.Equals(_handToMouth) && gesture.GestureType == GestureType.Discrete && result.Confidence > 0.05)
{
// update the GestureResultView object with new gesture result values
GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence, gesture.Name);
_gestureName = "HandToMouth";
}
else if (gesture.Name.Equals(_pour) && gesture.GestureType == GestureType.Discrete && result.Confidence > 0.05)
{
// update the GestureResultView object with new gesture result values
GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence, gesture.Name);
_gestureName = "Pour";
}
else
{
_gestureName = "No Gesture";
}
}
}
}
}
}
}
void _gestureFrameReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null && frame.DiscreteGestureResults != null)
{
DiscreteGestureResult result = null;
if (frame.DiscreteGestureResults.Count > 0)
{
foreach (Gesture gesture in trackedGestures)
{
result = frame.DiscreteGestureResults[gesture];
if (result != null)
{
if (result.Detected == true)
{
//if(result.Confidence > 0.60f)
{
Debug.Log("Detected: " + gesture.Name);
//Debug.Log("result confidence: " +result.Confidence);
}
}
}
}
}
}
}
}
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
//Get the gesture results from the last frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.Name.Equals(this.waveName) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null && result.Confidence > 0.8) //Limit the amount of results which are reported back, by setting a minimum confidence level
{
if (result.Confidence == 1)
{
this.GestureResultView.GestureCount++;
}
this.GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence); //Report back the updated gesture result
}
}
}
}
}
}
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
///
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
if (result.Confidence > 0 && gesture.GestureType == GestureType.Discrete) //gesture.Name.Equals(this.crossedArms)
{
// System.Diagnostics.Debug.WriteLine(vgbFrameSource.TrackingId);
// update the GestureResultView object with new gesture result values
this.GestureResultView.UpdateGestureResult(gesture.Name, true, result.Detected, result.Confidence);
}
if (result.Confidence < 0.15)
{
this.GestureResultView.UpdateGestureResult(gesture.Name, true, result.Detected, 0);
}
}
}
}
}
}
}
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
//Get the gesture results from the last frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.Name.Equals(this.waveGestureName) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
this.GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence);
}
}
}
}
}
}
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.Name.Equals(this.seatedGestureName) && gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
// update the GestureResultView object with new gesture result values
this.GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence);
//Update DB
}
}
}
}
}
}
}
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
IReadOnlyDictionary <Gesture, ContinuousGestureResult> continuousResults =
frame.ContinuousGestureResults;
if (discreteResults != null)
{
DiscreteGestureResult SwipeFromLeftResult = null;
DiscreteGestureResult SwipeFromRightResult = null;
DiscreteGestureResult ZoomOutResult = null;
discreteResults.TryGetValue(ZoomOut, out ZoomOutResult);
discreteResults.TryGetValue(RightToLeft, out SwipeFromRightResult);
discreteResults.TryGetValue(LeftToRight, out SwipeFromLeftResult);
if (EnableSwipe && SwipeFromRightResult != null && SwipeFromRightResult.Detected && SwipeFromRightResult.Confidence > 0.35)
{
Trace.WriteLine("Swipe from right");
OnSwipe(GestureType.RightToLeft);
EnableSwipe = false;
ResetSwipe(gestureResetTime);
}
if (EnableSwipe && SwipeFromLeftResult != null && SwipeFromLeftResult.Detected && SwipeFromLeftResult.Confidence > 0.35)
{
Trace.WriteLine("swipe from left");
OnSwipe(GestureType.LeftToRight);
EnableSwipe = false;
ResetSwipe(gestureResetTime);
}
if (EnableZoom && ZoomOutResult != null && ZoomOutResult.Detected && ZoomOutResult.Confidence > 0.5)
{
OnZoomOut();
}
}
if (continuousResults != null)
{
ContinuousGestureResult ClapResult = null;
continuousResults.TryGetValue(clapGesture, out ClapResult);
if (EnableClap && ClapResult != null)
{
float clapProg = ClapResult.Progress;
if (clapProg > 1.85 && clapProg < 3)
{
Trace.WriteLine("Clap detected");
EnableClap = false;
ResetClap(gestureResetTime);
}
}
}
}
}
}
//method for detecting a gesture in kinect frame
void _gestureFrameReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs args)
{
if (_gestureFrameSource.IsTrackingIdValid && StartGame.ControlsOn)
{
using (var frame = args.FrameReference.AcquireFrame())
{
if (frame != null)
{
var results = frame.DiscreteGestureResults;
if (results != null && results.Count > 0)
{
DiscreteGestureResult jumpResult;
DiscreteGestureResult moveLeftResult;
DiscreteGestureResult moveRightResult;
DiscreteGestureResult crouchResult;
DiscreteGestureResult swingResult;
results.TryGetValue(_jump, out jumpResult);
results.TryGetValue(_moveLeft, out moveLeftResult);
results.TryGetValue(_moveRight, out moveRightResult);
results.TryGetValue(_swing, out swingResult);
//if jump gesture detected
if (jumpResult.FirstFrameDetected && gestureDetected == false)
{
gestureDetected = true;
if (startgame.GetComponent <StartGame>().IsGrounded())
{
startgame.GetComponent <StartGame>().PlayerJump();
}
isJumping = true;
}
//if move left gesture detected
else if (moveLeftResult.FirstFrameDetected && gestureDetected == false)
{
gestureDetected = true;
startgame.GetComponent <StartGame>().MoveLeft();
}
//if move right gesture detected
else if (moveRightResult.FirstFrameDetected && gestureDetected == false)
{
gestureDetected = true;
startgame.GetComponent <StartGame>().MoveRight();
}
//if swing gesture detected
else if (swingResult.FirstFrameDetected && gestureDetected == false)
{
gestureDetected = true;
startgame.GetComponent <StartGame>().PlayerAttack();
}
else
{
//no gesture detected in frame
gestureDetected = false;
}
}
}
}
}
}
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
protected virtual void GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in _Source.Gestures)
{
if (gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
// Fire Event
if (result.Detected)
{
//Debug.Log("Detected Gesture " + gesture.Name + " with Confidence " + result.Confidence);
if (result.Confidence >= MinConfidence)
{
DetectedConfidence = result.Confidence;
this.CurrentGestureName = gesture.Name;
DetectedWork();
OnGesture(new EventArgs(gesture.Name, result.Confidence));
}
else
{
this.CurrentGestureName = string.Empty;
this.DetectedConfidence = 0.0f;
}
}
else
{
this.CurrentGestureName = string.Empty;
this.DetectedConfidence = 0.0f;
NotDetectedWork();
}
// OnGesture(new EventArgs(gesture.Name, result.Confidence));
//
}
}
}
}
}
}
}
void vgbFrameReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
int i = 0;
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
this.gesturedetected[i] = result.Detected;
this.gestureconfidence[i] = result.Confidence;
}
}
i++;
}
}
IReadOnlyDictionary <Gesture, ContinuousGestureResult> continuousResults = frame.ContinuousGestureResults;
if (continuousResults != null)
{
int i = 0;
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.GestureType == GestureType.Continuous)
{
ContinuousGestureResult result = null;
continuousResults.TryGetValue(gesture, out result);
if (result != null)
{
this.gestureprogress[i] = result.Progress;
}
}
i++;
}
}
}
}
}
private void gestureFrameReader_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
using (var gestureFrame = e.FrameReference.AcquireFrame())
{
if (gestureFrame != null && gestureFrame.DiscreteGestureResults != null)
{
bodySender.addGestures(gestureFrame, gestureFrame.TrackingId, this.discreteGestures, this.continuousGestures);
}
}
}
void gestureFrameReaders_FrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrame gestureFrame = e.FrameReference.AcquireFrame();
if (gestureFrame == null)
{
return;
}
UpdateGestureFrame(gestureFrame);
gestureFrame.Dispose();
}
/// <summary>
/// Handles gesture detection results arriving from the sensor for the associated body tracking Id
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
Gesture localGesture = null;
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
// get the discrete gesture results which arrived with the latest frame
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
// we only have one gesture in this source object, but you can get multiple gestures
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
if (result.Detected)
{
localGesture = gesture;
}
// update the GestureResultView object with new gesture result values
//this.GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence);
}
}
}
}
}
if (currentWantedGesture == gestureNames.Length)
{
OnGestureFired?.Invoke();
currentWantedGesture = 0;
lastGesture = null;
return;
}
if (gestureNames[currentWantedGesture] == localGesture?.Name)
{
lastGesture = localGesture;
lastCoolGesture = DateTime.UtcNow;
currentWantedGesture++;
return;
}
if (lastGesture != null && DateTime.UtcNow - lastCoolGesture > TimeSpan.FromSeconds(5))
{
currentWantedGesture = 0;
lastGesture = null;
}
}
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
lock (GestureResults)
{
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
GestureResult gr = GestureResults.FirstOrDefault(n => n.Name == gesture.Name);
gr.UpdateGestureResult(gesture.Name, true, result.Detected, result.Confidence);
}
}
}
}
IReadOnlyDictionary <Gesture, ContinuousGestureResult> continuousResults = frame.ContinuousGestureResults;
if (continuousResults != null)
{
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.GestureType == GestureType.Continuous)
{
ContinuousGestureResult result = null;
continuousResults.TryGetValue(gesture, out result);
if (result != null)
{
GestureResult gr = GestureResults.FirstOrDefault(n => n.Name == gesture.Name);
gr.UpdateGestureResult(gesture.Name, true, true, result.Progress);
}
}
}
}
}
}
}
}
private void OnFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
using (var frame = e.FrameReference.AcquireFrame())
{
if (frame == null)
{
return;
}
if (frame.DiscreteGestureResults == null)
{
return;
}
foreach (var gestureKey in frame.DiscreteGestureResults.Keys.Where(gestureKey => frame.DiscreteGestureResults[gestureKey].Detected))
{
switch (gestureKey.Name)
{
case "TakeControl":
if (TakeControl != null)
{
TakeControl(this, EventArgs.Empty);
}
break;
case "Next":
if (Next != null)
{
Next(this, EventArgs.Empty);
}
break;
case "Previous":
if (Previous != null)
{
Previous(this, EventArgs.Empty);
}
break;
case "End":
if (End != null)
{
End(this, EventArgs.Empty);
}
break;
}
}
}
}
/// <summary>
/// This function reads every input frame from Kinect using VisualGestureBuilder API
/// A valid frame is stored in an array as soon as it is received
/// recordbodydata is a flag that is a boundary condition to record the coordinates to know about the status of last detected frame.
/// The 'result' is set to true when gesture received from frame matches either start or end position of gestures
/// The function passes to DTW for sequence matching when the start and end position are of same gesture.
/// </summary>
private void Reader_GestureFrameArrived(object sender, VisualGestureBuilderFrameArrivedEventArgs e)
{
VisualGestureBuilderFrameReference frameReference = e.FrameReference;
using (VisualGestureBuilderFrame frame = frameReference.AcquireFrame())
{
if (frame != null)
{
IReadOnlyDictionary <Gesture, DiscreteGestureResult> discreteResults = frame.DiscreteGestureResults;
if (discreteResults != null)
{
foreach (Gesture gesture in this.vgbFrameSource.Gestures)
{
if (gesture.GestureType == GestureType.Discrete)
{
DiscreteGestureResult result = null;
discreteResults.TryGetValue(gesture, out result);
if (result != null)
{
this.GestureResultView.UpdateGestureResult(true, result.Detected, result.Confidence);
}
try
{
//conditional statement to record body data
if (RECORD_BODY_DATA == RECORD && result.Detected == false)
{
storebodycoordinates();//stores current frame
}
else if (result != null && result.Detected == true && result.Confidence >= 0.6)
{
if (KINECT_COORDINATES.Length != 0)
{
string result_gesture = passToDTW();
RECORD_BODY_DATA = EMPTY;
break;
}
RECORD_BODY_DATA = RECORD;
}
}
catch (Exception ex)
{
//do nothing
}
}
}
}
}
}
}
