private void BtnQueryFromMicrophoneClick(object sender, EventArgs e)
{
DefaultFingerprintConfiguration configuration = new DefaultFingerprintConfiguration();
int secondsToRecord = (int)_nudSecondsToRecord.Value;
int sampleRate = (int)_nudSampleRate.Value;
string pathToFile = "mic_" + DateTime.Now.Ticks + ".wav";
_gbQueryMicrophoneBox.Enabled = false;
Task<float[]>.Factory.StartNew(() => audioService.ReadMonoFromMicrophoneToFile(pathToFile, sampleRate, secondsToRecord)).ContinueWith(
task =>
{
_gbQueryMicrophoneBox.Enabled = true;
WinQueryResults winQueryResults = new WinQueryResults(
secondsToRecord,
0,
(int)_nudHashtables.Value,
(int)_nudKeys.Value,
(int)_nudThreshold.Value,
WinUtils.GetStride((StrideType)_cmbStrideType.SelectedIndex, (int)_nudQueryStrideMax.Value, (int)_nudQueryStrideMin.Value, configuration.SamplesPerFingerprint),
tagService,
modelService,
queryCommandBuilder);
winQueryResults.Show();
winQueryResults.Refresh();
winQueryResults.ExtractCandidatesUsingSamples(task.Result);
},
TaskScheduler.FromCurrentSynchronizationContext());
}
public QueryCommand(IFingerprintCommandBuilder fingerprintCommandBuilder, IQueryFingerprintService queryFingerprintService)
{
this.fingerprintCommandBuilder = fingerprintCommandBuilder;
this.queryFingerprintService = queryFingerprintService;
FingerprintConfiguration = new DefaultFingerprintConfiguration();
QueryConfiguration = new DefaultQueryConfiguration();
}
private void BtnStartClick(object sender, EventArgs e)
{
DefaultFingerprintConfiguration configuration = new DefaultFingerprintConfiguration();
switch (hashAlgorithm)
{
case HashAlgorithm.LSH:
if (!fileList.Any())
{
MessageBox.Show(Resources.SelectFolderWithSongs, Resources.Songs, MessageBoxButtons.OK, MessageBoxIcon.Information);
break;
}
WinQueryResults winQueryResults = new WinQueryResults(
_numSecondsToAnalyze.Enabled ? (int)_numSecondsToAnalyze.Value : 0,
_numStartAtSecond.Enabled ? (int)_numStartAtSecond.Value : 0,
(int)_nudHashtables.Value,
(int)_nudKeys.Value,
Convert.ToInt32(_nudThreshold.Value),
WinUtils.GetStride((StrideType)_cmbStrideType.SelectedIndex, (int)_nudQueryStrideMax.Value, (int)_nudQueryStrideMin.Value, configuration.SamplesPerFingerprint),
tagService,
modelService,
queryCommandBuilder);
winQueryResults.Show();
winQueryResults.Refresh();
winQueryResults.ExtractCandidatesWithMinHashAlgorithm(fileList);
break;
case HashAlgorithm.NeuralHasher:
throw new NotImplementedException();
case HashAlgorithm.None:
throw new NotImplementedException();
}
}
public IQueryCommand WithDefaultConfigs()
{
QueryConfiguration = new DefaultQueryConfiguration();
FingerprintConfiguration = new DefaultFingerprintConfiguration();
createFingerprintMethod = () => fingerprintingMethodFromSelector().WithFingerprintConfig(FingerprintConfiguration);
return(this);
}
public void CreateFingerprintsTest()
{
float[] samples = TestUtilities.GenerateRandomFloatArray(5512 * 10);
var configuration = new DefaultFingerprintConfiguration();
float[][] logarithmizedSpectrum = new[]
{
TestUtilities.GenerateRandomFloatArray(2048),
TestUtilities.GenerateRandomFloatArray(2048),
TestUtilities.GenerateRandomFloatArray(2048)
};
List <float[][]> dividedLogSpectrum = new List <float[][]>
{
new[] { TestUtilities.GenerateRandomFloatArray(2048) },
new[] { TestUtilities.GenerateRandomFloatArray(2048) },
new[] { TestUtilities.GenerateRandomFloatArray(2048) }
};
spectrumService.Setup(service => service.CreateLogSpectrogram(samples, configuration)).Returns(logarithmizedSpectrum);
spectrumService.Setup(service => service.CutLogarithmizedSpectrum(logarithmizedSpectrum, configuration.Stride, configuration.FingerprintLength, configuration.Overlap))
.Returns(dividedLogSpectrum);
waveletDecomposition.Setup(service => service.DecomposeImagesInPlace(dividedLogSpectrum));
fingerprintDescriptor.Setup(descriptor => descriptor.ExtractTopWavelets(It.IsAny <float[][]>(), configuration.TopWavelets)).Returns(GenericFingerprint);
List <bool[]> rawFingerprints = fingerprintService.CreateFingerprints(samples, configuration);
Assert.AreEqual(3, rawFingerprints.Count);
foreach (bool[] fingerprint in rawFingerprints)
{
Assert.AreEqual(GenericFingerprint, fingerprint);
}
}
public void QueryCommandIsBuiltWithCustomFingerprintConfigCorrectly()
{
var customConfig = new DefaultFingerprintConfiguration();
var command = queryCommandBuilder.BuildQueryCommand()
.From("path-to-file", 10, 0)
.WithFingerprintConfig(customConfig)
.UsingServices(modelService.Object, audioService.Object);
Assert.AreSame(command.FingerprintConfiguration, customConfig);
}
public void CreateLogSpectrogramFromSamplesLessThanFourierTransformWindowLength()
{
var configuration = new DefaultFingerprintConfiguration();
float[] samples = TestUtilities.GenerateRandomFloatArray(configuration.WdftSize - 1);
logUtility.Setup(utility => utility.GenerateLogFrequenciesRanges(configuration)).Returns(new int[33]);
float[][] result = spectrumService.CreateLogSpectrogram(samples, configuration);
logUtility.Verify(utility => utility.GenerateLogFrequenciesRanges(configuration), Times.Once());
Assert.AreEqual(0, result.Length); // 128
}
public void CreateFingerprintFromSamplesWhichAreExactlyEqualToMinimumLength()
{
var config = new DefaultFingerprintConfiguration();
var samples = GenerateRandomAudioSamples(config.SamplesPerFingerprint + config.SpectrogramConfig.WdftSize);
var hash = fingerprintCommandBuilder.BuildFingerprintCommand()
.From(samples)
.UsingServices(bassAudioService)
.Hash()
.Result;
Assert.AreEqual(1, hash.Count);
}
public void CreateFingerprintFromSamplesWhichAreExactlyEqualToMinimumLength()
{
DefaultFingerprintConfiguration config = new DefaultFingerprintConfiguration();
float[] samples = TestUtilities.GenerateRandomFloatArray(config.SamplesPerFingerprint + config.WdftSize);
var hash = fingerprintCommandBuilderWithBass
.BuildFingerprintCommand()
.From(samples)
.WithDefaultFingerprintConfig()
.Hash()
.Result;
Assert.AreEqual(1, hash.Count);
}
public void SilenceIsNotFingerprinted()
{
var samples = TestUtilities.GenerateRandomAudioSamples(5512 * 10);
var configuration = new DefaultFingerprintConfiguration();
var dividedLogSpectrum = GetDividedLogSpectrum();
spectrumService.Setup(service => service.CreateLogSpectrogram(samples, It.IsAny <DefaultSpectrogramConfig>())).Returns(dividedLogSpectrum);
waveletDecomposition.Setup(decomposition => decomposition.DecomposeImageInPlace(It.IsAny <float[]>(), 128, 32, configuration.HaarWaveletNorm));
fingerprintDescriptor.Setup(descriptor => descriptor.ExtractTopWavelets(It.IsAny <float[]>(), configuration.TopWavelets, It.IsAny <ushort[]>())).Returns(
new TinyFingerprintSchema(1024));
var rawFingerprints = fingerprintService.CreateFingerprintsFromAudioSamples(samples, configuration);
Assert.IsTrue(!rawFingerprints.Any());
}
public void CutLogarithmizedSpectrumTest()
{
DefaultFingerprintConfiguration config = new DefaultFingerprintConfiguration();
const int LogSpectrumLength = 1024;
var stride = new StaticStride(0, 0);
var logSpectrum = new float[LogSpectrumLength][];
for (int i = 0; i < LogSpectrumLength; i++)
{
logSpectrum[i] = new float[32];
}
var cutLogarithmizedSpectrum = spectrumService.CutLogarithmizedSpectrum(logSpectrum, stride, config.FingerprintLength, config.Overlap);
Assert.AreEqual(8, cutLogarithmizedSpectrum.Count);
}
public void CutLogarithmizedSpectrumWithAnIncrementalStaticStride()
{
DefaultFingerprintConfiguration config = new DefaultFingerprintConfiguration();
int logSpectrumLength = (config.FingerprintLength * 24) + config.Overlap;
var stride = new IncrementalStaticStride(config.SamplesPerFingerprint / 2, config.SamplesPerFingerprint, 0);
var logSpectrum = new float[logSpectrumLength][];
for (int i = 0; i < logSpectrumLength; i++)
{
logSpectrum[i] = new float[32];
}
var cutLogarithmizedSpectrum = spectrumService.CutLogarithmizedSpectrum(logSpectrum, stride, config.FingerprintLength, config.Overlap);
Assert.AreEqual(48, cutLogarithmizedSpectrum.Count);
}
public void CutLogarithmizedSpectrumWithSpectrumWhichIsLessThanMinimalLengthOfOneFingerprintTest()
{
DefaultFingerprintConfiguration config = new DefaultFingerprintConfiguration();
int logSpectrumLength = config.FingerprintLength - 1;
var stride = new StaticStride(0, 0);
var logSpectrum = new float[logSpectrumLength][];
for (int i = 0; i < logSpectrumLength; i++)
{
logSpectrum[i] = new float[32];
}
var cutLogarithmizedSpectrum = spectrumService.CutLogarithmizedSpectrum(logSpectrum, stride, config.FingerprintLength, config.Overlap);
Assert.AreEqual(0, cutLogarithmizedSpectrum.Count);
}
public void AudioSamplesAreNormalized()
{
const int TenSeconds = 5512 * 10;
var samples = TestUtilities.GenerateRandomAudioSamples(TenSeconds);
var fingerprintConfig = new DefaultFingerprintConfiguration {
NormalizeSignal = true
};
var dividedLogSpectrum = GetDividedLogSpectrum();
spectrumService.Setup(service => service.CreateLogSpectrogram(samples, It.IsAny <DefaultSpectrogramConfig>())).Returns(dividedLogSpectrum);
waveletDecomposition.Setup(service => service.DecomposeImageInPlace(It.IsAny <float[][]>()));
fingerprintDescriptor.Setup(descriptor => descriptor.ExtractTopWavelets(It.IsAny <float[][]>(), fingerprintConfig.TopWavelets))
.Returns(GenericFingerprint);
audioSamplesNormalizer.Setup(normalizer => normalizer.NormalizeInPlace(samples.Samples));
fingerprintService.CreateFingerprints(samples, fingerprintConfig);
}
public void SilenceIsNotFingerprinted()
{
var samples = TestUtilities.GenerateRandomAudioSamples(5512 * 10);
var configuration = new DefaultFingerprintConfiguration();
var spectrogramConfig = SpectrogramConfig.Default;
var dividedLogSpectrum = GetDividedLogSpectrum();
spectrumService.Setup(service => service.CreateLogSpectrogram(samples, spectrogramConfig)).Returns(dividedLogSpectrum);
waveletDecomposition.Setup(decomposition => decomposition.DecomposeImageInPlace(It.IsAny <float[][]>()));
fingerprintDescriptor.Setup(descriptor => descriptor.ExtractTopWavelets(It.IsAny <float[][]>(), configuration.TopWavelets)).Returns(
new[] { false, false, false, false, false, false, false, false });
var rawFingerprints = fingerprintService.CreateFingerprints(samples, configuration);
Assert.IsTrue(rawFingerprints.Count == 0);
}
public void ShouldCalculateQueryLengthCorrectly()
{
var config = new DefaultFingerprintConfiguration();
float delta = 0.05f;
int runs = 1000;
var bag = new ConcurrentBag <HashedFingerprint>();
Parallel.For(0, runs, i =>
{
var hashed = new HashedFingerprint(new int[0], (uint)i, i * delta);
bag.Add(hashed);
});
double length = bag.QueryLength(config);
Assert.AreEqual(length, delta * (runs - 1) + config.FingerprintLengthInSeconds, 0.0001);
}
public void ShoudUseCorrectFingerprintConfigurationIsUsedWithInstanceConfig()
{
const string PathToAudioFile = "path-to-audio-file";
var configuration = new DefaultFingerprintConfiguration {
SpectrogramConfig = new DefaultSpectrogramConfig {
ImageLength = 1234
}
};
var fingerprintCommand = fingerprintCommandBuilder.BuildFingerprintCommand()
.From(PathToAudioFile)
.WithFingerprintConfig(configuration)
.UsingServices(audioService.Object);
Assert.AreSame(configuration, fingerprintCommand.FingerprintConfiguration);
Assert.AreEqual(configuration.SpectrogramConfig.ImageLength, fingerprintCommand.FingerprintConfiguration.SpectrogramConfig.ImageLength);
}
public void ShouldSaveOriginalPoints()
{
var random = new Random();
var frames = Enumerable.Range(0, 100)
.Select(index =>
{
byte[] bytes = new byte[128 * 72 * sizeof(float)];
random.NextBytes(bytes);
float[] frame = new float[128 * 72];
Buffer.BlockCopy(bytes, 0, frame, 0, bytes.Length);
return(new Frame(frame, 128, 72, (float)index / 30, (uint)index));
})
.ToList();
var fs = new Frames(frames.Select(frame => new Frame(frame.GetImageRowColsCopy(), frame.Rows, frame.Cols, frame.StartsAt, frame.SequenceNumber)), string.Empty, 30);
var config = new DefaultFingerprintConfiguration
{
FrameNormalizationTransform = new NoFrameNormalization(),
GaussianBlurConfiguration = GaussianBlurConfiguration.None,
OriginalPointSaveTransform = frame =>
{
byte[] original = new byte[frame.Length * sizeof(float)];
Buffer.BlockCopy(frame.ImageRowCols, 0, original, 0, original.Length);
return(original);
}
};
var hashes = FingerprintService.Instance.CreateFingerprintsFromImageFrames(fs, config);
Assert.AreEqual(hashes.Count, frames.Count);
var originalPoints = hashes
.OrderBy(_ => _.SequenceNumber)
.Select(_ => _.OriginalPoint)
.Select(point =>
{
float[] pt = new float[point.Length / 4];
Buffer.BlockCopy(point, 0, pt, 0, point.Length);
return(pt);
})
.ToList();
CollectionAssert.AreEqual(frames.Select(_ => _.ImageRowCols).ToList(), originalPoints);
}
public void CreateFingerprints()
{
const int tenSeconds = 5512 * 10;
var samples = TestUtilities.GenerateRandomAudioSamples(tenSeconds);
var fingerprintConfig = new DefaultFingerprintConfiguration();
var dividedLogSpectrum = GetDividedLogSpectrum();
spectrumService.Setup(service => service.CreateLogSpectrogram(samples, It.IsAny <DefaultSpectrogramConfig>())).Returns(dividedLogSpectrum);
waveletDecomposition.Setup(service => service.DecomposeImageInPlace(It.IsAny <float[]>(), 128, 32, fingerprintConfig.HaarWaveletNorm));
fingerprintDescriptor.Setup(descriptor => descriptor.ExtractTopWavelets(It.IsAny <float[]>(), fingerprintConfig.TopWavelets, It.IsAny <ushort[]>())).Returns(new TinyFingerprintSchema(8192).SetTrueAt(0, 1));
localitySensitiveHashingAlgorithm.Setup(service => service.Hash(It.IsAny <Fingerprint>(), fingerprintConfig.HashingConfig))
.Returns(new HashedFingerprint(new int[0], 1, 0f, Array.Empty <byte>()));
var fingerprints = fingerprintService.CreateFingerprintsFromAudioSamples(samples, fingerprintConfig)
.OrderBy(f => f.SequenceNumber)
.ToList();
Assert.AreEqual(dividedLogSpectrum.Count, fingerprints.Count);
}
public async Task CreateFingerprintsFromFileAndAssertNumberOfFingerprints()
{
const int staticStride = 5096;
var fingerprintConfiguration = new DefaultFingerprintConfiguration {
Stride = new IncrementalStaticStride(staticStride)
};
var command = FingerprintCommandBuilder.Instance.BuildFingerprintCommand()
.From(PathToWav)
.WithFingerprintConfig(fingerprintConfiguration)
.UsingServices(audioService);
double seconds = audioService.GetLengthInSeconds(PathToWav);
int samples = (int)(seconds * fingerprintConfiguration.SampleRate);
int expectedFingerprints = (samples - fingerprintConfiguration.SamplesPerFingerprint) / staticStride;
var fingerprints = await command.Hash();
Assert.AreEqual(expectedFingerprints, fingerprints.Count);
}
public void CreateFingerprints()
{
const int TenSeconds = 5512 * 10;
var samples = TestUtilities.GenerateRandomAudioSamples(TenSeconds);
var fingerprintConfig = new DefaultFingerprintConfiguration();
var dividedLogSpectrum = GetDividedLogSpectrum();
spectrumService.Setup(service => service.CreateLogSpectrogram(samples, It.IsAny <DefaultSpectrogramConfig>())).Returns(dividedLogSpectrum);
waveletDecomposition.Setup(service => service.DecomposeImageInPlace(It.IsAny <float[][]>()));
fingerprintDescriptor.Setup(descriptor => descriptor.ExtractTopWavelets(It.IsAny <float[][]>(), fingerprintConfig.TopWavelets))
.Returns(GenericFingerprint);
var fingerprints = fingerprintService.CreateFingerprints(samples, fingerprintConfig);
Assert.AreEqual(dividedLogSpectrum.Count, fingerprints.Count);
for (int index = 0; index < fingerprints.Count; index++)
{
Assert.AreEqual(GenericFingerprint, fingerprints[index].Signature);
Assert.AreEqual(dividedLogSpectrum[index].Timestamp, fingerprints[index].Timestamp, Epsilon);
}
}
public void FingerprintConfigurationInheritsDefaultValues()
{
var customConfiguration = new CustomFingerprintConfiguration();
var defaultConfiguration = new DefaultFingerprintConfiguration();
Assert.AreEqual(defaultConfiguration.FingerprintLength, customConfiguration.FingerprintLength);
Assert.AreEqual(defaultConfiguration.LogBase, customConfiguration.LogBase);
Assert.AreEqual(defaultConfiguration.LogBins, customConfiguration.LogBins);
Assert.AreEqual(defaultConfiguration.MaxFrequency, customConfiguration.MaxFrequency);
Assert.AreEqual(defaultConfiguration.MinFrequency, customConfiguration.MinFrequency);
Assert.AreEqual(defaultConfiguration.NormalizeSignal, customConfiguration.NormalizeSignal);
Assert.AreEqual(defaultConfiguration.NumberOfLSHTables, customConfiguration.NumberOfLSHTables);
Assert.AreEqual(defaultConfiguration.NumberOfMinHashesPerTable, customConfiguration.NumberOfMinHashesPerTable);
Assert.AreEqual(defaultConfiguration.Overlap, customConfiguration.Overlap);
Assert.AreEqual(defaultConfiguration.SampleRate, customConfiguration.SampleRate);
Assert.AreEqual(defaultConfiguration.SamplesPerFingerprint, customConfiguration.SamplesPerFingerprint);
Assert.IsTrue(defaultConfiguration.Stride.GetType() == customConfiguration.Stride.GetType());
Assert.AreEqual(defaultConfiguration.TopWavelets, customConfiguration.TopWavelets);
Assert.AreEqual(defaultConfiguration.UseDynamicLogBase, customConfiguration.UseDynamicLogBase);
Assert.AreEqual(defaultConfiguration.WdftSize, customConfiguration.WdftSize);
}
public void ShouldSerializeDeserializeSameArray()
{
var fingerprintService = FingerprintService.Instance;
var image = GetOneImage();
var configuration = new DefaultFingerprintConfiguration
{
FrameNormalizationTransform = new NoFrameNormalization(),
OriginalPointSaveTransform = EncodeFrame
};
var hashes = fingerprintService.CreateFingerprintsFromImageFrames(new Frames(new[] { new Frame(image, 0, 0) }, string.Empty, 30), configuration);
var decodedFrame = DecodeFrame(hashes.First().OriginalPoint);
Assert.AreEqual(image.Length, decodedFrame.Length);
for (int i = 0; i < image.Length; ++i)
{
CollectionAssert.AreEqual(image[i], decodedFrame[i]);
}
}
public void ShouldRunCorrectlyForSpecificUseCase()
{
int sequenceNumber = 334;
float[] samples = GetAudioSamples().Samples;
int start = sequenceNumber * 1536;
float[] troubledPart = new float[8192 + 2048];
Array.Copy(samples, start, troubledPart, 0, 8192 + 2048);
var audioSamples = new AudioSamples(troubledPart, "test", 5512);
var fingerprintService = new FingerprintService(
new SpectrumService(new LomontFFT(), new LogUtility()),
LocalitySensitiveHashingAlgorithm.Instance,
new StandardHaarWaveletDecomposition(),
new FingerprintDescriptor());
var fastFingerprintService = new FingerprintService(
new SpectrumService(new LomontFFT(), new LogUtility()),
LocalitySensitiveHashingAlgorithm.Instance,
new StandardHaarWaveletDecomposition(),
new FastFingerprintDescriptor());
int runs = 10;
var configuration = new DefaultFingerprintConfiguration();
for (int i = 0; i < runs; ++i)
{
var x = fingerprintService.CreateFingerprintsFromAudioSamples(audioSamples, configuration).ToList();
var y = fastFingerprintService.CreateFingerprintsFromAudioSamples(audioSamples, configuration).ToList();
for (int j = 0; j < x.Count; ++j)
{
CollectionAssert.AreEqual(x[j].HashBins, y[j].HashBins);
}
}
}
public IUsingQueryServices WithDefaultConfigs()
{
QueryConfiguration = new DefaultQueryConfiguration();
FingerprintConfiguration = new DefaultFingerprintConfiguration();
return(this);
}
internal FingerprintCommand(IFingerprintService fingerprintService, ILocalitySensitiveHashingAlgorithm lshAlgorithm)
{
this.fingerprintService = fingerprintService;
this.lshAlgorithm = lshAlgorithm;
FingerprintConfiguration = new DefaultFingerprintConfiguration();
}
internal FingerprintCommand(IFingerprintService fingerprintService)
{
this.fingerprintService = fingerprintService;
FingerprintConfiguration = new DefaultFingerprintConfiguration();
}
