def populate(trackNum, track): eventsDict = { 'trackNum': None, 'allEvents': [], 'f': [], '8': [], '9': [], 'a': [], 'b': [], 'c': [], 'd': [], 'e': [], } #searches through the track string looking for meta and midi events. #A new object is created for each event found and stored in the dict #eventsDict. ######################### #Event class definitions# ######################### #There is a different class for each type of midi or meta event. Each class #has a print_properties() method which prints the properties of the event #and a collapse() method which collapses the event object back into a string #and returns it. #Midi events can be in running mode (indicated by runningMode == True, #this will result in the event type being omitted from the collapsed string. class MetaEvent(object): def __init__(self, listLength, d, eventType, t, l, data, trackNum): self.id = listLength self.deltaTime = d self.type = 'meta' self.eventType = eventType self.metaType = t self.length = l self.data = data self.runningMode = '' self.cumulativeDeltaTime = cumulativeDeltaTime self.realTime = None self.trackNum = trackNum def __repr__(self): return "(%d) MetaEvent %d\n" % (self.trackNum, self.id) + \ "deltaTime: %s\n" % self.deltaTime + \ "cum delta time: %d\n" % self.cumulativeDeltaTime + \ "metaType: %s\n" % self.metaType + \ "length: %s\n" % self.length + \ "data: %s\n\n" % self.data def __cmp__(self, other): if hasattr(other, 'cumulativeDeltaTime'): return (self.cumulativeDeltaTime).__cmp__( other.cumulativeDeltaTime) def collapse(self): collapsed = (self.deltaTime + self.eventType + self.metaType + self.length + self.data) return collapsed class NoteEvent(object): def __init__(self, listLength, d, eventType, noteNumber, velocity, runningMode, trackNum): self.id = listLength self.deltaTime = d self.type = 'note' self.eventType = eventType self.noteNumber = noteNumber self.velocity = velocity self.runningMode = runningMode self.cumulativeDeltaTime = cumulativeDeltaTime self.realTime = None self.trackNum = trackNum def __repr__(self): return "(%d) NoteEvent %d\n" % (self.trackNum, self.id) + \ "deltaTime: %s\n" % self.deltaTime + \ "cum delta time: %d\n" % self.cumulativeDeltaTime + \ "eventType: %s\n" % self.eventType + \ "noteNumber: %s\n" % self.noteNumber + \ "velocity: %s\n" % self.velocity + \ "runningMode: %s\n\n" % self.runningMode def __cmp__(self, other): if hasattr(other, 'cumulativeDeltaTime'): return (self.cumulativeDeltaTime).__cmp__( other.cumulativeDeltaTime) def collapse(self): collapsed = self.deltaTime if self.runningMode == False: collapsed = ''.join([collapsed, self.eventType]) collapsed = ''.join([collapsed, self.noteNumber, self.velocity]) return collapsed class CcEvent(object): def __init__(self, listLength, d, eventType, contNum, newVal, runningMode, trackNum): self.id = listLength self.deltaTime = d self.type = 'cc' self.eventType = eventType self.contNum = contNum self.newVal = newVal self.runningMode = runningMode self.cumulativeDeltaTime = cumulativeDeltaTime self.realTime = None self.trackNum = trackNum def __repr__(self): return "(%d) CcEvent %d\n" % (self.trackNum, self.id) + \ "deltaTime: %s\n" % self.deltaTime + \ "cum delta time: %d\n" % self.cumulativeDeltaTime + \ "eventType: %s\n" % self.eventType + \ "contNumber: %s\n" % self.contNum + \ "new value: %s\n" % self.newVal + \ "runningMode: %s\n\n" % self.runningMode def __cmp__(self, other): if hasattr(other, 'cumulativeDeltaTime'): return (self.cumulativeDeltaTime).__cmp__( other.cumulativeDeltaTime) def collapse(self): collapsed = self.deltaTime if self.runningMode == False: collapsed = ''.join([collapsed, self.eventType]) collapsed = ''.join([collapsed, self.contNum, self.newVal]) return collapsed class PcEvent(object): def __init__(self, listLength, d, eventType, newProgNum, runningMode, trackNum): self.id = listLength self.deltaTime = d self.type = 'pc' self.eventType = eventType self.newProgNum = newProgNum self.runningMode = runningMode self.cumulativeDeltaTime = cumulativeDeltaTime self.realTime = None self.trackNum = trackNum def __repr__(self): return "(%d) PcEvent %d\n" % (self.trackNum, self.id) + \ "deltaTime: %s\n" % self.deltaTime + \ "cum delta time: %d\n" % self.cumulativeDeltaTime + \ "eventType: %s\n" % self.eventType + \ "new prog number: %s\n" % self.newProgNum + \ "runningMode: %s\n\n" % self.runningMode def __cmp__(self, other): if hasattr(other, 'cumulativeDeltaTime'): return (self.cumulativeDeltaTime).__cmp__( other.cumulativeDeltaTime) def collapse(self): collapsed = self.deltaTime if self.runningMode == False: collapsed = ''.join([collapsed, self.eventType]) collapsed = ''.join([collapsed, self.newProgNum]) return collapsed class AtEvent(object): def __init__(self, listLength, d, eventType, channelNum, runningMode, trackNum): self.id = listLength self.deltaTime = d self.type = 'at' self.eventType = eventType self.channelNum = channelNum self.runningMode = runningMode self.cumulativeDeltaTime = cumulativeDeltaTime self.realTime = None self.trackNum = trackNum def __repr__(self): return "(%d) AtEvent %d\n" % (self.trackNum, self.id) + \ "deltaTime: %s\n" % self.deltaTime + \ "cum delta time: %d\n" % self.cumulativeDeltaTime + \ "eventType: %s\n" % self.eventType + \ "channel number: %s\n" % self.channelNum + \ "runningMode: %s\n\n" % self.runningMode def __cmp__(self, other): if hasattr(other, 'cumulativeDeltaTime'): return (self.cumulativeDeltaTime).__cmp__( other.cumulativeDeltaTime) def collapse(self): collapsed = self.deltaTime if self.runningMode == False: collapsed = ''.join([collapsed, self.eventType]) collapsed = ''.join([collapsed, self.channelNum]) return collapsed class PwcEvent(object): def __init__(self, listLength, d, eventType, bottom, top, runningMode, trackNum): self.id = listLength self.deltaTime = d self.type = 'pwc' self.eventType = eventType self.bottom = bottom self.top = top self.runningMode = runningMode self.cumulativeDeltaTime = cumulativeDeltaTime self.realTime = None self.trackNum = trackNum def __repr__(self): return "(%d) PwcEvent %d\n" % (self.trackNum, self.id) + \ "deltaTime: %s\n" % self.deltaTime + \ "cum delta time: %d\n" % self.cumulativeDeltaTime + \ "eventType: %s\n" % self.eventType + \ "bottom: %s\n" % self.bottom + \ "top: %s\n" % self.top + \ "runningMode: %s\n\n" % self.runningMode def __cmp__(self, other): if hasattr(other, 'cumulativeDeltaTime'): return (self.cumulativeDeltaTime).__cmp__( other.cumulativeDeltaTime) def collapse(self): collapsed = self.deltaTime if self.runningMode == False: collapsed = ''.join([collapsed, self.eventType]) collapsed = ''.join([collapsed, self.bottom + self.top]) return collapsed ############################################################################### ##################################### #Event object instantiation functions# ##################################### #These functions create a new object for every midi or meta event found. #They return the newly created object and advance the counter (i) by the #correct amount for that object and return it. #If an event is in running mode, the counter will be advanced by 2 less #than otherwise. def pop_meta_events(i, d, eventType, track, runningMode, trackNum): dataEnd = 6 + 2 * int(functions.return_range(track, i, 4, 6), 16) metaEvent = MetaEvent(len(eventsDict[eventType[0]]), d, eventType, functions.return_range(track, i, 2, 4), functions.return_range(track, i, 4, 6), functions.return_range(track, i, 6, dataEnd), trackNum) i += dataEnd return (i, metaEvent) def pop_note_events(i, d, eventType, track, runningMode, trackNum): adj = functions.return_adjustment(runningMode) #NoteEvent(listLength, d, eventType, noteNumber, velocity, runningMode, trackNum) noteEvent = NoteEvent( len(eventsDict[eventType[0]]), d, eventType, functions.return_range(track, i, (2 + adj), (4 + adj)), functions.return_range(track, i, (4 + adj), (6 + adj)), runningMode, trackNum) i += (6 + adj) return (i, noteEvent) def pop_cc_events(i, d, eventType, track, runningMode, trackNum): adj = functions.return_adjustment(runningMode) ccEvent = CcEvent( len(eventsDict[eventType[0]]), d, eventType, functions.return_range(track, i, (2 + adj), (4 + adj)), functions.return_range(track, i, (4 + adj), (6 + adj)), runningMode, trackNum) i += (6 + adj) return (i, ccEvent) def pop_pc_events(i, d, eventType, track, runningMode, trackNum): adj = functions.return_adjustment(runningMode) pcEvent = PcEvent( len(eventsDict[eventType[0]]), d, eventType, functions.return_range(track, i, (2 + adj), (4 + adj)), runningMode, trackNum) i += (4 + adj) return (i, pcEvent) def pop_at_events(i, d, eventType, track, runningMode, trackNum): adj = functions.return_adjustment(runningMode) atEvent = AtEvent( len(eventsDict[eventType[0]]), d, eventType, functions.return_range(track, i, (2 + adj), (4 + adj)), runningMode, trackNum) i += (4 + adj) return (i, atEvent) def pop_pwc_events(i, d, eventType, track, runningMode, trackNum): adj = functions.return_adjustment(runningMode) pwcEvent = PwcEvent( len(eventsDict[eventType[0]]), d, eventType, functions.return_range(track, i, (2 + adj), (4 + adj)), functions.return_range(track, i, (4 + adj), (6 + adj)), runningMode, trackNum) i += (6 + adj) return (i, pwcEvent) ############################################################################### i = 0 def event_decider(i, d, track, eventType, eventBuffer, runningMode, trackNum): #This if statement decides which function to call based on eventType #which is the byte (two characters) after the delta-time bytes. It also #decides if the event is in running mode and if so, sets the #runningMode boolean to True. if int(eventType, 16) < 128: #if eventType is less than 0x80 (128 in base 10) then the status #byte of the event must have been omitted, the event is in running #mode and takes the value of the status byte of the event before it. runningMode = True i, d, eventBuffer = event_decider(i, d, track, eventBuffer, eventBuffer, runningMode, trackNum) elif eventType == 'ff': #meta event i, event = pop_meta_events(i, d, eventType, track, runningMode, trackNum) eventBuffer = pop_eventsDict(event, eventType) runningMode = False elif eventType[0] in ['8', '9', 'a']: #note event i, event = pop_note_events(i, d, eventType, track, runningMode, trackNum) eventBuffer = pop_eventsDict(event, eventType) runningMode = False elif eventType[0] == 'b': #control change i, event = pop_cc_events(i, d, eventType, track, runningMode, trackNum) eventBuffer = pop_eventsDict(event, eventType) runningMode = False elif eventType[0] == 'c': #program change i, event = pop_pc_events(i, d, eventType, track, runningMode, trackNum) eventBuffer = pop_eventsDict(event, eventType) runningMode = False elif eventType[0] == 'd': #channel after-touch i, event = pop_at_events(i, d, eventType, track, runningMode, trackNum) eventBuffer = pop_eventsDict(event, eventType) runningMode = False elif eventType[0] == 'e': #pitch wheel change i, event = pop_pwc_events(i, d, eventType, track, runningMode, trackNum) eventBuffer = pop_eventsDict(event, eventType) runningMode = False elif eventType[0] == 'f' and eventType[1] != 'f': #system common events, these should not be found in midi files print "fx event found" else: print "This shouldn't have happened." return (i, d, eventBuffer) def pop_eventsDict(event, eventType): eventsDict[eventType[0]].append(event) eventsDict['allEvents'].append(event) return eventType eventBuffer = '' runningMode = False eventsDict['trackNum'] = trackNum cumulativeDeltaTime = 0 while i < functions.check_length(track): #takes account of the variable length of the delta time portion. i, d = functions.get_delta_time(i, track) cumulativeDeltaTime += d #print "Cumulative Delta Time: ", cumulativeDeltaTime, "Delta Time: " eventType = functions.get_event_type(i, track) i, d, eventBuffer = event_decider(i, d, track, eventType, eventBuffer, runningMode, trackNum) return eventsDict
parser.add_argument('-m', '--model', required=False, help=("Name of" "the folder with the model.")) parser.add_argument('--algorithm', required=False, help=("The " "algorith used to classify the RSS. By default all are used."), choices=('RIC', 'rRIC', 'CROSSED', 'REC'), default='REC') args = parser.parse_args() algorithm = args.algorithm #Getting rec folder base_folder = os.path.dirname(os.path.realpath(__file__)) #Check length of the sequence length = functions.check_length(args.test) #Get model data if args.model == None: model = os.path.join(os.path.join(base_folder, "Data"), "base_model_" + str(length)) else: model = args.model data = pickle.load(open(os.path.join(model, "data"))) #Tranform data if algorithm == "CROSSED": crossed_test = functions.convert_crossed(filename = args.test, length = length, output = "test_crossed_" + args.output,
parser.add_argument('-o', '--output', required=True, help='Name of the folder with the model.') parser.add_argument('-f', '--features', required=False, help='Feature file to use.') parser.add_argument('-e', '--extra', required=False, help='For RSS 28 the extra nucleotide to use in the end.', default='T') #Get all the arguments args = parser.parse_args() #Getting rec folder base_folder = os.path.dirname(os.path.realpath(__file__)) #Check length of the sequence length = functions.check_length(args.positive) #Define output unique element unique = args.output #Get extra extra = args.extra #Check if output folder exists and remove if os.path.exists(unique): shutil.rmtree(unique) os.mkdir(unique) #Convert input files to RIC format ric_positives = functions.convert_ric(