Python Timeline.add方法代码示例

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
def singlebeat(beat, *args, **kwargs):
    beat_timeline = Timeline()
    time = 0.0
    beat_timeline.add(time+0.0, beat)

    print "Rendering beat audio..."
    beat_data = beat_timeline.render()

    return beat_data

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
def singlenote(note_number, *args, **kwargs):
    singlenote_timeline = Timeline()
    time = 0.0 # Keep track of currect note placement time in seconds

    # Strum out root chord to finish
    chord = kwargs['progression'][0]
    singlenote_timeline.add(time + 0.0, Hit(chord.notes[note_number], 3.0))

    print "Rendering singlenote audio..."
    singlenote_data = singlenote_timeline.render()

    return singlenote_data

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
def playchords(imu):
    
    key = Note('E3')
    scale = Scale(key, 'harmonic minor')
    progression = Chord.progression(scale, base_octave=key.octave)
    time = 0.0
    timeline = Timeline()    
    chord = progression[0]
    
    d = 3.0 #length of time (seconds)
    chords = [Hit(chord.notes[0], d), Hit(chord.notes[1], d), Hit(chord.notes[2], d), Hit(chord.notes[0], d)]
        
    amp = 0.25 #Amplitude
    thrd = None
    
    while True: 
        timeline = Timeline()
        acc = imu.getacc()
        #print "acc is {}".format(acc)
        
        ax, ay, az = acc
        if ax > 1.5:
            timeline.add(0.0, chords[0])
        elif ax < -1.5:
            timeline.add(0.0, chords[1])
        if ay > 1.5:
            timeline.add(0.0, chords[2])
        elif ay < -1.5:
            timeline.add(0.0, chords[3])
    
        data = timeline.render() * amp
        
        if thrd == None or not thrd.isAlive():
            thrd = threading.Thread(target=play, args=(data,))
            thrd.start()

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
def arpeggio(*args, **kwargs):

    arpeggio_timeline = Timeline()
    time = 0.0 # Keep track of currect note placement time in seconds

    # Add progression to timeline by arpeggiating chords from the progression
    for index in [0, 1]:
      chord = kwargs['progression'][index]
      root, third, fifth = chord.notes
      arpeggio = [root, third, fifth, third, root, third, fifth, third]
      for i, interval in enumerate(arpeggio):
        ts = float(i * 2) / len(arpeggio)
        arpeggio_timeline.add(time + ts, Hit(interval, 1.0))
      time += 2.0

    print "Rendering arpeggio audio..."
    arpeggio_data = arpeggio_timeline.render()

    return arpeggio_data

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
def strum(*args, **kwargs):
    strum_timeline = Timeline()
    time = 0.0 # Keep track of currect note placement time in seconds

    # Strum out root chord to finish
    chord = kwargs['progression'][0]
    strum_timeline.add(time + 0.0, Hit(chord.notes[0], 4.0))
    strum_timeline.add(time + 0.1, Hit(chord.notes[1], 4.0))
    strum_timeline.add(time + 0.2, Hit(chord.notes[2], 4.0))
    strum_timeline.add(time + 0.3, Hit(chord.notes[1].transpose(12), 4.0))
    strum_timeline.add(time + 0.4, Hit(chord.notes[2].transpose(12), 4.0))
    strum_timeline.add(time + 0.5, Hit(chord.notes[0].transpose(12), 4.0))

    print "Rendering strum audio..."
    strum_data = strum_timeline.render()

    return strum_data

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
# Grab progression chords from scale starting at the octave of our key
progression = Chord.progression(scale, base_octave=key.octave)

time = 0.0 # Keep track of currect note placement time in seconds

timeline = Timeline()

# Add progression to timeline by arpeggiating chords from the progression
for index in [0, 2, 3, 1,    0, 2, 3, 4,    5, 4, 0]:
  chord = progression[index]
  root, third, fifth = chord.notes
  arpeggio = [root, third, fifth, third, root, third, fifth, third]
  for i, interval in enumerate(arpeggio):
    ts = float(i * 2) / len(arpeggio)
    timeline.add(time + ts, Hit(interval, 1.0))
  time += 2.0

# Strum out root chord to finish
chord = progression[0]
timeline.add(time + 0.0, Hit(chord.notes[0], 4.0))
timeline.add(time + 0.1, Hit(chord.notes[1], 4.0))
timeline.add(time + 0.2, Hit(chord.notes[2], 4.0))
timeline.add(time + 0.3, Hit(chord.notes[1].transpose(12), 4.0))
timeline.add(time + 0.4, Hit(chord.notes[2].transpose(12), 4.0))
timeline.add(time + 0.5, Hit(chord.notes[0].transpose(12), 4.0))

print "Rendering audio..."

data = timeline.render()

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
    def get (self, request):

        ##############################
        # check overlaps of intervals, uniqueness identified via the column : 
        overlapchecks = [ (PersonZusage, 'person'),
                          (Fachgebiet, 'kuerzel'),
                          (Stelle, 'stellennummer'),
                          (StellenwertigkeitIntervalle, 'wertigkeit'),
                          (Zuordnung, 'stelle'), 
                          (Besetzung, 'stelle'), 
                        ]
        overlapmsg = []

        for o in overlapchecks:
            # print o[0]
            for k in o[0].objects.values(o[1]).distinct().all():

                qs = o[0].objects.filter (**{ o[1] + '__exact':   k[o[1]]})
                violationList= self.check_overlap (qs, o[1])


                if violationList:

                    violationURLs =  [ (urlresolvers.reverse ('admin:stellenplan_' +
                                                              o[0].__name__.lower()  + '_change', args=(v[0],)),
                                        urlresolvers.reverse ('admin:stellenplan_' +
                                                              o[0].__name__.lower()  + '_change', args=(v[1],)),
                                        qs.get(id=v[0]).__unicode__(),
                                        qs.get(id=v[1]).__unicode__(),
                                        )
                                        for v in violationList ]

                    overlapmsg.append({'module_name': o[0].__name__,
                                       'field': o[1].capitalize(),
                                       'violationUrls': violationURLs})
        #print overlapmsg 

        ##############################

        # Konsistenz der Verknuepfungen: Teilmengen der intervalkle müssen eingehalten werden 
        # Klasse: von -bis muss Teilintervall des foreign keys sein 

        teilintervallbeziehungen = [(Zusage, "fachgebiet"),
                                    (Zuordnung, "fachgebiet"),
                                    (Zuordnung, "stelle"),
                                    # (Besetzung, "person"),
                                    (Besetzung, "stelle"),
                                    ]


        teilintervallkonflikte =  filter (lambda x: x[2],
                        [(tib[0].__name__, tib[1].capitalize(),
                    [ ( urlresolvers.reverse ('admin:stellenplan_' +
                                            tib[0].__name__.lower() + '_change',
                                            args = (entry.pk,)),
                      urlresolvers.reverse ('admin:stellenplan_' +
                                             getattr (entry, tib[1]).__class__.__name__.lower() + '_change',
                                             args = (getattr (entry, tib[1]).pk,)),
                      entry.__unicode__(),
                      getattr (entry, tib[1]).__unicode__()
                      )
                      for entry in tib[0].objects.all()
                      if not (( entry.von >= getattr (entry, tib[1]).von ) and
                              ( entry.von <= getattr (entry, tib[1]).bis ) and
                              ( entry.bis >= getattr (entry, tib[1]).von ) and
                              ( entry.bis <= getattr (entry, tib[1]).bis ) )
                      ])
                for tib in teilintervallbeziehungen ]
                )



        ##############################


        # Wurden stellen mehrfach besetzt? use following backwords:
        # https://docs.djangoproject.com/en/dev/topics/db/queries/#backwards-related-objects


        besetzungStelleKonflikt = []
        zuordnungStelleKonflikt = []

        for stelle in Stelle.objects.all():

            ## print "----" 
            ## print "Stelle: ", stelle

            tlBesetzung = Timeline()
            besetzungenDieserStelle = stelle.besetzung_set.all()
            for bes in besetzungenDieserStelle: 
                tlBesetzung.add (bes.von, bes.bis, bes.prozent)


            tlZuordnung = Timeline()
            zuordnungenDieserStelle = stelle.zuordnung_set.all()
            for zu in zuordnungenDieserStelle: 
                tlZuordnung.add (zu.von, zu.bis, zu.prozent)


            conflictsBesetzung = tlBesetzung.aboveThreshold(stelle.prozent)
#.........这里部分代码省略.........

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]
timeline = Timeline()

note = key

# Semi-randomly queue notes from the scale
for i in xrange(64):
  if note.index > 50 or note.index < 24:
    # If note goes out of comfort zone, randomly place back at base octave
    note = scale.get(random.randrange(4) * 2)
    note = note.at_octave(key.octave)
  else:
    # Transpose the note by some small random interval
    note = scale.transpose(note, random.choice((-2, -1, 1, 2)))
  length = random.choice((0.125, 0.125, 0.25))
  timeline.add(time, Hit(note, length + 0.125))
  time += length

# Resolve
note = scale.transpose(key, random.choice((-1, 1, 4)))
timeline.add(time, Hit(note, 0.75))     # Tension
timeline.add(time + 0.5, Hit(key, 4.0)) # Resolution

print "Rendering audio..."

data = timeline.render()

print "Applying chorus effect..."

data = effect.chorus(data, freq=3.14159)

# 需要导入模块: from timeline import Timeline [as 别名]
# 或者: from timeline.Timeline import add [as 别名]

#.........这里部分代码省略.........
    dice_roll = random.choice([1,2,3,4,5])
  else:
    dice_roll = random.choice([1,2,3,4,5,6])

  if (dice_roll < 5 and _debug <> 1):
    print "Going back to sleep"
    sys.exit()

  # We're alive, import what else we need now
  sys.path.append(os.path.join(os.path.dirname(__file__), 'python-musical'))

  from musical.theory import Note, Scale, Chord
  from musical.audio import effect, playback

  from timeline import Hit, Timeline

  # Define key and scale
  key = Note((random.choice(Note.NOTES), random.choice([2,3,3])))

  scales = ['major', 'minor', 'melodicminor', 'harmonicminor', 'pentatonicmajor', 'bluesmajor', 'pentatonicminor', 'bluesminor', 'augmented', 'diminished', 'wholehalf', 'halfwhole', 'augmentedfifth', 'japanese', 'oriental', 'ionian', 'phrygian', 'lydian', 'mixolydian', 'aeolian', 'locrian']
  scale = Scale(key, random.choice(scales))

  print key
  print scale

  # Grab progression chords from scale starting at the octave of our key
  progression = Chord.progression(scale, base_octave=key.octave)

  time = 0.0 # Keep track of currect note placement time in seconds

  timeline = Timeline()

  # Pick a notes from a chord randomly chosen from a list of notes in this progression
  chord = progression[ random.choice(range(len(progression)-1)) ]
  notes = chord.notes

  melodies = [
    [1.0, 0.1, 0.2, 0.1, 0.2, 0.10, 0.1],
    [0.8, 0.1, 0.1, 0.2],
    [0.8, 0.4, 0.1, 0.2, 0.4, 0.1, 0.2],
    [0.8, 0.4, 0.4, 0.2, 0.2, 0.1, 0.1],
    [0.4, 0.0, 0.1, 0.1, 0.2, 0, 0.1, 0.4],
    [0.1, 0.1, 0.1, 0.0, 0.2, 0.0, 0.1, 0.2, 0.4],
    [0.8, 0.4, 0.1, 0.4, 0.2, 0.2, 0.1, 0.2, 0.8, 0.1, 0.4, 0.1],
    [0.2, 0.2, 0.4, 0.2, 0.1, 0.1, 0.0, 0.2],
    [1.0, 0.1, 0.2, 0.1, 0.2, 0.2],
    [0.2, 0.1, 0.2, 0.4, 0.1, 0.2, 0.4],
    [0.4, 0.1, 0.4, 0.2, 0.4, 0.1, 0.4, 0.2],
    [0.1, 0.1, 0.1, 0.2, 0.1, 0.1, 0.2],
    [0.1, 0.1, 0.1, 0.2, 0.1, 0.1, 0.1, 0.2, 0.0],
    [0.1, 0.0, 0.1, 0.0, 0.1, 0.0, 0.2, 0.0, 0.2, 0.0, 0.1, 0.1, 0.3],
  ]

  random_melody = random.choice(melodies)
  print random_melody

  last_interval = 0.0
  last_transpose = 0

  for i, interval in enumerate(random_melody):
    random_note = random.choice(notes)

    # the first note should be high
    # identical intervals should often hold the same pitch
    # otherwise, pick a random pitch
    if i == 0:
      random_transpose = random.choice([8, 12])
    elif (last_interval == interval):
      if random.choice([0,1,2]) == 2:
        random_transpose = last_transpose
      else:
        random_transpose = 0
    else:
      random_transpose = random.choice([0, 2,4,6,8,10,12])

    last_interval = interval
    last_transpose = random_transpose

    note = random_note.transpose(random_transpose)
    #print note

    # favour queued notes, but occasionally overlap them too
    if (random.choice([1,2,3,4,5,6]) > 2):
      time = time + interval
      timeline.add(time, Hit(note, interval))
    else:
      timeline.add(time, Hit(note, interval))
      time = time + interval

  print "Rendering audio..."
  data = timeline.render()

  # Reduce volume to 95%
  data = data * 0.95

  print "Playing audio..."
  for i in range(random.choice([1,2])):
    playback.play(data)

  print "Done!"