छवि में रिक्त क्षेत्र ढूंढना

Question

यह प्रश्न कुछ हद तक भाषा-अज्ञेयवादी है, लेकिन मेरी पसंद का टूल एक सुस्त सरणी होता है।

क्या मैं कर रहा हूँ जनहित याचिका के माध्यम से दो छवियों के अंतर ले जा रहा है:

img = ImageChops.difference(img1, img2) 

और मैं आयताकार क्षेत्रों है कि एक से दूसरे तस्वीर से परिवर्तन शामिल होने लगाना चाहते हैं। बेशक .getbbox() विधि में बनाया गया है, लेकिन यदि परिवर्तन वाले दो क्षेत्र हैं तो यह एक क्षेत्र से दूसरे क्षेत्र में एक बॉक्स लौटाएगा, और यदि प्रत्येक कोने में केवल 1 पिक्सेल परिवर्तन हैं तो यह पूरी छवि वापस कर देगा।

______________________ 
|o   ooo | 
|  oooo ooo | 
|  o    | 
|  o o   | 
|     | 
|  oo  o  | 
| o o  ooo | 
|  oo  ooooo | 
|    ooo | 
|    o  | 
|____________________| 

मैं प्रत्येक गैर शून्य क्षेत्र के लिए सीमांकन बॉक्स युक्त 4x4-tuples प्राप्त करना चाहते हैं:

उदाहरण के लिए निम्नलिखित जहां o एक गैर शून्य पिक्सेल है पर विचार करें।

oooo 
o 
o o 

संरचना के किनारे मामले के लिए, मैं बहुत चिंतित हैं कि कैसे संभाला है नहीं कर रहा हूँ - या तो दोनों वर्गों अलग या एक साथ हो रही है, क्योंकि उल्टे-एल आकार की सीमा पूरी तरह से एक की सीमा से ओवरलैप होगा पिक्सेल।

मैंने कभी भी छवि प्रसंस्करण के साथ यह कुछ भी नहीं किया है, इसलिए मैं वास्तव में कुछ भी लिखने से पहले कुछ इनपुट प्राप्त करना चाहता था (और यदि मॉड्यूल में पहले से मौजूद तरीके हैं जो मैं पहले से उपयोग कर रहा हूं, तो मैं उनका स्वागत करता हूं!) ।

मेरे psuedocode-ish संस्करण कुछ इस तरह चला जाता है:

for line in image: 
    started = False 
    for pixel in line: 
     if pixel and not started: 
     started = True 
     save start coords 
     elif started and not pixel: 
     started = False 
     save end coords (x - 1 of course) 

यह मैं निर्देशांक की एक सूची देना चाहिए, लेकिन फिर मैं निर्धारित करने के लिए क्षेत्रों सन्निहित हैं। मैं ग्राफ-प्रकार की खोज के साथ ऐसा कर सकता हूं? (हमने पिछले सेमेस्टर में एल्गोरिदम में बहुत सारे डीएफएस और बीएफएस किए थे) बेशक मुझे लगता है कि मैं इसके बजाय/पिछले पिछले लूप के साथ ऐसा कर सकता हूं?

मैं इसे "बड़ी" छवियों पर नहीं करूँगा - उन्हें वेबकैम से खींचा जाता है और सबसे अच्छा मैं वर्तमान में 640x480 करता हूं। अधिकतर मैं 720 पी या 1080 पी कर रहा हूं, लेकिन भविष्य में यह काफी दूर है कि यह वास्तविक चिंता नहीं है।

तो मेरा प्रश्न है: क्या मैं सही रास्ते पर चला गया हूं, या क्या मैं रास्ता बंद कर रहा हूं? और अधिक महत्वपूर्ण, क्या कोई अंतर्निहित कार्य है जो मुझे पहिया को फिर से आविष्कार करने से रोकता है? और आखिरकार, क्या कोई अच्छा संसाधन है जो मुझे देखना चाहिए (ट्यूटोरियल, कागजात, इत्यादि) जो यहां मदद करेंगे?

धन्यवाद!

Answer 1

मेरा मानना ​​है कि scipy's ndimage module में आपकी हर चीज है ...

[[1]] 
[[1 1 1] 
[1 1 1]] 
[[1 1 1 1] 
[1 0 0 0] 
[1 0 0 1]] 
[[1]] 
[[0 1 1 0] 
[1 0 0 1] 
[0 1 1 0]] 
[[0 0 1 0 0] 
[0 1 1 1 0] 
[1 1 1 1 1] 
[0 1 1 1 0] 
[0 0 1 0 0]] 

ध्यान दें कि "object_slices" क्या आप मूल रूप से करने के लिए कहा, यदि आप वास्तविक indicies की जरूरत मूल रूप से कर रहे हैं:

यहाँ एक त्वरित उदाहरण

import numpy as np 
import scipy as sp 
import scipy.ndimage.morphology 

# The array you gave above 
data = np.array( 
     [ 
      [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 
      [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], 
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 
     ]) 


# Fill holes to make sure we get nice clusters 
filled = sp.ndimage.morphology.binary_fill_holes(data) 

# Now seperate each group of contigous ones into a distinct value 
# This will be an array of values from 1 - num_objects, with zeros 
# outside of any contigous object 
objects, num_objects = sp.ndimage.label(filled) 

# Now return a list of slices around each object 
# (This is effectively the tuple that you wanted) 
object_slices = sp.ndimage.find_objects(objects) 

# Just to illustrate using the object_slices 
for obj_slice in object_slices: 
    print data[obj_slice] 

यह आउटपुट है।

संपादित करें: बस का कहना है कि बावजूद इसे ठीक से

[[1 1 1 1] 
[1 0 0 0] 
[1 0 0 1]] 

के किनारे मामले को संभालने के लिए प्रदर्शित होने के लिए चाहते थे यह वास्तव में ऐसा नहीं (इस प्रकार अतिरिक्त अकेला [[1]])। आप यह देख सकते हैं यदि आप "वस्तुओं" सरणी प्रिंट आउट और वस्तुओं 3 & 4.

[[1 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 0 0 0 0] 
[0 0 0 0 0 0 3 3 3 3 0 0 0 2 2 2 0 0 0 0] 
[0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0] 
[0 0 0 0 0 0 3 0 0 4 0 0 0 0 0 0 0 0 0 0] 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 
[0 0 0 0 0 5 5 0 0 0 0 0 0 0 6 0 0 0 0 0] 
[0 0 0 0 5 5 5 5 0 0 0 0 0 6 6 6 0 0 0 0] 
[0 0 0 0 0 5 5 0 0 0 0 0 6 6 6 6 6 0 0 0] 
[0 0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 0 0 0 0] 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0 0 0 0 0]] 

आशा है कि मदद करता है पर एक नज़र डालें!

[1]

Answer 2

आप छवि में जुड़े घटक ढूंढ सकते हैं और फिर इन घटकों के बाध्यकारी बक्से निर्धारित कर सकते हैं।

Answer 3

एक क्लस्टरिंग पैकेज (ie this) अधिकांश काम (कनेक्ट पिक्सेल ढूंढने) में सक्षम होना चाहिए। क्लस्टर के लिए बाउंडिंग बॉक्स ढूंढना तब छोटा होता है।