light9: flax/curvecalc comparison

comparison flax/curvecalc @ 202:97e21bc387fe

loading and saving loading and saving fixed the hanging bug in update()

author	drewp
date	Wed, 16 Jun 2004 14:22:48 +0000
parents	f5d3492981ab
children	3905d3c92aaa

comparison

equal deleted inserted replaced

-:e4a711d9a338
+:97e21bc387fe
 """
 todo: curveview should preserve more objects, for speed maybe
 """
 from __future__ import division
-import xmlrpclib,time,socket,sys,textwrap,math
+import xmlrpclib,time,socket,sys,textwrap,math,glob
 from bisect import bisect_left,bisect,bisect_right
 import Tkinter as tk
 from dispatch import dispatcher
 from twisted.internet import reactor,tksupport
 from twisted.web.xmlrpc import Proxy
 """curve does not know its name. see Curveset"""
 points = None # x-sorted list of (x,y)
 def __init__(self):
 self.points = []
-self.points = [(0,0),(1,1),(9,1),(10,0)]
+def load(self,filename):
-for x in range(11,500):
+for line in file(filename):
-self.points.append((x,.5))
+self.points.append(tuple([float(a) for a in line.split()]))
+self.points.sort()
+dispatcher.send("points changed",sender=self)
+def save(self,filename):
+f = file(filename,'w')
+for p in self.points:
+f.write("%s %s\n" % p)
+f.close()
 def eval(self,t):
 i = bisect_left(self.points,(t,None))-1
 if self.points[i][0]>t:
 self.selected_points=[] # idx of points being dragged
 self.update()
 self.bind("<Enter>",self.focus)
 dispatcher.connect(self.input_time,"input time")
 dispatcher.connect(self.update,"zoom changed")
+dispatcher.connect(self.update,"points changed",sender=self.curve)
 self.bind("<Configure>",self.update)
 def screen_from_world(self,p):
 start,end = self.zoom
 ht = self.winfo_height()
 return (p[0]-start)/(end-start)*self.winfo_width(), (ht-5)-p[1]*(ht-10)
 self.world_from_screen(self.winfo_width(),0)[0])
 visleftidx = max(0,bisect_left(cp,(visible_x[0],None))-1)
 visrightidx = min(len(cp)-1,bisect_left(cp,(visible_x[1],None))+1)
-visible_points = cp[visleftidx:visrightidx]
+visible_points = cp[visleftidx:visrightidx+1]
 self.delete('curve')
 linepts=[]
 for p in visible_points:
 linepts.extend(self.screen_from_world(p))
+if not linepts:
+return
 line = self.create_line(*linepts,**{'tags':'curve'})
 # canvas doesnt have keyboard focus, so i can't easily change the
 # cursor when ctrl is pressed
 #        def curs(ev):
 #            print ev.state
 #        self.bind("<KeyPress>",curs)
 #        self.bind("<KeyRelease-Control_L>",lambda ev: curs(0))
 self.tag_bind(line,"<Control-ButtonPress-1>",self.newpoint)
 self.dots = {} # idx : canvas rectangle
-if len(visible_points)<50: ###self.zoom[1]-self.zoom[0]<30 or len(visible_points)<:
+if len(visible_points)<50:
 for i,p in enumerate(visible_points):
 rad=3
 p = self.screen_from_world(p)
-#            if p[0]-prevx<10:
-#                # too close- skip the dots
-#                continue
 dot = self.create_rectangle(p[0]-rad,p[1]-rad,p[0]+rad,p[1]+rad,
 outline='black',fill='blue',
 tags=('curve','point'))
 self.tag_bind(dot,"<ButtonPress-1>",
 lambda ev,i=i: self.dotpress(ev,i))
 def dotmotion(self,ev,dotidx):
 cp = self.curve.points
 moved=0
 for idx in self.selected_points:
-newp = self.world_from_screen(ev.x,ev.y)
+x,y = self.world_from_screen(ev.x,ev.y)
-if idx>0 and newp[0]<=cp[idx-1][0]:
+y = max(0,min(1,y))
+if idx>0 and x<=cp[idx-1][0]:
 continue
-if idx<len(cp)-1 and newp[0]>=cp[idx+1][0]:
+if idx<len(cp)-1 and x>=cp[idx+1][0]:
 continue
 moved=1
-cp[idx] = newp
+cp[idx] = (x,y)
 if moved:
 self.update()
 def unselect(self):
 self.selected_points=[]
 self.highlight_selected_dots()
 class Curveset:
 curves = None # curvename : curve
 def __init__(self):
 self.curves = {}
+def load(self,basename):
+"""find all files that look like basename-curvename and add
+curves with their contents"""
+for filename in glob.glob("%s-*"%basename):
+curvename = filename[filename.rfind('-')+1:]
+c=Curve()
+c.load(filename)
+self.add_curve(curvename,c)
+def save(self,basename):
+"""writes a file for each curve with a name
+like basename-curvename"""
+for name,cur in self.curves.items():
+cur.save("%s-%s" % (basename,name))
 def add_curve(self,name,curve):
 self.curves[name] = curve
 dispatcher.send("add_curve",sender=self,name=name)
 def globalsdict(self):
 return self.curves.copy()
 def current_time(self):
 """return deferred which gets called with the current time"""
 if self.player is None:
 self.player = Proxy("http://spot:8040")
 d = self.player.callRemote("songlength")
-def sendmax(l):
+d.addCallback(lambda l: dispatcher.send("max time",maxtime=l))
-dispatcher.send("max time",maxtime=l)
+d = self.player.callRemote("songname")
-d.addCallback(sendmax)
+d.addCallback(lambda n: dispatcher.send("songname",name=n))
 d = self.player.callRemote('gettime')
 def sendtime(t):
 dispatcher.send("input time",val=t)
 return t # pass along to the real receiver
 def error(e):
 scaledsubs.append(scl)
 out = Submaster.sub_maxes(*scaledsubs)
 dispatcher.send("output levels",val=out.get_levels())
 dmxclient.outputlevels(out.get_dmx_list(),twisted=1)
-def statuslines(master):
+def create_status_lines(master):
 for signame,textfilter in [
 ('input time',lambda t: "%.2fs"%t),
 ('output levels',
 lambda levels: textwrap.fill("; ".join(["%s:%.2f"%(n,v)
 for n,v in
 l.pack(side='top',fill='x')
 dispatcher.connect(lambda val,l=l,sn=signame,tf=textfilter:
 l.config(text=sn+": "+tf(val)),
 signame,weak=0)
+def savesubterms(filename,subterms):
+f = file(filename,'w')
+for st in subterms:
+f.write("%s %s\n" % (st.sub.name,st.subexpr.expr))
+f.close()
+def save(song,subterms,curveset):
+savesubterms("subterms/"+song,subterms)
+curveset.save(basename="curves/"+song)
 #######################################################################
 root=tk.Tk()
 root.wm_geometry("790x930")
 #root.tk_focusFollowsMouse()
-m=Music()
+music=Music()
 zc = Zoomcontrol(root)
 zc.pack(side='top',fill='x')
-cs = Curveset()
+curveset = Curveset()
-csv = Curvesetview(root,cs)
+csv = Curvesetview(root,curveset)
 csv.pack(side='top',fill='both',exp=1)
-for loop in range(6):
+song = "16mix.wav"
-cs.add_curve('c'+str(loop+1),Curve())
+curveset.load(basename="curves/"+song)
 subterms = []
-for subname in "zip_orange","zip_red":
+for line in file("subterms/"+song):
+subname,expr = line.strip().split(" ",1)
-se = Subexpr(cs)
-if subname=='zip_orange':
+term = Subterm()
-se.expr="c1(t)+c2(t)+c3(t)+c4(t)+c5(t)"
+sexpr = Subexpr(curveset)
+sexpr.expr = expr
-st=Subterm()
+term.sub = Submaster.Submaster(subname)
-st.sub=Submaster.Submaster(subname)
+term.subexpr = sexpr
-st.subexpr=se
+subterms.append(term)
-stv=Subtermview(root,st)
+stv=Subtermview(root,term)
 stv.pack(side='top',fill='x')
-subterms.append(st)
 out = Output(subterms)
-statuslines(root)
+#save(song,subterms,curveset)
+create_status_lines(root)
 recent_t=[]
+later = None
 def update():
-d = m.current_time()
+global later
+d = music.current_time()
 d.addCallback(update2)
 d.addErrback(updateerr)
 def updateerr(e):
-reactor.callLater(1,update)
+global later
+print "err",e
+if later and not later.cancelled and not later.called: later.cancel()
+later = reactor.callLater(1,update)
 def update2(t):
-global recent_t
+global recent_t,later
-reactor.callLater(.001,update)
+if later and not later.cancelled and not later.called: later.cancel()
+later = reactor.callLater(.01,update)
 recent_t = recent_t[-50:]+[t]
 period = (recent_t[-1]-recent_t[0])/len(recent_t)
 dispatcher.send("update period",val=period)
 out.send_dmx(t)

Mercurial > code > home > repos > light9

comparison flax/curvecalc @ 202:97e21bc387fe