def show_bboxes(folder): with open(lfw_pickle, 'rb') as file: data = pickle.load(file) samples = data['samples'] for sample in tqdm(samples): full_path = sample['full_path'] bounding_boxes = sample['bounding_boxes'] landmarks = sample['landmarks'] img = cv.imread(full_path) img = draw_bboxes(img, bounding_boxes, landmarks) filename = os.path.basename(full_path) filename = os.path.join(folder, filename) cv.imwrite(filename, img)
def face_detect(): start = time.time() ensure_folder(STATIC_DIR) ensure_folder(UPLOAD_DIR) file = request.files['file'] fn = secure_filename(file.filename) full_path = os.path.join(UPLOAD_DIR, fn) file.save(full_path) # resize(full_path) print('full_path: ' + full_path) img = Image.open(full_path).convert('RGB') bboxes, landmarks = detect_faces(img) num_faces = len(bboxes) if num_faces > 0: img = cv.imread(full_path) draw_bboxes(img, bboxes, landmarks) cv.imwrite(full_path, img) elapsed = time.time() - start return num_faces, float(elapsed), str(fn), bboxes, landmarks
def callback_button1(self): """Running button""" if not self.fa.is_loaded: self.set_text('Network is not loaded') return name = tk.filedialog.askopenfilename() # open dialog if path.exists(name): self.img_file_path = name self.load_img() # load image img = cv2.imread(name) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) bboxes = self.fa.FD.detect_faces(img, conf_th=0.9, scales=[1]) # face detection print("{} faces are detected".format(len(bboxes))) img_result = draw_bboxes(img, bboxes) # draw face boxes pts = self.fa.FA.face_alignment(img, bboxes) # face alignment print("Face Alignment is done") img_result = draw_pts(img_result, pts) # draw landmarks plt.figure(1) # show result plt.axis('off') plt.imshow(img_result) plt.show()
imgs = torch.zeros([10, 3, im_size, im_size], dtype=torch.float) ensure_folder('images') for i in range(10): sample = samples[i] fullpath = sample['fullpath'] raw = cv.imread(fullpath) raw = cv.resize(raw, (im_size, im_size)) img = raw[..., ::-1] # RGB img = transforms.ToPILImage()(img) img = transformer(img) imgs[i] = img cv.imwrite('images/{}_img.jpg'.format(i), raw) raw = draw_bboxes(raw, sample['pts']) cv.imwrite('images/{}_true.jpg'.format(i), raw) with torch.no_grad(): outputs = model(imgs) for i in range(10): output = outputs[i].cpu().numpy() output = np.reshape(output, (4, 1, 2)) output = output * im_size print('output: ' + str(output)) print('output.shape: ' + str(output.shape)) img = cv.imread('images/{}_img.jpg'.format(i)) img = draw_bboxes(img, output) cv.imwrite('images/{}_out.jpg'.format(i), img)
] imgs = torch.zeros([4, 3, im_size, im_size], dtype=torch.float) ensure_folder('images') for i in range(len(file_list)): file = file_list[i] fullpath = os.path.join('images', file) print(fullpath) raw = cv.imread(fullpath) raw = cv.resize(raw, (im_size, im_size)) img = raw[..., ::-1] # RGB img = transforms.ToPILImage()(img) img = transformer(img) imgs[i] = img cv.imwrite('images/img_bld_{}.jpg'.format(i), raw) with torch.no_grad(): outputs = model(imgs) for i in range(len(file_list)): output = outputs[i].cpu().numpy() output = np.reshape(output, (4, 1, 2)) output = output * im_size print('output: ' + str(output)) print('output.shape: ' + str(output.shape)) img = cv.imread('images/img_bld_{}.jpg'.format(i)) img = draw_bboxes(img, output) cv.imwrite('images/out_bld_{}.jpg'.format(i), img)
dc2.start() dc3.start() dc4.start() # Wait to process every frame: while queue_results.qsize() < NUM_OF_FRAMES: time.sleep(1) print(time.time() - st, queue_results.qsize()) # Save results dict_results = {} while (not queue_results.empty()): idx, img_orig, list_res = queue_results.get() dict_results[idx] = list_res newImg = draw_bboxes(img_orig, list_res) cv2.imwrite(f'/home/dobreff/videos/outputs/test/resize{idx}.jpg', newImg) print(f'Item {idx} saved!') with open('/home/dobreff/videos/outputs/test/test_resize.pickle', 'wb') as handle: pickle.dump(dict_results, handle, protocol=pickle.HIGHEST_PROTOCOL) # # Mivel maxra fel van töltve a Queue, addig pörgök a ciklusban amíg van benne elem: # while (not queue_frames.empty()) or (not queue_results.empty()): # # Grab result image # idx, img_orig, list_res = queue_results.get() # newImg = draw_bboxes(img_orig, list_res) # cv2.imwrite(f'/home/dobreff/videos/outputs/{idx}.jpg', newImg) # print(f'Item {idx} saved!')
def output_check_result(save_path, xml_path, img_path, recog_path, recognition_xml): ''' 将含有问题算式的图片输出出来 1.标注错误 2.版面分析错误 :param save_path: 保存输出结果的地址 :return: ''' all_img = set_xml_data(xml_path, img_path, recog_path, recognition_xml) for i, img_result in tqdm(enumerate(all_img)): img_result.row_connect() column_pairs = img_result.column_connect() img_result.graph_to_forest() if img_result.problem_label: save_path1 = os.path.join(save_path, 'problem') if not os.path.exists(save_path1): os.mkdir(save_path1) img = img_result.img img, x_pro, y_pro = image_size_normal(img) img2 = img.copy() draw_bboxes(img, img_result.problem_label, x_pro, y_pro) img = draw_result(img, img_result.problem_label, x_pro, y_pro) img.save( os.path.join(save_path1, img_result.img_path.split('/')[-1])) draw_bboxes(img2, img_result.print_word + img_result.hand_word, x_pro, y_pro) draw_pair(img_result.print_hand_pair, img_result.print_word, img_result.hand_word, img2, (255, 0, 0), x_pro, y_pro) draw_pair(img_result.bracket_pair, img_result.merge, img_result.print_not_pair, img2, (0, 0, 255), x_pro, y_pro) # draw_column_pair(column_pairs,img_result.all_after_row_connect,img2,x_pro, y_pro) img2 = draw_result(img2, [], x_pro, y_pro) img2.save( os.path.join( save_path1, img_result.img_path.split('/')[-1].replace('.', '_.'))) if (img_result.problem_label + img_result.error_label): save_path2 = os.path.join(save_path, 'problem_error') if not os.path.exists(save_path2): os.mkdir(save_path2) img = img_result.img img, x_pro, y_pro = image_size_normal(img) img2 = img.copy() draw_bboxes(img, img_result.problem_label + img_result.error_label, x_pro, y_pro) img = draw_result( img, img_result.problem_label + img_result.error_label, x_pro, y_pro) img.save( os.path.join(save_path2, img_result.img_path.split('/')[-1])) draw_bboxes(img2, img_result.print_word + img_result.hand_word, x_pro, y_pro) draw_pair(img_result.print_hand_pair, img_result.print_word, img_result.hand_word, img2, (255, 0, 0), x_pro, y_pro) draw_pair(img_result.bracket_pair, img_result.merge, img_result.print_not_pair, img2, (0, 0, 255), x_pro, y_pro) # draw_column_pair(column_pairs,img_result.all_after_row_connect,img2,x_pro, y_pro) img2 = draw_result(img2, [], x_pro, y_pro) img2.save( os.path.join( save_path2, img_result.img_path.split('/')[-1].replace('.', '_.')))
def process_img(vd, img_file, out_dir='output_images', process_pool=None): img = cv2.imread(img_file) t1 = time.time() bounding_boxes, heatmap, windows = vd.detect_vehicles( img, process_pool=process_pool) t2 = time.time() plt.figure(figsize=(20, 15)) rows = np.ceil((len(windows) + 2) / 2) all_bboxes = [] i = 1 for scale, cells_per_step, bboxes in windows: i += 1 plt.subplot(rows, 2, i) w_tot = len(bboxes) w_pos = len( list(filter(lambda bbox: bbox[1] >= vd.min_confidence, bboxes))) w_rej = len( list( filter( lambda bbox: bbox[1] > 0 and bbox[1] < vd.min_confidence, bboxes))) box_text = 'Scale: {}, Cells per Step: {}, Windows (Total/Positive/Rejected): {}/{}/{}'.format( scale, cells_per_step, w_tot, w_pos, w_rej) plt.title(box_text) box_img = draw_windows(np.copy(img), bboxes, min_confidence=vd.min_confidence, lines_thick=(2, 3, 2)) plt.imshow(cv2.cvtColor(box_img, cv2.COLOR_BGR2RGB)) all_bboxes.extend(bboxes) plt.subplot(rows, 2, 1) plt.title('Original Image') plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) box_img = draw_windows(np.copy(img), all_bboxes, min_confidence=vd.min_confidence, lines_thick=(2, 3, 2)) plt.subplot(rows, 2, i + 1) w_tot = len(all_bboxes) w_pos = len( list(filter(lambda bbox: bbox[1] >= vd.min_confidence, all_bboxes))) w_rej = len( list( filter(lambda bbox: bbox[1] > 0 and bbox[1] < vd.min_confidence, all_bboxes))) box_text = 'Combined - Min Confidence: {}, Windows (Total/Positive/Rejected): {}/{}/{}'.format( vd.min_confidence, w_tot, w_pos, w_rej) plt.title(box_text) plt.imshow(cv2.cvtColor(box_img, cv2.COLOR_BGR2RGB)) plt.tight_layout() img_prefix = os.path.split(img_file)[-1].split('.')[0] plt.savefig(os.path.join(out_dir, img_prefix + '_window_search.jpg')) plt.figure(figsize=(20, 10)) plt.subplot(221) plt.title('Original Image') plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) plt.subplot(222) plt.title(box_text) plt.imshow(cv2.cvtColor(box_img, cv2.COLOR_BGR2RGB)) plt.subplot(223) plt.title('Heatmap') heatmap_o = vd._heatmap(img, windows, 0) plt.imshow(heatmap_o, cmap='hot') plt.subplot(224) heatmap_text = 'Heatmap - Min confidence: {}, Threshold: {}'.format( vd.min_confidence, vd.heat_threshold) plt.title(heatmap_text) plt.imshow(heatmap, cmap='hot') plt.tight_layout() plt.savefig(os.path.join(out_dir, img_prefix + '_heatmap.jpg')) plt.figure(figsize=(20, 10)) plt.subplot(221) plt.title('Original Image') plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) plt.subplot(222) plt.title(box_text) plt.imshow(cv2.cvtColor(box_img, cv2.COLOR_BGR2RGB)) plt.subplot(223) plt.title(heatmap_text) plt.imshow(heatmap, cmap='hot') labeled_img = draw_bboxes(np.copy(img), bounding_boxes, (250, 150, 55), 2, fill=True) plt.subplot(224) plt.title('Labeled Image') plt.imshow(cv2.cvtColor(labeled_img, cv2.COLOR_BGR2RGB)) plt.tight_layout() plt.savefig(os.path.join(out_dir, img_prefix + '_labeled.jpg')) return t2 - t1
transformer = data_transforms['valid'] test_image = 'images/ski.jpg' bgr_img = cv.imread(test_image) # B,G,R order bgr_img = cv.resize(bgr_img, (400, 300)) rgb_img = cv.cvtColor(bgr_img, cv.COLOR_BGR2RGB) h, w = rgb_img.shape[:2] x_test = torch.zeros((3, h, w), dtype=torch.float) img = transforms.ToPILImage()(rgb_img) img = transformer(img) x_test[:, :, :] = img with torch.no_grad(): pred = model([x_test])[0] boxes = pred['boxes'].cpu().numpy().tolist() labels = pred['labels'].cpu().numpy().tolist() scores = pred['scores'].cpu().numpy().tolist() keypoints = pred['keypoints'].cpu().numpy().tolist() # print('boxes.size(): ' + str(boxes.size())) # print('labels.size(): ' + str(labels.size())) # print('scores.size(): ' + str(scores.size())) # print('keypoints.size(): ' + str(keypoints.size())) img = draw_bboxes(bgr_img, boxes, scores, keypoints) cv.imshow('image', img) cv.waitKey(0)
# print("\nOutput size here: ", torch.nn.Sequential(*list(model.children())[:6]).to(device)(x).shape) # yolo = YOLOv3().to(device).eval() # inp = torch.randn(1, 3, 480, 640).to(device) # pred = yolo(inp) # print(pred.shape) # with torch.no_grad(): # for _ in trange(100): # pred = yolo(inp) # normalize = tv.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # root = "data/COCO/val2017/" # ann_file = "data/COCO/annotations/instances_val2017.json" # ds = tv.datasets.CocoDetection(root, ann_file) # img, lbl = ds[101] # pprint(len(ds)) # pprint(img.size) # pprint(type(lbl)) # pprint(lbl) root = "data/COCO/cleaned/val2017/" coco = COCODataset(root) for i in np.random.randint(0, len(coco), 25): img, (bboxes, cats) = coco[i] img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) img = draw_bboxes(img, bboxes, cats) cv2.imshow("Boxes", img) cv2.waitKey(0) cv2.destroyAllWindows()
def face_attributes(): start = time.time() ensure_folder(STATIC_DIR) ensure_folder(UPLOAD_DIR) file = request.files['file'] fn = secure_filename(file.filename) full_path = os.path.join(UPLOAD_DIR, fn) file.save(full_path) # resize(full_path) print('full_path: ' + full_path) img = Image.open(full_path).convert('RGB') bboxes, landmarks = detect_faces(img) result = None if len(bboxes) > 0: i = select_central_face((im_size, im_size), bboxes) bbox = bboxes[i] img = cv.imread(full_path) boxed = draw_bboxes(img, [bbox], [landmarks[i]]) cv.imwrite(full_path, boxed) img = crop_image(img, bbox) img = cv.resize(img, (im_size, im_size)) img = transforms.ToPILImage()(img) img = transformer(img) img = img.to(device) inputs = torch.zeros([1, 3, im_size, im_size], dtype=torch.float) inputs[0] = img with torch.no_grad(): reg_out, expression_out, gender_out, glasses_out, race_out = model( inputs) reg_out = reg_out.cpu().numpy() age_out = reg_out[0, 0] pitch_out = reg_out[0, 1] roll_out = reg_out[0, 2] yaw_out = reg_out[0, 3] beauty_out = reg_out[0, 4] age = int(age_out * 100) pitch = float('{0:.2f}'.format(pitch_out * 360 - 180)) roll = float('{0:.2f}'.format(roll_out * 360 - 180)) yaw = float('{0:.2f}'.format(yaw_out * 360 - 180)) beauty = float('{0:.2f}'.format(beauty_out * 100)) beauty_prob = float('{0:.4f}'.format(get_prob(beauty))) _, expression_out = expression_out.topk(1, 1, True, True) _, gender_out = gender_out.topk(1, 1, True, True) _, glasses_out = glasses_out.topk(1, 1, True, True) _, race_out = race_out.topk(1, 1, True, True) expression_out = expression_out.cpu().numpy() gender_out = gender_out.cpu().numpy() glasses_out = glasses_out.cpu().numpy() race_out = race_out.cpu().numpy() expression = idx2name(int(expression_out[0, 0]), 'expression') gender = idx2name(int(gender_out[0, 0]), 'gender') glasses = idx2name(int(glasses_out[0, 0]), 'glasses') race = idx2name(int(race_out[0, 0]), 'race') result = { 'age': age, 'pitch': pitch, 'roll': roll, 'yaw': yaw, 'beauty': beauty, 'beauty_prob': beauty_prob, 'expression': expression, 'gender': gender, 'glasses': glasses, 'race': race } elapsed = time.time() - start return result, float(elapsed), str(fn)
def main(): ''' input ''' # choose the input stream #captureSource = "video/video_116.mp4" #captureSource = "video/video_205.mp4" captureSource = "video/video_white.mp4" #captureSource = 0 # webcam cap = cv2.VideoCapture(captureSource) ''' trackers typology ''' # choose the tracker trackerName = "CSRT" # "MOSSE" | "KCF" | "CSRT" tm = TrackerManager(trackerName, maxFailures=20) ''' parameters ''' # try to change these parameters period = 1 # length of the period: only on the first frame of the period we detect objects (instead, we track them in every frame) maintainDetected = True # True if in transition frames, in case of overlapping bboxes, we want to keep those of the detector (False if we want to keep those of the tracker) frameWidth = 512 ''' some background subtractor with default params ''' # bgSubtractor = cv2.bgsegm.createBackgroundSubtractorMOG(history=200, nmixtures=5, backgroundRatio=0.7, noiseSigma=0) # bgSubtractor = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=16, detectShadows=True) # bgSubtractor = cv2.bgsegm.createBackgroundSubtractorGMG(initializationFrames=120, decisionThreshold=0.8) # bgSubtractor = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400.0, detectShadows=True) # bgSubtractor = CompositeBackgroundSubtractor(bgSubtractor1, bgSubtractor2, ...) ''' background subtractor ''' # define a background subtractor to be used for object detection #bgSubtractor = cv2.createBackgroundSubtractorMOG2(history=200, varThreshold=25, detectShadows=True) # good for video/video_116.mp4 bgSubtractor = cv2.createBackgroundSubtractorKNN( history=500, dist2Threshold=500.0, detectShadows=True) # good for video/video_205.mp4 # bgSubtractor = CompositeBackgroundSubtractor( # cv2.bgsegm.createBackgroundSubtractorMOG(history=600, nmixtures=3, backgroundRatio=0.2, noiseSigma=2.3), # cv2.createBackgroundSubtractorMOG2(history=200, varThreshold=14, detectShadows=True)) # good for video/video_white.mp4 ''' pipeline ''' # define the pipeline of functions to be executed on the b/w image, after the background subtraction and before getting bounding rects of contours kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7)) pipeline = ProcessPipeline() pipeline \ .add(cv2.medianBlur, ksize=5) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(fillHoles) \ .add(cv2.erode, kernel=kernel) \ .add(cv2.erode, kernel=kernel) \ ''' create object detector and face detector ''' od = ObjectDetector(bgSubtractor, pipeline) fd = FaceDetector() ''' auto-definition of output folder ''' outputDir = "output" if captureSource == 0: outputDir = os.path.join(outputDir, "webcam") else: outputDir = os.path.join(outputDir, captureSource[:captureSource.find(".")]) outputDir = os.path.join(outputDir, trackerName) print("Tracking video '%s' with tracker %s" % (captureSource, trackerName)) ''' cycle begins ''' frameNumber = 0 frames = 0 seconds = 0 eta = 0.05 totalTime = 0 show = True oneSkipOnly = False while True: ''' handle input: esc to quit; space to pause/start; "n" to go one frame at a time ''' k = cv2.waitKey(30) & 0xff if k == 27: break elif k == ord(' ') or oneSkipOnly: show = not show oneSkipOnly = False elif k == ord('n'): show = True oneSkipOnly = True if not show: if oneSkipOnly: show = False continue start = timer() ''' reading next frame ''' ret, frameOrig = cap.read() if not ret: break frameOrig = cv2.flip(frameOrig, 1) frame = imutils.resize(frameOrig, width=frameWidth) scale = frameOrig.shape[1] / frameWidth detectedObjects = [] if frameNumber % period == 0: ''' detection by background subtraction ''' detectedObjects = od.detect(frame) ''' objects tracking, faces detection''' ''' tracking ''' success, objects = tm.update(frame, detectedObjects, maintainDetected=maintainDetected) objIDs = tm.getIDs() tm.removeDeadTrackers() failed_objects = [obj for suc, obj in zip(success, objects) if not suc] failed_objIDs = [ objID for suc, objID in zip(success, objIDs) if not suc ] succ_objIDs = [objID for suc, objID in zip(success, objIDs) if suc] objects = [obj for suc, obj in zip(success, objects) if suc] ''' detection of faces ''' faces_bboxes = fd.detectFaces(frameOrig, objects, objIDs, scale=scale) ''' images merging and show ''' frameOrig = draw_bboxes(frameOrig, objects, (255, 0, 0), succ_objIDs, scale=scale) frameOrig = draw_bboxes(frameOrig, failed_objects, (0, 0, 255), failed_objIDs, scale=scale) frameOrig = draw_bboxes(frameOrig, faces_bboxes, (0, 255, 0)) frameOrig = cv2.resize(frameOrig, (640, 640)) cv2.imshow('frame', frameOrig) ''' some stats ''' frameNumber += 1 end = timer() frames = eta + (1 - eta) * frames seconds = eta * (end - start) + (1 - eta) * seconds print( "\rFrame: %04d FPS: %03d Active trackers: %02d Failed trackers: %02d " % (frameNumber, int( frames // seconds), len(objects), len(failed_objects)), end="") totalTime += end - start cap.release() cv2.destroyAllWindows() ''' save on disk ''' fd.dump(outputDir) avgFPS = str(round(frameNumber / totalTime, 2)) print("\rAverage FPS: " + avgFPS) with open(os.path.join(outputDir, "info.txt"), "w") as file: bgSubClsName = str(bgSubtractor.__class__) bgSubClsName = bgSubClsName[bgSubClsName.index("'") + 1:bgSubClsName.rindex("'")] file.write("tracker: " + trackerName + "\n") file.write("background subtractor: " + bgSubClsName + "\n") file.write("average FPS: " + avgFPS + "\n")
img = cv2.imread(IMAGE_PATH) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # load detectors. DET1 = MTCNN(device='cuda') DET2 = FaceBoxes(device='cuda') DET3 = TinyFace(device='cuda') DET4 = PyramidBox(device='cuda') DET5 = S3FD(device='cuda') DET6 = DSFD(device='cuda') # MTCNN returns bboxes and landmarks. t = time.time() bboxes, _ = DET1.detect_faces(img, conf_th=0.9, scales=[1]) print('MTCNN : %d faces in %.4f seconds.' % (len(bboxes), time.time() - t)) img1 = draw_bboxes(img, bboxes) sizes = [] for box in bboxes: sizes.append((box[2] - box[0]) * (box[3] - box[1])) print(min(sizes)) print(max(sizes)) # FaceBoxes returns bboxes. t = time.time() bboxes = DET2.detect_faces(img, conf_th=0.9, scales=[1]) print('FaceBoxes : %d faces in %.4f seconds.' % (len(bboxes), time.time() - t)) img2 = draw_bboxes(img, bboxes) sizes = [] for box in bboxes: sizes.append((box[2] - box[0]) * (box[3] - box[1])) print(min(sizes))
pngList = glob.glob(imagesPath + '/*.png') savedList = glob.glob(imagesWithBox + '/*.png') savedListSet = set() needHandleList = [] for savedListPath in savedList: path = savedListPath.replace(imagesWithBox, '') savedListSet.add(path) for pngListPath in pngList: path = pngListPath.replace(imagesPath, '') if not savedListSet.__contains__(path): needHandleList.append(pngListPath) print("png num: ", len(pngList), 'handled num: ', len(savedListSet), 'needHandle num: ', len(needHandleList)) for pngPath in needHandleList: print("handle", pngPath) img = cv2.imread(pngPath) img = img[regionY:regionY + regionH, regionX:regionX + regionW] img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) bboxes = tf.detect_faces(img, conf_th=0.9, scales=[1]) print(bboxes) img = draw_bboxes(img, bboxes, thickness=1) img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) savePath = pngPath.replace(imagesPath, imagesWithBox) print(savePath) cv2.imwrite(savePath, img) print("png num: ", len(pngList), 'handled num: ', len(savedListSet), 'needHandle num: ', len(needHandleList))
def draw_bboxes(self, query_path, bboxes, output_path): query_img = utils.read_image(query_path) boxes_img = utils.draw_bboxes(query_img, bboxes) cv2.imwrite(output_path, boxes_img)
def main(): ''' input ''' # choose the input stream #captureSource = 0 # webcam #captureSource = 'video/video_116.mp4' #captureSource = 'video/video_205.mp4' captureSource = 'video/video_white.mp4' cap = cv2.VideoCapture(captureSource) ''' some background subtractor with default params ''' # bgSubtractor = cv2.bgsegm.createBackgroundSubtractorMOG(history=200, nmixtures=5, backgroundRatio=0.7, noiseSigma=0) # bgSubtractor = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=16, detectShadows=True) # bgSubtractor = cv2.bgsegm.createBackgroundSubtractorGMG(initializationFrames=120, decisionThreshold=0.8) # bgSubtractor = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400.0, detectShadows=True) # bgSubtractor = CompositeBackgroundSubtractor(bgSubtractor1, bgSubtractor2, ...) ''' list of background subtractors ''' backgroundSubtractors = [ cv2.createBackgroundSubtractorMOG2( history=200, varThreshold=25, detectShadows=True), # good for video/video_116.mp4 cv2.createBackgroundSubtractorKNN( history=500, dist2Threshold=500.0, detectShadows=True), # good for video/video_205.mp4 CompositeBackgroundSubtractor( cv2.bgsegm.createBackgroundSubtractorMOG(history=600, nmixtures=3, backgroundRatio=0.2, noiseSigma=2.3), cv2.createBackgroundSubtractorMOG2( history=200, varThreshold=14, detectShadows=True)) # good for video/video_white.mp4 ] ''' pipeline steps applied after background subtraction ''' kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7)) pipeline = ProcessPipeline() pipeline \ .add(cv2.medianBlur, ksize=5) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(cv2.dilate, kernel=kernel) \ .add(fillHoles) \ .add(cv2.erode, kernel=kernel) \ .add(cv2.erode, kernel=kernel) ''' detectors creation and beginning of video analysis ''' detectors = [ ObjectDetector(bgSub, pipeline) for bgSub in backgroundSubtractors ] show = True oneSkipOnly = False while True: ''' handle input: esc to quit; space to pause/start; "n" to go one frame at a time ''' k = cv2.waitKey(30) & 0xff if k == 27: break elif k == ord(' ') or oneSkipOnly: show = not show oneSkipOnly = False elif k == ord('n'): show = True oneSkipOnly = True if not show: if oneSkipOnly: show = False continue ''' reading next frame ''' ret, frame = cap.read() if not ret: break frame = imutils.resize(frame, width=512) frame = cv2.flip(frame, 1) ''' detection ''' color = (255, 0, 0) # blue outputFrames = [ draw_bboxes(frame, detector.detect(frame), color) for detector in detectors ] ''' show frames ''' imgOutput = mergeImgs( [[*detector.pipeline.intermediateOutputsBGR, outputFrame] for detector, outputFrame in zip(detectors, outputFrames)]) imgOutput = cv2.resize(imgOutput, (1920, 1000)) cv2.imshow('frame', imgOutput) cap.release() cv2.destroyAllWindows()
if __name__ == '__main__': # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--image", help="path to the image file") ap.add_argument("-c", "--coords", help="comma seperated list of source points") args = vars(ap.parse_args()) # load the image and grab the source coordinates (i.e. the list of # of (x, y) points) # NOTE: using the 'eval' function is bad form, but for this example # let's just roll with it -- in future posts I'll show you how to # automatically determine the coordinates without pre-supplying them image = cv2.imread(args["image"]) pts = np.array(eval(args["coords"]), dtype="float32") # apply the four point tranform to obtain a "birds eye view" of # the image warped = four_point_transform(image, pts) pts = np.array(pts) pts = np.reshape(pts, (4, 1, 2)) image = draw_bboxes(image, pts) # show the original and warped images cv2.imshow("Original", image) cv2.imshow("Warped", warped) cv2.waitKey(0)
def process_frame(self, frame, process_pool): img = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) if self.detect_lanes: # Uses the undistored image img, _, warped_img = self.image_processor.process_image(img) bboxes, heatmap, windows = self.vehicle_detector.detect_vehicles( img, process_pool=process_pool) frame_out = np.copy(img) if self.debug else img # Labelled image frame_out = draw_bboxes(frame_out, bboxes, (250, 150, 55), 1, fill=True) frame_out_text = 'Frame Smoothing: {}, Min Confidence: {}, Threshold: {}'.format( self.vehicle_detector.smooth_frames, self.vehicle_detector.min_confidence, self.vehicle_detector.heat_threshold) self.write_text(frame_out, frame_out_text) self.write_text(frame_out, 'Detected Cars: {}'.format(len(bboxes)), pos=(30, frame_out.shape[0] - 30), font_color=(0, 250, 150)) if self.detect_lanes: _, polyfit, curvature, deviation, fail_code = self.lane_detector.detect_lanes( warped_img) fill_color = (0, 255, 0) if fail_code == 0 else (0, 255, 255) lane_img = self.lane_detector.draw_lanes(frame_out, polyfit, fill_color=fill_color) lane_img = self.image_processor.unwarp_image(lane_img) frame_out = cv2.addWeighted(frame_out, 1.0, lane_img, 1.0, 0) curvature_text = 'Left Curvature: {:.1f}, Right Curvature: {:.1f}'.format( curvature[0], curvature[1]) offset_text = 'Center Offset: {:.2f} m'.format(deviation) self.write_text(frame_out, curvature_text, pos=(30, 60)) self.write_text(frame_out, offset_text, pos=(30, 90)) frame_out = cv2.cvtColor(frame_out, cv2.COLOR_BGR2RGB) if self.debug: result = [] self.write_frame_count(frame_out) result.append(frame_out) # Unthresholded heatmap image heatmap_o = self.vehicle_detector._heatmap(img, windows, 0) heatmap_o = self.normalize_heatmap(heatmap_o) heatmap_o = np.dstack((heatmap_o, np.zeros_like(heatmap_o), np.zeros_like(heatmap_o))) self.write_frame_count(heatmap_o) result.append(heatmap_o) # Heatmap image heatmap = self.normalize_heatmap(heatmap) heatmap = np.dstack( (np.zeros_like(heatmap), np.zeros_like(heatmap), heatmap)) self.write_frame_count(heatmap) result.append(cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)) heatmap_img = cv2.addWeighted(img, 1, heatmap, 0.8, 0) result.append(cv2.cvtColor(heatmap_img, cv2.COLOR_BGR2RGB)) all_windows = [] # Windows search image for scale, cells_per_step, layer_windows in windows: all_windows.extend(layer_windows) layer_img = draw_windows( np.copy(img), layer_windows, min_confidence=self.vehicle_detector.min_confidence) w_tot = len(layer_windows) w_pos = len( list( filter( lambda bbox: bbox[1] >= self.vehicle_detector. min_confidence, layer_windows))) w_rej = len( list( filter( lambda bbox: bbox[1] > 0 and bbox[1] < self. vehicle_detector.min_confidence, layer_windows))) self.write_text( layer_img, 'Scale: {}, Cells per Steps: {}, Min Confidence: {}'. format(scale, cells_per_step, self.vehicle_detector.min_confidence)) layer_text = 'Windows (Total/Positive/Rejected): {}/{}/{}'.format( w_tot, w_pos, w_rej) self.write_text(layer_img, layer_text, pos=(30, layer_img.shape[0] - 30)) self.write_frame_count(layer_img) result.append(cv2.cvtColor(layer_img, cv2.COLOR_BGR2RGB)) # Combined scales image box_img = draw_windows( np.copy(img), all_windows, min_confidence=self.vehicle_detector.min_confidence) w_tot = len(all_windows) w_pos = len( list( filter( lambda bbox: bbox[1] >= self.vehicle_detector. min_confidence, all_windows))) w_rej = len( list( filter( lambda bbox: bbox[1] > 0 and bbox[1] < self. vehicle_detector.min_confidence, all_windows))) self.write_text( box_img, 'Min Confidence: {}'.format( self.vehicle_detector.min_confidence)) box_text = 'Windows (Total/Positive/Rejected): {}/{}/{}'.format( w_tot, w_pos, w_rej) self.write_text(box_img, box_text, pos=(30, layer_img.shape[0] - 30)) self.write_frame_count(box_img) result.append(cv2.cvtColor(box_img, cv2.COLOR_BGR2RGB)) else: result = frame_out return result