public void TestDecibelSpectrogram()
{
var recording = new AudioRecording(PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav"));
// specfied linear scale
var freqScale = new FrequencyScale(nyquist: 11025, frameSize: 1024, hertzGridInterval: 1000);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
// DO EQUALITY TEST on the AMPLITUDE SONGOGRAM DATA
// Do not bother with the image because this is only an amplitude spectrogram.
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
// DO FILE EQUALITY TEST on the DECIBEL SONGOGRAM DATA
// Do not bother with the image because this has been tested elsewhere.
var decibelSonogram = MFCCStuff.DecibelSpectra(sonogram.Data, sonogram.Configuration.WindowPower, sonogram.SampleRate, sonogram.Configuration.epsilon);
var expectedFile = PathHelper.ResolveAsset("StandardSonograms", "BAC2_20071008_DecibelSonogramData.EXPECTED.bin");
// run this once to generate expected test data
// uncomment this to update the binary data. Should be rarely needed
// AT: Updated 2017-02-15 because FFT library changed in 864f7a491e2ea0e938161bd390c1c931ecbdf63c
//Binary.Serialize(expectedFile, decibelSonogram);
var expected = Binary.Deserialize <double[, ]>(expectedFile);
CollectionAssert.That.AreEqual(expected, decibelSonogram, EnvelopeAndFftTests.Delta);
}
public static Image <Rgb24> GetLcnSpectrogram(
SonogramConfig sonoConfig,
AudioRecording recordingSegment,
string sourceRecordingName,
double neighbourhoodSeconds,
double lcnContrastLevel)
{
BaseSonogram sonogram = new AmplitudeSonogram(sonoConfig, recordingSegment.WavReader);
int neighbourhoodFrames = (int)(sonogram.FramesPerSecond * neighbourhoodSeconds);
LoggedConsole.WriteLine("LCN: FramesPerSecond (Prior to LCN) = {0}", sonogram.FramesPerSecond);
LoggedConsole.WriteLine("LCN: Neighbourhood of {0} seconds = {1} frames", neighbourhoodSeconds, neighbourhoodFrames);
// subtract the lowest 20% of frames. This is first step in LCN noise removal. Sets the baseline.
const int lowPercentile = 20;
sonogram.Data =
NoiseRemoval_Briggs.NoiseReduction_byLowestPercentileSubtraction(sonogram.Data, lowPercentile);
sonogram.Data =
NoiseRemoval_Briggs.NoiseReduction_byLCNDivision(sonogram.Data, neighbourhoodFrames, lcnContrastLevel);
//Matrix normalisation
//MatrixTools.PercentileCutoffs(sonogram.Data, 10.0, 90, out double minCut, out double maxCut);
//NoiseRemoval_Briggs.NoiseReduction_byLowestPercentileSubtraction(sonogram.Data, lowPercentile);
var image = sonogram.GetImageFullyAnnotated(
"AMPLITUDE SPECTROGRAM with freq bin Local Contrast Normalization - " + sourceRecordingName,
ImageTags[AmplitudeSpectrogramLocalContrastNormalization]);
return(image);
}
private void WriteDebugImage(
AudioRecording recording,
DirectoryInfo outputDirectory,
BaseSonogram sonogram,
List <AcousticEvent> acousticEvents,
List <Plot> plots,
double[,] hits)
{
//DEBUG IMAGE this recogniser only. MUST set false for deployment.
bool displayDebugImage = MainEntry.InDEBUG;
if (displayDebugImage)
{
Image debugImage1 = SpectrogramTools.GetSonogramPlusCharts(sonogram, acousticEvents, plots, hits);
var debugPath1 = outputDirectory.Combine(FilenameHelpers.AnalysisResultName(Path.GetFileNameWithoutExtension(recording.BaseName), this.Identifier, "png", "DebugSpectrogram1"));
debugImage1.Save(debugPath1.FullName);
// save new image with longer frame
var sonoConfig2 = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = 1024,
WindowOverlap = 0,
//NoiseReductionType = NoiseReductionType.NONE,
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.1,
};
BaseSonogram sonogram2 = new SpectrogramStandard(sonoConfig2, recording.WavReader);
var debugPath2 = outputDirectory.Combine(FilenameHelpers.AnalysisResultName(Path.GetFileNameWithoutExtension(recording.BaseName), this.Identifier, "png", "DebugSpectrogram2"));
Image debugImage2 = SpectrogramTools.GetSonogramPlusCharts(sonogram2, acousticEvents, plots, null);
debugImage2.Save(debugPath2.FullName);
}
}
public void SonogramDecibelMethodsAreEquivalent()
{
var recording = new AudioRecording(PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav"));
// specfied linear scale
var freqScale = new FrequencyScale(nyquist: 11025, frameSize: 1024, hertzGridInterval: 1000);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
// Method 1
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
var expectedDecibelSonogram = MFCCStuff.DecibelSpectra(sonogram.Data, sonogram.Configuration.WindowPower, sonogram.SampleRate, sonogram.Configuration.epsilon);
// Method 2: make sure that the decibel spectrum is the same no matter which path we take to calculate it.
var actualDecibelSpectrogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
CollectionAssert.That.AreEqual(expectedDecibelSonogram, actualDecibelSpectrogram.Data, EnvelopeAndFftTests.Delta);
}
public void LinearFrequencyScale()
{
var recordingPath = PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav");
var opFileStem = "BAC2_20071008";
var outputDir = this.outputDirectory;
var outputImagePath = Path.Combine(outputDir.FullName, "LinearScaleSonogram.png");
var recording = new AudioRecording(recordingPath);
// specfied linear scale
int nyquist = 11025;
int frameSize = 1024;
int hertzInterval = 1000;
var freqScale = new FrequencyScale(nyquist, frameSize, hertzInterval);
var fst = freqScale.ScaleType;
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
sonogram.Configuration.WindowSize = freqScale.WindowSize;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst.ToString(), freqScale.GridLineLocations);
image.Save(outputImagePath, ImageFormat.Png);
// DO FILE EQUALITY TEST
var stemOfExpectedFile = opFileStem + "_LinearScaleGridLineLocations.EXPECTED.json";
var stemOfActualFile = opFileStem + "_LinearScaleGridLineLocations.ACTUAL.json";
// Check that freqScale.GridLineLocations are correct
var expectedFile1 = PathHelper.ResolveAsset("FrequencyScale\\" + stemOfExpectedFile);
if (!expectedFile1.Exists)
{
LoggedConsole.WriteErrorLine("An EXPECTED results file does not exist. Test will fail!");
LoggedConsole.WriteErrorLine(
$"If ACTUAL results file is correct, move it to dir `{PathHelper.TestResources}` and change its suffix to <.EXPECTED.json>");
}
var resultFile1 = new FileInfo(Path.Combine(outputDir.FullName, stemOfActualFile));
Json.Serialise(resultFile1, freqScale.GridLineLocations);
FileEqualityHelpers.TextFileEqual(expectedFile1, resultFile1);
// Check that image dimensions are correct
Assert.AreEqual(566, image.Height);
Assert.AreEqual(1621, image.Width);
}
public static Tuple <EventCommon[], AudioRecording, BaseSonogram> Detect(
FileInfo audioFile,
AedConfiguration aedConfiguration,
TimeSpan segmentStartOffset)
{
if (aedConfiguration.NoiseReductionType != NoiseReductionType.None && aedConfiguration.NoiseReductionParameter == null)
{
throw new ArgumentException("A noise production parameter should be supplied if not using AED noise removal", "noiseReductionParameter");
}
var recording = new AudioRecording(audioFile);
var segmentDuration = recording.Duration;
if (recording.SampleRate != aedConfiguration.ResampleRate)
{
throw new ArgumentException(
"Sample rate of recording ({0}) does not match the desired sample rate ({1})".Format2(
recording.SampleRate,
aedConfiguration.ResampleRate));
}
var config = new SonogramConfig
{
NoiseReductionType = aedConfiguration.NoiseReductionType,
NoiseReductionParameter = aedConfiguration.NoiseReductionParameter,
};
var sonogram = (BaseSonogram) new SpectrogramStandard(config, recording.WavReader);
var events = CallAed(sonogram, aedConfiguration, segmentStartOffset, segmentDuration);
Log.Debug("AED # events: " + events.Length);
return(Tuple.Create(events, recording, sonogram));
}
/// <summary>
/// This method takes an audio recording and returns an octave scale spectrogram.
/// At the present time it only works for recordings with 64000 sample rate and returns a 256 bin sonogram.
/// TODO: generalise this method for other recordings and octave scales.
/// </summary>
public static BaseSonogram ConvertRecordingToOctaveScaleSonogram(AudioRecording recording, FreqScaleType fst)
{
var freqScale = new FrequencyScale(fst);
double windowOverlap = 0.75;
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.WindowSize,
WindowOverlap = windowOverlap,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
// Generate amplitude sonogram and then conver to octave scale
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
// THIS IS THE CRITICAL LINE.
// TODO: SHOULD DEVELOP A SEPARATE UNIT TEST for this method
sonogram.Data = ConvertAmplitudeSpectrogramToDecibelOctaveScale(sonogram.Data, freqScale);
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
int windowSize = freqScale.FinalBinCount * 2;
sonogram.Configuration.WindowSize = windowSize;
sonogram.Configuration.WindowStep = (int)Math.Round(windowSize * (1 - windowOverlap));
return(sonogram);
}
public void TestFreqScaleOnArtificialSignal1()
{
int sampleRate = 22050;
double duration = 20; // signal duration in seconds
int[] harmonics = { 500, 1000, 2000, 4000, 8000 };
int windowSize = 512;
var freqScale = new FrequencyScale(sampleRate / 2, windowSize, 1000);
var outputImagePath = Path.Combine(this.outputDirectory.FullName, "Signal1_LinearFreqScale.png");
var recording = DspFilters.GenerateTestRecording(sampleRate, duration, harmonics, WaveType.Cosine);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.WindowSize,
WindowOverlap = 0.0,
SourceFName = "Signal1",
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.12,
};
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
// pick a row, any row
var oneSpectrum = MatrixTools.GetRow(sonogram.Data, 40);
oneSpectrum = DataTools.filterMovingAverage(oneSpectrum, 5);
var peaks = DataTools.GetPeaks(oneSpectrum);
for (int i = 5; i < peaks.Length - 5; i++)
{
if (peaks[i])
{
LoggedConsole.WriteLine($"bin ={freqScale.BinBounds[i, 0]}, Herz={freqScale.BinBounds[i, 1]}-{freqScale.BinBounds[i + 1, 1]} ");
}
}
foreach (int h in harmonics)
{
LoggedConsole.WriteLine($"Harmonic {h}Herz should be in bin {freqScale.GetBinIdForHerzValue(h)}");
}
// spectrogram without framing, annotation etc
var image = sonogram.GetImage();
string title = $"Spectrogram of Harmonics: {DataTools.Array2String(harmonics)} SR={sampleRate} Window={windowSize}";
image = sonogram.GetImageFullyAnnotated(image, title, freqScale.GridLineLocations);
image.Save(outputImagePath);
// Check that image dimensions are correct
Assert.AreEqual(861, image.Width);
Assert.AreEqual(310, image.Height);
Assert.IsTrue(peaks[11]);
Assert.IsTrue(peaks[22]);
Assert.IsTrue(peaks[45]);
Assert.IsTrue(peaks[92]);
Assert.IsTrue(peaks[185]);
}
public void LinearFrequencyScaleDefault()
{
// relative path because post-Build command transfers files to ...\\Work\GitHub\...\bin\Debug subfolder.
var recordingPath = @"Recordings\BAC2_20071008-085040.wav";
var opFileStem = "BAC2_20071008";
var outputDir = this.outputDirectory;
var outputImagePath = Path.Combine(outputDir.FullName, "DefaultLinearScaleSonogram.png");
var recording = new AudioRecording(recordingPath);
// default linear scale
var fst = FreqScaleType.Linear;
var freqScale = new FrequencyScale(fst);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
sonogram.Configuration.WindowSize = freqScale.WindowSize;
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst.ToString(), freqScale.GridLineLocations);
image.Save(outputImagePath, ImageFormat.Png);
// DO UNIT TESTING
var stemOfExpectedFile = opFileStem + "_DefaultLinearScaleGridLineLocations.EXPECTED.json";
var stemOfActualFile = opFileStem + "_DefaultLinearScaleGridLineLocations.ACTUAL.json";
// Check that freqScale.GridLineLocations are correct
var expectedFile1 = new FileInfo("FrequencyScale\\" + stemOfExpectedFile);
if (!expectedFile1.Exists)
{
LoggedConsole.WriteErrorLine("An EXPECTED results file does not exist. Test will fail!");
LoggedConsole.WriteErrorLine("If ACTUAL results file is correct, move it to dir <...\\TestResources\\FrequencyScale> and change its suffix to <.EXPECTED.json>");
}
var resultFile1 = new FileInfo(Path.Combine(outputDir.FullName, stemOfActualFile));
Json.Serialise(resultFile1, freqScale.GridLineLocations);
FileEqualityHelpers.TextFileEqual(expectedFile1, resultFile1);
// Check that image dimensions are correct
Assert.AreEqual(310, image.Height);
Assert.AreEqual(3247, image.Width);
}
public void LinearFrequencyScale()
{
var recordingPath = PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav");
var outputImagePath = this.outputDirectory.CombineFile("DefaultLinearScaleSonogram.png");
var recording = new AudioRecording(recordingPath);
// specfied linear scale
int nyquist = 11025;
int frameSize = 1024;
int hertzInterval = 1000;
var freqScale = new FrequencyScale(nyquist, frameSize, hertzInterval);
var fst = freqScale.ScaleType;
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
sonogram.Configuration.WindowSize = freqScale.WindowSize;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst, freqScale.GridLineLocations);
image.Save(outputImagePath);
var expected = new[, ]
{
{ 46, 1000 },
{ 92, 2000 },
{ 139, 3000 },
{ 185, 4000 },
{ 232, 5000 },
{ 278, 6000 },
{ 325, 7000 },
{ 371, 8000 },
{ 417, 9000 },
{ 464, 10000 },
{ 510, 11000 },
};
Assert.That.MatricesAreEqual(expected, freqScale.GridLineLocations);
// Check that image dimensions are correct
Assert.AreEqual(566, image.Height);
Assert.AreEqual(1621, image.Width);
}
public static void TestMethod_GenerateSignal1()
{
int sampleRate = 22050;
double duration = 20; // signal duration in seconds
int[] harmonics = { 500, 1000, 2000, 4000, 8000 };
int windowSize = 512;
var freqScale = new FrequencyScale(sampleRate / 2, windowSize, 1000);
string path = @"C:\SensorNetworks\Output\Sonograms\UnitTestSonograms\SineSignal1.png";
var recording = GenerateTestRecording(sampleRate, duration, harmonics, WaveType.Cosine);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.WindowSize,
WindowOverlap = 0.0,
SourceFName = "Signal1",
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.12,
};
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
// pick a row, any row
var oneSpectrum = MatrixTools.GetRow(sonogram.Data, 40);
oneSpectrum = DataTools.normalise(oneSpectrum);
var peaks = DataTools.GetPeaks(oneSpectrum, 0.5);
for (int i = 2; i < peaks.Length - 2; i++)
{
if (peaks[i])
{
LoggedConsole.WriteLine($"bin ={freqScale.BinBounds[i, 0]}, Herz={freqScale.BinBounds[i, 1]}-{freqScale.BinBounds[i + 1, 1]} ");
}
}
if (peaks[11] && peaks[22] && peaks[45] && peaks[92] && peaks[185])
{
LoggedConsole.WriteSuccessLine("Spectral Peaks found at correct places");
}
else
{
LoggedConsole.WriteErrorLine("Spectral Peaks found at INCORRECT places");
}
foreach (int h in harmonics)
{
LoggedConsole.WriteLine($"Harmonic {h}Herz should be in bin {freqScale.GetBinIdForHerzValue(h)}");
}
// spectrogram without framing, annotation etc
var image = sonogram.GetImage();
string title = $"Spectrogram of Harmonics: {DataTools.Array2String(harmonics)} SR={sampleRate} Window={windowSize}";
image = sonogram.GetImageFullyAnnotated(image, title, freqScale.GridLineLocations);
image.Save(path);
}
public void LinearFrequencyScaleDefault()
{
var recordingPath = PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav");
var outputImagePath = this.outputDirectory.CombineFile("DefaultLinearScaleSonogram.png");
var recording = new AudioRecording(recordingPath);
// default linear scale
var fst = FreqScaleType.Linear;
var freqScale = new FrequencyScale(fst);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
sonogram.Configuration.WindowSize = freqScale.WindowSize;
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst, freqScale.GridLineLocations);
image.Save(outputImagePath);
// Check that freqScale.GridLineLocations are correct
var expected = new[, ]
{
{ 23, 1000 },
{ 46, 2000 },
{ 69, 3000 },
{ 92, 4000 },
{ 116, 5000 },
{ 139, 6000 },
{ 162, 7000 },
{ 185, 8000 },
{ 208, 9000 },
{ 232, 10000 },
{ 255, 11000 },
};
Assert.That.MatricesAreEqual(expected, freqScale.GridLineLocations);
// Check that image dimensions are correct
Assert.AreEqual(310, image.Height);
Assert.AreEqual(3247, image.Width);
}
public static void Execute(Arguments arguments)
{
Log.Verbosity = 1;
FileInfo wavFilePath = arguments.Source.ToFileInfo();
DirectoryInfo opDir = arguments.Output.ToDirectoryInfo();
double intensityThreshold = arguments.IntensityThreshold;
Log.WriteLine("intensityThreshold = " + intensityThreshold);
int smallLengthThreshold = 50;
Log.WriteLine("smallLengthThreshold = " + smallLengthThreshold);
string wavFilePath1 = wavFilePath.FullName;
var recording = new AudioRecording(wavFilePath1);
const int sampleRate = 22050;
if (recording.SampleRate != sampleRate)
{
throw new ArgumentException(
"Sample rate of recording ({0}) does not match the desired sample rate ({1})".Format2(
recording.SampleRate,
sampleRate),
"sampleRate");
}
var config = new SonogramConfig
{
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 3.5,
};
var sonogram = (BaseSonogram) new SpectrogramStandard(config, recording.WavReader);
var result = doSPT(sonogram, intensityThreshold, smallLengthThreshold);
sonogram.Data = result.Item1;
// SAVE IMAGE
string savePath = opDir + System.IO.Path.GetFileNameWithoutExtension(wavFilePath.Name);
string suffix = string.Empty;
while (File.Exists(savePath + suffix + ".jpg"))
{
suffix = suffix == string.Empty ? "1" : (int.Parse(suffix) + 1).ToString();
}
Image im = sonogram.GetImage(false, false, doMelScale: false);
string newPath = savePath + suffix + ".jpg";
Log.WriteIfVerbose("imagePath = " + newPath);
im.Save(newPath);
LoggedConsole.WriteLine("\nFINISHED!");
}
/// <summary>
/// Generates the FREQUENCY x OSCILLATIONS Graphs and csv
/// I have experimented with five methods to search for oscillations:
/// 1: string algorithmName = "Autocorr-FFT";
/// use this if want more detailed output - but not necessrily accurate!
/// 2: string algorithmName = "Autocorr-SVD-FFT";
/// use this if want only dominant oscillations
/// 3: string algorithmName = "Autocorr-Cwt";
/// a Wavelets option but could not get it to work well
/// 4: string algorithmName = "Autocorr-WPD";
/// another Wavelets option but could not get it to work well
/// 5: Discrete Cosine Transform
/// The DCT only works well when you know which periodicity you are looking for. e.g. Canetoad.
/// </summary>
public static Tuple <Image <Rgb24>, double[, ]> GenerateOscillationDataAndImages(FileInfo audioSegment, Dictionary <string, string> configDict, bool drawImage = false)
{
// set two oscillation detection parameters
double sensitivity = DefaultSensitivityThreshold;
if (configDict.ContainsKey(AnalysisKeys.OscilDetection2014SensitivityThreshold))
{
sensitivity = double.Parse(configDict[AnalysisKeys.OscilDetection2014SensitivityThreshold]);
}
// Sample length i.e. number of frames spanned to calculate oscillations per second
int sampleLength = DefaultSampleLength;
if (configDict.ContainsKey(AnalysisKeys.OscilDetection2014SampleLength))
{
sampleLength = int.Parse(configDict[AnalysisKeys.OscilDetection2014SampleLength]);
}
var sonoConfig = new SonogramConfig(configDict); // default values config
if (configDict.ContainsKey(AnalysisKeys.OscilDetection2014FrameSize))
{
sonoConfig.WindowSize = int.Parse(configDict[AnalysisKeys.OscilDetection2014FrameSize]);
}
var recordingSegment = new AudioRecording(audioSegment.FullName);
var spgm = GetSpectrogramMatrix(recordingSegment, DefaultFrameLength);
double framesPerSecond = DefaultResampleRate / (double)DefaultFrameLength;
double freqBinWidth = framesPerSecond;
// get the appropriate sampleLength (patch size) for short recordings
int framecount = spgm.GetLength(0);
sampleLength = AdjustSampleSize(framecount, sampleLength);
var algorithmName1 = "autocorr-svd-fft";
var freqOscilMatrix1 = GetFrequencyByOscillationsMatrix(spgm, sensitivity, sampleLength, algorithmName1);
var image1 = GetFreqVsOscillationsImage(freqOscilMatrix1, framesPerSecond, freqBinWidth, sampleLength, algorithmName1);
var algorithmName2 = "autocorr-fft";
var freqOscilMatrix2 = GetFrequencyByOscillationsMatrix(spgm, sensitivity, sampleLength, algorithmName2);
var image2 = GetFreqVsOscillationsImage(freqOscilMatrix2, framesPerSecond, freqBinWidth, sampleLength, algorithmName2);
//IMPORTANT NOTE: To generate an OSC spectral index matrix for making LDFC spectrograms, use the following line:
//var spectralIndex = MatrixTools.GetMaximumColumnValues(freqOscilMatrix2);
var compositeImage = ImageTools.CombineImagesInLine(image2, image1);
// Return (1) composite image of oscillations,
// (2) data matrix from only one algorithm,
return(Tuple.Create(compositeImage, freqOscilMatrix2));
}
public static Tuple <BaseSonogram, AcousticEvent, double[, ], double[], double[, ]> Execute_Extraction(
AudioRecording recording,
double eventStart,
double eventEnd,
int minHz,
int maxHz,
double frameOverlap,
double backgroundThreshold,
TimeSpan segmentStartOffset)
{
//ii: MAKE SONOGRAM
SonogramConfig sonoConfig = new SonogramConfig(); //default values config
sonoConfig.SourceFName = recording.BaseName;
//sonoConfig.WindowSize = windowSize;
sonoConfig.WindowOverlap = frameOverlap;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
Log.WriteLine("Frames: Size={0}, Count={1}, Duration={2:f1}ms, Overlap={5:f2}%, Offset={3:f1}ms, Frames/s={4:f1}",
sonogram.Configuration.WindowSize, sonogram.FrameCount, (sonogram.FrameDuration * 1000),
(sonogram.FrameStep * 1000), sonogram.FramesPerSecond, frameOverlap);
int binCount = (int)(maxHz / sonogram.FBinWidth) - (int)(minHz / sonogram.FBinWidth) + 1;
Log.WriteIfVerbose("Freq band: {0} Hz - {1} Hz. (Freq bin count = {2})", minHz, maxHz, binCount);
//calculate the modal noise profile
double SD_COUNT = 0.0; // number of noise standard deviations used to calculate noise threshold
NoiseProfile profile = NoiseProfile.CalculateModalNoiseProfile(sonogram.Data, SD_COUNT); //calculate modal noise profile
double[] modalNoise = DataTools.filterMovingAverage(profile.NoiseMode, 7); //smooth the noise profile
//extract modal noise values of the required event
double[] noiseSubband = SpectrogramTools.ExtractModalNoiseSubband(modalNoise, minHz, maxHz, false, sonogram.NyquistFrequency, sonogram.FBinWidth);
//extract data values of the required event
double[,] target = SpectrogramTools.ExtractEvent(sonogram.Data, eventStart, eventEnd, sonogram.FrameStep,
minHz, maxHz, false, sonogram.NyquistFrequency, sonogram.FBinWidth);
// create acoustic event with defined boundaries
AcousticEvent ae = new AcousticEvent(segmentStartOffset, eventStart, eventEnd - eventStart, minHz, maxHz);
ae.SetTimeAndFreqScales(sonogram.FramesPerSecond, sonogram.FBinWidth);
//truncate noise
sonogram.Data = SNR.TruncateBgNoiseFromSpectrogram(sonogram.Data, modalNoise);
sonogram.Data = SNR.RemoveNeighbourhoodBackgroundNoise(sonogram.Data, backgroundThreshold);
double[,] targetMinusNoise = SpectrogramTools.ExtractEvent(sonogram.Data, eventStart, eventEnd, sonogram.FrameStep,
minHz, maxHz, false, sonogram.NyquistFrequency, sonogram.FBinWidth);
return(Tuple.Create(sonogram, ae, target, noiseSubband, targetMinusNoise));
}
/// <summary>
/// METHOD TO CHECK IF Octave FREQ SCALE IS WORKING
/// Check it on standard one minute recording, SR=22050.
/// </summary>
public static void TESTMETHOD_OctaveFrequencyScale1()
{
var recordingPath = @"G:\SensorNetworks\WavFiles\LewinsRail\FromLizZnidersic\Lewinsrail_TasmanIs_Tractor_SM304253_0151119_0640_1minMono.wav";
var outputDir = @"C:\SensorNetworks\Output\LewinsRail\LewinsRail_ThreeCallTypes".ToDirectoryInfo();
//var recordingPath = @"C:\SensorNetworks\SoftwareTests\TestRecordings\BAC\BAC2_20071008-085040.wav";
//var outputDir = @"C:\SensorNetworks\SoftwareTests\TestFrequencyScale".ToDirectoryInfo();
//var expectedResultsDir = Path.Combine(outputDir.FullName, TestTools.ExpectedResultsDir).ToDirectoryInfo();
var outputImagePath = Path.Combine(outputDir.FullName, "octaveFrequencyScale1NoNoiseReduciton.png");
//var opFileStem = "Lewinsrail_TasmanIs_Tractor";
var recording = new AudioRecording(recordingPath);
// default octave scale
var fst = FreqScaleType.Linear125Octaves6Tones30Nyquist11025;
var freqScale = new FrequencyScale(fst);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.WindowSize,
WindowOverlap = 0.75,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
// Generate amplitude sonogram and then conver to octave scale
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
sonogram.Data = OctaveFreqScale.ConvertAmplitudeSpectrogramToDecibelOctaveScale(sonogram.Data, freqScale);
// DO NOISE REDUCTION
//var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
//sonogram.Data = dataMatrix;
sonogram.Configuration.WindowSize = freqScale.WindowSize;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst.ToString(), freqScale.GridLineLocations);
image.Save(outputImagePath);
// DO FILE EQUALITY TEST
//string testName = "test1";
//var expectedTestFile = new FileInfo(Path.Combine(expectedResultsDir.FullName, "FrequencyOctaveScaleTest1.EXPECTED.json"));
//var resultFile = new FileInfo(Path.Combine(outputDir.FullName, opFileStem + "FrequencyOctaveScaleTest1Results.json"));
//Acoustics.Shared.Csv.Csv.WriteMatrixToCsv(resultFile, freqScale.GridLineLocations);
//TestTools.FileEqualityTest(testName, resultFile, expectedTestFile);
LoggedConsole.WriteLine("Completed Octave Frequency Scale test 1");
Console.WriteLine("\n\n");
}
/// <summary>
/// METHOD TO CHECK IF SPECIFIED linear FREQ SCALE IS WORKING
/// Check it on standard one minute recording.
/// </summary>
public static void TESTMETHOD_LinearFrequencyScale()
{
var recordingPath = @"C:\SensorNetworks\SoftwareTests\TestRecordings\BAC2_20071008-085040.wav";
var outputDir = @"C:\SensorNetworks\SoftwareTests\TestFrequencyScale".ToDirectoryInfo();
var expectedResultsDir = Path.Combine(outputDir.FullName, TestTools.ExpectedResultsDir).ToDirectoryInfo();
var outputImagePath = Path.Combine(outputDir.FullName, "linearScaleSonogram.png");
var opFileStem = "BAC2_20071008";
var recording = new AudioRecording(recordingPath);
// specfied linear scale
int nyquist = 11025;
int frameSize = 1024;
int hertzInterval = 1000;
var freqScale = new FrequencyScale(nyquist, frameSize, hertzInterval);
var fst = freqScale.ScaleType;
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
//NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
sonogram.Configuration.WindowSize = freqScale.WindowSize;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst.ToString(), freqScale.GridLineLocations);
image.Save(outputImagePath);
// DO FILE EQUALITY TEST
string testName = "testName";
var expectedTestFile = new FileInfo(Path.Combine(expectedResultsDir.FullName, "FrequencyLinearScaleTest.EXPECTED.json"));
var resultFile = new FileInfo(Path.Combine(outputDir.FullName, opFileStem + "FrequencyLinearScaleTestResults.json"));
Acoustics.Shared.Csv.Csv.WriteMatrixToCsv(resultFile, freqScale.GridLineLocations);
TestTools.FileEqualityTest(testName, resultFile, expectedTestFile);
LoggedConsole.WriteLine("Completed Linear Frequency Scale test");
Console.WriteLine("\n\n");
}
public void Setup()
{
this.outputDirectory = PathHelper.GetTempDir();
this.audioRecording = new AudioRecording(PathHelper.ResolveAsset("Recordings", "20190115_Bellingen_Feeding_minute6_OneChannel22050.wav"));
var sonoConfig = new SonogramConfig
{
WindowSize = 512,
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 3.0,
WindowOverlap = 0.0,
};
this.sonogram = new SpectrogramStandard(sonoConfig, this.audioRecording.WavReader);
}
/// <summary>
/// METHOD TO CHECK IF SPECIFIED MEL FREQ SCALE IS WORKING
/// Check it on standard one minute recording.
/// </summary>
public static void TESTMETHOD_MelFrequencyScale()
{
var recordingPath = @"C:\SensorNetworks\SoftwareTests\TestRecordings\BAC2_20071008-085040.wav";
var outputDir = @"C:\SensorNetworks\SoftwareTests\TestFrequencyScale".ToDirectoryInfo();
var expectedResultsDir = Path.Combine(outputDir.FullName, TestTools.ExpectedResultsDir).ToDirectoryInfo();
var outputImagePath = Path.Combine(outputDir.FullName, "melScaleSonogram.png");
var opFileStem = "BAC2_20071008";
var recording = new AudioRecording(recordingPath);
int nyquist = recording.Nyquist;
int frameSize = 1024;
int finalBinCount = 256;
int hertzInterval = 1000;
FreqScaleType scaleType = FreqScaleType.Mel;
var freqScale = new FrequencyScale(scaleType, nyquist, frameSize, finalBinCount, hertzInterval);
var fst = freqScale.ScaleType;
var sonoConfig = new SonogramConfig
{
WindowSize = frameSize,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
DoMelScale = (scaleType == FreqScaleType.Mel) ? true : false,
MelBinCount = (scaleType == FreqScaleType.Mel) ? finalBinCount : frameSize / 2,
//NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// DRAW SPECTROGRAM
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst.ToString(), freqScale.GridLineLocations);
image.Save(outputImagePath);
// DO FILE EQUALITY TEST
string testName = "MelTest";
var expectedTestFile = new FileInfo(Path.Combine(expectedResultsDir.FullName, "MelFrequencyScaleTest.EXPECTED.json"));
var resultFile = new FileInfo(Path.Combine(outputDir.FullName, opFileStem + "MelFrequencyLinearScaleTestResults.json"));
Acoustics.Shared.Csv.Csv.WriteMatrixToCsv(resultFile, freqScale.GridLineLocations);
TestTools.FileEqualityTest(testName, resultFile, expectedTestFile);
LoggedConsole.WriteLine("Completed Mel Frequency Scale test");
Console.WriteLine("\n\n");
}
// ################################## REMAINING STATIC METHODS DEAL WITH THE OBTAINING AND DRAWING OF SPECTROGRAMS
public static SpectrogramStandard GetStandardSpectrogram(AudioRecording recording, int frameSize)
{
// make a normal standard decibel spectogram on which to superimpose cluster results
var config = new SonogramConfig
{
WindowSize = frameSize,
NoiseReductionType = NoiseReductionType.Standard,
WindowOverlap = 0.0,
NoiseReductionParameter = 0.0,
};
var stdSpectrogram = new SpectrogramStandard(config, recording.WavReader);
return(stdSpectrogram);
}
/// <summary>
/// Transfers the required six indices from SpectralIndexBase to a dictionary.
/// IMPORTANT NOTE: THis method needs to be updated if there is a change to the indices used for content description.
/// </summary>
/*public static Dictionary<string, double[]> ConvertIndicesToDictionary(SpectralIndexBase indexSet)
* {
* var dictionary = new Dictionary<string, double[]>();
* var aciArray = (double[])indexSet.GetPropertyValue("ACI");
* dictionary.Add("ACI", aciArray);
* var entArray = (double[])indexSet.GetPropertyValue("ENT");
* dictionary.Add("ENT", entArray);
* var evnArray = (double[])indexSet.GetPropertyValue("EVN");
* dictionary.Add("EVN", evnArray);
* var bgnArray = (double[])indexSet.GetPropertyValue("BGN");
* dictionary.Add("BGN", bgnArray);
* var pmnArray = (double[])indexSet.GetPropertyValue("PMN");
* dictionary.Add("PMN", pmnArray);
* var oscArray = (double[])indexSet.GetPropertyValue("OSC");
* dictionary.Add("OSC", oscArray);
* return dictionary;
* }*/
private static SpectrogramStandard GetSonogram(AudioRecording recording, int windowSize)
{
// init the default sonogram config
var sonogramConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = windowSize,
WindowOverlap = 0.0,
NoiseReductionType = NoiseReductionType.Standard,
};
var sonogram = new SpectrogramStandard(sonogramConfig, recording.WavReader);
return(sonogram);
}
public static Image GetLcnSpectrogram(SonogramConfig sonoConfig, AudioRecording recordingSegment, string sourceRecordingName, double neighbourhoodSeconds, double lcnContrastLevel)
{
BaseSonogram sonogram = new AmplitudeSonogram(sonoConfig, recordingSegment.WavReader);
int neighbourhoodFrames = (int)(sonogram.FramesPerSecond * neighbourhoodSeconds);
LoggedConsole.WriteLine("LCN: FramesPerSecond (Prior to LCN) = {0}", sonogram.FramesPerSecond);
LoggedConsole.WriteLine("LCN: Neighbourhood of {0} seconds = {1} frames", neighbourhoodSeconds, neighbourhoodFrames);
const int lowPercentile = 20;
sonogram.Data = NoiseRemoval_Briggs.NoiseReduction_byLowestPercentileSubtraction(sonogram.Data, lowPercentile);
sonogram.Data = NoiseRemoval_Briggs.NoiseReduction_byLCNDivision(sonogram.Data, neighbourhoodFrames, lcnContrastLevel);
var image = sonogram.GetImageFullyAnnotated("AMPLITUDE SPECTROGRAM with freq bin Local Contrast Normalization - " + sourceRecordingName);
return(image);
}
/// <summary>
/// Detect using EPR.
/// </summary>
/// <param name="wavFilePath">
/// The wav file path.
/// </param>
/// <param name="eprNormalisedMinScore">
/// The epr Normalised Min Score.
/// </param>
/// <returns>
/// Tuple containing base Sonogram and list of acoustic events.
/// </returns>
public static Tuple <BaseSonogram, List <AcousticEvent> > Detect(FileInfo wavFilePath, Aed.AedConfiguration aedConfiguration, double eprNormalisedMinScore, TimeSpan segmentStartOffset)
{
Tuple <EventCommon[], AudioRecording, BaseSonogram> aed = Aed.Detect(wavFilePath, aedConfiguration, segmentStartOffset);
var events = aed.Item1;
var newEvents = new List <AcousticEvent>();
foreach (var be in events)
{
newEvents.Add(EventConverters.ConvertSpectralEventToAcousticEvent((SpectralEvent)be));
}
var aeEvents = newEvents.Select(ae => Util.fcornersToRect(ae.TimeStart, ae.TimeEnd, ae.HighFrequencyHertz, ae.LowFrequencyHertz)).ToList();
Log.Debug("EPR start");
var eprRects = EventPatternRecog.DetectGroundParrots(aeEvents, eprNormalisedMinScore);
Log.Debug("EPR finished");
var sonogram = aed.Item3;
SonogramConfig config = sonogram.Configuration;
double framesPerSec = 1 / config.GetFrameOffset(); // Surely this should go somewhere else
double freqBinWidth = config.NyquistFreq / (double)config.FreqBinCount;
// TODO this is common with AED
var eprEvents = new List <AcousticEvent>();
foreach (var rectScore in eprRects)
{
var ae = new AcousticEvent(
segmentStartOffset,
rectScore.Item1.Left,
rectScore.Item1.Right - rectScore.Item1.Left,
rectScore.Item1.Bottom,
rectScore.Item1.Top);
ae.SetTimeAndFreqScales(framesPerSec, freqBinWidth);
ae.SetTimeAndFreqScales(sonogram.NyquistFrequency, sonogram.Configuration.WindowSize, 0);
ae.SetScores(rectScore.Item2, 0, 1);
ae.BorderColour = aedConfiguration.AedEventColor;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.SegmentDurationSeconds = aed.Item2.Duration.TotalSeconds;
eprEvents.Add(ae);
}
return(Tuple.Create(sonogram, eprEvents));
}
public static Image GetCepstralSpectrogram(SonogramConfig sonoConfig, AudioRecording recording, string sourceRecordingName)
{
// TODO at present noise reduction type must be set = Standard.
sonoConfig.NoiseReductionType = NoiseReductionType.Standard;
sonoConfig.NoiseReductionParameter = 3.0;
var cepgram = new SpectrogramCepstral(sonoConfig, recording.WavReader);
var image = cepgram.GetImage();
var titleBar = BaseSonogram.DrawTitleBarOfGrayScaleSpectrogram("CEPSTRO-GRAM " + sourceRecordingName, image.Width);
var startTime = TimeSpan.Zero;
var xAxisTicInterval = TimeSpan.FromSeconds(1);
TimeSpan xAxisPixelDuration = TimeSpan.FromSeconds(sonoConfig.WindowStep / (double)sonoConfig.SampleRate);
var labelInterval = TimeSpan.FromSeconds(5);
image = BaseSonogram.FrameSonogram(image, titleBar, startTime, xAxisTicInterval, xAxisPixelDuration, labelInterval);
return(image);
}
/// <summary>
/// returns a base sonogram type from which spectrogram images are prepared.
/// </summary>
internal static BaseSonogram GetSonogram(Config configuration, AudioRecording audioRecording)
{
var sonoConfig = new SonogramConfig
{
WindowSize = DefaultWindow,
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = configuration.GetDoubleOrNull(AnalysisKeys.NoiseBgThreshold) ?? 0.0,
WindowOverlap = 0.0,
};
// now construct the standard decibel spectrogram WITH noise removal
// get frame parameters for the analysis
var sonogram = (BaseSonogram) new SpectrogramStandard(sonoConfig, audioRecording.WavReader);
return(sonogram);
}
/// <summary>
/// METHOD TO CHECK IF Octave FREQ SCALE IS WORKING
/// Check it on MARINE RECORDING from JASCO, SR=64000.
/// 24 BIT JASCO RECORDINGS from GBR must be converted to 16 bit.
/// ffmpeg -i source_file.wav -sample_fmt s16 out_file.wav
/// e.g. ". C:\Work\Github\audio-analysis\Extra Assemblies\ffmpeg\ffmpeg.exe" -i "C:\SensorNetworks\WavFiles\MarineRecordings\JascoGBR\AMAR119-00000139.00000139.Chan_1-24bps.1375012796.2013-07-28-11-59-56.wav" -sample_fmt s16 "C:\SensorNetworks\Output\OctaveFreqScale\JascoeMarineGBR116bit.wav"
/// ffmpeg binaries are in C:\Work\Github\audio-analysis\Extra Assemblies\ffmpeg
/// </summary>
public static void TESTMETHOD_OctaveFrequencyScale2()
{
var recordingPath = @"C:\SensorNetworks\SoftwareTests\TestRecordings\MarineJasco_AMAR119-00000139.00000139.Chan_1-24bps.1375012796.2013-07-28-11-59-56-16bit.wav";
var outputDir = @"C:\SensorNetworks\SoftwareTests\TestFrequencyScale".ToDirectoryInfo();
var expectedResultsDir = Path.Combine(outputDir.FullName, TestTools.ExpectedResultsDir).ToDirectoryInfo();
var outputImagePath = Path.Combine(outputDir.FullName, "JascoMarineGBR1.png");
var opFileStem = "JascoMarineGBR1";
var recording = new AudioRecording(recordingPath);
var fst = FreqScaleType.Linear125Octaves7Tones28Nyquist32000;
var freqScale = new FrequencyScale(fst);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.WindowSize,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
var sonogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
sonogram.Data = OctaveFreqScale.ConvertAmplitudeSpectrogramToDecibelOctaveScale(sonogram.Data, freqScale);
// DO NOISE REDUCTION
var dataMatrix = SNR.NoiseReduce_Standard(sonogram.Data);
sonogram.Data = dataMatrix;
sonogram.Configuration.WindowSize = freqScale.WindowSize;
var image = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM: " + fst.ToString(), freqScale.GridLineLocations);
image.Save(outputImagePath);
// DO FILE EQUALITY TEST
string testName = "test2";
var expectedTestFile = new FileInfo(Path.Combine(expectedResultsDir.FullName, "FrequencyOctaveScaleTest2.EXPECTED.json"));
var resultFile = new FileInfo(Path.Combine(outputDir.FullName, opFileStem + "FrequencyOctaveScaleTest2Results.json"));
Acoustics.Shared.Csv.Csv.WriteMatrixToCsv(resultFile, freqScale.GridLineLocations);
TestTools.FileEqualityTest(testName, resultFile, expectedTestFile);
LoggedConsole.WriteLine("Completed Octave Frequency Scale " + testName);
Console.WriteLine("\n\n");
}
public static Tuple <BaseSonogram, double[, ], double[], List <AcousticEvent>, double[], TimeSpan> Execute_ODDetect(FileInfo wavPath,
bool doSegmentation, int minHz, int maxHz, double frameOverlap, double dctDuration, double dctThreshold, int minOscilFreq, int maxOscilFreq,
double eventThreshold, double minDuration, double maxDuration)
{
//i: GET RECORDING
AudioRecording recording = new AudioRecording(wavPath.FullName);
//if (recording.SampleRate != 22050) recording.ConvertSampleRate22kHz(); // THIS METHOD CALL IS OBSOLETE
int sr = recording.SampleRate;
//ii: MAKE SONOGRAM
Log.WriteLine("Start sonogram.");
SonogramConfig sonoConfig = new SonogramConfig(); //default values config
sonoConfig.WindowOverlap = frameOverlap;
sonoConfig.SourceFName = recording.BaseName;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
Log.WriteLine("Signal: Duration={0}, Sample Rate={1}", sonogram.Duration, sr);
Log.WriteLine("Frames: Size={0}, Count={1}, Duration={2:f1}ms, Overlap={5:f0}%, Offset={3:f1}ms, Frames/s={4:f1}",
sonogram.Configuration.WindowSize, sonogram.FrameCount, sonogram.FrameDuration * 1000,
sonogram.FrameStep * 1000, sonogram.FramesPerSecond, frameOverlap);
int binCount = (int)(maxHz / sonogram.FBinWidth) - (int)(minHz / sonogram.FBinWidth) + 1;
Log.WriteIfVerbose("Freq band: {0} Hz - {1} Hz. (Freq bin count = {2})", minHz, maxHz, binCount);
Log.WriteIfVerbose("DctDuration=" + dctDuration + "sec. (# frames=" + (int)Math.Round(dctDuration * sonogram.FramesPerSecond) + ")");
Log.WriteIfVerbose("Score threshold for oscil events=" + eventThreshold);
Log.WriteLine("Start OD event detection");
//iii: DETECT OSCILLATIONS
bool normaliseDCT = true;
List <AcousticEvent> predictedEvents; //predefinition of results event list
double[] scores; //predefinition of score array
double[,] hits; //predefinition of hits matrix - to superimpose on sonogram image
double[] segments; //predefinition of segmentation of recording
TimeSpan analysisTime; //predefinition of Time duration taken to do analysis on this file
Oscillations2010.Execute((SpectrogramStandard)sonogram, doSegmentation, minHz, maxHz, dctDuration, dctThreshold, normaliseDCT,
minOscilFreq, maxOscilFreq, eventThreshold, minDuration, maxDuration,
out scores, out predictedEvents, out hits, out segments, out analysisTime);
return(Tuple.Create(sonogram, hits, scores, predictedEvents, segments, analysisTime));
}//end CaneToadRecogniser
public void Setup()
{
this.outputDirectory = PathHelper.GetTempDir();
this.recording = new AudioRecording(PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav"));
// specified linear scale
this.freqScale = new FrequencyScale(nyquist: 11025, frameSize: 1024, hertzGridInterval: 1000);
// set up the config for each spectrogram
this.sonoConfig = new SonogramConfig
{
WindowSize = this.freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = this.recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
}
public void PcaWhiteningDefault()
{
var recordingPath = PathHelper.ResolveAsset("Recordings", "BAC2_20071008-085040.wav");
var fst = FreqScaleType.Linear;
var freqScale = new FrequencyScale(fst);
var recording = new AudioRecording(recordingPath);
var sonoConfig = new SonogramConfig
{
WindowSize = freqScale.FinalBinCount * 2,
WindowOverlap = 0.2,
SourceFName = recording.BaseName,
NoiseReductionType = NoiseReductionType.None,
NoiseReductionParameter = 0.0,
};
// GENERATE AMPLITUDE SPECTROGRAM
var spectrogram = new AmplitudeSonogram(sonoConfig, recording.WavReader);
spectrogram.Configuration.WindowSize = freqScale.WindowSize;
// DO RMS NORMALIZATION
spectrogram.Data = SNR.RmsNormalization(spectrogram.Data);
// CONVERT NORMALIZED AMPLITUDE SPECTROGRAM TO dB SPECTROGRAM
var sonogram = new SpectrogramStandard(spectrogram);
// DO NOISE REDUCTION
var dataMatrix = PcaWhitening.NoiseReduction(sonogram.Data);
sonogram.Data = dataMatrix;
// DO PCA WHITENING
var whitenedSpectrogram = PcaWhitening.Whitening(sonogram.Data);
// DO UNIT TESTING
// check if the dimensions of the reverted spectrogram (second output of the pca whitening) is equal to the input matrix
Assert.AreEqual(whitenedSpectrogram.Reversion.GetLength(0), sonogram.Data.GetLength(0));
Assert.AreEqual(whitenedSpectrogram.Reversion.GetLength(1), sonogram.Data.GetLength(1));
}
/// <summary>
///
/// </summary>
/// <param name="wavPath"></param>
/// <param name="minHz"></param>
/// <param name="maxHz"></param>
/// <param name="frameOverlap"></param>
/// <param name="threshold"></param>
/// <param name="minDuration">used for smoothing intensity as well as for removing short events</param>
/// <param name="maxDuration"></param>
/// <returns></returns>
public static Tuple <BaseSonogram, List <AcousticEvent>, double, double, double, double[]> Execute_Segmentation(FileInfo wavPath,
int minHz, int maxHz, double frameOverlap, double smoothWindow, double thresholdSD, double minDuration, double maxDuration)
{
//i: GET RECORDING
AudioRecording recording = new AudioRecording(wavPath.FullName);
//ii: MAKE SONOGRAM
Log.WriteLine("# Start sonogram.");
SonogramConfig sonoConfig = new SonogramConfig(); //default values config
sonoConfig.WindowOverlap = frameOverlap;
sonoConfig.SourceFName = recording.BaseName;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
//iii: DETECT SEGMENTS
Log.WriteLine("# Start event detection");
var tuple = AcousticEvent.GetSegmentationEvents((SpectrogramStandard)sonogram, TimeSpan.Zero, minHz, maxHz, smoothWindow,
thresholdSD, minDuration, maxDuration);
var tuple2 = Tuple.Create(sonogram, tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4, tuple.Item5);
return(tuple2);
}//end Execute_Segmentation
