c# सी#में दो छवियों की तुलना करने के लिए एल्गोरिदम




image hash (4)

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

जब तक आप अपने आप पर पूर्ण एल्गोरिदम को फिर से बनाना नहीं चाहते हैं, तो आपको पहले से मौजूद मौजूदा पुस्तकालयों या उनके कोड का कम से कम हिस्सा उपयोग करने का प्रयास करना चाहिए (जब तक उनका लाइसेंस आपके लिए ठीक है)।

एज डिटेक्शन और संबंधित कंप्यूटर दृष्टि एल्गोरिदम के ओपन सोर्स सी # कार्यान्वयन के लिए, आप EmguCV को आज़मा सकते हैं जो EmguCV का एक रैपर है।

मैं डुप्लिकेट छवियों को खोजने के लिए सी # में एक उपकरण लिख रहा हूं। वर्तमान में मैं फ़ाइलों का एमडी 5 चेकसम बनाता हूं और उनसे तुलना करता हूं।

दुर्भाग्य से मेरी छवियां हो सकती हैं

  • 90 डिग्री से घिरा हुआ
  • अलग आयाम हैं (एक ही सामग्री के साथ छोटी छवि)
  • अलग संपीड़न या फ़ाइल प्रकार हैं (उदाहरण के लिए जेपीजी कलाकृतियों, नीचे देखें)

इस समस्या को हल करने का सबसे अच्छा तरीका क्या होगा?


256 बिट छवि-हैश (एमडी 5 में 128 बिट) के साथ एक सरल दृष्टिकोण है

  1. चित्र को 16x16 पिक्सेल का आकार बदलें

  1. काले / सफेद रंगों को कम करें (जो इस कंसोल आउटपुट में सत्य / गलत के बराबर है )

  1. बूलियन मानों को List<bool> में पढ़ें - यह हैश है

संहिता :

public static List<bool> GetHash(Bitmap bmpSource)
{
    List<bool> lResult = new List<bool>();         
    //create new image with 16x16 pixel
    Bitmap bmpMin = new Bitmap(bmpSource, new Size(16, 16));
    for (int j = 0; j < bmpMin.Height; j++)
    {
        for (int i = 0; i < bmpMin.Width; i++)
        {
            //reduce colors to true / false                
            lResult.Add(bmpMin.GetPixel(i, j).GetBrightness() < 0.5f);
        }             
    }
    return lResult;
}

मुझे पता है, GetPixel तेज़ नहीं है लेकिन 16x16 पिक्सेल छवि पर यह बाधा नहीं होनी चाहिए।

  1. इस हैश की तुलना अन्य छवियों से हैश मानों की तुलना करें और सहिष्णुता जोड़ें। (पिक्सेल की संख्या जो अन्य हैश से भिन्न हो सकती है)

कोड:

List<bool> iHash1 = GetHash(new Bitmap(@"C:\mykoala1.jpg"));
List<bool> iHash2 = GetHash(new Bitmap(@"C:\mykoala2.jpg"));

//determine the number of equal pixel (x of 256)
int equalElements = iHash1.Zip(iHash2, (i, j) => i == j).Count(eq => eq);

तो यह कोड बराबर छवियों को ढूंढने में सक्षम है:

  • विभिन्न फ़ाइल प्रारूप (जैसे जेपीजी, पीएनजी, बीएमपी)
  • घूर्णन (90, 180, 270), क्षैतिज / ऊर्ध्वाधर फ्लिप - i और j के पुनरावृत्ति क्रम को बदलकर
  • विभिन्न आयाम (एक ही पहलू की आवश्यकता है)
  • विभिन्न संपीड़न (जेपीईजी कलाकृतियों जैसे गुणवत्ता के नुकसान के मामले में सहिष्णुता की आवश्यकता होती है) - आप एक ही छवि होने के लिए 99% समानता स्वीकार कर सकते हैं और 50% अलग हो सकते हैं।
  • रंग बदलकर गीसेस्लेल्ड और दूसरी तरफ गोल (क्योंकि चमक रंग से स्वतंत्र है)

अद्यतन / सुधार:

थोड़ी देर के लिए इस विधि का उपयोग करने के बाद मैंने कुछ सुधार किए जो कि किए जा सकते हैं

  • अधिक प्रदर्शन के लिए GetPixel replacing
  • प्रदर्शन सुधार के लिए पूरी छवि को पढ़ने के बजाय exeif-thumbnail का उपयोग करना
  • प्रकाश और अंधेरे के बीच 0.5f को अलग करने के बजाय - सभी 256 पिक्सल की विशिष्ट औसत चमक का उपयोग करें। अन्यथा अंधेरे / हल्की छवियों को समान माना जाता है और यह उन छवियों का पता लगाने में सक्षम बनाता है जिनमें एक चमकदार चमक है।
  • यदि आपको fast गणना की आवश्यकता है, तो bool[] या List<bool> यदि आपको स्मृति को बचाने की आवश्यकता के साथ बहुत सारे Bitarray स्टोर करने की आवश्यकता है, तो Bitarray उपयोग करें क्योंकि एक बूलियन थोड़ी देर में संग्रहीत नहीं होता है, यह byte लेता है!

छवियों को कुछ सामान्य संकल्प में दोबारा बदलने के बाद, आप एक वेवलेट अपघटन का उपयोग कर सकते हैं और छवियों के बजाय इस अपघटन के गुणांक की तुलना कर सकते हैं। केवल पहले एन गुणांक की तुलना करना इस विधि को शोर और अन्य कलाकृतियों के लिए अधिक मजबूत बना देगा।

उपलब्ध लहरों के लिए कई सी # कार्यान्वयन हैं। एक उदाहरण है https://waveletstudio.codeplex.com/


दिलचस्प सवाल, छवियों की तुलना इतना मुश्किल नहीं है कि,

  1. वे छवियां एक जैसी हैं (पहला एक दूसरे के एक भाग या vise विपरीत नहीं है)
  2. छवियों को केवल 90 डिग्री के गुणकों द्वारा घुमाया जाता है

तुलना करने का एक तरीका होगा,

  1. छवियों को निम्नतम आकार के व्यास में आकार दें
  2. प्रत्येक छवि पर किनारे का पता लगाने के परिणामस्वरूप काले और सफेद छवि (या 0 और 1 की सरणी)
  3. परिणामी बिटमैप्स की तुलना करें (पहले एक को रखें, और दूसरे को 90 डिग्री 3 बार घुमाएं) और% मिलान पिक्सेल की गणना करें और सबसे महत्वपूर्ण मूल्य प्राप्त करें

अब यदि मूल्य उचित मूल्य के भीतर आता है तो 9 0% (शायद कुछ प्रयोग करके निर्धारित करना होगा), तो आप सुरक्षित रूप से दोनों ही मान सकते हैं, लेकिन यह काम नहीं करेगा यदि यह काम नहीं करेगा,

  1. यहां तक ​​कि अगर कुछ पिक्सेल कोने में भिन्न होता है, उदाहरण के लिए दूसरी छवि पहले से फसल की जाती है
  2. छवियों को 90 डिग्री के गुणकों के अलावा घुमाया जाता है (हालांकि यह बहुत संभव नहीं है)




hash