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_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 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))
