public void TestReadSpectralIndices()
{
var testSpectra = PathHelper.ResolveAssetPath("20160725_203006_continuous1__Towsey.Acoustic.ACI.csv");
var dir = PathHelper.TestResources.ToDirectoryEntry();
var matrix = IndexMatrices.ReadSpectralIndices(
dir,
"20160725_203006_continuous1",
"Towsey.Acoustic",
new[] { "ACI" })
.Single()
.Value;
Assert.AreEqual(256, matrix.GetLength(0));
Assert.AreEqual(30, matrix.GetLength(1));
Assert.AreEqual(0.462924678189025, matrix[255, 0]);
Assert.AreEqual(0.42779069684277, matrix[254, 0]);
Assert.AreEqual(0.46412042529103, matrix[255, 1]);
Assert.AreEqual(0.444650614488611, matrix[254, 1]);
var matrix2 = IndexMatrices.ReadSpectrogram(testSpectra.ToFileInfo(), out var binCount);
matrix2 = MatrixTools.MatrixRotate90Anticlockwise(matrix2);
var actualEnumerator = matrix2.GetEnumerator();
foreach (var expected in matrix)
{
actualEnumerator.MoveNext();
Assert.AreEqual(expected, (double)actualEnumerator.Current, 1E-14, $"delta: {expected - (double)actualEnumerator.Current}");
}
}
private static (Dictionary <string, double[, ]>, Dictionary <string, IndexProperties>) LoadSpectra(
AnalysisIoInputDirectory io,
string analysisTag,
string fileStem,
Dictionary <string, IndexProperties> indexProperties)
{
indexProperties = InitialiseIndexProperties.FilterIndexPropertiesForSpectralOnly(indexProperties);
string[] keys = indexProperties.Keys.ToArray();
Dictionary <string, double[, ]> spectra = IndexMatrices.ReadSpectralIndices(
io.InputBase,
fileStem,
analysisTag,
keys);
return(spectra, indexProperties);
}
public static (Dictionary <string, double[, ]>, Dictionary <string, IndexProperties>) LoadSpectra(
AnalysisIoInputDirectory io,
string analysisTag,
string fileStem,
LdSpectrogramConfig config,
Dictionary <string, IndexProperties> indexProperties)
{
var keys = config.GetKeys().Distinct();
// add two necessary keys for zooming
keys = keys.ToList().Append("SUM");
keys = keys.ToList().Append("DIF");
//add following matrix for possible subsequent BNG combination matrix.
string comboIndexID = "RHZ";
keys = keys.ToList().Append(comboIndexID);
var relevantIndexProperties = keys.ToDictionary(x => x, x => indexProperties[x]);
Dictionary <string, double[, ]> spectra = IndexMatrices.ReadSpectralIndices(
io.InputBase,
fileStem,
analysisTag,
keys.ToArray());
/*
* // THE FOLLOWING IDEA TO MAKE A COMBINED MATRIX OF BGN and RHZ was rejected.
* // Anthony was concerned that the BGN matrix alone was not conveying much information at high resolutions.
* // The idea was to combine another matrix with the BGN matrix.
* // I tried three combinations, BGN-RHZ, BGN-OSC and BGN-SPT. None of them appeard to provide additional useful information at high resolution.
* // The problem is that at high resolution, i.e. approaching 0.1s for an analysis unit, there are not many orthogonal features in a single frequency bin.
* // Make a BNG COMBINATION Spectral matrix.
* //var comboMatrix = MatrixTools.MaxOfTwoMatrices(spectra["BNG"], spectra["RHZ"]);
* var comboMatrix = MatrixTools.AddMatricesWeightedSum(spectra["BGN"], 1.0, spectra[comboIndexID], 10.0);
* spectra["BGN"] = comboMatrix;
*/
return(spectra, relevantIndexProperties);
}
} // method DrawRidgeSpectrograms()
public static Image DrawRidgeSpectrograms(DirectoryInfo inputDirectory, FileInfo ipConfig, string fileStem, double scale, Dictionary <string, double[, ]> spectra = null)
{
string analysisType = AcousticIndices.TowseyAcoustic;
//double backgroundFilter = 0.0; // 0.0 means small values are removed.
double backgroundFilter = 0.75; // 0.75 means small values are accentuated.
var dataScale = TimeSpan.FromSeconds(scale);
Dictionary <string, IndexProperties> indexProperties = IndexProperties.GetIndexProperties(ipConfig);
string[] keys = SpectralPeakTracks.GetDefaultRidgeKeys();
// read the csv files of the indices in keys array
if (spectra == null)
{
//C:\SensorNetworks\Output\BIRD50\Training\ID0001\Towsey.Acoustic\ID0001__Towsey.Acoustic.ACI
spectra = IndexMatrices.ReadSpectralIndices(inputDirectory, fileStem, analysisType, keys);
}
var cs1 = new LDSpectrogramRGB(minuteOffset: TimeSpan.Zero, xScale: dataScale, sampleRate: 22050, frameWidth: 512, colorMap: null)
{
FileName = fileStem,
BackgroundFilter = backgroundFilter,
IndexCalculationDuration = dataScale,
};
// set the relevant dictionary of index properties
cs1.SetSpectralIndexProperties(indexProperties);
cs1.SpectrogramMatrices = spectra;
if (cs1.GetCountOfSpectrogramMatrices() == 0)
{
LoggedConsole.WriteLine("WARNING: " + fileStem + ": No spectrogram matrices in the dictionary. Spectrogram files do not exist?");
return(null);
}
else if (cs1.GetCountOfSpectrogramMatrices() < keys.Length)
{
LoggedConsole.WriteLine("WARNING: " + fileStem + ": Missing indices in the dictionary. Some files do not exist?");
return(null);
}
var stringFont = Drawing.Tahoma8;
// constants for labels
Color[] color = { Color.Blue, Color.Green, Color.Red, Color.Orange, Color.Purple };
int labelYvalue = 3;
int labelIndex = 0;
Image <Rgb24> ridges = null;
foreach (string key in keys)
{
Image <Rgb24> greyScaleImage = (Image <Rgb24>)cs1.DrawGreyscaleSpectrogramOfIndex(key);
var pixelWidth = greyScaleImage.Width;
int height = greyScaleImage.Height;
ridges.Mutate(g2 =>
{
if (ridges == null)
{
ridges = new Image <Rgb24>(pixelWidth, height);
g2.Clear(Color.White);
}
g2.DrawText(key, stringFont, color[labelIndex], new PointF(0, labelYvalue));
});
labelYvalue += 10;
//g1.DrawLine(new Pen(Color.Black, 1), 0, 0, width, 0);//draw upper boundary
//g1.DrawLine(new Pen(Color.Black, 1), 0, 1, width, 1);//draw upper boundary
// transfer greyscale image to colour image
for (int y = 0; y < height; y++)
{
for (int x = 0; x < pixelWidth; x++)
{
var col = greyScaleImage[x, y];
if (col.G < 150)
{
ridges[x, y] = color[labelIndex];
}
}
}
labelIndex += 1;
} //foreach key
return(ridges);
} // method DrawRidgeSpectrograms()
} // method DrawAggregatedSpectrograms()
public static Image <Rgb24> DrawGrayScaleSpectrograms(Arguments arguments, string fileStem, TimeSpan dataScale, Dictionary <string, double[, ]> spectra = null)
{
// default values
int sampleRate = 22050;
int frameWidth = 512;
//double backgroundFilter = 0.0; // 0.0 means small values are removed.
double backgroundFilter = 0.75; // 0.75 means small values are accentuated.
string analysisType = AcousticIndices.TowseyAcoustic;
string[] keys = LDSpectrogramRGB.GetArrayOfAvailableKeys();
var inputDirectory = arguments.InputDataDirectory;
Dictionary <string, IndexProperties> indexProperties = IndexProperties.GetIndexProperties(arguments.IndexPropertiesConfig.ToFileInfo());
if (spectra == null)
{
spectra = IndexMatrices.ReadSpectralIndices(inputDirectory.ToDirectoryInfo(), fileStem, analysisType, keys);
}
// note: the spectra are oriented as per visual orientation, i.e. xAxis = time frames
//int frameCount = spectra[keys[0]].GetLength(1);
var cs1 = new LDSpectrogramRGB(minuteOffset: TimeSpan.Zero, xScale: dataScale, sampleRate: sampleRate, frameWidth: frameWidth, colorMap: null)
{
FileName = fileStem,
BackgroundFilter = backgroundFilter,
IndexCalculationDuration = dataScale,
};
cs1.SetSpectralIndexProperties(indexProperties); // set the relevant dictionary of index properties
cs1.SpectrogramMatrices = spectra;
if (cs1.GetCountOfSpectrogramMatrices() == 0)
{
LoggedConsole.WriteLine("WARNING: " + fileStem + ": No spectrogram matrices in the dictionary. Spectrogram files do not exist?");
return(null);
}
var list = new List <Image <Rgb24> >();
var stringFont = Drawing.Arial14;
foreach (string key in keys)
{
var image = cs1.DrawGreyscaleSpectrogramOfIndex(key);
int width = 70;
int height = image.Height;
var label = new Image <Rgb24>(width, height);
label.Mutate(g1 =>
{
g1.Clear(Color.Gray);
g1.DrawText(key, stringFont, Color.Black, new PointF(4, 30));
g1.DrawLine(new Pen(Color.Black, 1), 0, 0, width, 0); //draw upper boundary
g1.DrawLine(new Pen(Color.Black, 1), 0, 1, width, 1); //draw upper boundary
});
var imagearray = new[] { label, image };
var labelledImage = ImageTools.CombineImagesInLine(imagearray);
list.Add(labelledImage);
} //foreach key
var combinedImage = ImageTools.CombineImagesVertically(list);
return(combinedImage);
} // method DrawGrayScaleSpectrograms()
} // method DrawAggregatedSpectrograms()
public static Image DrawGrayScaleSpectrograms(Arguments arguments, string fileStem, TimeSpan dataScale, Dictionary <string, double[, ]> spectra = null)
{
int sampleRate = 22050;
int frameWidth = 512;
//double backgroundFilter = 0.0; // 0.0 means small values are removed.
double backgroundFilter = 0.75; // 0.75 means small values are accentuated.
string analysisType = AcousticIndices.TowseyAcoustic;
string[] keys = LDSpectrogramRGB.GetArrayOfAvailableKeys();
//LoggedConsole.WriteLine("# Spectrogram Config file: " + arguments.SpectrogramConfigPath);
//LoggedConsole.WriteLine("# Index Properties Config file: " + arguments.IndexPropertiesConfig);
var inputDirectory = arguments.InputDataDirectory;
Dictionary <string, IndexProperties> indexProperties = IndexProperties.GetIndexProperties(arguments.IndexPropertiesConfig.ToFileInfo());
if (spectra == null)
{
//C:\SensorNetworks\Output\BIRD50\Training\ID0001\Towsey.Acoustic\ID0001__Towsey.Acoustic.ACI
spectra = IndexMatrices.ReadSpectralIndices(inputDirectory.ToDirectoryInfo(), fileStem, analysisType, keys);
}
// note: the spectra are oriented as per visual orientation, i.e. xAxis = time frames
//int frameCount = spectra[keys[0]].GetLength(1);
var cs1 = new LDSpectrogramRGB(minuteOffset: TimeSpan.Zero, xScale: dataScale, sampleRate: sampleRate, frameWidth: frameWidth, colourMap: null)
{
FileName = fileStem,
BackgroundFilter = backgroundFilter,
IndexCalculationDuration = dataScale,
};
cs1.SetSpectralIndexProperties(indexProperties); // set the relevant dictionary of index properties
cs1.SpectrogramMatrices = spectra;
if (cs1.GetCountOfSpectrogramMatrices() == 0)
{
LoggedConsole.WriteLine("WARNING: " + fileStem + ": No spectrogram matrices in the dictionary. Spectrogram files do not exist?");
return(null);
}
List <Image> list = new List <Image>();
Font stringFont = new Font("Arial", 14);
foreach (string key in keys)
{
var image = cs1.DrawGreyscaleSpectrogramOfIndex(key);
int width = 70;
int height = image.Height;
var label = new Bitmap(width, height);
var g1 = Graphics.FromImage(label);
g1.Clear(Color.Gray);
g1.DrawString(key, stringFont, Brushes.Black, new PointF(4, 30));
g1.DrawLine(new Pen(Color.Black), 0, 0, width, 0); //draw upper boundary
g1.DrawLine(new Pen(Color.Black), 0, 1, width, 1); //draw upper boundary
Image[] imagearray = { label, image };
var labelledImage = ImageTools.CombineImagesInLine(imagearray);
list.Add(labelledImage);
} //foreach key
var combinedImage = ImageTools.CombineImagesVertically(list.ToArray());
return(combinedImage);
} // method DrawGrayScaleSpectrograms()
public void TestAnalyzeSr64000Recording()
{
int sampleRate = 64000;
double duration = 420; // signal duration in seconds = 7 minutes
int[] harmonics = { 500, 1000, 2000, 4000, 8000 };
var recording = DspFilters.GenerateTestRecording(sampleRate, duration, harmonics, WaveType.Cosine);
string recordingName = "TemporaryRecording2";
var recordingPath = this.outputDirectory.CombineFile(recordingName + ".wav");
WavWriter.WriteWavFileViaFfmpeg(recordingPath, recording.WavReader);
var fst = FreqScaleType.Linear125Octaves7Tones28Nyquist32000;
var freqScale = new FrequencyScale(fst);
/*
* // draw the signal as spectrogram just for debugging purposes
* // but can only draw a two minute spectrogram when sr=64000 - change duration above.
* duration = 120; // if drawing sonogram, then set signal duration = 2 minutes
* var sonogram = OctaveFreqScale.ConvertRecordingToOctaveScaleSonogram(recording, fst);
* var sonogramImage = sonogram.GetImageFullyAnnotated(sonogram.GetImage(), "SPECTROGRAM", freqScale.GridLineLocations);
* var outputImagePath = this.outputDirectory.CombineFile("SignalSpectrogram_OctaveFreqScale.png");
* sonogramImage.Save(outputImagePath.FullName);
*/
// Now need to rewrite the config file with new parameter settings
var configPath = PathHelper.ResolveConfigFile("Towsey.Acoustic.yml");
// Convert the Config config to IndexCalculateConfig class and merge in the unnecesary parameters.
//Config configuration = Yaml.Deserialise(configPath);
//IndexCalculateConfig config = IndexCalculateConfig.GetConfig(configuration, false);
// because of difficulties in dealing with Config config files, just edit the text file!!!!!
var configLines = File.ReadAllLines(configPath.FullName);
configLines[configLines.IndexOf(x => x.StartsWith("IndexCalculationDuration: "))] = "IndexCalculationDuration: 15.0";
//configLines[configLines.IndexOf(x => x.StartsWith("BgNoiseBuffer: "))] = "BgNoiseBuffer: 5.0";
configLines[configLines.IndexOf(x => x.StartsWith("FrequencyScale: Linear"))] = "FrequencyScale: " + fst;
// the is the only octave scale currently functioning for IndexCalculate class
configLines[configLines.IndexOf(x => x.StartsWith("FrameLength"))] = $"FrameLength: {freqScale.WindowSize}";
configLines[configLines.IndexOf(x => x.StartsWith("ResampleRate: "))] = "ResampleRate: 64000";
// write the edited Config file to temporary output directory
var newConfigPath = this.outputDirectory.CombineFile("Towsey.Acoustic.yml");
File.WriteAllLines(newConfigPath.FullName, configLines);
PathHelper.ResolveConfigFile("IndexPropertiesConfig.yml").CopyTo(this.outputDirectory.CombineFile("IndexPropertiesConfig.yml").FullName);
var arguments = new AnalyseLongRecording.Arguments
{
Source = recordingPath,
Config = newConfigPath.FullName,
Output = this.outputDirectory,
MixDownToMono = true,
Parallel = !Debugger.IsAttached,
};
AnalyseLongRecording.Execute(arguments);
var resultsDirectory = this.outputDirectory.Combine("Towsey.Acoustic");
var listOfFiles = resultsDirectory.EnumerateFiles().ToArray();
Assert.AreEqual(19, listOfFiles.Length);
var csvCount = listOfFiles.Count(f => f.Name.EndsWith(".csv"));
Assert.AreEqual(15, csvCount);
var jsonCount = listOfFiles.Count(f => f.Name.EndsWith(".json"));
Assert.AreEqual(2, jsonCount);
var pngCount = listOfFiles.Count(f => f.Name.EndsWith(".png"));
Assert.AreEqual(2, pngCount);
var bgnFile = resultsDirectory.CombineFile(recordingName + "__Towsey.Acoustic.BGN.csv");
double[,] actualBgn = Csv.ReadMatrixFromCsv <double>(bgnFile, TwoDimensionalArray.None);
var expectedSpectrumFile = PathHelper.ResolveAsset("LongDuration", "BgnMatrix.OctaveScale.csv");
// uncomment the following line when first produce the array
// bgnFile.CopyTo(expectedSpectrumFile.FullName);
// compare actual BGN file with expected file.
var expectedBgn = Csv.ReadMatrixFromCsv <double>(expectedSpectrumFile, TwoDimensionalArray.None);
CollectionAssert.That.AreEqual(expectedBgn, actualBgn, 0.000_000_001);
var array = MatrixTools.GetRow(actualBgn, 0);
Assert.AreEqual(28, actualBgn.RowLength());
Assert.AreEqual(256, array.Length);
// draw array just to check peaks are in correct places - just for debugging purposes
var ldsBgnSpectrumFile = this.outputDirectory.CombineFile("Spectrum2.png");
GraphsAndCharts.DrawGraph(array, "LD BGN SPECTRUM Octave", ldsBgnSpectrumFile);
// ##########################################
// SECOND part of test is to create the LD spectrograms because they are not created when IndexCalcDuration < 60 seconds
// first read in the index generation data
var icdPath = resultsDirectory.CombineFile(recordingName + "__IndexGenerationData.json");
var indexConfigData = Json.Deserialize <IndexGenerationData>(icdPath);
var indexPropertiesConfig = PathHelper.ResolveConfigFile("IndexPropertiesConfig.yml");
var ldSpectrogramConfigFile = PathHelper.ResolveConfigFile("SpectrogramFalseColourConfig.yml");
var ldSpectrogramConfig = LdSpectrogramConfig.ReadYamlToConfig(ldSpectrogramConfigFile);
ldSpectrogramConfig.FreqScale = fst.ToString();
// finally read in the dictionary of spectra
string analysisType = "Towsey.Acoustic";
var keys = LDSpectrogramRGB.GetArrayOfAvailableKeys();
var dictionaryOfSpectra = IndexMatrices.ReadSpectralIndices(resultsDirectory, recordingName, analysisType, keys);
LDSpectrogramRGB.DrawSpectrogramsFromSpectralIndices(
inputDirectory: resultsDirectory,
outputDirectory: resultsDirectory,
ldSpectrogramConfig: ldSpectrogramConfig,
indexPropertiesConfigPath: indexPropertiesConfig,
indexGenerationData: indexConfigData,
basename: recordingName,
analysisType: analysisType,
indexSpectrograms: dictionaryOfSpectra);
// test number of images - should now be 23
listOfFiles = resultsDirectory.EnumerateFiles().ToArray();
pngCount = listOfFiles.Count(f => f.Name.EndsWith(".png"));
Assert.AreEqual(22, pngCount);
var twoMapsImagePath = resultsDirectory.CombineFile(recordingName + "__2Maps.png");
var twoMapsImage = Image.Load <Rgb24>(twoMapsImagePath.FullName);
// image is (7*4) * 652
Assert.AreEqual(28, twoMapsImage.Width);
Assert.AreEqual(652, twoMapsImage.Height);
}
public static void DrawStackOfZoomedSpectrograms(DirectoryInfo inputDirectory, DirectoryInfo outputDirectory, ZoomParameters common, TimeSpan focalTime, int imageWidth, string analysisType)
{
var zoomConfig = common.SpectrogramZoomingConfig;
LdSpectrogramConfig ldsConfig = common.SpectrogramZoomingConfig.LdSpectrogramConfig;
var distributions = common.IndexDistributions;
var indexGeneration = common.IndexGenerationData;
string fileStem = common.OriginalBasename;
TimeSpan dataScale = indexGeneration.IndexCalculationDuration;
// ####################### DERIVE ZOOMED OUT SPECTROGRAMS FROM SPECTRAL INDICES
string[] keys = { "ACI", "BGN", "CVR", "DIF", "ENT", "EVN", "PMN", "POW", "RHZ", "RVT", "RPS", "RNG", "SUM", "SPT" };
var indexProperties = InitialiseIndexProperties.FilterIndexPropertiesForSpectralOnly(zoomConfig.IndexProperties);
Dictionary <string, double[, ]> spectra = IndexMatrices.ReadSpectralIndices(inputDirectory, fileStem, analysisType, keys);
Stopwatch sw = Stopwatch.StartNew();
// standard scales in seconds per pixel.
double[] imageScales = { 60, 24, 12, 6, 2, 1, 0.6, 0.2 };
if (zoomConfig.SpectralIndexScale != null)
{
imageScales = zoomConfig.SpectralIndexScale;
}
sw = Stopwatch.StartNew();
int scaleCount = imageScales.Length;
var imageList = new List <Image>();
for (int i = 0; i < scaleCount; i++)
{
var imageScale = TimeSpan.FromSeconds(imageScales[i]);
var image = DrawIndexSpectrogramAtScale(ldsConfig, indexGeneration, indexProperties, focalTime, dataScale, imageScale, imageWidth, spectra, fileStem);
if (image != null)
{
imageList.Add(image);
string name = $"{fileStem}_FocalZoom_min{focalTime.TotalMinutes:f1}_scale{imageScales[i]}.png";
image.Save(Path.Combine(outputDirectory.FullName, name));
}
}
sw.Stop();
LoggedConsole.WriteLine("Finished spectrograms derived from spectral indices. Elapsed time = " + sw.Elapsed.TotalSeconds + " seconds");
// ####################### DERIVE ZOOMED IN SPECTROGRAMS FROM STANDARD SPECTRAL FRAMES
int[] compressionFactor = { 8, 4, 2, 1 };
int compressionCount = compressionFactor.Length;
sw = Stopwatch.StartNew();
double frameStepInSeconds = indexGeneration.FrameStep / (double)indexGeneration.SampleRateResampled;
TimeSpan frameScale = TimeSpan.FromTicks((long)Math.Round(frameStepInSeconds * 10000000));
if (zoomConfig.SpectralFrameScale != null)
{
imageScales = zoomConfig.SpectralFrameScale;
// TODO: CONVERT IMAGE scales into Compression factors.
compressionCount = imageScales.Length;
compressionFactor = new int[compressionCount];
compressionFactor[compressionCount - 1] = 1;
double denom = imageScales[compressionCount - 1];
for (int i = 0; i < compressionCount - 1; i++)
{
compressionFactor[i] = (int)Math.Round(imageScales[i] / denom);
}
}
int maxCompression = compressionFactor[0];
TimeSpan maxImageDuration = TimeSpan.FromTicks(maxCompression * imageWidth * frameScale.Ticks);
TimeSpan halfMaxImageDuration = TimeSpan.FromMilliseconds(maxImageDuration.TotalMilliseconds / 2);
TimeSpan startTimeOfMaxImage = TimeSpan.Zero;
if (focalTime != TimeSpan.Zero)
{
startTimeOfMaxImage = focalTime - halfMaxImageDuration;
}
TimeSpan startTimeOfData = TimeSpan.FromMinutes(Math.Floor(startTimeOfMaxImage.TotalMinutes));
List <double[]> frameData = ReadFrameData(inputDirectory, fileStem, startTimeOfMaxImage, maxImageDuration, zoomConfig, indexGeneration.MaximumSegmentDuration.Value);
// get the index data to add into the
// TimeSpan imageScale1 = TimeSpan.FromSeconds(0.1);
double[,] indexData = spectra["POW"];
// make the images
for (int i = 0; i < compressionCount; i++)
{
int factor = compressionFactor[i];
var image = DrawFrameSpectrogramAtScale(ldsConfig, indexGeneration, startTimeOfData, factor, frameData, indexData, focalTime, frameScale, imageWidth);
if (image != null)
{
imageList.Add(image);
}
}
sw.Stop();
LoggedConsole.WriteLine("Finished spectrograms derived from standard frames. Elapsed time = " + sw.Elapsed.TotalSeconds + " seconds");
// combine the images into a stack
Image combinedImage = ImageTools.CombineImagesVertically(imageList);
string fileName = $"{fileStem}_FocalZOOM_min{focalTime.TotalMinutes:f1}.png";
combinedImage.Save(Path.Combine(outputDirectory.FullName, fileName));
}
