2.2.0

Author: Decimation

SmartImage.Lib/DirectImage.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using RestSharp;
+
+namespace SmartImage.Lib
+{
+	public class DirectImage : IDisposable
+	{
+		public Uri Url { get; internal set; }
+
+		public Stream Stream { get; internal set; }
+
+		public IRestResponse Response { get; internal set; }
+
+		public bool Equals(DirectImage other)
+		{
+			
+			return Url == other?.Url && Equals(Stream, other?.Stream) 
+			                        && Equals(Response, other?.Response);
+		}
+
+		public override bool Equals(object obj)
+		{
+			return obj is DirectImage other && Equals(other);
+		}
+
+		public override int GetHashCode()
+		{
+			return HashCode.Combine(Stream, Response, Url);
+		}
+
+		public static bool operator ==(DirectImage left, DirectImage right) => left.Equals(right);
+
+		public static bool operator !=(DirectImage left, DirectImage right) => !left.Equals(right);
+
+		public void Dispose()
+		{
+			// Stream?.Dispose();
+		}
+
+		public override string ToString()
+		{
+			return $"{Url}";
+		}
+	}
+}

SmartImage.Lib/SearchClient.cs

@@ -214,19 +214,17 @@ public async void FindDirectResults(SearchResult result)
 	{
 		Debug.WriteLine($"searching within {result.Engine.Name}");
 
-		for (int i = 0; i < result.AllResults.Count; i++) {
-			var ir = result.AllResults[i];
-
-			var b = await ir.FindDirectImages();
+		foreach (ImageResult ir in result.AllResults) {
+			var b = await ir.TryScanForDirectImages();
 
 			if (b && !DirectResults.Contains(ir)) {
-				ir.Direct = new Uri(UriUtilities.NormalizeUrl(ir.Direct));
+				ir.Direct.Url = new Uri(UriUtilities.NormalizeUrl(ir.Direct.Url));
 
-				Debug.WriteLine($"{ir.Direct}");
+				Debug.WriteLine($"{nameof(SearchClient)}: Found direct result {ir.Direct.Url}");
 
 				DirectResults.Add(ir);
 
-				result.PrimaryResult.Direct ??= ir.Direct;
+				result.PrimaryResult.Direct.Url ??= ir.Direct.Url;
 
 				DirectFound?.Invoke(null, new DirectResultsFoundEventArgs
 				{
@@ -240,13 +238,12 @@ public async void FindDirectResults(SearchResult result)
 
 	private void FindDirectResults(object state, SearchResult value, int take1 = 10, int take2 = 5)
 	{
-
 		var imageResults = value.AllResults;
 
 		var images = imageResults.AsParallel()
-		                         .Where(x => x.CheckDirect(DirectImageCriterion.Regex))
-		                         .Take(take1)
-		                         .Where(x => x.CheckDirect(DirectImageCriterion.Binary))
+		                         /*.Where(x => x.CheckDirect(DirectImageCriterion.Regex))
+		                         .Take(take1)*/
+		                         .Where(x => x.IsAlreadyDirect(DirectImageCriterion.Binary))
 		                         .Take(take2)
 		                         .ToList();
 
@@ -269,22 +266,27 @@ private void FindDirectResults(object state, SearchResult value, int take1 = 10,
 	/// Waits until <see cref="DirectResults"/> contains any elements
 	/// </summary>
 	/// <returns><see cref="DirectResults"/></returns>
-	public Task<List<ImageResult>> WaitForDirectResults()
+	public Task<bool> WaitForDirectResults()
 	{
 		return Task.Run(() =>
 		{
 			while (Results.Any() && !DirectResults.Any()) {
 				if (IsComplete) {
-					var b = Results.SelectMany(x => x.AllResults.Where(x2 => x2.Direct != null))
+					
+					/*var imageResults = Results.SelectMany(x =>
+					               {
+						               return x.AllResults.Where(x2 => x2.Direct != null);
+					               })
 					               .OrderByDescending(x => x.PixelResolution)
 					               .ToList();
-					DirectResults.AddRange(b);
+
+					DirectResults.AddRange(imageResults);*/
 
 					break;
 				}
 			}
 
-			return DirectResults;
+			return true;
 		});
 	}
 
@@ -307,7 +309,7 @@ public async Task RefineSearchAsync()
 			// return;
 		}
 
-		var direct = directResult.Direct;
+		var direct = directResult.Direct.Url;
 
 		Debug.WriteLine($"{nameof(SearchClient)}: Refining by {direct}", C_DEBUG);
 

SmartImage.Lib/Searching/ImageQuery.cs

@@ -11,6 +11,7 @@
 using SmartImage.Lib.Upload;
 using SmartImage.Lib.Utilities;
 using static Kantan.Diagnostics.LogCategories;
+
 #pragma warning disable CA1416
 namespace SmartImage.Lib.Searching;
 
@@ -84,25 +85,31 @@ public ImageQuery([NotNull] string value, [CanBeNull] BaseUploadEngine engine =
 
 	public static (bool IsUri, bool IsFile) IsUriOrFile(string x)
 	{
-		return (ImageHelper.IsImage(x), File.Exists(x));
+		var isUriOrFile = (ImageHelper.IsImage(x, out var di), File.Exists(x));
+
+		return isUriOrFile;
 	}
 
 	public ImageResult GetImageResult()
 	{
 
 		var result = new ImageResult
 		{
-			Url    = UploadUri,
-			Direct = UploadUri,
-			Image  = Image.FromStream(Stream)
+			Url = UploadUri,
+			Image = Image.FromStream(Stream),
+			Direct =
+			{
+				Stream = Stream,
+				Url = UploadUri
+			}
 		};
 
 		result.OtherMetadata.Add("Upload engine", UploadEngine.Name);
 		result.OtherMetadata.Add("Input type", IsUri ? "URI" : "File");
 		result.OtherMetadata.Add("Input value", Value);
 		result.OtherMetadata.Add("Time", $"(upload: {UploadTime.TotalSeconds:F3})");
 
-		result.UpdateImageData();
+		result.ReloadImageData();
 
 		return result;
 	}

SmartImage.Lib/Searching/ImageResult.cs

@@ -37,12 +37,6 @@ public sealed class ImageResult : IOutline
 	[MaybeNull]
 	public Uri Url { get; set; }
 
-	/// <summary>
-	/// Direct image link of <see cref="Url"/>
-	/// </summary>
-	[CanBeNull]
-	public Uri Direct { get; set; }
-
 	/// <summary>
 	/// Similarity
 	/// </summary>
@@ -196,7 +190,7 @@ private static List<FieldInfo> GetDetailFields()
 	public void UpdateFrom(ImageResult result)
 	{
 		Url         = result.Url;
-		Direct      = result.Direct;
+		Direct.Url      = result.Direct.Url;
 		Similarity  = result.Similarity;
 		Width       = result.Width;
 		Height      = result.Height;
@@ -207,25 +201,30 @@ public void UpdateFrom(ImageResult result)
 		Description = result.Description;
 		Date        = result.Date;
 
-		UpdateImageData();
+		ReloadImageData();
 
 	}
 
-	public async Task<bool> FindDirectImages()
+	public DirectImage Direct { get; internal set; } = new();
+
+	public async Task<bool> TryScanForDirectImages()
 	{
-		if (Url == null || Direct != null) {
+		if (Url == null || Direct.Url != null) {
 			return true;
 		}
 
 		try {
 
 			var directImages = await ImageHelper.ScanForImages(Url.ToString());
 
+			Debug.WriteLine($"{nameof(ImageResult)}: Found {directImages.Count} direct images");
+
 			var direct = directImages.FirstOrDefault();
 
 			if (direct != null) {
-				Direct = new Uri((direct));
-				UpdateImageData();
+				Direct    = direct;
+				Direct.Url =  ((Direct.Url));
+				ReloadImageData();
 				return true;
 			}
 		}
@@ -236,30 +235,31 @@ public async Task<bool> FindDirectImages()
 		return false;
 	}
 
-	public bool CheckDirect(DirectImageCriterion d)
+
+	public bool IsAlreadyDirect(DirectImageCriterion d)
 	{
 		if (Url is not { }) {
 			return false;
 		}
 
 		var s = Url.ToString();
 
-		var b = ImageHelper.IsImage(s, d);
+		var b = ImageHelper.IsImage(s, out var di, d);
 
 		if (b) {
-			Direct = Url;
+			Image = Image.FromStream(di.Stream);
+
+			Direct.Url = Url;
 		}
 
 		return b;
 	}
 
-	public void UpdateImageData()
+	public void ReloadImageData()
 	{
 		if (Image is { }) {
-
 			Width  = Image.Width;
 			Height = Image.Height;
-
 		}
 	}
 
@@ -274,7 +274,7 @@ public Dictionary<string, object> Outline
 			var map = new Dictionary<string, object>
 			{
 				{ nameof(Url), Url },
-				{ nameof(Direct), Direct }
+				{ "Direct Url",Direct.Url }
 			};
 
 			if (Similarity.HasValue) {