def get(self, api):
memory_file = StringIO()
g = Grabber(api)
g.grab(memory_file)
self.response.headers['Content-Type'] = 'application/zip'
self.response.headers[
'Content-Disposition'] = ('attachment;filename={}.zip'.format(api))
self.response.write(memory_file.getvalue())
memory_file.close()
def process_queue(self):
map_fromsettings = True
if not self.cell_list:
self.cell_list = []
if self.config.get('map','render_from') == 'webdir':
self.cell_list.extend(self._get_regions_from_apache_dir(self.config.get('service','render_webdir')))
elif self.config.get('map','render_from') == 'dsm':
self.cell_list.extend(self._get_regions_from_dsm())
else:
print 'select a valid(db/webdir) scavenging method!'
return
self._clean_tilepath()
self.processor.write_helpers()
map_fromsettings = False
self.init_map(map_fromsettings)
grabber = Grabber(self,self.config.getint('service','grab_workers'))
grabber.grab(self.cell_list)
return {'cells':len(self.cell_list)}
class Toddler:
MOTOR_PORT = 1
BUMP_SENSOR_SHELF_1 = 0
BUMP_SENSOR_SHELF_2 = 1
BUMP_SENSOR_GRABBER_FRONT = 2
BUMP_SENSOR_GRABBER_BACK = 3
def __init__(self, onRobot):
IO = IOTools(onRobot)
print('Grabber initialised')
self.camera = IO.camera.initCamera('pi', 'low')
self.getInputs = IO.interface_kit.getInputs
self.getSensors = IO.interface_kit.getSensors
self.mc = IO.motor_control
self.mc.stopMotors()
self.sc = IO.servo_control
self.sc.engage()
self.grabber = Grabber(self.mc, self.MOTOR_PORT, self.sc)
#self.grabber.prepare_grabber()
self.lift = Lift(onRobot, self.mc)
self.lift_pos = 0
self.s = None
# self.mc.setMotor(self.MOTOR_PORT, 100)
# time.sleep(3)
# self.mc.stopMotors()
def kill_socket(self):
s.close()
def listen(self):
global halt
try:
PORT = 65432 # Port to listen on (non-privileged ports are > 1023)
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# HOST = socket.gethostbyname(socket.gethostname())
HOST = '192.168.105.139'
self.s.bind(('192.168.105.139', PORT))
print("Listening on {}:{}".format(HOST, PORT))
self.s.listen(1)
conn, addr = self.s.accept()
while not (halt['stop']):
data = conn.recv(1024)
data = data.decode('utf-8')
data = data.split(' ')
print("Listen: " + data[0])
if data[0] == 'grab':
self.grabber.grab(self)
elif data[0] == 'upper_grab':
self.grabber.upper_grab(self)
elif data[0] == 'prepare':
self.grabber.prepare_grabber()
elif data[0] == 'retract':
self.grabber.retract_grabber()
elif data[0] == 'wait_for_bump':
inp = self.getInputs()
while inp[self.BUMP_SENSOR_SHELF_1] == 0 or inp[
self.BUMP_SENSOR_SHELF_2] == 0:
print(inp)
print("bump")
elif data[0] == 'lift':
if int(data[1]) < self.lift_pos:
print('down')
self.lift.lift('down')
elif int(data[1]) > self.lift_pos:
print('up')
self.lift.lift('up')
self.lift_pos = int(data[1])
time.sleep(0.5)
elif data[0] == 'drop':
self.grabber.prepare_grabber()
while inp[self.BUMP_SENSOR_GRABBER_BACK] == 0:
print('Waiting for collection')
self.grabber.retract_grabber()
print("Listen done")
conn.sendall(b'done')
conn.close()
except KeyboardInterrupt:
conn.close()
return
def control(self):
global halt
try:
thread = Thread(target=self.listen)
thread.daemon = True
thread.start()
print("here")
rjr = RobotJobListener(('192.168.105.38', 9000),
('192.168.105.139', 65432),
('192.168.105.94', 65433))
rjr.start_reliable_listener('robot')
# start pinging the server
# server, rasppi, ev3
except KeyboardInterrupt:
halt['stop'] = True
self.sc.disengage()
return
def vision(self):
# image = self.camera.getFrame()
# self.camera.imshow('Camera', image)
time.sleep(0.05)
return
class ScreenRecorder(object):
grp = None
dimmensions = None # Screen area
attempt = 1
keypresses = []
buffer_write = None # Write pointer
buffer_read = None # Read pointer
space_pressed = False
attempt_startime = 0
attempt_endtime = 0
times = [] # List with the time progression of each attempt
writter = None # For saving video
# sfrag example: (1, 26, 1601, 926) captures 1600x900
# without the window bar
def __init__(self, sfrag, buffer_len=2):
self.grb = Grabber(bbox=sfrag)
# Calculate screen size
size = (sfrag[2]-sfrag[0], sfrag[3]-sfrag[1])
self.dimmensions = size + (3,)
# Set the frame buffer to zeros
self.buffer_write = np.zeros(self.dimmensions, dtype=np.int8)
self.buffer_read = np.zeros(self.dimmensions, dtype=np.int8)
self.space_pressed = False
# Grabs a frame and sotores it in buffer[buffer_head]
# Also grabs the key value
def refresh_frame(self):
if wapi.GetAsyncKeyState(32):
self.space_pressed = True
else:
self.space_pressed = False
self.buffer_write = self.grb.grab(None)
self.buffer_write, self.buffer_read = self.buffer_read, self.buffer_write
# Gets the newest frame from buffer[buffer_head]
def get_newest_frame(self):
return self.buffer_read
def capture_live(self, show=False, save=False, savePath="video_raw.mp4", time_frame=5, cut_attempt=False):
time_start = time.time()
if save and (savePath != None):
fps=60 # !!!
if cut_attempt:
size = (self.dimmensions[0]-200, self.dimmensions[1]-100)
else:
size = (self.dimmensions[0], self.dimmensions[1])
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
writer = cv2.VideoWriter(savePath, fourcc, fps, size)
self.attempt_startime = time.time()
while True:
# Cambiar por tecla !!!
if time.time() - time_start > time_frame:
break
self.refresh_frame()
self.keypresses.append(self.key_check(32))
self.update_attempt()
# Recortar el frame
if cut_attempt:
frame = self.reduce_frame(self.buffer_read)
else:
frame = self.buffer_read
# Muestra la grabacion
if show:
#frame = self.buffer_read
cv2.imshow('frame',frame)
cv2.waitKey(1)
if save:
#frame = self.buffer_read
time.sleep(0.01)
writer.write(frame)
if save:
writer.release()
np.asarray(self.keypresses)
np.savez_compressed("keypresses_raw.npz", self.keypresses, allow_pickle=True)
def update_attempt(self, tolerance=0):
last_frame = self.get_attempt_area(self.buffer_read)
last_last_frame = self.get_attempt_area(self.buffer_write)
if self.attempt_has_changed(last_frame, last_last_frame, tolerance):
self.attempt_endtime = time.time()
self.times.append(self.attempt_endtime - self.attempt_startime)
print(f"Attempt: {self.attempt}, Time: {self.times[-1]}")
self.attempt += 1
self.attempt_startime = time.time()
return True
return False
# Isolates a small area that indicates the attempt number
# from a frame
def get_attempt_area(self, frame):
return frame[0:100, 390:480]
def attempt_has_changed(self, frame1_attempt_area, frame_2_attempt_area, tolerance=0):
diff = frame1_attempt_area - frame_2_attempt_area
m_norm = np.sum(abs(diff)) # Manhattan norm
#z_norm = norm(diff.ravel(), 0) # Zero norm
if m_norm > tolerance:
return True
return False
def reduce_frame(self, frame):
return frame[100:, 200:]
def key_check(self, key):
if wapi.GetAsyncKeyState( key):
return True
return False
from grabber import Grabber
from flask import Flask, jsonify, request, Response
import json
import os.path
import re
# Variables
URL = "https://cat-fact.herokuapp.com/facts"
FILENAME = "data.json"
if not os.path.isfile(FILENAME):
g = Grabber()
g.grab(URL, FILENAME)
app = Flask(__name__)
@app.route('/', methods=["GET"])
def home():
return "Welcome to cat facts"
@app.route('/api/v1/catfacts', methods=["GET"])
def get_catfacts():
# Create a params dict to hold query parameters
params = {}
params['firstname'] = request.args.get('firstname')
params['lastname'] = request.args.get('lastname')
params['id'] = request.args.get('id')
print("params is ", params)
