def cv2_demo(net, transform): def predict(frame): height, width = frame.shape[:2] x = torch.from_numpy(transform(frame)[0]).permute(2, 0, 1) x = Variable(x.unsqueeze(0)) y = net(x) # forward pass detections = y.data # scale each detection back up to the image scale = torch.Tensor([width, height, width, height]) for i in range(detections.size(1)): j = 0 while detections[0, i, j, 0] >= 0.6: pt = (detections[0, i, j, 1:] * scale).cpu().numpy() cv2.rectangle(frame, (int(pt[0]), int(pt[1])), (int(pt[2]), int(pt[3])), COLORS[i % 3], 2) cv2.putText(frame, labelmap[i - 1], (int(pt[0]), int(pt[1])), FONT, 2, (255, 255, 255), 2, cv2.LINE_AA) j += 1 return frame # start video stream thread, allow buffer to fill print("[INFO] starting threaded video stream...") stream = WebcamVideoStream(src=0).start() # default camera time.sleep(1.0) # start fps timer # loop over frames from the video file stream while True: # grab next frame frame = stream.read() key = cv2.waitKey(1) & 0xFF # update FPS counter fps.update() frame = predict(frame) # keybindings for display if key == ord('p'): # pause while True: key2 = cv2.waitKey(1) or 0xff cv2.imshow('frame', frame) if key2 == ord('p'): # resume break cv2.imshow('frame', frame) if key == 27: # exit break
def stream(): vs = WebcamVideoStream(src="rtmp://192.168.100.240:1935/b").start() fps = FPS().start() while True: frame = vs.read() if frame is None: print("Error: failed to capture image") break cv2.imwrite('demo.jpg', frame) yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + open('demo.jpg', 'rb').read() + b'\r\n') fps.update() fps.stop() vs.stop()
def __init__(self): super(Afis_1, self).__init__() loadUi('gui.ui', self) self.image = None self.im_thresh = None self.start_counter = 0 self.data = [[], [], [], []] self.kata = [] self.data_compress = [[], []] self.data_morse = [] # [ record, mode(0=single,1=multi)] self.rd_snl = [0, 0] self.t1 = 0 self.t2 = 0 self.sinyal = [[], []] self.massage = "" self.position_cursor = [] self.capture = WebcamVideoStream(src=0).start() # self.capture = cv2.VideoCapture(0) # ret, self.image =self.capture.read() self.image = self.capture.read() height, width, can = np.shape(self.image) self.fy = 480 / height self.fx = 640 / width # print(self.fx) # print(self.fy) self.main_frame.mousePressEvent = self.getPos self.Button_Start.toggled.connect(self.start_cam) self.Button_Start.setCheckable(True) self.Button_Save.toggled.connect(self.start_record) self.Button_Save.setCheckable(True) self.Button_Clear.clicked.connect(self.clear_data) self.Button_Send.clicked.connect(self.send_data)
def recognize(self): recognizer = cv2.face.LBPHFaceRecognizer_create() recognizer.read('trainer/trainer.yml') cascadePath = "haarcascade/haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascadePath) if sys.platform == 'win32': from imutils.video import WebcamVideoStream cap = WebcamVideoStream(src=0).start() else: from imutils.video.pivideostream import PiVideoStream cap = PiVideoStream().start() font = cv2.FONT_HERSHEY_COMPLEX d = database.Database().getAll() ls = {} for doc in d: ls[doc['id']] = doc['name'] name = 'unknown' while True: im = cap.read() gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(gray, 1.2, 5) for (x, y, w, h) in faces: cv2.rectangle(im, (x, y), (x + w, y + h), (225, 0, 0), 2) Id, conf = recognizer.predict(gray[y:y + h, x:x + w]) if sys.platform == 'win32': if (conf <= 70): name = ls.get(Id) print(name, Id, conf) else: name = "who?" else: if (conf >= 50): name = ls.get(Id) print(name, Id, conf) else: name = "who?" cv2.putText(im, str(name), (x, y + h), font, 1, (255, 255, 255)) cv2.imshow('im', im) if cv2.waitKey(10) == ord('q'): break cap.stop() cv2.destroyAllWindows() Gui.Gui()
def __init__(self, cam_id): self.id = cam_id self.stream = WebcamVideoStream(self.id).start() self.size = get_image_size(self) self.cam_mat = None self.dist_coeff = None # targets # names for targets - short for index, middle, thumb(fingers) targ_names = cf['targets'] self.targets = create_tracking_targets(targ_names, cam_id) self._cal_count = None self._cal_funcs = [self._get_cal_frame, self._select_target] self._cal_image = None self._circle_draw = None
def web_camera(src): stream = WebcamVideoStream(src=src).start() while True: # grab next frame frame = stream.read() key = cv2.waitKey(1) & 0xFF # keybindings for display if key == ord('p'): # pause while True: key2 = cv2.waitKey(1) or 0xff cv2.imshow('frame', frame) if key2 == ord('p'): # resume break cv2.imshow('frame', frame) if key == 27: # exit break
def main(): for i in list(range(4))[::-1]: print(i + 1) time.sleep(1) paused = False while (True): if not paused: # 800x600 windowed mode #screen = grab_screen(region=(0,40,800,640)) last_time = time.time() vs = WebcamVideoStream(src=0).start() fps = FPS().start() # loop over some frames...this time using the threaded stream while fps._numFrames < args["num_frames"]: # grab the frame from the threaded video stream and resize it # to have a maximum width of 400 pixels frame = vs.read() screen = imutils.resize(frame, width=400) screen = cv2.cvtColor(screen, cv2.COLOR_BGR2GRAY) final = cv2.resize(screen, (80, 60)) #cv2.imshow("Frame", screen) #cv2.imshow("Frame2", final) # resize to something a bit more acceptable for a CNN keys = key_check() output = keys_to_output(keys) training_data.append([screen, output]) if len(training_data) % 5000 == 0: print(len(training_data)) np.save(file_name, training_data) keys = key_check() if 'T' in keys: if paused: paused = False print('unpaused!') time.sleep(1) else: print('Pausing!') paused = True time.sleep(1)
def recognize_Face(self): ''' Recognition of the new input image Input is from web camera ''' #frame = cv2.imread('bhog.jpg') #frame = cv2.resize(frame,(640,480)) cam = WebcamVideoStream(src=1).start() prevTime = 0 while True: curTime = time.time() frame = cam.read() rects, landmarks = self.face_detect.detect_face(frame,20) aligns = [] positions = [] if len(rects) > 0 : for (i, rect) in enumerate(rects): aligned_face, face_pos = self.aligner.align(160,frame,landmarks[i]) aligns.append(aligned_face) positions.append(face_pos) features_arr = self.extract_feature.get_features(aligns) recog_data = findPeople(features_arr,positions) for (i,rect) in enumerate(rects): cv2.rectangle(frame,(rect[0],rect[1]),(rect[0] + rect[2],rect[1]+rect[3]),(255,0,0),3) #draw bounding box for the face cv2.putText(frame,recog_data[i][0]+ "-" +str(recog_data[i][1])+"%",(rect[0],rect[1]),cv2.FONT_HERSHEY_SIMPLEX,1,(0,0,255)) communicate(recog_data[i][0],dictionary_list) sec = curTime - prevTime prevTime = curTime fps = 1 / (sec) string = 'FPS: %2.3f' % fps text_fps_x = len(frame[0]) - 150 text_fps_y = 20 #frame = cv2.resize(frame,(640,480)) cv2.putText(frame, string,(text_fps_x, text_fps_y),cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), thickness=1, lineType=2) #cv2.imwrite('group.jpg',frame) cv2.imshow("Frame",frame) key = cv2.waitKey(1) & 0xFF if key == ord("q"): break #cv2.destroyAllWindows() #database.close_connection() cv2.destroyAllWindows() cam.stop() data_file.close()
def webcamAgeAndGenderDetection(): face_net, age_net, gender_net = load_caffe_models() video_capture = WebcamVideoStream(src=0).start() # image = loadImage(img_path) while True: padding = 20 frame = video_capture.read() resultImg, faceBoxes = highlightFace(face_net, frame) for faceBox in faceBoxes: face = frame[max(0, faceBox[1] - padding):min(faceBox[3] + padding, frame.shape[0] - 1), max(0, faceBox[0] - padding):min(faceBox[2] + padding, frame.shape[1] - 1)] blob = cv2.dnn.blobFromImage(face, 1.0, (227, 227), MODEL_MEAN_VALUES, swapRB=False) #Predict Gender gender_net.setInput(blob) gender_preds = gender_net.forward() gender = gender_list[gender_preds[0].argmax()] #Predict Age age_net.setInput(blob) age_preds = age_net.forward() age = age_list[age_preds[0].argmax()] overlay_text = "%s %s" % (gender, age) cv2.putText(resultImg, overlay_text, (faceBox[0], faceBox[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, .7, (0, 255, 255), 2, cv2.LINE_AA) cv2.imshow("Video", resultImg) # Quits when 'Q' or 'q' or 'esc' is pressed ch = cv2.waitKey(1) if ch == 27 or ch == ord('q') or ch == ord('Q'): break video_capture.stop() cv2.destroyAllWindows()
def main(): print("startup") vs = WebcamVideoStream(src=0).start() fps = FPS().start() while fps._numFrames < 100: print(fps._numFrames) frame = vs.read() frame = imutils.resize(frame, width=400) cv2.imshow("Frame", frame) fps.update() fps.stop() cv2.destroyAllWindows() vs.stop()
def __init__(self): # These variables define the average width and height of human face (in cm) self.face_width = 13.9 self.face_height = 22.5 # Get ROS parameters self._published_topic = rospy.get_param('published_topic', '/face_distance') self._video_device = rospy.get_param('video_device', '/dev/front_camera') self._graph_name = rospy.get_param('graph_name', '/frozen_inference_graph_face.pb') self._label_name = rospy.get_param('label_name', '/face_label_map.pbtxt') self._num_classes = rospy.get_param('num_classes', 2) self._min_score = rospy.get_param('min_score', 0.5) self._display_image = rospy.get_param('display_image', True) self._camera_info_path = rospy.get_param('camera_info_path', '/home/yago/catkin_ws/src/eyecu/eyecu/config/logitech_webcam_calibration.yaml') # Tensorflow initialization self._path_to_ckpt = sys.path[0] + '/exported_graphs' + self._graph_name self._path_to_labels = sys.path[0] + '/labels' + self._label_name self._detection_graph = tf.Graph() self.load_graph() self._session = tf.Session(graph=self._detection_graph) self._label_map = label_map_util.load_labelmap(self._path_to_labels) self._categories = label_map_util.convert_label_map_to_categories(self._label_map, max_num_classes=self._num_classes, use_display_name=True) self._category_index = label_map_util.create_category_index(self._categories) # OpenCV video capture self._cap = WebcamVideoStream(src=self._video_device).start() # Load values for calibration self.load_camera_info() # Publisher variable self.face_distance = DistanceCamera() # Subscribers and publishers self._pub = rospy.Publisher(self._published_topic, DistanceCamera, queue_size=1)
def starter(self): self.clientVideoSocket.connect((self.HOST, self.PORT_VIDEO)) try: MediaChat.wvs = WebcamVideoStream(0) self.wvs.start() except: print("Camera cannot start...") self.clientAudioSocket.connect((self.HOST, self.PORT_AUDIO)) self.audio = pyaudio.PyAudio() self.stream = self.audio.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, output=True, frames_per_buffer=CHUNK) SendFrameThread = Thread(target=self.SendFrame).start() SendAudioThread = Thread(target=self.SendAudio).start() RecieveFrameThread = Thread(target=self.RecieveFrame).start() RecieveAudioThread = Thread(target=self.RecieveAudio).start()
def capture_with_threading_without_workload(camera): vs = WebcamVideoStream(camera).start() while True: # grab the frame from the threaded video stream and resize it # to have a maximum width of 400 pixels start = time.time() frame = vs.read() read_cost = (time.time() - start) * 1000 print("read: {:.2f}ms".format(read_cost)) cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord('q'): break # do a bit of cleanup cv2.destroyAllWindows() vs.stop()
def __init__(self, src=0, usePiCamera=False, resolution=(320, 240), framerate=32): # check to see if the picamera module should be used if usePiCamera: # only import the picamera packages unless we are # explicity told to do so -- this helps remove the # requirement of `picamera[array]` from desktops or # laptops that still want to use the `imutils` package from pivideostream import PiVideoStream # initialize the picamera stream and allow the camera # sensor to warmup self.stream = PiVideoStream(resolution=resolution, framerate=framerate) # otherwise, we are using OpenCV so initialize the webcam # stream else: self.stream = WebcamVideoStream(src=src)
def main(): client = get_mqtt_client() client.connect(MQTT_BROKER, port=MQTT_PORT) time.sleep(4) # Wait for connection setup to complete client.loop_start() # Open camera camera = WebcamVideoStream(src=VIDEO_SOURCE).start() time.sleep(2) # Webcam light should come on if using one while True: frame = camera.read() np_array_RGB = opencv2matplotlib(frame) # Convert to RGB image = Image.fromarray(np_array_RGB) # PIL image byte_array = pil_image_to_byte_array(image) client.publish(MQTT_TOPIC_CAMERA, byte_array, qos=MQTT_QOS) now = get_now_string() print(f"published frame on topic: {MQTT_TOPIC_CAMERA} at {now}") time.sleep(1 / FPS)
def start_video(): # deeplab_model = Deeplabv3(backbone='xception', OS=8) deeplab_model = Deeplabv3(OS=8) vid = WebcamVideoStream(src=0).start() cv2.namedWindow("result", cv2.WINDOW_NORMAL) blurValue = (3, 3) blur_bg_value = 81 while True: frame = vid.read() if frame is None: break w, h, _ = frame.shape ratio = 512. / np.max([w, h]) resized = cv2.resize(frame, (int(ratio * h), int(ratio * w))) resized = resized / 127.5 - 1. pad_x = int(512 - resized.shape[0]) resized2 = np.pad(resized, ((0, pad_x), (0, 0), (0, 0)), mode='constant') res = deeplab_model.predict(np.expand_dims(resized2, 0)) labels = np.argmax(res.squeeze(), -1) labels = labels[:-pad_x] mask = labels == 0 mask_person = labels != 0 resizedFrame = cv2.resize(frame, (labels.shape[1], labels.shape[0])) blur = cv2.GaussianBlur(resizedFrame, (blur_bg_value,blur_bg_value), 0) blur_person = cv2.GaussianBlur(resizedFrame, blurValue, 0) resizedFrame[mask] = blur[mask] resizedFrame[mask_person] = blur_person[mask_person] cv2.imshow("result", resizedFrame) if cv2.waitKey(1) & 0xFF == ord('q'): break vid.stop() cv2.destroyAllWindows()
def get_frame(): vs = WebcamVideoStream(src=src).start() with model.as_default(): with tf.Session(graph=model) as sess: while True: # grab the frame from the threaded video stream and process it src_frame = vs.read() # Process image out_frame = cp.process_frame(src_frame, model, sess, category_index, display=True) imgencode = cv2.imencode('.jpg', out_frame)[1] stringData = imgencode.tostring() yield (b'--frame\r\n' b'Content-Type: text/plain\r\n\r\n' + stringData + b'\r\n') vs.stop()
def main(pipe_object): cam = WebcamVideoStream(src=0).start() global pipe pipe = pipe_object background_set = False bg_model = None # Drawing variables thickness = 4 drawing = False start = time.time() count = -1 check = True # Main loop while check: drawing, bg_model, background_set, check, count, restart_time, thickness = loop( height, cam, bg_model, background_set, rect, thickness, drawing, start, count) if restart_time: start = time.time()
def __init__(self, id): # self.cap = cv2.VideoCapture(id) self.cap = WebcamVideoStream(src = id).start() self.cfgfile = "cfg/yolov4-tiny.cfg" self.weightsfile = "yolov4-tiny.weights" self.confidence = float(0.6) self.nms_thesh = float(0.8) self.num_classes = 1 self.classes = load_classes('data/butts.names') self.colors = pkl.load(open("pallete", "rb")) self.model = Darknet(self.cfgfile) self.CUDA = torch.cuda.is_available() self.model.load_weights(self.weightsfile) self.width = 1280 #640#1280 self.height = 720 #360#720 print("Loading network.....") if self.CUDA: self.model.cuda() print("Network successfully loaded") self.model.eval()
def obj_center(objX, objY, centerX, centerY): signal.signal(signal.SIGINT, signal_handler) vs = WebcamVideoStream(args.camera).start() # time.sleep(2.0) obj = ObjCenter() while True: frame = vs.read() frame = imutils.resize(frame, width=300) (H, W, _) = frame.shape centerX.value = W // 2 centerY.value = H // 2 objectLoc = obj.update(frame, (centerX.value, centerY.value)) (objX.value, objY.value) = objectLoc cv.imshow("frame", frame) print(objectLoc) cv.waitKey(1) vs.stop()
def main(): global vs, videoDeviceNumber # created a threaded video stream print("starting webcam thread...") vs = WebcamVideoStream(src=videoDeviceNumber).start() # allow the camera sensor to warm up before grabbing frames time.sleep(1) try: server = ThreadedHTTPServer(('', 8080), httpHandler) print 'started httpserver...' server.serve_forever() except KeyboardInterrupt: print '^C received, shutting down server' server.shutdown() server.server_close() try: os.sys.exit(0) except SystemExit: os._exit(0)
def detect_process(): # start video stream thread, allow buffer to fill print("[INFO] starting threaded video stream...") # use camera stream = WebcamVideoStream(src=0).start() # default camera time.sleep(1.0) # read video video = FileVideoStream("test_data/test3.mp4").start() # start fps timer # loop over frames from the video file stream frame_count = 0 detect_model = detect.Detect() while True: # grab next frame # frame = stream.read() frame = video.read() key = cv2.waitKey(1) & 0xFF if frame_count % 10 != 0: frame_count += 1 continue frame_count += 1 frame = detect_model.predict(frame) # keybindings for display if key == ord('p'): # pause while True: key2 = cv2.waitKey(1) or 0xff cv2.imshow('frame', frame) if key2 == ord('p'): # resume break cv2.imshow('frame', frame) if key == 27: # exit break
def __init__(self, src=0, flip=True, crop=False, live=True, calibrate=False, resize=False, multi=False): """ Constructor for camera object. :param src: The source for the camera. 0 for live and video name for saved video. :param flip: True if image needs to be flipped. :param crop: True if image needs to be cropped. :param live: True if live camera is on. :param calibrate: Feature to calibrate the tablet. True if we want to use the feature. """ self.src = src self.FLIP = flip self.CROP = crop self.LIVE = live self.CALIBRATE = calibrate self.RESIZE = resize self.MULTI = multi # Opens a stream for the camera. if self.LIVE: self.stream = WebcamVideoStream(src=src, name="Live Video").start() else: self.stream = SavedVideoWrapper.SavedVideoWrapper(src) # Crop dimensions for automatic calibration. self.bl_crop_dimensions, self.tr_crop_dimensions = calibrate_from_file( ) # Current frame taken. self.current = None # Buffer which saves the original frames to display for debug purposes. self.buffer = [] self.last_big_frame = [] # Maximal size for buffer to avoid using too much memory. self.MAX_SIZE_BUFFER = 500 fourcc = cv2.VideoWriter_fourcc(*'XVID') self.out = cv2.VideoWriter('detection.avi', fourcc, 30.0, (480, 160))
def theThreaded(): print ("[INFO] sampling frames from webcam...") vs = WebcamVideoStream(src=0).start() fps = FPS().start() while fps._numFrames < args["num_frames"]: frame = vs.read() frame = imutils.resize(frame, width=400) if args["display"] > 0: cv2.imshow("Frame", frame) key = cv2.waitkey(1) & 0xFF fps.update() fps.stop() print("[INFO] elapsed Time: {:.2f}".format(fps.elapsed())) print ("[INFO] approx. fps: {:.2f}".format(fps.fps())) cv2.destroyAllWindows() vs.stop()
def detect_faces(): print("[INFO] starting video stream...") vs = WebcamVideoStream( src="rtsp://*****:*****@192.168.1.90/axis-media/media.amp") if vs.grabbed: vs = vs.start() time.sleep(2.0) print("------started survillancing------") id = 0 x = 1 while (True): x += 1 frame = vs.read() id += 1 if x % 2 == 0: gray = face_detector(frame, id) cv2.imshow('frame', gray) if cv2.waitKey(10) & 0xFF == ord('q'): break vs.stop() cv2.destroyAllWindows()
def __init__(self): self.cap = WebcamVideoStream(src=0).start() self.root = tk.Tk() w, h = self.root.winfo_screenwidth(), self.root.winfo_screenheight() self.root.overrideredirect(0) self.root.geometry("%dx%d+0+0" % (w, h)) self.root.wm_title('Face Recognizer') #Top and Bottom Frame tFrame = tk.Frame(self.root, width=360, height=240) tFrame.grid(row=0, column=0, padx=10, pady=50) bFrame = tk.Frame(self.root, width=360, height=240) bFrame.grid(row=1, column=0, padx=10, pady=2) #Video Frame self.lmain = tk.Label(tFrame) self.lmain.grid(row=0, column=0) self.details = Label(tFrame, text='Details: ') self.details.grid(row=0, column=1) self.det = Label(tFrame) self.det.grid( row=0, column=2, ) self.vc = Label(bFrame, text='Say Something') self.vc.grid( row=1, column=0, ) #Buttons trainButton = Button(bFrame, text='Train System', command=self.ftrain) trainButton.grid(row=0, column=0) quitButton = Button(bFrame, text='Quit', command=self.Quit) quitButton.grid(row=0, column=1) self.video_Loop()
def __init__(self): camera = 'rtsp://*****:*****@10.0.17.13:80/live' ####################################################################### # Camera Options # # My phone IP Cam - 'http://10.10.10.149:8080/video' # # Webcam - 0 # # 'rtsp://*****:*****@10.0.17.13:80/live' # # 'http://*****:*****@10.0.17.13:80/axis-cgi/mjpg/video.cgi' # # 'http://*****:*****@10.0.17.13:80/axis-cgi/mjpg/video.cgi?camera=1' # ####################################################################### # Using OpenCV to capture from device 0. If you have trouble capturing # from a webcam, comment the line below out and use a video file # instead. # If you decide to use video.mp4, you must have this file in the folder # as the main.py. # Initialize camera threading and start getting image object to self.vs variable self.vs = WebcamVideoStream(src=camera).start() # Getting image width and height self.W = self.vs.getW() self.H = self.vs.getH() # Initialize detection program and specify height and width self.detect = ConDetect(self.H, self.W)
def __init__(self, logger, src, ROOT_DIR): self.vs = WebcamVideoStream(src) self.fps = FPS() self.logger = logger self.ROOT_DIR = ROOT_DIR cv2.namedWindow("Webcam") cv2.namedWindow("roi") cv2.namedWindow("stacked") cv2.createTrackbar('dilate kernel', 'roi', 3, 5, self.none) cv2.createTrackbar('erode kernel', 'roi', 2, 5, self.none) cv2.createTrackbar('blackhat kernel', 'roi', 21, 30, self.none) self.mouse = Mouse(window="Webcam") self.gt = Graphics() # self.hist = Hist() self.msg = "draw a rectangle to continue ..." self.font_20 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Light.ttf', 20) self.font_10 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Light.ttf', 15) self.font_30 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Light.ttf', 30) self.font_40 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Medium.ttf', 50) # self.stabilizer = VidStab() self.predictor = parser_v3.Predictor(model_path=f'{self.ROOT_DIR}/models/model_0.1v7.h5', root_dir=self.ROOT_DIR)
def faceBlurWebcam(conf_threshold, blocks): video_capture = WebcamVideoStream(src=0).start() net = loadCaffeModels() while True: orig = video_capture.read() (h, w) = orig.shape[:2] # construct a blob from the image blob = cv2.dnn.blobFromImage(orig, 1.0, (300, 300), (104.0, 177.0, 123.0)) net.setInput(blob) detections = net.forward() # loop over the detections for i in range(0, detections.shape[2]): confidence = detections[0, 0, i, 2] if confidence > conf_threshold: startX = int(detections[0, 0, i, 3] * w) startY = int(detections[0, 0, i, 4] * h) endX = int(detections[0, 0, i, 5] * w) endY = int(detections[0, 0, i, 6] * h) face = orig[startY:endY, startX:endX] face = anonymize_face_pixelate(face, blocks=blocks) # store the blurred face in the output image orig[startY:endY, startX:endX] = face cv2.imshow("Video", orig) # Quits when 'Q' or 'q' or 'esc' is pressed ch = cv2.waitKey(1) if ch == 27 or ch == ord('q') or ch == ord('Q'): break video_capture.stop() cv2.destroyAllWindows()
def capture_with_threading(camera, display=True): vs = WebcamVideoStream(camera).start() if display: threading.Thread(target=display_video, args=(camera, vs)).start() frame_count = 0 while True: # grab the frame from the threaded video stream and resize it # to have a maximum width of 400 pixels start = time.time() frame = vs.read() read_cost = (time.time() - start) * 1000 frame_count += 1 if frame_count >= 100 and frame_count < 200: save_image(IMAGE_PATH, 'cv2', frame) start = time.time() for i in range(100): imutils.resize(frame, width=400) handle_cost = (time.time() - start) * 1000 print("read: {:.2f}ms, handle: {:.2f}ms".format( read_cost, handle_cost)) # do a bit of cleanup vs.stop()