/// <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;
}
}
