| Current Path : /proc/thread-self/root/usr/local/lib/python2.7/dist-packages/iftlib/score/ |
Linux ift1.ift-informatik.de 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64 |
| Current File : //proc/thread-self/root/usr/local/lib/python2.7/dist-packages/iftlib/score/abcutil.py |
# coding: utf8
import os
import re
import sys
import codecs
import time
#********************************************************************
class Part (object):
def __init__ (self):
self.text = ""
#********************************************************************
def make_parts (self,pars): # Creating all possible parts of the score
'''
erster Parameter: abc-File
zweiter Parameter: Kommaseparierte Liste von Stimmauszuegen: Wenn leer, werden alle gefundenen Stimmen gewaehlt
'''
m = re.search(r"^(.*)\.abc",pars[0])
if not m:
return()
try:
filter = pars[1];
filter = re.sub(r",","|",filter,9999)
except:
filter = ""
fileroot = m.group(1)
print fileroot, filter
text = codecs.open(pars[0],"r","utf-8").read()
all_parts = {}
while 0 == 0:
m = re.search(r"\s([a-z][a-z0-9]+)\:\:\s",text,re.DOTALL)
if not m:
break
if filter == "" or re.search("("+filter+")",m.group(1)):
all_parts[m.group(1)] = 1
text = re.sub(m.group(1),"",text,99999999)
for part in all_parts:
print part
text = self.read_in([pars[0],part])
# continue
fileroot1 = fileroot+"___"+part
open(fileroot1+".abc","w").write(text)
os.system("abcm2ps " + fileroot1 + ".abc -N 2 -j 0 -O " + fileroot1 + ".ps")
# os.system("ps2pdf " + fileroot1 + ".ps")
#********************************************************************
def read_in (self,pars):
part = pars[1]
if self.text == "":
self.text = codecs.open(pars[0],"r","utf-8").read()
self.parts = []
macros = {}
proceed_all_parts = True
if re.search(r"\n\%proceed",self.text):
proceed_all_parts = False
# 1. Evaluation of macros
text1 = self.text
while 0 == 0:
m = re.search(r"( MACRO +)(.*?)( +)(.*?)\n",text1,flags=re.DOTALL)
if not m:
break
macros[m.group(1)] = m.group(2)
o = m.group(1) + m.group(2) + m.group(3) + m.group(4)
text1 = re.sub(o,"",text1,99999999)
# 2. Evalutation of Includes
while 0 == 0:
m = re.search(r"( INCLUDE +)(.*?)\n",self.text,flags=re.DOTALL)
if not m:
break
o = m.group(1) + m.group(2)
o1 = "INXXCLUDE " + m.group(2) + "\n" + codecs.open(m.group(2),"r","utf-8").read()
self.text = re.sub(o,o1,self.text,99999999)
# 3. Evaluation of parts, the parts are cached in self.parts --- speed it up!
while 0 == 0:
m = re.search(r"^(.*?)([a-z0-9\-]+)\:\:(.*?[^a-z0-9\-])\:\:\n?(.*)$",self.text,re.DOTALL)
if not m:
break
self.text = m.group(1) + " PART---" + str(len(self.parts)) + "--- " + m.group(4)
partitem = m.group(2) + "::" + m.group(3) +"::"
partitems = {}
# print partitem
# time.sleep(1)
while 0 == 0:
m1 = re.search("^([a-z0-9\-]+)\:\: *(.*?) *([a-z0-9\-]*)\:\:(.*)$",partitem,re.DOTALL)
if not m1:
break
partitem = m1.group(3) + "::" + m1.group(4)
partitems[m1.group(1)] = m1.group(2)
self.parts.append(partitems)
# print self.text
# return()
text = self.text
while 0 == 0:
m = re.search(" PART---(\d+)--- ",text)
if not m:
break
o = " PART---" + m.group(1) + "--- "
o1 = self.parts[int(m.group(1))]
if part in o1:
o1 = o1[part]
elif "-" in o1:
o1 = o1["-"]
else:
o1 = ""
text = re.sub(o,o1,text)
# print text
# exit()
# 2. ----- split off in staves-Parts
textparts = []
while 0 == 0:
m = re.search(r"^(.*?)\n *\n(.*)$",text,re.DOTALL)
if not m:
textparts.append(text)
break
textparts.append(m.group(1)+"\n")
text = m.group(2)
textparts1 = []
for textpart in textparts:
if re.search(r"(^|\n)X\:\d",textpart) and not re.search(r"\n\%\%staves ",textpart):
continue
if not proceed_all_parts and not re.search(r"\n\%proceed",textpart):
continue
textparts1.append(textpart)
staveparts = textpart.split("\n%%staves ")
textpart = ""
vskip_present = 1 # Examination of all parts where a stave change is made
for stavepart in staveparts:
# m = re.search(r"^ *(treble|alto|bass)(.*)$",stavepart,re.DOTALL)
# if m:
# stavepart = m.group(2)
# text = text + "\nV:0 " + m.group(1)
if not vskip_present:
textpart = textpart + "\n%%vskip 0"
vskip_present = re.search(r"\n%%vskip ",stavepart)
if textpart == "":
textpart = stavepart
continue
m = re.search(r"^(.*?)\n(.*)$",stavepart,re.DOTALL)
staves = m.group(1) # the first line contains stave data
textrest = m.group(2)
transp = {} # collection of transposings
while 0 == 0:
m = re.search(r"^(.*[^a-zA-Z0-9\_|^])([a-zA-Z0-9\_]+)\:([a-zA-Z0-9\_\-\.]+)(.*)$",staves)
if not m:
break
transp[m.group(2)] = m.group(3)
staves = m.group(1) + m.group(2) + m.group(4)
stavepart = staves + "\n" + textrest
staves = re.sub(r"[\[\]\{\}\(\)\|]"," ",staves,99999999)
staves = re.sub(r" +"," ",staves,99999999).strip()
staves = re.sub(r" ",",",staves,99999999)
# print staves
stavepart = re.sub(r"\nV:XX ","\nV:"+staves,stavepart,99999999)
# 3# 3. Expand combined score lines --> e.g. Fl,Tr,Co
while 0 == 0:
m = re.search(r"^(.*?\n)(V:)([a-zA-Z0-9\_]+,[a-zA-Z0-9\_\:,]+)(.*?)\n(.*?I: *)(\n|$)(.*)$",stavepart,re.DOTALL)
if not m:
break
stavepart = m.group(1)
for o in m.group(3).split(","):
o1 = re.sub(r"\_$"," ",o)
o1 = re.sub(r"\_$"," ",o1)
o1 = re.sub(r"\_$"," ",o1)
if not ("V:" + o1) in ("V:0 " + m.group(5) + m.group(6)):
stavepart = stavepart + "V:" + ("%-3s" % o1) + m.group(4) + "\n"
stavepart = stavepart + m.group(5) + m.group(6) + m.group(7)
for transpose_voice in transp: # Add transposings
stavepart = re.sub("\nV:"+transpose_voice+" ",
"\nV:"+transpose_voice+" TRANSPOSE:" + transp[transpose_voice] + " ",
stavepart,99999999)
textpart = textpart + "\n%%staves " + stavepart
textparts1[-1] = textpart
text = "\n\n".join(textparts1)
# 4. Evaluate the transposings:
text1 = ""
while 0 == 0:
m = re.search(r"^(.*?) TRANSPOSE:([a-zA-Z0-9\.\_\-]+) (.*?)\n(.*)$",text,re.DOTALL)
if not m:
text1 = text1 + text
break
text1 = text1 + m.group(1) + " " + self.transpose_zeile(m.group(3),m.group(2)) + "\n"
text = m.group(4)
# text = "INXXCLUDE " + chkey + "\n" + codecs.open("deco.fmt","r","utf-8").read() + "\n\n" + text
# print text
# exit()
return text1
#********************************************************************
def transpose_zeile (self,zeile,transp):
zeile1 = ""
while 0 == 0:
if zeile == "":
break
m = re.search(r"^(treble|alto|bass) (.*)$",zeile)
if m:
zeile1 = zeile1 + m.group(1)
zeile = m.group(2)
continue
m = re.search(r"^\[K\:([ABCDEFGXZ])([b\#]?)(m*)\](.*)$",zeile)
if m:
note1 = m.group(1)
note1v = {"b":"_","\#":"^","":""}[m.group(2)]
note1m = m.group(3)
note1tr = self.transpose_note(note1v+note1,transp)
note1tr = re.sub(r"^(.*)(.)$","\\2\\1",note1tr)
note1tr = re.sub(r"\_","b",note1tr,99)
note1tr = re.sub(r"\^","#",note1tr,99)
zeile1 = zeile1 + "[K:" + note1tr.upper() + m.group(3) + "]"
zeile = m.group(4)
continue
m = re.search(r"^\"([ABCDEFG][b\#m]+)(\d*)\"(\s*)(.*)$",zeile)
if m: # Akkord-Angaben
zeile1 = zeile1 + ( "\"" +
self.transpose_note(m.group(1),transp) +
m.group(2) + "\"" + m.group(3) )
zeile = m.group(4)
continue
m = re.search(r"^\"([ABCDEFG][b\#m]*)(\d*)\/([ABCDEFG][b\#m]*)(\d*)\"(\s*)(.*)$",zeile)
if m: # Slash-Akkorde
zeile1 = zeile1 + ( "\"" +
self.transpose_note(m.group(1),transp) +
m.group(2) + "/" +
self.transpose_note(m.group(3),transp) +
m.group(4) + "\"" + m.group(5) )
zeile = m.group(6); # Slash-Akkorde
continue
m = re.search(r"^([\!\"])(.*?)([\!\"])(\s*)(.*)$",zeile)
if m: # Decorations
zeile1 = zeile1 + m.group(1) + m.group(2) + m.group(3) + m.group(4)
zeile = m.group(5)
continue
m = re.search(r"^([\^\_\=]*[ABCDEFGabcdefg][\'\,]*)(.*)$",zeile)
if m: # normal note
zeile1 = zeile1 + self.transpose_note(m.group(1),transp)
zeile = m.group(2)
continue
m = re.search(r"^(\[\S+?\:.+?\])(\s*)(.*)$",zeile)
if m:
zeile1 = zeile1 + m.group(1) + m.group(2)
zeile = m.group(3)
continue
m = re.search(r"^(\[\|\]|\[\||\|\]|\|\||\|:|:\||::|\|) (.*)$",zeile)
if m:
zeile1 = zeile1 + m.group(1) + " "
zeile = m.group(2);
continue
zeile1 = zeile1 + zeile[0]
zeile = zeile[1:]
return zeile1
#********************************************************************
def transpose_note (self,note,transp):
m = re.search(r"([\^\_\=]*)([ABCDEFGabcdefg])([\'\,]*)",note)
transp = float(transp)
quinte = int(transp)
oktave = int( 100 * ( 0.0001 + abs(int(transp)-transp) ) ) - 50
vorz = m.group(1)
notename = m.group(2)
noteokt = m.group(3)
if notename.lower() == notename:
notename = notename.upper()
noteokt = "'" + noteokt
notenr = { "F":-1,"C":0,"G":1,"D":2,"A":3,"E":4,"B":5 }[m.group(2).upper()]
notenr_tr = (notenr + quinte) % 7
notename_tr = "CGDAEBF"[notenr_tr]
vorz_tr = vorz + "^" * ((notenr + quinte + 1) / 7) + "_" * ( 0 - ((notenr + quinte + 1) / 7) )
vorz_tr = re.sub(r"=","",vorz_tr,99)
if int("0516273"[notenr_tr]) < int("0516273"[notenr]):
oktave = oktave + 1
noteokt_tr = noteokt + "'" * oktave + "," * (-oktave)
if notename_tr == notename_tr.upper() and len(re.sub(r"\'","",noteokt_tr,99)) < len(re.sub(r",","",noteokt_tr,99)):
notename_tr = notename_tr.lower()
noteokt_tr = "," + noteokt_tr
while 0 == 0:
m = re.search(r"^(.*)(\^_|_\^)(.*)$",vorz_tr)
if not m:
break
vorz_tr = m.group(1) + m.group(3)
while 0 == 0:
m = re.search(r"^(.*)(\'\,|\,\')(.*)$",noteokt_tr)
if not m:
if re.search(r"(\'\,|\,\')",noteokt):
noteokt_tr = noteokt_tr0
break
noteokt_tr0 = noteokt_tr
noteokt_tr = m.group(1) + m.group(3)
if vorz == "":
vorz_tr = ""
else:
if vorz_tr == "":
vorz_tr = "="
return( vorz_tr + notename_tr + noteokt_tr )
#********************************************************************
def xxexpand (self,pars):
text0 = codecs.open(sys.argv[1],"r","utf-8").read()
text = re.sub(r"V:XX ","V:A_,T_,C1,C2,C3,C4,Fl,Tr,Sx,Co,Ps,Bk,1_,2_,3_,4_,5_,Pc",text0,9999999)
#text = re.sub(r"\nI: +","\nI:",text0,99999999,re.DOTALL)
while 0 == 0:
m = re.search(r"^(.*?\n)(V:)([a-zA-Z0-9\_]+,[a-zA-Z0-9\_,]+)(.*?)\n(.*?I: *\n)(.*)$",text,re.DOTALL)
if not m:
break
text = m.group(1)
for o in m.group(3).split(","):
o1 = re.sub(r"\_$"," ",o)
o1 = re.sub(r"\_$"," ",o1)
o1 = re.sub(r"\_$"," ",o1)
if not ("V:" + o1) in m.group(5):
text = text + "V:" + o1 + m.group(4) + "\n"
text = text + m.group(5) + m.group(6)
# print text
open("yyy.abc","w").write(text)
os.system("abcm2ps yyy.abc -j 0 -O " + re.sub(r"\.abc$","",sys.argv[1]) + ".ps")
#********************************************************************
def xxsc0 (self,pars):
text = open(pars[0]).read()
text1 = text
voices_written = {}
for zeile in text:
if zeile[0:2] == "I:":
voices_written = {}
m = re.search(r"^(V\:)(\S+)(.*)$",zeile)
if m.group(2) == "-":
for voice in voices:
print voice
# if zeile[0:2] == "I:":
# voices = {}
# voices_cons = {}
#********************************************************************
def xxsc1 (self,pars):
text = open(pars[0]).read()
voices = {}
voices_cons = {}
onelines = {}
voiceseries = []
text1 = ""
voices_in_akko = {}
for zeile in text.split("\n"):
m = re.search(r"^V:([A-Za-z0-9\_]+) ",zeile)
if m:
try:
onelines[m.group(1)]
except:
onelines[m.group(1)] = ""
voiceseries.append(m.group(1))
if re.search(r"^(I\: *|\s*|\%[^\%].*)$",zeile):
continue
m = re.search(r"^V\:(-|[A-Z0-9a-z\_]+) (.*)(\||::)(.*)$",zeile)
if m:
if m.group(1) == "-":
for voice in voiceseries:
if not voices_in_akko[voice]:
onelines[voice] += m.group(2) + m.group(3) + m.group(4)
else:
onelines[m.group(1)] += m.group(2) + m.group(3) + m.group(4)
voice0 = m.group(1)
vcount = 0
m = re.search(r"w: (.*)(\||::)(.*)$",zeile)
else:
voice = voice0
try:
onelines[m.group(1)]
except:
onelines[m.group(1)] = ""
voiceseries.append(m.group(1))
text1 = text1 + zeile + "\n"
for voice in voiceseries:
text1 = text1 + "V:" + voice + " \n" + onelines[voice] + "\n"
print text1