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