public void Generate_Image_Hash()
{
var imageFilename = @"C:\temp\image_tests\1.jpg";
var secondImagFilename = @"C:\temp\image_tests\2.jpg";
var resizedFirstImageFilename = @"C:\temp\image_tests\1-resized.jpg";
var thirdImageFilename = @"C:\temp\image_tests\3.jpg";
var hash = ImageHasher.AverageHash(imageFilename);
Assert.True(hash > 0);
var secondHash = ImageHasher.AverageHash(imageFilename);
Assert.True(secondHash > 0);
Assert.Equal(hash, secondHash);
secondHash = ImageHasher.AverageHash(secondImagFilename);
Assert.True(secondHash > 0);
Assert.Equal(hash, secondHash);
var similiar = ImageHasher.Similarity(imageFilename, secondImagFilename);
Assert.Equal(100d, similiar);
Assert.True(ImageHasher.ImagesAreSame(imageFilename, secondImagFilename));
secondHash = ImageHasher.AverageHash(resizedFirstImageFilename);
Assert.True(secondHash > 0);
Assert.Equal(hash, secondHash);
Assert.False(ImageHasher.ImagesAreSame(imageFilename, thirdImageFilename));
}
public void GrayscaleImage()
{
using (var image = ImageUtils.GrayscaleImage(ImageUtils.ReduceImage(ImageFullSize, 9, 8)))
{
image.Save(
IOUtils.MapServerPath("~/Images/Alyson-9x8-Gray-Generated.jpg"),
ImageFormat.Jpeg);
}
Image grayscaleImage = Image.FromFile(IOUtils.MapServerPath(
"~/Images/Alyson-9x8-Gray-Generated.jpg"));
Image expectedImage = Image.FromFile(IOUtils.MapServerPath(
"~/Images/Alyson-9x8-Gray.jpg"));
ulong grayscaleImageHash = ImageHasher.ComputeDifferenceHash(grayscaleImage);
ulong expectedImageHash = ImageHasher.ComputeDifferenceHash(expectedImage);
Assert.That(grayscaleImageHash, Is.EqualTo(expectedImageHash));
double similarity = ImageHasher.ComputeSimilarity(grayscaleImageHash, expectedImageHash);
int distance = ImageHasher.ComputeHammingDistance(grayscaleImageHash, expectedImageHash);
Assert.That(similarity, Is.EqualTo(1.0));
Assert.That(distance, Is.EqualTo(0));
}
public static async Task <Image> GetImageFromUrlAsync(string url)
{
byte[] imageBytes = null;
try
{
using (var webClient = new WebClient())
{
webClient.Headers.Add("user-agent", WebHelper.UserAgent);
imageBytes = await webClient.DownloadDataTaskAsync(new Uri(url));
}
}
catch
{
}
if (imageBytes != null)
{
var signature = ImageHasher.AverageHash(imageBytes).ToString();
var ib = ImageHelper.ConvertToJpegFormat(imageBytes);
return(new Image
{
Url = url,
Status = Statuses.New,
Signature = signature,
Bytes = ib
});
}
return(null);
}
public string GenerateSignature()
{
if (this.Bytes == null || !this.Bytes.Any())
{
return(null);
}
return(ImageHasher.AverageHash(this.Bytes).ToString());
}
public void ComputeHammingDistanceWithDifferenceHash()
{
ulong imageHashB = ImageHasher.ComputeDifferenceHash(ImageB);
ulong imageHashC = ImageHasher.ComputeDifferenceHash(ImageC);
int distanceBB = ImageHasher.ComputeHammingDistance(imageHashB, imageHashB);
int distanceBC = ImageHasher.ComputeHammingDistance(imageHashB, imageHashC);
Assert.That(distanceBB, Is.EqualTo(0));
Assert.That(distanceBC, Is.EqualTo(1));
}
public void ComputeSimilarityWithAverageHash()
{
ulong imageHashA = ImageHasher.ComputeAverageHash(ImageA);
ulong imageHashC = ImageHasher.ComputeAverageHash(ImageC);
double similarityAA = ImageHasher.ComputeSimilarity(imageHashA, imageHashA);
double similarityAC = ImageHasher.ComputeSimilarity(imageHashA, imageHashC);
Assert.That(similarityAA, Is.EqualTo(1.0));
Assert.That(similarityAC, Is.InRange <double>(0.8, 0.85));
}
public void ComputeSimilarityWithDifferenceHash()
{
ulong imageHashB = ImageHasher.ComputeDifferenceHash(ImageB);
ulong imageHashC = ImageHasher.ComputeDifferenceHash(ImageC);
double similarityBB = ImageHasher.ComputeSimilarity(imageHashB, imageHashB);
double similarityBC = ImageHasher.ComputeSimilarity(imageHashB, imageHashC);
Assert.That(similarityBB, Is.EqualTo(1.0));
Assert.That(similarityBC, Is.InRange <double>(0.95, 1.0));
}
public void ComputeHammingDistanceWithAverageHash()
{
ulong imageHashA = ImageHasher.ComputeAverageHash(ImageA);
ulong imageHashC = ImageHasher.ComputeAverageHash(ImageC);
int distanceAA = ImageHasher.ComputeHammingDistance(imageHashA, imageHashA);
int distanceAC = ImageHasher.ComputeHammingDistance(imageHashA, imageHashC);
Assert.That(distanceAA, Is.EqualTo(0));
Assert.That(distanceAC, Is.EqualTo(10));
}
public async Task <IActionResult> OnPostAsync(Guid id, CancellationToken cancellationToken)
{
EnsureArg.IsNotEmpty(id, nameof(id));
var f = await this.fileService.GetPostFile(id, cancellationToken);
return(await f.Match(async some =>
{
var hash = ImageHasher.Hash(some.Data);
await fileService.BanImage(hash, Reason, cancellationToken);
return this.RedirectToPage <IndexModel>().ToIAR();
}, () => this.NotFound().ToIART()));
}
public static void Main(string[] args)
{
ImageHasher ih = new ImageHasher();
foreach (string str in args)
{
Console.WriteLine(str);
}
Bitmap image = ih.HashData(64, Encoding.UTF8.GetBytes(args[0]));
image.Save("out.png", ImageFormat.Png);
}
static void Main(string[] args)
{
if (args == null || args.Length < 2)
{
Console.WriteLine("not enough arguments");
}
else if (!File.Exists(args[0]))
{
Console.WriteLine("{0} does not exist", args[0]);
}
else if (!File.Exists(args[1]))
{
Console.WriteLine("{0} does not exist", args[1]);
}
else
{
string imageAPath = args[0];
string imageBPath = args[1];
Image imageA = null;
Image imageB = null;
try
{
imageA = Image.FromFile(imageAPath);
imageB = Image.FromFile(imageBPath);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (imageA != null && imageB != null)
{
ulong imageAHash = ImageHasher.ComputeDifferenceHash(imageA);
ulong imageBHash = ImageHasher.ComputeDifferenceHash(imageB);
Console.WriteLine(
"{0}: {1}", Path.GetFileName(imageAPath), imageAHash);
Console.WriteLine(
"{0}: {1}", Path.GetFileName(imageBPath), imageBHash);
Console.WriteLine(
"Similarity: {0}",
ImageHasher.ComputeSimilarity(imageAHash, imageBHash));
Console.WriteLine(
"Hamming Distance: {0}",
ImageHasher.ComputeHammingDistance(imageAHash, imageBHash));
}
}
}
/// <summary>
/// CONSTRUCTOR
/// </summary>
/// <param name="PathToOriginal"></param>
public ReportImage(string PathToOriginal, ReportImageStateEnum reportsSupported)
{
this.PathToOriginal = PathToOriginal;
this.ImageReportState = reportsSupported;
if (filePaths.ContainsKey(PathToOriginal))
{
OriginalHash = filePaths[PathToOriginal];
}
else
{
byte[] bytes = File.ReadAllBytes(PathToOriginal);
OriginalHash = ImageHasher.Hash(bytes);
filePaths.Add(PathToOriginal, OriginalHash);
}
}
public void Calculate()
{
// Arrange
var transformer = new Mock <IImageTransformer>();
transformer.Setup(impl => impl.ConvertToGreyscaleAndResize(It.IsAny <Stream>(), 9, 8))
.Returns(() => Enumerable.Range(1, 72).Reverse().Select(value => (byte)value).ToArray());
IImageHasher hasher = new ImageHasher(transformer.Object);
// Act
var hash = hasher.Calculate(Stream.Null, KnownImageHashes.Difference64);
// Assert
Assert.Equal(18446744073709551615UL, hash.InternalValue);
}
Task <ResType> IValidateImage.ValidateAsync(Option <byte[]> data)
{
return(data.Match(async some =>
{
if (some.Length > ImageMaxSize)
{
return (ResType) new SizeExceeded(ImageMaxSize);
}
var hash = ImageHasher.Hash(some);
if (await this.bannedImages.IsBanned(hash, CancellationToken.None))
{
return new BannedImage();
}
return new Pass();
}, () => Task.FromResult <ResType>(new Pass())));
}
static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.CreateLogger();
IServiceProvider sp = BuildServiceProvider();
BulkMediaUpdater updater = sp.GetService <BulkMediaUpdater>();
VideoConverter videoConverter = sp.GetService <VideoConverter>();
FaceScanner faceScanner = sp.GetService <FaceScanner>();
ImageHasher hasher = sp.GetService <ImageHasher>();
//await videoConverter.GenerateVideosAsync(default);
//await updater.UpdateMediaAISummaryAsync(default);
await hasher.HashAsync();
//await faceScanner.RunAsync(default);
}
public static async Task <IImage> GetImageFromUrlAsync(string url)
{
byte[] imageBytes = null;
try
{
using (var webClient = new WebClient())
{
webClient.Headers.Add("user-agent", UserAgent);
imageBytes = await webClient.DownloadDataTaskAsync(new Uri(url));
}
}
catch
{
}
try
{
if (imageBytes != null)
{
var signature = ImageHasher.AverageHash(imageBytes).ToString();
var ib = ImageHelper.ConvertToJpegFormat(imageBytes);
return(new Image(Guid.NewGuid())
{
Url = url,
Status = Statuses.New,
Signature = signature,
Bytes = ib
});
}
}
catch (Exception ex)
{
Trace.WriteLine($"GetImageFromUrlAsync Url [{ url }], Exception [{ ex.ToString() }", "Warning");
}
return(null);
}
public void ComputeAverageHash()
{
ulong hash = ImageHasher.ComputeAverageHash(ImageA);
Assert.That(hash, Is.EqualTo(16701559407061564136));
}
public void ComputeDifferenceHash()
{
ulong hash = ImageHasher.ComputeDifferenceHash(ImageA);
Assert.That(hash, Is.EqualTo(8100370218449873837));
}
