// OTHER CONSTANTS
//private const string ImageViewer = @"C:\Windows\system32\mspaint.exe";
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
/// <param name="recording"></param>
/// <param name="configuration"></param>
/// <param name="segmentStartOffset"></param>
/// <param name="getSpectralIndexes"></param>
/// <param name="outputDirectory"></param>
/// <param name="imageWidth"></param>
/// <returns></returns>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
var recognizerConfig = new LitoriaWatjulumConfig();
recognizerConfig.ReadConfigFile(configuration);
//int maxOscilRate = (int)Math.Ceiling(1 / lwConfig.MinPeriod);
if (recording.WavReader.SampleRate != 22050)
{
throw new InvalidOperationException("Requires a 22050Hz file");
}
TimeSpan recordingDuration = recording.WavReader.Time;
// this default framesize seems to work
const int frameSize = 128;
double windowOverlap = 0.0;
// calculate the overlap instead
//double windowOverlap = Oscillations2012.CalculateRequiredFrameOverlap(
// recording.SampleRate,
// frameSize,
// maxOscilRate);
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
//set default values - ignore those set by user
WindowSize = frameSize,
WindowOverlap = windowOverlap,
// the default window is HAMMING
//WindowFunction = WindowFunctions.HANNING.ToString(),
//WindowFunction = WindowFunctions.NONE.ToString(),
// if do not use noise reduction can get a more sensitive recogniser.
//NoiseReductionType = NoiseReductionType.NONE,
NoiseReductionType = SNR.KeyToNoiseReductionType("STANDARD"),
};
//#############################################################################################################################################
//DO THE ANALYSIS
var results = Analysis(recording, sonoConfig, recognizerConfig, MainEntry.InDEBUG, segmentStartOffset);
//######################################################################
if (results == null)
{
return(null); //nothing to process
}
var sonogram = results.Item1;
var hits = results.Item2;
var scoreArray = results.Item3;
var predictedEvents = results.Item4;
var debugImage = results.Item5;
// old way of creating a path:
//var debugPath = outputDirectory.Combine(FilenameHelpers.AnalysisResultName(Path.GetFileNameWithoutExtension(recording.FileName), SpeciesName, "png", "DebugSpectrogram"));
var debugPath = FilenameHelpers.AnalysisResultPath(outputDirectory, recording.BaseName, this.SpeciesName, "png", "DebugSpectrogram");
debugImage.Save(debugPath);
//#############################################################################################################################################
// Prune events here if required i.e. remove those below threshold score if this not already done. See other recognizers.
foreach (var ae in predictedEvents)
{
// add additional info
ae.Name = recognizerConfig.AbbreviatedSpeciesName;
ae.SpeciesName = recognizerConfig.SpeciesName;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
}
// do a recognizer TEST.
if (false)
{
var testDir = new DirectoryInfo(outputDirectory.Parent.Parent.FullName);
TestTools.RecognizerScoresTest(recording.BaseName, testDir, recognizerConfig.AnalysisName, scoreArray);
AcousticEvent.TestToCompareEvents(recording.BaseName, testDir, recognizerConfig.AnalysisName, predictedEvents);
}
var plot = new Plot(this.DisplayName, scoreArray, recognizerConfig.EventThreshold);
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = predictedEvents,
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
/// <param name="recording"></param>
/// <param name="configuration"></param>
/// <param name="segmentStartOffset"></param>
/// <param name="getSpectralIndexes"></param>
/// <param name="outputDirectory"></param>
/// <param name="imageWidth"></param>
/// <returns></returns>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
var recognizerConfig = new LitoriaNasutaConfig();
recognizerConfig.ReadConfigFile(configuration);
// BETTER TO SET THESE. IGNORE USER!
// this default framesize seems to work
const int frameSize = 1024;
const double windowOverlap = 0.0;
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
// use the default HAMMING window
//WindowFunction = WindowFunctions.HANNING.ToString(),
//WindowFunction = WindowFunctions.NONE.ToString(),
// if do not use noise reduction can get a more sensitive recogniser.
//NoiseReductionType = NoiseReductionType.None
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.0,
};
TimeSpan recordingDuration = recording.WavReader.Time;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
int minBin = (int)Math.Round(recognizerConfig.MinHz / freqBinWidth) + 1;
int maxBin = (int)Math.Round(recognizerConfig.MaxHz / freqBinWidth) + 1;
var decibelThreshold = 3.0;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
int rowCount = sonogram.Data.GetLength(0);
double[] amplitudeArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, minBin, rowCount - 1, maxBin);
//double[] topBand = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, maxBin + 3, (rowCount - 1), maxBin + 9);
//double[] botBand = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, minBin - 3, (rowCount - 1), minBin - 9);
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
var acousticEvents = AcousticEvent.ConvertScoreArray2Events(
amplitudeArray,
recognizerConfig.MinHz,
recognizerConfig.MaxHz,
sonogram.FramesPerSecond,
freqBinWidth,
decibelThreshold,
recognizerConfig.MinDuration,
recognizerConfig.MaxDuration,
segmentStartOffset);
double[,] hits = null;
var prunedEvents = new List <AcousticEvent>();
acousticEvents.ForEach(ae =>
{
ae.SpeciesName = recognizerConfig.SpeciesName;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.Name = recognizerConfig.AbbreviatedSpeciesName;
});
var thresholdedPlot = new double[amplitudeArray.Length];
for (int x = 0; x < amplitudeArray.Length; x++)
{
if (amplitudeArray[x] > decibelThreshold)
{
thresholdedPlot[x] = amplitudeArray[x];
}
}
var maxDb = amplitudeArray.MaxOrDefault();
double[] normalisedScores;
double normalisedThreshold;
DataTools.Normalise(thresholdedPlot, decibelThreshold, out normalisedScores, out normalisedThreshold);
var text = string.Format($"{this.DisplayName} (Fullscale={maxDb:f1}dB)");
var plot = new Plot(text, normalisedScores, normalisedThreshold);
if (true)
{
// display a variety of debug score arrays
DataTools.Normalise(amplitudeArray, decibelThreshold, out normalisedScores, out normalisedThreshold);
var amplPlot = new Plot("Band amplitude", normalisedScores, normalisedThreshold);
var debugPlots = new List <Plot> {
plot, amplPlot
};
// NOTE: This DrawDebugImage() method can be over-written in this class.
var debugImage = DrawDebugImage(sonogram, acousticEvents, debugPlots, hits);
var debugPath = FilenameHelpers.AnalysisResultPath(outputDirectory, recording.BaseName, this.SpeciesName, "png", "DebugSpectrogram");
debugImage.Save(debugPath);
}
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = acousticEvents,
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
/// <param name="recording"></param>
/// <param name="configuration"></param>
/// <param name="segmentStartOffset"></param>
/// <param name="getSpectralIndexes"></param>
/// <param name="outputDirectory"></param>
/// <param name="imageWidth"></param>
/// <returns></returns>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
var recognizerConfig = new LitoriaCaeruleaConfig();
recognizerConfig.ReadConfigFile(configuration);
// common properties
string speciesName = configuration[AnalysisKeys.SpeciesName] ?? "<no name>";
string abbreviatedSpeciesName = configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";
// BETTER TO SET THESE. IGNORE USER!
// This framesize is large because the oscillation we wish to detect is due to repeated croaks
// having an interval of about 0.6 seconds. The overlap is also required to give smooth oscillation.
const int frameSize = 2048;
const double windowOverlap = 0.5;
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
// use the default HAMMING window
//WindowFunction = WindowFunctions.HANNING.ToString(),
//WindowFunction = WindowFunctions.NONE.ToString(),
// if do not use noise reduction can get a more sensitive recogniser.
//NoiseReductionType = NoiseReductionType.None
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.0,
};
TimeSpan recordingDuration = recording.WavReader.Time;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
double framesPerSecond = sr / (sonoConfig.WindowSize * (1 - windowOverlap));
//int dominantFreqBin = (int)Math.Round(recognizerConfig.DominantFreq / freqBinWidth) + 1;
int minBin = (int)Math.Round(recognizerConfig.MinHz / freqBinWidth) + 1;
int maxBin = (int)Math.Round(recognizerConfig.MaxHz / freqBinWidth) + 1;
var decibelThreshold = 9.0;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
int rowCount = sonogram.Data.GetLength(0);
// get the freq band as set by min and max Herz
var frogBand = MatrixTools.Submatrix(sonogram.Data, 0, minBin, rowCount - 1, maxBin);
// Now look for spectral maxima. For L.caerulea, the max should lie around 1100Hz +/-150 Hz.
// Skip over spectra where maximum is not in correct location.
int buffer = 150;
var croakScoreArray = new double[rowCount];
var hzAtTopOfTopBand = recognizerConfig.DominantFreq + buffer;
var hzAtBotOfTopBand = recognizerConfig.DominantFreq - buffer;
var binAtTopOfTopBand = (int)Math.Round((hzAtTopOfTopBand - recognizerConfig.MinHz) / freqBinWidth);
var binAtBotOfTopBand = (int)Math.Round((hzAtBotOfTopBand - recognizerConfig.MinHz) / freqBinWidth);
// scan the frog band and get the decibel value of those spectra which have their maximum within the correct subband.
for (int x = 0; x < rowCount; x++)
{
//extract spectrum
var spectrum = MatrixTools.GetRow(frogBand, x);
int maxIndex = DataTools.GetMaxIndex(spectrum);
if (spectrum[maxIndex] < decibelThreshold)
{
continue;
}
if (maxIndex < binAtTopOfTopBand && maxIndex > binAtBotOfTopBand)
{
croakScoreArray[x] = spectrum[maxIndex];
}
}
// Perpare a normalised plot for later display with spectrogram
double[] normalisedScores;
double normalisedThreshold;
DataTools.Normalise(croakScoreArray, decibelThreshold, out normalisedScores, out normalisedThreshold);
var text1 = string.Format($"Croak scores (threshold={decibelThreshold})");
var croakPlot1 = new Plot(text1, normalisedScores, normalisedThreshold);
// extract potential croak events from the array of croak candidate
var croakEvents = AcousticEvent.ConvertScoreArray2Events(
croakScoreArray,
recognizerConfig.MinHz,
recognizerConfig.MaxHz,
sonogram.FramesPerSecond,
freqBinWidth,
recognizerConfig.EventThreshold,
recognizerConfig.MinCroakDuration,
recognizerConfig.MaxCroakDuration,
segmentStartOffset);
// add necesary info into the candidate events
var prunedEvents = new List <AcousticEvent>();
foreach (var ae in croakEvents)
{
// add additional info
ae.SpeciesName = speciesName;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.Name = recognizerConfig.AbbreviatedSpeciesName;
prunedEvents.Add(ae);
}
// With those events that survive the above Array2Events process, we now extract a new array croak scores
croakScoreArray = AcousticEvent.ExtractScoreArrayFromEvents(prunedEvents, rowCount, recognizerConfig.AbbreviatedSpeciesName);
DataTools.Normalise(croakScoreArray, decibelThreshold, out normalisedScores, out normalisedThreshold);
var text2 = string.Format($"Croak events (threshold={decibelThreshold})");
var croakPlot2 = new Plot(text2, normalisedScores, normalisedThreshold);
// Look for oscillations in the difference array
// duration of DCT in seconds
//croakScoreArray = DataTools.filterMovingAverageOdd(croakScoreArray, 5);
double dctDuration = recognizerConfig.DctDuration;
// minimum acceptable value of a DCT coefficient
double dctThreshold = recognizerConfig.DctThreshold;
double minOscRate = 1 / recognizerConfig.MaxPeriod;
double maxOscRate = 1 / recognizerConfig.MinPeriod;
var dctScores = Oscillations2012.DetectOscillations(croakScoreArray, framesPerSecond, dctDuration, minOscRate, maxOscRate, dctThreshold);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
var events = AcousticEvent.ConvertScoreArray2Events(
dctScores,
recognizerConfig.MinHz,
recognizerConfig.MaxHz,
sonogram.FramesPerSecond,
freqBinWidth,
recognizerConfig.EventThreshold,
recognizerConfig.MinDuration,
recognizerConfig.MaxDuration,
segmentStartOffset);
double[,] hits = null;
prunedEvents = new List <AcousticEvent>();
foreach (var ae in events)
{
// add additional info
ae.SpeciesName = speciesName;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.Name = recognizerConfig.AbbreviatedSpeciesName;
prunedEvents.Add(ae);
}
// do a recognizer test.
if (MainEntry.InDEBUG)
{
//TestTools.RecognizerScoresTest(scores, new FileInfo(recording.FilePath));
//AcousticEvent.TestToCompareEvents(prunedEvents, new FileInfo(recording.FilePath));
}
var scoresPlot = new Plot(this.DisplayName, dctScores, recognizerConfig.EventThreshold);
if (true)
{
// display a variety of debug score arrays
// calculate amplitude at location
double[] amplitudeArray = MatrixTools.SumRows(frogBand);
DataTools.Normalise(amplitudeArray, decibelThreshold, out normalisedScores, out normalisedThreshold);
var amplPlot = new Plot("Band amplitude", normalisedScores, normalisedThreshold);
var debugPlots = new List <Plot> {
scoresPlot, croakPlot2, croakPlot1, amplPlot
};
// NOTE: This DrawDebugImage() method can be over-written in this class.
var debugImage = DrawDebugImage(sonogram, prunedEvents, debugPlots, hits);
var debugPath = FilenameHelpers.AnalysisResultPath(outputDirectory, recording.BaseName, this.SpeciesName, "png", "DebugSpectrogram");
debugImage.Save(debugPath);
}
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = scoresPlot.AsList(),
Events = prunedEvents,
//Events = events
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
/// <param name="audioRecording"></param>
/// <param name="configuration"></param>
/// <param name="segmentStartOffset"></param>
/// <param name="getSpectralIndexes"></param>
/// <param name="outputDirectory"></param>
/// <param name="imageWidth"></param>
/// <returns></returns>
public override RecognizerResults Recognize(AudioRecording audioRecording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
const double minAmplitudeThreshold = 0.1;
const int percentile = 5;
const double scoreThreshold = 0.3;
const bool doFiltering = true;
const int windowWidth = 1024;
const int signalBuffer = windowWidth * 2;
//string path = @"C:\SensorNetworks\WavFiles\Freshwater\savedfortest.wav";
//audioRecording.Save(path); // this does not work
int sr = audioRecording.SampleRate;
int nyquist = audioRecording.Nyquist;
// Get a value from the config file - with a backup default
//int minHz = (int?)configuration[AnalysisKeys.MinHz] ?? 600;
// Get a value from the config file - with no default, throw an exception if value is not present
//int maxHz = ((int?)configuration[AnalysisKeys.MaxHz]).Value;
// Get a value from the config file - without a string accessor, as a double
//double someExampleSettingA = (double?)configuration.someExampleSettingA ?? 0.0;
// common properties
//string speciesName = (string)configuration[AnalysisKeys.SpeciesName] ?? "<no species>";
//string abbreviatedSpeciesName = (string)configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";
// min score for an acceptable event
double eventThreshold = (double)configuration.GetDoubleOrNull(AnalysisKeys.EventThreshold);
// get samples
var samples = audioRecording.WavReader.Samples;
double[] bandPassFilteredSignal = null;
if (doFiltering)
{
// high pass filter
int windowLength = 71;
double[] highPassFilteredSignal;
DSP_IIRFilter.ApplyMovingAvHighPassFilter(samples, windowLength, out highPassFilteredSignal);
//DSP_IIRFilter filter2 = new DSP_IIRFilter("Chebyshev_Highpass_400");
//int order2 = filter2.order;
//filter2.ApplyIIRFilter(samples, out highPassFilteredSignal);
// Amplify 40dB and clip to +/-1.0;
double factor = 100; // equiv to 20dB
highPassFilteredSignal = DspFilters.AmplifyAndClip(highPassFilteredSignal, factor);
//low pass filter
string filterName = "Chebyshev_Lowpass_5000, scale*5";
DSP_IIRFilter filter = new DSP_IIRFilter(filterName);
int order = filter.order;
//System.LoggedConsole.WriteLine("\nTest " + filterName + ", order=" + order);
filter.ApplyIIRFilter(highPassFilteredSignal, out bandPassFilteredSignal);
}
else // do not filter because already filtered - using Chris's filtered recording
{
bandPassFilteredSignal = samples;
}
// calculate an amplitude threshold that is above Nth percentile of amplitudes in the subsample
int[] histogramOfAmplitudes;
double minAmplitude;
double maxAmplitude;
double binWidth;
int window = 66;
Histogram.GetHistogramOfWaveAmplitudes(bandPassFilteredSignal, window, out histogramOfAmplitudes, out minAmplitude, out maxAmplitude, out binWidth);
int percentileBin = Histogram.GetPercentileBin(histogramOfAmplitudes, percentile);
double amplitudeThreshold = (percentileBin + 1) * binWidth;
if (amplitudeThreshold < minAmplitudeThreshold)
{
amplitudeThreshold = minAmplitudeThreshold;
}
bool doAnalysisOfKnownExamples = true;
if (doAnalysisOfKnownExamples)
{
// go to fixed location to check
//1:02.07, 1:07.67, 1:12.27, 1:12.42, 1:12.59, 1:12.8, 1.34.3, 1:35.3, 1:40.16, 1:50.0, 2:05.9, 2:06.62, 2:17.57, 2:21.0
//2:26.33, 2:43.07, 2:43.15, 3:16.55, 3:35.09, 4:22.44, 4:29.9, 4:42.6, 4:51.48, 5:01.8, 5:21.15, 5:22.72, 5:32.37, 5.36.1,
//5:42.82, 6:03.5, 6:19.93, 6:21.55, 6:42.0, 6:42.15, 6:46.44, 7:12.17, 7:42.65, 7:45.86, 7:46.18, 7:52.38, 7:59.11, 8:10.63,
//8:14.4, 8:14.63, 8_15_240, 8_46_590, 8_56_590, 9_25_77, 9_28_94, 9_30_5, 9_43_9, 10_03_19, 10_24_26, 10_24_36, 10_38_8,
//10_41_08, 10_50_9, 11_05_13, 11_08_63, 11_44_66, 11_50_36, 11_51_2, 12_04_93, 12_10_05, 12_20_78, 12_27_0, 12_38_5,
//13_02_25, 13_08_18, 13_12_8, 13_25_24, 13_36_0, 13_50_4, 13_51_2, 13_57_87, 14_15_00, 15_09_74, 15_12_14, 15_25_79
//double[] times = { 2.2, 26.589, 29.62 };
//double[] times = { 2.2, 3.68, 10.83, 24.95, 26.589, 27.2, 29.62 };
//double[] times = { 2.2, 3.68, 10.83, 24.95, 26.589, 27.2, 29.62, 31.39, 62.1, 67.67, 72.27, 72.42, 72.59, 72.8, 94.3, 95.3,
// 100.16, 110.0, 125.9, 126.62, 137.57, 141.0, 146.33, 163.07, 163.17, 196.55, 215.09, 262.44, 269.9, 282.6,
// 291.48, 301.85, 321.18, 322.72, 332.37, 336.1, 342.82, 363.5, 379.93, 381.55, 402.0, 402.15, 406.44, 432.17,
// 462.65, 465.86, 466.18, 472.38, 479.14, 490.63, 494.4, 494.63, 495.240, 526.590, 536.590, 565.82, 568.94,
// 570.5, 583.9, 603.19, 624.26, 624.36, 638.8, 641.08, 650.9, 65.13, 68.63, 704.66,
// 710.36, 711.2, 724.93, 730.05, 740.78, 747.05, 758.5, 782.25, 788.18, 792.8,
// 805.24, 816.03, 830.4, 831.2, 837.87, 855.02, 909.74, 912.14, 925.81 };
var filePath = new FileInfo(@"C:\SensorNetworks\WavFiles\Freshwater\GruntSummaryRevisedAndEditedByMichael.csv");
List <CatFishCallData> data = Csv.ReadFromCsv <CatFishCallData>(filePath, true).ToList();
//var catFishCallDatas = data as IList<CatFishCallData> ?? data.ToList();
int count = data.Count();
var subSamplesDirectory = outputDirectory.CreateSubdirectory("testSubsamples_5000LPFilter");
//for (int t = 0; t < times.Length; t++)
foreach (var fishCall in data)
{
//Image bmp1 = IctalurusFurcatus.AnalyseLocation(bandPassFilteredSignal, sr, times[t], windowWidth);
// use following line where using time in seconds
//int location = (int)Math.Round(times[t] * sr); //assume location points to start of grunt
//double[] subsample = DataTools.Subarray(bandPassFilteredSignal, location - signalBuffer, 2 * signalBuffer);
// use following line where using sample
int location1 = fishCall.Sample / 2; //assume Chris's sample location points to centre of grunt. Divide by 2 because original recording was 44100.
int location = (int)Math.Round(fishCall.TimeSeconds * sr); //assume location points to centre of grunt
double[] subsample = DataTools.Subarray(bandPassFilteredSignal, location - signalBuffer, 2 * signalBuffer);
// calculate an amplitude threshold that is above 95th percentile of amplitudes in the subsample
//int[] histogramOfAmplitudes;
//double minAmplitude;
//double maxAmplitude;
//double binWidth;
//int window = 70;
//int percentile = 90;
//Histogram.GetHistogramOfWaveAmplitudes(subsample, window, out histogramOfAmplitudes, out minAmplitude, out maxAmplitude, out binWidth);
//int percentileBin = Histogram.GetPercentileBin(histogramOfAmplitudes, percentile);
//double amplitudeThreshold = (percentileBin + 1) * binWidth;
//if (amplitudeThreshold < minAmplitudeThreshold) amplitudeThreshold = minAmplitudeThreshold;
double[] scores1 = AnalyseWaveformAtLocation(subsample, amplitudeThreshold, scoreThreshold);
string title1 = $"scores={fishCall.Timehms}";
Image bmp1 = GraphsAndCharts.DrawGraph(title1, scores1, subsample.Length, 300, 1);
//bmp1.Save(path1.FullName);
string title2 = $"tStart={fishCall.Timehms}";
Image bmp2 = GraphsAndCharts.DrawWaveform(title2, subsample, 1);
var path1 = subSamplesDirectory.CombineFile($"scoresForTestSubsample_{fishCall.TimeSeconds}secs.png");
//var path2 = subSamplesDirectory.CombineFile($@"testSubsample_{times[t]}secs.wav.png");
Image[] imageList = { bmp2, bmp1 };
Image bmp3 = ImageTools.CombineImagesVertically(imageList);
bmp3.Save(path1.FullName);
//write wave form to txt file for later work in XLS
//var path3 = subSamplesDirectory.CombineFile($@"testSubsample_{times[t]}secs.wav.csv");
//signalBuffer = 800;
//double[] subsample2 = DataTools.Subarray(bandPassFilteredSignal, location - signalBuffer, 3 * signalBuffer);
//FileTools.WriteArray2File(subsample2, path3.FullName);
}
}
int signalLength = bandPassFilteredSignal.Length;
// count number of 1000 sample segments
int blockLength = 1000;
int blockCount = signalLength / blockLength;
int[] indexOfMax = new int[blockCount];
double[] maxInBlock = new double[blockCount];
for (int i = 0; i < blockCount; i++)
{
double max = -2.0;
int blockStart = blockLength * i;
for (int s = 0; s < blockLength; s++)
{
double absValue = Math.Abs(bandPassFilteredSignal[blockStart + s]);
if (absValue > max)
{
max = absValue;
maxInBlock[i] = max;
indexOfMax[i] = blockStart + s;
}
}
}
// transfer max values to a list
var indexList = new List <int>();
for (int i = 1; i < blockCount - 1; i++)
{
// only find the blocks that contain a max value that is > neighbouring blocks
if (maxInBlock[i] > maxInBlock[i - 1] && maxInBlock[i] > maxInBlock[i + 1])
{
indexList.Add(indexOfMax[i]);
}
//ALTERNATIVELY
// look at max in each block
//indexList.Add(indexOfMax[i]);
}
// now process neighbourhood of each max
int binCount = windowWidth / 2;
FFT.WindowFunc wf = FFT.Hamming;
var fft = new FFT(windowWidth, wf);
int maxHz = 1000;
double hzPerBin = nyquist / (double)binCount;
int requiredBinCount = (int)Math.Round(maxHz / hzPerBin);
// init list of events
List <AcousticEvent> events = new List <AcousticEvent>();
double[] scores = new double[signalLength]; // init of score array
int id = 0;
foreach (int location in indexList)
{
//System.LoggedConsole.WriteLine("Location " + location + ", id=" + id);
int start = location - binCount;
if (start < 0)
{
continue;
}
int end = location + binCount;
if (end >= signalLength)
{
continue;
}
double[] subsampleWav = DataTools.Subarray(bandPassFilteredSignal, start, windowWidth);
var spectrum = fft.Invoke(subsampleWav);
// convert to power
spectrum = DataTools.SquareValues(spectrum);
spectrum = DataTools.filterMovingAverageOdd(spectrum, 3);
spectrum = DataTools.normalise(spectrum);
var subBandSpectrum = DataTools.Subarray(spectrum, 1, requiredBinCount); // ignore DC in bin zero.
// now do some tests on spectrum to determine if it is a candidate grunt
bool eventFound = false;
double[] scoreArray = CalculateScores(subBandSpectrum, windowWidth);
double score = scoreArray[0];
if (score > scoreThreshold)
{
eventFound = true;
}
if (eventFound)
{
for (int i = location - binCount; i < location + binCount; i++)
{
scores[location] = score;
}
var startTime = TimeSpan.FromSeconds((location - binCount) / (double)sr);
string startLabel = startTime.Minutes + "." + startTime.Seconds + "." + startTime.Milliseconds;
Image image4 = GraphsAndCharts.DrawWaveAndFft(subsampleWav, sr, startTime, spectrum, maxHz * 2, scoreArray);
var path4 = outputDirectory.CreateSubdirectory("subsamples").CombineFile($@"subsample_{location}_{startLabel}.png");
image4.Save(path4.FullName);
// have an event, store the data in the AcousticEvent class
double duration = 0.2;
int minFreq = 50;
int maxFreq = 1000;
var anEvent = new AcousticEvent(segmentStartOffset, startTime.TotalSeconds, duration, minFreq, maxFreq);
anEvent.Name = "grunt";
//anEvent.Name = DataTools.WriteArrayAsCsvLine(subBandSpectrum, "f4");
anEvent.Score = score;
events.Add(anEvent);
}
id++;
}
// make a spectrogram
var config = new SonogramConfig
{
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = configuration.GetDoubleOrNull(AnalysisKeys.NoiseBgThreshold) ?? 0.0,
};
var sonogram = (BaseSonogram) new SpectrogramStandard(config, audioRecording.WavReader);
//// when the value is accessed, the indices are calculated
//var indices = getSpectralIndexes.Value;
//// check if the indices have been calculated - you shouldn't actually need this
//if (getSpectralIndexes.IsValueCreated)
//{
// // then indices have been calculated before
//}
var plot = new Plot(this.DisplayName, scores, eventThreshold);
return(new RecognizerResults()
{
Events = events,
Hits = null,
//ScoreTrack = null,
Plots = plot.AsList(),
Sonogram = sonogram,
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
// common properties
var speciesName = configuration[AnalysisKeys.SpeciesName] ?? "<no species>";
var abbreviatedSpeciesName = configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";
int minHz = configuration.GetInt(AnalysisKeys.MinHz);
int maxHz = configuration.GetInt(AnalysisKeys.MaxHz);
// BETTER TO CALCULATE THIS. IGNORE USER!
// double frameOverlap = Double.Parse(configDict[Keys.FRAME_OVERLAP]);
// duration of DCT in seconds
double dctDuration = configuration.GetDouble(AnalysisKeys.DctDuration);
// minimum acceptable value of a DCT coefficient
double dctThreshold = configuration.GetDouble(AnalysisKeys.DctThreshold);
// ignore oscillations below this threshold freq
int minOscilFreq = configuration.GetInt(AnalysisKeys.MinOscilFreq);
// ignore oscillations above this threshold freq
int maxOscilFreq = configuration.GetInt(AnalysisKeys.MaxOscilFreq);
// min duration of event in seconds
double minDuration = configuration.GetDouble(AnalysisKeys.MinDuration);
// max duration of event in seconds
double maxDuration = configuration.GetDouble(AnalysisKeys.MaxDuration);
// min score for an acceptable event
double eventThreshold = configuration.GetDouble(AnalysisKeys.EventThreshold);
// this default framesize seems to work for Canetoad
const int frameSize = 512;
double windowOverlap = Oscillations2012.CalculateRequiredFrameOverlap(
recording.SampleRate,
frameSize,
maxOscilFreq);
//windowOverlap = 0.75; // previous default
// DEBUG: Following line used to search for where indeterminism creeps into the spectrogram values which vary from run to run.
//FileTools.AddArrayAdjacentToExistingArrays(Path.Combine(outputDirectory.FullName, recording.BaseName+"_RecordingSamples.csv"), recording.WavReader.GetChannel(0));
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
// the default window is HAMMING
//WindowFunction = WindowFunctions.HANNING.ToString(),
//WindowFunction = WindowFunctions.NONE.ToString(),
// if do not use noise reduction can get a more sensitive recogniser.
NoiseReductionType = NoiseReductionType.None,
};
// sonoConfig.NoiseReductionType = SNR.Key2NoiseReductionType("STANDARD");
TimeSpan recordingDuration = recording.Duration;
//int sr = recording.SampleRate;
//double freqBinWidth = sr / (double)sonoConfig.WindowSize;
/* #############################################################################################################################################
* window sr frameDuration frames/sec hz/bin 64frameDuration hz/64bins hz/128bins
* 1024 22050 46.4ms 21.5 21.5 2944ms 1376hz 2752hz
* 1024 17640 58.0ms 17.2 17.2 3715ms 1100hz 2200hz
* 2048 17640 116.1ms 8.6 8.6 7430ms 551hz 1100hz
*/
// int minBin = (int)Math.Round(minHz / freqBinWidth) + 1;
// int maxbin = minBin + numberOfBins - 1;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
//int rowCount = sonogram.Data.GetLength(0);
//int colCount = sonogram.Data.GetLength(1);
// DEBUG: Following lines used to search for where indeterminism creeps into the spectrogram values which vary from run to run.
//double[] array = DataTools.Matrix2Array(sonogram.Data);
//FileTools.AddArrayAdjacentToExistingArrays(Path.Combine(outputDirectory.FullName, recording.BaseName+".csv"), array);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
double minDurationOfAdvertCall = minDuration; // this boundary duration should = 5.0 seconds as of 4 June 2015.
//double minDurationOfReleaseCall = 1.0;
Oscillations2012.Execute(
(SpectrogramStandard)sonogram,
minHz,
maxHz,
dctDuration,
minOscilFreq,
maxOscilFreq,
dctThreshold,
eventThreshold,
minDurationOfAdvertCall,
maxDuration,
out var scores,
out var oscillationEvents,
out var hits,
segmentStartOffset);
// DEBUG: Following line used to search for where indeterminism creeps into the event detection
//FileTools.AddArrayAdjacentToExistingArrays(Path.Combine(outputDirectory.FullName, recording.BaseName+"_ScoreArray.csv"), scores);
var events = oscillationEvents.ConvertSpectralEventsToAcousticEvents();
var prunedEvents = new List <AcousticEvent>();
foreach (AcousticEvent ae in events)
{
//if (ae.Duration < minDurationOfReleaseCall) { continue; }
if (ae.EventDurationSeconds < minDurationOfAdvertCall)
{
continue;
}
if (ae.EventDurationSeconds > maxDuration)
{
continue;
}
// add additional info
ae.SpeciesName = speciesName;
ae.Name = abbreviatedSpeciesName;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
prunedEvents.Add(ae);
//if (ae.Duration >= minDurationOfAdvertCall)
//{
// ae.Name = abbreviatedSpeciesName; // + ".AdvertCall";
// prunedEvents.Add(ae);
// continue;
//}
}
// do a recognizer test.
if (false)
{
if (MainEntry.InDEBUG)
{
RecognizerTest(scores, new FileInfo(recording.FilePath));
RecognizerTest(prunedEvents, new FileInfo(recording.FilePath));
}
}
var plot = new Plot(this.DisplayName, scores, eventThreshold);
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = prunedEvents,
//Events = events
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
// WARNING: TODO TODO TODO = this method simply duplicates the CANETOAD analyser!!!!!!!!!!!!!!!!!!!!! ###################
string speciesName = configuration[AnalysisKeys.SpeciesName] ?? "<no species>";
string abbreviatedSpeciesName = configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";
int minHz = configuration.GetInt(AnalysisKeys.MinHz);
int maxHz = configuration.GetInt(AnalysisKeys.MaxHz);
// BETTER TO CALCULATE THIS. IGNORE USER!
// double frameOverlap = Double.Parse(configDict[Keys.FRAME_OVERLAP]);
// duration of DCT in seconds
double dctDuration = configuration.GetDouble(AnalysisKeys.DctDuration);
// minimum acceptable value of a DCT coefficient
double dctThreshold = configuration.GetDouble(AnalysisKeys.DctThreshold);
// ignore oscillations below this threshold freq
int minOscilFreq = configuration.GetInt(AnalysisKeys.MinOscilFreq);
// ignore oscillations above this threshold freq
int maxOscilFreq = configuration.GetInt(AnalysisKeys.MaxOscilFreq);
// min duration of event in seconds
double minDuration = configuration.GetDouble(AnalysisKeys.MinDuration);
// max duration of event in seconds
double maxDuration = configuration.GetDouble(AnalysisKeys.MaxDuration);
// min score for an acceptable event
double eventThreshold = configuration.GetDouble(AnalysisKeys.EventThreshold);
// The default was 512 for Canetoad.
// Framesize = 128 seems to work for Littoria fallax.
// frame size
int frameSize = configuration.GetInt(AnalysisKeys.KeyFrameSize);
if (recording.WavReader.SampleRate != 22050)
{
throw new InvalidOperationException("Requires a 22050Hz file");
}
double windowOverlap = Oscillations2012.CalculateRequiredFrameOverlap(
recording.SampleRate,
frameSize,
maxOscilFreq);
//windowOverlap = 0.75; // previous default
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
NoiseReductionType = NoiseReductionType.None,
};
// sonoConfig.NoiseReductionType = SNR.Key2NoiseReductionType("STANDARD");
TimeSpan recordingDuration = recording.Duration;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
/* #############################################################################################################################################
* window sr frameDuration frames/sec hz/bin 64frameDuration hz/64bins hz/128bins
* 1024 22050 46.4ms 21.5 21.5 2944ms 1376hz 2752hz
* 1024 17640 58.0ms 17.2 17.2 3715ms 1100hz 2200hz
* 2048 17640 116.1ms 8.6 8.6 7430ms 551hz 1100hz
*/
// int minBin = (int)Math.Round(minHz / freqBinWidth) + 1;
// int maxbin = minBin + numberOfBins - 1;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
int rowCount = sonogram.Data.GetLength(0);
int colCount = sonogram.Data.GetLength(1);
// double[,] subMatrix = MatrixTools.Submatrix(sonogram.Data, 0, minBin, (rowCount - 1), maxbin);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
//minDuration = 1.0;
Oscillations2012.Execute(
(SpectrogramStandard)sonogram,
minHz,
maxHz,
dctDuration,
minOscilFreq,
maxOscilFreq,
dctThreshold,
eventThreshold,
minDuration,
maxDuration,
out var scores,
out var acousticEvents,
out var hits,
segmentStartOffset);
acousticEvents.ForEach(ae =>
{
ae.SpeciesName = speciesName;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.Name = abbreviatedSpeciesName;
});
var plot = new Plot(this.DisplayName, scores, eventThreshold);
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = acousticEvents,
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
var recognizerConfig = new CriniaRemotaConfig();
recognizerConfig.ReadConfigFile(configuration);
// BETTER TO SET THESE. IGNORE USER!
// this default framesize seems to work
const int frameSize = 256;
const double windowOverlap = 0.25;
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
// use the default HAMMING window
//WindowFunction = WindowFunctions.HANNING.ToString(),
//WindowFunction = WindowFunctions.NONE.ToString(),
// if do not use noise reduction can get a more sensitive recogniser.
//NoiseReductionType = NoiseReductionType.None
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.0,
};
TimeSpan recordingDuration = recording.WavReader.Time;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
int minBin = (int)Math.Round(recognizerConfig.MinHz / freqBinWidth) + 1;
int maxBin = (int)Math.Round(recognizerConfig.MaxHz / freqBinWidth) + 1;
var decibelThreshold = 6.0;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
int rowCount = sonogram.Data.GetLength(0);
double[] amplitudeArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, minBin, rowCount - 1, maxBin);
double[] topBand = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, maxBin + 3, rowCount - 1, maxBin + 9);
double[] botBand = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, minBin - 3, rowCount - 1, minBin - 9);
double[] diffArray = new double[amplitudeArray.Length];
for (int i = 0; i < amplitudeArray.Length; i++)
{
diffArray[i] = amplitudeArray[i] - topBand[i] - botBand[i];
if (diffArray[i] < 1.0)
{
diffArray[i] = 0.0;
}
}
bool[] peakArray = new bool[amplitudeArray.Length];
for (int i = 1; i < diffArray.Length - 1; i++)
{
if (diffArray[i] < decibelThreshold)
{
continue;
}
if (diffArray[i] > diffArray[i - 1] && diffArray[i] > diffArray[i + 1])
{
peakArray[i] = true;
}
}
// calculate score array based on density of peaks
double frameDuration = (double)frameSize / sr;
// use a stimulus-decay function
double durationOfDecayTail = 0.35; // seconds
int lengthOfDecayTail = (int)Math.Round(durationOfDecayTail / frameDuration);
double decayrate = 0.95;
//double decay = -0.05;
//double fractionalDecay = Math.Exp(decay * lengthOfDecayTail);
// the above setting gives decay of 0.22 over 0.35 seconds or 30 frames.
double score = 0.0;
int locationOfLastPeak = 0;
double[] peakScores = new double[amplitudeArray.Length];
for (int p = 0; p < peakScores.Length - 1; p++)
{
if (!peakArray[p])
{
int distanceFromLastpeak = p - locationOfLastPeak;
// score decay
score *= decayrate;
// remove the decay tail
if (score < 0.5 && distanceFromLastpeak > lengthOfDecayTail && p >= lengthOfDecayTail)
{
score = 0.0;
for (int j = 0; j < lengthOfDecayTail; j++)
{
peakScores[p - j] = score;
}
}
}
else
{
locationOfLastPeak = p;
score += 0.8;
}
peakScores[p] = score;
}
var events = AcousticEvent.ConvertScoreArray2Events(
peakScores,
recognizerConfig.MinHz,
recognizerConfig.MaxHz,
sonogram.FramesPerSecond,
freqBinWidth,
recognizerConfig.EventThreshold,
recognizerConfig.MinDuration,
recognizerConfig.MaxDuration,
segmentStartOffset);
double[,] hits = null;
var prunedEvents = new List <AcousticEvent>();
foreach (var ae in events)
{
if (ae.EventDurationSeconds < recognizerConfig.MinDuration || ae.EventDurationSeconds > recognizerConfig.MaxDuration)
{
continue;
}
// add additional info
ae.SpeciesName = recognizerConfig.SpeciesName;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.Name = recognizerConfig.AbbreviatedSpeciesName;
prunedEvents.Add(ae);
}
// do a recognizer test.
if (MainEntry.InDEBUG)
{
// var testDir = new DirectoryInfo(outputDirectory.Parent.Parent.FullName);
// TestTools.RecognizerScoresTest(recording.BaseName, testDir, recognizerConfig.AnalysisName, peakScores);
// AcousticEvent.TestToCompareEvents(recording.BaseName, testDir, recognizerConfig.AnalysisName, prunedEvents);
}
var plot = new Plot(this.DisplayName, peakScores, recognizerConfig.EventThreshold);
if (false)
{
// display a variety of debug score arrays
double[] normalisedScores;
double normalisedThreshold;
DataTools.Normalise(amplitudeArray, decibelThreshold, out normalisedScores, out normalisedThreshold);
var amplPlot = new Plot("Band amplitude", normalisedScores, normalisedThreshold);
DataTools.Normalise(diffArray, decibelThreshold, out normalisedScores, out normalisedThreshold);
var diffPlot = new Plot("Diff plot", normalisedScores, normalisedThreshold);
var debugPlots = new List <Plot> {
plot, amplPlot, diffPlot
};
// NOTE: This DrawDebugImage() method can be over-written in this class.
var debugImage = DrawDebugImage(sonogram, prunedEvents, debugPlots, hits);
var debugPath = FilenameHelpers.AnalysisResultPath(outputDirectory, recording.BaseName, this.SpeciesName, "png", "DebugSpectrogram");
debugImage.Save(debugPath);
}
return(new RecognizerResults
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = prunedEvents,
//Events = events
});
} // Recognize()
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
public override RecognizerResults Recognize(
AudioRecording recording,
Config configuration,
TimeSpan segmentStartOffset,
Lazy <IndexCalculateResult[]> getSpectralIndexes,
DirectoryInfo outputDirectory,
int?imageWidth)
{
string speciesName = configuration[AnalysisKeys.SpeciesName] ?? "<no species>";
string abbreviatedSpeciesName = configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";
int minHz = configuration.GetInt(AnalysisKeys.MinHz);
int maxHz = configuration.GetInt(AnalysisKeys.MaxHz);
// BETTER TO CALCULATE THIS. IGNORE USER!
// double frameOverlap = Double.Parse(configDict[Keys.FRAME_OVERLAP]);
// duration of DCT in seconds
double dctDuration = configuration.GetDouble(AnalysisKeys.DctDuration);
// minimum acceptable value of a DCT coefficient
double dctThreshold = configuration.GetDouble(AnalysisKeys.DctThreshold);
// ignore oscillations below this threshold freq
int minOscilFreq = configuration.GetInt(AnalysisKeys.MinOscilFreq);
// ignore oscillations above this threshold freq
int maxOscilFreq = configuration.GetInt(AnalysisKeys.MaxOscilFreq);
// min duration of event in seconds
double minDuration = configuration.GetDouble(AnalysisKeys.MinDuration);
// max duration of event in seconds
double maxDuration = configuration.GetDouble(AnalysisKeys.MaxDuration);
// The default was 512 for Canetoad.
// Framesize = 128 seems to work for Littoria fallax.
// frame size
int frameSize = configuration.GetInt(AnalysisKeys.KeyFrameSize);
// min score for an acceptable event
double eventThreshold = configuration.GetDouble(AnalysisKeys.EventThreshold);
if (recording.WavReader.SampleRate != 22050)
{
throw new InvalidOperationException("Requires a 22050Hz file");
}
double windowOverlap = Oscillations2012.CalculateRequiredFrameOverlap(
recording.SampleRate,
frameSize,
maxOscilFreq);
//windowOverlap = 0.75; // previous default
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
//NoiseReductionType = NoiseReductionType.NONE,
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = 0.1,
};
TimeSpan recordingDuration = recording.Duration;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
int rowCount = sonogram.Data.GetLength(0);
int colCount = sonogram.Data.GetLength(1);
// double[,] subMatrix = MatrixTools.Submatrix(sonogram.Data, 0, minBin, (rowCount - 1), maxbin);
// ######################################################################
// ii: DO THE ANALYSIS AND RECOVER SCORES OR WHATEVER
// This window is used to smooth the score array before extracting events.
// A short window preserves sharper score edges to define events but also keeps noise.
int scoreSmoothingWindow = 5;
Oscillations2012.Execute(
(SpectrogramStandard)sonogram,
minHz,
maxHz,
dctDuration,
minOscilFreq,
maxOscilFreq,
dctThreshold,
eventThreshold,
minDuration,
maxDuration,
scoreSmoothingWindow,
out var scores,
out var acousticEvents,
out var hits,
segmentStartOffset);
acousticEvents.ForEach(
ae =>
{
ae.SpeciesName = speciesName;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.Name = abbreviatedSpeciesName;
});
var plot = new Plot(this.DisplayName, scores, eventThreshold);
var plots = new List <Plot> {
plot
};
this.WriteDebugImage(recording.BaseName, outputDirectory, sonogram, acousticEvents, plots, hits);
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = acousticEvents,
});
}
/// <summary>
/// Do your analysis. This method is called once per segment (typically one-minute segments).
/// </summary>
public override RecognizerResults Recognize(AudioRecording recording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
{
// common properties
string speciesName = configuration[AnalysisKeys.SpeciesName] ?? "<no name>";
string abbreviatedSpeciesName = configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";
int minHz = configuration.GetInt(AnalysisKeys.MinHz);
int maxHz = configuration.GetInt(AnalysisKeys.MaxHz);
// BETTER TO CALCULATE THIS. IGNORE USER!
// double frameOverlap = Double.Parse(configDict[Keys.FRAME_OVERLAP]);
// duration of DCT in seconds
//double dctDuration = (double)configuration[AnalysisKeys.DctDuration];
// minimum acceptable value of a DCT coefficient
//double dctThreshold = (double)configuration[AnalysisKeys.DctThreshold];
double noiseReductionParameter = configuration.GetDoubleOrNull("SeverityOfNoiseRemoval") ?? 2.0;
double decibelThreshold = configuration.GetDouble("DecibelThreshold");
//double minPeriod = (double)configuration["MinPeriod"]; //: 0.18
//double maxPeriod = (double)configuration["MaxPeriod"]; //
//int maxOscilRate = (int)Math.Ceiling(1 /minPeriod);
//int minOscilRate = (int)Math.Floor(1 /maxPeriod);
// min duration of event in seconds
double minDuration = configuration.GetDouble(AnalysisKeys.MinDuration);
// max duration of event in second
var maxDuration = configuration.GetDouble(AnalysisKeys.MaxDuration);
// min score for an acceptable event
var eventThreshold = configuration.GetDouble(AnalysisKeys.EventThreshold);
// this default framesize and overlap is best for the White Hrron of Bhutan.
const int frameSize = 2048;
double windowOverlap = 0.0;
// i: MAKE SONOGRAM
var sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
// the default window is HAMMING
//WindowFunction = WindowFunctions.HANNING.ToString(),
NoiseReductionType = NoiseReductionType.Standard,
NoiseReductionParameter = noiseReductionParameter,
};
var recordingDuration = recording.Duration;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
int minBin = (int)Math.Round(minHz / freqBinWidth) + 1;
int maxBin = (int)Math.Round(maxHz / freqBinWidth) + 1;
/* #############################################################################################################################################
* window sr frameDuration frames/sec hz/bin 64frameDuration hz/64bins hz/128bins
* 1024 22050 46.4ms 21.5 21.5 2944ms 1376hz 2752hz
* 1024 17640 58.0ms 17.2 17.2 3715ms 1100hz 2200hz
* 2048 17640 116.1ms 8.6 8.6 7430ms 551hz 1100hz
* 2048 22050 92.8ms 21.5 10.7666 1472ms
*/
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
int rowCount = sonogram.Data.GetLength(0);
int colCount = sonogram.Data.GetLength(1);
// var templates = GetTemplatesForAlgorithm1(14);
var amplitudeArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, minBin, rowCount - 1, maxBin);
bool[] peakArray = new bool[rowCount];
var amplitudeScores = new double[rowCount];
var hits = new double[rowCount, colCount];
const int maxTemplateLength = 20;
const int templateEndPadding = 7;
const int templateOffset = 14;
const int minimumGap = 4;
const int maximumGap = 100;
// first find the amplitude peaks
for (int j = 1; j < amplitudeArray.Length - 1; j++)
{
if (amplitudeArray[j] < decibelThreshold)
{
continue;
}
if (amplitudeArray[j] > amplitudeArray[j - 1] && amplitudeArray[j] > amplitudeArray[j + 1])
{
peakArray[j] = true;
}
}
// get template for end of Herron call
var endTemplate = GetEndTemplateForAlgorithm2();
// now search for peaks that are the correct distance apart.
for (int i = 2; i < amplitudeArray.Length - maxTemplateLength - templateEndPadding; i++)
{
if (!peakArray[i])
{
continue;
}
// calculate distance to next peak
int distanceToNextPeak = CalculateDistanceToNextPeak(peakArray, i);
// skip gaps that are too small or too large
if (distanceToNextPeak < minimumGap || distanceToNextPeak > maximumGap)
{
continue;
}
// The herron call ends with a rising whip
// Check end of call using end template
if (distanceToNextPeak > maxTemplateLength)
{
int start = i - templateOffset;
if (start < 0)
{
start = 0;
}
var endLocality = DataTools.Subarray(amplitudeArray, start, endTemplate.Length);
double endScore = DataTools.CosineSimilarity(endLocality, endTemplate);
for (int to = -templateOffset; to < endTemplate.Length - templateOffset; to++)
{
if (i + to >= 0 && endScore > amplitudeScores[i + to])
{
amplitudeScores[i + to] = endScore;
// hits[i, minBin] = 10;
}
}
for (int k = 2; k < maxTemplateLength; k++)
{
amplitudeScores[i + k] = 0.0;
}
continue;
}
// Get the start template which depends on distance to next peak.
var startTemplate = GetTemplateForAlgorithm2(distanceToNextPeak, templateEndPadding);
// now calculate similarity of locality with the startTemplate
var locality = DataTools.Subarray(amplitudeArray, i - 2, startTemplate.Length); // i-2 because first two places should be zero.
double score = DataTools.CosineSimilarity(locality, startTemplate);
for (int t = 0; t < startTemplate.Length; t++)
{
if (score > amplitudeScores[i + t])
{
amplitudeScores[i + t] = score;
hits[i, minBin] = 10;
}
}
} // loop over peak array
var smoothedScores = DataTools.filterMovingAverageOdd(amplitudeScores, 3);
// iii: CONVERT decibel sum-diff SCORES TO ACOUSTIC EVENTS
var predictedEvents = AcousticEvent.ConvertScoreArray2Events(
smoothedScores,
minHz,
maxHz,
sonogram.FramesPerSecond,
freqBinWidth,
eventThreshold,
minDuration,
maxDuration,
segmentStartOffset);
var prunedEvents = new List <AcousticEvent>();
foreach (var ae in predictedEvents)
{
if (ae.EventDurationSeconds < minDuration)
{
continue;
}
// add additional info
ae.SpeciesName = speciesName;
ae.SegmentStartSeconds = segmentStartOffset.TotalSeconds;
ae.SegmentDurationSeconds = recordingDuration.TotalSeconds;
ae.Name = abbreviatedSpeciesName;
prunedEvents.Add(ae);
}
// do a recognizer test.
//CompareArrayWithBenchmark(scores, new FileInfo(recording.FilePath));
//CompareArrayWithBenchmark(prunedEvents, new FileInfo(recording.FilePath));
var plot = new Plot(this.DisplayName, amplitudeScores, eventThreshold);
return(new RecognizerResults()
{
Sonogram = sonogram,
Hits = hits,
Plots = plot.AsList(),
Events = prunedEvents,
});
}
