360 lines
12 KiB
Python
360 lines
12 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# This file is part of sensors2osc package
|
|
#
|
|
# sensors2osc is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# sensors2osc is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with sensors2osc. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# found the mjpeg part here, thanks for the nice code :)
|
|
# http://hardsoftlucid.wordpress.com/2013/04/11/mjpeg-server-for-webcam-in-python-with-opencv/
|
|
# the osc integration stuff is implemented by me
|
|
#
|
|
# Copyright (C) 2014 Stefan Kögl
|
|
|
|
from __future__ import absolute_import
|
|
|
|
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
|
|
from chaosc.argparser_groups import *
|
|
from chaosc.lib import logger, resolve_host
|
|
from datetime import datetime
|
|
from operator import attrgetter
|
|
from PyQt4 import QtGui, QtCore
|
|
from PyQt4.QtCore import QBuffer, QByteArray, QIODevice
|
|
from SocketServer import ThreadingMixIn, ForkingMixIn
|
|
|
|
import logging
|
|
import numpy as np
|
|
import os.path
|
|
import pyqtgraph as pg
|
|
import Queue
|
|
import re
|
|
import select
|
|
import socket
|
|
import threading
|
|
import time
|
|
|
|
|
|
try:
|
|
from chaosc.c_osc_lib import OSCMessage, decode_osc
|
|
except ImportError as e:
|
|
logging.exception(e)
|
|
from chaosc.osc_lib import OSCMessage, decode_osc
|
|
|
|
|
|
class OSCThread(threading.Thread):
|
|
def __init__(self, args):
|
|
super(OSCThread, self).__init__()
|
|
self.args = args
|
|
self.running = True
|
|
|
|
self.client_address = resolve_host(args.client_host, args.client_port, args.address_family)
|
|
|
|
self.chaosc_address = chaosc_host, chaosc_port = resolve_host(args.chaosc_host, args.chaosc_port, args.address_family)
|
|
|
|
self.osc_sock = socket.socket(args.address_family, 2, 17)
|
|
self.osc_sock.bind(self.client_address)
|
|
self.osc_sock.setblocking(0)
|
|
|
|
logger.info("%s: starting up osc receiver on '%s:%d'",
|
|
datetime.now().strftime("%x %X"), self.client_address[0], self.client_address[1])
|
|
|
|
self.subscribe_me()
|
|
|
|
def subscribe_me(self):
|
|
logger.info("%s: subscribing to '%s:%d' with label %r", datetime.now().strftime("%x %X"), self.chaosc_address[0], self.chaosc_address[1], self.args.subscriber_label)
|
|
msg = OSCMessage("/subscribe")
|
|
msg.appendTypedArg(self.client_address[0], "s")
|
|
msg.appendTypedArg(self.client_address[1], "i")
|
|
msg.appendTypedArg(self.args.authenticate, "s")
|
|
if self.args.subscriber_label is not None:
|
|
msg.appendTypedArg(self.args.subscriber_label, "s")
|
|
self.osc_sock.sendto(msg.encode_osc(), self.chaosc_address)
|
|
|
|
|
|
def unsubscribe_me(self):
|
|
if self.args.keep_subscribed:
|
|
return
|
|
|
|
logger.info("%s: unsubscribing from '%s:%d'", datetime.now().strftime("%x %X"), self.chaosc_address[0], self.chaosc_address[1])
|
|
msg = OSCMessage("/unsubscribe")
|
|
msg.appendTypedArg(self.client_address[0], "s")
|
|
msg.appendTypedArg(self.client_address[1], "i")
|
|
msg.appendTypedArg(self.args.authenticate, "s")
|
|
self.osc_sock.sendto(msg.encode_osc(), self.chaosc_address)
|
|
|
|
def run(self):
|
|
|
|
while self.running:
|
|
try:
|
|
reads, writes, errs = select.select([self.osc_sock], [], [], 0.005)
|
|
except Exception, e:
|
|
logging.exception(e)
|
|
pass
|
|
else:
|
|
if reads:
|
|
try:
|
|
osc_input, address = self.osc_sock.recvfrom(8192)
|
|
osc_address, typetags, messages = decode_osc(osc_input, 0, len(osc_input))
|
|
queue.put_nowait((osc_address, messages))
|
|
except Exception, e:
|
|
logger.info(e)
|
|
|
|
self.unsubscribe_me()
|
|
self.osc_sock.close()
|
|
logger.info("OSCThread is going down")
|
|
|
|
|
|
queue = Queue.Queue()
|
|
|
|
class Actor(object):
|
|
def __init__(self, name, num_data, color, ix, max_actors, actor_height):
|
|
self.name = name
|
|
self.num_data = num_data
|
|
self.color = color
|
|
self.ix = ix
|
|
self.max_actors = max_actors
|
|
self.actor_height = actor_height
|
|
self.updated = 0
|
|
|
|
self.offset = ix * actor_height
|
|
self.data = np.array([self.offset] * num_data)
|
|
self.head = 0
|
|
self.pre_head = 0
|
|
self.plotItem = pg.PlotCurveItem(pen=pg.mkPen(color, width=3), name=name)
|
|
self.plotPoint = pg.ScatterPlotItem(pen=pg.mkPen("w", width=5), brush=pg.mkBrush(color), size=5)
|
|
|
|
def __str__(self):
|
|
return "<Actor name:%r, active=%r, position=%r>" % (self.name, self.active, self.head)
|
|
|
|
__repr__ = __str__
|
|
|
|
|
|
def add_value(self, value):
|
|
dp = self.head
|
|
self.data[dp] = value / self.max_actors + self.offset
|
|
self.pre_head = dp
|
|
self.head = (dp + 1) % self.num_data
|
|
self.updated += 1
|
|
|
|
def fill_missing(self, count):
|
|
dp = self.head
|
|
for i in range(count):
|
|
self.data[dp] = self.offset
|
|
dp = (dp + 1) % self.num_data
|
|
self.updated += 1
|
|
|
|
self.pre_head = (dp - 1) % self.num_data
|
|
self.head = dp
|
|
|
|
def render(self):
|
|
self.plotItem.setData(y=self.data, clear=True)
|
|
self.plotPoint.setData(x=[self.pre_head], y = [self.data[self.pre_head]])
|
|
|
|
|
|
class EkgPlot(object):
|
|
def __init__(self, actor_names, num_data, colors):
|
|
self.plot = pg.PlotWidget()
|
|
#self.plot.setConfigOptions(antialias=True)
|
|
self.plot.hide()
|
|
self.plot.showGrid(False, False)
|
|
self.plot.setYRange(0, 255)
|
|
self.plot.setXRange(0, num_data)
|
|
self.plot.resize(768, 576)
|
|
|
|
ba = self.plot.getAxis("bottom")
|
|
bl = self.plot.getAxis("left")
|
|
ba.setTicks([])
|
|
bl.setTicks([])
|
|
ba.hide()
|
|
bl.hide()
|
|
self.active_actors = list()
|
|
|
|
self.actors = dict()
|
|
self.lengths1 = [0]
|
|
self.num_data = num_data
|
|
|
|
self.max_value = 255
|
|
self.max_actors = len(actor_names)
|
|
self.actor_height = self.max_value / self.max_actors
|
|
for ix, (actor_name, color) in enumerate(zip(actor_names, colors)):
|
|
self.add_actor(actor_name, num_data, color, ix, self.max_actors, self.actor_height)
|
|
|
|
self.set_positions()
|
|
|
|
self.ekg_regex = re.compile("^/(.*?)/ekg$")
|
|
self.ctl_regex = re.compile("^/plot/(.*?)$")
|
|
self.updated_actors = set()
|
|
|
|
|
|
def add_actor(self, actor_name, num_data, color, ix, max_actors, actor_height):
|
|
actor_obj = Actor(actor_name, num_data, color, ix, max_actors, actor_height)
|
|
self.actors[actor_name] = actor_obj
|
|
self.plot.addItem(actor_obj.plotItem)
|
|
self.plot.addItem(actor_obj.plotPoint)
|
|
self.active_actors.append(actor_obj)
|
|
|
|
|
|
def set_positions(self):
|
|
for ix, actor_obj in enumerate(self.active_actors):
|
|
actor_obj.plotItem.setPos(0, ix * 2)
|
|
actor_obj.plotPoint.setPos(0, ix * 2)
|
|
|
|
def active_actor_count(self):
|
|
return self.max_actors
|
|
|
|
def new_round(self):
|
|
for ix, actor in enumerate(self.active_actors):
|
|
actor.updated = 0
|
|
|
|
def update_missing_actors(self):
|
|
liste = sorted(self.active_actors, key=attrgetter("updated"))
|
|
max_values = liste[-1].updated
|
|
if max_values == 0:
|
|
# handling no signal
|
|
for actor in self.active_actors:
|
|
actor.add_value(0)
|
|
return
|
|
for ix, actor in enumerate(self.active_actors):
|
|
diff = max_values - actor.updated
|
|
if diff > 0:
|
|
for i in range(diff):
|
|
actor.add_value(0)
|
|
|
|
|
|
def update(self, osc_address, value):
|
|
|
|
res = self.ekg_regex.match(osc_address)
|
|
if res:
|
|
actor_name = res.group(1)
|
|
actor_obj = self.actors[actor_name]
|
|
actor_obj.add_value(value)
|
|
|
|
|
|
def render(self):
|
|
for ix, actor in enumerate(self.active_actors):
|
|
actor.render()
|
|
|
|
|
|
class MyHandler(BaseHTTPRequestHandler):
|
|
|
|
def do_GET(self):
|
|
|
|
try:
|
|
self.path=re.sub('[^.a-zA-Z0-9]', "",str(self.path))
|
|
if self.path=="" or self.path==None or self.path[:1]==".":
|
|
self.send_error(403,'Forbidden')
|
|
|
|
if self.path.endswith(".html"):
|
|
directory = os.path.dirname(os.path.abspath(__file__))
|
|
data = open(os.path.join(directory, self.path), "rb").read()
|
|
self.send_response(200)
|
|
self.send_header('Content-type', 'text/html')
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
elif self.path.endswith(".mjpeg"):
|
|
self.thread = thread = OSCThread(self.server.args)
|
|
thread.daemon = True
|
|
thread.start()
|
|
actor_names = ["bjoern", "uwe", "merle"]
|
|
num_data = 100
|
|
colors = ["r", "g", "b"]
|
|
qtapp = QtGui.QApplication([])
|
|
plotter = EkgPlot(actor_names, num_data, colors)
|
|
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "multipart/x-mixed-replace; boundary=--2342")
|
|
self.end_headers()
|
|
event_loop = QtCore.QEventLoop()
|
|
last_frame = time.time() - 1.0
|
|
frame_rate = 13.0
|
|
frame_length = 1. / frame_rate
|
|
plotter.new_round()
|
|
while 1:
|
|
event_loop.processEvents()
|
|
qtapp.sendPostedEvents(None, 0)
|
|
while 1:
|
|
try:
|
|
osc_address, args = queue.get_nowait()
|
|
plotter.update(osc_address, args[0])
|
|
except Queue.Empty:
|
|
break
|
|
|
|
now = time.time()
|
|
delta = now - last_frame
|
|
if delta > frame_length:
|
|
plotter.update_missing_actors()
|
|
plotter.render()
|
|
exporter = pg.exporters.ImageExporter.ImageExporter(plotter.plot.plotItem)
|
|
exporter.parameters()['width'] = 768
|
|
img = exporter.export(toBytes=True)
|
|
buffer = QBuffer()
|
|
buffer.open(QIODevice.WriteOnly)
|
|
img.save(buffer, "JPG")
|
|
JpegData = buffer.data()
|
|
self.wfile.write("--2342\r\nContent-Type: image/jpeg\r\nContent-length: %d\r\n\r\n%s\r\n\r\n\r\n" % (len(JpegData), JpegData))
|
|
last_frame = now
|
|
plotter.new_round()
|
|
#JpegData = None
|
|
#buffer = None
|
|
#img = None
|
|
#exporter = None
|
|
time.sleep(0.01)
|
|
|
|
except (KeyboardInterrupt, SystemError), e:
|
|
raise e
|
|
except IOError, e:
|
|
if e[0] in (32, 104):
|
|
if hasattr(self, "thread") and self.thread is not None:
|
|
self.thread.running = False
|
|
self.thread.join()
|
|
self.thread = None
|
|
else:
|
|
pass
|
|
|
|
|
|
class JustAHTTPServer(HTTPServer):
|
|
pass
|
|
|
|
|
|
def main():
|
|
arg_parser = ArgParser("ekgplotter")
|
|
arg_parser.add_global_group()
|
|
client_group = arg_parser.add_client_group()
|
|
arg_parser.add_argument(client_group, '-x', "--http_host", default="::",
|
|
help='my host, defaults to "::"')
|
|
arg_parser.add_argument(client_group, '-X', "--http_port", default=9000,
|
|
type=int, help='my port, defaults to 9000')
|
|
arg_parser.add_chaosc_group()
|
|
arg_parser.add_subscriber_group()
|
|
args = arg_parser.finalize()
|
|
|
|
|
|
http_host, http_port = resolve_host(args.http_host, args.http_port, args.address_family)
|
|
|
|
server = JustAHTTPServer((http_host, http_port), MyHandler)
|
|
server.address_family = args.address_family
|
|
server.args = args
|
|
logger.info("%s: starting up http server on '%s:%d'",
|
|
datetime.now().strftime("%x %X"), http_host, http_port)
|
|
|
|
try:
|
|
server.serve_forever()
|
|
except KeyboardInterrupt:
|
|
logger.info('^C received, shutting down server')
|
|
server.socket.close()
|
|
sys.exit(0)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|