def test_cam_angle_calculator():
detector = Detector()
handrail_filter = calibrate_from_package_return_handrail_filter()
cam = CameraController()
for i in 1, 2:
test_img = cam.get_image()
out = handrail_filter.get_handrail_vectors(test_img)
print(out)
def test_cam_dist_calculator():
detector = Detector()
handrail_filter = calibrate_from_package_return_handrail_filter()
cam = CameraController()
test_img = cam.get_image()
cv2.imshow("before", test_img)
cv2.waitKey(0)
detections = detector.get_rects_from_bgr(test_img)
out = handrail_filter.get_valid_detections_and_distances_list(detections)
def test_id_assignment_camera():
handrail_filter = HandrailLocator.calibrate_from_package_return_handrail_filter(
)
map_manager = create_sample_map_manager()
cam = CameraController()
test_img = cam.get_image()
vectors = handrail_filter.get_handrail_vectors(test_img)
for vect in vectors:
print(map_manager.assign_id_and_conf_to_handrail_detection(vect))
def __init__(self):
# Set up Configuration
self.configController = ConfigController()
# Set up System
self.systemController = SystemController(
SystemBuilder(ConfigController.config.systemConfig))
self.sound = self.systemController.get_by_name('SPK')
self.armedLight = self.systemController.get_by_name('LED0')
self.alarmLight = self.systemController.get_by_name('LED1')
self.systemController.register_system_triggered_handler(
self.handle_sensor_trigger)
# Set up Camera + system for images
self.mediaController = MediaController(
self.configController.config.primaryConfig.find('media'))
self.cameraController = CameraController(self.mediaController)
# Set up Authentication
self.authController = AuthController(self)
self.authController.configure(self.configController.config.authConfig)
self.authController.register_accept_handler(self.on_accepted_handler)
self.authController.register_deny_handler(self.on_denied_handler)
# Set up the user interface
self.interfaceController = InterfaceController()
self.interfaceController.set_rfid(
self.systemController.getFirstOf(RfidReaderComponent))
self.interfaceController.set_keypad(
self.systemController.getFirstOf(KeypadComponent))
self.interfaceController.setup_server(
self.configController.config.systemConfig.find('server'))
self.interfaceController.setup_messenger(
self.configController.config.systemConfig.find('email'))
self.interfaceController.register_rfid_read_handler(
self.handle_rfid_tag)
self.interfaceController.register_keypad_read_handler(
self.handle_keypad_code)
print(len(self.systemController.components),
"components built from system configuration.")
for component in self.systemController.components:
print('\t', component.__class__.__name__)
# Set up Behaviour
self.behaviour = NormalArmedBehaviour(self)
def __init__(self):
self.camera = CameraController()
print("Creating histrogram...")
self.valoresMinimos = 0
self.valoresMaximos = 0
#Rango de roojos en HSV
self.rojo_bajos1 = np.array([150, 65, 75], dtype=np.uint8)
self.rojo_altos1 = np.array([180, 255, 255], dtype=np.uint8)
self.rojo_bajos2 = np.array([240, 65, 75], dtype=np.uint8)
self.rojo_altos2 = np.array([256, 255, 255], dtype=np.uint8)
#Rango de verdes en HSV
self.verdes_bajos = np.array([49, 50, 50], dtype=np.uint8)
self.verdes_altos = np.array([107, 255, 255], dtype=np.uint8)
#self.histograma=np.zeros((10, 256, 3))
#Histograma y valores frontera inicializados
self.llindar = 100
self.getPhotosHistogram()
self.crearHistograma()
class VCModule():
def __init__(self):
self.camera = CameraController()
print("Creating histrogram...")
self.valoresMinimos = 0
self.valoresMaximos = 0
#Rango de roojos en HSV
self.rojo_bajos1 = np.array([150, 65, 75], dtype=np.uint8)
self.rojo_altos1 = np.array([180, 255, 255], dtype=np.uint8)
self.rojo_bajos2 = np.array([240, 65, 75], dtype=np.uint8)
self.rojo_altos2 = np.array([256, 255, 255], dtype=np.uint8)
#Rango de verdes en HSV
self.verdes_bajos = np.array([49, 50, 50], dtype=np.uint8)
self.verdes_altos = np.array([107, 255, 255], dtype=np.uint8)
#self.histograma=np.zeros((10, 256, 3))
#Histograma y valores frontera inicializados
self.llindar = 100
self.getPhotosHistogram()
self.crearHistograma()
# Esta funcion devuelve una matriz con el tablero encontrado
# Fases:
# 1- Obtener foto
# 2- Recortar y encuadrar la foto
# 3- Comprobar que la foto contenga un tablero visible
# 4- Transformacion de la foto a tablero en matriz
def getTablero(self):
imagenRuido = True
while imagenRuido == True:
imagen = self.getPhoto()
imagen = self.cuadrarImagen(imagen, "histograma/lastPhoto.jpg")
imagenRuido = self.comprobacionRuido(imagen)
return self.deteccion_tablero(imagen)
#################################################################################
# 1- Obtener foto
#################################################################################
def getPhotosHistogram(self):
self.camera.getInitialPhotos()
# Este metodo obtiene la foto del tablero
def getPhoto(self):
return self.camera.getPhoto()
#################################################################################
#2- Recortar y encuadrar la foto
#################################################################################
# Este metodo se encarga de coger una imagen, compararla con la muestra llamando
# a alinear y guarda la foto nueva encuadrada y recortada
def cuadrarImagen(self, im, outFilename):
# Read reference image
refFilename = "muestra.jpg"
imReference = cv2.imread(refFilename, cv2.IMREAD_COLOR)
# Registered image will be resotred in imReg.
# The estimated homography will be stored in h.
imReg, h = self.alignImages(im, imReference)
# Write aligned image to disk.
cv2.imwrite(outFilename, imReg)
return imReg
# Este metodo recibe dos imagenes, una muestra y la imagen a encuadrar,
# busca los puntos en comun entre ambas, elimina los puntos no comunes y
# encuentra la homografia para hacer el transformado de la imagen final
def alignImages(self, im1, im2):
# Convert images to grayscale
im1Gray = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY)
im2Gray = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY)
# Detect ORB features and compute descriptors.
orb = cv2.ORB_create(MAX_FEATURES)
keypoints1, descriptors1 = orb.detectAndCompute(im1Gray, None)
keypoints2, descriptors2 = orb.detectAndCompute(im2Gray, None)
# Match features.
matcher = cv2.DescriptorMatcher_create(
cv2.DESCRIPTOR_MATCHER_BRUTEFORCE_HAMMING)
matches = matcher.match(descriptors1, descriptors2, None)
# Sort matches by score
matches.sort(key=lambda x: x.distance, reverse=False)
# Remove not so good matches
numGoodMatches = int(len(matches) * GOOD_MATCH_PERCENT)
matches = matches[:numGoodMatches]
# Draw top matches
imMatches = cv2.drawMatches(im1, keypoints1, im2, keypoints2, matches,
None)
cv2.imwrite("histograma/matches.jpg", imMatches)
# Extract location of good matches
points1 = np.zeros((len(matches), 2), dtype=np.float32)
points2 = np.zeros((len(matches), 2), dtype=np.float32)
for i, match in enumerate(matches):
points1[i, :] = keypoints1[match.queryIdx].pt
points2[i, :] = keypoints2[match.trainIdx].pt
# Find homography
h, mask = cv2.findHomography(points1, points2, cv2.RANSAC)
# Use homography
height, width, channels = im2.shape
im1Reg = cv2.warpPerspective(im1, h, (width, height))
return im1Reg, h
#################################################################################
# 3- Comprobar que la foto contenga un tablero visible
#################################################################################
# Este metodo se encarga de crear un histograma a partir de N imagenes el cual
# servira para obtener los valores frontera.
def crearHistograma(self):
print("please wait during calibration...")
count = self.camera.num_histo_photos
histograma = np.zeros((count, 256, 3))
for z in range(count):
porciento = int((z / (count - 1)) * 100)
print(str(porciento) + "%")
contador = 0
imgName = "histograma/" + str(z) + ".jpg"
img = cv2.imread(imgName)
img = self.cuadrarImagen(img, imgName)
color = ('b', 'g', 'r')
for i, c in enumerate(color):
hist = cv2.calcHist([img], [i], None, [256], [0, 256])
for j in range(256):
histograma[z][j][contador] = hist[j][0]
contador += 1
self.valoresMinimos = histograma.min(axis=0)
self.valoresMaximos = histograma.max(axis=0)
# Los valores frontera se utilizaran en este metodo para determinar si la
# foto obtenida es valida. Sera valida cuando el histograma de la nueva
# imagen este comprendida entre los valores frontera.
def comprobacionRuido(self, image):
#calculo del nuevo hisograma
histograma = np.zeros((256, 3))
color = ('b', 'g', 'r')
contador = 0
for i, c in enumerate(color):
hist = cv2.calcHist([image], [i], None, [256], [0, 256])
for j in range(256):
histograma[j][contador] = hist[j][0]
contador += 1
#calculo del numero de diferencias
return self.comprobarDiferencias(histograma) > 200
#Metodo para contabilizar el numero de valores fuera de los valores frontera
def comprobarDiferencias(self, h):
final = np.zeros((256, 3))
for j in range(3):
for i in range(256):
if ((h[i][j] > self.valoresMaximos[i][j] + self.llindar) or
(h[i][j] < self.valoresMinimos[i][j] - self.llindar)):
final[i][j] = 1
return final.sum()
#################################################################################
# 4- Transformacion de la foto a tablero en matriz
#################################################################################
# Metodo para crear una mascara que detecte el color rojo
def detector_rojo(self, hsv):
mascara_rojo1 = cv2.inRange(hsv, self.rojo_bajos1, self.rojo_altos1)
mascara_rojo2 = cv2.inRange(hsv, self.rojo_bajos2, self.rojo_altos2)
return cv2.add(mascara_rojo1, mascara_rojo2)
def detector_verde(self, hsv):
mascara_verde = cv2.inRange(hsv, self.verdes_bajos, self.verdes_altos)
return cv2.add(mascara_verde, mascara_verde)
# Metdo para obtener la imagen en HSV
def RGBtoHSV(self, imagen):
return cv2.cvtColor(imagen, cv2.COLOR_BGR2HSV)
# Este metodo transforma la imagen a matriz
# Fases:
# 1- Obtener la imagen en HSV
# 2- Crear la mascara verde y roja para la deteccion de colores
# 3- Division de las mascaras en porciones segun el tablero
# 4- Por cada porcion miramos la cantidad de color detectado y si es
# mayor a la tolerancia establecida. se considera que hay una ficha.
# 5- Transformar las fichas detectadas a matriz de caracteres
def deteccion_tablero(self, imagen):
tablero = np.zeros((8, 8), dtype=(np.unicode_, 2))
imagen = self.RGBtoHSV(imagen)
mask_verde = self.detector_verde(imagen)
mask_rojo = self.detector_rojo(imagen)
valor_blancas = False
valor_negras = False
contador_n = 1
contador_b = 1
pos_x = 0
suma_x = int(imagen.shape[0] / 8)
suma_y = int(imagen.shape[1] / 8)
for i in range(8):
pos_y = 0
for j in range(8):
aux_negras = mask_verde[pos_x:pos_x + suma_x,
pos_y:pos_y + suma_y]
aux_blancas = mask_rojo[pos_x:pos_x + suma_x,
pos_y:pos_y + suma_y]
valor_negras = self.encontrarFichaEnCasilla(aux_negras)
valor_blancas = self.encontrarFichaEnCasilla(aux_blancas)
if (valor_negras == True):
numero = 'n' + str(contador_n)
contador_n = contador_n + 1
tablero[i][j] = numero
elif (valor_blancas == True):
numero_b = 'b' + str(contador_b)
contador_b = contador_b + 1
tablero[i][j] = numero_b
else:
tablero[i][j] = '-'
pos_y = pos_y + suma_y
pos_x = pos_x + suma_x
print(tablero)
return tablero
# Metodo que comprueba si hay pieza en una casilla
def encontrarFichaEnCasilla(self, block):
valor = False
contador = 0
total_pixeles = block.shape[0] * block.shape[1]
contador = np.count_nonzero(block)
if contador / total_pixeles > 0.075:
valor = True
return valor
class App:
system_delay = 10 # Entire system delay, data doesnt change often so no need for this to be high
sensor_data = {'temp': 0, 'camera': ''}
sensor_status = {
'temp': {
'ison': {
'data': False
},
'threshold': 0
},
'camera': {
'ison': {
'data': False
}
},
'heater': {
'ison': {
'data': False
}
},
'servo': {
'ison': {
'data': False
}
},
'external': {
'ison': {
'data': False
}
}
}
fb = FirebaseController()
# Comment out on non camera pi
camera = CameraController('live')
"""
Gets the status of all sensors from firebase and passes the data into the
class status object for each object
"""
def get_sensor_status(self):
while True:
sleep(self.system_delay)
sensorstats = self.fb.get_from_firebase('sensorstat/')
self.sensor_status['temp'] = sensorstats[0]['temp']
self.sensor_status['camera'] = sensorstats[0]['camera']
self.sensor_status['external'] = sensorstats[0]['external']
self.sensor_status['servo'] = sensorstats[0]['servo']
self.sensor_status['heater'] = sensorstats[0]['heater']
"""
Starts and controls sensor operations based on the passed
component string, will be threaded
@param component - the component to control
"""
def start_sensor(self, component):
environment = 'live'
while True: # Goes forever
if component == 'servo':
if self.sensor_status['servo']['ison']['data']:
print("Servo is on")
servo = ServoController(environment)
servo.servo_flip(
True) # If the servo was set to on , open it
print("Servo Open")
sleep(5) # Allow some liquid to leave the container
servo.servo_flip(False) # Close the tap
print("Servo Close")
self.fb.post_to_firebase('sensorstat/' + component +
'/ison/data',
False) # turn the servo off
if component == 'camera':
if self.sensor_status['camera']['ison']['data']:
sleep(self.system_delay)
# get the camera to take a picture and retunr the picture as base64
self.sensor_data['camera'] = str(self.camera.get_picture())
sleep(5)
self.fb.post_to_firebase('sensorstat/' + component +
'/ison/data',
False) # turn the camera off
if component == 'temp':
if self.sensor_status['temp']['ison']['data']:
thermo = TemperatureController(environment)
sleep(self.system_delay)
self.sensor_data['temp'] = thermo.get_temp()
"""
If the average temperature form the thermometers is lower that the threshold
turn the heater on by toggling the energenie hat and tell firebase the heater is on
if the heater is already on do nothing.
Else if the heater is on and the temperature is equal or above the threshold and
the heater is on, turn it off
"""
if self.sensor_data['temp'] < self.sensor_status['temp'][
'threshold']['data']:
if self.sensor_status['heater']['ison']['data']:
print('too low, heater was already on')
else:
print('too low, heater is being turned on')
self.fb.post_to_firebase(
'sensorstat/heater/ison/data', True)
else:
if self.sensor_status['heater']['ison']['data']:
print('Temp fine heater off')
self.fb.post_to_firebase(
'sensorstat/heater/ison/data', False)
else:
print("temp fine")
if component == 'external':
if self.sensor_status['external']['ison']:
# Get and post the external environment data to firebase
extern = ExternalReadings(environment)
self.fb.post_to_firebase('external/temp/',
extern.get_temp())
self.fb.post_to_firebase('external/light/',
extern.get_light_level())
sleep(self.system_delay)
if component == 'heater':
sock = SocketController()
if self.sensor_status['heater']['ison']['data']:
sock.socket_on()
sleep(self.system_delay)
else:
sock.socket_off()
sleep(self.system_delay)
"""
Calls the post_to_firbase method and passes sensor data to be sent.
Each sensor (except the externals) gets its on thread in which this runs
Only posts if the sensor is on and if the data isn't 0 - as there is no
likely event that the sensor data will reach 0
@params sensor - the sensor to post
"""
def post_sensor_data(self, sensor):
while True:
if self.sensor_status[sensor]['ison']['data']:
if sensor == 'servo':
sleep(self.system_delay)
if sensor != 'servo' and self.sensor_data[sensor] != 0:
self.fb.post_to_firebase(sensor, self.sensor_data[sensor])
sleep(self.system_delay)
from Face import Face
faceCascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
vPoints = []
def collectVPoints(event, x, y, flags, param):
if event == cv2.EVENT_LBUTTONDBLCLK:
vPoints.append([x, y])
cv2.namedWindow('Camera')
cv2.setMouseCallback('Camera', collectVPoints)
controller = CameraController(16)
controller.start()
time.sleep(1)
frame_counter = 0
attenuation = 0.5
while True:
frame = controller.getFrame()
frame_counter += 1
faces = faceCascade.detectMultiScale(frame)
CMarker.markFaces(frame, faces)
#if (frame_counter % 10 == 0):
# print("10th frame")
# corners = cv2.goodFeaturesToTrack(frame,50,0.01,10)
#Marker.markPoints(mask, corners)
class AlarmController(object):
authController = None # type: AuthController
configController = None # type: ConfigController
systemController = None # type: SystemController
interfaceController = None # type: InterfaceContoller
behaviour = None # type: AlarmArmedBehaviour
sound = None
armedLight = None
alarmLight = None
_exiting = False # type: bool
_armed = False # type: bool
def __init__(self):
# Set up Configuration
self.configController = ConfigController()
# Set up System
self.systemController = SystemController(
SystemBuilder(ConfigController.config.systemConfig))
self.sound = self.systemController.get_by_name('SPK')
self.armedLight = self.systemController.get_by_name('LED0')
self.alarmLight = self.systemController.get_by_name('LED1')
self.systemController.register_system_triggered_handler(
self.handle_sensor_trigger)
# Set up Camera + system for images
self.mediaController = MediaController(
self.configController.config.primaryConfig.find('media'))
self.cameraController = CameraController(self.mediaController)
# Set up Authentication
self.authController = AuthController(self)
self.authController.configure(self.configController.config.authConfig)
self.authController.register_accept_handler(self.on_accepted_handler)
self.authController.register_deny_handler(self.on_denied_handler)
# Set up the user interface
self.interfaceController = InterfaceController()
self.interfaceController.set_rfid(
self.systemController.getFirstOf(RfidReaderComponent))
self.interfaceController.set_keypad(
self.systemController.getFirstOf(KeypadComponent))
self.interfaceController.setup_server(
self.configController.config.systemConfig.find('server'))
self.interfaceController.setup_messenger(
self.configController.config.systemConfig.find('email'))
self.interfaceController.register_rfid_read_handler(
self.handle_rfid_tag)
self.interfaceController.register_keypad_read_handler(
self.handle_keypad_code)
print(len(self.systemController.components),
"components built from system configuration.")
for component in self.systemController.components:
print('\t', component.__class__.__name__)
# Set up Behaviour
self.behaviour = NormalArmedBehaviour(self)
#
# Alarm functions
#
def is_armed(self) -> bool:
return self._armed
def toggle_armed(self):
self._armed = not self._armed
self.armedLight.toggle()
if self._armed is False:
self.behaviour.on_accepted()
return self._armed
def on_accepted_handler(self, id, method):
self.toggle_armed()
logging.debug("Alarm has been turned %s by %s using %s.",
"on" if self.is_armed() else "off", id, method)
self.sound.single_beep(1, 5000)
self.cameraController.take_still()
def on_denied_handler(self, id, method):
logging.debug("Authentication failed for %s using %s.", id, method)
self.sound.single_beep(0.2, 5000)
time.sleep(0.4)
self.sound.single_beep(0.2, 5000)
self.cameraController.take_still()
def handle_sensor_trigger(self, component):
alarm_type = component.extra.find('alarm-type')
if alarm_type is None:
return
if self.is_armed():
at = str(alarm_type.get('value')).lower()
if at == "trigger":
if self.behaviour.is_triggered() is not True:
self.behaviour.on_trigger()
logging.debug("Alarm triggered!")
elif at == "alarm":
if self.behavious.is_sounding() is not True:
self.behavious.on_alarm()
logging.debug("Alarm sounding!")
def handle_keypad_code(self, code):
self.authController.authenticate_code(code)
def handle_rfid_tag(self, id):
self.authController.authenticate_tag(id)
#
# Program flow functions
#
def run(self):
logging.debug("====== STARTING RUNTIME LOOP ======")
self.sound.single_beep(0.10, 2500)
self.interfaceController.start()
# print("Starting to run.")
while not self.is_exiting():
try:
self.behaviour.tick()
time.sleep(0.01)
# pass
except KeyboardInterrupt:
logging.debug("Interrupted by keyboard. Exiting.")
self._exiting = True
self.interfaceController.do_exit = True
except Exception as ex:
print(ex)
self.shutdown()
def is_exiting(self) -> bool:
return self._exiting
def shutdown(self):
self.interfaceController.join()
self.systemController.cleanup()
def draw_text(image, text, x, y, bold=False):
if bold is True:
cv2.putText(image, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 255, 0), 2)
else:
cv2.putText(image, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 255, 0), 1)
#draw_data(test_data)
if __name__ == '__main__':
# Create new CameraController instance
cam = CameraController()
cam.start()
cv2.namedWindow("Output", cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty("Output", cv2.WND_PROP_FULLSCREEN, 1)
gpio.setmode(gpio.BCM)
gpio.setwarnings(False)
gpio.setup(17, gpio.IN, gpio.PUD_UP)
gpio.setup(23, gpio.OUT)
light = gpio.PWM(23, 50)
light.start(100)
try:
def startCamera(serverIpAddress, serverPort):
cameraClient = CameraClient(serverIpAddress, serverPort)
cameraController = CameraController(cameraClient)
camera = Camera(cameraController)
camera.captureContinuousStream()