//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Tue Aug 19 13:13:21 PDT 2014
// Last Modified: Tue Sep 23 14:20:21 PDT 2014 (reverse part order, add quartls)
// Filename:      ...sig/examples/all/beat.cpp
// Web Address:   http://sig.sapp.org/examples/museinfo/humdrum/beat.cpp
// Syntax:        C++; museinfo
//
// Description:   Calculate the average pitch for a single staff or all staves.
//                with a selectable analysis window size.
//

#include "humdrum.h"
#include <string.h>
#include <ctype.h>
#include <string>


class Data {
	public:
		int startindex;
		int endindex;
		vector<int>    minpitch;
		vector<int>    maxpitch;
		vector<double> average;
		vector<double> q25;
		vector<double> q75;
		vector<double> sd;
		vector<int>    attacks;

		void clear(int voicecount);
};


void Data::clear(int voicecount) {
	startindex = -1;
	endindex = -1;

	minpitch.resize(voicecount);
	std::fill(minpitch.begin(), minpitch.end(), 1000);
	maxpitch.resize(voicecount);
	std::fill(maxpitch.begin(), maxpitch.end(), -1000);
	average.resize(voicecount);
	std::fill(average.begin(), average.end(), 0.0);
	q25.resize(voicecount);
	std::fill(q25.begin(), q25.end(), 0.0);
	q75.resize(voicecount);
	std::fill(q75.begin(), q75.end(), 0.0);
	sd.resize(voicecount);
	std::fill(sd.begin(), sd.end(), 0.0);
	attacks.resize(voicecount);
	std::fill(attacks.begin(), attacks.end(), 0.0);
}


// function declarations
void    checkOptions       (Options& opts, int argc, char* argv[]);
void    example            (void);
void    usage              (const char* command);
void    processFile        (HumdrumFile& infile);
void    generateAnalysis   (HumdrumFile& infile, vector<vector<Data> >& data,
                            int windowsize, int windowindex,
                            vector<vector<vector<double> > >& histograms,
                            vector<vector<int> >& attacks, double hop);
void    printJsonData      (HumdrumFile& infile, vector<vector<Data> >& data,
                            vector<int> window);
void    generatePitchHistogram(HumdrumFile& infile,
                            vector<vector<vector<double> > >& hophistogram,
                            vector<vector<int> >& attacks, double hopsize);
void    addToHistogram     (vector<vector<vector<double> > >& hophistogram,
                            int timebin, double amount, int track, int base7);
void    addToHistogram2    (vector<vector<double> >& notehist,
                            vector<int>& attacksum, int index,
                            vector<vector<vector<double> > >& histograms,
                            vector<vector<int> >& attacks);
void    subtractFromHistogram2(vector<vector<double> >& notehist,
                            vector<int>& attacksum, int index,
                            vector<vector<vector<double> > >& histograms,
                            vector<vector<int> >& attacks);
void    doAnalysis         (Data& data, vector<vector<double> >& notehist,
                            vector<int>& attacksum);
double  getWeightedAverage (vector<double>& notes);
double  getStandardDeviation(double weightedaverage, vector<double>& notes);
void    printDataContentJson(vector<vector<Data> >& data);
void    printPartNames      (HumdrumFile& infile);
void    printVoiceData      (vector<vector<Data> >& data, int index, int vcount);
void    printPitchMean      (vector<vector<Data> >& data, int index, int voice);
void    printPitchMax       (vector<vector<Data> >& data, int index, int voice);
void    printPitchMin       (vector<vector<Data> >& data, int index, int voice);
void    printPitchSD        (vector<vector<Data> >& data, int index, int voice);
void    printPitchAttacks   (vector<vector<Data> >& data, int index, int voice);
void    printStartFrame     (vector<vector<Data> >& data, int index);
void    printEndFrame       (vector<vector<Data> >& data, int index);
void    printPitch25q       (vector<vector<Data> >& data, int index, int voice);
void    printPitch75q       (vector<vector<Data> >& data, int index, int voice);
double  get25thQuartile     (vector<double>& notes);
double  get75thQuartile     (vector<double>& notes);
double  getMinPitch         (vector<double>& notes);
double  getMaxPitch         (vector<double>& notes);
void    printVoicePartData  (vector<vector<Data> >& data, int index, int vcount, int v,
				int comma);

// global variables
Options   options;         // database for command-line arguments
int       jsonQ = 0;       // output analysis JSON data
vector<int> Window;         // used with -w option
double    Hopsize = 2.0;   // used with -h option
vector<int> Minpitch;
vector<int> Maxpitch;
string     optionfilename = "";


///////////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[]) {
	checkOptions(options, argc, argv);
	HumdrumFileSet infiles;
	infiles.read(options);

	for (int i=0; i<infiles.getCount(); i++) {
		if (optionfilename.size() > 0) {
			infiles[i].setFilename(optionfilename.c_str());
		}
		processFile(infiles[i]);
	}

	return 0;
}


///////////////////////////////////////////////////////////////////////////


//////////////////////////////
//
// processFile -- create analysis for one data file.
//

void processFile(HumdrumFile& infile) {
	infile.analyzeRhythm("4");

	vector<int> ktracks;
	infile.getTracksByExInterp(ktracks, "**kern");

	vector<vector<vector<double> > > hophistogram;
	vector<vector<int> > attacks;
	// dimension 1: time in score
	// dimension 2: voice in score (0th index is for all parts)
	// dimension 3: diatonic pitch class
	generatePitchHistogram(infile, hophistogram, attacks, Hopsize);

	vector<vector<Data> > data;
	// dimension 1: time in score
	// dimension 2: window size
	data.resize(attacks.size());
	int i, j;
	for (i=0; i<(int)data.size(); i++) {
		data[i].resize(Window.size());
		for (j=0; j<(int)data[i].size(); j++) {
			data[i][j].clear(ktracks.size()+1);
		}
	}

	for (int i=0; i<(int)Window.size(); i++) {
		generateAnalysis(infile, data, Window[i], i, hophistogram, attacks,
				Hopsize);
	}

	if (jsonQ) {
		printJsonData(infile, data, Window);
	}
}



//////////////////////////////
//
// generatePitchHistogram --
//
// dimension 1: time in score
// dimension 2: voice in score (0th index is for all parts)
// dimension 3: diatonic pitch class
//

void generatePitchHistogram(HumdrumFile& infile,
		vector<vector<vector<double> > >& hophistogram,
		vector<vector<int> >& attacks,
		double hopsize) {
	double beatcount = infile[infile.getNumLines()-1].getAbsBeat();
	int bincount = beatcount / hopsize + 1;


	hophistogram.resize(bincount);
	attacks.resize(bincount);

	int trackcount = infile.getMaxTracks() + 1;
	int i, j;

	for (i=0; i<bincount; i++) {

		hophistogram[i].resize(trackcount);
		for (j=0; j<trackcount; j++) {
			hophistogram[i][j].resize(70);
			std::fill(hophistogram[i][j].begin(), hophistogram[i][j].end(), 0.0);
		}

		attacks[i].resize(trackcount);
		std::fill(attacks[i].begin(), attacks[i].end(), 0);
	}

	Minpitch.resize(trackcount);
	Maxpitch.resize(trackcount);
	std::fill(Minpitch.begin(), Minpitch.end(), 70);
	std::fill(Maxpitch.begin, Maxpitch.end(), 0);

	int track;
	int tcount;
	int ii;
	int base7;
	int jj;
	int k;
	double dur;
	char buffer[1024] = {0};
	double startbin;
	double tdur;
	int attack = 0;
	double sdiff;
	int curbin;

	for (i=0; i<infile.getNumLines(); i++) {
		if (!infile[i].isData()) {
			continue;
		}
		if (infile[i].getDuration() == 0.0) {
			// ignore grace notes
			continue;
		}

		dur      = infile[i].getDuration();
		startbin = infile[i].getAbsBeat() / hopsize;

		for (j=0; j<infile[i].getFieldCount(); j++) {
			if (!infile[i].isExInterp(j, "**kern")) {
				continue;
			}
			if (strchr(infile[i][j], 'r') != NULL) {
				// ignore rests;
				continue;
			}
			track = infile[i].getPrimaryTrack(j);
			ii = i;
			jj = j;
			attack = 1;
			if (strcmp(infile[i][j], ".") == 0) {
				ii = infile[i].getDotLine(j);
				jj = infile[i].getDotSpine(j);
				attack = 0;
			}
			if (strcmp(infile[ii][jj], ".") == 0) {
				continue;
			}
			if (strchr(infile[ii][jj], 'r') != NULL) {
				continue;
			}
			tcount = infile[ii].getTokenCount(jj);
			for (k=0; k<tcount; k++) {
				infile[ii].getToken(buffer, jj, k);
				if (strchr(buffer, 'r') != NULL) {
					continue;
				}
				if (strcmp(buffer, ".") == 0) {
					continue;
				}
				if (strchr(buffer, '_') != NULL) {
					attack = 0;
				}
				if (strchr(buffer, ']') != NULL) {
					attack = 0;
				}
				if (attack) {
					attacks[int(startbin)][track]++;
					attacks[int(startbin)][0]++;
				}
				base7 = Convert::kernToDiatonicPitch(buffer);
				if (base7 < Minpitch[track]) {
					Minpitch[track] = base7;
				}
				if (base7 > Maxpitch[track]) {
					Maxpitch[track] = base7;
				}
				if (base7 < Minpitch[0]) {
					Minpitch[0] = base7;
				}
				if (base7 > Maxpitch[0]) {
					Maxpitch[0] = base7;
				}

				// split note into hop histograms:
				tdur = dur;
				sdiff = (1.0 - (startbin - int(startbin))) * hopsize;
				if (tdur < sdiff) {
					sdiff = tdur;
				}
				tdur -= sdiff;
				curbin = (int)startbin;
				addToHistogram(hophistogram, curbin++, sdiff, track, base7);
				while (tdur > 0.0) {
					sdiff = 1.0 * hopsize;
					if (tdur < sdiff) {
						sdiff = tdur;
					}
					addToHistogram(hophistogram, curbin++, sdiff, track, base7);
					tdur -= sdiff;
				}
			}
		}
	}
}



//////////////////////////////
//
// addToHistogram --
//

void addToHistogram(vector<vector<vector<double> > >& hophistogram, int timebin,
		double amount, int track, int base7) {

	hophistogram[timebin][track][base7] += amount;
	hophistogram[timebin][0][base7] += amount;

}



//////////////////////////////
//
// generateAnalysis --
//

void generateAnalysis(HumdrumFile& infile, vector<vector<Data> >& data, int windowsize,
		int windowindex, vector<vector<vector<double> > >& histograms,
		vector<vector<int> >& attacks, double hop) {

	int trackcount = infile.getMaxTracks() + 1;
	vector<int> kerntracks;
	infile.getTracksByExInterp(kerntracks, "**kern");
	int ktracks = (int)kerntracks.size() + 1; // +1 for full score.
	vector<int> rtrack(trackcount);
	rtrack.setAll(-1);
	int i, j;
	for (i=0; i<(int)kerntracks.size(); i++) {
		rtrack[kerntracks[i]] = i+1;
	}

	vector<vector<double> > notehist;
	notehist.resize(ktracks);
	for (i=0; i<(int)notehist.size(); i++) {
		notehist[i].resize(70);
		std::fill(notehist[i].begin(), notehist[i].end(), 0.0);
	}

	vector<int> attacksum;
	attacksum.resize(ktracks);
	attacksum.setAll(0);

	int windowstart = 0;
	int windowend = windowsize-1;
	int newstart = 0;
	int newend = 0;

	for (i=windowstart; i<=windowend; i++) {
		addToHistogram2(notehist, attacksum, i, histograms, attacks);
	}

	//int shiftval;
	for (i=0; i<(int)data.size(); i++) {
		newstart = i - windowsize/2;
		if (newstart < 0) {
			// shiftval = -newstart;
			newstart = 0;
		}
		newend = newstart + windowsize - 1;
		if (newend >= (int)data.size()) {
			newstart = windowstart;
			newend   = windowend;
		}
		if (newstart > windowstart) {
			for (j=windowstart; j<newstart; j++) {
				subtractFromHistogram2(notehist, attacksum, j, histograms, attacks);
			}
			windowstart = newstart;
		}
		if (newend > windowend) {
			for (j=windowend+1; j<=newend; j++) {
				addToHistogram2(notehist, attacksum, j, histograms, attacks);
			}
			windowend = newend;
		}

		data[i][windowindex].startindex = windowstart;
		data[i][windowindex].endindex = windowend;
		doAnalysis(data[i][windowindex], notehist, attacksum);
	}
}



//////////////////////////////
//
// doAnalysis --
//

void doAnalysis(Data& data, vector<vector<double> >& notehist, vector<int>& attacksum) {
	data.average.resize(attacksum.size());
	data.q25.resize(attacksum.size());
	data.q75.resize(attacksum.size());
	data.sd.resize(attacksum.size());
	data.attacks.resize(attacksum.size());

	for (int v=0; v<(int)attacksum.size(); v++) {
		data.attacks[v]  = attacksum[v];
		data.average[v]  = getWeightedAverage(notehist[v]);
		data.average[v]  = getWeightedAverage(notehist[v]);
		data.minpitch[v] = getMinPitch(notehist[v]);
		data.maxpitch[v] = getMaxPitch(notehist[v]);
		data.q25[v]      = get25thQuartile(notehist[v]);
		data.q75[v]      = get75thQuartile(notehist[v]);
		data.sd[v]       = getStandardDeviation(data.average[v], notehist[v]);
	}
}



//////////////////////////////
//
// getStandardDeviation --
//

double getStandardDeviation(double weightedaverage, vector<double>& notes) {
	double topsum = 0;
	double botsum = 0;
	double temp;
	int i;
	for (i=0; i<(int)notes.size(); i++) {
		if (notes[i] == 0.0) {
			continue;
		}
		temp = i - weightedaverage;
		topsum += notes[i] * temp * temp;
		botsum += notes[i];
	}
	if (botsum == 0.0) {
		return 0;
	}
	return sqrt(topsum/botsum);
}



//////////////////////////////
//
// getWeightedAverage --
//

double getWeightedAverage(vector<double>& notes) {
	double topsum = 0.0;
	double botsum = 0.0;
	for (int i=0; i<(int)notes.size(); i++) {
		if (notes[i] <= 0.0) {
			continue;
		}
		topsum += notes[i] * i;
		botsum += notes[i];
	}

	if (botsum <= 0.0) {
		return 0;
	}
	return topsum / botsum;
}



//////////////////////////////
//
// getMinPitch --
//

double getMinPitch(vector<double>& notes) {
	for (int i=0; i<(int)notes.size(); i++) {
		if (fabs(notes[i]) > 100.0) {
			continue;
		}
		if (notes[i] > 0.0) {
			return i;
		}
	}
	return 0;
}



//////////////////////////////
//
// getMaxPitch --
//

double getMaxPitch(vector<double>& notes) {
	for (int i=(int)notes.size()-1; i>=0; i--) {
		if (fabs(notes[i]) > 100.0) {
			continue;
		}
		if (notes[i] > 0.0) {
			return i;
		}
	}
	return 0;
}



//////////////////////////////
//
// get25thQuartile --
//

double get25thQuartile(vector<double>& notes) {
	double sum = 0.0;
	int i;
	for (i=0; i<(int)notes.size(); i++) {
		sum += notes[i];
	}

	double p;
	double tsum = 0.0;
	for (i=0; i<(int)notes.size(); i++) {
		if (notes[i] == 0.0) {
			continue;
		}
		tsum += notes[i];
		p = tsum / sum;
		if (p >= 0.245) {
			return (double)i;
		}
	}
	return 0.0;
}



//////////////////////////////
//
// get75thQuartile --
//

double get75thQuartile(vector<double>& notes) {
	double sum = 0.0;
	int i;
	for (i=0; i<(int)notes.size(); i++) {
		sum += notes[i];
	}

	double p;
	double tsum = 0.0;
	for (i=(int)notes.size()-1; i>=0; i--) {
		if (notes[i] == 0.0) {
			continue;
		}
		tsum += notes[i];
		p = tsum / sum;
		if (p >= 0.245) {
			return (double)i;
		}
	}
	return 0.0;
}



//////////////////////////////
//
// addToHistogram2 --
//

void addToHistogram2(vector<vector<double> >& notehist, vector<int>& attacksum, int index,
		vector<vector<vector<double> > >& histograms, vector<vector<int> >& attacks) {
	int j, k;

	for (j=0; j<(int)histograms[index].size(); j++) {
		attacksum[j] += attacks[index][j];
		for (k=0; k<(int)histograms[index][j].size(); k++) {
			notehist[j][k] += histograms[index][j][k];
		}
	}
}



//////////////////////////////
//
// subtractFromHistogram2 --
//

void subtractFromHistogram2(vector<vector<double> >& notehist, vector<int>& attacksum,
		int index, vector<vector<vector<double> > >& histograms, vector<vector<int> >& attacks) {
	int j, k;

	for (j=0; j<(int)histograms[index].size(); j++) {
		attacksum[j] -= attacks[index][j];
		for (k=0; k<(int)histograms[index][j].size(); k++) {
			notehist[j][k] -= histograms[index][j][k];
		}
	}
}



//////////////////////////////
//
// printJsonData --
//

void printJsonData(HumdrumFile& infile, vector<vector<Data> >& data,
	vector<int> window) {
	cout << "{" << endl;
	cout << "\t\"analysistype\"\t:\t\"avgpitch\",\n";
	cout << "\t\"version\"\t:\t2.0,\n";
	cout << "\t\"analysisdate\"\t:\t\"";

	struct tm *current;
	time_t now;
	time(&now);
	current = localtime(&now);
	int year = current->tm_year + 1900;
	int month = current->tm_mon + 1;
	int day = current->tm_mday;
	cout << year;
	if (month < 10) {
		cout << "0";
	}
	cout << month;
	if (day < 10) {
		cout << "0";
	}
	cout << day;
	cout << "\",\n";

	cout << "\t\"filename\"\t:\t\"" << infile.getFilename() << "\",\n";
	cout << "\t\"scorelength\"\t:\t" << infile[infile.getNumLines()-1].getAbsBeat() << ",\n";
	cout << "\t\"hopsize\"\t:\t" << Hopsize << ",\n";
	cout << "\t\"framecount\"\t:\t" << data.size() << ",\n";

	cout << "\t\"windowsizes\"\t:\t[";
	for (int i=0; i<(int)window.size(); i++) {
		cout << window[i];
		if (i < (int)window.size()-1) {
			cout << ", ";
		}
	}
	cout << "],\n";

	// cout << "\t\"parts\"\t\t:\t" << (int)data[0][0].attacks.size() << ",\n";
	cout << "\t\"partnames\"\t:\t[";
	printPartNames(infile);
	cout << "\"full score\"";
	cout << "],\n";

	cout << "\t\"rangemin\"\t:\t[";
	for (int i=(int)Minpitch.size()-1; i>0; i--) {
		cout << Minpitch[i] << ", ";
	}
	cout << Minpitch[0];
	cout << "],\n";

	cout << "\t\"rangemax\"\t:\t[";
	for (int i=(int)Maxpitch.size()-1; i>0; i--) {
		cout << Maxpitch[i] << ", ";
	}
	cout << Maxpitch[0];
	cout << "],\n";

	cout << "\t\"framedata\"\t:\n";
	cout << "\t\t[\n";
	printDataContentJson(data);
	cout << "\t\t]\n";
	cout << "}\n";  // end of data
}



//////////////////////////////
//
// printPartNames --
//

void printPartNames(HumdrumFile& infile) {
	int i, j;
	vector<string> names;
	vector<int> ktracks;
	infile.getTracksByExInterp(ktracks, "**kern");
	names.resize(ktracks.size());
	char buffer[1024] = {0};
	for (i=0; i<(int)names.size(); i++) {
		sprintf(buffer, "part %ld", (int)names.size() - i);
		names[i] = buffer;
	}
	vector<int> rkern;
	rkern.resize(infile.getMaxTracks()+1);
	rkern.setAll(-1);
	for (i=0; i<(int)ktracks.size(); i++) {
		rkern[ktracks[i]] = i;
	}
	int track;


	for (i=0; i<infile.getNumLines(); i++) {
		if (infile[i].isData()) {
			break;
		}
		if (!infile[i].isInterpretation()) {
			continue;
		}
		for (j=0; j<infile[i].getFieldCount(); j++) {
			if (!infile[i].isExInterp(j, "**kern")) {
				continue;
			}
			if (strncmp(infile[i][j], "*I\"", 3) == 0) {
				track = infile[i].getPrimaryTrack(j);
				names[rkern[track]] = &(infile[i][j][3]);
			}
		}
	}

	for (i=(int)names.size()-1; i>=0; i--) {
		cout << "\"" << names[i] << "\", ";
	}
}



//////////////////////////////
//
// printDataContentJson --
//

void printDataContentJson(vector<vector<Data> >& data) {
	int i;
	int frameindex = 0;

	for (i=0; i<(int)data.size(); i++) {
		cout << "\t\t{\n";
		cout << "\t\t\t\"frameindex\"\t:\t" << frameindex++ << ",\n";
		cout << "\t\t\t\"partdata\"\t:\n";
		cout << "\t\t\t\t[\n";
		printVoiceData(data, i, (int)data[0][0].attacks.size());
		cout << "\t\t\t\t]\n";
		cout << "\t\t}";
		if (i < (int)data.size() - 1)  {
			cout << ",";
		}
		cout << "\n";
	}
}



//////////////////////////////
//
// printVoiceData --  For a particular frame, print the voices from
//    highest part to lowest, then for the full score.
//

void printVoiceData(vector<vector<Data> >& data, int index, int vcount) {
	int v;
	for (v=vcount-1; v>0; v--) {
		printVoicePartData(data, index, vcount, v, 1);
	}
	printVoicePartData(data, index, vcount, 0, 0);
}



//////////////////////////////
//
// printVoicePartData --  For a particular frame, print the voices from
//    highest part to lowest, then for the full score.
//

void printVoicePartData(vector<vector<Data> >& data, int index, int vcount, int v,
		int comma) {
	cout << "\t\t\t\t{\n";
	cout << "\t\t\t\t\t\"partindex\"\t:\t" << v << ",\n";

	cout << "\t\t\t\t\t\"startframe\"\t:\t[";
	printStartFrame(data, index);
	cout << "],\n";

	cout << "\t\t\t\t\t\"endframe\"\t:\t[";
	printEndFrame(data, index);
	cout << "],\n";

	cout << "\t\t\t\t\t\"pitchmin\"\t:\t[";
	printPitchMin(data, index, v);
	cout << "],\n";

	cout << "\t\t\t\t\t\"pitchmax\"\t:\t[";
	printPitchMax(data, index, v);
	cout << "],\n";

	cout << "\t\t\t\t\t\"pitch25q\"\t:\t[";
	printPitch25q(data, index, v);
	cout << "],\n";

	cout << "\t\t\t\t\t\"pitch75q\"\t:\t[";
	printPitch75q(data, index, v);
	cout << "],\n";

	cout << "\t\t\t\t\t\"pitchmean\"\t:\t[";
	printPitchMean(data, index, v);
	cout << "],\n";

	cout << "\t\t\t\t\t\"pitchsd\"\t:\t[";
	printPitchSD(data, index, v);
	cout << "],\n";

	cout << "\t\t\t\t\t\"attacks\"\t:\t[";
	printPitchAttacks(data, index, v);
	cout << "]\n";

	cout << "\t\t\t\t}";
	if (comma) {
		cout << ",";
	}
	cout << "\n";
}



//////////////////////////////
//
// printStartFrame --
//

void printStartFrame(vector<vector<Data> >& data, int index) {
	int wcount = (int)data[index].size();
	for (int w=0; w<wcount; w++) {
		cout << data[index][w].startindex;
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printEndFrame --
//

void printEndFrame(vector<vector<Data> >& data, int index) {
	int wcount = (int)data[index].size();
	for (int w=0; w<wcount; w++) {
		cout << data[index][w].endindex;
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitchMean --
//

void printPitchMean(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	for (w=0; w<wcount; w++) {
		cout << int(data[index][w].average[voice] * 10.0 + 0.5) / 10.0;
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitchMin --
//

void printPitchMin(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	for (w=0; w<wcount; w++) {
		cout << data[index][w].minpitch[voice];
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitchMax --
//

void printPitchMax(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	for (w=0; w<wcount; w++) {
		cout << data[index][w].maxpitch[voice];
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitch25q --
//

void printPitch25q(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	for (w=0; w<wcount; w++) {
		cout << data[index][w].q25[voice];
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitch75q --
//

void printPitch75q(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	for (w=0; w<wcount; w++) {
		cout << data[index][w].q75[voice];
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitchSD --
//

void printPitchSD(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	double value;

	for (w=0; w<wcount; w++) {
		value = data[index][w].sd[voice];
		if (!(value > 0.0)) {
			value = 0.0;
		}
		cout << int(value * 100.0 + 0.05) / 100.0;
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// printPitchAttacks --
//

void printPitchAttacks(vector<vector<Data> >& data, int index, int voice) {
	int wcount = (int)data[index].size();
	int w;
	for (w=0; w<wcount; w++) {
		cout << data[index][w].attacks[voice];
		if (w < wcount - 1) {
			cout << ", ";
		}
	}
}



//////////////////////////////
//
// checkOptions -- validate and process command-line options.
//

void checkOptions(Options& opts, int argc, char* argv[]) {
	opts.define("w|window=s:10.0", "Analysis window size(s)");
	opts.define("j|json=b", "Output analysis in JSON format");
	opts.define("f|filename=s:", "Filename in cases of standard input");

	opts.define("debug=b");      // determine bad input line num
	opts.define("author=b");     // author of program
	opts.define("version=b");    // compilation info
	opts.define("example=b");    // example usages
	opts.define("h|help=b");     // short description
	opts.process(argc, argv);

	// handle basic options:
	if (opts.getBoolean("author")) {
		cout << "Written by Craig Stuart Sapp, "
			  << "craig@ccrma.stanford.edu, August 2014" << endl;
		exit(0);
	} else if (opts.getBoolean("version")) {
		cout << argv[0] << ", version: 19 August 2014" << endl;
		cout << "compiled: " << __DATE__ << endl;
		cout << MUSEINFO_VERSION << endl;
		exit(0);
	} else if (opts.getBoolean("help")) {
		usage(opts.getCommand().c_str());
		exit(0);
	} else if (opts.getBoolean("example")) {
		example();
		exit(0);
	}

	PerlRegularExpression pre;
	vector<string> numbers;
	pre.getTokens(numbers, "[^\\d.]+", opts.getString("window").c_str());
	Window.resize(numbers.size());
	for (int i=0; i<(int)numbers.size(); i++) {
		Window[i] = int(stod(numbers[i].getBase()) + 0.5);
	}
	jsonQ = opts.getBoolean("json");
	optionfilename = opts.getString("filename");
}



//////////////////////////////
//
// example -- example usage of the quality program
//

void example(void) {
	cout <<
	"                                                                         \n"
	<< endl;
}



//////////////////////////////
//
// usage -- gives the usage statement for the meter program
//

void usage(const char* command) {
	cout <<
	"                                                                         \n"
	<< endl;
}



// md5sum: e7a5037bc385e67c765fb76ee852cf7e avgpitch.cpp [20160305]