//
// Copyright 2002 by Craig Stuart Sapp, All Rights Reserved.
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Sun Jul 29 18:09:38 PDT 2012
// Last Modified: Sun Jul 29 18:09:42 PDT 2012
// Filename:      ...sig/src/sigInfo/ScorePageSet.h
// Web Address:   http://sig.sapp.org/include/sigInfo/ScorePageSet.h
// Syntax:        C++ 
//
// Description:   Data structure for storing mulitiple pages of SCORE
//                data which represents one movement of a work.
//                (or one work if it only has one movement).
//

#include "ScorePageSet.h"
#include "Convert.h"
#include "PerlRegularExpression.h"

#include <string.h>

#ifndef OLDCPP
   using namespace std;
#endif

/*

//////////////////////////////
//
// ScorePageSet::ScorePageSet --
//

ScorePageSet::ScorePageSet(void) { 
   pages.setSize(1000);
   pages.setAll(NULL);
   pages.setSize(0);
   pages.setGrowth(1000);
   verseCount.setSize(1000);
   verseCount.setSize(0);
}



//////////////////////////////
//
// ScorePageSet::~ScorePageSet --
//

ScorePageSet::~ScorePageSet() { 
   int i;

   for (i=0; i<pages.getSize(); i++) {
      if (pages[i] != NULL) {
         delete pages[i];
         pages[i] = NULL;
      }
   }
   pages.setSize(0);
}



//////////////////////////////
//
// ScorePageSet::appendRead -- read a page of music and append it as 
//    the last page in the pages array.
//

int ScorePageSet::appendRead(const char* filename, int verboseQ) {
   ScorePage* newpage = new ScorePage;
   newpage->readFile(filename, verboseQ);
   pages.append(newpage);
   return pages.getSize();
}



//////////////////////////////
//
// ScorePageSet::analyzeContent --
//

void ScorePageSet::analyzeContent(void) {
   int i, j, k;
   for (i=0; i<pages.getSize(); i++) {
      pages[i]->analyzeContent();
   }

   int sysCount; 
   int sysObjCount = 0;

   // presuming a constant staff count per system for the
   // following code.

   // store durations of pages and absBeat data
   workDuration = 0.0;
   double sysBeat;
   double absBeat;
   for (i=0; i<pages.getSize(); i++) {
      sysCount = pages[i]->getSystemCount();
      for (j=0; j<sysCount; j++) {
         sysObjCount += pages[i]->getSystemItemCount(j);
      }
      for (j=0; j<pages[i]->getSystemCount(); j++) {
         for (k=0; k<pages[i]->getSystemItemCount(j); k++) {
            sysBeat = pages[i]->getSystemItem(j, k).getSystemBeat();
            absBeat = sysBeat + workDuration;
            pages[i]->getSystemItem(j,k).setAbsBeat(absBeat);
         }
         workDuration += pages[i]->getSystemDuration(j);
      }
   }

   // store a single stream of score items which are time sorted.
   systemItems.setSize(int(sysObjCount*1.1));
   systemItems.setGrowth(systemItems.getSize());
   systemItems.setSize(0);
   int systemCount;
   int itemcount;
   PageItem item;
   for (i=0; i<pages.getSize(); i++) {
      item.page = i;
      systemCount = pages[i]->getSystemCount();
      for (j=0; j<systemCount; j++) {
         itemcount = pages[i]->getSystemItemCount(j);
         for (k=0; k<itemcount; k++) {
            item.obj = pages[i]->getSystemItemNumber(j, k);
            systemItems.append(item);
         }
      }
   }

   // set the page index value within each ScoreRecord:
   for (i=0; i<getItemCount(); i++) {
      getItem(i).setSetIndex(i);
   }

   // process Lyrics information
   verseCount.setSize(getSystemStaffCount());
   verseCount.setAll(0);
   int lcount = 0;
   for (i=0; i<pages.getSize(); i++) {
      for (j=0; j<pages[i]->getSystemCount(); j++) {
         for (k=0; k<pages[i]->getSystemStaffCount(j); k++) {
            lcount = pages[i]->getSystemStaffLyricCount(k);
            if (lcount > verseCount[k]) {
               verseCount[k] = lcount;
            }
         }
      }
   }


   // adjust lyrics hyphenation across pages
   for (i=0; i<getPageCount()-1; i++) {
      for (j=0; j<getPartCount(); j++) {
         if (getVerseCount(j)) {
            //  page1, system; page2, system; sysstaff
            identifyPageBreakHyphens(i, getPage(i).getSystemCount()-1, 
                  i+1, 0, j);
         }
      }
   }

   analyzePartNames();
}



//////////////////////////////
//
// ScorePageSet::analyzePartNames -- identify text which is probably the name
//     of the part.  Look for text before indented staff lines of the first
//     system in the page set.
//

void ScorePageSet::analyzePartNames(void) {
   int i;
   int vpos;
   for (i=0; i<getItemCount(); i++) {
      if (getItem(i).hasDuration()) {
         break;
      }
      if (!getItem(i).isTextItem()) {
         continue;
      }
      vpos = (int)getItem(i).getVpos();
      if ((vpos > 0) && (vpos < 12)) { 
         getItem(i).setKeyValue("partname", 1);
      }
   }
}



//////////////////////////////
//
// ScorePageSet::getVerseCount --
//

int ScorePageSet::getVerseCount(int staffidx) {
   return verseCount[staffidx];
}



//////////////////////////////
//
// ScorePageSet::getPartVerseCount --
//

int ScorePageSet::getPartVerseCount(int staffidx) {
   return getVerseCount(staffidx);
}



//////////////////////////////
//
// ScorePageSet::getSystemStaffCount --
//

int ScorePageSet::getSystemStaffCount(void) {
   if (pages.getSize() == 0) {
      return 0;
   }
   return pages[0]->getSystemStaffCount(0);
}



//////////////////////////////
//
// ScorePageSet::getPartCount --
//

int ScorePageSet::getPartCount(void) {
   return getSystemStaffCount();
}



//////////////////////////////
//
// ScorePageSet::getPageCount --
//

int ScorePageSet::getPageCount(void) {
   return pages.getSize();
}



//////////////////////////////
//
// ScorePageSet::operator[] --
//

ScorePage& ScorePageSet::operator[](int pageidx) {
   return *(pages[pageidx]);
}



//////////////////////////////
//
// ScorePageSet::getPage --
//

ScorePage& ScorePageSet::getPage(int pageidx) {
   return *(pages[pageidx]);
}



//////////////////////////////
//
// ScorePageSet::getDuration -- return the duration in quarter notes.
//

double ScorePageSet::getDuration(void) {
   return workDuration;
}



//////////////////////////////
//
// ScorePageSet::getItem --
//

ScoreRecord& ScorePageSet::getItem(int objidx) {
   int page = systemItems[objidx].page;
   int num  = systemItems[objidx].obj;
   return pages[page]->getItem(num);
}



//////////////////////////////
//
// ScorePageSet::getItemCount --
//

int ScorePageSet::getItemCount(void) {
   return systemItems.getSize();
}



//////////////////////////////
//
// ScorePageSet::isAtEnd -- Returns true if the object is after the
//     last duration object (note or rests) in the work (set of pages).
//

int ScorePageSet::isAtEnd(int objidx) {
   int i;
   for (i=objidx; i<getItemCount(); i++) {
      if (getItem(i).hasDuration()) {
         return 0;
      }
   }

   return 1;
}



//////////////////////////////
//
// ScorePageSet::getTitle --
//

int ScorePageSet::getTitle(Array<char>& title) {
   title.setSize(1);
   title[0] = '\0';

   int    highestidx = -1;
   int    biggestidx = -1;
   double highestval = -1.0;
   double biggestval = -1.0;
   int    targetidx = -1;

   double p3;
   double p4;
   double p6;

   int staffidx = getSystemStaffCount()-1;
   int i;

   ScorePage& firstpage = getPage(0);
   int itemcount = firstpage.getItemCount(0,staffidx);

   for (i=0; i<itemcount; i++) {
      if (!firstpage.getItem(0,staffidx,i).isTextItem()) {
         continue;
      }
      p3 = firstpage.getItem(0,staffidx,i).getValue(P3);
      p4 = firstpage.getItem(0,staffidx,i).getValue(P4);
      p6 = firstpage.getItem(0,staffidx,i).getValue(P6);
      if (p6==0.0) {
         p6 = 1.0;
      }

      if (p3 < 20) {
         // don't look for title in top left corner of page.
         continue;
      }
      if (p3 > 150) {
         // don't look for title in top left corner of page.
         continue;
      }
      if (p4 < 12) {
         // don't look for title in/under staff.
         continue;
      }

      if (p4 > highestval) {
         highestval = p4;
         highestidx = i;
      }
      if (p6 > biggestval) {
         biggestval = p6;
         biggestidx = i;
      }
   }

   if (biggestval > 1) {
      targetidx = biggestidx;
   } else if (highestidx > 15) {
      targetidx = highestidx;
   }

   if (targetidx < 0) {
      return 0;
   }

   int len = strlen(firstpage.getItem(0,staffidx,targetidx).getTextData());
   title.setSize(len+1);
   strcpy(title.getBase(), 
      firstpage.getItem(0,staffidx,targetidx).getTextData());

   return 1;
}



//////////////////////////////
//
// ScorePageSet::getComposer --
//

int ScorePageSet::getComposer(Array<char>& composer) {
   composer.setSize(1);
   composer[0] = '\0';

   int    highestidx = -1;
   int    highestval = -1;
   int    targetidx = -1;

   double p3;
   double p4;

   int staffidx = getSystemStaffCount()-1;
   int i;

   ScorePage& firstpage = getPage(0);
   int itemcount = firstpage.getItemCount(0,staffidx);

   for (i=0; i<itemcount; i++) {
      if (!firstpage.getItem(0,staffidx,i).isTextItem()) {
         continue;
      }
      p3 = firstpage.getItem(0,staffidx,i).getValue(P3);
      p4 = firstpage.getItem(0,staffidx,i).getValue(P4);

      if (p3 < 150) {
         // don't look for composer on left side of page
         continue;
      }
      if (p4 < 12) {
         // don't look for composer in/under staff.
         continue;
      }
      if (p4 > 40) {
         // don't look for composer too high
         continue;
      }

      if (p4 > highestval) {
         highestval = p4;
         highestidx = i;
      }
   }

   if (highestidx > 12) {
      targetidx = highestidx;
   }

   if (targetidx < 0) {
      return 0;
   }

   int len = strlen(firstpage.getItem(0,staffidx,targetidx).getTextData());
   composer.setSize(len+1);
   strcpy(composer.getBase(), 
      firstpage.getItem(0,staffidx,targetidx).getTextData());

   return 1;
}



//////////////////////////////
//
// ScorePageSet::getInstrumentName --
//

int ScorePageSet::getInstrumentName(int staffidx, Array<char>& name) {
   name.setSize(1);
   name[0] = '\0';

   double p3;
   double p4;
   int i;

   double indent = getInitialStaffIndent();

   ScorePage& firstpage = getPage(0);
   int itemcount = firstpage.getItemCount(0,staffidx);

   int foundindex = -1;

   for (i=0; i<itemcount; i++) {
      if (!firstpage.getItem(0,staffidx,i).isTextItem()) {
         continue;
      }
      p3 = firstpage.getItem(0,staffidx,i).getValue(P3);
      p4 = firstpage.getItem(0,staffidx,i).getValue(P4);

      if (p3 > indent-3) {
         // only look for instrument name to the left of the staff.
         continue;
      }
      if (p4 < 3) {
         // don't look for name too low.
         continue;
      }
      if (p4 > 11) {
         // don't look for name too high
         continue;
      }

      foundindex = i;
      break;
   }

   PerlRegularExpression pre;
   if (foundindex >= 0) {
      int len = strlen(firstpage.getItem(0,staffidx,foundindex).getTextData());
      name.setSize(len+1);
      strcpy(name.getBase(), 
         firstpage.getItem(0,staffidx,foundindex).getTextData());
      pre.sar(name, "_\\d\\d", "", "g");
   }

   return foundindex? 1 : 0;
}



//////////////////////////////
//
// ScorePageSet::getInitialStaffIndent --
//

int ScorePageSet::getInitialStaffIndent(void) {
   int i;
   for (i=0; i<getItemCount(); i++) {
      if (!getItem(i).isStaffItem()) {
         continue;
      }
      return getItem(i).getValue(P3);
   }

   return 0;
}



//////////////////////////////
//
// ScorePage::identifyPageBreakHyphens --  Search for hyphenations which span system page breaks.
//

void ScorePageSet::identifyPageBreakHyphens(int page1, int sys1idx, int page2, int sys2idx, int staffidx) {
   int staff1num = getPage(page1).getSystemStaffNumber(sys1idx, staffidx);
   int staff2num = getPage(page2).getSystemStaffNumber(sys2idx, staffidx);

   int verse1count = getPage(page1).getPageStaffLyricCount(staff1num);
   int verse2count = getPage(page2).getPageStaffLyricCount(staff2num);

   // verse1count and verse2count should be the same value; otherwise,
   // the alignment of verses may be incorrect.
   
   int maxverse = verse1count < verse2count ? verse1count : verse2count;
   if (maxverse == 0) {
      return;
   }

   Array<int> syllables(maxverse);
   syllables.setAll(-1);
   // find the first lyric syllable for each verse on the second line
   int total = 0;
   int verse;
   ScoreRecord* srecord;
   int i;
   for (i=0; i<getPage(page2).getSystemStaffItemCount(sys2idx, staffidx); i++) {
      srecord = &(getPage(page2).getItem(sys2idx, staffidx, i));;
      if (!srecord->isTextItem()) {
         continue;
      }
      verse = srecord->getVerseIndex();
      if (verse < 0) {
         continue;
      }
      // found a verse syllable, add it to the list if the verse has not
      // yet been processed
      if (syllables[verse] < 0) {
         syllables[verse] = i;
         total++;
      }
      // stop looking for syllables if all verses have been accounted for
      if (total >= maxverse) {
         break;
      }
   }

   // find the last lyric or hyphen for each verse on the first line
   Array<int> proceeding(maxverse);
   proceeding.setAll(-1);
   total = 0;
   for (i=getPage(page1).getSystemStaffItemCount(sys1idx, staffidx)-1; i>=0; i--) {
      srecord = &(getPage(page1).getItem(sys1idx, staffidx, i));;

      verse = srecord->getVerseIndex();
      if (verse < 0) {
         continue;
      }

      if ((verse < proceeding.getSize()) && (proceeding[verse] < 0)) {
         proceeding[verse] = i;
         total++;
      }

      if (total >= maxverse) {
         break;
      }
   }


   // for each verse, add a "hyphenbefore" to syllables on the second staff
   // if the last item in the verse on the previous line as a hyphen.

   ScoreRecord* srecord1;
   ScoreRecord* srecord2;
   for (i=0; i<maxverse; i++) {
      srecord1 = &(getPage(page1).getSystemStaffItem(sys1idx, staffidx, proceeding[i])); 
      srecord2 = &(getPage(page2).getSystemStaffItem(sys2idx, staffidx, syllables[i])); 

      // presuming "hyphen" marked previously in named number parameters.
      if (srecord1->isHyphen()) {
         srecord2->setNumKeyValue("hyphenbefore", 1);
      } 
   }
}



//////////////////////////////
//
// ScorePageSet::getAbsBeat --
//

double ScorePageSet::getAbsBeat(int objidx) {
   return getItem(objidx).getAbsBeat();
}



//////////////////////////////
//
// ScorePageSet::getSystemStaffIndex --
//

int ScorePageSet::getSystemStaffIndex(int objidx) {
   return pages[getItemPage(objidx)]->getSystemStaffIndex(getItemPageIndex(objidx));
//   int page = systemItems[objidx].page;
//   int num  = systemItems[objidx].obj;
//   return pages[page]->getItem(num).getSystemStaffIndex();

}



//////////////////////////////
//
// ScorePageSet::getItemPage -- return the page to which the indexed item belongs.
//

int ScorePageSet::getItemPage(int objidx) {
   return systemItems[objidx].page;
}



//////////////////////////////
//
// ScorePageSet::getItemPageIndex -- return the page index of the pageset indexed
//     item.
//

int ScorePageSet::getItemPageIndex(int objidx) {
   return systemItems[objidx].obj;
}


*/

// md5sum: 097b1076b87b8b25465be795f377816f ScorePageSet.cpp [20050403]