def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer(("localhost", 11661))
self.server.timeout = 0
self.server.handle_timeout = types.MethodType(handle_timeout,
self.server)
self.server.addMsgHandler("/setcolors", self.set_colors)
self.server.addMsgHandler("/poop", self.whatever)
self.server.addMsgHandler("/reloadconfig", self.reload_config)
while True:
self.each_frame()
self.server.close()
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.addMsgHandler( "/setcolors", self.set_colors)
self.server.addMsgHandler( "/poop", self.whatever)
self.server.addMsgHandler( "/reloadconfig", self.reload_config)
while True:
self.each_frame()
self.server.close()
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer(("localhost", 11661))
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout,
self.server)
self.server.lastpixels = [(0, 0, 0)] * MAX_LIGHTS
self.layers = {}
self.activepid = 0
self.lastclear = time.time()
self.lastwriteany = 0
self.streamer = StreamPoster()
self.streamer.start()
self.server.addMsgHandler("/setcolors", self.set_colors)
while True:
self.each_frame()
self.server.close()
class ColorsIn:
# this method of reporting timeouts only works by convention
# that before calling handle_request() field .timed_out is
# set to False
def set_colors(self,path, tags, args, source):
# which user will be determined by path:
# we just throw away all slashes and join together what's left
#print "Here's what we got : path:%s tags:%s args:%s source:%s"%(str(path),str(tags),str(args),str(source))
pixels = []
for i in range(0,len(args)/3):
pixel = (clamp(args[i*3]), clamp(args[i*3+1]), clamp(args[i*3+2]))
pixels.append( pixel )
#print "Pixels: %s"%str(pixels)
#print "Time: "+str((time.time()*1000) % 10000)
octoapi.write(pixels)
self.lastwrite=time.time()
self.server.lastpixels = pixels
def diff_colors(self, path, tags, args, source):
# which user will be determined by path:
# we just throw away all slashes and join together what's left
#print "Here's what we got : path:%s tags:%s args:%s source:%s"%(str(path),str(tags),str(args),str(source))
pixels = server.lastpixels
for i in range(0,len(args)/3):
pp = (args[i*3],args[i*3+1],args[i*3+2])
p = pixels[i]
pixels[i] = (clamp(p[0]+pp[0]), clamp(p[1]+pp[1]), clamp(p[2]+pp[2]))
#print "Pixels: %s"%str(pixels)
#print "Time: "+str((time.time()*1000) % 10000)
octoapi.write(pixels)
self.lastwrite=time.time()
self.server.lastpixels = pixels
def each_frame(self):
self.server.timed_out = False
while not self.server.timed_out:
if time.time() - self.lastwrite > CLEAR_TIME:
self.lastwrite = time.time()
octoapi.write([(0,0,0)]*24)
print "Clearing"
self.server.handle_request()
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.lastpixels = [(0,0,0)]*24
self.server.addMsgHandler( "/setcolors", self.set_colors)
self.server.addMsgHandler( "/diffcolors", self.diff_colors)
while True:
self.each_frame()
self.server.close()
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.lastpixels = [(0,0,0)]*24
self.server.addMsgHandler( "/setcolors", self.set_colors)
self.server.addMsgHandler( "/diffcolors", self.diff_colors)
while True:
self.each_frame()
self.server.close()
class ColorsIn:
def set_colors(self, path, tags, args, source):
try:
chroma = ChromaMessage.fromOSC(tags, args)
octoapi.write(chroma.data)
#in any case, we slowly fade out every stream remaining
#this also writes to the device
#mark the last time we got a packet
except:
import traceback
traceback.print_exc()
def each_frame(self):
self.server.timed_out = False
while not self.server.timed_out:
#self.handleClearing()
self.server.handle_request()
def reload_config(self, path, tags, args, source):
octoapi.reload_config()
def whatever(self, path, tags, args, source):
pass
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer(("localhost", 11661))
self.server.timeout = 0
self.server.handle_timeout = types.MethodType(handle_timeout,
self.server)
self.server.addMsgHandler("/setcolors", self.set_colors)
self.server.addMsgHandler("/poop", self.whatever)
self.server.addMsgHandler("/reloadconfig", self.reload_config)
while True:
self.each_frame()
self.server.close()
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.lastpixels = [(0,0,0)]*MAX_LIGHTS
self.layers = {}
self.activepid = 0
self.lastclear = time.time()
self.lastwriteany = 0
self.streamer = StreamPoster()
self.streamer.start()
self.server.addMsgHandler( "/setcolors", self.set_colors)
while True:
self.each_frame()
self.server.close()
class ColorsIn:
def set_colors(self,path, tags, args, source):
try:
chroma = ChromaMessage.fromOSC(tags,args)
octoapi.write(chroma.data)
#in any case, we slowly fade out every stream remaining
#this also writes to the device
#mark the last time we got a packet
except:
import traceback
traceback.print_exc()
def each_frame(self):
self.server.timed_out = False
while not self.server.timed_out:
#self.handleClearing()
self.server.handle_request()
def reload_config(self, path, tags, args, source):
octoapi.reload_config()
def whatever(self, path, tags, args, source):
pass
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.addMsgHandler( "/setcolors", self.set_colors)
self.server.addMsgHandler( "/poop", self.whatever)
self.server.addMsgHandler( "/reloadconfig", self.reload_config)
while True:
self.each_frame()
self.server.close()
class ColorsIn:
#measured in seconds to fade in 100%
fadeoutrate = 4.0
fadeinrate = 4.0
bootthreshold = 0.01
maxlayers = 3
def set_colors(self,path, tags, args, source):
try:
chroma = ChromaMessage.fromOSC(tags,args)
#if we have no records of any streams:
#if we have a record of a current stream, and no record of this stream:
if not self.activepid or chroma.pid not in self.layers:
self.activepid = chroma.pid
#mark all other layers as fading out
for pid in self.layers:
self.layers[pid].state = Layer.FADEOUT
self.layers[chroma.pid] = Layer(chroma, 0, Layer.FADEIN)
self.lastwriteany = time.time() - 1/30.0 #force this frame to fade in at the target framerate: 30fps
self.layers[chroma.pid].chroma = chroma
#in any case, we slowly fade out every stream remaining
#this also writes to the device
self.updateStream()
#mark the last time we got a packet
self.lastwrite=time.time()
except:
import traceback
traceback.print_exc()
"""
applies fadeout rules to any stream not the main one
and writes to the device
"""
def updateStream(self):
for layer in self.layers.values():
self.applyFadingRules(layer)
if len(self.layers) > ColorsIn.maxlayers:
self.layers = dict( (k, v) for k,v in self.layers.iteritems() if self.shouldWeKeepLayer(v) )
#apply our opacity rules
pixels = self.applyOpacity(self.layers.values())
if not STAGING:
self.streamer.pixels = pixels
self.streamer.metadata = self.layers[self.activepid].chroma
#pixels = self.crazyMofoingReorderingOfLights(pixels)
octoapi.write(pixels)
if DEBUG:
for layer in self.layers.values():
print "PID: %d, OPACITY: %f"%(layer.chroma.pid, layer.opacity)
self.lastwriteany=time.time()
def shouldWeKeepLayer(self,layer):
if layer.state == Layer.FADEOUT and layer.opacity < self.bootthreshold:
return False
return True
def applyFadingRules(self,layer):
diff = time.time() - self.lastwriteany
print diff
fadein = (1.0/ColorsIn.fadeinrate) * diff
fadeout = (1.0/ColorsIn.fadeoutrate) * diff
if layer.state == Layer.FADEIN:
layer.opacity += fadein
if layer.state == Layer.FADEOUT:
layer.opacity -= fadeout
layer.opacity = clampv(0,layer.opacity,1)
return layer
"""
compresses down the entire list and gives us the final result
"""
def applyOpacity(self,layers):
data = [(0.0,0.0,0.0)] * len(layers[0].chroma.data)
for layer in layers:
data = [sum(currentvalue,mult(value,layer.opacity)) for currentvalue,value in itertools.izip(data,layer.chroma.data)]
data = [clampColor(value) for value in data]
return data
def handleClearing(self):
if time.time() - self.lastwrite > CLEAR_TIME and time.time() - self.lastclear > 1/30.0:
#print "CLEARING! %f"%time.time()
self.activepid = 0
for layer in self.layers.values(): layer.state = Layer.FADEOUT
shouldweupdate = False
#don't bother updating if we're below the threshold. not often anyway.
for layer in self.layers.values():
if layer.opacity > self.bootthreshold:
shouldweupdate = True
if shouldweupdate:
self.updateStream()
else:
if not STAGING:
octoapi.write([(0,0,0)]*MAX_LIGHTS)
if DEBUG:
print "CLEARED! %f"%time.time()
self.lastclear = time.time()
def each_frame(self):
self.server.timed_out = False
while not self.server.timed_out:
self.handleClearing()
self.server.handle_request()
def crazyMofoingReorderingOfLights(self, pixels):
pixels2 = pixels[:] #make a copy so we don't kerplode someone's work
"""
what are we expecting? we want the back left (by the couches) of the room to be pixel 0,
and by the front is the last row
whereas in reality, it's the opposite.
here is the order it'd be nice to have them in:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
20 21 22 23
this is the actual order:
23 22 21 20
19 16 17 18
15 14 13 12
11 10 9 8
3 2 5 4
6 *0**1**7* *=not there
"""
actualorder = [23,22,21,20,19,16,17,18,15,14,13,12,11,10,9,8,3,2,5,4,6,0,1,7]
badcolors = [] #3,2,5,4,6,0,1,7]
for i in range(len(actualorder)):
(r,g,b) = pixels[i]
r = max(0.0, min(r, 1023.0))
g = max(0.0, min(g, 1023.0))
b = max(0.0, min(b, 1023.0))
pixels2[actualorder[i]] = (r,g,b)
for i in range(len(badcolors)):
pixels2[badcolors[i]] = (0.0,0.0,0.0)
return pixels2
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.lastpixels = [(0,0,0)]*MAX_LIGHTS
self.layers = {}
self.activepid = 0
self.lastclear = time.time()
self.lastwriteany = 0
self.streamer = StreamPoster()
self.streamer.start()
self.server.addMsgHandler( "/setcolors", self.set_colors)
while True:
self.each_frame()
self.server.close()
leds = LEDStrip(args.kind, args.width * args.height, args.freq, args.gpio,
args.dma, args.channel, args.strip, args.invert,
args.bright, args.gamma, args.debug)
except RuntimeError:
if os.geteuid() != 0:
print("Unable to initialise LED strip, you probably need to run with sudo")
raise SystemExit()
else:
raise
controller = Controller(args.width, args.height, args.period, leds, args.debug)
loop = asyncio.get_event_loop()
def cleanup():
loop.stop()
if args.clear:
if args.debug:
print()
leds.clear()
print("\nQuitting...")
loop.add_signal_handler(signal.SIGINT, cleanup)
loop.add_signal_handler(signal.SIGTERM, cleanup)
print('Press Ctrl-C to quit')
server = OSCServer(controller.handler, args.port, args.ip)
try:
loop.run_forever()
finally:
loop.close()
from osc import OSCMessage, OSCBundle, OSCClient, OSCServer
message = OSCMessage(address='/message/address')
# argument can be string, int, float, bool and binary
message.add('Some text argument')
message.add(3)
message.add(0.75)
message.add(True)
# create osc bundle and add a message
bundle = OSCBundle()
bundle.add(message)
# create client and send to 127.0.0.1:8000
client = OSCClient('127.0.0.1', 8000)
client.send(message)
client.send(bundle)
# bind server and listen for incoming messages at 127.0.0.1:8000
server = OSCServer('127.0.0.1', 8000)
server.serve_forever()
class ColorsIn:
#measured in seconds to fade in 100%
fadeoutrate = 4.0
fadeinrate = 4.0
bootthreshold = 0.01
maxlayers = 3
def set_colors(self,path, tags, args, source):
try:
chroma = ChromaMessage.fromOSC(tags,args)
#if we have no records of any streams:
#if we have a record of a current stream, and no record of this stream:
if not self.activepid or chroma.pid not in self.layers:
self.activepid = chroma.pid
#mark all other layers as fading out
for pid in self.layers:
self.layers[pid].state = Layer.FADEOUT
self.layers[chroma.pid] = Layer(chroma, 0, Layer.FADEIN)
self.lastwriteany = time.time() - 1/30.0 #force this frame to fade in at the target framerate: 30fps
self.layers[chroma.pid].chroma = chroma
#in any case, we slowly fade out every stream remaining
#this also writes to the device
self.updateStream()
#mark the last time we got a packet
self.lastwrite=time.time()
except:
import traceback
traceback.print_exc()
"""
applies fadeout rules to any stream not the main one
and writes to the device
"""
def updateStream(self):
for layer in self.layers.values():
self.applyFadingRules(layer)
if len(self.layers) > ColorsIn.maxlayers:
self.layers = dict( (k, v) for k,v in self.layers.iteritems() if self.shouldWeKeepLayer(v) )
#apply our opacity rules
pixels = self.applyOpacity(self.layers.values())
if not STAGING:
octoapi.write(pixels)
if DEBUG:
for layer in self.layers.values():
print "PID: %d, OPACITY: %f"%(layer.chroma.pid, layer.opacity)
self.lastwriteany=time.time()
def shouldWeKeepLayer(self,layer):
if layer.state == Layer.FADEOUT and layer.opacity < self.bootthreshold:
return False
return True
def applyFadingRules(self,layer):
diff = time.time() - self.lastwriteany
print diff
fadein = (1.0/ColorsIn.fadeinrate) * diff
fadeout = (1.0/ColorsIn.fadeoutrate) * diff
if layer.state == Layer.FADEIN:
layer.opacity += fadein
if layer.state == Layer.FADEOUT:
layer.opacity -= fadeout
layer.opacity = clampv(0,layer.opacity,1)
return layer
"""
compresses down the entire list and gives us the final result
"""
def applyOpacity(self,layers):
data = [(0.0,0.0,0.0)] * len(layers[0].chroma.data)
for layer in layers:
data = [sum(currentvalue,mult(value,layer.opacity)) for currentvalue,value in itertools.izip(data,layer.chroma.data)]
data = [clampColor(value) for value in data]
return data
def handleClearing(self):
if time.time() - self.lastwrite > CLEAR_TIME and time.time() - self.lastclear > 1/30.0:
#print "CLEARING! %f"%time.time()
self.activepid = 0
for layer in self.layers.values(): layer.state = Layer.FADEOUT
shouldweupdate = False
#don't bother updating if we're below the threshold. not often anyway.
for layer in self.layers.values():
if layer.opacity > self.bootthreshold:
shouldweupdate = True
if shouldweupdate:
self.updateStream()
else:
if not STAGING:
octoapi.write([(0,0,0)]*24)
if DEBUG:
print "CLEARED! %f"%time.time()
self.lastclear = time.time()
def each_frame(self):
self.server.timed_out = False
while not self.server.timed_out:
self.handleClearing()
self.server.handle_request()
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer( ("localhost", 11661) )
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
self.server.lastpixels = [(0,0,0)]*24
self.layers = {}
self.activepid = 0
self.lastclear = time.time()
self.lastwriteany = 0
self.server.addMsgHandler( "/setcolors", self.set_colors)
while True:
self.each_frame()
self.server.close()
def main():
args = parse_args()
level = args.verbose and logging.DEBUG or logging.INFO
config = load_config()
video_buffer.operator = config.get('operator', 'add')
video_buffer.add_effect('clear', fx.Clear, enabled=config.get('clear', True))
video_buffer.add_effect('background', fx.BackGround, color=[0, 0, 0], enabled=config.get('background', False))
video_buffer.add_effect('fade', fx.FadeBackGround, enabled=config.get('fade', False))
# video_buffer.add_effect('midi_note_spark_1', fx.MidiNoteSpark, nrange=(300,420), enabled=config.get('midi_note_spark_1', False))
# video_buffer.add_effect('midi_note_spark_2', fx.MidiNoteSpark, nrange=(0,150), enabled=config.get('midi_note_spark_2', False))
# video_buffer.add_effect('midi_note_spark_3', fx.MidiNoteSpark, nrange=(150,300), enabled=config.get('midi_note_spark_3', False))
# video_buffer.add_effect('strobe', fx.Strobe, enabled=config.get('strobe', False))
video_buffer.add_effect('noise', fx.Noise, enabled=config.get('noise', False))
video_buffer.add_effect('wave', fx.Wave, enabled=config.get('wave', False))
video_buffer.add_effect('creamsicle', fx.Creamsicle, enabled=config.get('creamsicle', False))
# note_ranges = ((260,320), (300,340), (340,380), (380,420), (0,40),(40,80),(80,120),(120,160),)
# note_ranges = ((340, 380), (340,420), (340,380), (380,420), (0,40),(40,80),(80,120),(120,160),)
# note_ranges = ((0,0), (300,420),)
# for i, note_range in enumerate(note_ranges):
# name = 'midi_note'+str(i)
# video_buffer.add_effect(name, fx.MidiNote, nrange=note_range, enabled=config.get(name, False))
video_buffer.add_effect('midi_note', fx.MidiNote, nrange=(.5,0.8), enabled=config.get('midi_note', False))
# video_buffer.add_effect('pointX', fx.PointFx, nrange=(360,420), enabled=True)
# video_buffer.add_effect('pointY', fx.PointFx, nrange=(360,420), enabled=True)
# video_buffer.add_effect('pointZ', fx.PointFx, nrange=(360,420), enabled=True)
video_buffer.add_effect('scanner', fx.LarsonScanner, enabled=config.get('scanner', True), scanners=[
{'p1': .9,'p2': .98, 'width': .025, 'color': (.8,.1,0.05)},
{'p1': .6,'p2': .65, 'width': .015, 'color': (.1,.8,.05)},
{'p1': .3,'p2': .4, 'width': .015, 'color': (.04,.2,1)},
{'p1': .02,'p2': .1, 'width': .015, 'color': (1,.8,0)},
])
# video_buffer.add_effect('peak_meter', fx.PeakMeter, enabled=config.get('peak_meter', False), meters=(
# {'n1': 60, 'n2': 120, 'reverse': True, 'color': (1,.5,0)},
# {'n1': 120, 'n2': 160, 'reverse': False, 'color': (1,.5,0)},
# {'n1': 160, 'n2': 214, 'reverse': True, 'color': (1,.5,0)},
# {'n1': 214, 'n2': 260, 'reverse': False, 'color': (1,.5,0)},
# {'n1': 260, 'n2': 332, 'reverse': True, 'color': (1,.5,0)},
# {'n1': 332, 'n2': 380, 'reverse': False, 'color': (1,.5,0)},
# {'n1': 320, 'n2': 420, 'reverse': True, 'color': (1,.5,0)},
# {'n1': 0, 'n2': 100, 'reverse': False, 'color': (1,.5,0)},
# ))
# video_buffer.add_effect('convolution', fx.Convolution, enabled=config.get('convolution', False))
video_buffer.add_effect('yb&rgp', fx.YellowBlackAndRedGreenPurple, enabled=config.get('yb&rgp', False))
video_buffer.add_effect('matrix', fx.Matrix, enabled=config.get('matrix', False))
video_buffer.add_effect('camera_rot', fx.CameraRot, enabled=config.get('camera_rot', False))
def toggle_fx(addr, state):
logging.info(f"toggling : {addr} : {state}")
x,y = map(lambda x: int(x)-1, addr.split('/')[2:])
i = x + 7*y
fx = list(video_buffer.effects.values())[i]
logging.info(fx)
fx.toggle()
osc_maps = [
('/metronome', video_buffer.effects['scanner'].metronome),
# ('/audio/envelope', video_buffer.effects['peak_meter'].envelope),
('/midi/note', video_buffer.effects['midi_note'].set),
('/q', video_buffer.effects['fade'].set), # /fade or /fader cause bugs in touchosc, awesome
('/color/r', functools.partial(video_buffer.effects['background'].set, color='r')),
('/color/g', functools.partial(video_buffer.effects['background'].set, color='g')),
('/color/b', functools.partial(video_buffer.effects['background'].set, color='b')),
('/brightness', video_buffer.set_brightness),
('/gamma', video_buffer.set_gamma),
('/operator/*', video_buffer.set_operator, True),
('/fx/*', toggle_fx),
('/*', osc_logger)
]
console_coros = ()
if args.no_console:
log.configure_logging(level=level)
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
else:
osc_maps.append(('/*', console.osc_recv))
log.configure_logging(level=level, queue_handler=True)
console_coros = console.init(video_buffer)
osc_server = OSCServer(
maps = osc_maps,
server_address = (args.ip, args.port)
)
serial_comms.init(video_buffer)
coros = (
osc_server.serve(),
idle(),
*console_coros,
websocket_server.serve(video_buffer)
# input_audio_stream(functools.partial(callback_video_buffer, video_buffer=video_buffer))
)
try:
loop = asyncio.get_event_loop()
loop.set_exception_handler(exception_handler)
loop.run_until_complete(main_loop(coros))
except (KeyboardInterrupt, CancelledError, UserQuit) as e:
print("have a great day")
except MainLoopError as e:
print("whooops")
finally:
loop.close()
save_config()
def main():
args = parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
# effects['background'] = fx.BackGround(video_buffer, color='')
video_buffer.add_effect("fade", fx.FadeBackGround, q=2, enabled=False)
video_buffer.add_effect("strobe", fx.Strobe, enabled=False)
video_buffer.add_effect("noise", fx.Noise, enabled=False)
video_buffer.add_effect("wave", fx.Wave, enabled=True)
video_buffer.add_effect("midi_note", fx.MidiNote, range=(300, 420), enabled=False)
# add_effect('pointX'] = fx.PointFx(video_buffer, range=(360,420))
# add_effect('pointY'] = fx.PointFx(video_buffer)
# add_effect('pointZ'] = fx.PointFx(video_buffer)
video_buffer.add_effect("scanner", fx.LarsonScanner, enabled=False, scanners=scanners(10))
video_buffer.add_effect(
"peak_meter",
fx.PeakMeter,
enabled=True,
meters=(
{"n1": 320, "n2": 420, "reverse": True, "color": (1, 0.5, 0)},
{"n1": 0, "n2": 100, "reverse": False, "color": (0, 0.5, 1)},
),
)
video_buffer.add_effect("brightness", fx.Brightness, level=0.4, enabled=True)
video_buffer.add_effect("convolution", fx.Convolution, enabled=False)
# midi_thread = threading.Thread(target=midi.main,kwargs={'q':midi_queue})
# midi_thread.daemon = True
# midi_thread.start()
loop = asyncio.get_event_loop()
console.init(loop, video_buffer)
websocket_server.serve(loop, video_buffer)
serial_comms.init(loop, video_buffer)
osc_server = OSCServer(
loop=loop,
maps=(
("/metronome", video_buffer.effects["scanner"].metronome),
("/metronome", video_buffer.effects["strobe"].metronome),
("/audio/envelope", video_buffer.effects["peak_meter"].envelope),
("/midi/note", video_buffer.effects["midi_note"].set),
# ('/accxyz', functools.partial(accxyz, axis=0, point=effects['pointX'])),
# ('/1/fader1', effects['background'].red),
# ('/1/fader2', effects['background'].green),
# ('/1/fader3', effects['background'].blue),
("/*", osc_logger),
),
forward=(websocket_server.osc_recv,),
server_address=(args.ip, args.port),
)
osc_server.serve()
try:
loop.run_forever()
except KeyboardInterrupt:
logging.info("keyboard int")
finally:
loop.close()
class ColorsInSucks:
#measured in seconds to fade in 100%
fadeoutrate = 4.0
fadeinrate = 4.0
bootthreshold = 0.01
maxlayers = 3
def set_colors(self, path, tags, args, source):
try:
chroma = ChromaMessage.fromOSC(tags, args)
#if we have no records of any streams:
#if we have a record of a current stream, and no record of this stream:
if not self.activepid or chroma.pid not in self.layers:
self.activepid = chroma.pid
#mark all other layers as fading out
for pid in self.layers:
self.layers[pid].state = Layer.FADEOUT
self.layers[chroma.pid] = Layer(chroma, 0, Layer.FADEIN)
self.lastwriteany = time.time(
) - 1 / 30.0 #force this frame to fade in at the target framerate: 30fps
self.layers[chroma.pid].chroma = chroma
#in any case, we slowly fade out every stream remaining
#this also writes to the device
self.updateStream()
#mark the last time we got a packet
self.lastwrite = time.time()
except:
import traceback
traceback.print_exc()
"""
applies fadeout rules to any stream not the main one
and writes to the device
"""
def updateStream(self):
for layer in self.layers.values():
self.applyFadingRules(layer)
if len(self.layers) > ColorsIn.maxlayers:
self.layers = dict((k, v) for k, v in self.layers.iteritems()
if self.shouldWeKeepLayer(v))
#apply our opacity rules
pixels = self.applyOpacity(self.layers.values())
if not STAGING and self.activepid:
self.streamer.pixels = pixels
self.streamer.metadata = self.layers[self.activepid].chroma
#pixels = self.crazyMofoingReorderingOfLights(pixels)
octoapi.write(pixels)
if DEBUG:
for layer in self.layers.values():
print "PID: %d, OPACITY: %f" % (layer.chroma.pid,
layer.opacity)
self.lastwriteany = time.time()
def shouldWeKeepLayer(self, layer):
if layer.state == Layer.FADEOUT and layer.opacity < self.bootthreshold:
return False
return True
def applyFadingRules(self, layer):
diff = time.time() - self.lastwriteany
print diff
fadein = (1.0 / ColorsIn.fadeinrate) * diff
fadeout = (1.0 / ColorsIn.fadeoutrate) * diff
if layer.state == Layer.FADEIN:
layer.opacity += fadein
if layer.state == Layer.FADEOUT:
layer.opacity -= fadeout
layer.opacity = clampv(0, layer.opacity, 1)
return layer
"""
compresses down the entire list and gives us the final result
"""
def applyOpacity(self, layers):
data = [(0.0, 0.0, 0.0)] * len(layers[0].chroma.data)
for layer in layers:
data = [
sum(currentvalue, mult(value, layer.opacity))
for currentvalue, value in itertools.izip(
data, layer.chroma.data)
]
data = [clampColor(value) for value in data]
return data
def handleClearing(self):
if time.time() - self.lastwrite > CLEAR_TIME and time.time(
) - self.lastclear > 1 / 30.0:
#print "CLEARING! %f"%time.time()
self.activepid = 0
for layer in self.layers.values():
layer.state = Layer.FADEOUT
shouldweupdate = False
#don't bother updating if we're below the threshold. not often anyway.
for layer in self.layers.values():
if layer.opacity > self.bootthreshold:
shouldweupdate = True
if shouldweupdate:
self.updateStream()
else:
if not STAGING:
octoapi.write([(0, 0, 0)] * MAX_LIGHTS)
if DEBUG:
print "CLEARED! %f" % time.time()
self.lastclear = time.time()
def each_frame(self):
self.server.timed_out = False
while not self.server.timed_out:
self.handleClearing()
self.server.handle_request()
def crazyMofoingReorderingOfLights(self, pixels):
pixels2 = pixels[:] #make a copy so we don't kerplode someone's work
"""
what are we expecting? we want the back left (by the couches) of the room to be pixel 0,
and by the front is the last row
whereas in reality, it's the opposite.
here is the order it'd be nice to have them in:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
20 21 22 23
this is the actual order:
23 22 21 20
19 16 17 18
15 14 13 12
11 10 9 8
3 2 5 4
6 *0**1**7* *=not there
"""
actualorder = [
23, 22, 21, 20, 19, 16, 17, 18, 15, 14, 13, 12, 11, 10, 9, 8, 3, 2,
5, 4, 6, 0, 1, 7
]
badcolors = [] #3,2,5,4,6,0,1,7]
for i in range(len(actualorder)):
(r, g, b) = pixels[i]
r = max(0.0, min(r, 1023.0))
g = max(0.0, min(g, 1023.0))
b = max(0.0, min(b, 1023.0))
pixels2[actualorder[i]] = (r, g, b)
for i in range(len(badcolors)):
pixels2[badcolors[i]] = (0.0, 0.0, 0.0)
return pixels2
def start(self):
#server = OSCServer( ("128.174.251.39", 11661) )
self.server = OSCServer(("localhost", 11661))
self.server.timeout = 0
self.lastwrite = time.time()
self.server.handle_timeout = types.MethodType(handle_timeout,
self.server)
self.server.lastpixels = [(0, 0, 0)] * MAX_LIGHTS
self.layers = {}
self.activepid = 0
self.lastclear = time.time()
self.lastwriteany = 0
self.streamer = StreamPoster()
self.streamer.start()
self.server.addMsgHandler("/setcolors", self.set_colors)
while True:
self.each_frame()
self.server.close()
