// Constructor public UnfoldedBindingComparisonPair(int _threshold, ImageSourceBinding _binding0, ImageSourceBinding _binding1, ImageSource _src0, ImageSource _src1, ComparativeData _radish, ComparativeData _dct, ComparativeData _wavelet, ComparativeData _bmb) { // Copy m_threshold = _threshold; m_binding0 = _binding0; m_binding1 = _binding1; m_sourceBinding0 = _src0; m_sourceBinding1 = _src1; m_compDataRADISH = _radish; m_compDataDCT = _dct; m_compDataWavelet = _wavelet; m_compDataBMB = _bmb; }
// Override: HashData::compareHashData public override ComparativeData compareHashData(HashData _data0, HashData _data1) { // Local variables ComparativeData data = null; // Check parameter if (_data0 == null || _data1 == null) { return(null); } if (_data0.getDataType() != getHashDataType() || _data1.getDataType() != getHashDataType()) { return(null); } // Compare hash data data = m_funcComp(this, (HashData <_HR>)_data0, (HashData <_HR>)_data1); return(data); }
// Override: HashData::containsComparativeDataDefaultValue public override bool containsComparativeDataDefaultValue(ComparativeData _data) { // Local variables ComparativeData <_CR> typedData = null; // Check parameter if (_data == null || _data.getDataType() != getComparatorDataType()) { return(false); } typedData = (ComparativeData <_CR>)_data; // The default value? if (EqualityComparer <_CR> .Default.Equals(typedData.Data, default(_CR))) { return(true); } return(false); }
// Event: Button::Click: Compute private void onButtonComputeClicked(object _sender, EventArgs _e) { // Local variables Job <ComparativeData> jg = null; // Validate if (m_controlImageSourceSelection0.Source == null || m_controlImageSourceSelection1.Source == null) { MessageBox.Show(MSG_ERROR_IMAGES_NOT_SET, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // Prepare m_controlButtonCompute.Enabled = false; lockTechniqueSelection(); m_controlImageSourceSelection0.lockImageSourceSelection(); m_controlImageSourceSelection1.lockImageSourceSelection(); m_controlProgressBar.Visible = m_controlProgressBar.Enabled = true; // Set states: computing m_controlImageSourceSelection0.setInstructionText(STATE_COMPUTING_HASH); m_controlImageSourceSelection1.setInstructionText(STATE_COMPUTING_HASH); // Create job jg = new Job <ComparativeData>((JobParameter <ComparativeData> _params) => { // Local variables ComparativeData result = null; Job <HashData> j0 = null, j1 = null; // Create jobs: computing hashes j0 = Job <HashData> .createJobComputeHash(m_controlImageSourceSelection0.Source, SingleModeTechnique, (JobParameter <HashData> _r) => { // Display hash m_controlImageSourceSelection0.setInstructionText(_r.Result.convertToString()); }, false); j1 = Job <HashData> .createJobComputeHash(m_controlImageSourceSelection1.Source, SingleModeTechnique, (JobParameter <HashData> _r) => { // Display hash m_controlImageSourceSelection1.setInstructionText(_r.Result.convertToString()); }, false); // Start jobs Job <HashData> .enqueue(j0); Job <HashData> .enqueue(j1); // Wait for jobs j0.waitForDone(); j1.waitForDone(); // Compare hashes result = SingleModeTechnique.compareHashData(m_controlImageSourceSelection0.Source, m_controlImageSourceSelection1.Source); return(result); }, (JobParameter <ComparativeData> _r) => { // Run in GUI thread Utility.invokeInGuiThread(m_tabPage, delegate { // Set result or error if (_r.Error != null) { m_controlLabelResult.Text = _r.Error.Message; } else if (_r == null || _r.Result == null) { m_controlLabelResult.Text = MSG_ERROR_COMPUTATION; } else { m_controlLabelResult.Text = _r.Result.convertToString(); } // Accepted? if (_r != null && _r.Result != null) { if (_r.Result.isAccepted() == true) { m_controlLabelResult.ForeColor = System.Drawing.Color.DarkGreen; } else { m_controlLabelResult.ForeColor = System.Drawing.Color.DarkRed; } } // Undo the preparations m_controlButtonCompute.Enabled = true; unlockTechniqueSelection(); m_controlImageSourceSelection0.unlockImageSourceSelection(); m_controlImageSourceSelection1.unlockImageSourceSelection(); m_controlProgressBar.Visible = m_controlProgressBar.Enabled = false; }); }); }
// Create the default technique instance for the algorithm: BMB public static Technique <BMBHash, double> createTechniqueBMB() { // Local variables Technique <BMBHash, double> t = null; // Create technique t = new Technique <BMBHash, double>(TechniqueID.BMB, (Technique _t, ImageSource _image, string[] _dumpToDiskPathes) => { // Local variables BMBHash hash = new BMBHash(); IntPtr hashUnmanaged = IntPtr.Zero; HashComputationTimings timings = new HashComputationTimings(); HashData <BMBHash> result = null; int attMethod = 1; // Extract attributes if (_t.isAttributeAvailable(Technique.ATT_BMB_METHOD) == true) { _t.getAttribute <int>(Technique.ATT_BMB_METHOD, out attMethod); } // Dump to disk? if (_dumpToDiskPathes != null && _dumpToDiskPathes.Length == DumpTechniqueStepsToDisk.BMB_PATH_COUNT) { if (PHash.dumpBMBHashToDisk(_image.FilePath, attMethod, _dumpToDiskPathes[0], _dumpToDiskPathes[1], _dumpToDiskPathes[2]) != 0) { return(null); } return(new HashData <BMBHash>(null)); } else { // Comnpute hash if (PHash.computeBMBHash(_image.FilePath, attMethod, out hashUnmanaged, timings) == -1) { return(null); } // Convert unmanaged to managed Utility.convertUnmanagedPtrToSimpleStructure <BMBHash>(hashUnmanaged, ref hash, false); // Store result result = new HashData <BMBHash>(hash, (BMBHash _data) => { return(Utility.toHexString(_data.m_data, _data.m_dataLength)); }, new HashDataTimings(timings.m_imageLoadingTimeMS, timings.m_hashComputationTimeMS)); return(result); } }, (Technique _t, HashData <BMBHash> _h0, HashData <BMBHash> _h1) => { // Local variables double dis = 0; decimal threshold = 90m; bool isSame = false; ComparativeData <double> result = null; // Extract attributes if (_t.isAttributeAvailable(Technique.ATT_GENERAL_THRESHOLD) == true) { _t.getAttribute <decimal>(Technique.ATT_GENERAL_THRESHOLD, out threshold); } // Compute distance dis = PHash.computeHammingDistance(_h0.Data.m_data, _h0.Data.m_dataLength, _h1.Data.m_data, _h1.Data.m_dataLength); // Is accepted? isSame = (1.0 - dis) >= Convert.ToSingle(threshold) / 100.0; // Store result result = new ComparativeData <double>(dis, isSame, (double _d) => { return("Match rate: " + (1.0 - _d).ToString("#0.0000")); }, (double _d) => { return(1.0 - _d); }); return(result); } ); return(t); }
// Create the default technique instance for the algorithm: wavelet public static Technique <WaveletHash, double> createTechniqueWavelet() { // Local variables Technique <WaveletHash, double> t = null; // Create technique t = new Technique <WaveletHash, double>(TechniqueID.WAVELET, (Technique _t, ImageSource _image, string[] _dumpToDiskPathes) => { // Local variables int len = 0; IntPtr hash; WaveletHash data = new WaveletHash(); HashData <WaveletHash> result = null; HashComputationTimings timings = new HashComputationTimings(); decimal attAlpha = 2m; decimal attLevel = 1m; // Extract attributes if (_t.isAttributeAvailable(Technique.ATT_WAVELET_ALPHA) == true) { _t.getAttribute <decimal>(Technique.ATT_WAVELET_ALPHA, out attAlpha); } if (_t.isAttributeAvailable(Technique.ATT_WAVELET_LEVEL) == true) { _t.getAttribute <decimal>(Technique.ATT_WAVELET_LEVEL, out attLevel); } // Dump to disk? if (_dumpToDiskPathes != null && _dumpToDiskPathes.Length == DumpTechniqueStepsToDisk.WAVELET_PATH_COUNT) { if (PHash.dumpWaveletHashToDisk(_image.FilePath, Convert.ToSingle(attAlpha), Convert.ToSingle(attLevel), _dumpToDiskPathes[0], _dumpToDiskPathes[1], _dumpToDiskPathes[2], _dumpToDiskPathes[3]) != 0) { return(null); } return(new HashData <WaveletHash>(null)); } else { // Compute hast hash = PHash.computeWaveletHash(_image.FilePath, ref len, timings, Convert.ToSingle(attAlpha), Convert.ToSingle(attLevel)); // Store result data.m_data = hash; data.m_dataLength = len; result = new HashData <WaveletHash>(data, (WaveletHash _data) => { return(Utility.toHexString(_data.m_data, _data.m_dataLength)); }, new HashDataTimings(timings.m_imageLoadingTimeMS, timings.m_hashComputationTimeMS)); return(result); } }, (Technique _t, HashData <WaveletHash> _h0, HashData <WaveletHash> _h1) => { // Local variables double dis = 0; decimal threshold = 90m; bool isSame = false; ComparativeData <double> result = null; // Extract attributes if (_t.isAttributeAvailable(Technique.ATT_GENERAL_THRESHOLD) == true) { _t.getAttribute <decimal>(Technique.ATT_GENERAL_THRESHOLD, out threshold); } // Compute distance dis = PHash.computeHammingDistance(_h0.Data.m_data, _h0.Data.m_dataLength, _h1.Data.m_data, _h1.Data.m_dataLength); // Is accepted? isSame = (1.0 - dis) >= Convert.ToSingle(threshold) / 100.0; // Store result result = new ComparativeData <double>(dis, isSame, (double _d) => { return("Match rate: " + (1.0 - _d).ToString("#0.0000")); }, (double _d) => { return(1.0 - _d); }); return(result); } ); return(t); }
// Create the default technique instance for the algorithm: DCT public static Technique <UInt64, double> createTechniqueDCT() { // Local variables Technique <UInt64, double> t = null; // Create technique t = new Technique <UInt64, double>(TechniqueID.DCT, (Technique _t, ImageSource _image, string[] _dumpToDiskPathes) => { // Local variables UInt64 hash = 0; HashData <UInt64> result = null; HashComputationTimings timings = new HashComputationTimings(); // Dump to disk? if (_dumpToDiskPathes != null && _dumpToDiskPathes.Length == DumpTechniqueStepsToDisk.DCT_PATH_COUNT) { if (PHash.dumpDCTHashToDisk(_image.FilePath, _dumpToDiskPathes[0], _dumpToDiskPathes[1], _dumpToDiskPathes[2], _dumpToDiskPathes[3], _dumpToDiskPathes[4], _dumpToDiskPathes[5]) != 0) { return(null); } return(new HashData <ulong>(0)); } else { // Compute hast PHash.computeDCTHash(_image.FilePath, ref hash, timings); // Store result result = new HashData <UInt64>(hash, null, new HashDataTimings(timings.m_imageLoadingTimeMS, timings.m_hashComputationTimeMS)); return(result); } }, (Technique _t, HashData <UInt64> _h0, HashData <UInt64> _h1) => { // Local variables double dis = 0; bool isSame = false; decimal threshold = 90m; ComparativeData <double> result = null; // Extract attributes if (_t.isAttributeAvailable(Technique.ATT_GENERAL_THRESHOLD) == true) { _t.getAttribute <decimal>(Technique.ATT_GENERAL_THRESHOLD, out threshold); } // Compute distance and normalize it dis = PHash.computeHammingDistance(_h0.Data, _h1.Data); dis /= 64; // Is accepted? isSame = (1.0 - dis) >= Convert.ToSingle(threshold) / 100.0; // Store result result = new ComparativeData <double>(dis, isSame, (double _d) => { return("Match rate: " + (1.0 - _d).ToString("#0.0000")); }, (double _d) => { return(1.0f - _d); }); return(result); } ); return(t); }
// Checks whether the comparative data contains the default value for its internal type public abstract bool containsComparativeDataDefaultValue(ComparativeData _data);
// Adds the comparison data for a certain technique public void setComparisonDataFor(TechniqueID _id, ComparativeData _data) { m_comparisonData.Add(_id, _data); }