C# Body.Where方法代码示例

        private void BodyReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
        {
            using (var frame = e.FrameReference.AcquireFrame())
            {
                if (frame != null)
                {
                    Body[] bodies = new Body[frame.BodyCount];
                    frame.GetAndRefreshBodyData(bodies);

                    Body body = bodies.Where(b => b.IsTracked).FirstOrDefault();

                    if (!_faceSource.IsTrackingIdValid)
                    {
                        if (body != null)
                        {
                            _faceSource.TrackingId = body.TrackingId;
                        }
                    }
                }
            }
        }

        private void bodyReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
        {
            using (var frame = e.FrameReference.AcquireFrame())
            {
                if (frame != null)
                {
                    Wall.Clear();

                    var bodies = new Body[frame.BodyCount];
                    frame.GetAndRefreshBodyData(bodies);

                    foreach (var body in bodies.Where(b => b.IsTracked))
                    {
                        foreach (var joint in body.Joints.Select(j => j.Value))
                        {
                            Wall.DrawPoint(joint, Brushes.White);
                        }

                        //Serializer.Save(body);
                    }
                }
            }
        }

 /// <summary>
 /// コンストラクタ
 /// </summary>
 /// <param name="frameNo"></param>
 /// <param name="dataDir"></param>
 /// <param name="timeStamp"></param>
 /// <param name="bodies"></param>
 public MotionData(int frameNo, string dataDir, DateTime timeStamp, Body[] bodies, Dictionary<ulong, PointsPair> pointPairs)
 {
     this.FrameNo = frameNo;
     this.ImagePath = Path.Combine(dataDir, frameNo.ToString() + "_color.jpg");
     this.DepthPath = Path.Combine(dataDir, frameNo.ToString() + "_depth.png");
     this.UserPath = Path.Combine(dataDir, frameNo.ToString() + "_user.png");
     this.TimeStamp = timeStamp;
     this.bodies = bodies.Where(body => body.IsTracked).Select(body => new SerializableBody(body)).ToArray();
     foreach (SerializableBody body in this.bodies)
     {
         try
         {
             body.colorSpacePoints = pointPairs[body.TrackingId].Item1;
             body.depthSpacePoints = pointPairs[body.TrackingId].Item2;
         }catch(KeyNotFoundException e){                    
             body.colorSpacePoints = null;
             body.depthSpacePoints = null;
         }
     }
 }

        /// <summary>
        /// Manages Body Tracking Id by detecting when a body moves is front of an existing body and the existing body loses it's body
        /// </summary>
        /// <param name="bodies">The Kinect bodies collection</param>
        public void TrackBodies(Body[] bodies)
        {
            bool writeOutput = false;

            //if our body count hasn't changed just return null
            //we're doing this for performance
            //this could fail if someone quickly runs in front of a existing body or if an existing player leaves quickly and a new player enters quickly at the same time
            if (bodies.Where(b => b.IsTracked).Count() == TrackedKinectBodyCount)
            {
                CleanupMissingBodies();
                CleanupHijackedBodies();
                return;
            }

            #region debug output
            #if DEBUG
            {
                if (writeOutput)
                {
                    System.Diagnostics.Debug.Print("-------------------- Tracking Bodies ---------------------- ");

                    var trackedBodies = bodies.Where(b => b.IsTracked);
                    System.Diagnostics.Debug.Print("trackedBodies Count:{0}", trackedBodies.Count());
                    var ghostBodies = bodies.Where(b => b.Joints.Count(joint => joint.Key == JointType.Head && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.Neck && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.ShoulderLeft && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.ShoulderRight && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.ElbowLeft && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.ElbowRight && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.WristLeft && joint.Value.TrackingState == TrackingState.Tracked
                                                                    || joint.Key == JointType.WristRight && joint.Value.TrackingState == TrackingState.Tracked) >= RequiredJointsTrackedCount);
                    System.Diagnostics.Debug.Print("ghostBodies Count:{0}", ghostBodies.Count());
                }

                if (writeOutput && _trackedBodiesMissing != null && _trackedBodiesMissing.Count() > 0)
                {
                    foreach (var missingBody in _trackedBodiesMissing)
                    {
                        System.Diagnostics.Debug.Print("MissingBody Output - CorrelatedPlayerId:{0}, CurrentPlayerTrackingId:{1}, BodyPosition.X:{2}, BodyPosition.Y:{3}, BodyPosition.Z{4}, TimeWentMissing{5}",
                            missingBody.CorrelationPlayerId
                            , missingBody.CurrentPlayerTrackingId
                            , missingBody.BodyPosition.X
                            , missingBody.BodyPosition.Y
                            , missingBody.BodyPosition.Z
                            , missingBody.TimeWentMissing.ToString());

                        foreach (var trackingId in missingBody.PlayerTrackingIds)
                            System.Diagnostics.Debug.Print("MissingBody Output PlayerTrackingIds for CorrelatedPlayerID: {0} - {1}", missingBody.CorrelationPlayerId, trackingId);
                    }

                }
                else if (writeOutput)
                    System.Diagnostics.Debug.Print("MissingBody Output - there are no missing bodies ");

                if (writeOutput && bodies.Any(b => b.IsTracked) && _trackedBodies != null)
                {
                    foreach (var body in bodies.Where(b => b.IsTracked))
                        System.Diagnostics.Debug.Print("Body - IsTracked:{0}, TrackingId:{1}, X:{2}, Y:{3}, Z{4}", body.IsTracked, body.TrackingId, body.Joints[BodyPositionJoint].Position.X, body.Joints[BodyPositionJoint].Position.Y, body.Joints[BodyPositionJoint].Position.Z);

                    foreach (var tb in _trackedBodies)
                    {
                        System.Diagnostics.Debug.Print("TrackedBody - BodyIsTracked:{0}, BodyTrackingId:{1}, TrackedBodyCorrelatedPlayerId:{2}, TrackedBodyCurrentPlayerTrackingId:{3}, BodyX:{4}, BodyY:{5}, BodyZ{6}, TrackedBodyX:{7}, TrackedBodyY:{8}, TrackedBodyZ{9}"
                            , tb.Value.IsTracked
                            , tb.Value.TrackingId
                            , tb.Key.CorrelationPlayerId
                            , tb.Key.CurrentPlayerTrackingId
                            , tb.Value.Joints[BodyPositionJoint].Position.X
                            , tb.Value.Joints[BodyPositionJoint].Position.Y
                            , tb.Value.Joints[BodyPositionJoint].Position.Z
                            , tb.Key.BodyPosition.X
                            , tb.Key.BodyPosition.Y
                            , tb.Key.BodyPosition.Z);

                        foreach (var trackingId in tb.Key.PlayerTrackingIds)
                            System.Diagnostics.Debug.Print("PlayerTrackingIds for CorrelatedPlayerID: {0} - {1}", tb.Key.CorrelationPlayerId, trackingId);
                    }
                }
            }
            #endif //DEBUG
            #endregion debug output

            if (bodies != null && bodies.Length > 0)
            {
                //first time in, just add bodies to TrackedBodies collection
                if (_trackedBodies.Count() == 0)
                {
                    foreach (var body in bodies)
                    {
                        var trackedBody = new TrackedBody(this)
                        {
                            BodyPosition = body.Joints[BodyPositionJoint].Position,
                        };
                        trackedBody.PlayerTrackingIds.Add(body.TrackingId);
                        _trackedBodies.Add(trackedBody, body);
                    }
                }
//.........这里部分代码省略.........

        void SendBodyData(ref UDP_PACKETS_CODER.UDP_PACKETS_ENCODER enc, Body[] bodies, int numberofplayer)
        {
            try
            {
                //UDP_PACKETS_CODER.UDP_PACKETS_ENCODER enc = new UDP_PACKETS_CODER.UDP_PACKETS_ENCODER();
                List<string> str = new List<string>();

                str.Add(bodies.Length.ToString());
                byte MoP = (byte)bodies.Length;
                enc += MoP; //MaxofPlayer

                str.Add(numberofplayer.ToString());
                byte NoP = (byte)numberofplayer;
                enc += NoP; //NumberOfPlayer

                int NumberofBody = 0;
                int NumberofJoint = 0;
                foreach (var body in bodies.Where(b => b.IsTracked))
                {

                    NumberofBody++;
                    byte NoB = (byte)body.Joints.ToArray().Length;
                    enc += NoB;

                    foreach (var joint in body.Joints)
                    {
                        //kinect関節名前書き出し
                        str.Add(joint.Value.JointType.ToString());
                        NumberofJoint++;
                        str.Add(NumberofJoint.ToString());
                        enc += this.Dimension;
                        enc += joint.Value.Position.X;
                        enc += joint.Value.Position.Y;
                        enc += joint.Value.Position.Z;
                        //追加
                        enc += body.JointOrientations[joint.Value.JointType].Orientation.X;
                        enc += body.JointOrientations[joint.Value.JointType].Orientation.Y;
                        enc += body.JointOrientations[joint.Value.JointType].Orientation.Z;
                        enc += body.JointOrientations[joint.Value.JointType].Orientation.W;
                        byte TS = (byte)joint.Value.TrackingState;
                        enc += TS;

                        #region
                        str.Add(this.Dimension.ToString());
                        str.Add(joint.Value.Position.X.ToString());
                        str.Add(joint.Value.Position.Y.ToString());
                        str.Add(joint.Value.Position.Z.ToString());
                        str.Add(body.JointOrientations[joint.Value.JointType].Orientation.X.ToString());
                        str.Add(body.JointOrientations[joint.Value.JointType].Orientation.Y.ToString());
                        str.Add(body.JointOrientations[joint.Value.JointType].Orientation.Z.ToString());
                        str.Add(body.JointOrientations[joint.Value.JointType].Orientation.W.ToString());
                        str.Add(joint.Value.TrackingState.ToString());
                        #endregion
                    }
                }

                //byte[] data = enc.data;
                //csvに保存
                #region
                if (this.IsSave)
                {

                    //string s2 = string.Join(",", s1);
                    string strdata = string.Join(",", str.ToArray());
                    this.streamWriter.WriteLine(strdata);
                    //sw.Close();
                }
                #endregion
                //CIPCに送信
                /*
                #region
                if (this.cipcMain != null)
                {
                    this.cipcMain.send(data);
                }
                #endregion
                */
            }
            catch
            {
                this.ErrorPoint(System.Reflection.MethodBase.GetCurrentMethod().ToString());
            }
        }

 //関節位置
 List<Joint> BodyPosition(Body[] bodies)
 {
     List<Joint> joints = new List<Joint>();
     //Point3f pt = new Point3f();
     int i = 0 ;
     foreach (var body in bodies.Where(b => b.IsTracked) )//
     {
         foreach (var joint in body.Joints)
         {
             if (joint.Value.JointType == JointType.SpineBase)
             {
                 //var position = this.kinect.CoordinateMapper.MapCameraPointToDepthSpace(joint.Value.Position);
                 //pt.X = joint.Value.Position.X;;
                 //pt.Y = joint.Value.Position.X;
                 //pt.Z = joint.Value.Position.X;
                 //Console.Write("hit\n");
                 joints.Add(joint.Value);
                 i++;
             }
         }
     }
     return joints;
 }

        /// <summary>
        /// ある点から一番近い人を追う
        /// </summary>
        /// <param name="bodies"></param>
        /// <param name="center"></param>
        /// <param name="closestDistance"></param>
        /// <returns></returns>
        private Body ChooseClosestBody( Body[] bodies,
            CameraSpacePoint center = new CameraSpacePoint(), float closestDistance = 2.0f )
        {
            Body closestBody = null;

            // 比較する関節位置
            var baseType = JointType.SpineBase;

            // 追跡しているBodyから選ぶ
            foreach ( var body in bodies.Where( b => b.IsTracked ) ) {
                // 比較する関節位置が追跡状態になければ対象外
                if ( body.Joints[baseType].TrackingState == TrackingState.NotTracked ) {
                    continue;
                }

                // 中心からの距離が近い人を選ぶ
                var distance = Distance( center, body.Joints[baseType].Position );
                if ( distance < closestDistance ) {
                    closestDistance = distance;
                    closestBody = body;
                }
            }

            return closestBody;
        }

        private void BodyReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
        {
            using (var frame = e.FrameReference.AcquireFrame())
            {
                if (frame != null)
                {
                    Body[] bodies = new Body[frame.BodyCount];
                    frame.GetAndRefreshBodyData(bodies);

                    Body body1 = bodies.Where(b => b.IsTracked).FirstOrDefault();
                    Body body2 = bodies.Where(b => b.IsTracked).LastOrDefault();

                    if (!_faceSource.IsTrackingIdValid)
                    {
                        if (body1 != null)
                        {
                            _faceSource.TrackingId = body1.TrackingId;
                        }
                    }
                    if (!_faceSourceSub.IsTrackingIdValid)
                    {
                        if (body2 != null)
                        {
                            if(_faceSource.TrackingId!=body2.TrackingId) _faceSourceSub.TrackingId = body2.TrackingId;
                            if (_faceSource.TrackingId != body1.TrackingId) _faceSourceSub.TrackingId = body1.TrackingId;
                        }
                    }
                    //MessageBox.Show(_faceSource.TrackingId.ToString() +"##"+ _faceSourceSub.TrackingId.ToString());
                }
            }
        }