view Source/WriteCSV.cpp @ 7:c6f38cba266d

Cleaned up redundant code

/*
  ==============================================================================

    WriteCSV.cpp
    Created: 29 Aug 2014 3:57:27pm
    Author:  david.ronan

  ==============================================================================
*/

#include "WriteCSV.h"
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <time.h>
//#include <windows.h>

WriteCSV::WriteCSV(){};
WriteCSV::~WriteCSV(){};

static int count = 1;

void WriteCSV::Write(std::string filename, FeatureData data)
{
	//Pooled
	std::string pooledfilename = filename + "Pooled" + std::to_string(data.GetPoolingTimeFactor()) + "Sec.csv";
	std::ofstream foutPooled(pooledfilename, std::ios::app|std::ios::out);

	std::vector<ObservationData> observationDataAverage = data.GetPooldedObservationDataAverage();
	std::vector<ObservationData> observationDataStd = data.GetPooldedObservationDataStd();
	std::vector<ObservationData> observationDataMax = data.GetPooldedObservationDataMax();
	std::vector<ObservationData> observationDataMin = data.GetPooldedObservationDataMin();


	std::string label = data.GetLabel();

	if (foutPooled.is_open())
	{
		for(size_t j = 0; j < observationDataAverage.size(); j++)
		{
			foutPooled
				<< observationDataAverage[j].GetRMS() << ','
				<< observationDataStd[j].GetRMS() << ','
				<< observationDataMax[j].GetRMS() << ','
				<< observationDataMin[j].GetRMS() << ','
				<< observationDataAverage[j].GetPeak() << ','
				<< observationDataStd[j].GetPeak() << ','
				<< observationDataMax[j].GetPeak() << ','
				<< observationDataMin[j].GetPeak() << ','
				<< observationDataAverage[j].GetCrestFactor() << ','
				<< observationDataStd[j].GetCrestFactor() << ','
				<< observationDataMax[j].GetCrestFactor() << ','
				<< observationDataMin[j].GetCrestFactor() << ','
				<< observationDataAverage[j].GetZCR() << ','
				<< observationDataStd[j].GetZCR() << ','
				<< observationDataMax[j].GetZCR() << ','
				<< observationDataMin[j].GetZCR() << ','
				<< observationDataAverage[j].GetCentroid() << ','
				<< observationDataStd[j].GetCentroid() << ','
				<< observationDataMax[j].GetCentroid() << ','
				<< observationDataMin[j].GetCentroid() << ','
				<< observationDataAverage[j].GetSpread() << ','
				<< observationDataStd[j].GetSpread() << ','
				<< observationDataMax[j].GetSpread() << ','
				<< observationDataMin[j].GetSpread() << ','
				<< observationDataAverage[j].GetSkewness() << ','
				<< observationDataStd[j].GetSkewness() << ','
				<< observationDataMax[j].GetSkewness() << ','
				<< observationDataMin[j].GetSkewness() << ','
				<< observationDataAverage[j].GetKurtosis() << ','
				<< observationDataStd[j].GetKurtosis() << ','
				<< observationDataMax[j].GetKurtosis() << ','
				<< observationDataMin[j].GetKurtosis() << ','
				<< observationDataAverage[j].GetBrightness() << ','
				<< observationDataStd[j].GetBrightness() << ','
				<< observationDataMax[j].GetBrightness() << ','
				<< observationDataMin[j].GetBrightness() << ','
				<< observationDataAverage[j].GetFlatness() << ','
				<< observationDataStd[j].GetFlatness() << ','
				<< observationDataMax[j].GetFlatness() << ','
				<< observationDataMin[j].GetFlatness() << ','
				<< observationDataAverage[j].GetRollOff85() << ','
				<< observationDataStd[j].GetRollOff85() << ','
				<< observationDataMax[j].GetRollOff85() << ','
				<< observationDataMin[j].GetRollOff85() << ','
				<< observationDataAverage[j].GetRollOff95() << ','
				<< observationDataStd[j].GetRollOff95() << ','
				<< observationDataMax[j].GetRollOff95() << ','
				<< observationDataMin[j].GetRollOff95() << ','
				<< observationDataAverage[j].GetSpectralEntropy() << ','
				<< observationDataStd[j].GetSpectralEntropy() << ','
				<< observationDataMax[j].GetSpectralEntropy() << ','
				<< observationDataMin[j].GetSpectralEntropy() << ','
				<< observationDataAverage[j].GetSpectralCF() << ','
				<< observationDataStd[j].GetSpectralCF() << ','
				<< observationDataMax[j].GetSpectralCF() << ','
				<< observationDataMin[j].GetSpectralCF() << ','
				<< observationDataAverage[j].GetSpectralFlux() << ','
				<< observationDataStd[j].GetSpectralFlux() << ','
				<< observationDataMax[j].GetSpectralFlux() << ','
				<< observationDataMin[j].GetSpectralFlux() << ','
				<< observationDataAverage[j].GetMFCCs()[0] << ','
				<< observationDataStd[j].GetMFCCs()[0] << ','
				<< observationDataMax[j].GetMFCCs()[0] << ','
				<< observationDataMin[j].GetMFCCs()[0] << ','
				<< observationDataAverage[j].GetMFCCs()[1] << ','
				<< observationDataStd[j].GetMFCCs()[1] << ','
				<< observationDataMax[j].GetMFCCs()[1] << ','
				<< observationDataMin[j].GetMFCCs()[1] << ','
				<< observationDataAverage[j].GetMFCCs()[2] << ','
				<< observationDataStd[j].GetMFCCs()[2] << ','
				<< observationDataMax[j].GetMFCCs()[2] << ','
				<< observationDataMin[j].GetMFCCs()[2] << ','
				<< observationDataAverage[j].GetMFCCs()[3] << ','
				<< observationDataStd[j].GetMFCCs()[3] << ','
				<< observationDataMax[j].GetMFCCs()[3] << ','
				<< observationDataMin[j].GetMFCCs()[3] << ','
				<< observationDataAverage[j].GetMFCCs()[4] << ','
				<< observationDataStd[j].GetMFCCs()[4] << ','
				<< observationDataMax[j].GetMFCCs()[4] << ','
				<< observationDataMin[j].GetMFCCs()[4] << ','
				<< observationDataAverage[j].GetMFCCs()[5] << ','
				<< observationDataStd[j].GetMFCCs()[5] << ','
				<< observationDataMax[j].GetMFCCs()[5] << ','
				<< observationDataMin[j].GetMFCCs()[5] << ','
				<< observationDataAverage[j].GetMFCCs()[6] << ','
				<< observationDataStd[j].GetMFCCs()[6] << ','
				<< observationDataMax[j].GetMFCCs()[6] << ','
				<< observationDataMin[j].GetMFCCs()[6] << ','
				<< observationDataAverage[j].GetMFCCs()[7] << ','
				<< observationDataStd[j].GetMFCCs()[7] << ','
				<< observationDataMax[j].GetMFCCs()[7] << ','
				<< observationDataMin[j].GetMFCCs()[7] << ','
				<< observationDataAverage[j].GetMFCCs()[8] << ','
				<< observationDataStd[j].GetMFCCs()[8] << ','
				<< observationDataMax[j].GetMFCCs()[8] << ','
				<< observationDataMin[j].GetMFCCs()[8] << ','
				<< observationDataAverage[j].GetMFCCs()[9] << ','
				<< observationDataStd[j].GetMFCCs()[9] << ','
				<< observationDataMax[j].GetMFCCs()[9] << ','
				<< observationDataMin[j].GetMFCCs()[9] << ','
				<< observationDataAverage[j].GetMFCCs()[10] << ','
				<< observationDataStd[j].GetMFCCs()[10] << ','
				<< observationDataMax[j].GetMFCCs()[10] << ','
				<< observationDataMin[j].GetMFCCs()[10] << ','
				<< observationDataAverage[j].GetMFCCs()[11] << ','
				<< observationDataStd[j].GetMFCCs()[11] << ','
				<< observationDataMax[j].GetMFCCs()[11] << ','
				<< observationDataMin[j].GetMFCCs()[11] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[0] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[0] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[0] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[0] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[1] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[1] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[1] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[1] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[2] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[2] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[2] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[2] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[3] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[3] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[3] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[3] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[4] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[4] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[4] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[4] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[5] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[5] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[5] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[5] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[6] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[6] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[6] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[6] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[7] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[7] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[7] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[7] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[8] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[8] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[8] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[8] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[9] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[9] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[9] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[9] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[10] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[10] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[10] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[10] << ','
				<< observationDataAverage[j].GetDeltaMFCCs()[11] << ','
				<< observationDataStd[j].GetDeltaMFCCs()[11] << ','
				<< observationDataMax[j].GetDeltaMFCCs()[11] << ','
				<< observationDataMin[j].GetDeltaMFCCs()[11] << ','
				<< observationDataAverage[j].GetLowEnergy() << ','
				<< observationDataAverage[j].GetPeriodicity() << ','
				<< observationDataAverage[j].GetEntropyOfEnergy() << ','
				<< label << ',' ;
			foutPooled << "\n";
		}
	}
	else
	{
		std::cout << "ERROR: Can't write to .csv.";
	}

	 foutPooled.close();

	//WholeTrack

	std::string wholetrackfilename = filename + "Whole" + std::to_string(data.GetPoolingTimeFactor()) + "Sec.csv";
	std::ofstream foutWholeTrack(wholetrackfilename, std::ios::app|std::ios::out);

	std::vector<ObservationData> wholeTrackobservationDataAverage = data.GetWholeTrackObservationDataAverage();
	std::vector<ObservationData> wholeTrackobservationDataStd = data.GetWholeTrackObservationDataStd();
	std::vector<ObservationData> wholeTrackobservationDataMax = data.GetWholeTrackObservationDataMax();
	std::vector<ObservationData> wholeTrackobservationDataMin = data.GetWholeTrackObservationDataMin();

	if (foutWholeTrack.is_open())
	{
		for(size_t j = 0; j < wholeTrackobservationDataAverage.size(); j++)
		{
			foutWholeTrack
				<< wholeTrackobservationDataAverage[j].GetRMS() << ','//1
				<< wholeTrackobservationDataStd[j].GetRMS() << ','//2
				<< wholeTrackobservationDataMax[j].GetRMS() << ','//3
				<< wholeTrackobservationDataMin[j].GetRMS() << ','//4
				<< wholeTrackobservationDataAverage[j].GetPeak() << ','//5
				<< wholeTrackobservationDataStd[j].GetPeak() << ','//6
				<< wholeTrackobservationDataMax[j].GetPeak() << ','//7
				<< wholeTrackobservationDataMin[j].GetPeak() << ','//8
				<< wholeTrackobservationDataAverage[j].GetCrestFactor() << ',' //9
				<< wholeTrackobservationDataStd[j].GetCrestFactor() << ',' //10
				<< wholeTrackobservationDataMax[j].GetCrestFactor() << ',' //11
				<< wholeTrackobservationDataMin[j].GetCrestFactor() << ',' //12
				<< wholeTrackobservationDataAverage[j].GetZCR() << ',' //13
				<< wholeTrackobservationDataStd[j].GetZCR() << ',' //14
				<< wholeTrackobservationDataMax[j].GetZCR()<< ',' //15
				<< wholeTrackobservationDataMin[j].GetZCR()<< ',' //16
				<< wholeTrackobservationDataAverage[j].GetCentroid() << ',' //17
				<< wholeTrackobservationDataStd[j].GetCentroid() << ','  //18
				<< wholeTrackobservationDataMax[j].GetCentroid() << ',' //19
				<< wholeTrackobservationDataMin[j].GetCentroid() << ',' //20
				<< wholeTrackobservationDataAverage[j].GetSpread() << ',' //21
				<< wholeTrackobservationDataStd[j].GetSpread() << ',' //22
				<< wholeTrackobservationDataMax[j].GetSpread() << ',' //23
				<< wholeTrackobservationDataMin[j].GetSpread() << ',' //24
				<< wholeTrackobservationDataAverage[j].GetSkewness() << ',' //25
				<< wholeTrackobservationDataStd[j].GetSkewness() << ',' //26
				<< wholeTrackobservationDataMax[j].GetSkewness() << ',' //27
				<< wholeTrackobservationDataMin[j].GetSkewness() << ',' //28
				<< wholeTrackobservationDataAverage[j].GetKurtosis() << ',' //29
				<< wholeTrackobservationDataStd[j].GetKurtosis() << ',' //30
				<< wholeTrackobservationDataMax[j].GetKurtosis() << ',' //31
				<< wholeTrackobservationDataMin[j].GetKurtosis() << ',' //32
				<< wholeTrackobservationDataAverage[j].GetBrightness() << ',' //33
				<< wholeTrackobservationDataStd[j].GetBrightness() << ',' //34
				<< wholeTrackobservationDataMax[j].GetBrightness() << ','  //35
				<< wholeTrackobservationDataMin[j].GetBrightness() << ',' //36
				<< wholeTrackobservationDataAverage[j].GetFlatness() << ',' //37
				<< wholeTrackobservationDataStd[j].GetFlatness() << ',' //38
				<< wholeTrackobservationDataMax[j].GetFlatness() << ','//39
				<< wholeTrackobservationDataMin[j].GetFlatness() << ','//40
				<< wholeTrackobservationDataAverage[j].GetRollOff85() << ',' //41
				<< wholeTrackobservationDataStd[j].GetRollOff85() << ','  //42
				<< wholeTrackobservationDataMax[j].GetRollOff85() << ','  //43
				<< wholeTrackobservationDataMin[j].GetRollOff85() << ','  //44
				<< wholeTrackobservationDataAverage[j].GetRollOff95() << ','  //45
				<< wholeTrackobservationDataStd[j].GetRollOff95() << ','  //46
				<< wholeTrackobservationDataMax[j].GetRollOff95() << ','  //47
				<< wholeTrackobservationDataMin[j].GetRollOff95() << ','  //48
				<< wholeTrackobservationDataAverage[j].GetSpectralEntropy() << ','//49
				<< wholeTrackobservationDataStd[j].GetSpectralEntropy() << ',' //50
				<< wholeTrackobservationDataMax[j].GetSpectralEntropy() << ','//51
				<< wholeTrackobservationDataMin[j].GetSpectralEntropy() << ','//52
				<< wholeTrackobservationDataAverage[j].GetSpectralCF() << ','//53
				<< wholeTrackobservationDataStd[j].GetSpectralCF() << ',' //54
				<< wholeTrackobservationDataMax[j].GetSpectralCF() << ','//55
				<< wholeTrackobservationDataMin[j].GetSpectralCF() << ','//56
				<< wholeTrackobservationDataAverage[j].GetSpectralFlux() << ','//57
				<< wholeTrackobservationDataStd[j].GetSpectralFlux() << ',' //58
				<< wholeTrackobservationDataMax[j].GetSpectralFlux() << ','//59
				<< wholeTrackobservationDataMin[j].GetSpectralFlux() << ','//60
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[0] << ','//61
				<< wholeTrackobservationDataStd[j].GetMFCCs()[0] << ',' //62
				<< wholeTrackobservationDataMax[j].GetMFCCs()[0] << ',' //47
				<< wholeTrackobservationDataMin[j].GetMFCCs()[0] << ',' //48
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[1] << ',' //49
				<< wholeTrackobservationDataStd[j].GetMFCCs()[1] << ',' //50
				<< wholeTrackobservationDataMax[j].GetMFCCs()[1] << ',' //51
				<< wholeTrackobservationDataMin[j].GetMFCCs()[1] << ',' //52
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[2] << ',' //53
				<< wholeTrackobservationDataStd[j].GetMFCCs()[2] << ',' //54
				<< wholeTrackobservationDataMax[j].GetMFCCs()[2] << ',' //55
				<< wholeTrackobservationDataMin[j].GetMFCCs()[2] << ',' //56
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[3] << ',' //57
				<< wholeTrackobservationDataStd[j].GetMFCCs()[3] << ',' //58
				<< wholeTrackobservationDataMax[j].GetMFCCs()[3] << ',' //59
				<< wholeTrackobservationDataMin[j].GetMFCCs()[3] << ',' //60
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[4] << ',' //61
				<< wholeTrackobservationDataStd[j].GetMFCCs()[4] << ',' //62
				<< wholeTrackobservationDataMax[j].GetMFCCs()[4] << ',' //63
				<< wholeTrackobservationDataMin[j].GetMFCCs()[4] << ',' //64
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[5] << ',' //65
				<< wholeTrackobservationDataStd[j].GetMFCCs()[5] << ',' //66
				<< wholeTrackobservationDataMax[j].GetMFCCs()[5] << ',' //67
				<< wholeTrackobservationDataMin[j].GetMFCCs()[5] << ',' //68
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[6] << ',' //69
				<< wholeTrackobservationDataStd[j].GetMFCCs()[6] << ',' //70
				<< wholeTrackobservationDataMax[j].GetMFCCs()[6] << ',' //71
				<< wholeTrackobservationDataMin[j].GetMFCCs()[6] << ',' //72
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[7] << ',' //73
				<< wholeTrackobservationDataStd[j].GetMFCCs()[7] << ',' //74
				<< wholeTrackobservationDataMax[j].GetMFCCs()[7] << ',' //75
				<< wholeTrackobservationDataMin[j].GetMFCCs()[7] << ',' //76
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[8] << ',' //77
				<< wholeTrackobservationDataStd[j].GetMFCCs()[8] << ',' //78
				<< wholeTrackobservationDataMax[j].GetMFCCs()[8] << ',' //79
				<< wholeTrackobservationDataMin[j].GetMFCCs()[8] << ',' //80
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[9] << ',' //81
				<< wholeTrackobservationDataStd[j].GetMFCCs()[9] << ',' //82
				<< wholeTrackobservationDataMax[j].GetMFCCs()[9] << ',' //83
				<< wholeTrackobservationDataMin[j].GetMFCCs()[9] << ',' //84
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[10] << ',' //85
				<< wholeTrackobservationDataStd[j].GetMFCCs()[10] << ',' //86
				<< wholeTrackobservationDataMax[j].GetMFCCs()[10] << ',' //87
				<< wholeTrackobservationDataMin[j].GetMFCCs()[10] << ',' //88
				<< wholeTrackobservationDataAverage[j].GetMFCCs()[11] << ',' //89
				<< wholeTrackobservationDataStd[j].GetMFCCs()[11] << ',' //90
				<< wholeTrackobservationDataMax[j].GetMFCCs()[11] << ',' //91
				<< wholeTrackobservationDataMin[j].GetMFCCs()[11] << ',' //92
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[0] << ','//45
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[0] << ',' //46
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[0] << ',' //47
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[0] << ',' //48
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[1] << ',' //49
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[1] << ',' //50
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[1] << ',' //51
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[1] << ',' //52
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[2] << ',' //53
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[2] << ',' //54
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[2] << ',' //55
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[2] << ',' //56
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[3] << ',' //57
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[3] << ',' //58
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[3] << ',' //59
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[3] << ',' //60
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[4] << ',' //61
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[4] << ',' //62
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[4] << ',' //63
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[4] << ',' //64
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[5] << ',' //65
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[5] << ',' //66
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[5] << ',' //67
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[5] << ',' //68
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[6] << ',' //69
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[6] << ',' //70
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[6] << ',' //71
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[6] << ',' //72
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[7] << ',' //73
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[7] << ',' //74
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[7] << ',' //75
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[7] << ',' //76
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[8] << ',' //77
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[8] << ',' //78
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[8] << ',' //79
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[8] << ',' //80
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[9] << ',' //81
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[9] << ',' //82
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[9] << ',' //83
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[9] << ',' //84
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[10] << ',' //85
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[10] << ',' //86
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[10] << ',' //87
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[10] << ',' //88
				<< wholeTrackobservationDataAverage[j].GetDeltaMFCCs()[11] << ',' //89
				<< wholeTrackobservationDataStd[j].GetDeltaMFCCs()[11] << ',' //90
				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[11] << ',' //91
				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[11] << ',' //92
				<< wholeTrackobservationDataAverage[j].GetLowEnergy() << ',' //93
				<< wholeTrackobservationDataAverage[j].GetPeriodicity() << ',' //94
				<< wholeTrackobservationDataAverage[j].GetEntropyOfEnergy() << ',' //95
				<< label << ',' ;
			foutWholeTrack << "\n";
		}
	}
	else
	{
		std::cout << "ERROR: Can't write to .csv.";
	}

	 foutWholeTrack.close();

	 std::string dave = "Files written: " + std::to_string(count) + "  Obs Data Size:" + std::to_string(wholeTrackobservationDataAverage.size())+  "\n";
//	 OutputDebugString(dave.c_str());
	 count++;
};

// Get current date/time, format is YYYY-MM-DD.HH:mm:ss
const std::string WriteCSV::currentDateTime()
{
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%Y-%m-%d.%H-%M-%S", &tstruct);

    return buf;
}