def take_photo_with_overlay(self): if (self.is_recording): return self.is_recording = True self.bus.post( event('status_update', { 'type': 'photo', 'value': 'start' })) self.bus.post(event('notification', 'Taking photo, please wait...')) filename = datetime.now().strftime('%d-%b-%Y_%H.%M.%S.png') temp_filename = 'temp.png' self.camera.capture(temp_filename) self.bus.post(event('notification', 'Done. Processing...')) photo = Image.open(temp_filename) crosshair_image = self.get_crosshair_image().resize((1080, 1140)) photo.paste(crosshair_image, (420, 0), crosshair_image) photo.save('photos/{0}'.format(filename), "PNG") self.bus.post(event('status_update', { 'type': 'photo', 'value': 'end' })) self.bus.post( event('notification', 'Photo saved as {0}'.format(filename))) os.remove(temp_filename) self.is_recording = False
def _check_if_button_was_touched(self, coordinates): x = coordinates[0] y = coordinates[1] #self.camera.annotate_text = '(' + str(x) + ',' + str(y) + ')' if (self.standard_overlay): if self._is_point_within(x, y, (700, 790, 30, 110)): self.bus.post(event('zoom', 'in')) elif self._is_point_within(x, y, (700, 790, 145, 230)): self.bus.post(event('zoom', 'out')) elif self._is_point_within(x, y, (700, 770, 260, 350)): self.show_options_layout() elif (self.options_overlay): if self._is_point_within(x, y, (700, 790, 30, 110)): self.show_standard_layout() elif self._is_point_within(x, y, (700, 790, 145, 230)): self.bus.post(event('crosshair', 'next')) elif self._is_point_within(x, y, (700, 790, 260, 350)): self.bus.post( event('video', 'start') ) # these are commands, not events. status_updates are the events elif self._is_point_within(x, y, (700, 790, 375, 470)): self.bus.post(event('photo', 'start')) elif self._is_point_within(x, y, (350, 450, 30, 110)): self.bus.post(event('adjust', 'up')) elif self._is_point_within(x, y, (350, 450, 380, 460)): self.bus.post(event('adjust', 'down')) elif self._is_point_within(x, y, (160, 260, 200, 300)): self.bus.post(event('adjust', 'left')) elif self._is_point_within(x, y, (540, 640, 200, 300)): self.bus.post(event('adjust', 'right')) elif (self.video_recording_overlay): if self._is_point_within(x, y, (700, 790, 30, 110)): self.bus.post( event('video', 'end') ) # again, this is a command. The status update (event) comes later
def loadConfigFromFile(self): config_file = open(CONFIG_FILE, 'r') lines = config_file.readlines() magnification_level = int(lines[0].strip()) self.latest_magnification_level = magnification_level crosshair_number = int(lines[1].strip()) self.latest_crosshair_number = crosshair_number adjustment = make_tuple(lines[2].strip()) self.latest_adjustment = adjustment self.bus.post(event('zoom',magnification_level)) self.bus.post(event('crosshair',crosshair_number)) self.bus.post(event('adjust',adjustment)) config_file.close()
def start_recording_video(self): if (self.is_recording): return self.is_recording = True video_filename = datetime.now().strftime('%d-%b-%Y_%H.%M.%S.mp4') self.last_filename_used = video_filename self.bus.post( event('status_update', { 'type': 'video', 'value': 'start' })) self.bus.post(event('notification', 'Recording video...')) self.camera.start_recording('temp.h264', resize=(1920, 1080))
def main(): eb = eventbus() parser = MessageParser(eb) cv = threading.Condition() #conditional Variable teq = TimeEventQueuer(eb, cv) teq.start() internet_check = InternetStatus(eb) weather_forcast = WeatherForcast(eb) client = FbClient(eb, parser) client.start() #eb.post(event(EVENTID_CLIENT_START,"")) """ print("Joining") while(client.isAlive()): time.sleep(1) client.join() """ client.join() print("Exiting Main Thread") eb.post(event(EVENTID_QUEUE_STOP, "")) teq.join() eb.shutdown()
def adjust(self, type): step = magnification_levels[self.magnification_level][1] zoom = self.camera.zoom new_zoom = None tolerance = magnification_levels[self.magnification_level][0][0] * 2 if (isinstance(type, tuple)): new_zoom = (type[0], type[1], zoom[2], zoom[3]) elif (type == 'up'): new_zoom = (zoom[0] - step, zoom[1], zoom[2], zoom[3]) elif (type == 'down'): new_zoom = (zoom[0] + step, zoom[1], zoom[2], zoom[3]) if (new_zoom[0] > tolerance): return elif (type == 'left'): new_zoom = (zoom[0], zoom[1] - step, zoom[2], zoom[3]) elif (type == 'right'): new_zoom = (zoom[0], zoom[1] + step, zoom[2], zoom[3]) if (new_zoom[1] > tolerance): return self.camera.zoom = new_zoom self.adjustement = (round(self.camera.zoom[0], 3), round(self.camera.zoom[1], 3)) self.bus.post( event('status_update', { 'type': 'adjustment', 'value': self.adjustement }))
def parseRemindMe(self,message_data): text = message_data.get_text().split() if(len(text)>1): text_time = text[1] time_delta = self.get_time_delta_from_text(text_time) else: message_data.set_text("Please Specify Time: !rm ?w?d?h?m?s") FbClient.post_message_event(self.eb,message_data) return text_message = "REMINDER" if(len(text) > 2): text_message += ": " + ' '.join(text[2:]) message_data.set_text(text_message) send_message_event = event(EVENTID_CLIENT_SEND,message_data) TimeEventQueuer.post_time_event(self.eb,send_message_event,time_delta) if(time_delta>timedelta(seconds = 15)): time_at = datetime.datetime.now() + time_delta reciept_text = "Reminder set at {} in {}".format( (':').join(str(time_at).split(':')[:-1]), str(time_delta).split('.')[0]) reciept_data = MessageData(reciept_text,message_data.get_id(), message_data.get_type()) FbClient.post_message_event(self.eb,reciept_data)
def show_standard_layout(self): """The initial, default layout with only three buttons""" #256/256 Large, 640/384 Medium, 736/480 Small - icon sizes pad = Image.new('RGBA', ( 640, 384, )) zoom_in_image = Image.open('icons/zoom_in.png') pad.paste(zoom_in_image, (550, 10), zoom_in_image) zoom_out_image = Image.open('icons/zoom_out.png') pad.paste(zoom_out_image, (550, 105), zoom_out_image) options_image = Image.open('icons/options.png') pad.paste(options_image, (550, 200), options_image) if (self.options_overlay): self.camera.remove_overlay(self.options_overlay) self.options_overlay = None standard_overlay = self.camera.add_overlay(pad.tobytes(), pad.size, layer=4) self.standard_overlay = standard_overlay self.bus.post( event('status_update', { 'type': 'layout', 'value': 'standard' }))
def handle_msg(self, command): ex = Exchange() try: ex.ParseFromString(command) except Exception as e: print 'Exception received ', e logging.error(e) self.transport.loseConnection() return exr = Exchange() if not self.registered: if not ex.HasField('hb'): exr.mid = ex.mid ex.sm.sv = StatusMsg.FAIL resp = exr.SerializeToString() outlen = len(resp) outbuf = pack('i', outlen) self.sendData(outbuf + resp) return else: self.registered = True hb = ex.hb self.clientId = hb.clientId statusdata = utility.get_StatusMsg_bin(ex.mid, StatusMsg.SUCCESS) self.sendData(statusdata) self.allclients.add_client(self.clientId, self) else: if ex.HasField('ur'): logging.debug('Unregistering client ' + self.clientId) self.allclients.unRegisterClient(self.clientId) self.transport.loseConnection() return self.allclients.add_client(self.clientId) if ex.HasField('clocks'): # details about locks is wanted c_locks = ex.clocks clientId = c_locks.clientId if not get_client().is_registered(clientId): exr.sm = CLIENT_NOT_REGISTERED resp = exr.SerializeToString() outlen = len(resp) outbuf(pack('i', outlen)) self.sendData(outbuf + resp) else: clocks = get_lc().getClientLocks(clientId) elif ex.HasField('ld'): logging.debug('Getting lock dettails ' + ex.ld.lockName) ld = get_lc().getLockDetails(ex.ld.lockName) lddata = utility.get_lockDetail_resp_msg(ex.mid, ld) self.sendData(lddata) elif ex.HasField('lc'): lcl = ex.lc logging.debug('Received lock request ' + ' ' + lcl.clientId + ' ' + lcl.cmd.lockId + ' ' + str(lcl.cmd.op.opval)) eobj = event(common.LOCKOP_TOPIC, ex, str(lcl.cmd.lockId)) self.ebus.post(eobj)
def handle_subscription(self, subscription_event): sub = subscription_event.get_data() occ = sub.get_occurrence() interval = sub.get_interval() msg_data = sub.get_data() weather_event = event(EVENTID_WEATHER_CHECK, msg_data) rep_event = RepeatingEventObject(self.eb, weather_event, occ, interval, 7) rep_event.queue() print("RepeatingEvent has been queued")
def stop_recording_video_and_save_with_overlay(self): self.camera.stop_recording() self.bus.post( event('status_update', { 'type': 'video', 'value': 'recording_stopped' })) self.bus.post(event('notification', 'Done. Processing, please wait...')) self._run_ffmpeg_command() #os.remove('temp.h264') self.is_recording = False self.bus.post(event('status_update', { 'type': 'video', 'value': 'end' })) self.bus.post( event('notification', 'Video saved as {0}'.format(self.last_filename_used)))
def parseRepeat(self,message_data): from repeating_event_object import RepeatingEventObject print("Parsing Repeat") message_data.set_text("Reapting This lol") send_message_event = event(EVENTID_CLIENT_SEND,message_data) start_time = datetime.datetime.now() + timedelta(seconds=5) repeat_delta = timedelta(seconds=5) repeat_event = RepeatingEventObject(self.eb, send_message_event, start_time, repeat_delta) repeat_event.queue()
def process(self, new_event): # print("Event Recieved: {}".format(new_event.get_topic())) if not isinstance(new_event, event): print("Invalid event type passed") return if (new_event.get_topic() == EVENTID_WEATHER_CHECK): msg_data = new_event.get_data() msg_data.set_text(self.get_weather()) self.eb.post(event(EVENTID_CLIENT_SEND, msg_data)) if (new_event.get_topic() == EVENTID_WEATHER_SUBSCRIPTION): self.handle_subscription(new_event)
def parse(self,message_data): text = message_data.get_text() print(text) print(message_data.get_id()) # echo if message start with @echo if text.startswith('!echo'): print("Echoing") message_data.set_text(text[6::]) FbClient.post_message_event(self.eb,message_data) return # send dad joke if message start with @dad if '!logout' in text: message_data.set_text("Logging out") FbClient.post_message_event(self.eb,message_data) sleep(1) print("Posting Stop event") self.eb.post(event(EVENTID_CLIENT_STOP,"")) elif text.startswith('!rm'): self.parseRemindMe(message_data) elif text.startswith('!help'): self.parseHelp(message_data) elif text.startswith('!repeat'): self.parseRepeat(message_data) elif text.startswith('!weather'): self.parseWeather(message_data) elif text.startswith('!sub'): self.parseSubscription(message_data) elif text.startswith('!ip'): self.parseIp(message_data) elif text.startswith('!capture'): self.parse_snapshot(message_data) elif '!dad' in text: print("Dading") joke = requests.get('https://icanhazdadjoke.com/', headers={'Accept': 'text/plain'}) joke.encoding = 'utf-8' message_data.set_text(joke.text) FbClient.post_message_event(self.eb,message_data) return elif text.startswith("!"): message_data.set_text(message_data.text + " is yet to be implemented") FbClient.post_message_event(self.eb,message_data)
def __init__(self, eb): super().__init__() self.previous = "Internet Status: Det er ikke registrert noen problemer i ditt område." self.eb = eb self.eb.register_consumer(self, EVENTID_INTERNET_CHECK) self.msg_data = MessageData('', thread_id=_THREAD_ID, thread_type=ThreadType.GROUP) self.repeating_event = RepeatingEventObject( eb, event(EVENTID_INTERNET_CHECK, None), datetime.now(), timedelta(minutes=4)) self.repeating_event.queue() print("internet status init")
def unRegisterClient(self, clientId): ret = StatusMsg.SUCCESS self.mutex.acquire() if clientId not in self.clients: ret = StatusMsg.CLIENT_NOT_REGISTERED else: oldtime = self.clients[clientId] oldexpirebucket = oldtime + (1023 - (1023 & oldtime)) + 1024 self.buckets[oldexpirebucket].remove(clientId) del self.clients[clientId] eobj = event(common.UNREGISTER_TOPIC, clientId, clientId) self.ebus.post(eobj) self.mutex.release() return ret
def queue(self): if (self.n == 0): print("RepeatingEvent Finished") return from datetime import datetime from time_event_queuer import TimeEventQueuer from geeteventbus.event import event self.n -= 1 # print("Posting REPEATING event") while (datetime.now() > self.occurence_time): self.occurence_time += self.repeat_time delta_time = self.occurence_time - datetime.now() time_event = event(EVENTID_REPEATING, self) TimeEventQueuer.post_time_event(self.eb, time_event, delta_time)
def set_crosshair(self, number): img = Image.open('crosshairs/crosshair' + str(number) + '.png') pad = Image.new('RGBA', ( ((img.size[0] + 31) // 32) * 32, ((img.size[1] + 15) // 16) * 16, )) pad.paste(img, (0, 0), img) if (self.crosshair_overlay): self.camera.remove_overlay(self.crosshair_overlay) self.crosshair_overlay = self.camera.add_overlay(pad.tobytes(), layer=3, size=img.size) self.crosshair_number = number self.bus.post( event('status_update', { 'type': 'crosshair', 'value': self.crosshair_number }))
def zoom(self, type): original_level = self.magnification_level if (isinstance(type, int)): self.magnification_level = type elif (type == 'in'): if (self.magnification_level == 5): return self.magnification_level = self.magnification_level + 1 elif (type == 'out'): if (self.magnification_level == 1): return self.magnification_level = self.magnification_level - 1 # we first need to adjust for exising adjustments base_level = magnification_levels[original_level][0] current_level = self.camera.zoom deviation = (round(base_level[0], 3) - round(current_level[0], 3), round(base_level[1], 3) - round(current_level[1], 3)) #print("Deviation: " + str(deviation)) new_level = magnification_levels[self.magnification_level][0] adjusted_new_level = (round(new_level[0], 3) - deviation[0], round(new_level[1], 3) - deviation[1], new_level[2], new_level[3]) #print("Adjusted new level: " + str(adjusted_new_level)) self.camera.zoom = adjusted_new_level human_readable_value = magnification_levels[ self.magnification_level][2] self.bus.post( event( 'status_update', { 'type': 'magnification_level', 'value': { 'human_readable_value': human_readable_value, 'number': self.magnification_level, 'x': round(self.camera.zoom[0], 3), 'y': round(self.camera.zoom[1], 3) } }))
def show_options_layout(self): """The secondary layout with buttons that provide secondary functionality""" pad = Image.new('RGBA', ( 640, 384, )) back_image = Image.open('icons/back.png') pad.paste(back_image, (550, 10), back_image) crosshair_image = Image.open('icons/crosshair_change.png') pad.paste(crosshair_image, (550, 105), crosshair_image) video_image = Image.open('icons/video.png') pad.paste(video_image, (550, 200), video_image) photo_image = Image.open('icons/photo.png') pad.paste(photo_image, (550, 295), photo_image) up_image = Image.open('icons/up.png') pad.paste(up_image, (280, 10), up_image) down_image = Image.open('icons/down.png') pad.paste(down_image, (280, 295), down_image) left_image = Image.open('icons/left.png') pad.paste(left_image, (135, 154), left_image) right_image = Image.open('icons/right.png') pad.paste(right_image, (425, 154), right_image) if (self.standard_overlay): self.camera.remove_overlay(self.standard_overlay) self.standard_overlay = None if (self.options_overlay): self.options_overlay.update(pad.tobytes()) else: options_overlay = self.camera.add_overlay(pad.tobytes(), pad.size, layer=4) self.options_overlay = options_overlay self.bus.post( event('status_update', { 'type': 'layout', 'value': 'options' }))
def post_message_event(eb,message_data): print("Posting event") eb.post(event(EVENTID_CLIENT_SEND,message_data))
def parse_snapshot(self,message_data): print("Posting snapshot event") self.eb.post(event(EVENTID_CLIENT_SNAPSHOT,message_data))
def parseWeather(self,message_data): self.eb.post(event(EVENTID_WEATHER_CHECK,message_data))
def post(self,eb): eb.post(event(self.topic,self))
def on_keyboard_key_press(self, key): #adjustements if (key == keyboard.KeyCode.from_char('a')): self.bus.post(event('adjust', 'left')) elif (key == keyboard.KeyCode.from_char('d')): self.bus.post(event('adjust', 'right')) elif (key == keyboard.KeyCode.from_char('w')): self.bus.post(event('adjust', 'up')) elif (key == keyboard.KeyCode.from_char('s')): self.bus.post(event('adjust', 'down')) #zooms elif (key == keyboard.KeyCode.from_char('q')): self.bus.post(event('zoom', 'in')) elif (key == keyboard.KeyCode.from_char('e')): self.bus.post(event('zoom', 'out')) #temp bindings for testing elif (key == keyboard.KeyCode.from_char('z')): self.bus.post(event('crosshair', 'next')) elif (key == keyboard.KeyCode.from_char('1')): self.bus.post(event('crosshair', 1)) elif (key == keyboard.KeyCode.from_char('2')): self.bus.post(event('crosshair', 2)) elif (key == keyboard.KeyCode.from_char('3')): self.bus.post(event('crosshair', 3)) elif (key == keyboard.KeyCode.from_char('p')): self.bus.post(event('photo', 'start')) elif (key == keyboard.KeyCode.from_char('v')): self.bus.post(event('video', 'start')) elif (key == keyboard.KeyCode.from_char('b')): self.bus.post(event('video', 'end')) elif (key == keyboard.KeyCode.from_char('o')): self.bus.post(event('layout', 'options')) elif (key == keyboard.KeyCode.from_char('i')): self.bus.post(event('layout', 'standard'))
def on_touch(self, x, y, button, pressed): if (pressed): self.bus.post(event('touch', (x, y)))
def __call__(self): while self.keep_running: ev = event(self.counters[randint(0, self.num_counter - 1)], randint(1, 100)) ebus.post(ev) sleep(0.02) print('producer exited')
def send(self, module, cmd, data): self.eb.post(event(module, {'cmd': cmd, 'data': data}))
def post_time_event(eb, data, delta_time): event_time = datetime.now() + delta_time #ms removed # print("EVENT scheduled at {}".format(event_time)) data = (event_time, data) eb.post(event(EVENTID_TIME, data))