private void kinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs args)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
//just one of the >2 hands is the active one
if (!kinectPointerPoint.Properties.IsEngaged)
{
return;
}
Point pointRelativeToKinectRegion = new Point(kinectPointerPoint.Position.X * kinectRegion.ActualWidth, kinectPointerPoint.Position.Y * kinectRegion.ActualHeight);
//CANVAS INTERACTION
if (!isMenuOpen)
{
if ((kinectPointerPoint.Properties.HandType == HandType.RIGHT && rHand == UserSettings.Instance.GESTURE_MOVE) || (kinectPointerPoint.Properties.HandType == HandType.LEFT && lHand == UserSettings.Instance.GESTURE_MOVE))
{
myCanvas.updateStrokes(pointRelativeToKinectRegion, SketchCanvas.UserAction.Move);
}
else if ((kinectPointerPoint.Properties.HandType == HandType.RIGHT && rHand == UserSettings.Instance.GESTURE_DRAW) || (kinectPointerPoint.Properties.HandType == HandType.LEFT && lHand == UserSettings.Instance.GESTURE_DRAW))
{
myCanvas.updateStrokes(pointRelativeToKinectRegion, SketchCanvas.UserAction.Draw);
}
else if ((kinectPointerPoint.Properties.HandType == HandType.RIGHT && rHand == UserSettings.Instance.GESTURE_RUBBER) || (kinectPointerPoint.Properties.HandType == HandType.LEFT && lHand == UserSettings.Instance.GESTURE_RUBBER))
{
myCanvas.updateStrokes(pointRelativeToKinectRegion, SketchCanvas.UserAction.Cancel);
}
}
}
private void kinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs args)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
if (kinectPointerPoint.Properties.IsEngaged)
{
// PointerPoints come with X/Y positions from 0.0 to 1.0
// To calculate the corresponding point in pixels, we multiple by width/height of KinectRegion
Point pointRelativeToKinectRegion = new Point(
kinectPointerPoint.Position.X * _kinectRegion.ActualWidth,
kinectPointerPoint.Position.Y * _kinectRegion.ActualHeight);
Point relativeToElement = _kinectRegion.TranslatePoint(pointRelativeToKinectRegion, _interactiveElement);
bool insideElement = (relativeToElement.X >= 0 && relativeToElement.X < _interactiveElement.ActualWidth &&
relativeToElement.Y >= 0 && relativeToElement.Y < _interactiveElement.ActualHeight);
if (insideElement)
{
if (!_isHandPointerEntered)
{
_isHandPointerEntered = true;
_handPointerEnter?.Invoke(_interactiveElement, null);
}
}
else
{
if (_isHandPointerEntered)
{
_isHandPointerEntered = false;
_handPointerLeave?.Invoke(_interactiveElement, null);
}
}
}
}
private void kinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs e)
{
if (bodies.Length != null && bodies.Length != 0)
{
handPointer = e.CurrentPoint;
}
}
//########################################################### EVENEMENTS ###########################################################
/// <summary>
/// Evénement déclenché lorsqu'un pointeur de Kinect bougé
/// </summary>
/// <remarks>Fonctionne pour 1 seul personne uniquement. Kinect ne doit en détecter qu'une seule et unique</remarks>
/// <param name="sender">L'objet déclenchant</param>
/// <param name="args">Les arguments de l'événement contenant, notamment, la position actuel du curseur</param>
void kinectCore_PointerMoved(KinectCoreWindow sender, KinectPointerEventArgs args)
{
//Un point selong l'axe X-Y (en %)
KinectPointerPoint point = args.CurrentPoint;
//Cette condition permet de contourner certain problème qui apparaissent.
//En effet, cet événement est appelé 2 fois par personne, une fois pour la main droite et une fois pour la main gauche
//On a donc 2 points de curseur par personne
//N'utiliser que la main droite permet d'éviter que les deux mains bougent le curseur
if (point.Properties.HandType == HandType.RIGHT) //On n'utilise que la main droite
{
//Calcule du diametre de la ligne
double diameter = CURSOR_DIAMETER;
diameter *= Math.Pow(point.Properties.HandReachExtent + 0.5, 3);
//Traduit les positions données par Kinect (en %) en position en pixel
double currentPosX = point.Position.X * this.cursorMoveCanvas.ActualWidth;
double currentPosY = point.Position.Y * this.cursorMoveCanvas.ActualHeight;
//Calcule la position du curseur
this.cursorPosition.PosX = currentPosX - CURSOR_DIAMETER / 2;
this.cursorPosition.PosY = currentPosY - CURSOR_DIAMETER / 2;
if (point.Properties.HandReachExtent > 0.5) //Lorsqu'on commence à appuyer, on dessine
{
if (this.lastPosition != null) //Si le dernier point appuyé existe, on peut dessiner. Sinon, on attends le prochain "tour"
{
//Ajout la ligne entre le dernier point et le point courant
Line lineToAdd = new Line()
{
//La position initiale de la ligne, tirée du dernier point
X1 = lastPosition.Value.X,
Y1 = lastPosition.Value.Y,
//La position finale de la ligne, tirée du point courant
X2 = currentPosX,
Y2 = currentPosY,
//Design de la ligne
StrokeThickness = diameter, //Le diamètre de la ligne a été calculé
Stroke = this.drawBrush, //La couleur stockée en local est utilisée
//La ligne commence et finis par un cercle.
StrokeStartLineCap = PenLineCap.Round,
StrokeEndLineCap = PenLineCap.Round
};
//On ajoute la ligne dans le canvas de dessin
this.drawCanvas.Children.Add(lineToAdd);
}
//Met à jour la dernière position du point. La ligne à dessiner se fera à partir de ce point
this.lastPosition = new Point(currentPosX, currentPosY);
}
else //Si on n'appuie pas/plus, on ne dessine pas
{
this.lastPosition = null;
}
} //FIN - main droite
} //FIN - kinectCore_PointerMoved
void kinectCore_PointerEntered(KinectCoreWindow sender, KinectPointerEventArgs args)
{
KinectPointerPoint point = args.CurrentPoint;
if (point.Properties.HandType == HandType.RIGHT)
{
}
}
private void kinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs args)
{
if (crowdController.mainBody != null)
{
if (args.CurrentPoint.Properties.BodyTrackingId == crowdController.mainBody.TrackingId)
{
kinectPointerPoint = args.CurrentPoint;
}
}
}
private void drawArea_PointerMove(object sender, KinectPointerEventArgs args)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
if (args.CurrentPoint.Properties.HandType == engagement.Draw(kinectPointerPoint.Properties.BodyTrackingId))
{
Point currentPoint = new Point(kinectPointerPoint.Position.X * drawArea.ActualWidth, kinectPointerPoint.Position.Y * drawArea.ActualHeight); // MouseControl.GetCursorPosition();
// Draw(currentPoint);
Console.WriteLine("kinect point " + drawArea.ActualWidth + " " + drawArea.ActualHeight);
}
}
/// <summary>
/// Handles kinect pointer events
/// </summary>
/// <param name="sender">the KinectCoreWindow</param>
/// <param name="args">Kinect pointer args</param>
private void kinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs args)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
if (lastTime == TimeSpan.Zero || lastTime != kinectPointerPoint.Properties.BodyTimeCounter)
{
lastTime = kinectPointerPoint.Properties.BodyTimeCounter;
mainScreen.Children.Clear();
}
RenderPointer(kinectPointerPoint.Properties.IsEngaged,
kinectPointerPoint.Position.X,
kinectPointerPoint.Position.Y,
kinectPointerPoint.Properties.BodyTrackingId,
kinectPointerPoint.Properties.HandType);
}
void kinectCore_PointerMoved(KinectCoreWindow sender, KinectPointerEventArgs args)
{
KinectPointerPoint point = args.CurrentPoint;
if (point.Properties.HandType == HandType.RIGHT)
{
//Diamètre du cercle
double diameter = 30;
diameter = diameter * Math.Pow(point.Properties.HandReachExtent + 0.5, 3);
this.posX = point.Position.X * CursorMove.ActualWidth - 15;
this.posY = point.Position.Y * CursorMove.ActualHeight - 15;
if (point.Properties.HandReachExtent > 0.5)
{
//Add line
if (lastPosition != null)
{
Line line = new Line()
{
X1 = lastPosition.Value.X, Y1 = lastPosition.Value.Y, X2 = posX + 15, Y2 = posY + 15, StrokeThickness = diameter, Stroke = this.drawBrush, StrokeStartLineCap = PenLineCap.Round, StrokeEndLineCap = PenLineCap.Round
};
Debug.WriteLine(line.Y1);
CursorMove.Children.Insert(0, line);
}
//Update the last position
lastPosition = new Point(posX + 15, posY + 15);
//Add ellipse --> DRAWING Lines is better
//Ellipse form = new Ellipse() { Height = diameter, Width = diameter, Margin = new Thickness(posX + 15 - diameter/2, posY+15-diameter/2, 0, 0), Fill = new SolidColorBrush(Colors.Red), Opacity=1f };
//CursorMove.Children.Insert(0,form);
}
else
{
lastPosition = null;
}
}
//INdique qu'on a traité le point
args.Handled = true;
}
/// <summary>
/// Handles kinect pointer events
/// </summary>
/// <param name="sender">the KinectCoreWindow</param>
/// <param name="args">Kinect pointer args</param>
private static void KinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs args)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
if (lastTime == TimeSpan.Zero || lastTime != kinectPointerPoint.Properties.BodyTimeCounter)
{
lastTime = kinectPointerPoint.Properties.BodyTimeCounter;
}
if (kinectPointerPoint.Properties.IsEngaged)
{
hand.posX = kinectPointerPoint.Position.X;
hand.posY = kinectPointerPoint.Position.Y;
engagedBodyId = kinectPointerPoint.Properties.BodyTrackingId;
engagedHandType = kinectPointerPoint.Properties.HandType;
SendPointerInfo();
}
}
private void kinectCoreWindow_PointerMoved(object sender, KinectPointerEventArgs args)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
if (lastTime == TimeSpan.Zero || lastTime != kinectPointerPoint.Properties.BodyTimeCounter)
{
lastTime = kinectPointerPoint.Properties.BodyTimeCounter;
mainScreen.Children.Clear();
//mainScreen.Children.Add(manoLeft);
mainScreen.Children.Add(imgHandRight);
}
RenderPointer(kinectPointerPoint.Position,
kinectPointerPoint.Properties.UnclampedPosition,
kinectPointerPoint.Properties.HandReachExtent,
kinectPointerPoint.Properties.BodyTimeCounter,
kinectPointerPoint.Properties.BodyTrackingId,
kinectPointerPoint.Properties.HandType);
}
//Control the Map
public void MoveTheMapPointer(KinectPointerPoint handPoiter, int numbOfPosit, Body skeleton)
{
ESRI.ArcGIS.Client.Geometry.MapPoint currentPoint = new ESRI.ArcGIS.Client.Geometry.MapPoint();
ESRI.ArcGIS.Client.Geometry.MapPoint lastPoint = new ESRI.ArcGIS.Client.Geometry.MapPoint();
double distanceX = 0;
double distanceY = 0;
double distanceZ = 0;
// real positions
double realDistX = 0;
double realDistY = 0;
double realDistZ = 0;
double distanceZoom = 0;
Positions.Add(new ContextPoint()
{
X = handPoiter.Position.X,
Y = handPoiter.Position.Y,
Time = DateTime.Now
});
if (Positions.Count > numbOfPosit)
{
Positions.RemoveAt(0);
}
lastPoint = MyMap.Extent.GetCenter();
if (Positions.Count == numbOfPosit)
{
distanceX = (Positions[Positions.Count - 2].X - Positions[Positions.Count - 1].X) * (MyMap.Resolution / 0.3);
distanceY = (Positions[Positions.Count - 2].Y - Positions[Positions.Count - 1].Y) * (MyMap.Resolution / 0.3);
}
textBox1.Text = distanceX.ToString();
textBox2.Text = distanceY.ToString();
currentPoint.X = lastPoint.X + distanceX * 100;
currentPoint.Y = lastPoint.Y - distanceY * 100;
currentPoint.SpatialReference = currentPoint.SpatialReference;
MyMap.PanTo(currentPoint);
}
/// <summary>
/// Handles kinect pointer events
/// </summary>
/// <param name="sender">the KinectCoreWindow</param>
/// <param name="args">Kinect pointer args</param>
private void kinectCoreWindow_PointerMoved(KinectCoreWindow sender, KinectPointerEventArgs args)
{
if (showKinect)
{
KinectPointerPoint kinectPointerPoint = args.CurrentPoint;
if (lastTime == 0 || lastTime != kinectPointerPoint.Timestamp)
{
lastTime = kinectPointerPoint.Timestamp;
mainScreen.Children.Clear();
}
RenderPointer(kinectPointerPoint.Properties.IsEngaged,
kinectPointerPoint.Position,
kinectPointerPoint.Properties.UnclampedPosition,
kinectPointerPoint.Properties.HandReachExtent,
kinectPointerPoint.Properties.BodyTimeCounter,
kinectPointerPoint.Properties.BodyTrackingId,
kinectPointerPoint.Properties.HandType);
}
}
/// <summary>
/// Lorsque une main/pointeur bouge sur l'écran
/// </summary>
/// <param name="sender">L'appelant</param>
/// <param name="args">Les arguments</param>
void kinectCore_PointerMoved(KinectCoreWindow sender, KinectPointerEventArgs args)
{
//Le point kinect et le point déduit sur l'interface
KinectPointerPoint currentPointerPoint = args.CurrentPoint;
Point currentPixelPoint = new Point()
{
X = (int)(currentPointerPoint.Position.X * app.kinectRegion.ActualWidth),
Y = (int)(currentPointerPoint.Position.Y * app.kinectRegion.ActualHeight)
};
if (currentPointerPoint.Properties.IsEngaged) //Vérifie le point actuellement utilisé
{
//Dans le cas ou le point est dans le canvas, on peut commencer à dessiner
if (isPointInCanvas(currentPixelPoint))
{
//Lorsqu'on est dans le canvas, on cache la main pour pouvoir dessiner
// TODO
#region dessin
//Diamètre du cercle changeant avec la pression
double diameter = 30;
diameter = diameter * Math.Pow(currentPointerPoint.Properties.HandReachExtent + 0.5, 3);
//Les deux possiion à dessiner
double posX = currentPixelPoint.X - getPointDrawCanvasPosition().X - 15;
double posY = currentPixelPoint.Y - getPointDrawCanvasPosition().Y - 15;
if (currentPointerPoint.Properties.HandReachExtent > 0.5) // Plus que 50 cm de l'épaule
{
//Add line
if (lastPoint != null)
{
Line line = new Line()
{
X1 = this.lastPoint.Value.X,
Y1 = this.lastPoint.Value.Y,
X2 = posX + 15,
Y2 = posY + 15,
StrokeThickness = diameter,
Stroke = btnColor.Background,
StrokeStartLineCap = PenLineCap.Round,
StrokeEndLineCap = PenLineCap.Round
};
drawCanvas.Children.Add(line);
}
//Update the last position
this.lastPoint = new Point(posX + 15, posY + 15);
}
else
{
//Si on est moins que 0.5cm, on met le dernier point à null pour ne plus dessiner
lastPoint = null;
}
#endregion //----Dessin
}
else //Si on est hors du champ de dessin
{
//On affiche le pointeur
}
}
//Indique que le point a bien été géré
args.Handled = true;
}
void kinectCore_PointerMoved(KinectCoreWindow sender, KinectPointerEventArgs args)
{
KinectPointerPoint point = args.CurrentPoint;
if (point.Properties.HandType == HandType.RIGHT)
{
//Diamètre du cercle
double diameter = 30;
diameter = diameter * Math.Pow(point.Properties.HandReachExtent + 0.5, 3);
this.posX = point.Position.X * CursorMove.ActualWidth - 15;
this.posY = point.Position.Y * CursorMove.ActualHeight - 15;
if (point.Properties.HandReachExtent > 0.5)
{
//Add line
if (lastPosition != null)
{
Line line = new Line()
{
X1 = lastPosition.Value.X, Y1 = lastPosition.Value.Y, X2 = posX + 15, Y2 = posY + 15, StrokeThickness = diameter, Stroke = this.drawBrush, StrokeStartLineCap = PenLineCap.Round, StrokeEndLineCap = PenLineCap.Round
};
CursorMove.Children.Insert(0, line);
}
//Update the last position
this.lastPosition = new Point(posX + 15, posY + 15);
//Add ellipse --> DRAWING Lines is better
//Ellipse form = new Ellipse() { Height = diameter, Width = diameter, Margin = new Thickness(posX + 15 - diameter/2, posY+15-diameter/2, 0, 0), Fill = new SolidColorBrush(Colors.Red), Opacity=1f };
//CursorMove.Children.Insert(0,form);
//--- TEST --- Connect with Joé
#region connectJoe
JObject position = new JObject();
position["x"] = (int)Math.Round(point.Position.X * 900, 0);
position["y"] = (int)Math.Round(point.Position.Y * 600, 0);
position["color"] = "#00A8E2";
socketIO.Emit("usrCanvasClick", position);
#endregion
//<----- FIN TEST
}
else
{
lastPosition = null;
}
}
//Changement de couleur avec la main gauche --> N'est pas une bonne façon de faire
/*
* if(point.Properties.HandType == HandType.LEFT)
* {
* //Modifie la couleur qui sera mise
* //Pour avoir toute les couleurs, transformation d'un entier en une couleur
* int intColor = (int)(0xFFFFFF * point.Position.Y); //Toute la gamme de couleur
* byte[] bytColor = BitConverter.GetBytes(intColor); //Retourne un tableau de byte correspondant
*
* Debug.WriteLine(intColor);
*
* Color colToPaint = new Color();
* colToPaint.A = 255;
* colToPaint.B = (byte)(intColor>>16 & 0xFF);
* colToPaint.G = (byte)(intColor>>8 & 0xFF);
* colToPaint.R = (byte)(intColor & 0xFF);
*
* this.btnColorChoice.Background = new SolidColorBrush(colToPaint);
*
* if (point.Properties.HandReachExtent > 0.5)
* {
* this.drawBrush = this.btnColorChoice.Background;
* storyChangedColor.Begin();
* }
* }*/
//Indique qu'on a traité le point
args.Handled = true;
}
/// <summary>
/// Méthode déclenchée ~30 fois par seconde par Kinect. On y trouve les infos mise à jour relatives à la position des mains/curseur kinect
/// </summary>
/// <param name="sender">L'objet appelant</param>
/// <param name="e">Les paramètres d'une frame de body</param>
private void MainWindow_PointerMoved(object sender, KinectPointerEventArgs e)
{
#region Méthode d'engagement "Dans l'écran"
//On définit qui a l'autorité sur le pointeur (quelle main est engagée)
//Celui dont la main est dans l'écran est engagé
if (KinectCoreWindow.KinectManualEngagedHands.Count == 0) //Personne n'est engagé
{
if (IsInScreen(e.CurrentPoint.Properties.UnclampedPosition)) //Vérifie que le point est sur l'écran
{
KinectCoreWindow.SetKinectOnePersonManualEngagement(new BodyHandPair(e.CurrentPoint.Properties.BodyTrackingId, e.CurrentPoint.Properties.HandType));
(this.Resources["CursorShow"] as Storyboard).Begin(); //On affiche le pointeur
}
else
{
this.lastPoint = null;
}
}
else //Une personne est engagée
{
//Vérifie si on doit désengager--
if (!IsInScreen(e.CurrentPoint.Properties.UnclampedPosition, 0.2f) && // si le point est en dehors de l'écran (avec une tolérance de 0.2, on peut sortir un peu de l'écran et dessiner) et que
e.CurrentPoint.Properties.IsEngaged) // celui-ci est engagé
{
KinectCoreWindow.SetKinectOnePersonManualEngagement(null);
this.lastPoint = null;
(this.Resources["CursorHide"] as Storyboard).Begin(); //On cache le pointeur
}
}
#endregion
KinectPointerPoint kinectPoint = e.CurrentPoint;
if (kinectPoint.Properties.IsEngaged) //On ne peut dessiner que si le point est engagé
{
//Vérification Dessin - Choix de couleur
switch (isPanelOpen)
{
case true: //On doit choisir la couleur
Canvas.SetLeft(colorChoicePanel, kinectPoint.Position.X * colorChoicePanel.ActualWidth - colorChoicePanel.ActualWidth);
this.UsedBrush = this.colorBrushes[this.colorBrushes.Count - 1 - (int)Math.Floor(kinectPoint.Position.X * this.colorBrushes.Count)];
this.lastPoint = null;
break;
case false: //On doit dessiner
//Diamètre du cercle changeant avec la pression
double diameter = 30;
diameter = diameter * Math.Pow(kinectPoint.Properties.HandReachExtent + 0.5, 3);
//On modifie la position du curseur
double posX = Math.Max(e.CurrentPoint.Properties.UnclampedPosition.X, 0);
posX = Math.Min(posX, 1); // Position relative 0->1 compris
posX *= this.drawCanvas.ActualWidth;
posX -= diameter / 2;
double posY = Math.Max(e.CurrentPoint.Properties.UnclampedPosition.Y, 0);
posY = Math.Min(posY, 1); // Position relative 0->1 compris
posY *= this.drawCanvas.ActualHeight;
posY -= diameter / 2;
//On modifie le curseur
this.cursorInfo.PosX = posX;
this.cursorInfo.PosY = posY;
this.cursorInfo.Diameter = diameter;
#region Dessin
//Les deux possition à dessiner
if (kinectPoint.Properties.HandReachExtent > 0.5) // Plus que 50 cm de l'épaule
{
if (lastPoint != null) //On ne dessine une ligne que si on connait le dernier point
{
//Création d'une nouvelle ligne
Line line = new Line()
{
//Premier point à partir du dernier point
X1 = this.lastPoint.Value.X + diameter / 2,
Y1 = this.lastPoint.Value.Y + diameter / 2,
//Deuxième point à partir du point courant
X2 = posX + diameter / 2,
Y2 = posY + diameter / 2,
//Design de la ligne
StrokeThickness = diameter, //Largeur de la ligne
Stroke = this.UsedBrush, //La couleur de la ligne
StrokeStartLineCap = PenLineCap.Round, //Ligne dont les deux côtés sont rond
StrokeEndLineCap = PenLineCap.Round
};
//Ajout de la ligne
drawCanvas.Children.Add(line);
}
//Update the last position
this.lastPoint = new Point(posX, posY);
}
else
{
//Si on est moins que 0.5cm, on met le dernier point à null pour ne plus dessiner
this.lastPoint = null;
}
#endregion //----Dessin
break;
}
}
}
/// <summary>
/// Méthode appelée lorsque le pointeur kinect, c'est à dire la main, a bougé.
/// </summary>
/// <param name="sender">L'objet appelant</param>
/// <param name="e">Les arguments de l'évenements</param>
private void KinectPowerPoint_PointerMoved(object sender, KinectPointerEventArgs e)
{
KinectPointerPoint point = e.CurrentPoint;
//On vérifie si on doit afficher le pointeur----
if (this.slideShow != null)
{
lock (this.pointerLock)
{
if (this.pointer != null)
{
#region Engagement "tendre le bras" avec HandReachExtent
//*
if (KinectCoreWindow.KinectManualEngagedHands.Count == 0) //On vérifie que personne n'est engagé
{
//Quand on montre du doigt, le doigt est a une certaine distance du coude. On peut l'utiliser pour activer le pointeur
if (point.Properties.HandReachExtent > FLT_POINTER_DISTANCE_ENGAGEMENT)
{
this.pointer.Visible = Office.MsoTriState.msoTrue;
KinectCoreWindow.SetKinectOnePersonManualEngagement(new BodyHandPair(point.Properties.BodyTrackingId, point.Properties.HandType));
}
}
else //Si une personne est engagée, on peut peut-être la désengager
{
if (point.Properties.IsEngaged) //Le point courant doit être engagé pour désengager
{
if (point.Properties.HandReachExtent <= FLT_POINTER_DISTANCE_DISENGAGEMENT)
{
KinectCoreWindow.SetKinectOnePersonManualEngagement(null);
this.pointer.Visible = Office.MsoTriState.msoFalse;
}
}
}
//*/
//Change la position du curseur en fonction de la position des mains
if (KinectCoreWindow.KinectManualEngagedHands.Count > 0 && point.Properties.IsEngaged && this.pointer != null)
{
PointF position = point.Properties.UnclampedPosition;
RectF size = new RectF {
X = 0, Y = 0, Width = this.Application.ActivePresentation.SlideMaster.Width, Height = this.Application.ActivePresentation.SlideMaster.Height
};
//This.pointer == null -> Problème de thread ? :/
this.pointer.Left = Math.Min(Math.Max(position.X * size.Width, size.X), size.Width - this.pointer.Width);
this.pointer.Top = Math.Min(Math.Max(position.Y * size.Height, size.Y), size.Height - this.pointer.Height);
this.pointer.Visible = Office.MsoTriState.msoTrue;
}
#endregion
}
}
#region méthode d'engagement "Dans l'écran"
//On définit qui a l'autorité sur le pointeur (quelle main est engagée)
//Celui dont la main est dans l'écran est engagé
/*if(KinectCoreWindow.KinectManualEngagedHands.Count == 0) //Personne n'est engagé
* {
* if(isInScreen(e.CurrentPoint.Properties.UnclampedPosition)) //Vérifie que le point est sur l'écran
* {
* KinectCoreWindow.SetKinectOnePersonManualEngagement(new BodyHandPair(e.CurrentPoint.Properties.BodyTrackingId, e.CurrentPoint.Properties.HandType));
* Debug.WriteLine("Engagé");
* }
* }
* else //Une personne est engagée
* {
* //Vérifie si on doit désengager--
*
* if(!isInScreen(e.CurrentPoint.Properties.UnclampedPosition) && // si le point est en dehors de l'écran et que
* e.CurrentPoint.Properties.IsEngaged) // celui-ci est engagé
* {
* KinectCoreWindow.SetKinectOnePersonManualEngagement(null);
* Debug.WriteLine("Désengagé");
* }
* }*/
#endregion
}
}