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