} //DetectBarsInTheRowsOfaMatrix()
/// <summary>
/// A METHOD TO DETECT HARMONICS IN THE ROWS of the passed portion of a sonogram.
/// This method assume the matrix is derived from a spectrogram rotated so that the matrix rows are spectral columns of sonogram.
/// Was first developed for crow calls.
/// First looks for a decibel profile that matches the passed call duration and decibel loudness.
/// Then samples the centre portion for the correct harmonic period.
/// </summary>
/// <param name="m">data matrix.</param>
/// <param name="dBThreshold">Minimum sound level.</param>
/// <param name="callSpan">Minimum length of call of interest.</param>
/// <returns>a tuple.</returns>
public static Tuple <double[], double[], double[]> DetectHarmonicsInSonogramMatrix(double[,] m, double dBThreshold, int callSpan)
{
int rowCount = m.GetLength(0);
int colCount = m.GetLength(1);
var intensity = new double[rowCount]; //an array of period intensity
var periodicity = new double[rowCount]; //an array of the periodicity values
double[] dBArray = MatrixTools.GetRowAverages(m);
dBArray = DataTools.filterMovingAverage(dBArray, 3);
// for all time frames
for (int t = 0; t < rowCount; t++)
{
if (dBArray[t] < dBThreshold)
{
continue;
}
var row = MatrixTools.GetRow(m, t);
var spectrum = AutoAndCrossCorrelation.CrossCorr(row, row);
int zeroBinCount = 3; //to remove low freq content which dominates the spectrum
for (int s = 0; s < zeroBinCount; s++)
{
spectrum[s] = 0.0; //in real data these bins are dominant and hide other frequency content
}
spectrum = DataTools.NormaliseArea(spectrum);
int maxId = DataTools.GetMaxIndex(spectrum);
double intensityValue = spectrum[maxId];
intensity[t] = intensityValue;
double period = 0.0;
if (maxId != 0)
{
period = 2 * colCount / (double)maxId;
}
periodicity[t] = period;
}
return(Tuple.Create(dBArray, intensity, periodicity));
}
/// <summary>
/// This method assume the matrix is derived from a spectrogram rotated so that the matrix rows are spectral columns of sonogram.
///
/// </summary>
/// <param name="m"></param>
/// <param name="amplitudeThreshold"></param>
/// <returns></returns>
public static Tuple <double[], double[]> DetectBarsInTheRowsOfaMatrix(double[,] m, double threshold, int zeroBinCount)
{
int rowCount = m.GetLength(0);
int colCount = m.GetLength(1);
var intensity = new double[rowCount]; //an array of period intensity
var periodicity = new double[rowCount]; //an array of the periodicity values
double[] prevRow = MatrixTools.GetRow(m, 0);
prevRow = DataTools.DiffFromMean(prevRow);
for (int r = 1; r < rowCount; r++)
{
double[] thisRow = MatrixTools.GetRow(m, r);
thisRow = DataTools.DiffFromMean(thisRow);
var spectrum = AutoAndCrossCorrelation.CrossCorr(prevRow, thisRow);
for (int s = 0; s < zeroBinCount; s++)
{
spectrum[s] = 0.0; //in real data these bins are dominant and hide other frequency content
}
spectrum = DataTools.NormaliseArea(spectrum);
int maxId = DataTools.GetMaxIndex(spectrum);
double intensityValue = spectrum[maxId];
intensity[r] = intensityValue;
double period = 0.0;
if (maxId != 0)
{
period = 2 * colCount / (double)maxId;
}
periodicity[r] = period;
prevRow = thisRow;
}// rows
return(Tuple.Create(intensity, periodicity));
} //DetectBarsInTheRowsOfaMatrix()
/// <summary>
/// ################ THE KEY ANALYSIS METHOD.
/// </summary>
public static Tuple <BaseSonogram, double[, ], List <Plot>, List <AcousticEvent>, TimeSpan> Analysis(FileInfo fiSegmentOfSourceFile, Dictionary <string, string> configDict, TimeSpan segmentStartOffset)
{
//set default values - ignore those set by user
int frameSize = 128;
double windowOverlap = 0.5;
double intensityThreshold = double.Parse(configDict["INTENSITY_THRESHOLD"]); //in 0-1
double minDuration = double.Parse(configDict["MIN_DURATION"]); // seconds
double maxDuration = double.Parse(configDict["MAX_DURATION"]); // seconds
double minPeriod = double.Parse(configDict["MIN_PERIOD"]); // seconds
double maxPeriod = double.Parse(configDict["MAX_PERIOD"]); // seconds
AudioRecording recording = new AudioRecording(fiSegmentOfSourceFile.FullName);
//i: MAKE SONOGRAM
SonogramConfig sonoConfig = new SonogramConfig
{
SourceFName = recording.BaseName,
WindowSize = frameSize,
WindowOverlap = windowOverlap,
NoiseReductionType = SNR.KeyToNoiseReductionType("STANDARD"),
}; //default values config
//sonoConfig.NoiseReductionType = SNR.Key2NoiseReductionType("NONE");
TimeSpan tsRecordingtDuration = recording.Duration;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
double frameOffset = sonoConfig.GetFrameOffset(sr);
double framesPerSecond = 1 / frameOffset;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
int rowCount = sonogram.Data.GetLength(0);
int colCount = sonogram.Data.GetLength(1);
//#############################################################################################################################################
//window sr frameDuration frames/sec hz/bin 64frameDuration hz/64bins hz/128bins
// 1024 22050 46.4ms 21.5 21.5 2944ms 1376hz 2752hz
// 256 17640 14.5ms 68.9 68.9 ms hz hz
// 512 17640 29.0ms 34.4 34.4 ms hz hz
// 1024 17640 58.0ms 17.2 17.2 3715ms 1100hz 2200hz
// 2048 17640 116.1ms 8.6 8.6 7430ms 551hz 1100hz
//The Xcorrelation-FFT technique requires number of bins to scan to be power of 2.
// Assuming sr=17640 and window=256, then binWidth = 68.9Hz and 1500Hz = bin 21.7..
// Therefore do a Xcorrelation between bins 21 and 22.
// Number of frames to span must power of 2. Try 16 frames which covers 232ms - almost 1/4 second.
int midHz = 1500;
int lowerBin = (int)(midHz / freqBinWidth) + 1; //because bin[0] = DC
int upperBin = lowerBin + 4;
int lowerHz = (int)Math.Floor((lowerBin - 1) * freqBinWidth);
int upperHz = (int)Math.Ceiling((upperBin - 1) * freqBinWidth);
//ALTERNATIVE IS TO USE THE AMPLITUDE SPECTRUM
//var results2 = DSP_Frames.ExtractEnvelopeAndFFTs(recording.GetWavReader().Samples, sr, frameSize, windowOverlap);
//double[,] matrix = results2.Item3; //amplitude spectrogram. Note that column zero is the DC or average energy value and can be ignored.
//double[] avAbsolute = results2.Item1; //average absolute value over the minute recording
////double[] envelope = results2.Item2;
//double windowPower = results2.Item4;
double[] lowerArray = MatrixTools.GetColumn(sonogram.Data, lowerBin);
double[] upperArray = MatrixTools.GetColumn(sonogram.Data, upperBin);
lowerArray = DataTools.NormaliseInZeroOne(lowerArray, 0, 60); //## ABSOLUTE NORMALISATION 0-60 dB #######################################################################
upperArray = DataTools.NormaliseInZeroOne(upperArray, 0, 60); //## ABSOLUTE NORMALISATION 0-60 dB #######################################################################
int step = (int)(framesPerSecond / 40); //take one/tenth second steps
int stepCount = rowCount / step;
int sampleLength = 32; //16 frames = 232ms - almost 1/4 second.
double[] intensity = new double[rowCount];
double[] periodicity = new double[rowCount];
//######################################################################
//ii: DO THE ANALYSIS AND RECOVER SCORES
for (int i = 0; i < stepCount; i++)
{
int start = step * i;
double[] lowerSubarray = DataTools.Subarray(lowerArray, start, sampleLength);
double[] upperSubarray = DataTools.Subarray(upperArray, start, sampleLength);
if (lowerSubarray == null || upperSubarray == null)
{
break;
}
if (lowerSubarray.Length != sampleLength || upperSubarray.Length != sampleLength)
{
break;
}
var spectrum = AutoAndCrossCorrelation.CrossCorr(lowerSubarray, upperSubarray);
int zeroCount = 2;
for (int s = 0; s < zeroCount; s++)
{
spectrum[s] = 0.0; //in real data these bins are dominant and hide other frequency content
}
int maxId = DataTools.GetMaxIndex(spectrum);
double period = 2 * sampleLength / (double)maxId / framesPerSecond; //convert maxID to period in seconds
if (period < minPeriod || period > maxPeriod)
{
continue;
}
// lay down score for sample length
for (int j = 0; j < sampleLength; j++)
{
if (intensity[start + j] < spectrum[maxId])
{
intensity[start + j] = spectrum[maxId];
}
periodicity[start + j] = period;
}
}
//iii: CONVERT SCORES TO ACOUSTIC EVENTS
intensity = DataTools.filterMovingAverage(intensity, 3);
intensity = DataTools.NormaliseInZeroOne(intensity, 0, 0.5); //## ABSOLUTE NORMALISATION 0-0.5 #######################################################################
List <AcousticEvent> predictedEvents = AcousticEvent.ConvertScoreArray2Events(
intensity,
lowerHz,
upperHz,
sonogram.FramesPerSecond,
freqBinWidth,
intensityThreshold,
minDuration,
maxDuration,
segmentStartOffset);
CropEvents(predictedEvents, upperArray, segmentStartOffset);
var hits = new double[rowCount, colCount];
var plots = new List <Plot>();
//plots.Add(new Plot("lowerArray", DataTools.Normalise(lowerArray, 0, 100), 10.0));
//plots.Add(new Plot("lowerArray", DataTools.Normalise(lowerArray, 0, 100), 10.0));
//plots.Add(new Plot("lowerArray", DataTools.NormaliseMatrixValues(lowerArray), 0.25));
//plots.Add(new Plot("upperArray", DataTools.NormaliseMatrixValues(upperArray), 0.25));
//plots.Add(new Plot("intensity", DataTools.NormaliseMatrixValues(intensity), intensityThreshold));
plots.Add(new Plot("intensity", intensity, intensityThreshold));
return(Tuple.Create(sonogram, hits, plots, predictedEvents, tsRecordingtDuration));
} //Analysis()
} //DetectBarsInTheRowsOfaMatrix()
/// A METHOD TO DETECT HARMONICS IN THE ROWS of the passed portion of a sonogram.
/// This method assume the matrix is derived from a spectrogram rotated so that the matrix rows are spectral columns of sonogram.
/// Was first developed for crow calls.
/// First looks for a decibel profile that matches the passed call duration and decibel loudness
/// Then samples the centre portion for the correct harmonic period.
/// </summary>
/// <param name="m"></param>
/// <param name="amplitudeThreshold"></param>
/// <returns></returns>
public static Tuple <double[], double[], double[]> DetectHarmonicsInSonogramMatrix(double[,] m, double dBThreshold, int callSpan)
{
int zeroBinCount = 3; //to remove low freq content which dominates the spectrum
int halfspan = callSpan / 2;
double[] dBArray = MatrixTools.GetRowAverages(m);
dBArray = DataTools.filterMovingAverage(dBArray, 3);
bool doNoiseRemoval = true;
if (doNoiseRemoval)
{
double StandardDeviationCount = 0.1; // number of noise SDs to calculate noise threshold - determines severity of noise reduction
SNR.BackgroundNoise bgn = SNR.SubtractBackgroundNoiseFromSignal(dBArray, StandardDeviationCount);
dBArray = bgn.NoiseReducedSignal;
}
bool[] peaks = DataTools.GetPeaks(dBArray);
int rowCount = m.GetLength(0);
int colCount = m.GetLength(1);
var intensity = new double[rowCount]; //an array of period intensity
var periodicity = new double[rowCount]; //an array of the periodicity values
for (int r = halfspan; r < rowCount - halfspan; r++)
{
//APPLY A FILTER: must satisfy the following conditions for a call.
if (!peaks[r])
{
continue;
}
if (dBArray[r] < dBThreshold)
{
continue;
}
double lowerDiff = dBArray[r] - dBArray[r - halfspan];
double upperDiff = dBArray[r] - dBArray[r + halfspan];
if (lowerDiff < dBThreshold || upperDiff < dBThreshold)
{
continue;
}
double[] prevRow = DataTools.DiffFromMean(MatrixTools.GetRow(m, r - 1));
double[] thisRow = DataTools.DiffFromMean(MatrixTools.GetRow(m, r));
var spectrum = AutoAndCrossCorrelation.CrossCorr(prevRow, thisRow);
for (int s = 0; s < zeroBinCount; s++)
{
spectrum[s] = 0.0; //in real data these bins are dominant and hide other frequency content
}
spectrum = DataTools.NormaliseArea(spectrum);
int maxId = DataTools.GetMaxIndex(spectrum);
double intensityValue = spectrum[maxId];
intensity[r] = intensityValue;
double period = 0.0;
if (maxId != 0)
{
period = 2 * colCount / (double)maxId;
}
periodicity[r] = period;
prevRow = thisRow;
} // rows
return(Tuple.Create(dBArray, intensity, periodicity));
} //DetectHarmonicsInSonogramMatrix()
/// <summary>
/// THE KEY ANALYSIS METHOD.
/// </summary>
private static Tuple <BaseSonogram, double[, ], double[], List <AcousticEvent>, Image> Analysis(
AudioRecording recording,
SonogramConfig sonoConfig,
LewinsRailConfig lrConfig,
bool returnDebugImage,
TimeSpan segmentStartOffset)
{
if (recording == null)
{
LoggedConsole.WriteLine("AudioRecording == null. Analysis not possible.");
return(null);
}
int sr = recording.SampleRate;
int upperBandMinHz = lrConfig.UpperBandMinHz;
int upperBandMaxHz = lrConfig.UpperBandMaxHz;
int lowerBandMinHz = lrConfig.LowerBandMinHz;
int lowerBandMaxHz = lrConfig.LowerBandMaxHz;
//double decibelThreshold = lrConfig.DecibelThreshold; //dB
//int windowSize = lrConfig.WindowSize;
double eventThreshold = lrConfig.EventThreshold; //in 0-1
double minDuration = lrConfig.MinDuration; // seconds
double maxDuration = lrConfig.MaxDuration; // seconds
double minPeriod = lrConfig.MinPeriod; // seconds
double maxPeriod = lrConfig.MaxPeriod; // seconds
//double freqBinWidth = sr / (double)windowSize;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
//i: MAKE SONOGRAM
double framesPerSecond = freqBinWidth;
//the Xcorrelation-FFT technique requires number of bins to scan to be power of 2.
//assuming sr=17640 and window=1024, then 64 bins span 1100 Hz above the min Hz level. i.e. 500 to 1600
//assuming sr=17640 and window=1024, then 128 bins span 2200 Hz above the min Hz level. i.e. 500 to 2700
int upperBandMinBin = (int)Math.Round(upperBandMinHz / freqBinWidth) + 1;
int upperBandMaxBin = (int)Math.Round(upperBandMaxHz / freqBinWidth) + 1;
int lowerBandMinBin = (int)Math.Round(lowerBandMinHz / freqBinWidth) + 1;
int lowerBandMaxBin = (int)Math.Round(lowerBandMaxHz / freqBinWidth) + 1;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
int rowCount = sonogram.Data.GetLength(0);
int colCount = sonogram.Data.GetLength(1);
//ALTERNATIVE IS TO USE THE AMPLITUDE SPECTRUM
//var results2 = DSP_Frames.ExtractEnvelopeAndFFTs(recording.GetWavReader().Samples, sr, frameSize, windowOverlap);
//double[,] matrix = results2.Item3; //amplitude spectrogram. Note that column zero is the DC or average energy value and can be ignored.
//double[] avAbsolute = results2.Item1; //average absolute value over the minute recording
////double[] envelope = results2.Item2;
//double windowPower = results2.Item4;
double[] lowerArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, lowerBandMinBin, rowCount - 1, lowerBandMaxBin);
double[] upperArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, upperBandMinBin, rowCount - 1, upperBandMaxBin);
int step = (int)Math.Round(framesPerSecond); //take one second steps
int stepCount = rowCount / step;
int sampleLength = 64; //64 frames = 3.7 seconds. Suitable for Lewins Rail.
double[] intensity = new double[rowCount];
double[] periodicity = new double[rowCount];
//######################################################################
//ii: DO THE ANALYSIS AND RECOVER SCORES
for (int i = 0; i < stepCount; i++)
{
int start = step * i;
double[] lowerSubarray = DataTools.Subarray(lowerArray, start, sampleLength);
double[] upperSubarray = DataTools.Subarray(upperArray, start, sampleLength);
if (lowerSubarray.Length != sampleLength || upperSubarray.Length != sampleLength)
{
break;
}
var spectrum = AutoAndCrossCorrelation.CrossCorr(lowerSubarray, upperSubarray);
int zeroCount = 3;
for (int s = 0; s < zeroCount; s++)
{
spectrum[s] = 0.0; //in real data these bins are dominant and hide other frequency content
}
spectrum = DataTools.NormaliseArea(spectrum);
int maxId = DataTools.GetMaxIndex(spectrum);
double period = 2 * sampleLength / (double)maxId / framesPerSecond; //convert maxID to period in seconds
if (period < minPeriod || period > maxPeriod)
{
continue;
}
// lay down score for sample length
for (int j = 0; j < sampleLength; j++)
{
if (intensity[start + j] < spectrum[maxId])
{
intensity[start + j] = spectrum[maxId];
}
periodicity[start + j] = period;
}
}
//######################################################################
//iii: CONVERT SCORES TO ACOUSTIC EVENTS
intensity = DataTools.filterMovingAverage(intensity, 5);
var predictedEvents = AcousticEvent.ConvertScoreArray2Events(
intensity,
lowerBandMinHz,
upperBandMaxHz,
sonogram.FramesPerSecond,
freqBinWidth,
eventThreshold,
minDuration,
maxDuration,
segmentStartOffset);
CropEvents(predictedEvents, upperArray, segmentStartOffset);
var hits = new double[rowCount, colCount];
//######################################################################
var scorePlot = new Plot("L.pect", intensity, lrConfig.IntensityThreshold);
Image debugImage = null;
if (returnDebugImage)
{
// display a variety of debug score arrays
DataTools.Normalise(intensity, lrConfig.DecibelThreshold, out var normalisedScores, out var normalisedThreshold);
var intensityPlot = new Plot("Intensity", normalisedScores, normalisedThreshold);
DataTools.Normalise(periodicity, 10, out normalisedScores, out normalisedThreshold);
var periodicityPlot = new Plot("Periodicity", normalisedScores, normalisedThreshold);
var debugPlots = new List <Plot> {
scorePlot, intensityPlot, periodicityPlot
};
debugImage = DrawDebugImage(sonogram, predictedEvents, debugPlots, hits);
}
return(Tuple.Create(sonogram, hits, intensity, predictedEvents, debugImage));
} //Analysis()
public static void DetectTrackPeriodicity(SpectralTrack track, int xCorrelationLength, List <double[]> listOfSpectralBins, double framesPerSecond)
{
int halfSample = xCorrelationLength / 2;
int lowerBin = (int)Math.Round(track.AverageBin);
int upperBin = lowerBin + 1;
upperBin = upperBin >= listOfSpectralBins.Count ? listOfSpectralBins.Count - 1 : upperBin;
int length = track.Length;
//only sample the middle third of track
int start = length / 3;
int end = start + start - 1;
//init score track and periodicity track
double[] score = new double[start];
double[] period = new double[start];
for (int r = start; r < end; r++) // for each position in centre third of track
{
int sampleStart = track.StartFrame - halfSample + r;
if (sampleStart < 0)
{
sampleStart = 0;
}
double[] lowerSubarray = DataTools.Subarray(listOfSpectralBins[lowerBin], sampleStart, xCorrelationLength);
double[] upperSubarray = DataTools.Subarray(listOfSpectralBins[upperBin], sampleStart, xCorrelationLength);
if (lowerSubarray == null || upperSubarray == null)
{
break; //reached end of array
}
if (lowerSubarray.Length != xCorrelationLength || upperSubarray.Length != xCorrelationLength)
{
break; //reached end of array
}
lowerSubarray = DataTools.SubtractMean(lowerSubarray); // zero mean the arrays
upperSubarray = DataTools.SubtractMean(upperSubarray);
//upperSubarray = lowerSubarray;
var xCorSpectrum = AutoAndCrossCorrelation.CrossCorr(lowerSubarray, upperSubarray); //sub-arrays already normalised
//DataTools.writeBarGraph(xCorSpectrum);
//Set the minimum OscilFreq of interest = 8 per second. Therefore max period ~ 125ms;
//int 0.125sec = 2 * xCorrelationLength / minInterestingID / framesPerSecond; //
double maxPeriod = 0.05; //maximum period of interest
int minInterestingID = (int)Math.Round(2 * xCorrelationLength / maxPeriod / framesPerSecond);
for (int s = 0; s <= minInterestingID; s++)
{
xCorSpectrum[s] = 0.0; //in real data these low freq/long period bins are dominant and hide other frequency content
}
int maxIdXcor = DataTools.GetMaxIndex(xCorSpectrum);
period[r - start] = 2 * xCorrelationLength / (double)maxIdXcor / framesPerSecond; //convert maxID to period in seconds
score[r - start] = xCorSpectrum[maxIdXcor];
} // for loop
track.periodicityScore = score;
track.periodicity = period;
//if (track.score.Average() < 0.3) track = null;
}
} //Analyze()
/// <summary>
/// ################ THE KEY ANALYSIS METHOD
/// Returns a DataTable
/// </summary>
/// <param name="fiSegmentOfSourceFile"></param>
/// <param name="configDict"></param>
/// <param name="segmentStartOffset"></param>
/// <param name="diOutputDir"></param>
public static Tuple <BaseSonogram, double[, ], double[], List <AcousticEvent>, TimeSpan> Analysis(FileInfo fiSegmentOfSourceFile, Dictionary <string, string> configDict, TimeSpan segmentStartOffset)
{
//set default values - ignor those set by user
int frameSize = 1024;
double windowOverlap = 0.0;
int upperBandMinHz = int.Parse(configDict[KeyUpperfreqbandBtm]);
int upperBandMaxHz = int.Parse(configDict[KeyUpperfreqbandTop]);
int lowerBandMinHz = int.Parse(configDict[KeyLowerfreqbandBtm]);
int lowerBandMaxHz = int.Parse(configDict[KeyLowerfreqbandTop]);
double decibelThreshold = double.Parse(configDict[KeyDecibelThreshold]);; //dB
double intensityThreshold = double.Parse(configDict[KeyIntensityThreshold]); //in 0-1
double minDuration = double.Parse(configDict[KeyMinDuration]); // seconds
double maxDuration = double.Parse(configDict[KeyMaxDuration]); // seconds
double minPeriod = double.Parse(configDict[KeyMinPeriod]); // seconds
double maxPeriod = double.Parse(configDict[KeyMaxPeriod]); // seconds
AudioRecording recording = new AudioRecording(fiSegmentOfSourceFile.FullName);
if (recording == null)
{
LoggedConsole.WriteLine("AudioRecording == null. Analysis not possible.");
return(null);
}
//i: MAKE SONOGRAM
SonogramConfig sonoConfig = new SonogramConfig(); //default values config
sonoConfig.SourceFName = recording.BaseName;
sonoConfig.WindowSize = frameSize;
sonoConfig.WindowOverlap = windowOverlap;
//sonoConfig.NoiseReductionType = SNR.Key2NoiseReductionType("NONE");
sonoConfig.NoiseReductionType = SNR.KeyToNoiseReductionType("STANDARD");
TimeSpan tsRecordingtDuration = recording.Duration;
int sr = recording.SampleRate;
double freqBinWidth = sr / (double)sonoConfig.WindowSize;
double framesPerSecond = freqBinWidth;
//#############################################################################################################################################
//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
//the Xcorrelation-FFT technique requires number of bins to scan to be power of 2.
//assuming sr=17640 and window=1024, then 64 bins span 1100 Hz above the min Hz level. i.e. 500 to 1600
//assuming sr=17640 and window=1024, then 128 bins span 2200 Hz above the min Hz level. i.e. 500 to 2700
int upperBandMinBin = (int)Math.Round(upperBandMinHz / freqBinWidth) + 1;
int upperBandMaxBin = (int)Math.Round(upperBandMaxHz / freqBinWidth) + 1;
int lowerBandMinBin = (int)Math.Round(lowerBandMinHz / freqBinWidth) + 1;
int lowerBandMaxBin = (int)Math.Round(lowerBandMaxHz / freqBinWidth) + 1;
BaseSonogram sonogram = new SpectrogramStandard(sonoConfig, recording.WavReader);
int rowCount = sonogram.Data.GetLength(0);
int colCount = sonogram.Data.GetLength(1);
//ALTERNATIVE IS TO USE THE AMPLITUDE SPECTRUM
//var results2 = DSP_Frames.ExtractEnvelopeAndFFTs(recording.GetWavReader().Samples, sr, frameSize, windowOverlap);
//double[,] matrix = results2.Item3; //amplitude spectrogram. Note that column zero is the DC or average energy value and can be ignored.
//double[] avAbsolute = results2.Item1; //average absolute value over the minute recording
////double[] envelope = results2.Item2;
//double windowPower = results2.Item4;
double[] lowerArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, lowerBandMinBin, (rowCount - 1), lowerBandMaxBin);
double[] upperArray = MatrixTools.GetRowAveragesOfSubmatrix(sonogram.Data, 0, upperBandMinBin, (rowCount - 1), upperBandMaxBin);
int step = (int)Math.Round(framesPerSecond); //take one second steps
int stepCount = rowCount / step;
int sampleLength = 64; //64 frames = 3.7 seconds. Suitable for Lewins Rail.
double[] intensity = new double[rowCount];
double[] periodicity = new double[rowCount];
//######################################################################
//ii: DO THE ANALYSIS AND RECOVER SCORES
for (int i = 0; i < stepCount; i++)
{
int start = step * i;
double[] lowerSubarray = DataTools.Subarray(lowerArray, start, sampleLength);
double[] upperSubarray = DataTools.Subarray(upperArray, start, sampleLength);
if ((lowerSubarray.Length != sampleLength) || (upperSubarray.Length != sampleLength))
{
break;
}
var spectrum = AutoAndCrossCorrelation.CrossCorr(lowerSubarray, upperSubarray);
int zeroCount = 3;
for (int s = 0; s < zeroCount; s++)
{
spectrum[s] = 0.0; //in real data these bins are dominant and hide other frequency content
}
spectrum = DataTools.NormaliseArea(spectrum);
int maxId = DataTools.GetMaxIndex(spectrum);
double period = 2 * sampleLength / (double)maxId / framesPerSecond; //convert maxID to period in seconds
if ((period < minPeriod) || (period > maxPeriod))
{
continue;
}
for (int j = 0; j < sampleLength; j++) //lay down score for sample length
{
if (intensity[start + j] < spectrum[maxId])
{
intensity[start + j] = spectrum[maxId];
}
periodicity[start + j] = period;
}
}
//######################################################################
//iii: CONVERT SCORES TO ACOUSTIC EVENTS
intensity = DataTools.filterMovingAverage(intensity, 5);
List <AcousticEvent> predictedEvents = AcousticEvent.ConvertScoreArray2Events(
intensity,
lowerBandMinHz,
upperBandMaxHz,
sonogram.FramesPerSecond,
freqBinWidth,
intensityThreshold,
minDuration,
maxDuration,
segmentStartOffset);
CropEvents(predictedEvents, upperArray);
var hits = new double[rowCount, colCount];
return(Tuple.Create(sonogram, hits, intensity, predictedEvents, tsRecordingtDuration));
} //Analysis()
