/// <summary> /// Search similar images /// </summary> /// <param name="image"> path of image of interest </param> /// <param name="imagehash"> Image hash algorithm </param> /// <param name="filter_method"> Color filtering method </param> /// <param name="similarity_cutoff"> min. similarity % </param> /// <returns></returns> public Dictionary <string, int> SearchSimilarImages(string image, Images.ImageHashAlgorithm imagehash, Images.ComparisonMethod filter_method, int similarity_cutoff) { var matches = new Dictionary <string, int>(); similar_images_found = new Dictionary <string, int> [number_of_index]; Parallel.For(0, number_of_index, i => { var found = new Dictionary <string, int>(); found.Add(image, 100); if (index_list[i].Count > 0) { found = index_list[i].SearchSimilarImages(image, imagehash, filter_method, similarity_cutoff); } similar_images_found[i] = found; }); if (similar_images_found == null) { return(matches); } if (similar_images_found.Length == 0) { return(matches); } foreach (var images_found in similar_images_found) { matches = matches.Union(images_found).ToDictionary(k => k.Key, v => v.Value); } return(matches); }
/// <summary> /// Constructor (Add to subtree) /// </summary> /// <param name="image"></param> /// <param name="distance"></param> /// <param name="imghash_algo">image hash algo</param> /// <param name="img_index">image hashes</param> public BKTree(string image, int distance, Images.ImageHashAlgorithm imghash_algo, Images.ImageIndex.Index img_index) { image_path = image; distParent = distance; ImageHashAlgo(imghash_algo); image_index = img_index; }
/// <summary> /// Calculate image hash /// </summary> /// <param name="image_path"></param> /// <param name="hash_algo">hash algorithm</param> /// <returns>image hash</returns> public static string HashImage(string image_path, Images.ImageHashAlgorithm hash_algo) { Image image = Image.FromFile(image_path, true); var hash = HashImage(image, hash_algo); image.Dispose(); return(hash); }
/// <summary> /// Compare 2 images hashes /// </summary> /// <param name="image_name1">path to 1st Image</param> /// <param name="image_name2">path to 2nd Image</param> /// <param name="hash">hash algorithm</param> /// <returns>similarity % [0,100]</returns> public static double Compare(String image_name1, String image_name2, Images.ImageHashAlgorithm hash) { Image image1 = Image.FromFile(image_name1, true); Image image2 = Image.FromFile(image_name2, true); var sim = Compare(image1, image2, hash); image1.Dispose(); image2.Dispose(); return(sim); }
/// <summary> /// Calculate the similarity of 2 images hashes /// </summary> /// <param name="first"></param> /// <param name="second"></param> /// <param name="hash_algo">hash algorithm</param> /// <returns>similarity % [0,100]</returns> public static double HashSimilarity(string first, string second, Images.ImageHashAlgorithm hash_algo) { double sim = 0; try { switch (hash_algo) { case ImageHashAlgorithm.Average: sim = Images.ImageAverageHash.Similarity(first, second); break; case ImageHashAlgorithm.Block: sim = Images.ImageBlockHash.Similarity(first, second); break; case ImageHashAlgorithm.Color: sim = Images.ImageColorHash.Similarity(first, second); break; case ImageHashAlgorithm.Difference: sim = Images.ImageDifferenceHash.Similarity(first, second); break; case ImageHashAlgorithm.MD5: sim = Images.ImageMD5Hash.Similarity(first, second); break; case ImageHashAlgorithm.Perceptive: sim = Images.ImagePHash.Similarity(first, second); break; case ImageHashAlgorithm.Histogram: sim = Images.ImageHistogramHash.Similarity(first, second); break; default: break; } } catch (Exception e) { var msg = e.Message; //Console.WriteLine("error hash sim {0} vs {1} : {2}", first, second,msg); } return(sim); }
/// <summary> /// Draw image representation of an image hash /// </summary> /// <param name="hash"></param> /// <param name="hash_algo"></param> /// <returns></returns> public static Image DrawHash(string hash, Images.ImageHashAlgorithm hash_algo) { var img = (Image) new Bitmap(1, 1); switch (hash_algo) { case ImageHashAlgorithm.Average: var ahashl = Convert.ToUInt64(hash); var ahashb = CommonUtils.StringUtils.LongToBinaryString((long)ahashl); img = HashBitStringToImage(ahashb); break; case ImageHashAlgorithm.Block: img = HashBitStringToImage(hash); break; case ImageHashAlgorithm.Color: img = (Image)CommonUtils.ImageUtils.MakeSquare(Color.FromArgb(Convert.ToInt32(hash))); break; case ImageHashAlgorithm.Difference: var dhashl = Convert.ToUInt64(hash); var dhashb = CommonUtils.StringUtils.LongToBinaryString((long)dhashl); img = HashBitStringToImage(dhashb); break; case ImageHashAlgorithm.Histogram: img = HashBitStringToImage(hash, 9); break; case ImageHashAlgorithm.MD5: break; case ImageHashAlgorithm.Perceptive: img = HashBitStringToImage(hash); break; default: break; } return(img); }
/// <summary> /// Calculate image hash /// </summary> /// <param name="image"></param> /// <param name="hash_algo">hash algorithm</param> /// <returns>image hash</returns> public static string HashImage(Image image, Images.ImageHashAlgorithm hash_algo) { string hash = String.Empty; switch (hash_algo) { case ImageHashAlgorithm.Average: hash = Images.ImageAverageHash.AverageHash(image); break; case ImageHashAlgorithm.Block: hash = Images.ImageBlockHash.BlockHash(image); break; case ImageHashAlgorithm.Color: hash = Images.ImageColorHash.ColorHash(image); break; case ImageHashAlgorithm.Difference: hash = Images.ImageDifferenceHash.DifferenceHash(image); break; case ImageHashAlgorithm.MD5: hash = Images.ImageMD5Hash.MD5Hash(image); break; case ImageHashAlgorithm.Perceptive: hash = Images.ImagePHash.PerceptiveHash(image); break; case ImageHashAlgorithm.Histogram: hash = Images.ImageHistogramHash.HistogramHash(image); break; default: break; } return(hash); }
/// <summary> /// Compare 2 images hashes /// </summary> /// <param name="image1">1st Image</param> /// <param name="image2">2nd Image</param> /// <param name="hash">hash algorithm</param> /// <returns>similarity % [0,100]</returns> public static double Compare(Image image1, Image image2, Images.ImageHashAlgorithm hash) { double cmp = 0; switch (hash) { case ImageHashAlgorithm.Average: cmp = Images.ImageAverageHash.Compare(image1, image2); break; case ImageHashAlgorithm.Block: cmp = Images.ImageBlockHash.Compare(image1, image2); break; case ImageHashAlgorithm.Color: cmp = Images.ImageColorHash.Compare(image1, image2); break; case ImageHashAlgorithm.Difference: cmp = Images.ImageDifferenceHash.Compare(image1, image2); break; case ImageHashAlgorithm.MD5: cmp = Images.ImageMD5Hash.Compare(image1, image2); break; case ImageHashAlgorithm.Perceptive: cmp = Images.ImagePHash.Compare(image1, image2); break; case ImageHashAlgorithm.Histogram: cmp = Images.ImageHistogramHash.Compare(image1, image2); break; default: break; } return(cmp); }
/// <summary> /// Constructor /// </summary> /// <param name="img_index">image hashes</param> /// <param name="imghash_algo">image hash algo</param> public BKTree(Images.ImageHashAlgorithm imghash_algo, Images.ImageIndex.Index img_index) { ImageHashAlgo(imghash_algo); image_index = img_index; ImageHashAlgo(imghash_algo); }
/// <summary> /// Set image hash algorithm used and distance metric /// </summary> /// <param name="imghash_algo">image hash algo</param> private void ImageHashAlgo(Images.ImageHashAlgorithm imghash_algo) { imghash_algo_used = imghash_algo; DistanceMethod = ImageHashDistance; }
/// <summary> /// Set search options from the UI (method, filter and similarity cutoff) /// </summary> private void ReadSearchOptions() { // method switch (this.CBMethod.SelectedIndex) { case 0: option_image_hash = Images.ImageHashAlgorithm.Average; break; case 1: option_image_hash = Images.ImageHashAlgorithm.AverageHistogram; break; case 2: option_image_hash = Images.ImageHashAlgorithm.AverageColor; break; case 3: option_image_hash = Images.ImageHashAlgorithm.Block; break; case 4: option_image_hash = Images.ImageHashAlgorithm.BlockHistogram; break; case 5: option_image_hash = Images.ImageHashAlgorithm.BlockColor; break; case 6: option_image_hash = Images.ImageHashAlgorithm.Color; break; case 7: option_image_hash = Images.ImageHashAlgorithm.Difference; break; case 8: option_image_hash = Images.ImageHashAlgorithm.DifferenceHistogram; break; case 9: option_image_hash = Images.ImageHashAlgorithm.DifferenceColor; break; case 10: option_image_hash = Images.ImageHashAlgorithm.Histogram; break; case 11: option_image_hash = Images.ImageHashAlgorithm.Perceptive; break; case 12: option_image_hash = Images.ImageHashAlgorithm.PerceptiveHistogram; break; case 13: option_image_hash = Images.ImageHashAlgorithm.PerceptiveColor; break; default: option_image_hash = Images.ImageHashAlgorithm.PerceptiveHistogram; break; } // filter switch (this.CBFilter.SelectedIndex) { case 0: option_filter_colors = Images.ComparisonMethod.None; break; case 1: option_filter_colors = Images.ComparisonMethod.MainColor; break; case 2: option_filter_colors = Images.ComparisonMethod.TopColors; break; case 3: option_filter_colors = Images.ComparisonMethod.PixelsDifference; break; case 4: option_filter_colors = Images.ComparisonMethod.PixelsDifferenceSorted; break; case 5: option_filter_colors = Images.ComparisonMethod.PixelsDistance; break; case 6: option_filter_colors = Images.ComparisonMethod.PixelsDistanceSorted; break; default: option_filter_colors = Images.ComparisonMethod.TopColors; break; } // similarity switch (this.CBSimilarity.SelectedIndex) { case 0: option_similarity_cutoff = 65; break; case 1: option_similarity_cutoff = 70; break; case 2: option_similarity_cutoff = 75; break; case 3: option_similarity_cutoff = 80; break; case 4: option_similarity_cutoff = 85; break; case 5: option_similarity_cutoff = 90; break; case 6: option_similarity_cutoff = 95; break; case 7: option_similarity_cutoff = 100; break; default: option_similarity_cutoff = 90; break; } }