none
動作dedection只偵測一次 RRS feed

  • 问题

  • 當program完成偵測第一次坐下和站立的動作,便不會再次偵測使用者的動作。 請求教!!

    以下是program 的code

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;
    using Microsoft.Kinect;
        

    namespace FYP_Kinect
    {
        public partial class MainWindow : Window
        {
            KinectSensor _myKinect;
            private SolidColorBrush[] _skeletonBrush;
            SitPost _sitPosture;
            StandPost _standPosture;

            public MainWindow()
            {
                _sitPosture = new SitPost();
                _standPosture = new StandPost();

                _sitPosture.PostureDetected += new EventHandler(_sitPosture_PostureDetected);
                _standPosture.PostureDetected += new EventHandler(_standPosture_PostureDetected);
                InitializeComponent();
                KinectSensor.KinectSensors.StatusChanged += KinectSensors_StatusChanged;
                _skeletonBrush = new[] { Brushes.Red,
                Brushes.MintCream, Brushes.Navy, Brushes.Orange,
                Brushes.Purple, Brushes.Blue };

            }
            private void KinectSensors_StatusChanged(object sender, StatusChangedEventArgs e)
            {

                switch (e.Status)
                {

                    case KinectStatus.Connected:
                        if (this._myKinect == null)
                        {
                            this._myKinect = e.Sensor;
                            InitialStream();
                        }
                        break;
                    case KinectStatus.Disconnected:
                        UninitialStream();
                        break;
                }
            }

            private void InitialStream()
            {
                this._myKinect.ColorStream.Enable();
                this._myKinect.ColorFrameReady +=
                    Kinect_ColorFrameReady;
                this._myKinect.SkeletonStream.Enable();
                this._myKinect.SkeletonFrameReady +=
                    Kinect_SkeletonFrameReady;
                this._myKinect.Start();
            }

            private void UninitialStream()
            {
                this._myKinect.ColorFrameReady -=
                    Kinect_ColorFrameReady;
                this._myKinect.SkeletonFrameReady -=
                    Kinect_SkeletonFrameReady;
                this._myKinect.Stop();
                this._myKinect = null;
            }

            private void Kinect_ColorFrameReady(object sender, ColorImageFrameReadyEventArgs e)
            {
                using (ColorImageFrame frameData = e.OpenColorImageFrame())
                {
                    if (frameData == null)
                    {
                        return;
                    }
                    byte[] imageDataByte = new
                    byte[frameData.PixelDataLength];
                    frameData.CopyPixelDataTo(imageDataByte);
                    RBGImage.Source = BitmapSource.Create
                    (
                    frameData.Width, frameData.Height, 96, 96,
                    PixelFormats.Bgr32,
                    null,
                    imageDataByte,
                    frameData.Width * frameData.BytesPerPixel
                    );
                }
            }

            private void Kinect_SkeletonFrameReady(object sender,
              SkeletonFrameReadyEventArgs e)
            {
                Skeleton[] skeletons;
                int i = 0;
                using (SkeletonFrame frameData =
                    e.OpenSkeletonFrame())
                {
                    if (frameData == null)
                    {
                        return;
                    }
                    StickFigure.Children.Clear();
                    skeletons = new Skeleton
                    [frameData.SkeletonArrayLength];
                    frameData.CopySkeletonDataTo(skeletons);
                    int brushesIndex = 0;
                    foreach (Skeleton skeleton in skeletons)
                    {
                        if (skeleton.TrackingState ==
                            SkeletonTrackingState.Tracked)
                        {
                            Brush brush = _skeletonBrush[brushesIndex];
                            
                            DrawLine(skeleton.Joints[JointType.Head],
                                skeleton.Joints[JointType.ShoulderCenter],
                                brush);
                            DrawLine(skeleton.Joints[JointType.ShoulderCenter],
                                skeleton.Joints[JointType.Spine], brush);
                            DrawLine(skeleton.Joints[JointType.Spine],
                                skeleton.Joints[JointType.HipCenter], brush);
                            
                            DrawLine(skeleton.Joints[JointType.ShoulderCenter],
                                skeleton.Joints[JointType.ShoulderLeft], brush);
                            DrawLine(skeleton.Joints[JointType.ShoulderLeft],
                                skeleton.Joints[JointType.ElbowLeft], brush);
                            DrawLine(skeleton.Joints[JointType.ElbowLeft],
                                skeleton.Joints[JointType.WristLeft], brush);
                            DrawLine(skeleton.Joints[JointType.WristLeft],
                                skeleton.Joints[JointType.HandLeft], brush);
                             
                            DrawLine(skeleton.Joints[JointType.ShoulderCenter],
                                skeleton.Joints[JointType.ShoulderRight], brush);
                            DrawLine(skeleton.Joints[JointType.ShoulderRight],
                                skeleton.Joints[JointType.ElbowRight], brush);
                            DrawLine(skeleton.Joints[JointType.ElbowRight],
                                skeleton.Joints[JointType.WristRight], brush);
                            DrawLine(skeleton.Joints[JointType.WristRight],
                                skeleton.Joints[JointType.HandRight], brush);
                            
                            DrawLine(skeleton.Joints[JointType.HipCenter],
                                skeleton.Joints[JointType.HipLeft], brush);
                            DrawLine(skeleton.Joints[JointType.HipLeft],
                                skeleton.Joints[JointType.KneeLeft], brush);
                            DrawLine(skeleton.Joints[JointType.KneeLeft],
                                skeleton.Joints[JointType.AnkleLeft], brush);
                            DrawLine(skeleton.Joints[JointType.AnkleLeft],
                                skeleton.Joints[JointType.FootLeft], brush);
                           
                            DrawLine(skeleton.Joints[JointType.HipCenter],
                                skeleton.Joints[JointType.HipRight], brush);
                            DrawLine(skeleton.Joints[JointType.HipRight],
                                skeleton.Joints[JointType.KneeRight], brush);
                            DrawLine(skeleton.Joints[JointType.KneeRight],
                                skeleton.Joints[JointType.AnkleRight], brush);
                            DrawLine(skeleton.Joints[JointType.AnkleRight],
                                skeleton.Joints[JointType.FootRight], brush);

                          
                                _sitPosture.DetectionResult(
                                    skeleton.Joints[JointType.HipRight],
                                    skeleton.Joints[JointType.KneeRight],
                                    skeleton.Joints[JointType.HipLeft],
                                    skeleton.Joints[JointType.KneeLeft],
                                    frameData.Timestamp);

                                _standPosture.DetectionResult(
                                    skeleton.Joints[JointType.HipRight],
                                    skeleton.Joints[JointType.KneeRight],
                                    skeleton.Joints[JointType.HipLeft],
                                    skeleton.Joints[JointType.KneeLeft],
                                    frameData.Timestamp);
                         
                              
                        }   
                    }
                }

            }


            private void _sitPosture_PostureDetected(object sender, EventArgs e)
            {
               _sitPosture.PostureDetected -= new EventHandler(_sitPosture_PostureDetected);
                status.Text = ("You are sitting");
                MessageBox.Show("You are sitting");


            }

            private void _standPosture_PostureDetected(object sender, EventArgs e)
            {
               _standPosture.PostureDetected -= new EventHandler(_standPosture_PostureDetected);
                status.Text = ("You are standing");
                MessageBox.Show("You are standing");

            }
            private void DrawLine(Joint joint1, Joint joint2,
                Brush brush)
            {
                Line stickLine = new Line();
                stickLine.Stroke = brush;
                stickLine.StrokeThickness = 5;
                ColorImagePoint point1 =
                    _myKinect.MapSkeletonPointToColor(joint1.Position,
                    ColorImageFormat.RgbResolution640x480Fps30);
                stickLine.X1 = point1.X;
                stickLine.Y1 = point1.Y;
                ColorImagePoint point2 =
                    _myKinect.MapSkeletonPointToColor(joint2.Position,
                    ColorImageFormat.RgbResolution640x480Fps30);
                stickLine.X2 = point2.X;
                stickLine.Y2 = point2.Y;
                StickFigure.Children.Add(stickLine);
            }

            private void Window_Loaded_1(object sender,
                RoutedEventArgs e)
            {
                if (KinectSensor.KinectSensors.Count == 0)
                {
                    MessageBox.Show("請將 Kinect 接上電腦");
                }
                else if (KinectSensor.KinectSensors[0].Status ==
                    KinectStatus.Connected)
                {
                    this._myKinect = KinectSensor.KinectSensors[0];
                    InitialStream();
                }
            }
            private void TextBox_TextChanged_1(object sender, TextChangedEventArgs e)
            {

            }
        }
    }

    namespace FYP_Kinect
    {
        class SitPost
        {
            const int TimeThreshold = 1000;
            const double DistanceThreshold = 0.2;
            long _startTimestamp = -1;
            bool _detected = false;



            public event EventHandler PostureDetected;

            public void DetectionResult(Joint rightHipJoint, Joint rightKneeJoint,
                Joint leftHipJoint, Joint leftKneeJoint, long currentTimestamp)
            {
                if (!_detected)
                {
                    if (_startTimestamp == -1)
                        _startTimestamp = currentTimestamp;
                    if (Math.Abs(rightHipJoint.Position.Y - rightKneeJoint.Position.Y) < DistanceThreshold) 
                    {
                        if (Math.Abs(leftHipJoint.Position.Y - leftKneeJoint.Position.Y) < DistanceThreshold) 
                        {
                            if (currentTimestamp - _startTimestamp > TimeThreshold)
                            {
                                _startTimestamp = -1;
                                _detected = true;
                                PostureDetected(this, new EventArgs());
                            }

                        }
                        else _startTimestamp = -1;
                    }
                    else _startTimestamp = -1;
                }
             }
          }
       }

    namespace FYP_Kinect
    {
        class StandPost
        {
            const int TimeThresh = 1000;
            const double DistanceThreshold = 0.2;
            long _startTimestamp = -1;
            bool _detected = false;
            int x = 0;

            public event EventHandler PostureDetected;
           

            public void DetectionResult(Joint rightHipJoint, Joint rightKneeJoint,
                Joint leftHipJoint, Joint leftKneeJoint, long currentTimestamp)
            {
               if (!_detected)
               {
                    if (_startTimestamp == -1)
                        _startTimestamp = currentTimestamp;
                    if (rightHipJoint.Position.Y - rightKneeJoint.Position.Y > DistanceThreshold) 
                    {
                        if (leftHipJoint.Position.Y - leftKneeJoint.Position.Y > DistanceThreshold) 
                        {

                            if (currentTimestamp - _startTimestamp > TimeThresh)
                            {
                                _startTimestamp = -1;
                                _detected = true;
                                PostureDetected(this, new EventArgs());
                            }

                        }
                        else _startTimestamp = -1;
                    }
                    else _startTimestamp = -1;
                }
            }

        }
    }


    • 已编辑 LOGLOG 2014年12月9日 8:13
    2014年12月9日 8:11

全部回复