def hyperloop():
imageFolder = None
imageNum = 0
logger = Logger('relog')
logger.setLogLevel('debug')
logger.info('Started replay')
state = State()
for p in sys.argv:
if (os.path.isdir(p)):
imageFolder = p
elif (p.isdigit()):
imageNum = int(p)
elif (p == "-lap"):
state.Approaching = Signal.LAP
elif (p == "-up"):
state.Approaching = Signal.UPPER
elif (p == "-lo"):
state.Approaching = Signal.LOWER
elif (p == "-s"):
state.Approaching = Signal.UPPER
if (state.Approaching != Signal.LAP):
state.setStopSignal(1)
camera = Camera(None, True)
if imageFolder:
# program loop
files = sorted_aphanumeric(os.listdir(imageFolder))
while True:
try:
file = os.path.join(imageFolder, files[imageNum])
logger.info("[" + str(imageNum) + "] Loaded file: " + file)
image = cv2.imread(file, 1)
camera.capture(image)
key = cv2.waitKey(0) & 0xFF
if key == ord("n"):
# cv2.destroyAllWindows()
if (imageNum + 1 < len(files)):
imageNum += 1
elif key == ord("b"):
# cv2.destroyAllWindows()
if (imageNum - 1 >= 0):
imageNum -= 1
elif key == ord('q'):
break
except KeyboardInterrupt:
break
except Exception as e:
logger.logError(e)
traceback.print_exc(limit=3, file=sys.stdout)
logger.info('Stopped')
def on_open(ws):
camera = Camera()
filepath = uuid.uuid4()
filename = '%s.jpg' % filepath
camera.snapshot(filename)
file = open('images/'+filename, "rb").read()
file_data = base64.b64encode(file)
ws.send(json.dumps({'upload_file': file_data}))
time.sleep(0.2)
def __init__(self, config):
self.config = config
calib_file = "../" + config['cam']['calibration']
calib = {}
with open(calib_file, 'r') as ymlfile:
calib = yaml.load(ymlfile, Loader=yaml.FullLoader)
self.camera = Camera(config, calib)
def __init__(self):
self.tasks = []
self.camera = Camera()
self.window = Window('Camera')
self.should_detect = True
self.trackers = []
self.color_filter = ColorFilter()
def start():
cams = [{
"tz":
"ID",
"url":
'https://cf-stream.coastalwatch.com/cw/' +
os.environ.get('CAMNAME', 'bondicamera') + '.stream/chunklist.m3u8',
"framerate":
int(os.environ.get('FR', '20')),
"videolength":
os.environ.get('LENGTH', '00:06:00')
}]
cam = Camera(cams, test=TEST)
cam.start = True
for img in cam:
if cam.start:
height, width, _ = img.shape
panarama = Panarama(img, height, width)
cam.start = False
else:
panarama.stitch(img)
# if no more states
if not panarama.REQUIREDSTATESBEFORERESET:
cam.resetnext = True
# either display at constant framerate (if zero display last frame)
if (cam.framerate > 0
and cam.f % cam.framerate == 0) or (cam.framerate == 0
and cam.resetnext):
if TEST:
img = cv2.imencode('.jpg', img)[1]
frame = img.tostring()
# yield (b'--frame\r\n'
# b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
else:
frame = np.flip(panarama.raw, axis=2)
(h, w, _) = frame.shape
im = Image.fromarray(frame)
name = cams[0]['url'][:-22].split('/')[-1]
dir = "/tmp/frame-" + name + ".jpeg"
#im = im.resize((w, h*2), Image.ANTIALIAS)
im.save(dir, quality=100)
sp.check_call('gsutil -m mv -a public-read ' + dir +
' gs://handy-contact-219622.appspot.com/frame-' +
name + '.jpeg',
shell=True)
def __init__(self, parent=None):
QtOpenGL.QGLWidget.__init__(self, parent)
self.setAutoFillBackground(False)
self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent, True)
self.setAttribute(QtCore.Qt.WA_NoSystemBackground, True)
self.setAttribute(QtCore.Qt.WA_StaticContents, True)
self.setAttribute(QtCore.Qt.WA_PaintOnScreen, True)
self.setMouseTracking(True)
self._mousePos = QtCore.QPoint()
self._zoomAnchor = QtCore.QPoint()
self.zoomPos1 = QtCore.QPoint()
self.zoomPos2 = QtCore.QPoint()
self.camera = Camera()
self.camera.identity()
self.settings = {}
self.settingsFilename = os.path.expanduser("~/%s.%s" % ("editor", "settings"))
self.loadSettings()
self.move(self.settings.get("x", 0), self.settings.get("y", 0))
self.resize(self.settings.get("w", 450), self.settings.get("h", 700))
def __init__(self):
destiny_coords = [29.15168, -81.01726];
partial_degree = 0;
camera = Camera();
camera_frame = None;
lidar = Lidar();
radar = Radar();
imu = Imu();
navigation = Navigation();
destiny = imu.get_degrees_and_distance_to_gps_coords(29.15168, -81.01726);
# Create new threads
thread_camera = CameraThread(1, "CameraThread");
thread_lidar = LidarThread(2, "LidarThread");
thread_navigation = NavigationThread(3, "NavigationThread");
thread_main = MainThread(4, "MainThread");
# Start Threads
thread_camera.start();
thread_lidar.start();
thread_main.start();
thread_navigation.start();
thread_camera.join();
thread_lidar.join();
thread_main.join();
thread_navigation.join();
print ("Terminating Main Program");
def __init__(self):
# Pygame launch
pygame.display.set_caption("SANTARENA")
# Screen (camera)
self.camera = Camera()
# Tilemap
self.tilemap = Tilemap(MAP_H, MAP_W)
# Characters
self.character = Character()
self.enemies = []
# Clock
self.clock = Clock()
self.dt = 0
def __init__(self):
super().__init__()
self.organisms = {}
self.camera = Camera(cfg.SCENE_WIDTH, cfg.SCENE_HEIGHT)
self.surface = pygame.Surface((cfg.SCENE_WIDTH, cfg.SCENE_HEIGHT))
self.zoom = 1
self.play = False
self.clock = pygame.time.Clock()
self.interval = 0
def __init__(self):
self.initParam()
self.pan_speed = 0
self.tilt_speed = 0
self.latestImage = None
# init
self.robot = Robot()
self.ball_detector = BallDetector()
self.camera = Camera()
def __init__(self):
self.tasks = []
self.camera = Camera()
self.window = Window('Camera')
self.should_detect = True
self.trackers = []
self.color_filter = ColorFilter()
def __init__(self, fps, duration, W, H, R, osm_cart, usgs_cart):
self._id = mp.current_process().name
self._fps = fps
self._duration = duration
self._W = W
self._H = H
self._R = R
self._osm_cart = osm_cart
self._usgs_cart = usgs_cart
self._dist = 3.0 * self._R
self._frames = self._duration * self._fps
self._camera = Camera()
self._camera.set_focal(50.0)
self._camera.set_factor(30)
self._camera.set_center(self._W / 2, self._H / 2)
self._usgs_cart_2d = np.zeros((2, self._usgs_cart.shape[1]), dtype = 'f4')
def __init__(self):
# read config file
config = configparser.ConfigParser()
config.read(self.config_filename)
refresh_in_seconds = 1
# exit on unavailable config file
if len(config) == 1:
sys.exit("Config file not found or empty, please create ./%s" %
(self.config_filename))
# exit if sections not present
if 'default' not in config.sections():
sys.exit("Default settings not found")
refresh_in_seconds = int(config['default']['refresh_in_seconds'])
# exit if sections not present
if 'camera' not in config.sections():
sys.exit("Camera settings not found")
self.cam = Camera(config['camera'])
# exit if sections not present
if 'backend' not in config.sections():
sys.exit("Backend settings not found")
self.backend_notifier = BackendNotifier(config['backend'])
# exit if sections not present
if 'parking_lot' not in config.sections():
sys.exit("Parking lot settings not found")
self.parking_lot = ParkingLot(config['parking_lot'], self.cam)
# write any changes to config
with open(self.config_filename, 'w') as configfile:
config.write(configfile)
# Execute Main Loop
self.execute(refresh_in_seconds)
def add_faces():
if not os.path.exists(DATABASE_DIR):
os.mkdir(DATABASE_DIR)
# face_id = input('Name: ')
face_id = sys.argv[1]
face_dir = DATABASE_DIR + face_id
if not os.path.exists(face_dir):
os.mkdir(face_dir)
camera = Camera()
face_detector = FaceDetector(FACE_CASCADES)
counter = 1
timer = 0
cv2.namedWindow('Video Feed', cv2.WINDOW_AUTOSIZE)
cv2.namedWindow('Saved Face', cv2.WINDOW_NORMAL)
while counter < 26:
frame = camera.get_frame()
# frame = camera.ip_camera(True)
face_coordinate = face_detector.detect(frame)
if len(face_coordinate):
shape = 'rectangle'
frame, face_image = get_images(frame, face_coordinate, shape)
if timer % 100 == 20:
cv2.imwrite(face_dir + '/' + str(counter) + '.jpg', face_image[0])
print(json.dumps({
'imageCounter': str(counter)
}))
counter += 1
cv2.imshow('Saved Face', face_image[0])
cv2.imshow('Video Feed', frame)
cv2.waitKeyEx(50)
timer += 20
if cv2.waitKey(100) & 0xFF == 27:
sys.exit()
else:
print(json.dumps({
'message': 'Face ID already exist',
'status': 'false'
}))
def __init__(self):
self.initParam()
self.pan_speed = 0
self.tilt_speed = 0
# init
self.robot = Robot()
self.ball_detector = BallDetector()
self.camera = Camera(self.imageCallback)
# move robot head to center
self.robot.center()
# load timer
rospy.Timer(rospy.Duration(1.0 / self.rate), self.robotUpdate)
def __init__(self, Story):
self.rsc = Resources()
self.camera = Camera(self.rsc.graphics, (0, 100, 0, 50))
self._timekeeper = TimeKeeper()
self._timekeeper.schedule('draw', 1.0 / settings.target_fps)
self._timekeeper.schedule('input', 1.0 / 100.0)
self._timekeeper.schedule('update_game', 1.0 / 50.0, game = True)
self._timekeeper.schedule('update', 1.0 / 50.0)
self._timekeeper.set_game_speed(settings.game_speed)
# world objects
self.fields = {}
for fieldtype in fieldtypes:
field = fieldtype()
self.fields[fieldtype] = field
self.actors = []
# initiate story
self.story = Story(self)
self.run()
class Main:
def __init__(self):
self.tasks = []
self.camera = Camera()
self.window = Window('Camera')
self.should_detect = True
self.trackers = []
self.color_filter = ColorFilter()
def add_target(self, filename):
self.trackers.append(Tracker(filename))
def clear(self):
for tracker in self.trackers:
tracker.clear()
def loop(self):
runner = CmdRunner(self)
runner.start()
while runner.isAlive():
while len(self.tasks) > 0:
task = self.tasks.pop(0)
task.execute()
try:
img = self.camera.get_frame()
if img is None:
self.window.clear()
continue
img = cv2.resize(img, (640, 480))
# TODO: show color mask
color_mask = self.color_filter.filter(img)
next_should_detect = self.should_detect
for tracker in self.trackers:
if self.should_detect:
rect = tracker.detect(img)
if rect is not None:
ret = tracker.update_window(img, rect)
self.window.draw_rectangle(rect, (255, 0, 255))
next_should_detect = False
rect = tracker.track(img)
if rect is None:
next_should_detect = True
continue
self.window.draw_rectangle(rect, (255, 0, 0))
self.should_detect = next_should_detect
except Exception as e:
print >> sys.stderr, e
finally:
self.window.update()
runner.join(0)
def _add_task(self, task):
self.should_detect = True
self.tasks.append(task)
def do_add_target(self, filename):
self._add_task(Task(self.add_target, (filename, )))
def do_clear(self):
self._add_task(Task(self.clear))
def do_snapshot(self, filename):
self._add_task(Task(self.window.snapshot, (filename, )))
def do_switch_camera(self, cid):
self._add_task(Task(self.camera.switch, (cid, )))
def keyboard_event_handler(self):
k = cv2.waitKey(1)
if k == 27:
self.quit = True
self.ms.close()
elif k == ord('t'):
self.ip.toggle_threshold = not self.ip.toggle_threshold
elif k == ord('g'):
self.ip.toggle_grayscale = not self.ip.toggle_grayscale
elif k == ord('g'):
self.ip.toggle_grayscale = not self.ip.toggle_grayscale
elif k == ord('f'):
self.ip.toggle_face_detection = not self.ip.toggle_face_detection
elif k == ord('z'):
self.ip.threshold_limit -= self.ip.threshold_delta
elif k == ord('u'):
self.ip.threshold_limit += self.ip.threshold_delta
def run(self):
while not self.quit:
self.ms.update_cam(0)
self.ms.update_cam(1)
self.keyboard_event_handler()
if __name__ == '__main__':
lv = LiveViewer(Camera('/dev/video1'), Camera('/dev/video3'))
lv.run()
remote_camera = False
initial_delay = 0
save = False
load = False
saved_directory = './saved'
body_address = ('192.168.1.4', 8089)
height = 120
width = 160
randomized_input = False
assert 2 * temp_buffer_length <= buffer_length, "Size of temp_buffer_length is too large!"
FLAG = {'time_point': 1., 'running': True, 'buffer_avg': 0., 'stream_avg': 0.}
# cmara setup
cam = Camera()
if remote_camera:
# connect to body
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connection.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
connection.settimeout(100)
connection.connect(body_address)
# receive stream
cam.receive(connection)
else:
cam.setSize(width, height)
cam.capture()
image_sample = cam.getFrame()
from lib.home_surveillance import HomeSurveillance
cpu = CPUTemperature()
cputemp = cpu.temperature
#################
# Instantiation #
#################
# Create an instance of the telegram bot
bot = Bot(token=TOKEN_ID)
# Create an instance of HomeSurveillance
surveillance = HomeSurveillance()
# Create an instance of the camera
camera = Camera(PiCamera(), REGISTRATION_FOLDER)
###########
# Utility #
###########
def restricted(func):
"""Restrict usage of func to allowed users only and replies if necessary"""
@wraps(func)
def wrapped(update, context, *args, **kwargs):
chat_id = update.effective_chat.id
if int(chat_id) != int(CHAT_ID):
update.message.reply_text('Unauthorized access.')
return None # quit function
return func(update, context, *args, **kwargs)
#!/usr/bin/env python3
#-*-coding:utf-8-*-
import pickle
import gzip
from lib.server import Server
from lib.camera import Camera, MultiStream
from lib.image_utils import resize, grayscale
import cv2
class CamServer(Server):
def func(self, sreq):
if sreq.strip() == '0':
iar = grayscale(resize(s0.__next__(), (320, 240)))
return gzip.compress(pickle.dumps(iar))
elif sreq.strip() == '1':
iar = grayscale(resize(s1.__next__(), (320, 240)))
return gzip.compress(pickle.dumps(iar))
else:
return b""
s0 = Camera('/dev/video1').start_stream()
s1 = Camera('/dev/video3').start_stream()
cs = CamServer()
cs.start()
def main():
'''
メイン処理を行う部分
'''
global stop_thread_running
global main_thread_running
# I2C Bus number
BUSNUM = 1
# CAR設定
HANDLE_NEUTRAL = 95 # ステアリングニュートラル位置
HANDLE_ANGLE = 42 # 左右最大アングル
# カメラ設定
COLS = 160
ROWS = 120
FPS = 5
# 通信設定
HOST = '192.168.0.77' # Server IP Address
PORT = 6666 # Server TCP Port
#HOST = '34.224.145.198' # AWS
#PORT = 8091 # AWS
#HOST = '192.168.0.17' # PC
#PORT = 8091 # PC
sock = None
try:
########################################
# CAR準備
########################################
car = Car(busnum=BUSNUM)
speed = 0
########################################
# カメラ準備
########################################
camera = Camera()
camera.init_webcam(cols=COLS, rows=ROWS, fps=FPS, save=False)
frame_count = 0
########################################
# 通信準備
########################################
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (HOST, PORT)
sock.connect(server_address)
is_need_header_send = True
########################################
# 画像サイズ、FPSをサーバに送る
########################################
message = "CAMERA," + str(COLS) + "," + str(ROWS) + "," + str(FPS / 5)
sock.sendall(message.encode('ascii'))
########################################
# 処理開始
########################################
while main_thread_running:
start_time, clock_time = time.time(), time.clock()
if not stop_thread_running: break # 強制停止ならループを抜ける
# カメラ画像を読み込む
for i in range(5):
if not camera.webcam_capture():
break
frame_count += 1
########################################
# 送信するデータを準備する
########################################
bytes = cv2.imencode('.jpg', camera.cv_bgr)[1].tostring()
size = len(bytes)
########################################
# 最初にデータサイズを送り、返答を待つ
########################################
if is_need_header_send:
# send image size to server
#print("send size = {}".format(size))
sock.sendall(("SIZE %s" % size).encode('ascii'))
answer = sock.recv(4096)
answer = answer.decode('ascii')
#print('answer = {}'.format(answer))
########################################
# 画像データを送り、返答を待つ
########################################
if answer == 'GOT SIZE':
is_need_header_send = False
sock.sendall(bytes)
# 画像データ送信後、0.5秒したら前回制御命令で動作している車両を停止する
time.sleep(0.5)
car.stop()
# check what server send
answer = sock.recv(4096)
answer = answer.decode('ascii')
print('answer = {}'.format(answer))
########################################
# 車両制御を行う
########################################
if answer.startswith('CONTROL'):
is_need_header_send = True
_, speed, handle_angle = answer.split(',')
speed = int(float(speed))
handle_angle = int(float(handle_angle))
print("CONTROL,speed={},handle_angle={}".format(
speed, handle_angle))
# 動作可能な角度内に調整する
if handle_angle > HANDLE_ANGLE:
handle_angle = HANDLE_ANGLE
if handle_angle < -1 * HANDLE_ANGLE:
handle_angle = -1 * HANDLE_ANGLE
if not stop_thread_running: break # 強制停止ならループを抜ける
########################################
# 車両を制御する
########################################
car.set_angle(HANDLE_NEUTRAL + handle_angle)
if speed == 0:
car.stop()
else:
car.forward(speed)
print("FPS:{} ".format(1 / (time.time() - start_time)))
# サーボを高速動作させるとRPに電力遮断されてカメラが動作不能になるため、車両制御にsleepを入れる
time.sleep(0.2)
except:
import traceback
traceback.print_exc()
finally:
main_thread_running = False
stop_thread_running = False
pass
if sock is not None:
sock.close()
car.stop()
car.set_angle(HANDLE_NEUTRAL)
return
class GLView(QtOpenGL.QGLWidget):
_zoom_coeff = 0.05
_scale_coeff = 1.2
_scale_coeff1 = 1/_scale_coeff
def __init__(self, parent=None):
QtOpenGL.QGLWidget.__init__(self, parent)
self.setAutoFillBackground(False)
self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent, True)
self.setAttribute(QtCore.Qt.WA_NoSystemBackground, True)
self.setAttribute(QtCore.Qt.WA_StaticContents, True)
self.setAttribute(QtCore.Qt.WA_PaintOnScreen, True)
self.setMouseTracking(True)
self._mousePos = QtCore.QPoint()
self._zoomAnchor = QtCore.QPoint()
self.zoomPos1 = QtCore.QPoint()
self.zoomPos2 = QtCore.QPoint()
self.camera = Camera()
self.camera.identity()
self.settings = {}
self.settingsFilename = os.path.expanduser("~/%s.%s" % ("editor", "settings"))
self.loadSettings()
self.move(self.settings.get("x", 0), self.settings.get("y", 0))
self.resize(self.settings.get("w", 450), self.settings.get("h", 700))
def saveSettings(self):
fout = open(self.settingsFilename, "w")
pprint.pprint(self.settings, fout)
fout.close()
def loadSettings(self):
try:
fin = open(self.settingsFilename, "r")
self.settings = eval(fin.read())
fin.close()
except:
pass
def moveEvent(self, event):
self.settings["x"] = self.x()
self.settings["y"] = self.y()
QtOpenGL.QGLWidget.moveEvent(self, event)
def resizeEvent(self, event):
self.settings["w"] = self.width()
self.settings["h"] = self.height()
QtOpenGL.QGLWidget.resizeEvent(self, event)
def closeEvent(self, event):
self.saveSettings()
QtOpenGL.QGLWidget.closeEvent(self, event)
def glInit(self):
QtOpenGL.QGLWidget.glInit(self)
def initializeGL(self):
glDisable(GL_DEPTH_TEST)
glDisable(GL_LIGHTING)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0.0, self.width(), self.height(), 0.0, -1.0, 1.0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
def convertNumpyToGLTexture(self, rgb): # rgb should be numpy array
glEnable(texture_mode)
tex_id = glGenTextures(1)
glBindTexture(texture_mode, tex_id)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(texture_mode, 0, GL_RGB, rgb.shape[0], rgb.shape[1], 0, GL_RGB, GL_UNSIGNED_BYTE, rgb)
glTexParameterf(texture_mode, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameterf(texture_mode, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameterf(texture_mode, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(texture_mode, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glDisable(texture_mode)
return tex_id
def resizeGL(self, width, height):
self.setUpdatesEnabled(False)
glViewport(0, 0, self.rect().width(), self.rect().height())
self.initializeGL()
self.setUpdatesEnabled(True)
def _beforeScale(self):
self.zoomPos1 = self.camera.qt_to_opengl(self._zoomAnchor)
def _afterScale(self):
self.zoomPos2 = self.camera.qt_to_opengl(self._zoomAnchor)
self.camera.translate((self.zoomPos2.x() - self.zoomPos1.x()) * self.camera.m[0],
(self.zoomPos2.y() - self.zoomPos1.y()) * self.camera.m[0])
def wheelEvent(self, event):
self._zoomAnchor = event.pos()
self._beforeScale()
# math.pow(self._scale_coeff, math.copysign(1, event.delta()))
# => 3 times slower (as measured with timeit module)
if event.delta() > 0:
self.camera.scale(self._scale_coeff)
else:
self.camera.scale(self._scale_coeff1)
self._afterScale()
def mousePressEvent(self, event):
QtOpenGL.QGLWidget.mousePressEvent(self, event)
self._mousePos = event.pos()
self._zoomAnchor = event.pos()
#if event.buttons() & QtCore.Qt.LeftButton:
# self.playhead = event.x()
self.update()
def mouseReleaseEvent(self, event):
QtOpenGL.QGLWidget.mouseReleaseEvent(self, event)
self._mousePos = event.pos()
self.update()
def mouseMoveEvent(self, event):
QtOpenGL.QGLWidget.mouseMoveEvent(self, event)
dx = event.x() - self._mousePos.x()
dy = event.y() - self._mousePos.y()
self._mousePos = event.pos()
if (event.buttons() & QtCore.Qt.MidButton) and (event.modifiers() & QtCore.Qt.AltModifier):
self.camera.translate(dx, dy)
elif (event.buttons() & QtCore.Qt.RightButton) and (event.modifiers() & QtCore.Qt.AltModifier):
self._beforeScale()
self.camera.scale(1.0 + math.copysign(self._zoom_coeff, dx))
self._afterScale()
self.update()
class World:
"""
A container for all level objects (actors, fields)
A time source
"""
def __init__(self, Story):
self.rsc = Resources()
self.camera = Camera(self.rsc.graphics, (0, 100, 0, 50))
self._timekeeper = TimeKeeper()
self._timekeeper.schedule('draw', 1.0 / settings.target_fps)
self._timekeeper.schedule('input', 1.0 / 100.0)
self._timekeeper.schedule('update_game', 1.0 / 50.0, game = True)
self._timekeeper.schedule('update', 1.0 / 50.0)
self._timekeeper.set_game_speed(settings.game_speed)
# world objects
self.fields = {}
for fieldtype in fieldtypes:
field = fieldtype()
self.fields[fieldtype] = field
self.actors = []
# initiate story
self.story = Story(self)
self.run()
def get_time(self): return self._timekeeper.get_game_time()
def pause(self): self._timekeeper.pause()
def set_speed(self, val): self._timekeeper.set_game_speed(val)
def get_speed(self): return self._timekeeper.get_game_speed()
def run(self):
story = self.story
player = story.get_player()
rsc = self.rsc
# debug objects
tm = debug.StatSet('World main loop timers')
tm.add(debug.Timer,
'update', 'update_actors', 'update_magic', 'update_fields',
'draw', 'draw_actors', 'draw_magic', 'draw_fields', 'events', 'calibrate')
ct = debug.StatSet('World main loop counters')
ct.add(debug.RateCounter, 'fps', 'update', 'input')
debug_rl = debug.RateLimit(1.0, exp = 0)
dd = debug.DrawDebug()
stats = ""
# input event handlers
if player is not None:
c_char = CharacterControl(self, player)
else:
c_char = None
c_game = GameControl(self, player)
while True:
# exit condition
if story.exit_now == True:
return
# wait for the next scheduler event
tm.calibrate.start()
sch_event = self._timekeeper.wait_for_event()
tm.calibrate.end()
if sch_event == "update_game":
## update
tm.update.start()
# actors moving
tm.update_actors.start()
if not self._timekeeper.paused():
for actor in self.get_actors(exclude = [actors.MagicParticle]):
actor.update()
tm.update_actors.end()
# magic moving
tm.update_magic.start()
if not self._timekeeper.paused():
for actor in self.get_actors(include = [actors.MagicParticle]):
actor.update()
tm.update_magic.end()
# storyline evolving
story.update()
# update fields
tm.update_fields.start()
for fieldtype in self.fields.keys():
self.fields[fieldtype].update()
tm.update_fields.end()
tm.update.end()
ct.update.count()
elif sch_event == "update":
# camera movements
self.camera.update()
elif sch_event == "draw":
## draw
tm.draw.start()
rsc.graphics.clear()
# clear allocated debug message space
dd.clear_allocations()
total_actor_count = total_magic_count = draw_actor_count = draw_magic_count = 0
# background changes slightly in color
if self._timekeeper.paused():
day = -1.0
rsc.graphics.fill([16, 32, 96])
else:
day = math.sin(time.time()) + 1
rsc.graphics.fill([day * 32, 32 + day * 32, 128 + day * 32])
# draw actors
self.sort_actors()
tm.draw_actors.start()
for actor in self.get_actors(exclude = [actors.MagicParticle]):
total_actor_count += 1
if actor.draw():
draw_actor_count += 1
if settings.debug and actor.debug_me:
dd.draw_msg(actor.debug_info(), *actor.get_xy())
tm.draw_actors.end()
# magic particles
tm.draw_magic.start()
for actor in self.get_actors(include = [actors.MagicParticle]):
total_magic_count += 1
if actor.draw():
draw_magic_count += 1
if settings.debug and actor.debug_me:
dd.draw_msg(actor.debug_info(), *actor.get_xy())
tm.draw_magic.end()
# draw fields
tm.draw_fields.start()
for field in self.all_fields():
field.draw(self.camera)
tm.draw_fields.end()
# draw storyline elements
story.draw()
# draw performance stats
if settings.debug:
if debug_rl.check():
# dump stats to debug log
#tm.dump()
#ct.dump()
# do not update stats when paused
if not self._timekeeper.paused():
def p(t, *parts):
r = ()
for part in parts:
if t == 0:
r += (float(part), 0.0)
else:
r += (float(part), float(part) / float(t) * 100.0)
return r
stats = "FPS: %.1f UPDATE: %.1f EVENT: %.1f\n" % (ct.fps, ct.update, ct.input)
draw_left = tm.draw - tm.draw_actors - tm.draw_magic - tm.draw_fields
stats += "DRAW=%.3f" % (tm.draw)
stats += " (actors=%.3f/%u%% magic=%.3f/%u%% fields=%.3f/%u%% left=%.3f/%u%%)" % \
p(tm.draw, tm.draw_actors, tm.draw_magic, tm.draw_fields, draw_left)
stats += " actors=%u/%u balls=%u/%u\n" % \
(draw_actor_count, total_actor_count, draw_magic_count, total_magic_count)
update_left = tm.update - tm.update_actors - tm.update_magic - tm.update_fields
stats += "UPDATE=%.3f" % (tm.update)
stats += " (actors=%.3f/%u%% magic=%.3f/%u%% fields=%.3f/%u%% left=%.3f/%u%%) calibrate=%.3f" % \
(p(tm.update, tm.update_actors, tm.update_magic, tm.update_fields, update_left) + (tm.calibrate,))
dd.draw_stats(stats)
dd.draw_msg(debug.debugger.last_messages)
# draw ball selector
if c_char is not None and c_char.get_magic:
i = 1
for ball in c_char.local_balls:
ball_txt = rsc.fonts.textfont.render("%u: %s" % (i, ball.__class__.__name__), True, ball.field.color)
ball_nr = rsc.fonts.textfont.render("%u" % (i), True, ball.field.color)
rsc.graphics.blit(ball_txt, (10, 40 + i * 20))
rsc.graphics.blit(ball_nr, (self.camera.pl2sc_x(ball.pos), self.camera.sc_h() - 80))
i += 1
rsc.graphics.update()
tm.draw.end()
ct.fps.count()
elif sch_event == "input":
## handle events
tm.events.start()
for event in pygame.event.get():
if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE:
return
c_game.handle(event)
if c_char is not None:
c_char.handle(event)
tm.events.end()
ct.input.count()
## actor management
def new_actor(self, actor_class, pos):
actor = actor_class(self, pos)
self.actors.append(actor)
return actor
def del_actor(self, actor):
self.actors.pop(self.actors.index(actor))
def all_actors(self):
return self.actors
def get_actors(self, x1 = False, x2 = False, filter = False, include = False, exclude = False):
"""
Get actors with position in range [x1 : x2] and matching filter
"""
ret = []
for actor in self.actors:
if x1 and actor.pos < x1:
continue
if x2 and actor.pos > x2:
continue
if filter and not filter(actor):
continue
if include:
decision = False
for klass in include:
if isinstance(actor, klass):
decision = True
break
if not decision:
continue
if exclude:
decision = True
for klass in exclude:
if isinstance(actor, klass):
decision = False
break
if not decision:
continue
ret.append(actor)
return ret
def sort_actors(self):
self.actors.sort(lambda x, y: cmp(x.stacking, y.stacking) or cmp(x.pos, y.pos))
# field management
def get_field(self, fieldtype):
return self.fields[fieldtype]
def all_fields(self):
return self.fields.values()
auto_settings = settings.get_auto()
# Find closest allowed ISO
speed = auto_settings['iso']
speeds = [100, 200, 320, 400, 500, 640, 800]
iso = 800
minimum_diff = float('inf')
for value in speeds:
diff = abs(speed - value)
if diff <= minimum_diff:
minimum_diff = diff
iso = value
auto_settings['iso'] = iso
# Setup camera for capture
camera = Camera()
camera.set_settings(auto_settings)
photo_counter = 0
# Check for previous folders
for content in list_dir(frames_dir):
if path_exists(frames_dir + '/' + content):
folder_number = (int(content) + 1) * 1000
if folder_number > photo_counter:
photo_counter = folder_number
# Start main loop
while 1==1:
# Set pins for next stepper motor
for index in range(0, 4):
pin = step_pins[index]
def startConsole(directory=None, camera_address=None):
if directory is None:
should_save = False
else:
should_save = True
if not os.path.isdir(directory):
os.makedirs(directory)
dir_positive = os.path.join(directory, 'positives')
if not os.path.isdir(dir_positive):
os.makedirs(dir_positive)
files_positive = glob.glob(os.path.join(dir_positive, '*.png'))
if files_positive:
files_positive = [
os.path.split(file)[1] for file in files_positive
]
files_positive = [
int(os.path.splitext(file)[0]) for file in files_positive
]
id_positive = sorted(files_positive)[-1] + 1
else:
id_positive = 0
dir_negative = os.path.join(directory, 'negatives')
if not os.path.isdir(dir_negative):
os.makedirs(dir_negative)
files_negative = glob.glob(os.path.join(dir_negative, '*.png'))
if files_negative:
files_negative = [
os.path.split(file)[1] for file in files_negative
]
files_negative = [
int(os.path.splitext(file)[0]) for file in files_negative
]
id_negative = sorted(files_negative)[-1] + 1
else:
id_negative = 0
print("Starting positive id from %i and negative id from %i." %
(id_positive, id_negative))
cam = Camera()
if camera_address is None:
send_command = False
cam.setSize(160, 120)
cam.capture()
else:
send_command = True
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connection.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
connection.settimeout(100)
connection.connect(camera_address)
# cam.receive(connection) # TODO: refactore camera module
pygame.init()
fpsClock = pygame.time.Clock()
# http://www.pygame.org/docs/ref/display.html#pygame.display.set_mode
surface = pygame.display.set_mode((width, height), 0, 0)
pygame.display.set_caption('Control Console')
pygame.mouse.set_visible(1)
background = pygame.Surface(surface.get_size())
background.fill((20, 20, 20))
# test=pygame.image.load("test.png")
rect = pygame.Rect(0, 0, width, height)
border_time = 0.
forward = 0.
turn = 0.
keep_running = True
while keep_running:
# surface.blit(background,(0,0))
# frame_received = cam.getFrame()
# frame = cv2.resize(frame_received, (width, height))
# frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
# frame = np.rot90(frame)
# frame = pygame.surfarray.make_surface(frame)
# surface.blit(frame, (0, 0))
reward = 0
events = pygame.event.get()
for event in events:
if event.type == QUIT:
keep_running = False
print('Exiting!!!')
if event.type == KEYDOWN:
if (event.key == K_q):
print('q')
if event.key == K_EQUALS:
border_time = time()
border_color = [0, 255, 0]
reward = 1
if should_save:
writeFrame(
frame_received,
os.path.join(dir_positive, '%i' % id_positive))
id_positive += 1
elif event.key == K_MINUS:
border_time = time()
border_color = [255, 0, 0]
reward = -1
if should_save:
writeFrame(
frame_received,
os.path.join(dir_negative, '%i' % id_negative))
id_negative += 1
if event.key == K_ESCAPE:
keep_running = False
print('Exiting!!!')
if time() - border_time < .2:
pygame.draw.rect(surface, border_color, rect, border)
keys_pressed = pygame.key.get_pressed()
if keys_pressed[K_RIGHT]:
turn = runningMean(1, turn, agility)
elif keys_pressed[K_LEFT]:
turn = runningMean(-1, turn, agility)
else:
turn = runningMean(0, turn, agility)
if keys_pressed[K_UP]:
forward = runningMean(1, forward, agility)
elif keys_pressed[K_DOWN]:
forward = runningMean(-1, forward, agility)
else:
forward = runningMean(0, forward, agility)
if abs(turn) < .1:
_turn = 0.
else:
_turn = turn
if abs(forward) < .1:
_forward = 0.
else:
_forward = forward
message = struct.pack(">cffc", "s", _forward, _turn, "e")
# print(struct.unpack(">cffc",message))
if send_command:
connection.send(message)
# if forward or turn or reward:
print("Positives: %i | Negatives: %i" % (id_positive, id_negative))
print("%+i | %+ 1.3f | %+ 1.3f" % (reward, forward, turn))
stdout.write("\033[F\033[K")
stdout.write("\033[F\033[K")
pygame.display.flip() # or pygame.display.update()
fpsClock.tick(FPS)
pygame.quit()
class Main:
config_filename = 'config'
cam = None
parking_lot = None
backend_notifier = None
def __init__(self):
# read config file
config = configparser.ConfigParser()
config.read(self.config_filename)
refresh_in_seconds = 1
# exit on unavailable config file
if len(config) == 1:
sys.exit("Config file not found or empty, please create ./%s" %
(self.config_filename))
# exit if sections not present
if 'default' not in config.sections():
sys.exit("Default settings not found")
refresh_in_seconds = int(config['default']['refresh_in_seconds'])
# exit if sections not present
if 'camera' not in config.sections():
sys.exit("Camera settings not found")
self.cam = Camera(config['camera'])
# exit if sections not present
if 'backend' not in config.sections():
sys.exit("Backend settings not found")
self.backend_notifier = BackendNotifier(config['backend'])
# exit if sections not present
if 'parking_lot' not in config.sections():
sys.exit("Parking lot settings not found")
self.parking_lot = ParkingLot(config['parking_lot'], self.cam)
# write any changes to config
with open(self.config_filename, 'w') as configfile:
config.write(configfile)
# Execute Main Loop
self.execute(refresh_in_seconds)
def execute(self, refresh_in_seconds):
self.cam.start()
frame_num = -1
while (True):
check, frame = self.cam.getNextFrame()
frame_num += 1
if (check and
(frame_num %
(self.cam.fps * refresh_in_seconds) == 0 or frame_num == 0)):
spots.find(frame, self.parking_lot)
frame_small = cv2.resize(frame, (1280, 720))
cv2.imshow('Free spots marked with green (press q to close)',
frame_small)
if (frame_num % (self.cam.fps * 2) == 0):
self.backend_notifier.notifyAll(
self.parking_lot.parking_spots)
frame_num = 0
if (cv2.waitKey(1) & 0xFF == ord('q')):
break
self.cam.stop()
class Game:
def __init__(self):
# Pygame launch
pygame.display.set_caption("SANTARENA")
# Screen (camera)
self.camera = Camera()
# Tilemap
self.tilemap = Tilemap(MAP_H, MAP_W)
# Characters
self.character = Character()
self.enemies = []
# Clock
self.clock = Clock()
self.dt = 0
def start(self):
"""
Called once.
"""
# Set the camera in the center of the map
self.camera.posH = (self.tilemap.h - self.camera.h) / 2
self.camera.posW = (self.tilemap.w - self.camera.w) / 2
# Set the character sprite in the center of the screen
self.character.posH = (self.camera.posH +
(self.camera.h - self.character.rectH) / 2)
self.character.posW = (self.camera.posW +
(self.camera.w - self.character.rectW) / 2)
# Spawn some enemies
for _ in range(3):
randH = randrange(400)
randW = randrange(700)
self.enemies.append(Enemy(randH, randW))
def event(self):
# Quit
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
# Full screen toggle
if event.type is pygame.KEYDOWN and event.key == pygame.K_f:
if self.camera.screen.get_flags() & pygame.FULLSCREEN:
pygame.display.set_mode(self.camera.size)
else:
pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
# Character
self.character.event(
pygame.key.get_pressed(),
self.camera,
self.enemies,
self.tilemap.blocks,
self.dt,
)
# Enemies
for enemy in self.enemies:
enemy.event(self.character, self.enemies, self.tilemap.blocks)
# Camera
self.camera.move(pygame.key.get_pressed(), self.character, self.dt)
def update(self):
# Map
self.tilemap.update(self.camera)
# Character & projectiles
self.character.update(self.camera, self.tilemap.blocks, self.dt)
# Enemies
for enemy in self.enemies:
enemy.update(self.character, self.enemies, self.camera, self.dt)
# Tic tac
self.dt = self.clock.tick(FPS)
def draw(self):
# Reset
self.camera.screen.fill(COLORS["BLACK"])
# Tilemap
self.tilemap.draw(self.camera)
# Enemies
for enemy in self.enemies:
enemy.draw(self.camera)
# Character
self.character.draw(self.camera)
pygame.display.update()
class Grid(Character):
def __init__(self):
super().__init__()
self.organisms = {}
self.camera = Camera(cfg.SCENE_WIDTH, cfg.SCENE_HEIGHT)
self.surface = pygame.Surface((cfg.SCENE_WIDTH, cfg.SCENE_HEIGHT))
self.zoom = 1
self.play = False
self.clock = pygame.time.Clock()
self.interval = 0
def update(self, event):
zw = int(cfg.ORG_WIDTH*self.zoom)
zh = int(cfg.ORG_HEIGHT*self.zoom)
if event.type == pygame.MOUSEMOTION:
# Mouse position
pos = event.pos
# Mouse velocity
vel = event.rel
# Add organisms when drawing
if event.buttons == (True, False, False):
x = int((pos[0]/ zw + self.camera.x) )
y = int((pos[1]/ zh + self.camera.y) )
self.organisms[(x, y)] = Organism()
# Move the viewport
if event.buttons == (False, True, False):
dx = -int(vel[0]) / zw
dy = -int(vel[1]) / zh
self.camera.move(dx, dy)
# delete organisms
if event.buttons == (False, False, True):
x = int((pos[0]/ zw + self.camera.x) )
y = int((pos[1]/ zh + self.camera.y) )
if (x, y) in self.organisms.keys():
del(self.organisms[(x, y)])
if event.type == pygame.MOUSEBUTTONUP:
if event.button == 5:
# zoom smaller
self.zoom = self.zoom * .9
if event.button == 4:
# zoom larger
self.zoom = self.zoom * 1.1
if event.type == pygame.KEYUP:
self.play = not self.play
if self.play:
self.interval = self.interval + self.clock.tick()
if self.interval > 1000 / cfg.GRID_FPS:
self.interval = 0
self.generate()
# Blit organisms that are in view
self.surface.fill((255,255,255))
visible = self.camera.focus(self.organisms, self.zoom)
for (x, y) in visible:
org = visible[(x, y)]
#TODO: call these functions only once when necessary, not every iteration
if not self.play:
org.sprite.animation.pause()
else:
org.sprite.animation.unpause()
org.update()
# scale the sprite surface to the zoom factor
zoomed = pygame.transform.scale(org.sprite.surface, (zw, zh))
self.surface.blit(zoomed, (
(x - self.camera.x) * zw,
(y - self.camera.y) * zh
))
def generate(self):
new = {}
for coord in self.organisms.keys():
org = self.organisms[coord]
neighbors = self.live_neighbors(coord)
# determine if the organism should remain alive
if neighbors <= 1:
pass
elif neighbors >= 4:
pass
else:
new[coord] = org
# get a list of nearby dead organisms
dead = self.dead_neighbors(coord)
for coord in dead:
# resurrect it if it has 3 living neighbors
neighbors = self.live_neighbors(coord)
if neighbors == 3:
new[coord] = Organism()
self.organisms = new
def dead_neighbors(self, pos):
coords = []
for i in range(-1,2):
for z in range(-1,2):
rpos = (pos[0]+i,pos[1]+z)
if not rpos in self.organisms.keys():
coords.append(rpos)
return coords
def live_neighbors(self, pos):
n = 0
for i in range(-1,2):
for z in range(-1,2):
rpos = (pos[0]+i,pos[1]+z)
if rpos in self.organisms.keys() and not rpos == pos:
n = n + 1
return n
@app.route('/droneblocks/<path:path>', methods=['GET'])
def droneblocks(path):
if not os.path.isfile(os.path.join(static_file_dir, path)):
path = os.path.join(path, 'tello.html')
return send_from_directory(static_file_dir, path)
if __name__ == "__main__":
# Initialize the drone class
drone = Drone(is_aruco_tracking_enabled=True)
# Camera for stream, photo, video
camera = Camera(drone)
# Udp for sending commands
udp = UDP()
udp.start_listening()
# Create the mission handler
mission = Mission(udp, camera)
# Handle Tello's state information
telemetry = Telemetry(drone)
telemetry.receive_telemetry()
# Fire up the app
app.run()
class _worker_context:
def __init__(self, fps, duration, W, H, R, osm_cart, usgs_cart):
self._id = mp.current_process().name
self._fps = fps
self._duration = duration
self._W = W
self._H = H
self._R = R
self._osm_cart = osm_cart
self._usgs_cart = usgs_cart
self._dist = 3.0 * self._R
self._frames = self._duration * self._fps
self._camera = Camera()
self._camera.set_focal(50.0)
self._camera.set_factor(30)
self._camera.set_center(self._W / 2, self._H / 2)
self._usgs_cart_2d = np.zeros((2, self._usgs_cart.shape[1]), dtype = 'f4')
def render_frame(self, frame_index):
angle = 2 * math.pi * frame_index / self._frames
self._camera.set_position(self._dist * math.cos(angle), self._dist * math.sin(angle), 0.0)
self._camera.set_direction(_rad(180.0) + angle, 0.0)
get_points = self._camera.compiled_get_points()
image = Image(self._W, self._H, background_color = (0.1, 0.1, 0.1))
for line in self._osm_cart:
image.draw_polygon(
*[self._camera.get_point(*point) for point in line],
line_color = (0.7, 0.7, 0.7),
line_width = 0.3,
)
get_points(self._usgs_cart, self._usgs_cart_2d)
for index in range(self._usgs_cart_2d.shape[1]):
image.draw_filledcircle(
*self._usgs_cart_2d[:, index], r = 1.0,
fill_color = (1.0, 0.0, 0.0),
)
image.save(os.path.join('frames', f'frame_{frame_index:05d}.png'))
jtalk.speak("遠くの%s" % text)
else:
jtalk.speak("%-3.2fメートル前方に%s" % (distance, text))
except UnboundLocalError:
print 'エラーが発生しました'
def on_publish(client, userdata, mid):
print("publish: {0}".format(mid))
if __name__ == "__main__":
client = mqtt.Client(protocol=mqtt.MQTTv311)
client.on_connect = on_connect
client.on_message = on_message
client.on_publish = on_publish
client.connect(host, port=port, keepalive=60)
client.loop_start()
accel = Acceralation()
camera = Camera()
while True:
if accel.permit_snapshot():
filepath = uuid.uuid4()
filename = '%s.jpg' % filepath
camera.snapshot(filename)
file = open('images/' + filename, "rb").read()
file_data = base64.b64encode(file)
client.publish(pub_topic, file_data, 0)
time.sleep(10.0)
class Scanner:
"""
The Scanner class uses the camera to "scan" the state of the cube.
This scanning process is very sensitive to lighting conditions.
"""
def __init__(self, config):
self.config = config
calib_file = "../" + config['cam']['calibration']
calib = {}
with open(calib_file, 'r') as ymlfile:
calib = yaml.load(ymlfile, Loader=yaml.FullLoader)
self.camera = Camera(config, calib)
def scan_state(self, motors):
"""
Scan the current state of the cube, and return a map of <facename:array<facename>> to represent the cube state.
Cube state is represented like:
|------------|
|*U0**U1**U2*|
|------------|
|*U3**U4**U5*|
|------------|
|*U6**U7**U8*|
|------------|------------|------------|------------|
|*L0**L1**L2*|*F0**F1**F2*|*R0**R1**R2*|*B0**B1**B2*|
|------------|------------|------------|------------|
|*L3**L4**L5*|*F3**F4**F5*|*R3**R4**R5*|*B3**B4**B5*|
|------------|------------|------------|------------|
|*L6**L7**L8*|*F6**F7**F8*|*R6**R7**R8*|*B6**B7**B8*|
|------------|------------|------------|------------|
|*D0**D1**D2*|
|------------|
|*D3**D4**D5*|
|------------|
|*D6**D7**D8*|
|------------|
The camera is always pointed at the edge <F2-R0-F5-R3-F8-R6>. We obtain the entire cube state by getting the
colors of all facelets on that edge, then rotating the cube through a predetermined sequence, such that all
edge facelets rotate through that edge.
"""
state = dict(SOLVED_STATE) # Initialize to fully solved.
# pylint: disable=unbalanced-tuple-unpacking
state['F'][2], state['R'][0], state['F'][5], state['R'][3], state['F'][
8], state['R'][6] = self.camera.get_faces()
motors.execute('F') # rotate front face clockwise
state['F'][0], state['U'][6], state['F'][1], state['U'][7], _, state[
'U'][8] = self.camera.get_faces()
motors.execute('F')
state['F'][6], state['L'][8], state['F'][3], state['L'][5], _, state[
'L'][2] = self.camera.get_faces()
motors.execute('F')
_, state['D'][2], state['F'][7], state['D'][1], _, state['D'][
0] = self.camera.get_faces()
# front map complete.
motors.execute('F R')
_, _, state['D'][5], state['R'][7], state['D'][8], state['R'][
8] = self.camera.get_faces()
motors.execute('R')
state['B'][6], _, state['B'][3], state['R'][5], state['B'][0], state[
'R'][2] = self.camera.get_faces()
motors.execute('R')
state['U'][2], _, state['U'][5], state['R'][
1], _, _ = self.camera.get_faces()
# right map complete
motors.execute("R B' U R'")
state['L'][6], state['B'][8], state['L'][3], state['B'][5], state['L'][
0], state['B'][2] = self.camera.get_faces()
motors.execute("R U' B L' F2")
state['D'][6], _, state['D'][3], state['L'][
7], _, _ = self.camera.get_faces()
motors.execute("F2 L U R'")
state['U'][0], _, state['U'][1], state['B'][1], state['U'][
2], _ = self.camera.get_faces()
# up map complete
motors.execute("R U R'")
_, _, _, state['L'][1], _, _ = self.camera.get_faces()
# left map complete
motors.execute("B R2")
_, _, state['B'][7], state['D'][7], _, _ = self.camera.get_faces()
# back and down maps complete
motors.execute("R2 B' R U2")
return state
def get_state_string(self, motors, state=None):
"""
Given a map of <face,array<facelet>>, representing the cube state, return a
string representation, according to the order U0, U1, U2, U3, U4, U5, U6, U7, U8, R0, R1,
R2, R3, R4, R5, R6, R7, R8, F0, F1, F2, F3, F4, F5, F6, F7, F8, D0, D1, D2, D3,
D4, D5, D6, D7, D8, L0, L1, L2, L3, L4, L5, L6, L7, L8, B0, B1, B2, B3, B4, B5,
B6, B7, B8
Example state: "DLRUULBDFLFFDRBBRRDLUFFFBRDUDLRDFRDULBRLLUBULDBFRBUFBU":
|------------|
|*D **L **R *|
|------------|
|*U **U **L *|
|------------|
|*B **D **F *|
|------------|------------|------------|------------|
|*L **B **R *|*D **L **U *|*L **F **F *|*D **B **F *|
|------------|------------|------------|------------|
|*L **L **U *|*F **F **F *|*D **R **B *|*R **B **U *|
|------------|------------|------------|------------|
|*B **U **L *|*B **R **D *|*B **R **R *|*F **B **U *|
|------------|------------|------------|------------|
|*U **D **L *|
|------------|
|*R **D **F *|
|------------|
|*R **D **U *|
|------------|
"""
if state is None:
state = self.scan_state(motors)
retval = "".join(state['U']) \
+ "".join(state['R']) \
+ "".join(state['F']) \
+ "".join(state['D']) \
+ "".join(state['L']) \
+ "".join(state['B'])
# fast (imperfect) test for a valid cube state.
if len(retval) != 54: # Is the string exactly 54 characters?
logging.error("Invalid Cube State! (not enough faces!)")
retval = ""
if (len(state['U']) != 9 or len(state['R']) != 9
or len(state['F']) != 9 or len(state['D']) != 9
or len(state['L']) != 9 or len(state['B']) != 9):
# Is each face exactly 9 facelets?
logging.error(
'Invalid Cube State! (inconsistent colors: U={:d}, R={:d}, F={:d}, D={:d}, L={:d}, B={:d})'
.format(len(state['U']), len(state['R']), len(state['F']),
len(state['D']), len(state['L']), len(state['B'])))
retval = ""
if state['U'][4] != 'U' or state['R'][4] != 'R' or state['F'][
4] != 'F' or state['D'][4] != 'D' or state['L'][
4] != 'L' or state['B'][4] != 'B':
# Is the center facelet of each face the same as the face itself? (since center squares can't move)
logging.error(
'Invalid Cube State! (Center facelets are not correct)')
retval = ""
return retval
def start_recognize():
shape = 'rectangle'
try:
faces = [employee for employee in os.listdir(DATABASE_DIR)]
except Exception as ex:
print(
json.dumps({
"message":
"Have you added at least one person to the system?" + str(ex),
"status":
"isEmpty"
}))
sys.exit()
print(
json.dumps(
{"message": "This are the people in the Recognition System:"}))
for employee in faces:
print(json.dumps({"-": employee}))
choice = 3
detector = FaceDetector(FACE_CASCADES)
if choice == 1:
recognizer = cv2.face.EigenFaceRecognizer_create()
threshold = 4000
elif choice == 2:
recognizer = cv2.face.FisherFaceRecognizer_create()
threshold = 300
elif choice == 3:
recognizer = cv2.face.LBPHFaceRecognizer_create()
# threshold = 105
threshold = 80
images = []
labels = []
state = []
state.append(0) # default
labels_faces = {}
for i, image_person in enumerate(faces):
labels_faces[i] = image_person
for image in os.listdir(DATABASE_DIR + image_person):
images.append(
cv2.imread(DATABASE_DIR + image_person + '/' + image, 0))
labels.append(i)
try:
recognizer.train(images, np.array(labels))
except:
print(
json.dumps({
"message": "Do you have at least two people in the database",
"status": "isEmpty"
}))
sys.exit()
video = Camera()
while True:
stroke = 1
color = (136, 150, 0)
cv2.namedWindow('Frame', cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty('Frame', cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
frame = video.get_frame()
# frame = video.ip_camera(True)
faces_coord = detector.detect(frame, False)
if len(faces_coord):
frame, faces_img = get_images(frame, faces_coord, shape)
for i, face_img in enumerate(faces_img):
pred, conf = recognizer.predict(face_img)
print(
json.dumps({
'prediction': pred,
'Confidence': conf,
'Threshold': threshold,
}))
if conf < threshold:
# Fetch data from face_entity the data from database
# to filter the first_name using uid
data = face_entity.get_face_profile(
labels_faces[pred].capitalize())
print(json.dumps({'code': str(data)}))
cv2.putText(frame,
data['firstname'] + ' | ' + str(round(conf)),
(faces_coord[i][0], faces_coord[i][1] - 2),
cv2.FONT_HERSHEY_PLAIN, 1.7, color, stroke,
cv2.LINE_AA)
# Push Available state
if state[0] == 0:
state.append(labels_faces[pred].capitalize())
if state[0] != str(labels_faces[pred].capitalize()):
if sys.argv[1] == "1":
face_post_module.login_employee_by_id(
data['employee_id'])
print(
json.dumps({
'status': 'IN',
'id': str(data['employee_id'])
}))
elif sys.argv[1] == "0":
face_post_module.logout_employee_by_id(
data['employee_id'])
print(
json.dumps({
'status': 'OUT',
'id': str(data['employee_id'])
}))
# Pop available state if they are not the same
state.pop(0)
else:
cv2.putText(frame, "Unknown",
(faces_coord[i][0], faces_coord[i][1]),
cv2.FONT_HERSHEY_PLAIN, 1.7, color, stroke,
cv2.LINE_AA)
print(json.dumps({"test": sys.argv[1]}))
if sys.argv[1] == "1":
if state[0] != 0:
data = face_entity.get_face_profile(12345678)
cv2.putText(
frame,
str(data['firstname'] + ' ' + data['lastname']).upper(),
(110, frame.shape[0] - 10), cv2.FONT_HERSHEY_PLAIN, 3,
color, 3, cv2.LINE_AA)
else:
if state[0] != 0:
data = face_entity.get_face_profile(12345678)
cv2.putText(
frame,
str(data['firstname'] + ' ' + data['lastname']).upper(),
(110, frame.shape[0] - 10), cv2.FONT_HERSHEY_PLAIN, 3,
color, 3, cv2.LINE_AA)
cv2.imshow('Frame', frame)
if cv2.waitKey(100) & 0xFF == 27:
sys.exit()
def hyperloop():
logger = Logger()
logger.setLogLevel('info')
logger.info('Started')
state = State()
for p in sys.argv:
if (p == "--standalone" or p == "-s"):
state.Standalone = True
logger.info("Standalone mode activated")
elif (p == "--nocamera" or p == "-n"):
state.NoImageTransfer = True
logger.info("Camera image transfer X11 disabled")
elif (p == "--record" or p == "-r"):
state.RecordImage = True
logger.info("Record mode activated")
elif (p == "--measure" or p == "-m"):
state.MeasureMode = True
logger.info("Measure mode activated")
elif (p == "--invert" or p == "-i"):
state.InvertCamera = True
logger.info("Inverted camera activated")
vs = PiVideoStream(resolution=(480, 368), framerate=32).start()
piCamera = vs.camera
piCamera.exposure_mode = 'sports'
piCamera.ISO = 1600
camera = Camera(vs, not state.NoImageTransfer)
# camera warmup
camera.warmup()
communication = Communication(logger)
acceleration = Acceleration(logger)
# reads any input incoming over UART / i2c / GPIO
communication.readThreadStart()
# measure acceleration
acceleration.measureThreadStart()
fps = FPS().start()
# program loop
while True:
try:
if ((not state.Stopped and state.Loaded) or state.Standalone):
# if (state.StopSignalNum == 0 or (state.Approaching and not state.StopSignalNum == 0) or state.Standalone):
# capture image from videostream and analyze
camera.capture()
fps.update()
if (state.StopSignalNum == 0 and state.LapSignalCount < 2 and not state.Approaching == Signal.UPPER):
communication.sendSpeedPercent(25)
state.Approaching = Signal.UPPER
logger.info("Approaching upper signal")
# if we found our stop signal, announce it
elif (state.StopSignalNum != 0 and not state.StopSignalAnnounced):
communication.sendSpeedPercent(100)
communication.buzzSignalNumber(state.StopSignalNum)
state.setStopSignalAnnounced(True)
state.Approaching = Signal.LAP
logger.info("Approaching lap signal")
# if we passed the lap signal twice, deccelerate to X percent
elif (state.StopSignalAnnounced and state.LapSignalCount >= 2 and not state.Approaching == Signal.LOWER):
communication.sendSpeedPercent(25)
state.Approaching = Signal.LOWER
logger.info("Approaching lower signal")
elif (state.StopSignalAnnounced and state.StopSignalNum == state.CurrentNum and not state.ApproachStop):
communication.sendApproachStop()
communication.sendSpeedPercent(25)
state.ApproachStop = True
logger.info("Approaching stop")
if (cv2.waitKey(1) & 0xFF) == ord('q'):
break
except KeyboardInterrupt:
break
except Exception as e:
logger.logError(e)
traceback.print_exc(limit=3, file=sys.stdout)
fps.stop()
communication.sendStartStop('stop')
time.sleep(1)
logger.info('FPS: ' + str(fps.fps()))
logger.info('Aborting running threads')
communication.readThreadStop()
acceleration.measureThreadStop()
logger.info('Stopped')
#!/usr/bin/env python
"""
Home surveillance application
"""
import time
from lib.camera import Camera
from lib.config import TOKEN_ID, REGISTRATION_FOLDER, VIDEO_TIME
from lib.telebot import Telebot
from lib.pir import MotionDetector
camera = Camera(REGISTRATION_FOLDER)
bot = Telebot(TOKEN_ID)
pir = MotionDetector()
@bot.handler("/start")
def on_start():
"""
command /start: start bot
"""
bot.is_listen = True
return bot.send_message("Bot start")
@bot.handler("/stop")
def on_stop():
"""
command /stop: stop bot
"""
bot.is_listen = False
class Main:
def __init__(self):
self.tasks = []
self.camera = Camera()
self.window = Window('Camera')
self.should_detect = True
self.trackers = []
self.color_filter = ColorFilter()
def add_target(self, filename):
self.trackers.append(Tracker(filename))
def clear(self):
for tracker in self.trackers:
tracker.clear()
def loop(self):
runner = CmdRunner(self)
runner.start()
while runner.isAlive():
while len(self.tasks) > 0:
task = self.tasks.pop(0)
task.execute()
try:
img = self.camera.get_frame()
if img is None:
self.window.clear()
continue
img = cv2.resize(img, (640, 480))
# TODO: show color mask
color_mask = self.color_filter.filter(img)
next_should_detect = self.should_detect
for tracker in self.trackers:
if self.should_detect:
rect = tracker.detect(img)
if rect is not None:
ret = tracker.update_window(img, rect)
self.window.draw_rectangle(rect, (255, 0, 255))
next_should_detect = False
rect = tracker.track(img)
if rect is None:
next_should_detect = True
continue
self.window.draw_rectangle(rect, (255, 0, 0))
self.should_detect = next_should_detect
except Exception as e:
print >> sys.stderr, e
finally:
self.window.update()
runner.join(0)
def _add_task(self, task):
self.should_detect = True
self.tasks.append(task)
def do_add_target(self, filename):
self._add_task(Task(self.add_target, (filename, )))
def do_clear(self):
self._add_task(Task(self.clear))
def do_snapshot(self, filename):
self._add_task(Task(self.window.snapshot, (filename, )))
def do_switch_camera(self, cid):
self._add_task(Task(self.camera.switch, (cid, )))
def setUpClass(cls):
"""
Initialize camera
"""
cls.camera = Camera(REGISTRATION_FOLDER)
import cv2
import glob
import matplotlib.pyplot as plt
from lib.camera import Camera
from lib.line_finder import LineFinder
import os
from moviepy.editor import VideoFileClip
# sample_camera controls whether we should recalibrate the camera from the sample pictures or just used the saved
# matrix from previous execution
sample_camera = False
camera = Camera()
if sample_camera:
# Make a list of calibration images
images = glob.glob('./camera_cal/calibration*.jpg')
fig, axs = plt.subplots(5, 4, figsize=(16, 11))
axs = axs.ravel()
# Go through the images one by one
for i, fname in enumerate(images):
img = cv2.imread(fname)
img = camera.sample_image(img)
axs[i].axis('off')
axs[i].imshow(img)
plt.show()
camera.calibrate()
