डुप्लिकेट छवियों की खोज के उदाहरण का उपयोग करके उनके चेकसम द्वारा वस्तुओं के मिलान के लिए त्वरित खोज

स्रोत डेटा:

• विशेषताओं के साथ वस्तुओं का एक सेट
• लगभग किसी चेकसम से तुलना करके वस्तु की सही पहचान करने की क्षमता।

अंतिम लक्ष्य:

• उन वस्तुओं की सूची प्राप्त करें जिनके लिए मैचों की पहचान करना आसान है।

एल्गोरिथ्म का विचार एक प्रत्यय का पेड़ बनाना है , जिसमें से प्रत्येक नोड चेकसम के एक बाइट को संग्रहीत करता है। अगली वस्तु के चेकसम प्राप्त होने पर, हम पेड़ की जड़ से गहराई से चलना शुरू करते हैं, अगर हमें अनुक्रम में अगले बाइट के लिए नोड नहीं मिलता है, तो इसे बनाएं। चेकसम के अंत तक पहुँचने और अंतिम नोड बनाने के बाद, हम इसमें ऑब्जेक्ट पैरामीटर लिखते हैं। नतीजतन, हम अंत नोड्स की एक सूची प्राप्त करते हैं, यदि अंत नोड में एक से अधिक ऑब्जेक्ट का विवरण होता है, तो हम मानते हैं कि ये ऑब्जेक्ट समान हैं।



मैं बेहतर समझ के लिए स्रोत पाठ का एक सामान्य दृष्टिकोण देता हूं, जिसे वास्तविक कार्यों के लिए टेम्पलेट के रूप में उपयोग किया जा सकता है।

using System;

using System.Collections. Generic ;

/// <summary>

///

/// </summary>

public class HashObject

{

public string attribute1 { get ; set ; }

public string attribute2 { get ; set ; }

}

/// <summary>

/// ,

///

///

/// </summary>

public class HashTreeNode

{

/// <summary>

///

/// </summary>

private byte myPart;

public byte MyPart

{

get { return myPart; }

}

public HashTreeNode( byte part)

{

myPart = part;

}

/// <summary>

/// ,

/// </summary>

public List <HashObject> files = null ;

/// <summary>

///

/// </summary>

private List <HashTreeNode> NextNodes = new List <HashTreeNode>();

/// <summary>

///

/// </summary>

public HashTreeNode FindEndNode( byte [] crc, int position)

{

HashTreeNode endNode = FindSubNodes(crc[position]);

if (position < crc.Length - 1)

return endNode.FindEndNode(crc, position + 1);

else return endNode;

}

/// <summary>

/// /

/// </summary>

private HashTreeNode FindSubNodes( byte part)

{

lock (NextNodes)

{

for ( int i = 0; i < NextNodes.Count; i++)

if (NextNodes[i].MyPart.Equals(part))

return NextNodes[i];

NextNodes.Add( new HashTreeNode(part));

return NextNodes[NextNodes.Count - 1];

}

}

}

/// <summary>

/// ,

/// </summary>

public class HashTree

{

/// <summary>

///

/// </summary>

List <HashTreeNode> Nodes = new List <HashTreeNode>();

/// <summary>

///

/// ,

/// </summary>

/// <param name="crc">Crc32 </param>

/// <returns></returns>

public HashTreeNode CheckOnTree( byte [] crc)

{

HashTreeNode root = FindNode(crc[0]);

return root.FindEndNode(crc, 1);

}

/// <summary>

///

/// </summary>

private HashTreeNode FindNode( byte part)

{

lock (Nodes)

{

for ( int i = 0; i < Nodes.Count; i++)

if (Nodes[i].MyPart.Equals(part))

return Nodes[i];

Nodes.Add( new HashTreeNode(part));

return Nodes[Nodes.Count - 1];

}

}

}



* This source code was highlighted with Source Code Highlighter .

एक उदाहरण के रूप में, निर्दिष्ट निर्देशिका में डुप्लिकेट छवियों को खोजने के लिए सबसे सरल अनुप्रयोग लागू किया गया है। काम के परिणामस्वरूप, हमें एक HTML रिपोर्ट फ़ाइल मिलती है।

प्रोजेक्ट को Microsoft Visual Studio 2008 में निष्पादित किया गया था, और Windows x86 के तहत संकलित किया गया था।

फोटो के साथ अपने स्वयं के फ़ोल्डर पर परियोजना का परीक्षण किया गया था, परीक्षा परिणाम:

निर्देशिका में फ़ाइलें: 4326

इन तस्वीरों में से: 4131

छवि वजन: 8.33 जीबी

डुप्लिकेट खोज समय: एक रिपोर्ट उत्पन्न करने और रिपोर्ट फ़ोल्डर में डुप्लिकेट फ़ाइलों को कॉपी करने के लिए 117 सेकंड (2 मिनट) + 6 सेकंड।

मिला: 90 डुप्लिकेट।

आवेदन और स्रोतों से लिंक करें:

ifolder.ru/19211139



अगर किसी को दिलचस्पी है, तो छवियों से संबंधित फाइलों की जांच विस्तार से नहीं, बल्कि हस्ताक्षर द्वारा, फ़ाइल हेडर की जांच करके की जाती है। Signatures.cs परियोजना में वर्ग है।



पेशेवरों:

• अपेक्षाकृत उच्च गति
• कार्यान्वयन और डेटा भंडारण में आसानी

विपक्ष:

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

मैं उन लोगों का आभारी रहूंगा, जो पद पर रहते हैं, जो उन्हें ज्ञात बेहतर एल्गोरिदम के लिए लिंक प्रदान करेंगे या वर्णित कमियों को इंगित करेंगे।