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

np_image_A = np.array(image_A)
np_image_B = np.array(image_B)

# Set the green and red channels respectively to 0. Leaves a blue image
np_image_A[:, :, 1] = 0
np_image_A[:, :, 2] = 0
# Set the blue channels to 0.
np_image_B[:, :, 0] = 0
# Add the np images after color modification
overlay_image = cv2.add(np_image_A, np_image_B)

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

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

यहां अद्यतन कोड है जो मुझे उस समाधान के रास्ते का हिस्सा देता है जिसे मैं ढूंढ रहा हूं। इस कोड के साथ समस्या यह है कि यह छवि डी में पाया जाता है और छवि सी नहीं। मैंने कोड के इस ब्लॉक को दो बार अनिवार्य रूप से चलाने की कोशिश की , img = imageA और imageB स्विच करना, लेकिन किसी कारण से आउटपुट खराब हो गया है।

    # load image A as color image
    img = cv2.imread('1a.png')
    # load A and B as grayscale
    imgA = cv2.imread('1a.png',0)
    imgB = cv2.imread('1b.png',0)
    # invert grayscale images for subtraction
    imgA_inv = cv2.bitwise_not(imgA)
    imgB_inv = cv2.bitwise_not(imgB)
    # subtract the original (A) for the new version (B)
    diff = cv2.subtract(imgB_inv, imgA_inv)
    # split color image A into blue,green,red color channels
    b,g,r = cv2.split(img)
    # merge channels back into image, subtracting the diff from
    # the blue and green channels, leaving the shape of diff red
    res = cv2.merge((b-diff,g-diff,r))
    # display result
    cv2.imshow('Result',res)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

जो परिणाम मैं ढूंढ रहा हूं वह छवि सी है, लेकिन वर्तमान में मैं केवल संशोधित कोड के साथ छवि डी प्राप्त कर सकता हूं।

संपादित करें: उपयोग के लिए परीक्षण छवियां ए और बी यहां दी गई हैं। टेस्ट इमेज ए Test Image B

3
JuliusDariusBelosarius 9 जुलाई 2019, 20:55

1 उत्तर

सबसे बढ़िया उत्तर

आप लगभग वहां हैं, लेकिन आपको दो अलग-अलग अंतर बनाने होंगे। एक अंतर काले पिक्सल का प्रतिनिधित्व करता है जो ए में हैं लेकिन बी में नहीं हैं, और दूसरा अंतर उन काले पिक्सल का प्रतिनिधित्व करता है जो बी में हैं लेकिन ए में नहीं हैं।

नतीजा: यहां छवि विवरण दर्ज करें

import cv2
import numpy as np

# load A and B as grayscale
imgA = cv2.imread('1a.png',0)
imgB = cv2.imread('1b.png',0)
# invert grayscale images for subtraction
imgA_inv = cv2.bitwise_not(imgA)
imgB_inv = cv2.bitwise_not(imgB)

# create two diffs, A - B and B - A
diff1 = cv2.subtract(imgB_inv, imgA_inv)
diff2 = cv2.subtract(imgA_inv, imgB_inv)
# create a combined image of the two inverted 
combined = cv2.add(imgA_inv, imgB_inv)
combined_inv = cv2.bitwise_not(combined)
# convert the combined image back to rbg, 
# so that we can modify individual color channels
combined_rgb = cv2.cvtColor(combined_inv, cv2.COLOR_GRAY2RGB)
# split combined image into blue,green,red color channels
b,g,r = cv2.split(combined_rgb)
# merge channels back into image, adding the first diff to
# the red channel and the second diff to the blue channel
res = cv2.merge((b+diff2,g,r+diff1))
# display result
cv2.imshow('Result',res)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
Jack 9 जुलाई 2019, 23:50