pip install firebase
pip install firebase-admin

pip install image

pip3 install scikit-learn
pip3 install numpy
pip3 install opencv-contrib-python

pip install google-cloud-storage
pip install firebase
pip install firebase-admin

버튼이 눌리면 firebase database에 있는 ‘request’ 값을 1로 바꿈
2020.03.22.
‘approved’값이 1이 되면 servo motor 제어
”’
import threading, requests
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
import RPi.GPIO as GPIO
import time

pin_servo_motor = 18 # GPIO.BCM
pin_switch = 21 # GPIO.BCM
pin_led_yellow = 19 # GPIO.BCM
pin_led_blue = 26 # GPIO.BCM

# red_led = port 12
GPIO.setmode(GPIO.BCM)
GPIO.setup(pin_led_yellow, GPIO.OUT)
GPIO.setup(pin_led_blue, GPIO.OUT)
GPIO.setup(pin_switch, GPIO.IN, pull_up_down=GPIO.PUD_UP)

GPIO.setup(pin_servo_motor, GPIO.OUT)

db_url = ‘https://whoru-ed991.firebaseio.com/’
cred = credentials.Certificate(“myKey.json”)
db_app = firebase_admin.initialize_app(cred, {‘databaseURL’: db_url})
ref = db.reference()

#pin_servo_motor = 12 # GPIO.BOARD

#p = GPIO.PWM(pin_servo_motor, 50)
p = GPIO.PWM(pin_servo_motor, 50)

p.start(0)

cnt = 0
pwm = 0
switch = 0
flag = 0
request = 0
input_state = 0
input_state_pre = 0
isrequest = False
GPIO.output(pin_led_yellow, GPIO.LOW)
GPIO.output(pin_led_blue, GPIO.LOW)

class get_database (threading.Thread):
def __init__(self):
threading.Thread.__init__(self)

def run(self):
print(“[Thread] get database start”)
global flag
global request
while True:
flag = ref.child(“carlist/06수 8850/approved”).get()
request = ref.child(“carlist/06수 8850/request”).get()
print(“[Thread] flag\t: {}”.format(flag))
print(“[Thread] request\t: {}”.format(request))

if __name__ == “__main__”:
try:
_time = 0
thread_database = get_database()
thread_database.start()
p.ChangeDutyCycle(1)

while True:
input_state_pre = input_state
input_state = GPIO.input(pin_switch)

# APPRROVED
if flag == ’1′ and request == ’1′:
print(“flag 1″)
# led off
GPIO.output(pin_led_yellow, GPIO.LOW)
GPIO.output(pin_led_blue, GPIO.HIGH)
# motor on
p.ChangeDutyCycle(10)
print(“angle : {}”.format(pwm))

if (input_state != input_state_pre): # switch edge detecting
print(“edge!”)
if input_state == 0:
switch += 1
else:
pass

if (switch % 2 == 1) and (isrequest == False):
print(“request 1″)
_time =time.time()
ref.child(“carlist/06수 8850″).update({‘request’: ’1′})
GPIO.output(pin_led_yellow, GPIO.HIGH)
GPIO.output(pin_led_blue, GPIO.LOW)
isrequest = True
if (switch % 2 == 0) and (isrequest == True):
print(“request 0″)
_time = 0
GPIO.output(pin_led_yellow, GPIO.LOW)
GPIO.output(pin_led_blue, GPIO.LOW)
p.ChangeDutyCycle(1)

ref.child(“carlist/06수 8850″).update({‘request’: ’0′})
ref.child(“carlist/06수 8850″).update({‘approved’: ’0′})
isrequest = False
time.sleep(1)

”’
if time.time() – _time > 15: # time out
switch += 1
”’

except KeyboardInterrupt:
p.stop()
GPIO.cleanup()

# -*- coding: utf-8 -*-

import cv2
import math
from sklearn import neighbors
import os
import os.path
import pickle
from PIL import Image, ImageDraw
import face_recognition
from face_recognition.face_recognition_cli import image_files_in_folder
import numpy as np

# FOR STORAGE
try:
from google.cloud import storage
except ImportError:
raise ImportError(‘Failed to import the Cloud Storage library for Python. Make sure ”to install the “google-cloud-storage” module.’)
from firebase_admin import storage
import datetime
import urllib.request
# FOR DATABASE
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

import time

####### Global Variable ######
cnt_face = 0

CARNUMBER = None
USERNAME = None
###############################

########### firebase import name ###############
db_url = ‘https://whoru-ed991.firebaseio.com/’
cred = credentials.Certificate(“myKey.json”)
db_app = firebase_admin.initialize_app(cred, {‘databaseURL’: db_url})
alldata = db.reference()

sr_buck = ‘whoru-ed991.appspot.com’
sr_app = firebase_admin.initialize_app(cred, {‘storageBucket’: sr_buck, }, name=’storage’)
############################################

ALLOWED_EXTENSIONS = {‘png’, ‘jpg’, ‘jpeg’, ‘JPG’}
def train(train_dir, model_save_path=None, n_neighbors=None, knn_algo=’ball_tree’, verbose=False):
X = [] y = [] for class_dir in os.listdir(train_dir):
if not os.path.isdir(os.path.join(train_dir, class_dir)):
continue

for img_path in image_files_in_folder(os.path.join(train_dir, class_dir)):
image = face_recognition.load_image_file(img_path)
face_bounding_boxes = face_recognition.face_locations(image)

if len(face_bounding_boxes) != 1:
if verbose:
print(“Image {} not suitable for training: {}”.format(img_path, “Didn’t find a face” if len(face_bounding_boxes) < 1 else “Found more than one face”))
else:
X.append(face_recognition.face_encodings(image, known_face_locations=face_bounding_boxes)[0])
y.append(class_dir)

if n_neighbors is None:
n_neighbors = int(round(math.sqrt(len(X))))
if verbose:
print(“Chose n_neighbors automatically:”, n_neighbors)

knn_clf = neighbors.KNeighborsClassifier(n_neighbors=n_neighbors, algorithm=knn_algo, weights=’distance’)
knn_clf.fit(X, y)

if model_save_path is not None:
with open(model_save_path, ‘wb’) as f:
pickle.dump(knn_clf, f)
return knn_clf
def predict(X_frame, knn_clf=None, model_path=None, distance_threshold=0.5):
if knn_clf is None and model_path is None:
raise Exception(“Must supply knn classifier either thourgh knn_clf or model_path”)

if knn_clf is None:
with open(model_path, ‘rb’) as f:
knn_clf = pickle.load(f)

X_face_locations = face_recognition.face_locations(X_frame)

if len(X_face_locations) == 0:
return [] faces_encodings = face_recognition.face_encodings(X_frame, known_face_locations=X_face_locations)

closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)
are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]

return [(pred, loc) if rec else ("unknown", loc) for pred, loc, rec in
zip(knn_clf.predict(faces_encodings), X_face_locations, are_matches)]

def show_prediction_labels_on_image(frame, predictions):
global cnt_face
pil_image = Image.fromarray(frame)
draw = ImageDraw.Draw(pil_image)

for name, (top, right, bottom, left) in predictions:
top *= 2
right *= 2
bottom *= 2
left *= 2

draw.rectangle(((left, top), (right, bottom)), outline=(0, 0, 255))
name = name.encode(“UTF-8″)
names = name.decode()
############## name compare #################
if cnt_face < 40:
# LED = Orange
if names == USERNAME:
print(“true”)
cnt_face += 1
else:
print(“false”)
cnt_face = 0

if cnt_face == 40: db.reference(‘carlist’).child(“{}”.format(CARNUMBER)).update({‘approved’: ’1′})
print(“Recognition successfully!”)
# LED = Green
elif cnt_face > 40:
cap1.release()
cv2.destroyAllWindows()
# LED = OFF
exit(0)
now = time.time()
if now > start_time + 15:
db.reference(‘carlist’).child(“{}”.format(CARNUMBER)).update({‘request’: ’0′})
print(“Disapproved. Try Again.”)
############################################

text_width, text_height = draw.textsize(name)
draw.rectangle(((left, bottom – text_height – 10), (right, bottom)), fill=(0, 0, 255), outline=(0, 0, 255))
draw.text((left + 6, bottom – text_height – 5), name, fill=(255, 255, 255, 255))

del draw

opencvimage = np.array(pil_image)
return opencvimage
if __name__ == “__main__”:
try:
while True:
############### Get Car Number ###############
print(“####\tGet Car Number……..\t####”)
carlist = db.reference(‘carlist’).get()
# print(carlist.items())

for carNumber, val in carlist.items():
Request = db.reference(‘carlist’).child(‘{}/request’.format(carNumber)).get()
if Request == ’1′:
CARNUMBER = carNumber
print(“Request : {} \t carNumber : {}”.format(Request, carNumber))
print(“####\tGet Car Number Complete!!\t####”)

################# Call Image #################
print(“####\tGet User Image……….\t####”)
USERNAME = db.reference(‘carlist’).child(‘{}/username’.format(CARNUMBER)).get()
print(“username : {}”.format(USERNAME))

bucket = storage.bucket(app=sr_app)
blob = bucket.blob(“WhoRU_target/{}.jpg”.format(USERNAME))
user_path = “./knn_examples/train/{}”.format(USERNAME)
if not os.path.isdir(user_path):
os.mkdir(user_path)
img_url = blob.generate_signed_url(datetime.timedelta(seconds=300), method=’GET’)
urllib.request.urlretrieve(img_url, ‘{0}/{1}.jpg’.format(user_path, USERNAME))
print(“####\tGet User Image Comoplete!!\t####”)
###########################################
print(“####\tTraining KNN classifier…\t####”)
classifier = train(“knn_examples/train”, model_save_path=”trained_knn_model.clf”, n_neighbors=2)
print(“####\tTraining complete!\t####”)
# process one frame in every 30 frames for speed
process_this_frame = 29
print(‘####\tSetting cameras up…\t####’)
# multiple cameras can be used with the format url = ‘http://username:password@camera_ip:port’
url = ‘http://192.168.43.78:8081/’
cap = cv2.VideoCapture(url)
# 시작 시간 기록
start_time = time.time()
while 1 > 0:
ret, frame = cap.read()
if ret:
img = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5)
process_this_frame = process_this_frame + 1
if process_this_frame % 30 == 0:
predictions = predict(img, model_path=”trained_knn_model.clf”)
frame = show_prediction_labels_on_image(frame, predictions)
cv2.imshow(‘camera’, frame)
if ord(‘q’) == cv2.waitKey(10):
cap1.release()
cv2.destroyAllWindows()
exit(0)

else:
pass
time.sleep(1)
except KeyboardInterrupt:
print(“KeyboardInterrupt!!”)