cv2.putText(a, ZOOM_LEVELS[zoom_idx], (10, 20), cv2.FONT_HERSHEY_PLAIN, 1, (255,255,255))

if ZOOM_LEVELS[zoom_idx] == 'structure':

structure_video(a)

elif ZOOM_LEVELS[zoom_idx] == 'rhythm':

rhythm_video(a)

else:

global audio_frame

segarr = getplayarr()

if segarr is None:

return

segarr = segarr[audio_frame:]

if len(segarr) < len(a):

a[:len(segarr)] = segarr

audio_advance()

return audio_out(a[len(segarr):])

a[:] = segarr[:len(a)]

if ZOOM_LEVELS[zoom_idx] == 'sound':

s = getplayseg()

if s is None:

return

return tape.getArray()[s.st_idx:s.end_idx]

else:

global playseg, audio_frame, rhythm_square, structure_rhythm_idx, rhythm_array

audio_frame = 0

if ZOOM_LEVELS[zoom_idx] == 'structure':

rhythms = composition.rhythms

if len(rhythms) == 0:

rhythm_array = None

return

structure_rhythm_idx = (1 + structure_rhythm_idx) % len(rhythms)

rhythm_square = rhythms[structure_rhythm_idx]

rhythm_change()

elif ZOOM_LEVELS[zoom_idx] == 'sound':

if sound_page_idx >= len(sound_pages) or len(sound_pages[sound_page_idx]) == 0:

print 'warning: big sound_page_idx', sound_page_idx, len(sound_pages)

return

segs = sound_pages[sound_page_idx]

N = int(np.ceil(np.sqrt(len(segs))))

w,h = (int(320/N), int(240/N))

for i,s in enumerate(segs):

x,y = ((i%N)*w, (i/N)*h)

color = (0,75,0)

if tape.isUsed(s):

color = (255,0,0)

elif sound_idx == i:

color = (0,255,0)

elif s in sound_selection:

color = (0,255,255)

a[y:y+h,x:x+w] += color

cv2.putText(a, 'page %d(%d)' % (sound_page_idx, len(sound_pages)), (10, 220), cv2.FONT_HERSHEY_PLAIN, 1, (255,255,0))

nsquares = len(composition.rhythms)

N = int(np.ceil(np.sqrt(nsquares)))

if N > 0:

w,h = 320/N, 240/N

for idx,square in enumerate(composition.rhythms):

x= w*(idx %N)

y= h*(int(idx/N))

global rhythm_sequence, audio_frame, rhythm_array

audio_frame = 0

if len(rhythm_square.groups) > 0:

rhythm_change()

else:

rhythm_sequence = None

global rhythm_array, rhythm_sequence, audio_frame

print 'rhythm_change'

rhythm_sequence = rhythm_square.getArrangement().getSequencePreview().segs

#rhythm_array = rhythm_square.getArrangement().getArray(tape)

rhythm_array = rhythm_square.getArrangement().getSequencePreview().getArray(tape)

if audio_frame > len(rhythm_array):

groups = square.groups

arrangement = square.getArrangement()

timings = arrangement.timings

duration = square.getDuration()

def get_timing(seg):

for t,s in timings.items():

if seg == s:

return t

curseg = getseg()

ngroups = len(groups)

if ngroups == 0:

return

h = a.shape[0] / ngroups

w = a.shape[1]

for idx,segs in enumerate(groups):

y = idx * h

if square.isFill(idx):

percent = sum([x.duration for x in segs]) / duration

h2 = int(h * percent)

a[y+h-h2:y+h] += (255,0,255)

continue

for s in segs:

st = get_timing(s)

end = st + s.duration

x1 = int(st*w/duration)

x2 = int(end*w/duration)

color = (0,200,0)

a[y:y+h,x1:x2] += color

if rhythm_square == square:

a[:,int(a.shape[1] * (audio_frame / float(len(rhythm_array))))] += (255,0,0)

tx = range(w)

ty = [int(a.shape[0]*square.getTone(X/float(w))) for X in tx]

a[ty,tx] += (0,0,255)

for px,py in square._tones.items():

x = int(px*w)

y = int(py*a.shape[0])

print 'keyboard_in', type, button

if button == 's':

composition.save(comppath)

if ZOOM_LEVELS[zoom_idx] == 'structure':

structure_keys(type, button)

elif ZOOM_LEVELS[zoom_idx] == 'rhythm':

rhythm_keys(type, button)

else:

global zoom_idx, rhythm_square, structure_rhythm_idx

r_idx = 0

nsquares = len(composition.rhythms)

if nsquares > 0:

N = int(np.ceil(np.sqrt(nsquares)))

r_idx = min(len(composition.rhythms)-1, int(mousex * N) + int(mousey * N) * N)

print 'sk on', r_idx, len(composition.rhythms)

if type == 'key-press':

if button == 'n':

rhythm_square = Square()

rhythm_init()

composition.append(rhythm_square)

zoom_idx = ZOOM_LEVELS.index('rhythm')

elif button == 'e':

print 'export'

out = np.concatenate([X.getArrangement().getArray(tape) for X in composition.rhythms])

numm.np2sound(out, 'export.wav')

elif button == 'x':

print 'delete', r_idx

if len(composition.rhythms) == 0:

return

rhy = composition.rhythms.pop(r_idx)

for i,g in enumerate(rhy.groups):

rhy.remove(i)

for s in g:

tape.unuse(s)

if rhy == rhythm_square:

rhythm_square = None

audio_advance()

elif button == 'c':

rhythm_square = composition.rhythms[r_idx]

rhythm_init()

zoom_idx = ZOOM_LEVELS.index('rhythm')

elif button == 'Left':

rhy = composition.rhythms.pop(r_idx)

n_idx = max(0, r_idx-1)

composition.rhythms.insert(n_idx, rhy)

elif button == 'Right':

rhy = composition.rhythms.pop(r_idx)

n_idx = max(len(composition.rhythms), r_idx+1)

composition.rhythms.insert(n_idx, rhy)

elif button == 'd':

print 'DUPLICATE'

rhy = composition.rhythms[r_idx]

dupe = Square()

dupe._fills = rhy._fills.copy()

dupe._tones = rhy._tones.copy()

dupe.theta = rhy.theta

for g in rhy.groups:

newg = []

for s in g:

news = tape.getNearUnsed(s)

tape.use(news)

newg.append(news)

dupe.append(newg)

composition.append(dupe)

elif button == 'space':

structure_rhythm_idx = r_idx - 1

global zoom_idx, rhythm_twisting, rhythm_toning

if type == 'key-press':

if button == 'n':

sound_init()

zoom_idx = ZOOM_LEVELS.index('sound')

elif button == 'r':

# rhythm_square.setTheta(mousex)

# rhythm_change()

rhythm_twisting = True

elif button == 't':

rhythm_square.addTone(mousex, mousey)

rhythm_change()

# rhythm_toning = True

elif button == 'Escape':

if len(rhythm_square.groups) == 0:

composition.rhythms.remove(rhythm_square)

structure_init()

zoom_idx = ZOOM_LEVELS.index('structure')

elif type == 'key-release':

if button == 'r':

rhythm_twisting = False

rhythm_change()

if button == 't':

rhythm_toning = False

global structure_rhythm_idx, audio_frame, rhythm_square

audio_frame = 0

structure_rhythm_idx = 0

if len(composition.rhythms) == 0:

return

rhythm_square = composition.rhythms[structure_rhythm_idx]

global sound_page_idx, sound_idx, sound_order_idx

if type == 'key-press':

try:

i = int(button)

sound_page_idx = i

sound_idx = 0

return

except ValueError:

pass

if button == 'c':

sound_order_idx = SOUND_ORDERINGS.index('cluster')

elif button == 'm':

sound_order_idx = SOUND_ORDERINGS.index('similarity')

elif button == 't':

sound_order_idx = SOUND_ORDERINGS.index('time')

elif button == 'o':

sound_order_idx = SOUND_ORDERINGS.index('closeness')

if button in 'cmto':

global mousex, mousey

mousex = px

mousey = py

# print type, px, py, button

if ZOOM_LEVELS[zoom_idx] == 'sound':

sound_mouse(type, px, py, button)

elif ZOOM_LEVELS[zoom_idx] == 'rhythm':

global sound_order_idx, sound_page_idx, sound_idx

sound_order_idx = 0

sound_idx = 0

sound_page_idx = 0

global sound_pages, sound_page_idx

print 'start paginate'

curseg = getseg()

if curseg:

print 'curseg', curseg.start, curseg.idx

sound_pages = []

sound_page_idx = 0

if SOUND_ORDERINGS[sound_order_idx] == 'time':

print 'order by time'

segs = tape.getSegments()

segs.sort(cmp=lambda x,y: int(44100*(x.start-y.start)))

npages = 10

npp = len(segs) / npages

for i in range(npages):

psegs = segs[i*npp:(i+1)*npp]

sound_pages.append(psegs)

if curseg and curseg in psegs:

print 'curseg in timepage', i

sound_page_idx = i

elif SOUND_ORDERINGS[sound_order_idx] == 'cluster':

clusters = tape.getClusters()

for idx,(k,v) in enumerate(sorted(clusters.items())):

sound_pages.append(v)

if curseg and curseg in v:

print 'curseg in cluster', idx

sound_page_idx = idx

elif SOUND_ORDERINGS[sound_order_idx] == 'similarity':

similarity_tape = Tape(tape.path, nbins=9)

base = curseg

nsegs = min(len(similarity_tape.getSegments()), 100)

page = []

sound_pages.append(page)

while len(page) < nsegs:

cluster,idx = similarity_tape.getClosestUnused(base)

base = similarity_tape.getClusters()[cluster][idx]

similarity_tape.use(base)

page.append(base)

else:

# closeness

base = curseg

page = []

ordered = tape.orderBySegment(base)

sound_pages.append(ordered[:100])

global rhythm_sequence

ngroups = len(rhythm_square.groups)

g_idx = int(py * ngroups)

if type == 'mouse-button-press' and ngroups > 0:

if button == 1:

if rhythm_square.isFill(g_idx):

rhythm_square.removeFill(g_idx)

else:

rhythm_square.addFill(g_idx)

rhythm_change()

elif button == 3:

print "delete", g_idx

group = rhythm_square.remove(g_idx)

for s in group:

tape.unuse(s)

if rhythm_twisting:

# XXX: relative motion!

rhythm_square.setTheta(px)

rhythm_sequence = rhythm_square.getArrangement().getSequencePreview().segs

elif rhythm_toning:

global sound_idx, sound_dragging, sound_selection, sound_dragging_first, zoom_idx, playseg, audio_frame

nsegs = len(sound_pages[sound_page_idx])

N = int(np.ceil(np.sqrt(nsegs)))

_oidx = sound_idx

sound_idx = min(nsegs-1, int(px*N) + N*int(py*N))

if type == 'mouse-button-press':

sound_selection = []

sound_dragging = True

sound_dragging_first = sound_pages[sound_page_idx][sound_idx]

if type == 'mouse-move' and sound_dragging:

sound_make_selection()

if type == 'mouse-button-release':

# Add selection to the rhythm

sound_dragging = False

sound_make_selection()

rhythm_square.append(sound_selection)

for seg in sound_selection:

tape.use(seg)

rhythm_init()

zoom_idx = ZOOM_LEVELS.index('rhythm')

sound_selection = []

if (_oidx != sound_idx) or (playseg is None):

audio_frame = 0

global sound_selection

spage = sound_pages[sound_page_idx]

sound_selection = []

st = min(spage.index(sound_dragging_first), sound_idx)

end = max(spage.index(sound_dragging_first), sound_idx) + 1

for idx in range(st,end):

if not tape.isUsed(spage[idx]):