मैं इस वीडियो अनुक्रम से शोर को कैसे हटा सकता हूं?

Question

हैलो मैं कुछ छवि प्रसंस्करण करने की कोशिश कर रहा हूं। मैं एक कमरे में मनुष्यों का पता लगाने के लिए माइक्रोसॉफ्ट किनेक्ट का उपयोग करता हूं।

http://www.screenr.com/h7f8

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

मुझे जितना संभव हो सके मानव को छोड़कर सबकुछ से छुटकारा पाना होगा। जब मैं क्षरण/फैलाव (एक बहुत बड़ा खिड़की आकार का उपयोग कर) करता हूं तो मैं बहुत सारे शोर से छुटकारा पा सकता हूं लेकिन मुझे आश्चर्य हुआ कि क्या अन्य विधियां हैं जिनका मैं उपयोग कर सकता हूं। विशेष रूप से वीडियो में लाल शोर क्षरण/फैलाव का उपयोग करके निकालना मुश्किल है।

कुछ नोट:

1) अगर हम जानते थे कि जब वहाँ दृश्य में कोई मनुष्य लेकिन पृष्ठभूमि घटाव हम करते हैं पूरी तरह से स्वचालित है एक बेहतर पृष्ठभूमि घटाव किया जा सकता है और यह भी काम करता है जब वहाँ में मनुष्य हैं दृश्य और यहां तक ​​कि जब कैमरा ले जाया जाता है आदि। तो यह सबसे अच्छा पृष्ठभूमि घटाव है जिसे हम अभी प्राप्त कर सकते हैं।

2) एल्गोरिदम एक एम्बेडेड सिस्टम, वास्तविक समय पर काम करेगा। तो अधिक कुशल और आसान एल्गोरिदम बेहतर है। और यह सही नहीं होना चाहिए। हालांकि जटिल सिग्नल प्रोसेसिंग तकनीकों का भी स्वागत है (शायद हम उन्हें किसी अन्य प्रोजेक्ट पर इस्तेमाल कर सकते हैं जिसे एम्बेडेड, रीयल टाइम प्रोसेसिंग की आवश्यकता नहीं है)।

3) मुझे वास्तविक कोड की आवश्यकता नहीं है। बस विचार

Answer 1

यह बहुत आसान लगता है कि आप किनेक्ट एसडीके का उपयोग कर रहे हैं। मैं गहराई मूल बातें के लिए this वीडियो का पालन होता है, और कुछ इस तरह करते हैं:

private byte[] GenerateColoredBytes(DepthImageFrame depthFrame) 
    { 

     //get the raw data from kinect with the depth for every pixel 
     short[] rawDepthData = new short[depthFrame.PixelDataLength]; 
     depthFrame.CopyPixelDataTo(rawDepthData); 

     //use depthFrame to create the image to display on-screen 
     //depthFrame contains color information for all pixels in image 
     //Height x Width x 4 (Red, Green, Blue, empty byte) 
     Byte[] pixels = new byte[depthFrame.Height * depthFrame.Width * 4]; 

     //Bgr32 - Blue, Green, Red, empty byte 
     //Bgra32 - Blue, Green, Red, transparency 
     //You must set transparency for Bgra as .NET defaults a byte to 0 = fully transparent 

     //hardcoded locations to Blue, Green, Red (BGR) index positions  
     const int BlueIndex = 0; 
     const int GreenIndex = 1; 
     const int RedIndex = 2; 


     //loop through all distances 
     //pick a RGB color based on distance 
     for (int depthIndex = 0, colorIndex = 0; 
      depthIndex < rawDepthData.Length && colorIndex < pixels.Length; 
      depthIndex++, colorIndex += 4) 
     { 
      //get the player (requires skeleton tracking enabled for values) 
      int player = rawDepthData[depthIndex] & DepthImageFrame.PlayerIndexBitmask; 

      //gets the depth value 
      int depth = rawDepthData[depthIndex] >> DepthImageFrame.PlayerIndexBitmaskWidth; 

      //.9M or 2.95' 
      if (depth <= 900) 
      { 
       //we are very close 
       pixels[colorIndex + BlueIndex] = Colors.White.B; 
       pixels[colorIndex + GreenIndex] = Colors.White.G; 
       pixels[colorIndex + RedIndex] = Colors.White.R; 
      } 
      // .9M - 2M or 2.95' - 6.56' 
      else if (depth > 900 && depth < 2000) 
      { 
       //we are a bit further away 
       pixels[colorIndex + BlueIndex] = Colors.White.B; 
       pixels[colorIndex + GreenIndex] = Colors.White.G; 
       pixels[colorIndex + RedIndex] = Colors.White.R; 
      } 
      // 2M+ or 6.56'+ 
      else if (depth > 2000) 
      { 
       //we are the farthest 
       pixels[colorIndex + BlueIndex] = Colors.White.B; 
       pixels[colorIndex + GreenIndex] = Colors.White.G; 
       pixels[colorIndex + RedIndex] = Colors.White.R; 
      } 


      ////equal coloring for monochromatic histogram 
      //byte intensity = CalculateIntensityFromDepth(depth); 
      //pixels[colorIndex + BlueIndex] = intensity; 
      //pixels[colorIndex + GreenIndex] = intensity; 
      //pixels[colorIndex + RedIndex] = intensity; 


      //Color all players "gold" 
      if (player > 0) 
      { 
       pixels[colorIndex + BlueIndex] = Colors.Gold.B; 
       pixels[colorIndex + GreenIndex] = Colors.Gold.G; 
       pixels[colorIndex + RedIndex] = Colors.Gold.R; 
      } 

     } 


     return pixels; 
    } 

यह सफेद मनुष्य के अलावा सब कुछ बदल जाता है, और मनुष्यों सोना है। उम्मीद है की यह मदद करेगा!

संपादित

मुझे पता है तुम जरूरी कोड सिर्फ विचारों नहीं करना चाहता था, तो मैं एक एल्गोरिथ्म कि गहराई पाता है, और है कि मनुष्य की राशि पाता है, और रंग सब कुछ छोड़कर सफेद लगता है कहेंगे मनुष्य। मैंने यह सब प्रदान किया है, लेकिन मुझे नहीं पता था कि क्या आप जानते थे कि क्या हो रहा था। इसके अलावा मेरे पास अंतिम कार्यक्रम की एक छवि है।

नोट: मैं परिप्रेक्ष्य के लिए दूसरा गहराई फ्रेम जोड़ा

Answer 2

मैं गलत हो सकता है (मुझे लगता है कि के लिए प्रसंस्करण के बिना वीडियो आवश्यकता होगी), लेकिन मुझे लगता है कि तुम कहते हो जाते हैं चाहते हैं रोशनी परिवर्तन से छुटकारा पाने की कोशिश कर रहे हैं।

यही कारण है कि लोगों को 'असली' वातावरण में वास्तव में मुश्किल लग रहा है।

आप कुछ लिंक के लिए this other SO question देख सकते हैं।

मैं आपके द्वारा समान विन्यास में मनुष्यों के वास्तविक समय का पता लगाता था, लेकिन मोनोकुलर दृष्टि के साथ। मेरे मामले में, वास्तव में एक अच्छा वर्णनकर्ता LBPs था, जिसका मुख्य रूप से बनावट वर्गीकरण के लिए उपयोग किया जाता है। अभ्यास में डालना काफी आसान है (पूरे वेब पर कार्यान्वयन हैं)।

एलबीपी जहां मूल रूप से ब्याज के क्षेत्र को परिभाषित करने के लिए उपयोग किया जाता है जहां आंदोलन का पता लगाया जाता है, ताकि मैं छवि के केवल हिस्से को संसाधित कर सकूं और उस शोर से छुटकारा पा सकूं।

उदाहरण के लिए यह पेपर छवियों के ग्रेस्केल सुधार के लिए एलबीपी का उपयोग करता है।

आशा है कि कुछ नए विचार लाएंगे।

Answer 3

बस मेरे दो सेंट:

आपको लगता है कि के लिए SDK का उपयोग करने से परहेज नहीं करते हैं, तो आप बहुत आसानी से केवल एक ही व्यक्ति PlayerIndexBitmask का उपयोग कर के रूप में आउटलॉ लेमर से पता चलता पिक्सल रख सकते हैं।

अब आप इसके लिए ड्राइवरों पर भरोसेमंद नहीं होना चाहते हैं और इसे एक छवि प्रसंस्करण स्तर में करना चाहते हैं। एक दृष्टिकोण जिसने हमने एक परियोजना में कोशिश की थी और बहुत अच्छा काम किया था वह समोच्च आधारित था। हमने पृष्ठभूमि घटाव से शुरू किया और फिर हमने छवि में सबसे बड़ा समोच्च पाया कि यह व्यक्ति था (आमतौर पर शोर जो कि बहुत छोटा ब्लब्स था) और हमने उस समोच्च को भर दिया और उसे रखा। आप पहले पास के रूप में किसी प्रकार का औसत फ़िल्टरिंग भी इस्तेमाल कर सकते हैं।

बेशक, यह सही नहीं है और न ही हर मामले में उपयुक्त है और शायद बहुत बेहतर तरीके हैं। लेकिन अगर मैं आपको किसी भी विचार के साथ आने में मदद करता हूं तो मैं इसे वहां फेंक रहा हूं।

Answer 4

eyesweb पर एक नज़र डालें।

यह डिजाइन करने के लिए एक मंच है जो किनेक्ट डिवाइस का समर्थन करता है और आप आउटपुट पर शोर फ़िल्टर लागू कर सकते हैं। यह multimodal सिस्टम डिज़ाइनिंग के लिए एक बहुत ही उपयोगी और सरल टूल है।