class VideoCamera(object): def __init__(self): self.video = WebcamVideoStream(src=0).start() def __del__(self): self.video.stop() def get_frame(self): #vs = WebcamVideoStream(src=0).start() fps = FPS().start() while fps._numFrames < numFrames: frame = detector(self.video) frame = imutils.resize(frame, width=400) image = self.video.read() image = cv2.resize(frame, None, fx=ds_factor, fy=ds_factor, interpolation=cv2.INTER_AREA) # grab the frame from the stream and resize it to have a maximum # width of 400 pixels # check to see if the frame should be displayed to our screen fps.update() ret, jpeg = cv2.imencode('.jpg', image) return jpeg.tobytes()
def threaded_test(): print("[TEST2] sampling THREADED frames from webcam...") vs0 = WebcamVideoStream(src=1).start() vs1 = WebcamVideoStream(src=2).start() fps = FPS().start() prev_frame = vs1.read() # loop over some frames...this time using the threaded stream while fps._numFrames < args["num_frames_thr"]: # grab the frame from the threaded video stream and resize it # to have a maximum width of 400 pixels frame0 = vs0.read() frame1 = vs1.read() diff = frame1 - prev_frame prev_frame = frame1 time.sleep(0.04) # check to see if the frame should be displayed to our screen if args["display"] > 0: cv2.imshow("Frame1", frame1) cv2.imshow("Frame0", frame0) key = cv2.waitKey(1) & 0xFF # update the FPS counter if notBlack(diff): fps.update() # stop the timer and display FPS information fps.stop() print("[TEST2] elasped time: {:.2f}".format(fps.elapsed())) print("[TEST2] approx. FPS: {:.2f}".format(fps.fps())) # do a bit of cleanup cv2.destroyAllWindows() vs0.stop() vs1.stop() return int(fps.fps()) >> 4 << 4
def predict(): face_classifier = cv2.CascadeClassifier( "C:/Users/uvss/AppData/Local/Programs/Python/Python37-32/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml" ) face_recognizer = cv2.face.LBPHFaceRecognizer_create() face_recognizer.read("trainer/training_data.yml") vs = WebcamVideoStream( "rtsp://*****:*****@192.168.1.90/axis-media/media.amp") vs = vs.start() if vs.grabbed: while True: image = vs.read() img = image.copy() gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_classifier.detectMultiScale(gray, 1.2, 5) if faces is (): pass for (x, y, w, h) in faces: cv2.rectangle(img, (x, y), (x + w, y + h), (102, 255, 102), 2) roi_gray = gray[y:y + h, x:x + w] label, conf = face_recognizer.predict(roi_gray) print(label, int(conf)) if conf > 85: label = "Unknown" cv2.putText(img, str(label), (x + 5, y + h - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2) cv2.imshow("frames", img) if cv2.waitKey(1) == ord("q"): break vs.stop() cv2.destroyAllWindows()
def training_Data(path): while True: try: details = { "name": input("Provide a name for the Employee:- "), "depart": input("Department:- "), "ID": int(input("Office Id (number) :- ")) } if bool(re.search(r'\d', details["name"])) or bool( re.search(r'\d', details["depart"])): raise ValueError( "[Error] Invalid Input for Name or Department") break except Exception as err: print("[Error] Invalid Input for Office Id") continue sampled_faces = [] sampled_labels = [] img_name = None usr_id, label = 1, 1 img_id = 0 users = os.listdir(path) users.sort( key=lambda x: int(x[1:])) # sorting all the user data directories if users == []: usr_dir = path + "/s" + str(usr_id) + "/" os.mkdir(usr_dir) else: label = int(users[-1][1:]) + 1 usr_id = str(label) # get [1:] part of last element in the list usr_dir = path + "/s" + usr_id + "/" os.mkdir(usr_dir) vs = WebcamVideoStream( src="rtsp://*****:*****@192.168.1.90/axis-media/media.amp") if vs.grabbed: vs = vs.start() while (True): frame = vs.read() cv2.imshow("frame", frame) faces = face_Detector(frame) if cv2.waitKey(1) == ord("q"): # sys.exit() break if faces is None or faces == []: continue for face in faces: img_id += 1 cv2.imshow("face", face) img_name = usr_dir + str(img_id) + ".jpg", face cv2.imwrite(img_name, face) sampled_labels.append(label) sampled_faces.append(face) if img_id >= 50: break vs.stop() cv2.destroyAllWindows() return (sampled_faces, sampled_labels, details)
def detection(): print('here') # cap = cv2.VideoCapture(0) # To capture stream using OpenCV vs = WebcamVideoStream().start() # To capture strem using imutils. start = tm.time() end = tm.time() pin = [] while (end-start<5): # We provide a time period of 5 seconds for each pin. image = vs.read() # Reading current frame from imutils. # check , image = cap.read() # For reading image using OpenCV img = cv2.cvtColor(image , cv2.COLOR_BGR2RGB) resized = cv2.resize(img,(224,224),cv2.INTER_AREA) # Resizing frame for expected input shape scaled = resized/255.0 expand_img = np.expand_dims(scaled , axis=0) img_np = np.array(expand_img,dtype='float32') # Prediction using tflite model. tflite_inter.set_tensor(input_details[0]['index'] , img_np) tflite_inter.invoke() tflite_pred = tflite_inter.get_tensor(output_details[0]['index']) pred=np.argmax(tflite_pred) # For prediction using direct .h5 model # pred = np.argmax(classifier.predict(expand_img)) pin.append(pred) end = tm.time() vs.stop() # The stream needs to be released after every function call. Or it will keep the camera Open. vs.stream.release() # To release capture stream from memory. # cv2.destroyAllWindows() # cap.release() return (mode(pin))
def handle_view_objects_intent(self, message): self.speak('Showing you what objects I see now') logger = multiprocessing.log_to_stderr() logger.setLevel(multiprocessing.SUBDEBUG) input_q = Queue(maxsize=5) output_q = Queue(maxsize=5) process = Process(target=worker, args=((input_q, output_q))) process.daemon = True pool = Pool(2, worker, (input_q, output_q)) video_capture = WebcamVideoStream(src=0).start() fps = FPS().start() while True: # fps._numFrames < 120 frame = video_capture.read() input_q.put(frame) t = time.time() cv2.imshow('Video', output_q.get()) fps.update() print('[INFO] elapsed time: {:.2f}'.format(time.time() - t)) if cv2.waitKey(1) & 0xFF == ord('q'): break fps.stop() print('[INFO] elapsed time (total): {:.2f}'.format(fps.elapsed())) print('[INFO] approx. FPS: {:.2f}'.format(fps.fps())) video_capture.stop() cv2.destroyAllWindows()
def pcv(**kwargs): geckopy.init_node(**kwargs) rate = geckopy.Rate(10) p = geckopy.Publisher() camera = WebcamVideoStream(src=0).start() while not geckopy.is_shutdown(): img = camera.read() if img is not None: # geckopy.log(img.shape) # img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) img = cv2.resize(img, (640,480)) msg = find_ball(img) # msg = Image(img.shape, img.tobytes(), img.dtype) if msg: # p.pub('images_color', msg) # topic msg p.pub('target', msg) geckopy.log(msg) # p.pub(topic, {'a': 5}) # geckopy.log(img.shape) else: geckopy.log("*** couldn't read image ***") # sleep rate.sleep() camera.stop() print('cv bye ...')
def mix_record(): #cams_test.raw_test() #cams_test.threaded_test() print("[INFO] saving image...") # created a *threaded *video stream, allow the camera senor to warmup, # and start the FPS counter vs0 = cv2.VideoCapture(1) vs1 = WebcamVideoStream(src=2).start() # loop over some frames...this time using the threaded stream count = 0 while True: count += 1 ret, frame0 = vs0.read() frame1 = vs1.read() if args['output'] < 0: cv2.imwrite("./mixRecord/" + str(count) + "_r.png", frame0) cv2.imwrite("./mixRecord/" + str(count) + "_t.png", frame1) if args['display'] > 0: cv2.imshow("Frame0", frame0) cv2.imshow("Frame1", frame1) key = cv2.waitKey(1) & 0xFF if key == 27: break vs0.release() vs1.stop() cv2.destroyAllWindows()
class VideoCamera(object): def __init__(self): self.stream = WebcamVideoStream(src=0).start() def __del__(self): self.stream.stop() def get_frame(self): image = self.stream.read() detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect the faces faces = detector.detectMultiScale(gray, 1.1, 4) # Draw the rectangle around each face for (x, y, w, h) in faces: cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2) # Release the VideoCapture object ret,jpeg = cv2.imencode('.jpg',image) data =[] data.append(jpeg.tobytes()) return data
def threaded_check(): #cams_test.raw_test() #cams_test.threaded_test() print("[INFO] saving image...") # created a *threaded *video stream, allow the camera senor to warmup, # and start the FPS counter vs1 = WebcamVideoStream(src=1).start() # loop over some frames...this time using the threaded stream count = 0 prev_frame = vs1.read() fps = FPS().start() while count < 1000: count += 1 frame1 = vs1.read() # gray = cv2.cvtColor((frame1-prev_frame), cv2.COLOR_BGR2GRAY) # ret, diff = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY) diff = frame1 - prev_frame # if args['output'] < 0: # cv2.imwrite("./fRecord/"+str(count)+".png",frame1) # cv2.imwrite("./tRecord/"+str(count)+"_d.png",frame1-prev_frame) prev_frame = frame1 if args['display'] > 0: cv2.imshow("Frame1", frame1) # cv2.imshow("Diff", diff) key = cv2.waitKey(1) & 0xFF if key == 27: break if notBlack(diff): fps.update() fps.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) vs1.stop() cv2.destroyAllWindows()
class VideoCamera(object): def __init__(self): self.stream = WebcamVideoStream(src=0).start() def __del__(self): self.stream.stop() def get_frame(self, found, sound): img2 = self.stream.read() img2 = preprocess(img2) data = [] while (True): #comienza la comparación para detectar el billete for bill in data_bill: img1 = bill[0] kp = bill[1] desc = bill[2] showText = bill[3] sound = bill[4] found = match_draw(img1, img2, found, showText, sound, kp, desc) if found: ret, jpeg = cv2.imencode('.jpg', img2) data.append(jpeg.tobytes()) return data
def threadind(): key = '' vs = WebcamVideoStream(src=0).start() fps = FPS().start() # loop over some frames...this time using the threaded stream while key != ord('q'): # grab the frame from the threaded video stream and resize it # to have a maximum width of 400 pixels frame = vs.read() # frame = imutils.resize(frame, width=400) # check to see if the frame should be displayed to our screen cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # update the FPS counter fps.update() # stop the timer and display FPS information fps.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) # do a bit of cleanup cv2.destroyAllWindows() vs.stop()
def main(): # Video capture constructor multithreaded stream = WebcamVideoStream(VIDEO_SOURCE).start() print("Tracking...") recording = False tracking = True frame_id = 0 while (tracking): # Capture frame frame = stream.read() frame = cv2.flip(frame, 1) if recording: if frame_id % 30 == 0: # Save image filename = os.path.join(DATA_DIR, str(frame_id) + '.jpg') cv2.imwrite(filename, frame) frame_id += 1 cv2.imshow('frame', frame) # Waits for pressed key to stop execution key = cv2.waitKey(1) & 0xFF if key == ord('q'): tracking = False cv2.destroyAllWindows() stream.stop() elif key == ord('r'): print("Recording...") recording = True
class VideoCamera(object): def __init__(self): self.stream = WebcamVideoStream(src=0).start() self.folderName = '38' self.n_folderName = self.folderName self.path = r"/home/asus/Desktop/mask_recog/without_mask2/{}".format( self.n_folderName) os.mkdir(self.path) def __del__(self): self.stream.stop() def get_frame(self): self.frame = self.stream.read() self.window_name = 'Image' self.font = cv2.FONT_HERSHEY_SIMPLEX self.org = (0, 50) self.fontScale = 1 self.color = (0, 0, 255) self.thickness = 2 self.detector = dlib.get_frontal_face_detector() self.predictor = dlib.shape_predictor( "shape_predictor_68_face_landmarks.dat") self.gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY) self.faces = self.detector(self.gray) for self.face in self.faces: self.x1 = self.face.left() self.y1 = self.face.top() self.x2 = self.face.right() self.y2 = self.face.bottom() self.p = cv2.rectangle(self.frame, (self.x1, self.y1), (self.x2, self.y2), (255, 0, 0), 3) self.landmarks = self.predictor(self.gray, self.face) for self.n in range(31, 36): self.x = self.landmarks.part(self.n).x self.y = self.landmarks.part(self.n).y self.t = cv2.circle(self.frame, (self.x, self.y), 2, (255, 255, 0), -1) if self.t.any() == True: time.sleep(2) self.photo = time.strftime(r"%Y-%m-%d_%H-%M-%S") self.file = r'/home/asus/Desktop/mask_recog/without_mask2/{}/{}.jpg'.format( self.n_folderName, self.photo) cv2.imwrite(self.file, self.frame) time.sleep(5) continue _, self.jpeg = cv2.imencode('.jpg', self.frame) self.data = [] self.data.append(self.jpeg.tobytes()) return self.data
def main(): global FONT, fx, fy, fh, accent_color model = load_model('models/final.h5') x0, y0, size = 200, 180, 300 cam = WebcamVideoStream(src=0).start() cv2.namedWindow('Capture', cv2.WINDOW_NORMAL) while True: frame = cam.read() frame = cv2.flip(frame, 1) window = copy.deepcopy(frame) cv2.rectangle(window, (x0, y0), (x0 + size, y0 + size), accent_color, 12) # get region of interest roi = frame[y0:y0 + size, x0:x0 + size] roi = binary_mask(roi) # apply processed roi in frame window[y0:y0 + size, x0:x0 + size] = cv2.cvtColor(roi, cv2.COLOR_GRAY2BGR) img = cv2.resize(roi, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_CUBIC) img = np.float32(img) / 255. img = np.expand_dims(img, axis=0) img = np.expand_dims(img, axis=-1) predictions = model.predict(img) if predictions.any() > 0.9: pred = classes[predictions.argmax()] actions[pred](*args[pred]) cv2.putText(window, 'Prediction: %s' % pred, (fx, fy + fh), FONT, 1.0, (245, 210, 65), 2, 1) else: cv2.putText(window, 'No gesture found', (fx, fy + fh), FONT, 1.0, (245, 210, 65), 2, 1) # show the window cv2.imshow('Capture', window) # Keyboard inputs key = cv2.waitKey(120) & 0xff # use q key to close the program if key == ord('q'): break # adjust the position of window elif key == ord('i'): y0 = max((y0 - 5, 0)) elif key == ord('k'): y0 = min((y0 + 5, window.shape[0] - size)) elif key == ord('j'): x0 = max((x0 - 5, 0)) elif key == ord('l'): x0 = min((x0 + 5, window.shape[1] - size)) cv2.destroyAllWindows() cam.stop()
def main(): # paths to models face_xml = "utils/face-detection-adas-0001.xml" face_bin = "utils/face-detection-adas-0001.bin" face_detection_net, n_f, c_f, w_f, h_f, input_blob_f, out_blob_f, plugin_f = init_model(face_xml, face_bin) fvs = WebcamVideoStream(src=0).start() time.sleep(0.5) # Initialize some variables frame_count = 0 cur_request_id_f = 0 next_request_id_f = 1 while True: # Grab a single frame of video frame = fvs.read() initial_h, initial_w = frame.shape[:2] if frame is None: break # Find all the faces and face encodings in the current frame of video face_locations = [] in_frame = cv2.resize(frame, (w_f, h_f)) in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW in_frame = in_frame.reshape((n_f, c_f, h_f, w_f)) face_detection_net.start_async(request_id=cur_request_id_f, inputs={input_blob_f: in_frame}) if face_detection_net.requests[cur_request_id_f].wait(-1) == 0: face_detection_res = face_detection_net.requests[cur_request_id_f].outputs[out_blob_f] for face_loc in face_detection_res[0][0]: if face_loc[2] > 0.5: xmin = abs(int(face_loc[3] * initial_w)) ymin = abs(int(face_loc[4] * initial_h)) xmax = abs(int(face_loc[5] * initial_w)) ymax = abs(int(face_loc[6] * initial_h)) face_locations.append((xmin, ymin, xmax, ymax)) for (left, top, right, bottom) in face_locations: crop_img = frame[top:bottom, left:right] label = mask_detection(crop_img) frame = cv2.rectangle(frame, (left, top), (right, bottom), (65, 65, 65), 2) cv2.putText(frame, label, (left, top + 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (36, 255, 12), 2) cv2.imshow('Video', frame) frame_count += 1 cur_request_id_f, next_request_id_f = next_request_id_f, cur_request_id_f if cv2.waitKey(1) & 0xFF == ord('q'): break # Release handle to the webcam fvs.stop() cv2.destroyAllWindows() del exec_net del plugin
def run(): print("run hsvpicker") cap = WebcamVideoStream(src=0).start() time.sleep(1) # startup sample = cap.read() height = sample.shape[0] # get height width = sample.shape[1] # get width print("w: " + str(width) + " " + "h: " + str(height)) createtrackbars("1") while True: img = cap.read() img = cv2.GaussianBlur(img, (9, 9), 0) lowh = cv2.getTrackbarPos('Low H', '1') lows = cv2.getTrackbarPos('Low S', '1') lowv = cv2.getTrackbarPos('Low V', '1') highh = cv2.getTrackbarPos('High H', '1') highs = cv2.getTrackbarPos('High S', '1') highv = cv2.getTrackbarPos('High V', '1') # Hsv Mask hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) lower = np.array([lowh, lows, lowv]) higher = np.array([highh, highs, highv]) mask = cv2.inRange(hsv, lower, higher) mask += calculate_mask("1", mask, img) output = cv2.bitwise_and(img, img, mask=mask) ret, thresh = cv2.threshold(mask, 127, 255, 0) im2, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: area = cv2.contourArea(cnt) if area > 100: cv2.drawContours(output, [cnt], -1, (255, 255, 255), 5) cv2.imshow('hsv-picker', output) if cv2.waitKey(1) & 0xFF == ord('s'): print("([" + str(lowh) + ", " + str(lows) + ", " + str(lowv) + "], [" + str(highh) + ", " + str(highs) + ", " + str(highv) + "])") if cv2.waitKey(1) & 0xFF == ord('q'): break cap.stop() cv2.destroyAllWindows()
class Scanner(): def __init__(self, src=1): self.camera = WebcamVideoStream(src=src).start() self.code = '' def __decode(self, im): # Find barcodes and QR codes decodedObjects = pyzbar.decode(im) # Print results for obj in decodedObjects: self.code = obj.data return decodedObjects # Display barcode and QR code location def display(self, im, decodedObjects): # Loop over all decoded objects for decodedObject in decodedObjects: points = decodedObject.polygon if len(points) == 4: cv2.rectangle(im, (points[0].x, points[0].y), (points[2].x, points[2].y), (0, 255, 0), 3) return im def decoded(self): if not self.code: return False else: return self.code def cv2_call(self): while (True): frame = self.camera.read() # resize the frame and convert it to grayscale (while still # retaining 3 channels) frame = imutils.resize(frame, width=400) #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #frame = np.dstack([frame, frame, frame]) decodedObjects = self.__decode(frame) self.display(frame, decodedObjects) cv2.imshow("Results", frame) cv2.waitKey(1) cv2.destroyAllWindows() camera.stop() def callback(self): frame = self.camera.read() frame = imutils.resize(frame, width=400) decodedObjects = self.__decode(frame) image = self.display(frame, decodedObjects) return image def exit(self): self.camera.stop()
def video_loop(delay): """ Show a delayed video loop with the specified number of seconds of delay buffer. """ vs = WebcamVideoStream().start() cv2.namedWindow('loop', cv2.WINDOW_NORMAL) cv2.setWindowProperty('loop', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN) fps = int(vs.stream.get(cv2.CAP_PROP_FPS) * 2) # Off by a factor of 2, inexplicably. width = int(vs.stream.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vs.stream.get(cv2.CAP_PROP_FRAME_HEIGHT)) buf_size = int(delay * fps) if buf_size == 0: buf_size = 1 buf = {} i = 0 while True: # Capture. # Despeckle before main processing. buf[i] = vs.read() buf[i] = cv2.medianBlur(buf[i], 3) # Collect the oldest few frames for frame processing. # Start at slow speed until buffer is full and we catch up to it. oldest_i = min(buf.keys()) if i < (2 * buf_size): display_i = int(i**2 / (4 * buf_size)) else: display_i = oldest_i input_frames = [] for offset in range(3): j = display_i + offset if j in buf: input_frames.append(buf[j]) # Display. frame = process_frame(input_frames, i) cv2.imshow('loop', frame) key = cv2.waitKey(1) if key != -1: # break pass # Rotate buffer. buf.pop(i - buf_size, None) i += 1 cv2.destroyAllWindows() vs.stop()
def main(args): def resource_path(relative_path): """Convert relative resource path to the real path""" if hasattr(sys, "_MEIPASS"): return os.path.join(sys._MEIPASS, relative_path) return os.path.join(relative_path) '''caffe DNN model for face detection''' net = cv2.dnn.readNetFromCaffe(resource_path(args["prototxt"]), resource_path(args["face_model"])) '''caffe CascadeClassifier model for face detection''' # net = cv2.CascadeClassifier('models/face/haarcascade_frontalface_alt.xml') ''''tflearn emotion model''' # network = EMR() # network.build_network() '''keras emotion model''' # network = resnext.ResNextImageNet(include_top=True, input_shape=(64, 64, 1), classes=8) # network.load_s("models/model.h5") network = load_model(resource_path("models/resnet50_final.h5")) '''tensorflow emotion model''' # network = predictor_factories.from_saved_model(args["emotion_model_dir"]) print("[INFO] sampling frames from webcam...") vs = WebcamVideoStream(args["webcam"]).start() fps = FPS().start() heart_rate = None while True: time0 = time.time() frame = vs.read() frame = imutils.resize(frame, width=720) try: face_rect = face_detection.detector(net, frame) except Exception as e: print("face_detection failed to {}".format(str(e))) if face_rect is not None: result = emotion_detection.detector1(frame, face_rect, network) cv2.rectangle(frame, (face_rect[0], face_rect[1]), (face_rect[2], face_rect[3]), (0, 255, 0), 2) cv2.putText(frame, "{}".format(EMOTION[np.argmax(result)]), (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 2) # cv2.imwrite("sdfjdf",frame) if args["display"] > 0: cv2.imshow("Frame", frame) key = cv2.waitKey(5) & 0xFF if key == ord("q"): break fps.update() fps.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) cv2.destroyAllWindows() vs.stop()
def run_detection(self): print("Start object detection ...") self.define_classes() vs = WebcamVideoStream(0).start() fps = FPS().start() while True: frame = vs.read() (h, w) = frame.shape[:-1] blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), scalefactor=0.007843, size=(300, 300), mean=127.5) self.net.setInput(blob) detections = self.net.forward() # Loop over detected objects for i in np.arange(0, detections.shape[2]): # Get proba for each object probability = detections[0, 0, i, 2] # Set up threshold for filtering detection if probability > 0.5: # Get prediction index index = int(detections[0, 0, i, 1]) # Get bounding box coordinates box = detections[0, 0, i, 3:7] * np.array([w, h, w, h]) (startX, startY, endX, endY) = box.astype("int") label = "{}: {:.2f}%".format(self.classes[index], probability * 100) y = startY - 10 if startY - 10 > 10 else startY + 10 cv2.rectangle(frame, (startX, startY), (endX, endY), self.colors[index], 2) cv2.putText(frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, self.colors[index], 2) cv2.imshow('frame', frame) fps.update() key = cv2.waitKey(1) & 0xFF if key == ord("q"): cv2.destroyAllWindows() vs.stop() fps.stop() break print("Fps: {:.2f}".format(fps.fps())) fps.update()
def cam(cap_id,e): cap = WebcamVideoStream(cap_id).start() while True: frame = cap.read() if e.is_set(): cv2.circle(frame,(50,50),10,(255,0,255),2) cv2.imshow(str(cap_id), frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.stop() cv2.destroyWindow(str(cap_id)) return
def apriltag_test(): camera = WVS(src=0).start() while 1: frame = camera.read() img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) detections, dimg = det.detect(img, return_image=True) cv2.imshow('Original', frame) cv2.imshow('Detection', dimg) if cv2.waitKey(1) & 0xff == ord('q'): break camera.stop() cv2.destroyAllWindows()
def open_camera(self): UITool.msg_window('Info', 'Start face distant protect mode.') flag = True vs = WebcamVideoStream(src=0) vs.start() time.sleep(2.0) cv2.startWindowThread() while flag: check = True frame = vs.read() frame = imutils.resize(frame, width=800) display_frame = frame.copy() capt_faces = FaceCapture.cap(frame) if capt_faces.has_face: display_frame = ImgTool.add_face_block(display_frame, capt_faces) face_data = FacesProc.get_all_faces_with_encode_low_filter( frame, self.mode) if face_data: check = self.check_face_encode(face_data) print(f"status: {check}") if not check: print( f" WARN - find stranger and no master in the same time !!!" ) self.alert = True else: print('fetched face data is not enough') if self.display: display_frame = cv2.flip(display_frame, 1) if check: text = 'Safe' print(text) display_frame = ImgTool.add_text(display_frame, text) else: text = 'Detect Stranger!' display_frame = ImgTool.add_text(display_frame, text, color='red') cv2.imshow('Frame', display_frame) key = cv2.waitKey(1) if self.alert or key == 27 or key == ord('q'): flag = False cv2.waitKey(500) cv2.destroyAllWindows() cv2.waitKey(500) vs.stop() cv2.destroyAllWindows()
def launch(self): flag = True vs = WebcamVideoStream(src=0) vs.start() time.sleep(2.0) fetch_face = 0 last_face_ts = 0 cv2.startWindowThread() while flag: frame = vs.read() if frame is None: continue frame = imutils.resize(frame, width=800) display_frame = frame.copy() capt_faces = FaceCapture.cap(frame) if capt_faces.face_count == 1: display_frame = ImgTool.add_face_block(display_frame, capt_faces) ts = FileTool.get_curr_ts() if ts - last_face_ts > RecordMD.INTERVAL: if self.__record_face(frame, capt_faces, ts): fetch_face += 1 print( f'fetch face successfully. ({fetch_face}/{self.fetch_count})' ) last_face_ts = ts else: print(f'failed to record faces') if self.display: display_frame = cv2.flip(display_frame, 1) text = f"{fetch_face} / {self.fetch_count}" display_frame = ImgTool.add_text(display_frame, text) cv2.imshow('Frame', display_frame) key = cv2.waitKey(1) if fetch_face == self.fetch_count or key == 27 or key == ord('q'): flag = False cv2.waitKey(500) cv2.destroyAllWindows() cv2.waitKey(500) vs.stop() cv2.destroyAllWindows() # self.__img_meta.to_csv(RecordMD.meta_path, index=False, encoding='utf-8') msg = 'Finish recoding master data.' UITool.msg_window(msg=msg) print('finish saving img meta.')
def main(mode): if mode == 'human': #cascade = cv2.CascadeClassifier('./cascade_xml/haarcascade_frontalface_default.xml') cascade = cv2.CascadeClassifier('./cascade_xml/lbpcascade_frontalface_improved.xml') else: cascade = None cam = WebcamVideoStream(src=-1).start() prevTime = 0 while 1: #ret, img = cam.read() img = cam.read() #img = imutils.resize(img,height=400) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #fps #현재 시간 가져오기 (초단위로 가져옴) curTime = time.time() #현재 시간에서 이전 시간을 빼면? #한번 돌아온 시간!! sec = curTime - prevTime #이전 시간을 현재시간으로 다시 저장시킴 prevTime = curTime # 프레임 계산 한바퀴 돌아온 시간을 1초로 나누면 된다. # 1 / time per frame fps = 1/(sec) # 프레임 수를 문자열에 저장 str = "FPS : %0.1f" % fps # 표시 cv2.putText(img, str, (0, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0)) #Cam START #if ret: detectAndDisply(img,cascade,mode) #ESC Click -> EXIT if cv2.waitKey(1) & 0xFF == 27: m.clean() break #cam.release() cv2.destroyAllWindows() cam.stop()
class VideoCam(object): def __init__(self): self.streaming = WebcamVideoStream(src=0).start() def __del__(self): self.streaming.stop() def get_frame(self): image = self.streaming.read() ret, jpeg = cv2.imencode('.jpg', image) data = [] data.append(jpeg.tobytes()) return data
def calibrate_blur(frames, path, src=0): blur_data = BlurData() camera_stream = WebcamVideoStream(src=src).start() fps = FPS().start() while fps._numFrames < frames: frame = camera_stream.read() blur_data.image = frame blur_data.define_blur_strength() BlurData.serialize_blur_data(blur_data, path) fps.stop() camera_stream.stop() cv2.destroyAllWindows()
def calibrate_hsv(frames, path, src=0): hsv_data = HSVData() camera_stream = WebcamVideoStream(src=src).start() fps = FPS().start() while fps._numFrames < frames: frame = camera_stream.read() hsv_data.image = frame hsv_data.define_hsv_range() HSVData.serialize_hsv_data(hsv_data.lower_bound, hsv_data.upper_bound, path) fps.stop() camera_stream.stop() cv2.destroyAllWindows()
def cam(cap_id, e): args = utilities.parseConnectionArguments() # Create connection to the device and get the router with utilities.DeviceConnection.createTcpConnection(args) as router: cap = WebcamVideoStream(cap_id).start() while True: frame = cap.read() if e.is_set(): break cv2.imshow("robot camera", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.stop() #cv2.destroyWindow(str(cap_id)) return
def main(): points = [] ticks =str(int(time.time() * 1000)) # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", help="path to the (optional) video file") ap.add_argument("-b", "--buffer", type=int, default=64, help="max buffer size") args = vars(ap.parse_args()) # define the lower and upper boundaries of the "green" # ball in the HSV color space, then initialize the # list of tracked points # BLUE ballLower, ballUpper = getBallColor() pts = deque(maxlen=args["buffer"]) # created a *threaded *video stream, allow the camera senor to warmup, # and start the FPS counter debugPrint("[INFO] sampling THREADED frames from webcam...") vs = WebcamVideoStream(src=1).start() frame = vs.read() if frame is None: debugPrint("Changed to default camera!") # Take the default camera (webcam is not connected) vs = WebcamVideoStream(src=0).start() if __ENABLE_VIDEO_OUT__: outStream = cv2.VideoWriter('Output/output' + ticks +'.avi', -1, 20.0, (1000,705)) eventHook = EventHook() # keep looping while True: # grab the current frame frame = vs.read() if frame is None: continue # resize the frame, blur it, and convert it to the HSV # color space frame = imutils.resize(frame, width=1000) frame = frame[40:745,0:1000] # blurred = cv2.GaussianBlur(frame, (11, 11), 0) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # construct a mask for the color "green", then perform # a series of dilations and erosions to remove any small # blobs left in the mask mask = cv2.inRange(hsv, ballLower, ballUpper) mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, None, iterations=2) # find contours in the mask and initialize the current # (x, y) center of the ball cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] center = None # only proceed if at least one contour was found if len(cnts) > 0: # find the largest contour in the mask, then use # it to compute the minimum enclosing circle and # centroid c = max(cnts, key=cv2.contourArea) ((x, y), radius) = cv2.minEnclosingCircle(c) M = cv2.moments(c) center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) # only proceed if the radius meets a minimum size if radius > 5: #Changed from 10 # draw the circle and centroid on the frame, # then update the list of tracked points cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) cv2.circle(frame, center, 5, (0, 0, 255), -1) # update the points queue pts.appendleft(center) debugPrint(center) if center is None: points.append((-1,-1)) else: points.append(center) # loop over the set of tracked points for i in xrange(1, len(pts)): # if either of the tracked points are None, ignore # them if pts[i - 1] is None or pts[i] is None: continue # otherwise, compute the thickness of the line and # draw the connecting lines thickness = int(np.sqrt(args["buffer"] / float(i + 1)) * 2.5) cv2.line(frame, pts[i - 1], pts[i], (0, 0, 255), thickness) # show the frame to our screen cv2.imshow("Frame", frame) if __ENABLE_VIDEO_OUT__: outStream.write(frame) # add replay frame addReplayFrame(frame) key = cv2.waitKey(1) & 0xFF # if the 'q' key is pressed, stop the loop if key == ord("q"): break if center is None: if eventHook.fire([(-1,-1)]): saveGoalVideo() else: normalizePoint = (int(2000*float(center[0]/1000.0)),int(1000*float(center[1]/705.0))) if eventHook.fire([normalizePoint]): saveGoalVideo() debugPrint(normalizePoint) # cleanup the camera and close any open windows cv2.destroyAllWindows() vs.stop() savePtsVector(points,ticks) raise SystemExit if __ENABLE_VIDEO_OUT__: outStream.release()
class EyeCanSee(object): def __init__(self, center=int(cvsettings.CAMERA_WIDTH / 2), debug=False, is_usb_webcam=True, period_s=0.025): # Our video stream # If its not a usb webcam then get pi camera if not is_usb_webcam: self.vs = PiVideoStream(resolution=(cvsettings.CAMERA_WIDTH, cvsettings.CAMERA_HEIGHT)) # Camera cvsettings self.vs.camera.shutter_speed = cvsettings.SHUTTER self.vs.camera.exposure_mode = cvsettings.EXPOSURE_MODE self.vs.camera.exposure_compensation = cvsettings.EXPOSURE_COMPENSATION self.vs.camera.awb_gains = cvsettings.AWB_GAINS self.vs.camera.awb_mode = cvsettings.AWB_MODE self.vs.camera.saturation = cvsettings.SATURATION self.vs.camera.rotation = cvsettings.ROTATION self.vs.camera.video_stabilization = cvsettings.VIDEO_STABALIZATION self.vs.camera.iso = cvsettings.ISO self.vs.camera.brightness = cvsettings.BRIGHTNESS self.vs.camera.contrast = cvsettings.CONTRAST # Else get the usb camera else: self.vs = WebcamVideoStream(src=0) self.vs.stream.set(cv2.CAP_PROP_FRAME_WIDTH, cvsettings.CAMERA_WIDTH) self.vs.stream.set(cv2.CAP_PROP_FRAME_HEIGHT, cvsettings.CAMERA_HEIGHT) # Has camera started self.camera_started = False self.start_camera() # Starts our camera # To calculate our error in positioning self.center = center # To determine if we actually detected lane or not self.detected_lane = False # debug mode on? (to display processed images) self.debug = debug # Time interval between in update (in ms) # FPS = 1/period_s self.period_s = period_s # Starting time self.start_time = time.time() # Mouse event handler for get_hsv def on_mouse(self, event, x, y, flag, param): if event == cv2.EVENT_LBUTTONDBLCLK: # Circle to indicate hsv location, and update frame cv2.circle(self.img_debug, (x, y), 3, (0, 0, 255)) cv2.imshow('hsv_extractor', self.img_debug) # Print values values = self.hsv_frame[y, x] print('H:', values[0], '\tS:', values[1], '\tV:', values[2]) def get_hsv(self): cv2.namedWindow('hsv_extractor') while True: self.grab_frame() # Bottom ROI cv2.rectangle(self.img_debug, (0, cvsettings.HEIGHT_PADDING_BOTTOM-2), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_BOTTOM + cvsettings.IMG_ROI_HEIGHT + 2), (0, 250, 0), 2) # Top ROI cv2.rectangle(self.img_debug, (0, cvsettings.HEIGHT_PADDING_TOP-2), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_TOP + cvsettings.IMG_ROI_HEIGHT + 2), (0, 250, 0), 2) # Object cv2.rectangle(self.img_debug, (0, cvsettings.OBJECT_HEIGHT_PADDING), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_TOP - cvsettings.OBJECT_HEIGHT_PADDING), (238, 130, 238), 2) self.hsv_frame = cv2.cvtColor(self.img, cv2.COLOR_BGR2HSV) # Mouse handler cv2.setMouseCallback('hsv_extractor', self.on_mouse, 0) cv2.imshow('hsv_extractor', self.img_debug) key = cv2.waitKey(0) & 0xFF if key == ord('q'): break self.stop_camera() cv2.destroyAllWindows() # Starts camera (needs to be called before run) def start_camera(self): self.camera_started = True self.vs.start() time.sleep(2.0) # Wait for camera to cool def stop_camera(self): self.camera_started = False self.vs.stop() # Grabs frame from camera def grab_frame(self): # Starts camera if it hasn't been started if not self.camera_started: self.start_camera() self.img = self.vs.read() self.img_debug = self.img.copy() # Normalizes our image def normalize_img(self): # Crop img and convert to hsv self.img_roi_bottom = np.copy(self.img[cvsettings.HEIGHT_PADDING_BOTTOM:int(cvsettings.HEIGHT_PADDING_BOTTOM + cvsettings.IMG_ROI_HEIGHT), :]) self.img_roi_top = np.copy(self.img[cvsettings.HEIGHT_PADDING_TOP:int(cvsettings.HEIGHT_PADDING_TOP + cvsettings.IMG_ROI_HEIGHT), :]) self.img_roi_bottom_hsv = cv2.cvtColor(self.img_roi_bottom, cv2.COLOR_BGR2HSV).copy() self.img_roi_top_hsv = cv2.cvtColor(self.img_roi_top, cv2.COLOR_BGR2HSV).copy() # Get our ROI's shape # Doesn't matter because both of them are the same shape self.roi_height, self.roi_width, self.roi_channels = self.img_roi_bottom.shape # Smooth image and convert to bianry image (threshold) # Filter out colors that are not within the RANGE value def filter_smooth_thres(self, RANGE, color): for (lower, upper) in RANGE: lower = np.array(lower, dtype='uint8') upper = np.array(upper, dtype='uint8') mask_bottom = cv2.inRange(self.img_roi_bottom_hsv, lower, upper) mask_top = cv2.inRange(self.img_roi_top_hsv, lower, upper) blurred_bottom = cv2.medianBlur(mask_bottom, 5) blurred_top = cv2.medianBlur(mask_top, 5) # Morphological transformation kernel = np.ones((2, 2), np.uint8) smoothen_bottom = blurred_bottom #cv2.morphologyEx(blurred, cv2.MORPH_OPEN, kernel, iterations=5) smoothen_top = blurred_top # cv2.morphologyEx(blurred, cv2.MORPH_OPEN, kernel, iterations=5) """ if self.debug: cv2.imshow('mask bottom ' + color, mask_bottom) cv2.imshow('blurred bottom' + color, blurred_bottom) cv2.imshow('mask top ' + color, mask_top) cv2.imshow('blurred top' + color, blurred_top) """ return smoothen_bottom, smoothen_top # Gets metadata from our contours def get_contour_metadata(self): # Metadata (x,y,w,h)for our ROI contour_metadata = {} for cur_img in [self.thres_yellow_bottom, self.thres_yellow_top, self.thres_blue_bottom, self.thres_blue_top]: key = '' # Blue is left lane, Yellow is right lane if cur_img is self.thres_yellow_bottom: key = 'right_bottom' elif cur_img is self.thres_yellow_top: key = 'right_top' elif cur_img is self.thres_blue_bottom: key = 'left_bottom' elif cur_img is self.thres_blue_top: key = 'left_top' _, contours, hierarchy = cv2.findContours(cur_img.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cur_height, cur_width = cur_img.shape # Get index of largest contour try: areas = [cv2.contourArea(c) for c in contours] max_index = np.argmax(areas) cnt = contours[max_index] # Metadata of contour x, y, w, h = cv2.boundingRect(cnt) # Normalize it to the original picture x += int(cvsettings.WIDTH_PADDING + w / 2) if 'top' in key: y += int(cvsettings.HEIGHT_PADDING_TOP +h /2) else: y += int(cvsettings.HEIGHT_PADDING_BOTTOM + h / 2) contour_metadata[key] = (x, y) self.detected_lane = True # If it throws an error then it doesn't have a ROI # Means we're too far off to the left or right except: # Blue is left lane, Yellow is right lane x = int(cvsettings.WIDTH_PADDING) - cvsettings.CAMERA_WIDTH if 'bottom' in key: y = int(cur_height / 2) + int(cvsettings.HEIGHT_PADDING_BOTTOM + cur_height / 2) else: y = int(cur_height / 2) + int(cvsettings.HEIGHT_PADDING_TOP + cur_height / 2) if 'right' in key: x = int(cur_width)*2 contour_metadata[key] = (x, y) self.detected_lane = False return contour_metadata # Gets the centered coord of the detected lines def get_centered_coord(self): bottom_centered_coord = None top_centered_coord = None left_xy_bottom = self.contour_metadata['left_bottom'] right_xy_bottom = self.contour_metadata['right_bottom'] left_xy_top = self.contour_metadata['left_top'] right_xy_top = self.contour_metadata['right_top'] bottom_xy = (left_xy_bottom[0] + right_xy_bottom[0], left_xy_bottom[1] + right_xy_bottom[1]) bottom_centered_coord = (int(bottom_xy[0] / 2), int(bottom_xy[1] / 2)) top_xy = (left_xy_top[0] + right_xy_top[0], left_xy_top[1] + right_xy_top[1]) top_centered_coord = (int(top_xy[0] / 2), int(top_xy[1] / 2)) # Left can't be greater than right and vice-versa if left_xy_top > right_xy_top: top_centered_coord = (0, top_centered_coord[1]) elif right_xy_top < left_xy_top: top_centered_corrd = (cvsettings.CAMERA_WIDTH, top_centered_coord[1]) if left_xy_bottom > right_xy_bottom: bottom_centered_coord = (0, bottom_centered_coord[1]) elif right_xy_bottom < left_xy_bottom: bottom_centered_coord = (cvsettings.CAMERA_WIDTH, top_centered_coord[1]) return bottom_centered_coord, top_centered_coord # Gets the error of the centered coordinates (x) # Also normlizes their values def get_errors(self): top_error = (float(self.center_coord_top[0]) - float(self.center))/float(cvsettings.CAMERA_WIDTH + cvsettings.WIDTH_PADDING) bottom_error = (float(self.center_coord_bottom[0]) - float(self.center))/float(cvsettings.CAMERA_WIDTH + cvsettings.WIDTH_PADDING) relative_error = (float(self.center_coord_top[0]) - float(self.center_coord_bottom[0]))/float(cvsettings.CAMERA_WIDTH + cvsettings.WIDTH_PADDING) return (top_error + relative_error + bottom_error)/3.0 # Object avoidance def where_object_be(self): # We only want to detect objects in our path: center of top region and bottom region # So to save processing speed, we'll only threshold from center of top region to center of bottom region left_x = cvsettings.WIDTH_PADDING right_x = cvsettings.CAMERA_WIDTH # Image region with objects img_roi_object = self.img[cvsettings.OBJECT_HEIGHT_PADDING : int(cvsettings.HEIGHT_PADDING_TOP - cvsettings.OBJECT_HEIGHT_PADDING), left_x:right_x] img_roi_object_hsv = cv2.cvtColor(img_roi_object, cv2.COLOR_BGR2HSV).copy() # Filtering color and blurring for (lower, upper) in cvsettings.OBJECT_HSV_RANGE: lower = np.array(lower, dtype='uint8') upper = np.array(upper, dtype='uint8') mask_object = cv2.inRange(img_roi_object_hsv, lower, upper) blurred_object = cv2.medianBlur(mask_object, 25) # Finding position of object (if its there) _, contours, hierarchy = cv2.findContours(blurred_object.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) left_x = self.contour_metadata['left_top'][0] right_x = self.contour_metadata['right_top'][0] for c in contours: areas = cv2.contourArea(c) # Object needs to be larger than a certain area if areas > cvsettings.OBJECT_AREA: x, y, w, h = cv2.boundingRect(c) y += int(cvsettings.OBJECT_HEIGHT_PADDING + h / 2) # Confusing part - this finds the object and makes it think that # it is also a line to avoid bumping into it # It +w and -w to find which line its closest to and then set # the opposite as to be the new left/right lane # e.g. line is closest to left lane (x-w), so left lane new x is # (x+w) distance_to_left = abs(x - left_x) distance_to_right = abs(x+w - right_x) # Make object's left most area the middle of right lane if distance_to_left > distance_to_right: self.contour_metadata['right_top'] = (x, self.contour_metadata['right_top'][1]) # Make object's right most area the middle of left lane elif distance_to_right > distance_to_right: self.contour_metadata['left_top'] = (x+w, self.contour_metadata['left_top'][1]) if self.debug: cv2.circle(self.img_debug, (x+(w/2), y+(h/2)), 5, (240, 32, 160), 2) if self.debug: cv2.imshow('Blurred object', blurred_object) # Where are we relative to our lane def where_lane_be(self): # Running once every period_ms while float(time.time() - self.start_time) < self.period_s: pass # Update time instance self.start_time = time.time() # Camera grab frame and normalize it self.grab_frame() self.normalize_img() # Filter out them colors self.thres_blue_bottom, self.thres_blue_top = self.filter_smooth_thres(cvsettings.BLUE_HSV_RANGE, 'blue') self.thres_yellow_bottom, self.thres_yellow_top = self.filter_smooth_thres(cvsettings.YELLOW_HSV_RANGE, 'yellow') # Get contour meta data self.contour_metadata = self.get_contour_metadata() # Finds objects and (and corrects lane position) # this overwrite contour_metadata #self.where_object_be() # Find the center of the lanes (bottom and top) [we wanna be in between] self.center_coord_bottom, self.center_coord_top = self.get_centered_coord() # Gets relative error between top center and bottom center self.relative_error = self.get_errors() if self.debug: # Drawing locations blue_top_xy = self.contour_metadata['left_top'] blue_bottom_xy = self.contour_metadata['left_bottom'] yellow_top_xy = self.contour_metadata['right_top'] yellow_bottom_xy = self.contour_metadata['right_bottom'] # Circles to indicate lanes cv2.circle(self.img_debug, blue_top_xy, 5, (255, 0, 0), 2) cv2.circle(self.img_debug, blue_bottom_xy, 5, (255, 0, 0), 2) cv2.circle(self.img_debug, yellow_top_xy, 5, (0, 255, 255), 2) cv2.circle(self.img_debug, yellow_bottom_xy, 5, (0, 255, 255), 2) cv2.circle(self.img_debug, self.center_coord_bottom, 5, (0, 255, 0), 3) cv2.circle(self.img_debug, self.center_coord_top, 5, (0, 255, 0), 3) # ROI for object detection cv2.rectangle(self.img_debug, (0, cvsettings.OBJECT_HEIGHT_PADDING), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_TOP - cvsettings.OBJECT_HEIGHT_PADDING), (238, 130, 238), 2) # Displaying image cv2.imshow('img', self.img_debug) #cv2.imshow('img_roi top', self.img_roi_top) #cv2.imshow('img_roi bottom', self.img_roi_bottom) #cv2.imshow('img_hsv', self.img_roi_hsv) cv2.imshow('thres_blue_bottom', self.thres_blue_bottom) cv2.imshow('thres_blue_top', self.thres_blue_top) cv2.imshow('thres_yellow_bottom', self.thres_yellow_bottom) cv2.imshow('thres_yellow_top', self.thres_yellow_top) key = cv2.waitKey(0) & 0xFF # Change 1 to 0 to pause between frames # Use this to calculate fps def calculate_fps(self, frames_no=100): fps = FPS().start() # Don't wanna display window if self.debug: self.debug = not self.debug for i in range(0, frames_no): self.where_lane_be() fps.update() fps.stop() # Don't wanna display window if not self.debug: self.debug = not self.debug print('Time taken: {:.2f}'.format(fps.elapsed())) print('~ FPS : {:.2f}'.format(fps.fps())) # Use this to save images to a location def save_images(self, dirname='dump'): import os img_no = 1 # Makes the directory if not os.path.exists('./' + dirname): os.mkdir(dirname) while True: self.grab_frame() if self.debug: cv2.imshow('frame', self.img) k = cv2.waitKey(1) & 0xFF if k == ord('s'): cv2.imwrite(os.path.join(dirname, 'dump_' + str(img_no) + '.jpg'), self.img) img_no += 1 elif k == ord('q'): break cv2.destroyAllWindows() # Destructor def __del__(self): self.vs.stop() cv2.destroyAllWindows()
class Stereo_Vision: """Class for obtaining and analyzing depth maps""" def __init__(self, cam_L_src, cam_R_src, display_frames=True, threshold=110): # initialize camera feed threads self.capL = WebcamVideoStream(src=cam_L_src).start() time.sleep(0.5) self.capR = WebcamVideoStream(src=cam_R_src).start() self.stop = False self.display_frames = display_frames # initialize windows if self.display_frames == True: cv2.namedWindow('Depth Map') cv2.namedWindow('Threshold') cv2.namedWindow('Shapes') # import calibration matrices self.undistMapL = np.load('calibration/undistortion_map_left.npy') self.undistMapR = np.load('calibration/undistortion_map_right.npy') self.rectMapL = np.load('calibration/rectification_map_left.npy') self.rectMapR = np.load('calibration/rectification_map_right.npy') # initialize blank frames self.rectL = np.zeros((640, 480, 3), np.uint8) self.rectR = np.zeros((640, 480, 3), np.uint8) self.quadrant_near_object = np.zeros((3, 3), dtype=bool) self.threshold = threshold self.exec_time_sum = 0 self.frame_counter = 0 self.fps = 0 self.no_object_left_column = False self.no_object_mid_column = False self.no_object_right_column = False self.no_object_bottom_row = False self.no_object_mid_row = False self.no_object_top_row = False def start(self): self.vision_thread = Thread(target=self.start_stereo) self.vision_thread.start() def stop_vision(self): self.stop = True def get_quadrants(self): return self.quadrant_near_object def start_stereo(self): while (self.stop != True): self.start_time = time.time() self.frameL = self.capL.read() self.frameR = self.capR.read() # remap cameras to remove distortion self.rectL = cv2.remap(self.frameL, self.undistMapL, self.rectMapL, cv2.INTER_LINEAR) self.rectR = cv2.remap(self.frameR, self.undistMapR, self.rectMapR, cv2.INTER_LINEAR) # convert rectified from RGB to 8 bit grayscale self.grayRectL = cv2.cvtColor(self.rectL, cv2.COLOR_BGR2GRAY) self.grayRectR = cv2.cvtColor(self.rectR, cv2.COLOR_BGR2GRAY) self.grayFrameL = cv2.cvtColor(self.frameL, cv2.COLOR_BGR2GRAY) self.grayFrameR = cv2.cvtColor(self.frameR, cv2.COLOR_BGR2GRAY) # create depth map self.object_left_column = True self.object_mid_column = True self.object_right_column = True self.object_top_row = True self.object_mid_row = True self.object_bottom_row = True self.stereo = cv2.StereoBM_create(numDisparities=0, blockSize=13) self.disparity = self.stereo.compute(self.grayRectL, self.grayRectR).astype(np.float32) self.disparity = cv2.normalize(self.disparity, self.disparity, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC1) # blur depth map to filter high frequency noise self.disparity_blur = cv2.medianBlur(self.disparity, 13) #apply 2 pixel border, helps keep contours continuous at extreme edges of image self.disparity_blur = cv2.copyMakeBorder(self.disparity_blur, top=2, bottom=2, right=2, left=2, borderType=cv2.BORDER_CONSTANT, value=0) # threshold depth map self.disparity_thresh_imm = cv2.threshold(self.disparity_blur, self.threshold, 255, cv2.THRESH_BINARY)[1] self.disparity_edge = cv2.Canny(self.disparity_thresh_imm, 100, 200) # contour finding self.contours = cv2.findContours(self.disparity_edge, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[1] self.disparity_contours = np.zeros((480, 640, 3), np.uint8) for self.contour_index in self.contours: #draw bounding rectangle around each contour self.rect = cv2.minAreaRect(self.contour_index) self.box = cv2.boxPoints(self.rect) self.box = np.int0(self.box) #calculate area of each box self.box_area = abs(self.box[2][0] - self.box[0][0]) * abs(self.box[2][1] - self.box[0][1]) self.col = -1 self.row = -1 if self.box_area > 1000: #pixels^2 cv2.drawContours(self.disparity_contours, [self.box], 0, (0, 255, 0), 2) # draw green box # determine which quadrants the rectangle occupies for corner_index in range(0, 3): self.col = self.box[corner_index][0] / 213 # x coordinates self.row = self.box[corner_index][1] / 160 # y coordinates if self.row > 2: self.row = 2 if self.col > 2: self.col = 2 if self.col != -1 and self.row != -1: self.quadrant_near_object[self.row][self.col] = True #Boolean logic to set flags for main program if (self.quadrant_near_object[0][0] == False and self.quadrant_near_object[1][0] == False or self.quadrant_near_object[2][0] == False): self.no_object_left_column = True else: self.no_object_left_column = False if (self.quadrant_near_object[0][1] == False and self.quadrant_near_object[1][1] == False and self.quadrant_near_object[2][1] == False): self.no_object_mid_column = True else: self.no_object_mid_column = False if (self.quadrant_near_object[0][2] == False and self.quadrant_near_object[1][2] == False and self.quadrant_near_object[2][2] == False): self.no_object_right_column = True else: self.no_object_right_column = False if (self.quadrant_near_object[0][0] == False and self.quadrant_near_object[0][1] == False and self.quadrant_near_object[0][2] == False): self.no_object_top_row = True else: self.no_object_top_row = False if (self.quadrant_near_object[1][0] == False and self.quadrant_near_object[1][1] == False and self.quadrant_near_object[1][2] == False): self.no_object_mid_row = True else: self.no_object_mid_row = False if (self.quadrant_near_object[2][0] == False and self.quadrant_near_object[2][1] == False and self.quadrant_near_object[2][2] == False): self.no_object_bottom_row = True else: self.no_object_bottom_row = False #FPS calculations self.end_time = time.time() self.exec_time = self.end_time - self.start_time self.exec_time_sum += self.exec_time self.frame_counter += 1 self.fps = 1.0 / self.exec_time #draw edges in pink cv2.drawContours(self.disparity_contours, self.contours, -1, (180, 105, 255), -1) cv2.line(self.disparity_contours, (0,160), (640,160), (255,0,0)) cv2.line(self.disparity_contours, (0,320), (640,320), (255,0,0)) cv2.line(self.disparity_contours, (213,0), (213,480), (255,0,0)) cv2.line(self.disparity_contours, (426,0), (426,480), (255,0,0)) if self.display_frames == True: cv2.imshow('Threshold', self.disparity_edge) cv2.imshow('Depth Map', self.disparity) cv2.imshow('Shapes', self.disparity_contours) if cv2.waitKey(1) & 0xFF == ord('q'): self.capL.stop() self.capR.stop() break self.capL.stop() self.capR.stop() cv2.destroyAllWindows() def save_frames(self, filename_index): cv2.imwrite("Images/DepthMap" + str(filename_index) + ".jpg", self.disparity) cv2.imwrite("Images/DepthMapBlur" + str(filename_index) + ".jpg", self.disparity_blur) cv2.imwrite("Images/Contours_" + str(filename_index) + ".jpg", self.disparity_contours) cv2.imwrite("Images/LeftCam" + str(filename_index) + ".jpg", self.frameL) cv2.imwrite("Images/RightCam" + str(filename_index) + ".jpg", self.frameR)
if avg is None: avg = gray.copy().astype("float") continue cv2.accumulateWeighted(gray, avg, 0.1) frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(avg)) thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1] thresh = cv2.dilate(thresh, None, iterations=2) _, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) for c in contours: if cv2.contourArea(c) < 4000: print("Tiny") continue (x, y, w, h) = cv2.boundingRect(c) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) M = cv2.moments(c) cX = int(M["m10"] / M["m00"]) cY = int(M["m01"] / M["m00"]) cv2.circle(frame, (cX, cY), 7, (0, 255, 0), -1) cv2.imshow("Diff", frame) key = cv2.waitKey(1) & 0xFF if key == 27: break cv2.destroyAllWindows() vs.stop()
if key == ord('r'): #go to recording component if record == False: record = True print("Starting Recording") rec_time = timer() elif record == True: record = False elif key == ord('q'): break if record == True: tmem = (numframe * h * w)/(1024**2) # approxamate total memory in megabytes mall = 2000 div = int((numframe * mall)/tmem) num_files = math.ceil(tmem / mall) for n in range (num_files): wb.saveFile(fnm_save + '_c1-%04d.tif' % n , c1[n*(div):(n+1)*(div)]) wb.saveFile(fnm_save + '_c2-%04d.tif' % n , c2[n*(div):(n+1)*(div)]) print("Shutting down") tlog.close() vs1.stop() vs2.stop() s.close() cv2.destroyAllWindows() for i in range(5): cv2.waitKey(1)
end_time = time.time() exec_time = end_time - start_time exec_time_sum += exec_time i += 1 fps = 1.0/exec_time #cv2.imshow(WINDOW_L, frameL) #cv2.imshow(WINDOW_R, frameR) #cv2.imshow(WINDOW_L1, rectL) #cv2.imshow(WINDOW_R1, rectR) #cv2.imshow('Threshold', disparity_thresh_imm) cv2.imshow('Depth Map', disparity) #cv2.imshow('Shapes', disparity_contours) #cv2.imshow('Test', disparity_gaussian) if cv2.waitKey(1) & 0xFF == ord('q'): capL.stop() capR.stop() break capL.stop() capR.stop() cv2.destroyAllWindows() exec_time_avg = exec_time_sum/i fps_avg = 1.0/exec_time_avg print "Average Execution Time/Frame : %s" %exec_time_avg print "Average FPS : %s" %fps_avg