private void fluxoInteracao_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame quadro = e.OpenInteractionFrame())
{
if (quadro == null) return;
UserInfo[] informacoesUsuarios = new UserInfo[6];
quadro.CopyInteractionDataTo(informacoesUsuarios);
IEnumerable<UserInfo> usuariosRastreados = informacoesUsuarios.Where(info => info.SkeletonTrackingId != 0);
if (usuariosRastreados.Count() > 0)
{
UserInfo usuarioPrincipal = usuariosRastreados.First();
if (usuarioPrincipal.HandPointers[0].HandEventType == InteractionHandEventType.Grip)
configuracaoMaoEsquerda.DesenhoAtivo = true;
else if (usuarioPrincipal.HandPointers[0].HandEventType == InteractionHandEventType.GripRelease)
configuracaoMaoEsquerda.DesenhoAtivo = false;
if (usuarioPrincipal.HandPointers[1].HandEventType == InteractionHandEventType.Grip)
configuracaoMaoDireita.DesenhoAtivo = true;
else if (usuarioPrincipal.HandPointers[1].HandEventType == InteractionHandEventType.GripRelease)
configuracaoMaoDireita.DesenhoAtivo = false;
}
}
}
void stream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (var interactionFrame = e.OpenInteractionFrame()) {
if (interactionFrame != null)
{
var userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
interactionFrame.CopyInteractionDataTo(userInfos);
List <InteractionHandPointer> hands = new List <InteractionHandPointer>();
foreach (var user in userInfos)
{
if (user.SkeletonTrackingId != 0)
{
foreach (var hand in user.HandPointers)
{
hands.Add(hand);
}
}
}
Grid.ItemsSource = hands;
}
}
}
//called on every new frame
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
return;
iaf.CopyInteractionDataTo(_userInfos);
}
var hasUser = false;
foreach (var userInfo in _userInfos)
{
var userID = userInfo.SkeletonTrackingId;
if (userID == 0)
continue;
mainManager.newImageReceived(userInfo);
hasUser = true;
//we manage only the first user
break;
}
if (!hasUser)
mainManager.setInformationText("No User Detected");
else
mainManager.setInformationText("User Tracked");
}
private void KinectInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
if (activeSkeleton == null)
{
return;
}
using (var iaf = args.OpenInteractionFrame()) { //dispose as soon as possible
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(_userInfos);
}
UserInfo userInfo = (from u in _userInfos where u.SkeletonTrackingId == activeSkeleton.TrackingId select u).FirstOrDefault();
if (userInfo == null)
{
return;
}
int userID = userInfo.SkeletonTrackingId;
var hands = userInfo.HandPointers;
if (hands.Count != 0)
{
foreach (var hand in hands)
{
bool grip = hand.HandEventType == InteractionHandEventType.Grip;
bool gripRelease = hand.HandEventType == InteractionHandEventType.GripRelease;
mouseController.AnalyzeGrip(grip, gripRelease, ref isClicks[(int)hand.HandType]);
}
}
}
void interStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (var iaf = e.OpenInteractionFrame())
{
#region 標準處理架構
if (iaf == null)
{
return;
}
UserInfo[] userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
iaf.CopyInteractionDataTo(userInfos);
#endregion
#region 擷取互動串流提供的資訊
GetIDs(userInfos);
var activeuser = (from u in userInfos
where u.SkeletonTrackingId > 0
select u).FirstOrDefault();
if (activeuser != null)
{
GetHands(activeuser);
GetHandEvent(activeuser);
}
#endregion
}
}
public void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.userInfos == null)
{
return;
}
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.userInfos;
}
}
if (localUserInfos != null)
{
HandleUsersInfo(localUserInfos);
}
}
private void InteractionStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (var frame = e.OpenInteractionFrame())
{
if (frame == null)
{
return;
}
frame.CopyInteractionDataTo(_userInfos);
if (_userInfos != null && _userInfos.Length > 0)
{
bool rightHandPress = false;
bool leftHandPress = false;
bool rightHandGrip = false;
bool leftHandGrip = false;
bool rightHandRelease = false;
bool leftHandRelease = false;
foreach (var info in _userInfos)
{
foreach (var hand in info.HandPointers)
{
if (hand.HandType == InteractionHandType.Right)
{
if (!rightHandPress && hand.IsPressed)
{
rightHandPress = true;
}
if (!rightHandGrip && hand.HandEventType == InteractionHandEventType.Grip)
{
rightHandGrip = true;
}
if (!rightHandRelease && hand.HandEventType == InteractionHandEventType.GripRelease)
{
rightHandRelease = true;
}
}
if (hand.HandType == InteractionHandType.Left)
{
if (!leftHandPress && hand.IsPressed)
{
leftHandPress = true;
}
if (!leftHandGrip && hand.HandEventType == InteractionHandEventType.Grip)
{
leftHandGrip = true;
}
if (!leftHandRelease && hand.HandEventType == InteractionHandEventType.GripRelease)
{
leftHandRelease = true;
}
}
}
}
}
}
}
/// <summary>
/// 手势的处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (this.userInfos == null)
{
this.userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
frame.CopyInteractionDataTo(this.userInfos);
}
else
{
return;
}
}
/////////////
foreach (UserInfo userInfo in this.userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
// string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
//action = "gripped";
//isDrawing.Content = "isDrawing: True";
isgrip = true;
break;
case InteractionHandEventType.GripRelease:
// action = "released";
isgrip = false;
break;
}
//if (action != null)
//{
// string handSide = "unknown";
// switch (handPointer.HandType)
// {
// case InteractionHandType.Left:
// handSide = "left";
// break;
// case InteractionHandType.Right:
// handSide = "right";
// break;
// }
// Console.WriteLine("User " + userInfo.SkeletonTrackingId + " " + action + " their " + handSide + "hand.");
//}
}
}
}
void stream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
interactionFrame.CopyInteractionDataTo(this.infos);
}
}
}
private void interactStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactFrame = e.OpenInteractionFrame())
{
if (interactFrame != null && masterKinectSettings.mergeSkeletons)
{
UserInfo[] tempUserInfo = new UserInfo[6];
interactFrame.CopyInteractionDataTo(tempUserInfo);
foreach (UserInfo interactionInfo in tempUserInfo)
{
foreach (InteractionHandPointer hand in interactionInfo.HandPointers)
{
if (hand.HandEventType == InteractionHandEventType.Grip)
{
for (int i = 0; i < skeletonHandGrabData.Count; i++)
{
if (skeletonHandGrabData[i].skeletonTrackingID == interactionInfo.SkeletonTrackingId)
{
if (hand.HandType == InteractionHandType.Left)
{
skeletonHandGrabData[i].leftHandClosed = true;
}
else if (hand.HandType == InteractionHandType.Right)
{
skeletonHandGrabData[i].rightHandClosed = true;
}
break;
}
}
}
else if (hand.HandEventType == InteractionHandEventType.GripRelease)
{
for (int i = 0; i < skeletonHandGrabData.Count; i++)
{
if (skeletonHandGrabData[i].skeletonTrackingID == interactionInfo.SkeletonTrackingId)
{
if (hand.HandType == InteractionHandType.Left)
{
skeletonHandGrabData[i].leftHandClosed = false;
}
else if (hand.HandType == InteractionHandType.Right)
{
skeletonHandGrabData[i].rightHandClosed = false;
}
break;
}
}
}
}
}
}
}
}
/// <summary>
/// Evènement : si on a les informations de profondeur et du squelette -> définit l'état actuel de la main
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void EventInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
UserInfo[] userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame == null)
{
return;
}
interactionFrame.CopyInteractionDataTo(userInfos);
}
// On parcourt les informations trouvées
bool handFound = false;
foreach (UserInfo userInfo in userInfos)
{
// Si mal reconnu ou on déjà trouvé une main qui est affichée
if (userInfo.SkeletonTrackingId == 0 || handFound)
{
continue;
}
var hands = userInfo.HandPointers;
if (hands.Count == 0) // Si aucune main reconnue
{
continue;
}
foreach (var hand in hands)
{
// La main doit être trackée, active et la main 'primaire' (= première levée des deux)
if (!hand.IsActive || !hand.IsTracked)
{
continue;
}
handFound = true;
actualHandType = hand.HandType;
// Si la main devient grip et c'était pas son ancien état
if (hand.HandEventType == InteractionHandEventType.Grip && hand.HandEventType != actualHandState)
{
actualHandState = InteractionHandEventType.Grip;
}
// Si la main lâche le grip
else if (hand.HandEventType == InteractionHandEventType.GripRelease && hand.HandEventType != actualHandState)
{
actualHandState = InteractionHandEventType.GripRelease;
}
}
}
}
/// <summary>
/// Event handler for InteractionStream's InteractionFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
internal async void InteractionFrameReadyAsync(object sender, InteractionFrameReadyEventArgs e)
{
if (!this.ShouldProcessInteractionData)
{
return;
}
if (this.isProcessingInteractionFrame)
{
// Re-entered InteractionFrameReadyAsync while a previous frame is already being processed.
// Just ignore new frames until the current one finishes processing.
return;
}
this.isProcessingInteractionFrame = true;
try
{
bool haveFrameData = false;
using (var interactionFrame = e.OpenInteractionFrame())
{
// Even though we checked value of userInfos above as part of
// ShouldProcessInteractionData check, callbacks happening while
// opening an interaction frame might have invalidated it, so we
// check value again.
if ((interactionFrame != null) && (this.userInfos != null))
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
this.interactionStreamMessage.timestamp = interactionFrame.Timestamp;
haveFrameData = true;
}
}
if (haveFrameData)
{
this.userStateManager.UpdateUserInformation(this.userInfos, this.interactionStreamMessage.timestamp);
this.userViewerColorizer.UpdateColorLookupTable(this.userInfos, this.userViewerDefaultUserColor, this.userStateManager.UserStates, this.userViewerUserColors);
if (this.interactionIsEnabled)
{
this.interactionStreamMessage.UpdateHandPointers(this.userInfos, this.userStateManager.PrimaryUserTrackingId);
await this.ownerContext.SendStreamMessageAsync(this.interactionStreamMessage);
}
}
}
finally
{
this.isProcessingInteractionFrame = false;
}
}
static void OnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
frame.CopyInteractionDataTo(userInfos);
foreach (UserInfo userInfo in userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
action = "gripped";
break;
case InteractionHandEventType.GripRelease:
action = "released";
break;
}
if (action != null)
{
string handSide = "unknown";
switch (handPointer.HandType)
{
case InteractionHandType.Left:
handSide = "left";
break;
case InteractionHandType.Right:
handSide = "right";
break;
}
Console.WriteLine("{\"hand\":" + handSide + ",\"action\":" + action + "}");
foreach (var socket in _clients)
{
socket.Send("{\"hand\":\"" + handSide + "\",\"action\":\"" + action + "\"}");
}
}
}
}
}
}
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(_userInfos);
}
if (_userInfos == null)
{
return;
}
//this.BeginInteractionFrame();
try
{
foreach (var userInfo in _userInfos)
{
if (userInfo.SkeletonTrackingId == 0)
{
continue;
}
var hands = userInfo.HandPointers;
foreach (var hand in hands)
{
if (!hand.IsActive)
{
continue;
}
if (hand.HandType == InteractionHandType.None)
{
continue;
}
analyzeHandPointer(hand);
}
}
}
finally
{
//this.EndInteractionFrame();
}
}
private void InteractionFrameReadyHandler(object sender, InteractionFrameReadyEventArgs e)
{
using (var interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
if (this.userInfos == null)
{
this.userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
interactionFrame.CopyInteractionDataTo(this.userInfos);
this.controller.processInteractionInfo(this.userInfos, interactionFrame.Timestamp);
}
}
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs interactionFrameReadyEventArgs)
{
if (_userInfos == null)
{
return;
}
using (var interactionFrame = interactionFrameReadyEventArgs.OpenInteractionFrame())
{
if (interactionFrame != null)
{
interactionFrame.CopyInteractionDataTo(_userInfos);
}
}
_payload = CreatePayloadFromUserInfo(_userInfos);
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
TrackClosestSkeleton();
using (var iaf = e.OpenInteractionFrame())
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(_userInfos);
}
// for activating and disabling draw
if (controlManager.isDrawActive(_userInfos, _skeletons))
{
newPoint = controlManager.getCursorLocation(kinectRegion);
if (oldDepth == null || stopDraw == true)
{
oldDepth = newDepth;
}
if (oldPoint == null || stopDraw == true)
{
oldPoint = newPoint;
stopDraw = false;
}
newDepth = controlManager.getHandLocation();
DrawCanvas.Paint(oldPoint, newPoint, inkCanvas, color, thickness, tool, oldDepth, newDepth);
oldPoint = newPoint;
oldDepth = newDepth;
kinectRegion.Tag = "draw";
}
else
{
kinectRegion.Tag = "";
stopDraw = true;
}
}
private void fluxoInteracao_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame quadro = e.OpenInteractionFrame())
{
if (quadro == null)
{
return;
}
UserInfo[] informacoesUsuarios = new UserInfo[6];
quadro.CopyInteractionDataTo(informacoesUsuarios);
IEnumerable <UserInfo> usuariosRastreados = informacoesUsuarios.Where(info => info.SkeletonTrackingId != 0);
if (usuariosRastreados.Count() > 0)
{
UserInfo usuarioPrincipal = usuariosRastreados.First();
if (usuarioPrincipal.HandPointers[0].HandEventType == InteractionHandEventType.Grip)
{
configuracaoMaoEsquerda.DesenhoAtivo = true;
}
else if (usuarioPrincipal.HandPointers[0].HandEventType == InteractionHandEventType.GripRelease)
{
configuracaoMaoEsquerda.DesenhoAtivo = false;
}
if (usuarioPrincipal.HandPointers[1].HandEventType == InteractionHandEventType.Grip)
{
configuracaoMaoDireita.DesenhoAtivo = true;
}
else if (usuarioPrincipal.HandPointers[1].HandEventType == InteractionHandEventType.GripRelease)
{
configuracaoMaoDireita.DesenhoAtivo = false;
}
}
}
}
private void interStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame inf = e.OpenInteractionFrame())
{
if (inf == null)
{
return;
}
inf.CopyInteractionDataTo(userInfos);
}
foreach (UserInfo ui in userInfos)
{
var hands = ui.HandPointers;
if (ui.SkeletonTrackingId == 0)
{
continue;
}
foreach (InteractionHandPointer hand in hands)
{
last = hand.HandEventType == InteractionHandEventType.None ? last : hand.HandEventType;
if (last == InteractionHandEventType.Grip)
{
checkDraw.IsChecked = true;
}
else
{
if (checkDraw.IsChecked == true)
{
checkDraw.IsChecked = false;
}
}
}
}
}
private void interStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame inf = e.OpenInteractionFrame())
{
if (inf == null)
{
return;
}
inf.CopyInteractionDataTo(userInfos);
}
foreach (UserInfo ui in userInfos)
{
var hands = ui.HandPointers;
if (ui.SkeletonTrackingId == 0)
continue;
foreach (InteractionHandPointer hand in hands)
{
last = hand.HandEventType == InteractionHandEventType.None ? last : hand.HandEventType;
if (last == InteractionHandEventType.Grip)
{
checkDraw.IsChecked = true;
}
else
{
if(checkDraw.IsChecked == true)
checkDraw.IsChecked = false;
}
}
}
}
private static void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
//Console.WriteLine("\tentered interaction");
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (userInfos == null)
{
userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
frame.CopyInteractionDataTo(userInfos);
}
else
{
return;
}
}
foreach (UserInfo userInfo in userInfos)
{
//Console.WriteLine(userInfo.HandPointers.Count + " mãos");
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
Console.WriteLine("grip");
action = "gripped";
break;
case InteractionHandEventType.GripRelease:
Console.WriteLine("grip release");
action = "released";
break;
default:
action = "default";
break;
}
if (action != null)
{
string handSide = "unknown";
switch (handPointer.HandType)
{
case InteractionHandType.Left:
//Console.WriteLine("mão esquerda");
handSide = "left";
break;
case InteractionHandType.Right:
//Console.WriteLine("mão direita");
handSide = "right";
break;
}
if (handSide == "left")
{
if (action == "released")
{
// left hand released code here
}
else if (action == "gripped")
{
// left hand gripped code here
}
}
else
{
if (action == "released")
{
// right hand released code here
}
else if (action == "gripped")
{
// right hand gripped code here
}
}
}
}
}
}
private void StreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
if (userInfos == null)
{
userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
interactionFrame.CopyInteractionDataTo(userInfos);
}
else
{
return;
}
foreach (UserInfo player in userInfos)
{
foreach (InteractionHandPointer handPointer in player.HandPointers)
{
int id = player.SkeletonTrackingId;
for (int i = 0; i < skeletonList.Length; i++)
{
if (id == skeletonList[i].TrackingId)
{
index = i;
}
}
//Trace.WriteLine(index);
headText = skeletonList[index].Joints[JointType.Head].Position.X + " " + skeletonList[index].Joints[JointType.Head].Position.Y + " " + skeletonList[index].Joints[JointType.Head].Position.Z;
string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
action = "Hand Gripped";
break;
case InteractionHandEventType.GripRelease:
action = "Hand Released";
break;
}
if (action != null)
{
string handSide = "unknown";
switch (handPointer.HandType)
{
case InteractionHandType.Left:
handSide = "Left";
break;
case InteractionHandType.Right:
handSide = "Right";
break;
}
handText = handSide + " " + action;
//this.label1.Content = labelText;
udpConnection.SendData(System.Text.Encoding.Default.GetBytes(handText));
}
if (handPointer.HandType == InteractionHandType.Right && handPointer.IsTracked)
{
string pos = "pos: " + handPointer.RawX + " " + handPointer.RawY + " " + handPointer.RawZ + " " + headText;
Trace.WriteLine(pos);
udpConnection.SendData(pos);
}
}
}
}
}
/// <summary>
/// Event handler for InteractionStream's InteractionFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
internal async void InteractionFrameReadyAsync(object sender, InteractionFrameReadyEventArgs e)
{
if (!this.ShouldProcessInteractionData)
{
return;
}
if (this.isProcessingInteractionFrame)
{
// Re-entered InteractionFrameReadyAsync while a previous frame is already being processed.
// Just ignore new frames until the current one finishes processing.
return;
}
this.isProcessingInteractionFrame = true;
try
{
bool haveFrameData = false;
using (var interactionFrame = e.OpenInteractionFrame())
{
// Even though we checked value of userInfos above as part of
// ShouldProcessInteractionData check, callbacks happening while
// opening an interaction frame might have invalidated it, so we
// check value again.
if ((interactionFrame != null) && (this.userInfos != null))
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
this.interactionStreamMessage.timestamp = interactionFrame.Timestamp;
haveFrameData = true;
}
}
if (haveFrameData)
{
this.userStateManager.UpdateUserInformation(this.userInfos, this.interactionStreamMessage.timestamp);
this.userViewerColorizer.UpdateColorLookupTable(this.userInfos, this.userViewerDefaultUserColor, this.userStateManager.UserStates, this.userViewerUserColors);
if (this.interactionIsEnabled)
{
this.interactionStreamMessage.UpdateHandPointers(this.userInfos, this.userStateManager.PrimaryUserTrackingId);
await this.ownerContext.SendStreamMessageAsync(this.interactionStreamMessage);
}
}
}
finally
{
this.isProcessingInteractionFrame = false;
}
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (this.userInfos == null)
{
this.userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
frame.CopyInteractionDataTo(this.userInfos);
}
else
{
return;
}
}
foreach (UserInfo userInfo in this.userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
action = "gripped";
break;
case InteractionHandEventType.GripRelease:
action = "released";
break;
}
if (action != null)
{
string handSide = "unknown";
switch (handPointer.HandType)
{
case InteractionHandType.Left:
handSide = "left";
break;
case InteractionHandType.Right:
handSide = "right";
break;
}
//comprobar si conincide con la mano primario y en caso de coincidir
//hand.JointType == JointType.HandRight
if (handSide == "left")
{
if (action == "released")
{
// left hand released code here
}
else
{
// left hand gripped code here
}
}
else
{
if (action == "released")
{
// right hand released code here
}
else
{
// right hand gripped code here
}
}
}
}
}
}
void inStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// if wrong state
//onRaisedVoiceCommand(new VoiceCommandEventArgs("I'm in state" + state + " and I got interaciton data"));
if (state < 2 || state > 3)
{
return;
}
if (frameout < 4)
{
frameout++;
return;
}
//onRaisedVoiceCommand(new VoiceCommandEventArgs("I'm in state" + state));
InteractionFrame intFrame = e.OpenInteractionFrame();
UserInfo[] userInfos = new UserInfo[6];
if (intFrame != null)
{
intFrame.CopyInteractionDataTo(userInfos); // copy userinfos to array
frameout = 0;
}
else
{
return;
}
foreach (UserInfo userInfo in userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
// if at state 2 and grip is detected
if (handPointer.IsPrimaryForUser && handPointer.IsTracked &&
handPointer.HandEventType == InteractionHandEventType.Grip && state == 2)
{
skeletonID = userInfo.SkeletonTrackingId;
if (this.command != "ZOOM")
{
initialValue = handPointer.RawY;
}
else
{
initialValue = handPointer.RawZ;
}
handType = handPointer.HandType;
String message = "Gesture command " + command.ToString() + " began with an initial value of " + initialValue;
//onRaisedGestureCommand(new GestureEventArgs(message, command, initialValue));
onRaisedVoiceCommand(new VoiceCommandEventArgs(message));
state = 3; // move onto next stage
}
// at state 3 grip has not released
if (handPointer.IsPrimaryForUser && handPointer.IsTracked && userInfo.SkeletonTrackingId == skeletonID &&
handPointer.HandEventType == InteractionHandEventType.None && state == 3 && handPointer.HandType == handType)
{
if (this.command != "ZOOM")
{
currentValue = handPointer.RawY;
}
else
{
currentValue = handPointer.RawZ;
}
String message = "Gesture command " + command.ToString() + " with a value of " + currentValue;
onRaisedGestureCommand(new GestureEventArgs(message, command, initialValue - currentValue));
}
// grip released detected at state 3
if (handPointer.IsPrimaryForUser && handPointer.IsTracked && userInfo.SkeletonTrackingId == skeletonID &&
handPointer.HandEventType == InteractionHandEventType.GripRelease && state == 3 && handPointer.HandType == handType)
{
//currentValue = handPointer.RawY;
String message = "Gesture command " + command.ToString() + " ended with a value of " + currentValue + " and initial value of " + initialValue + " and a difference of " + (currentValue - initialValue);
onRaisedGestureCommand(new GestureEventArgs(message, command, initialValue - currentValue));
state = 1; // return to initial stage
}
}
}
}
/// <summary>
/// The event handler for interaction frame events.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The arguments for the event.</param>
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
Player playerToUse = null;
List<Point> RectanglePoints = new List<Point>();
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.usersInfo != null)
{
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.usersInfo);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.usersInfo;
}
}
if (localUserInfos != null)
{
var currentUserSet = new HashSet<int>();
var usersToRemove = new HashSet<Player>();
// Keep track of current users in scene
foreach (var info in localUserInfos)
{
if (info.SkeletonTrackingId == 0)
{
// Only look at user information corresponding to valid users
continue;
}
foreach (Player player in players)
{
if (player.Info.SkeletonTrackingId == info.SkeletonTrackingId)
{
playerToUse = player;
}
}
currentUserSet.Add(info.SkeletonTrackingId);
this.trackedUsers.Add(info.SkeletonTrackingId);
// Perform hit testing and look for Grip and GripRelease events
foreach (var handPointer in info.HandPointers)
{
if (handPointer.IsPrimaryForUser)
{
double xUI = handPointer.X * this.Width;
double yUI = handPointer.Y * this.Height;
RectanglePoints.Add(new Point(xUI+50, yUI+50));
if (handPointer.HandEventType == InteractionHandEventType.Grip)
{
playerToUse.Grab();
//check the rectangle and see what colour we're on.
foreach (UIElement elem in ColourScreen.Children)
{
if (elem is Rectangle)
{
Rectangle tmp = (Rectangle)elem;
CheckSelect(playerToUse, new Point(xUI+50, yUI+50), tmp);
}
}
}
else if(handPointer.HandEventType == InteractionHandEventType.GripRelease)
{
playerToUse.Release();
}
if (playerToUse != null)
{
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(playerToUse.Cursor, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(playerToUse.Cursor, yUI);
}
}
}
}
}
foreach (Player player in players)
{
if (!currentUserSet.Contains(player.Info.SkeletonTrackingId))
{
usersToRemove.Add(player);
ResetUser(player);
}
}
foreach (Player player in usersToRemove)
{
ColourScreen.Children.Remove(player.Cursor);
players.Remove(player);
if (players.Count == 0)
{
//start a timer that will mark the time and go back if there's no one there within 5 seconds
break;
}
sensor.SkeletonStream.AppChoosesSkeletons = false;
}
CheckHover(RectanglePoints);
}
}
}
void stream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
interactionFrame.CopyInteractionDataTo(this.infos);
}
}
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
return;
iaf.CopyInteractionDataTo(_userInfos);
}
StringBuilder dump = new StringBuilder();
this.buildAndSendStringDump(dump);
foreach (var userInfo in _userInfos)
{
var userID = userInfo.SkeletonTrackingId;
if (userID == 0)
continue;
var hands = userInfo.HandPointers;
if (hands.Count == 0)
dump.AppendLine(" No hands");
else
{
foreach (var hand in hands)
{
if (hand.IsActive)
{
}
var lastHandEvents = hand.HandType == InteractionHandType.Left
? _lastLeftHandEvents
: _lastRightHandEvents;
if (hand.HandEventType != InteractionHandEventType.None)
lastHandEvents[userID] = hand.HandEventType;
var lastHandEvent = lastHandEvents.ContainsKey(userID)
? lastHandEvents[userID]
: InteractionHandEventType.None;
}
}
}
}
private void interactStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactFrame = e.OpenInteractionFrame())
{
if (interactFrame != null && masterKinectSettings.mergeSkeletons)
{
UserInfo[] tempUserInfo = new UserInfo[6];
interactFrame.CopyInteractionDataTo(tempUserInfo);
foreach (UserInfo interactionInfo in tempUserInfo)
{
foreach (InteractionHandPointer hand in interactionInfo.HandPointers)
{
if (hand.HandEventType == InteractionHandEventType.Grip)
{
for (int i = 0; i < skeletonHandGrabData.Count; i++)
{
if (skeletonHandGrabData[i].skeletonTrackingID == interactionInfo.SkeletonTrackingId)
{
if (hand.HandType == InteractionHandType.Left)
{
skeletonHandGrabData[i].leftHandClosed = true;
}
else if (hand.HandType == InteractionHandType.Right)
{
skeletonHandGrabData[i].rightHandClosed = true;
}
break;
}
}
}
else if (hand.HandEventType == InteractionHandEventType.GripRelease)
{
for (int i = 0; i < skeletonHandGrabData.Count; i++)
{
if (skeletonHandGrabData[i].skeletonTrackingID == interactionInfo.SkeletonTrackingId)
{
if (hand.HandType == InteractionHandType.Left)
{
skeletonHandGrabData[i].leftHandClosed = false;
}
else if (hand.HandType == InteractionHandType.Right)
{
skeletonHandGrabData[i].rightHandClosed = false;
}
break;
}
}
}
}
}
}
}
}
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
Storyboard sb = this.TryFindResource("HelloFlashing") as Storyboard;
Player playerToUse = null;
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.usersInfo == null)
{
return;
}
UserInfo[] localUserInfos = null;
long timestamp = 0;
//HashSet<int> trackedUsers = new HashSet<int>();
//foreach(Player player in players)
//{
// trackedUsers.Add(player.Info.SkeletonTrackingId);
//}
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.usersInfo);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.usersInfo;
}
}
if (localUserInfos != null)
{
var currentUserSet = new HashSet<int>();
var usersToRemove = new HashSet<Player>();
// Keep track of current users in scene
foreach (var info in localUserInfos)
{
if (info.SkeletonTrackingId == 0)
{
// Only look at user information corresponding to valid users
continue;
}
if (!this.trackedUsers.Contains(info.SkeletonTrackingId))
{
Ellipse newPlayerCursor;
if (players.Count == 0)
{
if(Hello.Opacity == 0)
{
sb.Begin(Hello, true);
}
newPlayerCursor = KinectHelper.CreateCursor(100, 100, new SolidColorBrush(Colors.Yellow), "player1");
players.Add(new Player(info, newPlayerCursor, "player1"));
canvas.Children.Add(newPlayerCursor);
}
else
{
if (players.Count == 1)
{
string name = "player2";
if (players[0].Name == "player2")
{
name = "player1";
}
newPlayerCursor = KinectHelper.CreateCursor(this.Height/20, this.Height / 20, new SolidColorBrush(Colors.Crimson), name);
players.Add(new Player(info, newPlayerCursor, name));
canvas.Children.Add(newPlayerCursor);
}
}
}
foreach (Player player in players)
{
if (player.Info.SkeletonTrackingId == info.SkeletonTrackingId)
{
playerToUse = player;
}
}
currentUserSet.Add(info.SkeletonTrackingId);
this.trackedUsers.Add(info.SkeletonTrackingId);
// Perform hit testing and look for Grip and GripRelease events
foreach (var handPointer in info.HandPointers)
{
if (handPointer.IsPrimaryForUser)
{
double xUI = handPointer.X * this.Width;
double yUI = handPointer.Y * this.Height;
double coinTop = 0;
double coinLeft = 0;
var uiElement = VisualTreeHelper.HitTest(canvas, new Point(xUI, yUI));
Ellipse coinElement = null;
// canvas.FindName("Quarter");
foreach (UIElement elem in canvas.Children)
{
if (elem is Ellipse && ((Ellipse)elem).Name == "Quarter")
{
coinElement = (Ellipse)elem;
coinTop = Canvas.GetTop(coinElement);
coinLeft = Canvas.GetLeft(coinElement);
}
}
if (playerToUse != null)
{
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(playerToUse.Cursor, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(playerToUse.Cursor, yUI);
}
}
if (coinElement != null)
{
if (handPointer.HandEventType != InteractionHandEventType.None)
{
if (handPointer.HandEventType == InteractionHandEventType.Grip)
{
if (!entryCoin.IsGripped)
{
if (((xUI <= coinLeft + 60) || (xUI <= coinLeft - 20)) && ((yUI <= coinTop + 60) || (yUI <= coinTop - 20)))
{
entryCoin.IsGripped = true;
entryCoin.GrippedBy = playerToUse.Name;
}
}
}
else if (handPointer.HandEventType == InteractionHandEventType.GripRelease)
{
if ((entryCoin.IsGripped) && (entryCoin.GrippedBy == playerToUse.Name))
{
entryCoin.GrippedBy = "";
entryCoin.IsGripped = false;
//do not let the coin exceed the bounds of the screen. This must be set explicitly and not
//in reference to the top/left of the players cursor due to it still exceeding boundary
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(coinElement, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(coinElement, yUI);
}
}
}
}
if (entryCoin.IsGripped && (entryCoin.GrippedBy == playerToUse.Name))
{
//do not let the coin exceed the bounds of the screen. This must be set explicitly and not
//in reference to the top/left of the players cursor due to it still exceeding boundary
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(coinElement, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(coinElement, yUI);
}
}
}
}
}
}
foreach (Player player in players)
{
if (!currentUserSet.Contains(player.Info.SkeletonTrackingId))
{
usersToRemove.Add(player);
}
}
foreach (Player player in usersToRemove)
{
canvas.Children.Remove(player.Cursor);
players.Remove(player);
}
if(players.Count == 0)
{
//start a timer that will mark the time and go back if there's no one there within 5 seconds
}
}
}
/// <summary>
/// Event handler for InteractionStream's InteractionFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.userInfos == null)
{
return;
}
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.userInfos;
}
}
if (localUserInfos != null)
{
//// TODO: Process user info data, perform hit testing with UI, route UI events, etc.
//// TODO: See KinectRegion and KinectAdapter in Microsoft.Kinect.Toolkit.Controls assembly
//// TODO: For a more comprehensive example on how to do this.
var currentUserSet = new HashSet<int>();
var usersToRemove = new HashSet<int>();
// Keep track of current users in scene
foreach (var info in localUserInfos)
{
if (info.SkeletonTrackingId == InvalidTrackingId)
{
// Only look at user information corresponding to valid users
continue;
}
if (!this.trackedUsers.Contains(info.SkeletonTrackingId))
{
Console.WriteLine(Converter.EncodeNewInteractionUser(info.SkeletonTrackingId));
}
currentUserSet.Add(info.SkeletonTrackingId);
this.trackedUsers.Add(info.SkeletonTrackingId);
// Perform hit testing and look for Grip and GripRelease events
foreach (var handPointer in info.HandPointers)
{
Console.WriteLine(Converter.EncodeInteraction(info.SkeletonTrackingId,
(HandEventType)handPointer.HandEventType,
(HandType)handPointer.HandType, (float)handPointer.X, (float)handPointer.Y, (float)handPointer.PressExtent,
handPointer.IsActive, handPointer.IsInteractive, handPointer.IsPressed, handPointer.IsTracked));
}
}
foreach (var id in this.trackedUsers)
{
if (!currentUserSet.Contains(id))
{
usersToRemove.Add(id);
}
}
foreach (var id in usersToRemove)
{
this.trackedUsers.Remove(id);
Console.WriteLine(Converter.EncodeInteractionUserLeft(id));
}
}
}
private void InteractiontStream_InteractionFrameReady( object sender, InteractionFrameReadyEventArgs e )
{
InteractionFrame iFrame = e.OpenInteractionFrame();
if( iFrame == null ) return;
iFrame.CopyInteractionDataTo( _userInfo );
List<UserInfo> curUsers = _userInfo.Where( x => x.SkeletonTrackingId > 0 ).ToList<UserInfo>();
if( curUsers.Count > 0 )
{
if ( !_skeletonFound )
{
_skeletonFound = true;
}
UserInfo curUser = curUsers[0];
_handsVisible = true;
_positionTrackerController.NotifyPositionTrackers( curUser );
if( HandsPointReady != null )
{
Point left = WindowPointFromHandPointer( curUser.HandPointers[0] );
Point right = WindowPointFromHandPointer( curUser.HandPointers[1] );
_leftHand = left;
_rightHand = right;
MapInput();
OnHandsPointReady( left, right );
SafetyModeCheck( curUser );
TestTakeOffCapabitility( curUser );
}
}
else if( _handsVisible == true )
{
OnHandsPointReady( new System.Windows.Point( -1, -1 ), new System.Windows.Point( -1, -1 ) );
_leftHand = new System.Windows.Point(-1, -1);
_rightHand = new System.Windows.Point(-1, -1);
MapInput();
_handsVisible = false;
if( _skeletonFound )
{
_skeletonFound = false;
SafetyModeCheck( null );
}
_leftGrip = false;
_rightGrip = false;
}
else
{
if( _skeletonFound )
{
_skeletonFound = false;
}
_leftGrip = false;
_rightGrip = false;
}
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(_userInfos);
}
foreach (var userInfo in _userInfos)
{
var userID = userInfo.SkeletonTrackingId;
if (userID == 0)
{
continue;
}
var hands = userInfo.HandPointers;
foreach (var hand in hands)
{
var lastHandEvents = hand.HandType == InteractionHandType.Left
? _lastLeftHandEvents
: _lastRightHandEvents;
if (lastHandEvents == _lastLeftHandEvents)
{
continue;
}
if (hand.HandEventType != InteractionHandEventType.None)
{
lastHandEvents[userID] = hand.HandEventType;
}
var lastHandEvent = lastHandEvents.ContainsKey(userID)
? lastHandEvents[userID]
: InteractionHandEventType.None;
if (lastHandEvent == InteractionHandEventType.Grip)
{
// Set value
isGripped = true;
// If hand gripped, show gripped cursor and move the item with the cursor
handCursor.Source = new BitmapImage(new Uri("Resources/pointerWhite.png", UriKind.Relative));
// Find the item number of which the hand cursor is on
if (itemGripped.HandCursorOn == -1 && itemGripped.HandCursorOnSet == false)
{
for (int i = itemChildrenStart; i < canvas.Children.Count; i++)
{
var childrenPoint = canvas.Children[i].TranslatePoint(new Point(0, 0), canvas);
var handCursorPoint = handCursor.TranslatePoint(new Point(0, 0), canvas);
if (handCursorPoint.X > childrenPoint.X && handCursorPoint.X < childrenPoint.X +
itemWidth && handCursorPoint.Y > childrenPoint.Y && handCursorPoint.Y < childrenPoint.Y + itemHeight)
{
itemGripped.HandCursorOn = i;
itemGripped.HandCursorOnLeftDistant = handCursorPoint.X - childrenPoint.X;
itemGripped.HandCursorOnTopDistant = handCursorPoint.Y - childrenPoint.Y;
itemGripped.HandCursorOnSet = true;
break;
}
}
}
// Move the item with the hand cursor
if (itemGripped.HandCursorOn != -1)
{
var p = handCursor.TranslatePoint(new Point(0, 0), canvas);
try
{
Canvas.SetLeft(canvas.Children[itemGripped.HandCursorOn], p.X - itemGripped.HandCursorOnLeftDistant);
Canvas.SetTop(canvas.Children[itemGripped.HandCursorOn], p.Y - itemGripped.HandCursorOnTopDistant);
}
catch (Exception)
{
}
}
}
else if (lastHandEvent == InteractionHandEventType.GripRelease)
{
// Set value
isGripped = false;
// If hand grip released, show normal cursor
handCursor.Source = new BitmapImage(new Uri("Resources/handWhite.png", UriKind.Relative));
itemGripped.HandCursorOn = -1;
itemGripped.HandCursorOnSet = false;
}
if (hand.IsPressed)
{
// If hand pressed the back, go back:
// Get points of hand cursor and back button
var handCursorPoint = handCursor.TranslatePoint(new Point(0, 0), canvas);
var backPoint = back.TranslatePoint(new Point(0, 0), canvas);
// Left and Right check:
if (back.ActualWidth + backPoint.X >= handCursorPoint.X && handCursorPoint.X + handCursor.ActualWidth / 2 >= backPoint.X)
{
// Top and Bottom check:
if (back.ActualHeight + backPoint.Y >= handCursorPoint.Y && handCursorPoint.Y + handCursor.ActualHeight / 2 >= backPoint.Y)
{
// If 'watch' timer is running, then save the game first
// If not, just close the window
if (watch.IsRunning)
{
// Stop the timer
watch.Stop();
// Reset the timer
watch.Reset();
}
// Close the game window
Close();
}
}
}
}
}
}
/// <summary>
/// Event handler for InteractionStream's InteractionFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.userInfos == null)
{
return;
}
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.userInfos;
}
}
if (localUserInfos != null)
{
//// TODO: Process user info data, perform hit testing with UI, route UI events, etc.
//// TODO: See KinectRegion and KinectAdapter in Microsoft.Kinect.Toolkit.Controls assembly
//// TODO: For a more comprehensive example on how to do this.
var currentUserSet = new HashSet <int>();
var usersToRemove = new HashSet <int>();
// Keep track of current users in scene
foreach (var info in localUserInfos)
{
if (info.SkeletonTrackingId == InvalidTrackingId)
{
// Only look at user information corresponding to valid users
continue;
}
if (!this.trackedUsers.Contains(info.SkeletonTrackingId))
{
Console.WriteLine(Converter.EncodeNewInteractionUser(info.SkeletonTrackingId));
}
currentUserSet.Add(info.SkeletonTrackingId);
this.trackedUsers.Add(info.SkeletonTrackingId);
// Perform hit testing and look for Grip and GripRelease events
foreach (var handPointer in info.HandPointers)
{
Console.WriteLine(Converter.EncodeInteraction(info.SkeletonTrackingId,
(HandEventType)handPointer.HandEventType,
(HandType)handPointer.HandType, (float)handPointer.X, (float)handPointer.Y, (float)handPointer.PressExtent,
handPointer.IsActive, handPointer.IsInteractive, handPointer.IsPressed, handPointer.IsTracked));
}
}
foreach (var id in this.trackedUsers)
{
if (!currentUserSet.Contains(id))
{
usersToRemove.Add(id);
}
}
foreach (var id in usersToRemove)
{
this.trackedUsers.Remove(id);
Console.WriteLine(Converter.EncodeInteractionUserLeft(id));
}
}
}
private static void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (userInfos == null)
{
userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
frame.CopyInteractionDataTo(userInfos);
}
else
{
return;
}
}
isFirstGrip = false;
Console.WriteLine("userinfo length : " + userInfos.Length);
foreach (UserInfo userInfo in userInfos)
{
//if (userInfo.SkeletonTrackingId == 0) continue;
Console.WriteLine("number handpointers : " + userInfo.HandPointers.Count);
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
//if (!handPointer.IsTracked) continue;
string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
Console.WriteLine("grip");
action = "gripped";
break;
case InteractionHandEventType.GripRelease:
Console.WriteLine("grip release");
action = "released";
break;
default:
action = "default";
break;
}
if (action != null)
{
string handSide = "unknown";
switch (handPointer.HandType)
{
case InteractionHandType.Left:
//Console.WriteLine("mão esquerda");
handSide = "left";
break;
case InteractionHandType.Right:
//Console.WriteLine("mão direita");
handSide = "right";
break;
}
if (handSide == "left")
{
if (action == "released")
{
// left hand released code here
handGrip = NO_HAND;
}
else if (action == "gripped")
{
// left hand gripped code here
handGrip = LEFT_HAND;
}
}
else
{
if (action == "released")
{
// right hand released code here
handGrip = NO_HAND;
}
else if (action == "gripped")
{
// right hand gripped code here
handGrip = RIGHT_HAND;
}
}
}
float xPos = 20f, yPos = 20f, zPos = 20f;
// check if at least one hand on grip
if (handGrip != NO_HAND)
{
// aqui podia verificar se dá -1, que significa nenhum a ser tracked, mas em
// princípio isso não vai suceder
int skeletonIndex = whichSkeleton(skeletons);
Console.WriteLine(handGrip);
if (handGrip == LEFT_HAND)
{
xPos = skeletons[skeletonIndex].Joints[JointType.HandLeft].Position.X;
yPos = skeletons[skeletonIndex].Joints[JointType.HandLeft].Position.Y;
zPos = skeletons[skeletonIndex].Joints[JointType.HandLeft].Position.Z;
}
else
{
xPos = skeletons[skeletonIndex].Joints[JointType.HandRight].Position.X;
yPos = skeletons[skeletonIndex].Joints[JointType.HandRight].Position.Y;
zPos = skeletons[skeletonIndex].Joints[JointType.HandRight].Position.Z;
Console.WriteLine(userInfo.SkeletonTrackingId);
Console.WriteLine("posição z : " + skeletons[skeletonIndex].Joints[JointType.HandRight].Position.Z);
}
// check if this is the first grip of a sequence
if (isFirstGrip)
{
isFirstGrip = false;
Console.WriteLine("First grip!");
// store the first positions
xPosFirst = xPos;
yPosFirst = yPos;
zPosFirst = zPos;
// dá sempre zero
float distanceFromOrigin = calculateDistanceBetweenHands(xPos, xPosFirst, yPos, yPosFirst);
Console.WriteLine("Distance from origin: " + distanceFromOrigin);
//Console.WriteLine(xPosFirst);
}
// call functions to manipulate image
else
{
float distanceFromOrigin = calculateDistanceBetweenHands(xPos, xPosFirst, yPos, yPosFirst);
// Console.WriteLine("Distance from origin: " + distanceFromOrigin);
Console.WriteLine("diferença z : " + (zPos - zPosFirst));
image_Zoom(zPos - zPosFirst);
}
}
else
{
isFirstGrip = true;
}
}
}
}
/// <summary>
/// Manejador de eventos para el evento del sensor de kinect InteractionStream sacado y adaptado de:
/// http://dotneteers.net/blogs/vbandi/archive/2013/05/03/kinect-interactions-with-wpf-part-iii-demystifying-the-interaction-stream.aspx
/// y https://msdn.microsoft.com/es-es/library/system.windows.media.formattedtext(v=vs.110).aspx
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (this.userInfos == null)
{
this.userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
//Copiamos los datos de interacción.
frame.CopyInteractionDataTo(this.userInfos);
}
else
{
//return;
}
}
foreach (UserInfo userInfo in this.userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
//Inicializamos la acción que realizará.
string action = null;
//Comprobamos cual es la acción y asignamos la acción que realice el evento de la mano.
switch (handPointer.HandEventType)
{
//Si cerramos la mano asignamos gripped a la acción
case InteractionHandEventType.Grip:
action = "gripped";
break;
//Si abrimos la mano asinamos released a la acción
case InteractionHandEventType.GripRelease:
action = "released";
break;
}
if (action != null)
{
//Iniciamos que mano es la que está realizando la acción a desconocida.
string handSide = "unknown";
//Comprobamos que mano es la que realiza la acción y asignamos left o right dependiendo de que mano es.
switch (handPointer.HandType)
{
case InteractionHandType.Left:
handSide = "left";
break;
case InteractionHandType.Right:
handSide = "right";
break;
}
// Dependiendo de la mano hará una acción u otra al abrir y cerrar,
// en nuestro caso son las mismas acciones para ambas manos pero dibujará un puño cerrado o abierto dependiendo de que mano esté realizando la acción.
//Si la acción es released llamaremos a la función soltar de la clase Puzzle.cs
//Si es coger llamará a la función coger de la clase Puzzle.cs
//Ver Puzzle.cs para saber lo que hacen.
if (handSide == "left")
{
if (action == "released")
{
puzzle.soltar(handSide);
manoIzq = manoIzqA;
}
else
{
puzzle.coger(handSide);
manoIzq = manoIzqC;
}
}
else
{
if (action == "released")
{
puzzle.soltar(handSide);
manoDer = manoDerA;
}
else
{
puzzle.coger(handSide);
manoDer = manoDerC;
}
}
}
}
}
}
private void InteractionStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactionFrame = e.OpenInteractionFrame()) //dispose as soon as possible
{
if (interactionFrame == null)
{
return;
}
interactionFrame.CopyInteractionDataTo(userInfos);
}
//select our user and get his data
var userInfo = userInfos.FirstOrDefault(uInfo => uInfo.SkeletonTrackingId != 0);
if (userInfo == null)
{
return;
}
var userID = userInfo.SkeletonTrackingId;
hands = userInfo.HandPointers;
//if at least one hand has been found
if (hands.Count > 0)
{
var mySkeleton = skeletons.FirstOrDefault(skeleton => skeleton.TrackingState == SkeletonTrackingState.Tracked);
var leftHand = hands.FirstOrDefault(hand => hand.HandType == InteractionHandType.Left);
var rightHand = hands.FirstOrDefault(hand => hand.HandType == InteractionHandType.Right);
if (leftHand == null || rightHand == null)
{
return;
}
var leftHandEvent = DetermineLastHandEvent(leftHand, userID);
var rightHandEvent = DetermineLastHandEvent(rightHand, userID);
var leftHandJoint = mySkeleton.Joints[JointType.HandLeft];
var rightHandJoint = mySkeleton.Joints[JointType.HandRight];
LHandText = $"Tracking status: {leftHand.IsTracked}\nX: {Math.Round(leftHand.RawX, 1)} Y: {Math.Round(leftHand.RawY, 1)} Z: {Math.Round(leftHand.RawZ, 1)}\nState: {leftHandEvent}";
RHandText = $"Tracking status: {rightHand.IsTracked}\nX: {Math.Round(rightHand.RawX, 1)} Y: {Math.Round(rightHand.RawY, 1)} Z: {Math.Round(rightHand.RawZ, 1)}\nState: {rightHandEvent}";
LeftHandMarker.UpdateUI(kinectSensor, leftHandJoint, leftHandEvent, leftHandEvent);
NotifyPropertyChanged("LeftHandMarker");
RightHandMarker.UpdateUI(kinectSensor, rightHandJoint, leftHandEvent, rightHandEvent);
NotifyPropertyChanged("RightHandMarker");
if (Manipulator == null || !Manipulator.Connected)
{
return;
}
if (leftHandEvent == InteractionHandEventType.Grip)
{
const int multiplication = 100; //tbd
if (sample)
{
if (rightHandEvent == InteractionHandEventType.Grip && lastGripCommand.Equals(GripOpen))
{
Manipulator?.SendCustom(GripClose);
lastGripCommand = GripClose;
wasGripSent = true;
}
else if (rightHandEvent == InteractionHandEventType.GripRelease && lastGripCommand.Equals(GripClose))
{
Manipulator?.SendCustom(GripOpen);
lastGripCommand = GripOpen;
wasGripSent = true;
}
if (!wasGripSent)
{
var moveCommand = $"DS {(int)sumZ}, {(int)sumX}, {(int)sumY}";
Manipulator?.SendCustom(moveCommand);
}
else
{
wasGripSent = false;
}
timer.Start();
ResetSums();
sample = false;
lastPosition = rightHandJoint.Position;
}
else
{
var deltaX = (rightHandJoint.Position.X - lastPosition.X) * multiplication;
var deltaY = (rightHandJoint.Position.Y - lastPosition.Y) * multiplication;
var deltaZ = (rightHandJoint.Position.Z - lastPosition.Z) * multiplication;
sumX += deltaX;
sumY += deltaY;
sumZ += deltaZ;
}
//lastPosition = rightHandJoint.Position;
}
else
{
lastPosition = rightHandJoint.Position;
}
}
}
/// <summary>
/// Manejador de eventos para el evento del sensor de kinect InteractionStream sacado y adaptado de:
/// http://dotneteers.net/blogs/vbandi/archive/2013/05/03/kinect-interactions-with-wpf-part-iii-demystifying-the-interaction-stream.aspx
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (this.userInfos == null)
{
this.userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
//Copiamos los datos de interacción.
frame.CopyInteractionDataTo(this.userInfos);
}
else
{
return;
}
}
foreach (UserInfo userInfo in this.userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
//Inicializamos la acción que realizará.
string action = null;
//Comprobamos cual es la acción y asignamos la acción que realice el evento de la mano.
switch (handPointer.HandEventType)
{
//Si cerramos la mano asignamos gripped a la acción
case InteractionHandEventType.Grip:
action = "gripped";
break;
//Si abrimos la mano asinamos released a la acción
case InteractionHandEventType.GripRelease:
action = "released";
break;
}
if (action != null)
{
//Iniciamos que mano es la que está realizando la acción a desconocida.
string handSide = "unknown";
//Comprobamos que mano es la que realiza la acción y asignamos left o right dependiendo de que mano es.
switch (handPointer.HandType)
{
case InteractionHandType.Left:
handSide = "left";
break;
case InteractionHandType.Right:
handSide = "right";
break;
}
// Dependiendo de la mano hará una acción u otra al abrir y cerrar,
// en nuestro caso son las mismas acciones para ambas manos pero dibujará un puño cerrado o abierto dependiendo de que mano esté realizando la acción.
//Si la acción es released llamaremos a la función soltar de la clase Puzzle.cs
//Si es coger llamará a la función coger de la clase Puzzle.cs
//Ver Puzzle.cs para saber lo que hacen.
if (handSide == "left")
{
if (action == "released")
{
puzzle.soltar(handSide);
manoIzq = manoIzqA;
}
else
{
puzzle.coger(handSide);
manoIzq = manoIzqC;
}
}
else
{
if (action == "released")
{
puzzle.soltar(handSide);
manoDer = manoDerA;
}
else
{
puzzle.coger(handSide);
manoDer = manoDerC;
}
}
}
}
}
}
//Listener de las interacciones del esqueleto
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(_userInfos);
}
StringBuilder dump = new StringBuilder();
var hasUser = false;
//Ciclo por los usuarios disponibles
foreach (var userInfo in _userInfos)
{
//obtiene id del usuario proporcionado por kinec
var userID = userInfo.SkeletonTrackingId;
//si el id es 0 se sigue con el siguiente
if (userID == 0)
{
continue;
}
//como existe usuario le coloca true
hasUser = true;
//se agrega el id del usuario al stringbuilder
dump.AppendLine("User ID = " + userID);
dump.AppendLine(" Hands: ");
//Se crea un arreglo con las manos disponibles de la persona y se le asigna
var hands = userInfo.HandPointers;
if (hands.Count == 0)
{
dump.AppendLine(" No hands");
}
else
{
//se recorren las manos por persona
foreach (var hand in hands)
{
//Se diferencia mano derecha o izquierda
var lastHandEvents = hand.HandType == InteractionHandType.Left
? _lastLeftHandEvents
: _lastRightHandEvents;
if (hand.HandEventType != InteractionHandEventType.None)
{
lastHandEvents[userID] = hand.HandEventType;
}
var lastHandEvent = lastHandEvents.ContainsKey(userID)
? lastHandEvents[userID]
: InteractionHandEventType.None;
//se obtienen datos de las manos, como que tipo
dump.AppendLine();
dump.AppendLine(" Mano derecha o izquierda : " + hand.HandType);
dump.AppendLine(" Tipo de evento de la mano: " + hand.HandEventType);
dump.AppendLine(" ultimo evento: " + lastHandEvent);
dump.AppendLine(" esta activa: " + hand.IsActive);
dump.AppendLine(" es la mano dominante en el programa: " + hand.IsPrimaryForUser);
dump.AppendLine(" IsInteractive: " + hand.IsInteractive);
dump.AppendLine(" PressExtent: " + hand.PressExtent.ToString("N3"));
dump.AppendLine(" es precionada: " + hand.IsPressed);
dump.AppendLine(" es trackeada: " + hand.IsTracked);
dump.AppendLine(" X: " + hand.X.ToString("N3"));
dump.AppendLine(" Y: " + hand.Y.ToString("N3"));
dump.AppendLine(" RawX: " + hand.RawX.ToString("N3"));
dump.AppendLine(" RawY: " + hand.RawY.ToString("N3"));
dump.AppendLine(" RawZ: " + hand.RawZ.ToString("N3"));
movimiento(hand.X, hand.Y, hand.HandType);
if (hand.HandEventType == InteractionHandEventType.Grip && hand.HandType == InteractionHandType.Right)
{
recDerecha.Fill = new SolidColorBrush(Colors.Red);
}
else if (hand.HandEventType == InteractionHandEventType.GripRelease && hand.HandType == InteractionHandType.Right)
{
recDerecha.Fill = new SolidColorBrush(Colors.Black);
}
}
}
//Se imprimen las variables
// tb.Text = dump.ToString();
}
// si no existe el usuario
if (!hasUser)
{
// tb.Text = "No user detected.";
}
}
private void StreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
if (userInfos == null)
{
userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
interactionFrame.CopyInteractionDataTo(userInfos);
}
else
{
return;
}
foreach (UserInfo player in userInfos)
{
foreach (InteractionHandPointer handPointer in player.HandPointers)
{
string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
action = "Hand Gripped";
break;
case InteractionHandEventType.GripRelease:
action = "Hand Released";
break;
}
if (action != null)
{
string handSide = "unknown";
switch (handPointer.HandType)
{
case InteractionHandType.Left:
handSide = "Left";
break;
case InteractionHandType.Right:
handSide = "Right";
break;
}
labelText = handSide + " " + action;
this.label1.Content = labelText;
udpConnection.SendData(System.Text.Encoding.Default.GetBytes(labelText));
}
if (handPointer.HandType == InteractionHandType.Right && handPointer.IsTracked)
{
string pos = "pos: " + handPointer.RawX + " " + handPointer.RawY + " " + handPointer.RawZ;
Trace.WriteLine(pos);
udpConnection.SendData(pos);
}
}
}
}
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
return;
iaf.CopyInteractionDataTo(_userInfos);
}
var lastSkeleton = _skeletons.Where((s) => s.TrackingState != SkeletonTrackingState.NotTracked).LastOrDefault();
foreach (var userInfo in _userInfos)
{
var userID = userInfo.SkeletonTrackingId;
if (userID == 0)
continue;
//Update with all skeletons and current user info
//Currently use last valid skeleton
gestureController.UpdateAllGestures(lastSkeleton, userInfo);
}
if (DEBUG)
GenerateDump(_userInfos,lastSkeleton);
}
private void InteractionStreamOnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs args)
{
using (var iaf = args.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(_userInfos);
}
StringBuilder dump = new StringBuilder();
var hasUser = false;
foreach (var userInfo in _userInfos)
{
var userID = userInfo.SkeletonTrackingId;
if (userID == 0)
{
continue;
}
hasUser = true;
dump.AppendLine("User ID = " + userID);
dump.AppendLine(" Hands: ");
var hands = userInfo.HandPointers;
if (hands.Count == 0)
{
dump.AppendLine(" No hands");
}
else
{
foreach (var hand in hands)
{
var lastHandEvents = hand.HandType == InteractionHandType.Left
? _lastLeftHandEvents
: _lastRightHandEvents;
if (hand.HandEventType != InteractionHandEventType.None)
{
lastHandEvents[userID] = hand.HandEventType;
}
var lastHandEvent = lastHandEvents.ContainsKey(userID)
? lastHandEvents[userID]
: InteractionHandEventType.None;
dump.AppendLine();
dump.AppendLine(" HandType: " + hand.HandType);
dump.AppendLine(" HandEventType: " + hand.HandEventType);
dump.AppendLine(" LastHandEventType: " + lastHandEvent);
dump.AppendLine(" IsActive: " + hand.IsActive);
dump.AppendLine(" IsPrimaryForUser: "******" IsInteractive: " + hand.IsInteractive);
dump.AppendLine(" PressExtent: " + hand.PressExtent.ToString("N3"));
dump.AppendLine(" IsPressed: " + hand.IsPressed);
dump.AppendLine(" IsTracked: " + hand.IsTracked);
dump.AppendLine(" X: " + hand.X.ToString("N3"));
dump.AppendLine(" Y: " + hand.Y.ToString("N3"));
dump.AppendLine(" RawX: " + hand.RawX.ToString("N3"));
dump.AppendLine(" RawY: " + hand.RawY.ToString("N3"));
dump.AppendLine(" RawZ: " + hand.RawZ.ToString("N3"));
}
}
tb.Text = dump.ToString();
}
if (!hasUser)
{
tb.Text = "No user detected.";
}
}
/// <summary>
/// The event handler for Kinect interactions for the InitialDetectionPage.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The arguments for the event.</param>
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
Player playerToUse = null;
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.usersInfo != null)
{
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.usersInfo);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.usersInfo;
}
}
if (localUserInfos != null)
{
var currentUserSet = new HashSet<int>();
var usersToRemove = new HashSet<Player>();
// Keep track of current users in scene
foreach (var info in localUserInfos)
{
if (info.SkeletonTrackingId == 0)
{
// Only look at user information corresponding to valid users
continue;
}
if (!this.trackedUsers.Contains(info.SkeletonTrackingId))
{
if (players.Count == 0)
{
players.Add(new Player(info, "player1", Brushes.SteelBlue));
canvas.Children.Add(players[0].Cursor);
}
else
{
if (players.Count == 1)
{
string name = "player2";
// Default the player's colour.
SolidColorBrush playerColour = Brushes.Firebrick;
if (players[0].Name == "player2")
{
name = "player1";
// Default the player's colour.
playerColour = Brushes.SteelBlue;
}
players.Add(new Player(info, name, playerColour));
canvas.Children.Add(players[1].Cursor);
sensor.SkeletonStream.AppChoosesSkeletons = true;
sensor.SkeletonStream.ChooseSkeletons(players[0].Info.SkeletonTrackingId, players[1].Info.SkeletonTrackingId);
}
}
//re initialize timer so we are not counting players missing
playersMissing.Stop();
playersMissingCount = 0;
}
foreach (Player player in players)
{
if (player.Info.SkeletonTrackingId == info.SkeletonTrackingId)
{
playerToUse = player;
}
}
currentUserSet.Add(info.SkeletonTrackingId);
this.trackedUsers.Add(info.SkeletonTrackingId);
// Perform hit testing and look for Grip and GripRelease events
foreach (var handPointer in info.HandPointers)
{
if (handPointer.IsPrimaryForUser)
{
double xUI = handPointer.X * this.Width;
double yUI = handPointer.Y * this.Height;
double coinTop = 0;
double coinLeft = 0;
Ellipse coinElement = null;
// canvas.FindName("Quarter");
foreach (UIElement elem in canvas.Children)
{
if (elem is Ellipse && ((Ellipse)elem).Name == "Quarter")
{
coinElement = (Ellipse)elem;
coinTop = Canvas.GetTop(coinElement);
coinLeft = Canvas.GetLeft(coinElement);
}
}
if (playerToUse != null)
{
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(playerToUse.Cursor, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(playerToUse.Cursor, yUI);
}
}
if (coinElement != null)
{
if (handPointer.HandEventType != InteractionHandEventType.None)
{
if (handPointer.HandEventType == InteractionHandEventType.Grip)
{
playerToUse.Grab();
if (!entryCoin.IsGripped)
{
if (((xUI <= coinLeft + 60) && (xUI >= coinLeft - 60)) && ((yUI <= coinTop + 60) && (yUI >= coinTop - 60)))
{
entryCoin.IsGripped = true;
entryCoin.GrippedBy = playerToUse.Name;
}
}
}
else if (handPointer.HandEventType == InteractionHandEventType.GripRelease)
{
playerToUse.Release();
if ((entryCoin.IsGripped) && (entryCoin.GrippedBy == playerToUse.Name))
{
entryCoin.GrippedBy = "";
entryCoin.IsGripped = false;
//do not let the coin exceed the bounds of the screen. This must be set explicitly and not
//in reference to the top/left of the players cursor due to it still exceeding boundary
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(coinElement, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(coinElement, yUI);
}
double slotThresholdX = xUI - Canvas.GetLeft(coinbox.Slot);
double slotThresholdY = yUI - Canvas.GetTop(coinbox.Slot);
if ( (slotThresholdX >= 0 && slotThresholdX < 400) && (slotThresholdY >= 0 && slotThresholdY < 400))
{
canvas.Children.Clear();
NavigationService.Navigate(new ColourPicker(players, sensor));
playersMissing.Stop();
playersMissing.Tick -= PlayersMissing_Tick;
playersMissingCount = 0;
}
}
}
}
if (entryCoin.IsGripped && (entryCoin.GrippedBy == playerToUse.Name))
{
//do not let the coin exceed the bounds of the screen. This must be set explicitly and not
//in reference to the top/left of the players cursor due to it still exceeding boundary
if (xUI + 100 <= this.Width && xUI >= 0)
{
Canvas.SetLeft(coinElement, xUI);
}
if (yUI + 100 <= this.Height && yUI >= 0)
{
Canvas.SetTop(coinElement, yUI);
}
}
}
}
}
}
foreach (Player player in players)
{
if (!currentUserSet.Contains(player.Info.SkeletonTrackingId))
{
usersToRemove.Add(player);
}
}
foreach (Player player in usersToRemove)
{
canvas.Children.Remove(player.Cursor);
players.Remove(player);
if (players.Count == 0)
{
//start a timer that will mark the time and go back if there's no one there within 5 seconds
playersMissing.Start();
break;
}
sensor.SkeletonStream.AppChoosesSkeletons = false;
}
}
}
}
private void OnInteractionFrameReady(object o, InteractionFrameReadyEventArgs e)
{
using (var iaf = e.OpenInteractionFrame()) //dispose as soon as possible
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(user_infos);
}
foreach (var u in user_infos)
{
var userId = u.SkeletonTrackingId;
if (userId == 0)
{
continue;
}
var hands = u.HandPointers;
if (hands.Count == 0)
{
Console.WriteLine("No hands.");
}
else
{
foreach (var hand in hands)
{
double cy = (this.ActualHeight - leftCursor.Height) / 2;
double cx = (this.ActualWidth - leftCursor.Width - this.ActualWidth / 4) / 2;
var v_hand = new Vector(hand.X, hand.Y);
if (hand.HandType == InteractionHandType.Right)
{
v_hand += shoulder;
rightCursor.SetValue(Canvas.LeftProperty, cx + v_hand.X * 420);
rightCursor.SetValue(Canvas.TopProperty, cy + v_hand.Y * 420);
if (!hand.IsTracked || hand.HandEventType == InteractionHandEventType.GripRelease)
{
startR = new Vector(0, 0);
currentR = new Vector(0, 0);
grabbedRightEh = false;
startLocation = null;
startHeading = mainMap.Heading;
rightCursor.Visibility = Visibility.Visible;
rightCursor.Fill = inactive;
if (!hand.IsTracked)
{
rightCursor.Visibility = Visibility.Hidden;
}
}
else if (grabbedRightEh)
{
currentR = v_hand;
}
else if (hand.HandEventType == InteractionHandEventType.Grip)
{
startR = v_hand;
currentR = v_hand;
grabbedRightEh = true;
startLocation = mainMap.Center;
rightCursor.Fill = active;
rightCursor.Visibility = Visibility.Visible;
}
}
if (hand.HandType == InteractionHandType.Left)
{
v_hand -= shoulder;
leftCursor.SetValue(Canvas.TopProperty, cy + v_hand.Y * 420);
leftCursor.SetValue(Canvas.LeftProperty, cx + v_hand.X * 420);
if (!hand.IsTracked || hand.HandEventType == InteractionHandEventType.GripRelease)
{
startL = new Vector(0, 0);
currentL = new Vector(0, 0);
grabbedLeftEh = false;
startLocation = null;
startHeading = mainMap.Heading;
leftCursor.Visibility = Visibility.Visible;
leftCursor.Fill = inactive;
if (!hand.IsTracked)
{
leftCursor.Visibility = Visibility.Hidden;
}
}
else if (grabbedLeftEh)
{
currentL = v_hand;
}
else if (hand.HandEventType == InteractionHandEventType.Grip)
{
startL = v_hand;
currentL = v_hand;
grabbedLeftEh = true;
startLocation = mainMap.Center;
startHeading = mainMap.Heading;
startZoom = mainMap.ZoomLevel;
leftCursor.Fill = active;
leftCursor.Visibility = Visibility.Visible;
}
}
}
if (grabbedLeftEh && grabbedRightEh)
{
Vector v_start = startL - startR;
Vector v_current = currentL - currentR;
Vector v_Rmove = currentR - startR;
Vector v_Lmove = currentL - startL;
Vector v_moveTotal = (v_Rmove + v_Lmove) / 2;
double newHeading = mainMap.Heading;
double lenChange = v_current.Length - v_start.Length;
double newZoomLevel = startZoom;
// StatusBarText = mainMap.ZoomLevel.ToString();
if (zoomEnabled)
{
newZoomLevel += lenChange;
}
if (newZoomLevel < 4.0)
{
newZoomLevel = 4.0;
}
double sa = 0.0, ca = 0.0;
ca = Math.Cos(-newHeading * (Math.PI / 180));
sa = Math.Sin(-newHeading * (Math.PI / 180));
if (Math.Abs(v_current.Length) > 0.4 && rotateEnabled)
{
newHeading = startHeading + Vector.AngleBetween(v_start, v_current);
}
if (movementEnabled)
{
v_moveTotal = new Vector(ca * v_moveTotal.X - sa * v_moveTotal.Y, sa * v_moveTotal.X + ca * v_moveTotal.Y);
}
else
{
v_moveTotal = new Vector(0, 0);
}
double mapFactor = 0.17 * (Math.Pow(2, 12 - newZoomLevel));
double longitude = startLocation.Longitude - (v_moveTotal.X * mapFactor);
double latitude = startLocation.Latitude + (v_moveTotal.Y * mapFactor * 0.5);
Console.WriteLine("Adjusting view");
mainMap.SetView(new Location(latitude, longitude), newZoomLevel, newHeading);
}
}
}
}
void stream_InteractionFrameReady( object sender, InteractionFrameReadyEventArgs e )
{
using ( var interactionFrame = e.OpenInteractionFrame() ) {
if ( interactionFrame != null ) {
var userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
interactionFrame.CopyInteractionDataTo( userInfos );
List<InteractionHandPointer> hands = new List<InteractionHandPointer>();
foreach ( var user in userInfos ) {
if ( user.SkeletonTrackingId != 0 ) {
foreach ( var hand in user.HandPointers ) {
hands.Add( hand );
}
}
}
Grid.ItemsSource = hands;
}
}
}
/// <summary>
/// 手势的处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame frame = e.OpenInteractionFrame())
{
if (frame != null)
{
if (this.userInfos == null)
{
this.userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
}
frame.CopyInteractionDataTo(this.userInfos);
}
else
{
return;
}
}
/////////////
foreach (UserInfo userInfo in this.userInfos)
{
foreach (InteractionHandPointer handPointer in userInfo.HandPointers)
{
// string action = null;
switch (handPointer.HandEventType)
{
case InteractionHandEventType.Grip:
//action = "gripped";
//isDrawing.Content = "isDrawing: True";
isgrip = true;
break;
case InteractionHandEventType.GripRelease:
// action = "released";
isgrip = false;
break;
}
//if (action != null)
//{
// string handSide = "unknown";
// switch (handPointer.HandType)
// {
// case InteractionHandType.Left:
// handSide = "left";
// break;
// case InteractionHandType.Right:
// handSide = "right";
// break;
// }
// Console.WriteLine("User " + userInfo.SkeletonTrackingId + " " + action + " their " + handSide + "hand.");
//}
}
}
}
/// <summary>
/// KinectInteraction Frame Manager
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnKinectInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// get the users KinectInteraction frame
UserInfo[] userInfos = new UserInfo[InteractionFrame.UserInfoArrayLength];
using (var iaf = e.OpenInteractionFrame())
{
if (iaf == null)
{
return;
}
iaf.CopyInteractionDataTo(userInfos);
}
// For each user, treated the kinectInteraction
foreach (var userInfo in userInfos)
{
if (m_refListUsers.ContainsKey(userInfo.SkeletonTrackingId))
{
(m_refListUsers[userInfo.SkeletonTrackingId] as UserDataPointing).UpdateDataHands(userInfo);
}
}
}
void intStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame iFrame = e.OpenInteractionFrame())
{
if (iFrame != null)
{
if (userInfo == null)
{
this.userInfo = new UserInfo[6];
}
iFrame.CopyInteractionDataTo(this.userInfo);
}
}
}
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.userInfos == null)
{
return;
}
if (this.kinectAdapter.IsInInteractionFrame)
{
Debugger.Log(
0,
"warning",
"Application might have raised modal UI (e.g.: message box) while handling KinectRegion event. Applications are advised to raise modal UI via a call to System.Windows.Threading.Dispatcher.BeginInvoke instead.\n");
return;
}
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.userInfos;
}
}
if (localUserInfos != null)
{
this.kinectAdapter.BeginInteractionFrame();
try
{
bool wasProcessingAborted = false;
// Distribute routed events based on the state of all hand pointers
for (int userIndex = 0; userIndex < localUserInfos.Length; ++userIndex)
{
var user = localUserInfos[userIndex];
foreach (var handPointer in user.HandPointers)
{
this.HandleHandPointerData(timestamp, user, userIndex, handPointer);
if (localUserInfos != this.userInfos)
{
// Double-check that user info data being processed is still valid.
// Client might have invalidated it by changing the KinectSensor
// while handling a KinectRegion event.
wasProcessingAborted = true;
break;
}
}
}
if (wasProcessingAborted)
{
Debugger.Log(
0,
"warning",
"Application might have changed KinectSensor while handling KinectRegion event. Applications are advised to change KinectSensor via a call to System.Windows.Threading.Dispatcher.BeginInvoke instead.\n");
}
else
{
this.PrimaryUserTrackingId = this.kinectAdapter.ChoosePrimaryUser(timestamp, this.PrimaryUserTrackingId, this.QueryPrimaryUserTrackingIdCallback);
}
}
finally
{
this.kinectAdapter.EndInteractionFrame();
}
}
}
private void SensorInteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// Do ball movement and collisions if we have a human being tracked
if (humanNumber != -1)
{
runCollisions();
}
// Acquire data from SensorInteractionFramesReadyEventArgs and do stuff with it
UserInfo[] interactionData;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame()) //dispose as soon as possible
{
if (interactionFrame == null)
{
return;
}
interactionData = new UserInfo[InteractionFrame.UserInfoArrayLength];
interactionFrame.CopyInteractionDataTo(interactionData);
bool sawUserThisFrame = false;
foreach (UserInfo u in interactionData)
{
if (u.SkeletonTrackingId != 0)
{
if (humanNumber == -1)
{
humanNumber = u.SkeletonTrackingId;
quitTimer.Stop();
}
if (humanNumber != u.SkeletonTrackingId)
{
continue;
}
sawUserThisFrame = true;
foreach (InteractionHandPointer pointer in u.HandPointers)
{
if (!pointer.IsPrimaryForUser)
{
continue;
}
double x = pointer.X;
if (x < 0)
{
x = 0;
}
if (x > 1)
{
x = 1;
}
x = x * (screenWidth - paddle.width) + paddle.width / 2;
paddle.loc = new Point(x, paddle.loc.Y);
}
}
}
if (!sawUserThisFrame)
{
humanNumber = -1;
quitTimer.Start();
}
}
draw();
}
private void InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
// Check for a null userInfos since we may still get posted events
// from the stream after we have unregistered our event handler and
// deleted our buffers.
if (this.userInfos == null)
{
return;
}
if (this.kinectAdapter.IsInInteractionFrame)
{
Debugger.Log(
0,
"warning",
"Application might have raised modal UI (e.g.: message box) while handling KinectRegion event. Applications are advised to raise modal UI via a call to System.Windows.Threading.Dispatcher.BeginInvoke instead.\n");
return;
}
UserInfo[] localUserInfos = null;
long timestamp = 0;
using (InteractionFrame interactionFrame = e.OpenInteractionFrame())
{
if (interactionFrame != null)
{
// Copy interaction frame data so we can dispose interaction frame
// right away, even if data processing/event handling takes a while.
interactionFrame.CopyInteractionDataTo(this.userInfos);
timestamp = interactionFrame.Timestamp;
localUserInfos = this.userInfos;
}
}
if (localUserInfos != null)
{
this.kinectAdapter.BeginInteractionFrame();
try
{
bool wasProcessingAborted = false;
// Distribute routed events based on the state of all hand pointers
for (int userIndex = 0; userIndex < localUserInfos.Length; ++userIndex)
{
var user = localUserInfos[userIndex];
foreach (var handPointer in user.HandPointers)
{
this.HandleHandPointerData(timestamp, user, userIndex, handPointer);
if (localUserInfos != this.userInfos)
{
// Double-check that user info data being processed is still valid.
// Client might have invalidated it by changing the KinectSensor
// while handling a KinectRegion event.
wasProcessingAborted = true;
break;
}
}
}
if (wasProcessingAborted)
{
Debugger.Log(
0,
"warning",
"Application might have changed KinectSensor while handling KinectRegion event. Applications are advised to change KinectSensor via a call to System.Windows.Threading.Dispatcher.BeginInvoke instead.\n");
}
else
{
this.PrimaryUserTrackingId = this.kinectAdapter.ChoosePrimaryUser(timestamp, this.PrimaryUserTrackingId, this.QueryPrimaryUserTrackingIdCallback);
}
}
finally
{
this.kinectAdapter.EndInteractionFrame();
}
}
}
private void interactStream_InteractionFrameReady(object sender, InteractionFrameReadyEventArgs e)
{
using (InteractionFrame interactFrame = e.OpenInteractionFrame())
{
if (interactFrame != null && server.serverMasterOptions.kinectOptions[kinectID].trackSkeletons)
{
bool changeMade = false;
UserInfo[] tempUserInfo = new UserInfo[6];
interactFrame.CopyInteractionDataTo(tempUserInfo);
foreach (UserInfo interactionInfo in tempUserInfo)
{
foreach (InteractionHandPointer hand in interactionInfo.HandPointers)
{
if (hand.HandEventType == InteractionHandEventType.Grip)
{
for (int i = 0; i < skeletonData.actualSkeletons.Count; i++)
{
if (skeletonData.actualSkeletons[i].skeleton.TrackingId == interactionInfo.SkeletonTrackingId)
{
if (hand.HandType == InteractionHandType.Left)
{
skeletonData.actualSkeletons[i].leftHandClosed = true;
changeMade = true;
}
else if (hand.HandType == InteractionHandType.Right)
{
skeletonData.actualSkeletons[i].rightHandClosed = true;
changeMade = true;
}
break;
}
}
}
else if (hand.HandEventType == InteractionHandEventType.GripRelease)
{
for (int i = 0; i < skeletonData.actualSkeletons.Count; i++)
{
if (skeletonData.actualSkeletons[i].skeleton.TrackingId == interactionInfo.SkeletonTrackingId)
{
if (hand.HandType == InteractionHandType.Left)
{
skeletonData.actualSkeletons[i].leftHandClosed = false;
changeMade = true;
}
else if (hand.HandType == InteractionHandType.Right)
{
skeletonData.actualSkeletons[i].rightHandClosed = false;
changeMade = true;
}
break;
}
}
}
}
}
lock (skeletonData)
{
//The grab isn't going to update very often, so lets just force an update when it is actually needed
skeletonData.needsUpdate = changeMade;
}
}
}
}
