annotate MainMultiOMR.py @ 2:46fb79167a61 tip

Main Code

'''
@organization: Lancaster University & University of Leeds
@version: 1.0
Created on 11/12/2014

@author: Victor Padilla
@contact: [e-mail]

The application can be run through command line (without windows interface) using 
MainMultiOMR library

'''
import logging
import time
import os
import gc
import sys
from subprocess import Popen
from music21 import stream
from music21 import converter
from Process import PipelineAlignment
from Process import Voting
from Process import SymbolConversion
from Process import FullScoreAlignment
from Automatism import BatchOMR
from Result import ProcessGroundS2
from Result import ExcellData
from Functions import FilesFunctions
from Functions import MeasureFunctions
from Alignment import NWunsch
import shutil

from Preprocessing import ossia
from Preprocessing import movements
from Preprocessing import preomr
import PythonMagick
import PyPDF2

class MainMultiOMR:
    '''
    main functions to run the Big Data Process. 
    They can be called without interface, from another program, for example
    ....
    # instance
    mmOMR=MainMultiOMR()
    
    # run the Big Data process once
    mmOMR.runBigData("C:\\Users\\victor\\Desktop\\data")
    
    # run the Big Data waiting for changes
    mmOMR.runDummyBigData("C:\\Users\\victor\\Desktop\\data")
    
     # run the Big Data Ground process once to get the results
    mmOMR.runBigDataGroung("C:\\Users\\victor\\Desktop\\data")
    
    # run the Big Data Ground waiting for changes
    mmOMR.runDummyBigData("C:\\Users\\victor\\Desktop\\data")
    '''
    
    def _loadNWunsch(self):
        '''
        Load Needlemann-Wunsch algorith library by default
        '''
        a=["foo00"]
        b=["foo000"]
        NWunsch.NWunsch_getSimilarity(a,b)
        #print "Default NWunsch......"
        
    
    def processPDF2TIFF(self,filename):  
        pdf_im = PyPDF2.PdfFileReader(file(filename, "rb"))
        npage = pdf_im.getNumPages()
        print('Converting %d pages.' % npage)
        intMovement=0
        for p in range(npage):
            im = PythonMagick.Image()
            im.density('300')
            print filename
            im.read(str(filename)+'[' + str(p) +']')
            strOut=str(filename) + str(p)
            im.write(strOut+ '.tif')
            
            infile=strOut+ '.tif'
            po = preomr.PreOMR(infile)
            rv = po.split_movements(strOut+'_A.tif', strOut+'_B.tif')
            if rv != None:
                print("new movement was detected at system %d" % (rv,)) 
                
                arrFile=filename.split("\\")
                myFile=arrFile.pop()
                path='\\'.join(arrFile)
                print "**********************",path
                if rv==0:
                    intMovement+=1
                    dirMovement=path+"\\m"+str(intMovement)
                    os.makedirs(dirMovement)
                    shutil.copy(strOut+ '.tif', dirMovement+"\\page_"+str(p)+".tif")
                else:
                    dirMovement=path+"\\m"+str(intMovement)
                    shutil.copy(strOut+ '_A.tif', dirMovement+"\\page_"+str(p)+".tif")
                    intMovement+=1
                    dirMovement=path+"\\m"+str(intMovement)
                    os.makedirs(dirMovement)
                    shutil.copy(strOut+ '_B.tif', dirMovement+"\\page_"+str(p)+".tif")
                    
            else:
                shutil.copy(strOut+ '.tif', dirMovement+"\\page_"+str(p)+".tif")
                
                
            
        
    def processOssia(self,rootDir):   
    ###############################################
    # @param dirGeneral root movement folder
        for dirname, dirnames, filenames in os.walk(rootDir):
            for f in filenames:
                fname_path = os.path.join(dirname, f)
                if f.endswith(".tif"):
                    print fname_path
                
                    ossia.process(fname_path, dirname+"\\_"+f)
#                     rootApp=os.path.dirname(sys.argv[0])
#                     rootApp=rootApp.replace("\\","/")
#                     cwd="python.exe "+rootApp+"/Preprocessing/ossia.py "+fname_path+" "+fname_path
#                     
#                     print cwd
#                     p = Popen(cwd)
#                     p.wait()
#                     p.communicate()
#     
               
                    
    def processMovement(self,dirGeneral):
        '''
        Process just one movement. The structure should be
        ....
        \\movementName\\fullScore\\XML\\(the .xml files)
                      \\parts\\0\\
                             \\1\\
                             \\2\\XML\\(the .xml files)
                             
        the result is \\movementName\\finalScore.xml
        
        usage:
        mmOMR=MainMultiOMR()
        mmOMR.processMovement("C:\Users\victor\Desktop\data\k458\Process\m2")
        '''
       
        
        ff=FilesFunctions()
        subdirnameParts=ff.SubDirPath(dirGeneral+"\\Parts\\") 
        fsOMRs_files=ff.getFiles(dirGeneral+"\\fullScore\\XML\\")   
        for dirname in subdirnameParts:
            d=dirname+"/XML/"
            urlSplit=dirname.split("\\")
            part=int(urlSplit[-1])
            partOMRs_files=ff.getFiles(d) 
            print "---------S2------------"
            logging.warning("Part:"+str(part)+" "+d)
            self.setResultS2(d,part,fsOMRs_files,partOMRs_files)
        
        print "---------Synchronising scores and parts------------"
        logging.warning("---------Synchronising scores and parts------------:"+dirGeneral)
        #fsOMRs=ff.getOMRs(dirGeneral+"\\fullScore\\XML\\")   
        self.__runSynchroScoresAndParts(dirGeneral,fsOMRs_files)    
    
    ###############################################
    # @param path folder where the .xml files are 
    # @param idPart part number 
    # @param fsOMRs array with the full score files processed by music21
    # @param partOMRs array with the part files processed by music21
    def setResultS2(self,path,idPart,fsOMRs,partOMRs):
        '''
        Takes the fullScores (processing the idPart) and parts.
        It writes the result (result.S2.xml) in the dirname
        
        This function process each part independently
        
        usage:
        
        mmOMR=MainMultiOMR()
        ff=FilesFunctions()
        fsOMRs=ff.getOMRs("C:\\Users\\victor\\Desktop\\data\\k458_test\\Process\\m2\\fullScore\\XML")
        partOMRs=ff.getOMRs("C:\\Users\\victor\\Desktop\\data\\k458_test\\Process\\m2\\parts\\0\\XML")
        d="C:\\Users\\victor\\Desktop\\data\\k458_test\\Process\\m2\\parts\\0\\XML"
        mmOMR.setResultS2(d,0,fsOMRs,partOMRs)
        '''
        
        
        
        pa=PipelineAlignment()
        vote=Voting()
        sc=SymbolConversion()
        ff=FilesFunctions()
        omr_symbolsAlign,betterOmrIds=pa.alignNJ_files(idPart,fsOMRs,partOMRs)
        #The .txt with the OMRs involved (tree) 
        ff.writeText(path,betterOmrIds)
        #voting
        
        outVote=vote.vote(omr_symbolsAlign)
        #apply voices if it is needed
        
        outVote=sc.setVoices(outVote)
        #convert to music21
        resultS2=sc.convertM21(outVote)
        mf=MeasureFunctions()
        #remove blank measures due to the alignment
        resultS2_clean=mf.filterExtraMeasures(resultS2)
        resultS2_clean.write("musicxml", path+'/result.S2.xml')
        

    ###############################################
    # @param dirGeneral folder where is the root of the movement 
    # @param fsOMRs array with the full score files processed by music21    
    def __runSynchroScoresAndParts(self,dirGeneral,fsOMRs_files):
        '''
        Takes the fullScores and part files generated to align the final full score
        - dirGeneral is the movement URL
        - fsOMRs is an array with the full scores OMRs processed by music21
        '''
        ff=FilesFunctions()
        subdirnameParts=ff.SubDirPath(dirGeneral+"\\parts\\")
        partsNumber=len(subdirnameParts)
        fsa=FullScoreAlignment()   
        idCompleteScoreBetter=fsa.getIdBetterOMRFullScore(fsOMRs_files,partsNumber)
        betterFsOMR=ff.getOMR(fsOMRs_files[idCompleteScoreBetter])
        finalScore=fsa.runSynchronisingMeasuresNJ(subdirnameParts,betterFsOMR) 
        betterFsOMR=None 
        finalScore.write("musicxml", dirGeneral+'/finalScore.xml')   
        finalScore=None
        gc.collect()
        print "----"
        
        

    ###############################################
    # @param dirGeneral root movement folder
    def processMovementGround(self,dirGeneral):
        '''
        Process the result. Just one movement. It takes each OMR file and compare against the ground.
        The differences are written in .XML and .xls
        
         ....
        \\movementName\\fullScore\\XML\\(the .xml files)
                      \\parts\\0\\
                             \\1\\
                             \\2\\XML\\(the .xml files)
                             
        the file finalScore.xml should be in \\movementName\\finalScore.xml
        the file ground.xml should be in \\movementName\\ground.xml
        
        The final result is written in 
        \\movementName\\parts\\resultGeneral.xlsx
                             \\fullScore_errors.xml
        
        usage:
        mmOMR=MainMultiOMR()
        mmOMR.processMovementGround("C:\Users\victor\Desktop\data\k458\Process\m2")
        '''
        percentagesArray=[]
        betterOMRIds=[]
        ff=FilesFunctions()
        subdirname=ff.SubDirPath(dirGeneral+"\\parts\\")
        filesFull=ff.getFiles(dirGeneral+"\\fullScore\\XML\\") 
    
        ground=ff.getGround(dirGeneral)
        groundparsed=converter.parse(ground, forceSource=True)
        finalScore=ff.getFinalScore(dirGeneral)
        finalScoreparsed=converter.parse(finalScore, forceSource=True)
            
       
        for dirname in subdirname:
            d=dirname+"/XML/"
            urlSplit=dirname.split("\\")
            part=int(urlSplit[-1])
            filesPart=ff.getFiles(d)
            files=filesPart+filesFull

            print files
            pg=ProcessGroundS2()
            ErrorsMatrix=[]
            percentages=[]
    
            OMRs=[]
            OMRs.append(groundparsed)
            OMRs.append(finalScoreparsed)
           
           
    
            percentage,errors,scoreWithErrors= pg.getSimilarity(OMRs,part)       
            ErrorsMatrix.append(errors)
            percentages.append(percentage)
            if not os.path.exists(dirname+"\\Result"):
                os.makedirs(dirname+"\\Result")
          
            scoreWithErrors.write("musicxml", dirname+"\\Result\\result.S2.xml")
           
            for i in range(len(files)):
                try:
                    OMRs[1]=ff.getOMR(files[i])
                    percentage,errors,scoreWithErrors= pg.getSimilarity(OMRs,part)
                    ErrorsMatrix.append(errors)
                    percentages.append(percentage)
                    scoreWithErrors.write("musicxml", dirname+"\\Result\\"+os.path.basename(files[i]))
                except:
                    print "ERROR OMR READING"
                    ErrorsMatrix.append("ERROR OMR READING")
                    percentages.append(0)
        
               
            f=open(d+"betterOMR.txt","r") 
            betterOMRId=f.readlines()
            f.close()
            betterOMRIds.append(betterOMRId)
            print "betterOMRIds",betterOMRIds
            ed=ExcellData()
            files.insert(0,dirname+"\\Result\\result.S2.xml" )
            print files
            ed.saveData(ErrorsMatrix,files,percentages)  
            percentagesArray.append(percentages)  
           
            
        ed=ExcellData()
        ed.saveGlobalData(percentagesArray,dirGeneral,betterOMRIds,files)  
        self.__joinErrorParts(dirGeneral)
        print "----------- END ------------"
   
    ################################################################
    # @param rootDir root folder where all the scores to process are
    def runBigData(self,rootDir): 
        '''
        Checks if there is any folder to process 
        If the folder "Process" is written, but the "finalScore.xml" is not,
            runs the procedure
        
        usage
        
        mmOMR=MainMultiOMR()
        d="C:\\Users\\victor\\Desktop\\cach"
        mmOMR.runBigData(d)
        '''
        ff=FilesFunctions()
        for outWalk in os.walk(rootDir):
            dirName=outWalk[0]
            arrDir=dirName.split("\\")
            if arrDir[-1]=="Process":
                movements=ff.SubDirPath(dirName)
                for movement in movements:
                    print movement
                    if not os.path.isfile(movement+"\\finalScore.xml"):
                        logging.warning("Movement:"+movement+" "+rootDir)
                        self.processMovement(movement) 
   
    ################################################################
    # @param rootDir root folder where all the scores to process are
    def runLoopBigData(self,rootDir,adaptOMRs=False):
        '''
        Infinity loop for processing data
        Checks if there is any folder to process 
        If the folder "Process" is written, but the "finalScore.xml" is not,
            runs the procedure
        
        usage
        
        mmOMR=MainMultiOMR()
        d="C:\\Users\\victor\\Desktop\\cach"
        mmOMR.runLoopBigData(d)
        '''
        batchOMR=BatchOMR()
        ff=FilesFunctions()
        for outWalk in os.walk(rootDir):
            dirName=outWalk[0]
            subdirList=outWalk[1]
            if "OMRS" in subdirList:
                rootScore=dirName
                omrFinished=True
                scoreFinished=True
                for outWalk2 in os.walk(rootScore):
                    dirName2=outWalk2[0]
                    files= ff.getAllImgFiles(dirName2)
                    omrs=ff.getAllXMLFiles(dirName2)
                    if len(files)>0 and len(omrs)<4:
                        omrFinished=False
                        
                if os.path.exists(rootScore+"\\Process"):
                    movements=ff.SubDirPath(rootScore+"\\Process")
                    for movement in movements:
                        if not os.path.isfile(movement+"\\finalScore.xml"):
                            scoreFinished=False
                else:
                    scoreFinished=False 
                        
                        
                if omrFinished==True and scoreFinished==False:
                    print "---- CONFIGURE SCORES ---"
                    batchOMR.setupApp(rootScore)
                    print "---- CONFIGURE GROUND ---"
                    batchOMR.setGround(rootScore)
                    if adaptOMRs:
                        print "---- ADAPT OMRs ---"
                        self.runAdaptAllOMRs(rootScore+"\\Process")
                    print "---- RUN BIG DATA ---"
                    self.runBigData(rootScore)
        print "Waiting for processing..."
        time.sleep(5)  
        self.runLoopBigData(rootDir,adaptOMRs)
                     
                             
    ################################################################
    # @param rootDir root folder where all the scores to process are                   
    def runBigDataGround(self,rootDir):
        '''
        Checks if there is any folder to process to get the result
        If "resultGeneral.xlsx" is not written and "finalScore.xml" and "ground.xml" are in the movement root dir,
        launches the process
        
        usage
        
        mmOMR=MainMultiOMR()
        d="C:\\Users\\victor\\Desktop\\data"
        mmOMR.runBigDataGround(d)
        '''
        ff=FilesFunctions()
        for outWalk in os.walk(rootDir):
            dirName=outWalk[0]
            arrDir=dirName.split("\\")
            if arrDir[-1]=="Process":
                movements=ff.SubDirPath(dirName)
                for movement in movements:
                    if not os.path.isfile(movement+"\\parts\\resultGeneral.xlsx"):
                        if os.path.isfile(movement+"\\finalScore.xml") and os.path.isfile(movement+"\\ground.xml") :
                            self.processMovementGround(movement)
                            
    ################################################################
    # @param rootDir root folder where all the scores to process are                   
    def runFinalXLS(self,rootDir):
        '''
        Checks if there is any folder to process to get the result
        If "resultGeneral.xlsx" is not written and "finalScore.xml" and "ground.xml" are in the movement root dir,
        launches the process
        
        usage
        
        mmOMR=MainMultiOMR()
        d="C:\\Users\\victor\\Desktop\\data"
        mmOMR.runBigDataGround(d)
        '''
        ed=ExcellData()
        files=0
        S2_sum=0
        CP_sum=0
        PS_sum=0
        SE_sum=0
        SS_sum=0
        ff=FilesFunctions()
        for outWalk in os.walk(rootDir):
            dirName=outWalk[0]
            arrDir=dirName.split("\\")
            if arrDir[-1]=="Process":
                movements=ff.SubDirPath(dirName)
                for movement in movements:
                    if os.path.isfile(movement+"\\parts\\resultGeneral.xlsx"):
                        files=files+1
                        s2,cp,ps,se,ss=ed.processResultGeneral(movement+"\\parts\\resultGeneral.xlsx")
                        S2_sum=S2_sum+s2
                        CP_sum=CP_sum+cp
                        PS_sum=PS_sum+ps
                        SE_sum=SE_sum+se
                        SS_sum=SS_sum+ss
        ed.writeFinalXLS(rootDir,S2_sum/files,CP_sum/files,PS_sum/files,SE_sum/files,SS_sum/files)             
                            
    ################################################################
    # @param rootDir root folder where all the scores to process are 
    def runLoopBigDataGround(self,rootDir):
        '''
        Infinity loop for getting the results
        
        If "resultGeneral.xlsx" is not written and "finalScore.xml" and "ground.xml" are in the movement root dir,
        launches the process
        
        usage
        
        mmOMR=MainMultiOMR()
        d="C:\\Users\\victor\\Desktop\\data"
        mmOMR.runLoopBigDataGround(d)
        '''
        self.runBigDataGround(rootDir)
        print "Waiting for results..."
        time.sleep(5)  
        self.runLoopBigDataGround(rootDir)
        

    ################################################################
    # @param dirGeneral root folder of the movement 
   
    def __joinErrorParts(self,dirGeneral):
        '''
        Joins the different result.S2.xml error in a single file.
        The output file is "fullScore_errors.xml"
        
        The function tries to find the file "parts\\[idMovement]\\Result\\result.S2.xml" in each part
        '''
        ff=FilesFunctions()
        subdirname=ff.SubDirPath(dirGeneral+"\\parts\\")
        fullScore=stream.Score()
        for dirname in subdirname:
            d=dirname+"\\Result\\"
            urlSplit=dirname.split("\\")
            part=int(urlSplit[-1])
            f=d+"\\result.S2.xml"
            omr=converter.parse(f, forceSource=True)
            part=omr.getElementsByClass(stream.Part)[0]
            fullScore.append(part)
        fullScore.write("musicxml", dirGeneral+"\\parts\\fullScore_errors.xml")
        

    ###############################################
    # @param rootDir root folder of the general data                                
    def runCompleteProcess(self,rootDir):
        '''
        Instead of working in parallel, this function launches a serial process with the different 
        steps involved
        1.- SIKULI AUTOMATISM
        2.- SETUP APPLICATION (copying files)
        3.- CONVERT GROUND (taking the .krn and convert to ground.xml)
        4.- RUN MULTIOMR BIG DATA
        5.- RUN GET RESULT BIG DATA
        
        
        usage:
        mmOMR=MainMultiOMR()
        d="C:\\Users\\victor\\Desktop\\data"
        mmOMR.runCompleteProcess(d)
        '''
        batchOMR=BatchOMR()
        logging.basicConfig(filename=rootDir+'\\BigDataLogs.log',format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
        print "-------SIKULI AUTOMATISM----------"
        logging.warning("---SIKULI AUTOMATISM--- "+rootDir)
        batchOMR.processAllTiffFiles(rootDir,"ALL")
        print "-------SETUP APPLICATION----------"
        logging.warning("---SETUP APPLICATION--- "+rootDir)
        batchOMR.setupApp(rootDir)
        print "-------CONVERT GROUND----------"
        logging.warning("---CONVERT GROUND--- "+rootDir)
        batchOMR.setGround(rootDir)
        logging.warning("------RUN MULTIOMR BIG DATA--- "+rootDir)
        print "-------RUN MULTIOMR BIG DATA----------"
        self.runBigData(rootDir)
        print "-------RUN GET RESULT BIG DATA----------"
        self.runBigDataGround(rootDir)
    
    ###############################################
    # @param filename file to convert  
    def runConvertKrnToMusicXML(self,filename):
        '''
        converts a .krn file to .xml using music21
        
        usage:
        mmOMR=MainMultiOMR()
        file="C:\\Users\\victor\\Desktop\\data\\k458\\OMRS\\m2\\k458.krn"
        mmOMR.runConvertKrnToMusicXML(file)
        '''
        omr=converter.parse(filename)
        omr.write("musicxml", filename+'.xml')
    
    ###############################################
    # @param filename file to convert  
    def runConvertMidiToMusicXML(self,filename):
        '''
        converts a .mid file to .xml using music21
        
        usage:
        mmOMR=MainMultiOMR()
        file="C:\\Users\\victor\\Desktop\\data\\k458\\OMRS\\m2\\k458.mid"
        mmOMR.runConvertKrnToMusicXML(file)
        '''
        omr=converter.parse(filename)
        #Reordering the different staffs
        omrOrdered=stream.Score()
        numberParts=len(omr.parts)
        for i in reversed(range(numberParts)):
            mypart=omr.parts[i]
            
            omrOrdered.insert(0,mypart)
        omrOrdered.write("musicxml", filename+'.xml')
        
    ###############################################
    # @param filename file to convert  
    def runConvertVoicesToChord(self,filename):
        '''

        '''
        mf=MeasureFunctions()
        omr=converter.parse(filename)
        omr=mf.convertVoicesToChord(omr)
        omr.show()
    
    ###############################################
    # @param filename file to convert  
    def runConvertBeamsToTriplets(self,filename):
        '''

        '''
        mf=MeasureFunctions()
        omr=converter.parse(filename)
        omr=mf.convertBeamsToTriplets(omr)
#         omr.show()
        omr.write("musicxml", filename+'.xml')
    
    def runRemovesEmptyVoices(self,filename):
        '''

        '''
        mf=MeasureFunctions()
        omr=converter.parse(filename)
        omr=mf.removesEmptyVoices(omr)
        omr.write("musicxml", filename+'.xml')
        
    def runRemovesGaps(self,filename):
        '''

        '''
        mf=MeasureFunctions()
        omr=converter.parse(filename)
        omr=mf.removesGaps(omr)
        omr.write("musicxml", filename+'.xml')


    def runAdaptOMRs(self,dirname):
        '''
        Runs the following process in one directory.
        1.-Removing GAPS
        2.-Converting voices to chords
        3.-Converting triplets
        4.-Removing Rest Voices
        '''
        ff=FilesFunctions()
        mf=MeasureFunctions()
        files=ff.getFiles(dirname)
        for f in files:
            try:
                print f
                omr=converter.parse(f)
                print "--- Removing GAPS---"
                omr=mf.removesGaps(omr)
               
                print "--- Converting voices to chords---"
                omr=mf.convertVoicesToChord( omr)
                
                print "--- Converting triplets---"
                omr=mf.convertBeamsToTriplets(omr)
                print "--- Removing Rest Voices---"
                omr=mf.removeRestVoice(omr)
                
                omr.write("musicxml", f)
            except:
                pass
                                    
    def runAdaptAllOMRs(self,rootDir):
        '''
        Adapt all the files in one directory tree
        '''
        for outWalk in os.walk(rootDir):
            dirName=outWalk[0]
            self.runAdaptOMRs(dirName)
                   
              

        
           
    ##################################################
    # @param dirname the directory where the files are  
    def runViewM21(self,dirname):
        '''
        Shows all the .xml files in a folder using music21
        to check the differences before and after processing
        
        usage:
        mmOMR=MainMultiOMR()
        dirname="C:\\Users\\victor\\Desktop\\data\\k458\\OMRS\\m2"
        mmOMR.runViewM21(dirname)
        '''
        ff=FilesFunctions()
        mf=MeasureFunctions()
        files=ff.getFiles(dirname)
        for f in files:
            omr=converter.parse(f)
            omr.show()
            omr.show('text')

    
    ##################################################
    # @param dirname the directory where the files are  
    def runViewWrongMeasures(self,dirname):
        '''
        Flags and prints the possible wrong measures
        
        usage:
        mmOMR=MainMultiOMR()
        dirname="C:\\Users\\victor\\Desktop\\data\\k458\\OMRS\\m2"
        mmOMR.runViewWrongMeasures(dirname)
        '''
        ff=FilesFunctions()
        mf=MeasureFunctions()   
        path = dirname
        print("Path:"+path)
        omr_files=ff.getAllFiles(path)   
        for f in omr_files:
            omr=converter.parse(f)
            arrayErrors=mf.flagIncorrectMeasures(omr)[1]
            for array in arrayErrors:
                for i in range(len(array)):
                    array[i]=array[i]+1
            print 
            print f
            print "Errors measures duration:"+str(arrayErrors[0])
            print "Errors measures estimated:"+str(arrayErrors[1])
            print "Errors based on beams:"+str(arrayErrors[2])
            print "Errors based on last notes:"+str(arrayErrors[3])