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)