def main(): global frame, key # initialize the camera and grab a reference to the raw camera capture wdth = int(math.floor(360)) hgth = int(math.floor(800)) camera = VideoStream(usePiCamera=True,resolution=(wdth,hgth)).start() time.sleep(2.0) fourcc = cv2.VideoWriter_fourcc(*'MJPG') writer = None (h,w) = (None, None) # setup the mouse callback cv2.startWindowThread() cv2.namedWindow("Detection") cv2.setMouseCallback("Detection",mouseOn) # keep looping over the frames #for frame2 in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True): while True: frame = camera.read(); frame = cv2.transpose(frame); frame = cv2.flip(frame,1) timestamp = datetime.datetime.now() ts = timestamp.strftime("%d/%m/%Y %H:%M:%S") cv2.putText(frame,ts,(10,frame.shape[0]-10),cv2.FONT_HERSHEY_SIMPLEX,0.35,(0,255,0),1) if writer is None: (h,w) = frame.shape[:2] writer = cv2.VideoWriter("/media/usb/test_" + timestamp.strftime("%d_%m_%Y_%H%M") + ".avi", fourcc,5,(w,h), True) writer.write(frame) cv2.imshow("Detection", frame); #cv2.setMouseCallback("Detection",mouseOn) #key = cv2.waitKey(10) & 0xFF # if the 'q' key is pressed, stop the loop if key == ord("q"): #cv2.EVENT_LBUTTONDOWN: #ord("q"): # cv2.destroyAllWindows() # camera.stop() break # cleanup the camera and close any open windows cv2.destroyAllWindows() camera.stop()
(minX, maxX) = (min(minX, x), max(maxX, x + w)) (minY, maxY) = (min(minY, y), max(maxY, y + h)) # draw the bounding box cv2.rectangle(result, (minX, minY), (maxX, maxY), (0, 0, 255), 3) # increment the total number of frames read and draw the # timestamp on the image total += 1 timestamp = datetime.datetime.now() ts = timestamp.strftime("%A %d %B %Y %I:%M:%S%p") cv2.putText(result, ts, (10, result.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 0, 255), 1) # show the output images cv2.imshow("Result", result) cv2.imshow("Left Frame", left) cv2.imshow("Right Frame", right) key = cv2.waitKey(1) & 0xFF # if the `q` key was pressed, break from the loop if key == ord("q"): break # do a bit of cleanup print("[INFO] cleaning up...") cv2.destroyAllWindows() leftStream.stop() rightStream.stop()
def main(): # construction des arguments ap = argparse.ArgumentParser() ap.add_argument("-p", "--prototxt", required=False, default="/home/pi/Kenobi/recognition/MobileNetSSD_deploy.prototxt.txt", help="path to Caffe 'deploy' prototxt file") ap.add_argument("-m", "--model", required=False, default="/home/pi/Kenobi/recognition/MobileNetSSD_deploy.caffemodel", help="path to Caffe pre-trained model") ap.add_argument("-c", "--confidence", type=float, default=0.6, help="minimum probability to filter weak detections") args = vars(ap.parse_args()) # initialiser la liste des objets entrainés par MobileNet SSD # création du contour de détection avec une couleur attribuée au hasard pour chaque objet CLASSES = ["arriere-plan", "avion", "velo", "oiseau", "bateau", "bouteille", "autobus", "voiture", "chat", "chaise", "vache", "table", "chien", "cheval", "moto", "personne", "plante", "mouton", "sofa", "train", "moniteur"] COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3)) pygame.mixer.init() # chargement des fichiers depuis le répertoire de stockage print(" ...chargement du modèle...") net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"]) # initialiser la caméra du pi, attendre 2s pour la mise au point , # initialiser le compteur FPS print("...démarrage de la Picamera...") vs = VideoStream(usePiCamera=True, resolution=(1600, 1200)).start() time.sleep(2.0) #fps = FPS().start() # boucle principale du flux vidéo while True: # récupération du flux vidéo, redimension # afin d'afficher au maximum 800 pixels frame = vs.read() frame = imutils.resize(frame, width=800) # récupération des dimensions et transformation en collection d'images (h, w) = frame.shape[:2] blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5) # determiner la détection et la prédiction net.setInput(blob) detections = net.forward() # boucle de détection list_objects = [] for i in np.arange(0, detections.shape[2]): # calcul de la probabilité de l'objet détecté en fonction de la prédiction confidence = detections[0, 0, i, 2] # supprimer les détections faibles inférieures à la probabilité minimale if confidence > args["confidence"]: # extraire l'index du type d'objet détecté # calcul des coordonnées de la fenêtre de détection idx = int(detections[0, 0, i, 1]) #box = detections[0, 0, i, 3:7] * np.array([w, h, w, h]) #(startX, startY, endX, endY) = box.astype("int") # creation du contour autour de l'objet détecté # insertion de la prédiction de l'objet détecté #label = "{}: {:.2f}%".format(CLASSES[idx], confidence * 100) #cv2.rectangle(frame, (startX, startY), (endX, endY), COLORS[idx], 2) #y = startY - 15 if startY - 15 > 15 else startY + 15 #cv2.putText(frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2) # enregistrement de l'image détectée #cv2.imwrite("detection.png", frame) obj = CLASSES[idx] if obj not in list_objects: list_objects.append(CLASSES[idx]) # affichage du flux vidéo dans une fenètre #cv2.imshow("Frame", frame) #key = cv2.waitKey(1) & 0xFF # ligne necessaire pour l'affichage dans la frame # Pronounce the objects seen print(list_objects) for anobject in list_objects: path_to_sound = "/home/pi/Kenobi/recognition/vocabulary/" + anobject + ".ogg" if os.path.isfile(path_to_sound): pygame.mixer.music.load(path_to_sound) pygame.mixer.music.play() # Play until end of music file while pygame.mixer.music.get_busy() == True: pygame.time.Clock().tick(10) # la touche q permet d'interrompre la boucle principale #if key == ord("q"): # break # mise à jour du FPS #fps.update() # arret du compteur et affichage des informations dans la console #fps.stop() #print("[INFO] elapsed time: {:.2f}".format(fps.elapsed())) #print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) cv2.destroyAllWindows() vs.stop()
class DualCamera(): def __init__(self): self.root = Tk() self.root.wm_title("Dual Cam") self.saving = False self.frames = [] self.overlay = False self.image_left = ImageTk.PhotoImage(image=Image.fromarray(np.uint8(np.zeros((256, 256))))) self.image_panel_left = Label(self.root, image = self.image_left) self.image_panel_left.grid(row = 0, column = 0, columnspan=2) self.image_right = ImageTk.PhotoImage(image=Image.fromarray(np.uint8(256 * np.random.rand(256, 256)))) self.image_panel_right = Label(self.root, image = self.image_right) self.image_panel_right.grid(row = 0, column = 2, columnspan=2) self.save_button = Button(width = 10, height = 2, text = 'Save', command=self.save) self.save_button.grid(row = 1, column = 0) self.calibrate_button = Button(width = 10, height = 2, text = 'Calibrate', command=self.calibrate) self.calibrate_button.grid(row = 1, column = 1) self.close_button = Button(width = 10, height = 2, text = 'Close', command=self.quit) self.close_button.grid(row = 1, column = 3) self.overlay_button = Button(width=10, height=2, text='Overlay', command=self.toggle_overlay) self.overlay_button.grid(row = 1, column = 2) self.bias_slider = Scale(self.root, from_=0, to=31, length=400, orient=HORIZONTAL, command=self.bias) self.bias_slider.grid(row = 2, column = 1, columnspan=3) self.bias_label = Label(self.root, text="Bias current") self.bias_label.grid(row=2, column=0) self.clock_slider = Scale(self.root, from_=0, to=63, length=400, orient=HORIZONTAL, command=self.clock) self.clock_slider.grid(row = 3, column = 1, columnspan=3) self.clock_label = Label(self.root, text="Clock speed") self.clock_label.grid(row=3, column=0) self.cm_slider = Scale(self.root, from_=0, to=31, length=400, orient=HORIZONTAL, command=self.cm) self.cm_slider.grid(row = 4, column = 1, columnspan=3) self.cm_label = Label(self.root, text="CM current") self.cm_label.grid(row=4, column=0) # set default positions self.cm_slider.set(0x0C) self.clock_slider.set(0x15) self.bias_slider.set(0x05) # initialize visible camera self.vs = VideoStream(usePiCamera=True).start() # thread for reading from sensor hardware intro an image queue self.ir_images = Queue.LifoQueue() self.ir_commands = Queue.Queue() self.ir_calibrate = threading.Event() self.ir_stop = threading.Event() self.raw_ir_images = Queue.LifoQueue() self.capture_thread = threading.Thread( target=ir_capture, name="capture_thread", args=[self.ir_images, self.ir_calibrate, self.ir_stop, self.ir_commands, self.raw_ir_images] ) self.capture_thread.start() self.ticktock() self.root.mainloop() def ticktock(self): # grab an image from the camera frame = self.vs.read() changed = False if frame is not None: frame = imutils.resize(frame, height=240) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) self.last_vis_frame = frame image = Image.fromarray(frame) if not self.overlay: self.image_right = ImageTk.PhotoImage(image=image) self.image_panel_right.configure(image=self.image_right); changed = True if not self.ir_images.empty(): ir_frame = self.ir_images.get() if not self.ir_images.empty(): with self.ir_images.mutex: self.ir_images.queue = [] ir_image = imutils.resize(ir_frame, height=240, inter=cv2.INTER_LINEAR) ir_image = np.dstack((ir_image, ir_image, ir_image)) ir_image = cv2.LUT(ir_image, colormap).astype('uint8') self.last_ir_frame = ir_image self.image_left = ImageTk.PhotoImage(image=Image.fromarray(ir_image)) self.image_panel_left.configure(image=self.image_left) changed = True if changed and self.overlay: overlay_image = np.zeros_like(self.last_vis_frame) overlay_image[:,:,2] = 0.125 * self.last_vis_frame[:,:,0] + 0.25 * self.last_vis_frame[:,:,1] + 0.125 * self.last_vis_frame[:,:,2] converted_frame = cv2.cvtColor(self.last_ir_frame, cv2.COLOR_RGB2HSV) overlay_image[:,40:280,2] += 0.5 * converted_frame[:,:,2] overlay_image[:,40:280,1] = converted_frame[:,:,1] overlay_image[:,40:280,0] = converted_frame[:,:,0] overlay_image = cv2.cvtColor(overlay_image, cv2.COLOR_HSV2RGB) self.image_right = ImageTk.PhotoImage(image=Image.fromarray(overlay_image)) self.image_panel_right.configure(image=self.image_right) if self.saving: if not self.raw_ir_images.empty(): ir_frame = self.raw_ir_images.get() if not self.raw_ir_images.empty(): with self.raw_ir_images.mutex: self.raw_ir_images.queue = [] else: ir_frame = None self.frames.append((frame, ir_frame)) if not self.ir_calibrate.isSet(): self.calibrate_button.configure(text = 'Calibrate', command=self.calibrate, state="normal") self.root.after(100, self.ticktock) def quit(self): self.vs.stop() self.ir_stop.set() self.root.quit() def save(self): self.save_button.configure(text = 'Stop Saving', command=self.stop_save) self.saving = True self.frames = [] def stop_save(self): self.save_button.configure(text = 'Save', command=self.save) now = time.strftime("%Y-%m-%dT%H:%M:%S") pickle.dump(self.frames, open(now + ".p", "wb")) self.frames = [] def calibrate(self): self.calibrate_button.configure(text = 'Calibrating...', state="disabled") self.ir_calibrate.set() def cm(self, val): val = int(val) self.ir_commands.put(('cm', val)) def bias(self, val): val = int(val) self.ir_commands.put(('bias', val)) def clock(self, val): val = int(val) self.ir_commands.put(('clock', val)) def toggle_overlay(self): if self.overlay: self.overlay = False self.overlay_button.configure(text = 'Overlay') else: self.overlay = True self.overlay_button.configure(text = 'No Overlay')
def viewCameraPi(self): #text = 'This is a message from app to inform that app start running now!' #statusSMS = outboundSMSviaTwilio(account=self.account, token=self.token, destPhone=self.destPhone1, # twilioNumber=self.twilioNumber, message_body=text) #statusSMS = outboundSMSviaTwilio(account=self.account, token=self.token, destPhone=self.destPhone2, # twilioNumber=self.twilioNumber, message_body=text) print("START SCRIPT AND MAJOR WARNING!") statusSMS = 'delivered' if((statusSMS != 'failed') and (statusSMS != 'undelivered')): #camera = PiCamera() #camera.resolution = ( 640, 480) #camera.framerate = 32 #rawCapture = PiRGBArray(camera, size=( 640, 480)) #self.sumMSE = self.sumSSIM = self.avgMSE = self.avgSSIM = 0 self.tempHour = datetime.datetime.now().hour self.tempMinute = datetime.datetime.now().minute self.warmup = 0 vs = VideoStream(usePiCamera=1,resolution=(640,480)).start() time.sleep(1.2) fourcc = cv2.VideoWriter_fourcc(*"MJPG") writer = None (h, w) = (None, None) zeros = None print ("view camera") while True: self.warmup+=1 if(self.warmup >=5): frame = vs.read() if writer is None: # store the image dimensions, initialzie the video writer, # and construct the zeros array (h, w) = frame.shape[:2] writer = cv2.VideoWriter('exampleTH3.avi', fourcc, 20, (w, h), True) writer.write(frame) self.curImage = frame self.getDefImagePerHours() #write xml print("process frame thu {}".format(self.warmup-4)) self.writeXML() #tat chuong trinh sau 5 phut: if(datetime.datetime.now().minute - self.tempMinute >5): self.final() break # for frame in camera.capture_continuous( rawCapture, format("bgr"), use_video_port = True): # # self.curImage = frame.array # frame = vs.read() # self.warmup +=1 # if(self.warmup >=5): # self.getDefImagePerHours() # # self.getDefImagePerTenMinutes() # # #write xml # print("process frame thu {}".format(self.warmup-4)) # self.writeXML() # # #warning # # self.warning() # # #tat chuong trinh sau 5 phut: # if(datetime.datetime.now().minute - self.tempMinute >5): # self.final() # break # #neu la 16h, script se tu tat # # tempBreak = datetime.datetime.now().hour # # if(( tempBreak == 0) or (tempBreak == 6) or (tempBreak == 18) or (tempBreak == 12)): # # if(datetime.datetime.now().minute == 0): # # if((datetime.datetime.now().second >= 0) and (datetime.datetime.now().second <=3)): # # self.final() # # self.__init__(tempBreak) # # # show frame # # cv2.imshow("image", self.curImage) # # key = cv2.waitKey(1) & 0xFF # # #renew # rawCapture.truncate(0) # # #press 'q' to stop, press any key to continue # # if(key == ord("q")): # # break #call function final vs.stop() writer.release() self.final() else : print("send message failed. So App will not run. Sorry for the inconvenience!!")
#contours cnts=cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] #time.sleep(10) center=None if len(cnts)>0: cnt=cnts[0] rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) box=np.int0(box) x1=(box[3][0]-(box[0][0])) y1=(box[3][1]-(box[0][1])) print 'x1', x1 print 'y1', y1 if ((abs(x1)>70)or (abs(y1)>70)): #time.sleep(5) cv2.imshow('OrigFrame',frame) execfile("InvKin_Control.py") print "picking up" cv2.drawContours(frame,[box],0,(0,0,255),2) key=cv2.waitKey(1)& 0xFF if key==ord("q"): break camera.stop() cv2.destroyAllWindows()
import time import cv2 import imutils from imutils.video import VideoStream from matcher import Matcher matcher = Matcher([("fau-logo", "./templates/fau-logo.png"), ("first-logo", "./templates/first-logo.jpg"), ("nextera-logo", "./templates/nextera-energy-logo.jpg"), ("techgarage-logo", "./templates/techgarage-logo.png") ], min_keypoints_pct_match=8) cam = VideoStream(usePiCamera=False).start() cnt = 0 while True: img = cam.read() cv2.imshow("Pic", img) print matcher.match(img) key = cv2.waitKey(10) if key == ord('q'): break cam.stop() cv2.destroyAllWindows()
def line_detection(shared_object): """ Detects the line in a special set region, calculates the average center of the line in the screen and detects red :param shared_object: Thread notifier :return: None """ # Get view of picamera and do a small warmup of 0.3s cap = VideoStream(src=0, usePiCamera=True, resolution=(320, 240)).start() time.sleep(0.3) # Get width and height of the frame and make vertices for a traingle shaped region sample = cap.read() height, width, channel = sample.shape vertices = [ (20, height), (width / 2, height / 2 + 20), (width - 20, height - 20), ] while not shared_object.has_to_stop(): # Get current frame from picamera and make a cropped image with the vertices above with set_region img = cap.read() img = cv2.flip(img, -1) img_cropped = set_region(img, np.array([vertices], np.int32)) # Add blur to the cropped image blur = cv2.GaussianBlur(img_cropped, (9, 9), 0) # Generate and set a mask for a range of black (color of the line) to the cropped image hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV) black = Color("Black", [0, 0, 0], [180, 92, 90]) mask = cv2.inRange(hsv, black.lower, black.upper) # Checks if the color red is detected and calls function detect_red with the img global red_detected, red if detect_red(img, hsv): red_detected = True else: if red_detected: red = True red_detected = False # Set variables and get lines with Houghlines function on the mask of black theta = np.pi / 180 threshold = 30 min_line_length = 10 max_line_gap = 40 lines = cv2.HoughLinesP(mask, 1, theta, threshold, np.array([]), min_line_length, max_line_gap) # Set line color to blue and clone the image to draw the lines on line_color = (255, 0, 0) img_clone = img.copy() global line_detected if lines is not None: for line in lines: for x1, y1, x2, y2 in line: # Make two points with the pixels of the line and draw the line on the cloned image p1 = Point(x1, y1) p2 = Point(x2, y2) cv2.line(img_clone, (p1.x, p1.y), (p2.x, p2.y), line_color, 5) # Calculate avarge distance with avarge_distance in percentages to the left and right left, right = average_distance(lines, width) global last_position last_position = round(left) line_detected = True else: line_detected = False # cv2.imshow('camservice-lijn', img_clone) # If q is pressed, break while loop if cv2.waitKey(1) & 0xFF == ord('q'): break cap.stop() cv2.destroyAllWindows()
elif event.key == pg.K_c: print("Going Backward-right") Backright(speed) elif event.key == pg.K_e: print("Doing a Circle-right") Circleright(speed) elif event.key == pg.K_q: print("Doing a Circle-left") Circleleft(speed) elif event.key == pg.K_l: print("Exiting!") GPIO.cleanup() webcam.stop() cv.destroyAllWindows() pg.quit() elif event.type == pg.QUIT: print("Exiting!") GPIO.cleanup() webcam.stop() cv.destroyAllWindows() pg.quit() break elif event.type == pg.KEYUP: Stop() print("Stop")
def run(mode, localPath): global font global success global totalInferenceDuration print("CUDE usage status : " + str(dlib.DLIB_USE_CUDA)) #faced face_detector = FaceDetector() startTS = time.time() """ Load models """ predictor_path = "assets/shape_predictor_5_face_landmarks.dat" face_rec_model_path = "assets/dlib_face_recognition_resnet_model_v1.dat" facerec = dlib.face_recognition_model_v1(face_rec_model_path) sp = dlib.shape_predictor(predictor_path) """ Check local/stream availability """ if (mode == "stream"): # initialize the video stream and allow the cammera sensor to warmup print("[INFO] starting video stream...") vs = VideoStream(src=0).start() w = int(vs.get(3)) h = int(vs.get(4)) time.sleep(2.0) elif (mode == "local"): vidcap = cv2.VideoCapture(localPath) success, frame = vidcap.read() fps = vidcap.get(cv2.CAP_PROP_FPS) frameCtr = 0 w = int(vidcap.get(3)) h = int(vidcap.get(4)) fourcc = cv2.VideoWriter_fourcc(*'MJPG') out = cv2.VideoWriter('output.avi', fourcc, 15, (w, h)) while success: processStartTs = time.time() """ Acquire the next frame """ if (mode == "stream"): frame = vs.read() elif (mode == "local"): success, frame = vidcap.read() frameCtr += 1 """ grab the frame from the threaded video stream and resize it to have a maximum width of 400 pixels """ try: frame = imutils.resize(frame, width=400) except AttributeError: continue try: rgb_img = cv2.cvtColor(frame.copy(), cv2.COLOR_BGR2RGB) except: break inferenceStartTs = time.time() #faced (thresh argument can be added, 0.85 by default-) bboxes = face_detector.predict(rgb_img) inferenceEndTs = time.time() totalInferenceDuration += inferenceEndTs - inferenceStartTs helpers.min_clusters = len(bboxes) if (mode == "stream"): timestamp = calendar.timegm(time.gmtime()) elif (mode == "local"): timestamp = float(frameCtr / fps) for x, y, w, h, p in bboxes: top = int(y + h / 2) left = int(x - w / 2) bottom = int(y - h / 2) right = int(x + w / 2) cv2.rectangle(frame, (left, bottom), (right, top), (99, 44, 255), 1) cv2.putText(frame, str(p), (left, top + 5), font, 0.2, (255, 255, 255), 1, cv2.LINE_AA) shape = sp(frame, dlib.rectangle(left, bottom, right, top)) # Compute the 128D vector that describes the face in img identified by face_descriptor = facerec.compute_face_descriptor(frame, shape) bestIndex = cluster_faces.match(face_descriptor) if (bestIndex >= 0): cv2.putText(frame, str(helpers.unique_persons[bestIndex]["uuid"]), (left, top + 10), font, 0.2, (0, 255, 255), 1, cv2.LINE_AA) data = [{ "uuid": helpers.unique_persons[bestIndex]["uuid"], "timestamp": timestamp }] helpers.individual_stats.extend(data) else: cv2.putText(frame, "Learning...", (left, top + 10), font, 0.2, (0, 255, 255), 1, cv2.LINE_AA) data = [{ "label": 0, "timestamp": timestamp, "encoding": face_descriptor }] helpers.candidate_persons.extend(data) try: frame = imutils.resize(frame, width=720) except AttributeError: continue cv2.putText(frame, "FPS : " + str(int(1 / (time.time() - processStartTs))), (20, 30), font, 1, (0, 255, 0), 3, cv2.LINE_AA, False) out.write(frame) #cv2.imshow("Frame", frame) if (len(helpers.candidate_persons) >= (helpers.MIN_FACES_PER_CLUSTER * helpers.min_clusters)): cluster_faces.cluster() key = cv2.waitKey(1) & 0xFF # if the `q` key was pressed, break from the loop if key == ord("q"): break # do a bit of cleanup if (mode == "stream"): vs.stop() endTS = time.time() out.release() print("Total number of unique faces = ", len(helpers.unique_persons)) print("Total duration") print(endTS - startTS) print("Total inference duration") print(totalInferenceDuration)
def objectdetection(objname): engine = pyttsx3.init() engine.setProperty('rate', 150) ap = argparse.ArgumentParser() ap.add_argument('-p', '--prototxt', required=True, help="path to Caffe 'deploy' prototxt file") ap.add_argument('-m', '--model', required=True, help='path to Caffe pre-trained model') ap.add_argument('-c', '--confidence', type=float, default=0.2, help='minimum probability to filter weak detections') args = vars(ap.parse_args()) CLASSES = [ 'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor', ] COLORS = np.random.uniform(0, 0xFF, size=(len(CLASSES), 3)) print('[INFO] loading model...') net = cv2.dnn.readNetFromCaffe(args['prototxt'], args['model']) print('Model information obtained') print('[INFO] starting video stream...') vs = VideoStream(src=0).start() time.sleep(2.0) fps = FPS().start() frame_width = 600 user_x = frame_width / 2 user_y = frame_width while True: frame = vs.read() frame = imutils.resize(frame, width=frame_width) frame = imutils.rotate(frame, angle=180) (h, w) = frame.shape[:2] blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5) net.setInput(blob) detections = net.forward() fl = False for i in np.arange(0, detections.shape[2]): confidence = detections[0, 0, i, 2] if confidence > args['confidence']: idx = int(detections[0, 0, i, 1]) if objname in CLASSES[idx]: fl = True box = detections[0, 0, i, 3:7] * np.array([w, h, w, h]) (startX, startY, endX, endY) = box.astype('int') label = '{}: {:.2f}%'.format(CLASSES[idx], confidence * 100) cv2.rectangle(frame, (startX, startY), (endX, endY), COLORS[idx], 2) y = (startY - 15 if startY - 15 > 15 else startY + 15) cv2.putText( frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2, ) centerX = (endX + startX) / 2 centerY = (endY + startY) / 2 cv2.line(frame, (int(user_x), int(user_y)), (int(centerX), int(centerY)), (0xFF, 0, 0), 7) dir = 0 if centerX > user_x: dir = 1 dirr = 'right' print(dirr) engine.say(dirr) engine.runAndWait() elif centerX < user_x: dir = -1 deg = math.degrees( math.atan( abs(centerX - user_x) / abs(centerY - user_y))) middle = centerY - user_y deg1 = centerX - user_x dirr = 'left' print(dirr) engine.say(dirr) engine.runAndWait() #print("LR = " + str(deg1)) #print("ceta = " + str(deg)) """if deg1 > 50: dirr = 'right' print(dirr) engine.say(dirr) engine.runAndWait() """ if deg1 < 50 and deg1 > -50: dirr = 'forward' print(dirr) engine.say(dirr) engine.runAndWait() distance = ShowDistance() engine.say(distance) engine.runAndWait() """if deg1 < -50: dirr = 'left' print(dirr) engine.say(dirr) engine.runAndWait() """ cv2.imshow('Frame', frame) key = cv2.waitKey(1) & 0xFF if key == ord("q"): break fps.update() fps.stop() print("[INFO] elapsed time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) cv2.destroyAllWindows() vs.stop() main()
for c in cnts: # if the contour is too small, ignore it if cv2.contourArea(c) < args["min_area"]: continue # compute the bounding box for the contour, draw it on the frame, # and update the text (x, y, w, h) = cv2.boundingRect(c) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) text = "Occupied" # draw the text and timestamp on the frame cv2.putText(frame, "Room Status: {}".format(text), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) cv2.putText(frame, datetime.datetime.now().strftime("%A %d %B %Y %I:%M:%S%p"), (10, frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 0, 255), 1) # show the frame and record if the user presses a key cv2.imshow("Security Feed", frame) cv2.imshow("Thresh", thresh) cv2.imshow("Frame Delta", frameDelta) key = cv2.waitKey(1) & 0xFF # if the `q` key is pressed, break from the lop if key == ord("q"): break # cleanup the camera and close any open windows vs.stop() if args.get("video", None) is None else vs.release() cv2.destroyAllWindows()
def cameraInput(): # load the known faces and embeddings along with OpenCV's Haar # cascade for face detection print("[INFO] loading encodings + face detector...") data = pickle.loads(open("/home/pi/Desktop/pi-face-recognition/ourencodings.pickle", "rb").read()) detector = cv2.CascadeClassifier("/home/pi/Desktop/pi-face-recognition/haarcascade_frontalface_default.xml") # initialize the video stream and allow the camera sensor to warm up print("[INFO] starting video stream...") # vs = VideoStream(src=0).start() vs = VideoStream(usePiCamera=True).start() time.sleep(2.0) # start the FPS counter fps = FPS().start() count = 0 start_time = 0 check = False ############################################# ## -- NEED TO CHANGE VIDEO->CAMERA # loop over frames from the video file stream while True: # grab the frame from the threaded video stream and resize it # to 500px (to speedup processing) frame = vs.read() frame = imutils.resize(frame, width=500) # convert the input frame from (1) BGR to grayscale (for face # detection) and (2) from BGR to RGB (for face recognition) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # detect faces in the grayscale frame rects = detector.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE) # OpenCV returns bounding box coordinates in (x, y, w, h) order # but we need them in (top, right, bottom, left) order, so we # need to do a bit of reordering boxes = [(y, x + w, y + h, x) for (x, y, w, h) in rects] # compute the facial embeddings for each face bounding box encodings = face_recognition.face_encodings(rgb, boxes) names = [] # loop over the facial embeddings for encoding in encodings: # attempt to match each face in the input image to our known # encodings matches = face_recognition.compare_faces(data["encodings"], encoding) name = "Unknown" # check to see if we have found a match if True in matches: # find the indexes of all matched faces then initialize a # dictionary to count the total number of times each face # was matched matchedIdxs = [i for (i, b) in enumerate(matches) if b] counts = {} # loop over the matched indexes and maintain a count for # each recognized face face for i in matchedIdxs: name = data["names"][i] counts[name] = counts.get(name, 0) + 1 # determine the recognized face with the largest number # of votes (note: in the event of an unlikely tie Python # will select first entry in the dictionary) name = max(counts, key=counts.get) if (name != "Unknown"): print("person") print(count) if (count == 0): start_time = time.time() count = count + 1 pre_name = name between = (time.time() - start_time) * 1000 / 60 if (between >= 2): ######### print('TTS start') tts = gTTS(name) tts.save('obj.mp3') print('TTS ok') print('pygame start') pygame.init() pygame.mixer.init() obj_out = pygame.mixer.music.load('obj.mp3') pygame.mixer.music.play() # pygame.event.wait() print('pygame ok') ############ check = True break count = 0 start_time = 0 # update the list of names names.append(name) # loop over the recognized faces for ((top, right, bottom, left), name) in zip(boxes, names): # draw the predicted face name on the image cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2) y = top - 15 if top - 15 > 15 else top + 15 cv2.putText(frame, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 2) # display the image to our screen cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # do a bit of cleanup cv2.destroyAllWindows() vs.stop()
frameHSV = cv2.cvtColor(frameBGR, cv2.COLOR_BGR2HSV) # HSV values to define a colour range we want to create a mask from. colorLow = np.array([lowHue,lowSat,lowVal]) colorHigh = np.array([highHue,highSat,highVal]) mask = cv2.inRange(frameHSV, colorLow, colorHigh) # Show the first mask cv2.imshow('mask-plain', mask) # Cleanup the mask with Morphological Transformation functions kernal = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7)) mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernal) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernal) # Show morphological transformation mask cv2.imshow('mask', mask) # Put mask over top of the original image. result = cv2.bitwise_and(frame, frame, mask = mask) # Show final output image cv2.imshow('colorTest', result) # listen for exit key (q) to eixt main loop if cv2.waitKey(1) & 0xff == ord('q'): break # close program cv2.destroyAllWindows() capture.stop()
# otherwise, the eye aspect ratio is not below the blink # threshold else: # if the eyes were closed for a sufficient number of # then increment the total number of blinks if COUNTER >= EYE_AR_CONSEC_FRAMES: TOTAL += 1 # reset the eye frame counter COUNTER = 0 # draw the total number of blinks on the frame along with # the computed eye aspect ratio for the frame cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2) cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2) # show the frame cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # if the `q` key was pressed, break from the loop if key == ord("q"): break # do a bit of cleanup cv2.destroyAllWindows() vs.stop()
#G = cv2.merge([zeros, G, zeros]) #B = cv2.merge([B, zeros, zeros]) # construct the final output frame, storing the original frame # at the top-left, the red channel in the top-right, the green # channel in the bottom-right, and the blue channel in the # bottom-left output = np.zeros((h, w, 3), dtype="uint8") output[0:h, 0:w] = frame #output[0:h, w:w * 2] = R #output[h:h * 2, w:w * 2] = G #output[h:h * 2, 0:w] = B # write the output frame to file writer.write(output) # show the frames cv2.imshow("Frame", frame) cv2.imshow("Output", output) key = cv2.waitKey(1) & 0xFF # if the `q` key was pressed, break from the loop if key == ord("q"): break # do a bit of cleanup print("[INFO] cleaning up...") cv2.destroyAllWindows() vs.stop() writer.release()
def barcode_scanner(csv_file): print("[INFO] Starting video stream ....") vs = VideoStream(src=0).start() #vs = VideoStream(usePiCamera=True).start() time.sleep(2.0) csv = open(csv_file, "a") found = set() reader = zxing.BarCodeReader() while True: frame = vs.read() frame = imutils.resize(frame, width=400) #barcodes = pyzbar.decode(frame) #f = BytesIO() im = Image.fromarray(frame) im.save("./tmp/a.jpeg") barcodes = reader.decode("./tmp/a.jpeg") #im.save(f, "JPEG") #barcodes = reader.decode(f.read()) #f.close() if barcodes: print(barcodes) if barcodes and (barcodes.format == "CODE_39" or barcodes.format == "QR_CODE"): print(dir(barcodes)) print("raw: {}".format(barcodes.raw)) print("type: {}".format(barcodes.type)) print("format: {}".format(barcodes.format)) print("parse: {}".format(barcodes.parse)) print("parsed: {}".format(barcodes.parsed)) print("points: {}".format(barcodes.points)) print(barcodes) barcode_data = barcodes.raw barcode_type = barcodes.format (x1, y1) = (int(barcodes.points[0][0]), int(barcodes.points[0][1])) (x2, y2) = (int(barcodes.points[1][0]), int(barcodes.points[1][1])) cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 2) text = "{} ({})".format(barcode_data, barcode_type) cv2.putText(frame, text, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) #for barcode in barcodes: # barcode_data = barcode.data.decode("utf-8") # barcode_type = barcode.type # (x, y, w, h) = barcode.rect # cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2) # # text = "{} ({})".format(barcode_data, barcode_type) # cv2.putText(frame, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) # if barcode_data not in found: # csv.write("{},{},{}\n".format(datetime.datetime.now(), barcode_data, barcode_type)) # csv.flush() # found.add(barcode_data) cv2.imshow("Barcode Scanner", frame) key = cv2.waitKey(1) & 0xFF if key == ord("q"): break print("[INFO] Cleaning up....") csv.close() cv2.destroyAllWindows() vs.stop()