Étape 7: Kinect Scripting
Créez un nouveau dossier dans votre dossier Scripts appelé KinectScripts. Maintenant dans ce dossier, créez deux nouveaux scripts ; un appelé BodyManger et l’autre appelé BodyView.
IMAGE 1 CI-DESSUS
BodyManager
Tout d’abord, nous avons besoin de BodyManager - cette volonté d’objet Mange la connexion du capteur Kinect et lire toutes les données de corps provenant de la Kinect.
Importer la bibliothèque de Kinect avec :
Ensuite, nous avons besoin de certains champs pour le manager pour stocker et les données et obtenir des données du capteur.
Private KinectSensor _Sensor ;
Private BodyFrameReader _Reader ;
privé corps [] _Data = null ;
Organisme public [GetData()
{
retour _Data ;
}
Bon alors maintenant dans la méthode Start nous voulons établir la connexion pour la Kinect.
void Start()
{
_Sensor = KinectSensor.GetDefault() ;
Si (_Sensor! = null)
{
_Reader = _Sensor.BodyFrameSource.OpenReader() ;
Si (! _Sensor.IsOpen)
{
_Sensor.Open() ;
}
}
}
Maintenant que la connexion est ouverte et la lecture des données, nous avons besoin de le stocker dans le tableau de corps. Nous ferons ce chaque frame du jeu, c’est pourquoi nous devons modifier la méthode Update().
Tout d’abord, nous vérifions pour voir si le _Reader a été mis en place et la connexion est terminée. Si il a nous prendrons la dernière image, le lecteur a lu dans et si ce n’est pas null, nous pouvons ensuite vérifier pour voir si les données sont là.
Maintenant, nous avons besoin d’obtenir des données relatives au corps de la Senor. Pour ce faire, nous aurons besoin créer un nouveau tableau de corps avec les données de le Sensor.BodyFrameSource.BodyCount.
À la fin, la méthode devrait ressembler à ceci :
void Update()
{
Si (_Reader! = null)
{
trame de var = _Reader.AcquireLatestFrame() ;
Si (image! = null)
{
Si (_Data == null)
{
}
}
}
}
Ensuite, nous avons besoin actualiser le flux de données du lecteur. En ajoutant le code suivant pour manipuler le cadre.
void Update()
{
Si (_Reader! = null)
{
trame de var = _Reader.AcquireLatestFrame() ;
Si (image! = null)
{
Si (_Data == null)
{
_Data = new Body[_Sensor.BodyFrameSource.BodyCount] ;
}
cadre. GetAndRefreshBodyData(_Data) ;
cadre. Dispose() ;
Frame = null ;
}
}
}
La dernière méthode dans la classe de gestionnaire de corps est OnApplicationQuit(), qui supprime le lecteur et ferme le flux de capteur, il définit à null.
Sub OnApplicationQuit()
{
Si (_Reader! = null)
{
_Reader.Dispose() ;
_Reader = null ;
}
Si (_Sensor! = null)
{
Si (_Sensor.IsOpen)
{
_Sensor.Close() ;
}
_Sensor = null ;
}
}
Vue du corps
Le Script suivant pour écrire est de tirer la structure du squelette. Il ne faut nécessairement voir le squelette pour le jeu, cependant, je vais vous montrer comment montrer suivi corps squelettique. Nous devons également les données squelettiques pour suivre les mains, dont l’État va dicter des commandes du contrôleur.
Pour cette classe de MonoBehavoir nous aurons besoin, un matériau pour dessiner l’os dans la scène de l’unité. Un gameobject pour stocker le BodyManger, pour contrôler le flux de la Kinect.
Il faut également un objet de BodyManager et un dictionnaire pour stocker les corps étant l’objet d’un suivi.
Ensuite, nous devons tracer tous les os par les deux articulations qui elles seront connectées à.
BodyView Update()
Nous devons maintenant dans la méthode Update() de l’unité vérifier si le gestionnaire de corps n’est pas null et qu’il a données.
Ensuite, tout en restant dans la méthode Update(), nous devons obtenir une quantité d’organes dans la liste des organes de suivi. Supprimez ensuite les organes inconnus.
Liste trackedIds = gcnew List () ;
foreach (var corps dans les données)
{
Si (corps == null)
{
continuer ;
}
Si (le corps. IsTracked)
{
trackedIds.Add (corps. TrackingId) ;
}
}
KnownIds la liste = new List (_Bodies.Keys) ;
Tout d’abord supprimer les organes non chaînées
foreach (ulong trackingId dans knownIds)
{
Si (! trackedIds.Contains(trackingId))
{
Destroy(_Bodies[trackingId]) ;
_Bodies.Remove(trackingId) ;
}
}
Maintenant que nous avons les clés pour les organes de suivi, nous avons besoin créer un objet de corps avec ce tracking key ID. Nous avons besoin d’écrire plus de deux méthodes. Une méthode CreateBodyObject() qui va prendre un id d’ulong et une méthode RefreashBodyObject() qui va prendre un objet Kinect.Body et un GameObject pour le corps. Nous allons utiliser ces méthodes après avoir traverser les données et trouver si les organes à l’intérieur sont suivis ou non. Si c’est l’objet d’un suivi, mais n’a pas un TrackingId, alors nous avons besoin de créer un organe avec cette TrackingID. S’il est suivi et a un TrackingId puis nous avons juste besoin de rafraîchir le corps dessiné.
foreach (var corps dans les données)
{
Si (corps == null)
{
continuer ;
}
Si (le corps. IsTracked)
{
Si (! _Bodies.ContainsKey (corps. TrackingId))
{
_Bodies [l’organe. TrackingId] = CreateBodyObject (corps. TrackingId) ;
}
RefreshBodyObject (corps, _Bodies [l’organe. TrackingId]) ;
}
}
}
CreateBodyObject()
Le CreateBodyObject prend un ID et retourne un gameobject corps. Donc il faut d’abord créer un gameobject qui stockera les données appropriées récupérées ; puis nous avons besoin d’une boucle for pour passer par chaque joint à dessiner le corps.
Pour chaque commune dans le corps, nous créons un cube et ajoutez un lineRenderer à ce cube. Le cube sera tiré à chaque joint alors que le moteur de rendu de ligne est tirés au sort pour assembler les jointures.
RefreashBodyObject()
Maintenant à écrire la méthode ResfreshBodyObject. Dans cette méthode, nous avons besoin de passer par chaque type commun possible tout comme nous l’avons fait dans la méthode CreateBodyObject. Mais cette fois nous passons dans le corpus actuel, ainsi que le cas échéant numéro de suivi donc nous n’attirons les os pour la mauvaise personne.
privé RefreshBodyObject Sub (Kinect.Body corps, bodyObject GameObject)
{
pour (jt Kinect.JointType = Kinect.JointType.SpineBase ; jt < = Kinect.JointType.ThumbRight ; jt ++)
{
}
}
À l’intérieur de cette boucle, nous avons besoin obtenir les paires clé-valeur, que nous avons fait avant dans la boucle de l’OS pour chaque articulation.
privé RefreshBodyObject Sub (Kinect.Body corps, bodyObject GameObject)
{
pour (jt Kinect.JointType = Kinect.JointType.SpineBase ; jt < = Kinect.JointType.ThumbRight ; jt ++)
{
Kinect.Joint sourceJoint = corps. Articulations [jt] ;
Kinect.Joint ? targetJoint = null ;
if(_BoneMap.ContainsKey(JT))
{
targetJoint = corps. Articulations [_BoneMap [jt]] ;
}
}
}
Il faut aussi mettre à jour la position de squelettes n’est à l’endroit précis sur l’écran. Pour ce faire, nous avons besoin d’écrire une méthode pour obtenir le Vetcor3 de la sourceJoint.
L’échelle de 10 est à agrandir le squelette, ce qui rendra plus facile à manipuler. Maintenant, nous devons pouvoir corriger la position de gameObjects.
L’étape suivante la boucle est d’obtenir le linerenderer de la bodyObject, qui était le cube, nous créons pour chaque articulation. Nous devons voir si la cible commune a une valeur. Si ce n’est nous pouvons ensuite tracer une ligne de l’articulation d’origine vers la cible.
LineRenderer lr = jointObj.GetComponent () ;
if(targetJoint.HasValue)
{
LR. SetPosition (0, jointObj.localPosition) ;
LR. SetPosition (1, GetVector3FromJoint(targetJoint.Value)) ;
}
d’autre
{
LR.Enabled = false ;
}
Formidable ! Donc nous sommes presque finis avec le dessin du squelette. Il y a un peu plus d’informations qui vous seront utile que le SDK vous donne, qui effectue le suivi de statut. Il y a trois États au choix, sur chenilles, présumée ou NotTracked. Nous pouvons avoir le moteur de rendu de ligne nous montrer l’état de suivi en changeant sa couleur. Pour ce faire nous avons besoin d’une méthode qui retourne une couleur selon l’état actuel.
Maintenant nous ajoutons une ligne supplémentaire à la boucle de la RefreachBodyObject méthode et nous avons finis.
Et c’est tout pour le dessin du squelette !
