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