2012-07-26 20 views
39

मुझे एक समस्या है। मेरी कंपनी ने मुझे एक बहुत ही उबाऊ काम दिया है। हमारे पास संवाद बॉक्स के दो डेटाबेस हैं। इन डेटाबेसों में से एक में भयानक गुणवत्ता की छवियां हैं, अन्य बहुत ही उच्च गुणवत्ता।उच्च गुणवत्ता और निम्न गुणवत्ता, पिक्सेल वाली छवियों के बीच मिलान ढूंढना - क्या यह संभव है? कैसे?

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

मुझे सभी बुरी छवियों के माध्यम से मैन्युअल रूप से कार्य करने और उन्हें अच्छी छवियों से मिलान करने के साथ काम किया गया है।

क्या इस प्रक्रिया को किसी भी डिग्री में स्वचालित करना संभव होगा?

Good quality image

Bad Quality image

तो मैं वर्तमान में सी # में एक प्रोग्राम लिखने के लिए डेटाबेस से इन तस्वीरों को खींचने के लिए कोशिश कर रहा हूँ, चक्र: यहाँ दो संवाद बक्से का एक उदाहरण (बेतरतीब ढंग से गूगल छवियों से खींच लिया है) उनके माध्यम से, आम आकार वाले लोगों को ढूंढें, और उनके आईडी आईडी वापस करें। यहां मेरे सबसे अच्छे विकल्प क्या हैं?

+1

क्या फ़ाइल प्रारूप? – EkoostikMartin

+3

Auwtch .. उस कार्य के साथ शुभकामनाएँ। मैंने एक बार चुनौती के रूप में इस तरह कुछ प्रोग्रामिंग करने की कोशिश की। चुनौती विफल: डी वे कुछ बहुत कठिन एल्गोरिदम हैं। – Matthias

+0

फ़ाइल प्रारूप jpg, png, gif हो सकता है ...जो कुछ भी आप पसंद करते हैं; मैं तुलनात्मक रूप से तुलना से पहले रूपांतरित कर सकते हैं। मूल रूप से वे पीएनजी हैं :) –

उत्तर

29

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

badness := 0.0 
For x, y over the entire image: 
    r, g, b := color at x,y in image 1 
    R, G, B := color at x,y in image 2 
    badness += (r-R)*(r-R) + (g-G)*(g-G) + (b-B)*(b-B) 
badness /= (image width) * (image height) 

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


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

विचार quad-tree बनाने का विचार है जहां प्रत्येक नोड उस क्षेत्र के औसत आरजीबी मानों का प्रतिनिधित्व करता है जो नोड का प्रतिनिधित्व करता है। तो एक 4x4 छवि में आरजीबी मूल्यों के साथ रूट नोड होगा जिसमें छवि के औसत आरजीबी मूल्य के बराबर होगा, उसके बच्चों के पास उनके संबंधित 2x2 क्षेत्रों के औसत आरजीबी मूल्य का प्रतिनिधित्व करने वाले आरजीबी मूल्य होंगे, और उनके बच्चे व्यक्तिगत पिक्सेल का प्रतिनिधित्व करेंगे। (व्यावहारिक रूप से यह 16x16 के क्षेत्र से गहराई से नहीं जाना एक अच्छा विचार है, उस बिंदु पर आपको केवल व्यक्तिगत पिक्सेल की तुलना करना शुरू करना चाहिए।)

छवियों की तुलना करना शुरू करने से पहले आपको एक बुरेपन सीमा पर निर्णय लेने की भी आवश्यकता होगी । आप इस सीमा से ऊपर की किसी भी विश्वसनीय सटीकता के साथ बैडनेस की गणना नहीं करेंगे, इसलिए यह मूल रूप से उस सीमा है जिस पर आप एक छवि को 'मैच नहीं' के रूप में लेबल करने के इच्छुक हैं।

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

यदि थ्रेसहोल्ड परीक्षण एनएक्सएन छवि पर गुजरता है, तो बस अगले स्तर पर नीचे जाएं और इसकी तुलना करें जैसे यह 2nx2n छवि थी। एक बार जब आप पर्याप्त कम हो जाए तो बस व्यक्तिगत पिक्सेल की तुलना करें। छवियों के आपके कॉर्पस के आधार पर यह आपको कई तुलनाओं को छोड़ने की अनुमति दे सकता है।

+1

सादगी के लिए यह पसंद है, यह मूल रूप से "बी से मिलान पिक्सेल से पिक्सेल कितना करीब है" सिवाय इसके कि आपको छवियों को स्केल करने की आवश्यकता हो सकती है ताकि वे आयामों से मेल खा सकें – Charleh

+0

यह बहुत अक्षम होगा। यदि 10,000 छवियां हैं तो यह पूरी छवियों की 100 मिलियन तुलना है। – MikeKulls

+0

@ माइककुल्स क्या आपने पोस्ट किए गए संपादन को पढ़ा था? पूरा बिंदु यह था कि आप पूरी छवियों की तुलना नहीं करते हैं। –

1

आईएमएचओ, सर्वोत्तम समाधान दोनों छवियों को धुंधला करना है और बाद में शीर्ष के (के = 5 हो सकता है?) विकल्प प्राप्त करने के लिए कुछ समानता माप (सहसंबंध/आपसी जानकारी आदि) का उपयोग करना है।

5

Here's a topic एल्गोरिदम के साथ छवि समानता पर चर्चा, पहले से ही OpenCV लाइब्रेरी में लागू किया गया है। आपको अपने सी # एप्लिकेशन में निम्न-स्तर के कार्यों को आयात करने में कोई समस्या नहीं होनी चाहिए।

+0

आप सही हैं, ओपनसीवी यहां सबसे अच्छा विकल्प है, लेकिन सी # में इसका उपयोग गैर-तुच्छ होगा। यदि पोस्टर में सी ++ का उपयोग करने का विकल्प है, तो मुझे आपका जवाब सबसे अच्छा लगता है। – EkoostikMartin

+0

@EkoostikMartin आप EmguCV का उपयोग कर सकते हैं जो ओपनसीवी – Aliostad

+0

के लिए सी ~ रैपर है, मैं सी ++ का उपयोग करने के प्रतिकूल नहीं होगा ... हालांकि मुझे इसे सीखना होगा; यह दिलचस्प लगता है :-)। प्रतिक्रियाओं के लिए धन्यवाद! –

0

आप एक ब्लॉक मिलान एल्गोरिथ्म की कोशिश कर सकते हैं, हालांकि मुझे यकीन है कि अपने विशिष्ट समस्या के खिलाफ इसका सटीक प्रभावशीलता नहीं कर रहा हूँ - http://scien.stanford.edu/pages/labsite/2001/ee368/projects2001/dropbox/project17/block.html - http://www.aforgenet.com/framework/docs/html/05d0ab7d-a1ae-7ea5-9f7b-a966c7824669.htm

यहां तक ​​कि अगर यह काम नहीं करता, तब भी आप बाहर Aforge.net की जाँच करनी चाहिए पुस्तकालय। वहां कई टूल हैं (ऊपर से ब्लॉक मिलान सहित) जो इस प्रक्रिया में आपकी मदद कर सकते हैं - http://www.aforgenet.com/

1

यदि आप छवि से समोच्च निकालें, तो आप छवियों का एक बहुत अच्छा मिलान प्राप्त करने के लिए आकार कॉन्टेक्स्ट का उपयोग कर सकते हैं।

ShapeContext इस सटीक बातों के लिए निर्माण

ShapeContext कार्यान्वयन लिंक (आपसी आकार के आधार पर छवियों की तुलना) है: Original publication A goot ppt on the subject CodeProject page about ShapeContext

* आप कुछ "समोच्च निष्कर्षण" तकनीक की कोशिश की जरूरत हो सकती थ्रेसहोल्ड या फोरियर ट्रांसफॉर्म की तरह, या इस CodeProject page about contour extraction

अच्छी किस्मत पर एक नज़र डालें।

0

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

4

चूंकि यह एक-एक नौकरी है, इसलिए मैं एक स्क्रिप्ट के साथ करूँगा (अपनी पसंदीदा भाषा चुनें; मैं शायद पर्ल चुनूंगा) और ImageMagick। आप स्क्रिप्ट के समान ही पूरा करने के लिए सी # का उपयोग कर सकते हैं, हालांकि अधिक कोड के साथ। बस कमांड लाइन यूटिलिटीज को कॉल करें और परिणामी आउटपुट को पार्स करें।

स्क्रिप्ट एक जोड़ी की जाँच करने के समानता के बारे में 10 लाइनों होगा के लिए इस प्रकार है:

पहले identify साथ आकारों को प्राप्त और पहलू अनुपात की जांच लगभग एक ही। यदि नहीं, कोई मैच नहीं। यदि ऐसा है, तो बड़ी छवि को convert के साथ छोटे आकार के पैमाने पर स्केल करें। ज्ञात समकक्ष छवियों में सबसे समानता उत्पन्न करने वाले व्यक्ति को खोजने के लिए आपको filter विकल्पों के साथ थोड़ा पहले प्रयोग करना चाहिए। उनमें से नौ उपलब्ध हैं।

फिर समानता मीट्रिक उत्पन्न करने के लिए compare फ़ंक्शन का उपयोग करें। तुलना अनुवाद और फसल से निपटने के लिए पर्याप्त स्मार्ट है। एक समानता सीमा खोजने के लिए प्रयोग जो बहुत अधिक झूठी सकारात्मक प्रदान नहीं करता है।

0

जंगली का जवाब चलाना बहुत करीब है। आप यहां क्या कर रहे हैं प्रत्येक छवि, या पीएसएनआर के लिए शोर अनुपात में पीक सिग्नल की गणना कर रहा है। आपके मामले में आपको वास्तव में केवल मीन स्क्वायर त्रुटि की आवश्यकता होती है, लेकिन इसके वर्ग का घटक छवियों के बीच अंतर की गणना करने में एक बड़ा सौदा करने में मदद करता है।

PSNR Reference

आपका कोड दिखना चाहिए:

sum = 0.0 
for(imageHeight){ 
    for(imageWidth){ 
    errorR = firstImage(r,x,y) - secondImage(r,x,y) 
    errorG = firstImage(g,x,y) - secondImage(g,x,y) 
    errorB = firstImage(b,x,y) - secondImage(b,x,y) 
    totalError = square(errorR) + square(errorG) + square(errorB) 
    } 
    sum += totalError 
} 
meanSquaredError = (sum/(imageHeight * imageWidth))/3 
6

Commercial TinEye API एक बहुत अच्छा विकल्प है।

मैंने पिछले और छवि प्रसंस्करण प्रौद्योगिकी में छवि मिलान कार्यक्रमों को आजकल अद्भुत बना दिया है, यह बहुत उन्नत है।

ps यहाँ है, जहां उन दो यादृच्छिक तस्वीरें आप गूगल से खींचा से आया था:http://www.tineye.com/search/1ec9ebbf1b5b3b81cb52a7e8dbf42cb63126b4ea/

1

आप छवियों का सिर्फ पिक्सेल अंतर की गणना करते हैं, यह काम करेगा ही अगर एक ही आकार के चित्र या आप जानते हैं कि वास्तव में कैसे करने के लिए इसे क्षैतिज और ऊर्ध्वाधर दिशा में स्केल करें, आपके पास कोई शिफ्ट या रोटेशन इनविरिएंस नहीं होगा।

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

0

मुझे लगता है कि दो डेटाबेस से छवियां एक ही संवाद दिखाती हैं और छवियों को समान गुणवत्ता के समान होना चाहिए लेकिन विभिन्न गुणवत्ता के करीब होना चाहिए? फिर मिलान करने वाली छवियों में समान (या बहुत करीब) पहलू अनुपात होगा।

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

यदि आपके पास कई छवियां हैं तो छवि मिलान बहुत सारे संसाधनों का उपयोग कर सकता है। शायद एक मल्टीपास दृष्टिकोण एक अच्छा विचार है? उदाहरण के लिए: पास 1: छवियों को ग्रुप छवियों (डीबी में चौड़ाई और ऊंचाई फ़ील्ड) के लिए पहलू अनुपात जैसे साधारण मेसर्स का उपयोग करें (कम्प्यूटेशनल सस्ता) पास 2: 1-रंग-चैनल (या सभी चैनल) के लिए हिस्टोग्राम द्वारा मैच या ग्रुप करें (अपेक्षाकृत संगणकीय रूप से सस्ते)

मैं ओपनसीवी की भी सिफारिश करूंगा। आप इसे सी, सी ++ और पायथन (और जल्द ही जावा) के साथ उपयोग कर सकते हैं।

2

मैं कुछ इस तरह करना होगा:

  • आप पहले से ही पता है कि धुंधला छवियों को धुंधला कर दिया गया है, तुलना से पहले उच्च गुणवत्ता वाले चित्रों के लिए एक ही समारोह लागू होते हैं।

    • फिर ऊपर सुझाए गए कम-वर्गों का उपयोग करके छवियों की तुलना करें।
    • सबसे कम मूल्य आपको एक मैच देना चाहिए। आदर्श रूप में, आप 0 मिलेगा अगर दोनों छवियों
    • चीजें तेजी लाने के लिए समान हैं, आप downsampled छवियों पर सबसे तुलना प्रदर्शन कर सकता है तो छवियों
  • आप नहीं जानते हैं के एक चयनित subsample पर परिष्कृत करते हैं, विभिन्न संभावित कार्यों की कोशिश (JPEG संपीड़न, downsampling, ...) और

14

मैं व्यक्तिगत रूप से एक छवि हैशिंग एल्गोरिथ्म के लिए जाना होगा दोहराएँ।

छवि हैशिंग का लक्ष्य एक सामग्री अनुक्रम प्राप्त करने के लिए छवि सामग्री को एक विशेषता अनुक्रम में बदलने के लिए है। यह फीचर अनुक्रम (यानी बिट्स का वेक्टर) तेजी से मेल खाने के लिए पर्याप्त छोटा होना चाहिए और समानता माप के लिए व्यवहार्य सुविधाओं को संरक्षित करना चाहिए।

कई एल्गोरिदम हैं जो मुक्त स्रोत समुदायों के माध्यम से स्वतंत्र रूप से उपलब्ध हैं।

एक साधारण उदाहरण this article में पाया जा सकता है, जहां डा नील Krawetz दिखाता है कि कैसे औसत हैश एल्गोरिदम काम करता है:

  1. आकार कम करें। उच्च आवृत्तियों और विस्तार को हटाने का सबसे तेज़ तरीका छवि को कम करना है। इस मामले में, इसे 8x8 तक छोटा करें ताकि 64 कुल पिक्सेल हो। पहलू अनुपात को बनाए रखने से परेशान न करें, इसे 8x8 वर्ग फिट करने के लिए बस इसे क्रश करें। इस तरह, हैश पैमाने या पहलू अनुपात के बावजूद, छवि के किसी भी बदलाव से मेल खाएगा।
  2. रंग घटाएं। छोटी 8x8 तस्वीर को ग्रेस्केल में परिवर्तित कर दिया गया है। यह हैश को 64 पिक्सल (64 लाल, 64 हरा, और 64 नीला) से 64 कुल रंगों में बदल देता है।
  3. रंगों का औसत। 64 रंगों के औसत मूल्य की गणना करें।
  4. बिट्स की गणना करें। यह मौजमस्ती वाला भाग है। प्रत्येक बिट बस इस आधार पर सेट किया जाता है कि रंग मान माध्य के ऊपर या नीचे है या नहीं।
  5. हैश का निर्माण। 64 बिट्स को 64-बिट पूर्णांक में सेट करें। आदेश कोई फर्क नहीं पड़ता, बस जब तक आप लगातार हैं। (मैं बिट्स नीचे करने के लिए सही, शीर्ष बाएं से बड़े endian का उपयोग कर निर्धारित किया है।)

David Oftedal एक C# command-line application जो वर्गीकृत और औसत हैश एल्गोरिदम का उपयोग कर छवियों की तुलना कर सकते लिखा था। (मैंने आपके नमूना छवियों के साथ अपने कार्यान्वयन का परीक्षण किया और मुझे 98.4% समानता मिली)।

इस समाधान का मुख्य लाभ यह है कि आप केवल एक बार प्रत्येक छवि को पढ़ते हैं, हैश बनाते हैं और उन्हें अपनी समानता के आधार पर वर्गीकृत करते हैं (उदाहरण के लिए, Hamming distance)।

इस तरह आप वर्गीकरण चरण से फीचर निष्कर्षण चरण को रद्द कर देते हैं, और यदि आप पाते हैं कि यह पर्याप्त सटीक नहीं है तो आप आसानी से किसी अन्य हैशिंग एल्गोरिदम पर स्विच कर सकते हैं।


संपादित

आप एक सरल उदाहरण here पा सकते हैं (यह 40 छवियों का एक परीक्षण सेट शामिल है और यह एक 40/40 स्कोर हो जाता है)।

+1

@ सिमोन कीली क्या आपने यह कोशिश की है? वर्तमान में सबसे लोकप्रिय समाधान बहुत संसाधन गहन होगा क्योंकि इसे हर छवि के हर पिक्सेल की तुलना अन्य हर छवि के साथ करने की आवश्यकता है। 10,000 छवियों के लिए जो पूरी छवियों की 100 मिलियन तुलना है।जहां यहां इस समाधान के रूप में बहुत कुशल होगा और केवल एक बार प्रत्येक छवि को पढ़ने की जरूरत है। – MikeKulls

+0

यह वास्तव में एक दिलचस्प जवाब है। यह निश्चित रूप से कुछ है जो मैं देखता हूं ... 98.4% अविश्वसनीय रूप से प्रभावशाली है। –

+0

@ सिमॉन आप 100 छवियों का एक परीक्षण सेट बना सकते हैं और देख सकते हैं कि यह आपके डेटा के साथ कैसा प्रदर्शन करता है। –

0

बस ज़ोर से सोच:

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

अगला आपको परिणामी छवि की चमक प्राप्त करनी होगी; यह गहरा है, मैच बेहतर है।

1

तो बुरा गुणवत्ता अभी तो कम संकल्प का परिणाम है:

  • कम गुणवत्ता छवि संकल्प के लिए उच्च गुणवत्ता छवि rescale (या बराबर कम संकल्प करने के लिए दोनों rescale)
  • प्रत्येक पिक्सेल रंग की तुलना निकटतम मिलान ढूंढने का

तो उदाहरण के लिए सभी छवियों को 32x32 पर पुन: सहेजना और उस सेट की तुलना पिक्सेल द्वारा तुलना करना आपको उचित परिणाम देना चाहिए और यह अभी भी करना आसान है। हालांकि rescaling विधि यहां अंतर कर सकते हैं।

+0

बस एक दोस्ताना fyi: यह अनिवार्य रूप से @ निकोलस बरबे उत्तर के समान है। –

2

आप सामग्री-आधारित छवि पुनर्प्राप्ति (CBIR) आजमा सकते हैं। एक फूरियर का उपयोग कर डेटाबेस में हर छवि के लिए

  1. , उत्पन्न एक फिंगरप्रिंट
  2. लोड स्रोत छवि रूपांतरण, बनाने छवि का एक अंगुली की छाप
  3. की गणना करें:

    यह साफ रखने के लिए यूक्लिडियन स्रोत और सभी डेटाबेस के बीच दूरी

  4. परिणाम
2

मुझे लगता है कि यह करने के लिए एक संकर दृष्टिकोण अपने विशेष बैच मिलान समस्या को हल

  1. एक सेट में Image Hashing algorithm @Paolo Morreti ने सुझाव दिया लागू करें, सभी छवियों
  2. प्रत्येक छवि के लिए करने के लिए, खोजने के लिए सबसे अच्छा होगा एक हैश के साथ छवियों का सबसेट करीब
  3. इस कम खोज स्थान के लिए अब आप महंगी मिलान विधियों को लागू कर सकते हैं जैसा कि @Running Wild या @Raskolnikov द्वारा सुझाया गया है ... सबसे अच्छा एक जीतता है।
0

क्या आपने पैदल चलने वाली औसत विंडो (आरजीबी मूल्यों के लिए) के संयोजन में समोच्च/थ्रेसहोल्डिंग तकनीकों का प्रयास किया है?

संबंधित मुद्दे