Mercurial > hg > batch-feature-extraction-tool

changeset 10:73852457b624

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
We now have a the spectral contrast feature
author Geogaddi\David <d.m.ronan@qmul.ac.uk>
date Fri, 14 Aug 2015 18:21:43 +0100
parents 262e084a15a9
children be889912d38e
files FeatureExtractionTool.jucer Source/AudioSourceFeatureExtractor.cpp Source/AudioSourceFeatureExtractor.h Source/FeatureData.cpp Source/ObservationData.h Source/SpectralContrast.cpp Source/SpectralContrast.h Source/WriteCSV.cpp
diffstat 8 files changed, 545 insertions(+), 76 deletions(-) [+]
line wrap: on
line diff
--- a/FeatureExtractionTool.jucer	Wed Aug 12 22:25:06 2015 +0100
+++ b/FeatureExtractionTool.jucer	Fri Aug 14 18:21:43 2015 +0100
@@ -2,7 +2,7 @@
 
 <JUCERPROJECT id="hvJbYi" name="FeatureExtractionTool" projectType="consoleapp"
               version="1.0.0" bundleIdentifier="com.yourcompany.FeatureExtractionTool"
-              includeBinaryInAppConfig="1" jucerVersion="3.1.0">
+              includeBinaryInAppConfig="1" jucerVersion="3.2.0">
   <MAINGROUP id="UKgH5X" name="FeatureExtractionTool">
     <GROUP id="{95DEE943-A3F3-BB07-A6D9-BD28F3B3CFDF}" name="Resource">
       <FILE id="rkvdMy" name="initMFCCVariables.m" compile="1" resource="1"
@@ -29,6 +29,10 @@
         <FILE id="V4aBIS" name="AudioReader.h" compile="0" resource="0" file="Source/AudioReader.h"/>
       </GROUP>
       <GROUP id="{73D0B8BA-664F-24A1-D1DE-9F157AB458E7}" name="Analysis">
+        <FILE id="FpmIPD" name="SpectralContrast.cpp" compile="1" resource="0"
+              file="Source/SpectralContrast.cpp"/>
+        <FILE id="f7YbDu" name="SpectralContrast.h" compile="0" resource="0"
+              file="Source/SpectralContrast.h"/>
         <FILE id="GuHO7T" name="MFCC.cpp" compile="1" resource="0" file="Source/MFCC.cpp"/>
         <FILE id="DStwU0" name="MFCC.h" compile="0" resource="0" file="Source/MFCC.h"/>
         <FILE id="buHhF1" name="AudioSourceFeatureExtractor.cpp" compile="1"
--- a/Source/AudioSourceFeatureExtractor.cpp	Wed Aug 12 22:25:06 2015 +0100
+++ b/Source/AudioSourceFeatureExtractor.cpp	Fri Aug 14 18:21:43 2015 +0100
@@ -49,6 +49,7 @@
 	}
 
 	m_MFCC.initMFFCvariables(12, MAGNITUDESIZE, m_fSampleRate);
+	m_SpectralContrast.initSpectralContrastVariables(FFTSIZE, m_fSampleRate);
 }
 
 //==============================================================================  process
@@ -137,11 +138,15 @@
 			float spectralcf = 0;
 			float spectralflux = 0;
 			std::vector<float> mfccs;
+			std::vector<float> spectralContrast;
+			std::vector<float> spectralValleys;
 
 			SpectralFeatures(m_fMagnitudeSpectrum, m_fPreviousMagnitudeSpectrum, MAGNITUDESIZE, centroid, spread, skewness, kurtosis, brightness, rolloff85, rolloff95, spectralentropy, flatness, spectralcf, spectralflux);
 
 			m_MFCC.ComputeMFCC(m_fMagnitudeSpectrum, mfccs);
 
+			m_SpectralContrast.computeSpectralContrast(m_fMagnitudeSpectrum, spectralContrast, spectralValleys);
+
 			//Update for Spectral Flux
 			for (int i = 0; i < MAGNITUDESIZE; i++)
 			{
@@ -156,7 +161,7 @@
 			}
 
 			//create an observation for this window and push it to the list of observations for this 30 sec. audio clip
-			ObservationData newObservation = ObservationData(rms, peakvalue, crestfactor, ZCR, centroid, spread, skewness, kurtosis, brightness, rolloff85, rolloff95, spectralentropy, flatness, spectralcf, spectralflux, mfccs, perdiodicity, entropyofenergy);
+			ObservationData newObservation = ObservationData(rms, peakvalue, crestfactor, ZCR, centroid, spread, skewness, kurtosis, brightness, rolloff85, rolloff95, spectralentropy, flatness, spectralcf, spectralflux, mfccs, spectralContrast, spectralValleys, perdiodicity, entropyofenergy);
 			observations.push_back(newObservation);
 		}
 	}
--- a/Source/AudioSourceFeatureExtractor.h	Wed Aug 12 22:25:06 2015 +0100
+++ b/Source/AudioSourceFeatureExtractor.h	Fri Aug 14 18:21:43 2015 +0100
@@ -15,6 +15,7 @@
 
 #include "FFT.h"
 #include "MFCC.h"
+#include "SpectralContrast.h"
 #include "ObservationData.h"
 
 #define MAGNITUDESIZE 512
@@ -71,6 +72,7 @@
 	std::vector<float> m_OutReal;
 	std::vector<float> m_OutImag;
 	MFCC   m_MFCC;
+	SpectralContrast m_SpectralContrast;
 	std::vector<float> m_fInputBuffer;
 	std::vector<float> m_fMagnitudeSpectrum;
 	std::vector<float> m_fPreviousMagnitudeSpectrum;
--- a/Source/FeatureData.cpp	Wed Aug 12 22:25:06 2015 +0100
+++ b/Source/FeatureData.cpp	Fri Aug 14 18:21:43 2015 +0100
@@ -50,18 +50,19 @@
 	std::vector<float>  mfcc11;
 	std::vector<float>  mfcc12;
 
-	std::vector<float>  dmfcc1;
-	std::vector<float>  dmfcc2;
-	std::vector<float>  dmfcc3;
-	std::vector<float>  dmfcc4;
-	std::vector<float>  dmfcc5;
-	std::vector<float>  dmfcc6;
-	std::vector<float>  dmfcc7;
-	std::vector<float>  dmfcc8;
-	std::vector<float>  dmfcc9;
-	std::vector<float>  dmfcc10;
-	std::vector<float>  dmfcc11;
-	std::vector<float>  dmfcc12;
+	std::vector<float>  spectralContrast1;
+	std::vector<float>  spectralContrast2;
+	std::vector<float>  spectralContrast3;
+	std::vector<float>  spectralContrast4;
+	std::vector<float>  spectralContrast5;
+	std::vector<float>  spectralContrast6;
+
+	std::vector<float>  spectralValley1;
+	std::vector<float>  spectralValley2;
+	std::vector<float>  spectralValley3;
+	std::vector<float>  spectralValley4;
+	std::vector<float>  spectralValley5;
+	std::vector<float>  spectralValley6;
 
 	for(size_t i = 1; i <= m_ObservationData.size(); i++)
 	{
@@ -80,6 +81,7 @@
 		flatness.push_back(m_ObservationData[i -1].GetFlatness());
 		spectralcf.push_back(m_ObservationData[i -1].GetSpectralCF());
 		spectralflux.push_back(m_ObservationData[i -1].GetSpectralFlux());
+
 		mfcc1.push_back(m_ObservationData[i -1].GetMFCCs()[0]);
 		mfcc2.push_back(m_ObservationData[i -1].GetMFCCs()[1]);
 		mfcc3.push_back(m_ObservationData[i -1].GetMFCCs()[2]);
@@ -93,6 +95,20 @@
 		mfcc11.push_back(m_ObservationData[i -1].GetMFCCs()[10]);
 		mfcc12.push_back(m_ObservationData[i -1].GetMFCCs()[11]);
 
+		spectralContrast1.push_back(m_ObservationData[i - 1].GetSpectralContrast()[0]);
+		spectralContrast2.push_back(m_ObservationData[i - 1].GetSpectralContrast()[1]);
+		spectralContrast3.push_back(m_ObservationData[i - 1].GetSpectralContrast()[2]);
+		spectralContrast4.push_back(m_ObservationData[i - 1].GetSpectralContrast()[3]);
+		spectralContrast5.push_back(m_ObservationData[i - 1].GetSpectralContrast()[4]);
+		spectralContrast6.push_back(m_ObservationData[i - 1].GetSpectralContrast()[5]);
+
+		spectralValley1.push_back(m_ObservationData[i - 1].GetSpectralValley()[0]);
+		spectralValley2.push_back(m_ObservationData[i - 1].GetSpectralValley()[1]);
+		spectralValley3.push_back(m_ObservationData[i - 1].GetSpectralValley()[2]);
+		spectralValley4.push_back(m_ObservationData[i - 1].GetSpectralValley()[3]);
+		spectralValley5.push_back(m_ObservationData[i - 1].GetSpectralValley()[4]);
+		spectralValley6.push_back(m_ObservationData[i - 1].GetSpectralValley()[5]);
+
 		if(i % modval == 0)
 		{
 			std::vector<float> peaksubset(peak.begin() + index, peak.begin() + index + modval);
@@ -123,19 +139,33 @@
 			std::vector<float> mfcc10subset(mfcc10.begin() + index, mfcc10.begin() + index + modval);			
 			std::vector<float> mfcc11subset(mfcc11.begin() + index, mfcc11.begin() + index + modval);			
 			std::vector<float> mfcc12subset(mfcc12.begin() + index, mfcc12.begin() + index + modval);
+					
+			std::vector<float> dmfcc1subset(m_deltamfccs[0].begin() + index, m_deltamfccs[0].begin() + index + modval);
+			std::vector<float> dmfcc2subset(m_deltamfccs[1].begin() + index, m_deltamfccs[1].begin() + index + modval);
+			std::vector<float> dmfcc3subset(m_deltamfccs[2].begin() + index, m_deltamfccs[2].begin() + index + modval);
+			std::vector<float> dmfcc4subset(m_deltamfccs[3].begin() + index, m_deltamfccs[3].begin() + index + modval);
+			std::vector<float> dmfcc5subset(m_deltamfccs[4].begin() + index, m_deltamfccs[4].begin() + index + modval);
+			std::vector<float> dmfcc6subset(m_deltamfccs[5].begin() + index, m_deltamfccs[5].begin() + index + modval);
+			std::vector<float> dmfcc7subset(m_deltamfccs[6].begin() + index, m_deltamfccs[6].begin() + index + modval);
+			std::vector<float> dmfcc8subset(m_deltamfccs[7].begin() + index, m_deltamfccs[7].begin() + index + modval);
+			std::vector<float> dmfcc9subset(m_deltamfccs[8].begin() + index, m_deltamfccs[8].begin() + index + modval);
+			std::vector<float> dmfcc10subset(m_deltamfccs[9].begin() + index, m_deltamfccs[9].begin() + index + modval);
+			std::vector<float> dmfcc11subset(m_deltamfccs[10].begin() + index, m_deltamfccs[10].begin() + index + modval);
+			std::vector<float> dmfcc12subset(m_deltamfccs[11].begin() + index, m_deltamfccs[11].begin() + index + modval);
 
-			std::vector<float> dmfcc1subset(m_deltamfccs[0].begin() + index, m_deltamfccs[0].begin() + index + modval);			
-			std::vector<float> dmfcc2subset(m_deltamfccs[1].begin() + index, m_deltamfccs[1].begin() + index + modval);			
-			std::vector<float> dmfcc3subset(m_deltamfccs[2].begin() + index, m_deltamfccs[2].begin() + index + modval);			
-			std::vector<float> dmfcc4subset(m_deltamfccs[3].begin() + index, m_deltamfccs[3].begin() + index + modval);			
-			std::vector<float> dmfcc5subset(m_deltamfccs[4].begin() + index, m_deltamfccs[4].begin() + index + modval);			
-			std::vector<float> dmfcc6subset(m_deltamfccs[5].begin() + index, m_deltamfccs[5].begin() + index + modval);			
-			std::vector<float> dmfcc7subset(m_deltamfccs[6].begin() + index, m_deltamfccs[6].begin() + index + modval);			
-			std::vector<float> dmfcc8subset(m_deltamfccs[7].begin() + index, m_deltamfccs[7].begin() + index + modval);			
-			std::vector<float> dmfcc9subset(m_deltamfccs[8].begin() + index, m_deltamfccs[8].begin() + index + modval);			
-			std::vector<float> dmfcc10subset(m_deltamfccs[9].begin() + index, m_deltamfccs[9].begin() + index + modval);			
-			std::vector<float> dmfcc11subset(m_deltamfccs[10].begin() + index, m_deltamfccs[10].begin() + index + modval);			
-			std::vector<float> dmfcc12subset(m_deltamfccs[11].begin() + index, m_deltamfccs[11].begin() + index + modval);
+			std::vector<float> spectralContrast1subset(spectralContrast1.begin() + index, spectralContrast1.begin() + index + modval);
+			std::vector<float> spectralContrast2subset(spectralContrast2.begin() + index, spectralContrast2.begin() + index + modval);
+			std::vector<float> spectralContrast3subset(spectralContrast3.begin() + index, spectralContrast3.begin() + index + modval);
+			std::vector<float> spectralContrast4subset(spectralContrast4.begin() + index, spectralContrast4.begin() + index + modval);
+			std::vector<float> spectralContrast5subset(spectralContrast5.begin() + index, spectralContrast5.begin() + index + modval);
+			std::vector<float> spectralContrast6subset(spectralContrast6.begin() + index, spectralContrast6.begin() + index + modval);
+
+			std::vector<float> spectralValley1subset(spectralValley1.begin() + index, spectralValley1.begin() + index + modval);
+			std::vector<float> spectralValley2subset(spectralValley2.begin() + index, spectralValley2.begin() + index + modval);
+			std::vector<float> spectralValley3subset(spectralValley3.begin() + index, spectralValley3.begin() + index + modval);
+			std::vector<float> spectralValley4subset(spectralValley4.begin() + index, spectralValley4.begin() + index + modval);
+			std::vector<float> spectralValley5subset(spectralValley5.begin() + index, spectralValley5.begin() + index + modval);
+			std::vector<float> spectralValley6subset(spectralValley6.begin() + index, spectralValley6.begin() + index + modval);
 
 			float  avgpeak = Average(peaksubset);
 			float  avgrms = Average(rmssubset);
@@ -154,6 +184,9 @@
 			float  avgspectralflux = Average(spectralfluxsubset); 
 			std::vector<float>  avgmfcc;
 			std::vector<float>  avgdmfcc;
+			std::vector<float>  avgspectralContrast;
+			std::vector<float>  avgspectralValley;
+
 			avgmfcc.push_back(Average(mfcc1subset));
 			avgmfcc.push_back(Average(mfcc2subset));
 			avgmfcc.push_back(Average(mfcc3subset));
@@ -180,44 +213,79 @@
 			avgdmfcc.push_back(Average(dmfcc11subset));
 			avgdmfcc.push_back(Average(dmfcc12subset));
 
-			ObservationData obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdmfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+			avgspectralContrast.push_back(Average(spectralContrast1subset));
+			avgspectralContrast.push_back(Average(spectralContrast2subset));
+			avgspectralContrast.push_back(Average(spectralContrast3subset));
+			avgspectralContrast.push_back(Average(spectralContrast4subset));
+			avgspectralContrast.push_back(Average(spectralContrast5subset));
+			avgspectralContrast.push_back(Average(spectralContrast6subset));
+
+			avgspectralValley.push_back(Average(spectralValley1subset));
+			avgspectralValley.push_back(Average(spectralValley2subset));
+			avgspectralValley.push_back(Average(spectralValley3subset));
+			avgspectralValley.push_back(Average(spectralValley4subset));
+			avgspectralValley.push_back(Average(spectralValley5subset));
+			avgspectralValley.push_back(Average(spectralValley6subset));
+
+
+			ObservationData obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdmfcc, avgspectralContrast, avgspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 			obs.SetLowEnergy(m_ObservationData[i-1].GetLowEnergy());
 			m_PooledObservationDataAverage.push_back(obs);
 
 			std::vector<float>  stdmfcc;
 			std::vector<float>  stddmfcc;
-			stdmfcc.push_back(Deviation(mfcc1,avgmfcc[0]));
-			stdmfcc.push_back(Deviation(mfcc2,avgmfcc[1]));
-			stdmfcc.push_back(Deviation(mfcc3,avgmfcc[2]));
-			stdmfcc.push_back(Deviation(mfcc4,avgmfcc[3]));
-			stdmfcc.push_back(Deviation(mfcc5,avgmfcc[4]));
-			stdmfcc.push_back(Deviation(mfcc6,avgmfcc[5]));
-			stdmfcc.push_back(Deviation(mfcc7,avgmfcc[6]));
-			stdmfcc.push_back(Deviation(mfcc8,avgmfcc[7]));
-			stdmfcc.push_back(Deviation(mfcc9,avgmfcc[8]));
-			stdmfcc.push_back(Deviation(mfcc10,avgmfcc[9]));
-			stdmfcc.push_back(Deviation(mfcc11,avgmfcc[10]));
-			stdmfcc.push_back(Deviation(mfcc12,avgmfcc[11]));
+			std::vector<float>  stdspectralContrast;
+			std::vector<float>  stdspectralValley;
 
-			stddmfcc.push_back(Deviation(m_deltamfccs[0], avgdmfcc[0]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[1], avgdmfcc[1]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[2], avgdmfcc[2]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[3], avgdmfcc[3]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[4], avgdmfcc[4]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[5], avgdmfcc[5]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[6], avgdmfcc[6]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[7], avgdmfcc[7]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[8], avgdmfcc[8]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[9], avgdmfcc[9]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[10], avgdmfcc[10]));
-			stddmfcc.push_back(Deviation(m_deltamfccs[11], avgdmfcc[11]));
+			stdmfcc.push_back(Deviation(mfcc1subset,avgmfcc[0]));
+			stdmfcc.push_back(Deviation(mfcc2subset, avgmfcc[1]));
+			stdmfcc.push_back(Deviation(mfcc3subset, avgmfcc[2]));
+			stdmfcc.push_back(Deviation(mfcc4subset, avgmfcc[3]));
+			stdmfcc.push_back(Deviation(mfcc5subset, avgmfcc[4]));
+			stdmfcc.push_back(Deviation(mfcc6subset, avgmfcc[5]));
+			stdmfcc.push_back(Deviation(mfcc7subset, avgmfcc[6]));
+			stdmfcc.push_back(Deviation(mfcc8subset, avgmfcc[7]));
+			stdmfcc.push_back(Deviation(mfcc9subset, avgmfcc[8]));
+			stdmfcc.push_back(Deviation(mfcc10subset, avgmfcc[9]));
+			stdmfcc.push_back(Deviation(mfcc11subset, avgmfcc[10]));
+			stdmfcc.push_back(Deviation(mfcc12subset, avgmfcc[11]));
 
-			obs = ObservationData(Deviation(rmssubset, avgrms), Deviation(peaksubset, avgpeak),  Deviation(crestfactorsubset, avgcrestFactor), Deviation(zcrsubset, avgzcr), Deviation(centroidsubset, avgcentroid), Deviation(spreadsubset, avgspread), Deviation(skewnesssubset, avgskewness), Deviation(kurtosissubset, avgkurtosis), Deviation(brightnesssubset, avgbrightness), Deviation(rolloff85subset, avgrolloff85), Deviation(rolloff95subset, avgrolloff95), Deviation(spectralentropysubset, avgspectralentropy), Deviation(flatnesssubset, avgflatness), Deviation(spectralcfsubset, avgspectralcf), Deviation(spectralfluxsubset, avgspectralflux), stdmfcc, stddmfcc, 0, 0);
+			stddmfcc.push_back(Deviation(dmfcc1subset, avgdmfcc[0]));
+			stddmfcc.push_back(Deviation(dmfcc2subset, avgdmfcc[1]));
+			stddmfcc.push_back(Deviation(dmfcc3subset, avgdmfcc[2]));
+			stddmfcc.push_back(Deviation(dmfcc4subset, avgdmfcc[3]));
+			stddmfcc.push_back(Deviation(dmfcc5subset, avgdmfcc[4]));
+			stddmfcc.push_back(Deviation(dmfcc6subset, avgdmfcc[5]));
+			stddmfcc.push_back(Deviation(dmfcc7subset, avgdmfcc[6]));
+			stddmfcc.push_back(Deviation(dmfcc8subset, avgdmfcc[7]));
+			stddmfcc.push_back(Deviation(dmfcc9subset, avgdmfcc[8]));
+			stddmfcc.push_back(Deviation(dmfcc10subset, avgdmfcc[9]));
+			stddmfcc.push_back(Deviation(dmfcc11subset, avgdmfcc[10]));
+			stddmfcc.push_back(Deviation(dmfcc12subset, avgdmfcc[11]));
+
+			stdspectralContrast.push_back(Deviation(spectralContrast1subset, avgspectralContrast[0]));
+			stdspectralContrast.push_back(Deviation(spectralContrast2subset, avgspectralContrast[1]));
+			stdspectralContrast.push_back(Deviation(spectralContrast3subset, avgspectralContrast[2]));
+			stdspectralContrast.push_back(Deviation(spectralContrast4subset, avgspectralContrast[3]));
+			stdspectralContrast.push_back(Deviation(spectralContrast5subset, avgspectralContrast[4]));
+			stdspectralContrast.push_back(Deviation(spectralContrast6subset, avgspectralContrast[5]));
+
+			stdspectralValley.push_back(Deviation(spectralValley1subset, avgspectralValley[0]));
+			stdspectralValley.push_back(Deviation(spectralValley2subset, avgspectralValley[1]));
+			stdspectralValley.push_back(Deviation(spectralValley3subset, avgspectralValley[2]));
+			stdspectralValley.push_back(Deviation(spectralValley4subset, avgspectralValley[3]));
+			stdspectralValley.push_back(Deviation(spectralValley5subset, avgspectralValley[4]));
+			stdspectralValley.push_back(Deviation(spectralValley6subset, avgspectralValley[5]));
+
+			obs = ObservationData(Deviation(rmssubset, avgrms), Deviation(peaksubset, avgpeak),  Deviation(crestfactorsubset, avgcrestFactor), Deviation(zcrsubset, avgzcr), Deviation(centroidsubset, avgcentroid), Deviation(spreadsubset, avgspread), Deviation(skewnesssubset, avgskewness), Deviation(kurtosissubset, avgkurtosis), Deviation(brightnesssubset, avgbrightness), Deviation(rolloff85subset, avgrolloff85), Deviation(rolloff95subset, avgrolloff95), Deviation(spectralentropysubset, avgspectralentropy), Deviation(flatnesssubset, avgflatness), Deviation(spectralcfsubset, avgspectralcf), Deviation(spectralfluxsubset, avgspectralflux), stdmfcc, stddmfcc, stdspectralContrast, stdspectralValley, 0, 0);
 			obs.SetLowEnergy(0); //
 			m_PooledObservationDataStd.push_back(obs);
 
 			std::vector<float>  maxmfcc;
 			std::vector<float>  maxdmfcc;
+			std::vector<float>  maxspectralContrast;
+			std::vector<float>  maxspectralValley;
+
 			maxmfcc.push_back(Max(mfcc1subset));
 			maxmfcc.push_back(Max(mfcc2subset));
 			maxmfcc.push_back(Max(mfcc3subset));
@@ -244,12 +312,29 @@
 			maxdmfcc.push_back(Max(dmfcc11subset));
 			maxdmfcc.push_back(Max(dmfcc12subset));
 
-			obs = ObservationData(Max(rmssubset), Max(peaksubset), Max(crestfactorsubset),  Max(zcrsubset), Max(centroidsubset), Max(spreadsubset), Max(skewnesssubset), Max(kurtosissubset), Max(brightnesssubset), Max(rolloff85subset), Max(rolloff95subset), Max(spectralentropysubset), Max(flatnesssubset), Max(spectralcfsubset), Max(spectralfluxsubset), maxmfcc, maxdmfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+			maxspectralContrast.push_back(Max(spectralContrast1subset));
+			maxspectralContrast.push_back(Max(spectralContrast2subset));
+			maxspectralContrast.push_back(Max(spectralContrast3subset));
+			maxspectralContrast.push_back(Max(spectralContrast4subset));
+			maxspectralContrast.push_back(Max(spectralContrast5subset));
+			maxspectralContrast.push_back(Max(spectralContrast6subset));
+
+			maxspectralValley.push_back(Max(spectralValley1subset));
+			maxspectralValley.push_back(Max(spectralValley2subset));
+			maxspectralValley.push_back(Max(spectralValley3subset));
+			maxspectralValley.push_back(Max(spectralValley4subset));
+			maxspectralValley.push_back(Max(spectralValley5subset));
+			maxspectralValley.push_back(Max(spectralValley6subset));
+
+			obs = ObservationData(Max(rmssubset), Max(peaksubset), Max(crestfactorsubset),  Max(zcrsubset), Max(centroidsubset), Max(spreadsubset), Max(skewnesssubset), Max(kurtosissubset), Max(brightnesssubset), Max(rolloff85subset), Max(rolloff95subset), Max(spectralentropysubset), Max(flatnesssubset), Max(spectralcfsubset), Max(spectralfluxsubset), maxmfcc, maxdmfcc, maxspectralContrast, maxspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 			obs.SetLowEnergy(m_ObservationData[i-1].GetLowEnergy());
 			m_PooledObservationDataMax.push_back(obs);
 
 			std::vector<float>  minmfcc;
 			std::vector<float>  mindmfcc;
+			std::vector<float>  minspectralContrast;
+			std::vector<float>  minspectralValley;
+
 			minmfcc.push_back(Min(mfcc1subset));
 			minmfcc.push_back(Min(mfcc2subset));
 			minmfcc.push_back(Min(mfcc3subset));
@@ -276,7 +361,21 @@
 			mindmfcc.push_back(Min(dmfcc11subset));
 			mindmfcc.push_back(Min(dmfcc12subset));
 
-			obs = ObservationData(Min(rmssubset), Min(peaksubset),  Min(crestfactorsubset),  Min(zcrsubset), Min(centroidsubset), Min(spreadsubset), Min(skewnesssubset), Min(kurtosissubset), Min(brightnesssubset), Min(rolloff85subset), Min(rolloff95subset), Min(spectralentropysubset), Min(flatnesssubset), Min(spectralcfsubset),  Min(spectralfluxsubset), minmfcc, mindmfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+			minspectralContrast.push_back(Min(spectralContrast1subset));
+			minspectralContrast.push_back(Min(spectralContrast2subset));
+			minspectralContrast.push_back(Min(spectralContrast3subset));
+			minspectralContrast.push_back(Min(spectralContrast4subset));
+			minspectralContrast.push_back(Min(spectralContrast5subset));
+			minspectralContrast.push_back(Min(spectralContrast6subset));
+
+			minspectralValley.push_back(Min(spectralValley1subset));
+			minspectralValley.push_back(Min(spectralValley2subset));
+			minspectralValley.push_back(Min(spectralValley3subset));
+			minspectralValley.push_back(Min(spectralValley4subset));
+			minspectralValley.push_back(Min(spectralValley5subset));
+			minspectralValley.push_back(Min(spectralValley6subset));
+
+			obs = ObservationData(Min(rmssubset), Min(peaksubset),  Min(crestfactorsubset),  Min(zcrsubset), Min(centroidsubset), Min(spreadsubset), Min(skewnesssubset), Min(kurtosissubset), Min(brightnesssubset), Min(rolloff85subset), Min(rolloff95subset), Min(spectralentropysubset), Min(flatnesssubset), Min(spectralcfsubset),  Min(spectralfluxsubset), minmfcc, mindmfcc, minspectralContrast, minspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 			obs.SetLowEnergy(m_ObservationData[i-1].GetLowEnergy());
 			m_PooledObservationDataMin.push_back(obs);
 
@@ -329,6 +428,20 @@
 	std::vector<float> dmfcc11subset(m_deltamfccs[10].begin() + remainderindex, m_deltamfccs[10].end());			
 	std::vector<float> dmfcc12subset(m_deltamfccs[11].begin() + remainderindex, m_deltamfccs[11].end());
 
+	std::vector<float> spectralContrast1subset(spectralContrast1.begin() + remainderindex, spectralContrast1.end());
+	std::vector<float> spectralContrast2subset(spectralContrast2.begin() + remainderindex, spectralContrast2.end());
+	std::vector<float> spectralContrast3subset(spectralContrast3.begin() + remainderindex, spectralContrast3.end());
+	std::vector<float> spectralContrast4subset(spectralContrast4.begin() + remainderindex, spectralContrast4.end());
+	std::vector<float> spectralContrast5subset(spectralContrast5.begin() + remainderindex, spectralContrast5.end());
+	std::vector<float> spectralContrast6subset(spectralContrast6.begin() + remainderindex, spectralContrast6.end());
+
+	std::vector<float> spectralValley1subset(spectralValley1.begin() + remainderindex, spectralValley1.end());
+	std::vector<float> spectralValley2subset(spectralValley2.begin() + remainderindex, spectralValley2.end());
+	std::vector<float> spectralValley3subset(spectralValley3.begin() + remainderindex, spectralValley3.end());
+	std::vector<float> spectralValley4subset(spectralValley4.begin() + remainderindex, spectralValley4.end());
+	std::vector<float> spectralValley5subset(spectralValley5.begin() + remainderindex, spectralValley5.end());
+	std::vector<float> spectralValley6subset(spectralValley6.begin() + remainderindex, spectralValley6.end());
+
 	float  avgpeak = Average(peaksubset);
 	float  avgrms = Average(rmssubset);
 	float  avgcrestFactor = Average(crestFactorsubset);
@@ -347,6 +460,9 @@
 
 	std::vector<float>  avgmfcc;
 	std::vector<float>  avgdeltamfcc;
+	std::vector<float>  avgspectralContrast;
+	std::vector<float>  avgspectralValley;
+
 	avgmfcc.push_back(Average(mfcc1subset));
 	avgmfcc.push_back(Average(mfcc2subset));
 	avgmfcc.push_back(Average(mfcc3subset));
@@ -373,12 +489,29 @@
 	avgdeltamfcc.push_back(Average(dmfcc11subset));
 	avgdeltamfcc.push_back(Average(dmfcc12subset));
 
-	ObservationData obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+	avgspectralContrast.push_back(Average(spectralContrast1subset));
+	avgspectralContrast.push_back(Average(spectralContrast2subset));
+	avgspectralContrast.push_back(Average(spectralContrast3subset));
+	avgspectralContrast.push_back(Average(spectralContrast4subset));
+	avgspectralContrast.push_back(Average(spectralContrast5subset));
+	avgspectralContrast.push_back(Average(spectralContrast6subset));
+
+	avgspectralValley.push_back(Average(spectralValley1subset));
+	avgspectralValley.push_back(Average(spectralValley2subset));
+	avgspectralValley.push_back(Average(spectralValley3subset));
+	avgspectralValley.push_back(Average(spectralValley4subset));
+	avgspectralValley.push_back(Average(spectralValley5subset));
+	avgspectralValley.push_back(Average(spectralValley6subset));
+
+	ObservationData obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdeltamfcc, avgspectralContrast, avgspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 	obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
 	m_PooledObservationDataAverage.push_back(obs);
 
 	std::vector<float>  stdmfcc;
 	std::vector<float>  stddeltamfcc;
+	std::vector<float>  stdspectralContrast;
+	std::vector<float>  stdspectralValley;
+
 	stdmfcc.push_back(Deviation(mfcc1subset,avgmfcc[0]));
 	stdmfcc.push_back(Deviation(mfcc2subset,avgmfcc[1]));
 	stdmfcc.push_back(Deviation(mfcc3subset,avgmfcc[2]));
@@ -405,12 +538,29 @@
 	stddeltamfcc.push_back(Deviation(dmfcc11subset,avgdeltamfcc[10]));
 	stddeltamfcc.push_back(Deviation(dmfcc12subset,avgdeltamfcc[11]));
 
-	obs = ObservationData(Deviation(rmssubset, avgrms), Deviation(peaksubset, avgpeak), Deviation(crestFactorsubset, avgcrestFactor), Deviation(zcrsubset, avgzcr), Deviation(centroidsubset, avgcentroid), Deviation(spreadsubset, avgspread), Deviation(skewnesssubset, avgskewness), Deviation(kurtosissubset, avgkurtosis), Deviation(brightnesssubset, avgbrightness), Deviation(rolloff85subset, avgrolloff85), Deviation(rolloff95subset, avgrolloff95), Deviation(spectralentropysubset, avgspectralentropy), Deviation(flatnesssubset, avgflatness), Deviation(spectralcfsubset, avgspectralcf), Deviation(spectralfluxsubset, avgspectralflux), stdmfcc, stddeltamfcc, 0, 0);
+	stdspectralContrast.push_back(Deviation(spectralContrast1subset, avgspectralContrast[0]));
+	stdspectralContrast.push_back(Deviation(spectralContrast2subset, avgspectralContrast[1]));
+	stdspectralContrast.push_back(Deviation(spectralContrast3subset, avgspectralContrast[2]));
+	stdspectralContrast.push_back(Deviation(spectralContrast4subset, avgspectralContrast[3]));
+	stdspectralContrast.push_back(Deviation(spectralContrast5subset, avgspectralContrast[4]));
+	stdspectralContrast.push_back(Deviation(spectralContrast6subset, avgspectralContrast[5]));
+
+	stdspectralValley.push_back(Deviation(spectralValley1subset, avgspectralValley[0]));
+	stdspectralValley.push_back(Deviation(spectralValley2subset, avgspectralValley[1]));
+	stdspectralValley.push_back(Deviation(spectralValley3subset, avgspectralValley[2]));
+	stdspectralValley.push_back(Deviation(spectralValley4subset, avgspectralValley[3]));
+	stdspectralValley.push_back(Deviation(spectralValley5subset, avgspectralValley[4]));
+	stdspectralValley.push_back(Deviation(spectralValley6subset, avgspectralValley[5]));
+
+	obs = ObservationData(Deviation(rmssubset, avgrms), Deviation(peaksubset, avgpeak), Deviation(crestFactorsubset, avgcrestFactor), Deviation(zcrsubset, avgzcr), Deviation(centroidsubset, avgcentroid), Deviation(spreadsubset, avgspread), Deviation(skewnesssubset, avgskewness), Deviation(kurtosissubset, avgkurtosis), Deviation(brightnesssubset, avgbrightness), Deviation(rolloff85subset, avgrolloff85), Deviation(rolloff95subset, avgrolloff95), Deviation(spectralentropysubset, avgspectralentropy), Deviation(flatnesssubset, avgflatness), Deviation(spectralcfsubset, avgspectralcf), Deviation(spectralfluxsubset, avgspectralflux), stdmfcc, stddeltamfcc, stdspectralContrast, stdspectralValley, 0, 0);
 	obs.SetLowEnergy(0); //
 	m_PooledObservationDataStd.push_back(obs);
 
 	std::vector<float>  maxmfcc;
 	std::vector<float>  maxdeltamfcc;
+	std::vector<float>  maxspectralContrast;
+	std::vector<float>  maxspectralValley;
+
 	maxmfcc.push_back(Max(mfcc1subset));
 	maxmfcc.push_back(Max(mfcc2subset));
 	maxmfcc.push_back(Max(mfcc3subset));
@@ -437,12 +587,29 @@
 	maxdeltamfcc.push_back(Max(dmfcc11subset));
 	maxdeltamfcc.push_back(Max(dmfcc12subset));
 
-	obs = ObservationData(Max(rmssubset), Max(peaksubset), Max(crestFactorsubset), Max(zcrsubset), Max(centroidsubset), Max(spreadsubset), Max(skewnesssubset), Max(kurtosissubset), Max(brightnesssubset), Max(rolloff85subset), Max(rolloff95subset), Max(spectralentropysubset), Max(flatnesssubset), Max(spectralcfsubset),  Max(spectralfluxsubset), maxmfcc, maxdeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+	maxspectralContrast.push_back(Max(spectralContrast1subset));
+	maxspectralContrast.push_back(Max(spectralContrast2subset));
+	maxspectralContrast.push_back(Max(spectralContrast3subset));
+	maxspectralContrast.push_back(Max(spectralContrast4subset));
+	maxspectralContrast.push_back(Max(spectralContrast5subset));
+	maxspectralContrast.push_back(Max(spectralContrast6subset));
+
+	maxspectralValley.push_back(Max(spectralValley1subset));
+	maxspectralValley.push_back(Max(spectralValley2subset));
+	maxspectralValley.push_back(Max(spectralValley3subset));
+	maxspectralValley.push_back(Max(spectralValley4subset));
+	maxspectralValley.push_back(Max(spectralValley5subset));
+	maxspectralValley.push_back(Max(spectralValley6subset));
+
+	obs = ObservationData(Max(rmssubset), Max(peaksubset), Max(crestFactorsubset), Max(zcrsubset), Max(centroidsubset), Max(spreadsubset), Max(skewnesssubset), Max(kurtosissubset), Max(brightnesssubset), Max(rolloff85subset), Max(rolloff95subset), Max(spectralentropysubset), Max(flatnesssubset), Max(spectralcfsubset),  Max(spectralfluxsubset), maxmfcc, maxdeltamfcc, maxspectralContrast, maxspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 	obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
 	m_PooledObservationDataMax.push_back(obs);
 
 	std::vector<float>  minmfcc;
 	std::vector<float> mindeltamfcc;
+	std::vector<float>  minspectralContrast;
+	std::vector<float>  minspectralValley;
+
 	minmfcc.push_back(Min(mfcc1subset));
 	minmfcc.push_back(Min(mfcc2subset));
 	minmfcc.push_back(Min(mfcc3subset));
@@ -469,7 +636,22 @@
 	mindeltamfcc.push_back(Min(dmfcc11subset));
 	mindeltamfcc.push_back(Min(dmfcc12subset));
 
-	obs = ObservationData( Min(rmssubset), Min(peaksubset), Min(crestFactorsubset), Min(zcrsubset), Min(centroidsubset), Min(spreadsubset), Min(skewnesssubset), Min(kurtosissubset), Min(brightnesssubset), Min(rolloff85subset), Min(rolloff95subset), Min(spectralentropysubset), Min(flatnesssubset), Min(spectralcfsubset),  Min(spectralfluxsubset), minmfcc, mindeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+	minspectralContrast.push_back(Min(spectralContrast1subset));
+	minspectralContrast.push_back(Min(spectralContrast2subset));
+	minspectralContrast.push_back(Min(spectralContrast3subset));
+	minspectralContrast.push_back(Min(spectralContrast4subset));
+	minspectralContrast.push_back(Min(spectralContrast5subset));
+	minspectralContrast.push_back(Min(spectralContrast6subset));
+
+	minspectralValley.push_back(Min(spectralValley1subset));
+	minspectralValley.push_back(Min(spectralValley2subset));
+	minspectralValley.push_back(Min(spectralValley3subset));
+	minspectralValley.push_back(Min(spectralValley4subset));
+	minspectralValley.push_back(Min(spectralValley5subset));
+	minspectralValley.push_back(Min(spectralValley6subset));
+
+
+	obs = ObservationData( Min(rmssubset), Min(peaksubset), Min(crestFactorsubset), Min(zcrsubset), Min(centroidsubset), Min(spreadsubset), Min(skewnesssubset), Min(kurtosissubset), Min(brightnesssubset), Min(rolloff85subset), Min(rolloff95subset), Min(spectralentropysubset), Min(flatnesssubset), Min(spectralcfsubset),  Min(spectralfluxsubset), minmfcc, mindeltamfcc, minspectralContrast, minspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 	obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
 	m_PooledObservationDataMin.push_back(obs);
 
@@ -519,9 +701,25 @@
 	avgdeltamfcc.push_back(Average(m_deltamfccs[10]));
 	avgdeltamfcc.push_back(Average(m_deltamfccs[11]));
 
+	avgspectralContrast.clear();
+	avgspectralContrast.push_back(Average(spectralContrast1));
+	avgspectralContrast.push_back(Average(spectralContrast2));
+	avgspectralContrast.push_back(Average(spectralContrast3));
+	avgspectralContrast.push_back(Average(spectralContrast4));
+	avgspectralContrast.push_back(Average(spectralContrast5));
+	avgspectralContrast.push_back(Average(spectralContrast6));
+
+	avgspectralValley.clear();
+	avgspectralValley.push_back(Average(spectralValley1));
+	avgspectralValley.push_back(Average(spectralValley2));
+	avgspectralValley.push_back(Average(spectralValley3));
+	avgspectralValley.push_back(Average(spectralValley4));
+	avgspectralValley.push_back(Average(spectralValley5));
+	avgspectralValley.push_back(Average(spectralValley6));
+
 	//for(size_t i =0; i < m_PooledObservationDataAverage.size(); i++)
 	{
-		obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+		obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdeltamfcc, avgspectralContrast, avgspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 		obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
 		m_WholeTrackObservationDataAverage.push_back(obs);
 
@@ -540,20 +738,36 @@
 		stdmfcc.push_back(Deviation(mfcc12,avgmfcc[11]));
 
 		stddeltamfcc.clear();
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[0],avgdeltamfcc[0]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[1],avgdeltamfcc[1]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[2],avgdeltamfcc[2]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[3],avgdeltamfcc[3]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[4],avgdeltamfcc[4]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[5],avgdeltamfcc[5]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[6],avgdeltamfcc[6]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[7],avgdeltamfcc[7]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[8],avgdeltamfcc[8]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[9],avgdeltamfcc[9]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[10],avgdeltamfcc[10]));
-		stddeltamfcc.push_back(Deviation(m_deltamfccs[11],avgdeltamfcc[11]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[0], avgdeltamfcc[0]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[1], avgdeltamfcc[1]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[2], avgdeltamfcc[2]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[3], avgdeltamfcc[3]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[4], avgdeltamfcc[4]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[5], avgdeltamfcc[5]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[6], avgdeltamfcc[6]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[7], avgdeltamfcc[7]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[8], avgdeltamfcc[8]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[9], avgdeltamfcc[9]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[10], avgdeltamfcc[10]));
+		stddeltamfcc.push_back(Deviation(m_deltamfccs[11], avgdeltamfcc[11]));
 
-		obs = ObservationData(Deviation(rms, avgrms), Deviation(peak, avgpeak), Deviation(crestFactor, avgcrestFactor), Deviation(zcr, avgzcr), Deviation(centroid, avgcentroid), Deviation(spread, avgspread), Deviation(skewness, avgskewness), Deviation(kurtosis, avgkurtosis), Deviation(brightness, avgbrightness), Deviation(rolloff85, avgrolloff85), Deviation(rolloff95, avgrolloff95), Deviation(spectralentropy, avgspectralentropy), Deviation(flatness, avgflatness), Deviation(spectralcf, avgspectralcf), Deviation(spectralflux, avgspectralflux), stdmfcc, stddeltamfcc, 0, 0);
+		stdspectralContrast.clear();
+		stdspectralContrast.push_back(Deviation(spectralContrast1, avgspectralContrast[0]));
+		stdspectralContrast.push_back(Deviation(spectralContrast2, avgspectralContrast[1]));
+		stdspectralContrast.push_back(Deviation(spectralContrast3, avgspectralContrast[2]));
+		stdspectralContrast.push_back(Deviation(spectralContrast4, avgspectralContrast[3]));
+		stdspectralContrast.push_back(Deviation(spectralContrast5, avgspectralContrast[4]));
+		stdspectralContrast.push_back(Deviation(spectralContrast6, avgspectralContrast[5]));
+
+		stdspectralValley.clear();
+		stdspectralValley.push_back(Deviation(spectralValley1, avgspectralValley[0]));
+		stdspectralValley.push_back(Deviation(spectralValley2, avgspectralValley[1]));
+		stdspectralValley.push_back(Deviation(spectralValley3, avgspectralValley[2]));
+		stdspectralValley.push_back(Deviation(spectralValley4, avgspectralValley[3]));
+		stdspectralValley.push_back(Deviation(spectralValley5, avgspectralValley[4]));
+		stdspectralValley.push_back(Deviation(spectralValley6, avgspectralValley[5]));
+
+		obs = ObservationData(Deviation(rms, avgrms), Deviation(peak, avgpeak), Deviation(crestFactor, avgcrestFactor), Deviation(zcr, avgzcr), Deviation(centroid, avgcentroid), Deviation(spread, avgspread), Deviation(skewness, avgskewness), Deviation(kurtosis, avgkurtosis), Deviation(brightness, avgbrightness), Deviation(rolloff85, avgrolloff85), Deviation(rolloff95, avgrolloff95), Deviation(spectralentropy, avgspectralentropy), Deviation(flatness, avgflatness), Deviation(spectralcf, avgspectralcf), Deviation(spectralflux, avgspectralflux), stdmfcc, stddeltamfcc, stdspectralContrast, stdspectralValley, 0, 0);
 		obs.SetLowEnergy(0);
 		m_WholeTrackObservationDataStd.push_back(obs);
 
@@ -570,6 +784,7 @@
 		maxmfcc.push_back(Max(mfcc10));
 		maxmfcc.push_back(Max(mfcc11));
 		maxmfcc.push_back(Max(mfcc12));
+
 		maxdeltamfcc.clear();
 		maxdeltamfcc.push_back(Max(m_deltamfccs[0]));
 		maxdeltamfcc.push_back(Max(m_deltamfccs[1]));
@@ -584,7 +799,7 @@
 		maxdeltamfcc.push_back(Max(m_deltamfccs[10]));
 		maxdeltamfcc.push_back(Max(m_deltamfccs[11]));
 
-		obs = ObservationData(Max(rms), Max(peak),  Max(crestFactor), Max(zcr), Max(centroid), Max(spread), Max(skewness), Max(kurtosis), Max(brightness), Max(rolloff85), Max(rolloff95), Max(spectralentropy), Max(flatness), Max(spectralcf),  Max(spectralflux), maxmfcc, maxdeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+		obs = ObservationData(Max(rms), Max(peak),  Max(crestFactor), Max(zcr), Max(centroid), Max(spread), Max(skewness), Max(kurtosis), Max(brightness), Max(rolloff85), Max(rolloff95), Max(spectralentropy), Max(flatness), Max(spectralcf),  Max(spectralflux), maxmfcc, maxdeltamfcc, maxspectralContrast, maxspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 		obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
 		m_WholeTrackObservationDataMax.push_back(obs);
 
@@ -616,7 +831,7 @@
 		mindeltamfcc.push_back(Min(m_deltamfccs[10]));
 		mindeltamfcc.push_back(Min(m_deltamfccs[11]));
 
-		obs = ObservationData(Min(rms), Min(peak),  Min(crestFactor), Min(zcr), Min(centroid), Min(spread), Min(skewness), Min(kurtosis), Min(brightness), Min(rolloff85), Min(rolloff95), Min(spectralentropy), Min(flatness), Min(spectralcf), Min(spectralflux), minmfcc, mindeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
+		obs = ObservationData(Min(rms), Min(peak),  Min(crestFactor), Min(zcr), Min(centroid), Min(spread), Min(skewness), Min(kurtosis), Min(brightness), Min(rolloff85), Min(rolloff95), Min(spectralentropy), Min(flatness), Min(spectralcf), Min(spectralflux), minmfcc, mindeltamfcc, minspectralContrast, minspectralValley, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 		obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
 		m_WholeTrackObservationDataMin.push_back(obs);
 	}
--- a/Source/ObservationData.h	Wed Aug 12 22:25:06 2015 +0100
+++ b/Source/ObservationData.h	Fri Aug 14 18:21:43 2015 +0100
@@ -19,7 +19,7 @@
 	ObservationData();
 	~ObservationData();
 
-	ObservationData(float rms, float peak, float crestfactor, float zcr, float centroid, float spread, float skewness, float kurtosis, float brightness, float rolloff85, float rolloff95, float spectralentropy, float flatness, float spectralcf, float spectralflux, std::vector<float> mfccs, float periodicity, float entropyofenergy)
+	ObservationData(float rms, float peak, float crestfactor, float zcr, float centroid, float spread, float skewness, float kurtosis, float brightness, float rolloff85, float rolloff95, float spectralentropy, float flatness, float spectralcf, float spectralflux, std::vector<float> mfccs, std::vector<float> spectralContrast, std::vector<float> spectralValley, float periodicity, float entropyofenergy)
 	{
 		m_peak = peak;
 		m_rms = rms;
@@ -37,11 +37,13 @@
 		m_spectralcf = spectralcf;
 		m_spectralflux = spectralflux;
 		m_mfccs = mfccs;
+		m_spectralContrast = spectralContrast;
+		m_spectralValley = spectralValley;
 		m_periodicity = periodicity;
 		m_entropyofenergy = entropyofenergy;
 	};
 
-	ObservationData(float rms, float peak, float crestfactor, float zcr, float centroid, float spread, float skewness, float kurtosis, float brightness, float rolloff85, float rolloff95, float spectralentropy, float flatness, float spectralcf, float spectralflux, std::vector<float> mfccs, std::vector<float> dmfccs, float periodicity, float entropyofenergy)
+	ObservationData(float rms, float peak, float crestfactor, float zcr, float centroid, float spread, float skewness, float kurtosis, float brightness, float rolloff85, float rolloff95, float spectralentropy, float flatness, float spectralcf, float spectralflux, std::vector<float> mfccs, std::vector<float> dmfccs, std::vector<float> spectralContrast, std::vector<float> spectralValley, float periodicity, float entropyofenergy)
 	{
 		m_peak = peak;
 		m_rms = rms;
@@ -58,6 +60,8 @@
 		m_flatness = flatness;
 		m_spectralcf = spectralcf;
 		m_spectralflux = spectralflux;
+		m_spectralContrast = spectralContrast;
+		m_spectralValley = spectralValley;
 		m_mfccs = mfccs;
 		m_dmfccs = dmfccs;
 		m_periodicity = periodicity;
@@ -84,6 +88,8 @@
 	float GetLowEnergy(){return m_lowEnergy;}
 	std::vector<float> GetMFCCs(){return m_mfccs;}
 	std::vector<float> GetDeltaMFCCs(){return m_dmfccs;}
+	std::vector<float> GetSpectralContrast(){ return m_spectralContrast; }
+	std::vector<float> GetSpectralValley(){ return m_spectralValley; }
 	
 	//WholeTrack Feature
 	void SetLowEnergy(float lowEnergy){m_lowEnergy = lowEnergy;}
@@ -106,6 +112,8 @@
 	float m_spectralflux;
 	std::vector<float> m_mfccs;
 	std::vector<float> m_dmfccs;
+	std::vector<float> m_spectralContrast;
+	std::vector<float> m_spectralValley;
 	float m_periodicity;
 	float m_lowEnergy;
 	float m_entropyofenergy;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Source/SpectralContrast.cpp	Fri Aug 14 18:21:43 2015 +0100
@@ -0,0 +1,110 @@
+/*
+  ==============================================================================
+
+    SpectralContrast.cpp
+    Created: 14 Aug 2015 12:21:29pm
+    Author:  David
+
+  ==============================================================================
+*/
+
+#include "SpectralContrast.h"
+#include <algorithm>
+
+void SpectralContrast::initSpectralContrastVariables(int frameSize, float sampleRate)
+{
+
+	int numberBands = 6; //the number of bands in the filter
+	float lowFrequencyBound = 20; //the lower bound of the lowest band
+	float highFrequencyBound = sampleRate / 2.0f;
+	float staticDistribution = 0.15f; //the ratio of the bins to distribute equally [0, 1]
+	m_neighbourRatio = 0.4f; //the ratio of the bins in the sub band used to calculate the peak and valley", "(0,1]"
+
+	// get staticDistribution
+	float partToScale = 1.0f - staticDistribution;
+
+	float binWidth = sampleRate / frameSize;
+
+	int lastBins = 0;
+	m_startAtBin = 0;
+
+	m_numberOfBinsInBands.clear();
+	m_numberOfBinsInBands.resize(numberBands);
+	lastBins = int(lowFrequencyBound / binWidth);
+	m_startAtBin = lastBins;
+
+	// Determine how many bins are in each band to start with.
+	// The rest of the bands will be distributed logarithmically.
+	int  totalNumberOfBins = int(highFrequencyBound / binWidth);
+	highFrequencyBound = int(partToScale * totalNumberOfBins) * binWidth;
+	int  staticBinsPerBand = int((1 - partToScale) * totalNumberOfBins) / numberBands;
+	float ratio = highFrequencyBound / lowFrequencyBound;
+	float ratioPerBand = pow(ratio, float(1.0 / numberBands));
+	float currFreq = lowFrequencyBound;
+
+	for (int i = 0; i < numberBands; ++i) 
+	{
+		currFreq = currFreq * ratioPerBand;
+		m_numberOfBinsInBands[i] = int(currFreq / binWidth - lastBins + staticBinsPerBand);
+		lastBins = int(currFreq / binWidth);
+	}
+
+}
+
+void SpectralContrast::computeSpectralContrast(std::vector<float> spectrum, std::vector<float>& spectralContrast, std::vector<float>& valleys)
+{
+	std::vector<float> spectrumCopy = spectrum; // I want a copy because I'll be transforming it
+
+	//substitute minReal for a static value that is the same in all architectures. i.e.: 1e-30
+	float minReal = 1e-30f; //numeric_limits<Real>::min();
+
+	spectralContrast.clear();
+	valleys.clear();
+
+	int specIdx = m_startAtBin;
+
+	for (int bandIdx = 0; bandIdx < int(m_numberOfBinsInBands.size()) && specIdx < int(spectrumCopy.size()); ++bandIdx) 
+	{
+		// get the mean of the band
+		float bandMean = 0;
+		for (int i = 0; i < m_numberOfBinsInBands[bandIdx] && specIdx + i < int(spectrumCopy.size()); ++i)
+		{
+			bandMean += spectrumCopy[specIdx + i];
+		}
+
+		if (m_numberOfBinsInBands[bandIdx] != 0) bandMean /= m_numberOfBinsInBands[bandIdx];
+		{
+			bandMean += minReal;
+		}
+
+		// sort the subband (ascending order)
+		std::sort(spectrumCopy.begin() + specIdx, spectrumCopy.begin() + std::min(specIdx + m_numberOfBinsInBands[bandIdx], int(spectrum.size())));
+
+		// number of bins to take the mean of
+		int neighbourBins = int(m_neighbourRatio * m_numberOfBinsInBands[bandIdx]);
+		if (neighbourBins < 1) neighbourBins = 1;
+
+		// valley (FLT_MIN prevents log(0))
+		float sum = 0;
+		for (int i = 0; i < neighbourBins && specIdx + i < int(spectrum.size()); ++i) 
+		{
+			sum += spectrum[specIdx + i];
+		}
+
+		float valley = sum / neighbourBins + minReal;
+
+		// peak
+		sum = 0;
+		for (int i = m_numberOfBinsInBands[bandIdx]; i > m_numberOfBinsInBands[bandIdx] - neighbourBins && specIdx + i - 1 < int(spectrum.size()) && i > 0; --i)
+		{
+			sum += spectrum[specIdx + i - 1];
+		}
+
+		float peak = sum / neighbourBins + minReal;
+
+		spectralContrast.push_back(-1.0f * (pow(peak / valley, float(1.0f / log(bandMean)))));
+		valleys.push_back(log(valley));
+
+		specIdx += m_numberOfBinsInBands[bandIdx];
+	}
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Source/SpectralContrast.h	Fri Aug 14 18:21:43 2015 +0100
@@ -0,0 +1,29 @@
+/*
+  ==============================================================================
+
+    SpectralContrast.h
+    Created: 14 Aug 2015 12:21:29pm
+    Author:  David
+
+  ==============================================================================
+*/
+
+#ifndef SPECTRALCONTRAST_H_INCLUDED
+#define SPECTRALCONTRAST_H_INCLUDED
+
+#include <vector>
+
+class SpectralContrast
+{
+public:
+	void initSpectralContrastVariables(int frameSize, float sampleRate);
+	void computeSpectralContrast(std::vector<float> spectrum, std::vector<float> &spectralContrast, std::vector<float> &valleys);
+private:
+	std::vector<int> m_numberOfBinsInBands;
+	int m_startAtBin;
+	float m_neighbourRatio;
+};
+
+
+
+#endif  // SPECTRALCONTRAST_H_INCLUDED
--- a/Source/WriteCSV.cpp	Wed Aug 12 22:25:06 2015 +0100
+++ b/Source/WriteCSV.cpp	Fri Aug 14 18:21:43 2015 +0100
@@ -196,6 +196,54 @@
 				<< observationDataStd[j].GetDeltaMFCCs()[11] << ','
 				<< observationDataMax[j].GetDeltaMFCCs()[11] << ','
 				<< observationDataMin[j].GetDeltaMFCCs()[11] << ','
+				<< observationDataAverage[j].GetSpectralContrast()[0] << ','
+				<< observationDataStd[j].GetSpectralContrast()[0] << ','
+				<< observationDataMax[j].GetSpectralContrast()[0] << ','
+				<< observationDataMin[j].GetSpectralContrast()[0] << ','
+				<< observationDataAverage[j].GetSpectralContrast()[1] << ','
+				<< observationDataStd[j].GetSpectralContrast()[1] << ','
+				<< observationDataMax[j].GetSpectralContrast()[1] << ','
+				<< observationDataMin[j].GetSpectralContrast()[1] << ','
+				<< observationDataAverage[j].GetSpectralContrast()[2] << ','
+				<< observationDataStd[j].GetSpectralContrast()[2] << ','
+				<< observationDataMax[j].GetSpectralContrast()[2] << ','
+				<< observationDataMin[j].GetSpectralContrast()[2] << ','
+				<< observationDataAverage[j].GetSpectralContrast()[3] << ','
+				<< observationDataStd[j].GetSpectralContrast()[3] << ','
+				<< observationDataMax[j].GetSpectralContrast()[3] << ','
+				<< observationDataMin[j].GetSpectralContrast()[3] << ','
+				<< observationDataAverage[j].GetSpectralContrast()[4] << ','
+				<< observationDataStd[j].GetSpectralContrast()[4] << ','
+				<< observationDataMax[j].GetSpectralContrast()[4] << ','
+				<< observationDataMin[j].GetSpectralContrast()[4] << ','
+				<< observationDataAverage[j].GetSpectralContrast()[5] << ','
+				<< observationDataStd[j].GetSpectralContrast()[5] << ','
+				<< observationDataMax[j].GetSpectralContrast()[5] << ','
+				<< observationDataMin[j].GetSpectralContrast()[5] << ','
+				<< observationDataAverage[j].GetSpectralValley()[0] << ','
+				<< observationDataStd[j].GetSpectralValley()[0] << ','
+				<< observationDataMax[j].GetSpectralValley()[0] << ','
+				<< observationDataMin[j].GetSpectralValley()[0] << ','
+				<< observationDataAverage[j].GetSpectralValley()[1] << ','
+				<< observationDataStd[j].GetSpectralValley()[1] << ','
+				<< observationDataMax[j].GetSpectralValley()[1] << ','
+				<< observationDataMin[j].GetSpectralValley()[1] << ','
+				<< observationDataAverage[j].GetSpectralValley()[2] << ','
+				<< observationDataStd[j].GetSpectralValley()[2] << ','
+				<< observationDataMax[j].GetSpectralValley()[2] << ','
+				<< observationDataMin[j].GetSpectralValley()[2] << ','
+				<< observationDataAverage[j].GetSpectralValley()[3] << ','
+				<< observationDataStd[j].GetSpectralValley()[3] << ','
+				<< observationDataMax[j].GetSpectralValley()[3] << ','
+				<< observationDataMin[j].GetSpectralValley()[3] << ','
+				<< observationDataAverage[j].GetSpectralValley()[4] << ','
+				<< observationDataStd[j].GetSpectralValley()[4] << ','
+				<< observationDataMax[j].GetSpectralValley()[4] << ','
+				<< observationDataMin[j].GetSpectralValley()[4] << ','
+				<< observationDataAverage[j].GetSpectralValley()[5] << ','
+				<< observationDataStd[j].GetSpectralValley()[5] << ','
+				<< observationDataMax[j].GetSpectralValley()[5] << ','
+				<< observationDataMin[j].GetSpectralValley()[5] << ','
 				<< observationDataAverage[j].GetLowEnergy() << ','
 				<< observationDataAverage[j].GetPeriodicity() << ','
 				<< observationDataAverage[j].GetEntropyOfEnergy() << ','
@@ -381,6 +429,54 @@
 				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[11] << ',' //90
 				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[11] << ',' //91
 				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[11] << ',' //92
+				<< wholeTrackobservationDataAverage[j].GetSpectralContrast()[0] << ','//61
+				<< wholeTrackobservationDataStd[j].GetSpectralContrast()[0] << ',' //62
+				<< wholeTrackobservationDataMax[j].GetSpectralContrast()[0] << ',' //47
+				<< wholeTrackobservationDataMin[j].GetSpectralContrast()[0] << ',' //48
+				<< wholeTrackobservationDataAverage[j].GetSpectralContrast()[1] << ',' //49
+				<< wholeTrackobservationDataStd[j].GetSpectralContrast()[1] << ',' //50
+				<< wholeTrackobservationDataMax[j].GetSpectralContrast()[1] << ',' //51
+				<< wholeTrackobservationDataMin[j].GetSpectralContrast()[1] << ',' //52
+				<< wholeTrackobservationDataAverage[j].GetSpectralContrast()[2] << ',' //53
+				<< wholeTrackobservationDataStd[j].GetSpectralContrast()[2] << ',' //54
+				<< wholeTrackobservationDataMax[j].GetSpectralContrast()[2] << ',' //55
+				<< wholeTrackobservationDataMin[j].GetSpectralContrast()[2] << ',' //56
+				<< wholeTrackobservationDataAverage[j].GetSpectralContrast()[3] << ',' //57
+				<< wholeTrackobservationDataStd[j].GetSpectralContrast()[3] << ',' //58
+				<< wholeTrackobservationDataMax[j].GetSpectralContrast()[3] << ',' //59
+				<< wholeTrackobservationDataMin[j].GetSpectralContrast()[3] << ',' //60
+				<< wholeTrackobservationDataAverage[j].GetSpectralContrast()[4] << ',' //61
+				<< wholeTrackobservationDataStd[j].GetSpectralContrast()[4] << ',' //62
+				<< wholeTrackobservationDataMax[j].GetSpectralContrast()[4] << ',' //63
+				<< wholeTrackobservationDataMin[j].GetSpectralContrast()[4] << ',' //64
+				<< wholeTrackobservationDataAverage[j].GetSpectralContrast()[5] << ',' //65
+				<< wholeTrackobservationDataStd[j].GetSpectralContrast()[5] << ',' //66
+				<< wholeTrackobservationDataMax[j].GetSpectralContrast()[5] << ',' //67
+				<< wholeTrackobservationDataMin[j].GetSpectralContrast()[5] << ',' //68
+				<< wholeTrackobservationDataAverage[j].GetSpectralValley()[0] << ','//61
+				<< wholeTrackobservationDataStd[j].GetSpectralValley()[0] << ',' //62
+				<< wholeTrackobservationDataMax[j].GetSpectralValley()[0] << ',' //47
+				<< wholeTrackobservationDataMin[j].GetSpectralValley()[0] << ',' //48
+				<< wholeTrackobservationDataAverage[j].GetSpectralValley()[1] << ',' //49
+				<< wholeTrackobservationDataStd[j].GetSpectralValley()[1] << ',' //50
+				<< wholeTrackobservationDataMax[j].GetSpectralValley()[1] << ',' //51
+				<< wholeTrackobservationDataMin[j].GetSpectralValley()[1] << ',' //52
+				<< wholeTrackobservationDataAverage[j].GetSpectralValley()[2] << ',' //53
+				<< wholeTrackobservationDataStd[j].GetSpectralValley()[2] << ',' //54
+				<< wholeTrackobservationDataMax[j].GetSpectralValley()[2] << ',' //55
+				<< wholeTrackobservationDataMin[j].GetSpectralValley()[2] << ',' //56
+				<< wholeTrackobservationDataAverage[j].GetSpectralValley()[3] << ',' //57
+				<< wholeTrackobservationDataStd[j].GetSpectralValley()[3] << ',' //58
+				<< wholeTrackobservationDataMax[j].GetSpectralValley()[3] << ',' //59
+				<< wholeTrackobservationDataMin[j].GetSpectralValley()[3] << ',' //60
+				<< wholeTrackobservationDataAverage[j].GetSpectralValley()[4] << ',' //61
+				<< wholeTrackobservationDataStd[j].GetSpectralValley()[4] << ',' //62
+				<< wholeTrackobservationDataMax[j].GetSpectralValley()[4] << ',' //63
+				<< wholeTrackobservationDataMin[j].GetSpectralValley()[4] << ',' //64
+				<< wholeTrackobservationDataAverage[j].GetSpectralValley()[5] << ',' //65
+				<< wholeTrackobservationDataStd[j].GetSpectralValley()[5] << ',' //66
+				<< wholeTrackobservationDataMax[j].GetSpectralValley()[5] << ',' //67
+				<< wholeTrackobservationDataMin[j].GetSpectralValley()[5] << ',' //68
 				<< wholeTrackobservationDataAverage[j].GetLowEnergy() << ',' //93
 				<< wholeTrackobservationDataAverage[j].GetPeriodicity() << ',' //94
 				<< wholeTrackobservationDataAverage[j].GetEntropyOfEnergy() << ',' //95