private static float GetGapSize(ResultEntry left, float fingerprintLength) { var lastMatch = left.Coverage.BestPath.Last(); float endsAt = lastMatch.QueryMatchAt + fingerprintLength; return((float)left.Coverage.QueryLength - endsAt); }
private static double CalculateNewQueryLength(ResultEntry a, ResultEntry b) { if (Math.Abs(a.TrackMatchStartsAt - b.TrackMatchStartsAt) < 0.0001) { // same start return(a.QueryLength); } // t -------------- // a --------- // b -------- if (a.TrackMatchStartsAt > b.TrackMatchStartsAt) { double diff = a.TrackMatchStartsAt - b.TrackMatchStartsAt; if (diff > b.TrackMatchStartsAt) { return(a.QueryLength + b.QueryLength); } return(diff + a.QueryLength); } else { // t ------------- // a ------ // b ----- double diff = b.TrackMatchStartsAt - a.TrackMatchStartsAt; if (diff > a.QueryLength) { return(a.QueryLength + b.QueryLength); } return(diff + b.QueryLength); } }
public static ResultEntry MergeWith(this ResultEntry entry, ResultEntry with) { if (!entry.Track.Equals(with.Track)) { throw new ArgumentException($"{nameof(with)} merging entries should correspond to the same track"); } double avgConfidence = Math.Min((entry.Confidence + with.Confidence) / 2, 1d); var queryMatchStartsAt = entry.TrackMatchStartsAt < with.TrackMatchStartsAt ? entry.QueryMatchStartsAt : with.QueryMatchStartsAt; var trackMatchStartsAt = entry.TrackMatchStartsAt < with.TrackMatchStartsAt ? entry.TrackMatchStartsAt : with.TrackMatchStartsAt; var trackStartsAt = entry.TrackMatchStartsAt < with.TrackMatchStartsAt ? entry.TrackStartsAt : with.TrackStartsAt; var matchedAt = entry.MatchedAt < with.MatchedAt ? entry.MatchedAt : with.MatchedAt; return(new ResultEntry(entry.Track, avgConfidence, entry.Score + with.Score, matchedAt, CalculateNewQueryLength(entry, with), queryMatchStartsAt, CalculateNewQueryCoverage(entry, with), CalculateNewMatchLength(entry, with), trackMatchStartsAt, trackStartsAt)); }
public PendingResultEntry Wait(double length) { var newCoverage = new Coverage(Entry.Coverage.BestPath, Entry.QueryLength + length, Entry.Coverage.TrackLength, Entry.Coverage.FingerprintLength, Entry.Coverage.PermittedGap); var resultEntry = new ResultEntry(Entry.Track, Entry.Score, Entry.MatchedAt, newCoverage); return(new PendingResultEntry(resultEntry, waiting + length)); }
public PendingResultEntry Wait(double length) { var newQueryLength = Entry.QueryLength + length; var resultEntry = new ResultEntry(Entry.Track, Entry.Confidence, Entry.Score, Entry.MatchedAt, newQueryLength, Entry.QueryMatchStartsAt, Entry.CoverageWithPermittedGapsLength, Entry.DiscreteCoverageLength, Entry.TrackMatchStartsAt, Entry.TrackStartsAt); return(new PendingResultEntry(resultEntry, waiting + length)); }
public ResultEntry Validate( ResultEntry result, IStride validationStride, string pathToAudioFile, IModelService modelService, IAudioService audioService, int topWavelets, int thresholdVotes) { double startAt = result.TrackStartsAt, length = result.QueryLength - result.TrackStartsAt; if (startAt + result.Track.Length < result.QueryLength) { length = result.Track.Length; } var newResult = queryCommandBuilder.BuildQueryCommand() .From(pathToAudioFile, length, startAt).WithConfigs( config => { config.Stride = validationStride; config.TopWavelets = topWavelets; }, queryConfig => { queryConfig.ThresholdVotes = thresholdVotes; }) .UsingServices(modelService, audioService) .Query() .Result; if (!newResult.ContainsMatches) { return(result); } var newEntry = newResult.BestMatch; if (newEntry.Confidence > result.Confidence) { return(new ResultEntry( newEntry.Track, newEntry.QueryMatchStartsAt, newEntry.QueryMatchLength, newEntry.TrackMatchStartsAt, newEntry.TrackStartsAt + result.TrackStartsAt, newEntry.Confidence, newEntry.HammingSimilaritySum, newEntry.QueryLength, newEntry.BestMatch)); } return(result); }
private static ResultEntry MergeWith(ResultEntry entry, ResultEntry with) { if (!entry.Track.Equals(with.Track)) { throw new ArgumentException($"{nameof(with)} merging entries should correspond to the same track"); } var mergedCoverage = MergeWith(entry.Coverage, with.Coverage); var matchedAt = entry.MatchedAt < with.MatchedAt ? entry.MatchedAt : with.MatchedAt; return(new ResultEntry(entry.Track, entry.Score + with.Score, matchedAt, mergedCoverage)); }
private static double CalculateNewMatchLength(ResultEntry a, ResultEntry b) { var first = a.TrackMatchStartsAt <= b.TrackMatchStartsAt ? a : b; var second = a.TrackMatchStartsAt <= b.TrackMatchStartsAt ? b : a; if (first.TrackMatchStartsAt + first.DiscreteCoverageLength >= second.TrackMatchStartsAt + second.DiscreteCoverageLength) { return(first.DiscreteCoverageLength); } if (first.TrackMatchStartsAt <= second.TrackMatchStartsAt && first.TrackMatchStartsAt + first.DiscreteCoverageLength >= second.TrackMatchStartsAt) { return(second.DiscreteCoverageLength - first.TrackMatchStartsAt + second.TrackMatchStartsAt); } return(first.DiscreteCoverageLength + second.DiscreteCoverageLength); }
public ResultEntry Validate( ResultEntry result, IStride validationStride, string pathToAudioFile, IModelService modelService, IAudioService audioService) { double startAt = result.TrackStartsAt, length = result.QueryLength - result.TrackStartsAt; if (startAt + result.Track.Length < result.QueryLength) { length = result.Track.Length; } var newResult = queryCommandBuilder.BuildQueryCommand() .From(pathToAudioFile, length, startAt) .WithFingerprintConfig(config => config.Stride = validationStride) .UsingServices(modelService, audioService) .Query() .Result; if (!newResult.ContainsMatches) { return result; } var newEntry = newResult.BestMatch; if (newEntry.Confidence > result.Confidence) { return new ResultEntry( newEntry.Track, newEntry.QueryMatchStartsAt, newEntry.QueryMatchLength, newEntry.TrackMatchStartsAt, newEntry.TrackStartsAt + result.TrackStartsAt, newEntry.Confidence, newEntry.HammingSimilaritySum, newEntry.QueryLength, newEntry.BestMatch); } return result; }
private RealtimeQueryResult PurgeCompleted(IEnumerable <ResultEntry> entries, double queryLength, double queryOffset) { var set = new HashSet <string>(entries.Select(_ => _.Track.Id)); foreach (var entry in trackEntries.Where(_ => !set.Contains(_.Key))) { var old = entry.Value; var updated = new ResultEntry(old.Track, old.Score, old.MatchedAt, new Coverage(old.Coverage.BestPath, old.Coverage.QueryLength + queryLength + queryOffset, old.Coverage.TrackLength, old.Coverage.FingerprintLength, old.Coverage.PermittedGap)); trackEntries.TryUpdate(entry.Key, updated, old); } var completed = new List <ResultEntry>(); var cantWaitAnymore = new HashSet <ResultEntry>(); foreach (KeyValuePair <string, ResultEntry> pair in trackEntries) { if (!completionStrategy.CanContinueInNextQuery(pair.Value) && trackEntries.TryRemove(pair.Key, out var entry)) { // can't continue in the next query if (realtimeResultEntryFilter.Pass(entry, false)) { // passed entry filter completed.Add(entry); } else { // did not pass filter cantWaitAnymore.Add(entry); } } else if (realtimeResultEntryFilter.Pass(pair.Value, true) && trackEntries.TryRemove(pair.Key, out _)) { // can continue, but realtime result entry filter takes precedence completed.Add(pair.Value); } } return(new RealtimeQueryResult(Sorted(completed), Sorted(cantWaitAnymore))); }
private static double CalculateNewQueryCoverage(ResultEntry a, ResultEntry b) { var first = a.TrackMatchStartsAt <= b.TrackMatchStartsAt ? a : b; var second = a.TrackMatchStartsAt <= b.TrackMatchStartsAt ? b : a; if (first.TrackMatchStartsAt + first.CoverageWithPermittedGapsLength >= second.TrackMatchStartsAt + second.CoverageWithPermittedGapsLength) { // a --------- // b ----- return(first.CoverageWithPermittedGapsLength); } if (first.TrackMatchStartsAt <= second.TrackMatchStartsAt && first.TrackMatchStartsAt + first.CoverageWithPermittedGapsLength >= second.TrackMatchStartsAt) { // a ------- // b ------- return(second.CoverageWithPermittedGapsLength - first.TrackMatchStartsAt + second.TrackMatchStartsAt); } // a ------- // b ------ // not glued on purpose return(first.CoverageWithPermittedGapsLength + second.CoverageWithPermittedGapsLength); }
private bool ContainsSequenceInfo(ResultEntry bestMatch) { return(!bestMatch.SequenceStart.Equals(0) && !bestMatch.SequenceLength.Equals(0)); }
public PendingResultEntry(ResultEntry entry, double waiting = 0) { Entry = entry; InternalUid = Guid.NewGuid().ToString(); this.waiting = waiting; }
private bool CanSwallow(ResultEntry next) { return(Entry.TrackMatchStartsAt <= next.TrackMatchStartsAt && TrackMatchEndsAt >= next.TrackMatchStartsAt + next.CoverageWithPermittedGapsLength); }
private bool TrackMatchOverlaps(ResultEntry next, double permittedGap) { return(TrackMatchEndsAt >= next.TrackMatchStartsAt - permittedGap && next.TrackMatchStartsAt + permittedGap >= TrackMatchEndsAt); }
private bool ContainsSequenceInfo(ResultEntry bestMatch) { return !bestMatch.SequenceStart.Equals(0) && !bestMatch.SequenceLength.Equals(0); }