छवियों में अंतर खोज रहे हैं

हेलो, हेब्र!

लेख के आधार पर हम खेल के लिए एक बॉट लिख रहे हैं "अंतर खोजें" एक विचार कंप्यूटर विज़न एल्गोरिदम का उपयोग करके किसी दिए गए चित्र में तीसरे पक्ष की वस्तुओं की खोज को लागू करने के लिए प्रकट हुआ है।

विवरण - कटौती के तहत।

कार्य का विवरण।

तृतीय-पक्ष ऑब्जेक्ट को अलग करने की समस्या कई स्थितियों में उत्पन्न होती है - उदाहरण के लिए, वीडियो रिकॉर्डिंग कार्यों में, जब, उदाहरण के लिए, आपको अलार्म को चालू करने की आवश्यकता होती है जब एक अनधिकृत व्यक्ति रात में एक संरक्षित क्षेत्र में दिखाई देता है।

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

रूपात्मक विश्लेषण से जानकारी

बेशक, एक गणितीय परिचय के बिना नहीं कर सकता!

फ़ंक्शन को कॉल करें

f(x):X → R 

छवि। हमारी समस्या में, f(x) का मान पिक्सेल की चमक के अनुरूप होगा (0 से 255 तक)।

L सभी छवियों का रैखिक स्थान हो, F संख्यात्मक मूल्यों को ग्रहण करने वाले सभी Borel कार्यों का वर्ग हो, F _f का एक उपवर्ग हो: F _f = { F : F : F⊗f (⋅)} L}।

और अंत में, हम छवि आकृति की महत्वपूर्ण अवधारणा का परिचय देते हैं: V _f = {F : _f : F we F _f } image L. इसलिए, छवि आकृति को छवि परिवर्तनों के अधिकतम आक्रमणकारी के रूप में समझा जाता है, जो अवलोकन की शर्तों को बदलते समय, शूटिंग मापदंडों को बदलते हुए। हम छवियों को संसाधित करते समय प्रपत्र की अवधारणा का उपयोग करेंगे।

एल्गोरिथ्म

एल्गोरिथ्म का मुख्य विचार छवि के एक निश्चित अधिकतम आक्रमण को उजागर करना है, जिसके साथ हम फिर आने वाली छवियों की तुलना करेंगे। एल्गोरिथ्म का कार्यान्वयन पायथन में दिया गया है।

 from PIL import Image#    

• 1. इनपुट (रंग) छवि को ग्रे में बदलें - रंग के बजाय प्रत्येक पिक्सेल को रेंज में एक चमक मान प्रदान करें [0,255]
  

   im1 = Image.open('./img/test1.jpg')#  p1 = im1.convert('L')#      

  
  
• 2. हम छवि का एक टुकड़ा-निरंतर-स्थापन प्राप्त करते हैं। निरंतर चमक के कई क्षेत्रों में इनपुट (चिकनी) छवि को विभाजित करना आवश्यक है।
  
  g = _i ^N _{i = 1} A _i c _i (x),
  
  जहाँ _i (x) क्षेत्र A के लिए चमक मान स्थिर है।
  
  

    for i in xrange(p1.size[1]):#   for j in xrange(p1.size[0]):#    for l in xrange(len(split_map[1])): if pix[j,i] in split_map[1][l]: pix[j,i]=split_map[0][l]#    , measure[l]+=1#   - break 

  
  हम चमक मानों के अंतराल को समान अंतराल [0, ..., a_1], ..., [a_m, ..., 255] में विभाजित करते हैं। फिर हम प्रत्येक समूह के लिए औसत चमक मान पर विचार करते हैं। उसके बाद, यह केवल छवि के माध्यम से जाने और प्रत्येक पिक्सेल को उस समूह के लिए औसत चमक मान निर्दिष्ट करने के लिए रहता है जिसमें यह गिरता है। नतीजतन, हम निरंतर चमक ए ₁ , ..., ए _{एन के} कई क्षेत्रों में इनपुट छवि का एक विभाजन प्राप्त करते हैं _। समानांतर में, हम निरंतर चमक के प्रत्येक सेट की शक्ति पर विचार करते हैं (क्योंकि सेट असतत है - शक्ति पिक्सल की संख्या के बराबर है)। एल्गोरिथ्म एक उदाहरण पर कैसे काम करता है:
  

  इनपुट छवि

  
  
  

  टुकड़े टुकड़े निरंतर सन्निकटन

  
  
  परिणामस्वरूप टुकड़े टुकड़े में निरंतर सन्निकटन अभिव्यक्ति का रूप है ।
  
• 3. अब इनपुट इमेज के साथ काम करते हैं (जिस पर हमें थर्ड-पार्टी एलिमेंट का चयन करना होगा)। ऐसा करने के लिए, हमारे फ़ॉर्म पर इनपुट छवि का प्रक्षेपण खोजें:
  P _{V g} f = ∑ ^N _{i = 1} = ( _{∈ x sk fA i} f (x _sk )) ((| | A | _i ) _i c _i (x) |
  
  दूसरे शब्दों में, हम इनपुट इमेज के लिए गणना करते हैं, प्रत्येक टुकड़े के निरंतर आकार के तत्व के लिए एक सामान्य चमक मूल्य।
  

   def projector(img,split_form): p1 = img.convert('L');pix = p1.load();summ = [0]*len(split_form[2][1]); for l in xrange(len(split_form[2][1])):#     for i in xrange(p1.size[1]): for j in xrange(p1.size[0]): if split_form[3][j,i]==l: summ[l]+=pix[j,i] summ[l] = summ[l] / split_form[1][l]# ""   #         ""  for i in xrange(p1.size[1]): for j in xrange(p1.size[0]): if split_form[3][j,i]==l: pix[j,i] = summ[l] return p1 

  
  
• 4. यह बात है! जब हमने अपने फॉर्म पर प्रोजेक्शन की गणना की है, उसके बाद हमारे फॉर्म से पिक्सेल द्वारा फॉर्म पिक्सेल पर नई छवि के प्रक्षेपण को कम करना है (एक बाहरी वस्तु के बिना एक टुकड़ा-स्थिर छवि की मूल छवि)।
  
  P = जी - पी _{वी जी} एफ
  
  छवियों का अंतर वांछित वस्तु होगी।
  
  

   def differ(i1,i2): map1 = i1.load(); map2 = i2.load() for i in xrange(i1.size[1]):#   for j in xrange(i1.size[0]):#    map1[j,i] = map1[j,i] - map2[j,i] return i1 

  
  
  एक उदाहरण के रूप में, हम मूल छवि में एक बाहरी वस्तु आकर्षित करेंगे। और इसे और गहरा करें ताकि यह काफी सरल न हो (हम पंजीकरण स्थितियों में बदलाव का अनुकरण करेंगे)।
  
  
  
  स्क्रिप्ट का परिणाम:
  
  
  
  हुर्रे! हमें एक सजातीय पृष्ठभूमि पर एक तृतीय-पक्ष ऑब्जेक्ट मिला - इसे चुनना और मूल छवि में चिह्नित करना मुश्किल नहीं होगा। किसी विदेशी वस्तु का पता लगाने की समस्या हल हो गई है।
  

निष्कर्ष

निष्कर्ष: छवियों के रूपात्मक विश्लेषण के लिए एक एल्गोरिथ्म लागू किया गया था - परिवर्तित पंजीकरण शर्तों के तहत छवि में एक विदेशी वस्तु का चयन, पायथन में एक कार्यान्वयन भी प्राप्त किया गया था।

साहित्य का इस्तेमाल किया

• 1. बितुकोव यू.आई. कंप्यूटर ज्यामिति पर व्याख्यान; MAI, 2012
• 2. पाइटिव यू.पी. रूपात्मक छवि विश्लेषण के तरीके; मॉस्को, फ़िज़मैटलिट 2010

पी.एस.

मुझे बताओ कि सूत्र कैसे लिखें? मैं लेखों में लेटेक्स की सुंदरता देखना चाहता हूं!