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; }