void printReferenceRecord(ostream& out, HumdrumFile& infile, int line) {
int& i = line;
PerlRegularExpression pre;
if (!pre.search(infile[line][0], "^!!!([^:]+):(.*)$", "")) {
out << "<tr valign=baseline><td colspan=" << infile.getMaxTracks() << ">";
out << "<font color=green>" << infile[i] << "</font></td></tr>";
return;
}
Array<char> description;
char buffer[128] = {0};
infile[line].getBibliographicMeaning(description, pre.getSubmatch(1));
PerlRegularExpression pre2;
pre2.sar(description, "\"", "", "g");
out << "<tr valign=baseline><td colspan=" << infile.getMaxTracks() << ">";
out << "<font color=green>";
out << "<span title=\"";
out << infile[line].getBibKey(buffer);
out << ": ";
out << description;
out << "\">";
out << "!!!";
out << pre.getSubmatch(1);
out << ":";
out << pre.getSubmatch(2);
out << "</span>";
out << "</font></td></tr>";
}
void getPartNames(HumdrumFile& infile, Array<Array<char> >& PartNames) {
int i, j;
PartNames.setSize(infile.getMaxTracks()+1); // 0 = unused
for (i=0; i<PartNames.getSize(); i++) {
PartNames[i].setSize(1);
PartNames[i][0]= '\0';
}
int abbreviationQ = 0;
Array<int> ignore;
ignore.setSize(infile.getMaxTracks()+1);
ignore.setAll(0);
PerlRegularExpression pre;
int track;
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].isData()) {
// stop looking when the first data line is found
break;
}
if (!infile[i].isInterpretation()) {
continue;
}
for (j=0; j<infile[i].getFieldCount(); j++) {
if (strcmp(infile[i][j], "*^") == 0) {
// don't search for names after spine splits (there might
// be two names, and one of them will be ignored).
ignore[infile[i].getPrimaryTrack(j)] = 1;
}
if (ignore[infile[i].getPrimaryTrack(j)]) {
continue;
}
if (!abbreviationQ) {
if (pre.search(infile[i][j], "^\\*I\"\\s*(.*)\\s*$", "")) {
track = infile[i].getPrimaryTrack(j);
PartNames[track].setSize(strlen(pre.getSubmatch(1))+1);
strcpy(PartNames[track].getBase(), pre.getSubmatch());
}
} else {
if (pre.search(infile[i][j], "^\\*I\'\\s*(.*)\\s*$", "")) {
track = infile[i].getPrimaryTrack(j);
PartNames[track].setSize(strlen(pre.getSubmatch(1))+1);
strcpy(PartNames[track].getBase(), pre.getSubmatch());
}
}
}
}
// if no part name, set to "part name" (for debugging purposes):
//for (i=1; i<=infile.getMaxTracks(); i++) {
// if (strcmp(PartNames[i].getBase(), "") == 0) {
// PartNames[i].setSize(strlen("part name")+1);
// strcpy(PartNames[i].getBase(), "part name");
// }
// }
}
void getSubspines(Array<int>& subtracks, HumdrumFile& infile,
Array<int>& kerntracks) {
int i;
int j;
int track;
int maxtracks = infile.getMaxTracks();
Array<int> maxvals(maxtracks+1);
maxvals.setAll(0);
Array<int> linevals(maxtracks+1);
for (i=0; i<infile.getNumLines(); i++) {
if (!infile[i].hasSpines()) {
continue;
}
linevals.setAll(0);
for (j=0; j<infile[i].getFieldCount(); j++) {
track = infile[i].getPrimaryTrack(j);
linevals[track]++;
}
for (j=0; j<linevals.getSize(); j++) {
if (linevals[j] > maxvals[j]) {
maxvals[j] = linevals[j];
}
}
}
subtracks.setSize(kerntracks.getSize());
subtracks.setAll(0);
for (i=0; i<kerntracks.getSize(); i++) {
subtracks[i] = maxvals[kerntracks[i]];
}
}
void createIndex(HumdrumFile& hfile, const char* filename) {
int i;
int maxtracks = hfile.getMaxTracks();
if (polyQ) {
for (i=1; i<=maxtracks; i++) {
if (strcmp("**kern", hfile.getTrackExInterp(i)) != 0) {
continue;
}
if (istnQ) {
cout << getIstn(filename);
} else {
cout << filename;
}
cout << "::" << i;
if (strcmp("**kern", hfile.getTrackExInterp(i)) == 0) {
createIndexEnding(hfile, i);
cout << "\n";
}
}
} else {
if (istnQ) {
cout << getIstn(filename);
} else {
cout << filename;
}
for (i=1; i<=maxtracks; i++) {
if (strcmp("**kern", hfile.getTrackExInterp(i)) == 0) {
createIndexEnding(hfile, i);
cout << "\n";
break;
}
}
}
}
void getMaxLayers(Array<int>& maxlayer, Array<Array<int> >& voice,
HumdrumFile& infile) {
int track;
maxlayer.setSize(infile.getMaxTracks() + 1);
maxlayer.setAll(0);
int i, j;
for (i=0; i<infile.getNumLines(); i++) {
if (!infile[i].isData()) {
continue;
}
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
if (strcmp(infile[i][j], ".") == 0) {
continue;
}
if (strchr(infile[i][j], 'r') != NULL) {
continue;
}
track = infile[i].getPrimaryTrack(j);
if (voice[i][j] + 1 > maxlayer[track]) {
maxlayer[track] = voice[i][j] + 1;
}
}
}
}
int getIdTags(Array<Array<char> >& idtags, HumdrumFile& infile) {
int i, j;
idtags.setSize(infile.getMaxTracks());
for (i=0; i<idtags.getSize(); i++) {
idtags[i].setSize(128);
idtags[i][0] = '\0';
}
int foundids = 0;
char tag[128] = {0};
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].getType() != E_humrec_data_comment) {
continue;
}
for (j=0; j<infile[i].getFieldCount(); j++) {
if (strncmp(infile[i][j], "!ID=", 4) == 0) {
strcpy(tag, &(infile[i][j][4]));
if (strlen(tag)) {
foundids++;
strcpy(idtags[infile[i].getPrimaryTrack(j)-1].getBase(), tag);
}
}
}
}
return foundids;
}
void getMaxLayers(vector<int>& maxlayer, vector<vector<int> >& voice,
HumdrumFile& infile) {
int track;
maxlayer.resize(infile.getMaxTracks() + 1);
std::fill(maxlayer.begin(), maxlayer.end(), 0);
int i, j;
for (i=0; i<infile.getNumLines(); i++) {
if (!infile[i].isData()) {
continue;
}
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
if (strcmp(infile[i][j], ".") == 0) {
continue;
}
if (strchr(infile[i][j], 'r') != NULL) {
continue;
}
track = infile[i].getPrimaryTrack(j);
if (voice[i][j] + 1 > maxlayer[track]) {
maxlayer[track] = voice[i][j] + 1;
}
}
}
}
void getKernTracks(Array<int>& tracks, HumdrumFile& infile) {
tracks.setSize(infile.getMaxTracks());
tracks.setSize(0);
int i;
for (i=1; i<=infile.getMaxTracks(); i++) {
if (infile.getTrackExInterp(i) == "**kern") {
tracks.append(i);
}
}
if (debugQ) {
cerr << "\t**kern tracks:\n";
for (i=0; i<tracks.getSize(); i++) {
cerr << "\t" << tracks[i] << endl;
}
}
}
int getVoiceCount(HumdrumFile& infile, int line) {
int i, j, k;
int ii, jj;
int count = 0;
int track;
int acount;
Array<int> tracks(infile.getMaxTracks()+1);
Array<Array<char> > tokens;
tracks.setAll(0);
tracks.allowGrowth(0);
for (j=0; j<infile[line].getFieldCount(); j++) {
if (!infile[line].isExInterp(j, "**kern")) {
continue;
}
ii = line;
jj = j;
if (attackQ && (strcmp(infile[line][j], ".") == 0)) {
continue;
}
if (infile[line].isNullToken(j)) {
ii = infile[line].getDotLine(j);
if (ii < 0) { continue; } // . at start of data spine
jj = infile[line].getDotSpine(j);
if (jj < 0) { continue; } // . at start of data spine
}
if (strchr(infile[ii][jj], 'r') != NULL) {
continue;
}
if (attackQ) {
infile[ii].getTokens(tokens, jj);
acount = 0;
for (k=0; k<tokens.getSize(); k++) {
if (isAttack(tokens[k].getBase())) {
acount++;
}
}
if (acount == 0) {
continue;
}
}
if (trackQ) {
track = infile[ii].getPrimaryTrack(jj);
tracks[track]++;
} else {
count++;
}
}
if (trackQ) {
count = 0;
for (i=1; i<tracks.getSize(); i++) {
if (tracks[i]) {
count++;
}
}
}
return count;
}
void printFields(ostream& out, HumdrumFile& infile, int line) {
out << "<tr class=\"hi\" valign=baseline>";
int& i = line;
int j;
int track;
int counter;
int subtracks;
PerlRegularExpression pre;
Array<char> strang;
for (track=1; track<=infile.getMaxTracks(); track++) {
subtracks = getSubTracks(infile, line, track);
out << "<td>";
if (subtracks > 1) {
out << "<table " << C0C0 << "><tr valign=top";
if (infile[i].isMeasure()) {
out << " bgcolor=#eeeeee ";
}
out << ">";
counter = 0;
for (j=0; j<infile[i].getFieldCount(); j++) {
if (infile[i].getPrimaryTrack(j) == track) {
strang.setSize(strlen(infile[i][j])+1);
strcpy(strang.getBase(), infile[i][j]);
pre.sar(strang, " ", " ", "g");
if (pre.search(strang, "^\\*>.*\\[", "")) {
addLabelHyperlinks(strang);
} else if (pre.search(strang, "^\\*>", "")) {
addLabelHyperlinkName(strang);
}
out << "<td width=" << TOKENWIDTH << ">" << strang << "</td>";
counter++;
if (counter < subtracks) {
out << "<td width=" << TDSEP << "></td>";
}
}
}
out << "</tr></table>\n";
} else {
for (j=0; j<infile[i].getFieldCount(); j++) {
if (infile[i].getPrimaryTrack(j) == track) {
strang.setSize(strlen(infile[i][j])+1);
strcpy(strang.getBase(), infile[i][j]);
pre.sar(strang, " ", " ", "g");
if (pre.search(strang, "^\\*>.*\\[", "")) {
addLabelHyperlinks(strang);
} else if (pre.search(strang, "^\\*>", "")) {
addLabelHyperlinkName(strang);
}
out << strang;
}
}
}
out << "</td>";
}
out << "</tr>\n";
}
void convertToCMN(HumdrumFile& infile) {
for (int i=infile.getMaxTracks()-1; i>= 0; i--) {
// set global state variables to uninitialized
key = -1;
nameinit = 0;
name[0] = '\0';
mode = -1;
metronome = -1;
bar = 0;
processTrack(infile, i+1);
}
}
void printPartNames(HumdrumFile& infile) {
int i, j;
Array<Array<char> > names;
Array<int> ktracks;
infile.getTracksByExInterp(ktracks, "**kern");
names.setSize(ktracks.getSize());
char buffer[1024] = {0};
for (i=0; i<names.getSize(); i++) {
sprintf(buffer, "part %ld", names.getSize() - i);
names[i] = buffer;
}
Array<int> rkern;
rkern.setSize(infile.getMaxTracks()+1);
rkern.setAll(-1);
for (i=0; i<ktracks.getSize(); 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]);
}
}
}
cout << "[";
for (i=names.getSize()-1; i>=0; i--) {
cout << "\"" << names[i] << "\"";
if (i > 0) {
cout << ", ";
}
}
cout << "]";
}
void processTrack(HumdrumFile& infile, int track) {
int status;
int i, j;
for (i=0; i<infile.getNumLines(); i++) {
if (start > i && track != infile.getMaxTracks()) {
// skip over global comments after the first time:
i = start;
}
if (terminus < i && terminus != -1 && track != 1) {
// skip over global comments after the first time:
break;
}
switch (infile[i].getType()) {
case E_humrec_data:
for (j=0; j<infile[i].getFieldCount(); j++) {
if (infile[i].getPrimaryTrack(j) == track) {
convertKernNoteToDM(infile, i, j, track);
break; // don't process second part of split track
}
}
break;
case E_humrec_bibliography:
cout << ";;;" << (char*)&infile[i][0][3] << "\n";
break;
case E_humrec_global_comment:
cout << ";;" << (char*)&infile[i][0][2] << "\n";
break;
case E_humrec_data_comment:
for (j=0; j<infile[i].getFieldCount(); j++) {
if (infile[i].getPrimaryTrack(j) == track) {
cout << ";" << (char*)&infile[i][j][1] << "\n";
break; // don't process second part of split track
}
}
break;
case E_humrec_data_measure:
break;
case E_humrec_interpretation:
status = parseInterpretation(infile, i, track);
if (status == 0) {
return;
}
default:
;
}
}
}
int getKernTrack(int number, HumdrumFile& infile) {
int counter = 0;
int i;
for (i=1; i<=infile.getMaxTracks(); i++) {
if (infile.getTrackExInterp(i) == "**kern") {
counter++;
}
if (counter == number) {
return i;
}
}
// Give some high-numbered spine which is not likely
// to be used (but is valid based on the size of trackmute).
return (int)trackmute.size()-10;
}
void getTrackInfo(HumdrumFile& infile, int trackline,
Array<int>& trackcount, Array<int>& subtrackcount) {
trackcount.setSize(1000);
trackcount.setSize(0);
subtrackcount.setSize(1000);
subtrackcount.setSize(0);
Array<int> ptrackcounter;
ptrackcounter.setSize(infile.getMaxTracks()+1);
ptrackcounter.setAll(0);
int ptrack;
int j;
if (!infile[trackline].isInterpretation()) {
for (j=0; j<infile[trackline].getFieldCount(); j++) {
ptrack = infile[trackline].getPrimaryTrack(j);
trackcount.append(ptrack);
subtrackcount.append(ptrackcounter[ptrack]);
ptrackcounter[ptrack]++;
}
return;
}
for (j=0; j<infile[trackline].getFieldCount(); j++) {
ptrack = infile[trackline].getPrimaryTrack(j);
if (strcmp(infile[trackline][j], "*^") == 0) {
trackcount.append(ptrack);
} else if ((j>0) && (strcmp(infile[trackline][j], "*v") == 0)) {
if (strcmp(infile[trackline][j-1], "*v") == 0) {
continue;
}
ptrack = infile[trackline].getPrimaryTrack(j);
trackcount.append(ptrack);
}
}
for (j=0; j<trackcount.getSize(); j++) {
subtrackcount.append(ptrackcounter[trackcount[j]]);
ptrackcounter[trackcount[j]]++;
}
}
int chooseSpine(const char* interp, HumdrumFile& infile) {
if (interp == NULL) {
return 1;
}
if (strcmp(interp, "") == 0) {
return 1;
}
int maxtracks = infile.getMaxTracks();
int i;
for (i=1; i<=maxtracks; i++) {
if (infile.getTrackExInterp(i) == interp) {
return i;
}
}
cerr << "Error: A " << interp
<< " data spine is not present in the source" << endl;
exit(1);
return 1;
}
int main(int argc, char* argv[]) {
HumdrumFile infile;
// process the command-line options
checkOptions(options, argc, argv);
infile.clear();
// if no command-line arguments read data file from standard input
int numinputs = options.getArgCount();
if (numinputs < 1) {
infile.read(cin);
} else {
filename = options.getArg(1);
infile.read(options.getArg(1));
}
int i;
for (i=0; i<infile.getMaxTracks(); i++) {
processFile(infile, i);
}
cout << infile;
}
void getClefInfo(Array<Array<int> >& baseline, HumdrumFile& infile) {
Array<int> states;
states.setSize(infile.getMaxTracks()+1); // +1 to allow for unused 0 index
states.setAll(Convert::kernClefToBaseline("*clefG2"));
int i, j;
baseline.setSize(infile.getNumLines());
for (i=0; i<baseline.getSize(); i++) {
baseline[i].setSize(0);
}
int pt;
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].isInterpretation()) {
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
if (strncmp(infile[i][j], "*clef", 5) == 0) {
pt = infile[i].getPrimaryTrack(j);
states[pt] = Convert::kernClefToBaseline(infile[i][j]);
}
}
}
if (!infile[i].isData()) {
continue;
}
baseline[i].setSize(infile[i].getFieldCount());
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
pt = infile[i].getPrimaryTrack(j);
baseline[i][j] = states[pt];
}
}
}
void processFile(HumdrumFile& infile) {
Array<int> octavestate;
int maxtracks = infile.getMaxTracks();
octavestate.setSize(maxtracks+1);
octavestate.allowGrowth(0);
octavestate.setAll(0);
int i;
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].getType() == E_humrec_interpretation) {
checkLineForOttavas(infile, i, octavestate);
}
if (infile[i].getType() == E_humrec_data) {
printDataLine(infile, i, octavestate, direction);
} else if (infile[i].getType() == E_humrec_interpretation) {
printTandemInterpretation(infile, i, direction);
} else {
cout << infile[i];
}
cout << "\n";
}
}
void getClefInfo(vector<vector<int> >& baseline, HumdrumFile& infile) {
vector<int> states(infile.getMaxTracks()+1,
Convert::kernClefToBaseline("*clefG2"));
int i, j;
baseline.resize(infile.getNumLines());
for (i=0; i<(int)baseline.size(); i++) {
baseline[i].resize(0);
}
int pt;
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].isInterpretation()) {
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
if (strncmp(infile[i][j], "*clef", 5) == 0) {
pt = infile[i].getPrimaryTrack(j);
states[pt] = Convert::kernClefToBaseline(infile[i][j]);
}
}
}
if (!infile[i].isData()) {
continue;
}
baseline[i].resize(infile[i].getFieldCount());
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
pt = infile[i].getPrimaryTrack(j);
baseline[i][j] = states[pt];
}
}
}
void getBeamState(vector<vector<string > >& beams, HumdrumFile& infile) {
int i, j, t;
int ii;
int contin;
int start;
int stop;
int flagr;
int flagl;
int track;
RationalNumber rn;
vector<vector<int> > beamstate; // state of beams in tracks/layers
vector<vector<int> > gracestate; // independents state for grace notes
string gbinfo;
beamstate.resize(infile.getMaxTracks() + 1);
gracestate.resize(infile.getMaxTracks() + 1);
for (i=0; i<(int)beamstate.size(); i++) {
beamstate[i].resize(100); // maximum of 100 layers in each track...
gracestate[i].resize(100); // maximum of 100 layers in each track...
std::fill(beamstate[i].begin(), beamstate[i].end(), 0);
std::fill(gracestate[i].begin(), gracestate[i].end(), 0);
}
beams.resize(infile.getNumLines());
vector<int> curlayer;
curlayer.resize(infile.getMaxTracks() + 1);
vector<int> laycounter;
for (i=0; i<infile.getNumLines(); i++) {
gbinfo.clear();
if (infile[i].isMeasure()) {
// don't allow beams across barlines. Mostly for
// preventing buggy beams from propagating...
for (t=1; t<=infile.getMaxTracks(); t++) {
std::fill(beamstate[t].begin(), beamstate[t].end(), 0);
std::fill(gracestate[t].begin(), gracestate[t].end(), 0);
}
}
if (!infile[i].isData() && !infile[i].isMeasure()) {
continue;
}
if (!infile[i].isData()) {
continue;
}
beams[i].resize(infile[i].getFieldCount());
for (j=0; j<(int)beams[i].size(); j++) {
beams[i][j].resize(1);
beams[i][j][0] = '\0';
}
std::fill(curlayer.begin(), curlayer.end(), 0);
for (j=0; j<infile[i].getFieldCount(); j++) {
track = infile[i].getPrimaryTrack(j);
curlayer[track]++;
if (strcmp(infile[i][j], ".") == 0) {
// ignore null tokens
continue;
}
if (strchr(infile[i][j], 'r') != NULL) {
// ignore rests. Might be useful to not ignore
// rests if beams extent over rests...
continue;
}
rn = Convert::kernToDurationR(infile[i][j]);
if (rn >= 1) {
beamstate[track][curlayer[track]] = 0;
continue;
}
if (rn == 0) {
// grace notes;
countBeamStuff(infile[i][j], start, stop, flagr, flagl);
if ((start != 0) && (stop != 0)) {
cerr << "Funny error in grace note beam calculation" << endl;
exit(1);
}
if (start > 7) {
cerr << "Too many beam starts" << endl;
}
if (stop > 7) {
cerr << "Too many beam ends" << endl;
}
if (flagr > 7) {
cerr << "Too many beam flagright" << endl;
}
if (flagl > 7) {
cerr << "Too many beam flagleft" << endl;
}
contin = gracestate[track][curlayer[track]];
contin -= stop;
for (ii=0; ii<contin; ii++) {
gbinfo += '=';
}
if (start > 0) {
for (ii=0; ii<start; ii++) {
gbinfo += '[';
}
} else if (stop > 0) {
for (ii=0; ii<stop; ii++) {
gbinfo += ']';
}
}
for (ii=0; ii<flagr; ii++) {
gbinfo += '/';
}
for (ii=0; ii<flagl; ii++) {
gbinfo += '\\';
}
if (gbinfo.size() > 6) {
cerr << "Error too many grace note beams" << endl;
cerr << "Size is " << gbinfo.size() << endl;
exit(1);
}
beams[i][j] = gbinfo;
gracestate[track][curlayer[track]] = contin;
gracestate[track][curlayer[track]] += start;
} else {
// regular notes which are shorter than a quarter note
// (including tuplet quarter notes which should be removed):
countBeamStuff(infile[i][j], start, stop, flagr, flagl);
if ((start != 0) && (stop != 0)) {
cerr << "Funny error in note beam calculation" << endl;
exit(1);
}
if (start > 7) {
cerr << "Too many beam starts" << endl;
}
if (stop > 7) {
cerr << "Too many beam ends" << endl;
}
if (flagr > 7) {
cerr << "Too many beam flagright" << endl;
}
if (flagl > 7) {
cerr << "Too many beam flagleft" << endl;
}
contin = beamstate[track][curlayer[track]];
contin -= stop;
for (ii=0; ii<contin; ii++) {
gbinfo += '=';
}
if (start > 0) {
for (ii=0; ii<start; ii++) {
gbinfo += '[';
}
} else if (stop > 0) {
for (ii=0; ii<stop; ii++) {
gbinfo += ']';
}
}
for (ii=0; ii<flagr; ii++) {
gbinfo += '/';
}
for (ii=0; ii<flagl; ii++) {
gbinfo += '\\';
}
if (gbinfo.size() > 6) {
cerr << "Error too many grace note beams" << endl;
cerr << "Size is " << gbinfo.size() << endl;
cerr << "Value is " << gbinfo << endl;
exit(1);
}
beams[i][j] = gbinfo;
beamstate[track][curlayer[track]] = contin;
beamstate[track][curlayer[track]] += start;
}
}
}
}
int main(int argc, char** argv) {
// process the command-line options
checkOptions(options, argc, argv);
HumdrumFile infile;
if (options.getArgCount() < 1) {
infile.read(cin);
} else {
infile.read(options.getArg(1));
}
if (field <= 0) { // field counter starts at 1
field = findBestField(infile);
}
if (field > infile.getMaxTracks()) {
field = infile.getMaxTracks();
}
vector<Datum> data;
extractNumbers(infile, field, data);
if (inputQ) {
printRawNumbers(data, fullQ);
}
double mean;
double sd;
if (meanQ) {
mean = myMean;
} else {
mean = getMean(data);
}
if (sdQ) {
sd = mySd;
} else {
if (sampleQ) {
sd = getSampleSD(mean, data);
} else {
sd = getStandardDeviation(mean, data);
}
}
if (statQ) {
cout << "Mean:\t" << mean << "\n";
cout << "SD:\t" << sd << "\n";
}
if (inputQ) {
exit(0);
}
if (statQ && !rawQ) {
exit(0);
}
adjustData(data, mean, sd, reverseQ);
if (rawQ) {
printRawNumbers(data, fullQ);
exit(0);
} else if (replaceQ) {
printDataReplace(data, field, infile, mean, sd);
} else if (prependQ) {
printDataPrepend(data, field, infile, mean, sd);
} else if (appendQ) {
printDataAppend(data, field, infile, mean, sd);
} else {
printDataSingle(data, field, infile, mean, sd);
}
return 0;
}
void getBeamState(Array<Array<Array<char> > >& beams, HumdrumFile& infile) {
int i, j, t;
int ii;
int len;
int contin;
int start;
int stop;
int flagr;
int flagl;
int track;
RationalNumber rn;
Array<Array<int> > beamstate; // state of beams in tracks/layers
Array<Array<int> > gracestate; // independents state for grace notes
Array<char> gbinfo;
gbinfo.setSize(100);
gbinfo.allowGrowth(0);
beamstate.setSize(infile.getMaxTracks() + 1);
gracestate.setSize(infile.getMaxTracks() + 1);
beamstate.allowGrowth(0);
gracestate.allowGrowth(0);
for (i=0; i<beamstate.getSize(); i++) {
beamstate[i].setSize(100); // maximum of 100 layers in each track...
gracestate[i].setSize(100); // maximum of 100 layers in each track...
beamstate[i].allowGrowth(0);
gracestate[i].allowGrowth(0);
beamstate[i].setAll(0);
gracestate[i].setAll(0);
}
beams.setSize(infile.getNumLines());
Array<int> curlayer;
curlayer.setSize(infile.getMaxTracks() + 1);
Array<int> laycounter;
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].isMeasure()) {
// don't allow beams across barlines. Mostly for
// preventing buggy beams from propagating...
for (t=1; t<=infile.getMaxTracks(); t++) {
beamstate[t].setAll(0);
gracestate[t].setAll(0);
}
}
if (!infile[i].isData() && !infile[i].isMeasure()) {
continue;
}
if (!infile[i].isData()) {
continue;
}
beams[i].setSize(infile[i].getFieldCount());
for (j=0; j<beams[i].getSize(); j++) {
beams[i][j].setSize(1);
beams[i][j][0] = '\0';
}
curlayer.setAll(0);
for (j=0; j<infile[i].getFieldCount(); j++) {
track = infile[i].getPrimaryTrack(j);
curlayer[track]++;
if (strcmp(infile[i][j], ".") == 0) {
// ignore null tokens
continue;
}
if (strchr(infile[i][j], 'r') != NULL) {
// ignore rests. Might be useful to not ignore
// rests if beams extent over rests...
continue;
}
rn = Convert::kernToDurationR(infile[i][j]);
if (rn >= 1) {
beamstate[track][curlayer[track]] = 0;
continue;
}
if (rn == 0) {
// grace notes;
countBeamStuff(infile[i][j], start, stop, flagr, flagl);
if ((start != 0) && (stop != 0)) {
cerr << "Funny error in grace note beam calculation" << endl;
exit(1);
}
if (start > 7) {
cerr << "Too many beam starts" << endl;
}
if (stop > 7) {
cerr << "Too many beam ends" << endl;
}
if (flagr > 7) {
cerr << "Too many beam flagright" << endl;
}
if (flagl > 7) {
cerr << "Too many beam flagleft" << endl;
}
contin = gracestate[track][curlayer[track]];
contin -= stop;
gbinfo.setAll(0);
for (ii=0; ii<contin; ii++) {
gbinfo[ii] = '=';
}
if (start > 0) {
for (ii=0; ii<start; ii++) {
strcat(gbinfo.getBase(), "[");
}
} else if (stop > 0) {
for (ii=0; ii<stop; ii++) {
strcat(gbinfo.getBase(), "]");
}
}
for (ii=0; ii<flagr; ii++) {
strcat(gbinfo.getBase(), "/");
}
for (ii=0; ii<flagl; ii++) {
strcat(gbinfo.getBase(), "\\");
}
len = strlen(gbinfo.getBase());
if (len > 6) {
cerr << "Error too many grace note beams" << endl;
exit(1);
}
beams[i][j].setSize(len+1);
strcpy(beams[i][j].getBase(), gbinfo.getBase());
gracestate[track][curlayer[track]] = contin;
gracestate[track][curlayer[track]] += start;
} else {
// regular notes which are shorter than a quarter note
// (including tuplet quarter notes which should be removed):
countBeamStuff(infile[i][j], start, stop, flagr, flagl);
if ((start != 0) && (stop != 0)) {
cerr << "Funny error in note beam calculation" << endl;
exit(1);
}
if (start > 7) {
cerr << "Too many beam starts" << endl;
}
if (stop > 7) {
cerr << "Too many beam ends" << endl;
}
if (flagr > 7) {
cerr << "Too many beam flagright" << endl;
}
if (flagl > 7) {
cerr << "Too many beam flagleft" << endl;
}
contin = beamstate[track][curlayer[track]];
contin -= stop;
gbinfo.setAll(0);
for (ii=0; ii<contin; ii++) {
gbinfo[ii] = '=';
}
if (start > 0) {
for (ii=0; ii<start; ii++) {
strcat(gbinfo.getBase(), "[");
}
} else if (stop > 0) {
for (ii=0; ii<stop; ii++) {
strcat(gbinfo.getBase(), "]");
}
}
for (ii=0; ii<flagr; ii++) {
strcat(gbinfo.getBase(), "/");
}
for (ii=0; ii<flagl; ii++) {
strcat(gbinfo.getBase(), "\\");
}
len = strlen(gbinfo.getBase());
if (len > 6) {
cerr << "Error too many grace note beams" << endl;
exit(1);
}
beams[i][j].setSize(len+1);
strcpy(beams[i][j].getBase(), gbinfo.getBase());
beamstate[track][curlayer[track]] = contin;
beamstate[track][curlayer[track]] += start;
}
}
}
}
PixelColor makeColor(HumdrumFile& infile, int line, int spine, int style,
Array<int>& rhylev, int track) {
PixelColor output;
int trackCount;
PerlRegularExpression pre;
const char* instrument = "";
PixelColor purple (225, 121, 255);
PixelColor yellowgreen(150, 200, 0);
switch (toupper(style)) {
case 'M': // color by metric position
if (rhylev[line] >= 2) {
output.setColor("red");
} else if (rhylev[line] == 1) {
output.setColor("lightorange");
} else if (rhylev[line] == 0) {
output.setColor("yellow");
} else if (rhylev[line] == -1) {
output.setColor("green");
} else if (rhylev[line] == -2) {
output.setColor("blue");
} else if (rhylev[line] <= -3) {
output.setColor("violet");
} else {
output.setColor("silver");
}
break;
case 'V': // color spines by voice
instrument = getInstrument(infile, track);
if (pre.search(instrument, "Bassus", "i")) {
output.setColor("red");
} else if (pre.search(instrument, "Contra", "i")) {
output.setColor("darkorange");
} else if (pre.search(instrument, "Tenor", "i")) {
output.setColor("blue");
} else if (pre.search(instrument, "Altus", "i")) {
output = purple;
} else if (pre.search(instrument, "Superius", "i")) {
output.setColor("limegreen");
} else if (pre.search(instrument, "Cantus", "i")) {
output.setColor("limegreen");
} else if (pre.search(instrument, "Discantus", "i")) {
output = yellowgreen;
} else {
output.setColor("black");
}
break;
case 'H': // color spines by hue
default:
trackCount = infile.getMaxTracks();
output.setHue(((int)infile[line].getTrack(spine))/(double)trackCount);
}
PixelColor bcolor(bgcolor);
double csum = (bcolor.Red + bcolor.Green + bcolor.Blue)/(255*3);
if (csum > 0.5) {
output.Red = output.Red / 2;
output.Green = output.Green / 2;
output.Blue = output.Blue / 2;
}
return output;
}
void getBeamSegments(vector<vector<Coord> >& beamednotes,
vector<vector<string > >& beamstates, HumdrumFile& infile,
vector<int> maxlayer) {
beamednotes.reserve(1000000);
beamednotes.resize(infile.getNumLines() * infile.getMaxTracks() / 2);
vector<vector<vector<Coord> > > beambuffer;
beambuffer.resize(infile.getMaxTracks() + 1);
int i, j;
for (i=0; i<(int)beambuffer.size(); i++) {
beambuffer[i].resize(10); // layer max 10, but allow growth
for (j=0; j<(int)beambuffer[i].size(); j++) {
beambuffer[i][j].reserve(100); // 100 notes in a beam expected as max
beambuffer[i][j].resize(0);
}
}
Coord tcoord;
char beamchar;
int track, oldtrack, layer;
for (i=0; i<infile.getNumLines(); i++) {
if (!infile[i].isData()) {
continue;
}
oldtrack = 0;
layer = 0;
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
track = infile[i].getPrimaryTrack(j);
if (track == oldtrack) {
layer++;
} else {
layer = 0;
}
oldtrack = track;
if (strcmp(infile[i][j], ".") == 0) {
continue;
}
if (strchr(infile[i][j], 'r') != NULL) {
continue;
}
beamchar = beamstates[i][j][0];
if (beamchar == '\0') {
beambuffer[track][layer].resize(0); // possible unter. beam
continue;
}
if ((beamchar == '[') || (beamchar == '=')) {
// add a beam to the buffer and wait for more
tcoord.i = i;
tcoord.j = j;
beambuffer[track][layer].push_back(tcoord);
continue;
}
if (beamchar == ']') {
// ending of a beam so store in permanent storage
tcoord.i = i;
tcoord.j = j;
beambuffer[track][layer].push_back(tcoord);
beamednotes.push_back(beambuffer[track][layer]);
beambuffer[track][layer].resize(0);
}
}
}
}
void getTransformation(HumdrumFile& hfile, Array<int>& transform) {
transform.setSize(1000);
transform.setSize(0);
transform.allowGrowth(1);
int maxspine = hfile.getMaxTracks();
int i, j;
if (reverseQ) {
transform.setSize(maxspine);
for (i=0; i<maxspine; i++) {
transform[i] = maxspine - i;
}
return;
}
if (options.getBoolean("field-order")) {
// const char* order = options.getString("field-order");
cout << "Not yet written" << endl;
return;
}
if (normalQ) {
int findex = -1;
int lindex = -1;
int i;
for (i=0; i<hfile.getMaxTracks(); i++) {
if (hfile.getTrackExInterp(i+1) == "**kern") {
if (findex == -1) {
findex = i;
}
lindex = i;
}
}
double favg = 0.0;
double lavg = 0.0;
if (findex != lindex) {
favg = getAveragePitch(hfile, findex + 1);
lavg = getAveragePitch(hfile, lindex + 1);
}
if (favg > lavg) {
if (determineQ) {
cout << "Score is in reverse order.\tpitch avgs:"
<< favg << "\tcompared to " << lavg << endl;
return;
}
// reverse data by kern (or primary spine type) blocks
for (i=maxspine; i>0; i--) {
if (hfile.getTrackExInterp(i) == "**kern") {
transform.append(i);
j = i+1;
while ((j <= maxspine) &&
(hfile.getTrackExInterp(j) != "**kern")) {
transform.append(j);
j++;
}
}
}
transform.allowGrowth(0);
return;
} else {
// score is already in normal form
if (determineQ) {
cout << "Score is in normal order.\tpictch avgs.:"
<< favg << " compared to " << lavg << endl;
return;
}
for (i=1; i<=maxspine; i++) {
transform.append(i);
}
transform.allowGrowth(0);
return;
}
}
// reverse data by kern (or primary spine type) blocks
char buffer[1024] = {0};
if (strncmp(primaryspine, "**", 2) != 0) {
strcpy(buffer, "**");
strcat(buffer, primaryspine);
} else {
strcat(buffer, primaryspine);
}
for (i=maxspine; i>0; i--) {
if (hfile.getTrackExInterp(i) == buffer) {
transform.append(i);
j = i+1;
while ((j <= maxspine) &&
(hfile.getTrackExInterp(j) != buffer)) {
transform.append(j);
j++;
}
}
}
}
void printGlobalComment(ostream& out, HumdrumFile& infile, int line) {
int& i = line;
out << "<tr valign=baseline><td colspan=" << infile.getMaxTracks() << ">";
out << "<font color=blue>" << infile[i] << "</font></td></tr>";
}
void processFile(HumdrumFile& infile) {
int i, j;
int pindex;
int hastext = 0;
vector<int> ktracks;
infile.getTracksByExInterp(ktracks, "**kern");
int partcount = ktracks.size();
vector<int> rktracks;
rktracks.resize(infile.getMaxTracks() + 1);
fill(rktracks.begin(), rktracks.end(), -1);
for (i=0; i<(int)ktracks.size(); i++) {
rktracks[ktracks[i]] = i;
}
char buffer[1024] = {0};
vector<string> partname(partcount);
vector<string> partabbr(partcount);
for (i=0; i<partcount; i++) {
sprintf(buffer, "part %d", partcount - i);
partname[i] = buffer;
sprintf(buffer, "P%d", partcount - i);
partabbr[i] = buffer;
}
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, "**text")) {
hastext = 1;
}
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
pindex = rktracks[infile[i].getPrimaryTrack(j)];
if (strncmp(infile[i][j], "*I\"", 3) == 0) {
partname[pindex] = &(infile[i][j][3]);
} else if (strncmp(infile[i][j], "*I'", 3) == 0) {
partabbr[pindex] = &(infile[i][j][3]);
}
}
}
cout << "**spine\t**pname\t**pabbr\n";
cout << "!!voice-count:\t" << partcount << "\n";
for (i=0; i<(int)ktracks.size(); i++) {
cout << ktracks[i] << "\t";
cout << partname[i] << "\t";
cout << partabbr[i];
cout << "\n";
}
if (hastext) {
cout << "!!has-text:\ttrue\n";
}
cout << "*-\t*-\t*-\t\n";
}
void createJsonProll(HumdrumFile& infile) {
infile.analyzeRhythm("4");
Array<int> ktracks;
infile.getTracksByExInterp(ktracks, "**kern");
Array<int> rktracks(infile.getMaxTracks()+1);
rktracks.allowGrowth(0);
rktracks.setAll(-1);
int i, j, k;
for (i=0; i<ktracks.getSize(); i++) {
rktracks[ktracks[i]] = i;
}
int ksize = ktracks.getSize();
stringstream* staves;
staves = new stringstream[ksize];
char buffer[1024] = {0};
int b40;
RationalNumber duration;
int track;
int tcount;
Array<Array<char> > partnames(ktracks.getSize());
Array<int> partmax(ktracks.getSize());
Array<int> partmin(ktracks.getSize());
partmax.setAll(-10000);
partmin.setAll(+10000);
Array<int> noteinit(ktracks.getSize());
noteinit.setAll(0);
for (i=0; i<infile.getNumLines(); i++) {
if (!infile[i].isData()) {
continue;
}
for (j=0; j<infile[i].getFieldCount(); j++) {
if (!infile[i].isExInterp(j, "**kern")) {
continue;
}
if (strcmp(infile[i][j], ".") == 0) {
continue;
}
tcount = infile[i].getTokenCount(j);
track = infile[i].getPrimaryTrack(j);
for (k=0; k<tcount; k++) {
infile[i].getToken(buffer, j, k);
if (strchr(buffer, 'r') != NULL) {
continue;
}
if (strchr(buffer, ']') != NULL) {
continue;
}
if (strchr(buffer, '_') != NULL) {
continue;
}
if (strcmp(buffer, ".") == 0) {
continue;
}
b40 = Convert::kernToBase40(buffer);
duration = infile.getTiedDurationR(i, j, k);
if (noteinit[rktracks[track]] == 0) {
noteinit[rktracks[track]] = 1;
pi(staves[rktracks[track]], 4);
staves[rktracks[track]] << "{\n";
} else {
pi(staves[rktracks[track]], 4);
staves[rktracks[track]] << "},\n";
pi(staves[rktracks[track]], 4);
staves[rktracks[track]] << "{\n";
}
printJsonNote(staves[rktracks[track]], b40, duration, buffer,
infile, i, j, k);
if (b40 > partmax[rktracks[track]]) {
partmax[rktracks[track]] = b40;
}
if (b40 < partmin[rktracks[track]]) {
partmin[rktracks[track]] = b40;
}
}
}
}
printJsonHeader(infile, 0, ktracks, partmin, partmax);
pi(cout, 2);
cout << "[\n";
pi(cout, 2);
cout << "{\n";
int pindex = 0;
for (i=ktracks.getSize()-1; i>=0; i--) {
pi(cout, 3);
cout << "\"partindex\"\t:\t" << pindex++ << ",\n";
pi(cout, 3);
cout << "\"notedata\"\t:\t" << "\n";
pi(cout, 4);
cout << "[\n";
cout << staves[i].str();
pi(cout, 4);
cout << "}\n";
pi(cout, 4);
cout << "]\n";
if (i > 0) {
pi(cout, 2);
cout << "},\n";
pi(cout, 2);
cout << "{\n";
} else {
pi(cout, 2);
cout << "}\n";
}
}
pi(cout, 2);
cout << "]\n";
pi(cout, 0);
cout << "}\n";
delete [] staves;
}
