public async Task <List <DeDupifyrResult> > Run(ComparisonRequest request) { Console.WriteLine($"Searching {(comparisonOptions.DirectorySearchOption == SearchOption.TopDirectoryOnly ? "only" : "the top of, and all sub directories, ")} in {request.DirectoryPath.Value}..."); var imageFileBuilders = ImageBuildersFromDirectory(request.DirectoryPath.Value, file => ValidExtensions.ForImage.Contains(Path.GetExtension(file))); #if DEBUG var sw = Stopwatch.StartNew(); #endif // Fire off all the tasks to build the LocalImages array, and wait for them all to complete. // Doing it this way means that we only have to wait as long as the longest running builder, // instead of having to wait for each one additively. var images = await Task.WhenAll(imageFileBuilders); #if DEBUG sw.Stop(); Console.WriteLine($"Took {sw.ElapsedMilliseconds} ms to run all image builders."); #endif Console.WriteLine($"Checking {images.Count()} files in '{request.DirectoryPath.Value}'..."); #if DEBUG sw.Restart(); #endif await CheckForDuplicates(images); #if DEBUG sw.Stop(); Console.WriteLine($"Took {sw.ElapsedMilliseconds} ms to check all duplicates."); #endif return(duplicateResults); }
/// <summary> /// Construct the comparison object that we'll be using for this current run. Once /// we have it, we need only call the `Run` method on the result. /// </summary> /// <param name="fromRequest"><see cref="ComparisonRequest"/>: The representation of the current request.</param> /// <param name="withOptions"><see cref="ComparisonOptions"/>: The options that will be used for the request.</param> /// <returns>The comparison object, that will handle the current request.</returns> /// <exception cref="ArgumentOutOfRangeException">Throws if we get a <see cref="ComparisonWith"/> /// value that isn't recognized.</exception> public ICompareImages Construct(ComparisonRequest fromRequest, ComparisonOptions withOptions) { ICompareImages imageComparer; switch (fromRequest.With) { case ComparisonWith.All: imageComparer = new DirectoryComparison( new BasicHashProvider(), new HashComparison(withOptions.BiasPercent), withOptions); break; case ComparisonWith.Pair: imageComparer = new PairComparison( new BasicHashProvider(), new PixelComparison(withOptions), withOptions); break; case ComparisonWith.Single: imageComparer = new SingleComparison( new BasicHashProvider(), new HashComparison(withOptions.BiasPercent), withOptions); break; default: throw new ArgumentOutOfRangeException(); } return(imageComparer); }
public async Task <List <DeDupifyrResult> > Run(ComparisonRequest request) { // If the paths are equal, print that we were given the same image path. if (request.FirstImagePath.Value == request.SecondImagePath.Value) { Console.WriteLine("The two paths given point to the same image."); } Console.WriteLine($"Comparing images at {request.FirstImagePath.Value} and {request.SecondImagePath.Value}..."); var sourceImage = await BuildLocalImage(request.FirstImagePath.Value); var targetImage = await BuildLocalImage(request.SecondImagePath.Value); var duplicateResult = new DeDupifyrResult(sourceImage); await UpdateDuplicationCollection( sourceImage, targetImage, duplicateResult.Duplicates); duplicateResults.Add(duplicateResult); return(duplicateResults); }
/// <summary> /// Compare position and size from a comparison request. /// </summary> /// <param name="comparisonRequest">hashs object</param> /// <returns>Return objetct with compasion results</returns> private DiffResultDTO Diff(ComparisonRequest comparisonRequest) { var result = new DiffResultDTO { Id = comparisonRequest.Id, Right = comparisonRequest.Right, Left = comparisonRequest.Left }; // Comparing positions if (comparisonRequest.Left.Equals(comparisonRequest.Right)) { result.Equal = true; } // Comparing sizes result.SameSize = comparisonRequest.Right.Length == comparisonRequest.Left.Length; if (!result.SameSize) { return(result); } // Collecting Differences between both hashs result.DiffInsights = GetDiffInsights(result.Left, result.Right); return(result); }
private void UpdateComparisonRequest(Side side, string data, ComparisonRequest comparisonRequest) { comparisonRequest.Left = side == Side.Left ? data : comparisonRequest.Left; comparisonRequest.Right = side == Side.Right ? data : comparisonRequest.Right; diffRepository.Update(comparisonRequest); diffRepository.SaveChanges(); }
public ExecutionStatus ConstructUpdated(ComparisonRequest original, ComparisonOptions updatedOptions) { var statusBuilder = InitialBuilder(original); return(statusBuilder .OverridesOptionsWith(updatedOptions) .Build()); }
public ExecutionStatus ConstructSuccess( ComparisonRequest original, Option <List <DeDupifyrResult> > results, Action printInstructions) { var statusBuilder = InitialBuilder(original); return(statusBuilder .HasResults(results) .WithPrintInstructions(printInstructions) .Build()); }
private async Task InsertComparisonRequest(long id, Side side, string data) { var comparisonRequest = new ComparisonRequest { Id = id, Left = side == Side.Left ? data : null, Right = side == Side.Right ? data : null }; await diffRepository.Insert(comparisonRequest); await diffRepository.SaveChangesAsync(); }
public IActionResult SimpleComparison([FromBody] ComparisonRequest request) { try { //var matches = new Dictionary<string, IList<Match>>(); var matches = new List <MatchResult>(); var submissions = request.Submissions.Select( s => new StudentSequence() { FirstName = s.FirstName, LastName = s.LastName, TokenSequence = CreateCombinedSequence(s) }).ToList(); // compare every submission with every other submission foreach (var curSequence in submissions) { foreach (var otherSequence in submissions) { var tmpResult = new MatchResult( new Student(curSequence.FirstName, curSequence.LastName), new Student(otherSequence.FirstName, otherSequence.LastName)); if (curSequence == otherSequence) { continue; } var match = GstComparator.Compare <int>(curSequence.TokenSequence, otherSequence.TokenSequence, 9) .OrderBy(m => m.PatternIndex) .ToList(); tmpResult.Matches = match; if (match != null && match.Count > 0) { matches.Add(tmpResult); } //matches.Add($"{curSequence.Name} - {otherSequence.Name}", match); curSequence.TokenSequence.Reset(); otherSequence.TokenSequence.Reset(); } } return(new ObjectResult(matches)); } catch (Exception) { return(new BadRequestObjectResult("Invalid request format")); } }
public async Task <List <DeDupifyrResult> > Run(ComparisonRequest request) { Console.WriteLine($"Comparing the image at '{request.FirstImagePath.Value}' with all images in '{request.DirectoryPath.Value}'..."); var sourceImage = await BuildLocalImage(request.FirstImagePath.Value); var otherImageBuilders = ImageBuildersFromDirectory( request.DirectoryPath.Value, file => ValidExtensions.ForImage.Contains(Path.GetExtension(file)) && file != request.FirstImagePath.Value); var otherImages = await Task.WhenAll(otherImageBuilders); var duplicateResult = new DeDupifyrResult(sourceImage); var duplicateImages = await CompareToOthers(sourceImage, otherImages); duplicateResult.Duplicates.AddRange(duplicateImages); duplicateResults.Add(duplicateResult); return(duplicateResults); }
ExecutionStatusBuilder InitialBuilder(ComparisonRequest original) { return(new ExecutionStatusBuilder() .WithOriginalRequest(original)); }
public ExecutionStatusBuilder WithOriginalRequest(ComparisonRequest request) { originalRequest = request; return(this); }