def main():
#Datastructure for faces and names
fd = FaceData()
rec = Recognition()
root = Tk()
ui = Ui(root, fd)
def task():
#while True:
#print("length: "+ str(len(known_face_names)))
rec.find_faces(fd)
ui.updateList()
## TODO: Hit 'q' on the keyboard to quit!
if cv2.waitKey(1) & 0xFF == ord('q'):
print("q pressed")
# break
root.after(20, task) # reschedule event in 2 seconds
root.after(20, task)
ui.startLoop()
rec.close()
def main(data: dict):
"""main
:param data:
:type data: dict
"""
rec = Recognition(data)
rec.convert_base64_to_img()
return "ok"
def run():
print(device_lib.list_local_devices())
configuration = Configuration('configuration/configuration.cfg')
DataUtils.check_and_create_folders(configuration)
DataUtils.create_cache_if_not_exists(configuration)
recognition = Recognition(configuration)
recognition.train()
def __init__(self):
self.recognizer = Recognition() # 语音识别
self.nlu = Nlu() # 语义识别
self.speaker = Speaker() # 语音合成
self.music_player = Music_Player() # 音乐播放器
self.weather = Weather(self.speaker) # 查询天气功能
self.chat = Chat(self.speaker) # 闲聊功能
self.ticket = Ticket(self.speaker) # 查询车票功能
self.noun = Noun(self.speaker) # 名词解释功能
self.music = Music(self.speaker, self.music_player) # 播放音乐功能
def stream(conn, num):
faces, names, ids = LoadDB.loadofflineDB()
r = Recognition(faces, names, ids)
v = video()
data = b""
payload_size = struct.calcsize(">L")
print("payload_size: {}".format(payload_size))
while True:
global isReady
while len(data) < payload_size:
#print("Recv: {}".format(len(data)))
data += conn.recv(4096)
'''if len(data) == 0 :
print("Breaking Face Recognition")
conn.close()
break'''
#print("Done Recv: {}".format(len(data)))
packed_msg_size = data[:payload_size]
data = data[payload_size:]
msg_size = struct.unpack(">L", packed_msg_size)[0]
#print("msg_size: {}".format(msg_size))
while len(data) < msg_size:
data += conn.recv(4096)
'''if len(data) == 0:
print("Breaking Face Recognition")
conn.close()
break'''
frame_data = data[:msg_size]
data = data[msg_size:]
frame = pickle.loads(frame_data, fix_imports=True, encoding="bytes")
frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
frame, name, id = r.startFaceRecognition(frame)
#print(id)
cv2.waitKey(1)
cv2.imwrite('outgoing.jpg', frame)
isReady = True
v.appendframes(frame)
with open(f"{date.today()}.txt", "a") as f:
f.write(
f"{name} is seen on {date.today()} at {datetime.now().strftime('%I:%M:%S %p')}\n"
)
f.close()
v.appendframes(frame)
'''if len(data) == 0:
print("Breaking Face Recognition")
conn.close()
break'''
#yield (b'--frame\r\n'
# b'Content-Type: image/jpeg\r\n\r\n' + open('outgoing.jpg', 'rb').read() + b'\r\n')
'''conn.close()
def __init__(self, camera):
self.actions = mp.Array('i', [1])
self.cameras = {
'usb': 0,
'china': 'rtsp://192.168.1.11:554/live/0/MAIN',
'intelbras': 'rtsp://*****:*****@@192.168.1.11:554',
}
self.box = mp.Array('i', [0])
self.battery = mp.Array('i', [0, 0, 0, 0, 0, 0, ])
self.lat_long_actual = mp.Array('d', [0.0, 0.0])
self.c = Communication(port='/dev/SERIAL_PORT')
self.r = Recognition(camera=self.cameras[camera], camera_rasp=False, show_image=True)
def __init__(self):
self.db = DataBase(data_base='cache.db')
self.camera, self.communication = self.read_config()
self.timer_process = TimerProcess()
self.r = Recognition(config=self.camera, db=self.db)
self.c = Communication(config=self.communication,
code_recognition=self.r,
timer_process=self.timer_process,
db=self.db)
self.station = self.camera.station_id
self.carts = mp.Array('i', self.r.create_list(12))
self.connection = self.c.data_call()
self.QRBE1 = self.c.create_digit('QRBE1,{}'.format(self.station))
def run(self):
#tworzymy lub pobieramy wartości mfcc
[MG_train, MG_unknown, M_midi]=self.instrument_variant()
mfcc_library=MG_train.import_or_make_mfcc()
mfcc_unknown=MG_unknown.import_or_make_mfcc()
#sprawdzamy jaki jest zakres dźwięków midi
midi=M_midi.range_of_midi()
#tworzymy modele dźwieków midi
gmms=GMM_Model(midi,mfcc_library).model()
#rozpoznajemy wysokosci we wszystkich plikach z podanego folderu
recognition=Recognition(gmms,mfcc_unknown,midi).rec_every_unknown()
#ostatecznie przyporządkowujemy wysokości
end_result=End_Results(recognition,self.SInstrument,self.SPathUnknown,self.CallbackProgress).end_result_for_each()
if self.Callback is not None:
self.Callback(end_result)
def run(self):
board = self.s.open_connection('/dev/ttyUSB0')
if board is None:
logger.error('Serial port error')
receive, send = mp.Pipe()
actions = mp.Array('i', [1, 1, 0, 0, 1])
s_service = mp.Process(target=self.communication, args=(board, actions, send))
r = Recognition()
r_service = mp.Process(target=r.recognition,
args=(board, actions, receive, 0, True))
s_service.start()
r_service.start()
s_service.join()
r_service.join()
from flask_cors import CORS, cross_origin
from flask import Flask, request, redirect
from client import TensorflowClient
from recognition import Recognition
UI_LOCATION = os.getenv('UI_LOCATION', 'http://*****:*****@app.route('/')
def index():
return redirect(UI_LOCATION[0])
@app.route('/recognise', methods=['POST'])
@cross_origin(origins=UI_LOCATION)
def recognise():
log.info('Image recognition request was received')
img_raw = request.files['image']
img_binary = img_raw.read()
log.debug('Successfully retrieved the file, recognising')
digit = recognition.recognise(img_binary)
# tts.setVolume(0.75)
# Wake up robot
print("Initializing robot.")
motion.wakeUp()
# build model
print("Building knowledge graph.")
master = Master()
master.buildModel()
for _ in range(5):
# Listening using recognition.py, record.py, and sftp.py
# try:
print("Listening for question.")
rcg = Recognition()
qst = rcg.recognize()
# with open("tmp.txt", "w") as f:
# f.write(qst)
print("Question: " + qst)
# query using the model
print("Finding answer in graph.")
ans = master.query(qst)
print("Answer: " + ans)
tts.say(ans, {"bodyLanguageMode": "contextual"})
# time.sleep(0.5)
# except KeyboardInterrupt:
import sys
sys.path.insert(0, '/home/pi/Zumi_Content/Data/face-recognition')
from recognition import Recognition
from zumi.util.camera import Camera
from zumi.util.screen import Screen
import time
import cv2
import IPython.display
import PIL.Image
import numpy as np
import os
fd = Recognition()
camera = Camera(auto_start=False)
screen = Screen()
def collectPictures():
camera.start_camera()
fd.name = input("input name : ")
print("Capture 50 pictures")
time.sleep(1)
while True:
try:
image = camera.capture()
fd.makeDataset(image)
IPython.display.display(PIL.Image.fromarray(image))
print("Progress : " + str(fd.cap) + "/50")
screen.draw_image(
PIL.Image.fromarray(fd.streaming_image).convert('1'))
from action import Action
from recognition import Recognition
act = Action()
rec = Recognition()
while True:
rec.start(act)
def __init__(self, config):
self.config = config
self.recognizer = Recognition() # 语音识别
def before_server_start(app, loop):
app.rec = Recognition() #创建对比对象
def __init__(self):
self.ans = Answer()
self.rec = Recognition()
locale.setlocale(locale.LC_ALL, "ru")
def main():
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "1"
with open("config.yml", "r") as config_file:
cfg = yaml.load(config_file)
det_cfg = cfg["detection"]
rec_cfg = cfg["recognition"]
logging.basicConfig(
format="%(asctime)s %(module)-12s %(levelname)-8s %(message)s",
level=cfg["log_level"])
logging.info("Starting detection")
detection = Detection(det_cfg)
found_frames = detection.detect_subtitle_region(cfg["video"])
y_start, y_end = detection.get_subtitle_region()
char_width = detection.get_char_width()
char_dist = detection.get_char_dist()
if char_width == 0 or char_dist == 0:
logging.error("Char width is 0")
return
logging.info(
"Found y pos ({}, {}), character width {}, character distance {}".
format(y_start, y_end, char_width, char_dist))
recognition = Recognition(rec_cfg["model"], rec_cfg["weights"],
rec_cfg["dictionary"])
cyk = True
for index, f in enumerate(FONTS):
font = load_font(f, char_width)
font2 = load_font(f, char_width // 2)
if font is None:
logging.error("No CYK font found")
cyk = False
else:
logging.info("Loaded font {}".format(FONTS[index]))
for frame in found_frames:
text = []
img = Image.fromarray(frame)
draw = ImageDraw.Draw(img)
for char_region, start, stop in detection.detect_char_regions(
frame[y_start:y_end, ]):
res = recognition.recognize_character(char_region)
text.append((start, stop, res[1], res[2]))
for start, stop, char, prob in text:
draw.rectangle([(start, y_start), (stop, y_end)],
outline=RECTANGLE_COLOR)
draw.rectangle([(start + 1, y_start + 1), (stop - 1, y_end - 1)],
outline=RECTANGLE_COLOR)
draw.rectangle([(start + 2, y_start + 2), (stop - 2, y_end - 2)],
outline=RECTANGLE_COLOR)
probability = str(int(prob * 100)) + "%"
if cyk:
draw.text((start, y_start - (stop - start)),
char,
fill=FONT_COLOR,
font=font)
draw.text((start, y_start - 1.5 * (stop - start)),
probability,
fill=FONT_COLOR,
font=font2)
else:
logging.info("Detected character {} ({})".format(
char, probability))
cv2.imshow('image', np.array(img))
cv2.waitKey(0)
cv2.destroyAllWindows()
def __init__(self):
self.config = self.read_config()
self.recognition = Recognition(config=self.config)
from register import RegisterUser
from recognition import Recognition
import os
path = 'training-data'
os.mkdir(path)
while True:
os.system("clear")
print("1 - Cadastrar novo usuário")
print("2 - Iniciar Reconhecimento")
print("0 - Sair")
o = input("Opção: ")
if o == '0':
break
elif o == '1':
RegisterUser(path)
elif o == '2':
rec = Recognition(path)
rec.main_loop()
car_id = input("Insert Car ID :")
print("\n")
message = '{"type": "credentials", "status": "%s", "username": "******", "password": "******", "customer_id": "%s", "car_id": "%s"}' % (
status, username, password, customer_id, car_id)
# sending back the credentials data to Master Pi for data validation
# Master Pi will return the message of validation result
sock.sendall(str.encode(message))
time.sleep(10)
clear()
# if the option is 'use face recognition'
elif index == 1:
recog = Recognition()
data = recog.start_recognition(status)
sock.sendall(str.encode(data))
time.sleep(10)
clear()
# if the option is 'Return Car'
elif index == 1:
status = "returned"
title = 'Please select an authorization option: '
options = ['use username and password', 'use face recognition']
option, index = pick(options, title)
print(option)
print("##########")
print("########## \n")
def __init__(self, modelPath, device='cpu'):
self.TF = TinyFace(modelPath, device=device)
self.REC = Recognition(device=device)
self.lastImg = None
def main():
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "1"
with open(sys.argv[1], "r") as config_file:
cfg = yaml.safe_load(config_file)
print(str(cfg))
det_cfg = cfg["detection"]
rec_cfg = cfg["recognition"]
logging.basicConfig(format="%(asctime)s %(module)-12s %(levelname)-8s %(message)s")
logging.warn("Starting detection")
detection = Detection(det_cfg)
found_frames = detection.detect_subtitle_region(cfg["video"])
y_start, y_end = detection.get_subtitle_region()
char_width = detection.get_char_width()
char_dist = detection.get_char_dist()
if char_width == 0 or char_dist == 0:
logging.error("Char width is 0")
return
logging.warn(
"Found y pos ({}, {}), character width {}, character distance {}".format(y_start, y_end, char_width, char_dist))
recognition = Recognition(rec_cfg["model"], rec_cfg["weights"], rec_cfg["dictionary"])
cyk = True
for index, f in enumerate(FONTS):
font = load_font(f, char_width)
font2 = load_font(f, char_width // 2)
if font is None:
logging.error("No CYK font found")
cyk = False
else:
logging.warn("Loaded font {}".format(FONTS[index]))
cap = cv2.VideoCapture(cfg["video"])
save_image_seq = cfg["video_offset_start"]
save_image_seq_end = cfg["video_offset_end"]
cap.set(cv2.CAP_PROP_POS_FRAMES, save_image_seq)
vout = cv2.VideoWriter(cfg["output_sub_video"], cv2.VideoWriter_fourcc(*'mp4v'), 29.97, (1920,1080-y_start+120))
vout.set(cv2.VIDEOWRITER_PROP_QUALITY, 0.1)
print(vout)
custom_config = r'--psm 7 -l chi_sim'
frames_ocr = {}
#for frame in found_frames:
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
text = []
img = Image.fromarray(frame)
draw = ImageDraw.Draw(img)
x_start = 1920
x_end = 0
for char_region, start, stop in detection.detect_char_regions(frame[y_start:y_end, ], save_image=False, save_image_name="fill/seq_{}_{:06d}.tiff".format("{}", save_image_seq)):
if x_start > start:
x_start = start
if x_end < stop:
x_end = stop
continue
res = recognition.recognize_character(char_region)
text.append((start, stop, res[1], res[2]))
logging.warn("Detected Region {} {} in ({} {})".format(start, stop, y_start, y_end))
save_image_seq += 1
if save_image_seq > save_image_seq_end:
break
for start, stop, char, prob in text:
draw.rectangle([(start, y_start), (stop, y_end)], outline=RECTANGLE_COLOR)
draw.rectangle([(start + 1, y_start + 1), (stop - 1, y_end - 1)], outline=RECTANGLE_COLOR)
draw.rectangle([(start + 2, y_start + 2), (stop - 2, y_end - 2)], outline=RECTANGLE_COLOR)
probability = str(int(prob * 100)) + "%"
if cyk:
draw.text((start, y_start - (stop - start)), char, fill=FONT_COLOR, font=font)
draw.text((start, y_start - 1.5 * (stop - start)), probability, fill=FONT_COLOR, font=font2)
#logging.warn("Detected character {} ({})".format(char, probability))
#cv2.imshow('image', np.array(img))
#cv2.resizeWindow('image', int(1920/2), int(1080/2))
#cv2.waitKey(0)
#cv2.destroyAllWindows()
vout.write(frame[y_start-120:1080, ])
if x_start < x_end:
gray = cv2.cvtColor(frame[y_start:y_end, x_start:x_end], cv2.COLOR_BGR2GRAY)
#gray = img
# threshhold
ret,bin = cv2.threshold(gray,245,255,cv2.THRESH_BINARY)
# closing
kernel = np.ones((3,3),np.uint8)
closing = cv2.morphologyEx(bin, cv2.MORPH_CLOSE, kernel)
# invert black/white
inv = cv2.bitwise_not(closing)
img_rgb = cv2.cvtColor(inv, cv2.COLOR_GRAY2RGB)
#print(img_rgb)
data_xml = pytesseract.image_to_alto_xml(img_rgb, config=custom_config)
print(str(save_image_seq) + " " + data_xml.decode('utf-8'))
#print(str(i) + " " + json.dumps(data_xml.decode('utf-8')))
frames_ocr[save_image_seq] = data_xml.decode('utf-8')
cap.release()
vout.release()
with open(cfg['output_sub_ocr'], 'w') as outfile:
json.dump(frames_ocr, outfile, sort_keys=True, indent=2)