def coord_callback(event, *args):
# send event data to event address and app port,
# this will be received by screens' coordinator
Logger.info('control SEND>: event msg: ' + str(event))
# osc.sendMsg(OSCConfig.event_addr, dataArray=[str(event),], port=OSCConfig.app_port)
osc = OSCClient("127.0.0.1", OSCConfig.app_port)
osc.send_message(bytes(OSCConfig.event_addr, "ascii"), [str(event),])
class FaderWidget(Widget):
box_pos = ListProperty([100, 100])
box_size = ListProperty([60, 800])
color = ListProperty([1, 0.5, 0])
def __init__(self, ind, addr, port, **kwargs):
self.source = 0
self.idx = ind
self.osc_client = OSCClient(addr, port)
super(FaderWidget, self).__init__(**kwargs)
def on_touch_down(self, touch):
if self.collide_point(*touch.pos):
gain = (touch.pos[1] - self.pos[1]) / self.size[1]
self.osc_client.send_message(b'/send/gain',
[self.source, self.idx, gain])
#print([self.idx, self.source, gain])
def on_touch_move(self, touch):
if self.collide_point(*touch.pos):
gain = (touch.pos[1] - self.pos[1]) / self.size[1]
self.osc_client.send_message(b'/send/gain',
[self.source, self.idx, gain])
#print([self.idx, self.source, gain])
def set_source(self, src):
self.source = src
def setup_service():
Logger.info('service: setup_service')
setup_logger('mi')
# add this dir to module search path
app_dir = os.path.join(mi2app_utils.get_files_dir(), "app")
sys.path.append(os.path.join(app_dir, 'service'))
Logger.info('service: sys path added: ' + str(sys.path))
# setup control and listen to osc signal
control = Control()
Logger.info('service: control created' + repr(control))
osc = OSCThreadServer()
osc.listen(port=OSCConfig.service_port, default=True)
# def dummy_callback(msg, *args):
# Logger.info('service: dummy callback: ' + str(msg))
# osc.bind(OSCID, dummy_callback, OSCConfig.control_addr)
osc.bind(bytes(OSCConfig.control_addr, "ascii"), control.osc_callback)
# Logger.info('service: osc setup, id: ' + OSCID)
Logger.info('service: osc setup')
gps_provider = GpsListener(on_gps)
gps_provider.start()
osc_client = OSCClient("127.0.0.1", OSCConfig.service_port)
osc_client.send_message(bytes(OSCConfig.control_addr, "ascii"), ['service ready',])
Logger.info('service SEND>: service ready msg sent')
while True:
# osc.readQueue(thread_id=OSCID)
time.sleep(.5)
def test_oscclient():
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
acc = []
def success(*values):
acc.append(values[0])
osc.bind(b'/success', success, sock)
client = OSCClient('localhost', port)
timeout = time() + 5
while len(acc) < 50:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_message(b'/success', [1])
while len(acc) < 100:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_bundle([(b'/success', [i]) for i in range(10)])
def test_server_different_port():
# server, will be tested:
server_3000 = OSCThreadServer(encoding='utf8')
sock_3000 = server_3000.listen(address='0.0.0.0', port=3000, default=True)
server_3000.bind(b'/callback_3000', callback_3000)
# clients sending to different ports, used to test the server:
client_3000 = OSCClient(address='localhost', port=3000, encoding='utf8')
# server sends message to himself, should work:
server_3000.send_message(b'/callback_3000', ["a"],
ip_address='localhost',
port=3000)
sleep(0.05)
# client sends message to server, will be received properly:
client_3000.send_message(b'/callback_3000', ["b"])
sleep(0.05)
# sever sends message on different port, might crash the server on windows:
server_3000.send_message(b'/callback_3000',
["nobody is going to receive this"],
ip_address='localhost',
port=3001)
sleep(0.05)
# client sends message to server again. if server is dead, message will not be received:
client_3000.send_message(b'/callback_3000', ["c"])
sleep(0.1) # give time to finish transmissions
# if 'c' is missing in the received checklist, the server thread crashed and could not recieve the last message from the client:
assert checklist == ['a', 'b', 'c']
server_3000.stop() # clean up
class ClientServerApp(App):
def build(self):
self.service = None
# self.start_service()
self.server = server = OSCThreadServer()
server.listen(
address=b'localhost',
port=3002,
default=True,
)
server.bind(b'/message', self.display_message)
server.bind(b'/date', self.date)
self.client = OSCClient(b'localhost', 3000)
self.root = Builder.load_string(KV)
return self.root
def start_service(self):
if platform == 'android':
service = autoclass(SERVICE_NAME)
mActivity = autoclass(u'org.kivy.android.PythonActivity').mActivity
argument = ''
service.start(mActivity, argument)
self.service = service
elif platform in ('linux', 'linux2', 'macos', 'win'):
from runpy import run_path
from threading import Thread
self.service = Thread(
target=run_path,
args=['src/service.py'],
kwargs={'run_name': '__main__'},
daemon=True
)
self.service.start()
else:
raise NotImplementedError(
"service start not implemented on this platform"
)
def stop_service(self):
if self.service:
self.service.stop()
self.service = None
def send(self, *args):
self.client.send_message(b'/ping', [])
def display_message(self, message):
if self.root:
self.root.ids.label.text += '{}\n'.format(message.decode('utf8'))
def date(self, message):
if self.root:
self.root.ids.date.text = message.decode('utf8')
def send(self, host, port, addr, args=()):
logger.debug('[OscServer.send host={} port={}] {} {}'.format(host,port,addr,args))
# for debugging only, really
if self.capture_sends:
self.capture_sends(host, port, addr, args)
return
client = OSCClient(host, port)
client.send_message(bytes(addr, 'utf-8'), args)
def onCameraClick(self, *args):
address = "0.0.0.0"
port = 8888
osc = OSCClient(address, port)
for i in range(10):
print(" SENDING OSC", i)
osc.send_message(b'/address', [i])
self.start_service()
class ClientServerApp(App):
def build(self):
self.service = None
# self.start_service()
self.server = server = OSCThreadServer()
server.listen(
address=b'localhost',
port=3002,
default=True,
)
server.bind(b'/message', self.display_message)
server.bind(b'/date', self.date)
self.client = OSCClient(b'localhost', 3000)
self.root = Builder.load_string(KV)
return self.root
def start_service(self):
if platform == 'android':
service = autoclass(SERVICE_NAME)
mActivity = autoclass(u'org.kivy.android.PythonActivity').mActivity
argument = ''
service.start(mActivity, argument)
self.service = service
elif platform in ('linux', 'linux2', 'macos', 'win'):
from runpy import run_path
from threading import Thread
self.service = Thread(target=run_path,
args=['src/service.py'],
kwargs={'run_name': '__main__'},
daemon=True)
self.service.start()
else:
raise NotImplementedError(
"service start not implemented on this platform")
def stop_service(self):
if self.service:
self.service.stop()
self.service = None
def send(self, *args):
self.client.send_message(b'/ping', [])
def display_message(self, message):
if self.root:
self.root.ids.label.text += '{}\n'.format(message.decode('utf8'))
def date(self, message):
if self.root:
self.root.ids.date.text = message.decode('utf8')
class FaderWidget(Widget):
box_pos = ListProperty([100,100])
box_size = ListProperty([80,400])
color = ListProperty([0.3, 0.3, 0.3])
text = StringProperty('SSS')
def __init__(self, path, addr, port, **kwargs):
self.index = 0
self.min = 0
self.max = 10
self.path = path
self.source = 0
self.osc_client = OSCClient(addr, port)
super(FaderWidget, self).__init__(**kwargs)
def on_touch_down(self, touch):
if self.collide_point(*touch.pos):
gain = ((touch.pos[1]-self.pos[1]) / self.size[1]) * self.max
self.osc_client.send_message(bytes(self.path,encoding='utf8') , [self.index, gain])
#print([self.idx, self.source, gain])
def on_touch_move(self, touch):
if self.collide_point(*touch.pos):
gain = ((touch.pos[1]-self.pos[1]) / self.size[1]) * self.max
self.osc_client.send_message(bytes(self.path,encoding='utf8'), [self.index, gain])
#print([self.idx, self.source, gain])
def set_source(self,src):
self.source=src
def on_receive(self, *values):
src = values[0]
if src==self.index:
gain = values[1]
# print(gain)
y = self.pos[1] + (gain/self.max) * self.size[1] - (0.5*self.ids.bar.ellipse_size[1])
self.ids.bar.ellipse_pos = [self.pos[0] + (self.size[0]/2) - (self.ids.bar.ellipse_size[0]/2), y] #[self.faders[dest].pos[0],y]
def set_index(self, ind):
self.index = ind;
def thread_target(msg):
# wait for service ready event
self._service_ready.wait()
# Update OSC
osc = OSCClient("127.0.0.1", OSCConfig.service_port)
osc.send_message(bytes(OSCConfig.control_addr, "ascii"), [
str(msg),
])
# osc = OSCThreadServer()
# osc.send_message(OSCConfig.control_addr, values=[str(msg), ], *osc.getaddress(), port=OSCConfig.service_port)
Logger.info('coordinator SEND>: control msg: ' + msg)
class OscAppClient:
"""OSC client that talks to the OscAppServer to update the app process."""
def __init__(self, address, port):
self.address = address
self.port = port
self.osc = OSCClient(address, port)
def send_ping(self):
for i in range(10):
self.osc.send_message(b'/ping', [i])
def send_refresh_balance(self):
self.osc.send_message(b'/refresh_balance', [])
def send(data):
"""# N° body à la fin
msg.append(bodyId)
# Heure de capture
self.all_data.append([msg, time()])
self.client.send_message(b'/points', msg)
"""
client = OSCClient(b'localhost', 8003)
for points in data:
points = points[0]
client.send_message(b'/points', points)
print(points)
sleep(0.1)
def osc_frame_upd(scn):
# kludge to avoid error while changing scene
if g_vars.scene is not scn:
return
# send osc events
bcw = bpy.context.window_manager
osc = OSCClient(bcw.addroutes_osc_udp_out, bcw.addroutes_osc_port_out, encoding='utf8')
if bcw.addroutes_osc_out_enable is True:
for bl_item, item in g_vars.addroutes_osc_out:
# getting current value
if bl_item.is_str2eval:
g_vars.evalprop(bl_item.str2eval, bl_item.withctx)
prop = g_vars.eval_prop
ref = g_vars.eval_ref
else:
ref = item['ref']
prop = item['prop']
# apply func
func = item['func']
try:
if bl_item.is_array:
if bl_item.use_array is False:
val = getattr(ref, prop)[bl_item.array]
val2 = [func(bl_item, item, val)]
else:
val = getattr(ref, prop)
val2 = list(func(bl_item, item, val))
else:
val = getattr(ref, prop)
val2 = [func(bl_item, item, val)]
# the value has changed
if val2 != item['val']:
item['val'] = val2
# for multi routes
val3 = val2.copy()
if bl_item.is_multi:
val3.insert(0, item['idx'])
addr = str.encode(item['address'])
osc.send_message(addr, val3)
except:
print("Error while sending, improper OSC route #", item["n"], 'category :', bl_item.category)
break
def blemote_poll():
global auto_port_out, auto_udp_out, stored, upd_cnt, blem_cnt
pref = bpy.context.preferences.addons['AddRoutes'].preferences
if pref.blemote_autoconf:
udp_out = auto_udp_out
port_out = auto_port_out
else:
udp_out = pref.blemote_udp_out
port_out = pref.blemote_port_out
try:
osc = OSCClient(udp_out, port_out, encoding='utf8')
osc.send_message("/pong", [upd_cnt])
except:
return 1
current = g_vars.addroutes_blemote
if blem_cnt != upd_cnt:
addr = str.encode('/BLEMOTE_ROUTES')
osc.send_message(addr, [str.encode('START')])
for p_rnk, item in g_vars.addroutes_blemote.items():
dico = item[2]
n = item[1]
val = dico['min']
bl_item = item[0]
index = bl_item.array
try:
if bl_item.is_str2eval is False:
#print(dico['trigger'])
if bl_item.is_array:
val = getattr(dico['trigger']['ref'],
dico['trigger']['prop'])[index]
else:
val = getattr(dico['trigger']['ref'],
dico['trigger']['prop'])
except:
pass
to_send = [
p_rnk, n, dico['min'], dico['max'], dico['step'],
dico['category'], val
]
osc.send_message(addr, to_send)
osc.send_message(addr, ['STOP'])
#print('BLEMOTE ROUTES UPDATE')
if current != stored:
upd_cnt += 1
stored = dict(current)
return 2
def test_timetag():
osc = OSCThreadServer(drop_late_bundles=True)
osc.drop_late_bundles = True
sock = osc.listen()
port = sock.getsockname()[1]
acc = []
@osc.address(b'/success', sock)
def success(*values):
acc.append(True)
@osc.address(b'/failure', sock)
def failure(*values):
acc.append(False)
client = OSCClient('localhost', port)
timeout = time() + 5
while len(acc) < 50:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_message(b'/success', [1])
while len(acc) < 100:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_bundle(
[(b'/failure', [i]) for i in range(10)],
timetag=time() - 1,
safer=True,
)
client.send_bundle(
[(b'/success', [i]) for i in range(10)],
timetag=time() + .1,
safer=True,
)
assert True in acc
assert False not in acc
def osc_frame_upd(scn):
# kludge to avoid error while changing scene
#if g_vars.scene is not scn:
#return
# send osc events
bcw = bpy.context.window_manager
osc = OSCClient(bcw.vpt_osc_udp_out, bcw.vpt_osc_port_out, encoding='utf8')
if bcw.vpt_osc_out_enable is True:
for item in g_vars.vpt_osc_out:
bl_item = scn.VPT_Items[item['n']]
# getting current value
if bl_item.is_array and (bl_item.use_array is False):
val = getattr(item['ref'], item['prop'])[bl_item.array]
else:
val = getattr(item['ref'], item['prop'])
# remap one day here ?
if type(val) is Vector or type(val) is Color:
val2 = list(val)
else:
val2 = [val]
# apply func
func = item['func']
val2 = func(bl_item, item, val2)
# the value has changed
if val2 != item['val']:
item['val'] = val2
# for multi routes
val3 = val2.copy()
if bl_item.is_multi:
val3.insert(0, item['idx'])
addr = str.encode(item['address'])
osc.send_message(addr, val3)
def main(ip_address, port, path, model_path, labels_path):
# Setup the OSC Client
osc = OSCClient(ip_address, int(port), encoding="utf8")
# Load your model onto your Coral Edgetpu
engine = ClassificationEngine(model_path)
labels = loadLabels(labels_path)
cap = cv2.VideoCapture(0)
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
# Format the image into a PIL Image so its compatable with Edge TPU
cv2_im = frame
pil_im = Image.fromarray(cv2_im)
# Resize and flip image so its a square and matches training
pil_im.resize((224, 224))
pil_im.transpose(Image.FLIP_LEFT_RIGHT)
# Classify and display image
results = classifyImage(pil_im, engine)
cv2.imshow('frame', cv2_im)
# Get the label of the best result and send it with OSC
details_of_best_result = get_details_of_best_result(results, labels)
print(details_of_best_result)
osc.send_message(path, details_of_best_result["label"])
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def remote_poll():
pref = bpy.context.preferences.addons['VPT'].preferences
osc = OSCClient(pref.remote_udp_out, pref.remote_port_out, encoding='utf8')
'''
for item in g_vars.vpt['remote']:
addr = str.encode(item['address'])
osc.send_message(addr, [val2])
'''
addr = str.encode('/BLEMOTE_ROUTES')
osc.send_message(addr, [str.encode('START')])
if g_vars.vpt_remote:
for item in g_vars.vpt_remote.items():
route = item[0]
dico = item[1]
to_send = [route, dico['min'], dico['max']]
osc.send_message(addr, to_send)
osc.send_message(addr, ['STOP'])
return 3
magnitude = np.abs(D).transpose()
predictions = model.predict_proba(magnitude, verbose=False)
predictions_mean = predictions.mean(axis=0)
predictions_in_60_sec = np.vstack([predictions_in_60_sec, predictions])
count = count + 1
#here for sending osc message
if LABELS[predictions_mean.argmax()] == 'wind':
print('its windy!')
from oscpy.client import OSCClient
address = "10.79.103.100"
port = 7001
osc = OSCClient(address, port)
for i in range(1):
osc.send_message(b'/wind', [i])
print('osc sending')
elapsed_time = time.time() - start
localtime = '{0.tm_hour:02d}:{0.tm_min:02d}:{0.tm_sec:02d}'.format(
time.localtime(time.time()))
print('{0:s} {1:s} - (accuracy {2:.3f}, processed in {3:.3f} seconds)'.
format(localtime, LABELS[predictions_mean.argmax()],
predictions_mean.max(), elapsed_time))
if predictions_mean.max() > threshold:
label = predictions_mean.argmax()
if last_label != label:
print('Changed: {0} > {1}'.format(LABELS[last_label],
class tstick:
# Creating variables to define T-Stick mapping
# This variable will be defined when we receive
# T-Stick info.
instrument_name = "T-Stick"
tstick_id = 0
def __init__(self, serialport, ip, port, networkinterface, listenport):
# set listening ip to receive OSC messages
self.local_ip = ni.ifaddresses(
args.networkinterface)[ni.AF_INET][0]['addr']
# Set OSC client and server
self.server_osc = OSCThreadServer()
self.sock = self.server_osc.listen(address=self.local_ip,
port=listenport,
default=True)
self.client_osc = OSCClient(ip, port)
# Opening T-Stick serial port
self.tstick_serial_port = serial.Serial(serialport, 115200, dsrdtr=1)
# routing OSC signals
self.server_osc.bind(b'/status', self.resend)
def osc_send(self, sensor_data):
if sensor_data:
for i in range(len(sensor_data)):
if isinstance(sensor_data[i], list): # has to be list
data = data_lib = sensor_data[i]
if not isinstance(sensor_data[i], list):
data_lib = sensor_data[i] # for libmapper
data = [sensor_data[i]] # adding [] if its not list
sensor_name = sensor_data._fields[i]
self.client_osc.send_message(b'/{}'.format(sensor_name), data)
def resend(self, *values):
self.tstick_serial_port.write(values)
def heartbeat(self):
self.tstick_serial_port.write('s'.encode('utf-8'))
def receive_and_send_serial(self):
""" Receive T-Stick serial data and make it available
as "serial_data" variable. The data is namedtuple.
Also sends serial data to T-Stick (receives OSC from client).
"""
flag = False
msg = []
while True:
# byte = int.from_bytes(TSTICK.read(), sys.byteorder) # python 3.2+
if sys.byteorder == 'little':
byte = struct.unpack("<B", self.tstick_serial_port.read())
else:
byte = struct.unpack(">B", self.tstick_serial_port.read())
byte = byte[0]
if not flag:
if byte == 100:
information = self.get_tstick_id(*msg)
self.osc_send(information)
if (self.tstick_id == 173):
serial_data = self.sort_173(*msg)
self.osc_send(serial_data)
elif (self.tstick_id == 10 or self.tstick_id == 12
or self.tstick_id == 24 or self.tstick_id == 171):
serial_data = self.sort_2G(*msg)
self.osc_send(serial_data)
elif (self.tstick_id == 15):
serial_data = self.sort_2GX(*msg)
self.osc_send(serial_data)
del msg[:]
elif byte == 101:
flag = True
else:
msg.append(byte)
else:
msg.append(byte)
flag = False
def bit_conversion(self, byte1, byte2):
return (byte1 * 256) + byte2
def bit_ext_conversion(self, byte1, byte2):
bin_or = (byte1 * 256) | byte2
return bin_or - (65535 * (bin_or > 32767))
def get_tstick_id(self, *msg):
named_return = collections.namedtuple('tstick_information',
'information')
if len(msg) < 1:
return False
if msg[0] == 0:
if len(msg) < 5:
return False
self.tstick_id = self.bit_conversion(msg[1], msg[2])
firmware = self.bit_conversion(msg[3], msg[4])
info_list = [self.tstick_id, firmware]
if len(msg) > 5:
for i in msg[5:]:
info_list.append(i)
return named_return(info_list)
def sort_173(self, *msg):
""" Route T-Stick messages for T-Stick #173. """
if msg[0] == 0:
return False
elif msg[0] == 1:
named_return = collections.namedtuple('tstick_sensor',
'rawcapsense')
rawcapsense = msg[1:]
return named_return(list(rawcapsense))
elif msg[0] == 2:
named_return = collections.namedtuple(
'tstick_sensor', 'rawaccel rawgyro rawpressure rawpiezo')
if len(msg) < 17:
return False
accel_x = self.bit_ext_conversion(msg[1], msg[2])
accel_y = self.bit_ext_conversion(msg[3], msg[4])
accel_z = self.bit_ext_conversion(msg[5], msg[6])
gyro_x = self.bit_ext_conversion(msg[7], msg[8])
gyro_y = self.bit_ext_conversion(msg[9], msg[10])
gyro_z = self.bit_ext_conversion(msg[11], msg[12])
pressure = self.bit_ext_conversion(msg[13], msg[14])
piezo = self.bit_ext_conversion(msg[15], msg[16])
return named_return([accel_x, accel_y, accel_z],
[gyro_x, gyro_y, gyro_z], pressure, piezo)
elif msg[0] == 3:
named_return = collections.namedtuple('tstick_sensor', 'rawmag')
if len(msg) < 7:
return False
mag_x = self.bit_ext_conversion(msg[1], msg[2])
mag_y = self.bit_ext_conversion(msg[3], msg[4])
mag_z = self.bit_ext_conversion(msg[5], msg[6])
return named_return([mag_x, mag_y, mag_z])
elif msg[0] == 4:
return False
def sort_2G(self, *msg):
""" Route T-Stick messages for T-Stick 2G series: 010, 012, 024, 171. """
if msg[0] == 0:
return False
elif msg[0] == 1:
named_return = collections.namedtuple('tstick_sensor',
'rawcapsense')
rawcapsense = msg[1:]
return named_return(list(rawcapsense))
elif msg[0] == 2:
named_return = collections.namedtuple('tstick_sensor', 'rawjab')
rawjab = msg[1:]
return named_return(list(rawjab))
elif msg[0] == 3:
named_return = collections.namedtuple('tstick_sensor', 'rawtap')
rawtap = msg[1:]
return named_return(list(rawtap))
elif msg[0] == 4:
named_return = collections.namedtuple(
'tstick_sensor', 'rawaccel rawpressure rawpiezo')
if len(msg) < 11:
return False
accel_x = self.bit_conversion(msg[1], msg[2])
accel_y = self.bit_conversion(msg[3], msg[4])
accel_z = self.bit_conversion(msg[5], msg[6])
pressure = self.bit_conversion(msg[7], msg[8])
piezo = self.bit_conversion(msg[9], msg[10])
return named_return([accel_x, accel_y, accel_z], pressure, piezo)
def sort_2GX(*msg):
""" Route T-Stick messages for T-Stick #015. """
if msg[0] == 0:
return False
elif msg[0] == 1:
named_return = collections.namedtuple('tstick_sensor',
'rawcapsense')
rawcapsense = msg[1:]
return named_return(list(rawcapsense))
# capsense_bits = cook_touch_soprano(*rawcapsense)
elif msg[0] == 2:
named_return = collections.namedtuple('tstick_sensor', 'rawjab')
rawjab = msg[1:]
return named_return(list(rawjab))
elif msg[0] == 3:
named_return = collections.namedtuple('tstick_sensor', 'rawtap')
rawtap = msg[1:]
return named_return(list(rawtap))
elif msg[0] == 4:
named_return = collections.namedtuple(
'tstick_sensor',
'rawaccel rawpressure rawpiezo rawairpressure rawrange rawldr1 rawldr2'
)
if len(msg) < 19:
return False
accel_x = self.bit_conversion(msg[1], msg[2])
accel_y = self.bit_conversion(msg[3], msg[4])
accel_z = self.bit_conversion(msg[5], msg[6])
pressure = self.bit_conversion(msg[7], msg[8])
piezo = self.bit_conversion(msg[9], msg[10])
airpressure = self.bit_conversion(msg[11], msg[12])
tstick_range = self.bit_conversion(msg[13], msg[14])
ldr1 = self.bit_conversion(msg[15], msg[16])
ldr2 = self.bit_conversion(msg[17], msg[18])
return named_return([accel_x, accel_y, accel_z], pressure, piezo,
airpressure, tstick_range, ldr1, ldr2)
def cook_touch_soprano(self, *bytes):
byte_list = ""
for byte in bytes:
byte_list = byte_list + format(byte, '08b')
return list(byte_list)
def wakeup(self):
""" Setting heartbeat to run every second """
scheduler = BackgroundScheduler()
scheduler.add_job(self.heartbeat, 'interval', seconds=1)
scheduler.start()
class cam():
def __init__(self, cam_num, ip, port, coordinates):
print("cam initialized")
self.x1, self.y1, self.x2, self.y2 = coordinates
self.osc = OSCClient(ip, port)
self.range_filter = 'HSV'
self.capture = False
self.lock = threading.Lock()
self.camera = cv2.VideoCapture(cam_num)
ret, image = self.camera.read()
if (not ret):
print("cam error!")
pass
self.width, self.height = self.x2 - self.x1, self.y2 - self.y1
#Markers
self.flip = False
self.m1 = [44, 99, 0, 84, 255, 255]
self.m2 = [0, 174, 0, 6, 255, 255]
self.m3 = [108, 44, 0, 137, 255, 255]
self.m4 = [0, 174, 0, 6, 255, 255]
self.items1 = [[0, 0]] #queue1
self.items2 = [[0, 0]] #queue2
self.seq1 = 2500 #sequence number1
self.seq2 = 1 #sequence number2
self.flag1, self.flag2 = False, False
def touch(self, image, seq, seq2, m1, m2, items, flag):
# Converting image between thresh hold values
thresh = cv2.inRange(image, (m1[0], m1[1], m1[2]),
(m1[3], m1[4], m1[5]))
thresh2 = cv2.inRange(image, (m2[0], m2[1], m2[2]),
(m2[3], m2[4], m2[5]))
#Creating mask by using 5 x 5 matrix, Perform advanced morphoogical transformation
kernel = np.ones((5, 5), np.uint8)
mask = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
mask2 = cv2.morphologyEx(thresh2, cv2.MORPH_OPEN, kernel)
#find the countour in the mask
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
cnts2 = cv2.findContours(mask2.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
#proceed only if atleast one contour is found
if len(cnts) > 0:
#find largest countour in the mask
c = max(cnts, key=cv2.contourArea)
#assign center of max countour to center of marker
((self.x, self.y), radius) = cv2.minEnclosingCircle(c)
# For cropping region of interest
if (self.x > self.x1 and self.x < self.x2 and self.y > self.y1
and self.y < self.y2):
self.x = self.x - self.x1
self.y = self.y - self.y1
#proceed if second marker is found
if len(cnts2) > 0:
c2 = max(cnts2, key=cv2.contourArea)
((x, y), radius2) = cv2.minEnclosingCircle(c2)
else:
radius2 = 0
# Store x, y position in queue for reducing shake
if len(items) < 7:
items.insert(0, [self.x, self.y])
else:
items.pop()
items.insert(0, [self.x, self.y])
# Avarage point in queue
x1, y1 = self.avgPoint(items)
#only proceed if radius meets minimum size
if radius > 10:
c1, c2 = self.setCursorPos(int(x1), int(y1), int(self.x),
int(self.y))
if (len(cnts2) > 0) and (radius2 > 10):
c1, c2 = c1 / self.width, c2 / self.height
self.osc.send_message(b'/tuio/2Dcur',
(b'alive', seq, seq2))
self.osc.send_message(b'/tuio/2Dcur',
(b'set', seq, c1, c2))
flag = True
else:
if flag:
if (seq < 99999):
seq = seq + 1
else:
seq = 1
print(seq)
flag = False
return seq, items, flag
def capture_pic(self, image):
while self.capture:
#going to detect is 4 markers present in image if not try another frame
kernel = np.ones((5, 5), np.uint8)
thresh = cv2.inRange(image, (self.m1[0], self.m1[1], self.m1[2]),
(self.m1[3], self.m1[4], self.m1[5]))
mask = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if len(cnts) > 0:
c = max(cnts, key=cv2.contourArea)
((self.x, self.y), radius) = cv2.minEnclosingCircle(c)
if radius > 10:
thresh = cv2.inRange(image,
(self.m2[0], self.m2[1], self.m2[2]),
(self.m2[3], self.m2[4], self.m2[5]))
mask = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if len(cnts) > 0:
c = max(cnts, key=cv2.contourArea)
((self.x, self.y), radius) = cv2.minEnclosingCircle(c)
if radius > 10:
thresh = cv2.inRange(
image, (self.m3[0], self.m3[1], self.m3[2]),
(self.m3[3], self.m3[4], self.m3[5]))
mask = cv2.morphologyEx(thresh, cv2.MORPH_OPEN,
kernel)
cnts = cv2.findContours(
mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if len(cnts) > 0:
c = max(cnts, key=cv2.contourArea)
((self.x, self.y),
radius) = cv2.minEnclosingCircle(c)
if radius > 10:
thresh = cv2.inRange(
image,
(self.m4[0], self.m4[1], self.m4[2]),
(self.m4[3], self.m4[4], self.m4[5]))
mask = cv2.morphologyEx(
thresh, cv2.MORPH_OPEN, kernel)
cnts = cv2.findContours(
mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if len(cnts) > 0:
c = max(cnts, key=cv2.contourArea)
((self.x, self.y),
radius) = cv2.minEnclosingCircle(c)
if radius > 10:
image = cv2.cvtColor(
image, cv2.COLOR_HSV2BGR)
cv2.imwrite("image.png", image)
self.capture = False
print("1 written!")
ret, image = self.camera.read()
if self.flip:
image = cv2.flip(image, 1)
image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
def frame(self, *args):
ret, image = self.camera.read()
if self.flip:
image = cv2.flip(image, 1)
image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
self.seq1, self.items1, self.flag1 = self.touch(
image, self.seq1, self.seq2, self.m1, self.m2, self.items1,
self.flag1)
self.seq2, self.items2, self.flag2 = self.touch(
image, self.seq2, self.seq1, self.m3, self.m4, self.items2,
self.flag2)
if self.capture:
self.lock.acquire()
try:
self.capture_pic(image)
finally:
self.lock.release()
def setCursorPos(self, pyp0, pyp1, yc0, yc1):
yp = [0, 0]
if abs(yc0 - pyp0) < 5 and abs(yc1 - pyp1) < 5:
yp[0] = yc0 + .7 * (pyp0 - yc0)
yp[1] = yc1 + .7 * (pyp1 - yc1)
else:
yp[0] = yc0 + .1 * (pyp0 - yc0)
yp[1] = yc1 + .1 * (pyp1 - yc1)
return yp[0], yp[1]
def avgPoint(self, items):
a, b = 0, 0
for x, y in items:
a = a + x
b = b + y
return a / len(items), b / len(items)
def cam_loop(self):
print('camera')
self.serverSocket = socket.socket()
port = 3335
self.serverSocket.bind(('', port))
self.capture = False
while True:
self.serverSocket.listen(1)
self.client, addr = self.serverSocket.accept()
message = self.client.recv(1024).decode("ascii")
self.capture = True
time.sleep(2)
self.lock.acquire()
self.lock.release()
f = open('image.png', 'rb') # Open in binary
l = f.read(1024)
while (l):
self.client.send(l)
l = f.read(1024)
f.close()
self.client.close()
def main_thread(self):
print("main")
while True:
self.frame()
class SourceViewer(App):
# default config is created on first run
def build_config(self, config):
config.setdefaults('self', {'n_channels': 16, 'receive_port': '8989'})
config.setdefaults('renderbox', {
'address': '127.0.0.1',
'port': '8989'
})
def build(self):
config = self.config
self.render_address = config.get('renderbox', 'address')
self.render_port = config.getint('renderbox', 'port')
self.receive_port = config.getint('self', 'receive_port')
self.n_channels = config.getint('self', 'n_channels')
print(self.render_address)
print(self.render_port)
self.osc_client = OSCClient(self.render_address, self.render_port)
# notify rendering server
self.osc_client.send_message(b'/addlistener/gains',
[self.receive_port])
n_channels = 16
self.active_source = 0
self.main_layout = GridLayout(rows=1,
cols=2,
row_default_height=40,
spacing=50,
size_hint_x=1,
size_hint_y=1)
# a GridLayout for the faders
self.xyl = GridLayout(rows=3,
col_default_width=80,
cols=n_channels,
size_hint_x=1,
size_hint_y=1)
self.main_layout.add_widget(self.xyl)
self.faders = []
for i in range(n_channels):
l = Label(text=str(i), font_size=30, bold=True, halign='center')
self.xyl.add_widget(l)
for i in range(n_channels):
f = FaderWidget(i, self.render_address, self.render_port)
if i < 2:
f.color = [1, 0, 0]
else:
f.color = [0, 1, 1]
f.ids.bar.ellipse_pos = [0, 0]
f.pos = [i * 80, 100]
f.text = str(i)
self.faders.append(f)
self.xyl.add_widget(f)
self.button_grid = GridLayout(rows=(int(n_channels / 2) + 1),
cols=2,
row_default_height=40,
spacing=50,
size_hint_x=0.2,
size_hint_y=1)
self.main_layout.add_widget(self.button_grid)
self.select_buttons = []
for i in range(n_channels):
self.select_buttons.append(Button(text='Source ' + str(i)))
for i in range(n_channels):
self.button_grid.add_widget(self.select_buttons[i])
self.select_buttons[i].background_color = (0, 0.5, 0.6, 1)
self.select_buttons[i].bind(
on_press=partial(self.toggle_source, i))
self.settings_button = Button(text='View All')
self.button_grid.add_widget(self.settings_button)
self.settings_button.bind(on_press=partial(self.open_settings))
self.default_routing_button = Button(text='View None')
self.button_grid.add_widget(self.default_routing_button)
self.default_routing_button.bind(
on_press=partial(self.default_routing))
self.osc_server = OSCThreadServer()
self.socket = self.osc_server.listen(address='0.0.0.0',
port=self.receive_port,
default=True)
self.osc_server.bind(b'/send/level', self.send_level_handler)
self.toggle_source(0, self.select_buttons[0])
return self.main_layout
def send_level_handler(self, *values):
src = values[0]
if src == self.active_source:
dest = values[1]
gain = values[2]
# scale to fader box
y = self.faders[dest].pos[1] + gain * self.faders[dest].size[1] - (
0.5 * self.faders[dest].ids.bar.ellipse_size[1])
self.faders[dest].ids.bar.ellipse_pos = [
self.faders[dest].pos[0], y
]
def toggle_source(self, ind, button):
self.active_source = ind
# dim other buttons
for b in self.select_buttons:
b.background_color = (0.3, 0.3, 0.3, 1)
# highlight active
self.select_buttons[ind].background_color = (0, 0.1, 0.9, 1)
#set source index
for f in self.faders:
f.set_source(ind)
def open_settings(self, button):
content = Button(text='Close me!')
popup = Popup(content=content, auto_dismiss=False)
content.bind(on_touch_down=popup.dismiss)
# open the popup
popup.open()
def default_routing(self, button):
x = 1
class OscClt:
"""Un client OSC spécifique pour envoyer les points Cubemos,
et enregistrer ces points dans un fichier pour debug.
"""
def __init__(self, ip, port):
""" ip = "192.168.1.101"
ip = b'localhost'
"""
self.ip = ip
self.port = port
# Pour l'enregistrement d'un json à la fin de la capture
self.all_data = []
self.client = OSCClient(self.ip, self.port)
def send_global_message(self, points3D, bodyId=110):
"""Envoi du point en OSC en 3D
Liste de n°body puis toutes les coordonnées sans liste de 3
oscpy n'envoie pas de liste de listes
"""
msg = []
for point in points3D:
if point:
for i in range(3):
# Envoi en int
msg.append(int(point[i]*1000))
# Si pas de point ajout arbitraire de 3 fois -1000000
# pour avoir toujours 3*18 valeurs dans la liste
else:
msg.extend((-1000000, -1000000, -1000000)) # tuple ou list
# N° body à la fin
msg.append(bodyId)
# Heure de capture
self.all_data.append([msg, time()])
self.client.send_message(b'/points', msg)
def send_mutiples_message(self, points3D, bodyId=110):
"""Envoi d'un message OSC pour chaque point: n = 0 à 17
point = [x, y, z]
il faudrait une adresse du type
/point_{n}_{bodyId}
mais je ne sait pas recevoir çà
d'où ce mix
msg = [bodyId, n, x, y, z]
"""
msg = [bodyId]
for point in points3D:
if point:
n = points3D.index(point)
msg.append(n)
for i in range(3):
msg.append(point[i])
self.client.send_message(b'/point', msg)
def send_msg(self, adress, note):
self.client.send_message(adress, [note])
def save(self):
"""Enregistrement des messages envoyés pour debug de la réception.
Les points sont au format cubemos * 1000
"""
dt_now = datetime.now()
dt = dt_now.strftime("%Y_%m_%d_%H_%M")
fichier = f"json/cap_{dt}.json" # dans le home
with open(fichier, "w") as fd:
fd.write(dumps(self.all_data))
print(f"{fichier} enregistré.")
fd.close()
from oscpy.client import OSCClient
import pyautogui
osc = OSCClient('127.0.0.1', 3334)
while (True):
(m1,m2)=pyautogui.position()
s=pyautogui.size()
m1=m1/s[0]
m2=m2/s[1]
osc.send_message(b'/tuio/2Dcur',(b'alive',100))
osc.send_message(b'/tuio/2Dcur',(b'set',100,m1,m2))
class SoundStimulus():
def __init__(self,
filename=None,
inputPort=None,
channel='left',
osc_port=12345,
totalStimuli=10):
self.p_minimix = None
#start jack with = ['/usr/bin/jackd', '--realtime', '-P10','-d', 'alsa', '-p128', '-n2', '-r48000']
#self.p_jack = Popen(jack_cmd, stdout=DEVNULL, stderr=DEVNULL)
try:
self.jack_client = jack.Client('PythonJackClient',
no_start_server=True)
except jack.JackError:
raise (EnvironmentError("Jack Client not started"))
if not os.path.isfile(filename):
raise (ValueError(
"Sound file {} could not be found.".format(filename)))
# Handle the minimixer already running
if not self.jack_client.get_ports(
'minimixer:', is_input=True): # minimix not started
minimix_cmd = [
'/usr/local/bin/jackminimix', '-a', '-c',
str(totalStimuli), '-p',
str(osc_port)
]
self.p_minimix = Popen(minimix_cmd)
for i in range(5):
if self.jack_client.get_ports('minimixer:', is_input=True):
break
time.sleep(1.0)
if self.jack_client.get_ports('minimixer:', is_input=True):
print('JACK Minimixer started')
else:
raise (EnvironmentError("Could not start minimixer"))
else:
print('Connecting to existing minimixer instance.')
if filename is not None:
if inputPort:
portName = 'minimixer:in{}_{}'
if self.jack_client.get_all_connections(portName):
raise (ValueError(
"Specified port {} is already connected".format(
portName)))
else:
availablePortNames = [
p.name for p in self.jack_client.get_ports('minimixer:',
is_input=True)
]
if availablePortNames is None:
raise (EnvironmentError(
"Jack minimix appears not to be running."))
self.inputPort = None
inputPort = 1
portName = 'minimixer:in{}_{}'.format(inputPort, channel)
while portName in availablePortNames:
if not self.jack_client.get_all_connections(portName):
self.inputPort = inputPort
break
else:
inputPort = inputPort + 1
portName = 'minimixer:in{}_{}'.format(
inputPort, channel)
if not self.jack_client.get_ports(portName):
raise (EnvironmentError(
"Not enough minimixer ports. Restart with totalStimuli of at least {}"
.format(inputPort)))
else:
print('Input port: {}'.format(self.inputPort))
jackplay_cmd = [
'/usr/local/bin/sndfile-jackplay', '-l0',
'-a=minimixer:in{}_{}'.format(self.inputPort,
channel), '{}'.format(filename)
]
print(jackplay_cmd)
self.p_jackplay = Popen(jackplay_cmd, stdout=DEVNULL, stderr=DEVNULL)
time.sleep(0.25)
self.oscC = OSCClient('127.0.0.1', int(osc_port))
self.gain = -10.0
self.oscC.send_message(b'/mixer/channel/set_gain',
[int(self.inputPort), self.gain])
self.localized = None
def change_gain(self, gain):
if gain != self.gain:
self.oscC.send_message(b'/mixer/channel/set_gain',
[int(self.inputPort), gain])
self.gain = gain
def initLocalizedSound(self,
center,
width,
trackLength,
maxGain,
minGain,
offGain=-90.0):
self.localized = LocalizedSound(center, width, trackLength, maxGain,
minGain, offGain)
def pos_update_gain(self, pos):
if self.localized:
new_gain = self.localized.linear_gain_from_pos(pos)
self.change_gain(new_gain)
def close_processes(self):
self.p_jackplay.kill()
time.sleep(0.25)
if self.p_minimix:
self.p_minimix.kill()
time.sleep(0.25)
def __del__(self):
self.close_processes()
from oscpy.client import OSCClient
address = "127.0.0.1"
port = 8000
osc = OSCClient(address, port)
for i in range(10):
osc.send_message(b'/send_i', [i])
class Remote(App):
"Remote"
host = StringProperty()
scan_results = ListProperty()
background_color = ColorProperty('#000000FF')
clock_color = ColorProperty('#000000FF')
clock_font_size = NumericProperty()
current_screen = StringProperty()
def __init__(self, **kwargs):
super(Remote, self).__init__(**kwargs)
self.osc_server = None
self.scan_client = None
def on_start(self, **args):
"stuff"
self.current_screen = 'connect'
self.osc_server = server = OSCThreadServer()
self.osc_server.listen(address='0.0.0.0', port=PORT, default=True)
server.bind(b'/found', callback=self.found)
server.bind(b'/conf', callback=self.conf)
sock = socket(AF_INET, SOCK_DGRAM)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.settimeout(1)
self.scan_client = OSCClient(
address='255.255.255.255',
port=PEER_PORT,
sock=sock,
)
def found(self, *values):
"when peer is found"
print("peer found", values)
frames = inspect.getouterframes(inspect.currentframe())
for frame, filename, line, function, lines, index in frames:
if function == '_listen' and 'oscpy/server.py' in filename:
break
else:
raise RuntimeError('answer() not called from a callback')
host, _ = frame.f_locals.get('sender')
self.scan_results.append({
'name': values[0].decode('utf8'),
'host': host
})
def conf(
self,
background_r,
background_g,
background_b,
clock_r,
clock_g,
clock_b,
clock_font_size,
):
self.background_color = background_r, background_g, background_b
self.clock_color = clock_r, clock_g, clock_b
self.clock_font_size = clock_font_size
def scan(self):
"look for peers"
self.scan_results = []
self.scan_client.send_message(b'/probe', [])
def select_host(self, host):
"select peer"
self.host = host
print(self.host)
self.current_screen = 'remote'
self.send('get_conf')
def send(self, address, *values):
"send to peer"
print(address, values)
print(
self.osc_server.send_message(b'/%s' % address.encode('utf8'),
values,
ip_address=self.host,
port=PEER_PORT))
bodyId = 110 # TODO récupérer le vrai nums de body
msg = []
for point in points3D:
if point:
for i in range(3):
# Envoi en int
msg.append(int(point[i] * 1000))
# Si pas de point ajout arbitraire de 3 fois -1 pour avoir toujours
# 3*18 valeurs dans la liste
else:
msg.extend((-1000000, -1000000, -1000000)) # tuple ou list
# N° body à la fin
msg.append(bodyId)
data.append(msg)
client.send_message(b'/points', msg)
# Draw articulation 2D
for point in points2D:
if point:
cv2.circle(frame, (point[0], point[1]),
4, (0, 255, 255),
thickness=2)
# Draw Skeleton
for pair in POSE_PAIRS:
if points2D[pair[0]] and points2D[pair[1]]:
p1 = tuple(points2D[pair[0]])
p2 = tuple(points2D[pair[1]])
cv2.line(frame, p1, p2, (0, 255, 0), 2)
class ForceStamp (QtWidgets.QWidget):
def __init__(self, parent=None):
super(ForceStamp, self).__init__(parent)
self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.WindowCloseButtonHint)
self.ui = Ui_MainWindow() # import GUI layout
self.ui.setupUi(self) # initalization
# param names
self.param_names = ['posx_max', 'posx_min', 'posy_max', 'posy_min', 'force_max',
'force_min', 'cof_x_max', 'cof_x_min', 'cof_y_max', 'cof_y_min']
# Morph size
self.rows = 185
self.cols = 105
# self.radius = [12.8, 20]
self.marker_radii = [55 / 2 / 1.25, 17 / 1.25, 20.0, 16 / 1.25]
self.num_ID = 102
# Initialize combobox items
self.initComboBox()
# initialize spin boxes
self.initSpinBox()
# initialize progress bars
self.initProgressBar()
# initailize ID scale parameters
self.IDs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 51, 80, 101]
self.IDparam = [IDparameter() for count in range(self.num_ID)]
# initialize force image
self.initViewBox()
self.ui.pushButton.clicked.connect(self.onStartButton)
self._buttonFlag = False
# Open Morph
# try:
# self.handle, self.info = sc.open_sensel()
# except OSError:
# sc.close_sensel(self.handle, self.frame)
# # Open Morph
# self.handle, self.info = sc.open_sensel()
# # Initalize frame
# self.frame = sc.init_frame(self.handle)
# initalize marker storage
self.markers = []
# set marker sensitivity
self.force_sensitivity = 3000
self.cof_sensitivity = 10
# store previous state
self.prevState = [0] * self.num_ID
# Setup OSC server
# self.setupOSC()
address = '127.0.0.1'
# address = '192.168.0.3'
port = 12000
self.osc = OSCClient(address, port)
# update interval
self.interval = 0 # miliseconds
self.lastTime = time()
self.fps = None
# update using timer
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.updateData)
# self.timer.start(self.interval)
# marker information popup
self._popframe = None
self._popflag = False
self.SIGNALS = MarkerPopupSignals()
self.SIGNALS.OPEN.connect(self.onPopup)
self.SIGNALS.CLOSE.connect(self.closePopup)
self.BlobTracker = forcestamp.TrackBlobs()
self.MarkerTracker = forcestamp.TrackMarkers(radii=self.marker_radii)
def updateData(self):
# scan image from the device
try:
self.f_image = sc.scan_frames(self.handle, self.frame, self.info)
except(UnboundLocalError):
try:
sc.close_sensel(self.handle, self.frame)
# Open Morph
self.handle, self.i = sc.open_sensel()
# Initalize frame
self.frame = sc.init_frame(self.handle, baseline=0)
self.f_image = sc.scan_frames(self.handle, self.frame, self.info)
except(UnboundLocalError):
self.f_image = np.zeros((self.rows, self.cols))
# update blob information
self.blobs = self.BlobTracker.update(self.f_image)
# update marker information
self.MarkerTracker.update(self.f_image, self.blobs)
if len(self.MarkerTracker.markers) > 0:
# print('markerID: ' + str(self.markers[0].ID))
# print('markerForce: ' + str(self.markers[0].sumForce()))
# print('markerVectorForce: ' + str(self.markers[0].vectorForce()))
if not self._popflag:
self.SIGNALS.OPEN.emit()
else:
if self._popflag:
self.SIGNALS.CLOSE.emit()
# send marker parameters to GUI
self.sendMarkerParameters()
'''
# retrieve peak coordinates from the peak image
self.peaks = forcestamp.findPeakCoord(self.f_image_peaks)
# exclude marker areas from the peak coords
self.f_image_peaks_excluded = deepcopy(self.f_image_peaks)
for mkr in self.markers:
self.f_image_peaks_excluded = forcestamp.excludeMarkerPeaks(self.f_image_peaks_excluded, (mkr.pos_y, mkr.pos_x), mkr.radius)
self.peaks_excluded = forcestamp.findPeakCoord(self.f_image_peaks_excluded)
self.peaks_excluded = forcestamp.findSubpixelPeaks(self.peaks_excluded, self.f_image)
self.peaks_force = []
for pk in self.peaks_excluded:
self.peaks_force.append(np.sum(forcestamp.cropImage(self.f_image, pk, radius=3, margin=1)))
# print(self.peaks_excluded)
# print(self.peaks_force)
# print(self.peaks_excluded)
if len(self.peaks_excluded) > 0:
self.sendOSC_coords(self.peaks_excluded, self.peaks_force)
'''
# prepare a image copy for display
f_image_show = deepcopy(self.f_image)
if np.max(f_image_show) > 0:
f_image_show = f_image_show / np.max(f_image_show) * 255
f_image_show = cv2.cvtColor(f_image_show.astype(np.uint8), cv2.COLOR_GRAY2RGB)
# draw peaks
for b in self.blobs:
cv2.circle(
f_image_show,
(np.int(b.cx), np.int(b.cy)),
0,
(0, 255, 255)
)
# set image for display
self.img.setImage(np.rot90(f_image_show, 3), autoLevels=True, levels=(0, 50))
# self.calculateFPS()
QtGui.QApplication.processEvents()
def onStartButton(self):
if self._buttonFlag:
self._buttonFlag = True
# self.ui.pushButton.setText('Start')
else:
self._buttonFlag = True
# self.ui.pushButton.setText('Stop')
try:
self.handle, self.info = sc.open_sensel()
except OSError:
sc.close_sensel(self.handle, self.frame)
# Open Morph
self.handle, self.info = sc.open_sensel()
# Initalize frame
self.frame = sc.init_frame(self.handle, baseline=0)
# update using timer
# self.timer = QtCore.QTimer()
# self.timer.timeout.connect(self.updateData)
self.timer.start(self.interval)
def resizeEvent(self, event):
if self._popflag:
self._popframe.move(0, 0)
self._popframe.resize(self.width(), self.height())
def onPopup(self):
self._popframe = MarkerPopupWidget(self)
self._popframe.move(10, 10)
# print(self.ui.graphicsView.width(), self.ui.graphicsView.height())
self._popframe.resize(self.ui.graphicsView.width(), self.ui.graphicsView.height())
self._popflag = True
self._popframe.show()
def closePopup(self):
self._popframe.close()
self._popflag = False
def sendMarkerParameters(self):
posx_min = 30
posx_max = self.rows - 30
posy_min = 30
posy_max = self.cols - 30
force_min = 0
# force_max = 8000
# cof_x_min = -30000
# cof_x_max = 30000
# cof_y_min = -30000
# cof_y_max = 30000
cof_x_min = cof_y_min = -self.cof_sensitivity
cof_x_max = cof_y_max = self.cof_sensitivity
currentState = [0] * self.num_ID
# self.sendOSC(len(self.MarkerTracker.markers), '/num')
self.osc.send_message(b'/num', [len(self.MarkerTracker.markers)])
# self.sendOSC([0.0, 0.0, 0.1], 'pos_x')
pos_x = []
pos_y = []
force = []
cof_x = []
cof_y = []
angle = []
id_list = []
radius = []
for mkr in self.MarkerTracker.markers:
# mkr.pos_y = 104 - mkr.pos_y
# mkr.force = mkr.sumForce()
# (mkr.cof_x, mkr.cof_y) = mkr.vectorForce()
# mkr.cof_y *= -1
mkr.pos_x_scaled = (self.IDparam[mkr.ID].posx_max - self.IDparam[mkr.ID].posx_min) * ((forcestamp.constraint(mkr.pos_x, posx_min, posx_max) - posx_min) / (posx_max - posx_min)) + self.IDparam[mkr.ID].posx_min
mkr.pos_y_scaled = (self.IDparam[mkr.ID].posy_max - self.IDparam[mkr.ID].posy_min) * ((forcestamp.constraint(self.cols - mkr.pos_y, posy_min, posy_max) - posy_min) / (posy_max - posy_min)) + self.IDparam[mkr.ID].posy_min
mkr.force_scaled = (self.IDparam[mkr.ID].force_max - self.IDparam[mkr.ID].force_min) * ((forcestamp.constraint(mkr.force, force_min, self.force_sensitivity) - force_min) / (self.force_sensitivity - force_min)) + self.IDparam[mkr.ID].force_min
mkr.cof_x_scaled = (self.IDparam[mkr.ID].cof_x_max - self.IDparam[mkr.ID].cof_x_min) * ((forcestamp.constraint(mkr.cof_x, cof_x_min, cof_x_max) - cof_x_min) / (cof_x_max - cof_x_min)) + self.IDparam[mkr.ID].cof_x_min
mkr.cof_y_scaled = (self.IDparam[mkr.ID].cof_y_max - self.IDparam[mkr.ID].cof_y_min) * ((forcestamp.constraint(mkr.cof_y, cof_y_min, cof_y_max) - cof_y_min) / (cof_y_max - cof_y_min)) + self.IDparam[mkr.ID].cof_y_min
# store current state
currentState[mkr.ID] = 1
# send osc data
# self.sendOSC(mkr.pos_x_scaled, '/m' + str(mkr.ID) + '/pos_x')
# self.sendOSC(mkr.d_pos_x, '/m' + str(mkr.ID) + '/d_pos_x')
# self.sendOSC(mkr.pos_y_scaled, '/m' + str(mkr.ID) + '/pos_y')
# self.sendOSC(mkr.d_pos_y, '/m' + str(mkr.ID) + '/d_pos_y')
# self.sendOSC(mkr.force_scaled, '/m' + str(mkr.ID) + '/force')
# self.sendOSC(mkr.d_force, '/m' + str(mkr.ID) + '/d_force')
# self.sendOSC(mkr.cof_x_scaled, '/m' + str(mkr.ID) + '/cof_x')
# self.sendOSC(mkr.cof_y_scaled, '/m' + str(mkr.ID) + '/cof_y')
# self.sendOSC(mkr.d_cof_x, '/m' + str(mkr.ID) + '/d_cof_x')
# self.sendOSC(mkr.d_cof_y, '/m' + str(mkr.ID) + '/d_cof_y')
# self.sendOSC(np.rad2deg(mkr.rot), '/m' + str(mkr.ID) + '/rot')
# self.sendOSC(np.rad2deg(mkr.d_rot), '/m' + str(mkr.ID) + '/d_rot')
# self.sendOSC(mkr.ID, '/m' + str(mkr.ID) + '/id')
# osc.send_message(b'/ids', id_list)
pos_x.append(mkr.pos_x)
pos_y.append(mkr.pos_y)
force.append(mkr.force)
cof_x.append(mkr.cof_x)
cof_y.append(mkr.cof_y)
# angle.append(np.rad2deg(mkr.rot))
angle.append(mkr.rot)
id_list.append(mkr.ID)
radius.append(mkr.radius)
if self.currentID == mkr.ID and mkr.ID is not 0:
# send current parameters
self.ui.progressBar_posx.setValue(mkr.pos_x_scaled * 10)
self.ui.progressBar_posy.setValue(mkr.pos_y_scaled * 10)
self.ui.progressBar_force.setValue(mkr.force_scaled * 10)
self.ui.progressBar_cof_x.setValue(mkr.cof_x_scaled * 10)
self.ui.progressBar_cof_y.setValue(mkr.cof_y_scaled * 10)
self.ui.value_posx.setText(('%.01f' % mkr.pos_x_scaled))
self.ui.value_posy.setText(('%.01f' % mkr.pos_y_scaled))
self.ui.value_force.setText(('%.01f' % mkr.force_scaled))
self.ui.value_cof_x.setText(('%.01f' % mkr.cof_x_scaled))
self.ui.value_cof_y.setText(('%.01f' % mkr.cof_y_scaled))
# self.sendOSC(pos_x, '/pos_x')
# self.sendOSC(pos_y, '/pos_y')
# self.sendOSC(force, '/force')
# self.sendOSC(cof_x, '/cof_x')
# self.sendOSC(cof_y, '/cof_y')
# self.sendOSC(angle, '/angle')
# self.sendOSC(id_list, '/id')
# self.sendOSC(radius, '/radius')
self.osc.send_message(b'/pos_x', pos_x)
self.osc.send_message(b'/pos_y', pos_y)
self.osc.send_message(b'/force', force)
self.osc.send_message(b'/cof_x', cof_x)
self.osc.send_message(b'/cof_y', cof_y)
self.osc.send_message(b'/angle', angle)
self.osc.send_message(b'/id', id_list)
self.osc.send_message(b'/radius', radius)
# # send OSC messages when markers disappear
# index = np.where((np.asarray(self.prevState, dtype=np.int8) - np.asarray(currentState, dtype=np.int8)) == 1)
# # print(index[0])
# for i in index[0]:
# # print('send message to %d' % i)
# # print('/m' + str(i) + '/force')
# self.sendOSC(0.0, '/m' + str(i) + '/force')
# # self.sendOSC(0.0, '/m' + str(i) + '/rot')
# self.sendOSC(0.0, '/m' + str(i) + '/cof_x')
# self.sendOSC(0.0, '/m' + str(i) + '/cof_y')
# update state
self.prevState = currentState
def calculateFPS(self):
now = time()
dt = now - self.lastTime
self.lastTime = now
if self.fps is None:
self.fps = 1.0 / dt
else:
s = np.clip(dt * 3., 0, 1)
self.fps = self.fps * (1 - s) + (1.0 / dt) * s
print('%0.2f fps' % self.fps)
def setupOSC(self):
# setup OSC server
ip = '127.0.0.1'
port_num = 8002
parser = argparse.ArgumentParser()
parser.add_argument("--ip", default=ip, help="The ip of th OSC Server")
parser.add_argument("--port", type=int, default=port_num, help="The port the OSC server is listening on")
args = parser.parse_args()
self.client = udp_client.UDPClient(args.ip, args.port)
print('OSC server on: ' + ip + ':' + str(port_num))
def sendOSC(self, msg, address):
msgStruct = osc_message_builder.OscMessageBuilder(address=address)
msgStruct.add_arg(msg)
msgStruct = msgStruct.build()
self.client.send(msgStruct)
def sendOSC_coords(self, coords, force):
msgStructX = osc_message_builder.OscMessageBuilder(address='/coords/x')
msgStructY = osc_message_builder.OscMessageBuilder(address='/coords/y')
msgStructForce = osc_message_builder.OscMessageBuilder(address='/coords/force')
for m in coords:
msgStructX.add_arg(m[1])
msgStructY.add_arg(m[0])
for f in force:
msgStructForce.add_arg(f)
msgStructX = msgStructX.build()
msgStructY = msgStructY.build()
msgStructForce = msgStructForce.build()
self.client.send(msgStructX)
self.client.send(msgStructY)
self.client.send(msgStructForce)
def initViewBox(self):
# Create random image
self.img = pg.ImageItem()
view = self.ui.graphicsView
view.ci.layout.setContentsMargins(0, 0, 0, 0)
view.ci.layout.setSpacing(0)
self.viewBox = view.addViewBox()
# self.ui.graphicsView.scale(50, 50)
# view.setCentralWidget(viewBox)
self.viewBox.addItem(self.img)
self.viewBox.setAspectLocked(True)
self.viewBox.setRange(QtCore.QRectF(0, 0, 185 * 1, 105 * 1), padding=0)
self.viewBox.setMouseEnabled(x=False, y=False)
self.viewBox.setMenuEnabled(False)
data = np.random.normal(size=(185 * 1, 105 * 1), loc=1024, scale=64).astype(np.uint16)
self.img.setImage(data)
def initComboBox(self):
# insert IDs
self.ui.comboBox.addItem('ID')
self.ui.comboBox.addItem('1')
self.ui.comboBox.addItem('2')
self.ui.comboBox.addItem('3')
self.ui.comboBox.addItem('4')
self.ui.comboBox.addItem('5')
self.ui.comboBox.addItem('6')
self.ui.comboBox.addItem('7')
self.ui.comboBox.addItem('8')
self.ui.comboBox.addItem('9')
self.ui.comboBox.addItem('10')
self.ui.comboBox.addItem('11')
self.ui.comboBox.addItem('12')
self.ui.comboBox.addItem('51')
self.ui.comboBox.addItem('80')
self.ui.comboBox.addItem('101')
self.currentID = 0
# event on value change
self.ui.comboBox.activated[str].connect(self.onComboBoxActivated)
# self.ui.comboBox.activated[str].connect(self.onPopup)
def onComboBoxActivated(self, text):
# save current parameters
self.IDparam[self.currentID].posx_max = self.ui.doubleSpinBox_posx_max.value()
self.IDparam[self.currentID].posx_min = self.ui.doubleSpinBox_posx_min.value()
self.IDparam[self.currentID].posy_max = self.ui.doubleSpinBox_posy_max.value()
self.IDparam[self.currentID].posy_min = self.ui.doubleSpinBox_posy_min.value()
self.IDparam[self.currentID].force_max = self.ui.doubleSpinBox_force_max.value()
self.IDparam[self.currentID].force_min = self.ui.doubleSpinBox_force_min.value()
self.IDparam[self.currentID].cof_x_max = self.ui.doubleSpinBox_cof_x_max.value()
self.IDparam[self.currentID].cof_x_min = self.ui.doubleSpinBox_cof_x_min.value()
self.IDparam[self.currentID].cof_y_max = self.ui.doubleSpinBox_cof_y_max.value()
self.IDparam[self.currentID].cof_y_min = self.ui.doubleSpinBox_cof_y_min.value()
# change current marker ID
if text == 'ID':
self.currentID = 0
else:
self.currentID = int(text)
# print(self.currentID)
# print(self.IDparam[self.currentID].printParameters())
# load ID parameters and apply to current controls
for name in self.param_names:
evaltext = 'self.ui.doubleSpinBox_' + name + '.setValue(self.IDparam[self.currentID].' + name + ')'
eval(evaltext)
def initSpinBox(self):
for name in self.param_names:
eval('self.ui.doubleSpinBox_' + name + '.setRange(-1000, 1000)')
if 'max' in name: # if there's 'max' string
eval('self.ui.doubleSpinBox_' + name + '.setValue(100)')
else:
if 'vec' in name: # if the box is vector
eval('self.ui.doubleSpinBox_' + name + '.setValue(-100)')
else:
eval('self.ui.doubleSpinBox_' + name + '.setValue(0)')
eval('self.ui.doubleSpinBox_' + name + '.setDecimals(1)')
eval('self.ui.doubleSpinBox_' + name + '.setKeyboardTracking(False)')
eval('self.ui.doubleSpinBox_' + name + '.valueChanged.connect(self.onSpinBoxChanged)')
self.ui.doubleSpinBox_force_sens.setRange(0, 20000)
self.ui.doubleSpinBox_force_sens.setValue(3000)
self.ui.doubleSpinBox_force_sens.setDecimals(0)
self.ui.doubleSpinBox_force_sens.valueChanged.connect(self.onSensivityChanged)
self.ui.doubleSpinBox_cof_sens.setRange(0, 50000)
self.ui.doubleSpinBox_cof_sens.setValue(5)
self.ui.doubleSpinBox_cof_sens.setDecimals(0)
self.ui.doubleSpinBox_cof_sens.valueChanged.connect(self.onSensivityChanged)
def onSensivityChanged(self, value):
self.force_sensitivity = self.ui.doubleSpinBox_force_sens.value()
self.cof_sensitivity = self.ui.doubleSpinBox_cof_sens.value()
def onSpinBoxChanged(self, value):
# sender is the latest signal
sender = self.sender()
name = sender.objectName()
# save current parameter
exectext = 'self.IDparam[self.currentID].' + name[14:] + ' = self.ui.' + name + '.value()'
exec(exectext)
self.updateProgressBarRange()
def updateProgressBarRange(self):
# Change corresponding progress bar range
if self.ui.doubleSpinBox_posx_max.value() >= self.ui.doubleSpinBox_posx_min.value():
self.ui.progressBar_posx.setRange(10 * self.ui.doubleSpinBox_posx_min.value(), 10 * self.ui.doubleSpinBox_posx_max.value())
else:
self.ui.progressBar_posx.setRange(10 * self.ui.doubleSpinBox_posx_max.value(), 10 * self.ui.doubleSpinBox_posx_min.value())
if self.ui.doubleSpinBox_posy_max.value() >= self.ui.doubleSpinBox_posy_min.value():
self.ui.progressBar_posy.setRange(10 * self.ui.doubleSpinBox_posy_min.value(), 10 * self.ui.doubleSpinBox_posy_max.value())
else:
self.ui.progressBar_posy.setRange(10 * self.ui.doubleSpinBox_posy_max.value(), 10 * self.ui.doubleSpinBox_posy_min.value())
if self.ui.doubleSpinBox_force_max.value() >= self.ui.doubleSpinBox_force_min.value():
self.ui.progressBar_force.setRange(10 * self.ui.doubleSpinBox_force_min.value(), 10 * self.ui.doubleSpinBox_force_max.value())
else:
self.ui.progressBar_force.setRange(10 * self.ui.doubleSpinBox_force_max.value(), 10 * self.ui.doubleSpinBox_force_min.value())
if self.ui.doubleSpinBox_cof_x_max.value() >= self.ui.doubleSpinBox_cof_x_min.value():
self.ui.progressBar_cof_x.setRange(10 * self.ui.doubleSpinBox_cof_x_min.value(), 10 * self.ui.doubleSpinBox_cof_x_max.value())
else:
self.ui.progressBar_cof_x.setRange(10 * self.ui.doubleSpinBox_cof_x_max.value(), 10 * self.ui.doubleSpinBox_cof_x_min.value())
if self.ui.doubleSpinBox_cof_y_max.value() >= self.ui.doubleSpinBox_cof_y_min.value():
self.ui.progressBar_cof_y.setRange(10 * self.ui.doubleSpinBox_cof_y_min.value(), 10 * self.ui.doubleSpinBox_cof_y_max.value())
else:
self.ui.progressBar_cof_y.setRange(10 * self.ui.doubleSpinBox_cof_y_max.value(), 10 * self.ui.doubleSpinBox_cof_y_min.value())
def initProgressBar(self):
# Change corresponding progress bar range
self.ui.progressBar_posx.setRange(10 * self.ui.doubleSpinBox_posx_min.value(), 10 * self.ui.doubleSpinBox_posx_max.value())
self.ui.progressBar_posy.setRange(10 * self.ui.doubleSpinBox_posy_min.value(), 10 * self.ui.doubleSpinBox_posy_max.value())
self.ui.progressBar_force.setRange(10 * self.ui.doubleSpinBox_force_min.value(), 10 * self.ui.doubleSpinBox_force_max.value())
self.ui.progressBar_cof_x.setRange(10 * self.ui.doubleSpinBox_cof_x_min.value(), 10 * self.ui.doubleSpinBox_cof_x_max.value())
self.ui.progressBar_cof_y.setRange(10 * self.ui.doubleSpinBox_cof_y_min.value(), 10 * self.ui.doubleSpinBox_cof_y_max.value())
def closeEvent(self, event):
print('Exit application')
if self._buttonFlag:
sc.close_sensel(self.handle, self.frame)
sys.exit()
class CartPoleSwingUpEnv(gym.Env):
metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': 50
}
def __init__(self):
self.step_number = 0
self.reset_number = 0
self.action_number = 0
self.t = 0 # timestep
# Angle at which to fail the episode
# 12 * 2 * math.pi / 360 = 0,20943951
# self.teta_threshold_radians = 0.20943951 ???????
self.x_threshold = 10 # 2.4
self.t_limit = 1000
self.my_reward_total = 0
# N'est pas utilisé mais nécessaire pour gym
high = np.array([
np.finfo(np.float32).max,
np.finfo(np.float32).max,
np.finfo(np.float32).max,
np.finfo(np.float32).max,
np.finfo(np.float32).max
])
# Discrete
self.action_space = spaces.Discrete(2)
self.observation_space = spaces.Box(-high, high)
# Continuous
# #self.action_space = spaces.Box(-1.0, 1.0, shape=(1,))
# #self.observation_space = spaces.Box(-high, high)
self.seed()
self.viewer = None
self.state = None
# Le serveur pour recevoir
self.osc_server_init()
self.state_updated = 0
# Un simple client pour l'envoi
self.client = OSCClient(b'localhost', 3001)
def osc_server_init(self):
self.server = OSCThreadServer()
self.server.listen('localhost', port=3003, default=True)
self.server.bind(b'/result', self.on_result)
self.server.bind(b'/reset', self.on_reset)
self.server.bind(b'/contact', self.on_contact)
def on_contact(self, r):
self.state_updated = 1
self.reset()
self.state_updated = 0
def on_result(self, *args):
"""result = [x, x_dot, teta, teta_dot]"""
self.state = np.array(np.array(args))
self.state_updated = 1
def on_reset(self, r):
self.reset()
def seed(self, seed=None):
self.np_random, seed = seeding.np_random(seed)
return [seed]
def step(self, action):
# Envoi à Blender d'une action à réaliser
self.client.send_message(b'/action', [0, int(action * 1000)])
# #print("Action demandée =", action)
self.action_number += 1
if self.step_number % 100 == 0:
print(
" step number =",
self.step_number)
self.step_number += 1
# Attente de la réponse
loop = 1
while loop:
if self.state_updated == 1:
x, x_dot, teta, teta_dot = self.state
self.state_updated = 0
loop = 0
done = False
# self.x_threshold =
if x < -self.x_threshold or x > self.x_threshold:
print("En dehors de +-self.x_threshold = +-", self.x_threshold)
done = True
self.t += 1
if self.t >= self.t_limit:
print("Temps supérieur à t_limit =", self.t_limit)
done = True
# La récompense est définie ici, le goal est 0
# Reward_teta is
# 1 when teta is 90
# np.cos(teta) de 0 to 90 or -90 to 0,
# 0 if between 90 and 270 or -270 to -90
# 0 < Reward_teta < 1
reward_teta = max(0, np.cos(teta))
# Reward_x is 0 when cart is at the edge of the screen,
# 1 when it's in the centre
reward_x = np.cos((x / self.x_threshold) * (np.pi / 2.0))
# La récompense totale
reward = reward_teta * reward_x
self.my_reward_total += reward
obs = np.array([x, x_dot, np.cos(teta), np.sin(teta), teta_dot])
return obs, reward, done, {}
def reset(self):
"""np.random.normal()
loc floats Mean (centre) of the distribution.
scale floats Standard deviation (spread or width) of the distribution
np.random.normal( loc=np.array([0.0, 0.0, np.pi, 0.0]),
scale=np.array([0.2, 0.2, 0.2, 0.2]))
Le pendule est à teta=0 en haut, pi est ajouté dans always.py pour
avoir le zero en bas.
"""
print(
"Reset ........................................................ ")
print(" Nombre d'actions demandée =", self.action_number)
self.action_number = 0
if self.reset_number % 10 == 0:
print(" step reset =", self.reset_number)
self.reset_number += 1
print(" self.my_reward_total =", int(self.my_reward_total))
# np.pi remplacé par
self.state = np.random.normal(loc=np.array(
[0.0, 0.0, 3.141592654, 0.0]),
scale=np.array([0.05, 0.05, 2.0, 0.05]))
self.steps_beyond_done = None
self.t = 0 # timestep
x, x_dot, teta, teta_dot = self.state
self.client.send_message(b'/reset', self.state)
self.steps_beyond_done = None
obs = np.array([x, x_dot, np.cos(teta), np.sin(teta), teta_dot])
return obs
def render(self, mode='human', close=False):
pass