दो फ्रेम की तुलना के माध्यम से गति का निर्धारण करने के लिए एल्गोरिदम

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

मूल एल्गोरिथ्म

• 1. हम कैमकॉर्डर से अंतिम दो फ्रेम लेते हैं।
  
  फ़्रेम 1 और फ़्रेम 2. उदाहरण के रूप में लिए गए चित्र। दूसरे फ्रेम में "सूरज निकल आया" (चमक में वृद्धि), दीवारों और फर्श पर चमक दिखाई दी। एक लड़की मेज पर बैठी और उससे एक परछाई पड़ने लगी।
  
• 2. हम छवि को ब्लॉकों में विभाजित करते हैं और उनका औसत रंग मूल्य प्राप्त करते हैं।
  ब्लॉक में क्यों विभाजित। उदाहरण के लिए, हम 640x480 को 10x10 ब्लॉक में विभाजित करते हैं और प्रत्येक ब्लॉक से 25 पिक्सेल लेते हैं)। ~ 300,000 पिक्सेल और पुनरावृत्तियों के बजाय, हमें विश्लेषण के लिए कुल ~ 3,000 पुनरावृत्तियों और ~ 75,000 पिक्सेल मिलते हैं। इस तरह के सरलीकरण को गति निर्धारित करने की अनुमति दी जा सकती है।
  
  
• 3. परिणामी दो रंग तालिकाओं (मैट्रीस) की तुलना करें और तीसरी तालिका में प्रत्येक ब्लॉक के लिए रंग अंतर प्राप्त करें।
  इसे मूवमास्क कहते हैं
  
  
• 4. शोर से तीसरी तालिका को फ़िल्टर करें।
  यह "डेल्टा" के चयन के माध्यम से किया जाता है। उन ब्लॉकों में झंडे मिला, जो छवि में परिवर्तन के स्थान पर हैं।
  
  (1) - "डेल्टा" का उपयोग (इस उदाहरण में, 2 घटाएँ)
  (२) - तैयार मास्क में संक्रमण
  
  
  वास्तविक फ्रेम पर मास्किंग (छवि में परिवर्तन) का एक उदाहरण।
  
• 5. हम MoveMask का उपयोग करके छवि में परिवर्तनों की "ताकत" पर विचार करते हैं।
  मैं आसन्न ब्लॉकों को क्षैतिज रूप से समेट कर (फ्रीस्टैंडिंग वाले जो शोर से सफाई से बच गया था) को हटाकर एक ही एल्गोरिथ्म द्वारा मैं पहले से ही खड़ी पंक्तियों के योगों को समेट रहा हूं। परिवर्तित ब्लॉकों (पास) की प्राप्त राशि और "वहाँ आंदोलन है" ध्वज के चयनित सीमा के आधार पर, ट्रिगर कॉन्फ़िगर किया गया है।
  उदाहरण के लिए, चलिए ऐसे मूवमेक की गणना करते हैं
  
  इस उदाहरण में, परिवर्तन की "ताकत" 12. ब्लॉक के आकार के आधार पर एक ही परिवर्तन की "ताकत" अलग-अलग होगी। इसलिए, ब्लॉक और थ्रेशोल्ड का आकार (ट्रिगर को किस "बल" पर ट्रिगर किया जाता है) एक दूसरे के सापेक्ष कॉन्फ़िगर किया गया है।
  

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

यदि डेल्टा को कम करके आंका गया है (जैसा कि हमारे एल्गोरिथम के पैराग्राफ 4 में), तो यह संवेदनशीलता को बहुत प्रभावित करता है, और हमारी गति संवेदक मंद रोशनी वाली वस्तुओं पर काम करना बंद कर सकता है।

इसलिए, मैंने इस मुद्दे का हल ढूंढना शुरू कर दिया, और खुशी के लिए मुझे हब पर एक संकेत मिला (पाठ की शुरुआत में लिंक देखें)। मैं चाहता था कि एल्गोरिदम केवल वस्तुओं (पारदर्शी नहीं) पर काम करे, और लड़की से पारदर्शी छाया और दीवारों और फर्श पर प्रकाश ने हमारे गति संवेदक को काम नहीं किया।

बेहतर एल्गोरिथ्म

• 1. हम कैमकॉर्डर से अंतिम दो फ्रेम लेते हैं।
  
  फ़्रेम 1 और फ़्रेम 2
  
• 2. हम छवि को ब्लॉकों में विभाजित करते हैं और उनका औसत रंग मूल्य प्राप्त करते हैं।
  
• 3. परिणामी दो रंग तालिकाओं (मैट्रीस) की तुलना करें और तीसरी तालिका में प्रत्येक ब्लॉक के लिए रंग अंतर प्राप्त करें।
  
• 4. शोर से तीसरी तालिका को फ़िल्टर करें।
  परिणामी तालिका MoveMask को नाम दें।
  
• 5. इस चरण में, हम प्रत्येक ब्लॉक के पास औसत मानों की एक तालिका प्राप्त करते हैं (छवि देखें)।
  हमें एक बिंदु के चारों ओर एक औसत पृष्ठभूमि की तरह कुछ मिलता है।
  
  संख्या और पड़ोसी ब्लॉकों के साथ ब्लॉक को संक्षेपित किया गया है (डॉट्स के साथ चिह्नित)। आप अधिक पड़ोसी ब्लॉक ले सकते हैं। औसत मान एक संख्या के साथ एक ब्लॉक में रखा गया है। टेबल्स को AvFrame (1 और 2) कहा जाएगा।
  
• 6. हम चरण 5 में प्राप्त मूल्यों के बीच अंतर की एक तालिका बनाते हैं और इसे हमारे "डेल्टा" द्वारा फ़िल्टर करते हैं।
  इसी तरह, पहले एल्गोरिथ्म के पैरा 3 में फ्रेम के साथ। वहां चित्रण देखें।
  
  यह मुखौटा वास्तविक फ्रेम में दिखाया गया है।
  
• 7. अब हम गुणा करते हैं, जिसे "सापेक्ष सहसंबंध" कहा जाता है (शुरुआत में संकेतित लेख देखें)।
  हम एक तालिका बनाते हैं जहां कोशिकाओं में हम निम्नलिखित गणना का परिणाम लिखते हैं। फ्रेम 1 [x] [y] x AvFrame2 [x] [y] - फ्रेम 2 [x] [y] x AvFrame1 [x] [y] | फिर से हम अपने "डेल्टा" के साथ फ़िल्टर करते हैं।
  यानी हम एक ही ब्लॉक में औसत मान से पहले फ्रेम से ब्लॉक का रंग गुणा करते हैं, लेकिन दूसरा फ्रेम, इसी तरह दूसरे फ्रेम के ब्लॉक का रंग पहले के औसत से और अंतर पाते हैं।
  
  यह मास्क असली फ्रेम पर है।
  
• 8. अब हम पी। 6 और पी 7 से तालिकाओं को पार करते हैं।
  मैं परिणामी तालिका में अंकगणित माध्य लगाता हूं (चलो इसे मास्कस्किल्टर कहते हैं) केवल उन कोशिकाओं में जो दोनों तालिकाओं में सकारात्मक हैं।
  
  हमें ऐसी तस्वीर मिलती है
  
• 9. हम MaskFilter फिल्टर के साथ MoveMask को फ़िल्टर करते हैं।
  हम मूवमस्क में केवल उन ब्लॉकों को छोड़ते हैं जो एक ही स्थिति में (या एक तरफ) मास्कस्किल्टर में मौजूद हैं।
  
  छवि पर फ़िल्टर किए गए MoveMask। पहले एल्गोरिथ्म के पैरा 4 के साथ तुलना करें।
  
• 10. इसके अतिरिक्त (वैकल्पिक), आप ऐसे ब्लॉक को हटाकर MoveMask को भी फ़िल्टर कर सकते हैं जिनके कुछ पड़ोसी हैं (उदाहरण के लिए, 4 से कम)।
  
  मास्क का अंतिम रूप।
  
• 11. और अंत में, हम समाप्त MoveMask तालिका का उपयोग करके परिवर्तनों की "ताकत" पर विचार करते हैं।
  पहले एल्गोरिथ्म के पैरा 5 देखें।
  
  

इस एल्गोरिथ्म में, मूस्कफिल्टर फिल्टर के साथ मूवमस्क को फ़िल्टर करते हुए, हम मूवमस्क से अधिकांश ब्लॉकों को हटाते हैं जो एक छाया या चमक से ट्रिगर होते हैं। सेंसर के गलत संचालन को दोगुना से अधिक कम करना संभव है।
कमियों में से, "डेल्टास" और प्रोग्रामिंग और ट्यूनिंग एल्गोरिथम की जटिलता की एक बड़ी संख्या।


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

एल्गोरिथ्म को और कैसे बेहतर बनाया जा सकता है?

हो सकता है कि अगर आप RGB को HSV में बदल दें और बिना ब्राइटनेस चैनल के काम करने की कोशिश करें, तो आप एल्गोरिथ्म की सटीकता बढ़ा सकते हैं। हाथ अभी जांच के लिए नहीं आए हैं।

मुझे आशा है कि मेरा अनुभव और एल्गोरिथम का यह वर्णन किसी के लिए उपयोगी है। और अगर आपके पास पूरक करने के लिए कुछ है, सही है, तो सुझाव दें - मुझे सुनने में खुशी होगी।