2011-07-13 17 views
6

मैं क्या Johhny ली ​​ने अपने Wii सिर पर नज़र रखने http://www.youtube.com/watch?v=Jd3-eiid-Uw&feature=player_embeddedसिर स्थिति

में किया था के लिए इसी तरह कुछ करना चाहता हूँ ट्रैक करने के लिए कैसे लेकिन मैं Kinect उपयोग करना चाहते हैं। चूंकि माइक्रोसॉफ्ट के एसडीके ने कंकाल जोड़ों को उजागर किया है, इसलिए मुझे उम्मीद थी कि मैं सिर की स्थिति पाने के लिए इसका उपयोग कर सकता हूं। समस्या यह है कि मैं इसे अपने डेस्कटॉप कंप्यूटर और इसकी मॉनिटर के साथ करना चाहता हूं। अगर मैंने अपने मॉनीटर के बगल में किनेक्ट सेंसर लगाया और डेस्क पर बैठे। काफी ज्यादा मेरे सिर और गर्दन सेंसर के लिए दृश्यमान हैं, इसलिए कंकाल ट्रैकिंग मेरे सिर की स्थिति पर पिकअप नहीं है।

क्या कोई भी किनेक्ट का उपयोग कर हेड ट्रैकिंग प्रोजेक्ट से परिचित है? पसंदीदा रूप से सी #

उत्तर

1

विंडोज एसडीके के लिए ऑफिकल किनेक्ट पर सीमाएं हैं, जो एक्सबॉक्स और एक्सडीके के लिए प्रदान किए गए मार्गदर्शन के साथ लाइन में आती हैं जिसमें आपको सक्षम होने के लिए सेंसर से 1.2 मीटर से 3.5 मीटर दूर होना चाहिए किनेक्ट सेंसर का उपयोग करने के लिए। यह सीमा वास्तव में वैकल्पिक एसडीके जैसे ओपनएनआई/नाइट पुस्तकालयों में कम हो जाती है जो आपको कंकाल के करीब कंकाल/वस्तुओं का पता लगाने की अनुमति देगी।

समस्या आपके पास स्केटलल इनपुट के साथ भी होगी, यह केवल कंकाल के अनुपात में सिर की स्थिति का पता लगाएगी, लेकिन यदि आप अपने सिर की तरफ घुमाएंगे तो नहीं। इसे प्राप्त करने के लिए आप कच्चे गहराई धाराओं और ऑब्जेक्ट मान्यता के आसपास कुछ स्मारकों का उपयोग नहीं करेंगे जो कुछ हद तक जटिल हैं।

अतीत में मैं जो सिर गतिविधियों पर नज़र करने के लिए एक वेब कैमरा का उपयोग करता है, और इस वाणिज्यिक नेट एपीआई का उपयोग किया है को प्राप्त होता है क्या आप के बाद कर रहे हैं: http://luxand.com/facesdk/index2.php

2

मैं इस आवेदन के लिए लगता है कि आप कंकाल पर नज़र रखने का उपयोग करने में सक्षम नहीं हैं माइक्रोसॉफ्ट के एसडीके या ओपनएनआई जैसे किसी भी ढांचे द्वारा प्रदान किया गया।

मैं कच्चे गहराई डेटा पर गहराई सीमा लागू करके उपयोगकर्ता के सिर को विभाजित करने का प्रस्ताव दूंगा। इसका परिणाम पृष्ठभूमि में कमी होनी चाहिए। मुझे लगता है कि पहले से ही मौजूदा तरीके हैं जो ऐसा करते हैं।

दूसरे चरण के रूप में आप खंडित उपयोगकर्ता के अंदर धुरी की तरह कुछ पसंद करते हैं। ओपनसीवी fitEllipse का उपयोग करना सबसे आसान तरीका होगा। गहराई की जानकारी के साथ संयुक्त लौटे हुए अंडाकार की प्रमुख धुरी आपको यह धुरी देती है।

यह दृष्टिकोण केवल तभी काम करता है जब अधिकांश सेगमेंट पॉइंट उपयोगकर्ता के सिर से संबंधित होते हैं। यदि आप आगे हैं तो आपको केवल सिर को विभाजित करने के लिए एक विधि के बारे में सोचना होगा। अंडाकार फिटिंग हमेशा काम करना चाहिए।

1

आपको अपने सिर की स्थिति को ट्रैक करने के लिए किनेक्ट की आवश्यकता नहीं है। फेस-ट्रैकिंग का उपयोग करके आप एक नियमित कैमरा और ओपनसीवी के साथ एक ही काम कर सकते हैं।

सरल उदाहरण यहाँ दिखाया: http://vimeo.com/19464641

वीडियो में मैं openCV मेरे चेहरे को ट्रैक करने का उपयोग कर रहा है (जो आप मुश्किल से कोने में देख सकते हैं, लेकिन लाल डॉट मेरे चेहरे स्थिति को दर्शाता है)।

+0

इसके अतिरिक्त, ओएमसीवी को इमू प्रोजेक्ट ([http://www.emgu.com/wiki/index.php/Main_Page]) के साथ सी # के माध्यम से पहुंचा जा सकता है। यहां तक ​​कि एक किनेक्ट कैप्चर विधि कॉल भी है जिसका उपयोग आप वीडियो फ्रेम प्राप्त करने और आसानी से चेहरे की पहचान करने के लिए कर सकते हैं ([http://www.emgu.com/wiki/files/2.4.2/document/html/a8b9f573-4c88-fdc0- a3b1-189096e54caa.htm]) –

-1

मैं उपयोग करने का सुझाव देता हूं: Aforge.net एक साथ माइक्रोसॉफ्ट एक्सएनए फ्रेमवर्क या सिर्फ Aforge.net के साथ। यद्यपि आपको खुद को थोड़ा सा विकास करने की आवश्यकता होगी। मैं सी # का उपयोग कर इसी तरह की चीज पर भी काम कर रहा हूं। मुझे लगता है कि आप एक पूर्ण आउट ऑफ़ द बॉक्स उदाहरण नहीं ढूंढ पाएंगे। अभी तक कोई शरीर नहीं हुआ। (अगर मैं ग़लत हूं तो मेरी गलती सुझाएं)।

1

इस तरह के विषय पर चैनलदेखें। आप कंकाल मूलभूत वीडियो पर जाएंगे। लेकिन अगर आप समय बचाना चाहते हैं तो यहां कुछ कोड है।
XAML

<Window x:Class="SkeletalTracking.MainWindow" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    Title="MainWindow" Height="600" Width="800" Loaded="Window_Loaded" 
    xmlns:my="clr-namespace:Microsoft.Samples.Kinect.WpfViewers;assembly=Microsoft.Samples.Kinect.WpfViewers" 
    Closing="Window_Closing" WindowState="Maximized">  
<Canvas Name="MainCanvas"> 
    <my:KinectColorViewer Canvas.Left="0" Canvas.Top="0" Width="640" Height="480" Name="kinectColorViewer1" 
          Kinect="{Binding ElementName=kinectSensorChooser1, Path=Kinect}" /> 
    <my:KinectSensorChooser Canvas.Left="250" Canvas.Top="380" Name="kinectSensorChooser1" Width="328" /> 
    <Image Canvas.Left="66" Canvas.Top="90" Height="87" Name="headImage" Stretch="Fill" Width="84" Source="/SkeletalTracking;component/c4f-color.png" /> 
</Canvas> 

आंतरिक कोड

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
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; 
using Coding4Fun.Kinect.Wpf; 

namespace SkeletalTracking 
{ 
/// <summary> 
/// Interaction logic for MainWindow.xaml 
/// </summary> 
public partial class MainWindow : Window 
{ 
    public MainWindow() 
    { 
     InitializeComponent(); 
    } 

    bool closing = false; 
    const int skeletonCount = 6; 
    Skeleton[] allSkeletons = new Skeleton[skeletonCount]; 

    private void Window_Loaded(object sender, RoutedEventArgs e) 
    { 
     kinectSensorChooser1.KinectSensorChanged += new DependencyPropertyChangedEventHandler(kinectSensorChooser1_KinectSensorChanged); 

    } 

    void kinectSensorChooser1_KinectSensorChanged(object sender, DependencyPropertyChangedEventArgs e) 
    { 
     KinectSensor old = (KinectSensor)e.OldValue; 

     StopKinect(old); 

     KinectSensor sensor = (KinectSensor)e.NewValue; 

     if (sensor == null) 
     { 
      return; 
     } 




     var parameters = new TransformSmoothParameters 
     { 
      Smoothing = 0.3f, 
      Correction = 0.0f, 
      Prediction = 0.0f, 
      JitterRadius = 1.0f, 
      MaxDeviationRadius = 0.5f 
     }; 
     //sensor.SkeletonStream.Enable(parameters); 

     sensor.SkeletonStream.Enable(); 

     sensor.AllFramesReady += new EventHandler<AllFramesReadyEventArgs>(sensor_AllFramesReady); 
     sensor.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30); 
     sensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30); 

     try 
     { 
      sensor.Start(); 
     } 
     catch (System.IO.IOException) 
     { 
      kinectSensorChooser1.AppConflictOccurred(); 
     } 
    } 

    void sensor_AllFramesReady(object sender, AllFramesReadyEventArgs e) 
    { 
     if (closing) 
     { 
      return; 
     } 

     //Get a skeleton 
     Skeleton first = GetFirstSkeleton(e); 

     if (first == null) 
     { 
      return; 
     } 



     //set scaled position 
     ScalePosition(headImage, first.Joints[JointType.Head]); 
     //ScalePosition(leftEllipse, first.Joints[JointType.HandLeft]); 
     //ScalePosition(rightEllipse, first.Joints[JointType.HandRight]); 

     GetCameraPoint(first, e); 

    } 

    void GetCameraPoint(Skeleton first, AllFramesReadyEventArgs e) 
    { 

     using (DepthImageFrame depth = e.OpenDepthImageFrame()) 
     { 
      if (depth == null || 
       kinectSensorChooser1.Kinect == null) 
      { 
       return; 
      } 


      //Map a joint location to a point on the depth map 
      //head 
      DepthImagePoint headDepthPoint = 
       depth.MapFromSkeletonPoint(first.Joints[JointType.Head].Position); 
      //left hand 
      DepthImagePoint leftDepthPoint = 
       depth.MapFromSkeletonPoint(first.Joints[JointType.HandLeft].Position); 
      //right hand 
      DepthImagePoint rightDepthPoint = 
       depth.MapFromSkeletonPoint(first.Joints[JointType.HandRight].Position); 


      //Map a depth point to a point on the color image 
      //head 
      ColorImagePoint headColorPoint = 
       depth.MapToColorImagePoint(headDepthPoint.X, headDepthPoint.Y, 
       ColorImageFormat.RgbResolution640x480Fps30); 
      //left hand 
      ColorImagePoint leftColorPoint = 
       depth.MapToColorImagePoint(leftDepthPoint.X, leftDepthPoint.Y, 
       ColorImageFormat.RgbResolution640x480Fps30); 
      //right hand 
      ColorImagePoint rightColorPoint = 
       depth.MapToColorImagePoint(rightDepthPoint.X, rightDepthPoint.Y, 
       ColorImageFormat.RgbResolution640x480Fps30); 


      //Set location 
      CameraPosition(headImage, headColorPoint); 
      //CameraPosition(leftEllipse, leftColorPoint); 
      //CameraPosition(rightEllipse, rightColorPoint); 
     }   
    } 


    Skeleton GetFirstSkeleton(AllFramesReadyEventArgs e) 
    { 
     using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame()) 
     { 
      if (skeletonFrameData == null) 
      { 
       return null; 
      } 


      skeletonFrameData.CopySkeletonDataTo(allSkeletons); 

      //get the first tracked skeleton 
      Skeleton first = (from s in allSkeletons 
            where s.TrackingState == SkeletonTrackingState.Tracked 
            select s).FirstOrDefault(); 

      return first; 

     } 
    } 

    private void StopKinect(KinectSensor sensor) 
    { 
     if (sensor != null) 
     { 
      if (sensor.IsRunning) 
      { 
       //stop sensor 
       sensor.Stop(); 

       //stop audio if not null 
       if (sensor.AudioSource != null) 
       { 
        sensor.AudioSource.Stop(); 
       } 


      } 
     } 
    } 

    private void CameraPosition(FrameworkElement element, ColorImagePoint point) 
    { 
     //Divide by 2 for width and height so point is right in the middle 
     // instead of in top/left corner 
     Canvas.SetLeft(element, point.X - element.Width/2); 
     Canvas.SetTop(element, point.Y - element.Height/2); 

    } 

    private void ScalePosition(FrameworkElement element, Joint joint) 
    { 
     //convert the value to X/Y 
     //Joint scaledJoint = joint.ScaleTo(1280, 720); 

     //convert & scale (.3 = means 1/3 of joint distance) 
     //Joint scaledJoint = joint.ScaleTo(1280, 720, .3f, .3f); 

     Canvas.SetLeft(element, scaledJoint.Position.X); 
     Canvas.SetTop(element, scaledJoint.Position.Y); 

    } 


    private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) 
    { 
     closing = true; 
     StopKinect(kinectSensorChooser1.Kinect); 
    } 



    } 
} 

मैं व्यक्तिगत रूप से, क्योंकि वे सब कुछ समझाने वीडियो देखने की सलाह देते हैं। आपकी परियोजना के लिए शुभकामनाएं!

संबंधित मुद्दे